libMesh
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 <exact_error_estimator.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. More...
 
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. More...
 
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 More...
 
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 More...
 
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. More...
 
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. More...
 
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. More...
 
virtual void print_dual_d2phi (std::ostream &os) const override
 
template<>
std::unique_ptr< FEGenericBase< Real > > build (const unsigned int dim, const FEType &fet)
 
template<>
std::unique_ptr< FEGenericBase< RealGradient > > build (const unsigned int dim, const FEType &fet)
 
template<>
std::unique_ptr< FEGenericBase< Real > > build_InfFE (const unsigned int dim, const FEType &fet)
 
template<>
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. More...
 
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. More...
 
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. More...
 
virtual void reinit_default_dual_shape_coeffs (const Elem *)
 This re-computes the dual shape function coefficients using DEFAULT qrule. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
virtual unsigned int n_shape_functions () const =0
 
virtual unsigned int n_quadrature_points () const
 
const Elemget_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. More...
 
virtual FEContinuity get_continuity () const =0
 
virtual bool is_hierarchic () const =0
 
FEFamily get_family () const
 
const FEMapget_fe_map () const
 
FEMapget_fe_map ()
 
void print_JxW (std::ostream &os) const
 Prints the Jacobian times the weight for each quadrature point. More...
 
void print_xyz (std::ostream &os) const
 Prints the spatial location of each quadrature point (on the physical element). More...
 
void print_info (std::ostream &os) const
 Prints all the relevant information about the current element. More...
 
void set_calculate_dual (const bool val)
 set calculate_dual as needed More...
 
void set_calculate_default_dual_coeff (const bool val)
 set calculate_default_dual_coeff as needed More...
 
void add_p_level_in_reinit (bool value)
 Indicate whether to add p-refinement levels in init/reinit methods. More...
 
bool add_p_level_in_reinit () const
 Whether to add p-refinement levels in init/reinit methods. More...
 

Static Public Member Functions

static std::unique_ptr< FEGenericBasebuild (const unsigned int dim, const FEType &type)
 Builds a specific finite element type. More...
 
static std::unique_ptr< FEGenericBasebuild_InfFE (const unsigned int dim, const FEType &type)
 Builds a specific infinite element type. More...
 
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. More...
 
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. More...
 
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. More...
 
static void compute_periodic_constraints (DofConstraints &constraints, DofMap &dof_map, const PeriodicBoundaries &boundaries, const MeshBase &mesh, const PointLocatorBase *point_locator, const unsigned int variable_number, const Elem *elem)
 Computes the constraint matrix contributions (for meshes with periodic boundary conditions) corresponding to variable number var_number, using generic projections. More...
 
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. More...
 
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) More...
 
static void print_info (std::ostream &out_stream=libMesh::out)
 Prints the reference information, by default to libMesh::out. More...
 
static std::string get_info ()
 Gets a string containing the reference information. More...
 
static unsigned int n_objects ()
 Prints the number of outstanding (created, but not yet destroyed) objects. More...
 
static void enable_print_counter_info ()
 Methods to enable/disable the reference counter output from print_info() More...
 
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. More...
 

Protected Member Functions

 FEGenericBase (const unsigned int dim, const FEType &fet)
 Constructor. More...
 
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. More...
 
virtual_for_inffe void determine_calculations ()
 Determine which values are to be calculated, for both the FE itself and for the FEMap. More...
 
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. More...
 
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. More...
 
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. More...
 
template<>
void compute_dual_shape_functions ()
 
template<>
void compute_dual_shape_coeffs (const std::vector< Real > &, const std::vector< std::vector< OutputShape >> &)
 
template<>
void compute_dual_shape_coeffs (const std::vector< Real > &JxW, const std::vector< std::vector< OutputShape >> &phi_vals)
 
template<>
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. More...
 
void increment_destructor_count (const std::string &name) noexcept
 Increments the destruction counter. More...
 

Protected Attributes

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

Static Protected Attributes

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

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

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 39 of file exact_error_estimator.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),
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 
869 template <typename OutputType>
870 inline
872 {
873 }
std::vector< std::vector< OutputTensor > > d2phi
Shape function second derivative values.
Definition: fe_base.h:674
std::vector< std::vector< OutputShape > > dphidxi
Shape function derivatives in the xi direction.
Definition: fe_base.h:641
std::vector< std::vector< OutputShape > > d2phidxdz
Shape function second derivatives in the x-z direction.
Definition: fe_base.h:720
std::vector< std::vector< OutputShape > > dphidzeta
Shape function derivatives in the zeta direction.
Definition: fe_base.h:651
std::vector< std::vector< OutputShape > > d2phidydz
Shape function second derivatives in the y-z direction.
Definition: fe_base.h:730
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
std::vector< std::vector< OutputShape > > d2phidxideta
Shape function second derivatives in the xi-eta direction.
Definition: fe_base.h:685
std::vector< std::vector< OutputTensor > > dual_d2phi
Definition: fe_base.h:675
FEAbstract(const unsigned int dim, const FEType &fet)
Constructor.
Definition: fe_abstract.C:47
std::vector< Real > weight
Used for certain infinite element families: the additional radial weight in local coordinates...
Definition: fe_base.h:767
std::vector< std::vector< OutputGradient > > dual_dphi
Definition: fe_base.h:621
std::vector< std::vector< OutputShape > > d2phidx2
Shape function second derivatives in the x direction.
Definition: fe_base.h:710
std::vector< std::vector< OutputShape > > curl_phi
Shape function curl values.
Definition: fe_base.h:631
std::vector< std::vector< OutputShape > > dphidy
Shape function derivatives in the y direction.
Definition: fe_base.h:661
std::vector< std::vector< OutputShape > > d2phidy2
Shape function second derivatives in the y direction.
Definition: fe_base.h:725
std::vector< std::vector< OutputShape > > d2phidetadzeta
Shape function second derivatives in the eta-zeta direction.
Definition: fe_base.h:700
std::vector< std::vector< OutputShape > > d2phidxidzeta
Shape function second derivatives in the xi-zeta direction.
Definition: fe_base.h:690
static std::unique_ptr< FETransformationBase< OutputShape > > build(const FEType &type)
Builds an FETransformation object based on the finite element type.
std::vector< std::vector< OutputShape > > d2phidxdy
Shape function second derivatives in the x-y direction.
Definition: fe_base.h:715
std::vector< std::vector< OutputShape > > dphidx
Shape function derivatives in the x direction.
Definition: fe_base.h:656
std::vector< std::vector< OutputShape > > phi
Shape function values.
Definition: fe_base.h:614
std::vector< std::vector< OutputShape > > d2phideta2
Shape function second derivatives in the eta direction.
Definition: fe_base.h:695
std::vector< std::vector< OutputShape > > dual_phi
Definition: fe_base.h:615
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
virtual ~FEGenericBase()
Destructor.
std::vector< std::vector< OutputDivergence > > div_phi
Shape function divergence values.
Definition: fe_base.h:636
std::vector< std::vector< OutputGradient > > dphi
Shape function derivative values.
Definition: fe_base.h:620
std::vector< std::vector< OutputShape > > d2phidz2
Shape function second derivatives in the z direction.
Definition: fe_base.h:735
std::vector< std::vector< OutputShape > > d2phidxi2
Shape function second derivatives in the xi direction.
Definition: fe_base.h:680
std::vector< std::vector< OutputShape > > d2phidzeta2
Shape function second derivatives in the zeta direction.
Definition: fe_base.h:705
std::vector< std::vector< OutputShape > > dphidz
Shape function derivatives in the z direction.
Definition: fe_base.h:666
std::vector< std::vector< OutputShape > > dphideta
Shape function derivatives in the eta direction.
Definition: fe_base.h:646
std::vector< RealGradient > dweight
Used for certain infinite element families: the global derivative of the additional radial weight ...
Definition: fe_base.h:760

