libMesh
Loading...
Searching...
No Matches
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 | Private Types | Private Member Functions | Private Attributes | Static Private Attributes | List of all members
libMesh::Quad9 Class Reference

The QUAD9 is an element in 2D composed of 9 nodes. More...

#include <face_quad9.h>

Inheritance diagram for libMesh::Quad9:
[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.
 
typedef const Elem *const * ConstNeighborPtrIter
 
typedef Predicates::multi_predicate Predicate
 Useful iterator typedefs.
 

Public Member Functions

 Quad9 (Elem *p=nullptr)
 Constructor.
 
 Quad9 (Quad9 &&)=delete
 
 Quad9 (const Quad9 &)=delete
 
Quad9 & operator= (const Quad9 &)=delete
 
Quad9 & operator= (Quad9 &&)=delete
 
virtual ~Quad9 ()=default
 
virtual ElemType type () const override
 
virtual unsigned int n_nodes () 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 int > nodes_on_side (const unsigned int s) const override
 
virtual std::vector< unsigned int > nodes_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 dof_id_type key (const unsigned int s) const override
 
virtual dof_id_type key () const override
 Compute a unique key for this element which is suitable for hashing (not necessarily unique, but close).
 
virtual unsigned int local_side_node (unsigned int side, unsigned int side_node) const override
 
virtual std::unique_ptr< Elem > build_side_ptr (const unsigned int i) override
 
virtual void build_side_ptr (std::unique_ptr< Elem > &elem, const unsigned int i) override
 Rebuilds an EDGE3 coincident with face i.
 
virtual void connectivity (const unsigned int sf, const IOPackage iop, std::vector< dof_id_type > &conn) const override
 
virtual unsigned int n_second_order_adjacent_vertices (const unsigned int n) const override
 
virtual unsigned short int second_order_adjacent_vertex (const unsigned int n, const unsigned int v) const override
 
virtual std::pair< unsigned short int, unsigned short int > second_order_child_vertex (const unsigned int n) const override
 
virtual Real volume () const override
 An optimized method for approximating the area of a QUAD9 using quadrature.
 
virtual BoundingBox loose_bounding_box () const override
 
virtual void permute (unsigned int perm_num) override final
 Permutes the element (by swapping node and neighbor pointers) according to the specified index.
 
virtual void flip (BoundaryInfo *) override final
 Flips the element (by swapping node and neighbor pointers) to have a mapping Jacobian of opposite sign.
 
unsigned int center_node_on_side (const unsigned short side) const override final
 
ElemType side_type (const unsigned int s) const override final
 
virtual dof_id_type key (const unsigned int s) const=0
 Don't hide Elem::key() defined in the base class.
 
virtual dof_id_type key () const
 Don't hide Elem::key() defined in the base class.
 
virtual std::unique_ptr< Elem > build_side_ptr (const unsigned int i)=0
 
std::unique_ptr< const Elem > build_side_ptr (const unsigned int i) const
 
virtual std::unique_ptr< Elem > build_side_ptr (const unsigned int i, bool proxy)
 
std::unique_ptr< const Elem > build_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.
 
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 final
 
virtual unsigned int n_sides () const override final
 
virtual unsigned int n_vertices () const override final
 
virtual unsigned int n_edges () const override final
 
virtual unsigned int n_children () const override final
 
virtual bool is_child_on_side (const unsigned int c, const unsigned int s) const override final
 
virtual unsigned int opposite_side (const unsigned int s) const override final
 
virtual unsigned int opposite_node (const unsigned int n, const unsigned int s) const override final
 
virtual dof_id_type low_order_key (const unsigned int s) const override
 
virtual unsigned int local_edge_node (unsigned int edge, unsigned int edge_node) const override
 Calls local_side_node(edge, edge_node).
 
virtual std::unique_ptr< Elem > side_ptr (const unsigned int i) override final
 
virtual void side_ptr (std::unique_ptr< Elem > &elem, const unsigned int i) override final
 Rebuilds an EDGE2 coincident with face i.
 
std::unique_ptr< const Elem > side_ptr (unsigned int i) const
 
void side_ptr (std::unique_ptr< const Elem > &side, const unsigned int i) const
 
virtual Real quality (const ElemQuality q) const override
 
virtual std::pair< Real, Real > qual_bounds (const ElemQuality q) const override
 
virtual unsigned int n_permutations () const override final
 Four sides, one orientation each.
 
virtual bool is_flipped () const override final
 
virtual std::vector< unsigned int > edges_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 final
 
virtual unsigned int n_faces () const override final
 
virtual std::unique_ptr< Elem > build_edge_ptr (const unsigned int i) override final
 build_side and build_edge are identical for faces.
 
virtual void build_edge_ptr (std::unique_ptr< Elem > &edge, const unsigned int i) override final
 build_side and build_edge are identical for faces.
 
virtual std::unique_ptr< Elem > build_edge_ptr (const unsigned int i)=0
 For the const build_edge_ptr we use the parent method.
 
std::unique_ptr< const Elem > build_edge_ptr (const unsigned int i) const
 For the const build_edge_ptr we use the parent method.
 
virtual void build_edge_ptr (std::unique_ptr< Elem > &edge, const unsigned int i)=0
 For the const build_edge_ptr we use the parent method.
 
void build_edge_ptr (std::unique_ptr< const Elem > &edge, const unsigned int i) const
 For the const build_edge_ptr we use the parent method.
 
virtual bool is_edge_on_side (const unsigned int e, const unsigned int s) const override final
 is_edge_on_side is trivial in 2D.
 
virtual std::vector< unsigned int > sides_on_edge (const unsigned int e) const override final
 sides_on_edge is trivial in 2D.
 
virtual Point quasicircumcenter () const override
 
virtual bool infinite () const override final
 
const Point & point (const unsigned int i) const
 
Point & point (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 Node * node_ptr (const unsigned int i) const
 
Node * node_ptr (const unsigned int i)
 
const Node & node_ref (const unsigned int i) const
 
Node & node_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.
 
SimpleRange< NodeRefIter > node_ref_range ()
 Returns a range with all nodes of an element, usable in range-based for loops.
 
SimpleRange< ConstNodeRefIter > node_ref_range () const
 
subdomain_id_type subdomain_id () const
 
subdomain_id_type & subdomain_id ()
 
virtual bool runtime_topology () const
 
const Elem * reference_elem () const
 
bool operator== (const Elem &rhs) const
 
bool operator!= (const Elem &rhs) const
 
bool topologically_equal (const Elem &rhs) const
 
const Elem * neighbor_ptr (unsigned int i) const
 
Elem * neighbor_ptr (unsigned int i)
 
SimpleRange< NeighborPtrIter > neighbor_ptr_range ()
 Returns a range with all neighbors of an element, usable in range-based for loops.
 
SimpleRange< ConstNeighborPtrIter > neighbor_ptr_range () const
 
const Elem * topological_neighbor (const unsigned int i, const MeshBase &mesh, const PointLocatorBase &point_locator, const PeriodicBoundaries *pb) const
 
Elem * topological_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.
 
bool has_neighbor (const Elem *elem) const
 
Elem * child_neighbor (Elem *elem)
 
const Elem * child_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.
 
unsigned int which_side_am_i (const Elem *e) const
 This function tells you which side the boundary element e is.
 
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.
 
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.
 
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.
 
void find_point_neighbors (std::set< Elem * > &neighbor_set, Elem *start_elem)
 Non-const version of function above.
 
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.
 
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).
 
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.
 
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.
 
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.
 
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.
 
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.
 
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".
 
IntRange< unsigned short > node_index_range () const
 
virtual unsigned int n_nodes_in_child (unsigned int) const
 
virtual Point side_vertex_average_normal (const unsigned int s) 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 Order supported_nodal_order () const
 
virtual Order default_side_order () const
 
virtual Point true_centroid () const
 
Point vertex_average () const
 
virtual Real hmin () const
 
virtual Real hmax () 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
 
bool relative_edge_face_order (const unsigned int e, const unsigned int s) 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.
 
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.
 
std::string get_info () const
 Prints relevant information about the element to a string.
 
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 Elem * parent () const
 
Elem * parent ()
 
void set_parent (Elem *p)
 Sets the pointer to the element's parent.
 
const Elem * top_parent () const
 
const Elem * interior_parent () const
 
Elem * interior_parent ()
 
void set_interior_parent (Elem *p)
 Sets the pointer to the element's interior_parent.
 
Real length (const unsigned int n1, const unsigned int n2) 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.
 
unsigned char mapping_data () const
 
void set_mapping_data (const unsigned char data)
 Sets the value of the mapping data for the element.
 
const Elem * raw_child_ptr (unsigned int i) const
 
const Elem * child_ptr (unsigned int i) const
 
Elem * child_ptr (unsigned int i)
 
SimpleRange< ChildRefIter > child_ref_range ()
 Returns a range with all children of a parent element, usable in range-based for loops.
 
SimpleRange< ConstChildRefIter > child_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.
 
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.
 
void replace_child (Elem *elem, unsigned int c)
 Replaces the child pointer at the specified index in the child array.
 
void family_tree (std::vector< const Elem * > &family, bool reset=true) const
 Fills the vector family with the children of this element, recursively.
 
void family_tree (std::vector< Elem * > &family, bool reset=true)
 Non-const version of function above; fills a vector of non-const pointers.
 
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.
 
void total_family_tree (std::vector< Elem * > &family, bool reset=true)
 Non-const version of function above; fills a vector of non-const pointers.
 
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.
 
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.
 
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.
 
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.
 
void total_family_tree_by_side (std::vector< const Elem * > &family, unsigned int side, bool reset=true) const
 Same as the total_family_tree() member, but only adds elements which are next to side.
 
void total_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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
RefinementState refinement_flag () const
 
void set_refinement_flag (const RefinementState rflag)
 Sets the value of the refinement flag for the element.
 
RefinementState p_refinement_flag () const
 
void set_p_refinement_flag (const RefinementState pflag)
 Sets the value of the p-refinement flag for the element.
 
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.
 
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.
 
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.
 
virtual void refine (MeshRefinement &mesh_refinement)
 Refine the element.
 
void coarsen ()
 Coarsen the element.
 
void contract ()
 Contract an active element, i.e.
 
void libmesh_assert_valid_neighbors () const
 Checks for consistent neighbor links on this element.
 
void libmesh_assert_valid_node_pointers () const
 Checks for a valid id and pointers to nodes with valid ids on this element.
 
virtual unsigned int local_singular_node (const Point &, const Real=TOLERANCE *TOLERANCE) const
 
virtual bool is_singular_node (unsigned int) const
 
side_iterator boundary_sides_begin ()
 Iterator accessor functions.
 
side_iterator boundary_sides_end ()
 
virtual bool is_mid_infinite_edge_node (const unsigned int) const
 
virtual Point origin () const
 
virtual std::unique_ptr< Elem > disconnected_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.
 
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.
 
DofObject * get_old_dof_object ()
 Pointer accessor for previously public old_dof_object.
 
const DofObject * get_old_dof_object () const
 
DofObject & get_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.
 
const DofObject & get_old_dof_object_ref () const
 
void clear_old_dof_object ()
 Sets the old_dof_object to nullptr.
 
void set_old_dof_object ()
 Sets the old_dof_object to a copy of this.
 
void clear_dofs ()
 Clear the DofMap data structures holding degree of freedom data.
 
void invalidate_dofs (const unsigned int sys_num=libMesh::invalid_uint)
 Sets all degree of freedom numbers to invalid_id.
 
void invalidate_id ()
 Sets the id to invalid_id.
 
void invalidate_processor_id ()
 Sets the processor id to invalid_processor_id.
 
void invalidate ()
 Invalidates all the indices for this DofObject.
 
unsigned int n_dofs (const unsigned int s, const unsigned int var=libMesh::invalid_uint) const
 
dof_id_type id () const
 
dof_id_type & set_id ()
 
void set_id (const dof_id_type dofid)
 Sets the id for this DofObject.
 
unique_id_type unique_id () const
 
void set_unique_id (unique_id_type new_id)
 Sets the unique_id for this DofObject.
 
bool valid_id () const
 
bool valid_unique_id () const
 
processor_id_type processor_id () const
 
processor_id_type & processor_id ()
 
void processor_id (const processor_id_type pid)
 Sets the processor_id for this DofObject.
 
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.
 
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.
 
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.
 
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.
 
template<typename T >
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.
 
void add_system ()
 Adds an additional system to the DofObject.
 
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.
 
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.
 
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.
 
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 int > var_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.
 
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.
 
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.
 
void add_extra_integers (const unsigned int n_integers)
 Assigns a set of extra integers to this DofObject.
 
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.
 
unsigned int n_extra_integers () const
 Returns how many extra integers are associated to the DofObject.
 
bool has_extra_integers () const
 Returns whether extra integers are associated to the DofObject.
 
unsigned int packed_indexing_size () const
 If we pack our indices into an buffer for communications, how many ints do we need?
 
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.
 
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.
 
void debug_buffer () const
 Print our buffer for debugging.
 
void print_dof_info () const
 Print out info for debugging.
 
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.
 
static void print_info (std::ostream &out_stream=libMesh::out)
 Prints the reference information, by default to libMesh::out.
 
static std::string get_info ()
 Gets a string containing the reference information.
 
static std::string get_info ()
 Gets a string containing the reference information.
 
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< Elem > build (const ElemType type, Elem *p=nullptr)
 
static std::unique_ptr< Elem > build_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.
 
static unsigned int n_objects ()
 Prints the number of outstanding (created, but not yet destroyed) objects.
 
static unsigned int n_objects ()
 Prints the number of outstanding (created, but not yet destroyed) objects.
 
static void enable_print_counter_info ()
 Methods to enable/disable the reference counter output from print_info().
 
static void enable_print_counter_info ()
 Methods to enable/disable the reference counter output from print_info().
 
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?
 

Static Public Attributes

static const int num_nodes = 9
 Geometric constants for Quad9.
 
static const int nodes_per_side = 3
 
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.
 
static const int num_sides = 4
 Geometric constants for Quad4.
 
static const int num_children = 4
 
static constexpr subdomain_id_type invalid_subdomain_id = std::numeric_limits<subdomain_id_type>::max()
 A static integral constant representing an invalid subdomain id.
 
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.
 
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.
 
static const unsigned int max_n_nodes = 27
 The maximum number of nodes any element can contain.
 
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.
 
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.
 
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.
 
static constexpr dof_id_type invalid_id = static_cast<dof_id_type>(-1)
 An invalid id to distinguish an uninitialized DofObject.
 
static constexpr unique_id_type invalid_unique_id = static_cast<unique_id_type>(-1)
 An invalid unique_id to distinguish an uninitialized DofObject.
 
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.
 

Protected Types

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

Protected Member Functions

virtual Real embedding_matrix (const unsigned int i, const unsigned int j, const unsigned int k) const override
 Matrix used to create the elements children.
 
void swap2nodes (unsigned int n1, unsigned int n2)
 Swaps two node_ptrs.
 
void swap2neighbors (unsigned int n1, unsigned int n2)
 Swaps two neighbor_ptrs.
 
void swap2boundarysides (unsigned short s1, unsigned short s2, BoundaryInfo *boundary_info) const
 Swaps two sides in boundary_info, if it is non-null.
 
void swap2boundaryedges (unsigned short e1, unsigned short e2, BoundaryInfo *boundary_info) const
 Swaps two edges in boundary_info, if it is non-null.
 
void swap3nodes (unsigned int n1, unsigned int n2, unsigned int n3)
 Swaps three node_ptrs, "rotating" them.
 
void swap3neighbors (unsigned int n1, unsigned int n2, unsigned int n3)
 Swaps three neighbor_ptrs, "rotating" them.
 
void swap4nodes (unsigned int n1, unsigned int n2, unsigned int n3, unsigned int n4)
 Swaps four node_ptrs, "rotating" them.
 
void swap4neighbors (unsigned int n1, unsigned int n2, unsigned int n3, unsigned int n4)
 Swaps four neighbor_ptrs, "rotating" them.
 
template<typename Sideclass , typename Subclass >
std::unique_ptr< Elem > simple_build_side_ptr (const unsigned int i)
 An implementation for simple (all sides equal) elements.
 
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.
 
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.
 
template<typename Edgeclass , typename Subclass >
std::unique_ptr< Elem > simple_build_edge_ptr (const unsigned int i)
 An implementation for simple (all edges equal) elements.
 
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.
 
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.
 
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.
 
void increment_constructor_count (const std::string &name) noexcept
 Increments the construction counter.
 
void increment_constructor_count (const std::string &name) noexcept
 Increments the construction counter.
 
void increment_destructor_count (const std::string &name) noexcept
 Increments the destruction counter.
 
void increment_destructor_count (const std::string &name) noexcept
 Increments the destruction counter.
 

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

Static Protected Attributes

static const Real _embedding_matrix [num_children][num_nodes][num_nodes]
 Matrix that computes new nodal locations/solution values from current nodes/solution.
 
static const unsigned short int _second_order_adjacent_vertices [4][2]
 Matrix that tells which vertices define the location of mid-side (or second-order) nodes.
 
static const unsigned short int _second_order_vertex_child_number [9]
 Vector that names a child sharing each second order node.
 
static const unsigned short int _second_order_vertex_child_index [9]
 Vector that names the child vertex index for each second order node.
 
static const Real _master_points [9][3]
 Master element node locations.
 
static const int _child_node_lookup [4][9]
 Lookup table from child id, child node id to "possible node location" (a simple dictionary-index in a 5x5 grid)
 
static const unsigned int adjacent_sides_map [4][2]
 This maps the \( j^{th} \) node to the (in this case) 2 side ids adjacent to the node.
 
static constexpr Real affine_tol = TOLERANCE*TOLERANCE
 Default tolerance to use in has_affine_map().
 
static Counts _counts
 Actually holds the data.
 
static Counts _counts
 Actually holds the data.
 
static Threads::atomic< unsigned int > _n_objects
 The number of objects.
 
static Threads::atomic< unsigned int > _n_objects
 The number of objects.
 
static Threads::spin_mutex _mutex
 Mutual exclusion object to enable thread-safe reference counting.
 
static Threads::spin_mutex _mutex
 Mutual exclusion object to enable thread-safe reference counting.
 
static bool _enable_print_counter = true
 Flag to control whether reference count information is printed when print_info is called.
 
static bool _enable_print_counter = true
 Flag to control whether reference count information is printed when print_info is called.
 

Private Types

typedef dof_id_type index_t
 DoF index information.
 
typedef std::vector< index_t > index_buffer_t
 

Private Member Functions

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.
 
void set_child (unsigned int c, Elem *elem)
 Sets the pointer to the \( i^{th} \) child for this element.
 
SideIter _first_side ()
 Side iterator helper functions.
 
SideIter _last_side ()
 
std::unique_ptr< DofObject > construct (const DofObject *other=nullptr)
 Convenient factory function that calls either the (deep) copy constructor or the default constructor depending on the input arg.
 
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.
 
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.
 
unsigned int start_idx (const unsigned int s) const
 The starting index for system s.
 
unsigned int end_idx (const unsigned int s) const
 The ending index for system s.
 
unsigned int start_idx_ints () const
 The starting index for an extra_integers pseudosystem.
 
unsigned int end_idx_ints () const
 The ending index for an extra_integers pseudosystem.
 

Private Attributes

unique_id_type _unique_id
 A globally unique id, guaranteed not to change as the mesh is repartitioned or adapted.
 
dof_id_type _id
 The id of the DofObject.
 
processor_id_type _processor_id
 The processor_id of the DofObject.
 
index_buffer_t _idx_buf
 

Static Private Attributes

static const index_t ncv_magic = 256
 Above we introduced the chimera ncv, which is a hybrid of the form ncv = ncv_magic*nv + nc where nv are the number of identical variables of a given type, and nc is the number of components for this set of variables.
 
static const index_t ncv_magic_exp = 8
 

Detailed Description

The QUAD9 is an element in 2D composed of 9 nodes.

It is numbered like this: 

*          3     6     2
*   QUAD9: o-----o-----o
*          |           |           eta
*          |     8     |            ^
*        7 o     o     o 5          |
*          |           |            |
*          |           |            o---> xi
*          o-----o-----o
*          0     4     1
*

(xi, eta) in [-1,1]^2 are the reference element coordinates associated with the given numbering.

Author
Benjamin S. Kirk
Date
2002

A 2D quadrilateral element with 9 nodes.

Definition at line 51 of file face_quad9.h.

Member Typedef Documentation

◆ ConstNeighborPtrIter

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

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

◆ index_buffer_t

typedef std::vector<index_t> libMesh::DofObject::index_buffer_t
privateinherited

Definition at line 670 of file dof_object.h.

◆ index_t

typedef dof_id_type libMesh::DofObject::index_t
privateinherited

DoF index information.

This is packed into a contiguous buffer of the following format:

* [hdr end_0 end_1 ... end_{nps-2} (ncv_0 idx_0 ncv_1 idx_1 ... ncv_nv idx_nv)_0
*                                  (ncv_0 idx_0 ncv_1 idx_1 ... ncv_nv idx_nv)_1
*                                   ...
*                                  (ncv_0 idx_0 ncv_1 idx_1 ... ncv_nv idx_nv)_{nps-2} ]
*

'hdr' determines whether this DofObject has_extra_integers() associated with it; iff so then it is negative.

The total number of "pseudo systems" is nps := abs(hdr).

The total number of true systems is 

* ns = hdr,            hdr >= 0
*    = abs(hdr) - 1,   otherwise.
*

'end_s' is the index past the end of the variable group (or integer) storage for (pseudo) system s.

Note
We specifically do not store the end for the last (pseudo) system - this always _idx_buf.size().

As a first example, consider the case of 4 systems, with 3, 0, 1, 2 variable groups, respectively. The _idx_buf then looks like:

* [4 10 10 12 () (ncv_0 idx_0 ncv_1 idx_1 ncv_2 idx_2) () (ncv_0 idx_0) (ncv_0 idx_0 ncv_1 idx_1)]
* [0  1  2  3         4     5     6     7     8     9         10    11      12    13    14    15]
*

The ending index for each (pseudo) system is then given by:

* end_s = _idx_buf.size(),                        s == (nps-1),
*       = _idx_buf[s+1] + has_extra_integers(),   otherwise.
*

The starting indices are not specifically stored, but rather inferred as follows:

start_s = abs(_idx_buf[s])

Now, the defining characteristic of the VariableGroup is that it supports an arbitrary number of variables of the same type. At the DofObject level, what that means is that each Variable in the VariableGroup will have the same number of nonzero components, and they can all be indexed from the same base number. We use this information in the ncv_# and idx_# entries as follows:

ncv_# = n_vars*ncv_magic + n_comp for variable group # idx_# = base_offset for variable group #

the DoF index for a particular component c of variable v within that group is then given by

idx_var = idx_# + n_comp*v + c

Note
There is a subtlety here - "variable v within that group" usually means nothing to the user. This class is either indexed with variable group numbers, or variable numbers counted within the system. So for a system with 2 variable groups, 4 and 8 variables each, the 5th variable in the system is the 1st variable in 2nd variable group. (Now of course 0-base everything... but you get the idea.)

When hdr is negative when cast to a signed type, then we interpret that to mean there exists one pseudo-system following the true systems, one for which the _idx_buf data stores the values associated with add_extra_integer entries, not ncv and idx data associated with system variables. We still return only the number of true systems for n_systems(), but we report has_extra_integers() as true iff hdr is negative, and abs(hdr) will reflect the total number of pseudo-systems, n_systems()+1.

E.g. if we had added two extra integers to the example case above, the _idx_buf then looks like:

* [-5 11 11 13 17 () (ncv_0 idx_0 ncv_1 idx_1 ncv_2 idx_2) () (ncv_0 idx_0) (ncv_0 idx_0 ncv_1 idx_1) (xtra1 xtra2)]
* [0   1  2  3  4         5     6     7     8     9    10         11    12      13    14    15    16      17    18]
*

Definition at line 669 of file dof_object.h.

◆ NeighborPtrIter

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

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

Definition at line 334 of file elem.h.

◆ Predicate

typedef Predicates::multi_predicate libMesh::Elem::Predicate
inherited

Useful iterator typedefs.

Definition at line 1875 of file elem.h.

Member Enumeration Documentation

◆ RefinementState

enum libMesh::Elem::RefinementState
inherited

Enumeration of possible element refinement states.

Enumerator
COARSEN 
DO_NOTHING 
REFINE 
JUST_REFINED 
JUST_COARSENED 
INACTIVE 
COARSEN_INACTIVE 
INVALID_REFINEMENTSTATE 

Definition at line 1446 of file elem.h.

1446 { COARSEN = 0,
1447 DO_NOTHING,
1448 REFINE,
1449 JUST_REFINED,
1450 JUST_COARSENED,
1451 INACTIVE,
1452 COARSEN_INACTIVE,
1453 INVALID_REFINEMENTSTATE };
libMesh::Elem::COARSEN_INACTIVE
@ COARSEN_INACTIVE
Definition elem.h:1452
libMesh::Elem::INVALID_REFINEMENTSTATE
@ INVALID_REFINEMENTSTATE
Definition elem.h:1453
libMesh::Elem::JUST_COARSENED
@ JUST_COARSENED
Definition elem.h:1450

Constructor & Destructor Documentation

◆ Quad9() [1/3]

libMesh::Quad9::Quad9 ( Elem *  p = nullptr)
inlineexplicit

Constructor.

By default this element has no parent.

Definition at line 59 of file face_quad9.h.

59 :
60 Quad(num_nodes, p, _nodelinks_data) {}
libMesh::Quad9::_nodelinks_data
Node * _nodelinks_data[num_nodes]
Data for links to nodes.
Definition face_quad9.h:231
libMesh::Quad9::num_nodes
static const int num_nodes
Geometric constants for Quad9.
Definition face_quad9.h:197
libMesh::Quad::Quad
Quad(const unsigned int nn, Elem *p, Node **nodelinkdata)
Default quadrilateral element, takes number of nodes and parent.
Definition face_quad.h:56

◆ Quad9() [2/3]

libMesh::Quad9::Quad9 ( Quad9 &&  )
delete

◆ Quad9() [3/3]

libMesh::Quad9::Quad9 ( const Quad9 &  )
delete

◆ ~Quad9()

virtual libMesh::Quad9::~Quad9 ( )
virtualdefault

Member Function Documentation

◆ _first_side()

Elem::SideIter libMesh::Elem::_first_side ( )
inlineprivateinherited

Side iterator helper functions.

Used to replace the begin() and end() functions of the STL containers.

Definition at line 3487 of file elem.h.

3488{
3489 return SideIter(0, this);
3490}

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

◆ _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 2218 of file elem.h.

2219 {
2220 static std::vector<std::vector<std::vector<std::vector<std::pair<unsigned char, unsigned char>>>>> c;
2221 libmesh_error();
2222 return c;
2223 }

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

◆ _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 2232 of file elem.h.

2233 {
2234 static std::vector<std::vector<std::vector<signed char>>> c;
2235 libmesh_error();
2236 return c;
2237 }

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

◆ _last_side()

Elem::SideIter libMesh::Elem::_last_side ( )
inlineprivateinherited

Definition at line 3495 of file elem.h.

3496{
3497 return SideIter(this->n_neighbors(), this);
3498}
libMesh::Elem::n_neighbors
unsigned int n_neighbors() const
Definition elem.h:713

References libMesh::Elem::n_neighbors().

Referenced by libMesh::Elem::boundary_sides_begin(), and libMesh::Elem::boundary_sides_end().

◆ 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 2958 of file elem.h.

2959{
2960#ifdef LIBMESH_ENABLE_AMR
2961 if ((this->refinement_flag() == INACTIVE) ||
2962 (this->refinement_flag() == COARSEN_INACTIVE))
2963 return false;
2964 else
2965 return true;
2966#else
2967 return true;
2968#endif
2969}
libMesh::Elem::refinement_flag
RefinementState refinement_flag() const
Definition elem.h:3227

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< OutputType >::compute_periodic_constraints(), libMesh::FEAbstract::compute_periodic_node_constraints(), libMesh::FEGenericBase< OutputType >::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::Elem::libmesh_assert_valid_neighbors(), 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::DofMap::old_dof_indices(), 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(), ElemTest< elem_type >::test_n_refinements(), EquationSystemsTest::testRefineThenReinitPreserveFlags(), libMesh::BoundaryInfo::transfer_boundary_ids_from_children(), and libMesh::Parallel::Packing< Elem * >::unpack().

◆ 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 2142 of file elem.C.

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

References libMesh::ElemInternal::active_family_tree().

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

◆ 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 2150 of file elem.C.

2152{
2153 ElemInternal::active_family_tree(this, active_family, reset);
2154}

References libMesh::ElemInternal::active_family_tree().

◆ 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 2288 of file elem.C.

2291{
2292 ElemInternal::active_family_tree_by_neighbor(this, family, neighbor, reset);
2293}
libMesh::ElemInternal::active_family_tree_by_neighbor
void active_family_tree_by_neighbor(T elem, std::vector< T > &family, T neighbor_in, bool reset=true)
Definition elem_internal.h:349

References libMesh::ElemInternal::active_family_tree_by_neighbor().

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

◆ 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 2297 of file elem.C.

2300{
2301 ElemInternal::active_family_tree_by_neighbor(this, family, neighbor, reset);
2302}

References libMesh::ElemInternal::active_family_tree_by_neighbor().

◆ 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 2194 of file elem.C.

2197{
2198 ElemInternal::active_family_tree_by_side(this, family, side, reset);
2199}
libMesh::ElemInternal::active_family_tree_by_side
void active_family_tree_by_side(T elem, std::vector< T > &family, unsigned int side, bool reset=true)
Definition elem_internal.h:178

References libMesh::ElemInternal::active_family_tree_by_side().

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

◆ 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 2203 of file elem.C.

2206{
2207 ElemInternal::active_family_tree_by_side(this, family, side, reset);
2208}

References libMesh::ElemInternal::active_family_tree_by_side().

◆ 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 2306 of file elem.C.

2312{
2313 ElemInternal::active_family_tree_by_topological_neighbor(this, family, neighbor,
2314 mesh, point_locator, pb,
2315 reset);
2316}
mesh
MeshBase & mesh
Definition mesh_communication.C:1460
libMesh::ElemInternal::active_family_tree_by_topological_neighbor
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)
Definition elem_internal.h:385

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

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

◆ 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 2320 of file elem.C.

2326{
2327 ElemInternal::active_family_tree_by_topological_neighbor(this, family, neighbor,
2328 mesh, point_locator, pb,
2329 reset);
2330}

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

◆ 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 2053 of file elem.C.

2054{
2055 const unsigned int nc = this->n_children();
2056
2057 if (!_children)
2058 {
2059 _children = std::make_unique<Elem *[]>(nc);
2060
2061 for (unsigned int c = 0; c != nc; c++)
2062 this->set_child(c, nullptr);
2063 }
2064
2065 for (unsigned int c = 0; c != nc; c++)
2066 {
2067 if (this->_children[c] == nullptr || this->_children[c] == remote_elem)
2068 {
2069 libmesh_assert_equal_to (this, elem->parent());
2070 this->set_child(c, elem);
2071 return;
2072 }
2073 }
2074
2075 libmesh_error_msg("Error: Tried to add a child to an element with full children array");
2076}
libMesh::Elem::set_child
void set_child(unsigned int c, Elem *elem)
Sets the pointer to the child for this element.
Definition elem.h:3199
libMesh::Elem::_children
std::unique_ptr< Elem *[]> _children
unique_ptr to array of this element's children.
Definition elem.h:2270
libMesh::Elem::n_children
virtual unsigned int n_children() const =0
libMesh::remote_elem
const RemoteElem * remote_elem
Definition remote_elem.C:57

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(), libMesh::CheckpointIO::read_remote_elem(), libMesh::XdrIO::read_serialized_connectivity(), and libMesh::Parallel::Packing< Elem * >::unpack().

◆ 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 2080 of file elem.C.

2081{
2082 if (!this->has_children())
2083 {
2084 const unsigned int nc = this->n_children();
2085 _children = std::make_unique<Elem *[]>(nc);
2086
2087 for (unsigned int i = 0; i != nc; i++)
2088 this->set_child(i, nullptr);
2089 }
2090
2091 libmesh_assert (this->_children[c] == nullptr || this->child_ptr(c) == remote_elem);
2092 libmesh_assert (elem == remote_elem || this == elem->parent());
2093
2094 this->set_child(c, elem);
2095}
libMesh::Elem::has_children
bool has_children() const
Definition elem.h:2996
libMesh::Elem::parent
const Elem * parent() const
Definition elem.h:3047
libMesh::Elem::child_ptr
const Elem * child_ptr(unsigned int i) const
Definition elem.h:3180
libMesh::libmesh_assert
libmesh_assert(ctx)

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

◆ 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.

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}
libMesh::DofObject::n_extra_integers
unsigned int n_extra_integers() const
Returns how many extra integers are associated to the DofObject.
Definition dof_object.h:1146
libMesh::DofObject::invalid_id
static constexpr dof_id_type invalid_id
An invalid id to distinguish an uninitialized DofObject.
Definition dof_object.h:473
libMesh::DofObject::_idx_buf
index_buffer_t _idx_buf
Definition dof_object.h:671
libMesh::dof_id_signed_type
int8_t dof_id_signed_type
Definition id_types.h:68
libMesh::dof_id_type
uint8_t dof_id_type
Definition id_types.h:67

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

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

◆ 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.

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}
libMesh::DofObject::add_extra_integers
void add_extra_integers(const unsigned int n_integers)
Assigns a set of extra integers to this DofObject.
Definition dof_object.C:482

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

◆ add_system()

void libMesh::DofObject::add_system ( )
inherited

Adds an additional system to the DofObject.

Definition at line 187 of file dof_object.C.

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}
n_vars
unsigned int n_vars
Definition adaptivity_ex3.C:117
libMesh::DofObject::n_systems
unsigned int n_systems() const
Definition dof_object.h:913
libMesh::DofObject::has_extra_integers
bool has_extra_integers() const
Returns whether extra integers are associated to the DofObject.
Definition dof_object.h:1164
libMesh::DofObject::n_var_groups
unsigned int n_var_groups(const unsigned int s) const
Definition dof_object.h:933
libMesh::DofObject::set_n_systems
void set_n_systems(const unsigned int s)
Sets the number of systems for this DofObject.
Definition dof_object.C:142

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

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

◆ 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 2019 of file elem.C.

2020{
2021#ifdef LIBMESH_ENABLE_AMR
2022
2023 // Use a fast, DistributedMesh-safe definition
2024 const bool is_ancestor =
2025 !this->active() && !this->subactive();
2026
2027 // But check for inconsistencies if we have time
2028#ifdef DEBUG
2029 if (!is_ancestor && this->has_children())
2030 {
2031 for (auto & c : this->child_ref_range())
2032 {
2033 if (&c != remote_elem)
2034 {
2035 libmesh_assert(!c.active());
2036 libmesh_assert(!c.ancestor());
2037 }
2038 }
2039 }
2040#endif // DEBUG
2041
2042 return is_ancestor;
2043
2044#else
2045 return false;
2046#endif
2047}
libMesh::Elem::active
bool active() const
Definition elem.h:2958
libMesh::Elem::child_ref_range
SimpleRange< ChildRefIter > child_ref_range()
Returns a range with all children of a parent element, usable in range-based for loops.
Definition elem.h:2355
libMesh::Elem::subactive
bool subactive() const
Definition elem.h:2976

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(), libMesh::Elem::make_links_to_me_local(), libMesh::Elem::refine(), and ElemTest< elem_type >::test_n_refinements().

◆ 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 2413 of file elem.C.

2415{
2416 const unsigned int nc = this->n_children();
2417 libmesh_assert_less(child, nc);
2418
2419 // Cached return values, indexed first by embedding_matrix version,
2420 // then by child number, then by child node number.
2421 std::vector<std::vector<std::vector<signed char>>> &
2422 cached_parent_indices = this->_get_parent_indices_cache();
2423
2424 unsigned int em_vers = this->embedding_matrix_version();
2425
2426 // We may be updating the cache on one thread, and while that
2427 // happens we can't safely access the cache from other threads.
2428 Threads::spin_mutex::scoped_lock lock(parent_indices_mutex);
2429
2430 if (em_vers >= cached_parent_indices.size())
2431 cached_parent_indices.resize(em_vers+1);
2432
2433 if (child >= cached_parent_indices[em_vers].size())
2434 {
2435 const signed char nn = cast_int<signed char>(this->n_nodes());
2436
2437 cached_parent_indices[em_vers].resize(nc);
2438
2439 for (unsigned int c = 0; c != nc; ++c)
2440 {
2441 const unsigned int ncn = this->n_nodes_in_child(c);
2442 cached_parent_indices[em_vers][c].resize(ncn);
2443 for (unsigned int cn = 0; cn != ncn; ++cn)
2444 {
2445 for (signed char n = 0; n != nn; ++n)
2446 {
2447 const Real em_val = this->embedding_matrix
2448 (c, cn, n);
2449 if (em_val == 1)
2450 {
2451 cached_parent_indices[em_vers][c][cn] = n;
2452 break;
2453 }
2454
2455 if (em_val != 0)
2456 {
2457 cached_parent_indices[em_vers][c][cn] =
2458 -1;
2459 break;
2460 }
2461
2462 // We should never see an all-zero embedding matrix
2463 // row
2464 libmesh_assert_not_equal_to (n+1, nn);
2465 }
2466 }
2467 }
2468 }
2469
2470 const signed char cache_val =
2471 cached_parent_indices[em_vers][child][child_node];
2472 if (cache_val == -1)
2473 return libMesh::invalid_uint;
2474
2475 return cached_parent_indices[em_vers][child][child_node];
2476}
libMesh::Elem::n_nodes_in_child
virtual unsigned int n_nodes_in_child(unsigned int) const
Definition elem.h:667
libMesh::Elem::n_nodes
virtual unsigned int n_nodes() const =0
libMesh::Elem::embedding_matrix
virtual Real embedding_matrix(const unsigned int child_num, const unsigned int child_node_num, const unsigned int parent_node_num) const =0
libMesh::Elem::_get_parent_indices_cache
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 stat...
Definition elem.h:2232
libMesh::Elem::embedding_matrix_version
virtual unsigned int embedding_matrix_version() const
Definition elem.h:2060
libMesh::invalid_uint
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:303
libMesh::parent_indices_mutex
Threads::spin_mutex parent_indices_mutex
Definition elem.C:97
libMesh::Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
Definition libmesh_common.h:144

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(), libMesh::Elem::parent_bracketing_nodes(), and ElemTest< elem_type >::test_n_refinements().

◆ boundary_sides_begin()

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

Iterator accessor functions.

Definition at line 3444 of file elem.C.

3445{
3446 Predicates::BoundarySide<SideIter> bsp;
3447 return side_iterator(this->_first_side(), this->_last_side(), bsp);
3448}
libMesh::Elem::_last_side
SideIter _last_side()
Definition elem.h:3495
libMesh::Elem::_first_side
SideIter _first_side()
Side iterator helper functions.
Definition elem.h:3487

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

◆ boundary_sides_end()

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

Definition at line 3453 of file elem.C.

3454{
3455 Predicates::BoundarySide<SideIter> bsp;
3456 return side_iterator(this->_last_side(), this->_last_side(), bsp);
3457}

References libMesh::Elem::_last_side().

◆ 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 2684 of file elem.C.

2686{
2687 std::vector<std::pair<dof_id_type, dof_id_type>> returnval;
2688
2689 const std::vector<std::pair<unsigned char, unsigned char>> & pbc =
2690 this->parent_bracketing_nodes(child,child_node);
2691
2692 for (const auto & pb : pbc)
2693 {
2694 const unsigned short n_n = this->n_nodes();
2695 if (pb.first < n_n && pb.second < n_n)
2696 returnval.emplace_back(this->node_id(pb.first), this->node_id(pb.second));
2697 else
2698 {
2699 // We must be on a non-full-order higher order element...
2700 libmesh_assert_not_equal_to(this->default_order(), FIRST);
2701 libmesh_assert_not_equal_to
2702 (second_order_equivalent_type (this->type(), true),
2703 this->type());
2704 libmesh_assert_equal_to
2705 (second_order_equivalent_type (this->type(), false),
2706 this->type());
2707
2708 // And that's a shame, because this is a nasty search:
2709
2710 // Build the full-order type
2711 ElemType full_type =
2712 second_order_equivalent_type(this->type(), /*full_ordered=*/ true);
2713 std::unique_ptr<Elem> full_elem = Elem::build(full_type);
2714
2715 dof_id_type pt1 = DofObject::invalid_id;
2716 dof_id_type pt2 = DofObject::invalid_id;
2717
2718 // Find the bracketing nodes by figuring out what
2719 // already-created children will have them.
2720
2721 // This only doesn't break horribly because we add children
2722 // and nodes in straightforward + hierarchical orders...
2723 for (unsigned int c=0; c <= child; ++c)
2724 {
2725 libmesh_assert(this->child_ptr(c));
2726 if (this->child_ptr(c) == remote_elem)
2727 continue;
2728
2729 for (auto n : make_range(this->n_nodes_in_child(c)))
2730 {
2731 if (c == child && n == child_node)
2732 break;
2733
2734 if (pb.first == full_elem->as_parent_node(c,n))
2735 {
2736 // We should be consistent
2737 if (pt1 != DofObject::invalid_id)
2738 libmesh_assert_equal_to(pt1, this->child_ptr(c)->node_id(n));
2739
2740 pt1 = this->child_ptr(c)->node_id(n);
2741 }
2742
2743 if (pb.second == full_elem->as_parent_node(c,n))
2744 {
2745 // We should be consistent
2746 if (pt2 != DofObject::invalid_id)
2747 libmesh_assert_equal_to(pt2, this->child_ptr(c)->node_id(n));
2748
2749 pt2 = this->child_ptr(c)->node_id(n);
2750 }
2751 }
2752 }
2753
2754 // We should *usually* find all bracketing nodes by the time
2755 // we query them (again, because of the child & node add
2756 // order)
2757 //
2758 // The exception is if we're a HEX20, in which case we will
2759 // find pairs of vertex nodes and edge nodes bracketing the
2760 // new central node but we *won't* find the pairs of face
2761 // nodes which we would have had on a HEX27. In that case
2762 // we'll still have enough bracketing nodes for a
2763 // topological lookup, but we won't be able to make the
2764 // following assertions.
2765 if (this->type() != HEX20)
2766 {
2767 libmesh_assert_not_equal_to (pt1, DofObject::invalid_id);
2768 libmesh_assert_not_equal_to (pt2, DofObject::invalid_id);
2769 }
2770
2771 if (pt1 != DofObject::invalid_id &&
2772 pt2 != DofObject::invalid_id)
2773 returnval.emplace_back(pt1, pt2);
2774 }
2775 }
2776
2777 return returnval;
2778}
libMesh::Elem::parent_bracketing_nodes
virtual const std::vector< std::pair< unsigned char, unsigned char > > & parent_bracketing_nodes(unsigned int c, unsigned int n) const
Definition elem.C:2481
libMesh::Elem::default_order
virtual Order default_order() const =0
libMesh::Elem::build
static std::unique_ptr< Elem > build(const ElemType type, Elem *p=nullptr)
Definition elem.C:442
libMesh::Elem::second_order_equivalent_type
static ElemType second_order_equivalent_type(const ElemType et, const bool full_ordered=true)
Definition elem.C:3168
libMesh::Elem::type
virtual ElemType type() const =0
libMesh::Elem::node_id
dof_id_type node_id(const unsigned int i) const
Definition elem.h:2484
libMesh::ElemType
ElemType
Defines an enum for geometric element types.
Definition enum_elem_type.h:33
libMesh::make_range
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:176

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

◆ 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.

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}
libMesh::Utility::enum_to_string
std::string enum_to_string(const T e)

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(), LinearElasticityWithContact::add_contact_edge_elements(), 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(), MeshfunctionDFEM::build_mesh(), MixedDimensionMeshTest::build_mesh(), MixedDimensionNonUniformRefinement::build_mesh(), MixedDimensionNonUniformRefinementTriangle::build_mesh(), MixedDimensionNonUniformRefinement3D::build_mesh(), ExtraIntegersTest::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::VTKIO::read(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::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(), RationalMapTest< elem_type >::setUp(), PerElemTest< elem_type >::setUp(), libMesh::MeshTools::Generation::surface_octahedron(), AllRBBTest::test_cylinder(), 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(), MeshTriangulationTest::testPoly2TriEdge3ToTri6FlipThrows(), QuadratureTest::testPolynomials(), EquationSystemsTest::testReinitWithNodeElem(), SystemsTest::testSetSystemParameterOverEquationSystem(), BoundaryInfoTest::testShellFaceConstraints(), MeshTetTest::testTetsToTets(), MeshSubdomainIDTest::testUnpartitioned(), libMesh::TetGenMeshInterface::triangulate_conformingDelaunayMesh_carvehole(), libMesh::TetGenMeshInterface::triangulate_pointset(), libMesh::Parallel::Packing< Elem * >::unpack(), and libMesh::GMVIO::write_ascii_old_impl().

◆ build_edge_ptr() [1/6]

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

For the const build_edge_ptr we use the parent method.

Definition at line 964 of file elem.h.

2858{
2859 // Call the non-const version of this function, return the result as
2860 // a std::unique_ptr<const Elem>.
2861 Elem * me = const_cast<Elem *>(this);
2862 return me->build_edge_ptr(i);
2863}
libMesh::Elem::Elem
Elem(const unsigned int n_nodes, const unsigned int n_sides, Elem *parent, Elem **elemlinkdata, Node **nodelinkdata)
Constructor.
Definition elem.h:2387

◆ build_edge_ptr() [2/6]

virtual std::unique_ptr< Elem > libMesh::Face::build_edge_ptr ( const unsigned int  i)
inlinefinaloverridevirtualinherited

build_side and build_edge are identical for faces.

Implements libMesh::Elem.

Definition at line 72 of file face.h.

73 { return build_side_ptr(i); }
libMesh::Elem::build_side_ptr
virtual std::unique_ptr< Elem > build_side_ptr(const unsigned int i)=0

References libMesh::Elem::build_side_ptr().

Referenced by libMesh::Polyhedron::build_edge_ptr(), libMesh::Polyhedron::build_edge_ptr(), and libMesh::Polyhedron::Polyhedron().

◆ build_edge_ptr() [3/6]

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

For the const build_edge_ptr we use the parent method.

Implements libMesh::Elem.

◆ build_edge_ptr() [4/6]

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

For the const build_edge_ptr we use the parent method.

Definition at line 981 of file elem.h.

2871{
2872 // Hand off to the non-const version of this function
2873 Elem * me = const_cast<Elem *>(this);
2874 std::unique_ptr<Elem> e {const_cast<Elem *>(elem.release())};
2875 me->build_edge_ptr(e, i);
2876 elem = std::move(e);
2877}

◆ build_edge_ptr() [5/6]

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

build_side and build_edge are identical for faces.

Implements libMesh::Elem.

Definition at line 78 of file face.h.

79 { build_side_ptr(edge, i); }

References libMesh::Elem::build_side_ptr().

◆ build_edge_ptr() [6/6]

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

For the const build_edge_ptr we use the parent method.

Implements libMesh::Elem.

◆ build_side_ptr() [1/8]

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

Definition at line 920 of file elem.h.

2763{
2764 // Call the non-const version of this function, return the result as
2765 // a std::unique_ptr<const Elem>.
2766 Elem * me = const_cast<Elem *>(this);
2767 return me->build_side_ptr(i);
2768}

◆ build_side_ptr() [2/8]

std::unique_ptr< Elem > libMesh::Quad9::build_side_ptr ( const unsigned int  i)
overridevirtual
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.

Implements libMesh::Elem.

Definition at line 238 of file face_quad9.C.

239{
240 return this->simple_build_side_ptr<Edge3, Quad9>(i);
241}

◆ build_side_ptr() [3/8]

virtual std::unique_ptr< Elem > libMesh::Elem::build_side_ptr ( const unsigned int  i)
virtual
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.

Implements libMesh::Elem.

◆ build_side_ptr() [4/8]

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

Reimplemented from libMesh::Elem.

Definition at line 926 of file elem.h.

927 { if (proxy) libmesh_error(); libmesh_deprecated(); return this->build_side_ptr(i); }
libMesh::Quad9::build_side_ptr
virtual std::unique_ptr< Elem > build_side_ptr(const unsigned int i) override
Definition face_quad9.C:238

◆ build_side_ptr() [5/8]

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

Definition at line 929 of file elem.h.

930 { if (proxy) libmesh_error(); libmesh_deprecated(); return this->build_side_ptr(i); }

◆ build_side_ptr() [6/8]

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

Definition at line 948 of file elem.h.

2776{
2777 // Hand off to the non-const version of this function
2778 Elem * me = const_cast<Elem *>(this);
2779 std::unique_ptr<Elem> e {const_cast<Elem *>(elem.release())};
2780 me->build_side_ptr(e, i);
2781 elem = std::move(e);
2782}

◆ build_side_ptr() [7/8]

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

Rebuilds an EDGE3 coincident with face i.

Implements libMesh::Elem.

Definition at line 245 of file face_quad9.C.

247{
248 this->simple_build_side_ptr<Quad9>(side, i, EDGE3);
249}

References libMesh::EDGE3.

◆ build_side_ptr() [8/8]

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

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.

Implements libMesh::Elem.

◆ 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.

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}

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

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

◆ center_node_on_side()

unsigned int libMesh::Quad9::center_node_on_side ( const unsigned short  side) const
finaloverridevirtual
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 from libMesh::Elem.

Definition at line 483 of file face_quad9.C.

484{
485 libmesh_assert_less (side, Quad9::num_sides);
486 return side + 4;
487}
libMesh::Quad::num_sides
static const int num_sides
Geometric constants for Quad4.
Definition face_quad.h:85

References libMesh::Quad::num_sides.

◆ child_neighbor() [1/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 2669 of file elem.h.

2670{
2671 for (auto n : elem->neighbor_ptr_range())
2672 if (n && n->parent() == this)
2673 return n;
2674
2675 return nullptr;
2676}
libMesh::Elem::neighbor_ptr_range
SimpleRange< NeighborPtrIter > neighbor_ptr_range()
Returns a range with all neighbors of an element, usable in range-based for loops.
Definition elem.h:3520

References libMesh::Elem::neighbor_ptr_range().

◆ child_neighbor() [2/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 2657 of file elem.h.

2658{
2659 for (auto n : elem->neighbor_ptr_range())
2660 if (n && n->parent() == this)
2661 return n;
2662
2663 return nullptr;
2664}

References libMesh::Elem::neighbor_ptr_range().

Referenced by ElemTest< elem_type >::test_n_refinements().

◆ child_ptr() [1/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 3189 of file elem.h.

3190{
3191 libmesh_assert(_children);
3192 libmesh_assert(_children[i]);
3193
3194 return _children[i];
3195}

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

◆ child_ptr() [2/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 3180 of file elem.h.

3181{
3182 libmesh_assert(_children);
3183 libmesh_assert(_children[i]);
3184
3185 return _children[i];
3186}

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< OutputType >::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(), ElemTest< elem_type >::test_n_refinements(), InfFERadialTest::testRefinement(), EquationSystemsTest::testRefineThenReinitPreserveFlags(), libMesh::BoundaryInfo::transfer_boundary_ids_from_children(), libMesh::Parallel::Packing< Elem * >::unpack(), libMesh::Elem::which_child_am_i(), and libMesh::CheckpointIO::write_remote_elem().

◆ 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 2355 of file elem.h.

2356{
2357 libmesh_assert(_children);
2358 return {_children.get(), _children.get() + this->n_children()};
2359}

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< OutputType >::coarsened_dof_values(), libMesh::connect_children(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::JumpErrorEstimator::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().

◆ child_ref_range() [2/2]

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

Definition at line 2363 of file elem.h.

2364{
2365 libmesh_assert(_children);
2366 return {_children.get(), _children.get() + this->n_children()};
2367}

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

◆ 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 789 of file dof_object.h.

790{
791 this->set_n_systems(0);
792}

References libMesh::DofObject::set_n_systems().

◆ 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.

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

References libMesh::DofObject::old_dof_object.

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

◆ 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 2809 of file elem.C.

2810{
2811 // This test uses the user's passed-in tolerance for the
2812 // bounding box test as well, thereby allowing the routine to
2813 // find points which are not only "in" the element, but also
2814 // "nearby" to within some tolerance.
2815 return this->point_test(p, tol, tol);
2816}
libMesh::Elem::point_test
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:2821

References libMesh::Elem::point_test().

Referenced by assemble_SchroedingerEquation(), libMesh::TreeNode< N >::find_element(), libMesh::PointLocatorNanoflann::operator()(), libMesh::PointLocatorTree::operator()(), and libMesh::PointLocatorNanoflann::operator()().

◆ 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 180 of file elem_refinement.C.

181{
182 libmesh_assert_equal_to (this->refinement_flag(), Elem::COARSEN_INACTIVE);
183 libmesh_assert (!this->active());
184
185 // We no longer delete children until MeshRefinement::contract()
186
187 unsigned int parent_p_level = 0;
188
189 const unsigned int n_n = this->n_nodes();
190
191 // re-compute hanging node nodal locations
192 for (unsigned int c = 0, nc = this->n_children(); c != nc; ++c)
193 {
194 Elem * mychild = this->child_ptr(c);
195 if (mychild == remote_elem)
196 continue;
197 for (auto cnode : mychild->node_index_range())
198 {
199 Point new_pos;
200 bool calculated_new_pos = false;
201
202 for (unsigned int n=0; n<n_n; n++)
203 {
204 // The value from the embedding matrix
205 const Real em_val = this->embedding_matrix(c,cnode,n);
206
207 // The node location is somewhere between existing vertices
208 if ((em_val != 0.) && (em_val != 1.))
209 {
210 new_pos.add_scaled (this->point(n), em_val);
211 calculated_new_pos = true;
212 }
213 }
214
215 if (calculated_new_pos)
216 {
217 //Move the existing node back into it's original location
218 for (unsigned int i=0; i<LIBMESH_DIM; i++)
219 {
220 Point & child_node = mychild->point(cnode);
221 child_node(i)=new_pos(i);
222 }
223 }
224 }
225 }
226
227 for (auto & mychild : this->child_ref_range())
228 {
229 if (&mychild == remote_elem)
230 continue;
231 libmesh_assert_equal_to (mychild.refinement_flag(), Elem::COARSEN);
232 mychild.set_refinement_flag(Elem::INACTIVE);
233 if (mychild.p_level() > parent_p_level)
234 parent_p_level = mychild.p_level();
235 }
236
237 this->set_refinement_flag(Elem::JUST_COARSENED);
238 this->set_p_level(parent_p_level);
239
240 libmesh_assert (this->active());
241}
libMesh::Elem::point
const Point & point(const unsigned int i) const
Definition elem.h:2462
libMesh::Elem::node_index_range
IntRange< unsigned short > node_index_range() const
Definition elem.h:2700
libMesh::Elem::set_refinement_flag
void set_refinement_flag(const RefinementState rflag)
Sets the value of the refinement flag for the element.
Definition elem.h:3235
libMesh::Elem::set_p_level
void set_p_level(const unsigned int p)
Sets the value of the p-refinement level for the element.
Definition elem_refinement.C:41

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

◆ 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 3352 of file elem.C.

3353{
3354 switch (et)
3355 {
3356 case NODEELEM:
3357 return NODEELEM;
3358 case EDGE2:
3359 case EDGE3:
3360 return EDGE3;
3361
3362 case EDGE4:
3363 return EDGE4;
3364
3365 case TRI3:
3366 case TRI6:
3367 case TRI7:
3368 return TRI7;
3369
3370 // Currently there is no TRISHELL6, so similarly to other types
3371 // where this is the case, we just return the input.
3372 case TRISHELL3:
3373 return TRISHELL3;
3374
3375 case QUAD4:
3376 case QUAD8:
3377 case QUAD9:
3378 return QUAD9;
3379
3380 case QUADSHELL4:
3381 case QUADSHELL8:
3382 case QUADSHELL9:
3383 return QUADSHELL9;
3384
3385 case TET4:
3386 case TET10:
3387 case TET14:
3388 return TET14;
3389
3390 case HEX8:
3391 case HEX20:
3392 case HEX27:
3393 return HEX27;
3394
3395 // We don't strictly need the 21st node for DoFs, but some code
3396 // depends on it for e.g. refinement patterns
3397 case PRISM6:
3398 case PRISM15:
3399 case PRISM18:
3400 case PRISM20:
3401 case PRISM21:
3402 return PRISM21;
3403
3404 case PYRAMID5:
3405 case PYRAMID13:
3406 case PYRAMID14:
3407 case PYRAMID18:
3408 return PYRAMID18;
3409
3410
3411
3412#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
3413 case INFEDGE2:
3414 return INFEDGE2;
3415
3416 case INFQUAD4:
3417 case INFQUAD6:
3418 return INFQUAD6;
3419
3420 case INFHEX8:
3421 case INFHEX16:
3422 case INFHEX18:
3423 return INFHEX18;
3424
3425 // Probably ought to implement INFPRISM13 and/or 14; until then
3426 // we'll just return the not-complete-order ElemType, in
3427 // accordance which what seems like bad precedent...
3428 case INFPRISM6:
3429 case INFPRISM12:
3430 return INFPRISM12;
3431#endif // LIBMESH_ENABLE_INFINITE_ELEMENTS
3432
3433 default:
3434 {
3435 // what did we miss?
3436 libmesh_error_msg("No complete order equivalent element type for et = "
3437 << Utility::enum_to_string(et));
3438 }
3439 }
3440}

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

◆ compute_key() [1/4]

dof_id_type libMesh::Elem::compute_key ( dof_id_type  n0)
inlinestaticprotectedinherited
Returns
A hash key computed from a single node id.

Definition at line 3311 of file elem.h.

3312{
3313 return n0;
3314}

Referenced by libMesh::Tet4::key(), libMesh::Edge2::key(), libMesh::Edge3::key(), libMesh::Edge4::key(), libMesh::Quad::key(), key(), libMesh::Tri::key(), libMesh::Hex::key(), libMesh::Hex27::key(), libMesh::InfHex::key(), libMesh::InfHex18::key(), libMesh::InfPrism::key(), libMesh::Prism::key(), libMesh::Prism18::key(), libMesh::Prism20::key(), libMesh::Prism21::key(), libMesh::Pyramid::key(), libMesh::Pyramid14::key(), libMesh::Pyramid18::key(), libMesh::Tet::key(), libMesh::InfQuad::key(), libMesh::InfQuad6::key(), libMesh::Polygon::key(), libMesh::Quad::key(), libMesh::Quad8::key(), key(), libMesh::Tri::key(), libMesh::Tri6::key(), libMesh::Tri7::key(), libMesh::Edge::key(), libMesh::Hex::low_order_key(), libMesh::InfHex::low_order_key(), libMesh::InfPrism::low_order_key(), libMesh::Prism::low_order_key(), libMesh::Pyramid::low_order_key(), libMesh::Tet::low_order_key(), libMesh::InfQuad::low_order_key(), libMesh::Polygon::low_order_key(), libMesh::Quad::low_order_key(), libMesh::Tri::low_order_key(), and libMesh::Edge::low_order_key().

◆ 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 3319 of file elem.h.

3321{
3322 // Order the two so that n0 < n1
3323 if (n0 > n1) std::swap (n0, n1);
3324
3325 return Utility::hashword2(n0, n1);
3326}
libMesh::Utility::hashword2
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

References libMesh::Utility::hashword2().

◆ 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 3331 of file elem.h.

3334{
3335 std::array<dof_id_type, 3> array = {{n0, n1, n2}};
3336 std::sort(array.begin(), array.end());
3337 return Utility::hashword(array);
3338}
libMesh::Utility::hashword
uint32_t hashword(const uint32_t *k, size_t length, uint32_t initval=0)
The hashword function takes an array of uint32_t's of length 'length' and computes a single key from ...
Definition hashword.h:158

References libMesh::Utility::hashword().

◆ 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 3343 of file elem.h.

3347{
3348 std::array<dof_id_type, 4> array = {{n0, n1, n2, n3}};
3349 std::sort(array.begin(), array.end());
3350 return Utility::hashword(array);
3351}

References libMesh::Utility::hashword().

◆ connectivity()

void libMesh::Quad9::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 253 of file face_quad9.C.

256{
257 libmesh_assert_less (sf, this->n_sub_elem());
258 libmesh_assert_not_equal_to (iop, INVALID_IO_PACKAGE);
259
260 conn.resize(4);
261
262 switch (iop)
263 {
264 case TECPLOT:
265 {
266 switch(sf)
267 {
268 case 0:
269 // linear sub-quad 0
270 conn[0] = this->node_id(0)+1;
271 conn[1] = this->node_id(4)+1;
272 conn[2] = this->node_id(8)+1;
273 conn[3] = this->node_id(7)+1;
274 return;
275
276 case 1:
277 // linear sub-quad 1
278 conn[0] = this->node_id(4)+1;
279 conn[1] = this->node_id(1)+1;
280 conn[2] = this->node_id(5)+1;
281 conn[3] = this->node_id(8)+1;
282 return;
283
284 case 2:
285 // linear sub-quad 2
286 conn[0] = this->node_id(7)+1;
287 conn[1] = this->node_id(8)+1;
288 conn[2] = this->node_id(6)+1;
289 conn[3] = this->node_id(3)+1;
290 return;
291
292 case 3:
293 // linear sub-quad 3
294 conn[0] = this->node_id(8)+1;
295 conn[1] = this->node_id(5)+1;
296 conn[2] = this->node_id(2)+1;
297 conn[3] = this->node_id(6)+1;
298 return;
299
300 default:
301 libmesh_error_msg("Invalid sf = " << sf);
302 }
303 }
304
305 case VTK:
306 {
307 conn.resize(Quad9::num_nodes);
308 for (auto i : index_range(conn))
309 conn[i] = this->node_id(i);
310 return;
311 }
312
313 default:
314 libmesh_error_msg("Unsupported IO package " << iop);
315 }
316}
libMesh::Quad9::n_sub_elem
virtual unsigned int n_sub_elem() const override
Definition face_quad9.h:81
libMesh::index_range
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:153

References libMesh::index_range(), libMesh::INVALID_IO_PACKAGE, n_sub_elem(), libMesh::Elem::node_id(), num_nodes, libMesh::TECPLOT, and libMesh::VTK.

◆ construct()

std::unique_ptr< DofObject > libMesh::DofObject::construct ( const DofObject *  other = nullptr)
inlineprivateinherited

Convenient factory function that calls either the (deep) copy constructor or the default constructor depending on the input arg.

Like the copy constructor, this function is also private. We can't use std::make_unique to construct a DofObject since the copy constructor is private, but we can at least encapsulate the code which calls "new" directly.

Definition at line 732 of file dof_object.h.

733{
734 return other
735 ? std::unique_ptr<DofObject>(new DofObject(*other))
736 : std::unique_ptr<DofObject>(new DofObject());
737}
libMesh::DofObject::DofObject
DofObject()
Constructor.
Definition dof_object.h:718

References libMesh::DofObject::DofObject().

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

◆ 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 946 of file elem.C.

947{
948 unsigned int num_contained_edges = 0;
949
950 // Our vertices are the first numbered nodes
951 for (auto n : make_range(e->n_vertices()))
952 {
953 if (this->contains_point(e->point(n)))
954 {
955 num_contained_edges++;
956 if (num_contained_edges>=2)
957 {
958 return true;
959 }
960 }
961 }
962 return false;
963}
libMesh::Elem::n_vertices
virtual unsigned int n_vertices() const =0
libMesh::Elem::contains_point
virtual bool contains_point(const Point &p, Real tol=TOLERANCE) const
Definition elem.C:2784

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

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

◆ 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::Tet4, libMesh::Tri3, libMesh::NodeElem, libMesh::InfHex, libMesh::InfPrism, and libMesh::InfQuad4.

Definition at line 2784 of file elem.C.

2785{
2786 // We currently allow the user to enlarge the bounding box by
2787 // providing a tol > TOLERANCE (so this routine is identical to
2788 // Elem::close_to_point()), but print a warning so that the
2789 // user can eventually switch his code over to calling close_to_point()
2790 // instead, which is intended to be used for this purpose.
2791 if (tol > TOLERANCE)
2792 {
2793 libmesh_do_once(libMesh::err
2794 << "WARNING: Resizing bounding box to match user-specified tolerance!\n"
2795 << "In the future, calls to Elem::contains_point() with tol > TOLERANCE\n"
2796 << "will be more optimized, but should not be used\n"
2797 << "to search for points 'close to' elements!\n"
2798 << "Instead, use Elem::close_to_point() for this purpose.\n"
2799 << std::endl;);
2800 return this->point_test(p, tol, tol);
2801 }
2802 else
2803 return this->point_test(p, TOLERANCE, tol);
2804}
libMesh::err
OStreamProxy err
libMesh::TOLERANCE
static constexpr Real TOLERANCE
Definition libmesh_common.h:151

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::Poly2TriTriangulator::insert_refinement_points(), libMesh::PointLocatorNanoflann::operator()(), libMesh::PointLocatorTree::operator()(), libMesh::PointLocatorNanoflann::operator()(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), NavierSystem::side_constraint(), RationalMapTest< elem_type >::testContainsPoint(), PointLocatorTest::testLocator(), FETest< order, family, elem_type, CaseName >::testLoop(), and PointLocatorTest::testPlanar().

◆ 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 908 of file elem.C.

909{
910 // Our vertices are the first numbered nodes
911 const unsigned int nv = e->n_vertices();
912 const unsigned int my_nv = this->n_vertices();
913
914 // Check for vertex-to-vertex containment first; contains_point() is
915 // expensive
916 for (auto n : make_range(nv))
917 {
918 const Node * vertex = e->node_ptr(n);
919 for (auto my_n : make_range(my_nv))
920 if (&this->node_ref(my_n) == vertex)
921 return true;
922 }
923
924 // If e is in our mesh, then we might be done testing
925 if (mesh_connection)
926 {
927 const unsigned int l = this->level();
928 const unsigned int el = e->level();
929
930 if (l >= el)
931 return false;
932
933 // We could also return false for l==el-1 iff we knew we had no
934 // triangular faces, but we don't have an API to check that.
935 }
936
937 // Our vertices are the first numbered nodes
938 for (auto n : make_range(nv))
939 if (this->contains_point(e->point(n)))
940 return true;
941 return false;
942}
libMesh::Elem::node_ref
const Node & node_ref(const unsigned int i) const
Definition elem.h:2538
libMesh::Elem::level
unsigned int level() const
Definition elem.h:3091

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

◆ 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 245 of file elem_refinement.C.

246{
247 // Subactive elements get deleted entirely, not contracted
248 libmesh_assert (this->active());
249
250 // Active contracted elements no longer can have children
251 _children.reset(nullptr);
252
253 if (this->refinement_flag() == Elem::JUST_COARSENED)
254 this->set_refinement_flag(Elem::DO_NOTHING);
255}

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

◆ debug_buffer()

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

Print our buffer for debugging.

Definition at line 652 of file dof_object.C.

653{
654 libMesh::out << " [ ";
655 for (const auto & idx : _idx_buf)
656 libMesh::out << idx << " ";
657 libMesh::out << "]\n";
658}
libMesh::MeshTools::Generation::Private::idx
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.
Definition mesh_generation.C:81
libMesh
The libMesh namespace provides an interface to certain functionality in the library.
libMesh::out
OStreamProxy out

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

◆ default_order()

Order libMesh::Quad9::default_order ( ) const
overridevirtual
Returns
SECOND.

Implements libMesh::Elem.

Definition at line 180 of file face_quad9.C.

181{
182 return SECOND;
183}

References libMesh::SECOND.

◆ 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 1011 of file elem.h.

1011{ return default_order(); }

References libMesh::Elem::default_order().

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

◆ dim()

virtual unsigned short libMesh::Face::dim ( ) const
inlinefinaloverridevirtualinherited
Returns
2, the dimensionality of the object.

Implements libMesh::Elem.

Definition at line 61 of file face.h.

61{ return 2; }

◆ disable_print_counter_info() [1/2]

void libMesh::ReferenceCounter::disable_print_counter_info ( )
staticinherited

Definition at line 100 of file reference_counter.C.

101{
102 _enable_print_counter = false;
103 return;
104}
libMesh::ReferenceCounter::_enable_print_counter
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called.
Definition reference_counter.h:143

References libMesh::ReferenceCounter::_enable_print_counter.

◆ disable_print_counter_info() [2/2]

void libMesh::ReferenceCounter::disable_print_counter_info ( )
staticinherited

Definition at line 100 of file reference_counter.C.

101{
102 _enable_print_counter = false;
103 return;
104}

References libMesh::ReferenceCounter::_enable_print_counter.

◆ 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.

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}
libMesh::DofObject::unique_id
unique_id_type unique_id() const
Definition dof_object.h:835
libMesh::DofObject::valid_unique_id
bool valid_unique_id() const
Definition dof_object.h:869
libMesh::DofObject::id
dof_id_type id() const
Definition dof_object.h:819
libMesh::Elem::n_sides
virtual unsigned int n_sides() const =0

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::Polyhedron::side_clones(), libMesh::Polyhedron::side_ptr(), and libMesh::Elem::true_centroid().

◆ 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 1008 of file dof_object.h.

1011{
1012 libmesh_assert_less (s, this->n_systems());
1013 libmesh_assert_less (var, this->n_vars(s));
1014 libmesh_assert_less (comp, this->n_comp(s,var));
1015
1016 const std::pair<unsigned int, unsigned int>
1017 vg_vig = this->var_to_vg_and_offset(s,var);
1018
1019 const unsigned int
1020 n_comp = this->n_comp_group(s,vg_vig.first);
1021
1022 return this->dof_number(s, vg_vig.first, vg_vig.second,
1023 comp, n_comp);
1024}
libMesh::DofObject::n_comp
unsigned int n_comp(const unsigned int s, const unsigned int var) const
Definition dof_object.h:978
libMesh::DofObject::n_comp_group
unsigned int n_comp_group(const unsigned int s, const unsigned int vg) const
Definition dof_object.h:991
libMesh::DofObject::dof_number
dof_id_type dof_number(const unsigned int s, const unsigned int var, const unsigned int comp) const
Definition dof_object.h:1008
libMesh::DofObject::var_to_vg_and_offset
std::pair< unsigned int, unsigned int > var_to_vg_and_offset(const unsigned int s, const unsigned int var) const
Definition dof_object.h:1176

References libMesh::DofObject::dof_number(), libMesh::DofObject::n_comp(), libMesh::DofObject::n_comp_group(), libMesh::DofObject::n_systems(), 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< OutputType >::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::DofMap::dof_indices(), libMesh::DofObject::dof_number(), libMesh::DofObject::DofObject(), libMesh::OldSolutionValue< Output, point_output >::eval_at_node(), libMesh::OldSolutionCoefs< Output, point_output >::eval_at_node(), libMesh::OldSolutionValue< Output, point_output >::eval_at_node(), libMesh::OldSolutionCoefs< Output, point_output >::eval_at_node(), libMesh::OldSolutionCoefs< Output, point_output >::eval_mixed_derivatives(), libMesh::OldSolutionValue< Output, point_output >::eval_mixed_derivatives(), libMesh::OldSolutionValue< Output, point_output >::eval_old_dofs(), libMesh::OldSolutionCoefs< Output, point_output >::eval_old_dofs(), fill_dirichlet_bc(), libMesh::VariationalSmootherConstraint::fix_node(), libMesh::Elem::get_info(), libMesh::Node::get_info(), AssemblyPointLoadX::get_nodal_rhs_values(), AssemblyPointLoadY::get_nodal_rhs_values(), AssemblyPointLoadZ::get_nodal_rhs_values(), libMesh::DofMap::local_variable_indices(), main(), libMesh::DofMap::old_dof_indices(), libMesh::BuildProjectionList::operator()(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectInteriors::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::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::PetscPreconditioner< T >::set_hypre_ads_data(), libMesh::PetscPreconditioner< T >::set_hypre_ams_data(), libMesh::DofMap::set_nonlocal_dof_objects(), ParsedFEMFunctionTest::setUp(), DofObjectTest< DerivedClass >::testJensEftangBug(), DofObjectTest< DerivedClass >::testManualDofCalculation(), libMesh::BoundaryVolumeSolutionTransfer::transfer_boundary_volume(), libMesh::DTKAdapter::update_variable_values(), and libMesh::Nemesis_IO_Helper::write_nodal_solution().

◆ 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 1029 of file dof_object.h.

1034{
1035 libmesh_assert_less (s, this->n_systems());
1036 libmesh_assert_less (vg, this->n_var_groups(s));
1037 libmesh_assert_less (vig, this->n_vars(s,vg));
1038
1039 const unsigned int
1040 start_idx_sys = this->start_idx(s);
1041
1042 libmesh_assert_less ((start_idx_sys + 2*vg + 1), _idx_buf.size());
1043
1044 const dof_id_type
1045 base_idx = _idx_buf[start_idx_sys + 2*vg + 1];
1046
1047 // if the first component is invalid, they
1048 // are all invalid
1049 if (base_idx == invalid_id)
1050 return invalid_id;
1051
1052 // otherwise the index is the first component
1053 // index augmented by the component number
1054 else
1055 return cast_int<dof_id_type>(base_idx + vig*n_comp + comp);
1056}
libMesh::DofObject::start_idx
unsigned int start_idx(const unsigned int s) const
The starting index for system s.
Definition dof_object.h:1225

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

◆ 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 2709 of file elem.h.

2710{
2711 return {0, cast_int<unsigned short>(this->n_edges())};
2712}
libMesh::Elem::n_edges
virtual unsigned int n_edges() const =0

References libMesh::Elem::n_edges().

Referenced by libMesh::MeshTools::Modification::all_rbb(), libMesh::FE< Dim, T >::cache(), libMesh::FEGenericBase< OutputType >::coarsened_dof_values(), libMesh::BoundaryInfo::copy_boundary_ids(), libMesh::ElemCutter::find_intersection_points(), libMesh::Elem::quality(), and libMesh::Parallel::Packing< Elem * >::unpack().

◆ edges_adjacent_to_node()

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

Implements libMesh::Elem.

Definition at line 200 of file face_quad.C.

201{
202 libmesh_assert_less(n, this->n_nodes());
203
204 // For vertices, we use the Quad::adjacent_sides_map, otherwise each
205 // of the mid-edge nodes is adjacent only to the edge it is on, and the
206 // center node is not adjacent to any edge.
207 if (this->is_vertex(n))
208 return {std::begin(adjacent_sides_map[n]), std::end(adjacent_sides_map[n])};
209 else if (this->is_edge(n))
210 return {n - this->n_vertices()};
211
212 libmesh_assert(this->is_face(n));
213 return {};
214}
libMesh::Elem::is_face
virtual bool is_face(const unsigned int i) const =0
libMesh::Elem::is_edge
virtual bool is_edge(const unsigned int i) const =0
libMesh::Elem::is_vertex
virtual bool is_vertex(const unsigned int i) const =0
libMesh::Quad::n_vertices
virtual unsigned int n_vertices() const override final
Definition face_quad.h:102
libMesh::Quad::adjacent_sides_map
static const unsigned int adjacent_sides_map[4][2]
This maps the node to the (in this case) 2 side ids adjacent to the node.
Definition face_quad.h:254
libMesh::Quad::n_nodes
virtual unsigned int n_nodes() const override
Definition face_quad.h:92

References libMesh::Quad::adjacent_sides_map, libMesh::Elem::is_edge(), libMesh::Elem::is_face(), libMesh::Elem::is_vertex(), libMesh::libmesh_assert(), libMesh::Quad::n_nodes(), and libMesh::Quad::n_vertices().

◆ embedding_matrix()

virtual Real libMesh::Quad9::embedding_matrix ( const unsigned int  i,
const unsigned int  j,
const unsigned int  k 
) const
inlineoverrideprotectedvirtual

Matrix used to create the elements children.

Implements libMesh::Elem.

Definition at line 240 of file face_quad9.h.

243 { return _embedding_matrix[i][j][k]; }
libMesh::Quad9::_embedding_matrix
static const Real _embedding_matrix[num_children][num_nodes][num_nodes]
Matrix that computes new nodal locations/solution values from current nodes/solution.
Definition face_quad9.h:249

References _embedding_matrix.

◆ 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 2060 of file elem.h.

2060{ return 0; }

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

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

Enabled by default.

Definition at line 94 of file reference_counter.C.

95{
96 _enable_print_counter = true;
97 return;
98}

References libMesh::ReferenceCounter::_enable_print_counter.

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

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

Enabled by default.

Definition at line 94 of file reference_counter.C.

95{
96 _enable_print_counter = true;
97 return;
98}

References libMesh::ReferenceCounter::_enable_print_counter.

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

◆ end_idx()

unsigned int libMesh::DofObject::end_idx ( const unsigned int  s) const
inlineprivateinherited

The ending index for system s.

Definition at line 1236 of file dof_object.h.

1237{
1238 libmesh_assert_less (s, this->n_systems());
1239 libmesh_assert_less (s, _idx_buf.size());
1240
1241 return ((s+1) == this->n_pseudo_systems()) ?
1242 cast_int<unsigned int>(_idx_buf.size()) :
1243 cast_int<unsigned int>(_idx_buf[s+1]);
1244}
int
void ErrorVector unsigned int
Definition adjoints_ex3.C:360
libMesh::DofObject::n_pseudo_systems
unsigned int n_pseudo_systems() const
Definition dof_object.h:923
TIMPI::cast_int
Tnew cast_int(Told oldvar)

References libMesh::DofObject::_idx_buf, libMesh::DofObject::n_pseudo_systems(), and libMesh::DofObject::n_systems().

Referenced by libMesh::DofObject::n_var_groups(), and libMesh::DofObject::set_n_vars_per_group().

◆ end_idx_ints()

unsigned int libMesh::DofObject::end_idx_ints ( ) const
inlineprivateinherited

The ending index for an extra_integers pseudosystem.

Definition at line 1263 of file dof_object.h.

1264{
1265 libmesh_assert (this->has_extra_integers());
1266
1267 return cast_int<unsigned int>(_idx_buf.size());
1268}

References libMesh::DofObject::_idx_buf, libMesh::DofObject::has_extra_integers(), and libMesh::libmesh_assert().

◆ 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 2718 of file elem.h.

2719{
2720 return {0, cast_int<unsigned short>(this->n_faces())};
2721}
libMesh::Elem::n_faces
virtual unsigned int n_faces() const =0

References libMesh::Elem::n_faces().

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

◆ 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 2110 of file elem.C.

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

References libMesh::ElemInternal::family_tree().

◆ 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 2118 of file elem.C.

2120{
2121 ElemInternal::family_tree(this, family, reset);
2122}

References libMesh::ElemInternal::family_tree().

◆ 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 2212 of file elem.C.

2215{
2216 ElemInternal::family_tree_by_neighbor(this, family, neighbor, reset);
2217}
libMesh::ElemInternal::family_tree_by_neighbor
void family_tree_by_neighbor(T elem, std::vector< T > &family, T neighbor_in, bool reset=true)
Definition elem_internal.h:211

References libMesh::ElemInternal::family_tree_by_neighbor().

◆ 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 2221 of file elem.C.

2224{
2225 ElemInternal::family_tree_by_neighbor(this, family, neighbor, reset);
2226}

References libMesh::ElemInternal::family_tree_by_neighbor().

◆ 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 2158 of file elem.C.

2161{
2162 ElemInternal::family_tree_by_side(this, family, side, reset);
2163}
libMesh::ElemInternal::family_tree_by_side
void family_tree_by_side(T elem, std::vector< T > &family, unsigned int s, bool reset)
Definition elem_internal.h:117

References libMesh::ElemInternal::family_tree_by_side().

◆ 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 2167 of file elem.C.

2170{
2171 ElemInternal::family_tree_by_side(this, family, side, reset);
2172}

References libMesh::ElemInternal::family_tree_by_side().

◆ 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 2248 of file elem.C.

2252{
2253 ElemInternal::family_tree_by_subneighbor(this, family, neighbor, subneighbor, reset);
2254}
libMesh::ElemInternal::family_tree_by_subneighbor
void family_tree_by_subneighbor(T elem, std::vector< T > &family, T neighbor_in, T subneighbor, bool reset=true)
Definition elem_internal.h:266

References libMesh::ElemInternal::family_tree_by_subneighbor().

◆ 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 2258 of file elem.C.

2262{
2263 ElemInternal::family_tree_by_subneighbor(this, family, neighbor, subneighbor, reset);
2264}

References libMesh::ElemInternal::family_tree_by_subneighbor().

◆ 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 1057 of file elem.C.

1060{
1061 // Simple but perhaps suboptimal code: find elements containing the
1062 // first point, then winnow this set down by removing elements which
1063 // don't also contain the second point
1064
1065 libmesh_assert(this->contains_point(p2));
1066 this->find_point_neighbors(p1, neighbor_set);
1067
1068 std::set<const Elem *>::iterator it = neighbor_set.begin();
1069 const std::set<const Elem *>::iterator end = neighbor_set.end();
1070
1071 while (it != end)
1072 {
1073 // As of C++11, set::erase returns an iterator to the element
1074 // following the erased element, or end.
1075 if (!(*it)->contains_point(p2))
1076 it = neighbor_set.erase(it);
1077 else
1078 ++it;
1079 }
1080}
libMesh::Elem::find_point_neighbors
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:967

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

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

◆ 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 1084 of file elem.C.

1085{
1086 neighbor_set.clear();
1087 neighbor_set.insert(this);
1088
1089 std::set<const Elem *> untested_set, next_untested_set;
1090 untested_set.insert(this);
1091
1092 while (!untested_set.empty())
1093 {
1094 // Loop over all the elements in the patch that haven't already
1095 // been tested
1096 for (const auto & elem : untested_set)
1097 {
1098 for (auto current_neighbor : elem->neighbor_ptr_range())
1099 {
1100 if (current_neighbor &&
1101 current_neighbor != remote_elem) // we have a real neighbor on this side
1102 {
1103 if (current_neighbor->active()) // ... if it is active
1104 {
1105 if (this->contains_edge_of(current_neighbor) // ... and touches us
1106 || current_neighbor->contains_edge_of(this))
1107 {
1108 // Make sure we'll test it
1109 if (!neighbor_set.count(current_neighbor))
1110 next_untested_set.insert (current_neighbor);
1111
1112 // And add it
1113 neighbor_set.insert (current_neighbor);
1114 }
1115 }
1116#ifdef LIBMESH_ENABLE_AMR
1117 else // ... the neighbor is *not* active,
1118 { // ... so add *all* neighboring
1119 // active children
1120 std::vector<const Elem *> active_neighbor_children;
1121
1122 current_neighbor->active_family_tree_by_neighbor
1123 (active_neighbor_children, elem);
1124
1125 for (const auto & current_child : active_neighbor_children)
1126 if (this->contains_edge_of(current_child) || current_child->contains_edge_of(this))
1127 {
1128 // Make sure we'll test it
1129 if (!neighbor_set.count(current_child))
1130 next_untested_set.insert (current_child);
1131
1132 neighbor_set.insert (current_child);
1133 }
1134 }
1135#endif // #ifdef LIBMESH_ENABLE_AMR
1136 }
1137 }
1138 }
1139 untested_set.swap(next_untested_set);
1140 next_untested_set.clear();
1141 }
1142}
libMesh::Elem::contains_edge_of
bool contains_edge_of(const Elem *e) const
Definition elem.C:946

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

◆ 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 1146 of file elem.C.

1147{
1148 ElemInternal::find_interior_neighbors(this, neighbor_set);
1149}
libMesh::ElemInternal::find_interior_neighbors
void find_interior_neighbors(T this_elem, std::set< T > &neighbor_set)
Definition elem_internal.h:501

References libMesh::ElemInternal::find_interior_neighbors().

◆ 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 1153 of file elem.C.

1154{
1155 ElemInternal::find_interior_neighbors(this, neighbor_set);
1156}

References libMesh::ElemInternal::find_interior_neighbors().

◆ 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 967 of file elem.C.

969{
970 libmesh_assert(this->contains_point(p));
971 libmesh_assert(this->active());
972
973 neighbor_set.clear();
974 neighbor_set.insert(this);
975
976 std::set<const Elem *> untested_set, next_untested_set;
977 untested_set.insert(this);
978
979#ifdef LIBMESH_ENABLE_AMR
980 std::vector<const Elem *> active_neighbor_children;
981#endif // #ifdef LIBMESH_ENABLE_AMR
982
983 while (!untested_set.empty())
984 {
985 // Loop over all the elements in the patch that haven't already
986 // been tested
987 for (const auto & elem : untested_set)
988 for (auto current_neighbor : elem->neighbor_ptr_range())
989 {
990 if (current_neighbor &&
991 current_neighbor != remote_elem) // we have a real neighbor on this side
992 {
993 if (current_neighbor->active()) // ... if it is active
994 {
995 auto it = neighbor_set.lower_bound(current_neighbor);
996 if ((it == neighbor_set.end() || *it != current_neighbor) &&
997 current_neighbor->contains_point(p)) // ... don't have and touches p
998 {
999 // Add it and test it
1000 next_untested_set.insert(current_neighbor);
1001 neighbor_set.emplace_hint(it, current_neighbor);
1002 }
1003 }
1004#ifdef LIBMESH_ENABLE_AMR
1005 else // ... the neighbor is *not* active,
1006 { // ... so add *all* neighboring
1007 // active children that touch p
1008 active_neighbor_children.clear();
1009 current_neighbor->active_family_tree_by_neighbor
1010 (active_neighbor_children, elem);
1011
1012 for (const auto & current_child : active_neighbor_children)
1013 {
1014 auto it = neighbor_set.lower_bound(current_child);
1015 if ((it == neighbor_set.end() || *it != current_child) &&
1016 current_child->contains_point(p))
1017 {
1018 // Add it and test it
1019 next_untested_set.insert(current_child);
1020 neighbor_set.emplace_hint(it, current_child);
1021 }
1022 }
1023 }
1024#endif // #ifdef LIBMESH_ENABLE_AMR
1025 }
1026 }
1027 untested_set.swap(next_untested_set);
1028 next_untested_set.clear();
1029 }
1030}

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

◆ 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 1034 of file elem.C.

1035{
1036 this->find_point_neighbors(neighbor_set, this);
1037}

References libMesh::Elem::find_point_neighbors().

◆ 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 1041 of file elem.C.

1043{
1044 ElemInternal::find_point_neighbors(this, neighbor_set, start_elem);
1045}
libMesh::ElemInternal::find_point_neighbors
void find_point_neighbors(T this_elem, std::set< T > &neighbor_set, T start_elem)
Definition elem_internal.h:429

References libMesh::ElemInternal::find_point_neighbors().

◆ 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 1049 of file elem.C.

1051{
1052 ElemInternal::find_point_neighbors(this, neighbor_set, start_elem);
1053}

References libMesh::ElemInternal::find_point_neighbors().

◆ 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 3099 of file elem.C.

3100{
3101 switch (et)
3102 {
3103 case NODEELEM:
3104 return NODEELEM;
3105 case EDGE2:
3106 case EDGE3:
3107 case EDGE4:
3108 return EDGE2;
3109 case TRI3:
3110 case TRI6:
3111 case TRI7:
3112 return TRI3;
3113 case TRISHELL3:
3114 return TRISHELL3;
3115 case QUAD4:
3116 case QUAD8:
3117 case QUAD9:
3118 return QUAD4;
3119 case QUADSHELL4:
3120 case QUADSHELL8:
3121 case QUADSHELL9:
3122 return QUADSHELL4;
3123 case TET4:
3124 case TET10:
3125 case TET14:
3126 return TET4;
3127 case HEX8:
3128 case HEX27:
3129 case HEX20:
3130 return HEX8;
3131 case PRISM6:
3132 case PRISM15:
3133 case PRISM18:
3134 case PRISM20:
3135 case PRISM21:
3136 return PRISM6;
3137 case PYRAMID5:
3138 case PYRAMID13:
3139 case PYRAMID14:
3140 case PYRAMID18:
3141 return PYRAMID5;
3142
3143#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
3144
3145 case INFEDGE2:
3146 return INFEDGE2;
3147 case INFQUAD4:
3148 case INFQUAD6:
3149 return INFQUAD4;
3150 case INFHEX8:
3151 case INFHEX16:
3152 case INFHEX18:
3153 return INFHEX8;
3154 case INFPRISM6:
3155 case INFPRISM12:
3156 return INFPRISM6;
3157
3158#endif
3159
3160 default:
3161 // unknown element
3162 return INVALID_ELEM;
3163 }
3164}

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

◆ flip()

void libMesh::Quad9::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 470 of file face_quad9.C.

471{
472 libmesh_assert(boundary_info);
473
474 swap2nodes(0,1);
475 swap2nodes(2,3);
476 swap2nodes(5,7);
477 swap2neighbors(1,3);
478 swap2boundarysides(1,3,boundary_info);
479 swap2boundaryedges(1,3,boundary_info);
480}
libMesh::Elem::swap2nodes
void swap2nodes(unsigned int n1, unsigned int n2)
Swaps two node_ptrs.
Definition elem.h:2101
libMesh::Elem::swap2neighbors
void swap2neighbors(unsigned int n1, unsigned int n2)
Swaps two neighbor_ptrs.
Definition elem.h:2111
libMesh::Elem::swap2boundarysides
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:3579
libMesh::Elem::swap2boundaryedges
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:3595

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

◆ 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 1122 of file dof_object.h.

1123{
1124#ifndef NDEBUG
1125 const unsigned int n_more_integers = (sizeof(T)-1)/sizeof(dof_id_type);
1126#endif
1127 libmesh_assert_less(index+n_more_integers, this->n_extra_integers());
1128 libmesh_assert_less(this->n_systems(), _idx_buf.size());
1129
1130 const unsigned int start_idx_i = this->start_idx_ints();
1131
1132 libmesh_assert_less(start_idx_i+index+n_more_integers, _idx_buf.size());
1133 T returnval;
1134 std::memcpy(&returnval, &_idx_buf[start_idx_i+index], sizeof(T));
1135 return returnval;
1136}
libMesh::DofObject::start_idx_ints
unsigned int start_idx_ints() const
The starting index for an extra_integers pseudosystem.
Definition dof_object.h:1249

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_rbb(), 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< DerivedClass >::testAddExtraData().

◆ 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 1078 of file dof_object.h.

1079{
1080 libmesh_assert_less(index, this->n_extra_integers());
1081 libmesh_assert_less(this->n_systems(), _idx_buf.size());
1082
1083 const unsigned int start_idx_i = this->start_idx_ints();
1084
1085 libmesh_assert_less(start_idx_i+index, _idx_buf.size());
1086 return _idx_buf[start_idx_i+index];
1087}

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::CheckpointIO::read_nodes(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::DofObject::set_n_vars_per_group(), DofObjectTest< DerivedClass >::testAddExtraData(), DofObjectTest< DerivedClass >::testAddSystemExtraInts(), ExtraIntegersTest::testExtraIntegersExodusReading(), DofObjectTest< DerivedClass >::testSetNSystemsExtraInts(), DofObjectTest< DerivedClass >::testSetNVariableGroupsExtraInts(), and libMesh::XdrIO::write_serialized_nodes().

◆ 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.

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}
libMesh::ReferenceCounter::_counts
static Counts _counts
Actually holds the data.
Definition reference_counter.h:124
libMesh::Quality::name
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition elem_quality.C:42

References libMesh::ReferenceCounter::_counts.

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

◆ 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.

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}

References libMesh::ReferenceCounter::_counts.

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

◆ get_info() [3/3]

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

Prints relevant information about the element to a string.

Definition at line 2956 of file elem.C.

2957{
2958 std::ostringstream oss;
2959
2960 oss << " Elem Information" << '\n'
2961 << " id()=";
2962
2963 if (this->valid_id())
2964 oss << this->id();
2965 else
2966 oss << "invalid";
2967
2968#ifdef LIBMESH_ENABLE_UNIQUE_ID
2969 oss << ", unique_id()=";
2970 if (this->valid_unique_id())
2971 oss << this->unique_id();
2972 else
2973 oss << "invalid";
2974#endif
2975
2976 oss << ", subdomain_id()=" << this->subdomain_id();
2977 oss << ", processor_id()=" << this->processor_id() << '\n';
2978
2979 oss << " type()=" << Utility::enum_to_string(this->type()) << '\n'
2980 << " dim()=" << this->dim() << '\n'
2981 << " n_nodes()=" << this->n_nodes() << '\n';
2982
2983 oss << " mapping=" << Utility::enum_to_string(this->mapping_type()) << '\n';
2984
2985 for (auto n : this->node_index_range())
2986 {
2987 oss << " " << n << this->node_ref(n);
2988 if (this->mapping_type() == RATIONAL_BERNSTEIN_MAP)
2989 {
2990 const unsigned char datum_index = this->mapping_data();
2991 oss << " weight=" <<
2992 this->node_ref(n).get_extra_datum<Real>(datum_index) << '\n';
2993 }
2994 }
2995
2996 oss << " n_sides()=" << this->n_sides() << '\n';
2997
2998 for (auto s : this->side_index_range())
2999 {
3000 oss << " neighbor(" << s << ")=";
3001 if (this->neighbor_ptr(s))
3002 oss << this->neighbor_ptr(s)->id() << '\n';
3003 else
3004 oss << "nullptr\n";
3005 }
3006
3007 if (!this->infinite())
3008 {
3009 oss << " hmin()=" << this->hmin()
3010 << ", hmax()=" << this->hmax() << '\n'
3011 << " volume()=" << this->volume() << '\n';
3012 }
3013 oss << " active()=" << this->active()
3014 << ", ancestor()=" << this->ancestor()
3015 << ", subactive()=" << this->subactive()
3016 << ", has_children()=" << this->has_children() << '\n'
3017 << " parent()=";
3018 if (this->parent())
3019 oss << this->parent()->id() << '\n';
3020 else
3021 oss << "nullptr\n";
3022 oss << " level()=" << this->level()
3023 << ", p_level()=" << this->p_level() << '\n'
3024#ifdef LIBMESH_ENABLE_AMR
3025 << " refinement_flag()=" << Utility::enum_to_string(this->refinement_flag()) << '\n'
3026 << " p_refinement_flag()=" << Utility::enum_to_string(this->p_refinement_flag()) << '\n'
3027#endif
3028#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
3029 << " infinite()=" << this->infinite() << '\n';
3030 if (this->infinite())
3031 oss << " origin()=" << this->origin() << '\n'
3032#endif
3033 ;
3034
3035 oss << " DoFs=";
3036 for (auto s : make_range(this->n_systems()))
3037 for (auto v : make_range(this->n_vars(s)))
3038 for (auto c : make_range(this->n_comp(s,v)))
3039 oss << '(' << s << '/' << v << '/' << this->dof_number(s,v,c) << ") ";
3040
3041
3042 return oss.str();
3043}
libMesh::DofObject::valid_id
bool valid_id() const
Definition dof_object.h:861
libMesh::DofObject::processor_id
processor_id_type processor_id() const
Definition dof_object.h:881
libMesh::DofObject::get_extra_datum
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:1122
libMesh::Elem::mapping_data
unsigned char mapping_data() const
Definition elem.h:3153
libMesh::Elem::origin
virtual Point origin() const
Definition elem.h:1923
libMesh::Elem::ancestor
bool ancestor() const
Definition elem.C:2019
libMesh::Elem::hmin
virtual Real hmin() const
Definition elem.C:683
libMesh::Elem::dim
virtual unsigned short dim() const =0
libMesh::Elem::subdomain_id
subdomain_id_type subdomain_id() const
Definition elem.h:2591
libMesh::Elem::hmax
virtual Real hmax() const
Definition elem.C:707
libMesh::Elem::mapping_type
ElemMappingType mapping_type() const
Definition elem.h:3137
libMesh::Elem::volume
virtual Real volume() const
Definition elem.C:3462
libMesh::Elem::p_level
unsigned int p_level() const
Definition elem.h:3125
libMesh::Elem::p_refinement_flag
RefinementState p_refinement_flag() const
Definition elem.h:3243
libMesh::Elem::neighbor_ptr
const Elem * neighbor_ptr(unsigned int i) const
Definition elem.h:2615
libMesh::Elem::infinite
virtual bool infinite() const =0
libMesh::Elem::side_index_range
IntRange< unsigned short > side_index_range() const
Definition elem.h:2727
libMesh::RATIONAL_BERNSTEIN_MAP
@ RATIONAL_BERNSTEIN_MAP
Definition enum_elem_type.h:96

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(), 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::MeshTetInterface::check_hull_integrity(), libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::inverse_map(), and libMesh::Elem::print_info().

◆ 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 2554 of file elem.h.

2555{
2556 for (auto n : make_range(this->n_nodes()))
2557 if (this->_nodes[n] == node_ptr)
2558 return n;
2559
2560 return libMesh::invalid_uint;
2561}
libMesh::Elem::_nodes
Node ** _nodes
Pointers to the nodes we are connected to.
Definition elem.h:2254
libMesh::Elem::node_ptr
const Node * node_ptr(const unsigned int i) const
Definition elem.h:2516

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::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(), ElemTest< elem_type >::test_n_refinements(), and VolumeTest::testC0PolyhedronMethods().

◆ get_nodes()

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

Definition at line 2508 of file elem.h.

2509{
2510 return _nodes;
2511}

References libMesh::Elem::_nodes.

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

◆ get_old_dof_object() [1/2]

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

Pointer accessor for previously public old_dof_object.

If you want to assert that the old_dof_object pointer is valid as well, consider using the get_old_dof_object_ref() accessor instead.

Definition at line 96 of file dof_object.h.

96{ return old_dof_object.get(); }

References libMesh::DofObject::old_dof_object.

Referenced by libMesh::OldSolutionBase< Output, point_output >::check_old_context(), libMesh::OldSolutionBase< Output, point_output >::check_old_context(), libMesh::OldSolutionValue< Output, point_output >::eval_at_node(), libMesh::OldSolutionCoefs< Output, point_output >::eval_at_node(), libMesh::OldSolutionValue< Output, point_output >::eval_at_node(), libMesh::OldSolutionCoefs< Output, point_output >::eval_at_node(), libMesh::OldSolutionCoefs< Output, point_output >::eval_mixed_derivatives(), libMesh::OldSolutionValue< Output, point_output >::eval_mixed_derivatives(), libMesh::DofMap::old_dof_indices(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SortAndCopy::operator()(), libMesh::BuildProjectionList::operator()(), and libMesh::DofObject::operator=().

◆ 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.

97{ return old_dof_object.get(); }

References libMesh::DofObject::old_dof_object.

◆ 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.

105 {
106 libmesh_assert(old_dof_object);
107 return *old_dof_object;
108 }

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

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

◆ 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.

111 {
112 libmesh_assert(old_dof_object);
113 return *old_dof_object;
114 }

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

◆ 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 3281 of file elem.h.

3282{
3283 if (p == 0)
3284 libmesh_assert_not_equal_to
3285 (this->p_refinement_flag(), Elem::JUST_REFINED);
3286
3287 _p_level = cast_int<unsigned char>(p);
3288}
libMesh::Elem::_p_level
unsigned char _p_level
p refinement level - the difference between the polynomial degree on this element and the minimum pol...
Definition elem.h:2299

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

◆ 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 3292 of file elem.h.

3294{
3295 _pflag = cast_int<unsigned char>(pflag);
3296 this->hack_p_level(p);
3297}
libMesh::Elem::hack_p_level
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:3281
libMesh::Elem::_pflag
unsigned char _pflag
p refinement flag.
Definition elem.h:2289

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

Referenced by libMesh::Parallel::Packing< Elem * >::unpack().

◆ has_affine_map()

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

Reimplemented from libMesh::Elem.

Definition at line 157 of file face_quad9.C.

158{
159 // make sure corners form a parallelogram
160 Point v = this->point(1) - this->point(0);
161 if (!v.relative_fuzzy_equals(this->point(2) - this->point(3), affine_tol))
162 return false;
163 // make sure "horizontal" sides are straight
164 v /= 2;
165 if (!v.relative_fuzzy_equals(this->point(4) - this->point(0), affine_tol) ||
166 !v.relative_fuzzy_equals(this->point(6) - this->point(3), affine_tol))
167 return false;
168 // make sure "vertical" sides are straight
169 // and the center node is centered
170 v = (this->point(3) - this->point(0))/2;
171 if (!v.relative_fuzzy_equals(this->point(7) - this->point(0), affine_tol) ||
172 !v.relative_fuzzy_equals(this->point(5) - this->point(1), affine_tol) ||
173 !v.relative_fuzzy_equals(this->point(8) - this->point(4), affine_tol))
174 return false;
175 return true;
176}
libMesh::Elem::affine_tol
static constexpr Real affine_tol
Default tolerance to use in has_affine_map().
Definition elem.h:2070

References libMesh::Elem::affine_tol, libMesh::Elem::point(), and libMesh::TypeVector< T >::relative_fuzzy_equals().

◆ 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 3010 of file elem.h.

3011{
3012#ifdef LIBMESH_ENABLE_AMR
3013 if (!_children)
3014 return false;
3015 else
3016 for (auto & c : child_ref_range())
3017 if (c.has_children())
3018 return true;
3019#endif
3020 return false;
3021}

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

Referenced by ElemTest< elem_type >::test_n_refinements().

◆ has_children()

bool libMesh::Elem::has_children ( ) const
inlineinherited
Returns
true if the element has any children (active or not), false otherwise, or if AMR is disabled.

Definition at line 2996 of file elem.h.

2997{
2998#ifdef LIBMESH_ENABLE_AMR
2999 if (!_children)
3000 return false;
3001 else
3002 return true;
3003#else
3004 return false;
3005#endif
3006}

References libMesh::Elem::_children.

Referenced by libMesh::Elem::add_child(), libMesh::BoundaryInfo::add_elements(), libMesh::Elem::ancestor(), libMesh::connect_children(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::Elem::get_info(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Elem >(), main(), 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::FEMSystem::mesh_position_set(), libMesh::Elem::remove_links_to_me(), libMesh::Elem::replace_child(), libMesh::Elem::set_child(), libMesh::Elem::subactive(), libMesh::Parallel::sync_element_data_by_parent_id(), ElemTest< elem_type >::test_n_refinements(), libMesh::Parallel::Packing< Elem * >::unpack(), and libMesh::Elem::which_child_am_i().

◆ 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 1202 of file dof_object.h.

1203{
1204 if (sys == libMesh::invalid_uint)
1205 {
1206 for (auto s : make_range(this->n_systems()))
1207 if (this->n_vars(s))
1208 return true;
1209 }
1210
1211 else
1212 {
1213 libmesh_assert_less (sys, this->n_systems());
1214
1215 if (this->n_vars(sys))
1216 return true;
1217 }
1218
1219 return false;
1220}

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

Referenced by libMesh::DofMap::old_dof_indices(), and libMesh::Parallel::Packing< Node * >::unpack().

◆ has_extra_integers()

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

Returns whether extra integers are associated to the DofObject.

Definition at line 1164 of file dof_object.h.

1165{
1166 if (_idx_buf.empty())
1167 return 0;
1168
1169 return (dof_id_signed_type(_idx_buf[0]) < 0);
1170}

References libMesh::DofObject::_idx_buf.

Referenced by libMesh::DofObject::add_system(), libMesh::DofObject::end_idx_ints(), libMesh::DofObject::set_n_vars_per_group(), libMesh::DofObject::start_idx_ints(), DofObjectTest< DerivedClass >::testAddExtraData(), DofObjectTest< DerivedClass >::testAddSystemExtraInts(), and DofObjectTest< DerivedClass >::testSetNSystemsExtraInts().

◆ 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::Tet4, libMesh::Edge2, libMesh::Edge3, libMesh::Edge4, libMesh::Quad4, libMesh::Tri3, and libMesh::NodeElem.

Definition at line 2914 of file elem.C.

2915{
2916 QNodal qnodal {this->dim()};
2917 FEMap fe_map;
2918 auto & jac = fe_map.get_jacobian();
2919
2920 // We have a separate check for is_singular_node() below, so in this
2921 // case its "OK" to do nodal quadrature on pyramids.
2922 qnodal.allow_nodal_pyramid_quadrature = true;
2923 qnodal.init(*this);
2924 auto & qp = qnodal.get_points();
2925 libmesh_assert_equal_to(qp.size(), this->n_nodes());
2926
2927 std::vector<Point> one_point(1);
2928 std::vector<Real> one_weight(1,1);
2929 for (auto i : index_range(qp))
2930 {
2931 if (this->is_singular_node(i))
2932 continue;
2933
2934 one_point[0] = qp[i];
2935
2936 fe_map.init_reference_to_physical_map(this->dim(), one_point, this);
2937 fe_map.compute_map(this->dim(), one_weight, this, false);
2938
2939 if (jac[0] <= 0)
2940 return false;
2941 }
2942
2943 return true;
2944}
libMesh::Elem::is_singular_node
virtual bool is_singular_node(unsigned int) const
Definition elem.h:1847

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

Referenced by VolumeTest::testEdge4Invertible().

◆ 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 2645 of file elem.h.

2646{
2647 for (auto n : this->neighbor_ptr_range())
2648 if (n == elem)
2649 return true;
2650
2651 return false;
2652}

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

◆ 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 1324 of file elem.C.

1328{
1329 // First see if this is a normal "interior" neighbor
1330 if (has_neighbor(elem))
1331 return true;
1332
1333 for (auto n : this->side_index_range())
1334 if (this->topological_neighbor(n, mesh, point_locator, pb))
1335 return true;
1336
1337 return false;
1338}
libMesh::Elem::has_neighbor
bool has_neighbor(const Elem *elem) const
Definition elem.h:2645
libMesh::Elem::topological_neighbor
const Elem * topological_neighbor(const unsigned int i, const MeshBase &mesh, const PointLocatorBase &point_locator, const PeriodicBoundaries *pb) const
Definition elem.C:1287

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

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

◆ hmax()

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

Definition at line 707 of file elem.C.

708{
709 Real h_max=0;
710
711 // Avoid calling a virtual a lot of times
712 const auto n_vertices = this->n_vertices();
713
714 for (unsigned int n_outer=0; n_outer<n_vertices; n_outer++)
715 for (unsigned int n_inner=n_outer+1; n_inner<n_vertices; n_inner++)
716 {
717 const auto diff = (this->point(n_outer) - this->point(n_inner));
718
719 h_max = std::max(h_max, diff.norm_sq());
720 }
721
722 return std::sqrt(h_max);
723}

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::DiscontinuityMeasure::internal_side_integration(), libMesh::LaplacianErrorEstimator::internal_side_integration(), libMesh::KellyErrorEstimator::internal_side_integration(), and libMesh::Elem::point_test().

◆ hmin()

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

Definition at line 683 of file elem.C.

684{
685 // Avoid calling a virtual a lot of times
686 const auto n_vertices = this->n_vertices();
687
688 // Special case for NodeElem
689 if (!n_vertices)
690 return 0;
691
692 Real h_min=std::numeric_limits<Real>::max();
693
694 for (unsigned int n_outer=0; n_outer<n_vertices; n_outer++)
695 for (unsigned int n_inner=n_outer+1; n_inner<n_vertices; n_inner++)
696 {
697 const auto diff = (this->point(n_outer) - this->point(n_inner));
698
699 h_min = std::min(h_min, diff.norm_sq());
700 }
701
702 return std::sqrt(h_min);
703}

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

Referenced by assemble_SchroedingerEquation(), compute_enriched_soln(), libMesh::FEGenericBase< OutputType >::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()().

◆ id()

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

Definition at line 819 of file dof_object.h.

820{
821 return _id;
822}
libMesh::DofObject::_id
dof_id_type _id
The id of the DofObject.
Definition dof_object.h:574

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::DistributedMesh::add_elem(), libMesh::ReplicatedMesh::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::TopologyMap::add_node(), libMesh::DistributedMesh::add_node(), libMesh::ReplicatedMesh::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(), assemble_shell(), libMesh::MeshTools::Generation::build_cube(), libMesh::Partitioner::build_graph(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::MeshTetInterface::check_hull_integrity(), compute_jacobian(), libMesh::FEGenericBase< OutputType >::compute_periodic_constraints(), libMesh::FEAbstract::compute_periodic_node_constraints(), compute_residual(), libMesh::InfFE< Dim, T_radial, T_map >::compute_shape_functions(), libMesh::MeshBase::copy_constraint_rows(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::MeshRefinement::create_parent_error_vector(), libMesh::DistributedMesh::delete_elem(), libMesh::ReplicatedMesh::delete_elem(), libMesh::DistributedMesh::delete_node(), libMesh::ReplicatedMesh::delete_node(), libMesh::Elem::disconnected_clone(), libMesh::C0Polyhedron::disconnected_clone(), libMesh::StaticCondensationDofMap::dof_indices(), libMesh::DTKAdapter::DTKAdapter(), libMesh::UNVIO::elements_out(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::find_dofs_to_send(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::MeshTools::find_nodal_neighbors(), libMesh::MeshTools::find_nodal_neighbors(), libMesh::MeshTools::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::Elem::get_info(), libMesh::Node::get_info(), libMesh::MeshBase::get_info(), libMesh::VariationalSmootherConstraint::get_neighbors_for_boundary_constraint(), libMesh::VariationalSmootherConstraint::get_neighbors_for_subdomain_constraint(), libMesh::MeshTetInterface::improve_hull_integrity(), libMesh::ParmetisPartitioner::initialize(), libMesh::TreeNode< N >::insert(), libMesh::TriangulatorInterface::insert_any_extra_boundary_points(), libMesh::DistributedMesh::insert_elem(), libMesh::ReplicatedMesh::insert_elem(), libMesh::Poly2TriTriangulator::insert_refinement_points(), EIM_F::interior_assembly(), AssemblyEIM::interior_assembly(), libMesh::MeshTools::Modification::interpolate_surface(), 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(), MeshPerElemTest< elem_type >::meshes_equal_enough(), LinearElasticityWithContact::move_mesh(), libMesh::MeshTools::n_connected_components(), libMesh::FE< Dim, T >::nodal_soln(), libMesh::Elem::node_id(), libMesh::TriangulatorInterface::nodes_to_segments(), libMesh::VTKIO::nodes_to_vtk(), libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::CompareDofObjectsByID::operator()(), libMesh::CompareDofObjectsByPIDAndThenID::operator()(), libMesh::CompareElemIdsByLevel::operator()(), libMesh::GhostPointNeighbors::operator()(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectVertices::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::DistributedMesh::query_elem_ptr(), libMesh::query_ghosting_functors(), libMesh::DistributedMesh::query_node_ptr(), libMesh::DistributedMesh::query_node_ptr(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::EquationSystems::redundant_added_side(), libMesh::SimplexRefiner::refine_via_edges(), 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, build_nx, CaseName >::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_n_refinements(), ElemTest< elem_type >::test_orient_elements(), DefaultCouplingTest::testCoupling(), MixedDimensionMeshTest::testPointLocatorTree(), InfFERadialTest::testRefinement(), DofObjectTest< DerivedClass >::testSetId(), DisjointNeighborTest::testTempJump(), libMesh::Elem::topologically_equal(), libMesh::NetGenMeshInterface::triangulate(), libMesh::TetGenMeshInterface::triangulate_conformingDelaunayMesh_carvehole(), libMesh::Poly2TriTriangulator::triangulate_current_points(), libMesh::Parallel::Packing< Elem * >::unpack(), libMesh::MeshTetInterface::volume_to_surface_mesh(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::GmshIO::write_mesh(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), and libMesh::XdrIO::write_serialized_nodes().

◆ 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.

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}
libMesh::BasicOStreamProxy::get
streamT * get()
Rather than implement every ostream/ios/ios_base function, we'll be lazy and make esoteric uses go th...
Definition ostream_proxy.h:217
libMesh::Threads::spin_mtx
spin_mutex spin_mtx
A convenient spin mutex object which can be used for obtaining locks.
Definition threads.C:30

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

Referenced by libMesh::ReferenceCountedObject< T >::ReferenceCountedObject(), libMesh::ReferenceCountedObject< T >::ReferenceCountedObject(), and libMesh::ReferenceCountedObject< T >::ReferenceCountedObject().

◆ 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.

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}

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

Referenced by libMesh::ReferenceCountedObject< T >::ReferenceCountedObject(), libMesh::ReferenceCountedObject< T >::ReferenceCountedObject(), and libMesh::ReferenceCountedObject< T >::ReferenceCountedObject().

◆ 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.

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}

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

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

◆ 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.

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}

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

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

◆ infinite() [1/2]

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

Definition at line 1927 of file elem.h.

1927{ return false; }

◆ infinite() [2/2]

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

Implements libMesh::Elem.

Definition at line 113 of file face.h.

113{ 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 3356 of file elem.h.

3357{
3358 this->set_mapping_type(src.mapping_type());
3359 this->set_mapping_data(src.mapping_data());
3360 this->subdomain_id() = src.subdomain_id();
3361 this->processor_id(src.processor_id());
3362#ifdef LIBMESH_ENABLE_AMR
3363 this->set_p_level(src.p_level());
3364#endif
3365}
libMesh::Elem::set_mapping_type
void set_mapping_type(const ElemMappingType type)
Sets the value of the mapping type for the element.
Definition elem.h:3145
libMesh::Elem::set_mapping_data
void set_mapping_data(const unsigned char data)
Sets the value of the mapping data for the element.
Definition elem.h:3161

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

◆ interior_parent() [1/2]

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

Definition at line 1205 of file elem.C.

1206{
1207 // See the const version for comments
1208 if (this->dim() >= LIBMESH_DIM)
1209 return nullptr;
1210
1211 Elem * interior_p = _elemlinks[1+this->n_sides()];
1212
1213 libmesh_assert (!interior_p ||
1214 (interior_p == remote_elem) ||
1215 (interior_p->dim() > this->dim()));
1216
1217 return interior_p;
1218}
libMesh::Elem::_elemlinks
Elem ** _elemlinks
Pointers to this element's parent and neighbors, and for lower-dimensional elements' interior_parent.
Definition elem.h:2260

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

◆ interior_parent() [2/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 1160 of file elem.C.

1161{
1162 // interior parents make no sense for full-dimensional elements.
1163 if (this->dim() >= LIBMESH_DIM)
1164 return nullptr;
1165
1166 // they USED TO BE only good for level-0 elements, but we now
1167 // support keeping interior_parent() valid on refined boundary
1168 // elements.
1169 // if (this->level() != 0)
1170 // return this->parent()->interior_parent();
1171
1172 // We store the interior_parent pointer after both the parent
1173 // neighbor and neighbor pointers
1174 Elem * interior_p = _elemlinks[1+this->n_sides()];
1175
1176 // If we have an interior_parent, we USED TO assume it was a
1177 // one-higher-dimensional interior element, but we now allow e.g.
1178 // edge elements to have a 3D interior_parent with no
1179 // intermediate 2D element.
1180 // libmesh_assert (!interior_p ||
1181 // interior_p->dim() == (this->dim()+1));
1182 libmesh_assert (!interior_p ||
1183 (interior_p == remote_elem) ||
1184 (interior_p->dim() > this->dim()));
1185
1186 // If an element in a multi-dimensional mesh has an interior_parent
1187 // link, it should be at our level or coarser, just like a neighbor
1188 // link. Our collect_families() code relies on this, but it might
1189 // be tempting for users to manually assign something that breaks
1190 // it.
1191 //
1192 // However, we *also* create temporary side elements, and we don't
1193 // bother with creating ancestors for those, so they can be at level
1194 // 0 even when they're sides of non-level-0 elements.
1195 libmesh_assert (!interior_p ||
1196 (interior_p->level() <= this->level()) ||
1197 (this->level() == 0 &&
1198 this->id() == DofObject::invalid_id));
1199
1200 return interior_p;
1201}

References libMesh::Elem::_elemlinks, libMesh::Elem::dim(), 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()(), ElemTest< elem_type >::test_n_refinements(), libMesh::Elem::topologically_equal(), libMesh::BoundaryVolumeSolutionTransfer::transfer_boundary_volume(), libMesh::BoundaryVolumeSolutionTransfer::transfer_volume_boundary(), and libMesh::Parallel::Packing< Elem * >::unpack().

◆ invalidate()

void libMesh::DofObject::invalidate ( )
inlineinherited

Invalidates all the indices for this DofObject.

Definition at line 779 of file dof_object.h.

780{
781 this->invalidate_dofs ();
782 this->invalidate_id ();
783 this->invalidate_processor_id ();
784}
libMesh::DofObject::invalidate_processor_id
void invalidate_processor_id()
Sets the processor id to invalid_processor_id.
Definition dof_object.h:771
libMesh::DofObject::invalidate_id
void invalidate_id()
Sets the id to invalid_id.
Definition dof_object.h:763
libMesh::DofObject::invalidate_dofs
void invalidate_dofs(const unsigned int sys_num=libMesh::invalid_uint)
Sets all degree of freedom numbers to invalid_id.
Definition dof_object.h:742

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

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

◆ 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 742 of file dof_object.h.

743{
744 const unsigned int n_sys = this->n_systems();
745 // If the user does not specify the system number...
746 if (sys_num >= n_sys)
747 {
748 for (auto s : make_range(n_sys))
749 for (auto vg : make_range(this->n_var_groups(s)))
750 if (this->n_comp_group(s,vg))
751 this->set_vg_dof_base(s,vg,invalid_id);
752 }
753 // ...otherwise invalidate the dofs for all systems
754 else
755 for (auto vg : make_range(this->n_var_groups(sys_num)))
756 if (this->n_comp_group(sys_num,vg))
757 this->set_vg_dof_base(sys_num,vg,invalid_id);
758}
libMesh::DofObject::set_vg_dof_base
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:1273

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

◆ invalidate_id()

void libMesh::DofObject::invalidate_id ( )
inlineinherited

Sets the id to invalid_id.

Definition at line 763 of file dof_object.h.

764{
765 this->set_id (invalid_id);
766}
libMesh::DofObject::set_id
dof_id_type & set_id()
Definition dof_object.h:827

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

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

◆ invalidate_processor_id()

void libMesh::DofObject::invalidate_processor_id ( )
inlineinherited

Sets the processor id to invalid_processor_id.

Definition at line 771 of file dof_object.h.

772{
773 this->processor_id (invalid_processor_id);
774}
libMesh::DofObject::invalid_processor_id
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:484

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

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

◆ 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 3026 of file elem.h.

3031{
3032#ifdef LIBMESH_ENABLE_AMR
3033 const Elem * e = descendant;
3034 while (e)
3035 {
3036 if (this == e)
3037 return true;
3038 e = e->parent();
3039 }
3040#endif
3041 return false;
3042}

References libMesh::Elem::parent().

Referenced by libMesh::UnstructuredMesh::find_neighbors(), and ElemTest< elem_type >::test_n_refinements().

◆ 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 2333 of file elem.C.

2335{
2336 libmesh_assert_less (c, this->n_children());
2337 libmesh_assert_less (e, this->n_edges());
2338
2339 std::unique_ptr<const Elem> my_edge = this->build_edge_ptr(e);
2340 std::unique_ptr<const Elem> child_edge = this->child_ptr(c)->build_edge_ptr(e);
2341
2342 // We're assuming that an overlapping child edge has the same
2343 // number and orientation as its parent
2344 return (child_edge->node_id(0) == my_edge->node_id(0) ||
2345 child_edge->node_id(1) == my_edge->node_id(1));
2346}
libMesh::Elem::build_edge_ptr
virtual std::unique_ptr< Elem > build_edge_ptr(const unsigned int i)=0

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

Referenced by libMesh::FEGenericBase< OutputType >::coarsened_dof_values(), libMesh::BoundaryInfo::edge_boundary_ids(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectEdges::operator()(), and ElemTest< elem_type >::test_n_refinements().

◆ is_child_on_side()

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

Implements libMesh::Elem.

Definition at line 134 of file face_quad.C.

136{
137 libmesh_assert_less (c, this->n_children());
138 libmesh_assert_less (s, this->n_sides());
139
140 // A quad's children and nodes don't share the same ordering:
141 // child 2 and 3 are swapped;
142 unsigned int n = (c < 2) ? c : 5-c;
143 return (n == s || n == (s+1)%4);
144}
libMesh::Quad::n_children
virtual unsigned int n_children() const override final
Definition face_quad.h:112
libMesh::Quad::n_sides
virtual unsigned int n_sides() const override final
Definition face_quad.h:97

References libMesh::Quad::n_children(), and libMesh::Quad::n_sides().

◆ is_edge()

bool libMesh::Quad9::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 119 of file face_quad9.C.

120{
121 if (i < 4)
122 return false;
123 if (i > 7)
124 return false;
125 return true;
126}

◆ is_edge_on_side()

virtual bool libMesh::Face::is_edge_on_side ( const unsigned int  e,
const unsigned int  s 
) const
inlinefinaloverridevirtualinherited

is_edge_on_side is trivial in 2D.

Implements libMesh::Elem.

Definition at line 89 of file face.h.

91 { return (e == s); }

◆ is_face()

bool libMesh::Quad9::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 128 of file face_quad9.C.

129{
130 if (i > 7)
131 return true;
132 return false;
133}

◆ is_flipped()

bool libMesh::Quad::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 184 of file face_quad.C.

185{
186 return (
187#if LIBMESH_DIM > 2
188 // Don't bother outside the XY plane
189 !this->point(0)(2) && !this->point(1)(2) &&
190 !this->point(2)(2) && !this->point(3)(2) &&
191#endif
192 ((this->point(1)(0)-this->point(0)(0))*
193 (this->point(3)(1)-this->point(0)(1)) <
194 (this->point(3)(0)-this->point(0)(0))*
195 (this->point(1)(1)-this->point(0)(1))));
196}

References libMesh::Elem::point().

◆ 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 3611 of file elem.C.

3612{
3613 switch (this->dim())
3614 {
3615 case 0:
3616 return false;
3617
3618 case 1:
3619 return !this->is_vertex(i);
3620
3621 case 2:
3622 return !this->is_vertex(i) && !this->is_edge(i);
3623
3624 case 3:
3625 return !this->is_vertex(i) && !this->is_edge(i) && !this->is_face(i);
3626
3627 default:
3628 libmesh_error_msg("impossible element dimension " << std::to_string(this->dim()));
3629 return 0;
3630 }
3631}

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

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

◆ 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::Tet4, libMesh::Edge2, libMesh::Tri3, libMesh::Tri3Subdivision, and libMesh::NodeElem.

Definition at line 1207 of file elem.h.

1207{ return false; }

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

◆ 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::InfHex, libMesh::InfPrism, and libMesh::InfQuad.

Definition at line 1914 of file elem.h.

1915 { libmesh_assert (!this->infinite()); return false; }

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

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

◆ is_node_on_edge()

virtual bool libMesh::Quad9::is_node_on_edge ( const unsigned int  n,
const unsigned int  e 
) const
inlineoverridevirtual
Returns
true if the specified (local) node number is on the specified edge (== is_node_on_side in 2D).

Implements libMesh::Elem.

Definition at line 113 of file face_quad9.h.

115 { return this->is_node_on_side(n,e); }
libMesh::Quad9::is_node_on_side
virtual bool is_node_on_side(const unsigned int n, const unsigned int s) const override
Definition face_quad9.C:135

References is_node_on_side().

◆ is_node_on_side()

bool libMesh::Quad9::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 135 of file face_quad9.C.

137{
138 libmesh_assert_less (s, n_sides());
139 return std::find(std::begin(side_nodes_map[s]),
140 std::end(side_nodes_map[s]),
141 n) != std::end(side_nodes_map[s]);
142}
libMesh::Quad9::side_nodes_map
static const unsigned int side_nodes_map[num_sides][nodes_per_side]
This maps the node of the side to element node numbers.
Definition face_quad9.h:204

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

Referenced by is_node_on_edge().

◆ 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 596 of file elem.h.

597 { return false; }

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

◆ 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 840 of file elem.C.

841{
842 std::set<const Elem *> point_neighbors;
843
844 this->find_point_neighbors(point_neighbors);
845
846 for (const auto & elem : point_neighbors)
847 if (elem->processor_id() == my_pid)
848 return true;
849
850 return false;
851}

References libMesh::Elem::find_point_neighbors().

◆ is_singular_node()

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

Reimplemented in libMesh::Pyramid.

Definition at line 1847 of file elem.h.

1847{ return false; }

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

◆ is_vertex()

bool libMesh::Quad9::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 112 of file face_quad9.C.

113{
114 if (i < 4)
115 return true;
116 return false;
117}

◆ 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 773 of file elem.h.

775 { return this->is_vertex(n); }

References libMesh::Elem::is_vertex().

Referenced by libMesh::Elem::parent_bracketing_nodes(), and ElemTest< elem_type >::test_n_refinements().

◆ 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 3532 of file elem.C.

3534{
3535#ifdef LIBMESH_ENABLE_AMR
3536
3537 unsigned int my_n_vertices = this->n_vertices();
3538 for (unsigned int n_parent = 0; n_parent != my_n_vertices;
3539 ++n_parent)
3540 if (this->node_ptr(n_parent) == this->child_ptr(c)->node_ptr(n))
3541 return true;
3542 return false;
3543
3544#else
3545
3546 // No AMR?
3547 libmesh_ignore(c,n);
3548 libmesh_error_msg("ERROR: AMR disabled, how did we get here?");
3549 return true;
3550
3551#endif
3552}
libMesh::libmesh_ignore
void libmesh_ignore(const Args &...)
Definition libmesh_common.h:569

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()(), and ElemTest< elem_type >::test_n_refinements().

◆ key() [1/4]

dof_id_type libMesh::Elem::key ( ) const
virtual

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

Reimplemented from libMesh::Quad.

Definition at line 290 of file elem.C.

739{
740 const unsigned short n_n = this->n_nodes();
741
742 std::array<dof_id_type, Elem::max_n_nodes> node_ids;
743
744 for (unsigned short n=0; n != n_n; ++n)
745 node_ids[n] = this->node_id(n);
746
747 // Always sort, so that different local node numberings hash to the
748 // same value.
749 std::sort (node_ids.begin(), node_ids.begin()+n_n);
750
751 return Utility::hashword(node_ids.data(), n_n);
752}
libMesh::Quad9::n_nodes
virtual unsigned int n_nodes() const override
Definition face_quad9.h:76

◆ key() [2/4]

dof_id_type libMesh::Quad9::key ( ) const
overridevirtual

Compute a unique key for this element which is suitable for hashing (not necessarily unique, but close).

The key is based solely on the mid-face node's global id, to be consistent with 3D elements that have Quad9 faces (Hex27, Prism18, etc.).

Reimplemented from libMesh::Quad.

Definition at line 220 of file face_quad9.C.

221{
222 return this->compute_key(this->node_id(8));
223}
libMesh::Elem::compute_key
static dof_id_type compute_key(dof_id_type n0)
Definition elem.h:3311

References libMesh::Elem::compute_key(), and libMesh::Elem::node_id().

◆ key() [3/4]

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

We reimplement this method here for the Quad9 since we can use the center node of each edge to provide a perfect (unique) key.

Reimplemented from libMesh::Quad.

Definition at line 187 of file face_quad9.C.

188{
189 libmesh_assert_less (s, this->n_sides());
190
191 switch (s)
192 {
193 case 0:
194
195 return
196 this->compute_key (this->node_id(4));
197
198 case 1:
199
200 return
201 this->compute_key (this->node_id(5));
202
203 case 2:
204
205 return
206 this->compute_key (this->node_id(6));
207
208 case 3:
209
210 return
211 this->compute_key (this->node_id(7));
212
213 default:
214 libmesh_error_msg("Invalid side s = " << s);
215 }
216}

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

◆ key() [4/4]

virtual dof_id_type libMesh::Elem::key ( const unsigned int  s) const
virtual

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

Reimplemented from libMesh::Quad.

◆ 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 727 of file elem.C.

729{
730 libmesh_assert_less ( n1, this->n_vertices() );
731 libmesh_assert_less ( n2, this->n_vertices() );
732
733 return (this->point(n1) - this->point(n2)).norm();
734}

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

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

◆ 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 3091 of file elem.h.

3092{
3093#ifdef LIBMESH_ENABLE_AMR
3094
3095 // if I don't have a parent I was
3096 // created directly from file
3097 // or by the user, so I am a
3098 // level-0 element
3099 if (this->parent() == nullptr)
3100 return 0;
3101
3102 // if the parent and this element are of different
3103 // dimensionality we are at the same level as
3104 // the parent (e.g. we are the 2D side of a
3105 // 3D element)
3106 if (this->dim() != this->parent()->dim())
3107 return this->parent()->level();
3108
3109 // otherwise we are at a level one
3110 // higher than our parent
3111 return (this->parent()->level() + 1);
3112
3113#else
3114
3115 // Without AMR all elements are
3116 // at level 0.
3117 return 0;
3118
3119#endif
3120}

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

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::BoundaryInfo::add_edge(), libMesh::BoundaryInfo::add_edge(), libMesh::BoundaryInfo::add_shellface(), libMesh::BoundaryInfo::add_shellface(), libMesh::BoundaryInfo::add_side(), libMesh::BoundaryInfo::add_side(), libMesh::MeshTools::Modification::all_rbb(), assemble_ellipticdg(), libMesh::BoundaryInfo::boundary_ids(), libMesh::EquationSystems::build_discontinuous_solution_vector(), compute_jacobian(), libMesh::FEAbstract::compute_node_constraints(), libMesh::FEGenericBase< OutputType >::compute_periodic_constraints(), libMesh::FEAbstract::compute_periodic_node_constraints(), libMesh::FEGenericBase< OutputType >::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::BoundaryInfo::remove_edge(), libMesh::Elem::remove_links_to_me(), libMesh::BoundaryInfo::remove_shellface(), 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::Elem::topological_neighbor(), libMesh::Parallel::Packing< Elem * >::unpack(), libMesh::MeshTetInterface::volume_to_surface_mesh(), and libMesh::Elem::which_neighbor_am_i().

◆ libmesh_assert_valid_neighbors()

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

Checks for consistent neighbor links on this element.

Definition at line 1357 of file elem.C.

1358{
1359 for (auto n : this->side_index_range())
1360 {
1361 const Elem * neigh = this->neighbor_ptr(n);
1362
1363 // Any element might have a remote neighbor; checking
1364 // to make sure that's not inaccurate is tough.
1365 if (neigh == remote_elem)
1366 continue;
1367
1368 if (neigh)
1369 {
1370 // Only subactive elements have subactive neighbors
1371 libmesh_assert (this->subactive() || !neigh->subactive());
1372
1373 const Elem * elem = this;
1374
1375 // If we're subactive but our neighbor isn't, its
1376 // return neighbor link will be to our first active
1377 // ancestor OR to our inactive ancestor of the same
1378 // level as neigh,
1379 if (this->subactive() && !neigh->subactive())
1380 {
1381 for (elem = this; !elem->active();
1382 elem = elem->parent())
1383 libmesh_assert(elem);
1384 }
1385 else
1386 {
1387 unsigned int rev = neigh->which_neighbor_am_i(elem);
1388 libmesh_assert_less (rev, neigh->n_neighbors());
1389
1390 if (this->subactive() && !neigh->subactive())
1391 {
1392 while (neigh->neighbor_ptr(rev) != elem)
1393 {
1394 libmesh_assert(elem->parent());
1395 elem = elem->parent();
1396 }
1397 }
1398 else
1399 {
1400 const Elem * nn = neigh->neighbor_ptr(rev);
1401 libmesh_assert(nn);
1402
1403 for (; elem != nn; elem = elem->parent())
1404 libmesh_assert(elem);
1405 }
1406 }
1407 }
1408 // If we don't have a neighbor and we're not subactive, our
1409 // ancestors shouldn't have any neighbors in this same
1410 // direction.
1411 else if (!this->subactive())
1412 {
1413 const Elem * my_parent = this->parent();
1414 if (my_parent &&
1415 // A parent with a different dimension isn't really one of
1416 // our ancestors, it means we're on a boundary mesh and this
1417 // is an interior mesh element for which we're on a side.
1418 // Nothing to test for in that case.
1419 (my_parent->dim() == this->dim()))
1420 libmesh_assert (!my_parent->neighbor_ptr(n));
1421 }
1422 }
1423}

References libMesh::Elem::active(), 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().

◆ 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 1345 of file elem.C.

1346{
1347 libmesh_assert(this->valid_id());
1348 for (auto n : this->node_index_range())
1349 {
1350 libmesh_assert(this->node_ptr(n));
1351 libmesh_assert(this->node_ptr(n)->valid_id());
1352 }
1353}

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

◆ local_edge_node()

unsigned int libMesh::Quad::local_edge_node ( unsigned int  edge,
unsigned int  edge_node 
) const
overridevirtualinherited

Calls local_side_node(edge, edge_node).

For 2D elements, there is an implied equivalence between edges and sides, e.g. n_edges() == n_sides(), so we treat these two functions the same.

Implements libMesh::Elem.

Definition at line 94 of file face_quad.C.

96{
97 return local_side_node(edge, edge_node);
98}
libMesh::Quad::local_side_node
virtual unsigned int local_side_node(unsigned int side, unsigned int side_node) const override
Definition face_quad.C:83

References libMesh::Quad::local_side_node().

◆ 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 2496 of file elem.h.

2497{
2498 for (auto n : make_range(this->n_nodes()))
2499 if (this->node_id(n) == i)
2500 return n;
2501
2502 return libMesh::invalid_uint;
2503}

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

Referenced by libMesh::MeshTetInterface::check_hull_integrity(), NodalNeighborsTest::do_test(), libMesh::MeshTetInterface::improve_hull_integrity(), libMesh::UnstructuredMesh::stitching_helper(), and ElemTest< elem_type >::test_n_refinements().

◆ local_side_node()

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

Reimplemented from libMesh::Quad.

Definition at line 227 of file face_quad9.C.

229{
230 libmesh_assert_less (side, this->n_sides());
231 libmesh_assert_less (side_node, Quad9::nodes_per_side);
232
233 return Quad9::side_nodes_map[side][side_node];
234}
libMesh::Quad9::nodes_per_side
static const int nodes_per_side
Definition face_quad9.h:198

References libMesh::Quad::n_sides(), nodes_per_side, and side_nodes_map.

◆ local_singular_node()

virtual unsigned int libMesh::Elem::local_singular_node ( const Point &  ,
const Real  = TOLERANCE*TOLERANCE 
) const
inlinevirtualinherited
Returns
The local node index of the given point IF said node has a singular Jacobian for this element. If the given point is not a node or is a node and does not have a singular Jacobian, this will return invalid_uint.

The intention is for this to be overridden in derived element classes that do have nodes that have singular Jacobians. When mapping failures are caught, we can check this to see if the failed physical point is actually a singular point and return the correct master point.

Reimplemented in libMesh::Pyramid.

Definition at line 1840 of file elem.h.

1841 { return invalid_uint; }

References libMesh::invalid_uint.

Referenced by libMesh::FEMap::inverse_map(), and FETest< order, family, elem_type, CaseName >::testLoop().

◆ loose_bounding_box()

BoundingBox libMesh::Quad9::loose_bounding_box ( ) const
overridevirtual
Returns
A bounding box (not necessarily the minimal bounding box) containing the geometric element.

Reimplemented from libMesh::Elem.

Definition at line 320 of file face_quad9.C.

321{
322 // This might have curved edges, or might be a curved surface in
323 // 3-space, in which case the full bounding box can be larger than
324 // the bounding box of just the nodes.
325 //
326 //
327 // FIXME - I haven't yet proven the formula below to be correct for
328 // biquadratics - RHS
329 Point pmin, pmax;
330
331 for (unsigned d=0; d<LIBMESH_DIM; ++d)
332 {
333 const Real center = this->point(8)(d);
334 Real hd = std::abs(center - this->point(0)(d));
335 for (unsigned int p=0; p != 8; ++p)
336 hd = std::max(hd, std::abs(center - this->point(p)(d)));
337
338 pmin(d) = center - hd;
339 pmax(d) = center + hd;
340 }
341
342 return BoundingBox(pmin, pmax);
343}

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

◆ low_order_key()

dof_id_type libMesh::Quad::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 73 of file face_quad.C.

74{
75 libmesh_assert_less (s, this->n_sides());
76
77 return this->compute_key(this->node_id(Quad4::side_nodes_map[s][0]),
78 this->node_id(Quad4::side_nodes_map[s][1]));
79}
libMesh::Quad4::side_nodes_map
static const unsigned int side_nodes_map[num_sides][nodes_per_side]
This maps the node of the side to element node numbers.
Definition face_quad4.h:155

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

◆ 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 1429 of file elem.C.

1430{
1431 Elem * neigh = this->neighbor_ptr(n);
1432
1433 // Don't bother calling this function unless it's necessary
1434 libmesh_assert(neigh);
1435 libmesh_assert(!neigh->is_remote());
1436
1437 const unsigned int this_level = this->level();
1438 const unsigned int neigh_level = neigh->level();
1439
1440 // We never have neighbors more refined than us
1441 libmesh_assert_less_equal (neigh_level, this_level);
1442
1443 // We never have subactive neighbors of non subactive elements
1444 libmesh_assert(!neigh->subactive() || this->subactive());
1445
1446 // If we have a neighbor less refined than us then it must not
1447 // have any more refined descendants we could have pointed to
1448 // instead.
1449 libmesh_assert((neigh_level == this_level) ||
1450 (neigh->active() && !this->subactive()) ||
1451 (!neigh->has_children() && this->subactive()));
1452
1453 // What side of neigh are we on? nn.
1454 //
1455 // We can't use the usual Elem method because we're in the middle of
1456 // restoring topology. We can't compare side_ptr nodes because
1457 // users want to abuse neighbor_ptr to point to
1458 // not-technically-neighbors across mesh slits. We can't compare
1459 // node locations because users want to move those
1460 // not-technically-neighbors until they're
1461 // not-even-geometrically-neighbors.
1462
1463 // Find any elements that might need to point to elem
1464 std::vector<Elem *> neigh_family;
1465#ifdef LIBMESH_ENABLE_AMR
1466 neigh->total_family_tree_by_side(neigh_family, nn);
1467#else
1468 neigh_family.push_back(neigh);
1469#endif
1470
1471 // Pull objects out of the loop to reduce heap operations
1472 std::unique_ptr<Elem> my_side, neigh_side;
1473
1474 // And point them to elem
1475 for (auto & neigh_family_member : neigh_family)
1476 {
1477 // Only subactive elements point to other subactive elements
1478 const bool member_subactive = neigh_family_member->subactive();
1479 if (this->subactive() && !member_subactive)
1480 continue;
1481
1482 // neigh (and possibly some of its family) might be at a lower
1483 // level than us, with a neighbor at that lower level. We
1484 // would exit early if neigh was at a lower level, except we do
1485 // want to handle neighbor links from subactive descendents.
1486 const unsigned int member_level = neigh_family_member->level();
1487 if (member_level < this_level)
1488 continue;
1489
1490 // Ideally, the neighbor link ought to either be correct
1491 // already or ought to be to remote_elem.
1492 //
1493 // However, if we're redistributing a newly created elem,
1494 // after an AMR step but before find_neighbors has fixed up
1495 // neighbor links, we might have an out of date neighbor
1496 // link to elem's parent instead.
1497#ifdef LIBMESH_ENABLE_AMR
1498 libmesh_assert((neigh_family_member->neighbor_ptr(nn) &&
1499 (neigh_family_member->neighbor_ptr(nn)->active() ||
1500 this->is_ancestor_of(neigh_family_member->neighbor_ptr(nn)) ||
1501 neigh_family_member->neighbor_ptr(nn)->is_ancestor_of(this))) ||
1502 (neigh_family_member->neighbor_ptr(nn) == remote_elem) ||
1503 ((this->refinement_flag() == JUST_REFINED) &&
1504 (this->parent() != nullptr) &&
1505 (neigh_family_member->neighbor_ptr(nn) == this->parent())));
1506#else
1507 libmesh_assert((neigh_family_member->neighbor_ptr(nn) == this) ||
1508 (neigh_family_member->neighbor_ptr(nn) == remote_elem));
1509#endif
1510
1511 // Some of neigh's family might be at a higher (finer) level
1512 // than us, and might need to point back to one of our children
1513 // rather than to us.
1514 if (member_level > this_level)
1515 {
1516 if (this->ancestor())
1517 continue;
1518
1519 if (member_subactive && this->has_children())
1520 continue;
1521 }
1522
1523 // If neigh is at a coarser level than us, some of neigh's
1524 // subactive family just won't line up with us!
1525 if (neigh_level < this_level &&
1526 member_level > neigh_level)
1527 {
1528 libmesh_assert(member_subactive);
1529
1530 this->side_ptr(my_side, n);
1531 neigh_family_member->side_ptr(neigh_side, nn);
1532
1533 if (*my_side != *neigh_side)
1534 continue;
1535 }
1536
1537 neigh_family_member->set_neighbor(nn, this);
1538 }
1539}
libMesh::Elem::side_ptr
virtual std::unique_ptr< Elem > side_ptr(unsigned int i)=0

References libMesh::Elem::active(), libMesh::Elem::ancestor(), libMesh::Elem::has_children(), libMesh::Elem::is_remote(), libMesh::Elem::JUST_REFINED, libMesh::Elem::level(), libMesh::libmesh_assert(), libMesh::Elem::neighbor_ptr(), libMesh::remote_elem, libMesh::Elem::side_ptr(), libMesh::Elem::subactive(), and libMesh::Elem::total_family_tree_by_side().

Referenced by libMesh::Parallel::Packing< Elem * >::unpack().

◆ 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 1542 of file elem.C.

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

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(), and libMesh::Elem::which_child_am_i().

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

◆ mapping_data()

unsigned char libMesh::Elem::mapping_data ( ) const
inlineinherited
Returns
The value of the mapping data for the element.

Definition at line 3153 of file elem.h.

3154{
3155 return _map_data;
3156}
libMesh::Elem::_map_data
unsigned char _map_data
Mapping function data; currently used when needed to store the RATIONAL_BERNSTEIN nodal weight data i...
Definition elem.h:2312

References libMesh::Elem::_map_data.

Referenced by libMesh::MeshTools::Modification::all_tri(), libMesh::MeshTools::Modification::flatten(), libMesh::Elem::get_info(), libMesh::Elem::inherit_data_from(), 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(), and libMesh::rational_fe_weighted_shapes_derivs().

◆ mapping_type()

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

Definition at line 3137 of file elem.h.

3138{
3139 return static_cast<ElemMappingType>(_map_type);
3140}
libMesh::Elem::_map_type
unsigned char _map_type
Mapping function type; currently either 0 (LAGRANGE) or 1 (RATIONAL_BERNSTEIN).
Definition elem.h:2306
libMesh::ElemMappingType
ElemMappingType
Enumeration of possible element master->physical mapping types.
Definition enum_elem_type.h:94

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::Edge3::has_invertible_map(), libMesh::Edge4::has_invertible_map(), libMesh::Quad4::has_invertible_map(), libMesh::Elem::inherit_data_from(), libMesh::QComposite< QSubCell >::init(), libMesh::MeshTools::Modification::interpolate_surface(), libMesh::FEMap::map_fe_type(), libMesh::Polygon::Polygon(), libMesh::Polyhedron::Polyhedron(), libMesh::FE< Dim, T >::reinit(), libMesh::C0Polyhedron::side_vertex_average_normal(), libMesh::Hex8::side_vertex_average_normal(), libMesh::Prism6::side_vertex_average_normal(), libMesh::Pyramid5::side_vertex_average_normal(), libMesh::Quad4::side_vertex_average_normal(), libMesh::C0Polyhedron::true_centroid(), libMesh::C0Polyhedron::volume(), libMesh::Hex20::volume(), libMesh::Hex27::volume(), libMesh::Hex8::volume(), libMesh::Prism15::volume(), libMesh::Prism18::volume(), libMesh::Prism6::volume(), libMesh::Pyramid13::volume(), libMesh::Pyramid14::volume(), libMesh::Pyramid5::volume(), libMesh::Tet10::volume(), libMesh::Edge3::volume(), libMesh::Edge4::volume(), libMesh::Quad4::volume(), libMesh::Quad8::volume(), volume(), and libMesh::Tri6::volume().

◆ master_point()

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

Implements libMesh::Elem.

Definition at line 74 of file face_quad.h.

75 {
76 libmesh_assert_less(i, this->n_nodes());
77 return Point(_master_points[i][0],
78 _master_points[i][1],
79 _master_points[i][2]);
80 }
libMesh::Quad::_master_points
static const Real _master_points[9][3]
Master element node locations.
Definition face_quad.h:239

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

◆ 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 3263 of file elem.h.

3264{
3265 // This is undefined for subactive elements,
3266 // which have no active descendants
3267 libmesh_assert (!this->subactive());
3268 if (this->active())
3269 return this->p_level();
3270
3271 unsigned int max_p_level = _p_level;
3272 for (auto & c : child_ref_range())
3273 max_p_level = std::max(max_p_level,
3274 c.max_descendant_p_level());
3275 return max_p_level;
3276}
libMesh::Elem::max_descendant_p_level
unsigned int max_descendant_p_level() const
Definition elem.h:3263

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< OutputType >::coarsened_dof_values().

◆ 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 2379 of file elem.C.

2381{
2382 libmesh_assert(!this->subactive());
2383 libmesh_assert(neighbor_in->active());
2384
2385 // If we're an active element this is simple
2386 if (this->active())
2387 {
2388 unsigned int new_p_level = this->p_level();
2389 if (this->p_refinement_flag() == Elem::REFINE)
2390 new_p_level += 1;
2391 if (this->p_refinement_flag() == Elem::COARSEN)
2392 {
2393 libmesh_assert_greater (new_p_level, 0);
2394 new_p_level -= 1;
2395 }
2396 return std::min(current_min, new_p_level);
2397 }
2398
2399 libmesh_assert(has_neighbor(neighbor_in));
2400
2401 unsigned int min_p_level = current_min;
2402
2403 for (auto & c : this->child_ref_range())
2404 if (&c != remote_elem && c.has_neighbor(neighbor_in))
2405 min_p_level =
2406 c.min_new_p_level_by_neighbor(neighbor_in, min_p_level);
2407
2408 return min_p_level;
2409}
libMesh::Elem::min_new_p_level_by_neighbor
unsigned int min_new_p_level_by_neighbor(const Elem *neighbor, unsigned int current_min) const
Definition elem.C:2379

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

◆ 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 2350 of file elem.C.

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 return std::min(current_min, this->p_level());
2359
2360 libmesh_assert(has_neighbor(neighbor_in));
2361
2362 // The p_level() of an ancestor element is already the minimum
2363 // p_level() of its children - so if that's high enough, we don't
2364 // need to examine any children.
2365 if (current_min <= this->p_level())
2366 return current_min;
2367
2368 unsigned int min_p_level = current_min;
2369
2370 for (auto & c : this->child_ref_range())
2371 if (&c != remote_elem && c.has_neighbor(neighbor_in))
2372 min_p_level =
2373 c.min_p_level_by_neighbor(neighbor_in, min_p_level);
2374
2375 return min_p_level;
2376}
libMesh::Elem::min_p_level_by_neighbor
unsigned int min_p_level_by_neighbor(const Elem *neighbor, unsigned int current_min) const
Definition elem.C:2350

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< OutputType >::compute_periodic_constraints(), and libMesh::FEGenericBase< OutputType >::compute_proj_constraints().

◆ n_children()

virtual unsigned int libMesh::Quad::n_children ( ) const
inlinefinaloverridevirtualinherited
Returns
4.

Implements libMesh::Elem.

Definition at line 112 of file face_quad.h.

112{ return 4; }

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

◆ 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 978 of file dof_object.h.

980{
981 libmesh_assert_less (s, this->n_systems());
982 libmesh_assert_less (var, this->n_vars(s));
983
984 return this->n_comp_group(s,this->var_to_vg(s,var));
985}
libMesh::DofObject::var_to_vg
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:1317

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

Referenced by libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEGenericBase< OutputType >::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::dof_number(), libMesh::DofObject::DofObject(), libMesh::OldSolutionValue< Output, point_output >::eval_at_node(), libMesh::OldSolutionCoefs< Output, point_output >::eval_at_node(), libMesh::OldSolutionValue< Output, point_output >::eval_at_node(), libMesh::OldSolutionCoefs< Output, point_output >::eval_at_node(), libMesh::OldSolutionCoefs< Output, point_output >::eval_mixed_derivatives(), libMesh::OldSolutionValue< Output, point_output >::eval_mixed_derivatives(), libMesh::Elem::get_info(), libMesh::Node::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().

◆ 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 991 of file dof_object.h.

993{
994 libmesh_assert_less (s, this->n_systems());
995 libmesh_assert_less (vg, this->n_var_groups(s));
996
997 const unsigned int
998 start_idx_sys = this->start_idx(s);
999
1000 libmesh_assert_less ((start_idx_sys + 2*vg), _idx_buf.size());
1001
1002 return (_idx_buf[start_idx_sys + 2*vg] % ncv_magic);
1003}
libMesh::DofObject::ncv_magic
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:682

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::DofMap::dof_indices(), libMesh::DofObject::dof_number(), libMesh::OldSolutionValue< Output, point_output >::eval_old_dofs(), libMesh::OldSolutionCoefs< Output, point_output >::eval_old_dofs(), libMesh::DofObject::invalidate_dofs(), libMesh::DofObject::n_comp(), libMesh::DofMap::old_dof_indices(), libMesh::BuildProjectionList::operator()(), 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().

◆ 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 797 of file dof_object.h.

799{
800 libmesh_assert_less (s, this->n_systems());
801
802 unsigned int num = 0;
803
804 // Count all variables
805 if (var == libMesh::invalid_uint)
806 for (auto v : make_range(this->n_vars(s)))
807 num += this->n_comp(s,v);
808
809 // Only count specified variable
810 else
811 num = this->n_comp(s,var);
812
813 return num;
814}

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

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

◆ n_edges()

virtual unsigned int libMesh::Quad::n_edges ( ) const
inlinefinaloverridevirtualinherited
Returns
4. All quadrilaterals have 4 edges.

Implements libMesh::Elem.

Definition at line 107 of file face_quad.h.

107{ return 4; }

◆ 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 1146 of file dof_object.h.

1147{
1148 if (_idx_buf.empty())
1149 return 0;
1150
1151 const int hdr = dof_id_signed_type(_idx_buf[0]);
1152 if (hdr >= 0)
1153 return 0;
1154
1155 const unsigned int start_idx_i = this->start_idx_ints();
1156
1157 return _idx_buf.size() - start_idx_i;
1158}

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

Referenced by libMesh::DofObject::add_extra_integers(), libMesh::DofObject::add_extra_integers(), libMesh::MeshTools::Modification::all_tri(), libMesh::Elem::disconnected_clone(), libMesh::C0Polyhedron::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< DerivedClass >::testAddExtraData(), DofObjectTest< DerivedClass >::testAddSystemExtraInts(), DofObjectTest< DerivedClass >::testSetNSystemsExtraInts(), and DofObjectTest< DerivedClass >::testSetNVariableGroupsExtraInts().

◆ n_faces()

virtual unsigned int libMesh::Face::n_faces ( ) const
inlinefinaloverridevirtualinherited
Returns
0. All 2D elements have no faces, just edges.

Implements libMesh::Elem.

Definition at line 67 of file face.h.

67{ return 0; }

◆ 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 713 of file elem.h.

714 { return this->n_sides(); }

References libMesh::Elem::n_sides().

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

◆ n_nodes()

virtual unsigned int libMesh::Quad9::n_nodes ( ) const
inlineoverridevirtual
Returns
9.

Reimplemented from libMesh::Quad.

Definition at line 76 of file face_quad9.h.

76{ return 9; }

Referenced by second_order_adjacent_vertex(), and second_order_child_vertex().

◆ 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 667 of file elem.h.

668 { return this->n_nodes(); }

References libMesh::Elem::n_nodes().

Referenced by libMesh::Elem::as_parent_node(), libMesh::Elem::bracketing_nodes(), libMesh::Elem::parent_bracketing_nodes(), and ElemTest< elem_type >::test_n_refinements().

◆ 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.

86 { return _n_objects; }
libMesh::ReferenceCounter::_n_objects
static Threads::atomic< unsigned int > _n_objects
The number of objects.
Definition reference_counter.h:132

References libMesh::ReferenceCounter::_n_objects.

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

◆ 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.

86 { return _n_objects; }

References libMesh::ReferenceCounter::_n_objects.

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

◆ n_permutations()

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

Four sides, one orientation each.

Implements libMesh::Elem.

Definition at line 202 of file face_quad.h.

202{ 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 923 of file dof_object.h.

924{
925 const int hdr = _idx_buf.empty() ?
926 0 : cast_int<int>(dof_id_signed_type(_idx_buf[0]));
927 return std::abs(hdr);
928}

References libMesh::DofObject::_idx_buf.

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

◆ n_second_order_adjacent_vertices()

unsigned int libMesh::Quad9::n_second_order_adjacent_vertices ( const unsigned int  n) const
overridevirtual
Returns
2 for edge nodes and 4 for the face node.

Reimplemented from libMesh::Elem.

Definition at line 396 of file face_quad9.C.

397{
398 switch (n)
399 {
400 case 4:
401 case 5:
402 case 6:
403 case 7:
404 return 2;
405
406 case 8:
407 return 4;
408
409 default:
410 libmesh_error_msg("Invalid n = " << n);
411 }
412}

◆ n_sides()

virtual unsigned int libMesh::Quad::n_sides ( ) const
inlinefinaloverridevirtualinherited
Returns
4.

Implements libMesh::Elem.

Definition at line 97 of file face_quad.h.

97{ return 4; }

Referenced by libMesh::Quad::is_child_on_side(), libMesh::Quad4::is_node_on_side(), libMesh::Quad8::is_node_on_side(), is_node_on_side(), libMesh::Quad::key(), libMesh::Quad8::key(), key(), libMesh::Quad::local_side_node(), libMesh::Quad8::local_side_node(), local_side_node(), libMesh::Quad::low_order_key(), libMesh::Quad4::nodes_on_side(), libMesh::Quad8::nodes_on_side(), nodes_on_side(), libMesh::Quad::opposite_node(), and libMesh::Quad::side_ptr().

◆ n_sub_elem()

virtual unsigned int libMesh::Quad9::n_sub_elem ( ) const
inlineoverridevirtual
Returns
4.

Implements libMesh::Elem.

Definition at line 81 of file face_quad9.h.

81{ return 4; }

Referenced by connectivity().

◆ n_systems()

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

Definition at line 913 of file dof_object.h.

914{
915 const int hdr = _idx_buf.empty() ?
916 0 : cast_int<int>(dof_id_signed_type(_idx_buf[0]));
917 return hdr >= 0 ? hdr : (-hdr-1);
918}

References libMesh::DofObject::_idx_buf.

Referenced by libMesh::DofMap::_dof_indices(), libMesh::DofObject::add_system(), libMesh::DofObject::dof_number(), libMesh::DofObject::dof_number(), libMesh::DofObject::DofObject(), libMesh::DofObject::end_idx(), libMesh::OldSolutionValue< Output, point_output >::eval_old_dofs(), libMesh::OldSolutionCoefs< Output, point_output >::eval_old_dofs(), libMesh::DofObject::get_extra_datum(), libMesh::DofObject::get_extra_integer(), libMesh::Elem::get_info(), libMesh::Node::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::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< DerivedClass >::testAddSystemExtraInts(), DofObjectTest< DerivedClass >::testSetNSystems(), DofObjectTest< DerivedClass >::testSetNSystemsExtraInts(), and libMesh::DofObject::vg_dof_base().

◆ n_var_groups()

unsigned int libMesh::DofObject::n_var_groups ( const unsigned int  s) const
inlineinherited
Returns
The number of VariableGroup variable groups associated with system s for this DofObject

Definition at line 933 of file dof_object.h.

934{
935 libmesh_assert_less (s, this->n_systems());
936
937 return (this->end_idx(s) - this->start_idx(s)) / 2;
938}
libMesh::DofObject::end_idx
unsigned int end_idx(const unsigned int s) const
The ending index for system s.
Definition dof_object.h:1236

References libMesh::DofObject::end_idx(), libMesh::DofObject::n_systems(), and libMesh::DofObject::start_idx().

Referenced by libMesh::DofObject::add_system(), libMesh::DofObject::dof_number(), libMesh::DofObject::DofObject(), libMesh::DofObject::invalidate_dofs(), libMesh::DofObject::n_comp_group(), libMesh::DofObject::n_vars(), libMesh::DofObject::n_vars(), libMesh::BuildProjectionList::operator()(), libMesh::DofObject::operator=(), 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::set_vg_dof_base(), DofObjectTest< DerivedClass >::testSetNVariableGroups(), DofObjectTest< DerivedClass >::testSetNVariableGroupsExtraInts(), libMesh::DofObject::var_to_vg(), libMesh::DofObject::var_to_vg_and_offset(), and libMesh::DofObject::vg_dof_base().

◆ n_vars() [1/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 960 of file dof_object.h.

961{
962 libmesh_assert_less (s, this->n_systems());
963
964 const unsigned int nvg = this->n_var_groups(s);
965
966 unsigned int val=0;
967
968 for (unsigned int vg=0; vg<nvg; vg++)
969 val += this->n_vars(s,vg);
970
971 return val;
972}

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

◆ n_vars() [2/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 943 of file dof_object.h.

945{
946 libmesh_assert_less (s, this->n_systems());
947 libmesh_assert_less (vg, this->n_var_groups(s));
948
949 const unsigned int start_idx_sys = this->start_idx(s);
950
951 libmesh_assert_less ((start_idx_sys + 2*vg), _idx_buf.size());
952
953 return (cast_int<unsigned int>
954 (_idx_buf[start_idx_sys + 2*vg]) >> ncv_magic_exp);
955}
libMesh::DofObject::ncv_magic_exp
static const index_t ncv_magic_exp
Definition dof_object.h:683

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::DofMap::allgather_recursive_constraints(), libMesh::DofMap::distribute_dofs(), libMesh::DofObject::DofObject(), libMesh::OldSolutionValue< Output, point_output >::eval_at_node(), libMesh::OldSolutionCoefs< Output, point_output >::eval_at_node(), libMesh::OldSolutionValue< Output, point_output >::eval_at_node(), libMesh::OldSolutionCoefs< Output, point_output >::eval_at_node(), libMesh::OldSolutionCoefs< Output, point_output >::eval_mixed_derivatives(), libMesh::OldSolutionValue< Output, point_output >::eval_mixed_derivatives(), libMesh::BuildProjectionList::operator()(), libMesh::DofObject::operator=(), libMesh::DofMap::set_nonlocal_dof_objects(), DofObjectTest< DerivedClass >::testAddSystemExtraInts(), DofObjectTest< DerivedClass >::testSetNVariableGroups(), and DofObjectTest< DerivedClass >::testSetNVariableGroupsExtraInts().

◆ n_vertices()

virtual unsigned int libMesh::Quad::n_vertices ( ) const
inlinefinaloverridevirtualinherited
Returns
4. All quadrilaterals have 4 vertices.

Implements libMesh::Elem.

Definition at line 102 of file face_quad.h.

102{ return 4; }

Referenced by libMesh::Quad::edges_adjacent_to_node(), libMesh::Quad8::second_order_adjacent_vertex(), second_order_adjacent_vertex(), libMesh::Quad8::second_order_child_vertex(), and second_order_child_vertex().

◆ neighbor_ptr() [1/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 2625 of file elem.h.

2626{
2627 libmesh_assert_less (i, this->n_neighbors());
2628
2629 return _elemlinks[i+1];
2630}

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

◆ neighbor_ptr() [2/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 2615 of file elem.h.

2616{
2617 libmesh_assert_less (i, this->n_neighbors());
2618
2619 return _elemlinks[i+1];
2620}

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(), assemble_temperature_jump(), assembly_with_dg_fem_context(), libMesh::BoundaryInfo::boundary_ids(), MeshBaseTest::BrokenNeighborMesh(), libMesh::EquationSystems::build_discontinuous_solution_vector(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::MeshTetInterface::check_hull_integrity(), libMesh::BoundaryInfo::clear_stitched_boundary_side_ids(), compute_enriched_soln(), compute_jacobian(), libMesh::FEAbstract::compute_node_constraints(), libMesh::FEGenericBase< OutputType >::compute_periodic_constraints(), libMesh::FEAbstract::compute_periodic_node_constraints(), libMesh::FEGenericBase< OutputType >::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_boundary_constraint(), libMesh::VariationalSmootherConstraint::get_neighbors_for_subdomain_constraint(), libMesh::MeshTetInterface::improve_hull_integrity(), 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::MeshTools::Modification::interpolate_surface(), libMesh::Poly2TriTriangulator::is_refine_boundary_allowed(), libMesh::HDGProblem::jacobian(), libMesh::Elem::libmesh_assert_valid_neighbors(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::Elem::make_links_to_me_local(), libMesh::Elem::nullify_neighbors(), libMesh::DefaultCoupling::operator()(), libMesh::CheckpointIO::read_remote_elem(), libMesh::EquationSystems::redundant_added_side(), libMesh::Elem::refine(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::FE< Dim, T >::reinit(), libMesh::FEXYZ< Dim >::reinit(), libMesh::InfFE< Dim, T_radial, T_map >::reinit(), libMesh::HDGProblem::residual(), libMesh::C0Polyhedron::retriangulate(), libMesh::BoundaryInfo::side_boundary_ids(), libMesh::FE< Dim, T >::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(), InfFERadialTest::testSides(), DisjointNeighborTest::testTempJump(), libMesh::Elem::topological_neighbor(), libMesh::Elem::topological_neighbor(), libMesh::MeshRefinement::topological_neighbor(), libMesh::Elem::topologically_equal(), libMesh::Parallel::Packing< Elem * >::unpack(), libMesh::MeshTetInterface::volume_to_surface_mesh(), libMesh::Elem::which_neighbor_am_i(), and libMesh::CheckpointIO::write_remote_elem().

◆ 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 3520 of file elem.h.

3521{
3522 return {_elemlinks+1, _elemlinks + 1 + this->n_neighbors()};
3523}

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

Referenced by libMesh::Elem::child_neighbor(), 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(), and libMesh::Elem::remove_links_to_me().

◆ neighbor_ptr_range() [2/2]

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

Definition at line 3527 of file elem.h.

3528{
3529 return {_elemlinks+1, _elemlinks + 1 + this->n_neighbors()};
3530}

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

◆ 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 2484 of file elem.h.

2485{
2486 libmesh_assert_less (i, this->n_nodes());
2487 libmesh_assert(_nodes[i]);
2488 libmesh_assert_not_equal_to (_nodes[i]->id(), Node::invalid_id);
2489
2490 return _nodes[i]->id();
2491}

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::Hex20::connectivity(), libMesh::Hex27::connectivity(), libMesh::Hex8::connectivity(), libMesh::InfHex16::connectivity(), libMesh::InfHex18::connectivity(), libMesh::InfHex8::connectivity(), libMesh::InfPrism12::connectivity(), libMesh::InfPrism6::connectivity(), libMesh::Prism15::connectivity(), libMesh::Prism18::connectivity(), libMesh::Prism6::connectivity(), libMesh::Pyramid5::connectivity(), libMesh::Tet10::connectivity(), libMesh::Tet14::connectivity(), libMesh::Tet4::connectivity(), libMesh::Edge2::connectivity(), libMesh::Edge3::connectivity(), libMesh::Edge4::connectivity(), libMesh::InfEdge2::connectivity(), libMesh::C0Polyhedron::connectivity(), libMesh::InfQuad4::connectivity(), libMesh::InfQuad6::connectivity(), libMesh::Quad4::connectivity(), libMesh::Quad8::connectivity(), connectivity(), libMesh::Tri3::connectivity(), libMesh::Tri6::connectivity(), libMesh::Tri7::connectivity(), libMesh::MeshTools::find_hanging_nodes_and_parents(), libMesh::VariationalSmootherConstraint::get_neighbors_for_boundary_constraint(), libMesh::VariationalSmootherConstraint::get_neighbors_for_subdomain_constraint(), 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::Elem::key(), libMesh::Tet4::key(), libMesh::Edge2::key(), libMesh::Edge3::key(), libMesh::Edge4::key(), libMesh::Quad::key(), key(), libMesh::Tri::key(), libMesh::Hex::key(), libMesh::Hex27::key(), libMesh::InfHex::key(), libMesh::InfHex18::key(), libMesh::InfPrism::key(), libMesh::Prism::key(), libMesh::Prism18::key(), libMesh::Prism20::key(), libMesh::Prism21::key(), libMesh::Pyramid::key(), libMesh::Pyramid14::key(), libMesh::Pyramid18::key(), libMesh::Tet::key(), libMesh::InfQuad::key(), libMesh::InfQuad6::key(), libMesh::Polygon::key(), libMesh::Quad::key(), libMesh::Quad8::key(), key(), libMesh::Tri::key(), libMesh::Tri6::key(), libMesh::Tri7::key(), libMesh::Edge::key(), libMesh::MeshTools::libmesh_assert_equal_connectivity(), libMesh::Elem::local_node(), libMesh::Tri3Subdivision::local_node_number(), libMesh::Hex::low_order_key(), libMesh::InfHex::low_order_key(), libMesh::InfPrism::low_order_key(), libMesh::Polyhedron::low_order_key(), libMesh::Prism::low_order_key(), libMesh::Pyramid::low_order_key(), libMesh::Tet::low_order_key(), libMesh::InfQuad::low_order_key(), libMesh::Polygon::low_order_key(), libMesh::Quad::low_order_key(), libMesh::Tri::low_order_key(), libMesh::Edge::low_order_key(), libMesh::Elem::operator==(), libMesh::XdrIO::pack_element(), libMesh::CheckpointIO::read_connectivity(), libMesh::C0Polyhedron::retriangulate(), ExodusC0PolyhedronTest::test_write_and_read_hexagonal_prism(), ExodusC0PolygonTest::test_write_and_read_pentagon(), CheckpointIOTest::testC0PolygonCheckpoint(), CheckpointIOTest::testC0PolyhedronCheckpoint(), libMesh::Elem::topologically_equal(), libMesh::Parallel::Packing< Elem * >::unpack(), libMesh::FroIO::write(), libMesh::Elem::write_connectivity(), and libMesh::ExodusII_IO_Helper::write_elements().

◆ node_index_range()

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

Definition at line 2700 of file elem.h.

2701{
2702 return {0, cast_int<unsigned short>(this->n_nodes())};
2703}

References libMesh::Elem::n_nodes().

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::MeshRefinement::add_node(), assemble_stokes(), libMesh::TetGenMeshInterface::assign_nodes_to_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::FE< Dim, T >::cache(), libMesh::Elem::coarsen(), libMesh::FEMap::compute_map(), libMesh::FEGenericBase< OutputType >::compute_periodic_constraints(), libMesh::VariationalSmootherSystem::element_time_derivative(), libMesh::MeshTools::Modification::flatten(), libMesh::Elem::get_info(), libMesh::MeshTools::libmesh_assert_equal_connectivity(), libMesh::Elem::libmesh_assert_valid_node_pointers(), libMesh::XdrIO::pack_element(), libMesh::Elem::quality(), libMesh::Polyhedron::side_ptr(), libMesh::MeshTools::Modification::smooth(), libMesh::Elem::true_centroid(), libMesh::Elem::write_connectivity(), and libMesh::ExodusII_IO_Helper::write_elements().

◆ node_ptr() [1/2]

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

Definition at line 2527 of file elem.h.

2528{
2529 libmesh_assert_less (i, this->n_nodes());
2530 libmesh_assert(_nodes[i]);
2531
2532 return _nodes[i];
2533}

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

◆ node_ptr() [2/2]

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

Definition at line 2516 of file elem.h.

2517{
2518 libmesh_assert_less (i, this->n_nodes());
2519 libmesh_assert(_nodes[i]);
2520
2521 return _nodes[i];
2522}

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::Edge::build_side_ptr(), libMesh::Edge::build_side_ptr(), libMesh::MeshTetInterface::check_hull_integrity(), libMesh::BoundaryInfo::clear_stitched_boundary_side_ids(), libMesh::FEMap::compute_affine_map(), libMesh::FEMap::compute_map(), libMesh::FEGenericBase< OutputType >::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::VariationalSmootherConstraint::get_neighbors_for_boundary_constraint(), libMesh::VariationalSmootherConstraint::get_neighbors_for_subdomain_constraint(), libMesh::Elem::get_node_index(), libMesh::MeshTetInterface::improve_hull_integrity(), libMesh::Poly2TriTriangulator::insert_refinement_points(), 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::Elem::node_ref(), libMesh::Polyhedron::Polyhedron(), libMesh::Tri3Subdivision::prepare_subdivision_properties(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::C0Polyhedron::retriangulate(), libMesh::FE< Dim, T >::shape(), libMesh::Polyhedron::side_clones(), libMesh::Polyhedron::side_ptr(), libMesh::Edge::side_ptr(), libMesh::Polygon::side_ptr(), libMesh::Polygon::side_ptr(), libMesh::Edge::side_ptr(), libMesh::MeshTools::Modification::smooth(), libMesh::UnstructuredMesh::stitching_helper(), libMesh::Elem::swap2nodes(), SystemsTest::testDofCouplingWithVarGroups(), InfFERadialTest::testInfQuants_numericDeriv(), and InfFERadialTest::testSides().

◆ node_ref() [1/2]

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

Definition at line 2546 of file elem.h.

2547{
2548 return *this->node_ptr(i);
2549}

References libMesh::Elem::node_ptr().

◆ node_ref() [2/2]

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

Definition at line 2538 of file elem.h.

2539{
2540 return *this->node_ptr(i);
2541}

References libMesh::Elem::node_ptr().

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::MeshTools::Modification::all_rbb(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEGenericBase< OutputType >::compute_periodic_constraints(), libMesh::DofMap::constrain_p_dofs(), libMesh::Elem::contains_vertex_of(), libMesh::DofMap::dof_indices(), libMesh::TopologyMap::fill(), libMesh::Elem::get_info(), libMesh::VariationalSmootherSystem::get_target_to_reference_jacobian(), libMesh::MeshTools::Modification::interpolate_surface(), libMesh::Pyramid::local_singular_node(), libMesh::MeshCommunication::make_new_node_proc_ids_parallel_consistent(), libMesh::DofMap::old_dof_indices(), libMesh::DofMap::process_mesh_constraint_rows(), 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(), FETestBase< order, family, elem_type, build_nx, CaseName >::setUp(), ParsedFEMFunctionTest::setUp(), libMesh::MeshTools::Modification::smooth(), libMesh::Parallel::sync_node_data_by_element_id_once(), SlitMeshRefinedSystemTest::testRestart(), and libMesh::Poly2TriTriangulator::triangulate_current_points().

◆ node_ref_range() [1/2]

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

Returns a range with all nodes 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 reference to a Node.

Definition at line 2682 of file elem.h.

2683{
2684 return {_nodes, _nodes+this->n_nodes()};
2685}

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

Referenced by libMesh::BoundaryInfo::build_side_list_from_node_list(), libMesh::Polyhedron::convex(), libMesh::MeshTools::Modification::distort(), libMesh::MeshBase::get_info(), libMesh::MeshTetInterface::improve_hull_integrity(), libMesh::MeshTools::Modification::interpolate_surface(), libMesh::Polyhedron::key(), libMesh::Polygon::key(), libMesh::MeshCommunication::make_new_node_proc_ids_parallel_consistent(), MeshPerElemTest< elem_type >::meshes_equal_enough(), libMesh::Elem::point_test(), libMesh::Polyhedron::Polyhedron(), libMesh::ReplicatedMesh::renumber_nodes_and_elements(), libMesh::FE< Dim, T >::shape_deriv(), libMesh::FE< Dim, T >::shape_deriv(), libMesh::FE< Dim, T >::shape_second_deriv(), libMesh::FE< Dim, T >::shape_second_deriv(), libMesh::BoundaryVolumeSolutionTransfer::transfer_boundary_volume(), libMesh::BoundaryVolumeSolutionTransfer::transfer_volume_boundary(), and libMesh::MeshTetInterface::volume_to_surface_mesh().

◆ node_ref_range() [2/2]

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

Definition at line 2691 of file elem.h.

2692{
2693 return {_nodes, _nodes+this->n_nodes()};
2694}

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

◆ nodes_on_edge()

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

Implements libMesh::Elem.

Definition at line 152 of file face_quad9.C.

153{
154 return nodes_on_side(e);
155}
libMesh::Quad9::nodes_on_side
virtual std::vector< unsigned int > nodes_on_side(const unsigned int s) const override
Definition face_quad9.C:145

References nodes_on_side().

◆ nodes_on_side()

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

Implements libMesh::Elem.

Definition at line 145 of file face_quad9.C.

146{
147 libmesh_assert_less(s, n_sides());
148 return {std::begin(side_nodes_map[s]), std::end(side_nodes_map[s])};
149}

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

Referenced by nodes_on_edge().

◆ 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 3047 of file elem.C.

3048{
3049 // Tell any of my neighbors about my death...
3050 // Looks strange, huh?
3051 for (auto n : this->side_index_range())
3052 {
3053 Elem * current_neighbor = this->neighbor_ptr(n);
3054 if (current_neighbor && current_neighbor != remote_elem)
3055 {
3056 // Note: it is possible that I see the neighbor
3057 // (which is coarser than me)
3058 // but they don't see me, so avoid that case.
3059 if (current_neighbor->level() == this->level())
3060 {
3061 const unsigned int w_n_a_i = current_neighbor->which_neighbor_am_i(this);
3062 libmesh_assert_less (w_n_a_i, current_neighbor->n_neighbors());
3063 current_neighbor->set_neighbor(w_n_a_i, nullptr);
3064 this->set_neighbor(n, nullptr);
3065 }
3066 }
3067 }
3068}
libMesh::Elem::set_neighbor
void set_neighbor(const unsigned int i, Elem *n)
Assigns n as the neighbor.
Definition elem.h:2635

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

◆ 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 2926 of file elem.h.

2927{
2928 // By convention, the element is on the boundary
2929 // if it has a nullptr neighbor.
2930 return this->has_neighbor(nullptr);
2931}

References libMesh::Elem::has_neighbor().

◆ on_reference_element()

bool libMesh::Quad::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 565 of file face_quad.C.

567{
568 const Real & xi = p(0);
569 const Real & eta = p(1);
570
571 // The reference quadrilateral element is [-1,1]^2.
572 return ((xi >= -1.-eps) &&
573 (xi <= 1.+eps) &&
574 (eta >= -1.-eps) &&
575 (eta <= 1.+eps));
576}

References libMesh::Real.

◆ operator!=()

bool libMesh::Elem::operator!= ( const Elem &  rhs) const
inlineinherited
Returns
false if two elements are equivalent, true otherwise.

Definition at line 2607 of file elem.h.

2608{
2609 return !(*this == rhs);
2610}

◆ operator=() [1/2]

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

◆ operator=() [2/2]

Quad9 & libMesh::Quad9::operator= ( Quad9 &&  )
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 756 of file elem.C.

757{
758 // If the elements aren't the same type, they aren't equal
759 if (this->type() != rhs.type())
760 return false;
761
762 const unsigned short n_n = this->n_nodes();
763 libmesh_assert_equal_to(n_n, rhs.n_nodes());
764
765 // Make two sorted arrays of global node ids and compare them for
766 // equality.
767 std::array<dof_id_type, Elem::max_n_nodes> this_ids, rhs_ids;
768
769 for (unsigned short n = 0; n != n_n; n++)
770 {
771 this_ids[n] = this->node_id(n);
772 rhs_ids[n] = rhs.node_id(n);
773 }
774
775 // Sort the vectors to rule out different local node numberings.
776 std::sort(this_ids.begin(), this_ids.begin()+n_n);
777 std::sort(rhs_ids.begin(), rhs_ids.begin()+n_n);
778
779 // If the node ids match, the elements are equal!
780 for (unsigned short n = 0; n != n_n; ++n)
781 if (this_ids[n] != rhs_ids[n])
782 return false;
783 return true;
784}

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

◆ opposite_node()

unsigned int libMesh::Quad::opposite_node ( const unsigned int  n,
const unsigned int  s 
) const
finaloverridevirtualinherited
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 from libMesh::Elem.

Definition at line 157 of file face_quad.C.

159{
160 libmesh_assert_less (node_in, 8);
161 libmesh_assert_less (node_in, this->n_nodes());
162 libmesh_assert_less (side_in, this->n_sides());
163 libmesh_assert(this->is_node_on_side(node_in, side_in));
164
165 static const unsigned char side02_nodes_map[] =
166 {3, 2, 1, 0, 6, 255, 4, 255};
167 static const unsigned char side13_nodes_map[] =
168 {1, 0, 3, 2, 255, 7, 255, 5};
169
170 switch (side_in)
171 {
172 case 0:
173 case 2:
174 return side02_nodes_map[node_in];
175 case 1:
176 case 3:
177 return side13_nodes_map[node_in];
178 default:
179 libmesh_error_msg("Unsupported side_in = " << side_in);
180 }
181}
libMesh::Elem::is_node_on_side
virtual bool is_node_on_side(const unsigned int n, const unsigned int s) const =0

References libMesh::Elem::is_node_on_side(), libMesh::libmesh_assert(), libMesh::Quad::n_nodes(), and libMesh::Quad::n_sides().

◆ opposite_side()

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

Reimplemented from libMesh::Elem.

Definition at line 148 of file face_quad.C.

149{
150 libmesh_assert_less (side_in, 4);
151
152 return (side_in + 2) % 4;
153}

◆ 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 3303 of file elem.h.

3304{
3305 if (this->is_flipped())
3306 this->flip(boundary_info);
3307}
libMesh::Elem::is_flipped
virtual bool is_flipped() const =0
libMesh::Elem::flip
virtual void flip(BoundaryInfo *boundary_info)=0
Flips the element (by swapping node and neighbor pointers) to have a mapping Jacobian of opposite sig...

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

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

◆ 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::InfCell, libMesh::InfEdge2, and libMesh::InfQuad.

Definition at line 1923 of file elem.h.

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

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

◆ 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 3125 of file elem.h.

3126{
3127#ifdef LIBMESH_ENABLE_AMR
3128 return _p_level;
3129#else
3130 return 0;
3131#endif
3132}

References libMesh::Elem::_p_level.

Referenced by libMesh::InfQuad6::build_side_ptr(), libMesh::FEGenericBase< OutputType >::coarsened_dof_values(), libMesh::FEGenericBase< OutputType >::compute_periodic_constraints(), libMesh::FEGenericBase< OutputType >::compute_proj_constraints(), libMesh::DofMap::constrain_p_dofs(), libMesh::DofMap::dof_indices(), libMesh::DofMap::dof_indices(), libMesh::FE< Dim, T >::dofs_on_side(), libMesh::FE< Dim, T >::edge_map(), libMesh::FE< Dim, T >::edge_reinit(), libMesh::Elem::Elem(), libMesh::MeshRefinement::enforce_mismatch_limit_prior_to_refinement(), libMesh::FE< Dim, CLOUGH >::FE(), 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::LIBMESH_DEFAULT_VECTORIZED_FE(), libMesh::LIBMESH_DEFAULT_VECTORIZED_FE(), 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(), libMesh::FEInterface::n_dofs_at_node(), libMesh::FEInterface::n_dofs_per_elem(), libMesh::FEInterface::n_shape_functions(), libMesh::DofMap::old_dof_indices(), libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::WeightedPatchRecoveryErrorEstimator::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::FE< Dim, T >::reinit(), libMesh::FE< Dim, T >::reinit(), libMesh::FEXYZ< Dim >::reinit(), libMesh::InfFE< Dim, T_radial, T_map >::reinit(), libMesh::FE< Dim, T >::reinit_dual_shape_coeffs(), libMesh::HPCoarsenTest::select_refinement(), libMesh::Elem::set_p_level(), libMesh::Elem::set_p_refinement_flag(), libMesh::FE< Dim, T >::shape(), libMesh::FE< Dim, T >::shape(), libMesh::InfFE< Dim, T_radial, T_map >::shape(), libMesh::FE< Dim, T >::shape(), libMesh::FE< Dim, T >::shape_deriv(), libMesh::FE< Dim, T >::shape_deriv(), libMesh::FE< Dim, T >::shape_deriv(), libMesh::FE< Dim, T >::shape_deriv(), libMesh::FE< Dim, T >::shape_deriv(), libMesh::FE< Dim, T >::shape_deriv(), libMesh::InfFE< Dim, T_radial, T_map >::shape_deriv(), libMesh::FE< Dim, T >::shape_second_deriv(), libMesh::FE< Dim, T >::shape_second_deriv(), libMesh::FE< Dim, T >::shape_second_deriv(), libMesh::FE< Dim, T >::shape_second_deriv(), libMesh::FE< Dim, T >::shape_second_deriv(), libMesh::FE< Dim, T >::shape_second_deriv(), libMesh::FE< Dim, T >::shape_second_deriv(), libMesh::FEInterface::shapes(), libMesh::FE< Dim, T >::side_map(), libMesh::SparsityPattern::Build::sorted_connected_dofs(), libMesh::MeshRefinement::test_level_one(), libMesh::Elem::true_centroid(), and libMesh::Parallel::Packing< Elem * >::unpack().

◆ p_refinement_flag()

Elem::RefinementState libMesh::Elem::p_refinement_flag ( ) const
inlineinherited
Returns
The value of the p-refinement flag for the element.

Definition at line 3243 of file elem.h.

3244{
3245 return static_cast<RefinementState>(_pflag);
3246}
libMesh::Elem::RefinementState
RefinementState
Enumeration of possible element refinement states.
Definition elem.h:1446

References libMesh::Elem::_pflag.

Referenced by libMesh::BoundaryInfo::add_elements(), libMesh::Elem::get_info(), libMesh::Elem::hack_p_level(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_flags(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::Elem::min_new_p_level_by_neighbor(), libMesh::DofMap::old_dof_indices(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectEdges::operator()(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectSides::operator()(), libMesh::Elem::refine(), and libMesh::Parallel::Packing< Elem * >::unpack().

◆ 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.

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}

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

◆ 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.

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}
libMesh::DofObject::packed_indexing_size
unsigned int packed_indexing_size() const
If we pack our indices into an buffer for communications, how many ints do we need?
Definition dof_object.C:552

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

Referenced by libMesh::Node::packed_size(), libMesh::Parallel::Packing< Elem * >::unpack(), and libMesh::Parallel::Packing< Node * >::unpack().

◆ parent() [1/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 3055 of file elem.h.

3056{
3057 return _elemlinks[0];
3058}

References libMesh::Elem::_elemlinks.

◆ parent() [2/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 3047 of file elem.h.

3048{
3049 return _elemlinks[0];
3050}

References libMesh::Elem::_elemlinks.

Referenced by libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::Elem::add_child(), 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::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::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::OldSolutionValue< Output, point_output >::eval_old_dofs(), libMesh::OldSolutionCoefs< 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_remote(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::BuildProjectionList::operator()(), libMesh::SiblingCoupling::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::topological_neighbor(), libMesh::Elem::topologically_equal(), libMesh::Parallel::Packing< Elem * >::unpack(), and libMesh::Elem::which_neighbor_am_i().

◆ 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::Tet14, libMesh::Tri7, and libMesh::Prism20.

Definition at line 2481 of file elem.C.

2483{
2484 // Indexed first by embedding matrix type, then by child id, then by
2485 // child node, then by bracketing pair
2486 std::vector<std::vector<std::vector<std::vector<std::pair<unsigned char, unsigned char>>>>> &
2487 cached_bracketing_nodes = this->_get_bracketing_node_cache();
2488
2489 const unsigned int em_vers = this->embedding_matrix_version();
2490
2491 // We may be updating the cache on one thread, and while that
2492 // happens we can't safely access the cache from other threads.
2493 Threads::spin_mutex::scoped_lock lock(parent_bracketing_nodes_mutex);
2494
2495 if (cached_bracketing_nodes.size() <= em_vers)
2496 cached_bracketing_nodes.resize(em_vers+1);
2497
2498 const unsigned int nc = this->n_children();
2499
2500 // If we haven't cached the bracketing nodes corresponding to this
2501 // embedding matrix yet, let's do so now.
2502 if (cached_bracketing_nodes[em_vers].size() < nc)
2503 {
2504 // If we're a second-order element but we're not a full-order
2505 // element, then some of our bracketing nodes may not exist
2506 // except on the equivalent full-order element. Let's build an
2507 // equivalent full-order element and make a copy of its cache to
2508 // use.
2509 if (this->default_order() != FIRST &&
2510 second_order_equivalent_type(this->type(), /*full_ordered=*/ true) != this->type())
2511 {
2512 // Check that we really are the non-full-order type
2513 libmesh_assert_equal_to
2514 (second_order_equivalent_type (this->type(), false),
2515 this->type());
2516
2517 // Build the full-order type
2518 ElemType full_type =
2519 second_order_equivalent_type(this->type(), /*full_ordered=*/ true);
2520 std::unique_ptr<Elem> full_elem = Elem::build(full_type);
2521
2522 // This won't work for elements with multiple
2523 // embedding_matrix versions, but every such element is full
2524 // order anyways.
2525 libmesh_assert_equal_to(em_vers, 0);
2526
2527 // Make sure its cache has been built. We temporarily
2528 // release our mutex lock so that the inner call can
2529 // re-acquire it.
2530 lock.release();
2531 full_elem->parent_bracketing_nodes(0,0);
2532
2533 // And then we need to lock again, so that if someone *else*
2534 // grabbed our lock before we did we don't risk accessing
2535 // cached_bracketing_nodes while they're working on it.
2536 // Threading is hard.
2537 lock.acquire(parent_bracketing_nodes_mutex);
2538
2539 // Copy its cache
2540 cached_bracketing_nodes =
2541 full_elem->_get_bracketing_node_cache();
2542
2543 // Now we don't need to build the cache ourselves.
2544 return cached_bracketing_nodes[em_vers][child][child_node];
2545 }
2546
2547 cached_bracketing_nodes[em_vers].resize(nc);
2548
2549 const unsigned int nn = this->n_nodes();
2550
2551 // We have to examine each child
2552 for (unsigned int c = 0; c != nc; ++c)
2553 {
2554 const unsigned int ncn = this->n_nodes_in_child(c);
2555
2556 cached_bracketing_nodes[em_vers][c].resize(ncn);
2557
2558 // We have to examine each node in that child
2559 for (unsigned int n = 0; n != ncn; ++n)
2560 {
2561 // If this child node isn't a vertex or an infinite
2562 // child element's mid-infinite-edge node, then we need
2563 // to find bracketing nodes on the child.
2564 if (!this->is_vertex_on_child(c, n)
2565#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
2566 && !this->is_mid_infinite_edge_node(n)
2567#endif
2568 )
2569 {
2570 // Use the embedding matrix to find the child node
2571 // location in parent master element space
2572 Point bracketed_pt;
2573
2574 for (unsigned int pn = 0; pn != nn; ++pn)
2575 {
2576 const Real em_val =
2577 this->embedding_matrix(c,n,pn);
2578
2579 libmesh_assert_not_equal_to (em_val, 1);
2580 if (em_val != 0.)
2581 bracketed_pt.add_scaled(this->master_point(pn), em_val);
2582 }
2583
2584 // Check each pair of nodes on the child which are
2585 // also both parent nodes
2586 for (unsigned int n1 = 0; n1 != ncn; ++n1)
2587 {
2588 if (n1 == n)
2589 continue;
2590
2591 unsigned int parent_n1 =
2592 this->as_parent_node(c,n1);
2593
2594 if (parent_n1 == libMesh::invalid_uint)
2595 continue;
2596
2597 Point p1 = this->master_point(parent_n1);
2598
2599 for (unsigned int n2 = n1+1; n2 < nn; ++n2)
2600 {
2601 if (n2 == n)
2602 continue;
2603
2604 unsigned int parent_n2 =
2605 this->as_parent_node(c,n2);
2606
2607 if (parent_n2 == libMesh::invalid_uint)
2608 continue;
2609
2610 Point p2 = this->master_point(parent_n2);
2611
2612 Point pmid = (p1 + p2)/2;
2613
2614 if (pmid == bracketed_pt)
2615 {
2616 cached_bracketing_nodes[em_vers][c][n].emplace_back(parent_n1, parent_n2);
2617 break;
2618 }
2619 else
2620 libmesh_assert(!pmid.absolute_fuzzy_equals(bracketed_pt));
2621 }
2622 }
2623 }
2624 // If this child node is a parent node, we need to
2625 // find bracketing nodes on the parent.
2626 else
2627 {
2628 unsigned int parent_node = this->as_parent_node(c,n);
2629
2630 Point bracketed_pt;
2631
2632 // If we're not a parent node, use the embedding
2633 // matrix to find the child node location in parent
2634 // master element space
2635 if (parent_node == libMesh::invalid_uint)
2636 {
2637 for (unsigned int pn = 0; pn != nn; ++pn)
2638 {
2639 const Real em_val =
2640 this->embedding_matrix(c,n,pn);
2641
2642 libmesh_assert_not_equal_to (em_val, 1);
2643 if (em_val != 0.)
2644 bracketed_pt.add_scaled(this->master_point(pn), em_val);
2645 }
2646 }
2647 // If we're a parent node then we need no arithmetic
2648 else
2649 bracketed_pt = this->master_point(parent_node);
2650
2651 for (unsigned int n1 = 0; n1 != nn; ++n1)
2652 {
2653 if (n1 == parent_node)
2654 continue;
2655
2656 Point p1 = this->master_point(n1);
2657
2658 for (unsigned int n2 = n1+1; n2 < nn; ++n2)
2659 {
2660 if (n2 == parent_node)
2661 continue;
2662
2663 Point pmid = (p1 + this->master_point(n2))/2;
2664
2665 if (pmid == bracketed_pt)
2666 {
2667 cached_bracketing_nodes[em_vers][c][n].emplace_back(n1, n2);
2668 break;
2669 }
2670 else
2671 libmesh_assert(!pmid.absolute_fuzzy_equals(bracketed_pt));
2672 }
2673 }
2674 }
2675 }
2676 }
2677 }
2678
2679 return cached_bracketing_nodes[em_vers][child][child_node];
2680}
libMesh::Elem::_get_bracketing_node_cache
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 ca...
Definition elem.h:2218
libMesh::Elem::is_mid_infinite_edge_node
virtual bool is_mid_infinite_edge_node(const unsigned int) const
Definition elem.h:1914
libMesh::Elem::is_vertex_on_child
virtual bool is_vertex_on_child(unsigned int, unsigned int n) const
Definition elem.h:773
libMesh::Elem::as_parent_node
virtual unsigned int as_parent_node(unsigned int c, unsigned int n) const
Definition elem.C:2413
libMesh::Elem::master_point
virtual Point master_point(const unsigned int i) const =0
libMesh::parent_bracketing_nodes_mutex
Threads::spin_mutex parent_bracketing_nodes_mutex
Definition elem.C:98

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

◆ permute()

void libMesh::Quad9::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 457 of file face_quad9.C.

458{
459 libmesh_assert_less (perm_num, 4);
460
461 for (unsigned int i = 0; i != perm_num; ++i)
462 {
463 swap4nodes(0,1,2,3);
464 swap4nodes(4,5,6,7);
465 swap4neighbors(0,1,2,3);
466 }
467}
libMesh::Elem::swap4nodes
void swap4nodes(unsigned int n1, unsigned int n2, unsigned int n3, unsigned int n4)
Swaps four node_ptrs, "rotating" them.
Definition elem.h:2152
libMesh::Elem::swap4neighbors
void swap4neighbors(unsigned int n1, unsigned int n2, unsigned int n3, unsigned int n4)
Swaps four neighbor_ptrs, "rotating" them.
Definition elem.h:2162

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

◆ point() [1/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 2474 of file elem.h.

2475{
2476 libmesh_assert_less (i, this->n_nodes());
2477
2478 return *_nodes[i];
2479}

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

◆ point() [2/2]

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

Definition at line 2462 of file elem.h.

2463{
2464 libmesh_assert_less (i, this->n_nodes());
2465 libmesh_assert(_nodes[i]);
2466 libmesh_assert_not_equal_to (_nodes[i]->id(), Node::invalid_id);
2467
2468 return *_nodes[i];
2469}

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::FEMContext::_do_elem_position_set(), libMesh::MeshTools::Subdivision::add_boundary_ghosts(), libMesh::BoundaryInfo::add_elements(), libMesh::MeshRefinement::add_node(), libMesh::C0Polyhedron::add_tet(), libMesh::MeshTools::Modification::all_rbb(), libMesh::MeshTools::Modification::all_tri(), assemble_stokes(), libMesh::FE< Dim, T >::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::Tet4::contains_point(), libMesh::Tri3::contains_point(), libMesh::NodeElem::contains_point(), libMesh::InfHex::contains_point(), libMesh::InfPrism::contains_point(), libMesh::InfQuad4::contains_point(), libMesh::Elem::contains_vertex_of(), libMesh::Polyhedron::convex(), libMesh::ElemCutter::cut_2D(), libMesh::ElemCutter::cut_3D(), libMesh::FEMContext::elem_position_get(), libMesh::Hex20::has_affine_map(), libMesh::Hex27::has_affine_map(), libMesh::Hex8::has_affine_map(), libMesh::Prism15::has_affine_map(), libMesh::Prism18::has_affine_map(), libMesh::Prism20::has_affine_map(), libMesh::Prism21::has_affine_map(), libMesh::Prism6::has_affine_map(), libMesh::Tet10::has_affine_map(), libMesh::Tet14::has_affine_map(), libMesh::Edge3::has_affine_map(), libMesh::Edge4::has_affine_map(), libMesh::Quad4::has_affine_map(), libMesh::Quad8::has_affine_map(), has_affine_map(), libMesh::Tri6::has_affine_map(), libMesh::Tri7::has_affine_map(), libMesh::Edge3::has_invertible_map(), libMesh::Edge4::has_invertible_map(), libMesh::Quad4::has_invertible_map(), libMesh::Elem::hmax(), libMesh::Elem::hmin(), libMesh::MeshTetInterface::improve_hull_integrity(), libMesh::Poly2TriTriangulator::insert_refinement_points(), libMesh::Hex::is_flipped(), libMesh::InfHex::is_flipped(), libMesh::InfPrism::is_flipped(), libMesh::Polyhedron::is_flipped(), libMesh::Prism::is_flipped(), libMesh::Pyramid::is_flipped(), libMesh::Tet::is_flipped(), libMesh::Edge::is_flipped(), libMesh::InfQuad::is_flipped(), libMesh::Polygon::is_flipped(), libMesh::Quad::is_flipped(), libMesh::Tri::is_flipped(), libMesh::Elem::length(), libMesh::Elem::loose_bounding_box(), libMesh::Edge3::loose_bounding_box(), libMesh::Edge4::loose_bounding_box(), libMesh::Quad8::loose_bounding_box(), loose_bounding_box(), libMesh::Tri6::loose_bounding_box(), libMesh::Tri7::loose_bounding_box(), main(), libMesh::FEMap::map(), libMesh::InfFEMap::map(), libMesh::FEMap::map_deriv(), libMesh::Polyhedron::master_point(), libMesh::FE< Dim, T >::matches_cache(), libMesh::Tet4::min_and_max_angle(), libMesh::Tri3::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::Elem::quality(), libMesh::Hex::quality(), libMesh::Quad::quality(), libMesh::Tri::quality(), libMesh::Edge::quasicircumcenter(), libMesh::Face::quasicircumcenter(), libMesh::NodeElem::quasicircumcenter(), libMesh::FE< Dim, T >::shape_deriv(), libMesh::FE< Dim, T >::shape_second_deriv(), libMesh::Poly2TriTriangulator::should_refine_elem(), libMesh::SimplexRefiner::should_refine_elem(), libMesh::Hex8::side_vertex_average_normal(), libMesh::Prism6::side_vertex_average_normal(), libMesh::Pyramid5::side_vertex_average_normal(), libMesh::Tet4::side_vertex_average_normal(), libMesh::Edge2::side_vertex_average_normal(), libMesh::Quad4::side_vertex_average_normal(), libMesh::Tri3::side_vertex_average_normal(), libMesh::MeshTools::Modification::smooth(), ExtraIntegersTest::test_final_integers(), CheckpointIOTest::testC0PolygonCheckpoint(), BoundaryInfoTest::testShellFaceConstraints(), VolumeTest::testTwistedVolume(), libMesh::Elem::true_centroid(), libMesh::C0Polyhedron::true_centroid(), libMesh::Hex8::true_centroid(), libMesh::Prism6::true_centroid(), libMesh::Pyramid5::true_centroid(), libMesh::Edge2::true_centroid(), libMesh::Quad4::true_centroid(), libMesh::C0Polyhedron::volume(), libMesh::Hex20::volume(), libMesh::Hex27::volume(), libMesh::Hex8::volume(), libMesh::Prism15::volume(), libMesh::Prism18::volume(), libMesh::Pyramid13::volume(), libMesh::Pyramid14::volume(), libMesh::Pyramid5::volume(), libMesh::Tet10::volume(), libMesh::Tet4::volume(), libMesh::Edge2::volume(), libMesh::Edge3::volume(), libMesh::Edge4::volume(), libMesh::Quad4::volume(), libMesh::Quad8::volume(), volume(), libMesh::Tri3::volume(), libMesh::Tri6::volume(), and libMesh::Elem::which_side_am_i().

◆ point_test()

bool libMesh::Elem::point_test ( const Point &  p,
Real  box_tol,
Real  map_tol 
) const
privateinherited

Shared private implementation used by the contains_point() and close_to_point() routines.

The box_tol tolerance is used in the bounding box optimization, the map_tol tolerance is used in the calls to inverse_map() and on_reference_element().

Definition at line 2821 of file elem.C.

2822{
2823 libmesh_assert_greater (box_tol, 0.);
2824 libmesh_assert_greater (map_tol, 0.);
2825
2826 // This is a great optimization on first order elements, but it
2827 // could return false negatives on higher orders
2828 if (this->default_order() == FIRST)
2829 {
2830 // Check to make sure the element *could* contain this point, so we
2831 // can avoid an expensive inverse_map call if it doesn't.
2832 bool
2833#if LIBMESH_DIM > 2
2834 point_above_min_z = false,
2835 point_below_max_z = false,
2836#endif
2837#if LIBMESH_DIM > 1
2838 point_above_min_y = false,
2839 point_below_max_y = false,
2840#endif
2841 point_above_min_x = false,
2842 point_below_max_x = false;
2843
2844 // For relative bounding box checks in physical space
2845 const Real my_hmax = this->hmax();
2846
2847 for (auto & n : this->node_ref_range())
2848 {
2849 point_above_min_x = point_above_min_x || (n(0) - my_hmax*box_tol <= p(0));
2850 point_below_max_x = point_below_max_x || (n(0) + my_hmax*box_tol >= p(0));
2851#if LIBMESH_DIM > 1
2852 point_above_min_y = point_above_min_y || (n(1) - my_hmax*box_tol <= p(1));
2853 point_below_max_y = point_below_max_y || (n(1) + my_hmax*box_tol >= p(1));
2854#endif
2855#if LIBMESH_DIM > 2
2856 point_above_min_z = point_above_min_z || (n(2) - my_hmax*box_tol <= p(2));
2857 point_below_max_z = point_below_max_z || (n(2) + my_hmax*box_tol >= p(2));
2858#endif
2859 }
2860
2861 if (
2862#if LIBMESH_DIM > 2
2863 !point_above_min_z ||
2864 !point_below_max_z ||
2865#endif
2866#if LIBMESH_DIM > 1
2867 !point_above_min_y ||
2868 !point_below_max_y ||
2869#endif
2870 !point_above_min_x ||
2871 !point_below_max_x)
2872 return false;
2873 }
2874
2875 // To be on the safe side, we converge the inverse_map() iteration
2876 // to a slightly tighter tolerance than that requested by the
2877 // user...
2878 const Point mapped_point = FEMap::inverse_map(this->dim(),
2879 this,
2880 p,
2881 0.1*map_tol, // <- this is |dx| tolerance, the Newton residual should be ~ |dx|^2
2882 /*secure=*/ false,
2883 /*extra_checks=*/ false);
2884
2885 // Check that the refspace point maps back to p! This is only necessary
2886 // for 1D and 2D elements, 3D elements always live in 3D.
2887 //
2888 // TODO: The contains_point() function could most likely be implemented
2889 // more efficiently in the element sub-classes themselves, at least for
2890 // the linear element types.
2891 if (this->dim() < 3)
2892 {
2893 Point xyz = FEMap::map(this->dim(), this, mapped_point);
2894
2895 // Compute the distance between the original point and the re-mapped point.
2896 // They should be in the same place.
2897 Real dist = (xyz - p).norm();
2898
2899
2900 // If dist is larger than some fraction of the tolerance, then return false.
2901 // This can happen when e.g. a 2D element is living in 3D, and
2902 // FEMap::inverse_map() maps p onto the projection of the element,
2903 // effectively "tricking" on_reference_element().
2904 if (dist > this->hmax() * map_tol)
2905 return false;
2906 }
2907
2908 return this->on_reference_element(mapped_point, map_tol);
2909}
libMesh::Elem::on_reference_element
virtual bool on_reference_element(const Point &p, const Real eps=TOLERANCE) const =0
libMesh::Elem::node_ref_range
SimpleRange< NodeRefIter > node_ref_range()
Returns a range with all nodes of an element, usable in range-based for loops.
Definition elem.h:2682
libMesh::FEMap::map
static Point map(const unsigned int dim, const Elem *elem, const Point &reference_point)
Definition fe_map.C:1954
libMesh::FEMap::inverse_map
static Point inverse_map(const unsigned int dim, const Elem *elem, const Point &p, const Real tolerance=TOLERANCE, const bool secure=true, const bool extra_checks=true)
Definition fe_map.C:1512
libMesh::TensorTools::norm
auto norm(const T &a)
Definition tensor_tools.h:74

References libMesh::Elem::default_order(), libMesh::Elem::dim(), libMesh::FIRST, libMesh::Elem::hmax(), libMesh::FEMap::inverse_map(), libMesh::FEMap::map(), libMesh::Elem::node_ref_range(), libMesh::Elem::on_reference_element(), and libMesh::Real.

Referenced by libMesh::Elem::close_to_point(), and libMesh::Elem::contains_point().

◆ 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 3634 of file elem.C.

3635{
3636 libmesh_assert_less (i, this->n_edges());
3637
3638 return this->point(this->local_edge_node(i, 0)) >
3639 this->point(this->local_edge_node(i, 1));
3640}
libMesh::Elem::local_edge_node
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 ...

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

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

◆ 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 3643 of file elem.C.

3644{
3645 libmesh_assert_less (i, this->n_faces());
3646
3647 // Get the number of vertices N of face i. Note that for 3d elements, i.e.
3648 // elements for which this->n_faces() > 0, the number of vertices on any of
3649 // its sides (or faces) is just the number of that face's sides (or edges).
3650 const unsigned int N = Elem::type_to_n_sides_map[this->side_type(i)];
3651
3652 const std::vector<unsigned int> nodes = this->nodes_on_side(i);
3653
3654 auto cmp = [&](const unsigned int & m, const unsigned int & n) -> bool
3655 { return this->point(m) < this->point(n); };
3656
3657 const unsigned int v = std::distance(nodes.begin(),
3658 std::min_element(nodes.begin(), nodes.begin() + N, cmp));
3659
3660 return cmp(nodes[(v - 1 + N) % N], nodes[(v + 1) % N]);
3661}
libMesh::Elem::nodes_on_side
virtual std::vector< unsigned int > nodes_on_side(const unsigned int) const =0
libMesh::Elem::type_to_n_sides_map
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...
Definition elem.h:678
libMesh::Elem::side_type
virtual ElemType side_type(const unsigned int s) const =0

References libMesh::Elem::n_faces(), libMesh::Elem::nodes_on_side(), libMesh::Elem::point(), libMesh::Elem::side_type(), and libMesh::Elem::type_to_n_sides_map.

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

◆ 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.

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}

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

◆ print_info() [1/3]

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

Prints relevant information about the element.

Definition at line 2948 of file elem.C.

2949{
2950 os << this->get_info()
2951 << std::endl;
2952}
libMesh::Elem::get_info
std::string get_info() const
Prints relevant information about the element to a string.
Definition elem.C:2956

References libMesh::Elem::get_info().

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

◆ 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.

82{
83 if (_enable_print_counter)
84 out_stream << ReferenceCounter::get_info();
85}
libMesh::ReferenceCounter::get_info
static std::string get_info()
Gets a string containing the reference information.
Definition reference_counter.C:47

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

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

◆ print_info() [3/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.

82{
83 if (_enable_print_counter)
84 out_stream << ReferenceCounter::get_info();
85}

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

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

◆ processor_id() [1/3]

processor_id_type & libMesh::DofObject::processor_id ( )
inlineinherited
Returns
The processor that this DofObject belongs to as a writable reference.

Definition at line 889 of file dof_object.h.

890{
891 return _processor_id;
892}
libMesh::DofObject::_processor_id
processor_id_type _processor_id
The processor_id of the DofObject.
Definition dof_object.h:585

References libMesh::DofObject::_processor_id.

◆ processor_id() [2/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 881 of file dof_object.h.

882{
883 return _processor_id;
884}

References libMesh::DofObject::_processor_id.

Referenced by NonManifoldTestPartitioner::_do_partition(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::DistributedMesh::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::MeshRefinement::add_node(), libMesh::DistributedMesh::add_node(), libMesh::DistributedMesh::add_point(), libMesh::ReplicatedMesh::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::Elem::get_info(), libMesh::Node::get_info(), libMesh::Elem::inherit_data_from(), libMesh::RBEIMConstruction::initialize_qp_data(), libMesh::DistributedMesh::insert_elem(), libMesh::MeshTools::Modification::interpolate_surface(), 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(), MeshPerElemTest< elem_type >::meshes_equal_enough(), libMesh::PeriodicBoundaries::neighbor(), libMesh::RBEIMEvaluation::node_distribute_bfs(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SortAndCopy::operator()(), libMesh::CompareDofObjectsByPIDAndThenID::operator()(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectInteriors::operator()(), AugmentSparsityOnInterface::operator()(), libMesh::GhostPointNeighbors::operator()(), OverlappingCouplingFunctor::operator()(), AugmentSparsityOnNodes::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::DistributedMesh::own_node(), libMesh::XdrIO::pack_element(), libMesh::CentroidPartitioner::partition_range(), libMesh::LinearPartitioner::partition_range(), libMesh::SFCPartitioner::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::CheckpointIO::read_nodes(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::DistributedMesh::renumber_nodes_and_elements(), libMesh::DofMap::scatter_constraints(), libMesh::PetscPreconditioner< T >::set_hypre_ads_data(), libMesh::PetscPreconditioner< T >::set_hypre_ams_data(), 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(), MeshFunctionTest::test_bad_gradient_var_with_out_of_mesh_value(), MeshFunctionTest::test_bad_hessian_var_with_out_of_mesh_value(), DefaultCouplingTest::testCoupling(), PointNeighborCouplingTest::testCoupling(), DofObjectTest< DerivedClass >::testInvalidateProcId(), EquationSystemsTest::testPostInitAddElem(), DofObjectTest< DerivedClass >::testSetProcId(), BoundaryInfoTest::testShellFaceConstraints(), DofObjectTest< DerivedClass >::testValidProcId(), libMesh::Parallel::Packing< Elem * >::unpack(), libMesh::Parallel::Packing< Node * >::unpack(), libMesh::DTKAdapter::update_variable_values(), NonManifoldGhostingFunctorTest::verify_send_list_entries_helper(), libMesh::GmshIO::write_mesh(), and libMesh::Nemesis_IO_Helper::write_sidesets().

◆ 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 897 of file dof_object.h.

898{
899 this->processor_id() = pid;
900}

References libMesh::DofObject::processor_id().

◆ qual_bounds()

std::pair< Real, Real > libMesh::Quad::qual_bounds ( const ElemQuality  q) const
overridevirtualinherited
Returns
The suggested quality bounds for the hex based on quality measure q. These are the values suggested by the CUBIT User's Manual.

Reimplemented from libMesh::Elem.

Definition at line 488 of file face_quad.C.

489{
490 std::pair<Real, Real> bounds;
491
492 switch (q)
493 {
494 case EDGE_LENGTH_RATIO:
495 case ASPECT_RATIO:
496 bounds.first = 1.;
497 bounds.second = 4.;
498 break;
499
500 case TAPER:
501 bounds.first = 0.;
502 bounds.second = 0.7;
503 break;
504
505 case WARP:
506 bounds.first = 0.9;
507 bounds.second = 1.;
508 break;
509
510 case STRETCH:
511 bounds.first = 0.25;
512 bounds.second = 1.;
513 break;
514
515 case MIN_ANGLE:
516 bounds.first = 45.;
517 bounds.second = 90.;
518 break;
519
520 case MAX_ANGLE:
521 bounds.first = 90.;
522 bounds.second = 135.;
523 break;
524
525 case CONDITION:
526 bounds.first = 1.;
527 bounds.second = 4.;
528 break;
529
530 case JACOBIAN:
531 case SCALED_JACOBIAN:
532 bounds.first = 0.5;
533 bounds.second = 1.;
534 break;
535
536 case SHEAR:
537 case SHAPE:
538 case SKEW:
539 case SIZE:
540 bounds.first = 0.3;
541 bounds.second = 1.;
542 break;
543
544 case DISTORTION:
545 bounds.first = 0.6;
546 bounds.second = 1.;
547 break;
548
549 case TWIST:
550 bounds.first = 0.;
551 bounds.second = 1.;
552 break;
553
554 default:
555 libMesh::out << "Warning: Invalid quality measure chosen." << std::endl;
556 bounds.first = -1;
557 bounds.second = -1;
558 }
559
560 return bounds;
561}

References libMesh::ASPECT_RATIO, libMesh::CONDITION, libMesh::DISTORTION, libMesh::EDGE_LENGTH_RATIO, libMesh::JACOBIAN, libMesh::MAX_ANGLE, libMesh::MIN_ANGLE, libMesh::out, libMesh::SCALED_JACOBIAN, libMesh::SHAPE, libMesh::SHEAR, libMesh::SIZE, libMesh::SKEW, libMesh::STRETCH, libMesh::TAPER, libMesh::TWIST, and libMesh::WARP.

◆ quality()

Real libMesh::Quad::quality ( const ElemQuality  q) const
overridevirtualinherited
Returns
A quantitative assessment of element quality based on the quality metric q specified by the user.

Reimplemented from libMesh::Elem.

Definition at line 216 of file face_quad.C.

217{
218 switch (q)
219 {
220 // The EDGE_LENGTH_RATIO metric is handled by the base class.
221 //
222 // The CUBIT 15.1 User Documentation refers to the
223 // EDGE_LENGTH_RATIO as the "Aspect Ratio" metric for Quads,
224 // however, we prefer the slightly more robust aspect ratio
225 // formula employed by Ansys, and have therefore designated that
226 // as our ASPECT_RATIO metric here.
227 //
228 // As a counter-example for employing the EDGE_LENGTH_RATIO in
229 // Quads, consider a "rhombus". All four side lengths are equal,
230 // so the EDGE_LENGTH_RATIO of this element is always (the
231 // optimal value) 1.0, regardless of the internal angle "theta"
232 // of the rhombus. A more sensitive shape quality metric should
233 // take this internal angle into account, so that very thin
234 // rhombus-shaped Quads are not considered optimal.
235
236 case ASPECT_RATIO:
237 {
238 // Aspect Ratio definition from Ansys Theory Manual.
239 // Reference: Ansys, Inc. Theory Reference, Ansys Release 9.0, 2004 (Chapter: 13.7.3)
240 //
241 // For the rhombus case described above, the aspect ratio of
242 // the element using the Ansys Aspect Ratio metric is
243 // 1/sin(theta), where theta is the acute interior angle of
244 // the rhombus. The aspect ratio therefore has a minimum value
245 // of 1.0 (when theta = pi/2), and blows up to infinity as
246 // sin(theta) -> 0, rather than remaining equal to 1.0 as in
247 // the CUBIT formula.
248
249 // Compute midpoint positions along each edge
250 Point m0 = Real(0.5) * (this->point(0) + this->point(1));
251 Point m1 = Real(0.5) * (this->point(1) + this->point(2));
252 Point m2 = Real(0.5) * (this->point(2) + this->point(3));
253 Point m3 = Real(0.5) * (this->point(3) + this->point(0));
254
255 // Compute vectors adjoining opposite side midpoints
256 Point v0 = m2 - m0;
257 Point v1 = m1 - m3;
258
259 // Compute the length of the midlines
260 Real v0_norm = v0.norm();
261 Real v1_norm = v1.norm();
262
263 // Instead of dividing by zero in the next step, just return
264 // 0. The optimal aspect ratio is 1.0, and "high" aspect
265 // ratios are bad, but an aspect ratio of 0 should also be
266 // considered bad.
267 if (v0_norm == 0. || v1_norm == 0.)
268 return 0.;
269
270 // Compute sine of the angle between v0, v1. For rectangular
271 // elements, sin_theta == 1.
272 Real sin_theta = cross_norm(v0, v1) / v0_norm / v1_norm;
273 Real v0s = v0_norm*sin_theta;
274 Real v1s = v1_norm*sin_theta;
275
276 // Determine the min, max of each midline length and its
277 // projection.
278 //
279 // Note: The return values min{0,1} and max{0,1} here are
280 // *references* and we cannot pass a temporary to
281 // std::minmax() since the reference returned becomes a
282 // dangling reference at "the end of the full expression that
283 // contains the call to std::minmax()"
284 // https://en.cppreference.com/w/cpp/algorithm/minmax
285 auto [min0, max0] = std::minmax(v0_norm, v1s);
286 auto [min1, max1] = std::minmax(v0s, v1_norm);
287
288 // Return the max of the two quotients
289 return std::max(max0/min0, max1/min1);
290 }
291
292 // Compute the min/max diagonal ratio.
293 // This is modeled after the Hex element
294 case DISTORTION:
295 case DIAGONAL:
296 {
297 // Diagonal between node 0 and node 2
298 const Real d02 = this->length(0,2);
299
300 // Diagonal between node 1 and node 3
301 const Real d13 = this->length(1,3);
302
303 // Find the biggest and smallest diagonals
304 if ((d02 > 0.) && (d13 >0.))
305 if (d02 < d13) return d02 / d13;
306 else return d13 / d02;
307 else
308 return 0.;
309 break;
310 }
311
312 // CUBIT 15.1 User Documentation:
313 // Stretch: Sqrt(2) * minimum edge length / maximum diagonal length
314 case STRETCH:
315 {
316 Real lengths[4] = {this->length(0,1), this->length(1,2), this->length(2,3), this->length(3,0)};
317 Real min_edge = *std::min_element(lengths, lengths+4);
318 Real d_max = std::max(this->length(0,2), this->length(1,3));
319
320 // Return 0. instead of dividing by zero.
321 if (d_max == 0.)
322 return 0.;
323 else
324 return std::sqrt(2) * min_edge / d_max;
325 }
326
327 case SHAPE:
328 case SKEW:
329 {
330 // From: P. Knupp, "Algebraic mesh quality metrics for
331 // unstructured initial meshes," Finite Elements in Analysis
332 // and Design 39, 2003, p. 217-241, Sections 5.2 and 5.3.
333 typedef std::array<Real, 4> Array4;
334 typedef std::array<Real, 6> Array6;
335
336 // x, y, z node coordinates.
337 std::vector<Real>
338 x = {this->point(0)(0), this->point(1)(0), this->point(2)(0), this->point(3)(0)},
339 y = {this->point(0)(1), this->point(1)(1), this->point(2)(1), this->point(3)(1)},
340 z = {this->point(0)(2), this->point(1)(2), this->point(2)(2), this->point(3)(2)};
341
342 // Nodal Jacobians. These are 3x2 matrices, hence we represent
343 // them by Array6.
344 std::array<Array6, 4> A;
345 for (unsigned int k=0; k<4; ++k)
346 {
347 unsigned int
348 kp1 = k+1 > 3 ? k+1-4 : k+1,
349 kp3 = k+3 > 3 ? k+3-4 : k+3;
350
351 // To initialize std::array we need double curly braces in
352 // C++11 but not C++14 apparently.
353 A[k] = {{x[kp1] - x[k], x[kp3] - x[k],
354 y[kp1] - y[k], y[kp3] - y[k],
355 z[kp1] - z[k], z[kp3] - z[k]}};
356 }
357
358 // Compute metric tensors, T_k = A_k^T * A_k. These are 2x2
359 // square matrices, hence we represent them by Array4.
360 std::array<Array4, 4> T;
361 for (unsigned int k=0; k<4; ++k)
362 {
363 Real
364 top_left = A[k][0]*A[k][0] + A[k][2]*A[k][2] + A[k][4]*A[k][4],
365 off_diag = A[k][0]*A[k][1] + A[k][2]*A[k][3] + A[k][4]*A[k][5],
366 bot_rigt = A[k][1]*A[k][1] + A[k][3]*A[k][3] + A[k][5]*A[k][5];
367
368 T[k] = {{top_left, off_diag,
369 off_diag, bot_rigt}};
370 }
371
372
373 // Nodal areas. These are approximated as sqrt(det(A^T * A))
374 // to handle the general case of a 2D element living in 3D.
375 Array4 alpha;
376 for (unsigned int k=0; k<4; ++k)
377 alpha[k] = std::sqrt(T[k][0]*T[k][3] - T[k][1]*T[k][2]);
378
379 // All nodal areas must be strictly positive. Return 0 (the
380 // lowest quality) otherwise. We know they can't be negative
381 // because they are the result of a sqrt, but they might be
382 // identically 0.
383 if (*std::min_element(alpha.begin(), alpha.end()) == 0.)
384 return 0.;
385
386 // Compute and return the shape metric. These only use the
387 // diagonal entries of the T_k.
388 Real den = 0.;
389 if (q == SHAPE)
390 {
391 for (unsigned int k=0; k<4; ++k)
392 den += (T[k][0] + T[k][3]) / alpha[k];
393 return (den == 0.) ? 0 : (8. / den);
394 }
395 else
396 {
397 for (unsigned int k=0; k<4; ++k)
398 den += std::sqrt(T[k][0] * T[k][3]) / alpha[k];
399 return (den == 0.) ? 0 : (4. / den);
400 }
401 }
402
403 // This test returns 0 if a Quad:
404 // 1) Is "twisted" (i.e. has an invalid numbering)
405 // 2) Has nearly parallel adjacent edges
406 // 3) Has a nearly zero length edge
407 // Otherwise, it returns 1.
408 case TWIST:
409 {
410 // Compute the cross product induced by each "corner" of the QUAD
411 // and check that:
412 // 1) None of the cross products are zero (within a tolernace), and
413 // 2) all of the cross products point in the same direction.
414
415 // Corner 0
416 Point vec_01 = point(1) - point(0);
417 Point vec_03 = point(3) - point(0);
418 Point corner_0_vec = vec_01.cross(vec_03);
419
420 // Corner 1
421 Point vec_12 = point(2) - point(1);
422 Point vec_10 = point(0) - point(1);
423 Point corner_1_vec = vec_12.cross(vec_10);
424
425 // Corner 2
426 Point vec_23 = point(3) - point(2);
427 Point vec_21 = point(1) - point(2);
428 Point corner_2_vec = vec_23.cross(vec_21);
429
430 // Corner 3
431 Point vec_30 = point(0) - point(3);
432 Point vec_32 = point(2) - point(3);
433 Point corner_3_vec = vec_30.cross(vec_32);
434
435 // If any of these cross products is nearly zero, then either
436 // we have nearly parallel adjacent edges or a nearly zero
437 // length edge. We return 0 in this case.
438 if ((corner_0_vec.norm() < TOLERANCE*TOLERANCE) ||
439 (corner_1_vec.norm() < TOLERANCE*TOLERANCE) ||
440 (corner_2_vec.norm() < TOLERANCE*TOLERANCE) ||
441 (corner_3_vec.norm() < TOLERANCE*TOLERANCE))
442 {
443 return 0.;
444 }
445
446 // Now check whether the element is twisted.
447 Real dot_01 = corner_0_vec * corner_1_vec;
448 Real dot_02 = corner_0_vec * corner_2_vec;
449 Real dot_03 = corner_0_vec * corner_3_vec;
450
451 if ((dot_01 <= 0.) || (dot_02 <= 0.) || (dot_03 <= 0.))
452 return 0.;
453
454 // If we made it here, then Elem is not twisted.
455 return 1.;
456 }
457
458 case WARP:
459 {
460 // We compute the angle between the two planes formed by
461 // drawing an imaginary diagonal separating opposite vertices
462 // A and B, where (A,B) = (0,2) and (1,3). The element warpage
463 // is then taken to be the smaller of these two angles. For a
464 // flat quadrilateral, the planes are parallel, thus the angle
465 // between them is zero, and the element warpage is therefore
466 // 1.
467 //
468 // Reference: https://cubit.sandia.gov/files/cubit/16.08/help_manual/WebHelp/mesh_generation/mesh_quality_assessment/quadrilateral_metrics.htm
469 Point
470 n0 = (this->point(1) - this->point(0)).cross(this->point(3) - this->point(0)).unit(),
471 n1 = (this->point(2) - this->point(1)).cross(this->point(0) - this->point(1)).unit(),
472 n2 = (this->point(3) - this->point(2)).cross(this->point(1) - this->point(2)).unit(),
473 n3 = (this->point(0) - this->point(3)).cross(this->point(2) - this->point(3)).unit();
474
475 return std::min(n0*n2, n1*n3);
476 }
477
478 default:
479 return Elem::quality(q);
480 }
481}
libMesh::Elem::quality
virtual Real quality(const ElemQuality q) const
Definition elem.C:1783
libMesh::Elem::length
Real length(const unsigned int n1, const unsigned int n2) const
Definition elem.C:727
libMesh::cross_norm
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:1132

References libMesh::ASPECT_RATIO, libMesh::TypeVector< T >::cross(), libMesh::cross_norm(), libMesh::DIAGONAL, libMesh::DISTORTION, libMesh::Elem::length(), libMesh::TypeVector< T >::norm(), libMesh::Elem::point(), libMesh::Elem::quality(), libMesh::Real, libMesh::SHAPE, libMesh::SKEW, libMesh::STRETCH, libMesh::TOLERANCE, libMesh::TWIST, and libMesh::WARP.

◆ quasicircumcenter()

Point libMesh::Face::quasicircumcenter ( ) const
overridevirtualinherited
Returns
The "circumcenter of mass" (area-weighted average of triangulation circumcenters) of the element.

Currently ignores curvature of element edges.

Reimplemented from libMesh::Elem.

Definition at line 33 of file face.C.

34{
35 const Point p0 = this->point(0);
36
37 // We have to use vertex-polygon area rather than real area if we
38 // want this to be consistent for faces with curved edges
39 Real total_area = 0;
40 Point weighted_cc_sum;
41
42 for (auto v : make_range(2u, this->n_vertices()))
43 {
44 const Point p1 = this->point(v-1);
45 const Point p2 = this->point(v);
46
47 const Point a = p1-p0;
48 const Point b = p2-p0;
49 const Point axb = a.cross(b);
50 const Real norm2_axb = axb.norm_sq();
51 const Real area = sqrt(norm2_axb)/2;
52
53 const Point cc_minus_p0 = ((a.norm_sq() * b - b.norm_sq() * a).cross(axb)) / 2 / norm2_axb;
54
55 weighted_cc_sum += area*cc_minus_p0;
56 total_area += area;
57 }
58
59 weighted_cc_sum /= total_area;
60 weighted_cc_sum += p0;
61
62 return weighted_cc_sum;
63}
b
static const Real b
Definition disjoint_neighbor_test.C:24

References b, libMesh::TypeVector< T >::cross(), libMesh::make_range(), libMesh::Elem::n_vertices(), libMesh::TypeVector< T >::norm_sq(), libMesh::Elem::point(), and libMesh::Real.

◆ 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 3171 of file elem.h.

3172{
3173 if (!_children)
3174 return nullptr;
3175
3176 return _children[i];
3177}

References libMesh::Elem::_children.

Referenced by libMesh::BoundaryInfo::add_elements(), and libMesh::CheckpointIO::read_remote_elem().

◆ 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.

569{
570 return &(ReferenceElem::get(this->type()));
571}
libMesh::ReferenceElem::get
const Elem & get(const ElemType type_in)
Definition reference_elem.C:254

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

◆ refine()

void libMesh::Elem::refine ( MeshRefinement &  mesh_refinement)
virtualinherited

Refine the element.

Definition at line 87 of file elem_refinement.C.

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 // Get any new remote neighbor links right; even find_neighbors
144 // relies on those
145 for (unsigned int s : this->side_index_range())
146 {
147 if (this->neighbor_ptr(s) != remote_elem)
148 continue;
149
150 for (unsigned int c = 0; c != nc; c++)
151 {
152 Elem * current_child = this->child_ptr(c);
153 if (current_child != remote_elem &&
154 this->is_child_on_side(c, s))
155 current_child->set_neighbor
156 (s, const_cast<RemoteElem *>(remote_elem));
157 }
158 }
159
160 // Un-set my refinement flag now
161 this->set_refinement_flag(Elem::INACTIVE);
162
163 // Leave the p refinement flag set - we will need that later to get
164 // projection operations correct
165 // this->set_p_refinement_flag(Elem::INACTIVE);
166
167#ifndef NDEBUG
168 for (unsigned int c = 0; c != nc; c++)
169 if (this->child_ptr(c) != remote_elem)
170 {
171 libmesh_assert_equal_to (this->child_ptr(c)->parent(), this);
172 libmesh_assert(this->child_ptr(c)->active());
173 }
174#endif
175 libmesh_assert (this->ancestor());
176}
libMesh::Elem::is_child_on_side
virtual bool is_child_on_side(const unsigned int c, const unsigned int s) const =0

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::is_child_on_side(), libMesh::Elem::JUST_REFINED, libMesh::libmesh_assert(), libMesh::Elem::n_children(), libMesh::DofObject::n_extra_integers(), libMesh::DofObject::n_systems(), libMesh::Elem::neighbor_ptr(), 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_neighbor(), libMesh::Elem::set_p_level(), libMesh::Elem::set_p_refinement_flag(), libMesh::Elem::set_refinement_flag(), libMesh::Elem::side_index_range(), libMesh::Elem::subactive(), and libMesh::Elem::type().

◆ refinement_flag()

Elem::RefinementState libMesh::Elem::refinement_flag ( ) const
inlineinherited
Returns
The value of the refinement flag for the element.

Definition at line 3227 of file elem.h.

3228{
3229 return static_cast<RefinementState>(_rflag);
3230}
libMesh::Elem::_rflag
unsigned char _rflag
h refinement flag.
Definition elem.h:2283

References libMesh::Elem::_rflag.

Referenced by libMesh::Elem::active(), libMesh::BoundaryInfo::add_elements(), libMesh::OldSolutionBase< Output, point_output >::check_old_context(), libMesh::OldSolutionBase< Output, point_output >::check_old_context(), libMesh::Elem::coarsen(), libMesh::Elem::contract(), libMesh::MeshRefinement::enforce_mismatch_limit_prior_to_refinement(), libMesh::OldSolutionValue< Output, point_output >::eval_at_node(), libMesh::OldSolutionCoefs< Output, point_output >::eval_at_node(), libMesh::OldSolutionValue< Output, point_output >::eval_at_node(), libMesh::OldSolutionCoefs< Output, point_output >::eval_at_node(), libMesh::OldSolutionValue< Output, point_output >::eval_old_dofs(), libMesh::OldSolutionCoefs< 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_refinement_compatible(), libMesh::DofMap::old_dof_indices(), 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(), libMesh::MeshRefinement::uniformly_coarsen(), and libMesh::Parallel::Packing< Elem * >::unpack().

◆ relative_edge_face_order()

bool libMesh::Elem::relative_edge_face_order ( const unsigned int  e,
const unsigned int  s 
) const
inherited
Returns
true iff, for an edge e on side s, the node map for side s is such that the first vertex (i.e. zeroth node) of e is lower positioned than the second vertex (i.e. first node) of e.

Definition at line 3664 of file elem.C.

3665{
3666 libmesh_assert_less (e, this->n_edges());
3667 libmesh_assert_less (s, this->n_faces());
3668 libmesh_assert (is_edge_on_side(e, s));
3669
3670 const unsigned int N = Elem::type_to_n_sides_map[this->side_type(s)];
3671
3672 unsigned int v;
3673 for (v = 0; v < N; v++)
3674 if (this->local_side_node(s, v) == this->local_edge_node(e, 0))
3675 break;
3676
3677 libmesh_assert (this->local_side_node(s, (v + 1) % N) ==
3678 this->local_edge_node(e, 1) ||
3679 this->local_side_node(s, (v - 1 + N) % N) ==
3680 this->local_edge_node(e, 1));
3681
3682 return this->local_side_node(s, (v + 1) % N) ==
3683 this->local_edge_node(e, 1);
3684}
libMesh::Elem::local_side_node
virtual unsigned int local_side_node(unsigned int side, unsigned int side_node) const =0
libMesh::Elem::is_edge_on_side
virtual bool is_edge_on_side(const unsigned int e, const unsigned int s) const =0

References libMesh::Elem::is_edge_on_side(), libMesh::libmesh_assert(), libMesh::Elem::local_edge_node(), libMesh::Elem::local_side_node(), libMesh::Elem::n_edges(), libMesh::Elem::n_faces(), libMesh::Elem::side_type(), and libMesh::Elem::type_to_n_sides_map.

◆ 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 1648 of file elem.C.

1649{
1650 libmesh_assert_not_equal_to (this, remote_elem);
1651
1652 // We need to have handled any children first
1653#ifdef LIBMESH_ENABLE_AMR
1654 libmesh_assert (!this->has_children());
1655#endif
1656
1657 // Nullify any neighbor links
1658 for (auto neigh : this->neighbor_ptr_range())
1659 {
1660 if (neigh && neigh != remote_elem)
1661 {
1662 // My neighbor should never be more refined than me; my real
1663 // neighbor would have been its parent in that case.
1664 libmesh_assert_greater_equal (this->level(), neigh->level());
1665
1666 if (this->level() == neigh->level() &&
1667 neigh->has_neighbor(this))
1668 {
1669#ifdef LIBMESH_ENABLE_AMR
1670 // My neighbor may have descendants which also consider me a
1671 // neighbor
1672 std::vector<Elem *> family;
1673 neigh->total_family_tree_by_neighbor (family, this);
1674
1675 for (auto & n : family)
1676 {
1677 libmesh_assert (n);
1678 if (n->is_remote())
1679 continue;
1680 unsigned int my_s = n->which_neighbor_am_i(this);
1681 libmesh_assert_less (my_s, n->n_neighbors());
1682 libmesh_assert_equal_to (n->neighbor_ptr(my_s), this);
1683 n->set_neighbor(my_s, nullptr);
1684 }
1685#else
1686 unsigned int my_s = neigh->which_neighbor_am_i(this);
1687 libmesh_assert_less (my_s, neigh->n_neighbors());
1688 libmesh_assert_equal_to (neigh->neighbor_ptr(my_s), this);
1689 neigh->set_neighbor(my_s, nullptr);
1690#endif
1691 }
1692#ifdef LIBMESH_ENABLE_AMR
1693 // Even if my neighbor doesn't link back to me, it might
1694 // have subactive descendants which do
1695 else if (neigh->has_children())
1696 {
1697 // If my neighbor at the same level doesn't have me as a
1698 // neighbor, I must be subactive
1699 libmesh_assert(this->level() > neigh->level() ||
1700 this->subactive());
1701
1702 // My neighbor must have some ancestor of mine as a
1703 // neighbor
1704 Elem * my_ancestor = this->parent();
1705 libmesh_assert(my_ancestor);
1706 while (!neigh->has_neighbor(my_ancestor))
1707 {
1708 my_ancestor = my_ancestor->parent();
1709 libmesh_assert(my_ancestor);
1710 }
1711
1712 // My neighbor may have descendants which consider me a
1713 // neighbor
1714 std::vector<Elem *> family;
1715 neigh->total_family_tree_by_subneighbor (family, my_ancestor, this);
1716
1717 for (auto & n : family)
1718 {
1719 libmesh_assert (n);
1720 if (n->is_remote())
1721 continue;
1722 unsigned int my_s = n->which_neighbor_am_i(this);
1723 libmesh_assert_less (my_s, n->n_neighbors());
1724 libmesh_assert_equal_to (n->neighbor_ptr(my_s), this);
1725 n->set_neighbor(my_s, nullptr);
1726 }
1727 }
1728#endif
1729 }
1730 }
1731
1732#ifdef LIBMESH_ENABLE_AMR
1733 // We can't currently delete a child with a parent!
1734 libmesh_assert (!this->parent());
1735#endif
1736}

References libMesh::Elem::has_children(), libMesh::Elem::level(), libMesh::libmesh_assert(), libMesh::Elem::neighbor_ptr_range(), libMesh::Elem::parent(), and libMesh::remote_elem.

Referenced by MeshDeletionsTest::testDeleteElem().

◆ 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 2099 of file elem.C.

2100{
2101 libmesh_assert(this->has_children());
2102
2103 libmesh_assert(this->child_ptr(c));
2104
2105 this->set_child(c, elem);
2106}

References libMesh::Elem::child_ptr(), libMesh::Elem::has_children(), libMesh::libmesh_assert(), and libMesh::Elem::set_child().

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

◆ 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.

254{ return false; }

Referenced by libMesh::FE< Dim, T >::edge_map(), libMesh::FE< Dim, T >::edge_reinit(), libMesh::Elem::Elem(), libMesh::QBase::init(), libMesh::FE< Dim, T >::reinit(), libMesh::FE< Dim, T >::reinit(), libMesh::FE< Dim, T >::side_map(), and libMesh::Parallel::Packing< Elem * >::unpack().

◆ second_order_adjacent_vertex()

unsigned short int libMesh::Quad9::second_order_adjacent_vertex ( const unsigned int  n,
const unsigned int  v 
) const
overridevirtual
Returns
The element-local number of the \( v^{th} \) vertex that defines the \( n^{th} \) second-order node.
Note
n is counted as depicted above, \( 4 \le n < 8 \).

Reimplemented from libMesh::Elem.

Definition at line 416 of file face_quad9.C.

418{
419 libmesh_assert_greater_equal (n, this->n_vertices());
420 libmesh_assert_less (n, this->n_nodes());
421
422 switch (n)
423 {
424 case 8:
425 {
426 libmesh_assert_less (v, 4);
427 return static_cast<unsigned short int>(v);
428 }
429
430 default:
431 {
432 libmesh_assert_less (v, 2);
433 // use the matrix that we inherited from \p Quad
434 return _second_order_adjacent_vertices[n-this->n_vertices()][v];
435 }
436 }
437}
libMesh::Quad::_second_order_adjacent_vertices
static const unsigned short int _second_order_adjacent_vertices[4][2]
Matrix that tells which vertices define the location of mid-side (or second-order) nodes.
Definition face_quad.h:224

References libMesh::Quad::_second_order_adjacent_vertices, n_nodes(), and libMesh::Quad::n_vertices().

◆ second_order_child_vertex()

std::pair< unsigned short int, unsigned short int > libMesh::Quad9::second_order_child_vertex ( const unsigned int  n) const
overridevirtual
Returns
The child number c and element-local index v of the \( n^{th} \) second-order node on the parent element. See elem.h for further details.

Reimplemented from libMesh::Elem.

Definition at line 442 of file face_quad9.C.

443{
444 libmesh_assert_greater_equal (n, this->n_vertices());
445 libmesh_assert_less (n, this->n_nodes());
446 /*
447 * the _second_order_vertex_child_* vectors are
448 * stored in face_quad.C, since they are identical
449 * for Quad8 and Quad9 (for the first 4 higher-order nodes)
450 */
451 return std::pair<unsigned short int, unsigned short int>
452 (_second_order_vertex_child_number[n],
453 _second_order_vertex_child_index[n]);
454}
libMesh::Quad::_second_order_vertex_child_number
static const unsigned short int _second_order_vertex_child_number[9]
Vector that names a child sharing each second order node.
Definition face_quad.h:229
libMesh::Quad::_second_order_vertex_child_index
static const unsigned short int _second_order_vertex_child_index[9]
Vector that names the child vertex index for each second order node.
Definition face_quad.h:234

References libMesh::Quad::_second_order_vertex_child_index, libMesh::Quad::_second_order_vertex_child_number, n_nodes(), and libMesh::Quad::n_vertices().

◆ 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 3168 of file elem.C.

3170{
3171 switch (et)
3172 {
3173 case NODEELEM:
3174 return NODEELEM;
3175 case EDGE2:
3176 case EDGE3:
3177 {
3178 // full_ordered not relevant
3179 return EDGE3;
3180 }
3181
3182 case EDGE4:
3183 {
3184 // full_ordered not relevant
3185 return EDGE4;
3186 }
3187
3188 case TRI3:
3189 case TRI6:
3190 {
3191 // full_ordered not relevant
3192 return TRI6;
3193 }
3194
3195 case TRI7:
3196 return TRI7;
3197
3198 // Currently there is no TRISHELL6, so similarly to other types
3199 // where this is the case, we just return the input.
3200 case TRISHELL3:
3201 return TRISHELL3;
3202
3203 case QUAD4:
3204 case QUAD8:
3205 {
3206 if (full_ordered)
3207 return QUAD9;
3208 else
3209 return QUAD8;
3210 }
3211
3212 case QUADSHELL4:
3213 case QUADSHELL8:
3214 {
3215 if (full_ordered)
3216 return QUADSHELL9;
3217 else
3218 return QUADSHELL8;
3219 }
3220
3221 case QUAD9:
3222 {
3223 // full_ordered not relevant
3224 return QUAD9;
3225 }
3226
3227 case QUADSHELL9:
3228 {
3229 // full_ordered not relevant
3230 return QUADSHELL9;
3231 }
3232
3233 case TET4:
3234 case TET10:
3235 {
3236 // full_ordered not relevant
3237 return TET10;
3238 }
3239
3240 case TET14:
3241 return TET14;
3242
3243 case HEX8:
3244 case HEX20:
3245 {
3246 // see below how this correlates with INFHEX8
3247 if (full_ordered)
3248 return HEX27;
3249 else
3250 return HEX20;
3251 }
3252
3253 case HEX27:
3254 {
3255 // full_ordered not relevant
3256 return HEX27;
3257 }
3258
3259 case PRISM6:
3260 case PRISM15:
3261 {
3262 if (full_ordered)
3263 return PRISM18;
3264 else
3265 return PRISM15;
3266 }
3267
3268 // full_ordered not relevant, already fully second order
3269 case PRISM18:
3270 return PRISM18;
3271 case PRISM20:
3272 return PRISM20;
3273 case PRISM21:
3274 return PRISM21;
3275 case PYRAMID18:
3276 return PYRAMID18;
3277
3278 case PYRAMID5:
3279 case PYRAMID13:
3280 {
3281 if (full_ordered)
3282 return PYRAMID14;
3283 else
3284 return PYRAMID13;
3285 }
3286
3287 case PYRAMID14:
3288 {
3289 // full_ordered not relevant
3290 return PYRAMID14;
3291 }
3292
3293
3294
3295#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
3296
3297 // infinite elements
3298 case INFEDGE2:
3299 {
3300 return INFEDGE2;
3301 }
3302
3303 case INFQUAD4:
3304 case INFQUAD6:
3305 {
3306 // full_ordered not relevant
3307 return INFQUAD6;
3308 }
3309
3310 case INFHEX8:
3311 case INFHEX16:
3312 {
3313 /*
3314 * Note that this matches with \p Hex8:
3315 * For full-ordered, \p InfHex18 and \p Hex27
3316 * belong together, and for not full-ordered,
3317 * \p InfHex16 and \p Hex20 belong together.
3318 */
3319 if (full_ordered)
3320 return INFHEX18;
3321 else
3322 return INFHEX16;
3323 }
3324
3325 case INFHEX18:
3326 {
3327 // full_ordered not relevant
3328 return INFHEX18;
3329 }
3330
3331 case INFPRISM6:
3332 case INFPRISM12:
3333 {
3334 // full_ordered not relevant
3335 return INFPRISM12;
3336 }
3337
3338#endif
3339
3340
3341 default:
3342 {
3343 // what did we miss?
3344 libmesh_error_msg("No second order equivalent element type for et = "
3345 << Utility::enum_to_string(et));
3346 }
3347 }
3348}

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

◆ set_buffer()

void libMesh::DofObject::set_buffer ( const std::vector< dof_id_type > &  buf)
inlineinherited

Definition at line 708 of file dof_object.h.

709 { _idx_buf = buf; }

References libMesh::DofObject::_idx_buf.

Referenced by DofObjectTest< DerivedClass >::testJensEftangBug().

◆ set_child()

void libMesh::Elem::set_child ( unsigned int  c,
Elem *  elem 
)
inlineprivateinherited

Sets the 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 3199 of file elem.h.

3200{
3201 libmesh_assert (this->has_children());
3202
3203 _children[c] = elem;
3204}

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

Referenced by libMesh::Elem::add_child(), libMesh::Elem::add_child(), libMesh::Elem::make_links_to_me_remote(), and libMesh::Elem::replace_child().

◆ 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.

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}
libMesh::DofObject::system_var_to_vg_var
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:1335

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(), n_vars, libMesh::DofObject::start_idx(), libMesh::DofObject::system_var_to_vg_var(), and libMesh::DofObject::var_to_vg().

◆ 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 1102 of file dof_object.h.

1104{
1105#ifndef NDEBUG
1106 const unsigned int n_more_integers = (sizeof(T)-1)/sizeof(dof_id_type);
1107#endif
1108 libmesh_assert_less(index+n_more_integers, this->n_extra_integers());
1109 libmesh_assert_less(this->n_pseudo_systems(), _idx_buf.size());
1110
1111 const unsigned int start_idx_i = this->start_idx_ints();
1112
1113 libmesh_assert_less(start_idx_i+index+n_more_integers, _idx_buf.size());
1114 std::memcpy(&_idx_buf[start_idx_i+index], &value, sizeof(T));
1115}
value
static const bool value
Definition xdr_io.C:55

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::MeshTools::Modification::all_rbb(), libMesh::ExodusII_IO::read(), libMesh::DynaIO::read_mesh(), RationalMapTest< elem_type >::setUp(), FETestBase< order, family, elem_type, build_nx, CaseName >::setUp(), and DofObjectTest< DerivedClass >::testAddExtraData().

◆ 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 1062 of file dof_object.h.

1064{
1065 libmesh_assert_less(index, this->n_extra_integers());
1066 libmesh_assert_less(this->n_pseudo_systems(), _idx_buf.size());
1067
1068 const unsigned int start_idx_i = this->start_idx_ints();
1069
1070 libmesh_assert_less(start_idx_i+index, _idx_buf.size());
1071 _idx_buf[start_idx_i+index] = value;
1072}

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< DerivedClass >::testAddExtraData(), DofObjectTest< DerivedClass >::testAddSystemExtraInts(), DofObjectTest< DerivedClass >::testSetNSystemsExtraInts(), and DofObjectTest< DerivedClass >::testSetNVariableGroupsExtraInts().

◆ set_id() [1/2]

dof_id_type & libMesh::DofObject::set_id ( )
inlineinherited
Returns
The id for this DofObject as a writable reference.

Definition at line 827 of file dof_object.h.

828{
829 return _id;
830}

References libMesh::DofObject::_id.

Referenced by libMesh::DistributedMesh::add_elem(), libMesh::ReplicatedMesh::add_elem(), libMesh::DistributedMesh::add_node(), libMesh::ReplicatedMesh::add_node(), libMesh::UnstructuredMesh::all_first_order(), ExodusC0PolyhedronTest::build_c0polyhedron(), libMesh::MeshTools::Generation::build_cube(), VolumeTest::buildC0Polyhedron(), libMesh::DistributedMesh::fix_broken_node_and_element_numbering(), libMesh::DofObject::invalidate_id(), libMesh::Node::Node(), libMesh::Node::Node(), libMesh::DistributedMesh::own_node(), libMesh::RemoteElem::RemoteElem(), libMesh::DistributedMesh::renumber_elem(), libMesh::ReplicatedMesh::renumber_elem(), libMesh::DistributedMesh::renumber_node(), libMesh::ReplicatedMesh::renumber_node(), libMesh::ReplicatedMesh::renumber_nodes_and_elements(), libMesh::DofObject::set_id(), AllTriTest::test_helper_c0polyhedron(), AllTriTest::testAllTriC0PolygonOctagon(), CheckpointIOTest::testC0PolyhedronCheckpoint(), DofObjectTest< DerivedClass >::testInvalidateId(), DofObjectTest< DerivedClass >::testSetId(), DofObjectTest< DerivedClass >::testValidId(), libMesh::Parallel::Packing< Elem * >::unpack(), and libMesh::MeshTetInterface::volume_to_surface_mesh().

◆ set_id() [2/2]

void libMesh::DofObject::set_id ( const dof_id_type  dofid)
inlineinherited

Sets the id for this DofObject.

Definition at line 192 of file dof_object.h.

193 { this->set_id() = dofid; }

References libMesh::DofObject::set_id().

◆ 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 1222 of file elem.C.

1223{
1224 // interior parents make no sense for full-dimensional elements.
1225 libmesh_assert (!p ||
1226 this->dim() < LIBMESH_DIM);
1227
1228 // If we have an interior_parent, we USED TO assume it was a
1229 // one-higher-dimensional interior element, but we now allow e.g.
1230 // edge elements to have a 3D interior_parent with no
1231 // intermediate 2D element.
1232 // libmesh_assert (!p ||
1233 // p->dim() == (this->dim()+1));
1234 libmesh_assert (!p ||
1235 (p == remote_elem) ||
1236 (p->dim() > this->dim()));
1237
1238 _elemlinks[1+this->n_sides()] = p;
1239}

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::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(), libMesh::Parallel::Packing< Elem * >::unpack(), and libMesh::MeshTetInterface::volume_to_surface_mesh().

◆ 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 3161 of file elem.h.

3162{
3163 _map_data = data;
3164}

References libMesh::Elem::_map_data.

Referenced by libMesh::DistributedMesh::add_elem(), libMesh::ReplicatedMesh::add_elem(), libMesh::MeshTools::Modification::all_rbb(), libMesh::Elem::inherit_data_from(), libMesh::DistributedMesh::insert_elem(), and libMesh::ReplicatedMesh::insert_elem().

◆ 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 3145 of file elem.h.

3146{
3147 _map_type = cast_int<unsigned char>(type);
3148}

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

Referenced by libMesh::DistributedMesh::add_elem(), libMesh::ReplicatedMesh::add_elem(), libMesh::MeshTools::Modification::all_rbb(), libMesh::Elem::inherit_data_from(), libMesh::DistributedMesh::insert_elem(), and libMesh::ReplicatedMesh::insert_elem().

◆ 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.

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}
libMesh::DofObject::set_n_comp_group
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

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

◆ 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.

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}
libMesh::DofObject::index_t
dof_id_type index_t
DoF index information.
Definition dof_object.h:669

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

Referenced by libMesh::DofObject::set_n_comp(), libMesh::DofObject::set_n_vars_per_group(), libMesh::DofMap::set_nonlocal_dof_objects(), and DofObjectTest< DerivedClass >::testManualDofCalculation().

◆ 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.

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}
libMesh::DofObject::index_buffer_t
std::vector< index_t > index_buffer_t
Definition dof_object.h:670

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

Referenced by libMesh::DofObject::add_system(), libMesh::DofObject::clear_dofs(), libMesh::Elem::refine(), DofObjectTest< DerivedClass >::testManualDofCalculation(), DofObjectTest< DerivedClass >::testSetNSystems(), DofObjectTest< DerivedClass >::testSetNSystemsExtraInts(), DofObjectTest< DerivedClass >::testSetNVariableGroups(), and DofObjectTest< DerivedClass >::testSetNVariableGroupsExtraInts().

◆ 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.

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.
344 DofObject::index_buffer_t(_idx_buf).swap(_idx_buf);
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}
libMesh::DofObject::get_extra_integer
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:1078

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(), n_vars, libMesh::DofObject::ncv_magic, libMesh::DofObject::set_n_comp_group(), and libMesh::DofObject::start_idx().

Referenced by DofObjectTest< DerivedClass >::testManualDofCalculation(), DofObjectTest< DerivedClass >::testSetNVariableGroups(), and DofObjectTest< DerivedClass >::testSetNVariableGroupsExtraInts().

◆ set_neighbor()

void libMesh::Elem::set_neighbor ( const unsigned int  i,
Elem *  n 
)
inlineinherited

Assigns n as the \( i^{th} \) neighbor.

Definition at line 2635 of file elem.h.

2636{
2637 libmesh_assert_less (i, this->n_neighbors());
2638
2639 _elemlinks[i+1] = n;
2640}

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

Referenced by libMesh::MeshTools::Subdivision::add_boundary_ghosts(), libMesh::BoundaryInfo::add_elements(), libMesh::UnstructuredMesh::all_first_order(), MeshBaseTest::BrokenNeighborMesh(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::Poly2TriTriangulator::insert_refinement_points(), libMesh::Elem::nullify_neighbors(), libMesh::CheckpointIO::read_remote_elem(), libMesh::Elem::refine(), libMesh::C0Polyhedron::retriangulate(), libMesh::UnstructuredMesh::stitching_helper(), libMesh::Elem::swap2neighbors(), libMesh::Parallel::Packing< Elem * >::unpack(), and libMesh::MeshTetInterface::volume_to_surface_mesh().

◆ 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 2567 of file elem.h.

2568{
2569 libmesh_assert_less (i, this->n_nodes());
2570
2571 libmesh_deprecated();
2572
2573 return _nodes[i];
2574}

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(), libMesh::MeshTools::Modification::all_tri(), AllSecondOrderTest::allCompleteOrderMixed(), AllSecondOrderTest::allCompleteOrderRange(), AllSecondOrderTest::allSecondOrderMixed(), AllSecondOrderTest::allSecondOrderRange(), libMesh::TetGenMeshInterface::assign_nodes_to_elem(), libMesh::MeshTools::Generation::build_cube(), DisjointNeighborTest::build_four_disjoint_elems(), GetBoundaryPointsTest::build_mesh(), MeshfunctionDFEM::build_mesh(), MixedDimensionMeshTest::build_mesh(), MixedDimensionNonUniformRefinement::build_mesh(), MixedDimensionNonUniformRefinementTriangle::build_mesh(), MixedDimensionNonUniformRefinement3D::build_mesh(), SlitMeshTest::build_mesh(), OverlappingTestBase::build_quad_mesh(), DisjointNeighborTest::build_split_mesh_with_interface(), DisjointNeighborTest::build_two_disjoint_elems(), libMesh::TriangleWrapper::copy_tri_to_mesh(), libMesh::UnstructuredMesh::create_submesh(), libMesh::TetGenIO::element_in(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::AbaqusIO::read_elements(), libMesh::DynaIO::read_mesh(), libMesh::GmshIO::read_mesh(), libMesh::MatlabIO::read_stream(), libMesh::C0Polyhedron::retriangulate(), libMesh::RemoteElem::set_node(), PerElemTest< elem_type >::setUp(), libMesh::FE< Dim, T >::shape(), libMesh::Polyhedron::side_clones(), libMesh::UnstructuredMesh::stitching_helper(), libMesh::MeshTools::Generation::surface_octahedron(), libMesh::Elem::swap2nodes(), DisjointNeighborTest::testDisjointNeighborConflictError(), SystemsTest::testDofCouplingWithVarGroups(), MeshTriangulationTest::testEdge3Mesh(), MeshTriangulationTest::testEdgesMesh(), MeshTriangulationTest::testHalfDomain(), NodalNeighborsTest::testOrientation(), MeshTriangulationTest::testPoly2TriBad1DMultiBoundary(), MeshTriangulationTest::testPoly2TriBad2DMultiBoundary(), MeshTriangulationTest::testPoly2TriBadEdges(), MeshTriangulationTest::testPoly2TriEdge3ToTri6FlipThrows(), EquationSystemsTest::testPostInitAddElem(), SystemsTest::testProjectMatrix3D(), InfFERadialTest::testRefinement(), EquationSystemsTest::testReinitWithNodeElem(), SystemsTest::testSetSystemParameterOverEquationSystem(), BoundaryInfoTest::testShellFaceConstraints(), InfFERadialTest::testSides(), DisjointNeighborTest::testStitchCrossMesh(), MeshTetTest::testTetsToTets(), MeshSubdomainIDTest::testUnpartitioned(), libMesh::Poly2TriTriangulator::triangulate_current_points(), and libMesh::Parallel::Packing< Elem * >::unpack().

◆ 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 2580 of file elem.h.

2582{
2583 libmesh_assert_less (i, this->n_nodes());
2584
2585 _nodes[i] = node;
2586}

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

◆ 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.

128{
129 this->clear_old_dof_object();
130
131 libmesh_assert (!this->old_dof_object);
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}
libMesh::DofObject::construct
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:732
libMesh::DofObject::clear_old_dof_object
void clear_old_dof_object()
Sets the old_dof_object to nullptr.
Definition dof_object.C:120

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

◆ 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.

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.
55 this->parent()->set_p_refinement_flag(Elem::JUST_COARSENED);
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.
75 this->parent()->set_p_refinement_flag(Elem::JUST_REFINED);
76 }
77
78 return;
79 }
80 }
81
82 this->hack_p_level(p);
83}
libMesh::Elem::set_p_refinement_flag
void set_p_refinement_flag(const RefinementState pflag)
Sets the value of the p-refinement flag for the element.
Definition elem.h:3251

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(), VolumeTest::testHex20PLevelTrueCentroid(), and libMesh::Parallel::Packing< Elem * >::unpack().

◆ 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 3251 of file elem.h.

3252{
3253 if (this->p_level() == 0)
3254 libmesh_assert_not_equal_to
3255 (pflag, Elem::JUST_REFINED);
3256
3257 _pflag = cast_int<unsigned char>(pflag);
3258}

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_refinement_compatible(), libMesh::Elem::refine(), libMesh::Elem::set_p_level(), and libMesh::Parallel::Packing< Elem * >::unpack().

◆ 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 3063 of file elem.h.

3064{
3065 // We no longer support using parent() as interior_parent()
3066 libmesh_assert_equal_to(this->dim(), p ? p->dim() : this->dim());
3067 _elemlinks[0] = p;
3068}

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

Referenced by libMesh::BoundaryInfo::add_elements(), and libMesh::UnstructuredMesh::all_first_order().

◆ set_refinement_flag()

void libMesh::Elem::set_refinement_flag ( const RefinementState  rflag)
inlineinherited

Sets the value of the refinement flag for the element.

Definition at line 3235 of file elem.h.

3236{
3237 _rflag = cast_int<unsigned char>(rflag);
3238}

References libMesh::Elem::_rflag.

Referenced by libMesh::BoundaryInfo::add_elements(), libMesh::UnstructuredMesh::all_first_order(), libMesh::Elem::coarsen(), libMesh::Elem::contract(), libMesh::MeshRefinement::enforce_mismatch_limit_prior_to_refinement(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), main(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::Elem::refine(), InfFERadialTest::testRefinement(), EquationSystemsTest::testRefineThenReinitPreserveFlags(), EquationSystemsTest::testSelectivePRefine(), libMesh::MeshRefinement::uniformly_coarsen(), and libMesh::Parallel::Packing< Elem * >::unpack().

◆ set_unique_id()

void libMesh::DofObject::set_unique_id ( unique_id_type  new_id)
inlineinherited

Sets the unique_id for this DofObject.

Definition at line 848 of file dof_object.h.

849{
850#ifdef LIBMESH_ENABLE_UNIQUE_ID
851 _unique_id = new_id;
852#else
853 libmesh_ignore(new_id);
854 libmesh_not_implemented();
855#endif
856}
libMesh::DofObject::_unique_id
unique_id_type _unique_id
A globally unique id, guaranteed not to change as the mesh is repartitioned or adapted.
Definition dof_object.h:568

References libMesh::DofObject::_unique_id, and libMesh::libmesh_ignore().

Referenced by libMesh::DistributedMesh::add_elem(), libMesh::ReplicatedMesh::add_elem(), libMesh::DistributedMesh::add_node(), libMesh::ReplicatedMesh::add_node(), libMesh::ReplicatedMesh::add_point(), libMesh::UnstructuredMesh::all_first_order(), libMesh::UnstructuredMesh::create_submesh(), libMesh::DistributedMesh::insert_elem(), libMesh::ReplicatedMesh::insert_elem(), MeshPerElemTest< elem_type >::meshes_equal_enough(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read_nodes(), libMesh::XdrIO::read_serialized_nodes(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::ExodusII_IO_Helper::set_dof_object_unique_id(), libMesh::Parallel::Packing< Elem * >::unpack(), and libMesh::MeshTetInterface::volume_to_surface_mesh().

◆ 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 1273 of file dof_object.h.

1276{
1277 libmesh_assert_less (s, this->n_systems());
1278 libmesh_assert_less (vg, this->n_var_groups(s));
1279
1280 const unsigned int
1281 start_idx_sys = this->start_idx(s);
1282
1283 libmesh_assert_less ((start_idx_sys + 2*vg + 1), _idx_buf.size());
1284
1285 _idx_buf[start_idx_sys + 2*vg + 1] = db;
1286
1287 libmesh_assert_equal_to (this->vg_dof_base(s,vg), db);
1288}
libMesh::DofObject::vg_dof_base
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:1293

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::set_nonlocal_dof_objects(), and DofObjectTest< DerivedClass >::testManualDofCalculation().

◆ 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 2727 of file elem.h.

2728{
2729 return {0, cast_int<unsigned short>(this->n_sides())};
2730}

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_rbb(), libMesh::MeshTools::Modification::all_tri(), MeshBaseTest::BrokenNeighborMesh(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::MeshTetInterface::check_hull_integrity(), libMesh::FEGenericBase< OutputType >::coarsened_dof_values(), compute_enriched_soln(), libMesh::FEAbstract::compute_node_constraints(), libMesh::FEAbstract::compute_periodic_node_constraints(), libMesh::FEGenericBase< OutputType >::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::VariationalSmootherConstraint::get_neighbors_for_boundary_constraint(), libMesh::VariationalSmootherConstraint::get_neighbors_for_subdomain_constraint(), libMesh::BoundaryInfo::get_side_and_node_maps(), libMesh::Elem::has_topological_neighbor(), libMesh::MeshTetInterface::improve_hull_integrity(), 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::MeshTools::Modification::interpolate_surface(), libMesh::Elem::libmesh_assert_valid_neighbors(), libMesh::VariationalSmootherConstraint::nodes_share_boundary_id(), libMesh::Elem::nullify_neighbors(), libMesh::PostscriptIO::plot_quadratic_elem(), libMesh::Elem::refine(), libMesh::MeshTools::Modification::smooth(), libMesh::UnstructuredMesh::stitching_helper(), ExodusC0PolyhedronTest::test_write_and_read_hexagonal_prism(), libMesh::Parallel::Packing< Elem * >::unpack(), libMesh::MeshTetInterface::volume_to_surface_mesh(), and libMesh::ExodusII_IO_Helper::write_elements().

◆ side_ptr() [1/4]

std::unique_ptr< Elem > libMesh::Quad::side_ptr ( const unsigned int  i)
finaloverridevirtualinherited
Returns
A primitive (2-noded) edge for edge i.

Implements libMesh::Elem.

Definition at line 112 of file face_quad.C.

113{
114 libmesh_assert_less (i, this->n_sides());
115
116 std::unique_ptr<Elem> edge = std::make_unique<Edge2>();
117
118 for (auto n : edge->node_index_range())
119 edge->set_node(n, this->node_ptr(Quad4::side_nodes_map[i][n]));
120
121 return edge;
122}
libMesh::Elem::set_node
virtual Node *& set_node(const unsigned int i)
Definition elem.h:2567

References libMesh::Quad::n_sides(), and libMesh::Quad4::side_nodes_map.

◆ side_ptr() [2/4]

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

Definition at line 2748 of file elem.h.

2750{
2751 // Hand off to the non-const version of this function
2752 Elem * me = const_cast<Elem *>(this);
2753 std::unique_ptr<Elem> e {const_cast<Elem *>(elem.release())};
2754 me->side_ptr(e, i);
2755 elem = std::move(e);
2756}

References libMesh::Elem::side_ptr().

◆ side_ptr() [3/4]

void libMesh::Quad::side_ptr ( std::unique_ptr< Elem > &  elem,
const unsigned int  i 
)
finaloverridevirtualinherited

Rebuilds an EDGE2 coincident with face i.

Implements libMesh::Elem.

Definition at line 126 of file face_quad.C.

128{
129 this->simple_side_ptr<Quad,Quad4>(side, i, EDGE2);
130}

References libMesh::EDGE2.

◆ side_ptr() [4/4]

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

Definition at line 2736 of file elem.h.

2737{
2738 // Call the non-const version of this function, return the result as
2739 // a std::unique_ptr<const Elem>.
2740 Elem * me = const_cast<Elem *>(this);
2741 return me->side_ptr(i);
2742}

References libMesh::Elem::side_ptr().

◆ side_type()

ElemType libMesh::Quad9::side_type ( const unsigned int  s) const
finaloverridevirtual
Returns
The type of element for side s.

Implements libMesh::Elem.

Definition at line 490 of file face_quad9.C.

491{
492 libmesh_assert_less (s, 4);
493 return EDGE3;
494}

References libMesh::EDGE3.

◆ side_vertex_average_normal()

Point libMesh::Elem::side_vertex_average_normal ( const unsigned int  s) const
virtualinherited
Returns
the normal (outwards-facing) of the side of the element at the vertex-average of the side
Parameters
sthe side of interest

Reimplemented in libMesh::C0Polyhedron, libMesh::Hex8, libMesh::Prism6, libMesh::Pyramid5, libMesh::Tet4, libMesh::Edge2, libMesh::C0Polygon, libMesh::Quad4, and libMesh::Tri3.

Definition at line 3519 of file elem.C.

3520{
3521 unsigned int dim = this->dim();
3522 const std::unique_ptr<const Elem> face = this->build_side_ptr(s);
3523 std::unique_ptr<libMesh::FEBase> fe(
3524 libMesh::FEBase::build(dim, libMesh::FEType(this->default_order())));
3525 fe->add_p_level_in_reinit(false); // Yes, really use the default order
3526 const std::vector<Point> & normals = fe->get_normals();
3527 std::vector<Point> ref_side_vertex_average_v = {face->reference_elem()->vertex_average()};
3528 fe->reinit(this, s, TOLERANCE, &ref_side_vertex_average_v);
3529 return normals[0];
3530}
libMesh::FEGenericBase::build
static std::unique_ptr< FEGenericBase > build(const unsigned int dim, const FEType &type)
Builds a specific finite element type.
libMesh::FEType
class FEType hides (possibly multiple) FEFamily and approximation orders, thereby enabling specialize...
Definition fe_type.h:197

References libMesh::FEGenericBase< OutputType >::build(), libMesh::Elem::build_side_ptr(), libMesh::Elem::default_order(), libMesh::Elem::dim(), and libMesh::TOLERANCE.

Referenced by SideVertexAverageNormalTest::testEdge2(), and SideVertexAverageNormalTest::testEdge3().

◆ sides_on_edge()

virtual std::vector< unsigned int > libMesh::Face::sides_on_edge ( const unsigned int  e) const
inlinefinaloverridevirtualinherited

sides_on_edge is trivial in 2D.

Implements libMesh::Elem.

Definition at line 96 of file face.h.

97 { return {e}; }

◆ 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 2883 of file elem.h.

2884{
2885 libmesh_assert_less (i, this->n_edges());
2886
2887 std::unique_ptr<Elem> edge = std::make_unique<Edgeclass>();
2888
2889 for (auto n : edge->node_index_range())
2890 edge->set_node(n, this->node_ptr(Subclass::edge_nodes_map[i][n]));
2891
2892 edge->set_interior_parent(this);
2893 edge->inherit_data_from(*this);
2894
2895 return edge;
2896}

References libMesh::Elem::n_edges().

◆ 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 2904 of file elem.h.

2907{
2908 libmesh_assert_less (i, this->n_edges());
2909
2910 if (!edge.get() || edge->type() != edgetype)
2911 {
2912 Subclass & real_me = cast_ref<Subclass&>(*this);
2913 edge = real_me.Subclass::build_edge_ptr(i);
2914 }
2915 else
2916 {
2917 edge->inherit_data_from(*this);
2918 for (auto n : edge->node_index_range())
2919 edge->set_node(n, this->node_ptr(Subclass::edge_nodes_map[i][n]));
2920 }
2921}

References libMesh::Elem::n_edges().

◆ 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 2789 of file elem.h.

2790{
2791 libmesh_assert_less (i, this->n_sides());
2792
2793 std::unique_ptr<Elem> face = std::make_unique<Sideclass>();
2794 for (auto n : face->node_index_range())
2795 face->set_node(n, this->node_ptr(Subclass::side_nodes_map[i][n]));
2796
2797 face->set_interior_parent(this);
2798 face->inherit_data_from(*this);
2799
2800 return face;
2801}

References libMesh::Elem::n_sides().

◆ 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 2808 of file elem.h.

2811{
2812 libmesh_assert_less (i, this->n_sides());
2813
2814 if (!side.get() || side->type() != sidetype)
2815 {
2816 Subclass & real_me = cast_ref<Subclass&>(*this);
2817 side = real_me.Subclass::build_side_ptr(i);
2818 }
2819 else
2820 {
2821 side->set_interior_parent(this);
2822 side->inherit_data_from(*this);
2823 for (auto n : side->node_index_range())
2824 side->set_node(n, this->node_ptr(Subclass::side_nodes_map[i][n]));
2825 }
2826}

References libMesh::Elem::n_sides().

◆ 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 2833 of file elem.h.

2836{
2837 libmesh_assert_less (i, this->n_sides());
2838
2839 if (!side.get() || side->type() != sidetype)
2840 {
2841 Subclass & real_me = cast_ref<Subclass&>(*this);
2842 side = real_me.Subclass::side_ptr(i);
2843 }
2844 else
2845 {
2846 side->subdomain_id() = this->subdomain_id();
2847
2848 for (auto n : side->node_index_range())
2849 side->set_node(n, this->node_ptr(Mapclass::side_nodes_map[i][n]));
2850 }
2851}

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

◆ start_idx()

unsigned int libMesh::DofObject::start_idx ( const unsigned int  s) const
inlineprivateinherited

The starting index for system s.

Definition at line 1225 of file dof_object.h.

1226{
1227 libmesh_assert_less (s, this->n_systems());
1228 libmesh_assert_less (s, _idx_buf.size());
1229
1230 return cast_int<unsigned int>(std::abs(dof_id_signed_type(_idx_buf[s])));
1231}

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

Referenced by libMesh::DofObject::dof_number(), libMesh::DofObject::n_comp_group(), libMesh::DofObject::n_var_groups(), libMesh::DofObject::n_vars(), libMesh::DofObject::set_dof_number(), libMesh::DofObject::set_n_comp_group(), libMesh::DofObject::set_n_vars_per_group(), libMesh::DofObject::set_vg_dof_base(), and libMesh::DofObject::vg_dof_base().

◆ start_idx_ints()

unsigned int libMesh::DofObject::start_idx_ints ( ) const
inlineprivateinherited

The starting index for an extra_integers pseudosystem.

Definition at line 1249 of file dof_object.h.

1250{
1251 libmesh_assert (this->has_extra_integers());
1252
1253 unsigned int n_sys = this->n_systems();
1254
1255 libmesh_assert_less(this->n_systems(), _idx_buf.size());
1256 return n_sys ? cast_int<unsigned int>(_idx_buf[this->n_systems()]) :
1257 (n_sys+1);
1258}

References libMesh::DofObject::_idx_buf, libMesh::DofObject::has_extra_integers(), libMesh::libmesh_assert(), and libMesh::DofObject::n_systems().

Referenced by libMesh::DofObject::get_extra_datum(), libMesh::DofObject::get_extra_integer(), libMesh::DofObject::n_extra_integers(), libMesh::DofObject::set_extra_datum(), libMesh::DofObject::set_extra_integer(), and libMesh::DofObject::set_n_systems().

◆ 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 2976 of file elem.h.

2977{
2978#ifdef LIBMESH_ENABLE_AMR
2979 if (this->active())
2980 return false;
2981 if (!this->has_children())
2982 return true;
2983 for (const Elem * my_ancestor = this->parent();
2984 my_ancestor != nullptr;
2985 my_ancestor = my_ancestor->parent())
2986 if (my_ancestor->active())
2987 return true;
2988#endif
2989
2990 return false;
2991}

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::max_descendant_p_level(), libMesh::Elem::min_new_p_level_by_neighbor(), libMesh::Elem::min_p_level_by_neighbor(), libMesh::Elem::refine(), libMesh::UnstructuredMesh::stitching_helper(), ElemTest< elem_type >::test_n_refinements(), and libMesh::Parallel::Packing< Elem * >::unpack().

◆ subdomain_id() [1/2]

subdomain_id_type & libMesh::Elem::subdomain_id ( )
inlineinherited
Returns
The subdomain that this element belongs to as a writable reference.

Definition at line 2599 of file elem.h.

2600{
2601 return _sbd_id;
2602}
libMesh::Elem::_sbd_id
subdomain_id_type _sbd_id
The subdomain to which this element belongs.
Definition elem.h:2276

References libMesh::Elem::_sbd_id.

◆ subdomain_id() [2/2]

subdomain_id_type libMesh::Elem::subdomain_id ( ) const
inlineinherited
Returns
The subdomain that this element belongs to.

Definition at line 2591 of file elem.h.

2592{
2593 return _sbd_id;
2594}

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::BoundaryInfo::add_elements(), libMesh::MeshTools::Modification::all_tri(), AllSecondOrderTest::allCompleteOrderRange(), AllSecondOrderTest::allSecondOrderRange(), libMesh::AbaqusIO::assign_subdomain_ids(), ExodusC0PolyhedronTest::build_c0polyhedron(), libMesh::EquationSystems::build_discontinuous_solution_vector(), MixedDimensionMeshTest::build_mesh(), MixedDimensionNonUniformRefinement::build_mesh(), MixedDimensionNonUniformRefinementTriangle::build_mesh(), MixedDimensionNonUniformRefinement3D::build_mesh(), ExodusC0PolygonTest::build_pentagon(), OverlappingTestBase::build_quad_mesh(), libMesh::InfQuad6::build_side_ptr(), libMesh::FEGenericBase< OutputType >::compute_proj_constraints(), libMesh::TriangleWrapper::copy_tri_to_mesh(), libMesh::DofMap::dof_indices(), libMesh::DofMap::dof_indices(), libMesh::Elem::Elem(), libMesh::TetGenIO::element_in(), HilbertSystem::element_time_derivative(), 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::MeshTools::Modification::interpolate_surface(), libMesh::DofMap::old_dof_indices(), libMesh::PointLocatorNanoflann::operator()(), libMesh::PointLocatorNanoflann::operator()(), libMesh::XdrIO::pack_element(), libMesh::Polygon::Polygon(), libMesh::Polyhedron::Polyhedron(), libMesh::CheckpointIO::read_connectivity(), libMesh::DynaIO::read_mesh(), libMesh::GmshIO::read_mesh(), libMesh::Polygon::side_ptr(), libMesh::Pyramid::side_ptr(), libMesh::InfHex::side_ptr(), libMesh::InfPrism::side_ptr(), libMesh::Prism::side_ptr(), libMesh::InfQuad::side_ptr(), libMesh::Elem::simple_side_ptr(), SystemsTest::testDofCouplingWithVarGroups(), MeshExtruderTest::testExtruder(), MeshBaseTest::testMeshBaseVerifyHasCachedElemData(), SystemsTest::testSetSystemParameterOverEquationSystem(), SystemsTest::tripleValueTest(), and libMesh::Parallel::Packing< Elem * >::unpack().

◆ 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 1004 of file elem.h.

1004{ return default_order(); }

References libMesh::Elem::default_order().

Referenced by libMesh::MeshBase::copy_constraint_rows().

◆ 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 3595 of file elem.C.

3598{
3599 std::vector<boundary_id_type> ids1, ids2;
3600 boundary_info->edge_boundary_ids(this, e1, ids1);
3601 boundary_info->edge_boundary_ids(this, e2, ids2);
3602 boundary_info->remove_edge(this, e1);
3603 boundary_info->remove_edge(this, e2);
3604 if (!ids1.empty())
3605 boundary_info->add_edge(this, e2, ids1);
3606 if (!ids2.empty())
3607 boundary_info->add_edge(this, e1, ids2);
3608}

References libMesh::BoundaryInfo::add_edge(), libMesh::BoundaryInfo::edge_boundary_ids(), and libMesh::BoundaryInfo::remove_edge().

Referenced by libMesh::Hex20::flip(), libMesh::Hex27::flip(), libMesh::Hex8::flip(), libMesh::InfHex16::flip(), libMesh::InfHex18::flip(), libMesh::InfHex8::flip(), libMesh::InfPrism12::flip(), libMesh::InfPrism6::flip(), libMesh::Prism15::flip(), libMesh::Prism18::flip(), libMesh::Prism20::flip(), libMesh::Prism21::flip(), libMesh::Prism6::flip(), libMesh::Pyramid13::flip(), libMesh::Pyramid14::flip(), libMesh::Pyramid18::flip(), libMesh::Pyramid5::flip(), libMesh::Tet10::flip(), libMesh::Tet14::flip(), libMesh::Tet4::flip(), libMesh::InfQuad4::flip(), libMesh::InfQuad6::flip(), libMesh::Quad4::flip(), libMesh::Quad8::flip(), flip(), libMesh::Tri3::flip(), libMesh::Tri6::flip(), and libMesh::Tri7::flip().

◆ 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 3579 of file elem.C.

3582{
3583 std::vector<boundary_id_type> ids1, ids2;
3584 boundary_info->boundary_ids(this, s1, ids1);
3585 boundary_info->boundary_ids(this, s2, ids2);
3586 boundary_info->remove_side(this, s1);
3587 boundary_info->remove_side(this, s2);
3588 if (!ids1.empty())
3589 boundary_info->add_side(this, s2, ids1);
3590 if (!ids2.empty())
3591 boundary_info->add_side(this, s1, ids2);
3592}

References libMesh::BoundaryInfo::add_side(), libMesh::BoundaryInfo::boundary_ids(), and libMesh::BoundaryInfo::remove_side().

Referenced by libMesh::Hex20::flip(), libMesh::Hex27::flip(), libMesh::Hex8::flip(), libMesh::InfHex16::flip(), libMesh::InfHex18::flip(), libMesh::InfHex8::flip(), libMesh::InfPrism12::flip(), libMesh::InfPrism6::flip(), libMesh::Prism15::flip(), libMesh::Prism18::flip(), libMesh::Prism20::flip(), libMesh::Prism21::flip(), libMesh::Prism6::flip(), libMesh::Pyramid13::flip(), libMesh::Pyramid14::flip(), libMesh::Pyramid18::flip(), libMesh::Pyramid5::flip(), libMesh::Tet10::flip(), libMesh::Tet14::flip(), libMesh::Tet4::flip(), libMesh::Edge2::flip(), libMesh::Edge3::flip(), libMesh::Edge4::flip(), libMesh::InfQuad4::flip(), libMesh::InfQuad6::flip(), libMesh::Quad4::flip(), libMesh::Quad8::flip(), flip(), libMesh::Tri3::flip(), libMesh::Tri6::flip(), and libMesh::Tri7::flip().

◆ swap2neighbors()

void libMesh::Elem::swap2neighbors ( unsigned int  n1,
unsigned int  n2 
)
inlineprotectedinherited

Swaps two neighbor_ptrs.

Definition at line 2111 of file elem.h.

2112 {
2113 Elem * temp = this->neighbor_ptr(n1);
2114 this->set_neighbor(n1, this->neighbor_ptr(n2));
2115 this->set_neighbor(n2, temp);
2116 }

References libMesh::Elem::neighbor_ptr(), and libMesh::Elem::set_neighbor().

Referenced by libMesh::Hex20::flip(), libMesh::Hex27::flip(), libMesh::Hex8::flip(), libMesh::InfHex16::flip(), libMesh::InfHex18::flip(), libMesh::InfHex8::flip(), libMesh::InfPrism12::flip(), libMesh::InfPrism6::flip(), libMesh::Prism15::flip(), libMesh::Prism18::flip(), libMesh::Prism20::flip(), libMesh::Prism21::flip(), libMesh::Prism6::flip(), libMesh::Pyramid13::flip(), libMesh::Pyramid14::flip(), libMesh::Pyramid18::flip(), libMesh::Pyramid5::flip(), libMesh::Tet10::flip(), libMesh::Tet14::flip(), libMesh::Tet4::flip(), libMesh::Edge2::flip(), libMesh::Edge3::flip(), libMesh::Edge4::flip(), libMesh::InfQuad4::flip(), libMesh::InfQuad6::flip(), libMesh::Quad4::flip(), libMesh::Quad8::flip(), flip(), libMesh::Tri3::flip(), libMesh::Tri6::flip(), libMesh::Tri7::flip(), libMesh::Hex20::permute(), libMesh::Hex27::permute(), libMesh::Hex8::permute(), libMesh::Prism15::permute(), libMesh::Prism18::permute(), libMesh::Prism20::permute(), libMesh::Prism21::permute(), libMesh::Prism6::permute(), libMesh::Elem::swap3neighbors(), and libMesh::Elem::swap4neighbors().

◆ swap2nodes()

void libMesh::Elem::swap2nodes ( unsigned int  n1,
unsigned int  n2 
)
inlineprotectedinherited

Swaps two node_ptrs.

Definition at line 2101 of file elem.h.

2102 {
2103 Node * temp = this->node_ptr(n1);
2104 this->set_node(n1, this->node_ptr(n2));
2105 this->set_node(n2, temp);
2106 }

References libMesh::Elem::node_ptr(), and libMesh::Elem::set_node().

Referenced by libMesh::Hex20::flip(), libMesh::Hex27::flip(), libMesh::Hex8::flip(), libMesh::InfHex16::flip(), libMesh::InfHex18::flip(), libMesh::InfHex8::flip(), libMesh::InfPrism12::flip(), libMesh::InfPrism6::flip(), libMesh::Prism15::flip(), libMesh::Prism18::flip(), libMesh::Prism20::flip(), libMesh::Prism21::flip(), libMesh::Prism6::flip(), libMesh::Pyramid13::flip(), libMesh::Pyramid14::flip(), libMesh::Pyramid18::flip(), libMesh::Pyramid5::flip(), libMesh::Tet10::flip(), libMesh::Tet14::flip(), libMesh::Tet4::flip(), libMesh::Edge2::flip(), libMesh::Edge3::flip(), libMesh::Edge4::flip(), libMesh::InfQuad4::flip(), libMesh::InfQuad6::flip(), libMesh::Quad4::flip(), libMesh::Quad8::flip(), flip(), libMesh::Tri3::flip(), libMesh::Tri6::flip(), libMesh::Tri7::flip(), libMesh::Hex20::permute(), libMesh::Hex27::permute(), libMesh::Hex8::permute(), libMesh::Prism15::permute(), libMesh::Prism18::permute(), libMesh::Prism20::permute(), libMesh::Prism21::permute(), libMesh::Prism6::permute(), libMesh::Elem::swap3nodes(), and libMesh::Elem::swap4nodes().

◆ swap3neighbors()

void libMesh::Elem::swap3neighbors ( unsigned int  n1,
unsigned int  n2,
unsigned int  n3 
)
inlineprotectedinherited

Swaps three neighbor_ptrs, "rotating" them.

Definition at line 2142 of file elem.h.

2144 {
2145 swap2neighbors(n1, n2);
2146 swap2neighbors(n2, n3);
2147 }

References libMesh::Elem::swap2neighbors().

Referenced by libMesh::InfPrism12::permute(), libMesh::InfPrism6::permute(), libMesh::Prism15::permute(), libMesh::Prism18::permute(), libMesh::Prism20::permute(), libMesh::Prism21::permute(), libMesh::Prism6::permute(), libMesh::Tet10::permute(), libMesh::Tet14::permute(), libMesh::Tet4::permute(), libMesh::Tri3::permute(), libMesh::Tri6::permute(), libMesh::Tri7::permute(), and libMesh::Elem::swap4neighbors().

◆ swap3nodes()

void libMesh::Elem::swap3nodes ( unsigned int  n1,
unsigned int  n2,
unsigned int  n3 
)
inlineprotectedinherited

Swaps three node_ptrs, "rotating" them.

Definition at line 2133 of file elem.h.

2134 {
2135 swap2nodes(n1, n2);
2136 swap2nodes(n2, n3);
2137 }

References libMesh::Elem::swap2nodes().

Referenced by libMesh::InfPrism12::permute(), libMesh::InfPrism6::permute(), libMesh::Prism15::permute(), libMesh::Prism18::permute(), libMesh::Prism20::permute(), libMesh::Prism21::permute(), libMesh::Prism6::permute(), libMesh::Tet10::permute(), libMesh::Tet14::permute(), libMesh::Tet4::permute(), libMesh::Tri3::permute(), libMesh::Tri6::permute(), libMesh::Tri7::permute(), and libMesh::Elem::swap4nodes().

◆ 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 2162 of file elem.h.

2164 {
2165 swap3neighbors(n1, n2, n3);
2166 swap2neighbors(n3, n4);
2167 }
libMesh::Elem::swap3neighbors
void swap3neighbors(unsigned int n1, unsigned int n2, unsigned int n3)
Swaps three neighbor_ptrs, "rotating" them.
Definition elem.h:2142

References libMesh::Elem::swap2neighbors(), and libMesh::Elem::swap3neighbors().

Referenced by libMesh::Hex20::permute(), libMesh::Hex27::permute(), libMesh::Hex8::permute(), libMesh::InfHex16::permute(), libMesh::InfHex18::permute(), libMesh::InfHex8::permute(), libMesh::Pyramid13::permute(), libMesh::Pyramid14::permute(), libMesh::Pyramid18::permute(), libMesh::Pyramid5::permute(), libMesh::Quad4::permute(), libMesh::Quad8::permute(), and permute().

◆ 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 2152 of file elem.h.

2154 {
2155 swap3nodes(n1, n2, n3);
2156 swap2nodes(n3, n4);
2157 }
libMesh::Elem::swap3nodes
void swap3nodes(unsigned int n1, unsigned int n2, unsigned int n3)
Swaps three node_ptrs, "rotating" them.
Definition elem.h:2133

References libMesh::Elem::swap2nodes(), and libMesh::Elem::swap3nodes().

Referenced by libMesh::Hex20::permute(), libMesh::Hex27::permute(), libMesh::Hex8::permute(), libMesh::InfHex16::permute(), libMesh::InfHex18::permute(), libMesh::InfHex8::permute(), libMesh::Pyramid13::permute(), libMesh::Pyramid14::permute(), libMesh::Pyramid18::permute(), libMesh::Pyramid5::permute(), libMesh::Quad4::permute(), libMesh::Quad8::permute(), and permute().

◆ system_var_to_vg_var()

unsigned int libMesh::DofObject::system_var_to_vg_var ( const unsigned int  s,
const unsigned int  vg,
const unsigned int  var 
) const
inlineprivateinherited

Utility function - for variable var in system s, figure out what variable group it lives in.

Definition at line 1335 of file dof_object.h.

1338{
1339 unsigned int accumulated_sum=0;
1340
1341 for (unsigned int vgc=0; vgc<vg; vgc++)
1342 accumulated_sum += this->n_vars(s,vgc);
1343
1344 libmesh_assert_less_equal (accumulated_sum, var);
1345
1346 return (var - accumulated_sum);
1347}

References n_vars.

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

◆ 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 3073 of file elem.h.

3074{
3075 const Elem * tp = this;
3076
3077 // Keep getting the element's parent
3078 // until that parent is at level-0
3079 while (tp->parent() != nullptr)
3080 tp = tp->parent();
3081
3082 libmesh_assert(tp);
3083 libmesh_assert_equal_to (tp->level(), 0);
3084
3085 return tp;
3086}

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(), ExtraIntegersTest::test_final_integers(), and ElemTest< elem_type >::test_n_refinements().

◆ 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 1287 of file elem.C.

1291{
1292 libmesh_assert_less (i, this->n_neighbors());
1293
1294 const Elem * neighbor_i = this->neighbor_ptr(i);
1295 if (neighbor_i != nullptr)
1296 return neighbor_i;
1297
1298 if (pb)
1299 {
1300 // Since the neighbor is nullptr it must be on a boundary. We need
1301 // see if this is a periodic boundary in which case it will have a
1302 // topological neighbor
1303 std::vector<boundary_id_type> bc_ids;
1304 mesh.get_boundary_info().boundary_ids(this, cast_int<unsigned short>(i), bc_ids);
1305 for (const auto & id : bc_ids)
1306 if (pb->boundary(id))
1307 {
1308 neighbor_i = pb->neighbor(id, point_locator, this, i);
1309
1310 // Since coarse elements do not have more refined
1311 // neighbors we need to make sure that we don't return one
1312 // of these types of neighbors.
1313 if (neighbor_i)
1314 while (level() < neighbor_i->level())
1315 neighbor_i = neighbor_i->parent();
1316 return neighbor_i;
1317 }
1318 }
1319
1320 return nullptr;
1321}

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::DefaultCoupling::operator()(), libMesh::GhostPointNeighbors::operator()(), and libMesh::MeshRefinement::topological_neighbor().

◆ 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 1245 of file elem.C.

1249{
1250 libmesh_assert_less (i, this->n_neighbors());
1251
1252 Elem * neighbor_i = this->neighbor_ptr(i);
1253 if (neighbor_i != nullptr)
1254 return neighbor_i;
1255
1256 if (pb)
1257 {
1258 // Since the neighbor is nullptr it must be on a boundary. We need
1259 // see if this is a periodic boundary in which case it will have a
1260 // topological neighbor
1261 std::vector<boundary_id_type> bc_ids;
1262 mesh.get_boundary_info().boundary_ids(this, cast_int<unsigned short>(i), bc_ids);
1263 for (const auto & id : bc_ids)
1264 if (pb->boundary(id))
1265 {
1266 // Since the point locator inside of periodic boundaries
1267 // returns a const pointer we will retrieve the proper
1268 // pointer directly from the mesh object.
1269 const Elem * const cn = pb->neighbor(id, point_locator, this, i);
1270 neighbor_i = const_cast<Elem *>(cn);
1271
1272 // Since coarse elements do not have more refined
1273 // neighbors we need to make sure that we don't return one
1274 // of these types of neighbors.
1275 if (neighbor_i)
1276 while (level() < neighbor_i->level())
1277 neighbor_i = neighbor_i->parent();
1278 return neighbor_i;
1279 }
1280 }
1281
1282 return nullptr;
1283}

References libMesh::PeriodicBoundaries::boundary(), libMesh::Elem::level(), mesh, libMesh::Elem::n_neighbors(), libMesh::PeriodicBoundaries::neighbor(), libMesh::Elem::neighbor_ptr(), and libMesh::Elem::parent().

◆ 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 788 of file elem.C.

789{
790 // If the elements aren't the same type, they aren't equal
791 if (this->type() != rhs.type())
792 return false;
793
794 libmesh_assert_equal_to(this->n_nodes(), rhs.n_nodes());
795
796 for (auto n : make_range(this->n_nodes()))
797 if (this->node_id(n) != rhs.node_id(n))
798 return false;
799
800 for (auto neigh : make_range(this->n_neighbors()))
801 {
802 if (!this->neighbor_ptr(neigh))
803 {
804 if (rhs.neighbor_ptr(neigh))
805 return false;
806 continue;
807 }
808 if (!rhs.neighbor_ptr(neigh) ||
809 this->neighbor_ptr(neigh)->id() !=
810 rhs.neighbor_ptr(neigh)->id())
811 return false;
812 }
813
814 if (this->parent())
815 {
816 if (!rhs.parent())
817 return false;
818 if (this->parent()->id() != rhs.parent()->id())
819 return false;
820 }
821 else if (rhs.parent())
822 return false;
823
824 if (this->interior_parent())
825 {
826 if (!rhs.interior_parent())
827 return false;
828 if (this->interior_parent()->id() !=
829 rhs.interior_parent()->id())
830 return false;
831 }
832 else if (rhs.interior_parent())
833 return false;
834
835 return true;
836}
libMesh::Elem::interior_parent
const Elem * interior_parent() const
Definition elem.C:1160

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

◆ 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 2126 of file elem.C.

2128{
2129 ElemInternal::total_family_tree(this, family, reset);
2130}
libMesh::ElemInternal::total_family_tree
void total_family_tree(T elem, std::vector< T > &family, bool reset)
Definition elem_internal.h:67

References libMesh::ElemInternal::total_family_tree().

Referenced by libMesh::Partitioner::set_parent_processor_ids().

◆ 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 2134 of file elem.C.

2136{
2137 ElemInternal::total_family_tree(this, family, reset);
2138}

References libMesh::ElemInternal::total_family_tree().

◆ 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 2230 of file elem.C.

2233{
2234 ElemInternal::total_family_tree_by_neighbor(this, family, neighbor, reset);
2235}
libMesh::ElemInternal::total_family_tree_by_neighbor
void total_family_tree_by_neighbor(T elem, std::vector< T > &family, T neighbor_in, bool reset=true)
Definition elem_internal.h:240

References libMesh::ElemInternal::total_family_tree_by_neighbor().

◆ 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 2239 of file elem.C.

2242{
2243 ElemInternal::total_family_tree_by_neighbor(this, family, neighbor, reset);
2244}

References libMesh::ElemInternal::total_family_tree_by_neighbor().

◆ total_family_tree_by_side() [1/2]

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

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

Definition at line 2176 of file elem.C.

2179{
2180 ElemInternal::total_family_tree_by_side(this, family, side, reset);
2181}
libMesh::ElemInternal::total_family_tree_by_side
void total_family_tree_by_side(T elem, std::vector< T > &family, unsigned int s, bool reset)
Definition elem_internal.h:149

References libMesh::ElemInternal::total_family_tree_by_side().

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

◆ total_family_tree_by_side() [2/2]

void libMesh::Elem::total_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 2185 of file elem.C.

2188{
2189 ElemInternal::total_family_tree_by_side(this, family, side, reset);
2190}

References libMesh::ElemInternal::total_family_tree_by_side().

◆ 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 2268 of file elem.C.

2272{
2273 ElemInternal::total_family_tree_by_subneighbor(this, family, neighbor, subneighbor, reset);
2274}
libMesh::ElemInternal::total_family_tree_by_subneighbor
void total_family_tree_by_subneighbor(T elem, std::vector< T > &family, T neighbor_in, T subneighbor, bool reset=true)
Definition elem_internal.h:309

References libMesh::ElemInternal::total_family_tree_by_subneighbor().

◆ 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 2278 of file elem.C.

2282{
2283 ElemInternal::total_family_tree_by_subneighbor(this, family, neighbor, subneighbor, reset);
2284}

References libMesh::ElemInternal::total_family_tree_by_subneighbor().

◆ true_centroid()

Point libMesh::Elem::true_centroid ( ) const
virtualinherited
Returns
The "true" geometric centroid of the element, c=(cx, cy, cz), where:

[cx] [\int x dV] [cy] := (1/V) * [\int y dV] [cz] [\int z dV]

This method is virtual since some derived elements might want to use shortcuts to compute their centroid. For most element types, this method is more expensive than calling vertex_average(), so if you only need a point which is located "somewhere" in the interior of the element, consider calling vertex_average() instead.

Reimplemented in libMesh::C0Polyhedron, libMesh::Hex8, libMesh::Prism6, libMesh::Pyramid5, libMesh::Tet4, libMesh::Edge2, libMesh::C0Polygon, libMesh::Quad4, and libMesh::Tri3.

Definition at line 575 of file elem.C.

576{
577 // The base class implementation builds a finite element of the correct
578 // order and computes the centroid, c=(cx, cy, cz), where:
579 //
580 // [cx] [\int x dV]
581 // [cy] := (1/V) * [\int y dV]
582 // [cz] [\int z dV]
583 //
584 // using quadrature. Note that we can expand "x" in the FE space as:
585 //
586 // x = \sum_i x_i \phi_i
587 //
588 // where x_i are the nodal positions of the element and \phi_i are the
589 // associated Lagrange shape functions. This allows us to write the
590 // integrals above as e.g.:
591 //
592 // \int x dV = \sum_i x_i \int \phi_i dV
593 //
594 // Defining:
595 //
596 // V_i := \int \phi_i dV
597 //
598 // we then have:
599 //
600 // [cx] [\sum_i x_i V_i]
601 // [cy] = (1/V) * [\sum_i y_i V_i]
602 // [cz] [\sum_i z_i V_i]
603 //
604 // where:
605 // V = \sum_i V_i
606 //
607 // Derived element types can overload this method to compute
608 // the centroid more efficiently when possible.
609
610 // If this Elem has an elevated p_level, then we need to generate a
611 // barebones copy of it with zero p_level and call true_centroid()
612 // on that instead. This workaround allows us to avoid issues with
613 // calling FE::reinit() with a default_order() FEType, and then
614 // having that order incorrectly boosted by p_level.
615 if (this->p_level())
616 {
617 auto elem_copy = this->disconnected_clone();
618#ifdef LIBMESH_ENABLE_AMR
619 elem_copy->set_p_level(0);
620#endif
621
622 // Set node pointers
623 for (auto n : this->node_index_range())
624 elem_copy->set_node(n, _nodes[n]);
625
626 return elem_copy->true_centroid();
627 }
628
629 const FEFamily mapping_family = FEMap::map_fe_type(*this);
630 const FEType fe_type(this->default_order(), mapping_family);
631
632 // Build FE and attach quadrature rule. The default quadrature rule
633 // integrates the mass matrix exactly, thus it is overkill to
634 // integrate the basis functions, but this is convenient.
635 std::unique_ptr<FEBase> fe = FEBase::build(this->dim(), fe_type);
636 QGauss qrule (this->dim(), fe_type.default_quadrature_order());
637 fe->attach_quadrature_rule(&qrule);
638
639 // Pre-request required data
640 const auto & JxW = fe->get_JxW();
641 const auto & phi = fe->get_phi();
642
643 // Re-compute element-specific values
644 fe->reinit(this);
645
646 // Number of basis functions
647 auto N = phi.size();
648 libmesh_assert_equal_to(N, this->n_nodes());
649
650 // Compute V_i
651 std::vector<Real> V(N);
652 for (auto qp : index_range(JxW))
653 for (auto i : make_range(N))
654 V[i] += JxW[qp] * phi[i][qp];
655
656 // Compute centroid
657 Point cp;
658 Real vol = 0.;
659
660 for (auto i : make_range(N))
661 {
662 cp += this->point(i) * V[i];
663 vol += V[i];
664 }
665
666 return cp / vol;
667}
libMesh::Elem::disconnected_clone
virtual std::unique_ptr< Elem > disconnected_clone() const
Definition elem.C:410
libMesh::FEMap::map_fe_type
static FEFamily map_fe_type(const Elem &elem)
Definition fe_map.C:46

References libMesh::Elem::_nodes, libMesh::FEGenericBase< OutputType >::build(), libMesh::Elem::default_order(), libMesh::FEType::default_quadrature_order(), libMesh::Elem::dim(), libMesh::Elem::disconnected_clone(), libMesh::index_range(), libMesh::make_range(), libMesh::FEMap::map_fe_type(), libMesh::Elem::n_nodes(), libMesh::Elem::node_index_range(), libMesh::Elem::p_level(), libMesh::Elem::point(), and libMesh::Real.

Referenced by VolumeTest::testHex20PLevelTrueCentroid(), VolumeTest::testPyramid5TrueCentroid(), VolumeTest::testQuad4TrueCentroid(), VolumeTest::testTri3TrueCentroid(), and libMesh::C0Polyhedron::true_centroid().

◆ type()

virtual ElemType libMesh::Quad9::type ( ) const
inlineoverridevirtual
Returns
QUAD9.

Implements libMesh::Elem.

Reimplemented in libMesh::QuadShell9.

Definition at line 71 of file face_quad9.h.

71{ return QUAD9; }

References libMesh::QUAD9.

◆ unique_id()

unique_id_type libMesh::DofObject::unique_id ( ) const
inlineinherited
Returns
The globally unique_id for this DofObject

Definition at line 835 of file dof_object.h.

836{
837#ifdef LIBMESH_ENABLE_UNIQUE_ID
838 libmesh_assert (this->valid_unique_id());
839 return _unique_id;
840#else
841 return invalid_unique_id;
842#endif
843}
libMesh::DofObject::invalid_unique_id
static constexpr unique_id_type invalid_unique_id
An invalid unique_id to distinguish an uninitialized DofObject.
Definition dof_object.h:478

References libMesh::DofObject::_unique_id, libMesh::DofObject::invalid_unique_id, libMesh::libmesh_assert(), and libMesh::DofObject::valid_unique_id().

Referenced by libMesh::DistributedMesh::add_elem(), libMesh::ReplicatedMesh::add_elem(), libMesh::DistributedMesh::add_node(), libMesh::ReplicatedMesh::add_node(), libMesh::ReplicatedMesh::add_point(), libMesh::MeshTools::Modification::all_tri(), libMesh::Elem::disconnected_clone(), libMesh::C0Polyhedron::disconnected_clone(), libMesh::MeshTools::Modification::flatten(), libMesh::Elem::get_info(), libMesh::DistributedMesh::insert_elem(), libMesh::ReplicatedMesh::insert_elem(), libMesh::XdrIO::pack_element(), libMesh::ExodusII_IO::read_elemental_variable(), libMesh::CheckpointIO::read_nodes(), MeshInputTest::testExodusSetNodeUniqueIdsFromMaps_implementation(), SlitMeshRefinedSystemTest::testRestart(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), and libMesh::XdrIO::write_serialized_nodes().

◆ 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.

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}
libMesh::largest_id_type
uint64_t largest_id_type
Definition id_types.h:148

References libMesh::DofObject::_idx_buf, libMesh::DofObject::clear_old_dof_object(), libMesh::DofObject::construct(), libMesh::libmesh_assert(), and libMesh::DofObject::old_dof_object.

Referenced by libMesh::Parallel::Packing< Elem * >::unpack(), and libMesh::Parallel::Packing< Node * >::unpack().

◆ 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}
libMesh::DofObject::unpackable_indexing_size
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

References libMesh::DofObject::unpackable_indexing_size().

Referenced by libMesh::Parallel::Packing< Node * >::unpack(), and libMesh::DofObject::unpackable_indexing_size().

◆ valid_id()

bool libMesh::DofObject::valid_id ( ) const
inlineinherited
Returns
true if this DofObject has a valid id set, false otherwise.

Definition at line 861 of file dof_object.h.

862{
863 return (DofObject::invalid_id != _id);
864}

References libMesh::DofObject::_id, and libMesh::DofObject::invalid_id.

Referenced by libMesh::DistributedMesh::add_elem(), libMesh::ReplicatedMesh::add_elem(), libMesh::DistributedMesh::add_node(), libMesh::ReplicatedMesh::add_node(), libMesh::Elem::get_info(), libMesh::Node::get_info(), libMesh::Poly2TriTriangulator::insert_refinement_points(), libMesh::Elem::libmesh_assert_valid_node_pointers(), DofObjectTest< DerivedClass >::testInvalidateId(), and DofObjectTest< DerivedClass >::testValidId().

◆ 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 905 of file dof_object.h.

906{
907 return (DofObject::invalid_processor_id != _processor_id);
908}

References libMesh::DofObject::_processor_id, and libMesh::DofObject::invalid_processor_id.

Referenced by DofObjectTest< DerivedClass >::testInvalidateProcId(), and DofObjectTest< DerivedClass >::testValidProcId().

◆ 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 869 of file dof_object.h.

870{
871#ifdef LIBMESH_ENABLE_UNIQUE_ID
872 return (DofObject::invalid_unique_id != _unique_id);
873#else
874 return false;
875#endif
876}

References libMesh::DofObject::_unique_id, and libMesh::DofObject::invalid_unique_id.

Referenced by libMesh::DistributedMesh::add_elem(), libMesh::ReplicatedMesh::add_elem(), libMesh::DistributedMesh::add_node(), libMesh::ReplicatedMesh::add_node(), libMesh::ReplicatedMesh::add_point(), libMesh::Elem::disconnected_clone(), libMesh::C0Polyhedron::disconnected_clone(), libMesh::Elem::get_info(), libMesh::DistributedMesh::insert_elem(), libMesh::ReplicatedMesh::insert_elem(), and libMesh::DofObject::unique_id().

◆ var_to_vg()

unsigned int libMesh::DofObject::var_to_vg ( const unsigned int  s,
const unsigned int  var 
) const
inlineprivateinherited

Utility function - for variable var in system s, figure out what variable group it lives in.

Definition at line 1317 of file dof_object.h.

1319{
1320 const unsigned int
1321 nvg = this->n_var_groups(s);
1322
1323 for (unsigned int vg=0, vg_end=0; vg<nvg; vg++)
1324 {
1325 vg_end += this->n_vars(s,vg);
1326 if (var < vg_end) return vg;
1327 }
1328
1329 libmesh_error_msg("Error: could not map variable " << var << " to variable group.");
1330}

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

Referenced by libMesh::DofObject::n_comp(), libMesh::DofObject::set_dof_number(), and libMesh::DofObject::set_n_comp().

◆ 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 1176 of file dof_object.h.

1178{
1179 std::pair<unsigned int, unsigned int> returnval(0,0);
1180
1181 unsigned int & vg = returnval.first;
1182 unsigned int & offset = returnval.second;
1183
1184 unsigned int vg_start = 0;
1185 for (; ; vg++)
1186 {
1187 libmesh_assert_less(vg, this->n_var_groups(s));
1188
1189 const unsigned int vg_end = vg_start + this->n_vars(s,vg);
1190 if (var < vg_end)
1191 {
1192 offset = var - vg_start;
1193 return returnval;
1194 }
1195 vg_start = vg_end;
1196 }
1197}

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

Referenced by libMesh::DofMap::_dof_indices(), libMesh::DofMap::_node_dof_indices(), libMesh::DofObject::dof_number(), libMesh::OldSolutionValue< Output, point_output >::eval_old_dofs(), and libMesh::OldSolutionCoefs< Output, point_output >::eval_old_dofs().

◆ 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 669 of file elem.C.

670{
671 Point cp;
672
673 const auto n_vertices = this->n_vertices();
674
675 for (unsigned int n=0; n<n_vertices; n++)
676 cp.add (this->point(n));
677
678 return (cp /= static_cast<Real>(n_vertices));
679}

References libMesh::TypeVector< T >::add(), libMesh::Elem::n_vertices(), and libMesh::Real.

Referenced by libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::BoundaryInfo::get_side_and_node_maps(), libMesh::Poly2TriTriangulator::insert_refinement_points(), OutputAssembly::interior_assembly(), A0::interior_assembly(), A1::interior_assembly(), SlitFunc::operator()(), libMesh::LocationMap< T >::point_of(), libMesh::RBParametrizedFunction::preevaluate_parametrized_function_on_mesh(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::C0Polyhedron::retriangulate(), libMesh::FE< Dim, T >::shape_deriv(), libMesh::FE< Dim, T >::shape_deriv(), libMesh::FE< Dim, T >::shape_second_deriv(), libMesh::FE< Dim, T >::shape_second_deriv(), DefaultCouplingTest::testCoupling(), PointNeighborCouplingTest::testCoupling(), libMesh::Tet4::true_centroid(), and libMesh::Tri3::true_centroid().

◆ 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 1293 of file dof_object.h.

1295{
1296 libmesh_assert_less (s, this->n_systems());
1297 libmesh_assert_less (vg, this->n_var_groups(s));
1298
1299 const unsigned int
1300 start_idx_sys = this->start_idx(s);
1301
1302 libmesh_assert_less ((start_idx_sys + 2*vg + 1), _idx_buf.size());
1303
1304 // #ifdef DEBUG
1305 // std::cout << " [ ";
1306 // for (auto i : _idx_buf)
1307 // std::cout << i << " ";
1308 // std::cout << "]\n";
1309 // #endif
1310
1311 return _idx_buf[start_idx_sys + 2*vg + 1];
1312}

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::set_nonlocal_dof_objects(), libMesh::DofObject::set_vg_dof_base(), and DofObjectTest< DerivedClass >::testManualDofCalculation().

◆ volume()

Real libMesh::Quad9::volume ( ) const
overridevirtual

An optimized method for approximating the area of a QUAD9 using quadrature.

Reimplemented from libMesh::Elem.

Definition at line 347 of file face_quad9.C.

348{
349 // This specialization is good for Lagrange mappings only
350 if (this->mapping_type() != LAGRANGE_MAP)
351 return this->Elem::volume();
352
353 // Make copies of our points. It makes the subsequent calculations a bit
354 // shorter and avoids dereferencing the same pointer multiple times.
355 Point
356 x0 = point(0), x1 = point(1), x2 = point(2),
357 x3 = point(3), x4 = point(4), x5 = point(5),
358 x6 = point(6), x7 = point(7), x8 = point(8);
359
360 // Construct constant data vectors.
361 // \vec{x}_{\xi} = \vec{a1}*xi*eta^2 + \vec{b1}*eta**2 + \vec{c1}*xi*eta + \vec{d1}*xi + \vec{e1}*eta + \vec{f1}
362 // \vec{x}_{\eta} = \vec{a2}*xi^2*eta + \vec{b2}*xi**2 + \vec{c2}*xi*eta + \vec{d2}*xi + \vec{e2}*eta + \vec{f2}
363 // This is copy-pasted directly from the output of a Python script.
364 Point
365 a1 = x0/2 + x1/2 + x2/2 + x3/2 - x4 - x5 - x6 - x7 + 2*x8,
366 b1 = -x0/4 + x1/4 + x2/4 - x3/4 - x5/2 + x7/2,
367 c1 = -x0/2 - x1/2 + x2/2 + x3/2 + x4 - x6,
368 d1 = x5 + x7 - 2*x8,
369 e1 = x0/4 - x1/4 + x2/4 - x3/4,
370 f1 = x5/2 - x7/2,
371 a2 = a1,
372 b2 = -x0/4 - x1/4 + x2/4 + x3/4 + x4/2 - x6/2,
373 c2 = -x0/2 + x1/2 + x2/2 - x3/2 - x5 + x7,
374 d2 = x0/4 - x1/4 + x2/4 - x3/4,
375 e2 = x4 + x6 - 2*x8,
376 f2 = -x4/2 + x6/2;
377
378 // 3x3 quadrature, exact for bi-quintics
379 const unsigned int N = 3;
380 const Real q[N] = {-std::sqrt(15)/5., 0., std::sqrt(15)/5.};
381 const Real w[N] = {5./9, 8./9, 5./9};
382
383 Real vol=0.;
384 for (unsigned int i=0; i<N; ++i)
385 for (unsigned int j=0; j<N; ++j)
386 vol += w[i] * w[j] *
387 cross_norm(q[i]*q[j]*q[j]*a1 + q[j]*q[j]*b1 + q[j]*q[i]*c1 + q[i]*d1 + q[j]*e1 + f1,
388 q[i]*q[i]*q[j]*a2 + q[i]*q[i]*b2 + q[j]*q[i]*c2 + q[i]*d2 + q[j]*e2 + f2);
389
390 return vol;
391}

References libMesh::cross_norm(), libMesh::LAGRANGE_MAP, libMesh::Elem::mapping_type(), libMesh::Elem::point(), libMesh::Real, and libMesh::Elem::volume().

◆ 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 3209 of file elem.h.

3210{
3211 libmesh_assert(e);
3212 libmesh_assert (this->has_children());
3213
3214 unsigned int nc = this->n_children();
3215 for (unsigned int c=0; c != nc; c++)
3216 if (this->child_ptr(c) == e)
3217 return c;
3218
3219 libmesh_error_msg("ERROR: which_child_am_i() was called with a non-child!");
3220
3221 return libMesh::invalid_uint;
3222}

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(), libMesh::Parallel::sync_element_data_by_parent_id(), and ElemTest< elem_type >::test_n_refinements().

◆ 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 2936 of file elem.h.

2937{
2938 libmesh_assert(e);
2939
2940 const Elem * eparent = e;
2941
2942 while (eparent->level() > this->level())
2943 {
2944 eparent = eparent->parent();
2945 libmesh_assert(eparent);
2946 }
2947
2948 for (auto s : make_range(this->n_sides()))
2949 if (this->neighbor_ptr(s) == eparent)
2950 return s;
2951
2952 return libMesh::invalid_uint;
2953}

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(), assemble_temperature_jump(), MeshBaseTest::BrokenNeighborMesh(), libMesh::EquationSystems::build_discontinuous_solution_vector(), libMesh::MeshTetInterface::check_hull_integrity(), libMesh::BoundaryInfo::clear_stitched_boundary_side_ids(), libMesh::FEGenericBase< OutputType >::compute_proj_constraints(), libMesh::MeshTools::find_hanging_nodes_and_parents(), libMesh::MeshTetInterface::improve_hull_integrity(), libMesh::Poly2TriTriangulator::insert_refinement_points(), libMesh::Elem::libmesh_assert_valid_neighbors(), libMesh::Elem::nullify_neighbors(), and libMesh::C0Polyhedron::retriangulate().

◆ 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 855 of file elem.C.

856{
857 libmesh_assert(e);
858
859 const unsigned int ns = this->n_sides();
860 const unsigned int nn = this->n_nodes();
861
862 const unsigned int en = e->n_nodes();
863
864 // e might be on any side until proven otherwise
865 std::vector<bool> might_be_side(ns, true);
866
867 for (unsigned int i=0; i != en; ++i)
868 {
869 Point side_point = e->point(i);
870 unsigned int local_node_id = libMesh::invalid_uint;
871
872 // Look for a node of this that's contiguous with node i of
873 // e. Note that the exact floating point comparison of Point
874 // positions is intentional, see the class documentation for
875 // this function.
876 for (unsigned int j=0; j != nn; ++j)
877 if (this->point(j) == side_point)
878 local_node_id = j;
879
880 // If a node of e isn't contiguous with some node of this, then
881 // e isn't a side of this.
882 if (local_node_id == libMesh::invalid_uint)
883 return libMesh::invalid_uint;
884
885 // If a node of e isn't contiguous with some node on side s of
886 // this, then e isn't on side s.
887 for (unsigned int s=0; s != ns; ++s)
888 if (!this->is_node_on_side(local_node_id, s))
889 might_be_side[s] = false;
890 }
891
892 for (unsigned int s=0; s != ns; ++s)
893 if (might_be_side[s])
894 {
895#ifdef DEBUG
896 for (unsigned int s2=s+1; s2 < ns; ++s2)
897 libmesh_assert (!might_be_side[s2]);
898#endif
899 return s;
900 }
901
902 // Didn't find any matching side
903 return libMesh::invalid_uint;
904}

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

◆ 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 1740 of file elem.C.

1742{
1743 libmesh_assert (out_stream.good());
1744 libmesh_assert(_nodes);
1745 libmesh_assert_not_equal_to (iop, INVALID_IO_PACKAGE);
1746
1747 switch (iop)
1748 {
1749 case TECPLOT:
1750 {
1751 // This connectivity vector will be used repeatedly instead
1752 // of being reconstructed inside the loop.
1753 std::vector<dof_id_type> conn;
1754 for (auto sc : make_range(this->n_sub_elem()))
1755 {
1756 this->connectivity(sc, TECPLOT, conn);
1757
1758 std::copy(conn.begin(),
1759 conn.end(),
1760 std::ostream_iterator<dof_id_type>(out_stream, " "));
1761
1762 out_stream << '\n';
1763 }
1764 return;
1765 }
1766
1767 case UCD:
1768 {
1769 for (auto i : this->node_index_range())
1770 out_stream << this->node_id(i)+1 << "\t";
1771
1772 out_stream << '\n';
1773 return;
1774 }
1775
1776 default:
1777 libmesh_error_msg("Unsupported IO package " << iop);
1778 }
1779}
libMesh::Elem::connectivity
virtual void connectivity(const unsigned int sc, const IOPackage iop, std::vector< dof_id_type > &conn) const =0
libMesh::Elem::n_sub_elem
virtual unsigned int n_sub_elem() const =0

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.

Member Data Documentation

◆ _child_node_lookup

const int libMesh::Quad::_child_node_lookup
staticprotectedinherited
Initial value:
=
{
{ 0, 2, 12, 10, 1, 7, 11, 5, 6},
{ 2, 4, 14, 12, 3, 9, 13, 7, 8},
{ 10, 12, 22, 20, 11, 17, 21, 15, 16},
{ 12, 14, 24, 22, 13, 19, 23, 17, 18}
}

Lookup table from child id, child node id to "possible node location" (a simple dictionary-index in a 5x5 grid)

Definition at line 245 of file face_quad.h.

◆ _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 2270 of file elem.h.

Referenced by libMesh::Elem::add_child(), libMesh::Elem::add_child(), libMesh::Elem::child_ptr(), libMesh::Elem::child_ptr(), libMesh::Elem::child_ref_range(), 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

Pointers to this element's parent and neighbors, and for lower-dimensional elements' interior_parent.

Definition at line 2260 of file elem.h.

Referenced by libMesh::Elem::Elem(), libMesh::Elem::interior_parent(), libMesh::Elem::interior_parent(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::neighbor_ptr_range(), libMesh::Elem::neighbor_ptr_range(), libMesh::Elem::parent(), libMesh::Elem::parent(), libMesh::Polygon::Polygon(), libMesh::Polyhedron::Polyhedron(), libMesh::Elem::set_interior_parent(), libMesh::Elem::set_neighbor(), and libMesh::Elem::set_parent().

◆ _elemlinks_data

Elem* libMesh::Quad::_elemlinks_data[5+(LIBMESH_DIM >2)]
protectedinherited

Data for links to parent/neighbor/interior_parent elements.

Definition at line 216 of file face_quad.h.

◆ _embedding_matrix

const Real libMesh::Quad9::_embedding_matrix
staticprotected

Matrix that computes new nodal locations/solution values from current nodes/solution.

Definition at line 249 of file face_quad9.h.

Referenced by embedding_matrix().

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

◆ _id

dof_id_type libMesh::DofObject::_id
privateinherited

The id of the DofObject.

Definition at line 574 of file dof_object.h.

Referenced by libMesh::DofObject::id(), libMesh::DofObject::operator=(), libMesh::DofObject::set_id(), and libMesh::DofObject::valid_id().

◆ _idx_buf

index_buffer_t libMesh::DofObject::_idx_buf
privateinherited

Definition at line 671 of file dof_object.h.

Referenced by libMesh::DofObject::add_extra_integers(), libMesh::DofObject::add_extra_integers(), libMesh::DofObject::add_system(), libMesh::DofObject::debug_buffer(), libMesh::DofObject::dof_number(), libMesh::DofObject::end_idx(), libMesh::DofObject::end_idx_ints(), libMesh::DofObject::get_extra_datum(), libMesh::DofObject::get_extra_integer(), libMesh::DofObject::has_extra_integers(), libMesh::DofObject::n_comp_group(), libMesh::DofObject::n_extra_integers(), libMesh::DofObject::n_pseudo_systems(), libMesh::DofObject::n_systems(), libMesh::DofObject::n_vars(), libMesh::DofObject::operator=(), libMesh::DofObject::pack_indexing(), libMesh::DofObject::packed_indexing_size(), libMesh::DofObject::set_buffer(), libMesh::DofObject::set_dof_number(), libMesh::DofObject::set_extra_datum(), libMesh::DofObject::set_extra_integer(), 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(), libMesh::DofObject::unpack_indexing(), and libMesh::DofObject::vg_dof_base().

◆ _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 2312 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 2306 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::Quad::_master_points
staticprotectedinherited
Initial value:
=
{
{-1, -1},
{1, -1},
{1, 1},
{-1, 1},
{0, -1},
{1, 0},
{0, 1},
{-1, 0},
{0, 0}
}

Master element node locations.

Definition at line 239 of file face_quad.h.

Referenced by libMesh::Quad::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(), libMesh::ReferenceCounter::ReferenceCounter(), 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(), libMesh::ReferenceCounter::ReferenceCounter(), libMesh::ReferenceCounter::ReferenceCounter(), and libMesh::ReferenceCounter::~ReferenceCounter().

◆ _nodelinks_data

Node* libMesh::Quad9::_nodelinks_data[num_nodes]
protected

Data for links to nodes.

Definition at line 231 of file face_quad9.h.

◆ _nodes

Node** libMesh::Elem::_nodes
protectedinherited

Pointers to the nodes we are connected to.

Definition at line 2254 of file elem.h.

Referenced by libMesh::Hex20::connectivity(), libMesh::Hex27::connectivity(), libMesh::Hex8::connectivity(), libMesh::InfHex16::connectivity(), libMesh::InfHex18::connectivity(), libMesh::InfHex8::connectivity(), libMesh::InfPrism12::connectivity(), libMesh::InfPrism6::connectivity(), libMesh::Prism15::connectivity(), libMesh::Prism18::connectivity(), libMesh::Prism6::connectivity(), libMesh::Pyramid13::connectivity(), libMesh::Pyramid14::connectivity(), libMesh::Pyramid18::connectivity(), libMesh::Pyramid5::connectivity(), libMesh::Tet10::connectivity(), libMesh::Tet14::connectivity(), libMesh::Tet4::connectivity(), libMesh::Elem::Elem(), libMesh::Elem::get_node_index(), libMesh::Elem::get_nodes(), libMesh::Tri3Subdivision::local_node_number(), libMesh::Elem::node_id(), libMesh::Elem::node_ptr(), libMesh::Elem::node_ptr(), libMesh::Elem::node_ref_range(), libMesh::Elem::node_ref_range(), libMesh::Elem::point(), libMesh::Elem::point(), libMesh::Polygon::Polygon(), libMesh::Polyhedron::Polyhedron(), libMesh::Elem::set_node(), libMesh::Elem::set_node(), libMesh::Elem::true_centroid(), and libMesh::Elem::write_connectivity().

◆ _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 2299 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 2289 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().

◆ _processor_id

processor_id_type libMesh::DofObject::_processor_id
privateinherited

The processor_id of the DofObject.

Degrees of freedom are wholly owned by processors, however they may be duplicated on other processors.

This is stored as an unsigned short int since we cannot expect to be solving on 65000+ processors any time soon, can we??

Definition at line 585 of file dof_object.h.

Referenced by libMesh::DofObject::operator=(), libMesh::DofObject::processor_id(), libMesh::DofObject::processor_id(), and libMesh::DofObject::valid_processor_id().

◆ _rflag

unsigned char libMesh::Elem::_rflag
protectedinherited

h refinement flag.

This is stored as an unsigned char to save space.

Definition at line 2283 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 2276 of file elem.h.

Referenced by libMesh::Elem::subdomain_id(), and libMesh::Elem::subdomain_id().

◆ _second_order_adjacent_vertices

const unsigned short int libMesh::Quad::_second_order_adjacent_vertices
staticprotectedinherited
Initial value:
=
{
{0, 1},
{1, 2},
{2, 3},
{0, 3}
}

Matrix that tells which vertices define the location of mid-side (or second-order) nodes.

Since most second-order nodes are identical for Quad8 and Quad9, we keep this matrix here in Quad

Definition at line 224 of file face_quad.h.

Referenced by libMesh::Quad8::second_order_adjacent_vertex(), and second_order_adjacent_vertex().

◆ _second_order_vertex_child_index

const unsigned short int libMesh::Quad::_second_order_vertex_child_index
staticprotectedinherited
Initial value:
=
{
99,99,99,99,
1,2,3,3,
2
}

Vector that names the child vertex index for each second order node.

Definition at line 234 of file face_quad.h.

Referenced by libMesh::Quad8::second_order_child_vertex(), and second_order_child_vertex().

◆ _second_order_vertex_child_number

const unsigned short int libMesh::Quad::_second_order_vertex_child_number
staticprotectedinherited
Initial value:
=
{
99,99,99,99,
0,1,2,0,
0
}

Vector that names a child sharing each second order node.

Definition at line 229 of file face_quad.h.

Referenced by libMesh::Quad8::second_order_child_vertex(), and second_order_child_vertex().

◆ _unique_id

unique_id_type libMesh::DofObject::_unique_id
privateinherited

A globally unique id, guaranteed not to change as the mesh is repartitioned or adapted.

Definition at line 568 of file dof_object.h.

Referenced by libMesh::DofObject::operator=(), libMesh::DofObject::set_unique_id(), libMesh::DofObject::unique_id(), and libMesh::DofObject::valid_unique_id().

◆ adjacent_sides_map

const unsigned int libMesh::Quad::adjacent_sides_map
staticprotectedinherited
Initial value:
=
{
{0, 3},
{0, 1},
{1, 2},
{2, 3}
}

This maps the \( j^{th} \) node to the (in this case) 2 side ids adjacent to the node.

The side numbering matches the one used in the derived classes' side_nodes_map. This data structure is used in the Quad::edges_adjacent_to_node() override and is shared by all the derived Quad types.

Definition at line 254 of file face_quad.h.

Referenced by libMesh::Quad::edges_adjacent_to_node().

◆ affine_tol

constexpr Real libMesh::Elem::affine_tol = TOLERANCE*TOLERANCE
staticconstexprprotectedinherited

Default tolerance to use in has_affine_map().

Definition at line 2070 of file elem.h.

Referenced by libMesh::Hex20::has_affine_map(), libMesh::Hex27::has_affine_map(), libMesh::Hex8::has_affine_map(), libMesh::Prism15::has_affine_map(), libMesh::Prism18::has_affine_map(), libMesh::Prism20::has_affine_map(), libMesh::Prism21::has_affine_map(), libMesh::Prism6::has_affine_map(), libMesh::Tet10::has_affine_map(), libMesh::Edge3::has_affine_map(), libMesh::Edge4::has_affine_map(), libMesh::Quad4::has_affine_map(), libMesh::Quad8::has_affine_map(), has_affine_map(), and libMesh::Tri6::has_affine_map().

◆ invalid_id

constexpr dof_id_type libMesh::DofObject::invalid_id = static_cast<dof_id_type>(-1)
staticconstexprinherited

An invalid id to distinguish an uninitialized DofObject.

Definition at line 473 of file dof_object.h.

Referenced by libMesh::DofMap::_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::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::Elem::bracketing_nodes(), ExtraIntegersTest::checkpoint_helper(), libMesh::StaticCondensation::clear(), libMesh::FEGenericBase< OutputType >::compute_periodic_constraints(), libMesh::FEGenericBase< OutputType >::compute_proj_constraints(), 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::OldSolutionValue< Output, point_output >::eval_old_dofs(), libMesh::TopologyMap::find(), libMesh::TopologyMap::find(), libMesh::DofMap::gather_constraints(), libMesh::MeshBase::get_elemset_code(), 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::DistributedMesh::own_node(), libMesh::XdrIO::pack_element(), libMesh::SFCPartitioner::partition_range(), libMesh::Elem::point(), libMesh::ExodusII_IO::read(), libMesh::DynaIO::read_mesh(), libMesh::System::read_parallel_data(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::StaticCondensationDofMap::reinit(), 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< DerivedClass >::testAddExtraData(), DofObjectTest< DerivedClass >::testAddSystemExtraInts(), ExtraIntegersTest::testExtraIntegersExodusReading(), InfFERadialTest::testRefinement(), DofObjectTest< DerivedClass >::testSetNSystemsExtraInts(), DofObjectTest< DerivedClass >::testSetNVariableGroupsExtraInts(), MeshTetTest::testTetInterfaceBase(), DofObjectTest< DerivedClass >::testValidId(), MeshSmootherTest::testVariationalSmoother(), WriteElemsetData::testWriteImpl(), libMesh::NetGenMeshInterface::triangulate(), libMesh::Poly2TriTriangulator::triangulate_current_points(), libMesh::Parallel::Packing< Elem * >::unpack(), 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)
staticconstexprinherited

An invalid processor_id to distinguish DoFs that have not been assigned to a processor.

Definition at line 484 of file dof_object.h.

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::DistributedMesh::add_elem(), libMesh::MeshRefinement::add_node(), libMesh::DistributedMesh::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< DerivedClass >::testValidProcId(), libMesh::MeshTools::total_weight(), libMesh::Parallel::Packing< Elem * >::unpack(), libMesh::Parallel::Packing< Node * >::unpack(), 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()
staticconstexprinherited

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 245 of file elem.h.

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::BoundaryInfo::add_elements(), 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)
staticconstexprinherited

An invalid unique_id to distinguish an uninitialized DofObject.

Definition at line 478 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::Quad9::LIBMESH_ENABLE_TOPOLOGY_CACHES
protected

Definition at line 251 of file face_quad9.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 654 of file elem.h.

Referenced by libMesh::Elem::Elem(), and ElemTest< elem_type >::test_static_data().

◆ ncv_magic

const index_t libMesh::DofObject::ncv_magic = 256
staticprivateinherited

Above we introduced the chimera ncv, which is a hybrid of the form ncv = ncv_magic*nv + nc where nv are the number of identical variables of a given type, and nc is the number of components for this set of variables.

It is hoped that by setting this to a power of two, an optimizing compiler will recognize later that #/ncv_magic is simply a bitshift

Definition at line 682 of file dof_object.h.

Referenced by libMesh::DofObject::n_comp_group(), libMesh::DofObject::set_n_comp_group(), and libMesh::DofObject::set_n_vars_per_group().

◆ ncv_magic_exp

const index_t libMesh::DofObject::ncv_magic_exp = 8
staticprivateinherited

Definition at line 683 of file dof_object.h.

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

◆ nodes_per_side

const int libMesh::Quad9::nodes_per_side = 3
static

Definition at line 198 of file face_quad9.h.

Referenced by local_side_node().

◆ num_children

const int libMesh::Quad::num_children = 4
staticinherited

Definition at line 86 of file face_quad.h.

◆ num_nodes

const int libMesh::Quad9::num_nodes = 9
static

Geometric constants for Quad9.

Definition at line 197 of file face_quad9.h.

Referenced by connectivity().

◆ num_sides

const int libMesh::Quad::num_sides = 4
staticinherited

Geometric constants for Quad4.

Definition at line 85 of file face_quad.h.

Referenced by libMesh::Quad8::center_node_on_side(), and 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(), libMesh::DofObject::get_old_dof_object_ref(), 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::Quad9::side_nodes_map
static
Initial value:
=
{
{0, 1, 4},
{1, 2, 5},
{2, 3, 6},
{3, 0, 7}
}

This maps the \( j^{th} \) node of the \( i^{th} \) side to element node numbers.

Definition at line 204 of file face_quad9.h.

Referenced by is_node_on_side(), local_side_node(), and nodes_on_side().

◆ 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 990 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 628 of file elem.h.

Referenced by FETestBase< order, family, elem_type, build_nx, CaseName >::setUp(), SystemsTest::test2DProjectVectorFE(), SystemsTest::test3DProjectVectorFE(), AllRBBTest::test_box(), AllTriTest::test_helper(), ElemTest< elem_type >::test_static_data(), PointLocatorTest::testLocator(), and libMesh::Parallel::Packing< Elem * >::unpack().

◆ 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 742 of file elem.h.

Referenced by ElemTest< elem_type >::test_static_data(), and libMesh::Parallel::Packing< Elem * >::unpack().

◆ 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 643 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(), libMesh::Parallel::Packing< Elem * >::unpack(), 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 678 of file elem.h.

Referenced by libMesh::Elem::positive_face_orientation(), libMesh::Elem::relative_edge_face_order(), libMesh::PetscPreconditioner< T >::set_hypre_ads_data(), ElemTest< elem_type >::test_static_data(), MeshGenerationTest::testBuildCube(), MeshGenerationTest::testBuildSquare(), and libMesh::Parallel::Packing< Elem * >::unpack().

The documentation for this class was generated from the following files:
Generated on Fri Aug 21 2026 13:32:59 for libMesh by doxygen 1.9.8