libMesh
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Static Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes | Static Protected Attributes | Friends | List of all members
libMesh::FEGenericBase< OutputType > Class Template Referenceabstract

This class forms the foundation from which generic finite elements may be derived. More...

#include <fe_base.h>

Inheritance diagram for libMesh::FEGenericBase< OutputType >:
[legend]

Public Types

typedef OutputType OutputShape
 Convenient typedefs for gradients of output, hessians of output, and potentially-complex-valued versions of same.
 
typedef TensorTools::IncrementRank< OutputShape >::type OutputGradient
 
typedef TensorTools::IncrementRank< OutputGradient >::type OutputTensor
 
typedef TensorTools::DecrementRank< OutputShape >::type OutputDivergence
 
typedef TensorTools::MakeNumber< OutputShape >::type OutputNumber
 
typedef TensorTools::IncrementRank< OutputNumber >::type OutputNumberGradient
 
typedef TensorTools::IncrementRank< OutputNumberGradient >::type OutputNumberTensor
 
typedef TensorTools::DecrementRank< OutputNumber >::type OutputNumberDivergence
 

Public Member Functions

virtual ~FEGenericBase ()
 Destructor.
 
const std::vector< std::vector< OutputShape > > & get_phi () const
 
const std::vector< std::vector< OutputShape > > & get_dual_phi () const
 
virtual void request_phi () const override
 request phi calculations
 
virtual void request_dual_phi () const override
 
const std::vector< std::vector< OutputGradient > > & get_dphi () const
 
const std::vector< std::vector< OutputGradient > > & get_dual_dphi () const
 
virtual void request_dphi () const override
 request dphi calculations
 
virtual void request_dual_dphi () const override
 
const DenseMatrix< Real > & get_dual_coeff () const
 
virtual_for_inffe const std::vector< std::vector< OutputShape > > & get_curl_phi () const
 
virtual_for_inffe const std::vector< std::vector< OutputDivergence > > & get_div_phi () const
 
const std::vector< std::vector< OutputShape > > & get_dphidx () const
 
const std::vector< std::vector< OutputShape > > & get_dphidy () const
 
const std::vector< std::vector< OutputShape > > & get_dphidz () const
 
const std::vector< std::vector< OutputShape > > & get_dphidxi () const
 
const std::vector< std::vector< OutputShape > > & get_dphideta () const
 
const std::vector< std::vector< OutputShape > > & get_dphidzeta () const
 
const std::vector< std::vector< OutputTensor > > & get_d2phi () const
 
const std::vector< std::vector< OutputTensor > > & get_dual_d2phi () const
 
const std::vector< std::vector< OutputShape > > & get_d2phidx2 () const
 
const std::vector< std::vector< OutputShape > > & get_d2phidxdy () const
 
const std::vector< std::vector< OutputShape > > & get_d2phidxdz () const
 
const std::vector< std::vector< OutputShape > > & get_d2phidy2 () const
 
const std::vector< std::vector< OutputShape > > & get_d2phidydz () const
 
const std::vector< std::vector< OutputShape > > & get_d2phidz2 () const
 
const std::vector< std::vector< OutputShape > > & get_d2phidxi2 () const
 
const std::vector< std::vector< OutputShape > > & get_d2phidxideta () const
 
const std::vector< std::vector< OutputShape > > & get_d2phidxidzeta () const
 
const std::vector< std::vector< OutputShape > > & get_d2phideta2 () const
 
const std::vector< std::vector< OutputShape > > & get_d2phidetadzeta () const
 
const std::vector< std::vector< OutputShape > > & get_d2phidzeta2 () const
 
const std::vector< OutputGradient > & get_dphase () const
 
virtual const std::vector< Real > & get_Sobolev_weight () const
 
virtual const std::vector< RealGradient > & get_Sobolev_dweight () const
 
virtual const std::vector< Real > & get_Sobolev_weightxR_sq () const
 
virtual const std::vector< RealGradient > & get_Sobolev_dweightxR_sq () const
 
virtual const std::vector< std::vector< OutputShape > > & get_phi_over_decayxR () const
 
virtual const std::vector< std::vector< OutputGradient > > & get_dphi_over_decayxR () const
 
virtual const std::vector< std::vector< OutputGradient > > & get_dphi_over_decay () const
 
virtual void print_phi (std::ostream &os) const override
 Prints the value of each shape function at each quadrature point.
 
virtual void print_dual_phi (std::ostream &os) const override
 
virtual void print_dphi (std::ostream &os) const override
 Prints the value of each shape function's derivative at each quadrature point.
 
virtual void print_dual_dphi (std::ostream &os) const override
 
virtual void print_d2phi (std::ostream &os) const override
 Prints the value of each shape function's second derivatives at each quadrature point.
 
virtual void print_dual_d2phi (std::ostream &os) const override
 
std::unique_ptr< FEGenericBase< Real > > build (const unsigned int dim, const FEType &fet)
 
std::unique_ptr< FEGenericBase< RealGradient > > build (const unsigned int dim, const FEType &fet)
 
std::unique_ptr< FEGenericBase< Real > > build_InfFE (const unsigned int dim, const FEType &fet)
 
std::unique_ptr< FEGenericBase< RealGradient > > build_InfFE (const unsigned int, const FEType &)
 
virtual void reinit (const Elem *elem, const std::vector< Point > *const pts=nullptr, const std::vector< Real > *const weights=nullptr)=0
 This is at the core of this class.
 
virtual void reinit (const Elem *elem, const unsigned int side, const Real tolerance=TOLERANCE, const std::vector< Point > *const pts=nullptr, const std::vector< Real > *const weights=nullptr)=0
 Reinitializes all the physical element-dependent data based on the side of the element elem.
 
virtual void reinit_dual_shape_coeffs (const Elem *, const std::vector< Point > &, const std::vector< Real > &)
 This re-computes the dual shape function coefficients using CUSTOMIZED qrule.
 
virtual void reinit_default_dual_shape_coeffs (const Elem *)
 This re-computes the dual shape function coefficients using DEFAULT qrule.
 
virtual void edge_reinit (const Elem *elem, const unsigned int edge, const Real tolerance=TOLERANCE, const std::vector< Point > *pts=nullptr, const std::vector< Real > *weights=nullptr)=0
 Reinitializes all the physical element-dependent data based on the edge of the element elem.
 
virtual void side_map (const Elem *elem, const Elem *side, const unsigned int s, const std::vector< Point > &reference_side_points, std::vector< Point > &reference_points)=0
 Computes the reference space quadrature points on the side of an element based on the side quadrature points.
 
unsigned int get_dim () const
 
void get_nothing () const
 
virtual_for_inffe const std::vector< Point > & get_xyz () const
 
virtual const std::vector< Real > & get_JxWxdecay_sq () const
 This function is the variant of get_JxW() for InfFE.
 
virtual_for_inffe const std::vector< Real > & get_JxW () const
 
virtual_for_inffe const std::vector< RealGradient > & get_dxyzdxi () const
 
virtual_for_inffe const std::vector< RealGradient > & get_dxyzdeta () const
 
virtual_for_inffe const std::vector< RealGradient > & get_dxyzdzeta () const
 
virtual_for_inffe const std::vector< RealGradient > & get_d2xyzdxi2 () const
 
virtual_for_inffe const std::vector< RealGradient > & get_d2xyzdeta2 () const
 
virtual_for_inffe const std::vector< RealGradient > & get_d2xyzdzeta2 () const
 
virtual_for_inffe const std::vector< RealGradient > & get_d2xyzdxideta () const
 
virtual_for_inffe const std::vector< RealGradient > & get_d2xyzdxidzeta () const
 
virtual_for_inffe const std::vector< RealGradient > & get_d2xyzdetadzeta () const
 
virtual_for_inffe const std::vector< Real > & get_dxidx () const
 
virtual_for_inffe const std::vector< Real > & get_dxidy () const
 
virtual_for_inffe const std::vector< Real > & get_dxidz () const
 
virtual_for_inffe const std::vector< Real > & get_detadx () const
 
virtual_for_inffe const std::vector< Real > & get_detady () const
 
virtual_for_inffe const std::vector< Real > & get_detadz () const
 
virtual_for_inffe const std::vector< Real > & get_dzetadx () const
 
virtual_for_inffe const std::vector< Real > & get_dzetady () const
 
virtual_for_inffe const std::vector< Real > & get_dzetadz () const
 
virtual_for_inffe const std::vector< std::vector< Point > > & get_tangents () const
 
virtual_for_inffe const std::vector< Point > & get_normals () const
 
virtual_for_inffe const std::vector< Real > & get_curvatures () const
 
virtual void attach_quadrature_rule (QBase *q)=0
 Provides the class with the quadrature rule.
 
virtual unsigned int n_shape_functions () const =0
 
virtual unsigned int n_quadrature_points () const
 
const Elem * get_elem () const
 
ElemType get_type () const
 
unsigned int get_p_level () const
 
FEType get_fe_type () const
 
Order get_order () const
 
void set_fe_order (int new_order)
 Sets the base FE order of the finite element.
 
virtual FEContinuity get_continuity () const =0
 
virtual bool is_hierarchic () const =0
 
FEFamily get_family () const
 
const FEMap & get_fe_map () const
 
FEMap & get_fe_map ()
 
void print_JxW (std::ostream &os) const
 Prints the Jacobian times the weight for each quadrature point.
 
void print_xyz (std::ostream &os) const
 Prints the spatial location of each quadrature point (on the physical element).
 
void print_info (std::ostream &os) const
 Prints all the relevant information about the current element.
 
void set_calculate_dual (const bool val)
 set calculate_dual as needed
 
void set_calculate_default_dual_coeff (const bool val)
 set calculate_default_dual_coeff as needed
 
void add_p_level_in_reinit (bool value)
 Indicate whether to add p-refinement levels in init/reinit methods.
 
bool add_p_level_in_reinit () const
 Whether to add p-refinement levels in init/reinit methods.
 

Static Public Member Functions

static std::unique_ptr< FEGenericBase > build (const unsigned int dim, const FEType &type)
 Builds a specific finite element type.
 
static std::unique_ptr< FEGenericBase > build_InfFE (const unsigned int dim, const FEType &type)
 Builds a specific infinite element type.
 
static void compute_proj_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, using generic projections.
 
static void coarsened_dof_values (const NumericVector< Number > &global_vector, const DofMap &dof_map, const Elem *coarse_elem, DenseVector< Number > &coarse_dofs, const unsigned int var, const bool use_old_dof_indices=false)
 Creates a local projection on coarse_elem, based on the DoF values in global_vector for it's children.
 
static void coarsened_dof_values (const NumericVector< Number > &global_vector, const DofMap &dof_map, const Elem *coarse_elem, DenseVector< Number > &coarse_dofs, const bool use_old_dof_indices=false)
 Creates a local projection on coarse_elem, based on the DoF values in global_vector for it's children.
 
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) corresponding to variable number var_number, using generic projections.
 
static bool on_reference_element (const Point &p, const ElemType t, const Real eps=TOLERANCE)
 
static void get_refspace_nodes (const ElemType t, std::vector< Point > &nodes)
 
static void compute_node_constraints (NodeConstraints &constraints, const Elem *elem)
 Computes the nodal constraint contributions (for non-conforming adapted meshes), using Lagrange geometry.
 
static void compute_periodic_node_constraints (NodeConstraints &constraints, const PeriodicBoundaries &boundaries, const MeshBase &mesh, const PointLocatorBase *point_locator, const Elem *elem)
 Computes the node position constraint equation contributions (for meshes with periodic boundary conditions)
 
static void print_info (std::ostream &out_stream=libMesh::out)
 Prints the reference information, by default to libMesh::out.
 
static std::string get_info ()
 Gets a string containing the reference information.
 
static unsigned int n_objects ()
 Prints the number of outstanding (created, but not yet destroyed) objects.
 
static void enable_print_counter_info ()
 Methods to enable/disable the reference counter output from print_info().
 
static void disable_print_counter_info ()
 

Protected Types

typedef std::map< std::string, std::pair< unsigned int, unsigned int > > Counts
 Data structure to log the information.
 

Protected Member Functions

 FEGenericBase (const unsigned int dim, const FEType &fet)
 Constructor.
 
virtual void init_base_shape_functions (const std::vector< Point > &qp, const Elem *e)=0
 Initialize the data fields for the base of an an infinite element.
 
virtual_for_inffe void determine_calculations ()
 Determine which values are to be calculated, for both the FE itself and for the FEMap.
 
bool calculating_nothing () const
 
virtual void compute_shape_functions (const Elem *elem, const std::vector< Point > &qp) override
 After having updated the jacobian and the transformation from local to global coordinates in FEMap::compute_map(), the first derivatives of the shape functions are transformed to global coordinates, giving dphi, dphidx, dphidy, and dphidz.
 
void compute_dual_shape_coeffs (const std::vector< Real > &JxW, const std::vector< std::vector< OutputShape > > &phi)
 Compute the dual basis coefficients dual_coeff we rely on the JxW (or weights) and the phi values, which can come from default or customized qrule.
 
void compute_dual_shape_functions ()
 Compute dual_phi, dual_dphi, dual_d2phi It is only valid for this to be called after reinit has occurred with a quadrature rule.
 
void compute_dual_shape_functions ()
 
void compute_dual_shape_coeffs (const std::vector< Real > &, const std::vector< std::vector< OutputShape > > &)
 
void compute_dual_shape_coeffs (const std::vector< Real > &JxW, const std::vector< std::vector< OutputShape > > &phi_vals)
 
void compute_dual_shape_functions ()
 
virtual bool shapes_need_reinit () const =0
 
void increment_constructor_count (const std::string &name) noexcept
 Increments the construction counter.
 
void increment_destructor_count (const std::string &name) noexcept
 Increments the destruction counter.
 

Protected Attributes

std::unique_ptr< FETransformationBase< OutputType > > _fe_trans
 Object that handles computing shape function values, gradients, etc in the physical domain.
 
std::vector< std::vector< OutputShape > > phi
 Shape function values.
 
std::vector< std::vector< OutputShape > > dual_phi
 
std::vector< std::vector< OutputGradient > > dphi
 Shape function derivative values.
 
std::vector< std::vector< OutputGradient > > dual_dphi
 
DenseMatrix< Real > dual_coeff
 Coefficient matrix for the dual basis.
 
std::vector< std::vector< OutputShape > > curl_phi
 Shape function curl values.
 
std::vector< std::vector< OutputDivergence > > div_phi
 Shape function divergence values.
 
std::vector< std::vector< OutputShape > > dphidxi
 Shape function derivatives in the xi direction.
 
std::vector< std::vector< OutputShape > > dphideta
 Shape function derivatives in the eta direction.
 
std::vector< std::vector< OutputShape > > dphidzeta
 Shape function derivatives in the zeta direction.
 
std::vector< std::vector< OutputShape > > dphidx
 Shape function derivatives in the x direction.
 
std::vector< std::vector< OutputShape > > dphidy
 Shape function derivatives in the y direction.
 
std::vector< std::vector< OutputShape > > dphidz
 Shape function derivatives in the z direction.
 
std::vector< std::vector< OutputTensor > > d2phi
 Shape function second derivative values.
 
std::vector< std::vector< OutputTensor > > dual_d2phi
 
std::vector< std::vector< OutputShape > > d2phidxi2
 Shape function second derivatives in the xi direction.
 
std::vector< std::vector< OutputShape > > d2phidxideta
 Shape function second derivatives in the xi-eta direction.
 
std::vector< std::vector< OutputShape > > d2phidxidzeta
 Shape function second derivatives in the xi-zeta direction.
 
std::vector< std::vector< OutputShape > > d2phideta2
 Shape function second derivatives in the eta direction.
 
std::vector< std::vector< OutputShape > > d2phidetadzeta
 Shape function second derivatives in the eta-zeta direction.
 
std::vector< std::vector< OutputShape > > d2phidzeta2
 Shape function second derivatives in the zeta direction.
 
std::vector< std::vector< OutputShape > > d2phidx2
 Shape function second derivatives in the x direction.
 
std::vector< std::vector< OutputShape > > d2phidxdy
 Shape function second derivatives in the x-y direction.
 
std::vector< std::vector< OutputShape > > d2phidxdz
 Shape function second derivatives in the x-z direction.
 
std::vector< std::vector< OutputShape > > d2phidy2
 Shape function second derivatives in the y direction.
 
std::vector< std::vector< OutputShape > > d2phidydz
 Shape function second derivatives in the y-z direction.
 
std::vector< std::vector< OutputShape > > d2phidz2
 Shape function second derivatives in the z direction.
 
std::vector< OutputGradient > dphase
 Used for certain infinite element families: the first derivatives of the phase term in global coordinates, over all quadrature points.
 
std::vector< RealGradient > dweight
 Used for certain infinite element families: the global derivative of the additional radial weight \( 1/{r^2} \), over all quadrature points.
 
std::vector< Real > weight
 Used for certain infinite element families: the additional radial weight \( 1/{r^2} \) in local coordinates, over all quadrature points.
 
std::unique_ptr< FEMap > _fe_map
 
const unsigned int dim
 The dimensionality of the object.
 
bool calculations_started
 Have calculations with this object already been started? Then all get_* functions should already have been called.
 
bool calculate_dual
 Are we calculating dual basis?
 
bool calculate_default_dual_coeff
 Are we calculating the coefficient for the dual basis using the default qrule?
 
bool calculate_nothing
 Are we potentially deliberately calculating nothing?
 
bool calculate_map
 Are we calculating mapping functions?
 
bool calculate_phi
 Should we calculate shape functions?
 
bool calculate_dphi
 Should we calculate shape function gradients?
 
bool calculate_d2phi
 Should we calculate shape function hessians?
 
const bool calculate_d2phi =false
 
bool calculate_curl_phi
 Should we calculate shape function curls?
 
bool calculate_div_phi
 Should we calculate shape function divergences?
 
bool calculate_dphiref
 Should we calculate reference shape function gradients?
 
FEType fe_type
 The finite element type for this object.
 
ElemType _elem_type
 The element type the current data structures were set up for.
 
const Elem * _elem
 The element the current data structures were set up for.
 
unsigned int _elem_p_level
 The element p-refinement level the current data structures are set up for.
 
unsigned int _p_level
 The p refinement level the current data structures are set up for.
 
QBase * qrule
 A pointer to the quadrature rule employed.
 
bool shapes_on_quadrature
 A flag indicating if current data structures correspond to quadrature rule points.
 
unsigned int _n_total_qp
 The total number of quadrature points for the current configuration.
 
bool _add_p_level_in_reinit
 Whether to add p-refinement levels in init/reinit methods.
 

Static Protected Attributes

static Counts _counts
 Actually holds the data.
 
static Threads::atomic< unsigned int > _n_objects
 The number of objects.
 
static Threads::spin_mutex _mutex
 Mutual exclusion object to enable thread-safe reference counting.
 
static bool _enable_print_counter = true
 Flag to control whether reference count information is printed when print_info is called.
 

Friends

template<unsigned int friend_Dim, FEFamily friend_T_radial, InfMapType friend_T_map>
class InfFE
 Make all InfFE<Dim,T_radial,T_map> classes friends so that they can safely used FE<Dim-1,T_base> through a FEGenericBase * as base approximation.
 

Detailed Description

template<typename OutputType>
class libMesh::FEGenericBase< OutputType >

This class forms the foundation from which generic finite elements may be derived.

In the current implementation the templated derived class FE offers a wide variety of commonly used finite element concepts. Check there for details.

Use the FEGenericBase<OutputType>::build() method to create an object of any of the derived classes which is compatible with OutputType.

Author
Benjamin S. Kirk
Date
2002

Definition at line 85 of file fe_base.h.

Member Typedef Documentation

◆ Counts

typedef std::map<std::string, std::pair<unsigned int, unsigned int> > libMesh::ReferenceCounter::Counts
protectedinherited

Data structure to log the information.

The log is identified by the class name.

Definition at line 119 of file reference_counter.h.

◆ OutputDivergence

template<typename OutputType >
typedef TensorTools::DecrementRank<OutputShape>::type libMesh::FEGenericBase< OutputType >::OutputDivergence

Definition at line 122 of file fe_base.h.

◆ OutputGradient

template<typename OutputType >
typedef TensorTools::IncrementRank<OutputShape>::type libMesh::FEGenericBase< OutputType >::OutputGradient

Definition at line 120 of file fe_base.h.

◆ OutputNumber

template<typename OutputType >
typedef TensorTools::MakeNumber<OutputShape>::type libMesh::FEGenericBase< OutputType >::OutputNumber

Definition at line 123 of file fe_base.h.

◆ OutputNumberDivergence

template<typename OutputType >
typedef TensorTools::DecrementRank<OutputNumber>::type libMesh::FEGenericBase< OutputType >::OutputNumberDivergence

Definition at line 126 of file fe_base.h.

◆ OutputNumberGradient

template<typename OutputType >
typedef TensorTools::IncrementRank<OutputNumber>::type libMesh::FEGenericBase< OutputType >::OutputNumberGradient

Definition at line 124 of file fe_base.h.

◆ OutputNumberTensor

template<typename OutputType >
typedef TensorTools::IncrementRank<OutputNumberGradient>::type libMesh::FEGenericBase< OutputType >::OutputNumberTensor

Definition at line 125 of file fe_base.h.

◆ OutputShape

template<typename OutputType >
typedef OutputType libMesh::FEGenericBase< OutputType >::OutputShape

Convenient typedefs for gradients of output, hessians of output, and potentially-complex-valued versions of same.

Definition at line 119 of file fe_base.h.

◆ OutputTensor

template<typename OutputType >
typedef TensorTools::IncrementRank<OutputGradient>::type libMesh::FEGenericBase< OutputType >::OutputTensor

Definition at line 121 of file fe_base.h.

Constructor & Destructor Documentation

◆ FEGenericBase()

template<typename OutputType >
libMesh::FEGenericBase< OutputType >::FEGenericBase ( const unsigned int  dim,
const FEType &  fet 
)
inlineprotected

Constructor.

Optionally initializes required data structures. Protected so that this base class cannot be explicitly instantiated.

Definition at line 865 of file fe_base.h.

866 :
867 FEAbstract(d,fet),
869 phi(),
870 dual_phi(),
871 dphi(),
872 dual_dphi(),
873 curl_phi(),
874 div_phi(),
875 dphidxi(),
876 dphideta(),
877 dphidzeta(),
878 dphidx(),
879 dphidy(),
880 dphidz()
881#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
882 ,d2phi(),
883 dual_d2phi(),
884 d2phidxi2(),
885 d2phidxideta(),
887 d2phideta2(),
889 d2phidzeta2(),
890 d2phidx2(),
891 d2phidxdy(),
892 d2phidxdz(),
893 d2phidy2(),
894 d2phidydz(),
895 d2phidz2()
896#endif
897#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
898 ,dphase(),
899 dweight(),
900 weight()
901#endif
902{
903}
904
905
906
907template <typename OutputType>
908inline
910{
911}
FEAbstract(const unsigned int dim, const FEType &fet)
Constructor.
Definition fe_abstract.C:47
std::vector< std::vector< OutputTensor > > d2phi
Shape function second derivative values.
Definition fe_base.h:712
virtual ~FEGenericBase()
Destructor.
std::vector< std::vector< OutputShape > > d2phidxdz
Shape function second derivatives in the x-z direction.
Definition fe_base.h:758
std::vector< std::vector< OutputShape > > d2phidxidzeta
Shape function second derivatives in the xi-zeta direction.
Definition fe_base.h:728
std::vector< std::vector< OutputShape > > d2phidx2
Shape function second derivatives in the x direction.
Definition fe_base.h:748
std::vector< std::vector< OutputShape > > d2phidz2
Shape function second derivatives in the z direction.
Definition fe_base.h:773
std::vector< std::vector< OutputShape > > dphidx
Shape function derivatives in the x direction.
Definition fe_base.h:694
std::vector< std::vector< OutputShape > > d2phidy2
Shape function second derivatives in the y direction.
Definition fe_base.h:763
std::vector< std::vector< OutputShape > > dphidy
Shape function derivatives in the y direction.
Definition fe_base.h:699
std::vector< std::vector< OutputShape > > d2phidydz
Shape function second derivatives in the y-z direction.
Definition fe_base.h:768
std::vector< std::vector< OutputDivergence > > div_phi
Shape function divergence values.
Definition fe_base.h:674
std::vector< Real > weight
Used for certain infinite element families: the additional radial weight in local coordinates,...
Definition fe_base.h:805
std::vector< std::vector< OutputGradient > > dual_dphi
Definition fe_base.h:659
std::vector< std::vector< OutputGradient > > dphi
Shape function derivative values.
Definition fe_base.h:658
std::vector< std::vector< OutputShape > > d2phidxi2
Shape function second derivatives in the xi direction.
Definition fe_base.h:718
std::vector< std::vector< OutputShape > > d2phidxideta
Shape function second derivatives in the xi-eta direction.
Definition fe_base.h:723
std::vector< std::vector< OutputShape > > phi
Shape function values.
Definition fe_base.h:652
std::vector< std::vector< OutputShape > > dphidzeta
Shape function derivatives in the zeta direction.
Definition fe_base.h:689
std::vector< std::vector< OutputTensor > > dual_d2phi
Definition fe_base.h:713
std::vector< OutputGradient > dphase
Used for certain infinite element families: the first derivatives of the phase term in global coordin...
Definition fe_base.h:791
std::vector< std::vector< OutputShape > > dphidz
Shape function derivatives in the z direction.
Definition fe_base.h:704
std::vector< std::vector< OutputShape > > dual_phi
Definition fe_base.h:653
std::vector< std::vector< OutputShape > > d2phidetadzeta
Shape function second derivatives in the eta-zeta direction.
Definition fe_base.h:738
std::vector< std::vector< OutputShape > > dphidxi
Shape function derivatives in the xi direction.
Definition fe_base.h:679
std::vector< std::vector< OutputShape > > d2phideta2
Shape function second derivatives in the eta direction.
Definition fe_base.h:733
std::unique_ptr< FETransformationBase< OutputType > > _fe_trans
Object that handles computing shape function values, gradients, etc in the physical domain.
Definition fe_base.h:647
std::vector< std::vector< OutputShape > > d2phidxdy
Shape function second derivatives in the x-y direction.
Definition fe_base.h:753
std::vector< RealGradient > dweight
Used for certain infinite element families: the global derivative of the additional radial weight ,...
Definition fe_base.h:798
std::vector< std::vector< OutputShape > > d2phidzeta2
Shape function second derivatives in the zeta direction.
Definition fe_base.h:743
std::vector< std::vector< OutputShape > > curl_phi
Shape function curl values.
Definition fe_base.h:669
std::vector< std::vector< OutputShape > > dphideta
Shape function derivatives in the eta direction.
Definition fe_base.h:684
static std::unique_ptr< FETransformationBase< OutputShape > > build(const FEType &type)
Builds an FETransformation object based on the finite element type.

◆ ~FEGenericBase()

template<typename OutputType >
virtual libMesh::FEGenericBase< OutputType >::~FEGenericBase ( )
virtual

Destructor.

Member Function Documentation

◆ add_p_level_in_reinit() [1/2]

bool libMesh::FEAbstract::add_p_level_in_reinit ( ) const
inlineinherited

Whether to add p-refinement levels in init/reinit methods.

Definition at line 636 of file fe_abstract.h.

636{ return _add_p_level_in_reinit; }
bool _add_p_level_in_reinit
Whether to add p-refinement levels in init/reinit methods.

References libMesh::FEAbstract::_add_p_level_in_reinit.

◆ add_p_level_in_reinit() [2/2]

void libMesh::FEAbstract::add_p_level_in_reinit ( bool  value)
inlineinherited

Indicate whether to add p-refinement levels in init/reinit methods.

Definition at line 631 of file fe_abstract.h.

static const bool value
Definition xdr_io.C:55

References libMesh::FEAbstract::_add_p_level_in_reinit, and value.

Referenced by libMesh::FEMContext::build_new_fe().

◆ attach_quadrature_rule()

virtual void libMesh::FEAbstract::attach_quadrature_rule ( QBase *  q)
pure virtualinherited

◆ build() [1/3]

std::unique_ptr< FEGenericBase< Real > > libMesh::FEGenericBase< Real >::build ( const unsigned int  dim,
const FEType &  fet 
)

Definition at line 191 of file fe_base.C.

