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 827 of file fe_base.h.

828 :
829 FEAbstract(d,fet),
830 _fe_trans( FETransformationBase<OutputType>::build(fet) ),
831 phi(),
832 dual_phi(),
833 dphi(),
834 dual_dphi(),
835 curl_phi(),
836 div_phi(),
837 dphidxi(),
838 dphideta(),
839 dphidzeta(),
840 dphidx(),
841 dphidy(),
842 dphidz()
843#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
844 ,d2phi(),
845 dual_d2phi(),
846 d2phidxi2(),
847 d2phidxideta(),
848 d2phidxidzeta(),
849 d2phideta2(),
850 d2phidetadzeta(),
851 d2phidzeta2(),
852 d2phidx2(),
853 d2phidxdy(),
854 d2phidxdz(),
855 d2phidy2(),
856 d2phidydz(),
857 d2phidz2()
858#endif
859#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
860 ,dphase(),
861 dweight(),
862 weight()
863#endif
864{
865}
866
867
868
869template <typename OutputType>
870inline
871FEGenericBase<OutputType>::~FEGenericBase()
872{
873}
libMesh::FEAbstract::FEAbstract
FEAbstract(const unsigned int dim, const FEType &fet)
Constructor.
Definition fe_abstract.C:47
libMesh::FEGenericBase::d2phi
std::vector< std::vector< OutputTensor > > d2phi
Shape function second derivative values.
Definition fe_base.h:674
libMesh::FEGenericBase::~FEGenericBase
virtual ~FEGenericBase()
Destructor.
libMesh::FEGenericBase::d2phidxdz
std::vector< std::vector< OutputShape > > d2phidxdz
Shape function second derivatives in the x-z direction.
Definition fe_base.h:720
libMesh::FEGenericBase::d2phidxidzeta
std::vector< std::vector< OutputShape > > d2phidxidzeta
Shape function second derivatives in the xi-zeta direction.
Definition fe_base.h:690
libMesh::FEGenericBase::d2phidx2
std::vector< std::vector< OutputShape > > d2phidx2
Shape function second derivatives in the x direction.
Definition fe_base.h:710
libMesh::FEGenericBase::d2phidz2
std::vector< std::vector< OutputShape > > d2phidz2
Shape function second derivatives in the z direction.
Definition fe_base.h:735
libMesh::FEGenericBase::dphidx
std::vector< std::vector< OutputShape > > dphidx
Shape function derivatives in the x direction.
Definition fe_base.h:656
libMesh::FEGenericBase::d2phidy2
std::vector< std::vector< OutputShape > > d2phidy2
Shape function second derivatives in the y direction.
Definition fe_base.h:725
libMesh::FEGenericBase::dphidy
std::vector< std::vector< OutputShape > > dphidy
Shape function derivatives in the y direction.
Definition fe_base.h:661
libMesh::FEGenericBase::d2phidydz
std::vector< std::vector< OutputShape > > d2phidydz
Shape function second derivatives in the y-z direction.
Definition fe_base.h:730
libMesh::FEGenericBase::div_phi
std::vector< std::vector< OutputDivergence > > div_phi
Shape function divergence values.
Definition fe_base.h:636
libMesh::FEGenericBase::weight
std::vector< Real > weight
Used for certain infinite element families: the additional radial weight in local coordinates,...
Definition fe_base.h:767
libMesh::FEGenericBase::dual_dphi
std::vector< std::vector< OutputGradient > > dual_dphi
Definition fe_base.h:621
libMesh::FEGenericBase::dphi
std::vector< std::vector< OutputGradient > > dphi
Shape function derivative values.
Definition fe_base.h:620
libMesh::FEGenericBase::d2phidxi2
std::vector< std::vector< OutputShape > > d2phidxi2
Shape function second derivatives in the xi direction.
Definition fe_base.h:680
libMesh::FEGenericBase::d2phidxideta
std::vector< std::vector< OutputShape > > d2phidxideta
Shape function second derivatives in the xi-eta direction.
Definition fe_base.h:685
libMesh::FEGenericBase::phi
std::vector< std::vector< OutputShape > > phi
Shape function values.
Definition fe_base.h:614
libMesh::FEGenericBase::dphidzeta
std::vector< std::vector< OutputShape > > dphidzeta
Shape function derivatives in the zeta direction.
Definition fe_base.h:651
libMesh::FEGenericBase::dual_d2phi
std::vector< std::vector< OutputTensor > > dual_d2phi
Definition fe_base.h:675
libMesh::FEGenericBase::dphase
std::vector< OutputGradient > dphase
Used for certain infinite element families: the first derivatives of the phase term in global coordin...
Definition fe_base.h:753
libMesh::FEGenericBase::dphidz
std::vector< std::vector< OutputShape > > dphidz
Shape function derivatives in the z direction.
Definition fe_base.h:666
libMesh::FEGenericBase::dual_phi
std::vector< std::vector< OutputShape > > dual_phi
Definition fe_base.h:615
libMesh::FEGenericBase::d2phidetadzeta
std::vector< std::vector< OutputShape > > d2phidetadzeta
Shape function second derivatives in the eta-zeta direction.
Definition fe_base.h:700
libMesh::FEGenericBase::dphidxi
std::vector< std::vector< OutputShape > > dphidxi
Shape function derivatives in the xi direction.
Definition fe_base.h:641
libMesh::FEGenericBase::d2phideta2
std::vector< std::vector< OutputShape > > d2phideta2
Shape function second derivatives in the eta direction.
Definition fe_base.h:695
libMesh::FEGenericBase::_fe_trans
std::unique_ptr< FETransformationBase< OutputType > > _fe_trans
Object that handles computing shape function values, gradients, etc in the physical domain.
Definition fe_base.h:609
libMesh::FEGenericBase::d2phidxdy
std::vector< std::vector< OutputShape > > d2phidxdy
Shape function second derivatives in the x-y direction.
Definition fe_base.h:715
libMesh::FEGenericBase::dweight
std::vector< RealGradient > dweight
Used for certain infinite element families: the global derivative of the additional radial weight ,...
Definition fe_base.h:760
libMesh::FEGenericBase::d2phidzeta2
std::vector< std::vector< OutputShape > > d2phidzeta2
Shape function second derivatives in the zeta direction.
Definition fe_base.h:705
libMesh::FEGenericBase::curl_phi
std::vector< std::vector< OutputShape > > curl_phi
Shape function curl values.
Definition fe_base.h:631
libMesh::FEGenericBase::dphideta
std::vector< std::vector< OutputShape > > dphideta
Shape function derivatives in the eta direction.
Definition fe_base.h:646
libMesh::FETransformationBase::build
static std::unique_ptr< FETransformationBase< OutputShape > > build(const FEType &type)
Builds an FETransformation object based on the finite element type.
Definition fe_transformation_base.C:32

