P2TetrahedronFiniteElement Class Reference

#include <P2TetrahedronFiniteElement.hpp>

Inheritance diagram for P2TetrahedronFiniteElement:

Inheritance graph
[legend]
Collaboration diagram for P2TetrahedronFiniteElement:

Collaboration graph
[legend]

List of all members.

Public Types

enum  {
  numberOfDegreesOfFreedom = 10, numberOfVertexDegreesOfFreedom = 1, numberOfEdgeDegreesOfFreedom = 1, numberOfFaceDegreesOfFreedom = 0,
  numberOfVolumeDegreesOfFreedom = 0, numberOfFaceLivingDegreesOfFreedom = 6
}
enum  
typedef
QuadratureFormulaP2Tetrahedron 		QuadratureType
typedef TinyVector
< numberOfDegreesOfFreedom > 		ElementaryVector
typedef TinyMatrix
< numberOfDegreesOfFreedom,
numberOfDegreesOfFreedom > 		ElementaryMatrix

Public Member Functions

real_t W (const size_t &i, const TinyVector< 3 > &X) const
real_t dxW (const size_t &i, const TinyVector< 3 > &X) const
real_t dyW (const size_t &i, const TinyVector< 3 > &X) const
real_t dzW (const size_t &i, const TinyVector< 3 > &X) const
const TinyVector
< QuadratureType::numberOfQuadraturePoints,
TinyVector< 3 > > & 		integrationVertices () const
 P2TetrahedronFiniteElement ()
 ~P2TetrahedronFiniteElement ()
const real_t & W (const size_t &i, const size_t &j) const
const real_t & dxW (const size_t &i, const size_t &j) const
const real_t & dyW (const size_t &i, const size_t &j) const
const real_t & dzW (const size_t &i, const size_t &j) const
void integrateWjWi (ElementaryMatrix &matElem, const ConformTransformation &T) const
void integrateDWjWi (ElementaryMatrix &matElem, const size_t &n, const ConformTransformation &T) const
void integrateWjDWi (ElementaryMatrix &matElem, const size_t &n, const ConformTransformation &T) const
void integrateDWjDWi (ElementaryMatrix &matElem, const size_t &n, const size_t &m, const ConformTransformation &T) const
void integrateWj (ElementaryVector &vectElem, const ConformTransformation &T, const TinyVector< numberOfQuadraturePoints, real_t > &f) const

Static Public Member Functions

static const TinyVector
< 3, real_t > & 		massCenter ()
static P2TetrahedronFiniteElement & instance ()
static void create ()
static void destroy ()

Static Public Attributes

static const size_t facesDOF [Tetrahedron::NumberOfFaces][numberOfFaceLivingDegreesOfFreedom]

Protected Member Functions

real_t __W (const size_t &i, const size_t &j)
real_t __dxW (const size_t &i, const size_t &j)
real_t __dyW (const size_t &i, const size_t &j)
real_t __dzW (const size_t &i, const size_t &j)

Protected Attributes

TinyMatrix
< numberOfDegreesOfFreedom,
numberOfQuadraturePoints > 		__w
TinyMatrix
< numberOfDegreesOfFreedom,
numberOfQuadraturePoints > 		__dxw
TinyMatrix
< numberOfDegreesOfFreedom,
numberOfQuadraturePoints > 		__dyw
TinyMatrix
< numberOfDegreesOfFreedom,
numberOfQuadraturePoints > 		__dzw

Static Protected Attributes

static P2TetrahedronFiniteElement * __pInstance

Static Private Attributes

static TinyVector< 3, real_t > __massCenter

Detailed Description

Definition at line 32 of file P2TetrahedronFiniteElement.hpp.

Member Typedef Documentation

typedef QuadratureFormulaP2Tetrahedron LagrangianFiniteElement< numberOfDegreesOfFreedom, P2TetrahedronFiniteElement , QuadratureFormulaP2Tetrahedron >::QuadratureType [inherited]

