FEGenericBase< T > Class Template Reference

#include <exact_error_estimator.h>

Public Member Functions

template<>
AutoPtr< FEGenericBase
< RealGradient > > 
build (const unsigned int dim, const FEType &fet)
 
template<>
AutoPtr< FEGenericBase< Real > > build_InfFE (const unsigned int dim, const FEType &fet)
 
template<>
AutoPtr< FEGenericBase
< RealGradient > > 
build_InfFE (const unsigned int, const FEType &)
 

Static Public Member Functions

template<>
AutoPtr< FEGenericBase< Real > > build (const unsigned int dim, const FEType &fet)
 

Detailed Description

template<typename T>
class FEGenericBase< T >

Definition at line 36 of file exact_error_estimator.h.

Member Function Documentation

template<>
AutoPtr< FEGenericBase< Real > > FEGenericBase< Real >::build ( const unsigned int  dim,
const FEType fet 
)
static

Definition at line 184 of file fe_base.C.

References libMeshEnums::BERNSTEIN, libMeshEnums::CLOUGH, libMesh::FEType::family, libMeshEnums::HERMITE, libMeshEnums::HIERARCHIC, libMeshEnums::L2_HIERARCHIC, libMeshEnums::L2_LAGRANGE, libMeshEnums::LAGRANGE, libMeshEnums::MONOMIAL, libMesh::out, libMeshEnums::SCALAR, libMeshEnums::SZABAB, and libMeshEnums::XYZ.

{
// The stupid AutoPtr<FEBase> ap(); return ap;
// construct is required to satisfy IBM's xlC
switch (dim)
{
// 0D
case 0:
{
switch (fet.family)
{
case CLOUGH:
{
return ap;
}
case HERMITE:
{
return ap;
}
case LAGRANGE:
{
return ap;
}
{
return ap;
}
case HIERARCHIC:
{
return ap;
}
{
return ap;
}
case MONOMIAL:
{
return ap;
}
#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES
case SZABAB:
{
return ap;
}
case BERNSTEIN:
{
return ap;
}
#endif
case XYZ:
{
AutoPtr<FEBase> ap(new FEXYZ<0>(fet));
return ap;
}
case SCALAR:
{
return ap;
}
default:
libMesh::out << "ERROR: Bad FEType.family= " << fet.family << std::endl;
libmesh_error();
}
}
// 1D
case 1:
{
switch (fet.family)
{
case CLOUGH:
{
return ap;
}
case HERMITE:
{
return ap;
}
case LAGRANGE:
{
return ap;
}
{
return ap;
}
case HIERARCHIC:
{
return ap;
}
{
return ap;
}
case MONOMIAL:
{
return ap;
}
#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES
case SZABAB:
{
return ap;
}
case BERNSTEIN:
{
return ap;
}
#endif
case XYZ:
{
AutoPtr<FEBase> ap(new FEXYZ<1>(fet));
return ap;
}
case SCALAR:
{
return ap;
}
default:
libMesh::out << "ERROR: Bad FEType.family= " << fet.family << std::endl;
libmesh_error();
}
}
// 2D
case 2:
{
switch (fet.family)
{
case CLOUGH:
{
return ap;
}
case HERMITE:
{
return ap;
}
case LAGRANGE:
{
return ap;
}
{
return ap;
}
case HIERARCHIC:
{
return ap;
}
{
return ap;
}
case MONOMIAL:
{
return ap;
}
#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES
case SZABAB:
{
return ap;
}
case BERNSTEIN:
{
return ap;
}
#endif
case XYZ:
{
AutoPtr<FEBase> ap(new FEXYZ<2>(fet));
return ap;
}
case SCALAR:
{
return ap;
}
default:
libMesh::out << "ERROR: Bad FEType.family= " << fet.family << std::endl;
libmesh_error();
}
}
// 3D
case 3:
{
switch (fet.family)
{
case CLOUGH:
{
libMesh::out << "ERROR: Clough-Tocher elements currently only support 1D and 2D"
<< std::endl;
libmesh_error();
}
case HERMITE:
{
return ap;
}
case LAGRANGE:
{
return ap;
}
{
return ap;
}
case HIERARCHIC:
{
return ap;
}
{
return ap;
}
case MONOMIAL:
{
return ap;
}
#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES
case SZABAB:
{
return ap;
}
case BERNSTEIN:
{
return ap;
}
#endif
case XYZ:
{
AutoPtr<FEBase> ap(new FEXYZ<3>(fet));
return ap;
}
case SCALAR:
{
return ap;
}
default:
libMesh::out << "ERROR: Bad FEType.family= " << fet.family << std::endl;
libmesh_error();
}
}
default:
libmesh_error();
}
libmesh_error();
AutoPtr<FEBase> ap(NULL);
return ap;
}
template<>
AutoPtr< FEGenericBase< RealGradient > > FEGenericBase< RealGradient >::build ( const unsigned int  dim,
const FEType fet 
)