193{
194 switch (dim)
195 {
196 // 0D
197 case 0:
198 {
199 switch (fet.family)
200 {
201 case CLOUGH:
202 return std::make_unique<FE<0,CLOUGH>>(fet);
203
204 case HERMITE:
205 return std::make_unique<FE<0,HERMITE>>(fet);
206
207 case LAGRANGE:
208 return std::make_unique<FE<0,LAGRANGE>>(fet);
209
210 case L2_LAGRANGE:
211 return std::make_unique<FE<0,L2_LAGRANGE>>(fet);
212
213 case L2_LAGRANGE_GLL:
214 return std::make_unique<FE<0,L2_LAGRANGE_GLL>>(fet);
215
216 case HIERARCHIC:
217 return std::make_unique<FE<0,HIERARCHIC>>(fet);
218
219 case L2_HIERARCHIC:
220 return std::make_unique<FE<0,L2_HIERARCHIC>>(fet);
221
222 case SIDE_HIERARCHIC:
223 return std::make_unique<FE<0,SIDE_HIERARCHIC>>(fet);
224
225 case MONOMIAL:
226 return std::make_unique<FE<0,MONOMIAL>>(fet);
227
228#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES
229 case SZABAB:
230 return std::make_unique<FE<0,SZABAB>>(fet);
231
232 case BERNSTEIN:
233 return std::make_unique<FE<0,BERNSTEIN>>(fet);
234
236 return std::make_unique<FE<0,RATIONAL_BERNSTEIN>>(fet);
237#endif
238
239 case XYZ:
240 return std::make_unique<FEXYZ<0>>(fet);
241
242 case SCALAR:
243 return std::make_unique<FEScalar<0>>(fet);
244
245 default:
246 libmesh_error_msg("ERROR: Bad FEType.family == " << Utility::enum_to_string(fet.family));
247 }
248 }
249 // 1D
250 case 1:
251 {
252 switch (fet.family)
253 {
254 case CLOUGH:
255 return std::make_unique<FE<1,CLOUGH>>(fet);
256
257 case HERMITE:
258 return std::make_unique<FE<1,HERMITE>>(fet);
259
260 case LAGRANGE:
261 return std::make_unique<FE<1,LAGRANGE>>(fet);
262
263 case L2_LAGRANGE:
264 return std::make_unique<FE<1,L2_LAGRANGE>>(fet);
265
266 case L2_LAGRANGE_GLL:
267 return std::make_unique<FE<1,L2_LAGRANGE_GLL>>(fet);
268
269 case HIERARCHIC:
270 return std::make_unique<FE<1,HIERARCHIC>>(fet);
271
272 case L2_HIERARCHIC:
273 return std::make_unique<FE<1,L2_HIERARCHIC>>(fet);
274
275 case SIDE_HIERARCHIC:
276 return std::make_unique<FE<1,SIDE_HIERARCHIC>>(fet);
277
278 case MONOMIAL:
279 return std::make_unique<FE<1,MONOMIAL>>(fet);
280
281#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES
282 case SZABAB:
283 return std::make_unique<FE<1,SZABAB>>(fet);
284
285 case BERNSTEIN:
286 return std::make_unique<FE<1,BERNSTEIN>>(fet);
287
289 return std::make_unique<FE<1,RATIONAL_BERNSTEIN>>(fet);
290#endif
291
292 case XYZ:
293 return std::make_unique<FEXYZ<1>>(fet);
294
295 case SCALAR:
296 return std::make_unique<FEScalar<1>>(fet);
297
298 default:
299 libmesh_error_msg("ERROR: Bad FEType.family == " << Utility::enum_to_string(fet.family));
300 }
301 }
302
303
304 // 2D
305 case 2:
306 {
307 switch (fet.family)
308 {
309 case CLOUGH:
310 return std::make_unique<FE<2,CLOUGH>>(fet);
311
312 case HERMITE:
313 return std::make_unique<FE<2,HERMITE>>(fet);
314
315 case LAGRANGE:
316 return std::make_unique<FE<2,LAGRANGE>>(fet);
317
318 case L2_LAGRANGE:
319 return std::make_unique<FE<2,L2_LAGRANGE>>(fet);
320
321 case L2_LAGRANGE_GLL:
322 return std::make_unique<FE<2,L2_LAGRANGE_GLL>>(fet);
323
324 case HIERARCHIC:
325 return std::make_unique<FE<2,HIERARCHIC>>(fet);
326
327 case L2_HIERARCHIC:
328 return std::make_unique<FE<2,L2_HIERARCHIC>>(fet);
329
330 case SIDE_HIERARCHIC:
331 return std::make_unique<FE<2,SIDE_HIERARCHIC>>(fet);
332
333 case MONOMIAL:
334 return std::make_unique<FE<2,MONOMIAL>>(fet);
335
336#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES
337 case SZABAB:
338 return std::make_unique<FE<2,SZABAB>>(fet);
339
340 case BERNSTEIN:
341 return std::make_unique<FE<2,BERNSTEIN>>(fet);
342
344 return std::make_unique<FE<2,RATIONAL_BERNSTEIN>>(fet);
345#endif
346
347 case XYZ:
348 return std::make_unique<FEXYZ<2>>(fet);
349
350 case SCALAR:
351 return std::make_unique<FEScalar<2>>(fet);
352
353 case SUBDIVISION:
354 return std::make_unique<FESubdivision>(fet);
355
356 default:
357 libmesh_error_msg("ERROR: Bad FEType.family == " << Utility::enum_to_string(fet.family));
358 }
359 }
360
361
362 // 3D
363 case 3:
364 {
365 switch (fet.family)
366 {
367 case CLOUGH:
368 libmesh_error_msg("ERROR: Clough-Tocher elements currently only support 1D and 2D");
369
370 case HERMITE:
371 return std::make_unique<FE<3,HERMITE>>(fet);
372
373 case LAGRANGE:
374 return std::make_unique<FE<3,LAGRANGE>>(fet);
375
376 case L2_LAGRANGE:
377 return std::make_unique<FE<3,L2_LAGRANGE>>(fet);
378
379 case L2_LAGRANGE_GLL:
380 return std::make_unique<FE<3,L2_LAGRANGE_GLL>>(fet);
381
382 case HIERARCHIC:
383 return std::make_unique<FE<3,HIERARCHIC>>(fet);
384
385 case L2_HIERARCHIC:
386 return std::make_unique<FE<3,L2_HIERARCHIC>>(fet);
387
388 case SIDE_HIERARCHIC:
389 return std::make_unique<FE<3,SIDE_HIERARCHIC>>(fet);
390
391 case MONOMIAL:
392 return std::make_unique<FE<3,MONOMIAL>>(fet);
393
394#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES
395 case SZABAB:
396 return std::make_unique<FE<3,SZABAB>>(fet);
397
398 case BERNSTEIN:
399 return std::make_unique<FE<3,BERNSTEIN>>(fet);
400
402 return std::make_unique<FE<3,RATIONAL_BERNSTEIN>>(fet);
403#endif
404
405 case XYZ:
406 return std::make_unique<FEXYZ<3>>(fet);
407
408 case SCALAR:
409 return std::make_unique<FEScalar<3>>(fet);
410
411 default:
412 libmesh_error_msg("ERROR: Bad FEType.family == " << Utility::enum_to_string(fet.family));
413 }
414 }
415
416 default:
417 libmesh_error_msg("Invalid dimension dim = " << dim);
418 }
419}
const unsigned int dim
The dimensionality of the object.
FEFamily family
The type of finite element.
Definition fe_type.h:228
std::string enum_to_string(const T e)
@ RATIONAL_BERNSTEIN

◆ build() [2/3]

std::unique_ptr< FEGenericBase< RealGradient > > libMesh::FEGenericBase< RealGradient >::build ( const unsigned int  dim,
const FEType &  fet 
)

Definition at line 425 of file fe_base.C.

427{
428 switch (dim)
429 {
430 // 0D
431 case 0:
432 {
433 switch (fet.family)
434 {
435 case HIERARCHIC_VEC:
436 return std::make_unique<FEHierarchicVec<0>>(fet);
437
439 return std::make_unique<FEL2HierarchicVec<0>>(fet);
440
441 case LAGRANGE_VEC:
442 return std::make_unique<FELagrangeVec<0>>(fet);
443
444 case L2_LAGRANGE_VEC:
445 return std::make_unique<FEL2LagrangeVec<0>>(fet);
446
447 case MONOMIAL_VEC:
448 return std::make_unique<FEMonomialVec<0>>(fet);
449
450 default:
451 libmesh_error_msg("ERROR: Bad FEType.family == " << Utility::enum_to_string(fet.family));
452 }
453 }
454 case 1:
455 {
456 switch (fet.family)
457 {
458 case HIERARCHIC_VEC:
459 return std::make_unique<FEHierarchicVec<1>>(fet);
460
462 return std::make_unique<FEL2HierarchicVec<1>>(fet);
463
464 case LAGRANGE_VEC:
465 return std::make_unique<FELagrangeVec<1>>(fet);
466
467 case L2_LAGRANGE_VEC:
468 return std::make_unique<FEL2LagrangeVec<1>>(fet);
469
470 case MONOMIAL_VEC:
471 return std::make_unique<FEMonomialVec<1>>(fet);
472
473 default:
474 libmesh_error_msg("ERROR: Bad FEType.family == " << Utility::enum_to_string(fet.family));
475 }
476 }
477 case 2:
478 {
479 switch (fet.family)
480 {
481 case HIERARCHIC_VEC:
482 return std::make_unique<FEHierarchicVec<2>>(fet);
483
485 return std::make_unique<FEL2HierarchicVec<2>>(fet);
486
487 case LAGRANGE_VEC:
488 return std::make_unique<FELagrangeVec<2>>(fet);
489
490 case L2_LAGRANGE_VEC:
491 return std::make_unique<FEL2LagrangeVec<2>>(fet);
492
493 case MONOMIAL_VEC:
494 return std::make_unique<FEMonomialVec<2>>(fet);
495
496 case NEDELEC_ONE:
497 return std::make_unique<FENedelecOne<2>>(fet);
498
499 case RAVIART_THOMAS:
500 return std::make_unique<FERaviartThomas<2>>(fet);
501
503 return std::make_unique<FEL2RaviartThomas<2>>(fet);
504
505 default:
506 libmesh_error_msg("ERROR: Bad FEType.family == " << Utility::enum_to_string(fet.family));
507 }
508 }
509 case 3:
510 {
511 switch (fet.family)
512 {
513 case HIERARCHIC_VEC:
514 return std::make_unique<FEHierarchicVec<3>>(fet);
515
517 return std::make_unique<FEL2HierarchicVec<3>>(fet);
518
519 case LAGRANGE_VEC:
520 return std::make_unique<FELagrangeVec<3>>(fet);
521
522 case L2_LAGRANGE_VEC:
523 return std::make_unique<FEL2LagrangeVec<3>>(fet);
524
525 case MONOMIAL_VEC:
526 return std::make_unique<FEMonomialVec<3>>(fet);
527
528 case NEDELEC_ONE:
529 return std::make_unique<FENedelecOne<3>>(fet);
530
531 case RAVIART_THOMAS:
532 return std::make_unique<FERaviartThomas<3>>(fet);
533
535 return std::make_unique<FEL2RaviartThomas<3>>(fet);
536
537 default:
538 libmesh_error_msg("ERROR: Bad FEType.family == " << Utility::enum_to_string(fet.family));
539 }
540 }
541
542 default:
543 libmesh_error_msg("Invalid dimension dim = " << dim);
544 } // switch(dim)
545}
@ L2_RAVIART_THOMAS
@ L2_HIERARCHIC_VEC

References dim, libMesh::Utility::enum_to_string(), libMesh::FEType::family, libMesh::HIERARCHIC_VEC, libMesh::L2_HIERARCHIC_VEC, libMesh::L2_LAGRANGE_VEC, libMesh::L2_RAVIART_THOMAS, libMesh::LAGRANGE_VEC, libMesh::MONOMIAL_VEC, libMesh::NEDELEC_ONE, and libMesh::RAVIART_THOMAS.

◆ build() [3/3]

template<typename OutputType >
static std::unique_ptr< FEGenericBase > libMesh::FEGenericBase< OutputType >::build ( const unsigned int  dim,
const FEType &  type 
)
static

Builds a specific finite element type.

A std::unique_ptr<FEGenericBase> is returned to prevent a memory leak. This way the user need not remember to delete the object.

The build call will fail if the OutputType of this class is not compatible with the output required for the requested type

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::MeshFunction::_gradient_on_elem(), alternative_fe_assembly(), LinearElasticity::assemble(), assemble(), assemble(), assemble_1D(), AssembleOptimization::assemble_A_and_F(), libMesh::ClawSystem::assemble_advection_matrices(), libMesh::ClawSystem::assemble_avg_coupling_matrices(), assemble_biharmonic(), libMesh::ClawSystem::assemble_boundary_condition_matrices(), assemble_cd(), assemble_cd(), assemble_divgrad(), assemble_elasticity(), assemble_ellipticdg(), assemble_func(), assemble_graddiv(), assemble_helmholtz(), libMesh::ClawSystem::assemble_jump_coupling_matrix(), assemble_laplace(), assemble_mass(), libMesh::ClawSystem::assemble_mass_matrix(), assemble_matrices(), assemble_poisson(), assemble_poisson(), assemble_poisson(), assemble_SchroedingerEquation(), assemble_shell(), assemble_shell(), assemble_stokes(), assemble_temperature_jump(), assemble_wave(), assemble_wave(), Biharmonic::JR::bounds(), libMesh::FEMContext::cached_fe(), libMesh::FEInterface::compute_data(), compute_enriched_soln(), compute_jacobian(), compute_residual(), LinearElasticity::compute_stresses(), LargeDeformationElasticity::compute_stresses(), LinearElasticityWithContact::compute_stresses(), compute_stresses(), libMesh::ExactErrorEstimator::estimate_error(), fe_assembly(), form_functionA(), form_functionB(), form_matrixA(), libMesh::MeshFunction::hessian(), libMesh::InfFE< Dim, T_radial, T_map >::InfFE(), libMesh::InfFE< Dim, T_radial, T_map >::init_face_shape_functions(), integrate_function(), LargeDeformationElasticity::jacobian(), LaplaceYoung::jacobian(), libMesh::LIBMESH_DEFAULT_VECTORIZED_FE(), libMesh::LIBMESH_DEFAULT_VECTORIZED_FE(), main(), libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::SmoothnessEstimator::EstimateSmoothness::operator()(), libMesh::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), OverlappingCouplingFunctor::operator()(), libMesh::MeshFunction::operator()(), periodic_bc_test_poisson(), libMesh::InfFE< Dim, T_radial, T_map >::reinit(), LargeDeformationElasticity::residual(), LaplaceYoung::residual(), LinearElasticityWithContact::residual_and_jacobian(), Biharmonic::JR::residual_and_jacobian(), libMesh::HPCoarsenTest::select_refinement(), DualShapeTest::setUp(), RationalMapTest< elem_type >::setUp(), FETestBase< order, family, elem_type, build_nx, CaseName >::setUp(), libMesh::Elem::side_vertex_average_normal(), SideVertexAverageNormalTest::testC0Polygon(), FETest< order, family, elem_type, CaseName >::testCustomReinit(), SideVertexAverageNormalTest::testEdge3(), HDivGradTest::testGradByFiniteDifference(), SideVertexAverageNormalTest::testHexes(), FEGLLCollocationTest< elem_type, order >::testMassMatrixIsDiagonal(), InfFERadialTest::testRefinement(), FEGLLCollocationTest< elem_type, order >::testShapesAreIdentity(), InfFERadialTest::testSides(), DualShapeTest::testTransformedDual(), libMesh::Elem::true_centroid(), and libMesh::Elem::volume().

◆ build_InfFE() [1/3]

std::unique_ptr< FEGenericBase< Real > > libMesh::FEGenericBase< Real >::build_InfFE ( const unsigned int  dim,
const FEType &  fet 
)

Definition at line 558 of file fe_base.C.

560{
561 switch (dim)
562 {
563
564 // 1D
565 case 1:
566 {
567 switch (fet.radial_family)
568 {
569 case INFINITE_MAP:
570 libmesh_error_msg("ERROR: Can't build an infinite element with FEFamily = " << Utility::enum_to_string(fet.radial_family));
571
572 case JACOBI_20_00:
573 {
574 switch (fet.inf_map)
575 {
576 case CARTESIAN:
577 return std::make_unique<InfFE<1,JACOBI_20_00,CARTESIAN>>(fet);
578
579 default:
580 libmesh_error_msg("ERROR: Can't build an infinite element with InfMapType = " << Utility::enum_to_string(fet.inf_map));
581 }
582 }
583
584 case JACOBI_30_00:
585 {
586 switch (fet.inf_map)
587 {
588 case CARTESIAN:
589 return std::make_unique<InfFE<1,JACOBI_30_00,CARTESIAN>>(fet);
590
591 default:
592 libmesh_error_msg("ERROR: Can't build an infinite element with InfMapType = " << Utility::enum_to_string(fet.inf_map));
593 }
594 }
595
596 case LEGENDRE:
597 {
598 switch (fet.inf_map)
599 {
600 case CARTESIAN:
601 return std::make_unique<InfFE<1,LEGENDRE,CARTESIAN>>(fet);
602
603 default:
604 libmesh_error_msg("ERROR: Can't build an infinite element with InfMapType = " << Utility::enum_to_string(fet.inf_map));
605 }
606 }
607
608 case LAGRANGE:
609 {
610 switch (fet.inf_map)
611 {
612 case CARTESIAN:
613 return std::make_unique<InfFE<1,LAGRANGE,CARTESIAN>>(fet);
614
615 default:
616 libmesh_error_msg("ERROR: Can't build an infinite element with InfMapType = " << Utility::enum_to_string(fet.inf_map));
617 }
618 }
619
620 default:
621 libmesh_error_msg("ERROR: Bad FEType.radial_family= " << Utility::enum_to_string(fet.radial_family));
622 }
623 }
624
625
626
627
628 // 2D
629 case 2:
630 {
631 switch (fet.radial_family)
632 {
633 case INFINITE_MAP:
634 libmesh_error_msg("ERROR: Can't build an infinite element with FEFamily = " << Utility::enum_to_string(fet.radial_family));
635
636 case JACOBI_20_00:
637 {
638 switch (fet.inf_map)
639 {
640 case CARTESIAN:
641 return std::make_unique<InfFE<2,JACOBI_20_00,CARTESIAN>>(fet);
642
643 default:
644 libmesh_error_msg("ERROR: Don't build an infinite element with InfMapType = " << Utility::enum_to_string(fet.inf_map));
645 }
646 }
647
648 case JACOBI_30_00:
649 {
650 switch (fet.inf_map)
651 {
652 case CARTESIAN:
653 return std::make_unique<InfFE<2,JACOBI_30_00,CARTESIAN>>(fet);
654
655 default:
656 libmesh_error_msg("ERROR: Don't build an infinite element with InfMapType = " << Utility::enum_to_string(fet.inf_map));
657 }
658 }
659
660 case LEGENDRE:
661 {
662 switch (fet.inf_map)
663 {
664 case CARTESIAN:
665 return std::make_unique<InfFE<2,LEGENDRE,CARTESIAN>>(fet);
666
667 default:
668 libmesh_error_msg("ERROR: Don't build an infinite element with InfMapType = " << Utility::enum_to_string(fet.inf_map));
669 }
670 }
671
672 case LAGRANGE:
673 {
674 switch (fet.inf_map)
675 {
676 case CARTESIAN:
677 return std::make_unique<InfFE<2,LAGRANGE,CARTESIAN>>(fet);
678
679 default:
680 libmesh_error_msg("ERROR: Don't build an infinite element with InfMapType = " << Utility::enum_to_string(fet.inf_map));
681 }
682 }
683
684 default:
685 libmesh_error_msg("ERROR: Bad FEType.radial_family= " << Utility::enum_to_string(fet.radial_family));
686 }
687 }
688
689
690
691
692 // 3D
693 case 3:
694 {
695 switch (fet.radial_family)
696 {
697 case INFINITE_MAP:
698 libmesh_error_msg("ERROR: Don't build an infinite element with FEFamily = " << Utility::enum_to_string(fet.radial_family));
699
700 case JACOBI_20_00:
701 {
702 switch (fet.inf_map)
703 {
704 case CARTESIAN:
705 return std::make_unique<InfFE<3,JACOBI_20_00,CARTESIAN>>(fet);
706
707 default:
708 libmesh_error_msg("ERROR: Don't build an infinite element with InfMapType = " << Utility::enum_to_string(fet.inf_map));
709 }
710 }
711
712 case JACOBI_30_00:
713 {
714 switch (fet.inf_map)
715 {
716 case CARTESIAN:
717 return std::make_unique<InfFE<3,JACOBI_30_00,CARTESIAN>>(fet);
718
719 default:
720 libmesh_error_msg("ERROR: Don't build an infinite element with InfMapType = " << Utility::enum_to_string(fet.inf_map));
721 }
722 }
723
724 case LEGENDRE:
725 {
726 switch (fet.inf_map)
727 {
728 case CARTESIAN:
729 return std::make_unique<InfFE<3,LEGENDRE,CARTESIAN>>(fet);
730
731 default:
732 libmesh_error_msg("ERROR: Don't build an infinite element with InfMapType = " << Utility::enum_to_string(fet.inf_map));
733 }
734 }
735
736 case LAGRANGE:
737 {
738 switch (fet.inf_map)
739 {
740 case CARTESIAN:
741 return std::make_unique<InfFE<3,LAGRANGE,CARTESIAN>>(fet);
742
743 default:
744 libmesh_error_msg("ERROR: Don't build an infinite element with InfMapType = " << Utility::enum_to_string(fet.inf_map));
745 }
746 }
747
748 default:
749 libmesh_error_msg("ERROR: Bad FEType.radial_family= " << Utility::enum_to_string(fet.radial_family));
750 }
751 }
752
753 default:
754 libmesh_error_msg("Invalid dimension dim = " << dim);
755 }
756}
InfMapType inf_map
The coordinate mapping type of the infinite element.
Definition fe_type.h:284
FEFamily radial_family
The type of approximation in radial direction.
Definition fe_type.h:276

References dim.

◆ build_InfFE() [2/3]

template<typename OutputType >
static std::unique_ptr< FEGenericBase > libMesh::FEGenericBase< OutputType >::build_InfFE ( const unsigned int  dim,
const FEType &  type 
)
static

Builds a specific infinite element type.

A std::unique_ptr<FEGenericBase> is returned to prevent a memory leak. This way the user need not remember to delete the object.

The build call will fail if the OutputShape of this class is not compatible with the output required for the requested type

Referenced by assemble_func(), assemble_SchroedingerEquation(), assemble_wave(), libMesh::FEMContext::cached_fe(), libMesh::InfFE< Dim, T_radial, T_map >::compute_data(), InfFERadialTest::testInfQuants(), InfFERadialTest::testInfQuants_numericDeriv(), InfFERadialTest::testRefinement(), InfFERadialTest::testSides(), and InfFERadialTest::testSingleOrder().

◆ build_InfFE() [3/3]

std::unique_ptr< FEGenericBase< RealGradient > > libMesh::FEGenericBase< RealGradient >::build_InfFE ( const unsigned int  ,
const FEType &   
)

Definition at line 762 of file fe_base.C.

764{
765 // No vector types defined... YET.
766 libmesh_not_implemented();
767 return std::unique_ptr<FEVectorBase>();
768}

◆ calculating_nothing()

template<typename OutputType >
bool libMesh::FEGenericBase< OutputType >::calculating_nothing ( ) const
inlineprotected
Returns
true iff no calculations have been requested of this FE object or of its associated FEMap

Definition at line 606 of file fe_base.h.

607 {
608 return calculate_nothing &&
609 !this->calculate_phi && !this->calculate_dphi &&
610#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
611 !this->calculate_d2phi &&
612#endif
613 !this->calculate_curl_phi && !this->calculate_div_phi &&
614 !this->calculate_map;
615 }
bool calculate_map
Are we calculating mapping functions?
bool calculate_nothing
Are we potentially deliberately calculating nothing?
bool calculate_d2phi
Should we calculate shape function hessians?
bool calculate_phi
Should we calculate shape functions?
bool calculate_dphi
Should we calculate shape function gradients?
bool calculate_curl_phi
Should we calculate shape function curls?
bool calculate_div_phi
Should we calculate shape function divergences?

References libMesh::FEAbstract::calculate_curl_phi, libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_div_phi, libMesh::FEAbstract::calculate_dphi, libMesh::FEAbstract::calculate_map, libMesh::FEAbstract::calculate_nothing, and libMesh::FEAbstract::calculate_phi.

◆ coarsened_dof_values() [1/2]

template<typename OutputType >
void libMesh::FEGenericBase< OutputType >::coarsened_dof_values ( const NumericVector< Number > &  global_vector,
const DofMap &  dof_map,
const Elem *  coarse_elem,
DenseVector< Number > &  coarse_dofs,
const bool  use_old_dof_indices = false 
)
static

Creates a local projection on coarse_elem, based on the DoF values in global_vector for it's children.

Computes a vector of coefficients corresponding to all dof_indices.

Definition at line 1549 of file fe_base.C.

1554{
1555 Ue.resize(0);
1556
1557 for (auto v : make_range(dof_map.n_variables()))
1558 {
1560
1561 coarsened_dof_values(old_vector, dof_map, elem, Usub,
1562 v, use_old_dof_indices);
1563
1564 Ue.append (Usub);
1565 }
1566}
Defines a dense vector for use in Finite Element-type computations.
static void coarsened_dof_values(const NumericVector< Number > &global_vector, const DofMap &dof_map, const Elem *coarse_elem, DenseVector< Number > &coarse_dofs, const unsigned int var, const bool use_old_dof_indices=false)
Creates a local projection on coarse_elem, based on the DoF values in global_vector for it's children...
Definition fe_base.C:1014
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition int_range.h:176

References libMesh::DenseVector< T >::append(), libMesh::make_range(), libMesh::DofMap::n_variables(), and libMesh::DenseVector< T >::resize().

◆ coarsened_dof_values() [2/2]

template<typename OutputType >
void libMesh::FEGenericBase< OutputType >::coarsened_dof_values ( const NumericVector< Number > &  global_vector,
const DofMap &  dof_map,
const Elem *  coarse_elem,
DenseVector< Number > &  coarse_dofs,
const unsigned int  var,
const bool  use_old_dof_indices = false 
)
static

Creates a local projection on coarse_elem, based on the DoF values in global_vector for it's children.

Computes a vector of coefficients corresponding to dof_indices for only the single given var

Definition at line 1014 of file fe_base.C.

