libMesh
Public Types | Public Member Functions | Static Public Member Functions | Static Public Attributes | Protected Types | Protected Member Functions | Static Protected Member Functions | Protected Attributes | Static Protected Attributes | List of all members
libMesh::Pyramid5 Class Referencefinal


The Pyramid5 is an element in 3D composed of 5 nodes. More...

#include <cell_pyramid5.h>

Inheritance diagram for libMesh::Pyramid5:
[legend]

Public Types

enum  RefinementState {
  COARSEN = 0, DO_NOTHING, REFINE, JUST_REFINED,
  JUST_COARSENED, INACTIVE, COARSEN_INACTIVE, INVALID_REFINEMENTSTATE
}
 Enumeration of possible element refinement states. More...
 
typedef Elem *const * NeighborPtrIter
 Nested "classes" for use iterating over all neighbors of an element. More...
 
typedef const Elem *const * ConstNeighborPtrIter
 
typedef Predicates::multi_predicate Predicate
 Useful iterator typedefs. More...
 

Public Member Functions

 Pyramid5 (Elem *p=nullptr)
 Constructor. More...
 
 Pyramid5 (Pyramid5 &&)=delete
 
 Pyramid5 (const Pyramid5 &)=delete
 
Pyramid5operator= (const Pyramid5 &)=delete
 
Pyramid5operator= (Pyramid5 &&)=delete
 
virtual ~Pyramid5 ()=default
 
virtual ElemType type () const override
 
virtual unsigned int n_sub_elem () const override
 
virtual bool is_vertex (const unsigned int i) const override
 
virtual bool is_edge (const unsigned int i) const override
 
virtual bool is_face (const unsigned int i) const override
 
virtual bool is_node_on_side (const unsigned int n, const unsigned int s) const override
 
virtual std::vector< unsigned intnodes_on_side (const unsigned int s) const override
 
virtual std::vector< unsigned intnodes_on_edge (const unsigned int e) const override
 
virtual bool is_node_on_edge (const unsigned int n, const unsigned int e) const override
 
virtual bool has_affine_map () const override
 
virtual Order default_order () const override
 
virtual std::unique_ptr< Elembuild_side_ptr (const unsigned int i) override
 Builds a QUAD4 or TRI3 built coincident with face i. More...
 
virtual void build_side_ptr (std::unique_ptr< Elem > &elem, const unsigned int i) override
 Rebuilds a QUAD4 or TRI3 built coincident with face i. More...
 
virtual std::unique_ptr< Elembuild_edge_ptr (const unsigned int i) override
 Builds a EDGE2 built coincident with edge i. More...
 
virtual void build_edge_ptr (std::unique_ptr< Elem > &edge, const unsigned int i) override
 Rebuilds a EDGE2 coincident with edge i. More...
 
virtual void connectivity (const unsigned int sc, const IOPackage iop, std::vector< dof_id_type > &conn) const override
 
virtual Point true_centroid () const override
 We compute the centroid of the Pyramid by treating it as a degenerate Hex8 element. More...
 
virtual Real volume () const override
 Specialization for computing the volume of a pyramid. More...
 
virtual BoundingBox loose_bounding_box () const override
 Builds a bounding box out of the nodal positions. More...
 
virtual void permute (unsigned int perm_num) override final
 Permutes the element (by swapping node and neighbor pointers) according to the specified index. More...
 
virtual void flip (BoundaryInfo *) override final
 Flips the element (by swapping node and neighbor pointers) to have a mapping Jacobian of opposite sign. More...
 
ElemType side_type (const unsigned int s) const override final
 
virtual Point side_vertex_average_normal (const unsigned int s) const override final
 
virtual std::unique_ptr< Elembuild_side_ptr (const unsigned int i)=0
 
std::unique_ptr< const Elembuild_side_ptr (const unsigned int i) const
 
virtual std::unique_ptr< Elembuild_side_ptr (const unsigned int i, bool proxy)
 
std::unique_ptr< const Elembuild_side_ptr (const unsigned int i, bool proxy) const
 
virtual void build_side_ptr (std::unique_ptr< Elem > &side, const unsigned int i)=0
 Resets the loose element side, which may currently point to a different side than i or even a different element than this, to point to side i on this. More...
 
void build_side_ptr (std::unique_ptr< const Elem > &side, const unsigned int i) const
 
virtual Point master_point (const unsigned int i) const override
 
virtual unsigned int n_nodes () const override
 
virtual unsigned int n_sides () const override
 
virtual unsigned int n_vertices () const override
 
virtual unsigned int n_edges () const override
 
virtual unsigned int n_faces () const override
 
virtual unsigned int n_children () const override
 
virtual bool is_child_on_side (const unsigned int c, const unsigned int s) const override
 
virtual bool is_edge_on_side (const unsigned int e, const unsigned int s) const override
 
virtual dof_id_type key (const unsigned int s) const override
 
virtual dof_id_type key (const unsigned int s) const=0
 Don't hide Elem::key() defined in the base class. More...
 
virtual dof_id_type key () const
 Don't hide Elem::key() defined in the base class. More...
 
virtual dof_id_type key () const
 
virtual dof_id_type low_order_key (const unsigned int s) const override
 
virtual unsigned int local_side_node (unsigned int side, unsigned int side_node) const override
 
virtual unsigned int local_edge_node (unsigned int edge, unsigned int edge_node) const override
 
virtual std::unique_ptr< Elemside_ptr (const unsigned int i) override
 
virtual void side_ptr (std::unique_ptr< Elem > &side, const unsigned int i) override
 Rebuilds a primitive triangle or quad for face i. More...
 
std::unique_ptr< const Elemside_ptr (unsigned int i) const
 
void side_ptr (std::unique_ptr< const Elem > &side, const unsigned int i) const
 
virtual std::vector< unsigned intsides_on_edge (const unsigned int e) const override final
 
unsigned int local_singular_node (const Point &p, const Real tol=TOLERANCE *TOLERANCE) const override final
 
virtual bool is_singular_node (unsigned int node_idx) const override final
 
virtual unsigned int n_permutations () const override final
 One quad side, four orientations. More...
 
virtual bool is_flipped () const override final
 
virtual std::vector< unsigned intedges_adjacent_to_node (const unsigned int n) const override
 
virtual bool on_reference_element (const Point &p, const Real eps=TOLERANCE) const override final
 
virtual unsigned short dim () const override
 
virtual bool infinite () const override
 
const Pointpoint (const unsigned int i) const
 
Pointpoint (const unsigned int i)
 
dof_id_type node_id (const unsigned int i) const
 
unsigned int local_node (const dof_id_type i) const
 
unsigned int get_node_index (const Node *node_ptr) const
 
const Node *const * get_nodes () const
 
const Nodenode_ptr (const unsigned int i) const
 
Nodenode_ptr (const unsigned int i)
 
const Nodenode_ref (const unsigned int i) const
 
Nodenode_ref (const unsigned int i)
 
virtual Node *& set_node (const unsigned int i)
 
virtual void set_node (const unsigned int i, Node *node)
 Sets local Node i to refer to node. More...
 
SimpleRange< NodeRefIternode_ref_range ()
 Returns a range with all nodes of an element, usable in range-based for loops. More...
 
SimpleRange< ConstNodeRefIternode_ref_range () const
 
subdomain_id_type subdomain_id () const
 
subdomain_id_typesubdomain_id ()
 
virtual bool runtime_topology () const
 
const Elemreference_elem () const
 
bool operator== (const Elem &rhs) const
 
bool topologically_equal (const Elem &rhs) const
 
const Elemneighbor_ptr (unsigned int i) const
 
Elemneighbor_ptr (unsigned int i)
 
SimpleRange< NeighborPtrIterneighbor_ptr_range ()
 Returns a range with all neighbors of an element, usable in range-based for loops. More...
 
SimpleRange< ConstNeighborPtrIterneighbor_ptr_range () const
 
const Elemtopological_neighbor (const unsigned int i, const MeshBase &mesh, const PointLocatorBase &point_locator, const PeriodicBoundaries *pb) const
 
Elemtopological_neighbor (const unsigned int i, MeshBase &mesh, const PointLocatorBase &point_locator, const PeriodicBoundaries *pb)
 
bool has_topological_neighbor (const Elem *elem, const MeshBase &mesh, const PointLocatorBase &point_locator, const PeriodicBoundaries *pb) const
 
void set_neighbor (const unsigned int i, Elem *n)
 Assigns n as the \( i^{th} \) neighbor. More...
 
bool has_neighbor (const Elem *elem) const
 
Elemchild_neighbor (Elem *elem)
 
const Elemchild_neighbor (const Elem *elem) const
 
bool on_boundary () const
 
bool is_semilocal (const processor_id_type my_pid) const
 
unsigned int which_neighbor_am_i (const Elem *e) const
 This function tells you which neighbor e is. More...
 
unsigned int which_side_am_i (const Elem *e) const
 This function tells you which side the boundary element e is. More...
 
unsigned int which_node_am_i (unsigned int side, unsigned int side_node) const
 This function is deprecated, call local_side_node(side, side_node) instead. More...
 
bool contains_vertex_of (const Elem *e, bool mesh_connection=false) const
 
bool contains_edge_of (const Elem *e) const
 
void find_point_neighbors (const Point &p, std::set< const Elem *> &neighbor_set) const
 This function finds all active elements (including this one) which are in the same manifold as this element and which touch the current active element at the specified point, which should be a point in the current element. More...
 
void find_point_neighbors (std::set< const Elem *> &neighbor_set) const
 This function finds all active elements (including this one) in the same manifold as this element which touch this active element at any point. More...
 
void find_point_neighbors (std::set< const Elem *> &neighbor_set, const Elem *start_elem) const
 This function finds all active elements (including this one) in the same manifold as start_elem (which must be active and must touch this element) which touch this element at any point. More...
 
void find_point_neighbors (std::set< Elem *> &neighbor_set, Elem *start_elem)
 Non-const version of function above. More...
 
void find_edge_neighbors (const Point &p1, const Point &p2, std::set< const Elem *> &neighbor_set) const
 This function finds all active elements in the same manifold as this element which touch the current active element along the whole edge defined by the two points p1 and p2. More...
 
void find_edge_neighbors (std::set< const Elem *> &neighbor_set) const
 This function finds all active elements in the same manifold as this element which touch the current active element along any edge (more precisely, at at least two points). More...
 
void find_interior_neighbors (std::set< const Elem *> &neighbor_set) const
 This function finds all active elements (not including this one) in the parent manifold of this element whose intersection with this element has non-zero measure. More...
 
void find_interior_neighbors (std::set< Elem *> &neighbor_set)
 Non-const version of function above that fills up a vector of non-const Elem pointers instead. More...
 
void remove_links_to_me ()
 Resets this element's neighbors' appropriate neighbor pointers and its parent's and children's appropriate pointers to point to null instead of to this. More...
 
void make_links_to_me_remote ()
 Resets this element's neighbors' appropriate neighbor pointers and its parent's and children's appropriate pointers to point to the global remote_elem instead of this. More...
 
void make_links_to_me_local (unsigned int n, unsigned int neighbor_side)
 Resets the neighbor_side pointers of our nth neighbor (and its descendants, if appropriate) to point to this Elem instead of to the global remote_elem. More...
 
virtual bool is_remote () const
 
void write_connectivity (std::ostream &out, const IOPackage iop) const
 Writes the element connectivity for various IO packages to the passed ostream "out". More...
 
IntRange< unsigned short > node_index_range () const
 
virtual unsigned int n_nodes_in_child (unsigned int) const
 
IntRange< unsigned short > side_index_range () const
 
unsigned int n_neighbors () const
 
IntRange< unsigned short > edge_index_range () const
 
IntRange< unsigned short > face_index_range () const
 
virtual bool is_vertex_on_child (unsigned int, unsigned int n) const
 
virtual bool is_vertex_on_parent (unsigned int c, unsigned int n) const
 
bool is_internal (const unsigned int i) const
 
virtual unsigned int opposite_side (const unsigned int s) const
 
virtual unsigned int opposite_node (const unsigned int n, const unsigned int s) const
 
std::unique_ptr< const Elembuild_side_ptr (const unsigned int i) const
 
virtual std::unique_ptr< Elembuild_side_ptr (const unsigned int i, bool proxy)
 
std::unique_ptr< const Elembuild_side_ptr (const unsigned int i, bool proxy) const
 
void build_side_ptr (std::unique_ptr< const Elem > &side, const unsigned int i) const
 
std::unique_ptr< const Elembuild_edge_ptr (const unsigned int i) const
 
void build_edge_ptr (std::unique_ptr< const Elem > &edge, const unsigned int i) const
 
virtual Order supported_nodal_order () const
 
virtual Order default_side_order () const
 
virtual Point centroid () const
 Calls Elem::vertex_average() for backwards compatibility. More...
 
Point vertex_average () const
 
virtual Point quasicircumcenter () const
 
virtual Real hmin () const
 
virtual Real hmax () const
 
virtual Real quality (const ElemQuality q) const
 
virtual std::pair< Real, Realqual_bounds (const ElemQuality) const
 
virtual bool contains_point (const Point &p, Real tol=TOLERANCE) const
 
virtual bool close_to_point (const Point &p, Real tol) const
 
bool positive_edge_orientation (const unsigned int i) const
 
bool positive_face_orientation (const unsigned int i) const
 
void inherit_data_from (const Elem &src)
 A helper function for copying generic element data (mapping, subdomain, processor) from an element to a derived (child, side, edge) element. More...
 
virtual bool has_invertible_map (Real tol=TOLERANCE *TOLERANCE) const
 
virtual bool is_linear () const
 
void print_info (std::ostream &os=libMesh::out) const
 Prints relevant information about the element. More...
 
std::string get_info () const
 Prints relevant information about the element to a string. More...
 
bool active () const
 
bool ancestor () const
 
bool subactive () const
 
bool has_children () const
 
bool has_ancestor_children () const
 
bool is_ancestor_of (const Elem *descendant) const
 
const Elemparent () const
 
Elemparent ()
 
void set_parent (Elem *p)
 Sets the pointer to the element's parent. More...
 
const Elemtop_parent () const
 
const Eleminterior_parent () const
 
Eleminterior_parent ()
 
void set_interior_parent (Elem *p)
 Sets the pointer to the element's interior_parent. More...
 
Real length (const unsigned int n1, const unsigned int n2) const
 
virtual unsigned int n_second_order_adjacent_vertices (const unsigned int n) const
 
virtual unsigned short int second_order_adjacent_vertex (const unsigned int n, const unsigned int v) const
 
virtual std::pair< unsigned short int, unsigned short intsecond_order_child_vertex (const unsigned int n) const
 
unsigned int level () const
 
unsigned int p_level () const
 
ElemMappingType mapping_type () const
 
void set_mapping_type (const ElemMappingType type)
 Sets the value of the mapping type for the element. More...
 
unsigned char mapping_data () const
 
void set_mapping_data (const unsigned char data)
 Sets the value of the mapping data for the element. More...
 
const Elemraw_child_ptr (unsigned int i) const
 
const Elemchild_ptr (unsigned int i) const
 
Elemchild_ptr (unsigned int i)
 
SimpleRange< ChildRefIterchild_ref_range ()
 Returns a range with all children of a parent element, usable in range-based for loops. More...
 
SimpleRange< ConstChildRefIterchild_ref_range () const
 
unsigned int which_child_am_i (const Elem *e) const
 
virtual bool is_child_on_edge (const unsigned int c, const unsigned int e) const
 
void add_child (Elem *elem)
 Adds a child pointer to the array of children of this element. More...
 
void add_child (Elem *elem, unsigned int c)
 Adds a new child pointer to the specified index in the array of children of this element. More...
 
void replace_child (Elem *elem, unsigned int c)
 Replaces the child pointer at the specified index in the child array. More...
 
void family_tree (std::vector< const Elem *> &family, bool reset=true) const
 Fills the vector family with the children of this element, recursively. More...
 
void family_tree (std::vector< Elem *> &family, bool reset=true)
 Non-const version of function above; fills a vector of non-const pointers. More...
 
void total_family_tree (std::vector< const Elem *> &family, bool reset=true) const
 Same as the family_tree() member, but also adds any subactive descendants. More...
 
void total_family_tree (std::vector< Elem *> &family, bool reset=true)
 Non-const version of function above; fills a vector of non-const pointers. More...
 
void active_family_tree (std::vector< const Elem *> &active_family, bool reset=true) const
 Same as the family_tree() member, but only adds the active children. More...
 
void active_family_tree (std::vector< Elem *> &active_family, bool reset=true)
 Non-const version of function above; fills a vector of non-const pointers. More...
 
void family_tree_by_side (std::vector< const Elem *> &family, unsigned int side, bool reset=true) const
 Same as the family_tree() member, but only adds elements which are next to side. More...
 
void family_tree_by_side (std::vector< Elem *> &family, unsigned int side, bool reset=true)
 Non-const version of function above; fills a vector of non-const pointers. More...
 
void active_family_tree_by_side (std::vector< const Elem *> &family, unsigned int side, bool reset=true) const
 Same as the active_family_tree() member, but only adds elements which are next to side. More...
 
void active_family_tree_by_side (std::vector< Elem *> &family, unsigned int side, bool reset=true)
 Non-const version of function above; fills a vector of non-const pointers. More...
 
void family_tree_by_neighbor (std::vector< const Elem *> &family, const Elem *neighbor, bool reset=true) const
 Same as the family_tree() member, but only adds elements which are next to neighbor. More...
 
void family_tree_by_neighbor (std::vector< Elem *> &family, Elem *neighbor, bool reset=true)
 Non-const version of function above; fills a vector of non-const pointers. More...
 
void total_family_tree_by_neighbor (std::vector< const Elem *> &family, const Elem *neighbor, bool reset=true) const
 Same as the family_tree_by_neighbor() member, but also adds any subactive descendants. More...
 
void total_family_tree_by_neighbor (std::vector< Elem *> &family, Elem *neighbor, bool reset=true)
 Non-const version of function above; fills a vector of non-const pointers. More...
 
void family_tree_by_subneighbor (std::vector< const Elem *> &family, const Elem *neighbor, const Elem *subneighbor, bool reset=true) const
 Same as the family_tree() member, but only adds elements which are next to subneighbor. More...
 
void family_tree_by_subneighbor (std::vector< Elem *> &family, Elem *neighbor, Elem *subneighbor, bool reset=true)
 Non-const version of function above; fills a vector of non-const pointers. More...
 
void total_family_tree_by_subneighbor (std::vector< const Elem *> &family, const Elem *neighbor, const Elem *subneighbor, bool reset=true) const
 Same as the family_tree_by_subneighbor() member, but also adds any subactive descendants. More...
 
void total_family_tree_by_subneighbor (std::vector< Elem *> &family, Elem *neighbor, Elem *subneighbor, bool reset=true)
 Non-const version of function above; fills a vector of non-const pointers. More...
 
void active_family_tree_by_neighbor (std::vector< const Elem *> &family, const Elem *neighbor, bool reset=true) const
 Same as the active_family_tree() member, but only adds elements which are next to neighbor. More...
 
void active_family_tree_by_neighbor (std::vector< Elem *> &family, Elem *neighbor, bool reset=true)
 Non-const version of function above; fills a vector of non-const pointers. More...
 
void active_family_tree_by_topological_neighbor (std::vector< const Elem *> &family, const Elem *neighbor, const MeshBase &mesh, const PointLocatorBase &point_locator, const PeriodicBoundaries *pb, bool reset=true) const
 Same as the active_family_tree_by_neighbor() member, but the neighbor here may be a topological (e.g. More...
 
void active_family_tree_by_topological_neighbor (std::vector< Elem *> &family, Elem *neighbor, const MeshBase &mesh, const PointLocatorBase &point_locator, const PeriodicBoundaries *pb, bool reset=true)
 Non-const version of function above; fills a vector of non-const pointers. More...
 
RefinementState refinement_flag () const
 
void set_refinement_flag (const RefinementState rflag)
 Sets the value of the refinement flag for the element. More...
 
RefinementState p_refinement_flag () const
 
void set_p_refinement_flag (const RefinementState pflag)
 Sets the value of the p-refinement flag for the element. More...
 
unsigned int max_descendant_p_level () const
 
unsigned int min_p_level_by_neighbor (const Elem *neighbor, unsigned int current_min) const
 
unsigned int min_new_p_level_by_neighbor (const Elem *neighbor, unsigned int current_min) const
 
void set_p_level (const unsigned int p)
 Sets the value of the p-refinement level for the element. More...
 
void hack_p_level (const unsigned int p)
 Sets the value of the p-refinement level for the element without altering the p-level of its ancestors. More...
 
void hack_p_level_and_refinement_flag (const unsigned int p, RefinementState pflag)
 Sets the value of the p-refinement level for the element without altering the p-level of its ancestors; also sets the p_refinement_flag, simultaneously so that they can be safely checked for mutual consistency. More...
 
virtual void refine (MeshRefinement &mesh_refinement)
 Refine the element. More...
 
void coarsen ()
 Coarsen the element. More...
 
void contract ()
 Contract an active element, i.e. More...
 
void libmesh_assert_valid_neighbors () const
 Checks for consistent neighbor links on this element. More...
 
void libmesh_assert_valid_node_pointers () const
 Checks for a valid id and pointers to nodes with valid ids on this element. More...
 
virtual unsigned int center_node_on_side (const unsigned short side) const
 
side_iterator boundary_sides_begin ()
 Iterator accessor functions. More...
 
side_iterator boundary_sides_end ()
 
virtual bool is_mid_infinite_edge_node (const unsigned int) const
 
virtual Point origin () const
 
virtual std::unique_ptr< Elemdisconnected_clone () const
 
void orient (BoundaryInfo *boundary_info)
 Flips the element (by swapping node and neighbor pointers) to have a mapping Jacobian of opposite sign, iff we find a negative orientation. More...
 
virtual unsigned int as_parent_node (unsigned int c, unsigned int n) const
 
virtual const std::vector< std::pair< unsigned char, unsigned char > > & parent_bracketing_nodes (unsigned int c, unsigned int n) const
 
virtual const std::vector< std::pair< dof_id_type, dof_id_type > > bracketing_nodes (unsigned int c, unsigned int n) const
 
virtual unsigned int embedding_matrix_version () const
 
void nullify_neighbors ()
 Replaces this element with nullptr for all of its neighbors. More...
 
DofObjectget_old_dof_object ()
 Pointer accessor for previously public old_dof_object. More...
 
const DofObjectget_old_dof_object () const
 
DofObjectget_old_dof_object_ref ()
 As above, but do not use in situations where the old_dof_object may be nullptr, since this function asserts that the old_dof_object is valid before returning a reference to it. More...
 
const DofObjectget_old_dof_object_ref () const
 
void clear_old_dof_object ()
 Sets the old_dof_object to nullptr. More...
 
void set_old_dof_object ()
 Sets the old_dof_object to a copy of this. More...
 
void clear_dofs ()
 Clear the DofMap data structures holding degree of freedom data. More...
 
void invalidate_dofs (const unsigned int sys_num=libMesh::invalid_uint)
 Sets all degree of freedom numbers to invalid_id. More...
 
void invalidate_id ()
 Sets the id to invalid_id. More...
 
void invalidate_processor_id ()
 Sets the processor id to invalid_processor_id. More...
 
void invalidate ()
 Invalidates all the indices for this DofObject. More...
 
unsigned int n_dofs (const unsigned int s, const unsigned int var=libMesh::invalid_uint) const
 
dof_id_type id () const
 
dof_id_typeset_id ()
 
void set_id (const dof_id_type dofid)
 Sets the id for this DofObject. More...
 
unique_id_type unique_id () const
 
unique_id_typeset_unique_id ()
 
void set_unique_id (unique_id_type new_id)
 Sets the unique_id for this DofObject. More...
 
bool valid_id () const
 
bool valid_unique_id () const
 
processor_id_type processor_id () const
 
processor_id_typeprocessor_id ()
 
void processor_id (const processor_id_type pid)
 Sets the processor_id for this DofObject. More...
 
bool valid_processor_id () const
 
unsigned int n_systems () const
 
unsigned int n_pseudo_systems () const
 
void set_n_systems (const unsigned int s)
 Sets the number of systems for this DofObject. More...
 
void set_extra_integer (const unsigned int index, const dof_id_type value)
 Sets the value on this object of the extra integer associated with index, which should have been obtained via a call to MeshBase::add_elem_integer or MeshBase::add_node_integer. More...
 
dof_id_type get_extra_integer (const unsigned int index) const
 Gets the value on this object of the extra integer associated with index, which should have been obtained via a call to MeshBase::add_elem_integer or MeshBase::add_node_integer. More...
 
template<typename T >
void set_extra_datum (const unsigned int index, const T value)
 Sets the value on this object of the extra datum associated with index, which should have been obtained via a call to MeshBase::add_elem_datum or MeshBase::add_node_datum using the same type T. More...
 
template<typename T >
get_extra_datum (const unsigned int index) const
 Gets the value on this object of the extra datum associated with index, which should have been obtained via a call to MeshBase::add_elem_datum or MeshBase::add_node_datum using the same type T. More...
 
void add_system ()
 Adds an additional system to the DofObject. More...
 
unsigned int n_var_groups (const unsigned int s) const
 
unsigned int n_vars (const unsigned int s, const unsigned int vg) const
 
unsigned int n_vars (const unsigned int s) const
 
void set_n_vars_per_group (const unsigned int s, const std::vector< unsigned int > &nvpg)
 Sets number of variables in each group associated with system s for this DofObject. More...
 
unsigned int n_comp (const unsigned int s, const unsigned int var) const
 
unsigned int n_comp_group (const unsigned int s, const unsigned int vg) const
 
void set_n_comp (const unsigned int s, const unsigned int var, const unsigned int ncomp)
 Sets the number of components for Variable var of system s associated with this DofObject. More...
 
void set_n_comp_group (const unsigned int s, const unsigned int vg, const unsigned int ncomp)
 Sets the number of components for VariableGroup vg of system s associated with this DofObject. More...
 
dof_id_type dof_number (const unsigned int s, const unsigned int var, const unsigned int comp) const
 
dof_id_type dof_number (const unsigned int s, const unsigned int vg, const unsigned int vig, const unsigned int comp, const unsigned int n_comp) const
 
std::pair< unsigned int, unsigned intvar_to_vg_and_offset (const unsigned int s, const unsigned int var) const
 
void set_dof_number (const unsigned int s, const unsigned int var, const unsigned int comp, const dof_id_type dn)
 Sets the global degree of freedom number for variable var, component comp for system s associated with this DofObject. More...
 
bool has_dofs (const unsigned int s=libMesh::invalid_uint) const
 
void set_vg_dof_base (const unsigned int s, const unsigned int vg, const dof_id_type db)
 VariableGroup DoF indices are indexed as id = base + var_in_vg*ncomp + comp This method allows for direct access to the base. More...
 
dof_id_type vg_dof_base (const unsigned int s, const unsigned int vg) const
 VariableGroup DoF indices are indexed as id = base + var_in_vg*ncomp + comp This method allows for direct access to the base. More...
 
void add_extra_integers (const unsigned int n_integers)
 Assigns a set of extra integers to this DofObject. More...
 
void add_extra_integers (const unsigned int n_integers, const std::vector< dof_id_type > &default_values)
 Assigns a set of extra integers to this DofObject. More...
 
unsigned int n_extra_integers () const
 Returns how many extra integers are associated to the DofObject. More...
 
bool has_extra_integers () const
 Returns whether extra integers are associated to the DofObject. More...
 
unsigned int packed_indexing_size () const
 If we pack our indices into an buffer for communications, how many ints do we need? More...
 
void unpack_indexing (std::vector< largest_id_type >::const_iterator begin)
 A method for creating our index buffer from packed data - basically with our current implementation we investigate the size term and then copy. More...
 
void pack_indexing (std::back_insert_iterator< std::vector< largest_id_type >> target) const
 A method for creating packed data from our index buffer - basically a copy with prepended size with our current implementation. More...
 
void debug_buffer () const
 Print our buffer for debugging. More...
 
void print_dof_info () const
 Print out info for debugging. More...
 
void set_buffer (const std::vector< dof_id_type > &buf)
 

Static Public Member Functions

static constexpr bool infinite ()
 
static void print_info (std::ostream &out_stream=libMesh::out)
 Prints the reference information, by default to libMesh::out. More...
 
static void print_info (std::ostream &out_stream=libMesh::out)
 Prints the reference information, by default to libMesh::out. More...
 
static std::string get_info ()
 Gets a string containing the reference information. More...
 
static std::string get_info ()
 Gets a string containing the reference information. More...
 
static ElemType second_order_equivalent_type (const ElemType et, const bool full_ordered=true)
 
static ElemType first_order_equivalent_type (const ElemType et)
 
static ElemType complete_order_equivalent_type (const ElemType et)
 
static std::unique_ptr< Elembuild (const ElemType type, Elem *p=nullptr)
 
static std::unique_ptr< Elembuild_with_id (const ElemType type, dof_id_type id)
 Calls the build() method above with a nullptr parent, and additionally sets the newly-created Elem's id. More...
 
static unsigned int n_objects ()
 Prints the number of outstanding (created, but not yet destroyed) objects. More...
 
static unsigned int n_objects ()
 Prints the number of outstanding (created, but not yet destroyed) objects. More...
 
static void enable_print_counter_info ()
 Methods to enable/disable the reference counter output from print_info() More...
 
static void enable_print_counter_info ()
 Methods to enable/disable the reference counter output from print_info() More...
 
static void disable_print_counter_info ()
 
static void disable_print_counter_info ()
 
static unsigned int unpackable_indexing_size (std::vector< largest_id_type >::const_iterator begin)
 If we have indices packed into an buffer for communications, how much of that buffer applies to this dof object? More...
 

Static Public Attributes

static const int num_nodes = 5
 Geometric constants for Pyramid5. More...
 
static const int nodes_per_side = 4
 
static const int nodes_per_edge = 2
 
static const unsigned int side_nodes_map [num_sides][nodes_per_side]
 This maps the \( j^{th} \) node of the \( i^{th} \) side to element node numbers. More...
 
static const unsigned int edge_nodes_map [num_edges][nodes_per_edge]
 This maps the \( j^{th} \) node of the \( i^{th} \) edge to element node numbers. More...
 
static const int num_sides = 5
 Geometric constants for all Pyramids. More...
 
static const int num_edges = 8
 
static const int num_children = 0
 
static const unsigned int edge_sides_map [8][2]
 This maps each edge to the sides that contain said edge. More...
 
static constexpr subdomain_id_type invalid_subdomain_id = std::numeric_limits<subdomain_id_type>::max()
 A static integral constant representing an invalid subdomain id. More...
 
static const unsigned int type_to_dim_map [INVALID_ELEM]
 This array maps the integer representation of the ElemType enum to the geometric dimension of the element. More...
 
static const unsigned int type_to_n_nodes_map [INVALID_ELEM]
 This array maps the integer representation of the ElemType enum to the number of nodes in the element. More...
 
static const unsigned int max_n_nodes = 27
 The maximum number of nodes any element can contain. More...
 
static const unsigned int type_to_n_sides_map [INVALID_ELEM]
 This array maps the integer representation of the ElemType enum to the number of sides on the element. More...
 
static const unsigned int type_to_n_edges_map [INVALID_ELEM]
 This array maps the integer representation of the ElemType enum to the number of edges on the element. More...
 
static const Order type_to_default_order_map [INVALID_ELEM]
 This array maps the integer representation of the ElemType enum to the default approximation order of elements of that type. More...
 
static constexpr dof_id_type invalid_id = static_cast<dof_id_type>(-1)
 An invalid id to distinguish an uninitialized DofObject. More...
 
static constexpr unique_id_type invalid_unique_id = static_cast<unique_id_type>(-1)
 An invalid unique_id to distinguish an uninitialized DofObject. More...
 
static constexpr processor_id_type invalid_processor_id = static_cast<processor_id_type>(-1)
 An invalid processor_id to distinguish DoFs that have not been assigned to a processor. More...
 

Protected Types

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

Protected Member Functions

virtual Real embedding_matrix (const unsigned int, const unsigned int, const unsigned int) const override
 Matrix used to create the elements children. More...
 
unsigned int side_children_matrix (const unsigned int, const unsigned int) const
 Matrix that allows children to inherit boundary conditions. More...
 
void swap2nodes (unsigned int n1, unsigned int n2)
 Swaps two node_ptrs. More...
 
void swap2neighbors (unsigned int n1, unsigned int n2)
 Swaps two neighbor_ptrs. More...
 
void swap2boundarysides (unsigned short s1, unsigned short s2, BoundaryInfo *boundary_info) const
 Swaps two sides in boundary_info, if it is non-null. More...
 
void swap2boundaryedges (unsigned short e1, unsigned short e2, BoundaryInfo *boundary_info) const
 Swaps two edges in boundary_info, if it is non-null. More...
 
void swap3nodes (unsigned int n1, unsigned int n2, unsigned int n3)
 Swaps three node_ptrs, "rotating" them. More...
 
void swap3neighbors (unsigned int n1, unsigned int n2, unsigned int n3)
 Swaps three neighbor_ptrs, "rotating" them. More...
 
void swap4nodes (unsigned int n1, unsigned int n2, unsigned int n3, unsigned int n4)
 Swaps four node_ptrs, "rotating" them. More...
 
void swap4neighbors (unsigned int n1, unsigned int n2, unsigned int n3, unsigned int n4)
 Swaps four neighbor_ptrs, "rotating" them. More...
 
template<typename Sideclass , typename Subclass >
std::unique_ptr< Elemsimple_build_side_ptr (const unsigned int i)
 An implementation for simple (all sides equal) elements. More...
 
template<typename Subclass >
void simple_build_side_ptr (std::unique_ptr< Elem > &side, const unsigned int i, ElemType sidetype)
 An implementation for simple (all sides equal) elements. More...
 
template<typename Subclass , typename Mapclass >
void simple_side_ptr (std::unique_ptr< Elem > &side, const unsigned int i, ElemType sidetype)
 An implementation for simple (all sides equal) elements. More...
 
template<typename Edgeclass , typename Subclass >
std::unique_ptr< Elemsimple_build_edge_ptr (const unsigned int i)
 An implementation for simple (all edges equal) elements. More...
 
template<typename Subclass >
void simple_build_edge_ptr (std::unique_ptr< Elem > &edge, const unsigned int i, ElemType edgetype)
 An implementation for simple (all edges equal) elements. More...
 
virtual std::vector< std::vector< std::vector< std::vector< std::pair< unsigned char, unsigned char > > > > > & _get_bracketing_node_cache () const
 Elem subclasses which don't do their own bracketing node calculations will need to supply a static cache, since the default calculation is slow. More...
 
virtual std::vector< std::vector< std::vector< signed char > > > & _get_parent_indices_cache () const
 Elem subclasses which don't do their own child-to-parent node calculations will need to supply a static cache, since the default calculation is slow. More...
 
void increment_constructor_count (const std::string &name) noexcept
 Increments the construction counter. More...
 
void increment_constructor_count (const std::string &name) noexcept
 Increments the construction counter. More...
 
void increment_destructor_count (const std::string &name) noexcept
 Increments the destruction counter. More...
 
void increment_destructor_count (const std::string &name) noexcept
 Increments the destruction counter. More...
 

Static Protected Member Functions

static dof_id_type compute_key (dof_id_type n0)
 
static dof_id_type compute_key (dof_id_type n0, dof_id_type n1)
 
static dof_id_type compute_key (dof_id_type n0, dof_id_type n1, dof_id_type n2)
 
static dof_id_type compute_key (dof_id_type n0, dof_id_type n1, dof_id_type n2, dof_id_type n3)
 

Protected Attributes

Node_nodelinks_data [num_nodes]
 Data for links to nodes. More...
 
 LIBMESH_ENABLE_TOPOLOGY_CACHES
 
Elem_elemlinks_data [6+(LIBMESH_DIM >3)]
 Data for links to parent/neighbor/interior_parent elements. More...
 
Node ** _nodes
 Pointers to the nodes we are connected to. More...
 
Elem ** _elemlinks
 Pointers to this element's parent and neighbors, and for lower-dimensional elements' interior_parent. More...
 
std::unique_ptr< Elem *[]> _children
 unique_ptr to array of this element's children. More...
 
subdomain_id_type _sbd_id
 The subdomain to which this element belongs. More...
 
unsigned char _rflag
 h refinement flag. More...
 
unsigned char _pflag
 p refinement flag. More...
 
unsigned char _p_level
 p refinement level - the difference between the polynomial degree on this element and the minimum polynomial degree on the mesh. More...
 
unsigned char _map_type
 Mapping function type; currently either 0 (LAGRANGE) or 1 (RATIONAL_BERNSTEIN). More...
 
unsigned char _map_data
 Mapping function data; currently used when needed to store the RATIONAL_BERNSTEIN nodal weight data index. More...
 
std::unique_ptr< DofObjectold_dof_object
 This object on the last mesh. More...
 

Static Protected Attributes

static const Real _master_points [14][3]
 Master element node locations. More...
 
static const unsigned int adjacent_edges_map [5][4]
 This maps the \( j^{th} \) node to the 3 or 4 edge ids adjacent to the node. More...
 
static constexpr Real affine_tol = TOLERANCE*TOLERANCE
 Default tolerance to use in has_affine_map(). More...
 
static Counts _counts
 Actually holds the data. More...
 
static Counts _counts
 Actually holds the data. More...
 
static Threads::atomic< unsigned int_n_objects
 The number of objects. More...
 
static Threads::atomic< unsigned int_n_objects
 The number of objects. More...
 
static Threads::spin_mutex _mutex
 Mutual exclusion object to enable thread-safe reference counting. More...
 
static Threads::spin_mutex _mutex
 Mutual exclusion object to enable thread-safe reference counting. More...
 
static bool _enable_print_counter = true
 Flag to control whether reference count information is printed when print_info is called. More...
 
static bool _enable_print_counter = true
 Flag to control whether reference count information is printed when print_info is called. More...
 

Detailed Description


The Pyramid5 is an element in 3D composed of 5 nodes.

It is numbered with a counter-clockwise base like this:

*   PYRAMID5:
*             o 4
*           //|\
*          // | \          zeta
*         //  |  \          ^   eta (into page)
*      3 o/...|...o 2       | /
*       ./    |  /          |/
*      ./     | /           o---> xi
*     ./      |/
*    o--------o
*    0        1
* 

(xi, eta, zeta): { zeta-1 <= xi <= 1-zeta { zeta-1 <= eta <= 1-zeta { 0 <= zeta <= 1 are the reference element coordinates associated with the given numbering.

Author
Benjamin S. Kirk
Date
2002 A 3D pyramid element with 5 nodes.

Definition at line 57 of file cell_pyramid5.h.

Member Typedef Documentation

◆ ConstNeighborPtrIter

typedef const Elem* const* libMesh::Elem::ConstNeighborPtrIter
inherited

Definition at line 329 of file elem.h.

◆ Counts [1/2]

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

Data structure to log the information.

The log is identified by the class name.

Definition at line 119 of file reference_counter.h.

◆ Counts [2/2]

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

Data structure to log the information.

The log is identified by the class name.

Definition at line 119 of file reference_counter.h.

◆ NeighborPtrIter

typedef Elem* const* libMesh::Elem::NeighborPtrIter
inherited

Nested "classes" for use iterating over all neighbors of an element.

Definition at line 328 of file elem.h.

◆ Predicate

Useful iterator typedefs.

Definition at line 1861 of file elem.h.

Member Enumeration Documentation

◆ RefinementState

Enumeration of possible element refinement states.

Enumerator
COARSEN 
DO_NOTHING 
REFINE 
JUST_REFINED 
JUST_COARSENED 
INACTIVE 
COARSEN_INACTIVE 
INVALID_REFINEMENTSTATE 

Definition at line 1453 of file elem.h.

Constructor & Destructor Documentation

◆ Pyramid5() [1/3]

libMesh::Pyramid5::Pyramid5 ( Elem p = nullptr)
inlineexplicit

Constructor.

By default this element has no parent.

Definition at line 65 of file cell_pyramid5.h.

65  :
67  {}
Node * _nodelinks_data[num_nodes]
Data for links to nodes.
static const int num_nodes
Geometric constants for Pyramid5.
Pyramid(const unsigned int nn, Elem *p, Node **nodelinkdata)
Default pyramid, one quad face, four triangular faces, takes number of nodes and parent.
Definition: cell_pyramid.h:48

◆ Pyramid5() [2/3]

libMesh::Pyramid5::Pyramid5 ( Pyramid5 &&  )
delete

◆ Pyramid5() [3/3]

libMesh::Pyramid5::Pyramid5 ( const Pyramid5 )
delete

◆ ~Pyramid5()

virtual libMesh::Pyramid5::~Pyramid5 ( )
virtualdefault

Member Function Documentation

◆ _get_bracketing_node_cache()

virtual std::vector<std::vector<std::vector<std::vector<std::pair<unsigned char, unsigned char> > > > >& libMesh::Elem::_get_bracketing_node_cache ( ) const
inlineprotectedvirtualinherited

Elem subclasses which don't do their own bracketing node calculations will need to supply a static cache, since the default calculation is slow.

Definition at line 2210 of file elem.h.

Referenced by libMesh::Elem::parent_bracketing_nodes().

2211  {
2212  static std::vector<std::vector<std::vector<std::vector<std::pair<unsigned char, unsigned char>>>>> c;
2213  libmesh_error();
2214  return c;
2215  }

◆ _get_parent_indices_cache()

virtual std::vector<std::vector<std::vector<signed char> > >& libMesh::Elem::_get_parent_indices_cache ( ) const
inlineprotectedvirtualinherited

Elem subclasses which don't do their own child-to-parent node calculations will need to supply a static cache, since the default calculation is slow.

Definition at line 2224 of file elem.h.

Referenced by libMesh::Elem::as_parent_node().

2225  {
2226  static std::vector<std::vector<std::vector<signed char>>> c;
2227  libmesh_error();
2228  return c;
2229  }

◆ active()

bool libMesh::Elem::active ( ) const
inlineinherited
Returns
true if the element is active (i.e. has no active descendants) or AMR is disabled, false otherwise.
Note
It suffices to check the first child only.

Definition at line 2942 of file elem.h.

References libMesh::Elem::COARSEN_INACTIVE, libMesh::Elem::INACTIVE, and libMesh::Elem::refinement_flag().

Referenced by libMesh::DofMap::_dof_indices(), libMesh::DofMap::_node_dof_indices(), libMesh::HPCoarsenTest::add_projection(), libMesh::Elem::ancestor(), assemble_ellipticdg(), libMesh::Patch::build_around_element(), libMesh::Elem::coarsen(), compute_jacobian(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), libMesh::FEAbstract::compute_periodic_node_constraints(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_proj_constraints(), compute_residual(), libMesh::Elem::contract(), libMesh::DofMap::dof_indices(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::find_dofs_to_send(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::Elem::find_point_neighbors(), libMesh::ReplicatedMesh::get_disconnected_subdomains(), libMesh::Elem::get_info(), libMesh::ErrorVector::is_active_elem(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_flags(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_p_levels(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::Elem::make_links_to_me_local(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::Elem::max_descendant_p_level(), libMesh::DofMap::merge_ghost_functor_outputs(), libMesh::Elem::min_new_p_level_by_neighbor(), libMesh::Elem::min_p_level_by_neighbor(), libMesh::PointLocatorTree::operator()(), libMesh::EquationSystems::redundant_added_side(), libMesh::Elem::refine(), libMesh::Elem::subactive(), libMesh::Parallel::sync_element_data_by_parent_id(), libMesh::MeshRefinement::test_level_one(), EquationSystemsTest::testRefineThenReinitPreserveFlags(), and libMesh::BoundaryInfo::transfer_boundary_ids_from_children().

2943 {
2944 #ifdef LIBMESH_ENABLE_AMR
2945  if ((this->refinement_flag() == INACTIVE) ||
2946  (this->refinement_flag() == COARSEN_INACTIVE))
2947  return false;
2948  else
2949  return true;
2950 #else
2951  return true;
2952 #endif
2953 }
RefinementState refinement_flag() const
Definition: elem.h:3211

◆ active_family_tree() [1/2]

void libMesh::Elem::active_family_tree ( std::vector< const Elem *> &  active_family,
bool  reset = true 
) const
inherited

Same as the family_tree() member, but only adds the active children.

Can be thought of as removing all the inactive elements from the vector created by family_tree, but is implemented more efficiently.

Definition at line 2131 of file elem.C.

References libMesh::ElemInternal::active_family_tree().

Referenced by libMesh::MeshCommunication::delete_remote_elements(), libMesh::DofMap::merge_ghost_functor_outputs(), and libMesh::SiblingCoupling::operator()().

2133 {
2134  ElemInternal::active_family_tree(this, active_family, reset);
2135 }
void active_family_tree(T elem, std::vector< T > &active_family, bool reset=true)
Definition: elem_internal.h:90

◆ active_family_tree() [2/2]

void libMesh::Elem::active_family_tree ( std::vector< Elem *> &  active_family,
bool  reset = true 
)
inherited

Non-const version of function above; fills a vector of non-const pointers.

Definition at line 2139 of file elem.C.

References libMesh::ElemInternal::active_family_tree().

2141 {
2142  ElemInternal::active_family_tree(this, active_family, reset);
2143 }
void active_family_tree(T elem, std::vector< T > &active_family, bool reset=true)
Definition: elem_internal.h:90

◆ active_family_tree_by_neighbor() [1/2]

void libMesh::Elem::active_family_tree_by_neighbor ( std::vector< const Elem *> &  family,
const Elem neighbor,
bool  reset = true 
) const
inherited

Same as the active_family_tree() member, but only adds elements which are next to neighbor.

Definition at line 2259 of file elem.C.

References libMesh::ElemInternal::active_family_tree_by_neighbor().

Referenced by libMesh::DefaultCoupling::operator()().

2262 {
2263  ElemInternal::active_family_tree_by_neighbor(this, family, neighbor, reset);
2264 }
void active_family_tree_by_neighbor(T elem, std::vector< T > &family, T neighbor_in, bool reset=true)

◆ active_family_tree_by_neighbor() [2/2]

void libMesh::Elem::active_family_tree_by_neighbor ( std::vector< Elem *> &  family,
Elem neighbor,
bool  reset = true 
)
inherited

Non-const version of function above; fills a vector of non-const pointers.

Definition at line 2268 of file elem.C.

References libMesh::ElemInternal::active_family_tree_by_neighbor().

2271 {
2272  ElemInternal::active_family_tree_by_neighbor(this, family, neighbor, reset);
2273 }
void active_family_tree_by_neighbor(T elem, std::vector< T > &family, T neighbor_in, bool reset=true)

◆ active_family_tree_by_side() [1/2]

void libMesh::Elem::active_family_tree_by_side ( std::vector< const Elem *> &  family,
unsigned int  side,
bool  reset = true 
) const
inherited

Same as the active_family_tree() member, but only adds elements which are next to side.

Definition at line 2165 of file elem.C.

References libMesh::ElemInternal::active_family_tree_by_side().

Referenced by libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::Nemesis_IO_Helper::write_sidesets(), and libMesh::ExodusII_IO_Helper::write_sidesets().

2168 {
2169  ElemInternal::active_family_tree_by_side(this, family, side, reset);
2170 }
void active_family_tree_by_side(T elem, std::vector< T > &family, unsigned int side, bool reset=true)

◆ active_family_tree_by_side() [2/2]

void libMesh::Elem::active_family_tree_by_side ( std::vector< Elem *> &  family,
unsigned int  side,
bool  reset = true 
)
inherited

Non-const version of function above; fills a vector of non-const pointers.

Definition at line 2174 of file elem.C.

References libMesh::ElemInternal::active_family_tree_by_side().

2177 {
2178  ElemInternal::active_family_tree_by_side(this, family, side, reset);
2179 }
void active_family_tree_by_side(T elem, std::vector< T > &family, unsigned int side, bool reset=true)

◆ active_family_tree_by_topological_neighbor() [1/2]

void libMesh::Elem::active_family_tree_by_topological_neighbor ( std::vector< const Elem *> &  family,
const Elem neighbor,
const MeshBase mesh,
const PointLocatorBase point_locator,
const PeriodicBoundaries pb,
bool  reset = true 
) const
inherited

Same as the active_family_tree_by_neighbor() member, but the neighbor here may be a topological (e.g.

periodic boundary condition) neighbor, not just a local neighbor.

Definition at line 2277 of file elem.C.

References libMesh::ElemInternal::active_family_tree_by_topological_neighbor(), and mesh.

Referenced by libMesh::GhostPointNeighbors::operator()(), and libMesh::DefaultCoupling::operator()().

2283 {
2285  mesh, point_locator, pb,
2286  reset);
2287 }
MeshBase & mesh
void active_family_tree_by_topological_neighbor(T elem, std::vector< T > &family, T neighbor_in, const MeshBase &mesh, const PointLocatorBase &point_locator, const PeriodicBoundaries *pb, bool reset=true)

◆ active_family_tree_by_topological_neighbor() [2/2]

void libMesh::Elem::active_family_tree_by_topological_neighbor ( std::vector< Elem *> &  family,
Elem neighbor,
const MeshBase mesh,
const PointLocatorBase point_locator,
const PeriodicBoundaries pb,
bool  reset = true 
)
inherited

Non-const version of function above; fills a vector of non-const pointers.

Definition at line 2291 of file elem.C.

References libMesh::ElemInternal::active_family_tree_by_topological_neighbor(), and mesh.

2297 {
2299  mesh, point_locator, pb,
2300  reset);
2301 }
MeshBase & mesh
void active_family_tree_by_topological_neighbor(T elem, std::vector< T > &family, T neighbor_in, const MeshBase &mesh, const PointLocatorBase &point_locator, const PeriodicBoundaries *pb, bool reset=true)

◆ add_child() [1/2]

void libMesh::Elem::add_child ( Elem elem)
inherited

Adds a child pointer to the array of children of this element.

If this is the first child to be added, this method allocates memory in the parent's _children array, otherwise, it just sets the pointer.

Definition at line 2042 of file elem.C.

References libMesh::Elem::_children, libMesh::Elem::n_children(), libMesh::Elem::parent(), libMesh::remote_elem, and libMesh::Elem::set_child().

Referenced by libMesh::BoundaryInfo::add_elements(), libMesh::UnstructuredMesh::all_first_order(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::CheckpointIO::read_connectivity(), and libMesh::CheckpointIO::read_remote_elem().

2043 {
2044  const unsigned int nc = this->n_children();
2045 
2046  if (!_children)
2047  {
2048  _children = std::make_unique<Elem *[]>(nc);
2049 
2050  for (unsigned int c = 0; c != nc; c++)
2051  this->set_child(c, nullptr);
2052  }
2053 
2054  for (unsigned int c = 0; c != nc; c++)
2055  {
2056  if (this->_children[c] == nullptr || this->_children[c] == remote_elem)
2057  {
2058  libmesh_assert_equal_to (this, elem->parent());
2059  this->set_child(c, elem);
2060  return;
2061  }
2062  }
2063 
2064  libmesh_error_msg("Error: Tried to add a child to an element with full children array");
2065 }
virtual unsigned int n_children() const =0
void set_child(unsigned int c, Elem *elem)
Sets the pointer to the child for this element.
Definition: elem.h:3183
std::unique_ptr< Elem *[]> _children
unique_ptr to array of this element&#39;s children.
Definition: elem.h:2262
const RemoteElem * remote_elem
Definition: remote_elem.C:57

◆ add_child() [2/2]

void libMesh::Elem::add_child ( Elem elem,
unsigned int  c 
)
inherited

Adds a new child pointer to the specified index in the array of children of this element.

If this is the first child to be added, this method allocates memory in the parent's _children array, otherwise, it just sets the pointer.

Definition at line 2069 of file elem.C.

References libMesh::Elem::_children, libMesh::Elem::child_ptr(), libMesh::Elem::has_children(), libMesh::libmesh_assert(), libMesh::Elem::n_children(), libMesh::Elem::parent(), libMesh::remote_elem, and libMesh::Elem::set_child().

2070 {
2071  if (!this->has_children())
2072  {
2073  const unsigned int nc = this->n_children();
2074  _children = std::make_unique<Elem *[]>(nc);
2075 
2076  for (unsigned int i = 0; i != nc; i++)
2077  this->set_child(i, nullptr);
2078  }
2079 
2080  libmesh_assert (this->_children[c] == nullptr || this->child_ptr(c) == remote_elem);
2081  libmesh_assert (elem == remote_elem || this == elem->parent());
2082 
2083  this->set_child(c, elem);
2084 }
const Elem * parent() const
Definition: elem.h:3031
virtual unsigned int n_children() const =0
libmesh_assert(ctx)
void set_child(unsigned int c, Elem *elem)
Sets the pointer to the child for this element.
Definition: elem.h:3183
bool has_children() const
Definition: elem.h:2980
std::unique_ptr< Elem *[]> _children
unique_ptr to array of this element&#39;s children.
Definition: elem.h:2262
const Elem * child_ptr(unsigned int i) const
Definition: elem.h:3164
const RemoteElem * remote_elem
Definition: remote_elem.C:57

◆ add_extra_integers() [1/2]

void libMesh::DofObject::add_extra_integers ( const unsigned int  n_integers)
inherited

Assigns a set of extra integers to this DofObject.

There will now be n_integers associated; this replaces, not augments, any previous count.

Any newly-added values will initially be DofObject::invalid_id

If non-integer data is in the set, each datum of type T should be counted sizeof(T)/sizeof(dof_id_type) times in n_integers.

Definition at line 482 of file dof_object.C.

References libMesh::DofObject::_idx_buf, libMesh::DofObject::invalid_id, and libMesh::DofObject::n_extra_integers().

Referenced by libMesh::ReplicatedMesh::add_elem(), libMesh::DistributedMesh::add_elem(), libMesh::DofObject::add_extra_integers(), libMesh::ReplicatedMesh::add_node(), libMesh::DistributedMesh::add_node(), libMesh::ReplicatedMesh::add_point(), libMesh::UnstructuredMesh::all_first_order(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::UnstructuredMesh::create_submesh(), libMesh::ReplicatedMesh::insert_elem(), libMesh::DistributedMesh::insert_elem(), libMesh::ReplicatedMesh::insert_node(), DofObjectTest< Node >::testAddExtraData(), DofObjectTest< Node >::testAddSystemExtraInts(), DofObjectTest< Node >::testSetNSystemsExtraInts(), and DofObjectTest< Node >::testSetNVariableGroupsExtraInts().

483 {
484  if (_idx_buf.empty())
485  {
486  if (n_integers)
487  {
488  _idx_buf.resize(n_integers+1, DofObject::invalid_id);
489  _idx_buf[0] = dof_id_type(-1);
490  }
491  return;
492  }
493  else
494  {
495  const int hdr = dof_id_signed_type(_idx_buf[0]);
496 
497  // We already have some extra integers, but may need more or
498  // less now.
499  if (hdr < 0)
500  {
501  const unsigned int old_n_integers = this->n_extra_integers();
502  if (n_integers != old_n_integers)
503  {
504  // Make or remove space as needed by count change
505  _idx_buf.resize(_idx_buf.size()+n_integers-old_n_integers, DofObject::invalid_id);
506 
507  // The start index for the extra integers is unchanged.
508  }
509  }
510  else if (n_integers)
511  // We had no extra integers, but need to add some
512  {
513  // Mark the DofObject as holding extra integers
514  _idx_buf[0] = dof_id_type(-hdr-1);
515 
516  // Insert the integer start position
517  DofObject::index_buffer_t::iterator it = _idx_buf.begin() + hdr;
518  _idx_buf.insert(it, _idx_buf.size()+1);
519 
520  // Increment the previous system start positions to account
521  // for the new header entry creating an offset
522  for (int i=1; i<hdr; i++)
523  _idx_buf[i]++;
524 
525  // Append space for extra integers
526  _idx_buf.resize(_idx_buf.size()+n_integers, DofObject::invalid_id);
527  }
528  }
529 }
static constexpr dof_id_type invalid_id
An invalid id to distinguish an uninitialized DofObject.
Definition: dof_object.h:482
int8_t dof_id_signed_type
Definition: id_types.h:68
unsigned int n_extra_integers() const
Returns how many extra integers are associated to the DofObject.
Definition: dof_object.h:1170
index_buffer_t _idx_buf
Definition: dof_object.h:680
uint8_t dof_id_type
Definition: id_types.h:67

◆ add_extra_integers() [2/2]

void libMesh::DofObject::add_extra_integers ( const unsigned int  n_integers,
const std::vector< dof_id_type > &  default_values 
)
inherited

Assigns a set of extra integers to this DofObject.

There will now be n_integers associated; this replaces, not augments, any previous count.

Any newly-added values will be copied from default_values.

If non-integer data is in the set, each datum of type T should be counted sizeof(T)/sizeof(dof_id_type) times in n_integers, and its data should be expressed in default_values as per memcpy.

Definition at line 534 of file dof_object.C.

References libMesh::DofObject::_idx_buf, libMesh::DofObject::add_extra_integers(), and libMesh::DofObject::n_extra_integers().

536 {
537  libmesh_assert_equal_to(n_integers, default_values.size());
538 
539  const unsigned int n_old_integers = this->n_extra_integers();
540  this->add_extra_integers(n_integers);
541  if (n_integers > n_old_integers)
542  {
543  const unsigned int n_more_integers = n_integers - n_old_integers;
544  std::copy(default_values.begin()+n_old_integers,
545  default_values.end(),
546  _idx_buf.end()-n_more_integers);
547  }
548 }
void add_extra_integers(const unsigned int n_integers)
Assigns a set of extra integers to this DofObject.
Definition: dof_object.C:482
unsigned int n_extra_integers() const
Returns how many extra integers are associated to the DofObject.
Definition: dof_object.h:1170
index_buffer_t _idx_buf
Definition: dof_object.h:680

◆ add_system()

void libMesh::DofObject::add_system ( )
inherited

Adds an additional system to the DofObject.

Definition at line 187 of file dof_object.C.

References libMesh::DofObject::_idx_buf, libMesh::DofObject::has_extra_integers(), libMesh::DofObject::n_systems(), libMesh::DofObject::n_var_groups(), libMesh::DofObject::n_vars(), and libMesh::DofObject::set_n_systems().

Referenced by DofObjectTest< Node >::testAddSystemExtraInts().

188 {
189  // quick return?
190  if (this->n_systems() == 0)
191  {
192  this->set_n_systems(1);
193  return;
194  }
195 
196  // cache this value before we screw it up!
197  const unsigned int ns_orig = this->n_systems();
198 
199  DofObject::index_buffer_t::iterator it = _idx_buf.begin() + ns_orig;
200 
201  // Create the entry for the new system indicating 0 variables.
202  //
203  // increment the number of systems and the offsets for each of
204  // the systems including the new one we just added.
205  if (this->has_extra_integers())
206  {
207  // this inserts the extra_integers' start position as the start
208  // position for the new system. We'll increment all those
209  // counts in one sweep next, to account for header expansion.
210  _idx_buf.insert(it, *it);
211 
212  _idx_buf[0]--;
213  for (unsigned int i=1; i<ns_orig+2; i++)
214  {
215  libmesh_assert_less(i, _idx_buf.size());
216  _idx_buf[i]++;
217  }
218  }
219  else
220  {
221  // this inserts the current vector size at the position for the
222  // new system
223  _idx_buf.insert(it, cast_int<dof_id_type>(_idx_buf.size()));
224 
225  for (unsigned int i=0; i<ns_orig+1; i++)
226  {
227  libmesh_assert_less(i, _idx_buf.size());
228  _idx_buf[i]++;
229  }
230  }
231 
232  libmesh_assert_equal_to (this->n_systems(), (ns_orig+1));
233  libmesh_assert_equal_to (this->n_vars(ns_orig), 0);
234  libmesh_assert_equal_to (this->n_var_groups(ns_orig), 0);
235 }
unsigned int n_var_groups(const unsigned int s) const
Definition: dof_object.h:957
unsigned int n_vars(const unsigned int s, const unsigned int vg) const
Definition: dof_object.h:967
unsigned int n_systems() const
Definition: dof_object.h:937
bool has_extra_integers() const
Returns whether extra integers are associated to the DofObject.
Definition: dof_object.h:1188
void set_n_systems(const unsigned int s)
Sets the number of systems for this DofObject.
Definition: dof_object.C:142
index_buffer_t _idx_buf
Definition: dof_object.h:680

◆ ancestor()

bool libMesh::Elem::ancestor ( ) const
inherited
Returns
true if the element is an ancestor (i.e. has an active child or ancestor child), false otherwise or when AMR is disabled.

Definition at line 2008 of file elem.C.

References libMesh::Elem::active(), libMesh::Elem::child_ref_range(), libMesh::Elem::has_children(), libMesh::libmesh_assert(), libMesh::remote_elem, and libMesh::Elem::subactive().

Referenced by libMesh::UnstructuredMesh::find_neighbors(), libMesh::Elem::get_info(), and libMesh::Elem::refine().

2009 {
2010 #ifdef LIBMESH_ENABLE_AMR
2011 
2012  // Use a fast, DistributedMesh-safe definition
2013  const bool is_ancestor =
2014  !this->active() && !this->subactive();
2015 
2016  // But check for inconsistencies if we have time
2017 #ifdef DEBUG
2018  if (!is_ancestor && this->has_children())
2019  {
2020  for (auto & c : this->child_ref_range())
2021  {
2022  if (&c != remote_elem)
2023  {
2024  libmesh_assert(!c.active());
2025  libmesh_assert(!c.ancestor());
2026  }
2027  }
2028  }
2029 #endif // DEBUG
2030 
2031  return is_ancestor;
2032 
2033 #else
2034  return false;
2035 #endif
2036 }
SimpleRange< ChildRefIter > child_ref_range()
Returns a range with all children of a parent element, usable in range-based for loops.
Definition: elem.h:2347
libmesh_assert(ctx)
bool subactive() const
Definition: elem.h:2960
bool active() const
Definition: elem.h:2942
bool has_children() const
Definition: elem.h:2980
const RemoteElem * remote_elem
Definition: remote_elem.C:57

◆ as_parent_node()

unsigned int libMesh::Elem::as_parent_node ( unsigned int  c,
unsigned int  n 
) const
virtualinherited
Returns
The local node id on the parent which corresponds to node n of child c, or invalid_uint if no such parent node exists.

Definition at line 2384 of file elem.C.

References libMesh::Elem::_get_parent_indices_cache(), libMesh::Elem::embedding_matrix(), libMesh::Elem::embedding_matrix_version(), libMesh::invalid_uint, libMesh::Elem::n_children(), libMesh::Elem::n_nodes(), libMesh::Elem::n_nodes_in_child(), libMesh::parent_indices_mutex, and libMesh::Real.

Referenced by libMesh::MeshRefinement::add_node(), and libMesh::Elem::parent_bracketing_nodes().

2386 {
2387  const unsigned int nc = this->n_children();
2388  libmesh_assert_less(child, nc);
2389 
2390  // Cached return values, indexed first by embedding_matrix version,
2391  // then by child number, then by child node number.
2392  std::vector<std::vector<std::vector<signed char>>> &
2393  cached_parent_indices = this->_get_parent_indices_cache();
2394 
2395  unsigned int em_vers = this->embedding_matrix_version();
2396 
2397  // We may be updating the cache on one thread, and while that
2398  // happens we can't safely access the cache from other threads.
2399  Threads::spin_mutex::scoped_lock lock(parent_indices_mutex);
2400 
2401  if (em_vers >= cached_parent_indices.size())
2402  cached_parent_indices.resize(em_vers+1);
2403 
2404  if (child >= cached_parent_indices[em_vers].size())
2405  {
2406  const signed char nn = cast_int<signed char>(this->n_nodes());
2407 
2408  cached_parent_indices[em_vers].resize(nc);
2409 
2410  for (unsigned int c = 0; c != nc; ++c)
2411  {
2412  const unsigned int ncn = this->n_nodes_in_child(c);
2413  cached_parent_indices[em_vers][c].resize(ncn);
2414  for (unsigned int cn = 0; cn != ncn; ++cn)
2415  {
2416  for (signed char n = 0; n != nn; ++n)
2417  {
2418  const Real em_val = this->embedding_matrix
2419  (c, cn, n);
2420  if (em_val == 1)
2421  {
2422  cached_parent_indices[em_vers][c][cn] = n;
2423  break;
2424  }
2425 
2426  if (em_val != 0)
2427  {
2428  cached_parent_indices[em_vers][c][cn] =
2429  -1;
2430  break;
2431  }
2432 
2433  // We should never see an all-zero embedding matrix
2434  // row
2435  libmesh_assert_not_equal_to (n+1, nn);
2436  }
2437  }
2438  }
2439  }
2440 
2441  const signed char cache_val =
2442  cached_parent_indices[em_vers][child][child_node];
2443  if (cache_val == -1)
2444  return libMesh::invalid_uint;
2445 
2446  return cached_parent_indices[em_vers][child][child_node];
2447 }
const unsigned int invalid_uint
A number which is used quite often to represent an invalid or uninitialized value for an unsigned int...
Definition: libmesh.h:310
virtual unsigned int embedding_matrix_version() const
Definition: elem.h:2052
Threads::spin_mutex parent_indices_mutex
Definition: elem.C:97
virtual unsigned int n_children() const =0
virtual Real embedding_matrix(const unsigned int child_num, const unsigned int child_node_num, const unsigned int parent_node_num) const =0
virtual std::vector< std::vector< std::vector< signed char > > > & _get_parent_indices_cache() const
Elem subclasses which don&#39;t do their own child-to-parent node calculations will need to supply a stat...
Definition: elem.h:2224
virtual unsigned int n_nodes() const =0
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
virtual unsigned int n_nodes_in_child(unsigned int) const
Definition: elem.h:669

◆ boundary_sides_begin()

Elem::side_iterator libMesh::Elem::boundary_sides_begin ( )
inherited

Iterator accessor functions.

Definition at line 3415 of file elem.C.

References libMesh::Elem::_first_side(), and libMesh::Elem::_last_side().

3416 {
3417  Predicates::BoundarySide<SideIter> bsp;
3418  return side_iterator(this->_first_side(), this->_last_side(), bsp);
3419 }
SideIter _last_side()
Definition: elem.h:3479
SideIter _first_side()
Side iterator helper functions.
Definition: elem.h:3471

◆ boundary_sides_end()

Elem::side_iterator libMesh::Elem::boundary_sides_end ( )
inherited

Definition at line 3424 of file elem.C.

References libMesh::Elem::_last_side().

3425 {
3426  Predicates::BoundarySide<SideIter> bsp;
3427  return side_iterator(this->_last_side(), this->_last_side(), bsp);
3428 }
SideIter _last_side()
Definition: elem.h:3479

◆ bracketing_nodes()

const std::vector< std::pair< dof_id_type, dof_id_type > > libMesh::Elem::bracketing_nodes ( unsigned int  c,
unsigned int  n 
) const
virtualinherited
Returns
All the pairs of nodes (indexed by global node id) which should bracket node n of child c.

Definition at line 2655 of file elem.C.

References libMesh::Elem::build(), libMesh::Elem::child_ptr(), libMesh::Elem::default_order(), libMesh::FIRST, libMesh::HEX20, libMesh::DofObject::invalid_id, libMesh::libmesh_assert(), libMesh::make_range(), libMesh::Elem::n_nodes(), libMesh::Elem::n_nodes_in_child(), libMesh::Elem::node_id(), libMesh::Elem::parent_bracketing_nodes(), libMesh::remote_elem, libMesh::Elem::second_order_equivalent_type(), and libMesh::Elem::type().

Referenced by libMesh::MeshRefinement::add_node(), and libMesh::TopologyMap::fill().

2657 {
2658  std::vector<std::pair<dof_id_type, dof_id_type>> returnval;
2659 
2660  const std::vector<std::pair<unsigned char, unsigned char>> & pbc =
2661  this->parent_bracketing_nodes(child,child_node);
2662 
2663  for (const auto & pb : pbc)
2664  {
2665  const unsigned short n_n = this->n_nodes();
2666  if (pb.first < n_n && pb.second < n_n)
2667  returnval.emplace_back(this->node_id(pb.first), this->node_id(pb.second));
2668  else
2669  {
2670  // We must be on a non-full-order higher order element...
2671  libmesh_assert_not_equal_to(this->default_order(), FIRST);
2672  libmesh_assert_not_equal_to
2673  (second_order_equivalent_type (this->type(), true),
2674  this->type());
2675  libmesh_assert_equal_to
2676  (second_order_equivalent_type (this->type(), false),
2677  this->type());
2678 
2679  // And that's a shame, because this is a nasty search:
2680 
2681  // Build the full-order type
2682  ElemType full_type =
2683  second_order_equivalent_type(this->type(), /*full_ordered=*/ true);
2684  std::unique_ptr<Elem> full_elem = Elem::build(full_type);
2685 
2688 
2689  // Find the bracketing nodes by figuring out what
2690  // already-created children will have them.
2691 
2692  // This only doesn't break horribly because we add children
2693  // and nodes in straightforward + hierarchical orders...
2694  for (unsigned int c=0; c <= child; ++c)
2695  {
2696  libmesh_assert(this->child_ptr(c));
2697  if (this->child_ptr(c) == remote_elem)
2698  continue;
2699 
2700  for (auto n : make_range(this->n_nodes_in_child(c)))
2701  {
2702  if (c == child && n == child_node)
2703  break;
2704 
2705  if (pb.first == full_elem->as_parent_node(c,n))
2706  {
2707  // We should be consistent
2708  if (pt1 != DofObject::invalid_id)
2709  libmesh_assert_equal_to(pt1, this->child_ptr(c)->node_id(n));
2710 
2711  pt1 = this->child_ptr(c)->node_id(n);
2712  }
2713 
2714  if (pb.second == full_elem->as_parent_node(c,n))
2715  {
2716  // We should be consistent
2717  if (pt2 != DofObject::invalid_id)
2718  libmesh_assert_equal_to(pt2, this->child_ptr(c)->node_id(n));
2719 
2720  pt2 = this->child_ptr(c)->node_id(n);
2721  }
2722  }
2723  }
2724 
2725  // We should *usually* find all bracketing nodes by the time
2726  // we query them (again, because of the child & node add
2727  // order)
2728  //
2729  // The exception is if we're a HEX20, in which case we will
2730  // find pairs of vertex nodes and edge nodes bracketing the
2731  // new central node but we *won't* find the pairs of face
2732  // nodes which we would have had on a HEX27. In that case
2733  // we'll still have enough bracketing nodes for a
2734  // topological lookup, but we won't be able to make the
2735  // following assertions.
2736  if (this->type() != HEX20)
2737  {
2738  libmesh_assert_not_equal_to (pt1, DofObject::invalid_id);
2739  libmesh_assert_not_equal_to (pt2, DofObject::invalid_id);
2740  }
2741 
2742  if (pt1 != DofObject::invalid_id &&
2743  pt2 != DofObject::invalid_id)
2744  returnval.emplace_back(pt1, pt2);
2745  }
2746  }
2747 
2748  return returnval;
2749 }
ElemType
Defines an enum for geometric element types.
static constexpr dof_id_type invalid_id
An invalid id to distinguish an uninitialized DofObject.
Definition: dof_object.h:482
virtual unsigned int n_nodes() const =0
static std::unique_ptr< Elem > build(const ElemType type, Elem *p=nullptr)
Definition: elem.C:442
libmesh_assert(ctx)
static ElemType second_order_equivalent_type(const ElemType et, const bool full_ordered=true)
Definition: elem.C:3139
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140
virtual Order default_order() const =0
virtual const std::vector< std::pair< unsigned char, unsigned char > > & parent_bracketing_nodes(unsigned int c, unsigned int n) const
Definition: elem.C:2452
virtual ElemType type() const =0
dof_id_type node_id(const unsigned int i) const
Definition: elem.h:2476
virtual unsigned int n_nodes_in_child(unsigned int) const
Definition: elem.h:669
const Elem * child_ptr(unsigned int i) const
Definition: elem.h:3164
uint8_t dof_id_type
Definition: id_types.h:67
const RemoteElem * remote_elem
Definition: remote_elem.C:57

◆ build()

std::unique_ptr< Elem > libMesh::Elem::build ( const ElemType  type,
Elem p = nullptr 
)
staticinherited
Returns
An Elem of type type wrapped in a smart pointer.

Definition at line 442 of file elem.C.

References libMesh::C0POLYGON, libMesh::C0POLYHEDRON, libMesh::EDGE2, libMesh::EDGE3, libMesh::EDGE4, libMesh::Utility::enum_to_string(), libMesh::HEX20, libMesh::HEX27, libMesh::HEX8, libMesh::INFEDGE2, libMesh::INFHEX16, libMesh::INFHEX18, libMesh::INFHEX8, libMesh::INFPRISM12, libMesh::INFPRISM6, libMesh::INFQUAD4, libMesh::INFQUAD6, libMesh::NODEELEM, libMesh::PRISM15, libMesh::PRISM18, libMesh::PRISM20, libMesh::PRISM21, libMesh::PRISM6, libMesh::PYRAMID13, libMesh::PYRAMID14, libMesh::PYRAMID18, libMesh::PYRAMID5, libMesh::QUAD4, libMesh::QUAD8, libMesh::QUAD9, libMesh::QUADSHELL4, libMesh::QUADSHELL8, libMesh::QUADSHELL9, libMesh::TET10, libMesh::TET14, libMesh::TET4, libMesh::TRI3, libMesh::TRI3SUBDIVISION, libMesh::TRI6, libMesh::TRI7, libMesh::TRISHELL3, and libMesh::Elem::type().

Referenced by libMesh::GMVIO::_read_one_cell(), libMesh::MeshTools::Subdivision::add_boundary_ghosts(), add_cube_convex_hull_to_mesh(), libMesh::UnstructuredMesh::all_first_order(), libMesh::MeshTools::Modification::all_tri(), AllSecondOrderTest::allCompleteOrderMixed(), AllSecondOrderTest::allCompleteOrderRange(), AllSecondOrderTest::allSecondOrderMixed(), AllSecondOrderTest::allSecondOrderRange(), libMesh::Elem::bracketing_nodes(), libMesh::MeshTools::Generation::build_cube(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::InfElemBuilder::build_inf_elem(), MixedDimensionMeshTest::build_mesh(), ExtraIntegersTest::build_mesh(), MeshfunctionDFEM::build_mesh(), MixedDimensionNonUniformRefinement::build_mesh(), MixedDimensionNonUniformRefinementTriangle::build_mesh(), MixedDimensionNonUniformRefinement3D::build_mesh(), libMesh::Elem::build_with_id(), SideVertexAverageNormalTest::construct_elem(), VolumeTest::construct_elem(), ContainsPointTest::containsPointTri3Helper(), libMesh::MeshBase::copy_constraint_rows(), libMesh::TriangleWrapper::copy_tri_to_mesh(), libMesh::Elem::disconnected_clone(), libMesh::UNVIO::elements_in(), libMesh::MeshTools::Modification::flatten(), libMesh::VariationalSmootherSystem::get_target_elem(), libMesh::ExodusII_IO_Helper::init_conversion_map(), main(), libMesh::Elem::parent_bracketing_nodes(), libMesh::TetGenMeshInterface::pointset_convexhull(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::VTKIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::ExodusII_IO_Helper::read_edge_blocks(), libMesh::AbaqusIO::read_elements(), libMesh::UCDIO::read_implementation(), libMesh::DynaIO::read_mesh(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::OFFIO::read_stream(), libMesh::Elem::refine(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::C0Polyhedron::retriangulate(), PerElemTest< elem_type >::setUp(), RationalMapTest< elem_type >::setUp(), libMesh::MeshTools::Generation::surface_octahedron(), ContainsPointTest::testContainsPointNodeElem(), ContainsPointTest::testContainsPointTet4(), DefaultCouplingTest::testCoupling(), PointNeighborCouplingTest::testCoupling(), SystemsTest::testDofCouplingWithVarGroups(), DofMapTest::testDofOwner(), MeshTriangulationTest::testEdge3Mesh(), MeshTriangulationTest::testEdgesMesh(), MeshTriangulationTest::testHalfDomain(), QuadratureTest::testNodalQuadrature(), MeshTriangulationTest::testPoly2TriBad1DMultiBoundary(), MeshTriangulationTest::testPoly2TriBad2DMultiBoundary(), MeshTriangulationTest::testPoly2TriBadEdges(), QuadratureTest::testPolynomials(), EquationSystemsTest::testReinitWithNodeElem(), SystemsTest::testSetSystemParameterOverEquationSystem(), BoundaryInfoTest::testShellFaceConstraints(), MeshTetTest::testTetsToTets(), MeshSubdomainIDTest::testUnpartitioned(), libMesh::TetGenMeshInterface::triangulate_conformingDelaunayMesh_carvehole(), libMesh::TetGenMeshInterface::triangulate_pointset(), and libMesh::GMVIO::write_ascii_old_impl().

444 {
445  switch (type)
446  {
447  // 0D elements
448  case NODEELEM:
449  return std::make_unique<NodeElem>(p);
450 
451  // 1D elements
452  case EDGE2:
453  return std::make_unique<Edge2>(p);
454  case EDGE3:
455  return std::make_unique<Edge3>(p);
456  case EDGE4:
457  return std::make_unique<Edge4>(p);
458 
459  // 2D elements
460  case TRI3:
461  return std::make_unique<Tri3>(p);
462  case TRISHELL3:
463  return std::make_unique<TriShell3>(p);
464  case TRI3SUBDIVISION:
465  return std::make_unique<Tri3Subdivision>(p);
466  case TRI6:
467  return std::make_unique<Tri6>(p);
468  case TRI7:
469  return std::make_unique<Tri7>(p);
470  case QUAD4:
471  return std::make_unique<Quad4>(p);
472  case QUADSHELL4:
473  return std::make_unique<QuadShell4>(p);
474  case QUAD8:
475  return std::make_unique<Quad8>(p);
476  case QUADSHELL8:
477  return std::make_unique<QuadShell8>(p);
478  case QUAD9:
479  return std::make_unique<Quad9>(p);
480  case QUADSHELL9:
481  return std::make_unique<QuadShell9>(p);
482 
483  // Well, a hexagon is *a* polygon...
484  case C0POLYGON:
485  return std::make_unique<C0Polygon>(6, p);
486 
487  // Building a polyhedron can't currently be done without creating
488  // its nodes first
489  case C0POLYHEDRON:
490  libmesh_not_implemented_msg
491  ("Polyhedra cannot be built via Elem::build()");
492 
493  // 3D elements
494  case TET4:
495  return std::make_unique<Tet4>(p);
496  case TET10:
497  return std::make_unique<Tet10>(p);
498  case TET14:
499  return std::make_unique<Tet14>(p);
500  case HEX8:
501  return std::make_unique<Hex8>(p);
502  case HEX20:
503  return std::make_unique<Hex20>(p);
504  case HEX27:
505  return std::make_unique<Hex27>(p);
506  case PRISM6:
507  return std::make_unique<Prism6>(p);
508  case PRISM15:
509  return std::make_unique<Prism15>(p);
510  case PRISM18:
511  return std::make_unique<Prism18>(p);
512  case PRISM20:
513  return std::make_unique<Prism20>(p);
514  case PRISM21:
515  return std::make_unique<Prism21>(p);
516  case PYRAMID5:
517  return std::make_unique<Pyramid5>(p);
518  case PYRAMID13:
519  return std::make_unique<Pyramid13>(p);
520  case PYRAMID14:
521  return std::make_unique<Pyramid14>(p);
522  case PYRAMID18:
523  return std::make_unique<Pyramid18>(p);
524 
525 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
526  // 1D infinite elements
527  case INFEDGE2:
528  return std::make_unique<InfEdge2>(p);
529 
530  // 2D infinite elements
531  case INFQUAD4:
532  return std::make_unique<InfQuad4>(p);
533  case INFQUAD6:
534  return std::make_unique<InfQuad6>(p);
535 
536  // 3D infinite elements
537  case INFHEX8:
538  return std::make_unique<InfHex8>(p);
539  case INFHEX16:
540  return std::make_unique<InfHex16>(p);
541  case INFHEX18:
542  return std::make_unique<InfHex18>(p);
543  case INFPRISM6:
544  return std::make_unique<InfPrism6>(p);
545  case INFPRISM12:
546  return std::make_unique<InfPrism12>(p);
547 #endif
548 
549  default:
550  libmesh_error_msg("ERROR: Undefined element type == " << Utility::enum_to_string(type));
551  }
552 }
std::string enum_to_string(const T e)
virtual ElemType type() const =0

◆ build_edge_ptr() [1/4]

std::unique_ptr< Elem > libMesh::Pyramid5::build_edge_ptr ( const unsigned int  i)
overridevirtual

Builds a EDGE2 built coincident with edge i.

The std::unique_ptr<Elem> handles the memory aspect.

Implements libMesh::Elem.

Definition at line 178 of file cell_pyramid5.C.

179 {
180  return this->simple_build_edge_ptr<Edge2,Pyramid5>(i);
181 }

◆ build_edge_ptr() [2/4]

void libMesh::Pyramid5::build_edge_ptr ( std::unique_ptr< Elem > &  edge,
const unsigned int  i 
)
overridevirtual

Rebuilds a EDGE2 coincident with edge i.

Implements libMesh::Elem.

Definition at line 185 of file cell_pyramid5.C.

References libMesh::EDGE2.

186 {
187  this->simple_build_edge_ptr<Pyramid5>(edge, i, EDGE2);
188 }

◆ build_edge_ptr() [3/4]

std::unique_ptr< const Elem > libMesh::Elem::build_edge_ptr ( const unsigned int  i) const
inlineinherited

Definition at line 2841 of file elem.h.

References libMesh::Elem::build_edge_ptr().

2842 {
2843  // Call the non-const version of this function, return the result as
2844  // a std::unique_ptr<const Elem>.
2845  Elem * me = const_cast<Elem *>(this);
2846  return me->build_edge_ptr(i);
2847 }
Elem(const unsigned int n_nodes, const unsigned int n_sides, Elem *parent, Elem **elemlinkdata, Node **nodelinkdata)
Constructor.
Definition: elem.h:2379

◆ build_edge_ptr() [4/4]

void libMesh::Elem::build_edge_ptr ( std::unique_ptr< const Elem > &  edge,
const unsigned int  i 
) const
inlineinherited

Definition at line 2853 of file elem.h.

References libMesh::Elem::build_edge_ptr().

2855 {
2856  // Hand off to the non-const version of this function
2857  Elem * me = const_cast<Elem *>(this);
2858  std::unique_ptr<Elem> e {const_cast<Elem *>(elem.release())};
2859  me->build_edge_ptr(e, i);
2860  elem = std::move(e);
2861 }
Elem(const unsigned int n_nodes, const unsigned int n_sides, Elem *parent, Elem **elemlinkdata, Node **nodelinkdata)
Constructor.
Definition: elem.h:2379

◆ build_side_ptr() [1/12]

std::unique_ptr< Elem > libMesh::Pyramid5::build_side_ptr ( const unsigned int  i)
overridevirtual

Builds a QUAD4 or TRI3 built coincident with face i.

The std::unique_ptr<Elem> handles the memory aspect.

Implements libMesh::Elem.

Definition at line 131 of file cell_pyramid5.C.

References libMesh::Pyramid::n_sides(), and side_nodes_map.

132 {
133  libmesh_assert_less (i, this->n_sides());
134 
135  std::unique_ptr<Elem> face;
136 
137  switch (i)
138  {
139  case 0: // triangular face 1
140  case 1: // triangular face 2
141  case 2: // triangular face 3
142  case 3: // triangular face 4
143  {
144  face = std::make_unique<Tri3>();
145  break;
146  }
147  case 4: // the quad face at z=0
148  {
149  face = std::make_unique<Quad4>();
150  break;
151  }
152  default:
153  libmesh_error_msg("Invalid side i = " << i);
154  }
155 
156  // Set the nodes
157  for (auto n : face->node_index_range())
158  face->set_node(n, this->node_ptr(Pyramid5::side_nodes_map[i][n]));
159 
160  face->set_interior_parent(this);
161  face->inherit_data_from(*this);
162 
163  return face;
164 }
virtual unsigned int n_sides() const override
Definition: cell_pyramid.h:90
static const unsigned int side_nodes_map[num_sides][nodes_per_side]
This maps the node of the side to element node numbers.

◆ build_side_ptr() [2/12]

void libMesh::Pyramid5::build_side_ptr ( std::unique_ptr< Elem > &  elem,
const unsigned int  i 
)
overridevirtual

Rebuilds a QUAD4 or TRI3 built coincident with face i.

Implements libMesh::Elem.

Definition at line 168 of file cell_pyramid5.C.

References libMesh::Pyramid::side_ptr().

170 {
171  this->side_ptr(side, i);
172  side->set_interior_parent(this);
173  side->inherit_data_from(*this);
174 }
virtual std::unique_ptr< Elem > side_ptr(const unsigned int i) override
Definition: cell_pyramid.C:158

◆ build_side_ptr() [3/12]

void libMesh::Elem::build_side_ptr
inline

Definition at line 2758 of file elem.h.

2760 {
2761  // Hand off to the non-const version of this function
2762  Elem * me = const_cast<Elem *>(this);
2763  std::unique_ptr<Elem> e {const_cast<Elem *>(elem.release())};
2764  me->build_side_ptr(e, i);
2765  elem = std::move(e);
2766 }
Elem(const unsigned int n_nodes, const unsigned int n_sides, Elem *parent, Elem **elemlinkdata, Node **nodelinkdata)
Constructor.
Definition: elem.h:2379

◆ build_side_ptr() [4/12]

virtual std::unique_ptr<Elem> libMesh::Elem::build_side_ptr
Returns
An temporary element coincident with side i wrapped in a smart pointer.

The element returned is full-ordered and full-featured, in contrast to the side method. For example, calling build_side_ptr(0) on a 20-noded hex in subdomain 5 will build a 8-noded quadrilateral coincident with face 0, assign it subdomain id 5, and pass back the pointer.

The side element's id() is undefined; it is a temporary element not added to any mesh.

A std::unique_ptr<Elem> is returned to prevent a memory leak. This way the user need not remember to delete the object.

The const version of this function is non-virtual; it simply calls the virtual non-const version and const_casts the return type.

◆ build_side_ptr() [5/12]

std::unique_ptr< const Elem > libMesh::Elem::build_side_ptr
inline

Definition at line 2746 of file elem.h.

2747 {
2748  // Call the non-const version of this function, return the result as
2749  // a std::unique_ptr<const Elem>.
2750  Elem * me = const_cast<Elem *>(this);
2751  return me->build_side_ptr(i);
2752 }
Elem(const unsigned int n_nodes, const unsigned int n_sides, Elem *parent, Elem **elemlinkdata, Node **nodelinkdata)
Constructor.
Definition: elem.h:2379

◆ build_side_ptr() [6/12]

virtual std::unique_ptr<Elem> libMesh::Elem::build_side_ptr
inline

Definition at line 928 of file elem.h.

929  { if (proxy) libmesh_error(); libmesh_deprecated(); return this->build_side_ptr(i); }
virtual std::unique_ptr< Elem > build_side_ptr(const unsigned int i) override
Builds a QUAD4 or TRI3 built coincident with face i.

◆ build_side_ptr() [7/12]

std::unique_ptr<const Elem> libMesh::Elem::build_side_ptr
inline

Definition at line 931 of file elem.h.

932  { if (proxy) libmesh_error(); libmesh_deprecated(); return this->build_side_ptr(i); }
virtual std::unique_ptr< Elem > build_side_ptr(const unsigned int i) override
Builds a QUAD4 or TRI3 built coincident with face i.

◆ build_side_ptr() [8/12]

virtual void libMesh::Elem::build_side_ptr

Resets the loose element side, which may currently point to a different side than i or even a different element than this, to point to side i on this.

If side is currently an element of the wrong type, it will be freed and a new element allocated; otherwise no memory allocation will occur.

This will cause side to be a full-ordered element, even if it is handed a lower-ordered element that must be replaced.

The const version of this function is non-virtual; it simply calls the virtual non-const version and const_casts the return type.

◆ build_side_ptr() [9/12]

std::unique_ptr< const Elem > libMesh::Elem::build_side_ptr ( const unsigned int  i) const
inlineinherited

Definition at line 2746 of file elem.h.

References libMesh::Elem::build_side_ptr().

2747 {
2748  // Call the non-const version of this function, return the result as
2749  // a std::unique_ptr<const Elem>.
2750  Elem * me = const_cast<Elem *>(this);
2751  return me->build_side_ptr(i);
2752 }
Elem(const unsigned int n_nodes, const unsigned int n_sides, Elem *parent, Elem **elemlinkdata, Node **nodelinkdata)
Constructor.
Definition: elem.h:2379

◆ build_side_ptr() [10/12]

virtual std::unique_ptr<Elem> libMesh::Elem::build_side_ptr ( const unsigned int  i,
bool  proxy 
)
inlinevirtualinherited

Definition at line 928 of file elem.h.

References libMesh::Elem::build_side_ptr().

929  { if (proxy) libmesh_error(); libmesh_deprecated(); return this->build_side_ptr(i); }
virtual std::unique_ptr< Elem > build_side_ptr(const unsigned int i)=0

◆ build_side_ptr() [11/12]

std::unique_ptr<const Elem> libMesh::Elem::build_side_ptr ( const unsigned int  i,
bool  proxy 
) const
inlineinherited

Definition at line 931 of file elem.h.

References libMesh::Elem::build_side_ptr().

932  { if (proxy) libmesh_error(); libmesh_deprecated(); return this->build_side_ptr(i); }
virtual std::unique_ptr< Elem > build_side_ptr(const unsigned int i)=0

◆ build_side_ptr() [12/12]

void libMesh::Elem::build_side_ptr ( std::unique_ptr< const Elem > &  side,
const unsigned int  i 
) const
inlineinherited

Definition at line 2758 of file elem.h.

References libMesh::Elem::build_side_ptr().

2760 {
2761  // Hand off to the non-const version of this function
2762  Elem * me = const_cast<Elem *>(this);
2763  std::unique_ptr<Elem> e {const_cast<Elem *>(elem.release())};
2764  me->build_side_ptr(e, i);
2765  elem = std::move(e);
2766 }
Elem(const unsigned int n_nodes, const unsigned int n_sides, Elem *parent, Elem **elemlinkdata, Node **nodelinkdata)
Constructor.
Definition: elem.h:2379

◆ build_with_id()

std::unique_ptr< Elem > libMesh::Elem::build_with_id ( const ElemType  type,
dof_id_type  id 
)
staticinherited

Calls the build() method above with a nullptr parent, and additionally sets the newly-created Elem's id.

This can be useful when adding pre-numbered Elems to a Mesh via add_elem() calls.

Definition at line 556 of file elem.C.

References libMesh::Elem::build(), and libMesh::Elem::type().

Referenced by libMesh::MeshTools::Subdivision::all_subdivision(), libMesh::MeshTools::Generation::build_cube(), GetBoundaryPointsTest::build_mesh(), SlitMeshTest::build_mesh(), OverlappingTestBase::build_quad_mesh(), libMesh::TetGenIO::element_in(), libMesh::Poly2TriTriangulator::insert_refinement_points(), libMesh::GmshIO::read_mesh(), libMesh::MatlabIO::read_stream(), NodalNeighborsTest::testOrientation(), EquationSystemsTest::testPostInitAddElem(), SystemsTest::testProjectMatrix3D(), InfFERadialTest::testRefinement(), libMesh::NetGenMeshInterface::triangulate(), and libMesh::Poly2TriTriangulator::triangulate_current_points().

558 {
559  // Call the other build() method with nullptr parent, then set the
560  // required id.
561  auto temp = Elem::build(type, nullptr);
562  temp->set_id(id);
563  return temp;
564 }
static std::unique_ptr< Elem > build(const ElemType type, Elem *p=nullptr)
Definition: elem.C:442
virtual ElemType type() const =0

◆ center_node_on_side()

unsigned int libMesh::Elem::center_node_on_side ( const unsigned short  side) const
virtualinherited
Returns
The local index of the center node on the side side.

A center node is a node that is located at the centroid of the given side. If the given side does not have a center node, this will return invalid_uint.

Reimplemented in libMesh::Prism20, libMesh::Prism21, libMesh::Prism18, libMesh::RemoteElem, libMesh::Hex27, libMesh::Pyramid18, libMesh::Pyramid14, libMesh::Edge, libMesh::Tri7, libMesh::Tri6, libMesh::Quad9, and libMesh::Quad8.

Definition at line 3542 of file elem.C.

References libMesh::invalid_uint, and libMesh::Elem::n_sides().

3543 {
3544  libmesh_assert_less (side, this->n_sides());
3545  return invalid_uint;
3546 }
const unsigned int invalid_uint
A number which is used quite often to represent an invalid or uninitialized value for an unsigned int...
Definition: libmesh.h:310
virtual unsigned int n_sides() const =0

◆ centroid()

Point libMesh::Elem::centroid ( ) const
virtualinherited

Calls Elem::vertex_average() for backwards compatibility.

Deprecated:
This method has now been deprecated, so it will be removed at some point in the future. Calls to Elem::centroid() in user code should be updated to either call Elem::vertex_average() or Elem::true_centroid() on a case by case basis.

Definition at line 576 of file elem.C.

References libMesh::err, and libMesh::Elem::vertex_average().

577 {
578  libmesh_do_once(libMesh::err
579  << "Elem::centroid() has been deprecated. Replace with either "
580  << "Elem::vertex_average() to maintain existing behavior, or "
581  << "the more expensive Elem::true_centroid() "
582  << "in cases where the true 'geometric' centroid is required."
583  << std::endl);
584  libmesh_deprecated();
585 
586  return Elem::vertex_average();
587 }
OStreamProxy err
Point vertex_average() const
Definition: elem.C:686

◆ child_neighbor() [1/2]

Elem * libMesh::Elem::child_neighbor ( Elem elem)
inlineinherited
Returns
If elem is a neighbor of a child of this element, a pointer to that child, otherwise nullptr.

Definition at line 2641 of file elem.h.

References libMesh::Elem::neighbor_ptr_range().

2642 {
2643  for (auto n : elem->neighbor_ptr_range())
2644  if (n && n->parent() == this)
2645  return n;
2646 
2647  return nullptr;
2648 }

◆ child_neighbor() [2/2]

const Elem * libMesh::Elem::child_neighbor ( const Elem elem) const
inlineinherited
Returns
If elem is a neighbor of a child of this element, a pointer to that child, otherwise nullptr.

Definition at line 2653 of file elem.h.

References libMesh::Elem::neighbor_ptr_range().

2654 {
2655  for (auto n : elem->neighbor_ptr_range())
2656  if (n && n->parent() == this)
2657  return n;
2658 
2659  return nullptr;
2660 }

◆ child_ptr() [1/2]

const Elem * libMesh::Elem::child_ptr ( unsigned int  i) const
inlineinherited
Returns
A constant pointer to the \( i^{th} \) child for this element. Do not call if this element has no children, i.e. is active.

Definition at line 3164 of file elem.h.

References libMesh::Elem::_children, and libMesh::libmesh_assert().

Referenced by libMesh::Elem::add_child(), libMesh::BoundaryInfo::add_elements(), libMesh::UnstructuredMesh::all_first_order(), libMesh::Elem::bracketing_nodes(), libMesh::Elem::coarsen(), libMesh::FEGenericBase< FEOutputType< T >::type >::coarsened_dof_values(), libMesh::TopologyMap::fill(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::Elem::is_child_on_edge(), libMesh::Elem::is_vertex_on_parent(), libMesh::Elem::make_links_to_me_remote(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectEdges::operator()(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectSides::operator()(), libMesh::Elem::refine(), libMesh::Elem::replace_child(), libMesh::Parallel::sync_element_data_by_parent_id(), InfFERadialTest::testRefinement(), EquationSystemsTest::testRefineThenReinitPreserveFlags(), libMesh::BoundaryInfo::transfer_boundary_ids_from_children(), libMesh::Elem::which_child_am_i(), and libMesh::CheckpointIO::write_remote_elem().

3165 {
3168 
3169  return _children[i];
3170 }
libmesh_assert(ctx)
std::unique_ptr< Elem *[]> _children
unique_ptr to array of this element&#39;s children.
Definition: elem.h:2262

◆ child_ptr() [2/2]

Elem * libMesh::Elem::child_ptr ( unsigned int  i)
inlineinherited
Returns
A non-constant pointer to the \( i^{th} \) child for this element. Do not call if this element has no children, i.e. is active.

Definition at line 3173 of file elem.h.

References libMesh::Elem::_children, and libMesh::libmesh_assert().

3174 {
3177 
3178  return _children[i];
3179 }
libmesh_assert(ctx)
std::unique_ptr< Elem *[]> _children
unique_ptr to array of this element&#39;s children.
Definition: elem.h:2262

◆ child_ref_range() [1/2]

SimpleRange< Elem::ChildRefIter > libMesh::Elem::child_ref_range ( )
inlineinherited

Returns a range with all children of a parent element, usable in range-based for loops.

The exact type of the return value here may be subject to change in future libMesh releases, but the iterators will always dereference to produce a reference to a child element.

Definition at line 2347 of file elem.h.

References libMesh::Elem::_children, libMesh::libmesh_assert(), and libMesh::Elem::n_children().

Referenced by libMesh::HPCoarsenTest::add_projection(), libMesh::Elem::ancestor(), libMesh::OldSolutionBase< Output, point_output >::check_old_context(), libMesh::Elem::coarsen(), libMesh::FEGenericBase< FEOutputType< T >::type >::coarsened_dof_values(), libMesh::connect_children(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::Elem::has_ancestor_children(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Elem >(), main(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::Elem::make_links_to_me_remote(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::Elem::max_descendant_p_level(), libMesh::Elem::min_new_p_level_by_neighbor(), libMesh::Elem::min_p_level_by_neighbor(), libMesh::Elem::set_p_level(), and libMesh::Partitioner::set_parent_processor_ids().

2348 {
2350  return {_children.get(), _children.get() + this->n_children()};
2351 }
virtual unsigned int n_children() const =0
libmesh_assert(ctx)
std::unique_ptr< Elem *[]> _children
unique_ptr to array of this element&#39;s children.
Definition: elem.h:2262

◆ child_ref_range() [2/2]

SimpleRange< Elem::ConstChildRefIter > libMesh::Elem::child_ref_range ( ) const
inlineinherited

Definition at line 2355 of file elem.h.

References libMesh::Elem::_children, libMesh::libmesh_assert(), and libMesh::Elem::n_children().

2356 {
2358  return {_children.get(), _children.get() + this->n_children()};
2359 }
virtual unsigned int n_children() const =0
libmesh_assert(ctx)
std::unique_ptr< Elem *[]> _children
unique_ptr to array of this element&#39;s children.
Definition: elem.h:2262

◆ clear_dofs()

void libMesh::DofObject::clear_dofs ( )
inlineinherited

Clear the DofMap data structures holding degree of freedom data.

If any extra integers are associated with this DofObject, their count and values are unchanged.

Definition at line 798 of file dof_object.h.

References libMesh::DofObject::set_n_systems().

799 {
800  this->set_n_systems(0);
801 }
void set_n_systems(const unsigned int s)
Sets the number of systems for this DofObject.
Definition: dof_object.C:142

◆ clear_old_dof_object()

void libMesh::DofObject::clear_old_dof_object ( )
inherited

Sets the old_dof_object to nullptr.

Definition at line 120 of file dof_object.C.

References libMesh::DofObject::old_dof_object.

Referenced by libMesh::DofObject::operator=(), libMesh::DofObject::set_old_dof_object(), and libMesh::DofObject::unpack_indexing().

121 {
122  this->old_dof_object.reset(nullptr);
123 }
std::unique_ptr< DofObject > old_dof_object
This object on the last mesh.
Definition: dof_object.h:88

◆ close_to_point()

bool libMesh::Elem::close_to_point ( const Point p,
Real  tol 
) const
virtualinherited
Returns
true if this element is "close" to the point p, where "close" is determined by the tolerance tol.

Reimplemented in libMesh::NodeElem.

Definition at line 2780 of file elem.C.

References libMesh::Elem::point_test().

Referenced by assemble_SchroedingerEquation(), libMesh::PointLocatorNanoflann::operator()(), and libMesh::PointLocatorTree::operator()().

2781 {
2782  // This test uses the user's passed-in tolerance for the
2783  // bounding box test as well, thereby allowing the routine to
2784  // find points which are not only "in" the element, but also
2785  // "nearby" to within some tolerance.
2786  return this->point_test(p, tol, tol);
2787 }
bool point_test(const Point &p, Real box_tol, Real map_tol) const
Shared private implementation used by the contains_point() and close_to_point() routines.
Definition: elem.C:2792

◆ coarsen()

void libMesh::Elem::coarsen ( )
inherited

Coarsen the element.

This function is non-virtual since it is the same for all element types.

Definition at line 163 of file elem_refinement.C.

References libMesh::Elem::active(), libMesh::TypeVector< T >::add_scaled(), libMesh::Elem::child_ptr(), libMesh::Elem::child_ref_range(), libMesh::Elem::COARSEN, libMesh::Elem::COARSEN_INACTIVE, libMesh::Elem::embedding_matrix(), libMesh::Elem::INACTIVE, libMesh::Elem::JUST_COARSENED, libMesh::libmesh_assert(), libMesh::Elem::n_children(), libMesh::Elem::n_nodes(), libMesh::Elem::node_index_range(), libMesh::Elem::point(), libMesh::Real, libMesh::Elem::refinement_flag(), libMesh::remote_elem, libMesh::Elem::set_p_level(), and libMesh::Elem::set_refinement_flag().

164 {
165  libmesh_assert_equal_to (this->refinement_flag(), Elem::COARSEN_INACTIVE);
166  libmesh_assert (!this->active());
167 
168  // We no longer delete children until MeshRefinement::contract()
169 
170  unsigned int parent_p_level = 0;
171 
172  const unsigned int n_n = this->n_nodes();
173 
174  // re-compute hanging node nodal locations
175  for (unsigned int c = 0, nc = this->n_children(); c != nc; ++c)
176  {
177  Elem * mychild = this->child_ptr(c);
178  if (mychild == remote_elem)
179  continue;
180  for (auto cnode : mychild->node_index_range())
181  {
182  Point new_pos;
183  bool calculated_new_pos = false;
184 
185  for (unsigned int n=0; n<n_n; n++)
186  {
187  // The value from the embedding matrix
188  const Real em_val = this->embedding_matrix(c,cnode,n);
189 
190  // The node location is somewhere between existing vertices
191  if ((em_val != 0.) && (em_val != 1.))
192  {
193  new_pos.add_scaled (this->point(n), em_val);
194  calculated_new_pos = true;
195  }
196  }
197 
198  if (calculated_new_pos)
199  {
200  //Move the existing node back into it's original location
201  for (unsigned int i=0; i<LIBMESH_DIM; i++)
202  {
203  Point & child_node = mychild->point(cnode);
204  child_node(i)=new_pos(i);
205  }
206  }
207  }
208  }
209 
210  for (auto & mychild : this->child_ref_range())
211  {
212  if (&mychild == remote_elem)
213  continue;
214  libmesh_assert_equal_to (mychild.refinement_flag(), Elem::COARSEN);
215  mychild.set_refinement_flag(Elem::INACTIVE);
216  if (mychild.p_level() > parent_p_level)
217  parent_p_level = mychild.p_level();
218  }
219 
221  this->set_p_level(parent_p_level);
222 
223  libmesh_assert (this->active());
224 }
void set_p_level(const unsigned int p)
Sets the value of the p-refinement level for the element.
RefinementState refinement_flag() const
Definition: elem.h:3211
void set_refinement_flag(const RefinementState rflag)
Sets the value of the refinement flag for the element.
Definition: elem.h:3219
virtual unsigned int n_children() const =0
SimpleRange< ChildRefIter > child_ref_range()
Returns a range with all children of a parent element, usable in range-based for loops.
Definition: elem.h:2347
virtual Real embedding_matrix(const unsigned int child_num, const unsigned int child_node_num, const unsigned int parent_node_num) const =0
virtual unsigned int n_nodes() const =0
libmesh_assert(ctx)
Elem(const unsigned int n_nodes, const unsigned int n_sides, Elem *parent, Elem **elemlinkdata, Node **nodelinkdata)
Constructor.
Definition: elem.h:2379
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
bool active() const
Definition: elem.h:2942
const Point & point(const unsigned int i) const
Definition: elem.h:2454
const Elem * child_ptr(unsigned int i) const
Definition: elem.h:3164
const RemoteElem * remote_elem
Definition: remote_elem.C:57

◆ complete_order_equivalent_type()

ElemType libMesh::Elem::complete_order_equivalent_type ( const ElemType  et)
staticinherited
Returns
The ElemType of the associated "complete" order element (which will be the same as the input if the input is already a complete-order ElemType), or INVALID_ELEM for elements that cannot be converted into complete-order equivalents.

The "complete" version of an element is an element which can represent the same geometry but which has nodes available to restore degrees of freedom on any vertex, edge, or face.

For example, when this is a TET4, then TET14 is returned.

Definition at line 3323 of file elem.C.

References libMesh::EDGE2, libMesh::EDGE3, libMesh::EDGE4, libMesh::Utility::enum_to_string(), libMesh::HEX20, libMesh::HEX27, libMesh::HEX8, libMesh::INFEDGE2, libMesh::INFHEX16, libMesh::INFHEX18, libMesh::INFHEX8, libMesh::INFPRISM12, libMesh::INFPRISM6, libMesh::INFQUAD4, libMesh::INFQUAD6, libMesh::NODEELEM, libMesh::PRISM15, libMesh::PRISM18, libMesh::PRISM20, libMesh::PRISM21, libMesh::PRISM6, libMesh::PYRAMID13, libMesh::PYRAMID14, libMesh::PYRAMID18, libMesh::PYRAMID5, libMesh::QUAD4, libMesh::QUAD8, libMesh::QUAD9, libMesh::QUADSHELL4, libMesh::QUADSHELL8, libMesh::QUADSHELL9, libMesh::TET10, libMesh::TET14, libMesh::TET4, libMesh::TRI3, libMesh::TRI6, libMesh::TRI7, and libMesh::TRISHELL3.

Referenced by libMesh::UnstructuredMesh::all_complete_order_range().

3324 {
3325  switch (et)
3326  {
3327  case NODEELEM:
3328  return NODEELEM;
3329  case EDGE2:
3330  case EDGE3:
3331  return EDGE3;
3332 
3333  case EDGE4:
3334  return EDGE4;
3335 
3336  case TRI3:
3337  case TRI6:
3338  case TRI7:
3339  return TRI7;
3340 
3341  // Currently there is no TRISHELL6, so similarly to other types
3342  // where this is the case, we just return the input.
3343  case TRISHELL3:
3344  return TRISHELL3;
3345 
3346  case QUAD4:
3347  case QUAD8:
3348  case QUAD9:
3349  return QUAD9;
3350 
3351  case QUADSHELL4:
3352  case QUADSHELL8:
3353  case QUADSHELL9:
3354  return QUADSHELL9;
3355 
3356  case TET4:
3357  case TET10:
3358  case TET14:
3359  return TET14;
3360 
3361  case HEX8:
3362  case HEX20:
3363  case HEX27:
3364  return HEX27;
3365 
3366  // We don't strictly need the 21st node for DoFs, but some code
3367  // depends on it for e.g. refinement patterns
3368  case PRISM6:
3369  case PRISM15:
3370  case PRISM18:
3371  case PRISM20:
3372  case PRISM21:
3373  return PRISM21;
3374 
3375  case PYRAMID5:
3376  case PYRAMID13:
3377  case PYRAMID14:
3378  case PYRAMID18:
3379  return PYRAMID18;
3380 
3381 
3382 
3383 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
3384  case INFEDGE2:
3385  return INFEDGE2;
3386 
3387  case INFQUAD4:
3388  case INFQUAD6:
3389  return INFQUAD6;
3390 
3391  case INFHEX8:
3392  case INFHEX16:
3393  case INFHEX18:
3394  return INFHEX18;
3395 
3396  // Probably ought to implement INFPRISM13 and/or 14; until then
3397  // we'll just return the not-complete-order ElemType, in
3398  // accordance which what seems like bad precedent...
3399  case INFPRISM6:
3400  case INFPRISM12:
3401  return INFPRISM12;
3402 #endif // LIBMESH_ENABLE_INFINITE_ELEMENTS
3403 
3404  default:
3405  {
3406  // what did we miss?
3407  libmesh_error_msg("No complete order equivalent element type for et = "
3408  << Utility::enum_to_string(et));
3409  }
3410  }
3411 }
std::string enum_to_string(const T e)

◆ compute_key() [1/4]

dof_id_type libMesh::Elem::compute_key ( dof_id_type  n0)
inlinestaticprotectedinherited

◆ compute_key() [2/4]

dof_id_type libMesh::Elem::compute_key ( dof_id_type  n0,
dof_id_type  n1 
)
inlinestaticprotectedinherited
Returns
A hash key computed from two node ids.

Definition at line 3303 of file elem.h.

References libMesh::Utility::hashword2().

3305 {
3306  // Order the two so that n0 < n1
3307  if (n0 > n1) std::swap (n0, n1);
3308 
3309  return Utility::hashword2(n0, n1);
3310 }
uint32_t hashword2(const uint32_t &first, const uint32_t &second, uint32_t initval=0)
This is a hard-coded version of hashword for hashing exactly 2 numbers.
Definition: hashword.h:215

◆ compute_key() [3/4]

dof_id_type libMesh::Elem::compute_key ( dof_id_type  n0,
dof_id_type  n1,
dof_id_type  n2 
)
inlinestaticprotectedinherited
Returns
A hash key computed from three node ids.

Definition at line 3315 of file elem.h.

References libMesh::Utility::hashword().

3318 {
3319  std::array<dof_id_type, 3> array = {{n0, n1, n2}};
3320  std::sort(array.begin(), array.end());
3321  return Utility::hashword(array);
3322 }
uint32_t hashword(const uint32_t *k, size_t length, uint32_t initval=0)
The hashword function takes an array of uint32_t&#39;s of length &#39;length&#39; and computes a single key from ...
Definition: hashword.h:158

◆ compute_key() [4/4]

dof_id_type libMesh::Elem::compute_key ( dof_id_type  n0,
dof_id_type  n1,
dof_id_type  n2,
dof_id_type  n3 
)
inlinestaticprotectedinherited
Returns
A hash key computed from four node ids.

Definition at line 3327 of file elem.h.

References libMesh::Utility::hashword().

3331 {
3332  std::array<dof_id_type, 4> array = {{n0, n1, n2, n3}};
3333  std::sort(array.begin(), array.end());
3334  return Utility::hashword(array);
3335 }
uint32_t hashword(const uint32_t *k, size_t length, uint32_t initval=0)
The hashword function takes an array of uint32_t&#39;s of length &#39;length&#39; and computes a single key from ...
Definition: hashword.h:158

◆ connectivity()

void libMesh::Pyramid5::connectivity ( const unsigned int  sc,
const IOPackage  iop,
std::vector< dof_id_type > &  conn 
) const
overridevirtual
Returns
The connectivity for this element in a specific format, which is specified by the IOPackage tag.

Implements libMesh::Elem.

Definition at line 192 of file cell_pyramid5.C.

References libMesh::Elem::_nodes, libMesh::INVALID_IO_PACKAGE, libMesh::libmesh_assert(), n_sub_elem(), libMesh::Elem::node_id(), libMesh::TECPLOT, and libMesh::VTK.

195 {
197  libmesh_assert_less (sc, this->n_sub_elem());
198  libmesh_assert_not_equal_to (iop, INVALID_IO_PACKAGE);
199 
200  switch (iop)
201  {
202  case TECPLOT:
203  {
204  conn.resize(8);
205  conn[0] = this->node_id(0)+1;
206  conn[1] = this->node_id(1)+1;
207  conn[2] = this->node_id(2)+1;
208  conn[3] = this->node_id(3)+1;
209  conn[4] = this->node_id(4)+1;
210  conn[5] = this->node_id(4)+1;
211  conn[6] = this->node_id(4)+1;
212  conn[7] = this->node_id(4)+1;
213  return;
214  }
215 
216  case VTK:
217  {
218  conn.resize(5);
219  conn[0] = this->node_id(3);
220  conn[1] = this->node_id(2);
221  conn[2] = this->node_id(1);
222  conn[3] = this->node_id(0);
223  conn[4] = this->node_id(4);
224  return;
225  }
226 
227  default:
228  libmesh_error_msg("Unsupported IO package " << iop);
229  }
230 }
Node ** _nodes
Pointers to the nodes we are connected to.
Definition: elem.h:2246
libmesh_assert(ctx)
virtual unsigned int n_sub_elem() const override
Definition: cell_pyramid5.h:83
dof_id_type node_id(const unsigned int i) const
Definition: elem.h:2476

◆ contains_edge_of()

bool libMesh::Elem::contains_edge_of ( const Elem e) const
inherited
Returns
true if an edge of e is contained in this element. (Internally, this is done by checking whether at least two vertices of e are contained in this element).

Definition at line 970 of file elem.C.

References libMesh::Elem::contains_point(), libMesh::make_range(), libMesh::Elem::n_vertices(), and libMesh::Elem::point().

Referenced by libMesh::Elem::find_edge_neighbors().

971 {
972  unsigned int num_contained_edges = 0;
973 
974  // Our vertices are the first numbered nodes
975  for (auto n : make_range(e->n_vertices()))
976  {
977  if (this->contains_point(e->point(n)))
978  {
979  num_contained_edges++;
980  if (num_contained_edges>=2)
981  {
982  return true;
983  }
984  }
985  }
986  return false;
987 }
virtual bool contains_point(const Point &p, Real tol=TOLERANCE) const
Definition: elem.C:2755
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140

◆ contains_point()

bool libMesh::Elem::contains_point ( const Point p,
Real  tol = TOLERANCE 
) const
virtualinherited
Returns
true if the physical point p is contained in this element, false otherwise.

For linear elements, performs an initial tight bounding box check (as an optimization step) and (if that passes) then uses the user-defined tolerance "tol" in a call to inverse_map() to actually test if the point is in the element. For quadratic elements, the bounding box optimization is skipped, and only the inverse_map() steps are performed.

Note
This routine should not be used to determine if a point is merely "nearby" an element to within some tolerance. For that, use Elem::close_to_point() instead.

Reimplemented in libMesh::NodeElem, libMesh::Tet4, libMesh::InfHex, libMesh::InfPrism, libMesh::Tri3, and libMesh::InfQuad4.

Definition at line 2755 of file elem.C.

References libMesh::err, libMesh::Elem::point_test(), and libMesh::TOLERANCE.

Referenced by libMesh::Elem::contains_edge_of(), libMesh::Elem::contains_vertex_of(), libMesh::Elem::find_edge_neighbors(), libMesh::Elem::find_point_neighbors(), libMesh::InfFE< Dim, T_radial, T_map >::inf_compute_constraints(), libMesh::PointLocatorNanoflann::operator()(), libMesh::PointLocatorTree::operator()(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), NavierSystem::side_constraint(), RationalMapTest< elem_type >::testContainsPoint(), PointLocatorTest::testLocator(), and PointLocatorTest::testPlanar().

2756 {
2757  // We currently allow the user to enlarge the bounding box by
2758  // providing a tol > TOLERANCE (so this routine is identical to
2759  // Elem::close_to_point()), but print a warning so that the
2760  // user can eventually switch his code over to calling close_to_point()
2761  // instead, which is intended to be used for this purpose.
2762  if (tol > TOLERANCE)
2763  {
2764  libmesh_do_once(libMesh::err
2765  << "WARNING: Resizing bounding box to match user-specified tolerance!\n"
2766  << "In the future, calls to Elem::contains_point() with tol > TOLERANCE\n"
2767  << "will be more optimized, but should not be used\n"
2768  << "to search for points 'close to' elements!\n"
2769  << "Instead, use Elem::close_to_point() for this purpose.\n"
2770  << std::endl;);
2771  return this->point_test(p, tol, tol);
2772  }
2773  else
2774  return this->point_test(p, TOLERANCE, tol);
2775 }
OStreamProxy err
static constexpr Real TOLERANCE
bool point_test(const Point &p, Real box_tol, Real map_tol) const
Shared private implementation used by the contains_point() and close_to_point() routines.
Definition: elem.C:2792

◆ contains_vertex_of()

bool libMesh::Elem::contains_vertex_of ( const Elem e,
bool  mesh_connection = false 
) const
inherited
Returns
true if a vertex of e is contained in this element. If mesh_connection is true, looks specifically for containment possibilities of an element e that is connected to this via membership in the same manifold of the same mesh.

Definition at line 932 of file elem.C.

References libMesh::Elem::contains_point(), libMesh::Elem::level(), libMesh::make_range(), libMesh::Elem::n_vertices(), libMesh::Elem::node_ptr(), libMesh::Elem::node_ref(), and libMesh::Elem::point().

933 {
934  // Our vertices are the first numbered nodes
935  const unsigned int nv = e->n_vertices();
936  const unsigned int my_nv = this->n_vertices();
937 
938  // Check for vertex-to-vertex containment first; contains_point() is
939  // expensive
940  for (auto n : make_range(nv))
941  {
942  const Node * vertex = e->node_ptr(n);
943  for (auto my_n : make_range(my_nv))
944  if (&this->node_ref(my_n) == vertex)
945  return true;
946  }
947 
948  // If e is in our mesh, then we might be done testing
949  if (mesh_connection)
950  {
951  const unsigned int l = this->level();
952  const unsigned int el = e->level();
953 
954  if (l >= el)
955  return false;
956 
957  // We could also return false for l==el-1 iff we knew we had no
958  // triangular faces, but we don't have an API to check that.
959  }
960 
961  // Our vertices are the first numbered nodes
962  for (auto n : make_range(nv))
963  if (this->contains_point(e->point(n)))
964  return true;
965  return false;
966 }
virtual bool contains_point(const Point &p, Real tol=TOLERANCE) const
Definition: elem.C:2755
const Node & node_ref(const unsigned int i) const
Definition: elem.h:2530
unsigned int level() const
Definition: elem.h:3075
virtual unsigned int n_vertices() const =0
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140

◆ contract()

void libMesh::Elem::contract ( )
inherited

Contract an active element, i.e.

remove pointers to any subactive children. This should only be called via MeshRefinement::contract, which will also remove subactive children from the mesh.

Definition at line 228 of file elem_refinement.C.

References libMesh::Elem::_children, libMesh::Elem::active(), libMesh::Elem::DO_NOTHING, libMesh::Elem::JUST_COARSENED, libMesh::libmesh_assert(), libMesh::Elem::refinement_flag(), and libMesh::Elem::set_refinement_flag().

229 {
230  // Subactive elements get deleted entirely, not contracted
231  libmesh_assert (this->active());
232 
233  // Active contracted elements no longer can have children
234  _children.reset(nullptr);
235 
236  if (this->refinement_flag() == Elem::JUST_COARSENED)
238 }
RefinementState refinement_flag() const
Definition: elem.h:3211
void set_refinement_flag(const RefinementState rflag)
Sets the value of the refinement flag for the element.
Definition: elem.h:3219
libmesh_assert(ctx)
bool active() const
Definition: elem.h:2942
std::unique_ptr< Elem *[]> _children
unique_ptr to array of this element&#39;s children.
Definition: elem.h:2262

◆ debug_buffer()

void libMesh::DofObject::debug_buffer ( ) const
inherited

Print our buffer for debugging.

Definition at line 652 of file dof_object.C.

References libMesh::DofObject::_idx_buf, libMesh::MeshTools::Generation::Private::idx(), and libMesh::out.

653 {
654  libMesh::out << " [ ";
655  for (const auto & idx : _idx_buf)
656  libMesh::out << idx << " ";
657  libMesh::out << "]\n";
658 }
OStreamProxy out
index_buffer_t _idx_buf
Definition: dof_object.h:680
unsigned int idx(const ElemType type, const unsigned int nx, const unsigned int i, const unsigned int j)
A useful inline function which replaces the macros used previously.

◆ default_order()

Order libMesh::Pyramid5::default_order ( ) const
overridevirtual
Returns
FIRST.

Implements libMesh::Elem.

Definition at line 124 of file cell_pyramid5.C.

References libMesh::FIRST.

125 {
126  return FIRST;
127 }

◆ default_side_order()

virtual Order libMesh::Elem::default_side_order ( ) const
inlinevirtualinherited
Returns
The default approximation order for side elements of this element type. This may be lower for elements with 'bubble functions' in the Lagrange basis.

Reimplemented in libMesh::Tri7.

Definition at line 1013 of file elem.h.

References libMesh::Elem::default_order().

Referenced by libMesh::FEAbstract::compute_node_constraints(), and libMesh::FEAbstract::compute_periodic_node_constraints().

1013 { return default_order(); }
virtual Order default_order() const =0

◆ dim()

virtual unsigned short libMesh::Cell::dim ( ) const
inlineoverridevirtualinherited
Returns
3, the dimensionality of the object.

Implements libMesh::Elem.

Definition at line 61 of file cell.h.

61 { return 3; }

◆ disable_print_counter_info() [1/2]

void libMesh::ReferenceCounter::disable_print_counter_info ( )
staticinherited

Definition at line 100 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

101 {
102  _enable_print_counter = false;
103  return;
104 }
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called...

◆ disable_print_counter_info() [2/2]

void libMesh::ReferenceCounter::disable_print_counter_info ( )
staticinherited

Definition at line 100 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

101 {
102  _enable_print_counter = false;
103  return;
104 }
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called...

◆ disconnected_clone()

std::unique_ptr< Elem > libMesh::Elem::disconnected_clone ( ) const
virtualinherited
Returns
An Elem of the same type as this, wrapped in a smart pointer.

This is not a complete clone() method (since e.g. it does not set node pointers; the standard use case reassigns node pointers from a different mesh), but it is necessary to use this instead of build() for runtime-polymorphic elements like Polygon subtypes whose "type" depends on more than their type(), and it is useful to use this for elements whose id, unique_id, extra integers, etc. should be preserved in the near-clone.

Reimplemented in libMesh::C0Polyhedron.

Definition at line 410 of file elem.C.

References libMesh::Elem::build(), libMesh::C0POLYGON, libMesh::DofObject::id(), libMesh::DofObject::n_extra_integers(), libMesh::Elem::n_sides(), libMesh::Elem::type(), libMesh::DofObject::unique_id(), and libMesh::DofObject::valid_unique_id().

Referenced by libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::Polyhedron::side_clones(), libMesh::Polyhedron::side_ptr(), and libMesh::Elem::true_centroid().

411 {
412  std::unique_ptr<Elem> returnval;
413 
414  switch (this->type())
415  {
416  case C0POLYGON:
417  returnval = std::make_unique<C0Polygon>(this->n_sides());
418  break;
419 
420  default:
421  returnval = Elem::build(this->type());
422  }
423 
424  returnval->set_id() = this->id();
425 #ifdef LIBMESH_ENABLE_UNIQUE_ID
426  if (this->valid_unique_id())
427  returnval->set_unique_id(this->unique_id());
428 #endif
429 
430  const auto n_elem_ints = this->n_extra_integers();
431  returnval->add_extra_integers(n_elem_ints);
432  for (unsigned int i = 0; i != n_elem_ints; ++i)
433  returnval->set_extra_integer(i, this->get_extra_integer(i));
434 
435  returnval->inherit_data_from(*this);
436 
437  return returnval;
438 }
unique_id_type unique_id() const
Definition: dof_object.h:844
dof_id_type id() const
Definition: dof_object.h:828
static std::unique_ptr< Elem > build(const ElemType type, Elem *p=nullptr)
Definition: elem.C:442
bool valid_unique_id() const
Definition: dof_object.h:893
virtual unsigned int n_sides() const =0
unsigned int n_extra_integers() const
Returns how many extra integers are associated to the DofObject.
Definition: dof_object.h:1170
virtual ElemType type() const =0

◆ dof_number() [1/2]

dof_id_type libMesh::DofObject::dof_number ( const unsigned int  s,
const unsigned int  var,
const unsigned int  comp 
) const
inlineinherited
Returns
The global degree of freedom number for variable var, component comp for system s associated with this DofObject

When partitioning and DoF numbering have been performed by libMesh, every current DoF on this DofObject will belong to its processor.

Definition at line 1032 of file dof_object.h.

References libMesh::DofObject::n_comp(), libMesh::DofObject::n_comp_group(), libMesh::DofObject::n_systems(), libMesh::DofObject::n_vars(), and libMesh::DofObject::var_to_vg_and_offset().

Referenced by libMesh::DofMap::_dof_indices(), libMesh::DofMap::_node_dof_indices(), libMesh::DofMap::allgather_recursive_constraints(), assemble_matrix_and_rhs(), assemble_shell(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), libMesh::VariationalSmootherConstraint::constrain_node_to_line(), libMesh::VariationalSmootherConstraint::constrain_node_to_plane(), libMesh::DofMap::constrain_p_dofs(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::Nemesis_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::Nemesis_IO::copy_nodal_solution(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::dof_indices(), libMesh::DofObject::DofObject(), libMesh::OldSolutionCoefs< Output, point_output >::eval_at_node(), libMesh::OldSolutionValue< Output, point_output >::eval_at_node(), libMesh::OldSolutionCoefs< Output, point_output >::eval_mixed_derivatives(), libMesh::OldSolutionValue< Output, point_output >::eval_mixed_derivatives(), libMesh::OldSolutionCoefs< Output, point_output >::eval_old_dofs(), libMesh::OldSolutionValue< Output, point_output >::eval_old_dofs(), fill_dirichlet_bc(), libMesh::VariationalSmootherConstraint::fix_node(), libMesh::Node::get_info(), libMesh::Elem::get_info(), libMesh::DofMap::local_variable_indices(), main(), libMesh::DofMap::old_dof_indices(), libMesh::BuildProjectionList::operator()(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectVertices::operator()(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectEdges::operator()(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectSides::operator()(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectInteriors::operator()(), libMesh::DofObject::operator=(), libMesh::DofObject::print_dof_info(), libMesh::DofMap::process_mesh_constraint_rows(), LinearElasticityWithContact::residual_and_jacobian(), libMesh::HPCoarsenTest::select_refinement(), libMesh::DofObject::set_dof_number(), libMesh::DofMap::set_nonlocal_dof_objects(), ParsedFEMFunctionTest::setUp(), DofObjectTest< Node >::testJensEftangBug(), DofObjectTest< Node >::testManualDofCalculation(), libMesh::BoundaryVolumeSolutionTransfer::transfer_boundary_volume(), libMesh::DTKAdapter::update_variable_values(), and libMesh::Nemesis_IO_Helper::write_nodal_solution().

1035 {
1036  libmesh_assert_less (s, this->n_systems());
1037  libmesh_assert_less (var, this->n_vars(s));
1038  libmesh_assert_less (comp, this->n_comp(s,var));
1039 
1040  const std::pair<unsigned int, unsigned int>
1041  vg_vig = this->var_to_vg_and_offset(s,var);
1042 
1043  const unsigned int
1044  n_comp = this->n_comp_group(s,vg_vig.first);
1045 
1046  return this->dof_number(s, vg_vig.first, vg_vig.second,
1047  comp, n_comp);
1048 }
dof_id_type dof_number(const unsigned int s, const unsigned int var, const unsigned int comp) const
Definition: dof_object.h:1032
unsigned int n_comp(const unsigned int s, const unsigned int var) const
Definition: dof_object.h:1002
unsigned int n_vars(const unsigned int s, const unsigned int vg) const
Definition: dof_object.h:967
unsigned int n_systems() const
Definition: dof_object.h:937
std::pair< unsigned int, unsigned int > var_to_vg_and_offset(const unsigned int s, const unsigned int var) const
Definition: dof_object.h:1200
unsigned int n_comp_group(const unsigned int s, const unsigned int vg) const
Definition: dof_object.h:1015

◆ dof_number() [2/2]

dof_id_type libMesh::DofObject::dof_number ( const unsigned int  s,
const unsigned int  vg,
const unsigned int  vig,
const unsigned int  comp,
const unsigned int  n_comp 
) const
inlineinherited
Returns
The global degree of freedom number for variable group vg, variable index vig within the group, component comp out of n_comp, for system s on this DofObject

Even users who need to call dof_number from user code probably don't want to call this overload.

Definition at line 1053 of file dof_object.h.

References libMesh::DofObject::_idx_buf, libMesh::DofObject::invalid_id, libMesh::DofObject::n_comp(), libMesh::DofObject::n_systems(), libMesh::DofObject::n_var_groups(), libMesh::DofObject::n_vars(), and libMesh::DofObject::start_idx().

1058 {
1059  libmesh_assert_less (s, this->n_systems());
1060  libmesh_assert_less (vg, this->n_var_groups(s));
1061  libmesh_assert_less (vig, this->n_vars(s,vg));
1062 
1063  const unsigned int
1064  start_idx_sys = this->start_idx(s);
1065 
1066  libmesh_assert_less ((start_idx_sys + 2*vg + 1), _idx_buf.size());
1067 
1068  const dof_id_type
1069  base_idx = _idx_buf[start_idx_sys + 2*vg + 1];
1070 
1071  // if the first component is invalid, they
1072  // are all invalid
1073  if (base_idx == invalid_id)
1074  return invalid_id;
1075 
1076  // otherwise the index is the first component
1077  // index augmented by the component number
1078  else
1079  return cast_int<dof_id_type>(base_idx + vig*n_comp + comp);
1080 }
unsigned int n_comp(const unsigned int s, const unsigned int var) const
Definition: dof_object.h:1002
unsigned int n_var_groups(const unsigned int s) const
Definition: dof_object.h:957
static constexpr dof_id_type invalid_id
An invalid id to distinguish an uninitialized DofObject.
Definition: dof_object.h:482
unsigned int n_vars(const unsigned int s, const unsigned int vg) const
Definition: dof_object.h:967
unsigned int n_systems() const
Definition: dof_object.h:937
unsigned int start_idx(const unsigned int s) const
The starting index for system s.
Definition: dof_object.h:1249
index_buffer_t _idx_buf
Definition: dof_object.h:680
uint8_t dof_id_type
Definition: id_types.h:67

◆ edge_index_range()

IntRange< unsigned short > libMesh::Elem::edge_index_range ( ) const
inlineinherited
Returns
An integer range from 0 up to (but not including) the number of edges this element has.

Definition at line 2693 of file elem.h.

References libMesh::Elem::n_edges().

Referenced by libMesh::FE< Dim, LAGRANGE_VEC >::cache(), libMesh::FEGenericBase< FEOutputType< T >::type >::coarsened_dof_values(), libMesh::BoundaryInfo::copy_boundary_ids(), libMesh::ElemCutter::find_intersection_points(), and libMesh::Elem::quality().

2694 {
2695  return {0, cast_int<unsigned short>(this->n_edges())};
2696 }
virtual unsigned int n_edges() const =0

◆ edges_adjacent_to_node()

std::vector< unsigned int > libMesh::Pyramid::edges_adjacent_to_node ( const unsigned int  int) const
overridevirtualinherited
Returns
the (local) edge numbers that touch the specified node

Implements libMesh::Elem.

Definition at line 278 of file cell_pyramid.C.

References libMesh::Pyramid::adjacent_edges_map, libMesh::Elem::is_edge(), libMesh::Elem::is_face(), libMesh::Elem::is_vertex(), libMesh::libmesh_assert(), libMesh::Pyramid::n_nodes(), and libMesh::Pyramid::n_vertices().

279 {
280  libmesh_assert_less(n, this->n_nodes());
281  if (this->is_vertex(n))
282  {
283  auto trim = (n < 4) ? 1 : 0;
284  return {std::begin(adjacent_edges_map[n]), std::end(adjacent_edges_map[n]) - trim};
285  }
286  else if (this->is_edge(n))
287  return {n - this->n_vertices()};
288 
289  // Not a vertex or edge node, so must be one of the face nodes.
290  libmesh_assert(this->is_face(n));
291  return {};
292 }
virtual bool is_face(const unsigned int i) const =0
virtual unsigned int n_vertices() const override
Definition: cell_pyramid.h:95
libmesh_assert(ctx)
virtual unsigned int n_nodes() const override
Definition: cell_pyramid.h:85
virtual bool is_vertex(const unsigned int i) const =0
static const unsigned int adjacent_edges_map[5][4]
This maps the node to the 3 or 4 edge ids adjacent to the node.
Definition: cell_pyramid.h:235
virtual bool is_edge(const unsigned int i) const =0

◆ embedding_matrix()

virtual Real libMesh::Pyramid5::embedding_matrix ( const unsigned int  ,
const unsigned int  ,
const unsigned int   
) const
inlineoverrideprotectedvirtual

Matrix used to create the elements children.

Implements libMesh::Elem.

Definition at line 216 of file cell_pyramid5.h.

219  { libmesh_not_implemented(); return 0.; }

◆ embedding_matrix_version()

virtual unsigned int libMesh::Elem::embedding_matrix_version ( ) const
inlinevirtualinherited
Returns
A "version number" that identifies which embedding matrix is in use.

Some element types may use a different embedding matrix depending on their geometric characteristics.

Reimplemented in libMesh::Tet.

Definition at line 2052 of file elem.h.

Referenced by libMesh::Elem::as_parent_node(), and libMesh::Elem::parent_bracketing_nodes().

2052 { return 0; }

◆ enable_print_counter_info() [1/2]

void libMesh::ReferenceCounter::enable_print_counter_info ( )
staticinherited

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

Definition at line 94 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

95 {
96  _enable_print_counter = true;
97  return;
98 }
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called...

◆ enable_print_counter_info() [2/2]

void libMesh::ReferenceCounter::enable_print_counter_info ( )
staticinherited

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

Definition at line 94 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

95 {
96  _enable_print_counter = true;
97  return;
98 }
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called...

◆ face_index_range()

IntRange< unsigned short > libMesh::Elem::face_index_range ( ) const
inlineinherited
Returns
An integer range from 0 up to (but not including) the number of faces this element has.

Definition at line 2702 of file elem.h.

References libMesh::Elem::n_faces().

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

2703 {
2704  return {0, cast_int<unsigned short>(this->n_faces())};
2705 }
virtual unsigned int n_faces() const =0

◆ family_tree() [1/2]

void libMesh::Elem::family_tree ( std::vector< const Elem *> &  family,
bool  reset = true 
) const
inherited

Fills the vector family with the children of this element, recursively.

Calling this method on a twice-refined element will give you the element itself, its direct children, and their children, etc... When the optional parameter reset is true, the vector will be cleared before the element and its descendants are added.

The family tree only includes ancestor and active elements. To include subactive elements as well, use total_family_tree().

Definition at line 2099 of file elem.C.

References libMesh::ElemInternal::family_tree().

2101 {
2102  ElemInternal::family_tree(this, family, reset);
2103 }
void family_tree(T elem, std::vector< T > &family, bool reset=true)
Definition: elem_internal.h:41

◆ family_tree() [2/2]

void libMesh::Elem::family_tree ( std::vector< Elem *> &  family,
bool  reset = true 
)
inherited

Non-const version of function above; fills a vector of non-const pointers.

Definition at line 2107 of file elem.C.

References libMesh::ElemInternal::family_tree().

2109 {
2110  ElemInternal::family_tree(this, family, reset);
2111 }
void family_tree(T elem, std::vector< T > &family, bool reset=true)
Definition: elem_internal.h:41

◆ family_tree_by_neighbor() [1/2]

void libMesh::Elem::family_tree_by_neighbor ( std::vector< const Elem *> &  family,
const Elem neighbor,
bool  reset = true 
) const
inherited

Same as the family_tree() member, but only adds elements which are next to neighbor.

Definition at line 2183 of file elem.C.

References libMesh::ElemInternal::family_tree_by_neighbor().

2186 {
2187  ElemInternal::family_tree_by_neighbor(this, family, neighbor, reset);
2188 }
void family_tree_by_neighbor(T elem, std::vector< T > &family, T neighbor_in, bool reset=true)

◆ family_tree_by_neighbor() [2/2]

void libMesh::Elem::family_tree_by_neighbor ( std::vector< Elem *> &  family,
Elem neighbor,
bool  reset = true 
)
inherited

Non-const version of function above; fills a vector of non-const pointers.

Definition at line 2192 of file elem.C.

References libMesh::ElemInternal::family_tree_by_neighbor().

2195 {
2196  ElemInternal::family_tree_by_neighbor(this, family, neighbor, reset);
2197 }
void family_tree_by_neighbor(T elem, std::vector< T > &family, T neighbor_in, bool reset=true)

◆ family_tree_by_side() [1/2]

void libMesh::Elem::family_tree_by_side ( std::vector< const Elem *> &  family,
unsigned int  side,
bool  reset = true 
) const
inherited

Same as the family_tree() member, but only adds elements which are next to side.

Definition at line 2147 of file elem.C.

References libMesh::ElemInternal::family_tree_by_side().

Referenced by libMesh::Elem::make_links_to_me_local().

2150 {
2151  ElemInternal::family_tree_by_side(this, family, side, reset);
2152 }
void family_tree_by_side(T elem, std::vector< T > &family, unsigned int s, bool reset)

◆ family_tree_by_side() [2/2]

void libMesh::Elem::family_tree_by_side ( std::vector< Elem *> &  family,
unsigned int  side,
bool  reset = true 
)
inherited

Non-const version of function above; fills a vector of non-const pointers.

Definition at line 2156 of file elem.C.

References libMesh::ElemInternal::family_tree_by_side().

2159 {
2160  ElemInternal::family_tree_by_side(this, family, side, reset);
2161 }
void family_tree_by_side(T elem, std::vector< T > &family, unsigned int s, bool reset)

◆ family_tree_by_subneighbor() [1/2]

void libMesh::Elem::family_tree_by_subneighbor ( std::vector< const Elem *> &  family,
const Elem neighbor,
const Elem subneighbor,
bool  reset = true 
) const
inherited

Same as the family_tree() member, but only adds elements which are next to subneighbor.

Only applicable when this->has_neighbor(neighbor) and neighbor->is_ancestor(subneighbor)

Definition at line 2219 of file elem.C.

References libMesh::ElemInternal::family_tree_by_subneighbor().

2223 {
2224  ElemInternal::family_tree_by_subneighbor(this, family, neighbor, subneighbor, reset);
2225 }
void family_tree_by_subneighbor(T elem, std::vector< T > &family, T neighbor_in, T subneighbor, bool reset=true)

◆ family_tree_by_subneighbor() [2/2]

void libMesh::Elem::family_tree_by_subneighbor ( std::vector< Elem *> &  family,
Elem neighbor,
Elem subneighbor,
bool  reset = true 
)
inherited

Non-const version of function above; fills a vector of non-const pointers.

Definition at line 2229 of file elem.C.

References libMesh::ElemInternal::family_tree_by_subneighbor().

2233 {
2234  ElemInternal::family_tree_by_subneighbor(this, family, neighbor, subneighbor, reset);
2235 }
void family_tree_by_subneighbor(T elem, std::vector< T > &family, T neighbor_in, T subneighbor, bool reset=true)

◆ find_edge_neighbors() [1/2]

void libMesh::Elem::find_edge_neighbors ( const Point p1,
const Point p2,
std::set< const Elem *> &  neighbor_set 
) const
inherited

This function finds all active elements in the same manifold as this element which touch the current active element along the whole edge defined by the two points p1 and p2.

Definition at line 1081 of file elem.C.

References libMesh::Elem::contains_point(), libMesh::Elem::find_point_neighbors(), and libMesh::libmesh_assert().

Referenced by libMesh::MeshRefinement::enforce_mismatch_limit_prior_to_refinement().

1084 {
1085  // Simple but perhaps suboptimal code: find elements containing the
1086  // first point, then winnow this set down by removing elements which
1087  // don't also contain the second point
1088 
1089  libmesh_assert(this->contains_point(p2));
1090  this->find_point_neighbors(p1, neighbor_set);
1091 
1092  std::set<const Elem *>::iterator it = neighbor_set.begin();
1093  const std::set<const Elem *>::iterator end = neighbor_set.end();
1094 
1095  while (it != end)
1096  {
1097  // As of C++11, set::erase returns an iterator to the element
1098  // following the erased element, or end.
1099  if (!(*it)->contains_point(p2))
1100  it = neighbor_set.erase(it);
1101  else
1102  ++it;
1103  }
1104 }
virtual bool contains_point(const Point &p, Real tol=TOLERANCE) const
Definition: elem.C:2755
void find_point_neighbors(const Point &p, std::set< const Elem *> &neighbor_set) const
This function finds all active elements (including this one) which are in the same manifold as this e...
Definition: elem.C:991
libmesh_assert(ctx)

◆ find_edge_neighbors() [2/2]

void libMesh::Elem::find_edge_neighbors ( std::set< const Elem *> &  neighbor_set) const
inherited

This function finds all active elements in the same manifold as this element which touch the current active element along any edge (more precisely, at at least two points).

In this case, elements are included even if they do not touch a whole edge of this element.

Definition at line 1108 of file elem.C.

References libMesh::Elem::contains_edge_of(), and libMesh::remote_elem.

1109 {
1110  neighbor_set.clear();
1111  neighbor_set.insert(this);
1112 
1113  std::set<const Elem *> untested_set, next_untested_set;
1114  untested_set.insert(this);
1115 
1116  while (!untested_set.empty())
1117  {
1118  // Loop over all the elements in the patch that haven't already
1119  // been tested
1120  for (const auto & elem : untested_set)
1121  {
1122  for (auto current_neighbor : elem->neighbor_ptr_range())
1123  {
1124  if (current_neighbor &&
1125  current_neighbor != remote_elem) // we have a real neighbor on this side
1126  {
1127  if (current_neighbor->active()) // ... if it is active
1128  {
1129  if (this->contains_edge_of(current_neighbor) // ... and touches us
1130  || current_neighbor->contains_edge_of(this))
1131  {
1132  // Make sure we'll test it
1133  if (!neighbor_set.count(current_neighbor))
1134  next_untested_set.insert (current_neighbor);
1135 
1136  // And add it
1137  neighbor_set.insert (current_neighbor);
1138  }
1139  }
1140 #ifdef LIBMESH_ENABLE_AMR
1141  else // ... the neighbor is *not* active,
1142  { // ... so add *all* neighboring
1143  // active children
1144  std::vector<const Elem *> active_neighbor_children;
1145 
1146  current_neighbor->active_family_tree_by_neighbor
1147  (active_neighbor_children, elem);
1148 
1149  for (const auto & current_child : active_neighbor_children)
1150  if (this->contains_edge_of(current_child) || current_child->contains_edge_of(this))
1151  {
1152  // Make sure we'll test it
1153  if (!neighbor_set.count(current_child))
1154  next_untested_set.insert (current_child);
1155 
1156  neighbor_set.insert (current_child);
1157  }
1158  }
1159 #endif // #ifdef LIBMESH_ENABLE_AMR
1160  }
1161  }
1162  }
1163  untested_set.swap(next_untested_set);
1164  next_untested_set.clear();
1165  }
1166 }
bool contains_edge_of(const Elem *e) const
Definition: elem.C:970
const RemoteElem * remote_elem
Definition: remote_elem.C:57

◆ find_interior_neighbors() [1/2]

void libMesh::Elem::find_interior_neighbors ( std::set< const Elem *> &  neighbor_set) const
inherited

This function finds all active elements (not including this one) in the parent manifold of this element whose intersection with this element has non-zero measure.

Definition at line 1170 of file elem.C.

References libMesh::ElemInternal::find_interior_neighbors().

1171 {
1172  ElemInternal::find_interior_neighbors(this, neighbor_set);
1173 }
void find_interior_neighbors(T this_elem, std::set< T > &neighbor_set)

◆ find_interior_neighbors() [2/2]

void libMesh::Elem::find_interior_neighbors ( std::set< Elem *> &  neighbor_set)
inherited

Non-const version of function above that fills up a vector of non-const Elem pointers instead.

Definition at line 1177 of file elem.C.

References libMesh::ElemInternal::find_interior_neighbors().

1178 {
1179  ElemInternal::find_interior_neighbors(this, neighbor_set);
1180 }
void find_interior_neighbors(T this_elem, std::set< T > &neighbor_set)

◆ find_point_neighbors() [1/4]

void libMesh::Elem::find_point_neighbors ( const Point p,
std::set< const Elem *> &  neighbor_set 
) const
inherited

This function finds all active elements (including this one) which are in the same manifold as this element and which touch the current active element at the specified point, which should be a point in the current element.

Elements which are not "in the same manifold" (e.g. the interior_parent of a boundary element) will not be found with this method.

Elements which overlap the specified point but which are only connected to the current element via elements which do not overlap that point (e.g. in a folded or tangled mesh) are not considered to "touch" the current element and will not be found with this method.

Definition at line 991 of file elem.C.

References libMesh::Elem::active(), libMesh::Elem::contains_point(), libMesh::libmesh_assert(), and libMesh::remote_elem.

Referenced by libMesh::MeshFunction::check_found_elem(), libMesh::MeshRefinement::enforce_mismatch_limit_prior_to_refinement(), libMesh::Elem::find_edge_neighbors(), libMesh::Elem::find_point_neighbors(), libMesh::ReplicatedMesh::get_boundary_points(), libMesh::Elem::is_semilocal(), libMesh::GhostPointNeighbors::operator()(), and InfFERadialTest::testRefinement().

993 {
994  libmesh_assert(this->contains_point(p));
995  libmesh_assert(this->active());
996 
997  neighbor_set.clear();
998  neighbor_set.insert(this);
999 
1000  std::set<const Elem *> untested_set, next_untested_set;
1001  untested_set.insert(this);
1002 
1003 #ifdef LIBMESH_ENABLE_AMR
1004  std::vector<const Elem *> active_neighbor_children;
1005 #endif // #ifdef LIBMESH_ENABLE_AMR
1006 
1007  while (!untested_set.empty())
1008  {
1009  // Loop over all the elements in the patch that haven't already
1010  // been tested
1011  for (const auto & elem : untested_set)
1012  for (auto current_neighbor : elem->neighbor_ptr_range())
1013  {
1014  if (current_neighbor &&
1015  current_neighbor != remote_elem) // we have a real neighbor on this side
1016  {
1017  if (current_neighbor->active()) // ... if it is active
1018  {
1019  auto it = neighbor_set.lower_bound(current_neighbor);
1020  if ((it == neighbor_set.end() || *it != current_neighbor) &&
1021  current_neighbor->contains_point(p)) // ... don't have and touches p
1022  {
1023  // Add it and test it
1024  next_untested_set.insert(current_neighbor);
1025  neighbor_set.emplace_hint(it, current_neighbor);
1026  }
1027  }
1028 #ifdef LIBMESH_ENABLE_AMR
1029  else // ... the neighbor is *not* active,
1030  { // ... so add *all* neighboring
1031  // active children that touch p
1032  active_neighbor_children.clear();
1033  current_neighbor->active_family_tree_by_neighbor
1034  (active_neighbor_children, elem);
1035 
1036  for (const auto & current_child : active_neighbor_children)
1037  {
1038  auto it = neighbor_set.lower_bound(current_child);
1039  if ((it == neighbor_set.end() || *it != current_child) &&
1040  current_child->contains_point(p))
1041  {
1042  // Add it and test it
1043  next_untested_set.insert(current_child);
1044  neighbor_set.emplace_hint(it, current_child);
1045  }
1046  }
1047  }
1048 #endif // #ifdef LIBMESH_ENABLE_AMR
1049  }
1050  }
1051  untested_set.swap(next_untested_set);
1052  next_untested_set.clear();
1053  }
1054 }
virtual bool contains_point(const Point &p, Real tol=TOLERANCE) const
Definition: elem.C:2755
libmesh_assert(ctx)
bool active() const
Definition: elem.h:2942
const RemoteElem * remote_elem
Definition: remote_elem.C:57

◆ find_point_neighbors() [2/4]

void libMesh::Elem::find_point_neighbors ( std::set< const Elem *> &  neighbor_set) const
inherited

This function finds all active elements (including this one) in the same manifold as this element which touch this active element at any point.

Definition at line 1058 of file elem.C.

References libMesh::Elem::find_point_neighbors().

1059 {
1060  this->find_point_neighbors(neighbor_set, this);
1061 }
void find_point_neighbors(const Point &p, std::set< const Elem *> &neighbor_set) const
This function finds all active elements (including this one) which are in the same manifold as this e...
Definition: elem.C:991

◆ find_point_neighbors() [3/4]

void libMesh::Elem::find_point_neighbors ( std::set< const Elem *> &  neighbor_set,
const Elem start_elem 
) const
inherited

This function finds all active elements (including this one) in the same manifold as start_elem (which must be active and must touch this element) which touch this element at any point.

Definition at line 1065 of file elem.C.

References libMesh::ElemInternal::find_point_neighbors().

1067 {
1068  ElemInternal::find_point_neighbors(this, neighbor_set, start_elem);
1069 }
void find_point_neighbors(T this_elem, std::set< T > &neighbor_set, T start_elem)

◆ find_point_neighbors() [4/4]

void libMesh::Elem::find_point_neighbors ( std::set< Elem *> &  neighbor_set,
Elem start_elem 
)
inherited

Non-const version of function above.

Fills a set of non-const Elem pointers.

Definition at line 1073 of file elem.C.

References libMesh::ElemInternal::find_point_neighbors().

1075 {
1076  ElemInternal::find_point_neighbors(this, neighbor_set, start_elem);
1077 }
void find_point_neighbors(T this_elem, std::set< T > &neighbor_set, T start_elem)

◆ first_order_equivalent_type()

ElemType libMesh::Elem::first_order_equivalent_type ( const ElemType  et)
staticinherited
Returns
The element type of the associated first-order element, or INVALID_ELEM for first-order or other elements that cannot be converted into lower order equivalents.

For example, when this is a TET10, then TET4 is returned.

Definition at line 3070 of file elem.C.

References libMesh::EDGE2, libMesh::EDGE3, libMesh::EDGE4, libMesh::HEX20, libMesh::HEX27, libMesh::HEX8, libMesh::INFEDGE2, libMesh::INFHEX16, libMesh::INFHEX18, libMesh::INFHEX8, libMesh::INFPRISM12, libMesh::INFPRISM6, libMesh::INFQUAD4, libMesh::INFQUAD6, libMesh::INVALID_ELEM, libMesh::NODEELEM, libMesh::PRISM15, libMesh::PRISM18, libMesh::PRISM20, libMesh::PRISM21, libMesh::PRISM6, libMesh::PYRAMID13, libMesh::PYRAMID14, libMesh::PYRAMID18, libMesh::PYRAMID5, libMesh::QUAD4, libMesh::QUAD8, libMesh::QUAD9, libMesh::QUADSHELL4, libMesh::QUADSHELL8, libMesh::QUADSHELL9, libMesh::TET10, libMesh::TET14, libMesh::TET4, libMesh::TRI3, libMesh::TRI6, libMesh::TRI7, and libMesh::TRISHELL3.

Referenced by libMesh::UnstructuredMesh::all_first_order(), libMesh::ExodusII_IO_Helper::read_edge_blocks(), SideTest< ElemClass, side_type, indexbegin, indexend >::testSidePtr(), SideTest< ElemClass, side_type, indexbegin, indexend >::testSidePtrFill(), and libMesh::GMVIO::write_ascii_old_impl().

3071 {
3072  switch (et)
3073  {
3074  case NODEELEM:
3075  return NODEELEM;
3076  case EDGE2:
3077  case EDGE3:
3078  case EDGE4:
3079  return EDGE2;
3080  case TRI3:
3081  case TRI6:
3082  case TRI7:
3083  return TRI3;
3084  case TRISHELL3:
3085  return TRISHELL3;
3086  case QUAD4:
3087  case QUAD8:
3088  case QUAD9:
3089  return QUAD4;
3090  case QUADSHELL4:
3091  case QUADSHELL8:
3092  case QUADSHELL9:
3093  return QUADSHELL4;
3094  case TET4:
3095  case TET10:
3096  case TET14:
3097  return TET4;
3098  case HEX8:
3099  case HEX27:
3100  case HEX20:
3101  return HEX8;
3102  case PRISM6:
3103  case PRISM15:
3104  case PRISM18:
3105  case PRISM20:
3106  case PRISM21:
3107  return PRISM6;
3108  case PYRAMID5:
3109  case PYRAMID13:
3110  case PYRAMID14:
3111  case PYRAMID18:
3112  return PYRAMID5;
3113 
3114 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
3115 
3116  case INFEDGE2:
3117  return INFEDGE2;
3118  case INFQUAD4:
3119  case INFQUAD6:
3120  return INFQUAD4;
3121  case INFHEX8:
3122  case INFHEX16:
3123  case INFHEX18:
3124  return INFHEX8;
3125  case INFPRISM6:
3126  case INFPRISM12:
3127  return INFPRISM6;
3128 
3129 #endif
3130 
3131  default:
3132  // unknown element
3133  return INVALID_ELEM;
3134  }
3135 }

◆ flip()

void libMesh::Pyramid5::flip ( BoundaryInfo boundary_info)
finaloverridevirtual

Flips the element (by swapping node and neighbor pointers) to have a mapping Jacobian of opposite sign.

This is useful for automatically fixing up elements that have been newly created (e.g. from extrusions) with a negative Jacobian.

If boundary_info is not null, swap boundary side/edge ids consistently.

Implements libMesh::Elem.

Definition at line 286 of file cell_pyramid5.C.

References libMesh::libmesh_assert(), libMesh::Elem::swap2boundaryedges(), libMesh::Elem::swap2boundarysides(), libMesh::Elem::swap2neighbors(), and libMesh::Elem::swap2nodes().

287 {
288  libmesh_assert(boundary_info);
289 
290  swap2nodes(0,1);
291  swap2nodes(2,3);
292  swap2neighbors(1,3);
293  swap2boundarysides(1,3,boundary_info);
294  swap2boundaryedges(1,3,boundary_info);
295  swap2boundaryedges(4,5,boundary_info);
296  swap2boundaryedges(6,7,boundary_info);
297 }
void swap2boundaryedges(unsigned short e1, unsigned short e2, BoundaryInfo *boundary_info) const
Swaps two edges in boundary_info, if it is non-null.
Definition: elem.C:3565
void swap2boundarysides(unsigned short s1, unsigned short s2, BoundaryInfo *boundary_info) const
Swaps two sides in boundary_info, if it is non-null.
Definition: elem.C:3549
void swap2nodes(unsigned int n1, unsigned int n2)
Swaps two node_ptrs.
Definition: elem.h:2093
libmesh_assert(ctx)
void swap2neighbors(unsigned int n1, unsigned int n2)
Swaps two neighbor_ptrs.
Definition: elem.h:2103

◆ get_extra_datum()

template<typename T >
T libMesh::DofObject::get_extra_datum ( const unsigned int  index) const
inlineinherited

Gets the value on this object of the extra datum associated with index, which should have been obtained via a call to MeshBase::add_elem_datum or MeshBase::add_node_datum using the same type T.

Definition at line 1146 of file dof_object.h.

References libMesh::DofObject::_idx_buf, libMesh::DofObject::n_extra_integers(), libMesh::DofObject::n_systems(), and libMesh::DofObject::start_idx_ints().

Referenced by libMesh::Elem::get_info(), libMesh::VTKIO::nodes_to_vtk(), libMesh::rational_fe_shape(), libMesh::rational_fe_shape_deriv(), libMesh::rational_fe_shape_second_deriv(), libMesh::rational_fe_weighted_shapes(), libMesh::rational_fe_weighted_shapes_derivs(), libMesh::ExodusII_IO::read(), and DofObjectTest< Node >::testAddExtraData().

1147 {
1148 #ifndef NDEBUG
1149  const unsigned int n_more_integers = (sizeof(T)-1)/sizeof(dof_id_type);
1150 #endif
1151  libmesh_assert_less(index+n_more_integers, this->n_extra_integers());
1152  libmesh_assert_less(this->n_systems(), _idx_buf.size());
1153 
1154  const unsigned int start_idx_i = this->start_idx_ints();
1155 
1156  libmesh_assert_less(start_idx_i+index+n_more_integers, _idx_buf.size());
1157  T returnval;
1158  std::memcpy(&returnval, &_idx_buf[start_idx_i+index], sizeof(T));
1159  return returnval;
1160 }
unsigned int start_idx_ints() const
The starting index for an extra_integers pseudosystem.
Definition: dof_object.h:1273
unsigned int n_systems() const
Definition: dof_object.h:937
unsigned int n_extra_integers() const
Returns how many extra integers are associated to the DofObject.
Definition: dof_object.h:1170
index_buffer_t _idx_buf
Definition: dof_object.h:680
uint8_t dof_id_type
Definition: id_types.h:67

◆ get_extra_integer()

dof_id_type libMesh::DofObject::get_extra_integer ( const unsigned int  index) const
inlineinherited

Gets the value on this object of the extra integer associated with index, which should have been obtained via a call to MeshBase::add_elem_integer or MeshBase::add_node_integer.

Definition at line 1102 of file dof_object.h.

References libMesh::DofObject::_idx_buf, libMesh::DofObject::n_extra_integers(), libMesh::DofObject::n_systems(), and libMesh::DofObject::start_idx_ints().

Referenced by libMesh::MeshTools::Modification::all_tri(), WriteElemsetData::checkByCentroid(), libMesh::MeshTools::Modification::flatten(), libMesh::SyncElementIntegers::gather_data(), libMesh::XdrIO::pack_element(), libMesh::CheckpointIO::read_connectivity(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::DofObject::set_n_vars_per_group(), DofObjectTest< Node >::testAddExtraData(), DofObjectTest< Node >::testAddSystemExtraInts(), ExtraIntegersTest::testExtraIntegersExodusReading(), DofObjectTest< Node >::testSetNSystemsExtraInts(), DofObjectTest< Node >::testSetNVariableGroupsExtraInts(), and libMesh::XdrIO::write_serialized_nodes().

1103 {
1104  libmesh_assert_less(index, this->n_extra_integers());
1105  libmesh_assert_less(this->n_systems(), _idx_buf.size());
1106 
1107  const unsigned int start_idx_i = this->start_idx_ints();
1108 
1109  libmesh_assert_less(start_idx_i+index, _idx_buf.size());
1110  return _idx_buf[start_idx_i+index];
1111 }
unsigned int start_idx_ints() const
The starting index for an extra_integers pseudosystem.
Definition: dof_object.h:1273
unsigned int n_systems() const
Definition: dof_object.h:937
unsigned int n_extra_integers() const
Returns how many extra integers are associated to the DofObject.
Definition: dof_object.h:1170
index_buffer_t _idx_buf
Definition: dof_object.h:680

◆ get_info() [1/3]

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

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

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

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

48 {
49 #if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
50 
51  std::ostringstream oss;
52 
53  oss << '\n'
54  << " ---------------------------------------------------------------------------- \n"
55  << "| Reference count information |\n"
56  << " ---------------------------------------------------------------------------- \n";
57 
58  for (const auto & [name, cd] : _counts)
59  oss << "| " << name << " reference count information:\n"
60  << "| Creations: " << cd.first << '\n'
61  << "| Destructions: " << cd.second << '\n';
62 
63  oss << " ---------------------------------------------------------------------------- \n";
64 
65  return oss.str();
66 
67 #else
68 
69  return "";
70 
71 #endif
72 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
static Counts _counts
Actually holds the data.

◆ get_info() [2/3]

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

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

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

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

48 {
49 #if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
50 
51  std::ostringstream oss;
52 
53  oss << '\n'
54  << " ---------------------------------------------------------------------------- \n"
55  << "| Reference count information |\n"
56  << " ---------------------------------------------------------------------------- \n";
57 
58  for (const auto & [name, cd] : _counts)
59  oss << "| " << name << " reference count information:\n"
60  << "| Creations: " << cd.first << '\n'
61  << "| Destructions: " << cd.second << '\n';
62 
63  oss << " ---------------------------------------------------------------------------- \n";
64 
65  return oss.str();
66 
67 #else
68 
69  return "";
70 
71 #endif
72 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
static Counts _counts
Actually holds the data.

◆ get_info() [3/3]

std::string libMesh::Elem::get_info ( ) const
inherited

Prints relevant information about the element to a string.

Definition at line 2927 of file elem.C.

References libMesh::Elem::active(), libMesh::Elem::ancestor(), libMesh::Elem::dim(), libMesh::DofObject::dof_number(), libMesh::Utility::enum_to_string(), libMesh::DofObject::get_extra_datum(), libMesh::Elem::has_children(), libMesh::Elem::hmax(), libMesh::Elem::hmin(), libMesh::DofObject::id(), libMesh::Elem::infinite(), libMesh::Elem::level(), libMesh::make_range(), libMesh::Elem::mapping_data(), libMesh::Elem::mapping_type(), libMesh::DofObject::n_comp(), libMesh::Elem::n_nodes(), libMesh::Elem::n_sides(), libMesh::DofObject::n_systems(), libMesh::DofObject::n_vars(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::node_index_range(), libMesh::Elem::node_ref(), libMesh::Elem::origin(), libMesh::Elem::p_level(), libMesh::Elem::p_refinement_flag(), libMesh::Elem::parent(), libMesh::DofObject::processor_id(), libMesh::RATIONAL_BERNSTEIN_MAP, libMesh::Real, libMesh::Elem::refinement_flag(), libMesh::Elem::side_index_range(), libMesh::Elem::subactive(), libMesh::Elem::subdomain_id(), libMesh::Elem::type(), libMesh::DofObject::unique_id(), libMesh::DofObject::valid_id(), libMesh::DofObject::valid_unique_id(), and libMesh::Elem::volume().

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

2928 {
2929  std::ostringstream oss;
2930 
2931  oss << " Elem Information" << '\n'
2932  << " id()=";
2933 
2934  if (this->valid_id())
2935  oss << this->id();
2936  else
2937  oss << "invalid";
2938 
2939 #ifdef LIBMESH_ENABLE_UNIQUE_ID
2940  oss << ", unique_id()=";
2941  if (this->valid_unique_id())
2942  oss << this->unique_id();
2943  else
2944  oss << "invalid";
2945 #endif
2946 
2947  oss << ", subdomain_id()=" << this->subdomain_id();
2948  oss << ", processor_id()=" << this->processor_id() << '\n';
2949 
2950  oss << " type()=" << Utility::enum_to_string(this->type()) << '\n'
2951  << " dim()=" << this->dim() << '\n'
2952  << " n_nodes()=" << this->n_nodes() << '\n';
2953 
2954  oss << " mapping=" << Utility::enum_to_string(this->mapping_type()) << '\n';
2955 
2956  for (auto n : this->node_index_range())
2957  {
2958  oss << " " << n << this->node_ref(n);
2959  if (this->mapping_type() == RATIONAL_BERNSTEIN_MAP)
2960  {
2961  const unsigned char datum_index = this->mapping_data();
2962  oss << " weight=" <<
2963  this->node_ref(n).get_extra_datum<Real>(datum_index) << '\n';
2964  }
2965  }
2966 
2967  oss << " n_sides()=" << this->n_sides() << '\n';
2968 
2969  for (auto s : this->side_index_range())
2970  {
2971  oss << " neighbor(" << s << ")=";
2972  if (this->neighbor_ptr(s))
2973  oss << this->neighbor_ptr(s)->id() << '\n';
2974  else
2975  oss << "nullptr\n";
2976  }
2977 
2978  if (!this->infinite())
2979  {
2980  oss << " hmin()=" << this->hmin()
2981  << ", hmax()=" << this->hmax() << '\n'
2982  << " volume()=" << this->volume() << '\n';
2983  }
2984  oss << " active()=" << this->active()
2985  << ", ancestor()=" << this->ancestor()
2986  << ", subactive()=" << this->subactive()
2987  << ", has_children()=" << this->has_children() << '\n'
2988  << " parent()=";
2989  if (this->parent())
2990  oss << this->parent()->id() << '\n';
2991  else
2992  oss << "nullptr\n";
2993  oss << " level()=" << this->level()
2994  << ", p_level()=" << this->p_level() << '\n'
2995 #ifdef LIBMESH_ENABLE_AMR
2996  << " refinement_flag()=" << Utility::enum_to_string(this->refinement_flag()) << '\n'
2997  << " p_refinement_flag()=" << Utility::enum_to_string(this->p_refinement_flag()) << '\n'
2998 #endif
2999 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
3000  << " infinite()=" << this->infinite() << '\n';
3001  if (this->infinite())
3002  oss << " origin()=" << this->origin() << '\n'
3003 #endif
3004  ;
3005 
3006  oss << " DoFs=";
3007  for (auto s : make_range(this->n_systems()))
3008  for (auto v : make_range(this->n_vars(s)))
3009  for (auto c : make_range(this->n_comp(s,v)))
3010  oss << '(' << s << '/' << v << '/' << this->dof_number(s,v,c) << ") ";
3011 
3012 
3013  return oss.str();
3014 }
unsigned char mapping_data() const
Definition: elem.h:3137
RefinementState refinement_flag() const
Definition: elem.h:3211
dof_id_type dof_number(const unsigned int s, const unsigned int var, const unsigned int comp) const
Definition: dof_object.h:1032
const Elem * parent() const
Definition: elem.h:3031
virtual Point origin() const
Definition: elem.h:1915
unsigned int n_comp(const unsigned int s, const unsigned int var) const
Definition: dof_object.h:1002
IntRange< unsigned short > side_index_range() const
Definition: elem.h:2711
RefinementState p_refinement_flag() const
Definition: elem.h:3227
unique_id_type unique_id() const
Definition: dof_object.h:844
unsigned int p_level() const
Definition: elem.h:3109
virtual Real hmax() const
Definition: elem.C:720
bool ancestor() const
Definition: elem.C:2008
ElemMappingType mapping_type() const
Definition: elem.h:3121
const Node & node_ref(const unsigned int i) const
Definition: elem.h:2530
dof_id_type id() const
Definition: dof_object.h:828
virtual Real hmin() const
Definition: elem.C:700
virtual unsigned int n_nodes() const =0
unsigned int n_vars(const unsigned int s, const unsigned int vg) const
Definition: dof_object.h:967
unsigned int n_systems() const
Definition: dof_object.h:937
bool valid_unique_id() const
Definition: dof_object.h:893
std::string enum_to_string(const T e)
virtual unsigned int n_sides() const =0
const Elem * neighbor_ptr(unsigned int i) const
Definition: elem.h:2599
unsigned int level() const
Definition: elem.h:3075
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
subdomain_id_type subdomain_id() const
Definition: elem.h:2583
bool valid_id() const
Definition: dof_object.h:885
virtual unsigned short dim() const =0
bool subactive() const
Definition: elem.h:2960
virtual Real volume() const
Definition: elem.C:3433
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140
IntRange< unsigned short > node_index_range() const
Definition: elem.h:2684
T get_extra_datum(const unsigned int index) const
Gets the value on this object of the extra datum associated with index, which should have been obtain...
Definition: dof_object.h:1146
virtual bool infinite() const =0
bool active() const
Definition: elem.h:2942
processor_id_type processor_id() const
Definition: dof_object.h:905
virtual ElemType type() const =0
bool has_children() const
Definition: elem.h:2980

◆ get_node_index()

unsigned int libMesh::Elem::get_node_index ( const Node node_ptr) const
inlineinherited
Returns
The local index for the Node pointer node_ptr, or invalid_uint if node_ptr is not a local node.

Definition at line 2546 of file elem.h.

References libMesh::Elem::_nodes, libMesh::invalid_uint, libMesh::make_range(), libMesh::Elem::n_nodes(), and libMesh::Elem::node_ptr().

Referenced by libMesh::OldSolutionValue< Output, point_output >::eval_at_node(), libMesh::ElemCutter::find_intersection_points(), libMesh::VariationalSmootherConstraint::nodes_share_boundary_id(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectVertices::operator()(), libMesh::C0Polyhedron::retriangulate(), and VolumeTest::testC0PolyhedronMethods().

2547 {
2548  for (auto n : make_range(this->n_nodes()))
2549  if (this->_nodes[n] == node_ptr)
2550  return n;
2551 
2552  return libMesh::invalid_uint;
2553 }
Node ** _nodes
Pointers to the nodes we are connected to.
Definition: elem.h:2246
const unsigned int invalid_uint
A number which is used quite often to represent an invalid or uninitialized value for an unsigned int...
Definition: libmesh.h:310
virtual unsigned int n_nodes() const =0
const Node * node_ptr(const unsigned int i) const
Definition: elem.h:2508
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140

◆ get_nodes()

const Node *const * libMesh::Elem::get_nodes ( ) const
inlineinherited
Returns
A pointer to an array of local node pointers.

Definition at line 2500 of file elem.h.

References libMesh::Elem::_nodes.

Referenced by libMesh::DofMap::dof_indices(), and libMesh::DofMap::old_dof_indices().

2501 {
2502  return _nodes;
2503 }
Node ** _nodes
Pointers to the nodes we are connected to.
Definition: elem.h:2246

◆ get_old_dof_object() [1/2]

DofObject* libMesh::DofObject::get_old_dof_object ( )
inlineinherited

◆ get_old_dof_object() [2/2]

const DofObject* libMesh::DofObject::get_old_dof_object ( ) const
inlineinherited

Definition at line 97 of file dof_object.h.

References libMesh::DofObject::old_dof_object.

97 { return old_dof_object.get(); }
std::unique_ptr< DofObject > old_dof_object
This object on the last mesh.
Definition: dof_object.h:88

◆ get_old_dof_object_ref() [1/2]

DofObject& libMesh::DofObject::get_old_dof_object_ref ( )
inlineinherited

As above, but do not use in situations where the old_dof_object may be nullptr, since this function asserts that the old_dof_object is valid before returning a reference to it.

Definition at line 104 of file dof_object.h.

References libMesh::libmesh_assert(), and libMesh::DofObject::old_dof_object.

Referenced by libMesh::OldSolutionCoefs< Output, point_output >::eval_old_dofs(), libMesh::OldSolutionValue< Output, point_output >::eval_old_dofs(), and libMesh::DofMap::old_dof_indices().

105  {
107  return *old_dof_object;
108  }
libmesh_assert(ctx)
std::unique_ptr< DofObject > old_dof_object
This object on the last mesh.
Definition: dof_object.h:88

◆ get_old_dof_object_ref() [2/2]

const DofObject& libMesh::DofObject::get_old_dof_object_ref ( ) const
inlineinherited

Definition at line 110 of file dof_object.h.

References libMesh::libmesh_assert(), and libMesh::DofObject::old_dof_object.

111  {
113  return *old_dof_object;
114  }
libmesh_assert(ctx)
std::unique_ptr< DofObject > old_dof_object
This object on the last mesh.
Definition: dof_object.h:88

◆ hack_p_level()

void libMesh::Elem::hack_p_level ( const unsigned int  p)
inlineinherited

Sets the value of the p-refinement level for the element without altering the p-level of its ancestors.

Definition at line 3265 of file elem.h.

References libMesh::Elem::_p_level, libMesh::Elem::JUST_REFINED, and libMesh::Elem::p_refinement_flag().

Referenced by libMesh::Elem::hack_p_level_and_refinement_flag(), libMesh::HPCoarsenTest::select_refinement(), and libMesh::Elem::set_p_level().

3266 {
3267  if (p == 0)
3268  libmesh_assert_not_equal_to
3270 
3271  _p_level = cast_int<unsigned char>(p);
3272 }
unsigned char _p_level
p refinement level - the difference between the polynomial degree on this element and the minimum pol...
Definition: elem.h:2291
RefinementState p_refinement_flag() const
Definition: elem.h:3227

◆ hack_p_level_and_refinement_flag()

void libMesh::Elem::hack_p_level_and_refinement_flag ( const unsigned int  p,
RefinementState  pflag 
)
inlineinherited

Sets the value of the p-refinement level for the element without altering the p-level of its ancestors; also sets the p_refinement_flag, simultaneously so that they can be safely checked for mutual consistency.

Definition at line 3276 of file elem.h.

References libMesh::Elem::_pflag, and libMesh::Elem::hack_p_level().

3278 {
3279  _pflag = cast_int<unsigned char>(pflag);
3280  this->hack_p_level(p);
3281 }
unsigned char _pflag
p refinement flag.
Definition: elem.h:2281
void hack_p_level(const unsigned int p)
Sets the value of the p-refinement level for the element without altering the p-level of its ancestor...
Definition: elem.h:3265

◆ has_affine_map()

bool libMesh::Pyramid5::has_affine_map ( ) const
overridevirtual
Returns
true if the element map is definitely affine within numerical tolerances.

Reimplemented from libMesh::Elem.

Definition at line 115 of file cell_pyramid5.C.

116 {
117  // Point v = this->point(3) - this->point(0);
118  // return (v.relative_fuzzy_equals(this->point(2) - this->point(1)));
119  return false;
120 }

◆ has_ancestor_children()

bool libMesh::Elem::has_ancestor_children ( ) const
inlineinherited
Returns
true if the element has any descendants other than its immediate children, false otherwise, or if AMR is disabled.

Definition at line 2994 of file elem.h.

References libMesh::Elem::_children, and libMesh::Elem::child_ref_range().

2995 {
2996 #ifdef LIBMESH_ENABLE_AMR
2997  if (!_children)
2998  return false;
2999  else
3000  for (auto & c : child_ref_range())
3001  if (c.has_children())
3002  return true;
3003 #endif
3004  return false;
3005 }
SimpleRange< ChildRefIter > child_ref_range()
Returns a range with all children of a parent element, usable in range-based for loops.
Definition: elem.h:2347
std::unique_ptr< Elem *[]> _children
unique_ptr to array of this element&#39;s children.
Definition: elem.h:2262

◆ has_children()

bool libMesh::Elem::has_children ( ) const
inlineinherited

◆ has_dofs()

bool libMesh::DofObject::has_dofs ( const unsigned int  s = libMesh::invalid_uint) const
inlineinherited
Returns
true if any system has variables which have been assigned, false otherwise.

Definition at line 1226 of file dof_object.h.

References libMesh::invalid_uint, libMesh::make_range(), libMesh::DofObject::n_systems(), and libMesh::DofObject::n_vars().

Referenced by libMesh::DofMap::old_dof_indices().

1227 {
1228  if (sys == libMesh::invalid_uint)
1229  {
1230  for (auto s : make_range(this->n_systems()))
1231  if (this->n_vars(s))
1232  return true;
1233  }
1234 
1235  else
1236  {
1237  libmesh_assert_less (sys, this->n_systems());
1238 
1239  if (this->n_vars(sys))
1240  return true;
1241  }
1242 
1243  return false;
1244 }
const unsigned int invalid_uint
A number which is used quite often to represent an invalid or uninitialized value for an unsigned int...
Definition: libmesh.h:310
unsigned int n_vars(const unsigned int s, const unsigned int vg) const
Definition: dof_object.h:967
unsigned int n_systems() const
Definition: dof_object.h:937
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140

◆ has_extra_integers()

bool libMesh::DofObject::has_extra_integers ( ) const
inlineinherited

◆ has_invertible_map()

bool libMesh::Elem::has_invertible_map ( Real  tol = TOLERANCE*TOLERANCE) const
virtualinherited
Returns
true if the element map is invertible everywhere on the element, to within a user-specified tolerance. The tolerance is generally used in comparisons against zero, so it should be an absolute rather than a relative tolerance. Throws a libmesh_not_implemented() error unless specialized by derived classes.

Reimplemented in libMesh::NodeElem, libMesh::Tet4, libMesh::Tri3, libMesh::Edge4, libMesh::Edge3, libMesh::Quad4, and libMesh::Edge2.

Definition at line 2885 of file elem.C.

References libMesh::FEMap::compute_map(), libMesh::Elem::dim(), libMesh::FEMap::get_jacobian(), libMesh::index_range(), libMesh::FEMap::init_reference_to_physical_map(), libMesh::Elem::is_singular_node(), and libMesh::Elem::n_nodes().

Referenced by VolumeTest::testEdge4Invertible().

2886 {
2887  QNodal qnodal {this->dim()};
2888  FEMap fe_map;
2889  auto & jac = fe_map.get_jacobian();
2890 
2891  // We have a separate check for is_singular_node() below, so in this
2892  // case its "OK" to do nodal quadrature on pyramids.
2893  qnodal.allow_nodal_pyramid_quadrature = true;
2894  qnodal.init(*this);
2895  auto & qp = qnodal.get_points();
2896  libmesh_assert_equal_to(qp.size(), this->n_nodes());
2897 
2898  std::vector<Point> one_point(1);
2899  std::vector<Real> one_weight(1,1);
2900  for (auto i : index_range(qp))
2901  {
2902  if (this->is_singular_node(i))
2903  continue;
2904 
2905  one_point[0] = qp[i];
2906 
2907  fe_map.init_reference_to_physical_map(this->dim(), one_point, this);
2908  fe_map.compute_map(this->dim(), one_weight, this, false);
2909 
2910  if (jac[0] <= 0)
2911  return false;
2912  }
2913 
2914  return true;
2915 }
virtual unsigned int n_nodes() const =0
virtual bool is_singular_node(unsigned int) const
Definition: elem.h:1839
virtual unsigned short dim() const =0
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:117

◆ has_neighbor()

bool libMesh::Elem::has_neighbor ( const Elem elem) const
inlineinherited
Returns
true if the element elem in question is a neighbor of this element, false otherwise.

Definition at line 2629 of file elem.h.

References libMesh::Elem::neighbor_ptr_range().

Referenced by libMesh::Elem::has_topological_neighbor(), libMesh::MeshRefinement::has_topological_neighbor(), libMesh::Elem::min_new_p_level_by_neighbor(), libMesh::Elem::min_p_level_by_neighbor(), and libMesh::Elem::on_boundary().

2630 {
2631  for (auto n : this->neighbor_ptr_range())
2632  if (n == elem)
2633  return true;
2634 
2635  return false;
2636 }
SimpleRange< NeighborPtrIter > neighbor_ptr_range()
Returns a range with all neighbors of an element, usable in range-based for loops.
Definition: elem.h:3504

◆ has_topological_neighbor()

bool libMesh::Elem::has_topological_neighbor ( const Elem elem,
const MeshBase mesh,
const PointLocatorBase point_locator,
const PeriodicBoundaries pb 
) const
inherited
Returns
true if the element elem in question is a neighbor or topological neighbor of this element, false otherwise.

Definition at line 1348 of file elem.C.

References libMesh::Elem::has_neighbor(), mesh, libMesh::Elem::side_index_range(), and libMesh::Elem::topological_neighbor().

Referenced by libMesh::MeshRefinement::has_topological_neighbor().

1352 {
1353  // First see if this is a normal "interior" neighbor
1354  if (has_neighbor(elem))
1355  return true;
1356 
1357  for (auto n : this->side_index_range())
1358  if (this->topological_neighbor(n, mesh, point_locator, pb))
1359  return true;
1360 
1361  return false;
1362 }
bool has_neighbor(const Elem *elem) const
Definition: elem.h:2629
const Elem * topological_neighbor(const unsigned int i, const MeshBase &mesh, const PointLocatorBase &point_locator, const PeriodicBoundaries *pb) const
Definition: elem.C:1311
IntRange< unsigned short > side_index_range() const
Definition: elem.h:2711
MeshBase & mesh

◆ hmax()

Real libMesh::Elem::hmax ( ) const
virtualinherited
Returns
The maximum vertex separation for the element.

Definition at line 720 of file elem.C.

References libMesh::Elem::n_vertices(), libMesh::Elem::point(), and libMesh::Real.

Referenced by libMesh::DiscontinuityMeasure::boundary_side_integration(), libMesh::KellyErrorEstimator::boundary_side_integration(), libMesh::OldSolutionBase< Output, point_output >::check_old_context(), libMesh::Elem::get_info(), libMesh::LaplacianErrorEstimator::internal_side_integration(), libMesh::DiscontinuityMeasure::internal_side_integration(), libMesh::KellyErrorEstimator::internal_side_integration(), and libMesh::Elem::point_test().

721 {
722  Real h_max=0;
723 
724  // Avoid calling a virtual a lot of times
725  const auto n_vertices = this->n_vertices();
726 
727  for (unsigned int n_outer=0; n_outer<n_vertices; n_outer++)
728  for (unsigned int n_inner=n_outer+1; n_inner<n_vertices; n_inner++)
729  {
730  const auto diff = (this->point(n_outer) - this->point(n_inner));
731 
732  h_max = std::max(h_max, diff.norm_sq());
733  }
734 
735  return std::sqrt(h_max);
736 }
virtual unsigned int n_vertices() const =0
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
const Point & point(const unsigned int i) const
Definition: elem.h:2454

◆ hmin()

Real libMesh::Elem::hmin ( ) const
virtualinherited
Returns
The minimum vertex separation for the element.

Definition at line 700 of file elem.C.

References libMesh::Elem::n_vertices(), libMesh::Elem::point(), and libMesh::Real.

Referenced by compute_enriched_soln(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), compute_tau(), libMesh::MeshTools::Modification::distort(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::Elem::get_info(), libMesh::FEMSystem::numerical_jacobian(), and libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectVertices::operator()().

701 {
702  Real h_min=std::numeric_limits<Real>::max();
703 
704  // Avoid calling a virtual a lot of times
705  const auto n_vertices = this->n_vertices();
706 
707  for (unsigned int n_outer=0; n_outer<n_vertices; n_outer++)
708  for (unsigned int n_inner=n_outer+1; n_inner<n_vertices; n_inner++)
709  {
710  const auto diff = (this->point(n_outer) - this->point(n_inner));
711 
712  h_min = std::min(h_min, diff.norm_sq());
713  }
714 
715  return std::sqrt(h_min);
716 }
virtual unsigned int n_vertices() const =0
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
const Point & point(const unsigned int i) const
Definition: elem.h:2454

◆ id()

dof_id_type libMesh::DofObject::id ( ) const
inlineinherited
Returns
The id for this DofObject

Definition at line 828 of file dof_object.h.

References libMesh::DofObject::_id.

Referenced by libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::MeshTools::Subdivision::add_boundary_ghosts(), add_cube_convex_hull_to_mesh(), libMesh::ReplicatedMesh::add_elem(), libMesh::DistributedMesh::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::TopologyMap::add_node(), libMesh::ReplicatedMesh::add_node(), libMesh::DistributedMesh::add_node(), libMesh::MeshTools::Modification::all_tri(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::ClawSystem::assemble_avg_coupling_matrices(), assemble_ellipticdg(), libMesh::ClawSystem::assemble_jump_coupling_matrix(), libMesh::Node::build(), libMesh::MeshTools::Generation::build_cube(), libMesh::Partitioner::build_graph(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::EquationSystems::build_parallel_solution_vector(), compute_jacobian(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), libMesh::FEAbstract::compute_periodic_node_constraints(), compute_residual(), libMesh::InfFE< Dim, T_radial, T_map >::compute_shape_functions(), libMesh::FEMap::compute_single_point_map(), libMesh::MeshBase::copy_constraint_rows(), libMesh::MeshRefinement::create_parent_error_vector(), libMesh::ReplicatedMesh::delete_elem(), libMesh::DistributedMesh::delete_elem(), libMesh::ReplicatedMesh::delete_node(), libMesh::DistributedMesh::delete_node(), libMesh::C0Polyhedron::disconnected_clone(), libMesh::Elem::disconnected_clone(), libMesh::StaticCondensationDofMap::dof_indices(), libMesh::DTKAdapter::DTKAdapter(), libMesh::UNVIO::elements_out(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::find_dofs_to_send(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::MeshTools::find_nodal_neighbors(), libMesh::VariationalSmootherConstraint::find_nodal_or_face_neighbors(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_error_fraction(), libMesh::MeshRefinement::flag_elements_by_error_tolerance(), libMesh::MeshTools::Modification::flatten(), libMesh::ReplicatedMesh::get_boundary_points(), libMesh::ReplicatedMesh::get_disconnected_subdomains(), libMesh::Node::get_info(), libMesh::Elem::get_info(), libMesh::MeshBase::get_info(), libMesh::VariationalSmootherConstraint::get_neighbors_for_boundary_constraint(), libMesh::VariationalSmootherConstraint::get_neighbors_for_subdomain_constraint(), libMesh::ParmetisPartitioner::initialize(), libMesh::TreeNode< N >::insert(), libMesh::TriangulatorInterface::insert_any_extra_boundary_points(), libMesh::ReplicatedMesh::insert_elem(), libMesh::DistributedMesh::insert_elem(), libMesh::ReplicatedMesh::insert_node(), libMesh::Poly2TriTriangulator::insert_refinement_points(), EIM_F::interior_assembly(), AssemblyEIM::interior_assembly(), libMesh::Elem::interior_parent(), libMesh::FEMap::inverse_map(), libMesh::MeshTools::libmesh_assert_valid_amr_elem_ids(), libMesh::MeshTools::libmesh_assert_valid_constraint_rows(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::Tri3Subdivision::local_node_number(), main(), ExodusTest< elem_type >::meshes_equal_enough(), LinearElasticityWithContact::move_mesh(), libMesh::MeshTools::n_connected_components(), libMesh::Elem::node_id(), libMesh::TriangulatorInterface::nodes_to_segments(), libMesh::VTKIO::nodes_to_vtk(), libMesh::CompareElemIdsByLevel::operator()(), libMesh::GhostPointNeighbors::operator()(), libMesh::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectVertices::operator()(), libMesh::CompareDofObjectsByID::operator()(), libMesh::CompareDofObjectsByPIDAndThenID::operator()(), libMesh::BoundaryInfo::operator==(), libMesh::DistributedMesh::own_node(), libMesh::DistributedMesh::parallel_max_elem_id(), libMesh::DistributedMesh::parallel_max_node_id(), libMesh::MetisPartitioner::partition_range(), libMesh::DofObject::print_dof_info(), libMesh::DofMap::process_mesh_constraint_rows(), libMesh::DistributedMesh::query_elem_ptr(), libMesh::query_ghosting_functors(), libMesh::DistributedMesh::query_node_ptr(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::EquationSystems::redundant_added_side(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::DistributedMesh::renumber_elem(), libMesh::DistributedMesh::renumber_node(), libMesh::DistributedMesh::renumber_nodes_and_elements(), libMesh::C0Polyhedron::retriangulate(), libMesh::DofMap::scatter_constraints(), libMesh::StaticCondensation::set_current_elem(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), FETestBase< order, family, elem_type, 1 >::setUp(), libMesh::MeshTools::Modification::smooth(), libMesh::BoundaryInfo::sync(), libMesh::Parallel::sync_dofobject_data_by_id(), libMesh::Parallel::sync_element_data_by_parent_id(), libMesh::Parallel::sync_node_data_by_element_id_once(), ElemTest< elem_type >::test_orient_elements(), DefaultCouplingTest::testCoupling(), MixedDimensionMeshTest::testPointLocatorTree(), InfFERadialTest::testRefinement(), DofObjectTest< Node >::testSetId(), libMesh::Elem::topologically_equal(), libMesh::NetGenMeshInterface::triangulate(), libMesh::TetGenMeshInterface::triangulate_conformingDelaunayMesh_carvehole(), libMesh::Poly2TriTriangulator::triangulate_current_points(), libMesh::MeshTetInterface::volume_to_surface_mesh(), libMesh::GmshIO::write_mesh(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), and libMesh::XdrIO::write_serialized_nodes().

829 {
830  return _id;
831 }
dof_id_type _id
The id of the DofObject.
Definition: dof_object.h:583

◆ increment_constructor_count() [1/2]

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

Increments the construction counter.

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

Definition at line 183 of file reference_counter.h.

References libMesh::err, libMesh::BasicOStreamProxy< charT, traits >::get(), libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

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

184 {
185  libmesh_try
186  {
187  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
188  std::pair<unsigned int, unsigned int> & p = _counts[name];
189  p.first++;
190  }
191  libmesh_catch (...)
192  {
193  auto stream = libMesh::err.get();
194  stream->exceptions(stream->goodbit); // stream must not throw
195  libMesh::err << "Encountered unrecoverable error while calling "
196  << "ReferenceCounter::increment_constructor_count() "
197  << "for a(n) " << name << " object." << std::endl;
198  std::terminate();
199  }
200 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
OStreamProxy err
static Counts _counts
Actually holds the data.
streamT * get()
Rather than implement every ostream/ios/ios_base function, we&#39;ll be lazy and make esoteric uses go th...
spin_mutex spin_mtx
A convenient spin mutex object which can be used for obtaining locks.
Definition: threads.C:30

◆ increment_constructor_count() [2/2]

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

Increments the construction counter.

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

Definition at line 183 of file reference_counter.h.

References libMesh::err, libMesh::BasicOStreamProxy< charT, traits >::get(), libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

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

184 {
185  libmesh_try
186  {
187  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
188  std::pair<unsigned int, unsigned int> & p = _counts[name];
189  p.first++;
190  }
191  libmesh_catch (...)
192  {
193  auto stream = libMesh::err.get();
194  stream->exceptions(stream->goodbit); // stream must not throw
195  libMesh::err << "Encountered unrecoverable error while calling "
196  << "ReferenceCounter::increment_constructor_count() "
197  << "for a(n) " << name << " object." << std::endl;
198  std::terminate();
199  }
200 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
OStreamProxy err
static Counts _counts
Actually holds the data.
streamT * get()
Rather than implement every ostream/ios/ios_base function, we&#39;ll be lazy and make esoteric uses go th...
spin_mutex spin_mtx
A convenient spin mutex object which can be used for obtaining locks.
Definition: threads.C:30

◆ increment_destructor_count() [1/2]

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

Increments the destruction counter.

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

Definition at line 207 of file reference_counter.h.

References libMesh::err, libMesh::BasicOStreamProxy< charT, traits >::get(), libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

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

208 {
209  libmesh_try
210  {
211  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
212  std::pair<unsigned int, unsigned int> & p = _counts[name];
213  p.second++;
214  }
215  libmesh_catch (...)
216  {
217  auto stream = libMesh::err.get();
218  stream->exceptions(stream->goodbit); // stream must not throw
219  libMesh::err << "Encountered unrecoverable error while calling "
220  << "ReferenceCounter::increment_destructor_count() "
221  << "for a(n) " << name << " object." << std::endl;
222  std::terminate();
223  }
224 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
OStreamProxy err
static Counts _counts
Actually holds the data.
streamT * get()
Rather than implement every ostream/ios/ios_base function, we&#39;ll be lazy and make esoteric uses go th...
spin_mutex spin_mtx
A convenient spin mutex object which can be used for obtaining locks.
Definition: threads.C:30

◆ increment_destructor_count() [2/2]

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

Increments the destruction counter.

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

Definition at line 207 of file reference_counter.h.

References libMesh::err, libMesh::BasicOStreamProxy< charT, traits >::get(), libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

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

208 {
209  libmesh_try
210  {
211  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
212  std::pair<unsigned int, unsigned int> & p = _counts[name];
213  p.second++;
214  }
215  libmesh_catch (...)
216  {
217  auto stream = libMesh::err.get();
218  stream->exceptions(stream->goodbit); // stream must not throw
219  libMesh::err << "Encountered unrecoverable error while calling "
220  << "ReferenceCounter::increment_destructor_count() "
221  << "for a(n) " << name << " object." << std::endl;
222  std::terminate();
223  }
224 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
OStreamProxy err
static Counts _counts
Actually holds the data.
streamT * get()
Rather than implement every ostream/ios/ios_base function, we&#39;ll be lazy and make esoteric uses go th...
spin_mutex spin_mtx
A convenient spin mutex object which can be used for obtaining locks.
Definition: threads.C:30

◆ infinite() [1/2]

virtual bool libMesh::Cell::infinite ( ) const
inlineoverridevirtualinherited
Returns
false. All classes derived from Cell are finite elements.

Implements libMesh::Elem.

Definition at line 75 of file cell.h.

75 { return false; }

◆ infinite() [2/2]

static constexpr bool libMesh::Elem::infinite ( )
inlinestaticinherited

Definition at line 1919 of file elem.h.

1919 { return false; }

◆ inherit_data_from()

void libMesh::Elem::inherit_data_from ( const Elem src)
inlineinherited

A helper function for copying generic element data (mapping, subdomain, processor) from an element to a derived (child, side, edge) element.

Useful for forwards compatibility when new data is added.

Definition at line 3340 of file elem.h.

References libMesh::Elem::mapping_data(), libMesh::Elem::mapping_type(), libMesh::Elem::p_level(), libMesh::DofObject::processor_id(), libMesh::Elem::set_mapping_data(), libMesh::Elem::set_mapping_type(), libMesh::Elem::set_p_level(), and libMesh::Elem::subdomain_id().

Referenced by libMesh::UnstructuredMesh::all_first_order().

3341 {
3342  this->set_mapping_type(src.mapping_type());
3343  this->set_mapping_data(src.mapping_data());
3344  this->subdomain_id() = src.subdomain_id();
3345  this->processor_id(src.processor_id());
3346 #ifdef LIBMESH_ENABLE_AMR
3347  this->set_p_level(src.p_level());
3348 #endif
3349 }
void set_p_level(const unsigned int p)
Sets the value of the p-refinement level for the element.
void set_mapping_type(const ElemMappingType type)
Sets the value of the mapping type for the element.
Definition: elem.h:3129
void set_mapping_data(const unsigned char data)
Sets the value of the mapping data for the element.
Definition: elem.h:3145
subdomain_id_type subdomain_id() const
Definition: elem.h:2583
processor_id_type processor_id() const
Definition: dof_object.h:905

◆ interior_parent() [1/2]

const Elem * libMesh::Elem::interior_parent ( ) const
inherited
Returns
The higher-dimensional Elem for which this Elem is a face.

In some cases it is desirable to extract the boundary (or a subset thereof) of a D-dimensional mesh as a (D-1)-dimensional manifold. In this case we may want to know the 'parent' element from which the manifold elements were extracted. We can easily do that for the level-0 manifold elements by storing the D-dimensional parent. This method provides access to that element.

This method returns nullptr if this->dim() == LIBMESH_DIM; in such cases no data storage for an interior parent pointer has been allocated.

Definition at line 1184 of file elem.C.

References libMesh::Elem::_elemlinks, libMesh::Elem::dim(), libMesh::DofObject::id(), libMesh::DofObject::invalid_id, libMesh::Elem::level(), libMesh::libmesh_assert(), libMesh::Elem::n_sides(), and libMesh::remote_elem.

Referenced by libMesh::FEMap::compute_face_map(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::BoundaryInfo::get_side_and_node_maps(), libMesh::InfFE< Dim, T_radial, T_map >::init_face_shape_functions(), libMesh::MeshTools::libmesh_assert_valid_amr_interior_parents(), libMesh::GhostPointNeighbors::operator()(), libMesh::Elem::topologically_equal(), libMesh::BoundaryVolumeSolutionTransfer::transfer_boundary_volume(), and libMesh::BoundaryVolumeSolutionTransfer::transfer_volume_boundary().

1185 {
1186  // interior parents make no sense for full-dimensional elements.
1187  if (this->dim() >= LIBMESH_DIM)
1188  return nullptr;
1189 
1190  // they USED TO BE only good for level-0 elements, but we now
1191  // support keeping interior_parent() valid on refined boundary
1192  // elements.
1193  // if (this->level() != 0)
1194  // return this->parent()->interior_parent();
1195 
1196  // We store the interior_parent pointer after both the parent
1197  // neighbor and neighbor pointers
1198  Elem * interior_p = _elemlinks[1+this->n_sides()];
1199 
1200  // If we have an interior_parent, we USED TO assume it was a
1201  // one-higher-dimensional interior element, but we now allow e.g.
1202  // edge elements to have a 3D interior_parent with no
1203  // intermediate 2D element.
1204  // libmesh_assert (!interior_p ||
1205  // interior_p->dim() == (this->dim()+1));
1206  libmesh_assert (!interior_p ||
1207  (interior_p == remote_elem) ||
1208  (interior_p->dim() > this->dim()));
1209 
1210  // If an element in a multi-dimensional mesh has an interior_parent
1211  // link, it should be at our level or coarser, just like a neighbor
1212  // link. Our collect_families() code relies on this, but it might
1213  // be tempting for users to manually assign something that breaks
1214  // it.
1215  //
1216  // However, we *also* create temporary side elements, and we don't
1217  // bother with creating ancestors for those, so they can be at level
1218  // 0 even when they're sides of non-level-0 elements.
1219  libmesh_assert (!interior_p ||
1220  (interior_p->level() <= this->level()) ||
1221  (this->level() == 0 &&
1222  this->id() == DofObject::invalid_id));
1223 
1224  return interior_p;
1225 }
dof_id_type id() const
Definition: dof_object.h:828
static constexpr dof_id_type invalid_id
An invalid id to distinguish an uninitialized DofObject.
Definition: dof_object.h:482
Elem ** _elemlinks
Pointers to this element&#39;s parent and neighbors, and for lower-dimensional elements&#39; interior_parent...
Definition: elem.h:2252
libmesh_assert(ctx)
Elem(const unsigned int n_nodes, const unsigned int n_sides, Elem *parent, Elem **elemlinkdata, Node **nodelinkdata)
Constructor.
Definition: elem.h:2379
virtual unsigned int n_sides() const =0
unsigned int level() const
Definition: elem.h:3075
virtual unsigned short dim() const =0
const RemoteElem * remote_elem
Definition: remote_elem.C:57

◆ interior_parent() [2/2]

Elem * libMesh::Elem::interior_parent ( )
inherited

Definition at line 1229 of file elem.C.

References libMesh::Elem::_elemlinks, libMesh::Elem::dim(), libMesh::libmesh_assert(), libMesh::Elem::n_sides(), and libMesh::remote_elem.

1230 {
1231  // See the const version for comments
1232  if (this->dim() >= LIBMESH_DIM)
1233  return nullptr;
1234 
1235  Elem * interior_p = _elemlinks[1+this->n_sides()];
1236 
1237  libmesh_assert (!interior_p ||
1238  (interior_p == remote_elem) ||
1239  (interior_p->dim() > this->dim()));
1240 
1241  return interior_p;
1242 }
Elem ** _elemlinks
Pointers to this element&#39;s parent and neighbors, and for lower-dimensional elements&#39; interior_parent...
Definition: elem.h:2252
libmesh_assert(ctx)
Elem(const unsigned int n_nodes, const unsigned int n_sides, Elem *parent, Elem **elemlinkdata, Node **nodelinkdata)
Constructor.
Definition: elem.h:2379
virtual unsigned int n_sides() const =0
virtual unsigned short dim() const =0
const RemoteElem * remote_elem
Definition: remote_elem.C:57

◆ invalidate()

void libMesh::DofObject::invalidate ( )
inlineinherited

Invalidates all the indices for this DofObject.

Definition at line 788 of file dof_object.h.

References libMesh::DofObject::invalidate_dofs(), libMesh::DofObject::invalidate_id(), and libMesh::DofObject::invalidate_processor_id().

Referenced by libMesh::DofObject::DofObject().

789 {
790  this->invalidate_dofs ();
791  this->invalidate_id ();
792  this->invalidate_processor_id ();
793 }
void invalidate_id()
Sets the id to invalid_id.
Definition: dof_object.h:772
void invalidate_processor_id()
Sets the processor id to invalid_processor_id.
Definition: dof_object.h:780
void invalidate_dofs(const unsigned int sys_num=libMesh::invalid_uint)
Sets all degree of freedom numbers to invalid_id.
Definition: dof_object.h:751

◆ invalidate_dofs()

void libMesh::DofObject::invalidate_dofs ( const unsigned int  sys_num = libMesh::invalid_uint)
inlineinherited

Sets all degree of freedom numbers to invalid_id.

Definition at line 751 of file dof_object.h.

References libMesh::DofObject::invalid_id, libMesh::make_range(), libMesh::DofObject::n_comp_group(), libMesh::DofObject::n_systems(), libMesh::DofObject::n_var_groups(), and libMesh::DofObject::set_vg_dof_base().

Referenced by libMesh::DofObject::invalidate().

752 {
753  const unsigned int n_sys = this->n_systems();
754  // If the user does not specify the system number...
755  if (sys_num >= n_sys)
756  {
757  for (auto s : make_range(n_sys))
758  for (auto vg : make_range(this->n_var_groups(s)))
759  if (this->n_comp_group(s,vg))
760  this->set_vg_dof_base(s,vg,invalid_id);
761  }
762  // ...otherwise invalidate the dofs for all systems
763  else
764  for (auto vg : make_range(this->n_var_groups(sys_num)))
765  if (this->n_comp_group(sys_num,vg))
766  this->set_vg_dof_base(sys_num,vg,invalid_id);
767 }
unsigned int n_var_groups(const unsigned int s) const
Definition: dof_object.h:957
void set_vg_dof_base(const unsigned int s, const unsigned int vg, const dof_id_type db)
VariableGroup DoF indices are indexed as id = base + var_in_vg*ncomp + comp This method allows for di...
Definition: dof_object.h:1297
static constexpr dof_id_type invalid_id
An invalid id to distinguish an uninitialized DofObject.
Definition: dof_object.h:482
unsigned int n_systems() const
Definition: dof_object.h:937
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140
unsigned int n_comp_group(const unsigned int s, const unsigned int vg) const
Definition: dof_object.h:1015

◆ invalidate_id()

void libMesh::DofObject::invalidate_id ( )
inlineinherited

Sets the id to invalid_id.

Definition at line 772 of file dof_object.h.

References libMesh::DofObject::invalid_id, and libMesh::DofObject::set_id().

Referenced by libMesh::DofObject::invalidate(), and DofObjectTest< Node >::testInvalidateId().

773 {
774  this->set_id (invalid_id);
775 }
dof_id_type & set_id()
Definition: dof_object.h:836
static constexpr dof_id_type invalid_id
An invalid id to distinguish an uninitialized DofObject.
Definition: dof_object.h:482

◆ invalidate_processor_id()

void libMesh::DofObject::invalidate_processor_id ( )
inlineinherited

Sets the processor id to invalid_processor_id.

Definition at line 780 of file dof_object.h.

References libMesh::DofObject::invalid_processor_id, and libMesh::DofObject::processor_id().

Referenced by libMesh::DofObject::invalidate(), libMesh::Partitioner::set_parent_processor_ids(), and DofObjectTest< Node >::testInvalidateProcId().

781 {
783 }
static constexpr processor_id_type invalid_processor_id
An invalid processor_id to distinguish DoFs that have not been assigned to a processor.
Definition: dof_object.h:493
processor_id_type processor_id() const
Definition: dof_object.h:905

◆ is_ancestor_of()

bool libMesh::Elem::is_ancestor_of ( const Elem descendant) const
inlineinherited
Returns
true if descendant is a child of this, or a child of a child of this, etc., false otherwise or if AMR is disabled.

Definition at line 3010 of file elem.h.

References libMesh::Elem::parent().

Referenced by libMesh::UnstructuredMesh::find_neighbors().

3015 {
3016 #ifdef LIBMESH_ENABLE_AMR
3017  const Elem * e = descendant;
3018  while (e)
3019  {
3020  if (this == e)
3021  return true;
3022  e = e->parent();
3023  }
3024 #endif
3025  return false;
3026 }
Elem(const unsigned int n_nodes, const unsigned int n_sides, Elem *parent, Elem **elemlinkdata, Node **nodelinkdata)
Constructor.
Definition: elem.h:2379

◆ is_child_on_edge()

bool libMesh::Elem::is_child_on_edge ( const unsigned int  c,
const unsigned int  e 
) const
virtualinherited
Returns
true if the specified child is on the specified edge.

Definition at line 2304 of file elem.C.

References libMesh::Elem::build_edge_ptr(), libMesh::Elem::child_ptr(), libMesh::Elem::n_children(), and libMesh::Elem::n_edges().

Referenced by libMesh::FEGenericBase< FEOutputType< T >::type >::coarsened_dof_values(), libMesh::BoundaryInfo::edge_boundary_ids(), and libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectEdges::operator()().

2306 {
2307  libmesh_assert_less (c, this->n_children());
2308  libmesh_assert_less (e, this->n_edges());
2309 
2310  std::unique_ptr<const Elem> my_edge = this->build_edge_ptr(e);
2311  std::unique_ptr<const Elem> child_edge = this->child_ptr(c)->build_edge_ptr(e);
2312 
2313  // We're assuming that an overlapping child edge has the same
2314  // number and orientation as its parent
2315  return (child_edge->node_id(0) == my_edge->node_id(0) ||
2316  child_edge->node_id(1) == my_edge->node_id(1));
2317 }
virtual unsigned int n_children() const =0
virtual unsigned int n_edges() const =0
virtual std::unique_ptr< Elem > build_edge_ptr(const unsigned int i)=0
const Elem * child_ptr(unsigned int i) const
Definition: elem.h:3164

◆ is_child_on_side()

bool libMesh::Pyramid::is_child_on_side ( const unsigned int  c,
const unsigned int  s 
) const
overridevirtualinherited
Returns
true if the specified child is on the specified side.

Implements libMesh::Elem.

Definition at line 237 of file cell_pyramid.C.

References libMesh::Pyramid::n_children(), libMesh::Pyramid::n_sides(), and side_nodes_map.

239 {
240  libmesh_assert_less (c, this->n_children());
241  libmesh_assert_less (s, this->n_sides());
242 
243  for (unsigned int i = 0; i != 4; ++i)
244  if (Pyramid5::side_nodes_map[s][i] == c)
245  return true;
246  return false;
247 }
virtual unsigned int n_sides() const override
Definition: cell_pyramid.h:90
virtual unsigned int n_children() const override
Definition: cell_pyramid.h:110
static const unsigned int side_nodes_map[num_sides][nodes_per_side]
This maps the node of the side to element node numbers.

◆ is_edge()

bool libMesh::Pyramid5::is_edge ( const unsigned int  i) const
overridevirtual
Returns
true if the specified (local) node number is an edge.

Implements libMesh::Elem.

Definition at line 70 of file cell_pyramid5.C.

71 {
72  return false;
73 }

◆ is_edge_on_side()

bool libMesh::Pyramid::is_edge_on_side ( const unsigned int  e,
const unsigned int  s 
) const
overridevirtualinherited
Returns
true if the specified edge is on the specified side.

Implements libMesh::Elem.

Definition at line 251 of file cell_pyramid.C.

References libMesh::Pyramid::edge_sides_map, libMesh::Pyramid::n_edges(), and libMesh::Pyramid::n_sides().

253 {
254  libmesh_assert_less (e, this->n_edges());
255  libmesh_assert_less (s, this->n_sides());
256 
257  return (edge_sides_map[e][0] == s || edge_sides_map[e][1] == s);
258 }
virtual unsigned int n_sides() const override
Definition: cell_pyramid.h:90
virtual unsigned int n_edges() const override
Definition: cell_pyramid.h:100
static const unsigned int edge_sides_map[8][2]
This maps each edge to the sides that contain said edge.
Definition: cell_pyramid.h:199

◆ is_face()

bool libMesh::Pyramid5::is_face ( const unsigned int  i) const
overridevirtual
Returns
true if the specified (local) node number is a face.

Implements libMesh::Elem.

Definition at line 75 of file cell_pyramid5.C.

76 {
77  return false;
78 }

◆ is_flipped()

bool libMesh::Pyramid::is_flipped ( ) const
finaloverridevirtualinherited
Returns
Whether the element is flipped compared to standard libMesh (e.g. clockwise for 2D elements) node orientations.

Always returns false if a 2D element is not in the XY plane or a 1D element is not on the X axis; user code designed to work for embedded manifolds should handle any consistent orientation, and determining whether an orientation is consistent is not a local operation.

Implements libMesh::Elem.

Definition at line 270 of file cell_pyramid.C.

References libMesh::Elem::point(), and libMesh::triple_product().

271 {
272  return (triple_product(this->point(1)-this->point(0),
273  this->point(3)-this->point(0),
274  this->point(4)-this->point(0)) < 0);
275 }
T triple_product(const TypeVector< T > &a, const TypeVector< T > &b, const TypeVector< T > &c)
Definition: type_vector.h:1029
const Point & point(const unsigned int i) const
Definition: elem.h:2454

◆ is_internal()

bool libMesh::Elem::is_internal ( const unsigned int  i) const
inherited
Returns
true if the specified (local) node number is an internal node.

Definition at line 3581 of file elem.C.

References libMesh::Elem::dim(), libMesh::Elem::is_edge(), libMesh::Elem::is_face(), and libMesh::Elem::is_vertex().

Referenced by libMesh::Prism::edges_adjacent_to_node(), libMesh::Hex::edges_adjacent_to_node(), libMesh::InfPrism::edges_adjacent_to_node(), and libMesh::InfHex::edges_adjacent_to_node().

3582 {
3583  switch (this->dim())
3584  {
3585  case 0:
3586  return false;
3587 
3588  case 1:
3589  return !this->is_vertex(i);
3590 
3591  case 2:
3592  return !this->is_vertex(i) && !this->is_edge(i);
3593 
3594  case 3:
3595  return !this->is_vertex(i) && !this->is_edge(i) && !this->is_face(i);
3596 
3597  default:
3598  libmesh_error_msg("impossible element dimension " << std::to_string(this->dim()));
3599  return 0;
3600  }
3601 }
virtual bool is_face(const unsigned int i) const =0
virtual unsigned short dim() const =0
virtual bool is_vertex(const unsigned int i) const =0
virtual bool is_edge(const unsigned int i) const =0

◆ is_linear()

virtual bool libMesh::Elem::is_linear ( ) const
inlinevirtualinherited
Returns
true if the Lagrange shape functions on this element are linear.

Reimplemented in libMesh::NodeElem, libMesh::Tet4, libMesh::Tri3, libMesh::Edge2, and libMesh::Tri3Subdivision.

Definition at line 1214 of file elem.h.

Referenced by libMesh::FEMap::init_reference_to_physical_map().

1214 { return false; }

◆ is_mid_infinite_edge_node()

virtual bool libMesh::Elem::is_mid_infinite_edge_node ( const unsigned int  ) const
inlinevirtualinherited
Returns
true if the specified (local) node number is a "mid-edge" node on an infinite element edge.

This is false for all nodes on non-infinite elements, so we won't make it pure virtual, to simplify their code.

Reimplemented in libMesh::InfEdge2, libMesh::InfQuad, libMesh::InfPrism, and libMesh::InfHex.

Definition at line 1906 of file elem.h.

References libMesh::Elem::infinite(), and libMesh::libmesh_assert().

Referenced by libMesh::Elem::parent_bracketing_nodes().

1907  { libmesh_assert (!this->infinite()); return false; }
libmesh_assert(ctx)
virtual bool infinite() const =0

◆ is_node_on_edge()

bool libMesh::Pyramid5::is_node_on_edge ( const unsigned int  n,
const unsigned int  e 
) const
overridevirtual
Returns
true if the specified (local) node number is on the specified edge.

Implements libMesh::Elem.

Definition at line 104 of file cell_pyramid5.C.

References edge_nodes_map, and libMesh::Pyramid::n_edges().

106 {
107  libmesh_assert_less (e, n_edges());
108  return std::find(std::begin(edge_nodes_map[e]),
109  std::end(edge_nodes_map[e]),
110  n) != std::end(edge_nodes_map[e]);
111 }
static const unsigned int edge_nodes_map[num_edges][nodes_per_edge]
This maps the node of the edge to element node numbers.
virtual unsigned int n_edges() const override
Definition: cell_pyramid.h:100

◆ is_node_on_side()

bool libMesh::Pyramid5::is_node_on_side ( const unsigned int  n,
const unsigned int  s 
) const
overridevirtual
Returns
true if the specified (local) node number is on the specified side.

Implements libMesh::Elem.

Definition at line 80 of file cell_pyramid5.C.

References libMesh::Pyramid::n_sides(), and side_nodes_map.

82 {
83  libmesh_assert_less (s, n_sides());
84  return std::find(std::begin(side_nodes_map[s]),
85  std::end(side_nodes_map[s]),
86  n) != std::end(side_nodes_map[s]);
87 }
virtual unsigned int n_sides() const override
Definition: cell_pyramid.h:90
static const unsigned int side_nodes_map[num_sides][nodes_per_side]
This maps the node of the side to element node numbers.

◆ is_remote()

virtual bool libMesh::Elem::is_remote ( ) const
inlinevirtualinherited
Returns
true if this element is remote, false otherwise.

A remote element (see RemoteElem) is a syntactic convenience – it is a placeholder for an element which exists on some other processor. Local elements are required to have valid neighbors, and these ghost elements may have remote neighbors for data structure consistency. The use of remote elements helps ensure that any element we may access has a nullptr neighbor only if it lies on the physical boundary of the domain.

Reimplemented in libMesh::RemoteElem.

Definition at line 598 of file elem.h.

Referenced by libMesh::Elem::make_links_to_me_local().

599  { return false; }

◆ is_semilocal()

bool libMesh::Elem::is_semilocal ( const processor_id_type  my_pid) const
inherited
Returns
true if this element is "semilocal" to the calling processor, which must specify its rank.

This method is discouraged, as it uses the old definition of semilocal (elements which are not local but which are point neighbors of something local) rather than any of the new definitions discussed in ghosting_functor.h

Definition at line 853 of file elem.C.

References libMesh::Elem::find_point_neighbors().

854 {
855  std::set<const Elem *> point_neighbors;
856 
857  this->find_point_neighbors(point_neighbors);
858 
859  for (const auto & elem : point_neighbors)
860  if (elem->processor_id() == my_pid)
861  return true;
862 
863  return false;
864 }
void find_point_neighbors(const Point &p, std::set< const Elem *> &neighbor_set) const
This function finds all active elements (including this one) which are in the same manifold as this e...
Definition: elem.C:991

◆ is_singular_node()

virtual bool libMesh::Pyramid::is_singular_node ( unsigned int  node_idx) const
inlinefinaloverridevirtualinherited
Returns
true iff the node at the given index has a singular mapping; i.e. is the degree-4 node on a Pyramid.

Reimplemented from libMesh::Elem.

Definition at line 185 of file cell_pyramid.h.

185 { return (node_idx == 4); }

◆ is_vertex()

bool libMesh::Pyramid5::is_vertex ( const unsigned int  i) const
overridevirtual
Returns
true if the specified (local) node number is a vertex.

Implements libMesh::Elem.

Definition at line 64 of file cell_pyramid5.C.

References libMesh::invalid_uint.

65 {
66  libmesh_assert_not_equal_to (n, invalid_uint);
67  return true;
68 }
const unsigned int invalid_uint
A number which is used quite often to represent an invalid or uninitialized value for an unsigned int...
Definition: libmesh.h:310

◆ is_vertex_on_child()

virtual bool libMesh::Elem::is_vertex_on_child ( unsigned  int,
unsigned int  n 
) const
inlinevirtualinherited
Returns
true if the specified child has a vertex at the specified (child-local) node number. Except in odd cases like pyramid refinement the child will have the same local structure as the parent element.

Definition at line 775 of file elem.h.

References libMesh::Elem::is_vertex().

Referenced by libMesh::Elem::parent_bracketing_nodes().

777  { return this->is_vertex(n); }
virtual bool is_vertex(const unsigned int i) const =0

◆ is_vertex_on_parent()

bool libMesh::Elem::is_vertex_on_parent ( unsigned int  c,
unsigned int  n 
) const
virtualinherited
Returns
true if this element has a vertex at the specified (child-local) node number n of the specified child c.

Definition at line 3502 of file elem.C.

References libMesh::Elem::child_ptr(), libMesh::libmesh_ignore(), libMesh::Elem::n_vertices(), and libMesh::Elem::node_ptr().

Referenced by libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectVertices::operator()().

3504 {
3505 #ifdef LIBMESH_ENABLE_AMR
3506 
3507  unsigned int my_n_vertices = this->n_vertices();
3508  for (unsigned int n_parent = 0; n_parent != my_n_vertices;
3509  ++n_parent)
3510  if (this->node_ptr(n_parent) == this->child_ptr(c)->node_ptr(n))
3511  return true;
3512  return false;
3513 
3514 #else
3515 
3516  // No AMR?
3517  libmesh_ignore(c,n);
3518  libmesh_error_msg("ERROR: AMR disabled, how did we get here?");
3519  return true;
3520 
3521 #endif
3522 }
void libmesh_ignore(const Args &...)
virtual unsigned int n_vertices() const =0
const Node * node_ptr(const unsigned int i) const
Definition: elem.h:2508
const Elem * child_ptr(unsigned int i) const
Definition: elem.h:3164

◆ key() [1/4]

virtual dof_id_type libMesh::Elem::key
inherited

Don't hide Elem::key() defined in the base class.

◆ key() [2/4]

dof_id_type libMesh::Elem::key
inherited

Don't hide Elem::key() defined in the base class.

Definition at line 751 of file elem.C.

752 {
753  const unsigned short n_n = this->n_nodes();
754 
755  std::array<dof_id_type, Elem::max_n_nodes> node_ids;
756 
757  for (unsigned short n=0; n != n_n; ++n)
758  node_ids[n] = this->node_id(n);
759 
760  // Always sort, so that different local node numberings hash to the
761  // same value.
762  std::sort (node_ids.begin(), node_ids.begin()+n_n);
763 
764  return Utility::hashword(node_ids.data(), n_n);
765 }
uint32_t hashword(const uint32_t *k, size_t length, uint32_t initval=0)
The hashword function takes an array of uint32_t&#39;s of length &#39;length&#39; and computes a single key from ...
Definition: hashword.h:158
virtual unsigned int n_nodes() const override
Definition: cell_pyramid.h:85
dof_id_type node_id(const unsigned int i) const
Definition: elem.h:2476

◆ key() [3/4]

dof_id_type libMesh::Pyramid::key ( const unsigned int  s) const
overridevirtualinherited
Returns
An id associated with the s side of this element. The id is not necessarily unique, but should be close.

Implements libMesh::Elem.

Reimplemented in libMesh::Pyramid18, and libMesh::Pyramid14.

Definition at line 77 of file cell_pyramid.C.

References libMesh::Elem::compute_key(), libMesh::Pyramid::n_sides(), libMesh::Elem::node_id(), and side_nodes_map.

78 {
79  libmesh_assert_less (s, this->n_sides());
80 
81  switch (s)
82  {
83  case 0: // triangular face 1
84  case 1: // triangular face 2
85  case 2: // triangular face 3
86  case 3: // triangular face 4
87  return this->compute_key (this->node_id(Pyramid5::side_nodes_map[s][0]),
88  this->node_id(Pyramid5::side_nodes_map[s][1]),
89  this->node_id(Pyramid5::side_nodes_map[s][2]));
90 
91  case 4: // the quad face at z=0
92  return this->compute_key (this->node_id(Pyramid5::side_nodes_map[s][0]),
93  this->node_id(Pyramid5::side_nodes_map[s][1]),
94  this->node_id(Pyramid5::side_nodes_map[s][2]),
95  this->node_id(Pyramid5::side_nodes_map[s][3]));
96 
97  default:
98  libmesh_error_msg("Invalid side s = " << s);
99  }
100 }
virtual unsigned int n_sides() const override
Definition: cell_pyramid.h:90
static const unsigned int side_nodes_map[num_sides][nodes_per_side]
This maps the node of the side to element node numbers.
static dof_id_type compute_key(dof_id_type n0)
Definition: elem.h:3295
dof_id_type node_id(const unsigned int i) const
Definition: elem.h:2476

◆ key() [4/4]

dof_id_type libMesh::Elem::key ( ) const
virtualinherited
Returns
An id associated with the global node ids of this element. The id is not necessarily unique, but should be close. Uses the same hash as the key(s) function, so for example if "tri3" is side 0 of "tet4", then tri3->key()==tet4->key(0).

Reimplemented in libMesh::Tet4, libMesh::Edge3, libMesh::Edge4, libMesh::Edge2, libMesh::Quad9, libMesh::Quad, libMesh::Polyhedron, libMesh::Polygon, and libMesh::Tri.

Definition at line 751 of file elem.C.

References libMesh::Utility::hashword(), libMesh::Elem::n_nodes(), and libMesh::Elem::node_id().

Referenced by libMesh::InfQuad6::key(), libMesh::Prism18::key(), libMesh::Pyramid14::key(), and libMesh::InfHex18::key().

752 {
753  const unsigned short n_n = this->n_nodes();
754 
755  std::array<dof_id_type, Elem::max_n_nodes> node_ids;
756 
757  for (unsigned short n=0; n != n_n; ++n)
758  node_ids[n] = this->node_id(n);
759 
760  // Always sort, so that different local node numberings hash to the
761  // same value.
762  std::sort (node_ids.begin(), node_ids.begin()+n_n);
763 
764  return Utility::hashword(node_ids.data(), n_n);
765 }
uint32_t hashword(const uint32_t *k, size_t length, uint32_t initval=0)
The hashword function takes an array of uint32_t&#39;s of length &#39;length&#39; and computes a single key from ...
Definition: hashword.h:158
virtual unsigned int n_nodes() const =0
dof_id_type node_id(const unsigned int i) const
Definition: elem.h:2476

◆ length()

Real libMesh::Elem::length ( const unsigned int  n1,
const unsigned int  n2 
) const
inherited
Returns
The distance between nodes n1 and n2.

Useful for computing the lengths of the sides of elements.

Definition at line 740 of file elem.C.

References libMesh::Elem::n_vertices(), and libMesh::Elem::point().

Referenced by libMesh::Hex::quality(), libMesh::Quad::quality(), and libMesh::InfHex::quality().

742 {
743  libmesh_assert_less ( n1, this->n_vertices() );
744  libmesh_assert_less ( n2, this->n_vertices() );
745 
746  return (this->point(n1) - this->point(n2)).norm();
747 }
virtual unsigned int n_vertices() const =0
const Point & point(const unsigned int i) const
Definition: elem.h:2454

◆ level()

unsigned int libMesh::Elem::level ( ) const
inlineinherited
Returns
The refinement level of the current element.

If the element's parent is nullptr then by convention it is at level 0, otherwise it is simply at one level greater than its parent.

Definition at line 3075 of file elem.h.

References libMesh::Elem::dim(), libMesh::Elem::level(), and libMesh::Elem::parent().

Referenced by libMesh::BoundaryInfo::add_edge(), libMesh::BoundaryInfo::add_shellface(), libMesh::BoundaryInfo::add_side(), assemble_ellipticdg(), libMesh::BoundaryInfo::boundary_ids(), libMesh::EquationSystems::build_discontinuous_solution_vector(), compute_jacobian(), libMesh::FEAbstract::compute_node_constraints(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), libMesh::FEAbstract::compute_periodic_node_constraints(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_proj_constraints(), compute_residual(), libMesh::Elem::contains_vertex_of(), libMesh::BoundaryInfo::edge_boundary_ids(), libMesh::MeshRefinement::enforce_mismatch_limit_prior_to_refinement(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::MeshTools::find_hanging_nodes_and_parents(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::Elem::get_info(), libMesh::InfFE< Dim, T_radial, T_map >::inf_compute_constraints(), libMesh::InfFE< Dim, T_radial, T_map >::inf_compute_node_constraints(), libMesh::Poly2TriTriangulator::insert_refinement_points(), libMesh::Elem::interior_parent(), libMesh::Elem::level(), libMesh::MeshTools::libmesh_assert_valid_amr_interior_parents(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::Elem::make_links_to_me_local(), libMesh::Elem::make_links_to_me_remote(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::Elem::nullify_neighbors(), libMesh::CompareElemIdsByLevel::operator()(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::BoundaryInfo::remove_edge(), libMesh::Elem::remove_links_to_me(), libMesh::BoundaryInfo::remove_shellface(), libMesh::BoundaryInfo::remove_side(), libMesh::BoundaryInfo::shellface_boundary_ids(), libMesh::BoundaryInfo::side_boundary_ids(), libMesh::BoundaryInfo::side_with_boundary_id(), libMesh::BoundaryInfo::sides_with_boundary_id(), libMesh::UnstructuredMesh::stitching_helper(), libMesh::MeshRefinement::test_level_one(), libMesh::Elem::top_parent(), libMesh::Elem::topological_neighbor(), libMesh::MeshTetInterface::volume_to_surface_mesh(), and libMesh::Elem::which_neighbor_am_i().

3076 {
3077 #ifdef LIBMESH_ENABLE_AMR
3078 
3079  // if I don't have a parent I was
3080  // created directly from file
3081  // or by the user, so I am a
3082  // level-0 element
3083  if (this->parent() == nullptr)
3084  return 0;
3085 
3086  // if the parent and this element are of different
3087  // dimensionality we are at the same level as
3088  // the parent (e.g. we are the 2D side of a
3089  // 3D element)
3090  if (this->dim() != this->parent()->dim())
3091  return this->parent()->level();
3092 
3093  // otherwise we are at a level one
3094  // higher than our parent
3095  return (this->parent()->level() + 1);
3096 
3097 #else
3098 
3099  // Without AMR all elements are
3100  // at level 0.
3101  return 0;
3102 
3103 #endif
3104 }
const Elem * parent() const
Definition: elem.h:3031
unsigned int level() const
Definition: elem.h:3075
virtual unsigned short dim() const =0

◆ libmesh_assert_valid_neighbors()

void libMesh::Elem::libmesh_assert_valid_neighbors ( ) const
inherited

Checks for consistent neighbor links on this element.

Definition at line 1381 of file elem.C.

References libMesh::Elem::dim(), libMesh::libmesh_assert(), libMesh::Elem::n_neighbors(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::parent(), libMesh::remote_elem, libMesh::Elem::side_index_range(), libMesh::Elem::subactive(), and libMesh::Elem::which_neighbor_am_i().

1382 {
1383  for (auto n : this->side_index_range())
1384  {
1385  const Elem * neigh = this->neighbor_ptr(n);
1386 
1387  // Any element might have a remote neighbor; checking
1388  // to make sure that's not inaccurate is tough.
1389  if (neigh == remote_elem)
1390  continue;
1391 
1392  if (neigh)
1393  {
1394  // Only subactive elements have subactive neighbors
1395  libmesh_assert (this->subactive() || !neigh->subactive());
1396 
1397  const Elem * elem = this;
1398 
1399  // If we're subactive but our neighbor isn't, its
1400  // return neighbor link will be to our first active
1401  // ancestor OR to our inactive ancestor of the same
1402  // level as neigh,
1403  if (this->subactive() && !neigh->subactive())
1404  {
1405  for (elem = this; !elem->active();
1406  elem = elem->parent())
1407  libmesh_assert(elem);
1408  }
1409  else
1410  {
1411  unsigned int rev = neigh->which_neighbor_am_i(elem);
1412  libmesh_assert_less (rev, neigh->n_neighbors());
1413 
1414  if (this->subactive() && !neigh->subactive())
1415  {
1416  while (neigh->neighbor_ptr(rev) != elem)
1417  {
1418  libmesh_assert(elem->parent());
1419  elem = elem->parent();
1420  }
1421  }
1422  else
1423  {
1424  const Elem * nn = neigh->neighbor_ptr(rev);
1425  libmesh_assert(nn);
1426 
1427  for (; elem != nn; elem = elem->parent())
1428  libmesh_assert(elem);
1429  }
1430  }
1431  }
1432  // If we don't have a neighbor and we're not subactive, our
1433  // ancestors shouldn't have any neighbors in this same
1434  // direction.
1435  else if (!this->subactive())
1436  {
1437  const Elem * my_parent = this->parent();
1438  if (my_parent &&
1439  // A parent with a different dimension isn't really one of
1440  // our ancestors, it means we're on a boundary mesh and this
1441  // is an interior mesh element for which we're on a side.
1442  // Nothing to test for in that case.
1443  (my_parent->dim() == this->dim()))
1444  libmesh_assert (!my_parent->neighbor_ptr(n));
1445  }
1446  }
1447 }
const Elem * parent() const
Definition: elem.h:3031
IntRange< unsigned short > side_index_range() const
Definition: elem.h:2711
libmesh_assert(ctx)
Elem(const unsigned int n_nodes, const unsigned int n_sides, Elem *parent, Elem **elemlinkdata, Node **nodelinkdata)
Constructor.
Definition: elem.h:2379
const Elem * neighbor_ptr(unsigned int i) const
Definition: elem.h:2599
virtual unsigned short dim() const =0
bool subactive() const
Definition: elem.h:2960
const RemoteElem * remote_elem
Definition: remote_elem.C:57

◆ libmesh_assert_valid_node_pointers()

void libMesh::Elem::libmesh_assert_valid_node_pointers ( ) const
inherited

Checks for a valid id and pointers to nodes with valid ids on this element.

Definition at line 1369 of file elem.C.

References libMesh::libmesh_assert(), libMesh::Elem::node_index_range(), libMesh::Elem::node_ptr(), and libMesh::DofObject::valid_id().

1370 {
1371  libmesh_assert(this->valid_id());
1372  for (auto n : this->node_index_range())
1373  {
1374  libmesh_assert(this->node_ptr(n));
1375  libmesh_assert(this->node_ptr(n)->valid_id());
1376  }
1377 }
libmesh_assert(ctx)
bool valid_id() const
Definition: dof_object.h:885
const Node * node_ptr(const unsigned int i) const
Definition: elem.h:2508
IntRange< unsigned short > node_index_range() const
Definition: elem.h:2684

◆ local_edge_node()

unsigned int libMesh::Pyramid::local_edge_node ( unsigned int  edge,
unsigned int  edge_node 
) const
overridevirtualinherited
Returns
Pyramid5::edge_nodes_map[edge][edge_node] after doing some range checking.

Implements libMesh::Elem.

Reimplemented in libMesh::Pyramid18, libMesh::Pyramid14, and libMesh::Pyramid13.

Definition at line 147 of file cell_pyramid.C.

References edge_nodes_map, libMesh::Pyramid::n_edges(), and nodes_per_edge.

149 {
150  libmesh_assert_less(edge, this->n_edges());
151  libmesh_assert_less(edge_node, Pyramid5::nodes_per_edge);
152 
153  return Pyramid5::edge_nodes_map[edge][edge_node];
154 }
static const int nodes_per_edge
static const unsigned int edge_nodes_map[num_edges][nodes_per_edge]
This maps the node of the edge to element node numbers.
virtual unsigned int n_edges() const override
Definition: cell_pyramid.h:100

◆ local_node()

unsigned int libMesh::Elem::local_node ( const dof_id_type  i) const
inlineinherited
Returns
The local id number of global Node id i, or invalid_uint if Node id i is not local.

Definition at line 2488 of file elem.h.

References libMesh::invalid_uint, libMesh::make_range(), libMesh::Elem::n_nodes(), and libMesh::Elem::node_id().

Referenced by NodalNeighborsTest::do_test(), and libMesh::UnstructuredMesh::stitching_helper().

2489 {
2490  for (auto n : make_range(this->n_nodes()))
2491  if (this->node_id(n) == i)
2492  return n;
2493 
2494  return libMesh::invalid_uint;
2495 }
const unsigned int invalid_uint
A number which is used quite often to represent an invalid or uninitialized value for an unsigned int...
Definition: libmesh.h:310
virtual unsigned int n_nodes() const =0
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140
dof_id_type node_id(const unsigned int i) const
Definition: elem.h:2476

◆ local_side_node()

unsigned int libMesh::Pyramid::local_side_node ( unsigned int  side,
unsigned int  side_node 
) const
overridevirtualinherited
Returns
Pyramid5::side_nodes_map[side][side_node] after doing some range checking.

Implements libMesh::Elem.

Reimplemented in libMesh::Pyramid18, libMesh::Pyramid14, and libMesh::Pyramid13.

Definition at line 131 of file cell_pyramid.C.

References libMesh::libmesh_assert(), libMesh::Pyramid::n_sides(), nodes_per_side, and side_nodes_map.

133 {
134  libmesh_assert_less (side, this->n_sides());
135 
136  // Never more than 4 nodes per side.
137  libmesh_assert_less(side_node, Pyramid5::nodes_per_side);
138 
139  // Some sides have 3 nodes.
140  libmesh_assert(side == 4 || side_node < 3);
141 
142  return Pyramid5::side_nodes_map[side][side_node];
143 }
virtual unsigned int n_sides() const override
Definition: cell_pyramid.h:90
libmesh_assert(ctx)
static const int nodes_per_side
static const unsigned int side_nodes_map[num_sides][nodes_per_side]
This maps the node of the side to element node numbers.

◆ local_singular_node()

unsigned int libMesh::Pyramid::local_singular_node ( const Point p,
const Real  tol = TOLERANCE*TOLERANCE 
) const
finaloverridevirtualinherited
Returns
Node 4 (the apex) if is at the apex within the tolerance tol. If is not at the apex within the tolerance tol, will return invalid_uint.

The Jacobian at the apex is singular because directional derivatives are defined in four directions, independently (four edges meet). Therefore, we can check for this in a caught, failed inverse mapping and return the correct point without failure if it is the apex. This behavior does require exceptions to be enabled.

Reimplemented from libMesh::Elem.

Definition at line 294 of file cell_pyramid.C.

References libMesh::TypeVector< T >::absolute_fuzzy_equals(), libMesh::invalid_uint, and libMesh::Elem::node_ref().

295 {
296  return this->node_ref(4).absolute_fuzzy_equals(p, tol) ? 4 : invalid_uint;
297 }
const unsigned int invalid_uint
A number which is used quite often to represent an invalid or uninitialized value for an unsigned int...
Definition: libmesh.h:310
const Node & node_ref(const unsigned int i) const
Definition: elem.h:2530
bool absolute_fuzzy_equals(const TypeVector< T > &rhs, Real tol=TOLERANCE) const
Definition: type_vector.h:972

◆ loose_bounding_box()

BoundingBox libMesh::Pyramid5::loose_bounding_box ( ) const
overridevirtual

Builds a bounding box out of the nodal positions.

Reimplemented from libMesh::Cell.

Definition at line 269 of file cell_pyramid5.C.

References libMesh::Elem::loose_bounding_box().

270 {
271  return Elem::loose_bounding_box();
272 }
virtual BoundingBox loose_bounding_box() const
Definition: elem.C:3469

◆ low_order_key()

dof_id_type libMesh::Pyramid::low_order_key ( const unsigned int  s) const
overridevirtualinherited
Returns
An id associated with the s side of this element, as defined solely by element vertices. The id is not necessarily unique, but should be close. This is particularly useful in the MeshBase::find_neighbors() routine.

Implements libMesh::Elem.

Definition at line 104 of file cell_pyramid.C.

References libMesh::Elem::compute_key(), libMesh::Pyramid::n_sides(), libMesh::Elem::node_id(), and side_nodes_map.

105 {
106  libmesh_assert_less (s, this->n_sides());
107 
108  switch (s)
109  {
110  case 0: // triangular face 1
111  case 1: // triangular face 2
112  case 2: // triangular face 3
113  case 3: // triangular face 4
114  return this->compute_key (this->node_id(Pyramid5::side_nodes_map[s][0]),
115  this->node_id(Pyramid5::side_nodes_map[s][1]),
116  this->node_id(Pyramid5::side_nodes_map[s][2]));
117 
118  case 4: // the quad face at z=0
119  return this->compute_key (this->node_id(Pyramid5::side_nodes_map[s][0]),
120  this->node_id(Pyramid5::side_nodes_map[s][1]),
121  this->node_id(Pyramid5::side_nodes_map[s][2]),
122  this->node_id(Pyramid5::side_nodes_map[s][3]));
123 
124  default:
125  libmesh_error_msg("Invalid side s = " << s);
126  }
127 }
virtual unsigned int n_sides() const override
Definition: cell_pyramid.h:90
static const unsigned int side_nodes_map[num_sides][nodes_per_side]
This maps the node of the side to element node numbers.
static dof_id_type compute_key(dof_id_type n0)
Definition: elem.h:3295
dof_id_type node_id(const unsigned int i) const
Definition: elem.h:2476

◆ make_links_to_me_local()

void libMesh::Elem::make_links_to_me_local ( unsigned int  n,
unsigned int  neighbor_side 
)
inherited

Resets the neighbor_side pointers of our nth neighbor (and its descendants, if appropriate) to point to this Elem instead of to the global remote_elem.

Used by the library when a formerly remote element is being added to the local processor.

Definition at line 1453 of file elem.C.

References libMesh::Elem::active(), libMesh::Elem::family_tree_by_side(), libMesh::Elem::has_children(), libMesh::Elem::is_remote(), libMesh::Elem::JUST_REFINED, libMesh::Elem::level(), libMesh::libmesh_assert(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::parent(), libMesh::Elem::refinement_flag(), libMesh::remote_elem, and libMesh::Elem::subactive().

1454 {
1455  Elem * neigh = this->neighbor_ptr(n);
1456 
1457  // Don't bother calling this function unless it's necessary
1458  libmesh_assert(neigh);
1459  libmesh_assert(!neigh->is_remote());
1460 
1461  // We never have neighbors more refined than us
1462  libmesh_assert_less_equal (neigh->level(), this->level());
1463 
1464  // We never have subactive neighbors of non subactive elements
1465  libmesh_assert(!neigh->subactive() || this->subactive());
1466 
1467  // If we have a neighbor less refined than us then it must not
1468  // have any more refined descendants we could have pointed to
1469  // instead.
1470  libmesh_assert((neigh->level() == this->level()) ||
1471  (neigh->active() && !this->subactive()) ||
1472  (!neigh->has_children() && this->subactive()));
1473 
1474  // If neigh is at our level, then its family might have
1475  // remote_elem neighbor links which need to point to us
1476  // instead, but if not, then we're done.
1477  if (neigh->level() != this->level())
1478  return;
1479 
1480  // What side of neigh are we on? nn.
1481  //
1482  // We can't use the usual Elem method because we're in the middle of
1483  // restoring topology. We can't compare side_ptr nodes because
1484  // users want to abuse neighbor_ptr to point to
1485  // not-technically-neighbors across mesh slits. We can't compare
1486  // node locations because users want to move those
1487  // not-technically-neighbors until they're
1488  // not-even-geometrically-neighbors.
1489 
1490  // Find any elements that ought to point to elem
1491  std::vector<Elem *> neigh_family;
1492 #ifdef LIBMESH_ENABLE_AMR
1493  if (this->active())
1494  neigh->family_tree_by_side(neigh_family, nn);
1495  else
1496 #endif
1497  neigh_family.push_back(neigh);
1498 
1499  // And point them to elem
1500  for (auto & neigh_family_member : neigh_family)
1501  {
1502  // Only subactive elements point to other subactive elements
1503  if (this->subactive() && !neigh_family_member->subactive())
1504  continue;
1505 
1506  // Ideally, the neighbor link ought to either be correct
1507  // already or ought to be to remote_elem.
1508  //
1509  // However, if we're redistributing a newly created elem,
1510  // after an AMR step but before find_neighbors has fixed up
1511  // neighbor links, we might have an out of date neighbor
1512  // link to elem's parent instead.
1513 #ifdef LIBMESH_ENABLE_AMR
1514  libmesh_assert((neigh_family_member->neighbor_ptr(nn) &&
1515  (neigh_family_member->neighbor_ptr(nn)->active() ||
1516  neigh_family_member->neighbor_ptr(nn)->is_ancestor_of(this))) ||
1517  (neigh_family_member->neighbor_ptr(nn) == remote_elem) ||
1518  ((this->refinement_flag() == JUST_REFINED) &&
1519  (this->parent() != nullptr) &&
1520  (neigh_family_member->neighbor_ptr(nn) == this->parent())));
1521 #else
1522  libmesh_assert((neigh_family_member->neighbor_ptr(nn) == this) ||
1523  (neigh_family_member->neighbor_ptr(nn) == remote_elem));
1524 #endif
1525 
1526  neigh_family_member->set_neighbor(nn, this);
1527  }
1528 }
RefinementState refinement_flag() const
Definition: elem.h:3211
const Elem * parent() const
Definition: elem.h:3031
libmesh_assert(ctx)
Elem(const unsigned int n_nodes, const unsigned int n_sides, Elem *parent, Elem **elemlinkdata, Node **nodelinkdata)
Constructor.
Definition: elem.h:2379
const Elem * neighbor_ptr(unsigned int i) const
Definition: elem.h:2599
unsigned int level() const
Definition: elem.h:3075
bool subactive() const
Definition: elem.h:2960
bool active() const
Definition: elem.h:2942
const RemoteElem * remote_elem
Definition: remote_elem.C:57

◆ make_links_to_me_remote()

void libMesh::Elem::make_links_to_me_remote ( )
inherited

Resets this element's neighbors' appropriate neighbor pointers and its parent's and children's appropriate pointers to point to the global remote_elem instead of this.

Used by the library before an element becomes remote on the local processor.

Definition at line 1531 of file elem.C.

References libMesh::Elem::child_ptr(), libMesh::Elem::child_ref_range(), libMesh::Elem::dim(), libMesh::Elem::has_children(), libMesh::Elem::level(), libMesh::libmesh_assert(), libMesh::Elem::neighbor_ptr_range(), libMesh::Elem::parent(), libMesh::remote_elem, libMesh::Elem::set_child(), libMesh::Elem::subactive(), and libMesh::Elem::which_child_am_i().

Referenced by libMesh::MeshCommunication::delete_remote_elements().

1532 {
1533  libmesh_assert_not_equal_to (this, remote_elem);
1534 
1535  // We need to have handled any children first
1536 #if defined(LIBMESH_ENABLE_AMR) && defined(DEBUG)
1537  if (this->has_children())
1538  for (auto & child : this->child_ref_range())
1539  libmesh_assert_equal_to (&child, remote_elem);
1540 #endif
1541 
1542  // Remotify any neighbor links
1543  for (auto neigh : this->neighbor_ptr_range())
1544  {
1545  if (neigh && neigh != remote_elem)
1546  {
1547  // My neighbor should never be more refined than me; my real
1548  // neighbor would have been its parent in that case.
1549  libmesh_assert_greater_equal (this->level(), neigh->level());
1550 
1551  if (this->level() == neigh->level() &&
1552  neigh->has_neighbor(this))
1553  {
1554 #ifdef LIBMESH_ENABLE_AMR
1555  // My neighbor may have descendants which also consider me a
1556  // neighbor
1557  std::vector<Elem *> family;
1558  neigh->total_family_tree_by_neighbor (family, this);
1559 
1560  // FIXME - There's a lot of ugly const_casts here; we
1561  // may want to make remote_elem non-const
1562  for (auto & n : family)
1563  {
1564  libmesh_assert (n);
1565  if (n == remote_elem)
1566  continue;
1567  unsigned int my_s = n->which_neighbor_am_i(this);
1568  libmesh_assert_less (my_s, n->n_neighbors());
1569  libmesh_assert_equal_to (n->neighbor_ptr(my_s), this);
1570  n->set_neighbor(my_s, const_cast<RemoteElem *>(remote_elem));
1571  }
1572 #else
1573  unsigned int my_s = neigh->which_neighbor_am_i(this);
1574  libmesh_assert_less (my_s, neigh->n_neighbors());
1575  libmesh_assert_equal_to (neigh->neighbor_ptr(my_s), this);
1576  neigh->set_neighbor(my_s, const_cast<RemoteElem *>(remote_elem));
1577 #endif
1578  }
1579 #ifdef LIBMESH_ENABLE_AMR
1580  // Even if my neighbor doesn't link back to me, it might
1581  // have subactive descendants which do
1582  else if (neigh->has_children())
1583  {
1584  // If my neighbor at the same level doesn't have me as a
1585  // neighbor, I must be subactive
1586  libmesh_assert(this->level() > neigh->level() ||
1587  this->subactive());
1588 
1589  // My neighbor must have some ancestor of mine as a
1590  // neighbor
1591  Elem * my_ancestor = this->parent();
1592  libmesh_assert(my_ancestor);
1593  while (!neigh->has_neighbor(my_ancestor))
1594  {
1595  my_ancestor = my_ancestor->parent();
1596  libmesh_assert(my_ancestor);
1597  }
1598 
1599  // My neighbor may have descendants which consider me a
1600  // neighbor
1601  std::vector<Elem *> family;
1602  neigh->total_family_tree_by_subneighbor (family, my_ancestor, this);
1603 
1604  for (auto & n : family)
1605  {
1606  libmesh_assert (n);
1607  if (n->is_remote())
1608  continue;
1609  unsigned int my_s = n->which_neighbor_am_i(this);
1610  libmesh_assert_less (my_s, n->n_neighbors());
1611  libmesh_assert_equal_to (n->neighbor_ptr(my_s), this);
1612  // TODO: we may want to make remote_elem non-const.
1613  n->set_neighbor(my_s, const_cast<RemoteElem *>(remote_elem));
1614  }
1615  }
1616 #endif
1617  }
1618  }
1619 
1620 #ifdef LIBMESH_ENABLE_AMR
1621  // Remotify parent's child link
1622  Elem * my_parent = this->parent();
1623  if (my_parent &&
1624  // As long as it's not already remote
1625  my_parent != remote_elem &&
1626  // And it's a real parent, not an interior parent
1627  this->dim() == my_parent->dim())
1628  {
1629  unsigned int me = my_parent->which_child_am_i(this);
1630  libmesh_assert_equal_to (my_parent->child_ptr(me), this);
1631  my_parent->set_child(me, const_cast<RemoteElem *>(remote_elem));
1632  }
1633 #endif
1634 }
const Elem * parent() const
Definition: elem.h:3031
SimpleRange< ChildRefIter > child_ref_range()
Returns a range with all children of a parent element, usable in range-based for loops.
Definition: elem.h:2347
libmesh_assert(ctx)
Elem(const unsigned int n_nodes, const unsigned int n_sides, Elem *parent, Elem **elemlinkdata, Node **nodelinkdata)
Constructor.
Definition: elem.h:2379
unsigned int level() const
Definition: elem.h:3075
virtual unsigned short dim() const =0
bool subactive() const
Definition: elem.h:2960
SimpleRange< NeighborPtrIter > neighbor_ptr_range()
Returns a range with all neighbors of an element, usable in range-based for loops.
Definition: elem.h:3504
bool has_children() const
Definition: elem.h:2980
const RemoteElem * remote_elem
Definition: remote_elem.C:57

◆ mapping_data()

unsigned char libMesh::Elem::mapping_data ( ) const
inlineinherited

◆ mapping_type()

ElemMappingType libMesh::Elem::mapping_type ( ) const
inlineinherited
Returns
The value of the mapping type for the element.

Definition at line 3121 of file elem.h.

References libMesh::Elem::_map_type.

Referenced by libMesh::MeshTools::Modification::all_tri(), libMesh::InfQuad6::build_side_ptr(), libMesh::MeshTools::clear_spline_nodes(), libMesh::MeshTools::Modification::flatten(), libMesh::Elem::get_info(), libMesh::Quad4::has_invertible_map(), libMesh::Edge3::has_invertible_map(), libMesh::Edge4::has_invertible_map(), libMesh::Elem::inherit_data_from(), libMesh::QComposite< QSubCell >::init(), libMesh::FEMap::map_fe_type(), libMesh::Polygon::Polygon(), libMesh::Polyhedron::Polyhedron(), libMesh::FE< Dim, LAGRANGE_VEC >::reinit(), libMesh::C0Polyhedron::side_vertex_average_normal(), libMesh::Quad4::side_vertex_average_normal(), libMesh::C0Polygon::side_vertex_average_normal(), side_vertex_average_normal(), libMesh::Prism6::side_vertex_average_normal(), libMesh::Hex8::side_vertex_average_normal(), libMesh::C0Polyhedron::true_centroid(), libMesh::C0Polygon::true_centroid(), libMesh::C0Polyhedron::volume(), libMesh::C0Polygon::volume(), libMesh::Quad8::volume(), libMesh::Quad9::volume(), libMesh::Tri6::volume(), libMesh::Pyramid13::volume(), libMesh::Hex20::volume(), libMesh::Tet10::volume(), libMesh::Prism15::volume(), libMesh::Pyramid14::volume(), libMesh::Hex27::volume(), and libMesh::Prism18::volume().

3122 {
3123  return static_cast<ElemMappingType>(_map_type);
3124 }
unsigned char _map_type
Mapping function type; currently either 0 (LAGRANGE) or 1 (RATIONAL_BERNSTEIN).
Definition: elem.h:2298
ElemMappingType
Enumeration of possible element master->physical mapping types.

◆ master_point()

virtual Point libMesh::Pyramid::master_point ( const unsigned int  i) const
inlineoverridevirtualinherited
Returns
The Point associated with local Node i, in master element rather than physical coordinates.

Implements libMesh::Elem.

Definition at line 66 of file cell_pyramid.h.

References libMesh::Pyramid::_master_points, and libMesh::Pyramid::n_nodes().

67  {
68  libmesh_assert_less(i, this->n_nodes());
69  return Point(_master_points[i][0],
70  _master_points[i][1],
71  _master_points[i][2]);
72  }
virtual unsigned int n_nodes() const override
Definition: cell_pyramid.h:85
static const Real _master_points[14][3]
Master element node locations.
Definition: cell_pyramid.h:214

◆ max_descendant_p_level()

unsigned int libMesh::Elem::max_descendant_p_level ( ) const
inlineinherited
Returns
The maximum value of the p-refinement levels of an ancestor element's descendants.

Definition at line 3247 of file elem.h.

References libMesh::Elem::_p_level, libMesh::Elem::active(), libMesh::Elem::child_ref_range(), libMesh::libmesh_assert(), libMesh::Elem::p_level(), and libMesh::Elem::subactive().

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

3248 {
3249  // This is undefined for subactive elements,
3250  // which have no active descendants
3251  libmesh_assert (!this->subactive());
3252  if (this->active())
3253  return this->p_level();
3254 
3255  unsigned int max_p_level = _p_level;
3256  for (auto & c : child_ref_range())
3257  max_p_level = std::max(max_p_level,
3258  c.max_descendant_p_level());
3259  return max_p_level;
3260 }
unsigned char _p_level
p refinement level - the difference between the polynomial degree on this element and the minimum pol...
Definition: elem.h:2291
unsigned int p_level() const
Definition: elem.h:3109
SimpleRange< ChildRefIter > child_ref_range()
Returns a range with all children of a parent element, usable in range-based for loops.
Definition: elem.h:2347
libmesh_assert(ctx)
bool subactive() const
Definition: elem.h:2960
bool active() const
Definition: elem.h:2942

◆ min_new_p_level_by_neighbor()

unsigned int libMesh::Elem::min_new_p_level_by_neighbor ( const Elem neighbor,
unsigned int  current_min 
) const
inherited
Returns
The minimum new p-refinement level (i.e. after refinement and coarsening is done) of elements which are descended from this element and which share a side with the active neighbor.

Definition at line 2350 of file elem.C.

References libMesh::Elem::active(), libMesh::Elem::child_ref_range(), libMesh::Elem::COARSEN, libMesh::Elem::has_neighbor(), libMesh::libmesh_assert(), libMesh::Elem::p_level(), libMesh::Elem::p_refinement_flag(), libMesh::Elem::REFINE, libMesh::remote_elem, and libMesh::Elem::subactive().

2352 {
2353  libmesh_assert(!this->subactive());
2354  libmesh_assert(neighbor_in->active());
2355 
2356  // If we're an active element this is simple
2357  if (this->active())
2358  {
2359  unsigned int new_p_level = this->p_level();
2360  if (this->p_refinement_flag() == Elem::REFINE)
2361  new_p_level += 1;
2362  if (this->p_refinement_flag() == Elem::COARSEN)
2363  {
2364  libmesh_assert_greater (new_p_level, 0);
2365  new_p_level -= 1;
2366  }
2367  return std::min(current_min, new_p_level);
2368  }
2369 
2370  libmesh_assert(has_neighbor(neighbor_in));
2371 
2372  unsigned int min_p_level = current_min;
2373 
2374  for (auto & c : this->child_ref_range())
2375  if (&c != remote_elem && c.has_neighbor(neighbor_in))
2376  min_p_level =
2377  c.min_new_p_level_by_neighbor(neighbor_in, min_p_level);
2378 
2379  return min_p_level;
2380 }
bool has_neighbor(const Elem *elem) const
Definition: elem.h:2629
RefinementState p_refinement_flag() const
Definition: elem.h:3227
unsigned int p_level() const
Definition: elem.h:3109
SimpleRange< ChildRefIter > child_ref_range()
Returns a range with all children of a parent element, usable in range-based for loops.
Definition: elem.h:2347
libmesh_assert(ctx)
bool subactive() const
Definition: elem.h:2960
bool active() const
Definition: elem.h:2942
const RemoteElem * remote_elem
Definition: remote_elem.C:57

◆ min_p_level_by_neighbor()

unsigned int libMesh::Elem::min_p_level_by_neighbor ( const Elem neighbor,
unsigned int  current_min 
) const
inherited
Returns
The minimum p-refinement level of elements which are descended from this element, and which share a side with the active neighbor.

Definition at line 2321 of file elem.C.

References libMesh::Elem::active(), libMesh::Elem::child_ref_range(), libMesh::Elem::has_neighbor(), libMesh::libmesh_assert(), libMesh::Elem::p_level(), libMesh::remote_elem, and libMesh::Elem::subactive().

Referenced by libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), and libMesh::FEGenericBase< FEOutputType< T >::type >::compute_proj_constraints().

2323 {
2324  libmesh_assert(!this->subactive());
2325  libmesh_assert(neighbor_in->active());
2326 
2327  // If we're an active element this is simple
2328  if (this->active())
2329  return std::min(current_min, this->p_level());
2330 
2331  libmesh_assert(has_neighbor(neighbor_in));
2332 
2333  // The p_level() of an ancestor element is already the minimum
2334  // p_level() of its children - so if that's high enough, we don't
2335  // need to examine any children.
2336  if (current_min <= this->p_level())
2337  return current_min;
2338 
2339  unsigned int min_p_level = current_min;
2340 
2341  for (auto & c : this->child_ref_range())
2342  if (&c != remote_elem && c.has_neighbor(neighbor_in))
2343  min_p_level =
2344  c.min_p_level_by_neighbor(neighbor_in, min_p_level);
2345 
2346  return min_p_level;
2347 }
bool has_neighbor(const Elem *elem) const
Definition: elem.h:2629
unsigned int p_level() const
Definition: elem.h:3109
SimpleRange< ChildRefIter > child_ref_range()
Returns a range with all children of a parent element, usable in range-based for loops.
Definition: elem.h:2347
libmesh_assert(ctx)
bool subactive() const
Definition: elem.h:2960
bool active() const
Definition: elem.h:2942
const RemoteElem * remote_elem
Definition: remote_elem.C:57

◆ n_children()

virtual unsigned int libMesh::Pyramid::n_children ( ) const
inlineoverridevirtualinherited
Returns
10.

Implements libMesh::Elem.

Definition at line 110 of file cell_pyramid.h.

Referenced by libMesh::Pyramid::is_child_on_side().

110 { return 10; }

◆ n_comp()

unsigned int libMesh::DofObject::n_comp ( const unsigned int  s,
const unsigned int  var 
) const
inlineinherited
Returns
The number of components for variable var of system s associated with this DofObject. For example, the HIERARCHIC shape functions may have multiple DoFs associated with one node. Another example is the MONOMIALs, where only the elements hold the DoFs. For the different spatial directions, and orders, see FE.

Definition at line 1002 of file dof_object.h.

References libMesh::DofObject::n_comp_group(), libMesh::DofObject::n_systems(), libMesh::DofObject::n_vars(), and libMesh::DofObject::var_to_vg().

Referenced by libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), libMesh::DofMap::constrain_p_dofs(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::Nemesis_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::Nemesis_IO::copy_nodal_solution(), libMesh::DofMap::distribute_dofs(), libMesh::DofObject::dof_number(), libMesh::DofObject::DofObject(), libMesh::OldSolutionCoefs< Output, point_output >::eval_at_node(), libMesh::OldSolutionValue< Output, point_output >::eval_at_node(), libMesh::OldSolutionCoefs< Output, point_output >::eval_mixed_derivatives(), libMesh::OldSolutionValue< Output, point_output >::eval_mixed_derivatives(), libMesh::Node::get_info(), libMesh::Elem::get_info(), libMesh::DofMap::local_variable_indices(), main(), libMesh::DofObject::n_dofs(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectVertices::operator()(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectSides::operator()(), libMesh::DofObject::operator=(), libMesh::DofObject::print_dof_info(), libMesh::DofObject::set_dof_number(), libMesh::DofObject::set_n_vars_per_group(), libMesh::DofMap::set_nonlocal_dof_objects(), and libMesh::Nemesis_IO_Helper::write_nodal_solution().

1004 {
1005  libmesh_assert_less (s, this->n_systems());
1006  libmesh_assert_less (var, this->n_vars(s));
1007 
1008  return this->n_comp_group(s,this->var_to_vg(s,var));
1009 }
unsigned int var_to_vg(const unsigned int s, const unsigned int var) const
Utility function - for variable var in system s, figure out what variable group it lives in...
Definition: dof_object.h:1341
unsigned int n_vars(const unsigned int s, const unsigned int vg) const
Definition: dof_object.h:967
unsigned int n_systems() const
Definition: dof_object.h:937
unsigned int n_comp_group(const unsigned int s, const unsigned int vg) const
Definition: dof_object.h:1015

◆ n_comp_group()

unsigned int libMesh::DofObject::n_comp_group ( const unsigned int  s,
const unsigned int  vg 
) const
inlineinherited
Returns
The number of components for VariableGroup vg of system s associated with this DofObject. For example, the HIERARCHIC shape functions may have multiple DoFs associated with one node. Another example is the MONOMIALs, where only the elements hold the DoFs. For the different spatial directions, and orders, see FE.

Definition at line 1015 of file dof_object.h.

References libMesh::DofObject::_idx_buf, libMesh::DofObject::n_systems(), libMesh::DofObject::n_var_groups(), libMesh::DofObject::ncv_magic, and libMesh::DofObject::start_idx().

Referenced by libMesh::DofMap::_dof_indices(), libMesh::DofMap::_node_dof_indices(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DofMap::dof_indices(), libMesh::DofObject::dof_number(), libMesh::OldSolutionCoefs< Output, point_output >::eval_old_dofs(), libMesh::OldSolutionValue< Output, point_output >::eval_old_dofs(), libMesh::DofObject::invalidate_dofs(), libMesh::DofObject::n_comp(), libMesh::DofMap::old_dof_indices(), libMesh::BuildProjectionList::operator()(), libMesh::DofMap::reinit(), libMesh::DofObject::set_dof_number(), libMesh::DofObject::set_n_comp_group(), libMesh::DofObject::set_n_vars_per_group(), and libMesh::DofMap::set_nonlocal_dof_objects().

1017 {
1018  libmesh_assert_less (s, this->n_systems());
1019  libmesh_assert_less (vg, this->n_var_groups(s));
1020 
1021  const unsigned int
1022  start_idx_sys = this->start_idx(s);
1023 
1024  libmesh_assert_less ((start_idx_sys + 2*vg), _idx_buf.size());
1025 
1026  return (_idx_buf[start_idx_sys + 2*vg] % ncv_magic);
1027 }
unsigned int n_var_groups(const unsigned int s) const
Definition: dof_object.h:957
unsigned int n_systems() const
Definition: dof_object.h:937
unsigned int start_idx(const unsigned int s) const
The starting index for system s.
Definition: dof_object.h:1249
index_buffer_t _idx_buf
Definition: dof_object.h:680
static const index_t ncv_magic
Above we introduced the chimera ncv, which is a hybrid of the form ncv = ncv_magic*nv + nc where nv a...
Definition: dof_object.h:691

◆ n_dofs()

unsigned int libMesh::DofObject::n_dofs ( const unsigned int  s,
const unsigned int  var = libMesh::invalid_uint 
) const
inlineinherited
Returns
The number of degrees of freedom associated with system s directly stored on this object. Optionally only degrees of freedom for variable number var are counted. Does not count degrees of freedom only indirectly associated with this object, such as those stored on an element's nodes when n_dofs() is called on the element itself.

Definition at line 806 of file dof_object.h.

References libMesh::invalid_uint, libMesh::make_range(), libMesh::DofObject::n_comp(), libMesh::DofObject::n_systems(), and libMesh::DofObject::n_vars().

Referenced by libMesh::PetscDMWrapper::add_dofs_helper(), and libMesh::EquationSystems::build_parallel_solution_vector().

808 {
809  libmesh_assert_less (s, this->n_systems());
810 
811  unsigned int num = 0;
812 
813  // Count all variables
814  if (var == libMesh::invalid_uint)
815  for (auto v : make_range(this->n_vars(s)))
816  num += this->n_comp(s,v);
817 
818  // Only count specified variable
819  else
820  num = this->n_comp(s,var);
821 
822  return num;
823 }
const unsigned int invalid_uint
A number which is used quite often to represent an invalid or uninitialized value for an unsigned int...
Definition: libmesh.h:310
unsigned int n_comp(const unsigned int s, const unsigned int var) const
Definition: dof_object.h:1002
unsigned int n_vars(const unsigned int s, const unsigned int vg) const
Definition: dof_object.h:967
unsigned int n_systems() const
Definition: dof_object.h:937
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140

◆ n_edges()

virtual unsigned int libMesh::Pyramid::n_edges ( ) const
inlineoverridevirtualinherited

◆ n_extra_integers()

unsigned int libMesh::DofObject::n_extra_integers ( ) const
inlineinherited

Returns how many extra integers are associated to the DofObject.

If non-integer data has been associated, each datum of type T counts for sizeof(T)/sizeof(dof_id_type) times in the return value.

Definition at line 1170 of file dof_object.h.

References libMesh::DofObject::_idx_buf, and libMesh::DofObject::start_idx_ints().

Referenced by libMesh::DofObject::add_extra_integers(), libMesh::MeshTools::Modification::all_tri(), libMesh::C0Polyhedron::disconnected_clone(), libMesh::Elem::disconnected_clone(), libMesh::MeshTools::Modification::flatten(), libMesh::DofObject::get_extra_datum(), libMesh::DofObject::get_extra_integer(), libMesh::CheckpointIO::read_connectivity(), libMesh::CheckpointIO::read_nodes(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::Elem::refine(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::DofObject::set_extra_datum(), libMesh::DofObject::set_extra_integer(), libMesh::DofObject::set_n_systems(), libMesh::DofObject::set_n_vars_per_group(), DofObjectTest< Node >::testAddExtraData(), DofObjectTest< Node >::testAddSystemExtraInts(), DofObjectTest< Node >::testSetNSystemsExtraInts(), and DofObjectTest< Node >::testSetNVariableGroupsExtraInts().

1171 {
1172  if (_idx_buf.empty())
1173  return 0;
1174 
1175  const int hdr = dof_id_signed_type(_idx_buf[0]);
1176  if (hdr >= 0)
1177  return 0;
1178 
1179  const unsigned int start_idx_i = this->start_idx_ints();
1180 
1181  return _idx_buf.size() - start_idx_i;
1182 }
unsigned int start_idx_ints() const
The starting index for an extra_integers pseudosystem.
Definition: dof_object.h:1273
int8_t dof_id_signed_type
Definition: id_types.h:68
index_buffer_t _idx_buf
Definition: dof_object.h:680

◆ n_faces()

virtual unsigned int libMesh::Pyramid::n_faces ( ) const
inlineoverridevirtualinherited
Returns
5. All pyramids have 5 faces.

Implements libMesh::Elem.

Definition at line 105 of file cell_pyramid.h.

105 { return 5; }

◆ n_neighbors()

unsigned int libMesh::Elem::n_neighbors ( ) const
inlineinherited
Returns
The number of neighbors the element that has been derived from this class has.

Only face (or edge in 2D) neighbors are stored, so this method returns n_sides(). At one point we intended to allow derived classes to override this, but too much current libMesh code assumes n_neighbors==n_sides.

Definition at line 715 of file elem.h.

References libMesh::Elem::n_sides().

Referenced by libMesh::Elem::_last_side(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_proj_constraints(), libMesh::MeshTools::find_hanging_nodes_and_parents(), libMesh::Tri3Subdivision::get_ordered_valence(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::Elem::libmesh_assert_valid_neighbors(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::neighbor_ptr_range(), libMesh::Elem::nullify_neighbors(), libMesh::Elem::set_neighbor(), libMesh::Elem::topological_neighbor(), and libMesh::Elem::topologically_equal().

716  { return this->n_sides(); }
virtual unsigned int n_sides() const =0

◆ n_nodes()

virtual unsigned int libMesh::Pyramid::n_nodes ( ) const
inlineoverridevirtualinherited
Returns
5. All pyramid-derivatives are guaranteed to have at least 5 nodes.

Implements libMesh::Elem.

Reimplemented in libMesh::Pyramid18, libMesh::Pyramid14, and libMesh::Pyramid13.

Definition at line 85 of file cell_pyramid.h.

Referenced by libMesh::Pyramid::edges_adjacent_to_node(), and libMesh::Pyramid::master_point().

85 { return 5; }

◆ n_nodes_in_child()

virtual unsigned int libMesh::Elem::n_nodes_in_child ( unsigned  int) const
inlinevirtualinherited
Returns
The number of nodes the given child of this element contains. Except in odd cases like pyramid refinement this will be the same as the number of nodes in the parent element.

Definition at line 669 of file elem.h.

References libMesh::Elem::n_nodes().

Referenced by libMesh::Elem::as_parent_node(), libMesh::Elem::bracketing_nodes(), and libMesh::Elem::parent_bracketing_nodes().

670  { return this->n_nodes(); }
virtual unsigned int n_nodes() const =0

◆ n_objects() [1/2]

static unsigned int libMesh::ReferenceCounter::n_objects ( )
inlinestaticinherited

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

Definition at line 85 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects.

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

86  { return _n_objects; }
static Threads::atomic< unsigned int > _n_objects
The number of objects.

◆ n_objects() [2/2]

static unsigned int libMesh::ReferenceCounter::n_objects ( )
inlinestaticinherited

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

Definition at line 85 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects.

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

86  { return _n_objects; }
static Threads::atomic< unsigned int > _n_objects
The number of objects.

◆ n_permutations()

virtual unsigned int libMesh::Pyramid::n_permutations ( ) const
inlinefinaloverridevirtualinherited

One quad side, four orientations.

Implements libMesh::Elem.

Definition at line 190 of file cell_pyramid.h.

190 { return 4; }

◆ n_pseudo_systems()

unsigned int libMesh::DofObject::n_pseudo_systems ( ) const
inlineinherited
Returns
The total number of pseudo-systems associated with this DofObject : n_systems(), plus one iff this->has_extra_integers()

Definition at line 947 of file dof_object.h.

References libMesh::DofObject::_idx_buf.

Referenced by libMesh::DofObject::end_idx(), libMesh::DofObject::set_extra_datum(), and libMesh::DofObject::set_extra_integer().

948 {
949  const int hdr = _idx_buf.empty() ?
950  0 : cast_int<int>(dof_id_signed_type(_idx_buf[0]));
951  return std::abs(hdr);
952 }
int8_t dof_id_signed_type
Definition: id_types.h:68
index_buffer_t _idx_buf
Definition: dof_object.h:680

◆ n_second_order_adjacent_vertices()

unsigned int libMesh::Elem::n_second_order_adjacent_vertices ( const unsigned int  n) const
virtualinherited
Returns
The number of adjacent vertices that uniquely define the location of the \( n^{th} \) second-order node, or 0 for linear elements.

This method is useful when converting linear elements to quadratic elements.

Note
n has to be greater than or equal to this->n_vertices().

Reimplemented in libMesh::Prism21, libMesh::Pyramid18, libMesh::Prism20, libMesh::Pyramid14, libMesh::Prism18, libMesh::Hex27, libMesh::Tet14, libMesh::Prism15, libMesh::Pyramid13, libMesh::InfHex18, libMesh::Tet10, libMesh::Hex20, libMesh::Tri7, libMesh::InfHex16, libMesh::Tri6, libMesh::Quad9, libMesh::InfPrism12, libMesh::C0Polygon, libMesh::Quad8, libMesh::InfQuad6, libMesh::Edge4, and libMesh::Edge3.

Definition at line 3044 of file elem.C.

Referenced by libMesh::MeshTools::Modification::smooth().

3045 {
3046  // for linear elements, always return 0
3047  return 0;
3048 }

◆ n_sides()

virtual unsigned int libMesh::Pyramid::n_sides ( ) const
inlineoverridevirtualinherited

◆ n_sub_elem()

virtual unsigned int libMesh::Pyramid5::n_sub_elem ( ) const
inlineoverridevirtual
Returns
1.

Implements libMesh::Elem.

Definition at line 83 of file cell_pyramid5.h.

Referenced by connectivity().

83 { return 1; }

◆ n_systems()

unsigned int libMesh::DofObject::n_systems ( ) const
inlineinherited
Returns
The number of systems associated with this DofObject

Definition at line 937 of file dof_object.h.

References libMesh::DofObject::_idx_buf.

Referenced by libMesh::DofMap::_dof_indices(), libMesh::DofObject::add_system(), libMesh::DofObject::dof_number(), libMesh::DofObject::DofObject(), libMesh::DofObject::end_idx(), libMesh::OldSolutionCoefs< Output, point_output >::eval_old_dofs(), libMesh::OldSolutionValue< Output, point_output >::eval_old_dofs(), libMesh::DofObject::get_extra_datum(), libMesh::DofObject::get_extra_integer(), libMesh::Node::get_info(), libMesh::Elem::get_info(), libMesh::DofObject::has_dofs(), libMesh::DofObject::invalidate_dofs(), libMesh::DofObject::n_comp(), libMesh::DofObject::n_comp_group(), libMesh::DofObject::n_dofs(), libMesh::DofObject::n_var_groups(), libMesh::DofObject::n_vars(), libMesh::DofMap::old_dof_indices(), libMesh::DofObject::operator=(), libMesh::DofObject::print_dof_info(), libMesh::Elem::refine(), libMesh::DofObject::set_dof_number(), libMesh::DofObject::set_n_comp(), libMesh::DofObject::set_n_comp_group(), libMesh::DofObject::set_n_systems(), libMesh::DofObject::set_n_vars_per_group(), libMesh::DofObject::set_vg_dof_base(), libMesh::DofObject::start_idx(), libMesh::DofObject::start_idx_ints(), DofObjectTest< Node >::testAddSystemExtraInts(), DofObjectTest< Node >::testSetNSystems(), DofObjectTest< Node >::testSetNSystemsExtraInts(), and libMesh::DofObject::vg_dof_base().

938 {
939  const int hdr = _idx_buf.empty() ?
940  0 : cast_int<int>(dof_id_signed_type(_idx_buf[0]));
941  return hdr >= 0 ? hdr : (-hdr-1);
942 }
int8_t dof_id_signed_type
Definition: id_types.h:68
index_buffer_t _idx_buf
Definition: dof_object.h:680

◆ n_var_groups()

unsigned int libMesh::DofObject::n_var_groups ( const unsigned int  s) const
inlineinherited

◆ n_vars() [1/2]

unsigned int libMesh::DofObject::n_vars ( const unsigned int  s,
const unsigned int  vg 
) const
inlineinherited
Returns
The number of Variable variables associated with VariableGroup vg in system s for this DofObject

Definition at line 967 of file dof_object.h.

References libMesh::DofObject::_idx_buf, libMesh::DofObject::n_systems(), libMesh::DofObject::n_var_groups(), libMesh::DofObject::ncv_magic_exp, and libMesh::DofObject::start_idx().

Referenced by libMesh::DofObject::add_system(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::DofMap::distribute_dofs(), libMesh::DofObject::dof_number(), libMesh::DofObject::DofObject(), libMesh::OldSolutionCoefs< Output, point_output >::eval_at_node(), libMesh::OldSolutionValue< Output, point_output >::eval_at_node(), libMesh::OldSolutionCoefs< Output, point_output >::eval_mixed_derivatives(), libMesh::OldSolutionValue< Output, point_output >::eval_mixed_derivatives(), libMesh::Node::get_info(), libMesh::Elem::get_info(), libMesh::DofObject::has_dofs(), libMesh::DofObject::n_comp(), libMesh::DofObject::n_dofs(), libMesh::DofObject::n_vars(), libMesh::BuildProjectionList::operator()(), libMesh::DofObject::operator=(), libMesh::DofObject::print_dof_info(), libMesh::DofObject::set_dof_number(), libMesh::DofObject::set_n_comp(), libMesh::DofObject::set_n_comp_group(), libMesh::DofObject::set_n_systems(), libMesh::DofObject::set_n_vars_per_group(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::DofObject::system_var_to_vg_var(), DofObjectTest< Node >::testAddSystemExtraInts(), DofObjectTest< Node >::testSetNVariableGroups(), DofObjectTest< Node >::testSetNVariableGroupsExtraInts(), libMesh::DofObject::var_to_vg(), and libMesh::DofObject::var_to_vg_and_offset().

969 {
970  libmesh_assert_less (s, this->n_systems());
971  libmesh_assert_less (vg, this->n_var_groups(s));
972 
973  const unsigned int start_idx_sys = this->start_idx(s);
974 
975  libmesh_assert_less ((start_idx_sys + 2*vg), _idx_buf.size());
976 
977  return (cast_int<unsigned int>
978  (_idx_buf[start_idx_sys + 2*vg]) >> ncv_magic_exp);
979 }
unsigned int n_var_groups(const unsigned int s) const
Definition: dof_object.h:957
unsigned int n_systems() const
Definition: dof_object.h:937
unsigned int start_idx(const unsigned int s) const
The starting index for system s.
Definition: dof_object.h:1249
index_buffer_t _idx_buf
Definition: dof_object.h:680
static const index_t ncv_magic_exp
Definition: dof_object.h:692

◆ n_vars() [2/2]

unsigned int libMesh::DofObject::n_vars ( const unsigned int  s) const
inlineinherited
Returns
The number of Variable variables associated with system s for this DofObject

Definition at line 984 of file dof_object.h.

References libMesh::DofObject::n_systems(), libMesh::DofObject::n_var_groups(), and libMesh::DofObject::n_vars().

985 {
986  libmesh_assert_less (s, this->n_systems());
987 
988  const unsigned int nvg = this->n_var_groups(s);
989 
990  unsigned int val=0;
991 
992  for (unsigned int vg=0; vg<nvg; vg++)
993  val += this->n_vars(s,vg);
994 
995  return val;
996 }
unsigned int n_var_groups(const unsigned int s) const
Definition: dof_object.h:957
unsigned int n_vars(const unsigned int s, const unsigned int vg) const
Definition: dof_object.h:967
unsigned int n_systems() const
Definition: dof_object.h:937

◆ n_vertices()

virtual unsigned int libMesh::Pyramid::n_vertices ( ) const
inlineoverridevirtualinherited

◆ neighbor_ptr() [1/2]

const Elem * libMesh::Elem::neighbor_ptr ( unsigned int  i) const
inlineinherited
Returns
A const pointer to the \( i^{th} \) neighbor of this element, or nullptr if MeshBase::find_neighbors() has not been called.
Note
If MeshBase::find_neighbors() has been called and this function still returns nullptr, then the side is on a boundary of the domain.

Definition at line 2599 of file elem.h.

References libMesh::Elem::_elemlinks, and libMesh::Elem::n_neighbors().

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::MeshTools::Subdivision::add_boundary_ghosts(), libMesh::BoundaryInfo::add_elements(), libMesh::RBConstruction::add_scaled_matrix_and_vector(), libMesh::MeshTools::Modification::all_tri(), libMesh::ClawSystem::assemble_avg_coupling_matrices(), assemble_ellipticdg(), libMesh::ClawSystem::assemble_jump_coupling_matrix(), assemble_SchroedingerEquation(), assembly_with_dg_fem_context(), libMesh::BoundaryInfo::boundary_ids(), libMesh::EquationSystems::build_discontinuous_solution_vector(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::clear_stitched_boundary_side_ids(), compute_enriched_soln(), compute_jacobian(), libMesh::FEAbstract::compute_node_constraints(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), libMesh::FEAbstract::compute_periodic_node_constraints(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_proj_constraints(), compute_residual(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::BoundaryInfo::edge_boundary_ids(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::MeshTools::find_hanging_nodes_and_parents(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::MeshTools::Subdivision::find_one_ring(), libMesh::MeshTools::Modification::flatten(), libMesh::ReplicatedMesh::get_disconnected_subdomains(), libMesh::Elem::get_info(), libMesh::VariationalSmootherConstraint::get_neighbors_for_subdomain_constraint(), libMesh::InfFE< Dim, T_radial, T_map >::inf_compute_constraints(), libMesh::InfFE< Dim, T_radial, T_map >::inf_compute_node_constraints(), libMesh::RBEIMConstruction::initialize_qp_data(), libMesh::Poly2TriTriangulator::insert_refinement_points(), libMesh::Poly2TriTriangulator::is_refine_boundary_allowed(), libMesh::HDGProblem::jacobian(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::Elem::libmesh_assert_valid_neighbors(), libMesh::Elem::make_links_to_me_local(), libMesh::Elem::nullify_neighbors(), libMesh::DefaultCoupling::operator()(), libMesh::C0Polygon::permute(), libMesh::CheckpointIO::read_remote_elem(), libMesh::EquationSystems::redundant_added_side(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::InfFE< Dim, T_radial, T_map >::reinit(), libMesh::FE< Dim, LAGRANGE_VEC >::reinit(), libMesh::FEXYZ< Dim >::reinit(), libMesh::HDGProblem::residual(), libMesh::C0Polyhedron::retriangulate(), libMesh::BoundaryInfo::side_boundary_ids(), libMesh::FE< Dim, LAGRANGE_VEC >::side_map(), libMesh::Elem::SideIter::side_on_boundary(), libMesh::BoundaryInfo::side_with_boundary_id(), libMesh::BoundaryInfo::sides_with_boundary_id(), libMesh::MeshTools::Modification::smooth(), libMesh::UnstructuredMesh::stitching_helper(), libMesh::Elem::swap2neighbors(), ElemTest< elem_type >::test_orient_elements(), DefaultCouplingTest::testCoupling(), PointNeighborCouplingTest::testCoupling(), MeshBaseTest::testMeshBaseVerifyIsPrepared(), InfFERadialTest::testSides(), libMesh::Elem::topological_neighbor(), libMesh::MeshRefinement::topological_neighbor(), libMesh::Elem::topologically_equal(), libMesh::MeshTetInterface::volume_to_surface_mesh(), libMesh::Elem::which_neighbor_am_i(), and libMesh::CheckpointIO::write_remote_elem().

2600 {
2601  libmesh_assert_less (i, this->n_neighbors());
2602 
2603  return _elemlinks[i+1];
2604 }
Elem ** _elemlinks
Pointers to this element&#39;s parent and neighbors, and for lower-dimensional elements&#39; interior_parent...
Definition: elem.h:2252
unsigned int n_neighbors() const
Definition: elem.h:715

◆ neighbor_ptr() [2/2]

Elem * libMesh::Elem::neighbor_ptr ( unsigned int  i)
inlineinherited
Returns
A non-const pointer to the \( i^{th} \) neighbor of this element.

Definition at line 2609 of file elem.h.

References libMesh::Elem::_elemlinks, and libMesh::Elem::n_neighbors().

2610 {
2611  libmesh_assert_less (i, this->n_neighbors());
2612 
2613  return _elemlinks[i+1];
2614 }
Elem ** _elemlinks
Pointers to this element&#39;s parent and neighbors, and for lower-dimensional elements&#39; interior_parent...
Definition: elem.h:2252
unsigned int n_neighbors() const
Definition: elem.h:715

◆ neighbor_ptr_range() [1/2]

SimpleRange< Elem::NeighborPtrIter > libMesh::Elem::neighbor_ptr_range ( )
inlineinherited

Returns a range with all neighbors of an element, usable in range-based for loops.

The exact type of the return value here may be subject to change in future libMesh releases, but the iterators will always dereference to produce a pointer to a neighbor element (or a null pointer, for sides which have no neighbors).

Definition at line 3504 of file elem.h.

References libMesh::Elem::_elemlinks, and libMesh::Elem::n_neighbors().

Referenced by ContrivedPartitioner::_do_partition(), libMesh::MeshTetInterface::check_hull_integrity(), libMesh::Elem::child_neighbor(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::Elem::has_neighbor(), libMesh::InfFE< Dim, T_radial, T_map >::inf_compute_constraints(), libMesh::Elem::make_links_to_me_remote(), libMesh::Elem::remove_links_to_me(), and DistributedMeshTest::testRemoteElemError().

3505 {
3506  return {_elemlinks+1, _elemlinks + 1 + this->n_neighbors()};
3507 }
Elem ** _elemlinks
Pointers to this element&#39;s parent and neighbors, and for lower-dimensional elements&#39; interior_parent...
Definition: elem.h:2252
unsigned int n_neighbors() const
Definition: elem.h:715

◆ neighbor_ptr_range() [2/2]

SimpleRange< Elem::ConstNeighborPtrIter > libMesh::Elem::neighbor_ptr_range ( ) const
inlineinherited

Definition at line 3511 of file elem.h.

References libMesh::Elem::_elemlinks, and libMesh::Elem::n_neighbors().

3512 {
3513  return {_elemlinks+1, _elemlinks + 1 + this->n_neighbors()};
3514 }
Elem ** _elemlinks
Pointers to this element&#39;s parent and neighbors, and for lower-dimensional elements&#39; interior_parent...
Definition: elem.h:2252
unsigned int n_neighbors() const
Definition: elem.h:715

◆ node_id()

dof_id_type libMesh::Elem::node_id ( const unsigned int  i) const
inlineinherited
Returns
The global id number of local Node i.

Definition at line 2476 of file elem.h.

References libMesh::Elem::_nodes, libMesh::DofObject::id(), libMesh::DofObject::invalid_id, libMesh::libmesh_assert(), and libMesh::Elem::n_nodes().

Referenced by libMesh::UnstructuredMesh::all_first_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::DofMap::allgather_recursive_constraints(), assemble_stokes(), libMesh::Elem::bracketing_nodes(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::FEMap::compute_face_map(), libMesh::InfQuad4::connectivity(), libMesh::InfEdge2::connectivity(), libMesh::Edge2::connectivity(), libMesh::Edge3::connectivity(), libMesh::Quad4::connectivity(), libMesh::Edge4::connectivity(), libMesh::InfHex8::connectivity(), libMesh::InfQuad6::connectivity(), libMesh::InfPrism6::connectivity(), libMesh::Tri3::connectivity(), connectivity(), libMesh::Prism6::connectivity(), libMesh::Hex8::connectivity(), libMesh::Quad8::connectivity(), libMesh::InfPrism12::connectivity(), libMesh::Quad9::connectivity(), libMesh::Tri6::connectivity(), libMesh::InfHex16::connectivity(), libMesh::Tri7::connectivity(), libMesh::Tet4::connectivity(), libMesh::InfHex18::connectivity(), libMesh::Hex20::connectivity(), libMesh::Tet10::connectivity(), libMesh::Prism15::connectivity(), libMesh::Tet14::connectivity(), libMesh::Hex27::connectivity(), libMesh::Prism18::connectivity(), libMesh::MeshTools::find_hanging_nodes_and_parents(), libMesh::Tri3Subdivision::get_ordered_node(), libMesh::Tri3Subdivision::get_ordered_valence(), libMesh::BoundaryInfo::get_side_and_node_maps(), libMesh::MeshTools::SidesToElemMap::get_sorted_vertex_ids(), libMesh::LaplaceMeshSmoother::init(), libMesh::Tet::key(), libMesh::InfQuad6::key(), libMesh::Pyramid::key(), libMesh::Prism::key(), libMesh::Hex::key(), libMesh::Tri::key(), libMesh::Polygon::key(), libMesh::Quad8::key(), libMesh::Quad9::key(), libMesh::Edge::key(), libMesh::Tri6::key(), libMesh::Quad::key(), libMesh::InfPrism::key(), libMesh::Tri7::key(), libMesh::Hex27::key(), libMesh::InfHex::key(), libMesh::Prism18::key(), libMesh::Pyramid14::key(), libMesh::InfQuad::key(), libMesh::Prism20::key(), libMesh::Edge2::key(), libMesh::InfHex18::key(), libMesh::Prism21::key(), libMesh::Pyramid18::key(), libMesh::Edge4::key(), libMesh::Edge3::key(), libMesh::Tet4::key(), libMesh::Elem::key(), libMesh::MeshTools::libmesh_assert_equal_connectivity(), libMesh::Elem::local_node(), libMesh::Tri3Subdivision::local_node_number(), libMesh::Tet::low_order_key(), libMesh::Pyramid::low_order_key(), libMesh::Prism::low_order_key(), libMesh::Hex::low_order_key(), libMesh::Tri::low_order_key(), libMesh::Polygon::low_order_key(), libMesh::Edge::low_order_key(), libMesh::Polyhedron::low_order_key(), libMesh::Quad::low_order_key(), libMesh::InfPrism::low_order_key(), libMesh::InfHex::low_order_key(), libMesh::InfQuad::low_order_key(), libMesh::Elem::operator==(), libMesh::XdrIO::pack_element(), libMesh::CheckpointIO::read_connectivity(), libMesh::Elem::topologically_equal(), libMesh::Elem::write_connectivity(), and libMesh::ExodusII_IO_Helper::write_elements().

2477 {
2478  libmesh_assert_less (i, this->n_nodes());
2479  libmesh_assert(_nodes[i]);
2480  libmesh_assert_not_equal_to (_nodes[i]->id(), Node::invalid_id);
2481 
2482  return _nodes[i]->id();
2483 }
Node ** _nodes
Pointers to the nodes we are connected to.
Definition: elem.h:2246
dof_id_type id() const
Definition: dof_object.h:828
static constexpr dof_id_type invalid_id
An invalid id to distinguish an uninitialized DofObject.
Definition: dof_object.h:482
virtual unsigned int n_nodes() const =0
libmesh_assert(ctx)

◆ node_index_range()

IntRange< unsigned short > libMesh::Elem::node_index_range ( ) const
inlineinherited

◆ node_ptr() [1/2]

const Node * libMesh::Elem::node_ptr ( const unsigned int  i) const
inlineinherited
Returns
A const pointer to local Node i.

Definition at line 2508 of file elem.h.

References libMesh::Elem::_nodes, libMesh::libmesh_assert(), and libMesh::Elem::n_nodes().

Referenced by libMesh::MeshTools::Subdivision::add_boundary_ghosts(), libMesh::BoundaryInfo::add_elements(), libMesh::MeshRefinement::add_node(), libMesh::MeshTools::Modification::all_tri(), libMesh::DofMap::allgather_recursive_constraints(), assemble_shell(), libMesh::EquationSystems::build_discontinuous_solution_vector(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::C0Polygon::build_side_ptr(), libMesh::Edge::build_side_ptr(), libMesh::BoundaryInfo::clear_stitched_boundary_side_ids(), libMesh::FEMap::compute_affine_map(), libMesh::FEMap::compute_map(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), libMesh::Elem::contains_vertex_of(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::find_dofs_to_send(), libMesh::MeshTools::Subdivision::find_one_ring(), libMesh::MeshTools::Modification::flatten(), libMesh::ReplicatedMesh::get_boundary_points(), libMesh::Elem::get_node_index(), libMesh::Elem::is_vertex_on_parent(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::Elem::libmesh_assert_valid_node_pointers(), libMesh::MeshTools::n_connected_components(), libMesh::Elem::node_ref(), libMesh::C0Polygon::permute(), libMesh::Tri3Subdivision::prepare_subdivision_properties(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::C0Polyhedron::retriangulate(), libMesh::FE< Dim, LAGRANGE_VEC >::shape(), libMesh::Polyhedron::side_clones(), libMesh::Edge::side_ptr(), libMesh::Polygon::side_ptr(), libMesh::Polyhedron::side_ptr(), libMesh::Tet4::side_vertex_average_normal(), libMesh::MeshTools::Modification::smooth(), libMesh::UnstructuredMesh::stitching_helper(), libMesh::Elem::swap2nodes(), SystemsTest::testDofCouplingWithVarGroups(), InfFERadialTest::testInfQuants_numericDeriv(), and InfFERadialTest::testSides().

2509 {
2510  libmesh_assert_less (i, this->n_nodes());
2511  libmesh_assert(_nodes[i]);
2512 
2513  return _nodes[i];
2514 }
Node ** _nodes
Pointers to the nodes we are connected to.
Definition: elem.h:2246
virtual unsigned int n_nodes() const =0
libmesh_assert(ctx)

◆ node_ptr() [2/2]

Node * libMesh::Elem::node_ptr ( const unsigned int  i)
inlineinherited
Returns
A non-const pointer to local Node i.

Definition at line 2519 of file elem.h.

References libMesh::Elem::_nodes, libMesh::libmesh_assert(), and libMesh::Elem::n_nodes().

2520 {
2521  libmesh_assert_less (i, this->n_nodes());
2522  libmesh_assert(_nodes[i]);
2523 
2524  return _nodes[i];
2525 }
Node ** _nodes
Pointers to the nodes we are connected to.
Definition: elem.h:2246
virtual unsigned int n_nodes() const =0
libmesh_assert(ctx)

◆ node_ref() [1/2]

const Node & libMesh::Elem::node_ref ( const unsigned int  i) const
inlineinherited

◆ node_ref() [2/2]

Node & libMesh::Elem::node_ref ( const unsigned int  i)
inlineinherited
Returns
A writable reference to local Node i.

Definition at line 2538 of file elem.h.

References libMesh::Elem::node_ptr().

2539 {
2540  return *this->node_ptr(i);
2541 }
const Node * node_ptr(const unsigned int i) const
Definition: elem.h:2508

◆ node_ref_range() [1/2]

SimpleRange< Elem::NodeRefIter > libMesh::Elem::node_ref_range ( )
inlineinherited

◆ node_ref_range() [2/2]

SimpleRange< Elem::ConstNodeRefIter > libMesh::Elem::node_ref_range ( ) const
inlineinherited

Definition at line 2675 of file elem.h.

References libMesh::Elem::_nodes, and libMesh::Elem::n_nodes().

2676 {
2677  return {_nodes, _nodes+this->n_nodes()};
2678 }
Node ** _nodes
Pointers to the nodes we are connected to.
Definition: elem.h:2246
virtual unsigned int n_nodes() const =0

◆ nodes_on_edge()

std::vector< unsigned > libMesh::Pyramid5::nodes_on_edge ( const unsigned int  int) const
overridevirtual
Returns
the (local) node numbers on the specified edge

Implements libMesh::Elem.

Definition at line 98 of file cell_pyramid5.C.

References edge_nodes_map, and libMesh::Pyramid::n_edges().

99 {
100  libmesh_assert_less(e, n_edges());
101  return {std::begin(edge_nodes_map[e]), std::end(edge_nodes_map[e])};
102 }
static const unsigned int edge_nodes_map[num_edges][nodes_per_edge]
This maps the node of the edge to element node numbers.
virtual unsigned int n_edges() const override
Definition: cell_pyramid.h:100

◆ nodes_on_side()

std::vector< unsigned > libMesh::Pyramid5::nodes_on_side ( const unsigned int  int) const
overridevirtual
Returns
the (local) node numbers on the specified side

Implements libMesh::Elem.

Definition at line 90 of file cell_pyramid5.C.

References libMesh::Pyramid::n_sides(), and side_nodes_map.

91 {
92  libmesh_assert_less(s, n_sides());
93  auto trim = (s == 4) ? 0 : 1;
94  return {std::begin(side_nodes_map[s]), std::end(side_nodes_map[s]) - trim};
95 }
virtual unsigned int n_sides() const override
Definition: cell_pyramid.h:90
static const unsigned int side_nodes_map[num_sides][nodes_per_side]
This maps the node of the side to element node numbers.

◆ nullify_neighbors()

void libMesh::Elem::nullify_neighbors ( )
inherited

Replaces this element with nullptr for all of its neighbors.

This is useful when deleting an element.

Definition at line 3018 of file elem.C.

References libMesh::Elem::level(), libMesh::Elem::n_neighbors(), libMesh::Elem::neighbor_ptr(), libMesh::remote_elem, libMesh::Elem::set_neighbor(), libMesh::Elem::side_index_range(), and libMesh::Elem::which_neighbor_am_i().

3019 {
3020  // Tell any of my neighbors about my death...
3021  // Looks strange, huh?
3022  for (auto n : this->side_index_range())
3023  {
3024  Elem * current_neighbor = this->neighbor_ptr(n);
3025  if (current_neighbor && current_neighbor != remote_elem)
3026  {
3027  // Note: it is possible that I see the neighbor
3028  // (which is coarser than me)
3029  // but they don't see me, so avoid that case.
3030  if (current_neighbor->level() == this->level())
3031  {
3032  const unsigned int w_n_a_i = current_neighbor->which_neighbor_am_i(this);
3033  libmesh_assert_less (w_n_a_i, current_neighbor->n_neighbors());
3034  current_neighbor->set_neighbor(w_n_a_i, nullptr);
3035  this->set_neighbor(n, nullptr);
3036  }
3037  }
3038  }
3039 }
IntRange< unsigned short > side_index_range() const
Definition: elem.h:2711
void set_neighbor(const unsigned int i, Elem *n)
Assigns n as the neighbor.
Definition: elem.h:2619
Elem(const unsigned int n_nodes, const unsigned int n_sides, Elem *parent, Elem **elemlinkdata, Node **nodelinkdata)
Constructor.
Definition: elem.h:2379
const Elem * neighbor_ptr(unsigned int i) const
Definition: elem.h:2599
unsigned int level() const
Definition: elem.h:3075
const RemoteElem * remote_elem
Definition: remote_elem.C:57

◆ on_boundary()

bool libMesh::Elem::on_boundary ( ) const
inlineinherited
Returns
true if this element has a side coincident with a boundary (indicated by a nullptr neighbor), false otherwise.

Definition at line 2910 of file elem.h.

References libMesh::Elem::has_neighbor().

2911 {
2912  // By convention, the element is on the boundary
2913  // if it has a nullptr neighbor.
2914  return this->has_neighbor(nullptr);
2915 }
bool has_neighbor(const Elem *elem) const
Definition: elem.h:2629

◆ on_reference_element()

bool libMesh::Pyramid::on_reference_element ( const Point p,
const Real  eps = TOLERANCE 
) const
finaloverridevirtualinherited
Returns
true if the master-space point p is contained in the reference element corresponding to this element, false otherwise.

Since we are doing floating point comparisons here the parameter eps can be specified to indicate a tolerance. For example, \( x \le 1 \) becomes \( x \le 1 + \epsilon \).

Implements libMesh::Elem.

Definition at line 300 of file cell_pyramid.C.

References libMesh::Real.

302 {
303  const Real & xi = p(0);
304  const Real & eta = p(1);
305  const Real & zeta = p(2);
306 
307  // Check that the point is on the same side of all the faces
308  // by testing whether:
309  //
310  // n_i.(x - x_i) <= 0
311  //
312  // for each i, where:
313  // n_i is the outward normal of face i,
314  // x_i is a point on face i.
315  return ((-eta - 1. + zeta <= 0.+eps) &&
316  ( xi - 1. + zeta <= 0.+eps) &&
317  ( eta - 1. + zeta <= 0.+eps) &&
318  ( -xi - 1. + zeta <= 0.+eps) &&
319  ( zeta >= 0.-eps));
320 }
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

◆ operator=() [1/2]

Pyramid5& libMesh::Pyramid5::operator= ( const Pyramid5 )
delete

◆ operator=() [2/2]

Pyramid5& libMesh::Pyramid5::operator= ( Pyramid5 &&  )
delete

◆ operator==()

bool libMesh::Elem::operator== ( const Elem rhs) const
inherited
Returns
true if two elements are equivalent, false otherwise. This is true if the elements are connected to identical global nodes, regardless of how those nodes might be numbered local to the elements.

Definition at line 769 of file elem.C.

References libMesh::Elem::n_nodes(), libMesh::Elem::node_id(), and libMesh::Elem::type().

770 {
771  // If the elements aren't the same type, they aren't equal
772  if (this->type() != rhs.type())
773  return false;
774 
775  const unsigned short n_n = this->n_nodes();
776  libmesh_assert_equal_to(n_n, rhs.n_nodes());
777 
778  // Make two sorted arrays of global node ids and compare them for
779  // equality.
780  std::array<dof_id_type, Elem::max_n_nodes> this_ids, rhs_ids;
781 
782  for (unsigned short n = 0; n != n_n; n++)
783  {
784  this_ids[n] = this->node_id(n);
785  rhs_ids[n] = rhs.node_id(n);
786  }
787 
788  // Sort the vectors to rule out different local node numberings.
789  std::sort(this_ids.begin(), this_ids.begin()+n_n);
790  std::sort(rhs_ids.begin(), rhs_ids.begin()+n_n);
791 
792  // If the node ids match, the elements are equal!
793  for (unsigned short n = 0; n != n_n; ++n)
794  if (this_ids[n] != rhs_ids[n])
795  return false;
796  return true;
797 }
virtual unsigned int n_nodes() const =0
virtual ElemType type() const =0
dof_id_type node_id(const unsigned int i) const
Definition: elem.h:2476

◆ opposite_node()

unsigned int libMesh::Elem::opposite_node ( const unsigned int  n,
const unsigned int  s 
) const
virtualinherited
Returns
The local node number for the node opposite to node n on side opposite_side(s) (for a tensor product element), or throws an error otherwise.

Reimplemented in libMesh::Quad, libMesh::Edge, libMesh::Polyhedron, libMesh::Hex, and libMesh::C0Polygon.

Definition at line 3534 of file elem.C.

3536 {
3537  // If the subclass didn't rederive this, using it is an error
3538  libmesh_not_implemented();
3539 }

◆ opposite_side()

unsigned int libMesh::Elem::opposite_side ( const unsigned int  s) const
virtualinherited
Returns
The side number opposite to s (for a tensor product element), or throws an error otherwise.

Reimplemented in libMesh::Quad, libMesh::Prism, libMesh::Polyhedron, libMesh::Edge, libMesh::Polygon, and libMesh::Hex.

Definition at line 3526 of file elem.C.

Referenced by VolumeTest::testC0PolygonMethods().

3527 {
3528  // If the subclass didn't rederive this, using it is an error
3529  libmesh_not_implemented();
3530 }

◆ orient()

void libMesh::Elem::orient ( BoundaryInfo boundary_info)
inlineinherited

Flips the element (by swapping node and neighbor pointers) to have a mapping Jacobian of opposite sign, iff we find a negative orientation.

This only fixes flipped elements; for tangled elements the only fixes possible are non-local.

Definition at line 3287 of file elem.h.

References libMesh::Elem::flip(), and libMesh::Elem::is_flipped().

Referenced by libMesh::MeshTools::Modification::orient_elements().

3288 {
3289  if (this->is_flipped())
3290  this->flip(boundary_info);
3291 }
virtual bool is_flipped() const =0
virtual void flip(BoundaryInfo *boundary_info)=0
Flips the element (by swapping node and neighbor pointers) to have a mapping Jacobian of opposite sig...

◆ origin()

virtual Point libMesh::Elem::origin ( ) const
inlinevirtualinherited
Returns
The origin for an infinite element.

Currently, all infinite elements used in a mesh share the same origin. Override this in infinite element classes.

Reimplemented in libMesh::InfQuad, libMesh::InfEdge2, and libMesh::InfCell.

Definition at line 1915 of file elem.h.

Referenced by InfFERadialTest::base_point(), libMesh::InfFE< Dim, T_radial, T_map >::compute_data(), libMesh::InfFE< Dim, T_radial, T_map >::compute_shape_functions(), libMesh::Elem::get_info(), libMesh::InfFEMap::inverse_map(), libMesh::InfFEMap::map(), InfFERadialTest::testInfQuants(), and InfFERadialTest::testInfQuants_numericDeriv().

1915 { libmesh_not_implemented(); return Point(); }

◆ p_level()

unsigned int libMesh::Elem::p_level ( ) const
inlineinherited
Returns
The value of the p refinement level of an active element, or the minimum value of the p refinement levels of an ancestor element's descendants.

Definition at line 3109 of file elem.h.

References libMesh::Elem::_p_level.

Referenced by libMesh::InfQuad6::build_side_ptr(), libMesh::FEGenericBase< FEOutputType< T >::type >::coarsened_dof_values(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_proj_constraints(), libMesh::DofMap::constrain_p_dofs(), libMesh::DofMap::dof_indices(), libMesh::FE< Dim, LAGRANGE_VEC >::dofs_on_edge(), libMesh::FE< Dim, LAGRANGE_VEC >::dofs_on_side(), libMesh::FE< Dim, LAGRANGE_VEC >::edge_map(), libMesh::FE< Dim, LAGRANGE_VEC >::edge_reinit(), libMesh::Elem::Elem(), libMesh::MeshRefinement::enforce_mismatch_limit_prior_to_refinement(), libMesh::Elem::get_info(), libMesh::Elem::inherit_data_from(), libMesh::QBase::init(), libMesh::InfFE< Dim, T_radial, T_map >::init_face_shape_functions(), libMesh::lagrange_nodal_soln(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_p_levels(), libMesh::LIBMESH_DEFAULT_VECTORIZED_FE(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::Elem::max_descendant_p_level(), libMesh::Elem::min_new_p_level_by_neighbor(), libMesh::Elem::min_p_level_by_neighbor(), libMesh::FEInterface::n_dofs(), libMesh::FEInterface::n_dofs_at_node(), libMesh::FEInterface::n_dofs_per_elem(), libMesh::FEInterface::n_shape_functions(), libMesh::DofMap::old_dof_indices(), libMesh::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectEdges::operator()(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectSides::operator()(), libMesh::XdrIO::pack_element(), libMesh::Polygon::Polygon(), libMesh::Polyhedron::Polyhedron(), libMesh::rational_fe_shape(), libMesh::rational_fe_shape_deriv(), libMesh::rational_fe_shape_second_deriv(), libMesh::rational_fe_weighted_shapes(), libMesh::rational_fe_weighted_shapes_derivs(), libMesh::Elem::refine(), libMesh::InfFE< Dim, T_radial, T_map >::reinit(), libMesh::FE< Dim, LAGRANGE_VEC >::reinit(), libMesh::FEXYZ< Dim >::reinit(), libMesh::FE< Dim, LAGRANGE_VEC >::reinit_dual_shape_coeffs(), libMesh::HPCoarsenTest::select_refinement(), libMesh::Elem::set_p_level(), libMesh::Elem::set_p_refinement_flag(), libMesh::FE< Dim, LAGRANGE_VEC >::shape(), libMesh::InfFE< Dim, T_radial, T_map >::shape(), libMesh::InfFE< Dim, T_radial, T_map >::shape_deriv(), libMesh::FE< Dim, LAGRANGE_VEC >::shape_deriv(), libMesh::FE< Dim, LAGRANGE_VEC >::shape_second_deriv(), libMesh::FE< Dim, LAGRANGE_VEC >::side_map(), libMesh::SparsityPattern::Build::sorted_connected_dofs(), libMesh::MeshRefinement::test_level_one(), and libMesh::Elem::true_centroid().

3110 {
3111 #ifdef LIBMESH_ENABLE_AMR
3112  return _p_level;
3113 #else
3114  return 0;
3115 #endif
3116 }
unsigned char _p_level
p refinement level - the difference between the polynomial degree on this element and the minimum pol...
Definition: elem.h:2291

◆ p_refinement_flag()

Elem::RefinementState libMesh::Elem::p_refinement_flag ( ) const
inlineinherited

◆ pack_indexing()

void libMesh::DofObject::pack_indexing ( std::back_insert_iterator< std::vector< largest_id_type >>  target) const
inherited

A method for creating packed data from our index buffer - basically a copy with prepended size with our current implementation.

Definition at line 634 of file dof_object.C.

References libMesh::DofObject::_idx_buf, and libMesh::DofObject::old_dof_object.

635 {
636 #ifdef LIBMESH_ENABLE_AMR
637  // We might need to pack old_dof_object too
638  *target++ = (old_dof_object == nullptr) ? 0 : 1;
639 #endif
640 
641  *target++ = _idx_buf.size();
642  std::copy(_idx_buf.begin(), _idx_buf.end(), target);
643 
644 #ifdef LIBMESH_ENABLE_AMR
645  if (old_dof_object)
646  old_dof_object->pack_indexing(target);
647 #endif
648 }
std::unique_ptr< DofObject > old_dof_object
This object on the last mesh.
Definition: dof_object.h:88
index_buffer_t _idx_buf
Definition: dof_object.h:680

◆ packed_indexing_size()

unsigned int libMesh::DofObject::packed_indexing_size ( ) const
inherited

If we pack our indices into an buffer for communications, how many ints do we need?

Definition at line 552 of file dof_object.C.

References libMesh::DofObject::_idx_buf, and libMesh::DofObject::old_dof_object.

Referenced by libMesh::Node::packed_size().

553 {
554  return
555  cast_int<unsigned int> (
556 #ifdef LIBMESH_ENABLE_AMR
557  ((old_dof_object == nullptr) ? 0 : old_dof_object->packed_indexing_size()) + 2 +
558 #else
559  1 +
560 #endif
561  _idx_buf.size());
562 }
std::unique_ptr< DofObject > old_dof_object
This object on the last mesh.
Definition: dof_object.h:88
index_buffer_t _idx_buf
Definition: dof_object.h:680

◆ parent() [1/2]

const Elem * libMesh::Elem::parent ( ) const
inlineinherited
Returns
A const pointer to the element's parent, or nullptr if the element was not created via refinement.

Definition at line 3031 of file elem.h.

References libMesh::Elem::_elemlinks.

Referenced by libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::Elem::add_child(), libMesh::BoundaryInfo::add_elements(), libMesh::UnstructuredMesh::all_first_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::BoundaryInfo::boundary_ids(), libMesh::OldSolutionBase< Output, point_output >::check_old_context(), libMesh::FEAbstract::compute_node_constraints(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::MeshRefinement::create_parent_error_vector(), libMesh::DistributedMesh::delete_elem(), libMesh::BoundaryInfo::edge_boundary_ids(), libMesh::Elem::Elem(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::OldSolutionCoefs< Output, point_output >::eval_old_dofs(), libMesh::OldSolutionValue< Output, point_output >::eval_old_dofs(), libMesh::MeshTools::find_hanging_nodes_and_parents(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_error_fraction(), libMesh::MeshRefinement::flag_elements_by_error_tolerance(), libMesh::Elem::get_info(), libMesh::InfFE< Dim, T_radial, T_map >::inf_compute_constraints(), libMesh::Elem::is_ancestor_of(), libMesh::Elem::level(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_amr_elem_ids(), libMesh::MeshTools::libmesh_assert_valid_amr_interior_parents(), libMesh::Elem::libmesh_assert_valid_neighbors(), libMesh::MeshTools::libmesh_assert_valid_remote_elems(), libMesh::MeshRefinement::limit_level_mismatch_at_edge(), libMesh::Elem::make_links_to_me_local(), libMesh::Elem::make_links_to_me_remote(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::SiblingCoupling::operator()(), libMesh::BuildProjectionList::operator()(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectVertices::operator()(), libMesh::BoundaryInfo::raw_boundary_ids(), libMesh::BoundaryInfo::raw_edge_boundary_ids(), libMesh::BoundaryInfo::raw_shellface_boundary_ids(), libMesh::CheckpointIO::read_connectivity(), libMesh::Elem::refine(), libMesh::Elem::remove_links_to_me(), libMesh::HPCoarsenTest::select_refinement(), libMesh::Elem::set_p_level(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::BoundaryInfo::shellface_boundary_ids(), libMesh::BoundaryInfo::side_boundary_ids(), libMesh::BoundaryInfo::side_with_boundary_id(), libMesh::BoundaryInfo::sides_with_boundary_id(), libMesh::MeshTools::Modification::smooth(), libMesh::Elem::subactive(), libMesh::Parallel::sync_element_data_by_parent_id(), ElemTest< elem_type >::test_n_refinements(), libMesh::Elem::top_parent(), libMesh::Elem::topological_neighbor(), libMesh::Elem::topologically_equal(), and libMesh::Elem::which_neighbor_am_i().

3032 {
3033  return _elemlinks[0];
3034 }
Elem ** _elemlinks
Pointers to this element&#39;s parent and neighbors, and for lower-dimensional elements&#39; interior_parent...
Definition: elem.h:2252

◆ parent() [2/2]

Elem * libMesh::Elem::parent ( )
inlineinherited
Returns
A pointer to the element's parent, or nullptr if the element was not created via refinement.

Definition at line 3039 of file elem.h.

References libMesh::Elem::_elemlinks.

3040 {
3041  return _elemlinks[0];
3042 }
Elem ** _elemlinks
Pointers to this element&#39;s parent and neighbors, and for lower-dimensional elements&#39; interior_parent...
Definition: elem.h:2252

◆ parent_bracketing_nodes()

const std::vector< std::pair< unsigned char, unsigned char > > & libMesh::Elem::parent_bracketing_nodes ( unsigned int  c,
unsigned int  n 
) const
virtualinherited
Returns
All the pairs of nodes (indexed by local node id) which should bracket node n of child c.

Reimplemented in libMesh::Prism21, libMesh::Prism20, libMesh::Tet14, and libMesh::Tri7.

Definition at line 2452 of file elem.C.

References libMesh::Elem::_get_bracketing_node_cache(), libMesh::TypeVector< T >::absolute_fuzzy_equals(), libMesh::TypeVector< T >::add_scaled(), libMesh::Elem::as_parent_node(), libMesh::Elem::build(), libMesh::Elem::default_order(), libMesh::Elem::embedding_matrix(), libMesh::Elem::embedding_matrix_version(), libMesh::FIRST, libMesh::invalid_uint, libMesh::Elem::is_mid_infinite_edge_node(), libMesh::Elem::is_vertex_on_child(), libMesh::libmesh_assert(), libMesh::Elem::master_point(), libMesh::Elem::n_children(), libMesh::Elem::n_nodes(), libMesh::Elem::n_nodes_in_child(), libMesh::parent_bracketing_nodes_mutex, libMesh::Real, libMesh::Elem::second_order_equivalent_type(), and libMesh::Elem::type().

Referenced by libMesh::Elem::bracketing_nodes(), and main().

2454 {
2455  // Indexed first by embedding matrix type, then by child id, then by
2456  // child node, then by bracketing pair
2457  std::vector<std::vector<std::vector<std::vector<std::pair<unsigned char, unsigned char>>>>> &
2458  cached_bracketing_nodes = this->_get_bracketing_node_cache();
2459 
2460  const unsigned int em_vers = this->embedding_matrix_version();
2461 
2462  // We may be updating the cache on one thread, and while that
2463  // happens we can't safely access the cache from other threads.
2464  Threads::spin_mutex::scoped_lock lock(parent_bracketing_nodes_mutex);
2465 
2466  if (cached_bracketing_nodes.size() <= em_vers)
2467  cached_bracketing_nodes.resize(em_vers+1);
2468 
2469  const unsigned int nc = this->n_children();
2470 
2471  // If we haven't cached the bracketing nodes corresponding to this
2472  // embedding matrix yet, let's do so now.
2473  if (cached_bracketing_nodes[em_vers].size() < nc)
2474  {
2475  // If we're a second-order element but we're not a full-order
2476  // element, then some of our bracketing nodes may not exist
2477  // except on the equivalent full-order element. Let's build an
2478  // equivalent full-order element and make a copy of its cache to
2479  // use.
2480  if (this->default_order() != FIRST &&
2481  second_order_equivalent_type(this->type(), /*full_ordered=*/ true) != this->type())
2482  {
2483  // Check that we really are the non-full-order type
2484  libmesh_assert_equal_to
2485  (second_order_equivalent_type (this->type(), false),
2486  this->type());
2487 
2488  // Build the full-order type
2489  ElemType full_type =
2490  second_order_equivalent_type(this->type(), /*full_ordered=*/ true);
2491  std::unique_ptr<Elem> full_elem = Elem::build(full_type);
2492 
2493  // This won't work for elements with multiple
2494  // embedding_matrix versions, but every such element is full
2495  // order anyways.
2496  libmesh_assert_equal_to(em_vers, 0);
2497 
2498  // Make sure its cache has been built. We temporarily
2499  // release our mutex lock so that the inner call can
2500  // re-acquire it.
2501  lock.release();
2502  full_elem->parent_bracketing_nodes(0,0);
2503 
2504  // And then we need to lock again, so that if someone *else*
2505  // grabbed our lock before we did we don't risk accessing
2506  // cached_bracketing_nodes while they're working on it.
2507  // Threading is hard.
2508  lock.acquire(parent_bracketing_nodes_mutex);
2509 
2510  // Copy its cache
2511  cached_bracketing_nodes =
2512  full_elem->_get_bracketing_node_cache();
2513 
2514  // Now we don't need to build the cache ourselves.
2515  return cached_bracketing_nodes[em_vers][child][child_node];
2516  }
2517 
2518  cached_bracketing_nodes[em_vers].resize(nc);
2519 
2520  const unsigned int nn = this->n_nodes();
2521 
2522  // We have to examine each child
2523  for (unsigned int c = 0; c != nc; ++c)
2524  {
2525  const unsigned int ncn = this->n_nodes_in_child(c);
2526 
2527  cached_bracketing_nodes[em_vers][c].resize(ncn);
2528 
2529  // We have to examine each node in that child
2530  for (unsigned int n = 0; n != ncn; ++n)
2531  {
2532  // If this child node isn't a vertex or an infinite
2533  // child element's mid-infinite-edge node, then we need
2534  // to find bracketing nodes on the child.
2535  if (!this->is_vertex_on_child(c, n)
2536 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
2537  && !this->is_mid_infinite_edge_node(n)
2538 #endif
2539  )
2540  {
2541  // Use the embedding matrix to find the child node
2542  // location in parent master element space
2543  Point bracketed_pt;
2544 
2545  for (unsigned int pn = 0; pn != nn; ++pn)
2546  {
2547  const Real em_val =
2548  this->embedding_matrix(c,n,pn);
2549 
2550  libmesh_assert_not_equal_to (em_val, 1);
2551  if (em_val != 0.)
2552  bracketed_pt.add_scaled(this->master_point(pn), em_val);
2553  }
2554 
2555  // Check each pair of nodes on the child which are
2556  // also both parent nodes
2557  for (unsigned int n1 = 0; n1 != ncn; ++n1)
2558  {
2559  if (n1 == n)
2560  continue;
2561 
2562  unsigned int parent_n1 =
2563  this->as_parent_node(c,n1);
2564 
2565  if (parent_n1 == libMesh::invalid_uint)
2566  continue;
2567 
2568  Point p1 = this->master_point(parent_n1);
2569 
2570  for (unsigned int n2 = n1+1; n2 < nn; ++n2)
2571  {
2572  if (n2 == n)
2573  continue;
2574 
2575  unsigned int parent_n2 =
2576  this->as_parent_node(c,n2);
2577 
2578  if (parent_n2 == libMesh::invalid_uint)
2579  continue;
2580 
2581  Point p2 = this->master_point(parent_n2);
2582 
2583  Point pmid = (p1 + p2)/2;
2584 
2585  if (pmid == bracketed_pt)
2586  {
2587  cached_bracketing_nodes[em_vers][c][n].emplace_back(parent_n1, parent_n2);
2588  break;
2589  }
2590  else
2591  libmesh_assert(!pmid.absolute_fuzzy_equals(bracketed_pt));
2592  }
2593  }
2594  }
2595  // If this child node is a parent node, we need to
2596  // find bracketing nodes on the parent.
2597  else
2598  {
2599  unsigned int parent_node = this->as_parent_node(c,n);
2600 
2601  Point bracketed_pt;
2602 
2603  // If we're not a parent node, use the embedding
2604  // matrix to find the child node location in parent
2605  // master element space
2606  if (parent_node == libMesh::invalid_uint)
2607  {
2608  for (unsigned int pn = 0; pn != nn; ++pn)
2609  {
2610  const Real em_val =
2611  this->embedding_matrix(c,n,pn);
2612 
2613  libmesh_assert_not_equal_to (em_val, 1);
2614  if (em_val != 0.)
2615  bracketed_pt.add_scaled(this->master_point(pn), em_val);
2616  }
2617  }
2618  // If we're a parent node then we need no arithmetic
2619  else
2620  bracketed_pt = this->master_point(parent_node);
2621 
2622  for (unsigned int n1 = 0; n1 != nn; ++n1)
2623  {
2624  if (n1 == parent_node)
2625  continue;
2626 
2627  Point p1 = this->master_point(n1);
2628 
2629  for (unsigned int n2 = n1+1; n2 < nn; ++n2)
2630  {
2631  if (n2 == parent_node)
2632  continue;
2633 
2634  Point pmid = (p1 + this->master_point(n2))/2;
2635 
2636  if (pmid == bracketed_pt)
2637  {
2638  cached_bracketing_nodes[em_vers][c][n].emplace_back(n1, n2);
2639  break;
2640  }
2641  else
2642  libmesh_assert(!pmid.absolute_fuzzy_equals(bracketed_pt));
2643  }
2644  }
2645  }
2646  }
2647  }
2648  }
2649 
2650  return cached_bracketing_nodes[em_vers][child][child_node];
2651 }
ElemType
Defines an enum for geometric element types.
const unsigned int invalid_uint
A number which is used quite often to represent an invalid or uninitialized value for an unsigned int...
Definition: libmesh.h:310
virtual unsigned int embedding_matrix_version() const
Definition: elem.h:2052
virtual unsigned int n_children() const =0
virtual Real embedding_matrix(const unsigned int child_num, const unsigned int child_node_num, const unsigned int parent_node_num) const =0
virtual unsigned int n_nodes() const =0
virtual unsigned int as_parent_node(unsigned int c, unsigned int n) const
Definition: elem.C:2384
static std::unique_ptr< Elem > build(const ElemType type, Elem *p=nullptr)
Definition: elem.C:442
libmesh_assert(ctx)
Threads::spin_mutex parent_bracketing_nodes_mutex
Definition: elem.C:98
static ElemType second_order_equivalent_type(const ElemType et, const bool full_ordered=true)
Definition: elem.C:3139
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
virtual Point master_point(const unsigned int i) const =0
virtual bool is_vertex_on_child(unsigned int, unsigned int n) const
Definition: elem.h:775
virtual Order default_order() const =0
virtual std::vector< std::vector< std::vector< std::vector< std::pair< unsigned char, unsigned char > > > > > & _get_bracketing_node_cache() const
Elem subclasses which don&#39;t do their own bracketing node calculations will need to supply a static ca...
Definition: elem.h:2210
virtual ElemType type() const =0
virtual unsigned int n_nodes_in_child(unsigned int) const
Definition: elem.h:669
virtual bool is_mid_infinite_edge_node(const unsigned int) const
Definition: elem.h:1906

◆ permute()

void libMesh::Pyramid5::permute ( unsigned int  perm_num)
finaloverridevirtual

Permutes the element (by swapping node and neighbor pointers) according to the specified index.

This is useful for regression testing, by making it easy to make a structured mesh behave more like an arbitrarily unstructured mesh.

This is so far only used for regression testing, so we do not currently provide a way to permute any boundary side/edge ids along with the element permutation.

Implements libMesh::Elem.

Definition at line 274 of file cell_pyramid5.C.

References libMesh::Elem::swap4neighbors(), and libMesh::Elem::swap4nodes().

275 {
276  libmesh_assert_less (perm_num, 4);
277 
278  for (unsigned int i = 0; i != perm_num; ++i)
279  {
280  swap4nodes(0,1,2,3);
281  swap4neighbors(0,1,2,3);
282  }
283 }
void swap4nodes(unsigned int n1, unsigned int n2, unsigned int n3, unsigned int n4)
Swaps four node_ptrs, "rotating" them.
Definition: elem.h:2144
void swap4neighbors(unsigned int n1, unsigned int n2, unsigned int n3, unsigned int n4)
Swaps four neighbor_ptrs, "rotating" them.
Definition: elem.h:2154

◆ point() [1/2]

const Point & libMesh::Elem::point ( const unsigned int  i) const
inlineinherited
Returns
The Point associated with local Node i.

Definition at line 2454 of file elem.h.

References libMesh::Elem::_nodes, libMesh::DofObject::invalid_id, libMesh::libmesh_assert(), and libMesh::Elem::n_nodes().

Referenced by libMesh::PostscriptIO::_compute_edge_bezier_coeffs(), libMesh::MeshTools::Subdivision::add_boundary_ghosts(), libMesh::BoundaryInfo::add_elements(), libMesh::MeshRefinement::add_node(), libMesh::C0Polyhedron::add_tet(), libMesh::MeshTools::Modification::all_tri(), assemble_stokes(), libMesh::FE< Dim, LAGRANGE_VEC >::cache(), libMesh::Tet::choose_diagonal(), libMesh::Elem::coarsen(), libMesh::InfFE< Dim, T_radial, T_map >::compute_data(), libMesh::FEMap::compute_edge_map(), libMesh::FEMap::compute_face_map(), libMesh::Elem::contains_edge_of(), libMesh::InfQuad4::contains_point(), libMesh::Tri3::contains_point(), libMesh::InfPrism::contains_point(), libMesh::InfHex::contains_point(), libMesh::Tet4::contains_point(), libMesh::NodeElem::contains_point(), libMesh::Elem::contains_vertex_of(), libMesh::Polyhedron::convex(), libMesh::ElemCutter::cut_2D(), libMesh::ElemCutter::cut_3D(), libMesh::FEMContext::elem_position_get(), libMesh::Edge3::has_affine_map(), libMesh::Quad4::has_affine_map(), libMesh::Edge4::has_affine_map(), libMesh::Quad8::has_affine_map(), libMesh::Quad9::has_affine_map(), libMesh::Prism6::has_affine_map(), libMesh::Hex8::has_affine_map(), libMesh::Tri6::has_affine_map(), libMesh::Tri7::has_affine_map(), libMesh::C0Polygon::has_affine_map(), libMesh::Hex20::has_affine_map(), libMesh::Hex27::has_affine_map(), libMesh::Tet10::has_affine_map(), libMesh::Prism15::has_affine_map(), libMesh::Prism18::has_affine_map(), libMesh::Tet14::has_affine_map(), libMesh::Prism20::has_affine_map(), libMesh::Prism21::has_affine_map(), libMesh::Quad4::has_invertible_map(), libMesh::Edge3::has_invertible_map(), libMesh::Edge4::has_invertible_map(), libMesh::Elem::hmax(), libMesh::Elem::hmin(), libMesh::Prism::is_flipped(), libMesh::Hex::is_flipped(), libMesh::Polygon::is_flipped(), libMesh::Tri::is_flipped(), libMesh::Pyramid::is_flipped(), libMesh::InfPrism::is_flipped(), libMesh::Quad::is_flipped(), libMesh::Tet::is_flipped(), libMesh::InfHex::is_flipped(), libMesh::Edge::is_flipped(), libMesh::Polyhedron::is_flipped(), libMesh::InfQuad::is_flipped(), libMesh::Elem::length(), libMesh::Edge4::loose_bounding_box(), libMesh::Edge3::loose_bounding_box(), libMesh::Quad8::loose_bounding_box(), libMesh::Quad9::loose_bounding_box(), libMesh::Tri7::loose_bounding_box(), libMesh::Tri6::loose_bounding_box(), libMesh::Elem::loose_bounding_box(), main(), libMesh::InfFEMap::map(), libMesh::FEMap::map(), libMesh::FEMap::map_deriv(), libMesh::Polyhedron::master_point(), libMesh::FE< Dim, LAGRANGE_VEC >::matches_cache(), libMesh::Tri3::min_and_max_angle(), libMesh::Tet4::min_and_max_angle(), libMesh::FEMSystem::numerical_jacobian(), libMesh::Polyhedron::on_reference_element(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectVertices::operator()(), libMesh::InfCell::origin(), libMesh::InfEdge2::origin(), libMesh::InfQuad::origin(), libMesh::PostscriptIO::plot_linear_elem(), libMesh::Polyhedron::Polyhedron(), libMesh::Elem::positive_edge_orientation(), libMesh::Elem::positive_face_orientation(), libMesh::Hex::quality(), libMesh::Tri::quality(), libMesh::Quad::quality(), libMesh::Elem::quality(), libMesh::Face::quasicircumcenter(), libMesh::Edge::quasicircumcenter(), libMesh::NodeElem::quasicircumcenter(), libMesh::C0Polygon::retriangulate(), libMesh::FE< Dim, LAGRANGE_VEC >::shape_deriv(), libMesh::FE< Dim, LAGRANGE_VEC >::shape_second_deriv(), libMesh::SimplexRefiner::should_refine_elem(), libMesh::Poly2TriTriangulator::should_refine_elem(), libMesh::Edge2::side_vertex_average_normal(), libMesh::Quad4::side_vertex_average_normal(), libMesh::C0Polygon::side_vertex_average_normal(), side_vertex_average_normal(), libMesh::Tri3::side_vertex_average_normal(), libMesh::Prism6::side_vertex_average_normal(), libMesh::Hex8::side_vertex_average_normal(), libMesh::MeshTools::Modification::smooth(), ExtraIntegersTest::test_final_integers(), BoundaryInfoTest::testShellFaceConstraints(), VolumeTest::testTwistedVolume(), libMesh::Edge2::true_centroid(), libMesh::Quad4::true_centroid(), libMesh::C0Polyhedron::true_centroid(), true_centroid(), libMesh::C0Polygon::true_centroid(), libMesh::Prism6::true_centroid(), libMesh::Hex8::true_centroid(), libMesh::Elem::true_centroid(), libMesh::Edge2::volume(), libMesh::C0Polyhedron::volume(), libMesh::Edge3::volume(), libMesh::Quad4::volume(), libMesh::C0Polygon::volume(), libMesh::Tri3::volume(), volume(), libMesh::Edge4::volume(), libMesh::Quad8::volume(), libMesh::Hex8::volume(), libMesh::Quad9::volume(), libMesh::Tri6::volume(), libMesh::Tet4::volume(), libMesh::Pyramid13::volume(), libMesh::Hex20::volume(), libMesh::Tet10::volume(), libMesh::Prism15::volume(), libMesh::Pyramid14::volume(), libMesh::Hex27::volume(), libMesh::Prism18::volume(), and libMesh::Elem::which_side_am_i().

2455 {
2456  libmesh_assert_less (i, this->n_nodes());
2457  libmesh_assert(_nodes[i]);
2458  libmesh_assert_not_equal_to (_nodes[i]->id(), Node::invalid_id);
2459 
2460  return *_nodes[i];
2461 }
Node ** _nodes
Pointers to the nodes we are connected to.
Definition: elem.h:2246
static constexpr dof_id_type invalid_id
An invalid id to distinguish an uninitialized DofObject.
Definition: dof_object.h:482
virtual unsigned int n_nodes() const =0
libmesh_assert(ctx)

◆ point() [2/2]

Point & libMesh::Elem::point ( const unsigned int  i)
inlineinherited
Returns
The Point associated with local Node i as a writable reference.

Definition at line 2466 of file elem.h.

References libMesh::Elem::_nodes, and libMesh::Elem::n_nodes().

2467 {
2468  libmesh_assert_less (i, this->n_nodes());
2469 
2470  return *_nodes[i];
2471 }
Node ** _nodes
Pointers to the nodes we are connected to.
Definition: elem.h:2246
virtual unsigned int n_nodes() const =0

◆ positive_edge_orientation()

bool libMesh::Elem::positive_edge_orientation ( const unsigned int  i) const
inherited
Returns
true if edge i is positively oriented. An edge is positively oriented iff its first vertex (i.e. zeroth node) is lexicographically greater than its second vertex (i.e. first node).

Definition at line 3604 of file elem.C.

References libMesh::Elem::local_edge_node(), libMesh::Elem::n_edges(), and libMesh::Elem::point().

Referenced by libMesh::FE< Dim, LAGRANGE_VEC >::cache(), libMesh::FE< Dim, LAGRANGE_VEC >::matches_cache(), libMesh::FE< Dim, LAGRANGE_VEC >::shape(), libMesh::FE< Dim, LAGRANGE_VEC >::shape_deriv(), and libMesh::FE< Dim, LAGRANGE_VEC >::shape_second_deriv().

3605 {
3606  libmesh_assert_less (i, this->n_edges());
3607 
3608  return this->point(this->local_edge_node(i, 0)) >
3609  this->point(this->local_edge_node(i, 1));
3610 }
virtual unsigned int local_edge_node(unsigned int edge, unsigned int edge_node) const =0
Similar to Elem::local_side_node(), but instead of a side id, takes an edge id and a node id on that ...
virtual unsigned int n_edges() const =0
const Point & point(const unsigned int i) const
Definition: elem.h:2454

◆ positive_face_orientation()

bool libMesh::Elem::positive_face_orientation ( const unsigned int  i) const
inherited
Returns
true if face i is positively oriented. A face is positively oriented iff the triangle defined by the lexicographically least vertex and its two adjacent vertices on the same face is positively oriented. Said triangle is positively oriented iff its vertices are an odd permutation of their lexicographic ordering.

Definition at line 3613 of file elem.C.

References distance(), libMesh::Elem::n_faces(), libMesh::Elem::nodes_on_side(), libMesh::Elem::point(), and libMesh::Elem::side_ptr().

Referenced by libMesh::FE< Dim, LAGRANGE_VEC >::cache(), libMesh::FE< Dim, LAGRANGE_VEC >::matches_cache(), libMesh::FE< Dim, LAGRANGE_VEC >::shape(), and libMesh::FE< Dim, LAGRANGE_VEC >::shape_deriv().

3614 {
3615  libmesh_assert_less (i, this->n_faces());
3616 
3617  // Get the number of vertices N of face i. Note that for 3d elements, i.e.
3618  // elements for which this->n_faces() > 0, the number of vertices on any of
3619  // its sides (or faces) is just the number of that face's sides (or edges).
3620  auto side_i = this->side_ptr(i);
3621  const unsigned int N = side_i->n_sides();
3622 
3623  const std::vector<unsigned int> nodes = this->nodes_on_side(i);
3624 
3625  auto cmp = [&](const unsigned int & m, const unsigned int & n) -> bool
3626  { return this->point(m) < this->point(n); };
3627 
3628  const unsigned int V = std::distance(nodes.begin(),
3629  std::min_element(nodes.begin(), nodes.begin() + N, cmp));
3630 
3631  return cmp(nodes[(V + N - 1) % N], nodes[(V + 1) % N]);
3632 }
Real distance(const Point &p)
virtual std::unique_ptr< Elem > side_ptr(unsigned int i)=0
virtual unsigned int n_faces() const =0
const Point & point(const unsigned int i) const
Definition: elem.h:2454
virtual std::vector< unsigned int > nodes_on_side(const unsigned int) const =0

◆ print_dof_info()

void libMesh::DofObject::print_dof_info ( ) const
inherited

Print out info for debugging.

Definition at line 662 of file dof_object.C.

References libMesh::DofObject::dof_number(), libMesh::DofObject::id(), libMesh::make_range(), libMesh::DofObject::n_comp(), libMesh::DofObject::n_systems(), libMesh::DofObject::n_vars(), and libMesh::out.

663 {
664  libMesh::out << this->id() << " [ ";
665 
666  for (auto s : make_range(this->n_systems()))
667  {
668  libMesh::out << "s:" << s << " ";
669  for (auto var : make_range(this->n_vars(s)))
670  {
671  libMesh::out << "v:" << var << " ";
672  for (auto comp : make_range(this->n_comp(s,var)))
673  {
674  libMesh::out << "c:" << comp << " dof:" << this->dof_number(s,var,comp) << " ";
675  }
676  }
677  }
678 
679  libMesh::out << "]\n";
680 }
dof_id_type dof_number(const unsigned int s, const unsigned int var, const unsigned int comp) const
Definition: dof_object.h:1032
unsigned int n_comp(const unsigned int s, const unsigned int var) const
Definition: dof_object.h:1002
dof_id_type id() const
Definition: dof_object.h:828
unsigned int n_vars(const unsigned int s, const unsigned int vg) const
Definition: dof_object.h:967
unsigned int n_systems() const
Definition: dof_object.h:937
OStreamProxy out
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140

◆ print_info() [1/3]

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

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

Definition at line 81 of file reference_counter.C.

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

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

82 {
84  out_stream << ReferenceCounter::get_info();
85 }
static std::string get_info()
Gets a string containing the reference information.
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called...

◆ print_info() [2/3]

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

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

Definition at line 81 of file reference_counter.C.

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

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

82 {
84  out_stream << ReferenceCounter::get_info();
85 }
static std::string get_info()
Gets a string containing the reference information.
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called...

◆ print_info() [3/3]

void libMesh::Elem::print_info ( std::ostream &  os = libMesh::out) const
inherited

Prints relevant information about the element.

Definition at line 2919 of file elem.C.

References libMesh::Elem::get_info().

Referenced by libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::inverse_map(), and libMesh::operator<<().

2920 {
2921  os << this->get_info()
2922  << std::endl;
2923 }
std::string get_info() const
Prints relevant information about the element to a string.
Definition: elem.C:2927

◆ processor_id() [1/3]

processor_id_type libMesh::DofObject::processor_id ( ) const
inlineinherited
Returns
The processor that this DofObject belongs to.

When partitioning and DoF numbering have been performed by libMesh, every current DoF on this DofObject will belong to its processor.

Definition at line 905 of file dof_object.h.

References libMesh::DofObject::_processor_id.

Referenced by NonManifoldTestPartitioner::_do_partition(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::DistributedMesh::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::DistributedMesh::add_node(), libMesh::MeshRefinement::add_node(), libMesh::ReplicatedMesh::add_point(), libMesh::DistributedMesh::add_point(), libMesh::RBConstruction::add_scaled_matrix_and_vector(), libMesh::MeshTools::Modification::all_tri(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::Patch::build_around_element(), libMesh::Partitioner::build_graph(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::MeshFunction::check_found_elem(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubProjector::construct_projection(), libMesh::MeshBase::copy_constraint_rows(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::DistributedMesh::delete_elem(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::Elem::Elem(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::find_dofs_to_send(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::MeshTools::Modification::flatten(), libMesh::Node::get_info(), libMesh::Elem::get_info(), libMesh::Elem::inherit_data_from(), libMesh::RBEIMConstruction::initialize_qp_data(), libMesh::DistributedMesh::insert_elem(), libMesh::DofObject::invalidate_processor_id(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_amr_elem_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DofMap::local_variable_indices(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshCommunication::make_new_node_proc_ids_parallel_consistent(), AugmentSparsityOnInterface::mesh_reinit(), ExodusTest< elem_type >::meshes_equal_enough(), libMesh::PeriodicBoundaries::neighbor(), libMesh::RBEIMEvaluation::node_distribute_bfs(), OverlappingCouplingFunctor::operator()(), AugmentSparsityOnInterface::operator()(), AugmentSparsityOnNodes::operator()(), libMesh::GhostPointNeighbors::operator()(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SortAndCopy::operator()(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectVertices::operator()(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectEdges::operator()(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectSides::operator()(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectInteriors::operator()(), libMesh::CompareDofObjectsByPIDAndThenID::operator()(), libMesh::DistributedMesh::own_node(), libMesh::XdrIO::pack_element(), libMesh::LinearPartitioner::partition_range(), libMesh::SFCPartitioner::partition_range(), libMesh::CentroidPartitioner::partition_range(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::Polygon::Polygon(), libMesh::Polyhedron::Polyhedron(), libMesh::DofMap::process_mesh_constraint_rows(), libMesh::DofObject::processor_id(), libMesh::CheckpointIO::read_connectivity(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::DistributedMesh::renumber_nodes_and_elements(), libMesh::DofMap::scatter_constraints(), libMesh::Partitioner::set_interface_node_processor_ids_BFS(), libMesh::Partitioner::set_interface_node_processor_ids_linear(), libMesh::Partitioner::set_interface_node_processor_ids_petscpartitioner(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Partitioner::set_parent_processor_ids(), ParsedFEMFunctionTest::setUp(), libMesh::Partitioner::single_partition_range(), libMesh::Parallel::sync_dofobject_data_by_id(), libMesh::Parallel::sync_element_data_by_parent_id(), libMesh::Parallel::sync_node_data_by_element_id_once(), DefaultCouplingTest::testCoupling(), PointNeighborCouplingTest::testCoupling(), DofObjectTest< Node >::testInvalidateProcId(), EquationSystemsTest::testPostInitAddElem(), DofObjectTest< Node >::testSetProcId(), BoundaryInfoTest::testShellFaceConstraints(), DofObjectTest< Node >::testValidProcId(), libMesh::DTKAdapter::update_variable_values(), NonManifoldGhostingFunctorTest::verify_send_list_entries_helper(), libMesh::GmshIO::write_mesh(), and libMesh::Nemesis_IO_Helper::write_sidesets().

906 {
907  return _processor_id;
908 }
processor_id_type _processor_id
The processor_id of the DofObject.
Definition: dof_object.h:594

◆ processor_id() [2/3]

processor_id_type & libMesh::DofObject::processor_id ( )
inlineinherited
Returns
The processor that this DofObject belongs to as a writable reference.

Definition at line 913 of file dof_object.h.

References libMesh::DofObject::_processor_id.

914 {
915  return _processor_id;
916 }
processor_id_type _processor_id
The processor_id of the DofObject.
Definition: dof_object.h:594

◆ processor_id() [3/3]

void libMesh::DofObject::processor_id ( const processor_id_type  pid)
inlineinherited

Sets the processor_id for this DofObject.

Definition at line 921 of file dof_object.h.

References libMesh::DofObject::processor_id().

922 {
923  this->processor_id() = pid;
924 }
processor_id_type processor_id() const
Definition: dof_object.h:905

◆ qual_bounds()

virtual std::pair<Real,Real> libMesh::Elem::qual_bounds ( const ElemQuality  ) const
inlinevirtualinherited
Returns
The suggested quality bounds for the Elem based on quality measure q.

These are the values suggested by the CUBIT User's Manual. Since this function can have no possible meaning for an abstract Elem, it is an error in the base class.

Reimplemented in libMesh::InfQuad, libMesh::Polyhedron, libMesh::InfHex, libMesh::Quad, libMesh::Tri, libMesh::Polygon, libMesh::Hex, and libMesh::Tet.

Definition at line 1121 of file elem.h.

Referenced by main().

1122  { libmesh_not_implemented(); return std::make_pair(0.,0.); }

◆ quality()

Real libMesh::Elem::quality ( const ElemQuality  q) const
virtualinherited
Returns
A quantitative assessment of element quality based on the quality metric q specified by the user. Not all ElemQuality metrics are supported for all Elem types; consult the Elem::quality() overrides for specific Elem types to determine which quality metrics are supported. The ElemQuality metrics with generic support for all Elems with dimension > 1 are: .) EDGE_LENGTH_RATIO - ratio of maximum to minimum edge (in 2D, side) length, where the min/max is taken over all Elem edges. .) MIN,MAX_ANGLE - The minimum (respectively maximum) angle between all pairs of adjacent Elem edges, in degrees. Note that, in 3D, these are not the dihedral angles (angle between adjacent planar faces of the element), which we plan to add support for in the future. In 2D, we compute the angle between adjacent sides for this metric.

Reimplemented in libMesh::InfQuad, libMesh::InfHex, libMesh::Quad, libMesh::Tri, libMesh::Hex, and libMesh::Tet.

Definition at line 1772 of file elem.C.

References libMesh::cross_norm(), libMesh::Elem::dim(), libMesh::Elem::edge_index_range(), libMesh::EDGE_LENGTH_RATIO, libMesh::Elem::edges_adjacent_to_node(), libMesh::Utility::enum_to_string(), libMesh::err, libMesh::index_range(), libMesh::JACOBIAN, libMesh::Elem::local_edge_node(), libMesh::make_range(), libMesh::MAX_ANGLE, libMesh::MAX_DIHEDRAL_ANGLE, libMesh::MIN_ANGLE, libMesh::MIN_DIHEDRAL_ANGLE, libMesh::Elem::n_edges(), libMesh::Elem::node_index_range(), libMesh::Elem::nodes_on_side(), libMesh::TensorTools::norm(), libMesh::pi, libMesh::Elem::point(), libMesh::Real, libMesh::SCALED_JACOBIAN, libMesh::Elem::sides_on_edge(), libMesh::triple_product(), libMesh::Elem::type(), and libMesh::TypeVector< T >::unit().

Referenced by libMesh::Tet::quality(), libMesh::Hex::quality(), libMesh::Tri::quality(), libMesh::Quad::quality(), libMesh::InfHex::quality(), and libMesh::InfQuad::quality().

1773 {
1774  switch (q)
1775  {
1776  // Return the maximum ratio of edge lengths, or zero if that
1777  // maximum would otherwise be infinity.
1778  case EDGE_LENGTH_RATIO:
1779  {
1780  if (this->dim() < 2)
1781  return 1;
1782 
1783  std::vector<Real> edge_lengths(this->n_edges());
1784  for (auto e : index_range(edge_lengths))
1785  edge_lengths[e] = (this->point(this->local_edge_node(e,1)) -
1786  this->point(this->local_edge_node(e,0))).norm();
1787 
1788  auto [min, max] =
1789  std::minmax_element(edge_lengths.begin(), edge_lengths.end());
1790 
1791  if (*min == 0.)
1792  return 0.;
1793  else
1794  return *max / *min;
1795  }
1796 
1797  case MIN_ANGLE:
1798  case MAX_ANGLE:
1799  {
1800  // 1D elements don't have interior angles, so just return some
1801  // dummy value in that case.
1802  if (this->dim() < 2)
1803  return 0.;
1804 
1805  // Initialize return values
1806  Real min_angle = std::numeric_limits<Real>::max();
1807  Real max_angle = -std::numeric_limits<Real>::max();
1808 
1809  for (auto n : this->node_index_range())
1810  {
1811  // Get list of edge ids adjacent to this node.
1812  const auto adjacent_edge_ids = this->edges_adjacent_to_node(n);
1813 
1814  // Skip any nodes with fewer than 2 adjacent edges. You
1815  // need at least two adjacent edges to form an interior
1816  // element angle.
1817  auto N = adjacent_edge_ids.size();
1818  if (N < 2)
1819  continue;
1820 
1821  // Consider all possible pairs of edges adjacent to node n
1822  for (unsigned int first = 0; first < N-1; ++first)
1823  for (unsigned int second = first+1; second < N; ++second)
1824  {
1825  // Get ids of first and second edges
1826  auto first_edge = adjacent_edge_ids[first];
1827  auto second_edge = adjacent_edge_ids[second];
1828 
1829  // Get node ids of first and second edge
1830  auto first_edge_node_0 = this->local_edge_node(first_edge, 0);
1831  auto first_edge_node_1 = this->local_edge_node(first_edge, 1);
1832  auto second_edge_node_0 = this->local_edge_node(second_edge, 0);
1833  auto second_edge_node_1 = this->local_edge_node(second_edge, 1);
1834 
1835  // Orient both edges so that edge node 0 == n
1836  if (first_edge_node_0 != n)
1837  std::swap(first_edge_node_0, first_edge_node_1);
1838  if (second_edge_node_0 != n)
1839  std::swap(second_edge_node_0, second_edge_node_1);
1840 
1841  libmesh_assert_equal_to(first_edge_node_0, n);
1842  libmesh_assert_equal_to(second_edge_node_0, n);
1843 
1844  // Locally oriented edge vectors
1845  Point
1846  first_ev = this->point(first_edge_node_1) - this->point(first_edge_node_0),
1847  second_ev = this->point(second_edge_node_1) - this->point(second_edge_node_0);
1848 
1849  // Angle between them in the range [0, pi]
1850  Real theta = std::acos(first_ev.unit() * second_ev.unit());
1851 
1852  // Track min and max angles seen
1853  min_angle = std::min(theta, min_angle);
1854  max_angle = std::max(theta, max_angle);
1855  }
1856  }
1857 
1858  // Return requested extreme value (in degrees)
1859  return Real(180)/libMesh::pi * ((q == MIN_ANGLE) ? min_angle : max_angle);
1860  }
1861 
1862  case MIN_DIHEDRAL_ANGLE:
1863  case MAX_DIHEDRAL_ANGLE:
1864  {
1865  // For 1D and 2D elements, just call this function with MIN,MAX_ANGLE instead.
1866  if (this->dim() < 3)
1867  return this->quality((q == MIN_DIHEDRAL_ANGLE) ? MIN_ANGLE : MAX_ANGLE);
1868 
1869  // Initialize return values
1870  Real min_angle = std::numeric_limits<Real>::max();
1871  Real max_angle = -std::numeric_limits<Real>::max();
1872 
1873  // Algorithm for computing dihedral angles:
1874  // .) Loop over the edges, use the edge_sides_map to get the
1875  // two sides adjacent to the edge.
1876  // .) For each adjacent side, use the side_nodes_map to get the
1877  // list of three (or more) node ids on that side.
1878  // .) Use the node ids to compute the (approximate) inward
1879  // normal for the side. Note: this is approximate since 3D
1880  // elements with four-sided faces and quadratic tetrahedra
1881  // do not necessarily have planar faces.
1882  // .) Compute the dihedral angle for the current edge, compare
1883  // it to the current min and max dihedral angles.
1884  for (auto e : this->edge_index_range())
1885  {
1886  // Get list of edge ids adjacent to this node.
1887  const auto adjacent_side_ids = this->sides_on_edge(e);
1888 
1889  // All 3D elements should have exactly two sides adjacent to each edge.
1890  libmesh_assert_equal_to(adjacent_side_ids.size(), 2);
1891 
1892  // Get lists of node ids on each side
1893  const auto side_0_node_ids = this->nodes_on_side(adjacent_side_ids[0]);
1894  const auto side_1_node_ids = this->nodes_on_side(adjacent_side_ids[1]);
1895 
1896  // All 3D elements have at least three nodes on each side
1897  libmesh_assert_greater_equal(side_0_node_ids.size(), 3);
1898  libmesh_assert_greater_equal(side_1_node_ids.size(), 3);
1899 
1900  // Construct (approximate) inward normal on each adjacent side
1901  const auto side_0_normal =
1902  (this->point(side_0_node_ids[2]) - this->point(side_0_node_ids[0])).cross
1903  (this->point(side_0_node_ids[1]) - this->point(side_0_node_ids[0])).unit();
1904  const auto side_1_normal =
1905  (this->point(side_1_node_ids[2]) - this->point(side_1_node_ids[0])).cross
1906  (this->point(side_1_node_ids[1]) - this->point(side_1_node_ids[0])).unit();
1907 
1908  // Compute dihedral angle between the planes.
1909  // Using the absolute value ensures that we get the same result
1910  // even if the orientation of one of the planes is flipped, i.e.
1911  // it always gives us a value in the range [0, pi/2].
1912  // https://en.wikipedia.org/wiki/Dihedral_angle
1913  Real theta = std::acos(std::abs(side_0_normal * side_1_normal));
1914 
1915  // Track min and max angles seen
1916  min_angle = std::min(theta, min_angle);
1917  max_angle = std::max(theta, max_angle);
1918  }
1919 
1920  // Return requested extreme value (in degrees)
1921  return Real(180)/libMesh::pi * ((q == MIN_DIHEDRAL_ANGLE) ? min_angle : max_angle);
1922  }
1923 
1924  case JACOBIAN:
1925  case SCALED_JACOBIAN:
1926  {
1927  // 1D elements don't have interior corners, so this metric
1928  // does not really apply to them.
1929  const auto N = this->dim();
1930  if (N < 2)
1931  return 1.;
1932 
1933  // Initialize return value
1934  Real min_node_area = std::numeric_limits<Real>::max();
1935 
1936  for (auto n : this->node_index_range())
1937  {
1938  // Get list of edge ids adjacent to this node.
1939  auto adjacent_edge_ids = this->edges_adjacent_to_node(n);
1940 
1941  // Skip any nodes that don't have dim() adjacent edges. In 2D,
1942  // you need at least two adjacent edges to compute the cross
1943  // product, and in 3D, you need at least three adjacent edges
1944  // to compute the scalar triple product. The only element
1945  // type which has an unusual topology in this regard is the
1946  // Pyramid element in 3D, where 4 edges meet at the apex node.
1947  // For now, we just skip this node when computing the JACOBIAN
1948  // metric for Pyramids.
1949  if (adjacent_edge_ids.size() != N)
1950  continue;
1951 
1952  // Construct oriented edges
1953  std::vector<Point> oriented_edges(N);
1954  for (auto i : make_range(N))
1955  {
1956  auto node_0 = this->local_edge_node(adjacent_edge_ids[i], 0);
1957  auto node_1 = this->local_edge_node(adjacent_edge_ids[i], 1);
1958  if (node_0 != n)
1959  std::swap(node_0, node_1);
1960  oriented_edges[i] = this->point(node_1) - this->point(node_0);
1961  }
1962 
1963  // Compute unscaled area (2D) or volume (3D) using the
1964  // cross product (2D) or scalar triple product (3D) of the
1965  // oriented edges. We take the absolute value so that we
1966  // don't have to worry about the sign of the area.
1967  Real node_area = (N == 2) ?
1968  cross_norm(oriented_edges[0], oriented_edges[1]) :
1969  std::abs(triple_product(oriented_edges[0], oriented_edges[1], oriented_edges[2]));
1970 
1971  // Divide by (non-zero) edge lengths if computing scaled Jacobian.
1972  // If any length is zero, then set node_area to zero. This means that
1973  // e.g. degenerate quadrilaterals will have a zero SCALED_JACOBIAN metric.
1974  if (q == SCALED_JACOBIAN)
1975  for (auto i : make_range(N))
1976  {
1977  Real len_i = oriented_edges[i].norm();
1978  node_area = (len_i == 0.) ? 0. : (node_area / len_i);
1979  }
1980 
1981  // Update minimum
1982  min_node_area = std::min(node_area, min_node_area);
1983  }
1984 
1985  return min_node_area;
1986  }
1987 
1988  // Return 1 if we made it here
1989  default:
1990  {
1991  libmesh_do_once( libmesh_here();
1992 
1993  libMesh::err << "ERROR: quality metric "
1995  << " not implemented on element type "
1996  << Utility::enum_to_string(this->type())
1997  << std::endl
1998  << "Returning 1."
1999  << std::endl; );
2000 
2001  return 1.;
2002  }
2003  }
2004 }
OStreamProxy err
virtual std::vector< unsigned int > sides_on_edge(const unsigned int) const =0
T cross_norm(const TypeVector< T > &b, const TypeVector< T > &c)
Calls cross_norm_sq() and takes the square root of the result.
Definition: type_vector.h:1096
IntRange< unsigned short > edge_index_range() const
Definition: elem.h:2693
T triple_product(const TypeVector< T > &a, const TypeVector< T > &b, const TypeVector< T > &c)
Definition: type_vector.h:1029
virtual std::vector< unsigned int > edges_adjacent_to_node(const unsigned int) const =0
virtual unsigned int local_edge_node(unsigned int edge, unsigned int edge_node) const =0
Similar to Elem::local_side_node(), but instead of a side id, takes an edge id and a node id on that ...
virtual unsigned int n_edges() const =0
auto norm(const T &a) -> decltype(std::abs(a))
Definition: tensor_tools.h:74
std::string enum_to_string(const T e)
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
virtual unsigned short dim() const =0
virtual Real quality(const ElemQuality q) const
Definition: elem.C:1772
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140
IntRange< unsigned short > node_index_range() const
Definition: elem.h:2684
virtual ElemType type() const =0
const Point & point(const unsigned int i) const
Definition: elem.h:2454
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:117
virtual std::vector< unsigned int > nodes_on_side(const unsigned int) const =0
const Real pi
.
Definition: libmesh.h:299

◆ quasicircumcenter()

virtual Point libMesh::Elem::quasicircumcenter ( ) const
inlinevirtualinherited
Returns
The "circumcenter of mass" (area-weighted average of triangulation circumcenters) of the element.

Not implemented for infinite elements, not currently implemented for 3D elements, currently ignores curvature of element edges.

Reimplemented in libMesh::NodeElem, libMesh::Edge, and libMesh::Face.

Definition at line 1061 of file elem.h.

Referenced by libMesh::Poly2TriTriangulator::insert_refinement_points().

1062  { libmesh_not_implemented(); }

◆ raw_child_ptr()

const Elem * libMesh::Elem::raw_child_ptr ( unsigned int  i) const
inlineinherited
Returns
A constant pointer to the \( i^{th} \) child for this element. For internal use only - skips assertions about null pointers.

Definition at line 3155 of file elem.h.

References libMesh::Elem::_children.

Referenced by libMesh::BoundaryInfo::add_elements(), and libMesh::CheckpointIO::read_remote_elem().

3156 {
3157  if (!_children)
3158  return nullptr;
3159 
3160  return _children[i];
3161 }
std::unique_ptr< Elem *[]> _children
unique_ptr to array of this element&#39;s children.
Definition: elem.h:2262

◆ reference_elem()

const Elem * libMesh::Elem::reference_elem ( ) const
inherited
Returns
A pointer to the "reference element" associated with this element. The reference element is the image of this element in reference parametric space. Importantly, it is not an actual element in the mesh, but rather a Singleton-type object, so for example all Quad4 elements share the same reference_elem().

If the element is of a type that can admit multiple topologies, such as a Polygon subtype, then there is no reference element; for such types this method should not be used.

Definition at line 568 of file elem.C.

References libMesh::ReferenceElem::get(), and libMesh::Elem::type().

Referenced by libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors(), libMesh::VariationalSmootherSystem::get_target_to_reference_jacobian(), libMesh::QComposite< QSubCell >::init(), and libMesh::RBParametrizedFunction::preevaluate_parametrized_function_on_mesh().

569 {
570  return &(ReferenceElem::get(this->type()));
571 }
virtual ElemType type() const =0
const Elem & get(const ElemType type_in)

◆ refine()

void libMesh::Elem::refine ( MeshRefinement mesh_refinement)
virtualinherited

Refine the element.

Definition at line 87 of file elem_refinement.C.

References libMesh::Elem::_children, libMesh::Elem::active(), libMesh::MeshRefinement::add_elem(), libMesh::MeshRefinement::add_node(), libMesh::Elem::ancestor(), libMesh::Elem::build(), libMesh::Elem::child_ptr(), libMesh::Elem::INACTIVE, libMesh::Elem::JUST_REFINED, libMesh::libmesh_assert(), libMesh::Elem::n_children(), libMesh::DofObject::n_extra_integers(), libMesh::DofObject::n_systems(), libMesh::Elem::p_level(), libMesh::Elem::p_refinement_flag(), libMesh::Elem::parent(), libMesh::Elem::REFINE, libMesh::Elem::refinement_flag(), libMesh::remote_elem, libMesh::DofObject::set_extra_integer(), libMesh::DofObject::set_n_systems(), libMesh::Elem::set_p_level(), libMesh::Elem::set_p_refinement_flag(), libMesh::Elem::set_refinement_flag(), libMesh::Elem::subactive(), and libMesh::Elem::type().

88 {
89  libmesh_assert_equal_to (this->refinement_flag(), Elem::REFINE);
90  libmesh_assert (this->active());
91 
92  const unsigned int nc = this->n_children();
93 
94  // Create my children if necessary
95  if (!_children)
96  {
97  _children = std::make_unique<Elem *[]>(nc);
98 
99  unsigned int parent_p_level = this->p_level();
100  const unsigned int nei = this->n_extra_integers();
101  for (unsigned int c = 0; c != nc; c++)
102  {
103  auto current_child = Elem::build(this->type(), this);
104  _children[c] = current_child.get();
105 
106  current_child->set_refinement_flag(Elem::JUST_REFINED);
107  current_child->set_p_level(parent_p_level);
108  current_child->set_p_refinement_flag(this->p_refinement_flag());
109 
110  for (auto cnode : current_child->node_index_range())
111  {
112  Node * node =
113  mesh_refinement.add_node(*this, c, cnode,
114  current_child->processor_id());
115  node->set_n_systems (this->n_systems());
116  current_child->set_node(cnode, node);
117  }
118 
119  Elem * added_child = mesh_refinement.add_elem (std::move(current_child));
120  added_child->set_n_systems(this->n_systems());
121  libmesh_assert_equal_to (added_child->n_extra_integers(),
122  this->n_extra_integers());
123  for (unsigned int i=0; i != nei; ++i)
124  added_child->set_extra_integer(i, this->get_extra_integer(i));
125  }
126  }
127  else
128  {
129  unsigned int parent_p_level = this->p_level();
130  for (unsigned int c = 0; c != nc; c++)
131  {
132  Elem * current_child = this->child_ptr(c);
133  if (current_child != remote_elem)
134  {
135  libmesh_assert(current_child->subactive());
136  current_child->set_refinement_flag(Elem::JUST_REFINED);
137  current_child->set_p_level(parent_p_level);
138  current_child->set_p_refinement_flag(this->p_refinement_flag());
139  }
140  }
141  }
142 
143  // Un-set my refinement flag now
145 
146  // Leave the p refinement flag set - we will need that later to get
147  // projection operations correct
148  // this->set_p_refinement_flag(Elem::INACTIVE);
149 
150 #ifndef NDEBUG
151  for (unsigned int c = 0; c != nc; c++)
152  if (this->child_ptr(c) != remote_elem)
153  {
154  libmesh_assert_equal_to (this->child_ptr(c)->parent(), this);
155  libmesh_assert(this->child_ptr(c)->active());
156  }
157 #endif
158  libmesh_assert (this->ancestor());
159 }
RefinementState refinement_flag() const
Definition: elem.h:3211
const Elem * parent() const
Definition: elem.h:3031
RefinementState p_refinement_flag() const
Definition: elem.h:3227
void set_refinement_flag(const RefinementState rflag)
Sets the value of the refinement flag for the element.
Definition: elem.h:3219
virtual unsigned int n_children() const =0
unsigned int p_level() const
Definition: elem.h:3109
bool ancestor() const
Definition: elem.C:2008
static std::unique_ptr< Elem > build(const ElemType type, Elem *p=nullptr)
Definition: elem.C:442
unsigned int n_systems() const
Definition: dof_object.h:937
libmesh_assert(ctx)
Elem(const unsigned int n_nodes, const unsigned int n_sides, Elem *parent, Elem **elemlinkdata, Node **nodelinkdata)
Constructor.
Definition: elem.h:2379
unsigned int n_extra_integers() const
Returns how many extra integers are associated to the DofObject.
Definition: dof_object.h:1170
bool active() const
Definition: elem.h:2942
virtual ElemType type() const =0
std::unique_ptr< Elem *[]> _children
unique_ptr to array of this element&#39;s children.
Definition: elem.h:2262
const Elem * child_ptr(unsigned int i) const
Definition: elem.h:3164
const RemoteElem * remote_elem
Definition: remote_elem.C:57

◆ refinement_flag()

Elem::RefinementState libMesh::Elem::refinement_flag ( ) const
inlineinherited
Returns
The value of the refinement flag for the element.

Definition at line 3211 of file elem.h.

References libMesh::Elem::_rflag.

Referenced by libMesh::Elem::active(), libMesh::BoundaryInfo::add_elements(), libMesh::OldSolutionBase< Output, point_output >::check_old_context(), libMesh::Elem::coarsen(), libMesh::Elem::contract(), libMesh::MeshRefinement::enforce_mismatch_limit_prior_to_refinement(), libMesh::OldSolutionCoefs< Output, point_output >::eval_at_node(), libMesh::OldSolutionValue< Output, point_output >::eval_at_node(), libMesh::OldSolutionCoefs< Output, point_output >::eval_old_dofs(), libMesh::OldSolutionValue< Output, point_output >::eval_old_dofs(), libMesh::Elem::get_info(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_flags(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshRefinement::make_flags_parallel_consistent(), libMesh::Elem::make_links_to_me_local(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectVertices::operator()(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectEdges::operator()(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectSides::operator()(), libMesh::Elem::refine(), EquationSystemsTest::testRefineThenReinitPreserveFlags(), libMesh::BoundaryInfo::transfer_boundary_ids_from_children(), and libMesh::MeshRefinement::uniformly_coarsen().

3212 {
3213  return static_cast<RefinementState>(_rflag);
3214 }
RefinementState
Enumeration of possible element refinement states.
Definition: elem.h:1453
unsigned char _rflag
h refinement flag.
Definition: elem.h:2275

◆ remove_links_to_me()

void libMesh::Elem::remove_links_to_me ( )
inherited

Resets this element's neighbors' appropriate neighbor pointers and its parent's and children's appropriate pointers to point to null instead of to this.

To be used before an element is deleted from a mesh.

Definition at line 1637 of file elem.C.

References libMesh::Elem::has_children(), libMesh::Elem::level(), libMesh::libmesh_assert(), libMesh::Elem::neighbor_ptr_range(), libMesh::Elem::parent(), libMesh::remote_elem, and libMesh::Elem::subactive().

Referenced by MeshDeletionsTest::testDeleteElem().

1638 {
1639  libmesh_assert_not_equal_to (this, remote_elem);
1640 
1641  // We need to have handled any children first
1642 #ifdef LIBMESH_ENABLE_AMR
1643  libmesh_assert (!this->has_children());
1644 #endif
1645 
1646  // Nullify any neighbor links
1647  for (auto neigh : this->neighbor_ptr_range())
1648  {
1649  if (neigh && neigh != remote_elem)
1650  {
1651  // My neighbor should never be more refined than me; my real
1652  // neighbor would have been its parent in that case.
1653  libmesh_assert_greater_equal (this->level(), neigh->level());
1654 
1655  if (this->level() == neigh->level() &&
1656  neigh->has_neighbor(this))
1657  {
1658 #ifdef LIBMESH_ENABLE_AMR
1659  // My neighbor may have descendants which also consider me a
1660  // neighbor
1661  std::vector<Elem *> family;
1662  neigh->total_family_tree_by_neighbor (family, this);
1663 
1664  for (auto & n : family)
1665  {
1666  libmesh_assert (n);
1667  if (n->is_remote())
1668  continue;
1669  unsigned int my_s = n->which_neighbor_am_i(this);
1670  libmesh_assert_less (my_s, n->n_neighbors());
1671  libmesh_assert_equal_to (n->neighbor_ptr(my_s), this);
1672  n->set_neighbor(my_s, nullptr);
1673  }
1674 #else
1675  unsigned int my_s = neigh->which_neighbor_am_i(this);
1676  libmesh_assert_less (my_s, neigh->n_neighbors());
1677  libmesh_assert_equal_to (neigh->neighbor_ptr(my_s), this);
1678  neigh->set_neighbor(my_s, nullptr);
1679 #endif
1680  }
1681 #ifdef LIBMESH_ENABLE_AMR
1682  // Even if my neighbor doesn't link back to me, it might
1683  // have subactive descendants which do
1684  else if (neigh->has_children())
1685  {
1686  // If my neighbor at the same level doesn't have me as a
1687  // neighbor, I must be subactive
1688  libmesh_assert(this->level() > neigh->level() ||
1689  this->subactive());
1690 
1691  // My neighbor must have some ancestor of mine as a
1692  // neighbor
1693  Elem * my_ancestor = this->parent();
1694  libmesh_assert(my_ancestor);
1695  while (!neigh->has_neighbor(my_ancestor))
1696  {
1697  my_ancestor = my_ancestor->parent();
1698  libmesh_assert(my_ancestor);
1699  }
1700 
1701  // My neighbor may have descendants which consider me a
1702  // neighbor
1703  std::vector<Elem *> family;
1704  neigh->total_family_tree_by_subneighbor (family, my_ancestor, this);
1705 
1706  for (auto & n : family)
1707  {
1708  libmesh_assert (n);
1709  if (n->is_remote())
1710  continue;
1711  unsigned int my_s = n->which_neighbor_am_i(this);
1712  libmesh_assert_less (my_s, n->n_neighbors());
1713  libmesh_assert_equal_to (n->neighbor_ptr(my_s), this);
1714  n->set_neighbor(my_s, nullptr);
1715  }
1716  }
1717 #endif
1718  }
1719  }
1720 
1721 #ifdef LIBMESH_ENABLE_AMR
1722  // We can't currently delete a child with a parent!
1723  libmesh_assert (!this->parent());
1724 #endif
1725 }
const Elem * parent() const
Definition: elem.h:3031
libmesh_assert(ctx)
Elem(const unsigned int n_nodes, const unsigned int n_sides, Elem *parent, Elem **elemlinkdata, Node **nodelinkdata)
Constructor.
Definition: elem.h:2379
unsigned int level() const
Definition: elem.h:3075
bool subactive() const
Definition: elem.h:2960
SimpleRange< NeighborPtrIter > neighbor_ptr_range()
Returns a range with all neighbors of an element, usable in range-based for loops.
Definition: elem.h:3504
bool has_children() const
Definition: elem.h:2980
const RemoteElem * remote_elem
Definition: remote_elem.C:57

◆ replace_child()

void libMesh::Elem::replace_child ( Elem elem,
unsigned int  c 
)
inherited

Replaces the child pointer at the specified index in the child array.

Definition at line 2088 of file elem.C.

References libMesh::Elem::child_ptr(), libMesh::Elem::has_children(), libMesh::libmesh_assert(), and libMesh::Elem::set_child().

Referenced by libMesh::UnstructuredMesh::all_first_order().

2089 {
2090  libmesh_assert(this->has_children());
2091 
2092  libmesh_assert(this->child_ptr(c));
2093 
2094  this->set_child(c, elem);
2095 }
libmesh_assert(ctx)
void set_child(unsigned int c, Elem *elem)
Sets the pointer to the child for this element.
Definition: elem.h:3183
bool has_children() const
Definition: elem.h:2980
const Elem * child_ptr(unsigned int i) const
Definition: elem.h:3164

◆ runtime_topology()

virtual bool libMesh::Elem::runtime_topology ( ) const
inlinevirtualinherited
Returns
true iff this element type can vary in topology (e.g. have different numbers of sides and/or nodes) at runtime. For such general polygons or polyhedra, APIs which assume a fixed topology are not safe to use.

Reimplemented in libMesh::Polyhedron, and libMesh::Polygon.

Definition at line 254 of file elem.h.

Referenced by libMesh::FE< Dim, LAGRANGE_VEC >::edge_map(), libMesh::FE< Dim, LAGRANGE_VEC >::edge_reinit(), libMesh::Elem::Elem(), libMesh::QBase::init(), libMesh::FE< Dim, LAGRANGE_VEC >::reinit(), and libMesh::FE< Dim, LAGRANGE_VEC >::side_map().

254 { return false; }

◆ second_order_adjacent_vertex()

unsigned short int libMesh::Elem::second_order_adjacent_vertex ( const unsigned int  n,
const unsigned int  v 
) const
virtualinherited
Returns
The element-local number of the \( v^{th} \) vertex that defines the \( n^{th} \) second-order node, or 0 for linear elements.
Note
The value is always less than this->n_vertices(), while n has to be greater than or equal to this->n_vertices().

Reimplemented in libMesh::Prism21, libMesh::Pyramid18, libMesh::Prism20, libMesh::Prism18, libMesh::Pyramid14, libMesh::Hex27, libMesh::Tet14, libMesh::Prism15, libMesh::InfHex18, libMesh::Pyramid13, libMesh::Tet10, libMesh::Hex20, libMesh::Tri7, libMesh::InfHex16, libMesh::Tri6, libMesh::Quad9, libMesh::InfPrism12, libMesh::Quad8, libMesh::InfQuad6, libMesh::Edge4, and libMesh::Edge3.

Definition at line 3052 of file elem.C.

Referenced by libMesh::MeshTools::Modification::smooth().

3054 {
3055  // for linear elements, always return 0
3056  return 0;
3057 }

◆ second_order_child_vertex()

std::pair< unsigned short int, unsigned short int > libMesh::Elem::second_order_child_vertex ( const unsigned int  n) const
virtualinherited
Returns
A pair (c,v), where c == child index, and v == element-local index of the \( n^{th} \) second-order node on the parent element. For linear elements, (0,0) is returned.
Note
The return values are always less than this->n_children() and this->child_ptr(c)->n_vertices().
n has to be greater than or equal to this->n_vertices().
On refined second-order elements, the return value will satisfy this->node_ptr(n) == this->child_ptr(c)->node_ptr(v).

Reimplemented in libMesh::Prism21, libMesh::Prism20, libMesh::Prism18, libMesh::Hex27, libMesh::Tet14, libMesh::Prism15, libMesh::InfHex18, libMesh::Tet10, libMesh::Hex20, libMesh::Tri7, libMesh::InfHex16, libMesh::Tri6, libMesh::Quad9, libMesh::InfPrism12, libMesh::Quad8, libMesh::C0Polygon, libMesh::InfQuad6, libMesh::Edge3, and libMesh::C0Polyhedron.

Definition at line 3062 of file elem.C.

3063 {
3064  // for linear elements, always return 0
3065  return std::pair<unsigned short int, unsigned short int>(0,0);
3066 }

◆ second_order_equivalent_type()

ElemType libMesh::Elem::second_order_equivalent_type ( const ElemType  et,
const bool  full_ordered = true 
)
staticinherited
Returns
The ElemType of the associated second-order element (which will be the same as the input if the input is already a second-order ElemType) or INVALID_ELEM for elements that cannot be converted into higher order equivalents.

For example, when this is a TET4, then TET10 is returned.

For some elements, there exist two second-order equivalents, e.g. for Quad4 there is Quad8 and Quad9. When the optional full_ordered is true, then QUAD9 is returned. When full_ordered is false, then QUAD8 is returned.

Definition at line 3139 of file elem.C.

References libMesh::EDGE2, libMesh::EDGE3, libMesh::EDGE4, libMesh::Utility::enum_to_string(), libMesh::HEX20, libMesh::HEX27, libMesh::HEX8, libMesh::INFEDGE2, libMesh::INFHEX16, libMesh::INFHEX18, libMesh::INFHEX8, libMesh::INFPRISM12, libMesh::INFPRISM6, libMesh::INFQUAD4, libMesh::INFQUAD6, libMesh::NODEELEM, libMesh::PRISM15, libMesh::PRISM18, libMesh::PRISM20, libMesh::PRISM21, libMesh::PRISM6, libMesh::PYRAMID13, libMesh::PYRAMID14, libMesh::PYRAMID18, libMesh::PYRAMID5, libMesh::QUAD4, libMesh::QUAD8, libMesh::QUAD9, libMesh::QUADSHELL4, libMesh::QUADSHELL8, libMesh::QUADSHELL9, libMesh::TET10, libMesh::TET14, libMesh::TET4, libMesh::TRI3, libMesh::TRI6, libMesh::TRI7, and libMesh::TRISHELL3.

Referenced by libMesh::UnstructuredMesh::all_second_order_range(), libMesh::Elem::bracketing_nodes(), and libMesh::Elem::parent_bracketing_nodes().

3141 {
3142  switch (et)
3143  {
3144  case NODEELEM:
3145  return NODEELEM;
3146  case EDGE2:
3147  case EDGE3:
3148  {
3149  // full_ordered not relevant
3150  return EDGE3;
3151  }
3152 
3153  case EDGE4:
3154  {
3155  // full_ordered not relevant
3156  return EDGE4;
3157  }
3158 
3159  case TRI3:
3160  case TRI6:
3161  {
3162  // full_ordered not relevant
3163  return TRI6;
3164  }
3165 
3166  case TRI7:
3167  return TRI7;
3168 
3169  // Currently there is no TRISHELL6, so similarly to other types
3170  // where this is the case, we just return the input.
3171  case TRISHELL3:
3172  return TRISHELL3;
3173 
3174  case QUAD4:
3175  case QUAD8:
3176  {
3177  if (full_ordered)
3178  return QUAD9;
3179  else
3180  return QUAD8;
3181  }
3182 
3183  case QUADSHELL4:
3184  case QUADSHELL8:
3185  {
3186  if (full_ordered)
3187  return QUADSHELL9;
3188  else
3189  return QUADSHELL8;
3190  }
3191 
3192  case QUAD9:
3193  {
3194  // full_ordered not relevant
3195  return QUAD9;
3196  }
3197 
3198  case QUADSHELL9:
3199  {
3200  // full_ordered not relevant
3201  return QUADSHELL9;
3202  }
3203 
3204  case TET4:
3205  case TET10:
3206  {
3207  // full_ordered not relevant
3208  return TET10;
3209  }
3210 
3211  case TET14:
3212  return TET14;
3213 
3214  case HEX8:
3215  case HEX20:
3216  {
3217  // see below how this correlates with INFHEX8
3218  if (full_ordered)
3219  return HEX27;
3220  else
3221  return HEX20;
3222  }
3223 
3224  case HEX27:
3225  {
3226  // full_ordered not relevant
3227  return HEX27;
3228  }
3229 
3230  case PRISM6:
3231  case PRISM15:
3232  {
3233  if (full_ordered)
3234  return PRISM18;
3235  else
3236  return PRISM15;
3237  }
3238 
3239  // full_ordered not relevant, already fully second order
3240  case PRISM18:
3241  return PRISM18;
3242  case PRISM20:
3243  return PRISM20;
3244  case PRISM21:
3245  return PRISM21;
3246  case PYRAMID18:
3247  return PYRAMID18;
3248 
3249  case PYRAMID5:
3250  case PYRAMID13:
3251  {
3252  if (full_ordered)
3253  return PYRAMID14;
3254  else
3255  return PYRAMID13;
3256  }
3257 
3258  case PYRAMID14:
3259  {
3260  // full_ordered not relevant
3261  return PYRAMID14;
3262  }
3263 
3264 
3265 
3266 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
3267 
3268  // infinite elements
3269  case INFEDGE2:
3270  {
3271  return INFEDGE2;
3272  }
3273 
3274  case INFQUAD4:
3275  case INFQUAD6:
3276  {
3277  // full_ordered not relevant
3278  return INFQUAD6;
3279  }
3280 
3281  case INFHEX8:
3282  case INFHEX16:
3283  {
3284  /*
3285  * Note that this matches with \p Hex8:
3286  * For full-ordered, \p InfHex18 and \p Hex27
3287  * belong together, and for not full-ordered,
3288  * \p InfHex16 and \p Hex20 belong together.
3289  */
3290  if (full_ordered)
3291  return INFHEX18;
3292  else
3293  return INFHEX16;
3294  }
3295 
3296  case INFHEX18:
3297  {
3298  // full_ordered not relevant
3299  return INFHEX18;
3300  }
3301 
3302  case INFPRISM6:
3303  case INFPRISM12:
3304  {
3305  // full_ordered not relevant
3306  return INFPRISM12;
3307  }
3308 
3309 #endif
3310 
3311 
3312  default:
3313  {
3314  // what did we miss?
3315  libmesh_error_msg("No second order equivalent element type for et = "
3316  << Utility::enum_to_string(et));
3317  }
3318  }
3319 }
std::string enum_to_string(const T e)

◆ set_buffer()

void libMesh::DofObject::set_buffer ( const std::vector< dof_id_type > &  buf)
inlineinherited

Definition at line 717 of file dof_object.h.

References libMesh::DofObject::_idx_buf.

Referenced by DofObjectTest< Node >::testJensEftangBug().

718  { _idx_buf = buf; }
index_buffer_t _idx_buf
Definition: dof_object.h:680

◆ set_dof_number()

void libMesh::DofObject::set_dof_number ( const unsigned int  s,
const unsigned int  var,
const unsigned int  comp,
const dof_id_type  dn 
)
inherited

Sets the global degree of freedom number for variable var, component comp for system s associated with this DofObject.

Definition at line 446 of file dof_object.C.

References libMesh::DofObject::_idx_buf, libMesh::DofObject::dof_number(), libMesh::DofObject::invalid_id, libMesh::libmesh_assert(), libMesh::DofObject::n_comp(), libMesh::DofObject::n_comp_group(), libMesh::DofObject::n_systems(), libMesh::DofObject::n_vars(), libMesh::DofObject::start_idx(), libMesh::DofObject::system_var_to_vg_var(), and libMesh::DofObject::var_to_vg().

450 {
451  libmesh_assert_less (s, this->n_systems());
452  libmesh_assert_less (var, this->n_vars(s));
453  libmesh_assert_less (comp, this->n_comp(s,var));
454 
455  const unsigned int
456  vg = this->var_to_vg(s,var),
457 #ifndef NDEBUG
458  ncg = this->n_comp_group(s,vg),
459 #endif
460  vig = this->system_var_to_vg_var(s,vg,var),
461  start_idx_sys = this->start_idx(s);
462 
463  libmesh_assert_less ((start_idx_sys + 2*vg + 1), _idx_buf.size());
464 
465  dof_id_type & base_idx = _idx_buf[start_idx_sys + 2*vg + 1];
466 
467  // We intend to change all dof numbers together or not at all
468  if (comp || vig)
469  libmesh_assert ((dn == invalid_id && base_idx == invalid_id) ||
470  (dn == base_idx + vig*ncg + comp));
471 
472  // only explicitly store the base index for vig==0, comp==0
473  else
474  base_idx = dn;
475 
476  libmesh_assert_equal_to (this->dof_number(s, var, comp), dn);
477 }
unsigned int system_var_to_vg_var(const unsigned int s, const unsigned int vg, const unsigned int var) const
Utility function - for variable var in system s, figure out what variable group it lives in...
Definition: dof_object.h:1359
dof_id_type dof_number(const unsigned int s, const unsigned int var, const unsigned int comp) const
Definition: dof_object.h:1032
unsigned int n_comp(const unsigned int s, const unsigned int var) const
Definition: dof_object.h:1002
unsigned int var_to_vg(const unsigned int s, const unsigned int var) const
Utility function - for variable var in system s, figure out what variable group it lives in...
Definition: dof_object.h:1341
static constexpr dof_id_type invalid_id
An invalid id to distinguish an uninitialized DofObject.
Definition: dof_object.h:482
unsigned int n_vars(const unsigned int s, const unsigned int vg) const
Definition: dof_object.h:967
unsigned int n_systems() const
Definition: dof_object.h:937
libmesh_assert(ctx)
unsigned int start_idx(const unsigned int s) const
The starting index for system s.
Definition: dof_object.h:1249
index_buffer_t _idx_buf
Definition: dof_object.h:680
unsigned int n_comp_group(const unsigned int s, const unsigned int vg) const
Definition: dof_object.h:1015
uint8_t dof_id_type
Definition: id_types.h:67

◆ set_extra_datum()

template<typename T >
void libMesh::DofObject::set_extra_datum ( const unsigned int  index,
const T  value 
)
inlineinherited

Sets the value on this object of the extra datum associated with index, which should have been obtained via a call to MeshBase::add_elem_datum or MeshBase::add_node_datum using the same type T.

Definition at line 1126 of file dof_object.h.

References libMesh::DofObject::_idx_buf, libMesh::DofObject::n_extra_integers(), libMesh::DofObject::n_pseudo_systems(), libMesh::DofObject::start_idx_ints(), and value.

Referenced by libMesh::ExodusII_IO::read(), libMesh::DynaIO::read_mesh(), and DofObjectTest< Node >::testAddExtraData().

1128 {
1129 #ifndef NDEBUG
1130  const unsigned int n_more_integers = (sizeof(T)-1)/sizeof(dof_id_type);
1131 #endif
1132  libmesh_assert_less(index+n_more_integers, this->n_extra_integers());
1133  libmesh_assert_less(this->n_pseudo_systems(), _idx_buf.size());
1134 
1135  const unsigned int start_idx_i = this->start_idx_ints();
1136 
1137  libmesh_assert_less(start_idx_i+index+n_more_integers, _idx_buf.size());
1138  std::memcpy(&_idx_buf[start_idx_i+index], &value, sizeof(T));
1139 }
unsigned int n_pseudo_systems() const
Definition: dof_object.h:947
unsigned int start_idx_ints() const
The starting index for an extra_integers pseudosystem.
Definition: dof_object.h:1273
static const bool value
Definition: xdr_io.C:55
unsigned int n_extra_integers() const
Returns how many extra integers are associated to the DofObject.
Definition: dof_object.h:1170
index_buffer_t _idx_buf
Definition: dof_object.h:680
uint8_t dof_id_type
Definition: id_types.h:67

◆ set_extra_integer()

void libMesh::DofObject::set_extra_integer ( const unsigned int  index,
const dof_id_type  value 
)
inlineinherited

Sets the value on this object of the extra integer associated with index, which should have been obtained via a call to MeshBase::add_elem_integer or MeshBase::add_node_integer.

Definition at line 1086 of file dof_object.h.

References libMesh::DofObject::_idx_buf, libMesh::DofObject::n_extra_integers(), libMesh::DofObject::n_pseudo_systems(), libMesh::DofObject::start_idx_ints(), and value.

Referenced by libMesh::SyncElementIntegers::act_on_data(), libMesh::BoundaryInfo::add_elements(), libMesh::UnstructuredMesh::all_first_order(), libMesh::UnstructuredMesh::create_submesh(), libMesh::ExodusII_IO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::CheckpointIO::read_nodes(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::Elem::refine(), DofObjectTest< Node >::testAddExtraData(), DofObjectTest< Node >::testAddSystemExtraInts(), DofObjectTest< Node >::testSetNSystemsExtraInts(), and DofObjectTest< Node >::testSetNVariableGroupsExtraInts().

1088 {
1089  libmesh_assert_less(index, this->n_extra_integers());
1090  libmesh_assert_less(this->n_pseudo_systems(), _idx_buf.size());
1091 
1092  const unsigned int start_idx_i = this->start_idx_ints();
1093 
1094  libmesh_assert_less(start_idx_i+index, _idx_buf.size());
1095  _idx_buf[start_idx_i+index] = value;
1096 }
unsigned int n_pseudo_systems() const
Definition: dof_object.h:947
unsigned int start_idx_ints() const
The starting index for an extra_integers pseudosystem.
Definition: dof_object.h:1273
static const bool value
Definition: xdr_io.C:55
unsigned int n_extra_integers() const
Returns how many extra integers are associated to the DofObject.
Definition: dof_object.h:1170
index_buffer_t _idx_buf
Definition: dof_object.h:680

◆ set_id() [1/2]

dof_id_type & libMesh::DofObject::set_id ( )
inlineinherited

◆ set_id() [2/2]

void libMesh::DofObject::set_id ( const dof_id_type  dofid)
inlineinherited

Sets the id for this DofObject.

Definition at line 201 of file dof_object.h.

References libMesh::DofObject::set_id().

202  { this->set_id() = dofid; }
dof_id_type & set_id()
Definition: dof_object.h:836

◆ set_interior_parent()

void libMesh::Elem::set_interior_parent ( Elem p)
inherited

Sets the pointer to the element's interior_parent.

Dangerous! Only use this if you know what you are doing!

Definition at line 1246 of file elem.C.

References libMesh::Elem::_elemlinks, libMesh::Elem::dim(), libMesh::libmesh_assert(), libMesh::Elem::n_sides(), and libMesh::remote_elem.

Referenced by libMesh::BoundaryInfo::add_elements(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::Edge::Edge(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::Hex::Hex(), libMesh::InfHex::InfHex(), libMesh::InfQuad::InfQuad(), libMesh::NodeElem::NodeElem(), libMesh::Polygon::Polygon(), libMesh::Polyhedron::Polyhedron(), libMesh::Prism::Prism(), libMesh::Pyramid::Pyramid(), libMesh::Quad::Quad(), libMesh::Tet::Tet(), libMesh::Tri::Tri(), and libMesh::MeshTetInterface::volume_to_surface_mesh().

1247 {
1248  // interior parents make no sense for full-dimensional elements.
1249  libmesh_assert (!p ||
1250  this->dim() < LIBMESH_DIM);
1251 
1252  // If we have an interior_parent, we USED TO assume it was a
1253  // one-higher-dimensional interior element, but we now allow e.g.
1254  // edge elements to have a 3D interior_parent with no
1255  // intermediate 2D element.
1256  // libmesh_assert (!p ||
1257  // p->dim() == (this->dim()+1));
1258  libmesh_assert (!p ||
1259  (p == remote_elem) ||
1260  (p->dim() > this->dim()));
1261 
1262  _elemlinks[1+this->n_sides()] = p;
1263 }
Elem ** _elemlinks
Pointers to this element&#39;s parent and neighbors, and for lower-dimensional elements&#39; interior_parent...
Definition: elem.h:2252
libmesh_assert(ctx)
virtual unsigned int n_sides() const =0
virtual unsigned short dim() const =0
const RemoteElem * remote_elem
Definition: remote_elem.C:57

◆ set_mapping_data()

void libMesh::Elem::set_mapping_data ( const unsigned char  data)
inlineinherited

Sets the value of the mapping data for the element.

Definition at line 3145 of file elem.h.

References libMesh::Elem::_map_data.

Referenced by libMesh::ReplicatedMesh::add_elem(), libMesh::DistributedMesh::add_elem(), libMesh::Elem::inherit_data_from(), libMesh::ReplicatedMesh::insert_elem(), and libMesh::DistributedMesh::insert_elem().

3146 {
3147  _map_data = data;
3148 }
unsigned char _map_data
Mapping function data; currently used when needed to store the RATIONAL_BERNSTEIN nodal weight data i...
Definition: elem.h:2304

◆ set_mapping_type()

void libMesh::Elem::set_mapping_type ( const ElemMappingType  type)
inlineinherited

Sets the value of the mapping type for the element.

Definition at line 3129 of file elem.h.

References libMesh::Elem::_map_type, and libMesh::Elem::type().

Referenced by libMesh::ReplicatedMesh::add_elem(), libMesh::DistributedMesh::add_elem(), libMesh::Elem::inherit_data_from(), libMesh::ReplicatedMesh::insert_elem(), and libMesh::DistributedMesh::insert_elem().

3130 {
3131  _map_type = cast_int<unsigned char>(type);
3132 }
unsigned char _map_type
Mapping function type; currently either 0 (LAGRANGE) or 1 (RATIONAL_BERNSTEIN).
Definition: elem.h:2298
virtual ElemType type() const =0

◆ set_n_comp()

void libMesh::DofObject::set_n_comp ( const unsigned int  s,
const unsigned int  var,
const unsigned int  ncomp 
)
inherited

Sets the number of components for Variable var of system s associated with this DofObject.

Definition at line 377 of file dof_object.C.

References libMesh::DofObject::n_systems(), libMesh::DofObject::n_vars(), libMesh::DofObject::set_n_comp_group(), and libMesh::DofObject::var_to_vg().

380 {
381  libmesh_assert_less (s, this->n_systems());
382  libmesh_assert_less (var, this->n_vars(s));
383 
384  this->set_n_comp_group(s, this->var_to_vg(s,var), ncomp);
385 }
unsigned int var_to_vg(const unsigned int s, const unsigned int var) const
Utility function - for variable var in system s, figure out what variable group it lives in...
Definition: dof_object.h:1341
unsigned int n_vars(const unsigned int s, const unsigned int vg) const
Definition: dof_object.h:967
unsigned int n_systems() const
Definition: dof_object.h:937
void set_n_comp_group(const unsigned int s, const unsigned int vg, const unsigned int ncomp)
Sets the number of components for VariableGroup vg of system s associated with this DofObject...
Definition: dof_object.C:389

◆ set_n_comp_group()

void libMesh::DofObject::set_n_comp_group ( const unsigned int  s,
const unsigned int  vg,
const unsigned int  ncomp 
)
inherited

Sets the number of components for VariableGroup vg of system s associated with this DofObject.

Definition at line 389 of file dof_object.C.

References libMesh::DofObject::_idx_buf, libMesh::DofObject::invalid_id, libMesh::DofObject::n_comp_group(), libMesh::DofObject::n_systems(), libMesh::DofObject::n_var_groups(), libMesh::DofObject::n_vars(), libMesh::DofObject::ncv_magic, and libMesh::DofObject::start_idx().

Referenced by libMesh::DofMap::reinit(), libMesh::DofObject::set_n_comp(), libMesh::DofObject::set_n_vars_per_group(), libMesh::DofMap::set_nonlocal_dof_objects(), and DofObjectTest< Node >::testManualDofCalculation().

392 {
393  libmesh_assert_less (s, this->n_systems());
394  libmesh_assert_less (vg, this->n_var_groups(s));
395 
396  // Check for trivial return
397  if (ncomp == this->n_comp_group(s,vg)) return;
398 
399 #ifndef NDEBUG
400  if (ncomp >= ncv_magic)
401  {
402  const index_t ncvm = ncv_magic;
403  libmesh_error_msg("ERROR: ncomp must be less than DofObject::ncv_magic!\n" \
404  << "ncomp = " \
405  << ncomp \
406  << ", ncv_magic = " \
407  << ncvm \
408  << "\nrecompile and try again!");
409  }
410 #endif
411 
412  const unsigned int
413  start_idx_sys = this->start_idx(s),
414  n_vars_group = this->n_vars(s,vg),
415  base_offset = start_idx_sys + 2*vg;
416 
417  libmesh_assert_less ((base_offset + 1), _idx_buf.size());
418 
419  // if (ncomp)
420  // libMesh::out << "s,vg,ncomp="
421  // << s << ","
422  // << vg << ","
423  // << ncomp << '\n';
424 
425  // set the number of components, maintaining the number
426  // of variables in the group
427  _idx_buf[base_offset] = ncv_magic*n_vars_group + ncomp;
428 
429  // We use (invalid_id - 1) to signify no
430  // components for this object
431  _idx_buf[base_offset + 1] = (ncomp == 0) ? invalid_id - 1 : invalid_id;
432 
433  // this->debug_buffer();
434  // libMesh::out << "s,vg = " << s << "," << vg << '\n'
435  // << "base_offset=" << base_offset << '\n'
436  // << "this->n_comp(s,vg)=" << this->n_comp(s,vg) << '\n'
437  // << "this->n_comp_group(s,vg)=" << this->n_comp_group(s,vg) << '\n'
438  // << "this->n_vars(s,vg)=" << this->n_vars(s,vg) << '\n'
439  // << "this->n_var_groups(s)=" << this->n_var_groups(s) << '\n';
440 
441  libmesh_assert_equal_to (ncomp, this->n_comp_group(s,vg));
442 }
unsigned int n_var_groups(const unsigned int s) const
Definition: dof_object.h:957
dof_id_type index_t
DoF index information.
Definition: dof_object.h:678
static constexpr dof_id_type invalid_id
An invalid id to distinguish an uninitialized DofObject.
Definition: dof_object.h:482
unsigned int n_vars(const unsigned int s, const unsigned int vg) const
Definition: dof_object.h:967
unsigned int n_systems() const
Definition: dof_object.h:937
unsigned int start_idx(const unsigned int s) const
The starting index for system s.
Definition: dof_object.h:1249
index_buffer_t _idx_buf
Definition: dof_object.h:680
unsigned int n_comp_group(const unsigned int s, const unsigned int vg) const
Definition: dof_object.h:1015
static const index_t ncv_magic
Above we introduced the chimera ncv, which is a hybrid of the form ncv = ncv_magic*nv + nc where nv a...
Definition: dof_object.h:691

◆ set_n_systems()

void libMesh::DofObject::set_n_systems ( const unsigned int  s)
inherited

Sets the number of systems for this DofObject.

If this number is a change, also clears all variable count and DoF indexing associated with this DofObject.

If any extra integers are associated with this DofObject, their count and values are unchanged.

Definition at line 142 of file dof_object.C.

References libMesh::DofObject::_idx_buf, libMesh::make_range(), libMesh::DofObject::n_extra_integers(), libMesh::DofObject::n_systems(), libMesh::DofObject::n_var_groups(), libMesh::DofObject::n_vars(), and libMesh::DofObject::start_idx_ints().

Referenced by libMesh::DofObject::add_system(), libMesh::DofObject::clear_dofs(), libMesh::Elem::refine(), DofObjectTest< Node >::testManualDofCalculation(), DofObjectTest< Node >::testSetNSystems(), DofObjectTest< Node >::testSetNSystemsExtraInts(), DofObjectTest< Node >::testSetNVariableGroups(), and DofObjectTest< Node >::testSetNVariableGroupsExtraInts().

143 {
144  const unsigned int old_ns = this->n_systems();
145 
146  // Check for trivial return
147  if (ns == old_ns)
148  return;
149 
150  const unsigned int nei = this->n_extra_integers();
151  const dof_id_type header_size = ns + bool(nei);
152  const dof_id_type hdr = nei ?
153  static_cast<dof_id_type>(-static_cast<std::ptrdiff_t>(header_size))
154  : header_size;
155  index_buffer_t new_buf(header_size + nei, hdr);
156  if (nei)
157  {
158  const unsigned int start_idx_ints = old_ns ?
159  cast_int<unsigned int>(_idx_buf[old_ns]) :
160  1;
161  libmesh_assert_less(start_idx_ints, _idx_buf.size());
162  std::copy(_idx_buf.begin()+start_idx_ints,
163  _idx_buf.end(),
164  new_buf.begin()+header_size);
165  if (ns)
166  std::fill(new_buf.begin()+1, new_buf.begin()+ns+1, ns+1);
167  }
168 
169  // vector swap trick to force deallocation when shrinking
170  new_buf.swap(_idx_buf);
171 
172 #ifdef DEBUG
173  libmesh_assert_equal_to(nei, this->n_extra_integers());
174 
175  // check that all systems now exist and that they have 0 size
176  libmesh_assert_equal_to (ns, this->n_systems());
177  for (auto s : make_range(this->n_systems()))
178  {
179  libmesh_assert_equal_to (this->n_vars(s), 0);
180  libmesh_assert_equal_to (this->n_var_groups(s), 0);
181  }
182 #endif
183 }
unsigned int n_var_groups(const unsigned int s) const
Definition: dof_object.h:957
unsigned int start_idx_ints() const
The starting index for an extra_integers pseudosystem.
Definition: dof_object.h:1273
unsigned int n_vars(const unsigned int s, const unsigned int vg) const
Definition: dof_object.h:967
unsigned int n_systems() const
Definition: dof_object.h:937
std::vector< index_t > index_buffer_t
Definition: dof_object.h:679
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140
unsigned int n_extra_integers() const
Returns how many extra integers are associated to the DofObject.
Definition: dof_object.h:1170
index_buffer_t _idx_buf
Definition: dof_object.h:680
uint8_t dof_id_type
Definition: id_types.h:67

◆ set_n_vars_per_group()

void libMesh::DofObject::set_n_vars_per_group ( const unsigned int  s,
const std::vector< unsigned int > &  nvpg 
)
inherited

Sets number of variables in each group associated with system s for this DofObject.

Implicit in this is also setting the number of VariableGroup variable groups for the system. Has the effect of setting the number of components to 0 even when called even with (nvg == this->n_var_groups(s)).

Definition at line 239 of file dof_object.C.

References libMesh::DofObject::_idx_buf, libMesh::DofObject::end_idx(), libMesh::DofObject::get_extra_integer(), libMesh::DofObject::has_extra_integers(), libMesh::DofObject::invalid_id, libMesh::make_range(), libMesh::DofObject::n_comp(), libMesh::DofObject::n_comp_group(), libMesh::DofObject::n_extra_integers(), libMesh::DofObject::n_systems(), libMesh::DofObject::n_var_groups(), libMesh::DofObject::n_vars(), libMesh::DofObject::ncv_magic, libMesh::DofObject::set_n_comp_group(), and libMesh::DofObject::start_idx().

Referenced by DofObjectTest< Node >::testManualDofCalculation(), DofObjectTest< Node >::testSetNVariableGroups(), and DofObjectTest< Node >::testSetNVariableGroupsExtraInts().

241 {
242  const unsigned int n_sys = this->n_systems();
243 
244  libmesh_assert_less (s, n_sys);
245 
246  // number of variable groups for this system - inferred
247  const unsigned int nvg = cast_int<unsigned int>(nvpg.size());
248 
249  // BSK - note that for compatibility with the previous implementation
250  // calling this method when (nvars == this->n_vars()) requires that
251  // we invalidate the DOF indices and set the number of components to 0.
252  // Note this was a bit of a surprise to me - there was no quick return in
253  // the old method, which caused removal and readdition of the DOF indices
254  // even in the case of (nvars == this->n_vars()), resulting in n_comp(s,v)
255  // implicitly becoming 0 regardless of any previous value.
256  // quick return?
257  if (nvg == this->n_var_groups(s))
258  {
259  for (unsigned int vg=0; vg<nvg; vg++)
260  {
261  this->set_n_comp_group(s,vg,0);
262  libmesh_assert_equal_to (this->n_vars(s,vg), nvpg[vg]);
263  }
264  return;
265  }
266 
267  const bool hei = this->has_extra_integers();
268 
269  // since there is ample opportunity to screw up other systems, let us
270  // cache their current sizes and later assert that they are unchanged.
271 #ifdef DEBUG
272  const unsigned int nei = this->n_extra_integers();
273 
274  DofObject::index_buffer_t old_system_sizes, old_extra_integers;
275  old_system_sizes.reserve(n_sys);
276  old_extra_integers.reserve(nei);
277 
278  for (unsigned int s_ctr=0; s_ctr<n_sys; s_ctr++)
279  old_system_sizes.push_back(this->n_var_groups(s_ctr));
280 
281  for (unsigned int ei=0; ei != nei; ++ei)
282  old_extra_integers.push_back(this->get_extra_integer(ei));
283 #endif
284 
285  // remove current indices if we have some
286  if (this->n_var_groups(s) != 0)
287  {
288  const unsigned int old_nvg_s = this->n_var_groups(s);
289 
290  DofObject::index_buffer_t::iterator
291  it = _idx_buf.begin(),
292  end = _idx_buf.begin();
293 
294  std::advance(it, this->start_idx(s));
295  std::advance(end, this->end_idx(s));
296  _idx_buf.erase(it,end);
297 
298  for (unsigned int ctr=(s+1); ctr<n_sys; ctr++)
299  _idx_buf[ctr] -= 2*old_nvg_s;
300 
301  if (hei)
302  _idx_buf[n_sys] -= 2*old_nvg_s;
303  }
304 
305  // better not have any now!
306  libmesh_assert_equal_to (this->n_var_groups(s), 0);
307 
308  // Make sure we didn't screw up any of our sizes!
309 #ifdef DEBUG
310  for (auto s_ctr : make_range(this->n_systems()))
311  if (s_ctr != s)
312  libmesh_assert_equal_to (this->n_var_groups(s_ctr), old_system_sizes[s_ctr]);
313 
314  libmesh_assert_equal_to (nei, this->n_extra_integers());
315 
316  for (unsigned int ei=0; ei != nei; ++ei)
317  libmesh_assert_equal_to(old_extra_integers[ei], this->get_extra_integer(ei));
318 #endif
319 
320  // OK, if the user requested 0 that is what we have
321  if (nvg == 0)
322  return;
323 
324  {
325  // array to hold new indices
326  DofObject::index_buffer_t var_idxs(2*nvg);
327  for (unsigned int vg=0; vg<nvg; vg++)
328  {
329  var_idxs[2*vg ] = ncv_magic*nvpg[vg] + 0;
330  var_idxs[2*vg + 1] = invalid_id - 1;
331  }
332 
333  DofObject::index_buffer_t::iterator it = _idx_buf.begin();
334  std::advance(it, this->end_idx(s));
335  _idx_buf.insert(it, var_idxs.begin(), var_idxs.end());
336 
337  for (unsigned int ctr=(s+1); ctr<n_sys; ctr++)
338  _idx_buf[ctr] += 2*nvg;
339 
340  if (hei)
341  _idx_buf[n_sys] += 2*nvg;
342 
343  // resize _idx_buf to fit so no memory is wasted.
345  }
346 
347  libmesh_assert_equal_to (nvg, this->n_var_groups(s));
348 
349 #ifdef DEBUG
350 
351  libmesh_assert_equal_to (this->n_var_groups(s), nvpg.size());
352 
353  for (auto vg : make_range(this->n_var_groups(s)))
354  {
355  libmesh_assert_equal_to (this->n_vars(s,vg), nvpg[vg]);
356  libmesh_assert_equal_to (this->n_comp_group(s,vg), 0);
357  }
358 
359  for (auto v : make_range(this->n_vars(s)))
360  libmesh_assert_equal_to (this->n_comp(s,v), 0);
361 
362  // again, all other system sizes should be unchanged!
363  for (auto s_ctr : make_range(this->n_systems()))
364  if (s_ctr != s)
365  libmesh_assert_equal_to (this->n_var_groups(s_ctr), old_system_sizes[s_ctr]);
366 
367  // Extra integers count and values should also be unchanged!
368  libmesh_assert_equal_to (nei, this->n_extra_integers());
369 
370  for (unsigned int ei=0; ei != nei; ++ei)
371  libmesh_assert_equal_to(old_extra_integers[ei], this->get_extra_integer(ei));
372 #endif
373 }
unsigned int n_comp(const unsigned int s, const unsigned int var) const
Definition: dof_object.h:1002
unsigned int n_var_groups(const unsigned int s) const
Definition: dof_object.h:957
unsigned int end_idx(const unsigned int s) const
The ending index for system s.
Definition: dof_object.h:1260
static constexpr dof_id_type invalid_id
An invalid id to distinguish an uninitialized DofObject.
Definition: dof_object.h:482
unsigned int n_vars(const unsigned int s, const unsigned int vg) const
Definition: dof_object.h:967
unsigned int n_systems() const
Definition: dof_object.h:937
bool has_extra_integers() const
Returns whether extra integers are associated to the DofObject.
Definition: dof_object.h:1188
std::vector< index_t > index_buffer_t
Definition: dof_object.h:679
void set_n_comp_group(const unsigned int s, const unsigned int vg, const unsigned int ncomp)
Sets the number of components for VariableGroup vg of system s associated with this DofObject...
Definition: dof_object.C:389
unsigned int start_idx(const unsigned int s) const
The starting index for system s.
Definition: dof_object.h:1249
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140
unsigned int n_extra_integers() const
Returns how many extra integers are associated to the DofObject.
Definition: dof_object.h:1170
index_buffer_t _idx_buf
Definition: dof_object.h:680
unsigned int n_comp_group(const unsigned int s, const unsigned int vg) const
Definition: dof_object.h:1015
dof_id_type get_extra_integer(const unsigned int index) const
Gets the value on this object of the extra integer associated with index, which should have been obta...
Definition: dof_object.h:1102
static const index_t ncv_magic
Above we introduced the chimera ncv, which is a hybrid of the form ncv = ncv_magic*nv + nc where nv a...
Definition: dof_object.h:691

◆ set_neighbor()

void libMesh::Elem::set_neighbor ( const unsigned int  i,
Elem n 
)
inlineinherited

◆ set_node() [1/2]

Node *& libMesh::Elem::set_node ( const unsigned int  i)
inlinevirtualinherited
Returns
The pointer to the Node with local number i as a writable reference.
Deprecated:
This setter cannot update the multiple node pointers used in a general polyhedron; use the set_node overload that takes an argument.

Reimplemented in libMesh::RemoteElem.

Definition at line 2559 of file elem.h.

References libMesh::Elem::_nodes, and libMesh::Elem::n_nodes().

Referenced by LinearElasticityWithContact::add_contact_edge_elements(), add_cube_convex_hull_to_mesh(), libMesh::UnstructuredMesh::all_first_order(), AllSecondOrderTest::allCompleteOrderMixed(), AllSecondOrderTest::allCompleteOrderRange(), AllSecondOrderTest::allSecondOrderMixed(), AllSecondOrderTest::allSecondOrderRange(), libMesh::TetGenMeshInterface::assign_nodes_to_elem(), libMesh::MeshTools::Generation::build_cube(), GetBoundaryPointsTest::build_mesh(), MixedDimensionMeshTest::build_mesh(), MeshfunctionDFEM::build_mesh(), SlitMeshTest::build_mesh(), MixedDimensionNonUniformRefinement::build_mesh(), MixedDimensionNonUniformRefinementTriangle::build_mesh(), MixedDimensionNonUniformRefinement3D::build_mesh(), OverlappingTestBase::build_quad_mesh(), libMesh::TriangleWrapper::copy_tri_to_mesh(), libMesh::UnstructuredMesh::create_submesh(), libMesh::C0Polygon::permute(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::AbaqusIO::read_elements(), libMesh::GmshIO::read_mesh(), libMesh::DynaIO::read_mesh(), libMesh::MatlabIO::read_stream(), libMesh::C0Polyhedron::retriangulate(), libMesh::RemoteElem::set_node(), PerElemTest< elem_type >::setUp(), libMesh::FE< Dim, LAGRANGE_VEC >::shape(), libMesh::Polyhedron::side_clones(), libMesh::UnstructuredMesh::stitching_helper(), libMesh::MeshTools::Generation::surface_octahedron(), libMesh::Elem::swap2nodes(), SystemsTest::testDofCouplingWithVarGroups(), MeshTriangulationTest::testEdge3Mesh(), MeshTriangulationTest::testEdgesMesh(), MeshTriangulationTest::testHalfDomain(), NodalNeighborsTest::testOrientation(), MeshTriangulationTest::testPoly2TriBad1DMultiBoundary(), MeshTriangulationTest::testPoly2TriBad2DMultiBoundary(), MeshTriangulationTest::testPoly2TriBadEdges(), EquationSystemsTest::testPostInitAddElem(), SystemsTest::testProjectMatrix3D(), InfFERadialTest::testRefinement(), EquationSystemsTest::testReinitWithNodeElem(), SystemsTest::testSetSystemParameterOverEquationSystem(), BoundaryInfoTest::testShellFaceConstraints(), InfFERadialTest::testSides(), MeshTetTest::testTetsToTets(), MeshSubdomainIDTest::testUnpartitioned(), and libMesh::Poly2TriTriangulator::triangulate_current_points().

2560 {
2561  libmesh_assert_less (i, this->n_nodes());
2562 
2563  libmesh_deprecated();
2564 
2565  return _nodes[i];
2566 }
Node ** _nodes
Pointers to the nodes we are connected to.
Definition: elem.h:2246
virtual unsigned int n_nodes() const =0

◆ set_node() [2/2]

void libMesh::Elem::set_node ( const unsigned int  i,
Node node 
)
inlinevirtualinherited

Sets local Node i to refer to node.

Reimplemented in libMesh::RemoteElem.

Definition at line 2572 of file elem.h.

References libMesh::Elem::_nodes, and libMesh::Elem::n_nodes().

2574 {
2575  libmesh_assert_less (i, this->n_nodes());
2576 
2577  _nodes[i] = node;
2578 }
Node ** _nodes
Pointers to the nodes we are connected to.
Definition: elem.h:2246
virtual unsigned int n_nodes() const =0

◆ set_old_dof_object()

void libMesh::DofObject::set_old_dof_object ( )
inherited

Sets the old_dof_object to a copy of this.

Definition at line 127 of file dof_object.C.

References libMesh::DofObject::clear_old_dof_object(), libMesh::DofObject::construct(), libMesh::libmesh_assert(), and libMesh::DofObject::old_dof_object.

128 {
129  this->clear_old_dof_object();
130 
132 
133  // Make a new DofObject, assign a copy of \p this.
134  // Make sure the copy ctor for DofObject works!!
135  this->old_dof_object = this->construct(this);
136 }
std::unique_ptr< DofObject > construct(const DofObject *other=nullptr)
Convenient factory function that calls either the (deep) copy constructor or the default constructor ...
Definition: dof_object.h:741
void clear_old_dof_object()
Sets the old_dof_object to nullptr.
Definition: dof_object.C:120
libmesh_assert(ctx)
std::unique_ptr< DofObject > old_dof_object
This object on the last mesh.
Definition: dof_object.h:88

◆ set_p_level()

void libMesh::Elem::set_p_level ( const unsigned int  p)
inherited

Sets the value of the p-refinement level for the element.

The following functions only apply when AMR is enabled and thus are not present otherwise.

Note
The maximum p-refinement level is currently 255.

Definition at line 41 of file elem_refinement.C.

References libMesh::Elem::_p_level, libMesh::Elem::child_ref_range(), libMesh::Elem::hack_p_level(), libMesh::Elem::JUST_COARSENED, libMesh::Elem::JUST_REFINED, libMesh::Elem::p_level(), libMesh::Elem::parent(), libMesh::Elem::set_p_level(), and libMesh::Elem::set_p_refinement_flag().

Referenced by libMesh::UnstructuredMesh::all_first_order(), libMesh::Elem::coarsen(), libMesh::Elem::Elem(), libMesh::Elem::inherit_data_from(), libMesh::Polygon::Polygon(), libMesh::Polyhedron::Polyhedron(), libMesh::Elem::refine(), libMesh::Elem::set_p_level(), and VolumeTest::testHex20PLevelTrueCentroid().

42 {
43  // Maintain the parent's p level as the minimum of it's children
44  if (this->parent() != nullptr)
45  {
46  unsigned int parent_p_level = this->parent()->p_level();
47 
48  // If our new p level is less than our parents, our parents drops
49  if (parent_p_level > p)
50  {
51  this->parent()->set_p_level(p);
52 
53  // And we should keep track of the drop, in case we need to
54  // do a projection later.
56  }
57  // If we are the lowest p level and it increases, so might
58  // our parent's, but we have to check every other child to see
59  else if (parent_p_level == _p_level && _p_level < p)
60  {
61  _p_level = cast_int<unsigned char>(p);
62  parent_p_level = cast_int<unsigned char>(p);
63  for (auto & c : this->parent()->child_ref_range())
64  parent_p_level = std::min(parent_p_level,
65  c.p_level());
66 
67  // When its children all have a higher p level, the parent's
68  // should rise
69  if (parent_p_level > this->parent()->p_level())
70  {
71  this->parent()->set_p_level(parent_p_level);
72 
73  // And we should keep track of the rise, in case we need to
74  // do a projection later.
76  }
77 
78  return;
79  }
80  }
81 
82  this->hack_p_level(p);
83 }
void set_p_level(const unsigned int p)
Sets the value of the p-refinement level for the element.
const Elem * parent() const
Definition: elem.h:3031
unsigned char _p_level
p refinement level - the difference between the polynomial degree on this element and the minimum pol...
Definition: elem.h:2291
unsigned int p_level() const
Definition: elem.h:3109
SimpleRange< ChildRefIter > child_ref_range()
Returns a range with all children of a parent element, usable in range-based for loops.
Definition: elem.h:2347
void set_p_refinement_flag(const RefinementState pflag)
Sets the value of the p-refinement flag for the element.
Definition: elem.h:3235
void hack_p_level(const unsigned int p)
Sets the value of the p-refinement level for the element without altering the p-level of its ancestor...
Definition: elem.h:3265

◆ set_p_refinement_flag()

void libMesh::Elem::set_p_refinement_flag ( const RefinementState  pflag)
inlineinherited

Sets the value of the p-refinement flag for the element.

Definition at line 3235 of file elem.h.

References libMesh::Elem::_pflag, libMesh::Elem::JUST_REFINED, and libMesh::Elem::p_level().

Referenced by libMesh::BoundaryInfo::add_elements(), libMesh::UnstructuredMesh::all_first_order(), libMesh::MeshRefinement::enforce_mismatch_limit_prior_to_refinement(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshRefinement::make_flags_parallel_consistent(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::Elem::refine(), and libMesh::Elem::set_p_level().

3236 {
3237  if (this->p_level() == 0)
3238  libmesh_assert_not_equal_to
3239  (pflag, Elem::JUST_REFINED);
3240 
3241  _pflag = cast_int<unsigned char>(pflag);
3242 }
unsigned char _pflag
p refinement flag.
Definition: elem.h:2281
unsigned int p_level() const
Definition: elem.h:3109

◆ set_parent()

void libMesh::Elem::set_parent ( Elem p)
inlineinherited

Sets the pointer to the element's parent.

Dangerous! Only use this if you know what you are doing!

Definition at line 3047 of file elem.h.

References libMesh::Elem::_elemlinks, and libMesh::Elem::dim().

Referenced by libMesh::BoundaryInfo::add_elements(), and libMesh::UnstructuredMesh::all_first_order().

3048 {
3049  // We no longer support using parent() as interior_parent()
3050  libmesh_assert_equal_to(this->dim(), p ? p->dim() : this->dim());
3051  _elemlinks[0] = p;
3052 }
Elem ** _elemlinks
Pointers to this element&#39;s parent and neighbors, and for lower-dimensional elements&#39; interior_parent...
Definition: elem.h:2252
virtual unsigned short dim() const =0

◆ set_refinement_flag()

void libMesh::Elem::set_refinement_flag ( const RefinementState  rflag)
inlineinherited

◆ set_unique_id() [1/2]

unique_id_type & libMesh::DofObject::set_unique_id ( )
inlineinherited

◆ set_unique_id() [2/2]

void libMesh::DofObject::set_unique_id ( unique_id_type  new_id)
inlineinherited

Sets the unique_id for this DofObject.

Definition at line 872 of file dof_object.h.

References libMesh::DofObject::_unique_id, and libMesh::libmesh_ignore().

873 {
874 #ifdef LIBMESH_ENABLE_UNIQUE_ID
875  _unique_id = new_id;
876 #else
877  libmesh_ignore(new_id);
878  libmesh_not_implemented();
879 #endif
880 }
unique_id_type _unique_id
A globally unique id, guaranteed not to change as the mesh is repartitioned or adapted.
Definition: dof_object.h:577
void libmesh_ignore(const Args &...)

◆ set_vg_dof_base()

void libMesh::DofObject::set_vg_dof_base ( const unsigned int  s,
const unsigned int  vg,
const dof_id_type  db 
)
inlineinherited

VariableGroup DoF indices are indexed as id = base + var_in_vg*ncomp + comp This method allows for direct access to the base.

Definition at line 1297 of file dof_object.h.

References libMesh::DofObject::_idx_buf, libMesh::DofObject::n_systems(), libMesh::DofObject::n_var_groups(), libMesh::DofObject::start_idx(), and libMesh::DofObject::vg_dof_base().

Referenced by libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DofObject::invalidate_dofs(), libMesh::DofMap::reinit(), libMesh::DofMap::set_nonlocal_dof_objects(), and DofObjectTest< Node >::testManualDofCalculation().

1300 {
1301  libmesh_assert_less (s, this->n_systems());
1302  libmesh_assert_less (vg, this->n_var_groups(s));
1303 
1304  const unsigned int
1305  start_idx_sys = this->start_idx(s);
1306 
1307  libmesh_assert_less ((start_idx_sys + 2*vg + 1), _idx_buf.size());
1308 
1309  _idx_buf[start_idx_sys + 2*vg + 1] = db;
1310 
1311  libmesh_assert_equal_to (this->vg_dof_base(s,vg), db);
1312 }
dof_id_type vg_dof_base(const unsigned int s, const unsigned int vg) const
VariableGroup DoF indices are indexed as id = base + var_in_vg*ncomp + comp This method allows for di...
Definition: dof_object.h:1317
unsigned int n_var_groups(const unsigned int s) const
Definition: dof_object.h:957
unsigned int n_systems() const
Definition: dof_object.h:937
unsigned int start_idx(const unsigned int s) const
The starting index for system s.
Definition: dof_object.h:1249
index_buffer_t _idx_buf
Definition: dof_object.h:680

◆ side_children_matrix()

unsigned int libMesh::Pyramid::side_children_matrix ( const unsigned  int,
const unsigned  int 
) const
inlineprotectedinherited

Matrix that allows children to inherit boundary conditions.

Definition at line 221 of file cell_pyramid.h.

223  { libmesh_not_implemented(); return 0; }

◆ side_index_range()

IntRange< unsigned short > libMesh::Elem::side_index_range ( ) const
inlineinherited
Returns
An integer range from 0 up to (but not including) the number of sides this element has.

Definition at line 2711 of file elem.h.

References libMesh::Elem::n_sides().

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::MeshTools::Subdivision::add_boundary_ghosts(), libMesh::BoundaryInfo::add_elements(), libMesh::MeshTools::Modification::all_tri(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::FEGenericBase< FEOutputType< T >::type >::coarsened_dof_values(), compute_enriched_soln(), libMesh::FEAbstract::compute_node_constraints(), libMesh::FEAbstract::compute_periodic_node_constraints(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_proj_constraints(), libMesh::BoundaryInfo::copy_boundary_ids(), libMesh::BoundaryInfo::edge_boundary_ids(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::MeshTools::Modification::flatten(), libMesh::ReplicatedMesh::get_disconnected_subdomains(), libMesh::Elem::get_info(), libMesh::BoundaryInfo::get_side_and_node_maps(), libMesh::Elem::has_topological_neighbor(), libMesh::InfFE< Dim, T_radial, T_map >::inf_compute_constraints(), libMesh::InfFE< Dim, T_radial, T_map >::inf_compute_node_constraints(), libMesh::LaplaceMeshSmoother::init(), libMesh::Elem::libmesh_assert_valid_neighbors(), libMesh::VariationalSmootherConstraint::nodes_share_boundary_id(), libMesh::Elem::nullify_neighbors(), libMesh::PostscriptIO::plot_quadratic_elem(), libMesh::MeshTools::Modification::smooth(), libMesh::UnstructuredMesh::stitching_helper(), MeshBaseTest::testMeshBaseVerifyIsPrepared(), and libMesh::MeshTetInterface::volume_to_surface_mesh().

2712 {
2713  return {0, cast_int<unsigned short>(this->n_sides())};
2714 }
virtual unsigned int n_sides() const =0

◆ side_ptr() [1/4]

std::unique_ptr< Elem > libMesh::Pyramid::side_ptr ( const unsigned int  i)
overridevirtualinherited
Returns
A primitive triangle or quad for face i.

Implements libMesh::Elem.

Definition at line 158 of file cell_pyramid.C.

References libMesh::Pyramid::n_sides(), and side_nodes_map.

Referenced by build_side_ptr(), and libMesh::Pyramid::side_ptr().

159 {
160  libmesh_assert_less (i, this->n_sides());
161 
162  // Return value
163  std::unique_ptr<Elem> face;
164 
165  // Set up the type of element
166  switch (i)
167  {
168  case 0: // triangular face 1
169  case 1: // triangular face 2
170  case 2: // triangular face 3
171  case 3: // triangular face 4
172  {
173  face = std::make_unique<Tri3>();
174  break;
175  }
176  case 4: // the quad face at z=0
177  {
178  face = std::make_unique<Quad4>();
179  break;
180  }
181  default:
182  libmesh_error_msg("Invalid side i = " << i);
183  }
184 
185  // Set the nodes
186  for (auto n : face->node_index_range())
187  face->set_node(n, this->node_ptr(Pyramid5::side_nodes_map[i][n]));
188 
189  return face;
190 }
virtual unsigned int n_sides() const override
Definition: cell_pyramid.h:90
static const unsigned int side_nodes_map[num_sides][nodes_per_side]
This maps the node of the side to element node numbers.

◆ side_ptr() [2/4]

void libMesh::Pyramid::side_ptr ( std::unique_ptr< Elem > &  side,
const unsigned int  i 
)
overridevirtualinherited

Rebuilds a primitive triangle or quad for face i.

Implements libMesh::Elem.

Definition at line 194 of file cell_pyramid.C.

References libMesh::Pyramid::n_sides(), libMesh::QUAD4, side_nodes_map, libMesh::Pyramid::side_ptr(), libMesh::Elem::subdomain_id(), and libMesh::TRI3.

196 {
197  libmesh_assert_less (i, this->n_sides());
198 
199  switch (i)
200  {
201  case 0: // triangular face 1
202  case 1: // triangular face 2
203  case 2: // triangular face 3
204  case 3: // triangular face 4
205  {
206  if (!side.get() || side->type() != TRI3)
207  {
208  side = this->side_ptr(i);
209  return;
210  }
211  break;
212  }
213 
214  case 4: // the quad face at z=0
215  {
216  if (!side.get() || side->type() != QUAD4)
217  {
218  side = this->side_ptr(i);
219  return;
220  }
221  break;
222  }
223 
224  default:
225  libmesh_error_msg("Invalid side i = " << i);
226  }
227 
228  side->subdomain_id() = this->subdomain_id();
229 
230  // Set the nodes
231  for (auto n : side->node_index_range())
232  side->set_node(n, this->node_ptr(Pyramid5::side_nodes_map[i][n]));
233 }
virtual unsigned int n_sides() const override
Definition: cell_pyramid.h:90
virtual std::unique_ptr< Elem > side_ptr(const unsigned int i) override
Definition: cell_pyramid.C:158
subdomain_id_type subdomain_id() const
Definition: elem.h:2583
static const unsigned int side_nodes_map[num_sides][nodes_per_side]
This maps the node of the side to element node numbers.

◆ side_ptr() [3/4]

std::unique_ptr< const Elem > libMesh::Elem::side_ptr ( unsigned int  i) const
inlineinherited

Definition at line 2720 of file elem.h.

References libMesh::Elem::side_ptr().

2721 {
2722  // Call the non-const version of this function, return the result as
2723  // a std::unique_ptr<const Elem>.
2724  Elem * me = const_cast<Elem *>(this);
2725  return me->side_ptr(i);
2726 }
Elem(const unsigned int n_nodes, const unsigned int n_sides, Elem *parent, Elem **elemlinkdata, Node **nodelinkdata)
Constructor.
Definition: elem.h:2379

◆ side_ptr() [4/4]

void libMesh::Elem::side_ptr ( std::unique_ptr< const Elem > &  side,
const unsigned int  i 
) const
inlineinherited

Definition at line 2732 of file elem.h.

References libMesh::Elem::side_ptr().

2734 {
2735  // Hand off to the non-const version of this function
2736  Elem * me = const_cast<Elem *>(this);
2737  std::unique_ptr<Elem> e {const_cast<Elem *>(elem.release())};
2738  me->side_ptr(e, i);
2739  elem = std::move(e);
2740 }
Elem(const unsigned int n_nodes, const unsigned int n_sides, Elem *parent, Elem **elemlinkdata, Node **nodelinkdata)
Constructor.
Definition: elem.h:2379

◆ side_type()

ElemType libMesh::Pyramid5::side_type ( const unsigned int  s) const
finaloverridevirtual
Returns
The type of element for side s.

Implements libMesh::Elem.

Definition at line 300 of file cell_pyramid5.C.

References libMesh::QUAD4, and libMesh::TRI3.

301 {
302  libmesh_assert_less (s, 5);
303  if (s < 4)
304  return TRI3;
305  return QUAD4;
306 }

◆ side_vertex_average_normal()

Point libMesh::Pyramid5::side_vertex_average_normal ( const unsigned int  s) const
finaloverridevirtual
Returns
the normal (outwards-facing) of the side of the element at the vertex-average of the side
Parameters
sthe side of interest

Reimplemented from libMesh::Elem.

Definition at line 310 of file cell_pyramid5.C.

References libMesh::TypeVector< T >::cross(), libMesh::LAGRANGE_MAP, libMesh::make_range(), libMesh::Elem::mapping_type(), libMesh::Elem::point(), side_nodes_map, and libMesh::TypeVector< T >::unit().

311 {
312  libmesh_assert_less (s, 5);
313  libmesh_assert_equal_to(this->mapping_type(), LAGRANGE_MAP);
314 
315  switch (s)
316  {
317  case 0: // triangular face 1
318  case 1: // triangular face 2
319  case 2: // triangular face 3
320  case 3: // triangular face 4
321  {
322  const Point n1 = this->point(side_nodes_map[s][1]) -
323  this->point(side_nodes_map[s][0]);
324  const Point n2 = this->point(side_nodes_map[s][2]) -
325  this->point(side_nodes_map[s][1]);
326  const Point pointing_out = n1.cross(n2);
327  return pointing_out.unit();
328  }
329  case 4: // the quad face at z=0
330  {
331  // At the side vertex average, things simplify a bit
332  // We get the side "plane" normal at all vertices, then average them
333  Point normal;
334  Point current_edge = this->point(side_nodes_map[s][1]) -
335  this->point(side_nodes_map[s][0]);
336  for (auto i : make_range(4))
337  {
338  const Point next_edge = this->point(side_nodes_map[s][(i + 2) % 4]) -
339  this->point(side_nodes_map[s][(i + 1) % 4]);
340  const Point normal_at_vertex = current_edge.cross(next_edge);
341  normal += normal_at_vertex;
342  current_edge = next_edge;
343  }
344  normal /= 4;
345  return normal.unit();
346  }
347  default:
348  libmesh_error_msg("Invalid side s = " << s);
349  }
350 }
ElemMappingType mapping_type() const
Definition: elem.h:3121
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140
static const unsigned int side_nodes_map[num_sides][nodes_per_side]
This maps the node of the side to element node numbers.
const Point & point(const unsigned int i) const
Definition: elem.h:2454

◆ sides_on_edge()

std::vector< unsigned int > libMesh::Pyramid::sides_on_edge ( const unsigned int  int) const
finaloverridevirtualinherited
Returns
the (local) side numbers that touch the specified edge

Implements libMesh::Elem.

Definition at line 262 of file cell_pyramid.C.

References libMesh::Pyramid::edge_sides_map, and libMesh::Pyramid::n_edges().

263 {
264  libmesh_assert_less (e, this->n_edges());
265  return {edge_sides_map[e][0], edge_sides_map[e][1]};
266 }
virtual unsigned int n_edges() const override
Definition: cell_pyramid.h:100
static const unsigned int edge_sides_map[8][2]
This maps each edge to the sides that contain said edge.
Definition: cell_pyramid.h:199

◆ simple_build_edge_ptr() [1/2]

template<typename Edgeclass , typename Subclass >
std::unique_ptr< Elem > libMesh::Elem::simple_build_edge_ptr ( const unsigned int  i)
inlineprotectedinherited

An implementation for simple (all edges equal) elements.

Definition at line 2867 of file elem.h.

References libMesh::Elem::n_edges().

2868 {
2869  libmesh_assert_less (i, this->n_edges());
2870 
2871  std::unique_ptr<Elem> edge = std::make_unique<Edgeclass>();
2872 
2873  for (auto n : edge->node_index_range())
2874  edge->set_node(n, this->node_ptr(Subclass::edge_nodes_map[i][n]));
2875 
2876  edge->set_interior_parent(this);
2877  edge->inherit_data_from(*this);
2878 
2879  return edge;
2880 }
virtual unsigned int n_edges() const =0

◆ simple_build_edge_ptr() [2/2]

template<typename Subclass >
void libMesh::Elem::simple_build_edge_ptr ( std::unique_ptr< Elem > &  edge,
const unsigned int  i,
ElemType  edgetype 
)
inlineprotectedinherited

An implementation for simple (all edges equal) elements.

Definition at line 2888 of file elem.h.

References libMesh::Elem::n_edges().

2891 {
2892  libmesh_assert_less (i, this->n_edges());
2893 
2894  if (!edge.get() || edge->type() != edgetype)
2895  {
2896  Subclass & real_me = cast_ref<Subclass&>(*this);
2897  edge = real_me.Subclass::build_edge_ptr(i);
2898  }
2899  else
2900  {
2901  edge->inherit_data_from(*this);
2902  for (auto n : edge->node_index_range())
2903  edge->set_node(n, this->node_ptr(Subclass::edge_nodes_map[i][n]));
2904  }
2905 }
virtual unsigned int n_edges() const =0

◆ simple_build_side_ptr() [1/2]

template<typename Sideclass , typename Subclass >
std::unique_ptr< Elem > libMesh::Elem::simple_build_side_ptr ( const unsigned int  i)
inlineprotectedinherited

An implementation for simple (all sides equal) elements.

Definition at line 2773 of file elem.h.

References libMesh::Elem::n_sides().

2774 {
2775  libmesh_assert_less (i, this->n_sides());
2776 
2777  std::unique_ptr<Elem> face = std::make_unique<Sideclass>();
2778  for (auto n : face->node_index_range())
2779  face->set_node(n, this->node_ptr(Subclass::side_nodes_map[i][n]));
2780 
2781  face->set_interior_parent(this);
2782  face->inherit_data_from(*this);
2783 
2784  return face;
2785 }
virtual unsigned int n_sides() const =0

◆ simple_build_side_ptr() [2/2]

template<typename Subclass >
void libMesh::Elem::simple_build_side_ptr ( std::unique_ptr< Elem > &  side,
const unsigned int  i,
ElemType  sidetype 
)
inlineprotectedinherited

An implementation for simple (all sides equal) elements.

Definition at line 2792 of file elem.h.

References libMesh::Elem::n_sides().

2795 {
2796  libmesh_assert_less (i, this->n_sides());
2797 
2798  if (!side.get() || side->type() != sidetype)
2799  {
2800  Subclass & real_me = cast_ref<Subclass&>(*this);
2801  side = real_me.Subclass::build_side_ptr(i);
2802  }
2803  else
2804  {
2805  side->set_interior_parent(this);
2806  side->inherit_data_from(*this);
2807  for (auto n : side->node_index_range())
2808  side->set_node(n, this->node_ptr(Subclass::side_nodes_map[i][n]));
2809  }
2810 }
virtual unsigned int n_sides() const =0

◆ simple_side_ptr()

template<typename Subclass , typename Mapclass >
void libMesh::Elem::simple_side_ptr ( std::unique_ptr< Elem > &  side,
const unsigned int  i,
ElemType  sidetype 
)
inlineprotectedinherited

An implementation for simple (all sides equal) elements.

Definition at line 2817 of file elem.h.

References libMesh::Elem::n_sides(), and libMesh::Elem::subdomain_id().

2820 {
2821  libmesh_assert_less (i, this->n_sides());
2822 
2823  if (!side.get() || side->type() != sidetype)
2824  {
2825  Subclass & real_me = cast_ref<Subclass&>(*this);
2826  side = real_me.Subclass::side_ptr(i);
2827  }
2828  else
2829  {
2830  side->subdomain_id() = this->subdomain_id();
2831 
2832  for (auto n : side->node_index_range())
2833  side->set_node(n, this->node_ptr(Mapclass::side_nodes_map[i][n]));
2834  }
2835 }
virtual unsigned int n_sides() const =0
subdomain_id_type subdomain_id() const
Definition: elem.h:2583

◆ subactive()

bool libMesh::Elem::subactive ( ) const
inlineinherited
Returns
true if the element is subactive (i.e. has no active descendants), false otherwise or if AMR is disabled.

Definition at line 2960 of file elem.h.

References libMesh::Elem::active(), libMesh::Elem::has_children(), and libMesh::Elem::parent().

Referenced by libMesh::HPCoarsenTest::add_projection(), libMesh::Elem::ancestor(), libMesh::FEAbstract::compute_node_constraints(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::Elem::get_info(), libMesh::InfFE< Dim, T_radial, T_map >::inf_compute_constraints(), libMesh::InfFE< Dim, T_radial, T_map >::inf_compute_node_constraints(), libMesh::Elem::libmesh_assert_valid_neighbors(), libMesh::Elem::make_links_to_me_local(), libMesh::Elem::make_links_to_me_remote(), libMesh::Elem::max_descendant_p_level(), libMesh::Elem::min_new_p_level_by_neighbor(), libMesh::Elem::min_p_level_by_neighbor(), libMesh::Elem::refine(), libMesh::Elem::remove_links_to_me(), and libMesh::UnstructuredMesh::stitching_helper().

2961 {
2962 #ifdef LIBMESH_ENABLE_AMR
2963  if (this->active())
2964  return false;
2965  if (!this->has_children())
2966  return true;
2967  for (const Elem * my_ancestor = this->parent();
2968  my_ancestor != nullptr;
2969  my_ancestor = my_ancestor->parent())
2970  if (my_ancestor->active())
2971  return true;
2972 #endif
2973 
2974  return false;
2975 }
const Elem * parent() const
Definition: elem.h:3031
Elem(const unsigned int n_nodes, const unsigned int n_sides, Elem *parent, Elem **elemlinkdata, Node **nodelinkdata)
Constructor.
Definition: elem.h:2379
bool active() const
Definition: elem.h:2942
bool has_children() const
Definition: elem.h:2980

◆ subdomain_id() [1/2]

subdomain_id_type libMesh::Elem::subdomain_id ( ) const
inlineinherited
Returns
The subdomain that this element belongs to.

Definition at line 2583 of file elem.h.

References libMesh::Elem::_sbd_id.

Referenced by libMesh::DofMap::_dof_indices(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::SyncSubdomainIds::act_on_data(), LinearElasticityWithContact::add_contact_edge_elements(), libMesh::MeshTools::Modification::all_tri(), AllSecondOrderTest::allCompleteOrderRange(), AllSecondOrderTest::allSecondOrderRange(), libMesh::AbaqusIO::assign_subdomain_ids(), libMesh::EquationSystems::build_discontinuous_solution_vector(), MixedDimensionMeshTest::build_mesh(), MixedDimensionNonUniformRefinement::build_mesh(), MixedDimensionNonUniformRefinementTriangle::build_mesh(), MixedDimensionNonUniformRefinement3D::build_mesh(), OverlappingTestBase::build_quad_mesh(), libMesh::InfQuad6::build_side_ptr(), libMesh::MeshTools::Modification::change_subdomain_id(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_proj_constraints(), libMesh::TriangleWrapper::copy_tri_to_mesh(), libMesh::DofMap::dof_indices(), libMesh::Elem::Elem(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::find_dofs_to_send(), libMesh::MeshTools::Modification::flatten(), libMesh::SyncSubdomainIds::gather_data(), libMesh::Elem::get_info(), libMesh::VariationalSmootherConstraint::get_neighbors_for_subdomain_constraint(), MeshExtruderTest::QueryElemSubdomainID::get_subdomain_for_layer(), libMesh::UNVIO::groups_in(), libMesh::Elem::inherit_data_from(), libMesh::DofMap::old_dof_indices(), libMesh::PointLocatorNanoflann::operator()(), libMesh::XdrIO::pack_element(), libMesh::Polygon::Polygon(), libMesh::Polyhedron::Polyhedron(), libMesh::CheckpointIO::read_connectivity(), libMesh::GmshIO::read_mesh(), libMesh::DynaIO::read_mesh(), libMesh::Pyramid::side_ptr(), libMesh::Prism::side_ptr(), libMesh::Polygon::side_ptr(), libMesh::InfPrism::side_ptr(), libMesh::InfHex::side_ptr(), libMesh::InfQuad::side_ptr(), libMesh::Elem::simple_side_ptr(), SystemsTest::testDofCouplingWithVarGroups(), MeshExtruderTest::testExtruder(), SystemsTest::testSetSystemParameterOverEquationSystem(), and SystemsTest::tripleValueTest().

2584 {
2585  return _sbd_id;
2586 }
subdomain_id_type _sbd_id
The subdomain to which this element belongs.
Definition: elem.h:2268

◆ subdomain_id() [2/2]

subdomain_id_type & libMesh::Elem::subdomain_id ( )
inlineinherited
Returns
The subdomain that this element belongs to as a writable reference.

Definition at line 2591 of file elem.h.

References libMesh::Elem::_sbd_id.

2592 {
2593  return _sbd_id;
2594 }
subdomain_id_type _sbd_id
The subdomain to which this element belongs.
Definition: elem.h:2268

◆ supported_nodal_order()

virtual Order libMesh::Elem::supported_nodal_order ( ) const
inlinevirtualinherited
Returns
The maximum supported approximation order for nodal (Lagrange or Rational Bezier-Bernstein) variables on this element type. This is usually the same as the default order.

Reimplemented in libMesh::NodeElem.

Definition at line 1006 of file elem.h.

References libMesh::Elem::default_order().

Referenced by libMesh::MeshBase::copy_constraint_rows().

1006 { return default_order(); }
virtual Order default_order() const =0

◆ swap2boundaryedges()

void libMesh::Elem::swap2boundaryedges ( unsigned short  e1,
unsigned short  e2,
BoundaryInfo boundary_info 
) const
protectedinherited

Swaps two edges in boundary_info, if it is non-null.

Definition at line 3565 of file elem.C.

References libMesh::BoundaryInfo::add_edge(), libMesh::BoundaryInfo::edge_boundary_ids(), and libMesh::BoundaryInfo::remove_edge().

Referenced by libMesh::InfQuad4::flip(), libMesh::InfPrism6::flip(), libMesh::InfHex8::flip(), libMesh::Quad4::flip(), libMesh::InfQuad6::flip(), libMesh::C0Polygon::flip(), flip(), libMesh::Tri3::flip(), libMesh::Prism6::flip(), libMesh::InfPrism12::flip(), libMesh::Quad8::flip(), libMesh::Hex8::flip(), libMesh::Quad9::flip(), libMesh::InfHex16::flip(), libMesh::Tri7::flip(), libMesh::Tri6::flip(), libMesh::Pyramid13::flip(), libMesh::InfHex18::flip(), libMesh::Hex20::flip(), libMesh::Tet10::flip(), libMesh::Tet14::flip(), libMesh::Prism15::flip(), libMesh::Tet4::flip(), libMesh::Pyramid14::flip(), libMesh::Pyramid18::flip(), libMesh::Hex27::flip(), libMesh::Prism18::flip(), libMesh::Prism20::flip(), and libMesh::Prism21::flip().

3568 {
3569  std::vector<boundary_id_type> ids1, ids2;
3570  boundary_info->edge_boundary_ids(this, e1, ids1);
3571  boundary_info->edge_boundary_ids(this, e2, ids2);
3572  boundary_info->remove_edge(this, e1);
3573  boundary_info->remove_edge(this, e2);
3574  if (!ids1.empty())
3575  boundary_info->add_edge(this, e2, ids1);
3576  if (!ids2.empty())
3577  boundary_info->add_edge(this, e1, ids2);
3578 }

◆ swap2boundarysides()

void libMesh::Elem::swap2boundarysides ( unsigned short  s1,
unsigned short  s2,
BoundaryInfo boundary_info 
) const
protectedinherited

Swaps two sides in boundary_info, if it is non-null.

Definition at line 3549 of file elem.C.

References libMesh::BoundaryInfo::add_side(), libMesh::BoundaryInfo::boundary_ids(), and libMesh::BoundaryInfo::remove_side().

Referenced by libMesh::InfQuad4::flip(), libMesh::InfPrism6::flip(), libMesh::InfHex8::flip(), libMesh::Edge2::flip(), libMesh::Quad4::flip(), libMesh::InfQuad6::flip(), libMesh::C0Polygon::flip(), flip(), libMesh::Edge4::flip(), libMesh::Edge3::flip(), libMesh::Tri3::flip(), libMesh::Prism6::flip(), libMesh::InfPrism12::flip(), libMesh::Quad8::flip(), libMesh::Hex8::flip(), libMesh::Quad9::flip(), libMesh::InfHex16::flip(), libMesh::Tri7::flip(), libMesh::Tri6::flip(), libMesh::Pyramid13::flip(), libMesh::InfHex18::flip(), libMesh::Hex20::flip(), libMesh::Tet10::flip(), libMesh::Tet14::flip(), libMesh::Prism15::flip(), libMesh::Tet4::flip(), libMesh::Pyramid14::flip(), libMesh::Pyramid18::flip(), libMesh::Hex27::flip(), libMesh::Prism18::flip(), libMesh::Prism20::flip(), and libMesh::Prism21::flip().

3552 {
3553  std::vector<boundary_id_type> ids1, ids2;
3554  boundary_info->boundary_ids(this, s1, ids1);
3555  boundary_info->boundary_ids(this, s2, ids2);
3556  boundary_info->remove_side(this, s1);
3557  boundary_info->remove_side(this, s2);
3558  if (!ids1.empty())
3559  boundary_info->add_side(this, s2, ids1);
3560  if (!ids2.empty())
3561  boundary_info->add_side(this, s1, ids2);
3562 }

◆ swap2neighbors()

void libMesh::Elem::swap2neighbors ( unsigned int  n1,
unsigned int  n2 
)
inlineprotectedinherited

Swaps two neighbor_ptrs.

Definition at line 2103 of file elem.h.

References libMesh::Elem::neighbor_ptr(), and libMesh::Elem::set_neighbor().

Referenced by libMesh::InfQuad4::flip(), libMesh::InfPrism6::flip(), libMesh::InfHex8::flip(), libMesh::Quad4::flip(), libMesh::Edge2::flip(), libMesh::InfQuad6::flip(), libMesh::C0Polygon::flip(), libMesh::Edge4::flip(), flip(), libMesh::Edge3::flip(), libMesh::Tri3::flip(), libMesh::Prism6::flip(), libMesh::InfPrism12::flip(), libMesh::Quad8::flip(), libMesh::Hex8::flip(), libMesh::Quad9::flip(), libMesh::Tri7::flip(), libMesh::InfHex16::flip(), libMesh::Tri6::flip(), libMesh::Pyramid13::flip(), libMesh::InfHex18::flip(), libMesh::Hex20::flip(), libMesh::Tet14::flip(), libMesh::Tet10::flip(), libMesh::Prism15::flip(), libMesh::Tet4::flip(), libMesh::Pyramid14::flip(), libMesh::Pyramid18::flip(), libMesh::Hex27::flip(), libMesh::Prism18::flip(), libMesh::Prism20::flip(), libMesh::Prism21::flip(), libMesh::Prism6::permute(), libMesh::Hex8::permute(), libMesh::Hex20::permute(), libMesh::Prism15::permute(), libMesh::Hex27::permute(), libMesh::Prism20::permute(), libMesh::Prism18::permute(), libMesh::Prism21::permute(), libMesh::Elem::swap3neighbors(), and libMesh::Elem::swap4neighbors().

2104  {
2105  Elem * temp = this->neighbor_ptr(n1);
2106  this->set_neighbor(n1, this->neighbor_ptr(n2));
2107  this->set_neighbor(n2, temp);
2108  }
void set_neighbor(const unsigned int i, Elem *n)
Assigns n as the neighbor.
Definition: elem.h:2619
Elem(const unsigned int n_nodes, const unsigned int n_sides, Elem *parent, Elem **elemlinkdata, Node **nodelinkdata)
Constructor.
Definition: elem.h:2379
const Elem * neighbor_ptr(unsigned int i) const
Definition: elem.h:2599

◆ swap2nodes()

void libMesh::Elem::swap2nodes ( unsigned int  n1,
unsigned int  n2 
)
inlineprotectedinherited

Swaps two node_ptrs.

Definition at line 2093 of file elem.h.

References libMesh::Elem::node_ptr(), and libMesh::Elem::set_node().

Referenced by libMesh::InfQuad4::flip(), libMesh::InfPrism6::flip(), libMesh::InfHex8::flip(), libMesh::Quad4::flip(), libMesh::Edge2::flip(), libMesh::InfQuad6::flip(), libMesh::C0Polygon::flip(), libMesh::Edge4::flip(), flip(), libMesh::Edge3::flip(), libMesh::Tri3::flip(), libMesh::Prism6::flip(), libMesh::InfPrism12::flip(), libMesh::Quad8::flip(), libMesh::Hex8::flip(), libMesh::Quad9::flip(), libMesh::Tri7::flip(), libMesh::InfHex16::flip(), libMesh::Tri6::flip(), libMesh::Pyramid13::flip(), libMesh::InfHex18::flip(), libMesh::Hex20::flip(), libMesh::Tet14::flip(), libMesh::Tet10::flip(), libMesh::Prism15::flip(), libMesh::Tet4::flip(), libMesh::Pyramid14::flip(), libMesh::Pyramid18::flip(), libMesh::Hex27::flip(), libMesh::Prism18::flip(), libMesh::Prism20::flip(), libMesh::Prism21::flip(), libMesh::Prism6::permute(), libMesh::Hex8::permute(), libMesh::Hex20::permute(), libMesh::Prism15::permute(), libMesh::Hex27::permute(), libMesh::Prism20::permute(), libMesh::Prism18::permute(), libMesh::Prism21::permute(), libMesh::Elem::swap3nodes(), and libMesh::Elem::swap4nodes().

2094  {
2095  Node * temp = this->node_ptr(n1);
2096  this->set_node(n1, this->node_ptr(n2));
2097  this->set_node(n2, temp);
2098  }
virtual Node *& set_node(const unsigned int i)
Definition: elem.h:2559
const Node * node_ptr(const unsigned int i) const
Definition: elem.h:2508

◆ swap3neighbors()

void libMesh::Elem::swap3neighbors ( unsigned int  n1,
unsigned int  n2,
unsigned int  n3 
)
inlineprotectedinherited

◆ swap3nodes()

void libMesh::Elem::swap3nodes ( unsigned int  n1,
unsigned int  n2,
unsigned int  n3 
)
inlineprotectedinherited

◆ swap4neighbors()

void libMesh::Elem::swap4neighbors ( unsigned int  n1,
unsigned int  n2,
unsigned int  n3,
unsigned int  n4 
)
inlineprotectedinherited

Swaps four neighbor_ptrs, "rotating" them.

Definition at line 2154 of file elem.h.

References libMesh::Elem::swap2neighbors(), and libMesh::Elem::swap3neighbors().

Referenced by libMesh::InfHex8::permute(), libMesh::Quad4::permute(), permute(), libMesh::Hex8::permute(), libMesh::Quad8::permute(), libMesh::Quad9::permute(), libMesh::InfHex16::permute(), libMesh::Pyramid13::permute(), libMesh::InfHex18::permute(), libMesh::Hex20::permute(), libMesh::Pyramid14::permute(), libMesh::Pyramid18::permute(), and libMesh::Hex27::permute().

2156  {
2157  swap3neighbors(n1, n2, n3);
2158  swap2neighbors(n3, n4);
2159  }
void swap3neighbors(unsigned int n1, unsigned int n2, unsigned int n3)
Swaps three neighbor_ptrs, "rotating" them.
Definition: elem.h:2134
void swap2neighbors(unsigned int n1, unsigned int n2)
Swaps two neighbor_ptrs.
Definition: elem.h:2103

◆ swap4nodes()

void libMesh::Elem::swap4nodes ( unsigned int  n1,
unsigned int  n2,
unsigned int  n3,
unsigned int  n4 
)
inlineprotectedinherited

Swaps four node_ptrs, "rotating" them.

Definition at line 2144 of file elem.h.

References libMesh::Elem::swap2nodes(), and libMesh::Elem::swap3nodes().

Referenced by libMesh::InfHex8::permute(), libMesh::Quad4::permute(), permute(), libMesh::Hex8::permute(), libMesh::Quad8::permute(), libMesh::Quad9::permute(), libMesh::InfHex16::permute(), libMesh::Pyramid13::permute(), libMesh::InfHex18::permute(), libMesh::Hex20::permute(), libMesh::Pyramid14::permute(), libMesh::Pyramid18::permute(), and libMesh::Hex27::permute().

2146  {
2147  swap3nodes(n1, n2, n3);
2148  swap2nodes(n3, n4);
2149  }
void swap3nodes(unsigned int n1, unsigned int n2, unsigned int n3)
Swaps three node_ptrs, "rotating" them.
Definition: elem.h:2125
void swap2nodes(unsigned int n1, unsigned int n2)
Swaps two node_ptrs.
Definition: elem.h:2093

◆ top_parent()

const Elem * libMesh::Elem::top_parent ( ) const
inlineinherited
Returns
A pointer to the element's top-most (i.e. level-0) parent.

That is, this if this is a level-0 element, this element's parent if this is a level-1 element, this element's grandparent if this is a level-2 element, etc...

Definition at line 3057 of file elem.h.

References libMesh::Elem::level(), libMesh::libmesh_assert(), and libMesh::Elem::parent().

Referenced by libMesh::BoundaryInfo::boundary_ids(), libMesh::BoundaryInfo::edge_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_amr_interior_parents(), libMesh::ExodusII_IO::read_elemental_variable(), libMesh::BoundaryInfo::side_boundary_ids(), libMesh::BoundaryInfo::side_with_boundary_id(), libMesh::BoundaryInfo::sides_with_boundary_id(), and ExtraIntegersTest::test_final_integers().

3058 {
3059  const Elem * tp = this;
3060 
3061  // Keep getting the element's parent
3062  // until that parent is at level-0
3063  while (tp->parent() != nullptr)
3064  tp = tp->parent();
3065 
3066  libmesh_assert(tp);
3067  libmesh_assert_equal_to (tp->level(), 0);
3068 
3069  return tp;
3070 }
libmesh_assert(ctx)
Elem(const unsigned int n_nodes, const unsigned int n_sides, Elem *parent, Elem **elemlinkdata, Node **nodelinkdata)
Constructor.
Definition: elem.h:2379

◆ topological_neighbor() [1/2]

const Elem * libMesh::Elem::topological_neighbor ( const unsigned int  i,
const MeshBase mesh,
const PointLocatorBase point_locator,
const PeriodicBoundaries pb 
) const
inherited
Returns
A pointer to the \( i^{th} \) neighbor of this element for interior elements. If an element is on a periodic boundary, it will return a corresponding element on the opposite side.

Definition at line 1311 of file elem.C.

References libMesh::PeriodicBoundaries::boundary(), libMesh::Elem::level(), mesh, libMesh::Elem::n_neighbors(), libMesh::PeriodicBoundaries::neighbor(), libMesh::Elem::neighbor_ptr(), and libMesh::Elem::parent().

Referenced by libMesh::Elem::has_topological_neighbor(), libMesh::GhostPointNeighbors::operator()(), libMesh::DefaultCoupling::operator()(), and libMesh::MeshRefinement::topological_neighbor().

1315 {
1316  libmesh_assert_less (i, this->n_neighbors());
1317 
1318  const Elem * neighbor_i = this->neighbor_ptr(i);
1319  if (neighbor_i != nullptr)
1320  return neighbor_i;
1321 
1322  if (pb)
1323  {
1324  // Since the neighbor is nullptr it must be on a boundary. We need
1325  // see if this is a periodic boundary in which case it will have a
1326  // topological neighbor
1327  std::vector<boundary_id_type> bc_ids;
1328  mesh.get_boundary_info().boundary_ids(this, cast_int<unsigned short>(i), bc_ids);
1329  for (const auto & id : bc_ids)
1330  if (pb->boundary(id))
1331  {
1332  neighbor_i = pb->neighbor(id, point_locator, this, i);
1333 
1334  // Since coarse elements do not have more refined
1335  // neighbors we need to make sure that we don't return one
1336  // of these types of neighbors.
1337  if (neighbor_i)
1338  while (level() < neighbor_i->level())
1339  neighbor_i = neighbor_i->parent();
1340  return neighbor_i;
1341  }
1342  }
1343 
1344  return nullptr;
1345 }
MeshBase & mesh
Elem(const unsigned int n_nodes, const unsigned int n_sides, Elem *parent, Elem **elemlinkdata, Node **nodelinkdata)
Constructor.
Definition: elem.h:2379
const Elem * neighbor_ptr(unsigned int i) const
Definition: elem.h:2599
unsigned int level() const
Definition: elem.h:3075
unsigned int n_neighbors() const
Definition: elem.h:715

◆ topological_neighbor() [2/2]

Elem * libMesh::Elem::topological_neighbor ( const unsigned int  i,
MeshBase mesh,
const PointLocatorBase point_locator,
const PeriodicBoundaries pb 
)
inherited
Returns
A writable pointer to the \( i^{th} \) neighbor of this element for interior elements. If an element is on a periodic boundary, it will return a corresponding element on the opposite side.

Definition at line 1269 of file elem.C.

References libMesh::PeriodicBoundaries::boundary(), libMesh::Elem::level(), mesh, libMesh::Elem::n_neighbors(), libMesh::PeriodicBoundaries::neighbor(), libMesh::Elem::neighbor_ptr(), and libMesh::Elem::parent().

1273 {
1274  libmesh_assert_less (i, this->n_neighbors());
1275 
1276  Elem * neighbor_i = this->neighbor_ptr(i);
1277  if (neighbor_i != nullptr)
1278  return neighbor_i;
1279 
1280  if (pb)
1281  {
1282  // Since the neighbor is nullptr it must be on a boundary. We need
1283  // see if this is a periodic boundary in which case it will have a
1284  // topological neighbor
1285  std::vector<boundary_id_type> bc_ids;
1286  mesh.get_boundary_info().boundary_ids(this, cast_int<unsigned short>(i), bc_ids);
1287  for (const auto & id : bc_ids)
1288  if (pb->boundary(id))
1289  {
1290  // Since the point locator inside of periodic boundaries
1291  // returns a const pointer we will retrieve the proper
1292  // pointer directly from the mesh object.
1293  const Elem * const cn = pb->neighbor(id, point_locator, this, i);
1294  neighbor_i = const_cast<Elem *>(cn);
1295 
1296  // Since coarse elements do not have more refined
1297  // neighbors we need to make sure that we don't return one
1298  // of these types of neighbors.
1299  if (neighbor_i)
1300  while (level() < neighbor_i->level())
1301  neighbor_i = neighbor_i->parent();
1302  return neighbor_i;
1303  }
1304  }
1305 
1306  return nullptr;
1307 }
MeshBase & mesh
Elem(const unsigned int n_nodes, const unsigned int n_sides, Elem *parent, Elem **elemlinkdata, Node **nodelinkdata)
Constructor.
Definition: elem.h:2379
const Elem * neighbor_ptr(unsigned int i) const
Definition: elem.h:2599
unsigned int level() const
Definition: elem.h:3075
unsigned int n_neighbors() const
Definition: elem.h:715

◆ topologically_equal()

bool libMesh::Elem::topologically_equal ( const Elem rhs) const
inherited
Returns
true if two elements have equal topologies, false otherwise. This is true if the elements connect to nodes of the same id in the same order, and neighbors of the same id on each side, the same id on any parent and/or interior_parent link, etc.

Definition at line 801 of file elem.C.

References libMesh::DofObject::id(), libMesh::Elem::interior_parent(), libMesh::make_range(), libMesh::Elem::n_neighbors(), libMesh::Elem::n_nodes(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::node_id(), libMesh::Elem::parent(), and libMesh::Elem::type().

802 {
803  // If the elements aren't the same type, they aren't equal
804  if (this->type() != rhs.type())
805  return false;
806 
807  libmesh_assert_equal_to(this->n_nodes(), rhs.n_nodes());
808 
809  for (auto n : make_range(this->n_nodes()))
810  if (this->node_id(n) != rhs.node_id(n))
811  return false;
812 
813  for (auto neigh : make_range(this->n_neighbors()))
814  {
815  if (!this->neighbor_ptr(neigh))
816  {
817  if (rhs.neighbor_ptr(neigh))
818  return false;
819  continue;
820  }
821  if (!rhs.neighbor_ptr(neigh) ||
822  this->neighbor_ptr(neigh)->id() !=
823  rhs.neighbor_ptr(neigh)->id())
824  return false;
825  }
826 
827  if (this->parent())
828  {
829  if (!rhs.parent())
830  return false;
831  if (this->parent()->id() != rhs.parent()->id())
832  return false;
833  }
834  else if (rhs.parent())
835  return false;
836 
837  if (this->interior_parent())
838  {
839  if (!rhs.interior_parent())
840  return false;
841  if (this->interior_parent()->id() !=
842  rhs.interior_parent()->id())
843  return false;
844  }
845  else if (rhs.interior_parent())
846  return false;
847 
848  return true;
849 }
const Elem * parent() const
Definition: elem.h:3031
const Elem * interior_parent() const
Definition: elem.C:1184
dof_id_type id() const
Definition: dof_object.h:828
virtual unsigned int n_nodes() const =0
const Elem * neighbor_ptr(unsigned int i) const
Definition: elem.h:2599
unsigned int n_neighbors() const
Definition: elem.h:715
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140
virtual ElemType type() const =0
dof_id_type node_id(const unsigned int i) const
Definition: elem.h:2476

◆ total_family_tree() [1/2]

void libMesh::Elem::total_family_tree ( std::vector< const Elem *> &  family,
bool  reset = true 
) const
inherited

Same as the family_tree() member, but also adds any subactive descendants.

Definition at line 2115 of file elem.C.

References libMesh::ElemInternal::total_family_tree().

Referenced by libMesh::Partitioner::set_parent_processor_ids().

2117 {
2118  ElemInternal::total_family_tree(this, family, reset);
2119 }
void total_family_tree(T elem, std::vector< T > &family, bool reset)
Definition: elem_internal.h:67

◆ total_family_tree() [2/2]

void libMesh::Elem::total_family_tree ( std::vector< Elem *> &  family,
bool  reset = true 
)
inherited

Non-const version of function above; fills a vector of non-const pointers.

Definition at line 2123 of file elem.C.

References libMesh::ElemInternal::total_family_tree().

2125 {
2126  ElemInternal::total_family_tree(this, family, reset);
2127 }
void total_family_tree(T elem, std::vector< T > &family, bool reset)
Definition: elem_internal.h:67

◆ total_family_tree_by_neighbor() [1/2]

void libMesh::Elem::total_family_tree_by_neighbor ( std::vector< const Elem *> &  family,
const Elem neighbor,
bool  reset = true 
) const
inherited

Same as the family_tree_by_neighbor() member, but also adds any subactive descendants.

Definition at line 2201 of file elem.C.

References libMesh::ElemInternal::total_family_tree_by_neighbor().

2204 {
2205  ElemInternal::total_family_tree_by_neighbor(this, family, neighbor, reset);
2206 }
void total_family_tree_by_neighbor(T elem, std::vector< T > &family, T neighbor_in, bool reset=true)

◆ total_family_tree_by_neighbor() [2/2]

void libMesh::Elem::total_family_tree_by_neighbor ( std::vector< Elem *> &  family,
Elem neighbor,
bool  reset = true 
)
inherited

Non-const version of function above; fills a vector of non-const pointers.

Definition at line 2210 of file elem.C.

References libMesh::ElemInternal::total_family_tree_by_neighbor().

2213 {
2214  ElemInternal::total_family_tree_by_neighbor(this, family, neighbor, reset);
2215 }
void total_family_tree_by_neighbor(T elem, std::vector< T > &family, T neighbor_in, bool reset=true)

◆ total_family_tree_by_subneighbor() [1/2]

void libMesh::Elem::total_family_tree_by_subneighbor ( std::vector< const Elem *> &  family,
const Elem neighbor,
const Elem subneighbor,
bool  reset = true 
) const
inherited

Same as the family_tree_by_subneighbor() member, but also adds any subactive descendants.

Definition at line 2239 of file elem.C.

References libMesh::ElemInternal::total_family_tree_by_subneighbor().

2243 {
2244  ElemInternal::total_family_tree_by_subneighbor(this, family, neighbor, subneighbor, reset);
2245 }
void total_family_tree_by_subneighbor(T elem, std::vector< T > &family, T neighbor_in, T subneighbor, bool reset=true)

◆ total_family_tree_by_subneighbor() [2/2]

void libMesh::Elem::total_family_tree_by_subneighbor ( std::vector< Elem *> &  family,
Elem neighbor,
Elem subneighbor,
bool  reset = true 
)
inherited

Non-const version of function above; fills a vector of non-const pointers.

Definition at line 2249 of file elem.C.

References libMesh::ElemInternal::total_family_tree_by_subneighbor().

2253 {
2254  ElemInternal::total_family_tree_by_subneighbor(this, family, neighbor, subneighbor, reset);
2255 }
void total_family_tree_by_subneighbor(T elem, std::vector< T > &family, T neighbor_in, T subneighbor, bool reset=true)

◆ true_centroid()

Point libMesh::Pyramid5::true_centroid ( ) const
overridevirtual

We compute the centroid of the Pyramid by treating it as a degenerate Hex8 element.

Reimplemented from libMesh::Elem.

Definition at line 233 of file cell_pyramid5.C.

References libMesh::Hex8::centroid_from_points(), and libMesh::Elem::point().

234 {
235  // Call Hex8 static helper function, passing 4 copies of the final
236  // vertex point, effectively treating the Pyramid as a degenerate
237  // hexahedron. In my testing, this still seems to give correct
238  // results.
240  point(0), point(1), point(2), point(3),
241  point(4), point(4), point(4), point(4));
242 }
static Point centroid_from_points(const Point &x0, const Point &x1, const Point &x2, const Point &x3, const Point &x4, const Point &x5, const Point &x6, const Point &x7)
Class static helper function that computes the centroid of a hexahedral region from a set of input po...
Definition: cell_hex8.C:336
const Point & point(const unsigned int i) const
Definition: elem.h:2454

◆ type()

virtual ElemType libMesh::Pyramid5::type ( ) const
inlineoverridevirtual
Returns
PYRAMID.

Implements libMesh::Elem.

Definition at line 78 of file cell_pyramid5.h.

References libMesh::PYRAMID5.

78 { return PYRAMID5; }

◆ unique_id()

unique_id_type libMesh::DofObject::unique_id ( ) const
inlineinherited
Returns
The globally unique_id for this DofObject

Definition at line 844 of file dof_object.h.

References libMesh::DofObject::_unique_id, libMesh::DofObject::invalid_unique_id, libMesh::libmesh_assert(), and libMesh::DofObject::valid_unique_id().

Referenced by libMesh::ReplicatedMesh::add_elem(), libMesh::DistributedMesh::add_elem(), libMesh::ReplicatedMesh::add_node(), libMesh::DistributedMesh::add_node(), libMesh::ReplicatedMesh::add_point(), libMesh::MeshTools::Modification::all_tri(), libMesh::C0Polyhedron::disconnected_clone(), libMesh::Elem::disconnected_clone(), libMesh::MeshTools::Modification::flatten(), libMesh::Elem::get_info(), libMesh::ReplicatedMesh::insert_elem(), libMesh::DistributedMesh::insert_elem(), libMesh::ReplicatedMesh::insert_node(), libMesh::XdrIO::pack_element(), libMesh::ExodusII_IO::read_elemental_variable(), SlitMeshRefinedSystemTest::testRestart(), and libMesh::XdrIO::write_serialized_nodes().

845 {
846 #ifdef LIBMESH_ENABLE_UNIQUE_ID
848  return _unique_id;
849 #else
850  return invalid_unique_id;
851 #endif
852 }
static constexpr unique_id_type invalid_unique_id
An invalid unique_id to distinguish an uninitialized DofObject.
Definition: dof_object.h:487
unique_id_type _unique_id
A globally unique id, guaranteed not to change as the mesh is repartitioned or adapted.
Definition: dof_object.h:577
libmesh_assert(ctx)
bool valid_unique_id() const
Definition: dof_object.h:893

◆ unpack_indexing()

void libMesh::DofObject::unpack_indexing ( std::vector< largest_id_type >::const_iterator  begin)
inherited

A method for creating our index buffer from packed data - basically with our current implementation we investigate the size term and then copy.

Definition at line 587 of file dof_object.C.

References libMesh::DofObject::_idx_buf, libMesh::DofObject::clear_old_dof_object(), libMesh::DofObject::construct(), libMesh::libmesh_assert(), and libMesh::DofObject::old_dof_object.

588 {
589  _idx_buf.clear();
590 
591 #ifdef LIBMESH_ENABLE_AMR
592  this->clear_old_dof_object();
593  const bool has_old_dof_object = cast_int<bool>(*begin++);
594 #endif
595 
596  const largest_id_type size = *begin++;
597  _idx_buf.reserve(size);
598  std::copy(begin, begin+size, back_inserter(_idx_buf));
599 
600  // Check as best we can for internal consistency now
601  libmesh_assert(_idx_buf.empty() ||
602  (std::abs(dof_id_signed_type(_idx_buf[0])) <=
603  cast_int<dof_id_signed_type>(_idx_buf.size())));
604 #ifdef DEBUG
605  if (!_idx_buf.empty())
606  {
607  const int hdr = cast_int<int>(dof_id_signed_type(_idx_buf[0]));
608  const unsigned int ns = hdr >= 0 ? hdr : (-hdr-1);
609  for (unsigned int i=1; i < ns; ++i)
610  {
611  if (hdr > 0 || i > 1)
612  libmesh_assert_greater_equal (_idx_buf[i], _idx_buf[i-1]);
613  else
614  libmesh_assert_greater_equal (_idx_buf[i], ns);
615  libmesh_assert_equal_to ((_idx_buf[i] - _idx_buf[i-1])%2, 0);
616  libmesh_assert_less_equal (_idx_buf[i], _idx_buf.size());
617  }
618  if (hdr < 0 && ns > 0)
619  libmesh_assert_less_equal(_idx_buf[ns], _idx_buf.size());
620  }
621 #endif
622 
623 #ifdef LIBMESH_ENABLE_AMR
624  if (has_old_dof_object)
625  {
626  this->old_dof_object = this->construct();
627  this->old_dof_object->unpack_indexing(begin+size);
628  }
629 #endif
630 }
std::unique_ptr< DofObject > construct(const DofObject *other=nullptr)
Convenient factory function that calls either the (deep) copy constructor or the default constructor ...
Definition: dof_object.h:741
uint64_t largest_id_type
Definition: id_types.h:148
void clear_old_dof_object()
Sets the old_dof_object to nullptr.
Definition: dof_object.C:120
libmesh_assert(ctx)
int8_t dof_id_signed_type
Definition: id_types.h:68
std::unique_ptr< DofObject > old_dof_object
This object on the last mesh.
Definition: dof_object.h:88
index_buffer_t _idx_buf
Definition: dof_object.h:680

◆ unpackable_indexing_size()

unsigned int libMesh::DofObject::unpackable_indexing_size ( std::vector< largest_id_type >::const_iterator  begin)
staticinherited

If we have indices packed into an buffer for communications, how much of that buffer applies to this dof object?

Definition at line 567 of file dof_object.C.

568 {
569 #ifdef LIBMESH_ENABLE_AMR
570  const bool has_old_dof_object = cast_int<bool>(*begin++);
571 
572  static const int dof_header_size = 2;
573 #else
574  static const bool has_old_dof_object = false;
575  static const int dof_header_size = 1;
576 #endif
577 
578  const largest_id_type this_indexing_size = *begin++;
579 
580  return cast_int<unsigned int>
581  (dof_header_size + this_indexing_size +
582  (has_old_dof_object ?
583  unpackable_indexing_size(begin+this_indexing_size) : 0));
584 }
static unsigned int unpackable_indexing_size(std::vector< largest_id_type >::const_iterator begin)
If we have indices packed into an buffer for communications, how much of that buffer applies to this ...
Definition: dof_object.C:567
uint64_t largest_id_type
Definition: id_types.h:148

◆ valid_id()

bool libMesh::DofObject::valid_id ( ) const
inlineinherited

◆ valid_processor_id()

bool libMesh::DofObject::valid_processor_id ( ) const
inlineinherited
Returns
true if this DofObject has a valid id set, false otherwise.

Definition at line 929 of file dof_object.h.

References libMesh::DofObject::_processor_id, and libMesh::DofObject::invalid_processor_id.

Referenced by DofObjectTest< Node >::testInvalidateProcId(), and DofObjectTest< Node >::testValidProcId().

930 {
932 }
static constexpr processor_id_type invalid_processor_id
An invalid processor_id to distinguish DoFs that have not been assigned to a processor.
Definition: dof_object.h:493
processor_id_type _processor_id
The processor_id of the DofObject.
Definition: dof_object.h:594

◆ valid_unique_id()

bool libMesh::DofObject::valid_unique_id ( ) const
inlineinherited
Returns
true if this DofObject has a valid unique_id set, false otherwise.

Definition at line 893 of file dof_object.h.

References libMesh::DofObject::_unique_id, and libMesh::DofObject::invalid_unique_id.

Referenced by libMesh::ReplicatedMesh::add_elem(), libMesh::DistributedMesh::add_elem(), libMesh::ReplicatedMesh::add_node(), libMesh::DistributedMesh::add_node(), libMesh::ReplicatedMesh::add_point(), libMesh::C0Polyhedron::disconnected_clone(), libMesh::Elem::disconnected_clone(), libMesh::Elem::get_info(), libMesh::ReplicatedMesh::insert_elem(), libMesh::DistributedMesh::insert_elem(), libMesh::ReplicatedMesh::insert_node(), and libMesh::DofObject::unique_id().

894 {
895 #ifdef LIBMESH_ENABLE_UNIQUE_ID
897 #else
898  return false;
899 #endif
900 }
static constexpr unique_id_type invalid_unique_id
An invalid unique_id to distinguish an uninitialized DofObject.
Definition: dof_object.h:487
unique_id_type _unique_id
A globally unique id, guaranteed not to change as the mesh is repartitioned or adapted.
Definition: dof_object.h:577

◆ var_to_vg_and_offset()

std::pair< unsigned int, unsigned int > libMesh::DofObject::var_to_vg_and_offset ( const unsigned int  s,
const unsigned int  var 
) const
inlineinherited
Returns
A pair consisting of the variable group number and the offset index from the start of that group for variable var on system s associated with this DofObject

Definition at line 1200 of file dof_object.h.

References libMesh::DofObject::n_var_groups(), and libMesh::DofObject::n_vars().

Referenced by libMesh::DofMap::_dof_indices(), libMesh::DofMap::_node_dof_indices(), libMesh::DofObject::dof_number(), libMesh::OldSolutionCoefs< Output, point_output >::eval_old_dofs(), and libMesh::OldSolutionValue< Output, point_output >::eval_old_dofs().

1202 {
1203  std::pair<unsigned int, unsigned int> returnval(0,0);
1204 
1205  unsigned int & vg = returnval.first;
1206  unsigned int & offset = returnval.second;
1207 
1208  unsigned int vg_start = 0;
1209  for (; ; vg++)
1210  {
1211  libmesh_assert_less(vg, this->n_var_groups(s));
1212 
1213  const unsigned int vg_end = vg_start + this->n_vars(s,vg);
1214  if (var < vg_end)
1215  {
1216  offset = var - vg_start;
1217  return returnval;
1218  }
1219  vg_start = vg_end;
1220  }
1221 }
unsigned int n_var_groups(const unsigned int s) const
Definition: dof_object.h:957
unsigned int n_vars(const unsigned int s, const unsigned int vg) const
Definition: dof_object.h:967

◆ vertex_average()

Point libMesh::Elem::vertex_average ( ) const
inherited
Returns
A Point at the average of the elment's vertices.
Note
This used to be the base class centroid() implementation, but the centroid is only equal to the vertex average in some special cases. The centroid() implementation now returns the "true" centroid of the element (up to quadrature error).

Definition at line 686 of file elem.C.

References libMesh::TypeVector< T >::add(), and libMesh::Elem::n_vertices().

Referenced by libMesh::Elem::centroid(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::BoundaryInfo::get_side_and_node_maps(), libMesh::Poly2TriTriangulator::insert_refinement_points(), A0::interior_assembly(), A1::interior_assembly(), OutputAssembly::interior_assembly(), SlitFunc::operator()(), libMesh::LocationMap< T >::point_of(), libMesh::RBParametrizedFunction::preevaluate_parametrized_function_on_mesh(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::C0Polygon::retriangulate(), libMesh::FE< Dim, LAGRANGE_VEC >::shape_deriv(), libMesh::FE< Dim, LAGRANGE_VEC >::shape_second_deriv(), libMesh::C0Polygon::side_vertex_average_normal(), DefaultCouplingTest::testCoupling(), PointNeighborCouplingTest::testCoupling(), libMesh::Tri3::true_centroid(), and libMesh::Tet4::true_centroid().

687 {
688  Point cp;
689 
690  const auto n_vertices = this->n_vertices();
691 
692  for (unsigned int n=0; n<n_vertices; n++)
693  cp.add (this->point(n));
694 
695  return (cp /= static_cast<Real>(n_vertices));
696 }
virtual unsigned int n_vertices() const =0

◆ vg_dof_base()

dof_id_type libMesh::DofObject::vg_dof_base ( const unsigned int  s,
const unsigned int  vg 
) const
inlineinherited

VariableGroup DoF indices are indexed as id = base + var_in_vg*ncomp + comp This method allows for direct access to the base.

Definition at line 1317 of file dof_object.h.

References libMesh::DofObject::_idx_buf, libMesh::DofObject::n_systems(), libMesh::DofObject::n_var_groups(), and libMesh::DofObject::start_idx().

Referenced by libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DofMap::reinit(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::DofObject::set_vg_dof_base(), and DofObjectTest< Node >::testManualDofCalculation().

1319 {
1320  libmesh_assert_less (s, this->n_systems());
1321  libmesh_assert_less (vg, this->n_var_groups(s));
1322 
1323  const unsigned int
1324  start_idx_sys = this->start_idx(s);
1325 
1326  libmesh_assert_less ((start_idx_sys + 2*vg + 1), _idx_buf.size());
1327 
1328  // #ifdef DEBUG
1329  // std::cout << " [ ";
1330  // for (auto i : _idx_buf)
1331  // std::cout << i << " ";
1332  // std::cout << "]\n";
1333  // #endif
1334 
1335  return _idx_buf[start_idx_sys + 2*vg + 1];
1336 }
unsigned int n_var_groups(const unsigned int s) const
Definition: dof_object.h:957
unsigned int n_systems() const
Definition: dof_object.h:937
unsigned int start_idx(const unsigned int s) const
The starting index for system s.
Definition: dof_object.h:1249
index_buffer_t _idx_buf
Definition: dof_object.h:680

◆ volume()

Real libMesh::Pyramid5::volume ( ) const
overridevirtual

Specialization for computing the volume of a pyramid.

Reimplemented from libMesh::Elem.

Definition at line 246 of file cell_pyramid5.C.

References libMesh::Elem::point(), and libMesh::triple_product().

247 {
248  // The pyramid with a bilinear base has volume given by the
249  // formula in: "Calculation of the Volume of a General Hexahedron
250  // for Flow Predictions", AIAA Journal v.23, no.6, 1984, p.954-
251  Point
252  x0 = point(0), x1 = point(1), x2 = point(2),
253  x3 = point(3), x4 = point(4);
254 
255  // Construct various edge and diagonal vectors.
256  Point v40 = x0 - x4;
257  Point v13 = x3 - x1;
258  Point v02 = x2 - x0;
259  Point v03 = x3 - x0;
260  Point v01 = x1 - x0;
261 
262  // Finally, ready to return the volume!
263  return
264  triple_product(v40, v13, v02) / 6. +
265  triple_product(v02, v01, v03) / 12.;
266 }
T triple_product(const TypeVector< T > &a, const TypeVector< T > &b, const TypeVector< T > &c)
Definition: type_vector.h:1029
const Point & point(const unsigned int i) const
Definition: elem.h:2454

◆ which_child_am_i()

unsigned int libMesh::Elem::which_child_am_i ( const Elem e) const
inlineinherited
Returns
The child index which e corresponds to.

I.e. if c = a->which_child_am_i(e); then a->child_ptr(c) will be e.

Definition at line 3193 of file elem.h.

References libMesh::Elem::child_ptr(), libMesh::Elem::has_children(), libMesh::invalid_uint, libMesh::libmesh_assert(), and libMesh::Elem::n_children().

Referenced by libMesh::BoundaryInfo::boundary_ids(), libMesh::BoundaryInfo::edge_boundary_ids(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::Elem::make_links_to_me_remote(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectVertices::operator()(), libMesh::BoundaryInfo::side_boundary_ids(), libMesh::BoundaryInfo::side_with_boundary_id(), libMesh::BoundaryInfo::sides_with_boundary_id(), libMesh::MeshTools::Modification::smooth(), and libMesh::Parallel::sync_element_data_by_parent_id().

3194 {
3195  libmesh_assert(e);
3196  libmesh_assert (this->has_children());
3197 
3198  unsigned int nc = this->n_children();
3199  for (unsigned int c=0; c != nc; c++)
3200  if (this->child_ptr(c) == e)
3201  return c;
3202 
3203  libmesh_error_msg("ERROR: which_child_am_i() was called with a non-child!");
3204 
3205  return libMesh::invalid_uint;
3206 }
const unsigned int invalid_uint
A number which is used quite often to represent an invalid or uninitialized value for an unsigned int...
Definition: libmesh.h:310
virtual unsigned int n_children() const =0
libmesh_assert(ctx)
bool has_children() const
Definition: elem.h:2980
const Elem * child_ptr(unsigned int i) const
Definition: elem.h:3164

◆ which_neighbor_am_i()

unsigned int libMesh::Elem::which_neighbor_am_i ( const Elem e) const
inlineinherited

This function tells you which neighbor e is.

I.e. if s = a->which_neighbor_am_i(e); then a->neighbor(s) will be an ancestor of e.

Definition at line 2920 of file elem.h.

References libMesh::invalid_uint, libMesh::Elem::level(), libMesh::libmesh_assert(), libMesh::make_range(), libMesh::Elem::n_sides(), libMesh::Elem::neighbor_ptr(), and libMesh::Elem::parent().

Referenced by assemble_ellipticdg(), libMesh::EquationSystems::build_discontinuous_solution_vector(), libMesh::BoundaryInfo::clear_stitched_boundary_side_ids(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_proj_constraints(), libMesh::MeshTools::find_hanging_nodes_and_parents(), libMesh::Poly2TriTriangulator::insert_refinement_points(), libMesh::Elem::libmesh_assert_valid_neighbors(), libMesh::Elem::nullify_neighbors(), libMesh::C0Polyhedron::retriangulate(), and MeshBaseTest::testMeshBaseVerifyIsPrepared().

2921 {
2922  libmesh_assert(e);
2923 
2924  const Elem * eparent = e;
2925 
2926  while (eparent->level() > this->level())
2927  {
2928  eparent = eparent->parent();
2929  libmesh_assert(eparent);
2930  }
2931 
2932  for (auto s : make_range(this->n_sides()))
2933  if (this->neighbor_ptr(s) == eparent)
2934  return s;
2935 
2936  return libMesh::invalid_uint;
2937 }
const unsigned int invalid_uint
A number which is used quite often to represent an invalid or uninitialized value for an unsigned int...
Definition: libmesh.h:310
libmesh_assert(ctx)
Elem(const unsigned int n_nodes, const unsigned int n_sides, Elem *parent, Elem **elemlinkdata, Node **nodelinkdata)
Constructor.
Definition: elem.h:2379
virtual unsigned int n_sides() const =0
const Elem * neighbor_ptr(unsigned int i) const
Definition: elem.h:2599
unsigned int level() const
Definition: elem.h:3075
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140

◆ which_node_am_i()

unsigned int libMesh::Elem::which_node_am_i ( unsigned int  side,
unsigned int  side_node 
) const
inherited

This function is deprecated, call local_side_node(side, side_node) instead.

Definition at line 922 of file elem.C.

References libMesh::Elem::local_side_node().

924 {
925  libmesh_deprecated();
926  return local_side_node(side, side_node);
927 }
virtual unsigned int local_side_node(unsigned int side, unsigned int side_node) const =0

◆ which_side_am_i()

unsigned int libMesh::Elem::which_side_am_i ( const Elem e) const
inherited

This function tells you which side the boundary element e is.

I.e. if e = a->build_side_ptr(s) or e = a->side_ptr(s); then a->which_side_am_i(e) will be s.

Note
An exact floating point comparison of the nodal positions of e is made with the nodal positions of this in order to perform this test. The idea is that the test will return a valid side id if e either directly shares Node pointers with this, or was created by exactly copying some of the nodes of this (e.g. through BoundaryMesh::sync()). In these circumstances, non-fuzzy floating point equality is expected.
Returns
The side of this the element which e is, otherwise invalid_uint.

Definition at line 868 of file elem.C.

References libMesh::invalid_uint, libMesh::Elem::is_node_on_side(), libMesh::libmesh_assert(), libMesh::Elem::n_nodes(), libMesh::Elem::n_sides(), and libMesh::Elem::point().

869 {
870  libmesh_assert(e);
871 
872  const unsigned int ns = this->n_sides();
873  const unsigned int nn = this->n_nodes();
874 
875  const unsigned int en = e->n_nodes();
876 
877  // e might be on any side until proven otherwise
878  std::vector<bool> might_be_side(ns, true);
879 
880  for (unsigned int i=0; i != en; ++i)
881  {
882  Point side_point = e->point(i);
883  unsigned int local_node_id = libMesh::invalid_uint;
884 
885  // Look for a node of this that's contiguous with node i of
886  // e. Note that the exact floating point comparison of Point
887  // positions is intentional, see the class documentation for
888  // this function.
889  for (unsigned int j=0; j != nn; ++j)
890  if (this->point(j) == side_point)
891  local_node_id = j;
892 
893  // If a node of e isn't contiguous with some node of this, then
894  // e isn't a side of this.
895  if (local_node_id == libMesh::invalid_uint)
896  return libMesh::invalid_uint;
897 
898  // If a node of e isn't contiguous with some node on side s of
899  // this, then e isn't on side s.
900  for (unsigned int s=0; s != ns; ++s)
901  if (!this->is_node_on_side(local_node_id, s))
902  might_be_side[s] = false;
903  }
904 
905  for (unsigned int s=0; s != ns; ++s)
906  if (might_be_side[s])
907  {
908 #ifdef DEBUG
909  for (unsigned int s2=s+1; s2 < ns; ++s2)
910  libmesh_assert (!might_be_side[s2]);
911 #endif
912  return s;
913  }
914 
915  // Didn't find any matching side
916  return libMesh::invalid_uint;
917 }
const unsigned int invalid_uint
A number which is used quite often to represent an invalid or uninitialized value for an unsigned int...
Definition: libmesh.h:310
virtual bool is_node_on_side(const unsigned int n, const unsigned int s) const =0
virtual unsigned int n_nodes() const =0
libmesh_assert(ctx)
virtual unsigned int n_sides() const =0
const Point & point(const unsigned int i) const
Definition: elem.h:2454

◆ write_connectivity()

void libMesh::Elem::write_connectivity ( std::ostream &  out,
const IOPackage  iop 
) const
inherited

Writes the element connectivity for various IO packages to the passed ostream "out".

Not virtual, since it is implemented in the base class.

Definition at line 1729 of file elem.C.

References libMesh::Elem::_nodes, libMesh::Elem::connectivity(), libMesh::INVALID_IO_PACKAGE, libMesh::libmesh_assert(), libMesh::make_range(), libMesh::Elem::n_sub_elem(), libMesh::Elem::node_id(), libMesh::Elem::node_index_range(), libMesh::TECPLOT, and libMesh::UCD.

1731 {
1732  libmesh_assert (out_stream.good());
1734  libmesh_assert_not_equal_to (iop, INVALID_IO_PACKAGE);
1735 
1736  switch (iop)
1737  {
1738  case TECPLOT:
1739  {
1740  // This connectivity vector will be used repeatedly instead
1741  // of being reconstructed inside the loop.
1742  std::vector<dof_id_type> conn;
1743  for (auto sc : make_range(this->n_sub_elem()))
1744  {
1745  this->connectivity(sc, TECPLOT, conn);
1746 
1747  std::copy(conn.begin(),
1748  conn.end(),
1749  std::ostream_iterator<dof_id_type>(out_stream, " "));
1750 
1751  out_stream << '\n';
1752  }
1753  return;
1754  }
1755 
1756  case UCD:
1757  {
1758  for (auto i : this->node_index_range())
1759  out_stream << this->node_id(i)+1 << "\t";
1760 
1761  out_stream << '\n';
1762  return;
1763  }
1764 
1765  default:
1766  libmesh_error_msg("Unsupported IO package " << iop);
1767  }
1768 }
Node ** _nodes
Pointers to the nodes we are connected to.
Definition: elem.h:2246
libmesh_assert(ctx)
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140
virtual void connectivity(const unsigned int sc, const IOPackage iop, std::vector< dof_id_type > &conn) const =0
IntRange< unsigned short > node_index_range() const
Definition: elem.h:2684
virtual unsigned int n_sub_elem() const =0
dof_id_type node_id(const unsigned int i) const
Definition: elem.h:2476

Member Data Documentation

◆ _children

std::unique_ptr<Elem *[]> libMesh::Elem::_children
protectedinherited

unique_ptr to array of this element's children.

A Mesh ultimately owns the child Elems so we are not responsible for deleting them, but we are responsible for cleaning up the array allocated to hold those Elems, hence the unique_ptr.

Definition at line 2262 of file elem.h.

Referenced by libMesh::Elem::add_child(), libMesh::Elem::child_ptr(), libMesh::Elem::child_ref_range(), libMesh::Elem::contract(), libMesh::Elem::has_ancestor_children(), libMesh::Elem::has_children(), libMesh::Elem::raw_child_ptr(), libMesh::Elem::refine(), and libMesh::Elem::set_child().

◆ _counts [1/2]

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts
staticprotectedinherited

Actually holds the data.

Definition at line 124 of file reference_counter.h.

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

◆ _counts [2/2]

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts
staticprotectedinherited

Actually holds the data.

Definition at line 124 of file reference_counter.h.

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

◆ _elemlinks

Elem** libMesh::Elem::_elemlinks
protectedinherited

◆ _elemlinks_data

Elem* libMesh::Pyramid::_elemlinks_data[6+(LIBMESH_DIM >3)]
protectedinherited

Data for links to parent/neighbor/interior_parent elements.

Definition at line 209 of file cell_pyramid.h.

◆ _enable_print_counter [1/2]

bool libMesh::ReferenceCounter::_enable_print_counter = true
staticprotectedinherited

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

Definition at line 143 of file reference_counter.h.

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

◆ _enable_print_counter [2/2]

bool libMesh::ReferenceCounter::_enable_print_counter = true
staticprotectedinherited

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

Definition at line 143 of file reference_counter.h.

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

◆ _map_data

unsigned char libMesh::Elem::_map_data
protectedinherited

Mapping function data; currently used when needed to store the RATIONAL_BERNSTEIN nodal weight data index.

Definition at line 2304 of file elem.h.

Referenced by libMesh::Elem::Elem(), libMesh::Elem::mapping_data(), libMesh::Polygon::Polygon(), libMesh::Polyhedron::Polyhedron(), and libMesh::Elem::set_mapping_data().

◆ _map_type

unsigned char libMesh::Elem::_map_type
protectedinherited

Mapping function type; currently either 0 (LAGRANGE) or 1 (RATIONAL_BERNSTEIN).

Definition at line 2298 of file elem.h.

Referenced by libMesh::Elem::Elem(), libMesh::Elem::mapping_type(), libMesh::Polygon::Polygon(), libMesh::Polyhedron::Polyhedron(), and libMesh::Elem::set_mapping_type().

◆ _master_points

const Real libMesh::Pyramid::_master_points
staticprotectedinherited
Initial value:
=
{
{-1, -1, 0},
{1, -1, 0},
{1, 1, 0},
{-1, 1, 0},
{0, 0, 1},
{0, -1, 0},
{1, 0, 0},
{0, 1, 0},
{-1, 0, 0},
{0, -0.5, 0.5},
{0.5, 0, 0.5},
{0, 0.5, 0.5},
{-0.5, 0, 0.5},
{0, 0, 0}
}

Master element node locations.

Definition at line 214 of file cell_pyramid.h.

Referenced by libMesh::Pyramid::master_point().

◆ _mutex [1/2]

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

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 137 of file reference_counter.h.

◆ _mutex [2/2]

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

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 137 of file reference_counter.h.

◆ _n_objects [1/2]

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

The number of objects.

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

Definition at line 132 of file reference_counter.h.

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

◆ _n_objects [2/2]

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

The number of objects.

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

Definition at line 132 of file reference_counter.h.

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

◆ _nodelinks_data

Node* libMesh::Pyramid5::_nodelinks_data[num_nodes]
protected

Data for links to nodes.

Definition at line 207 of file cell_pyramid5.h.

◆ _nodes

Node** libMesh::Elem::_nodes
protectedinherited

◆ _p_level

unsigned char libMesh::Elem::_p_level
protectedinherited

p refinement level - the difference between the polynomial degree on this element and the minimum polynomial degree on the mesh.

This is stored as an unsigned char to save space. In theory, these last four bytes might have been padding anyway.

Definition at line 2291 of file elem.h.

Referenced by libMesh::Elem::hack_p_level(), libMesh::Elem::max_descendant_p_level(), libMesh::Elem::p_level(), and libMesh::Elem::set_p_level().

◆ _pflag

unsigned char libMesh::Elem::_pflag
protectedinherited

p refinement flag.

This is stored as an unsigned char to save space.

Definition at line 2281 of file elem.h.

Referenced by libMesh::Elem::hack_p_level_and_refinement_flag(), libMesh::Elem::p_refinement_flag(), and libMesh::Elem::set_p_refinement_flag().

◆ _rflag

unsigned char libMesh::Elem::_rflag
protectedinherited

h refinement flag.

This is stored as an unsigned char to save space.

Definition at line 2275 of file elem.h.

Referenced by libMesh::Elem::refinement_flag(), and libMesh::Elem::set_refinement_flag().

◆ _sbd_id

subdomain_id_type libMesh::Elem::_sbd_id
protectedinherited

The subdomain to which this element belongs.

Definition at line 2268 of file elem.h.

Referenced by libMesh::Elem::subdomain_id().

◆ adjacent_edges_map

const unsigned int libMesh::Pyramid::adjacent_edges_map
staticprotectedinherited
Initial value:
=
{
{0, 3, 4, 99},
{0, 1, 5, 99},
{1, 2, 6, 99},
{2, 3, 7, 99},
{4, 5, 6, 7}
}

This maps the \( j^{th} \) node to the 3 or 4 edge ids adjacent to the node.

The edge numbering matches the ones used in the derived classes' edge_nodes_map. An edge index of 99 is used to indicate that there is no adjacent edge. This data structure is used in the Pyramid::edges_adjacent_to_node() override and is shared by all the derived Hex types.

Definition at line 235 of file cell_pyramid.h.

Referenced by libMesh::Pyramid::edges_adjacent_to_node().

◆ affine_tol

constexpr Real libMesh::Elem::affine_tol = TOLERANCE*TOLERANCE
staticprotectedinherited

◆ edge_nodes_map

const unsigned int libMesh::Pyramid5::edge_nodes_map
static
Initial value:
=
{
{0, 1},
{1, 2},
{2, 3},
{0, 3},
{0, 4},
{1, 4},
{2, 4},
{3, 4}
}

This maps the \( j^{th} \) node of the \( i^{th} \) edge to element node numbers.

Definition at line 176 of file cell_pyramid5.h.

Referenced by is_node_on_edge(), libMesh::Pyramid::local_edge_node(), and nodes_on_edge().

◆ edge_sides_map

const unsigned int libMesh::Pyramid::edge_sides_map
staticinherited
Initial value:
=
{
{0, 4},
{1, 4},
{2, 4},
{3, 4},
{0, 3},
{0, 1},
{1, 2},
{2, 3}
}

This maps each edge to the sides that contain said edge.

Definition at line 199 of file cell_pyramid.h.

Referenced by libMesh::Pyramid::is_edge_on_side(), and libMesh::Pyramid::sides_on_edge().

◆ invalid_id

constexpr dof_id_type libMesh::DofObject::invalid_id = static_cast<dof_id_type>(-1)
staticinherited

An invalid id to distinguish an uninitialized DofObject.

Definition at line 482 of file dof_object.h.

Referenced by libMesh::DofMap::_dof_indices(), libMesh::DofMap::_node_dof_indices(), libMesh::Node::active(), libMesh::MeshBase::add_elem_datum(), libMesh::MeshBase::add_elem_integers(), libMesh::DofObject::add_extra_integers(), libMesh::StaticCondensation::add_matrix(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::TopologyMap::add_node(), libMesh::MeshRefinement::add_node(), libMesh::MeshBase::add_node_datum(), libMesh::MeshBase::add_node_integers(), libMesh::ReplicatedMesh::add_point(), libMesh::MeshTools::Modification::all_tri(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::DofMap::assert_no_nodes_missed(), libMesh::Elem::bracketing_nodes(), ExtraIntegersTest::checkpoint_helper(), libMesh::StaticCondensation::clear(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_proj_constraints(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DofMap::dof_indices(), libMesh::DofObject::dof_number(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_nodes(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_sides(), libMesh::OldSolutionValue< Output, point_output >::eval_old_dofs(), libMesh::TopologyMap::find(), libMesh::DofMap::gather_constraints(), libMesh::MeshBase::get_elemset_code(), libMesh::ReplicatedMesh::insert_node(), libMesh::Poly2TriTriangulator::insert_refinement_points(), libMesh::Elem::interior_parent(), libMesh::DofObject::invalidate_dofs(), libMesh::DofObject::invalidate_id(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::Node::Node(), libMesh::Elem::node_id(), libMesh::DofMap::old_dof_indices(), libMesh::DistributedMesh::own_node(), libMesh::XdrIO::pack_element(), libMesh::SFCPartitioner::partition_range(), libMesh::Elem::point(), libMesh::ExodusII_IO::read(), libMesh::System::read_legacy_data(), libMesh::DynaIO::read_mesh(), libMesh::System::read_parallel_data(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::StaticCondensationDofMap::reinit(), libMesh::DofMap::SCALAR_dof_indices(), libMesh::DofObject::set_dof_number(), libMesh::DofObject::set_n_comp_group(), libMesh::DofObject::set_n_vars_per_group(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Parallel::sync_node_data_by_element_id_once(), ExtraIntegersTest::test_and_set_initial_data(), DofObjectTest< Node >::testAddExtraData(), DofObjectTest< Node >::testAddSystemExtraInts(), ExtraIntegersTest::testExtraIntegersExodusReading(), InfFERadialTest::testRefinement(), DofObjectTest< Node >::testSetNSystemsExtraInts(), DofObjectTest< Node >::testSetNVariableGroupsExtraInts(), MeshTetTest::testTetInterfaceBase(), DofObjectTest< Node >::testValidId(), MeshSmootherTest::testVariationalSmoother(), WriteElemsetData::testWriteImpl(), libMesh::NetGenMeshInterface::triangulate(), libMesh::Poly2TriTriangulator::triangulate_current_points(), libMesh::DofObject::valid_id(), libMesh::System::write_parallel_data(), and libMesh::XdrIO::write_serialized_connectivity().

◆ invalid_processor_id

constexpr processor_id_type libMesh::DofObject::invalid_processor_id = static_cast<processor_id_type>(-1)
staticinherited

An invalid processor_id to distinguish DoFs that have not been assigned to a processor.

Definition at line 493 of file dof_object.h.

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::DistributedMesh::add_elem(), libMesh::DistributedMesh::add_node(), libMesh::MeshRefinement::add_node(), libMesh::MeshCommunication::allgather(), libMesh::Node::choose_processor_id(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubProjector::construct_projection(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::MeshTools::create_bounding_box(), libMesh::MeshTools::create_nodal_bounding_box(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::Elem::Elem(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::find_dofs_to_send(), libMesh::MeshCommunication::find_global_indices(), libMesh::MeshBase::get_info(), libMesh::DistributedMesh::insert_elem(), libMesh::DofObject::invalidate_processor_id(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::MeshCommunication::make_new_node_proc_ids_parallel_consistent(), libMesh::DistributedMesh::n_active_elem(), libMesh::MeshBase::n_constraint_rows(), libMesh::MeshBase::n_elem_on_proc(), libMesh::MeshBase::n_nodes_on_proc(), libMesh::MeshBase::n_unpartitioned_elem(), libMesh::MeshBase::n_unpartitioned_nodes(), libMesh::SparsityPattern::Build::operator()(), libMesh::Partitioner::processor_pairs_to_interface_nodes(), libMesh::Nemesis_IO_Helper::read_var_names_impl(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DistributedMesh::renumber_nodes_and_elements(), OverlappingFunctorTest::run_coupling_functor_test(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::send_and_insert_dof_values(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::Parallel::sync_dofobject_data_by_id(), libMesh::Parallel::sync_dofobject_data_by_xyz(), libMesh::Parallel::sync_element_data_by_parent_id(), libMesh::Parallel::sync_node_data_by_element_id_once(), DofObjectTest< Node >::testValidProcId(), libMesh::MeshTools::total_weight(), libMesh::DofObject::valid_processor_id(), and libMesh::CheckpointIO::write().

◆ invalid_subdomain_id

constexpr subdomain_id_type libMesh::Elem::invalid_subdomain_id = std::numeric_limits<subdomain_id_type>::max()
staticinherited

A static integral constant representing an invalid subdomain id.

See also DofObject::{invalid_id, invalid_unique_id, invalid_processor_id}.

Note
We don't use the static_cast(-1) trick here since subdomain_id_type is sometimes a signed integer for compatibility reasons (see libmesh/id_types.h).

Definition at line 246 of file elem.h.

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::BoundaryInfo::add_elements(), libMesh::ReplicatedMesh::get_disconnected_subdomains(), libMesh::MeshBase::get_id_by_name(), libMesh::BoundaryInfo::sync(), and MeshSubdomainIDTest::testMultiple().

◆ invalid_unique_id

constexpr unique_id_type libMesh::DofObject::invalid_unique_id = static_cast<unique_id_type>(-1)
staticinherited

An invalid unique_id to distinguish an uninitialized DofObject.

Definition at line 487 of file dof_object.h.

Referenced by libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DofObject::unique_id(), and libMesh::DofObject::valid_unique_id().

◆ LIBMESH_ENABLE_TOPOLOGY_CACHES

libMesh::Pyramid5::LIBMESH_ENABLE_TOPOLOGY_CACHES
protected

Definition at line 221 of file cell_pyramid5.h.

◆ max_n_nodes

const unsigned int libMesh::Elem::max_n_nodes = 27
staticinherited

The maximum number of nodes any element can contain.

This is useful for replacing heap vectors with stack arrays.

Definition at line 656 of file elem.h.

Referenced by libMesh::Elem::Elem(), and ElemTest< elem_type >::test_static_data().

◆ nodes_per_edge

const int libMesh::Pyramid5::nodes_per_edge = 2
static

Definition at line 164 of file cell_pyramid5.h.

Referenced by libMesh::Pyramid::local_edge_node().

◆ nodes_per_side

const int libMesh::Pyramid5::nodes_per_side = 4
static

Definition at line 163 of file cell_pyramid5.h.

Referenced by libMesh::Pyramid::local_side_node().

◆ num_children

const int libMesh::Pyramid::num_children = 0
staticinherited

Definition at line 79 of file cell_pyramid.h.

◆ num_edges

const int libMesh::Pyramid::num_edges = 8
staticinherited

Definition at line 78 of file cell_pyramid.h.

◆ num_nodes

const int libMesh::Pyramid5::num_nodes = 5
static

Geometric constants for Pyramid5.

Definition at line 162 of file cell_pyramid5.h.

◆ num_sides

const int libMesh::Pyramid::num_sides = 5
staticinherited

Geometric constants for all Pyramids.

Definition at line 77 of file cell_pyramid.h.

Referenced by libMesh::Pyramid14::center_node_on_side(), and libMesh::Pyramid18::center_node_on_side().

◆ old_dof_object

std::unique_ptr<DofObject> libMesh::DofObject::old_dof_object
protectedinherited

This object on the last mesh.

Useful for projecting solutions from one mesh to another.

Public access to old_dof_object is now officially deprecated and will be removed in future libMesh versions. Use the get_old_dof_object() accessor instead.

Definition at line 88 of file dof_object.h.

Referenced by libMesh::DofObject::clear_old_dof_object(), libMesh::DofObject::get_old_dof_object(), libMesh::DofObject::get_old_dof_object_ref(), libMesh::DofObject::operator=(), libMesh::DofObject::pack_indexing(), libMesh::DofObject::packed_indexing_size(), libMesh::DofObject::set_old_dof_object(), and libMesh::DofObject::unpack_indexing().

◆ side_nodes_map

const unsigned int libMesh::Pyramid5::side_nodes_map
static
Initial value:
=
{
{0, 1, 4, 99},
{1, 2, 4, 99},
{2, 3, 4, 99},
{3, 0, 4, 99},
{0, 3, 2, 1}
}

This maps the \( j^{th} \) node of the \( i^{th} \) side to element node numbers.

Definition at line 170 of file cell_pyramid5.h.

Referenced by build_side_ptr(), libMesh::Pyramid::is_child_on_side(), is_node_on_side(), libMesh::Pyramid::key(), libMesh::Pyramid::local_side_node(), libMesh::Pyramid::low_order_key(), nodes_on_side(), libMesh::Pyramid::side_ptr(), and side_vertex_average_normal().

◆ type_to_default_order_map

const Order libMesh::Elem::type_to_default_order_map
staticinherited

This array maps the integer representation of the ElemType enum to the default approximation order of elements of that type.

This is currently usable even for complicated subclasses with runtime-varying topology.

Definition at line 992 of file elem.h.

Referenced by NodalNeighborsTest::do_test(), SystemsTest::test2DProjectVectorFE(), SystemsTest::test3DProjectVectorFE(), ElemTest< elem_type >::test_static_data(), and MeshSmootherTest::testVariationalSmoother().

◆ type_to_dim_map

const unsigned int libMesh::Elem::type_to_dim_map
staticinherited

This array maps the integer representation of the ElemType enum to the geometric dimension of the element.

This is currently usable even for complicated subclasses with runtime-varying topology.

Definition at line 630 of file elem.h.

Referenced by FETestBase< order, family, elem_type, 1 >::setUp(), SystemsTest::test2DProjectVectorFE(), SystemsTest::test3DProjectVectorFE(), ElemTest< elem_type >::test_static_data(), and PointLocatorTest::testLocator().

◆ type_to_n_edges_map

const unsigned int libMesh::Elem::type_to_n_edges_map
staticinherited

This array maps the integer representation of the ElemType enum to the number of edges on the element.

This is only usable for simple types for which the node number is fixed; for more general types like Polygon subclasses an actual instantiated Elem must be queried.

Definition at line 744 of file elem.h.

Referenced by ElemTest< elem_type >::test_static_data().

◆ type_to_n_nodes_map

const unsigned int libMesh::Elem::type_to_n_nodes_map
staticinherited

This array maps the integer representation of the ElemType enum to the number of nodes in the element.

This is only usable for simple types for which the node number is fixed; for more general types like Polygon subclasses an actual instantiated Elem must be queried.

Definition at line 645 of file elem.h.

Referenced by libMesh::DynaIO::ElementDefinition::ElementDefinition(), libMesh::FEAbstract::get_refspace_nodes(), libMesh::XdrIO::pack_element(), libMesh::CheckpointIO::read_connectivity(), libMesh::XdrIO::read_serialized_connectivity(), ElemTest< elem_type >::test_static_data(), MeshGenerationTest::testBuildCube(), MeshGenerationTest::testBuildLine(), and libMesh::ExodusII_IO_Helper::write_elements().

◆ type_to_n_sides_map

const unsigned int libMesh::Elem::type_to_n_sides_map
staticinherited

This array maps the integer representation of the ElemType enum to the number of sides on the element.

This is only usable for simple types for which the node number is fixed; for more general types like Polygon subclasses an actual instantiated Elem must be queried.

Definition at line 680 of file elem.h.

Referenced by ElemTest< elem_type >::test_static_data(), MeshGenerationTest::testBuildCube(), and MeshGenerationTest::testBuildSquare().


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