Definition at line 522 of file fe_base.C.

References libMesh::FEType::family, libMeshEnums::LAGRANGE_VEC, libMeshEnums::NEDELEC_ONE, and libMesh::out.

{
// The stupid AutoPtr<FEBase> ap(); return ap;
// construct is required to satisfy IBM's xlC
switch (dim)
{
// 0D
case 0:
{
switch (fet.family)
{
{
return ap;
}
default:
{
libMesh::out << "ERROR: Bad FEType.family= " << fet.family << std::endl;
libmesh_error();
}
}
}
case 1:
{
switch (fet.family)
{
{
return ap;
}
default:
{
libMesh::out << "ERROR: Bad FEType.family= " << fet.family << std::endl;
libmesh_error();
}
}
}
case 2:
{
switch (fet.family)
{
{
return ap;
}
{
return ap;
}
default:
{
libMesh::out << "ERROR: Bad FEType.family= " << fet.family << std::endl;
libmesh_error();
}
}
}
case 3:
{
switch (fet.family)
{
{
return ap;
}
{
return ap;
}
default:
{
libMesh::out << "ERROR: Bad FEType.family= " << fet.family << std::endl;
libmesh_error();
}
}
}
default:
libmesh_error();
} // switch(dim)
libmesh_error();
return ap;
}
template<>
AutoPtr< FEGenericBase< Real > > FEGenericBase< Real >::build_InfFE ( const unsigned int  dim,
const FEType fet 
)

Definition at line 627 of file fe_base.C.

References libMeshEnums::CARTESIAN, libMesh::err, libMesh::FEType::inf_map, libMeshEnums::INFINITE_MAP, libMeshEnums::JACOBI_20_00, libMeshEnums::JACOBI_30_00, libMeshEnums::LAGRANGE, libMeshEnums::LEGENDRE, and libMesh::FEType::radial_family.