◆ ~FEGenericBase()

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

Destructor.

Member Function Documentation

◆ add_p_level_in_reinit() [1/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.

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

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

bool _add_p_level_in_reinit
Whether to add p-refinement levels in init/reinit methods.
Definition: fe_abstract.h:787
static const bool value
Definition: xdr_io.C:54

◆ add_p_level_in_reinit() [2/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.

References libMesh::FEAbstract::_add_p_level_in_reinit.

636 { return _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

◆ attach_quadrature_rule()

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

◆ build() [1/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(), assemble(), LinearElasticity::assemble(), assemble_1D(), libMesh::ClawSystem::assemble_advection_matrices(), libMesh::ClawSystem::assemble_avg_coupling_matrices(), assemble_biharmonic(), libMesh::ClawSystem::assemble_boundary_condition_matrices(), 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_SchroedingerEquation(), assemble_shell(), assemble_stokes(), assemble_wave(), libMesh::FEMContext::cached_fe(), libMesh::System::calculate_norm(), libMesh::FEInterface::compute_data(), compute_enriched_soln(), compute_jacobian(), compute_residual(), compute_stresses(), LinearElasticity::compute_stresses(), LargeDeformationElasticity::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(), LaplaceYoung::jacobian(), LargeDeformationElasticity::jacobian(), libMesh::LIBMESH_DEFAULT_VECTORIZED_FE(), main(), OverlappingCouplingFunctor::operator()(), libMesh::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()(), periodic_bc_test_poisson(), libMesh::System::point_hessian(), libMesh::InfFE< Dim, T_radial, T_map >::reinit(), LaplaceYoung::residual(), LargeDeformationElasticity::residual(), libMesh::HPCoarsenTest::select_refinement(), RationalMapTest< elem_type >::setUp(), DualShapeTest::setUp(), FETestBase< order, family, elem_type, 1 >::setUp(), FETest< order, family, elem_type >::testCustomReinit(), InfFERadialTest::testRefinement(), InfFERadialTest::testSides(), libMesh::Elem::true_centroid(), and libMesh::Elem::volume().

◆ build() [2/3]

template<>
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 }
FEFamily family
The type of finite element.
Definition: fe_type.h:221
const unsigned int dim
The dimensionality of the object.
Definition: fe_abstract.h:660
std::string enum_to_string(const T e)

◆ build() [3/3]

template<>
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 }
FEFamily family
The type of finite element.
Definition: fe_type.h:221
const unsigned int dim
The dimensionality of the object.
Definition: fe_abstract.h:660
std::string enum_to_string(const T e)

◆ build_InfFE() [1/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() [2/3]

template<>
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 }
const unsigned int dim
The dimensionality of the object.
Definition: fe_abstract.h:660
InfMapType inf_map
The coordinate mapping type of the infinite element.
Definition: fe_type.h:275
FEFamily radial_family
The type of approximation in radial direction.
Definition: fe_type.h:267
std::string enum_to_string(const T e)

◆ build_InfFE() [3/3]

template<>
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  }
bool calculate_d2phi
Should we calculate shape function hessians?
Definition: fe_abstract.h:702
bool calculate_curl_phi
Should we calculate shape function curls?
Definition: fe_abstract.h:712
bool calculate_phi
Should we calculate shape functions?
Definition: fe_abstract.h:691
bool calculate_div_phi
Should we calculate shape function divergences?
Definition: fe_abstract.h:717
bool calculate_dphi
Should we calculate shape function gradients?
Definition: fe_abstract.h:696
bool calculate_map
Are we calculating mapping functions?
Definition: fe_abstract.h:686
bool calculate_nothing
Are we potentially deliberately calculating nothing?
Definition: fe_abstract.h:681

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

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

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

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

1552 {
1553  Ue.resize(0);
1554 
1555  for (auto v : make_range(dof_map.n_variables()))
1556  {
1557  DenseVector<Number> Usub;
1558 
1559  coarsened_dof_values(old_vector, dof_map, elem, Usub,
1560  v, use_old_dof_indices);
1561 
1562  Ue.append (Usub);
1563  }
1564 }
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&#39;s children...
Definition: fe_base.C:1012
unsigned int n_variables() const override
Definition: dof_map.h:628
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:140

◆ compute_dual_shape_coeffs() [1/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() [2/3]

template<>
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 }
DenseMatrix< Real > dual_coeff
Coefficient matrix for the dual basis.
Definition: fe_base.h:626
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
Defines a dense vector for use in Finite Element-type computations.
Definition: dof_map.h:74
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:117

◆ compute_dual_shape_coeffs() [3/3]

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

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

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

◆ compute_dual_shape_functions() [3/3]

template<>
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 }
bool calculate_d2phi
Should we calculate shape function hessians?
Definition: fe_abstract.h:702
std::vector< std::vector< OutputTensor > > d2phi
Shape function second derivative values.
Definition: fe_base.h:674
std::vector< std::vector< OutputTensor > > dual_d2phi
Definition: fe_base.h:675
std::vector< std::vector< OutputGradient > > dual_dphi
Definition: fe_base.h:621
unsigned int m() const
DenseMatrix< Real > dual_coeff
Coefficient matrix for the dual basis.
Definition: fe_base.h:626
std::vector< std::vector< OutputShape > > phi
Shape function values.
Definition: fe_base.h:614
std::vector< std::vector< OutputShape > > dual_phi
Definition: fe_base.h:615
libmesh_assert(ctx)
std::vector< std::vector< OutputGradient > > dphi
Shape function derivative values.
Definition: fe_base.h:620
bool calculate_dphi
Should we calculate shape function gradients?
Definition: fe_abstract.h:696
unsigned int n() const
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:117

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

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

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 }
static unsigned int n_dofs(const unsigned int dim, const FEType &fe_t, const ElemType t)
Definition: fe_interface.C:355
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:1628
OrderWrapper order
The approximation order of the element.
Definition: fe_type.h:215
static unsigned int max_order(const FEType &fe_t, const ElemType &el_t)
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:760
libmesh_assert(ctx)
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
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
FEFamily
defines an enum for finite element families.
FEType fe_type
The finite element type for this object.
Definition: fe_abstract.h:730
static FEFamily map_fe_type(const Elem &elem)
Definition: fe_map.C:46
spin_mutex spin_mtx
A convenient spin mutex object which can be used for obtaining locks.
Definition: threads.C:30
const RemoteElem * remote_elem
Definition: remote_elem.C:57

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

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

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

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

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.

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 }
static unsigned int n_dofs(const unsigned int dim, const FEType &fe_t, const ElemType t)
Definition: fe_interface.C:355
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:1628
MeshBase & mesh
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:760
libmesh_assert(ctx)
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
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
FEFamily
defines an enum for finite element families.
FEType fe_type
The finite element type for this object.
Definition: fe_abstract.h:730
static FEFamily map_fe_type(const Elem &elem)
Definition: fe_map.C:46
spin_mutex spin_mtx
A convenient spin mutex object which can be used for obtaining locks.
Definition: threads.C:30

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

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

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

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

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
791  this->_fe_trans->map_curl(this->dim, elem, qp, (*this), this->curl_phi);
792 
793  // Only compute div for vector-valued elements
795  this->_fe_trans->map_div(this->dim, elem, qp, (*this), this->div_phi);
796 }
bool calculate_d2phi
Should we calculate shape function hessians?
Definition: fe_abstract.h:702
bool calculate_curl_phi
Should we calculate shape function curls?
Definition: fe_abstract.h:712
std::vector< std::vector< OutputTensor > > d2phi
Shape function second derivative values.
Definition: fe_base.h:674
std::vector< std::vector< OutputShape > > d2phidxdz
Shape function second derivatives in the x-z direction.
Definition: fe_base.h:720
std::vector< std::vector< OutputShape > > d2phidydz
Shape function second derivatives in the y-z direction.
Definition: fe_base.h:730
bool calculate_phi
Should we calculate shape functions?
Definition: fe_abstract.h:691
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
std::vector< std::vector< OutputShape > > d2phidx2
Shape function second derivatives in the x direction.
Definition: fe_base.h:710
std::vector< std::vector< OutputShape > > curl_phi
Shape function curl values.
Definition: fe_base.h:631
std::vector< std::vector< OutputShape > > dphidy
Shape function derivatives in the y direction.
Definition: fe_base.h:661
std::vector< std::vector< OutputShape > > d2phidy2
Shape function second derivatives in the y direction.
Definition: fe_base.h:725
bool calculate_div_phi
Should we calculate shape function divergences?
Definition: fe_abstract.h:717
std::vector< std::vector< OutputShape > > d2phidxdy
Shape function second derivatives in the x-y direction.
Definition: fe_base.h:715
std::vector< std::vector< OutputShape > > dphidx
Shape function derivatives in the x direction.
Definition: fe_base.h:656
std::vector< std::vector< OutputShape > > phi
Shape function values.
Definition: fe_base.h:614
const unsigned int dim
The dimensionality of the object.
Definition: fe_abstract.h:660
std::vector< std::vector< OutputDivergence > > div_phi
Shape function divergence values.
Definition: fe_base.h:636
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
std::vector< std::vector< OutputGradient > > dphi
Shape function derivative values.
Definition: fe_base.h:620
bool _add_p_level_in_reinit
Whether to add p-refinement levels in init/reinit methods.
Definition: fe_abstract.h:787
bool calculate_dphi
Should we calculate shape function gradients?
Definition: fe_abstract.h:696
std::vector< std::vector< OutputShape > > d2phidz2
Shape function second derivatives in the z direction.
Definition: fe_base.h:735
std::vector< std::vector< OutputShape > > dphidz
Shape function derivatives in the z direction.
Definition: fe_base.h:666