default quadrature type

Definition at line 46 of file LagrangianFiniteElement.hpp.

typedef TinyVector<numberOfDegreesOfFreedom> LagrangianFiniteElement< numberOfDegreesOfFreedom, P2TetrahedronFiniteElement , QuadratureFormulaP2Tetrahedron >::ElementaryVector [inherited]

type of elementary vector

Definition at line 54 of file LagrangianFiniteElement.hpp.

typedef TinyMatrix<numberOfDegreesOfFreedom, numberOfDegreesOfFreedom> LagrangianFiniteElement< numberOfDegreesOfFreedom, P2TetrahedronFiniteElement , QuadratureFormulaP2Tetrahedron >::ElementaryMatrix [inherited]

type of elementary matrix

Definition at line 59 of file LagrangianFiniteElement.hpp.

Member Enumeration Documentation

anonymous enum

Enumerator:
numberOfDegreesOfFreedom 
numberOfVertexDegreesOfFreedom 
numberOfEdgeDegreesOfFreedom 
numberOfFaceDegreesOfFreedom 
numberOfVolumeDegreesOfFreedom 
numberOfFaceLivingDegreesOfFreedom 

Definition at line 41 of file P2TetrahedronFiniteElement.hpp.

00041        {
00042     numberOfDegreesOfFreedom = 10,
00043     numberOfVertexDegreesOfFreedom = 1,
00044     numberOfEdgeDegreesOfFreedom = 1,
00045     numberOfFaceDegreesOfFreedom = 0,
00046     numberOfVolumeDegreesOfFreedom = 0,
00047     numberOfFaceLivingDegreesOfFreedom = 6 // degrees of freedom carried by a face
00048   };

anonymous enum [inherited]

Definition at line 48 of file LagrangianFiniteElement.hpp.

00048        {
00049     numberOfQuadraturePoints = QuadratureType::numberOfQuadraturePoints
00050   };

Constructor & Destructor Documentation

P2TetrahedronFiniteElement::P2TetrahedronFiniteElement (  )  [inline]

Definition at line 78 of file P2TetrahedronFiniteElement.hpp.

00079   {
00080     ;
00081   }

P2TetrahedronFiniteElement::~P2TetrahedronFiniteElement (  )  [inline]

Definition at line 83 of file P2TetrahedronFiniteElement.hpp.

00084   {
00085     ;
00086   }

Member Function Documentation

static const TinyVector<3, real_t>& P2TetrahedronFiniteElement::massCenter (  )  [inline, static]

returns the mass center of the reference element

Returns:
__massCenter

Definition at line 60 of file P2TetrahedronFiniteElement.hpp.

References __massCenter.

00061   {
00062     return __massCenter;
00063   }

real_t P2TetrahedronFiniteElement::W ( const size_t &  i,
const TinyVector< 3 > &  X 
) const

Definition at line 33 of file P2TetrahedronFiniteElement.cpp.

References ErrorHandler::unexpected.

00035 {
00036   const real_t& x = X[0];
00037   const real_t& y = X[1];
00038   const real_t& z = X[2];
00039 
00040   switch (i) {
00041     // Vertices basis functions 
00042   case 0: {
00043     const real_t lambda = 1-x-y-z;
00044     return lambda*(2*lambda-1);
00045   }
00046   case 1: {
00047     return x*(2*x-1);
00048   }
00049   case 2: {
00050     return y*(2*y-1);
00051   }
00052   case 3: {
00053     return z*(2*z-1);
00054   }
00055     // Edges basis functions
00056   case 4: {
00057     return 4*(1-x-y-z)*x;
00058   }
00059   case 5: {
00060     return 4*(1-x-y-z)*y;
00061   }
00062   case 6: {
00063     return 4*(1-x-y-z)*z;
00064   }
00065   case 7: {
00066     return 4*x*y;
00067   }
00068   case 8: {
00069     return 4*x*z;
00070   }
00071   case 9: {
00072     return 4*y*z;
00073   }
00074   default: {
00075     throw ErrorHandler(__FILE__,__LINE__,
00076                        "unexpected basis function number",
00077                        ErrorHandler::unexpected);
00078     return 0.;
00079   }
00080   }
00081 }

