Public Types | Public Member Functions | Static Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes | Static Protected Attributes | List of all members
libMesh::FEL2Hierarchic< Dim > Class Template Reference

#include <fe.h>

Inheritance diagram for libMesh::FEL2Hierarchic< Dim >:
Inheritance graph
[legend]

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

 FEL2Hierarchic (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
 
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 FEMap & get_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 UniquePtr< FEGenericBase > build (const unsigned int dim, const FEType &type)
 
static UniquePtr< FEGenericBase > build_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< Point > cached_nodes
 
ElemType last_side
 
unsigned int last_edge
 
UniquePtr< 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< OutputGradient > dphase
 
std::vector< RealGradient > dweight
 
std::vector< Real > weight
 
UniquePtr< 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
 
QBase * qrule
 
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::FEL2Hierarchic< Dim >

Discontinuous Hierarchic finite elements. Still templated on the dimension, Dim.

Author
Truman E. Ellis
Date
2011

Definition at line 713 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.

typedef TensorTools::DecrementRank<OutputShape>::type libMesh::FEGenericBase< FEOutputType< T >::type >::OutputDivergence
inherited

Definition at line 123 of file fe_base.h.

typedef TensorTools::IncrementRank<OutputShape>::type libMesh::FEGenericBase< FEOutputType< T >::type >::OutputGradient
inherited

Definition at line 121 of file fe_base.h.

typedef TensorTools::MakeNumber<OutputShape>::type libMesh::FEGenericBase< FEOutputType< T >::type >::OutputNumber
inherited

Definition at line 124 of file fe_base.h.

typedef TensorTools::DecrementRank<OutputNumber>::type libMesh::FEGenericBase< FEOutputType< T >::type >::OutputNumberDivergence
inherited

Definition at line 127 of file fe_base.h.

typedef TensorTools::IncrementRank<OutputNumber>::type libMesh::FEGenericBase< FEOutputType< T >::type >::OutputNumberGradient
inherited

Definition at line 125 of file fe_base.h.

typedef TensorTools::IncrementRank<OutputNumberGradient>::type libMesh::FEGenericBase< FEOutputType< T >::type >::OutputNumberTensor
inherited

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.

typedef TensorTools::IncrementRank<OutputGradient>::type libMesh::FEGenericBase< FEOutputType< T >::type >::OutputTensor
inherited

Definition at line 122 of file fe_base.h.

Constructor & Destructor Documentation

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

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

Definition at line 722 of file fe.h.

722  :
723  FE<Dim,L2_HIERARCHIC> (fet)
724  {}

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 UniquePtr<FEGenericBase> libMesh::FEGenericBase< FEOutputType< T >::type >::build ( const unsigned int  dim,
const FEType &  type 
)
staticinherited

Builds a specific finite element type. A UniquePtr<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 UniquePtr<FEGenericBase> libMesh::FEGenericBase< FEOutputType< T >::type >::build_InfFE ( const unsigned int  dim,
const FEType &  type 
)
staticinherited

Builds a specific infinite element type. A UniquePtr<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 791 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::libmesh_assert(), libmesh_nullptr, libMesh::FEInterface::n_dofs(), libMesh::Elem::n_sides(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::parent(), libMesh::Real, libMesh::remote_elem, libMesh::FEInterface::shape(), libMesh::Threads::spin_mtx, and libMesh::Elem::subactive().

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

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

Definition at line 107 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

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

108 {
109  _enable_print_counter = false;
110  return;
111 }
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 paremeter 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, libMesh::FEGenericBase< OutputType >::curl_phi, and libMesh::libmesh_assert().

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

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

378  { return this->_fe_map->get_curvatures();}
libMesh::FEAbstract::_fe_map
UniquePtr< FEMap > _fe_map
Definition: fe_abstract.h:511
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, libMesh::FEGenericBase< OutputType >::d2phi, and libMesh::libmesh_assert().

291  { libmesh_assert(!calculations_started || calculate_d2phi);
292  calculate_d2phi = calculate_dphiref = true; return d2phi; }
libMesh::FEGenericBase< FEOutputType< T >::type >::d2phi
std::vector< std::vector< OutputTensor > > d2phi
Definition: fe_base.h:552
libMesh::libmesh_assert
libmesh_assert(j)
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, libMesh::FEGenericBase< OutputType >::d2phideta2, and libMesh::libmesh_assert().

371  { libmesh_assert(!calculations_started || calculate_d2phi);
372  calculate_d2phi = calculate_dphiref = true; return d2phideta2; }
libMesh::libmesh_assert
libmesh_assert(j)
libMesh::FEGenericBase< FEOutputType< T >::type >::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, libMesh::FEGenericBase< OutputType >::d2phidetadzeta, and libMesh::libmesh_assert().

379  { libmesh_assert(!calculations_started || calculate_d2phi);
380  calculate_d2phi = calculate_dphiref = true; return d2phidetadzeta; }
libMesh::libmesh_assert
libmesh_assert(j)
libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidetadzeta
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, libMesh::FEGenericBase< OutputType >::d2phidx2, and libMesh::libmesh_assert().

299  { libmesh_assert(!calculations_started || calculate_d2phi);
300  calculate_d2phi = calculate_dphiref = true; return d2phidx2; }
libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidx2
std::vector< std::vector< OutputShape > > d2phidx2
Definition: fe_base.h:587
libMesh::libmesh_assert
libmesh_assert(j)
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, libMesh::FEGenericBase< OutputType >::d2phidxdy, and libMesh::libmesh_assert().

307  { libmesh_assert(!calculations_started || calculate_d2phi);
308  calculate_d2phi = calculate_dphiref = true; return d2phidxdy; }
libMesh::libmesh_assert
libmesh_assert(j)
libMesh::FEGenericBase< FEOutputType< T >::type >::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, libMesh::FEGenericBase< OutputType >::d2phidxdz, and libMesh::libmesh_assert().

315  { libmesh_assert(!calculations_started || calculate_d2phi);
316  calculate_d2phi = calculate_dphiref = true; return d2phidxdz; }
libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidxdz
std::vector< std::vector< OutputShape > > d2phidxdz
Definition: fe_base.h:597
libMesh::libmesh_assert
libmesh_assert(j)
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, libMesh::FEGenericBase< OutputType >::d2phidxi2, and libMesh::libmesh_assert().

347  { libmesh_assert(!calculations_started || calculate_d2phi);
348  calculate_d2phi = calculate_dphiref = true; return d2phidxi2; }
libMesh::libmesh_assert
libmesh_assert(j)
libMesh::FEGenericBase< FEOutputType< T >::type >::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, libMesh::FEGenericBase< OutputType >::d2phidxideta, and libMesh::libmesh_assert().

355  { libmesh_assert(!calculations_started || calculate_d2phi);
356  calculate_d2phi = calculate_dphiref = true; return d2phidxideta; }
libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidxideta
std::vector< std::vector< OutputShape > > d2phidxideta
Definition: fe_base.h:562
libMesh::libmesh_assert
libmesh_assert(j)
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, libMesh::FEGenericBase< OutputType >::d2phidxidzeta, and libMesh::libmesh_assert().

363  { libmesh_assert(!calculations_started || calculate_d2phi);
364  calculate_d2phi = calculate_dphiref = true; return d2phidxidzeta; }
libMesh::libmesh_assert
libmesh_assert(j)
libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidxidzeta
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, libMesh::FEGenericBase< OutputType >::d2phidy2, and libMesh::libmesh_assert().

323  { libmesh_assert(!calculations_started || calculate_d2phi);
324  calculate_d2phi = calculate_dphiref = true; return d2phidy2; }
libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidy2
std::vector< std::vector< OutputShape > > d2phidy2
Definition: fe_base.h:602
libMesh::libmesh_assert
libmesh_assert(j)
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, libMesh::FEGenericBase< OutputType >::d2phidydz, and libMesh::libmesh_assert().

331  { libmesh_assert(!calculations_started || calculate_d2phi);
332  calculate_d2phi = calculate_dphiref = true; return d2phidydz; }
libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidydz
std::vector< std::vector< OutputShape > > d2phidydz
Definition: fe_base.h:607
libMesh::libmesh_assert
libmesh_assert(j)
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, libMesh::FEGenericBase< OutputType >::d2phidz2, and libMesh::libmesh_assert().

339  { libmesh_assert(!calculations_started || calculate_d2phi);
340  calculate_d2phi = calculate_dphiref = true; return d2phidz2; }
libMesh::libmesh_assert
libmesh_assert(j)
libMesh::FEGenericBase< FEOutputType< T >::type >::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, libMesh::FEGenericBase< OutputType >::d2phidzeta2, and libMesh::libmesh_assert().

387  { libmesh_assert(!calculations_started || calculate_d2phi);
388  calculate_d2phi = calculate_dphiref = true; return d2phidzeta2; }
libMesh::libmesh_assert
libmesh_assert(j)
libMesh::FEGenericBase< FEOutputType< T >::type >::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 264 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

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

Definition at line 294 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

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

Definition at line 258 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

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

Definition at line 280 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

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

Definition at line 288 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

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

Definition at line 272 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

273  { return this->_fe_map->get_d2xyzdzeta2(); }
libMesh::FEAbstract::_fe_map
UniquePtr< FEMap > _fe_map
Definition: fe_abstract.h:511
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 324 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

325  { return this->_fe_map->get_detadx(); }
libMesh::FEAbstract::_fe_map
UniquePtr< FEMap > _fe_map
Definition: fe_abstract.h:511
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 331 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

332  { return this->_fe_map->get_detady(); }
libMesh::FEAbstract::_fe_map
UniquePtr< FEMap > _fe_map
Definition: fe_abstract.h:511
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 338 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

339  { return this->_fe_map->get_detadz(); }
libMesh::FEAbstract::_fe_map
UniquePtr< FEMap > _fe_map
Definition: fe_abstract.h:511
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, libMesh::FEGenericBase< OutputType >::div_phi, and libMesh::libmesh_assert().

233  { libmesh_assert(!calculations_started || calculate_div_phi);
234  calculate_div_phi = calculate_dphiref = true; return div_phi; }
libMesh::libmesh_assert
libmesh_assert(j)
libMesh::FEGenericBase< FEOutputType< T >::type >::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; }
libMesh::FEGenericBase< FEOutputType< T >::type >::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, libMesh::FEGenericBase< OutputType >::dphi, and libMesh::libmesh_assert().

217  { libmesh_assert(!calculations_started || calculate_dphi);
218  calculate_dphi = calculate_dphiref = true; return dphi; }
libMesh::libmesh_assert
libmesh_assert(j)
libMesh::FEGenericBase< FEOutputType< T >::type >::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, libMesh::FEGenericBase< OutputType >::dphideta, and libMesh::libmesh_assert().

273  { libmesh_assert(!calculations_started || calculate_dphiref);
274  calculate_dphiref = true; return dphideta; }
libMesh::libmesh_assert
libmesh_assert(j)
libMesh::FEGenericBase< FEOutputType< T >::type >::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, libMesh::FEGenericBase< OutputType >::dphidx, and libMesh::libmesh_assert().

241  { libmesh_assert(!calculations_started || calculate_dphi);
242  calculate_dphi = calculate_dphiref = true; return dphidx; }
libMesh::libmesh_assert
libmesh_assert(j)
libMesh::FEGenericBase< FEOutputType< T >::type >::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, libMesh::FEGenericBase< OutputType >::dphidxi, and libMesh::libmesh_assert().

265  { libmesh_assert(!calculations_started || calculate_dphiref);
266  calculate_dphiref = true; return dphidxi; }
libMesh::FEGenericBase< FEOutputType< T >::type >::dphidxi
std::vector< std::vector< OutputShape > > dphidxi
Definition: fe_base.h:519
libMesh::libmesh_assert
libmesh_assert(j)
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, libMesh::FEGenericBase< OutputType >::dphidy, and libMesh::libmesh_assert().

249  { libmesh_assert(!calculations_started || calculate_dphi);
250  calculate_dphi = calculate_dphiref = true; return dphidy; }
libMesh::FEGenericBase< FEOutputType< T >::type >::dphidy
std::vector< std::vector< OutputShape > > dphidy
Definition: fe_base.h:539
libMesh::libmesh_assert
libmesh_assert(j)
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, libMesh::FEGenericBase< OutputType >::dphidz, and libMesh::libmesh_assert().

257  { libmesh_assert(!calculations_started || calculate_dphi);
258  calculate_dphi = calculate_dphiref = true; return dphidz; }
libMesh::libmesh_assert
libmesh_assert(j)
libMesh::FEGenericBase< FEOutputType< T >::type >::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, libMesh::FEGenericBase< OutputType >::dphidzeta, and libMesh::libmesh_assert().

281  { libmesh_assert(!calculations_started || calculate_dphiref);
282  calculate_dphiref = true; return dphidzeta; }
libMesh::FEGenericBase< FEOutputType< T >::type >::dphidzeta
std::vector< std::vector< OutputShape > > dphidzeta
Definition: fe_base.h:529
libMesh::libmesh_assert
libmesh_assert(j)
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 303 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

304  { return this->_fe_map->get_dxidx(); }
libMesh::FEAbstract::_fe_map
UniquePtr< FEMap > _fe_map
Definition: fe_abstract.h:511
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 310 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

311  { return this->_fe_map->get_dxidy(); }
libMesh::FEAbstract::_fe_map
UniquePtr< FEMap > _fe_map
Definition: fe_abstract.h:511
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 317 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

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

Definition at line 245 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

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

Definition at line 238 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

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

Definition at line 252 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

253  { return _fe_map->get_dxyzdzeta(); }
libMesh::FEAbstract::_fe_map
UniquePtr< FEMap > _fe_map
Definition: fe_abstract.h:511
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 345 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

346  { return this->_fe_map->get_dzetadx(); }
libMesh::FEAbstract::_fe_map
UniquePtr< FEMap > _fe_map
Definition: fe_abstract.h:511
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 352 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

353  { return this->_fe_map->get_dzetady(); }
libMesh::FEAbstract::_fe_map
UniquePtr< FEMap > _fe_map
Definition: fe_abstract.h:511
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 359 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

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

Definition at line 441 of file fe_abstract.h.

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

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

441 { return fe_type.family; }
libMesh::FEType::family
FEFamily family
Definition: fe_type.h:203
const FEMap& libMesh::FEAbstract::get_fe_map ( ) const
inlineinherited
Returns
The mapping object

Definition at line 446 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map, libMesh::FEAbstract::compute_shape_functions(), libMesh::FEAbstract::operator<<, libMesh::FEAbstract::print_d2phi(), libMesh::FEAbstract::print_dphi(), libMesh::FEAbstract::print_info(), libMesh::FEAbstract::print_JxW(), libMesh::FEAbstract::print_phi(), and libMesh::FEAbstract::print_xyz().

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

446 { return *_fe_map.get(); }
libMesh::FEAbstract::_fe_map
UniquePtr< FEMap > _fe_map
Definition: fe_abstract.h:511
FEType libMesh::FEAbstract::get_fe_type ( ) const
inlineinherited
Returns
The FE Type (approximation order and family) of the finite element.

Definition at line 415 of file fe_abstract.h.

References libMesh::FEAbstract::fe_type.

Referenced by libMesh::FEMContext::build_new_fe(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::H1FETransformation< OutputShape >::map_phi(), libMesh::HCurlFETransformation< OutputShape >::map_phi(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::operator()(), and libMesh::JumpErrorEstimator::reinit_sides().

415 { return fe_type; }
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 }
libMesh::Quality::name
std::string name(const ElemQuality q)
Definition: elem_quality.C:39
const std::vector<Real>& libMesh::FEAbstract::get_JxW ( ) const
inlineinherited
Returns
The element Jacobian times the quadrature weight for each quadrature point.

Definition at line 231 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::DiscontinuityMeasure::boundary_side_integration(), libMesh::KellyErrorEstimator::boundary_side_integration(), libMesh::System::calculate_norm(), libMesh::ExactErrorEstimator::find_squared_element_error(), libMesh::FEMSystem::init_context(), libMesh::LaplacianErrorEstimator::internal_side_integration(), libMesh::DiscontinuityMeasure::internal_side_integration(), libMesh::KellyErrorEstimator::internal_side_integration(), and libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::operator()().

232  { return this->_fe_map->get_JxW(); }
libMesh::FEAbstract::_fe_map
UniquePtr< FEMap > _fe_map
Definition: fe_abstract.h:511
const std::vector<Point>& libMesh::FEAbstract::get_normals ( ) const
inlineinherited
Returns
The outward pointing normal vectors for face integration.

Definition at line 371 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

Referenced by libMesh::KellyErrorEstimator::boundary_side_integration(), libMesh::ParsedFEMFunction< Output >::eval_args(), libMesh::ParsedFEMFunction< Output >::init_context(), libMesh::KellyErrorEstimator::init_context(), and libMesh::KellyErrorEstimator::internal_side_integration().

372  { return this->_fe_map->get_normals(); }
libMesh::FEAbstract::_fe_map
UniquePtr< FEMap > _fe_map
Definition: fe_abstract.h:511
Order libMesh::FEAbstract::get_order ( ) const
inlineinherited
Returns
The approximation order of the finite element.

Definition at line 420 of file fe_abstract.h.

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

420 { return static_cast<Order>(fe_type.order + _p_level); }
libMesh::FEAbstract::_p_level
unsigned int _p_level
Definition: fe_abstract.h:573
libMesh::FEType::order
OrderWrapper order
Definition: fe_type.h:197
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 410 of file fe_abstract.h.

References libMesh::FEAbstract::_p_level.

410 { return _p_level; }
libMesh::FEAbstract::_p_level
unsigned int _p_level
Definition: fe_abstract.h:573
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, libMesh::libmesh_assert(), and libMesh::FEGenericBase< OutputType >::phi.

209  { libmesh_assert(!calculations_started || calculate_phi);
210  calculate_phi = true; return phi; }
libMesh::libmesh_assert
libmesh_assert(j)
libMesh::FEGenericBase< FEOutputType< T >::type >::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 259 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::TET10, libMesh::TET4, libMesh::TRI3, libMesh::TRI6, and libMesh::TRISHELL3.

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

Definition at line 428 of file fe_base.h.

References libMesh::FEGenericBase< OutputType >::compute_shape_functions(), libMesh::FEGenericBase< OutputType >::determine_calculations(), libMesh::FEGenericBase< OutputType >::dweight, libMesh::FEGenericBase< OutputType >::init_base_shape_functions(), libMesh::FEGenericBase< OutputType >::print_d2phi(), libMesh::FEGenericBase< OutputType >::print_dphi(), and libMesh::FEGenericBase< OutputType >::print_phi().

429  { return dweight; }
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 365 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

366  { return this->_fe_map->get_tangents(); }
libMesh::FEAbstract::_fe_map
UniquePtr< FEMap > _fe_map
Definition: fe_abstract.h:511
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 404 of file fe_abstract.h.

References libMesh::FEAbstract::elem_type.

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

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

Definition at line 224 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::DiscontinuityMeasure::boundary_side_integration(), libMesh::KellyErrorEstimator::boundary_side_integration(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::ParsedFEMFunction< Output >::eval_args(), libMesh::ExactErrorEstimator::find_squared_element_error(), libMesh::ParsedFEMFunction< Output >::init_context(), libMesh::DGFEMContext::neighbor_side_fe_reinit(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::operator()(), and libMesh::InfFE< Dim, T_radial, T_map >::reinit().

225  { return this->_fe_map->get_xyz(); }
libMesh::FEAbstract::_fe_map
UniquePtr< FEMap > _fe_map
Definition: fe_abstract.h:511
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 }
libMesh::Quality::name
std::string name(const ElemQuality q)
Definition: elem_quality.C:39
libMesh::Threads::spin_mtx
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 }
libMesh::Quality::name
std::string name(const ElemQuality q)
Definition: elem_quality.C:39
libMesh::Threads::spin_mtx
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

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

Definition at line 85 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects, libMesh::ReferenceCounter::disable_print_counter_info(), libMesh::ReferenceCounter::enable_print_counter_info(), libMesh::ReferenceCounter::increment_constructor_count(), libMesh::ReferenceCounter::increment_destructor_count(), and libMesh::Quality::name().

Referenced by libMesh::System::hide_output(), and libMesh::LibMeshInit::LibMeshInit().

86  { return _n_objects; }
libMesh::ReferenceCounter::_n_objects
static Threads::atomic< unsigned int > _n_objects
Definition: reference_counter.h:132
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 556 of file fe_abstract.C.

References libMesh::EDGE2, libMesh::EDGE3, libMesh::EDGE4, libMesh::HEX20, libMesh::HEX27, libMesh::HEX8, libMesh::INFHEX8, 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::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().

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

Prints all the relevant information about the current element.

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

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

References libMesh::FEAbstract::_fe_map.

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

752 {
753  this->_fe_map->print_JxW(os);
754 }
libMesh::FEAbstract::_fe_map
UniquePtr< FEMap > _fe_map
Definition: fe_abstract.h:511
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 758 of file fe_abstract.C.

References libMesh::FEAbstract::_fe_map.

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

759 {
760  this->_fe_map->print_xyz(os);
761 }
libMesh::FEAbstract::_fe_map
UniquePtr< FEMap > _fe_map
Definition: fe_abstract.h:511
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 paremeter 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 425 of file fe_abstract.h.

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

425 { fe_type.order = new_order; }
libMesh::FEType::order
OrderWrapper order
Definition: fe_type.h:197
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

Actually holds the data.

Definition at line 124 of file reference_counter.h.

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

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

UniquePtr<FEMap> libMesh::FEAbstract::_fe_map
protectedinherited

Definition at line 511 of file fe_abstract.h.

Referenced by libMesh::FESubdivision::attach_quadrature_rule(), libMesh::InfFE< Dim, T_radial, T_map >::combine_base_radial(), libMesh::InfFE< Dim, T_radial, T_map >::compute_shape_functions(), libMesh::FEAbstract::get_curvatures(), libMesh::FEAbstract::get_d2xyzdeta2(), libMesh::FEAbstract::get_d2xyzdetadzeta(), libMesh::FEAbstract::get_d2xyzdxi2(), libMesh::FEAbstract::get_d2xyzdxideta(), libMesh::FEAbstract::get_d2xyzdxidzeta(), libMesh::FEAbstract::get_d2xyzdzeta2(), libMesh::FEAbstract::get_detadx(), libMesh::FEAbstract::get_detady(), libMesh::FEAbstract::get_detadz(), libMesh::FEAbstract::get_dxidx(), libMesh::FEAbstract::get_dxidy(), libMesh::FEAbstract::get_dxidz(), libMesh::FEAbstract::get_dxyzdeta(), libMesh::FEAbstract::get_dxyzdxi(), libMesh::FEAbstract::get_dxyzdzeta(), libMesh::FEAbstract::get_dzetadx(), libMesh::FEAbstract::get_dzetady(), libMesh::FEAbstract::get_dzetadz(), libMesh::FEAbstract::get_fe_map(), libMesh::FEAbstract::get_JxW(), libMesh::FEAbstract::get_normals(), libMesh::FEAbstract::get_tangents(), libMesh::FEAbstract::get_xyz(), libMesh::InfFE< Dim, T_radial, T_map >::init_shape_functions(), libMesh::FESubdivision::init_shape_functions(), libMesh::FEAbstract::print_JxW(), libMesh::FEAbstract::print_xyz(), and libMesh::InfFE< Dim, T_radial, T_map >::reinit().

UniquePtr<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 573 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 543 of file fe_abstract.h.

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

bool libMesh::FEAbstract::calculate_d2phi
mutableprotectedinherited

Should we calculate shape function hessians?

Definition at line 538 of file fe_abstract.h.

Referenced by libMesh::FESubdivision::attach_quadrature_rule(), 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(), and libMesh::InfFE< Dim, T_radial, T_map >::reinit().

bool libMesh::FEAbstract::calculate_div_phi
mutableprotectedinherited

Should we calculate shape function divergences?

Definition at line 548 of file fe_abstract.h.

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

bool libMesh::FEAbstract::calculate_dphi
mutableprotectedinherited

Should we calculate shape function gradients?

Definition at line 533 of file fe_abstract.h.

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

bool libMesh::FEAbstract::calculate_dphiref
mutableprotectedinherited

Should we calculate reference shape function gradients?

Definition at line 553 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 528 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 523 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

The dimensionality of the object

Definition at line 517 of file fe_abstract.h.

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

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

FEType libMesh::FEAbstract::fe_type
protectedinherited

The finite element type for this object.

Note
This should be constant for the object.

Definition at line 561 of file fe_abstract.h.

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

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 578 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 584 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:
generated by doxygen