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

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

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

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

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

unsigned int	get_dim () const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

virtual unsigned int	n_shape_functions () const =0

virtual unsigned int	n_quadrature_points () const =0

ElemType	get_type () const

unsigned int	get_p_level () const

FEType	get_fe_type () const

Order	get_order () const

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

virtual FEContinuity	get_continuity () const =0

virtual bool	is_hierarchic () const =0

FEFamily	get_family () const

const FEMap &	get_fe_map () const

FEMap &	get_fe_map ()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static void	disable_print_counter_info ()

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

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

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

virtual bool	shapes_need_reinit () const =0

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

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

Protected Attributes
std::unique_ptr< FEMap >	_fe_map

const unsigned int	dim
	The dimensionality of the object. More...

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

bool	calculate_map
	Are we calculating mapping functions? More...

bool	calculate_phi
	Should we calculate shape functions? More...

bool	calculate_dphi
	Should we calculate shape function gradients? More...

bool	calculate_d2phi
	Should we calculate shape function hessians? More...

const bool	calculate_d2phi =false

bool	calculate_curl_phi
	Should we calculate shape function curls? More...

bool	calculate_div_phi
	Should we calculate shape function divergences? More...

bool	calculate_dphiref
	Should we calculate reference shape function gradients? More...

FEType	fe_type
	The finite element type for this object. More...

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

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

QBase *	qrule
	A pointer to the quadrature rule employed. More...

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

Static Protected Attributes
static Counts	_counts
	Actually holds the data. More...

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

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

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

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

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 100 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 117 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 46 of file fe_abstract.C.

                                            :
   _fe_map( FEMap::build(fet) ),
   dim(d),
   calculations_started(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),
   _p_level(0),
   qrule(nullptr),
   shapes_on_quadrature(false)
 {
 }

◆ ~FEAbstract()

libMesh::FEAbstract::~FEAbstract ( )

virtual

Destructor.

Definition at line 67 of file fe_abstract.C.

68 {

69 }

