#include <fe.h>
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 FEMap & | get_fe_map () const |
| void | print_JxW (std::ostream &os) const |
| void | print_xyz (std::ostream &os) const |
| void | print_info (std::ostream &os) const |
Static Public Member Functions | |
| static OutputShape | shape (const ElemType t, const Order o, const unsigned int i, const Point &p) |
| static OutputShape | shape (const Elem *elem, const Order o, const unsigned int i, const Point &p) |
| static OutputShape | shape_deriv (const ElemType t, const Order o, const unsigned int i, const unsigned int j, const Point &p) |
| static OutputShape | shape_deriv (const Elem *elem, const Order o, const unsigned int i, const unsigned int j, const Point &p) |
| static OutputShape | shape_second_deriv (const ElemType t, const Order o, const unsigned int i, const unsigned int j, const Point &p) |
| static OutputShape | shape_second_deriv (const Elem *elem, const Order o, const unsigned int i, const unsigned int j, const Point &p) |
| static void | nodal_soln (const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln) |
| static unsigned int | n_shape_functions (const ElemType t, const Order o) |
| static unsigned int | n_dofs (const ElemType t, const Order o) |
| static unsigned int | n_dofs_at_node (const ElemType t, const Order o, const unsigned int n) |
| static unsigned int | n_dofs_per_elem (const ElemType t, const Order o) |
| static void | dofs_on_side (const Elem *const elem, const Order o, unsigned int s, std::vector< unsigned int > &di) |
| static void | dofs_on_edge (const Elem *const elem, const Order o, unsigned int e, std::vector< unsigned int > &di) |
| static Point | inverse_map (const Elem *elem, const Point &p, const Real tolerance=TOLERANCE, const bool secure=true) |
| static void | inverse_map (const Elem *elem, const std::vector< Point > &physical_points, std::vector< Point > &reference_points, const Real tolerance=TOLERANCE, const bool secure=true) |
| static void | compute_constraints (DofConstraints &constraints, DofMap &dof_map, const unsigned int variable_number, const Elem *elem) |
| static Point | map (const Elem *elem, const Point &reference_point) |
| static Point | map_xi (const Elem *elem, const Point &reference_point) |
| static Point | map_eta (const Elem *elem, const Point &reference_point) |
| static Point | map_zeta (const Elem *elem, const Point &reference_point) |
| static UniquePtr< FEGenericBase > | build (const unsigned int dim, const FEType &type) |
| static UniquePtr< FEGenericBase > | build_InfFE (const unsigned int dim, const FEType &type) |
| static void | compute_proj_constraints (DofConstraints &constraints, DofMap &dof_map, const unsigned int variable_number, const Elem *elem) |
| static void | coarsened_dof_values (const NumericVector< Number > &global_vector, const DofMap &dof_map, const Elem *coarse_elem, DenseVector< Number > &coarse_dofs, const unsigned int var, const bool use_old_dof_indices=false) |
| static void | 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< Point > | cached_nodes |
| ElemType | last_side |
| unsigned int | last_edge |
| UniquePtr < FETransformationBase < FEOutputType< T >::type > > | _fe_trans |
| std::vector< std::vector < OutputShape > > | phi |
| std::vector< std::vector < OutputGradient > > | dphi |
| std::vector< std::vector < OutputShape > > | curl_phi |
| std::vector< std::vector < OutputDivergence > > | div_phi |
| std::vector< std::vector < OutputShape > > | dphidxi |
| std::vector< std::vector < OutputShape > > | dphideta |
| std::vector< std::vector < OutputShape > > | dphidzeta |
| std::vector< std::vector < OutputShape > > | dphidx |
| std::vector< std::vector < OutputShape > > | dphidy |
| std::vector< std::vector < OutputShape > > | dphidz |
| std::vector< std::vector < OutputTensor > > | d2phi |
| std::vector< std::vector < OutputShape > > | d2phidxi2 |
| std::vector< std::vector < OutputShape > > | d2phidxideta |
| std::vector< std::vector < OutputShape > > | d2phidxidzeta |
| std::vector< std::vector < OutputShape > > | d2phideta2 |
| std::vector< std::vector < OutputShape > > | d2phidetadzeta |
| std::vector< std::vector < OutputShape > > | d2phidzeta2 |
| std::vector< std::vector < OutputShape > > | d2phidx2 |
| std::vector< std::vector < OutputShape > > | d2phidxdy |
| std::vector< std::vector < OutputShape > > | d2phidxdz |
| std::vector< std::vector < OutputShape > > | d2phidy2 |
| std::vector< std::vector < OutputShape > > | d2phidydz |
| std::vector< std::vector < OutputShape > > | d2phidz2 |
| std::vector< OutputGradient > | dphase |
| std::vector< RealGradient > | dweight |
| std::vector< Real > | weight |
| UniquePtr< FEMap > | _fe_map |
| const unsigned int | dim |
| bool | calculations_started |
| bool | calculate_phi |
| bool | calculate_dphi |
| bool | calculate_d2phi |
| bool | calculate_curl_phi |
| bool | calculate_div_phi |
| bool | calculate_dphiref |
| const FEType | fe_type |
| ElemType | elem_type |
| unsigned int | _p_level |
| QBase * | qrule |
| bool | shapes_on_quadrature |
Static Protected Attributes | |
| static Counts | _counts |
| static Threads::atomic < unsigned int > | _n_objects |
| static Threads::spin_mutex | _mutex |
| static bool | _enable_print_counter = true |
Friends | |
| class | InfFE |
| std::ostream & | operator<< (std::ostream &os, const FEAbstract &fe) |
Detailed Description
template<unsigned int Dim>
class libMesh::FEL2Lagrange< Dim >
Discontinuous Lagrange finite elements.
Member Typedef Documentation
typedef std::map<std::string, std::pair<unsigned int, unsigned int> > libMesh::ReferenceCounter::Counts [protected, inherited] |
Data structure to log the information. The log is identified by the class name.
Definition at line 113 of file reference_counter.h.
typedef TensorTools::DecrementRank<OutputShape>::type libMesh::FEGenericBase< FEOutputType< T >::type >::OutputDivergence [inherited] |
typedef TensorTools::IncrementRank<OutputShape>::type libMesh::FEGenericBase< FEOutputType< T >::type >::OutputGradient [inherited] |
typedef TensorTools::MakeNumber<OutputShape>::type libMesh::FEGenericBase< FEOutputType< T >::type >::OutputNumber [inherited] |
typedef TensorTools::DecrementRank<OutputNumber>::type libMesh::FEGenericBase< FEOutputType< T >::type >::OutputNumberDivergence [inherited] |
typedef TensorTools::IncrementRank<OutputNumber>::type libMesh::FEGenericBase< FEOutputType< T >::type >::OutputNumberGradient [inherited] |
typedef TensorTools::IncrementRank<OutputNumberGradient>::type libMesh::FEGenericBase< FEOutputType< T >::type >::OutputNumberTensor [inherited] |
typedef FEGenericBase<typename FEOutputType<T>::type>::OutputShape libMesh::FE< Dim, T >::OutputShape [inherited] |
Convenient typedefs for gradients of output, hessians of output, and potentially-complex-valued versions of same.
Reimplemented from libMesh::FEGenericBase< FEOutputType< T >::type >.
typedef TensorTools::IncrementRank<OutputGradient>::type libMesh::FEGenericBase< FEOutputType< T >::type >::OutputTensor [inherited] |
Constructor & Destructor Documentation
| libMesh::FEL2Lagrange< Dim >::FEL2Lagrange | ( | const FEType & | fet | ) | [inline, explicit] |
Member Function Documentation
| virtual void libMesh::FE< Dim, T >::attach_quadrature_rule | ( | QBase * | q | ) | [virtual, inherited] |
Provides the class with the quadrature rule, which provides the locations (on a reference element) where the shape functions are to be calculated.
Implements libMesh::FEAbstract.
| static UniquePtr<FEGenericBase> libMesh::FEGenericBase< FEOutputType< T >::type >::build | ( | const unsigned int | dim, |
| const FEType & | type | ||
| ) | [static, inherited] |
Builds a specific finite element type. A UniquePtr<FEGenericBase> is returned to prevent a memory leak. This way the user need not remember to delete the object.
The build call will fail if the OutputType of this class is not compatible with the output required for the requested type
Reimplemented from libMesh::FEAbstract.
| static UniquePtr<FEGenericBase> libMesh::FEGenericBase< FEOutputType< T >::type >::build_InfFE | ( | const unsigned int | dim, |
| const FEType & | type | ||
| ) | [static, inherited] |
Builds a specific infinite element type. A UniquePtr<FEGenericBase> is returned to prevent a memory leak. This way the user need not remember to delete the object.
The build call will fail if the OutputShape of this class is not compatible with the output required for the requested type
| static void libMesh::FEGenericBase< FEOutputType< T >::type >::coarsened_dof_values | ( | const NumericVector< Number > & | global_vector, |
| const DofMap & | dof_map, | ||
| const Elem * | coarse_elem, | ||
| DenseVector< Number > & | coarse_dofs, | ||
| const unsigned int | var, | ||
| const bool | use_old_dof_indices = false |
||
| ) | [static, inherited] |
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 | ||
| ) | [static, inherited] |
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 | ||
| ) | [static, inherited] |
Computes the nodal constraint contributions (for non-conforming adapted meshes), using Lagrange geometry
Definition at line 788 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(), libMesh::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().
{
libmesh_assert(elem);
const unsigned int Dim = elem->dim();
// Only constrain elements in 2,3D.
if (Dim == 1)
return;
// Only constrain active and ancestor elements
if (elem->subactive())
return;
// We currently always use LAGRANGE mappings for geometry
const FEType fe_type(elem->default_order(), LAGRANGE);
std::vector<const Node*> my_nodes, parent_nodes;
// Look at the element faces. Check to see if we need to
// build constraints.
for (unsigned int s=0; s<elem->n_sides(); s++)
if (elem->neighbor(s) != NULL &&
elem->neighbor(s) != remote_elem)
if (elem->neighbor(s)->level() < elem->level()) // constrain dofs shared between
{ // this element and ones coarser
// than this element.
// Get pointers to the elements of interest and its parent.
const Elem* parent = elem->parent();
// This can't happen... Only level-0 elements have NULL
// parents, and no level-0 elements can be at a higher
// level than their neighbors!
libmesh_assert(parent);
const UniquePtr<Elem> my_side (elem->build_side(s));
const UniquePtr<Elem> parent_side (parent->build_side(s));
const unsigned int n_side_nodes = my_side->n_nodes();
my_nodes.clear();
my_nodes.reserve (n_side_nodes);
parent_nodes.clear();
parent_nodes.reserve (n_side_nodes);
for (unsigned int n=0; n != n_side_nodes; ++n)
my_nodes.push_back(my_side->get_node(n));
for (unsigned int n=0; n != n_side_nodes; ++n)
parent_nodes.push_back(parent_side->get_node(n));
for (unsigned int my_side_n=0;
my_side_n < n_side_nodes;
my_side_n++)
{
libmesh_assert_less (my_side_n, FEInterface::n_dofs(Dim-1, fe_type, my_side->type()));
const Node* my_node = my_nodes[my_side_n];
// The support point of the DOF
const Point& support_point = *my_node;
// Figure out where my node lies on their reference element.
const Point mapped_point = FEInterface::inverse_map(Dim-1, fe_type,
parent_side.get(),
support_point);
// Compute the parent's side shape function values.
for (unsigned int their_side_n=0;
their_side_n < n_side_nodes;
their_side_n++)
{
libmesh_assert_less (their_side_n, FEInterface::n_dofs(Dim-1, fe_type, parent_side->type()));
const Node* their_node = parent_nodes[their_side_n];
libmesh_assert(their_node);
const Real their_value = FEInterface::shape(Dim-1,
fe_type,
parent_side->type(),
their_side_n,
mapped_point);
const Real their_mag = std::abs(their_value);
#ifdef DEBUG
// Protect for the case u_i ~= u_j,
// in which case i better equal j.
if (their_mag > 0.999)
{
libmesh_assert_equal_to (my_node, their_node);
libmesh_assert_less (std::abs(their_value - 1.), 0.001);
}
else
#endif
// To make nodal constraints useful for constructing
// sparsity patterns faster, we need to get EVERY
// POSSIBLE constraint coupling identified, even if
// there is no coupling in the isoparametric
// Lagrange case.
if (their_mag < 1.e-5)
{
// since we may be running this method concurrently
// on multiple threads we need to acquire a lock
// before modifying the shared constraint_row object.
Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
// A reference to the constraint row.
NodeConstraintRow& constraint_row = constraints[my_node].first;
constraint_row.insert(std::make_pair (their_node,
0.));
}
// To get nodal coordinate constraints right, only
// add non-zero and non-identity values for Lagrange
// basis functions.
else // (1.e-5 <= their_mag <= .999)
{
// since we may be running this method concurrently
// on multiple threads we need to acquire a lock
// before modifying the shared constraint_row object.
Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
// A reference to the constraint row.
NodeConstraintRow& constraint_row = constraints[my_node].first;
constraint_row.insert(std::make_pair (their_node,
their_value));
}
}
}
}
}
| 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 | ||
| ) | [static, inherited] |
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 | ||
| ) | [static, inherited] |
Computes the node position constraint equation contributions (for meshes with periodic boundary conditions)
Definition at line 931 of file fe_abstract.C.
References libMesh::Elem::active(), libMesh::PeriodicBoundaries::boundary(), libMesh::BoundaryInfo::boundary_ids(), libMesh::Elem::build_side(), libMesh::Elem::default_order(), libMesh::Elem::dim(), libMesh::FEAbstract::fe_type, libMesh::MeshBase::get_boundary_info(), libMesh::PeriodicBoundaryBase::get_corresponding_pos(), libMesh::invalid_uint, libMesh::FEInterface::inverse_map(), libMesh::LAGRANGE, libMesh::Elem::level(), libMesh::libmesh_assert(), libMesh::FEInterface::n_dofs(), libMesh::Elem::n_sides(), libMesh::PeriodicBoundaries::neighbor(), libMesh::Elem::neighbor(), libMesh::PeriodicBoundaryBase::pairedboundary, libMesh::Real, libMesh::FEInterface::shape(), libMesh::BoundaryInfo::side_with_boundary_id(), and libMesh::Threads::spin_mtx.
{
// Only bother if we truly have periodic boundaries
if (boundaries.empty())
return;
libmesh_assert(elem);
// Only constrain active elements with this method
if (!elem->active())
return;
const unsigned int Dim = elem->dim();
// We currently always use LAGRANGE mappings for geometry
const FEType fe_type(elem->default_order(), LAGRANGE);
std::vector<const Node*> my_nodes, neigh_nodes;
// Look at the element faces. Check to see if we need to
// build constraints.
for (unsigned short int s=0; s<elem->n_sides(); s++)
{
if (elem->neighbor(s))
continue;
const std::vector<boundary_id_type>& bc_ids =
mesh.get_boundary_info().boundary_ids (elem, s);
for (std::vector<boundary_id_type>::const_iterator id_it=bc_ids.begin(); id_it!=bc_ids.end(); ++id_it)
{
const boundary_id_type boundary_id = *id_it;
const PeriodicBoundaryBase *periodic = boundaries.boundary(boundary_id);
if (periodic)
{
libmesh_assert(point_locator);
// Get pointers to the element's neighbor.
const Elem* neigh = boundaries.neighbor(boundary_id, *point_locator, elem, s);
// h refinement constraints:
// constrain dofs shared between
// this element and ones as coarse
// as or coarser than this element.
if (neigh->level() <= elem->level())
{
unsigned int s_neigh =
mesh.get_boundary_info().side_with_boundary_id(neigh, periodic->pairedboundary);
libmesh_assert_not_equal_to (s_neigh, libMesh::invalid_uint);
#ifdef LIBMESH_ENABLE_AMR
libmesh_assert(neigh->active());
#endif // #ifdef LIBMESH_ENABLE_AMR
const UniquePtr<Elem> my_side (elem->build_side(s));
const UniquePtr<Elem> neigh_side (neigh->build_side(s_neigh));
const unsigned int n_side_nodes = my_side->n_nodes();
my_nodes.clear();
my_nodes.reserve (n_side_nodes);
neigh_nodes.clear();
neigh_nodes.reserve (n_side_nodes);
for (unsigned int n=0; n != n_side_nodes; ++n)
my_nodes.push_back(my_side->get_node(n));
for (unsigned int n=0; n != n_side_nodes; ++n)
neigh_nodes.push_back(neigh_side->get_node(n));
// Make sure we're not adding recursive constraints
// due to the redundancy in the way we add periodic
// boundary constraints, or adding constraints to
// nodes that already have AMR constraints
std::vector<bool> skip_constraint(n_side_nodes, false);
for (unsigned int my_side_n=0;
my_side_n < n_side_nodes;
my_side_n++)
{
libmesh_assert_less (my_side_n, FEInterface::n_dofs(Dim-1, fe_type, my_side->type()));
const Node* my_node = my_nodes[my_side_n];
// Figure out where my node lies on their reference element.
const Point neigh_point = periodic->get_corresponding_pos(*my_node);
const Point mapped_point = FEInterface::inverse_map(Dim-1, fe_type,
neigh_side.get(),
neigh_point);
// If we've already got a constraint on this
// node, then the periodic constraint is
// redundant
{
Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
if (constraints.count(my_node))
{
skip_constraint[my_side_n] = true;
continue;
}
}
// Compute the neighbors's side shape function values.
for (unsigned int their_side_n=0;
their_side_n < n_side_nodes;
their_side_n++)
{
libmesh_assert_less (their_side_n, FEInterface::n_dofs(Dim-1, fe_type, neigh_side->type()));
const Node* their_node = neigh_nodes[their_side_n];
// If there's a constraint on an opposing node,
// we need to see if it's constrained by
// *our side* making any periodic constraint
// on us recursive
{
Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
if (!constraints.count(their_node))
continue;
const NodeConstraintRow& their_constraint_row =
constraints[their_node].first;
for (unsigned int orig_side_n=0;
orig_side_n < n_side_nodes;
orig_side_n++)
{
libmesh_assert_less (orig_side_n, FEInterface::n_dofs(Dim-1, fe_type, my_side->type()));
const Node* orig_node = my_nodes[orig_side_n];
if (their_constraint_row.count(orig_node))
skip_constraint[orig_side_n] = true;
}
}
}
}
for (unsigned int my_side_n=0;
my_side_n < n_side_nodes;
my_side_n++)
{
libmesh_assert_less (my_side_n, FEInterface::n_dofs(Dim-1, fe_type, my_side->type()));
if (skip_constraint[my_side_n])
continue;
const Node* my_node = my_nodes[my_side_n];
// Figure out where my node lies on their reference element.
const Point neigh_point = periodic->get_corresponding_pos(*my_node);
// Figure out where my node lies on their reference element.
const Point mapped_point = FEInterface::inverse_map(Dim-1, fe_type,
neigh_side.get(),
neigh_point);
for (unsigned int their_side_n=0;
their_side_n < n_side_nodes;
their_side_n++)
{
libmesh_assert_less (their_side_n, FEInterface::n_dofs(Dim-1, fe_type, neigh_side->type()));
const Node* their_node = neigh_nodes[their_side_n];
libmesh_assert(their_node);
const Real their_value = FEInterface::shape(Dim-1,
fe_type,
neigh_side->type(),
their_side_n,
mapped_point);
// since we may be running this method concurrently
// on multiple threads we need to acquire a lock
// before modifying the shared constraint_row object.
{
Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
NodeConstraintRow& constraint_row =
constraints[my_node].first;
constraint_row.insert(std::make_pair(their_node,
their_value));
}
}
}
}
}
}
}
}
| static void libMesh::FEGenericBase< FEOutputType< T >::type >::compute_proj_constraints | ( | DofConstraints & | constraints, |
| DofMap & | dof_map, | ||
| const unsigned int | variable_number, | ||
| const Elem * | elem | ||
| ) | [static, inherited] |
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 | ||
| ) | [protected, virtual, inherited] |
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 | ( | ) | [static, inherited] |
Definition at line 106 of file reference_counter.C.
References libMesh::ReferenceCounter::_enable_print_counter.
Referenced by libMesh::LibMeshInit::LibMeshInit().
{
_enable_print_counter = false;
return;
}
| static void libMesh::FE< Dim, T >::dofs_on_edge | ( | const Elem *const | elem, |
| const Order | o, | ||
| unsigned int | e, | ||
| std::vector< unsigned int > & | di | ||
| ) | [static, inherited] |
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 | ||
| ) | [static, inherited] |
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 |
||
| ) | [virtual, inherited] |
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 | ( | ) | [static, inherited] |
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.
{
_enable_print_counter = true;
return;
}
| virtual FEContinuity libMesh::FE< Dim, T >::get_continuity | ( | ) | const [virtual, inherited] |
- 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 [inline, inherited] |
- Returns:
- the curl of the shape function at the quadrature points.
Definition at line 226 of file fe_base.h.
References libMesh::FEAbstract::calculate_curl_phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::curl_phi, and libMesh::libmesh_assert().
{ libmesh_assert(!calculations_started || calculate_curl_phi);
calculate_curl_phi = calculate_dphiref = true; return curl_phi; }
| const std::vector<Real>& libMesh::FEAbstract::get_curvatures | ( | ) | const [inline, inherited] |
- Returns:
- the curvatures for use in face integration.
Definition at line 380 of file fe_abstract.h.
References libMesh::FEAbstract::_fe_map.
{ return this->_fe_map->get_curvatures();}
| const std::vector<std::vector<OutputTensor> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phi | ( | ) | const [inline, inherited] |
- Returns:
- the shape function second derivatives at the quadrature points.
Definition at line 292 of file fe_base.h.
References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::d2phi, and libMesh::libmesh_assert().
{ libmesh_assert(!calculations_started || calculate_d2phi);
calculate_d2phi = calculate_dphiref = true; return d2phi; }
| const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phideta2 | ( | ) | const [inline, inherited] |
- Returns:
- the shape function second derivatives at the quadrature points, in reference coordinates
Definition at line 372 of file fe_base.h.
References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::d2phideta2, and libMesh::libmesh_assert().
{ libmesh_assert(!calculations_started || calculate_d2phi);
calculate_d2phi = calculate_dphiref = true; return d2phideta2; }
| const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidetadzeta | ( | ) | const [inline, inherited] |
- Returns:
- the shape function second derivatives at the quadrature points, in reference coordinates
Definition at line 380 of file fe_base.h.
References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::d2phidetadzeta, and libMesh::libmesh_assert().
{ libmesh_assert(!calculations_started || calculate_d2phi);
calculate_d2phi = calculate_dphiref = true; return d2phidetadzeta; }
| const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidx2 | ( | ) | const [inline, inherited] |
- Returns:
- the shape function second derivatives at the quadrature points.
Definition at line 300 of file fe_base.h.
References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::d2phidx2, and libMesh::libmesh_assert().
{ libmesh_assert(!calculations_started || calculate_d2phi);
calculate_d2phi = calculate_dphiref = true; return d2phidx2; }
| const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxdy | ( | ) | const [inline, inherited] |
- Returns:
- the shape function second derivatives at the quadrature points.
Definition at line 308 of file fe_base.h.
References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::d2phidxdy, and libMesh::libmesh_assert().
{ libmesh_assert(!calculations_started || calculate_d2phi);
calculate_d2phi = calculate_dphiref = true; return d2phidxdy; }
| const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxdz | ( | ) | const [inline, inherited] |
- Returns:
- the shape function second derivatives at the quadrature points.
Definition at line 316 of file fe_base.h.
References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::d2phidxdz, and libMesh::libmesh_assert().
{ libmesh_assert(!calculations_started || calculate_d2phi);
calculate_d2phi = calculate_dphiref = true; return d2phidxdz; }
| const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxi2 | ( | ) | const [inline, inherited] |
- Returns:
- the shape function second derivatives at the quadrature points, in reference coordinates
Definition at line 348 of file fe_base.h.
References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::d2phidxi2, and libMesh::libmesh_assert().
{ libmesh_assert(!calculations_started || calculate_d2phi);
calculate_d2phi = calculate_dphiref = true; return d2phidxi2; }
| const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxideta | ( | ) | const [inline, inherited] |
- Returns:
- the shape function second derivatives at the quadrature points, in reference coordinates
Definition at line 356 of file fe_base.h.
References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::d2phidxideta, and libMesh::libmesh_assert().
{ libmesh_assert(!calculations_started || calculate_d2phi);
calculate_d2phi = calculate_dphiref = true; return d2phidxideta; }
| const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxidzeta | ( | ) | const [inline, inherited] |
- Returns:
- the shape function second derivatives at the quadrature points, in reference coordinates
Definition at line 364 of file fe_base.h.
References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::d2phidxidzeta, and libMesh::libmesh_assert().
{ libmesh_assert(!calculations_started || calculate_d2phi);
calculate_d2phi = calculate_dphiref = true; return d2phidxidzeta; }
| const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidy2 | ( | ) | const [inline, inherited] |
- Returns:
- the shape function second derivatives at the quadrature points.
Definition at line 324 of file fe_base.h.
References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::d2phidy2, and libMesh::libmesh_assert().
{ libmesh_assert(!calculations_started || calculate_d2phi);
calculate_d2phi = calculate_dphiref = true; return d2phidy2; }
| const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidydz | ( | ) | const [inline, inherited] |
- Returns:
- the shape function second derivatives at the quadrature points.
Definition at line 332 of file fe_base.h.
References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::d2phidydz, and libMesh::libmesh_assert().
{ libmesh_assert(!calculations_started || calculate_d2phi);
calculate_d2phi = calculate_dphiref = true; return d2phidydz; }
| const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidz2 | ( | ) | const [inline, inherited] |
- Returns:
- the shape function second derivatives at the quadrature points.
Definition at line 340 of file fe_base.h.
References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::d2phidz2, and libMesh::libmesh_assert().
{ libmesh_assert(!calculations_started || calculate_d2phi);
calculate_d2phi = calculate_dphiref = true; return d2phidz2; }
| const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidzeta2 | ( | ) | const [inline, inherited] |
- Returns:
- the shape function second derivatives at the quadrature points, in reference coordinates
Definition at line 388 of file fe_base.h.
References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::d2phidzeta2, and libMesh::libmesh_assert().
{ libmesh_assert(!calculations_started || calculate_d2phi);
calculate_d2phi = calculate_dphiref = true; return d2phidzeta2; }
| const std::vector<RealGradient>& libMesh::FEAbstract::get_d2xyzdeta2 | ( | ) | const [inline, inherited] |
- Returns:
- the second partial derivatives in eta.
Definition at line 267 of file fe_abstract.h.
References libMesh::FEAbstract::_fe_map.
{ return this->_fe_map->get_d2xyzdeta2(); }
| const std::vector<RealGradient>& libMesh::FEAbstract::get_d2xyzdetadzeta | ( | ) | const [inline, inherited] |
- Returns:
- the second partial derivatives in eta-zeta.
Definition at line 297 of file fe_abstract.h.
References libMesh::FEAbstract::_fe_map.
{ return this->_fe_map->get_d2xyzdetadzeta(); }
| const std::vector<RealGradient>& libMesh::FEAbstract::get_d2xyzdxi2 | ( | ) | const [inline, inherited] |
- Returns:
- the second partial derivatives in xi.
Definition at line 261 of file fe_abstract.h.
References libMesh::FEAbstract::_fe_map.
{ return this->_fe_map->get_d2xyzdxi2(); }
| const std::vector<RealGradient>& libMesh::FEAbstract::get_d2xyzdxideta | ( | ) | const [inline, inherited] |
- Returns:
- the second partial derivatives in xi-eta.
Definition at line 283 of file fe_abstract.h.
References libMesh::FEAbstract::_fe_map.
{ return this->_fe_map->get_d2xyzdxideta(); }
| const std::vector<RealGradient>& libMesh::FEAbstract::get_d2xyzdxidzeta | ( | ) | const [inline, inherited] |
- Returns:
- the second partial derivatives in xi-zeta.
Definition at line 291 of file fe_abstract.h.
References libMesh::FEAbstract::_fe_map.
{ return this->_fe_map->get_d2xyzdxidzeta(); }
| const std::vector<RealGradient>& libMesh::FEAbstract::get_d2xyzdzeta2 | ( | ) | const [inline, inherited] |
- Returns:
- the second partial derivatives in zeta.
Definition at line 275 of file fe_abstract.h.
References libMesh::FEAbstract::_fe_map.
{ return this->_fe_map->get_d2xyzdzeta2(); }
| const std::vector<Real>& libMesh::FEAbstract::get_detadx | ( | ) | const [inline, inherited] |
- 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.
{ return this->_fe_map->get_detadx(); }
| const std::vector<Real>& libMesh::FEAbstract::get_detady | ( | ) | const [inline, inherited] |
- 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.
{ return this->_fe_map->get_detady(); }
| const std::vector<Real>& libMesh::FEAbstract::get_detadz | ( | ) | const [inline, inherited] |
- 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.
{ return this->_fe_map->get_detadz(); }
| const std::vector<std::vector<OutputDivergence> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_div_phi | ( | ) | const [inline, inherited] |
- Returns:
- the divergence of the shape function at the quadrature points.
Definition at line 234 of file fe_base.h.
References libMesh::FEAbstract::calculate_div_phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::div_phi, and libMesh::libmesh_assert().
{ libmesh_assert(!calculations_started || calculate_div_phi);
calculate_div_phi = calculate_dphiref = true; return div_phi; }
| const std::vector<OutputGradient>& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphase | ( | ) | const [inline, inherited] |
- 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 406 of file fe_base.h.
References libMesh::FEGenericBase< OutputType >::dphase.
{ return dphase; }
| const std::vector<std::vector<OutputGradient> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphi | ( | ) | const [inline, inherited] |
- Returns:
- the shape function derivatives at the quadrature points.
Definition at line 218 of file fe_base.h.
References libMesh::FEAbstract::calculate_dphi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::dphi, and libMesh::libmesh_assert().
{ libmesh_assert(!calculations_started || calculate_dphi);
calculate_dphi = calculate_dphiref = true; return dphi; }
| const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphideta | ( | ) | const [inline, inherited] |
- Returns:
- the shape function eta-derivative at the quadrature points.
Definition at line 274 of file fe_base.h.
References libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::dphideta, and libMesh::libmesh_assert().
{ libmesh_assert(!calculations_started || calculate_dphiref);
calculate_dphiref = true; return dphideta; }
| const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidx | ( | ) | const [inline, inherited] |
- Returns:
- the shape function x-derivative at the quadrature points.
Definition at line 242 of file fe_base.h.
References libMesh::FEAbstract::calculate_dphi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::dphidx, and libMesh::libmesh_assert().
{ libmesh_assert(!calculations_started || calculate_dphi);
calculate_dphi = calculate_dphiref = true; return dphidx; }
| const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidxi | ( | ) | const [inline, inherited] |
- Returns:
- the shape function xi-derivative at the quadrature points.
Definition at line 266 of file fe_base.h.
References libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::dphidxi, and libMesh::libmesh_assert().
{ libmesh_assert(!calculations_started || calculate_dphiref);
calculate_dphiref = true; return dphidxi; }
| const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidy | ( | ) | const [inline, inherited] |
- Returns:
- the shape function y-derivative at the quadrature points.
Definition at line 250 of file fe_base.h.
References libMesh::FEAbstract::calculate_dphi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::dphidy, and libMesh::libmesh_assert().
{ libmesh_assert(!calculations_started || calculate_dphi);
calculate_dphi = calculate_dphiref = true; return dphidy; }
| const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidz | ( | ) | const [inline, inherited] |
- Returns:
- the shape function z-derivative at the quadrature points.
Definition at line 258 of file fe_base.h.
References libMesh::FEAbstract::calculate_dphi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::dphidz, and libMesh::libmesh_assert().
{ libmesh_assert(!calculations_started || calculate_dphi);
calculate_dphi = calculate_dphiref = true; return dphidz; }
| const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidzeta | ( | ) | const [inline, inherited] |
- Returns:
- the shape function zeta-derivative at the quadrature points.
Definition at line 282 of file fe_base.h.
References libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::dphidzeta, and libMesh::libmesh_assert().
{ libmesh_assert(!calculations_started || calculate_dphiref);
calculate_dphiref = true; return dphidzeta; }
| const std::vector<Real>& libMesh::FEAbstract::get_dxidx | ( | ) | const [inline, inherited] |
- 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.
{ return this->_fe_map->get_dxidx(); }
| const std::vector<Real>& libMesh::FEAbstract::get_dxidy | ( | ) | const [inline, inherited] |
- 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.
{ return this->_fe_map->get_dxidy(); }
| const std::vector<Real>& libMesh::FEAbstract::get_dxidz | ( | ) | const [inline, inherited] |
- 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.
{ return this->_fe_map->get_dxidz(); }
| const std::vector<RealGradient>& libMesh::FEAbstract::get_dxyzdeta | ( | ) | const [inline, inherited] |
- 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.
{ return this->_fe_map->get_dxyzdeta(); }
| const std::vector<RealGradient>& libMesh::FEAbstract::get_dxyzdxi | ( | ) | const [inline, inherited] |
- 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.
{ return this->_fe_map->get_dxyzdxi(); }
| const std::vector<RealGradient>& libMesh::FEAbstract::get_dxyzdzeta | ( | ) | const [inline, inherited] |
- 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.
{ return _fe_map->get_dxyzdzeta(); }
| const std::vector<Real>& libMesh::FEAbstract::get_dzetadx | ( | ) | const [inline, inherited] |
- 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.
{ return this->_fe_map->get_dzetadx(); }
| const std::vector<Real>& libMesh::FEAbstract::get_dzetady | ( | ) | const [inline, inherited] |
- 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.
{ return this->_fe_map->get_dzetady(); }
| const std::vector<Real>& libMesh::FEAbstract::get_dzetadz | ( | ) | const [inline, inherited] |
- 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.
{ return this->_fe_map->get_dzetadz(); }
| FEFamily libMesh::FEAbstract::get_family | ( | ) | const [inline, inherited] |
- 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().
| const FEMap& libMesh::FEAbstract::get_fe_map | ( | ) | const [inline, inherited] |
- Returns:
- the mapping object
Definition at line 444 of file fe_abstract.h.
References libMesh::FEAbstract::_fe_map.
Referenced by libMesh::HCurlFETransformation< OutputShape >::map_curl(), libMesh::H1FETransformation< OutputShape >::map_curl(), libMesh::H1FETransformation< OutputShape >::map_d2phi(), libMesh::H1FETransformation< OutputShape >::map_div(), libMesh::H1FETransformation< OutputShape >::map_dphi(), and libMesh::HCurlFETransformation< OutputShape >::map_phi().
{ return *_fe_map.get(); }
| FEType libMesh::FEAbstract::get_fe_type | ( | ) | const [inline, inherited] |
- 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< OutputShape >::map_phi(), libMesh::HCurlFETransformation< OutputShape >::map_phi(), and libMesh::ProjectFEMSolution::operator()().
{ return fe_type; }
| std::string libMesh::ReferenceCounter::get_info | ( | ) | [static, inherited] |
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().
{
#if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
std::ostringstream oss;
oss << '\n'
<< " ---------------------------------------------------------------------------- \n"
<< "| Reference count information |\n"
<< " ---------------------------------------------------------------------------- \n";
for (Counts::iterator it = _counts.begin();
it != _counts.end(); ++it)
{
const std::string name(it->first);
const unsigned int creations = it->second.first;
const unsigned int destructions = it->second.second;
oss << "| " << name << " reference count information:\n"
<< "| Creations: " << creations << '\n'
<< "| Destructions: " << destructions << '\n';
}
oss << " ---------------------------------------------------------------------------- \n";
return oss.str();
#else
return "";
#endif
}
| const std::vector<Real>& libMesh::FEAbstract::get_JxW | ( | ) | const [inline, inherited] |
- 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::ExactSolution::_compute_error(), libMesh::ExactErrorEstimator::find_squared_element_error(), libMesh::FEMSystem::init_context(), and libMesh::ProjectFEMSolution::operator()().
{ return this->_fe_map->get_JxW(); }
| const std::vector<Point>& libMesh::FEAbstract::get_normals | ( | ) | const [inline, inherited] |
- Returns:
- the normal vectors for face integration.
Definition at line 374 of file fe_abstract.h.
References libMesh::FEAbstract::_fe_map.
{ return this->_fe_map->get_normals(); }
| Order libMesh::FEAbstract::get_order | ( | ) | const [inline, inherited] |
- 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.
| unsigned int libMesh::FEAbstract::get_p_level | ( | ) | const [inline, inherited] |
- 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.
{ return _p_level; }
| const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_phi | ( | ) | const [inline, inherited] |
- Returns:
- the shape function values at the quadrature points on the element.
Definition at line 210 of file fe_base.h.
References libMesh::FEAbstract::calculate_phi, libMesh::FEAbstract::calculations_started, libMesh::libmesh_assert(), and libMesh::FEGenericBase< OutputType >::phi.
{ libmesh_assert(!calculations_started || calculate_phi);
calculate_phi = true; return phi; }
| void libMesh::FEAbstract::get_refspace_nodes | ( | const ElemType | t, |
| std::vector< Point > & | nodes | ||
| ) | [static, inherited] |
returns the reference space nodes coordinates given the element type
Definition at line 259 of file fe_abstract.C.
References libMesh::EDGE2, libMesh::EDGE3, libMesh::HEX20, libMesh::HEX27, libMesh::HEX8, libMesh::PRISM15, libMesh::PRISM18, libMesh::PRISM6, libMesh::PYRAMID13, libMesh::PYRAMID14, libMesh::PYRAMID5, libMesh::QUAD4, libMesh::QUAD8, libMesh::QUAD9, libMesh::TET10, libMesh::TET4, libMesh::TRI3, and libMesh::TRI6.
{
switch(itemType)
{
case EDGE2:
{
nodes.resize(2);
nodes[0] = Point (-1.,0.,0.);
nodes[1] = Point (1.,0.,0.);
return;
}
case EDGE3:
{
nodes.resize(3);
nodes[0] = Point (-1.,0.,0.);
nodes[1] = Point (1.,0.,0.);
nodes[2] = Point (0.,0.,0.);
return;
}
case TRI3:
{
nodes.resize(3);
nodes[0] = Point (0.,0.,0.);
nodes[1] = Point (1.,0.,0.);
nodes[2] = Point (0.,1.,0.);
return;
}
case TRI6:
{
nodes.resize(6);
nodes[0] = Point (0.,0.,0.);
nodes[1] = Point (1.,0.,0.);
nodes[2] = Point (0.,1.,0.);
nodes[3] = Point (.5,0.,0.);
nodes[4] = Point (.5,.5,0.);
nodes[5] = Point (0.,.5,0.);
return;
}
case QUAD4:
{
nodes.resize(4);
nodes[0] = Point (-1.,-1.,0.);
nodes[1] = Point (1.,-1.,0.);
nodes[2] = Point (1.,1.,0.);
nodes[3] = Point (-1.,1.,0.);
return;
}
case QUAD8:
{
nodes.resize(8);
nodes[0] = Point (-1.,-1.,0.);
nodes[1] = Point (1.,-1.,0.);
nodes[2] = Point (1.,1.,0.);
nodes[3] = Point (-1.,1.,0.);
nodes[4] = Point (0.,-1.,0.);
nodes[5] = Point (1.,0.,0.);
nodes[6] = Point (0.,1.,0.);
nodes[7] = Point (-1.,0.,0.);
return;
}
case QUAD9:
{
nodes.resize(9);
nodes[0] = Point (-1.,-1.,0.);
nodes[1] = Point (1.,-1.,0.);
nodes[2] = Point (1.,1.,0.);
nodes[3] = Point (-1.,1.,0.);
nodes[4] = Point (0.,-1.,0.);
nodes[5] = Point (1.,0.,0.);
nodes[6] = Point (0.,1.,0.);
nodes[7] = Point (-1.,0.,0.);
nodes[8] = Point (0.,0.,0.);
return;
}
case TET4:
{
nodes.resize(4);
nodes[0] = Point (0.,0.,0.);
nodes[1] = Point (1.,0.,0.);
nodes[2] = Point (0.,1.,0.);
nodes[3] = Point (0.,0.,1.);
return;
}
case TET10:
{
nodes.resize(10);
nodes[0] = Point (0.,0.,0.);
nodes[1] = Point (1.,0.,0.);
nodes[2] = Point (0.,1.,0.);
nodes[3] = Point (0.,0.,1.);
nodes[4] = Point (.5,0.,0.);
nodes[5] = Point (.5,.5,0.);
nodes[6] = Point (0.,.5,0.);
nodes[7] = Point (0.,0.,.5);
nodes[8] = Point (.5,0.,.5);
nodes[9] = Point (0.,.5,.5);
return;
}
case HEX8:
{
nodes.resize(8);
nodes[0] = Point (-1.,-1.,-1.);
nodes[1] = Point (1.,-1.,-1.);
nodes[2] = Point (1.,1.,-1.);
nodes[3] = Point (-1.,1.,-1.);
nodes[4] = Point (-1.,-1.,1.);
nodes[5] = Point (1.,-1.,1.);
nodes[6] = Point (1.,1.,1.);
nodes[7] = Point (-1.,1.,1.);
return;
}
case HEX20:
{
nodes.resize(20);
nodes[0] = Point (-1.,-1.,-1.);
nodes[1] = Point (1.,-1.,-1.);
nodes[2] = Point (1.,1.,-1.);
nodes[3] = Point (-1.,1.,-1.);
nodes[4] = Point (-1.,-1.,1.);
nodes[5] = Point (1.,-1.,1.);
nodes[6] = Point (1.,1.,1.);
nodes[7] = Point (-1.,1.,1.);
nodes[8] = Point (0.,-1.,-1.);
nodes[9] = Point (1.,0.,-1.);
nodes[10] = Point (0.,1.,-1.);
nodes[11] = Point (-1.,0.,-1.);
nodes[12] = Point (-1.,-1.,0.);
nodes[13] = Point (1.,-1.,0.);
nodes[14] = Point (1.,1.,0.);
nodes[15] = Point (-1.,1.,0.);
nodes[16] = Point (0.,-1.,1.);
nodes[17] = Point (1.,0.,1.);
nodes[18] = Point (0.,1.,1.);
nodes[19] = Point (-1.,0.,1.);
return;
}
case HEX27:
{
nodes.resize(27);
nodes[0] = Point (-1.,-1.,-1.);
nodes[1] = Point (1.,-1.,-1.);
nodes[2] = Point (1.,1.,-1.);
nodes[3] = Point (-1.,1.,-1.);
nodes[4] = Point (-1.,-1.,1.);
nodes[5] = Point (1.,-1.,1.);
nodes[6] = Point (1.,1.,1.);
nodes[7] = Point (-1.,1.,1.);
nodes[8] = Point (0.,-1.,-1.);
nodes[9] = Point (1.,0.,-1.);
nodes[10] = Point (0.,1.,-1.);
nodes[11] = Point (-1.,0.,-1.);
nodes[12] = Point (-1.,-1.,0.);
nodes[13] = Point (1.,-1.,0.);
nodes[14] = Point (1.,1.,0.);
nodes[15] = Point (-1.,1.,0.);
nodes[16] = Point (0.,-1.,1.);
nodes[17] = Point (1.,0.,1.);
nodes[18] = Point (0.,1.,1.);
nodes[19] = Point (-1.,0.,1.);
nodes[20] = Point (0.,0.,-1.);
nodes[21] = Point (0.,-1.,0.);
nodes[22] = Point (1.,0.,0.);
nodes[23] = Point (0.,1.,0.);
nodes[24] = Point (-1.,0.,0.);
nodes[25] = Point (0.,0.,1.);
nodes[26] = Point (0.,0.,0.);
return;
}
case PRISM6:
{
nodes.resize(6);
nodes[0] = Point (0.,0.,-1.);
nodes[1] = Point (1.,0.,-1.);
nodes[2] = Point (0.,1.,-1.);
nodes[3] = Point (0.,0.,1.);
nodes[4] = Point (1.,0.,1.);
nodes[5] = Point (0.,1.,1.);
return;
}
case PRISM15:
{
nodes.resize(15);
nodes[0] = Point (0.,0.,-1.);
nodes[1] = Point (1.,0.,-1.);
nodes[2] = Point (0.,1.,-1.);
nodes[3] = Point (0.,0.,1.);
nodes[4] = Point (1.,0.,1.);
nodes[5] = Point (0.,1.,1.);
nodes[6] = Point (.5,0.,-1.);
nodes[7] = Point (.5,.5,-1.);
nodes[8] = Point (0.,.5,-1.);
nodes[9] = Point (0.,0.,0.);
nodes[10] = Point (1.,0.,0.);
nodes[11] = Point (0.,1.,0.);
nodes[12] = Point (.5,0.,1.);
nodes[13] = Point (.5,.5,1.);
nodes[14] = Point (0.,.5,1.);
return;
}
case PRISM18:
{
nodes.resize(18);
nodes[0] = Point (0.,0.,-1.);
nodes[1] = Point (1.,0.,-1.);
nodes[2] = Point (0.,1.,-1.);
nodes[3] = Point (0.,0.,1.);
nodes[4] = Point (1.,0.,1.);
nodes[5] = Point (0.,1.,1.);
nodes[6] = Point (.5,0.,-1.);
nodes[7] = Point (.5,.5,-1.);
nodes[8] = Point (0.,.5,-1.);
nodes[9] = Point (0.,0.,0.);
nodes[10] = Point (1.,0.,0.);
nodes[11] = Point (0.,1.,0.);
nodes[12] = Point (.5,0.,1.);
nodes[13] = Point (.5,.5,1.);
nodes[14] = Point (0.,.5,1.);
nodes[15] = Point (.5,0.,0.);
nodes[16] = Point (.5,.5,0.);
nodes[17] = Point (0.,.5,0.);
return;
}
case PYRAMID5:
{
nodes.resize(5);
nodes[0] = Point (-1.,-1.,0.);
nodes[1] = Point (1.,-1.,0.);
nodes[2] = Point (1.,1.,0.);
nodes[3] = Point (-1.,1.,0.);
nodes[4] = Point (0.,0.,1.);
return;
}
case PYRAMID13:
{
nodes.resize(13);
// base corners
nodes[0] = Point (-1.,-1.,0.);
nodes[1] = Point (1.,-1.,0.);
nodes[2] = Point (1.,1.,0.);
nodes[3] = Point (-1.,1.,0.);
// apex
nodes[4] = Point (0.,0.,1.);
// base midedge
nodes[5] = Point (0.,-1.,0.);
nodes[6] = Point (1.,0.,0.);
nodes[7] = Point (0.,1.,0.);
nodes[8] = Point (-1,0.,0.);
// lateral midedge
nodes[9] = Point (-.5,-.5,.5);
nodes[10] = Point (.5,-.5,.5);
nodes[11] = Point (.5,.5,.5);
nodes[12] = Point (-.5,.5,.5);
return;
}
case PYRAMID14:
{
nodes.resize(14);
// base corners
nodes[0] = Point (-1.,-1.,0.);
nodes[1] = Point (1.,-1.,0.);
nodes[2] = Point (1.,1.,0.);
nodes[3] = Point (-1.,1.,0.);
// apex
nodes[4] = Point (0.,0.,1.);
// base midedge
nodes[5] = Point (0.,-1.,0.);
nodes[6] = Point (1.,0.,0.);
nodes[7] = Point (0.,1.,0.);
nodes[8] = Point (-1,0.,0.);
// lateral midedge
nodes[9] = Point (-.5,-.5,.5);
nodes[10] = Point (.5,-.5,.5);
nodes[11] = Point (.5,.5,.5);
nodes[12] = Point (-.5,.5,.5);
// base center
nodes[13] = Point (0.,0.,0.);
return;
}
default:
libmesh_error_msg("ERROR: Unknown element type " << itemType);
}
}
| const std::vector<RealGradient>& libMesh::FEGenericBase< FEOutputType< T >::type >::get_Sobolev_dweight | ( | ) | const [inline, inherited] |
- Returns:
- the first global derivative of the multiplicative weight at each quadrature point. See
get_Sobolev_weight()for details. In case ofFEinitialized to all zero.
Definition at line 430 of file fe_base.h.
References libMesh::FEGenericBase< OutputType >::dweight.
{ return dweight; }
| const std::vector<Real>& libMesh::FEGenericBase< FEOutputType< T >::type >::get_Sobolev_weight | ( | ) | const [inline, inherited] |
- 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 422 of file fe_base.h.
References libMesh::FEGenericBase< OutputType >::weight.
{ return weight; }
| const std::vector<std::vector<Point> >& libMesh::FEAbstract::get_tangents | ( | ) | const [inline, inherited] |
- Returns:
- the tangent vectors for face integration.
Definition at line 368 of file fe_abstract.h.
References libMesh::FEAbstract::_fe_map.
{ return this->_fe_map->get_tangents(); }
| ElemType libMesh::FEAbstract::get_type | ( | ) | const [inline, inherited] |
- 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.
{ return elem_type; }
| const std::vector<Point>& libMesh::FEAbstract::get_xyz | ( | ) | const [inline, inherited] |
- Returns:
- the
xyzspatial 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::ExactSolution::_compute_error(), libMesh::ExactErrorEstimator::find_squared_element_error(), libMesh::DGFEMContext::neighbor_side_fe_reinit(), and libMesh::ProjectFEMSolution::operator()().
{ return this->_fe_map->get_xyz(); }
| void libMesh::ReferenceCounter::increment_constructor_count | ( | const std::string & | name | ) | [inline, protected, inherited] |
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().
{
Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
std::pair<unsigned int, unsigned int>& p = _counts[name];
p.first++;
}
| void libMesh::ReferenceCounter::increment_destructor_count | ( | const std::string & | name | ) | [inline, protected, inherited] |
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().
{
Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
std::pair<unsigned int, unsigned int>& p = _counts[name];
p.second++;
}
| virtual void libMesh::FE< Dim, T >::init_base_shape_functions | ( | const std::vector< Point > & | qp, |
| const Elem * | e | ||
| ) | [protected, virtual, inherited] |
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 | ||
| ) | [protected, virtual, inherited] |
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 |
||
| ) | [static, inherited] |
- Returns:
- the location (on the reference element) of the point
plocated in physical space. This function requires inverting the (possibly nonlinear) transformation map, so it is not trivial. The optional parametertolerancedefines how close is "good enough." The map inversion iteration computes the sequence
, and the iteration is terminated when 
| 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 |
||
| ) | [static, inherited] |
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 , and the iteration is terminated when
| virtual bool libMesh::FE< Dim, T >::is_hierarchic | ( | ) | const [virtual, inherited] |
- 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 | ||
| ) | [static, inherited] |
- Returns:
- the location (in physical space) of the point
plocated on the reference element.
| static Point libMesh::FE< Dim, T >::map_eta | ( | const Elem * | elem, |
| const Point & | reference_point | ||
| ) | [static, inherited] |
- Returns:
- d(xyz)/deta (in physical space) of the point
plocated on the reference element.
| static Point libMesh::FE< Dim, T >::map_xi | ( | const Elem * | elem, |
| const Point & | reference_point | ||
| ) | [static, inherited] |
- Returns:
- d(xyz)/dxi (in physical space) of the point
plocated on the reference element.
| static Point libMesh::FE< Dim, T >::map_zeta | ( | const Elem * | elem, |
| const Point & | reference_point | ||
| ) | [static, inherited] |
- Returns:
- d(xyz)/dzeta (in physical space) of the point
plocated on the reference element.
| static unsigned int libMesh::FE< Dim, T >::n_dofs | ( | const ElemType | t, |
| const Order | o | ||
| ) | [static, inherited] |
- 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 | ||
| ) | [static, inherited] |
- Returns:
- the number of dofs at node
nfor a finite element of typetand ordero.
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 | ||
| ) | [static, inherited] |
- 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 | ( | ) | [inline, static, inherited] |
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.
Referenced by libMesh::LibMeshInit::~LibMeshInit().
{ return _n_objects; }
| virtual unsigned int libMesh::FE< Dim, T >::n_quadrature_points | ( | ) | const [virtual, inherited] |
- Returns:
- the total number of quadrature points. Call this to get an upper bound for the
forloop in your simulation for matrix assembly of the current element.
Implements libMesh::FEAbstract.
| virtual unsigned int libMesh::FE< Dim, T >::n_shape_functions | ( | ) | const [virtual, inherited] |
- 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 | ||
| ) | [inline, static, inherited] |
| 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 | ||
| ) | [static, inherited] |
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 |
||
| ) | [static, inherited] |
- 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
epscan be specified to indicate a tolerance. For example,
becomes 
.
Definition at line 554 of file fe_abstract.C.
References libMesh::EDGE2, libMesh::EDGE3, libMesh::EDGE4, libMesh::HEX20, libMesh::HEX27, libMesh::HEX8, libMesh::INFHEX8, libMesh::INFPRISM6, libMesh::NODEELEM, libMesh::PRISM15, libMesh::PRISM18, libMesh::PRISM6, libMesh::PYRAMID13, libMesh::PYRAMID14, libMesh::PYRAMID5, libMesh::QUAD4, libMesh::QUAD8, libMesh::QUAD9, libMesh::Real, libMesh::TET10, libMesh::TET4, libMesh::TRI3, and libMesh::TRI6.
Referenced by libMesh::FE< Dim, T >::inverse_map().
{
libmesh_assert_greater_equal (eps, 0.);
const Real xi = p(0);
#if LIBMESH_DIM > 1
const Real eta = p(1);
#else
const Real eta = 0.;
#endif
#if LIBMESH_DIM > 2
const Real zeta = p(2);
#else
const Real zeta = 0.;
#endif
switch (t)
{
case NODEELEM:
{
return (!xi && !eta && !zeta);
}
case EDGE2:
case EDGE3:
case EDGE4:
{
// The reference 1D element is [-1,1].
if ((xi >= -1.-eps) &&
(xi <= 1.+eps))
return true;
return false;
}
case TRI3:
case TRI6:
{
// The reference triangle is isocoles
// and is bound by xi=0, eta=0, and xi+eta=1.
if ((xi >= 0.-eps) &&
(eta >= 0.-eps) &&
((xi + eta) <= 1.+eps))
return true;
return false;
}
case QUAD4:
case QUAD8:
case QUAD9:
{
// The reference quadrilateral element is [-1,1]^2.
if ((xi >= -1.-eps) &&
(xi <= 1.+eps) &&
(eta >= -1.-eps) &&
(eta <= 1.+eps))
return true;
return false;
}
case TET4:
case TET10:
{
// The reference tetrahedral is isocoles
// and is bound by xi=0, eta=0, zeta=0,
// and xi+eta+zeta=1.
if ((xi >= 0.-eps) &&
(eta >= 0.-eps) &&
(zeta >= 0.-eps) &&
((xi + eta + zeta) <= 1.+eps))
return true;
return false;
}
case HEX8:
case HEX20:
case HEX27:
{
/*
if ((xi >= -1.) &&
(xi <= 1.) &&
(eta >= -1.) &&
(eta <= 1.) &&
(zeta >= -1.) &&
(zeta <= 1.))
return true;
*/
// The reference hexahedral element is [-1,1]^3.
if ((xi >= -1.-eps) &&
(xi <= 1.+eps) &&
(eta >= -1.-eps) &&
(eta <= 1.+eps) &&
(zeta >= -1.-eps) &&
(zeta <= 1.+eps))
{
// libMesh::out << "Strange Point:\n";
// p.print();
return true;
}
return false;
}
case PRISM6:
case PRISM15:
case PRISM18:
{
// Figure this one out...
// inside the reference triange with zeta in [-1,1]
if ((xi >= 0.-eps) &&
(eta >= 0.-eps) &&
(zeta >= -1.-eps) &&
(zeta <= 1.+eps) &&
((xi + eta) <= 1.+eps))
return true;
return false;
}
case PYRAMID5:
case PYRAMID13:
case PYRAMID14:
{
// Check that the point is on the same side of all the faces
// by testing whether:
//
// n_i.(x - x_i) <= 0
//
// for each i, where:
// n_i is the outward normal of face i,
// x_i is a point on face i.
if ((-eta - 1. + zeta <= 0.+eps) &&
( xi - 1. + zeta <= 0.+eps) &&
( eta - 1. + zeta <= 0.+eps) &&
( -xi - 1. + zeta <= 0.+eps) &&
( zeta >= 0.-eps))
return true;
return false;
}
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
case INFHEX8:
{
// The reference infhex8 is a [-1,1]^3.
if ((xi >= -1.-eps) &&
(xi <= 1.+eps) &&
(eta >= -1.-eps) &&
(eta <= 1.+eps) &&
(zeta >= -1.-eps) &&
(zeta <= 1.+eps))
{
return true;
}
return false;
}
case INFPRISM6:
{
// inside the reference triange with zeta in [-1,1]
if ((xi >= 0.-eps) &&
(eta >= 0.-eps) &&
(zeta >= -1.-eps) &&
(zeta <= 1.+eps) &&
((xi + eta) <= 1.+eps))
{
return true;
}
return false;
}
#endif
default:
libmesh_error_msg("ERROR: Unknown element type " << t);
}
// If we get here then the point is _not_ in the
// reference element. Better return false.
return false;
}
| void libMesh::FEGenericBase< FEOutputType< T >::type >::print_d2phi | ( | std::ostream & | os | ) | const [virtual, inherited] |
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 [virtual, inherited] |
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 | ) | [static, inherited] |
Prints the reference information, by default to libMesh::out.
Definition at line 88 of file reference_counter.C.
References libMesh::ReferenceCounter::_enable_print_counter, and libMesh::ReferenceCounter::get_info().
Referenced by libMesh::LibMeshInit::~LibMeshInit().
{
if( _enable_print_counter ) out_stream << ReferenceCounter::get_info();
}
| void libMesh::FEAbstract::print_info | ( | std::ostream & | os | ) | const [inherited] |
Prints all the relevant information about the current element.
Definition at line 761 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<<().
{
os << "phi[i][j]: Shape function i at quadrature pt. j" << std::endl;
this->print_phi(os);
os << "dphi[i][j]: Shape function i's gradient at quadrature pt. j" << std::endl;
this->print_dphi(os);
os << "XYZ locations of the quadrature pts." << std::endl;
this->print_xyz(os);
os << "Values of JxW at the quadrature pts." << std::endl;
this->print_JxW(os);
}
| void libMesh::FEAbstract::print_JxW | ( | std::ostream & | os | ) | const [inherited] |
Prints the Jacobian times the weight for each quadrature point.
Definition at line 748 of file fe_abstract.C.
References libMesh::FEAbstract::_fe_map.
Referenced by libMesh::FEAbstract::print_info().
{
this->_fe_map->print_JxW(os);
}
| void libMesh::FEGenericBase< FEOutputType< T >::type >::print_phi | ( | std::ostream & | os | ) | const [virtual, inherited] |
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 755 of file fe_abstract.C.
References libMesh::FEAbstract::_fe_map.
Referenced by libMesh::FEAbstract::print_info().
{
this->_fe_map->print_xyz(os);
}
| virtual void libMesh::FE< Dim, T >::reinit | ( | const Elem * | elem, |
| const std::vector< Point > *const | pts = NULL, |
||
| const std::vector< Real > *const | weights = NULL |
||
| ) | [virtual, inherited] |
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 |
||
| ) | [virtual, inherited] |
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 | ||
| ) | [static, inherited] |
- Returns:
- the value of the
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 | ||
| ) | [static, inherited] |
- Returns:
- the value of the 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 | ||
| ) | [static, inherited] |
- Returns:
- the
derivative of the 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 | ||
| ) | [static, inherited] |
- Returns:
- the derivative of the 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 | ||
| ) | [static, inherited] |
- Returns:
- the second derivative of the 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, Hermite and Subdivision), Lagrange, Hierarchic, L2_Hierarchic, and Monomial are supported. All other element types return an error when asked for second derivatives.
On a p-refined element, o should be the total order of the element.
| static OutputShape libMesh::FE< Dim, T >::shape_second_deriv | ( | const Elem * | elem, |
| const Order | o, | ||
| const unsigned int | i, | ||
| const unsigned int | j, | ||
| const Point & | p | ||
| ) | [static, inherited] |
- Returns:
- the second derivative of the 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, Hermite and Subdivision), Lagrange, Hierarchic, L2_Hierarchic, and Monomial are supported. All other element types return an error when asked for second derivatives.
On a p-refined element, o should be the base order of the element.
| virtual bool libMesh::FE< Dim, T >::shapes_need_reinit | ( | ) | const [virtual, inherited] |
- Returns:
truewhen the shape functions (for thisFEFamily) depend on the particular element, and therefore needs to be re-initialized for each new element.falseotherwise.
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 | ||
| ) | [virtual, inherited] |
Computes the reference space quadrature points on the side of an element based on the side quadrature points.
Implements libMesh::FEAbstract.
Friends And Related Function Documentation
friend class InfFE [friend, inherited] |
make InfFE classes friends, so that these may access the private map, map_xyz methods
Reimplemented from libMesh::FEGenericBase< FEOutputType< T >::type >.
| std::ostream& operator<< | ( | std::ostream & | os, |
| const FEAbstract & | fe | ||
| ) | [friend, inherited] |
Same as above, but allows you to print to a stream.
Definition at line 777 of file fe_abstract.C.
{
fe.print_info(os);
return os;
}
Member Data Documentation
ReferenceCounter::Counts libMesh::ReferenceCounter::_counts [static, protected, inherited] |
Actually holds the data.
Definition at line 118 of file reference_counter.h.
Referenced by libMesh::ReferenceCounter::get_info(), libMesh::ReferenceCounter::increment_constructor_count(), and libMesh::ReferenceCounter::increment_destructor_count().
bool libMesh::ReferenceCounter::_enable_print_counter = true [static, protected, inherited] |
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().
UniquePtr<FEMap> libMesh::FEAbstract::_fe_map [protected, inherited] |
Definition at line 509 of file fe_abstract.h.
Referenced by libMesh::FEAbstract::get_curvatures(), libMesh::FEAbstract::get_d2xyzdeta2(), libMesh::FEAbstract::get_d2xyzdetadzeta(), libMesh::FEAbstract::get_d2xyzdxi2(), libMesh::FEAbstract::get_d2xyzdxideta(), libMesh::FEAbstract::get_d2xyzdxidzeta(), libMesh::FEAbstract::get_d2xyzdzeta2(), libMesh::FEAbstract::get_detadx(), libMesh::FEAbstract::get_detady(), libMesh::FEAbstract::get_detadz(), libMesh::FEAbstract::get_dxidx(), libMesh::FEAbstract::get_dxidy(), libMesh::FEAbstract::get_dxidz(), libMesh::FEAbstract::get_dxyzdeta(), libMesh::FEAbstract::get_dxyzdxi(), libMesh::FEAbstract::get_dxyzdzeta(), libMesh::FEAbstract::get_dzetadx(), libMesh::FEAbstract::get_dzetady(), libMesh::FEAbstract::get_dzetadz(), libMesh::FEAbstract::get_fe_map(), libMesh::FEAbstract::get_JxW(), libMesh::FEAbstract::get_normals(), libMesh::FEAbstract::get_tangents(), libMesh::FEAbstract::get_xyz(), libMesh::FESubdivision::init_shape_functions(), libMesh::FEAbstract::print_JxW(), and libMesh::FEAbstract::print_xyz().
UniquePtr<FETransformationBase<FEOutputType< T >::type > > libMesh::FEGenericBase< FEOutputType< T >::type >::_fe_trans [protected, inherited] |
Threads::spin_mutex libMesh::ReferenceCounter::_mutex [static, protected, inherited] |
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 [static, protected, inherited] |
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 [protected, inherited] |
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 [protected, inherited] |
bool libMesh::FEAbstract::calculate_curl_phi [mutable, protected, inherited] |
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_d2phi [mutable, protected, inherited] |
Should we calculate shape function hessians?
Definition at line 536 of file fe_abstract.h.
Referenced by libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phi(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phideta2(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidetadzeta(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidx2(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxdy(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxdz(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxi2(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxideta(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxidzeta(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidy2(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidydz(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidz2(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidzeta2(), and libMesh::FESubdivision::init_shape_functions().
bool libMesh::FEAbstract::calculate_div_phi [mutable, protected, inherited] |
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_dphi [mutable, protected, inherited] |
Should we calculate shape function gradients?
Definition at line 531 of file fe_abstract.h.
Referenced by libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphi(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidx(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidy(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidz(), and libMesh::FESubdivision::init_shape_functions().
bool libMesh::FEAbstract::calculate_dphiref [mutable, protected, inherited] |
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 [mutable, protected, inherited] |
Should we calculate shape functions?
Definition at line 526 of file fe_abstract.h.
Referenced by libMesh::FEGenericBase< FEOutputType< T >::type >::get_phi(), and libMesh::FESubdivision::init_shape_functions().
bool libMesh::FEAbstract::calculations_started [mutable, protected, inherited] |
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(), libMesh::FEGenericBase< FEOutputType< T >::type >::get_phi(), and libMesh::FESubdivision::init_shape_functions().
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::curl_phi [protected, inherited] |
std::vector<std::vector<OutputTensor> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phi [protected, inherited] |
Shape function second derivative values.
Definition at line 548 of file fe_base.h.
Referenced by libMesh::FESubdivision::init_shape_functions().
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phideta2 [protected, inherited] |
Shape function second derivatives in the eta direction.
Definition at line 568 of file fe_base.h.
Referenced by libMesh::FESubdivision::init_shape_functions().
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidetadzeta [protected, inherited] |
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidx2 [protected, inherited] |
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidxdy [protected, inherited] |
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidxdz [protected, inherited] |
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidxi2 [protected, inherited] |
Shape function second derivatives in the xi direction.
Definition at line 553 of file fe_base.h.
Referenced by libMesh::FESubdivision::init_shape_functions().
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidxideta [protected, inherited] |
Shape function second derivatives in the xi-eta direction.
Definition at line 558 of file fe_base.h.
Referenced by libMesh::FESubdivision::init_shape_functions().
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidxidzeta [protected, inherited] |
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidy2 [protected, inherited] |
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidydz [protected, inherited] |
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidz2 [protected, inherited] |
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidzeta2 [protected, inherited] |
const unsigned int libMesh::FEAbstract::dim [protected, inherited] |
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 [protected, inherited] |
std::vector<OutputGradient> libMesh::FEGenericBase< FEOutputType< T >::type >::dphase [protected, inherited] |
std::vector<std::vector<OutputGradient> > libMesh::FEGenericBase< FEOutputType< T >::type >::dphi [protected, inherited] |
Shape function derivative values.
Definition at line 500 of file fe_base.h.
Referenced by libMesh::FESubdivision::init_shape_functions().
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::dphideta [protected, inherited] |
Shape function derivatives in the eta direction.
Definition at line 520 of file fe_base.h.
Referenced by libMesh::FESubdivision::init_shape_functions().
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::dphidx [protected, inherited] |
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::dphidxi [protected, inherited] |
Shape function derivatives in the xi direction.
Definition at line 515 of file fe_base.h.
Referenced by libMesh::FESubdivision::init_shape_functions().
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::dphidy [protected, inherited] |
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::dphidz [protected, inherited] |
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::dphidzeta [protected, inherited] |
std::vector<RealGradient> libMesh::FEGenericBase< FEOutputType< T >::type >::dweight [protected, inherited] |
, over all quadrature points. ElemType libMesh::FEAbstract::elem_type [protected, inherited] |
The element type the current data structures are set up for.
Definition at line 564 of file fe_abstract.h.
Referenced by libMesh::FESubdivision::attach_quadrature_rule(), and libMesh::FEAbstract::get_type().
const FEType libMesh::FEAbstract::fe_type [protected, inherited] |
The finite element type for this object. Note that this should be constant for the object.
Definition at line 558 of file fe_abstract.h.
Referenced by libMesh::FEAbstract::compute_node_constraints(), libMesh::FEAbstract::compute_periodic_node_constraints(), libMesh::FEAbstract::get_family(), libMesh::FEAbstract::get_fe_type(), libMesh::FEAbstract::get_order(), libMesh::InfFE< Dim, T_radial, T_map >::InfFE(), and libMesh::FESubdivision::init_shape_functions().
unsigned int libMesh::FE< Dim, T >::last_edge [protected, inherited] |
ElemType libMesh::FE< Dim, T >::last_side [protected, inherited] |
std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::phi [protected, inherited] |
Shape function values.
Definition at line 495 of file fe_base.h.
Referenced by libMesh::FESubdivision::init_shape_functions().
QBase* libMesh::FEAbstract::qrule [protected, inherited] |
A pointer to the quadrature rule employed
Definition at line 575 of file fe_abstract.h.
Referenced by libMesh::FESubdivision::attach_quadrature_rule().
bool libMesh::FEAbstract::shapes_on_quadrature [protected, inherited] |
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 [protected, inherited] |
The documentation for this class was generated from the following file:
generated by
