libMesh::FELagrange< Dim > Class Template Reference

#include <fe.h>

Inheritance diagram for libMesh::FELagrange< Dim >:

Public Types

typedef FEGenericBase< typename FEOutputType< T >::type >::OutputShape OutputShape
 
typedef TensorTools::IncrementRank< OutputShape >::type OutputGradient
 
typedef TensorTools::IncrementRank< OutputGradient >::type OutputTensor
 
typedef TensorTools::DecrementRank< OutputShape >::type OutputDivergence
 
typedef TensorTools::MakeNumber< OutputShape >::type OutputNumber
 
typedef TensorTools::IncrementRank< OutputNumber >::type OutputNumberGradient
 
typedef TensorTools::IncrementRank< OutputNumberGradient >::type OutputNumberTensor
 
typedef TensorTools::DecrementRank< OutputNumber >::type OutputNumberDivergence
 

Public Member Functions

 FELagrange (const FEType &fet)
 
virtual unsigned int n_shape_functions () const libmesh_override
 
virtual FEContinuity get_continuity () const libmesh_override
 
virtual bool is_hierarchic () const libmesh_override
 
virtual void reinit (const Elem *elem, const std::vector< Point > *const pts=libmesh_nullptr, const std::vector< Real > *const weights=libmesh_nullptr) libmesh_override
 
virtual void reinit (const Elem *elem, const unsigned int side, const Real tolerance=TOLERANCE, const std::vector< Point > *const pts=libmesh_nullptr, const std::vector< Real > *const weights=libmesh_nullptr) libmesh_override
 
virtual void edge_reinit (const Elem *elem, const unsigned int edge, const Real tolerance=TOLERANCE, const std::vector< Point > *const pts=libmesh_nullptr, const std::vector< Real > *const weights=libmesh_nullptr) libmesh_override
 
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) libmesh_override
 
virtual void attach_quadrature_rule (QBase *q) libmesh_override
 
virtual unsigned int n_quadrature_points () const libmesh_override
 
virtual bool shapes_need_reinit () const libmesh_override
 
const std::vector< std::vector< OutputShape > > & get_phi () const
 
const std::vector< std::vector< OutputGradient > > & get_dphi () const
 
const std::vector< std::vector< OutputShape > > & get_curl_phi () const
 
const std::vector< std::vector< OutputDivergence > > & get_div_phi () const
 
const std::vector< std::vector< OutputShape > > & get_dphidx () const
 
const std::vector< std::vector< OutputShape > > & get_dphidy () const
 
const std::vector< std::vector< OutputShape > > & get_dphidz () const
 
const std::vector< std::vector< OutputShape > > & get_dphidxi () const
 
const std::vector< std::vector< OutputShape > > & get_dphideta () const
 
const std::vector< std::vector< OutputShape > > & get_dphidzeta () const
 
const std::vector< std::vector< OutputTensor > > & get_d2phi () const
 
const std::vector< std::vector< OutputShape > > & get_d2phidx2 () const
 
const std::vector< std::vector< OutputShape > > & get_d2phidxdy () const
 
const std::vector< std::vector< OutputShape > > & get_d2phidxdz () const
 
const std::vector< std::vector< OutputShape > > & get_d2phidy2 () const
 
const std::vector< std::vector< OutputShape > > & get_d2phidydz () const
 
const std::vector< std::vector< OutputShape > > & get_d2phidz2 () const
 
const std::vector< std::vector< OutputShape > > & get_d2phidxi2 () const
 
const std::vector< std::vector< OutputShape > > & get_d2phidxideta () const
 
const std::vector< std::vector< OutputShape > > & get_d2phidxidzeta () const
 
const std::vector< std::vector< OutputShape > > & get_d2phideta2 () const
 
const std::vector< std::vector< OutputShape > > & get_d2phidetadzeta () const
 
const std::vector< std::vector< OutputShape > > & get_d2phidzeta2 () const
 
const std::vector< OutputGradient > & get_dphase () const
 
const std::vector< Real > & get_Sobolev_weight () const
 
const std::vector< RealGradient > & get_Sobolev_dweight () const
 
void print_phi (std::ostream &os) const
 
void print_dphi (std::ostream &os) const
 
void print_d2phi (std::ostream &os) const
 
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
 
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)
 
FEFamily get_family () const
 
const FEMapget_fe_map () const
 
void print_JxW (std::ostream &os) const
 
void print_xyz (std::ostream &os) const
 
void print_info (std::ostream &os) const
 

Static Public Member Functions

static OutputShape shape (const ElemType t, const Order o, const unsigned int i, const Point &p)
 
static OutputShape shape (const Elem *elem, const Order o, const unsigned int i, const Point &p)
 
static OutputShape shape_deriv (const ElemType t, const Order o, const unsigned int i, const unsigned int j, const Point &p)
 
static OutputShape shape_deriv (const Elem *elem, const Order o, const unsigned int i, const unsigned int j, const Point &p)
 
static OutputShape shape_second_deriv (const ElemType t, const Order o, const unsigned int i, const unsigned int j, const Point &p)
 
static OutputShape shape_second_deriv (const Elem *elem, const Order o, const unsigned int i, const unsigned int j, const Point &p)
 
static void nodal_soln (const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)
 
static unsigned int n_shape_functions (const ElemType t, const Order o)
 
static unsigned int n_dofs (const ElemType t, const Order o)
 
static unsigned int n_dofs_at_node (const ElemType t, const Order o, const unsigned int n)
 
static unsigned int n_dofs_per_elem (const ElemType t, const Order o)
 
static void dofs_on_side (const Elem *const elem, const Order o, unsigned int s, std::vector< unsigned int > &di)
 
static void dofs_on_edge (const Elem *const elem, const Order o, unsigned int e, std::vector< unsigned int > &di)
 
static Point inverse_map (const Elem *elem, const Point &p, const Real tolerance=TOLERANCE, const bool secure=true)
 
static void inverse_map (const Elem *elem, const std::vector< Point > &physical_points, std::vector< Point > &reference_points, const Real tolerance=TOLERANCE, const bool secure=true)
 
static void compute_constraints (DofConstraints &constraints, DofMap &dof_map, const unsigned int variable_number, const Elem *elem)
 
static Point map (const Elem *elem, const Point &reference_point)
 
static Point map_xi (const Elem *elem, const Point &reference_point)
 
static Point map_eta (const Elem *elem, const Point &reference_point)
 
static Point map_zeta (const Elem *elem, const Point &reference_point)
 
static std::unique_ptr< FEGenericBasebuild (const unsigned int dim, const FEType &type)
 
static std::unique_ptr< FEGenericBasebuild_InfFE (const unsigned int dim, const FEType &type)
 
static void compute_proj_constraints (DofConstraints &constraints, DofMap &dof_map, const unsigned int variable_number, const Elem *elem)
 
static void coarsened_dof_values (const NumericVector< Number > &global_vector, const DofMap &dof_map, const Elem *coarse_elem, DenseVector< Number > &coarse_dofs, const unsigned int var, const bool use_old_dof_indices=false)
 
static void coarsened_dof_values (const NumericVector< Number > &global_vector, const DofMap &dof_map, const Elem *coarse_elem, DenseVector< Number > &coarse_dofs, const bool use_old_dof_indices=false)
 
static void compute_periodic_constraints (DofConstraints &constraints, DofMap &dof_map, const PeriodicBoundaries &boundaries, const MeshBase &mesh, const PointLocatorBase *point_locator, const unsigned int variable_number, const Elem *elem)
 
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)
 
static void compute_periodic_node_constraints (NodeConstraints &constraints, const PeriodicBoundaries &boundaries, const MeshBase &mesh, const PointLocatorBase *point_locator, const Elem *elem)
 
static void print_info (std::ostream &out=libMesh::out)
 
static std::string get_info ()
 
static unsigned int n_objects ()
 
static void enable_print_counter_info ()
 
static void disable_print_counter_info ()
 

Protected Types

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

Protected Member Functions

virtual void init_shape_functions (const std::vector< Point > &qp, const Elem *e)
 
virtual void init_base_shape_functions (const std::vector< Point > &qp, const Elem *e) libmesh_override
 
void determine_calculations ()
 
virtual void compute_shape_functions (const Elem *elem, const std::vector< Point > &qp)
 
void increment_constructor_count (const std::string &name)
 
void increment_destructor_count (const std::string &name)
 

Protected Attributes

std::vector< Pointcached_nodes
 
ElemType last_side
 
unsigned int last_edge
 
std::unique_ptr< FETransformationBase< FEOutputType< T >::type > > _fe_trans
 
std::vector< std::vector< OutputShape > > phi
 
std::vector< std::vector< OutputGradient > > dphi
 
std::vector< std::vector< OutputShape > > curl_phi
 
std::vector< std::vector< OutputDivergence > > div_phi
 
std::vector< std::vector< OutputShape > > dphidxi
 
std::vector< std::vector< OutputShape > > dphideta
 
std::vector< std::vector< OutputShape > > dphidzeta
 
std::vector< std::vector< OutputShape > > dphidx
 
std::vector< std::vector< OutputShape > > dphidy
 
std::vector< std::vector< OutputShape > > dphidz
 
std::vector< std::vector< OutputTensor > > d2phi
 
std::vector< std::vector< OutputShape > > d2phidxi2
 
std::vector< std::vector< OutputShape > > d2phidxideta
 
std::vector< std::vector< OutputShape > > d2phidxidzeta
 
std::vector< std::vector< OutputShape > > d2phideta2
 
std::vector< std::vector< OutputShape > > d2phidetadzeta
 
std::vector< std::vector< OutputShape > > d2phidzeta2
 
std::vector< std::vector< OutputShape > > d2phidx2
 
std::vector< std::vector< OutputShape > > d2phidxdy
 
std::vector< std::vector< OutputShape > > d2phidxdz
 
std::vector< std::vector< OutputShape > > d2phidy2
 
std::vector< std::vector< OutputShape > > d2phidydz
 
std::vector< std::vector< OutputShape > > d2phidz2
 
std::vector< OutputGradientdphase
 
std::vector< RealGradientdweight
 
std::vector< Realweight
 
std::unique_ptr< FEMap_fe_map
 
const unsigned int dim
 
bool calculations_started
 
bool calculate_phi
 
bool calculate_dphi
 
bool calculate_d2phi
 
bool calculate_curl_phi
 
bool calculate_div_phi
 
bool calculate_dphiref
 
FEType fe_type
 
ElemType elem_type
 
unsigned int _p_level
 
QBaseqrule
 
bool shapes_on_quadrature
 

Static Protected Attributes

static Counts _counts
 
static Threads::atomic< unsigned int > _n_objects
 
static Threads::spin_mutex _mutex
 
static bool _enable_print_counter = true
 

Detailed Description

template<unsigned int Dim>
class libMesh::FELagrange< Dim >

Lagrange finite elements. Still templated on the dimension, Dim.