◆ 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 forgot to request anything, but we're enabling
918  // deprecated backwards compatibility, then we'll be safe and
919  // calculate everything. If we haven't enable deprecated backwards
920  // compatibility then we'll scream and die.
921 #ifdef LIBMESH_ENABLE_DEPRECATED
922 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
923  if (!this->calculate_nothing &&
924  !this->calculate_phi && !this->calculate_dphi &&
925  !this->calculate_dphiref &&
926  !this->calculate_d2phi && !this->calculate_curl_phi &&
927  !this->calculate_div_phi && !this->calculate_map)
928  {
929  libmesh_deprecated();
930  this->calculate_phi = this->calculate_dphi = this->calculate_d2phi = this->calculate_dphiref = true;
932  {
933  this->calculate_curl_phi = true;
934  this->calculate_div_phi = true;
935  }
936  }
937 #else
938  if (!this->calculate_nothing &&
939  !this->calculate_phi && !this->calculate_dphi &&
940  !this->calculate_dphiref &&
941  !this->calculate_curl_phi && !this->calculate_div_phi &&
942  !this->calculate_map)
943  {
944  libmesh_deprecated();
945  this->calculate_phi = this->calculate_dphi = this->calculate_dphiref = true;
947  {
948  this->calculate_curl_phi = true;
949  this->calculate_div_phi = true;
950  }
951  }
952 #endif // LIBMESH_ENABLE_SECOND_DERIVATIVES
953 #else
954 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
956  this->calculate_phi || this->calculate_dphi ||
957  this->calculate_d2phi ||
958  this->calculate_dphiref ||
959  this->calculate_curl_phi || this->calculate_div_phi ||
960  this->calculate_map);
961 #else
963  this->calculate_phi || this->calculate_dphi ||
964  this->calculate_dphiref ||
965  this->calculate_curl_phi || this->calculate_div_phi ||
966  this->calculate_map);
967 #endif // LIBMESH_ENABLE_SECOND_DERIVATIVES
968 #endif // LIBMESH_ENABLE_DEPRECATED
969 
970  // Request whichever terms are necessary from the FEMap
971  if (this->calculate_phi)
972  this->_fe_trans->init_map_phi(*this);
973 
974  if (this->calculate_dphiref)
975  this->_fe_trans->init_map_dphi(*this);
976 
977 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
978  if (this->calculate_d2phi)
979  this->_fe_trans->init_map_d2phi(*this);
980 #endif //LIBMESH_ENABLE_SECOND_DERIVATIVES
981 }
bool calculate_d2phi
Should we calculate shape function hessians?
Definition: fe_abstract.h:702
bool calculate_curl_phi
Should we calculate shape function curls?
Definition: fe_abstract.h:712
FEFamily family
The type of finite element.
Definition: fe_type.h:221
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_abstract.h:666
bool calculate_phi
Should we calculate shape functions?
Definition: fe_abstract.h:691
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
static FEFieldType field_type(const FEType &fe_type)
bool calculate_div_phi
Should we calculate shape function divergences?
Definition: fe_abstract.h:717
libmesh_assert(ctx)
bool calculate_dphiref
Should we calculate reference shape function gradients?
Definition: fe_abstract.h:722
bool calculate_dphi
Should we calculate shape function gradients?
Definition: fe_abstract.h:696
bool calculate_map
Are we calculating mapping functions?
Definition: fe_abstract.h:686
FEType fe_type
The finite element type for this object.
Definition: fe_abstract.h:730
bool calculate_nothing
Are we potentially deliberately calculating nothing?
Definition: fe_abstract.h:681