real_t P2TetrahedronFiniteElement::dxW ( const size_t &  i,
const TinyVector< 3 > &  X 
) const

Definition at line 84 of file P2TetrahedronFiniteElement.cpp.

References ErrorHandler::unexpected.

00086 {
00087   const real_t& x = X[0];
00088   const real_t& y = X[1];
00089   const real_t& z = X[2];
00090 
00091   switch (i) {
00092     // Vertices basis functions 
00093   case 0: {
00094     return -3+4*x+4*y+4*z;
00095   }
00096   case 1: {
00097     return 4*x-1;
00098   }
00099   case 2: {
00100     return 0;
00101   }
00102   case 3: {
00103     return 0;
00104   }
00105     // Edges basis functions
00106   case 4: {
00107     return 4*(1-2*x-y-z);
00108   }
00109   case 5: {
00110     return -4*y;
00111   }
00112   case 6: {
00113     return -4*z;
00114   }
00115   case 7: {
00116     return 4*y;
00117   }
00118   case 8: {
00119     return 4*z;
00120   }
00121   case 9: {
00122     return 0;
00123   }
00124   default: {
00125     throw ErrorHandler(__FILE__,__LINE__,
00126                        "unexpected basis function number",
00127                        ErrorHandler::unexpected);
00128     return 0.;
00129   }
00130   }
00131 }

real_t P2TetrahedronFiniteElement::dyW ( const size_t &  i,
const TinyVector< 3 > &  X 
) const

Definition at line 134 of file P2TetrahedronFiniteElement.cpp.

References ErrorHandler::unexpected.

00136 {
00137   const real_t& x = X[0];
00138   const real_t& y = X[1];
00139   const real_t& z = X[2];
00140 
00141   switch (i) {
00142     // Vertices basis functions 
00143   case 0: {
00144     return -3+4*x+4*y+4*z;
00145   }
00146   case 1: {
00147     return 0;
00148   }
00149   case 2: {
00150     return 4*y-1;
00151   }
00152   case 3: {
00153     return 0;
00154   }
00155     // Edges basis functions
00156   case 4: {
00157     return -4*x;
00158   }
00159   case 5: {
00160     return 4*(1-x-2*y-z);
00161   }
00162   case 6: {
00163     return -4*z;
00164   }
00165   case 7: {
00166     return 4*x;
00167   }
00168   case 8: {
00169     return 0;
00170   }
00171   case 9: {
00172     return 4*z;
00173   }
00174   default: {
00175     throw ErrorHandler(__FILE__,__LINE__,
00176                        "unexpected basis function number",
00177                        ErrorHandler::unexpected);
00178     return 0.;
00179   }
00180   }
00181 }

real_t P2TetrahedronFiniteElement::dzW ( const size_t &  i,
const TinyVector< 3 > &  X 
) const

Definition at line 184 of file P2TetrahedronFiniteElement.cpp.

References ErrorHandler::unexpected.

00186 {
00187   const real_t& x = X[0];
00188   const real_t& y = X[1];
00189   const real_t& z = X[2];
00190 
00191   switch (i) {
00192     // Vertices basis functions 
00193   case 0: {
00194     return -3+4*x+4*y+4*z;
00195   }
00196   case 1: {
00197     return 0;
00198   }
00199   case 2: {
00200     return 0;
00201   }
00202   case 3: {
00203     return 4*z-1;
00204   }
00205     // Edges basis functions
00206   case 4: {
00207     return -4*x;
00208   }
00209   case 5: {
00210     return -4*y;
00211   }
00212   case 6: {
00213     return 4*(1-x-y-2*z);
00214   }
00215   case 7: {
00216     return 0;
00217   }
00218   case 8: {
00219     return 4*x;
00220   }
00221   case 9: {
00222     return 4*y;
00223   }
00224   default: {
00225     throw ErrorHandler(__FILE__,__LINE__,
00226                        "unexpected basis function number",
00227                        ErrorHandler::unexpected);
00228     return 0.;
00229   }
00230   }
00231 }

