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

#include <fe_abstract.h>

Inheritance diagram for libMesh::FEAbstract:

Public Member Functions
virtual	~FEAbstract ()
	Destructor.

virtual void	reinit (const Elem elem, const std::vector< Point > const pts=nullptr, const std::vector< Real > *const weights=nullptr)=0
	This is at the core of this class.

virtual void	reinit_dual_shape_coeffs (const Elem *, const std::vector< Point > &, const std::vector< Real > &)
	This re-computes the dual shape function coefficients using CUSTOMIZED qrule.

virtual void	reinit_default_dual_shape_coeffs (const Elem *)
	This re-computes the dual shape function coefficients using DEFAULT qrule.

virtual void	reinit (const Elem elem, const unsigned int side, const Real tolerance=TOLERANCE, const std::vector< Point > const pts=nullptr, const std::vector< Real > *const weights=nullptr)=0
	Reinitializes all the physical element-dependent data based on the `side` of the element `elem`.

virtual void	edge_reinit (const Elem elem, const unsigned int edge, const Real tolerance=TOLERANCE, const std::vector< Point > pts=nullptr, const std::vector< Real > *weights=nullptr)=0
	Reinitializes all the physical element-dependent data based on the `edge` of the element `elem`.

virtual void	side_map (const Elem elem, const Elem side, const unsigned int s, const std::vector< Point > &reference_side_points, std::vector< Point > &reference_points)=0
	Computes the reference space quadrature points on the side of an element based on the side quadrature points.

unsigned int	get_dim () const

void	get_nothing () const

virtual_for_inffe const std::vector< Point > &	get_xyz () const

virtual const std::vector< Real > &	get_JxWxdecay_sq () const
	This function is the variant of `get_JxW()` for `InfFE`.

virtual_for_inffe const std::vector< Real > &	get_JxW () const

virtual_for_inffe const std::vector< RealGradient > &	get_dxyzdxi () const

virtual_for_inffe const std::vector< RealGradient > &	get_dxyzdeta () const

virtual_for_inffe const std::vector< RealGradient > &	get_dxyzdzeta () const

virtual_for_inffe const std::vector< RealGradient > &	get_d2xyzdxi2 () const

virtual_for_inffe const std::vector< RealGradient > &	get_d2xyzdeta2 () const

virtual_for_inffe const std::vector< RealGradient > &	get_d2xyzdzeta2 () const

virtual_for_inffe const std::vector< RealGradient > &	get_d2xyzdxideta () const

virtual_for_inffe const std::vector< RealGradient > &	get_d2xyzdxidzeta () const

virtual_for_inffe const std::vector< RealGradient > &	get_d2xyzdetadzeta () const

virtual_for_inffe const std::vector< Real > &	get_dxidx () const

virtual_for_inffe const std::vector< Real > &	get_dxidy () const

virtual_for_inffe const std::vector< Real > &	get_dxidz () const

virtual_for_inffe const std::vector< Real > &	get_detadx () const

virtual_for_inffe const std::vector< Real > &	get_detady () const

virtual_for_inffe const std::vector< Real > &	get_detadz () const

virtual_for_inffe const std::vector< Real > &	get_dzetadx () const

virtual_for_inffe const std::vector< Real > &	get_dzetady () const

virtual_for_inffe const std::vector< Real > &	get_dzetadz () const

virtual_for_inffe const std::vector< std::vector< Point > > &	get_tangents () const

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

virtual_for_inffe const std::vector< Real > &	get_curvatures () const

virtual void	attach_quadrature_rule (QBase *q)=0
	Provides the class with the quadrature rule.

virtual unsigned int	n_shape_functions () const =0

virtual unsigned int	n_quadrature_points () const

const Elem *	get_elem () const

ElemType	get_type () const

unsigned int	get_p_level () const

FEType	get_fe_type () const

Order	get_order () const

void	set_fe_order (int new_order)
	Sets the base FE order of the finite element.

virtual FEContinuity	get_continuity () const =0

virtual bool	is_hierarchic () const =0

FEFamily	get_family () const

const FEMap &	get_fe_map () const

FEMap &	get_fe_map ()

void	print_JxW (std::ostream &os) const
	Prints the Jacobian times the weight for each quadrature point.

virtual void	print_phi (std::ostream &os) const =0
	Prints the value of each shape function at each quadrature point.

virtual void	print_dual_phi (std::ostream &os) const =0

virtual void	print_dphi (std::ostream &os) const =0
	Prints the value of each shape function's derivative at each quadrature point.

virtual void	print_dual_dphi (std::ostream &os) const =0

virtual void	print_d2phi (std::ostream &os) const =0
	Prints the value of each shape function's second derivatives at each quadrature point.

virtual void	print_dual_d2phi (std::ostream &os) const =0

void	print_xyz (std::ostream &os) const
	Prints the spatial location of each quadrature point (on the physical element).

void	print_info (std::ostream &os) const
	Prints all the relevant information about the current element.

virtual void	request_phi () const =0
	request phi calculations

virtual void	request_dual_phi () const =0

virtual void	request_dphi () const =0
	request dphi calculations

virtual void	request_dual_dphi () const =0

void	set_calculate_dual (const bool val)
	set calculate_dual as needed

void	set_calculate_default_dual_coeff (const bool val)
	set calculate_default_dual_coeff as needed

void	add_p_level_in_reinit (bool value)
	Indicate whether to add p-refinement levels in init/reinit methods.

bool	add_p_level_in_reinit () const
	Whether to add p-refinement levels in init/reinit methods.

Static Public Member Functions
static std::unique_ptr< FEAbstract >	build (const unsigned int dim, const FEType &type)
	Builds a specific finite element type.

static bool	on_reference_element (const Point &p, const ElemType t, const Real eps=TOLERANCE)

static void	get_refspace_nodes (const ElemType t, std::vector< Point > &nodes)

static void	compute_node_constraints (NodeConstraints &constraints, const Elem *elem)
	Computes the nodal constraint contributions (for non-conforming adapted meshes), using Lagrange geometry.

static void	compute_periodic_node_constraints (NodeConstraints &constraints, const PeriodicBoundaries &boundaries, const MeshBase &mesh, const PointLocatorBase point_locator, const Elem elem)
	Computes the node position constraint equation contributions (for meshes with periodic boundary conditions)

static std::string	get_info ()
	Gets a string containing the reference information.

static void	print_info (std::ostream &out_stream=libMesh::out)
	Prints the reference information, by default to `libMesh::out`.

static unsigned int	n_objects ()
	Prints the number of outstanding (created, but not yet destroyed) objects.

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

static void	disable_print_counter_info ()

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

Protected Member Functions
	FEAbstract (const unsigned int dim, const FEType &fet)
	Constructor.

virtual void	compute_shape_functions (const Elem *, const std::vector< Point > &)=0
	After having updated the jacobian and the transformation from local to global coordinates in `FEMap::compute_map()`, the first derivatives of the shape functions are transformed to global coordinates, giving `dphi`, `dphidx`, `dphidy`, and `dphidz`.

virtual bool	shapes_need_reinit () const =0

void	increment_constructor_count (const std::string &name) noexcept
	Increments the construction counter.

void	increment_destructor_count (const std::string &name) noexcept
	Increments the destruction counter.

Protected Attributes
std::unique_ptr< FEMap >	_fe_map

const unsigned int	dim
	The dimensionality of the object.

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

bool	calculate_dual
	Are we calculating dual basis?

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

bool	calculate_nothing
	Are we potentially deliberately calculating nothing?

bool	calculate_map
	Are we calculating mapping functions?

bool	calculate_phi
	Should we calculate shape functions?

bool	calculate_dphi
	Should we calculate shape function gradients?

bool	calculate_d2phi
	Should we calculate shape function hessians?

const bool	calculate_d2phi =false

bool	calculate_curl_phi
	Should we calculate shape function curls?

bool	calculate_div_phi
	Should we calculate shape function divergences?

bool	calculate_dphiref
	Should we calculate reference shape function gradients?

FEType	fe_type
	The finite element type for this object.

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

const Elem *	_elem
	The element the current data structures were set up for.

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

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

QBase *	qrule
	A pointer to the quadrature rule employed.

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

unsigned int	_n_total_qp
	The total number of quadrature points for the current configuration.

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

Static Protected Attributes
static Counts	_counts
	Actually holds the data.

static Threads::atomic< unsigned int >	_n_objects
	The number of objects.

static Threads::spin_mutex	_mutex
	Mutual exclusion object to enable thread-safe reference counting.

static bool	_enable_print_counter = true
	Flag to control whether reference count information is printed when print_info is called.

Friends
std::ostream &	operator<< (std::ostream &os, const FEAbstract &fe)
	Same as above, but allows you to print to a stream.

Detailed Description

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 FEAbstract::build() method to create an object of any of the derived classes.

Note: In the present design, the number of virtual members is kept to a minimum for performance reasons, although this is not based on rigorous profiling.

All calls to static members of the FE classes should be requested through the FEInterface. This interface class approximates runtime polymorphism for the templated finite element classes. Even internal library classes, like DofMap, request the number of DOFs through this interface class. This approach also enables the co-existence of various element-based schemes.

Author: Benjamin S. Kirk

Date: 2002

Definition at line 99 of file fe_abstract.h.

Member Typedef Documentation

◆ Counts

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

protectedinherited

Data structure to log the information.

The log is identified by the class name.

Definition at line 119 of file reference_counter.h.

Constructor & Destructor Documentation

◆ FEAbstract()

libMesh::FEAbstract::FEAbstract	(	const unsigned int	dim,
		const FEType &	fet
	)

protected

Constructor.

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

