[cig-commits] r14048 - in short/3D/PyLith/branches/pylith-swig: libsrc libsrc/feassemble unittests/libtests/feassemble
brad at geodynamics.org
brad at geodynamics.org
Fri Feb 13 11:52:04 PST 2009
Author: brad
Date: 2009-02-13 11:52:03 -0800 (Fri, 13 Feb 2009)
New Revision: 14048
Added:
short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadratureRefCell.cc
short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadratureRefCell.hh
Removed:
short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadratureBase.cc
short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadratureBase.hh
Modified:
short/3D/PyLith/branches/pylith-swig/libsrc/Makefile.am
short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Makefile.am
short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature0D.cc
short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature0D.hh
short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature0D.icc
short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature1D.cc
short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature1D.hh
short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature1D.icc
short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature1Din2D.cc
short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature1Din2D.hh
short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature1Din2D.icc
short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature1Din3D.cc
short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature1Din3D.hh
short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature1Din3D.icc
short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature2D.cc
short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature2D.hh
short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature2D.icc
short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature2Din3D.cc
short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature2Din3D.hh
short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature2Din3D.icc
short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature3D.cc
short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature3D.hh
short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/QuadratureEngine.cc
short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/QuadratureEngine.hh
short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/QuadratureRefCell.cc
short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/QuadratureRefCell.hh
short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/QuadratureRefCell.icc
short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/Makefile.am
short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature0D.cc
short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature0D.hh
short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature1D.cc
short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature1D.hh
short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature1Din2D.cc
short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature1Din2D.hh
short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature1Din3D.cc
short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature1Din3D.hh
short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature2D.cc
short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature2D.hh
short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature2Din3D.cc
short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature2Din3D.hh
short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature3D.cc
short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature3D.hh
short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadratureEngine.cc
short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadratureEngine.hh
Log:
Finished cleaning up low-level quadrature stuff and updating corresponding unit tests.
Modified: short/3D/PyLith/branches/pylith-swig/libsrc/Makefile.am
===================================================================
--- short/3D/PyLith/branches/pylith-swig/libsrc/Makefile.am 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/libsrc/Makefile.am 2009-02-13 19:52:03 UTC (rev 14048)
@@ -41,6 +41,13 @@
feassemble/GeometryHex3D.cc \
feassemble/QuadratureRefCell.cc \
feassemble/QuadratureEngine.cc \
+ feassemble/Quadrature0D.cc \
+ feassemble/Quadrature1D.cc \
+ feassemble/Quadrature1Din2D.cc \
+ feassemble/Quadrature1Din3D.cc \
+ feassemble/Quadrature2D.cc \
+ feassemble/Quadrature2Din3D.cc \
+ feassemble/Quadrature3D.cc \
meshio/BinaryIO.cc \
meshio/GMVFile.cc \
meshio/GMVFileAscii.cc \
Modified: short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Makefile.am
===================================================================
--- short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Makefile.am 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Makefile.am 2009-02-13 19:52:03 UTC (rev 14048)
@@ -46,7 +46,6 @@
Quadrature0D.icc \
Quadrature1D.hh \
Quadrature1D.icc \
- Quadrature1D.cc \
Quadrature1Din2D.hh \
Quadrature1Din2D.icc \
Quadrature1Din3D.hh \
@@ -57,7 +56,6 @@
Quadrature2Din3D.icc \
Quadrature3D.hh \
Quadrature3D.icc \
- Quadrature3D.cc \
feassemblefwd.hh
noinst_HEADERS =
Modified: short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature0D.cc
===================================================================
--- short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature0D.cc 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature0D.cc 2009-02-13 19:52:03 UTC (rev 14048)
@@ -14,7 +14,8 @@
#include "Quadrature0D.hh" // implementation of class methods
-#include "pylith/utils/array.hh" // USES double_array
+#include "QuadratureRefCell.hh" // USES QuadratureRefCell
+#include "CellGeometry.hh" // USES CellGeometry
#include "petsc.h" // USES PetscLogFlops()
@@ -22,7 +23,8 @@
// ----------------------------------------------------------------------
// Constructor
-pylith::feassemble::Quadrature0D::Quadrature0D(void) : Quadrature()
+pylith::feassemble::Quadrature0D::Quadrature0D(const QuadratureRefCell& q) :
+ QuadratureEngine(q)
{ // constructor
} // constructor
@@ -35,32 +37,38 @@
// ----------------------------------------------------------------------
// Copy constructor.
pylith::feassemble::Quadrature0D::Quadrature0D(const Quadrature0D& q) :
- Quadrature(q)
+ QuadratureEngine(q)
{ // copy constructor
} // copy constructor
// ----------------------------------------------------------------------
// Compute geometric quantities for a cell at quadrature points.
void
-pylith::feassemble::Quadrature0D::computeGeometry(
- const real_section_type::value_type* vertCoords,
- const int coordDim,
- const Mesh::point_type& cell)
+pylith::feassemble::Quadrature0D::computeGeometry(const double* vertCoords,
+ const int coordDim,
+ const int cell)
{ // computeGeometry
- assert(0 == _cellDim);
- assert(1 == _numQuadPts);
- assert(1 == _numBasis);
+ const int cellDim = _quadRefCell.cellDim();
+ const int spaceDim = _quadRefCell.spaceDim();
+ const int numQuadPts = _quadRefCell.numQuadPts();
+ const int numBasis = _quadRefCell.numBasis();
- _resetGeometry();
+ const double_array& basisDerivRef = _quadRefCell.basisDerivRef();
+
+ assert(0 == cellDim);
+ assert(1 == numQuadPts);
+ assert(1 == numBasis);
+
+ zero();
assert(1 == coordDim);
- for (int i=0; i < _spaceDim; ++i)
+ for (int i=0; i < spaceDim; ++i)
_quadPts[i] = vertCoords[i];
_jacobian[0] = 1.0;
_jacobianDet[0] = 1.0;
_jacobianInv[0] = 1.0;
- _basisDeriv[0] = _basisDerivRef[0];
+ _basisDeriv[0] = basisDerivRef[0];
PetscLogFlops(0);
} // computeGeometry
Modified: short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature0D.hh
===================================================================
--- short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature0D.hh 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature0D.hh 2009-02-13 19:52:03 UTC (rev 14048)
@@ -22,40 +22,42 @@
#if !defined(pylith_feassemble_quadrature0d_hh)
#define pylith_feassemble_quadrature0d_hh
-#include "Quadrature.hh"
+#include "QuadratureEngine.hh"
namespace pylith {
namespace feassemble {
- class Quadrature0D;
class TestQuadrature0D;
} // feassemble
} // pylith
-class pylith::feassemble::Quadrature0D : public Quadrature
+class pylith::feassemble::Quadrature0D : public QuadratureEngine
{ // Quadrature0D
friend class TestQuadrature0D; // unit testing
// PUBLIC MEMBERS ///////////////////////////////////////////////////////
public :
- /// Constructor
- Quadrature0D(void);
+ /** Constructor.
+ *
+ * @param q Quadrature information for reference cell.
+ */
+ Quadrature0D(const QuadratureRefCell& q);
/// Destructor
~Quadrature0D(void);
/// Create a copy of this object.
- Quadrature* clone(void) const;
+ QuadratureEngine* clone(void) const;
/** Compute geometric quantities for a cell at quadrature points.
*
- * @param mesh Finite-element mesh
- * @param coordinates Section containing vertex coordinates
+ * @param vertCoords Coordinates of vertices of finite-element cell.
+ * @param coordDim Spatial dimension of coordinate system.
* @param cell Finite-element cell
*/
- void computeGeometry(const real_section_type::value_type* vertCoords,
- const int coordDim,
- const Mesh::point_type& cell);
+ void computeGeometry(const double* vertCoords,
+ const int coordDim,
+ const int cell);
// PROTECTED METHODS ////////////////////////////////////////////////////
protected :
@@ -77,4 +79,5 @@
#endif // pylith_feassemble_quadrature0d_hh
+
// End of file
Modified: short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature0D.icc
===================================================================
--- short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature0D.icc 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature0D.icc 2009-02-13 19:52:03 UTC (rev 14048)
@@ -16,7 +16,7 @@
// Create a copy of this object.
inline
-pylith::feassemble::Quadrature*
+pylith::feassemble::QuadratureEngine*
pylith::feassemble::Quadrature0D::clone(void) const {
return new Quadrature0D(*this);
} // clone
Modified: short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature1D.cc
===================================================================
--- short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature1D.cc 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature1D.cc 2009-02-13 19:52:03 UTC (rev 14048)
@@ -12,8 +12,9 @@
#include <portinfo>
-//#include "Quadrature1D.hh" // implementation of class methods
+#include "Quadrature1D.hh" // implementation of class methods
+#include "QuadratureRefCell.hh" // USES QuadratureRefCell
#include "CellGeometry.hh" // USES CellGeometry
#include "petsc.h" // USES PetscLogFlops
@@ -24,64 +25,68 @@
// ----------------------------------------------------------------------
// Constructor
-template<typename mesh_type>
-pylith::feassemble::Quadrature1D<mesh_type>::Quadrature1D(void)
+pylith::feassemble::Quadrature1D::Quadrature1D(const QuadratureRefCell& q) :
+ QuadratureEngine(q)
{ // constructor
} // constructor
// ----------------------------------------------------------------------
// Destructor
-template<typename mesh_type>
-pylith::feassemble::Quadrature1D<mesh_type>::~Quadrature1D(void)
+pylith::feassemble::Quadrature1D::~Quadrature1D(void)
{ // destructor
} // destructor
// ----------------------------------------------------------------------
// Copy constructor.
-template<typename mesh_type>
-pylith::feassemble::Quadrature1D<mesh_type>::Quadrature1D(const Quadrature1D& q) :
- Quadrature<mesh_type>(q)
+pylith::feassemble::Quadrature1D::Quadrature1D(const Quadrature1D& q) :
+ QuadratureEngine(q)
{ // copy constructor
} // copy constructor
-#if 1
// ----------------------------------------------------------------------
// Compute geometric quantities for a cell at quadrature points.
-template<typename mesh_type>
void
-pylith::feassemble::Quadrature1D<mesh_type>::_computeGeometry(
- const double* vertCoords,
- const int coordDim,
- const int cell)
+pylith::feassemble::Quadrature1D::computeGeometry(const double* vertCoords,
+ const int coordDim,
+ const int cell)
{ // computeGeometry
- const int cellDim = this->_cellDim;
- const int spaceDim = this->_spaceDim;
+ assert(0 != vertCoords);
+ assert(1 == coordDim);
- assert(1 == this->_cellDim);
- assert(1 == this->_spaceDim);
- assert(1 == coordDim);
+ const int cellDim = _quadRefCell.cellDim();
+ const int spaceDim = _quadRefCell.spaceDim();
+ const int numQuadPts = _quadRefCell.numQuadPts();
+ const int numBasis = _quadRefCell.numBasis();
+
+ const double_array& basis = _quadRefCell.basis();
+ const double_array& quadPtsRef = _quadRefCell.quadPtsRef();
+ const double_array& basisDerivRef = _quadRefCell.basisDerivRef();
+ const CellGeometry& geometry = _quadRefCell.refGeometry();
+
+ assert(1 == cellDim);
+ assert(1 == spaceDim);
+ zero();
// Loop over quadrature points
- for (int iQuadPt=0; iQuadPt < _numQuadPts; ++iQuadPt) {
+ for (int iQuadPt=0; iQuadPt < numQuadPts; ++iQuadPt) {
// Compute coordinates of quadrature point in cell
#if defined(ISOPARAMETRIC)
// x = sum[i=0,n-1] (Ni * xi)
- for (int iBasis=0; iBasis < _numBasis; ++iBasis)
+ for (int iBasis=0; iBasis < numBasis; ++iBasis)
_quadPts[iQuadPt] +=
- _basis[iQuadPt*_numBasis+iBasis]*vertCoords[iBasis];
+ basis[iQuadPt*numBasis+iBasis]*vertCoords[iBasis];
#else
- assert(0 != _geometry);
- _geometry->coordsRefToGlobal(&_quadPts[iQuadPt], &_quadPtsRef[iQuadPt],
- vertCoords, _spaceDim);
+ geometry.coordsRefToGlobal(&_quadPts[iQuadPt], &quadPtsRef[iQuadPt],
+ vertCoords, spaceDim);
#endif
#if defined(ISOPARAMETRIC)
// Compute Jacobian at quadrature point
// J = dx/dp = sum[i=0,n-1] (dNi/dp * xi)
- for (int iBasis=0; iBasis < _numBasis; ++iBasis)
+ for (int iBasis=0; iBasis < numBasis; ++iBasis)
_jacobian[iQuadPt] +=
- _basisDerivRef[iQuadPt*_numBasis+iBasis] * vertCoords[iBasis];
+ basisDerivRef[iQuadPt*numBasis+iBasis] * vertCoords[iBasis];
// Compute determinant of Jacobian at quadrature point
// |J| = j00
@@ -91,8 +96,8 @@
#else
// Compute Jacobian and determinant of Jacobian at quadrature point
assert(0 != _geometry);
- _geometry->jacobian(&_jacobian[iQuadPt], &_jacobianDet[iQuadPt],
- vertCoords, &_quadPtsRef[iQuadPt], _spaceDim);
+ geometry->jacobian(&_jacobian[iQuadPt], &_jacobianDet[iQuadPt],
+ vertCoords, &quadPtsRef[iQuadPt], spaceDim);
_checkJacobianDet(_jacobianDet[iQuadPt], cell);
#endif
@@ -100,21 +105,21 @@
// Jinv = 1/j00
_jacobianInv[iQuadPt] = 1.0 / _jacobianDet[iQuadPt];
- assert(_numQuadPts*_numBasis*_spaceDim == _basisDeriv.size());
- assert(_numQuadPts*_numBasis*_cellDim == _basisDerivRef.size());
- assert(_numQuadPts*_cellDim*_spaceDim == _jacobianInv.size());
+ assert(numQuadPts*numBasis*spaceDim == _basisDeriv.size());
+ assert(numQuadPts*numBasis*cellDim == basisDerivRef.size());
+ assert(numQuadPts*cellDim*spaceDim == _jacobianInv.size());
// Compute derivatives of basis functions with respect to global
// coordinates
// dNi/dx = dNi/dp dp/dx + dNi/dq dq/dx + dNi/dr dr/dx
- for (int iBasis=0; iBasis < _numBasis; ++iBasis)
- _basisDeriv[iQuadPt*_numBasis+iBasis] +=
- _basisDerivRef[iQuadPt*_numBasis+iBasis] *
+ for (int iBasis=0; iBasis < numBasis; ++iBasis)
+ _basisDeriv[iQuadPt*numBasis+iBasis] +=
+ basisDerivRef[iQuadPt*numBasis+iBasis] *
_jacobianInv[iQuadPt];
} // for
- PetscLogFlops(_numQuadPts * (1 + _numBasis * 4));
+ PetscLogFlops(numQuadPts * (1 + numBasis * 4));
} // computeGeometry
-#endif
+
// End of file
Modified: short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature1D.hh
===================================================================
--- short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature1D.hh 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature1D.hh 2009-02-13 19:52:03 UTC (rev 14048)
@@ -19,45 +19,47 @@
#if !defined(pylith_feassemble_quadrature1d_hh)
#define pylith_feassemble_quadrature1d_hh
-#include "Quadrature.hh" // ISA Quadrature
+#include "QuadratureEngine.hh" // ISA Quadrature
-template<typename mesh_type>
-class pylith::feassemble::Quadrature1D : public Quadrature<mesh_type>
+class pylith::feassemble::Quadrature1D : public QuadratureEngine
{ // Quadrature1D
friend class TestQuadrature1D; // unit testing
// PUBLIC MEMBERS ///////////////////////////////////////////////////////
public :
- /// Constructor
- Quadrature1D(void);
+ /** Constructor.
+ *
+ * @param q Quadrature information for reference cell.
+ */
+ Quadrature1D(const QuadratureRefCell& q);
/// Destructor
~Quadrature1D(void);
/// Create a copy of this object.
- Quadrature<mesh_type>* clone(void) const;
+ QuadratureEngine* clone(void) const;
-// PROTECTED METHODS ////////////////////////////////////////////////////
-protected :
+ /** Compute geometric quantities for a cell at quadrature points.
+ *
+ * @param vertCoords Coordinates of vertices of finite-element cell.
+ * @param coordDim Spatial dimension of coordinate system.
+ * @param cell Finite-element cell
+ */
+ void computeGeometry(const double* vertCoords,
+ const int coordDim,
+ const int cell);
+// PRIVATE METHODS //////////////////////////////////////////////////////
+private :
+
/** Copy constructor.
*
* @param q Quadrature to copy
*/
Quadrature1D(const Quadrature1D& q);
- /** Compute geometric quantities for a cell at quadrature points.
- *
- * @param mesh Finite-element mesh
- * @param coordinates Section containing vertex coordinates
- * @param cell Finite-element cell
- */
- void _computeGeometry(const double* vertCoords,
- const int coordDim,
- const int cell);
-
-// PRIVATE METHODS //////////////////////////////////////////////////////
+// NOT IMPLEMENTED //////////////////////////////////////////////////////
private :
const Quadrature1D& operator=(const Quadrature1D&); ///< Not implemented
@@ -65,8 +67,8 @@
}; // Quadrature1D
#include "Quadrature1D.icc" // inline methods
-#include "Quadrature1D.cc" // template methods
#endif // pylith_feassemble_quadrature1d_hh
+
// End of file
Modified: short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature1D.icc
===================================================================
--- short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature1D.icc 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature1D.icc 2009-02-13 19:52:03 UTC (rev 14048)
@@ -15,11 +15,10 @@
#else
// Create a copy of this object.
-template<typename mesh_type>
inline
-pylith::feassemble::Quadrature<mesh_type>*
-pylith::feassemble::Quadrature1D<mesh_type>::clone(void) const {
- return new Quadrature1D<mesh_type>(*this);
+pylith::feassemble::QuadratureEngine*
+pylith::feassemble::Quadrature1D::clone(void) const {
+ return new Quadrature1D(*this);
} // clone
#endif
Modified: short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature1Din2D.cc
===================================================================
--- short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature1Din2D.cc 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature1Din2D.cc 2009-02-13 19:52:03 UTC (rev 14048)
@@ -14,6 +14,7 @@
#include "Quadrature1Din2D.hh" // implementation of class methods
+#include "QuadratureRefCell.hh" // USES QuadratureRefCell
#include "CellGeometry.hh" // USES CellGeometry
#include "petsc.h" // USES PetscLogFlops
@@ -24,7 +25,8 @@
// ----------------------------------------------------------------------
// Constructor
-pylith::feassemble::Quadrature1Din2D::Quadrature1Din2D(void) : Quadrature()
+pylith::feassemble::Quadrature1Din2D::Quadrature1Din2D(const QuadratureRefCell& q) :
+ QuadratureEngine(q)
{ // constructor
} // constructor
@@ -37,42 +39,51 @@
// ----------------------------------------------------------------------
// Copy constructor.
pylith::feassemble::Quadrature1Din2D::Quadrature1Din2D(const Quadrature1Din2D& q) :
- Quadrature(q)
+ QuadratureEngine(q)
{ // copy constructor
} // copy constructor
// ----------------------------------------------------------------------
// Compute geometric quantities for a cell at quadrature points.
void
-pylith::feassemble::Quadrature1Din2D::computeGeometry(
- const real_section_type::value_type* vertCoords,
- const int coordDim,
- const Mesh::point_type& cell)
+pylith::feassemble::Quadrature1Din2D::computeGeometry(const double* vertCoords,
+ const int coordDim,
+ const int cell)
{ // computeGeometry
- assert(1 == _cellDim);
- assert(2 == _spaceDim);
-
- _resetGeometry();
+ assert(0 != vertCoords);
assert(2 == coordDim);
+ const int cellDim = _quadRefCell.cellDim();
+ const int spaceDim = _quadRefCell.spaceDim();
+ const int numQuadPts = _quadRefCell.numQuadPts();
+ const int numBasis = _quadRefCell.numBasis();
+
+ const double_array& basis = _quadRefCell.basis();
+ const double_array& quadPtsRef = _quadRefCell.quadPtsRef();
+ const double_array& basisDerivRef = _quadRefCell.basisDerivRef();
+ const CellGeometry& geometry = _quadRefCell.refGeometry();
+
+ assert(1 == cellDim);
+ assert(2 == spaceDim);
+ zero();
+
// Loop over quadrature points
- for (int iQuadPt=0; iQuadPt < _numQuadPts; ++iQuadPt) {
+ for (int iQuadPt=0; iQuadPt < numQuadPts; ++iQuadPt) {
// Compute coordinates of quadrature point in cell
#if defined(ISOPARAMETRIC)
// x = sum[i=0,n-1] (Ni * xi)
// y = sum[i=0,n-1] (Ni * yi)
- for (int iBasis=0; iBasis < _numBasis; ++iBasis) {
- const double basis = _basis[iQuadPt*_numBasis+iBasis];
- for (int iDim=0; iDim < _spaceDim; ++iDim)
- _quadPts[iQuadPt*_spaceDim+iDim] +=
- basis * vertCoords[iBasis*_spaceDim+iDim];
+ for (int iBasis=0; iBasis < numBasis; ++iBasis) {
+ const double valueBasis = basis[iQuadPt*numBasis+iBasis];
+ for (int iDim=0; iDim < spaceDim; ++iDim)
+ _quadPts[iQuadPt*spaceDim+iDim] +=
+ valueBasis * vertCoords[iBasis*spaceDim+iDim];
} // for
#else
- assert(0 != _geometry);
- _geometry->coordsRefToGlobal(&_quadPts[iQuadPt*_spaceDim],
- &_quadPtsRef[iQuadPt*_cellDim],
- vertCoords, _spaceDim);
+ geometry.coordsRefToGlobal(&_quadPts[iQuadPt*spaceDim],
+ &quadPtsRef[iQuadPt*cellDim],
+ vertCoords, spaceDim);
#endif
#if defined(ISOPARAMETRIC)
@@ -81,51 +92,50 @@
// dy/dp]
// dx/dp = sum[i=0,n-1] (dNi/dp * xi)
// dy/dp = sum[i=0,n-1] (dNi/dp * yi)
- for (int iBasis=0; iBasis < _numBasis; ++iBasis) {
- const double deriv = _basisDerivRef[iQuadPt*_numBasis+iBasis];
- for (int iDim=0; iDim < _spaceDim; ++iDim)
- _jacobian[iQuadPt*_spaceDim+iDim] +=
- deriv * vertCoords[iBasis*_spaceDim+iDim];
+ for (int iBasis=0; iBasis < numBasis; ++iBasis) {
+ const double deriv = basisDerivRef[iQuadPt*numBasis+iBasis];
+ for (int iDim=0; iDim < spaceDim; ++iDim)
+ _jacobian[iQuadPt*spaceDim+iDim] +=
+ deriv * vertCoords[iBasis*spaceDim+iDim];
} // for
// Compute determinant of Jacobian at quadrature point
// |J| = sqrt(transpose(J) J)
double det = 0.0;
- for (int iDim=0; iDim < _spaceDim; ++iDim)
- det += _jacobian[iQuadPt*_spaceDim+iDim] *
- _jacobian[iQuadPt*_spaceDim+iDim];
+ for (int iDim=0; iDim < spaceDim; ++iDim)
+ det += _jacobian[iQuadPt*spaceDim+iDim] *
+ _jacobian[iQuadPt*spaceDim+iDim];
det = sqrt(det);
_checkJacobianDet(det, cell);
_jacobianDet[iQuadPt] = det;
#else
// Compute Jacobian and determinant of Jacobian at quadrature point
- assert(0 != _geometry);
- _geometry->jacobian(&_jacobian[iQuadPt*_cellDim*_spaceDim],
- &_jacobianDet[iQuadPt],
- vertCoords, &_quadPtsRef[iQuadPt*_cellDim], _spaceDim);
+ geometry.jacobian(&_jacobian[iQuadPt*_cellDim*spaceDim],
+ &_jacobianDet[iQuadPt],
+ vertCoords, &quadPtsRef[iQuadPt*cellDim], spaceDim);
_checkJacobianDet(_jacobianDet[iQuadPt], cell);
#endif
// Compute inverse of Jacobian at quadrature point
// Jinv = 1.0/[J]
- for (int iDim=0; iDim < _spaceDim; ++iDim)
- _jacobianInv[iQuadPt*_spaceDim+iDim] =
- 1.0 / _jacobian[iQuadPt*_spaceDim+iDim];
+ for (int iDim=0; iDim < spaceDim; ++iDim)
+ _jacobianInv[iQuadPt*spaceDim+iDim] =
+ 1.0 / _jacobian[iQuadPt*spaceDim+iDim];
// Compute derivatives of basis functions with respect to global
// coordinates
// dNi/dx = dNi/dp dp/dx + dNi/dq dq/dx + dNi/dr dr/dx
- for (int iBasis=0; iBasis < _numBasis; ++iBasis)
- for (int iDim=0; iDim < _spaceDim; ++iDim)
- for (int jDim=0; jDim < _cellDim; ++jDim)
- _basisDeriv[iQuadPt*_numBasis*_spaceDim+iBasis*_spaceDim+iDim] +=
- _basisDerivRef[iQuadPt*_numBasis*_cellDim+iBasis*_cellDim+jDim] *
- _jacobianInv[iQuadPt*_cellDim*_spaceDim+jDim*_spaceDim+iDim];
+ for (int iBasis=0; iBasis < numBasis; ++iBasis)
+ for (int iDim=0; iDim < spaceDim; ++iDim)
+ for (int jDim=0; jDim < cellDim; ++jDim)
+ _basisDeriv[iQuadPt*numBasis*spaceDim+iBasis*spaceDim+iDim] +=
+ basisDerivRef[iQuadPt*numBasis*cellDim+iBasis*cellDim+jDim] *
+ _jacobianInv[iQuadPt*cellDim*spaceDim+jDim*spaceDim+iDim];
} // for
- PetscLogFlops(_numQuadPts * (1+_numBasis*_spaceDim*2+
- _spaceDim*1 +
- _numBasis*_spaceDim*_cellDim*2));
+ PetscLogFlops(numQuadPts * (1 + numBasis*spaceDim*2 +
+ spaceDim*1 +
+ numBasis*spaceDim*cellDim*2));
} // computeGeometry
Modified: short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature1Din2D.hh
===================================================================
--- short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature1Din2D.hh 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature1Din2D.hh 2009-02-13 19:52:03 UTC (rev 14048)
@@ -19,40 +19,42 @@
#if !defined(pylith_feassemble_quadrature1din2d_hh)
#define pylith_feassemble_quadrature1din2d_hh
-#include "Quadrature.hh"
+#include "QuadratureEngine.hh"
namespace pylith {
namespace feassemble {
class Quadrature1Din2D;
- class TestQuadrature1Din2D;
} // feassemble
} // pylith
-class pylith::feassemble::Quadrature1Din2D : public Quadrature
+class pylith::feassemble::Quadrature1Din2D : public QuadratureEngine
{ // Quadrature1Din2D
friend class TestQuadrature1Din2D; // unit testing
// PUBLIC MEMBERS ///////////////////////////////////////////////////////
public :
- /// Constructor
- Quadrature1Din2D(void);
+ /** Constructor.
+ *
+ * @param q Quadrature information for reference cell.
+ */
+ Quadrature1Din2D(const QuadratureRefCell& q);
/// Destructor
~Quadrature1Din2D(void);
/// Create a copy of this object.
- Quadrature* clone(void) const;
+ QuadratureEngine* clone(void) const;
/** Compute geometric quantities for a cell at quadrature points.
*
- * @param mesh Finite-element mesh
- * @param coordinates Section containing vertex coordinates
+ * @param vertCoords Coordinates of vertices of finite-element cell.
+ * @param coordDim Spatial dimension of coordinate system.
* @param cell Finite-element cell
*/
- void computeGeometry(const real_section_type::value_type* vertCoords,
- const int coordDim,
- const Mesh::point_type& cell);
+ void computeGeometry(const double* vertCoords,
+ const int coordDim,
+ const int cell);
// PROTECTED METHODS ////////////////////////////////////////////////////
protected :
@@ -75,4 +77,5 @@
#endif // pylith_feassemble_quadrature1din2d_hh
+
// End of file
Modified: short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature1Din2D.icc
===================================================================
--- short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature1Din2D.icc 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature1Din2D.icc 2009-02-13 19:52:03 UTC (rev 14048)
@@ -16,7 +16,7 @@
// Create a copy of this object.
inline
-pylith::feassemble::Quadrature*
+pylith::feassemble::QuadratureEngine*
pylith::feassemble::Quadrature1Din2D::clone(void) const {
return new Quadrature1Din2D(*this);
} // clone
Modified: short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature1Din3D.cc
===================================================================
--- short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature1Din3D.cc 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature1Din3D.cc 2009-02-13 19:52:03 UTC (rev 14048)
@@ -14,6 +14,7 @@
#include "Quadrature1Din3D.hh" // implementation of class methods
+#include "QuadratureRefCell.hh" // USES QuadratureRefCell
#include "CellGeometry.hh" // USES CellGeometry
#include "petsc.h" // USES PetscLogFlops
@@ -24,7 +25,8 @@
// ----------------------------------------------------------------------
// Constructor
-pylith::feassemble::Quadrature1Din3D::Quadrature1Din3D(void) : Quadrature()
+pylith::feassemble::Quadrature1Din3D::Quadrature1Din3D(const QuadratureRefCell& q) :
+ QuadratureEngine(q)
{ // constructor
} // constructor
@@ -37,43 +39,52 @@
// ----------------------------------------------------------------------
// Copy constructor.
pylith::feassemble::Quadrature1Din3D::Quadrature1Din3D(const Quadrature1Din3D& q) :
- Quadrature(q)
+ QuadratureEngine(q)
{ // copy constructor
} // copy constructor
// ----------------------------------------------------------------------
// Compute geometric quantities for a cell at quadrature points.
void
-pylith::feassemble::Quadrature1Din3D::computeGeometry(
- const real_section_type::value_type* vertCoords,
- const int coordDim,
- const Mesh::point_type& cell)
+pylith::feassemble::Quadrature1Din3D::computeGeometry(const double* vertCoords,
+ const int coordDim,
+ const int cell)
{ // computeGeometry
- assert(1 == _cellDim);
- assert(3 == _spaceDim);
-
- _resetGeometry();
+ assert(0 != vertCoords);
assert(3 == coordDim);
+ const int cellDim = _quadRefCell.cellDim();
+ const int spaceDim = _quadRefCell.spaceDim();
+ const int numQuadPts = _quadRefCell.numQuadPts();
+ const int numBasis = _quadRefCell.numBasis();
+
+ const double_array& basis = _quadRefCell.basis();
+ const double_array& quadPtsRef = _quadRefCell.quadPtsRef();
+ const double_array& basisDerivRef = _quadRefCell.basisDerivRef();
+ const CellGeometry& geometry = _quadRefCell.refGeometry();
+
+ assert(1 == cellDim);
+ assert(3 == spaceDim);
+ zero();
+
// Loop over quadrature points
- for (int iQuadPt=0; iQuadPt < _numQuadPts; ++iQuadPt) {
+ for (int iQuadPt=0; iQuadPt < numQuadPts; ++iQuadPt) {
// Compute coordinates of quadrature point in cell
#if defined(ISOPARAMETRIC)
// x = sum[i=0,n-1] (Ni * xi)
// y = sum[i=0,n-1] (Ni * yi)
// z = sum[i=0,n-1] (Ni * zi)
- for (int iBasis=0; iBasis < _numBasis; ++iBasis) {
- const double basis = _basis[iQuadPt*_numBasis+iBasis];
- for (int iDim=0; iDim < _spaceDim; ++iDim)
- _quadPts[iQuadPt*_spaceDim+iDim] +=
- basis * vertCoords[iBasis*_spaceDim+iDim];
+ for (int iBasis=0; iBasis < numBasis; ++iBasis) {
+ const double valueBasis = basis[iQuadPt*numBasis+iBasis];
+ for (int iDim=0; iDim < spaceDim; ++iDim)
+ _quadPts[iQuadPt*spaceDim+iDim] +=
+ valueBasis * vertCoords[iBasis*spaceDim+iDim];
} // for
#else
- assert(0 != _geometry);
- _geometry->coordsRefToGlobal(&_quadPts[iQuadPt*_spaceDim],
- &_quadPtsRef[iQuadPt*_cellDim],
- vertCoords, _spaceDim);
+ geometry.coordsRefToGlobal(&_quadPts[iQuadPt*spaceDim],
+ &quadPtsRef[iQuadPt*cellDim],
+ vertCoords, spaceDim);
#endif
#if defined(ISOPARAMETRIC)
@@ -84,52 +95,51 @@
// dx/dp = sum[i=0,n-1] (dNi/dp * xi)
// dy/dp = sum[i=0,n-1] (dNi/dp * yi)
// dz/dp = sum[i=0,n-1] (dNi/dp * zi)
- for (int iBasis=0; iBasis < _numBasis; ++iBasis) {
- const double deriv = _basisDerivRef[iQuadPt*_numBasis+iBasis];
- for (int iDim=0; iDim < _spaceDim; ++iDim)
- _jacobian[iQuadPt*_spaceDim+iDim] +=
- deriv * vertCoords[iBasis*_spaceDim+iDim];
+ for (int iBasis=0; iBasis < numBasis; ++iBasis) {
+ const double deriv = basisDerivRef[iQuadPt*numBasis+iBasis];
+ for (int iDim=0; iDim < spaceDim; ++iDim)
+ _jacobian[iQuadPt*spaceDim+iDim] +=
+ deriv * vertCoords[iBasis*spaceDim+iDim];
} // for
// Compute determinant of Jacobian at quadrature point
// |J| = sqrt(transpose(J) J)
double det = 0.0;
- for (int iDim=0; iDim < _spaceDim; ++iDim)
- det += _jacobian[iQuadPt*_spaceDim+iDim] *
- _jacobian[iQuadPt*_spaceDim+iDim];
+ for (int iDim=0; iDim < spaceDim; ++iDim)
+ det += _jacobian[iQuadPt*spaceDim+iDim] *
+ _jacobian[iQuadPt*spaceDim+iDim];
det = sqrt(det);
_checkJacobianDet(det, cell);
_jacobianDet[iQuadPt] = det;
#else
// Compute Jacobian and determinant of Jacobian at quadrature point
- assert(0 != _geometry);
- _geometry->jacobian(&_jacobian[iQuadPt*_cellDim*_spaceDim],
- &_jacobianDet[iQuadPt],
- vertCoords, &_quadPtsRef[iQuadPt*_cellDim], _spaceDim);
+ geometry.jacobian(&_jacobian[iQuadPt*cellDim*spaceDim],
+ &_jacobianDet[iQuadPt],
+ vertCoords, &quadPtsRef[iQuadPt*cellDim], spaceDim);
_checkJacobianDet(_jacobianDet[iQuadPt], cell);
#endif
// Compute inverse of Jacobian at quadrature point
// Jinv = 1.0/[J]
- for (int iDim=0; iDim < _spaceDim; ++iDim)
- _jacobianInv[iQuadPt*_spaceDim+iDim] =
- 1.0 / _jacobian[iQuadPt*_spaceDim+iDim];
+ for (int iDim=0; iDim < spaceDim; ++iDim)
+ _jacobianInv[iQuadPt*spaceDim+iDim] =
+ 1.0 / _jacobian[iQuadPt*spaceDim+iDim];
// Compute derivatives of basis functions with respect to global
// coordinates
// dNi/dx = dNi/dp dp/dx + dNi/dq dq/dx + dNi/dr dr/dx
- for (int iBasis=0; iBasis < _numBasis; ++iBasis)
- for (int iDim=0; iDim < _spaceDim; ++iDim)
- for (int jDim=0; jDim < _cellDim; ++jDim)
- _basisDeriv[iQuadPt*_numBasis*_spaceDim+iBasis*_spaceDim+iDim] +=
- _basisDerivRef[iQuadPt*_numBasis*_cellDim+iBasis*_cellDim+jDim] *
- _jacobianInv[iQuadPt*_cellDim*_spaceDim+jDim*_spaceDim+iDim];
+ for (int iBasis=0; iBasis < numBasis; ++iBasis)
+ for (int iDim=0; iDim < spaceDim; ++iDim)
+ for (int jDim=0; jDim < cellDim; ++jDim)
+ _basisDeriv[iQuadPt*numBasis*spaceDim+iBasis*spaceDim+iDim] +=
+ basisDerivRef[iQuadPt*numBasis*cellDim+iBasis*cellDim+jDim] *
+ _jacobianInv[iQuadPt*cellDim*spaceDim+jDim*spaceDim+iDim];
} // for
+
+ PetscLogFlops(numQuadPts * (1 + numBasis*spaceDim*2 +
+ spaceDim*1 +
+ numBasis*spaceDim*cellDim*2));
- PetscLogFlops(_numQuadPts * (1+_numBasis*_spaceDim*2 +
- _spaceDim*1 +
- _numBasis*_spaceDim*_cellDim*2));
-
} // computeGeometry
Modified: short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature1Din3D.hh
===================================================================
--- short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature1Din3D.hh 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature1Din3D.hh 2009-02-13 19:52:03 UTC (rev 14048)
@@ -19,40 +19,42 @@
#if !defined(pylith_feassemble_quadrature1din3d_hh)
#define pylith_feassemble_quadrature1din3d_hh
-#include "Quadrature.hh"
+#include "QuadratureEngine.hh"
namespace pylith {
namespace feassemble {
class Quadrature1Din3D;
- class TestQuadrature1Din3D;
} // feassemble
} // pylith
-class pylith::feassemble::Quadrature1Din3D : public Quadrature
+class pylith::feassemble::Quadrature1Din3D : public QuadratureEngine
{ // Quadrature1Din3D
friend class TestQuadrature1Din3D; // unit testing
// PUBLIC MEMBERS ///////////////////////////////////////////////////////
public :
- /// Constructor
- Quadrature1Din3D(void);
+ /** Constructor.
+ *
+ * @param q Quadrature information for reference cell.
+ */
+ Quadrature1Din3D(const QuadratureRefCell& q);
/// Destructor
~Quadrature1Din3D(void);
/// Create a copy of this object.
- Quadrature* clone(void) const;
+ QuadratureEngine* clone(void) const;
/** Compute geometric quantities for a cell at quadrature points.
*
- * @param mesh Finite-element mesh
- * @param coordinates Section containing vertex coordinates
+ * @param vertCoords Coordinates of vertices of finite-element cell.
+ * @param coordDim Spatial dimension of coordinate system.
* @param cell Finite-element cell
*/
- void computeGeometry(const real_section_type::value_type* vertCoords,
- const int coordDim,
- const Mesh::point_type& cell);
+ void computeGeometry(const double* vertCoords,
+ const int coordDim,
+ const int cell);
// PROTECTED METHODS ////////////////////////////////////////////////////
protected :
@@ -75,4 +77,5 @@
#endif // pylith_feassemble_quadrature1din3d_hh
+
// End of file
Modified: short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature1Din3D.icc
===================================================================
--- short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature1Din3D.icc 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature1Din3D.icc 2009-02-13 19:52:03 UTC (rev 14048)
@@ -16,7 +16,7 @@
// Create a copy of this object.
inline
-pylith::feassemble::Quadrature*
+pylith::feassemble::QuadratureEngine*
pylith::feassemble::Quadrature1Din3D::clone(void) const {
return new Quadrature1Din3D(*this);
} // clone
Modified: short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature2D.cc
===================================================================
--- short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature2D.cc 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature2D.cc 2009-02-13 19:52:03 UTC (rev 14048)
@@ -14,6 +14,7 @@
#include "Quadrature2D.hh" // implementation of class methods
+#include "QuadratureRefCell.hh" // USES QuadratureRefCell
#include "CellGeometry.hh" // USES CellGeometry
#include "petsc.h" // USES PetscLogFlops
@@ -24,7 +25,8 @@
// ----------------------------------------------------------------------
// Constructor
-pylith::feassemble::Quadrature2D::Quadrature2D(void) : Quadrature()
+pylith::feassemble::Quadrature2D::Quadrature2D(const QuadratureRefCell& q) :
+ QuadratureEngine(q)
{ // constructor
} // constructor
@@ -37,42 +39,51 @@
// ----------------------------------------------------------------------
// Copy constructor.
pylith::feassemble::Quadrature2D::Quadrature2D(const Quadrature2D& q) :
- Quadrature(q)
+ QuadratureEngine(q)
{ // copy constructor
} // copy constructor
// ----------------------------------------------------------------------
// Compute geometric quantities for a cell at quadrature points.
void
-pylith::feassemble::Quadrature2D::computeGeometry(
- const real_section_type::value_type* vertCoords,
- const int coordDim,
- const Mesh::point_type& cell)
+pylith::feassemble::Quadrature2D::computeGeometry(const double* vertCoords,
+ const int coordDim,
+ const int cell)
{ // computeGeometry
- assert(2 == _cellDim);
- assert(2 == _spaceDim);
-
- _resetGeometry();
+ assert(0 != vertCoords);
assert(2 == coordDim);
+ const int cellDim = _quadRefCell.cellDim();
+ const int spaceDim = _quadRefCell.spaceDim();
+ const int numQuadPts = _quadRefCell.numQuadPts();
+ const int numBasis = _quadRefCell.numBasis();
+
+ const double_array& basis = _quadRefCell.basis();
+ const double_array& quadPtsRef = _quadRefCell.quadPtsRef();
+ const double_array& basisDerivRef = _quadRefCell.basisDerivRef();
+ const CellGeometry& geometry = _quadRefCell.refGeometry();
+
+ assert(2 == cellDim);
+ assert(2 == spaceDim);
+ zero();
+
// Loop over quadrature points
- for (int iQuadPt=0; iQuadPt < _numQuadPts; ++iQuadPt) {
+ for (int iQuadPt=0; iQuadPt < numQuadPts; ++iQuadPt) {
// Compute coordinates of quadrature point in cell
#if defined(ISOPARAMETRIC)
// x = sum[i=0,n-1] (Ni * xi)
// y = sum[i=0,n-1] (Ni * yi)
- for (int iBasis=0; iBasis < _numBasis; ++iBasis) {
- const double basis = _basis[iQuadPt*_numBasis+iBasis];
- for (int iDim=0; iDim < _spaceDim; ++iDim)
- _quadPts[iQuadPt*_spaceDim+iDim] +=
- basis * vertCoords[iBasis*_spaceDim+iDim];
+ for (int iBasis=0; iBasis < numBasis; ++iBasis) {
+ const double valueBasis = basis[iQuadPt*numBasis+iBasis];
+ for (int iDim=0; iDim < spaceDim; ++iDim)
+ _quadPts[iQuadPt*spaceDim+iDim] +=
+ valueBasis * vertCoords[iBasis*spaceDim+iDim];
} // for
#else
- assert(0 != _geometry);
- _geometry->coordsRefToGlobal(&_quadPts[iQuadPt*_spaceDim],
- &_quadPtsRef[iQuadPt*_cellDim],
- vertCoords, _spaceDim);
+ geometry.coordsRefToGlobal(&_quadPts[iQuadPt*spaceDim],
+ &quadPtsRef[iQuadPt*cellDim],
+ vertCoords, spaceDim);
#endif
#if defined(ISOPARAMETRIC)
@@ -83,22 +94,22 @@
// dx/dq = sum[i=0,n-1] (dNi/dq * xi)
// dy/dp = sum[i=0,n-1] (dNi/dp * yi)
// dy/dq = sum[i=0,n-1] (dNi/dq * yi)
- for (int iBasis=0; iBasis < _numBasis; ++iBasis)
- for (int iCol=0; iCol < _cellDim; ++iCol) {
+ for (int iBasis=0; iBasis < numBasis; ++iBasis)
+ for (int iCol=0; iCol < cellDim; ++iCol) {
const double deriv =
- _basisDerivRef[iQuadPt*_numBasis*_spaceDim+iBasis*_cellDim+iCol];
- for (int iRow=0; iRow < _spaceDim; ++iRow)
- _jacobian[iQuadPt*_cellDim*_spaceDim+iRow*_cellDim+iCol] +=
- deriv * vertCoords[iBasis*_spaceDim+iRow];
+ basisDerivRef[iQuadPt*numBasis*spaceDim+iBasis*cellDim+iCol];
+ for (int iRow=0; iRow < spaceDim; ++iRow)
+ _jacobian[iQuadPt*cellDim*spaceDim+iRow*cellDim+iCol] +=
+ deriv * vertCoords[iBasis*spaceDim+iRow];
} // for
// Compute determinant of Jacobian at quadrature point
// |J| = j00*j11-j01*j10
- const int iJ = iQuadPt*_cellDim*_spaceDim;
- const int i00 = iJ + 0*_spaceDim + 0;
- const int i01 = iJ + 0*_spaceDim + 1;
- const int i10 = iJ + 1*_spaceDim + 0;
- const int i11 = iJ + 1*_spaceDim + 1;
+ const int iJ = iQuadPt*cellDim*spaceDim;
+ const int i00 = iJ + 0*spaceDim + 0;
+ const int i01 = iJ + 0*spaceDim + 1;
+ const int i10 = iJ + 1*spaceDim + 0;
+ const int i11 = iJ + 1*spaceDim + 1;
const double det =
_jacobian[i00]*_jacobian[i11] -
_jacobian[i01]*_jacobian[i10];
@@ -106,17 +117,16 @@
_jacobianDet[iQuadPt] = det;
#else
// Compute Jacobian and determinant of Jacobian at quadrature point
- assert(0 != _geometry);
- _geometry->jacobian(&_jacobian[iQuadPt*_cellDim*_spaceDim],
- &_jacobianDet[iQuadPt],
- vertCoords, &_quadPtsRef[iQuadPt*_cellDim], _spaceDim);
+ geometry.jacobian(&_jacobian[iQuadPt*cellDim*spaceDim],
+ &_jacobianDet[iQuadPt],
+ vertCoords, &quadPtsRef[iQuadPt*cellDim], spaceDim);
_checkJacobianDet(_jacobianDet[iQuadPt], cell);
- const int iJ = iQuadPt*_cellDim*_spaceDim;
- const int i00 = iJ + 0*_spaceDim + 0;
- const int i01 = iJ + 0*_spaceDim + 1;
- const int i10 = iJ + 1*_spaceDim + 0;
- const int i11 = iJ + 1*_spaceDim + 1;
+ const int iJ = iQuadPt*cellDim*spaceDim;
+ const int i00 = iJ + 0*spaceDim + 0;
+ const int i01 = iJ + 0*spaceDim + 1;
+ const int i10 = iJ + 1*spaceDim + 0;
+ const int i11 = iJ + 1*spaceDim + 1;
const double det = _jacobianDet[iQuadPt];
#endif
@@ -131,17 +141,17 @@
// Compute derivatives of basis functions with respect to global
// coordinates
// dNi/dx = dNi/dp dp/dx + dNi/dq dq/dx + dNi/dr dr/dx
- for (int iBasis=0; iBasis < _numBasis; ++iBasis)
- for (int iDim=0; iDim < _spaceDim; ++iDim)
- for (int jDim=0; jDim < _cellDim; ++jDim)
- _basisDeriv[iQuadPt*_numBasis*_spaceDim+iBasis*_spaceDim+iDim] +=
- _basisDerivRef[iQuadPt*_numBasis*_cellDim+iBasis*_cellDim+jDim] *
- _jacobianInv[iQuadPt*_cellDim*_spaceDim+jDim*_spaceDim+iDim];
+ for (int iBasis=0; iBasis < numBasis; ++iBasis)
+ for (int iDim=0; iDim < spaceDim; ++iDim)
+ for (int jDim=0; jDim < cellDim; ++jDim)
+ _basisDeriv[iQuadPt*numBasis*spaceDim+iBasis*spaceDim+iDim] +=
+ basisDerivRef[iQuadPt*numBasis*cellDim+iBasis*cellDim+jDim] *
+ _jacobianInv[iQuadPt*cellDim*spaceDim+jDim*spaceDim+iDim];
} // for
- PetscLogFlops(_numQuadPts*(4 +
- _numBasis*_spaceDim*2 +
- _numBasis*_spaceDim*_cellDim*2));
+ PetscLogFlops(numQuadPts*(4 +
+ numBasis*spaceDim*2 +
+ numBasis*spaceDim*cellDim*2));
} // computeGeometry
Modified: short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature2D.hh
===================================================================
--- short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature2D.hh 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature2D.hh 2009-02-13 19:52:03 UTC (rev 14048)
@@ -19,7 +19,7 @@
#if !defined(pylith_feassemble_quadrature2d_hh)
#define pylith_feassemble_quadrature2d_hh
-#include "Quadrature.hh"
+#include "QuadratureEngine.hh"
namespace pylith {
namespace feassemble {
@@ -28,31 +28,34 @@
} // feassemble
} // pylith
-class pylith::feassemble::Quadrature2D : public Quadrature
+class pylith::feassemble::Quadrature2D : public QuadratureEngine
{ // Quadrature2D
friend class TestQuadrature2D; // unit testing
// PUBLIC MEMBERS ///////////////////////////////////////////////////////
public :
- /// Constructor
- Quadrature2D(void);
+ /** Constructor.
+ *
+ * @param q Quadrature information for reference cell.
+ */
+ Quadrature2D(const QuadratureRefCell& q);
/// Destructor
~Quadrature2D(void);
/// Create a copy of this object.
- Quadrature* clone(void) const;
+ QuadratureEngine* clone(void) const;
/** Compute geometric quantities for a cell at quadrature points.
*
- * @param mesh Finite-element mesh
- * @param coordinates Section containing vertex coordinates
+ * @param vertCoords Coordinates of vertices of finite-element cell.
+ * @param coordDim Spatial dimension of coordinate system.
* @param cell Finite-element cell
*/
- void computeGeometry(const real_section_type::value_type* vertCoords,
- const int coordDim,
- const Mesh::point_type& cell);
+ void computeGeometry(const double* vertCoords,
+ const int coordDim,
+ const int cell);
// PROTECTED METHODS ////////////////////////////////////////////////////
protected :
@@ -74,4 +77,5 @@
#endif // pylith_feassemble_quadrature2d_hh
+
// End of file
Modified: short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature2D.icc
===================================================================
--- short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature2D.icc 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature2D.icc 2009-02-13 19:52:03 UTC (rev 14048)
@@ -16,7 +16,7 @@
// Create a copy of this object.
inline
-pylith::feassemble::Quadrature*
+pylith::feassemble::QuadratureEngine*
pylith::feassemble::Quadrature2D::clone(void) const {
return new Quadrature2D(*this);
} // clone
Modified: short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature2Din3D.cc
===================================================================
--- short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature2Din3D.cc 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature2Din3D.cc 2009-02-13 19:52:03 UTC (rev 14048)
@@ -14,19 +14,21 @@
#include "Quadrature2Din3D.hh" // implementation of class methods
+#include "QuadratureRefCell.hh" // USES QuadratureRefCell
#include "CellGeometry.hh" // USES CellGeometry
#include "petsc.h" // USES PetscLogFlops
#include <cmath> // USES fabs()
#include <cassert> // USES assert()
-#include <stdexcept> // USES internal_error
+#include <stdexcept> // USES std::runtime_error()
#define ISOPARAMETRIC
// ----------------------------------------------------------------------
// Constructor
-pylith::feassemble::Quadrature2Din3D::Quadrature2Din3D(void) : Quadrature()
+pylith::feassemble::Quadrature2Din3D::Quadrature2Din3D(const QuadratureRefCell& q) :
+ QuadratureEngine(q)
{ // constructor
} // constructor
@@ -39,43 +41,53 @@
// ----------------------------------------------------------------------
// Copy constructor.
pylith::feassemble::Quadrature2Din3D::Quadrature2Din3D(const Quadrature2Din3D& q) :
- Quadrature(q)
+ QuadratureEngine(q)
{ // copy constructor
} // copy constructor
// ----------------------------------------------------------------------
// Compute geometric quantities for a cell at quadrature points.
void
-pylith::feassemble::Quadrature2Din3D::computeGeometry(
- const real_section_type::value_type* vertCoords,
- const int coordDim,
- const Mesh::point_type& cell)
+pylith::feassemble::Quadrature2Din3D::computeGeometry(const double* vertCoords,
+ const int coordDim,
+ const int cell)
{ // computeGeometry
- assert(2 == _cellDim);
- assert(3 == _spaceDim);
-
- _resetGeometry();
+ assert(0 != vertCoords);
assert(3 == coordDim);
+ const int cellDim = _quadRefCell.cellDim();
+ const int spaceDim = _quadRefCell.spaceDim();
+ const int numQuadPts = _quadRefCell.numQuadPts();
+ const int numBasis = _quadRefCell.numBasis();
+
+ const double_array& basis = _quadRefCell.basis();
+ const double_array& quadPtsRef = _quadRefCell.quadPtsRef();
+ const double_array& basisDerivRef = _quadRefCell.basisDerivRef();
+ const CellGeometry& geometry = _quadRefCell.refGeometry();
+ const double minJacobian = _quadRefCell.minJacobian();
+
+ assert(2 == cellDim);
+ assert(3 == spaceDim);
+ zero();
+
// Loop over quadrature points
- for (int iQuadPt=0; iQuadPt < _numQuadPts; ++iQuadPt) {
+ for (int iQuadPt=0; iQuadPt < numQuadPts; ++iQuadPt) {
// Compute coordinates of quadrature point in cell
#if defined(ISOPARAMETRIC)
// x = sum[i=0,n-1] (Ni * xi)
// y = sum[i=0,n-1] (Ni * yi)
// z = sum[i=0,n-1] (Ni * zi)
- for (int iBasis=0; iBasis < _numBasis; ++iBasis) {
- const double basis = _basis[iQuadPt*_numBasis+iBasis];
- for (int iDim=0; iDim < _spaceDim; ++iDim)
- _quadPts[iQuadPt*_spaceDim+iDim] +=
- basis * vertCoords[iBasis*_spaceDim+iDim];
+ for (int iBasis=0; iBasis < numBasis; ++iBasis) {
+ const double valueBasis = basis[iQuadPt*numBasis+iBasis];
+ for (int iDim=0; iDim < spaceDim; ++iDim)
+ _quadPts[iQuadPt*spaceDim+iDim] +=
+ valueBasis * vertCoords[iBasis*spaceDim+iDim];
} // for
#else
- assert(0 != _geometry);
- _geometry->coordsRefToGlobal(&_quadPts[iQuadPt*_spaceDim],
- &_quadPtsRef[iQuadPt*_cellDim],
- vertCoords, _spaceDim);
+ geometry.coordsRefToGlobal(&_quadPts[iQuadPt*spaceDim],
+ &quadPtsRef[iQuadPt*cellDim],
+ vertCoords, spaceDim);
#endif
#if defined(ISOPARAMETRIC)
@@ -89,24 +101,24 @@
// dy/dq = sum[i=0,n-1] (dNi/dq * yi)
// dz/dp = sum[i=0,n-1] (dNi/dp * zi)
// dz/dq = sum[i=0,n-1] (dNi/dq * zi)
- for (int iBasis=0; iBasis < _numBasis; ++iBasis)
- for (int iCol=0; iCol < _cellDim; ++iCol) {
+ for (int iBasis=0; iBasis < numBasis; ++iBasis)
+ for (int iCol=0; iCol < cellDim; ++iCol) {
const double deriv =
- _basisDerivRef[iQuadPt*_numBasis*_cellDim+iBasis*_cellDim+iCol];
- for (int iRow=0; iRow < _spaceDim; ++iRow)
- _jacobian[iQuadPt*_cellDim*_spaceDim+iRow*_cellDim+iCol] +=
- deriv * vertCoords[iBasis*+_spaceDim+iRow];
+ basisDerivRef[iQuadPt*numBasis*cellDim+iBasis*cellDim+iCol];
+ for (int iRow=0; iRow < spaceDim; ++iRow)
+ _jacobian[iQuadPt*cellDim*spaceDim+iRow*cellDim+iCol] +=
+ deriv * vertCoords[iBasis*+spaceDim+iRow];
} // for
// Compute determinant of Jacobian at quadrature point
// |J| = sqrt(transpose(J) J)
- const int iJ = iQuadPt*_cellDim*_spaceDim;
- const int i00 = iJ + 0*_cellDim + 0;
- const int i01 = iJ + 0*_cellDim + 1;
- const int i10 = iJ + 1*_cellDim + 0;
- const int i11 = iJ + 1*_cellDim + 1;
- const int i20 = iJ + 2*_cellDim + 0;
- const int i21 = iJ + 2*_cellDim + 1;
+ const int iJ = iQuadPt*cellDim*spaceDim;
+ const int i00 = iJ + 0*cellDim + 0;
+ const int i01 = iJ + 0*cellDim + 1;
+ const int i10 = iJ + 1*cellDim + 0;
+ const int i11 = iJ + 1*cellDim + 1;
+ const int i20 = iJ + 2*cellDim + 0;
+ const int i21 = iJ + 2*cellDim + 1;
// JJ = transpose(J) J
const double jj00 =
_jacobian[i00]*_jacobian[i00] +
@@ -126,19 +138,18 @@
_jacobianDet[iQuadPt] = det;
#else
// Compute Jacobian and determinant of Jacobian at quadrature point
- assert(0 != _geometry);
- _geometry->jacobian(&_jacobian[iQuadPt*_cellDim*_spaceDim],
- &_jacobianDet[iQuadPt],
- vertCoords, &_quadPtsRef[iQuadPt*_cellDim], _spaceDim);
+ geometry.jacobian(&_jacobian[iQuadPt*cellDim*spaceDim],
+ &_jacobianDet[iQuadPt],
+ vertCoords, &quadPtsRef[iQuadPt*cellDim], spaceDim);
_checkJacobianDet(_jacobianDet[iQuadPt], cell);
- const int iJ = iQuadPt*_cellDim*_spaceDim;
- const int i00 = iJ + 0*_cellDim + 0;
- const int i01 = iJ + 0*_cellDim + 1;
- const int i10 = iJ + 1*_cellDim + 0;
- const int i11 = iJ + 1*_cellDim + 1;
- const int i20 = iJ + 2*_cellDim + 0;
- const int i21 = iJ + 2*_cellDim + 1;
+ const int iJ = iQuadPt*cellDim*spaceDim;
+ const int i00 = iJ + 0*cellDim + 0;
+ const int i01 = iJ + 0*cellDim + 1;
+ const int i10 = iJ + 1*cellDim + 0;
+ const int i11 = iJ + 1*cellDim + 1;
+ const int i20 = iJ + 2*cellDim + 0;
+ const int i21 = iJ + 2*cellDim + 1;
#endif
// Compute inverse of Jacobian at quadrature point
@@ -151,7 +162,7 @@
const double d02 =
_jacobian[i00]*_jacobian[i21] -
_jacobian[i20]*_jacobian[i01];
- if (fabs(d01) > _minJacobian) {
+ if (fabs(d01) > minJacobian) {
// Jinv00 = 1/d01 * J11
// Jinv01 = 1/d01 * -J01
// Jinv10 = 1/d01 * -J10
@@ -160,13 +171,13 @@
_jacobianInv[iJ+1] = -_jacobian[i01] / d01; // Jinv01
_jacobianInv[iJ+3] = -_jacobian[i10] / d01; // Jinv10
_jacobianInv[iJ+4] = _jacobian[i00] / d01; // Jinv11
- if (fabs(d12) > _minJacobian) {
+ if (fabs(d12) > minJacobian) {
// Jinv02 = 1/d12 -J11
// Jinv12 = 1/d12 J10
_jacobianInv[iJ+2] = -_jacobian[i11] / d12; // Jinv02
_jacobianInv[iJ+5] = _jacobian[i10] / d12; // Jinv12
- } else if (fabs(d02) > _minJacobian) {
+ } else if (fabs(d02) > minJacobian) {
// Jinv02 = 1/d02 -J01
// Jinv12 = 1/d02 J00
_jacobianInv[iJ+2] = -_jacobian[i01] / d02; // Jinv02
@@ -175,7 +186,7 @@
_jacobianInv[iJ+2] = 0.0; // Jinv02
_jacobianInv[iJ+5] = 0.0; // Jinv12
} // if/else
- } else if (fabs(d02) > _minJacobian) {
+ } else if (fabs(d02) > minJacobian) {
// Jinv00 = 1/d02 * J21
// Jinv02 = 1/d02 * -J01
// Jinv10 = 1/d02 * -J20
@@ -184,7 +195,7 @@
_jacobianInv[iJ+2] = -_jacobian[i01] / d02; // Jinv02
_jacobianInv[iJ+3] = -_jacobian[i20] / d02; // Jinv10
_jacobianInv[iJ+5] = _jacobian[i00] / d02; // Jinv12
- if (fabs(d12) > _minJacobian) {
+ if (fabs(d12) > minJacobian) {
// Jinv01 = 1/d12 J21
// Jinv11 = 1/d12 -J20
_jacobianInv[iJ+1] = -_jacobian[i21] / d12; // Jinv01
@@ -193,7 +204,7 @@
_jacobianInv[iJ+1] = 0.0; // Jinv01
_jacobianInv[iJ+4] = 0.0; // Jinv11
} // if/else
- } else if (fabs(d12) > _minJacobian) {
+ } else if (fabs(d12) > minJacobian) {
_jacobianInv[iJ+0] = 0.0; // Jinv00
_jacobianInv[iJ+3] = 0.0; // Jinv10
// Jinv01 = 1/d12 J21
@@ -210,17 +221,17 @@
// Compute derivatives of basis functions with respect to global
// coordinates
// dNi/dx = dNi/dp dp/dx + dNi/dq dq/dx + dNi/dr dr/dx
- for (int iBasis=0; iBasis < _numBasis; ++iBasis)
- for (int iDim=0; iDim < _spaceDim; ++iDim)
- for (int jDim=0; jDim < _cellDim; ++jDim)
- _basisDeriv[iQuadPt*_numBasis*_spaceDim+iBasis*_spaceDim+iDim] +=
- _basisDerivRef[iQuadPt*_numBasis*_cellDim + iBasis*_cellDim+jDim] *
- _jacobianInv[iQuadPt*_cellDim*_spaceDim+jDim*_spaceDim+iDim];
+ for (int iBasis=0; iBasis < numBasis; ++iBasis)
+ for (int iDim=0; iDim < spaceDim; ++iDim)
+ for (int jDim=0; jDim < cellDim; ++jDim)
+ _basisDeriv[iQuadPt*numBasis*spaceDim+iBasis*spaceDim+iDim] +=
+ basisDerivRef[iQuadPt*numBasis*cellDim + iBasis*cellDim+jDim] *
+ _jacobianInv[iQuadPt*cellDim*spaceDim+jDim*spaceDim+iDim];
} // for
-
- PetscLogFlops(_numQuadPts*(15 +
- _numBasis*_spaceDim*2 +
- _numBasis*_spaceDim*_cellDim*2));
+
+ PetscLogFlops(numQuadPts*(15 +
+ numBasis*spaceDim*2 +
+ numBasis*spaceDim*cellDim*2));
} // computeGeometry
Modified: short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature2Din3D.hh
===================================================================
--- short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature2Din3D.hh 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature2Din3D.hh 2009-02-13 19:52:03 UTC (rev 14048)
@@ -19,7 +19,7 @@
#if !defined(pylith_feassemble_quadrature2din3d_hh)
#define pylith_feassemble_quadrature2din3d_hh
-#include "Quadrature.hh"
+#include "QuadratureEngine.hh"
namespace pylith {
namespace feassemble {
@@ -28,31 +28,34 @@
} // feassemble
} // pylith
-class pylith::feassemble::Quadrature2Din3D : public Quadrature
+class pylith::feassemble::Quadrature2Din3D : public QuadratureEngine
{ // Quadrature2Din3D
friend class TestQuadrature2Din3D; // unit testing
// PUBLIC MEMBERS ///////////////////////////////////////////////////////
public :
- /// Constructor
- Quadrature2Din3D(void);
+ /** Constructor.
+ *
+ * @param q Quadrature information for reference cell.
+ */
+ Quadrature2Din3D(const QuadratureRefCell& q);
/// Destructor
~Quadrature2Din3D(void);
/// Create a copy of this object.
- Quadrature* clone(void) const;
+ QuadratureEngine* clone(void) const;
/** Compute geometric quantities for a cell at quadrature points.
*
- * @param mesh Finite-element mesh
- * @param coordinates Section containing vertex coordinates
+ * @param vertCoords Coordinates of vertices of finite-element cell.
+ * @param coordDim Spatial dimension of coordinate system.
* @param cell Finite-element cell
*/
- void computeGeometry(const real_section_type::value_type* vertCoords,
- const int coordDim,
- const Mesh::point_type& cell);
+ void computeGeometry(const double* vertCoords,
+ const int coordDim,
+ const int cell);
// PROTECTED METHODS ////////////////////////////////////////////////////
protected :
@@ -75,4 +78,5 @@
#endif // pylith_feassemble_quadrature2din3d_hh
+
// End of file
Modified: short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature2Din3D.icc
===================================================================
--- short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature2Din3D.icc 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature2Din3D.icc 2009-02-13 19:52:03 UTC (rev 14048)
@@ -16,7 +16,7 @@
// Create a copy of this object.
inline
-pylith::feassemble::Quadrature*
+pylith::feassemble::QuadratureEngine*
pylith::feassemble::Quadrature2Din3D::clone(void) const {
return new Quadrature2Din3D(*this);
} // clone
Modified: short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature3D.cc
===================================================================
--- short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature3D.cc 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature3D.cc 2009-02-13 19:52:03 UTC (rev 14048)
@@ -14,6 +14,7 @@
#include "Quadrature3D.hh" // implementation of class methods
+#include "QuadratureRefCell.hh" // USES QuadratureRefCell
#include "CellGeometry.hh" // USES CellGeometry
#include "petsc.h" // USES PetscLogFlops
@@ -24,7 +25,8 @@
// ----------------------------------------------------------------------
// Constructor
-pylith::feassemble::Quadrature3D::Quadrature3D(void)
+pylith::feassemble::Quadrature3D::Quadrature3D(const QuadratureRefCell& q) :
+ QuadratureEngine(q)
{ // constructor
} // constructor
@@ -37,7 +39,7 @@
// ----------------------------------------------------------------------
// Copy constructor.
pylith::feassemble::Quadrature3D::Quadrature3D(const Quadrature3D& q) :
- Quadrature(q)
+ QuadratureEngine(q)
{ // copy constructor
} // copy constructor
@@ -48,21 +50,23 @@
const int coordDim,
const int cell)
{ // computeGeometry
+ assert(0 != vertCoords);
+ assert(3 == coordDim);
+
const int cellDim = _quadRefCell.cellDim();
const int spaceDim = _quadRefCell.spaceDim();
const int numQuadPts = _quadRefCell.numQuadPts();
const int numBasis = _quadRefCell.numBasis();
const double_array& basis = _quadRefCell.basis();
- const double_array& quadPtsRef = _quadRefCell.quadPts();
- const CellGeometry* geometry = _quadRefCell.cellGeometry();
+ const double_array& quadPtsRef = _quadRefCell.quadPtsRef();
+ const double_array& basisDerivRef = _quadRefCell.basisDerivRef();
+ const CellGeometry& geometry = _quadRefCell.refGeometry();
assert(3 == cellDim);
assert(3 == spaceDim);
-
- _resetGeometry();
- assert(3 == coordDim);
-
+ zero();
+
// Loop over quadrature points
for (int iQuadPt=0; iQuadPt < numQuadPts; ++iQuadPt) {
@@ -72,16 +76,15 @@
// y = sum[i=0,n-1] (Ni * yi)
// z = sum[i=0,n-1] (Ni * zi)
for (int iBasis=0; iBasis < numBasis; ++iBasis) {
- const double basis = basis[iQuadPt*_numBasis+iBasis];
- for (int iDim=0; iDim < _spaceDim; ++iDim)
- _quadPts[iQuadPt*_spaceDim+iDim] +=
- basis * vertCoords[iBasis*spaceDim+iDim];
+ const double valueBasis = basis[iQuadPt*numBasis+iBasis];
+ for (int iDim=0; iDim < spaceDim; ++iDim)
+ _quadPts[iQuadPt*spaceDim+iDim] +=
+ valueBasis * vertCoords[iBasis*spaceDim+iDim];
} // for
#else
- assert(0 != geometry);
- geometry->coordsRefToGlobal(&quadPts[iQuadPt*spaceDim],
- &_quadPtsRef[iQuadPt*cellDim],
- vertCoords, spaceDim);
+ geometry.coordsRefToGlobal(&quadPts[iQuadPt*spaceDim],
+ &quadPtsRef[iQuadPt*cellDim],
+ vertCoords, spaceDim);
#endif
#if defined(ISOPARAMETRIC)
@@ -98,29 +101,29 @@
// dz/dp = sum[i=0,n-1] (dNi/dp * zi)
// dz/dq = sum[i=0,n-1] (dNi/dq * zi)
// dz/dr = sum[i=0,n-1] (dNi/dr * zi)
- for (int iBasis=0; iBasis < _numBasis; ++iBasis)
- for (int iCol=0; iCol < _cellDim; ++iCol) {
+ for (int iBasis=0; iBasis < numBasis; ++iBasis)
+ for (int iCol=0; iCol < cellDim; ++iCol) {
const double deriv =
- _basisDerivRef[iQuadPt*_numBasis*_spaceDim+iBasis*_cellDim+iCol];
- for (int iRow=0; iRow < _spaceDim; ++iRow)
- _jacobian[iQuadPt*_cellDim*_spaceDim+iRow*_cellDim+iCol] +=
- deriv * vertCoords[iBasis*_spaceDim+iRow];
+ basisDerivRef[iQuadPt*numBasis*spaceDim+iBasis*cellDim+iCol];
+ for (int iRow=0; iRow < spaceDim; ++iRow)
+ _jacobian[iQuadPt*cellDim*spaceDim+iRow*cellDim+iCol] +=
+ deriv * vertCoords[iBasis*spaceDim+iRow];
} // for
// Compute determinant of Jacobian at quadrature point
// |J| = j00*(j11*j22-j12*j21) +
// -j01*(j10*j22-j12*j20) +
// j02*(j10*j21-j11*j20)
- const int iJ = iQuadPt*_cellDim*_spaceDim;
- const int i00 = iJ + 0*_spaceDim + 0;
- const int i01 = iJ + 0*_spaceDim + 1;
- const int i02 = iJ + 0*_spaceDim + 2;
- const int i10 = iJ + 1*_spaceDim + 0;
- const int i11 = iJ + 1*_spaceDim + 1;
- const int i12 = iJ + 1*_spaceDim + 2;
- const int i20 = iJ + 2*_spaceDim + 0;
- const int i21 = iJ + 2*_spaceDim + 1;
- const int i22 = iJ + 2*_spaceDim + 2;
+ const int iJ = iQuadPt*cellDim*spaceDim;
+ const int i00 = iJ + 0*spaceDim + 0;
+ const int i01 = iJ + 0*spaceDim + 1;
+ const int i02 = iJ + 0*spaceDim + 2;
+ const int i10 = iJ + 1*spaceDim + 0;
+ const int i11 = iJ + 1*spaceDim + 1;
+ const int i12 = iJ + 1*spaceDim + 2;
+ const int i20 = iJ + 2*spaceDim + 0;
+ const int i21 = iJ + 2*spaceDim + 1;
+ const int i22 = iJ + 2*spaceDim + 2;
const double det =
_jacobian[i00]*(_jacobian[i11]*_jacobian[i22] -
_jacobian[i12]*_jacobian[i21]) -
@@ -132,22 +135,21 @@
_jacobianDet[iQuadPt] = det;
#else
// Compute Jacobian and determinant of Jacobian at quadrature point
- assert(0 != _geometry);
- _geometry->jacobian(&_jacobian[iQuadPt*_cellDim*_spaceDim],
- &_jacobianDet[iQuadPt],
- vertCoords, &_quadPtsRef[iQuadPt*_cellDim], _spaceDim);
+ geometry.jacobian(&_jacobian[iQuadPt*cellDim*spaceDim],
+ &_jacobianDet[iQuadPt],
+ vertCoords, &quadPtsRef[iQuadPt*cellDim], spaceDim);
_checkJacobianDet(_jacobianDet[iQuadPt], cell);
- const int iJ = iQuadPt*_cellDim*_spaceDim;
- const int i00 = iJ + 0*_spaceDim + 0;
- const int i01 = iJ + 0*_spaceDim + 1;
- const int i02 = iJ + 0*_spaceDim + 2;
- const int i10 = iJ + 1*_spaceDim + 0;
- const int i11 = iJ + 1*_spaceDim + 1;
- const int i12 = iJ + 1*_spaceDim + 2;
- const int i20 = iJ + 2*_spaceDim + 0;
- const int i21 = iJ + 2*_spaceDim + 1;
- const int i22 = iJ + 2*_spaceDim + 2;
+ const int iJ = iQuadPt*cellDim*spaceDim;
+ const int i00 = iJ + 0*spaceDim + 0;
+ const int i01 = iJ + 0*spaceDim + 1;
+ const int i02 = iJ + 0*spaceDim + 2;
+ const int i10 = iJ + 1*spaceDim + 0;
+ const int i11 = iJ + 1*spaceDim + 1;
+ const int i12 = iJ + 1*spaceDim + 2;
+ const int i20 = iJ + 2*spaceDim + 0;
+ const int i21 = iJ + 2*spaceDim + 1;
+ const int i22 = iJ + 2*spaceDim + 2;
const double det = _jacobianDet[iQuadPt];
#endif
@@ -174,16 +176,16 @@
// Compute derivatives of basis functions with respect to global
// coordinates
// dNi/dx = dNi/dp dp/dx + dNi/dq dq/dx + dNi/dr dr/dx
- for (int iBasis=0; iBasis < _numBasis; ++iBasis)
- for (int iDim=0; iDim < _spaceDim; ++iDim)
- for (int jDim=0; jDim < _cellDim; ++jDim)
- _basisDeriv[iQuadPt*_numBasis*_spaceDim+iBasis*_spaceDim+iDim] +=
- _basisDerivRef[iQuadPt*_numBasis*_cellDim+iBasis*_cellDim+jDim] *
- _jacobianInv[iQuadPt*_cellDim*_spaceDim+jDim*_spaceDim+iDim];
+ for (int iBasis=0; iBasis < numBasis; ++iBasis)
+ for (int iDim=0; iDim < spaceDim; ++iDim)
+ for (int jDim=0; jDim < cellDim; ++jDim)
+ _basisDeriv[iQuadPt*numBasis*spaceDim+iBasis*spaceDim+iDim] +=
+ basisDerivRef[iQuadPt*numBasis*cellDim+iBasis*cellDim+jDim] *
+ _jacobianInv[iQuadPt*cellDim*spaceDim+jDim*spaceDim+iDim];
} // for
-
- PetscLogFlops(_numQuadPts*(2+36 +
- _numBasis*_spaceDim*_cellDim*4));
+
+ PetscLogFlops(numQuadPts*(2+36 +
+ numBasis*spaceDim*cellDim*4));
} // computeGeometry
Modified: short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature3D.hh
===================================================================
--- short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature3D.hh 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/Quadrature3D.hh 2009-02-13 19:52:03 UTC (rev 14048)
@@ -28,8 +28,11 @@
// PUBLIC MEMBERS ///////////////////////////////////////////////////////
public :
- /// Constructor
- Quadrature3D(void);
+ /** Constructor.
+ *
+ * @param q Quadrature information for reference cell.
+ */
+ Quadrature3D(const QuadratureRefCell& q);
/// Destructor
~Quadrature3D(void);
@@ -39,8 +42,8 @@
/** Compute geometric quantities for a cell at quadrature points.
*
- * @param mesh Finite-element mesh
- * @param coordinates Section containing vertex coordinates
+ * @param vertCoords Coordinates of vertices of finite-element cell.
+ * @param coordDim Spatial dimension of coordinate system.
* @param cell Finite-element cell
*/
void computeGeometry(const double* vertCoords,
Modified: short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/QuadratureEngine.cc
===================================================================
--- short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/QuadratureEngine.cc 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/QuadratureEngine.cc 2009-02-13 19:52:03 UTC (rev 14048)
@@ -17,6 +17,9 @@
#include "CellGeometry.hh" // USES CellGeometry
#include "QuadratureRefCell.hh" // QuadratureRefCell
+#include <sstream> // USES std::ostringstream
+#include <stdexcept> // USES std::runtime_error
+
// ----------------------------------------------------------------------
// Constructor.
pylith::feassemble::QuadratureEngine::QuadratureEngine(const QuadratureRefCell& q) :
@@ -40,11 +43,19 @@
const int cellDim = _quadRefCell.cellDim();
const int spaceDim = _quadRefCell.spaceDim();
- _quadPts.resize(numQuadPts*spaceDim);
- _jacobian.resize(numQuadPts*cellDim*spaceDim);
- _jacobianInv.resize(numQuadPts*cellDim*spaceDim);
- _jacobianDet.resize(numQuadPts);
- _basisDeriv.resize(numQuadPts*numBasis*spaceDim);
+ if (cellDim > 0) {
+ _quadPts.resize(numQuadPts*spaceDim);
+ _jacobian.resize(numQuadPts*cellDim*spaceDim);
+ _jacobianInv.resize(numQuadPts*cellDim*spaceDim);
+ _jacobianDet.resize(numQuadPts);
+ _basisDeriv.resize(numQuadPts*numBasis*spaceDim);
+ } else {
+ _quadPts.resize(numQuadPts*spaceDim);
+ _jacobian.resize(1);
+ _jacobianInv.resize(1);
+ _jacobianDet.resize(1);
+ _basisDeriv.resize(numQuadPts*numBasis*spaceDim);
+ } // if/else
} // initialize
// ----------------------------------------------------------------------
@@ -71,5 +82,21 @@
{ // copy constructor
} // copy constructor
+// ----------------------------------------------------------------------
+// Check determinant of Jacobian against minimum allowable value
+void
+pylith::feassemble::QuadratureEngine::_checkJacobianDet(const double det,
+ const int cell) const
+{ // _checkJacobianDet
+ const double minJacobian = _quadRefCell.minJacobian();
+ if (det < minJacobian) {
+ std::ostringstream msg;
+ msg << "Determinant of Jacobian (" << det << ") for cell " << cell
+ << " is smaller than minimum permissible value (" << minJacobian
+ << ")!\n";
+ throw std::runtime_error(msg.str());
+ } // if
+} // _checkJacobianDet
+
// End of file
Modified: short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/QuadratureEngine.hh
===================================================================
--- short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/QuadratureEngine.hh 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/QuadratureEngine.hh 2009-02-13 19:52:03 UTC (rev 14048)
@@ -24,6 +24,7 @@
class pylith::feassemble::QuadratureEngine
{ // QuadratureEngine
+ friend class TestQuadratureEngine;
// PUBLIC MEMBERS ///////////////////////////////////////////////////////
public :
@@ -95,9 +96,17 @@
*/
QuadratureEngine(const QuadratureEngine& q);
-// PRIVATE MEMBERS //////////////////////////////////////////////////////
-private :
+ /* Check determinant of Jacobian against minimum allowable value.
+ *
+ * @param det Value of determinant of Jacobian
+ * @param cell Label of finite-element cell
+ */
+ void _checkJacobianDet(const double det,
+ const int cell) const;
+// PROTECTED MEMBERS ////////////////////////////////////////////////////
+protected :
+
/** Buffers for cell data */
double_array _quadPts; ///< Coordinates of quad pts.
double_array _jacobian; ///< Jacobian at quad pts;
Modified: short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/QuadratureRefCell.cc
===================================================================
--- short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/QuadratureRefCell.cc 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/QuadratureRefCell.cc 2009-02-13 19:52:03 UTC (rev 14048)
@@ -181,20 +181,5 @@
return *_geometry;
} // refGeometry
-// ----------------------------------------------------------------------
-// Check determinant of Jacobian against minimum allowable value
-void
-pylith::feassemble::QuadratureRefCell::_checkJacobianDet(const double det,
- const int cell) const
-{ // _checkJacobianDet
- if (det < _minJacobian) {
- std::ostringstream msg;
- msg << "Determinant of Jacobian (" << det << ") for cell " << cell
- << " is smaller than minimum permissible value (" << _minJacobian
- << ")!\n";
- throw std::runtime_error(msg.str());
- } // if
-} // _checkJacobianDet
-
// End of file
Modified: short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/QuadratureRefCell.hh
===================================================================
--- short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/QuadratureRefCell.hh 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/QuadratureRefCell.hh 2009-02-13 19:52:03 UTC (rev 14048)
@@ -131,6 +131,12 @@
*/
const double_array& basis(void) const;
+ /** Get derivates of basis fns evaluated at quadrature points.
+ *
+ * @returns Array of derivates of basis fns evaluated at quadrature points
+ */
+ const double_array& basisDerivRef(void) const;
+
/** Get number of dimensions in reference cell.
*
* @returns Number of dimensions in reference cell
@@ -164,14 +170,6 @@
*/
QuadratureRefCell(const QuadratureRefCell& q);
- /* Check determinant of Jacobian against minimum allowable value.
- *
- * @param det Value of determinant of Jacobian
- * @param cell Label of finite-element cell
- */
- void _checkJacobianDet(const double det,
- const int cell) const;
-
// PROTECTED MEMBERS ////////////////////////////////////////////////////
protected :
Modified: short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/QuadratureRefCell.icc
===================================================================
--- short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/QuadratureRefCell.icc 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/libsrc/feassemble/QuadratureRefCell.icc 2009-02-13 19:52:03 UTC (rev 14048)
@@ -49,6 +49,13 @@
return _basis;
}
+// Get derivates of basis fns evaluated at quadrature points.
+inline
+const pylith::double_array&
+pylith::feassemble::QuadratureRefCell::basisDerivRef(void) const {
+ return _basisDerivRef;
+}
+
// Get number of dimensions in reference cell.
inline
int
Modified: short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/Makefile.am
===================================================================
--- short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/Makefile.am 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/Makefile.am 2009-02-13 19:52:03 UTC (rev 14048)
@@ -34,18 +34,19 @@
TestGeometryQuad3D.cc \
TestGeometryTet3D.cc \
TestGeometryHex3D.cc \
- TestQuadratureBase.cc \
- TestQuadrature.cc \
+ TestQuadratureRefCell.cc \
+ TestQuadratureEngine.cc \
+ TestQuadrature0D.cc \
+ TestQuadrature1D.cc \
+ TestQuadrature1Din2D.cc \
+ TestQuadrature1Din3D.cc \
+ TestQuadrature2D.cc \
+ TestQuadrature2Din3D.cc \
TestQuadrature3D.cc \
test_feassemble.cc
# TestIntegrator.cc \
# TestIntegratorElasticity.cc \
-# TestQuadrature0D.cc \
-# TestQuadrature1D.cc \
-# TestQuadrature1Din2D.cc \
-# TestQuadrature2D.cc \
-# TestQuadrature2Din3D.cc \
# TestElasticityExplicit.cc \
# TestElasticityExplicit1DLinear.cc \
# TestElasticityExplicit1DQuadratic.cc \
Modified: short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature0D.cc
===================================================================
--- short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature0D.cc 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature0D.cc 2009-02-13 19:52:03 UTC (rev 14048)
@@ -15,6 +15,7 @@
#include "TestQuadrature0D.hh" // Implementation of class methods
#include "pylith/feassemble/Quadrature0D.hh"
+#include "pylith/feassemble/QuadratureRefCell.hh"
// ----------------------------------------------------------------------
CPPUNIT_TEST_SUITE_REGISTRATION( pylith::feassemble::TestQuadrature0D );
@@ -24,7 +25,8 @@
void
pylith::feassemble::TestQuadrature0D::testConstructor(void)
{ // testConstructor
- Quadrature0D quadrature;
+ QuadratureRefCell refCell;
+ Quadrature0D quadrature(refCell);
} // testConstructor
// ----------------------------------------------------------------------
@@ -52,48 +54,24 @@
const double minJacobian = 1.0e-06;
- Quadrature0D quadrature;
+ QuadratureRefCell refCell;
+ refCell.minJacobian(minJacobian);
+ refCell.initialize(basis, basisDeriv, quadPtsRef, quadWts,
+ cellDim, numBasis, numQuadPts, spaceDim);
- quadrature.minJacobian(minJacobian);
- quadrature.initialize(basis, basisDeriv, quadPtsRef, quadWts,
- cellDim, numBasis, numQuadPts, spaceDim);
+ Quadrature0D engine(refCell);
- // Create mesh with test cell
- ALE::Obj<Mesh> mesh = new Mesh(PETSC_COMM_WORLD, cellDim);
- CPPUNIT_ASSERT(!mesh.isNull());
- ALE::Obj<sieve_type> sieve = new sieve_type(mesh->comm());
- CPPUNIT_ASSERT(!sieve.isNull());
+ engine.initialize();
+ engine.computeGeometry(vertCoords, spaceDim, 0);
- const bool interpolate = false;
- ALE::Obj<ALE::Mesh::sieve_type> s = new ALE::Mesh::sieve_type(sieve->comm(), sieve->debug());
-
- ALE::SieveBuilder<ALE::Mesh>::buildTopology(s, cellDim, numCells,
- (int*) cells, numVertices, interpolate, numBasis);
- std::map<Mesh::point_type,Mesh::point_type> renumbering;
- ALE::ISieveConverter::convertSieve(*s, *sieve, renumbering);
- mesh->setSieve(sieve);
- mesh->stratify();
- ALE::SieveBuilder<Mesh>::buildCoordinates(mesh, spaceDim, vertCoords);
-
- // Check values from computeGeometry()
- const ALE::Obj<Mesh::label_sequence>& cellsMesh = mesh->heightStratum(0);
- CPPUNIT_ASSERT(!cellsMesh.isNull());
- const Mesh::label_sequence::iterator e_iter = cellsMesh->begin();
- const ALE::Obj<Mesh::real_section_type>& coordinates =
- mesh->getRealSection("coordinates");
- CPPUNIT_ASSERT(!coordinates.isNull());
- quadrature.Quadrature::computeGeometry(mesh, coordinates, *e_iter);
-
- CPPUNIT_ASSERT(1 == numCells);
-
const double tolerance = 1.0e-06;
- CPPUNIT_ASSERT_DOUBLES_EQUAL(quadPts[0], quadrature._quadPts[0],
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(quadPts[0], engine._quadPts[0],
tolerance);
- CPPUNIT_ASSERT_DOUBLES_EQUAL(jacobian[0], quadrature._jacobian[0],
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(jacobian[0], engine._jacobian[0],
tolerance);
- CPPUNIT_ASSERT_DOUBLES_EQUAL(jacobianInv[0], quadrature._jacobianInv[0],
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(jacobianInv[0], engine._jacobianInv[0],
tolerance);
- CPPUNIT_ASSERT_DOUBLES_EQUAL(jacobianDet[0], quadrature._jacobianDet[0],
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(jacobianDet[0], engine._jacobianDet[0],
tolerance);
} // testPoint
Modified: short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature0D.hh
===================================================================
--- short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature0D.hh 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature0D.hh 2009-02-13 19:52:03 UTC (rev 14048)
@@ -21,7 +21,7 @@
#if !defined(pylith_feassemble_testquadrature0d_hh)
#define pylith_feassemble_testquadrature0d_hh
-#include "TestQuadrature.hh"
+#include "TestQuadratureEngine.hh"
/// Namespace for pylith package
namespace pylith {
@@ -31,13 +31,15 @@
} // pylith
/// C++ unit testing for Quadrature0D
-class pylith::feassemble::TestQuadrature0D : public TestQuadrature
+class pylith::feassemble::TestQuadrature0D : public TestQuadratureEngine
{ // class TestQuadrature0D
// CPPUNIT TEST SUITE /////////////////////////////////////////////////
CPPUNIT_TEST_SUITE( TestQuadrature0D );
+
CPPUNIT_TEST( testConstructor );
CPPUNIT_TEST( testPoint );
+
CPPUNIT_TEST_SUITE_END();
// PUBLIC METHODS /////////////////////////////////////////////////////
Modified: short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature1D.cc
===================================================================
--- short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature1D.cc 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature1D.cc 2009-02-13 19:52:03 UTC (rev 14048)
@@ -15,6 +15,7 @@
#include "TestQuadrature1D.hh" // Implementation of class methods
#include "pylith/feassemble/Quadrature1D.hh"
+#include "pylith/feassemble/QuadratureRefCell.hh"
#include "pylith/feassemble/GeometryLine1D.hh"
#include "data/QuadratureData1DLinear.hh"
@@ -28,7 +29,8 @@
void
pylith::feassemble::TestQuadrature1D::testConstructor(void)
{ // testConstructor
- Quadrature1D quadrature;
+ QuadratureRefCell refCell;
+ Quadrature1D quadrature(refCell);
} // testConstructor
// ----------------------------------------------------------------------
@@ -36,12 +38,14 @@
void
pylith::feassemble::TestQuadrature1D::testLinear(void)
{ // testLinear
- Quadrature1D q;
GeometryLine1D geometry;
- q.refGeometry(&geometry);
+ QuadratureRefCell refCell;
+ refCell.refGeometry(&geometry);
+
+ Quadrature1D q(refCell);
QuadratureData1DLinear data;
- _testComputeGeometry(&q, data);
+ _testComputeGeometry(&q, &refCell, data);
} // testLinear
// ----------------------------------------------------------------------
@@ -49,12 +53,14 @@
void
pylith::feassemble::TestQuadrature1D::testQuadratic(void)
{ // testQuadratic
- Quadrature1D q;
GeometryLine1D geometry;
- q.refGeometry(&geometry);
+ QuadratureRefCell refCell;
+ refCell.refGeometry(&geometry);
+
+ Quadrature1D q(refCell);
QuadratureData1DQuadratic data;
- _testComputeGeometry(&q, data);
+ _testComputeGeometry(&q, &refCell, data);
} // testQuadratic
Modified: short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature1D.hh
===================================================================
--- short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature1D.hh 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature1D.hh 2009-02-13 19:52:03 UTC (rev 14048)
@@ -21,7 +21,7 @@
#if !defined(pylith_feassemble_testquadrature1d_hh)
#define pylith_feassemble_testquadrature1d_hh
-#include "TestQuadrature.hh"
+#include "TestQuadratureEngine.hh" // ISA TestQuadratureEngine
/// Namespace for pylith package
namespace pylith {
@@ -31,14 +31,16 @@
} // pylith
/// C++ unit testing for Quadrature1D
-class pylith::feassemble::TestQuadrature1D : public TestQuadrature
+class pylith::feassemble::TestQuadrature1D : public TestQuadratureEngine
{ // class TestQuadrature1D
// CPPUNIT TEST SUITE /////////////////////////////////////////////////
CPPUNIT_TEST_SUITE( TestQuadrature1D );
+
CPPUNIT_TEST( testConstructor );
CPPUNIT_TEST( testLinear );
CPPUNIT_TEST( testQuadratic );
+
CPPUNIT_TEST_SUITE_END();
// PUBLIC METHODS /////////////////////////////////////////////////////
@@ -57,4 +59,5 @@
#endif // pylith_feassemble_testquadrature1d_hh
+
// End of file
Modified: short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature1Din2D.cc
===================================================================
--- short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature1Din2D.cc 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature1Din2D.cc 2009-02-13 19:52:03 UTC (rev 14048)
@@ -15,6 +15,7 @@
#include "TestQuadrature1Din2D.hh" // Implementation of class methods
#include "pylith/feassemble/Quadrature1Din2D.hh"
+#include "pylith/feassemble/QuadratureRefCell.hh"
#include "pylith/feassemble/GeometryLine2D.hh"
#include "data/QuadratureData1Din2DLinear.hh"
@@ -28,7 +29,8 @@
void
pylith::feassemble::TestQuadrature1Din2D::testConstructor(void)
{ // testConstructor
- Quadrature1Din2D quadrature;
+ QuadratureRefCell refCell;
+ Quadrature1Din2D quadrature(refCell);
} // testConstructor
// ----------------------------------------------------------------------
@@ -36,12 +38,14 @@
void
pylith::feassemble::TestQuadrature1Din2D::testLinear(void)
{ // testLinear
- Quadrature1Din2D q;
GeometryLine2D geometry;
- q.refGeometry(&geometry);
+ QuadratureRefCell refCell;
+ refCell.refGeometry(&geometry);
+
+ Quadrature1Din2D q(refCell);
QuadratureData1Din2DLinear data;
- _testComputeGeometry(&q, data);
+ _testComputeGeometry(&q, &refCell, data);
} // testLinear
// ----------------------------------------------------------------------
@@ -49,12 +53,14 @@
void
pylith::feassemble::TestQuadrature1Din2D::testQuadratic(void)
{ // testQuadratic
- Quadrature1Din2D q;
GeometryLine2D geometry;
- q.refGeometry(&geometry);
+ QuadratureRefCell refCell;
+ refCell.refGeometry(&geometry);
+
+ Quadrature1Din2D q(refCell);
QuadratureData1Din2DQuadratic data;
- _testComputeGeometry(&q, data);
+ _testComputeGeometry(&q, &refCell, data);
} // testQuadratic
// End of file
Modified: short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature1Din2D.hh
===================================================================
--- short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature1Din2D.hh 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature1Din2D.hh 2009-02-13 19:52:03 UTC (rev 14048)
@@ -21,7 +21,7 @@
#if !defined(pylith_feassemble_testquadrature1din2d_hh)
#define pylith_feassemble_testquadrature1din2d_hh
-#include "TestQuadrature.hh"
+#include "TestQuadratureEngine.hh"
/// Namespace for pylith package
namespace pylith {
@@ -31,14 +31,16 @@
} // pylith
/// C++ unit testing for Quadrature1Din2D
-class pylith::feassemble::TestQuadrature1Din2D : public TestQuadrature
+class pylith::feassemble::TestQuadrature1Din2D : public TestQuadratureEngine
{ // class TestQuadrature1D
// CPPUNIT TEST SUITE /////////////////////////////////////////////////
CPPUNIT_TEST_SUITE( TestQuadrature1Din2D );
+
CPPUNIT_TEST( testConstructor );
CPPUNIT_TEST( testLinear );
CPPUNIT_TEST( testQuadratic );
+
CPPUNIT_TEST_SUITE_END();
// PUBLIC METHODS /////////////////////////////////////////////////////
@@ -57,4 +59,5 @@
#endif // pylith_feassemble_testquadrature1din2d_hh
+
// End of file
Modified: short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature1Din3D.cc
===================================================================
--- short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature1Din3D.cc 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature1Din3D.cc 2009-02-13 19:52:03 UTC (rev 14048)
@@ -15,7 +15,8 @@
#include "TestQuadrature1Din3D.hh" // Implementation of class methods
#include "pylith/feassemble/Quadrature1Din3D.hh"
-#include "pylith/feassemble/GeomertyLine3D.hh"
+#include "pylith/feassemble/QuadratureRefCell.hh"
+#include "pylith/feassemble/GeometryLine3D.hh"
#include "data/QuadratureData1Din3DLinear.hh"
#include "data/QuadratureData1Din3DQuadratic.hh"
@@ -28,7 +29,8 @@
void
pylith::feassemble::TestQuadrature1Din3D::testConstructor(void)
{ // testConstructor
- Quadrature1Din3D quadrature;
+ QuadratureRefCell refCell;
+ Quadrature1Din3D quadrature(refCell);
} // testConstructor
// ----------------------------------------------------------------------
@@ -36,12 +38,14 @@
void
pylith::feassemble::TestQuadrature1Din3D::testLinear(void)
{ // testLinear
- Quadrature1Din3D q;
GeometryLine3D geometry;
- q.refGeometry(&geometry);
+ QuadratureRefCell refCell;
+ refCell.refGeometry(&geometry);
+
+ Quadrature1Din3D q(refCell);
QuadratureData1Din3DLinear data;
- _testComputeGeometry(&q, data);
+ _testComputeGeometry(&q, &refCell, data);
} // testLinear
// ----------------------------------------------------------------------
@@ -49,12 +53,14 @@
void
pylith::feassemble::TestQuadrature1Din3D::testQuadratic(void)
{ // testQuadratic
- Quadrature1Din3D q;
GeometryLine3D geometry;
- q.refGeometry(&geometry);
+ QuadratureRefCell refCell;
+ refCell.refGeometry(&geometry);
+
+ Quadrature1Din3D q(refCell);
QuadratureData1Din3DQuadratic data;
- _testComputeGeometry(&q, data);
+ _testComputeGeometry(&q, &refCell, data);
} // testQuadratic
// End of file
Modified: short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature1Din3D.hh
===================================================================
--- short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature1Din3D.hh 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature1Din3D.hh 2009-02-13 19:52:03 UTC (rev 14048)
@@ -21,7 +21,7 @@
#if !defined(pylith_feassemble_testquadrature1din3d_hh)
#define pylith_feassemble_testquadrature1din3d_hh
-#include "TestQuadrature.hh"
+#include "TestQuadratureEngine.hh"
/// Namespace for pylith package
namespace pylith {
@@ -31,14 +31,16 @@
} // pylith
/// C++ unit testing for Quadrature1Din3D
-class pylith::feassemble::TestQuadrature1Din3D : public TestQuadrature
+class pylith::feassemble::TestQuadrature1Din3D : public TestQuadratureEngine
{ // class TestQuadrature1D
// CPPUNIT TEST SUITE /////////////////////////////////////////////////
CPPUNIT_TEST_SUITE( TestQuadrature1Din3D );
+
CPPUNIT_TEST( testConstructor );
CPPUNIT_TEST( testLinear );
CPPUNIT_TEST( testQuadratic );
+
CPPUNIT_TEST_SUITE_END();
// PUBLIC METHODS /////////////////////////////////////////////////////
@@ -57,4 +59,5 @@
#endif // pylith_feassemble_testquadrature1din3d_hh
+
// End of file
Modified: short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature2D.cc
===================================================================
--- short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature2D.cc 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature2D.cc 2009-02-13 19:52:03 UTC (rev 14048)
@@ -15,6 +15,7 @@
#include "TestQuadrature2D.hh" // Implementation of class methods
#include "pylith/feassemble/Quadrature2D.hh"
+#include "pylith/feassemble/QuadratureRefCell.hh"
#include "pylith/feassemble/GeometryTri2D.hh"
#include "data/QuadratureData2DLinear.hh"
@@ -28,7 +29,8 @@
void
pylith::feassemble::TestQuadrature2D::testConstructor(void)
{ // testConstructor
- Quadrature2D quadrature;
+ QuadratureRefCell refCell;
+ Quadrature2D quadrature(refCell);
} // testConstructor
// ----------------------------------------------------------------------
@@ -36,12 +38,14 @@
void
pylith::feassemble::TestQuadrature2D::testLinear(void)
{ // testLinear
- Quadrature2D q;
GeometryTri2D geometry;
- q.refGeometry(&geometry);
+ QuadratureRefCell refCell;
+ refCell.refGeometry(&geometry);
+
+ Quadrature2D q(refCell);
QuadratureData2DLinear data;
- _testComputeGeometry(&q, data);
+ _testComputeGeometry(&q, &refCell, data);
} // testLinear
// ----------------------------------------------------------------------
@@ -49,12 +53,15 @@
void
pylith::feassemble::TestQuadrature2D::testQuadratic(void)
{ // testQuadratic
- Quadrature2D q;
GeometryTri2D geometry;
- q.refGeometry(&geometry);
+ QuadratureRefCell refCell;
+ refCell.refGeometry(&geometry);
+
+ Quadrature2D q(refCell);
QuadratureData2DQuadratic data;
- _testComputeGeometry(&q, data);
+ _testComputeGeometry(&q, &refCell, data);
} // testQuadratic
+
// End of file
Modified: short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature2D.hh
===================================================================
--- short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature2D.hh 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature2D.hh 2009-02-13 19:52:03 UTC (rev 14048)
@@ -21,7 +21,7 @@
#if !defined(pylith_feassemble_testquadrature2d_hh)
#define pylith_feassemble_testquadrature2d_hh
-#include "TestQuadrature.hh"
+#include "TestQuadratureEngine.hh"
/// Namespace for pylith package
namespace pylith {
@@ -31,14 +31,16 @@
} // pylith
/// C++ unit testing for Quadrature2D
-class pylith::feassemble::TestQuadrature2D : public TestQuadrature
+class pylith::feassemble::TestQuadrature2D : public TestQuadratureEngine
{ // class TestQuadrature2D
// CPPUNIT TEST SUITE /////////////////////////////////////////////////
CPPUNIT_TEST_SUITE( TestQuadrature2D );
+
CPPUNIT_TEST( testConstructor );
CPPUNIT_TEST( testLinear );
CPPUNIT_TEST( testQuadratic );
+
CPPUNIT_TEST_SUITE_END();
// PUBLIC METHODS /////////////////////////////////////////////////////
@@ -53,8 +55,9 @@
/// Test initialize() & computeGeometry() w/quadratic basis fns
void testQuadratic(void);
-}; // class TestQuadrature
+}; // class TestQuadrature2D
#endif // pylith_feassemble_testquadrature2d_hh
+
// End of file
Modified: short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature2Din3D.cc
===================================================================
--- short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature2Din3D.cc 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature2Din3D.cc 2009-02-13 19:52:03 UTC (rev 14048)
@@ -15,6 +15,7 @@
#include "TestQuadrature2Din3D.hh" // Implementation of class methods
#include "pylith/feassemble/Quadrature2Din3D.hh"
+#include "pylith/feassemble/QuadratureRefCell.hh"
#include "pylith/feassemble/GeometryTri3D.hh"
#include "data/QuadratureData2Din3DLinearXYZ.hh"
@@ -31,7 +32,8 @@
void
pylith::feassemble::TestQuadrature2Din3D::testConstructor(void)
{ // testConstructor
- Quadrature2Din3D quadrature;
+ QuadratureRefCell refCell;
+ Quadrature2Din3D quadrature(refCell);
} // testConstructor
// ----------------------------------------------------------------------
@@ -39,12 +41,14 @@
void
pylith::feassemble::TestQuadrature2Din3D::testLinearXYZ(void)
{ // testLinearXYZ
- Quadrature2Din3D q;
GeometryTri3D geometry;
- q.refGeometry(&geometry);
+ QuadratureRefCell refCell;
+ refCell.refGeometry(&geometry);
+
+ Quadrature2Din3D q(refCell);
QuadratureData2Din3DLinearXYZ data;
- _testComputeGeometry(&q, data);
+ _testComputeGeometry(&q, &refCell, data);
} // testLinearXYZ
// ----------------------------------------------------------------------
@@ -52,12 +56,14 @@
void
pylith::feassemble::TestQuadrature2Din3D::testLinearXY(void)
{ // testLinearXY
- Quadrature2Din3D q;
- QuadratureData2Din3DLinearXY data;
GeometryTri3D geometry;
- q.refGeometry(&geometry);
+ QuadratureRefCell refCell;
+ refCell.refGeometry(&geometry);
- _testComputeGeometry(&q, data);
+ Quadrature2Din3D q(refCell);
+ QuadratureData2Din3DLinearXY data;
+
+ _testComputeGeometry(&q, &refCell, data);
} // testLinearXY
// ----------------------------------------------------------------------
@@ -65,12 +71,14 @@
void
pylith::feassemble::TestQuadrature2Din3D::testLinearYZ(void)
{ // testLinearYZ
- Quadrature2Din3D q;
GeometryTri3D geometry;
- q.refGeometry(&geometry);
+ QuadratureRefCell refCell;
+ refCell.refGeometry(&geometry);
+
+ Quadrature2Din3D q(refCell);
QuadratureData2Din3DLinearYZ data;
- _testComputeGeometry(&q, data);
+ _testComputeGeometry(&q, &refCell, data);
} // testLinearYZ
// ----------------------------------------------------------------------
@@ -78,12 +86,14 @@
void
pylith::feassemble::TestQuadrature2Din3D::testLinearXZ(void)
{ // testLinearXZ
- Quadrature2Din3D q;
GeometryTri3D geometry;
- q.refGeometry(&geometry);
+ QuadratureRefCell refCell;
+ refCell.refGeometry(&geometry);
+
+ Quadrature2Din3D q(refCell);
QuadratureData2Din3DLinearXZ data;
- _testComputeGeometry(&q, data);
+ _testComputeGeometry(&q, &refCell, data);
} // testLinearXZ
// ----------------------------------------------------------------------
@@ -91,12 +101,15 @@
void
pylith::feassemble::TestQuadrature2Din3D::testQuadratic(void)
{ // testQuadratic
- Quadrature2Din3D q;
GeometryTri3D geometry;
- q.refGeometry(&geometry);
+ QuadratureRefCell refCell;
+ refCell.refGeometry(&geometry);
+
+ Quadrature2Din3D q(refCell);
QuadratureData2Din3DQuadratic data;
- _testComputeGeometry(&q, data);
+ _testComputeGeometry(&q, &refCell, data);
} // testQuadratic
+
// End of file
Modified: short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature2Din3D.hh
===================================================================
--- short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature2Din3D.hh 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature2Din3D.hh 2009-02-13 19:52:03 UTC (rev 14048)
@@ -21,7 +21,7 @@
#if !defined(pylith_feassemble_testquadrature2din3d_hh)
#define pylith_feassemble_testquadrature2din3d_hh
-#include "TestQuadrature.hh"
+#include "TestQuadratureEngine.hh"
/// Namespace for pylith package
namespace pylith {
@@ -31,17 +31,19 @@
} // pylith
/// C++ unit testing for Quadrature2Din3D
-class pylith::feassemble::TestQuadrature2Din3D : public TestQuadrature
+class pylith::feassemble::TestQuadrature2Din3D : public TestQuadratureEngine
{ // class TestQuadrature2D
// CPPUNIT TEST SUITE /////////////////////////////////////////////////
CPPUNIT_TEST_SUITE( TestQuadrature2Din3D );
+
CPPUNIT_TEST( testConstructor );
CPPUNIT_TEST( testLinearXYZ );
CPPUNIT_TEST( testLinearXY );
CPPUNIT_TEST( testLinearYZ );
CPPUNIT_TEST( testLinearXZ );
CPPUNIT_TEST( testQuadratic );
+
CPPUNIT_TEST_SUITE_END();
// PUBLIC METHODS /////////////////////////////////////////////////////
@@ -69,4 +71,5 @@
#endif // pylith_feassemble_testquadrature2din3d_hh
+
// End of file
Modified: short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature3D.cc
===================================================================
--- short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature3D.cc 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature3D.cc 2009-02-13 19:52:03 UTC (rev 14048)
@@ -15,6 +15,7 @@
#include "TestQuadrature3D.hh" // Implementation of class methods
#include "pylith/feassemble/Quadrature3D.hh"
+#include "pylith/feassemble/QuadratureRefCell.hh"
#include "pylith/feassemble/GeometryTet3D.hh"
#include "data/QuadratureData3DLinear.hh"
@@ -28,7 +29,8 @@
void
pylith::feassemble::TestQuadrature3D::testConstructor(void)
{ // testConstructor
- Quadrature3D quadrature;
+ QuadratureRefCell refCell;
+ Quadrature3D quadrature(refCell);
} // testConstructor
// ----------------------------------------------------------------------
@@ -36,12 +38,14 @@
void
pylith::feassemble::TestQuadrature3D::testLinear(void)
{ // testLinear
- Quadrature3D q;
GeometryTet3D geometry;
- q.refGeometry(&geometry);
+ QuadratureRefCell refCell;
+ refCell.refGeometry(&geometry);
+
+ Quadrature3D q(refCell);
QuadratureData3DLinear data;
- _testComputeGeometry(&q, data);
+ _testComputeGeometry(&q, &refCell, data);
} // testLinear
// ----------------------------------------------------------------------
@@ -49,12 +53,15 @@
void
pylith::feassemble::TestQuadrature3D::testQuadratic(void)
{ // testQuadratic
- Quadrature3D q;
GeometryTet3D geometry;
- q.refGeometry(&geometry);
+ QuadratureRefCell refCell;
+ refCell.refGeometry(&geometry);
+
+ Quadrature3D q(refCell);
QuadratureData3DQuadratic data;
- _testComputeGeometry(&q, data);
+ _testComputeGeometry(&q, &refCell, data);
} // testQuadratic
+
// End of file
Modified: short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature3D.hh
===================================================================
--- short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature3D.hh 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadrature3D.hh 2009-02-13 19:52:03 UTC (rev 14048)
@@ -21,7 +21,7 @@
#if !defined(pylith_feassemble_testquadrature3d_hh)
#define pylith_feassemble_testquadrature3d_hh
-#include "TestQuadrature.hh"
+#include "TestQuadratureEngine.hh"
/// Namespace for pylith package
namespace pylith {
@@ -31,14 +31,16 @@
} // pylith
/// C++ unit testing for Quadrature3D
-class pylith::feassemble::TestQuadrature3D : public TestQuadrature
+class pylith::feassemble::TestQuadrature3D : public TestQuadratureEngine
{ // class TestQuadrature3D
// CPPUNIT TEST SUITE /////////////////////////////////////////////////
CPPUNIT_TEST_SUITE( TestQuadrature3D );
+
CPPUNIT_TEST( testConstructor );
CPPUNIT_TEST( testLinear );
CPPUNIT_TEST( testQuadratic );
+
CPPUNIT_TEST_SUITE_END();
// PUBLIC METHODS /////////////////////////////////////////////////////
@@ -57,4 +59,5 @@
#endif // pylith_feassemble_testquadrature3d_hh
+
// End of file
Deleted: short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadratureBase.cc
===================================================================
--- short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadratureBase.cc 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadratureBase.cc 2009-02-13 19:52:03 UTC (rev 14048)
@@ -1,106 +0,0 @@
-// -*- C++ -*-
-//
-// ----------------------------------------------------------------------
-//
-// Brad T. Aagaard
-// U.S. Geological Survey
-//
-// {LicenseText}
-//
-// ----------------------------------------------------------------------
-//
-
-#include <portinfo>
-
-#include "TestQuadratureBase.hh" // Implementation of class methods
-
-#include "pylith/feassemble/QuadratureBase.hh" // USES QuadratureBase
-#include "pylith/feassemble/GeometryLine1D.hh" // USES GeometryLine1D
-
-#include "data/QuadratureData.hh" // USES QuadratureData
-
-#include <string.h> // USES memcpy()
-
-// ----------------------------------------------------------------------
-CPPUNIT_TEST_SUITE_REGISTRATION( pylith::feassemble::TestQuadratureBase );
-
-// ----------------------------------------------------------------------
-// Test constructor.
-void
-pylith::feassemble::TestQuadratureBase::testConstructor(void)
-{ // testConstructor
- QuadratureBase q;
-} // testMinJacobian
-
-// ----------------------------------------------------------------------
-// Test minJacobian()
-void
-pylith::feassemble::TestQuadratureBase::testMinJacobian(void)
-{ // testMinJacobian
- QuadratureBase q;
-
- const double min = 1.0;
- q.minJacobian(min);
- CPPUNIT_ASSERT_EQUAL(min, q._minJacobian);
-} // testMinJacobian
-
-// ----------------------------------------------------------------------
-// Test refGeometry()
-void
-pylith::feassemble::TestQuadratureBase::testRefGeometry(void)
-{ // testRefGeometry
- GeometryLine1D geometry;
- QuadratureBase quadrature;
-
- quadrature.refGeometry(&geometry);
- const CellGeometry& test = quadrature.refGeometry();
-
- CPPUNIT_ASSERT_EQUAL(geometry.cellDim(), test.cellDim());
- CPPUNIT_ASSERT_EQUAL(geometry.spaceDim(), test.spaceDim());
- CPPUNIT_ASSERT_EQUAL(geometry.numCorners(), test.numCorners());
-} // testRefGeometry
-
-// ----------------------------------------------------------------------
-// Test initialize()
-void
-pylith::feassemble::TestQuadratureBase::testInitialize(void)
-{ // initialize
-
- const int cellDim = 1;
- const int numBasis = 2;
- const int numQuadPts = 1;
- const int spaceDim = 1;
- const double basis[] = { 0.5, 0.5 };
- const double basisDerivRef[] = { -0.5, 0.5 };
- const double quadPtsRef[] = { 0.0 };
- const double quadWts[] = { 2.0 };
- const double minJacobian = 1.0;
-
- QuadratureBase q;
- q.initialize(basis, basisDerivRef, quadPtsRef, quadWts,
- cellDim, numBasis, numQuadPts, spaceDim);
-
- CPPUNIT_ASSERT_EQUAL(cellDim, q._cellDim);
- CPPUNIT_ASSERT_EQUAL(numBasis, q._numBasis);
- CPPUNIT_ASSERT_EQUAL(numQuadPts, q._numQuadPts);
- CPPUNIT_ASSERT_EQUAL(spaceDim, q._spaceDim);
-
- size_t size = numBasis * numQuadPts;
- for (int i=0; i < size; ++i)
- CPPUNIT_ASSERT_EQUAL(basis[i], q._basis[i]);
-
- size = numBasis * numQuadPts * spaceDim;
- for (int i=0; i < size; ++i)
- CPPUNIT_ASSERT_EQUAL(basisDerivRef[i], q._basisDerivRef[i]);
-
- size = numQuadPts * cellDim;
- for (int i=0; i < size; ++i)
- CPPUNIT_ASSERT_EQUAL(quadPtsRef[i], q._quadPtsRef[i]);
-
- size = numQuadPts;
- for (int i=0; i < size; ++i)
- CPPUNIT_ASSERT_EQUAL(quadWts[i], q._quadWts[i]);
-} // initialize
-
-
-// End of file
Deleted: short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadratureBase.hh
===================================================================
--- short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadratureBase.hh 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadratureBase.hh 2009-02-13 19:52:03 UTC (rev 14048)
@@ -1,67 +0,0 @@
-// -*- C++ -*-
-//
-// ----------------------------------------------------------------------
-//
-// Brad T. Aagaard
-// U.S. Geological Survey
-//
-// {LicenseText}
-//
-// ----------------------------------------------------------------------
-//
-
-/**
- * @file unittests/libtests/feassemble/TestQuadratureBase.hh
- *
- * @brief C++ TestQuadratureBase object
- *
- * C++ unit testing for QuadratureBase.
- */
-
-#if !defined(pylith_feassemble_testquadraturebase_hh)
-#define pylith_feassemble_testquadraturebase_hh
-
-#include <cppunit/extensions/HelperMacros.h>
-
-/// Namespace for pylith package
-namespace pylith {
- namespace feassemble {
- class TestQuadratureBase;
- class QuadratureBaseData;
- } // feassemble
-} // pylith
-
-/// C++ unit testing for QuadratureBase
-class pylith::feassemble::TestQuadratureBase : public CppUnit::TestFixture
-{ // class TestQuadratureBase
-
- // CPPUNIT TEST SUITE /////////////////////////////////////////////////
- CPPUNIT_TEST_SUITE( TestQuadratureBase );
-
- CPPUNIT_TEST( testConstructor );
- CPPUNIT_TEST( testMinJacobian );
- CPPUNIT_TEST( testRefGeometry );
- CPPUNIT_TEST( testInitialize );
-
- CPPUNIT_TEST_SUITE_END();
-
- // PUBLIC METHODS /////////////////////////////////////////////////////
-public :
-
- /// Test constructor.
- void testConstructor(void);
-
- /// Test minJacobian()
- void testMinJacobian(void);
-
- /// Test refGeometry()
- void testRefGeometry(void);
-
- /// Test initialize()
- void testInitialize(void);
-
-}; // class TestQuadratureBase
-
-#endif // pylith_feassemble_testquadraturebase_hh
-
-// End of file
Modified: short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadratureEngine.cc
===================================================================
--- short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadratureEngine.cc 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadratureEngine.cc 2009-02-13 19:52:03 UTC (rev 14048)
@@ -14,6 +14,7 @@
#include "TestQuadratureEngine.hh" // Implementation of class methods
+#include "pylith/feassemble/QuadratureRefCell.hh" // USES QuadratureRefCell
#include "pylith/feassemble/Quadrature1D.hh" // USES Quadrature1D
#include "data/QuadratureData.hh" // USES QuadratureData
@@ -35,9 +36,11 @@
const double jacobianDetE[] = { 10.24 };
const double basisDerivE[] = { 0.8, 1.6 };
- Quadrature1D engineOrig;
- int size = 0;
+ QuadratureRefCell refCell;
+ Quadrature1D engineOrig(refCell);
+ size_t size = 0;
+
// Set values
size = 1;
engineOrig._quadPts.resize(size);
@@ -56,27 +59,28 @@
memcpy(&engineOrig._jacobianDet[0], jacobianDetE, size*sizeof(double));
// Copy
- Quadrature1D engine(engineOrig);
+ const QuadratureEngine* engine = engineOrig.clone();
+ CPPUNIT_ASSERT(0 != engine);
- const double_array& quadPts = engine.quadPts();
+ const double_array& quadPts = engine->quadPts();
size = 1;
CPPUNIT_ASSERT_EQUAL(size, quadPts.size());
for (int i=0; i < size; ++i)
CPPUNIT_ASSERT_EQUAL(quadPtsE[i], quadPts[i]);
- const double_array& jacobian = engine._jacobian;
+ const double_array& jacobian = engine->_jacobian;
size = 1;
CPPUNIT_ASSERT_EQUAL(size, jacobian.size());
for (int i=0; i < size; ++i)
CPPUNIT_ASSERT_EQUAL(jacobianE[i], jacobian[i]);
- const double_array& jacobianInv = engine.jacobianInv();
+ const double_array& jacobianInv = engine->_jacobianInv;
size = 1;
CPPUNIT_ASSERT_EQUAL(size, jacobianInv.size());
for (int i=0; i < size; ++i)
CPPUNIT_ASSERT_EQUAL(jacobianInvE[i], jacobianInv[i]);
- const double_array& jacobianDet = engine.jacobianDet();
+ const double_array& jacobianDet = engine->jacobianDet();
size = 1;
CPPUNIT_ASSERT_EQUAL(size, jacobianDet.size());
for (int i=0; i < size; ++i)
@@ -84,9 +88,55 @@
} // testCopyConstructor
// ----------------------------------------------------------------------
+// Test initialize().
+void
+pylith::feassemble::TestQuadratureEngine::testInitialize(void)
+{ // testInitialize
+ const int cellDim = 2;
+ const int numBasis = 5;
+ const int numQuadPts = 1;
+ const int spaceDim = 3;
+ const double basis[] = {
+ 1.1, 1.2, 1.3, 1.4, 1.5
+ };
+ const double basisDerivRef[] = {
+ 2.1, 2.2, 2.3,
+ 2.4, 2.5, 2.6,
+ 2.7, 2.8, 2.9,
+ 2.10, 2.11, 2.12,
+ 2.13, 2.14, 2.15,
+ };
+ const double quadPtsRef[] = { 3.1, 3.2, 3.3 };
+ const double quadWts[] = { 4.0 };
+
+ QuadratureRefCell refCell;
+ refCell.initialize(basis, basisDerivRef, quadPtsRef, quadWts,
+ cellDim, numBasis, numQuadPts, spaceDim);
+
+ Quadrature1D engine(refCell);
+ engine.initialize();
+
+ size_t size = 0;
+
+ size = numQuadPts * spaceDim;
+ CPPUNIT_ASSERT_EQUAL(size, engine.quadPts().size());
+
+ size = numQuadPts * cellDim * spaceDim;
+ CPPUNIT_ASSERT_EQUAL(size, engine.jacobian().size());
+
+ size = numQuadPts * cellDim * spaceDim;
+ CPPUNIT_ASSERT_EQUAL(size, engine._jacobianInv.size());
+
+ size = numQuadPts;
+ CPPUNIT_ASSERT_EQUAL(size, engine.jacobianDet().size());
+} // testInitialize
+
+// ----------------------------------------------------------------------
// Test computeGeometry().
void
-pylith::feassemble::TestQuadratureEngine::_testComputeGeometry(Quadrature<topology::Mesh>* pQuad,
+pylith::feassemble::TestQuadratureEngine::_testComputeGeometry(
+ QuadratureEngine* engine,
+ QuadratureRefCell* refCell,
const QuadratureData& data) const
{ // testComputeGeometry
const int cellDim = data.cellDim;
@@ -95,7 +145,6 @@
const int spaceDim = data.spaceDim;
const double* basis = data.basis;
const double* basisDerivRef = data.basisDerivRef;
- const double* basisDeriv = data.basisDeriv;
const double* quadPtsRef = data.quadPtsRef;
const double* quadWts = data.quadWts;
@@ -103,54 +152,50 @@
const int numCells = data.numCells;
const double* vertCoords = data.vertices;
const int* cells = data.cells;
- const double* quadPts = data.quadPts;
- const double* jacobian = data.jacobian;
- const double* jacobianInv = data.jacobianInv;
- const double* jacobianDet = data.jacobianDet;
+ const double* quadPtsE = data.quadPts;
+ const double* jacobianE = data.jacobian;
+ const double* jacobianInvE = data.jacobianInv;
+ const double* jacobianDetE = data.jacobianDet;
+ const double* basisDerivE = data.basisDeriv;
+ CPPUNIT_ASSERT(1 == numCells);
+ CPPUNIT_ASSERT(0 != engine);
+ CPPUNIT_ASSERT(0 != refCell);
+
const double minJacobian = 1.0e-06;
+ refCell->minJacobian(minJacobian);
+ refCell->initialize(basis, basisDerivRef, quadPtsRef, quadWts,
+ cellDim, numBasis, numQuadPts, spaceDim);
- QuadratureRefCell quadRefCell;
- quadRefCell.minJacobian(minJacobian);
- quadRefCell.initialize(basis, basisDerivRef, quadPtsRef, quadWts,
- cellDim, numBasis, numQuadPts, spaceDim);
-
// Check values from computeGeometry()
- const ALE::Obj<Mesh::label_sequence>& cellsMesh = mesh->heightStratum(0);
- CPPUNIT_ASSERT(!cellsMesh.isNull());
- const Mesh::label_sequence::iterator e_iter = cellsMesh->begin();
- const ALE::Obj<Mesh::real_section_type>& coordinates =
- mesh->getRealSection("coordinates");
- CPPUNIT_ASSERT(!coordinates.isNull());
- pQuad->computeGeometry(mesh, coordinates, *e_iter);
+ engine->initialize();
+ engine->computeGeometry(vertCoords, spaceDim, 0);
- CPPUNIT_ASSERT(1 == numCells);
const double tolerance = 1.0e-06;
int size = numQuadPts * spaceDim;
for (int i=0; i < size; ++i)
- CPPUNIT_ASSERT_DOUBLES_EQUAL(quadPts[i], pQuad->_quadPts[i], tolerance);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(quadPtsE[i], engine->_quadPts[i], tolerance);
size = numQuadPts * cellDim * spaceDim;
for (int i=0; i < size; ++i)
- CPPUNIT_ASSERT_DOUBLES_EQUAL(jacobian[i], pQuad->_jacobian[i],
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(jacobianE[i], engine->_jacobian[i],
tolerance);
size = numQuadPts * spaceDim * cellDim;
for (int i=0; i < size; ++i)
- CPPUNIT_ASSERT_DOUBLES_EQUAL(jacobianInv[i], pQuad->_jacobianInv[i],
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(jacobianInvE[i], engine->_jacobianInv[i],
tolerance);
size = numQuadPts;
for (int i=0; i < size; ++i)
- CPPUNIT_ASSERT_DOUBLES_EQUAL(jacobianDet[i], pQuad->_jacobianDet[i],
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(jacobianDetE[i], engine->_jacobianDet[i],
tolerance);
size = numQuadPts * numBasis * spaceDim;
for (int i=0; i < size; ++i)
- CPPUNIT_ASSERT_DOUBLES_EQUAL(basisDeriv[i], pQuad->_basisDeriv[i],
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(basisDerivE[i], engine->_basisDeriv[i],
tolerance);
-
} // testComputeGeometry
Modified: short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadratureEngine.hh
===================================================================
--- short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadratureEngine.hh 2009-02-13 05:42:52 UTC (rev 14047)
+++ short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadratureEngine.hh 2009-02-13 19:52:03 UTC (rev 14048)
@@ -41,7 +41,7 @@
CPPUNIT_TEST_SUITE( TestQuadratureEngine );
CPPUNIT_TEST( testCopyConstructor );
- CPPUNIT_TEST( testCheckConditioning );
+ CPPUNIT_TEST( testInitialize );
CPPUNIT_TEST_SUITE_END();
@@ -51,8 +51,8 @@
/// Test copy constructor.
void testCopyConstructor(void);
- /// Test checkConditioning()
- void testCheckConditioning(void);
+ /// Test initialize().
+ void testInitialize(void);
// PROTECTED METHODS //////////////////////////////////////////////////
protected :
@@ -60,9 +60,11 @@
/** Test computeGeometry() and retrieveGeometry().
*
* @param engine Quadrature engine.
+ * @param refCell Quadrature reference cell information.
* @param data Data for testing quadrature
*/
void _testComputeGeometry(QuadratureEngine* engine,
+ QuadratureRefCell* refCell,
const QuadratureData& data) const;
}; // class TestQuadratureEngine
Copied: short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadratureRefCell.cc (from rev 14047, short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadratureBase.cc)
===================================================================
--- short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadratureRefCell.cc (rev 0)
+++ short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadratureRefCell.cc 2009-02-13 19:52:03 UTC (rev 14048)
@@ -0,0 +1,106 @@
+// -*- C++ -*-
+//
+// ----------------------------------------------------------------------
+//
+// Brad T. Aagaard
+// U.S. Geological Survey
+//
+// {LicenseText}
+//
+// ----------------------------------------------------------------------
+//
+
+#include <portinfo>
+
+#include "TestQuadratureRefCell.hh" // Implementation of class methods
+
+#include "pylith/feassemble/QuadratureRefCell.hh" // USES QuadratureRefCell
+#include "pylith/feassemble/GeometryLine1D.hh" // USES GeometryLine1D
+
+#include "data/QuadratureData.hh" // USES QuadratureData
+
+#include <string.h> // USES memcpy()
+
+// ----------------------------------------------------------------------
+CPPUNIT_TEST_SUITE_REGISTRATION( pylith::feassemble::TestQuadratureRefCell );
+
+// ----------------------------------------------------------------------
+// Test constructor.
+void
+pylith::feassemble::TestQuadratureRefCell::testConstructor(void)
+{ // testConstructor
+ QuadratureRefCell q;
+} // testMinJacobian
+
+// ----------------------------------------------------------------------
+// Test minJacobian()
+void
+pylith::feassemble::TestQuadratureRefCell::testMinJacobian(void)
+{ // testMinJacobian
+ QuadratureRefCell q;
+
+ const double min = 1.0;
+ q.minJacobian(min);
+ CPPUNIT_ASSERT_EQUAL(min, q._minJacobian);
+} // testMinJacobian
+
+// ----------------------------------------------------------------------
+// Test refGeometry()
+void
+pylith::feassemble::TestQuadratureRefCell::testRefGeometry(void)
+{ // testRefGeometry
+ GeometryLine1D geometry;
+ QuadratureRefCell quadrature;
+
+ quadrature.refGeometry(&geometry);
+ const CellGeometry& test = quadrature.refGeometry();
+
+ CPPUNIT_ASSERT_EQUAL(geometry.cellDim(), test.cellDim());
+ CPPUNIT_ASSERT_EQUAL(geometry.spaceDim(), test.spaceDim());
+ CPPUNIT_ASSERT_EQUAL(geometry.numCorners(), test.numCorners());
+} // testRefGeometry
+
+// ----------------------------------------------------------------------
+// Test initialize()
+void
+pylith::feassemble::TestQuadratureRefCell::testInitialize(void)
+{ // initialize
+
+ const int cellDim = 1;
+ const int numBasis = 2;
+ const int numQuadPts = 1;
+ const int spaceDim = 1;
+ const double basis[] = { 0.5, 0.5 };
+ const double basisDerivRef[] = { -0.5, 0.5 };
+ const double quadPtsRef[] = { 0.0 };
+ const double quadWts[] = { 2.0 };
+ const double minJacobian = 1.0;
+
+ QuadratureRefCell q;
+ q.initialize(basis, basisDerivRef, quadPtsRef, quadWts,
+ cellDim, numBasis, numQuadPts, spaceDim);
+
+ CPPUNIT_ASSERT_EQUAL(cellDim, q._cellDim);
+ CPPUNIT_ASSERT_EQUAL(numBasis, q._numBasis);
+ CPPUNIT_ASSERT_EQUAL(numQuadPts, q._numQuadPts);
+ CPPUNIT_ASSERT_EQUAL(spaceDim, q._spaceDim);
+
+ size_t size = numBasis * numQuadPts;
+ for (int i=0; i < size; ++i)
+ CPPUNIT_ASSERT_EQUAL(basis[i], q._basis[i]);
+
+ size = numBasis * numQuadPts * spaceDim;
+ for (int i=0; i < size; ++i)
+ CPPUNIT_ASSERT_EQUAL(basisDerivRef[i], q._basisDerivRef[i]);
+
+ size = numQuadPts * cellDim;
+ for (int i=0; i < size; ++i)
+ CPPUNIT_ASSERT_EQUAL(quadPtsRef[i], q._quadPtsRef[i]);
+
+ size = numQuadPts;
+ for (int i=0; i < size; ++i)
+ CPPUNIT_ASSERT_EQUAL(quadWts[i], q._quadWts[i]);
+} // initialize
+
+
+// End of file
Copied: short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadratureRefCell.hh (from rev 14047, short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadratureBase.hh)
===================================================================
--- short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadratureRefCell.hh (rev 0)
+++ short/3D/PyLith/branches/pylith-swig/unittests/libtests/feassemble/TestQuadratureRefCell.hh 2009-02-13 19:52:03 UTC (rev 14048)
@@ -0,0 +1,67 @@
+// -*- C++ -*-
+//
+// ----------------------------------------------------------------------
+//
+// Brad T. Aagaard
+// U.S. Geological Survey
+//
+// {LicenseText}
+//
+// ----------------------------------------------------------------------
+//
+
+/**
+ * @file unittests/libtests/feassemble/TestQuadratureRefCell.hh
+ *
+ * @brief C++ TestQuadratureRefCell object
+ *
+ * C++ unit testing for QuadratureRefCell.
+ */
+
+#if !defined(pylith_feassemble_testquadraturerefcell_hh)
+#define pylith_feassemble_testquadraturerefcell_hh
+
+#include <cppunit/extensions/HelperMacros.h>
+
+/// Namespace for pylith package
+namespace pylith {
+ namespace feassemble {
+ class TestQuadratureRefCell;
+ class QuadratureRefCellData;
+ } // feassemble
+} // pylith
+
+/// C++ unit testing for QuadratureRefCell
+class pylith::feassemble::TestQuadratureRefCell : public CppUnit::TestFixture
+{ // class TestQuadratureRefCell
+
+ // CPPUNIT TEST SUITE /////////////////////////////////////////////////
+ CPPUNIT_TEST_SUITE( TestQuadratureRefCell );
+
+ CPPUNIT_TEST( testConstructor );
+ CPPUNIT_TEST( testMinJacobian );
+ CPPUNIT_TEST( testRefGeometry );
+ CPPUNIT_TEST( testInitialize );
+
+ CPPUNIT_TEST_SUITE_END();
+
+ // PUBLIC METHODS /////////////////////////////////////////////////////
+public :
+
+ /// Test constructor.
+ void testConstructor(void);
+
+ /// Test minJacobian()
+ void testMinJacobian(void);
+
+ /// Test refGeometry()
+ void testRefGeometry(void);
+
+ /// Test initialize()
+ void testInitialize(void);
+
+}; // class TestQuadratureRefCell
+
+#endif // pylith_feassemble_testquadraturerefcell_hh
+
+// End of file
More information about the CIG-COMMITS
mailing list