◆ ~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; }
libMesh::FEAbstract::_add_p_level_in_reinit
bool _add_p_level_in_reinit
Whether to add p-refinement levels in init/reinit methods.
Definition fe_abstract.h:787

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.

631{ _add_p_level_in_reinit = value; }
value
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

Provides the class with the quadrature rule.

Implement this in derived classes.

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, and libMesh::InfFE< Dim, T_radial, T_map >.

Referenced by libMesh::RBConstruction::add_scaled_matrix_and_vector().

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

◆ build() [2/3]

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

Definition at line 413 of file fe_base.C.

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

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(), SideVertexAverageNormalTest::testHexes(), InfFERadialTest::testRefinement(), InfFERadialTest::testSides(), 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 546 of file fe_base.C.

548{
549 switch (dim)
550 {
551
552 // 1D
553 case 1:
554 {
555 switch (fet.radial_family)
556 {
557 case INFINITE_MAP:
558 libmesh_error_msg("ERROR: Can't build an infinite element with FEFamily = " << Utility::enum_to_string(fet.radial_family));
559
560 case JACOBI_20_00:
561 {
562 switch (fet.inf_map)
563 {
564 case CARTESIAN:
565 return std::make_unique<InfFE<1,JACOBI_20_00,CARTESIAN>>(fet);
566
567 default:
568 libmesh_error_msg("ERROR: Can't build an infinite element with InfMapType = " << Utility::enum_to_string(fet.inf_map));
569 }
570 }
571
572 case JACOBI_30_00:
573 {
574 switch (fet.inf_map)
575 {
576 case CARTESIAN:
577 return std::make_unique<InfFE<1,JACOBI_30_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 LEGENDRE:
585 {
586 switch (fet.inf_map)
587 {
588 case CARTESIAN:
589 return std::make_unique<InfFE<1,LEGENDRE,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 LAGRANGE:
597 {
598 switch (fet.inf_map)
599 {
600 case CARTESIAN:
601 return std::make_unique<InfFE<1,LAGRANGE,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 default:
609 libmesh_error_msg("ERROR: Bad FEType.radial_family= " << Utility::enum_to_string(fet.radial_family));
610 }
611 }
612
613
614
615
616 // 2D
617 case 2:
618 {
619 switch (fet.radial_family)
620 {
621 case INFINITE_MAP:
622 libmesh_error_msg("ERROR: Can't build an infinite element with FEFamily = " << Utility::enum_to_string(fet.radial_family));
623
624 case JACOBI_20_00:
625 {
626 switch (fet.inf_map)
627 {
628 case CARTESIAN:
629 return std::make_unique<InfFE<2,JACOBI_20_00,CARTESIAN>>(fet);
630
631 default:
632 libmesh_error_msg("ERROR: Don't build an infinite element with InfMapType = " << Utility::enum_to_string(fet.inf_map));
633 }
634 }
635
636 case JACOBI_30_00:
637 {
638 switch (fet.inf_map)
639 {
640 case CARTESIAN:
641 return std::make_unique<InfFE<2,JACOBI_30_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 LEGENDRE:
649 {
650 switch (fet.inf_map)
651 {
652 case CARTESIAN:
653 return std::make_unique<InfFE<2,LEGENDRE,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 LAGRANGE:
661 {
662 switch (fet.inf_map)
663 {
664 case CARTESIAN:
665 return std::make_unique<InfFE<2,LAGRANGE,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 default:
673 libmesh_error_msg("ERROR: Bad FEType.radial_family= " << Utility::enum_to_string(fet.radial_family));
674 }
675 }
676
677
678
679
680 // 3D
681 case 3:
682 {
683 switch (fet.radial_family)
684 {
685 case INFINITE_MAP:
686 libmesh_error_msg("ERROR: Don't build an infinite element with FEFamily = " << Utility::enum_to_string(fet.radial_family));
687
688 case JACOBI_20_00:
689 {
690 switch (fet.inf_map)
691 {
692 case CARTESIAN:
693 return std::make_unique<InfFE<3,JACOBI_20_00,CARTESIAN>>(fet);
694
695 default:
696 libmesh_error_msg("ERROR: Don't build an infinite element with InfMapType = " << Utility::enum_to_string(fet.inf_map));
697 }
698 }
699
700 case JACOBI_30_00:
701 {
702 switch (fet.inf_map)
703 {
704 case CARTESIAN:
705 return std::make_unique<InfFE<3,JACOBI_30_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 LEGENDRE:
713 {
714 switch (fet.inf_map)
715 {
716 case CARTESIAN:
717 return std::make_unique<InfFE<3,LEGENDRE,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 LAGRANGE:
725 {
726 switch (fet.inf_map)
727 {
728 case CARTESIAN:
729 return std::make_unique<InfFE<3,LAGRANGE,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 default:
737 libmesh_error_msg("ERROR: Bad FEType.radial_family= " << Utility::enum_to_string(fet.radial_family));
738 }
739 }
740
741 default:
742 libmesh_error_msg("Invalid dimension dim = " << dim);
743 }
744}
libMesh::FEType::inf_map
InfMapType inf_map
The coordinate mapping type of the infinite element.
Definition fe_type.h:284
libMesh::FEType::radial_family
FEFamily radial_family
The type of approximation in radial direction.
Definition fe_type.h:276

References dim, libMesh::Utility::enum_to_string(), libMesh::INFINITE_MAP, libMesh::JACOBI_20_00, and libMesh::FEType::radial_family.

◆ 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 750 of file fe_base.C.

752{
753 // No vector types defined... YET.
754 libmesh_not_implemented();
755 return std::unique_ptr<FEVectorBase>();
756}

◆ 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 568 of file fe_base.h.

569 {
570 return calculate_nothing &&
571 !this->calculate_phi && !this->calculate_dphi &&
572#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
573 !this->calculate_d2phi &&
574#endif
575 !this->calculate_curl_phi && !this->calculate_div_phi &&
576 !this->calculate_map;
577 }
libMesh::FEAbstract::calculate_map
bool calculate_map
Are we calculating mapping functions?
Definition fe_abstract.h:686
libMesh::FEAbstract::calculate_nothing
bool calculate_nothing
Are we potentially deliberately calculating nothing?
Definition fe_abstract.h:681
libMesh::FEAbstract::calculate_d2phi
bool calculate_d2phi
Should we calculate shape function hessians?
Definition fe_abstract.h:702
libMesh::FEAbstract::calculate_phi
bool calculate_phi
Should we calculate shape functions?
Definition fe_abstract.h:691
libMesh::FEAbstract::calculate_dphi
bool calculate_dphi
Should we calculate shape function gradients?
Definition fe_abstract.h:696
libMesh::FEAbstract::calculate_curl_phi
bool calculate_curl_phi
Should we calculate shape function curls?
Definition fe_abstract.h:712
libMesh::FEAbstract::calculate_div_phi
bool calculate_div_phi
Should we calculate shape function divergences?
Definition fe_abstract.h:717

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 1511 of file fe_base.C.

1516{
1517 Ue.resize(0);
1518
1519 for (auto v : make_range(dof_map.n_variables()))
1520 {
1521 DenseVector<Number> Usub;
1522
1523 coarsened_dof_values(old_vector, dof_map, elem, Usub,
1524 v, use_old_dof_indices);
1525
1526 Ue.append (Usub);
1527 }
1528}
libMesh::DenseVector
Defines a dense vector for use in Finite Element-type computations.
Definition dense_vector.h:59
libMesh::FEGenericBase::coarsened_dof_values
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:976
libMesh::make_range
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 976 of file fe_base.C.

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

801{
802 libmesh_error_msg(
803 "Computation of dual shape functions for vector finite element "
804 "families is not currently implemented");
805}

◆ 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 804 of file fe_base.C.

805{
806 // Start logging the dual coeff computation
807 LOG_SCOPE("compute_dual_shape_coeffs()", "FE");
808
809 const unsigned int sz=phi_vals.size();
810 libmesh_error_msg_if(!sz, "ERROR: cannot compute dual shape coefficients with empty phi values");
811
812 //compute dual basis coefficient (dual_coeff)
813 dual_coeff.resize(sz, sz);
814 DenseMatrix<Real> A(sz, sz), D(sz, sz);
815
816 for (const auto i : index_range(phi_vals))
817 for (const auto qp : index_range(phi_vals[i]))
818 {
819 D(i,i) += JxW[qp]*phi_vals[i][qp];
820 for (const auto j : index_range(phi_vals))
821 A(i,j) += JxW[qp]*phi_vals[i][qp]*phi_vals[j][qp];
822 }
823
824 // dual_coeff = A^-1*D
825 for (const auto j : index_range(phi_vals))
826 {
827 DenseVector<Real> Dcol(sz), coeffcol(sz);
828 for (const auto i : index_range(phi_vals))
829 Dcol(i) = D(i, j);
830 A.cholesky_solve(Dcol, coeffcol);
831
832 for (const auto row : index_range(phi_vals))
833 dual_coeff(row, j)=coeffcol(row);
834 }
835}
libMesh::FEGenericBase::dual_coeff
DenseMatrix< Real > dual_coeff
Coefficient matrix for the dual basis.
Definition fe_base.h:626
libMesh::index_range
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

References libMesh::index_range().

◆ 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 792 of file fe_base.h.

793{
794 libmesh_error_msg(
795 "Computation of dual shape functions for vector finite element "
796 "families is not currently implemented");
797}

◆ 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 838 of file fe_base.C.

839{
840 // Start logging the shape function computation
841 LOG_SCOPE("compute_dual_shape_functions()", "FE");
842
843 // The dual coeffs matrix should have the same size as phi
844 libmesh_assert(dual_coeff.m() == phi.size());
845 libmesh_assert(dual_coeff.n() == phi.size());
846
847 // initialize dual basis
848 for (const auto j : index_range(phi))
849 for (const auto qp : index_range(phi[j]))
850 {
851 dual_phi[j][qp] = 0;
852 if (calculate_dphi)
853 dual_dphi[j][qp] = 0;
854#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
855 if (calculate_d2phi)
856 dual_d2phi[j][qp] = 0;
857#endif
858 }
859
860 // compute dual basis
861 for (const auto j : index_range(phi))
862 for (const auto i : index_range(phi))
863 for (const auto qp : index_range(phi[j]))
864 {
865 dual_phi[j][qp] += dual_coeff(i, j) * phi[i][qp];
866 if (calculate_dphi)
867 dual_dphi[j][qp] += dual_coeff(i, j) * dphi[i][qp];
868#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
869 if (calculate_d2phi)
870 dual_d2phi[j][qp] += dual_coeff(i, j) * d2phi[i][qp];
871#endif
872 }
873}

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 886 of file fe_abstract.C.

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

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 1841 of file fe_base.C.

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

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

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 1534 of file fe_base.C.

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

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 762 of file fe_base.C.

764{
765 //-------------------------------------------------------------------------
766 // Compute the shape function values (and derivatives)
767 // at the Quadrature points. Note that the actual values
768 // have already been computed via init_shape_functions
769
770 // Start logging the shape function computation
771 LOG_SCOPE("compute_shape_functions()", "FE");
772
773 this->determine_calculations();
774
775 if (calculate_phi)
776 this->_fe_trans->map_phi(this->dim, elem, qp, (*this), this->phi, this->_add_p_level_in_reinit);
777
778 if (calculate_dphi)
779 this->_fe_trans->map_dphi(this->dim, elem, qp, (*this), this->dphi,
780 this->dphidx, this->dphidy, this->dphidz);
781
782#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
783 if (calculate_d2phi)
784 this->_fe_trans->map_d2phi(this->dim, qp, (*this), this->d2phi,
785 this->d2phidx2, this->d2phidxdy, this->d2phidxdz,
786 this->d2phidy2, this->d2phidydz, this->d2phidz2);
787#endif //LIBMESH_ENABLE_SECOND_DERIVATIVES
788
789 // Only compute curl for vector-valued elements
790 if (calculate_curl_phi && TypesEqual<OutputType,RealGradient>::value)
791 this->_fe_trans->map_curl(this->dim, elem, qp, (*this), this->curl_phi);
792
793 // Only compute div for vector-valued elements
794 if (calculate_div_phi && TypesEqual<OutputType,RealGradient>::value)
795 this->_fe_trans->map_div(this->dim, elem, qp, (*this), this->div_phi);
796}
libMesh::FEGenericBase::determine_calculations
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:913

◆ 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 913 of file fe_base.C.

914{
915 this->calculations_started = true;
916
917 // If the user did not explicitly pre-request something (or nothing)
918 // to be computed, then we throw an error here.
919 bool requested_ok =
920 this->calculate_nothing || this->calculate_phi || this->calculate_dphi ||
921 this->calculate_dphiref || this->calculate_curl_phi || this->calculate_div_phi ||
922 this->calculate_map;
923
924#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
925 requested_ok = requested_ok || this->calculate_d2phi;
926#endif
927
928 libmesh_error_msg_if(
929 !requested_ok,
930 "You must call one or more of the FE accessors "
931 "(e.g. get_phi(), get_dphi(), get_nothing()) "
932 "_before_ calling reinit()!");
933
934 // Request whichever terms are necessary from the FEMap
935 if (this->calculate_phi)
936 this->_fe_trans->init_map_phi(*this);
937
938 if (this->calculate_dphiref)
939 this->_fe_trans->init_map_dphi(*this);
940
941#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
942 if (this->calculate_d2phi)
943 this->_fe_trans->init_map_d2phi(*this);
944#endif //LIBMESH_ENABLE_SECOND_DERIVATIVES
945}
libMesh::FEAbstract::calculations_started
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition fe_abstract.h:666
libMesh::FEAbstract::calculate_dphiref
bool calculate_dphiref
Should we calculate reference shape function gradients?
Definition fe_abstract.h:722

◆ 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}
libMesh::ReferenceCounter::_enable_print_counter
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called.
Definition reference_counter.h:143

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{
96 _enable_print_counter = true;
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 >, 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
Returns
The curl of the shape function at the quadrature points.

Definition at line 252 of file fe_base.h.

253 { libmesh_assert(!calculations_started || calculate_curl_phi);
254 calculate_curl_phi = calculate_dphiref = true; return curl_phi; }

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

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::FEMContext::build_new_fe(), CurlCurlSystem::element_time_derivative(), CurlCurlSystem::init_context(), libMesh::FEMContext::interior_curl(), and libMesh::FEMContext::point_curl().

◆ 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();}
libMesh::FEAbstract::_fe_map
std::unique_ptr< FEMap > _fe_map
Definition fe_abstract.h:654

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
Returns
The shape function second derivatives at the quadrature points.

Definition at line 319 of file fe_base.h.

320 { libmesh_assert(!calculations_started || calculate_d2phi);
321 calculate_d2phi = calculate_dphiref = true; return d2phi; }

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

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::FEMContext::build_new_fe(), libMesh::ExactErrorEstimator::find_squared_element_error(), libMesh::FEMContext::fixed_point_hessian(), libMesh::ParsedFEMFunction< Output >::init_context(), libMesh::LaplacianErrorEstimator::init_context(), libMesh::FEMContext::interior_hessians(), libMesh::LaplacianErrorEstimator::internal_side_integration(), libMesh::FEMContext::point_hessian(), libMesh::FEMContext::side_hessians(), and libMesh::FEMContext::some_hessian().

◆ get_d2phideta2()

template<typename OutputType >
const std::vector< std::vector< OutputShape > > & libMesh::FEGenericBase< OutputType >::get_d2phideta2 ( ) const
inline
Returns
The shape function second derivatives at the quadrature points, in reference coordinates

Definition at line 403 of file fe_base.h.

404 { libmesh_assert(!calculations_started || calculate_d2phi);
405 calculate_d2phi = calculate_dphiref = true; return d2phideta2; }

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

Referenced by libMesh::H1FETransformation< OutputShape >::map_d2phi().

◆ get_d2phidetadzeta()

template<typename OutputType >
const std::vector< std::vector< OutputShape > > & libMesh::FEGenericBase< OutputType >::get_d2phidetadzeta ( ) const
inline
Returns
The shape function second derivatives at the quadrature points, in reference coordinates

Definition at line 411 of file fe_base.h.

412 { libmesh_assert(!calculations_started || calculate_d2phi);
413 calculate_d2phi = calculate_dphiref = true; return d2phidetadzeta; }

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

Referenced by libMesh::H1FETransformation< OutputShape >::map_d2phi().

◆ get_d2phidx2()

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

Definition at line 331 of file fe_base.h.

332 { libmesh_assert(!calculations_started || calculate_d2phi);
333 calculate_d2phi = calculate_dphiref = true; return d2phidx2; }

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

◆ get_d2phidxdy()

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

Definition at line 339 of file fe_base.h.

340 { libmesh_assert(!calculations_started || calculate_d2phi);
341 calculate_d2phi = calculate_dphiref = true; return d2phidxdy; }

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

◆ get_d2phidxdz()

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

Definition at line 347 of file fe_base.h.

348 { libmesh_assert(!calculations_started || calculate_d2phi);
349 calculate_d2phi = calculate_dphiref = true; return d2phidxdz; }

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

◆ get_d2phidxi2()

template<typename OutputType >
const std::vector< std::vector< OutputShape > > & libMesh::FEGenericBase< OutputType >::get_d2phidxi2 ( ) const
inline
Returns
The shape function second derivatives at the quadrature points, in reference coordinates

Definition at line 379 of file fe_base.h.

380 { libmesh_assert(!calculations_started || calculate_d2phi);
381 calculate_d2phi = calculate_dphiref = true; return d2phidxi2; }

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

Referenced by libMesh::H1FETransformation< OutputShape >::map_d2phi().

◆ get_d2phidxideta()

template<typename OutputType >
const std::vector< std::vector< OutputShape > > & libMesh::FEGenericBase< OutputType >::get_d2phidxideta ( ) const
inline
Returns
The shape function second derivatives at the quadrature points, in reference coordinates

Definition at line 387 of file fe_base.h.

388 { libmesh_assert(!calculations_started || calculate_d2phi);
389 calculate_d2phi = calculate_dphiref = true; return d2phidxideta; }

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

Referenced by libMesh::H1FETransformation< OutputShape >::map_d2phi().

◆ get_d2phidxidzeta()

template<typename OutputType >
const std::vector< std::vector< OutputShape > > & libMesh::FEGenericBase< OutputType >::get_d2phidxidzeta ( ) const
inline
Returns
The shape function second derivatives at the quadrature points, in reference coordinates

Definition at line 395 of file fe_base.h.

396 { libmesh_assert(!calculations_started || calculate_d2phi);
397 calculate_d2phi = calculate_dphiref = true; return d2phidxidzeta; }

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

Referenced by libMesh::H1FETransformation< OutputShape >::map_d2phi().

◆ get_d2phidy2()

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

Definition at line 355 of file fe_base.h.

356 { libmesh_assert(!calculations_started || calculate_d2phi);
357 calculate_d2phi = calculate_dphiref = true; return d2phidy2; }

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

◆ get_d2phidydz()

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

Definition at line 363 of file fe_base.h.

364 { libmesh_assert(!calculations_started || calculate_d2phi);
365 calculate_d2phi = calculate_dphiref = true; return d2phidydz; }

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

◆ get_d2phidz2()

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

Definition at line 371 of file fe_base.h.

372 { libmesh_assert(!calculations_started || calculate_d2phi);
373 calculate_d2phi = calculate_dphiref = true; return d2phidz2; }

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

◆ get_d2phidzeta2()

template<typename OutputType >
const std::vector< std::vector< OutputShape > > & libMesh::FEGenericBase< OutputType >::get_d2phidzeta2 ( ) const
inline
Returns
The shape function second derivatives at the quadrature points, in reference coordinates

Definition at line 419 of file fe_base.h.

420 { libmesh_assert(!calculations_started || calculate_d2phi);
421 calculate_d2phi = calculate_dphiref = true; return d2phidzeta2; }

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

Referenced by libMesh::H1FETransformation< OutputShape >::map_d2phi().

◆ 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
Returns
The divergence of the shape function at the quadrature points.

Definition at line 261 of file fe_base.h.

262 { libmesh_assert(!calculations_started || calculate_div_phi);
263 calculate_div_phi = calculate_dphiref = true; return div_phi; }

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

Referenced by libMesh::ExactSolution::_compute_error(), and libMesh::FEMContext::interior_div().

◆ 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 437 of file fe_base.h.

438 { 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 230 of file fe_base.h.

231 { libmesh_assert(!calculations_started || calculate_dphi);
232 calculate_dphi = calculate_dphiref = true; return dphi; }

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(), 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(), 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 511 of file fe_base.h.

512 { return get_dphi();}
libMesh::FEGenericBase::get_dphi
const std::vector< std::vector< OutputGradient > > & get_dphi() const
Definition fe_base.h:230

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 501 of file fe_base.h.

502 { 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
Returns
The shape function eta-derivative at the quadrature points.

Definition at line 301 of file fe_base.h.

302 { libmesh_assert(!calculations_started || calculate_dphiref);
303 calculate_dphiref = true; return dphideta; }

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

Referenced by libMesh::HCurlFETransformation< OutputShape >::map_curl(), libMesh::H1FETransformation< OutputShape >::map_curl(), libMesh::H1FETransformation< OutputShape >::map_d2phi(), libMesh::HDivFETransformation< OutputShape >::map_div(), libMesh::H1FETransformation< OutputShape >::map_div(), and libMesh::H1FETransformation< OutputShape >::map_dphi().

◆ get_dphidx()

template<typename OutputType >
const std::vector< std::vector< OutputShape > > & libMesh::FEGenericBase< OutputType >::get_dphidx ( ) const
inline
Returns
The shape function x-derivative at the quadrature points.

Definition at line 269 of file fe_base.h.

270 { libmesh_assert(!calculations_started || calculate_dphi);
271 calculate_dphi = calculate_dphiref = true; return dphidx; }

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

◆ get_dphidxi()

template<typename OutputType >
const std::vector< std::vector< OutputShape > > & libMesh::FEGenericBase< OutputType >::get_dphidxi ( ) const
inline
Returns
The shape function xi-derivative at the quadrature points.

Definition at line 293 of file fe_base.h.

294 { libmesh_assert(!calculations_started || calculate_dphiref);
295 calculate_dphiref = true; return dphidxi; }

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

Referenced by libMesh::HCurlFETransformation< OutputShape >::map_curl(), libMesh::H1FETransformation< OutputShape >::map_curl(), libMesh::H1FETransformation< OutputShape >::map_d2phi(), libMesh::HDivFETransformation< OutputShape >::map_div(), libMesh::H1FETransformation< OutputShape >::map_div(), and libMesh::H1FETransformation< OutputShape >::map_dphi().

◆ get_dphidy()

template<typename OutputType >
const std::vector< std::vector< OutputShape > > & libMesh::FEGenericBase< OutputType >::get_dphidy ( ) const
inline
Returns
The shape function y-derivative at the quadrature points.

Definition at line 277 of file fe_base.h.

278 { libmesh_assert(!calculations_started || calculate_dphi);
279 calculate_dphi = calculate_dphiref = true; return dphidy; }

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

◆ get_dphidz()

template<typename OutputType >
const std::vector< std::vector< OutputShape > > & libMesh::FEGenericBase< OutputType >::get_dphidz ( ) const
inline
Returns
The shape function z-derivative at the quadrature points.

Definition at line 285 of file fe_base.h.

286 { libmesh_assert(!calculations_started || calculate_dphi);
287 calculate_dphi = calculate_dphiref = true; return dphidz; }

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

◆ get_dphidzeta()

template<typename OutputType >
const std::vector< std::vector< OutputShape > > & libMesh::FEGenericBase< OutputType >::get_dphidzeta ( ) const
inline
Returns
The shape function zeta-derivative at the quadrature points.

Definition at line 309 of file fe_base.h.

310 { libmesh_assert(!calculations_started || calculate_dphiref);
311 calculate_dphiref = true; return dphidzeta; }

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

Referenced by libMesh::HCurlFETransformation< OutputShape >::map_curl(), libMesh::H1FETransformation< OutputShape >::map_curl(), libMesh::H1FETransformation< OutputShape >::map_d2phi(), libMesh::HDivFETransformation< OutputShape >::map_div(), libMesh::H1FETransformation< OutputShape >::map_div(), and libMesh::H1FETransformation< OutputShape >::map_dphi().

◆ get_dual_coeff()

template<typename OutputType >
const DenseMatrix< Real > & libMesh::FEGenericBase< OutputType >::get_dual_coeff ( ) const
inline

Definition at line 244 of file fe_base.h.

245 { 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

Definition at line 323 of file fe_base.h.

324 { libmesh_assert(!calculations_started || calculate_d2phi);
325 calculate_d2phi = calculate_dual = calculate_dphiref = true; return dual_d2phi; }
libMesh::FEAbstract::calculate_dual
bool calculate_dual
Are we calculating dual basis?
Definition fe_abstract.h:671

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

Definition at line 234 of file fe_base.h.

235 { libmesh_assert(!calculations_started || calculate_dphi);
236 calculate_dphi = calculate_dual = calculate_dphiref = true; return dual_dphi; }

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

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

◆ get_dual_phi()

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

Definition at line 211 of file fe_base.h.

212 {
213 libmesh_assert(!calculations_started || calculate_dual);
214 calculate_dual = true;
215 // Dual phi computation relies on primal phi computation
216 this->request_phi();
217 return dual_phi;
218 }
libMesh::FEGenericBase::request_phi
virtual void request_phi() const override
request phi calculations
Definition fe_base.h:220

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; }
libMesh::FEAbstract::_elem
const Elem * _elem
The element the current data structures were set up for.
Definition fe_abstract.h:740

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
Returns
The mapping object
Note
for InfFE, this gives a useless object.

Definition at line 554 of file fe_abstract.h.

554{ return *_fe_map.get(); }

References libMesh::FEAbstract::_fe_map.

Referenced by libMesh::VariationalSmootherSystem::init_context(), libMesh::H1FETransformation< OutputShape >::init_map_d2phi(), libMesh::HCurlFETransformation< OutputShape >::init_map_d2phi(), libMesh::HDivFETransformation< OutputShape >::init_map_d2phi(), libMesh::H1FETransformation< OutputShape >::init_map_dphi(), libMesh::HCurlFETransformation< OutputShape >::init_map_dphi(), libMesh::HDivFETransformation< OutputShape >::init_map_dphi(), libMesh::HCurlFETransformation< OutputShape >::init_map_phi(), libMesh::HDivFETransformation< OutputShape >::init_map_phi(), libMesh::HCurlFETransformation< OutputShape >::map_curl(), libMesh::H1FETransformation< OutputShape >::map_curl(), libMesh::H1FETransformation< OutputShape >::map_d2phi(), libMesh::HDivFETransformation< OutputShape >::map_div(), libMesh::H1FETransformation< OutputShape >::map_div(), libMesh::H1FETransformation< OutputShape >::map_dphi(), libMesh::HCurlFETransformation< OutputShape >::map_phi(), and libMesh::HDivFETransformation< OutputShape >::map_phi().

◆ get_fe_type()

FEType libMesh::FEAbstract::get_fe_type ( ) const
inlineinherited
Returns
The FE Type (approximation order and family) of the finite element.

Definition at line 520 of file fe_abstract.h.

520{ return fe_type; }

References libMesh::FEAbstract::fe_type.

Referenced by libMesh::RBConstruction::add_scaled_matrix_and_vector(), assemble_func(), assemble_SchroedingerEquation(), assemble_wave(), libMesh::FEMContext::build_new_fe(), libMesh::HCurlFETransformation< OutputShape >::map_phi(), libMesh::HDivFETransformation< OutputShape >::map_phi(), libMesh::H1FETransformation< OutputShape >::map_phi(), NavierSystem::side_constraint(), and libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::SubFunctor().

◆ 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}
libMesh::ReferenceCounter::_counts
static Counts _counts
Actually holds the data.
Definition reference_counter.h:124
libMesh::Quality::name
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition elem_quality.C:42

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(), 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(), 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();}
libMesh::FEAbstract::get_JxW
virtual_for_inffe const std::vector< Real > & get_JxW() const
Definition fe_abstract.h:303

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
Returns
The outward pointing normal vectors for face integration.

Definition at line 459 of file fe_abstract.h.

460 { calculate_map = true; return this->_fe_map->get_normals(); }

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

Referenced by libMesh::KellyErrorEstimator::boundary_side_integration(), compute_enriched_soln(), libMesh::ParsedFEMFunction< Output >::eval_args(), libMesh::ParsedFEMFunction< Output >::init_context(), ElasticitySystem::init_context(), libMesh::KellyErrorEstimator::init_context(), libMesh::KellyErrorEstimator::internal_side_integration(), LaplaceSystem::side_postprocess(), LaplaceSystem::side_qoi_derivative(), ElasticitySystem::side_time_derivative(), and CurlCurlSystem::side_time_derivative().

◆ 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(), 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; }
libMesh::FEAbstract::_p_level
unsigned int _p_level
The p refinement level the current data structures are set up for.
Definition fe_abstract.h:757

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.

208 { libmesh_assert(!calculations_started || calculate_phi);
209 calculate_phi = true; return phi; }

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(), 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(), 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 493 of file fe_base.h.

494 { return get_phi();}
libMesh::FEGenericBase::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 400 of file fe_abstract.C.

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

462 { 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 480 of file fe_base.h.

481 { 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 453 of file fe_base.h.

454 { 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 470 of file fe_base.h.

471 { 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; }
libMesh::FEAbstract::_elem_type
ElemType _elem_type
The element type the current data structures were set up for.
Definition fe_abstract.h:735

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(), 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(), 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}
libMesh::BasicOStreamProxy::get
streamT * get()
Rather than implement every ostream/ios/ios_base function, we'll be lazy and make esoteric uses go th...
Definition ostream_proxy.h:217
libMesh::err
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

Initialize the data fields for the base of an an infinite element.

Implement this in the derived class FE<Dim,T>.

Implemented in 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 >.

◆ 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 >, 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; }
libMesh::ReferenceCounter::_n_objects
static Threads::atomic< unsigned int > _n_objects
The number of objects.
Definition reference_counter.h:132

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 1279 of file fe_abstract.C.

1280{
1281 if (this->shapes_on_quadrature)
1282 {
1283 libmesh_assert(this->qrule);
1284 libmesh_assert_equal_to(this->qrule->n_points(),
1285 this->_n_total_qp);
1286 }
1287 return this->_n_total_qp;
1288}
libMesh::FEAbstract::shapes_on_quadrature
bool shapes_on_quadrature
A flag indicating if current data structures correspond to quadrature rule points.
Definition fe_abstract.h:768
libMesh::FEAbstract::_n_total_qp
unsigned int _n_total_qp
The total number of quadrature points for the current configuration.
Definition fe_abstract.h:774

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
Returns
The total number of approximation shape functions for the current element. Useful during matrix assembly. Implement this in derived classes.

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 >, and libMesh::InfFE< Dim, T_radial, T_map >.

◆ 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 637 of file fe_abstract.C.

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

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 953 of file fe_base.C.

954{
955 for (auto i : index_range(dphi))
956 for (auto j : index_range(dphi[i]))
957 os << " d2phi[" << i << "][" << j << "]=" << d2phi[i][j];
958}

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 895 of file fe_base.C.

896{
897 for (auto i : index_range(dphi))
898 for (auto j : index_range(dphi[i]))
899 os << " dphi[" << i << "][" << j << "]=" << dphi[i][j];
900}

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 961 of file fe_base.C.

962{
963 for (auto i : index_range(dual_d2phi))
964 for (auto j : index_range(dual_d2phi[i]))
965 os << " dual_d2phi[" << i << "][" << j << "]=" << dual_d2phi[i][j];
966}

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 903 of file fe_base.C.

904{
905 for (auto i : index_range(dphi))
906 for (auto j : index_range(dphi[i]))
907 os << " dual_dphi[" << i << "][" << j << "]=" << dual_dphi[i][j];
908}

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 884 of file fe_base.C.

885{
886 for (auto i : index_range(dual_phi))
887 for (auto j : index_range(dual_phi[i]))
888 os << " dual_phi[" << i << "][" << j << "]=" << dual_phi[i][j] << std::endl;
889}

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 859 of file fe_abstract.C.

860{
861 os << "phi[i][j]: Shape function i at quadrature pt. j" << std::endl;
862 this->print_phi(os);
863
864 os << "dphi[i][j]: Shape function i's gradient at quadrature pt. j" << std::endl;
865 this->print_dphi(os);
866
867 os << "XYZ locations of the quadrature pts." << std::endl;
868 this->print_xyz(os);
869
870 os << "Values of JxW at the quadrature pts." << std::endl;
871 this->print_JxW(os);
872}
libMesh::FEAbstract::print_JxW
void print_JxW(std::ostream &os) const
Prints the Jacobian times the weight for each quadrature point.
Definition fe_abstract.C:846
libMesh::FEAbstract::print_dphi
virtual void print_dphi(std::ostream &os) const =0
Prints the value of each shape function's derivative at each quadrature point.
libMesh::FEAbstract::print_phi
virtual void print_phi(std::ostream &os) const =0
Prints the value of each shape function at each quadrature point.
libMesh::FEAbstract::print_xyz
void print_xyz(std::ostream &os) const
Prints the spatial location of each quadrature point (on the physical element).
Definition fe_abstract.C:853

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{
83 if (_enable_print_counter)
84 out_stream << ReferenceCounter::get_info();
85}
libMesh::ReferenceCounter::get_info
static std::string get_info()
Gets a string containing the reference information.
Definition reference_counter.C:47

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 846 of file fe_abstract.C.

847{
848 this->_fe_map->print_JxW(os);
849}

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 876 of file fe_base.C.

877{
878 for (auto i : index_range(phi))
879 for (auto j : index_range(phi[i]))
880 os << " phi[" << i << "][" << j << "]=" << phi[i][j] << std::endl;
881}

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 853 of file fe_abstract.C.

854{
855 this->_fe_map->print_xyz(os);
856}

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

Reinitializes all the physical element-dependent data based on the side 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 side element may be specified in the optional argument pts.

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

◆ reinit_default_dual_shape_coeffs()

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

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

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 161 of file fe_abstract.h.

162 {
163 libmesh_error_msg("Default dual shape coefficient calculation has not been implemented for this FE type.");
164 }

◆ 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 238 of file fe_base.h.

239 { 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 241 of file fe_base.h.

242 { get_dual_dphi(); }
libMesh::FEGenericBase::get_dual_dphi
const std::vector< std::vector< OutputGradient > > & get_dual_dphi() const
Definition fe_base.h:234

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 223 of file fe_base.h.

224 { get_dual_phi(); }
libMesh::FEGenericBase::get_dual_phi
const std::vector< std::vector< OutputShape > > & get_dual_phi() const
Definition fe_base.h:211

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 220 of file fe_base.h.

221 { 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.

626{calculate_default_dual_coeff = val; }
libMesh::FEAbstract::calculate_default_dual_coeff
bool calculate_default_dual_coeff
Are we calculating the coefficient for the dual basis using the default qrule?
Definition fe_abstract.h:676

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 >, 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

Computes the reference space quadrature points on the side of an element based on the side quadrature points.

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 >.

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 781 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

Definition at line 654 of file fe_abstract.h.

Referenced by libMesh::FEAbstract::get_curvatures(), libMesh::FEAbstract::get_d2xyzdeta2(), libMesh::FEAbstract::get_d2xyzdetadzeta(), libMesh::FEAbstract::get_d2xyzdxi2(), libMesh::FEAbstract::get_d2xyzdxideta(), libMesh::FEAbstract::get_d2xyzdxidzeta(), libMesh::FEAbstract::get_d2xyzdzeta2(), libMesh::FEAbstract::get_detadx(), libMesh::FEAbstract::get_detady(), libMesh::FEAbstract::get_detadz(), libMesh::FEAbstract::get_dxidx(), libMesh::FEAbstract::get_dxidy(), libMesh::FEAbstract::get_dxidz(), libMesh::FEAbstract::get_dxyzdeta(), libMesh::FEAbstract::get_dxyzdxi(), libMesh::FEAbstract::get_dxyzdzeta(), libMesh::FEAbstract::get_dzetadx(), libMesh::FEAbstract::get_dzetady(), libMesh::FEAbstract::get_dzetadz(), libMesh::FEAbstract::get_fe_map(), libMesh::FEAbstract::get_fe_map(), libMesh::FEAbstract::get_JxW(), libMesh::FEAbstract::get_normals(), libMesh::FEAbstract::get_tangents(), libMesh::FEAbstract::get_xyz(), libMesh::FEAbstract::print_JxW(), and libMesh::FEAbstract::print_xyz().

◆ _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 609 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

The number of objects.

Print the reference count information when the number returns to 0.

Definition at line 132 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::n_objects(), libMesh::ReferenceCounter::ReferenceCounter(), libMesh::ReferenceCounter::ReferenceCounter(), libMesh::ReferenceCounter::ReferenceCounter(), and libMesh::ReferenceCounter::~ReferenceCounter().

◆ _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

Should we calculate shape function hessians?

Definition at line 702 of file fe_abstract.h.

Referenced by libMesh::FEGenericBase< OutputType >::calculating_nothing(), 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(), and libMesh::FEGenericBase< OutputType >::get_dual_d2phi().

◆ 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

Should we calculate shape function gradients?

Definition at line 696 of file fe_abstract.h.

Referenced by libMesh::FEGenericBase< OutputType >::calculating_nothing(), libMesh::FEGenericBase< OutputType >::get_dphi(), libMesh::FEGenericBase< OutputType >::get_dphidx(), libMesh::FEGenericBase< OutputType >::get_dphidy(), libMesh::FEGenericBase< OutputType >::get_dphidz(), libMesh::FEGenericBase< OutputType >::get_dual_dphi(), and libMesh::InfFE< Dim, T_radial, T_map >::get_Sobolev_dweight().

◆ calculate_dphiref

bool libMesh::FEAbstract::calculate_dphiref
mutableprotectedinherited

Should we calculate reference shape function gradients?

Definition at line 722 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::FEGenericBase< OutputType >::get_div_phi(), libMesh::FEGenericBase< OutputType >::get_dphi(), 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(), and libMesh::FEGenericBase< OutputType >::get_dual_dphi().

◆ calculate_dual

bool libMesh::FEAbstract::calculate_dual
mutableprotectedinherited

Are we calculating dual basis?

Definition at line 671 of file fe_abstract.h.

Referenced by libMesh::FEGenericBase< OutputType >::get_dual_d2phi(), libMesh::FEGenericBase< OutputType >::get_dual_dphi(), libMesh::FEGenericBase< OutputType >::get_dual_phi(), and libMesh::FEAbstract::set_calculate_dual().

◆ 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

Should we calculate shape functions?

Definition at line 691 of file fe_abstract.h.

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

◆ 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 631 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 674 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 695 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 700 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 710 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 715 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 720 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 680 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 685 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 690 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 725 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 730 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 735 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 705 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 636 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 753 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 620 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 646 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 656 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 641 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 661 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 666 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 651 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 626 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 675 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 621 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 615 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 760 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

The finite element type for this object.

Note
This should be constant for the object.

Definition at line 730 of file fe_abstract.h.

Referenced by libMesh::FEAbstract::compute_node_constraints(), libMesh::FEAbstract::compute_periodic_node_constraints(), libMesh::FEAbstract::get_family(), libMesh::FEAbstract::get_fe_type(), libMesh::FEAbstract::get_order(), libMesh::InfFE< Dim, T_radial, T_map >::InfFE(), and libMesh::FEAbstract::set_fe_order().

◆ phi

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

Shape function values.

Definition at line 614 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 767 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:
Generated on Mon Aug 24 2026 19:00:51 for libMesh by doxygen 1.9.8