Member Function Documentation

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

 {
   switch (dim)
     {
       // 0D
     case 0:
       {
         switch (fet.family)
           {
           case CLOUGH:
             return libmesh_make_unique<FE<0,CLOUGH>>(fet);
  
           case HERMITE:
             return libmesh_make_unique<FE<0,HERMITE>>(fet);
  
           case LAGRANGE:
             return libmesh_make_unique<FE<0,LAGRANGE>>(fet);
  
           case LAGRANGE_VEC:
             return libmesh_make_unique<FE<0,LAGRANGE_VEC>>(fet);
  
           case L2_LAGRANGE:
             return libmesh_make_unique<FE<0,L2_LAGRANGE>>(fet);
  
           case HIERARCHIC:
             return libmesh_make_unique<FE<0,HIERARCHIC>>(fet);
  
           case L2_HIERARCHIC:
             return libmesh_make_unique<FE<0,L2_HIERARCHIC>>(fet);
  
           case MONOMIAL:
             return libmesh_make_unique<FE<0,MONOMIAL>>(fet);
  
           case MONOMIAL_VEC:
             return libmesh_make_unique<FE<0,MONOMIAL_VEC>>(fet);
  
 #ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES
           case SZABAB:
             return libmesh_make_unique<FE<0,SZABAB>>(fet);
  
           case BERNSTEIN:
             return libmesh_make_unique<FE<0,BERNSTEIN>>(fet);
  
           case RATIONAL_BERNSTEIN:
             return libmesh_make_unique<FE<0,RATIONAL_BERNSTEIN>>(fet);
 #endif
  
           case XYZ:
             return libmesh_make_unique<FEXYZ<0>>(fet);
  
           case SCALAR:
             return libmesh_make_unique<FEScalar<0>>(fet);
  
           default:
             libmesh_error_msg("ERROR: Bad FEType.family= " << fet.family);
           }
       }
       // 1D
     case 1:
       {
         switch (fet.family)
           {
           case CLOUGH:
             return libmesh_make_unique<FE<1,CLOUGH>>(fet);
  
           case HERMITE:
             return libmesh_make_unique<FE<1,HERMITE>>(fet);
  
           case LAGRANGE:
             return libmesh_make_unique<FE<1,LAGRANGE>>(fet);
  
           case LAGRANGE_VEC:
             return libmesh_make_unique<FE<1,LAGRANGE_VEC>>(fet);
  
           case L2_LAGRANGE:
             return libmesh_make_unique<FE<1,L2_LAGRANGE>>(fet);
  
           case HIERARCHIC:
             return libmesh_make_unique<FE<1,HIERARCHIC>>(fet);
  
           case L2_HIERARCHIC:
             return libmesh_make_unique<FE<1,L2_HIERARCHIC>>(fet);
  
           case MONOMIAL:
             return libmesh_make_unique<FE<1,MONOMIAL>>(fet);
  
           case MONOMIAL_VEC:
             return libmesh_make_unique<FE<1,MONOMIAL_VEC>>(fet);
  
 #ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES
           case SZABAB:
             return libmesh_make_unique<FE<1,SZABAB>>(fet);
  
           case BERNSTEIN:
             return libmesh_make_unique<FE<1,BERNSTEIN>>(fet);
  
           case RATIONAL_BERNSTEIN:
             return libmesh_make_unique<FE<1,RATIONAL_BERNSTEIN>>(fet);
 #endif
  
           case XYZ:
             return libmesh_make_unique<FEXYZ<1>>(fet);
  
           case SCALAR:
             return libmesh_make_unique<FEScalar<1>>(fet);
  
           default:
             libmesh_error_msg("ERROR: Bad FEType.family= " << fet.family);
           }
       }
  
  
       // 2D
     case 2:
       {
         switch (fet.family)
           {
           case CLOUGH:
             return libmesh_make_unique<FE<2,CLOUGH>>(fet);
  
           case HERMITE:
             return libmesh_make_unique<FE<2,HERMITE>>(fet);
  
           case LAGRANGE:
             return libmesh_make_unique<FE<2,LAGRANGE>>(fet);
  
           case LAGRANGE_VEC:
             return libmesh_make_unique<FE<2,LAGRANGE_VEC>>(fet);
  
           case L2_LAGRANGE:
             return libmesh_make_unique<FE<2,L2_LAGRANGE>>(fet);
  
           case HIERARCHIC:
             return libmesh_make_unique<FE<2,HIERARCHIC>>(fet);
  
           case L2_HIERARCHIC:
             return libmesh_make_unique<FE<2,L2_HIERARCHIC>>(fet);
  
           case MONOMIAL:
             return libmesh_make_unique<FE<2,MONOMIAL>>(fet);
  
           case MONOMIAL_VEC:
             return libmesh_make_unique<FE<2,MONOMIAL_VEC>>(fet);
  
 #ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES
           case SZABAB:
             return libmesh_make_unique<FE<2,SZABAB>>(fet);
  
           case BERNSTEIN:
             return libmesh_make_unique<FE<2,BERNSTEIN>>(fet);
  
           case RATIONAL_BERNSTEIN:
             return libmesh_make_unique<FE<2,RATIONAL_BERNSTEIN>>(fet);
 #endif
  
           case XYZ:
             return libmesh_make_unique<FEXYZ<2>>(fet);
  
           case SCALAR:
             return libmesh_make_unique<FEScalar<2>>(fet);
  
           case NEDELEC_ONE:
             return libmesh_make_unique<FENedelecOne<2>>(fet);
  
           case SUBDIVISION:
             return libmesh_make_unique<FESubdivision>(fet);
  
           default:
             libmesh_error_msg("ERROR: Bad FEType.family= " << 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 libmesh_make_unique<FE<3,HERMITE>>(fet);
  
           case LAGRANGE:
             return libmesh_make_unique<FE<3,LAGRANGE>>(fet);
  
           case LAGRANGE_VEC:
             return libmesh_make_unique<FE<3,LAGRANGE_VEC>>(fet);
  
           case L2_LAGRANGE:
             return libmesh_make_unique<FE<3,L2_LAGRANGE>>(fet);
  
           case HIERARCHIC:
             return libmesh_make_unique<FE<3,HIERARCHIC>>(fet);
  
           case L2_HIERARCHIC:
             return libmesh_make_unique<FE<3,L2_HIERARCHIC>>(fet);
  
           case MONOMIAL:
             return libmesh_make_unique<FE<3,MONOMIAL>>(fet);
  
           case MONOMIAL_VEC:
             return libmesh_make_unique<FE<3,MONOMIAL_VEC>>(fet);
  
 #ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES
           case SZABAB:
             return libmesh_make_unique<FE<3,SZABAB>>(fet);
  
           case BERNSTEIN:
             return libmesh_make_unique<FE<3,BERNSTEIN>>(fet);
  
           case RATIONAL_BERNSTEIN:
             return libmesh_make_unique<FE<3,RATIONAL_BERNSTEIN>>(fet);
 #endif
  
           case XYZ:
             return libmesh_make_unique<FEXYZ<3>>(fet);
  
           case SCALAR:
             return libmesh_make_unique<FEScalar<3>>(fet);
  
           case NEDELEC_ONE:
             return libmesh_make_unique<FENedelecOne<3>>(fet);
  
           default:
             libmesh_error_msg("ERROR: Bad FEType.family= " << fet.family);
           }
       }
  
     default:
       libmesh_error_msg("Invalid dimension dim = " << dim);
     }
 }

References libMesh::BERNSTEIN, libMesh::CLOUGH, dim, libMesh::FEType::family, libMesh::HERMITE, libMesh::HIERARCHIC, libMesh::L2_HIERARCHIC, libMesh::L2_LAGRANGE, libMesh::LAGRANGE, libMesh::LAGRANGE_VEC, libMesh::MONOMIAL, libMesh::MONOMIAL_VEC, libMesh::NEDELEC_ONE, libMesh::RATIONAL_BERNSTEIN, libMesh::SCALAR, libMesh::SUBDIVISION, libMesh::SZABAB, and libMesh::XYZ.

Referenced by libMesh::DGFEMContext::DGFEMContext(), libMesh::FEMContext::init_internal_data(), and libMesh::DofMap::use_coupled_neighbor_dofs().

◆ 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 845 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;
  
   const FEFamily mapping_family = FEMap::map_fe_type(*elem);
   const FEType fe_type(elem->default_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++)
             {
               libmesh_assert_less (my_side_n, FEInterface::n_dofs(Dim-1, fe_type, my_side->type()));
  
               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++)
                 {
                   libmesh_assert_less (their_side_n, FEInterface::n_dofs(Dim-1, fe_type, parent_side->type()));
  
                   const Node * their_node = parent_nodes[their_side_n];
                   libmesh_assert(their_node);
  
                   const Real their_value = FEInterface::shape(Dim-1,
                                                               fe_type,
                                                               parent_side->type(),
                                                               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.insert(std::make_pair (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.insert(std::make_pair (their_node,
                                                               their_value));
                       }
                 }
             }
         }
 }

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