1020{
1021 // Side/edge local DOF indices
1022 std::vector<unsigned int> new_side_dofs, old_side_dofs;
1023
1024 // FIXME: what about 2D shells in 3D space?
1025 unsigned int dim = elem->dim();
1026
1027 // Cache n_children(); it's a virtual call but it's const.
1028 const unsigned int n_children = elem->n_children();
1029
1030 // We use local FE objects for now
1031 // FIXME: we should use more, external objects instead for efficiency
1032 const FEType & base_fe_type = dof_map.variable_type(var);
1033 std::unique_ptr<FEGenericBase<OutputShape>> fe
1034 (FEGenericBase<OutputShape>::build(dim, base_fe_type));
1035 std::unique_ptr<FEGenericBase<OutputShape>> fe_coarse
1036 (FEGenericBase<OutputShape>::build(dim, base_fe_type));
1037
1038 std::unique_ptr<QBase> qrule (base_fe_type.default_quadrature_rule(dim));
1039 std::unique_ptr<QBase> qedgerule (base_fe_type.default_quadrature_rule(1));
1040 std::unique_ptr<QBase> qsiderule (base_fe_type.default_quadrature_rule(dim-1));
1041 std::vector<Point> coarse_qpoints;
1042
1043 // The values of the shape functions at the quadrature
1044 // points
1045 const std::vector<std::vector<OutputShape>> & phi_values =
1046 fe->get_phi();
1047 const std::vector<std::vector<OutputShape>> & phi_coarse =
1048 fe_coarse->get_phi();
1049
1050 // The gradients of the shape functions at the quadrature
1051 // points on the child element.
1052 const std::vector<std::vector<OutputGradient>> * dphi_values =
1053 nullptr;
1054 const std::vector<std::vector<OutputGradient>> * dphi_coarse =
1055 nullptr;
1056
1057 const FEContinuity cont = fe->get_continuity();
1058
1059 if (cont == C_ONE)
1060 {
1061 const std::vector<std::vector<OutputGradient>> &
1062 ref_dphi_values = fe->get_dphi();
1063 dphi_values = &ref_dphi_values;
1064 const std::vector<std::vector<OutputGradient>> &
1065 ref_dphi_coarse = fe_coarse->get_dphi();
1066 dphi_coarse = &ref_dphi_coarse;
1067 }
1068
1069 // The Jacobian * quadrature weight at the quadrature points
1070 const std::vector<Real> & JxW =
1071 fe->get_JxW();
1072
1073 // The XYZ locations of the quadrature points on the
1074 // child element
1075 const std::vector<Point> & xyz_values =
1076 fe->get_xyz();
1077
1078 // Number of nodes on parent element
1079 const unsigned int n_nodes = elem->n_nodes();
1080
1081 // Number of dofs on parent element
1082 const unsigned int new_n_dofs =
1083 FEInterface::n_dofs(base_fe_type, elem->max_descendant_p_level(), elem);
1084
1085 // Fixed vs. free DoFs on edge/face projections
1086 std::vector<char> dof_is_fixed(new_n_dofs, false); // bools
1087 std::vector<int> free_dof(new_n_dofs, 0);
1088
1091 Ue.resize(new_n_dofs); Ue.zero();
1092
1093
1094 // When coarsening, in general, we need a series of
1095 // projections to ensure a unique and continuous
1096 // solution. We start by interpolating nodes, then
1097 // hold those fixed and project edges, then
1098 // hold those fixed and project faces, then
1099 // hold those fixed and project interiors
1100
1101 // Copy node values first
1102 {
1103 std::vector<dof_id_type> node_dof_indices;
1104 if (use_old_dof_indices)
1105 dof_map.old_dof_indices (elem, node_dof_indices, var);
1106 else
1107 dof_map.dof_indices (elem, node_dof_indices, var);
1108
1109 unsigned int current_dof = 0;
1110 for (unsigned int n=0; n!= n_nodes; ++n)
1111 {
1112 // FIXME: this should go through the DofMap,
1113 // not duplicate dof_indices code badly!
1114 const unsigned int my_nc =
1115 FEInterface::n_dofs_at_node (base_fe_type, elem->max_descendant_p_level(), elem, n);
1116 if (!elem->is_vertex(n))
1117 {
1118 current_dof += my_nc;
1119 continue;
1120 }
1121
1122 // We're assuming here that child n shares vertex n,
1123 // which is wrong on non-simplices right now
1124 // ... but this code isn't necessary except on elements
1125 // where p refinement creates more vertex dofs; we have
1126 // no such elements yet.
1127 int extra_order = 0;
1128 // if (elem->child_ptr(n)->p_level() < elem->p_level())
1129 // extra_order = elem->child_ptr(n)->p_level();
1130 const unsigned int nc =
1131 FEInterface::n_dofs_at_node (base_fe_type, extra_order, elem, n);
1132 for (unsigned int i=0; i!= nc; ++i)
1133 {
1134 Ue(current_dof) =
1135 old_vector(node_dof_indices[current_dof]);
1136 dof_is_fixed[current_dof] = true;
1137 current_dof++;
1138 }
1139 }
1140 }
1141
1142 FEType fe_type = base_fe_type, temp_fe_type;
1143 fe_type.order = fe_type.order + elem->max_descendant_p_level();
1144
1145 // In 3D, project any edge values next
1146 if (dim > 2 && cont != DISCONTINUOUS)
1147 for (auto e : elem->edge_index_range())
1148 {
1150 e, new_side_dofs);
1151
1152 const unsigned int n_new_side_dofs =
1153 cast_int<unsigned int>(new_side_dofs.size());
1154
1155 // Some edge dofs are on nodes and already
1156 // fixed, others are free to calculate
1157 unsigned int free_dofs = 0;
1158 for (unsigned int i=0; i != n_new_side_dofs; ++i)
1159 if (!dof_is_fixed[new_side_dofs[i]])
1160 free_dof[free_dofs++] = i;
1161 Ke.resize (free_dofs, free_dofs); Ke.zero();
1162 Fe.resize (free_dofs); Fe.zero();
1163 // The new edge coefficients
1164 DenseVector<Number> Uedge(free_dofs);
1165
1166 // Add projection terms from each child sharing
1167 // this edge
1168 for (unsigned int c=0; c != n_children; ++c)
1169 {
1170 if (!elem->is_child_on_edge(c,e))
1171 continue;
1172 const Elem * child = elem->child_ptr(c);
1173
1174 std::vector<dof_id_type> child_dof_indices;
1175 if (use_old_dof_indices)
1176 dof_map.old_dof_indices (child,
1177 child_dof_indices, var);
1178 else
1179 dof_map.dof_indices (child,
1180 child_dof_indices, var);
1181 const unsigned int child_n_dofs =
1182 cast_int<unsigned int>
1183 (child_dof_indices.size());
1184
1185 temp_fe_type = base_fe_type;
1186 temp_fe_type.order = temp_fe_type.order + child->p_level();
1187
1189 temp_fe_type, e, old_side_dofs);
1190
1191 // Initialize both child and parent FE data
1192 // on the child's edge
1193 fe->attach_quadrature_rule (qedgerule.get());
1194 fe->edge_reinit (child, e);
1195 const unsigned int n_qp = qedgerule->n_points();
1196
1197 FEMap::inverse_map (dim, elem, xyz_values,
1198 coarse_qpoints);
1199
1200 fe_coarse->reinit(elem, &coarse_qpoints);
1201
1202 // Loop over the quadrature points
1203 for (unsigned int qp=0; qp<n_qp; qp++)
1204 {
1205 // solution value at the quadrature point
1206 OutputNumber fineval = libMesh::zero;
1207 // solution grad at the quadrature point
1208 OutputNumberGradient finegrad;
1209
1210 // Sum the solution values * the DOF
1211 // values at the quadrature point to
1212 // get the solution value and gradient.
1213 for (unsigned int i=0; i<child_n_dofs;
1214 i++)
1215 {
1216 fineval +=
1217 (old_vector(child_dof_indices[i])*
1218 phi_values[i][qp]);
1219 if (cont == C_ONE)
1220 finegrad += (*dphi_values)[i][qp] *
1221 old_vector(child_dof_indices[i]);
1222 }
1223
1224 // Form edge projection matrix
1225 for (unsigned int sidei=0, freei=0; sidei != n_new_side_dofs; ++sidei)
1226 {
1227 unsigned int i = new_side_dofs[sidei];
1228 // fixed DoFs aren't test functions
1229 if (dof_is_fixed[i])
1230 continue;
1231 for (unsigned int sidej=0, freej=0; sidej != n_new_side_dofs; ++sidej)
1232 {
1233 unsigned int j =
1234 new_side_dofs[sidej];
1235 if (dof_is_fixed[j])
1236 Fe(freei) -=
1237 TensorTools::inner_product(phi_coarse[i][qp],
1238 phi_coarse[j][qp]) *
1239 JxW[qp] * Ue(j);
1240 else
1241 Ke(freei,freej) +=
1242 TensorTools::inner_product(phi_coarse[i][qp],
1243 phi_coarse[j][qp]) *
1244 JxW[qp];
1245 if (cont == C_ONE)
1246 {
1247 if (dof_is_fixed[j])
1248 Fe(freei) -=
1249 TensorTools::inner_product((*dphi_coarse)[i][qp],
1250 (*dphi_coarse)[j][qp]) *
1251 JxW[qp] * Ue(j);
1252 else
1253 Ke(freei,freej) +=
1254 TensorTools::inner_product((*dphi_coarse)[i][qp],
1255 (*dphi_coarse)[j][qp]) *
1256 JxW[qp];
1257 }
1258 if (!dof_is_fixed[j])
1259 freej++;
1260 }
1261 Fe(freei) += TensorTools::inner_product(phi_coarse[i][qp],
1262 fineval) * JxW[qp];
1263 if (cont == C_ONE)
1264 Fe(freei) +=
1265 TensorTools::inner_product(finegrad, (*dphi_coarse)[i][qp]) * JxW[qp];
1266 freei++;
1267 }
1268 }
1269 }
1270 Ke.cholesky_solve(Fe, Uedge);
1271
1272 // Transfer new edge solutions to element
1273 for (unsigned int i=0; i != free_dofs; ++i)
1274 {
1275 Number & ui = Ue(new_side_dofs[free_dof[i]]);
1276 libmesh_assert(std::abs(ui) < TOLERANCE ||
1277 std::abs(ui - Uedge(i)) < TOLERANCE);
1278 ui = Uedge(i);
1279 dof_is_fixed[new_side_dofs[free_dof[i]]] = true;
1280 }
1281 }
1282
1283 // Project any side values (edges in 2D, faces in 3D)
1284 if (dim > 1 && cont != DISCONTINUOUS)
1285 for (auto s : elem->side_index_range())
1286 {
1288 s, new_side_dofs);
1289
1290 const unsigned int n_new_side_dofs =
1291 cast_int<unsigned int>(new_side_dofs.size());
1292
1293 // Some side dofs are on nodes/edges and already
1294 // fixed, others are free to calculate
1295 unsigned int free_dofs = 0;
1296 for (unsigned int i=0; i != n_new_side_dofs; ++i)
1297 if (!dof_is_fixed[new_side_dofs[i]])
1298 free_dof[free_dofs++] = i;
1299 Ke.resize (free_dofs, free_dofs); Ke.zero();
1300 Fe.resize (free_dofs); Fe.zero();
1301 // The new side coefficients
1302 DenseVector<Number> Uside(free_dofs);
1303
1304 // Add projection terms from each child sharing
1305 // this side
1306 for (unsigned int c=0; c != n_children; ++c)
1307 {
1308 if (!elem->is_child_on_side(c,s))
1309 continue;
1310 const Elem * child = elem->child_ptr(c);
1311
1312 std::vector<dof_id_type> child_dof_indices;
1313 if (use_old_dof_indices)
1314 dof_map.old_dof_indices (child,
1315 child_dof_indices, var);
1316 else
1317 dof_map.dof_indices (child,
1318 child_dof_indices, var);
1319 const unsigned int child_n_dofs =
1320 cast_int<unsigned int>
1321 (child_dof_indices.size());
1322
1323 temp_fe_type = base_fe_type;
1324 temp_fe_type.order = temp_fe_type.order + child->p_level();
1325
1327 temp_fe_type, s, old_side_dofs);
1328
1329 // Initialize both child and parent FE data
1330 // on the child's side
1331 fe->attach_quadrature_rule (qsiderule.get());
1332 fe->reinit (child, s);
1333 const unsigned int n_qp = qsiderule->n_points();
1334
1335 FEMap::inverse_map (dim, elem, xyz_values,
1336 coarse_qpoints);
1337
1338 fe_coarse->reinit(elem, &coarse_qpoints);
1339
1340 // Loop over the quadrature points
1341 for (unsigned int qp=0; qp<n_qp; qp++)
1342 {
1343 // solution value at the quadrature point
1344 OutputNumber fineval = libMesh::zero;
1345 // solution grad at the quadrature point
1346 OutputNumberGradient finegrad;
1347
1348 // Sum the solution values * the DOF
1349 // values at the quadrature point to
1350 // get the solution value and gradient.
1351 for (unsigned int i=0; i<child_n_dofs;
1352 i++)
1353 {
1354 fineval +=
1355 old_vector(child_dof_indices[i]) *
1356 phi_values[i][qp];
1357 if (cont == C_ONE)
1358 finegrad += (*dphi_values)[i][qp] *
1359 old_vector(child_dof_indices[i]);
1360 }
1361
1362 // Form side projection matrix
1363 for (unsigned int sidei=0, freei=0; sidei != n_new_side_dofs; ++sidei)
1364 {
1365 unsigned int i = new_side_dofs[sidei];
1366 // fixed DoFs aren't test functions
1367 if (dof_is_fixed[i])
1368 continue;
1369 for (unsigned int sidej=0, freej=0; sidej != n_new_side_dofs; ++sidej)
1370 {
1371 unsigned int j =
1372 new_side_dofs[sidej];
1373 if (dof_is_fixed[j])
1374 Fe(freei) -=
1375 TensorTools::inner_product(phi_coarse[i][qp],
1376 phi_coarse[j][qp]) *
1377 JxW[qp] * Ue(j);
1378 else
1379 Ke(freei,freej) +=
1380 TensorTools::inner_product(phi_coarse[i][qp],
1381 phi_coarse[j][qp]) *
1382 JxW[qp];
1383 if (cont == C_ONE)
1384 {
1385 if (dof_is_fixed[j])
1386 Fe(freei) -=
1387 TensorTools::inner_product((*dphi_coarse)[i][qp],
1388 (*dphi_coarse)[j][qp]) *
1389 JxW[qp] * Ue(j);
1390 else
1391 Ke(freei,freej) +=
1392 TensorTools::inner_product((*dphi_coarse)[i][qp],
1393 (*dphi_coarse)[j][qp]) *
1394 JxW[qp];
1395 }
1396 if (!dof_is_fixed[j])
1397 freej++;
1398 }
1399 Fe(freei) += TensorTools::inner_product(fineval, phi_coarse[i][qp]) * JxW[qp];
1400 if (cont == C_ONE)
1401 Fe(freei) +=
1402 TensorTools::inner_product(finegrad, (*dphi_coarse)[i][qp]) * JxW[qp];
1403 freei++;
1404 }
1405 }
1406 }
1407 Ke.cholesky_solve(Fe, Uside);
1408
1409 // Transfer new side solutions to element
1410 for (unsigned int i=0; i != free_dofs; ++i)
1411 {
1412 Number & ui = Ue(new_side_dofs[free_dof[i]]);
1413 libmesh_assert(std::abs(ui) < TOLERANCE ||
1414 std::abs(ui - Uside(i)) < TOLERANCE);
1415 ui = Uside(i);
1416 dof_is_fixed[new_side_dofs[free_dof[i]]] = true;
1417 }
1418 }
1419
1420 // Project the interior values, finally
1421
1422 // Some interior dofs are on nodes/edges/sides and
1423 // already fixed, others are free to calculate
1424 unsigned int free_dofs = 0;
1425 for (unsigned int i=0; i != new_n_dofs; ++i)
1426 if (!dof_is_fixed[i])
1427 free_dof[free_dofs++] = i;
1428 Ke.resize (free_dofs, free_dofs); Ke.zero();
1429 Fe.resize (free_dofs); Fe.zero();
1430 // The new interior coefficients
1431 DenseVector<Number> Uint(free_dofs);
1432
1433 // Add projection terms from each child
1434 for (auto & child : elem->child_ref_range())
1435 {
1436 std::vector<dof_id_type> child_dof_indices;
1437 if (use_old_dof_indices)
1438 dof_map.old_dof_indices (&child,
1439 child_dof_indices, var);
1440 else
1441 dof_map.dof_indices (&child,
1442 child_dof_indices, var);
1443 const unsigned int child_n_dofs =
1444 cast_int<unsigned int>
1445 (child_dof_indices.size());
1446
1447 // Initialize both child and parent FE data
1448 // on the child's quadrature points
1449 fe->attach_quadrature_rule (qrule.get());
1450 fe->reinit (&child);
1451 const unsigned int n_qp = qrule->n_points();
1452
1453 FEMap::inverse_map (dim, elem, xyz_values, coarse_qpoints);
1454
1455 fe_coarse->reinit(elem, &coarse_qpoints);
1456
1457 // Loop over the quadrature points
1458 for (unsigned int qp=0; qp<n_qp; qp++)
1459 {
1460 // solution value at the quadrature point
1461 OutputNumber fineval = libMesh::zero;
1462 // solution grad at the quadrature point
1463 OutputNumberGradient finegrad;
1464
1465 // Sum the solution values * the DOF
1466 // values at the quadrature point to
1467 // get the solution value and gradient.
1468 for (unsigned int i=0; i<child_n_dofs; i++)
1469 {
1470 fineval +=
1471 (old_vector(child_dof_indices[i]) *
1472 phi_values[i][qp]);
1473 if (cont == C_ONE)
1474 finegrad += (*dphi_values)[i][qp] *
1475 old_vector(child_dof_indices[i]);
1476 }
1477
1478 // Form interior projection matrix
1479 for (unsigned int i=0, freei=0;
1480 i != new_n_dofs; ++i)
1481 {
1482 // fixed DoFs aren't test functions
1483 if (dof_is_fixed[i])
1484 continue;
1485 for (unsigned int j=0, freej=0; j !=
1486 new_n_dofs; ++j)
1487 {
1488 if (dof_is_fixed[j])
1489 Fe(freei) -=
1490 TensorTools::inner_product(phi_coarse[i][qp],
1491 phi_coarse[j][qp]) *
1492 JxW[qp] * Ue(j);
1493 else
1494 Ke(freei,freej) +=
1495 TensorTools::inner_product(phi_coarse[i][qp],
1496 phi_coarse[j][qp]) *
1497 JxW[qp];
1498 if (cont == C_ONE)
1499 {
1500 if (dof_is_fixed[j])
1501 Fe(freei) -=
1502 TensorTools::inner_product((*dphi_coarse)[i][qp],
1503 (*dphi_coarse)[j][qp]) *
1504 JxW[qp] * Ue(j);
1505 else
1506 Ke(freei,freej) +=
1507 TensorTools::inner_product((*dphi_coarse)[i][qp],
1508 (*dphi_coarse)[j][qp]) *
1509 JxW[qp];
1510 }
1511 if (!dof_is_fixed[j])
1512 freej++;
1513 }
1514 Fe(freei) += TensorTools::inner_product(phi_coarse[i][qp], fineval) *
1515 JxW[qp];
1516 if (cont == C_ONE)
1517 Fe(freei) += TensorTools::inner_product(finegrad, (*dphi_coarse)[i][qp]) * JxW[qp];
1518 freei++;
1519 }
1520 }
1521 }
1522 Ke.cholesky_solve(Fe, Uint);
1523
1524 // Transfer new interior solutions to element
1525 for (unsigned int i=0; i != free_dofs; ++i)
1526 {
1527 Number & ui = Ue(free_dof[i]);
1528 libmesh_assert(std::abs(ui) < TOLERANCE ||
1529 std::abs(ui - Uint(i)) < TOLERANCE);
1530 ui = Uint(i);
1531 // We should be fixing all dofs by now; no need to keep track of
1532 // that unless we're debugging
1533#ifndef NDEBUG
1534 dof_is_fixed[free_dof[i]] = true;
1535#endif
1536 }
1537
1538#ifndef NDEBUG
1539 // Make sure every DoF got reached!
1540 for (unsigned int i=0; i != new_n_dofs; ++i)
1541 libmesh_assert(dof_is_fixed[i]);
1542#endif
1543}
Defines a dense matrix for use in Finite Element-type computations.
void cholesky_solve(const DenseVector< T2 > &b, DenseVector< T2 > &x)
For symmetric positive definite (SPD) matrices.
void resize(const unsigned int new_m, const unsigned int new_n)
Resizes the matrix to the specified size and calls zero().
virtual void zero() override final
Sets all elements of the matrix to 0 and resets any decomposition flag which may have been previously...
void resize(const unsigned int n)
Resize the vector.
virtual void zero() override final
Set every element in the vector to 0.
void dof_indices(const Elem *const elem, std::vector< dof_id_type > &di) const
Definition dof_map.C:2203
const FEType & variable_type(const unsigned int i) const
Definition dof_map.h:2401
void old_dof_indices(const Elem &elem, unsigned int n, std::vector< dof_id_type > &di, const unsigned int vn) const
Appends to the vector di the old global degree of freedom indices for elem.node_ref(n),...
Definition dof_map.C:2480
This is the base class from which all geometric element types are derived.
Definition elem.h:96
const Elem * child_ptr(unsigned int i) const
Definition elem.h:3301
unsigned int p_level() const
Definition elem.h:3246
FEType fe_type
The finite element type for this object.
QBase * qrule
A pointer to the quadrature rule employed.
This class forms the foundation from which generic finite elements may be derived.
Definition fe_base.h:86
TensorTools::IncrementRank< OutputNumber >::type OutputNumberGradient
Definition fe_base.h:124
TensorTools::MakeNumber< OutputShape >::type OutputNumber
Definition fe_base.h:123
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, const bool add_p_level=true)
Fills the vector di with the local degree of freedom indices associated with side s of element elem A...
static unsigned int n_dofs(const unsigned int dim, const FEType &fe_t, const ElemType t)
static unsigned int n_dofs_at_node(const unsigned int dim, const FEType &fe_t, const ElemType t, const unsigned int n)
static void dofs_on_edge(const Elem *const elem, const unsigned int dim, const FEType &fe_t, unsigned int e, std::vector< unsigned int > &di, const bool add_p_level=true)
Fills the vector di with the local degree of freedom indices associated with edge e of element elem A...
static Point inverse_map(const unsigned int dim, const Elem *elem, const Point &p, const Real tolerance=TOLERANCE, const bool secure=true, const bool extra_checks=true)
Definition fe_map.C:1512
class FEType hides (possibly multiple) FEFamily and approximation orders, thereby enabling specialize...
Definition fe_type.h:197
std::unique_ptr< QBase > default_quadrature_rule(const unsigned int dim, const int extraorder=0) const
Definition fe_type.C:35
OrderWrapper order
The approximation order of the element (at 0 p-refinement level).
Definition fe_type.h:203
unsigned int n_points() const
Definition quadrature.h:131
LIBMESH_DEVICE_INLINE std::enable_if< ScalarTraits< T >::value &&ScalarTraits< T2 >::value, typenameCompareTypes< T, T2 >::supertype >::type inner_product(const T &a, const T2 &b)
libmesh_assert(ctx)
const Number zero
.
Definition libmesh.h:297
static constexpr Real TOLERANCE
const dof_id_type n_nodes
Definition tecplot_io.C:67

References libMesh::C_ONE, libMesh::Elem::child_ptr(), libMesh::Elem::child_ref_range(), libMesh::DenseMatrix< T >::cholesky_solve(), libMesh::FEType::default_quadrature_rule(), dim, libMesh::Elem::dim(), libMesh::DISCONTINUOUS, libMesh::DofMap::dof_indices(), libMesh::FEInterface::dofs_on_edge(), libMesh::FEInterface::dofs_on_side(), libMesh::Elem::edge_index_range(), libMesh::TensorTools::inner_product(), libMesh::FEMap::inverse_map(), libMesh::Elem::is_child_on_edge(), libMesh::Elem::is_child_on_side(), libMesh::Elem::is_vertex(), libMesh::libmesh_assert(), libMesh::Elem::max_descendant_p_level(), libMesh::Elem::n_children(), libMesh::FEInterface::n_dofs(), libMesh::FEInterface::n_dofs_at_node(), libMesh::Elem::n_nodes(), n_nodes, libMesh::DofMap::old_dof_indices(), libMesh::FEType::order, libMesh::Elem::p_level(), libMesh::DenseVector< T >::resize(), libMesh::DenseMatrix< T >::resize(), libMesh::Elem::side_index_range(), libMesh::TOLERANCE, libMesh::DofMap::variable_type(), libMesh::zero, libMesh::DenseMatrix< T >::zero(), and libMesh::DenseVector< T >::zero().

Referenced by libMesh::ExactErrorEstimator::estimate_error(), and libMesh::JumpErrorEstimator::estimate_error().

◆ compute_dual_shape_coeffs() [1/3]

void libMesh::FEGenericBase< Real >::compute_dual_shape_coeffs ( const std::vector< Real > &  ,
const std::vector< std::vector< OutputShape > > &   
)
protected

◆ compute_dual_shape_coeffs() [2/3]

template<typename OutputType >
void libMesh::FEGenericBase< OutputType >::compute_dual_shape_coeffs ( const std::vector< Real > &  JxW,
const std::vector< std::vector< OutputShape > > &  phi 
)
protected

Compute the dual basis coefficients dual_coeff we rely on the JxW (or weights) and the phi values, which can come from default or customized qrule.

Definition at line 838 of file fe_base.h.

839{
840 libmesh_error_msg(
841 "Computation of dual shape functions for vector finite element "
842 "families is not currently implemented");
843}

◆ compute_dual_shape_coeffs() [3/3]

void libMesh::FEGenericBase< Real >::compute_dual_shape_coeffs ( const std::vector< Real > &  JxW,
const std::vector< std::vector< OutputShape > > &  phi_vals 
)
protected

Definition at line 816 of file fe_base.C.

817{
818 // Start logging the dual coeff computation
819 LOG_SCOPE("compute_dual_shape_coeffs()", "FE");
820
821 const unsigned int sz=phi_vals.size();
822 libmesh_error_msg_if(!sz, "ERROR: cannot compute dual shape coefficients with empty phi values");
823
824 //compute dual basis coefficient (dual_coeff)
825 dual_coeff.resize(sz, sz);
826 DenseMatrix<Real> A(sz, sz), D(sz, sz);
827
828 for (const auto i : index_range(phi_vals))
829 for (const auto qp : index_range(phi_vals[i]))
830 {
831 D(i,i) += JxW[qp]*phi_vals[i][qp];
832 for (const auto j : index_range(phi_vals))
833 A(i,j) += JxW[qp]*phi_vals[i][qp]*phi_vals[j][qp];
834 }
835
836 // The integral positivity condition on the dual basis (Popp, Wohlmuth, Gee and Wall, SIAM J. Sci.
837 // Comput. 34(4):B421-B446, 2012, Eq. (4.2)) fails on QUAD8 and TRI6: D(k,k) = \int N_k is -1/3 at a
838 // QUAD8 corner and exactly 0 at a TRI6 vertex (their Eqs. (4.3) and (4.4)), the latter leaving those
839 // dual shape functions identically zero. Biorthogonalize instead against the locally quadratic
840 // transformed basis Ntilde = T N of their Sec. 4.4.1, in which each vertex absorbs a fraction alpha
841 // of its adjacent mid-edge shapes. That replaces D by T^-1 diag(T d), which for this T is the sparse
842 // update below. alpha = 1/5 is recommended there, and makes the weights strictly positive (QUAD8
843 // 1/5 and 4/5, TRI6 1/15 and 1/10) while preserving the partition of unity. T = I elsewhere.
844 // SECOND order on TRI7 is the TRI6 basis, with no degree of freedom at the centroid node, and
845 // L2_LAGRANGE shares the LAGRANGE shape functions.
846 if (_elem && (get_family() == LAGRANGE || get_family() == L2_LAGRANGE) &&
847 (((_elem->type() == TRI6 || _elem->type() == TRI7) && sz == 6) ||
848 (_elem->type() == QUAD8 && sz == 8)))
849 {
850 const Real alpha = Real(1)/5;
851 // Mid-edge nodes are the trailing indices, and only vertex entries are written, so D(m,m) here
852 // is never a value an earlier iteration modified.
853 for (const auto m : make_range(_elem->n_vertices(), sz))
854 for (const auto v : make_range(_elem->n_second_order_adjacent_vertices(m)))
855 {
856 const auto vertex = _elem->second_order_adjacent_vertex(m, v);
857 D(vertex, vertex) += alpha*D(m,m);
858 D(vertex, m) -= alpha*D(m,m);
859 }
860 }
861
862 // dual_coeff = A^-1*D
863 for (const auto j : index_range(phi_vals))
864 {
865 DenseVector<Real> Dcol(sz), coeffcol(sz);
866 for (const auto i : index_range(phi_vals))
867 Dcol(i) = D(i, j);
868 A.cholesky_solve(Dcol, coeffcol);
869
870 for (const auto row : index_range(phi_vals))
871 dual_coeff(row, j)=coeffcol(row);
872 }
873}
virtual ElemType type() const =0
virtual unsigned short int second_order_adjacent_vertex(const unsigned int n, const unsigned int v) const
Definition elem.C:3183
const Elem * _elem
The element the current data structures were set up for.
FEFamily get_family() const
DenseMatrix< Real > dual_coeff
Coefficient matrix for the dual basis.
Definition fe_base.h:664
LIBMESH_DEVICE_INLINE ResultVector row(const TensorLike &T_in, const unsigned int row_index)
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition int_range.h:153
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

References libMesh::index_range(), libMesh::L2_LAGRANGE, libMesh::LAGRANGE, libMesh::make_range(), libMesh::QUAD8, libMesh::Real, libMesh::TRI6, and libMesh::TRI7.

◆ compute_dual_shape_functions() [1/3]

template<typename OutputType >
void libMesh::FEGenericBase< OutputType >::compute_dual_shape_functions ( )
protected

Compute dual_phi, dual_dphi, dual_d2phi It is only valid for this to be called after reinit has occurred with a quadrature rule.

Definition at line 830 of file fe_base.h.

831{
832 libmesh_error_msg(
833 "Computation of dual shape functions for vector finite element "
834 "families is not currently implemented");
835}

◆ compute_dual_shape_functions() [2/3]

void libMesh::FEGenericBase< Real >::compute_dual_shape_functions ( )
protected

◆ compute_dual_shape_functions() [3/3]

void libMesh::FEGenericBase< Real >::compute_dual_shape_functions ( )
protected

Definition at line 876 of file fe_base.C.

877{
878 // Start logging the shape function computation
879 LOG_SCOPE("compute_dual_shape_functions()", "FE");
880
881 // The dual coeffs matrix should have the same size as phi
882 libmesh_assert(dual_coeff.m() == phi.size());
883 libmesh_assert(dual_coeff.n() == phi.size());
884
885 // initialize dual basis
886 for (const auto j : index_range(phi))
887 for (const auto qp : index_range(phi[j]))
888 {
889 dual_phi[j][qp] = 0;
890 if (calculate_dphi)
891 dual_dphi[j][qp] = 0;
892#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
893 if (calculate_d2phi)
894 dual_d2phi[j][qp] = 0;
895#endif
896 }
897
898 // compute dual basis
899 for (const auto j : index_range(phi))
900 for (const auto i : index_range(phi))
901 for (const auto qp : index_range(phi[j]))
902 {
903 dual_phi[j][qp] += dual_coeff(i, j) * phi[i][qp];
904 if (calculate_dphi)
905 dual_dphi[j][qp] += dual_coeff(i, j) * dphi[i][qp];
906#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
907 if (calculate_d2phi)
908 dual_d2phi[j][qp] += dual_coeff(i, j) * d2phi[i][qp];
909#endif
910 }
911}

References libMesh::index_range(), and libMesh::libmesh_assert().

◆ compute_node_constraints()

void libMesh::FEAbstract::compute_node_constraints ( NodeConstraints &  constraints,
const Elem *  elem 
)
staticinherited

Computes the nodal constraint contributions (for non-conforming adapted meshes), using Lagrange geometry.

Definition at line 898 of file fe_abstract.C.

900{
901 libmesh_assert(elem);
902
903 const unsigned int Dim = elem->dim();
904
905 // Only constrain elements in 2,3D.
906 if (Dim == 1)
907 return;
908
909 // Only constrain active and ancestor elements
910 if (elem->subactive())
911 return;
912
913
914#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
915 if (elem->infinite())
916 {
917 const FEType fe_t(elem->default_order(), FEMap::map_fe_type(*elem));
918
919 // expand the infinite_compute_constraint in its template-arguments.
920 switch(Dim)
921 {
922 case 2:
923 {
924 inf_fe_family_mapping_switch(2, inf_compute_node_constraints (constraints, elem) , ,; break;);
925 break;
926 }
927 case 3:
928 {
929 inf_fe_family_mapping_switch(3, inf_compute_node_constraints (constraints, elem) , ,; break;);
930 break;
931 }
932 default:
933 libmesh_error_msg("Invalid dim = " << Dim);
934 }
935 return;
936 }
937
938#endif
939 const FEFamily mapping_family = FEMap::map_fe_type(*elem);
940 const FEType fe_type(elem->default_side_order(), mapping_family);
941
942 // Pull objects out of the loop to reduce heap operations
943 std::vector<const Node *> my_nodes, parent_nodes;
944 std::unique_ptr<const Elem> my_side, parent_side;
945
946 // Look at the element faces. Check to see if we need to
947 // build constraints.
948 for (auto s : elem->side_index_range())
949 if (elem->neighbor_ptr(s) != nullptr &&
950 elem->neighbor_ptr(s) != remote_elem)
951 if (elem->neighbor_ptr(s)->level() < elem->level()) // constrain dofs shared between
952 { // this element and ones coarser
953 // than this element.
954 // Get pointers to the elements of interest and its parent.
955 const Elem * parent = elem->parent();
956
957 // This can't happen... Only level-0 elements have nullptr
958 // parents, and no level-0 elements can be at a higher
959 // level than their neighbors!
960 libmesh_assert(parent);
961
962 elem->build_side_ptr(my_side, s);
963 parent->build_side_ptr(parent_side, s);
964
965 const unsigned int n_side_nodes = my_side->n_nodes();
966
967 my_nodes.clear();
968 my_nodes.reserve (n_side_nodes);
969 parent_nodes.clear();
970 parent_nodes.reserve (n_side_nodes);
971
972 for (unsigned int n=0; n != n_side_nodes; ++n)
973 my_nodes.push_back(my_side->node_ptr(n));
974
975 for (unsigned int n=0; n != n_side_nodes; ++n)
976 parent_nodes.push_back(parent_side->node_ptr(n));
977
978 for (unsigned int my_side_n=0;
979 my_side_n < n_side_nodes;
980 my_side_n++)
981 {
982 // We can have an FE type that supports an order
983 // partially, such that sides do not support the same
984 // order. E.g. we say that a LAGRANGE PRISM21 supports
985 // "third" order to distinguish its shape functions from
986 // a PRISM18, but the QUAD9 sides will still only
987 // support second order.
988 FEType side_fe_type = fe_type;
989 const int side_max_order =
990 FEInterface::max_order(fe_type, my_side->type());
991
992 if ((int)fe_type.order > side_max_order)
993 side_fe_type.order = side_max_order;
994
995 // Do not use the p_level(), if any, that is inherited by the side.
996 libmesh_assert_less
997 (my_side_n,
998 FEInterface::n_dofs(side_fe_type, /*extra_order=*/0,
999 my_side.get()));
1000
1001 const Node * my_node = my_nodes[my_side_n];
1002
1003 // The support point of the DOF
1004 const Point & support_point = *my_node;
1005
1006 // Figure out where my node lies on their reference element.
1007 const Point mapped_point = FEMap::inverse_map(Dim-1,
1008 parent_side.get(),
1009 support_point);
1010
1011 // Compute the parent's side shape function values.
1012 for (unsigned int their_side_n=0;
1013 their_side_n < n_side_nodes;
1014 their_side_n++)
1015 {
1016 // Do not use the p_level(), if any, that is inherited by the side.
1017 libmesh_assert_less
1018 (their_side_n,
1019 FEInterface::n_dofs(side_fe_type,
1020 /*extra_order=*/0,
1021 parent_side.get()));
1022
1023 const Node * their_node = parent_nodes[their_side_n];
1024 libmesh_assert(their_node);
1025
1026 // Do not use the p_level(), if any, that is inherited by the side.
1027 const Real their_value = FEInterface::shape(side_fe_type,
1028 /*extra_order=*/0,
1029 parent_side.get(),
1030 their_side_n,
1031 mapped_point);
1032
1033 const Real their_mag = std::abs(their_value);
1034#ifdef DEBUG
1035 // Protect for the case u_i ~= u_j,
1036 // in which case i better equal j.
1037 if (their_mag > 0.999)
1038 {
1039 libmesh_assert_equal_to (my_node, their_node);
1040 libmesh_assert_less (std::abs(their_value - 1.), 0.001);
1041 }
1042 else
1043#endif
1044 // To make nodal constraints useful for constructing
1045 // sparsity patterns faster, we need to get EVERY
1046 // POSSIBLE constraint coupling identified, even if
1047 // there is no coupling in the isoparametric
1048 // Lagrange case.
1049 if (their_mag < 1.e-5)
1050 {
1051 // since we may be running this method concurrently
1052 // on multiple threads we need to acquire a lock
1053 // before modifying the shared constraint_row object.
1054 Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
1055
1056 // A reference to the constraint row.
1057 NodeConstraintRow & constraint_row = constraints[my_node].first;
1058
1059 constraint_row.emplace(their_node, 0.);
1060 }
1061 // To get nodal coordinate constraints right, only
1062 // add non-zero and non-identity values for Lagrange
1063 // basis functions.
1064 else // (1.e-5 <= their_mag <= .999)
1065 {
1066 // since we may be running this method concurrently
1067 // on multiple threads we need to acquire a lock
1068 // before modifying the shared constraint_row object.
1069 Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
1070
1071 // A reference to the constraint row.
1072 NodeConstraintRow & constraint_row = constraints[my_node].first;
1073
1074 constraint_row.emplace(their_node, their_value);
1075 }
1076 }
1077 }
1078 }
1079}
static Real shape(const unsigned int dim, const FEType &fe_t, const ElemType t, const unsigned int i, const Point &p)
static unsigned int max_order(const FEType &fe_t, const ElemType &el_t)
static FEFamily map_fe_type(const Elem &elem)
Definition fe_map.C:46
spin_mutex spin_mtx
A convenient spin mutex object which can be used for obtaining locks.
Definition threads.C:30
std::map< const Node *, Real, std::less< const Node * >, Threads::scalable_allocator< std::pair< const Node *const, Real > > > NodeConstraintRow
A row of the Node constraint mapping.
Definition dof_map.h:148
const RemoteElem * remote_elem
Definition remote_elem.C:57