Definition at line 47 of file fe_abstract.C.

                                           :
  _fe_map( FEMap::build(fet) ),
  dim(d),
  calculations_started(false),
  calculate_dual(false),
  calculate_default_dual_coeff(true),
  calculate_nothing(false),
  calculate_map(false),
  calculate_phi(false),
  calculate_dphi(false),
  calculate_d2phi(false),
  calculate_curl_phi(false),
  calculate_div_phi(false),
  calculate_dphiref(false),
  fe_type(fet),
  _elem_type(INVALID_ELEM),
  _elem(nullptr),
  _elem_p_level(0),
  _p_level(0),
  qrule(nullptr),
  shapes_on_quadrature(false),
  _n_total_qp(0),
  _add_p_level_in_reinit(fet.p_refinement)
{
}

◆ ~FEAbstract()

libMesh::FEAbstract::~FEAbstract ( )

virtualdefault

Destructor.

Member Function Documentation

◆ add_p_level_in_reinit() [1/2]

bool libMesh::FEAbstract::add_p_level_in_reinit ( ) const

inline

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

Definition at line 636 of file fe_abstract.h.

636{ return _add_p_level_in_reinit; }

References _add_p_level_in_reinit.

◆ add_p_level_in_reinit() [2/2]

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

inline

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

Definition at line 631 of file fe_abstract.h.

631{ _add_p_level_in_reinit = value; }

value

static const bool value

Definition xdr_io.C:55

References _add_p_level_in_reinit, and value.

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

◆ attach_quadrature_rule()

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

pure virtual

Provides the class with the quadrature rule.

Implement this in derived classes.

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

◆ build()

std::unique_ptr< FEAbstract > libMesh::FEAbstract::build	(	const unsigned int	dim,
		const FEType &	type
	)

static

Builds a specific finite element type.

Returns: A std::unique_ptr<FEAbstract> to the FE object to prevent memory leaks.

Definition at line 78 of file fe_abstract.C.

{
  switch (dim)
    {
      // 0D
    case 0:
      {
        switch (fet.family)
          {
          case CLOUGH:
            return std::make_unique<FE<0,CLOUGH>>(fet);
 
          case HERMITE:
            return std::make_unique<FE<0,HERMITE>>(fet);
 
          case LAGRANGE:
            return std::make_unique<FE<0,LAGRANGE>>(fet);
 
          case LAGRANGE_VEC:
            return std::make_unique<FE<0,LAGRANGE_VEC>>(fet);
 
          case L2_LAGRANGE:
            return std::make_unique<FE<0,L2_LAGRANGE>>(fet);
 
          case L2_LAGRANGE_GLL:
            return std::make_unique<FE<0,L2_LAGRANGE_GLL>>(fet);
 
          case L2_LAGRANGE_VEC:
            return std::make_unique<FE<0,L2_LAGRANGE_VEC>>(fet);
 
          case HIERARCHIC_VEC:
            return std::make_unique<FE<0,HIERARCHIC_VEC>>(fet);
 
          case HIERARCHIC:
            return std::make_unique<FE<0,HIERARCHIC>>(fet);
 
          case L2_HIERARCHIC:
            return std::make_unique<FE<0,L2_HIERARCHIC>>(fet);
 
          case L2_HIERARCHIC_VEC:
            return std::make_unique<FE<0,L2_HIERARCHIC_VEC>>(fet);
 
          case SIDE_HIERARCHIC:
            return std::make_unique<FE<0,SIDE_HIERARCHIC>>(fet);
 
          case MONOMIAL:
            return std::make_unique<FE<0,MONOMIAL>>(fet);
 
          case MONOMIAL_VEC:
            return std::make_unique<FE<0,MONOMIAL_VEC>>(fet);
 
#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES
          case SZABAB:
            return std::make_unique<FE<0,SZABAB>>(fet);
 
          case BERNSTEIN:
            return std::make_unique<FE<0,BERNSTEIN>>(fet);
 
          case RATIONAL_BERNSTEIN:
            return std::make_unique<FE<0,RATIONAL_BERNSTEIN>>(fet);
#endif
 
          case XYZ:
            return std::make_unique<FEXYZ<0>>(fet);
 
          case SCALAR:
            return std::make_unique<FEScalar<0>>(fet);
 
          case NEDELEC_ONE:
            return std::make_unique<FENedelecOne<0>>(fet);
 
          case RAVIART_THOMAS:
            return std::make_unique<FERaviartThomas<0>>(fet);
 
          case L2_RAVIART_THOMAS:
            return std::make_unique<FEL2RaviartThomas<0>>(fet);
 
          case SUBDIVISION:
            return std::make_unique<FESubdivision>(fet);
 
          default:
            libmesh_error_msg("ERROR: Bad FEType.family= " << Utility::enum_to_string(fet.family));
          }
      }
      // 1D
    case 1:
      {
        switch (fet.family)
          {
          case CLOUGH:
            return std::make_unique<FE<1,CLOUGH>>(fet);
 
          case HERMITE:
            return std::make_unique<FE<1,HERMITE>>(fet);
 
          case LAGRANGE:
            return std::make_unique<FE<1,LAGRANGE>>(fet);
 
          case LAGRANGE_VEC:
            return std::make_unique<FE<1,LAGRANGE_VEC>>(fet);
 
          case L2_LAGRANGE:
            return std::make_unique<FE<1,L2_LAGRANGE>>(fet);
 
          case L2_LAGRANGE_GLL:
            return std::make_unique<FE<1,L2_LAGRANGE_GLL>>(fet);
 
          case L2_LAGRANGE_VEC:
            return std::make_unique<FE<1,L2_LAGRANGE_VEC>>(fet);
 
          case HIERARCHIC_VEC:
            return std::make_unique<FE<1,HIERARCHIC_VEC>>(fet);
 
          case HIERARCHIC:
            return std::make_unique<FE<1,HIERARCHIC>>(fet);
 
          case L2_HIERARCHIC:
            return std::make_unique<FE<1,L2_HIERARCHIC>>(fet);
 
          case L2_HIERARCHIC_VEC:
            return std::make_unique<FE<1,L2_HIERARCHIC_VEC>>(fet);
 
          case SIDE_HIERARCHIC:
            return std::make_unique<FE<1,SIDE_HIERARCHIC>>(fet);
 
          case MONOMIAL:
            return std::make_unique<FE<1,MONOMIAL>>(fet);
 
          case MONOMIAL_VEC:
            return std::make_unique<FE<1,MONOMIAL_VEC>>(fet);
 
#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES
          case SZABAB:
            return std::make_unique<FE<1,SZABAB>>(fet);
 
          case BERNSTEIN:
            return std::make_unique<FE<1,BERNSTEIN>>(fet);
 
          case RATIONAL_BERNSTEIN:
            return std::make_unique<FE<1,RATIONAL_BERNSTEIN>>(fet);
#endif
 
          case XYZ:
            return std::make_unique<FEXYZ<1>>(fet);
 
          case SCALAR:
            return std::make_unique<FEScalar<1>>(fet);
 
          case NEDELEC_ONE:
            return std::make_unique<FENedelecOne<1>>(fet);
 
          case RAVIART_THOMAS:
            return std::make_unique<FERaviartThomas<1>>(fet);
 
          case L2_RAVIART_THOMAS:
            return std::make_unique<FEL2RaviartThomas<1>>(fet);
 
          case SUBDIVISION:
            return std::make_unique<FESubdivision>(fet);
 
          default:
            libmesh_error_msg("ERROR: Bad FEType.family= " << Utility::enum_to_string(fet.family));
          }
      }
 
 
      // 2D
    case 2:
      {
        switch (fet.family)
          {
          case CLOUGH:
            return std::make_unique<FE<2,CLOUGH>>(fet);
 
          case HERMITE:
            return std::make_unique<FE<2,HERMITE>>(fet);
 
          case LAGRANGE:
            return std::make_unique<FE<2,LAGRANGE>>(fet);
 
          case LAGRANGE_VEC:
            return std::make_unique<FE<2,LAGRANGE_VEC>>(fet);
 
          case L2_LAGRANGE:
            return std::make_unique<FE<2,L2_LAGRANGE>>(fet);
 
          case L2_LAGRANGE_GLL:
            return std::make_unique<FE<2,L2_LAGRANGE_GLL>>(fet);
 
          case L2_LAGRANGE_VEC:
            return std::make_unique<FE<2,L2_LAGRANGE_VEC>>(fet);
 
          case HIERARCHIC_VEC:
            return std::make_unique<FE<2,HIERARCHIC_VEC>>(fet);
 
          case HIERARCHIC:
            return std::make_unique<FE<2,HIERARCHIC>>(fet);
 
          case L2_HIERARCHIC:
            return std::make_unique<FE<2,L2_HIERARCHIC>>(fet);
 
          case L2_HIERARCHIC_VEC:
            return std::make_unique<FE<2,L2_HIERARCHIC_VEC>>(fet);
 
          case SIDE_HIERARCHIC:
            return std::make_unique<FE<2,SIDE_HIERARCHIC>>(fet);
 
          case MONOMIAL:
            return std::make_unique<FE<2,MONOMIAL>>(fet);
 
          case MONOMIAL_VEC:
            return std::make_unique<FE<2,MONOMIAL_VEC>>(fet);
 
#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES
          case SZABAB:
            return std::make_unique<FE<2,SZABAB>>(fet);
 
          case BERNSTEIN:
            return std::make_unique<FE<2,BERNSTEIN>>(fet);
 
          case RATIONAL_BERNSTEIN:
            return std::make_unique<FE<2,RATIONAL_BERNSTEIN>>(fet);
#endif
 
          case XYZ:
            return std::make_unique<FEXYZ<2>>(fet);
 
          case SCALAR:
            return std::make_unique<FEScalar<2>>(fet);
 
          case NEDELEC_ONE:
            return std::make_unique<FENedelecOne<2>>(fet);
 
          case RAVIART_THOMAS:
            return std::make_unique<FERaviartThomas<2>>(fet);
 
          case L2_RAVIART_THOMAS:
            return std::make_unique<FEL2RaviartThomas<2>>(fet);
 
          case SUBDIVISION:
            return std::make_unique<FESubdivision>(fet);
 
          default:
            libmesh_error_msg("ERROR: Bad FEType.family= " << Utility::enum_to_string(fet.family));
          }
      }
 
 
      // 3D
    case 3:
      {
        switch (fet.family)
          {
          case CLOUGH:
            libmesh_error_msg("ERROR: Clough-Tocher elements currently only support 1D and 2D");
 
          case HERMITE:
            return std::make_unique<FE<3,HERMITE>>(fet);
 
          case LAGRANGE:
            return std::make_unique<FE<3,LAGRANGE>>(fet);
 
          case LAGRANGE_VEC:
            return std::make_unique<FE<3,LAGRANGE_VEC>>(fet);
 
          case L2_LAGRANGE:
            return std::make_unique<FE<3,L2_LAGRANGE>>(fet);
 
          case L2_LAGRANGE_GLL:
            return std::make_unique<FE<3,L2_LAGRANGE_GLL>>(fet);
 
          case L2_LAGRANGE_VEC:
            return std::make_unique<FE<3,L2_LAGRANGE_VEC>>(fet);
 
          case HIERARCHIC_VEC:
            return std::make_unique<FE<3,HIERARCHIC_VEC>>(fet);
 
          case HIERARCHIC:
            return std::make_unique<FE<3,HIERARCHIC>>(fet);
 
          case L2_HIERARCHIC:
            return std::make_unique<FE<3,L2_HIERARCHIC>>(fet);
 
          case L2_HIERARCHIC_VEC:
            return std::make_unique<FE<3,L2_HIERARCHIC_VEC>>(fet);
 
          case SIDE_HIERARCHIC:
            return std::make_unique<FE<3,SIDE_HIERARCHIC>>(fet);
 
          case MONOMIAL:
            return std::make_unique<FE<3,MONOMIAL>>(fet);
 
          case MONOMIAL_VEC:
            return std::make_unique<FE<3,MONOMIAL_VEC>>(fet);
 
#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES
          case SZABAB:
            return std::make_unique<FE<3,SZABAB>>(fet);
 
          case BERNSTEIN:
            return std::make_unique<FE<3,BERNSTEIN>>(fet);
 
          case RATIONAL_BERNSTEIN:
            return std::make_unique<FE<3,RATIONAL_BERNSTEIN>>(fet);
#endif
 
          case XYZ:
            return std::make_unique<FEXYZ<3>>(fet);
 
          case SCALAR:
            return std::make_unique<FEScalar<3>>(fet);
 
          case NEDELEC_ONE:
            return std::make_unique<FENedelecOne<3>>(fet);
 
          case RAVIART_THOMAS:
            return std::make_unique<FERaviartThomas<3>>(fet);
 
          case L2_RAVIART_THOMAS:
            return std::make_unique<FEL2RaviartThomas<3>>(fet);
 
          default:
            libmesh_error_msg("ERROR: Bad FEType.family= " << Utility::enum_to_string(fet.family));
          }
      }
 
    default:
      libmesh_error_msg("Invalid dimension dim = " << dim);
    }
}

