libMesh::FEL2Lagrange< Dim > Class Template Reference

#include <fe.h>

Inheritance diagram for libMesh::FEL2Lagrange< Dim >:

Public Types

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

Public Member Functions

 FEL2Lagrange (const FEType &fet)
 
virtual unsigned int n_shape_functions () const
 
virtual FEContinuity get_continuity () const
 
virtual bool is_hierarchic () const
 
virtual void reinit (const Elem *elem, const std::vector< Point > *const pts=NULL, const std::vector< Real > *const weights=NULL)
 
virtual void reinit (const Elem *elem, const unsigned int side, const Real tolerance=TOLERANCE, const std::vector< Point > *const pts=NULL, const std::vector< Real > *const weights=NULL)
 
virtual void edge_reinit (const Elem *elem, const unsigned int edge, const Real tolerance=TOLERANCE, const std::vector< Point > *const pts=NULL, const std::vector< Real > *const weights=NULL)
 
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)
 
virtual void attach_quadrature_rule (QBase *q)
 
virtual unsigned int n_quadrature_points () const
 
virtual bool shapes_need_reinit () const
 
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
 
FEFamily get_family () const
 
const FEMapget_fe_map () const
 
void print_JxW (std::ostream &os) const
 
void print_xyz (std::ostream &os) const
 
void print_info (std::ostream &os) const
 

Static Public Member Functions

static OutputShape shape (const ElemType t, const Order o, const unsigned int i, const Point &p)
 
static OutputShape shape (const Elem *elem, const Order o, const unsigned int i, const Point &p)
 
static OutputShape shape_deriv (const ElemType t, const Order o, const unsigned int i, const unsigned int j, const Point &p)
 
static OutputShape shape_deriv (const Elem *elem, const Order o, const unsigned int i, const unsigned int j, const Point &p)
 
static OutputShape shape_second_deriv (const ElemType t, const Order o, const unsigned int i, const unsigned int j, const Point &p)
 
static OutputShape shape_second_deriv (const Elem *elem, const Order o, const unsigned int i, const unsigned int j, const Point &p)
 
static void nodal_soln (const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)
 
static unsigned int n_shape_functions (const ElemType t, const Order o)
 
static unsigned int n_dofs (const ElemType t, const Order o)
 
static unsigned int n_dofs_at_node (const ElemType t, const Order o, const unsigned int n)
 
static unsigned int n_dofs_per_elem (const ElemType t, const Order o)
 
static void dofs_on_side (const Elem *const elem, const Order o, unsigned int s, std::vector< unsigned int > &di)
 
static void dofs_on_edge (const Elem *const elem, const Order o, unsigned int e, std::vector< unsigned int > &di)
 
static Point inverse_map (const Elem *elem, const Point &p, const Real tolerance=TOLERANCE, const bool secure=true)
 
static void inverse_map (const Elem *elem, const std::vector< Point > &physical_points, std::vector< Point > &reference_points, const Real tolerance=TOLERANCE, const bool secure=true)
 
static void compute_constraints (DofConstraints &constraints, DofMap &dof_map, const unsigned int variable_number, const Elem *elem)
 
static Point map (const Elem *elem, const Point &reference_point)
 
static Point map_xi (const Elem *elem, const Point &reference_point)
 
static Point map_eta (const Elem *elem, const Point &reference_point)
 
static Point map_zeta (const Elem *elem, const Point &reference_point)
 
static AutoPtr< FEGenericBasebuild (const unsigned int dim, const FEType &type)
 
static AutoPtr< FEGenericBasebuild_InfFE (const unsigned int dim, const FEType &type)
 
static void compute_proj_constraints (DofConstraints &constraints, DofMap &dof_map, const unsigned int variable_number, const Elem *elem)
 
static void coarsened_dof_values (const NumericVector< Number > &global_vector, const DofMap &dof_map, const Elem *coarse_elem, DenseVector< Number > &coarse_dofs, const unsigned int var, const bool use_old_dof_indices=false)
 
static void 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)
 
virtual void compute_shape_functions (const Elem *elem, const std::vector< Point > &qp)
 
void increment_constructor_count (const std::string &name)
 
void increment_destructor_count (const std::string &name)
 

Protected Attributes

std::vector< Pointcached_nodes
 
ElemType last_side
 
unsigned int last_edge
 
AutoPtr< FETransformationBase
< OutputType > > 
_fe_trans
 
std::vector< std::vector
< OutputShape > > 
phi
 
std::vector< std::vector
< OutputGradient > > 
dphi
 
std::vector< std::vector
< OutputShape > > 
curl_phi
 
std::vector< std::vector
< OutputDivergence > > 
div_phi
 
std::vector< std::vector
< OutputShape > > 
dphidxi
 
std::vector< std::vector
< OutputShape > > 
dphideta
 
std::vector< std::vector
< OutputShape > > 
dphidzeta
 
std::vector< std::vector
< OutputShape > > 
dphidx
 
std::vector< std::vector
< OutputShape > > 
dphidy
 
std::vector< std::vector
< OutputShape > > 
dphidz
 
std::vector< std::vector
< OutputTensor > > 
d2phi
 
std::vector< std::vector
< OutputShape > > 
d2phidxi2
 
std::vector< std::vector
< OutputShape > > 
d2phidxideta
 
std::vector< std::vector
< OutputShape > > 
d2phidxidzeta
 
std::vector< std::vector
< OutputShape > > 
d2phideta2
 
std::vector< std::vector
< OutputShape > > 
d2phidetadzeta
 
std::vector< std::vector
< OutputShape > > 
d2phidzeta2
 
std::vector< std::vector
< OutputShape > > 
d2phidx2
 
std::vector< std::vector
< OutputShape > > 
d2phidxdy
 
std::vector< std::vector
< OutputShape > > 
d2phidxdz
 
std::vector< std::vector
< OutputShape > > 
d2phidy2
 
std::vector< std::vector
< OutputShape > > 
d2phidydz
 
std::vector< std::vector
< OutputShape > > 
d2phidz2
 
std::vector< OutputGradientdphase
 
std::vector< RealGradientdweight
 
std::vector< Realweight
 
AutoPtr< 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
 
const FEType fe_type
 
ElemType elem_type
 
unsigned int _p_level
 
QBaseqrule
 
bool shapes_on_quadrature
 

Static Protected Attributes

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

Detailed Description

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

Discontinuous Lagrange finite elements.

Definition at line 625 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 113 of file reference_counter.h.

Definition at line 151 of file fe_base.h.

Definition at line 149 of file fe_base.h.

Definition at line 152 of file fe_base.h.

Definition at line 155 of file fe_base.h.

Definition at line 153 of file fe_base.h.

Definition at line 154 of file fe_base.h.

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

Definition at line 103 of file fe.h.

Definition at line 150 of file fe_base.h.

Constructor & Destructor Documentation

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

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