◆ disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )
staticinherited

Definition at line 100 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

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

◆ 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, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, and libMesh::InfFE< Dim, T_radial, T_map >.

◆ enable_print_counter_info()

void libMesh::ReferenceCounter::enable_print_counter_info ( )
staticinherited

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

Definition at line 94 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

95 {
96  _enable_print_counter = true;
97  return;
98 }
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called...

◆ 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, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::InfFE< Dim, T_radial, T_map >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, and libMesh::FE< Dim, LAGRANGE_VEC >.

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.

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

254  calculate_curl_phi = calculate_dphiref = true; return curl_phi; }
bool calculate_curl_phi
Should we calculate shape function curls?
Definition: fe_abstract.h:712
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_abstract.h:666
std::vector< std::vector< OutputShape > > curl_phi
Shape function curl values.
Definition: fe_base.h:631
libmesh_assert(ctx)
bool calculate_dphiref
Should we calculate reference shape function gradients?
Definition: fe_abstract.h:722

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

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

468  { calculate_map = true; return this->_fe_map->get_curvatures();}
bool calculate_map
Are we calculating mapping functions?
Definition: fe_abstract.h:686
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:654

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

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

321  calculate_d2phi = calculate_dphiref = true; return d2phi; }
bool calculate_d2phi
Should we calculate shape function hessians?
Definition: fe_abstract.h:702
std::vector< std::vector< OutputTensor > > d2phi
Shape function second derivative values.
Definition: fe_base.h:674
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_abstract.h:666
libmesh_assert(ctx)
bool calculate_dphiref
Should we calculate reference shape function gradients?
Definition: fe_abstract.h:722

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

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

405  calculate_d2phi = calculate_dphiref = true; return d2phideta2; }
bool calculate_d2phi
Should we calculate shape function hessians?
Definition: fe_abstract.h:702
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_abstract.h:666
std::vector< std::vector< OutputShape > > d2phideta2
Shape function second derivatives in the eta direction.
Definition: fe_base.h:695
libmesh_assert(ctx)
bool calculate_dphiref
Should we calculate reference shape function gradients?
Definition: fe_abstract.h:722

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

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

bool calculate_d2phi
Should we calculate shape function hessians?
Definition: fe_abstract.h:702
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_abstract.h:666
std::vector< std::vector< OutputShape > > d2phidetadzeta
Shape function second derivatives in the eta-zeta direction.
Definition: fe_base.h:700
libmesh_assert(ctx)
bool calculate_dphiref
Should we calculate reference shape function gradients?
Definition: fe_abstract.h:722

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

333  calculate_d2phi = calculate_dphiref = true; return d2phidx2; }
bool calculate_d2phi
Should we calculate shape function hessians?
Definition: fe_abstract.h:702
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_abstract.h:666
std::vector< std::vector< OutputShape > > d2phidx2
Shape function second derivatives in the x direction.
Definition: fe_base.h:710
libmesh_assert(ctx)
bool calculate_dphiref
Should we calculate reference shape function gradients?
Definition: fe_abstract.h:722

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

341  calculate_d2phi = calculate_dphiref = true; return d2phidxdy; }
bool calculate_d2phi
Should we calculate shape function hessians?
Definition: fe_abstract.h:702
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_abstract.h:666
std::vector< std::vector< OutputShape > > d2phidxdy
Shape function second derivatives in the x-y direction.
Definition: fe_base.h:715
libmesh_assert(ctx)
bool calculate_dphiref
Should we calculate reference shape function gradients?
Definition: fe_abstract.h:722

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

349  calculate_d2phi = calculate_dphiref = true; return d2phidxdz; }
bool calculate_d2phi
Should we calculate shape function hessians?
Definition: fe_abstract.h:702
std::vector< std::vector< OutputShape > > d2phidxdz
Shape function second derivatives in the x-z direction.
Definition: fe_base.h:720
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_abstract.h:666
libmesh_assert(ctx)
bool calculate_dphiref
Should we calculate reference shape function gradients?
Definition: fe_abstract.h:722

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

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

381  calculate_d2phi = calculate_dphiref = true; return d2phidxi2; }
bool calculate_d2phi
Should we calculate shape function hessians?
Definition: fe_abstract.h:702
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_abstract.h:666
libmesh_assert(ctx)
bool calculate_dphiref
Should we calculate reference shape function gradients?
Definition: fe_abstract.h:722
std::vector< std::vector< OutputShape > > d2phidxi2
Shape function second derivatives in the xi direction.
Definition: fe_base.h:680

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

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

bool calculate_d2phi
Should we calculate shape function hessians?
Definition: fe_abstract.h:702
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_abstract.h:666
std::vector< std::vector< OutputShape > > d2phidxideta
Shape function second derivatives in the xi-eta direction.
Definition: fe_base.h:685
libmesh_assert(ctx)
bool calculate_dphiref
Should we calculate reference shape function gradients?
Definition: fe_abstract.h:722

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

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

bool calculate_d2phi
Should we calculate shape function hessians?
Definition: fe_abstract.h:702
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_abstract.h:666
std::vector< std::vector< OutputShape > > d2phidxidzeta
Shape function second derivatives in the xi-zeta direction.
Definition: fe_base.h:690
libmesh_assert(ctx)
bool calculate_dphiref
Should we calculate reference shape function gradients?
Definition: fe_abstract.h:722

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

357  calculate_d2phi = calculate_dphiref = true; return d2phidy2; }
bool calculate_d2phi
Should we calculate shape function hessians?
Definition: fe_abstract.h:702
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_abstract.h:666
std::vector< std::vector< OutputShape > > d2phidy2
Shape function second derivatives in the y direction.
Definition: fe_base.h:725
libmesh_assert(ctx)
bool calculate_dphiref
Should we calculate reference shape function gradients?
Definition: fe_abstract.h:722

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

365  calculate_d2phi = calculate_dphiref = true; return d2phidydz; }
bool calculate_d2phi
Should we calculate shape function hessians?
Definition: fe_abstract.h:702
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_abstract.h:666
std::vector< std::vector< OutputShape > > d2phidydz
Shape function second derivatives in the y-z direction.
Definition: fe_base.h:730
libmesh_assert(ctx)
bool calculate_dphiref
Should we calculate reference shape function gradients?
Definition: fe_abstract.h:722

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

373  calculate_d2phi = calculate_dphiref = true; return d2phidz2; }
bool calculate_d2phi
Should we calculate shape function hessians?
Definition: fe_abstract.h:702
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_abstract.h:666
libmesh_assert(ctx)
bool calculate_dphiref
Should we calculate reference shape function gradients?
Definition: fe_abstract.h:722
std::vector< std::vector< OutputShape > > d2phidz2
Shape function second derivatives in the z direction.
Definition: fe_base.h:735

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

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