References libMesh::Elem::build_side_ptr(), libMesh::Elem::default_order(), libMesh::Elem::default_side_order(), libMesh::Elem::dim(), libMesh::FEAbstract::fe_type, libMesh::Elem::infinite(), libMesh::FEMap::inverse_map(), libMesh::Elem::level(), libMesh::libmesh_assert(), libMesh::FEMap::map_fe_type(), libMesh::FEInterface::max_order(), libMesh::FEInterface::n_dofs(), libMesh::Elem::neighbor_ptr(), libMesh::FEType::order, libMesh::Elem::parent(), libMesh::Real, libMesh::remote_elem, libMesh::FEInterface::shape(), libMesh::Elem::side_index_range(), libMesh::Threads::spin_mtx, and libMesh::Elem::subactive().

◆ compute_periodic_constraints()

template<typename OutputType >
void libMesh::FEGenericBase< OutputType >::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 meshes with periodic boundary conditions) corresponding to variable number var_number, using generic projections.

Definition at line 1879 of file fe_base.C.

1887{
1888 // Only bother if we truly have periodic boundaries
1889 if (boundaries.empty())
1890 return;
1891
1892 libmesh_assert(elem);
1893
1894 // Only constrain active elements with this method
1895 if (!elem->active())
1896 return;
1897
1898 if (elem->infinite())
1899 libmesh_not_implemented();
1900
1901 const unsigned int Dim = elem->dim();
1902
1903 // We need sys_number and variable_number for DofObject methods
1904 // later
1905 const unsigned int sys_number = dof_map.sys_number();
1906
1907 const FEType & base_fe_type = dof_map.variable_type(variable_number);
1908
1909 // Construct FE objects for this element and its pseudo-neighbors.
1910 std::unique_ptr<FEGenericBase<OutputShape>> my_fe
1911 (FEGenericBase<OutputShape>::build(Dim, base_fe_type));
1912 const FEContinuity cont = my_fe->get_continuity();
1913
1914 // We don't need to constrain discontinuous elements
1915 if (cont == DISCONTINUOUS)
1916 return;
1917 libmesh_assert (cont == C_ZERO || cont == C_ONE);
1918
1919 // We'll use element size to generate relative tolerances later
1920 const Real primary_hmin = elem->hmin();
1921
1922 std::unique_ptr<FEGenericBase<OutputShape>> neigh_fe
1923 (FEGenericBase<OutputShape>::build(Dim, base_fe_type));
1924
1925 QGauss my_qface(Dim-1, base_fe_type.default_quadrature_order());
1926 my_fe->attach_quadrature_rule (&my_qface);
1927 std::vector<Point> neigh_qface;
1928
1929 const std::vector<Real> & JxW = my_fe->get_JxW();
1930 const std::vector<Point> & q_point = my_fe->get_xyz();
1931 const std::vector<std::vector<OutputShape>> & phi = my_fe->get_phi();
1932 const std::vector<std::vector<OutputShape>> & neigh_phi =
1933 neigh_fe->get_phi();
1934 const std::vector<Point> * face_normals = nullptr;
1935 const std::vector<std::vector<OutputGradient>> * dphi = nullptr;
1936 const std::vector<std::vector<OutputGradient>> * neigh_dphi = nullptr;
1937 std::vector<dof_id_type> my_dof_indices, neigh_dof_indices;
1938 std::vector<unsigned int> my_side_dofs, neigh_side_dofs;
1939
1940 if (cont != C_ZERO)
1941 {
1942 const std::vector<Point> & ref_face_normals =
1943 my_fe->get_normals();
1944 face_normals = &ref_face_normals;
1945 const std::vector<std::vector<OutputGradient>> & ref_dphi =
1946 my_fe->get_dphi();
1947 dphi = &ref_dphi;
1948 const std::vector<std::vector<OutputGradient>> & ref_neigh_dphi =
1949 neigh_fe->get_dphi();
1950 neigh_dphi = &ref_neigh_dphi;
1951 }
1952
1955 std::vector<DenseVector<Real>> Ue;
1956
1957 // Container to catch the boundary ids that BoundaryInfo hands us.
1958 std::vector<boundary_id_type> bc_ids;
1959
1960 // Look at the element faces. Check to see if we need to
1961 // build constraints.
1962 const unsigned short int max_ns = elem->n_sides();
1963 for (unsigned short int s = 0; s != max_ns; ++s)
1964 {
1965 if (elem->neighbor_ptr(s))
1966 continue;
1967
1968 mesh.get_boundary_info().boundary_ids (elem, s, bc_ids);
1969
1970 for (const auto & boundary_id : bc_ids)
1971 {
1972 const PeriodicBoundaryBase * periodic = boundaries.boundary(boundary_id);
1973 if (!periodic || !periodic->is_my_variable(variable_number))
1974 continue;
1975
1976 libmesh_assert(point_locator);
1977
1978 // Get pointers to the element's neighbor.
1979 unsigned int s_neigh;
1980 const Elem * neigh = boundaries.neighbor(boundary_id, *point_locator, elem, s, &s_neigh);
1981
1982 libmesh_error_msg_if(neigh == nullptr,
1983 "PeriodicBoundaries point locator object returned nullptr!");
1984
1985 // periodic (and possibly h refinement) constraints:
1986 // constrain dofs shared between
1987 // this element and ones as coarse
1988 // as or coarser than this element.
1989 if (neigh->level() <= elem->level())
1990 {
1991#ifdef LIBMESH_ENABLE_AMR
1992 // Find the minimum p level; we build the h constraint
1993 // matrix with this and then constrain away all higher p
1994 // DoFs.
1995 libmesh_assert(neigh->active());
1996 const unsigned int min_p_level =
1997 std::min(elem->p_level(), neigh->p_level());
1998
1999 // we may need to make the FE objects reinit with the
2000 // minimum shared p_level
2001 // FIXME - I hate using const_cast<> and avoiding
2002 // accessor functions; there's got to be a
2003 // better way to do this!
2004 const unsigned int old_elem_level = elem->p_level();
2005 if (old_elem_level != min_p_level)
2006 (const_cast<Elem *>(elem))->hack_p_level(min_p_level);
2007 const unsigned int old_neigh_level = neigh->p_level();
2008 if (old_neigh_level != min_p_level)
2009 (const_cast<Elem *>(neigh))->hack_p_level(min_p_level);
2010#endif // #ifdef LIBMESH_ENABLE_AMR
2011
2012 // We can do a projection with a single integration,
2013 // due to the assumption of nested finite element
2014 // subspaces.
2015 // FIXME: it might be more efficient to do nodes,
2016 // then edges, then side, to reduce the size of the
2017 // Cholesky factorization(s)
2018 my_fe->reinit(elem, s);
2019
2020 dof_map.dof_indices (elem, my_dof_indices,
2021 variable_number);
2022 dof_map.dof_indices (neigh, neigh_dof_indices,
2023 variable_number);
2024
2025 // We use neigh_dof_indices_all_variables in the case that the
2026 // periodic boundary condition involves mappings between multiple
2027 // variables.
2028 std::vector<std::vector<dof_id_type>> neigh_dof_indices_all_variables;
2029 if(periodic->has_transformation_matrix())
2030 {
2031 const std::set<unsigned int> & variables = periodic->get_variables();
2032 neigh_dof_indices_all_variables.resize(variables.size());
2033 unsigned int index = 0;
2034 for(unsigned int var : variables)
2035 {
2036 dof_map.dof_indices (neigh, neigh_dof_indices_all_variables[index],
2037 var);
2038 index++;
2039 }
2040 }
2041
2042 const unsigned int n_qp = my_qface.n_points();
2043
2044 // Translate the quadrature points over to the
2045 // neighbor's boundary
2046 std::vector<Point> neigh_point(q_point.size());
2047 for (auto i : index_range(neigh_point))
2048 neigh_point[i] = periodic->get_corresponding_pos(q_point[i]);
2049
2050 FEMap::inverse_map (Dim, neigh, neigh_point,
2051 neigh_qface);
2052
2053 neigh_fe->reinit(neigh, &neigh_qface);
2054
2055 // We're only concerned with DOFs whose values (and/or first
2056 // derivatives for C1 elements) are supported on side nodes
2057 FEInterface::dofs_on_side(elem, Dim, base_fe_type, s, my_side_dofs);
2058 FEInterface::dofs_on_side(neigh, Dim, base_fe_type, s_neigh, neigh_side_dofs);
2059
2060 // We're done with functions that examine Elem::p_level(),
2061 // so let's unhack those levels
2062#ifdef LIBMESH_ENABLE_AMR
2063 if (elem->p_level() != old_elem_level)
2064 (const_cast<Elem *>(elem))->hack_p_level(old_elem_level);
2065 if (neigh->p_level() != old_neigh_level)
2066 (const_cast<Elem *>(neigh))->hack_p_level(old_neigh_level);
2067#endif // #ifdef LIBMESH_ENABLE_AMR
2068
2069 const unsigned int n_side_dofs =
2070 cast_int<unsigned int>
2071 (my_side_dofs.size());
2072 libmesh_assert_equal_to (n_side_dofs, neigh_side_dofs.size());
2073
2074 Ke.resize (n_side_dofs, n_side_dofs);
2075 Ue.resize(n_side_dofs);
2076
2077 // Form the projection matrix, (inner product of fine basis
2078 // functions against fine test functions)
2079 for (unsigned int is = 0; is != n_side_dofs; ++is)
2080 {
2081 const unsigned int i = my_side_dofs[is];
2082 for (unsigned int js = 0; js != n_side_dofs; ++js)
2083 {
2084 const unsigned int j = my_side_dofs[js];
2085 for (unsigned int qp = 0; qp != n_qp; ++qp)
2086 {
2087 Ke(is,js) += JxW[qp] *
2089 phi[j][qp]);
2090 if (cont != C_ZERO)
2091 Ke(is,js) += JxW[qp] *
2093 (*face_normals)[qp],
2094 (*dphi)[j][qp] *
2095 (*face_normals)[qp]);
2096 }
2097 }
2098 }
2099
2100 // Form the right hand sides, (inner product of coarse basis
2101 // functions against fine test functions)
2102 for (unsigned int is = 0; is != n_side_dofs; ++is)
2103 {
2104 const unsigned int i = neigh_side_dofs[is];
2105 Fe.resize (n_side_dofs);
2106 for (unsigned int js = 0; js != n_side_dofs; ++js)
2107 {
2108 const unsigned int j = my_side_dofs[js];
2109 for (unsigned int qp = 0; qp != n_qp; ++qp)
2110 {
2111 Fe(js) += JxW[qp] *
2112 TensorTools::inner_product(neigh_phi[i][qp],
2113 phi[j][qp]);
2114 if (cont != C_ZERO)
2115 Fe(js) += JxW[qp] *
2116 TensorTools::inner_product((*neigh_dphi)[i][qp] *
2117 (*face_normals)[qp],
2118 (*dphi)[j][qp] *
2119 (*face_normals)[qp]);
2120 }
2121 }
2122 Ke.cholesky_solve(Fe, Ue[is]);
2123 }
2124
2125 // Make sure we're not adding recursive constraints
2126 // due to the redundancy in the way we add periodic
2127 // boundary constraints
2128 //
2129 // In order for this to work while threaded or on
2130 // distributed meshes, we need a rigorous way to
2131 // avoid recursive constraints. Here it is:
2132 //
2133 // For vertex DoFs, if there is a "prior" element
2134 // (i.e. a coarser element or an equally refined
2135 // element with a lower id) on this boundary which
2136 // contains the vertex point, then we will avoid
2137 // generating constraints; the prior element (or
2138 // something prior to it) may do so. If we are the
2139 // most prior (or "primary") element on this
2140 // boundary sharing this point, then we look at the
2141 // boundary periodic to us, we find the primary
2142 // element there, and if that primary is coarser or
2143 // equal-but-lower-id, then our vertex dofs are
2144 // constrained in terms of that element.
2145 //
2146 // For edge DoFs, if there is a coarser element
2147 // on this boundary sharing this edge, then we will
2148 // avoid generating constraints (we will be
2149 // constrained indirectly via AMR constraints
2150 // connecting us to the coarser element's DoFs). If
2151 // we are the coarsest element sharing this edge,
2152 // then we generate constraints if and only if we
2153 // are finer than the coarsest element on the
2154 // boundary periodic to us sharing the corresponding
2155 // periodic edge, or if we are at equal level but
2156 // our edge nodes have higher ids than the periodic
2157 // edge nodes (sorted from highest to lowest, then
2158 // compared lexicographically)
2159 //
2160 // For face DoFs, we generate constraints if we are
2161 // finer than our periodic neighbor, or if we are at
2162 // equal level but our element id is higher than its
2163 // element id.
2164 //
2165 // If the primary neighbor is also the current elem
2166 // (a 1-element-thick mesh) then we choose which
2167 // vertex dofs to constrain via lexicographic
2168 // ordering on point locations
2169
2170 // FIXME: This code doesn't yet properly handle
2171 // cases where multiple different periodic BCs
2172 // intersect.
2173 std::set<dof_id_type> my_constrained_dofs;
2174
2175 // Container to catch boundary IDs handed back by BoundaryInfo.
2176 std::vector<boundary_id_type> new_bc_ids;
2177
2178 for (auto n : elem->node_index_range())
2179 {
2180 if (!elem->is_node_on_side(n,s))
2181 continue;
2182
2183 const Node & my_node = elem->node_ref(n);
2184
2185 if (elem->is_vertex(n))
2186 {
2187 // Find all boundary ids that include this
2188 // point and have periodic boundary
2189 // conditions for this variable
2190 std::set<boundary_id_type> point_bcids;
2191
2192 for (unsigned int new_s = 0;
2193 new_s != max_ns; ++new_s)
2194 {
2195 if (!elem->is_node_on_side(n,new_s))
2196 continue;
2197
2198 mesh.get_boundary_info().boundary_ids (elem, s, new_bc_ids);
2199
2200 for (const auto & new_boundary_id : new_bc_ids)
2201 {
2202 const PeriodicBoundaryBase * new_periodic = boundaries.boundary(new_boundary_id);
2203 if (new_periodic && new_periodic->is_my_variable(variable_number))
2204 point_bcids.insert(new_boundary_id);
2205 }
2206 }
2207
2208 // See if this vertex has point neighbors to
2209 // defer to
2210 if (primary_boundary_point_neighbor
2211 (elem, my_node, mesh.get_boundary_info(), point_bcids)
2212 != elem)
2213 continue;
2214
2215 // Find the complementary boundary id set
2216 std::set<boundary_id_type> point_pairedids;
2217 for (const auto & new_boundary_id : point_bcids)
2218 {
2219 const PeriodicBoundaryBase * new_periodic = boundaries.boundary(new_boundary_id);
2220 point_pairedids.insert(new_periodic->pairedboundary);
2221 }
2222
2223 // What do we want to constrain against?
2224 const Elem * primary_elem = nullptr;
2225 const Elem * main_neigh = nullptr;
2226 Point main_pt = my_node,
2227 primary_pt = my_node;
2228
2229 for (const auto & new_boundary_id : point_bcids)
2230 {
2231 // Find the corresponding periodic point and
2232 // its primary neighbor
2233 const PeriodicBoundaryBase * new_periodic = boundaries.boundary(new_boundary_id);
2234
2235 const Point neigh_pt =
2236 new_periodic->get_corresponding_pos(my_node);
2237
2238 // If the point is getting constrained
2239 // to itself by this PBC then we don't
2240 // generate any constraints
2241 if (neigh_pt.absolute_fuzzy_equals
2242 (my_node, primary_hmin*TOLERANCE))
2243 continue;
2244
2245 // Otherwise we'll have a constraint in
2246 // one direction or another
2247 if (!primary_elem)
2248 primary_elem = elem;
2249
2250 const Elem * primary_neigh =
2251 primary_boundary_point_neighbor(neigh, neigh_pt,
2253 point_pairedids);
2254
2255 libmesh_assert(primary_neigh);
2256
2257 if (new_boundary_id == boundary_id)
2258 {
2259 main_neigh = primary_neigh;
2260 main_pt = neigh_pt;
2261 }
2262
2263 // Finer elements will get constrained in
2264 // terms of coarser neighbors, not the
2265 // other way around
2266 if ((primary_neigh->level() > primary_elem->level()) ||
2267
2268 // For equal-level elements, the one with
2269 // higher id gets constrained in terms of
2270 // the one with lower id
2271 (primary_neigh->level() == primary_elem->level() &&
2272 primary_neigh->id() > primary_elem->id()) ||
2273
2274 // On a one-element-thick mesh, we compare
2275 // points to see what side gets constrained
2276 (primary_neigh == primary_elem &&
2277 (neigh_pt > primary_pt)))
2278 continue;
2279
2280 primary_elem = primary_neigh;
2281 primary_pt = neigh_pt;
2282 }
2283
2284 if (!primary_elem ||
2285 primary_elem != main_neigh ||
2286 primary_pt != main_pt)
2287 continue;
2288 }
2289 else if (elem->is_edge(n))
2290 {
2291 // Find which edge we're on
2292 unsigned int e=0, ne = elem->n_edges();
2293 for (; e != ne; ++e)
2294 {
2295 if (elem->is_node_on_edge(n,e))
2296 break;
2297 }
2298 libmesh_assert_less (e, elem->n_edges());
2299
2300 // Find the edge end nodes
2301 const Node
2302 * e1 = nullptr,
2303 * e2 = nullptr;
2304 for (auto nn : elem->node_index_range())
2305 {
2306 if (nn == n)
2307 continue;
2308
2309 if (elem->is_node_on_edge(nn, e))
2310 {
2311 if (e1 == nullptr)
2312 {
2313 e1 = elem->node_ptr(nn);
2314 }
2315 else
2316 {
2317 e2 = elem->node_ptr(nn);
2318 break;
2319 }
2320 }
2321 }
2322 libmesh_assert (e1 && e2);
2323
2324 // Find all boundary ids that include this
2325 // edge and have periodic boundary
2326 // conditions for this variable
2327 std::set<boundary_id_type> edge_bcids;
2328
2329 for (unsigned int new_s = 0;
2330 new_s != max_ns; ++new_s)
2331 {
2332 if (!elem->is_node_on_side(n,new_s))
2333 continue;
2334
2335 // We're reusing the new_bc_ids vector created outside the loop over nodes.
2336 mesh.get_boundary_info().boundary_ids (elem, s, new_bc_ids);
2337
2338 for (const auto & new_boundary_id : new_bc_ids)
2339 {
2340 const PeriodicBoundaryBase * new_periodic = boundaries.boundary(new_boundary_id);
2341 if (new_periodic && new_periodic->is_my_variable(variable_number))
2342 edge_bcids.insert(new_boundary_id);
2343 }
2344 }
2345
2346
2347 // See if this edge has neighbors to defer to
2348 if (primary_boundary_edge_neighbor
2349 (elem, *e1, *e2, mesh.get_boundary_info(), edge_bcids)
2350 != elem)
2351 continue;
2352
2353 // Find the complementary boundary id set
2354 std::set<boundary_id_type> edge_pairedids;
2355 for (const auto & new_boundary_id : edge_bcids)
2356 {
2357 const PeriodicBoundaryBase * new_periodic = boundaries.boundary(new_boundary_id);
2358 edge_pairedids.insert(new_periodic->pairedboundary);
2359 }
2360
2361 // What do we want to constrain against?
2362 const Elem * primary_elem = nullptr;
2363 const Elem * main_neigh = nullptr;
2364 Point main_pt1 = *e1,
2365 main_pt2 = *e2,
2366 primary_pt1 = *e1,
2367 primary_pt2 = *e2;
2368
2369 for (const auto & new_boundary_id : edge_bcids)
2370 {
2371 // Find the corresponding periodic edge and
2372 // its primary neighbor
2373 const PeriodicBoundaryBase * new_periodic = boundaries.boundary(new_boundary_id);
2374
2375 Point neigh_pt1 = new_periodic->get_corresponding_pos(*e1),
2376 neigh_pt2 = new_periodic->get_corresponding_pos(*e2);
2377
2378 // If the edge is getting constrained
2379 // to itself by this PBC then we don't
2380 // generate any constraints
2381 if (neigh_pt1.absolute_fuzzy_equals
2382 (*e1, primary_hmin*TOLERANCE) &&
2383 neigh_pt2.absolute_fuzzy_equals
2384 (*e2, primary_hmin*TOLERANCE))
2385 continue;
2386
2387 // Otherwise we'll have a constraint in
2388 // one direction or another
2389 if (!primary_elem)
2390 primary_elem = elem;
2391
2392 const Elem * primary_neigh = primary_boundary_edge_neighbor
2393 (neigh, neigh_pt1, neigh_pt2,
2394 mesh.get_boundary_info(), edge_pairedids);
2395
2396 libmesh_assert(primary_neigh);
2397
2398 if (new_boundary_id == boundary_id)
2399 {
2400 main_neigh = primary_neigh;
2401 main_pt1 = neigh_pt1;
2402 main_pt2 = neigh_pt2;
2403 }
2404
2405 // If we have a one-element thick mesh,
2406 // we'll need to sort our points to get a
2407 // consistent ordering rule
2408 //
2409 // Use >= in this test to make sure that,
2410 // for angular constraints, no node gets
2411 // constrained to itself.
2412 if (primary_neigh == primary_elem)
2413 {
2414 if (primary_pt1 > primary_pt2)
2415 std::swap(primary_pt1, primary_pt2);
2416 if (neigh_pt1 > neigh_pt2)
2417 std::swap(neigh_pt1, neigh_pt2);
2418
2419 if (neigh_pt2 >= primary_pt2)
2420 continue;
2421 }
2422
2423 // Otherwise:
2424 // Finer elements will get constrained in
2425 // terms of coarser ones, not the other way
2426 // around
2427 if ((primary_neigh->level() > primary_elem->level()) ||
2428
2429 // For equal-level elements, the one with
2430 // higher id gets constrained in terms of
2431 // the one with lower id
2432 (primary_neigh->level() == primary_elem->level() &&
2433 primary_neigh->id() > primary_elem->id()))
2434 continue;
2435
2436 primary_elem = primary_neigh;
2437 primary_pt1 = neigh_pt1;
2438 primary_pt2 = neigh_pt2;
2439 }
2440
2441 if (!primary_elem ||
2442 primary_elem != main_neigh ||
2443 primary_pt1 != main_pt1 ||
2444 primary_pt2 != main_pt2)
2445 continue;
2446 }
2447 else if (elem->is_face(n))
2448 {
2449 // If we have a one-element thick mesh,
2450 // use the ordering of the face node and its
2451 // periodic counterpart to determine what
2452 // gets constrained
2453 if (neigh == elem)
2454 {
2455 const Point neigh_pt =
2456 periodic->get_corresponding_pos(my_node);
2457 if (neigh_pt > my_node)
2458 continue;
2459 }
2460
2461 // Otherwise:
2462 // Finer elements will get constrained in
2463 // terms of coarser ones, not the other way
2464 // around
2465 if ((neigh->level() > elem->level()) ||
2466
2467 // For equal-level elements, the one with
2468 // higher id gets constrained in terms of
2469 // the one with lower id
2470 (neigh->level() == elem->level() &&
2471 neigh->id() > elem->id()))
2472 continue;
2473 }
2474
2475 // If we made it here without hitting a continue
2476 // statement, then we're at a node whose dofs
2477 // should be constrained by this element's
2478 // calculations.
2479 const unsigned int n_comp =
2480 my_node.n_comp(sys_number, variable_number);
2481
2482 for (unsigned int i=0; i != n_comp; ++i)
2483 my_constrained_dofs.insert
2484 (my_node.dof_number
2485 (sys_number, variable_number, i));
2486 }
2487
2488 // FIXME: old code for disambiguating periodic BCs:
2489 // this is not threadsafe nor safe to run on a
2490 // non-serialized mesh.
2491 /*
2492 std::vector<bool> recursive_constraint(n_side_dofs, false);
2493
2494 for (unsigned int is = 0; is != n_side_dofs; ++is)
2495 {
2496 const unsigned int i = neigh_side_dofs[is];
2497 const dof_id_type their_dof_g = neigh_dof_indices[i];
2498 libmesh_assert_not_equal_to (their_dof_g, DofObject::invalid_id);
2499
2500 {
2501 Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
2502
2503 if (!dof_map.is_constrained_dof(their_dof_g))
2504 continue;
2505 }
2506
2507 DofConstraintRow & their_constraint_row =
2508 constraints[their_dof_g].first;
2509
2510 for (unsigned int js = 0; js != n_side_dofs; ++js)
2511 {
2512 const unsigned int j = my_side_dofs[js];
2513 const dof_id_type my_dof_g = my_dof_indices[j];
2514 libmesh_assert_not_equal_to (my_dof_g, DofObject::invalid_id);
2515
2516 if (their_constraint_row.count(my_dof_g))
2517 recursive_constraint[js] = true;
2518 }
2519 }
2520 */
2521
2522 for (unsigned int js = 0; js != n_side_dofs; ++js)
2523 {
2524 // FIXME: old code path
2525 // if (recursive_constraint[js])
2526 // continue;
2527
2528 const unsigned int j = my_side_dofs[js];
2529 const dof_id_type my_dof_g = my_dof_indices[j];
2530 libmesh_assert_not_equal_to (my_dof_g, DofObject::invalid_id);
2531
2532 // FIXME: new code path
2533 if (!my_constrained_dofs.count(my_dof_g))
2534 continue;
2535
2536 DofConstraintRow * constraint_row;
2537
2538 // we may be running constraint methods concurrently
2539 // on multiple threads, so we need a lock to
2540 // ensure that this constraint is "ours"
2541 {
2542 Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
2543
2544 if (dof_map.is_constrained_dof(my_dof_g))
2545 continue;
2546
2547 constraint_row = &(constraints[my_dof_g]);
2548 libmesh_assert(constraint_row->empty());
2549 }
2550
2551 for (unsigned int is = 0; is != n_side_dofs; ++is)
2552 {
2553 const unsigned int i = neigh_side_dofs[is];
2554 const dof_id_type their_dof_g = neigh_dof_indices[i];
2555 libmesh_assert_not_equal_to (their_dof_g, DofObject::invalid_id);
2556
2557 // Periodic constraints should never be
2558 // self-constraints
2559 // libmesh_assert_not_equal_to (their_dof_g, my_dof_g);
2560
2561 const Real their_dof_value = Ue[is](js);
2562
2563 if (their_dof_g == my_dof_g)
2564 {
2565 libmesh_assert_less (std::abs(their_dof_value-1.), 1.e-5);
2566 for (unsigned int k = 0; k != n_side_dofs; ++k)
2567 libmesh_assert(k == is || std::abs(Ue[k](js)) < 1.e-5);
2568 continue;
2569 }
2570
2571 if (std::abs(their_dof_value) < 10*TOLERANCE)
2572 continue;
2573
2574 if(!periodic->has_transformation_matrix())
2575 {
2576 constraint_row->emplace(their_dof_g, their_dof_value);
2577 }
2578 else
2579 {
2580 // In this case the current variable is constrained in terms of other variables.
2581 // We assume that all variables in this constraint have the same FE type (this
2582 // is asserted below), and hence we can create the constraint row contribution
2583 // by multiplying their_dof_value by the corresponding row of the transformation
2584 // matrix.
2585
2586 const std::set<unsigned int> & variables = periodic->get_variables();
2587 neigh_dof_indices_all_variables.resize(variables.size());
2588 unsigned int index = 0;
2589 for(unsigned int other_var : variables)
2590 {
2591 libmesh_assert_msg(base_fe_type == dof_map.variable_type(other_var), "FE types must match for all variables involved in constraint");
2592
2593 Real var_weighting = periodic->get_transformation_matrix()(variable_number, other_var);
2594 constraint_row->emplace(neigh_dof_indices_all_variables[index][i],
2595 var_weighting*their_dof_value);
2596 index++;
2597 }
2598 }
2599
2600 }
2601 }
2602 }
2603 // p refinement constraints:
2604 // constrain dofs shared between
2605 // active elements and neighbors with
2606 // lower polynomial degrees
2607#ifdef LIBMESH_ENABLE_AMR
2608 const unsigned int min_p_level =
2609 neigh->min_p_level_by_neighbor(elem, elem->p_level());
2610 if (min_p_level < elem->p_level())
2611 {
2612 // Adaptive p refinement of non-hierarchic bases will
2613 // require more coding
2614 libmesh_assert(my_fe->is_hierarchic());
2615 dof_map.constrain_p_dofs(variable_number, elem,
2616 s, min_p_level);
2617 }
2618#endif // #ifdef LIBMESH_ENABLE_AMR
2619 }
2620 }
2621}
void boundary_ids(const Node *node, std::vector< boundary_id_type > &vec_to_fill) const
Fills a user-provided std::vector with the boundary ids associated with Node node.
void constrain_p_dofs(unsigned int var, const Elem *elem, unsigned int s, unsigned int p)
Constrains degrees of freedom on side s of element elem which correspond to variable number var and t...
unsigned int sys_number() const
Definition dof_map.h:2353
bool is_constrained_dof(const dof_id_type dof) const
Definition dof_map.h:2439
unsigned int n_comp(const unsigned int s, const unsigned int var) const
Definition dof_object.h:992
dof_id_type dof_number(const unsigned int s, const unsigned int var, const unsigned int comp) const
static constexpr dof_id_type invalid_id
An invalid id to distinguish an uninitialized DofObject.
Definition dof_object.h:473
dof_id_type id() const
Definition dof_object.h:833
virtual bool is_node_on_side(const unsigned int n, const unsigned int s) const =0
bool active() const
Definition elem.h:3079
const Node & node_ref(const unsigned int i) const
Definition elem.h:2659
virtual bool is_face(const unsigned int i) const =0
virtual Real hmin() const
Definition elem.C:623
virtual unsigned short dim() const =0
virtual bool is_edge(const unsigned int i) const =0
unsigned int level() const
Definition elem.h:3212
unsigned int min_p_level_by_neighbor(const Elem *neighbor, unsigned int current_min) const
Definition elem.C:2452
const Node * node_ptr(const unsigned int i) const
Definition elem.h:2637
virtual bool is_vertex(const unsigned int i) const =0
virtual bool is_node_on_edge(const unsigned int n, const unsigned int e) const =0
virtual unsigned int n_edges() const =0
virtual unsigned int n_sides() const =0
const Elem * neighbor_ptr(unsigned int i) const
Definition elem.h:2736
virtual bool infinite() const =0
Order default_quadrature_order() const
Definition fe_type.h:415
const BoundaryInfo & get_boundary_info() const
The information about boundary ids on the mesh.
Definition mesh_base.h:170
A Node is like a Point, but with more information.
Definition node.h:55
PeriodicBoundaryBase * boundary(boundary_id_type id)
const Elem * neighbor(boundary_id_type boundary_id, const PointLocatorBase &point_locator, const Elem *e, unsigned int side, unsigned int *neigh_side=nullptr) const
The base class for defining periodic boundaries.
const DenseMatrix< Real > & get_transformation_matrix() const
Get the transformation matrix, if it is defined.
bool is_my_variable(unsigned int var_num) const
const std::set< unsigned int > & get_variables() const
Get the set of variables for this periodic boundary condition.
virtual Point get_corresponding_pos(const Point &pt) const =0
This function should be overridden by derived classes to define how one finds corresponding nodes on ...
A Point defines a location in LIBMESH_DIM dimensional Real space.
Definition point.h:41
This class implements specific orders of Gauss quadrature.
bool absolute_fuzzy_equals(const TypeVector< T > &rhs, Real tol=TOLERANCE) const
MeshBase & mesh
std::map< dof_id_type, Real, std::less< dof_id_type >, Threads::scalable_allocator< std::pair< const dof_id_type, Real > > > DofConstraintRow
A row of the Dof constraint matrix.
Definition dof_map.h:100
PetscErrorCode PetscInt const PetscInt IS * is
uint8_t dof_id_type
Definition id_types.h:67