◆ compute_periodic_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 990 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_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.
               const Elem * neigh = boundaries.neighbor(boundary_id, *point_locator, elem, 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())
                 {
                   unsigned int s_neigh =
                     mesh.get_boundary_info().side_with_boundary_id(neigh, periodic->pairedboundary);
                   libmesh_assert_not_equal_to (s_neigh, libMesh::invalid_uint);
  
 #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++)
                     {
                       libmesh_assert_less (my_side_n, FEInterface::n_dofs(Dim-1, fe_type, my_side->type()));
  
                       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);
  
                       const Point mapped_point =
                         FEMap::inverse_map(Dim-1, neigh_side.get(),
                                            neigh_point);
  
                       // 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++)
                         {
                           libmesh_assert_less (their_side_n, FEInterface::n_dofs(Dim-1, fe_type, neigh_side->type()));
  
                           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++)
                               {
                                 libmesh_assert_less (orig_side_n, FEInterface::n_dofs(Dim-1, fe_type, my_side->type()));
  
                                 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++)
                     {
                       libmesh_assert_less (my_side_n, FEInterface::n_dofs(Dim-1, fe_type, my_side->type()));
  
                       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++)
                         {
                           libmesh_assert_less (their_side_n, FEInterface::n_dofs(Dim-1, fe_type, neigh_side->type()));
  
                           const Node * their_node = neigh_nodes[their_side_n];
                           libmesh_assert(their_node);
  
                           const Real their_value = FEInterface::shape(Dim-1,
                                                                       fe_type,
                                                                       neigh_side->type(),
                                                                       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.insert(std::make_pair(their_node,
                                                                  their_value));
                           }
                         }
                     }
                 }
             }
         }
     }
 }

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