References libMesh::BERNSTEIN, libMesh::CLOUGH, dim, libMesh::Utility::enum_to_string(), libMesh::FEType::family, libMesh::HERMITE, libMesh::HIERARCHIC, libMesh::HIERARCHIC_VEC, libMesh::L2_HIERARCHIC, libMesh::L2_HIERARCHIC_VEC, libMesh::L2_LAGRANGE, libMesh::L2_LAGRANGE_GLL, libMesh::L2_LAGRANGE_VEC, libMesh::L2_RAVIART_THOMAS, libMesh::LAGRANGE, libMesh::LAGRANGE_VEC, libMesh::MONOMIAL, libMesh::MONOMIAL_VEC, libMesh::NEDELEC_ONE, libMesh::RATIONAL_BERNSTEIN, libMesh::RAVIART_THOMAS, libMesh::SCALAR, libMesh::SIDE_HIERARCHIC, libMesh::SUBDIVISION, libMesh::SZABAB, and libMesh::XYZ.

Referenced by libMesh::DGFEMContext::DGFEMContext(), libMesh::JumpErrorEstimator::estimate_error(), and libMesh::FEMContext::init_internal_data().

◆ compute_node_constraints()

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

static

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

Definition at line 898 of file fe_abstract.C.

{
  libmesh_assert(elem);
 
  const unsigned int Dim = elem->dim();
 
  // Only constrain elements in 2,3D.
  if (Dim == 1)
    return;
 
  // Only constrain active and ancestor elements
  if (elem->subactive())
    return;
 
 
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
  if (elem->infinite())
    {
      const FEType fe_t(elem->default_order(), FEMap::map_fe_type(*elem));
 
      // expand the infinite_compute_constraint in its template-arguments.
      switch(Dim)
      {
         case 2:
            {
            inf_fe_family_mapping_switch(2, inf_compute_node_constraints (constraints, elem) , ,; break;);
            break;
          }
         case 3:
            {
            inf_fe_family_mapping_switch(3, inf_compute_node_constraints (constraints, elem) , ,; break;);
            break;
            }
         default:
           libmesh_error_msg("Invalid dim = " << Dim);
      }
      return;
    }
 
#endif
  const FEFamily mapping_family = FEMap::map_fe_type(*elem);
  const FEType fe_type(elem->default_side_order(), mapping_family);
 
  // Pull objects out of the loop to reduce heap operations
  std::vector<const Node *> my_nodes, parent_nodes;
  std::unique_ptr<const Elem> my_side, parent_side;
 
  // Look at the element faces.  Check to see if we need to
  // build constraints.
  for (auto s : elem->side_index_range())
    if (elem->neighbor_ptr(s) != nullptr &&
        elem->neighbor_ptr(s) != remote_elem)
      if (elem->neighbor_ptr(s)->level() < elem->level()) // constrain dofs shared between
        {                                                 // this element and ones coarser
          // than this element.
          // Get pointers to the elements of interest and its parent.
          const Elem * parent = elem->parent();
 
          // This can't happen...  Only level-0 elements have nullptr
          // parents, and no level-0 elements can be at a higher
          // level than their neighbors!
          libmesh_assert(parent);
 
          elem->build_side_ptr(my_side, s);
          parent->build_side_ptr(parent_side, s);
 
          const unsigned int n_side_nodes = my_side->n_nodes();
 
          my_nodes.clear();
          my_nodes.reserve (n_side_nodes);
          parent_nodes.clear();
          parent_nodes.reserve (n_side_nodes);
 
          for (unsigned int n=0; n != n_side_nodes; ++n)
            my_nodes.push_back(my_side->node_ptr(n));
 
          for (unsigned int n=0; n != n_side_nodes; ++n)
            parent_nodes.push_back(parent_side->node_ptr(n));
 
          for (unsigned int my_side_n=0;
               my_side_n < n_side_nodes;
               my_side_n++)
            {
              // We can have an FE type that supports an order
              // partially, such that sides do not support the same
              // order.  E.g. we say that a LAGRANGE PRISM21 supports
              // "third" order to distinguish its shape functions from
              // a PRISM18, but the QUAD9 sides will still only
              // support second order.
              FEType side_fe_type = fe_type;
              const int side_max_order =
                FEInterface::max_order(fe_type, my_side->type());
 
              if ((int)fe_type.order > side_max_order)
                side_fe_type.order = side_max_order;
 
              // Do not use the p_level(), if any, that is inherited by the side.
              libmesh_assert_less
                (my_side_n,
                 FEInterface::n_dofs(side_fe_type, /*extra_order=*/0,
                                     my_side.get()));
 
              const Node * my_node = my_nodes[my_side_n];
 
              // The support point of the DOF
              const Point & support_point = *my_node;
 
              // Figure out where my node lies on their reference element.
              const Point mapped_point = FEMap::inverse_map(Dim-1,
                                                            parent_side.get(),
                                                            support_point);
 
              // Compute the parent's side shape function values.
              for (unsigned int their_side_n=0;
                   their_side_n < n_side_nodes;
                   their_side_n++)
                {
                  // Do not use the p_level(), if any, that is inherited by the side.
                  libmesh_assert_less
                    (their_side_n,
                     FEInterface::n_dofs(side_fe_type,
                                         /*extra_order=*/0,
                                         parent_side.get()));
 
                  const Node * their_node = parent_nodes[their_side_n];
                  libmesh_assert(their_node);
 
                  // Do not use the p_level(), if any, that is inherited by the side.
                  const Real their_value = FEInterface::shape(side_fe_type,
                                                              /*extra_order=*/0,
                                                              parent_side.get(),
                                                              their_side_n,
                                                              mapped_point);
 
                  const Real their_mag = std::abs(their_value);
#ifdef DEBUG
                  // Protect for the case u_i ~= u_j,
                  // in which case i better equal j.
                  if (their_mag > 0.999)
                    {
                      libmesh_assert_equal_to (my_node, their_node);
                      libmesh_assert_less (std::abs(their_value - 1.), 0.001);
                    }
                  else
#endif
                    // To make nodal constraints useful for constructing
                    // sparsity patterns faster, we need to get EVERY
                    // POSSIBLE constraint coupling identified, even if
                    // there is no coupling in the isoparametric
                    // Lagrange case.
                    if (their_mag < 1.e-5)
                      {
                        // since we may be running this method concurrently
                        // on multiple threads we need to acquire a lock
                        // before modifying the shared constraint_row object.
                        Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
 
                        // A reference to the constraint row.
                        NodeConstraintRow & constraint_row = constraints[my_node].first;
 
                        constraint_row.emplace(their_node, 0.);
                      }
                  // To get nodal coordinate constraints right, only
                  // add non-zero and non-identity values for Lagrange
                  // basis functions.
                    else // (1.e-5 <= their_mag <= .999)
                      {
                        // since we may be running this method concurrently
                        // on multiple threads we need to acquire a lock
                        // before modifying the shared constraint_row object.
                        Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
 
                        // A reference to the constraint row.
                        NodeConstraintRow & constraint_row = constraints[my_node].first;
 
                        constraint_row.emplace(their_node, their_value);
                      }
                }
            }
        }
}

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