const TinyVector<QuadratureType::numberOfQuadraturePoints, TinyVector<3> >& P2TetrahedronFiniteElement::integrationVertices (  )  const [inline]

Definition at line 73 of file P2TetrahedronFiniteElement.hpp.

References StaticBase< QuadratureFormulaP2Tetrahedron >::instance(), and QuadratureFormulaP2Tetrahedron::vertices().

00074   {
00075     return QuadratureType::instance().vertices();
00076   }

Here is the call graph for this function:

static P2TetrahedronFiniteElement & StaticBase< P2TetrahedronFiniteElement >::instance (  )  [inline, static, inherited]

Access to auto instanciated static;

Returns:
*__pInstance

Definition at line 46 of file StaticBase.hpp.

00047   {
00048     return *__pInstance;
00049   }

static void StaticBase< P2TetrahedronFiniteElement >::create (  )  [inline, static, inherited]

Creates __pInstance in Embedding class.

Definition at line 55 of file StaticBase.hpp.

Referenced by ThreadStaticCenter::ThreadStaticCenter().

00056   {
00057     __pInstance = new EmbeddingClass();
00058   }

static void StaticBase< P2TetrahedronFiniteElement >::destroy (  )  [inline, static, inherited]

Destroyes __autoInstanciated in Embedding class.

Definition at line 64 of file StaticBase.hpp.

Referenced by ThreadStaticCenter::~ThreadStaticCenter().

00065   {
00066     delete __pInstance;
00067   }

real_t LagrangianFiniteElement< numberOfDegreesOfFreedom, P2TetrahedronFiniteElement , QuadratureFormulaP2Tetrahedron >::__W ( const size_t &  i,
const size_t &  j 
) [inline, protected, inherited]

Computes hat function value at quadrature point

Parameters:
i the hat function number
j the number of quadrature point
Returns:
the function value

Definition at line 81 of file LagrangianFiniteElement.hpp.

00082   {
00083     return self().W(i,self().integrationVertices()[j]);
00084   }

real_t LagrangianFiniteElement< numberOfDegreesOfFreedom, P2TetrahedronFiniteElement , QuadratureFormulaP2Tetrahedron >::__dxW ( const size_t &  i,
const size_t &  j 
) [inline, protected, inherited]

Computes hat function derivative by x at quadrature point

Parameters:
i the hat function number
j the number of quadrature point
Returns:
the function's derivative value

Definition at line 94 of file LagrangianFiniteElement.hpp.

00095   {
00096     return self().dxW(i,self().integrationVertices()[j]);
00097   }

real_t LagrangianFiniteElement< numberOfDegreesOfFreedom, P2TetrahedronFiniteElement , QuadratureFormulaP2Tetrahedron >::__dyW ( const size_t &  i,
const size_t &  j 
) [inline, protected, inherited]

Computes hat function derivative by y at quadrature point

Parameters:
i the hat function number
j the number of quadrature point
Returns:
the function's derivative value

Definition at line 107 of file LagrangianFiniteElement.hpp.

00108   {
00109     return self().dyW(i,self().integrationVertices()[j]);
00110   }

real_t LagrangianFiniteElement< numberOfDegreesOfFreedom, P2TetrahedronFiniteElement , QuadratureFormulaP2Tetrahedron >::__dzW ( const size_t &  i,
const size_t &  j 
) [inline, protected, inherited]

