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< OutputGradient > > & get_dphi () const
 
const std::vector< std::vector< OutputShape > > & get_curl_phi () const
 
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< 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
 
const std::vector< Real > & get_Sobolev_weight () const
 
const std::vector< RealGradient > & get_Sobolev_dweight () const
 
void print_phi (std::ostream &os) const
 Prints the value of each shape function at each quadrature point. More...
 
void print_dphi (std::ostream &os) const
 Prints the value of each shape function's derivative at each quadrature point. More...
 
void print_d2phi (std::ostream &os) const
 Prints the value of each shape function's second derivatives at each quadrature point. More...
 
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 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
 
const std::vector< Point > & get_xyz () const
 
const std::vector< Real > & get_JxW () const
 
const std::vector< RealGradient > & get_dxyzdxi () const
 
const std::vector< RealGradient > & get_dxyzdeta () const
 
const std::vector< RealGradient > & get_dxyzdzeta () const
 
const std::vector< RealGradient > & get_d2xyzdxi2 () const
 
const std::vector< RealGradient > & get_d2xyzdeta2 () const
 
const std::vector< RealGradient > & get_d2xyzdzeta2 () const
 
const std::vector< RealGradient > & get_d2xyzdxideta () const
 
const std::vector< RealGradient > & get_d2xyzdxidzeta () const
 
const std::vector< RealGradient > & get_d2xyzdetadzeta () const
 
const std::vector< Real > & get_dxidx () const
 
const std::vector< Real > & get_dxidy () const
 
const std::vector< Real > & get_dxidz () const
 
const std::vector< Real > & get_detadx () const
 
const std::vector< Real > & get_detady () const
 
const std::vector< Real > & get_detadz () const
 
const std::vector< Real > & get_dzetadx () const
 
const std::vector< Real > & get_dzetady () const
 
const std::vector< Real > & get_dzetadz () const
 
const std::vector< std::vector< Point > > & get_tangents () const
 
const std::vector< Point > & get_normals () const
 
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 =0
 
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 FEMap & get_fe_map () const
 
FEMap & get_fe_map ()
 
void print_JxW (std::ostream &os) const
 Prints the Jacobian times the weight for each quadrature point. 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...
 

Static Public Member Functions

static std::unique_ptr< FEGenericBase > build (const unsigned int dim, const FEType &type)
 Builds a specific finite element type. More...
 
static std::unique_ptr< FEGenericBase > build_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=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...
 
void determine_calculations ()
 Determine which values are to be calculated, for both the FE itself and for the FEMap. More...
 
virtual void compute_shape_functions (const Elem *elem, const std::vector< Point > &qp)
 After having updated the jacobian and the transformation from local to global coordinates in FEAbstract::compute_map(), the first derivatives of the shape functions are transformed to global coordinates, giving dphi, dphidx, dphidy, and dphidz. More...
 
virtual bool shapes_need_reinit () const =0
 
void increment_constructor_count (const std::string &name)
 Increments the construction counter. More...
 
void increment_destructor_count (const std::string &name)
 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< OutputGradient > > dphi
 Shape function derivative values. 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< 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< OutputGradient > dphase
 Used for certain infinite element families: the first derivatives of the phase term in global coordinates, over all quadrature points. More...
 
std::vector< RealGradient > dweight
 Used for certain infinite element families: the global derivative of the additional radial weight \( 1/{r^2} \), over all quadrature points. More...
 
std::vector< Real > weight
 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_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 are set up for. More...
 
unsigned int _p_level
 The p refinement level the current data structures are set up for. More...
 
QBase * qrule
 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...
 

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 117 of file reference_counter.h.

◆ OutputDivergence

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

Definition at line 121 of file fe_base.h.

◆ OutputGradient

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

Definition at line 119 of file fe_base.h.

◆ OutputNumber

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

Definition at line 122 of file fe_base.h.

◆ OutputNumberDivergence

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

Definition at line 125 of file fe_base.h.

◆ OutputNumberGradient

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

Definition at line 123 of file fe_base.h.

◆ OutputNumberTensor

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

Definition at line 124 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 118 of file fe_base.h.

◆ OutputTensor

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

Definition at line 120 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 675 of file fe_base.h.

676  :
677  FEAbstract(d,fet),
678  _fe_trans( FETransformationBase<OutputType>::build(fet) ),
679  phi(),
680  dphi(),
681  curl_phi(),
682  div_phi(),
683  dphidxi(),
684  dphideta(),
685  dphidzeta(),
686  dphidx(),
687  dphidy(),
688  dphidz()
689 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
690  ,d2phi(),
691  d2phidxi2(),
692  d2phidxideta(),
693  d2phidxidzeta(),
694  d2phideta2(),
695  d2phidetadzeta(),
696  d2phidzeta2(),
697  d2phidx2(),
698  d2phidxdy(),
699  d2phidxdz(),
700  d2phidy2(),
701  d2phidydz(),
702  d2phidz2()
703 #endif
704 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
705  ,dphase(),
706  dweight(),
707  weight()
708 #endif
709 {
710 }
711 
712 
713 
714 template <typename OutputType>
715 inline
716 FEGenericBase<OutputType>::~FEGenericBase()
717 {
718 }

◆ ~FEGenericBase()

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

Destructor.

Member Function Documentation

◆ attach_quadrature_rule()

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

Provides the class with the quadrature rule.

Implement this in derived classes.

Implemented in libMesh::FESubdivision, libMesh::InfFE< Dim, T_radial, T_map >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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::RBConstruction::add_scaled_matrix_and_vector().

◆ build() [1/3]

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

Definition at line 186 of file fe_base.C.

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

◆ build() [2/3]

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

Definition at line 396 of file fe_base.C.

398 {
399  switch (dim)
400  {
401  // 0D
402  case 0:
403  {
404  switch (fet.family)
405  {
406  case LAGRANGE_VEC:
407  return libmesh_make_unique<FELagrangeVec<0>>(fet);
408 
409  case MONOMIAL_VEC:
410  return libmesh_make_unique<FEMonomialVec<0>>(fet);
411 
412  default:
413  libmesh_error_msg("ERROR: Bad FEType.family= " << fet.family);
414  }
415  }
416  case 1:
417  {
418  switch (fet.family)
419  {
420  case LAGRANGE_VEC:
421  return libmesh_make_unique<FELagrangeVec<1>>(fet);
422 
423  case MONOMIAL_VEC:
424  return libmesh_make_unique<FEMonomialVec<1>>(fet);
425 
426  default:
427  libmesh_error_msg("ERROR: Bad FEType.family= " << fet.family);
428  }
429  }
430  case 2:
431  {
432  switch (fet.family)
433  {
434  case LAGRANGE_VEC:
435  return libmesh_make_unique<FELagrangeVec<2>>(fet);
436 
437  case MONOMIAL_VEC:
438  return libmesh_make_unique<FEMonomialVec<2>>(fet);
439 
440  case NEDELEC_ONE:
441  return libmesh_make_unique<FENedelecOne<2>>(fet);
442 
443  default:
444  libmesh_error_msg("ERROR: Bad FEType.family= " << fet.family);
445  }
446  }
447  case 3:
448  {
449  switch (fet.family)
450  {
451  case LAGRANGE_VEC:
452  return libmesh_make_unique<FELagrangeVec<3>>(fet);
453 
454  case MONOMIAL_VEC:
455  return libmesh_make_unique<FEMonomialVec<3>>(fet);
456 
457  case NEDELEC_ONE:
458  return libmesh_make_unique<FENedelecOne<3>>(fet);
459 
460  default:
461  libmesh_error_msg("ERROR: Bad FEType.family= " << fet.family);
462  }
463  }
464 
465  default:
466  libmesh_error_msg("Invalid dimension dim = " << dim);
467  } // switch(dim)
468 }

◆ build() [3/3]

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