421  calculate_d2phi = calculate_dphiref = true; return d2phidzeta2; }
bool calculate_d2phi
Should we calculate shape function hessians?
Definition: fe_abstract.h:702
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_abstract.h:666
libmesh_assert(ctx)
bool calculate_dphiref
Should we calculate reference shape function gradients?
Definition: fe_abstract.h:722
std::vector< std::vector< OutputShape > > d2phidzeta2
Shape function second derivatives in the zeta direction.
Definition: fe_base.h:705

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

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

344  { calculate_map = true; return this->_fe_map->get_d2xyzdeta2(); }
bool calculate_map
Are we calculating mapping functions?
Definition: fe_abstract.h:686
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:654

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

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

372  { calculate_map = true; return this->_fe_map->get_d2xyzdetadzeta(); }
bool calculate_map
Are we calculating mapping functions?
Definition: fe_abstract.h:686
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:654

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

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

337  { calculate_map = true; return this->_fe_map->get_d2xyzdxi2(); }
bool calculate_map
Are we calculating mapping functions?
Definition: fe_abstract.h:686
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:654

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

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

358  { calculate_map = true; return this->_fe_map->get_d2xyzdxideta(); }
bool calculate_map
Are we calculating mapping functions?
Definition: fe_abstract.h:686
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:654

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

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

365  { calculate_map = true; return this->_fe_map->get_d2xyzdxidzeta(); }
bool calculate_map
Are we calculating mapping functions?
Definition: fe_abstract.h:686
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:654

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

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

351  { calculate_map = true; return this->_fe_map->get_d2xyzdzeta2(); }
bool calculate_map
Are we calculating mapping functions?
Definition: fe_abstract.h:686
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:654

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

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

406  { calculate_map = true; return this->_fe_map->get_detadx(); }
bool calculate_map
Are we calculating mapping functions?
Definition: fe_abstract.h:686
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:654

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

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

414  { calculate_map = true; return this->_fe_map->get_detady(); }
bool calculate_map
Are we calculating mapping functions?
Definition: fe_abstract.h:686
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:654

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

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

422  { calculate_map = true; return this->_fe_map->get_detadz(); }
bool calculate_map
Are we calculating mapping functions?
Definition: fe_abstract.h:686
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:654

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

References libMesh::FEAbstract::dim.

259  { return dim; }
const unsigned int dim
The dimensionality of the object.
Definition: fe_abstract.h:660

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

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

263  calculate_div_phi = calculate_dphiref = true; return div_phi; }
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_abstract.h:666
bool calculate_div_phi
Should we calculate shape function divergences?
Definition: fe_abstract.h:717
libmesh_assert(ctx)
std::vector< std::vector< OutputDivergence > > div_phi
Shape function divergence values.
Definition: fe_base.h:636
bool calculate_dphiref
Should we calculate reference shape function gradients?
Definition: fe_abstract.h:722

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

Referenced by assemble_SchroedingerEquation().

438  { return 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

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

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(), ElasticitySystem::element_time_derivative(), HeatSystem::element_time_derivative(), libMesh::OldSolutionCoefs< Output, point_output >::eval_at_point(), libMesh::ExactErrorEstimator::find_squared_element_error(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphi_over_decay(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphi_over_decayxR(), PoissonSystem::init_context(), LaplaceSystem::init_context(), ElasticitySystem::init_context(), libMesh::ParsedFEMFunction< T >::init_context(), HeatSystem::init_context(), libMesh::KellyErrorEstimator::init_context(), ElasticityRBConstruction::init_context(), libMesh::FEMContext::interior_gradients(), libMesh::FEGenericBase< FEOutputType< T >::type >::request_dphi(), libMesh::FEMContext::side_gradient(), libMesh::FEMContext::side_gradients(), and libMesh::FEMContext::some_gradient().

232  calculate_dphi = calculate_dphiref = true; return dphi; }
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_abstract.h:666
libmesh_assert(ctx)
bool calculate_dphiref
Should we calculate reference shape function gradients?
Definition: fe_abstract.h:722
std::vector< std::vector< OutputGradient > > dphi
Shape function derivative values.
Definition: fe_base.h:620
bool calculate_dphi
Should we calculate shape function gradients?
Definition: fe_abstract.h:696

◆ 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();}
const std::vector< std::vector< OutputGradient > > & get_dphi() const
Definition: fe_base.h:230

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

Referenced by assemble_func(), and assemble_SchroedingerEquation().

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

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

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

303  calculate_dphiref = true; return dphideta; }
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_abstract.h:666
libmesh_assert(ctx)
bool calculate_dphiref
Should we calculate reference shape function gradients?
Definition: fe_abstract.h:722
std::vector< std::vector< OutputShape > > dphideta
Shape function derivatives in the eta direction.
Definition: fe_base.h:646

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

271  calculate_dphi = calculate_dphiref = true; return dphidx; }
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_abstract.h:666
std::vector< std::vector< OutputShape > > dphidx
Shape function derivatives in the x direction.
Definition: fe_base.h:656
libmesh_assert(ctx)
bool calculate_dphiref
Should we calculate reference shape function gradients?
Definition: fe_abstract.h:722
bool calculate_dphi
Should we calculate shape function gradients?
Definition: fe_abstract.h:696

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

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

295  calculate_dphiref = true; return dphidxi; }
std::vector< std::vector< OutputShape > > dphidxi
Shape function derivatives in the xi direction.
Definition: fe_base.h:641
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_abstract.h:666
libmesh_assert(ctx)
bool calculate_dphiref
Should we calculate reference shape function gradients?
Definition: fe_abstract.h:722

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

279  calculate_dphi = calculate_dphiref = true; return dphidy; }
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_abstract.h:666
std::vector< std::vector< OutputShape > > dphidy
Shape function derivatives in the y direction.
Definition: fe_base.h:661
libmesh_assert(ctx)
bool calculate_dphiref
Should we calculate reference shape function gradients?
Definition: fe_abstract.h:722
bool calculate_dphi
Should we calculate shape function gradients?
Definition: fe_abstract.h:696

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

287  calculate_dphi = calculate_dphiref = true; return dphidz; }
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_abstract.h:666
libmesh_assert(ctx)
bool calculate_dphiref
Should we calculate reference shape function gradients?
Definition: fe_abstract.h:722
bool calculate_dphi
Should we calculate shape function gradients?
Definition: fe_abstract.h:696
std::vector< std::vector< OutputShape > > dphidz
Shape function derivatives in the z direction.
Definition: fe_base.h:666

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

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

311  calculate_dphiref = true; return dphidzeta; }
std::vector< std::vector< OutputShape > > dphidzeta
Shape function derivatives in the zeta direction.
Definition: fe_base.h:651
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_abstract.h:666
libmesh_assert(ctx)
bool calculate_dphiref
Should we calculate reference shape function gradients?
Definition: fe_abstract.h:722

