libMesh
Public Types | Public Member Functions | Static Public Member Functions | Private Member Functions | Static Private Member Functions | List of all members
libMesh::FEInterface Class Reference

This class provides an encapsulated access to all static public member functions of finite element classes. More...

#include <fe_interface.h>

Public Types

typedef unsigned int(* n_dofs_at_node_ptr) (const ElemType, const Order, const unsigned int)
 
typedef Real(* shape_ptr) (const Elem *elem, const Order o, const unsigned int i, const Point &p, const bool add_p_level)
 
typedef Real(* shape_deriv_ptr) (const Elem *elem, const Order o, const unsigned int i, const unsigned int j, const Point &p, const bool add_p_level)
 
typedef Real(* shape_second_deriv_ptr) (const Elem *elem, const Order o, const unsigned int i, const unsigned int j, const Point &p, const bool add_p_level)
 

Public Member Functions

virtual ~FEInterface ()
 Destructor. More...
 

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 (const unsigned int dim, const FEType &fe_t, const Elem *elem)
 Similar to the function above but takes an Elem * and accounts for p-refinement internally, if any. More...
 
static unsigned int n_dofs_at_node (const unsigned int dim, const FEType &fe_t, const ElemType t, const unsigned int n)
 
static n_dofs_at_node_ptr n_dofs_at_node_function (const unsigned int dim, const FEType &fe_t)
 
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)
 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. More...
 
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)
 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. More...
 
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)
 Build the nodal soln from the element soln. More...
 
static Point map (unsigned int dim, const FEType &fe_t, const Elem *elem, const Point &p)
 This is now deprecated; use FEMap::map instead. More...
 
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)
 This is now deprecated; use FEMap::inverse_map instead. More...
 
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)
 This is now deprecated; use FEMap::inverse_map instead. More...
 
static bool on_reference_element (const Point &p, const ElemType t, const Real eps=TOLERANCE)
 
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)
 
template<typename OutputType >
static void shape (const unsigned int dim, const FEType &fe_t, const ElemType t, const unsigned int i, const Point &p, OutputType &phi)
 
template<typename OutputType >
static void shape (const unsigned int dim, const FEType &fe_t, const Elem *elem, const unsigned int i, const Point &p, OutputType &phi)
 
static shape_ptr shape_function (const unsigned int dim, const FEType &fe_t)
 
static Real shape_deriv (const unsigned int dim, const FEType &fe_t, const ElemType t, const unsigned int i, const unsigned int j, const Point &p)
 
static Real shape_deriv (const unsigned int dim, const FEType &fe_t, const Elem *elem, const unsigned int i, const unsigned int j, const Point &p)
 
static shape_deriv_ptr shape_deriv_function (const unsigned int dim, const FEType &fe_t)
 
static Real shape_second_deriv (const unsigned int dim, const FEType &fe_t, const ElemType t, const unsigned int i, const unsigned int j, const Point &p)
 
static Real shape_second_deriv (const unsigned int dim, const FEType &fe_t, const Elem *elem, const unsigned int i, const unsigned int j, const Point &p)
 
static shape_second_deriv_ptr shape_second_deriv_function (const unsigned int dim, const FEType &fe_t)
 
static void compute_data (const unsigned int dim, const FEType &fe_t, const Elem *elem, FEComputeData &data)
 Lets the appropriate child of FEBase compute the requested data for the input specified in data, and sets the values in data. More...
 
static void compute_constraints (DofConstraints &constraints, DofMap &dof_map, const unsigned int variable_number, const Elem *elem)
 Computes the constraint matrix contributions (for non-conforming adapted meshes) corresponding to variable number var_number. More...
 
static void compute_periodic_constraints (DofConstraints &constraints, DofMap &dof_map, const PeriodicBoundaries &boundaries, const MeshBase &mesh, const PointLocatorBase *point_locator, const unsigned int variable_number, const Elem *elem)
 Computes the constraint matrix contributions (for periodic boundary conditions) corresponding to variable number var_number. More...
 
static unsigned int max_order (const FEType &fe_t, const ElemType &el_t)
 
static bool extra_hanging_dofs (const FEType &fe_t)
 
static FEFieldType field_type (const FEType &fe_type)
 
static FEFieldType field_type (const FEFamily &fe_family)
 
static unsigned int n_vec_dim (const MeshBase &mesh, const FEType &fe_type)
 
static FEContinuity get_continuity (const FEType &fe_type)
 Returns the input FEType's FEContinuity based on the underlying FEFamily and potentially the Order, although we do not currently support FEs with order-dependent continuity. More...
 
template<>
void shape (const unsigned int dim, const FEType &fe_t, const ElemType t, const unsigned int i, const Point &p, Real &phi)
 
template<>
void shape (const unsigned int dim, const FEType &fe_t, const Elem *elem, const unsigned int i, const Point &p, Real &phi)
 
template<>
void shape (const unsigned int dim, const FEType &fe_t, const ElemType t, const unsigned int i, const Point &p, RealGradient &phi)
 
template<>
void shape (const unsigned int dim, const FEType &fe_t, const Elem *elem, const unsigned int i, const Point &p, RealGradient &phi)
 

Private Member Functions

 FEInterface ()
 Empty constructor. More...
 

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_map (const unsigned int dim, const FEType &fe_t, const Elem *elem, const Point &p)
 
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 Real ifem_shape_deriv (const unsigned int dim, const FEType &fe_t, const ElemType t, const unsigned int i, const unsigned int j, const Point &p)
 