Author
Benjamin S. Kirk
Date
2002-2007

Definition at line 737 of file fe.h.

Member Typedef Documentation

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.

Definition at line 123 of file fe_base.h.

Definition at line 121 of file fe_base.h.

Definition at line 124 of file fe_base.h.

Definition at line 127 of file fe_base.h.

Definition at line 125 of file fe_base.h.

Definition at line 126 of file fe_base.h.

typedef FEGenericBase<typename FEOutputType<T>::type>::OutputShape libMesh::FE< Dim, T >::OutputShape
inherited

Definition at line 101 of file fe.h.

Definition at line 122 of file fe_base.h.

Constructor & Destructor Documentation

template<unsigned int Dim>
libMesh::FELagrange< Dim >::FELagrange ( const FEType fet)
inlineexplicit

Constructor. Creates a Lagrange finite element to be used in dimension Dim.

Definition at line 746 of file fe.h.

746  :
747  FE<Dim,LAGRANGE> (fet)
748  {}

Member Function Documentation

virtual void libMesh::FE< Dim, T >::attach_quadrature_rule ( QBase q)
virtualinherited

Provides the class with the quadrature rule, which provides the locations (on a reference element) where the shape functions are to be calculated.

Implements libMesh::FEAbstract.

static std::unique_ptr<FEGenericBase> libMesh::FEGenericBase< FEOutputType< T >::type >::build ( const unsigned int  dim,
const FEType type 
)
staticinherited

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

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

static std::unique_ptr<FEGenericBase> libMesh::FEGenericBase< FEOutputType< T >::type >::build_InfFE ( const unsigned int  dim,
const FEType type 
)
staticinherited

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

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

static void libMesh::FEGenericBase< FEOutputType< T >::type >::coarsened_dof_values ( const NumericVector< Number > &  global_vector,
const DofMap dof_map,
const Elem coarse_elem,
DenseVector< Number > &  coarse_dofs,
const unsigned int  var,
const bool  use_old_dof_indices = false 
)
staticinherited

Creates a local projection on coarse_elem, based on the DoF values in global_vector for it's children. Computes a vector of coefficients corresponding to dof_indices for only the single given var

static void libMesh::FEGenericBase< FEOutputType< T >::type >::coarsened_dof_values ( const NumericVector< Number > &  global_vector,
const DofMap dof_map,
const Elem coarse_elem,
DenseVector< Number > &  coarse_dofs,
const bool  use_old_dof_indices = false 
)
staticinherited

Creates a local projection on coarse_elem, based on the DoF values in global_vector for it's children. Computes a vector of coefficients corresponding to all dof_indices.

static void libMesh::FE< Dim, T >::compute_constraints ( DofConstraints constraints,
DofMap dof_map,
const unsigned int  variable_number,
const Elem elem 
)
staticinherited

Computes the constraint matrix contributions (for non-conforming adapted meshes) corresponding to variable number var_number, using element-specific optimizations if possible.

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

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

Definition at line 793 of file fe_abstract.C.

References std::abs(), libMesh::Elem::build_side_ptr(), libMesh::Elem::default_order(), libMesh::Elem::dim(), libMesh::FEAbstract::fe_type, libMesh::FEInterface::inverse_map(), libMesh::LAGRANGE, libMesh::Elem::level(), libmesh_nullptr, 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().

795 {
796  libmesh_assert(elem);
797 
798  const unsigned int Dim = elem->dim();
799 
800  // Only constrain elements in 2,3D.
801  if (Dim == 1)
802  return;
803 
804  // Only constrain active and ancestor elements
805  if (elem->subactive())
806  return;
807 
808  // We currently always use LAGRANGE mappings for geometry
809  const FEType fe_type(elem->default_order(), LAGRANGE);
810 
811  std::vector<const Node *> my_nodes, parent_nodes;
812 
813  // Look at the element faces. Check to see if we need to
814  // build constraints.
815  for (auto s : elem->side_index_range())
816  if (elem->neighbor_ptr(s) != libmesh_nullptr &&
817  elem->neighbor_ptr(s) != remote_elem)
818  if (elem->neighbor_ptr(s)->level() < elem->level()) // constrain dofs shared between
819  { // this element and ones coarser
820  // than this element.
821  // Get pointers to the elements of interest and its parent.
822  const Elem * parent = elem->parent();
823 
824  // This can't happen... Only level-0 elements have NULL
825  // parents, and no level-0 elements can be at a higher
826  // level than their neighbors!
827  libmesh_assert(parent);
828 
829  const std::unique_ptr<const Elem> my_side (elem->build_side_ptr(s));
830  const std::unique_ptr<const Elem> parent_side (parent->build_side_ptr(s));
831 
832  const unsigned int n_side_nodes = my_side->n_nodes();
833 
834  my_nodes.clear();
835  my_nodes.reserve (n_side_nodes);
836  parent_nodes.clear();
837  parent_nodes.reserve (n_side_nodes);
838 
839  for (unsigned int n=0; n != n_side_nodes; ++n)
840  my_nodes.push_back(my_side->node_ptr(n));
841 
842  for (unsigned int n=0; n != n_side_nodes; ++n)
843  parent_nodes.push_back(parent_side->node_ptr(n));
844 
845  for (unsigned int my_side_n=0;
846  my_side_n < n_side_nodes;
847  my_side_n++)
848  {
849  libmesh_assert_less (my_side_n, FEInterface::n_dofs(Dim-1, fe_type, my_side->type()));
850 
851  const Node * my_node = my_nodes[my_side_n];
852 
853  // The support point of the DOF
854  const Point & support_point = *my_node;
855 
856  // Figure out where my node lies on their reference element.
857  const Point mapped_point = FEInterface::inverse_map(Dim-1, fe_type,
858  parent_side.get(),
859  support_point);
860 
861  // Compute the parent's side shape function values.
862  for (unsigned int their_side_n=0;
863  their_side_n < n_side_nodes;
864  their_side_n++)
865  {
866  libmesh_assert_less (their_side_n, FEInterface::n_dofs(Dim-1, fe_type, parent_side->type()));
867 
868  const Node * their_node = parent_nodes[their_side_n];
869  libmesh_assert(their_node);
870 
871  const Real their_value = FEInterface::shape(Dim-1,
872  fe_type,
873  parent_side->type(),
874  their_side_n,
875  mapped_point);
876 
877  const Real their_mag = std::abs(their_value);
878 #ifdef DEBUG
879  // Protect for the case u_i ~= u_j,
880  // in which case i better equal j.
881  if (their_mag > 0.999)
882  {
883  libmesh_assert_equal_to (my_node, their_node);
884  libmesh_assert_less (std::abs(their_value - 1.), 0.001);
885  }
886  else
887 #endif
888  // To make nodal constraints useful for constructing
889  // sparsity patterns faster, we need to get EVERY
890  // POSSIBLE constraint coupling identified, even if
891  // there is no coupling in the isoparametric
892  // Lagrange case.
893  if (their_mag < 1.e-5)
894  {
895  // since we may be running this method concurrently
896  // on multiple threads we need to acquire a lock
897  // before modifying the shared constraint_row object.
898  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
899 
900  // A reference to the constraint row.
901  NodeConstraintRow & constraint_row = constraints[my_node].first;
902 
903  constraint_row.insert(std::make_pair (their_node,
904  0.));
905  }
906  // To get nodal coordinate constraints right, only
907  // add non-zero and non-identity values for Lagrange
908  // basis functions.
909  else // (1.e-5 <= their_mag <= .999)
910  {
911  // since we may be running this method concurrently
912  // on multiple threads we need to acquire a lock
913  // before modifying the shared constraint_row object.
914  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
915 
916  // A reference to the constraint row.
917  NodeConstraintRow & constraint_row = constraints[my_node].first;
918 
919  constraint_row.insert(std::make_pair (their_node,
920  their_value));
921  }
922  }
923  }
924  }
925 }
double abs(double a)
static unsigned int n_dofs(const unsigned int dim, const FEType &fe_t, const ElemType t)
Definition: fe_interface.C:411
const class libmesh_nullptr_t libmesh_nullptr
spin_mutex spin_mtx
Definition: threads.C:29
static Real shape(const unsigned int dim, const FEType &fe_t, const ElemType t, const unsigned int i, const Point &p)
Definition: fe_interface.C:614
static Point inverse_map(const unsigned int dim, const FEType &fe_t, const Elem *elem, const Point &p, const Real tolerance=TOLERANCE, const bool secure=true)
Definition: fe_interface.C:547
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
std::map< const Node *, Real, std::less< const Node * >, Threads::scalable_allocator< std::pair< const Node *const, Real > > > NodeConstraintRow
Definition: dof_map.h:137
const RemoteElem * remote_elem
Definition: remote_elem.C:57
static void libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints ( DofConstraints constraints,
DofMap dof_map,
const PeriodicBoundaries boundaries,
const MeshBase mesh,
const PointLocatorBase point_locator,
const unsigned int  variable_number,
const Elem elem 
)
staticinherited

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

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

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

Definition at line 936 of file fe_abstract.C.

References libMesh::Elem::active(), libMesh::PeriodicBoundaries::boundary(), libMesh::BoundaryInfo::boundary_ids(), libMesh::Elem::build_side_ptr(), libMesh::Elem::default_order(), libMesh::Elem::dim(), libMesh::FEAbstract::fe_type, libMesh::MeshBase::get_boundary_info(), libMesh::PeriodicBoundaryBase::get_corresponding_pos(), libMesh::invalid_uint, libMesh::FEInterface::inverse_map(), libMesh::LAGRANGE, libMesh::Elem::level(), libMesh::FEInterface::n_dofs(), libMesh::PeriodicBoundaries::neighbor(), libMesh::Elem::neighbor_ptr(), libMesh::PeriodicBoundaryBase::pairedboundary, libMesh::Real, libMesh::FEInterface::shape(), libMesh::Elem::side_index_range(), libMesh::BoundaryInfo::side_with_boundary_id(), and libMesh::Threads::spin_mtx.