Computes hat function derivative by z at quadrature point

Parameters:
i the hat function number
j the number of quadrature point
Returns:
the function's derivative value

Definition at line 120 of file LagrangianFiniteElement.hpp.

00121   {
00122     return self().dzW(i,self().integrationVertices()[j]);
00123   }

const real_t& LagrangianFiniteElement< numberOfDegreesOfFreedom, P2TetrahedronFiniteElement , QuadratureFormulaP2Tetrahedron >::W ( const size_t &  i,
const size_t &  j 
) const [inline, inherited]

Read-only access to hat function value at a quadrature point

Parameters:
i the hat function number
j the number of quadrature point
Returns:
the function's value

Definition at line 147 of file LagrangianFiniteElement.hpp.

00148   {
00149     return __w(i,j);
00150   }

const real_t& LagrangianFiniteElement< numberOfDegreesOfFreedom, P2TetrahedronFiniteElement , QuadratureFormulaP2Tetrahedron >::dxW ( const size_t &  i,
const size_t &  j 
) const [inline, inherited]

Read-only access to hat function's derivative by x value at a quadrature point

Parameters:
i the hat function number
j the number of quadrature point
Returns:
the function's value

Definition at line 161 of file LagrangianFiniteElement.hpp.

00162   {
00163     return __dxw(i,j);
00164   }

const real_t& LagrangianFiniteElement< numberOfDegreesOfFreedom, P2TetrahedronFiniteElement , QuadratureFormulaP2Tetrahedron >::dyW ( const size_t &  i,
const size_t &  j 
) const [inline, inherited]

Read-only access to hat function's derivative by y value at a quadrature point

Parameters:
i the hat function number
j the number of quadrature point
Returns:
the function's value

Definition at line 175 of file LagrangianFiniteElement.hpp.

00176   {
00177     return __dyw(i,j);
00178   }

const real_t& LagrangianFiniteElement< numberOfDegreesOfFreedom, P2TetrahedronFiniteElement , QuadratureFormulaP2Tetrahedron >::dzW ( const size_t &  i,
const size_t &  j 
) const [inline, inherited]

Read-only access to hat function's derivative by z value at a quadrature point

Parameters:
i the hat function number
j the number of quadrature point
Returns:
the function's value

Definition at line 189 of file LagrangianFiniteElement.hpp.

00190   {
00191     return __dzw(i,j);
00192   }

void LagrangianFiniteElement< numberOfDegreesOfFreedom, P2TetrahedronFiniteElement , QuadratureFormulaP2Tetrahedron >::integrateWjWi ( ElementaryMatrix &  matElem,
const ConformTransformation &  T 
) const [inline, inherited]

Computes elementary matrix associated to $ \int w_j w_i $ on a given element using the associated conform transformation

Parameters:
matElem the elementary matrix
T the given transformation

Definition at line 203 of file LagrangianFiniteElement.hpp.

00205   {
00206     ElementaryMatrix tmp = 0;
00207 
00208     for (size_t k=0; k<numberOfQuadraturePoints; ++k) { // Loop on integration vertices
00209       for (size_t j=0; j<numberOfDegreesOfFreedom; ++j) {
00210         for (size_t i=0; i<=j; ++i) {
00211           tmp(i,j)
00212             += W(i,k) * W(j,k) * QuadratureType::instance().weight(k);
00213         }
00214       }
00215     }
00216 
00217     // for this operator, matElem is symetric.
00218     for (size_t j=0; j<numberOfDegreesOfFreedom; ++j)
00219       for (size_t i=j+1; i<numberOfDegreesOfFreedom; ++i)
00220         tmp(i,j) = tmp(j,i);
00221 
00222     matElem += tmp;
00223   }