References libMesh::TypeVector< T >::absolute_fuzzy_equals(), libMesh::Elem::active(), libMesh::PeriodicBoundaries::boundary(), libMesh::BoundaryInfo::boundary_ids(), libMesh::C_ONE, libMesh::C_ZERO, libMesh::DenseMatrix< T >::cholesky_solve(), libMesh::DofMap::constrain_p_dofs(), libMesh::FEType::default_quadrature_order(), libMesh::Elem::dim(), libMesh::DISCONTINUOUS, libMesh::DofMap::dof_indices(), libMesh::DofObject::dof_number(), libMesh::FEInterface::dofs_on_side(), libMesh::MeshBase::get_boundary_info(), libMesh::PeriodicBoundaryBase::get_corresponding_pos(), libMesh::PeriodicBoundaryBase::get_transformation_matrix(), libMesh::PeriodicBoundaryBase::get_variables(), libMesh::PeriodicBoundaryBase::has_transformation_matrix(), libMesh::Elem::hmin(), libMesh::DofObject::id(), libMesh::index_range(), libMesh::Elem::infinite(), libMesh::TensorTools::inner_product(), libMesh::DofObject::invalid_id, libMesh::FEMap::inverse_map(), libMesh::is, libMesh::DofMap::is_constrained_dof(), libMesh::Elem::is_edge(), libMesh::Elem::is_face(), libMesh::PeriodicBoundaryBase::is_my_variable(), libMesh::Elem::is_node_on_edge(), libMesh::Elem::is_node_on_side(), libMesh::Elem::is_vertex(), libMesh::Elem::level(), libMesh::libmesh_assert(), mesh, libMesh::Elem::min_p_level_by_neighbor(), libMesh::DofObject::n_comp(), libMesh::Elem::n_edges(), libMesh::QBase::n_points(), libMesh::Elem::n_sides(), libMesh::PeriodicBoundaries::neighbor(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::node_index_range(), libMesh::Elem::node_ptr(), libMesh::Elem::node_ref(), libMesh::Elem::p_level(), libMesh::PeriodicBoundaryBase::pairedboundary, libMesh::Real, libMesh::DenseVector< T >::resize(), libMesh::DenseMatrix< T >::resize(), libMesh::Threads::spin_mtx, libMesh::DofMap::sys_number(), libMesh::TOLERANCE, and libMesh::DofMap::variable_type().

Referenced by libMesh::FEInterface::compute_periodic_constraints().

◆ compute_periodic_node_constraints()

void libMesh::FEAbstract::compute_periodic_node_constraints ( NodeConstraints &  constraints,
const PeriodicBoundaries &  boundaries,
const MeshBase &  mesh,
const PointLocatorBase *  point_locator,
const Elem *  elem 
)
staticinherited

Computes the node position constraint equation contributions (for meshes with periodic boundary conditions)

Definition at line 1090 of file fe_abstract.C.

1095{
1096 // Only bother if we truly have periodic boundaries
1097 if (boundaries.empty())
1098 return;
1099
1100 libmesh_assert(elem);
1101
1102 // Only constrain active elements with this method
1103 if (!elem->active())
1104 return;
1105
1106 const unsigned int Dim = elem->dim();
1107
1108 const FEFamily mapping_family = FEMap::map_fe_type(*elem);
1109 const FEType fe_type(elem->default_side_order(), mapping_family);
1110
1111 // Pull objects out of the loop to reduce heap operations
1112 std::vector<const Node *> my_nodes, neigh_nodes;
1113 std::unique_ptr<const Elem> my_side, neigh_side;
1114
1115 // Look at the element faces. Check to see if we need to
1116 // build constraints.
1117 std::vector<boundary_id_type> bc_ids;
1118 for (auto s : elem->side_index_range())
1119 {
1120 if (elem->neighbor_ptr(s))
1121 continue;
1122
1123 mesh.get_boundary_info().boundary_ids (elem, s, bc_ids);
1124 for (const auto & boundary_id : bc_ids)
1125 {
1126 const PeriodicBoundaryBase * periodic = boundaries.boundary(boundary_id);
1127 if (periodic)
1128 {
1129 libmesh_assert(point_locator);
1130
1131 // Get pointers to the element's neighbor.
1132 unsigned int s_neigh;
1133 const Elem * neigh = boundaries.neighbor(boundary_id, *point_locator, elem, s, &s_neigh);
1134
1135 libmesh_error_msg_if
1136 (!neigh, "PeriodicBoundaries can't find a periodic neighbor for element " <<
1137 elem->id() << " side " << s);
1138
1139 // h refinement constraints:
1140 // constrain dofs shared between
1141 // this element and ones as coarse
1142 // as or coarser than this element.
1143 if (neigh->level() <= elem->level())
1144 {
1145#ifdef LIBMESH_ENABLE_AMR
1146 libmesh_assert(neigh->active());
1147#endif // #ifdef LIBMESH_ENABLE_AMR
1148
1149 elem->build_side_ptr(my_side, s);
1150 neigh->build_side_ptr(neigh_side, s_neigh);
1151
1152 const unsigned int n_side_nodes = my_side->n_nodes();
1153
1154 my_nodes.clear();
1155 my_nodes.reserve (n_side_nodes);
1156 neigh_nodes.clear();
1157 neigh_nodes.reserve (n_side_nodes);
1158
1159 for (unsigned int n=0; n != n_side_nodes; ++n)
1160 my_nodes.push_back(my_side->node_ptr(n));
1161
1162 for (unsigned int n=0; n != n_side_nodes; ++n)
1163 neigh_nodes.push_back(neigh_side->node_ptr(n));
1164
1165 // Make sure we're not adding recursive constraints
1166 // due to the redundancy in the way we add periodic
1167 // boundary constraints, or adding constraints to
1168 // nodes that already have AMR constraints
1169 std::vector<bool> skip_constraint(n_side_nodes, false);
1170
1171 for (unsigned int my_side_n=0;
1172 my_side_n < n_side_nodes;
1173 my_side_n++)
1174 {
1175 // Do not use the p_level(), if any, that is inherited by the side.
1176 libmesh_assert_less (my_side_n, FEInterface::n_dofs(fe_type, /*extra_order=*/0, my_side.get()));
1177
1178 const Node * my_node = my_nodes[my_side_n];
1179
1180 // If we've already got a constraint on this
1181 // node, then the periodic constraint is
1182 // redundant
1183 {
1184 Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
1185
1186 if (constraints.count(my_node))
1187 {
1188 skip_constraint[my_side_n] = true;
1189 continue;
1190 }
1191 }
1192
1193 // Compute the neighbors's side shape function values.
1194 for (unsigned int their_side_n=0;
1195 their_side_n < n_side_nodes;
1196 their_side_n++)
1197 {
1198 // Do not use the p_level(), if any, that is inherited by the side.
1199 libmesh_assert_less (their_side_n, FEInterface::n_dofs(fe_type, /*extra_order=*/0, neigh_side.get()));
1200
1201 const Node * their_node = neigh_nodes[their_side_n];
1202
1203 // If there's a constraint on an opposing node,
1204 // we need to see if it's constrained by
1205 // *our side* making any periodic constraint
1206 // on us recursive
1207 {
1208 Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
1209
1210 if (!constraints.count(their_node))
1211 continue;
1212
1213 const NodeConstraintRow & their_constraint_row =
1214 constraints[their_node].first;
1215
1216 for (unsigned int orig_side_n=0;
1217 orig_side_n < n_side_nodes;
1218 orig_side_n++)
1219 {
1220 // Do not use the p_level(), if any, that is inherited by the side.
1221 libmesh_assert_less (orig_side_n, FEInterface::n_dofs(fe_type, /*extra_order=*/0, my_side.get()));
1222
1223 const Node * orig_node = my_nodes[orig_side_n];
1224
1225 if (their_constraint_row.count(orig_node))
1226 skip_constraint[orig_side_n] = true;
1227 }
1228 }
1229 }
1230 }
1231 for (unsigned int my_side_n=0;
1232 my_side_n < n_side_nodes;
1233 my_side_n++)
1234 {
1235 // Do not use the p_level(), if any, that is inherited by the side.
1236 libmesh_assert_less (my_side_n, FEInterface::n_dofs(fe_type, /*extra_order=*/0, my_side.get()));
1237
1238 if (skip_constraint[my_side_n])
1239 continue;
1240
1241 const Node * my_node = my_nodes[my_side_n];
1242
1243 // Figure out where my node lies on their reference element.
1244 const Point neigh_point = periodic->get_corresponding_pos(*my_node);
1245
1246 // Figure out where my node lies on their reference element.
1247 const Point mapped_point =
1248 FEMap::inverse_map(Dim-1, neigh_side.get(),
1249 neigh_point);
1250
1251 for (unsigned int their_side_n=0;
1252 their_side_n < n_side_nodes;
1253 their_side_n++)
1254 {
1255 // Do not use the p_level(), if any, that is inherited by the side.
1256 libmesh_assert_less (their_side_n, FEInterface::n_dofs(fe_type, /*extra_order=*/0, neigh_side.get()));
1257
1258 const Node * their_node = neigh_nodes[their_side_n];
1259 libmesh_assert(their_node);
1260
1261 // Do not use the p_level(), if any, that is inherited by the side.
1262 const Real their_value = FEInterface::shape(fe_type,
1263 /*extra_order=*/0,
1264 neigh_side.get(),
1265 their_side_n,
1266 mapped_point);
1267
1268 // since we may be running this method concurrently
1269 // on multiple threads we need to acquire a lock
1270 // before modifying the shared constraint_row object.
1271 {
1272 Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
1273
1274 NodeConstraintRow & constraint_row =
1275 constraints[my_node].first;
1276
1277 constraint_row.emplace(their_node, their_value);
1278 }
1279 }
1280 }
1281 }
1282 }
1283 }
1284 }
1285}

References libMesh::Elem::active(), libMesh::PeriodicBoundaries::boundary(), libMesh::Elem::build_side_ptr(), libMesh::Elem::default_side_order(), libMesh::Elem::dim(), libMesh::FEAbstract::fe_type, libMesh::PeriodicBoundaryBase::get_corresponding_pos(), libMesh::DofObject::id(), libMesh::FEMap::inverse_map(), libMesh::Elem::level(), libMesh::libmesh_assert(), libMesh::FEMap::map_fe_type(), mesh, libMesh::FEInterface::n_dofs(), libMesh::PeriodicBoundaries::neighbor(), libMesh::Elem::neighbor_ptr(), libMesh::Real, libMesh::FEInterface::shape(), libMesh::Elem::side_index_range(), and libMesh::Threads::spin_mtx.

◆ compute_proj_constraints()

template<typename OutputType >
void libMesh::FEGenericBase< OutputType >::compute_proj_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, using generic projections.

Definition at line 1572 of file fe_base.C.

1576{
1577 libmesh_assert(elem);
1578
1579 const unsigned int Dim = elem->dim();
1580
1581 // Only constrain elements in 2,3D.
1582 if (Dim == 1)
1583 return;
1584
1585 // Only constrain active elements with this method
1586 if (!elem->active())
1587 return;
1588
1589 const Variable & var = dof_map.variable(variable_number);
1590 const FEType & base_fe_type = var.type();
1591 const bool add_p_level = base_fe_type.p_refinement;
1592
1593 // Construct FE objects for this element and its neighbors.
1594 std::unique_ptr<FEGenericBase<OutputShape>> my_fe
1595 (FEGenericBase<OutputShape>::build(Dim, base_fe_type));
1596 my_fe->add_p_level_in_reinit(add_p_level);
1597 const FEContinuity cont = my_fe->get_continuity();
1598
1599 // We don't need to constrain discontinuous elements
1600 if (cont == DISCONTINUOUS)
1601 return;
1602 libmesh_assert (cont == C_ZERO || cont == C_ONE ||
1603 cont == SIDE_DISCONTINUOUS);
1604
1605 // this would require some generalisation:
1606 // - e.g. the 'my_fe'-object needs generalisation
1607 // - due to lack of one-to-one correspondence of DOFs and nodes,
1608 // this doesn't work easily.
1609 if (elem->infinite())
1610 libmesh_not_implemented();
1611
1612 std::unique_ptr<FEGenericBase<OutputShape>> neigh_fe
1613 (FEGenericBase<OutputShape>::build(Dim, base_fe_type));
1614 neigh_fe->add_p_level_in_reinit(add_p_level);
1615
1616 QGauss my_qface(Dim-1, base_fe_type.default_quadrature_order());
1617 my_fe->attach_quadrature_rule (&my_qface);
1618 std::vector<Point> neigh_qface;
1619
1620 const std::vector<Real> & JxW = my_fe->get_JxW();
1621 const std::vector<Point> & q_point = my_fe->get_xyz();
1622 const std::vector<std::vector<OutputShape>> & phi = my_fe->get_phi();
1623 const std::vector<std::vector<OutputShape>> & neigh_phi =
1624 neigh_fe->get_phi();
1625 const std::vector<Point> * face_normals = nullptr;
1626 const std::vector<std::vector<OutputGradient>> * dphi = nullptr;
1627 const std::vector<std::vector<OutputGradient>> * neigh_dphi = nullptr;
1628
1629 std::vector<dof_id_type> my_dof_indices, neigh_dof_indices;
1630 std::vector<unsigned int> my_side_dofs, neigh_side_dofs;
1631
1632 if (cont == C_ONE)
1633 {
1634 const std::vector<Point> & ref_face_normals =
1635 my_fe->get_normals();
1636 face_normals = &ref_face_normals;
1637 const std::vector<std::vector<OutputGradient>> & ref_dphi =
1638 my_fe->get_dphi();
1639 dphi = &ref_dphi;
1640 const std::vector<std::vector<OutputGradient>> & ref_neigh_dphi =
1641 neigh_fe->get_dphi();
1642 neigh_dphi = &ref_neigh_dphi;
1643 }
1644
1647 std::vector<DenseVector<Real>> Ue;
1648
1649 // Look at the element faces. Check to see if we need to
1650 // build constraints.
1651 for (auto s : elem->side_index_range())
1652 {
1653 // Get pointers to the element's neighbor.
1654 const Elem * neigh = elem->neighbor_ptr(s);
1655
1656 if (!neigh)
1657 continue;
1658
1659 if (!var.active_on_subdomain(neigh->subdomain_id()))
1660 continue;
1661
1662 // h refinement constraints:
1663 // constrain dofs shared between
1664 // this element and ones coarser
1665 // than this element.
1666 if (neigh->level() < elem->level())
1667 {
1668 unsigned int s_neigh = neigh->which_neighbor_am_i(elem);
1669 libmesh_assert_less (s_neigh, neigh->n_neighbors());
1670
1671 // Find the minimum p level; we build the h constraint
1672 // matrix with this and then constrain away all higher p
1673 // DoFs.
1674 libmesh_assert(neigh->active());
1675 const unsigned int min_p_level = add_p_level *
1676 std::min(elem->p_level(), neigh->p_level());
1677 // we may need to make the FE objects reinit with the
1678 // minimum shared p_level
1679 const unsigned int old_elem_level = add_p_level * elem->p_level();
1680 if (old_elem_level != min_p_level)
1681 my_fe->set_fe_order(my_fe->get_fe_type().order.get_order() + min_p_level - old_elem_level);
1682 const unsigned int old_neigh_level = add_p_level * neigh->p_level();
1683 if (old_neigh_level != min_p_level)
1684 neigh_fe->set_fe_order(neigh_fe->get_fe_type().order.get_order() + min_p_level - old_neigh_level);
1685
1686 my_fe->reinit(elem, s);
1687
1688 // This function gets called element-by-element, so there
1689 // will be a lot of memory allocation going on. We can
1690 // at least minimize this for the case of the dof indices
1691 // by efficiently preallocating the requisite storage.
1692 // n_nodes is not necessarily n_dofs, but it is better
1693 // than nothing!
1694 my_dof_indices.reserve (elem->n_nodes());
1695 neigh_dof_indices.reserve (neigh->n_nodes());
1696
1697 dof_map.dof_indices (elem, my_dof_indices,
1698 variable_number,
1699 min_p_level);
1700 dof_map.dof_indices (neigh, neigh_dof_indices,
1701 variable_number,
1702 min_p_level);
1703
1704 const unsigned int n_qp = my_qface.n_points();
1705
1706 FEMap::inverse_map (Dim, neigh, q_point, neigh_qface);
1707
1708 neigh_fe->reinit(neigh, &neigh_qface);
1709
1710 // We're only concerned with DOFs whose values (and/or first
1711 // derivatives for C1 elements) are supported on side nodes
1712 FEType elem_fe_type = base_fe_type;
1713 if (old_elem_level != min_p_level)
1714 elem_fe_type.order = base_fe_type.order.get_order() + min_p_level - old_elem_level;
1715 FEType neigh_fe_type = base_fe_type;
1716 if (old_neigh_level != min_p_level)
1717 neigh_fe_type.order = base_fe_type.order.get_order() + min_p_level - old_neigh_level;
1718 FEInterface::dofs_on_side(elem, Dim, elem_fe_type, s, my_side_dofs);
1719 FEInterface::dofs_on_side(neigh, Dim, neigh_fe_type, s_neigh, neigh_side_dofs);
1720
1721 const unsigned int n_side_dofs =
1722 cast_int<unsigned int>(my_side_dofs.size());
1723 libmesh_assert_equal_to (n_side_dofs, neigh_side_dofs.size());
1724
1725#ifndef NDEBUG
1726 for (auto i : my_side_dofs)
1727 libmesh_assert_less(i, my_dof_indices.size());
1728 for (auto i : neigh_side_dofs)
1729 libmesh_assert_less(i, neigh_dof_indices.size());
1730#endif
1731
1732 Ke.resize (n_side_dofs, n_side_dofs);
1733 Ue.resize(n_side_dofs);
1734
1735 // Form the projection matrix, (inner product of fine basis
1736 // functions against fine test functions)
1737 for (unsigned int is = 0; is != n_side_dofs; ++is)
1738 {
1739 const unsigned int i = my_side_dofs[is];
1740 for (unsigned int js = 0; js != n_side_dofs; ++js)
1741 {
1742 const unsigned int j = my_side_dofs[js];
1743 for (unsigned int qp = 0; qp != n_qp; ++qp)
1744 {
1745 Ke(is,js) += JxW[qp] * TensorTools::inner_product(phi[i][qp], phi[j][qp]);
1746 if (cont == C_ONE)
1747 Ke(is,js) += JxW[qp] *
1749 (*face_normals)[qp],
1750 (*dphi)[j][qp] *
1751 (*face_normals)[qp]);
1752 }
1753 }
1754 }
1755
1756 // Form the right hand sides, (inner product of coarse basis
1757 // functions against fine test functions)
1758 for (unsigned int is = 0; is != n_side_dofs; ++is)
1759 {
1760 const unsigned int i = neigh_side_dofs[is];
1761 Fe.resize (n_side_dofs);
1762 for (unsigned int js = 0; js != n_side_dofs; ++js)
1763 {
1764 const unsigned int j = my_side_dofs[js];
1765 for (unsigned int qp = 0; qp != n_qp; ++qp)
1766 {
1767 Fe(js) += JxW[qp] *
1768 TensorTools::inner_product(neigh_phi[i][qp],
1769 phi[j][qp]);
1770 if (cont == C_ONE)
1771 Fe(js) += JxW[qp] *
1772 TensorTools::inner_product((*neigh_dphi)[i][qp] *
1773 (*face_normals)[qp],
1774 (*dphi)[j][qp] *
1775 (*face_normals)[qp]);
1776 }
1777 }
1778 Ke.cholesky_solve(Fe, Ue[is]);
1779 }
1780
1781 for (unsigned int js = 0; js != n_side_dofs; ++js)
1782 {
1783 const unsigned int j = my_side_dofs[js];
1784 const dof_id_type my_dof_g = my_dof_indices[j];
1785 libmesh_assert_not_equal_to (my_dof_g, DofObject::invalid_id);
1786
1787 // Hunt for "constraining against myself" cases before
1788 // we bother creating a constraint row
1789 bool self_constraint = false;
1790 for (unsigned int is = 0; is != n_side_dofs; ++is)
1791 {
1792 const unsigned int i = neigh_side_dofs[is];
1793 const dof_id_type their_dof_g = neigh_dof_indices[i];
1794 libmesh_assert_not_equal_to (their_dof_g, DofObject::invalid_id);
1795
1796 if (their_dof_g == my_dof_g)
1797 {
1798#ifndef NDEBUG
1799 const Real their_dof_value = Ue[is](js);
1800 libmesh_assert_less (std::abs(their_dof_value-1.),
1801 10*TOLERANCE);
1802
1803 for (unsigned int k = 0; k != n_side_dofs; ++k)
1804 libmesh_assert(k == is ||
1805 std::abs(Ue[k](js)) <
1806 10*TOLERANCE);
1807#endif
1808
1809 self_constraint = true;
1810 break;
1811 }
1812 }
1813
1814 if (self_constraint)
1815 continue;
1816
1817 DofConstraintRow * constraint_row;
1818
1819 // we may be running constraint methods concurrently
1820 // on multiple threads, so we need a lock to
1821 // ensure that this constraint is "ours"
1822 {
1823 Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
1824
1825 if (dof_map.is_constrained_dof(my_dof_g))
1826 continue;
1827
1828 constraint_row = &(constraints[my_dof_g]);
1829 libmesh_assert(constraint_row->empty());
1830 }
1831
1832 for (unsigned int is = 0; is != n_side_dofs; ++is)
1833 {
1834 const unsigned int i = neigh_side_dofs[is];
1835 const dof_id_type their_dof_g = neigh_dof_indices[i];
1836 libmesh_assert_not_equal_to (their_dof_g, DofObject::invalid_id);
1837 libmesh_assert_not_equal_to (their_dof_g, my_dof_g);
1838
1839 const Real their_dof_value = Ue[is](js);
1840
1841 if (std::abs(their_dof_value) < 10*TOLERANCE)
1842 continue;
1843
1844 constraint_row->emplace(their_dof_g, their_dof_value);
1845 }
1846 }
1847
1848 my_fe->set_fe_order(my_fe->get_fe_type().order.get_order() + old_elem_level - min_p_level);
1849 neigh_fe->set_fe_order(neigh_fe->get_fe_type().order.get_order() + old_neigh_level - min_p_level);
1850 }
1851
1852 if (add_p_level)
1853 {
1854 // p refinement constraints:
1855 // constrain dofs shared between
1856 // active elements and neighbors with
1857 // lower polynomial degrees
1858 const unsigned int min_p_level =
1859 neigh->min_p_level_by_neighbor(elem, elem->p_level());
1860 if (min_p_level < elem->p_level())
1861 {
1862 // Adaptive p refinement of non-hierarchic bases will
1863 // require more coding
1864 libmesh_assert(my_fe->is_hierarchic());
1865 dof_map.constrain_p_dofs(variable_number, elem,
1866 s, min_p_level);
1867 }
1868 }
1869 }
1870}
const Variable & variable(const unsigned int c) const override
Definition dof_map.h:2371
virtual unsigned int n_nodes() const =0
unsigned int which_neighbor_am_i(const Elem *e) const
This function tells you which neighbor e is.
Definition elem.h:3057
unsigned int n_neighbors() const
Definition elem.h:812
subdomain_id_type subdomain_id() const
Definition elem.h:2712
bool p_refinement
Whether or not the finite elements for this type increase their p refinement level on geometric eleme...
Definition fe_type.h:292
int get_order() const
Explicitly request the order as an int.
Definition fe_type.h:80
This class defines the notion of a variable in the system.
Definition variable.h:51
bool active_on_subdomain(subdomain_id_type sid) const
Definition variable.h:167
const FEType & type() const
Definition variable.h:144
@ SIDE_DISCONTINUOUS

References libMesh::Elem::active(), libMesh::Variable::active_on_subdomain(), libMesh::C_ONE, libMesh::C_ZERO, libMesh::DenseMatrix< T >::cholesky_solve(), libMesh::DofMap::constrain_p_dofs(), libMesh::FEType::default_quadrature_order(), libMesh::Elem::dim(), libMesh::DISCONTINUOUS, libMesh::DofMap::dof_indices(), libMesh::FEInterface::dofs_on_side(), libMesh::OrderWrapper::get_order(), libMesh::Elem::infinite(), libMesh::TensorTools::inner_product(), libMesh::DofObject::invalid_id, libMesh::FEMap::inverse_map(), libMesh::is, libMesh::DofMap::is_constrained_dof(), libMesh::Elem::level(), libMesh::libmesh_assert(), libMesh::Elem::min_p_level_by_neighbor(), libMesh::Elem::n_neighbors(), libMesh::Elem::n_nodes(), libMesh::QBase::n_points(), libMesh::Elem::neighbor_ptr(), libMesh::FEType::order, libMesh::Elem::p_level(), libMesh::FEType::p_refinement, libMesh::Real, libMesh::DenseVector< T >::resize(), libMesh::DenseMatrix< T >::resize(), libMesh::SIDE_DISCONTINUOUS, libMesh::Elem::side_index_range(), libMesh::Threads::spin_mtx, libMesh::Elem::subdomain_id(), libMesh::TOLERANCE, libMesh::Variable::type(), libMesh::DofMap::variable(), and libMesh::Elem::which_neighbor_am_i().

Referenced by libMesh::FE< Dim, T >::compute_constraints().

◆ compute_shape_functions()

template<typename OutputType >
void libMesh::FEGenericBase< OutputType >::compute_shape_functions ( const Elem *  elem,
const std::vector< Point > &  qp 
)
overrideprotectedvirtual

After having updated the jacobian and the transformation from local to global coordinates in FEMap::compute_map(), the first derivatives of the shape functions are transformed to global coordinates, giving dphi, dphidx, dphidy, and dphidz.

This method should rarely be re-defined in derived classes, but still should be usable for children. Therefore, keep it protected.

Implements libMesh::FEAbstract.

Reimplemented in libMesh::InfFE< Dim, T_radial, T_map >, and libMesh::FEXYZ< Dim >.

Definition at line 774 of file fe_base.C.

776{
777 //-------------------------------------------------------------------------
778 // Compute the shape function values (and derivatives)
779 // at the Quadrature points. Note that the actual values
780 // have already been computed via init_shape_functions
781
782 // Start logging the shape function computation
783 LOG_ONE_ENTITY_SCOPE("compute_shape_functions()", "FE");
784
786
787 if (calculate_phi)
788 this->_fe_trans->map_phi(this->dim, elem, qp, (*this), this->phi, this->_add_p_level_in_reinit);
789
790 if (calculate_dphi)
791 this->_fe_trans->map_dphi(this->dim, elem, qp, (*this), this->dphi,
792 this->dphidx, this->dphidy, this->dphidz);
793
794#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
795 if (calculate_d2phi)
796 this->_fe_trans->map_d2phi(this->dim, qp, (*this), this->d2phi,
797 this->d2phidx2, this->d2phidxdy, this->d2phidxdz,
798 this->d2phidy2, this->d2phidydz, this->d2phidz2);
799#endif //LIBMESH_ENABLE_SECOND_DERIVATIVES
800
801 // Only compute curl for vector-valued elements
803 this->_fe_trans->map_curl(this->dim, elem, qp, (*this), this->curl_phi);
804
805 // Only compute div for vector-valued elements
807 this->_fe_trans->map_div(this->dim, elem, qp, (*this), this->div_phi);
808}
virtual_for_inffe void determine_calculations()
Determine which values are to be calculated, for both the FE itself and for the FEMap.
Definition fe_base.C:951

◆ determine_calculations()

template<typename OutputType >
void libMesh::FEGenericBase< OutputType >::determine_calculations ( )
protected

Determine which values are to be calculated, for both the FE itself and for the FEMap.

Definition at line 951 of file fe_base.C.

952{
953 this->calculations_started = true;
954
955 // If the user did not explicitly pre-request something (or nothing)
956 // to be computed, then we throw an error here.
957 bool requested_ok =
958 this->calculate_nothing || this->calculate_phi || this->calculate_dphi ||
960 this->calculate_map;
961
962#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
963 requested_ok = requested_ok || this->calculate_d2phi;
964#endif
965
966 libmesh_error_msg_if(
967 !requested_ok,
968 "You must call one or more of the FE accessors "
969 "(e.g. get_phi(), get_dphi(), get_nothing()) "
970 "_before_ calling reinit()!");
971
972 // Request whichever terms are necessary from the FEMap
973 if (this->calculate_phi)
974 this->_fe_trans->init_map_phi(*this);
975
976 if (this->calculate_dphiref)
977 this->_fe_trans->init_map_dphi(*this);
978
979#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
980 if (this->calculate_d2phi)
981 this->_fe_trans->init_map_d2phi(*this);
982#endif //LIBMESH_ENABLE_SECOND_DERIVATIVES
983}
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
bool calculate_dphiref
Should we calculate reference shape function gradients?