Builds a specific finite element type.

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

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

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), assemble(), LinearElasticity::assemble(), assemble_1D(), assemble_biharmonic(), assemble_cd(), assemble_elasticity(), assemble_ellipticdg(), assemble_helmholtz(), assemble_laplace(), assemble_mass(), 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_jacobian(), compute_residual(), LinearElasticity::compute_stresses(), compute_stresses(), LargeDeformationElasticity::compute_stresses(), libMesh::MeshFunction::discontinuous_gradient(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::MeshFunction::gradient(), libMesh::MeshFunction::hessian(), libMesh::InfFE< Dim, T_radial, T_map >::InfFE(), libMesh::InfFE< Dim, T_radial, T_map >::init_face_shape_functions(), libMesh::RBEIMAssembly::initialize_fe(), integrate_function(), LaplaceYoung::jacobian(), LargeDeformationElasticity::jacobian(), main(), OverlappingCouplingFunctor::operator()(), libMesh::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectEdges::operator()(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectSides::operator()(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectInteriors::operator()(), libMesh::System::point_hessian(), libMesh::InfFE< Dim, T_radial, T_map >::reinit(), LaplaceYoung::residual(), LargeDeformationElasticity::residual(), libMesh::HPCoarsenTest::select_refinement(), RationalMapTest< elem_type >::setUp(), FETest< order, family, elem_type >::setUp(), and libMesh::Elem::volume().

◆ build_InfFE() [1/3]

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

Definition at line 481 of file fe_base.C.

483 {
484  switch (dim)
485  {
486 
487  // 1D
488  case 1:
489  {
490  switch (fet.radial_family)
491  {
492  case INFINITE_MAP:
493  libmesh_error_msg("ERROR: Can't build an infinite element with FEFamily = " << fet.radial_family);
494 
495  case JACOBI_20_00:
496  {
497  switch (fet.inf_map)
498  {
499  case CARTESIAN:
500  return libmesh_make_unique<InfFE<1,JACOBI_20_00,CARTESIAN>>(fet);
501 
502  default:
503  libmesh_error_msg("ERROR: Can't build an infinite element with InfMapType = " << fet.inf_map);
504  }
505  }
506 
507  case JACOBI_30_00:
508  {
509  switch (fet.inf_map)
510  {
511  case CARTESIAN:
512  return libmesh_make_unique<InfFE<1,JACOBI_30_00,CARTESIAN>>(fet);
513 
514  default:
515  libmesh_error_msg("ERROR: Can't build an infinite element with InfMapType = " << fet.inf_map);
516  }
517  }
518 
519  case LEGENDRE:
520  {
521  switch (fet.inf_map)
522  {
523  case CARTESIAN:
524  return libmesh_make_unique<InfFE<1,LEGENDRE,CARTESIAN>>(fet);
525 
526  default:
527  libmesh_error_msg("ERROR: Can't build an infinite element with InfMapType = " << fet.inf_map);
528  }
529  }
530 
531  case LAGRANGE:
532  {
533  switch (fet.inf_map)
534  {
535  case CARTESIAN:
536  return libmesh_make_unique<InfFE<1,LAGRANGE,CARTESIAN>>(fet);
537 
538  default:
539  libmesh_error_msg("ERROR: Can't build an infinite element with InfMapType = " << fet.inf_map);
540  }
541  }
542 
543  default:
544  libmesh_error_msg("ERROR: Bad FEType.radial_family= " << fet.radial_family);
545  }
546  }
547 
548 
549 
550 
551  // 2D
552  case 2:
553  {
554  switch (fet.radial_family)
555  {
556  case INFINITE_MAP:
557  libmesh_error_msg("ERROR: Can't build an infinite element with FEFamily = " << fet.radial_family);
558 
559  case JACOBI_20_00:
560  {
561  switch (fet.inf_map)
562  {
563  case CARTESIAN:
564  return libmesh_make_unique<InfFE<2,JACOBI_20_00,CARTESIAN>>(fet);
565 
566  default:
567  libmesh_error_msg("ERROR: Don't build an infinite element with InfMapType = " << fet.inf_map);
568  }
569  }
570 
571  case JACOBI_30_00:
572  {
573  switch (fet.inf_map)
574  {
575  case CARTESIAN:
576  return libmesh_make_unique<InfFE<2,JACOBI_30_00,CARTESIAN>>(fet);
577 
578  default:
579  libmesh_error_msg("ERROR: Don't build an infinite element with InfMapType = " << fet.inf_map);
580  }
581  }
582 
583  case LEGENDRE:
584  {
585  switch (fet.inf_map)
586  {
587  case CARTESIAN:
588  return libmesh_make_unique<InfFE<2,LEGENDRE,CARTESIAN>>(fet);
589 
590  default:
591  libmesh_error_msg("ERROR: Don't build an infinite element with InfMapType = " << fet.inf_map);
592  }
593  }
594 
595  case LAGRANGE:
596  {
597  switch (fet.inf_map)
598  {
599  case CARTESIAN:
600  return libmesh_make_unique<InfFE<2,LAGRANGE,CARTESIAN>>(fet);
601 
602  default:
603  libmesh_error_msg("ERROR: Don't build an infinite element with InfMapType = " << fet.inf_map);
604  }
605  }
606 
607  default:
608  libmesh_error_msg("ERROR: Bad FEType.radial_family= " << fet.radial_family);
609  }
610  }
611 
612 
613 
614 
615  // 3D
616  case 3:
617  {
618  switch (fet.radial_family)
619  {
620  case INFINITE_MAP:
621  libmesh_error_msg("ERROR: Don't build an infinite element with FEFamily = " << fet.radial_family);
622 
623  case JACOBI_20_00:
624  {
625  switch (fet.inf_map)
626  {
627  case CARTESIAN:
628  return libmesh_make_unique<InfFE<3,JACOBI_20_00,CARTESIAN>>(fet);
629 
630  default:
631  libmesh_error_msg("ERROR: Don't build an infinite element with InfMapType = " << fet.inf_map);
632  }
633  }
634 
635  case JACOBI_30_00:
636  {
637  switch (fet.inf_map)
638  {
639  case CARTESIAN:
640  return libmesh_make_unique<InfFE<3,JACOBI_30_00,CARTESIAN>>(fet);
641 
642  default:
643  libmesh_error_msg("ERROR: Don't build an infinite element with InfMapType = " << fet.inf_map);
644  }
645  }
646 
647  case LEGENDRE:
648  {
649  switch (fet.inf_map)
650  {
651  case CARTESIAN:
652  return libmesh_make_unique<InfFE<3,LEGENDRE,CARTESIAN>>(fet);
653 
654  default:
655  libmesh_error_msg("ERROR: Don't build an infinite element with InfMapType = " << fet.inf_map);
656  }
657  }
658 
659  case LAGRANGE:
660  {
661  switch (fet.inf_map)
662  {
663  case CARTESIAN:
664  return libmesh_make_unique<InfFE<3,LAGRANGE,CARTESIAN>>(fet);
665 
666  default:
667  libmesh_error_msg("ERROR: Don't build an infinite element with InfMapType = " << fet.inf_map);
668  }
669  }
670 
671  default:
672  libmesh_error_msg("ERROR: Bad FEType.radial_family= " << fet.radial_family);
673  }
674  }
675 
676  default:
677  libmesh_error_msg("Invalid dimension dim = " << dim);
678  }
679 }

◆ build_InfFE() [2/3]

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

Builds a specific infinite element type.

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

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

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

◆ build_InfFE() [3/3]

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

Definition at line 685 of file fe_base.C.

687 {
688  // No vector types defined... YET.
689  libmesh_not_implemented();
690  return std::unique_ptr<FEVectorBase>();
691 }

◆ coarsened_dof_values() [1/2]

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

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

Computes a vector of coefficients corresponding to all dof_indices.

Definition at line 1373 of file fe_base.C.

1378 {
1379  Ue.resize(0);
1380 
1381  for (unsigned int v=0; v != dof_map.n_variables(); ++v)
1382  {
1383  DenseVector<Number> Usub;
1384 
1385  coarsened_dof_values(old_vector, dof_map, elem, Usub,
1386  v, use_old_dof_indices);
1387 
1388  Ue.append (Usub);
1389  }
1390 }

◆ coarsened_dof_values() [2/2]

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

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

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

Definition at line 822 of file fe_base.C.

828 {
829  // Side/edge local DOF indices
830  std::vector<unsigned int> new_side_dofs, old_side_dofs;
831 
832  // FIXME: what about 2D shells in 3D space?
833  unsigned int dim = elem->dim();
834 
835  // Cache n_children(); it's a virtual call but it's const.
836  const unsigned int n_children = elem->n_children();
837 
838  // We use local FE objects for now
839  // FIXME: we should use more, external objects instead for efficiency
840  const FEType & base_fe_type = dof_map.variable_type(var);
841  std::unique_ptr<FEGenericBase<OutputShape>> fe
842  (FEGenericBase<OutputShape>::build(dim, base_fe_type));
843  std::unique_ptr<FEGenericBase<OutputShape>> fe_coarse
844  (FEGenericBase<OutputShape>::build(dim, base_fe_type));
845 
846  std::unique_ptr<QBase> qrule (base_fe_type.default_quadrature_rule(dim));
847  std::unique_ptr<QBase> qedgerule (base_fe_type.default_quadrature_rule(1));
848  std::unique_ptr<QBase> qsiderule (base_fe_type.default_quadrature_rule(dim-1));
849  std::vector<Point> coarse_qpoints;
850 
851  // The values of the shape functions at the quadrature
852  // points
853  const std::vector<std::vector<OutputShape>> & phi_values =
854  fe->get_phi();
855  const std::vector<std::vector<OutputShape>> & phi_coarse =
856  fe_coarse->get_phi();
857 
858  // The gradients of the shape functions at the quadrature
859  // points on the child element.
860  const std::vector<std::vector<OutputGradient>> * dphi_values =
861  nullptr;
862  const std::vector<std::vector<OutputGradient>> * dphi_coarse =
863  nullptr;
864 
865  const FEContinuity cont = fe->get_continuity();
866 
867  if (cont == C_ONE)
868  {
869  const std::vector<std::vector<OutputGradient>> &
870  ref_dphi_values = fe->get_dphi();
871  dphi_values = &ref_dphi_values;
872  const std::vector<std::vector<OutputGradient>> &
873  ref_dphi_coarse = fe_coarse->get_dphi();
874  dphi_coarse = &ref_dphi_coarse;
875  }
876 
877  // The Jacobian * quadrature weight at the quadrature points
878  const std::vector<Real> & JxW =
879  fe->get_JxW();
880 
881  // The XYZ locations of the quadrature points on the
882  // child element
883  const std::vector<Point> & xyz_values =
884  fe->get_xyz();
885 
886 
887 
888  FEType fe_type = base_fe_type, temp_fe_type;
889  const ElemType elem_type = elem->type();
890  fe_type.order = static_cast<Order>(fe_type.order +
891  elem->max_descendant_p_level());
892 
893  // Number of nodes on parent element
894  const unsigned int n_nodes = elem->n_nodes();
895 
896  // Number of dofs on parent element
897  const unsigned int new_n_dofs =
898  FEInterface::n_dofs(dim, fe_type, elem_type);
899 
900  // Fixed vs. free DoFs on edge/face projections
901  std::vector<char> dof_is_fixed(new_n_dofs, false); // bools
902  std::vector<int> free_dof(new_n_dofs, 0);
903 
904  DenseMatrix<Real> Ke;
905  DenseVector<Number> Fe;
906  Ue.resize(new_n_dofs); Ue.zero();
907 
908 
909  // When coarsening, in general, we need a series of
910  // projections to ensure a unique and continuous
911  // solution. We start by interpolating nodes, then
912  // hold those fixed and project edges, then
913  // hold those fixed and project faces, then
914  // hold those fixed and project interiors
915 
916  // Copy node values first
917  {
918  std::vector<dof_id_type> node_dof_indices;
919  if (use_old_dof_indices)
920  dof_map.old_dof_indices (elem, node_dof_indices, var);
921  else
922  dof_map.dof_indices (elem, node_dof_indices, var);
923 
924  unsigned int current_dof = 0;
925  for (unsigned int n=0; n!= n_nodes; ++n)
926  {
927  // FIXME: this should go through the DofMap,
928  // not duplicate dof_indices code badly!
929  const unsigned int my_nc =
930  FEInterface::n_dofs_at_node (dim, fe_type,
931  elem_type, n);
932  if (!elem->is_vertex(n))
933  {
934  current_dof += my_nc;
935  continue;
936  }
937 
938  temp_fe_type = base_fe_type;
939  // We're assuming here that child n shares vertex n,
940  // which is wrong on non-simplices right now
941  // ... but this code isn't necessary except on elements
942  // where p refinement creates more vertex dofs; we have
943  // no such elements yet.
944  /*
945  if (elem->child_ptr(n)->p_level() < elem->p_level())
946  {
947  temp_fe_type.order =
948  static_cast<Order>(temp_fe_type.order +
949  elem->child_ptr(n)->p_level());
950  }
951  */
952  const unsigned int nc =
953  FEInterface::n_dofs_at_node (dim, temp_fe_type,
954  elem_type, n);
955  for (unsigned int i=0; i!= nc; ++i)
956  {
957  Ue(current_dof) =
958  old_vector(node_dof_indices[current_dof]);
959  dof_is_fixed[current_dof] = true;
960  current_dof++;
961  }
962  }
963  }
964 
965  // In 3D, project any edge values next
966  if (dim > 2 && cont != DISCONTINUOUS)
967  for (auto e : elem->edge_index_range())
968  {
969  FEInterface::dofs_on_edge(elem, dim, fe_type,
970  e, new_side_dofs);
971 
972  const unsigned int n_new_side_dofs =
973  cast_int<unsigned int>(new_side_dofs.size());
974 
975  // Some edge dofs are on nodes and already
976  // fixed, others are free to calculate
977  unsigned int free_dofs = 0;
978  for (unsigned int i=0; i != n_new_side_dofs; ++i)
979  if (!dof_is_fixed[new_side_dofs[i]])
980  free_dof[free_dofs++] = i;
981  Ke.resize (free_dofs, free_dofs); Ke.zero();
982  Fe.resize (free_dofs); Fe.zero();
983  // The new edge coefficients
984  DenseVector<Number> Uedge(free_dofs);
985 
986  // Add projection terms from each child sharing
987  // this edge
988  for (unsigned int c=0; c != n_children; ++c)
989  {
990  if (!elem->is_child_on_edge(c,e))
991  continue;
992  const Elem * child = elem->child_ptr(c);
993 
994  std::vector<dof_id_type> child_dof_indices;
995  if (use_old_dof_indices)
996  dof_map.old_dof_indices (child,
997  child_dof_indices, var);
998  else
999  dof_map.dof_indices (child,
1000  child_dof_indices, var);
1001  const unsigned int child_n_dofs =
1002  cast_int<unsigned int>
1003  (child_dof_indices.size());
1004 
1005  temp_fe_type = base_fe_type;
1006  temp_fe_type.order =
1007  static_cast<Order>(temp_fe_type.order +
1008  child->p_level());
1009 
1010  FEInterface::dofs_on_edge(child, dim,
1011  temp_fe_type, e, old_side_dofs);
1012 
1013  // Initialize both child and parent FE data
1014  // on the child's edge
1015  fe->attach_quadrature_rule (qedgerule.get());
1016  fe->edge_reinit (child, e);
1017  const unsigned int n_qp = qedgerule->n_points();
1018 
1019  FEMap::inverse_map (dim, elem, xyz_values,
1020  coarse_qpoints);
1021 
1022  fe_coarse->reinit(elem, &coarse_qpoints);
1023 
1024  // Loop over the quadrature points
1025  for (unsigned int qp=0; qp<n_qp; qp++)
1026  {
1027  // solution value at the quadrature point
1028  OutputNumber fineval = libMesh::zero;
1029  // solution grad at the quadrature point
1030  OutputNumberGradient finegrad;
1031 
1032  // Sum the solution values * the DOF
1033  // values at the quadrature point to
1034  // get the solution value and gradient.
1035  for (unsigned int i=0; i<child_n_dofs;
1036  i++)
1037  {
1038  fineval +=
1039  (old_vector(child_dof_indices[i])*
1040  phi_values[i][qp]);
1041  if (cont == C_ONE)
1042  finegrad += (*dphi_values)[i][qp] *
1043  old_vector(child_dof_indices[i]);
1044  }
1045 
1046  // Form edge projection matrix
1047  for (unsigned int sidei=0, freei=0; sidei != n_new_side_dofs; ++sidei)
1048  {
1049  unsigned int i = new_side_dofs[sidei];
1050  // fixed DoFs aren't test functions
1051  if (dof_is_fixed[i])
1052  continue;
1053  for (unsigned int sidej=0, freej=0; sidej != n_new_side_dofs; ++sidej)
1054  {
1055  unsigned int j =
1056  new_side_dofs[sidej];
1057  if (dof_is_fixed[j])
1058  Fe(freei) -=
1059  TensorTools::inner_product(phi_coarse[i][qp],
1060  phi_coarse[j][qp]) *
1061  JxW[qp] * Ue(j);
1062  else
1063  Ke(freei,freej) +=
1064  TensorTools::inner_product(phi_coarse[i][qp],
1065  phi_coarse[j][qp]) *
1066  JxW[qp];
1067  if (cont == C_ONE)
1068  {
1069  if (dof_is_fixed[j])
1070  Fe(freei) -=
1071  TensorTools::inner_product((*dphi_coarse)[i][qp],
1072  (*dphi_coarse)[j][qp]) *
1073  JxW[qp] * Ue(j);
1074  else
1075  Ke(freei,freej) +=
1076  TensorTools::inner_product((*dphi_coarse)[i][qp],
1077  (*dphi_coarse)[j][qp]) *
1078  JxW[qp];
1079  }
1080  if (!dof_is_fixed[j])
1081  freej++;
1082  }
1083  Fe(freei) += TensorTools::inner_product(phi_coarse[i][qp],
1084  fineval) * JxW[qp];
1085  if (cont == C_ONE)
1086  Fe(freei) +=
1087  TensorTools::inner_product(finegrad, (*dphi_coarse)[i][qp]) * JxW[qp];
1088  freei++;
1089  }
1090  }
1091  }
1092  Ke.cholesky_solve(Fe, Uedge);
1093 
1094  // Transfer new edge solutions to element
1095  for (unsigned int i=0; i != free_dofs; ++i)
1096  {
1097  Number & ui = Ue(new_side_dofs[free_dof[i]]);
1098  libmesh_assert(std::abs(ui) < TOLERANCE ||
1099  std::abs(ui - Uedge(i)) < TOLERANCE);
1100  ui = Uedge(i);
1101  dof_is_fixed[new_side_dofs[free_dof[i]]] = true;
1102  }
1103  }
1104 
1105  // Project any side values (edges in 2D, faces in 3D)
1106  if (dim > 1 && cont != DISCONTINUOUS)
1107  for (auto s : elem->side_index_range())
1108  {
1109  FEInterface::dofs_on_side(elem, dim, fe_type,
1110  s, new_side_dofs);
1111 
1112  const unsigned int n_new_side_dofs =
1113  cast_int<unsigned int>(new_side_dofs.size());
1114 
1115  // Some side dofs are on nodes/edges and already
1116  // fixed, others are free to calculate
1117  unsigned int free_dofs = 0;
1118  for (unsigned int i=0; i != n_new_side_dofs; ++i)
1119  if (!dof_is_fixed[new_side_dofs[i]])
1120  free_dof[free_dofs++] = i;
1121  Ke.resize (free_dofs, free_dofs); Ke.zero();
1122  Fe.resize (free_dofs); Fe.zero();
1123  // The new side coefficients
1124  DenseVector<Number> Uside(free_dofs);
1125 
1126  // Add projection terms from each child sharing
1127  // this side
1128  for (unsigned int c=0; c != n_children; ++c)
1129  {
1130  if (!elem->is_child_on_side(c,s))
1131  continue;
1132  const Elem * child = elem->child_ptr(c);
1133 
1134  std::vector<dof_id_type> child_dof_indices;
1135  if (use_old_dof_indices)
1136  dof_map.old_dof_indices (child,
1137  child_dof_indices, var);
1138  else
1139  dof_map.dof_indices (child,
1140  child_dof_indices, var);
1141  const unsigned int child_n_dofs =
1142  cast_int<unsigned int>
1143  (child_dof_indices.size());
1144 
1145  temp_fe_type = base_fe_type;
1146  temp_fe_type.order =
1147  static_cast<Order>(temp_fe_type.order +
1148  child->p_level());
1149 
1150  FEInterface::dofs_on_side(child, dim,
1151  temp_fe_type, s, old_side_dofs);
1152 
1153  // Initialize both child and parent FE data
1154  // on the child's side
1155  fe->attach_quadrature_rule (qsiderule.get());
1156  fe->reinit (child, s);
1157  const unsigned int n_qp = qsiderule->n_points();
1158 
1159  FEMap::inverse_map (dim, elem, xyz_values,
1160  coarse_qpoints);
1161 
1162  fe_coarse->reinit(elem, &coarse_qpoints);
1163 
1164  // Loop over the quadrature points
1165  for (unsigned int qp=0; qp<n_qp; qp++)
1166  {
1167  // solution value at the quadrature point
1168  OutputNumber fineval = libMesh::zero;
1169  // solution grad at the quadrature point
1170  OutputNumberGradient finegrad;
1171 
1172  // Sum the solution values * the DOF
1173  // values at the quadrature point to
1174  // get the solution value and gradient.
1175  for (unsigned int i=0; i<child_n_dofs;
1176  i++)
1177  {
1178  fineval +=
1179  old_vector(child_dof_indices[i]) *
1180  phi_values[i][qp];
1181  if (cont == C_ONE)
1182  finegrad += (*dphi_values)[i][qp] *
1183  old_vector(child_dof_indices[i]);
1184  }
1185 
1186  // Form side projection matrix
1187  for (unsigned int sidei=0, freei=0; sidei != n_new_side_dofs; ++sidei)
1188  {
1189  unsigned int i = new_side_dofs[sidei];
1190  // fixed DoFs aren't test functions
1191  if (dof_is_fixed[i])
1192  continue;
1193  for (unsigned int sidej=0, freej=0; sidej != n_new_side_dofs; ++sidej)
1194  {
1195  unsigned int j =
1196  new_side_dofs[sidej];
1197  if (dof_is_fixed[j])
1198  Fe(freei) -=
1199  TensorTools::inner_product(phi_coarse[i][qp],
1200  phi_coarse[j][qp]) *
1201  JxW[qp] * Ue(j);
1202  else
1203  Ke(freei,freej) +=
1204  TensorTools::inner_product(phi_coarse[i][qp],
1205  phi_coarse[j][qp]) *
1206  JxW[qp];
1207  if (cont == C_ONE)
1208  {
1209  if (dof_is_fixed[j])
1210  Fe(freei) -=
1211  TensorTools::inner_product((*dphi_coarse)[i][qp],
1212  (*dphi_coarse)[j][qp]) *
1213  JxW[qp] * Ue(j);
1214  else
1215  Ke(freei,freej) +=
1216  TensorTools::inner_product((*dphi_coarse)[i][qp],
1217  (*dphi_coarse)[j][qp]) *
1218  JxW[qp];
1219  }
1220  if (!dof_is_fixed[j])
1221  freej++;
1222  }
1223  Fe(freei) += TensorTools::inner_product(fineval, phi_coarse[i][qp]) * JxW[qp];
1224  if (cont == C_ONE)
1225  Fe(freei) +=
1226  TensorTools::inner_product(finegrad, (*dphi_coarse)[i][qp]) * JxW[qp];
1227  freei++;
1228  }
1229  }
1230  }
1231  Ke.cholesky_solve(Fe, Uside);
1232 
1233  // Transfer new side solutions to element
1234  for (unsigned int i=0; i != free_dofs; ++i)
1235  {
1236  Number & ui = Ue(new_side_dofs[free_dof[i]]);
1237  libmesh_assert(std::abs(ui) < TOLERANCE ||
1238  std::abs(ui - Uside(i)) < TOLERANCE);
1239  ui = Uside(i);
1240  dof_is_fixed[new_side_dofs[free_dof[i]]] = true;
1241  }
1242  }
1243 
1244  // Project the interior values, finally
1245 
1246  // Some interior dofs are on nodes/edges/sides and
1247  // already fixed, others are free to calculate
1248  unsigned int free_dofs = 0;
1249  for (unsigned int i=0; i != new_n_dofs; ++i)
1250  if (!dof_is_fixed[i])
1251  free_dof[free_dofs++] = i;
1252  Ke.resize (free_dofs, free_dofs); Ke.zero();
1253  Fe.resize (free_dofs); Fe.zero();
1254  // The new interior coefficients
1255  DenseVector<Number> Uint(free_dofs);
1256 
1257  // Add projection terms from each child
1258  for (auto & child : elem->child_ref_range())
1259  {
1260  std::vector<dof_id_type> child_dof_indices;
1261  if (use_old_dof_indices)
1262  dof_map.old_dof_indices (&child,
1263  child_dof_indices, var);
1264  else
1265  dof_map.dof_indices (&child,
1266  child_dof_indices, var);
1267  const unsigned int child_n_dofs =
1268  cast_int<unsigned int>
1269  (child_dof_indices.size());
1270 
1271  // Initialize both child and parent FE data
1272  // on the child's quadrature points
1273  fe->attach_quadrature_rule (qrule.get());
1274  fe->reinit (&child);
1275  const unsigned int n_qp = qrule->n_points();
1276 
1277  FEMap::inverse_map (dim, elem, xyz_values, coarse_qpoints);
1278 
1279  fe_coarse->reinit(elem, &coarse_qpoints);
1280 
1281  // Loop over the quadrature points
1282  for (unsigned int qp=0; qp<n_qp; qp++)
1283  {
1284  // solution value at the quadrature point
1285  OutputNumber fineval = libMesh::zero;
1286  // solution grad at the quadrature point
1287  OutputNumberGradient finegrad;
1288 
1289  // Sum the solution values * the DOF
1290  // values at the quadrature point to
1291  // get the solution value and gradient.
1292  for (unsigned int i=0; i<child_n_dofs; i++)
1293  {
1294  fineval +=
1295  (old_vector(child_dof_indices[i]) *
1296  phi_values[i][qp]);
1297  if (cont == C_ONE)
1298  finegrad += (*dphi_values)[i][qp] *
1299  old_vector(child_dof_indices[i]);
1300  }
1301 
1302  // Form interior projection matrix
1303  for (unsigned int i=0, freei=0;
1304  i != new_n_dofs; ++i)
1305  {
1306  // fixed DoFs aren't test functions
1307  if (dof_is_fixed[i])
1308  continue;
1309  for (unsigned int j=0, freej=0; j !=
1310  new_n_dofs; ++j)
1311  {
1312  if (dof_is_fixed[j])
1313  Fe(freei) -=
1314  TensorTools::inner_product(phi_coarse[i][qp],
1315  phi_coarse[j][qp]) *
1316  JxW[qp] * Ue(j);
1317  else
1318  Ke(freei,freej) +=
1319  TensorTools::inner_product(phi_coarse[i][qp],
1320  phi_coarse[j][qp]) *
1321  JxW[qp];
1322  if (cont == C_ONE)
1323  {
1324  if (dof_is_fixed[j])
1325  Fe(freei) -=
1326  TensorTools::inner_product((*dphi_coarse)[i][qp],
1327  (*dphi_coarse)[j][qp]) *
1328  JxW[qp] * Ue(j);
1329  else
1330  Ke(freei,freej) +=
1331  TensorTools::inner_product((*dphi_coarse)[i][qp],
1332  (*dphi_coarse)[j][qp]) *
1333  JxW[qp];
1334  }
1335  if (!dof_is_fixed[j])
1336  freej++;
1337  }
1338  Fe(freei) += TensorTools::inner_product(phi_coarse[i][qp], fineval) *
1339  JxW[qp];
1340  if (cont == C_ONE)
1341  Fe(freei) += TensorTools::inner_product(finegrad, (*dphi_coarse)[i][qp]) * JxW[qp];
1342  freei++;
1343  }
1344  }
1345  }
1346  Ke.cholesky_solve(Fe, Uint);
1347 
1348  // Transfer new interior solutions to element
1349  for (unsigned int i=0; i != free_dofs; ++i)
1350  {
1351  Number & ui = Ue(free_dof[i]);
1352  libmesh_assert(std::abs(ui) < TOLERANCE ||
1353  std::abs(ui - Uint(i)) < TOLERANCE);
1354  ui = Uint(i);
1355  // We should be fixing all dofs by now; no need to keep track of
1356  // that unless we're debugging
1357 #ifndef NDEBUG
1358  dof_is_fixed[free_dof[i]] = true;
1359 #endif
1360  }
1361 
1362 #ifndef NDEBUG
1363  // Make sure every DoF got reached!
1364  for (unsigned int i=0; i != new_n_dofs; ++i)
1365  libmesh_assert(dof_is_fixed[i]);
1366 #endif
1367 }

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

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

847 {
848  libmesh_assert(elem);
849 
850  const unsigned int Dim = elem->dim();
851 
852  // Only constrain elements in 2,3D.
853  if (Dim == 1)
854  return;
855 
856  // Only constrain active and ancestor elements
857  if (elem->subactive())
858  return;
859 
860  const FEFamily mapping_family = FEMap::map_fe_type(*elem);
861  const FEType fe_type(elem->default_order(), mapping_family);
862 
863  // Pull objects out of the loop to reduce heap operations
864  std::vector<const Node *> my_nodes, parent_nodes;
865  std::unique_ptr<const Elem> my_side, parent_side;
866 
867  // Look at the element faces. Check to see if we need to
868  // build constraints.
869  for (auto s : elem->side_index_range())
870  if (elem->neighbor_ptr(s) != nullptr &&
871  elem->neighbor_ptr(s) != remote_elem)
872  if (elem->neighbor_ptr(s)->level() < elem->level()) // constrain dofs shared between
873  { // this element and ones coarser
874  // than this element.
875  // Get pointers to the elements of interest and its parent.
876  const Elem * parent = elem->parent();
877 
878  // This can't happen... Only level-0 elements have nullptr
879  // parents, and no level-0 elements can be at a higher
880  // level than their neighbors!
881  libmesh_assert(parent);
882 
883  elem->build_side_ptr(my_side, s);
884  parent->build_side_ptr(parent_side, s);
885 
886  const unsigned int n_side_nodes = my_side->n_nodes();
887 
888  my_nodes.clear();
889  my_nodes.reserve (n_side_nodes);
890  parent_nodes.clear();
891  parent_nodes.reserve (n_side_nodes);
892 
893  for (unsigned int n=0; n != n_side_nodes; ++n)
894  my_nodes.push_back(my_side->node_ptr(n));
895 
896  for (unsigned int n=0; n != n_side_nodes; ++n)
897  parent_nodes.push_back(parent_side->node_ptr(n));
898 
899  for (unsigned int my_side_n=0;
900  my_side_n < n_side_nodes;
901  my_side_n++)
902  {
903  libmesh_assert_less (my_side_n, FEInterface::n_dofs(Dim-1, fe_type, my_side->type()));
904 
905  const Node * my_node = my_nodes[my_side_n];
906 
907  // The support point of the DOF
908  const Point & support_point = *my_node;
909 
910  // Figure out where my node lies on their reference element.
911  const Point mapped_point = FEMap::inverse_map(Dim-1,
912  parent_side.get(),
913  support_point);
914 
915  // Compute the parent's side shape function values.
916  for (unsigned int their_side_n=0;
917  their_side_n < n_side_nodes;
918  their_side_n++)
919  {
920  libmesh_assert_less (their_side_n, FEInterface::n_dofs(Dim-1, fe_type, parent_side->type()));
921 
922  const Node * their_node = parent_nodes[their_side_n];
923  libmesh_assert(their_node);
924 
925  const Real their_value = FEInterface::shape(Dim-1,
926  fe_type,
927  parent_side->type(),
928  their_side_n,
929  mapped_point);
930 
931  const Real their_mag = std::abs(their_value);
932 #ifdef DEBUG
933  // Protect for the case u_i ~= u_j,
934  // in which case i better equal j.
935  if (their_mag > 0.999)
936  {
937  libmesh_assert_equal_to (my_node, their_node);
938  libmesh_assert_less (std::abs(their_value - 1.), 0.001);
939  }
940  else
941 #endif
942  // To make nodal constraints useful for constructing
943  // sparsity patterns faster, we need to get EVERY
944  // POSSIBLE constraint coupling identified, even if
945  // there is no coupling in the isoparametric
946  // Lagrange case.
947  if (their_mag < 1.e-5)
948  {
949  // since we may be running this method concurrently
950  // on multiple threads we need to acquire a lock
951  // before modifying the shared constraint_row object.
952  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
953 
954  // A reference to the constraint row.
955  NodeConstraintRow & constraint_row = constraints[my_node].first;
956 
957  constraint_row.insert(std::make_pair (their_node,
958  0.));
959  }
960  // To get nodal coordinate constraints right, only
961  // add non-zero and non-identity values for Lagrange
962  // basis functions.
963  else // (1.e-5 <= their_mag <= .999)
964  {
965  // since we may be running this method concurrently
966  // on multiple threads we need to acquire a lock
967  // before modifying the shared constraint_row object.
968  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
969 
970  // A reference to the constraint row.
971  NodeConstraintRow & constraint_row = constraints[my_node].first;
972 
973  constraint_row.insert(std::make_pair (their_node,
974  their_value));
975  }
976  }
977  }
978  }
979 }

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

◆ compute_periodic_constraints()

template<typename OutputType >
void libMesh::FEGenericBase< OutputType >::compute_periodic_constraints ( DofConstraints &  constraints,
DofMap &  dof_map,
const PeriodicBoundaries &  boundaries,
const MeshBase &  mesh,
const PointLocatorBase *  point_locator,
const unsigned int  variable_number,
const Elem *  elem 
)
static

Computes the constraint matrix contributions (for meshes with periodic boundary conditions) corresponding to variable number var_number, using generic projections.

Definition at line 1692 of file fe_base.C.

1699 {
1700  // Only bother if we truly have periodic boundaries
1701  if (boundaries.empty())
1702  return;
1703 
1704  libmesh_assert(elem);
1705 
1706  // Only constrain active elements with this method
1707  if (!elem->active())
1708  return;
1709 
1710  const unsigned int Dim = elem->dim();
1711 
1712  // We need sys_number and variable_number for DofObject methods
1713  // later
1714  const unsigned int sys_number = dof_map.sys_number();
1715 
1716  const FEType & base_fe_type = dof_map.variable_type(variable_number);
1717 
1718  // Construct FE objects for this element and its pseudo-neighbors.
1719  std::unique_ptr<FEGenericBase<OutputShape>> my_fe
1720  (FEGenericBase<OutputShape>::build(Dim, base_fe_type));
1721  const FEContinuity cont = my_fe->get_continuity();
1722 
1723  // We don't need to constrain discontinuous elements
1724  if (cont == DISCONTINUOUS)
1725  return;
1726  libmesh_assert (cont == C_ZERO || cont == C_ONE);
1727 
1728  // We'll use element size to generate relative tolerances later
1729  const Real primary_hmin = elem->hmin();
1730 
1731  std::unique_ptr<FEGenericBase<OutputShape>> neigh_fe
1732  (FEGenericBase<OutputShape>::build(Dim, base_fe_type));
1733 
1734  QGauss my_qface(Dim-1, base_fe_type.default_quadrature_order());
1735  my_fe->attach_quadrature_rule (&my_qface);
1736  std::vector<Point> neigh_qface;
1737 
1738  const std::vector<Real> & JxW = my_fe->get_JxW();
1739  const std::vector<Point> & q_point = my_fe->get_xyz();
1740  const std::vector<std::vector<OutputShape>> & phi = my_fe->get_phi();
1741  const std::vector<std::vector<OutputShape>> & neigh_phi =
1742  neigh_fe->get_phi();
1743  const std::vector<Point> * face_normals = nullptr;
1744  const std::vector<std::vector<OutputGradient>> * dphi = nullptr;
1745  const std::vector<std::vector<OutputGradient>> * neigh_dphi = nullptr;
1746  std::vector<dof_id_type> my_dof_indices, neigh_dof_indices;
1747  std::vector<unsigned int> my_side_dofs, neigh_side_dofs;
1748 
1749  if (cont != C_ZERO)
1750  {
1751  const std::vector<Point> & ref_face_normals =
1752  my_fe->get_normals();
1753  face_normals = &ref_face_normals;
1754  const std::vector<std::vector<OutputGradient>> & ref_dphi =
1755  my_fe->get_dphi();
1756  dphi = &ref_dphi;
1757  const std::vector<std::vector<OutputGradient>> & ref_neigh_dphi =
1758  neigh_fe->get_dphi();
1759  neigh_dphi = &ref_neigh_dphi;
1760  }
1761 
1762  DenseMatrix<Real> Ke;
1763  DenseVector<Real> Fe;
1764  std::vector<DenseVector<Real>> Ue;
1765 
1766  // Container to catch the boundary ids that BoundaryInfo hands us.
1767  std::vector<boundary_id_type> bc_ids;
1768 
1769  // Look at the element faces. Check to see if we need to
1770  // build constraints.
1771  const unsigned short int max_ns = elem->n_sides();
1772  for (unsigned short int s = 0; s != max_ns; ++s)
1773  {
1774  if (elem->neighbor_ptr(s))
1775  continue;
1776 
1777  mesh.get_boundary_info().boundary_ids (elem, s, bc_ids);
1778 
1779  for (const auto & boundary_id : bc_ids)
1780  {
1781  const PeriodicBoundaryBase * periodic = boundaries.boundary(boundary_id);
1782  if (periodic && periodic->is_my_variable(variable_number))
1783  {
1784  libmesh_assert(point_locator);
1785 
1786  // Get pointers to the element's neighbor.
1787  const Elem * neigh = boundaries.neighbor(boundary_id, *point_locator, elem, s);
1788 
1789  if (neigh == nullptr)
1790  libmesh_error_msg("PeriodicBoundaries point locator object returned nullptr!");
1791 
1792  // periodic (and possibly h refinement) constraints:
1793  // constrain dofs shared between
1794  // this element and ones as coarse
1795  // as or coarser than this element.
1796  if (neigh->level() <= elem->level())
1797  {
1798  unsigned int s_neigh =
1799  mesh.get_boundary_info().side_with_boundary_id(neigh, periodic->pairedboundary);
1800  libmesh_assert_not_equal_to (s_neigh, libMesh::invalid_uint);
1801 
1802 #ifdef LIBMESH_ENABLE_AMR
1803  // Find the minimum p level; we build the h constraint
1804  // matrix with this and then constrain away all higher p
1805  // DoFs.
1806  libmesh_assert(neigh->active());
1807  const unsigned int min_p_level =
1808  std::min(elem->p_level(), neigh->p_level());
1809 
1810  // we may need to make the FE objects reinit with the
1811  // minimum shared p_level
1812  // FIXME - I hate using const_cast<> and avoiding
1813  // accessor functions; there's got to be a
1814  // better way to do this!
1815  const unsigned int old_elem_level = elem->p_level();
1816  if (old_elem_level != min_p_level)
1817  (const_cast<Elem *>(elem))->hack_p_level(min_p_level);
1818  const unsigned int old_neigh_level = neigh->p_level();
1819  if (old_neigh_level != min_p_level)
1820  (const_cast<Elem *>(neigh))->hack_p_level(min_p_level);
1821 #endif // #ifdef LIBMESH_ENABLE_AMR
1822 
1823  // We can do a projection with a single integration,
1824  // due to the assumption of nested finite element
1825  // subspaces.
1826  // FIXME: it might be more efficient to do nodes,
1827  // then edges, then side, to reduce the size of the
1828  // Cholesky factorization(s)
1829  my_fe->reinit(elem, s);
1830 
1831  dof_map.dof_indices (elem, my_dof_indices,
1832  variable_number);
1833  dof_map.dof_indices (neigh, neigh_dof_indices,
1834  variable_number);
1835 
1836  // We use neigh_dof_indices_all_variables in the case that the
1837  // periodic boundary condition involves mappings between multiple
1838  // variables.
1839  std::vector<std::vector<dof_id_type>> neigh_dof_indices_all_variables;
1840  if(periodic->has_transformation_matrix())
1841  {
1842  const std::set<unsigned int> & variables = periodic->get_variables();
1843  neigh_dof_indices_all_variables.resize(variables.size());
1844  unsigned int index = 0;
1845  for(unsigned int var : variables)
1846  {
1847  dof_map.dof_indices (neigh, neigh_dof_indices_all_variables[index],
1848  var);
1849  index++;
1850  }
1851  }
1852 
1853  const unsigned int n_qp = my_qface.n_points();
1854 
1855  // Translate the quadrature points over to the
1856  // neighbor's boundary
1857  std::vector<Point> neigh_point(q_point.size());
1858  for (auto i : index_range(neigh_point))
1859  neigh_point[i] = periodic->get_corresponding_pos(q_point[i]);
1860 
1861  FEMap::inverse_map (Dim, neigh, neigh_point,
1862  neigh_qface);
1863 
1864  neigh_fe->reinit(neigh, &neigh_qface);
1865 
1866  // We're only concerned with DOFs whose values (and/or first
1867  // derivatives for C1 elements) are supported on side nodes
1868  FEInterface::dofs_on_side(elem, Dim, base_fe_type, s, my_side_dofs);
1869  FEInterface::dofs_on_side(neigh, Dim, base_fe_type, s_neigh, neigh_side_dofs);
1870 
1871  // We're done with functions that examine Elem::p_level(),
1872  // so let's unhack those levels
1873 #ifdef LIBMESH_ENABLE_AMR
1874  if (elem->p_level() != old_elem_level)
1875  (const_cast<Elem *>(elem))->hack_p_level(old_elem_level);
1876  if (neigh->p_level() != old_neigh_level)
1877  (const_cast<Elem *>(neigh))->hack_p_level(old_neigh_level);
1878 #endif // #ifdef LIBMESH_ENABLE_AMR
1879 
1880  const unsigned int n_side_dofs =
1881  cast_int<unsigned int>
1882  (my_side_dofs.size());
1883  libmesh_assert_equal_to (n_side_dofs, neigh_side_dofs.size());
1884 
1885  Ke.resize (n_side_dofs, n_side_dofs);
1886  Ue.resize(n_side_dofs);
1887 
1888  // Form the projection matrix, (inner product of fine basis
1889  // functions against fine test functions)
1890  for (unsigned int is = 0; is != n_side_dofs; ++is)
1891  {
1892  const unsigned int i = my_side_dofs[is];
1893  for (unsigned int js = 0; js != n_side_dofs; ++js)
1894  {
1895  const unsigned int j = my_side_dofs[js];
1896  for (unsigned int qp = 0; qp != n_qp; ++qp)
1897  {
1898  Ke(is,js) += JxW[qp] *
1899  TensorTools::inner_product(phi[i][qp],
1900  phi[j][qp]);
1901  if (cont != C_ZERO)
1902  Ke(is,js) += JxW[qp] *
1903  TensorTools::inner_product((*dphi)[i][qp] *
1904  (*face_normals)[qp],
1905  (*dphi)[j][qp] *
1906  (*face_normals)[qp]);
1907  }
1908  }
1909  }
1910 
1911  // Form the right hand sides, (inner product of coarse basis
1912  // functions against fine test functions)
1913  for (unsigned int is = 0; is != n_side_dofs; ++is)
1914  {
1915  const unsigned int i = neigh_side_dofs[is];
1916  Fe.resize (n_side_dofs);
1917  for (unsigned int js = 0; js != n_side_dofs; ++js)
1918  {
1919  const unsigned int j = my_side_dofs[js];
1920  for (unsigned int qp = 0; qp != n_qp; ++qp)
1921  {
1922  Fe(js) += JxW[qp] *
1923  TensorTools::inner_product(neigh_phi[i][qp],
1924  phi[j][qp]);
1925  if (cont != C_ZERO)
1926  Fe(js) += JxW[qp] *
1927  TensorTools::inner_product((*neigh_dphi)[i][qp] *
1928  (*face_normals)[qp],
1929  (*dphi)[j][qp] *
1930  (*face_normals)[qp]);
1931  }
1932  }
1933  Ke.cholesky_solve(Fe, Ue[is]);
1934  }
1935 
1936  // Make sure we're not adding recursive constraints
1937  // due to the redundancy in the way we add periodic
1938  // boundary constraints
1939  //
1940  // In order for this to work while threaded or on
1941  // distributed meshes, we need a rigorous way to
1942  // avoid recursive constraints. Here it is:
1943  //
1944  // For vertex DoFs, if there is a "prior" element
1945  // (i.e. a coarser element or an equally refined
1946  // element with a lower id) on this boundary which
1947  // contains the vertex point, then we will avoid
1948  // generating constraints; the prior element (or
1949  // something prior to it) may do so. If we are the
1950  // most prior (or "primary") element on this
1951  // boundary sharing this point, then we look at the
1952  // boundary periodic to us, we find the primary
1953  // element there, and if that primary is coarser or
1954  // equal-but-lower-id, then our vertex dofs are
1955  // constrained in terms of that element.
1956  //
1957  // For edge DoFs, if there is a coarser element
1958  // on this boundary sharing this edge, then we will
1959  // avoid generating constraints (we will be
1960  // constrained indirectly via AMR constraints
1961  // connecting us to the coarser element's DoFs). If
1962  // we are the coarsest element sharing this edge,
1963  // then we generate constraints if and only if we
1964  // are finer than the coarsest element on the
1965  // boundary periodic to us sharing the corresponding
1966  // periodic edge, or if we are at equal level but
1967  // our edge nodes have higher ids than the periodic
1968  // edge nodes (sorted from highest to lowest, then
1969  // compared lexicographically)
1970  //
1971  // For face DoFs, we generate constraints if we are
1972  // finer than our periodic neighbor, or if we are at
1973  // equal level but our element id is higher than its
1974  // element id.
1975  //
1976  // If the primary neighbor is also the current elem
1977  // (a 1-element-thick mesh) then we choose which
1978  // vertex dofs to constrain via lexicographic
1979  // ordering on point locations
1980 
1981  // FIXME: This code doesn't yet properly handle
1982  // cases where multiple different periodic BCs
1983  // intersect.
1984  std::set<dof_id_type> my_constrained_dofs;
1985 
1986  // Container to catch boundary IDs handed back by BoundaryInfo.
1987  std::vector<boundary_id_type> new_bc_ids;
1988 
1989  for (auto n : elem->node_index_range())
1990  {
1991  if (!elem->is_node_on_side(n,s))
1992  continue;
1993 
1994  const Node & my_node = elem->node_ref(n);
1995 
1996  if (elem->is_vertex(n))
1997  {
1998  // Find all boundary ids that include this
1999  // point and have periodic boundary
2000  // conditions for this variable
2001  std::set<boundary_id_type> point_bcids;
2002 
2003  for (unsigned int new_s = 0;
2004  new_s != max_ns; ++new_s)
2005  {
2006  if (!elem->is_node_on_side(n,new_s))
2007  continue;
2008 
2009  mesh.get_boundary_info().boundary_ids (elem, s, new_bc_ids);
2010 
2011  for (const auto & new_boundary_id : new_bc_ids)
2012  {
2013  const PeriodicBoundaryBase * new_periodic = boundaries.boundary(new_boundary_id);
2014  if (new_periodic && new_periodic->is_my_variable(variable_number))
2015  point_bcids.insert(new_boundary_id);
2016  }
2017  }
2018 
2019  // See if this vertex has point neighbors to
2020  // defer to
2021  if (primary_boundary_point_neighbor
2022  (elem, my_node, mesh.get_boundary_info(), point_bcids)
2023  != elem)
2024  continue;
2025 
2026  // Find the complementary boundary id set
2027  std::set<boundary_id_type> point_pairedids;
2028  for (const auto & new_boundary_id : point_bcids)
2029  {
2030  const PeriodicBoundaryBase * new_periodic = boundaries.boundary(new_boundary_id);
2031  point_pairedids.insert(new_periodic->pairedboundary);
2032  }
2033 
2034  // What do we want to constrain against?
2035  const Elem * primary_elem = nullptr;
2036  const Elem * main_neigh = nullptr;
2037  Point main_pt = my_node,
2038  primary_pt = my_node;
2039 
2040  for (const auto & new_boundary_id : point_bcids)
2041  {
2042  // Find the corresponding periodic point and
2043  // its primary neighbor
2044  const PeriodicBoundaryBase * new_periodic = boundaries.boundary(new_boundary_id);
2045 
2046  const Point neigh_pt =
2047  new_periodic->get_corresponding_pos(my_node);
2048 
2049  // If the point is getting constrained
2050  // to itself by this PBC then we don't
2051  // generate any constraints
2052  if (neigh_pt.absolute_fuzzy_equals
2053  (my_node, primary_hmin*TOLERANCE))
2054  continue;
2055 
2056  // Otherwise we'll have a constraint in
2057  // one direction or another
2058  if (!primary_elem)
2059  primary_elem = elem;
2060 
2061  const Elem * primary_neigh =
2062  primary_boundary_point_neighbor(neigh, neigh_pt,
2063  mesh.get_boundary_info(),
2064  point_pairedids);
2065 
2066  libmesh_assert(primary_neigh);
2067 
2068  if (new_boundary_id == boundary_id)
2069  {
2070  main_neigh = primary_neigh;
2071  main_pt = neigh_pt;
2072  }
2073 
2074  // Finer elements will get constrained in
2075  // terms of coarser neighbors, not the
2076  // other way around
2077  if ((primary_neigh->level() > primary_elem->level()) ||
2078 
2079  // For equal-level elements, the one with
2080  // higher id gets constrained in terms of
2081  // the one with lower id
2082  (primary_neigh->level() == primary_elem->level() &&
2083  primary_neigh->id() > primary_elem->id()) ||
2084 
2085  // On a one-element-thick mesh, we compare
2086  // points to see what side gets constrained
2087  (primary_neigh == primary_elem &&
2088  (neigh_pt > primary_pt)))
2089  continue;
2090 
2091  primary_elem = primary_neigh;
2092  primary_pt = neigh_pt;
2093  }
2094 
2095  if (!primary_elem ||
2096  primary_elem != main_neigh ||
2097  primary_pt != main_pt)
2098  continue;
2099  }
2100  else if (elem->is_edge(n))
2101  {
2102  // Find which edge we're on
2103  unsigned int e=0, ne = elem->n_edges();
2104  for (; e != ne; ++e)
2105  {
2106  if (elem->is_node_on_edge(n,e))
2107  break;
2108  }
2109  libmesh_assert_less (e, elem->n_edges());
2110 
2111  // Find the edge end nodes
2112  const Node
2113  * e1 = nullptr,
2114  * e2 = nullptr;
2115  for (auto nn : elem->node_index_range())
2116  {
2117  if (nn == n)
2118  continue;
2119 
2120  if (elem->is_node_on_edge(nn, e))
2121  {
2122  if (e1 == nullptr)
2123  {
2124  e1 = elem->node_ptr(nn);
2125  }
2126  else
2127  {
2128  e2 = elem->node_ptr(nn);
2129  break;
2130  }
2131  }
2132  }
2133  libmesh_assert (e1 && e2);
2134 
2135  // Find all boundary ids that include this
2136  // edge and have periodic boundary
2137  // conditions for this variable
2138  std::set<boundary_id_type> edge_bcids;
2139 
2140  for (unsigned int new_s = 0;
2141  new_s != max_ns; ++new_s)
2142  {
2143  if (!elem->is_node_on_side(n,new_s))
2144  continue;
2145 
2146  // We're reusing the new_bc_ids vector created outside the loop over nodes.
2147  mesh.get_boundary_info().boundary_ids (elem, s, new_bc_ids);
2148 
2149  for (const auto & new_boundary_id : new_bc_ids)
2150  {
2151  const PeriodicBoundaryBase * new_periodic = boundaries.boundary(new_boundary_id);
2152  if (new_periodic && new_periodic->is_my_variable(variable_number))
2153  edge_bcids.insert(new_boundary_id);
2154  }
2155  }
2156 
2157 
2158  // See if this edge has neighbors to defer to
2159  if (primary_boundary_edge_neighbor
2160  (elem, *e1, *e2, mesh.get_boundary_info(), edge_bcids)
2161  != elem)
2162  continue;
2163 
2164  // Find the complementary boundary id set
2165  std::set<boundary_id_type> edge_pairedids;
2166  for (const auto & new_boundary_id : edge_bcids)
2167  {
2168  const PeriodicBoundaryBase * new_periodic = boundaries.boundary(new_boundary_id);
2169  edge_pairedids.insert(new_periodic->pairedboundary);
2170  }
2171 
2172  // What do we want to constrain against?
2173  const Elem * primary_elem = nullptr;
2174  const Elem * main_neigh = nullptr;
2175  Point main_pt1 = *e1,
2176  main_pt2 = *e2,
2177  primary_pt1 = *e1,
2178  primary_pt2 = *e2;
2179 
2180  for (const auto & new_boundary_id : edge_bcids)
2181  {
2182  // Find the corresponding periodic edge and
2183  // its primary neighbor
2184  const PeriodicBoundaryBase * new_periodic = boundaries.boundary(new_boundary_id);
2185 
2186  Point neigh_pt1 = new_periodic->get_corresponding_pos(*e1),
2187  neigh_pt2 = new_periodic->get_corresponding_pos(*e2);
2188 
2189  // If the edge is getting constrained
2190  // to itself by this PBC then we don't
2191  // generate any constraints
2192  if (neigh_pt1.absolute_fuzzy_equals
2193  (*e1, primary_hmin*TOLERANCE) &&
2194  neigh_pt2.absolute_fuzzy_equals
2195  (*e2, primary_hmin*TOLERANCE))
2196  continue;
2197 
2198  // Otherwise we'll have a constraint in
2199  // one direction or another
2200  if (!primary_elem)
2201  primary_elem = elem;
2202 
2203  const Elem * primary_neigh = primary_boundary_edge_neighbor
2204  (neigh, neigh_pt1, neigh_pt2,
2205  mesh.get_boundary_info(), edge_pairedids);
2206 
2207  libmesh_assert(primary_neigh);
2208 
2209  if (new_boundary_id == boundary_id)
2210  {
2211  main_neigh = primary_neigh;
2212  main_pt1 = neigh_pt1;
2213  main_pt2 = neigh_pt2;
2214  }
2215 
2216  // If we have a one-element thick mesh,
2217  // we'll need to sort our points to get a
2218  // consistent ordering rule
2219  //
2220  // Use >= in this test to make sure that,
2221  // for angular constraints, no node gets
2222  // constrained to itself.
2223  if (primary_neigh == primary_elem)
2224  {
2225  if (primary_pt1 > primary_pt2)
2226  std::swap(primary_pt1, primary_pt2);
2227  if (neigh_pt1 > neigh_pt2)
2228  std::swap(neigh_pt1, neigh_pt2);
2229 
2230  if (neigh_pt2 >= primary_pt2)
2231  continue;
2232  }
2233 
2234  // Otherwise:
2235  // Finer elements will get constrained in
2236  // terms of coarser ones, not the other way
2237  // around
2238  if ((primary_neigh->level() > primary_elem->level()) ||
2239 
2240  // For equal-level elements, the one with
2241  // higher id gets constrained in terms of
2242  // the one with lower id
2243  (primary_neigh->level() == primary_elem->level() &&
2244  primary_neigh->id() > primary_elem->id()))
2245  continue;
2246 
2247  primary_elem = primary_neigh;
2248  primary_pt1 = neigh_pt1;
2249  primary_pt2 = neigh_pt2;
2250  }
2251 
2252  if (!primary_elem ||
2253  primary_elem != main_neigh ||
2254  primary_pt1 != main_pt1 ||
2255  primary_pt2 != main_pt2)
2256  continue;
2257  }
2258  else if (elem->is_face(n))
2259  {
2260  // If we have a one-element thick mesh,
2261  // use the ordering of the face node and its
2262  // periodic counterpart to determine what
2263  // gets constrained
2264  if (neigh == elem)
2265  {
2266  const Point neigh_pt =
2267  periodic->get_corresponding_pos(my_node);
2268  if (neigh_pt > my_node)
2269  continue;
2270  }
2271 
2272  // Otherwise:
2273  // Finer elements will get constrained in
2274  // terms of coarser ones, not the other way
2275  // around
2276  if ((neigh->level() > elem->level()) ||
2277 
2278  // For equal-level elements, the one with
2279  // higher id gets constrained in terms of
2280  // the one with lower id
2281  (neigh->level() == elem->level() &&
2282  neigh->id() > elem->id()))
2283  continue;
2284  }
2285 
2286  // If we made it here without hitting a continue
2287  // statement, then we're at a node whose dofs
2288  // should be constrained by this element's
2289  // calculations.
2290  const unsigned int n_comp =
2291  my_node.n_comp(sys_number, variable_number);
2292 
2293  for (unsigned int i=0; i != n_comp; ++i)
2294  my_constrained_dofs.insert
2295  (my_node.dof_number
2296  (sys_number, variable_number, i));
2297  }
2298 
2299  // FIXME: old code for disambiguating periodic BCs:
2300  // this is not threadsafe nor safe to run on a
2301  // non-serialized mesh.
2302  /*
2303  std::vector<bool> recursive_constraint(n_side_dofs, false);
2304 
2305  for (unsigned int is = 0; is != n_side_dofs; ++is)
2306  {
2307  const unsigned int i = neigh_side_dofs[is];
2308  const dof_id_type their_dof_g = neigh_dof_indices[i];
2309  libmesh_assert_not_equal_to (their_dof_g, DofObject::invalid_id);
2310 
2311  {
2312  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
2313 
2314  if (!dof_map.is_constrained_dof(their_dof_g))
2315  continue;
2316  }
2317 
2318  DofConstraintRow & their_constraint_row =
2319  constraints[their_dof_g].first;
2320 
2321  for (unsigned int js = 0; js != n_side_dofs; ++js)
2322  {
2323  const unsigned int j = my_side_dofs[js];
2324  const dof_id_type my_dof_g = my_dof_indices[j];
2325  libmesh_assert_not_equal_to (my_dof_g, DofObject::invalid_id);
2326 
2327  if (their_constraint_row.count(my_dof_g))
2328  recursive_constraint[js] = true;
2329  }
2330  }
2331  */
2332 
2333  for (unsigned int js = 0; js != n_side_dofs; ++js)
2334  {
2335  // FIXME: old code path
2336  // if (recursive_constraint[js])
2337  // continue;
2338 
2339  const unsigned int j = my_side_dofs[js];
2340  const dof_id_type my_dof_g = my_dof_indices[j];
2341  libmesh_assert_not_equal_to (my_dof_g, DofObject::invalid_id);
2342 
2343  // FIXME: new code path
2344  if (!my_constrained_dofs.count(my_dof_g))
2345  continue;
2346 
2347  DofConstraintRow * constraint_row;
2348 
2349  // we may be running constraint methods concurrently
2350  // on multiple threads, so we need a lock to
2351  // ensure that this constraint is "ours"
2352  {
2353  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
2354 
2355  if (dof_map.is_constrained_dof(my_dof_g))
2356  continue;
2357 
2358  constraint_row = &(constraints[my_dof_g]);
2359  libmesh_assert(constraint_row->empty());
2360  }
2361 
2362  for (unsigned int is = 0; is != n_side_dofs; ++is)
2363  {
2364  const unsigned int i = neigh_side_dofs[is];
2365  const dof_id_type their_dof_g = neigh_dof_indices[i];
2366  libmesh_assert_not_equal_to (their_dof_g, DofObject::invalid_id);
2367 
2368  // Periodic constraints should never be
2369  // self-constraints
2370  // libmesh_assert_not_equal_to (their_dof_g, my_dof_g);
2371 
2372  const Real their_dof_value = Ue[is](js);
2373 
2374  if (their_dof_g == my_dof_g)
2375  {
2376  libmesh_assert_less (std::abs(their_dof_value-1.), 1.e-5);
2377  for (unsigned int k = 0; k != n_side_dofs; ++k)
2378  libmesh_assert(k == is || std::abs(Ue[k](js)) < 1.e-5);
2379  continue;
2380  }
2381 
2382  if (std::abs(their_dof_value) < 10*TOLERANCE)
2383  continue;
2384 
2385  if(!periodic->has_transformation_matrix())
2386  {
2387  constraint_row->insert(std::make_pair(their_dof_g,
2388  their_dof_value));
2389  }
2390  else
2391  {
2392  // In this case the current variable is constrained in terms of other variables.
2393  // We assume that all variables in this constraint have the same FE type (this
2394  // is asserted below), and hence we can create the constraint row contribution
2395  // by multiplying their_dof_value by the corresponding row of the transformation
2396  // matrix.
2397 
2398  const std::set<unsigned int> & variables = periodic->get_variables();
2399  neigh_dof_indices_all_variables.resize(variables.size());
2400  unsigned int index = 0;
2401  for(unsigned int other_var : variables)
2402  {
2403  libmesh_assert_msg(base_fe_type == dof_map.variable_type(other_var), "FE types must match for all variables involved in constraint");
2404 
2405  Real var_weighting = periodic->get_transformation_matrix()(variable_number, other_var);
2406  constraint_row->insert(std::make_pair(neigh_dof_indices_all_variables[index][i],
2407  var_weighting*their_dof_value));
2408  index++;
2409  }
2410  }
2411 
2412  }
2413  }
2414  }
2415  // p refinement constraints:
2416  // constrain dofs shared between
2417  // active elements and neighbors with
2418  // lower polynomial degrees
2419 #ifdef LIBMESH_ENABLE_AMR
2420  const unsigned int min_p_level =
2421  neigh->min_p_level_by_neighbor(elem, elem->p_level());
2422  if (min_p_level < elem->p_level())
2423  {
2424  // Adaptive p refinement of non-hierarchic bases will
2425  // require more coding
2426  libmesh_assert(my_fe->is_hierarchic());
2427  dof_map.constrain_p_dofs(variable_number, elem,
2428  s, min_p_level);
2429  }
2430 #endif // #ifdef LIBMESH_ENABLE_AMR
2431  }
2432  }
2433  }
2434 }

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

◆ compute_periodic_node_constraints()

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

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

Definition at line 990 of file fe_abstract.C.

995 {
996  // Only bother if we truly have periodic boundaries
997  if (boundaries.empty())
998  return;
999 
1000  libmesh_assert(elem);
1001 
1002  // Only constrain active elements with this method
1003  if (!elem->active())
1004  return;
1005 
1006  const unsigned int Dim = elem->dim();
1007 
1008  const FEFamily mapping_family = FEMap::map_fe_type(*elem);
1009  const FEType fe_type(elem->default_order(), mapping_family);
1010 
1011  // Pull objects out of the loop to reduce heap operations
1012  std::vector<const Node *> my_nodes, neigh_nodes;
1013  std::unique_ptr<const Elem> my_side, neigh_side;
1014 
1015  // Look at the element faces. Check to see if we need to
1016  // build constraints.
1017  std::vector<boundary_id_type> bc_ids;
1018  for (auto s : elem->side_index_range())
1019  {
1020  if (elem->neighbor_ptr(s))
1021  continue;
1022 
1023  mesh.get_boundary_info().boundary_ids (elem, s, bc_ids);
1024  for (const auto & boundary_id : bc_ids)
1025  {
1026  const PeriodicBoundaryBase * periodic = boundaries.boundary(boundary_id);
1027  if (periodic)
1028  {
1029  libmesh_assert(point_locator);
1030 
1031  // Get pointers to the element's neighbor.
1032  const Elem * neigh = boundaries.neighbor(boundary_id, *point_locator, elem, s);
1033 
1034  // h refinement constraints:
1035  // constrain dofs shared between
1036  // this element and ones as coarse
1037  // as or coarser than this element.
1038  if (neigh->level() <= elem->level())
1039  {
1040  unsigned int s_neigh =
1041  mesh.get_boundary_info().side_with_boundary_id(neigh, periodic->pairedboundary);
1042  libmesh_assert_not_equal_to (s_neigh, libMesh::invalid_uint);
1043 
1044 #ifdef LIBMESH_ENABLE_AMR
1045  libmesh_assert(neigh->active());
1046 #endif // #ifdef LIBMESH_ENABLE_AMR
1047 
1048  elem->build_side_ptr(my_side, s);
1049  neigh->build_side_ptr(neigh_side, s_neigh);
1050 
1051  const unsigned int n_side_nodes = my_side->n_nodes();
1052 
1053  my_nodes.clear();
1054  my_nodes.reserve (n_side_nodes);
1055  neigh_nodes.clear();
1056  neigh_nodes.reserve (n_side_nodes);
1057 
1058  for (unsigned int n=0; n != n_side_nodes; ++n)
1059  my_nodes.push_back(my_side->node_ptr(n));
1060 
1061  for (unsigned int n=0; n != n_side_nodes; ++n)
1062  neigh_nodes.push_back(neigh_side->node_ptr(n));
1063 
1064  // Make sure we're not adding recursive constraints
1065  // due to the redundancy in the way we add periodic
1066  // boundary constraints, or adding constraints to
1067  // nodes that already have AMR constraints
1068  std::vector<bool> skip_constraint(n_side_nodes, false);
1069 
1070  for (unsigned int my_side_n=0;
1071  my_side_n < n_side_nodes;
1072  my_side_n++)
1073  {
1074  libmesh_assert_less (my_side_n, FEInterface::n_dofs(Dim-1, fe_type, my_side->type()));
1075 
1076  const Node * my_node = my_nodes[my_side_n];
1077 
1078  // Figure out where my node lies on their reference element.
1079  const Point neigh_point = periodic->get_corresponding_pos(*my_node);
1080 
1081  const Point mapped_point =
1082  FEMap::inverse_map(Dim-1, neigh_side.get(),
1083  neigh_point);
1084 
1085  // If we've already got a constraint on this
1086  // node, then the periodic constraint is
1087  // redundant
1088  {
1089  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
1090 
1091  if (constraints.count(my_node))
1092  {
1093  skip_constraint[my_side_n] = true;
1094  continue;
1095  }
1096  }
1097 
1098  // Compute the neighbors's side shape function values.
1099  for (unsigned int their_side_n=0;
1100  their_side_n < n_side_nodes;
1101  their_side_n++)
1102  {
1103  libmesh_assert_less (their_side_n, FEInterface::n_dofs(Dim-1, fe_type, neigh_side->type()));
1104 
1105  const Node * their_node = neigh_nodes[their_side_n];
1106 
1107  // If there's a constraint on an opposing node,
1108  // we need to see if it's constrained by
1109  // *our side* making any periodic constraint
1110  // on us recursive
1111  {
1112  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
1113 
1114  if (!constraints.count(their_node))
1115  continue;
1116 
1117  const NodeConstraintRow & their_constraint_row =
1118  constraints[their_node].first;
1119 
1120  for (unsigned int orig_side_n=0;
1121  orig_side_n < n_side_nodes;
1122  orig_side_n++)
1123  {
1124  libmesh_assert_less (orig_side_n, FEInterface::n_dofs(Dim-1, fe_type, my_side->type()));
1125 
1126  const Node * orig_node = my_nodes[orig_side_n];
1127 
1128  if (their_constraint_row.count(orig_node))
1129  skip_constraint[orig_side_n] = true;
1130  }
1131  }
1132  }
1133  }
1134  for (unsigned int my_side_n=0;
1135  my_side_n < n_side_nodes;
1136  my_side_n++)
1137  {
1138  libmesh_assert_less (my_side_n, FEInterface::n_dofs(Dim-1, fe_type, my_side->type()));
1139 
1140  if (skip_constraint[my_side_n])
1141  continue;
1142 
1143  const Node * my_node = my_nodes[my_side_n];
1144 
1145  // Figure out where my node lies on their reference element.
1146  const Point neigh_point = periodic->get_corresponding_pos(*my_node);
1147 
1148  // Figure out where my node lies on their reference element.
1149  const Point mapped_point =
1150  FEMap::inverse_map(Dim-1, neigh_side.get(),
1151  neigh_point);
1152 
1153  for (unsigned int their_side_n=0;
1154  their_side_n < n_side_nodes;
1155  their_side_n++)
1156  {
1157  libmesh_assert_less (their_side_n, FEInterface::n_dofs(Dim-1, fe_type, neigh_side->type()));
1158 
1159  const Node * their_node = neigh_nodes[their_side_n];
1160  libmesh_assert(their_node);
1161 
1162  const Real their_value = FEInterface::shape(Dim-1,
1163  fe_type,
1164  neigh_side->type(),
1165  their_side_n,
1166  mapped_point);
1167 
1168  // since we may be running this method concurrently
1169  // on multiple threads we need to acquire a lock
1170  // before modifying the shared constraint_row object.
1171  {
1172  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
1173 
1174  NodeConstraintRow & constraint_row =
1175  constraints[my_node].first;
1176 
1177  constraint_row.insert(std::make_pair(their_node,
1178  their_value));
1179  }
1180  }
1181  }
1182  }
1183  }
1184  }
1185  }
1186 }

References libMesh::Elem::active(), libMesh::PeriodicBoundaries::boundary(), libMesh::Elem::build_side_ptr(), libMesh::Elem::default_order(), libMesh::Elem::dim(), libMesh::FEAbstract::fe_type, libMesh::PeriodicBoundaryBase::get_corresponding_pos(), libMesh::invalid_uint, 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::PeriodicBoundaryBase::pairedboundary, libMesh::Real, libMesh::FEInterface::shape(), libMesh::Elem::side_index_range(), and libMesh::Threads::spin_mtx.

◆ compute_proj_constraints()

template<typename OutputType >
void libMesh::FEGenericBase< OutputType >::compute_proj_constraints ( DofConstraints &  constraints,
DofMap &  dof_map,
const unsigned int  variable_number,
const Elem *  elem 
)
static

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

Definition at line 1396 of file fe_base.C.

1400 {
1401  libmesh_assert(elem);
1402 
1403  const unsigned int Dim = elem->dim();
1404 
1405  // Only constrain elements in 2,3D.
1406  if (Dim == 1)
1407  return;
1408 
1409  // Only constrain active elements with this method
1410  if (!elem->active())
1411  return;
1412 
1413  const Variable & var = dof_map.variable(variable_number);
1414  const FEType & base_fe_type = var.type();
1415 
1416  // Construct FE objects for this element and its neighbors.
1417  std::unique_ptr<FEGenericBase<OutputShape>> my_fe
1418  (FEGenericBase<OutputShape>::build(Dim, base_fe_type));
1419  const FEContinuity cont = my_fe->get_continuity();
1420 
1421  // We don't need to constrain discontinuous elements
1422  if (cont == DISCONTINUOUS)
1423  return;
1424  libmesh_assert (cont == C_ZERO || cont == C_ONE);
1425 
1426  std::unique_ptr<FEGenericBase<OutputShape>> neigh_fe
1427  (FEGenericBase<OutputShape>::build(Dim, base_fe_type));
1428 
1429  QGauss my_qface(Dim-1, base_fe_type.default_quadrature_order());
1430  my_fe->attach_quadrature_rule (&my_qface);
1431  std::vector<Point> neigh_qface;
1432 
1433  const std::vector<Real> & JxW = my_fe->get_JxW();
1434  const std::vector<Point> & q_point = my_fe->get_xyz();
1435  const std::vector<std::vector<OutputShape>> & phi = my_fe->get_phi();
1436  const std::vector<std::vector<OutputShape>> & neigh_phi =
1437  neigh_fe->get_phi();
1438  const std::vector<Point> * face_normals = nullptr;
1439  const std::vector<std::vector<OutputGradient>> * dphi = nullptr;
1440  const std::vector<std::vector<OutputGradient>> * neigh_dphi = nullptr;
1441 
1442  std::vector<dof_id_type> my_dof_indices, neigh_dof_indices;
1443  std::vector<unsigned int> my_side_dofs, neigh_side_dofs;
1444 
1445  if (cont != C_ZERO)
1446  {
1447  const std::vector<Point> & ref_face_normals =
1448  my_fe->get_normals();
1449  face_normals = &ref_face_normals;
1450  const std::vector<std::vector<OutputGradient>> & ref_dphi =
1451  my_fe->get_dphi();
1452  dphi = &ref_dphi;
1453  const std::vector<std::vector<OutputGradient>> & ref_neigh_dphi =
1454  neigh_fe->get_dphi();
1455  neigh_dphi = &ref_neigh_dphi;
1456  }
1457 
1458  DenseMatrix<Real> Ke;
1459  DenseVector<Real> Fe;
1460  std::vector<DenseVector<Real>> Ue;
1461 
1462  // Look at the element faces. Check to see if we need to
1463  // build constraints.
1464  for (auto s : elem->side_index_range())
1465  {
1466  // Get pointers to the element's neighbor.
1467  const Elem * neigh = elem->neighbor_ptr(s);
1468 
1469  if (!neigh)
1470  continue;
1471 
1472  if (!var.active_on_subdomain(neigh->subdomain_id()))
1473  continue;
1474 
1475  // h refinement constraints:
1476  // constrain dofs shared between
1477  // this element and ones coarser
1478  // than this element.
1479  if (neigh->level() < elem->level())
1480  {
1481  unsigned int s_neigh = neigh->which_neighbor_am_i(elem);
1482  libmesh_assert_less (s_neigh, neigh->n_neighbors());
1483 
1484  // Find the minimum p level; we build the h constraint
1485  // matrix with this and then constrain away all higher p
1486  // DoFs.
1487  libmesh_assert(neigh->active());
1488  const unsigned int min_p_level =
1489  std::min(elem->p_level(), neigh->p_level());
1490 
1491  // we may need to make the FE objects reinit with the
1492  // minimum shared p_level
1493  const unsigned int old_elem_level = elem->p_level();
1494  if (elem->p_level() != min_p_level)
1495  my_fe->set_fe_order(my_fe->get_fe_type().order.get_order() - old_elem_level + min_p_level);
1496  const unsigned int old_neigh_level = neigh->p_level();
1497  if (old_neigh_level != min_p_level)
1498  neigh_fe->set_fe_order(neigh_fe->get_fe_type().order.get_order() - old_neigh_level + min_p_level);
1499 
1500  my_fe->reinit(elem, s);
1501 
1502  // This function gets called element-by-element, so there
1503  // will be a lot of memory allocation going on. We can
1504  // at least minimize this for the case of the dof indices
1505  // by efficiently preallocating the requisite storage.
1506  // n_nodes is not necessarily n_dofs, but it is better
1507  // than nothing!
1508  my_dof_indices.reserve (elem->n_nodes());
1509  neigh_dof_indices.reserve (neigh->n_nodes());
1510 
1511  dof_map.dof_indices (elem, my_dof_indices,
1512  variable_number,
1513  min_p_level);
1514  dof_map.dof_indices (neigh, neigh_dof_indices,
1515  variable_number,
1516  min_p_level);
1517 
1518  const unsigned int n_qp = my_qface.n_points();
1519 
1520  FEMap::inverse_map (Dim, neigh, q_point, neigh_qface);
1521 
1522  neigh_fe->reinit(neigh, &neigh_qface);
1523 
1524  // We're only concerned with DOFs whose values (and/or first
1525  // derivatives for C1 elements) are supported on side nodes
1526  FEType elem_fe_type = base_fe_type;
1527  if (old_elem_level != min_p_level)
1528  elem_fe_type.order = base_fe_type.order.get_order() - old_elem_level + min_p_level;
1529  FEType neigh_fe_type = base_fe_type;
1530  if (old_neigh_level != min_p_level)
1531  neigh_fe_type.order = base_fe_type.order.get_order() - old_neigh_level + min_p_level;
1532  FEInterface::dofs_on_side(elem, Dim, elem_fe_type, s, my_side_dofs);
1533  FEInterface::dofs_on_side(neigh, Dim, neigh_fe_type, s_neigh, neigh_side_dofs);
1534 
1535  const unsigned int n_side_dofs =
1536  cast_int<unsigned int>(my_side_dofs.size());
1537  libmesh_assert_equal_to (n_side_dofs, neigh_side_dofs.size());
1538 
1539 #ifndef NDEBUG
1540  for (auto i : my_side_dofs)
1541  libmesh_assert_less(i, my_dof_indices.size());
1542  for (auto i : neigh_side_dofs)
1543  libmesh_assert_less(i, neigh_dof_indices.size());
1544 #endif
1545 
1546  Ke.resize (n_side_dofs, n_side_dofs);
1547  Ue.resize(n_side_dofs);
1548 
1549  // Form the projection matrix, (inner product of fine basis
1550  // functions against fine test functions)
1551  for (unsigned int is = 0; is != n_side_dofs; ++is)
1552  {
1553  const unsigned int i = my_side_dofs[is];
1554  for (unsigned int js = 0; js != n_side_dofs; ++js)
1555  {
1556  const unsigned int j = my_side_dofs[js];
1557  for (unsigned int qp = 0; qp != n_qp; ++qp)
1558  {
1559  Ke(is,js) += JxW[qp] * TensorTools::inner_product(phi[i][qp], phi[j][qp]);
1560  if (cont != C_ZERO)
1561  Ke(is,js) += JxW[qp] *
1562  TensorTools::inner_product((*dphi)[i][qp] *
1563  (*face_normals)[qp],
1564  (*dphi)[j][qp] *
1565  (*face_normals)[qp]);
1566  }
1567  }
1568  }
1569 
1570  // Form the right hand sides, (inner product of coarse basis
1571  // functions against fine test functions)
1572  for (unsigned int is = 0; is != n_side_dofs; ++is)
1573  {
1574  const unsigned int i = neigh_side_dofs[is];
1575  Fe.resize (n_side_dofs);
1576  for (unsigned int js = 0; js != n_side_dofs; ++js)
1577  {
1578  const unsigned int j = my_side_dofs[js];
1579  for (unsigned int qp = 0; qp != n_qp; ++qp)
1580  {
1581  Fe(js) += JxW[qp] *
1582  TensorTools::inner_product(neigh_phi[i][qp],
1583  phi[j][qp]);
1584  if (cont != C_ZERO)
1585  Fe(js) += JxW[qp] *
1586  TensorTools::inner_product((*neigh_dphi)[i][qp] *
1587  (*face_normals)[qp],
1588  (*dphi)[j][qp] *
1589  (*face_normals)[qp]);
1590  }
1591  }
1592  Ke.cholesky_solve(Fe, Ue[is]);
1593  }
1594 
1595  for (unsigned int js = 0; js != n_side_dofs; ++js)
1596  {
1597  const unsigned int j = my_side_dofs[js];
1598  const dof_id_type my_dof_g = my_dof_indices[j];
1599  libmesh_assert_not_equal_to (my_dof_g, DofObject::invalid_id);
1600 
1601  // Hunt for "constraining against myself" cases before
1602  // we bother creating a constraint row
1603  bool self_constraint = false;
1604  for (unsigned int is = 0; is != n_side_dofs; ++is)
1605  {
1606  const unsigned int i = neigh_side_dofs[is];
1607  const dof_id_type their_dof_g = neigh_dof_indices[i];
1608  libmesh_assert_not_equal_to (their_dof_g, DofObject::invalid_id);
1609 
1610  if (their_dof_g == my_dof_g)
1611  {
1612 #ifndef NDEBUG
1613  const Real their_dof_value = Ue[is](js);
1614  libmesh_assert_less (std::abs(their_dof_value-1.),
1615  10*TOLERANCE);
1616 
1617  for (unsigned int k = 0; k != n_side_dofs; ++k)
1618  libmesh_assert(k == is ||
1619  std::abs(Ue[k](js)) <
1620  10*TOLERANCE);
1621 #endif
1622 
1623  self_constraint = true;
1624  break;
1625  }
1626  }
1627 
1628  if (self_constraint)
1629  continue;
1630 
1631  DofConstraintRow * constraint_row;
1632 
1633  // we may be running constraint methods concurrently
1634  // on multiple threads, so we need a lock to
1635  // ensure that this constraint is "ours"
1636  {
1637  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
1638 
1639  if (dof_map.is_constrained_dof(my_dof_g))
1640  continue;
1641 
1642  constraint_row = &(constraints[my_dof_g]);
1643  libmesh_assert(constraint_row->empty());
1644  }
1645 
1646  for (unsigned int is = 0; is != n_side_dofs; ++is)
1647  {
1648  const unsigned int i = neigh_side_dofs[is];
1649  const dof_id_type their_dof_g = neigh_dof_indices[i];
1650  libmesh_assert_not_equal_to (their_dof_g, DofObject::invalid_id);
1651  libmesh_assert_not_equal_to (their_dof_g, my_dof_g);
1652 
1653  const Real their_dof_value = Ue[is](js);
1654 
1655  if (std::abs(their_dof_value) < 10*TOLERANCE)
1656  continue;
1657 
1658  constraint_row->insert(std::make_pair(their_dof_g,
1659  their_dof_value));
1660  }
1661  }
1662 
1663  my_fe->set_fe_order(my_fe->get_fe_type().order.get_order() + old_elem_level - min_p_level);
1664  neigh_fe->set_fe_order(neigh_fe->get_fe_type().order.get_order() + old_neigh_level - min_p_level);
1665  }
1666 
1667  // p refinement constraints:
1668  // constrain dofs shared between
1669  // active elements and neighbors with
1670  // lower polynomial degrees
1671  const unsigned int min_p_level =
1672  neigh->min_p_level_by_neighbor(elem, elem->p_level());
1673  if (min_p_level < elem->p_level())
1674  {
1675  // Adaptive p refinement of non-hierarchic bases will
1676  // require more coding
1677  libmesh_assert(my_fe->is_hierarchic());
1678  dof_map.constrain_p_dofs(variable_number, elem,
1679  s, min_p_level);
1680  }
1681  }
1682 }

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

◆ compute_shape_functions()

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

After having updated the jacobian and the transformation from local to global coordinates in FEAbstract::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 697 of file fe_base.C.

699 {
700  //-------------------------------------------------------------------------
701  // Compute the shape function values (and derivatives)
702  // at the Quadrature points. Note that the actual values
703  // have already been computed via init_shape_functions
704 
705  // Start logging the shape function computation
706  LOG_SCOPE("compute_shape_functions()", "FE");
707 
708  this->determine_calculations();
709 
710  if (calculate_phi)
711  this->_fe_trans->map_phi(this->dim, elem, qp, (*this), this->phi);
712 
713  if (calculate_dphi)
714  this->_fe_trans->map_dphi(this->dim, elem, qp, (*this), this->dphi,
715  this->dphidx, this->dphidy, this->dphidz);
716 
717 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
718  if (calculate_d2phi)
719  this->_fe_trans->map_d2phi(this->dim, qp, (*this), this->d2phi,
720  this->d2phidx2, this->d2phidxdy, this->d2phidxdz,
721  this->d2phidy2, this->d2phidydz, this->d2phidz2);
722 #endif //LIBMESH_ENABLE_SECOND_DERIVATIVES
723 
724  // Only compute curl for vector-valued elements
725  if (calculate_curl_phi && TypesEqual<OutputType,RealGradient>::value)
726  this->_fe_trans->map_curl(this->dim, elem, qp, (*this), this->curl_phi);
727 
728  // Only compute div for vector-valued elements
729  if (calculate_div_phi && TypesEqual<OutputType,RealGradient>::value)
730  this->_fe_trans->map_div(this->dim, elem, qp, (*this), this->div_phi);
731 }

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

757 {
758  this->calculations_started = true;
759 
760  // If the user forgot to request anything, we'll be safe and
761  // calculate everything:
762 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
763  if (!this->calculate_phi && !this->calculate_dphi &&
764  !this->calculate_d2phi && !this->calculate_curl_phi &&
765  !this->calculate_div_phi && !this->calculate_map)
766  {
767  this->calculate_phi = this->calculate_dphi = this->calculate_d2phi = this->calculate_dphiref = true;
768  if (FEInterface::field_type(fe_type.family) == TYPE_VECTOR)
769  {
770  this->calculate_curl_phi = true;
771  this->calculate_div_phi = true;
772  }
773  }
774 #else
775  if (!this->calculate_phi && !this->calculate_dphi &&
776  !this->calculate_curl_phi && !this->calculate_div_phi &&
777  !this->calculate_map)
778  {
779  this->calculate_phi = this->calculate_dphi = this->calculate_dphiref = true;
780  if (FEInterface::field_type(fe_type.family) == TYPE_VECTOR)
781  {
782  this->calculate_curl_phi = true;
783  this->calculate_div_phi = true;
784  }
785  }
786 #endif // LIBMESH_ENABLE_SECOND_DERIVATIVES
787 
788  // Request whichever terms are necessary from the FEMap
789  if (this->calculate_phi)
790  this->_fe_trans->init_map_phi(*this);
791 
792  if (this->calculate_dphiref)
793  this->_fe_trans->init_map_dphi(*this);
794 
795 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
796  if (this->calculate_d2phi)
797  this->_fe_trans->init_map_d2phi(*this);
798 #endif //LIBMESH_ENABLE_SECOND_DERIVATIVES
799 }

◆ disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )
staticinherited

Definition at line 106 of file reference_counter.C.

107 {
108  _enable_print_counter = false;
109  return;
110 }

References libMesh::ReferenceCounter::_enable_print_counter.

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

◆ 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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 >.

◆ 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 100 of file reference_counter.C.

101 {
102  _enable_print_counter = true;
103  return;
104 }

References libMesh::ReferenceCounter::_enable_print_counter.

◆ get_continuity()

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

Implemented in libMesh::InfFE< Dim, T_radial, T_map >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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>
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 222 of file fe_base.h.

223  { libmesh_assert(!calculations_started || calculate_curl_phi);
224  calculate_curl_phi = calculate_dphiref = true; return curl_phi; }

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

◆ get_curvatures()

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

Definition at line 387 of file fe_abstract.h.

388  { calculate_map = true; return this->_fe_map->get_curvatures();}

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

◆ get_d2phi()

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

Definition at line 288 of file fe_base.h.

289  { libmesh_assert(!calculations_started || calculate_d2phi);
290  calculate_d2phi = calculate_dphiref = true; return d2phi; }

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

◆ get_d2phideta2()

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

Definition at line 368 of file fe_base.h.

369  { libmesh_assert(!calculations_started || calculate_d2phi);
370  calculate_d2phi = calculate_dphiref = true; return d2phideta2; }

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

◆ get_d2phidetadzeta()

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

Definition at line 376 of file fe_base.h.

377  { libmesh_assert(!calculations_started || calculate_d2phi);
378  calculate_d2phi = calculate_dphiref = true; return d2phidetadzeta; }

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

◆ get_d2phidx2()

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

Definition at line 296 of file fe_base.h.

297  { libmesh_assert(!calculations_started || calculate_d2phi);
298  calculate_d2phi = calculate_dphiref = true; return d2phidx2; }

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

305  { libmesh_assert(!calculations_started || calculate_d2phi);
306  calculate_d2phi = calculate_dphiref = true; return d2phidxdy; }

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

313  { libmesh_assert(!calculations_started || calculate_d2phi);
314  calculate_d2phi = calculate_dphiref = true; return d2phidxdz; }

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

345  { libmesh_assert(!calculations_started || calculate_d2phi);
346  calculate_d2phi = calculate_dphiref = true; return d2phidxi2; }

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

◆ get_d2phidxideta()

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

Definition at line 352 of file fe_base.h.

353  { libmesh_assert(!calculations_started || calculate_d2phi);
354  calculate_d2phi = calculate_dphiref = true; return d2phidxideta; }

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

◆ get_d2phidxidzeta()

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

Definition at line 360 of file fe_base.h.

361  { libmesh_assert(!calculations_started || calculate_d2phi);
362  calculate_d2phi = calculate_dphiref = true; return d2phidxidzeta; }

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

◆ get_d2phidy2()

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

Definition at line 320 of file fe_base.h.

321  { libmesh_assert(!calculations_started || calculate_d2phi);
322  calculate_d2phi = calculate_dphiref = true; return d2phidy2; }

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

329  { libmesh_assert(!calculations_started || calculate_d2phi);
330  calculate_d2phi = calculate_dphiref = true; return d2phidydz; }

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

337  { libmesh_assert(!calculations_started || calculate_d2phi);
338  calculate_d2phi = calculate_dphiref = true; return d2phidz2; }

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

385  { libmesh_assert(!calculations_started || calculate_d2phi);
386  calculate_d2phi = calculate_dphiref = true; return d2phidzeta2; }

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

◆ get_d2xyzdeta2()

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

Definition at line 279 of file fe_abstract.h.

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

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

◆ get_d2xyzdetadzeta()

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

Definition at line 303 of file fe_abstract.h.

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

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

◆ get_d2xyzdxi2()

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

Definition at line 273 of file fe_abstract.h.

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

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

◆ get_d2xyzdxideta()

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

Definition at line 291 of file fe_abstract.h.

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

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

◆ get_d2xyzdxidzeta()

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

Definition at line 297 of file fe_abstract.h.

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

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

◆ get_d2xyzdzeta2()

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

Definition at line 285 of file fe_abstract.h.

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

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

◆ get_detadx()

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

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

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

◆ get_detady()

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

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

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

◆ get_detadz()

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

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

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

◆ get_dim()

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

Definition at line 230 of file fe_abstract.h.

231  { return dim; }

References libMesh::FEAbstract::dim.

◆ get_div_phi()

template<typename OutputType>
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 230 of file fe_base.h.

231  { libmesh_assert(!calculations_started || calculate_div_phi);
232  calculate_div_phi = calculate_dphiref = true; return div_phi; }

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

◆ get_dphase()

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

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

Definition at line 402 of file fe_base.h.

403  { return dphase; }

Referenced by assemble_SchroedingerEquation().

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

215  { libmesh_assert(!calculations_started || calculate_dphi);
216  calculate_dphi = calculate_dphiref = true; return dphi; }

Referenced by libMesh::ExactSolution::_compute_error(), assemble_SchroedingerEquation(), assembly_with_dg_fem_context(), libMesh::KellyErrorEstimator::boundary_side_integration(), libMesh::System::calculate_norm(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubProjector::construct_projection(), NavierSystem::element_constraint(), CoupledSystem::element_constraint(), NavierSystem::element_time_derivative(), SolidSystem::element_time_derivative(), PoissonSystem::element_time_derivative(), LaplaceSystem::element_time_derivative(), ElasticitySystem::element_time_derivative(), CoupledSystem::element_time_derivative(), libMesh::OldSolutionCoefs< Output, point_output >::eval_at_point(), libMesh::ExactErrorEstimator::find_squared_element_error(), libMesh::FEMContext::fixed_point_gradient(), libMesh::OldSolutionBase< Output, point_output >::get_shape_outputs(), NavierSystem::init_context(), SolidSystem::init_context(), LaplaceSystem::init_context(), PoissonSystem::init_context(), ElasticitySystem::init_context(), CoupledSystem::init_context(), libMesh::ParsedFEMFunction< T >::init_context(), libMesh::KellyErrorEstimator::init_context(), ElasticityRBConstruction::init_context(), libMesh::FEMContext::interior_gradients(), libMesh::KellyErrorEstimator::internal_side_integration(), libMesh::FEMContext::point_gradient(), RationalMapTest< elem_type >::setUp(), FETest< order, family, elem_type >::setUp(), libMesh::FEMContext::side_gradient(), libMesh::FEMContext::side_gradients(), LaplaceSystem::side_qoi_derivative(), libMesh::FEMContext::some_gradient(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::SubFunctor(), and FETest< order, family, elem_type >::testGradU().

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

271  { libmesh_assert(!calculations_started || calculate_dphiref);
272  calculate_dphiref = true; return dphideta; }

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

◆ get_dphidx()

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

Definition at line 238 of file fe_base.h.

239  { libmesh_assert(!calculations_started || calculate_dphi);
240  calculate_dphi = calculate_dphiref = true; return dphidx; }

Referenced by RationalMapTest< elem_type >::setUp(), FETest< order, family, elem_type >::setUp(), and FETest< order, family, elem_type >::testGradUComp().

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

263  { libmesh_assert(!calculations_started || calculate_dphiref);
264  calculate_dphiref = true; return dphidxi; }

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

◆ get_dphidy()

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

Definition at line 246 of file fe_base.h.

247  { libmesh_assert(!calculations_started || calculate_dphi);
248  calculate_dphi = calculate_dphiref = true; return dphidy; }

Referenced by RationalMapTest< elem_type >::setUp(), FETest< order, family, elem_type >::setUp(), and FETest< order, family, elem_type >::testGradUComp().

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

255  { libmesh_assert(!calculations_started || calculate_dphi);
256  calculate_dphi = calculate_dphiref = true; return dphidz; }

Referenced by RationalMapTest< elem_type >::setUp(), FETest< order, family, elem_type >::setUp(), and FETest< order, family, elem_type >::testGradUComp().

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

279  { libmesh_assert(!calculations_started || calculate_dphiref);
280  calculate_dphiref = true; return dphidzeta; }

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

◆ get_dxidx()

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

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

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

◆ get_dxidy()

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

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

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

◆ get_dxidz()

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

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

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

◆ get_dxyzdeta()

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

Definition at line 258 of file fe_abstract.h.

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

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

◆ get_dxyzdxi()

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

Definition at line 251 of file fe_abstract.h.

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

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

◆ get_dxyzdzeta()

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

Definition at line 265 of file fe_abstract.h.

266  { return _fe_map->get_dxyzdzeta(); }

References libMesh::FEAbstract::_fe_map.

◆ get_dzetadx()

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

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

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

◆ get_dzetady()

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

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

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

◆ get_dzetadz()

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

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

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

◆ get_family()

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

Definition at line 453 of file fe_abstract.h.

453 { return fe_type.family; }

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

◆ get_fe_map() [1/2]

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

Definition at line 459 of file fe_abstract.h.

459 { return *_fe_map.get(); }

References libMesh::FEAbstract::_fe_map.

◆ get_fe_map() [2/2]

const FEMap& libMesh::FEAbstract::get_fe_map ( ) const
inlineinherited
Returns
The mapping object

Definition at line 458 of file fe_abstract.h.

458 { return *_fe_map.get(); }

References libMesh::FEAbstract::_fe_map.

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

◆ get_fe_type()

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

Definition at line 427 of file fe_abstract.h.

427 { return fe_type; }

References libMesh::FEAbstract::fe_type.

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

◆ get_info()

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

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

48 {
49 #if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
50 
51  std::ostringstream oss;
52 
53  oss << '\n'
54  << " ---------------------------------------------------------------------------- \n"
55  << "| Reference count information |\n"
56  << " ---------------------------------------------------------------------------- \n";
57 
58  for (const auto & pr : _counts)
59  {
60  const std::string name(pr.first);
61  const unsigned int creations = pr.second.first;
62  const unsigned int destructions = pr.second.second;
63 
64  oss << "| " << name << " reference count information:\n"
65  << "| Creations: " << creations << '\n'
66  << "| Destructions: " << destructions << '\n';
67  }
68 
69  oss << " ---------------------------------------------------------------------------- \n";
70 
71  return oss.str();
72 
73 #else
74 
75  return "";
76 
77 #endif
78 }

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

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

◆ get_JxW()

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

Definition at line 244 of file fe_abstract.h.

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

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

Referenced by libMesh::ExactSolution::_compute_error(), assemble_SchroedingerEquation(), assembly_with_dg_fem_context(), libMesh::DiscontinuityMeasure::boundary_side_integration(), libMesh::KellyErrorEstimator::boundary_side_integration(), libMesh::System::calculate_norm(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubProjector::construct_projection(), NavierSystem::element_constraint(), CoupledSystem::element_constraint(), PoissonSystem::element_postprocess(), LaplaceSystem::element_postprocess(), LaplaceQoI::element_qoi(), LaplaceQoI::element_qoi_derivative(), LaplaceSystem::element_qoi_derivative(), HeatSystem::element_qoi_derivative(), NavierSystem::element_time_derivative(), SolidSystem::element_time_derivative(), PoissonSystem::element_time_derivative(), LaplaceSystem::element_time_derivative(), CurlCurlSystem::element_time_derivative(), ElasticitySystem::element_time_derivative(), CoupledSystem::element_time_derivative(), libMesh::ExactErrorEstimator::find_squared_element_error(), LaplaceQoI::init_context(), NavierSystem::init_context(), SolidSystem::init_context(), PoissonSystem::init_context(), LaplaceSystem::init_context(), CurlCurlSystem::init_context(), ElasticitySystem::init_context(), CoupledSystem::init_context(), ElasticityRBConstruction::init_context(), libMesh::FEMSystem::init_context(), libMesh::RBEIMConstruction::init_context_with_sys(), libMesh::LaplacianErrorEstimator::internal_side_integration(), libMesh::DiscontinuityMeasure::internal_side_integration(), libMesh::KellyErrorEstimator::internal_side_integration(), NavierSystem::mass_residual(), ElasticitySystem::mass_residual(), libMesh::FEMPhysics::mass_residual(), LaplaceSystem::side_constraint(), LaplaceSystem::side_postprocess(), CoupledSystemQoI::side_qoi(), CoupledSystemQoI::side_qoi_derivative(), LaplaceSystem::side_qoi_derivative(), SolidSystem::side_time_derivative(), CurlCurlSystem::side_time_derivative(), ElasticitySystem::side_time_derivative(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::SubFunctor(), and libMesh::RBEIMConstruction::truth_solve().

◆ get_normals()

const std::vector<Point>& libMesh::FEAbstract::get_normals ( ) const
inlineinherited
Returns
The outward pointing normal vectors for face integration.

Definition at line 380 of file fe_abstract.h.

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

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

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

◆ get_order()

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

Definition at line 432 of file fe_abstract.h.

432 { return static_cast<Order>(fe_type.order + _p_level); }

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

◆ get_p_level()

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

Definition at line 422 of file fe_abstract.h.

422 { return _p_level; }

References libMesh::FEAbstract::_p_level.

◆ get_phi()

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

Definition at line 206 of file fe_base.h.

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

Referenced by libMesh::ExactSolution::_compute_error(), assemble_SchroedingerEquation(), assembly_with_dg_fem_context(), libMesh::DiscontinuityMeasure::boundary_side_integration(), libMesh::System::calculate_norm(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubProjector::construct_projection(), NavierSystem::element_constraint(), CoupledSystem::element_constraint(), LaplaceQoI::element_qoi_derivative(), LaplaceSystem::element_qoi_derivative(), HeatSystem::element_qoi_derivative(), NavierSystem::element_time_derivative(), PoissonSystem::element_time_derivative(), CurlCurlSystem::element_time_derivative(), ElasticitySystem::element_time_derivative(), CoupledSystem::element_time_derivative(), libMesh::OldSolutionCoefs< Output, point_output >::eval_at_point(), libMesh::RBEIMAssembly::evaluate_basis_function(), libMesh::ExactErrorEstimator::find_squared_element_error(), libMesh::FEMContext::fixed_point_value(), libMesh::OldSolutionBase< Output, point_output >::get_shape_outputs(), LaplaceQoI::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(), libMesh::ParsedFEMFunction< T >::init_context(), ElasticityRBConstruction::init_context(), libMesh::FEMSystem::init_context(), libMesh::RBEIMConstruction::init_context_with_sys(), libMesh::FEMContext::interior_values(), libMesh::DiscontinuityMeasure::internal_side_integration(), NavierSystem::mass_residual(), ElasticitySystem::mass_residual(), libMesh::FEMPhysics::mass_residual(), libMesh::FEMContext::point_value(), RationalMapTest< elem_type >::setUp(), FETest< order, family, elem_type >::setUp(), LaplaceSystem::side_constraint(), CoupledSystemQoI::side_qoi_derivative(), SolidSystem::side_time_derivative(), CurlCurlSystem::side_time_derivative(), ElasticitySystem::side_time_derivative(), libMesh::FEMContext::side_values(), libMesh::FEMContext::some_value(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::SubFunctor(), SlitMeshRefinedSystemTest::testRestart(), SlitMeshRefinedSystemTest::testSystem(), FETest< order, family, elem_type >::testU(), and libMesh::RBEIMConstruction::truth_solve().

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

309 {
310  switch(itemType)
311  {
312  case EDGE2:
313  {
314  nodes.resize(2);
315  nodes[0] = Point (-1.,0.,0.);
316  nodes[1] = Point (1.,0.,0.);
317  return;
318  }
319  case EDGE3:
320  {
321  nodes.resize(3);
322  nodes[0] = Point (-1.,0.,0.);
323  nodes[1] = Point (1.,0.,0.);
324  nodes[2] = Point (0.,0.,0.);
325  return;
326  }
327  case TRI3:
328  case TRISHELL3:
329  {
330  nodes.resize(3);
331  nodes[0] = Point (0.,0.,0.);
332  nodes[1] = Point (1.,0.,0.);
333  nodes[2] = Point (0.,1.,0.);
334  return;
335  }
336  case TRI6:
337  {
338  nodes.resize(6);
339  nodes[0] = Point (0.,0.,0.);
340  nodes[1] = Point (1.,0.,0.);
341  nodes[2] = Point (0.,1.,0.);
342  nodes[3] = Point (.5,0.,0.);
343  nodes[4] = Point (.5,.5,0.);
344  nodes[5] = Point (0.,.5,0.);
345  return;
346  }
347  case QUAD4:
348  case QUADSHELL4:
349  {
350  nodes.resize(4);
351  nodes[0] = Point (-1.,-1.,0.);
352  nodes[1] = Point (1.,-1.,0.);
353  nodes[2] = Point (1.,1.,0.);
354  nodes[3] = Point (-1.,1.,0.);
355  return;
356  }
357  case QUAD8:
358  case QUADSHELL8:
359  {
360  nodes.resize(8);
361  nodes[0] = Point (-1.,-1.,0.);
362  nodes[1] = Point (1.,-1.,0.);
363  nodes[2] = Point (1.,1.,0.);
364  nodes[3] = Point (-1.,1.,0.);
365  nodes[4] = Point (0.,-1.,0.);
366  nodes[5] = Point (1.,0.,0.);
367  nodes[6] = Point (0.,1.,0.);
368  nodes[7] = Point (-1.,0.,0.);
369  return;
370  }
371  case QUAD9:
372  {
373  nodes.resize(9);
374  nodes[0] = Point (-1.,-1.,0.);
375  nodes[1] = Point (1.,-1.,0.);
376  nodes[2] = Point (1.,1.,0.);
377  nodes[3] = Point (-1.,1.,0.);
378  nodes[4] = Point (0.,-1.,0.);
379  nodes[5] = Point (1.,0.,0.);
380  nodes[6] = Point (0.,1.,0.);
381  nodes[7] = Point (-1.,0.,0.);
382  nodes[8] = Point (0.,0.,0.);
383  return;
384  }
385  case TET4:
386  {
387  nodes.resize(4);
388  nodes[0] = Point (0.,0.,0.);
389  nodes[1] = Point (1.,0.,0.);
390  nodes[2] = Point (0.,1.,0.);
391  nodes[3] = Point (0.,0.,1.);
392  return;
393  }
394  case TET10:
395  {
396  nodes.resize(10);
397  nodes[0] = Point (0.,0.,0.);
398  nodes[1] = Point (1.,0.,0.);
399  nodes[2] = Point (0.,1.,0.);
400  nodes[3] = Point (0.,0.,1.);
401  nodes[4] = Point (.5,0.,0.);
402  nodes[5] = Point (.5,.5,0.);
403  nodes[6] = Point (0.,.5,0.);
404  nodes[7] = Point (0.,0.,.5);
405  nodes[8] = Point (.5,0.,.5);
406  nodes[9] = Point (0.,.5,.5);
407  return;
408  }
409  case HEX8:
410  {
411  nodes.resize(8);
412  nodes[0] = Point (-1.,-1.,-1.);
413  nodes[1] = Point (1.,-1.,-1.);
414  nodes[2] = Point (1.,1.,-1.);
415  nodes[3] = Point (-1.,1.,-1.);
416  nodes[4] = Point (-1.,-1.,1.);
417  nodes[5] = Point (1.,-1.,1.);
418  nodes[6] = Point (1.,1.,1.);
419  nodes[7] = Point (-1.,1.,1.);
420  return;
421  }
422  case HEX20:
423  {
424  nodes.resize(20);
425  nodes[0] = Point (-1.,-1.,-1.);
426  nodes[1] = Point (1.,-1.,-1.);
427  nodes[2] = Point (1.,1.,-1.);
428  nodes[3] = Point (-1.,1.,-1.);
429  nodes[4] = Point (-1.,-1.,1.);
430  nodes[5] = Point (1.,-1.,1.);
431  nodes[6] = Point (1.,1.,1.);
432  nodes[7] = Point (-1.,1.,1.);
433  nodes[8] = Point (0.,-1.,-1.);
434  nodes[9] = Point (1.,0.,-1.);
435  nodes[10] = Point (0.,1.,-1.);
436  nodes[11] = Point (-1.,0.,-1.);
437  nodes[12] = Point (-1.,-1.,0.);
438  nodes[13] = Point (1.,-1.,0.);
439  nodes[14] = Point (1.,1.,0.);
440  nodes[15] = Point (-1.,1.,0.);
441  nodes[16] = Point (0.,-1.,1.);
442  nodes[17] = Point (1.,0.,1.);
443  nodes[18] = Point (0.,1.,1.);
444  nodes[19] = Point (-1.,0.,1.);
445  return;
446  }
447  case HEX27:
448  {
449  nodes.resize(27);
450  nodes[0] = Point (-1.,-1.,-1.);
451  nodes[1] = Point (1.,-1.,-1.);
452  nodes[2] = Point (1.,1.,-1.);
453  nodes[3] = Point (-1.,1.,-1.);
454  nodes[4] = Point (-1.,-1.,1.);
455  nodes[5] = Point (1.,-1.,1.);
456  nodes[6] = Point (1.,1.,1.);
457  nodes[7] = Point (-1.,1.,1.);
458  nodes[8] = Point (0.,-1.,-1.);
459  nodes[9] = Point (1.,0.,-1.);
460  nodes[10] = Point (0.,1.,-1.);
461  nodes[11] = Point (-1.,0.,-1.);
462  nodes[12] = Point (-1.,-1.,0.);
463  nodes[13] = Point (1.,-1.,0.);
464  nodes[14] = Point (1.,1.,0.);
465  nodes[15] = Point (-1.,1.,0.);
466  nodes[16] = Point (0.,-1.,1.);
467  nodes[17] = Point (1.,0.,1.);
468  nodes[18] = Point (0.,1.,1.);
469  nodes[19] = Point (-1.,0.,1.);
470  nodes[20] = Point (0.,0.,-1.);
471  nodes[21] = Point (0.,-1.,0.);
472  nodes[22] = Point (1.,0.,0.);
473  nodes[23] = Point (0.,1.,0.);
474  nodes[24] = Point (-1.,0.,0.);
475  nodes[25] = Point (0.,0.,1.);
476  nodes[26] = Point (0.,0.,0.);
477  return;
478  }
479  case PRISM6:
480  {
481  nodes.resize(6);
482  nodes[0] = Point (0.,0.,-1.);
483  nodes[1] = Point (1.,0.,-1.);
484  nodes[2] = Point (0.,1.,-1.);
485  nodes[3] = Point (0.,0.,1.);
486  nodes[4] = Point (1.,0.,1.);
487  nodes[5] = Point (0.,1.,1.);
488  return;
489  }
490  case PRISM15:
491  {
492  nodes.resize(15);
493  nodes[0] = Point (0.,0.,-1.);
494  nodes[1] = Point (1.,0.,-1.);
495  nodes[2] = Point (0.,1.,-1.);
496  nodes[3] = Point (0.,0.,1.);
497  nodes[4] = Point (1.,0.,1.);
498  nodes[5] = Point (0.,1.,1.);
499  nodes[6] = Point (.5,0.,-1.);
500  nodes[7] = Point (.5,.5,-1.);
501  nodes[8] = Point (0.,.5,-1.);
502  nodes[9] = Point (0.,0.,0.);
503  nodes[10] = Point (1.,0.,0.);
504  nodes[11] = Point (0.,1.,0.);
505  nodes[12] = Point (.5,0.,1.);
506  nodes[13] = Point (.5,.5,1.);
507  nodes[14] = Point (0.,.5,1.);
508  return;
509  }
510  case PRISM18:
511  {
512  nodes.resize(18);
513  nodes[0] = Point (0.,0.,-1.);
514  nodes[1] = Point (1.,0.,-1.);
515  nodes[2] = Point (0.,1.,-1.);
516  nodes[3] = Point (0.,0.,1.);
517  nodes[4] = Point (1.,0.,1.);
518  nodes[5] = Point (0.,1.,1.);
519  nodes[6] = Point (.5,0.,-1.);
520  nodes[7] = Point (.5,.5,-1.);
521  nodes[8] = Point (0.,.5,-1.);
522  nodes[9] = Point (0.,0.,0.);
523  nodes[10] = Point (1.,0.,0.);
524  nodes[11] = Point (0.,1.,0.);
525  nodes[12] = Point (.5,0.,1.);
526  nodes[13] = Point (.5,.5,1.);
527  nodes[14] = Point (0.,.5,1.);
528  nodes[15] = Point (.5,0.,0.);
529  nodes[16] = Point (.5,.5,0.);
530  nodes[17] = Point (0.,.5,0.);
531  return;
532  }
533  case PYRAMID5:
534  {
535  nodes.resize(5);
536  nodes[0] = Point (-1.,-1.,0.);
537  nodes[1] = Point (1.,-1.,0.);
538  nodes[2] = Point (1.,1.,0.);
539  nodes[3] = Point (-1.,1.,0.);
540  nodes[4] = Point (0.,0.,1.);
541  return;
542  }
543  case PYRAMID13:
544  {
545  nodes.resize(13);
546 
547  // base corners
548  nodes[0] = Point (-1.,-1.,0.);
549  nodes[1] = Point (1.,-1.,0.);
550  nodes[2] = Point (1.,1.,0.);
551  nodes[3] = Point (-1.,1.,0.);
552 
553  // apex
554  nodes[4] = Point (0.,0.,1.);
555 
556  // base midedge
557  nodes[5] = Point (0.,-1.,0.);
558  nodes[6] = Point (1.,0.,0.);
559  nodes[7] = Point (0.,1.,0.);
560  nodes[8] = Point (-1,0.,0.);
561 
562  // lateral midedge
563  nodes[9] = Point (-.5,-.5,.5);
564  nodes[10] = Point (.5,-.5,.5);
565  nodes[11] = Point (.5,.5,.5);
566  nodes[12] = Point (-.5,.5,.5);
567 
568  return;
569  }
570  case PYRAMID14:
571  {
572  nodes.resize(14);
573 
574  // base corners
575  nodes[0] = Point (-1.,-1.,0.);
576  nodes[1] = Point (1.,-1.,0.);
577  nodes[2] = Point (1.,1.,0.);
578  nodes[3] = Point (-1.,1.,0.);
579 
580  // apex
581  nodes[4] = Point (0.,0.,1.);
582 
583  // base midedge
584  nodes[5] = Point (0.,-1.,0.);
585  nodes[6] = Point (1.,0.,0.);
586  nodes[7] = Point (0.,1.,0.);
587  nodes[8] = Point (-1,0.,0.);
588 
589  // lateral midedge
590  nodes[9] = Point (-.5,-.5,.5);
591  nodes[10] = Point (.5,-.5,.5);
592  nodes[11] = Point (.5,.5,.5);
593  nodes[12] = Point (-.5,.5,.5);
594 
595  // base center
596  nodes[13] = Point (0.,0.,0.);
597 
598  return;
599  }
600 
601  default:
602  libmesh_error_msg("ERROR: Unknown element type " << itemType);
603  }
604 }

References libMesh::EDGE2, libMesh::EDGE3, libMesh::HEX20, libMesh::HEX27, libMesh::HEX8, libMesh::PRISM15, libMesh::PRISM18, libMesh::PRISM6, libMesh::PYRAMID13, libMesh::PYRAMID14, libMesh::PYRAMID5, libMesh::QUAD4, libMesh::QUAD8, libMesh::QUAD9, libMesh::QUADSHELL4, libMesh::QUADSHELL8, libMesh::TET10, libMesh::TET4, libMesh::TRI3, libMesh::TRI6, and libMesh::TRISHELL3.

◆ get_Sobolev_dweight()

template<typename OutputType>
const std::vector<RealGradient>& libMesh::FEGenericBase< OutputType >::get_Sobolev_dweight ( ) const
inline
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.

Definition at line 426 of file fe_base.h.

427  { return dweight; }

Referenced by assemble_SchroedingerEquation().

◆ get_Sobolev_weight()

template<typename OutputType>
const std::vector<Real>& libMesh::FEGenericBase< OutputType >::get_Sobolev_weight ( ) const
inline
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.

Definition at line 418 of file fe_base.h.

419  { return weight; }

Referenced by assemble_SchroedingerEquation().

◆ get_tangents()

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

Definition at line 374 of file fe_abstract.h.

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

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

◆ get_type()

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

Definition at line 416 of file fe_abstract.h.

416 { return elem_type; }

References libMesh::FEAbstract::elem_type.

◆ get_xyz()

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

Definition at line 237 of file fe_abstract.h.

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

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

Referenced by libMesh::ExactSolution::_compute_error(), assemble_SchroedingerEquation(), libMesh::DiscontinuityMeasure::boundary_side_integration(), libMesh::KellyErrorEstimator::boundary_side_integration(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubProjector::construct_projection(), PoissonSystem::element_postprocess(), LaplaceSystem::element_postprocess(), LaplaceQoI::element_qoi(), LaplaceQoI::element_qoi_derivative(), LaplaceSystem::element_qoi_derivative(), NavierSystem::element_time_derivative(), PoissonSystem::element_time_derivative(), CurlCurlSystem::element_time_derivative(), libMesh::RBEIMConstruction::enrich_RB_space(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::ParsedFEMFunction< T >::eval_args(), libMesh::ExactErrorEstimator::find_squared_element_error(), LaplaceQoI::init_context(), NavierSystem::init_context(), SolidSystem::init_context(), LaplaceSystem::init_context(), PoissonSystem::init_context(), CurlCurlSystem::init_context(), CoupledSystem::init_context(), libMesh::ParsedFEMFunction< T >::init_context(), libMesh::RBEIMConstruction::init_context_with_sys(), libMesh::DGFEMContext::neighbor_side_fe_reinit(), RationalMapTest< elem_type >::setUp(), LaplaceSystem::side_constraint(), LaplaceSystem::side_postprocess(), CoupledSystemQoI::side_qoi(), CoupledSystemQoI::side_qoi_derivative(), LaplaceSystem::side_qoi_derivative(), SolidSystem::side_time_derivative(), CurlCurlSystem::side_time_derivative(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::SubFunctor(), SlitMeshRefinedSystemTest::testRestart(), SlitMeshRefinedSystemTest::testSystem(), and libMesh::RBEIMConstruction::truth_solve().

◆ increment_constructor_count()

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

Increments the construction counter.

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

Definition at line 181 of file reference_counter.h.

182 {
183  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
184  std::pair<unsigned int, unsigned int> & p = _counts[name];
185 
186  p.first++;
187 }

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

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

◆ increment_destructor_count()

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

Increments the destruction counter.

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

Definition at line 194 of file reference_counter.h.

195 {
196  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
197  std::pair<unsigned int, unsigned int> & p = _counts[name];
198 
199  p.second++;
200 }

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

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

◆ init_base_shape_functions()

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

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

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

Implemented in libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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 >.

◆ 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::InfFE< Dim, T_radial, T_map >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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 83 of file reference_counter.h.

84  { return _n_objects; }

References libMesh::ReferenceCounter::_n_objects.

◆ n_quadrature_points()

virtual unsigned int libMesh::FEAbstract::n_quadrature_points ( ) const
pure virtualinherited
Returns
The total number of quadrature points. Useful during matrix assembly. Implement this in derived classes.

Implemented in libMesh::InfFE< Dim, T_radial, T_map >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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 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().

◆ n_shape_functions()

virtual unsigned int libMesh::FEAbstract::n_shape_functions ( ) const
pure virtualinherited
Returns
The total number of approximation shape functions for the current element. Useful during matrix assembly. Implement this in derived classes.

Implemented in libMesh::InfFE< Dim, T_radial, T_map >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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 assemble_SchroedingerEquation().

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

Definition at line 606 of file fe_abstract.C.

607 {
608  libmesh_assert_greater_equal (eps, 0.);
609 
610  const Real xi = p(0);
611 #if LIBMESH_DIM > 1
612  const Real eta = p(1);
613 #else
614  const Real eta = 0.;
615 #endif
616 #if LIBMESH_DIM > 2
617  const Real zeta = p(2);
618 #else
619  const Real zeta = 0.;
620 #endif
621 
622  switch (t)
623  {
624  case NODEELEM:
625  {
626  return (!xi && !eta && !zeta);
627  }
628  case EDGE2:
629  case EDGE3:
630  case EDGE4:
631  {
632  // The reference 1D element is [-1,1].
633  if ((xi >= -1.-eps) &&
634  (xi <= 1.+eps))
635  return true;
636 
637  return false;
638  }
639 
640 
641  case TRI3:
642  case TRISHELL3:
643  case TRI6:
644  {
645  // The reference triangle is isosceles
646  // and is bound by xi=0, eta=0, and xi+eta=1.
647  if ((xi >= 0.-eps) &&
648  (eta >= 0.-eps) &&
649  ((xi + eta) <= 1.+eps))
650  return true;
651 
652  return false;
653  }
654 
655 
656  case QUAD4:
657  case QUADSHELL4:
658  case QUAD8:
659  case QUADSHELL8:
660  case QUAD9:
661  {
662  // The reference quadrilateral element is [-1,1]^2.
663  if ((xi >= -1.-eps) &&
664  (xi <= 1.+eps) &&
665  (eta >= -1.-eps) &&
666  (eta <= 1.+eps))
667  return true;
668 
669  return false;
670  }
671 
672 
673  case TET4:
674  case TET10:
675  {
676  // The reference tetrahedral is isosceles
677  // and is bound by xi=0, eta=0, zeta=0,
678  // and xi+eta+zeta=1.
679  if ((xi >= 0.-eps) &&
680  (eta >= 0.-eps) &&
681  (zeta >= 0.-eps) &&
682  ((xi + eta + zeta) <= 1.+eps))
683  return true;
684 
685  return false;
686  }
687 
688 
689  case HEX8:
690  case HEX20:
691  case HEX27:
692  {
693  /*
694  if ((xi >= -1.) &&
695  (xi <= 1.) &&
696  (eta >= -1.) &&
697  (eta <= 1.) &&
698  (zeta >= -1.) &&
699  (zeta <= 1.))
700  return true;
701  */
702 
703  // The reference hexahedral element is [-1,1]^3.
704  if ((xi >= -1.-eps) &&
705  (xi <= 1.+eps) &&
706  (eta >= -1.-eps) &&
707  (eta <= 1.+eps) &&
708  (zeta >= -1.-eps) &&
709  (zeta <= 1.+eps))
710  {
711  // libMesh::out << "Strange Point:\n";
712  // p.print();
713  return true;
714  }
715 
716  return false;
717  }
718 
719  case PRISM6:
720  case PRISM15:
721  case PRISM18:
722  {
723  // Figure this one out...
724  // inside the reference triangle with zeta in [-1,1]
725  if ((xi >= 0.-eps) &&
726  (eta >= 0.-eps) &&
727  (zeta >= -1.-eps) &&
728  (zeta <= 1.+eps) &&
729  ((xi + eta) <= 1.+eps))
730  return true;
731 
732  return false;
733  }
734 
735 
736  case PYRAMID5:
737  case PYRAMID13:
738  case PYRAMID14:
739  {
740  // Check that the point is on the same side of all the faces
741  // by testing whether:
742  //
743  // n_i.(x - x_i) <= 0
744  //
745  // for each i, where:
746  // n_i is the outward normal of face i,
747  // x_i is a point on face i.
748  if ((-eta - 1. + zeta <= 0.+eps) &&
749  ( xi - 1. + zeta <= 0.+eps) &&
750  ( eta - 1. + zeta <= 0.+eps) &&
751  ( -xi - 1. + zeta <= 0.+eps) &&
752  ( zeta >= 0.-eps))
753  return true;
754 
755  return false;
756  }
757 
758 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
759  case INFHEX8:
760  case INFHEX16:
761  case INFHEX18:
762  {
763  // The reference infhex8 is a [-1,1]^3.
764  if ((xi >= -1.-eps) &&
765  (xi <= 1.+eps) &&
766  (eta >= -1.-eps) &&
767  (eta <= 1.+eps) &&
768  (zeta >= -1.-eps) &&
769  (zeta <= 1.+eps))
770  {
771  return true;
772  }
773  return false;
774  }
775 
776  case INFPRISM6:
777  case INFPRISM12:
778  {
779  // inside the reference triangle with zeta in [-1,1]
780  if ((xi >= 0.-eps) &&
781  (eta >= 0.-eps) &&
782  (zeta >= -1.-eps) &&
783  (zeta <= 1.+eps) &&
784  ((xi + eta) <= 1.+eps))
785  {
786  return true;
787  }
788 
789  return false;
790  }
791 #endif
792 
793  default:
794  libmesh_error_msg("ERROR: Unknown element type " << t);
795  }
796 
797  // If we get here then the point is _not_ in the
798  // reference element. Better return false.
799 
800  return false;
801 }

References libMesh::EDGE2, libMesh::EDGE3, libMesh::EDGE4, libMesh::HEX20, libMesh::HEX27, libMesh::HEX8, libMesh::INFHEX16, libMesh::INFHEX18, libMesh::INFHEX8, libMesh::INFPRISM12, libMesh::INFPRISM6, libMesh::NODEELEM, libMesh::PRISM15, libMesh::PRISM18, libMesh::PRISM6, libMesh::PYRAMID13, libMesh::PYRAMID14, libMesh::PYRAMID5, libMesh::QUAD4, libMesh::QUAD8, libMesh::QUAD9, libMesh::QUADSHELL4, libMesh::QUADSHELL8, libMesh::Real, libMesh::TET10, libMesh::TET4, libMesh::TRI3, libMesh::TRI6, and libMesh::TRISHELL3.

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

◆ print_d2phi()

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

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

Implements libMesh::FEAbstract.

Definition at line 807 of file fe_base.C.

808 {
809  for (auto i : index_range(dphi))
810  for (auto j : index_range(dphi[i]))
811  os << " d2phi[" << i << "][" << j << "]=" << d2phi[i][j];
812 }

◆ print_dphi()

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

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

Implements libMesh::FEAbstract.

Definition at line 746 of file fe_base.C.

747 {
748  for (auto i : index_range(dphi))
749  for (auto j : index_range(dphi[i]))
750  os << " dphi[" << i << "][" << j << "]=" << dphi[i][j];
751 }

◆ print_info() [1/2]

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

Prints all the relevant information about the current element.

Definition at line 818 of file fe_abstract.C.

819 {
820  os << "phi[i][j]: Shape function i at quadrature pt. j" << std::endl;
821  this->print_phi(os);
822 
823  os << "dphi[i][j]: Shape function i's gradient at quadrature pt. j" << std::endl;
824  this->print_dphi(os);
825 
826  os << "XYZ locations of the quadrature pts." << std::endl;
827  this->print_xyz(os);
828 
829  os << "Values of JxW at the quadrature pts." << std::endl;
830  this->print_JxW(os);
831 }

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

Referenced by libMesh::operator<<().

◆ print_info() [2/2]

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

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

Definition at line 87 of file reference_counter.C.

88 {
89  if (_enable_print_counter)
90  out_stream << ReferenceCounter::get_info();
91 }

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

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

806 {
807  this->_fe_map->print_JxW(os);
808 }

References libMesh::FEAbstract::_fe_map.

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

◆ print_phi()

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

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

Implements libMesh::FEAbstract.

Definition at line 735 of file fe_base.C.

736 {
737  for (auto i : index_range(phi))
738  for (auto j : index_range(phi[i]))
739  os << " phi[" << i << "][" << j << "]=" << phi[i][j] << std::endl;
740 }

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

813 {
814  this->_fe_map->print_xyz(os);
815 }

References libMesh::FEAbstract::_fe_map.

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

◆ reinit() [1/2]

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

This is at the core of this class.

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

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

Implemented in libMesh::FEXYZ< Dim >, libMesh::FESubdivision, libMesh::InfFE< Dim, T_radial, T_map >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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::ExactSolution::_compute_error(), assemble_SchroedingerEquation(), libMesh::FEMContext::build_new_fe(), libMesh::System::calculate_norm(), libMesh::RBEIMAssembly::evaluate_basis_function(), libMesh::ExactErrorEstimator::find_squared_element_error(), libMesh::JumpErrorEstimator::reinit_sides(), FETest< order, family, elem_type >::testGradU(), FETest< order, family, elem_type >::testGradUComp(), and FETest< order, family, elem_type >::testU().

◆ reinit() [2/2]

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

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

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

Implemented in libMesh::InfFE< Dim, T_radial, T_map >, libMesh::FEXYZ< Dim >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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::FESubdivision, libMesh::FEXYZ< Dim >, and libMesh::FEXYZ< Dim >.

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

437 { fe_type.order = new_order; }

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

◆ shapes_need_reinit()

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

Implemented in libMesh::InfFE< Dim, T_radial, T_map >, libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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

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

Implemented in libMesh::FE< Dim, T >, libMesh::FE< 2, SUBDIVISION >, libMesh::FE< Dim, HIERARCHIC >, libMesh::FE< Dim, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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, SCALAR >, libMesh::FE< Dim, L2_LAGRANGE >, libMesh::FE< Dim, NEDELEC_ONE >, libMesh::FE< Dim, HERMITE >, 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 >.

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

Member Data Documentation

◆ _counts

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

Actually holds the data.

Definition at line 122 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::get_info(), libMesh::ReferenceCounter::increment_constructor_count(), and libMesh::ReferenceCounter::increment_destructor_count().

◆ _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 141 of file reference_counter.h.

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

◆ _fe_map

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

Definition at line 524 of file fe_abstract.h.

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

◆ _fe_trans

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

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

Definition at line 492 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 135 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 130 of file reference_counter.h.

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

◆ _p_level

unsigned int libMesh::FEAbstract::_p_level
protectedinherited

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

Definition at line 597 of file fe_abstract.h.

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

◆ calculate_curl_phi

bool libMesh::FEAbstract::calculate_curl_phi
mutableprotectedinherited

Should we calculate shape function curls?

Definition at line 567 of file fe_abstract.h.

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

◆ calculate_d2phi [1/2]

bool libMesh::FEAbstract::calculate_d2phi
mutableprotectedinherited

Should we calculate shape function hessians?

Definition at line 557 of file fe_abstract.h.

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

◆ calculate_d2phi [2/2]

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

Definition at line 560 of file fe_abstract.h.

◆ calculate_div_phi

bool libMesh::FEAbstract::calculate_div_phi
mutableprotectedinherited

Should we calculate shape function divergences?

Definition at line 572 of file fe_abstract.h.

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

◆ calculate_dphi

bool libMesh::FEAbstract::calculate_dphi
mutableprotectedinherited

Should we calculate shape function gradients?

Definition at line 551 of file fe_abstract.h.

Referenced by libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphi(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidx(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidy(), and libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidz().

◆ calculate_dphiref

bool libMesh::FEAbstract::calculate_dphiref
mutableprotectedinherited

Should we calculate reference shape function gradients?

Definition at line 577 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(), and libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidzeta().

◆ calculate_map

bool libMesh::FEAbstract::calculate_map
mutableprotectedinherited

Are we calculating mapping functions?

Definition at line 541 of file fe_abstract.h.

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

◆ calculate_phi

bool libMesh::FEAbstract::calculate_phi
mutableprotectedinherited

Should we calculate shape functions?

Definition at line 546 of file fe_abstract.h.

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

◆ 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 536 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_phi(), and libMesh::FESubdivision::init_shape_functions().

◆ 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 507 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 550 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 570 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 575 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 585 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 590 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 595 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 555 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 560 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 565 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 600 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 605 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 610 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 580 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 530 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 512 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 628 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 502 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 522 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 532 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 517 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 537 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 542 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 527 of file fe_base.h.

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

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

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

◆ elem_type

ElemType libMesh::FEAbstract::elem_type
protectedinherited

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

Definition at line 591 of file fe_abstract.h.

Referenced by libMesh::FESubdivision::attach_quadrature_rule(), and libMesh::FEAbstract::get_type().

◆ fe_type

FEType libMesh::FEAbstract::fe_type
protectedinherited

The finite element type for this object.

Note
This should be constant for the object.

Definition at line 585 of file fe_abstract.h.

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

◆ phi

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

Shape function values.

Definition at line 497 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 602 of file fe_abstract.h.

Referenced by libMesh::FESubdivision::attach_quadrature_rule().

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

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

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

The documentation for this class was generated from the following files:
libMesh::C_ONE
Definition: enum_fe_family.h:80
libMesh::FEType::inf_map
InfMapType inf_map
The coordinate mapping type of the infinite element.
Definition: fe_type.h:257
libMesh::FEGenericBase::d2phidxdz
std::vector< std::vector< OutputShape > > d2phidxdz
Shape function second derivatives in the x-z direction.
Definition: fe_base.h:595
libMesh::HEX20
Definition: enum_elem_type.h:48
libMesh::dof_id_type
uint8_t dof_id_type
Definition: id_types.h:67
libMesh::Number
Real Number
Definition: libmesh_common.h:195
libMesh::PRISM6
Definition: enum_elem_type.h:50
libMesh::FETransformationBase::build
static std::unique_ptr< FETransformationBase< OutputShape > > build(const FEType &type)
Builds an FETransformation object based on the finite element type.
Definition: fe_transformation_base.C:28
libMesh::BoundaryInfo::boundary_ids
std::vector< boundary_id_type > boundary_ids(const Node *node) const
Definition: boundary_info.C:985
libMesh::Elem::child_ptr
const Elem * child_ptr(unsigned int i) const
Definition: elem.h:2567
libMesh::FEType::radial_family
FEFamily radial_family
The type of approximation in radial direction.
Definition: fe_type.h:249
libMesh::PeriodicBoundaryBase::has_transformation_matrix
bool has_transformation_matrix() const
Definition: periodic_boundary_base.C:76
libMesh::Elem::is_node_on_side
virtual bool is_node_on_side(const unsigned int n, const unsigned int s) const =0
libMesh::Elem::n_edges
virtual unsigned int n_edges() const =0
libMesh::OrderWrapper::get_order
int get_order() const
Explicitly request the order as an int.
Definition: fe_type.h:77
libMesh::invalid_uint
const unsigned int invalid_uint
A number which is used quite often to represent an invalid or uninitialized value.
Definition: libmesh.h:249
libMesh::PeriodicBoundaryBase::get_corresponding_pos
virtual Point get_corresponding_pos(const Point &pt) const =0
This function should be overridden by derived classes to define how one finds corresponding nodes on ...
libMesh::FEGenericBase::_fe_trans
std::unique_ptr< FETransformationBase< OutputType > > _fe_trans
Object that handles computing shape function values, gradients, etc in the physical domain.
Definition: fe_base.h:492
libMesh::FEAbstract::calculate_dphi
bool calculate_dphi
Should we calculate shape function gradients?
Definition: fe_abstract.h:551
libMesh::CLOUGH
Definition: enum_fe_family.h:53
libMesh::FEGenericBase::d2phideta2
std::vector< std::vector< OutputShape > > d2phideta2
Shape function second derivatives in the eta direction.
Definition: fe_base.h:570
libMesh::MeshBase::get_boundary_info
const BoundaryInfo & get_boundary_info() const
The information about boundary ids on the mesh.
Definition: mesh_base.h:132
libMesh::FEType::family
FEFamily family
The type of finite element.
Definition: fe_type.h:203
libMesh::QGauss
This class implements specific orders of Gauss quadrature.
Definition: quadrature_gauss.h:39
libMesh::DofMap::dof_indices
void dof_indices(const Elem *const elem, std::vector< dof_id_type > &di) const
Fills the vector di with the global degree of freedom indices for the element.
Definition: dof_map.C:1967
libMesh::FEGenericBase::curl_phi
std::vector< std::vector< OutputShape > > curl_phi
Shape function curl values.
Definition: fe_base.h:507
libMesh::FEGenericBase::~FEGenericBase
virtual ~FEGenericBase()
Destructor.
libMesh::Elem::level
unsigned int level() const
Definition: elem.h:2478
libMesh::L2_HIERARCHIC
Definition: enum_fe_family.h:40
libMesh::FEGenericBase::dphidzeta
std::vector< std::vector< OutputShape > > dphidzeta
Shape function derivatives in the zeta direction.
Definition: fe_base.h:527
libMesh::FEGenericBase::dphideta
std::vector< std::vector< OutputShape > > dphideta
Shape function derivatives in the eta direction.
Definition: fe_base.h:522
libMesh::Elem::n_nodes
virtual unsigned int n_nodes() const =0
libMesh::HEX8
Definition: enum_elem_type.h:47
libMesh::FEAbstract::print_xyz
void print_xyz(std::ostream &os) const
Prints the spatial location of each quadrature point (on the physical element).
Definition: fe_abstract.C:812
libMesh::INFINITE_MAP
Definition: enum_fe_family.h:48
libMesh::EDGE4
Definition: enum_elem_type.h:37
libMesh::FEGenericBase::dphidz
std::vector< std::vector< OutputShape > > dphidz
Shape function derivatives in the z direction.
Definition: fe_base.h:542
libMesh::INFHEX8
Definition: enum_elem_type.h:60
libMesh::FEAbstract::fe_type
FEType fe_type
The finite element type for this object.
Definition: fe_abstract.h:585
libMesh::Elem::n_neighbors
unsigned int n_neighbors() const
Definition: elem.h:631
libMesh::HERMITE
Definition: enum_fe_family.h:54
libMesh::FEInterface::n_dofs_at_node
static unsigned int n_dofs_at_node(const unsigned int dim, const FEType &fe_t, const ElemType t, const unsigned int n)
Definition: fe_interface.C:503
libMesh::FEGenericBase::div_phi
std::vector< std::vector< OutputDivergence > > div_phi
Shape function divergence values.
Definition: fe_base.h:512
libMesh::QBase::n_points
unsigned int n_points() const
Definition: quadrature.h:126
libMesh::FEGenericBase::dphidy
std::vector< std::vector< OutputShape > > dphidy
Shape function derivatives in the y direction.
Definition: fe_base.h:537
libMesh::PeriodicBoundaryBase
The base class for defining periodic boundaries.
Definition: periodic_boundary_base.h:48
libMesh::index_range
IntRange< std::size_t > index_range(const std::vector< T > &vec)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:106
libMesh::Elem::dim
virtual unsigned short dim() const =0
libMesh::DenseVector::zero
virtual void zero() override
Set every element in the vector to 0.
Definition: dense_vector.h:379
libMesh::JACOBI_20_00
Definition: enum_fe_family.h:49
libMesh::TET10
Definition: enum_elem_type.h:46
libMesh::XYZ
Definition: enum_fe_family.h:46
libMesh::FEGenericBase
This class forms the foundation from which generic finite elements may be derived.
Definition: exact_error_estimator.h:39
libMesh::FEAbstract::print_dphi
virtual void print_dphi(std::ostream &os) const =0
Prints the value of each shape function's derivative at each quadrature point.
libMesh::FEAbstract::calculate_dphiref
bool calculate_dphiref
Should we calculate reference shape function gradients?
Definition: fe_abstract.h:577
libMesh::FEAbstract::calculations_started
bool calculations_started
Have calculations with this object already been started? Then all get_* functions should already have...
Definition: fe_abstract.h:536
libMesh::ReferenceCounter::_counts
static Counts _counts
Actually holds the data.
Definition: reference_counter.h:122
libMesh::TOLERANCE
static const Real TOLERANCE
Definition: libmesh_common.h:128
libMesh::FEAbstract::calculate_phi
bool calculate_phi
Should we calculate shape functions?
Definition: fe_abstract.h:546
libMesh::DenseMatrix< Real >
libMesh::DofMap::n_variables
unsigned int n_variables() const
Definition: dof_map.h:592
libMesh::FEAbstract::calculate_map
bool calculate_map
Are we calculating mapping functions?
Definition: fe_abstract.h:541
libMesh::MONOMIAL_VEC
Definition: enum_fe_family.h:62
libMesh::Elem::p_level
unsigned int p_level() const
Definition: elem.h:2512
libMesh::ReferenceCounter::_n_objects
static Threads::atomic< unsigned int > _n_objects
The number of objects.
Definition: reference_counter.h:130
libMesh::Elem::node_index_range
IntRange< unsigned short > node_index_range() const
Definition: elem.h:2170
libMesh::Variable::type
const FEType & type() const
Definition: variable.h:119
mesh
MeshBase & mesh
Definition: mesh_communication.C:1257
libMesh::FEGenericBase::d2phidxidzeta
std::vector< std::vector< OutputShape > > d2phidxidzeta
Shape function second derivatives in the xi-zeta direction.
Definition: fe_base.h:565
libMesh::FEAbstract::calculate_curl_phi
bool calculate_curl_phi
Should we calculate shape function curls?
Definition: fe_abstract.h:567
libMesh::DofMap::is_constrained_dof
bool is_constrained_dof(const dof_id_type dof) const
Definition: dof_map.h:1962
libMesh::ReferenceCounter::get_info
static std::string get_info()
Gets a string containing the reference information.
Definition: reference_counter.C:47
libMesh::Elem::active
bool active() const
Definition: elem.h:2345
libMesh::FEGenericBase::phi
std::vector< std::vector< OutputShape > > phi
Shape function values.
Definition: fe_base.h:497
libMesh::FEGenericBase::d2phidetadzeta
std::vector< std::vector< OutputShape > > d2phidetadzeta
Shape function second derivatives in the eta-zeta direction.
Definition: fe_base.h:575
libMesh::DenseMatrix::resize
void resize(const unsigned int new_m, const unsigned int new_n)
Resize the matrix.
Definition: dense_matrix.h:822
libMesh::FEGenericBase::d2phidz2
std::vector< std::vector< OutputShape > > d2phidz2
Shape function second derivatives in the z direction.
Definition: fe_base.h:610
libMesh::TET4
Definition: enum_elem_type.h:45
libMesh::DofMap::old_dof_indices
void old_dof_indices(const Elem &elem, unsigned int n, std::vector< dof_id_type > &di, const unsigned int vn) const
Appends to the vector di the old global degree of freedom indices for elem.node_ref(n),...
Definition: dof_map.C:2258
libMesh::PeriodicBoundaries::boundary
PeriodicBoundaryBase * boundary(boundary_id_type id)
Definition: periodic_boundaries.C:40
libMesh::CARTESIAN
Definition: enum_inf_map_type.h:35
libMesh::zero
const Number zero
.
Definition: libmesh.h:243
libMesh::FEGenericBase::dphidxi
std::vector< std::vector< OutputShape > > dphidxi
Shape function derivatives in the xi direction.
Definition: fe_base.h:517
libMesh::FEGenericBase::d2phidzeta2
std::vector< std::vector< OutputShape > > d2phidzeta2
Shape function second derivatives in the zeta direction.
Definition: fe_base.h:580
libMesh::FEGenericBase::dweight
std::vector< RealGradient > dweight
Used for certain infinite element families: the global derivative of the additional radial weight ,...
Definition: fe_base.h:635
libMesh::PRISM15
Definition: enum_elem_type.h:51
libMesh::SZABAB
Definition: enum_fe_family.h:44
libMesh::DofObject::dof_number
dof_id_type dof_number(const unsigned int s, const unsigned int var, const unsigned int comp) const
Definition: dof_object.h:956
libMesh::INFPRISM6
Definition: enum_elem_type.h:63
libMesh::libmesh_assert
libmesh_assert(ctx)
libMesh::FEGenericBase::d2phidxideta
std::vector< std::vector< OutputShape > > d2phidxideta
Shape function second derivatives in the xi-eta direction.
Definition: fe_base.h:560
std::abs
MetaPhysicL::DualNumber< T, D > abs(const MetaPhysicL::DualNumber< T, D > &in)
libMesh::JACOBI_30_00
Definition: enum_fe_family.h:50
libMesh::HEX27
Definition: enum_elem_type.h:49
libMesh::FEMap::inverse_map
static Point inverse_map(const unsigned int dim, const Elem *elem, const Point &p, const Real tolerance=TOLERANCE, const bool secure=true)
Definition: fe_map.C:1622
libMesh::DofMap::sys_number
unsigned int sys_number() const
Definition: dof_map.h:1876
libMesh::FEGenericBase::d2phi
std::vector< std::vector< OutputTensor > > d2phi
Shape function second derivative values.
Definition: fe_base.h:550
libMesh::DofObject::n_comp
unsigned int n_comp(const unsigned int s, const unsigned int var) const
Definition: dof_object.h:926
libMesh::FEAbstract::print_phi
virtual void print_phi(std::ostream &os) const =0
Prints the value of each shape function at each quadrature point.
libMesh::FEGenericBase::d2phidydz
std::vector< std::vector< OutputShape > > d2phidydz
Shape function second derivatives in the y-z direction.
Definition: fe_base.h:605
libMesh::FEAbstract::calculate_div_phi
bool calculate_div_phi
Should we calculate shape function divergences?
Definition: fe_abstract.h:572
libMesh::DofMap::variable
const Variable & variable(const unsigned int c) const
Definition: dof_map.h:1894
libMesh::Threads::spin_mtx
spin_mutex spin_mtx
A convenient spin mutex object which can be used for obtaining locks.
Definition: threads.C:29
libMesh::DofObject::invalid_id
static const dof_id_type invalid_id
An invalid id to distinguish an uninitialized DofObject.
Definition: dof_object.h:421
libMesh::FEAbstract::qrule
QBase * qrule
A pointer to the quadrature rule employed.
Definition: fe_abstract.h:602
libMesh::INFHEX18
Definition: enum_elem_type.h:62
libMesh::BoundaryInfo::side_with_boundary_id
unsigned int side_with_boundary_id(const Elem *const elem, const boundary_id_type boundary_id) const
Definition: boundary_info.C:1527
libMesh::QUAD4
Definition: enum_elem_type.h:41
libMesh::Point
A Point defines a location in LIBMESH_DIM dimensional Real space.
Definition: point.h:38
libMesh::FEInterface::dofs_on_edge
static void dofs_on_edge(const Elem *const elem, const unsigned int dim, const FEType &fe_t, unsigned int e, std::vector< unsigned int > &di)
Fills the vector di with the local degree of freedom indices associated with edge e of element elem A...
Definition: fe_interface.C:566
libMesh::Variable
This class defines the notion of a variable in the system.
Definition: variable.h:49
libMesh::DISCONTINUOUS
Definition: enum_fe_family.h:78
libMesh::TRI3
Definition: enum_elem_type.h:39
libMesh::FEAbstract::_fe_map
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:524
libMesh::C_ZERO
Definition: enum_fe_family.h:79
libMesh::FEGenericBase::dphi
std::vector< std::vector< OutputGradient > > dphi
Shape function derivative values.
Definition: fe_base.h:502
libMesh::Node
A Node is like a Point, but with more information.
Definition: node.h:52
libMesh::FEGenericBase::d2phidxi2
std::vector< std::vector< OutputShape > > d2phidxi2
Shape function second derivatives in the xi direction.
Definition: fe_base.h:555
libMesh::LEGENDRE
Definition: enum_fe_family.h:51
libMesh::TensorTools::inner_product
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:62
libMesh::DofMap::constrain_p_dofs
void constrain_p_dofs(unsigned int var, const Elem *elem, unsigned int s, unsigned int p)
Constrains degrees of freedom on side s of element elem which correspond to variable number var and t...
Definition: dof_map_constraints.C:4325
libMesh::FEInterface::n_dofs
static unsigned int n_dofs(const unsigned int dim, const FEType &fe_t, const ElemType t)
Definition: fe_interface.C:472
libMesh::DofMap::variable_type
const FEType & variable_type(const unsigned int c) const
Definition: dof_map.h:1924
libMesh::FEMap::map_fe_type
static FEFamily map_fe_type(const Elem &elem)
Definition: fe_map.C:47
libMesh::FEType::default_quadrature_rule
std::unique_ptr< QBase > default_quadrature_rule(const unsigned int dim, const int extraorder=0) const
Definition: fe_type.C:31
libMesh::RATIONAL_BERNSTEIN
Definition: enum_fe_family.h:64
libMesh::BERNSTEIN
Definition: enum_fe_family.h:43
libMesh::PeriodicBoundaryBase::is_my_variable
bool is_my_variable(unsigned int var_num) const
Definition: periodic_boundary_base.C:68
n_nodes
const dof_id_type n_nodes
Definition: tecplot_io.C:68
libMesh::INFHEX16
Definition: enum_elem_type.h:61
libMesh::Elem::is_node_on_edge
virtual bool is_node_on_edge(const unsigned int n, const unsigned int e) const =0
libMesh::FEAbstract::dim
const unsigned int dim
The dimensionality of the object.
Definition: fe_abstract.h:530
libMesh::FEGenericBase::coarsened_dof_values
static void coarsened_dof_values(const NumericVector< Number > &global_vector, const DofMap &dof_map, const Elem *coarse_elem, DenseVector< Number > &coarse_dofs, const unsigned int var, const bool use_old_dof_indices=false)
Creates a local projection on coarse_elem, based on the DoF values in global_vector for it's children...
Definition: fe_base.C:822
libMesh::FEGenericBase::OutputNumber
TensorTools::MakeNumber< OutputShape >::type OutputNumber
Definition: fe_base.h:122
libMesh::is
PetscErrorCode PetscInt const PetscInt IS * is
Definition: petsc_dm_wrapper.C:60
libMesh::DenseMatrix::zero
virtual void zero() override
Set every element in the matrix to 0.
Definition: dense_matrix.h:838
libMesh::HIERARCHIC
Definition: enum_fe_family.h:37
libMesh::MONOMIAL
Definition: enum_fe_family.h:39
libMesh::INFPRISM12
Definition: enum_elem_type.h:64
libMesh::PeriodicBoundaryBase::get_transformation_matrix
const DenseMatrix< Real > & get_transformation_matrix() const
Get the transformation matrix, if it is defined.
Definition: periodic_boundary_base.C:83
libMesh::FEInterface::dofs_on_side
static void dofs_on_side(const Elem *const elem, const unsigned int dim, const FEType &fe_t, unsigned int s, std::vector< unsigned int > &di)
Fills the vector di with the local degree of freedom indices associated with side s of element elem A...
Definition: fe_interface.C:553
libMesh::DenseMatrix::cholesky_solve
void cholesky_solve(const DenseVector< T2 > &b, DenseVector< T2 > &x)
For symmetric positive definite (SPD) matrices.
Definition: dense_matrix_impl.h:947
libMesh::TRI6
Definition: enum_elem_type.h:40
libMesh::DenseVector::resize
void resize(const unsigned int n)
Resize the vector.
Definition: dense_vector.h:355
swap
void swap(Iterator &lhs, Iterator &rhs)
swap, used to implement op=
Definition: variant_filter_iterator.h:478
libMesh::Elem::is_edge
virtual bool is_edge(const unsigned int i) const =0
libMesh::FEType
class FEType hides (possibly multiple) FEFamily and approximation orders, thereby enabling specialize...
Definition: fe_type.h:178
libMesh::FEType::order
OrderWrapper order
The approximation order of the element.
Definition: fe_type.h:197
libMesh::PeriodicBoundaries::neighbor
const Elem * neighbor(boundary_id_type boundary_id, const PointLocatorBase &point_locator, const Elem *e, unsigned int side) const
Definition: periodic_boundaries.C:61
libMesh::FEFamily
FEFamily
Definition: enum_fe_family.h:34
libMesh::QUADSHELL8
Definition: enum_elem_type.h:73
libMesh::PYRAMID5
Definition: enum_elem_type.h:53
libMesh::Elem::hmin
virtual Real hmin() const
Definition: elem.C:359
libMesh::FEInterface::field_type
static FEFieldType field_type(const FEType &fe_type)
Definition: fe_interface.C:1683
libMesh::NEDELEC_ONE
Definition: enum_fe_family.h:61
libMesh::Elem::subdomain_id
subdomain_id_type subdomain_id() const
Definition: elem.h:2069
libMesh::DofObject::id
dof_id_type id() const
Definition: dof_object.h:767
libMesh::TYPE_VECTOR
Definition: enum_fe_family.h:94
libMesh::EDGE3
Definition: enum_elem_type.h:36
libMesh::QUADSHELL4
Definition: enum_elem_type.h:72
libMesh::Elem::side_index_range
IntRange< unsigned short > side_index_range() const
Definition: elem.h:2188
libMesh::Elem::is_vertex
virtual bool is_vertex(const unsigned int i) const =0
libMesh::Elem::min_p_level_by_neighbor
unsigned int min_p_level_by_neighbor(const Elem *neighbor, unsigned int current_min) const
Definition: elem.C:1663
libMesh::FEGenericBase::dphase
std::vector< OutputGradient > dphase
Used for certain infinite element families: the first derivatives of the phase term in global coordin...
Definition: fe_base.h:628
libMesh::FEAbstract::_p_level
unsigned int _p_level
The p refinement level the current data structures are set up for.
Definition: fe_abstract.h:597
libMesh::Elem
This is the base class from which all geometric element types are derived.
Definition: elem.h:100
libMesh::FEGenericBase::dphidx
std::vector< std::vector< OutputShape > > dphidx
Shape function derivatives in the x direction.
Definition: fe_base.h:532
libMesh::Elem::is_face
virtual bool is_face(const unsigned int i) const =0
libMesh::FEGenericBase::d2phidxdy
std::vector< std::vector< OutputShape > > d2phidxdy
Shape function second derivatives in the x-y direction.
Definition: fe_base.h:590
libMesh::NODEELEM
Definition: enum_elem_type.h:66
libMesh::PeriodicBoundaryBase::get_variables
const std::set< unsigned int > & get_variables() const
Get the set of variables for this periodic boundary condition.
Definition: periodic_boundary_base.C:108
libMesh::FEAbstract::elem_type
ElemType elem_type
The element type the current data structures are set up for.
Definition: fe_abstract.h:591
libMesh::L2_LAGRANGE
Definition: enum_fe_family.h:41
libMesh::FEGenericBase::determine_calculations
void determine_calculations()
Determine which values are to be calculated, for both the FE itself and for the FEMap.
Definition: fe_base.C:756
libMesh::QUAD9
Definition: enum_elem_type.h:43
libMesh::FEGenericBase::OutputNumberGradient
TensorTools::IncrementRank< OutputNumber >::type OutputNumberGradient
Definition: fe_base.h:123
libMesh::LAGRANGE_VEC
Definition: enum_fe_family.h:60
libMesh::FEGenericBase::d2phidy2
std::vector< std::vector< OutputShape > > d2phidy2
Shape function second derivatives in the y direction.
Definition: fe_base.h:600
libMesh::LAGRANGE
Definition: enum_fe_family.h:36
libMesh::SCALAR
Definition: enum_fe_family.h:58
libMesh::SUBDIVISION
Definition: enum_fe_family.h:55
libMesh::Elem::neighbor_ptr
const Elem * neighbor_ptr(unsigned int i) const
Definition: elem.h:2085
libMesh::Elem::node_ref
const Node & node_ref(const unsigned int i) const
Definition: elem.h:2031
libMesh::Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
Definition: libmesh_common.h:121
libMesh::PeriodicBoundaryBase::pairedboundary
boundary_id_type pairedboundary
Definition: periodic_boundary_base.h:58
libMesh::Variable::active_on_subdomain
bool active_on_subdomain(subdomain_id_type sid) const
Definition: variable.h:136
libMesh::FEType::default_quadrature_order
Order default_quadrature_order() const
Definition: fe_type.h:353
libMesh::ReferenceCounter::_enable_print_counter
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called.
Definition: reference_counter.h:141
libMesh::FEContinuity
FEContinuity
Definition: enum_fe_family.h:77
libMesh::Elem::n_sides
virtual unsigned int n_sides() const =0
libMesh::PRISM18
Definition: enum_elem_type.h:52
libMesh::TRISHELL3
Definition: enum_elem_type.h:71
libMesh::Elem::node_ptr
const Node * node_ptr(const unsigned int i) const
Definition: elem.h:2009
libMesh::FEAbstract::FEAbstract
FEAbstract(const unsigned int dim, const FEType &fet)
Constructor.
Definition: fe_abstract.C:46
libMesh::FEGenericBase::d2phidx2
std::vector< std::vector< OutputShape > > d2phidx2
Shape function second derivatives in the x direction.
Definition: fe_base.h:585
libMesh::DofConstraintRow
std::map< dof_id_type, Real, std::less< dof_id_type >, Threads::scalable_allocator< std::pair< const dof_id_type, Real > > > DofConstraintRow
A row of the Dof constraint matrix.
Definition: dof_map.h:97
libMesh::Elem::which_neighbor_am_i
unsigned int which_neighbor_am_i(const Elem *e) const
This function tells you which neighbor e is.
Definition: elem.h:2323
libMesh::remote_elem
const RemoteElem * remote_elem
Definition: remote_elem.C:57
libMesh::FEAbstract::print_JxW
void print_JxW(std::ostream &os) const
Prints the Jacobian times the weight for each quadrature point.
Definition: fe_abstract.C:805
libMesh::TypesEqual
Definition: compare_types.h:51
libMesh::FEAbstract::calculate_d2phi
bool calculate_d2phi
Should we calculate shape function hessians?
Definition: fe_abstract.h:557
libMesh::FEGenericBase::weight
std::vector< Real > weight
Used for certain infinite element families: the additional radial weight in local coordinates,...
Definition: fe_base.h:642
libMesh::PYRAMID13
Definition: enum_elem_type.h:54
libMesh::Quality::name
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
libMesh::DenseVector< Number >
libMesh::PYRAMID14
Definition: enum_elem_type.h:55
libMesh::EDGE2
Definition: enum_elem_type.h:35
libMesh::QUAD8
Definition: enum_elem_type.h:42
libMesh::ElemType
ElemType
Defines an enum for geometric element types.
Definition: enum_elem_type.h:33
libMesh::TypeVector::absolute_fuzzy_equals
bool absolute_fuzzy_equals(const TypeVector< T > &rhs, Real tol=TOLERANCE) const
Definition: type_vector.h:1017
libMesh::NodeConstraintRow
std::map< const Node *, Real, std::less< const Node * >, Threads::scalable_allocator< std::pair< const Node *const, Real > > > NodeConstraintRow
A row of the Node constraint mapping.
Definition: dof_map.h:145
libMesh::FEInterface::shape
static Real shape(const unsigned int dim, const FEType &fe_t, const ElemType t, const unsigned int i, const Point &p)
Definition: fe_interface.C:687
Generated on Sat Jan 25 2020 12:07:46 for libMesh by   doxygen 1.8.16