Definition at line 983 of file fe.h.

983  :
984  FE<Dim,L2_LAGRANGE> (fet)
985 {
986 }

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

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

Builds a specific infinite element type. A AutoPtr<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.

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

References std::abs(), libMesh::Elem::build_side(), libMesh::Elem::default_order(), libMesh::Elem::dim(), libMesh::FEAbstract::fe_type, libMesh::FEInterface::inverse_map(), libMeshEnums::LAGRANGE, libMesh::Elem::level(), libMesh::libmesh_assert(), libMesh::FEInterface::n_dofs(), libMesh::Elem::n_sides(), libMesh::Elem::neighbor(), libMesh::Elem::parent(), libMesh::Real, libMesh::remote_elem, libMesh::FEInterface::shape(), libMesh::Threads::spin_mtx, and libMesh::Elem::subactive().

922 {
923  libmesh_assert(elem);
924 
925  const unsigned int Dim = elem->dim();
926 
927  // Only constrain elements in 2,3D.
928  if (Dim == 1)
929  return;
930 
931  // Only constrain active and ancestor elements
932  if (elem->subactive())
933  return;
934 
935  // We currently always use LAGRANGE mappings for geometry
936  const FEType fe_type(elem->default_order(), LAGRANGE);
937 
938  std::vector<const Node*> my_nodes, parent_nodes;
939 
940  // Look at the element faces. Check to see if we need to
941  // build constraints.
942  for (unsigned int s=0; s<elem->n_sides(); s++)
943  if (elem->neighbor(s) != NULL &&
944  elem->neighbor(s) != remote_elem)
945  if (elem->neighbor(s)->level() < elem->level()) // constrain dofs shared between
946  { // this element and ones coarser
947  // than this element.
948  // Get pointers to the elements of interest and its parent.
949  const Elem* parent = elem->parent();
950 
951  // This can't happen... Only level-0 elements have NULL
952  // parents, and no level-0 elements can be at a higher
953  // level than their neighbors!
954  libmesh_assert(parent);
955 
956  const AutoPtr<Elem> my_side (elem->build_side(s));
957  const AutoPtr<Elem> parent_side (parent->build_side(s));
958 
959  const unsigned int n_side_nodes = my_side->n_nodes();
960 
961  my_nodes.clear();
962  my_nodes.reserve (n_side_nodes);
963  parent_nodes.clear();
964  parent_nodes.reserve (n_side_nodes);
965 
966  for (unsigned int n=0; n != n_side_nodes; ++n)
967  my_nodes.push_back(my_side->get_node(n));
968 
969  for (unsigned int n=0; n != n_side_nodes; ++n)
970  parent_nodes.push_back(parent_side->get_node(n));
971 
972  for (unsigned int my_side_n=0;
973  my_side_n < n_side_nodes;
974  my_side_n++)
975  {
976  libmesh_assert_less (my_side_n, FEInterface::n_dofs(Dim-1, fe_type, my_side->type()));
977 
978  const Node* my_node = my_nodes[my_side_n];
979 
980  // The support point of the DOF
981  const Point& support_point = *my_node;
982 
983  // Figure out where my node lies on their reference element.
984  const Point mapped_point = FEInterface::inverse_map(Dim-1, fe_type,
985  parent_side.get(),
986  support_point);
987 
988  // Compute the parent's side shape function values.
989  for (unsigned int their_side_n=0;
990  their_side_n < n_side_nodes;
991  their_side_n++)
992  {
993  libmesh_assert_less (their_side_n, FEInterface::n_dofs(Dim-1, fe_type, parent_side->type()));
994 
995  const Node* their_node = parent_nodes[their_side_n];
996  libmesh_assert(their_node);
997 
998  const Real their_value = FEInterface::shape(Dim-1,
999  fe_type,
1000  parent_side->type(),
1001  their_side_n,
1002  mapped_point);
1003 
1004  const Real their_mag = std::abs(their_value);
1005 #ifdef DEBUG
1006  // Protect for the case u_i ~= u_j,
1007  // in which case i better equal j.
1008  if (their_mag > 0.999)
1009  {
1010  libmesh_assert_equal_to (my_node, their_node);
1011  libmesh_assert_less (std::abs(their_value - 1.), 0.001);
1012  }
1013  else
1014 #endif
1015  // To make nodal constraints useful for constructing
1016  // sparsity patterns faster, we need to get EVERY
1017  // POSSIBLE constraint coupling identified, even if
1018  // there is no coupling in the isoparametric
1019  // Lagrange case.
1020  if (their_mag < 1.e-5)
1021  {
1022  // since we may be running this method concurretly
1023  // on multiple threads we need to acquire a lock
1024  // before modifying the shared constraint_row object.
1025  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
1026 
1027  // A reference to the constraint row.
1028  NodeConstraintRow& constraint_row = constraints[my_node].first;
1029 
1030  constraint_row.insert(std::make_pair (their_node,
1031  0.));
1032  }
1033  // To get nodal coordinate constraints right, only
1034  // add non-zero and non-identity values for Lagrange
1035  // basis functions.
1036  else // (1.e-5 <= their_mag <= .999)
1037  {
1038  // since we may be running this method concurretly
1039  // on multiple threads we need to acquire a lock
1040  // before modifying the shared constraint_row object.
1041  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
1042 
1043  // A reference to the constraint row.
1044  NodeConstraintRow& constraint_row = constraints[my_node].first;
1045 
1046  constraint_row.insert(std::make_pair (their_node,
1047  their_value));
1048  }
1049  }
1050  }
1051  }
1052 }
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 1063 of file fe_abstract.C.

References libMesh::Elem::active(), libMesh::PeriodicBoundaries::boundary(), libMesh::MeshBase::boundary_info, libMesh::Elem::build_side(), libMesh::Elem::default_order(), libMesh::Elem::dim(), libMesh::FEAbstract::fe_type, libMesh::PeriodicBoundaryBase::get_corresponding_pos(), libMesh::invalid_uint, libMesh::FEInterface::inverse_map(), libMeshEnums::LAGRANGE, libMesh::Elem::level(), libMesh::libmesh_assert(), libMesh::FEInterface::n_dofs(), libMesh::Elem::n_sides(), libMesh::PeriodicBoundaries::neighbor(), libMesh::Elem::neighbor(), libMesh::PeriodicBoundaryBase::pairedboundary, libMesh::Real, libMesh::FEInterface::shape(), and libMesh::Threads::spin_mtx.