◆ compute_periodic_node_constraints()

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

static

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

Definition at line 1090 of file fe_abstract.C.

{
  // Only bother if we truly have periodic boundaries
  if (boundaries.empty())
    return;
 
  libmesh_assert(elem);
 
  // Only constrain active elements with this method
  if (!elem->active())
    return;
 
  const unsigned int Dim = elem->dim();
 
  const FEFamily mapping_family = FEMap::map_fe_type(*elem);
  const FEType fe_type(elem->default_side_order(), mapping_family);
 
  // Pull objects out of the loop to reduce heap operations
  std::vector<const Node *> my_nodes, neigh_nodes;
  std::unique_ptr<const Elem> my_side, neigh_side;
 
  // Look at the element faces.  Check to see if we need to
  // build constraints.
  std::vector<boundary_id_type> bc_ids;
  for (auto s : elem->side_index_range())
    {
      if (elem->neighbor_ptr(s))
        continue;
 
      mesh.get_boundary_info().boundary_ids (elem, s, bc_ids);
      for (const auto & boundary_id : bc_ids)
        {
          const PeriodicBoundaryBase * periodic = boundaries.boundary(boundary_id);
          if (periodic)
            {
              libmesh_assert(point_locator);
 
              // Get pointers to the element's neighbor.
              unsigned int s_neigh;
              const Elem * neigh = boundaries.neighbor(boundary_id, *point_locator, elem, s, &s_neigh);
 
              libmesh_error_msg_if
                (!neigh, "PeriodicBoundaries can't find a periodic neighbor for element " <<
                         elem->id() << " side " << s);
 
              // h refinement constraints:
              // constrain dofs shared between
              // this element and ones as coarse
              // as or coarser than this element.
              if (neigh->level() <= elem->level())
                {
#ifdef LIBMESH_ENABLE_AMR
                  libmesh_assert(neigh->active());
#endif // #ifdef LIBMESH_ENABLE_AMR
 
                  elem->build_side_ptr(my_side, s);
                  neigh->build_side_ptr(neigh_side, s_neigh);
 
                  const unsigned int n_side_nodes = my_side->n_nodes();
 
                  my_nodes.clear();
                  my_nodes.reserve (n_side_nodes);
                  neigh_nodes.clear();
                  neigh_nodes.reserve (n_side_nodes);
 
                  for (unsigned int n=0; n != n_side_nodes; ++n)
                    my_nodes.push_back(my_side->node_ptr(n));
 
                  for (unsigned int n=0; n != n_side_nodes; ++n)
                    neigh_nodes.push_back(neigh_side->node_ptr(n));
 
                  // Make sure we're not adding recursive constraints
                  // due to the redundancy in the way we add periodic
                  // boundary constraints, or adding constraints to
                  // nodes that already have AMR constraints
                  std::vector<bool> skip_constraint(n_side_nodes, false);
 
                  for (unsigned int my_side_n=0;
                       my_side_n < n_side_nodes;
                       my_side_n++)
                    {
                      // Do not use the p_level(), if any, that is inherited by the side.
                      libmesh_assert_less (my_side_n, FEInterface::n_dofs(fe_type, /*extra_order=*/0, my_side.get()));
 
                      const Node * my_node = my_nodes[my_side_n];
 
                      // If we've already got a constraint on this
                      // node, then the periodic constraint is
                      // redundant
                      {
                        Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
 
                        if (constraints.count(my_node))
                          {
                            skip_constraint[my_side_n] = true;
                            continue;
                          }
                      }
 
                      // Compute the neighbors's side shape function values.
                      for (unsigned int their_side_n=0;
                           their_side_n < n_side_nodes;
                           their_side_n++)
                        {
                          // Do not use the p_level(), if any, that is inherited by the side.
                          libmesh_assert_less (their_side_n, FEInterface::n_dofs(fe_type, /*extra_order=*/0, neigh_side.get()));
 
                          const Node * their_node = neigh_nodes[their_side_n];
 
                          // If there's a constraint on an opposing node,
                          // we need to see if it's constrained by
                          // *our side* making any periodic constraint
                          // on us recursive
                          {
                            Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
 
                            if (!constraints.count(their_node))
                              continue;
 
                            const NodeConstraintRow & their_constraint_row =
                              constraints[their_node].first;
 
                            for (unsigned int orig_side_n=0;
                                 orig_side_n < n_side_nodes;
                                 orig_side_n++)
                              {
                                // Do not use the p_level(), if any, that is inherited by the side.
                                libmesh_assert_less (orig_side_n, FEInterface::n_dofs(fe_type, /*extra_order=*/0, my_side.get()));
 
                                const Node * orig_node = my_nodes[orig_side_n];
 
                                if (their_constraint_row.count(orig_node))
                                  skip_constraint[orig_side_n] = true;
                              }
                          }
                        }
                    }
                  for (unsigned int my_side_n=0;
                       my_side_n < n_side_nodes;
                       my_side_n++)
                    {
                      // Do not use the p_level(), if any, that is inherited by the side.
                      libmesh_assert_less (my_side_n, FEInterface::n_dofs(fe_type, /*extra_order=*/0, my_side.get()));
 
                      if (skip_constraint[my_side_n])
                        continue;
 
                      const Node * my_node = my_nodes[my_side_n];
 
                      // Figure out where my node lies on their reference element.
                      const Point neigh_point = periodic->get_corresponding_pos(*my_node);
 
                      // Figure out where my node lies on their reference element.
                      const Point mapped_point =
                        FEMap::inverse_map(Dim-1, neigh_side.get(),
                                           neigh_point);
 
                      for (unsigned int their_side_n=0;
                           their_side_n < n_side_nodes;
                           their_side_n++)
                        {
                          // Do not use the p_level(), if any, that is inherited by the side.
                          libmesh_assert_less (their_side_n, FEInterface::n_dofs(fe_type, /*extra_order=*/0, neigh_side.get()));
 
                          const Node * their_node = neigh_nodes[their_side_n];
                          libmesh_assert(their_node);
 
                          // Do not use the p_level(), if any, that is inherited by the side.
                          const Real their_value = FEInterface::shape(fe_type,
                                                                      /*extra_order=*/0,
                                                                      neigh_side.get(),
                                                                      their_side_n,
                                                                      mapped_point);
 
                          // since we may be running this method concurrently
                          // on multiple threads we need to acquire a lock
                          // before modifying the shared constraint_row object.
                          {
                            Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
 
                            NodeConstraintRow & constraint_row =
                              constraints[my_node].first;
 
                            constraint_row.emplace(their_node, their_value);
                          }
                        }
                    }
                }
            }
        }
    }
}

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

◆ compute_shape_functions()

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

protectedpure virtual

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

This method should rarely be re-defined in derived classes, but still should be usable for children. Therefore, keep it protected. This needs to be implemented in the derived class since this function depends on whether the shape functions are vector-valued or not.

Implemented in libMesh::InfFE< Dim, T_radial, T_map >, libMesh::FEXYZ< Dim >, libMesh::FEGenericBase< OutputType >, and libMesh::FEGenericBase< FEOutputType< T >::type >.

◆ disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

Definition at line 100 of file reference_counter.C.