◆ 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; }
DenseMatrix< Real > dual_coeff
Coefficient matrix for the dual basis.
Definition: fe_base.h:626

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

bool calculate_d2phi
Should we calculate shape function hessians?
Definition: fe_abstract.h:702
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_abstract.h:666
std::vector< std::vector< OutputTensor > > dual_d2phi
Definition: fe_base.h:675
libmesh_assert(ctx)
bool calculate_dphiref
Should we calculate reference shape function gradients?
Definition: fe_abstract.h:722
bool calculate_dual
Are we calculating dual basis?
Definition: fe_abstract.h:671

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

Referenced by libMesh::FEGenericBase< FEOutputType< T >::type >::request_dual_dphi().

bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_abstract.h:666
std::vector< std::vector< OutputGradient > > dual_dphi
Definition: fe_base.h:621
libmesh_assert(ctx)
bool calculate_dphiref
Should we calculate reference shape function gradients?
Definition: fe_abstract.h:722
bool calculate_dphi
Should we calculate shape function gradients?
Definition: fe_abstract.h:696
bool calculate_dual
Are we calculating dual basis?
Definition: fe_abstract.h:671

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

Referenced by libMesh::FEGenericBase< FEOutputType< T >::type >::request_dual_phi().

212  {
214  calculate_dual = true;
215  // Dual phi computation relies on primal phi computation
216  this->request_phi();
217  return dual_phi;
218  }
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_abstract.h:666
virtual void request_phi() const override
request phi calculations
Definition: fe_base.h:220
std::vector< std::vector< OutputShape > > dual_phi
Definition: fe_base.h:615
libmesh_assert(ctx)
bool calculate_dual
Are we calculating dual basis?
Definition: fe_abstract.h:671

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

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

382  { calculate_map = true; return this->_fe_map->get_dxidx(); }
bool calculate_map
Are we calculating mapping functions?
Definition: fe_abstract.h:686
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:654

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

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

390  { calculate_map = true; return this->_fe_map->get_dxidy(); }
bool calculate_map
Are we calculating mapping functions?
Definition: fe_abstract.h:686
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:654

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

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

398  { calculate_map = true; return this->_fe_map->get_dxidz(); }
bool calculate_map
Are we calculating mapping functions?
Definition: fe_abstract.h:686
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:654

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

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

320  { calculate_map = true; return this->_fe_map->get_dxyzdeta(); }
bool calculate_map
Are we calculating mapping functions?
Definition: fe_abstract.h:686
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:654

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

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

312  { calculate_map = true; return this->_fe_map->get_dxyzdxi(); }
bool calculate_map
Are we calculating mapping functions?
Definition: fe_abstract.h:686
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:654

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

References libMesh::FEAbstract::_fe_map.

328  { return _fe_map->get_dxyzdzeta(); }
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:654

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

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

430  { calculate_map = true; return this->_fe_map->get_dzetadx(); }
bool calculate_map
Are we calculating mapping functions?
Definition: fe_abstract.h:686
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:654

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

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

438  { calculate_map = true; return this->_fe_map->get_dzetady(); }
bool calculate_map
Are we calculating mapping functions?
Definition: fe_abstract.h:686
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:654

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

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

446  { calculate_map = true; return this->_fe_map->get_dzetadz(); }
bool calculate_map
Are we calculating mapping functions?
Definition: fe_abstract.h:686
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:654

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

References libMesh::FEAbstract::_elem.

496 { return _elem; }
const Elem * _elem
The element the current data structures were set up for.
Definition: fe_abstract.h:740

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

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

547 { return fe_type.family; }
FEFamily family
The type of finite element.
Definition: fe_type.h:221
FEType fe_type
The finite element type for this object.
Definition: fe_abstract.h:730

◆ get_fe_map() [1/2]

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

◆ get_fe_map() [2/2]

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

Definition at line 555 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

555 { return *_fe_map.get(); }
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:654

◆ get_fe_type()

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

◆ get_info()

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

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

References libMesh::ReferenceCounter::_counts, and libMesh::Quality::name().

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

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

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

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::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubProjector::construct_projection(), ElasticitySystem::element_time_derivative(), HeatSystem::element_time_derivative(), libMesh::ExactErrorEstimator::find_squared_element_error(), libMesh::FEAbstract::get_JxWxdecay_sq(), CoupledSystemQoI::init_context(), NavierSystem::init_context(), SolidSystem::init_context(), PoissonSystem::init_context(), LaplaceSystem::init_context(), CurlCurlSystem::init_context(), ElasticitySystem::init_context(), CoupledSystem::init_context(), libMesh::DiscontinuityMeasure::init_context(), HeatSystem::init_context(), ElasticityRBConstruction::init_context(), libMesh::FEMSystem::init_context(), libMesh::LaplacianErrorEstimator::internal_side_integration(), libMesh::DiscontinuityMeasure::internal_side_integration(), libMesh::KellyErrorEstimator::internal_side_integration(), ElasticitySystem::mass_residual(), libMesh::FEMPhysics::mass_residual(), Integrate::operator()(), SolidSystem::side_time_derivative(), ElasticitySystem::side_time_derivative(), and libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::SubFunctor().

304  { calculate_map = true; return this->_fe_map->get_JxW(); }
bool calculate_map
Are we calculating mapping functions?
Definition: fe_abstract.h:686
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:654

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

References libMesh::FEAbstract::get_JxW().

Referenced by assemble_func(), and assemble_SchroedingerEquation().

293  { return get_JxW();}
virtual_for_inffe const std::vector< Real > & get_JxW() const
Definition: fe_abstract.h:303

◆ get_normals()

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

◆ get_nothing()

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

Definition at line 269 of file fe_abstract.h.

References libMesh::FEAbstract::calculate_nothing.

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

270  { calculate_nothing = true; }
bool calculate_nothing
Are we potentially deliberately calculating nothing?
Definition: fe_abstract.h:681

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

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

526  { return fe_type.order + _p_level; }
unsigned int _p_level
The p refinement level the current data structures are set up for.
Definition: fe_abstract.h:757
OrderWrapper order
The approximation order of the element.
Definition: fe_type.h:215
FEType fe_type
The finite element type for this object.
Definition: fe_abstract.h:730

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

References libMesh::FEAbstract::_p_level.

515 { return _p_level; }
unsigned int _p_level
The p refinement level the current data structures are set up for.
Definition: fe_abstract.h:757

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

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

209  calculate_phi = true; return phi; }
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_abstract.h:666
bool calculate_phi
Should we calculate shape functions?
Definition: fe_abstract.h:691
std::vector< std::vector< OutputShape > > phi
Shape function values.
Definition: fe_base.h:614
libmesh_assert(ctx)

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

Referenced by assemble_func(), and assemble_SchroedingerEquation().

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

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

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

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 }
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:310
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:650
const dof_id_type n_nodes
Definition: tecplot_io.C:67
std::string enum_to_string(const T e)
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