void LagrangianFiniteElement< numberOfDegreesOfFreedom, P2TetrahedronFiniteElement , QuadratureFormulaP2Tetrahedron >::integrateDWjWi ( ElementaryMatrix &  matElem,
const size_t &  n,
const ConformTransformation &  T 
) const [inline, inherited]

Computes elementary matrix associated to $ \int \partial_{x_n} w_j w_i $ on a given element using the associated conform transformation

Parameters:
matElem the elementary matrix
n the $ n $ in $ \partial_{x_n} $
T the given transformation

Definition at line 235 of file LagrangianFiniteElement.hpp.

00238   {
00239     ElementaryMatrix tmp = 0;
00240 
00241     for (size_t k=0; k<numberOfQuadraturePoints; ++k) { // Loop on integration vertices
00242       for (size_t j=0; j<numberOfDegreesOfFreedom; ++j) {
00243         const real_t fj
00244           = dxW(j,k)*T.invJacobian(0,n)
00245           + dyW(j,k)*T.invJacobian(1,n)
00246           + dzW(j,k)*T.invJacobian(2,n);
00247         for (size_t i=0; i<numberOfDegreesOfFreedom; ++i) {
00248           tmp(i,j)
00249             += fj * W(i,k)  * QuadratureType::instance().weight(k);
00250         }
00251       }
00252     }
00253     matElem += tmp;
00254   }

void LagrangianFiniteElement< numberOfDegreesOfFreedom, P2TetrahedronFiniteElement , QuadratureFormulaP2Tetrahedron >::integrateWjDWi ( ElementaryMatrix &  matElem,
const size_t &  n,
const ConformTransformation &  T 
) const [inline, inherited]

Computes elementary matrix associated to $ \int w_j \partial_{x_n} w_i $ on a given element using the associated conform transformation

Parameters:
matElem the elementary matrix
n the $ n $ in $ \partial_{x_n} $
T the given transformation

Definition at line 266 of file LagrangianFiniteElement.hpp.

00269   {
00270     ElementaryMatrix tmp = 0;
00271 
00272     for (size_t k=0; k<numberOfQuadraturePoints; ++k) { // Loop on integration vertices
00273       for (size_t i=0; i<numberOfDegreesOfFreedom; ++i) {
00274         const real_t fi
00275           = dxW(i,k)*T.invJacobian(0,n)
00276           + dyW(i,k)*T.invJacobian(1,n)
00277           + dzW(i,k)*T.invJacobian(2,n);
00278         for (size_t j=0; j<numberOfDegreesOfFreedom; ++j) {
00279           tmp(i,j)
00280             += fi * W(j,k) * QuadratureType::instance().weight(k);
00281         }
00282       }
00283     }
00284     matElem += tmp;
00285   }

void LagrangianFiniteElement< numberOfDegreesOfFreedom, P2TetrahedronFiniteElement , QuadratureFormulaP2Tetrahedron >::integrateDWjDWi ( ElementaryMatrix &  matElem,
const size_t &  n,
const size_t &  m,
const ConformTransformation &  T 
) const [inline, inherited]

Computes elementary matrix associated to $ \int \partial_{x_n} w_j \partial_{x_m} w_i $ on a given element using the associated conform transformation

Parameters:
matElem the elementary matrix
n the $ n $ in $ \partial_{x_n} $
m the $ m $ in $ \partial_{x_m} $
T the given transformation

Definition at line 298 of file LagrangianFiniteElement.hpp.

00302   {
00303     ElementaryMatrix tmp = 0;
00304 
00305     for (size_t k=0; k<numberOfQuadraturePoints; ++k) { // Loop on integration vertices
00306       for (size_t j=0; j<numberOfDegreesOfFreedom; ++j) {
00307         const real_t fj
00308           = dxW(j,k)*T.invJacobian(0,n)
00309           + dyW(j,k)*T.invJacobian(1,n)
00310           + dzW(j,k)*T.invJacobian(2,n);
00311         for (size_t i=0; i<numberOfDegreesOfFreedom; ++i) {
00312           tmp(i,j)
00313             += fj
00314             * (  dxW(i,k)*T.invJacobian(0,m)
00315                + dyW(i,k)*T.invJacobian(1,m)
00316                + dzW(i,k)*T.invJacobian(2,m) )
00317             * QuadratureType::instance().weight(k);
00318         }
00319       }
00320     }
00321 
00322     matElem += tmp;
00323   }