◆ compute_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::FEXYZ< Dim >, libMesh::FEGenericBase< OutputType >, libMesh::FEGenericBase< FEOutputType< T >::type >, and libMesh::InfFE< Dim, T_radial, T_map >.

◆ disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

Definition at line 106 of file reference_counter.C.

 {
   _enable_print_counter = false;
   return;
 }

References libMesh::ReferenceCounter::_enable_print_counter.

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

◆ edge_reinit()

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

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

Definition at line 100 of file reference_counter.C.

 {
   _enable_print_counter = true;
   return;
 }

References libMesh::ReferenceCounter::_enable_print_counter.

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

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

inline

Returns: The curvatures for use in face integration.

Definition at line 387 of file fe_abstract.h.

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

References _fe_map, and calculate_map.

◆ get_d2xyzdeta2()

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

inline

Returns: The second partial derivatives in eta.

Definition at line 279 of file fe_abstract.h.

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

References _fe_map, and calculate_map.

◆ get_d2xyzdetadzeta()

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

inline

Returns: The second partial derivatives in eta-zeta.

Definition at line 303 of file fe_abstract.h.

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

References _fe_map, and calculate_map.

◆ get_d2xyzdxi2()

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

inline

Returns: The second partial derivatives in xi.

Definition at line 273 of file fe_abstract.h.

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

References _fe_map, and calculate_map.

◆ get_d2xyzdxideta()

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

inline

Returns: The second partial derivatives in xi-eta.

Definition at line 291 of file fe_abstract.h.

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

References _fe_map, and calculate_map.

◆ get_d2xyzdxidzeta()

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

inline

Returns: The second partial derivatives in xi-zeta.

Definition at line 297 of file fe_abstract.h.

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

References _fe_map, and calculate_map.

◆ get_d2xyzdzeta2()

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

inline

Returns: The second partial derivatives in zeta.

Definition at line 285 of file fe_abstract.h.

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

References _fe_map, and calculate_map.

◆ get_detadx()

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

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

References _fe_map, and calculate_map.

◆ get_detady()

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

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

References _fe_map, and calculate_map.

◆ get_detadz()

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