1068 {
1069  // Only bother if we truly have periodic boundaries
1070  if (boundaries.empty())
1071  return;
1072 
1073  libmesh_assert(elem);
1074 
1075  // Only constrain active elements with this method
1076  if (!elem->active())
1077  return;
1078 
1079  const unsigned int Dim = elem->dim();
1080 
1081  // We currently always use LAGRANGE mappings for geometry
1082  const FEType fe_type(elem->default_order(), LAGRANGE);
1083 
1084  std::vector<const Node*> my_nodes, neigh_nodes;
1085 
1086  // Look at the element faces. Check to see if we need to
1087  // build constraints.
1088  for (unsigned int s=0; s<elem->n_sides(); s++)
1089  {
1090  if (elem->neighbor(s))
1091  continue;
1092 
1093  const std::vector<boundary_id_type>& bc_ids = mesh.boundary_info->boundary_ids (elem, s);
1094  for (std::vector<boundary_id_type>::const_iterator id_it=bc_ids.begin(); id_it!=bc_ids.end(); ++id_it)
1095  {
1096  const boundary_id_type boundary_id = *id_it;
1097  const PeriodicBoundaryBase *periodic = boundaries.boundary(boundary_id);
1098  if (periodic)
1099  {
1100  libmesh_assert(point_locator);
1101 
1102  // Get pointers to the element's neighbor.
1103  const Elem* neigh = boundaries.neighbor(boundary_id, *point_locator, elem, s);
1104 
1105  // h refinement constraints:
1106  // constrain dofs shared between
1107  // this element and ones as coarse
1108  // as or coarser than this element.
1109  if (neigh->level() <= elem->level())
1110  {
1111  unsigned int s_neigh =
1112  mesh.boundary_info->side_with_boundary_id (neigh, periodic->pairedboundary);
1113  libmesh_assert_not_equal_to (s_neigh, libMesh::invalid_uint);
1114 
1115 #ifdef LIBMESH_ENABLE_AMR
1116  libmesh_assert(neigh->active());
1117 #endif // #ifdef LIBMESH_ENABLE_AMR
1118 
1119  const AutoPtr<Elem> my_side (elem->build_side(s));
1120  const AutoPtr<Elem> neigh_side (neigh->build_side(s_neigh));
1121 
1122  const unsigned int n_side_nodes = my_side->n_nodes();
1123 
1124  my_nodes.clear();
1125  my_nodes.reserve (n_side_nodes);
1126  neigh_nodes.clear();
1127  neigh_nodes.reserve (n_side_nodes);
1128 
1129  for (unsigned int n=0; n != n_side_nodes; ++n)
1130  my_nodes.push_back(my_side->get_node(n));
1131 
1132  for (unsigned int n=0; n != n_side_nodes; ++n)
1133  neigh_nodes.push_back(neigh_side->get_node(n));
1134 
1135  // Make sure we're not adding recursive constraints
1136  // due to the redundancy in the way we add periodic
1137  // boundary constraints, or adding constraints to
1138  // nodes that already have AMR constraints
1139  std::vector<bool> skip_constraint(n_side_nodes, false);
1140 
1141  for (unsigned int my_side_n=0;
1142  my_side_n < n_side_nodes;
1143  my_side_n++)
1144  {
1145  libmesh_assert_less (my_side_n, FEInterface::n_dofs(Dim-1, fe_type, my_side->type()));
1146 
1147  const Node* my_node = my_nodes[my_side_n];
1148 
1149  // Figure out where my node lies on their reference element.
1150  const Point neigh_point = periodic->get_corresponding_pos(*my_node);
1151 
1152  const Point mapped_point = FEInterface::inverse_map(Dim-1, fe_type,
1153  neigh_side.get(),
1154  neigh_point);
1155 
1156  // If we've already got a constraint on this
1157  // node, then the periodic constraint is
1158  // redundant
1159  {
1160  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
1161 
1162  if (constraints.count(my_node))
1163  {
1164  skip_constraint[my_side_n] = true;
1165  continue;
1166  }
1167  }
1168 
1169  // Compute the neighbors's side shape function values.
1170  for (unsigned int their_side_n=0;
1171  their_side_n < n_side_nodes;
1172  their_side_n++)
1173  {
1174  libmesh_assert_less (their_side_n, FEInterface::n_dofs(Dim-1, fe_type, neigh_side->type()));
1175 
1176  const Node* their_node = neigh_nodes[their_side_n];
1177 
1178  // If there's a constraint on an opposing node,
1179  // we need to see if it's constrained by
1180  // *our side* making any periodic constraint
1181  // on us recursive
1182  {
1183  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
1184 
1185  if (!constraints.count(their_node))
1186  continue;
1187 
1188  const NodeConstraintRow& their_constraint_row =
1189  constraints[their_node].first;
1190 
1191  for (unsigned int orig_side_n=0;
1192  orig_side_n < n_side_nodes;
1193  orig_side_n++)
1194  {
1195  libmesh_assert_less (orig_side_n, FEInterface::n_dofs(Dim-1, fe_type, my_side->type()));
1196 
1197  const Node* orig_node = my_nodes[orig_side_n];
1198 
1199  if (their_constraint_row.count(orig_node))
1200  skip_constraint[orig_side_n] = true;
1201  }
1202  }
1203  }
1204  }
1205  for (unsigned int my_side_n=0;
1206  my_side_n < n_side_nodes;
1207  my_side_n++)
1208  {
1209  libmesh_assert_less (my_side_n, FEInterface::n_dofs(Dim-1, fe_type, my_side->type()));
1210 
1211  if (skip_constraint[my_side_n])
1212  continue;
1213 
1214  const Node* my_node = my_nodes[my_side_n];
1215 
1216  // Figure out where my node lies on their reference element.
1217  const Point neigh_point = periodic->get_corresponding_pos(*my_node);
1218 
1219  // Figure out where my node lies on their reference element.
1220  const Point mapped_point = FEInterface::inverse_map(Dim-1, fe_type,
1221  neigh_side.get(),
1222  neigh_point);
1223 
1224  for (unsigned int their_side_n=0;
1225  their_side_n < n_side_nodes;
1226  their_side_n++)
1227  {
1228  libmesh_assert_less (their_side_n, FEInterface::n_dofs(Dim-1, fe_type, neigh_side->type()));
1229 
1230  const Node* their_node = neigh_nodes[their_side_n];
1231  libmesh_assert(their_node);
1232 
1233  const Real their_value = FEInterface::shape(Dim-1,
1234  fe_type,
1235  neigh_side->type(),
1236  their_side_n,
1237  mapped_point);
1238 
1239  // since we may be running this method concurretly
1240  // on multiple threads we need to acquire a lock
1241  // before modifying the shared constraint_row object.
1242  {
1243  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
1244 
1245  NodeConstraintRow& constraint_row =
1246  constraints[my_node].first;
1247 
1248  constraint_row.insert(std::make_pair(their_node,
1249  their_value));
1250  }
1251  }
1252  }
1253  }
1254  }
1255  }
1256  }
1257 }
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::ReferenceCounter::disable_print_counter_info ( )
staticinherited

Definition at line 106 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

107 {
108  _enable_print_counter = false;
109  return;
110 }
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 = NULL,
const std::vector< Real > *const  weights = NULL 
)
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 100 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

