FEInterface

NAME

SYNOPSIS

#include <fe_interface.h>  

Public Member Functions

virtual ~FEInterface ()
 

Static Public Member Functions

static unsigned int n_shape_functions (const unsigned int dim, const FEType &fe_t, const ElemType t)

static unsigned int n_dofs (const unsigned int dim, const FEType &fe_t, const ElemType t)

static unsigned int n_dofs_at_node (const unsigned int dim, const FEType &fe_t, const ElemType t, const unsigned int n)

static unsigned int n_dofs_per_elem (const unsigned int dim, const FEType &fe_t, const ElemType t)

static void dofs_on_side (const Elem *const elem, const unsigned int dim, const FEType &fe_t, unsigned int s, std::vector< unsigned int > &di)

static void dofs_on_edge (const Elem *const elem, const unsigned int dim, const FEType &fe_t, unsigned int e, std::vector< unsigned int > &di)

static void nodal_soln (const unsigned int dim, const FEType &fe_t, const Elem *elem, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

static Point inverse_map (const unsigned int dim, const FEType &fe_t, const Elem *elem, const Point &p, const Real tolerance=TOLERANCE, const bool secure=true)

static void inverse_map (const unsigned int dim, const FEType &fe_t, const Elem *elem, const std::vector< Point > &physical_points, std::vector< Point > &reference_points, const Real tolerance=TOLERANCE, const bool secure=true)

static bool on_reference_element (const Point &p, const ElemType t, const Real eps=1.e-6)

static Real shape (const unsigned int dim, const FEType &fe_t, const ElemType t, const unsigned int i, const Point &p)

static Real shape (const unsigned int dim, const FEType &fe_t, const Elem *elem, const unsigned int i, const Point &p)

static void compute_data (const unsigned int dim, const FEType &fe_t, const Elem *elem, FEComputeData &data)

static void compute_constraints (DofConstraints &constraints, DofMap &dof_map, const unsigned int variable_number, const Elem *elem)

static void compute_periodic_constraints (DofConstraints &constraints, DofMap &dof_map, PeriodicBoundaries &boundaries, const MeshBase &mesh, const unsigned int variable_number, const Elem *elem)

static unsigned int max_order (const FEType &fe_t, const ElemType &el_t)

static bool extra_hanging_dofs (const FEType &fe_t)
 

Private Member Functions

FEInterface ()
 

Static Private Member Functions

static bool is_InfFE_elem (const ElemType et)

static unsigned int ifem_n_shape_functions (const unsigned int dim, const FEType &fe_t, const ElemType t)

static unsigned int ifem_n_dofs (const unsigned int dim, const FEType &fe_t, const ElemType t)

static unsigned int ifem_n_dofs_at_node (const unsigned int dim, const FEType &fe_t, const ElemType t, const unsigned int n)

static unsigned int ifem_n_dofs_per_elem (const unsigned int dim, const FEType &fe_t, const ElemType t)

static void ifem_nodal_soln (const unsigned int dim, const FEType &fe_t, const Elem *elem, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

static Point ifem_inverse_map (const unsigned int dim, const FEType &fe_t, const Elem *elem, const Point &p, const Real tolerance=TOLERANCE, const bool secure=true)

static void ifem_inverse_map (const unsigned int dim, const FEType &fe_t, const Elem *elem, const std::vector< Point > &physical_points, std::vector< Point > &reference_points, const Real tolerance=TOLERANCE, const bool secure=true)

static bool ifem_on_reference_element (const Point &p, const ElemType t, const Real eps)

static Real ifem_shape (const unsigned int dim, const FEType &fe_t, const ElemType t, const unsigned int i, const Point &p)

static Real ifem_shape (const unsigned int dim, const FEType &fe_t, const Elem *elem, const unsigned int i, const Point &p)

static void ifem_compute_data (const unsigned int dim, const FEType &fe_t, const Elem *elem, FEComputeData &data)
 

Detailed Description

This class provides an encapsulated access to all static public member functions of finite element classes. Using this class, one need not worry about the correct finite element class.

Author:

Daniel Dreyer, 2002-2007

Definition at line 57 of file fe_interface.h.  

Constructor & Destructor Documentation

FEInterface::FEInterface () [private]Empty constructor. Do not create an object of this type.

Definition at line 31 of file fe_interface.C.

{
  std::cerr << 'ERROR: Do not define an object of this type.' 
            << std::endl;
  libmesh_error();
}

virtual FEInterface::~FEInterface () [inline, virtual]Destructor.

Definition at line 71 of file fe_interface.h.

{return;}

Member Function Documentation

void FEInterface::compute_constraints (DofConstraints &constraints, DofMap &dof_map, const unsigned intvariable_number, const Elem *elem) [static]Computes the constraint matrix contributions (for non-conforming adapted meshes) corresponding to variable number var_number.

Definition at line 1892 of file fe_interface.C.

References libMeshEnums::CLOUGH, Elem::dim(), FEType::family, libMeshEnums::HERMITE, libMeshEnums::HIERARCHIC, libMeshEnums::LAGRANGE, and DofMap::variable_type().

{
  libmesh_assert (elem != NULL);

  const FEType& fe_t = dof_map.variable_type(variable_number);
  
  switch (elem->dim())
    {
    case 1:
      {
        // No constraints in 1D.
        return;
      }

      
    case 2:
      {
        switch (fe_t.family)
          {
          case CLOUGH:
            FE<2,CLOUGH>::compute_constraints (constraints,
                                               dof_map,
                                               variable_number,
                                               elem); return;

          case HERMITE:
            FE<2,HERMITE>::compute_constraints (constraints,
                                                dof_map,
                                                variable_number,
                                                elem); return;

          case LAGRANGE:
            FE<2,LAGRANGE>::compute_constraints (constraints,
                                                 dof_map,
                                                 variable_number,
                                                 elem); return;

          case HIERARCHIC:
            FE<2,HIERARCHIC>::compute_constraints (constraints,
                                                   dof_map,
                                                   variable_number,
                                                   elem); return;

          default:
            return;
          }
      }


    case 3:
      {
        switch (fe_t.family)
          {
          case HERMITE:
            FE<3,HERMITE>::compute_constraints (constraints,
                                                dof_map,
                                                variable_number,
                                                elem); return;

          case LAGRANGE:
            FE<3,LAGRANGE>::compute_constraints (constraints,
                                                 dof_map,
                                                 variable_number,
                                                 elem); return;      

          case HIERARCHIC:
            FE<3,HIERARCHIC>::compute_constraints (constraints,
                                                   dof_map,
                                                   variable_number,
                                                   elem); return;
          default:
            return;
          }
      }

      
    default:
      libmesh_error();
    }
}

void FEInterface::compute_data (const unsigned intdim, const FEType &fe_t, const Elem *elem, FEComputeData &data) [static]Lets the appropriate child of FEBase compute the requested data for the input specified in data, and returns the values also through data. See this as a generalization of shape(). Currently, with disabled infinite elements, returns a vector of all shape functions of elem evaluated ap p.

On a p-refined element, fe_t.order should be the base order of the element.

Definition at line 1856 of file fe_interface.C.

References ifem_compute_data(), FEComputeData::init(), is_InfFE_elem(), n_dofs(), FEType::order, FEComputeData::p, Elem::p_level(), shape(), FEComputeData::shape, and Elem::type().

Referenced by ifem_compute_data(), and MeshFunction::operator()().

{
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS

  if ( is_InfFE_elem(elem->type()) )
    {
      data.init();
      ifem_compute_data(dim, fe_t, elem, data);
      return;
    }

#endif

  FEType p_refined = fe_t;
  p_refined.order = static_cast<Order>(p_refined.order + elem->p_level());

  const unsigned int n_dof = n_dofs (dim, p_refined, elem->type());
  const Point&       p     = data.p;
  data.shape.resize(n_dof);

  // set default values for all the output fields
  data.init();

  for (unsigned int n=0; n<n_dof; n++)
      data.shape[n] = shape(dim, p_refined, elem, n, p);

   return;
}

void FEInterface::compute_periodic_constraints (DofConstraints &constraints, DofMap &dof_map, PeriodicBoundaries &boundaries, const MeshBase &mesh, const unsigned intvariable_number, const Elem *elem) [static]Computes the constraint matrix contributions (for periodic boundary conditions) corresponding to variable number var_number.

Definition at line 1982 of file fe_interface.C.

{
  // No element-specific optimizations currently exist
  FEBase::compute_periodic_constraints (constraints,
                                        dof_map,
                                        boundaries,
                                        mesh,
                                        variable_number,
                                        elem);
}

void FEInterface::dofs_on_edge (const Elem *constelem, const unsigned intdim, const FEType &fe_t, unsigned inte, std::vector< unsigned int > &di) [static]Fills the vector di with the local degree of freedom indices associated with edge e of element elem Automatically decides which finite element class to use.

On a p-refined element, fe_t.order should be the base order of the element.

Definition at line 819 of file fe_interface.C.

References libMeshEnums::BERNSTEIN, libMeshEnums::CLOUGH, FEType::family, libMeshEnums::HERMITE, libMeshEnums::HIERARCHIC, libMeshEnums::LAGRANGE, libMeshEnums::MONOMIAL, FEType::order, libMeshEnums::SCALAR, libMeshEnums::SZABAB, and libMeshEnums::XYZ.

Referenced by FEBase::coarsened_dof_values(), and System::ProjectVector::operator()().

{
  const Order o = fe_t.order;

  switch (dim)
    {
      // 1D
    case 1:
      {
        switch (fe_t.family)
          {
          case CLOUGH:
            FE<1,CLOUGH>::dofs_on_edge(elem, o, e, di);
            return;
            
          case HERMITE:
            FE<1,HERMITE>::dofs_on_edge(elem, o, e, di);
            return;
            
          case HIERARCHIC:
            FE<1,HIERARCHIC>::dofs_on_edge(elem, o, e, di);
            return;
            
          case LAGRANGE:
            FE<1,LAGRANGE>::dofs_on_edge(elem, o, e, di);
            return;
            
          case MONOMIAL:
            FE<1,MONOMIAL>::dofs_on_edge(elem, o, e, di);
            return;

          case SCALAR:
            FE<1,SCALAR>::dofs_on_edge(elem, o, e, di);
            return;

#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES

          case BERNSTEIN:
            FE<1,BERNSTEIN>::dofs_on_edge(elem, o, e, di);
            return;

          case SZABAB:
            FE<1,SZABAB>::dofs_on_edge(elem, o, e, di);
            return;

#endif
            
          case XYZ:
            FEXYZ<1>::dofs_on_edge(elem, o, e, di);
            return;

          default:
            libmesh_error();
          }
      }

      
      // 2D
    case 2:
      {
        switch (fe_t.family)
          {
          case CLOUGH:
            FE<2,CLOUGH>::dofs_on_edge(elem, o, e, di);
            return;
            
          case HERMITE:
            FE<2,HERMITE>::dofs_on_edge(elem, o, e, di);
            return;
            
          case HIERARCHIC:
            FE<2,HIERARCHIC>::dofs_on_edge(elem, o, e, di);
            return;
            
          case LAGRANGE:
            FE<2,LAGRANGE>::dofs_on_edge(elem, o, e, di);
            return;
            
          case MONOMIAL:
            FE<2,MONOMIAL>::dofs_on_edge(elem, o, e, di);
            return;

          case SCALAR:
            FE<2,SCALAR>::dofs_on_edge(elem, o, e, di);
            return;

#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES

          case BERNSTEIN:
            FE<2,BERNSTEIN>::dofs_on_edge(elem, o, e, di);
            return;

          case SZABAB:
            FE<2,SZABAB>::dofs_on_edge(elem, o, e, di);
            return;

#endif
            
          case XYZ:
            FEXYZ<2>::dofs_on_edge(elem, o, e, di);
            return;

          default:
            libmesh_error();
          }
      }

      
      // 3D
    case 3:
      {
        switch (fe_t.family)
          {
          case HERMITE:
            FE<3,HERMITE>::dofs_on_edge(elem, o, e, di);
            return;
            
          case HIERARCHIC:
            FE<3,HIERARCHIC>::dofs_on_edge(elem, o, e, di);
            return;
            
          case LAGRANGE:
            FE<3,LAGRANGE>::dofs_on_edge(elem, o, e, di);
            return;
            
          case MONOMIAL:
            FE<3,MONOMIAL>::dofs_on_edge(elem, o, e, di);
            return;

          case SCALAR:
            FE<3,SCALAR>::dofs_on_edge(elem, o, e, di);
            return;

#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES

          case BERNSTEIN:
            FE<3,BERNSTEIN>::dofs_on_edge(elem, o, e, di);
            return;

          case SZABAB:
            FE<3,SZABAB>::dofs_on_edge(elem, o, e, di);
            return;

#endif
            
          case XYZ:
            FEXYZ<3>::dofs_on_edge(elem, o, e, di);
            return;

          default:
            libmesh_error();
          }
      }


    default:
      libmesh_error();
    }

  libmesh_error();
}

void FEInterface::dofs_on_side (const Elem *constelem, const unsigned intdim, const FEType &fe_t, unsigned ints, std::vector< unsigned int > &di) [static]Fills the vector di with the local degree of freedom indices associated with side s of element elem Automatically decides which finite element class to use.

On a p-refined element, fe_t.order should be the base order of the element.

Definition at line 651 of file fe_interface.C.

References libMeshEnums::BERNSTEIN, libMeshEnums::CLOUGH, FEType::family, libMeshEnums::HERMITE, libMeshEnums::HIERARCHIC, libMeshEnums::LAGRANGE, libMeshEnums::MONOMIAL, FEType::order, libMeshEnums::SCALAR, libMeshEnums::SZABAB, and libMeshEnums::XYZ.

Referenced by FEBase::coarsened_dof_values(), FEBase::compute_periodic_constraints(), FEBase::compute_proj_constraints(), and System::ProjectVector::operator()().

{
  const Order o = fe_t.order;

  switch (dim)
    {
      // 1D
    case 1:
      {
        switch (fe_t.family)
          {
          case CLOUGH:
            FE<1,CLOUGH>::dofs_on_side(elem, o, s, di);
            return;
            
          case HERMITE:
            FE<1,HERMITE>::dofs_on_side(elem, o, s, di);
            return;
            
          case HIERARCHIC:
            FE<1,HIERARCHIC>::dofs_on_side(elem, o, s, di);
            return;
            
          case LAGRANGE:
            FE<1,LAGRANGE>::dofs_on_side(elem, o, s, di);
            return;
            
          case MONOMIAL:
            FE<1,MONOMIAL>::dofs_on_side(elem, o, s, di);
            return;

          case SCALAR:
            FE<1,SCALAR>::dofs_on_side(elem, o, s, di);
            return;

#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES

          case BERNSTEIN:
            FE<1,BERNSTEIN>::dofs_on_side(elem, o, s, di);
            return;

          case SZABAB:
            FE<1,SZABAB>::dofs_on_side(elem, o, s, di);
            return;

#endif
            
          case XYZ:
            FEXYZ<1>::dofs_on_side(elem, o, s, di);
            return;

          default:
            libmesh_error();
          }
      }

      
      // 2D
    case 2:
      {
        switch (fe_t.family)
          {
          case CLOUGH:
            FE<2,CLOUGH>::dofs_on_side(elem, o, s, di);
            return;
            
          case HERMITE:
            FE<2,HERMITE>::dofs_on_side(elem, o, s, di);
            return;
            
          case HIERARCHIC:
            FE<2,HIERARCHIC>::dofs_on_side(elem, o, s, di);
            return;
            
          case LAGRANGE:
            FE<2,LAGRANGE>::dofs_on_side(elem, o, s, di);
            return;
            
          case MONOMIAL:
            FE<2,MONOMIAL>::dofs_on_side(elem, o, s, di);
            return;

          case SCALAR:
            FE<2,SCALAR>::dofs_on_side(elem, o, s, di);
            return;

#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES

          case BERNSTEIN:
            FE<2,BERNSTEIN>::dofs_on_side(elem, o, s, di);
            return;

          case SZABAB:
            FE<2,SZABAB>::dofs_on_side(elem, o, s, di);
            return;

#endif
            
          case XYZ:
            FEXYZ<2>::dofs_on_side(elem, o, s, di);
            return;

          default:
            libmesh_error();
          }
      }

      
      // 3D
    case 3:
      {
        switch (fe_t.family)
          {
          case HERMITE:
            FE<3,HERMITE>::dofs_on_side(elem, o, s, di);
            return;
            
          case HIERARCHIC:
            FE<3,HIERARCHIC>::dofs_on_side(elem, o, s, di);
            return;
            
          case LAGRANGE:
            FE<3,LAGRANGE>::dofs_on_side(elem, o, s, di);
            return;
            
          case MONOMIAL:
            FE<3,MONOMIAL>::dofs_on_side(elem, o, s, di);
            return;

          case SCALAR:
            FE<3,SCALAR>::dofs_on_side(elem, o, s, di);
            return;

#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES

          case BERNSTEIN:
            FE<3,BERNSTEIN>::dofs_on_side(elem, o, s, di);
            return;

          case SZABAB:
            FE<3,SZABAB>::dofs_on_side(elem, o, s, di);
            return;

#endif
            
          case XYZ:
            FEXYZ<3>::dofs_on_side(elem, o, s, di);
            return;

          default:
            libmesh_error();
          }
      }


    default:
      libmesh_error();
    }

  libmesh_error();
}

bool FEInterface::extra_hanging_dofs (const FEType &fe_t) [static]Returns true if separate degrees of freedom must be allocated for vertex DoFs and edge/face DoFs at a hanging node.

Definition at line 2271 of file fe_interface.C.

References libMeshEnums::BERNSTEIN, libMeshEnums::CLOUGH, FEType::family, libMeshEnums::HERMITE, libMeshEnums::HIERARCHIC, libMeshEnums::LAGRANGE, libMeshEnums::MONOMIAL, libMeshEnums::SZABAB, and libMeshEnums::XYZ.

Referenced by DofMap::dof_indices(), DofMap::old_dof_indices(), and DofMap::reinit().

{
  switch (fe_t.family)
    {
      case LAGRANGE:
      case MONOMIAL:
#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES
      case BERNSTEIN:
      case SZABAB:
#endif
      case XYZ:
        return false;
      case CLOUGH:
      case HERMITE:
      case HIERARCHIC:
      default:
        return true;
    }
}

void FEInterface::ifem_compute_data (const unsigned intdim, const FEType &fe_t, const Elem *elem, FEComputeData &data) [static, private]

Definition at line 870 of file fe_interface_inf_fe.C.

References compute_data(), libMeshEnums::INFINITE_MAP, libMeshEnums::JACOBI_20_00, libMeshEnums::JACOBI_30_00, libMeshEnums::LAGRANGE, libMeshEnums::LEGENDRE, and FEType::radial_family.

Referenced by compute_data().

{
  switch (dim)
    {
      // 1D
    case 1:
      {
        switch (fe_t.radial_family)
          {
            /*
             * For no derivatives (and local coordinates, as
             * given in 

 p) the infinite element shapes
             * are independent of mapping type
             */
          case INFINITE_MAP:
            InfFE<1,INFINITE_MAP,CARTESIAN>::compute_data(fe_t, elem, data);
            break;

          case JACOBI_20_00:
            InfFE<1,JACOBI_20_00,CARTESIAN>::compute_data(fe_t, elem, data);
            break;

          case JACOBI_30_00:
            InfFE<1,JACOBI_30_00,CARTESIAN>::compute_data(fe_t, elem, data);
            break;

          case LEGENDRE:   
            InfFE<1,LEGENDRE,CARTESIAN>::compute_data(fe_t, elem, data);
            break;

          case LAGRANGE:
            InfFE<1,LAGRANGE,CARTESIAN>::compute_data(fe_t, elem, data);
            break;

          default:
            libmesh_error();
          }

        break;
      }


      // 2D
    case 2:
      {
        switch (fe_t.radial_family)
          {
          case INFINITE_MAP:
            InfFE<2,INFINITE_MAP,CARTESIAN>::compute_data(fe_t, elem, data);
            break;

          case JACOBI_20_00:
            InfFE<2,JACOBI_20_00,CARTESIAN>::compute_data(fe_t, elem, data);
            break;

          case JACOBI_30_00:
            InfFE<2,JACOBI_30_00,CARTESIAN>::compute_data(fe_t, elem, data);
            break;

          case LEGENDRE:   
            InfFE<2,LEGENDRE,CARTESIAN>::compute_data(fe_t, elem, data);
            break;

          case LAGRANGE:
            InfFE<2,LAGRANGE,CARTESIAN>::compute_data(fe_t, elem, data);
            break;

          default:
            libmesh_error();
          }

        break;
      }

            
      // 3D
    case 3:
      {
        switch (fe_t.radial_family)
          {
          case INFINITE_MAP:
            InfFE<3,INFINITE_MAP,CARTESIAN>::compute_data(fe_t, elem, data);
            break;

          case JACOBI_20_00:
            InfFE<3,JACOBI_20_00,CARTESIAN>::compute_data(fe_t, elem, data);
            break;

          case JACOBI_30_00:
            InfFE<3,JACOBI_30_00,CARTESIAN>::compute_data(fe_t, elem, data);
            break;

          case LEGENDRE:   
            InfFE<3,LEGENDRE,CARTESIAN>::compute_data(fe_t, elem, data);
            break;

          case LAGRANGE:
            InfFE<3,LAGRANGE,CARTESIAN>::compute_data(fe_t, elem, data);
            break;

          default:
            libmesh_error();
          }

        break;
      }


    default:
      libmesh_error();
      break;
    }

  return;
}

Point FEInterface::ifem_inverse_map (const unsigned intdim, const FEType &fe_t, const Elem *elem, const Point &p, const Realtolerance = TOLERANCE, const boolsecure = true) [static, private]

Definition at line 469 of file fe_interface_inf_fe.C.

References libMeshEnums::CARTESIAN, libMeshEnums::ELLIPSOIDAL, FEType::inf_map, inverse_map(), and libMeshEnums::SPHERICAL.

Referenced by inverse_map().

{
  switch (dim)
    {
      // 1D
    case 1:
      {
        switch (fe_t.inf_map)
          {
          case CARTESIAN:
            return InfFE<1,JACOBI_20_00,CARTESIAN>::inverse_map(elem, p, tolerance, secure);

          case SPHERICAL:
          case ELLIPSOIDAL:
            {
              std::cerr << 'ERROR: Spherical and Ellipsoidal IFEMs not (yet) ' << std::endl
                        << 'implemented.' << std::endl;
              libmesh_error();
            }

/*
          case SPHERICAL:
            return InfFE<1,JACOBI_20_00,SPHERICAL>::inverse_map(elem, p, tolerance);

          case ELLIPSOIDAL:
            return InfFE<1,JACOBI_20_00,ELLIPSOIDAL>::inverse_map(elem, p, tolerance);
*/

          default:
            libmesh_error();
          }
      }

      
      // 2D
    case 2:
      {
        switch (fe_t.inf_map)
          {
          case CARTESIAN:
            return InfFE<2,JACOBI_20_00,CARTESIAN>::inverse_map(elem, p, tolerance, secure);

          case SPHERICAL:
          case ELLIPSOIDAL:
            {
              std::cerr << 'ERROR: Spherical and Ellipsoidal IFEMs not (yet) ' << std::endl
                        << 'implemented.' << std::endl;
              libmesh_error();
            }

/*
          case SPHERICAL:
            return InfFE<2,JACOBI_20_00,SPHERICAL>::inverse_map(elem, p, tolerance);

          case ELLIPSOIDAL:
            return InfFE<2,JACOBI_20_00,ELLIPSOIDAL>::inverse_map(elem, p, tolerance);
*/

          default:
            libmesh_error();
          }

      }

      
      // 3D
    case 3:
      {
        switch (fe_t.inf_map)
          {
          case CARTESIAN:
            return InfFE<3,JACOBI_20_00,CARTESIAN>::inverse_map(elem, p, tolerance, secure);

          case SPHERICAL:
          case ELLIPSOIDAL:
            {
              std::cerr << 'ERROR: Spherical and Ellipsoidal IFEMs not (yet) ' << std::endl
                        << 'implemented.' << std::endl;
              libmesh_error();
            }

/*
          case SPHERICAL:
            return InfFE<3,JACOBI_20_00,SPHERICAL>::inverse_map(elem, p, tolerance);

          case ELLIPSOIDAL:
            return InfFE<3,JACOBI_20_00,ELLIPSOIDAL>::inverse_map(elem, p, tolerance);
*/

          default:
            libmesh_error();
          }

      }


    default:
      libmesh_error();
    }

  
  libmesh_error();
  Point pt;
  return pt;
}

void FEInterface::ifem_inverse_map (const unsigned intdim, const FEType &fe_t, const Elem *elem, const std::vector< Point > &physical_points, std::vector< Point > &reference_points, const Realtolerance = TOLERANCE, const boolsecure = true) [static, private]

Definition at line 582 of file fe_interface_inf_fe.C.

References libMeshEnums::CARTESIAN, FEType::inf_map, and inverse_map().

{
  switch (dim)
    {
      // 1D
    case 1:
      {
        switch (fe_t.inf_map)
          {
          case CARTESIAN:
            InfFE<1,JACOBI_20_00,CARTESIAN>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
            return;

          default:
            libmesh_error();
          }
      }

      
      // 2D
    case 2:
      {
        switch (fe_t.inf_map)
          {
          case CARTESIAN:
           InfFE<2,JACOBI_20_00,CARTESIAN>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
           return;

          default:
            libmesh_error();
          }

      }

      
      // 3D
    case 3:
      {
        switch (fe_t.inf_map)
          {
          case CARTESIAN:
           InfFE<3,JACOBI_20_00,CARTESIAN>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
           return;

          default:
            libmesh_error();
          }

      }


    default:
      libmesh_error();
    }

  libmesh_error();
  return;
}

unsigned int FEInterface::ifem_n_dofs (const unsigned intdim, const FEType &fe_t, const ElemTypet) [static, private]

Definition at line 74 of file fe_interface_inf_fe.C.

References n_dofs().

Referenced by n_dofs().

{
  switch (dim)
    {
      // 1D
    case 1:
      /* 
       * Since InfFE<Dim,T_radial,T_map>::n_dofs(...)
       * is actually independent of T_radial and T_map, we can use
       * just any T_radial and T_map
       */
      return InfFE<1,JACOBI_20_00,CARTESIAN>::n_dofs(fe_t, t);
      
      // 2D
    case 2:
      return InfFE<2,JACOBI_20_00,CARTESIAN>::n_dofs(fe_t, t);
      
      // 3D
    case 3:
      return InfFE<3,JACOBI_20_00,CARTESIAN>::n_dofs(fe_t, t);

    default:
      libmesh_error();
    }

  
  libmesh_error();
  return 0;
}

unsigned int FEInterface::ifem_n_dofs_at_node (const unsigned intdim, const FEType &fe_t, const ElemTypet, const unsigned intn) [static, private]

Definition at line 109 of file fe_interface_inf_fe.C.

References n_dofs_at_node().

Referenced by n_dofs_at_node().

{
  switch (dim)
    {
      // 1D
    case 1:
      /* 
       * Since InfFE<Dim,T_radial,T_map>::n_dofs_at_node(...)
       * is actually independent of T_radial and T_map, we can use
       * just any T_radial and T_map
       */
      return InfFE<1,JACOBI_20_00,CARTESIAN>::n_dofs_at_node(fe_t, t, n);
      
      // 2D
    case 2:
      return InfFE<2,JACOBI_20_00,CARTESIAN>::n_dofs_at_node(fe_t, t, n);
      
      // 3D
    case 3:
      return InfFE<3,JACOBI_20_00,CARTESIAN>::n_dofs_at_node(fe_t, t, n);

    default:
      libmesh_error();
    }

  
  libmesh_error();
  return 0;
}

unsigned int FEInterface::ifem_n_dofs_per_elem (const unsigned intdim, const FEType &fe_t, const ElemTypet) [static, private]

Definition at line 146 of file fe_interface_inf_fe.C.

References n_dofs_per_elem().

Referenced by n_dofs_per_elem().

{
  switch (dim)
    {
      // 1D
    case 1:
      /* 
       * Since InfFE<Dim,T_radial,T_map>::n_dofs(...)
       * is actually independent of T_radial and T_map, we can use
       * just any T_radial and T_map
       */
      return InfFE<1,JACOBI_20_00,CARTESIAN>::n_dofs_per_elem(fe_t, t);
      
      // 2D
    case 2:
      return InfFE<2,JACOBI_20_00,CARTESIAN>::n_dofs_per_elem(fe_t, t);
      
      // 3D
    case 3:
      return InfFE<3,JACOBI_20_00,CARTESIAN>::n_dofs_per_elem(fe_t, t);

    default:
      libmesh_error();
    }

  
  libmesh_error();
  return 0;
}

unsigned int FEInterface::ifem_n_shape_functions (const unsigned intdim, const FEType &fe_t, const ElemTypet) [static, private]

Definition at line 38 of file fe_interface_inf_fe.C.

References n_shape_functions().

Referenced by n_shape_functions().

{ 
  switch (dim)
    {
      // 1D
    case 1:
      /* 
       * Since InfFE<Dim,T_radial,T_map>::n_shape_functions(...)
       * is actually independent of T_radial and T_map, we can use
       * just any T_radial and T_map
       */
      return InfFE<1,JACOBI_20_00,CARTESIAN>::n_shape_functions(fe_t, t);
      
      // 2D
    case 2:
      return InfFE<2,JACOBI_20_00,CARTESIAN>::n_shape_functions(fe_t, t);
      
      // 3D
    case 3:
      return InfFE<3,JACOBI_20_00,CARTESIAN>::n_shape_functions(fe_t, t);

    default:
      libmesh_error();
    }

  
  libmesh_error();
  return 0;
}

void FEInterface::ifem_nodal_soln (const unsigned intdim, const FEType &fe_t, const Elem *elem, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln) [static, private]

Definition at line 181 of file fe_interface_inf_fe.C.

References libMeshEnums::CARTESIAN, FEType::inf_map, libMeshEnums::INFINITE_MAP, libMeshEnums::JACOBI_20_00, libMeshEnums::JACOBI_30_00, libMeshEnums::LAGRANGE, libMeshEnums::LEGENDRE, nodal_soln(), and FEType::radial_family.

Referenced by nodal_soln().

{
  switch (dim)
    {

      // 1D
    case 1:
      {
        switch (fe_t.radial_family)
          {
          case INFINITE_MAP:
            {
              std::cerr << 'ERROR: INFINTE_MAP is not a valid shape family for radial approximation.' << std::endl;
              libmesh_error();
              break;
            }

          case JACOBI_20_00:
            {
              switch (fe_t.inf_map)
                {
                  case CARTESIAN:
                    {
                      InfFE<1,JACOBI_20_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
                      break;
                    }
                  default:
                    std::cerr << 'ERROR: Spherical & Ellipsoidal IFEMs not implemented.' << std::endl;
                    libmesh_error();
                }
              break;
            }

          case JACOBI_30_00:
            {
              switch (fe_t.inf_map)
                {
                  case CARTESIAN:
                    {
                      InfFE<1,JACOBI_30_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
                      break;
                    }
                  default:
                    std::cerr << 'ERROR: Spherical & Ellipsoidal IFEMs not implemented.' << std::endl;
                    libmesh_error();
                }
              break;
            }

          case LEGENDRE:
            {
              switch (fe_t.inf_map)
                {
                  case CARTESIAN:
                    {
                      InfFE<1,LEGENDRE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
                      break;
                    }
                  default:
                    std::cerr << 'ERROR: Spherical & Ellipsoidal IFEMs not implemented.' << std::endl;
                    libmesh_error();
                }
              break;
            }

          case LAGRANGE:
            {
              switch (fe_t.inf_map)
                {
                  case CARTESIAN:
                    {
                      InfFE<1,LAGRANGE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
                      break;
                    }
                  default:
                    std::cerr << 'ERROR: Spherical & Ellipsoidal IFEMs not implemented.' << std::endl;
                    libmesh_error();
                }
              break;
            }


            
          default:
            std::cerr << 'ERROR: Bad FEType.radial_family= ' << fe_t.radial_family << std::endl;
            libmesh_error();
            break;
          }

        break;
      }

      


      // 2D
    case 2:
      {
        switch (fe_t.radial_family)
          {
          case INFINITE_MAP:
            {
              std::cerr << 'ERROR: INFINTE_MAP is not a valid shape family for radial approximation.' << std::endl;
              libmesh_error();
              break;
            }

          case JACOBI_20_00:
            {
              switch (fe_t.inf_map)
                {
                  case CARTESIAN:
                    {
                      InfFE<2,JACOBI_20_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
                      break;
                    }
                  default:
                    std::cerr << 'ERROR: Spherical & Ellipsoidal IFEMs not implemented.' << std::endl;                        
                    libmesh_error();
                }
              break;
            }

          case JACOBI_30_00:
            {
              switch (fe_t.inf_map)
                {
                  case CARTESIAN:
                    {
                      InfFE<2,JACOBI_30_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
                      break;
                    }
                  default:
                    std::cerr << 'ERROR: Spherical & Ellipsoidal IFEMs not implemented.' << std::endl;                        
                    libmesh_error();
                }
              break;
            }

          case LEGENDRE:
            {
              switch (fe_t.inf_map)
                {
                  case CARTESIAN:
                    {
                      InfFE<2,LEGENDRE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
                      break;
                    }
                  default:
                    std::cerr << 'ERROR: Spherical & Ellipsoidal IFEMs not implemented.' << std::endl;                        
                    libmesh_error();
                }
              break;
            }

          case LAGRANGE:
            {
              switch (fe_t.inf_map)
                {
                  case CARTESIAN:
                    {
                      InfFE<2,LAGRANGE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
                      break;
                    }
                  default:
                    std::cerr << 'ERROR: Spherical & Ellipsoidal IFEMs not implemented.' << std::endl;                        
                    libmesh_error();
                }
              break;
            }


            
          default:
            std::cerr << 'ERROR: Bad FEType.radial_family= ' << fe_t.radial_family << std::endl;
            libmesh_error();
            break;
          }

        break;
      }

      


      // 3D
    case 3:
      {
        switch (fe_t.radial_family)
          {
          case INFINITE_MAP:
            {
              std::cerr << 'ERROR: INFINTE_MAP is not a valid shape family for radial approximation.' << std::endl;
              libmesh_error();
              break;
            }

          case JACOBI_20_00:
            {
              switch (fe_t.inf_map)
                {
                  case CARTESIAN:
                    {
                      InfFE<3,JACOBI_20_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
                      break;
                    }
                  default:
                    std::cerr << 'ERROR: Spherical & Ellipsoidal IFEMs not implemented.' << std::endl;                        
                    libmesh_error();
                }
              break;
            }

          case JACOBI_30_00:
            {
              switch (fe_t.inf_map)
                {
                  case CARTESIAN:
                    {
                      InfFE<3,JACOBI_30_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
                      break;
                    }
                  default:
                    std::cerr << 'ERROR: Spherical & Ellipsoidal IFEMs not implemented.' << std::endl;                        
                    libmesh_error();
                }
              break;
            }

          case LEGENDRE:
            {
              switch (fe_t.inf_map)
                {
                  case CARTESIAN:
                    {
                      InfFE<3,LEGENDRE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
                      break;
                    }
                  default:
                    std::cerr << 'ERROR: Spherical & Ellipsoidal IFEMs not implemented.' << std::endl;                
                    libmesh_error();
                }
              break;
            }

          case LAGRANGE:
            {
              switch (fe_t.inf_map)
                {
                  case CARTESIAN:
                    {
                      InfFE<3,LAGRANGE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
                      break;
                    }
                  default:
                    std::cerr << 'ERROR: Spherical & Ellipsoidal IFEMs not implemented.' << std::endl;                        
                    libmesh_error();
                }
              break;
            }


            
          default:
            std::cerr << 'ERROR: Bad FEType.radial_family= ' << fe_t.radial_family << std::endl;
            libmesh_error();
            break;
          }

        break;
      }

    default:
      libmesh_error();
    }
  return;
}

bool FEInterface::ifem_on_reference_element (const Point &p, const ElemTypet, const Realeps) [static, private]

Definition at line 650 of file fe_interface_inf_fe.C.

References on_reference_element().

{
  return FEBase::on_reference_element(p,t,eps);
}

Real FEInterface::ifem_shape (const unsigned intdim, const FEType &fe_t, const ElemTypet, const unsigned inti, const Point &p) [static, private]

Definition at line 660 of file fe_interface_inf_fe.C.

References libMeshEnums::INFINITE_MAP, libMeshEnums::JACOBI_20_00, libMeshEnums::JACOBI_30_00, libMeshEnums::LAGRANGE, libMeshEnums::LEGENDRE, FEType::radial_family, and shape().

Referenced by shape().

{
  switch (dim)
    {
      // 1D
    case 1:
      {
        switch (fe_t.radial_family)
          {
            /*
             * For no derivatives (and local coordinates, as
             * given in 

 p) the infinite element shapes
             * are independent of mapping type
             */
          case INFINITE_MAP:
            return InfFE<1,INFINITE_MAP,CARTESIAN>::shape(fe_t, t, i, p);

          case JACOBI_20_00:
            return InfFE<1,JACOBI_20_00,CARTESIAN>::shape(fe_t, t, i, p);

          case JACOBI_30_00:
            return InfFE<1,JACOBI_30_00,CARTESIAN>::shape(fe_t, t, i, p);

          case LEGENDRE:   
            return InfFE<1,LEGENDRE,CARTESIAN>::shape(fe_t, t, i, p);

          case LAGRANGE:
            return InfFE<1,LAGRANGE,CARTESIAN>::shape(fe_t, t, i, p);

          default:
            libmesh_error();
          }
      }

      
      // 2D
    case 2:
      {
        switch (fe_t.radial_family)
          {
          case INFINITE_MAP:
            return InfFE<2,INFINITE_MAP,CARTESIAN>::shape(fe_t, t, i, p);

          case JACOBI_20_00:
            return InfFE<2,JACOBI_20_00,CARTESIAN>::shape(fe_t, t, i, p);

          case JACOBI_30_00:
            return InfFE<2,JACOBI_30_00,CARTESIAN>::shape(fe_t, t, i, p);

          case LEGENDRE:   
            return InfFE<2,LEGENDRE,CARTESIAN>::shape(fe_t, t, i, p);

          case LAGRANGE:
            return InfFE<2,LAGRANGE,CARTESIAN>::shape(fe_t, t, i, p);

          default:
            libmesh_error();
          }

      }

      
      // 3D
    case 3:
      {
        switch (fe_t.radial_family)
          {
          case INFINITE_MAP:
            return InfFE<3,INFINITE_MAP,CARTESIAN>::shape(fe_t, t, i, p);

          case JACOBI_20_00:
            return InfFE<3,JACOBI_20_00,CARTESIAN>::shape(fe_t, t, i, p);

          case JACOBI_30_00:
            return InfFE<3,JACOBI_30_00,CARTESIAN>::shape(fe_t, t, i, p);

          case LEGENDRE:   
            return InfFE<3,LEGENDRE,CARTESIAN>::shape(fe_t, t, i, p);

          case LAGRANGE:
            return InfFE<3,LAGRANGE,CARTESIAN>::shape(fe_t, t, i, p);

          default:
            libmesh_error();
          }

      }


    default:
      libmesh_error();
    }

  
  libmesh_error();
  return 0.;
}

Real FEInterface::ifem_shape (const unsigned intdim, const FEType &fe_t, const Elem *elem, const unsigned inti, const Point &p) [static, private]

Definition at line 765 of file fe_interface_inf_fe.C.

References libMeshEnums::INFINITE_MAP, libMeshEnums::JACOBI_20_00, libMeshEnums::JACOBI_30_00, libMeshEnums::LAGRANGE, libMeshEnums::LEGENDRE, FEType::radial_family, and shape().

{
  switch (dim)
    {
      // 1D
    case 1:
      {
        switch (fe_t.radial_family)
          {
            /*
             * For no derivatives (and local coordinates, as
             * given in 

 p) the infinite element shapes
             * are independent of mapping type
             */
          case INFINITE_MAP:
            return InfFE<1,INFINITE_MAP,CARTESIAN>::shape(fe_t, elem, i, p);

          case JACOBI_20_00:
            return InfFE<1,JACOBI_20_00,CARTESIAN>::shape(fe_t, elem, i, p);

          case JACOBI_30_00:
            return InfFE<1,JACOBI_30_00,CARTESIAN>::shape(fe_t, elem, i, p);

          case LEGENDRE:   
            return InfFE<1,LEGENDRE,CARTESIAN>::shape(fe_t, elem, i, p);

          case LAGRANGE:
            return InfFE<1,LAGRANGE,CARTESIAN>::shape(fe_t, elem, i, p);

          default:
            libmesh_error();
          }
      }


      // 2D
    case 2:
      {
        switch (fe_t.radial_family)
          {
          case INFINITE_MAP:
            return InfFE<2,INFINITE_MAP,CARTESIAN>::shape(fe_t, elem, i, p);

          case JACOBI_20_00:
            return InfFE<2,JACOBI_20_00,CARTESIAN>::shape(fe_t, elem, i, p);

          case JACOBI_30_00:
            return InfFE<2,JACOBI_30_00,CARTESIAN>::shape(fe_t, elem, i, p);

          case LEGENDRE:   
            return InfFE<2,LEGENDRE,CARTESIAN>::shape(fe_t, elem, i, p);

          case LAGRANGE:
            return InfFE<2,LAGRANGE,CARTESIAN>::shape(fe_t, elem, i, p);

          default:
            libmesh_error();
          }

      }

            
      // 3D
    case 3:
      {
        switch (fe_t.radial_family)
          {
          case INFINITE_MAP:
            return InfFE<3,INFINITE_MAP,CARTESIAN>::shape(fe_t, elem, i, p);

          case JACOBI_20_00:
            return InfFE<3,JACOBI_20_00,CARTESIAN>::shape(fe_t, elem, i, p);

          case JACOBI_30_00:
            return InfFE<3,JACOBI_30_00,CARTESIAN>::shape(fe_t, elem, i, p);

          case LEGENDRE:   
            return InfFE<3,LEGENDRE,CARTESIAN>::shape(fe_t, elem, i, p);

          case LAGRANGE:
            return InfFE<3,LAGRANGE,CARTESIAN>::shape(fe_t, elem, i, p);

          default:
            libmesh_error();
          }

      }


    default:
      libmesh_error();
    }

  
  libmesh_error();
  return 0.;
}

void FEInterface::inverse_map (const unsigned intdim, const FEType &fe_t, const Elem *elem, const std::vector< Point > &physical_points, std::vector< Point > &reference_points, const Realtolerance = TOLERANCE, const boolsecure = true) [static]Returns:

the location (on the reference element) of the points physical_points located in physical space. This function requires inverting the (probably nonlinear) transformation map, so it is not trivial. The location of each point on the reference element is returned in the vector reference_points. The optional parameter tolerance defines how close is 'good
 enough.' The map inversion iteration computes the sequence $  p_n  $, and the iteration is terminated when $ p - p_n < mbox{ exttt{tolerance}} $ 

Definition at line 1341 of file fe_interface.C.

References libMeshEnums::BERNSTEIN, libMeshEnums::CLOUGH, FEType::family, libMeshEnums::HERMITE, libMeshEnums::HIERARCHIC, ifem_inverse_map(), inverse_map(), is_InfFE_elem(), libMeshEnums::LAGRANGE, libMeshEnums::MONOMIAL, libMeshEnums::SCALAR, TypeVector< T >::size(), libMeshEnums::SZABAB, Elem::type(), and libMeshEnums::XYZ.

{
  const unsigned int n_pts = physical_points.size();

  // Resize the vector
  reference_points.resize(n_pts);
  
  if (n_pts == 0)
    {
      std::cerr << 'WARNING: empty vector physical_points!'
                << std::endl;
      libmesh_here();
      return;
    }
  



  
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS

  if ( is_InfFE_elem(elem->type()) )
    {
      ifem_inverse_map(dim, fe_t, elem, physical_points, reference_points, tolerance, secure);
      return;

//       std::cerr << 'ERROR: Not implemented!'
//              << std::endl;
//       libmesh_error();
    }
  
#endif

  switch (dim)
    {
      // 1D
    case 1:
      {
        switch (fe_t.family)
          {
          case CLOUGH:
            FE<1,CLOUGH>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
            return;
            
          case HERMITE:
            FE<1,HERMITE>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
            return;
            
          case HIERARCHIC:
            FE<1,HIERARCHIC>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
            return;
            
          case LAGRANGE:
            FE<1,LAGRANGE>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
            return;
            
          case MONOMIAL:
            FE<1,MONOMIAL>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
            return;

          case SCALAR:
            FE<1,SCALAR>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
            return;
            
#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES

          case BERNSTEIN:
            FE<1,BERNSTEIN>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
            return;

          case SZABAB:
            FE<1,SZABAB>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
            return;

#endif
            
          case XYZ:
            FEXYZ<1>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
            return;

          default:
            libmesh_error();
          }
      }

      
      // 2D
    case 2:
      {
        switch (fe_t.family)
          {
          case CLOUGH:
            FE<2,CLOUGH>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
            return;
            
          case HERMITE:
            FE<2,HERMITE>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
            return;
            
          case HIERARCHIC:
            FE<2,HIERARCHIC>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
            return;
            
          case LAGRANGE:
            FE<2,LAGRANGE>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
            return;
            
          case MONOMIAL:
            FE<2,MONOMIAL>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
            return;

          case SCALAR:
            FE<2,SCALAR>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
            return;
            
#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES

          case BERNSTEIN:
            FE<2,BERNSTEIN>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
            return;

          case SZABAB:
            FE<2,SZABAB>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
            return;

#endif
            
          case XYZ:
            FEXYZ<2>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
            return;

          default:
            libmesh_error();
          }
      }

      
      // 3D
    case 3:
      {
        switch (fe_t.family)
          {
          case HERMITE:
            FE<3,HERMITE>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
            return;
            
          case HIERARCHIC:
            FE<3,HIERARCHIC>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
            return;
            
          case LAGRANGE:
            FE<3,LAGRANGE>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
            return;
            
          case MONOMIAL:
            FE<3,MONOMIAL>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
            return;

          case SCALAR:
            FE<3,SCALAR>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
            return;
            
#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES

          case BERNSTEIN:
            FE<3,BERNSTEIN>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
            return;

          case SZABAB:
            FE<3,SZABAB>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
            return;

#endif
            
          case XYZ:
            FEXYZ<3>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
            return;
            
          default:
            libmesh_error();
          }
      }


    default:
      libmesh_error();
    }

  
  libmesh_error();
  return;
}

Point FEInterface::inverse_map (const unsigned intdim, const FEType &fe_t, const Elem *elem, const Point &p, const Realtolerance = TOLERANCE, const boolsecure = true) [static]Returns:

the location (on the reference element) of the point p located in physical space. This function requires inverting the (probably nonlinear) transformation map, so it is not trivial. The optional parameter tolerance defines how close is 'good enough.' The map inversion iteration computes the sequence $ p_n $, and the iteration is terminated when $ p - p_n < mbox{ exttt{tolerance}} $

Definition at line 1191 of file fe_interface.C.

References libMeshEnums::BERNSTEIN, libMeshEnums::CLOUGH, FEType::family, libMeshEnums::HERMITE, libMeshEnums::HIERARCHIC, ifem_inverse_map(), is_InfFE_elem(), libMeshEnums::LAGRANGE, libMeshEnums::MONOMIAL, libMeshEnums::SCALAR, libMeshEnums::SZABAB, Elem::type(), and libMeshEnums::XYZ.

Referenced by HPCoarsenTest::add_projection(), FEBase::coarsened_dof_values(), FEBase::compute_periodic_constraints(), FEBase::compute_proj_constraints(), InfQuad4::contains_point(), Elem::contains_point(), InfPrism6::contains_point(), InfHex8::contains_point(), FEMContext::fixed_point_value(), MeshFunction::gradient(), MeshFunction::hessian(), ifem_inverse_map(), inverse_map(), System::ProjectVector::operator()(), MeshFunction::operator()(), FEMContext::point_value(), and HPCoarsenTest::select_refinement().

{
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS

  if ( is_InfFE_elem(elem->type()) )
    return ifem_inverse_map(dim, fe_t, elem, p,tolerance, secure);

#endif

  switch (dim)
    {
      // 1D
    case 1:
      {
        switch (fe_t.family)
          {
          case CLOUGH:
            return FE<1,CLOUGH>::inverse_map(elem, p, tolerance, secure);
            
          case HERMITE:
            return FE<1,HERMITE>::inverse_map(elem, p, tolerance, secure);
            
          case HIERARCHIC:
            return FE<1,HIERARCHIC>::inverse_map(elem, p, tolerance, secure);
            
          case LAGRANGE:
            return FE<1,LAGRANGE>::inverse_map(elem, p, tolerance, secure);
            
          case MONOMIAL:
            return FE<1,MONOMIAL>::inverse_map(elem, p, tolerance, secure);

          case SCALAR:
            return FE<1,SCALAR>::inverse_map(elem, p, tolerance, secure);

#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES

          case BERNSTEIN:
            return FE<1,BERNSTEIN>::inverse_map(elem, p, tolerance, secure);

          case SZABAB:
            return FE<1,SZABAB>::inverse_map(elem, p, tolerance, secure);

#endif
          case XYZ:
            return FEXYZ<1>::inverse_map(elem, p, tolerance, secure);


          default:
            libmesh_error();
          }
      }

      
      // 2D
    case 2:
      {
        switch (fe_t.family)
          {
          case CLOUGH:
            return FE<2,CLOUGH>::inverse_map(elem, p, tolerance, secure);
            
          case HERMITE:
            return FE<2,HERMITE>::inverse_map(elem, p, tolerance, secure);
            
          case HIERARCHIC:
            return FE<2,HIERARCHIC>::inverse_map(elem, p, tolerance, secure);
            
          case LAGRANGE:
            return FE<2,LAGRANGE>::inverse_map(elem, p, tolerance, secure);
            
          case MONOMIAL:
            return FE<2,MONOMIAL>::inverse_map(elem, p, tolerance, secure);

          case SCALAR:
            return FE<2,SCALAR>::inverse_map(elem, p, tolerance, secure);

#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES

          case BERNSTEIN:
            return FE<2,BERNSTEIN>::inverse_map(elem, p, tolerance, secure);

          case SZABAB:
            return FE<2,SZABAB>::inverse_map(elem, p, tolerance, secure);

#endif
          case XYZ:
            return FEXYZ<2>::inverse_map(elem, p, tolerance, secure);

          default:
            libmesh_error();
          }
      }

      
      // 3D
    case 3:
      {
        switch (fe_t.family)
          {
          case HERMITE:
            return FE<3,HERMITE>::inverse_map(elem, p, tolerance, secure);
            
          case HIERARCHIC:
            return FE<3,HIERARCHIC>::inverse_map(elem, p, tolerance, secure);
            
          case LAGRANGE:
            return FE<3,LAGRANGE>::inverse_map(elem, p, tolerance, secure);
            
          case MONOMIAL:
            return FE<3,MONOMIAL>::inverse_map(elem, p, tolerance, secure);

          case SCALAR:
            return FE<3,SCALAR>::inverse_map(elem, p, tolerance, secure);

#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES

          case BERNSTEIN:
            return FE<3,BERNSTEIN>::inverse_map(elem, p, tolerance, secure);

          case SZABAB:
            return FE<3,SZABAB>::inverse_map(elem, p, tolerance, secure);

#endif
          case XYZ:
            return FEXYZ<3>::inverse_map(elem, p, tolerance, secure);

          default:
            libmesh_error();
          }
      }


    default:
      libmesh_error();
    }

  
  libmesh_error();
  Point pt;
  return pt;
}

bool FEInterface::is_InfFE_elem (const ElemTypeet) [inline, static, private]Returns:

true if et is an element to be processed by class InfFE. Otherwise, it returns false. For compatibility with disabled infinite elements it always returns false.

Definition at line 381 of file fe_interface.h.

Referenced by compute_data(), inverse_map(), n_dofs(), n_dofs_at_node(), n_dofs_per_elem(), n_shape_functions(), nodal_soln(), and shape().

{
  return false; 
}

unsigned int FEInterface::max_order (const FEType &fe_t, const ElemType &el_t) [static]Returns the maximum polynomial degree that the given finite element family can support on the given geometric element.

Definition at line 2002 of file fe_interface.C.

References libMeshEnums::BERNSTEIN, libMeshEnums::CLOUGH, libMeshEnums::EDGE2, libMeshEnums::EDGE3, libMeshEnums::EDGE4, FEType::family, libMeshEnums::HERMITE, libMeshEnums::HEX20, libMeshEnums::HEX27, libMeshEnums::HEX8, libMeshEnums::HIERARCHIC, libMeshEnums::LAGRANGE, libMeshEnums::MONOMIAL, libMeshEnums::PRISM15, libMeshEnums::PRISM18, libMeshEnums::PRISM6, libMeshEnums::PYRAMID5, libMeshEnums::QUAD4, libMeshEnums::QUAD8, libMeshEnums::QUAD9, libMeshEnums::SZABAB, libMeshEnums::TET10, libMeshEnums::TET4, libMeshEnums::TRI3, libMeshEnums::TRI6, and libMeshEnums::XYZ.

Referenced by DofMap::reinit().

{
  // Yeah, I know, infinity is much larger than 11, but our
  // solvers don't seem to like high degree polynomials, and our
  // quadrature rules and number_lookups tables
  // need to go up higher.
  const unsigned int unlimited = 11;

  // If we used 0 as a default, then elements missing from this 
  // table (e.g. infinite elements) would be considered broken.
  const unsigned int unknown = unlimited;

  switch (fe_t.family)
    {
      case LAGRANGE:
        switch (el_t)
          {
            case EDGE2:
            case EDGE3:
            case EDGE4:
              return 3;
            case TRI3:
              return 1;
            case TRI6:
              return 2;
            case QUAD4:
              return 1;
            case QUAD8:
            case QUAD9:
              return 2;
            case TET4:
              return 1;
            case TET10:
              return 2;
            case HEX8:
              return 1;
            case HEX20:
            case HEX27:
              return 2;
            case PRISM6:
            case PRISM15:
              return 1;
            case PRISM18:
              return 2;
            case PYRAMID5:
              return 1;
            default:
              return unknown;
          }
        break;
      case MONOMIAL:
        switch (el_t)
          {
            case EDGE2:
            case EDGE3:
            case EDGE4:
            case TRI3:
            case TRI6:
            case QUAD4:
            case QUAD8:
            case QUAD9:
            case TET4:
            case TET10:
            case HEX8:
            case HEX20:
            case HEX27:
            case PRISM6:
            case PRISM15:
            case PRISM18:
            case PYRAMID5:
              return unlimited;
            default:
              return unknown;
          }
        break;
#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES
      case BERNSTEIN:
        switch (el_t)
          {
            case EDGE2:
            case EDGE3:
            case EDGE4:
              return unlimited;
            case TRI3:
              return 0;
            case TRI6:
              return 6;
            case QUAD4:
              return 0;
            case QUAD8:
            case QUAD9:
              return unlimited;
            case TET4:
              return 1;
            case TET10:
              return 2;
            case HEX8:
              return 0;
            case HEX20:
              return 2;
            case HEX27:
              return 4;
            case PRISM6:
            case PRISM15:
            case PRISM18:
            case PYRAMID5:
              return 0;
            default:
              return unknown;
          }
        break;
      case SZABAB:
        switch (el_t)
          {
            case EDGE2:
            case EDGE3:
            case EDGE4:
              return 7;
            case TRI3:
              return 0;
            case TRI6:
              return 7;
            case QUAD4:
              return 0;
            case QUAD8:
            case QUAD9:
              return 7;
            case TET4:
            case TET10:
            case HEX8:
            case HEX20:
            case HEX27:
            case PRISM6:
            case PRISM15:
            case PRISM18:
            case PYRAMID5:
              return 0;
            default:
              return unknown;
          }
        break;
#endif
      case XYZ:
        switch (el_t)
          {
            case EDGE2:
            case EDGE3:
            case EDGE4:
            case TRI3:
            case TRI6:
            case QUAD4:
            case QUAD8:
            case QUAD9:
            case TET4:
            case TET10:
            case HEX8:
            case HEX20:
            case HEX27:
            case PRISM6:
            case PRISM15:
            case PRISM18:
            case PYRAMID5:
              return unlimited;
            default:
              return unknown;
          }
        break;
      case CLOUGH:
        switch (el_t)
          {
            case EDGE2:
            case EDGE3:
              return 3;
            case EDGE4:
            case TRI3:
              return 0;
            case TRI6:
              return 3;
            case QUAD4:
            case QUAD8:
            case QUAD9:
            case TET4:
            case TET10:
            case HEX8:
            case HEX20:
            case HEX27:
            case PRISM6:
            case PRISM15:
            case PRISM18:
            case PYRAMID5:
              return 0;
            default:
              return unknown;
          }
        break;
      case HERMITE:
        switch (el_t)
          {
            case EDGE2:
            case EDGE3:
              return unlimited;
            case EDGE4:
            case TRI3:
            case TRI6:
              return 0;
            case QUAD4:
              return 3;
            case QUAD8:
            case QUAD9:
              return unlimited;
            case TET4:
            case TET10:
              return 0;
            case HEX8:
              return 3;
            case HEX20:
            case HEX27:
              return unlimited;
            case PRISM6:
            case PRISM15:
            case PRISM18:
            case PYRAMID5:
              return 0;
            default:
              return unknown;
          }
        break;
      case HIERARCHIC:
        switch (el_t)
          {
            case EDGE2:
            case EDGE3:
            case EDGE4:
              return unlimited;
            case TRI3:
              return 1;
            case TRI6:
              return unlimited;
            case QUAD4:
              return 1;
            case QUAD8:
            case QUAD9:
              return unlimited;
            case TET4:
            case TET10:
              return 0;
            case HEX8:
            case HEX20:
              return 1;
            case HEX27:
              return unlimited;
            case PRISM6:
            case PRISM15:
            case PRISM18:
            case PYRAMID5:
              return 0;
            default:
              return unknown;
          }
        break;
      default:
        return 0;
        break;
    }
}

unsigned int FEInterface::n_dofs (const unsigned intdim, const FEType &fe_t, const ElemTypet) [static]Returns:

the number of shape functions associated with this finite element. Automatically decides which finite element class to use.

On a p-refined element, fe_t.order should be the total order of the element.

Definition at line 199 of file fe_interface.C.

References libMeshEnums::BERNSTEIN, libMeshEnums::CLOUGH, FEType::family, libMeshEnums::HERMITE, libMeshEnums::HIERARCHIC, ifem_n_dofs(), is_InfFE_elem(), libMeshEnums::LAGRANGE, libMeshEnums::MONOMIAL, FEType::order, libMeshEnums::SCALAR, libMeshEnums::SZABAB, and libMeshEnums::XYZ.

Referenced by FEBase::coarsened_dof_values(), compute_data(), ifem_n_dofs(), InfFE< Dim, T_radial, T_map >::n_dofs(), and HPCoarsenTest::select_refinement().

{
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS

  if ( is_InfFE_elem(t) )
    return ifem_n_dofs(dim, fe_t, t);

#endif

  const Order o = fe_t.order;

  switch (dim)
    {
      // 1D
    case 1:
      {
        switch (fe_t.family)
          {
          case CLOUGH:
            return FE<1,CLOUGH>::n_dofs(t, o);
            
          case HERMITE:
            return FE<1,HERMITE>::n_dofs(t, o);
            
          case HIERARCHIC:
            return FE<1,HIERARCHIC>::n_dofs(t, o);
            
          case LAGRANGE:
            return FE<1,LAGRANGE>::n_dofs(t, o);
            
          case MONOMIAL:
            return FE<1,MONOMIAL>::n_dofs(t, o);

          case SCALAR:
            return FE<1,SCALAR>::n_dofs(t, o);

#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES

          case BERNSTEIN:
            return FE<1,BERNSTEIN>::n_dofs(t, o);

          case SZABAB:
            return FE<1,SZABAB>::n_dofs(t, o);

#endif
            
          case XYZ:
            return FEXYZ<1>::n_dofs(t, o);

          default:
            libmesh_error();
          }
      }

      
      // 2D
    case 2:
      {
        switch (fe_t.family)
          {
          case CLOUGH:
            return FE<2,CLOUGH>::n_dofs(t, o);
            
          case HERMITE:
            return FE<2,HERMITE>::n_dofs(t, o);
            
          case HIERARCHIC:
            return FE<2,HIERARCHIC>::n_dofs(t, o);
            
          case LAGRANGE:
            return FE<2,LAGRANGE>::n_dofs(t, o);
            
          case MONOMIAL:
            return FE<2,MONOMIAL>::n_dofs(t, o);

          case SCALAR:
            return FE<2,SCALAR>::n_dofs(t, o);

#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES

          case BERNSTEIN:
            return FE<2,BERNSTEIN>::n_dofs(t, o);

          case SZABAB:
            return FE<2,SZABAB>::n_dofs(t, o);

#endif
            
          case XYZ:
            return FEXYZ<2>::n_dofs(t, o);

          default:
            libmesh_error();
          }
      }

      
      // 3D
    case 3:
      {
        switch (fe_t.family)
          {
          case HERMITE:
            return FE<3,HERMITE>::n_dofs(t, o);
            
          case HIERARCHIC:
            return FE<3,HIERARCHIC>::n_dofs(t, o);
            
          case LAGRANGE:
            return FE<3,LAGRANGE>::n_dofs(t, o);
            
          case MONOMIAL:
            return FE<3,MONOMIAL>::n_dofs(t, o);

          case SCALAR:
            return FE<3,SCALAR>::n_dofs(t, o);

#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES

          case BERNSTEIN:
            return FE<3,BERNSTEIN>::n_dofs(t, o);

          case SZABAB:
            return FE<3,SZABAB>::n_dofs(t, o);

#endif
            
          case XYZ:
            return FEXYZ<3>::n_dofs(t, o);

          default:
            libmesh_error();
          }
      }


    default:
      libmesh_error();
    }

  
  libmesh_error();
  return 0;
}

unsigned int FEInterface::n_dofs_at_node (const unsigned intdim, const FEType &fe_t, const ElemTypet, const unsigned intn) [static]Returns:

the number of dofs at node n for a finite element of type fe_t. Automatically decides which finite element class to use.

On a p-refined element, fe_t.order should be the total order of the element.

Definition at line 349 of file fe_interface.C.

References libMeshEnums::BERNSTEIN, libMeshEnums::CLOUGH, FEType::family, libMeshEnums::HERMITE, libMeshEnums::HIERARCHIC, ifem_n_dofs_at_node(), is_InfFE_elem(), libMeshEnums::LAGRANGE, libMeshEnums::MONOMIAL, FEType::order, libMeshEnums::SCALAR, libMeshEnums::SZABAB, and libMeshEnums::XYZ.

Referenced by FEBase::coarsened_dof_values(), InfFE< Dim, T_radial, T_map >::compute_shape_indices(), DofMap::constrain_p_dofs(), DofMap::dof_indices(), ifem_n_dofs_at_node(), InfFE< Dim, T_radial, T_map >::n_dofs_at_node(), DofMap::old_dof_indices(), System::ProjectVector::operator()(), and DofMap::reinit().

{
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS

  if ( is_InfFE_elem(t) )
    return ifem_n_dofs_at_node(dim, fe_t, t, n);

#endif

  const Order o = fe_t.order;
  
  switch (dim)
    {
      // 1D
    case 1:
      {
        switch (fe_t.family)
          {
          case CLOUGH:
            return FE<1,CLOUGH>::n_dofs_at_node(t, o, n);
            
          case HERMITE:
            return FE<1,HERMITE>::n_dofs_at_node(t, o, n);
            
          case HIERARCHIC:
            return FE<1,HIERARCHIC>::n_dofs_at_node(t, o, n);
            
          case LAGRANGE:
            return FE<1,LAGRANGE>::n_dofs_at_node(t, o, n);
            
          case MONOMIAL:
            return FE<1,MONOMIAL>::n_dofs_at_node(t, o, n);

          case SCALAR:
            return FE<1,SCALAR>::n_dofs_at_node(t, o, n);

#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES

          case BERNSTEIN:
            return FE<1,BERNSTEIN>::n_dofs_at_node(t, o, n);

          case SZABAB:
            return FE<1,SZABAB>::n_dofs_at_node(t, o, n);

#endif
            
          case XYZ:
            return FEXYZ<1>::n_dofs_at_node(t, o, n);

          default:
            libmesh_error();
          }
      }

      
      // 2D
    case 2:
      {
        switch (fe_t.family)
          {
          case CLOUGH:
            return FE<2,CLOUGH>::n_dofs_at_node(t, o, n);
            
          case HERMITE:
            return FE<2,HERMITE>::n_dofs_at_node(t, o, n);
            
          case HIERARCHIC:
            return FE<2,HIERARCHIC>::n_dofs_at_node(t, o, n);
            
          case LAGRANGE:
            return FE<2,LAGRANGE>::n_dofs_at_node(t, o, n);
            
          case MONOMIAL:
            return FE<2,MONOMIAL>::n_dofs_at_node(t, o, n);

          case SCALAR:
            return FE<2,SCALAR>::n_dofs_at_node(t, o, n);

#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES

          case BERNSTEIN:
            return FE<2,BERNSTEIN>::n_dofs_at_node(t, o, n);

          case SZABAB:
            return FE<2,SZABAB>::n_dofs_at_node(t, o, n);

#endif
            
          case XYZ:
            return FEXYZ<2>::n_dofs_at_node(t, o, n);

          default:
            libmesh_error();
          }
      }

      
      // 3D
    case 3:
      {
        switch (fe_t.family)
          {
          case HERMITE:
            return FE<3,HERMITE>::n_dofs_at_node(t, o, n);
            
          case HIERARCHIC:
            return FE<3,HIERARCHIC>::n_dofs_at_node(t, o, n);
            
          case LAGRANGE:
            return FE<3,LAGRANGE>::n_dofs_at_node(t, o, n);
            
          case MONOMIAL:
            return FE<3,MONOMIAL>::n_dofs_at_node(t, o, n);

          case SCALAR:
            return FE<3,SCALAR>::n_dofs_at_node(t, o, n);

#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES

          case BERNSTEIN:
            return FE<3,BERNSTEIN>::n_dofs_at_node(t, o, n);

          case SZABAB:
            return FE<3,SZABAB>::n_dofs_at_node(t, o, n);

#endif
            
          case XYZ:
            return FEXYZ<3>::n_dofs_at_node(t, o, n);

          default:
            libmesh_error();
          }
      }


    default:
      libmesh_error();
    }

  
  libmesh_error();
  return 0;
}

unsigned int FEInterface::n_dofs_per_elem (const unsigned intdim, const FEType &fe_t, const ElemTypet) [static]Returns:

the number of dofs interior to the element, not associated with any interior nodes. Automatically decides which finite element class to use.

On a p-refined element, fe_t.order should be the total order of the element.

Definition at line 501 of file fe_interface.C.

References libMeshEnums::BERNSTEIN, libMeshEnums::CLOUGH, FEType::family, libMeshEnums::HERMITE, libMeshEnums::HIERARCHIC, ifem_n_dofs_per_elem(), is_InfFE_elem(), libMeshEnums::LAGRANGE, libMeshEnums::MONOMIAL, FEType::order, libMeshEnums::SCALAR, libMeshEnums::SZABAB, and libMeshEnums::XYZ.

Referenced by InfFE< Dim, T_radial, T_map >::compute_shape_indices(), DofMap::dof_indices(), ifem_n_dofs_per_elem(), InfFE< Dim, T_radial, T_map >::n_dofs_per_elem(), DofMap::old_dof_indices(), and DofMap::reinit().

{
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS

  if ( is_InfFE_elem(t) )
    return ifem_n_dofs_per_elem(dim, fe_t, t);

#endif

  const Order o = fe_t.order;

  switch (dim)
    {
      // 1D
    case 1:
      {
        switch (fe_t.family)
          {
          case CLOUGH:
            return FE<1,CLOUGH>::n_dofs_per_elem(t, o);
            
          case HERMITE:
            return FE<1,HERMITE>::n_dofs_per_elem(t, o);
            
          case HIERARCHIC:
            return FE<1,HIERARCHIC>::n_dofs_per_elem(t, o);
            
          case LAGRANGE:
            return FE<1,LAGRANGE>::n_dofs_per_elem(t, o);
            
          case MONOMIAL:
            return FE<1,MONOMIAL>::n_dofs_per_elem(t, o);

          case SCALAR:
            return FE<1,SCALAR>::n_dofs_per_elem(t, o);

#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES

          case BERNSTEIN:
            return FE<1,BERNSTEIN>::n_dofs_per_elem(t, o);

          case SZABAB:
            return FE<1,SZABAB>::n_dofs_per_elem(t, o);

#endif
            
          case XYZ:
            return FEXYZ<1>::n_dofs_per_elem(t, o);

          default:
            libmesh_error();
          }
      }

      
      // 2D
    case 2:
      {
        switch (fe_t.family)
          {
          case CLOUGH:
            return FE<2,CLOUGH>::n_dofs_per_elem(t, o);
            
          case HERMITE:
            return FE<2,HERMITE>::n_dofs_per_elem(t, o);
            
          case HIERARCHIC:
            return FE<2,HIERARCHIC>::n_dofs_per_elem(t, o);
            
          case LAGRANGE:
            return FE<2,LAGRANGE>::n_dofs_per_elem(t, o);
            
          case MONOMIAL:
            return FE<2,MONOMIAL>::n_dofs_per_elem(t, o);

          case SCALAR:
            return FE<2,SCALAR>::n_dofs_per_elem(t, o);

#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES

          case BERNSTEIN:
            return FE<2,BERNSTEIN>::n_dofs_per_elem(t, o);

          case SZABAB:
            return FE<2,SZABAB>::n_dofs_per_elem(t, o);

#endif
            
          case XYZ:
            return FEXYZ<2>::n_dofs_per_elem(t, o);

          default:
            libmesh_error();
          }
      }

      
      // 3D
    case 3:
      {
        switch (fe_t.family)
          {
          case HERMITE:
            return FE<3,HERMITE>::n_dofs_per_elem(t, o);
            
          case HIERARCHIC:
            return FE<3,HIERARCHIC>::n_dofs_per_elem(t, o);
            
          case LAGRANGE:
            return FE<3,LAGRANGE>::n_dofs_per_elem(t, o);
            
          case MONOMIAL:
            return FE<3,MONOMIAL>::n_dofs_per_elem(t, o);

          case SCALAR:
            return FE<3,SCALAR>::n_dofs_per_elem(t, o);

#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES

          case BERNSTEIN:
            return FE<3,BERNSTEIN>::n_dofs_per_elem(t, o);

          case SZABAB:
            return FE<3,SZABAB>::n_dofs_per_elem(t, o);

#endif
            
          case XYZ:
            return FEXYZ<3>::n_dofs_per_elem(t, o);

          default:
            libmesh_error();
          }
      }


    default:
      libmesh_error();
    }

  
  libmesh_error();
  return 0;
}

unsigned int FEInterface::n_shape_functions (const unsigned intdim, const FEType &fe_t, const ElemTypet) [static]Returns:

the number of shape functions associated with this finite element of type fe_t. Automatically decides which finite element class to use.

On a p-refined element, fe_t.order should be the total order of the element.

Definition at line 41 of file fe_interface.C.

References libMeshEnums::BERNSTEIN, libMeshEnums::CLOUGH, FEType::family, libMeshEnums::HERMITE, libMeshEnums::HIERARCHIC, ifem_n_shape_functions(), is_InfFE_elem(), libMeshEnums::LAGRANGE, libMeshEnums::MONOMIAL, FEType::order, libMeshEnums::SCALAR, libMeshEnums::SZABAB, and libMeshEnums::XYZ.

Referenced by ifem_n_shape_functions().

{

#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
  /*
   * Since the FEType, stored in DofMap/(some System child), has to
   * be the _same_ for InfFE and FE, we have to catch calls
   * to infinite elements through the element type.
   */

  if ( is_InfFE_elem(t) )
    return ifem_n_shape_functions(dim, fe_t, t);

#endif

  const Order o = fe_t.order;
  
  switch (dim)
    {
      // 1D
    case 1:
      {
        switch (fe_t.family)
          {
          case CLOUGH:
            return FE<1,CLOUGH>::n_shape_functions(t, o);
            
          case HERMITE:
            return FE<1,HERMITE>::n_shape_functions(t, o);
            
          case HIERARCHIC:
            return FE<1,HIERARCHIC>::n_shape_functions(t, o);
            
          case LAGRANGE:
            return FE<1,LAGRANGE>::n_shape_functions(t, o);
            
          case MONOMIAL:
            return FE<1,MONOMIAL>::n_shape_functions(t, o);

          case SCALAR:
            return FE<1,SCALAR>::n_shape_functions(t, o);

#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES

          case BERNSTEIN:
            return FE<1,BERNSTEIN>::n_shape_functions(t, o);

          case SZABAB:
            return FE<1,SZABAB>::n_shape_functions(t, o);

#endif
            
          case XYZ:
            return FEXYZ<1>::n_shape_functions(t, o);


          default:
            libmesh_error();
          }
      }

      
      // 2D
    case 2:
      {
        switch (fe_t.family)
          {
          case CLOUGH:
            return FE<2,CLOUGH>::n_shape_functions(t, o);
            
          case HERMITE:
            return FE<2,HERMITE>::n_shape_functions(t, o);
            
          case HIERARCHIC:
            return FE<2,HIERARCHIC>::n_shape_functions(t, o);
            
          case LAGRANGE:
            return FE<2,LAGRANGE>::n_shape_functions(t, o);
            
          case MONOMIAL:
            return FE<2,MONOMIAL>::n_shape_functions(t, o);

          case SCALAR:
            return FE<2,SCALAR>::n_shape_functions(t, o);

#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES

          case BERNSTEIN:
            return FE<2,BERNSTEIN>::n_shape_functions(t, o);

          case SZABAB:
            return FE<2,SZABAB>::n_shape_functions(t, o);

#endif
            
          case XYZ:
            return FEXYZ<2>::n_shape_functions(t, o);

          default:
            libmesh_error();
          }
      }

      
      // 3D
    case 3:
      {
        switch (fe_t.family)
          {
          case HERMITE:
            return FE<3,HERMITE>::n_shape_functions(t, o);
            
          case HIERARCHIC:
            return FE<3,HIERARCHIC>::n_shape_functions(t, o);
            
          case LAGRANGE:
            return FE<3,LAGRANGE>::n_shape_functions(t, o);
            
          case MONOMIAL:
            return FE<3,MONOMIAL>::n_shape_functions(t, o);

          case SCALAR:
            return FE<3,SCALAR>::n_shape_functions(t, o);

#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES

          case BERNSTEIN:
            return FE<3,BERNSTEIN>::n_shape_functions(t, o);

          case SZABAB:
            return FE<3,SZABAB>::n_shape_functions(t, o);

#endif
            
          case XYZ:
            return FEXYZ<3>::n_shape_functions(t, o);

          default:
            libmesh_error();
          }
      }


    default:
      libmesh_error();
    }

  
  libmesh_error();
  return 0;
}

void FEInterface::nodal_soln (const unsigned intdim, const FEType &fe_t, const Elem *elem, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln) [static]Build the nodal soln from the element soln. This is the solution that will be plotted. Automatically passes the request to the appropriate finite element class member. To indicate that results from this specific implementation of nodal_soln should not be used, the vector nodal_soln is returned empty.

On a p-refined element, fe_t.order should be the base order of the element.

Definition at line 988 of file fe_interface.C.

References libMeshEnums::BERNSTEIN, libMeshEnums::CLOUGH, FEType::family, libMeshEnums::HERMITE, libMeshEnums::HIERARCHIC, ifem_nodal_soln(), is_InfFE_elem(), libMeshEnums::LAGRANGE, libMeshEnums::MONOMIAL, FEType::order, libMeshEnums::SCALAR, libMeshEnums::SZABAB, Elem::type(), and libMeshEnums::XYZ.

Referenced by EquationSystems::build_discontinuous_solution_vector(), EquationSystems::build_solution_vector(), ifem_nodal_soln(), EnsightIO::write_scalar_ascii(), and EnsightIO::write_vector_ascii().

{
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS

  if ( is_InfFE_elem(elem->type()) )
  {
    ifem_nodal_soln(dim, fe_t, elem, elem_soln, nodal_soln);
    return;
  }

#endif

  const Order order = fe_t.order;
  
  switch (dim)
    {
      // 1D
    case 1:
      {
        switch (fe_t.family)
          {
          case CLOUGH:
            FE<1,CLOUGH>::nodal_soln(elem, order,
                                     elem_soln, nodal_soln);
            return;
            
          case HERMITE:
            FE<1,HERMITE>::nodal_soln(elem, order,
                                     elem_soln, nodal_soln);
            return;
            
          case HIERARCHIC:
            FE<1,HIERARCHIC>::nodal_soln(elem, order,
                                         elem_soln, nodal_soln);
            return;

          case LAGRANGE:
            FE<1,LAGRANGE>::nodal_soln(elem, order,
                                       elem_soln, nodal_soln);
            return;
   
          case MONOMIAL:
            FE<1,MONOMIAL>::nodal_soln(elem, order,
                                       elem_soln, nodal_soln);
            return;

          case SCALAR:
            FE<1,SCALAR>::nodal_soln(elem, order,
                                       elem_soln, nodal_soln);
            return;

#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES

          case BERNSTEIN:
            FE<1,BERNSTEIN>::nodal_soln(elem, order,
                                     elem_soln, nodal_soln);
            return;

          case SZABAB:
            FE<1,SZABAB>::nodal_soln(elem, order,
                                     elem_soln, nodal_soln);
            return;

#endif

          case XYZ:
            FEXYZ<1>::nodal_soln(elem, order,
                                 elem_soln, nodal_soln);
            return;

          default:
            libmesh_error();
          }
      }

      
      // 2D
    case 2:
      {
        switch (fe_t.family)
          {
          case CLOUGH:
            FE<2,CLOUGH>::nodal_soln(elem, order,
                                     elem_soln, nodal_soln);
            return;
            
          case HERMITE:
            FE<2,HERMITE>::nodal_soln(elem, order,
                                     elem_soln, nodal_soln);
            return;
            
          case HIERARCHIC:
            FE<2,HIERARCHIC>::nodal_soln(elem, order,
                                         elem_soln, nodal_soln);
            return;
            
          case LAGRANGE:
            FE<2,LAGRANGE>::nodal_soln(elem, order,
                                       elem_soln, nodal_soln);
            return;
   
          case MONOMIAL:
            FE<2,MONOMIAL>::nodal_soln(elem, order,
                                       elem_soln, nodal_soln);
            return;

          case SCALAR:
            FE<2,SCALAR>::nodal_soln(elem, order,
                                       elem_soln, nodal_soln);
            return;

#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES

          case BERNSTEIN:
            FE<2,BERNSTEIN>::nodal_soln(elem, order,
                                     elem_soln, nodal_soln);
            return;

          case SZABAB:
            FE<2,SZABAB>::nodal_soln(elem, order,
                                     elem_soln, nodal_soln);
            return;

#endif

          case XYZ:
            FEXYZ<2>::nodal_soln(elem, order,
                                 elem_soln, nodal_soln);
            return;

          default:
            libmesh_error();
          }
      }

      
      // 3D
    case 3:
      {
        switch (fe_t.family)
          {
          case HERMITE:
            FE<3,HERMITE>::nodal_soln(elem, order,
                                     elem_soln, nodal_soln);
            return;
            
          case HIERARCHIC:
            FE<3,HIERARCHIC>::nodal_soln(elem, order,
                                         elem_soln, nodal_soln);
            return;
            
          case LAGRANGE:
            FE<3,LAGRANGE>::nodal_soln(elem, order,
                                       elem_soln, nodal_soln);
            return;
            
          case MONOMIAL:
            FE<3,MONOMIAL>::nodal_soln(elem, order,
                                       elem_soln, nodal_soln);
            return;

          case SCALAR:
            FE<3,SCALAR>::nodal_soln(elem, order,
                                       elem_soln, nodal_soln);
            return;

#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES

          case BERNSTEIN:
            FE<3,BERNSTEIN>::nodal_soln(elem, order,
                                     elem_soln, nodal_soln);
            return;

          case SZABAB:
            FE<3,SZABAB>::nodal_soln(elem, order,
                                     elem_soln, nodal_soln);
            return;

#endif

          case XYZ:
            FEXYZ<3>::nodal_soln(elem, order,
                                 elem_soln, nodal_soln);
            return;

          default:
            libmesh_error();
          }
      }


    default:
      libmesh_error();
    }
}

bool FEInterface::on_reference_element (const Point &p, const ElemTypet, const Realeps = 1.e-6) [static]Returns:

true if the point p is located on the reference element for element type t, false otherwise. Since we are doing floating point comparisons here the parameter eps can be specified to indicate a tolerance. For example, $ x

---

comes $ x

---

finition at line 1542 of file fe_interface.C.

Referenced by InfQuad4::contains_point(), Elem::contains_point(), InfPrism6::contains_point(), InfHex8::contains_point(), and ifem_on_reference_element().

{
  return FEBase::on_reference_element(p,t,eps);
}

Real FEInterface::shape (const unsigned intdim, const FEType &fe_t, const Elem *elem, const unsigned inti, const Point &p) [static]Returns:

the value of the $ i^{th} $ shape function at point p. This method allows you to specify the dimension, element type, and order directly. Automatically passes the request to the appropriate finite element class member.

On a p-refined element, fe_t.order should be the base order of the element.

Definition at line 1704 of file fe_interface.C.

References libMeshEnums::BERNSTEIN, libMeshEnums::CLOUGH, FEType::family, libMeshEnums::HERMITE, libMeshEnums::HIERARCHIC, ifem_shape(), is_InfFE_elem(), libMeshEnums::LAGRANGE, libMeshEnums::MONOMIAL, FEType::order, libMeshEnums::SCALAR, shape(), libMeshEnums::SZABAB, Elem::type(), and libMeshEnums::XYZ.

{
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS

  if ( is_InfFE_elem(elem->type()) )
    return ifem_shape(dim, fe_t, elem, i, p);

#endif

  const Order o = fe_t.order;

  switch (dim)
    {
      // 1D
    case 1:
      {
        switch (fe_t.family)
          {
          case CLOUGH:
            return FE<1,CLOUGH>::shape(elem,o,i,p);
            
          case HERMITE:
            return FE<1,HERMITE>::shape(elem,o,i,p);
            
          case HIERARCHIC:
            return FE<1,HIERARCHIC>::shape(elem,o,i,p);
            
          case LAGRANGE:
            return FE<1,LAGRANGE>::shape(elem,o,i,p);
            
          case MONOMIAL:
            return FE<1,MONOMIAL>::shape(elem,o,i,p);

          case SCALAR:
            return FE<1,SCALAR>::shape(elem,o,i,p);

#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES

          case BERNSTEIN:
            return FE<1,BERNSTEIN>::shape(elem,o,i,p);

          case SZABAB:
            return FE<1,SZABAB>::shape(elem,o,i,p);

#endif
            
          case XYZ:
            return FEXYZ<1>::shape(elem,o,i,p);

          default:
            libmesh_error();
          }
      }

      
      // 2D
    case 2:
      {
        switch (fe_t.family)
          {
          case CLOUGH:
            return FE<2,CLOUGH>::shape(elem,o,i,p);
            
          case HERMITE:
            return FE<2,HERMITE>::shape(elem,o,i,p);
            
          case HIERARCHIC:
            return FE<2,HIERARCHIC>::shape(elem,o,i,p);
            
          case LAGRANGE:
            return FE<2,LAGRANGE>::shape(elem,o,i,p);
            
          case MONOMIAL:
            return FE<2,MONOMIAL>::shape(elem,o,i,p);

          case SCALAR:
            return FE<2,SCALAR>::shape(elem,o,i,p);

#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES

          case BERNSTEIN:
            return FE<2,BERNSTEIN>::shape(elem,o,i,p);

          case SZABAB:
            return FE<2,SZABAB>::shape(elem,o,i,p);

#endif
            
          case XYZ:
            return FEXYZ<2>::shape(elem,o,i,p);

          default:
            libmesh_error();
          }
      }

      
      // 3D
    case 3:
      {
        switch (fe_t.family)
          {
          case HERMITE:
            return FE<3,HERMITE>::shape(elem,o,i,p);
            
          case HIERARCHIC:
            return FE<3,HIERARCHIC>::shape(elem,o,i,p);
            
          case LAGRANGE:
            return FE<3,LAGRANGE>::shape(elem,o,i,p);
            
          case MONOMIAL:
            return FE<3,MONOMIAL>::shape(elem,o,i,p);

          case SCALAR:
            return FE<3,SCALAR>::shape(elem,o,i,p);

#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES

          case BERNSTEIN:
            return FE<3,BERNSTEIN>::shape(elem,o,i,p);

          case SZABAB:
            return FE<3,SZABAB>::shape(elem,o,i,p);

#endif
            
          case XYZ:
            return FEXYZ<3>::shape(elem,o,i,p);

          default:
            libmesh_error();
          }
      }


    default:
      libmesh_error();
    }

  
  libmesh_error();
  return 0.;
}

Real FEInterface::shape (const unsigned intdim, const FEType &fe_t, const ElemTypet, const unsigned inti, const Point &p) [static]Returns:

the value of the $ i^{th} $ shape function at point p. This method allows you to specify the dimension, element type, and order directly. Automatically passes the request to the appropriate finite element class member.

On a p-refined element, fe_t.order should be the total order of the element.

Definition at line 1552 of file fe_interface.C.

References libMeshEnums::BERNSTEIN, libMeshEnums::CLOUGH, FEType::family, libMeshEnums::HERMITE, libMeshEnums::HIERARCHIC, ifem_shape(), is_InfFE_elem(), libMeshEnums::LAGRANGE, libMeshEnums::MONOMIAL, FEType::order, libMeshEnums::SCALAR, libMeshEnums::SZABAB, and libMeshEnums::XYZ.

Referenced by InfFE< Dim, T_radial, T_map >::compute_data(), compute_data(), FEMContext::fixed_point_value(), ifem_shape(), System::ProjectVector::operator()(), FEMContext::point_value(), InfFE< Dim, T_radial, T_map >::shape(), and shape().

{
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS

  if ( is_InfFE_elem(t) )
    return ifem_shape(dim, fe_t, t, i, p);

#endif

  const Order o = fe_t.order;
  
  switch (dim)
    {
      // 1D
    case 1:
      {
        switch (fe_t.family)
          {
          case CLOUGH:
            return FE<1,CLOUGH>::shape(t,o,i,p);
            
          case HERMITE:
            return FE<1,HERMITE>::shape(t,o,i,p);
            
          case HIERARCHIC:
            return FE<1,HIERARCHIC>::shape(t,o,i,p);
            
          case LAGRANGE:
            return FE<1,LAGRANGE>::shape(t,o,i,p);
            
          case MONOMIAL:
            return FE<1,MONOMIAL>::shape(t,o,i,p);

          case SCALAR:
            return FE<1,SCALAR>::shape(t,o,i,p);

#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES

          case BERNSTEIN:
            return FE<1,BERNSTEIN>::shape(t,o,i,p);

          case SZABAB:
            return FE<1,SZABAB>::shape(t,o,i,p);

#endif
            
          case XYZ:
            return FEXYZ<1>::shape(t,o,i,p);

          default:
            libmesh_error();
          }
      }

      
      // 2D
    case 2:
      {
        switch (fe_t.family)
          {
          case CLOUGH:
            return FE<2,CLOUGH>::shape(t,o,i,p);
            
          case HERMITE:
            return FE<2,HERMITE>::shape(t,o,i,p);
            
          case HIERARCHIC:
            return FE<2,HIERARCHIC>::shape(t,o,i,p);
            
          case LAGRANGE:
            return FE<2,LAGRANGE>::shape(t,o,i,p);
            
          case MONOMIAL:
            return FE<2,MONOMIAL>::shape(t,o,i,p);

          case SCALAR:
            return FE<2,SCALAR>::shape(t,o,i,p);

#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES

          case BERNSTEIN:
            return FE<2,BERNSTEIN>::shape(t,o,i,p);

          case SZABAB:
            return FE<2,SZABAB>::shape(t,o,i,p);

#endif
            
          case XYZ:
            return FEXYZ<2>::shape(t,o,i,p);

          default:
            libmesh_error();
          }
      }

      
      // 3D
    case 3:
      {
        switch (fe_t.family)
          {
          case HERMITE:
            return FE<3,HERMITE>::shape(t,o,i,p);
            
          case HIERARCHIC:
            return FE<3,HIERARCHIC>::shape(t,o,i,p);
            
          case LAGRANGE:
            return FE<3,LAGRANGE>::shape(t,o,i,p);
            
          case MONOMIAL:
            return FE<3,MONOMIAL>::shape(t,o,i,p);

          case SCALAR:
            return FE<3,SCALAR>::shape(t,o,i,p);

#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES

          case BERNSTEIN:
            return FE<3,BERNSTEIN>::shape(t,o,i,p);

          case SZABAB:
            return FE<3,SZABAB>::shape(t,o,i,p);

#endif
            
          case XYZ:
            return FEXYZ<3>::shape(t,o,i,p);

          default:
            libmesh_error();
          }
      }


    default:
      libmesh_error();
    }

  
  libmesh_error();
  return 0.;
}

Author

Generated automatically by Doxygen for libMesh from the source code.

Index

NAME

SYNOPSIS

Public Member Functions

Static Public Member Functions

Private Member Functions

Static Private Member Functions

Detailed Description

Constructor & Destructor Documentation

FEInterface::FEInterface () [private]Empty constructor. Do not create an object of this type.

virtual FEInterface::~FEInterface () [inline, virtual]Destructor.

Member Function Documentation

void FEInterface::compute_constraints (DofConstraints &constraints, DofMap &dof_map, const unsigned intvariable_number, const Elem *elem) [static]Computes the constraint matrix contributions (for non-conforming adapted meshes) corresponding to variable number var_number.

void FEInterface::compute_data (const unsigned intdim, const FEType &fe_t, const Elem *elem, FEComputeData &data) [static]Lets the appropriate child of FEBase compute the requested data for the input specified in data, and returns the values also through data. See this as a generalization of shape(). Currently, with disabled infinite elements, returns a vector of all shape functions of elem evaluated ap p.

void FEInterface::compute_periodic_constraints (DofConstraints &constraints, DofMap &dof_map, PeriodicBoundaries &boundaries, const MeshBase &mesh, const unsigned intvariable_number, const Elem *elem) [static]Computes the constraint matrix contributions (for periodic boundary conditions) corresponding to variable number var_number.

void FEInterface::dofs_on_edge (const Elem *constelem, const unsigned intdim, const FEType &fe_t, unsigned inte, std::vector< unsigned int > &di) [static]Fills the vector di with the local degree of freedom indices associated with edge e of element elem Automatically decides which finite element class to use.

void FEInterface::dofs_on_side (const Elem *constelem, const unsigned intdim, const FEType &fe_t, unsigned ints, std::vector< unsigned int > &di) [static]Fills the vector di with the local degree of freedom indices associated with side s of element elem Automatically decides which finite element class to use.

bool FEInterface::extra_hanging_dofs (const FEType &fe_t) [static]Returns true if separate degrees of freedom must be allocated for vertex DoFs and edge/face DoFs at a hanging node.

void FEInterface::ifem_compute_data (const unsigned intdim, const FEType &fe_t, const Elem *elem, FEComputeData &data) [static, private]

Point FEInterface::ifem_inverse_map (const unsigned intdim, const FEType &fe_t, const Elem *elem, const Point &p, const Realtolerance = TOLERANCE, const boolsecure = true) [static, private]

void FEInterface::ifem_inverse_map (const unsigned intdim, const FEType &fe_t, const Elem *elem, const std::vector< Point > &physical_points, std::vector< Point > &reference_points, const Realtolerance = TOLERANCE, const boolsecure = true) [static, private]

unsigned int FEInterface::ifem_n_dofs (const unsigned intdim, const FEType &fe_t, const ElemTypet) [static, private]

unsigned int FEInterface::ifem_n_dofs_at_node (const unsigned intdim, const FEType &fe_t, const ElemTypet, const unsigned intn) [static, private]

unsigned int FEInterface::ifem_n_dofs_per_elem (const unsigned intdim, const FEType &fe_t, const ElemTypet) [static, private]

unsigned int FEInterface::ifem_n_shape_functions (const unsigned intdim, const FEType &fe_t, const ElemTypet) [static, private]

void FEInterface::ifem_nodal_soln (const unsigned intdim, const FEType &fe_t, const Elem *elem, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln) [static, private]

bool FEInterface::ifem_on_reference_element (const Point &p, const ElemTypet, const Realeps) [static, private]

Real FEInterface::ifem_shape (const unsigned intdim, const FEType &fe_t, const ElemTypet, const unsigned inti, const Point &p) [static, private]

Real FEInterface::ifem_shape (const unsigned intdim, const FEType &fe_t, const Elem *elem, const unsigned inti, const Point &p) [static, private]

void FEInterface::inverse_map (const unsigned intdim, const FEType &fe_t, const Elem *elem, const std::vector< Point > &physical_points, std::vector< Point > &reference_points, const Realtolerance = TOLERANCE, const boolsecure = true) [static]Returns:

Point FEInterface::inverse_map (const unsigned intdim, const FEType &fe_t, const Elem *elem, const Point &p, const Realtolerance = TOLERANCE, const boolsecure = true) [static]Returns:

bool FEInterface::is_InfFE_elem (const ElemTypeet) [inline, static, private]Returns:

unsigned int FEInterface::max_order (const FEType &fe_t, const ElemType &el_t) [static]Returns the maximum polynomial degree that the given finite element family can support on the given geometric element.

unsigned int FEInterface::n_dofs (const unsigned intdim, const FEType &fe_t, const ElemTypet) [static]Returns:

unsigned int FEInterface::n_dofs_at_node (const unsigned intdim, const FEType &fe_t, const ElemTypet, const unsigned intn) [static]Returns:

unsigned int FEInterface::n_dofs_per_elem (const unsigned intdim, const FEType &fe_t, const ElemTypet) [static]Returns:

unsigned int FEInterface::n_shape_functions (const unsigned intdim, const FEType &fe_t, const ElemTypet) [static]Returns:

void FEInterface::nodal_soln (const unsigned intdim, const FEType &fe_t, const Elem *elem, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln) [static]Build the nodal soln from the element soln. This is the solution that will be plotted. Automatically passes the request to the appropriate finite element class member. To indicate that results from this specific implementation of nodal_soln should not be used, the vector nodal_soln is returned empty.

bool FEInterface::on_reference_element (const Point &p, const ElemTypet, const Realeps = 1.e-6) [static]Returns:

Real FEInterface::shape (const unsigned intdim, const FEType &fe_t, const Elem *elem, const unsigned inti, const Point &p) [static]Returns:

Real FEInterface::shape (const unsigned intdim, const FEType &fe_t, const ElemTypet, const unsigned inti, const Point &p) [static]Returns:

Author