348 { 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 230 of file fe_abstract.h.

231 { return dim; }

References dim.

◆ get_dxidx()

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

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

References _fe_map, and calculate_map.

◆ get_dxidy()

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

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

References _fe_map, and calculate_map.

◆ get_dxidz()

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

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

References _fe_map, and calculate_map.

◆ get_dxyzdeta()

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

inline

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

Definition at line 258 of file fe_abstract.h.

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

References _fe_map, and calculate_map.

◆ get_dxyzdxi()

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

inline

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

Definition at line 251 of file fe_abstract.h.

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

References _fe_map, and calculate_map.

◆ get_dxyzdzeta()

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

inline

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

Definition at line 265 of file fe_abstract.h.

266 { return _fe_map->get_dxyzdzeta(); }

References _fe_map.

◆ get_dzetadx()

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

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

References _fe_map, and calculate_map.

◆ get_dzetady()

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

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

References _fe_map, and calculate_map.

◆ get_dzetadz()

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

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

References _fe_map, and calculate_map.

◆ get_family()

FEFamily libMesh::FEAbstract::get_family ( ) const

inline

Returns: The finite element family of this element.

Definition at line 453 of file fe_abstract.h.

453 { return fe_type.family; }

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

◆ get_fe_map() [1/2]

FEMap& libMesh::FEAbstract::get_fe_map ( )

inline

Definition at line 459 of file fe_abstract.h.

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

Definition at line 458 of file fe_abstract.h.

458 { 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 427 of file fe_abstract.h.

427 { return fe_type; }

References fe_type.

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

◆ get_info()

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

staticinherited

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

 {
 #if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
  
   std::ostringstream oss;
  
   oss << '\n'
       << " ---------------------------------------------------------------------------- \n"
       << "| Reference count information                                                |\n"
       << " ---------------------------------------------------------------------------- \n";
  
   for (const auto & pr : _counts)
     {
       const std::string name(pr.first);
       const unsigned int creations    = pr.second.first;
       const unsigned int destructions = pr.second.second;
  
       oss << "| " << name << " reference count information:\n"
           << "|  Creations:    " << creations    << '\n'
           << "|  Destructions: " << destructions << '\n';
     }
  
   oss << " ---------------------------------------------------------------------------- \n";
  
   return oss.str();
  
 #else
  
   return "";
  
 #endif
 }

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

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

◆ get_JxW()

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

inline

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

Definition at line 244 of file fe_abstract.h.

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

References _fe_map, and calculate_map.

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

◆ get_normals()

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

inline

Returns: The outward pointing normal vectors for face integration.

Definition at line 380 of file fe_abstract.h.

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

References _fe_map, and calculate_map.

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

◆ get_order()

Order libMesh::FEAbstract::get_order ( ) const

inline

Returns: The approximation order of the finite element.

Definition at line 432 of file fe_abstract.h.

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

References _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 422 of file fe_abstract.h.

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

 {
   switch(itemType)
     {
     case EDGE2:
       {
         nodes.resize(2);
         nodes[0] = Point (-1.,0.,0.);
         nodes[1] = Point (1.,0.,0.);
         return;
       }
     case EDGE3:
       {
         nodes.resize(3);
         nodes[0] = Point (-1.,0.,0.);
         nodes[1] = Point (1.,0.,0.);
         nodes[2] = Point (0.,0.,0.);
         return;
       }
     case TRI3:
     case TRISHELL3:
       {
         nodes.resize(3);
         nodes[0] = Point (0.,0.,0.);
         nodes[1] = Point (1.,0.,0.);
         nodes[2] = Point (0.,1.,0.);
         return;
       }
     case TRI6:
       {
         nodes.resize(6);
         nodes[0] = Point (0.,0.,0.);
         nodes[1] = Point (1.,0.,0.);
         nodes[2] = Point (0.,1.,0.);
         nodes[3] = Point (.5,0.,0.);
         nodes[4] = Point (.5,.5,0.);
         nodes[5] = Point (0.,.5,0.);
         return;
       }
     case QUAD4:
     case QUADSHELL4:
       {
         nodes.resize(4);
         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 QUAD8:
     case QUADSHELL8:
       {
         nodes.resize(8);
         nodes[0] = Point (-1.,-1.,0.);
         nodes[1] = Point (1.,-1.,0.);
         nodes[2] = Point (1.,1.,0.);
         nodes[3] = Point (-1.,1.,0.);
         nodes[4] = Point (0.,-1.,0.);
         nodes[5] = Point (1.,0.,0.);
         nodes[6] = Point (0.,1.,0.);
         nodes[7] = Point (-1.,0.,0.);
         return;
       }
     case QUAD9:
       {
         nodes.resize(9);
         nodes[0] = Point (-1.,-1.,0.);
         nodes[1] = Point (1.,-1.,0.);
         nodes[2] = Point (1.,1.,0.);
         nodes[3] = Point (-1.,1.,0.);
         nodes[4] = Point (0.,-1.,0.);
         nodes[5] = Point (1.,0.,0.);
         nodes[6] = Point (0.,1.,0.);
         nodes[7] = Point (-1.,0.,0.);
         nodes[8] = Point (0.,0.,0.);
         return;
       }
     case TET4:
       {
         nodes.resize(4);
         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 TET10:
       {
         nodes.resize(10);
         nodes[0] = Point (0.,0.,0.);
         nodes[1] = Point (1.,0.,0.);
         nodes[2] = Point (0.,1.,0.);
         nodes[3] = Point (0.,0.,1.);
         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);
         return;
       }
     case HEX8:
       {
         nodes.resize(8);
         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 HEX20:
       {
         nodes.resize(20);
         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.);
         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.);
         return;
       }
     case HEX27:
       {
         nodes.resize(27);
         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.);
         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.);
         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.);
         return;
       }
     case PRISM6:
       {
         nodes.resize(6);
         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 PRISM15:
       {
         nodes.resize(15);
         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.);
         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.);
         return;
       }
     case PRISM18:
       {
         nodes.resize(18);
         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.);
         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.);
         nodes[15] = Point (.5,0.,0.);
         nodes[16] = Point (.5,.5,0.);
         nodes[17] = Point (0.,.5,0.);
         return;
       }
     case PYRAMID5:
       {
         nodes.resize(5);
         nodes[0] = Point (-1.,-1.,0.);
         nodes[1] = Point (1.,-1.,0.);
         nodes[2] = Point (1.,1.,0.);
         nodes[3] = Point (-1.,1.,0.);
         nodes[4] = Point (0.,0.,1.);
         return;
       }
     case PYRAMID13:
       {
         nodes.resize(13);
  
         // 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.);
  
         // 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);
  
         return;
       }
     case PYRAMID14:
       {
         nodes.resize(14);
  
         // 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.);
  
         // 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);
  
         // base center
         nodes[13] = Point (0.,0.,0.);
  
         return;
       }
  
     default:
       libmesh_error_msg("ERROR: Unknown element type " << itemType);
     }
 }

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

