Added comments specifying what each assembly example is doing.

trilinos · Apr 20, 2022 · e09a38f · e09a38f
1 parent 48daa76
commit e09a38f
Show file tree

Hide file tree

Showing 10 changed files with 46 additions and 6 deletions.
diff --git a/packages/intrepid2/assembly-examples/GRADGRADStandardAssembly.hpp b/packages/intrepid2/assembly-examples/GRADGRADStandardAssembly.hpp
@@ -10,7 +10,11 @@
 
 #include "JacobianFlopEstimate.hpp"
 
-//! version that uses the classic, generic Intrepid2 paths;
+/** \file   GRADGRADStandardAssembly.hpp
+    \brief  Locally assembles a Poisson matrix -- an array of shape (C,F,F), with formulation (grad e_i, grad e_j), using standard Intrepid2 methods; these do not algorithmically exploit geometric structure.
+ */
+
+//! Version that uses the classic, generic Intrepid2 paths.
 template<class Scalar, class BasisFamily, class PointScalar, int spaceDim, typename DeviceType>
 Intrepid2::ScalarView<Scalar,DeviceType> performStandardQuadratureGRADGRAD(Intrepid2::CellGeometry<PointScalar, spaceDim, DeviceType> &geometry,
                                                                               const int &polyOrder, int worksetSize,

diff --git a/packages/intrepid2/assembly-examples/GRADGRADStructuredAssembly.hpp b/packages/intrepid2/assembly-examples/GRADGRADStructuredAssembly.hpp
@@ -10,6 +10,10 @@
 
 #include "JacobianFlopEstimate.hpp"
 
+/** \file   GRADGRADStructuredAssembly.hpp
+    \brief  Locally assembles a Poisson matrix -- an array of shape (C,F,F), with formulation (grad e_i, grad e_j), using "structured" Intrepid2 methods; these algorithmically exploit geometric structure as expressed in the provided CellGeometry.
+ */
+
 //! Version that takes advantage of new structured integration support, including sum factorization.
 template<class Scalar, class BasisFamily, class PointScalar, int spaceDim, typename DeviceType>
 Intrepid2::ScalarView<Scalar,DeviceType> performStructuredQuadratureGRADGRAD(Intrepid2::CellGeometry<PointScalar, spaceDim, DeviceType> &geometry, const int &polyOrder, const int &worksetSize,

diff --git a/packages/intrepid2/assembly-examples/H1StandardAssembly.hpp b/packages/intrepid2/assembly-examples/H1StandardAssembly.hpp
@@ -10,7 +10,11 @@
 
 #include "JacobianFlopEstimate.hpp"
 
-//! version that uses the classic, generic Intrepid2 paths;
+/** \file   H1StandardAssembly.hpp
+    \brief  Locally assembles a matrix with the H^1 natural norm -- an array of shape (C,F,F), with formulation (e_i, e_j) + (grad e_i, grad e_j), using standard Intrepid2 methods; these do not algorithmically exploit geometric structure.
+ */
+
+//! Version that uses the classic, generic Intrepid2 paths.
 template<class Scalar, class BasisFamily, class PointScalar, int spaceDim, typename DeviceType>
 Intrepid2::ScalarView<Scalar,DeviceType> performStandardQuadratureH1(Intrepid2::CellGeometry<PointScalar, spaceDim, DeviceType> &geometry,
                                                                      const int &polyOrder, int worksetSize,

diff --git a/packages/intrepid2/assembly-examples/H1StructuredAssembly.hpp b/packages/intrepid2/assembly-examples/H1StructuredAssembly.hpp
@@ -10,6 +10,10 @@
 
 #include "JacobianFlopEstimate.hpp"
 
+/** \file   H1StructuredAssembly.hpp
+    \brief  Locally assembles a matrix with the H^1 natural norm -- an array of shape (C,F,F), with formulation (e_i, e_j) + (grad e_i, grad e_j), using "structured" Intrepid2 methods; these algorithmically exploit geometric structure as expressed in the provided CellGeometry.
+ */
+
 //! Version that takes advantage of new structured integration support, including sum factorization.
 template<class Scalar, class BasisFamily, class PointScalar, int spaceDim, typename DeviceType>
 Intrepid2::ScalarView<Scalar,DeviceType> performStructuredQuadratureH1(Intrepid2::CellGeometry<PointScalar, spaceDim, DeviceType> &geometry, const int &polyOrder, const int &worksetSize,

diff --git a/packages/intrepid2/assembly-examples/HCURLStandardAssembly.hpp b/packages/intrepid2/assembly-examples/HCURLStandardAssembly.hpp
@@ -10,7 +10,11 @@
 
 #include "JacobianFlopEstimate.hpp"
 
-//! version that uses the classic, generic Intrepid2 paths;
+/** \file   HCURLStandardAssembly.hpp
+    \brief  Locally assembles a matrix with the H(curl) natural norm -- an array of shape (C,F,F), with formulation (e_i, e_j) + (curl e_i, curl e_j), using standard Intrepid2 methods; these do not algorithmically exploit geometric structure.
+ */
+
+//! Version that uses the classic, generic Intrepid2 paths.
 template<class Scalar, class BasisFamily, class PointScalar, int spaceDim, typename DeviceType>
 Intrepid2::ScalarView<Scalar,DeviceType> performStandardQuadratureHCURL(Intrepid2::CellGeometry<PointScalar, spaceDim, DeviceType> &geometry,
                                                                         const int &polyOrder, int worksetSize,

diff --git a/packages/intrepid2/assembly-examples/HCURLStructuredAssembly.hpp b/packages/intrepid2/assembly-examples/HCURLStructuredAssembly.hpp
@@ -10,6 +10,10 @@
 
 #include "JacobianFlopEstimate.hpp"
 
+/** \file   HCURLStructuredAssembly.hpp
+    \brief  Locally assembles a matrix with the H(curl) natural norm -- an array of shape (C,F,F), with formulation (e_i, e_j) + (curl e_i, curl e_j), using "structured" Intrepid2 methods; these algorithmically exploit geometric structure as expressed in the provided CellGeometry.
+ */
+
 //! Version that takes advantage of new structured integration support, including sum factorization.  Computes H(curl) norm: (curl, curl) + (value,value).
 template<class Scalar, class BasisFamily, class PointScalar, int spaceDim, typename DeviceType>
 Intrepid2::ScalarView<Scalar,DeviceType> performStructuredQuadratureHCURL(Intrepid2::CellGeometry<PointScalar, spaceDim, DeviceType> &geometry, const int &polyOrder, const int &worksetSize,

diff --git a/packages/intrepid2/assembly-examples/HDIVStandardAssembly.hpp b/packages/intrepid2/assembly-examples/HDIVStandardAssembly.hpp
@@ -10,7 +10,11 @@
 
 #include "JacobianFlopEstimate.hpp"
 
-//! version that uses the classic, generic Intrepid2 paths;
+/** \file   HDIVStandardAssembly.hpp
+    \brief  Locally assembles a matrix with the H(div) natural norm -- an array of shape (C,F,F), with formulation (e_i, e_j) + (div e_i, div e_j), using standard Intrepid2 methods; these do not algorithmically exploit geometric structure.
+ */
+
+//! Version that uses the classic, generic Intrepid2 paths.
 template<class Scalar, class BasisFamily, class PointScalar, int spaceDim, typename DeviceType>
 Intrepid2::ScalarView<Scalar,DeviceType> performStandardQuadratureHDIV(Intrepid2::CellGeometry<PointScalar, spaceDim, DeviceType> &geometry,
                                                                        const int &polyOrder, int worksetSize,

diff --git a/packages/intrepid2/assembly-examples/HDIVStructuredAssembly.hpp b/packages/intrepid2/assembly-examples/HDIVStructuredAssembly.hpp
@@ -10,6 +10,10 @@
 
 #include "JacobianFlopEstimate.hpp"
 
+/** \file   HDIVStructuredAssembly.hpp
+    \brief  Locally assembles a matrix with the H(div) natural norm -- an array of shape (C,F,F), with formulation (e_i, e_j) + (div e_i, div e_j), using "structured" Intrepid2 methods; these algorithmically exploit geometric structure as expressed in the provided CellGeometry.
+ */
+
 //! Version that takes advantage of new structured integration support, including sum factorization.  Computes H(div) norm: (div, div) + (value,value).
 template<class Scalar, class BasisFamily, class PointScalar, int spaceDim, typename DeviceType>
 Intrepid2::ScalarView<Scalar,DeviceType> performStructuredQuadratureHDIV(Intrepid2::CellGeometry<PointScalar, spaceDim, DeviceType> &geometry, const int &polyOrder, const int &worksetSize,

diff --git a/packages/intrepid2/assembly-examples/HVOLStandardAssembly.hpp b/packages/intrepid2/assembly-examples/HVOLStandardAssembly.hpp
@@ -10,7 +10,11 @@
 
 #include "JacobianFlopEstimate.hpp"
 
-//! version that uses the classic, generic Intrepid2 paths.
+/** \file   HVOLStandardAssembly.hpp
+    \brief  Locally assembles a matrix with the H(vol) natural norm -- an array of shape (C,F,F), with formulation (e_i, e_j), using standard Intrepid2 methods; these do not algorithmically exploit geometric structure.
+ */
+
+//! Version that uses the classic, generic Intrepid2 paths.
 template<class Scalar, class BasisFamily, class PointScalar, int spaceDim, typename DeviceType>
 Intrepid2::ScalarView<Scalar,DeviceType> performStandardQuadratureHVOL(Intrepid2::CellGeometry<PointScalar, spaceDim, DeviceType> &geometry,
                                                                        const int &polyOrder, int worksetSize,

diff --git a/packages/intrepid2/assembly-examples/HVOLStructuredAssembly.hpp b/packages/intrepid2/assembly-examples/HVOLStructuredAssembly.hpp
@@ -10,7 +10,11 @@
 
 #include "JacobianFlopEstimate.hpp"
 
-//! Version that takes advantage of new structured integration support, including sum factorization.  Computes H(curl) norm: (curl, curl) + (value,value).
+/** \file   HVOLStructuredAssembly.hpp
+    \brief  Locally assembles a matrix with the H(vol) natural norm -- an array of shape (C,F,F), with formulation (e_i, e_j), using "structured" Intrepid2 methods; these algorithmically exploit geometric structure as expressed in the provided CellGeometry.
+ */
+
+//! Version that takes advantage of new structured integration support, including sum factorization.  Computes H(vol) norm: (value,value).
 template<class Scalar, class BasisFamily, class PointScalar, int spaceDim, typename DeviceType>
 Intrepid2::ScalarView<Scalar,DeviceType> performStructuredQuadratureHVOL(Intrepid2::CellGeometry<PointScalar, spaceDim, DeviceType> &geometry, const int &polyOrder, const int &worksetSize,
                                                                           double &transformIntegrateFlopCount, double &jacobianCellMeasureFlopCount)