{
// The stupid AutoPtr<FEBase> ap(); return ap;
// construct is required to satisfy IBM's xlC
switch (dim)
{
// 1D
case 1:
{
switch (fet.radial_family)
{
{
libMesh::err << "ERROR: Don't build an infinite element " << std::endl
<< " with FEFamily = " << fet.radial_family << std::endl;
libmesh_error();
}
{
switch (fet.inf_map)
{
case CARTESIAN:
{
return ap;
}
default:
libMesh::err << "ERROR: Don't build an infinite element " << std::endl
<< " with InfMapType = " << fet.inf_map << std::endl;
libmesh_error();
}
}
{
switch (fet.inf_map)
{
case CARTESIAN:
{
return ap;
}
default:
libMesh::err << "ERROR: Don't build an infinite element " << std::endl
<< " with InfMapType = " << fet.inf_map << std::endl;
libmesh_error();
}
}
case LEGENDRE:
{
switch (fet.inf_map)
{
case CARTESIAN:
{
return ap;
}
default:
libMesh::err << "ERROR: Don't build an infinite element " << std::endl
<< " with InfMapType = " << fet.inf_map << std::endl;
libmesh_error();
}
}
case LAGRANGE:
{
switch (fet.inf_map)
{
case CARTESIAN:
{
return ap;
}
default:
libMesh::err << "ERROR: Don't build an infinite element " << std::endl
<< " with InfMapType = " << fet.inf_map << std::endl;
libmesh_error();
}
}
default:
libMesh::err << "ERROR: Bad FEType.radial_family= " << fet.radial_family << std::endl;
libmesh_error();
}
}
// 2D
case 2:
{
switch (fet.radial_family)
{
{
libMesh::err << "ERROR: Don't build an infinite element " << std::endl
<< " with FEFamily = " << fet.radial_family << std::endl;
libmesh_error();
}
{
switch (fet.inf_map)
{
case CARTESIAN:
{
return ap;
}
default:
libMesh::err << "ERROR: Don't build an infinite element " << std::endl
<< " with InfMapType = " << fet.inf_map << std::endl;
libmesh_error();
}
}
{
switch (fet.inf_map)
{
case CARTESIAN:
{
return ap;
}
default:
libMesh::err << "ERROR: Don't build an infinite element " << std::endl
<< " with InfMapType = " << fet.inf_map << std::endl;
libmesh_error();
}
}
case LEGENDRE:
{
switch (fet.inf_map)
{
case CARTESIAN:
{
return ap;
}
default:
libMesh::err << "ERROR: Don't build an infinite element " << std::endl
<< " with InfMapType = " << fet.inf_map << std::endl;
libmesh_error();
}
}
case LAGRANGE:
{
switch (fet.inf_map)
{
case CARTESIAN:
{
return ap;
}
default:
libMesh::err << "ERROR: Don't build an infinite element " << std::endl
<< " with InfMapType = " << fet.inf_map << std::endl;
libmesh_error();
}
}
default:
libMesh::err << "ERROR: Bad FEType.radial_family= " << fet.radial_family << std::endl;
libmesh_error();
}
}
// 3D
case 3:
{
switch (fet.radial_family)
{
{
libMesh::err << "ERROR: Don't build an infinite element " << std::endl
<< " with FEFamily = " << fet.radial_family << std::endl;
libmesh_error();
}
{
switch (fet.inf_map)
{
case CARTESIAN:
{
return ap;
}
default:
libMesh::err << "ERROR: Don't build an infinite element " << std::endl
<< " with InfMapType = " << fet.inf_map << std::endl;
libmesh_error();
}
}
{
switch (fet.inf_map)
{
case CARTESIAN:
{
return ap;
}
default:
libMesh::err << "ERROR: Don't build an infinite element " << std::endl
<< " with InfMapType = " << fet.inf_map << std::endl;
libmesh_error();
}
}
case LEGENDRE:
{
switch (fet.inf_map)
{
case CARTESIAN:
{
return ap;
}
default:
libMesh::err << "ERROR: Don't build an infinite element " << std::endl
<< " with InfMapType = " << fet.inf_map << std::endl;
libmesh_error();
}
}
case LAGRANGE:
{
switch (fet.inf_map)
{
case CARTESIAN:
{
return ap;
}
default:
libMesh::err << "ERROR: Don't build an infinite element " << std::endl
<< " with InfMapType = " << fet.inf_map << std::endl;
libmesh_error();
}
}
default:
libMesh::err << "ERROR: Bad FEType.radial_family= " << fet.radial_family << std::endl;
libmesh_error();
}
}
default:
libmesh_error();
}
libmesh_error();
AutoPtr<FEBase> ap(NULL);
return ap;
}
template<>
AutoPtr< FEGenericBase< RealGradient > > FEGenericBase< RealGradient >::build_InfFE ( const unsigned  int,
const FEType  
)

Definition at line 909 of file fe_base.C.

{
// No vector types defined... YET.
libmesh_error();
return ap;
}

The documentation for this class was generated from the following file:

Site Created By: libMesh Developers
Last modified: January 12 2013 15:00:43 UTC

Hosted By:
SourceForge.net Logo