◆ get_tangents()

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

inline

Returns: The tangent vectors for face integration.

Definition at line 374 of file fe_abstract.h.

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

References _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. Useful in determining when shape functions must be recomputed.

Definition at line 416 of file fe_abstract.h.

416 { return elem_type; }

References elem_type.

◆ get_xyz()

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

inline

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

Definition at line 237 of file fe_abstract.h.

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

References _fe_map, and calculate_map.

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

◆ increment_constructor_count()

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

inlineprotectedinherited

Increments the construction counter.

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

Definition at line 181 of file reference_counter.h.

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

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

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

◆ increment_destructor_count()

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

inlineprotectedinherited

Increments the destruction counter.

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

Definition at line 194 of file reference_counter.h.

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

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

Referenced by libMesh::ReferenceCountedObject< RBParametrized >::~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 83 of file reference_counter.h.

84 { return _n_objects; }

References libMesh::ReferenceCounter::_n_objects.

◆ n_quadrature_points()

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

pure virtual

Returns: The total number of quadrature points. Useful during matrix assembly. Implement this in derived classes.

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

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

◆ n_shape_functions()

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

pure virtual

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

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

Referenced by assemble_SchroedingerEquation().

◆ on_reference_element()

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

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

Definition at line 606 of file fe_abstract.C.

 {
   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:
       {
         // 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:
       {
         // 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:
       {
         // 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:
       {
         // 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:
       {
         // 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 " << 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::HEX20, libMesh::HEX27, libMesh::HEX8, libMesh::INFHEX16, libMesh::INFHEX18, libMesh::INFHEX8, libMesh::INFPRISM12, libMesh::INFPRISM6, libMesh::NODEELEM, libMesh::PRISM15, libMesh::PRISM18, libMesh::PRISM6, libMesh::PYRAMID13, libMesh::PYRAMID14, libMesh::PYRAMID5, libMesh::QUAD4, libMesh::QUAD8, libMesh::QUAD9, libMesh::QUADSHELL4, libMesh::QUADSHELL8, libMesh::Real, libMesh::TET10, libMesh::TET4, libMesh::TRI3, libMesh::TRI6, and libMesh::TRISHELL3.

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

◆ print_d2phi()

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_info() [1/2]

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

Prints all the relevant information about the current element.

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

Referenced by libMesh::operator<<().

◆ print_info() [2/2]

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

staticinherited

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

Definition at line 87 of file reference_counter.C.

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

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

◆ print_JxW()

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

Prints the Jacobian times the weight for each quadrature point.

Definition at line 805 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 812 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_SchroedingerEquation(), libMesh::FEMContext::build_new_fe(), libMesh::System::calculate_norm(), libMesh::RBEIMAssembly::evaluate_basis_function(), libMesh::ExactErrorEstimator::find_squared_element_error(), libMesh::JumpErrorEstimator::reinit_sides(), FETest< order, family, elem_type >::testGradU(), FETest< order, family, elem_type >::testGradUComp(), and FETest< order, family, elem_type >::testU().

◆ reinit() [2/2]

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

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

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

437 { 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 Function 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 834 of file fe_abstract.C.

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

Member Data Documentation

◆ _counts

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

Definition at line 122 of file reference_counter.h.

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

◆ _enable_print_counter

bool libMesh::ReferenceCounter::_enable_print_counter = true

staticprotectedinherited

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

Definition at line 141 of file reference_counter.h.

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

◆ _fe_map

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

protected

◆ _mutex

Threads::spin_mutex libMesh::ReferenceCounter::_mutex

staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 135 of file reference_counter.h.

◆ _n_objects

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

staticprotectedinherited

The number of objects.

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

Definition at line 130 of file reference_counter.h.

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

◆ _p_level

unsigned int libMesh::FEAbstract::_p_level

protected

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

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

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

◆ calculate_d2phi [1/2]

bool libMesh::FEAbstract::calculate_d2phi

mutableprotected

Should we calculate shape function hessians?

Definition at line 557 of file fe_abstract.h.

◆ calculate_d2phi [2/2]

const bool libMesh::FEAbstract::calculate_d2phi =false

protected

Definition at line 560 of file fe_abstract.h.

◆ calculate_div_phi

bool libMesh::FEAbstract::calculate_div_phi

mutableprotected

Should we calculate shape function divergences?

Definition at line 572 of file fe_abstract.h.

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

◆ calculate_dphi

bool libMesh::FEAbstract::calculate_dphi

mutableprotected

Should we calculate shape function gradients?

Definition at line 551 of file fe_abstract.h.

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

◆ calculate_dphiref

bool libMesh::FEAbstract::calculate_dphiref

mutableprotected

Should we calculate reference shape function gradients?

Definition at line 577 of file fe_abstract.h.

◆ calculate_map

bool libMesh::FEAbstract::calculate_map

mutableprotected

Are we calculating mapping functions?

Definition at line 541 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_dzetadx(), get_dzetady(), get_dzetadz(), get_JxW(), get_normals(), get_tangents(), and get_xyz().

◆ calculate_phi

bool libMesh::FEAbstract::calculate_phi

mutableprotected

Should we calculate shape functions?

Definition at line 546 of file fe_abstract.h.

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

◆ calculations_started

bool libMesh::FEAbstract::calculations_started

mutableprotected

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

Definition at line 536 of file fe_abstract.h.

◆ dim

const unsigned int libMesh::FEAbstract::dim

protected

The dimensionality of the object.

Definition at line 530 of file fe_abstract.h.

Referenced by build(), and get_dim().

◆ elem_type

ElemType libMesh::FEAbstract::elem_type

protected

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

Definition at line 591 of file fe_abstract.h.

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

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

◆ qrule

QBase* libMesh::FEAbstract::qrule

protected

A pointer to the quadrature rule employed.

Definition at line 602 of file fe_abstract.h.

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

◆ shapes_on_quadrature

bool libMesh::FEAbstract::shapes_on_quadrature

protected

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

Definition at line 608 of file fe_abstract.h.

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

◆ 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_family()

◆ get_fe_map() [1/2]

◆ get_fe_map() [2/2]

◆ get_fe_type()

◆ get_info()

◆ get_JxW()

◆ get_normals()

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

◆ print_info() [2/2]

◆ print_JxW()

◆ print_phi()

◆ print_xyz()

◆ reinit() [1/2]

◆ reinit() [2/2]

◆ set_fe_order()

◆ shapes_need_reinit()

◆ side_map()

Friends And Related Function Documentation

◆ operator<<

Member Data Documentation

◆ _counts

◆ _enable_print_counter