941 {
942  // Only bother if we truly have periodic boundaries
943  if (boundaries.empty())
944  return;
945 
946  libmesh_assert(elem);
947 
948  // Only constrain active elements with this method
949  if (!elem->active())
950  return;
951 
952  const unsigned int Dim = elem->dim();
953 
954  // We currently always use LAGRANGE mappings for geometry
955  const FEType fe_type(elem->default_order(), LAGRANGE);
956 
957  std::vector<const Node *> my_nodes, neigh_nodes;
958 
959  // Look at the element faces. Check to see if we need to
960  // build constraints.
961  std::vector<boundary_id_type> bc_ids;
962  for (auto s : elem->side_index_range())
963  {
964  if (elem->neighbor_ptr(s))
965  continue;
966 
967  mesh.get_boundary_info().boundary_ids (elem, s, bc_ids);
968  for (std::vector<boundary_id_type>::const_iterator id_it=bc_ids.begin(); id_it!=bc_ids.end(); ++id_it)
969  {
970  const boundary_id_type boundary_id = *id_it;
971  const PeriodicBoundaryBase * periodic = boundaries.boundary(boundary_id);
972  if (periodic)
973  {
974  libmesh_assert(point_locator);
975 
976  // Get pointers to the element's neighbor.
977  const Elem * neigh = boundaries.neighbor(boundary_id, *point_locator, elem, s);
978 
979  // h refinement constraints:
980  // constrain dofs shared between
981  // this element and ones as coarse
982  // as or coarser than this element.
983  if (neigh->level() <= elem->level())
984  {
985  unsigned int s_neigh =
986  mesh.get_boundary_info().side_with_boundary_id(neigh, periodic->pairedboundary);
987  libmesh_assert_not_equal_to (s_neigh, libMesh::invalid_uint);
988 
989 #ifdef LIBMESH_ENABLE_AMR
990  libmesh_assert(neigh->active());
991 #endif // #ifdef LIBMESH_ENABLE_AMR
992 
993  const std::unique_ptr<const Elem> my_side (elem->build_side_ptr(s));
994  const std::unique_ptr<const Elem> neigh_side (neigh->build_side_ptr(s_neigh));
995 
996  const unsigned int n_side_nodes = my_side->n_nodes();
997 
998  my_nodes.clear();
999  my_nodes.reserve (n_side_nodes);
1000  neigh_nodes.clear();
1001  neigh_nodes.reserve (n_side_nodes);
1002 
1003  for (unsigned int n=0; n != n_side_nodes; ++n)
1004  my_nodes.push_back(my_side->node_ptr(n));
1005 
1006  for (unsigned int n=0; n != n_side_nodes; ++n)
1007  neigh_nodes.push_back(neigh_side->node_ptr(n));
1008 
1009  // Make sure we're not adding recursive constraints
1010  // due to the redundancy in the way we add periodic
1011  // boundary constraints, or adding constraints to
1012  // nodes that already have AMR constraints
1013  std::vector<bool> skip_constraint(n_side_nodes, false);
1014 
1015  for (unsigned int my_side_n=0;
1016  my_side_n < n_side_nodes;
1017  my_side_n++)
1018  {
1019  libmesh_assert_less (my_side_n, FEInterface::n_dofs(Dim-1, fe_type, my_side->type()));
1020 
1021  const Node * my_node = my_nodes[my_side_n];
1022 
1023  // Figure out where my node lies on their reference element.
1024  const Point neigh_point = periodic->get_corresponding_pos(*my_node);
1025 
1026  const Point mapped_point = FEInterface::inverse_map(Dim-1, fe_type,
1027  neigh_side.get(),
1028  neigh_point);
1029 
1030  // If we've already got a constraint on this
1031  // node, then the periodic constraint is
1032  // redundant
1033  {
1034  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
1035 
1036  if (constraints.count(my_node))
1037  {
1038  skip_constraint[my_side_n] = true;
1039  continue;
1040  }
1041  }
1042 
1043  // Compute the neighbors's side shape function values.
1044  for (unsigned int their_side_n=0;
1045  their_side_n < n_side_nodes;
1046  their_side_n++)
1047  {
1048  libmesh_assert_less (their_side_n, FEInterface::n_dofs(Dim-1, fe_type, neigh_side->type()));
1049 
1050  const Node * their_node = neigh_nodes[their_side_n];
1051 
1052  // If there's a constraint on an opposing node,
1053  // we need to see if it's constrained by
1054  // *our side* making any periodic constraint
1055  // on us recursive
1056  {
1057  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
1058 
1059  if (!constraints.count(their_node))
1060  continue;
1061 
1062  const NodeConstraintRow & their_constraint_row =
1063  constraints[their_node].first;
1064 
1065  for (unsigned int orig_side_n=0;
1066  orig_side_n < n_side_nodes;
1067  orig_side_n++)
1068  {
1069  libmesh_assert_less (orig_side_n, FEInterface::n_dofs(Dim-1, fe_type, my_side->type()));
1070 
1071  const Node * orig_node = my_nodes[orig_side_n];
1072 
1073  if (their_constraint_row.count(orig_node))
1074  skip_constraint[orig_side_n] = true;
1075  }
1076  }
1077  }
1078  }
1079  for (unsigned int my_side_n=0;
1080  my_side_n < n_side_nodes;
1081  my_side_n++)
1082  {
1083  libmesh_assert_less (my_side_n, FEInterface::n_dofs(Dim-1, fe_type, my_side->type()));
1084 
1085  if (skip_constraint[my_side_n])
1086  continue;
1087 
1088  const Node * my_node = my_nodes[my_side_n];
1089 
1090  // Figure out where my node lies on their reference element.
1091  const Point neigh_point = periodic->get_corresponding_pos(*my_node);
1092 
1093  // Figure out where my node lies on their reference element.
1094  const Point mapped_point = FEInterface::inverse_map(Dim-1, fe_type,
1095  neigh_side.get(),
1096  neigh_point);
1097 
1098  for (unsigned int their_side_n=0;
1099  their_side_n < n_side_nodes;
1100  their_side_n++)
1101  {
1102  libmesh_assert_less (their_side_n, FEInterface::n_dofs(Dim-1, fe_type, neigh_side->type()));
1103 
1104  const Node * their_node = neigh_nodes[their_side_n];
1105  libmesh_assert(their_node);
1106 
1107  const Real their_value = FEInterface::shape(Dim-1,
1108  fe_type,
1109  neigh_side->type(),
1110  their_side_n,
1111  mapped_point);
1112 
1113  // since we may be running this method concurrently
1114  // on multiple threads we need to acquire a lock
1115  // before modifying the shared constraint_row object.
1116  {
1117  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
1118 
1119  NodeConstraintRow & constraint_row =
1120  constraints[my_node].first;
1121 
1122  constraint_row.insert(std::make_pair(their_node,
1123  their_value));
1124  }
1125  }
1126  }
1127  }
1128  }
1129  }
1130  }
1131 }
static unsigned int n_dofs(const unsigned int dim, const FEType &fe_t, const ElemType t)
Definition: fe_interface.C:411
const unsigned int invalid_uint
Definition: libmesh.h:184
MeshBase & mesh
spin_mutex spin_mtx
Definition: threads.C:29
int8_t boundary_id_type
Definition: id_types.h:51
static Real shape(const unsigned int dim, const FEType &fe_t, const ElemType t, const unsigned int i, const Point &p)
Definition: fe_interface.C:614
static Point inverse_map(const unsigned int dim, const FEType &fe_t, const Elem *elem, const Point &p, const Real tolerance=TOLERANCE, const bool secure=true)
Definition: fe_interface.C:547
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
std::map< const Node *, Real, std::less< const Node * >, Threads::scalable_allocator< std::pair< const Node *const, Real > > > NodeConstraintRow
Definition: dof_map.h:137
static void libMesh::FEGenericBase< FEOutputType< T >::type >::compute_proj_constraints ( DofConstraints constraints,
DofMap dof_map,
const unsigned int  variable_number,
const Elem elem 
)
staticinherited

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

virtual void libMesh::FEGenericBase< FEOutputType< T >::type >::compute_shape_functions ( const Elem elem,
const std::vector< Point > &  qp 
)
protectedvirtualinherited

After having updated the jacobian and the transformation from local to global coordinates in FEAbstract::compute_map(), the first derivatives of the shape functions are transformed to global coordinates, giving dphi, dphidx, dphidy, and dphidz. This method should rarely be re-defined in derived classes, but still should be usable for children. Therefore, keep it protected.

Implements libMesh::FEAbstract.

Reimplemented in libMesh::FEXYZ< Dim >.

void libMesh::FEGenericBase< FEOutputType< T >::type >::determine_calculations ( )
protectedinherited

Determine which values are to be calculated, for both the FE itself and for the FEMap.

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

void libMesh::ReferenceCounter::disable_print_counter_info ( )
staticinherited
static void libMesh::FE< Dim, T >::dofs_on_edge ( const Elem *const  elem,
const Order  o,
unsigned int  e,
std::vector< unsigned int > &  di 
)
staticinherited

Fills the vector di with the local degree of freedom indices associated with edge e of element elem

On a p-refined element, o should be the base order of the element.

static void libMesh::FE< Dim, T >::dofs_on_side ( const Elem *const  elem,
const Order  o,
unsigned int  s,
std::vector< unsigned int > &  di 
)
staticinherited

Fills the vector di with the local degree of freedom indices associated with side s of element elem

On a p-refined element, o should be the base order of the element.

virtual void libMesh::FE< Dim, T >::edge_reinit ( const Elem elem,
const unsigned int  edge,
const Real  tolerance = TOLERANCE,
const std::vector< Point > *const  pts = libmesh_nullptr,
const std::vector< Real > *const  weights = libmesh_nullptr 
)
virtualinherited

Reinitializes all the physical element-dependent data based on the edge. The tolerance parameter is passed to the involved call to inverse_map(). By default the shape functions and associated data are computed at the quadrature points specified by the quadrature rule qrule, but may be any points specified on the reference side element specified in the optional argument pts.

Implements libMesh::FEAbstract.

void libMesh::ReferenceCounter::enable_print_counter_info ( )
staticinherited

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

Definition at line 101 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

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

102 {
103  _enable_print_counter = true;
104  return;
105 }
virtual FEContinuity libMesh::FE< Dim, T >::get_continuity ( ) const
virtualinherited
Returns
The continuity level of the finite element.

Implements libMesh::FEAbstract.

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_curl_phi ( ) const
inlineinherited
Returns
The curl of the shape function at the quadrature points.

Definition at line 224 of file fe_base.h.

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

225  { libmesh_assert(!calculations_started || calculate_curl_phi);
226  calculate_curl_phi = calculate_dphiref = true; return curl_phi; }
std::vector< std::vector< OutputShape > > curl_phi
Definition: fe_base.h:509
const std::vector<Real>& libMesh::FEAbstract::get_curvatures ( ) const
inlineinherited
Returns
The curvatures for use in face integration.

Definition at line 383 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map, libMesh::FEAbstract::attach_quadrature_rule(), libMesh::FEAbstract::n_quadrature_points(), and libMesh::FEAbstract::n_shape_functions().

384  { return this->_fe_map->get_curvatures();}
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:517
const std::vector<std::vector<OutputTensor> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phi ( ) const
inlineinherited
Returns
The shape function second derivatives at the quadrature points.

Definition at line 290 of file fe_base.h.

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

291  { libmesh_assert(!calculations_started || calculate_d2phi);
292  calculate_d2phi = calculate_dphiref = true; return d2phi; }
std::vector< std::vector< OutputTensor > > d2phi
Definition: fe_base.h:552
const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phideta2 ( ) const
inlineinherited
Returns
The shape function second derivatives at the quadrature points, in reference coordinates

Definition at line 370 of file fe_base.h.

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