◆ disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )
staticinherited

Definition at line 100 of file reference_counter.C.

101{
102 _enable_print_counter = false;
103 return;
104}
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called.

References libMesh::ReferenceCounter::_enable_print_counter.

◆ edge_reinit()

virtual void libMesh::FEAbstract::edge_reinit ( const Elem *  elem,
const unsigned int  edge,
const Real  tolerance = TOLERANCE,
const std::vector< Point > *  pts = nullptr,
const std::vector< Real > *  weights = nullptr 
)
pure virtualinherited

Reinitializes all the physical element-dependent data based on the edge of the element elem.

The tolerance parameter is passed to the involved call to inverse_map(). By default the element data are computed at the quadrature points specified by the quadrature rule qrule, but any set of points on the reference edge element may be specified in the optional argument pts.

Implemented in libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::InfFE< Dim, T_radial, T_map >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, and libMesh::FE< Dim, XYZ >.

◆ enable_print_counter_info()

void libMesh::ReferenceCounter::enable_print_counter_info ( )
staticinherited

Methods to enable/disable the reference counter output from print_info().

Enabled by default.

Definition at line 94 of file reference_counter.C.

95{
97 return;
98}

References libMesh::ReferenceCounter::_enable_print_counter.

Referenced by libMesh::LibMeshInit::~LibMeshInit().

◆ get_continuity()

virtual FEContinuity libMesh::FEAbstract::get_continuity ( ) const
pure virtualinherited
Returns
The continuity level of the finite element.

Implemented in libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, and libMesh::InfFE< Dim, T_radial, T_map >.

Referenced by libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubProjector::construct_projection(), and libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::SubFunctor().

◆ get_curl_phi()

template<typename OutputType >
virtual_for_inffe const std::vector< std::vector< OutputShape > > & libMesh::FEGenericBase< OutputType >::get_curl_phi ( ) const
inline

◆ get_curvatures()

virtual_for_inffe const std::vector< Real > & libMesh::FEAbstract::get_curvatures ( ) const
inlineinherited
Returns
The curvatures for use in face integration.

Definition at line 467 of file fe_abstract.h.

468 { calculate_map = true; return this->_fe_map->get_curvatures();}
std::unique_ptr< FEMap > _fe_map

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

◆ get_d2phi()

template<typename OutputType >
const std::vector< std::vector< OutputTensor > > & libMesh::FEGenericBase< OutputType >::get_d2phi ( ) const
inline

◆ get_d2phideta2()

template<typename OutputType >
const std::vector< std::vector< OutputShape > > & libMesh::FEGenericBase< OutputType >::get_d2phideta2 ( ) const
inline

◆ get_d2phidetadzeta()

template<typename OutputType >
const std::vector< std::vector< OutputShape > > & libMesh::FEGenericBase< OutputType >::get_d2phidetadzeta ( ) const
inline

◆ get_d2phidx2()

template<typename OutputType >
const std::vector< std::vector< OutputShape > > & libMesh::FEGenericBase< OutputType >::get_d2phidx2 ( ) const
inline

◆ get_d2phidxdy()

template<typename OutputType >
const std::vector< std::vector< OutputShape > > & libMesh::FEGenericBase< OutputType >::get_d2phidxdy ( ) const
inline

◆ get_d2phidxdz()

template<typename OutputType >
const std::vector< std::vector< OutputShape > > & libMesh::FEGenericBase< OutputType >::get_d2phidxdz ( ) const
inline

◆ get_d2phidxi2()

template<typename OutputType >
const std::vector< std::vector< OutputShape > > & libMesh::FEGenericBase< OutputType >::get_d2phidxi2 ( ) const
inline

◆ get_d2phidxideta()

template<typename OutputType >
const std::vector< std::vector< OutputShape > > & libMesh::FEGenericBase< OutputType >::get_d2phidxideta ( ) const
inline

◆ get_d2phidxidzeta()

template<typename OutputType >
const std::vector< std::vector< OutputShape > > & libMesh::FEGenericBase< OutputType >::get_d2phidxidzeta ( ) const
inline

◆ get_d2phidy2()

template<typename OutputType >
const std::vector< std::vector< OutputShape > > & libMesh::FEGenericBase< OutputType >::get_d2phidy2 ( ) const
inline

◆ get_d2phidydz()

template<typename OutputType >
const std::vector< std::vector< OutputShape > > & libMesh::FEGenericBase< OutputType >::get_d2phidydz ( ) const
inline

◆ get_d2phidz2()

template<typename OutputType >
const std::vector< std::vector< OutputShape > > & libMesh::FEGenericBase< OutputType >::get_d2phidz2 ( ) const
inline

◆ get_d2phidzeta2()

template<typename OutputType >
const std::vector< std::vector< OutputShape > > & libMesh::FEGenericBase< OutputType >::get_d2phidzeta2 ( ) const
inline

◆ get_d2xyzdeta2()

virtual_for_inffe const std::vector< RealGradient > & libMesh::FEAbstract::get_d2xyzdeta2 ( ) const
inlineinherited
Returns
The second partial derivatives in eta.

Definition at line 343 of file fe_abstract.h.

344 { calculate_map = true; return this->_fe_map->get_d2xyzdeta2(); }

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

◆ get_d2xyzdetadzeta()

virtual_for_inffe const std::vector< RealGradient > & libMesh::FEAbstract::get_d2xyzdetadzeta ( ) const
inlineinherited
Returns
The second partial derivatives in eta-zeta.

Definition at line 371 of file fe_abstract.h.

372 { calculate_map = true; return this->_fe_map->get_d2xyzdetadzeta(); }

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

◆ get_d2xyzdxi2()

virtual_for_inffe const std::vector< RealGradient > & libMesh::FEAbstract::get_d2xyzdxi2 ( ) const
inlineinherited
Returns
The second partial derivatives in xi.

Definition at line 336 of file fe_abstract.h.

337 { calculate_map = true; return this->_fe_map->get_d2xyzdxi2(); }

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

◆ get_d2xyzdxideta()

virtual_for_inffe const std::vector< RealGradient > & libMesh::FEAbstract::get_d2xyzdxideta ( ) const
inlineinherited
Returns
The second partial derivatives in xi-eta.

Definition at line 357 of file fe_abstract.h.

358 { calculate_map = true; return this->_fe_map->get_d2xyzdxideta(); }

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

◆ get_d2xyzdxidzeta()

virtual_for_inffe const std::vector< RealGradient > & libMesh::FEAbstract::get_d2xyzdxidzeta ( ) const
inlineinherited
Returns
The second partial derivatives in xi-zeta.

Definition at line 364 of file fe_abstract.h.

365 { calculate_map = true; return this->_fe_map->get_d2xyzdxidzeta(); }

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

◆ get_d2xyzdzeta2()

virtual_for_inffe const std::vector< RealGradient > & libMesh::FEAbstract::get_d2xyzdzeta2 ( ) const
inlineinherited
Returns
The second partial derivatives in zeta.

Definition at line 350 of file fe_abstract.h.

351 { calculate_map = true; return this->_fe_map->get_d2xyzdzeta2(); }

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

◆ get_detadx()

virtual_for_inffe const std::vector< Real > & libMesh::FEAbstract::get_detadx ( ) const
inlineinherited
Returns
The deta/dx entry in the transformation matrix from physical to local coordinates.

Definition at line 405 of file fe_abstract.h.

406 { calculate_map = true; return this->_fe_map->get_detadx(); }

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

◆ get_detady()

virtual_for_inffe const std::vector< Real > & libMesh::FEAbstract::get_detady ( ) const
inlineinherited
Returns
The deta/dy entry in the transformation matrix from physical to local coordinates.

Definition at line 413 of file fe_abstract.h.

414 { calculate_map = true; return this->_fe_map->get_detady(); }

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

◆ get_detadz()

virtual_for_inffe const std::vector< Real > & libMesh::FEAbstract::get_detadz ( ) const
inlineinherited
Returns
The deta/dz entry in the transformation matrix from physical to local coordinates.

Definition at line 421 of file fe_abstract.h.

422 { calculate_map = true; return this->_fe_map->get_detadz(); }

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

◆ get_dim()

unsigned int libMesh::FEAbstract::get_dim ( ) const
inlineinherited
Returns
the dimension of this FE

Definition at line 258 of file fe_abstract.h.

259 { return dim; }

References libMesh::FEAbstract::dim.

◆ get_div_phi()

template<typename OutputType >
virtual_for_inffe const std::vector< std::vector< OutputDivergence > > & libMesh::FEGenericBase< OutputType >::get_div_phi ( ) const
inline

◆ get_dphase()

template<typename OutputType >
const std::vector< OutputGradient > & libMesh::FEGenericBase< OutputType >::get_dphase ( ) const
inline
Returns
The global first derivative of the phase term which is used in infinite elements, evaluated at the quadrature points.

In case of the general finite element class FE this field is initialized to all zero, so that the variational formulation for an infinite element produces correct element matrices for a mesh using both finite and infinite elements.

Definition at line 475 of file fe_base.h.

476 { return dphase; }

References libMesh::FEGenericBase< OutputType >::dphase.

Referenced by assemble_SchroedingerEquation(), and assemble_wave().

◆ get_dphi()

template<typename OutputType >
const std::vector< std::vector< OutputGradient > > & libMesh::FEGenericBase< OutputType >::get_dphi ( ) const
inline
Returns
The shape function derivatives at the quadrature points.

Definition at line 252 of file fe_base.h.

References libMesh::FEAbstract::calculate_dphi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::dphi, and libMesh::libmesh_assert().