101 {
102  _enable_print_counter = true;
103  return;
104 }
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 238 of file fe_base.h.

References libMesh::FEAbstract::calculate_curl_phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< T >::curl_phi, and libMesh::libmesh_assert().

239  { libmesh_assert(!calculations_started || calculate_curl_phi);
240  calculate_curl_phi = calculate_dphiref = true; return curl_phi; }
const std::vector<Real>& libMesh::FEAbstract::get_curvatures ( ) const
inlineinherited
Returns
the curvatures for use in face integration.

Definition at line 380 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

381  { return this->_fe_map->get_curvatures();}
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 304 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< T >::d2phi, and libMesh::libmesh_assert().

305  { libmesh_assert(!calculations_started || calculate_d2phi);
306  calculate_d2phi = calculate_dphiref = true; return d2phi; }
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 384 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< T >::d2phideta2, and libMesh::libmesh_assert().

385  { libmesh_assert(!calculations_started || calculate_d2phi);
386  calculate_d2phi = calculate_dphiref = true; return d2phideta2; }
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 392 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< T >::d2phidetadzeta, and libMesh::libmesh_assert().

393  { libmesh_assert(!calculations_started || calculate_d2phi);
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 312 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< T >::d2phidx2, and libMesh::libmesh_assert().

313  { libmesh_assert(!calculations_started || calculate_d2phi);
314  calculate_d2phi = calculate_dphiref = true; return d2phidx2; }
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 320 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< T >::d2phidxdy, and libMesh::libmesh_assert().

321  { libmesh_assert(!calculations_started || calculate_d2phi);
322  calculate_d2phi = calculate_dphiref = true; return d2phidxdy; }
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 328 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< T >::d2phidxdz, and libMesh::libmesh_assert().

329  { libmesh_assert(!calculations_started || calculate_d2phi);
330  calculate_d2phi = calculate_dphiref = true; return d2phidxdz; }
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 360 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< T >::d2phidxi2, and libMesh::libmesh_assert().

361  { libmesh_assert(!calculations_started || calculate_d2phi);
362  calculate_d2phi = calculate_dphiref = true; return d2phidxi2; }
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 368 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< T >::d2phidxideta, and libMesh::libmesh_assert().

369  { libmesh_assert(!calculations_started || calculate_d2phi);
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 376 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< T >::d2phidxidzeta, and libMesh::libmesh_assert().

377  { libmesh_assert(!calculations_started || calculate_d2phi);
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 336 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< T >::d2phidy2, and libMesh::libmesh_assert().

337  { libmesh_assert(!calculations_started || calculate_d2phi);
338  calculate_d2phi = calculate_dphiref = true; return d2phidy2; }
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 344 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< T >::d2phidydz, and libMesh::libmesh_assert().

345  { libmesh_assert(!calculations_started || calculate_d2phi);
346  calculate_d2phi = calculate_dphiref = true; return d2phidydz; }
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 352 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< T >::d2phidz2, and libMesh::libmesh_assert().

353  { libmesh_assert(!calculations_started || calculate_d2phi);
354  calculate_d2phi = calculate_dphiref = true; return d2phidz2; }
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 400 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< T >::d2phidzeta2, and libMesh::libmesh_assert().

401  { libmesh_assert(!calculations_started || calculate_d2phi);
402  calculate_d2phi = calculate_dphiref = true; return d2phidzeta2; }
const std::vector<RealGradient>& libMesh::FEAbstract::get_d2xyzdeta2 ( ) const
inlineinherited
Returns
the second partial derivatives in eta.

Definition at line 267 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

268  { return this->_fe_map->get_d2xyzdeta2(); }
const std::vector<RealGradient>& libMesh::FEAbstract::get_d2xyzdetadzeta ( ) const
inlineinherited
Returns
the second partial derivatives in eta-zeta.

Definition at line 297 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

298  { return this->_fe_map->get_d2xyzdetadzeta(); }
const std::vector<RealGradient>& libMesh::FEAbstract::get_d2xyzdxi2 ( ) const
inlineinherited
Returns
the second partial derivatives in xi.

Definition at line 261 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

262  { return this->_fe_map->get_d2xyzdxi2(); }
const std::vector<RealGradient>& libMesh::FEAbstract::get_d2xyzdxideta ( ) const
inlineinherited
Returns
the second partial derivatives in xi-eta.

Definition at line 283 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

284  { return this->_fe_map->get_d2xyzdxideta(); }
const std::vector<RealGradient>& libMesh::FEAbstract::get_d2xyzdxidzeta ( ) const
inlineinherited
Returns
the second partial derivatives in xi-zeta.

Definition at line 291 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

292  { return this->_fe_map->get_d2xyzdxidzeta(); }
const std::vector<RealGradient>& libMesh::FEAbstract::get_d2xyzdzeta2 ( ) const
inlineinherited
Returns
the second partial derivatives in zeta.

Definition at line 275 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

276  { return this->_fe_map->get_d2xyzdzeta2(); }
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 327 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

328  { return this->_fe_map->get_detadx(); }
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 334 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

335  { return this->_fe_map->get_detady(); }
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 341 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

342  { return this->_fe_map->get_detadz(); }
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 246 of file fe_base.h.

References libMesh::FEAbstract::calculate_div_phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< T >::div_phi, and libMesh::libmesh_assert().

247  { libmesh_assert(!calculations_started || calculate_div_phi);
248  calculate_div_phi = calculate_dphiref = true; return div_phi; }
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 returns correct element matrices for a mesh using both finite and infinite elements.

Definition at line 418 of file fe_base.h.

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

419  { return dphase; }
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 230 of file fe_base.h.

References libMesh::FEAbstract::calculate_dphi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< T >::dphi, and libMesh::libmesh_assert().

231  { libmesh_assert(!calculations_started || calculate_dphi);
232  calculate_dphi = calculate_dphiref = true; return dphi; }
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 286 of file fe_base.h.

References libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< T >::dphideta, and libMesh::libmesh_assert().

287  { libmesh_assert(!calculations_started || calculate_dphiref);
288  calculate_dphiref = true; return dphideta; }
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 254 of file fe_base.h.

References libMesh::FEAbstract::calculate_dphi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< T >::dphidx, and libMesh::libmesh_assert().

255  { libmesh_assert(!calculations_started || calculate_dphi);
256  calculate_dphi = calculate_dphiref = true; return dphidx; }
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 278 of file fe_base.h.

References libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< T >::dphidxi, and libMesh::libmesh_assert().

279  { libmesh_assert(!calculations_started || calculate_dphiref);
280  calculate_dphiref = true; return dphidxi; }
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 262 of file fe_base.h.

References libMesh::FEAbstract::calculate_dphi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< T >::dphidy, and libMesh::libmesh_assert().

263  { libmesh_assert(!calculations_started || calculate_dphi);
264  calculate_dphi = calculate_dphiref = true; return dphidy; }
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 270 of file fe_base.h.

References libMesh::FEAbstract::calculate_dphi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< T >::dphidz, and libMesh::libmesh_assert().

271  { libmesh_assert(!calculations_started || calculate_dphi);
272  calculate_dphi = calculate_dphiref = true; return dphidz; }
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 294 of file fe_base.h.

References libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< T >::dphidzeta, and libMesh::libmesh_assert().

295  { libmesh_assert(!calculations_started || calculate_dphiref);
296  calculate_dphiref = true; return dphidzeta; }
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 306 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

307  { return this->_fe_map->get_dxidx(); }
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 313 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

314  { return this->_fe_map->get_dxidy(); }
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 320 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

321  { return this->_fe_map->get_dxidz(); }
const std::vector<RealGradient>& libMesh::FEAbstract::get_dxyzdeta ( ) const
inlineinherited
Returns
the element tangents in eta-direction at the quadrature points.

Definition at line 248 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

249  { return this->_fe_map->get_dxyzdeta(); }
const std::vector<RealGradient>& libMesh::FEAbstract::get_dxyzdxi ( ) const
inlineinherited
Returns
the element tangents in xi-direction at the quadrature points.

Definition at line 241 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

242  { return this->_fe_map->get_dxyzdxi(); }
const std::vector<RealGradient>& libMesh::FEAbstract::get_dxyzdzeta ( ) const
inlineinherited
Returns
the element tangents in zeta-direction at the quadrature points.

Definition at line 255 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

256  { return _fe_map->get_dxyzdzeta(); }
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 348 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

349  { return this->_fe_map->get_dzetadx(); }
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 355 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

356  { return this->_fe_map->get_dzetady(); }
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 362 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

363  { return this->_fe_map->get_dzetadz(); }
FEFamily libMesh::FEAbstract::get_family ( ) const
inlineinherited
Returns
the finite element family of this element.

Definition at line 439 of file fe_abstract.h.

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

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

439 { return fe_type.family; }
FEType libMesh::FEAbstract::get_fe_type ( ) const
inlineinherited
Returns
the FE Type (approximation order and family) of the finite element.

Definition at line 418 of file fe_abstract.h.

References libMesh::FEAbstract::fe_type.

Referenced by libMesh::FEMContext::build_new_fe(), libMesh::H1FETransformation< T >::map_phi(), libMesh::HCurlFETransformation< T >::map_phi(), and libMesh::ProjectFEMSolution::operator()().

418 { 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 }
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 234 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

Referenced by libMesh::ExactErrorEstimator::find_squared_element_error(), libMesh::FEMSystem::init_context(), and libMesh::ProjectFEMSolution::operator()().

235  { return this->_fe_map->get_JxW(); }
const std::vector<Point>& libMesh::FEAbstract::get_normals ( ) const
inlineinherited
Returns
the normal vectors for face integration.

Definition at line 374 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

375  { return this->_fe_map->get_normals(); }
Order libMesh::FEAbstract::get_order ( ) const
inlineinherited
Returns
the approximation order of the finite element.

Definition at line 423 of file fe_abstract.h.

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

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

Definition at line 413 of file fe_abstract.h.

References libMesh::FEAbstract::_p_level.

413 { return _p_level; }
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 222 of file fe_base.h.

References libMesh::FEAbstract::calculate_phi, libMesh::FEAbstract::calculations_started, libMesh::libmesh_assert(), and libMesh::FEGenericBase< T >::phi.

223  { libmesh_assert(!calculations_started || calculate_phi);
224  calculate_phi = true; return phi; }
void libMesh::FEAbstract::get_refspace_nodes ( const ElemType  t,
std::vector< Point > &  nodes 
)
staticinherited

returns the reference space nodes coordinates given the element type

Definition at line 415 of file fe_abstract.C.

References libMeshEnums::EDGE2, libMeshEnums::EDGE3, libMesh::err, libMeshEnums::HEX20, libMeshEnums::HEX27, libMeshEnums::HEX8, libMeshEnums::PRISM15, libMeshEnums::PRISM18, libMeshEnums::PRISM6, libMeshEnums::PYRAMID14, libMeshEnums::PYRAMID5, libMeshEnums::QUAD4, libMeshEnums::QUAD8, libMeshEnums::QUAD9, libMeshEnums::TET10, libMeshEnums::TET4, libMeshEnums::TRI3, and libMeshEnums::TRI6.

416 {
417  switch(itemType)
418  {
419  case EDGE2:
420  {
421  nodes.resize(2);
422  nodes[0] = Point (-1.,0.,0.);
423  nodes[1] = Point (1.,0.,0.);
424  return;
425  }
426  case EDGE3:
427  {
428  nodes.resize(3);
429  nodes[0] = Point (-1.,0.,0.);
430  nodes[1] = Point (1.,0.,0.);
431  nodes[2] = Point (0.,0.,0.);
432  return;
433  }
434  case TRI3:
435  {
436  nodes.resize(3);
437  nodes[0] = Point (0.,0.,0.);
438  nodes[1] = Point (1.,0.,0.);
439  nodes[2] = Point (0.,1.,0.);
440  return;
441  }
442  case TRI6:
443  {
444  nodes.resize(6);
445  nodes[0] = Point (0.,0.,0.);
446  nodes[1] = Point (1.,0.,0.);
447  nodes[2] = Point (0.,1.,0.);
448  nodes[3] = Point (.5,0.,0.);
449  nodes[4] = Point (.5,.5,0.);
450  nodes[5] = Point (0.,.5,0.);
451  return;
452  }
453  case QUAD4:
454  {
455  nodes.resize(4);
456  nodes[0] = Point (-1.,-1.,0.);
457  nodes[1] = Point (1.,-1.,0.);
458  nodes[2] = Point (1.,1.,0.);
459  nodes[3] = Point (-1.,1.,0.);
460  return;
461  }
462  case QUAD8:
463  {
464  nodes.resize(8);
465  nodes[0] = Point (-1.,-1.,0.);
466  nodes[1] = Point (1.,-1.,0.);
467  nodes[2] = Point (1.,1.,0.);
468  nodes[3] = Point (-1.,1.,0.);
469  nodes[4] = Point (0.,-1.,0.);
470  nodes[5] = Point (1.,0.,0.);
471  nodes[6] = Point (0.,1.,0.);
472  nodes[7] = Point (-1.,0.,0.);
473  return;
474  }
475  case QUAD9:
476  {
477  nodes.resize(9);
478  nodes[0] = Point (-1.,-1.,0.);
479  nodes[1] = Point (1.,-1.,0.);
480  nodes[2] = Point (1.,1.,0.);
481  nodes[3] = Point (-1.,1.,0.);
482  nodes[4] = Point (0.,-1.,0.);
483  nodes[5] = Point (1.,0.,0.);
484  nodes[6] = Point (0.,1.,0.);
485  nodes[7] = Point (-1.,0.,0.);
486  nodes[8] = Point (0.,0.,0.);
487  return;
488  }
489  case TET4:
490  {
491  nodes.resize(4);
492  nodes[0] = Point (0.,0.,0.);
493  nodes[1] = Point (1.,0.,0.);
494  nodes[2] = Point (0.,1.,0.);
495  nodes[3] = Point (0.,0.,1.);
496  return;
497  }
498  case TET10:
499  {
500  nodes.resize(10);
501  nodes[0] = Point (0.,0.,0.);
502  nodes[1] = Point (1.,0.,0.);
503  nodes[2] = Point (0.,1.,0.);
504  nodes[3] = Point (0.,0.,1.);
505  nodes[4] = Point (.5,0.,0.);
506  nodes[5] = Point (.5,.5,0.);
507  nodes[6] = Point (0.,.5,0.);
508  nodes[7] = Point (0.,0.,.5);
509  nodes[8] = Point (.5,0.,.5);
510  nodes[9] = Point (0.,.5,.5);
511  return;
512  }
513  case HEX8:
514  {
515  nodes.resize(8);
516  nodes[0] = Point (-1.,-1.,-1.);
517  nodes[1] = Point (1.,-1.,-1.);
518  nodes[2] = Point (1.,1.,-1.);
519  nodes[3] = Point (-1.,1.,-1.);
520  nodes[4] = Point (-1.,-1.,1.);
521  nodes[5] = Point (1.,-1.,1.);
522  nodes[6] = Point (1.,1.,1.);
523  nodes[7] = Point (-1.,1.,1.);
524  return;
525  }
526  case HEX20:
527  {
528  nodes.resize(20);
529  nodes[0] = Point (-1.,-1.,-1.);
530  nodes[1] = Point (1.,-1.,-1.);
531  nodes[2] = Point (1.,1.,-1.);
532  nodes[3] = Point (-1.,1.,-1.);
533  nodes[4] = Point (-1.,-1.,1.);
534  nodes[5] = Point (1.,-1.,1.);
535  nodes[6] = Point (1.,1.,1.);
536  nodes[7] = Point (-1.,1.,1.);
537  nodes[8] = Point (0.,-1.,-1.);
538  nodes[9] = Point (1.,0.,-1.);
539  nodes[10] = Point (0.,1.,-1.);
540  nodes[11] = Point (-1.,0.,-1.);
541  nodes[12] = Point (-1.,-1.,0.);
542  nodes[13] = Point (1.,-1.,0.);
543  nodes[14] = Point (1.,1.,0.);
544  nodes[15] = Point (-1.,1.,0.);
545  nodes[16] = Point (0.,-1.,1.);
546  nodes[17] = Point (1.,0.,1.);
547  nodes[18] = Point (0.,1.,1.);
548  nodes[19] = Point (-1.,0.,1.);
549  return;
550  }
551  case HEX27:
552  {
553  nodes.resize(27);
554  nodes[0] = Point (-1.,-1.,-1.);
555  nodes[1] = Point (1.,-1.,-1.);
556  nodes[2] = Point (1.,1.,-1.);
557  nodes[3] = Point (-1.,1.,-1.);
558  nodes[4] = Point (-1.,-1.,1.);
559  nodes[5] = Point (1.,-1.,1.);
560  nodes[6] = Point (1.,1.,1.);
561  nodes[7] = Point (-1.,1.,1.);
562  nodes[8] = Point (0.,-1.,-1.);
563  nodes[9] = Point (1.,0.,-1.);
564  nodes[10] = Point (0.,1.,-1.);
565  nodes[11] = Point (-1.,0.,-1.);
566  nodes[12] = Point (-1.,-1.,0.);
567  nodes[13] = Point (1.,-1.,0.);
568  nodes[14] = Point (1.,1.,0.);
569  nodes[15] = Point (-1.,1.,0.);
570  nodes[16] = Point (0.,-1.,1.);
571  nodes[17] = Point (1.,0.,1.);
572  nodes[18] = Point (0.,1.,1.);
573  nodes[19] = Point (-1.,0.,1.);
574  nodes[20] = Point (0.,0.,-1.);
575  nodes[21] = Point (0.,-1.,0.);
576  nodes[22] = Point (1.,0.,0.);
577  nodes[23] = Point (0.,1.,0.);
578  nodes[24] = Point (-1.,0.,0.);
579  nodes[25] = Point (0.,0.,1.);
580  nodes[26] = Point (0.,0.,0.);
581  return;
582  }
583  case PRISM6:
584  {
585  nodes.resize(6);
586  nodes[0] = Point (0.,0.,-1.);
587  nodes[1] = Point (1.,0.,-1.);
588  nodes[2] = Point (0.,1.,-1.);
589  nodes[3] = Point (0.,0.,1.);
590  nodes[4] = Point (1.,0.,1.);
591  nodes[5] = Point (0.,1.,1.);
592  return;
593  }
594  case PRISM15:
595  {
596  nodes.resize(15);
597  nodes[0] = Point (0.,0.,-1.);
598  nodes[1] = Point (1.,0.,-1.);
599  nodes[2] = Point (0.,1.,-1.);
600  nodes[3] = Point (0.,0.,1.);
601  nodes[4] = Point (1.,0.,1.);
602  nodes[5] = Point (0.,1.,1.);
603  nodes[6] = Point (.5,0.,-1.);
604  nodes[7] = Point (.5,.5,-1.);
605  nodes[8] = Point (0.,.5,-1.);
606  nodes[9] = Point (0.,0.,0.);
607  nodes[10] = Point (1.,0.,0.);
608  nodes[11] = Point (0.,1.,0.);
609  nodes[12] = Point (.5,0.,1.);
610  nodes[13] = Point (.5,.5,1.);
611  nodes[14] = Point (0.,.5,1.);
612  return;
613  }
614  case PRISM18:
615  {
616  nodes.resize(18);
617  nodes[0] = Point (0.,0.,-1.);
618  nodes[1] = Point (1.,0.,-1.);
619  nodes[2] = Point (0.,1.,-1.);
620  nodes[3] = Point (0.,0.,1.);
621  nodes[4] = Point (1.,0.,1.);
622  nodes[5] = Point (0.,1.,1.);
623  nodes[6] = Point (.5,0.,-1.);
624  nodes[7] = Point (.5,.5,-1.);
625  nodes[8] = Point (0.,.5,-1.);
626  nodes[9] = Point (0.,0.,0.);
627  nodes[10] = Point (1.,0.,0.);
628  nodes[11] = Point (0.,1.,0.);
629  nodes[12] = Point (.5,0.,1.);
630  nodes[13] = Point (.5,.5,1.);
631  nodes[14] = Point (0.,.5,1.);
632  nodes[15] = Point (.5,0.,0.);
633  nodes[16] = Point (.5,.5,0.);
634  nodes[17] = Point (0.,.5,0.);
635  return;
636  }
637  case PYRAMID5:
638  {
639  nodes.resize(5);
640  nodes[0] = Point (-1.,-1.,0.);
641  nodes[1] = Point (1.,-1.,0.);
642  nodes[2] = Point (1.,1.,0.);
643  nodes[3] = Point (-1.,1.,0.);
644  nodes[4] = Point (0.,0.,1.);
645  return;
646  }
647  case PYRAMID14:
648  {
649  nodes.resize(14);
650 
651  // base corners
652  nodes[0] = Point (-1.,-1.,0.);
653  nodes[1] = Point (1.,-1.,0.);
654  nodes[2] = Point (1.,1.,0.);
655  nodes[3] = Point (-1.,1.,0.);
656 
657  // apex
658  nodes[4] = Point (0.,0.,1.);
659 
660  // base midedge
661  nodes[5] = Point (0.,-1.,0.);
662  nodes[6] = Point (1.,0.,0.);
663  nodes[7] = Point (0.,1.,0.);
664  nodes[8] = Point (-1,0.,0.);
665 
666  // lateral midedge
667  nodes[9] = Point (-.5,-.5,.5);
668  nodes[10] = Point (.5,-.5,.5);
669  nodes[11] = Point (.5,.5,.5);
670  nodes[12] = Point (-.5,.5,.5);
671 
672  // base center
673  nodes[13] = Point (0.,0.,0.);
674 
675  return;
676  }
677  default:
678  {
679  libMesh::err << "ERROR: Unknown element type " << itemType << std::endl;
680  libmesh_error();
681  }
682  }
683  return;
684 }
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 442 of file fe_base.h.

References libMesh::FEGenericBase< T >::dweight.

443  { 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 returns correct element matrices for a mesh using both finite and infinite elements.

Definition at line 434 of file fe_base.h.

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

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

Definition at line 368 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

369  { return this->_fe_map->get_tangents(); }
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 407 of file fe_abstract.h.

References libMesh::FEAbstract::elem_type.

407 { 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 227 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

Referenced by libMesh::ExactErrorEstimator::find_squared_element_error(), libMesh::DGFEMContext::neighbor_side_fe_reinit(), and libMesh::ProjectFEMSolution::operator()().

228  { return this->_fe_map->get_xyz(); }
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 163 of file reference_counter.h.

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

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

164 {
165  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
166  std::pair<unsigned int, unsigned int>& p = _counts[name];
167 
168  p.first++;
169 }
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 176 of file reference_counter.h.

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

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

177 {
178  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
179  std::pair<unsigned int, unsigned int>& p = _counts[name];
180 
181  p.second++;
182 }
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 79 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects.

80  { return _n_objects; }
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 226 of file fe.h.

228  { 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 686 of file fe_abstract.C.

References libMeshEnums::EDGE2, libMeshEnums::EDGE3, libMeshEnums::EDGE4, libMesh::err, libMeshEnums::HEX20, libMeshEnums::HEX27, libMeshEnums::HEX8, libMeshEnums::INFHEX8, libMeshEnums::INFPRISM6, libMeshEnums::NODEELEM, libMeshEnums::PRISM15, libMeshEnums::PRISM18, libMeshEnums::PRISM6, libMeshEnums::PYRAMID14, libMeshEnums::PYRAMID5, libMeshEnums::QUAD4, libMeshEnums::QUAD8, libMeshEnums::QUAD9, libMesh::Real, libMeshEnums::TET10, libMeshEnums::TET4, libMeshEnums::TRI3, and libMeshEnums::TRI6.

Referenced by libMesh::FEInterface::ifem_on_reference_element(), libMesh::FE< Dim, T >::inverse_map(), and libMesh::FEInterface::on_reference_element().

687 {
688  libmesh_assert_greater_equal (eps, 0.);
689 
690  const Real xi = p(0);
691 #if LIBMESH_DIM > 1
692  const Real eta = p(1);
693 #else
694  const Real eta = 0.;
695 #endif
696 #if LIBMESH_DIM > 2
697  const Real zeta = p(2);
698 #else
699  const Real zeta = 0.;
700 #endif
701 
702  switch (t)
703  {
704  case NODEELEM:
705  {
706  return (!xi && !eta && !zeta);
707  }
708  case EDGE2:
709  case EDGE3:
710  case EDGE4:
711  {
712  // The reference 1D element is [-1,1].
713  if ((xi >= -1.-eps) &&
714  (xi <= 1.+eps))
715  return true;
716 
717  return false;
718  }
719 
720 
721  case TRI3:
722  case TRI6:
723  {
724  // The reference triangle is isocoles
725  // and is bound by xi=0, eta=0, and xi+eta=1.
726  if ((xi >= 0.-eps) &&
727  (eta >= 0.-eps) &&
728  ((xi + eta) <= 1.+eps))
729  return true;
730 
731  return false;
732  }
733 
734 
735  case QUAD4:
736  case QUAD8:
737  case QUAD9:
738  {
739  // The reference quadrilateral element is [-1,1]^2.
740  if ((xi >= -1.-eps) &&
741  (xi <= 1.+eps) &&
742  (eta >= -1.-eps) &&
743  (eta <= 1.+eps))
744  return true;
745 
746  return false;
747  }
748 
749 
750  case TET4:
751  case TET10:
752  {
753  // The reference tetrahedral is isocoles
754  // and is bound by xi=0, eta=0, zeta=0,
755  // and xi+eta+zeta=1.
756  if ((xi >= 0.-eps) &&
757  (eta >= 0.-eps) &&
758  (zeta >= 0.-eps) &&
759  ((xi + eta + zeta) <= 1.+eps))
760  return true;
761 
762  return false;
763  }
764 
765 
766  case HEX8:
767  case HEX20:
768  case HEX27:
769  {
770  /*
771  if ((xi >= -1.) &&
772  (xi <= 1.) &&
773  (eta >= -1.) &&
774  (eta <= 1.) &&
775  (zeta >= -1.) &&
776  (zeta <= 1.))
777  return true;
778  */
779 
780  // The reference hexahedral element is [-1,1]^3.
781  if ((xi >= -1.-eps) &&
782  (xi <= 1.+eps) &&
783  (eta >= -1.-eps) &&
784  (eta <= 1.+eps) &&
785  (zeta >= -1.-eps) &&
786  (zeta <= 1.+eps))
787  {
788  // libMesh::out << "Strange Point:\n";
789  // p.print();
790  return true;
791  }
792 
793  return false;
794  }
795 
796  case PRISM6:
797  case PRISM15:
798  case PRISM18:
799  {
800  // Figure this one out...
801  // inside the reference triange with zeta in [-1,1]
802  if ((xi >= 0.-eps) &&
803  (eta >= 0.-eps) &&
804  (zeta >= -1.-eps) &&
805  (zeta <= 1.+eps) &&
806  ((xi + eta) <= 1.+eps))
807  return true;
808 
809  return false;
810  }
811 
812 
813  case PYRAMID5:
814  case PYRAMID14:
815  {
816  // Check that the point is on the same side of all the faces
817  // by testing whether:
818  //
819  // n_i.(x - x_i) <= 0
820  //
821  // for each i, where:
822  // n_i is the outward normal of face i,
823  // x_i is a point on face i.
824  if ((-eta - 1. + zeta <= 0.+eps) &&
825  ( xi - 1. + zeta <= 0.+eps) &&
826  ( eta - 1. + zeta <= 0.+eps) &&
827  ( -xi - 1. + zeta <= 0.+eps) &&
828  ( zeta >= 0.-eps))
829  return true;
830 
831  return false;
832  }
833 
834 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
835  case INFHEX8:
836  {
837  // The reference infhex8 is a [-1,1]^3.
838  if ((xi >= -1.-eps) &&
839  (xi <= 1.+eps) &&
840  (eta >= -1.-eps) &&
841  (eta <= 1.+eps) &&
842  (zeta >= -1.-eps) &&
843  (zeta <= 1.+eps))
844  {
845  return true;
846  }
847  return false;
848  }
849 
850  case INFPRISM6:
851  {
852  // inside the reference triange with zeta in [-1,1]
853  if ((xi >= 0.-eps) &&
854  (eta >= 0.-eps) &&
855  (zeta >= -1.-eps) &&
856  (zeta <= 1.+eps) &&
857  ((xi + eta) <= 1.+eps))
858  {
859  return true;
860  }
861 
862  return false;
863  }
864 #endif
865 
866  default:
867  libMesh::err << "ERROR: Unknown element type " << t << std::endl;
868  libmesh_error();
869  }
870 
871  // If we get here then the point is _not_ in the
872  // reference element. Better return false.
873 
874  return false;
875 }
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().

89 {
91 }
void libMesh::FEAbstract::print_info ( std::ostream &  os) const
inherited

Prints all the relevant information about the current element.

Definition at line 893 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::operator<<().

894 {
895  os << "phi[i][j]: Shape function i at quadrature pt. j" << std::endl;
896  this->print_phi(os);
897 
898  os << "dphi[i][j]: Shape function i's gradient at quadrature pt. j" << std::endl;
899  this->print_dphi(os);
900 
901  os << "XYZ locations of the quadrature pts." << std::endl;
902  this->print_xyz(os);
903 
904  os << "Values of JxW at the quadrature pts." << std::endl;
905  this->print_JxW(os);
906 }
void libMesh::FEAbstract::print_JxW ( std::ostream &  os) const
inherited

Prints the Jacobian times the weight for each quadrature point.

Definition at line 880 of file fe_abstract.C.

References libMesh::FEAbstract::_fe_map.

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

881 {
882  this->_fe_map->print_JxW(os);
883 }
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 887 of file fe_abstract.C.

References libMesh::FEAbstract::_fe_map.

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

888 {
889  this->_fe_map->print_xyz(os);
890 }
virtual void libMesh::FE< Dim, T >::reinit ( const Elem elem,
const std::vector< Point > *const  pts = NULL,
const std::vector< Real > *const  weights = NULL 
)
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 = NULL,
const std::vector< Real > *const  weights = NULL 
)
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.

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 imension, 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 imension, 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 that cross-derivatives are also possible, i.e. 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

Note: Computing second derivatives is not currently supported for all element types: C1 (Clough and Hermite), 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 that cross-derivatives are also possible, i.e. 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

Note: Computing second derivatives is not currently supported for all element types: C1 (Clough and Hermite), Lagrange, Hierarchic, L2_Hierarchic, and Monomial are supported. All other element types return an error when asked for second derivatives.

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

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

Implements libMesh::FEAbstract.

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

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

Implements libMesh::FEAbstract.

Member Data Documentation

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts
staticprotectedinherited
bool libMesh::ReferenceCounter::_enable_print_counter = true
staticprotectedinherited

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

Definition at line 137 of file reference_counter.h.

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

AutoPtr<FETransformationBase<OutputType> > libMesh::FEGenericBase< FEOutputType< T >::type >::_fe_trans
protectedinherited

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

Definition at line 502 of file fe_base.h.

Threads::spin_mutex libMesh::ReferenceCounter::_mutex
staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 131 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 126 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 570 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 473 of file fe.h.

bool libMesh::FEAbstract::calculate_curl_phi
mutableprotectedinherited

Should we calculate shape function curls?

Definition at line 541 of file fe_abstract.h.

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

bool libMesh::FEAbstract::calculate_div_phi
mutableprotectedinherited

Should we calculate shape function divergences?

Definition at line 546 of file fe_abstract.h.

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

bool libMesh::FEAbstract::calculate_dphiref
mutableprotectedinherited

Should we calculate reference shape function gradients?

Definition at line 551 of file fe_abstract.h.

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

bool libMesh::FEAbstract::calculate_phi
mutableprotectedinherited

Should we calculate shape functions?

Definition at line 526 of file fe_abstract.h.

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

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 521 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::FEGenericBase< FEOutputType< T >::type >::get_phi().

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

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

Shape function second derivatives in the eta direction.

Definition at line 580 of file fe_base.h.

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

Shape function second derivatives in the eta-zeta direction.

Definition at line 585 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 595 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 600 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 605 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 565 of file fe_base.h.

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

Shape function second derivatives in the xi-eta direction.

Definition at line 570 of file fe_base.h.

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

Shape function second derivatives in the xi-zeta direction.

Definition at line 575 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 610 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 615 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 620 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 590 of file fe_base.h.

const unsigned int libMesh::FEAbstract::dim
protectedinherited

The dimensionality of the object

Definition at line 515 of file fe_abstract.h.

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

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

Shape function derivative values.

Definition at line 512 of file fe_base.h.

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

Shape function derivatives in the eta direction.

Definition at line 532 of file fe_base.h.

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

Shape function derivatives in the x direction.

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

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

Shape function derivatives in the y direction.

Definition at line 547 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 552 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 537 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 645 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 564 of file fe_abstract.h.

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

const FEType libMesh::FEAbstract::fe_type
protectedinherited
unsigned int libMesh::FE< Dim, T >::last_edge
protectedinherited

Definition at line 480 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 478 of file fe.h.

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

Shape function values.

Definition at line 507 of file fe_base.h.

QBase* libMesh::FEAbstract::qrule
protectedinherited

A pointer to the quadrature rule employed

Definition at line 575 of file fe_abstract.h.

bool libMesh::FEAbstract::shapes_on_quadrature
protectedinherited

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

Definition at line 581 of file fe_abstract.h.

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


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

Site Created By: libMesh Developers
Last modified: February 07 2014 16:58:00 UTC

Hosted By:
SourceForge.net Logo