void LagrangianFiniteElement< numberOfDegreesOfFreedom, P2TetrahedronFiniteElement , QuadratureFormulaP2Tetrahedron >::integrateWj ( ElementaryVector &  vectElem,
const ConformTransformation &  T,
const TinyVector< numberOfQuadraturePoints, real_t > &  f 
) const [inline, inherited]

Computes elementary vector associated to $ \int f w_i $ on a given element using the associated conform transformation

Parameters:
vectElem the elementary vector
T the given transformation
f $ f $ values at quadrature points

Definition at line 334 of file LagrangianFiniteElement.hpp.

00337   {
00338     vectElem = 0;
00339 
00340     for (size_t k=0; k<numberOfQuadraturePoints; ++k)
00341       for (size_t j=0; j<numberOfDegreesOfFreedom; ++j) {
00342         vectElem[j]
00343           += W(j,k)
00344           *  f[k]
00345           *  QuadratureType::instance().weight(k);
00346       }
00347   }

Member Data Documentation

TinyVector< 3, real_t > P2TetrahedronFiniteElement::__massCenter [static, private]

mass center of the reference element

Definition at line 38 of file P2TetrahedronFiniteElement.hpp.

Referenced by massCenter().

const size_t P2TetrahedronFiniteElement::facesDOF [static]

Initial value:

 {{1,2,3,9,8,7},
   {3,2,0,5,6,9},
   {0,1,3,8,6,4},
   {2,1,0,4,5,7}}
Degrees of freedom living on faces

Definition at line 53 of file P2TetrahedronFiniteElement.hpp.

P2TetrahedronFiniteElement * StaticBase< P2TetrahedronFiniteElement >::__pInstance [static, protected, inherited]

The static variable

Definition at line 37 of file StaticBase.hpp.

TinyMatrix<numberOfDegreesOfFreedom,numberOfQuadraturePoints> LagrangianFiniteElement< numberOfDegreesOfFreedom, P2TetrahedronFiniteElement , QuadratureFormulaP2Tetrahedron >::__w [protected, inherited]

hat function values at quadrature points

Definition at line 127 of file LagrangianFiniteElement.hpp.

TinyMatrix<numberOfDegreesOfFreedom,numberOfQuadraturePoints> LagrangianFiniteElement< numberOfDegreesOfFreedom, P2TetrahedronFiniteElement , QuadratureFormulaP2Tetrahedron >::__dxw [protected, inherited]

hat function dx values at quadrature points

Definition at line 130 of file LagrangianFiniteElement.hpp.

TinyMatrix<numberOfDegreesOfFreedom,numberOfQuadraturePoints> LagrangianFiniteElement< numberOfDegreesOfFreedom, P2TetrahedronFiniteElement , QuadratureFormulaP2Tetrahedron >::__dyw [protected, inherited]

hat function dy values at quadrature points

Definition at line 133 of file LagrangianFiniteElement.hpp.

TinyMatrix<numberOfDegreesOfFreedom,numberOfQuadraturePoints> LagrangianFiniteElement< numberOfDegreesOfFreedom, P2TetrahedronFiniteElement , QuadratureFormulaP2Tetrahedron >::__dzw [protected, inherited]

hat function dz values at quadrature points

Definition at line 136 of file LagrangianFiniteElement.hpp.

The documentation for this class was generated from the following files:
Generated on Wed Nov 19 00:11:10 2008 for FreeFEM3D (aka ff3d) by  doxygen 1.5.6