Referenced by libMesh::ExactSolution::_compute_error(), assembly_with_dg_fem_context(), libMesh::FEMContext::build_new_fe(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubProjector::construct_projection(), CoupledSystem::element_constraint(), NavierSystem::element_constraint(), LaplaceSystem::element_time_derivative(), CoupledSystem::element_time_derivative(), HeatSystem::element_time_derivative(), PoissonSystem::element_time_derivative(), NavierSystem::element_time_derivative(), SolidSystem::element_time_derivative(), ElasticitySystem::element_time_derivative(), SigmaPhysics::element_time_derivative(), NonlinearDiffusionSystem::element_time_derivative(), libMesh::OldSolutionCoefs< Output, point_output >::eval_at_point(), libMesh::ExactErrorEstimator::find_squared_element_error(), libMesh::FEMContext::fixed_point_gradient(), libMesh::FEGenericBase< OutputType >::get_dphi_over_decay(), libMesh::FEGenericBase< OutputType >::get_dphi_over_decayxR(), libMesh::ParsedFEMFunction< Output >::init_context(), LaplaceSystem::init_context(), CoupledSystem::init_context(), HeatSystem::init_context(), PoissonSystem::init_context(), NavierSystem::init_context(), SolidSystem::init_context(), ElasticitySystem::init_context(), SigmaPhysics::init_context(), NonlinearDiffusionSystem::init_context(), ElasticityRBConstruction::init_context(), libMesh::KellyErrorEstimator::init_context(), HilbertSystem::init_context(), libMesh::FEMContext::interior_gradients(), libMesh::FEMContext::point_gradient(), libMesh::FEGenericBase< OutputType >::request_dphi(), libMesh::FEMContext::side_gradient(), libMesh::FEMContext::side_gradients(), LaplaceSystem::side_qoi_derivative(), and libMesh::FEMContext::some_gradient().

◆ get_dphi_over_decay()

template<typename OutputType >
virtual const std::vector< std::vector< OutputGradient > > & libMesh::FEGenericBase< OutputType >::get_dphi_over_decay ( ) const
inlinevirtual
Returns
the gradient of the shape function (see get_dphi()), but in case of InfFE, weighted with 1/decay.

In contrast to the shape function, its gradient stays finite when divided by the decay function.

Reimplemented in libMesh::InfFE< Dim, T_radial, T_map >.

Definition at line 549 of file fe_base.h.

550 { return get_dphi();}
const std::vector< std::vector< OutputGradient > > & get_dphi() const
Definition fe_base.h:252

References libMesh::FEGenericBase< OutputType >::get_dphi().

◆ get_dphi_over_decayxR()

template<typename OutputType >
virtual const std::vector< std::vector< OutputGradient > > & libMesh::FEGenericBase< OutputType >::get_dphi_over_decayxR ( ) const
inlinevirtual
Returns
the gradient of the shape function (see get_dphi()), but in case of InfFE, weighted with r/decay. See get_phi_over_decayxR() for details.

Reimplemented in libMesh::InfFE< Dim, T_radial, T_map >.

Definition at line 539 of file fe_base.h.

540 { return get_dphi();}

References libMesh::FEGenericBase< OutputType >::get_dphi().

Referenced by assemble_func(), assemble_SchroedingerEquation(), and assemble_wave().

◆ get_dphideta()

template<typename OutputType >
const std::vector< std::vector< OutputShape > > & libMesh::FEGenericBase< OutputType >::get_dphideta ( ) const
inline

◆ get_dphidx()

template<typename OutputType >
const std::vector< std::vector< OutputShape > > & libMesh::FEGenericBase< OutputType >::get_dphidx ( ) const
inline

◆ get_dphidxi()

template<typename OutputType >
const std::vector< std::vector< OutputShape > > & libMesh::FEGenericBase< OutputType >::get_dphidxi ( ) const
inline

◆ get_dphidy()

template<typename OutputType >
const std::vector< std::vector< OutputShape > > & libMesh::FEGenericBase< OutputType >::get_dphidy ( ) const
inline

◆ get_dphidz()

template<typename OutputType >
const std::vector< std::vector< OutputShape > > & libMesh::FEGenericBase< OutputType >::get_dphidz ( ) const
inline

◆ get_dphidzeta()

template<typename OutputType >
const std::vector< std::vector< OutputShape > > & libMesh::FEGenericBase< OutputType >::get_dphidzeta ( ) const
inline

◆ get_dual_coeff()

template<typename OutputType >
const DenseMatrix< Real > & libMesh::FEGenericBase< OutputType >::get_dual_coeff ( ) const
inline
Returns
The coefficients expressing the dual basis in the primal basis.
Note
See get_dual_phi() for the QUAD8/TRI6 caveat.

Definition at line 276 of file fe_base.h.

277 { return dual_coeff; }

References libMesh::FEGenericBase< OutputType >::dual_coeff.

◆ get_dual_d2phi()

template<typename OutputType >
const std::vector< std::vector< OutputTensor > > & libMesh::FEGenericBase< OutputType >::get_dual_d2phi ( ) const
inline
Returns
The dual shape function second derivatives at the quadrature points.
Note
See get_dual_phi() for the QUAD8/TRI6 caveat.

Definition at line 361 of file fe_base.h.

bool calculate_dual
Are we calculating dual basis?

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculate_dual, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::dual_d2phi, and libMesh::libmesh_assert().

◆ get_dual_dphi()

template<typename OutputType >
const std::vector< std::vector< OutputGradient > > & libMesh::FEGenericBase< OutputType >::get_dual_dphi ( ) const
inline

◆ get_dual_phi()

template<typename OutputType >
const std::vector< std::vector< OutputShape > > & libMesh::FEGenericBase< OutputType >::get_dual_phi ( ) const
inline
Returns
The dual (biorthogonal) shape function values at the quadrature points on the element.

The dual basis is constructed to satisfy \( \int \Phi_j N_k \, d\gamma = \delta_{jk} \int N_k \, d\gamma \) against the primal basis \( N \). That biorthogonality is what makes a mortar coupling matrix diagonal, so a Lagrange multiplier can be condensed with a diagonal inverse.

Note
For SECOND order LAGRANGE and L2_LAGRANGE on QUAD8, TRI6 and TRI7 these functions are biorthogonal to a locally transformed primal basis rather than to \( N \) itself: \( \int N_k \) is not positive on those faces (exactly 0 at a TRI6 vertex, -1/3 at a QUAD8 corner), so the usual construction degenerates. For those element types \( \int \Phi_j N_k \) is therefore not diagonal; it factors as \( D = \tilde{D} T^{-1} \) with \( \tilde{D} \) diagonal, leaving \( D^{-1} = T \tilde{D}^{-1} \) sparse and cheap to apply. The functions returned here are still expressed in the primal basis, so the type and meaning of this return value are unchanged. See Popp, Wohlmuth, Gee and Wall, SIAM J. Sci. Comput. 34(4):B421-B446, 2012, Sec. 4.4.1 and Eq. (4.12).

Definition at line 233 of file fe_base.h.

234 {
236 calculate_dual = true;
237 // Dual phi computation relies on primal phi computation
238 this->request_phi();
239 return dual_phi;
240 }
virtual void request_phi() const override
request phi calculations
Definition fe_base.h:242

References libMesh::FEAbstract::calculate_dual, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::dual_phi, libMesh::libmesh_assert(), and libMesh::FEGenericBase< OutputType >::request_phi().

Referenced by libMesh::FEGenericBase< OutputType >::request_dual_phi().

◆ get_dxidx()

virtual_for_inffe const std::vector< Real > & libMesh::FEAbstract::get_dxidx ( ) const
inlineinherited
Returns
The dxi/dx entry in the transformation matrix from physical to local coordinates.

Definition at line 381 of file fe_abstract.h.

382 { calculate_map = true; return this->_fe_map->get_dxidx(); }

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

◆ get_dxidy()

virtual_for_inffe const std::vector< Real > & libMesh::FEAbstract::get_dxidy ( ) const
inlineinherited
Returns
The dxi/dy entry in the transformation matrix from physical to local coordinates.

Definition at line 389 of file fe_abstract.h.

390 { calculate_map = true; return this->_fe_map->get_dxidy(); }

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

◆ get_dxidz()

virtual_for_inffe const std::vector< Real > & libMesh::FEAbstract::get_dxidz ( ) const
inlineinherited
Returns
The dxi/dz entry in the transformation matrix from physical to local coordinates.

Definition at line 397 of file fe_abstract.h.

398 { calculate_map = true; return this->_fe_map->get_dxidz(); }

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

◆ get_dxyzdeta()

virtual_for_inffe const std::vector< RealGradient > & libMesh::FEAbstract::get_dxyzdeta ( ) const
inlineinherited
Returns
The element tangents in eta-direction at the quadrature points.

Definition at line 319 of file fe_abstract.h.

320 { calculate_map = true; return this->_fe_map->get_dxyzdeta(); }

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

◆ get_dxyzdxi()

virtual_for_inffe const std::vector< RealGradient > & libMesh::FEAbstract::get_dxyzdxi ( ) const
inlineinherited
Returns
The element tangents in xi-direction at the quadrature points.

Definition at line 311 of file fe_abstract.h.

312 { calculate_map = true; return this->_fe_map->get_dxyzdxi(); }

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

◆ get_dxyzdzeta()

virtual_for_inffe const std::vector< RealGradient > & libMesh::FEAbstract::get_dxyzdzeta ( ) const
inlineinherited
Returns
The element tangents in zeta-direction at the quadrature points.

Definition at line 327 of file fe_abstract.h.

328 { return _fe_map->get_dxyzdzeta(); }

References libMesh::FEAbstract::_fe_map.

◆ get_dzetadx()

virtual_for_inffe const std::vector< Real > & libMesh::FEAbstract::get_dzetadx ( ) const
inlineinherited
Returns
The dzeta/dx entry in the transformation matrix from physical to local coordinates.

Definition at line 429 of file fe_abstract.h.

430 { calculate_map = true; return this->_fe_map->get_dzetadx(); }

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

◆ get_dzetady()

virtual_for_inffe const std::vector< Real > & libMesh::FEAbstract::get_dzetady ( ) const
inlineinherited
Returns
The dzeta/dy entry in the transformation matrix from physical to local coordinates.

Definition at line 437 of file fe_abstract.h.

438 { calculate_map = true; return this->_fe_map->get_dzetady(); }

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

◆ get_dzetadz()

virtual_for_inffe const std::vector< Real > & libMesh::FEAbstract::get_dzetadz ( ) const
inlineinherited
Returns
The dzeta/dz entry in the transformation matrix from physical to local coordinates.

Definition at line 445 of file fe_abstract.h.

446 { calculate_map = true; return this->_fe_map->get_dzetadz(); }

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

◆ get_elem()

const Elem * libMesh::FEAbstract::get_elem ( ) const
inlineinherited
Returns
The element that the current shape functions have been calculated for. Useful in determining when shape functions must be recomputed.

Definition at line 496 of file fe_abstract.h.

496{ return _elem; }

References libMesh::FEAbstract::_elem.

◆ get_family()

FEFamily libMesh::FEAbstract::get_family ( ) const
inlineinherited
Returns
The finite element family of this element.

Definition at line 547 of file fe_abstract.h.

547{ return fe_type.family; }

References libMesh::FEType::family, and libMesh::FEAbstract::fe_type.

Referenced by libMesh::FE< Dim, T >::FE().

◆ get_fe_map() [1/2]

FEMap & libMesh::FEAbstract::get_fe_map ( )
inlineinherited

Definition at line 555 of file fe_abstract.h.

555{ return *_fe_map.get(); }

References libMesh::FEAbstract::_fe_map.

◆ get_fe_map() [2/2]

const FEMap & libMesh::FEAbstract::get_fe_map ( ) const
inlineinherited

◆ get_fe_type()

FEType libMesh::FEAbstract::get_fe_type ( ) const
inlineinherited

◆ get_info()

std::string libMesh::ReferenceCounter::get_info ( )
staticinherited

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

48{
49#if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
50
51 std::ostringstream oss;
52
53 oss << '\n'
54 << " ---------------------------------------------------------------------------- \n"
55 << "| Reference count information |\n"
56 << " ---------------------------------------------------------------------------- \n";
57
58 for (const auto & [name, cd] : _counts)
59 oss << "| " << name << " reference count information:\n"
60 << "| Creations: " << cd.first << '\n'
61 << "| Destructions: " << cd.second << '\n';
62
63 oss << " ---------------------------------------------------------------------------- \n";
64
65 return oss.str();
66
67#else
68
69 return "";
70
71#endif
72}
static Counts _counts
Actually holds the data.
std::string name(const ElemQuality q)
This function returns a string containing some name for q.

References libMesh::ReferenceCounter::_counts.

Referenced by libMesh::ReferenceCounter::print_info().

◆ get_JxW()

virtual_for_inffe const std::vector< Real > & libMesh::FEAbstract::get_JxW ( ) const
inlineinherited
Returns
The element Jacobian times the quadrature weight for each quadrature point.

For InfFE, use get_JxWxdecay_sq() instead.

Definition at line 303 of file fe_abstract.h.

304 { calculate_map = true; return this->_fe_map->get_JxW(); }

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

Referenced by libMesh::ExactSolution::_compute_error(), assembly_with_dg_fem_context(), libMesh::DiscontinuityMeasure::boundary_side_integration(), libMesh::KellyErrorEstimator::boundary_side_integration(), compute_enriched_soln(), libMesh::FirstOrderUnsteadySolver::compute_second_order_eqns(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubProjector::construct_projection(), CoupledSystem::element_constraint(), NavierSystem::element_constraint(), LaplaceSystem::element_postprocess(), PoissonSystem::element_postprocess(), LaplaceQoI::element_qoi(), HeatSystem::element_qoi(), HeatSystem::element_qoi_derivative(), LaplaceSystem::element_qoi_derivative(), LaplaceQoI::element_qoi_derivative(), LaplaceSystem::element_time_derivative(), CoupledSystem::element_time_derivative(), HeatSystem::element_time_derivative(), PoissonSystem::element_time_derivative(), NavierSystem::element_time_derivative(), SolidSystem::element_time_derivative(), ElasticitySystem::element_time_derivative(), CurlCurlSystem::element_time_derivative(), SigmaPhysics::element_time_derivative(), NonlinearDiffusionSystem::element_time_derivative(), libMesh::ExactErrorEstimator::find_squared_element_error(), libMesh::FEAbstract::get_JxWxdecay_sq(), CoupledSystemQoI::init_context(), libMesh::FEMSystem::init_context(), LaplaceSystem::init_context(), LaplaceQoI::init_context(), CoupledSystem::init_context(), HeatSystem::init_context(), PoissonSystem::init_context(), NavierSystem::init_context(), SolidSystem::init_context(), ElasticitySystem::init_context(), CurlCurlSystem::init_context(), SigmaPhysics::init_context(), NonlinearDiffusionSystem::init_context(), ElasticityRBConstruction::init_context(), libMesh::DiscontinuityMeasure::init_context(), HilbertSystem::init_context(), libMesh::DiscontinuityMeasure::internal_side_integration(), libMesh::LaplacianErrorEstimator::internal_side_integration(), libMesh::KellyErrorEstimator::internal_side_integration(), libMesh::FEMPhysics::mass_residual(), NavierSystem::mass_residual(), ElasticitySystem::mass_residual(), Integrate::operator()(), LaplaceSystem::side_constraint(), LaplaceSystem::side_postprocess(), CoupledSystemQoI::side_qoi(), LaplaceSystem::side_qoi_derivative(), CoupledSystemQoI::side_qoi_derivative(), SolidSystem::side_time_derivative(), ElasticitySystem::side_time_derivative(), CurlCurlSystem::side_time_derivative(), and libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::SubFunctor().

◆ get_JxWxdecay_sq()

virtual const std::vector< Real > & libMesh::FEAbstract::get_JxWxdecay_sq ( ) const
inlinevirtualinherited

This function is the variant of get_JxW() for InfFE.

Since J diverges there, a respectize decay-function must be applied to obtain well-defined quantities.

For FE, it is equivalent to the common get_JxW().

Reimplemented in libMesh::InfFE< Dim, T_radial, T_map >.

Definition at line 292 of file fe_abstract.h.

293 { return get_JxW();}
virtual_for_inffe const std::vector< Real > & get_JxW() const

References libMesh::FEAbstract::get_JxW().

Referenced by assemble_func(), assemble_SchroedingerEquation(), and assemble_wave().

◆ get_normals()

virtual_for_inffe const std::vector< Point > & libMesh::FEAbstract::get_normals ( ) const
inlineinherited

◆ get_nothing()

void libMesh::FEAbstract::get_nothing ( ) const
inlineinherited
Returns
nothing, but lets the FE know you're explicitly prerequesting calculations. This is useful when you only want the FE for n_quadrature_points, n_dofs_on_side, or other methods that don't require shape function calculations, but you don't want libMesh "backwards compatibility" mode to assume you've made no prerequests and need to calculate everything.

Definition at line 269 of file fe_abstract.h.

270 { calculate_nothing = true; }

References libMesh::FEAbstract::calculate_nothing.

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::ParsedFEMFunction< Output >::init_context(), libMesh::WrappedFunctor< Output >::init_context(), CoupledSystemQoI::init_context(), CoupledSystem::init_context(), HeatSystem::init_context(), NavierSystem::init_context(), ElasticitySystem::init_context(), SigmaPhysics::init_context(), NonlinearDiffusionSystem::init_context(), HilbertSystem::init_context(), libMesh::VariationalSmootherSystem::init_context(), and Integrate::operator()().

◆ get_order()

Order libMesh::FEAbstract::get_order ( ) const
inlineinherited
Returns
The approximation order of the finite element.

Definition at line 525 of file fe_abstract.h.

526 { return fe_type.order + _p_level; }
unsigned int _p_level
The p refinement level the current data structures are set up for.

References libMesh::FEAbstract::_p_level, libMesh::FEAbstract::fe_type, and libMesh::FEType::order.

◆ get_p_level()

unsigned int libMesh::FEAbstract::get_p_level ( ) const
inlineinherited
Returns
The p refinement level that the current shape functions have been calculated for.

Definition at line 515 of file fe_abstract.h.

515{ return _p_level; }

References libMesh::FEAbstract::_p_level.

◆ get_phi()

template<typename OutputType >
const std::vector< std::vector< OutputShape > > & libMesh::FEGenericBase< OutputType >::get_phi ( ) const
inline
Returns
The shape function values at the quadrature points on the element.

Definition at line 207 of file fe_base.h.

References libMesh::FEAbstract::calculate_phi, libMesh::FEAbstract::calculations_started, libMesh::libmesh_assert(), and libMesh::FEGenericBase< OutputType >::phi.

Referenced by libMesh::ExactSolution::_compute_error(), assembly_with_dg_fem_context(), libMesh::FEMContext::build_new_fe(), compute_enriched_soln(), libMesh::FirstOrderUnsteadySolver::compute_second_order_eqns(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubProjector::construct_projection(), CoupledSystem::element_constraint(), NavierSystem::element_constraint(), HeatSystem::element_qoi_derivative(), LaplaceSystem::element_qoi_derivative(), LaplaceQoI::element_qoi_derivative(), CoupledSystem::element_time_derivative(), HeatSystem::element_time_derivative(), PoissonSystem::element_time_derivative(), NavierSystem::element_time_derivative(), ElasticitySystem::element_time_derivative(), CurlCurlSystem::element_time_derivative(), SigmaPhysics::element_time_derivative(), NonlinearDiffusionSystem::element_time_derivative(), libMesh::OldSolutionCoefs< Output, point_output >::eval_at_point(), libMesh::ExactErrorEstimator::find_squared_element_error(), libMesh::FEMContext::fixed_point_value(), libMesh::FEGenericBase< OutputType >::get_phi_over_decayxR(), libMesh::ParsedFEMFunction< Output >::init_context(), CoupledSystemQoI::init_context(), libMesh::FEMSystem::init_context(), LaplaceSystem::init_context(), LaplaceQoI::init_context(), CoupledSystem::init_context(), HeatSystem::init_context(), PoissonSystem::init_context(), NavierSystem::init_context(), SolidSystem::init_context(), ElasticitySystem::init_context(), CurlCurlSystem::init_context(), SigmaPhysics::init_context(), NonlinearDiffusionSystem::init_context(), ElasticityRBConstruction::init_context(), libMesh::DiscontinuityMeasure::init_context(), HilbertSystem::init_context(), libMesh::FEMContext::interior_values(), libMesh::FEMPhysics::mass_residual(), NavierSystem::mass_residual(), ElasticitySystem::mass_residual(), libMesh::FEMContext::point_value(), libMesh::FEGenericBase< OutputType >::request_phi(), LaplaceSystem::side_constraint(), CoupledSystemQoI::side_qoi_derivative(), SolidSystem::side_time_derivative(), ElasticitySystem::side_time_derivative(), CurlCurlSystem::side_time_derivative(), libMesh::FEMContext::side_values(), libMesh::FEMContext::some_value(), InfFERadialTest::testRefinement(), SlitMeshRefinedSystemTest::testRestart(), and SlitMeshRefinedSystemTest::testSystem().

◆ get_phi_over_decayxR()

template<typename OutputType >
virtual const std::vector< std::vector< OutputShape > > & libMesh::FEGenericBase< OutputType >::get_phi_over_decayxR ( ) const
inlinevirtual
Returns
The shape function phi (for FE) and phi weighted by r/decay for InfFE.

To compensate for the decay function applied to the Jacobian (see get_JxWxdecay_sq), the wave function phi should be divided by this function.

The factor r must be compensated for by the Sobolev weight. (i.e. by using get_Sobolev_weightxR_sq())

Reimplemented in libMesh::InfFE< Dim, T_radial, T_map >.

Definition at line 531 of file fe_base.h.

532 { return get_phi();}
const std::vector< std::vector< OutputShape > > & get_phi() const
Definition fe_base.h:207

References libMesh::FEGenericBase< OutputType >::get_phi().

Referenced by assemble_func(), assemble_SchroedingerEquation(), and assemble_wave().

◆ get_refspace_nodes()

void libMesh::FEAbstract::get_refspace_nodes ( const ElemType  t,
std::vector< Point > &  nodes 
)
staticinherited
Returns
The reference space coordinates of nodes based on the element type.

Definition at line 412 of file fe_abstract.C.

413{
414 const unsigned int n_nodes = Elem::type_to_n_nodes_map[itemType];
415 if (n_nodes == invalid_uint)
416 libmesh_error_msg("Number of nodes is not well-defined for " <<
417 Utility::enum_to_string(itemType));
418
419 nodes.resize(n_nodes);
420 switch(itemType)
421 {
422 case NODEELEM:
423 {
424 nodes[0] = Point (0.,0.,0.);
425 return;
426 }
427 case EDGE3:
428 {
429 nodes[2] = Point (0.,0.,0.);
430 libmesh_fallthrough();
431 }
432 case EDGE2:
433 {
434 nodes[0] = Point (-1.,0.,0.);
435 nodes[1] = Point (1.,0.,0.);
436 return;
437 }
438 case EDGE4: // not nested with EDGE3
439 {
440 nodes[0] = Point (-1.,0.,0.);
441 nodes[1] = Point (1.,0.,0.);
442 nodes[2] = Point (-1./3.,0.,0.);
443 nodes[3] = Point (1./3.,0.,0.);
444 return;
445 }
446 case TRI7:
447 {
448 nodes[6] = Point (1./3.,1./3.,0.);
449 libmesh_fallthrough();
450 }
451 case TRI6:
452 {
453 nodes[3] = Point (.5,0.,0.);
454 nodes[4] = Point (.5,.5,0.);
455 nodes[5] = Point (0.,.5,0.);
456 libmesh_fallthrough();
457 }
458 case TRI3:
459 case TRISHELL3:
460 {
461 nodes[0] = Point (0.,0.,0.);
462 nodes[1] = Point (1.,0.,0.);
463 nodes[2] = Point (0.,1.,0.);
464 return;
465 }
466 case QUAD9:
467 case QUADSHELL9:
468 {
469 nodes[8] = Point (0.,0.,0.);
470 libmesh_fallthrough();
471 }
472 case QUAD8:
473 case QUADSHELL8:
474 {
475 nodes[4] = Point (0.,-1.,0.);
476 nodes[5] = Point (1.,0.,0.);
477 nodes[6] = Point (0.,1.,0.);
478 nodes[7] = Point (-1.,0.,0.);
479 libmesh_fallthrough();
480 }
481 case QUAD4:
482 case QUADSHELL4:
483 {
484 nodes[0] = Point (-1.,-1.,0.);
485 nodes[1] = Point (1.,-1.,0.);
486 nodes[2] = Point (1.,1.,0.);
487 nodes[3] = Point (-1.,1.,0.);
488 return;
489 }
490 case TET14:
491 {
492 nodes[10] = Point (1/Real(3),1/Real(3),0.);
493 nodes[11] = Point (1/Real(3),0.,1/Real(3));
494 nodes[12] = Point (1/Real(3),1/Real(3),1/Real(3));
495 nodes[13] = Point (0.,1/Real(3),1/Real(3));
496 libmesh_fallthrough();
497 }
498 case TET10:
499 {
500 nodes[4] = Point (.5,0.,0.);
501 nodes[5] = Point (.5,.5,0.);
502 nodes[6] = Point (0.,.5,0.);
503 nodes[7] = Point (0.,0.,.5);
504 nodes[8] = Point (.5,0.,.5);
505 nodes[9] = Point (0.,.5,.5);
506 libmesh_fallthrough();
507 }
508 case TET4:
509 {
510 nodes[0] = Point (0.,0.,0.);
511 nodes[1] = Point (1.,0.,0.);
512 nodes[2] = Point (0.,1.,0.);
513 nodes[3] = Point (0.,0.,1.);
514 return;
515 }
516 case HEX27:
517 {
518 nodes[20] = Point (0.,0.,-1.);
519 nodes[21] = Point (0.,-1.,0.);
520 nodes[22] = Point (1.,0.,0.);
521 nodes[23] = Point (0.,1.,0.);
522 nodes[24] = Point (-1.,0.,0.);
523 nodes[25] = Point (0.,0.,1.);
524 nodes[26] = Point (0.,0.,0.);
525 libmesh_fallthrough();
526 }
527 case HEX20:
528 {
529 nodes[8] = Point (0.,-1.,-1.);
530 nodes[9] = Point (1.,0.,-1.);
531 nodes[10] = Point (0.,1.,-1.);
532 nodes[11] = Point (-1.,0.,-1.);
533 nodes[12] = Point (-1.,-1.,0.);
534 nodes[13] = Point (1.,-1.,0.);
535 nodes[14] = Point (1.,1.,0.);
536 nodes[15] = Point (-1.,1.,0.);
537 nodes[16] = Point (0.,-1.,1.);
538 nodes[17] = Point (1.,0.,1.);
539 nodes[18] = Point (0.,1.,1.);
540 nodes[19] = Point (-1.,0.,1.);
541 libmesh_fallthrough();
542 }
543 case HEX8:
544 {
545 nodes[0] = Point (-1.,-1.,-1.);
546 nodes[1] = Point (1.,-1.,-1.);
547 nodes[2] = Point (1.,1.,-1.);
548 nodes[3] = Point (-1.,1.,-1.);
549 nodes[4] = Point (-1.,-1.,1.);
550 nodes[5] = Point (1.,-1.,1.);
551 nodes[6] = Point (1.,1.,1.);
552 nodes[7] = Point (-1.,1.,1.);
553 return;
554 }
555 case PRISM21:
556 {
557 nodes[20] = Point (1/Real(3),1/Real(3),0);
558 libmesh_fallthrough();
559 }
560 case PRISM20:
561 {
562 nodes[18] = Point (1/Real(3),1/Real(3),-1);
563 nodes[19] = Point (1/Real(3),1/Real(3),1);
564 libmesh_fallthrough();
565 }
566 case PRISM18:
567 {
568 nodes[15] = Point (.5,0.,0.);
569 nodes[16] = Point (.5,.5,0.);
570 nodes[17] = Point (0.,.5,0.);
571 libmesh_fallthrough();
572 }
573 case PRISM15:
574 {
575 nodes[6] = Point (.5,0.,-1.);
576 nodes[7] = Point (.5,.5,-1.);
577 nodes[8] = Point (0.,.5,-1.);
578 nodes[9] = Point (0.,0.,0.);
579 nodes[10] = Point (1.,0.,0.);
580 nodes[11] = Point (0.,1.,0.);
581 nodes[12] = Point (.5,0.,1.);
582 nodes[13] = Point (.5,.5,1.);
583 nodes[14] = Point (0.,.5,1.);
584 libmesh_fallthrough();
585 }
586 case PRISM6:
587 {
588 nodes[0] = Point (0.,0.,-1.);
589 nodes[1] = Point (1.,0.,-1.);
590 nodes[2] = Point (0.,1.,-1.);
591 nodes[3] = Point (0.,0.,1.);
592 nodes[4] = Point (1.,0.,1.);
593 nodes[5] = Point (0.,1.,1.);
594 return;
595 }
596 case PYRAMID18:
597 {
598 // triangle centers
599 nodes[14] = Point (0., -2/Real(3),1/Real(3));
600 nodes[15] = Point (2/Real(3),0.,1/Real(3));
601 nodes[16] = Point (0.,2/Real(3),1/Real(3));
602 nodes[17] = Point (-2/Real(3),0.,1/Real(3));
603
604 libmesh_fallthrough();
605 }
606 case PYRAMID14:
607 {
608 // base center
609 nodes[13] = Point (0.,0.,0.);
610
611 libmesh_fallthrough();
612 }
613 case PYRAMID13:
614 {
615 // base midedge
616 nodes[5] = Point (0.,-1.,0.);
617 nodes[6] = Point (1.,0.,0.);
618 nodes[7] = Point (0.,1.,0.);
619 nodes[8] = Point (-1,0.,0.);
620
621 // lateral midedge
622 nodes[9] = Point (-.5,-.5,.5);
623 nodes[10] = Point (.5,-.5,.5);
624 nodes[11] = Point (.5,.5,.5);
625 nodes[12] = Point (-.5,.5,.5);
626
627 libmesh_fallthrough();
628 }
629 case PYRAMID5:
630 {
631 // base corners
632 nodes[0] = Point (-1.,-1.,0.);
633 nodes[1] = Point (1.,-1.,0.);
634 nodes[2] = Point (1.,1.,0.);
635 nodes[3] = Point (-1.,1.,0.);
636 // apex
637 nodes[4] = Point (0.,0.,1.);
638 return;
639 }
640
641 default:
642 libmesh_error_msg("ERROR: Unknown element type " << Utility::enum_to_string(itemType));
643 }
644}
static constexpr unsigned int type_to_n_nodes_map[INVALID_ELEM]
This array maps the integer representation of the ElemType enum to the number of nodes in the element...
Definition elem.h:664
const unsigned int invalid_uint
A number which is used quite often to represent an invalid or uninitialized value for an unsigned int...
Definition libmesh.h:303

References libMesh::EDGE2, libMesh::EDGE3, libMesh::EDGE4, libMesh::Utility::enum_to_string(), libMesh::HEX20, libMesh::HEX27, libMesh::HEX8, libMesh::invalid_uint, n_nodes, libMesh::NODEELEM, libMesh::PRISM15, libMesh::PRISM18, libMesh::PRISM20, libMesh::PRISM21, libMesh::PRISM6, libMesh::PYRAMID13, libMesh::PYRAMID14, libMesh::PYRAMID18, libMesh::PYRAMID5, libMesh::QUAD4, libMesh::QUAD8, libMesh::QUAD9, libMesh::QUADSHELL4, libMesh::QUADSHELL8, libMesh::QUADSHELL9, libMesh::Real, libMesh::TET10, libMesh::TET14, libMesh::TET4, libMesh::TRI3, libMesh::TRI6, libMesh::TRI7, libMesh::TRISHELL3, and libMesh::Elem::type_to_n_nodes_map.

Referenced by libMesh::l2_lagrange_gll_nodal_soln(), libMesh::LIBMESH_DEFAULT_VECTORIZED_FE(), libMesh::LIBMESH_DEFAULT_VECTORIZED_FE(), libMesh::LIBMESH_DEFAULT_VECTORIZED_FE(), and libMesh::LIBMESH_DEFAULT_VECTORIZED_FE().

◆ get_Sobolev_dweight()

template<typename OutputType >
virtual const std::vector< RealGradient > & libMesh::FEGenericBase< OutputType >::get_Sobolev_dweight ( ) const
inlinevirtual
Returns
The first global derivative of the multiplicative weight at each quadrature point. See get_Sobolev_weight() for details. In case of FE initialized to all zero.

Reimplemented in libMesh::InfFE< Dim, T_radial, T_map >.

Definition at line 499 of file fe_base.h.

500 { return dweight; }

References libMesh::FEGenericBase< OutputType >::dweight.

◆ get_Sobolev_dweightxR_sq()

template<typename OutputType >
virtual const std::vector< RealGradient > & libMesh::FEGenericBase< OutputType >::get_Sobolev_dweightxR_sq ( ) const
inlinevirtual
Returns
The first global derivative of the multiplicative weight (see dget_Sobolev_weight) but weighted with the square of the radial coordinate.

In finite elements, this is 0.

Reimplemented in libMesh::InfFE< Dim, T_radial, T_map >.

Definition at line 518 of file fe_base.h.

519 { return dweight; }

References libMesh::FEGenericBase< OutputType >::dweight.

Referenced by assemble_func(), assemble_SchroedingerEquation(), and assemble_wave().

◆ get_Sobolev_weight()

template<typename OutputType >
virtual const std::vector< Real > & libMesh::FEGenericBase< OutputType >::get_Sobolev_weight ( ) const
inlinevirtual
Returns
The multiplicative weight at each quadrature point. This weight is used for certain infinite element weak formulations, so that weighted Sobolev spaces are used for the trial function space. This renders the variational form easily computable.

In case of the general finite element class FE this field is initialized to all ones, so that the variational formulation for an infinite element produces correct element matrices for a mesh using both finite and infinite elements.

Reimplemented in libMesh::InfFE< Dim, T_radial, T_map >.

Definition at line 491 of file fe_base.h.

492 { return weight; }

References libMesh::FEGenericBase< OutputType >::weight.

◆ get_Sobolev_weightxR_sq()

template<typename OutputType >
virtual const std::vector< Real > & libMesh::FEGenericBase< OutputType >::get_Sobolev_weightxR_sq ( ) const
inlinevirtual
Returns
The multiplicative weight (see get_Sobolev_weight) but weighted with the radial coordinate square.

In finite elements, this gives just 1, similar to get_Sobolev_Weight()

Reimplemented in libMesh::InfFE< Dim, T_radial, T_map >.

Definition at line 508 of file fe_base.h.

509 { return weight; }

References libMesh::FEGenericBase< OutputType >::weight.

Referenced by assemble_func(), assemble_SchroedingerEquation(), and assemble_wave().

◆ get_tangents()

virtual_for_inffe const std::vector< std::vector< Point > > & libMesh::FEAbstract::get_tangents ( ) const
inlineinherited
Returns
The tangent vectors for face integration.

Definition at line 452 of file fe_abstract.h.

453 { calculate_map = true; return this->_fe_map->get_tangents(); }

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

◆ get_type()

ElemType libMesh::FEAbstract::get_type ( ) const
inlineinherited
Returns
The element type that the current shape functions have been calculated for, or INVALID_ELEM if no such element exists. Useful in determining when shape functions must be recomputed.

This is generally redundant with _elem->type(), but must be cached separately for cases (such as internal FE use in QComposite) where _elem might be a dangling pointer to a temporary.

Definition at line 509 of file fe_abstract.h.

509{ return _elem_type; }
ElemType _elem_type
The element type the current data structures were set up for.

References libMesh::FEAbstract::_elem_type.

◆ get_xyz()

virtual_for_inffe const std::vector< Point > & libMesh::FEAbstract::get_xyz ( ) const
inlineinherited
Returns
The xyz spatial locations of the quadrature points on the element.

It is overwritten by infinite elements since there FEMap cannot be used to compute xyz.

Definition at line 280 of file fe_abstract.h.

281 { calculate_map = true; return this->_fe_map->get_xyz(); }

References libMesh::FEAbstract::_fe_map, and libMesh::FEAbstract::calculate_map.

Referenced by libMesh::ExactSolution::_compute_error(), assemble_SchroedingerEquation(), libMesh::DiscontinuityMeasure::boundary_side_integration(), libMesh::KellyErrorEstimator::boundary_side_integration(), compute_enriched_soln(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubProjector::construct_projection(), LaplaceSystem::element_postprocess(), PoissonSystem::element_postprocess(), LaplaceQoI::element_qoi(), LaplaceSystem::element_qoi_derivative(), LaplaceQoI::element_qoi_derivative(), HeatSystem::element_time_derivative(), PoissonSystem::element_time_derivative(), NavierSystem::element_time_derivative(), CurlCurlSystem::element_time_derivative(), SigmaPhysics::element_time_derivative(), NonlinearDiffusionSystem::element_time_derivative(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::ParsedFEMFunction< Output >::eval_args(), libMesh::ExactErrorEstimator::find_squared_element_error(), libMesh::ParsedFEMFunction< Output >::init_context(), CoupledSystemQoI::init_context(), LaplaceSystem::init_context(), LaplaceQoI::init_context(), CoupledSystem::init_context(), HeatSystem::init_context(), PoissonSystem::init_context(), NavierSystem::init_context(), SolidSystem::init_context(), CurlCurlSystem::init_context(), SigmaPhysics::init_context(), NonlinearDiffusionSystem::init_context(), HilbertSystem::init_context(), libMesh::DGFEMContext::neighbor_side_fe_reinit(), Integrate::operator()(), libMesh::JumpErrorEstimator::reinit_sides(), LaplaceSystem::side_constraint(), LaplaceSystem::side_postprocess(), CoupledSystemQoI::side_qoi(), LaplaceSystem::side_qoi_derivative(), CoupledSystemQoI::side_qoi_derivative(), SolidSystem::side_time_derivative(), CurlCurlSystem::side_time_derivative(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::SubFunctor(), SlitMeshRefinedSystemTest::testRestart(), and SlitMeshRefinedSystemTest::testSystem().

◆ increment_constructor_count()

void libMesh::ReferenceCounter::increment_constructor_count ( const std::string &  name)
inlineprotectednoexceptinherited

Increments the construction counter.

Should be called in the constructor of any derived class that will be reference counted.

Definition at line 183 of file reference_counter.h.

184{
185 libmesh_try
186 {
187 Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
188 std::pair<unsigned int, unsigned int> & p = _counts[name];
189 p.first++;
190 }
191 libmesh_catch (...)
192 {
193 auto stream = libMesh::err.get();
194 stream->exceptions(stream->goodbit); // stream must not throw
195 libMesh::err << "Encountered unrecoverable error while calling "
196 << "ReferenceCounter::increment_constructor_count() "
197 << "for a(n) " << name << " object." << std::endl;
198 std::terminate();
199 }
200}
streamT * get()
Rather than implement every ostream/ios/ios_base function, we'll be lazy and make esoteric uses go th...
OStreamProxy err

References libMesh::err, libMesh::BasicOStreamProxy< charT, traits >::get(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< T >::ReferenceCountedObject(), libMesh::ReferenceCountedObject< T >::ReferenceCountedObject(), and libMesh::ReferenceCountedObject< T >::ReferenceCountedObject().

◆ increment_destructor_count()

void libMesh::ReferenceCounter::increment_destructor_count ( const std::string &  name)
inlineprotectednoexceptinherited

Increments the destruction counter.

Should be called in the destructor of any derived class that will be reference counted.

Definition at line 207 of file reference_counter.h.

208{
209 libmesh_try
210 {
211 Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
212 std::pair<unsigned int, unsigned int> & p = _counts[name];
213 p.second++;
214 }
215 libmesh_catch (...)
216 {
217 auto stream = libMesh::err.get();
218 stream->exceptions(stream->goodbit); // stream must not throw
219 libMesh::err << "Encountered unrecoverable error while calling "
220 << "ReferenceCounter::increment_destructor_count() "
221 << "for a(n) " << name << " object." << std::endl;
222 std::terminate();
223 }
224}

References libMesh::err, libMesh::BasicOStreamProxy< charT, traits >::get(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< T >::~ReferenceCountedObject().

◆ init_base_shape_functions()

template<typename OutputType >
virtual void libMesh::FEGenericBase< OutputType >::init_base_shape_functions ( const std::vector< Point > &  qp,
const Elem *  e 
)
protectedpure virtual

◆ is_hierarchic()

virtual bool libMesh::FEAbstract::is_hierarchic ( ) const
pure virtualinherited
Returns
true if the finite element's higher order shape functions are hierarchic

Implemented in libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, and libMesh::InfFE< Dim, T_radial, T_map >.

◆ n_objects()

static unsigned int libMesh::ReferenceCounter::n_objects ( )
inlinestaticinherited

Prints the number of outstanding (created, but not yet destroyed) objects.

Definition at line 85 of file reference_counter.h.

86 { return _n_objects; }
static Threads::atomic< unsigned int > _n_objects
The number of objects.

References libMesh::ReferenceCounter::_n_objects.

Referenced by libMesh::LibMeshInit::~LibMeshInit().

◆ n_quadrature_points()

unsigned int libMesh::FEAbstract::n_quadrature_points ( ) const
virtualinherited
Returns
The total number of quadrature points with which this was last reinitialized. Useful during matrix assembly.

Reimplemented in libMesh::InfFE< Dim, T_radial, T_map >.

Definition at line 1291 of file fe_abstract.C.

1292{
1293 if (this->shapes_on_quadrature)
1294 {
1295 libmesh_assert(this->qrule);
1296 libmesh_assert_equal_to(this->qrule->n_points(),
1297 this->_n_total_qp);
1298 }
1299 return this->_n_total_qp;
1300}
bool shapes_on_quadrature
A flag indicating if current data structures correspond to quadrature rule points.
unsigned int _n_total_qp
The total number of quadrature points for the current configuration.

References libMesh::FEAbstract::_n_total_qp, libMesh::libmesh_assert(), libMesh::QBase::n_points(), libMesh::FEAbstract::qrule, and libMesh::FEAbstract::shapes_on_quadrature.

Referenced by assemble_func(), assemble_SchroedingerEquation(), assemble_wave(), libMesh::DiscontinuityMeasure::boundary_side_integration(), libMesh::KellyErrorEstimator::boundary_side_integration(), libMesh::DiscontinuityMeasure::internal_side_integration(), libMesh::LaplacianErrorEstimator::internal_side_integration(), and libMesh::KellyErrorEstimator::internal_side_integration().

◆ n_shape_functions()

virtual unsigned int libMesh::FEAbstract::n_shape_functions ( ) const
pure virtualinherited

◆ on_reference_element()

bool libMesh::FEAbstract::on_reference_element ( const Point &  p,
const ElemType  t,
const Real  eps = TOLERANCE 
)
staticinherited
Returns
true if the point p is located on the reference element for element type t, false otherwise. Since we are doing floating point comparisons here the parameter eps can be specified to indicate a tolerance. For example, \( x \le 1 \) becomes \( x \le 1 + \epsilon \).
Deprecated:
This method overload does not support all finite element types; e.g. the reference element for an arbitrary polygon or polyhedron type may differ from element to element. Use Elem::on_reference_element() instead.

Definition at line 649 of file fe_abstract.C.

650{
651 // Use Elem::on_reference_element() instead
652 libmesh_deprecated();
653
654 libmesh_assert_greater_equal (eps, 0.);
655
656 const Real xi = p(0);
657#if LIBMESH_DIM > 1
658 const Real eta = p(1);
659#else
660 const Real eta = 0.;
661#endif
662#if LIBMESH_DIM > 2
663 const Real zeta = p(2);
664#else
665 const Real zeta = 0.;
666#endif
667
668 switch (t)
669 {
670 case NODEELEM:
671 {
672 return (!xi && !eta && !zeta);
673 }
674 case EDGE2:
675 case EDGE3:
676 case EDGE4:
677 {
678 // The reference 1D element is [-1,1].
679 if ((xi >= -1.-eps) &&
680 (xi <= 1.+eps))
681 return true;
682
683 return false;
684 }
685
686
687 case TRI3:
688 case TRISHELL3:
689 case TRI6:
690 case TRI7:
691 {
692 // The reference triangle is isosceles
693 // and is bound by xi=0, eta=0, and xi+eta=1.
694 if ((xi >= 0.-eps) &&
695 (eta >= 0.-eps) &&
696 ((xi + eta) <= 1.+eps))
697 return true;
698
699 return false;
700 }
701
702
703 case QUAD4:
704 case QUADSHELL4:
705 case QUAD8:
706 case QUADSHELL8:
707 case QUAD9:
708 case QUADSHELL9:
709 {
710 // The reference quadrilateral element is [-1,1]^2.
711 if ((xi >= -1.-eps) &&
712 (xi <= 1.+eps) &&
713 (eta >= -1.-eps) &&
714 (eta <= 1.+eps))
715 return true;
716
717 return false;
718 }
719
720
721 case TET4:
722 case TET10:
723 case TET14:
724 {
725 // The reference tetrahedral is isosceles
726 // and is bound by xi=0, eta=0, zeta=0,
727 // and xi+eta+zeta=1.
728 if ((xi >= 0.-eps) &&
729 (eta >= 0.-eps) &&
730 (zeta >= 0.-eps) &&
731 ((xi + eta + zeta) <= 1.+eps))
732 return true;
733
734 return false;
735 }
736
737
738 case HEX8:
739 case HEX20:
740 case HEX27:
741 {
742 /*
743 if ((xi >= -1.) &&
744 (xi <= 1.) &&
745 (eta >= -1.) &&
746 (eta <= 1.) &&
747 (zeta >= -1.) &&
748 (zeta <= 1.))
749 return true;
750 */
751
752 // The reference hexahedral element is [-1,1]^3.
753 if ((xi >= -1.-eps) &&
754 (xi <= 1.+eps) &&
755 (eta >= -1.-eps) &&
756 (eta <= 1.+eps) &&
757 (zeta >= -1.-eps) &&
758 (zeta <= 1.+eps))
759 {
760 // libMesh::out << "Strange Point:\n";
761 // p.print();
762 return true;
763 }
764
765 return false;
766 }
767
768 case PRISM6:
769 case PRISM15:
770 case PRISM18:
771 case PRISM20:
772 case PRISM21:
773 {
774 // Figure this one out...
775 // inside the reference triangle with zeta in [-1,1]
776 if ((xi >= 0.-eps) &&
777 (eta >= 0.-eps) &&
778 (zeta >= -1.-eps) &&
779 (zeta <= 1.+eps) &&
780 ((xi + eta) <= 1.+eps))
781 return true;
782
783 return false;
784 }
785
786
787 case PYRAMID5:
788 case PYRAMID13:
789 case PYRAMID14:
790 case PYRAMID18:
791 {
792 // Check that the point is on the same side of all the faces
793 // by testing whether:
794 //
795 // n_i.(x - x_i) <= 0
796 //
797 // for each i, where:
798 // n_i is the outward normal of face i,
799 // x_i is a point on face i.
800 if ((-eta - 1. + zeta <= 0.+eps) &&
801 ( xi - 1. + zeta <= 0.+eps) &&
802 ( eta - 1. + zeta <= 0.+eps) &&
803 ( -xi - 1. + zeta <= 0.+eps) &&
804 ( zeta >= 0.-eps))
805 return true;
806
807 return false;
808 }
809
810#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
811 case INFHEX8:
812 case INFHEX16:
813 case INFHEX18:
814 {
815 // The reference infhex8 is a [-1,1]^3.
816 if ((xi >= -1.-eps) &&
817 (xi <= 1.+eps) &&
818 (eta >= -1.-eps) &&
819 (eta <= 1.+eps) &&
820 (zeta >= -1.-eps) &&
821 (zeta <= 1.+eps))
822 {
823 return true;
824 }
825 return false;
826 }
827
828 case INFPRISM6:
829 case INFPRISM12:
830 {
831 // inside the reference triangle with zeta in [-1,1]
832 if ((xi >= 0.-eps) &&
833 (eta >= 0.-eps) &&
834 (zeta >= -1.-eps) &&
835 (zeta <= 1.+eps) &&
836 ((xi + eta) <= 1.+eps))
837 {
838 return true;
839 }
840
841 return false;
842 }
843#endif
844
845 default:
846 libmesh_error_msg("ERROR: Unknown element type " << Utility::enum_to_string(t));
847 }
848
849 // If we get here then the point is _not_ in the
850 // reference element. Better return false.
851
852 return false;
853}

References libMesh::EDGE2, libMesh::EDGE3, libMesh::EDGE4, libMesh::Utility::enum_to_string(), libMesh::HEX20, libMesh::HEX27, libMesh::HEX8, libMesh::INFHEX16, libMesh::INFHEX18, libMesh::INFHEX8, libMesh::INFPRISM12, libMesh::INFPRISM6, libMesh::NODEELEM, libMesh::PRISM15, libMesh::PRISM18, libMesh::PRISM20, libMesh::PRISM21, libMesh::PRISM6, libMesh::PYRAMID13, libMesh::PYRAMID14, libMesh::PYRAMID18, libMesh::PYRAMID5, libMesh::QUAD4, libMesh::QUAD8, libMesh::QUAD9, libMesh::QUADSHELL4, libMesh::QUADSHELL8, libMesh::QUADSHELL9, libMesh::Real, libMesh::TET10, libMesh::TET14, libMesh::TET4, libMesh::TRI3, libMesh::TRI6, libMesh::TRI7, and libMesh::TRISHELL3.

Referenced by libMesh::FEInterface::ifem_on_reference_element(), and libMesh::FEInterface::on_reference_element().

◆ print_d2phi()

template<typename OutputType >
void libMesh::FEGenericBase< OutputType >::print_d2phi ( std::ostream &  os) const
overridevirtual

Prints the value of each shape function's second derivatives at each quadrature point.

Implements libMesh::FEAbstract.

Definition at line 991 of file fe_base.C.

992{
993 for (auto i : index_range(dphi))
994 for (auto j : index_range(dphi[i]))
995 os << " d2phi[" << i << "][" << j << "]=" << d2phi[i][j];
996}

References libMesh::index_range().

◆ print_dphi()

template<typename OutputType >
void libMesh::FEGenericBase< OutputType >::print_dphi ( std::ostream &  os) const
overridevirtual

Prints the value of each shape function's derivative at each quadrature point.

Implements libMesh::FEAbstract.

Definition at line 933 of file fe_base.C.

934{
935 for (auto i : index_range(dphi))
936 for (auto j : index_range(dphi[i]))
937 os << " dphi[" << i << "][" << j << "]=" << dphi[i][j];
938}

References libMesh::index_range().

◆ print_dual_d2phi()

template<typename OutputType >
void libMesh::FEGenericBase< OutputType >::print_dual_d2phi ( std::ostream &  os) const
overridevirtual

Implements libMesh::FEAbstract.

Definition at line 999 of file fe_base.C.

1000{
1001 for (auto i : index_range(dual_d2phi))
1002 for (auto j : index_range(dual_d2phi[i]))
1003 os << " dual_d2phi[" << i << "][" << j << "]=" << dual_d2phi[i][j];
1004}

References libMesh::index_range().

◆ print_dual_dphi()

template<typename OutputType >
void libMesh::FEGenericBase< OutputType >::print_dual_dphi ( std::ostream &  os) const
overridevirtual

Implements libMesh::FEAbstract.

Definition at line 941 of file fe_base.C.

942{
943 for (auto i : index_range(dphi))
944 for (auto j : index_range(dphi[i]))
945 os << " dual_dphi[" << i << "][" << j << "]=" << dual_dphi[i][j];
946}

References libMesh::index_range().

◆ print_dual_phi()

template<typename OutputType >
void libMesh::FEGenericBase< OutputType >::print_dual_phi ( std::ostream &  os) const
overridevirtual

Implements libMesh::FEAbstract.

Definition at line 922 of file fe_base.C.

923{
924 for (auto i : index_range(dual_phi))
925 for (auto j : index_range(dual_phi[i]))
926 os << " dual_phi[" << i << "][" << j << "]=" << dual_phi[i][j] << std::endl;
927}

References libMesh::index_range().

◆ print_info() [1/2]

void libMesh::FEAbstract::print_info ( std::ostream &  os) const
inherited

Prints all the relevant information about the current element.

Definition at line 871 of file fe_abstract.C.

872{
873 os << "phi[i][j]: Shape function i at quadrature pt. j" << std::endl;
874 this->print_phi(os);
875
876 os << "dphi[i][j]: Shape function i's gradient at quadrature pt. j" << std::endl;
877 this->print_dphi(os);
878
879 os << "XYZ locations of the quadrature pts." << std::endl;
880 this->print_xyz(os);
881
882 os << "Values of JxW at the quadrature pts." << std::endl;
883 this->print_JxW(os);
884}
void print_JxW(std::ostream &os) const
Prints the Jacobian times the weight for each quadrature point.
virtual void print_dphi(std::ostream &os) const =0
Prints the value of each shape function's derivative at each quadrature point.
virtual void print_phi(std::ostream &os) const =0
Prints the value of each shape function at each quadrature point.
void print_xyz(std::ostream &os) const
Prints the spatial location of each quadrature point (on the physical element).

References libMesh::FEAbstract::print_dphi(), libMesh::FEAbstract::print_JxW(), libMesh::FEAbstract::print_phi(), and libMesh::FEAbstract::print_xyz().

◆ print_info() [2/2]

void libMesh::ReferenceCounter::print_info ( std::ostream &  out_stream = libMesh::out)
staticinherited

Prints the reference information, by default to libMesh::out.

Definition at line 81 of file reference_counter.C.

82{
84 out_stream << ReferenceCounter::get_info();
85}
static std::string get_info()
Gets a string containing the reference information.

References libMesh::ReferenceCounter::_enable_print_counter, and libMesh::ReferenceCounter::get_info().

Referenced by libMesh::LibMeshInit::~LibMeshInit().

◆ print_JxW()

void libMesh::FEAbstract::print_JxW ( std::ostream &  os) const
inherited

Prints the Jacobian times the weight for each quadrature point.

Definition at line 858 of file fe_abstract.C.

859{
860 this->_fe_map->print_JxW(os);
861}

References libMesh::FEAbstract::_fe_map.

Referenced by libMesh::FEAbstract::print_info().

◆ print_phi()

template<typename OutputType >
void libMesh::FEGenericBase< OutputType >::print_phi ( std::ostream &  os) const
overridevirtual

Prints the value of each shape function at each quadrature point.

Implements libMesh::FEAbstract.

Definition at line 914 of file fe_base.C.

915{
916 for (auto i : index_range(phi))
917 for (auto j : index_range(phi[i]))
918 os << " phi[" << i << "][" << j << "]=" << phi[i][j] << std::endl;
919}

References libMesh::index_range().

◆ print_xyz()

void libMesh::FEAbstract::print_xyz ( std::ostream &  os) const
inherited

Prints the spatial location of each quadrature point (on the physical element).

Definition at line 865 of file fe_abstract.C.

866{
867 this->_fe_map->print_xyz(os);
868}

References libMesh::FEAbstract::_fe_map.

Referenced by libMesh::FEAbstract::print_info().

◆ reinit() [1/2]

virtual void libMesh::FEAbstract::reinit ( const Elem *  elem,
const std::vector< Point > *const  pts = nullptr,
const std::vector< Real > *const  weights = nullptr 
)
pure virtualinherited

This is at the core of this class.

Use this for each new element in the mesh. Reinitializes the requested physical element-dependent data based on the current element elem. By default the element data are computed at the quadrature points specified by the quadrature rule qrule, but any set of points on the reference element may be specified in the optional argument pts.

Note
The FE classes decide which data to initialize based on which accessor functions such as get_phi() or get_d2phi() have been called, so all such accessors should be called before the first reinit().

Implemented in libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FESubdivision, libMesh::FEXYZ< Dim >, and libMesh::InfFE< Dim, T_radial, T_map >.

Referenced by libMesh::ExactSolution::_compute_error(), assemble_func(), assemble_SchroedingerEquation(), assemble_wave(), libMesh::FEMContext::build_new_fe(), compute_enriched_soln(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::ExactErrorEstimator::find_squared_element_error(), libMesh::JumpErrorEstimator::reinit_sides(), and InfFERadialTest::testRefinement().

◆ reinit() [2/2]

virtual void libMesh::FEAbstract::reinit ( const Elem *  elem,
const unsigned int  side,
const Real  tolerance = TOLERANCE,
const std::vector< Point > *const  pts = nullptr,
const std::vector< Real > *const  weights = nullptr 
)
pure virtualinherited

◆ reinit_default_dual_shape_coeffs()

virtual void libMesh::FEAbstract::reinit_default_dual_shape_coeffs ( const Elem *  )
inlinevirtualinherited

◆ reinit_dual_shape_coeffs()

virtual void libMesh::FEAbstract::reinit_dual_shape_coeffs ( const Elem *  ,
const std::vector< Point > &  ,
const std::vector< Real > &   
)
inlinevirtualinherited

This re-computes the dual shape function coefficients using CUSTOMIZED qrule.

The dual shape coefficients are utilized when calculating dual shape functions. This has not been implemented for InfFE

Reimplemented in libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, and libMesh::FE< Dim, XYZ >.

Definition at line 150 of file fe_abstract.h.

153 {
154 libmesh_error_msg("Customized dual shape coefficient calculation has not been implemented for this FE type.");
155 }

◆ request_dphi()

template<typename OutputType >
virtual void libMesh::FEGenericBase< OutputType >::request_dphi ( ) const
inlineoverridevirtual

request dphi calculations

Implements libMesh::FEAbstract.

Definition at line 265 of file fe_base.h.

266 { get_dphi(); }

References libMesh::FEGenericBase< OutputType >::get_dphi().

◆ request_dual_dphi()

template<typename OutputType >
virtual void libMesh::FEGenericBase< OutputType >::request_dual_dphi ( ) const
inlineoverridevirtual

Implements libMesh::FEAbstract.

Definition at line 268 of file fe_base.h.

269 { get_dual_dphi(); }
const std::vector< std::vector< OutputGradient > > & get_dual_dphi() const
Definition fe_base.h:261

References libMesh::FEGenericBase< OutputType >::get_dual_dphi().

◆ request_dual_phi()

template<typename OutputType >
virtual void libMesh::FEGenericBase< OutputType >::request_dual_phi ( ) const
inlineoverridevirtual

Implements libMesh::FEAbstract.

Definition at line 245 of file fe_base.h.

246 { get_dual_phi(); }
const std::vector< std::vector< OutputShape > > & get_dual_phi() const
Definition fe_base.h:233

References libMesh::FEGenericBase< OutputType >::get_dual_phi().

◆ request_phi()

template<typename OutputType >
virtual void libMesh::FEGenericBase< OutputType >::request_phi ( ) const
inlineoverridevirtual

request phi calculations

Implements libMesh::FEAbstract.

Definition at line 242 of file fe_base.h.

243 { get_phi(); }

References libMesh::FEGenericBase< OutputType >::get_phi().

Referenced by libMesh::FEGenericBase< OutputType >::get_dual_phi().

◆ set_calculate_default_dual_coeff()

void libMesh::FEAbstract::set_calculate_default_dual_coeff ( const bool  val)
inlineinherited

set calculate_default_dual_coeff as needed

Definition at line 626 of file fe_abstract.h.

bool calculate_default_dual_coeff
Are we calculating the coefficient for the dual basis using the default qrule?

References libMesh::FEAbstract::calculate_default_dual_coeff.

◆ set_calculate_dual()

void libMesh::FEAbstract::set_calculate_dual ( const bool  val)
inlineinherited

set calculate_dual as needed

Definition at line 621 of file fe_abstract.h.

621{calculate_dual = val; }

References libMesh::FEAbstract::calculate_dual.

◆ set_fe_order()

void libMesh::FEAbstract::set_fe_order ( int  new_order)
inlineinherited

Sets the base FE order of the finite element.

Definition at line 531 of file fe_abstract.h.

531{ fe_type.order = new_order; }

References libMesh::FEAbstract::fe_type, and libMesh::FEType::order.

◆ shapes_need_reinit()

virtual bool libMesh::FEAbstract::shapes_need_reinit ( ) const
protectedpure virtualinherited
Returns
true when the shape functions (for this FEFamily) depend on the particular element, and therefore needs to be re-initialized for each new element. false otherwise.

Implemented in libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, XYZ >, and libMesh::InfFE< Dim, T_radial, T_map >.

◆ side_map()

virtual void libMesh::FEAbstract::side_map ( const Elem *  elem,
const Elem *  side,
const unsigned int  s,
const std::vector< Point > &  reference_side_points,
std::vector< Point > &  reference_points 
)
pure virtualinherited

Friends And Related Symbol Documentation

◆ InfFE

template<typename OutputType >
template<unsigned int friend_Dim, FEFamily friend_T_radial, InfMapType friend_T_map>
friend class InfFE
friend

Make all InfFE<Dim,T_radial,T_map> classes friends so that they can safely used FE<Dim-1,T_base> through a FEGenericBase * as base approximation.

Definition at line 819 of file fe_base.h.

Member Data Documentation

◆ _add_p_level_in_reinit

bool libMesh::FEAbstract::_add_p_level_in_reinit
protectedinherited

Whether to add p-refinement levels in init/reinit methods.

Definition at line 787 of file fe_abstract.h.

Referenced by libMesh::FEAbstract::add_p_level_in_reinit(), and libMesh::FEAbstract::add_p_level_in_reinit().

◆ _counts

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts
staticprotectedinherited

Actually holds the data.

Definition at line 124 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::get_info().

◆ _elem

const Elem* libMesh::FEAbstract::_elem
protectedinherited

The element the current data structures were set up for.

Definition at line 740 of file fe_abstract.h.

Referenced by libMesh::FEAbstract::get_elem().

◆ _elem_p_level

unsigned int libMesh::FEAbstract::_elem_p_level
protectedinherited

The element p-refinement level the current data structures are set up for.

Note that this is different from _p_level which is the p-refinement level this finite elment object is operating at, e.g. how many dofs per elem, etc. On the other hand, this data member can indicate things like the order of the quadrature rule. We will use this primarily to determine whether cached data is still valid

Definition at line 751 of file fe_abstract.h.

◆ _elem_type

ElemType libMesh::FEAbstract::_elem_type
protectedinherited

The element type the current data structures were set up for.

Definition at line 735 of file fe_abstract.h.

Referenced by libMesh::FEAbstract::get_type().

◆ _enable_print_counter

bool libMesh::ReferenceCounter::_enable_print_counter = true
staticprotectedinherited

Flag to control whether reference count information is printed when print_info is called.

Definition at line 143 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::disable_print_counter_info(), libMesh::ReferenceCounter::enable_print_counter_info(), and libMesh::ReferenceCounter::print_info().

◆ _fe_map

std::unique_ptr<FEMap> libMesh::FEAbstract::_fe_map
protectedinherited

◆ _fe_trans

template<typename OutputType >
std::unique_ptr<FETransformationBase<OutputType> > libMesh::FEGenericBase< OutputType >::_fe_trans
protected

Object that handles computing shape function values, gradients, etc in the physical domain.

Definition at line 647 of file fe_base.h.

◆ _mutex

Threads::spin_mutex libMesh::ReferenceCounter::_mutex
staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 137 of file reference_counter.h.

◆ _n_objects

Threads::atomic< unsigned int > libMesh::ReferenceCounter::_n_objects
staticprotectedinherited

◆ _n_total_qp

unsigned int libMesh::FEAbstract::_n_total_qp
protectedinherited

The total number of quadrature points for the current configuration.

Definition at line 774 of file fe_abstract.h.

Referenced by libMesh::FEAbstract::n_quadrature_points(), and libMesh::InfFE< Dim, T_radial, T_map >::n_quadrature_points().

◆ _p_level

unsigned int libMesh::FEAbstract::_p_level
protectedinherited

The p refinement level the current data structures are set up for.

Definition at line 757 of file fe_abstract.h.

Referenced by libMesh::FEAbstract::get_order(), and libMesh::FEAbstract::get_p_level().

◆ calculate_curl_phi

bool libMesh::FEAbstract::calculate_curl_phi
mutableprotectedinherited

Should we calculate shape function curls?

Definition at line 712 of file fe_abstract.h.

Referenced by libMesh::FEGenericBase< OutputType >::calculating_nothing(), and libMesh::FEGenericBase< OutputType >::get_curl_phi().

◆ calculate_d2phi [1/2]

bool libMesh::FEAbstract::calculate_d2phi
mutableprotectedinherited

◆ calculate_d2phi [2/2]

const bool libMesh::FEAbstract::calculate_d2phi =false
protectedinherited

Definition at line 705 of file fe_abstract.h.

◆ calculate_default_dual_coeff

bool libMesh::FEAbstract::calculate_default_dual_coeff
mutableprotectedinherited

Are we calculating the coefficient for the dual basis using the default qrule?

Definition at line 676 of file fe_abstract.h.

Referenced by libMesh::FEAbstract::set_calculate_default_dual_coeff().

◆ calculate_div_phi

bool libMesh::FEAbstract::calculate_div_phi
mutableprotectedinherited

Should we calculate shape function divergences?

Definition at line 717 of file fe_abstract.h.

Referenced by libMesh::FEGenericBase< OutputType >::calculating_nothing(), and libMesh::FEGenericBase< OutputType >::get_div_phi().

◆ calculate_dphi

bool libMesh::FEAbstract::calculate_dphi
mutableprotectedinherited

◆ calculate_dphiref

bool libMesh::FEAbstract::calculate_dphiref
mutableprotectedinherited

◆ calculate_dual

bool libMesh::FEAbstract::calculate_dual
mutableprotectedinherited

◆ calculate_map

bool libMesh::FEAbstract::calculate_map
mutableprotectedinherited

Are we calculating mapping functions?

Definition at line 686 of file fe_abstract.h.

Referenced by libMesh::FEGenericBase< OutputType >::calculating_nothing(), libMesh::FEAbstract::get_curvatures(), libMesh::InfFE< Dim, T_radial, T_map >::get_curvatures(), libMesh::FEAbstract::get_d2xyzdeta2(), libMesh::InfFE< Dim, T_radial, T_map >::get_d2xyzdeta2(), libMesh::FEAbstract::get_d2xyzdetadzeta(), libMesh::InfFE< Dim, T_radial, T_map >::get_d2xyzdetadzeta(), libMesh::FEAbstract::get_d2xyzdxi2(), libMesh::InfFE< Dim, T_radial, T_map >::get_d2xyzdxi2(), libMesh::FEAbstract::get_d2xyzdxideta(), libMesh::InfFE< Dim, T_radial, T_map >::get_d2xyzdxideta(), libMesh::FEAbstract::get_d2xyzdxidzeta(), libMesh::InfFE< Dim, T_radial, T_map >::get_d2xyzdxidzeta(), libMesh::FEAbstract::get_d2xyzdzeta2(), libMesh::InfFE< Dim, T_radial, T_map >::get_d2xyzdzeta2(), libMesh::FEAbstract::get_detadx(), libMesh::InfFE< Dim, T_radial, T_map >::get_detadx(), libMesh::FEAbstract::get_detady(), libMesh::InfFE< Dim, T_radial, T_map >::get_detady(), libMesh::FEAbstract::get_detadz(), libMesh::InfFE< Dim, T_radial, T_map >::get_detadz(), libMesh::FEAbstract::get_dxidx(), libMesh::InfFE< Dim, T_radial, T_map >::get_dxidx(), libMesh::FEAbstract::get_dxidy(), libMesh::InfFE< Dim, T_radial, T_map >::get_dxidy(), libMesh::FEAbstract::get_dxidz(), libMesh::InfFE< Dim, T_radial, T_map >::get_dxidz(), libMesh::FEAbstract::get_dxyzdeta(), libMesh::InfFE< Dim, T_radial, T_map >::get_dxyzdeta(), libMesh::FEAbstract::get_dxyzdxi(), libMesh::InfFE< Dim, T_radial, T_map >::get_dxyzdxi(), libMesh::InfFE< Dim, T_radial, T_map >::get_dxyzdzeta(), libMesh::FEAbstract::get_dzetadx(), libMesh::InfFE< Dim, T_radial, T_map >::get_dzetadx(), libMesh::FEAbstract::get_dzetady(), libMesh::InfFE< Dim, T_radial, T_map >::get_dzetady(), libMesh::FEAbstract::get_dzetadz(), libMesh::InfFE< Dim, T_radial, T_map >::get_dzetadz(), libMesh::FEAbstract::get_JxW(), libMesh::FEAbstract::get_normals(), libMesh::InfFE< Dim, T_radial, T_map >::get_normals(), libMesh::FEAbstract::get_tangents(), libMesh::InfFE< Dim, T_radial, T_map >::get_tangents(), and libMesh::FEAbstract::get_xyz().

◆ calculate_nothing

bool libMesh::FEAbstract::calculate_nothing
mutableprotectedinherited

Are we potentially deliberately calculating nothing?

Definition at line 681 of file fe_abstract.h.

Referenced by libMesh::FEGenericBase< OutputType >::calculating_nothing(), and libMesh::FEAbstract::get_nothing().

◆ calculate_phi

bool libMesh::FEAbstract::calculate_phi
mutableprotectedinherited

◆ calculations_started

bool libMesh::FEAbstract::calculations_started
mutableprotectedinherited

Have calculations with this object already been started? Then all get_* functions should already have been called.

Definition at line 666 of file fe_abstract.h.

Referenced by libMesh::FEGenericBase< OutputType >::get_curl_phi(), libMesh::FEGenericBase< OutputType >::get_d2phi(), libMesh::FEGenericBase< OutputType >::get_d2phideta2(), libMesh::FEGenericBase< OutputType >::get_d2phidetadzeta(), libMesh::FEGenericBase< OutputType >::get_d2phidx2(), libMesh::FEGenericBase< OutputType >::get_d2phidxdy(), libMesh::FEGenericBase< OutputType >::get_d2phidxdz(), libMesh::FEGenericBase< OutputType >::get_d2phidxi2(), libMesh::FEGenericBase< OutputType >::get_d2phidxideta(), libMesh::FEGenericBase< OutputType >::get_d2phidxidzeta(), libMesh::FEGenericBase< OutputType >::get_d2phidy2(), libMesh::FEGenericBase< OutputType >::get_d2phidydz(), libMesh::FEGenericBase< OutputType >::get_d2phidz2(), libMesh::FEGenericBase< OutputType >::get_d2phidzeta2(), libMesh::InfFE< Dim, T_radial, T_map >::get_detadx(), libMesh::InfFE< Dim, T_radial, T_map >::get_detady(), libMesh::InfFE< Dim, T_radial, T_map >::get_detadz(), libMesh::FEGenericBase< OutputType >::get_div_phi(), libMesh::FEGenericBase< OutputType >::get_dphi(), libMesh::InfFE< Dim, T_radial, T_map >::get_dphi_over_decay(), libMesh::InfFE< Dim, T_radial, T_map >::get_dphi_over_decayxR(), libMesh::FEGenericBase< OutputType >::get_dphideta(), libMesh::FEGenericBase< OutputType >::get_dphidx(), libMesh::FEGenericBase< OutputType >::get_dphidxi(), libMesh::FEGenericBase< OutputType >::get_dphidy(), libMesh::FEGenericBase< OutputType >::get_dphidz(), libMesh::FEGenericBase< OutputType >::get_dphidzeta(), libMesh::FEGenericBase< OutputType >::get_dual_d2phi(), libMesh::FEGenericBase< OutputType >::get_dual_dphi(), libMesh::FEGenericBase< OutputType >::get_dual_phi(), libMesh::InfFE< Dim, T_radial, T_map >::get_dxidx(), libMesh::InfFE< Dim, T_radial, T_map >::get_dxidy(), libMesh::InfFE< Dim, T_radial, T_map >::get_dxidz(), libMesh::InfFE< Dim, T_radial, T_map >::get_dzetadx(), libMesh::InfFE< Dim, T_radial, T_map >::get_dzetady(), libMesh::InfFE< Dim, T_radial, T_map >::get_dzetadz(), libMesh::InfFE< Dim, T_radial, T_map >::get_JxW(), libMesh::InfFE< Dim, T_radial, T_map >::get_JxWxdecay_sq(), libMesh::InfFE< Dim, T_radial, T_map >::get_normals(), libMesh::FEGenericBase< OutputType >::get_phi(), libMesh::InfFE< Dim, T_radial, T_map >::get_phi_over_decayxR(), libMesh::InfFE< Dim, T_radial, T_map >::get_Sobolev_dweight(), libMesh::InfFE< Dim, T_radial, T_map >::get_Sobolev_dweightxR_sq(), libMesh::InfFE< Dim, T_radial, T_map >::get_Sobolev_weight(), libMesh::InfFE< Dim, T_radial, T_map >::get_Sobolev_weightxR_sq(), libMesh::InfFE< Dim, T_radial, T_map >::get_tangents(), and libMesh::InfFE< Dim, T_radial, T_map >::get_xyz().

◆ curl_phi

template<typename OutputType >
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< OutputType >::curl_phi
protected

Shape function curl values.

Only defined for vector types.

Definition at line 669 of file fe_base.h.

Referenced by libMesh::FEGenericBase< OutputType >::get_curl_phi().

◆ d2phi

template<typename OutputType >
std::vector<std::vector<OutputTensor> > libMesh::FEGenericBase< OutputType >::d2phi
protected

Shape function second derivative values.

Definition at line 712 of file fe_base.h.

Referenced by libMesh::FEGenericBase< OutputType >::get_d2phi().

◆ d2phideta2

template<typename OutputType >
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< OutputType >::d2phideta2
protected

Shape function second derivatives in the eta direction.

Definition at line 733 of file fe_base.h.

Referenced by libMesh::FEGenericBase< OutputType >::get_d2phideta2().

◆ d2phidetadzeta

template<typename OutputType >
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< OutputType >::d2phidetadzeta
protected

Shape function second derivatives in the eta-zeta direction.

Definition at line 738 of file fe_base.h.

Referenced by libMesh::FEGenericBase< OutputType >::get_d2phidetadzeta().

◆ d2phidx2

template<typename OutputType >
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< OutputType >::d2phidx2
protected

Shape function second derivatives in the x direction.

Definition at line 748 of file fe_base.h.

Referenced by libMesh::FEGenericBase< OutputType >::get_d2phidx2().

◆ d2phidxdy

template<typename OutputType >
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< OutputType >::d2phidxdy
protected

Shape function second derivatives in the x-y direction.

Definition at line 753 of file fe_base.h.

Referenced by libMesh::FEGenericBase< OutputType >::get_d2phidxdy().

◆ d2phidxdz

template<typename OutputType >
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< OutputType >::d2phidxdz
protected

Shape function second derivatives in the x-z direction.

Definition at line 758 of file fe_base.h.

Referenced by libMesh::FEGenericBase< OutputType >::get_d2phidxdz().

◆ d2phidxi2

template<typename OutputType >
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< OutputType >::d2phidxi2
protected

Shape function second derivatives in the xi direction.

Definition at line 718 of file fe_base.h.

Referenced by libMesh::FEGenericBase< OutputType >::get_d2phidxi2().

◆ d2phidxideta

template<typename OutputType >
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< OutputType >::d2phidxideta
protected

Shape function second derivatives in the xi-eta direction.

Definition at line 723 of file fe_base.h.

Referenced by libMesh::FEGenericBase< OutputType >::get_d2phidxideta().

◆ d2phidxidzeta

template<typename OutputType >
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< OutputType >::d2phidxidzeta
protected

Shape function second derivatives in the xi-zeta direction.

Definition at line 728 of file fe_base.h.

Referenced by libMesh::FEGenericBase< OutputType >::get_d2phidxidzeta().

◆ d2phidy2

template<typename OutputType >
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< OutputType >::d2phidy2
protected

Shape function second derivatives in the y direction.

Definition at line 763 of file fe_base.h.

Referenced by libMesh::FEGenericBase< OutputType >::get_d2phidy2().

◆ d2phidydz

template<typename OutputType >
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< OutputType >::d2phidydz
protected

Shape function second derivatives in the y-z direction.

Definition at line 768 of file fe_base.h.

Referenced by libMesh::FEGenericBase< OutputType >::get_d2phidydz().

◆ d2phidz2

template<typename OutputType >
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< OutputType >::d2phidz2
protected

Shape function second derivatives in the z direction.

Definition at line 773 of file fe_base.h.

Referenced by libMesh::FEGenericBase< OutputType >::get_d2phidz2().

◆ d2phidzeta2

template<typename OutputType >
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< OutputType >::d2phidzeta2
protected

Shape function second derivatives in the zeta direction.

Definition at line 743 of file fe_base.h.

Referenced by libMesh::FEGenericBase< OutputType >::get_d2phidzeta2().

◆ dim

const unsigned int libMesh::FEAbstract::dim
protectedinherited

The dimensionality of the object.

Definition at line 660 of file fe_abstract.h.

Referenced by libMesh::FEAbstract::build(), and libMesh::FEAbstract::get_dim().

◆ div_phi

template<typename OutputType >
std::vector<std::vector<OutputDivergence> > libMesh::FEGenericBase< OutputType >::div_phi
protected

Shape function divergence values.

Only defined for vector types.

Definition at line 674 of file fe_base.h.

Referenced by libMesh::FEGenericBase< OutputType >::get_div_phi().

◆ dphase

template<typename OutputType >
std::vector<OutputGradient> libMesh::FEGenericBase< OutputType >::dphase
protected

Used for certain infinite element families: the first derivatives of the phase term in global coordinates, over all quadrature points.

Definition at line 791 of file fe_base.h.

Referenced by libMesh::FEGenericBase< OutputType >::get_dphase().

◆ dphi

template<typename OutputType >
std::vector<std::vector<OutputGradient> > libMesh::FEGenericBase< OutputType >::dphi
protected

Shape function derivative values.

Definition at line 658 of file fe_base.h.

Referenced by libMesh::FEGenericBase< OutputType >::get_dphi().

◆ dphideta

template<typename OutputType >
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< OutputType >::dphideta
protected

Shape function derivatives in the eta direction.

Definition at line 684 of file fe_base.h.

Referenced by libMesh::FEGenericBase< OutputType >::get_dphideta().

◆ dphidx

template<typename OutputType >
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< OutputType >::dphidx
protected

Shape function derivatives in the x direction.

Definition at line 694 of file fe_base.h.

Referenced by libMesh::FEGenericBase< OutputType >::get_dphidx().

◆ dphidxi

template<typename OutputType >
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< OutputType >::dphidxi
protected

Shape function derivatives in the xi direction.

Definition at line 679 of file fe_base.h.

Referenced by libMesh::FEGenericBase< OutputType >::get_dphidxi().

◆ dphidy

template<typename OutputType >
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< OutputType >::dphidy
protected

Shape function derivatives in the y direction.

Definition at line 699 of file fe_base.h.

Referenced by libMesh::FEGenericBase< OutputType >::get_dphidy().

◆ dphidz

template<typename OutputType >
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< OutputType >::dphidz
protected

Shape function derivatives in the z direction.

Definition at line 704 of file fe_base.h.

Referenced by libMesh::FEGenericBase< OutputType >::get_dphidz().

◆ dphidzeta

template<typename OutputType >
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< OutputType >::dphidzeta
protected

Shape function derivatives in the zeta direction.

Definition at line 689 of file fe_base.h.

Referenced by libMesh::FEGenericBase< OutputType >::get_dphidzeta().

◆ dual_coeff

template<typename OutputType >
DenseMatrix<Real> libMesh::FEGenericBase< OutputType >::dual_coeff
mutableprotected

Coefficient matrix for the dual basis.

Definition at line 664 of file fe_base.h.

Referenced by libMesh::FEGenericBase< OutputType >::get_dual_coeff().

◆ dual_d2phi

template<typename OutputType >
std::vector<std::vector<OutputTensor> > libMesh::FEGenericBase< OutputType >::dual_d2phi
protected

Definition at line 713 of file fe_base.h.

Referenced by libMesh::FEGenericBase< OutputType >::get_dual_d2phi().

◆ dual_dphi

template<typename OutputType >
std::vector<std::vector<OutputGradient> > libMesh::FEGenericBase< OutputType >::dual_dphi
protected

Definition at line 659 of file fe_base.h.

Referenced by libMesh::FEGenericBase< OutputType >::get_dual_dphi().

◆ dual_phi

template<typename OutputType >
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< OutputType >::dual_phi
protected

Definition at line 653 of file fe_base.h.

Referenced by libMesh::FEGenericBase< OutputType >::get_dual_phi().

◆ dweight

template<typename OutputType >
std::vector<RealGradient> libMesh::FEGenericBase< OutputType >::dweight
protected

Used for certain infinite element families: the global derivative of the additional radial weight \( 1/{r^2} \), over all quadrature points.

Definition at line 798 of file fe_base.h.

Referenced by libMesh::FEGenericBase< OutputType >::get_Sobolev_dweight(), libMesh::InfFE< Dim, T_radial, T_map >::get_Sobolev_dweight(), and libMesh::FEGenericBase< OutputType >::get_Sobolev_dweightxR_sq().

◆ fe_type

FEType libMesh::FEAbstract::fe_type
protectedinherited

◆ phi

template<typename OutputType >
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< OutputType >::phi
protected

Shape function values.

Definition at line 652 of file fe_base.h.

Referenced by libMesh::FEGenericBase< OutputType >::get_phi().

◆ qrule

QBase* libMesh::FEAbstract::qrule
protectedinherited

A pointer to the quadrature rule employed.

Definition at line 762 of file fe_abstract.h.

Referenced by libMesh::FEAbstract::n_quadrature_points().

◆ shapes_on_quadrature

bool libMesh::FEAbstract::shapes_on_quadrature
protectedinherited

A flag indicating if current data structures correspond to quadrature rule points.

Definition at line 768 of file fe_abstract.h.

Referenced by libMesh::FEAbstract::n_quadrature_points().

◆ weight

template<typename OutputType >
std::vector<Real> libMesh::FEGenericBase< OutputType >::weight
protected

Used for certain infinite element families: the additional radial weight \( 1/{r^2} \) in local coordinates, over all quadrature points.

Definition at line 805 of file fe_base.h.

Referenced by libMesh::FEGenericBase< OutputType >::get_Sobolev_weight(), libMesh::InfFE< Dim, T_radial, T_map >::get_Sobolev_weight(), and libMesh::FEGenericBase< OutputType >::get_Sobolev_weightxR_sq().


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