◆ 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; }
std::vector< RealGradient > dweight
Used for certain infinite element families: the global derivative of the additional radial weight ...
Definition: fe_base.h:760

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

Referenced by assemble_func(), and assemble_SchroedingerEquation().

481  { return dweight; }
std::vector< RealGradient > dweight
Used for certain infinite element families: the global derivative of the additional radial weight ...
Definition: fe_base.h:760

◆ 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; }
std::vector< Real > weight
Used for certain infinite element families: the additional radial weight in local coordinates...
Definition: fe_base.h:767

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

Referenced by assemble_func(), and assemble_SchroedingerEquation().

471  { return weight; }
std::vector< Real > weight
Used for certain infinite element families: the additional radial weight in local coordinates...
Definition: fe_base.h:767

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

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

453  { calculate_map = true; return this->_fe_map->get_tangents(); }
bool calculate_map
Are we calculating mapping functions?
Definition: fe_abstract.h:686
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:654

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

References libMesh::FEAbstract::_elem_type.

509 { return _elem_type; }
ElemType _elem_type
The element type the current data structures were set up for.
Definition: fe_abstract.h:735

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

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(), HeatSystem::element_time_derivative(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::ParsedFEMFunction< T >::eval_args(), libMesh::ExactErrorEstimator::find_squared_element_error(), CoupledSystemQoI::init_context(), NavierSystem::init_context(), SolidSystem::init_context(), PoissonSystem::init_context(), CurlCurlSystem::init_context(), CoupledSystem::init_context(), libMesh::ParsedFEMFunction< T >::init_context(), HeatSystem::init_context(), libMesh::DGFEMContext::neighbor_side_fe_reinit(), Integrate::operator()(), SolidSystem::side_time_derivative(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::SubFunctor(), SlitMeshRefinedSystemTest::testRestart(), and SlitMeshRefinedSystemTest::testSystem().

281  { calculate_map = true; return this->_fe_map->get_xyz(); }
bool calculate_map
Are we calculating mapping functions?
Definition: fe_abstract.h:686
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:654

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

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

Referenced by libMesh::ReferenceCountedObject< RBParametrized >::ReferenceCountedObject().

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 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
OStreamProxy err
static Counts _counts
Actually holds the data.
streamT * get()
Rather than implement every ostream/ios/ios_base function, we&#39;ll be lazy and make esoteric uses go th...
spin_mutex spin_mtx
A convenient spin mutex object which can be used for obtaining locks.
Definition: threads.C:30

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

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

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

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 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
OStreamProxy err
static Counts _counts
Actually holds the data.
streamT * get()
Rather than implement every ostream/ios/ios_base function, we&#39;ll be lazy and make esoteric uses go th...
spin_mutex spin_mtx
A convenient spin mutex object which can be used for obtaining locks.
Definition: threads.C:30

◆ init_base_shape_functions()

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

◆ is_hierarchic()

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

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

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

References libMesh::ReferenceCounter::_n_objects.

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

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

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

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(), libMesh::DiscontinuityMeasure::boundary_side_integration(), libMesh::KellyErrorEstimator::boundary_side_integration(), libMesh::LaplacianErrorEstimator::internal_side_integration(), libMesh::DiscontinuityMeasure::internal_side_integration(), and libMesh::KellyErrorEstimator::internal_side_integration().

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 }
unsigned int _n_total_qp
The total number of quadrature points for the current configuration.
Definition: fe_abstract.h:774
bool shapes_on_quadrature
A flag indicating if current data structures correspond to quadrature rule points.
Definition: fe_abstract.h:768
libmesh_assert(ctx)
unsigned int n_points() const
Definition: quadrature.h:131
QBase * qrule
A pointer to the quadrature rule employed.
Definition: fe_abstract.h:762

◆ n_shape_functions()

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

◆ on_reference_element()

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

Definition at line 637 of file fe_abstract.C.

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

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 }
std::string enum_to_string(const T e)
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

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

990 {
991  for (auto i : index_range(dphi))
992  for (auto j : index_range(dphi[i]))
993  os << " d2phi[" << i << "][" << j << "]=" << d2phi[i][j];
994 }
std::vector< std::vector< OutputTensor > > d2phi
Shape function second derivative values.
Definition: fe_base.h:674
std::vector< std::vector< OutputGradient > > dphi
Shape function derivative values.
Definition: fe_base.h:620
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:117

◆ 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 }
std::vector< std::vector< OutputGradient > > dphi
Shape function derivative values.
Definition: fe_base.h:620
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:117

◆ print_dual_d2phi()

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

Implements libMesh::FEAbstract.

Definition at line 997 of file fe_base.C.

998 {
999  for (auto i : index_range(dual_d2phi))
1000  for (auto j : index_range(dual_d2phi[i]))
1001  os << " dual_d2phi[" << i << "][" << j << "]=" << dual_d2phi[i][j];
1002 }
std::vector< std::vector< OutputTensor > > dual_d2phi
Definition: fe_base.h:675
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:117

◆ 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 }
std::vector< std::vector< OutputGradient > > dual_dphi
Definition: fe_base.h:621
std::vector< std::vector< OutputGradient > > dphi
Shape function derivative values.
Definition: fe_base.h:620
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:117

◆ 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 }
std::vector< std::vector< OutputShape > > dual_phi
Definition: fe_base.h:615
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:117

◆ print_info() [1/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.

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

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

82 {
84  out_stream << ReferenceCounter::get_info();
85 }
static std::string get_info()
Gets a string containing the reference information.
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called...

◆ print_info() [2/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.

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

Referenced by libMesh::operator<<().

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 }
virtual void print_phi(std::ostream &os) const =0
Prints the value of each shape function at each quadrature point.
virtual void print_dphi(std::ostream &os) const =0
Prints the value of each shape function&#39;s derivative at each quadrature point.
void print_xyz(std::ostream &os) const
Prints the spatial location of each quadrature point (on the physical element).
Definition: fe_abstract.C:853
void print_JxW(std::ostream &os) const
Prints the Jacobian times the weight for each quadrature point.
Definition: fe_abstract.C:846

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

References libMesh::FEAbstract::_fe_map.

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

847 {
848  this->_fe_map->print_JxW(os);
849 }
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:654

◆ 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 }
std::vector< std::vector< OutputShape > > phi
Shape function values.
Definition: fe_base.h:614
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:117

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

References libMesh::FEAbstract::_fe_map.

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

854 {
855  this->_fe_map->print_xyz(os);
856 }
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:654

◆ 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::FEXYZ< Dim >, libMesh::FESubdivision, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, and libMesh::InfFE< Dim, T_radial, T_map >.

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

◆ reinit() [2/2]

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

◆ reinit_default_dual_shape_coeffs()

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

◆ reinit_dual_shape_coeffs()

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

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

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

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

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(); }
const std::vector< std::vector< OutputGradient > > & get_dphi() const
Definition: fe_base.h:230