371  { libmesh_assert(!calculations_started || calculate_d2phi);
372  calculate_d2phi = calculate_dphiref = true; return d2phideta2; }
std::vector< std::vector< OutputShape > > d2phideta2
Definition: fe_base.h:572
const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidetadzeta ( ) const
inlineinherited
Returns
The shape function second derivatives at the quadrature points, in reference coordinates

Definition at line 378 of file fe_base.h.

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

379  { libmesh_assert(!calculations_started || calculate_d2phi);
std::vector< std::vector< OutputShape > > d2phidetadzeta
Definition: fe_base.h:577
const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidx2 ( ) const
inlineinherited
Returns
The shape function second derivatives at the quadrature points.

Definition at line 298 of file fe_base.h.

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

299  { libmesh_assert(!calculations_started || calculate_d2phi);
300  calculate_d2phi = calculate_dphiref = true; return d2phidx2; }
std::vector< std::vector< OutputShape > > d2phidx2
Definition: fe_base.h:587
const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxdy ( ) const
inlineinherited
Returns
The shape function second derivatives at the quadrature points.

Definition at line 306 of file fe_base.h.

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

307  { libmesh_assert(!calculations_started || calculate_d2phi);
308  calculate_d2phi = calculate_dphiref = true; return d2phidxdy; }
std::vector< std::vector< OutputShape > > d2phidxdy
Definition: fe_base.h:592
const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxdz ( ) const
inlineinherited
Returns
The shape function second derivatives at the quadrature points.

Definition at line 314 of file fe_base.h.

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

315  { libmesh_assert(!calculations_started || calculate_d2phi);
316  calculate_d2phi = calculate_dphiref = true; return d2phidxdz; }
std::vector< std::vector< OutputShape > > d2phidxdz
Definition: fe_base.h:597
const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxi2 ( ) const
inlineinherited
Returns
The shape function second derivatives at the quadrature points, in reference coordinates

Definition at line 346 of file fe_base.h.

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

347  { libmesh_assert(!calculations_started || calculate_d2phi);
348  calculate_d2phi = calculate_dphiref = true; return d2phidxi2; }
std::vector< std::vector< OutputShape > > d2phidxi2
Definition: fe_base.h:557
const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxideta ( ) const
inlineinherited
Returns
The shape function second derivatives at the quadrature points, in reference coordinates

Definition at line 354 of file fe_base.h.

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

355  { libmesh_assert(!calculations_started || calculate_d2phi);
std::vector< std::vector< OutputShape > > d2phidxideta
Definition: fe_base.h:562
const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxidzeta ( ) const
inlineinherited
Returns
The shape function second derivatives at the quadrature points, in reference coordinates

Definition at line 362 of file fe_base.h.

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

363  { libmesh_assert(!calculations_started || calculate_d2phi);
std::vector< std::vector< OutputShape > > d2phidxidzeta
Definition: fe_base.h:567
const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidy2 ( ) const
inlineinherited
Returns
The shape function second derivatives at the quadrature points.

Definition at line 322 of file fe_base.h.

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

323  { libmesh_assert(!calculations_started || calculate_d2phi);
324  calculate_d2phi = calculate_dphiref = true; return d2phidy2; }
std::vector< std::vector< OutputShape > > d2phidy2
Definition: fe_base.h:602
const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidydz ( ) const
inlineinherited
Returns
The shape function second derivatives at the quadrature points.

Definition at line 330 of file fe_base.h.

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

331  { libmesh_assert(!calculations_started || calculate_d2phi);
332  calculate_d2phi = calculate_dphiref = true; return d2phidydz; }
std::vector< std::vector< OutputShape > > d2phidydz
Definition: fe_base.h:607
const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidz2 ( ) const
inlineinherited
Returns
The shape function second derivatives at the quadrature points.

Definition at line 338 of file fe_base.h.

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

339  { libmesh_assert(!calculations_started || calculate_d2phi);
340  calculate_d2phi = calculate_dphiref = true; return d2phidz2; }
std::vector< std::vector< OutputShape > > d2phidz2
Definition: fe_base.h:612
const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidzeta2 ( ) const
inlineinherited
Returns
The shape function second derivatives at the quadrature points, in reference coordinates

Definition at line 386 of file fe_base.h.

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

387  { libmesh_assert(!calculations_started || calculate_d2phi);
388  calculate_d2phi = calculate_dphiref = true; return d2phidzeta2; }
std::vector< std::vector< OutputShape > > d2phidzeta2
Definition: fe_base.h:582
const std::vector<RealGradient>& libMesh::FEAbstract::get_d2xyzdeta2 ( ) const
inlineinherited
Returns
The second partial derivatives in eta.

Definition at line 270 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

271  { return this->_fe_map->get_d2xyzdeta2(); }
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:517
const std::vector<RealGradient>& libMesh::FEAbstract::get_d2xyzdetadzeta ( ) const
inlineinherited
Returns
The second partial derivatives in eta-zeta.

Definition at line 300 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

301  { return this->_fe_map->get_d2xyzdetadzeta(); }
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:517
const std::vector<RealGradient>& libMesh::FEAbstract::get_d2xyzdxi2 ( ) const
inlineinherited
Returns
The second partial derivatives in xi.

Definition at line 264 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

265  { return this->_fe_map->get_d2xyzdxi2(); }
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:517
const std::vector<RealGradient>& libMesh::FEAbstract::get_d2xyzdxideta ( ) const
inlineinherited
Returns
The second partial derivatives in xi-eta.

Definition at line 286 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

287  { return this->_fe_map->get_d2xyzdxideta(); }
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:517
const std::vector<RealGradient>& libMesh::FEAbstract::get_d2xyzdxidzeta ( ) const
inlineinherited
Returns
The second partial derivatives in xi-zeta.

Definition at line 294 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

295  { return this->_fe_map->get_d2xyzdxidzeta(); }
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:517
const std::vector<RealGradient>& libMesh::FEAbstract::get_d2xyzdzeta2 ( ) const
inlineinherited
Returns
The second partial derivatives in zeta.

Definition at line 278 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

279  { return this->_fe_map->get_d2xyzdzeta2(); }
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:517
const std::vector<Real>& libMesh::FEAbstract::get_detadx ( ) const
inlineinherited
Returns
The deta/dx entry in the transformation matrix from physical to local coordinates.

Definition at line 330 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

331  { return this->_fe_map->get_detadx(); }
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:517
const std::vector<Real>& libMesh::FEAbstract::get_detady ( ) const
inlineinherited
Returns
The deta/dy entry in the transformation matrix from physical to local coordinates.

Definition at line 337 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

338  { return this->_fe_map->get_detady(); }
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:517
const std::vector<Real>& libMesh::FEAbstract::get_detadz ( ) const
inlineinherited
Returns
The deta/dz entry in the transformation matrix from physical to local coordinates.

Definition at line 344 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

345  { return this->_fe_map->get_detadz(); }
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:517
unsigned int libMesh::FEAbstract::get_dim ( ) const
inlineinherited
Returns
the dimension of this FE

Definition at line 223 of file fe_abstract.h.

References libMesh::FEAbstract::dim.

224  { return dim; }
const unsigned int dim
Definition: fe_abstract.h:523
const std::vector<std::vector<OutputDivergence> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_div_phi ( ) const
inlineinherited
Returns
The divergence of the shape function at the quadrature points.

Definition at line 232 of file fe_base.h.

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

233  { libmesh_assert(!calculations_started || calculate_div_phi);
234  calculate_div_phi = calculate_dphiref = true; return div_phi; }
std::vector< std::vector< OutputDivergence > > div_phi
Definition: fe_base.h:514
const std::vector<OutputGradient>& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphase ( ) const
inlineinherited
Returns
The global first derivative of the phase term which is used in infinite elements, evaluated at the quadrature points.

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

Definition at line 404 of file fe_base.h.

References libMesh::FEGenericBase< OutputType >::dphase.

405  { return dphase; }
std::vector< OutputGradient > dphase
Definition: fe_base.h:630
const std::vector<std::vector<OutputGradient> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphi ( ) const
inlineinherited
Returns
The shape function derivatives at the quadrature points.

Definition at line 216 of file fe_base.h.

References libMesh::FEAbstract::calculate_dphi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, and libMesh::FEGenericBase< OutputType >::dphi.

217  { libmesh_assert(!calculations_started || calculate_dphi);
218  calculate_dphi = calculate_dphiref = true; return dphi; }
std::vector< std::vector< OutputGradient > > dphi
Definition: fe_base.h:504
const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphideta ( ) const
inlineinherited
Returns
The shape function eta-derivative at the quadrature points.

Definition at line 272 of file fe_base.h.

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

273  { libmesh_assert(!calculations_started || calculate_dphiref);
274  calculate_dphiref = true; return dphideta; }
std::vector< std::vector< OutputShape > > dphideta
Definition: fe_base.h:524
const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidx ( ) const
inlineinherited
Returns
The shape function x-derivative at the quadrature points.

Definition at line 240 of file fe_base.h.

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

241  { libmesh_assert(!calculations_started || calculate_dphi);
242  calculate_dphi = calculate_dphiref = true; return dphidx; }
std::vector< std::vector< OutputShape > > dphidx
Definition: fe_base.h:534
const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidxi ( ) const
inlineinherited
Returns
The shape function xi-derivative at the quadrature points.

Definition at line 264 of file fe_base.h.

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

265  { libmesh_assert(!calculations_started || calculate_dphiref);
266  calculate_dphiref = true; return dphidxi; }
std::vector< std::vector< OutputShape > > dphidxi
Definition: fe_base.h:519
const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidy ( ) const
inlineinherited
Returns
The shape function y-derivative at the quadrature points.

Definition at line 248 of file fe_base.h.

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

249  { libmesh_assert(!calculations_started || calculate_dphi);
250  calculate_dphi = calculate_dphiref = true; return dphidy; }
std::vector< std::vector< OutputShape > > dphidy
Definition: fe_base.h:539
const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidz ( ) const
inlineinherited
Returns
The shape function z-derivative at the quadrature points.

Definition at line 256 of file fe_base.h.

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

257  { libmesh_assert(!calculations_started || calculate_dphi);
258  calculate_dphi = calculate_dphiref = true; return dphidz; }
std::vector< std::vector< OutputShape > > dphidz
Definition: fe_base.h:544
const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidzeta ( ) const
inlineinherited
Returns
The shape function zeta-derivative at the quadrature points.

Definition at line 280 of file fe_base.h.

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

281  { libmesh_assert(!calculations_started || calculate_dphiref);
282  calculate_dphiref = true; return dphidzeta; }
std::vector< std::vector< OutputShape > > dphidzeta
Definition: fe_base.h:529
const std::vector<Real>& libMesh::FEAbstract::get_dxidx ( ) const
inlineinherited
Returns
The dxi/dx entry in the transformation matrix from physical to local coordinates.

Definition at line 309 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

310  { return this->_fe_map->get_dxidx(); }
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:517
const std::vector<Real>& libMesh::FEAbstract::get_dxidy ( ) const
inlineinherited
Returns
The dxi/dy entry in the transformation matrix from physical to local coordinates.

Definition at line 316 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

317  { return this->_fe_map->get_dxidy(); }
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:517
const std::vector<Real>& libMesh::FEAbstract::get_dxidz ( ) const
inlineinherited
Returns
The dxi/dz entry in the transformation matrix from physical to local coordinates.

Definition at line 323 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

324  { return this->_fe_map->get_dxidz(); }
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:517
const std::vector<RealGradient>& libMesh::FEAbstract::get_dxyzdeta ( ) const
inlineinherited
Returns
The element tangents in eta-direction at the quadrature points.

Definition at line 251 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

252  { return this->_fe_map->get_dxyzdeta(); }
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:517
const std::vector<RealGradient>& libMesh::FEAbstract::get_dxyzdxi ( ) const
inlineinherited
Returns
The element tangents in xi-direction at the quadrature points.

Definition at line 244 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

245  { return this->_fe_map->get_dxyzdxi(); }
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:517
const std::vector<RealGradient>& libMesh::FEAbstract::get_dxyzdzeta ( ) const
inlineinherited
Returns
The element tangents in zeta-direction at the quadrature points.

Definition at line 258 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

259  { return _fe_map->get_dxyzdzeta(); }
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:517
const std::vector<Real>& libMesh::FEAbstract::get_dzetadx ( ) const
inlineinherited
Returns
The dzeta/dx entry in the transformation matrix from physical to local coordinates.

Definition at line 351 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

352  { return this->_fe_map->get_dzetadx(); }
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:517
const std::vector<Real>& libMesh::FEAbstract::get_dzetady ( ) const
inlineinherited
Returns
The dzeta/dy entry in the transformation matrix from physical to local coordinates.

Definition at line 358 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

359  { return this->_fe_map->get_dzetady(); }
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:517
const std::vector<Real>& libMesh::FEAbstract::get_dzetadz ( ) const
inlineinherited
Returns
The dzeta/dz entry in the transformation matrix from physical to local coordinates.

Definition at line 365 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

366  { return this->_fe_map->get_dzetadz(); }
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:517
FEFamily libMesh::FEAbstract::get_family ( ) const
inlineinherited
Returns
The finite element family of this element.

Definition at line 447 of file fe_abstract.h.

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

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

447 { return fe_type.family; }
FEFamily family
Definition: fe_type.h:204
std::string libMesh::ReferenceCounter::get_info ( )
staticinherited

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

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

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

48 {
49 #if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
50 
51  std::ostringstream oss;
52 
53  oss << '\n'
54  << " ---------------------------------------------------------------------------- \n"
55  << "| Reference count information |\n"
56  << " ---------------------------------------------------------------------------- \n";
57 
58  for (Counts::iterator it = _counts.begin();
59  it != _counts.end(); ++it)
60  {
61  const std::string name(it->first);
62  const unsigned int creations = it->second.first;
63  const unsigned int destructions = it->second.second;
64 
65  oss << "| " << name << " reference count information:\n"
66  << "| Creations: " << creations << '\n'
67  << "| Destructions: " << destructions << '\n';
68  }
69 
70  oss << " ---------------------------------------------------------------------------- \n";
71 
72  return oss.str();
73 
74 #else
75 
76  return "";
77 
78 #endif
79 }
std::string name(const ElemQuality q)
Definition: elem_quality.C:39
const std::vector<Point>& libMesh::FEAbstract::get_normals ( ) const
inlineinherited
Order libMesh::FEAbstract::get_order ( ) const
inlineinherited
Returns
The approximation order of the finite element.

Definition at line 426 of file fe_abstract.h.

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

426 { return static_cast<Order>(fe_type.order + _p_level); }
unsigned int _p_level
Definition: fe_abstract.h:579
OrderWrapper order
Definition: fe_type.h:198
unsigned int libMesh::FEAbstract::get_p_level ( ) const
inlineinherited
Returns
The p refinement level that the current shape functions have been calculated for.

Definition at line 416 of file fe_abstract.h.

References libMesh::FEAbstract::_p_level.

416 { return _p_level; }
unsigned int _p_level
Definition: fe_abstract.h:579
const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_phi ( ) const
inlineinherited
Returns
The shape function values at the quadrature points on the element.

Definition at line 208 of file fe_base.h.

References libMesh::FEAbstract::calculate_phi, libMesh::FEAbstract::calculations_started, and libMesh::FEGenericBase< OutputType >::phi.

209  { libmesh_assert(!calculations_started || calculate_phi);
210  calculate_phi = true; return phi; }
std::vector< std::vector< OutputShape > > phi
Definition: fe_base.h:499
void libMesh::FEAbstract::get_refspace_nodes ( const ElemType  t,
std::vector< Point > &  nodes 
)
staticinherited
Returns
The reference space coordinates of nodes based on the element type.

Definition at line 256 of file fe_abstract.C.

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.

257 {
258  switch(itemType)
259  {
260  case EDGE2:
261  {
262  nodes.resize(2);
263  nodes[0] = Point (-1.,0.,0.);
264  nodes[1] = Point (1.,0.,0.);
265  return;
266  }
267  case EDGE3:
268  {
269  nodes.resize(3);
270  nodes[0] = Point (-1.,0.,0.);
271  nodes[1] = Point (1.,0.,0.);
272  nodes[2] = Point (0.,0.,0.);
273  return;
274  }
275  case TRI3:
276  case TRISHELL3:
277  {
278  nodes.resize(3);
279  nodes[0] = Point (0.,0.,0.);
280  nodes[1] = Point (1.,0.,0.);
281  nodes[2] = Point (0.,1.,0.);
282  return;
283  }
284  case TRI6:
285  {
286  nodes.resize(6);
287  nodes[0] = Point (0.,0.,0.);
288  nodes[1] = Point (1.,0.,0.);
289  nodes[2] = Point (0.,1.,0.);
290  nodes[3] = Point (.5,0.,0.);
291  nodes[4] = Point (.5,.5,0.);
292  nodes[5] = Point (0.,.5,0.);
293  return;
294  }
295  case QUAD4:
296  case QUADSHELL4:
297  {
298  nodes.resize(4);
299  nodes[0] = Point (-1.,-1.,0.);
300  nodes[1] = Point (1.,-1.,0.);
301  nodes[2] = Point (1.,1.,0.);
302  nodes[3] = Point (-1.,1.,0.);
303  return;
304  }
305  case QUAD8:
306  case QUADSHELL8:
307  {
308  nodes.resize(8);
309  nodes[0] = Point (-1.,-1.,0.);
310  nodes[1] = Point (1.,-1.,0.);
311  nodes[2] = Point (1.,1.,0.);
312  nodes[3] = Point (-1.,1.,0.);
313  nodes[4] = Point (0.,-1.,0.);
314  nodes[5] = Point (1.,0.,0.);
315  nodes[6] = Point (0.,1.,0.);
316  nodes[7] = Point (-1.,0.,0.);
317  return;
318  }
319  case QUAD9:
320  {
321  nodes.resize(9);
322  nodes[0] = Point (-1.,-1.,0.);
323  nodes[1] = Point (1.,-1.,0.);
324  nodes[2] = Point (1.,1.,0.);
325  nodes[3] = Point (-1.,1.,0.);
326  nodes[4] = Point (0.,-1.,0.);
327  nodes[5] = Point (1.,0.,0.);
328  nodes[6] = Point (0.,1.,0.);
329  nodes[7] = Point (-1.,0.,0.);
330  nodes[8] = Point (0.,0.,0.);
331  return;
332  }
333  case TET4:
334  {
335  nodes.resize(4);
336  nodes[0] = Point (0.,0.,0.);
337  nodes[1] = Point (1.,0.,0.);
338  nodes[2] = Point (0.,1.,0.);
339  nodes[3] = Point (0.,0.,1.);
340  return;
341  }
342  case TET10:
343  {
344  nodes.resize(10);
345  nodes[0] = Point (0.,0.,0.);
346  nodes[1] = Point (1.,0.,0.);
347  nodes[2] = Point (0.,1.,0.);
348  nodes[3] = Point (0.,0.,1.);
349  nodes[4] = Point (.5,0.,0.);
350  nodes[5] = Point (.5,.5,0.);
351  nodes[6] = Point (0.,.5,0.);
352  nodes[7] = Point (0.,0.,.5);
353  nodes[8] = Point (.5,0.,.5);
354  nodes[9] = Point (0.,.5,.5);
355  return;
356  }
357  case HEX8:
358  {
359  nodes.resize(8);
360  nodes[0] = Point (-1.,-1.,-1.);
361  nodes[1] = Point (1.,-1.,-1.);
362  nodes[2] = Point (1.,1.,-1.);
363  nodes[3] = Point (-1.,1.,-1.);
364  nodes[4] = Point (-1.,-1.,1.);
365  nodes[5] = Point (1.,-1.,1.);
366  nodes[6] = Point (1.,1.,1.);
367  nodes[7] = Point (-1.,1.,1.);
368  return;
369  }
370  case HEX20:
371  {
372  nodes.resize(20);
373  nodes[0] = Point (-1.,-1.,-1.);
374  nodes[1] = Point (1.,-1.,-1.);
375  nodes[2] = Point (1.,1.,-1.);
376  nodes[3] = Point (-1.,1.,-1.);
377  nodes[4] = Point (-1.,-1.,1.);
378  nodes[5] = Point (1.,-1.,1.);
379  nodes[6] = Point (1.,1.,1.);
380  nodes[7] = Point (-1.,1.,1.);
381  nodes[8] = Point (0.,-1.,-1.);
382  nodes[9] = Point (1.,0.,-1.);
383  nodes[10] = Point (0.,1.,-1.);
384  nodes[11] = Point (-1.,0.,-1.);
385  nodes[12] = Point (-1.,-1.,0.);
386  nodes[13] = Point (1.,-1.,0.);
387  nodes[14] = Point (1.,1.,0.);
388  nodes[15] = Point (-1.,1.,0.);
389  nodes[16] = Point (0.,-1.,1.);
390  nodes[17] = Point (1.,0.,1.);
391  nodes[18] = Point (0.,1.,1.);
392  nodes[19] = Point (-1.,0.,1.);
393  return;
394  }
395  case HEX27:
396  {
397  nodes.resize(27);
398  nodes[0] = Point (-1.,-1.,-1.);
399  nodes[1] = Point (1.,-1.,-1.);
400  nodes[2] = Point (1.,1.,-1.);
401  nodes[3] = Point (-1.,1.,-1.);
402  nodes[4] = Point (-1.,-1.,1.);
403  nodes[5] = Point (1.,-1.,1.);
404  nodes[6] = Point (1.,1.,1.);
405  nodes[7] = Point (-1.,1.,1.);
406  nodes[8] = Point (0.,-1.,-1.);
407  nodes[9] = Point (1.,0.,-1.);
408  nodes[10] = Point (0.,1.,-1.);
409  nodes[11] = Point (-1.,0.,-1.);
410  nodes[12] = Point (-1.,-1.,0.);
411  nodes[13] = Point (1.,-1.,0.);
412  nodes[14] = Point (1.,1.,0.);
413  nodes[15] = Point (-1.,1.,0.);
414  nodes[16] = Point (0.,-1.,1.);
415  nodes[17] = Point (1.,0.,1.);
416  nodes[18] = Point (0.,1.,1.);
417  nodes[19] = Point (-1.,0.,1.);
418  nodes[20] = Point (0.,0.,-1.);
419  nodes[21] = Point (0.,-1.,0.);
420  nodes[22] = Point (1.,0.,0.);
421  nodes[23] = Point (0.,1.,0.);
422  nodes[24] = Point (-1.,0.,0.);
423  nodes[25] = Point (0.,0.,1.);
424  nodes[26] = Point (0.,0.,0.);
425  return;
426  }
427  case PRISM6:
428  {
429  nodes.resize(6);
430  nodes[0] = Point (0.,0.,-1.);
431  nodes[1] = Point (1.,0.,-1.);
432  nodes[2] = Point (0.,1.,-1.);
433  nodes[3] = Point (0.,0.,1.);
434  nodes[4] = Point (1.,0.,1.);
435  nodes[5] = Point (0.,1.,1.);
436  return;
437  }
438  case PRISM15:
439  {
440  nodes.resize(15);
441  nodes[0] = Point (0.,0.,-1.);
442  nodes[1] = Point (1.,0.,-1.);
443  nodes[2] = Point (0.,1.,-1.);
444  nodes[3] = Point (0.,0.,1.);
445  nodes[4] = Point (1.,0.,1.);
446  nodes[5] = Point (0.,1.,1.);
447  nodes[6] = Point (.5,0.,-1.);
448  nodes[7] = Point (.5,.5,-1.);
449  nodes[8] = Point (0.,.5,-1.);
450  nodes[9] = Point (0.,0.,0.);
451  nodes[10] = Point (1.,0.,0.);
452  nodes[11] = Point (0.,1.,0.);
453  nodes[12] = Point (.5,0.,1.);
454  nodes[13] = Point (.5,.5,1.);
455  nodes[14] = Point (0.,.5,1.);
456  return;
457  }
458  case PRISM18:
459  {
460  nodes.resize(18);
461  nodes[0] = Point (0.,0.,-1.);
462  nodes[1] = Point (1.,0.,-1.);
463  nodes[2] = Point (0.,1.,-1.);
464  nodes[3] = Point (0.,0.,1.);
465  nodes[4] = Point (1.,0.,1.);
466  nodes[5] = Point (0.,1.,1.);
467  nodes[6] = Point (.5,0.,-1.);
468  nodes[7] = Point (.5,.5,-1.);
469  nodes[8] = Point (0.,.5,-1.);
470  nodes[9] = Point (0.,0.,0.);
471  nodes[10] = Point (1.,0.,0.);
472  nodes[11] = Point (0.,1.,0.);
473  nodes[12] = Point (.5,0.,1.);
474  nodes[13] = Point (.5,.5,1.);
475  nodes[14] = Point (0.,.5,1.);
476  nodes[15] = Point (.5,0.,0.);
477  nodes[16] = Point (.5,.5,0.);
478  nodes[17] = Point (0.,.5,0.);
479  return;
480  }
481  case PYRAMID5:
482  {
483  nodes.resize(5);
484  nodes[0] = Point (-1.,-1.,0.);
485  nodes[1] = Point (1.,-1.,0.);
486  nodes[2] = Point (1.,1.,0.);
487  nodes[3] = Point (-1.,1.,0.);
488  nodes[4] = Point (0.,0.,1.);
489  return;
490  }
491  case PYRAMID13:
492  {
493  nodes.resize(13);
494 
495  // base corners
496  nodes[0] = Point (-1.,-1.,0.);
497  nodes[1] = Point (1.,-1.,0.);
498  nodes[2] = Point (1.,1.,0.);
499  nodes[3] = Point (-1.,1.,0.);
500 
501  // apex
502  nodes[4] = Point (0.,0.,1.);
503 
504  // base midedge
505  nodes[5] = Point (0.,-1.,0.);
506  nodes[6] = Point (1.,0.,0.);
507  nodes[7] = Point (0.,1.,0.);
508  nodes[8] = Point (-1,0.,0.);
509 
510  // lateral midedge
511  nodes[9] = Point (-.5,-.5,.5);
512  nodes[10] = Point (.5,-.5,.5);
513  nodes[11] = Point (.5,.5,.5);
514  nodes[12] = Point (-.5,.5,.5);
515 
516  return;
517  }
518  case PYRAMID14:
519  {
520  nodes.resize(14);
521 
522  // base corners
523  nodes[0] = Point (-1.,-1.,0.);
524  nodes[1] = Point (1.,-1.,0.);
525  nodes[2] = Point (1.,1.,0.);
526  nodes[3] = Point (-1.,1.,0.);
527 
528  // apex
529  nodes[4] = Point (0.,0.,1.);
530 
531  // base midedge
532  nodes[5] = Point (0.,-1.,0.);
533  nodes[6] = Point (1.,0.,0.);
534  nodes[7] = Point (0.,1.,0.);
535  nodes[8] = Point (-1,0.,0.);
536 
537  // lateral midedge
538  nodes[9] = Point (-.5,-.5,.5);
539  nodes[10] = Point (.5,-.5,.5);
540  nodes[11] = Point (.5,.5,.5);
541  nodes[12] = Point (-.5,.5,.5);
542 
543  // base center
544  nodes[13] = Point (0.,0.,0.);
545 
546  return;
547  }
548 
549  default:
550  libmesh_error_msg("ERROR: Unknown element type " << itemType);
551  }
552 }
const std::vector<Real>& libMesh::FEGenericBase< FEOutputType< T >::type >::get_Sobolev_weight ( ) const
inlineinherited
Returns
The multiplicative weight at each quadrature point. This weight is used for certain infinite element weak formulations, so that weighted Sobolev spaces are used for the trial function space. This renders the variational form easily computable.

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

Definition at line 420 of file fe_base.h.

References libMesh::FEGenericBase< OutputType >::weight.

421  { return weight; }
const std::vector<std::vector<Point> >& libMesh::FEAbstract::get_tangents ( ) const
inlineinherited
Returns
The tangent vectors for face integration.

Definition at line 371 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

372  { return this->_fe_map->get_tangents(); }
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:517
ElemType libMesh::FEAbstract::get_type ( ) const
inlineinherited
Returns
The element type that the current shape functions have been calculated for. Useful in determining when shape functions must be recomputed.

Definition at line 410 of file fe_abstract.h.

References libMesh::FEAbstract::elem_type.

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

410 { return elem_type; }
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 185 of file reference_counter.h.

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

Referenced by libMesh::ReferenceCounter::n_objects(), and libMesh::ReferenceCountedObject< RBParametrized >::ReferenceCountedObject().

186 {
187  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
188  std::pair<unsigned int, unsigned int> & p = _counts[name];
189 
190  p.first++;
191 }
std::string name(const ElemQuality q)
Definition: elem_quality.C:39
spin_mutex spin_mtx
Definition: threads.C:29
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 198 of file reference_counter.h.

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

Referenced by libMesh::ReferenceCounter::n_objects(), and libMesh::ReferenceCountedObject< RBParametrized >::~ReferenceCountedObject().

199 {
200  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
201  std::pair<unsigned int, unsigned int> & p = _counts[name];
202 
203  p.second++;
204 }
std::string name(const ElemQuality q)
Definition: elem_quality.C:39
spin_mutex spin_mtx
Definition: threads.C:29
virtual void libMesh::FE< Dim, T >::init_base_shape_functions ( const std::vector< Point > &  qp,
const Elem e 
)
protectedvirtualinherited

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

Implements libMesh::FEGenericBase< FEOutputType< T >::type >.

virtual void libMesh::FE< Dim, T >::init_shape_functions ( const std::vector< Point > &  qp,
const Elem e 
)
protectedvirtualinherited

Update the various member data fields phi, dphidxi, dphideta, dphidzeta, etc. for the current element. These data will be computed at the points qp, which are generally (but need not be) the quadrature points.

static Point libMesh::FE< Dim, T >::inverse_map ( const Elem elem,
const Point p,
const Real  tolerance = TOLERANCE,
const bool  secure = true 
)
staticinherited
Returns
The location (on the reference element) of the point p located in physical space. This function requires inverting the (possibly nonlinear) transformation map, so it is not trivial. The optional parameter tolerance defines how close is "good enough." The map inversion iteration computes the sequence $ \{ p_n \} $, and the iteration is terminated when $ \|p - p_n\| < \mbox{\texttt{tolerance}} $
static void libMesh::FE< Dim, T >::inverse_map ( const Elem elem,
const std::vector< Point > &  physical_points,
std::vector< Point > &  reference_points,
const Real  tolerance = TOLERANCE,
const bool  secure = true 
)
staticinherited

Takes a number points in physical space (in the physical_points vector) and finds their location on the reference element for the input element elem. The values on the reference element are returned in the vector reference_points. The optional parameter tolerance defines how close is "good enough." The map inversion iteration computes the sequence $ \{ p_n \} $, and the iteration is terminated when $ \|p - p_n\| < \mbox{\texttt{tolerance}} $

virtual bool libMesh::FE< Dim, T >::is_hierarchic ( ) const
virtualinherited
Returns
true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

static Point libMesh::FE< Dim, T >::map ( const Elem elem,
const Point reference_point 
)
staticinherited
Returns
The location (in physical space) of the point p located on the reference element.
static Point libMesh::FE< Dim, T >::map_eta ( const Elem elem,
const Point reference_point 
)
staticinherited
Returns
d(xyz)/deta (in physical space) of the point p located on the reference element.
static Point libMesh::FE< Dim, T >::map_xi ( const Elem elem,
const Point reference_point 
)
staticinherited
Returns
d(xyz)/dxi (in physical space) of the point p located on the reference element.
static Point libMesh::FE< Dim, T >::map_zeta ( const Elem elem,
const Point reference_point 
)
staticinherited
Returns
d(xyz)/dzeta (in physical space) of the point p located on the reference element.
static unsigned int libMesh::FE< Dim, T >::n_dofs ( const ElemType  t,
const Order  o 
)
staticinherited
Returns
The number of shape functions associated with this finite element.

On a p-refined element, o should be the total order of the element.

static unsigned int libMesh::FE< Dim, T >::n_dofs_at_node ( const ElemType  t,
const Order  o,
const unsigned int  n 
)
staticinherited
Returns
The number of dofs at node n for a finite element of type t and order o.

On a p-refined element, o should be the total order of the element.

static unsigned int libMesh::FE< Dim, T >::n_dofs_per_elem ( const ElemType  t,
const Order  o 
)
staticinherited
Returns
The number of dofs interior to the element, not associated with any interior nodes.

On a p-refined element, o should be the total order of the element.

static unsigned int libMesh::ReferenceCounter::n_objects ( )
inlinestaticinherited
virtual unsigned int libMesh::FE< Dim, T >::n_quadrature_points ( ) const
virtualinherited
Returns
The total number of quadrature points. Call this to get an upper bound for the for loop in your simulation for matrix assembly of the current element.

Implements libMesh::FEAbstract.

virtual unsigned int libMesh::FE< Dim, T >::n_shape_functions ( ) const
virtualinherited
Returns
The number of shape functions associated with this finite element.

Implements libMesh::FEAbstract.

static unsigned int libMesh::FE< Dim, T >::n_shape_functions ( const ElemType  t,
const Order  o 
)
inlinestaticinherited
Returns
The number of shape functions associated with a finite element of type t and approximation order o.

On a p-refined element, o should be the total order of the element.

Definition at line 228 of file fe.h.

230  { return FE<Dim,T>::n_dofs (t,o); }
static void libMesh::FE< Dim, T >::nodal_soln ( const Elem elem,
const Order  o,
const std::vector< Number > &  elem_soln,
std::vector< Number > &  nodal_soln 
)
staticinherited

Build the nodal soln from the element soln. This is the solution that will be plotted.

On a p-refined element, o should be the base order of the element.

bool libMesh::FEAbstract::on_reference_element ( const Point p,
const ElemType  t,
const Real  eps = TOLERANCE 
)
staticinherited
Returns
true if the point p is located on the reference element for element type t, false otherwise. Since we are doing floating point comparisons here the parameter eps can be specified to indicate a tolerance. For example, $ x \le 1 $ becomes $ x \le 1 + \epsilon $.

Definition at line 554 of file fe_abstract.C.

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::FE< Dim, T >::inverse_map(), and libMesh::FEInterface::on_reference_element().

555 {
556  libmesh_assert_greater_equal (eps, 0.);
557 
558  const Real xi = p(0);
559 #if LIBMESH_DIM > 1
560  const Real eta = p(1);
561 #else
562  const Real eta = 0.;
563 #endif
564 #if LIBMESH_DIM > 2
565  const Real zeta = p(2);
566 #else
567  const Real zeta = 0.;
568 #endif
569 
570  switch (t)
571  {
572  case NODEELEM:
573  {
574  return (!xi && !eta && !zeta);
575  }
576  case EDGE2:
577  case EDGE3:
578  case EDGE4:
579  {
580  // The reference 1D element is [-1,1].
581  if ((xi >= -1.-eps) &&
582  (xi <= 1.+eps))
583  return true;
584 
585  return false;
586  }
587 
588 
589  case TRI3:
590  case TRISHELL3:
591  case TRI6:
592  {
593  // The reference triangle is isosceles
594  // and is bound by xi=0, eta=0, and xi+eta=1.
595  if ((xi >= 0.-eps) &&
596  (eta >= 0.-eps) &&
597  ((xi + eta) <= 1.+eps))
598  return true;
599 
600  return false;
601  }
602 
603 
604  case QUAD4:
605  case QUADSHELL4:
606  case QUAD8:
607  case QUADSHELL8:
608  case QUAD9:
609  {
610  // The reference quadrilateral element is [-1,1]^2.
611  if ((xi >= -1.-eps) &&
612  (xi <= 1.+eps) &&
613  (eta >= -1.-eps) &&
614  (eta <= 1.+eps))
615  return true;
616 
617  return false;
618  }
619 
620 
621  case TET4:
622  case TET10:
623  {
624  // The reference tetrahedral is isosceles
625  // and is bound by xi=0, eta=0, zeta=0,
626  // and xi+eta+zeta=1.
627  if ((xi >= 0.-eps) &&
628  (eta >= 0.-eps) &&
629  (zeta >= 0.-eps) &&
630  ((xi + eta + zeta) <= 1.+eps))
631  return true;
632 
633  return false;
634  }
635 
636 
637  case HEX8:
638  case HEX20:
639  case HEX27:
640  {
641  /*
642  if ((xi >= -1.) &&
643  (xi <= 1.) &&
644  (eta >= -1.) &&
645  (eta <= 1.) &&
646  (zeta >= -1.) &&
647  (zeta <= 1.))
648  return true;
649  */
650 
651  // The reference hexahedral element is [-1,1]^3.
652  if ((xi >= -1.-eps) &&
653  (xi <= 1.+eps) &&
654  (eta >= -1.-eps) &&
655  (eta <= 1.+eps) &&
656  (zeta >= -1.-eps) &&
657  (zeta <= 1.+eps))
658  {
659  // libMesh::out << "Strange Point:\n";
660  // p.print();
661  return true;
662  }
663 
664  return false;
665  }
666 
667  case PRISM6:
668  case PRISM15:
669  case PRISM18:
670  {
671  // Figure this one out...
672  // inside the reference triangle with zeta in [-1,1]
673  if ((xi >= 0.-eps) &&
674  (eta >= 0.-eps) &&
675  (zeta >= -1.-eps) &&
676  (zeta <= 1.+eps) &&
677  ((xi + eta) <= 1.+eps))
678  return true;
679 
680  return false;
681  }
682 
683 
684  case PYRAMID5:
685  case PYRAMID13:
686  case PYRAMID14:
687  {
688  // Check that the point is on the same side of all the faces
689  // by testing whether:
690  //
691  // n_i.(x - x_i) <= 0
692  //
693  // for each i, where:
694  // n_i is the outward normal of face i,
695  // x_i is a point on face i.
696  if ((-eta - 1. + zeta <= 0.+eps) &&
697  ( xi - 1. + zeta <= 0.+eps) &&
698  ( eta - 1. + zeta <= 0.+eps) &&
699  ( -xi - 1. + zeta <= 0.+eps) &&
700  ( zeta >= 0.-eps))
701  return true;
702 
703  return false;
704  }
705 
706 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
707  case INFHEX8:
708  case INFHEX16:
709  case INFHEX18:
710  {
711  // The reference infhex8 is a [-1,1]^3.
712  if ((xi >= -1.-eps) &&
713  (xi <= 1.+eps) &&
714  (eta >= -1.-eps) &&
715  (eta <= 1.+eps) &&
716  (zeta >= -1.-eps) &&
717  (zeta <= 1.+eps))
718  {
719  return true;
720  }
721  return false;
722  }
723 
724  case INFPRISM6:
725  case INFPRISM12:
726  {
727  // inside the reference triangle with zeta in [-1,1]
728  if ((xi >= 0.-eps) &&
729  (eta >= 0.-eps) &&
730  (zeta >= -1.-eps) &&
731  (zeta <= 1.+eps) &&
732  ((xi + eta) <= 1.+eps))
733  {
734  return true;
735  }
736 
737  return false;
738  }
739 #endif
740 
741  default:
742  libmesh_error_msg("ERROR: Unknown element type " << t);
743  }
744 
745  // If we get here then the point is _not_ in the
746  // reference element. Better return false.
747 
748  return false;
749 }
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
void libMesh::FEGenericBase< FEOutputType< T >::type >::print_d2phi ( std::ostream &  os) const
virtualinherited

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

Implements libMesh::FEAbstract.

void libMesh::FEGenericBase< FEOutputType< T >::type >::print_dphi ( std::ostream &  os) const
virtualinherited

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

Implements libMesh::FEAbstract.

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

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

Definition at line 88 of file reference_counter.C.

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

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

89 {
91  out_stream << ReferenceCounter::get_info();
92 }
static std::string get_info()
void libMesh::FEAbstract::print_info ( std::ostream &  os) const
inherited

Prints all the relevant information about the current element.

Definition at line 766 of file fe_abstract.C.

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

Referenced by libMesh::FEAbstract::get_fe_map(), and libMesh::operator<<().

767 {
768  os << "phi[i][j]: Shape function i at quadrature pt. j" << std::endl;
769  this->print_phi(os);
770 
771  os << "dphi[i][j]: Shape function i's gradient at quadrature pt. j" << std::endl;
772  this->print_dphi(os);
773 
774  os << "XYZ locations of the quadrature pts." << std::endl;
775  this->print_xyz(os);
776 
777  os << "Values of JxW at the quadrature pts." << std::endl;
778  this->print_JxW(os);
779 }
void print_JxW(std::ostream &os) const
Definition: fe_abstract.C:753
void print_xyz(std::ostream &os) const
Definition: fe_abstract.C:760
virtual void print_phi(std::ostream &os) const =0
virtual void print_dphi(std::ostream &os) const =0
void libMesh::FEAbstract::print_JxW ( std::ostream &  os) const
inherited

Prints the Jacobian times the weight for each quadrature point.

Definition at line 753 of file fe_abstract.C.

References libMesh::FEAbstract::_fe_map.

Referenced by libMesh::FEAbstract::get_fe_map(), and libMesh::FEAbstract::print_info().

754 {
755  this->_fe_map->print_JxW(os);
756 }
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:517
void libMesh::FEGenericBase< FEOutputType< T >::type >::print_phi ( std::ostream &  os) const
virtualinherited

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

Implements libMesh::FEAbstract.

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

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

Definition at line 760 of file fe_abstract.C.

References libMesh::FEAbstract::_fe_map.

Referenced by libMesh::FEAbstract::get_fe_map(), and libMesh::FEAbstract::print_info().

761 {
762  this->_fe_map->print_xyz(os);
763 }
std::unique_ptr< FEMap > _fe_map
Definition: fe_abstract.h:517
virtual void libMesh::FE< Dim, T >::reinit ( const Elem elem,
const std::vector< Point > *const  pts = libmesh_nullptr,
const std::vector< Real > *const  weights = libmesh_nullptr 
)
virtualinherited

This is at the core of this class. Use this for each new element in the mesh. Reinitializes all the physical element-dependent data based on the current element elem. By default the shape functions and associated data are computed at the quadrature points specified by the quadrature rule qrule, but may be any points specified on the reference element specified in the optional argument pts.

Implements libMesh::FEAbstract.

virtual void libMesh::FE< Dim, T >::reinit ( const Elem elem,
const unsigned int  side,
const Real  tolerance = TOLERANCE,
const std::vector< Point > *const  pts = libmesh_nullptr,
const std::vector< Real > *const  weights = libmesh_nullptr 
)
virtualinherited

Reinitializes all the physical element-dependent data based on the side of face. The tolerance parameter is passed to the involved call to inverse_map(). By default the shape functions and associated data are computed at the quadrature points specified by the quadrature rule qrule, but may be any points specified on the reference side element specified in the optional argument pts.

Implements libMesh::FEAbstract.

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

Sets the base FE order of the finite element.

Definition at line 431 of file fe_abstract.h.

References libMesh::FEAbstract::fe_type, libMesh::FEAbstract::get_continuity(), libMesh::FEAbstract::is_hierarchic(), and libMesh::FEType::order.

431 { fe_type.order = new_order; }
OrderWrapper order
Definition: fe_type.h:198
static OutputShape libMesh::FE< Dim, T >::shape ( const ElemType  t,
const Order  o,
const unsigned int  i,
const Point p 
)
staticinherited
Returns
The value of the $ i^{th} $ shape function at point p. This method allows you to specify the dimension, element type, and order directly. This allows the method to be static.

On a p-refined element, o should be the total order of the element.

static OutputShape libMesh::FE< Dim, T >::shape ( const Elem elem,
const Order  o,
const unsigned int  i,
const Point p 
)
staticinherited
Returns
The value of the $ i^{th} $ shape function at point p. This method allows you to specify the dimension, element type, and order directly. This allows the method to be static.

On a p-refined element, o should be the base order of the element.

static OutputShape libMesh::FE< Dim, T >::shape_deriv ( const ElemType  t,
const Order  o,
const unsigned int  i,
const unsigned int  j,
const Point p 
)
staticinherited
Returns
The $ j^{th} $ derivative of the $ i^{th} $ shape function at point p. This method allows you to specify the dimension, element type, and order directly.

On a p-refined element, o should be the total order of the element.

static OutputShape libMesh::FE< Dim, T >::shape_deriv ( const Elem elem,
const Order  o,
const unsigned int  i,
const unsigned int  j,
const Point p 
)
staticinherited
Returns
The $ j^{th} $ derivative of the $ i^{th} $ shape function. You must specify element type, and order directly.

On a p-refined element, o should be the base order of the element.

static OutputShape libMesh::FE< Dim, T >::shape_second_deriv ( const ElemType  t,
const Order  o,
const unsigned int  i,
const unsigned int  j,
const Point p 
)
staticinherited
Returns
The second $ j^{th} $ derivative of the $ i^{th} $ shape function at the point p.
Note
Cross-derivatives are indexed according to: j = 0 ==> d^2 phi / dxi^2 j = 1 ==> d^2 phi / dxi deta j = 2 ==> d^2 phi / deta^2 j = 3 ==> d^2 phi / dxi dzeta j = 4 ==> d^2 phi / deta dzeta j = 5 ==> d^2 phi / dzeta^2
Computing second derivatives is not currently supported for all element types: $ C^1 $ (Clough, Hermite and Subdivision), Lagrange, Hierarchic, L2_Hierarchic, and Monomial are supported. All other element types return an error when asked for second derivatives.

On a p-refined element, o should be the total order of the element.

static OutputShape libMesh::FE< Dim, T >::shape_second_deriv ( const Elem elem,
const Order  o,
const unsigned int  i,
const unsigned int  j,
const Point p 
)
staticinherited
Returns
The second $ j^{th} $ derivative of the $ i^{th} $ shape function at the point p.
Note
Cross-derivatives are indexed according to: j = 0 ==> d^2 phi / dxi^2 j = 1 ==> d^2 phi / dxi deta j = 2 ==> d^2 phi / deta^2 j = 3 ==> d^2 phi / dxi dzeta j = 4 ==> d^2 phi / deta dzeta j = 5 ==> d^2 phi / dzeta^2
Computing second derivatives is not currently supported for all element types: $ C^1 $ (Clough, Hermite and Subdivision), Lagrange, Hierarchic, L2_Hierarchic, and Monomial are supported. All other element types return an error when asked for second derivatives.

On a p-refined element, o should be the base order of the element.

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

Implements libMesh::FEAbstract.

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

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

Implements libMesh::FEAbstract.

Member Data Documentation

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts
staticprotectedinherited
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().

std::unique_ptr<FETransformationBase<FEOutputType< T >::type > > libMesh::FEGenericBase< FEOutputType< T >::type >::_fe_trans
protectedinherited

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

Definition at line 494 of file fe_base.h.

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.

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

The number of objects. Print the reference count information when the number returns to 0.

Definition at line 132 of file reference_counter.h.

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

unsigned int libMesh::FEAbstract::_p_level
protectedinherited

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

Definition at line 579 of file fe_abstract.h.

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

std::vector<Point> libMesh::FE< Dim, T >::cached_nodes
protectedinherited

An array of the node locations on the last element we computed on

Definition at line 475 of file fe.h.

bool libMesh::FEAbstract::calculate_curl_phi
mutableprotectedinherited

Should we calculate shape function curls?

Definition at line 549 of file fe_abstract.h.

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

bool libMesh::FEAbstract::calculate_div_phi
mutableprotectedinherited

Should we calculate shape function divergences?

Definition at line 554 of file fe_abstract.h.

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

bool libMesh::FEAbstract::calculate_dphiref
mutableprotectedinherited

Should we calculate reference shape function gradients?

Definition at line 559 of file fe_abstract.h.

Referenced by libMesh::FEGenericBase< FEOutputType< T >::type >::get_curl_phi(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phi(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phideta2(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidetadzeta(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidx2(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxdy(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxdz(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxi2(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxideta(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxidzeta(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidy2(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidydz(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidz2(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidzeta2(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_div_phi(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphi(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphideta(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidx(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidxi(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidy(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidz(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidzeta(), and libMesh::InfFE< Dim, T_radial, T_map >::reinit().

bool libMesh::FEAbstract::calculate_phi
mutableprotectedinherited

Should we calculate shape functions?

Definition at line 534 of file fe_abstract.h.

Referenced by libMesh::FEGenericBase< FEOutputType< T >::type >::get_phi(), and libMesh::InfFE< Dim, T_radial, T_map >::reinit().

bool libMesh::FEAbstract::calculations_started
mutableprotectedinherited

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

Definition at line 529 of file fe_abstract.h.

Referenced by libMesh::FEGenericBase< FEOutputType< T >::type >::get_curl_phi(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phi(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phideta2(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidetadzeta(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidx2(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxdy(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxdz(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxi2(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxideta(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxidzeta(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidy2(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidydz(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidz2(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidzeta2(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_div_phi(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphi(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphideta(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidx(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidxi(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidy(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidz(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidzeta(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_phi(), and libMesh::FESubdivision::init_shape_functions().

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::curl_phi
protectedinherited

Shape function curl values. Only defined for vector types.

Definition at line 509 of file fe_base.h.

std::vector<std::vector<OutputTensor> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phi
protectedinherited

Shape function second derivative values.

Definition at line 552 of file fe_base.h.

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

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phideta2
protectedinherited

Shape function second derivatives in the eta direction.

Definition at line 572 of file fe_base.h.

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

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidetadzeta
protectedinherited

Shape function second derivatives in the eta-zeta direction.

Definition at line 577 of file fe_base.h.

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidx2
protectedinherited

Shape function second derivatives in the x direction.

Definition at line 587 of file fe_base.h.

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidxdy
protectedinherited

Shape function second derivatives in the x-y direction.

Definition at line 592 of file fe_base.h.

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidxdz
protectedinherited

Shape function second derivatives in the x-z direction.

Definition at line 597 of file fe_base.h.

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidxi2
protectedinherited

Shape function second derivatives in the xi direction.

Definition at line 557 of file fe_base.h.

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

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidxideta
protectedinherited

Shape function second derivatives in the xi-eta direction.

Definition at line 562 of file fe_base.h.

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

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidxidzeta
protectedinherited

Shape function second derivatives in the xi-zeta direction.

Definition at line 567 of file fe_base.h.

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidy2
protectedinherited

Shape function second derivatives in the y direction.

Definition at line 602 of file fe_base.h.

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidydz
protectedinherited

Shape function second derivatives in the y-z direction.

Definition at line 607 of file fe_base.h.

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidz2
protectedinherited

Shape function second derivatives in the z direction.

Definition at line 612 of file fe_base.h.

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidzeta2
protectedinherited

Shape function second derivatives in the zeta direction.

Definition at line 582 of file fe_base.h.

const unsigned int libMesh::FEAbstract::dim
protectedinherited
std::vector<std::vector<OutputDivergence> > libMesh::FEGenericBase< FEOutputType< T >::type >::div_phi
protectedinherited

Shape function divergence values. Only defined for vector types.

Definition at line 514 of file fe_base.h.

std::vector<OutputGradient> libMesh::FEGenericBase< FEOutputType< T >::type >::dphase
protectedinherited

Used for certain infinite element families: the first derivatives of the phase term in global coordinates, over all quadrature points.

Definition at line 630 of file fe_base.h.

std::vector<std::vector<OutputGradient> > libMesh::FEGenericBase< FEOutputType< T >::type >::dphi
protectedinherited

Shape function derivative values.

Definition at line 504 of file fe_base.h.

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

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::dphideta
protectedinherited

Shape function derivatives in the eta direction.

Definition at line 524 of file fe_base.h.

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

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::dphidx
protectedinherited

Shape function derivatives in the x direction.

Definition at line 534 of file fe_base.h.

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::dphidxi
protectedinherited

Shape function derivatives in the xi direction.

Definition at line 519 of file fe_base.h.

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

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::dphidy
protectedinherited

Shape function derivatives in the y direction.

Definition at line 539 of file fe_base.h.

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::dphidz
protectedinherited

Shape function derivatives in the z direction.

Definition at line 544 of file fe_base.h.

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::dphidzeta
protectedinherited

Shape function derivatives in the zeta direction.

Definition at line 529 of file fe_base.h.

std::vector<RealGradient> libMesh::FEGenericBase< FEOutputType< T >::type >::dweight
protectedinherited

Used for certain infinite element families: the global derivative of the additional radial weight $ 1/{r^2} $, over all quadrature points.

Definition at line 637 of file fe_base.h.

ElemType libMesh::FEAbstract::elem_type
protectedinherited

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

Definition at line 573 of file fe_abstract.h.

Referenced by libMesh::FESubdivision::attach_quadrature_rule(), libMesh::FEAbstract::get_type(), and libMesh::InfFE< Dim, T_radial, T_map >::reinit().

unsigned int libMesh::FE< Dim, T >::last_edge
protectedinherited

Definition at line 482 of file fe.h.

ElemType libMesh::FE< Dim, T >::last_side
protectedinherited

The last side and last edge we did a reinit on

Definition at line 480 of file fe.h.

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::phi
protectedinherited

Shape function values.

Definition at line 499 of file fe_base.h.

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

QBase* libMesh::FEAbstract::qrule
protectedinherited

A pointer to the quadrature rule employed

Definition at line 584 of file fe_abstract.h.

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

bool libMesh::FEAbstract::shapes_on_quadrature
protectedinherited

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

Definition at line 590 of file fe_abstract.h.

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

std::vector<Real> libMesh::FEGenericBase< FEOutputType< T >::type >::weight
protectedinherited

Used for certain infinite element families: the additional radial weight $ 1/{r^2} $ in local coordinates, over all quadrature points.

Definition at line 644 of file fe_base.h.


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