{
  _enable_print_counter = false;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

◆ edge_reinit()

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

pure virtual

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.

◆ enable_print_counter_info()

void libMesh::ReferenceCounter::enable_print_counter_info ( )

staticinherited

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

Enabled by default.

Definition at line 94 of file reference_counter.C.

{
  _enable_print_counter = true;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

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

◆ get_continuity()

virtual FEContinuity libMesh::FEAbstract::get_continuity ( ) const

pure virtual

Returns: The continuity level of the finite element.

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

◆ get_curvatures()

virtual_for_inffe const std::vector< Real > & libMesh::FEAbstract::get_curvatures ( ) const

inline

Returns: The curvatures for use in face integration.

Definition at line 467 of file fe_abstract.h.

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

References _fe_map, and calculate_map.

◆ get_d2xyzdeta2()

virtual_for_inffe const std::vector< RealGradient > & libMesh::FEAbstract::get_d2xyzdeta2 ( ) const

inline

Returns: The second partial derivatives in eta.

Definition at line 343 of file fe_abstract.h.

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

References _fe_map, and calculate_map.

◆ get_d2xyzdetadzeta()

virtual_for_inffe const std::vector< RealGradient > & libMesh::FEAbstract::get_d2xyzdetadzeta ( ) const

inline

Returns: The second partial derivatives in eta-zeta.

Definition at line 371 of file fe_abstract.h.

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

References _fe_map, and calculate_map.

◆ get_d2xyzdxi2()

virtual_for_inffe const std::vector< RealGradient > & libMesh::FEAbstract::get_d2xyzdxi2 ( ) const

inline

Returns: The second partial derivatives in xi.

Definition at line 336 of file fe_abstract.h.

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

References _fe_map, and calculate_map.

◆ get_d2xyzdxideta()

virtual_for_inffe const std::vector< RealGradient > & libMesh::FEAbstract::get_d2xyzdxideta ( ) const

inline

Returns: The second partial derivatives in xi-eta.

Definition at line 357 of file fe_abstract.h.

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

References _fe_map, and calculate_map.

◆ get_d2xyzdxidzeta()

virtual_for_inffe const std::vector< RealGradient > & libMesh::FEAbstract::get_d2xyzdxidzeta ( ) const

inline

Returns: The second partial derivatives in xi-zeta.

Definition at line 364 of file fe_abstract.h.

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

References _fe_map, and calculate_map.

◆ get_d2xyzdzeta2()

virtual_for_inffe const std::vector< RealGradient > & libMesh::FEAbstract::get_d2xyzdzeta2 ( ) const

inline

Returns: The second partial derivatives in zeta.

Definition at line 350 of file fe_abstract.h.

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

References _fe_map, and calculate_map.

◆ get_detadx()

virtual_for_inffe const std::vector< Real > & libMesh::FEAbstract::get_detadx ( ) const

inline

Returns: The deta/dx entry in the transformation matrix from physical to local coordinates.

Definition at line 405 of file fe_abstract.h.

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

References _fe_map, and calculate_map.

◆ get_detady()

virtual_for_inffe const std::vector< Real > & libMesh::FEAbstract::get_detady ( ) const

inline

Returns: The deta/dy entry in the transformation matrix from physical to local coordinates.

Definition at line 413 of file fe_abstract.h.

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

References _fe_map, and calculate_map.

◆ get_detadz()

virtual_for_inffe const std::vector< Real > & libMesh::FEAbstract::get_detadz ( ) const

inline

Returns: The deta/dz entry in the transformation matrix from physical to local coordinates.

Definition at line 421 of file fe_abstract.h.

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

References _fe_map, and calculate_map.

◆ get_dim()

unsigned int libMesh::FEAbstract::get_dim ( ) const

inline

Returns: the dimension of this FE

Definition at line 258 of file fe_abstract.h.

259 { return dim; }

References dim.

◆ get_dxidx()

virtual_for_inffe const std::vector< Real > & libMesh::FEAbstract::get_dxidx ( ) const

inline

Returns: The dxi/dx entry in the transformation matrix from physical to local coordinates.

Definition at line 381 of file fe_abstract.h.

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

References _fe_map, and calculate_map.

◆ get_dxidy()

virtual_for_inffe const std::vector< Real > & libMesh::FEAbstract::get_dxidy ( ) const

inline

Returns: The dxi/dy entry in the transformation matrix from physical to local coordinates.

Definition at line 389 of file fe_abstract.h.

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

References _fe_map, and calculate_map.

◆ get_dxidz()

virtual_for_inffe const std::vector< Real > & libMesh::FEAbstract::get_dxidz ( ) const

inline

Returns: The dxi/dz entry in the transformation matrix from physical to local coordinates.

Definition at line 397 of file fe_abstract.h.

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

References _fe_map, and calculate_map.

◆ get_dxyzdeta()

virtual_for_inffe const std::vector< RealGradient > & libMesh::FEAbstract::get_dxyzdeta ( ) const

inline

Returns: The element tangents in eta-direction at the quadrature points.

Definition at line 319 of file fe_abstract.h.

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

References _fe_map, and calculate_map.

◆ get_dxyzdxi()

virtual_for_inffe const std::vector< RealGradient > & libMesh::FEAbstract::get_dxyzdxi ( ) const

inline

Returns: The element tangents in xi-direction at the quadrature points.

Definition at line 311 of file fe_abstract.h.

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

References _fe_map, and calculate_map.

◆ get_dxyzdzeta()

virtual_for_inffe const std::vector< RealGradient > & libMesh::FEAbstract::get_dxyzdzeta ( ) const

inline

Returns: The element tangents in zeta-direction at the quadrature points.

Definition at line 327 of file fe_abstract.h.

328 { return _fe_map->get_dxyzdzeta(); }

References _fe_map.

◆ get_dzetadx()

virtual_for_inffe const std::vector< Real > & libMesh::FEAbstract::get_dzetadx ( ) const

inline

Returns: The dzeta/dx entry in the transformation matrix from physical to local coordinates.

Definition at line 429 of file fe_abstract.h.

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

References _fe_map, and calculate_map.

◆ get_dzetady()

virtual_for_inffe const std::vector< Real > & libMesh::FEAbstract::get_dzetady ( ) const

inline

Returns: The dzeta/dy entry in the transformation matrix from physical to local coordinates.

Definition at line 437 of file fe_abstract.h.

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

References _fe_map, and calculate_map.

◆ get_dzetadz()

virtual_for_inffe const std::vector< Real > & libMesh::FEAbstract::get_dzetadz ( ) const

inline

Returns: The dzeta/dz entry in the transformation matrix from physical to local coordinates.

Definition at line 445 of file fe_abstract.h.

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

References _fe_map, and calculate_map.

◆ get_elem()

const Elem * libMesh::FEAbstract::get_elem ( ) const

inline

Returns: The element that the current shape functions have been calculated for. Useful in determining when shape functions must be recomputed.

Definition at line 496 of file fe_abstract.h.

496{ return _elem; }

References _elem.

◆ get_family()

FEFamily libMesh::FEAbstract::get_family ( ) const

inline

Returns: The finite element family of this element.

Definition at line 547 of file fe_abstract.h.

547{ return fe_type.family; }

libMesh::FEType::family

FEFamily family

The type of finite element.

Definition fe_type.h:228

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

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

◆ get_fe_map() [1/2]

FEMap & libMesh::FEAbstract::get_fe_map ( )

inline

Definition at line 555 of file fe_abstract.h.

555{ return *_fe_map.get(); }

References _fe_map.

◆ get_fe_map() [2/2]

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

inline

Returns: The mapping object

Note: for InfFE, this gives a useless object.

Definition at line 554 of file fe_abstract.h.

554{ return *_fe_map.get(); }

References _fe_map.

◆ get_fe_type()

FEType libMesh::FEAbstract::get_fe_type ( ) const

inline

Returns: The FE Type (approximation order and family) of the finite element.

Definition at line 520 of file fe_abstract.h.

520{ return fe_type; }

References fe_type.

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

◆ get_info()

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

staticinherited

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

{
#if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
 
  std::ostringstream oss;
 
  oss << '\n'
      << " ---------------------------------------------------------------------------- \n"
      << "| Reference count information                                                |\n"
      << " ---------------------------------------------------------------------------- \n";
 
  for (const auto & [name, cd] : _counts)
    oss << "| " << name << " reference count information:\n"
        << "|  Creations:    " << cd.first    << '\n'
        << "|  Destructions: " << cd.second << '\n';
 
  oss << " ---------------------------------------------------------------------------- \n";
 
  return oss.str();
 
#else
 
  return "";
 
#endif
}

References libMesh::ReferenceCounter::_counts.

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

◆ get_JxW()

virtual_for_inffe const std::vector< Real > & libMesh::FEAbstract::get_JxW ( ) const

inline

Returns: The element Jacobian times the quadrature weight for each quadrature point.

For InfFE, use get_JxWxdecay_sq() instead.

Definition at line 303 of file fe_abstract.h.

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

References _fe_map, and calculate_map.

◆ get_JxWxdecay_sq()

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

inlinevirtual

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

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

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

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

Definition at line 292 of file fe_abstract.h.

293 { return get_JxW();}

libMesh::FEAbstract::get_JxW

virtual_for_inffe const std::vector< Real > & get_JxW() const

Definition fe_abstract.h:303

References get_JxW().

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

◆ get_normals()

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

inline

Returns: The outward pointing normal vectors for face integration.

Definition at line 459 of file fe_abstract.h.

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

References _fe_map, and calculate_map.

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

◆ get_nothing()

void libMesh::FEAbstract::get_nothing ( ) const

inline

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

Definition at line 269 of file fe_abstract.h.

270 { calculate_nothing = true; }

References calculate_nothing.

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

◆ get_order()

Order libMesh::FEAbstract::get_order ( ) const

inline

Returns: The approximation order of the finite element.

Definition at line 525 of file fe_abstract.h.

526 { return fe_type.order + _p_level; }

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

◆ get_p_level()

unsigned int libMesh::FEAbstract::get_p_level ( ) const

inline

Returns: The p refinement level that the current shape functions have been calculated for.

Definition at line 515 of file fe_abstract.h.

515{ return _p_level; }

References _p_level.

◆ get_refspace_nodes()

void libMesh::FEAbstract::get_refspace_nodes	(	const ElemType	t,
		std::vector< Point > &	nodes
	)

static

Returns: The reference space coordinates of nodes based on the element type.

Definition at line 412 of file fe_abstract.C.

{
  const unsigned int n_nodes = Elem::type_to_n_nodes_map[itemType];
  if (n_nodes == invalid_uint)
    libmesh_error_msg("Number of nodes is not well-defined for " <<
                      Utility::enum_to_string(itemType));
 
  nodes.resize(n_nodes);
  switch(itemType)
    {
    case NODEELEM:
      {
        nodes[0] = Point (0.,0.,0.);
        return;
      }
    case EDGE3:
      {
        nodes[2] = Point (0.,0.,0.);
        libmesh_fallthrough();
      }
    case EDGE2:
      {
        nodes[0] = Point (-1.,0.,0.);
        nodes[1] = Point (1.,0.,0.);
        return;
      }
    case EDGE4: // not nested with EDGE3
      {
        nodes[0] = Point (-1.,0.,0.);
        nodes[1] = Point (1.,0.,0.);
        nodes[2] = Point (-1./3.,0.,0.);
        nodes[3] = Point (1./3.,0.,0.);
        return;
      }
    case TRI7:
      {
        nodes[6] = Point (1./3.,1./3.,0.);
        libmesh_fallthrough();
      }
    case TRI6:
      {
        nodes[3] = Point (.5,0.,0.);
        nodes[4] = Point (.5,.5,0.);
        nodes[5] = Point (0.,.5,0.);
        libmesh_fallthrough();
      }
    case TRI3:
    case TRISHELL3:
      {
        nodes[0] = Point (0.,0.,0.);
        nodes[1] = Point (1.,0.,0.);
        nodes[2] = Point (0.,1.,0.);
        return;
      }
    case QUAD9:
    case QUADSHELL9:
      {
        nodes[8] = Point (0.,0.,0.);
        libmesh_fallthrough();
      }
    case QUAD8:
    case QUADSHELL8:
      {
        nodes[4] = Point (0.,-1.,0.);
        nodes[5] = Point (1.,0.,0.);
        nodes[6] = Point (0.,1.,0.);
        nodes[7] = Point (-1.,0.,0.);
        libmesh_fallthrough();
      }
    case QUAD4:
    case QUADSHELL4:
      {
        nodes[0] = Point (-1.,-1.,0.);
        nodes[1] = Point (1.,-1.,0.);
        nodes[2] = Point (1.,1.,0.);
        nodes[3] = Point (-1.,1.,0.);
        return;
      }
    case TET14:
      {
        nodes[10] = Point (1/Real(3),1/Real(3),0.);
        nodes[11] = Point (1/Real(3),0.,1/Real(3));
        nodes[12] = Point (1/Real(3),1/Real(3),1/Real(3));
        nodes[13] = Point (0.,1/Real(3),1/Real(3));
        libmesh_fallthrough();
      }
    case TET10:
      {
        nodes[4] = Point (.5,0.,0.);
        nodes[5] = Point (.5,.5,0.);
        nodes[6] = Point (0.,.5,0.);
        nodes[7] = Point (0.,0.,.5);
        nodes[8] = Point (.5,0.,.5);
        nodes[9] = Point (0.,.5,.5);
        libmesh_fallthrough();
      }
    case TET4:
      {
        nodes[0] = Point (0.,0.,0.);
        nodes[1] = Point (1.,0.,0.);
        nodes[2] = Point (0.,1.,0.);
        nodes[3] = Point (0.,0.,1.);
        return;
      }
    case HEX27:
      {
        nodes[20] = Point (0.,0.,-1.);
        nodes[21] = Point (0.,-1.,0.);
        nodes[22] = Point (1.,0.,0.);
        nodes[23] = Point (0.,1.,0.);
        nodes[24] = Point (-1.,0.,0.);
        nodes[25] = Point (0.,0.,1.);
        nodes[26] = Point (0.,0.,0.);
        libmesh_fallthrough();
      }
    case HEX20:
      {
        nodes[8] = Point (0.,-1.,-1.);
        nodes[9] = Point (1.,0.,-1.);
        nodes[10] = Point (0.,1.,-1.);
        nodes[11] = Point (-1.,0.,-1.);
        nodes[12] = Point (-1.,-1.,0.);
        nodes[13] = Point (1.,-1.,0.);
        nodes[14] = Point (1.,1.,0.);
        nodes[15] = Point (-1.,1.,0.);
        nodes[16] = Point (0.,-1.,1.);
        nodes[17] = Point (1.,0.,1.);
        nodes[18] = Point (0.,1.,1.);
        nodes[19] = Point (-1.,0.,1.);
        libmesh_fallthrough();
      }
    case HEX8:
      {
        nodes[0] = Point (-1.,-1.,-1.);
        nodes[1] = Point (1.,-1.,-1.);
        nodes[2] = Point (1.,1.,-1.);
        nodes[3] = Point (-1.,1.,-1.);
        nodes[4] = Point (-1.,-1.,1.);
        nodes[5] = Point (1.,-1.,1.);
        nodes[6] = Point (1.,1.,1.);
        nodes[7] = Point (-1.,1.,1.);
        return;
      }
    case PRISM21:
      {
        nodes[20] = Point (1/Real(3),1/Real(3),0);
        libmesh_fallthrough();
      }
    case PRISM20:
      {
        nodes[18] = Point (1/Real(3),1/Real(3),-1);
        nodes[19] = Point (1/Real(3),1/Real(3),1);
        libmesh_fallthrough();
      }
    case PRISM18:
      {
        nodes[15] = Point (.5,0.,0.);
        nodes[16] = Point (.5,.5,0.);
        nodes[17] = Point (0.,.5,0.);
        libmesh_fallthrough();
      }
    case PRISM15:
      {
        nodes[6] = Point (.5,0.,-1.);
        nodes[7] = Point (.5,.5,-1.);
        nodes[8] = Point (0.,.5,-1.);
        nodes[9] = Point (0.,0.,0.);
        nodes[10] = Point (1.,0.,0.);
        nodes[11] = Point (0.,1.,0.);
        nodes[12] = Point (.5,0.,1.);
        nodes[13] = Point (.5,.5,1.);
        nodes[14] = Point (0.,.5,1.);
        libmesh_fallthrough();
      }
    case PRISM6:
      {
        nodes[0] = Point (0.,0.,-1.);
        nodes[1] = Point (1.,0.,-1.);
        nodes[2] = Point (0.,1.,-1.);
        nodes[3] = Point (0.,0.,1.);
        nodes[4] = Point (1.,0.,1.);
        nodes[5] = Point (0.,1.,1.);
        return;
      }
    case PYRAMID18:
      {
        // triangle centers
        nodes[14] = Point (0., -2/Real(3),1/Real(3));
        nodes[15] = Point (2/Real(3),0.,1/Real(3));
        nodes[16] = Point (0.,2/Real(3),1/Real(3));
        nodes[17] = Point (-2/Real(3),0.,1/Real(3));
 
        libmesh_fallthrough();
      }
    case PYRAMID14:
      {
        // base center
        nodes[13] = Point (0.,0.,0.);
 
        libmesh_fallthrough();
      }
    case PYRAMID13:
      {
        // base midedge
        nodes[5] = Point (0.,-1.,0.);
        nodes[6] = Point (1.,0.,0.);
        nodes[7] = Point (0.,1.,0.);
        nodes[8] = Point (-1,0.,0.);
 
        // lateral midedge
        nodes[9] = Point (-.5,-.5,.5);
        nodes[10] = Point (.5,-.5,.5);
        nodes[11] = Point (.5,.5,.5);
        nodes[12] = Point (-.5,.5,.5);
 
        libmesh_fallthrough();
      }
    case PYRAMID5:
      {
        // base corners
        nodes[0] = Point (-1.,-1.,0.);
        nodes[1] = Point (1.,-1.,0.);
        nodes[2] = Point (1.,1.,0.);
        nodes[3] = Point (-1.,1.,0.);
        // apex
        nodes[4] = Point (0.,0.,1.);
        return;
      }
 
    default:
      libmesh_error_msg("ERROR: Unknown element type " << Utility::enum_to_string(itemType));
    }
}

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

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

◆ get_tangents()

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

inline

Returns: The tangent vectors for face integration.

Definition at line 452 of file fe_abstract.h.

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

References _fe_map, and calculate_map.

◆ get_type()

ElemType libMesh::FEAbstract::get_type ( ) const

inline

Returns: The element type that the current shape functions have been calculated for, or INVALID_ELEM if no such element exists. Useful in determining when shape functions must be recomputed.

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

Definition at line 509 of file fe_abstract.h.

509{ return _elem_type; }

References _elem_type.

◆ get_xyz()

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

inline

Returns: The xyz spatial locations of the quadrature points on the element.

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

Definition at line 280 of file fe_abstract.h.

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

References _fe_map, and calculate_map.

◆ increment_constructor_count()

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

inlineprotectednoexceptinherited

Increments the construction counter.

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

Definition at line 183 of file reference_counter.h.

{
  libmesh_try
  {
    Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
    std::pair<unsigned int, unsigned int> & p = _counts[name];
    p.first++;
  }
  libmesh_catch (...)
  {
    auto stream = libMesh::err.get();
    stream->exceptions(stream->goodbit); // stream must not throw
    libMesh::err << "Encountered unrecoverable error while calling "
                 << "ReferenceCounter::increment_constructor_count() "
                 << "for a(n) " << name << " object." << std::endl;
    std::terminate();
  }
}

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

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

◆ increment_destructor_count()

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

inlineprotectednoexceptinherited

Increments the destruction counter.

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

Definition at line 207 of file reference_counter.h.

{
  libmesh_try
  {
    Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
    std::pair<unsigned int, unsigned int> & p = _counts[name];
    p.second++;
  }
  libmesh_catch (...)
  {
    auto stream = libMesh::err.get();
    stream->exceptions(stream->goodbit); // stream must not throw
    libMesh::err << "Encountered unrecoverable error while calling "
                 << "ReferenceCounter::increment_destructor_count() "
                 << "for a(n) " << name << " object." << std::endl;
    std::terminate();
  }
}

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

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

◆ is_hierarchic()

virtual bool libMesh::FEAbstract::is_hierarchic ( ) const

pure virtual

Returns: true if the finite element's higher order shape functions are hierarchic

◆ n_objects()

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

inlinestaticinherited

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

Definition at line 85 of file reference_counter.h.

86 { return _n_objects; }

libMesh::ReferenceCounter::_n_objects

static Threads::atomic< unsigned int > _n_objects

The number of objects.

Definition reference_counter.h:132

References libMesh::ReferenceCounter::_n_objects.

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

◆ n_quadrature_points()

unsigned int libMesh::FEAbstract::n_quadrature_points ( ) const

virtual

Returns: The total number of quadrature points with which this was last reinitialized. Useful during matrix assembly.

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

Definition at line 1291 of file fe_abstract.C.

{
  if (this->shapes_on_quadrature)
    {
      libmesh_assert(this->qrule);
      libmesh_assert_equal_to(this->qrule->n_points(),
                              this->_n_total_qp);
    }
  return this->_n_total_qp;
}

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

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

◆ n_shape_functions()

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

pure virtual

Returns: The total number of approximation shape functions for the current element. Useful during matrix assembly. Implement this in derived classes.

◆ on_reference_element()

bool libMesh::FEAbstract::on_reference_element	(	const Point &	p,
		const ElemType	t,
		const Real	eps = `TOLERANCE`
	)

static

Returns: true if the point p is located on the reference element for element type t, false otherwise. Since we are doing floating point comparisons here the parameter eps can be specified to indicate a tolerance. For example, \( x \le 1 \) becomes \( x \le 1 + \epsilon \).

Deprecated:: This method overload does not support all finite element types; e.g. the reference element for an arbitrary polygon or polyhedron type may differ from element to element. Use Elem::on_reference_element() instead.

Definition at line 649 of file fe_abstract.C.

{
  // Use Elem::on_reference_element() instead
  libmesh_deprecated();
 
  libmesh_assert_greater_equal (eps, 0.);
 
  const Real xi   = p(0);
#if LIBMESH_DIM > 1
  const Real eta  = p(1);
#else
  const Real eta  = 0.;
#endif
#if LIBMESH_DIM > 2
  const Real zeta = p(2);
#else
  const Real zeta  = 0.;
#endif
 
  switch (t)
    {
    case NODEELEM:
      {
        return (!xi && !eta && !zeta);
      }
    case EDGE2:
    case EDGE3:
    case EDGE4:
      {
        // The reference 1D element is [-1,1].
        if ((xi >= -1.-eps) &&
            (xi <=  1.+eps))
          return true;
 
        return false;
      }
 
 
    case TRI3:
    case TRISHELL3:
    case TRI6:
    case TRI7:
      {
        // The reference triangle is isosceles
        // and is bound by xi=0, eta=0, and xi+eta=1.
        if ((xi  >= 0.-eps) &&
            (eta >= 0.-eps) &&
            ((xi + eta) <= 1.+eps))
          return true;
 
        return false;
      }
 
 
    case QUAD4:
    case QUADSHELL4:
    case QUAD8:
    case QUADSHELL8:
    case QUAD9:
    case QUADSHELL9:
      {
        // The reference quadrilateral element is [-1,1]^2.
        if ((xi  >= -1.-eps) &&
            (xi  <=  1.+eps) &&
            (eta >= -1.-eps) &&
            (eta <=  1.+eps))
          return true;
 
        return false;
      }
 
 
    case TET4:
    case TET10:
    case TET14:
      {
        // The reference tetrahedral is isosceles
        // and is bound by xi=0, eta=0, zeta=0,
        // and xi+eta+zeta=1.
        if ((xi   >= 0.-eps) &&
            (eta  >= 0.-eps) &&
            (zeta >= 0.-eps) &&
            ((xi + eta + zeta) <= 1.+eps))
          return true;
 
        return false;
      }
 
 
    case HEX8:
    case HEX20:
    case HEX27:
      {
        /*
          if ((xi   >= -1.) &&
          (xi   <=  1.) &&
          (eta  >= -1.) &&
          (eta  <=  1.) &&
          (zeta >= -1.) &&
          (zeta <=  1.))
          return true;
        */
 
        // The reference hexahedral element is [-1,1]^3.
        if ((xi   >= -1.-eps) &&
            (xi   <=  1.+eps) &&
            (eta  >= -1.-eps) &&
            (eta  <=  1.+eps) &&
            (zeta >= -1.-eps) &&
            (zeta <=  1.+eps))
          {
            //    libMesh::out << "Strange Point:\n";
            //    p.print();
            return true;
          }
 
        return false;
      }
 
    case PRISM6:
    case PRISM15:
    case PRISM18:
    case PRISM20:
    case PRISM21:
      {
        // Figure this one out...
        // inside the reference triangle with zeta in [-1,1]
        if ((xi   >=  0.-eps) &&
            (eta  >=  0.-eps) &&
            (zeta >= -1.-eps) &&
            (zeta <=  1.+eps) &&
            ((xi + eta) <= 1.+eps))
          return true;
 
        return false;
      }
 
 
    case PYRAMID5:
    case PYRAMID13:
    case PYRAMID14:
    case PYRAMID18:
      {
        // Check that the point is on the same side of all the faces
        // by testing whether:
        //
        // n_i.(x - x_i) <= 0
        //
        // for each i, where:
        //   n_i is the outward normal of face i,
        //   x_i is a point on face i.
        if ((-eta - 1. + zeta <= 0.+eps) &&
            (  xi - 1. + zeta <= 0.+eps) &&
            ( eta - 1. + zeta <= 0.+eps) &&
            ( -xi - 1. + zeta <= 0.+eps) &&
            (            zeta >= 0.-eps))
          return true;
 
        return false;
      }
 
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
    case INFHEX8:
    case INFHEX16:
    case INFHEX18:
      {
        // The reference infhex8 is a [-1,1]^3.
        if ((xi   >= -1.-eps) &&
            (xi   <=  1.+eps) &&
            (eta  >= -1.-eps) &&
            (eta  <=  1.+eps) &&
            (zeta >= -1.-eps) &&
            (zeta <=  1.+eps))
          {
            return true;
          }
        return false;
      }
 
    case INFPRISM6:
    case INFPRISM12:
      {
        // inside the reference triangle with zeta in [-1,1]
        if ((xi   >=  0.-eps) &&
            (eta  >=  0.-eps) &&
            (zeta >= -1.-eps) &&
            (zeta <=  1.+eps) &&
            ((xi + eta) <= 1.+eps))
          {
            return true;
          }
 
        return false;
      }
#endif
 
    default:
      libmesh_error_msg("ERROR: Unknown element type " << Utility::enum_to_string(t));
    }
 
  // If we get here then the point is _not_ in the
  // reference element.   Better return false.
 
  return false;
}

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

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

◆ print_d2phi()

virtual void libMesh::FEAbstract::print_d2phi ( std::ostream & os ) const

pure virtual

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

Implement in derived class since this depends on whether the element is vector-valued or not.

Implemented in libMesh::FEGenericBase< OutputType >, and libMesh::FEGenericBase< FEOutputType< T >::type >.

◆ print_dphi()

virtual void libMesh::FEAbstract::print_dphi ( std::ostream & os ) const

pure virtual

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

Implement in derived class since this depends on whether the element is vector-valued or not.

Implemented in libMesh::FEGenericBase< OutputType >, and libMesh::FEGenericBase< FEOutputType< T >::type >.

Referenced by print_info().

◆ print_dual_d2phi()

virtual void libMesh::FEAbstract::print_dual_d2phi ( std::ostream & os ) const

pure virtual

Implemented in libMesh::FEGenericBase< OutputType >, and libMesh::FEGenericBase< FEOutputType< T >::type >.

◆ print_dual_dphi()

virtual void libMesh::FEAbstract::print_dual_dphi ( std::ostream & os ) const

pure virtual

Implemented in libMesh::FEGenericBase< OutputType >, and libMesh::FEGenericBase< FEOutputType< T >::type >.

◆ print_dual_phi()

virtual void libMesh::FEAbstract::print_dual_phi ( std::ostream & os ) const

pure virtual

Implemented in libMesh::FEGenericBase< OutputType >, and libMesh::FEGenericBase< FEOutputType< T >::type >.

◆ print_info() [1/2]

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

Prints all the relevant information about the current element.

Definition at line 871 of file fe_abstract.C.

{
  os << "phi[i][j]: Shape function i at quadrature pt. j" << std::endl;
  this->print_phi(os);
 
  os << "dphi[i][j]: Shape function i's gradient at quadrature pt. j" << std::endl;
  this->print_dphi(os);
 
  os << "XYZ locations of the quadrature pts." << std::endl;
  this->print_xyz(os);
 
  os << "Values of JxW at the quadrature pts." << std::endl;
  this->print_JxW(os);
}

References print_dphi(), print_JxW(), print_phi(), and print_xyz().

◆ print_info() [2/2]

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

staticinherited

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

Definition at line 81 of file reference_counter.C.

{
  if (_enable_print_counter)
    out_stream << ReferenceCounter::get_info();
}

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

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

◆ print_JxW()

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

Prints the Jacobian times the weight for each quadrature point.

Definition at line 858 of file fe_abstract.C.

{
  this->_fe_map->print_JxW(os);
}

References _fe_map.

Referenced by print_info().

◆ print_phi()

virtual void libMesh::FEAbstract::print_phi ( std::ostream & os ) const

pure virtual

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

Implement in derived class since this depends on whether the element is vector-valued or not.

Implemented in libMesh::FEGenericBase< OutputType >, and libMesh::FEGenericBase< FEOutputType< T >::type >.

Referenced by print_info().

◆ print_xyz()

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

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

Definition at line 865 of file fe_abstract.C.

{
  this->_fe_map->print_xyz(os);
}

References _fe_map.

Referenced by 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 virtual

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

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

◆ reinit() [2/2]

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

pure virtual

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.

◆ reinit_default_dual_shape_coeffs()

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

inlinevirtual

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

This has not been implemented for InfFE

Definition at line 161 of file fe_abstract.h.

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

◆ reinit_dual_shape_coeffs()

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

inlinevirtual

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

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

Definition at line 150 of file fe_abstract.h.

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

◆ request_dphi()

virtual void libMesh::FEAbstract::request_dphi ( ) const

pure virtual

request dphi calculations

Implemented in libMesh::FEGenericBase< OutputType >, and libMesh::FEGenericBase< FEOutputType< T >::type >.

Referenced by libMesh::OldSolutionBase< Output, point_output >::get_shape_outputs(), and libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::SubFunctor().

◆ request_dual_dphi()

virtual void libMesh::FEAbstract::request_dual_dphi ( ) const

pure virtual

Implemented in libMesh::FEGenericBase< OutputType >, and libMesh::FEGenericBase< FEOutputType< T >::type >.

◆ request_dual_phi()

virtual void libMesh::FEAbstract::request_dual_phi ( ) const

pure virtual

Implemented in libMesh::FEGenericBase< OutputType >, and libMesh::FEGenericBase< FEOutputType< T >::type >.

◆ request_phi()

virtual void libMesh::FEAbstract::request_phi ( ) const

pure virtual

request phi calculations

Implemented in libMesh::FEGenericBase< OutputType >, and libMesh::FEGenericBase< FEOutputType< T >::type >.

Referenced by libMesh::OldSolutionBase< Output, point_output >::get_shape_outputs(), and libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::SubFunctor().

◆ set_calculate_default_dual_coeff()

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

inline

set calculate_default_dual_coeff as needed

Definition at line 626 of file fe_abstract.h.

626{calculate_default_dual_coeff = val; }

References calculate_default_dual_coeff.

◆ set_calculate_dual()

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

inline

set calculate_dual as needed

Definition at line 621 of file fe_abstract.h.

621{calculate_dual = val; }

References calculate_dual.

◆ set_fe_order()

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

inline

Sets the base FE order of the finite element.

Definition at line 531 of file fe_abstract.h.

531{ fe_type.order = new_order; }

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

◆ shapes_need_reinit()

virtual bool libMesh::FEAbstract::shapes_need_reinit ( ) const

protectedpure virtual

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.

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

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

Friends And Related Symbol Documentation

◆ operator<<

std::ostream & operator<<	(	std::ostream &	os,
		const FEAbstract &	fe
	)

friend

Same as above, but allows you to print to a stream.

Definition at line 887 of file fe_abstract.C.

{
  fe.print_info(os);
  return os;
}

Member Data Documentation

◆ _add_p_level_in_reinit

bool libMesh::FEAbstract::_add_p_level_in_reinit

protected

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

Definition at line 787 of file fe_abstract.h.

Referenced by add_p_level_in_reinit(), and add_p_level_in_reinit().

◆ _counts

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

Definition at line 124 of file reference_counter.h.

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

◆ _elem

const Elem* libMesh::FEAbstract::_elem

protected

The element the current data structures were set up for.

Definition at line 740 of file fe_abstract.h.

Referenced by get_elem().

◆ _elem_p_level

unsigned int libMesh::FEAbstract::_elem_p_level

protected

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

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

Definition at line 751 of file fe_abstract.h.

◆ _elem_type

ElemType libMesh::FEAbstract::_elem_type

protected

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

Definition at line 735 of file fe_abstract.h.

Referenced by get_type().

◆ _enable_print_counter

bool libMesh::ReferenceCounter::_enable_print_counter = true

staticprotectedinherited

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

Definition at line 143 of file reference_counter.h.

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

◆ _fe_map

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

protected

Definition at line 654 of file fe_abstract.h.

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

◆ _mutex

Threads::spin_mutex libMesh::ReferenceCounter::_mutex

staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 137 of file reference_counter.h.

◆ _n_objects

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

staticprotectedinherited

The number of objects.

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

Definition at line 132 of file reference_counter.h.

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

◆ _n_total_qp

unsigned int libMesh::FEAbstract::_n_total_qp

protected

The total number of quadrature points for the current configuration.

Definition at line 774 of file fe_abstract.h.

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

◆ _p_level

unsigned int libMesh::FEAbstract::_p_level

protected

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

Definition at line 757 of file fe_abstract.h.

Referenced by get_order(), and get_p_level().

◆ calculate_curl_phi

bool libMesh::FEAbstract::calculate_curl_phi

mutableprotected

Should we calculate shape function curls?

Definition at line 712 of file fe_abstract.h.

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

◆ calculate_d2phi [1/2]

bool libMesh::FEAbstract::calculate_d2phi

mutableprotected

Should we calculate shape function hessians?

Definition at line 702 of file fe_abstract.h.

◆ calculate_d2phi [2/2]

const bool libMesh::FEAbstract::calculate_d2phi =false

protected

Definition at line 705 of file fe_abstract.h.

◆ calculate_default_dual_coeff

bool libMesh::FEAbstract::calculate_default_dual_coeff

mutableprotected

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

Definition at line 676 of file fe_abstract.h.

Referenced by set_calculate_default_dual_coeff().

◆ calculate_div_phi

bool libMesh::FEAbstract::calculate_div_phi

mutableprotected

Should we calculate shape function divergences?

Definition at line 717 of file fe_abstract.h.

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

◆ calculate_dphi

bool libMesh::FEAbstract::calculate_dphi

mutableprotected

Should we calculate shape function gradients?

Definition at line 696 of file fe_abstract.h.

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

◆ calculate_dphiref

bool libMesh::FEAbstract::calculate_dphiref

mutableprotected

Should we calculate reference shape function gradients?

Definition at line 722 of file fe_abstract.h.

◆ calculate_dual

bool libMesh::FEAbstract::calculate_dual

mutableprotected

Are we calculating dual basis?

Definition at line 671 of file fe_abstract.h.

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

◆ calculate_map

bool libMesh::FEAbstract::calculate_map

mutableprotected

Are we calculating mapping functions?

Definition at line 686 of file fe_abstract.h.

◆ calculate_nothing

bool libMesh::FEAbstract::calculate_nothing

mutableprotected

Are we potentially deliberately calculating nothing?

Definition at line 681 of file fe_abstract.h.

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

◆ calculate_phi

bool libMesh::FEAbstract::calculate_phi

mutableprotected

Should we calculate shape functions?

Definition at line 691 of file fe_abstract.h.

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

◆ calculations_started

bool libMesh::FEAbstract::calculations_started

mutableprotected

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

Definition at line 666 of file fe_abstract.h.

◆ dim

const unsigned int libMesh::FEAbstract::dim

protected

The dimensionality of the object.

Definition at line 660 of file fe_abstract.h.

Referenced by build(), and get_dim().

◆ fe_type

FEType libMesh::FEAbstract::fe_type

protected

The finite element type for this object.

Note: This should be constant for the object.

Definition at line 730 of file fe_abstract.h.

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

◆ qrule

QBase* libMesh::FEAbstract::qrule

protected

A pointer to the quadrature rule employed.

Definition at line 762 of file fe_abstract.h.

Referenced by n_quadrature_points().

◆ shapes_on_quadrature

bool libMesh::FEAbstract::shapes_on_quadrature

protected

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

Definition at line 768 of file fe_abstract.h.

Referenced by n_quadrature_points().

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

include/fe/fe_abstract.h
src/fe/fe_abstract.C

Public Member Functions

Static Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Static Protected Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ Counts

Constructor & Destructor Documentation

◆ FEAbstract()

◆ ~FEAbstract()

Member Function Documentation

◆ add_p_level_in_reinit() [1/2]

◆ add_p_level_in_reinit() [2/2]

◆ attach_quadrature_rule()

◆ build()

◆ compute_node_constraints()

◆ compute_periodic_node_constraints()

◆ compute_shape_functions()

◆ disable_print_counter_info()

◆ edge_reinit()

◆ enable_print_counter_info()

◆ get_continuity()

◆ get_curvatures()

◆ get_d2xyzdeta2()

◆ get_d2xyzdetadzeta()

◆ get_d2xyzdxi2()

◆ get_d2xyzdxideta()

◆ get_d2xyzdxidzeta()

◆ get_d2xyzdzeta2()

◆ get_detadx()

◆ get_detady()

◆ get_detadz()

◆ get_dim()

◆ get_dxidx()

◆ get_dxidy()

◆ get_dxidz()

◆ get_dxyzdeta()

◆ get_dxyzdxi()

◆ get_dxyzdzeta()

◆ get_dzetadx()

◆ get_dzetady()

◆ get_dzetadz()

◆ get_elem()

◆ get_family()

◆ get_fe_map() [1/2]

◆ get_fe_map() [2/2]

◆ get_fe_type()

◆ get_info()

◆ get_JxW()

◆ get_JxWxdecay_sq()

◆ get_normals()

◆ get_nothing()

◆ get_order()

◆ get_p_level()

◆ get_refspace_nodes()

◆ get_tangents()

◆ get_type()

◆ get_xyz()

◆ increment_constructor_count()

◆ increment_destructor_count()

◆ is_hierarchic()

◆ n_objects()

◆ n_quadrature_points()

◆ n_shape_functions()

◆ on_reference_element()

◆ print_d2phi()

◆ print_dphi()

◆ print_dual_d2phi()

◆ print_dual_dphi()

◆ print_dual_phi()

◆ print_info() [1/2]

◆ print_info() [2/2]

◆ print_JxW()

◆ print_phi()

◆ print_xyz()

◆ reinit() [1/2]

◆ reinit() [2/2]