◆ 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(); }
const std::vector< std::vector< OutputGradient > > & get_dual_dphi() const
Definition: fe_base.h:234

◆ 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(); }
const std::vector< std::vector< OutputShape > > & get_dual_phi() const
Definition: fe_base.h:211

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

Referenced by libMesh::FEGenericBase< FEOutputType< T >::type >::get_dual_phi().

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

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

References 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

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

References libMesh::FEAbstract::calculate_dual.

621 {calculate_dual = val; }
bool calculate_dual
Are we calculating dual basis?
Definition: fe_abstract.h:671

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

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

531 { fe_type.order = new_order; }
OrderWrapper order
The approximation order of the element.
Definition: fe_type.h:215
FEType fe_type
The finite element type for this object.
Definition: fe_abstract.h:730

◆ 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, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::InfFE< Dim, T_radial, T_map >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, libMesh::FE< Dim, LAGRANGE_VEC >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, L2_RAVIART_THOMAS >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, L2_LAGRANGE_VEC >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HIERARCHIC_VEC >, libMesh::FE< Dim, RAVIART_THOMAS >, libMesh::FE< Dim, HERMITE >, libMesh::FE< Dim, L2_HIERARCHIC_VEC >, libMesh::FE< Dim, CLOUGH >, libMesh::FE< Dim, MONOMIAL >, libMesh::FE< Dim, XYZ >, libMesh::FE< Dim, MONOMIAL_VEC >, libMesh::FE< Dim, LAGRANGE >, libMesh::FE< Dim, L2_HIERARCHIC >, and libMesh::FE< Dim, LAGRANGE_VEC >.

◆ side_map()

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

Friends And Related Function 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().

◆ _counts

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

Actually holds the data.

Definition at line 124 of file reference_counter.h.

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

◆ _elem

const Elem* libMesh::FEAbstract::_elem
protectedinherited

The element the current data structures were set up for.

Definition at line 740 of file fe_abstract.h.

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

◆ _elem_p_level

unsigned int libMesh::FEAbstract::_elem_p_level
protectedinherited

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

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

Definition at line 751 of file fe_abstract.h.

◆ _elem_type

ElemType libMesh::FEAbstract::_elem_type
protectedinherited

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

Definition at line 735 of file fe_abstract.h.

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

◆ _enable_print_counter

bool libMesh::ReferenceCounter::_enable_print_counter = true
staticprotectedinherited

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

Definition at line 143 of file reference_counter.h.

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

◆ _fe_map

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

◆ _fe_trans

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

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

Definition at line 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(), 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

◆ calculate_d2phi [1/2]

bool libMesh::FEAbstract::calculate_d2phi
mutableprotectedinherited

◆ calculate_d2phi [2/2]

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

Definition at line 705 of file fe_abstract.h.

◆ calculate_default_dual_coeff

bool libMesh::FEAbstract::calculate_default_dual_coeff
mutableprotectedinherited

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

Definition at line 676 of file fe_abstract.h.

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

◆ calculate_div_phi

bool libMesh::FEAbstract::calculate_div_phi
mutableprotectedinherited

◆ calculate_dphi

bool libMesh::FEAbstract::calculate_dphi
mutableprotectedinherited

◆ 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< FEOutputType< T >::type >::get_curl_phi(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phi(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phideta2(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidetadzeta(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidx2(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxdy(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxdz(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxi2(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxideta(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxidzeta(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidy2(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidydz(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidz2(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidzeta2(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_div_phi(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphi(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphideta(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidx(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidxi(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidy(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidz(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidzeta(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dual_d2phi(), and libMesh::FEGenericBase< FEOutputType< T >::type >::get_dual_dphi().

◆ calculate_dual

bool libMesh::FEAbstract::calculate_dual
mutableprotectedinherited

◆ calculate_map

bool libMesh::FEAbstract::calculate_map
mutableprotectedinherited

Are we calculating mapping functions?

Definition at line 686 of file fe_abstract.h.

Referenced by libMesh::FEGenericBase< FEOutputType< T >::type >::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< FEOutputType< T >::type >::calculating_nothing(), and libMesh::FEAbstract::get_nothing().

◆ calculate_phi

bool libMesh::FEAbstract::calculate_phi
mutableprotectedinherited

◆ calculations_started

bool libMesh::FEAbstract::calculations_started
mutableprotectedinherited

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

Definition at line 666 of file fe_abstract.h.

Referenced by libMesh::FEGenericBase< FEOutputType< T >::type >::get_curl_phi(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phi(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phideta2(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidetadzeta(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidx2(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxdy(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxdz(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxi2(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxideta(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxidzeta(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidy2(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidydz(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidz2(), libMesh::FEGenericBase< FEOutputType< T >::type >::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< FEOutputType< T >::type >::get_div_phi(), libMesh::FEGenericBase< FEOutputType< T >::type >::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< FEOutputType< T >::type >::get_dphideta(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidx(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidxi(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidy(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidz(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidzeta(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dual_d2phi(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dual_dphi(), libMesh::FEGenericBase< FEOutputType< T >::type >::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< FEOutputType< T >::type >::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< FEOutputType< T >::type >::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< FEOutputType< T >::type >::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< FEOutputType< T >::type >::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< FEOutputType< T >::type >::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< FEOutputType< T >::type >::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< FEOutputType< T >::type >::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< FEOutputType< T >::type >::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< FEOutputType< T >::type >::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< FEOutputType< T >::type >::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< FEOutputType< T >::type >::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< FEOutputType< T >::type >::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< FEOutputType< T >::type >::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< FEOutputType< T >::type >::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< FEOutputType< T >::type >::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< FEOutputType< T >::type >::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< FEOutputType< T >::type >::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< FEOutputType< T >::type >::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< FEOutputType< T >::type >::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< FEOutputType< T >::type >::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< FEOutputType< T >::type >::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< FEOutputType< T >::type >::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< FEOutputType< T >::type >::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< FEOutputType< T >::type >::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< FEOutputType< T >::type >::get_dual_coeff().

◆ dual_d2phi

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

◆ dual_dphi

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

◆ dual_phi

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

◆ 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< FEOutputType< T >::type >::get_Sobolev_dweight(), libMesh::InfFE< Dim, T_radial, T_map >::get_Sobolev_dweight(), and libMesh::FEGenericBase< FEOutputType< T >::type >::get_Sobolev_dweightxR_sq().

◆ fe_type

FEType libMesh::FEAbstract::fe_type
protectedinherited

◆ phi

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

Shape function values.

Definition at line 614 of file fe_base.h.

Referenced by libMesh::FEGenericBase< FEOutputType< T >::type >::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< FEOutputType< T >::type >::get_Sobolev_weight(), libMesh::InfFE< Dim, T_radial, T_map >::get_Sobolev_weight(), and libMesh::FEGenericBase< FEOutputType< T >::type >::get_Sobolev_weightxR_sq().


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