static Real ifem_shape_deriv (const unsigned int dim, const FEType &fe_t, const Elem *elem, const unsigned int i, const unsigned int j, 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
Date
2002-2007

Interface class which provides access to FE functions.

Definition at line 65 of file fe_interface.h.

Member Typedef Documentation

◆ n_dofs_at_node_ptr

typedef unsigned int(* libMesh::FEInterface::n_dofs_at_node_ptr) (const ElemType, const Order, const unsigned int)

Definition at line 126 of file fe_interface.h.

◆ shape_deriv_ptr

typedef Real(* libMesh::FEInterface::shape_deriv_ptr) (const Elem *elem, const Order o, const unsigned int i, const unsigned int j, const Point &p, const bool add_p_level)

Definition at line 345 of file fe_interface.h.

◆ shape_ptr

typedef Real(* libMesh::FEInterface::shape_ptr) (const Elem *elem, const Order o, const unsigned int i, const Point &p, const bool add_p_level)

Definition at line 296 of file fe_interface.h.

◆ shape_second_deriv_ptr

typedef Real(* libMesh::FEInterface::shape_second_deriv_ptr) (const Elem *elem, const Order o, const unsigned int i, const unsigned int j, const Point &p, const bool add_p_level)

Definition at line 409 of file fe_interface.h.

Constructor & Destructor Documentation

◆ FEInterface()

libMesh::FEInterface::FEInterface ( )
private

Empty constructor.

Do not create an object of this type.

Definition at line 36 of file fe_interface.C.

37 {
38  libmesh_error_msg("ERROR: Do not define an object of this type.");
39 }

◆ ~FEInterface()

virtual libMesh::FEInterface::~FEInterface ( )
inlinevirtual

Destructor.

Definition at line 79 of file fe_interface.h.

79 {}

Member Function Documentation

◆ compute_constraints()

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

Computes the constraint matrix contributions (for non-conforming adapted meshes) corresponding to variable number var_number.

Definition at line 1103 of file fe_interface.C.

1107 {
1108  libmesh_assert(elem);
1109 
1110  const FEType & fe_t = dof_map.variable_type(variable_number);
1111 
1112  switch (elem->dim())
1113  {
1114  case 0:
1115  case 1:
1116  {
1117  // No constraints in 0D/1D.
1118  return;
1119  }
1120 
1121 
1122  case 2:
1123  {
1124  switch (fe_t.family)
1125  {
1126  case CLOUGH:
1127  FE<2,CLOUGH>::compute_constraints (constraints,
1128  dof_map,
1129  variable_number,
1130  elem); return;
1131 
1132  case HERMITE:
1133  FE<2,HERMITE>::compute_constraints (constraints,
1134  dof_map,
1135  variable_number,
1136  elem); return;
1137 
1138  case LAGRANGE:
1139  FE<2,LAGRANGE>::compute_constraints (constraints,
1140  dof_map,
1141  variable_number,
1142  elem); return;
1143 
1144  case HIERARCHIC:
1145  FE<2,HIERARCHIC>::compute_constraints (constraints,
1146  dof_map,
1147  variable_number,
1148  elem); return;
1149 
1150  case L2_HIERARCHIC:
1151  FE<2,L2_HIERARCHIC>::compute_constraints (constraints,
1152  dof_map,
1153  variable_number,
1154  elem); return;
1155 
1156  case LAGRANGE_VEC:
1157  FE<2,LAGRANGE_VEC>::compute_constraints (constraints,
1158  dof_map,
1159  variable_number,
1160  elem); return;
1161 
1162 
1163 #ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES
1164  case SZABAB:
1165  FE<2,SZABAB>::compute_constraints (constraints,
1166  dof_map,
1167  variable_number,
1168  elem); return;
1169 
1170  case BERNSTEIN:
1171  FE<2,BERNSTEIN>::compute_constraints (constraints,
1172  dof_map,
1173  variable_number,
1174  elem); return;
1175 
1176  case RATIONAL_BERNSTEIN:
1177  FE<2,RATIONAL_BERNSTEIN>::compute_constraints (constraints,
1178  dof_map,
1179  variable_number,
1180  elem); return;
1181 
1182 #endif
1183  default:
1184  return;
1185  }
1186  }
1187 
1188 
1189  case 3:
1190  {
1191  switch (fe_t.family)
1192  {
1193  case HERMITE:
1194  FE<3,HERMITE>::compute_constraints (constraints,
1195  dof_map,
1196  variable_number,
1197  elem); return;
1198 
1199  case LAGRANGE:
1200  FE<3,LAGRANGE>::compute_constraints (constraints,
1201  dof_map,
1202  variable_number,
1203  elem); return;
1204 
1205  case HIERARCHIC:
1206  FE<3,HIERARCHIC>::compute_constraints (constraints,
1207  dof_map,
1208  variable_number,
1209  elem); return;
1210 
1211  case L2_HIERARCHIC:
1212  FE<3,L2_HIERARCHIC>::compute_constraints (constraints,
1213  dof_map,
1214  variable_number,
1215  elem); return;
1216 
1217  case LAGRANGE_VEC:
1218  FE<3,LAGRANGE_VEC>::compute_constraints (constraints,
1219  dof_map,
1220  variable_number,
1221  elem); return;
1222 #ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES
1223  case SZABAB:
1224  FE<3,SZABAB>::compute_constraints (constraints,
1225  dof_map,
1226  variable_number,
1227  elem); return;
1228 
1229  case BERNSTEIN:
1230  FE<3,BERNSTEIN>::compute_constraints (constraints,
1231  dof_map,
1232  variable_number,
1233  elem); return;
1234 
1235  case RATIONAL_BERNSTEIN:
1236  FE<3,RATIONAL_BERNSTEIN>::compute_constraints (constraints,
1237  dof_map,
1238  variable_number,
1239  elem); return;
1240 
1241 #endif
1242  default:
1243  return;
1244  }
1245  }
1246 
1247 
1248  default:
1249  libmesh_error_msg("Invalid dimension = " << elem->dim());
1250  }
1251 }

References libMesh::BERNSTEIN, libMesh::CLOUGH, libMesh::FE< Dim, T >::compute_constraints(), libMesh::Elem::dim(), libMesh::FEType::family, libMesh::HERMITE, libMesh::HIERARCHIC, libMesh::L2_HIERARCHIC, libMesh::LAGRANGE, libMesh::LAGRANGE_VEC, libMesh::libmesh_assert(), libMesh::RATIONAL_BERNSTEIN, libMesh::SZABAB, and libMesh::DofMap::variable_type().

◆ compute_data()

void libMesh::FEInterface::compute_data ( const unsigned int  dim,
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 sets the values in data.

See this as a generalization of shape(). With infinite elements disabled, computes values for all shape functions of elem evaluated at p.

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

Definition at line 1028 of file fe_interface.C.

1032 {
1033 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
1034 
1035  if (elem && is_InfFE_elem(elem->type()))
1036  {
1037  data.init();
1038  ifem_compute_data(dim, fe_t, elem, data);
1039  return;
1040  }
1041 
1042 #endif
1043 
1044  const unsigned int n_dof = n_dofs (dim, fe_t, elem);
1045  const Point & p = data.p;
1046  data.shape.resize(n_dof);
1047 
1048  if (data.need_derivative())
1049  {
1050  data.dshape.resize(n_dof);
1051  data.local_transform.resize(dim);
1052 
1053  for (unsigned int d=0; d<dim; d++)
1054  data.local_transform[d].resize(dim);
1055 
1056  UniquePtr<FEBase> fe (FEBase::build(dim, fe_t));
1057  std::vector<Point> pt(1);
1058  pt[0]=p;
1059  fe->get_dphideta(); // to compute the map
1060  fe->reinit(elem, &pt);
1061 
1062  // compute the reference->physical map.
1063  data.local_transform[0][0] = fe->get_dxidx()[0];
1064  if (dim > 1)
1065  {
1066  data.local_transform[1][0] = fe->get_detadx()[0];
1067  data.local_transform[1][1] = fe->get_detady()[0];
1068  data.local_transform[0][1] = fe->get_dxidy()[0];
1069  if (dim > 2)
1070  {
1071  data.local_transform[2][0] = fe->get_dzetadx()[0];
1072  data.local_transform[2][1] = fe->get_dzetady()[0];
1073  data.local_transform[2][2] = fe->get_dzetadz()[0];
1074  data.local_transform[1][2] = fe->get_detadz()[0];
1075  data.local_transform[0][2] = fe->get_dxidz()[0];
1076  }
1077  }
1078  }
1079 
1080  // set default values for all the output fields
1081  data.init();
1082 
1083  for (unsigned int n=0; n<n_dof; n++)
1084  {
1085  // Here we pass the original fe_t object. Additional p-levels
1086  // (if any) are handled internally by the shape() and
1087  // shape_deriv() functions since they have access to the elem
1088  // pointer. Note that we are already using the n_dof value
1089  // appropriate to the elevated p-level.
1090  data.shape[n] = shape(dim, fe_t, elem, n, p);
1091  if (data.need_derivative())
1092  {
1093  for (unsigned int j=0; j<dim; j++)
1094  data.dshape[n](j) = shape_deriv(dim, fe_t, elem, n, j, p);
1095  }
1096  }
1097 }

References libMesh::FEGenericBase< OutputType >::build(), data, dim, ifem_compute_data(), is_InfFE_elem(), n_dofs(), shape(), shape_deriv(), and libMesh::Elem::type().

Referenced by libMesh::MeshFunction::discontinuous_gradient(), libMesh::MeshFunction::discontinuous_value(), libMesh::DTKEvaluator::evaluate(), libMesh::MeshFunction::gradient(), libMesh::MeshFunction::operator()(), libMesh::System::point_gradient(), and libMesh::System::point_value().

◆ compute_periodic_constraints()

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

Computes the constraint matrix contributions (for periodic boundary conditions) corresponding to variable number var_number.

Definition at line 1259 of file fe_interface.C.

1266 {
1267  // No element-specific optimizations currently exist
1268  FEBase::compute_periodic_constraints (constraints,
1269  dof_map,
1270  boundaries,
1271  mesh,
1272  point_locator,
1273  variable_number,
1274  elem);
1275 }

References libMesh::FEGenericBase< OutputType >::compute_periodic_constraints(), and mesh.

◆ dofs_on_edge()

void libMesh::FEInterface::dofs_on_edge ( const Elem *const  elem,
const unsigned int  dim,
const FEType &  fe_t,
unsigned int  e,
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 566 of file fe_interface.C.

571 {
572  const Order o = fe_t.order;
573 
574  void_fe_with_vec_switch(dofs_on_edge(elem, o, e, di));
575 }

References libMesh::FEType::order.

Referenced by libMesh::FEGenericBase< FEOutputType< T >::type >::coarsened_dof_values(), and libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectEdges::operator()().

◆ dofs_on_side()

void libMesh::FEInterface::dofs_on_side ( const Elem *const  elem,
const unsigned int  dim,
const FEType &  fe_t,
unsigned int  s,
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 553 of file fe_interface.C.

558 {
559  const Order o = fe_t.order;
560 
561  void_fe_with_vec_switch(dofs_on_side(elem, o, s, di));
562 }

References libMesh::FEType::order.

Referenced by libMesh::FEGenericBase< FEOutputType< T >::type >::coarsened_dof_values(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_proj_constraints(), and libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectSides::operator()().

◆ extra_hanging_dofs()

bool libMesh::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 1656 of file fe_interface.C.

1657 {
1658  switch (fe_t.family)
1659  {
1660  case LAGRANGE:
1661  case L2_LAGRANGE:
1662  case MONOMIAL:
1663  case MONOMIAL_VEC:
1664  case L2_HIERARCHIC:
1665  case XYZ:
1666  case SUBDIVISION:
1667  case LAGRANGE_VEC:
1668  case NEDELEC_ONE:
1669  return false;
1670  case CLOUGH:
1671  case HERMITE:
1672  case HIERARCHIC:
1673 #ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES
1674  case BERNSTEIN:
1675  case SZABAB:
1676  case RATIONAL_BERNSTEIN:
1677 #endif
1678  default:
1679  return true;
1680  }
1681 }

References libMesh::BERNSTEIN, libMesh::CLOUGH, libMesh::FEType::family, libMesh::HERMITE, libMesh::HIERARCHIC, libMesh::L2_HIERARCHIC, libMesh::L2_LAGRANGE, libMesh::LAGRANGE, libMesh::LAGRANGE_VEC, libMesh::MONOMIAL, libMesh::MONOMIAL_VEC, libMesh::NEDELEC_ONE, libMesh::RATIONAL_BERNSTEIN, libMesh::SUBDIVISION, libMesh::SZABAB, and libMesh::XYZ.

Referenced by libMesh::DofMap::_dof_indices(), libMesh::DofMap::_node_dof_indices(), libMesh::DofMap::old_dof_indices(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SortAndCopy::operator()(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectVertices::operator()(), and libMesh::DofMap::reinit().

◆ field_type() [1/2]

FEFieldType libMesh::FEInterface::field_type ( const FEFamily &  fe_family)
static
Returns
The number of components of a vector-valued element. Scalar-valued elements return 1.

Definition at line 1688 of file fe_interface.C.

1689 {
1690  switch (fe_family)
1691  {
1692  case LAGRANGE_VEC:
1693  case NEDELEC_ONE:
1694  case MONOMIAL_VEC:
1695  return TYPE_VECTOR;
1696  default:
1697  return TYPE_SCALAR;
1698  }
1699 }

References libMesh::LAGRANGE_VEC, libMesh::MONOMIAL_VEC, libMesh::NEDELEC_ONE, libMesh::TYPE_SCALAR, and libMesh::TYPE_VECTOR.

◆ field_type() [2/2]

FEFieldType libMesh::FEInterface::field_type ( const FEType &  fe_type)
static
Returns
The number of components of a vector-valued element. Scalar-valued elements return 1.

Definition at line 1683 of file fe_interface.C.

1684 {
1685  return FEInterface::field_type(fe_type.family);
1686 }

References libMesh::FEType::family.

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::EquationSystems::build_variable_names(), libMesh::ExactSolution::compute_error(), libMesh::FEGenericBase< FEOutputType< T >::type >::determine_calculations(), libMesh::ExactSolution::error_norm(), and libMesh::FEMSystem::init_context().

◆ get_continuity()

FEContinuity libMesh::FEInterface::get_continuity ( const FEType &  fe_type)
static

Returns the input FEType's FEContinuity based on the underlying FEFamily and potentially the Order, although we do not currently support FEs with order-dependent continuity.

These should exactly match the FEBase::get_continuity() specializations/overrides for the different FE types.

Definition at line 1719 of file fe_interface.C.

1720 {
1721  switch (fe_type.family)
1722  {
1723  // Discontinuous elements
1724  case MONOMIAL:
1725  case MONOMIAL_VEC:
1726  case L2_HIERARCHIC:
1727  case L2_LAGRANGE:
1728  case XYZ:
1729  case SCALAR:
1730  return DISCONTINUOUS;
1731 
1732  // C0 elements
1733  case LAGRANGE:
1734  case HIERARCHIC:
1735  case BERNSTEIN:
1736  case SZABAB:
1737  case RATIONAL_BERNSTEIN:
1738  case INFINITE_MAP:
1739  case JACOBI_20_00:
1740  case JACOBI_30_00:
1741  case LEGENDRE:
1742  case LAGRANGE_VEC:
1743  return C_ZERO;
1744 
1745  // C1 elements
1746  case CLOUGH:
1747  case HERMITE:
1748  case SUBDIVISION:
1749  return C_ONE;
1750 
1751  case NEDELEC_ONE:
1752  return H_CURL;
1753 
1754  default:
1755  libmesh_error_msg("Unknown FE Family " << Utility::enum_to_string(fe_type.family));
1756  }
1757 }

References libMesh::BERNSTEIN, libMesh::C_ONE, libMesh::C_ZERO, libMesh::CLOUGH, libMesh::DISCONTINUOUS, libMesh::Utility::enum_to_string(), libMesh::FEType::family, libMesh::H_CURL, libMesh::HERMITE, libMesh::HIERARCHIC, libMesh::INFINITE_MAP, libMesh::JACOBI_20_00, libMesh::JACOBI_30_00, libMesh::L2_HIERARCHIC, libMesh::L2_LAGRANGE, libMesh::LAGRANGE, libMesh::LAGRANGE_VEC, libMesh::LEGENDRE, libMesh::MONOMIAL, libMesh::MONOMIAL_VEC, libMesh::NEDELEC_ONE, libMesh::RATIONAL_BERNSTEIN, libMesh::SCALAR, libMesh::SUBDIVISION, libMesh::SZABAB, and libMesh::XYZ.

◆ ifem_compute_data()

void libMesh::FEInterface::ifem_compute_data ( const unsigned int  dim,
const FEType &  fe_t,
const Elem *  elem,
FEComputeData &  data 
)
staticprivate

Definition at line 918 of file fe_interface_inf_fe.C.

922 {
923  switch (dim)
924  {
925  // 1D
926  case 1:
927  {
928  switch (fe_t.radial_family)
929  {
930  /*
931  * For no derivatives (and local coordinates, as
932  * given in \p p) the infinite element shapes
933  * are independent of mapping type
934  */
935  case INFINITE_MAP:
936  InfFE<1,INFINITE_MAP,CARTESIAN>::compute_data(fe_t, elem, data);
937  break;
938 
939  case JACOBI_20_00:
940  InfFE<1,JACOBI_20_00,CARTESIAN>::compute_data(fe_t, elem, data);
941  break;
942 
943  case JACOBI_30_00:
944  InfFE<1,JACOBI_30_00,CARTESIAN>::compute_data(fe_t, elem, data);
945  break;
946 
947  case LEGENDRE:
948  InfFE<1,LEGENDRE,CARTESIAN>::compute_data(fe_t, elem, data);
949  break;
950 
951  case LAGRANGE:
952  InfFE<1,LAGRANGE,CARTESIAN>::compute_data(fe_t, elem, data);
953  break;
954 
955  default:
956  libmesh_error_msg("Invalid radial family = " << fe_t.radial_family);
957  }
958 
959  break;
960  }
961 
962 
963  // 2D
964  case 2:
965  {
966  switch (fe_t.radial_family)
967  {
968  case INFINITE_MAP:
969  InfFE<2,INFINITE_MAP,CARTESIAN>::compute_data(fe_t, elem, data);
970  break;
971 
972  case JACOBI_20_00:
973  InfFE<2,JACOBI_20_00,CARTESIAN>::compute_data(fe_t, elem, data);
974  break;
975 
976  case JACOBI_30_00:
977  InfFE<2,JACOBI_30_00,CARTESIAN>::compute_data(fe_t, elem, data);
978  break;
979 
980  case LEGENDRE:
981  InfFE<2,LEGENDRE,CARTESIAN>::compute_data(fe_t, elem, data);
982  break;
983 
984  case LAGRANGE:
985  InfFE<2,LAGRANGE,CARTESIAN>::compute_data(fe_t, elem, data);
986  break;
987 
988  default:
989  libmesh_error_msg("Invalid radial family = " << fe_t.radial_family);
990  }
991 
992  break;
993  }
994 
995 
996  // 3D
997  case 3:
998  {
999  switch (fe_t.radial_family)
1000  {
1001  case INFINITE_MAP:
1002  InfFE<3,INFINITE_MAP,CARTESIAN>::compute_data(fe_t, elem, data);
1003  break;
1004 
1005  case JACOBI_20_00:
1006  InfFE<3,JACOBI_20_00,CARTESIAN>::compute_data(fe_t, elem, data);
1007  break;
1008 
1009  case JACOBI_30_00:
1010  InfFE<3,JACOBI_30_00,CARTESIAN>::compute_data(fe_t, elem, data);
1011  break;
1012 
1013  case LEGENDRE:
1014  InfFE<3,LEGENDRE,CARTESIAN>::compute_data(fe_t, elem, data);
1015  break;
1016 
1017  case LAGRANGE:
1018  InfFE<3,LAGRANGE,CARTESIAN>::compute_data(fe_t, elem, data);
1019  break;
1020 
1021  default:
1022  libmesh_error_msg("Invalid radial family = " << fe_t.radial_family);
1023  }
1024 
1025  break;
1026  }
1027 
1028 
1029  default:
1030  libmesh_error_msg("Invalid dim = " << dim);
1031  break;
1032  }
1033 }

References libMesh::InfFE< Dim, T_radial, T_map >::compute_data(), data, dim, libMesh::INFINITE_MAP, libMesh::JACOBI_20_00, libMesh::JACOBI_30_00, libMesh::LAGRANGE, libMesh::LEGENDRE, and libMesh::FEType::radial_family.

Referenced by compute_data().

◆ ifem_inverse_map() [1/2]

Point libMesh::FEInterface::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 
)
staticprivate

Definition at line 510 of file fe_interface_inf_fe.C.

516 {
517  switch (dim)
518  {
519  // 1D
520  case 1:
521  {
522  switch (fe_t.inf_map)
523  {
524  case CARTESIAN:
525  return InfFE<1,JACOBI_20_00,CARTESIAN>::inverse_map(elem, p, tolerance, secure);
526 
527  case SPHERICAL:
528  case ELLIPSOIDAL:
529  libmesh_not_implemented_msg("ERROR: Spherical and Ellipsoidal IFEMs not (yet) implemented.");
530 
531  /*
532  case SPHERICAL:
533  return InfFE<1,JACOBI_20_00,SPHERICAL>::inverse_map(elem, p, tolerance);
534 
535  case ELLIPSOIDAL:
536  return InfFE<1,JACOBI_20_00,ELLIPSOIDAL>::inverse_map(elem, p, tolerance);
537  */
538 
539  default:
540  libmesh_error_msg("Invalid map = " << fe_t.inf_map);
541  }
542  }
543 
544 
545  // 2D
546  case 2:
547  {
548  switch (fe_t.inf_map)
549  {
550  case CARTESIAN:
551  return InfFE<2,JACOBI_20_00,CARTESIAN>::inverse_map(elem, p, tolerance, secure);
552 
553  case SPHERICAL:
554  case ELLIPSOIDAL:
555  libmesh_not_implemented_msg("ERROR: Spherical and Ellipsoidal IFEMs not (yet) implemented.");
556 
557  /*
558  case SPHERICAL:
559  return InfFE<2,JACOBI_20_00,SPHERICAL>::inverse_map(elem, p, tolerance);
560 
561  case ELLIPSOIDAL:
562  return InfFE<2,JACOBI_20_00,ELLIPSOIDAL>::inverse_map(elem, p, tolerance);
563  */
564 
565  default:
566  libmesh_error_msg("Invalid map = " << fe_t.inf_map);
567  }
568  }
569 
570 
571  // 3D
572  case 3:
573  {
574  switch (fe_t.inf_map)
575  {
576  case CARTESIAN:
577  return InfFE<3,JACOBI_20_00,CARTESIAN>::inverse_map(elem, p, tolerance, secure);
578 
579  case SPHERICAL:
580  case ELLIPSOIDAL:
581  libmesh_not_implemented_msg("ERROR: Spherical and Ellipsoidal IFEMs not (yet) implemented.");
582 
583  /*
584  case SPHERICAL:
585  return InfFE<3,JACOBI_20_00,SPHERICAL>::inverse_map(elem, p, tolerance);
586 
587  case ELLIPSOIDAL:
588  return InfFE<3,JACOBI_20_00,ELLIPSOIDAL>::inverse_map(elem, p, tolerance);
589  */
590 
591  default:
592  libmesh_error_msg("Invalid map = " << fe_t.inf_map);
593  }
594  }
595 
596  default:
597  libmesh_error_msg("Invalid dim = " << dim);
598  }
599 }

References libMesh::CARTESIAN, dim, libMesh::ELLIPSOIDAL, libMesh::FEType::inf_map, libMesh::InfFE< Dim, T_radial, T_map >::inverse_map(), and libMesh::SPHERICAL.

Referenced by inverse_map().

◆ ifem_inverse_map() [2/2]

void libMesh::FEInterface::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 
)
staticprivate

Definition at line 603 of file fe_interface_inf_fe.C.

610 {
611  switch (dim)
612  {
613  // 1D
614  case 1:
615  {
616  switch (fe_t.inf_map)
617  {
618  case CARTESIAN:
619  InfFE<1,JACOBI_20_00,CARTESIAN>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
620  return;
621 
622  default:
623  libmesh_error_msg("Invalid map = " << fe_t.inf_map);
624  }
625  }
626 
627 
628  // 2D
629  case 2:
630  {
631  switch (fe_t.inf_map)
632  {
633  case CARTESIAN:
634  InfFE<2,JACOBI_20_00,CARTESIAN>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
635  return;
636 
637  default:
638  libmesh_error_msg("Invalid map = " << fe_t.inf_map);
639  }
640  }
641 
642 
643  // 3D
644  case 3:
645  {
646  switch (fe_t.inf_map)
647  {
648  case CARTESIAN:
649  InfFE<3,JACOBI_20_00,CARTESIAN>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
650  return;
651 
652  default:
653  libmesh_error_msg("Invalid map = " << fe_t.inf_map);
654  }
655  }
656 
657  default:
658  libmesh_error_msg("Invalid dim = " << dim);
659  }
660 }

References libMesh::CARTESIAN, dim, libMesh::FEType::inf_map, and libMesh::InfFE< Dim, T_radial, T_map >::inverse_map().

◆ ifem_map()

Point libMesh::FEInterface::ifem_map ( const unsigned int  dim,
const FEType &  fe_t,
const Elem *  elem,
const Point &  p 
)
staticprivate

Definition at line 479 of file fe_interface_inf_fe.C.

483 {
484  switch (fe_t.inf_map)
485  {
486  case CARTESIAN:
487  {
488  switch (dim)
489  {
490  case 1:
491  return InfFE<1,JACOBI_20_00,CARTESIAN>::map(elem, p);
492  case 2:
493  return InfFE<2,JACOBI_20_00,CARTESIAN>::map(elem, p);
494  case 3:
495  return InfFE<3,JACOBI_20_00,CARTESIAN>::map(elem, p);
496  default:
497  libmesh_error_msg("Invalid dim = " << dim);
498  }
499  }
500  case SPHERICAL:
501  case ELLIPSOIDAL:
502  libmesh_not_implemented_msg("ERROR: Spherical and Ellipsoidal IFEMs not (yet) implemented.");
503  default:
504  libmesh_error_msg("Invalid map = " << fe_t.inf_map);
505  }
506 }

References libMesh::CARTESIAN, dim, libMesh::ELLIPSOIDAL, libMesh::FEType::inf_map, libMesh::InfFE< Dim, T_radial, T_map >::map(), and libMesh::SPHERICAL.

Referenced by map().

◆ ifem_n_dofs()

unsigned int libMesh::FEInterface::ifem_n_dofs ( const unsigned int  dim,
const FEType &  fe_t,
const ElemType  t 
)
staticprivate

Definition at line 134 of file fe_interface_inf_fe.C.

137 {
138  switch (dim)
139  {
140  // 1D
141  case 1:
142  /*
143  * Since InfFE<Dim,T_radial,T_map>::n_dofs(...)
144  * is actually independent of T_radial and T_map, we can use
145  * just any T_radial and T_map
146  */
147  return InfFE<1,JACOBI_20_00,CARTESIAN>::n_dofs(fe_t, t);
148 
149  // 2D
150  case 2:
151  return InfFE<2,JACOBI_20_00,CARTESIAN>::n_dofs(fe_t, t);
152 
153  // 3D
154  case 3:
155  return InfFE<3,JACOBI_20_00,CARTESIAN>::n_dofs(fe_t, t);
156 
157  default:
158  libmesh_error_msg("Unsupported dim = " << dim);
159  }
160 }

References dim, and libMesh::InfFE< Dim, T_radial, T_map >::n_dofs().

Referenced by n_dofs().

◆ ifem_n_dofs_at_node()

unsigned int libMesh::FEInterface::ifem_n_dofs_at_node ( const unsigned int  dim,
const FEType &  fe_t,
const ElemType  t,
const unsigned int  n 
)
staticprivate

Definition at line 165 of file fe_interface_inf_fe.C.

169 {
170  switch (dim)
171  {
172  // 1D
173  case 1:
174  /*
175  * Since InfFE<Dim,T_radial,T_map>::n_dofs_at_node(...)
176  * is actually independent of T_radial and T_map, we can use
177  * just any T_radial and T_map
178  */
179  return InfFE<1,JACOBI_20_00,CARTESIAN>::n_dofs_at_node(fe_t, t, n);
180 
181  // 2D
182  case 2:
183  return InfFE<2,JACOBI_20_00,CARTESIAN>::n_dofs_at_node(fe_t, t, n);
184 
185  // 3D
186  case 3:
187  return InfFE<3,JACOBI_20_00,CARTESIAN>::n_dofs_at_node(fe_t, t, n);
188 
189  default:
190  libmesh_error_msg("Unsupported dim = " << dim);
191  }
192 }

References dim, and libMesh::InfFE< Dim, T_radial, T_map >::n_dofs_at_node().

Referenced by n_dofs_at_node().

◆ ifem_n_dofs_per_elem()

unsigned int libMesh::FEInterface::ifem_n_dofs_per_elem ( const unsigned int  dim,
const FEType &  fe_t,
const ElemType  t 
)
staticprivate

Definition at line 198 of file fe_interface_inf_fe.C.

201 {
202  switch (dim)
203  {
204  // 1D
205  case 1:
206  /*
207  * Since InfFE<Dim,T_radial,T_map>::n_dofs(...)
208  * is actually independent of T_radial and T_map, we can use
209  * just any T_radial and T_map
210  */
211  return InfFE<1,JACOBI_20_00,CARTESIAN>::n_dofs_per_elem(fe_t, t);
212 
213  // 2D
214  case 2:
215  return InfFE<2,JACOBI_20_00,CARTESIAN>::n_dofs_per_elem(fe_t, t);
216 
217  // 3D
218  case 3:
219  return InfFE<3,JACOBI_20_00,CARTESIAN>::n_dofs_per_elem(fe_t, t);
220 
221  default:
222  libmesh_error_msg("Unsupported dim = " << dim);
223  }
224 }

References dim, and libMesh::InfFE< Dim, T_radial, T_map >::n_dofs_per_elem().

Referenced by n_dofs_per_elem().

◆ ifem_n_shape_functions()

unsigned int libMesh::FEInterface::ifem_n_shape_functions ( const unsigned int  dim,
const FEType &  fe_t,
const ElemType  t 
)
staticprivate

Definition at line 102 of file fe_interface_inf_fe.C.

105 {
106  switch (dim)
107  {
108  // 1D
109  case 1:
110  /*
111  * Since InfFE<Dim,T_radial,T_map>::n_shape_functions(...)
112  * is actually independent of T_radial and T_map, we can use
113  * just any T_radial and T_map
114  */
115  return InfFE<1,JACOBI_20_00,CARTESIAN>::n_shape_functions(fe_t, t);
116 
117  // 2D
118  case 2:
119  return InfFE<2,JACOBI_20_00,CARTESIAN>::n_shape_functions(fe_t, t);
120 
121  // 3D
122  case 3:
123  return InfFE<3,JACOBI_20_00,CARTESIAN>::n_shape_functions(fe_t, t);
124 
125  default:
126  libmesh_error_msg("Unsupported dim = " << dim);
127  }
128 }

References dim, and libMesh::InfFE< Dim, T_radial, T_map >::n_shape_functions().

Referenced by n_shape_functions().

◆ ifem_nodal_soln()

void libMesh::FEInterface::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 
)
staticprivate

Definition at line 229 of file fe_interface_inf_fe.C.

234 {
235  switch (dim)
236  {
237 
238  // 1D
239  case 1:
240  {
241  switch (fe_t.radial_family)
242  {
243  case INFINITE_MAP:
244  libmesh_error_msg("ERROR: INFINITE_MAP is not a valid shape family for radial approximation.");
245 
246  case JACOBI_20_00:
247  {
248  switch (fe_t.inf_map)
249  {
250  case CARTESIAN:
251  {
252  InfFE<1,JACOBI_20_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
253  break;
254  }
255  default:
256  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
257  }
258  break;
259  }
260 
261  case JACOBI_30_00:
262  {
263  switch (fe_t.inf_map)
264  {
265  case CARTESIAN:
266  {
267  InfFE<1,JACOBI_30_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
268  break;
269  }
270  default:
271  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
272  }
273  break;
274  }
275 
276  case LEGENDRE:
277  {
278  switch (fe_t.inf_map)
279  {
280  case CARTESIAN:
281  {
282  InfFE<1,LEGENDRE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
283  break;
284  }
285  default:
286  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
287  }
288  break;
289  }
290 
291  case LAGRANGE:
292  {
293  switch (fe_t.inf_map)
294  {
295  case CARTESIAN:
296  {
297  InfFE<1,LAGRANGE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
298  break;
299  }
300  default:
301  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
302  }
303  break;
304  }
305 
306  default:
307  libmesh_error_msg("ERROR: Bad FEType.radial_family= " << fe_t.radial_family);
308  }
309 
310  break;
311  }
312 
313 
314 
315 
316  // 2D
317  case 2:
318  {
319  switch (fe_t.radial_family)
320  {
321  case INFINITE_MAP:
322  libmesh_error_msg("ERROR: INFINITE_MAP is not a valid shape family for radial approximation.");
323 
324  case JACOBI_20_00:
325  {
326  switch (fe_t.inf_map)
327  {
328  case CARTESIAN:
329  {
330  InfFE<2,JACOBI_20_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
331  break;
332  }
333  default:
334  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
335  }
336  break;
337  }
338 
339  case JACOBI_30_00:
340  {
341  switch (fe_t.inf_map)
342  {
343  case CARTESIAN:
344  {
345  InfFE<2,JACOBI_30_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
346  break;
347  }
348  default:
349  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
350  }
351  break;
352  }
353 
354  case LEGENDRE:
355  {
356  switch (fe_t.inf_map)
357  {
358  case CARTESIAN:
359  {
360  InfFE<2,LEGENDRE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
361  break;
362  }
363  default:
364  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
365  }
366  break;
367  }
368 
369  case LAGRANGE:
370  {
371  switch (fe_t.inf_map)
372  {
373  case CARTESIAN:
374  {
375  InfFE<2,LAGRANGE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
376  break;
377  }
378  default:
379  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
380  }
381  break;
382  }
383 
384  default:
385  libmesh_error_msg("ERROR: Bad FEType.radial_family= " << fe_t.radial_family);
386  }
387 
388  break;
389  }
390 
391 
392 
393 
394  // 3D
395  case 3:
396  {
397  switch (fe_t.radial_family)
398  {
399  case INFINITE_MAP:
400  libmesh_error_msg("ERROR: INFINITE_MAP is not a valid shape family for radial approximation.");
401 
402  case JACOBI_20_00:
403  {
404  switch (fe_t.inf_map)
405  {
406  case CARTESIAN:
407  {
408  InfFE<3,JACOBI_20_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
409  break;
410  }
411  default:
412  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
413  }
414  break;
415  }
416 
417  case JACOBI_30_00:
418  {
419  switch (fe_t.inf_map)
420  {
421  case CARTESIAN:
422  {
423  InfFE<3,JACOBI_30_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
424  break;
425  }
426  default:
427  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
428  }
429  break;
430  }
431 
432  case LEGENDRE:
433  {
434  switch (fe_t.inf_map)
435  {
436  case CARTESIAN:
437  {
438  InfFE<3,LEGENDRE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
439  break;
440  }
441  default:
442  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
443  }
444  break;
445  }
446 
447  case LAGRANGE:
448  {
449  switch (fe_t.inf_map)
450  {
451  case CARTESIAN:
452  {
453  InfFE<3,LAGRANGE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
454  break;
455  }
456  default:
457  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
458  }
459  break;
460  }
461 
462 
463 
464  default:
465  libmesh_error_msg("ERROR: Bad FEType.radial_family= " << fe_t.radial_family);
466  }
467 
468  break;
469  }
470 
471  default:
472  libmesh_error_msg("Invalid dim = " << dim);
473  }
474 }

References libMesh::CARTESIAN, dim, libMesh::FEType::inf_map, libMesh::INFINITE_MAP, libMesh::JACOBI_20_00, libMesh::JACOBI_30_00, libMesh::LAGRANGE, libMesh::LEGENDRE, nodal_soln(), libMesh::InfFE< Dim, T_radial, T_map >::nodal_soln(), and libMesh::FEType::radial_family.

Referenced by nodal_soln().

◆ ifem_on_reference_element()

bool libMesh::FEInterface::ifem_on_reference_element ( const Point &  p,
const ElemType  t,
const Real  eps 
)
staticprivate

Definition at line 665 of file fe_interface_inf_fe.C.

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

References libMesh::FEAbstract::on_reference_element().

◆ ifem_shape() [1/2]

Real libMesh::FEInterface::ifem_shape ( const unsigned int  dim,
const FEType &  fe_t,
const Elem *  elem,
const unsigned int  i,
const Point &  p 
)
staticprivate

Definition at line 773 of file fe_interface_inf_fe.C.

778 {
779  switch (dim)
780  {
781  // 1D
782  case 1:
783  {
784  switch (fe_t.radial_family)
785  {
786  /*
787  * For no derivatives (and local coordinates, as
788  * given in \p p) the infinite element shapes
789  * are independent of mapping type
790  */
791  case INFINITE_MAP:
792  return InfFE<1,INFINITE_MAP,CARTESIAN>::shape(fe_t, elem, i, p);
793 
794  case JACOBI_20_00:
795  return InfFE<1,JACOBI_20_00,CARTESIAN>::shape(fe_t, elem, i, p);
796 
797  case JACOBI_30_00:
798  return InfFE<1,JACOBI_30_00,CARTESIAN>::shape(fe_t, elem, i, p);
799 
800  case LEGENDRE:
801  return InfFE<1,LEGENDRE,CARTESIAN>::shape(fe_t, elem, i, p);
802 
803  case LAGRANGE:
804  return InfFE<1,LAGRANGE,CARTESIAN>::shape(fe_t, elem, i, p);
805 
806  default:
807  libmesh_error_msg("Invalid radial family = " << fe_t.radial_family);
808  }
809  }
810 
811 
812  // 2D
813  case 2:
814  {
815  switch (fe_t.radial_family)
816  {
817  case INFINITE_MAP:
818  return InfFE<2,INFINITE_MAP,CARTESIAN>::shape(fe_t, elem, i, p);
819 
820  case JACOBI_20_00:
821  return InfFE<2,JACOBI_20_00,CARTESIAN>::shape(fe_t, elem, i, p);
822 
823  case JACOBI_30_00:
824  return InfFE<2,JACOBI_30_00,CARTESIAN>::shape(fe_t, elem, i, p);
825 
826  case LEGENDRE:
827  return InfFE<2,LEGENDRE,CARTESIAN>::shape(fe_t, elem, i, p);
828 
829  case LAGRANGE:
830  return InfFE<2,LAGRANGE,CARTESIAN>::shape(fe_t, elem, i, p);
831 
832  default:
833  libmesh_error_msg("Invalid radial family = " << fe_t.radial_family);
834  }
835  }
836 
837 
838  // 3D
839  case 3:
840  {
841  switch (fe_t.radial_family)
842  {
843  case INFINITE_MAP:
844  return InfFE<3,INFINITE_MAP,CARTESIAN>::shape(fe_t, elem, i, p);
845 
846  case JACOBI_20_00:
847  return InfFE<3,JACOBI_20_00,CARTESIAN>::shape(fe_t, elem, i, p);
848 
849  case JACOBI_30_00:
850  return InfFE<3,JACOBI_30_00,CARTESIAN>::shape(fe_t, elem, i, p);
851 
852  case LEGENDRE:
853  return InfFE<3,LEGENDRE,CARTESIAN>::shape(fe_t, elem, i, p);
854 
855  case LAGRANGE:
856  return InfFE<3,LAGRANGE,CARTESIAN>::shape(fe_t, elem, i, p);
857 
858  default:
859  libmesh_error_msg("Invalid radial family = " << fe_t.radial_family);
860  }
861  }
862 
863  default:
864  libmesh_error_msg("Invalid dim = " << dim);
865  }
866 }

References dim, libMesh::INFINITE_MAP, libMesh::JACOBI_20_00, libMesh::JACOBI_30_00, libMesh::LAGRANGE, libMesh::LEGENDRE, libMesh::FEType::radial_family, and libMesh::InfFE< Dim, T_radial, T_map >::shape().

◆ ifem_shape() [2/2]

Real libMesh::FEInterface::ifem_shape ( const unsigned int  dim,
const FEType &  fe_t,
const ElemType  t,
const unsigned int  i,
const Point &  p 
)
staticprivate

Definition at line 675 of file fe_interface_inf_fe.C.

680 {
681  switch (dim)
682  {
683  // 1D
684  case 1:
685  {
686  switch (fe_t.radial_family)
687  {
688  /*
689  * For no derivatives (and local coordinates, as
690  * given in \p p) the infinite element shapes
691  * are independent of mapping type
692  */
693  case INFINITE_MAP:
694  return InfFE<1,INFINITE_MAP,CARTESIAN>::shape(fe_t, t, i, p);
695 
696  case JACOBI_20_00:
697  return InfFE<1,JACOBI_20_00,CARTESIAN>::shape(fe_t, t, i, p);
698 
699  case JACOBI_30_00:
700  return InfFE<1,JACOBI_30_00,CARTESIAN>::shape(fe_t, t, i, p);
701 
702  case LEGENDRE:
703  return InfFE<1,LEGENDRE,CARTESIAN>::shape(fe_t, t, i, p);
704 
705  case LAGRANGE:
706  return InfFE<1,LAGRANGE,CARTESIAN>::shape(fe_t, t, i, p);
707 
708  default:
709  libmesh_error_msg("Invalid radial family = " << fe_t.radial_family);
710  }
711  }
712 
713 
714  // 2D
715  case 2:
716  {
717  switch (fe_t.radial_family)
718  {
719  case INFINITE_MAP:
720  return InfFE<2,INFINITE_MAP,CARTESIAN>::shape(fe_t, t, i, p);
721 
722  case JACOBI_20_00:
723  return InfFE<2,JACOBI_20_00,CARTESIAN>::shape(fe_t, t, i, p);
724 
725  case JACOBI_30_00:
726  return InfFE<2,JACOBI_30_00,CARTESIAN>::shape(fe_t, t, i, p);
727 
728  case LEGENDRE:
729  return InfFE<2,LEGENDRE,CARTESIAN>::shape(fe_t, t, i, p);
730 
731  case LAGRANGE:
732  return InfFE<2,LAGRANGE,CARTESIAN>::shape(fe_t, t, i, p);
733 
734  default:
735  libmesh_error_msg("Invalid radial family = " << fe_t.radial_family);
736  }
737  }
738 
739 
740  // 3D
741  case 3:
742  {
743  switch (fe_t.radial_family)
744  {
745  case INFINITE_MAP:
746  return InfFE<3,INFINITE_MAP,CARTESIAN>::shape(fe_t, t, i, p);
747 
748  case JACOBI_20_00:
749  return InfFE<3,JACOBI_20_00,CARTESIAN>::shape(fe_t, t, i, p);
750 
751  case JACOBI_30_00:
752  return InfFE<3,JACOBI_30_00,CARTESIAN>::shape(fe_t, t, i, p);
753 
754  case LEGENDRE:
755  return InfFE<3,LEGENDRE,CARTESIAN>::shape(fe_t, t, i, p);
756 
757  case LAGRANGE:
758  return InfFE<3,LAGRANGE,CARTESIAN>::shape(fe_t, t, i, p);
759 
760  default:
761  libmesh_error_msg("Invalid radial family = " << fe_t.radial_family);
762  }
763  }
764 
765  default:
766  libmesh_error_msg("Invalid dim = " << dim);
767  }
768 }

References dim, libMesh::INFINITE_MAP, libMesh::JACOBI_20_00, libMesh::JACOBI_30_00, libMesh::LAGRANGE, libMesh::LEGENDRE, libMesh::FEType::radial_family, and libMesh::InfFE< Dim, T_radial, T_map >::shape().

Referenced by shape().

◆ ifem_shape_deriv() [1/2]

Real libMesh::FEInterface::ifem_shape_deriv ( const unsigned int  dim,
const FEType &  fe_t,
const Elem *  elem,
const unsigned int  i,
const unsigned int  j,
const Point &  p 
)
staticprivate

Definition at line 868 of file fe_interface_inf_fe.C.

874 {
875  switch (dim)
876  {
877  // 1D
878  case 1:
879  inf_fe_family_mapping_switch(1, shape_deriv(fe_t, elem, i, j, p), return, ;);
880  // 2D
881  case 2:
882  inf_fe_family_mapping_switch(2, shape_deriv(fe_t, elem, i, j, p), return, ;);
883  // 3D
884  case 3:
885  inf_fe_family_mapping_switch(3, shape_deriv(fe_t, elem, i, j, p), return, ;);
886 
887  default:
888  libmesh_error_msg("Invalid dim = " << dim);
889  }
890 }

References dim, and shape_deriv().

◆ ifem_shape_deriv() [2/2]

Real libMesh::FEInterface::ifem_shape_deriv ( const unsigned int  dim,
const FEType &  fe_t,
const ElemType  t,
const unsigned int  i,
const unsigned int  j,
const Point &  p 
)
staticprivate

Definition at line 893 of file fe_interface_inf_fe.C.

899 {
900  switch (dim)
901  {
902  // 1D
903  case 1:
904  inf_fe_family_mapping_switch(1, shape_deriv(fe_t, t, i, j, p), return, ;);
905  // 2D
906  case 2:
907  inf_fe_family_mapping_switch(2, shape_deriv(fe_t, t, i, j, p), return, ;);
908  // 3D
909  case 3:
910  inf_fe_family_mapping_switch(3, shape_deriv(fe_t, t, i, j, p), return, ;);
911 
912  default:
913  libmesh_error_msg("Invalid dim = " << dim);
914  }
915 }

References dim, and shape_deriv().

Referenced by shape_deriv().

◆ inverse_map() [1/2]

Point libMesh::FEInterface::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

This is now deprecated; use FEMap::inverse_map instead.

Definition at line 620 of file fe_interface.C.

626 {
627 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
628 
629  if (is_InfFE_elem(elem->type()))
630  return ifem_inverse_map(dim, fe_t, elem, p,tolerance, secure);
631 
632 #endif
633 
634  fe_with_vec_switch(inverse_map(elem, p, tolerance, secure));
635 }

References dim, ifem_inverse_map(), is_InfFE_elem(), and libMesh::Elem::type().

Referenced by inverse_map().

◆ inverse_map() [2/2]

void libMesh::FEInterface::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

This is now deprecated; use FEMap::inverse_map instead.

Definition at line 640 of file fe_interface.C.

647 {
648  const std::size_t n_pts = physical_points.size();
649 
650  // Resize the vector
651  reference_points.resize(n_pts);
652 
653  if (n_pts == 0)
654  {
655  libMesh::err << "WARNING: empty vector physical_points!"
656  << std::endl;
657  libmesh_here();
658  return;
659  }
660 
661 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
662 
663  if (is_InfFE_elem(elem->type()))
664  {
665  ifem_inverse_map(dim, fe_t, elem, physical_points, reference_points, tolerance, secure);
666  return;
667  // libmesh_not_implemented();
668  }
669 
670 #endif
671 
672  void_fe_with_vec_switch(inverse_map(elem, physical_points, reference_points, tolerance, secure));
673 }

References dim, libMesh::err, ifem_inverse_map(), inverse_map(), is_InfFE_elem(), libMesh::TypeVector< T >::size(), and libMesh::Elem::type().

◆ is_InfFE_elem()

bool libMesh::FEInterface::is_InfFE_elem ( const ElemType  et)
staticprivate
Returns
true if et is an element to be processed by class InfFE, false otherwise or when !LIBMESH_ENABLE_INFINITE_ELEMENTS.

Definition at line 46 of file fe_interface.C.

47 {
48  return false;
49 }

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

◆ map()

Point libMesh::FEInterface::map ( unsigned int  dim,
const FEType &  fe_t,
const Elem *  elem,
const Point &  p 
)
static

This is now deprecated; use FEMap::map instead.

Definition at line 604 of file fe_interface.C.

608 {
609 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
610  if (is_InfFE_elem(elem->type()))
611  return ifem_map(dim, fe_t, elem, p);
612 #endif
613  fe_with_vec_switch(map(elem, p));
614 }

References dim, ifem_map(), is_InfFE_elem(), and libMesh::Elem::type().

◆ max_order()

unsigned int libMesh::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 1281 of file fe_interface.C.

1283 {
1284  // Yeah, I know, infinity is much larger than 11, but our
1285  // solvers don't seem to like high degree polynomials, and our
1286  // quadrature rules and number_lookups tables
1287  // need to go up higher.
1288  const unsigned int unlimited = 11;
1289 
1290  // If we used 0 as a default, then elements missing from this
1291  // table (e.g. infinite elements) would be considered broken.
1292  const unsigned int unknown = unlimited;
1293 
1294  switch (fe_t.family)
1295  {
1296  case LAGRANGE:
1297  case L2_LAGRANGE: // TODO: L2_LAGRANGE can have higher "max_order" than LAGRANGE
1298  case LAGRANGE_VEC:
1299  switch (el_t)
1300  {
1301  case EDGE2:
1302  case EDGE3:
1303  case EDGE4:
1304  return 3;
1305  case TRI3:
1306  case TRISHELL3:
1307  return 1;
1308  case TRI6:
1309  return 2;
1310  case QUAD4:
1311  case QUADSHELL4:
1312  return 1;
1313  case QUAD8:
1314  case QUADSHELL8:
1315  case QUAD9:
1316  return 2;
1317  case TET4:
1318  return 1;
1319  case TET10:
1320  return 2;
1321  case HEX8:
1322  return 1;
1323  case HEX20:
1324  case HEX27:
1325  return 2;
1326  case PRISM6:
1327  return 1;
1328  case PRISM15:
1329  case PRISM18:
1330  return 2;
1331  case PYRAMID5:
1332  return 1;
1333  case PYRAMID13:
1334  case PYRAMID14:
1335  return 2;
1336  default:
1337  return unknown;
1338  }
1339  break;
1340  case MONOMIAL:
1341  case MONOMIAL_VEC:
1342  switch (el_t)
1343  {
1344  case EDGE2:
1345  case EDGE3:
1346  case EDGE4:
1347  case TRI3:
1348  case TRISHELL3:
1349  case TRI6:
1350  case QUAD4:
1351  case QUADSHELL4:
1352  case QUAD8:
1353  case QUADSHELL8:
1354  case QUAD9:
1355  case TET4:
1356  case TET10:
1357  case HEX8:
1358  case HEX20:
1359  case HEX27:
1360  case PRISM6:
1361  case PRISM15:
1362  case PRISM18:
1363  case PYRAMID5:
1364  case PYRAMID13:
1365  case PYRAMID14:
1366  return unlimited;
1367  default:
1368  return unknown;
1369  }
1370  break;
1371 #ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES
1372  case BERNSTEIN:
1373  case RATIONAL_BERNSTEIN:
1374  switch (el_t)
1375  {
1376  case EDGE2:
1377  case EDGE3:
1378  case EDGE4:
1379  return unlimited;
1380  case TRI3:
1381  case TRISHELL3:
1382  return 1;
1383  case TRI6:
1384  return 6;
1385  case QUAD4:
1386  case QUADSHELL4:
1387  return 1;
1388  case QUAD8:
1389  case QUADSHELL8:
1390  case QUAD9:
1391  return unlimited;
1392  case TET4:
1393  return 1;
1394  case TET10:
1395  return 2;
1396  case HEX8:
1397  return 1;
1398  case HEX20:
1399  return 2;
1400  case HEX27:
1401  return 4;
1402  case PRISM6:
1403  case PRISM15:
1404  case PRISM18:
1405  case PYRAMID5:
1406  case PYRAMID13:
1407  case PYRAMID14:
1408  return 0;
1409  default:
1410  return unknown;
1411  }
1412  break;
1413  case SZABAB:
1414  switch (el_t)
1415  {
1416  case EDGE2:
1417  return 1;
1418  case EDGE3:
1419  case EDGE4:
1420  return 7;
1421  case TRI3:
1422  case TRISHELL3:
1423  return 1;
1424  case TRI6:
1425  return 7;
1426  case QUAD4:
1427  case QUADSHELL4:
1428  return 1;
1429  case QUAD8:
1430  case QUADSHELL8:
1431  case QUAD9:
1432  return 7;
1433  case TET4:
1434  case TET10:
1435  case HEX8:
1436  case HEX20:
1437  case HEX27:
1438  case PRISM6:
1439  case PRISM15:
1440  case PRISM18:
1441  case PYRAMID5:
1442  case PYRAMID13:
1443  case PYRAMID14:
1444  return 0;
1445  default:
1446  return unknown;
1447  }
1448  break;
1449 #endif
1450  case XYZ:
1451  switch (el_t)
1452  {
1453  case EDGE2:
1454  case EDGE3:
1455  case EDGE4:
1456  case TRI3:
1457  case TRISHELL3:
1458  case TRI6:
1459  case QUAD4:
1460  case QUADSHELL4:
1461  case QUAD8:
1462  case QUADSHELL8:
1463  case QUAD9:
1464  case TET4:
1465  case TET10:
1466  case HEX8:
1467  case HEX20:
1468  case HEX27:
1469  case PRISM6:
1470  case PRISM15:
1471  case PRISM18:
1472  case PYRAMID5:
1473  case PYRAMID13:
1474  case PYRAMID14:
1475  return unlimited;
1476  default:
1477  return unknown;
1478  }
1479  break;
1480  case CLOUGH:
1481  switch (el_t)
1482  {
1483  case EDGE2:
1484  case EDGE3:
1485  return 3;
1486  case EDGE4:
1487  case TRI3:
1488  case TRISHELL3:
1489  return 0;
1490  case TRI6:
1491  return 3;
1492  case QUAD4:
1493  case QUADSHELL4:
1494  case QUAD8:
1495  case QUADSHELL8:
1496  case QUAD9:
1497  case TET4:
1498  case TET10:
1499  case HEX8:
1500  case HEX20:
1501  case HEX27:
1502  case PRISM6:
1503  case PRISM15:
1504  case PRISM18:
1505  case PYRAMID5:
1506  case PYRAMID13:
1507  case PYRAMID14:
1508  return 0;
1509  default:
1510  return unknown;
1511  }
1512  break;
1513  case HERMITE:
1514  switch (el_t)
1515  {
1516  case EDGE2:
1517  case EDGE3:
1518  return unlimited;
1519  case EDGE4:
1520  case TRI3:
1521  case TRISHELL3:
1522  case TRI6:
1523  return 0;
1524  case QUAD4:
1525  case QUADSHELL4:
1526  return 3;
1527  case QUAD8:
1528  case QUADSHELL8:
1529  case QUAD9:
1530  return unlimited;
1531  case TET4:
1532  case TET10:
1533  return 0;
1534  case HEX8:
1535  return 3;
1536  case HEX20:
1537  case HEX27:
1538  return unlimited;
1539  case PRISM6:
1540  case PRISM15:
1541  case PRISM18:
1542  case PYRAMID5:
1543  case PYRAMID13:
1544  case PYRAMID14:
1545  return 0;
1546  default:
1547  return unknown;
1548  }
1549  break;
1550  case HIERARCHIC:
1551  switch (el_t)
1552  {
1553  case EDGE2:
1554  case EDGE3:
1555  case EDGE4:
1556  return unlimited;
1557  case TRI3:
1558  case TRISHELL3:
1559  return 1;
1560  case TRI6:
1561  return unlimited;
1562  case QUAD4:
1563  case QUADSHELL4:
1564  return 1;
1565  case QUAD8:
1566  case QUADSHELL8:
1567  case QUAD9:
1568  return unlimited;
1569  case TET4:
1570  case TET10:
1571  return 0;
1572  case HEX8:
1573  case HEX20:
1574  return 1;
1575  case HEX27:
1576  return unlimited;
1577  case PRISM6:
1578  case PRISM15:
1579  case PRISM18:
1580  case PYRAMID5:
1581  case PYRAMID13:
1582  case PYRAMID14:
1583  return 0;
1584  default:
1585  return unknown;
1586  }
1587  break;
1588  case L2_HIERARCHIC:
1589  switch (el_t)
1590  {
1591  case EDGE2:
1592  case EDGE3:
1593  case EDGE4:
1594  return unlimited;
1595  case TRI3:
1596  case TRISHELL3:
1597  return 1;
1598  case TRI6:
1599  return unlimited;
1600  case QUAD4:
1601  case QUADSHELL4:
1602  return 1;
1603  case QUAD8:
1604  case QUADSHELL8:
1605  case QUAD9:
1606  return unlimited;
1607  case TET4:
1608  case TET10:
1609  return 0;
1610  case HEX8:
1611  case HEX20:
1612  return 1;
1613  case HEX27:
1614  return unlimited;
1615  case PRISM6:
1616  case PRISM15:
1617  case PRISM18:
1618  case PYRAMID5:
1619  case PYRAMID13:
1620  case PYRAMID14:
1621  return 0;
1622  default:
1623  return unknown;
1624  }
1625  break;
1626  case SUBDIVISION:
1627  switch (el_t)
1628  {
1629  case TRI3SUBDIVISION:
1630  return unlimited;
1631  default:
1632  return unknown;
1633  }
1634  break;
1635  case NEDELEC_ONE:
1636  switch (el_t)
1637  {
1638  case TRI6:
1639  case QUAD8:
1640  case QUAD9:
1641  case HEX20:
1642  case HEX27:
1643  return 1;
1644  default:
1645  return 0;
1646  }
1647  break;
1648  default:
1649  return 0;
1650  break;
1651  }
1652 }

References libMesh::BERNSTEIN, libMesh::CLOUGH, libMesh::EDGE2, libMesh::EDGE3, libMesh::EDGE4, libMesh::FEType::family, libMesh::HERMITE, libMesh::HEX20, libMesh::HEX27, libMesh::HEX8, libMesh::HIERARCHIC, libMesh::L2_HIERARCHIC, libMesh::L2_LAGRANGE, libMesh::LAGRANGE, libMesh::LAGRANGE_VEC, libMesh::MONOMIAL, libMesh::MONOMIAL_VEC, libMesh::NEDELEC_ONE, libMesh::PRISM15, libMesh::PRISM18, libMesh::PRISM6, libMesh::PYRAMID13, libMesh::PYRAMID14, libMesh::PYRAMID5, libMesh::QUAD4, libMesh::QUAD8, libMesh::QUAD9, libMesh::QUADSHELL4, libMesh::QUADSHELL8, libMesh::RATIONAL_BERNSTEIN, libMesh::SUBDIVISION, libMesh::SZABAB, libMesh::TET10, libMesh::TET4, libMesh::TRI3, libMesh::TRI3SUBDIVISION, libMesh::TRI6, libMesh::TRISHELL3, and libMesh::XYZ.

Referenced by libMesh::DofMap::reinit().

◆ n_dofs() [1/2]

unsigned int libMesh::FEInterface::n_dofs ( const unsigned int  dim,
const FEType &  fe_t,
const Elem *  elem 
)
static

Similar to the function above but takes an Elem * and accounts for p-refinement internally, if any.

This function is designed to prevent users from needing to trick FEInterface::n_dofs() into giving them the right number of dofs when working with p-refined elements. See, e.g. FEInterface::compute_data().

Definition at line 492 of file fe_interface.C.

495 {
496  FEType p_refined_fe_t = fe_t;
497  p_refined_fe_t.order = static_cast<Order>(p_refined_fe_t.order + elem->p_level());
498  return FEInterface::n_dofs(dim, p_refined_fe_t, elem->type());
499 }

References dim, n_dofs(), libMesh::FEType::order, libMesh::Elem::p_level(), and libMesh::Elem::type().

◆ n_dofs() [2/2]

unsigned int libMesh::FEInterface::n_dofs ( const unsigned int  dim,
const FEType &  fe_t,
const ElemType  t 
)
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 472 of file fe_interface.C.

475 {
476 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
477 
478  if (is_InfFE_elem(t))
479  return ifem_n_dofs(dim, fe_t, t);
480 
481 #endif
482 
483  const Order o = fe_t.order;
484 
485  fe_with_vec_switch(n_dofs(t, o));
486 }

References dim, ifem_n_dofs(), is_InfFE_elem(), and libMesh::FEType::order.

Referenced by libMesh::DofMap::_dof_indices(), libMesh::FEGenericBase< FEOutputType< T >::type >::coarsened_dof_values(), compute_data(), libMesh::FEAbstract::compute_node_constraints(), libMesh::FEAbstract::compute_periodic_node_constraints(), n_dofs(), libMesh::InfFE< Dim, T_radial, T_map >::n_dofs(), and libMesh::HPCoarsenTest::select_refinement().

◆ n_dofs_at_node()

unsigned int libMesh::FEInterface::n_dofs_at_node ( const unsigned int  dim,
const FEType &  fe_t,
const ElemType  t,
const unsigned int  n 
)
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 503 of file fe_interface.C.

507 {
508 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
509 
510  if (is_InfFE_elem(t))
511  return ifem_n_dofs_at_node(dim, fe_t, t, n);
512 
513 #endif
514 
515  const Order o = fe_t.order;
516 
517  fe_with_vec_switch(n_dofs_at_node(t, o, n));
518 }

References dim, ifem_n_dofs_at_node(), is_InfFE_elem(), and libMesh::FEType::order.

Referenced by libMesh::DofMap::_dof_indices(), libMesh::DofMap::_node_dof_indices(), libMesh::FEGenericBase< FEOutputType< T >::type >::coarsened_dof_values(), libMesh::InfFE< Dim, T_radial, T_map >::compute_shape_indices(), libMesh::DofMap::constrain_p_dofs(), libMesh::InfFE< Dim, T_radial, T_map >::n_dofs_at_node(), n_dofs_at_node_function(), libMesh::DofMap::old_dof_indices(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SortAndCopy::operator()(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectVertices::operator()(), and libMesh::DofMap::reinit().

◆ n_dofs_at_node_function()

FEInterface::n_dofs_at_node_ptr libMesh::FEInterface::n_dofs_at_node_function ( const unsigned int  dim,
const FEType &  fe_t 
)
static
Returns
A function which evaluates n_dofs_at_node for the requested FE type and dimension.

Definition at line 523 of file fe_interface.C.

525 {
526  fe_with_vec_switch(n_dofs_at_node);
527 }

References n_dofs_at_node().

Referenced by libMesh::DofMap::_dof_indices(), and libMesh::DofMap::old_dof_indices().

◆ n_dofs_per_elem()

unsigned int libMesh::FEInterface::n_dofs_per_elem ( const unsigned int  dim,
const FEType &  fe_t,
const ElemType  t 
)
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 534 of file fe_interface.C.

537 {
538 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
539 
540  if (is_InfFE_elem(t))
541  return ifem_n_dofs_per_elem(dim, fe_t, t);
542 
543 #endif
544 
545  const Order o = fe_t.order;
546 
547  fe_with_vec_switch(n_dofs_per_elem(t, o));
548 }

References dim, ifem_n_dofs_per_elem(), is_InfFE_elem(), and libMesh::FEType::order.

Referenced by libMesh::DofMap::_dof_indices(), libMesh::InfFE< Dim, T_radial, T_map >::compute_shape_indices(), libMesh::OldSolutionValue< Output, point_output >::eval_old_dofs(), libMesh::InfFE< Dim, T_radial, T_map >::n_dofs_per_elem(), libMesh::DofMap::old_dof_indices(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SortAndCopy::operator()(), and libMesh::DofMap::reinit().

◆ n_shape_functions()

unsigned int libMesh::FEInterface::n_shape_functions ( const unsigned int  dim,
const FEType &  fe_t,
const ElemType  t 
)
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 446 of file fe_interface.C.

449 {
450 
451 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
452  /*
453  * Since the FEType, stored in DofMap/(some System child), has to
454  * be the _same_ for InfFE and FE, we have to catch calls
455  * to infinite elements through the element type.
456  */
457 
458  if (is_InfFE_elem(t))
459  return ifem_n_shape_functions(dim, fe_t, t);
460 
461 #endif
462 
463  const Order o = fe_t.order;
464 
465  fe_with_vec_switch(n_shape_functions(t, o));
466 }

References dim, ifem_n_shape_functions(), is_InfFE_elem(), and libMesh::FEType::order.

Referenced by libMesh::FEMap::compute_face_map(), libMesh::FEMap::init_edge_shape_functions(), libMesh::FEMap::init_face_shape_functions(), libMesh::FEMap::init_reference_to_physical_map(), libMesh::FEMap::map(), libMesh::FEMap::map_deriv(), libMesh::FE< Dim, LAGRANGE_VEC >::shape(), libMesh::FE< Dim, LAGRANGE_VEC >::shape_deriv(), and libMesh::FE< Dim, LAGRANGE_VEC >::shape_second_deriv().

◆ n_vec_dim()

unsigned int libMesh::FEInterface::n_vec_dim ( const MeshBase &  mesh,
const FEType &  fe_type 
)
static
Returns
The number of components of a vector-valued element. Scalar-valued elements return 1.

Definition at line 1701 of file fe_interface.C.

1703 {
1704  switch (fe_type.family)
1705  {
1706  //FIXME: We currently assume that the number of vector components is tied
1707  // to the mesh dimension. This will break for mixed-dimension meshes.
1708  case LAGRANGE_VEC:
1709  case NEDELEC_ONE:
1710  case MONOMIAL_VEC:
1711  return mesh.mesh_dimension();
1712  default:
1713  return 1;
1714  }
1715 }

References libMesh::FEType::family, libMesh::LAGRANGE_VEC, mesh, libMesh::MONOMIAL_VEC, and libMesh::NEDELEC_ONE.

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::EquationSystems::build_parallel_solution_vector(), and libMesh::EquationSystems::build_variable_names().

◆ nodal_soln()

void libMesh::FEInterface::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

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 580 of file fe_interface.C.

585 {
586 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
587 
588  if (is_InfFE_elem(elem->type()))
589  {
590  ifem_nodal_soln(dim, fe_t, elem, elem_soln, nodal_soln);
591  return;
592  }
593 
594 #endif
595 
596  const Order order = fe_t.order;
597 
598  void_fe_with_vec_switch(nodal_soln(elem, order, elem_soln, nodal_soln));
599 }

References dim, ifem_nodal_soln(), is_InfFE_elem(), libMesh::FEType::order, and libMesh::Elem::type().

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

◆ on_reference_element()

bool libMesh::FEInterface::on_reference_element ( const Point &  p,
const ElemType  t,
const Real  eps = TOLERANCE 
)
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, the parameter eps can be specified to indicate a tolerance. For example, \( \xi \le 1 \) becomes \( \xi \le 1 + \epsilon \).

Definition at line 677 of file fe_interface.C.

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

References libMesh::FEAbstract::on_reference_element().

Referenced by libMesh::InfQuad4::contains_point(), libMesh::InfPrism::contains_point(), libMesh::InfHex::contains_point(), and libMesh::Elem::point_test().

◆ shape() [1/8]

Real libMesh::FEInterface::shape ( const unsigned int  dim,
const FEType &  fe_t,
const Elem *  elem,
const unsigned int  i,
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.
Note
On a p-refined element, fe_t.order should be the base order of the element.

Definition at line 705 of file fe_interface.C.

710 {
711 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
712 
713  if (elem && is_InfFE_elem(elem->type()))
714  return ifem_shape(dim, fe_t, elem, i, p);
715 
716 #endif
717 
718  const Order o = fe_t.order;
719 
720  fe_switch(shape(elem,o,i,p));
721 }

References dim, ifem_shape(), is_InfFE_elem(), libMesh::FEType::order, shape(), and libMesh::Elem::type().

◆ shape() [2/8]

template<typename OutputType >
static void libMesh::FEInterface::shape ( const unsigned int  dim,
const FEType &  fe_t,
const Elem *  elem,
const unsigned int  i,
const Point &  p,
OutputType &  phi 
)
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 scalar finite element class member.
Note
On a p-refined element, fe_t.order should be the total order of the element.

◆ shape() [3/8]

template<>
void libMesh::FEInterface::shape ( const unsigned int  dim,
const FEType &  fe_t,
const Elem *  elem,
const unsigned int  i,
const Point &  p,
Real &  phi 
)
static

Definition at line 765 of file fe_interface.C.

771 {
772 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
773 
774  if (elem && is_InfFE_elem(elem->type()))
775  {
776  phi = ifem_shape(dim, fe_t, elem, i, p);
777  return;
778  }
779 #endif
780 
781  const Order o = fe_t.order;
782 
783  switch(dim)
784  {
785  case 0:
786  fe_scalar_vec_error_switch(0, shape(elem,o,i,p), phi = , ; break;);
787  break;
788  case 1:
789  fe_scalar_vec_error_switch(1, shape(elem,o,i,p), phi = , ; break;);
790  break;
791  case 2:
792  fe_scalar_vec_error_switch(2, shape(elem,o,i,p), phi = , ; break;);
793  break;
794  case 3:
795  fe_scalar_vec_error_switch(3, shape(elem,o,i,p), phi = , ; break;);
796  break;
797  default:
798  libmesh_error_msg("Invalid dimension = " << dim);
799  }
800 
801  return;
802 }

References dim, ifem_shape(), is_InfFE_elem(), libMesh::FEType::order, shape(), and libMesh::Elem::type().

◆ shape() [4/8]

template<>
void libMesh::FEInterface::shape ( const unsigned int  dim,
const FEType &  fe_t,
const Elem *  elem,
const unsigned int  i,
const Point &  p,
RealGradient &  phi 
)
static

Definition at line 998 of file fe_interface.C.

1004 {
1005  const Order o = fe_t.order;
1006 
1007  switch(dim)
1008  {
1009  case 0:
1010  fe_vector_scalar_error_switch(0, shape(elem,o,i,p), phi = , ; break;);
1011  break;
1012  case 1:
1013  fe_vector_scalar_error_switch(1, shape(elem,o,i,p), phi = , ; break;);
1014  break;
1015  case 2:
1016  fe_vector_scalar_error_switch(2, shape(elem,o,i,p), phi = , ; break;);
1017  break;
1018  case 3:
1019  fe_vector_scalar_error_switch(3, shape(elem,o,i,p), phi = , ; break;);
1020  break;
1021  default:
1022  libmesh_error_msg("Invalid dimension = " << dim);
1023  }
1024 
1025  return;
1026 }

References dim, libMesh::FEType::order, and shape().

◆ shape() [5/8]

Real libMesh::FEInterface::shape ( const unsigned int  dim,
const FEType &  fe_t,
const ElemType  t,
const unsigned int  i,
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.
Note
On a p-refined element, fe_t.order should be the total order of the element.

Definition at line 687 of file fe_interface.C.

692 {
693 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
694 
695  if (is_InfFE_elem(t))
696  return ifem_shape(dim, fe_t, t, i, p);
697 
698 #endif
699 
700  const Order o = fe_t.order;
701 
702  fe_switch(shape(t,o,i,p));
703 }

References dim, ifem_shape(), is_InfFE_elem(), and libMesh::FEType::order.

Referenced by libMesh::InfFE< Dim, T_radial, T_map >::compute_data(), compute_data(), libMesh::FEAbstract::compute_node_constraints(), libMesh::FEAbstract::compute_periodic_node_constraints(), libMesh::FE< Dim, LAGRANGE_VEC >::shape(), shape(), libMesh::InfFE< Dim, T_radial, T_map >::shape(), libMesh::FE< Dim, LAGRANGE_VEC >::shape_deriv(), libMesh::InfFE< Dim, T_radial, T_map >::shape_deriv(), shape_function(), libMesh::FE< Dim, LAGRANGE_VEC >::shape_second_deriv(), and NavierSystem::side_constraint().

◆ shape() [6/8]

template<typename OutputType >
static void libMesh::FEInterface::shape ( const unsigned int  dim,
const FEType &  fe_t,
const ElemType  t,
const unsigned int  i,
const Point &  p,
OutputType &  phi 
)
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 scalar finite element class member.
Note
On a p-refined element, fe_t.order should be the total order of the element.

◆ shape() [7/8]

template<>
void libMesh::FEInterface::shape ( const unsigned int  dim,
const FEType &  fe_t,
const ElemType  t,
const unsigned int  i,
const Point &  p,
Real &  phi 
)
static

Definition at line 724 of file fe_interface.C.

730 {
731 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
732 
733  if (is_InfFE_elem(t))
734  {
735  phi = ifem_shape(dim, fe_t, t, i, p);
736  return;
737  }
738 
739 #endif
740 
741  const Order o = fe_t.order;
742 
743  switch(dim)
744  {
745  case 0:
746  fe_scalar_vec_error_switch(0, shape(t,o,i,p), phi = , ; break;);
747  break;
748  case 1:
749  fe_scalar_vec_error_switch(1, shape(t,o,i,p), phi = , ; break;);
750  break;
751  case 2:
752  fe_scalar_vec_error_switch(2, shape(t,o,i,p), phi = , ; break;);
753  break;
754  case 3:
755  fe_scalar_vec_error_switch(3, shape(t,o,i,p), phi = , ; break;);
756  break;
757  default:
758  libmesh_error_msg("Invalid dimension = " << dim);
759  }
760 
761  return;
762 }

References dim, ifem_shape(), is_InfFE_elem(), libMesh::FEType::order, and shape().

◆ shape() [8/8]

template<>
void libMesh::FEInterface::shape ( const unsigned int  dim,
const FEType &  fe_t,
const ElemType  t,
const unsigned int  i,
const Point &  p,
RealGradient &  phi 
)
static

Definition at line 805 of file fe_interface.C.

811 {
812  // This even does not handle infinite elements at all!?
813  const Order o = fe_t.order;
814 
815  switch(dim)
816  {
817  case 0:
818  fe_vector_scalar_error_switch(0, shape(t,o,i,p), phi = , ; break;);
819  break;
820  case 1:
821  fe_vector_scalar_error_switch(1, shape(t,o,i,p), phi = , ; break;);
822  break;
823  case 2:
824  fe_vector_scalar_error_switch(2, shape(t,o,i,p), phi = , ; break;);
825  break;
826  case 3:
827  fe_vector_scalar_error_switch(3, shape(t,o,i,p), phi = , ; break;);
828  break;
829  default:
830  libmesh_error_msg("Invalid dimension = " << dim);
831  }
832 
833  return;
834 }

References dim, libMesh::FEType::order, and shape().

◆ shape_deriv() [1/2]

Real libMesh::FEInterface::shape_deriv ( const unsigned int  dim,
const FEType &  fe_t,
const Elem *  elem,
const unsigned int  i,
const unsigned int  j,
const Point &  p 
)
static
Returns
The \( j^{th} \) coordinate of the gradient 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 scalar finite element class member.
Note
On a p-refined element, fe_t.order should be the total order of the element.

Definition at line 880 of file fe_interface.C.

886 {
887  libmesh_assert_greater (dim,j);
888 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
889 
890  if (elem->infinite()){
891  return ifem_shape_deriv(dim, fe_t, elem, i, j, p);
892  }
893 
894 #endif
895 
896  const Order o = fe_t.order;
897 
898  switch(dim)
899  {
900  case 0:
901  fe_family_switch (0, shape_deriv(elem, o, i, j, p), return , ;);
902  case 1:
903  fe_family_switch (1, shape_deriv(elem, o, i, j, p), return , ;);
904  case 2:
905  fe_family_switch (2, shape_deriv(elem, o, i, j, p), return , ;);
906  case 3:
907  fe_family_switch (3, shape_deriv(elem, o, i, j, p), return , ;);
908  default:
909  libmesh_error_msg("Invalid dimension = " << dim);
910  }
911  return 0;
912 }

References dim, ifem_shape_deriv(), libMesh::Elem::infinite(), libMesh::FEType::order, and shape_deriv().

◆ shape_deriv() [2/2]

Real libMesh::FEInterface::shape_deriv ( const unsigned int  dim,
const FEType &  fe_t,
const ElemType  t,
const unsigned int  i,
const unsigned int  j,
const Point &  p 
)
static
Returns
The \( j^{th} \) coordinate of the gradient 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 scalar finite element class member.
Note
On a p-refined element, fe_t.order should be the total order of the element.

Definition at line 845 of file fe_interface.C.

851 {
852  libmesh_assert_greater (dim,j);
853 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
854 
855  if (is_InfFE_elem(t)){
856  return ifem_shape_deriv(dim, fe_t, t, i, j, p);
857  }
858 
859 #endif
860 
861  const Order o = fe_t.order;
862 
863  switch(dim)
864  {
865  case 0:
866  fe_family_switch (0, shape_deriv(t, o, i, j, p), return , ;);
867  case 1:
868  fe_family_switch (1, shape_deriv(t, o, i, j, p), return , ;);
869  case 2:
870  fe_family_switch (2, shape_deriv(t, o, i, j, p), return , ;);
871  case 3:
872  fe_family_switch (3, shape_deriv(t, o, i, j, p), return , ;);
873  default:
874  libmesh_error_msg("Invalid dimension = " << dim);
875  }
876  return 0;
877 }

References dim, ifem_shape_deriv(), is_InfFE_elem(), and libMesh::FEType::order.

Referenced by libMesh::InfFE< Dim, T_radial, T_map >::compute_data(), compute_data(), ifem_shape_deriv(), libMesh::FE< Dim, LAGRANGE_VEC >::shape_deriv(), libMesh::InfFE< Dim, T_radial, T_map >::shape_deriv(), shape_deriv(), shape_deriv_function(), and libMesh::FE< Dim, LAGRANGE_VEC >::shape_second_deriv().

◆ shape_deriv_function()

FEInterface::shape_deriv_ptr libMesh::FEInterface::shape_deriv_function ( const unsigned int  dim,
const FEType &  fe_t 
)
static
Returns
A function which evaluates shape for the requested FE type and dimension.

Definition at line 916 of file fe_interface.C.

918 {
919  fe_switch(shape_deriv);
920 }

References shape_deriv().

Referenced by libMesh::FEMap::init_edge_shape_functions(), libMesh::FEMap::init_face_shape_functions(), libMesh::FEMap::init_reference_to_physical_map(), and libMesh::FEMap::map_deriv().

◆ shape_function()

FEInterface::shape_ptr libMesh::FEInterface::shape_function ( const unsigned int  dim,
const FEType &  fe_t 
)
static
Returns
A function which evaluates shape for the requested FE type and dimension.

Definition at line 838 of file fe_interface.C.

840 {
841  fe_switch(shape);
842 }

References shape().

Referenced by libMesh::FEMap::init_edge_shape_functions(), libMesh::FEMap::init_face_shape_functions(), libMesh::FEMap::init_reference_to_physical_map(), and libMesh::FEMap::map().

◆ shape_second_deriv() [1/2]

Real libMesh::FEInterface::shape_second_deriv ( const unsigned int  dim,
const FEType &  fe_t,
const Elem *  elem,
const unsigned int  i,
const unsigned int  j,
const Point &  p 
)
static
Returns
The second \( j^{th} \) derivative of the \( i^{th} \) shape function at the point p.
Note
Cross-derivatives are indexed according to: j = 0 ==> d^2 phi / dxi^2 j = 1 ==> d^2 phi / dxi deta j = 2 ==> d^2 phi / deta^2 j = 3 ==> d^2 phi / dxi dzeta j = 4 ==> d^2 phi / deta dzeta j = 5 ==> d^2 phi / dzeta^2
On a p-refined element, fe_t.order should be the total order of the element.

Definition at line 956 of file fe_interface.C.

962 {
963  libmesh_assert_greater (dim,j);
964 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
965  if (elem->infinite())
966  libmesh_not_implemented();
967 #endif
968 
969  const Order o = fe_t.order;
970 
971  switch(dim)
972  {
973  case 0:
974  fe_family_switch (0, shape_second_deriv(elem, o, i, j, p), return , ;);
975  case 1:
976  fe_family_switch (1, shape_second_deriv(elem, o, i, j, p), return , ;);
977  case 2:
978  fe_family_switch (2, shape_second_deriv(elem, o, i, j, p), return , ;);
979  case 3:
980  fe_family_switch (3, shape_second_deriv(elem, o, i, j, p), return , ;);
981  default:
982  libmesh_error_msg("Invalid dimension = " << dim);
983  }
984  return 0;
985 }

References dim, libMesh::Elem::infinite(), libMesh::FEType::order, and shape_second_deriv().

◆ shape_second_deriv() [2/2]

Real libMesh::FEInterface::shape_second_deriv ( const unsigned int  dim,
const FEType &  fe_t,
const ElemType  t,
const unsigned int  i,
const unsigned int  j,
const Point &  p 
)
static
Returns
The second \( j^{th} \) derivative of the \( i^{th} \) shape function at the point p.
Note
Cross-derivatives are indexed according to: j = 0 ==> d^2 phi / dxi^2 j = 1 ==> d^2 phi / dxi deta j = 2 ==> d^2 phi / deta^2 j = 3 ==> d^2 phi / dxi dzeta j = 4 ==> d^2 phi / deta dzeta j = 5 ==> d^2 phi / dzeta^2

This method allows you to specify the dimension, element type, and order directly. Automatically passes the request to the appropriate scalar finite element class member.

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

Definition at line 924 of file fe_interface.C.

930 {
931  libmesh_assert_greater (dim*(dim-1),j);
932 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
933  if (is_InfFE_elem(t))
934  libmesh_not_implemented();
935 #endif
936 
937  const Order o = fe_t.order;
938 
939  switch(dim)
940  {
941  case 0:
942  fe_family_switch (0, shape_second_deriv(t, o, i, j, p), return , ;);
943  case 1:
944  fe_family_switch (1, shape_second_deriv(t, o, i, j, p), return , ;);
945  case 2:
946  fe_family_switch (2, shape_second_deriv(t, o, i, j, p), return , ;);
947  case 3:
948  fe_family_switch (3, shape_second_deriv(t, o, i, j, p), return , ;);
949  default:
950  libmesh_error_msg("Invalid dimension = " << dim);
951  }
952  return 0;
953 }

References dim, is_InfFE_elem(), and libMesh::FEType::order.

Referenced by libMesh::FE< Dim, LAGRANGE_VEC >::shape_second_deriv(), shape_second_deriv(), and shape_second_deriv_function().

◆ shape_second_deriv_function()

FEInterface::shape_second_deriv_ptr libMesh::FEInterface::shape_second_deriv_function ( const unsigned int  dim,
const FEType &  fe_t 
)
static
Returns
A function which evaluates shape for the requested FE type and dimension.

Definition at line 989 of file fe_interface.C.

991 {
992  fe_switch(shape_second_deriv);
993 }

References shape_second_deriv().

Referenced by libMesh::FEMap::init_edge_shape_functions(), libMesh::FEMap::init_face_shape_functions(), and libMesh::FEMap::init_reference_to_physical_map().

The documentation for this class was generated from the following files:
libMesh::C_ONE
Definition: enum_fe_family.h:80
libMesh::HEX20
Definition: enum_elem_type.h:48
libMesh::PRISM6
Definition: enum_elem_type.h:50
libMesh::FEGenericBase::compute_periodic_constraints
static void compute_periodic_constraints(DofConstraints &constraints, DofMap &dof_map, const PeriodicBoundaries &boundaries, const MeshBase &mesh, const PointLocatorBase *point_locator, const unsigned int variable_number, const Elem *elem)
Computes the constraint matrix contributions (for meshes with periodic boundary conditions) correspon...
Definition: fe_base.C:1692
libMesh::FEInterface::n_shape_functions
static unsigned int n_shape_functions(const unsigned int dim, const FEType &fe_t, const ElemType t)
Definition: fe_interface.C:446
libMesh::CLOUGH
Definition: enum_fe_family.h:53
libMesh::FEInterface::inverse_map
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)
This is now deprecated; use FEMap::inverse_map instead.
Definition: fe_interface.C:620
libMesh::FEInterface::ifem_nodal_soln
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)
Definition: fe_interface_inf_fe.C:229
libMesh::L2_HIERARCHIC
Definition: enum_fe_family.h:40
libMesh::HEX8
Definition: enum_elem_type.h:47
libMesh::INFINITE_MAP
Definition: enum_fe_family.h:48
libMesh::EDGE4
Definition: enum_elem_type.h:37
libMesh::FEInterface::ifem_n_dofs
static unsigned int ifem_n_dofs(const unsigned int dim, const FEType &fe_t, const ElemType t)
Definition: fe_interface_inf_fe.C:134
libMesh::HERMITE
Definition: enum_fe_family.h:54
libMesh::TYPE_SCALAR
Definition: enum_fe_family.h:93
libMesh::FEInterface::n_dofs_at_node
static unsigned int n_dofs_at_node(const unsigned int dim, const FEType &fe_t, const ElemType t, const unsigned int n)
Definition: fe_interface.C:503
libMesh::FEInterface::shape_second_deriv
static Real shape_second_deriv(const unsigned int dim, const FEType &fe_t, const ElemType t, const unsigned int i, const unsigned int j, const Point &p)
Definition: fe_interface.C:924
libMesh::FEInterface::ifem_n_dofs_per_elem
static unsigned int ifem_n_dofs_per_elem(const unsigned int dim, const FEType &fe_t, const ElemType t)
Definition: fe_interface_inf_fe.C:198
libMesh::InfFE::n_dofs
static unsigned int n_dofs(const FEType &fet, const ElemType inf_elem_type)
Definition: inf_fe_static.C:58
libMesh::JACOBI_20_00
Definition: enum_fe_family.h:49
libMesh::InfFE::nodal_soln
static void nodal_soln(const FEType &fet, const Elem *elem, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)
Usually, this method would build the nodal soln from the element soln.
Definition: inf_fe_static.C:123
libMesh::TET10
Definition: enum_elem_type.h:46
libMesh::XYZ
Definition: enum_fe_family.h:46
libMesh::Order
Order
Definition: enum_order.h:40
libMesh::InfFE::map
static Point map(const Elem *inf_elem, const Point &reference_point)
Definition: inf_fe.h:390
libMesh::MONOMIAL_VEC
Definition: enum_fe_family.h:62
libMesh::FEInterface::is_InfFE_elem
static bool is_InfFE_elem(const ElemType et)
Definition: fe_interface.C:46
mesh
MeshBase & mesh
Definition: mesh_communication.C:1257
dim
unsigned int dim
Definition: adaptivity_ex3.C:113
libMesh::FEInterface::nodal_soln
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)
Build the nodal soln from the element soln.
Definition: fe_interface.C:580
libMesh::TET4
Definition: enum_elem_type.h:45
libMesh::CARTESIAN
Definition: enum_inf_map_type.h:35
libMesh::FEInterface::ifem_shape_deriv
static Real ifem_shape_deriv(const unsigned int dim, const FEType &fe_t, const ElemType t, const unsigned int i, const unsigned int j, const Point &p)
Definition: fe_interface_inf_fe.C:893
libMesh::PRISM15
Definition: enum_elem_type.h:51
libMesh::SZABAB
Definition: enum_fe_family.h:44
libMesh::libmesh_assert
libmesh_assert(ctx)
libMesh::JACOBI_30_00
Definition: enum_fe_family.h:50
libMesh::HEX27
Definition: enum_elem_type.h:49
libMesh::FEInterface::n_dofs_per_elem
static unsigned int n_dofs_per_elem(const unsigned int dim, const FEType &fe_t, const ElemType t)
Definition: fe_interface.C:534
libMesh::FEGenericBase::build
static std::unique_ptr< FEGenericBase > build(const unsigned int dim, const FEType &type)
Builds a specific finite element type.
libMesh::QUAD4
Definition: enum_elem_type.h:41
libMesh::FEInterface::dofs_on_edge
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)
Fills the vector di with the local degree of freedom indices associated with edge e of element elem A...
Definition: fe_interface.C:566
libMesh::DISCONTINUOUS
Definition: enum_fe_family.h:78
libMesh::TRI3
Definition: enum_elem_type.h:39
libMesh::H_CURL
Definition: enum_fe_family.h:81
libMesh::C_ZERO
Definition: enum_fe_family.h:79
libMesh::LEGENDRE
Definition: enum_fe_family.h:51
libMesh::FE::compute_constraints
static void compute_constraints(DofConstraints &constraints, DofMap &dof_map, const unsigned int variable_number, const Elem *elem)
Computes the constraint matrix contributions (for non-conforming adapted meshes) corresponding to var...
libMesh::FEInterface::ifem_n_dofs_at_node
static unsigned int ifem_n_dofs_at_node(const unsigned int dim, const FEType &fe_t, const ElemType t, const unsigned int n)
Definition: fe_interface_inf_fe.C:165
libMesh::FEInterface::n_dofs
static unsigned int n_dofs(const unsigned int dim, const FEType &fe_t, const ElemType t)
Definition: fe_interface.C:472
libMesh::RATIONAL_BERNSTEIN
Definition: enum_fe_family.h:64
libMesh::BERNSTEIN
Definition: enum_fe_family.h:43
libMesh::InfFE::n_shape_functions
virtual unsigned int n_shape_functions() const override
Definition: inf_fe.h:482
libMesh::Utility::enum_to_string
std::string enum_to_string(const T e)
libMesh::FEInterface::ifem_n_shape_functions
static unsigned int ifem_n_shape_functions(const unsigned int dim, const FEType &fe_t, const ElemType t)
Definition: fe_interface_inf_fe.C:102
libMesh::FEInterface::map
static Point map(unsigned int dim, const FEType &fe_t, const Elem *elem, const Point &p)
This is now deprecated; use FEMap::map instead.
Definition: fe_interface.C:604
libMesh::SPHERICAL
Definition: enum_inf_map_type.h:36
libMesh::ELLIPSOIDAL
Definition: enum_inf_map_type.h:37
libMesh::HIERARCHIC
Definition: enum_fe_family.h:37
libMesh::MONOMIAL
Definition: enum_fe_family.h:39
libMesh::FEInterface::ifem_shape
static Real ifem_shape(const unsigned int dim, const FEType &fe_t, const ElemType t, const unsigned int i, const Point &p)
Definition: fe_interface_inf_fe.C:675
libMesh::FEInterface::dofs_on_side
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)
Fills the vector di with the local degree of freedom indices associated with side s of element elem A...
Definition: fe_interface.C:553
libMesh::FEAbstract::on_reference_element
static bool on_reference_element(const Point &p, const ElemType t, const Real eps=TOLERANCE)
Definition: fe_abstract.C:606
libMesh::TRI6
Definition: enum_elem_type.h:40
libMesh::InfFE::inverse_map
static Point inverse_map(const Elem *elem, const Point &p, const Real tolerance=TOLERANCE, const bool secure=true)
Definition: inf_fe.h:397
libMesh::FEInterface::shape_deriv
static Real shape_deriv(const unsigned int dim, const FEType &fe_t, const ElemType t, const unsigned int i, const unsigned int j, const Point &p)
Definition: fe_interface.C:845
libMesh::InfFE::shape
static Real shape(const FEType &fet, const ElemType t, const unsigned int i, const Point &p)
Definition: inf_fe_static.C:158
libMesh::QUADSHELL8
Definition: enum_elem_type.h:73
libMesh::PYRAMID5
Definition: enum_elem_type.h:53
libMesh::FEInterface::field_type
static FEFieldType field_type(const FEType &fe_type)
Definition: fe_interface.C:1683
libMesh::NEDELEC_ONE
Definition: enum_fe_family.h:61
libMesh::TYPE_VECTOR
Definition: enum_fe_family.h:94
libMesh::EDGE3
Definition: enum_elem_type.h:36
libMesh::QUADSHELL4
Definition: enum_elem_type.h:72
data
IterBase * data
Ideally this private member data should have protected access.
Definition: variant_filter_iterator.h:337
libMesh::L2_LAGRANGE
Definition: enum_fe_family.h:41
libMesh::QUAD9
Definition: enum_elem_type.h:43
libMesh::FEInterface::ifem_inverse_map
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)
Definition: fe_interface_inf_fe.C:510
libMesh::LAGRANGE_VEC
Definition: enum_fe_family.h:60
libMesh::err
OStreamProxy err
libMesh::LAGRANGE
Definition: enum_fe_family.h:36
libMesh::InfFE::n_dofs_at_node
static unsigned int n_dofs_at_node(const FEType &fet, const ElemType inf_elem_type, const unsigned int n)
Definition: inf_fe_static.C:76
libMesh::SCALAR
Definition: enum_fe_family.h:58
libMesh::SUBDIVISION
Definition: enum_fe_family.h:55
libMesh::InfFE::compute_data
static void compute_data(const FEType &fe_t, const Elem *inf_elem, FEComputeData &data)
Generalized version of shape(), takes an Elem *.
Definition: inf_fe_static.C:337
libMesh::TRI3SUBDIVISION
Definition: enum_elem_type.h:69
libMesh::PRISM18
Definition: enum_elem_type.h:52
libMesh::TRISHELL3
Definition: enum_elem_type.h:71
libMesh::FEInterface::ifem_compute_data
static void ifem_compute_data(const unsigned int dim, const FEType &fe_t, const Elem *elem, FEComputeData &data)
Definition: fe_interface_inf_fe.C:918
libMesh::PYRAMID13
Definition: enum_elem_type.h:54
libMesh::PYRAMID14
Definition: enum_elem_type.h:55
libMesh::EDGE2
Definition: enum_elem_type.h:35
libMesh::QUAD8
Definition: enum_elem_type.h:42
libMesh::FEInterface::shape
static Real shape(const unsigned int dim, const FEType &fe_t, const ElemType t, const unsigned int i, const Point &p)
Definition: fe_interface.C:687
libMesh::InfFE::n_dofs_per_elem
static unsigned int n_dofs_per_elem(const FEType &fet, const ElemType inf_elem_type)
Definition: inf_fe_static.C:105
libMesh::FEInterface::ifem_map
static Point ifem_map(const unsigned int dim, const FEType &fe_t, const Elem *elem, const Point &p)
Definition: fe_interface_inf_fe.C:479
Generated on Sat Jan 25 2020 12:07:51 for libMesh by   doxygen 1.8.16