Processing math: 0%
libMesh
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Pages
Public Types | Public Member Functions | Static Public Member Functions | Static Public Attributes | Protected Types | Protected Member Functions | Static Protected Member Functions | Protected Attributes | Static Protected Attributes | List of all members
libMesh::InfEdge2 Class Reference


The InfEdge2 is an infinite element in 1D composed of 2 nodes. More...

#include <edge_inf_edge2.h>

Inheritance diagram for libMesh::InfEdge2:
[legend]

Public Types

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

Public Member Functions

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

Static Public Member Functions

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

Static Public Attributes

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

Protected Types

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

Protected Member Functions

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

Static Protected Member Functions

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

Protected Attributes

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

Static Protected Attributes

static constexpr Real affine_tol = TOLERANCE*TOLERANCE
 Default tolerance to use in has_affine_map(). More...
 
static Counts _counts
 Actually holds the data. More...
 
static Counts _counts
 Actually holds the data. More...
 
static Threads::atomic< unsigned int_n_objects
 The number of objects. More...
 
static Threads::atomic< unsigned int_n_objects
 The number of objects. More...
 
static Threads::spin_mutex _mutex
 Mutual exclusion object to enable thread-safe reference counting. More...
 
static Threads::spin_mutex _mutex
 Mutual exclusion object to enable thread-safe reference counting. More...
 
static bool _enable_print_counter = true
 Flag to control whether reference count information is printed when print_info is called. More...
 
static bool _enable_print_counter = true
 Flag to control whether reference count information is printed when print_info is called. More...
 

Detailed Description


The InfEdge2 is an infinite element in 1D composed of 2 nodes.

It is numbered like this:

*   INFEDGE2:
*       o         closer to infinity
*       | 1
*       |
*       |
*       |
*       o         base node
*         0
* 
Author
Daniel Dreyer
Date
2003 A 1D infinite element with 2 nodes.

Definition at line 52 of file edge_inf_edge2.h.

Member Typedef Documentation

◆ ConstNeighborPtrIter

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

Definition at line 334 of file elem.h.

◆ Counts [1/2]

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

Data structure to log the information.

The log is identified by the class name.

Definition at line 119 of file reference_counter.h.

◆ Counts [2/2]

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

Data structure to log the information.

The log is identified by the class name.

Definition at line 119 of file reference_counter.h.

◆ NeighborPtrIter

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

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

Definition at line 333 of file elem.h.

◆ Predicate

Useful iterator typedefs.

Definition at line 1860 of file elem.h.

Member Enumeration Documentation

◆ RefinementState

Enumeration of possible element refinement states.

Enumerator
COARSEN 
DO_NOTHING 
REFINE 
JUST_REFINED 
JUST_COARSENED 
INACTIVE 
COARSEN_INACTIVE 
INVALID_REFINEMENTSTATE 

Definition at line 1452 of file elem.h.

Constructor & Destructor Documentation

◆ InfEdge2() [1/3]

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

Constructor.

By default this element has no parent.

Definition at line 60 of file edge_inf_edge2.h.

60  :
Edge(const unsigned int nn, Elem *p, Node **nodelinkdata)
Default line element, takes number of nodes and parent.
Definition: edge.h:45
static const int num_nodes
Geometric constants for InfEdge2.
Node * _nodelinks_data[2]
Data for links to nodes.

◆ InfEdge2() [2/3]

libMesh::InfEdge2::InfEdge2 ( InfEdge2 &&  )
delete

◆ InfEdge2() [3/3]

libMesh::InfEdge2::InfEdge2 ( const InfEdge2 )
delete

◆ ~InfEdge2()

virtual libMesh::InfEdge2::~InfEdge2 ( )
virtualdefault

Member Function Documentation

◆ _get_bracketing_node_cache()

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

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

Definition at line 2209 of file elem.h.

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

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

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

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

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

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

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

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

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

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

References libMesh::ElemInternal::active_family_tree().

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

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

◆ active_family_tree() [2/2]

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

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

Definition at line 2141 of file elem.C.

References libMesh::ElemInternal::active_family_tree().

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

◆ active_family_tree_by_neighbor() [1/2]

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

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

Definition at line 2261 of file elem.C.

References libMesh::ElemInternal::active_family_tree_by_neighbor().

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

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

◆ active_family_tree_by_neighbor() [2/2]

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

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

Definition at line 2270 of file elem.C.

References libMesh::ElemInternal::active_family_tree_by_neighbor().

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

◆ active_family_tree_by_side() [1/2]

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

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

Definition at line 2167 of file elem.C.

References libMesh::ElemInternal::active_family_tree_by_side().

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

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

◆ active_family_tree_by_side() [2/2]

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

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

Definition at line 2176 of file elem.C.

References libMesh::ElemInternal::active_family_tree_by_side().

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

◆ active_family_tree_by_topological_neighbor() [1/2]

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

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

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

Definition at line 2279 of file elem.C.

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

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

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

◆ active_family_tree_by_topological_neighbor() [2/2]

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

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

Definition at line 2293 of file elem.C.

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

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

◆ add_child() [1/2]

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

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

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

Definition at line 2044 of file elem.C.

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

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

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

◆ add_child() [2/2]

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

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

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

Definition at line 2071 of file elem.C.

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

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

◆ add_extra_integers() [1/2]

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

Assigns a set of extra integers to this DofObject.

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

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

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

Definition at line 490 of file dof_object.C.

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

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

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

◆ add_extra_integers() [2/2]

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

Assigns a set of extra integers to this DofObject.

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

Any newly-added values will be copied from default_values.

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

Definition at line 542 of file dof_object.C.

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

544 {
545  libmesh_assert_equal_to(n_integers, default_values.size());
546 
547  const unsigned int n_old_integers = this->n_extra_integers();
548  this->add_extra_integers(n_integers);
549  if (n_integers > n_old_integers)
550  {
551  const unsigned int n_more_integers = n_integers - n_old_integers;
552  std::copy(default_values.begin()+n_old_integers,
553  default_values.end(),
554  _idx_buf.end()-n_more_integers);
555  }
556 }
void add_extra_integers(const unsigned int n_integers)
Assigns a set of extra integers to this DofObject.
Definition: dof_object.C:490
unsigned int n_extra_integers() const
Returns how many extra integers are associated to the DofObject.
Definition: dof_object.h:1170
index_buffer_t _idx_buf
Definition: dof_object.h:680

◆ add_system()

void libMesh::DofObject::add_system ( )
inherited

Adds an additional system to the DofObject.

Definition at line 195 of file dof_object.C.

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

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

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

◆ ancestor()

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

Definition at line 2010 of file elem.C.

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

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

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

◆ as_parent_node()

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

Definition at line 2386 of file elem.C.

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

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

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

◆ boundary_sides_begin()

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

Iterator accessor functions.

Definition at line 3411 of file elem.C.

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

3412 {
3413  Predicates::BoundarySide<SideIter> bsp;
3414  return side_iterator(this->_first_side(), this->_last_side(), bsp);
3415 }
SideIter _last_side()
Definition: elem.h:3478
SideIter _first_side()
Side iterator helper functions.
Definition: elem.h:3470

◆ boundary_sides_end()

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

Definition at line 3420 of file elem.C.

References libMesh::Elem::_last_side().

3421 {
3422  Predicates::BoundarySide<SideIter> bsp;
3423  return side_iterator(this->_last_side(), this->_last_side(), bsp);
3424 }
SideIter _last_side()
Definition: elem.h:3478

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

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

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

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

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

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

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

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

◆ build_edge_ptr() [1/4]

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

The Elem::build_edge_ptr() member makes no sense for edges.

Implements libMesh::Elem.

Definition at line 193 of file edge.h.

194  { libmesh_not_implemented(); return std::unique_ptr<Elem>(); }

◆ build_edge_ptr() [2/4]

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

The Elem::build_edge_ptr() member makes no sense for edges.

Implements libMesh::Elem.

Definition at line 199 of file edge.h.

200  { libmesh_not_implemented(); }

◆ build_edge_ptr() [3/4]

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

Definition at line 2840 of file elem.h.

References libMesh::Elem::build_edge_ptr().

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

◆ build_edge_ptr() [4/4]

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

Definition at line 2852 of file elem.h.

References libMesh::Elem::build_edge_ptr().

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

◆ build_side_ptr() [1/12]

std::unique_ptr< Elem > libMesh::Edge::build_side_ptr ( const unsigned int  i)
finaloverridevirtualinherited
Returns
A pointer to a NodeElem for the specified node.

Implements libMesh::Elem.

Definition at line 86 of file edge.C.

References libMesh::Elem::node_ptr().

Referenced by libMesh::Edge::build_side_ptr(), and libMesh::Edge::side_ptr().

87 {
88  libmesh_assert_less (i, 2);
89  std::unique_ptr<Elem> nodeelem = std::make_unique<NodeElem>();
90  nodeelem->set_node(0, this->node_ptr(i));
91 
92  nodeelem->set_interior_parent(this);
93  nodeelem->inherit_data_from(*this);
94 
95  return nodeelem;
96 }
const Node * node_ptr(const unsigned int i) const
Definition: elem.h:2507

◆ build_side_ptr() [2/12]

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

Rebuilds a NODEELEM for the specified node.

Implements libMesh::Elem.

Definition at line 99 of file edge.C.

References libMesh::Edge::build_side_ptr(), libMesh::Edge::n_sides(), libMesh::Elem::node_ptr(), and libMesh::NODEELEM.

101 {
102  libmesh_assert_less (i, this->n_sides());
103 
104  if (!side.get() || side->type() != NODEELEM)
105  side = this->build_side_ptr(i);
106  else
107  {
108  side->set_interior_parent(this);
109  side->inherit_data_from(*this);
110  side->set_node(0, this->node_ptr(i));
111  }
112 }
virtual std::unique_ptr< Elem > build_side_ptr(const unsigned int i) override final
Definition: edge.C:86
const Node * node_ptr(const unsigned int i) const
Definition: elem.h:2507
virtual unsigned int n_sides() const override final
Definition: edge.h:83

◆ build_side_ptr() [3/12]

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

Definition at line 927 of file elem.h.

928  { if (proxy) libmesh_error(); libmesh_deprecated(); return this->build_side_ptr(i); }
virtual std::unique_ptr< Elem > build_side_ptr(const unsigned int i) override final
Definition: edge.C:86

◆ build_side_ptr() [4/12]

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

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

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

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

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

◆ build_side_ptr() [5/12]

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

Definition at line 2745 of file elem.h.

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

◆ build_side_ptr() [6/12]

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

Definition at line 930 of file elem.h.

931  { if (proxy) libmesh_error(); libmesh_deprecated(); return this->build_side_ptr(i); }
virtual std::unique_ptr< Elem > build_side_ptr(const unsigned int i) override final
Definition: edge.C:86

◆ build_side_ptr() [7/12]

virtual void libMesh::Elem::build_side_ptr
inherited

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

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

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

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

◆ build_side_ptr() [8/12]

void libMesh::Elem::build_side_ptr
inlineinherited

Definition at line 2757 of file elem.h.

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

◆ build_side_ptr() [9/12]

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

Definition at line 2745 of file elem.h.

References libMesh::Elem::build_side_ptr().

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

◆ build_side_ptr() [10/12]

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

Definition at line 927 of file elem.h.

References libMesh::Elem::build_side_ptr().

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

◆ build_side_ptr() [11/12]

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

Definition at line 930 of file elem.h.

References libMesh::Elem::build_side_ptr().

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

◆ build_side_ptr() [12/12]

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

Definition at line 2757 of file elem.h.

References libMesh::Elem::build_side_ptr().

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

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

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

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

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

◆ center_node_on_side()

unsigned int libMesh::Edge::center_node_on_side ( const unsigned short  side) const
finaloverridevirtualinherited
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 159 of file edge.C.

References libMesh::Edge::n_sides().

160 {
161  libmesh_assert_less (side, this->n_sides());
162  return side;
163 }
virtual unsigned int n_sides() const override final
Definition: edge.h:83

◆ centroid()

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

Calls Elem::vertex_average() for backwards compatibility.

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

Definition at line 578 of file elem.C.

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

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

◆ child_neighbor() [1/2]

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

Definition at line 2640 of file elem.h.

References libMesh::Elem::neighbor_ptr_range().

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

◆ child_neighbor() [2/2]

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

Definition at line 2652 of file elem.h.

References libMesh::Elem::neighbor_ptr_range().

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

◆ child_ptr() [1/2]

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

Definition at line 3163 of file elem.h.

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

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

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

◆ child_ptr() [2/2]

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

Definition at line 3172 of file elem.h.

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

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

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

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

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

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

◆ child_ref_range() [2/2]

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

Definition at line 2354 of file elem.h.

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

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

◆ clear_dofs()

void libMesh::DofObject::clear_dofs ( )
inlineinherited

Clear the DofMap data structures holding degree of freedom data.

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

Definition at line 798 of file dof_object.h.

References libMesh::DofObject::set_n_systems().

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

◆ clear_old_dof_object()

void libMesh::DofObject::clear_old_dof_object ( )
inherited

Sets the old_dof_object to nullptr.

Definition at line 128 of file dof_object.C.

References libMesh::DofObject::old_dof_object.

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

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

◆ close_to_point()

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

Reimplemented in libMesh::NodeElem.

Definition at line 2776 of file elem.C.

References libMesh::Elem::point_test().

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

2777 {
2778  // This test uses the user's passed-in tolerance for the
2779  // bounding box test as well, thereby allowing the routine to
2780  // find points which are not only "in" the element, but also
2781  // "nearby" to within some tolerance.
2782  return this->point_test(p, tol, tol);
2783 }
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:2788

◆ coarsen()

void libMesh::Elem::coarsen ( )
inherited

Coarsen the element.

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

Definition at line 163 of file elem_refinement.C.

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

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

◆ complete_order_equivalent_type()

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

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

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

Definition at line 3319 of file elem.C.

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

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

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

◆ compute_key() [1/4]

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

◆ compute_key() [2/4]

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

Definition at line 3302 of file elem.h.

References libMesh::Utility::hashword2().

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

◆ compute_key() [3/4]

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

Definition at line 3314 of file elem.h.

References libMesh::Utility::hashword().

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

◆ compute_key() [4/4]

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

Definition at line 3326 of file elem.h.

References libMesh::Utility::hashword().

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

◆ connectivity()

void libMesh::InfEdge2::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 84 of file edge_inf_edge2.C.

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

87 {
88  libmesh_assert_equal_to (se, 0);
89  libmesh_assert_less (se, this->n_sub_elem());
90  libmesh_assert_not_equal_to (iop, INVALID_IO_PACKAGE);
91 
92  conn.resize(2);
93 
94  switch (iop)
95  {
96  case TECPLOT:
97  {
98  conn[0] = this->node_id(0)+1;
99  conn[1] = this->node_id(1)+1;
100  return;
101  }
102 
103  case VTK:
104  {
105  conn[0] = this->node_id(0);
106  conn[1] = this->node_id(1);
107  return;
108  }
109 
110  default:
111  libmesh_error_msg("Unsupported IO package " << iop);
112  }
113 }
virtual unsigned int n_sub_elem() const override
dof_id_type node_id(const unsigned int i) const
Definition: elem.h:2475

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

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

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

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

◆ contains_point()

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

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

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

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

Definition at line 2751 of file elem.C.

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

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

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

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

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

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

◆ contract()

void libMesh::Elem::contract ( )
inherited

Contract an active element, i.e.

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

Definition at line 228 of file elem_refinement.C.

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

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

◆ debug_buffer()

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

Print our buffer for debugging.

Definition at line 660 of file dof_object.C.

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

661 {
662  libMesh::out << " [ ";
663  for (const auto & idx : _idx_buf)
664  libMesh::out << idx << " ";
665  libMesh::out << "]\n";
666 }
OStreamProxy out
index_buffer_t _idx_buf
Definition: dof_object.h:680
unsigned int idx(const ElemType type, const unsigned int nx, const unsigned int i, const unsigned int j)
A useful inline function which replaces the macros used previously.

◆ default_order()

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

Implements libMesh::Elem.

Definition at line 79 of file edge_inf_edge2.C.

References libMesh::FIRST.

80 {
81  return FIRST;
82 }

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

References libMesh::Elem::default_order().

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

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

◆ dim()

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

Implements libMesh::Elem.

Definition at line 73 of file edge.h.

73 { return 1; }

◆ disable_print_counter_info() [1/2]

void libMesh::ReferenceCounter::disable_print_counter_info ( )
staticinherited

Definition at line 100 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

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

◆ disable_print_counter_info() [2/2]

void libMesh::ReferenceCounter::disable_print_counter_info ( )
staticinherited

Definition at line 100 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

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

◆ disconnected_clone()

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

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

Reimplemented in libMesh::C0Polyhedron.

Definition at line 412 of file elem.C.

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

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

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

◆ dof_number() [1/2]

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

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

Definition at line 1032 of file dof_object.h.

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

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

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

◆ dof_number() [2/2]

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

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

Definition at line 1053 of file dof_object.h.

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

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

◆ edge_index_range()

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

Definition at line 2692 of file elem.h.

References libMesh::Elem::n_edges().

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

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

◆ edges_adjacent_to_node()

virtual std::vector<unsigned int> libMesh::Edge::edges_adjacent_to_node ( const unsigned int  ) const
inlinefinaloverridevirtualinherited

1D elements don't have any edges, but they are themselves edges, so I guess an argument could be made for returning "this" somehow.

Since I don't know exactly how that should be done, return an empty vector for now.

Implements libMesh::Elem.

Definition at line 215 of file edge.h.

216  { return {}; }

◆ embedding_matrix()

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

Matrix used to create the elements children.

Implements libMesh::Elem.

Definition at line 175 of file edge_inf_edge2.h.

178  { libmesh_not_implemented(); return 0.; }

◆ embedding_matrix_version()

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

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

Reimplemented in libMesh::Tet.

Definition at line 2051 of file elem.h.

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

2051 { return 0; }

◆ enable_print_counter_info() [1/2]

void libMesh::ReferenceCounter::enable_print_counter_info ( )
staticinherited

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

Definition at line 94 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

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

◆ enable_print_counter_info() [2/2]

void libMesh::ReferenceCounter::enable_print_counter_info ( )
staticinherited

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

Definition at line 94 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

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

◆ face_index_range()

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

Definition at line 2701 of file elem.h.

References libMesh::Elem::n_faces().

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

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

◆ family_tree() [1/2]

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

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

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

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

Definition at line 2101 of file elem.C.

References libMesh::ElemInternal::family_tree().

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

◆ family_tree() [2/2]

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

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

Definition at line 2109 of file elem.C.

References libMesh::ElemInternal::family_tree().

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

◆ family_tree_by_neighbor() [1/2]

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

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

Definition at line 2185 of file elem.C.

References libMesh::ElemInternal::family_tree_by_neighbor().

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

◆ family_tree_by_neighbor() [2/2]

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

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

Definition at line 2194 of file elem.C.

References libMesh::ElemInternal::family_tree_by_neighbor().

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

◆ family_tree_by_side() [1/2]

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

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

Definition at line 2149 of file elem.C.

References libMesh::ElemInternal::family_tree_by_side().

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

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

◆ family_tree_by_side() [2/2]

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

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

Definition at line 2158 of file elem.C.

References libMesh::ElemInternal::family_tree_by_side().

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

◆ family_tree_by_subneighbor() [1/2]

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

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

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

Definition at line 2221 of file elem.C.

References libMesh::ElemInternal::family_tree_by_subneighbor().

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

◆ family_tree_by_subneighbor() [2/2]

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

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

Definition at line 2231 of file elem.C.

References libMesh::ElemInternal::family_tree_by_subneighbor().

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

◆ find_edge_neighbors() [1/2]

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

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

Definition at line 1083 of file elem.C.

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

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

1086 {
1087  // Simple but perhaps suboptimal code: find elements containing the
1088  // first point, then winnow this set down by removing elements which
1089  // don't also contain the second point
1090 
1091  libmesh_assert(this->contains_point(p2));
1092  this->find_point_neighbors(p1, neighbor_set);
1093 
1094  std::set<const Elem *>::iterator it = neighbor_set.begin();
1095  const std::set<const Elem *>::iterator end = neighbor_set.end();
1096 
1097  while (it != end)
1098  {
1099  // As of C++11, set::erase returns an iterator to the element
1100  // following the erased element, or end.
1101  if (!(*it)->contains_point(p2))
1102  it = neighbor_set.erase(it);
1103  else
1104  ++it;
1105  }
1106 }
virtual bool contains_point(const Point &p, Real tol=TOLERANCE) const
Definition: elem.C:2751
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:993
libmesh_assert(ctx)

◆ find_edge_neighbors() [2/2]

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

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

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

Definition at line 1110 of file elem.C.

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

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

◆ find_interior_neighbors() [1/2]

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

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

Definition at line 1172 of file elem.C.

References libMesh::ElemInternal::find_interior_neighbors().

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

◆ find_interior_neighbors() [2/2]

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

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

Definition at line 1179 of file elem.C.

References libMesh::ElemInternal::find_interior_neighbors().

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

◆ find_point_neighbors() [1/4]

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

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

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

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

Definition at line 993 of file elem.C.

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

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

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

◆ find_point_neighbors() [2/4]

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

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

Definition at line 1060 of file elem.C.

References libMesh::Elem::find_point_neighbors().

1061 {
1062  this->find_point_neighbors(neighbor_set, this);
1063 }
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:993

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

References libMesh::ElemInternal::find_point_neighbors().

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

◆ find_point_neighbors() [4/4]

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

Non-const version of function above.

Fills a set of non-const Elem pointers.

Definition at line 1075 of file elem.C.

References libMesh::ElemInternal::find_point_neighbors().

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

◆ first_order_equivalent_type()

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

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

Definition at line 3066 of file elem.C.

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

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

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

◆ flip()

virtual void libMesh::InfEdge2::flip ( BoundaryInfo )
inlinefinaloverridevirtual

No such thing as a misoriented InfEdge.

Implements libMesh::Elem.

Definition at line 137 of file edge_inf_edge2.h.

137 {};

◆ get_extra_datum()

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

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

Definition at line 1146 of file dof_object.h.

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

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

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

◆ get_extra_integer()

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

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

Definition at line 1102 of file dof_object.h.

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

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

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

◆ get_info() [1/3]

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

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

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

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

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

◆ get_info() [2/3]

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

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

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

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

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

◆ get_info() [3/3]

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

Prints relevant information about the element to a string.

Definition at line 2923 of file elem.C.

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

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

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

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

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

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

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

◆ get_nodes()

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

Definition at line 2499 of file elem.h.

References libMesh::Elem::_nodes.

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

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

◆ get_old_dof_object() [1/2]

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

◆ get_old_dof_object() [2/2]

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

Definition at line 97 of file dof_object.h.

References libMesh::DofObject::old_dof_object.

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

◆ get_old_dof_object_ref() [1/2]

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

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

Definition at line 104 of file dof_object.h.

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

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

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

◆ get_old_dof_object_ref() [2/2]

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

Definition at line 110 of file dof_object.h.

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

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

◆ hack_p_level()

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

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

Definition at line 3264 of file elem.h.

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

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

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

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

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

3277 {
3278  _pflag = cast_int<unsigned char>(pflag);
3279  this->hack_p_level(p);
3280 }
unsigned char _pflag
p refinement flag.
Definition: elem.h:2280
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:3264

◆ has_affine_map()

virtual bool libMesh::Elem::has_affine_map ( ) const
inlinevirtualinherited

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

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

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

◆ has_children()

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

◆ has_dofs()

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

Definition at line 1226 of file dof_object.h.

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

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

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

◆ has_extra_integers()

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

◆ has_invertible_map()

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

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

Definition at line 2881 of file elem.C.

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

Referenced by VolumeTest::testEdge4Invertible().

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

◆ has_neighbor()

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

Definition at line 2628 of file elem.h.

References libMesh::Elem::neighbor_ptr_range().

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

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

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

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

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

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

◆ hmax()

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

Definition at line 722 of file elem.C.

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

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

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

◆ hmin()

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

Definition at line 702 of file elem.C.

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

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

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

◆ id()

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

Definition at line 828 of file dof_object.h.

References libMesh::DofObject::_id.

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

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

◆ increment_constructor_count() [1/2]

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

Increments the construction counter.

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

Definition at line 183 of file reference_counter.h.

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

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

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

◆ increment_constructor_count() [2/2]

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

Increments the construction counter.

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

Definition at line 183 of file reference_counter.h.

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

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

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

◆ increment_destructor_count() [1/2]

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

Increments the destruction counter.

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

Definition at line 207 of file reference_counter.h.

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

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

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

◆ increment_destructor_count() [2/2]

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

Increments the destruction counter.

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

Definition at line 207 of file reference_counter.h.

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

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

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

◆ infinite() [1/2]

virtual bool libMesh::InfEdge2::infinite ( ) const
inlineoverridevirtual
Returns
true. This is an infinite element.

Implements libMesh::Elem.

Definition at line 144 of file edge_inf_edge2.h.

144 { return true; }

◆ infinite() [2/2]

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

Definition at line 1918 of file elem.h.

1918 { 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 3339 of file elem.h.

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

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

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

◆ interior_parent() [1/2]

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

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

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

Definition at line 1186 of file elem.C.

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

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

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

◆ interior_parent() [2/2]

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

Definition at line 1231 of file elem.C.

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

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

◆ invalidate()

void libMesh::DofObject::invalidate ( )
inlineinherited

Invalidates all the indices for this DofObject.

Definition at line 788 of file dof_object.h.

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

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

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

◆ invalidate_dofs()

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

Sets all degree of freedom numbers to invalid_id.

Definition at line 751 of file dof_object.h.

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

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

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

◆ invalidate_id()

void libMesh::DofObject::invalidate_id ( )
inlineinherited

Sets the id to invalid_id.

Definition at line 772 of file dof_object.h.

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

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

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

◆ invalidate_processor_id()

void libMesh::DofObject::invalidate_processor_id ( )
inlineinherited

Sets the processor id to invalid_processor_id.

Definition at line 780 of file dof_object.h.

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

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

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

◆ is_ancestor_of()

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

Definition at line 3009 of file elem.h.

References libMesh::Elem::parent().

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

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

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

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

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

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

◆ is_child_on_side()

bool libMesh::Edge::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 117 of file edge.C.

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

119 {
120  libmesh_assert_less (c, this->n_children());
121  libmesh_assert_less (s, this->n_sides());
122 
123  return (c == s);
124 }
virtual unsigned int n_children() const override final
Definition: edge.h:103
virtual unsigned int n_sides() const override final
Definition: edge.h:83

◆ is_edge()

bool libMesh::InfEdge2::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 46 of file edge_inf_edge2.C.

47 {
48  if (i)
49  return true;
50  return false;
51 }

◆ is_edge_on_side()

virtual bool libMesh::Edge::is_edge_on_side ( const unsigned int  ,
const unsigned int   
) const
inlinefinaloverridevirtualinherited
Returns
true if the specified edge is on the specified side.

Implements libMesh::Elem.

Definition at line 114 of file edge.h.

116  { return false; }

◆ is_face()

bool libMesh::InfEdge2::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 53 of file edge_inf_edge2.C.

54 {
55  return false;
56 }

◆ is_flipped()

bool libMesh::Edge::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 173 of file edge.C.

References libMesh::Elem::point().

174 {
175  // Don't trigger on 1D elements embedded in 2D/3D
176  return (
177 #if LIBMESH_DIM > 2
178  !this->point(0)(2) && !this->point(1)(2) &&
179 #endif
180 #if LIBMESH_DIM > 1
181  !this->point(0)(1) && !this->point(1)(1) &&
182 #endif
183  this->point(0)(0) > this->point(1)(0));
184 }
const Point & point(const unsigned int i) const
Definition: elem.h:2453

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

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

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

3567 {
3568  switch (this->dim())
3569  {
3570  case 0:
3571  return false;
3572 
3573  case 1:
3574  return !this->is_vertex(i);
3575 
3576  case 2:
3577  return !this->is_vertex(i) && !this->is_edge(i);
3578 
3579  case 3:
3580  return !this->is_vertex(i) && !this->is_edge(i) && !this->is_face(i);
3581 
3582  default:
3583  libmesh_error_msg("impossible element dimension " << std::to_string(this->dim()));
3584  return 0;
3585  }
3586 }
virtual bool is_face(const unsigned int i) const =0
virtual unsigned short dim() const =0
virtual bool is_vertex(const unsigned int i) const =0
virtual bool is_edge(const unsigned int i) const =0

◆ is_linear()

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

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

Definition at line 1213 of file elem.h.

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

1213 { return false; }

◆ is_mid_infinite_edge_node()

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

Reimplemented from libMesh::Elem.

Definition at line 155 of file edge_inf_edge2.h.

156  { return (i > 0); }

◆ is_node_on_edge()

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

Implements libMesh::Elem.

Definition at line 72 of file edge_inf_edge2.C.

74 {
75  libmesh_assert_equal_to (e, 0);
76  return true;
77 }

◆ is_node_on_side()

bool libMesh::InfEdge2::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 58 of file edge_inf_edge2.C.

60 {
61  libmesh_assert_less (s, 1);
62  return (s == n);
63 }

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

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

604  { return false; }

◆ is_semilocal()

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

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

Definition at line 855 of file elem.C.

References libMesh::Elem::find_point_neighbors().

856 {
857  std::set<const Elem *> point_neighbors;
858 
859  this->find_point_neighbors(point_neighbors);
860 
861  for (const auto & elem : point_neighbors)
862  if (elem->processor_id() == my_pid)
863  return true;
864 
865  return false;
866 }
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:993

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

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

1838 { return false; }

◆ is_vertex()

bool libMesh::InfEdge2::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 39 of file edge_inf_edge2.C.

40 {
41  if (i)
42  return false;
43  return true;
44 }

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

References libMesh::Elem::is_vertex().

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

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

◆ is_vertex_on_parent()

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

Definition at line 3487 of file elem.C.

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

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

3489 {
3490 #ifdef LIBMESH_ENABLE_AMR
3491 
3492  unsigned int my_n_vertices = this->n_vertices();
3493  for (unsigned int n_parent = 0; n_parent != my_n_vertices;
3494  ++n_parent)
3495  if (this->node_ptr(n_parent) == this->child_ptr(c)->node_ptr(n))
3496  return true;
3497  return false;
3498 
3499 #else
3500 
3501  // No AMR?
3502  libmesh_ignore(c,n);
3503  libmesh_error_msg("ERROR: AMR disabled, how did we get here?");
3504  return true;
3505 
3506 #endif
3507 }
void libmesh_ignore(const Args &...)
virtual unsigned int n_vertices() const =0
const Node * node_ptr(const unsigned int i) const
Definition: elem.h:2507
const Elem * child_ptr(unsigned int i) const
Definition: elem.h:3163

◆ key() [1/4]

dof_id_type libMesh::Elem::key
inherited

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

Definition at line 753 of file elem.C.

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

◆ key() [2/4]

virtual dof_id_type libMesh::Elem::key
inherited

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

◆ key() [3/4]

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

Implements libMesh::Elem.

Definition at line 141 of file edge.h.

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

142  { return this->compute_key(this->node_id(s)); }
static dof_id_type compute_key(dof_id_type n0)
Definition: elem.h:3294
dof_id_type node_id(const unsigned int i) const
Definition: elem.h:2475

◆ key() [4/4]

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

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

Definition at line 753 of file elem.C.

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

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

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

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

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

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

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

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

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

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

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

◆ libmesh_assert_valid_neighbors()

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

Checks for consistent neighbor links on this element.

Definition at line 1383 of file elem.C.

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

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

◆ libmesh_assert_valid_node_pointers()

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

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

Definition at line 1371 of file elem.C.

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

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

◆ local_edge_node()

unsigned int libMesh::Edge::local_edge_node ( unsigned int  edge,
unsigned int  edge_node 
) const
finaloverridevirtualinherited

Throws an error.

Edge elems have n_edges() == 0, so it does not make sense to call local_edge_node().

Implements libMesh::Elem.

Definition at line 47 of file edge.C.

49 {
50  libmesh_error_msg("Calling Edge::local_edge_node() does not make sense.");
51  return 0;
52 }

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

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

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

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

◆ local_side_node()

unsigned int libMesh::Edge::local_side_node ( unsigned int  side,
unsigned int   
) const
finaloverridevirtualinherited
Returns
side after doing some range checking. side_node is ignored.

Implements libMesh::Elem.

Definition at line 38 of file edge.C.

References libMesh::Edge::n_sides().

40 {
41  libmesh_assert_less (side, this->n_sides());
42  return side;
43 }
virtual unsigned int n_sides() const override final
Definition: edge.h:83

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

References libMesh::invalid_uint.

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

1832  { return 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:310

◆ loose_bounding_box()

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

The base class implementation determines a bounding box for the element nodes, which should be sufficient for first order finite elements. Higher order geometric elements will need to override with an implementation which takes curved elements into account.

Reimplemented in libMesh::Tri6, libMesh::Tri7, libMesh::Quad9, libMesh::Hex8, libMesh::Quad8, libMesh::Prism6, libMesh::Tri3, libMesh::Pyramid5, libMesh::Edge3, libMesh::Quad4, libMesh::Edge4, and libMesh::Cell.

Definition at line 3465 of file elem.C.

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

Referenced by libMesh::MeshBase::get_info(), libMesh::TreeNode< N >::insert(), libMesh::Quad4::loose_bounding_box(), libMesh::Pyramid5::loose_bounding_box(), libMesh::Tri3::loose_bounding_box(), libMesh::Prism6::loose_bounding_box(), and libMesh::Hex8::loose_bounding_box().

3466 {
3467  Point pmin = this->point(0);
3468  Point pmax = pmin;
3469 
3470  unsigned int n_points = this->n_nodes();
3471  for (unsigned int p=0; p != n_points; ++p)
3472  for (unsigned d=0; d<LIBMESH_DIM; ++d)
3473  {
3474  const Point & pt = this->point(p);
3475  if (pmin(d) > pt(d))
3476  pmin(d) = pt(d);
3477 
3478  if (pmax(d) < pt(d))
3479  pmax(d) = pt(d);
3480  }
3481 
3482  return BoundingBox(pmin, pmax);
3483 }
virtual unsigned int n_nodes() const =0
const Point & point(const unsigned int i) const
Definition: elem.h:2453

◆ low_order_key()

virtual dof_id_type libMesh::Edge::low_order_key ( const unsigned int  s) const
inlinefinaloverridevirtualinherited
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 150 of file edge.h.

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

151  { return this->compute_key(this->node_id(s)); }
static dof_id_type compute_key(dof_id_type n0)
Definition: elem.h:3294
dof_id_type node_id(const unsigned int i) const
Definition: elem.h:2475

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

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

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

◆ make_links_to_me_remote()

void libMesh::Elem::make_links_to_me_remote ( )
inherited

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

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

Definition at line 1533 of file elem.C.

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

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

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

◆ mapping_data()

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

◆ mapping_type()

ElemMappingType libMesh::Elem::mapping_type ( ) const
inlineinherited

◆ master_point()

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

Implements libMesh::Elem.

Definition at line 78 of file edge_inf_edge2.h.

References libMesh::Edge::n_nodes().

79  {
80  libmesh_assert_less(i, this->n_nodes());
81  return Point(0,i,0);
82  }
virtual unsigned int n_nodes() const override
Definition: edge.h:78

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

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

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

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

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

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

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

◆ min_p_level_by_neighbor()

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

Definition at line 2323 of file elem.C.

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

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

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

◆ n_children()

virtual unsigned int libMesh::Edge::n_children ( ) const
inlinefinaloverridevirtualinherited
Returns
2.

Implements libMesh::Elem.

Definition at line 103 of file edge.h.

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

103 { return 2; }

◆ n_comp()

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

Definition at line 1002 of file dof_object.h.

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

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

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

◆ n_comp_group()

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

Definition at line 1015 of file dof_object.h.

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

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

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

◆ n_dofs()

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

Definition at line 806 of file dof_object.h.

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

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

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

◆ n_edges()

virtual unsigned int libMesh::Edge::n_edges ( ) const
inlinefinaloverridevirtualinherited
Returns
0. All 1D elements have no edges.

Implements libMesh::Elem.

Definition at line 93 of file edge.h.

93 { return 0; }

◆ n_extra_integers()

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

Returns how many extra integers are associated to the DofObject.

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

Definition at line 1170 of file dof_object.h.

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

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

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

◆ n_faces()

virtual unsigned int libMesh::Edge::n_faces ( ) const
inlinefinaloverridevirtualinherited
Returns
0. All 1D elements have no faces.

Implements libMesh::Elem.

Definition at line 98 of file edge.h.

98 { 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 714 of file elem.h.

References libMesh::Elem::n_sides().

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

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

◆ n_nodes()

virtual unsigned int libMesh::Edge::n_nodes ( ) const
inlineoverridevirtualinherited
Returns
2. Every edge is guaranteed to have at least 2 nodes.

Implements libMesh::Elem.

Reimplemented in libMesh::Edge4, and libMesh::Edge3.

Definition at line 78 of file edge.h.

Referenced by libMesh::Edge2::master_point(), and master_point().

78 { return 2; }

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

References libMesh::Elem::n_nodes().

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

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

◆ n_objects() [1/2]

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

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

Definition at line 85 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects.

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

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

◆ n_objects() [2/2]

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

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

Definition at line 85 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects.

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

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

◆ n_permutations()

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

Returns the number of independent permutations of element nodes - e.g.

a cube can be reoriented to put side 0 where side N is (for 0 <= N < 6) and then rotated in one of four ways, giving 24 possible permutations.

Permutations which change the mapping Jacobian of an element (i.e. flipping the element) are not allowed in this definition.

Implements libMesh::Elem.

Definition at line 229 of file edge.h.

229 { return 0; }

◆ n_pseudo_systems()

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

Definition at line 947 of file dof_object.h.

References libMesh::DofObject::_idx_buf.

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

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

◆ n_second_order_adjacent_vertices()

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

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

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

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

Definition at line 3040 of file elem.C.

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

3041 {
3042  // for linear elements, always return 0
3043  return 0;
3044 }

◆ n_sides()

virtual unsigned int libMesh::Edge::n_sides ( ) const
inlinefinaloverridevirtualinherited

◆ n_sub_elem()

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

Implements libMesh::Elem.

Definition at line 87 of file edge_inf_edge2.h.

Referenced by connectivity().

87 { return 1; }

◆ n_systems()

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

Definition at line 937 of file dof_object.h.

References libMesh::DofObject::_idx_buf.

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

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

◆ n_var_groups()

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

◆ n_vars() [1/2]

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

Definition at line 967 of file dof_object.h.

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

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

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

◆ n_vars() [2/2]

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

Definition at line 984 of file dof_object.h.

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

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

◆ n_vertices()

virtual unsigned int libMesh::Edge::n_vertices ( ) const
inlinefinaloverridevirtualinherited
Returns
2. Every edge has exactly two vertices.

Implements libMesh::Elem.

Definition at line 88 of file edge.h.

88 { return 2; }

◆ neighbor_ptr() [1/2]

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

Definition at line 2598 of file elem.h.

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

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

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

◆ neighbor_ptr() [2/2]

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

Definition at line 2608 of file elem.h.

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

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

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

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

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

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

◆ neighbor_ptr_range() [2/2]

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

Definition at line 3510 of file elem.h.

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

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

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

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

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

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

◆ node_index_range()

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

◆ node_ptr() [1/2]

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

Definition at line 2507 of file elem.h.

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

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

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

◆ node_ptr() [2/2]

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

Definition at line 2518 of file elem.h.

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

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

◆ node_ref() [1/2]

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

◆ node_ref() [2/2]

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

Definition at line 2537 of file elem.h.

References libMesh::Elem::node_ptr().

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

◆ node_ref_range() [1/2]

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

◆ node_ref_range() [2/2]

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

Definition at line 2674 of file elem.h.

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

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

◆ nodes_on_edge()

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

Implements libMesh::Elem.

Definition at line 154 of file edge.C.

References libMesh::Edge::nodes_on_side().

155 {
156  return nodes_on_side(e);
157 }
virtual std::vector< unsigned int > nodes_on_side(const unsigned int s) const override
Definition: edge.C:147

◆ nodes_on_side()

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

Reimplemented from libMesh::Edge.

Definition at line 66 of file edge_inf_edge2.C.

67 {
68  libmesh_assert_less(s, 1);
69  return {s};
70 }

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

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

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

◆ on_boundary()

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

Definition at line 2909 of file elem.h.

References libMesh::Elem::has_neighbor().

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

◆ on_reference_element()

bool libMesh::Edge::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 188 of file edge.C.

190 {
191  return ((p(0) >= -1-eps) && (p(0) <= 1+eps));
192 }

◆ operator=() [1/2]

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

◆ operator=() [2/2]

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

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

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

◆ opposite_node()

unsigned int libMesh::Edge::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 136 of file edge.C.

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

138 {
139  libmesh_assert_less (node_in, 2);
140  libmesh_assert_less (side_in, this->n_sides());
141  libmesh_assert(this->is_node_on_side(node_in, side_in));
142 
143  return 1 - node_in;
144 }
virtual bool is_node_on_side(const unsigned int n, const unsigned int s) const =0
libmesh_assert(ctx)
virtual unsigned int n_sides() const override final
Definition: edge.h:83

◆ opposite_side()

unsigned int libMesh::Edge::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 128 of file edge.C.

129 {
130  libmesh_assert_less (side_in, 2);
131  return 1 - side_in;
132 }

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

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

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

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

◆ origin()

Point libMesh::InfEdge2::origin ( ) const
inlineoverridevirtual
Returns
The origin of this infinite element.

Reimplemented from libMesh::Elem.

Definition at line 192 of file edge_inf_edge2.h.

References libMesh::Elem::point().

193 {
194  return ( this->point(0)*2 - this->point(1) );
195 }
const Point & point(const unsigned int i) const
Definition: elem.h:2453

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

References libMesh::Elem::_p_level.

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

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

◆ p_refinement_flag()

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

◆ pack_indexing()

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

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

Definition at line 642 of file dof_object.C.

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

643 {
644 #ifdef LIBMESH_ENABLE_AMR
645  // We might need to pack old_dof_object too
646  *target++ = (old_dof_object == nullptr) ? 0 : 1;
647 #endif
648 
649  *target++ = _idx_buf.size();
650  std::copy(_idx_buf.begin(), _idx_buf.end(), target);
651 
652 #ifdef LIBMESH_ENABLE_AMR
653  if (old_dof_object)
654  old_dof_object->pack_indexing(target);
655 #endif
656 }
std::unique_ptr< DofObject > old_dof_object
This object on the last mesh.
Definition: dof_object.h:88
index_buffer_t _idx_buf
Definition: dof_object.h:680

◆ packed_indexing_size()

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

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

Definition at line 560 of file dof_object.C.

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

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

561 {
562  return
563  cast_int<unsigned int> (
564 #ifdef LIBMESH_ENABLE_AMR
565  ((old_dof_object == nullptr) ? 0 : old_dof_object->packed_indexing_size()) + 2 +
566 #else
567  1 +
568 #endif
569  _idx_buf.size());
570 }
std::unique_ptr< DofObject > old_dof_object
This object on the last mesh.
Definition: dof_object.h:88
index_buffer_t _idx_buf
Definition: dof_object.h:680

◆ parent() [1/2]

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

Definition at line 3030 of file elem.h.

References libMesh::Elem::_elemlinks.

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

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

◆ parent() [2/2]

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

Definition at line 3038 of file elem.h.

References libMesh::Elem::_elemlinks.

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

◆ parent_bracketing_nodes()

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

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

Definition at line 2454 of file elem.C.

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

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

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

◆ permute()

virtual void libMesh::Edge::permute ( unsigned  perm_num)
inlinefinaloverridevirtualinherited

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 231 of file edge.h.

231 { libmesh_error(); }

◆ point() [1/2]

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

Definition at line 2453 of file elem.h.

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

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

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

◆ point() [2/2]

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

Definition at line 2465 of file elem.h.

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

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

◆ positive_edge_orientation()

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

Definition at line 3589 of file elem.C.

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

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

3590 {
3591  libmesh_assert_less (i, this->n_edges());
3592 
3593  return this->point(this->local_edge_node(i, 0)) >
3594  this->point(this->local_edge_node(i, 1));
3595 }
virtual unsigned int local_edge_node(unsigned int edge, unsigned int edge_node) const =0
Similar to Elem::local_side_node(), but instead of a side id, takes an edge id and a node id on that ...
virtual unsigned int n_edges() const =0
const Point & point(const unsigned int i) const
Definition: elem.h:2453

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

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

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

3599 {
3600  libmesh_assert_less (i, this->n_faces());
3601 
3602  // Get the number of vertices N of face i. Note that for 3d elements, i.e.
3603  // elements for which this->n_faces() > 0, the number of vertices on any of
3604  // its sides (or faces) is just the number of that face's sides (or edges).
3605  auto side_i = this->side_ptr(i);
3606  const unsigned int N = side_i->n_sides();
3607 
3608  const std::vector<unsigned int> nodes = this->nodes_on_side(i);
3609 
3610  auto cmp = [&](const unsigned int & m, const unsigned int & n) -> bool
3611  { return this->point(m) < this->point(n); };
3612 
3613  const unsigned int V = std::distance(nodes.begin(),
3614  std::min_element(nodes.begin(), nodes.begin() + N, cmp));
3615 
3616  return cmp(nodes[(V + N - 1) % N], nodes[(V + 1) % N]);
3617 }
Real distance(const Point &p)
virtual std::unique_ptr< Elem > side_ptr(unsigned int i)=0
virtual unsigned int n_faces() const =0
const Point & point(const unsigned int i) const
Definition: elem.h:2453
virtual std::vector< unsigned int > nodes_on_side(const unsigned int) const =0

◆ print_dof_info()

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

Print out info for debugging.

Definition at line 670 of file dof_object.C.

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

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

◆ print_info() [1/3]

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

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

Definition at line 81 of file reference_counter.C.

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

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

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

◆ print_info() [2/3]

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

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

Definition at line 81 of file reference_counter.C.

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

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

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

◆ print_info() [3/3]

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

Prints relevant information about the element.

Definition at line 2915 of file elem.C.

References libMesh::Elem::get_info().

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

2916 {
2917  os << this->get_info()
2918  << std::endl;
2919 }
std::string get_info() const
Prints relevant information about the element to a string.
Definition: elem.C:2923

◆ processor_id() [1/3]

processor_id_type libMesh::DofObject::processor_id ( ) const
inlineinherited
Returns
The processor that this DofObject belongs to.

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

Definition at line 905 of file dof_object.h.

References libMesh::DofObject::_processor_id.

Referenced by NonManifoldTestPartitioner::_do_partition(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::DistributedMesh::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::DistributedMesh::add_node(), libMesh::MeshRefinement::add_node(), libMesh::ReplicatedMesh::add_point(), libMesh::DistributedMesh::add_point(), libMesh::RBConstruction::add_scaled_matrix_and_vector(), libMesh::MeshTools::Modification::all_tri(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::Patch::build_around_element(), libMesh::Partitioner::build_graph(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::MeshFunction::check_found_elem(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubProjector::construct_projection(), libMesh::MeshBase::copy_constraint_rows(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::DistributedMesh::delete_elem(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::Elem::Elem(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::find_dofs_to_send(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::MeshTools::Modification::flatten(), libMesh::Node::get_info(), libMesh::Elem::get_info(), libMesh::Elem::inherit_data_from(), libMesh::RBEIMConstruction::initialize_qp_data(), libMesh::DistributedMesh::insert_elem(), libMesh::DofObject::invalidate_processor_id(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_amr_elem_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DofMap::local_variable_indices(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshCommunication::make_new_node_proc_ids_parallel_consistent(), AugmentSparsityOnInterface::mesh_reinit(), ExodusTest< elem_type >::meshes_equal_enough(), libMesh::PeriodicBoundaries::neighbor(), libMesh::RBEIMEvaluation::node_distribute_bfs(), OverlappingCouplingFunctor::operator()(), AugmentSparsityOnInterface::operator()(), AugmentSparsityOnNodes::operator()(), libMesh::GhostPointNeighbors::operator()(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SortAndCopy::operator()(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectVertices::operator()(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectEdges::operator()(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectSides::operator()(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectInteriors::operator()(), libMesh::CompareDofObjectsByPIDAndThenID::operator()(), libMesh::DistributedMesh::own_node(), libMesh::XdrIO::pack_element(), libMesh::LinearPartitioner::partition_range(), libMesh::SFCPartitioner::partition_range(), libMesh::CentroidPartitioner::partition_range(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::Polygon::Polygon(), libMesh::Polyhedron::Polyhedron(), libMesh::DofMap::process_mesh_constraint_rows(), libMesh::DofObject::processor_id(), libMesh::CheckpointIO::read_connectivity(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::DistributedMesh::renumber_nodes_and_elements(), libMesh::DofMap::scatter_constraints(), libMesh::Partitioner::set_interface_node_processor_ids_BFS(), libMesh::Partitioner::set_interface_node_processor_ids_linear(), libMesh::Partitioner::set_interface_node_processor_ids_petscpartitioner(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Partitioner::set_parent_processor_ids(), ParsedFEMFunctionTest::setUp(), libMesh::Partitioner::single_partition_range(), libMesh::Parallel::sync_dofobject_data_by_id(), libMesh::Parallel::sync_element_data_by_parent_id(), libMesh::Parallel::sync_node_data_by_element_id_once(), DefaultCouplingTest::testCoupling(), PointNeighborCouplingTest::testCoupling(), DofObjectTest< Node >::testInvalidateProcId(), EquationSystemsTest::testPostInitAddElem(), DofObjectTest< Node >::testSetProcId(), BoundaryInfoTest::testShellFaceConstraints(), DofObjectTest< Node >::testValidProcId(), libMesh::DTKAdapter::update_variable_values(), NonManifoldGhostingFunctorTest::verify_send_list_entries_helper(), libMesh::GmshIO::write_mesh(), and libMesh::Nemesis_IO_Helper::write_sidesets().

906 {
907  return _processor_id;
908 }
processor_id_type _processor_id
The processor_id of the DofObject.
Definition: dof_object.h:594

◆ processor_id() [2/3]

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

Definition at line 913 of file dof_object.h.

References libMesh::DofObject::_processor_id.

914 {
915  return _processor_id;
916 }
processor_id_type _processor_id
The processor_id of the DofObject.
Definition: dof_object.h:594

◆ processor_id() [3/3]

void libMesh::DofObject::processor_id ( const processor_id_type  pid)
inlineinherited

Sets the processor_id for this DofObject.

Definition at line 921 of file dof_object.h.

References libMesh::DofObject::processor_id().

922 {
923  this->processor_id() = pid;
924 }
processor_id_type processor_id() const
Definition: dof_object.h:905

◆ qual_bounds()

virtual std::pair<Real,Real> libMesh::Elem::qual_bounds ( const ElemQuality  ) const
inlinevirtualinherited
Returns
The suggested quality bounds for the Elem based on quality measure q.

These are the values suggested by the CUBIT User's Manual. Since this function can have no possible meaning for an abstract Elem, it is an error in the base class.

Reimplemented in libMesh::InfQuad, libMesh::Polyhedron, libMesh::InfHex, libMesh::Quad, libMesh::Tri, libMesh::Polygon, libMesh::Hex, and libMesh::Tet.

Definition at line 1120 of file elem.h.

Referenced by main().

1121  { libmesh_not_implemented(); return std::make_pair(0.,0.); }

◆ quality()

Real libMesh::Elem::quality ( const ElemQuality  q) const
virtualinherited
Returns
A quantitative assessment of element quality based on the quality metric q specified by the user. Not all ElemQuality metrics are supported for all Elem types; consult the Elem::quality() overrides for specific Elem types to determine which quality metrics are supported. The ElemQuality metrics with generic support for all Elems with dimension > 1 are: .) EDGE_LENGTH_RATIO - ratio of maximum to minimum edge (in 2D, side) length, where the min/max is taken over all Elem edges. .) MIN,MAX_ANGLE - The minimum (respectively maximum) angle between all pairs of adjacent Elem edges, in degrees. Note that, in 3D, these are not the dihedral angles (angle between adjacent planar faces of the element), which we plan to add support for in the future. In 2D, we compute the angle between adjacent sides for this metric.

Reimplemented in libMesh::InfQuad, libMesh::InfHex, libMesh::Quad, libMesh::Tri, libMesh::Hex, and libMesh::Tet.

Definition at line 1774 of file elem.C.

References libMesh::cross_norm(), libMesh::Elem::dim(), libMesh::Elem::edge_index_range(), libMesh::EDGE_LENGTH_RATIO, libMesh::Elem::edges_adjacent_to_node(), libMesh::Utility::enum_to_string(), libMesh::err, libMesh::index_range(), libMesh::JACOBIAN, libMesh::Elem::local_edge_node(), libMesh::make_range(), libMesh::MAX_ANGLE, libMesh::MAX_DIHEDRAL_ANGLE, libMesh::MIN_ANGLE, libMesh::MIN_DIHEDRAL_ANGLE, libMesh::Elem::n_edges(), libMesh::Elem::node_index_range(), libMesh::Elem::nodes_on_side(), libMesh::TensorTools::norm(), libMesh::pi, libMesh::Elem::point(), libMesh::Real, libMesh::SCALED_JACOBIAN, libMesh::Elem::sides_on_edge(), libMesh::triple_product(), libMesh::Elem::type(), and libMesh::TypeVector< T >::unit().

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

1775 {
1776  switch (q)
1777  {
1778  // Return the maximum ratio of edge lengths, or zero if that
1779  // maximum would otherwise be infinity.
1780  case EDGE_LENGTH_RATIO:
1781  {
1782  if (this->dim() < 2)
1783  return 1;
1784 
1785  std::vector<Real> edge_lengths(this->n_edges());
1786  for (auto e : index_range(edge_lengths))
1787  edge_lengths[e] = (this->point(this->local_edge_node(e,1)) -
1788  this->point(this->local_edge_node(e,0))).norm();
1789 
1790  auto [min, max] =
1791  std::minmax_element(edge_lengths.begin(), edge_lengths.end());
1792 
1793  if (*min == 0.)
1794  return 0.;
1795  else
1796  return *max / *min;
1797  }
1798 
1799  case MIN_ANGLE:
1800  case MAX_ANGLE:
1801  {
1802  // 1D elements don't have interior angles, so just return some
1803  // dummy value in that case.
1804  if (this->dim() < 2)
1805  return 0.;
1806 
1807  // Initialize return values
1808  Real min_angle = std::numeric_limits<Real>::max();
1809  Real max_angle = -std::numeric_limits<Real>::max();
1810 
1811  for (auto n : this->node_index_range())
1812  {
1813  // Get list of edge ids adjacent to this node.
1814  const auto adjacent_edge_ids = this->edges_adjacent_to_node(n);
1815 
1816  // Skip any nodes with fewer than 2 adjacent edges. You
1817  // need at least two adjacent edges to form an interior
1818  // element angle.
1819  auto N = adjacent_edge_ids.size();
1820  if (N < 2)
1821  continue;
1822 
1823  // Consider all possible pairs of edges adjacent to node n
1824  for (unsigned int first = 0; first < N-1; ++first)
1825  for (unsigned int second = first+1; second < N; ++second)
1826  {
1827  // Get ids of first and second edges
1828  auto first_edge = adjacent_edge_ids[first];
1829  auto second_edge = adjacent_edge_ids[second];
1830 
1831  // Get node ids of first and second edge
1832  auto first_edge_node_0 = this->local_edge_node(first_edge, 0);
1833  auto first_edge_node_1 = this->local_edge_node(first_edge, 1);
1834  auto second_edge_node_0 = this->local_edge_node(second_edge, 0);
1835  auto second_edge_node_1 = this->local_edge_node(second_edge, 1);
1836 
1837  // Orient both edges so that edge node 0 == n
1838  if (first_edge_node_0 != n)
1839  std::swap(first_edge_node_0, first_edge_node_1);
1840  if (second_edge_node_0 != n)
1841  std::swap(second_edge_node_0, second_edge_node_1);
1842 
1843  libmesh_assert_equal_to(first_edge_node_0, n);
1844  libmesh_assert_equal_to(second_edge_node_0, n);
1845 
1846  // Locally oriented edge vectors
1847  Point
1848  first_ev = this->point(first_edge_node_1) - this->point(first_edge_node_0),
1849  second_ev = this->point(second_edge_node_1) - this->point(second_edge_node_0);
1850 
1851  // Angle between them in the range [0, pi]
1852  Real theta = std::acos(first_ev.unit() * second_ev.unit());
1853 
1854  // Track min and max angles seen
1855  min_angle = std::min(theta, min_angle);
1856  max_angle = std::max(theta, max_angle);
1857  }
1858  }
1859 
1860  // Return requested extreme value (in degrees)
1861  return Real(180)/libMesh::pi * ((q == MIN_ANGLE) ? min_angle : max_angle);
1862  }
1863 
1864  case MIN_DIHEDRAL_ANGLE:
1865  case MAX_DIHEDRAL_ANGLE:
1866  {
1867  // For 1D and 2D elements, just call this function with MIN,MAX_ANGLE instead.
1868  if (this->dim() < 3)
1869  return this->quality((q == MIN_DIHEDRAL_ANGLE) ? MIN_ANGLE : MAX_ANGLE);
1870 
1871  // Initialize return values
1872  Real min_angle = std::numeric_limits<Real>::max();
1873  Real max_angle = -std::numeric_limits<Real>::max();
1874 
1875  // Algorithm for computing dihedral angles:
1876  // .) Loop over the edges, use the edge_sides_map to get the
1877  // two sides adjacent to the edge.
1878  // .) For each adjacent side, use the side_nodes_map to get the
1879  // list of three (or more) node ids on that side.
1880  // .) Use the node ids to compute the (approximate) inward
1881  // normal for the side. Note: this is approximate since 3D
1882  // elements with four-sided faces and quadratic tetrahedra
1883  // do not necessarily have planar faces.
1884  // .) Compute the dihedral angle for the current edge, compare
1885  // it to the current min and max dihedral angles.
1886  for (auto e : this->edge_index_range())
1887  {
1888  // Get list of edge ids adjacent to this node.
1889  const auto adjacent_side_ids = this->sides_on_edge(e);
1890 
1891  // All 3D elements should have exactly two sides adjacent to each edge.
1892  libmesh_assert_equal_to(adjacent_side_ids.size(), 2);
1893 
1894  // Get lists of node ids on each side
1895  const auto side_0_node_ids = this->nodes_on_side(adjacent_side_ids[0]);
1896  const auto side_1_node_ids = this->nodes_on_side(adjacent_side_ids[1]);
1897 
1898  // All 3D elements have at least three nodes on each side
1899  libmesh_assert_greater_equal(side_0_node_ids.size(), 3);
1900  libmesh_assert_greater_equal(side_1_node_ids.size(), 3);
1901 
1902  // Construct (approximate) inward normal on each adjacent side
1903  const auto side_0_normal =
1904  (this->point(side_0_node_ids[2]) - this->point(side_0_node_ids[0])).cross
1905  (this->point(side_0_node_ids[1]) - this->point(side_0_node_ids[0])).unit();
1906  const auto side_1_normal =
1907  (this->point(side_1_node_ids[2]) - this->point(side_1_node_ids[0])).cross
1908  (this->point(side_1_node_ids[1]) - this->point(side_1_node_ids[0])).unit();
1909 
1910  // Compute dihedral angle between the planes.
1911  // Using the absolute value ensures that we get the same result
1912  // even if the orientation of one of the planes is flipped, i.e.
1913  // it always gives us a value in the range [0, pi/2].
1914  // https://en.wikipedia.org/wiki/Dihedral_angle
1915  Real theta = std::acos(std::abs(side_0_normal * side_1_normal));
1916 
1917  // Track min and max angles seen
1918  min_angle = std::min(theta, min_angle);
1919  max_angle = std::max(theta, max_angle);
1920  }
1921 
1922  // Return requested extreme value (in degrees)
1923  return Real(180)/libMesh::pi * ((q == MIN_DIHEDRAL_ANGLE) ? min_angle : max_angle);
1924  }
1925 
1926  case JACOBIAN:
1927  case SCALED_JACOBIAN:
1928  {
1929  // 1D elements don't have interior corners, so this metric
1930  // does not really apply to them.
1931  const auto N = this->dim();
1932  if (N < 2)
1933  return 1.;
1934 
1935  // Initialize return value
1936  Real min_node_area = std::numeric_limits<Real>::max();
1937 
1938  for (auto n : this->node_index_range())
1939  {
1940  // Get list of edge ids adjacent to this node.
1941  auto adjacent_edge_ids = this->edges_adjacent_to_node(n);
1942 
1943  // Skip any nodes that don't have dim() adjacent edges. In 2D,
1944  // you need at least two adjacent edges to compute the cross
1945  // product, and in 3D, you need at least three adjacent edges
1946  // to compute the scalar triple product. The only element
1947  // type which has an unusual topology in this regard is the
1948  // Pyramid element in 3D, where 4 edges meet at the apex node.
1949  // For now, we just skip this node when computing the JACOBIAN
1950  // metric for Pyramids.
1951  if (adjacent_edge_ids.size() != N)
1952  continue;
1953 
1954  // Construct oriented edges
1955  std::vector<Point> oriented_edges(N);
1956  for (auto i : make_range(N))
1957  {
1958  auto node_0 = this->local_edge_node(adjacent_edge_ids[i], 0);
1959  auto node_1 = this->local_edge_node(adjacent_edge_ids[i], 1);
1960  if (node_0 != n)
1961  std::swap(node_0, node_1);
1962  oriented_edges[i] = this->point(node_1) - this->point(node_0);
1963  }
1964 
1965  // Compute unscaled area (2D) or volume (3D) using the
1966  // cross product (2D) or scalar triple product (3D) of the
1967  // oriented edges. We take the absolute value so that we
1968  // don't have to worry about the sign of the area.
1969  Real node_area = (N == 2) ?
1970  cross_norm(oriented_edges[0], oriented_edges[1]) :
1971  std::abs(triple_product(oriented_edges[0], oriented_edges[1], oriented_edges[2]));
1972 
1973  // Divide by (non-zero) edge lengths if computing scaled Jacobian.
1974  // If any length is zero, then set node_area to zero. This means that
1975  // e.g. degenerate quadrilaterals will have a zero SCALED_JACOBIAN metric.
1976  if (q == SCALED_JACOBIAN)
1977  for (auto i : make_range(N))
1978  {
1979  Real len_i = oriented_edges[i].norm();
1980  node_area = (len_i == 0.) ? 0. : (node_area / len_i);
1981  }
1982 
1983  // Update minimum
1984  min_node_area = std::min(node_area, min_node_area);
1985  }
1986 
1987  return min_node_area;
1988  }
1989 
1990  // Return 1 if we made it here
1991  default:
1992  {
1993  libmesh_do_once( libmesh_here();
1994 
1995  libMesh::err << "ERROR: quality metric "
1997  << " not implemented on element type "
1998  << Utility::enum_to_string(this->type())
1999  << std::endl
2000  << "Returning 1."
2001  << std::endl; );
2002 
2003  return 1.;
2004  }
2005  }
2006 }
OStreamProxy err
virtual std::vector< unsigned int > sides_on_edge(const unsigned int) const =0
T cross_norm(const TypeVector< T > &b, const TypeVector< T > &c)
Calls cross_norm_sq() and takes the square root of the result.
Definition: type_vector.h:1096
IntRange< unsigned short > edge_index_range() const
Definition: elem.h:2692
T triple_product(const TypeVector< T > &a, const TypeVector< T > &b, const TypeVector< T > &c)
Definition: type_vector.h:1029
virtual std::vector< unsigned int > edges_adjacent_to_node(const unsigned int) const =0
virtual unsigned int local_edge_node(unsigned int edge, unsigned int edge_node) const =0
Similar to Elem::local_side_node(), but instead of a side id, takes an edge id and a node id on that ...
virtual unsigned int n_edges() const =0
auto norm(const T &a) -> decltype(std::abs(a))
Definition: tensor_tools.h:74
std::string enum_to_string(const T e)
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
virtual unsigned short dim() const =0
virtual Real quality(const ElemQuality q) const
Definition: elem.C:1774
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140
IntRange< unsigned short > node_index_range() const
Definition: elem.h:2683
virtual ElemType type() const =0
const Point & point(const unsigned int i) const
Definition: elem.h:2453
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:117
virtual std::vector< unsigned int > nodes_on_side(const unsigned int) const =0
const Real pi
.
Definition: libmesh.h:299

◆ quasicircumcenter()

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

Currently ignores curvature of element edges, which makes this trivial in 1D.

Reimplemented from libMesh::Elem.

Definition at line 225 of file edge.h.

References libMesh::Elem::point().

226  { return (this->point(0) + this->point(1)) / 2; }
const Point & point(const unsigned int i) const
Definition: elem.h:2453

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

References libMesh::Elem::_children.

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

3155 {
3156  if (!_children)
3157  return nullptr;
3158 
3159  return _children[i];
3160 }
std::unique_ptr< Elem *[]> _children
unique_ptr to array of this element&#39;s children.
Definition: elem.h:2261

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

References libMesh::ReferenceElem::get(), and libMesh::Elem::type().

Referenced by libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors(), libMesh::QComposite< QSubCell >::init(), and libMesh::RBParametrizedFunction::preevaluate_parametrized_function_on_mesh().

571 {
572  return &(ReferenceElem::get(this->type()));
573 }
virtual ElemType type() const =0
const Elem & get(const ElemType type_in)

◆ refine()

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

Refine the element.

Definition at line 87 of file elem_refinement.C.

References libMesh::Elem::_children, libMesh::Elem::active(), libMesh::MeshRefinement::add_elem(), libMesh::MeshRefinement::add_node(), libMesh::Elem::ancestor(), libMesh::Elem::build(), libMesh::Elem::child_ptr(), libMesh::Elem::INACTIVE, libMesh::Elem::JUST_REFINED, libMesh::libmesh_assert(), libMesh::Elem::n_children(), libMesh::DofObject::n_extra_integers(), libMesh::DofObject::n_systems(), libMesh::Elem::p_level(), libMesh::Elem::p_refinement_flag(), libMesh::Elem::parent(), libMesh::Elem::REFINE, libMesh::Elem::refinement_flag(), libMesh::remote_elem, libMesh::DofObject::set_extra_integer(), libMesh::DofObject::set_n_systems(), libMesh::Elem::set_p_level(), libMesh::Elem::set_p_refinement_flag(), libMesh::Elem::set_refinement_flag(), libMesh::Elem::subactive(), and libMesh::Elem::type().

88 {
89  libmesh_assert_equal_to (this->refinement_flag(), Elem::REFINE);
90  libmesh_assert (this->active());
91 
92  const unsigned int nc = this->n_children();
93 
94  // Create my children if necessary
95  if (!_children)
96  {
97  _children = std::make_unique<Elem *[]>(nc);
98 
99  unsigned int parent_p_level = this->p_level();
100  const unsigned int nei = this->n_extra_integers();
101  for (unsigned int c = 0; c != nc; c++)
102  {
103  auto current_child = Elem::build(this->type(), this);
104  _children[c] = current_child.get();
105 
106  current_child->set_refinement_flag(Elem::JUST_REFINED);
107  current_child->set_p_level(parent_p_level);
108  current_child->set_p_refinement_flag(this->p_refinement_flag());
109 
110  for (auto cnode : current_child->node_index_range())
111  {
112  Node * node =
113  mesh_refinement.add_node(*this, c, cnode,
114  current_child->processor_id());
115  node->set_n_systems (this->n_systems());
116  current_child->set_node(cnode, node);
117  }
118 
119  Elem * added_child = mesh_refinement.add_elem (std::move(current_child));
120  added_child->set_n_systems(this->n_systems());
121  libmesh_assert_equal_to (added_child->n_extra_integers(),
122  this->n_extra_integers());
123  for (unsigned int i=0; i != nei; ++i)
124  added_child->set_extra_integer(i, this->get_extra_integer(i));
125  }
126  }
127  else
128  {
129  unsigned int parent_p_level = this->p_level();
130  for (unsigned int c = 0; c != nc; c++)
131  {
132  Elem * current_child = this->child_ptr(c);
133  if (current_child != remote_elem)
134  {
135  libmesh_assert(current_child->subactive());
136  current_child->set_refinement_flag(Elem::JUST_REFINED);
137  current_child->set_p_level(parent_p_level);
138  current_child->set_p_refinement_flag(this->p_refinement_flag());
139  }
140  }
141  }
142 
143  // Un-set my refinement flag now
145 
146  // Leave the p refinement flag set - we will need that later to get
147  // projection operations correct
148  // this->set_p_refinement_flag(Elem::INACTIVE);
149 
150 #ifndef NDEBUG
151  for (unsigned int c = 0; c != nc; c++)
152  if (this->child_ptr(c) != remote_elem)
153  {
154  libmesh_assert_equal_to (this->child_ptr(c)->parent(), this);
155  libmesh_assert(this->child_ptr(c)->active());
156  }
157 #endif
158  libmesh_assert (this->ancestor());
159 }
RefinementState refinement_flag() const
Definition: elem.h:3210
const Elem * parent() const
Definition: elem.h:3030
RefinementState p_refinement_flag() const
Definition: elem.h:3226
void set_refinement_flag(const RefinementState rflag)
Sets the value of the refinement flag for the element.
Definition: elem.h:3218
virtual unsigned int n_children() const =0
unsigned int p_level() const
Definition: elem.h:3108
bool ancestor() const
Definition: elem.C:2010
static std::unique_ptr< Elem > build(const ElemType type, Elem *p=nullptr)
Definition: elem.C:444
unsigned int n_systems() const
Definition: dof_object.h:937
libmesh_assert(ctx)
Elem(const unsigned int n_nodes, const unsigned int n_sides, Elem *parent, Elem **elemlinkdata, Node **nodelinkdata)
Constructor.
Definition: elem.h:2378
unsigned int n_extra_integers() const
Returns how many extra integers are associated to the DofObject.
Definition: dof_object.h:1170
bool active() const
Definition: elem.h:2941
virtual ElemType type() const =0
std::unique_ptr< Elem *[]> _children
unique_ptr to array of this element&#39;s children.
Definition: elem.h:2261
const Elem * child_ptr(unsigned int i) const
Definition: elem.h:3163
const RemoteElem * remote_elem
Definition: remote_elem.C:57

◆ refinement_flag()

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

Definition at line 3210 of file elem.h.

References libMesh::Elem::_rflag.

Referenced by libMesh::Elem::active(), libMesh::BoundaryInfo::add_elements(), libMesh::OldSolutionBase< Output, point_output >::check_old_context(), libMesh::Elem::coarsen(), libMesh::Elem::contract(), libMesh::MeshRefinement::enforce_mismatch_limit_prior_to_refinement(), libMesh::OldSolutionCoefs< Output, point_output >::eval_at_node(), libMesh::OldSolutionValue< Output, point_output >::eval_at_node(), libMesh::OldSolutionCoefs< Output, point_output >::eval_old_dofs(), libMesh::OldSolutionValue< Output, point_output >::eval_old_dofs(), libMesh::Elem::get_info(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_flags(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshRefinement::make_flags_parallel_consistent(), libMesh::Elem::make_links_to_me_local(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectVertices::operator()(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectEdges::operator()(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectSides::operator()(), libMesh::Elem::refine(), EquationSystemsTest::testRefineThenReinitPreserveFlags(), libMesh::BoundaryInfo::transfer_boundary_ids_from_children(), and libMesh::MeshRefinement::uniformly_coarsen().

3211 {
3212  return static_cast<RefinementState>(_rflag);
3213 }
RefinementState
Enumeration of possible element refinement states.
Definition: elem.h:1452
unsigned char _rflag
h refinement flag.
Definition: elem.h:2274

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

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

Referenced by MeshDeletionsTest::testDeleteElem().

1640 {
1641  libmesh_assert_not_equal_to (this, remote_elem);
1642 
1643  // We need to have handled any children first
1644 #ifdef LIBMESH_ENABLE_AMR
1645  libmesh_assert (!this->has_children());
1646 #endif
1647 
1648  // Nullify any neighbor links
1649  for (auto neigh : this->neighbor_ptr_range())
1650  {
1651  if (neigh && neigh != remote_elem)
1652  {
1653  // My neighbor should never be more refined than me; my real
1654  // neighbor would have been its parent in that case.
1655  libmesh_assert_greater_equal (this->level(), neigh->level());
1656 
1657  if (this->level() == neigh->level() &&
1658  neigh->has_neighbor(this))
1659  {
1660 #ifdef LIBMESH_ENABLE_AMR
1661  // My neighbor may have descendants which also consider me a
1662  // neighbor
1663  std::vector<Elem *> family;
1664  neigh->total_family_tree_by_neighbor (family, this);
1665 
1666  for (auto & n : family)
1667  {
1668  libmesh_assert (n);
1669  if (n->is_remote())
1670  continue;
1671  unsigned int my_s = n->which_neighbor_am_i(this);
1672  libmesh_assert_less (my_s, n->n_neighbors());
1673  libmesh_assert_equal_to (n->neighbor_ptr(my_s), this);
1674  n->set_neighbor(my_s, nullptr);
1675  }
1676 #else
1677  unsigned int my_s = neigh->which_neighbor_am_i(this);
1678  libmesh_assert_less (my_s, neigh->n_neighbors());
1679  libmesh_assert_equal_to (neigh->neighbor_ptr(my_s), this);
1680  neigh->set_neighbor(my_s, nullptr);
1681 #endif
1682  }
1683 #ifdef LIBMESH_ENABLE_AMR
1684  // Even if my neighbor doesn't link back to me, it might
1685  // have subactive descendants which do
1686  else if (neigh->has_children())
1687  {
1688  // If my neighbor at the same level doesn't have me as a
1689  // neighbor, I must be subactive
1690  libmesh_assert(this->level() > neigh->level() ||
1691  this->subactive());
1692 
1693  // My neighbor must have some ancestor of mine as a
1694  // neighbor
1695  Elem * my_ancestor = this->parent();
1696  libmesh_assert(my_ancestor);
1697  while (!neigh->has_neighbor(my_ancestor))
1698  {
1699  my_ancestor = my_ancestor->parent();
1700  libmesh_assert(my_ancestor);
1701  }
1702 
1703  // My neighbor may have descendants which consider me a
1704  // neighbor
1705  std::vector<Elem *> family;
1706  neigh->total_family_tree_by_subneighbor (family, my_ancestor, this);
1707 
1708  for (auto & n : family)
1709  {
1710  libmesh_assert (n);
1711  if (n->is_remote())
1712  continue;
1713  unsigned int my_s = n->which_neighbor_am_i(this);
1714  libmesh_assert_less (my_s, n->n_neighbors());
1715  libmesh_assert_equal_to (n->neighbor_ptr(my_s), this);
1716  n->set_neighbor(my_s, nullptr);
1717  }
1718  }
1719 #endif
1720  }
1721  }
1722 
1723 #ifdef LIBMESH_ENABLE_AMR
1724  // We can't currently delete a child with a parent!
1725  libmesh_assert (!this->parent());
1726 #endif
1727 }
const Elem * parent() const
Definition: elem.h:3030
libmesh_assert(ctx)
Elem(const unsigned int n_nodes, const unsigned int n_sides, Elem *parent, Elem **elemlinkdata, Node **nodelinkdata)
Constructor.
Definition: elem.h:2378
unsigned int level() const
Definition: elem.h:3074
bool subactive() const
Definition: elem.h:2959
SimpleRange< NeighborPtrIter > neighbor_ptr_range()
Returns a range with all neighbors of an element, usable in range-based for loops.
Definition: elem.h:3503
bool has_children() const
Definition: elem.h:2979
const RemoteElem * remote_elem
Definition: remote_elem.C:57

◆ replace_child()

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

Replaces the child pointer at the specified index in the child array.

Definition at line 2090 of file elem.C.

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

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

2091 {
2092  libmesh_assert(this->has_children());
2093 
2094  libmesh_assert(this->child_ptr(c));
2095 
2096  this->set_child(c, elem);
2097 }
libmesh_assert(ctx)
void set_child(unsigned int c, Elem *elem)
Sets the pointer to the child for this element.
Definition: elem.h:3182
bool has_children() const
Definition: elem.h:2979
const Elem * child_ptr(unsigned int i) const
Definition: elem.h:3163

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

Referenced by libMesh::FE< Dim, LAGRANGE_VEC >::edge_map(), libMesh::FE< Dim, LAGRANGE_VEC >::edge_reinit(), libMesh::Elem::Elem(), libMesh::QBase::init(), libMesh::FE< Dim, LAGRANGE_VEC >::reinit(), and libMesh::FE< Dim, LAGRANGE_VEC >::side_map().

259 { return false; }

◆ second_order_adjacent_vertex()

unsigned short int libMesh::Elem::second_order_adjacent_vertex ( const unsigned int  n,
const unsigned int  v 
) const
virtualinherited
Returns
The element-local number of the v^{th} vertex that defines the n^{th} second-order node, or 0 for linear elements.
Note
The value is always less than this->n_vertices(), while n has to be greater than or equal to this->n_vertices().

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

Definition at line 3048 of file elem.C.

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

3050 {
3051  // for linear elements, always return 0
3052  return 0;
3053 }

◆ second_order_child_vertex()

std::pair< unsigned short int, unsigned short int > libMesh::Elem::second_order_child_vertex ( const unsigned int  n) const
virtualinherited
Returns
A pair (c,v), where c == child index, and v == element-local index of the \( n^{th} \) second-order node on the parent element. For linear elements, (0,0) is returned.
Note
The return values are always less than this->n_children() and this->child_ptr(c)->n_vertices().
n has to be greater than or equal to this->n_vertices().
On refined second-order elements, the return value will satisfy this->node_ptr(n) == this->child_ptr(c)->node_ptr(v).

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

Definition at line 3058 of file elem.C.

3059 {
3060  // for linear elements, always return 0
3061  return std::pair<unsigned short int, unsigned short int>(0,0);
3062 }

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

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

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

3137 {
3138  switch (et)
3139  {
3140  case NODEELEM:
3141  return NODEELEM;
3142  case EDGE2:
3143  case EDGE3:
3144  {
3145  // full_ordered not relevant
3146  return EDGE3;
3147  }
3148 
3149  case EDGE4:
3150  {
3151  // full_ordered not relevant
3152  return EDGE4;
3153  }
3154 
3155  case TRI3:
3156  case TRI6:
3157  {
3158  // full_ordered not relevant
3159  return TRI6;
3160  }
3161 
3162  case TRI7:
3163  return TRI7;
3164 
3165  // Currently there is no TRISHELL6, so similarly to other types
3166  // where this is the case, we just return the input.
3167  case TRISHELL3:
3168  return TRISHELL3;
3169 
3170  case QUAD4:
3171  case QUAD8:
3172  {
3173  if (full_ordered)
3174  return QUAD9;
3175  else
3176  return QUAD8;
3177  }
3178 
3179  case QUADSHELL4:
3180  case QUADSHELL8:
3181  {
3182  if (full_ordered)
3183  return QUADSHELL9;
3184  else
3185  return QUADSHELL8;
3186  }
3187 
3188  case QUAD9:
3189  {
3190  // full_ordered not relevant
3191  return QUAD9;
3192  }
3193 
3194  case QUADSHELL9:
3195  {
3196  // full_ordered not relevant
3197  return QUADSHELL9;
3198  }
3199 
3200  case TET4:
3201  case TET10:
3202  {
3203  // full_ordered not relevant
3204  return TET10;
3205  }
3206 
3207  case TET14:
3208  return TET14;
3209 
3210  case HEX8:
3211  case HEX20:
3212  {
3213  // see below how this correlates with INFHEX8
3214  if (full_ordered)
3215  return HEX27;
3216  else
3217  return HEX20;
3218  }
3219 
3220  case HEX27:
3221  {
3222  // full_ordered not relevant
3223  return HEX27;
3224  }
3225 
3226  case PRISM6:
3227  case PRISM15:
3228  {
3229  if (full_ordered)
3230  return PRISM18;
3231  else
3232  return PRISM15;
3233  }
3234 
3235  // full_ordered not relevant, already fully second order
3236  case PRISM18:
3237  return PRISM18;
3238  case PRISM20:
3239  return PRISM20;
3240  case PRISM21:
3241  return PRISM21;
3242  case PYRAMID18:
3243  return PYRAMID18;
3244 
3245  case PYRAMID5:
3246  case PYRAMID13:
3247  {
3248  if (full_ordered)
3249  return PYRAMID14;
3250  else
3251  return PYRAMID13;
3252  }
3253 
3254  case PYRAMID14:
3255  {
3256  // full_ordered not relevant
3257  return PYRAMID14;
3258  }
3259 
3260 
3261 
3262 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
3263 
3264  // infinite elements
3265  case INFEDGE2:
3266  {
3267  return INFEDGE2;
3268  }
3269 
3270  case INFQUAD4:
3271  case INFQUAD6:
3272  {
3273  // full_ordered not relevant
3274  return INFQUAD6;
3275  }
3276 
3277  case INFHEX8:
3278  case INFHEX16:
3279  {
3280  /*
3281  * Note that this matches with \p Hex8:
3282  * For full-ordered, \p InfHex18 and \p Hex27
3283  * belong together, and for not full-ordered,
3284  * \p InfHex16 and \p Hex20 belong together.
3285  */
3286  if (full_ordered)
3287  return INFHEX18;
3288  else
3289  return INFHEX16;
3290  }
3291 
3292  case INFHEX18:
3293  {
3294  // full_ordered not relevant
3295  return INFHEX18;
3296  }
3297 
3298  case INFPRISM6:
3299  case INFPRISM12:
3300  {
3301  // full_ordered not relevant
3302  return INFPRISM12;
3303  }
3304 
3305 #endif
3306 
3307 
3308  default:
3309  {
3310  // what did we miss?
3311  libmesh_error_msg("No second order equivalent element type for et = "
3312  << Utility::enum_to_string(et));
3313  }
3314  }
3315 }
std::string enum_to_string(const T e)

◆ set_buffer()

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

Definition at line 717 of file dof_object.h.

References libMesh::DofObject::_idx_buf.

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

718  { _idx_buf = buf; }
index_buffer_t _idx_buf
Definition: dof_object.h:680

◆ set_dof_number()

void libMesh::DofObject::set_dof_number ( const unsigned int  s,
const unsigned int  var,
const unsigned int  comp,
const dof_id_type  dn 
)
inherited

Sets the global degree of freedom number for variable var, component comp for system s associated with this DofObject.

Definition at line 454 of file dof_object.C.

References libMesh::DofObject::_idx_buf, libMesh::DofObject::dof_number(), libMesh::DofObject::invalid_id, libMesh::libmesh_assert(), libMesh::DofObject::n_comp(), libMesh::DofObject::n_comp_group(), libMesh::DofObject::n_systems(), libMesh::DofObject::n_vars(), libMesh::DofObject::start_idx(), libMesh::DofObject::system_var_to_vg_var(), and libMesh::DofObject::var_to_vg().

458 {
459  libmesh_assert_less (s, this->n_systems());
460  libmesh_assert_less (var, this->n_vars(s));
461  libmesh_assert_less (comp, this->n_comp(s,var));
462 
463  const unsigned int
464  vg = this->var_to_vg(s,var),
465 #ifndef NDEBUG
466  ncg = this->n_comp_group(s,vg),
467 #endif
468  vig = this->system_var_to_vg_var(s,vg,var),
469  start_idx_sys = this->start_idx(s);
470 
471  libmesh_assert_less ((start_idx_sys + 2*vg + 1), _idx_buf.size());
472 
473  dof_id_type & base_idx = _idx_buf[start_idx_sys + 2*vg + 1];
474 
475  // We intend to change all dof numbers together or not at all
476  if (comp || vig)
477  libmesh_assert ((dn == invalid_id && base_idx == invalid_id) ||
478  (dn == base_idx + vig*ncg + comp));
479 
480  // only explicitly store the base index for vig==0, comp==0
481  else
482  base_idx = dn;
483 
484  libmesh_assert_equal_to (this->dof_number(s, var, comp), dn);
485 }
unsigned int system_var_to_vg_var(const unsigned int s, const unsigned int vg, const unsigned int var) const
Utility function - for variable var in system s, figure out what variable group it lives in...
Definition: dof_object.h:1359
dof_id_type dof_number(const unsigned int s, const unsigned int var, const unsigned int comp) const
Definition: dof_object.h:1032
unsigned int n_comp(const unsigned int s, const unsigned int var) const
Definition: dof_object.h:1002
unsigned int var_to_vg(const unsigned int s, const unsigned int var) const
Utility function - for variable var in system s, figure out what variable group it lives in...
Definition: dof_object.h:1341
unsigned int n_vars(const unsigned int s, const unsigned int vg) const
Definition: dof_object.h:967
unsigned int n_systems() const
Definition: dof_object.h:937
libmesh_assert(ctx)
static const dof_id_type invalid_id
An invalid id to distinguish an uninitialized DofObject.
Definition: dof_object.h:482
unsigned int start_idx(const unsigned int s) const
The starting index for system s.
Definition: dof_object.h:1249
index_buffer_t _idx_buf
Definition: dof_object.h:680
unsigned int n_comp_group(const unsigned int s, const unsigned int vg) const
Definition: dof_object.h:1015
uint8_t dof_id_type
Definition: id_types.h:67

◆ set_extra_datum()

template<typename T >
void libMesh::DofObject::set_extra_datum ( const unsigned int  index,
const T  value 
)
inlineinherited

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

Definition at line 1126 of file dof_object.h.

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

Referenced by libMesh::ExodusII_IO::read(), libMesh::DynaIO::read_mesh(), and DofObjectTest< Node >::testAddExtraData().

1128 {
1129 #ifndef NDEBUG
1130  const unsigned int n_more_integers = (sizeof(T)-1)/sizeof(dof_id_type);
1131 #endif
1132  libmesh_assert_less(index+n_more_integers, this->n_extra_integers());
1133  libmesh_assert_less(this->n_pseudo_systems(), _idx_buf.size());
1134 
1135  const unsigned int start_idx_i = this->start_idx_ints();
1136 
1137  libmesh_assert_less(start_idx_i+index+n_more_integers, _idx_buf.size());
1138  std::memcpy(&_idx_buf[start_idx_i+index], &value, sizeof(T));
1139 }
unsigned int n_pseudo_systems() const
Definition: dof_object.h:947
unsigned int start_idx_ints() const
The starting index for an extra_integers pseudosystem.
Definition: dof_object.h:1273
static const bool value
Definition: xdr_io.C:54
unsigned int n_extra_integers() const
Returns how many extra integers are associated to the DofObject.
Definition: dof_object.h:1170
index_buffer_t _idx_buf
Definition: dof_object.h:680
uint8_t dof_id_type
Definition: id_types.h:67

◆ set_extra_integer()

void libMesh::DofObject::set_extra_integer ( const unsigned int  index,
const dof_id_type  value 
)
inlineinherited

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

Definition at line 1086 of file dof_object.h.

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

Referenced by libMesh::SyncElementIntegers::act_on_data(), libMesh::BoundaryInfo::add_elements(), libMesh::UnstructuredMesh::all_first_order(), libMesh::UnstructuredMesh::create_submesh(), libMesh::ExodusII_IO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::CheckpointIO::read_nodes(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::Elem::refine(), DofObjectTest< Node >::testAddExtraData(), DofObjectTest< Node >::testAddSystemExtraInts(), DofObjectTest< Node >::testSetNSystemsExtraInts(), and DofObjectTest< Node >::testSetNVariableGroupsExtraInts().

1088 {
1089  libmesh_assert_less(index, this->n_extra_integers());
1090  libmesh_assert_less(this->n_pseudo_systems(), _idx_buf.size());
1091 
1092  const unsigned int start_idx_i = this->start_idx_ints();
1093 
1094  libmesh_assert_less(start_idx_i+index, _idx_buf.size());
1095  _idx_buf[start_idx_i+index] = value;
1096 }
unsigned int n_pseudo_systems() const
Definition: dof_object.h:947
unsigned int start_idx_ints() const
The starting index for an extra_integers pseudosystem.
Definition: dof_object.h:1273
static const bool value
Definition: xdr_io.C:54
unsigned int n_extra_integers() const
Returns how many extra integers are associated to the DofObject.
Definition: dof_object.h:1170
index_buffer_t _idx_buf
Definition: dof_object.h:680

◆ set_id() [1/2]

dof_id_type & libMesh::DofObject::set_id ( )
inlineinherited

◆ set_id() [2/2]

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

Sets the id for this DofObject.

Definition at line 201 of file dof_object.h.

References libMesh::DofObject::set_id().

202  { this->set_id() = dofid; }
dof_id_type & set_id()
Definition: dof_object.h:836

◆ set_interior_parent()

void libMesh::Elem::set_interior_parent ( Elem p)
inherited

Sets the pointer to the element's interior_parent.

Dangerous! Only use this if you know what you are doing!

Definition at line 1248 of file elem.C.

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

Referenced by libMesh::BoundaryInfo::add_elements(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::Edge::Edge(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::Hex::Hex(), libMesh::InfHex::InfHex(), libMesh::InfQuad::InfQuad(), libMesh::NodeElem::NodeElem(), libMesh::Polygon::Polygon(), libMesh::Polyhedron::Polyhedron(), libMesh::Prism::Prism(), libMesh::Pyramid::Pyramid(), libMesh::Quad::Quad(), libMesh::Tet::Tet(), libMesh::Tri::Tri(), and libMesh::MeshTetInterface::volume_to_surface_mesh().

1249 {
1250  // interior parents make no sense for full-dimensional elements.
1251  libmesh_assert (!p ||
1252  this->dim() < LIBMESH_DIM);
1253 
1254  // If we have an interior_parent, we USED TO assume it was a
1255  // one-higher-dimensional interior element, but we now allow e.g.
1256  // edge elements to have a 3D interior_parent with no
1257  // intermediate 2D element.
1258  // libmesh_assert (!p ||
1259  // p->dim() == (this->dim()+1));
1260  libmesh_assert (!p ||
1261  (p == remote_elem) ||
1262  (p->dim() > this->dim()));
1263 
1264  _elemlinks[1+this->n_sides()] = p;
1265 }
Elem ** _elemlinks
Pointers to this element&#39;s parent and neighbors, and for lower-dimensional elements&#39; interior_parent...
Definition: elem.h:2251
libmesh_assert(ctx)
virtual unsigned int n_sides() const =0
virtual unsigned short dim() const =0
const RemoteElem * remote_elem
Definition: remote_elem.C:57

◆ set_mapping_data()

void libMesh::Elem::set_mapping_data ( const unsigned char  data)
inlineinherited

Sets the value of the mapping data for the element.

Definition at line 3144 of file elem.h.

References libMesh::Elem::_map_data.

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

3145 {
3146  _map_data = data;
3147 }
unsigned char _map_data
Mapping function data; currently used when needed to store the RATIONAL_BERNSTEIN nodal weight data i...
Definition: elem.h:2303

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

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

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

3129 {
3130  _map_type = cast_int<unsigned char>(type);
3131 }
unsigned char _map_type
Mapping function type; currently either 0 (LAGRANGE) or 1 (RATIONAL_BERNSTEIN).
Definition: elem.h:2297
virtual ElemType type() const =0

◆ set_n_comp()

void libMesh::DofObject::set_n_comp ( const unsigned int  s,
const unsigned int  var,
const unsigned int  ncomp 
)
inherited

Sets the number of components for Variable var of system s associated with this DofObject.

Definition at line 385 of file dof_object.C.

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

388 {
389  libmesh_assert_less (s, this->n_systems());
390  libmesh_assert_less (var, this->n_vars(s));
391 
392  this->set_n_comp_group(s, this->var_to_vg(s,var), ncomp);
393 }
unsigned int var_to_vg(const unsigned int s, const unsigned int var) const
Utility function - for variable var in system s, figure out what variable group it lives in...
Definition: dof_object.h:1341
unsigned int n_vars(const unsigned int s, const unsigned int vg) const
Definition: dof_object.h:967
unsigned int n_systems() const
Definition: dof_object.h:937
void set_n_comp_group(const unsigned int s, const unsigned int vg, const unsigned int ncomp)
Sets the number of components for VariableGroup vg of system s associated with this DofObject...
Definition: dof_object.C:397

◆ 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 397 of file dof_object.C.

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

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

400 {
401  libmesh_assert_less (s, this->n_systems());
402  libmesh_assert_less (vg, this->n_var_groups(s));
403 
404  // Check for trivial return
405  if (ncomp == this->n_comp_group(s,vg)) return;
406 
407 #ifndef NDEBUG
408  if (ncomp >= ncv_magic)
409  {
410  const index_t ncvm = ncv_magic;
411  libmesh_error_msg("ERROR: ncomp must be less than DofObject::ncv_magic!\n" \
412  << "ncomp = " \
413  << ncomp \
414  << ", ncv_magic = " \
415  << ncvm \
416  << "\nrecompile and try again!");
417  }
418 #endif
419 
420  const unsigned int
421  start_idx_sys = this->start_idx(s),
422  n_vars_group = this->n_vars(s,vg),
423  base_offset = start_idx_sys + 2*vg;
424 
425  libmesh_assert_less ((base_offset + 1), _idx_buf.size());
426 
427  // if (ncomp)
428  // libMesh::out << "s,vg,ncomp="
429  // << s << ","
430  // << vg << ","
431  // << ncomp << '\n';
432 
433  // set the number of components, maintaining the number
434  // of variables in the group
435  _idx_buf[base_offset] = ncv_magic*n_vars_group + ncomp;
436 
437  // We use (invalid_id - 1) to signify no
438  // components for this object
439  _idx_buf[base_offset + 1] = (ncomp == 0) ? invalid_id - 1 : invalid_id;
440 
441  // this->debug_buffer();
442  // libMesh::out << "s,vg = " << s << "," << vg << '\n'
443  // << "base_offset=" << base_offset << '\n'
444  // << "this->n_comp(s,vg)=" << this->n_comp(s,vg) << '\n'
445  // << "this->n_comp_group(s,vg)=" << this->n_comp_group(s,vg) << '\n'
446  // << "this->n_vars(s,vg)=" << this->n_vars(s,vg) << '\n'
447  // << "this->n_var_groups(s)=" << this->n_var_groups(s) << '\n';
448 
449  libmesh_assert_equal_to (ncomp, this->n_comp_group(s,vg));
450 }
unsigned int n_var_groups(const unsigned int s) const
Definition: dof_object.h:957
dof_id_type index_t
DoF index information.
Definition: dof_object.h:678
unsigned int n_vars(const unsigned int s, const unsigned int vg) const
Definition: dof_object.h:967
unsigned int n_systems() const
Definition: dof_object.h:937
static const dof_id_type invalid_id
An invalid id to distinguish an uninitialized DofObject.
Definition: dof_object.h:482
unsigned int start_idx(const unsigned int s) const
The starting index for system s.
Definition: dof_object.h:1249
index_buffer_t _idx_buf
Definition: dof_object.h:680
unsigned int n_comp_group(const unsigned int s, const unsigned int vg) const
Definition: dof_object.h:1015
static const index_t ncv_magic
Above we introduced the chimera ncv, which is a hybrid of the form ncv = ncv_magic*nv + nc where nv a...
Definition: dof_object.h:691

◆ set_n_systems()

void libMesh::DofObject::set_n_systems ( const unsigned int  s)
inherited

Sets the number of systems for this DofObject.

If this number is a change, also clears all variable count and DoF indexing associated with this DofObject.

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

Definition at line 150 of file dof_object.C.

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

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

151 {
152  const unsigned int old_ns = this->n_systems();
153 
154  // Check for trivial return
155  if (ns == old_ns)
156  return;
157 
158  const unsigned int nei = this->n_extra_integers();
159  const dof_id_type header_size = ns + bool(nei);
160  const dof_id_type hdr = nei ?
161  static_cast<dof_id_type>(-static_cast<std::ptrdiff_t>(header_size))
162  : header_size;
163  index_buffer_t new_buf(header_size + nei, hdr);
164  if (nei)
165  {
166  const unsigned int start_idx_ints = old_ns ?
167  cast_int<unsigned int>(_idx_buf[old_ns]) :
168  1;
169  libmesh_assert_less(start_idx_ints, _idx_buf.size());
170  std::copy(_idx_buf.begin()+start_idx_ints,
171  _idx_buf.end(),
172  new_buf.begin()+header_size);
173  if (ns)
174  std::fill(new_buf.begin()+1, new_buf.begin()+ns+1, ns+1);
175  }
176 
177  // vector swap trick to force deallocation when shrinking
178  new_buf.swap(_idx_buf);
179 
180 #ifdef DEBUG
181  libmesh_assert_equal_to(nei, this->n_extra_integers());
182 
183  // check that all systems now exist and that they have 0 size
184  libmesh_assert_equal_to (ns, this->n_systems());
185  for (auto s : make_range(this->n_systems()))
186  {
187  libmesh_assert_equal_to (this->n_vars(s), 0);
188  libmesh_assert_equal_to (this->n_var_groups(s), 0);
189  }
190 #endif
191 }
unsigned int n_var_groups(const unsigned int s) const
Definition: dof_object.h:957
unsigned int start_idx_ints() const
The starting index for an extra_integers pseudosystem.
Definition: dof_object.h:1273
unsigned int n_vars(const unsigned int s, const unsigned int vg) const
Definition: dof_object.h:967
unsigned int n_systems() const
Definition: dof_object.h:937
std::vector< index_t > index_buffer_t
Definition: dof_object.h:679
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140
unsigned int n_extra_integers() const
Returns how many extra integers are associated to the DofObject.
Definition: dof_object.h:1170
index_buffer_t _idx_buf
Definition: dof_object.h:680
uint8_t dof_id_type
Definition: id_types.h:67

◆ set_n_vars_per_group()

void libMesh::DofObject::set_n_vars_per_group ( const unsigned int  s,
const std::vector< unsigned int > &  nvpg 
)
inherited

Sets number of variables in each group associated with system s for this DofObject.

Implicit in this is also setting the number of VariableGroup variable groups for the system. Has the effect of setting the number of components to 0 even when called even with (nvg == this->n_var_groups(s)).

Definition at line 247 of file dof_object.C.

References libMesh::DofObject::_idx_buf, libMesh::DofObject::end_idx(), libMesh::DofObject::get_extra_integer(), libMesh::DofObject::has_extra_integers(), libMesh::DofObject::invalid_id, libMesh::make_range(), libMesh::DofObject::n_comp(), libMesh::DofObject::n_comp_group(), libMesh::DofObject::n_extra_integers(), libMesh::DofObject::n_systems(), libMesh::DofObject::n_var_groups(), libMesh::DofObject::n_vars(), libMesh::DofObject::ncv_magic, libMesh::DofObject::set_n_comp_group(), and libMesh::DofObject::start_idx().

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

249 {
250  const unsigned int n_sys = this->n_systems();
251 
252  libmesh_assert_less (s, n_sys);
253 
254  // number of variable groups for this system - inferred
255  const unsigned int nvg = cast_int<unsigned int>(nvpg.size());
256 
257  // BSK - note that for compatibility with the previous implementation
258  // calling this method when (nvars == this->n_vars()) requires that
259  // we invalidate the DOF indices and set the number of components to 0.
260  // Note this was a bit of a surprise to me - there was no quick return in
261  // the old method, which caused removal and readdition of the DOF indices
262  // even in the case of (nvars == this->n_vars()), resulting in n_comp(s,v)
263  // implicitly becoming 0 regardless of any previous value.
264  // quick return?
265  if (nvg == this->n_var_groups(s))
266  {
267  for (unsigned int vg=0; vg<nvg; vg++)
268  {
269  this->set_n_comp_group(s,vg,0);
270  libmesh_assert_equal_to (this->n_vars(s,vg), nvpg[vg]);
271  }
272  return;
273  }
274 
275  const bool hei = this->has_extra_integers();
276 
277  // since there is ample opportunity to screw up other systems, let us
278  // cache their current sizes and later assert that they are unchanged.
279 #ifdef DEBUG
280  const unsigned int nei = this->n_extra_integers();
281 
282  DofObject::index_buffer_t old_system_sizes, old_extra_integers;
283  old_system_sizes.reserve(n_sys);
284  old_extra_integers.reserve(nei);
285 
286  for (unsigned int s_ctr=0; s_ctr<n_sys; s_ctr++)
287  old_system_sizes.push_back(this->n_var_groups(s_ctr));
288 
289  for (unsigned int ei=0; ei != nei; ++ei)
290  old_extra_integers.push_back(this->get_extra_integer(ei));
291 #endif
292 
293  // remove current indices if we have some
294  if (this->n_var_groups(s) != 0)
295  {
296  const unsigned int old_nvg_s = this->n_var_groups(s);
297 
298  DofObject::index_buffer_t::iterator
299  it = _idx_buf.begin(),
300  end = _idx_buf.begin();
301 
302  std::advance(it, this->start_idx(s));
303  std::advance(end, this->end_idx(s));
304  _idx_buf.erase(it,end);
305 
306  for (unsigned int ctr=(s+1); ctr<n_sys; ctr++)
307  _idx_buf[ctr] -= 2*old_nvg_s;
308 
309  if (hei)
310  _idx_buf[n_sys] -= 2*old_nvg_s;
311  }
312 
313  // better not have any now!
314  libmesh_assert_equal_to (this->n_var_groups(s), 0);
315 
316  // Make sure we didn't screw up any of our sizes!
317 #ifdef DEBUG
318  for (auto s_ctr : make_range(this->n_systems()))
319  if (s_ctr != s)
320  libmesh_assert_equal_to (this->n_var_groups(s_ctr), old_system_sizes[s_ctr]);
321 
322  libmesh_assert_equal_to (nei, this->n_extra_integers());
323 
324  for (unsigned int ei=0; ei != nei; ++ei)
325  libmesh_assert_equal_to(old_extra_integers[ei], this->get_extra_integer(ei));
326 #endif
327 
328  // OK, if the user requested 0 that is what we have
329  if (nvg == 0)
330  return;
331 
332  {
333  // array to hold new indices
334  DofObject::index_buffer_t var_idxs(2*nvg);
335  for (unsigned int vg=0; vg<nvg; vg++)
336  {
337  var_idxs[2*vg ] = ncv_magic*nvpg[vg] + 0;
338  var_idxs[2*vg + 1] = invalid_id - 1;
339  }
340 
341  DofObject::index_buffer_t::iterator it = _idx_buf.begin();
342  std::advance(it, this->end_idx(s));
343  _idx_buf.insert(it, var_idxs.begin(), var_idxs.end());
344 
345  for (unsigned int ctr=(s+1); ctr<n_sys; ctr++)
346  _idx_buf[ctr] += 2*nvg;
347 
348  if (hei)
349  _idx_buf[n_sys] += 2*nvg;
350 
351  // resize _idx_buf to fit so no memory is wasted.
353  }
354 
355  libmesh_assert_equal_to (nvg, this->n_var_groups(s));
356 
357 #ifdef DEBUG
358 
359  libmesh_assert_equal_to (this->n_var_groups(s), nvpg.size());
360 
361  for (auto vg : make_range(this->n_var_groups(s)))
362  {
363  libmesh_assert_equal_to (this->n_vars(s,vg), nvpg[vg]);
364  libmesh_assert_equal_to (this->n_comp_group(s,vg), 0);
365  }
366 
367  for (auto v : make_range(this->n_vars(s)))
368  libmesh_assert_equal_to (this->n_comp(s,v), 0);
369 
370  // again, all other system sizes should be unchanged!
371  for (auto s_ctr : make_range(this->n_systems()))
372  if (s_ctr != s)
373  libmesh_assert_equal_to (this->n_var_groups(s_ctr), old_system_sizes[s_ctr]);
374 
375  // Extra integers count and values should also be unchanged!
376  libmesh_assert_equal_to (nei, this->n_extra_integers());
377 
378  for (unsigned int ei=0; ei != nei; ++ei)
379  libmesh_assert_equal_to(old_extra_integers[ei], this->get_extra_integer(ei));
380 #endif
381 }
unsigned int n_comp(const unsigned int s, const unsigned int var) const
Definition: dof_object.h:1002
unsigned int n_var_groups(const unsigned int s) const
Definition: dof_object.h:957
unsigned int end_idx(const unsigned int s) const
The ending index for system s.
Definition: dof_object.h:1260
unsigned int n_vars(const unsigned int s, const unsigned int vg) const
Definition: dof_object.h:967
unsigned int n_systems() const
Definition: dof_object.h:937
static const dof_id_type invalid_id
An invalid id to distinguish an uninitialized DofObject.
Definition: dof_object.h:482
bool has_extra_integers() const
Returns whether extra integers are associated to the DofObject.
Definition: dof_object.h:1188
std::vector< index_t > index_buffer_t
Definition: dof_object.h:679
void set_n_comp_group(const unsigned int s, const unsigned int vg, const unsigned int ncomp)
Sets the number of components for VariableGroup vg of system s associated with this DofObject...
Definition: dof_object.C:397
unsigned int start_idx(const unsigned int s) const
The starting index for system s.
Definition: dof_object.h:1249
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140
unsigned int n_extra_integers() const
Returns how many extra integers are associated to the DofObject.
Definition: dof_object.h:1170
index_buffer_t _idx_buf
Definition: dof_object.h:680
unsigned int n_comp_group(const unsigned int s, const unsigned int vg) const
Definition: dof_object.h:1015
dof_id_type get_extra_integer(const unsigned int index) const
Gets the value on this object of the extra integer associated with index, which should have been obta...
Definition: dof_object.h:1102
static const index_t ncv_magic
Above we introduced the chimera ncv, which is a hybrid of the form ncv = ncv_magic*nv + nc where nv a...
Definition: dof_object.h:691

◆ set_neighbor()

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

◆ set_node() [1/2]

Node *& libMesh::Elem::set_node ( const unsigned int  i)
inlinevirtualinherited
Returns
The pointer to the Node with local number i as a writable reference.
Deprecated:
This setter cannot update the multiple node pointers used in a general polyhedron; use the set_node overload that takes an argument.

Reimplemented in libMesh::RemoteElem.

Definition at line 2558 of file elem.h.

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

Referenced by LinearElasticityWithContact::add_contact_edge_elements(), add_cube_convex_hull_to_mesh(), libMesh::UnstructuredMesh::all_first_order(), AllSecondOrderTest::allCompleteOrderMixed(), AllSecondOrderTest::allCompleteOrderRange(), AllSecondOrderTest::allSecondOrderMixed(), AllSecondOrderTest::allSecondOrderRange(), libMesh::TetGenMeshInterface::assign_nodes_to_elem(), libMesh::MeshTools::Generation::build_cube(), GetBoundaryPointsTest::build_mesh(), MixedDimensionMeshTest::build_mesh(), MeshfunctionDFEM::build_mesh(), SlitMeshTest::build_mesh(), MixedDimensionNonUniformRefinement::build_mesh(), MixedDimensionNonUniformRefinementTriangle::build_mesh(), MixedDimensionNonUniformRefinement3D::build_mesh(), OverlappingTestBase::build_quad_mesh(), libMesh::TriangleWrapper::copy_tri_to_mesh(), libMesh::UnstructuredMesh::create_submesh(), libMesh::C0Polygon::permute(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::AbaqusIO::read_elements(), libMesh::GmshIO::read_mesh(), libMesh::DynaIO::read_mesh(), libMesh::MatlabIO::read_stream(), libMesh::C0Polyhedron::retriangulate(), libMesh::RemoteElem::set_node(), PerElemTest< elem_type >::setUp(), libMesh::FE< Dim, LAGRANGE_VEC >::shape(), libMesh::Polyhedron::side_clones(), libMesh::UnstructuredMesh::stitching_helper(), libMesh::MeshTools::Generation::surface_octahedron(), libMesh::Elem::swap2nodes(), SystemsTest::testDofCouplingWithVarGroups(), MeshTriangulationTest::testEdgesMesh(), MeshTriangulationTest::testHalfDomain(), NodalNeighborsTest::testOrientation(), MeshTriangulationTest::testPoly2TriBad1DMultiBoundary(), MeshTriangulationTest::testPoly2TriBad2DMultiBoundary(), MeshTriangulationTest::testPoly2TriBadEdges(), EquationSystemsTest::testPostInitAddElem(), SystemsTest::testProjectMatrix3D(), InfFERadialTest::testRefinement(), EquationSystemsTest::testReinitWithNodeElem(), SystemsTest::testSetSystemParameterOverEquationSystem(), BoundaryInfoTest::testShellFaceConstraints(), InfFERadialTest::testSides(), MeshTetTest::testTetsToTets(), MeshSubdomainIDTest::testUnpartitioned(), and libMesh::Poly2TriTriangulator::triangulate_current_points().

2559 {
2560  libmesh_assert_less (i, this->n_nodes());
2561 
2562  libmesh_deprecated();
2563 
2564  return _nodes[i];
2565 }
Node ** _nodes
Pointers to the nodes we are connected to.
Definition: elem.h:2245
virtual unsigned int n_nodes() const =0

◆ set_node() [2/2]

void libMesh::Elem::set_node ( const unsigned int  i,
Node node 
)
inlinevirtualinherited

Sets local Node i to refer to node.

Reimplemented in libMesh::RemoteElem.

Definition at line 2571 of file elem.h.

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

2573 {
2574  libmesh_assert_less (i, this->n_nodes());
2575 
2576  _nodes[i] = node;
2577 }
Node ** _nodes
Pointers to the nodes we are connected to.
Definition: elem.h:2245
virtual unsigned int n_nodes() const =0

◆ set_old_dof_object()

void libMesh::DofObject::set_old_dof_object ( )
inherited

Sets the old_dof_object to a copy of this.

Definition at line 135 of file dof_object.C.

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

136 {
137  this->clear_old_dof_object();
138 
140 
141  // Make a new DofObject, assign a copy of \p this.
142  // Make sure the copy ctor for DofObject works!!
143  this->old_dof_object = this->construct(this);
144 }
std::unique_ptr< DofObject > construct(const DofObject *other=nullptr)
Convenient factory function that calls either the (deep) copy constructor or the default constructor ...
Definition: dof_object.h:741
void clear_old_dof_object()
Sets the old_dof_object to nullptr.
Definition: dof_object.C:128
libmesh_assert(ctx)
std::unique_ptr< DofObject > old_dof_object
This object on the last mesh.
Definition: dof_object.h:88

◆ set_p_level()

void libMesh::Elem::set_p_level ( const unsigned int  p)
inherited

Sets the value of the p-refinement level for the element.

The following functions only apply when AMR is enabled and thus are not present otherwise.

Note
The maximum p-refinement level is currently 255.

Definition at line 41 of file elem_refinement.C.

References libMesh::Elem::_p_level, libMesh::Elem::child_ref_range(), libMesh::Elem::hack_p_level(), libMesh::Elem::JUST_COARSENED, libMesh::Elem::JUST_REFINED, libMesh::Elem::p_level(), libMesh::Elem::parent(), libMesh::Elem::set_p_level(), and libMesh::Elem::set_p_refinement_flag().

Referenced by libMesh::UnstructuredMesh::all_first_order(), libMesh::Elem::coarsen(), libMesh::Elem::Elem(), libMesh::Elem::inherit_data_from(), libMesh::Polygon::Polygon(), libMesh::Polyhedron::Polyhedron(), libMesh::Elem::refine(), libMesh::Elem::set_p_level(), and VolumeTest::testHex20PLevelTrueCentroid().

42 {
43  // Maintain the parent's p level as the minimum of it's children
44  if (this->parent() != nullptr)
45  {
46  unsigned int parent_p_level = this->parent()->p_level();
47 
48  // If our new p level is less than our parents, our parents drops
49  if (parent_p_level > p)
50  {
51  this->parent()->set_p_level(p);
52 
53  // And we should keep track of the drop, in case we need to
54  // do a projection later.
56  }
57  // If we are the lowest p level and it increases, so might
58  // our parent's, but we have to check every other child to see
59  else if (parent_p_level == _p_level && _p_level < p)
60  {
61  _p_level = cast_int<unsigned char>(p);
62  parent_p_level = cast_int<unsigned char>(p);
63  for (auto & c : this->parent()->child_ref_range())
64  parent_p_level = std::min(parent_p_level,
65  c.p_level());
66 
67  // When its children all have a higher p level, the parent's
68  // should rise
69  if (parent_p_level > this->parent()->p_level())
70  {
71  this->parent()->set_p_level(parent_p_level);
72 
73  // And we should keep track of the rise, in case we need to
74  // do a projection later.
76  }
77 
78  return;
79  }
80  }
81 
82  this->hack_p_level(p);
83 }
void set_p_level(const unsigned int p)
Sets the value of the p-refinement level for the element.
const Elem * parent() const
Definition: elem.h:3030
unsigned char _p_level
p refinement level - the difference between the polynomial degree on this element and the minimum pol...
Definition: elem.h:2290
unsigned int p_level() const
Definition: elem.h:3108
SimpleRange< ChildRefIter > child_ref_range()
Returns a range with all children of a parent element, usable in range-based for loops.
Definition: elem.h:2346
void set_p_refinement_flag(const RefinementState pflag)
Sets the value of the p-refinement flag for the element.
Definition: elem.h:3234
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:3264

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

References libMesh::Elem::_pflag, libMesh::Elem::JUST_REFINED, and libMesh::Elem::p_level().

Referenced by libMesh::BoundaryInfo::add_elements(), libMesh::UnstructuredMesh::all_first_order(), libMesh::MeshRefinement::enforce_mismatch_limit_prior_to_refinement(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshRefinement::make_flags_parallel_consistent(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::Elem::refine(), and libMesh::Elem::set_p_level().

3235 {
3236  if (this->p_level() == 0)
3237  libmesh_assert_not_equal_to
3238  (pflag, Elem::JUST_REFINED);
3239 
3240  _pflag = cast_int<unsigned char>(pflag);
3241 }
unsigned char _pflag
p refinement flag.
Definition: elem.h:2280
unsigned int p_level() const
Definition: elem.h:3108

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

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

Referenced by libMesh::BoundaryInfo::add_elements(), and libMesh::UnstructuredMesh::all_first_order().

3047 {
3048  // We no longer support using parent() as interior_parent()
3049  libmesh_assert_equal_to(this->dim(), p ? p->dim() : this->dim());
3050  _elemlinks[0] = p;
3051 }
Elem ** _elemlinks
Pointers to this element&#39;s parent and neighbors, and for lower-dimensional elements&#39; interior_parent...
Definition: elem.h:2251
virtual unsigned short dim() const =0

◆ set_refinement_flag()

void libMesh::Elem::set_refinement_flag ( const RefinementState  rflag)
inlineinherited

◆ set_unique_id() [1/2]

unique_id_type & libMesh::DofObject::set_unique_id ( )
inlineinherited

◆ set_unique_id() [2/2]

void libMesh::DofObject::set_unique_id ( unique_id_type  new_id)
inlineinherited

Sets the unique_id for this DofObject.

Definition at line 872 of file dof_object.h.

References libMesh::DofObject::_unique_id, and libMesh::libmesh_ignore().

873 {
874 #ifdef LIBMESH_ENABLE_UNIQUE_ID
875  _unique_id = new_id;
876 #else
877  libmesh_ignore(new_id);
878  libmesh_not_implemented();
879 #endif
880 }
unique_id_type _unique_id
A globally unique id, guaranteed not to change as the mesh is repartitioned or adapted.
Definition: dof_object.h:577
void libmesh_ignore(const Args &...)

◆ set_vg_dof_base()

void libMesh::DofObject::set_vg_dof_base ( const unsigned int  s,
const unsigned int  vg,
const dof_id_type  db 
)
inlineinherited

VariableGroup DoF indices are indexed as id = base + var_in_vg*ncomp + comp This method allows for direct access to the base.

Definition at line 1297 of file dof_object.h.

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

Referenced by libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DofObject::invalidate_dofs(), libMesh::DofMap::reinit(), libMesh::DofMap::set_nonlocal_dof_objects(), and DofObjectTest< Node >::testManualDofCalculation().

1300 {
1301  libmesh_assert_less (s, this->n_systems());
1302  libmesh_assert_less (vg, this->n_var_groups(s));
1303 
1304  const unsigned int
1305  start_idx_sys = this->start_idx(s);
1306 
1307  libmesh_assert_less ((start_idx_sys + 2*vg + 1), _idx_buf.size());
1308 
1309  _idx_buf[start_idx_sys + 2*vg + 1] = db;
1310 
1311  libmesh_assert_equal_to (this->vg_dof_base(s,vg), db);
1312 }
dof_id_type vg_dof_base(const unsigned int s, const unsigned int vg) const
VariableGroup DoF indices are indexed as id = base + var_in_vg*ncomp + comp This method allows for di...
Definition: dof_object.h:1317
unsigned int n_var_groups(const unsigned int s) const
Definition: dof_object.h:957
unsigned int n_systems() const
Definition: dof_object.h:937
unsigned int start_idx(const unsigned int s) const
The starting index for system s.
Definition: dof_object.h:1249
index_buffer_t _idx_buf
Definition: dof_object.h:680

◆ side_children_matrix()

unsigned int libMesh::Edge::side_children_matrix ( const unsigned  int,
const unsigned  int 
) const
inlineprotectedinherited

Matrix that allows children to inherit boundary conditions.

Definition at line 254 of file edge.h.

256  { libmesh_not_implemented(); return 0; }

◆ side_index_range()

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

Definition at line 2710 of file elem.h.

References libMesh::Elem::n_sides().

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::MeshTools::Subdivision::add_boundary_ghosts(), libMesh::BoundaryInfo::add_elements(), libMesh::MeshTools::Modification::all_tri(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::FEGenericBase< FEOutputType< T >::type >::coarsened_dof_values(), compute_enriched_soln(), libMesh::FEAbstract::compute_node_constraints(), libMesh::FEAbstract::compute_periodic_node_constraints(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_proj_constraints(), libMesh::BoundaryInfo::copy_boundary_ids(), libMesh::BoundaryInfo::edge_boundary_ids(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::MeshTools::Modification::flatten(), libMesh::ReplicatedMesh::get_disconnected_subdomains(), libMesh::Elem::get_info(), libMesh::BoundaryInfo::get_side_and_node_maps(), libMesh::Elem::has_topological_neighbor(), libMesh::InfFE< Dim, T_radial, T_map >::inf_compute_constraints(), libMesh::InfFE< Dim, T_radial, T_map >::inf_compute_node_constraints(), libMesh::LaplaceMeshSmoother::init(), libMesh::Elem::libmesh_assert_valid_neighbors(), libMesh::Elem::nullify_neighbors(), libMesh::PostscriptIO::plot_quadratic_elem(), libMesh::MeshTools::Modification::smooth(), libMesh::UnstructuredMesh::stitching_helper(), MeshBaseTest::testMeshBaseVerifyIsPrepared(), and libMesh::MeshTetInterface::volume_to_surface_mesh().

2711 {
2712  return {0, cast_int<unsigned short>(this->n_sides())};
2713 }
virtual unsigned int n_sides() const =0

◆ side_ptr() [1/4]

std::unique_ptr< Elem > libMesh::Edge::side_ptr ( const unsigned int  i)
finaloverridevirtualinherited
Returns
A pointer to a NodeElem for the specified node.

Implements libMesh::Elem.

Definition at line 56 of file edge.C.

References libMesh::Elem::node_ptr().

57 {
58  libmesh_assert_less (i, 2);
59  std::unique_ptr<Elem> nodeelem = std::make_unique<NodeElem>();
60  nodeelem->set_node(0, this->node_ptr(i));
61 
62  nodeelem->set_interior_parent(this);
63  nodeelem->inherit_data_from(*this);
64 
65  return nodeelem;
66 }
const Node * node_ptr(const unsigned int i) const
Definition: elem.h:2507

◆ side_ptr() [2/4]

void libMesh::Edge::side_ptr ( std::unique_ptr< Elem > &  side,
const unsigned int  i 
)
finaloverridevirtualinherited

Rebuilds a pointer to a NodeElem for the specified node.

Implements libMesh::Elem.

Definition at line 69 of file edge.C.

References libMesh::Edge::build_side_ptr(), libMesh::Edge::n_sides(), libMesh::Elem::node_ptr(), and libMesh::NODEELEM.

71 {
72  libmesh_assert_less (i, this->n_sides());
73 
74  if (!side.get() || side->type() != NODEELEM)
75  side = this->build_side_ptr(i);
76  else
77  {
78  side->inherit_data_from(*this);
79  side->set_node(0, this->node_ptr(i));
80  }
81 }
virtual std::unique_ptr< Elem > build_side_ptr(const unsigned int i) override final
Definition: edge.C:86
const Node * node_ptr(const unsigned int i) const
Definition: elem.h:2507
virtual unsigned int n_sides() const override final
Definition: edge.h:83

◆ side_ptr() [3/4]

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

Definition at line 2719 of file elem.h.

References libMesh::Elem::side_ptr().

2720 {
2721  // Call the non-const version of this function, return the result as
2722  // a std::unique_ptr<const Elem>.
2723  Elem * me = const_cast<Elem *>(this);
2724  return me->side_ptr(i);
2725 }
Elem(const unsigned int n_nodes, const unsigned int n_sides, Elem *parent, Elem **elemlinkdata, Node **nodelinkdata)
Constructor.
Definition: elem.h:2378

◆ side_ptr() [4/4]

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

Definition at line 2731 of file elem.h.

References libMesh::Elem::side_ptr().

2733 {
2734  // Hand off to the non-const version of this function
2735  Elem * me = const_cast<Elem *>(this);
2736  std::unique_ptr<Elem> e {const_cast<Elem *>(elem.release())};
2737  me->side_ptr(e, i);
2738  elem = std::move(e);
2739 }
Elem(const unsigned int n_nodes, const unsigned int n_sides, Elem *parent, Elem **elemlinkdata, Node **nodelinkdata)
Constructor.
Definition: elem.h:2378

◆ side_type()

ElemType libMesh::Edge::side_type ( const unsigned int  s) const
finaloverridevirtualinherited
Returns
The type of element for side s.

Implements libMesh::Elem.

Definition at line 165 of file edge.C.

References libMesh::NODEELEM.

166 {
167  libmesh_assert_less (s, 2);
168  return NODEELEM;
169 }

◆ sides_on_edge()

virtual std::vector<unsigned int> libMesh::Edge::sides_on_edge ( const unsigned  int) const
inlinefinaloverridevirtualinherited
Returns
the (local) side numbers that touch the specified edge

Implements libMesh::Elem.

Definition at line 206 of file edge.h.

207  { return {}; }

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

References libMesh::Elem::n_edges().

2867 {
2868  libmesh_assert_less (i, this->n_edges());
2869 
2870  std::unique_ptr<Elem> edge = std::make_unique<Edgeclass>();
2871 
2872  for (auto n : edge->node_index_range())
2873  edge->set_node(n, this->node_ptr(Subclass::edge_nodes_map[i][n]));
2874 
2875  edge->set_interior_parent(this);
2876  edge->inherit_data_from(*this);
2877 
2878  return edge;
2879 }
virtual unsigned int n_edges() const =0

◆ simple_build_edge_ptr() [2/2]

template<typename Subclass >
void libMesh::Elem::simple_build_edge_ptr ( std::unique_ptr< Elem > &  edge,
const unsigned int  i,
ElemType  edgetype 
)
inlineprotectedinherited

An implementation for simple (all edges equal) elements.

Definition at line 2887 of file elem.h.

References libMesh::Elem::n_edges().

2890 {
2891  libmesh_assert_less (i, this->n_edges());
2892 
2893  if (!edge.get() || edge->type() != edgetype)
2894  {
2895  Subclass & real_me = cast_ref<Subclass&>(*this);
2896  edge = real_me.Subclass::build_edge_ptr(i);
2897  }
2898  else
2899  {
2900  edge->inherit_data_from(*this);
2901  for (auto n : edge->node_index_range())
2902  edge->set_node(n, this->node_ptr(Subclass::edge_nodes_map[i][n]));
2903  }
2904 }
virtual unsigned int n_edges() const =0

◆ simple_build_side_ptr() [1/2]

template<typename Sideclass , typename Subclass >
std::unique_ptr< Elem > libMesh::Elem::simple_build_side_ptr ( const unsigned int  i)
inlineprotectedinherited

An implementation for simple (all sides equal) elements.

Definition at line 2772 of file elem.h.

References libMesh::Elem::n_sides().

2773 {
2774  libmesh_assert_less (i, this->n_sides());
2775 
2776  std::unique_ptr<Elem> face = std::make_unique<Sideclass>();
2777  for (auto n : face->node_index_range())
2778  face->set_node(n, this->node_ptr(Subclass::side_nodes_map[i][n]));
2779 
2780  face->set_interior_parent(this);
2781  face->inherit_data_from(*this);
2782 
2783  return face;
2784 }
virtual unsigned int n_sides() const =0

◆ simple_build_side_ptr() [2/2]

template<typename Subclass >
void libMesh::Elem::simple_build_side_ptr ( std::unique_ptr< Elem > &  side,
const unsigned int  i,
ElemType  sidetype 
)
inlineprotectedinherited

An implementation for simple (all sides equal) elements.

Definition at line 2791 of file elem.h.

References libMesh::Elem::n_sides().

2794 {
2795  libmesh_assert_less (i, this->n_sides());
2796 
2797  if (!side.get() || side->type() != sidetype)
2798  {
2799  Subclass & real_me = cast_ref<Subclass&>(*this);
2800  side = real_me.Subclass::build_side_ptr(i);
2801  }
2802  else
2803  {
2804  side->set_interior_parent(this);
2805  side->inherit_data_from(*this);
2806  for (auto n : side->node_index_range())
2807  side->set_node(n, this->node_ptr(Subclass::side_nodes_map[i][n]));
2808  }
2809 }
virtual unsigned int n_sides() const =0

◆ simple_side_ptr()

template<typename Subclass , typename Mapclass >
void libMesh::Elem::simple_side_ptr ( std::unique_ptr< Elem > &  side,
const unsigned int  i,
ElemType  sidetype 
)
inlineprotectedinherited

An implementation for simple (all sides equal) elements.

Definition at line 2816 of file elem.h.

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

2819 {
2820  libmesh_assert_less (i, this->n_sides());
2821 
2822  if (!side.get() || side->type() != sidetype)
2823  {
2824  Subclass & real_me = cast_ref<Subclass&>(*this);
2825  side = real_me.Subclass::side_ptr(i);
2826  }
2827  else
2828  {
2829  side->subdomain_id() = this->subdomain_id();
2830 
2831  for (auto n : side->node_index_range())
2832  side->set_node(n, this->node_ptr(Mapclass::side_nodes_map[i][n]));
2833  }
2834 }
virtual unsigned int n_sides() const =0
subdomain_id_type subdomain_id() const
Definition: elem.h:2582

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

References libMesh::Elem::active(), libMesh::Elem::has_children(), and libMesh::Elem::parent().

Referenced by libMesh::HPCoarsenTest::add_projection(), libMesh::Elem::ancestor(), libMesh::FEAbstract::compute_node_constraints(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::Elem::get_info(), libMesh::InfFE< Dim, T_radial, T_map >::inf_compute_constraints(), libMesh::InfFE< Dim, T_radial, T_map >::inf_compute_node_constraints(), libMesh::Elem::libmesh_assert_valid_neighbors(), libMesh::Elem::make_links_to_me_local(), libMesh::Elem::make_links_to_me_remote(), libMesh::Elem::max_descendant_p_level(), libMesh::Elem::min_new_p_level_by_neighbor(), libMesh::Elem::min_p_level_by_neighbor(), libMesh::Elem::refine(), libMesh::Elem::remove_links_to_me(), and libMesh::UnstructuredMesh::stitching_helper().

2960 {
2961 #ifdef LIBMESH_ENABLE_AMR
2962  if (this->active())
2963  return false;
2964  if (!this->has_children())
2965  return true;
2966  for (const Elem * my_ancestor = this->parent();
2967  my_ancestor != nullptr;
2968  my_ancestor = my_ancestor->parent())
2969  if (my_ancestor->active())
2970  return true;
2971 #endif
2972 
2973  return false;
2974 }
const Elem * parent() const
Definition: elem.h:3030
Elem(const unsigned int n_nodes, const unsigned int n_sides, Elem *parent, Elem **elemlinkdata, Node **nodelinkdata)
Constructor.
Definition: elem.h:2378
bool active() const
Definition: elem.h:2941
bool has_children() const
Definition: elem.h:2979

◆ subdomain_id() [1/2]

subdomain_id_type libMesh::Elem::subdomain_id ( ) const
inlineinherited
Returns
The subdomain that this element belongs to.

Definition at line 2582 of file elem.h.

References libMesh::Elem::_sbd_id.

Referenced by libMesh::DofMap::_dof_indices(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::SyncSubdomainIds::act_on_data(), LinearElasticityWithContact::add_contact_edge_elements(), libMesh::MeshTools::Modification::all_tri(), AllSecondOrderTest::allCompleteOrderRange(), AllSecondOrderTest::allSecondOrderRange(), libMesh::AbaqusIO::assign_subdomain_ids(), libMesh::EquationSystems::build_discontinuous_solution_vector(), MixedDimensionMeshTest::build_mesh(), MixedDimensionNonUniformRefinement::build_mesh(), MixedDimensionNonUniformRefinementTriangle::build_mesh(), MixedDimensionNonUniformRefinement3D::build_mesh(), OverlappingTestBase::build_quad_mesh(), libMesh::InfQuad6::build_side_ptr(), libMesh::MeshTools::Modification::change_subdomain_id(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_proj_constraints(), libMesh::TriangleWrapper::copy_tri_to_mesh(), libMesh::DofMap::dof_indices(), libMesh::Elem::Elem(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::find_dofs_to_send(), libMesh::MeshTools::Modification::flatten(), libMesh::SyncSubdomainIds::gather_data(), libMesh::Elem::get_info(), MeshExtruderTest::QueryElemSubdomainID::get_subdomain_for_layer(), libMesh::UNVIO::groups_in(), libMesh::Elem::inherit_data_from(), libMesh::DofMap::old_dof_indices(), libMesh::PointLocatorNanoflann::operator()(), libMesh::XdrIO::pack_element(), libMesh::Polygon::Polygon(), libMesh::Polyhedron::Polyhedron(), libMesh::CheckpointIO::read_connectivity(), libMesh::GmshIO::read_mesh(), libMesh::DynaIO::read_mesh(), libMesh::Pyramid::side_ptr(), libMesh::Prism::side_ptr(), libMesh::Polygon::side_ptr(), libMesh::InfPrism::side_ptr(), libMesh::InfHex::side_ptr(), libMesh::InfQuad::side_ptr(), libMesh::Elem::simple_side_ptr(), SystemsTest::testDofCouplingWithVarGroups(), MeshExtruderTest::testExtruder(), SystemsTest::testSetSystemParameterOverEquationSystem(), and SystemsTest::tripleValueTest().

2583 {
2584  return _sbd_id;
2585 }
subdomain_id_type _sbd_id
The subdomain to which this element belongs.
Definition: elem.h:2267

◆ subdomain_id() [2/2]

subdomain_id_type & libMesh::Elem::subdomain_id ( )
inlineinherited
Returns
The subdomain that this element belongs to as a writable reference.

Definition at line 2590 of file elem.h.

References libMesh::Elem::_sbd_id.

2591 {
2592  return _sbd_id;
2593 }
subdomain_id_type _sbd_id
The subdomain to which this element belongs.
Definition: elem.h:2267

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

References libMesh::Elem::default_order().

Referenced by libMesh::MeshBase::copy_constraint_rows().

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

◆ swap2boundaryedges()

void libMesh::Elem::swap2boundaryedges ( unsigned short  e1,
unsigned short  e2,
BoundaryInfo boundary_info 
) const
protectedinherited

Swaps two edges in boundary_info, if it is non-null.

Definition at line 3550 of file elem.C.

References libMesh::BoundaryInfo::add_edge(), libMesh::BoundaryInfo::edge_boundary_ids(), and libMesh::BoundaryInfo::remove_edge().

Referenced by libMesh::InfQuad4::flip(), libMesh::InfPrism6::flip(), libMesh::InfHex8::flip(), libMesh::Quad4::flip(), libMesh::InfQuad6::flip(), libMesh::C0Polygon::flip(), libMesh::Pyramid5::flip(), libMesh::Tri3::flip(), libMesh::Prism6::flip(), libMesh::InfPrism12::flip(), libMesh::Quad8::flip(), libMesh::Hex8::flip(), libMesh::Quad9::flip(), libMesh::InfHex16::flip(), libMesh::Tri7::flip(), libMesh::Tri6::flip(), libMesh::Pyramid13::flip(), libMesh::InfHex18::flip(), libMesh::Hex20::flip(), libMesh::Tet10::flip(), libMesh::Tet14::flip(), libMesh::Prism15::flip(), libMesh::Tet4::flip(), libMesh::Pyramid14::flip(), libMesh::Pyramid18::flip(), libMesh::Hex27::flip(), libMesh::Prism18::flip(), libMesh::Prism20::flip(), and libMesh::Prism21::flip().

3553 {
3554  std::vector<boundary_id_type> ids1, ids2;
3555  boundary_info->edge_boundary_ids(this, e1, ids1);
3556  boundary_info->edge_boundary_ids(this, e2, ids2);
3557  boundary_info->remove_edge(this, e1);
3558  boundary_info->remove_edge(this, e2);
3559  if (!ids1.empty())
3560  boundary_info->add_edge(this, e2, ids1);
3561  if (!ids2.empty())
3562  boundary_info->add_edge(this, e1, ids2);
3563 }

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

References libMesh::BoundaryInfo::add_side(), libMesh::BoundaryInfo::boundary_ids(), and libMesh::BoundaryInfo::remove_side().

Referenced by libMesh::InfQuad4::flip(), libMesh::InfPrism6::flip(), libMesh::InfHex8::flip(), libMesh::Edge2::flip(), libMesh::Quad4::flip(), libMesh::InfQuad6::flip(), libMesh::C0Polygon::flip(), libMesh::Pyramid5::flip(), libMesh::Edge4::flip(), libMesh::Edge3::flip(), libMesh::Tri3::flip(), libMesh::Prism6::flip(), libMesh::InfPrism12::flip(), libMesh::Quad8::flip(), libMesh::Hex8::flip(), libMesh::Quad9::flip(), libMesh::InfHex16::flip(), libMesh::Tri7::flip(), libMesh::Tri6::flip(), libMesh::Pyramid13::flip(), libMesh::InfHex18::flip(), libMesh::Hex20::flip(), libMesh::Tet10::flip(), libMesh::Tet14::flip(), libMesh::Prism15::flip(), libMesh::Tet4::flip(), libMesh::Pyramid14::flip(), libMesh::Pyramid18::flip(), libMesh::Hex27::flip(), libMesh::Prism18::flip(), libMesh::Prism20::flip(), and libMesh::Prism21::flip().

3537 {
3538  std::vector<boundary_id_type> ids1, ids2;
3539  boundary_info->boundary_ids(this, s1, ids1);
3540  boundary_info->boundary_ids(this, s2, ids2);
3541  boundary_info->remove_side(this, s1);
3542  boundary_info->remove_side(this, s2);
3543  if (!ids1.empty())
3544  boundary_info->add_side(this, s2, ids1);
3545  if (!ids2.empty())
3546  boundary_info->add_side(this, s1, ids2);
3547 }

◆ swap2neighbors()

void libMesh::Elem::swap2neighbors ( unsigned int  n1,
unsigned int  n2 
)
inlineprotectedinherited

Swaps two neighbor_ptrs.

Definition at line 2102 of file elem.h.

References libMesh::Elem::neighbor_ptr(), and libMesh::Elem::set_neighbor().

Referenced by libMesh::InfQuad4::flip(), libMesh::InfPrism6::flip(), libMesh::InfHex8::flip(), libMesh::Edge2::flip(), libMesh::Quad4::flip(), libMesh::InfQuad6::flip(), libMesh::C0Polygon::flip(), libMesh::Edge4::flip(), libMesh::Pyramid5::flip(), libMesh::Edge3::flip(), libMesh::Tri3::flip(), libMesh::Prism6::flip(), libMesh::InfPrism12::flip(), libMesh::Quad8::flip(), libMesh::Hex8::flip(), libMesh::Quad9::flip(), libMesh::Tri7::flip(), libMesh::InfHex16::flip(), libMesh::Tri6::flip(), libMesh::Pyramid13::flip(), libMesh::InfHex18::flip(), libMesh::Hex20::flip(), libMesh::Tet14::flip(), libMesh::Tet10::flip(), libMesh::Prism15::flip(), libMesh::Tet4::flip(), libMesh::Pyramid14::flip(), libMesh::Pyramid18::flip(), libMesh::Hex27::flip(), libMesh::Prism18::flip(), libMesh::Prism20::flip(), libMesh::Prism21::flip(), libMesh::Prism6::permute(), libMesh::Hex8::permute(), libMesh::Hex20::permute(), libMesh::Prism15::permute(), libMesh::Hex27::permute(), libMesh::Prism20::permute(), libMesh::Prism18::permute(), libMesh::Prism21::permute(), libMesh::Elem::swap3neighbors(), and libMesh::Elem::swap4neighbors().

2103  {
2104  Elem * temp = this->neighbor_ptr(n1);
2105  this->set_neighbor(n1, this->neighbor_ptr(n2));
2106  this->set_neighbor(n2, temp);
2107  }
void set_neighbor(const unsigned int i, Elem *n)
Assigns n as the neighbor.
Definition: elem.h:2618
Elem(const unsigned int n_nodes, const unsigned int n_sides, Elem *parent, Elem **elemlinkdata, Node **nodelinkdata)
Constructor.
Definition: elem.h:2378
const Elem * neighbor_ptr(unsigned int i) const
Definition: elem.h:2598

◆ swap2nodes()

void libMesh::Elem::swap2nodes ( unsigned int  n1,
unsigned int  n2 
)
inlineprotectedinherited

Swaps two node_ptrs.

Definition at line 2092 of file elem.h.

References libMesh::Elem::node_ptr(), and libMesh::Elem::set_node().

Referenced by libMesh::InfQuad4::flip(), libMesh::InfPrism6::flip(), libMesh::InfHex8::flip(), libMesh::Edge2::flip(), libMesh::Quad4::flip(), libMesh::InfQuad6::flip(), libMesh::C0Polygon::flip(), libMesh::Edge4::flip(), libMesh::Pyramid5::flip(), libMesh::Edge3::flip(), libMesh::Tri3::flip(), libMesh::Prism6::flip(), libMesh::InfPrism12::flip(), libMesh::Quad8::flip(), libMesh::Hex8::flip(), libMesh::Quad9::flip(), libMesh::Tri7::flip(), libMesh::InfHex16::flip(), libMesh::Tri6::flip(), libMesh::Pyramid13::flip(), libMesh::InfHex18::flip(), libMesh::Hex20::flip(), libMesh::Tet14::flip(), libMesh::Tet10::flip(), libMesh::Prism15::flip(), libMesh::Tet4::flip(), libMesh::Pyramid14::flip(), libMesh::Pyramid18::flip(), libMesh::Hex27::flip(), libMesh::Prism18::flip(), libMesh::Prism20::flip(), libMesh::Prism21::flip(), libMesh::Prism6::permute(), libMesh::Hex8::permute(), libMesh::Hex20::permute(), libMesh::Prism15::permute(), libMesh::Hex27::permute(), libMesh::Prism20::permute(), libMesh::Prism18::permute(), libMesh::Prism21::permute(), libMesh::Elem::swap3nodes(), and libMesh::Elem::swap4nodes().

2093  {
2094  Node * temp = this->node_ptr(n1);
2095  this->set_node(n1, this->node_ptr(n2));
2096  this->set_node(n2, temp);
2097  }
virtual Node *& set_node(const unsigned int i)
Definition: elem.h:2558
const Node * node_ptr(const unsigned int i) const
Definition: elem.h:2507

◆ swap3neighbors()

void libMesh::Elem::swap3neighbors ( unsigned int  n1,
unsigned int  n2,
unsigned int  n3 
)
inlineprotectedinherited

◆ swap3nodes()

void libMesh::Elem::swap3nodes ( unsigned int  n1,
unsigned int  n2,
unsigned int  n3 
)
inlineprotectedinherited

◆ swap4neighbors()

void libMesh::Elem::swap4neighbors ( unsigned int  n1,
unsigned int  n2,
unsigned int  n3,
unsigned int  n4 
)
inlineprotectedinherited

Swaps four neighbor_ptrs, "rotating" them.

Definition at line 2153 of file elem.h.

References libMesh::Elem::swap2neighbors(), and libMesh::Elem::swap3neighbors().

Referenced by libMesh::InfHex8::permute(), libMesh::Quad4::permute(), libMesh::Pyramid5::permute(), libMesh::Hex8::permute(), libMesh::Quad8::permute(), libMesh::Quad9::permute(), libMesh::InfHex16::permute(), libMesh::Pyramid13::permute(), libMesh::InfHex18::permute(), libMesh::Hex20::permute(), libMesh::Pyramid14::permute(), libMesh::Pyramid18::permute(), and libMesh::Hex27::permute().

2155  {
2156  swap3neighbors(n1, n2, n3);
2157  swap2neighbors(n3, n4);
2158  }
void swap3neighbors(unsigned int n1, unsigned int n2, unsigned int n3)
Swaps three neighbor_ptrs, "rotating" them.
Definition: elem.h:2133
void swap2neighbors(unsigned int n1, unsigned int n2)
Swaps two neighbor_ptrs.
Definition: elem.h:2102

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

References libMesh::Elem::swap2nodes(), and libMesh::Elem::swap3nodes().

Referenced by libMesh::InfHex8::permute(), libMesh::Quad4::permute(), libMesh::Pyramid5::permute(), libMesh::Hex8::permute(), libMesh::Quad8::permute(), libMesh::Quad9::permute(), libMesh::InfHex16::permute(), libMesh::Pyramid13::permute(), libMesh::InfHex18::permute(), libMesh::Hex20::permute(), libMesh::Pyramid14::permute(), libMesh::Pyramid18::permute(), and libMesh::Hex27::permute().

2145  {
2146  swap3nodes(n1, n2, n3);
2147  swap2nodes(n3, n4);
2148  }
void swap3nodes(unsigned int n1, unsigned int n2, unsigned int n3)
Swaps three node_ptrs, "rotating" them.
Definition: elem.h:2124
void swap2nodes(unsigned int n1, unsigned int n2)
Swaps two node_ptrs.
Definition: elem.h:2092

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

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

Referenced by libMesh::BoundaryInfo::boundary_ids(), libMesh::BoundaryInfo::edge_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_amr_interior_parents(), libMesh::ExodusII_IO::read_elemental_variable(), libMesh::BoundaryInfo::side_with_boundary_id(), libMesh::BoundaryInfo::sides_with_boundary_id(), and ExtraIntegersTest::test_final_integers().

3057 {
3058  const Elem * tp = this;
3059 
3060  // Keep getting the element's parent
3061  // until that parent is at level-0
3062  while (tp->parent() != nullptr)
3063  tp = tp->parent();
3064 
3065  libmesh_assert(tp);
3066  libmesh_assert_equal_to (tp->level(), 0);
3067 
3068  return tp;
3069 }
libmesh_assert(ctx)
Elem(const unsigned int n_nodes, const unsigned int n_sides, Elem *parent, Elem **elemlinkdata, Node **nodelinkdata)
Constructor.
Definition: elem.h:2378

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

References libMesh::PeriodicBoundaries::boundary(), libMesh::Elem::level(), mesh, libMesh::Elem::n_neighbors(), libMesh::PeriodicBoundaries::neighbor(), libMesh::Elem::neighbor_ptr(), and libMesh::Elem::parent().

Referenced by libMesh::Elem::has_topological_neighbor(), libMesh::GhostPointNeighbors::operator()(), libMesh::DefaultCoupling::operator()(), and libMesh::MeshRefinement::topological_neighbor().

1317 {
1318  libmesh_assert_less (i, this->n_neighbors());
1319 
1320  const Elem * neighbor_i = this->neighbor_ptr(i);
1321  if (neighbor_i != nullptr)
1322  return neighbor_i;
1323 
1324  if (pb)
1325  {
1326  // Since the neighbor is nullptr it must be on a boundary. We need
1327  // see if this is a periodic boundary in which case it will have a
1328  // topological neighbor
1329  std::vector<boundary_id_type> bc_ids;
1330  mesh.get_boundary_info().boundary_ids(this, cast_int<unsigned short>(i), bc_ids);
1331  for (const auto & id : bc_ids)
1332  if (pb->boundary(id))
1333  {
1334  neighbor_i = pb->neighbor(id, point_locator, this, i);
1335 
1336  // Since coarse elements do not have more refined
1337  // neighbors we need to make sure that we don't return one
1338  // of these types of neighbors.
1339  if (neighbor_i)
1340  while (level() < neighbor_i->level())
1341  neighbor_i = neighbor_i->parent();
1342  return neighbor_i;
1343  }
1344  }
1345 
1346  return nullptr;
1347 }
MeshBase & mesh
Elem(const unsigned int n_nodes, const unsigned int n_sides, Elem *parent, Elem **elemlinkdata, Node **nodelinkdata)
Constructor.
Definition: elem.h:2378
const Elem * neighbor_ptr(unsigned int i) const
Definition: elem.h:2598
unsigned int level() const
Definition: elem.h:3074
unsigned int n_neighbors() const
Definition: elem.h:714

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

References libMesh::PeriodicBoundaries::boundary(), libMesh::Elem::level(), mesh, libMesh::Elem::n_neighbors(), libMesh::PeriodicBoundaries::neighbor(), libMesh::Elem::neighbor_ptr(), and libMesh::Elem::parent().

1275 {
1276  libmesh_assert_less (i, this->n_neighbors());
1277 
1278  Elem * neighbor_i = this->neighbor_ptr(i);
1279  if (neighbor_i != nullptr)
1280  return neighbor_i;
1281 
1282  if (pb)
1283  {
1284  // Since the neighbor is nullptr it must be on a boundary. We need
1285  // see if this is a periodic boundary in which case it will have a
1286  // topological neighbor
1287  std::vector<boundary_id_type> bc_ids;
1288  mesh.get_boundary_info().boundary_ids(this, cast_int<unsigned short>(i), bc_ids);
1289  for (const auto & id : bc_ids)
1290  if (pb->boundary(id))
1291  {
1292  // Since the point locator inside of periodic boundaries
1293  // returns a const pointer we will retrieve the proper
1294  // pointer directly from the mesh object.
1295  const Elem * const cn = pb->neighbor(id, point_locator, this, i);
1296  neighbor_i = const_cast<Elem *>(cn);
1297 
1298  // Since coarse elements do not have more refined
1299  // neighbors we need to make sure that we don't return one
1300  // of these types of neighbors.
1301  if (neighbor_i)
1302  while (level() < neighbor_i->level())
1303  neighbor_i = neighbor_i->parent();
1304  return neighbor_i;
1305  }
1306  }
1307 
1308  return nullptr;
1309 }
MeshBase & mesh
Elem(const unsigned int n_nodes, const unsigned int n_sides, Elem *parent, Elem **elemlinkdata, Node **nodelinkdata)
Constructor.
Definition: elem.h:2378
const Elem * neighbor_ptr(unsigned int i) const
Definition: elem.h:2598
unsigned int level() const
Definition: elem.h:3074
unsigned int n_neighbors() const
Definition: elem.h:714

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

References libMesh::DofObject::id(), libMesh::Elem::interior_parent(), libMesh::make_range(), libMesh::Elem::n_neighbors(), libMesh::Elem::n_nodes(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::node_id(), libMesh::Elem::parent(), and libMesh::Elem::type().

804 {
805  // If the elements aren't the same type, they aren't equal
806  if (this->type() != rhs.type())
807  return false;
808 
809  libmesh_assert_equal_to(this->n_nodes(), rhs.n_nodes());
810 
811  for (auto n : make_range(this->n_nodes()))
812  if (this->node_id(n) != rhs.node_id(n))
813  return false;
814 
815  for (auto neigh : make_range(this->n_neighbors()))
816  {
817  if (!this->neighbor_ptr(neigh))
818  {
819  if (rhs.neighbor_ptr(neigh))
820  return false;
821  continue;
822  }
823  if (!rhs.neighbor_ptr(neigh) ||
824  this->neighbor_ptr(neigh)->id() !=
825  rhs.neighbor_ptr(neigh)->id())
826  return false;
827  }
828 
829  if (this->parent())
830  {
831  if (!rhs.parent())
832  return false;
833  if (this->parent()->id() != rhs.parent()->id())
834  return false;
835  }
836  else if (rhs.parent())
837  return false;
838 
839  if (this->interior_parent())
840  {
841  if (!rhs.interior_parent())
842  return false;
843  if (this->interior_parent()->id() !=
844  rhs.interior_parent()->id())
845  return false;
846  }
847  else if (rhs.interior_parent())
848  return false;
849 
850  return true;
851 }
const Elem * parent() const
Definition: elem.h:3030
const Elem * interior_parent() const
Definition: elem.C:1186
dof_id_type id() const
Definition: dof_object.h:828
virtual unsigned int n_nodes() const =0
const Elem * neighbor_ptr(unsigned int i) const
Definition: elem.h:2598
unsigned int n_neighbors() const
Definition: elem.h:714
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140
virtual ElemType type() const =0
dof_id_type node_id(const unsigned int i) const
Definition: elem.h:2475

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

References libMesh::ElemInternal::total_family_tree().

Referenced by libMesh::Partitioner::set_parent_processor_ids().

2119 {
2120  ElemInternal::total_family_tree(this, family, reset);
2121 }
void total_family_tree(T elem, std::vector< T > &family, bool reset)
Definition: elem_internal.h:67

◆ total_family_tree() [2/2]

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

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

Definition at line 2125 of file elem.C.

References libMesh::ElemInternal::total_family_tree().

2127 {
2128  ElemInternal::total_family_tree(this, family, reset);
2129 }
void total_family_tree(T elem, std::vector< T > &family, bool reset)
Definition: elem_internal.h:67

◆ total_family_tree_by_neighbor() [1/2]

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

Same as the family_tree_by_neighbor() member, but also adds any subactive descendants.

Definition at line 2203 of file elem.C.

References libMesh::ElemInternal::total_family_tree_by_neighbor().

2206 {
2207  ElemInternal::total_family_tree_by_neighbor(this, family, neighbor, reset);
2208 }
void total_family_tree_by_neighbor(T elem, std::vector< T > &family, T neighbor_in, bool reset=true)

◆ total_family_tree_by_neighbor() [2/2]

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

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

Definition at line 2212 of file elem.C.

References libMesh::ElemInternal::total_family_tree_by_neighbor().

2215 {
2216  ElemInternal::total_family_tree_by_neighbor(this, family, neighbor, reset);
2217 }
void total_family_tree_by_neighbor(T elem, std::vector< T > &family, T neighbor_in, bool reset=true)

◆ total_family_tree_by_subneighbor() [1/2]

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

Same as the family_tree_by_subneighbor() member, but also adds any subactive descendants.

Definition at line 2241 of file elem.C.

References libMesh::ElemInternal::total_family_tree_by_subneighbor().

2245 {
2246  ElemInternal::total_family_tree_by_subneighbor(this, family, neighbor, subneighbor, reset);
2247 }
void total_family_tree_by_subneighbor(T elem, std::vector< T > &family, T neighbor_in, T subneighbor, bool reset=true)

◆ total_family_tree_by_subneighbor() [2/2]

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

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

Definition at line 2251 of file elem.C.

References libMesh::ElemInternal::total_family_tree_by_subneighbor().

2255 {
2256  ElemInternal::total_family_tree_by_subneighbor(this, family, neighbor, subneighbor, reset);
2257 }
void total_family_tree_by_subneighbor(T elem, std::vector< T > &family, T neighbor_in, T subneighbor, bool reset=true)

◆ true_centroid()

Point libMesh::Elem::true_centroid ( ) const
virtualinherited
Returns
The "true" geometric centroid of the element, c=(cx, cy, cz), where:

[cx] [ x dV] [cy] := (1/V) * [ y dV] [cz] [ 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::Tet4, libMesh::Hex8, libMesh::Prism6, libMesh::C0Polygon, libMesh::Pyramid5, libMesh::Tri3, libMesh::C0Polyhedron, libMesh::Quad4, and libMesh::Edge2.

Definition at line 594 of file elem.C.

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(), libMesh::Real, and libMesh::QBase::size().

Referenced by VolumeTest::testHex20PLevelTrueCentroid(), VolumeTest::testPyramid5TrueCentroid(), VolumeTest::testQuad4TrueCentroid(), VolumeTest::testTri3TrueCentroid(), libMesh::C0Polyhedron::true_centroid(), and libMesh::C0Polygon::true_centroid().

595 {
596  // The base class implementation builds a finite element of the correct
597  // order and computes the centroid, c=(cx, cy, cz), where:
598  //
599  // [cx] [\int x dV]
600  // [cy] := (1/V) * [\int y dV]
601  // [cz] [\int z dV]
602  //
603  // using quadrature. Note that we can expand "x" in the FE space as:
604  //
605  // x = \sum_i x_i \phi_i
606  //
607  // where x_i are the nodal positions of the element and \phi_i are the
608  // associated Lagrange shape functions. This allows us to write the
609  // integrals above as e.g.:
610  //
611  // \int x dV = \sum_i x_i \int \phi_i dV
612  //
613  // Defining:
614  //
615  // V_i := \int \phi_i dV
616  //
617  // we then have:
618  //
619  // [cx] [\sum_i x_i V_i]
620  // [cy] = (1/V) * [\sum_i y_i V_i]
621  // [cz] [\sum_i z_i V_i]
622  //
623  // where:
624  // V = \sum_i V_i
625  //
626  // Derived element types can overload this method to compute
627  // the centroid more efficiently when possible.
628 
629  // If this Elem has an elevated p_level, then we need to generate a
630  // barebones copy of it with zero p_level and call true_centroid()
631  // on that instead. This workaround allows us to avoid issues with
632  // calling FE::reinit() with a default_order() FEType, and then
633  // having that order incorrectly boosted by p_level.
634  if (this->p_level())
635  {
636  auto elem_copy = this->disconnected_clone();
637 #ifdef LIBMESH_ENABLE_AMR
638  elem_copy->set_p_level(0);
639 #endif
640 
641  // Set node pointers
642  for (auto n : this->node_index_range())
643  elem_copy->set_node(n, _nodes[n]);
644 
645  return elem_copy->true_centroid();
646  }
647 
648  const FEFamily mapping_family = FEMap::map_fe_type(*this);
649  const FEType fe_type(this->default_order(), mapping_family);
650 
651  // Build FE and attach quadrature rule. The default quadrature rule
652  // integrates the mass matrix exactly, thus it is overkill to
653  // integrate the basis functions, but this is convenient.
654  std::unique_ptr<FEBase> fe = FEBase::build(this->dim(), fe_type);
655  QGauss qrule (this->dim(), fe_type.default_quadrature_order());
656  fe->attach_quadrature_rule(&qrule);
657 
658  // Pre-request required data
659  const auto & JxW = fe->get_JxW();
660  const auto & phi = fe->get_phi();
661 
662  // Re-compute element-specific values
663  fe->reinit(this);
664 
665  // Number of basis functions
666  auto N = phi.size();
667  libmesh_assert_equal_to(N, this->n_nodes());
668 
669  // Compute V_i
670  std::vector<Real> V(N);
671  for (auto qp : index_range(JxW))
672  for (auto i : make_range(N))
673  V[i] += JxW[qp] * phi[i][qp];
674 
675  // Compute centroid
676  Point cp;
677  Real vol = 0.;
678 
679  for (auto i : make_range(N))
680  {
681  cp += this->point(i) * V[i];
682  vol += V[i];
683  }
684 
685  return cp / vol;
686 }
Node ** _nodes
Pointers to the nodes we are connected to.
Definition: elem.h:2245
unsigned int p_level() const
Definition: elem.h:3108
virtual unsigned int n_nodes() const =0
static std::unique_ptr< FEGenericBase > build(const unsigned int dim, const FEType &type)
Builds a specific finite element type.
virtual std::unique_ptr< Elem > disconnected_clone() const
Definition: elem.C:412
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
virtual unsigned short dim() const =0
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140
IntRange< unsigned short > node_index_range() const
Definition: elem.h:2683
FEFamily
defines an enum for finite element families.
virtual Order default_order() const =0
const Point & point(const unsigned int i) const
Definition: elem.h:2453
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:117
static FEFamily map_fe_type(const Elem &elem)
Definition: fe_map.C:46

◆ type()

virtual ElemType libMesh::InfEdge2::type ( ) const
inlineoverridevirtual
Returns
INFEDGE2.

Implements libMesh::Elem.

Definition at line 123 of file edge_inf_edge2.h.

References libMesh::INFEDGE2.

123 { return INFEDGE2; }

◆ unique_id()

unique_id_type libMesh::DofObject::unique_id ( ) const
inlineinherited
Returns
The globally unique_id for this DofObject

Definition at line 844 of file dof_object.h.

References libMesh::DofObject::_unique_id, libMesh::DofObject::invalid_unique_id, libMesh::libmesh_assert(), and libMesh::DofObject::valid_unique_id().

Referenced by libMesh::ReplicatedMesh::add_elem(), libMesh::DistributedMesh::add_elem(), libMesh::ReplicatedMesh::add_node(), libMesh::DistributedMesh::add_node(), libMesh::ReplicatedMesh::add_point(), libMesh::MeshTools::Modification::all_tri(), libMesh::C0Polyhedron::disconnected_clone(), libMesh::Elem::disconnected_clone(), libMesh::MeshTools::Modification::flatten(), libMesh::Elem::get_info(), libMesh::ReplicatedMesh::insert_elem(), libMesh::DistributedMesh::insert_elem(), libMesh::ReplicatedMesh::insert_node(), libMesh::XdrIO::pack_element(), libMesh::ExodusII_IO::read_elemental_variable(), SlitMeshRefinedSystemTest::testRestart(), and libMesh::XdrIO::write_serialized_nodes().

845 {
846 #ifdef LIBMESH_ENABLE_UNIQUE_ID
848  return _unique_id;
849 #else
850  return invalid_unique_id;
851 #endif
852 }
unique_id_type _unique_id
A globally unique id, guaranteed not to change as the mesh is repartitioned or adapted.
Definition: dof_object.h:577
static const unique_id_type invalid_unique_id
An invalid unique_id to distinguish an uninitialized DofObject.
Definition: dof_object.h:487
libmesh_assert(ctx)
bool valid_unique_id() const
Definition: dof_object.h:893

◆ unpack_indexing()

void libMesh::DofObject::unpack_indexing ( std::vector< largest_id_type >::const_iterator  begin)
inherited

A method for creating our index buffer from packed data - basically with our current implementation we investigate the size term and then copy.

Definition at line 595 of file dof_object.C.

References libMesh::DofObject::_idx_buf, libMesh::DofObject::clear_old_dof_object(), libMesh::DofObject::construct(), libMesh::libmesh_assert(), and libMesh::DofObject::old_dof_object.

596 {
597  _idx_buf.clear();
598 
599 #ifdef LIBMESH_ENABLE_AMR
600  this->clear_old_dof_object();
601  const bool has_old_dof_object = cast_int<bool>(*begin++);
602 #endif
603 
604  const largest_id_type size = *begin++;
605  _idx_buf.reserve(size);
606  std::copy(begin, begin+size, back_inserter(_idx_buf));
607 
608  // Check as best we can for internal consistency now
609  libmesh_assert(_idx_buf.empty() ||
610  (std::abs(dof_id_signed_type(_idx_buf[0])) <=
611  cast_int<dof_id_signed_type>(_idx_buf.size())));
612 #ifdef DEBUG
613  if (!_idx_buf.empty())
614  {
615  const int hdr = cast_int<int>(dof_id_signed_type(_idx_buf[0]));
616  const unsigned int ns = hdr >= 0 ? hdr : (-hdr-1);
617  for (unsigned int i=1; i < ns; ++i)
618  {
619  if (hdr > 0 || i > 1)
620  libmesh_assert_greater_equal (_idx_buf[i], _idx_buf[i-1]);
621  else
622  libmesh_assert_greater_equal (_idx_buf[i], ns);
623  libmesh_assert_equal_to ((_idx_buf[i] - _idx_buf[i-1])%2, 0);
624  libmesh_assert_less_equal (_idx_buf[i], _idx_buf.size());
625  }
626  if (hdr < 0 && ns > 0)
627  libmesh_assert_less_equal(_idx_buf[ns], _idx_buf.size());
628  }
629 #endif
630 
631 #ifdef LIBMESH_ENABLE_AMR
632  if (has_old_dof_object)
633  {
634  this->old_dof_object = this->construct();
635  this->old_dof_object->unpack_indexing(begin+size);
636  }
637 #endif
638 }
std::unique_ptr< DofObject > construct(const DofObject *other=nullptr)
Convenient factory function that calls either the (deep) copy constructor or the default constructor ...
Definition: dof_object.h:741
uint64_t largest_id_type
Definition: id_types.h:148
void clear_old_dof_object()
Sets the old_dof_object to nullptr.
Definition: dof_object.C:128
libmesh_assert(ctx)
int8_t dof_id_signed_type
Definition: id_types.h:68
std::unique_ptr< DofObject > old_dof_object
This object on the last mesh.
Definition: dof_object.h:88
index_buffer_t _idx_buf
Definition: dof_object.h:680

◆ unpackable_indexing_size()

unsigned int libMesh::DofObject::unpackable_indexing_size ( std::vector< largest_id_type >::const_iterator  begin)
staticinherited

If we have indices packed into an buffer for communications, how much of that buffer applies to this dof object?

Definition at line 575 of file dof_object.C.

576 {
577 #ifdef LIBMESH_ENABLE_AMR
578  const bool has_old_dof_object = cast_int<bool>(*begin++);
579 
580  static const int dof_header_size = 2;
581 #else
582  static const bool has_old_dof_object = false;
583  static const int dof_header_size = 1;
584 #endif
585 
586  const largest_id_type this_indexing_size = *begin++;
587 
588  return cast_int<unsigned int>
589  (dof_header_size + this_indexing_size +
590  (has_old_dof_object ?
591  unpackable_indexing_size(begin+this_indexing_size) : 0));
592 }
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:575
uint64_t largest_id_type
Definition: id_types.h:148

◆ valid_id()

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

◆ valid_processor_id()

bool libMesh::DofObject::valid_processor_id ( ) const
inlineinherited
Returns
true if this DofObject has a valid id set, false otherwise.

Definition at line 929 of file dof_object.h.

References libMesh::DofObject::_processor_id, and libMesh::DofObject::invalid_processor_id.

Referenced by DofObjectTest< Node >::testInvalidateProcId(), and DofObjectTest< Node >::testValidProcId().

930 {
932 }
static const processor_id_type invalid_processor_id
An invalid processor_id to distinguish DoFs that have not been assigned to a processor.
Definition: dof_object.h:493
processor_id_type _processor_id
The processor_id of the DofObject.
Definition: dof_object.h:594

◆ valid_unique_id()

bool libMesh::DofObject::valid_unique_id ( ) const
inlineinherited
Returns
true if this DofObject has a valid unique_id set, false otherwise.

Definition at line 893 of file dof_object.h.

References libMesh::DofObject::_unique_id, and libMesh::DofObject::invalid_unique_id.

Referenced by libMesh::ReplicatedMesh::add_elem(), libMesh::DistributedMesh::add_elem(), libMesh::ReplicatedMesh::add_node(), libMesh::DistributedMesh::add_node(), libMesh::ReplicatedMesh::add_point(), libMesh::C0Polyhedron::disconnected_clone(), libMesh::Elem::disconnected_clone(), libMesh::Elem::get_info(), libMesh::ReplicatedMesh::insert_elem(), libMesh::DistributedMesh::insert_elem(), libMesh::ReplicatedMesh::insert_node(), and libMesh::DofObject::unique_id().

894 {
895 #ifdef LIBMESH_ENABLE_UNIQUE_ID
897 #else
898  return false;
899 #endif
900 }
unique_id_type _unique_id
A globally unique id, guaranteed not to change as the mesh is repartitioned or adapted.
Definition: dof_object.h:577
static const unique_id_type invalid_unique_id
An invalid unique_id to distinguish an uninitialized DofObject.
Definition: dof_object.h:487

◆ var_to_vg_and_offset()

std::pair< unsigned int, unsigned int > libMesh::DofObject::var_to_vg_and_offset ( const unsigned int  s,
const unsigned int  var 
) const
inlineinherited
Returns
A pair consisting of the variable group number and the offset index from the start of that group for variable var on system s associated with this DofObject

Definition at line 1200 of file dof_object.h.

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

Referenced by libMesh::DofMap::_dof_indices(), libMesh::DofMap::_node_dof_indices(), libMesh::DofObject::dof_number(), libMesh::OldSolutionCoefs< Output, point_output >::eval_old_dofs(), and libMesh::OldSolutionValue< Output, point_output >::eval_old_dofs().

1202 {
1203  std::pair<unsigned int, unsigned int> returnval(0,0);
1204 
1205  unsigned int & vg = returnval.first;
1206  unsigned int & offset = returnval.second;
1207 
1208  unsigned int vg_start = 0;
1209  for (; ; vg++)
1210  {
1211  libmesh_assert_less(vg, this->n_var_groups(s));
1212 
1213  const unsigned int vg_end = vg_start + this->n_vars(s,vg);
1214  if (var < vg_end)
1215  {
1216  offset = var - vg_start;
1217  return returnval;
1218  }
1219  vg_start = vg_end;
1220  }
1221 }
unsigned int n_var_groups(const unsigned int s) const
Definition: dof_object.h:957
unsigned int n_vars(const unsigned int s, const unsigned int vg) const
Definition: dof_object.h:967

◆ vertex_average()

Point libMesh::Elem::vertex_average ( ) const
inherited
Returns
A Point at the average of the elment's vertices.
Note
This used to be the base class centroid() implementation, but the centroid is only equal to the vertex average in some special cases. The centroid() implementation now returns the "true" centroid of the element (up to quadrature error).

Definition at line 688 of file elem.C.

References libMesh::TypeVector< T >::add(), and libMesh::Elem::n_vertices().

Referenced by libMesh::Elem::centroid(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::BoundaryInfo::get_side_and_node_maps(), libMesh::Poly2TriTriangulator::insert_refinement_points(), A0::interior_assembly(), A1::interior_assembly(), OutputAssembly::interior_assembly(), SlitFunc::operator()(), libMesh::LocationMap< T >::point_of(), libMesh::RBParametrizedFunction::preevaluate_parametrized_function_on_mesh(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::C0Polygon::retriangulate(), libMesh::FE< Dim, LAGRANGE_VEC >::shape_deriv(), libMesh::FE< Dim, LAGRANGE_VEC >::shape_second_deriv(), DefaultCouplingTest::testCoupling(), PointNeighborCouplingTest::testCoupling(), libMesh::Tri3::true_centroid(), and libMesh::Tet4::true_centroid().

689 {
690  Point cp;
691 
692  const auto n_vertices = this->n_vertices();
693 
694  for (unsigned int n=0; n<n_vertices; n++)
695  cp.add (this->point(n));
696 
697  return (cp /= static_cast<Real>(n_vertices));
698 }
virtual unsigned int n_vertices() const =0

◆ vg_dof_base()

dof_id_type libMesh::DofObject::vg_dof_base ( const unsigned int  s,
const unsigned int  vg 
) const
inlineinherited

VariableGroup DoF indices are indexed as id = base + var_in_vg*ncomp + comp This method allows for direct access to the base.

Definition at line 1317 of file dof_object.h.

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

Referenced by libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DofMap::reinit(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::DofObject::set_vg_dof_base(), and DofObjectTest< Node >::testManualDofCalculation().

1319 {
1320  libmesh_assert_less (s, this->n_systems());
1321  libmesh_assert_less (vg, this->n_var_groups(s));
1322 
1323  const unsigned int
1324  start_idx_sys = this->start_idx(s);
1325 
1326  libmesh_assert_less ((start_idx_sys + 2*vg + 1), _idx_buf.size());
1327 
1328  // #ifdef DEBUG
1329  // std::cout << " [ ";
1330  // for (auto i : _idx_buf)
1331  // std::cout << i << " ";
1332  // std::cout << "]\n";
1333  // #endif
1334 
1335  return _idx_buf[start_idx_sys + 2*vg + 1];
1336 }
unsigned int n_var_groups(const unsigned int s) const
Definition: dof_object.h:957
unsigned int n_systems() const
Definition: dof_object.h:937
unsigned int start_idx(const unsigned int s) const
The starting index for system s.
Definition: dof_object.h:1249
index_buffer_t _idx_buf
Definition: dof_object.h:680

◆ volume()

Real libMesh::Elem::volume ( ) const
virtualinherited
Returns
The (length/area/volume) of the geometric element.

If the element is twisted or inverted such that the mapping Jacobian is singular at any point, implementations of this method may return a "net" volume or may simply return NaN.

Reimplemented in libMesh::Prism18, libMesh::Hex27, libMesh::Pyramid14, libMesh::Prism15, libMesh::Tet10, libMesh::Hex20, libMesh::Pyramid13, libMesh::Tet4, libMesh::Tri6, libMesh::Quad9, libMesh::Hex8, libMesh::Quad8, libMesh::Prism6, libMesh::Edge4, libMesh::Pyramid5, libMesh::Tri3, libMesh::C0Polygon, libMesh::Quad4, libMesh::Edge3, libMesh::C0Polyhedron, and libMesh::Edge2.

Definition at line 3429 of file elem.C.

References libMesh::FEGenericBase< OutputType >::build(), libMesh::Elem::default_order(), libMesh::FEType::default_quadrature_order(), libMesh::Elem::dim(), libMesh::FEMap::map_fe_type(), and libMesh::Real.

Referenced by assemble_ellipticdg(), libMesh::Elem::get_info(), libMesh::MeshBase::get_info(), libMesh::QNodal::init_3D(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::SimplexRefiner::should_refine_elem(), libMesh::Poly2TriTriangulator::should_refine_elem(), VolumeTest::testC0Polygon(), VolumeTest::testC0Polyhedron(), MeshInputTest::testTetgenIO(), VolumeTest::testTwistedVolume(), libMesh::C0Polyhedron::volume(), libMesh::C0Polygon::volume(), libMesh::Quad8::volume(), libMesh::Quad9::volume(), libMesh::Tri6::volume(), libMesh::Pyramid13::volume(), libMesh::Hex20::volume(), libMesh::Tet10::volume(), libMesh::Prism15::volume(), libMesh::Pyramid14::volume(), libMesh::Hex27::volume(), and libMesh::Prism18::volume().

3430 {
3431  // The default implementation builds a finite element of the correct
3432  // order and sums up the JxW contributions. This can be expensive,
3433  // so the various element types can overload this method and compute
3434  // the volume more efficiently.
3435  const FEFamily mapping_family = FEMap::map_fe_type(*this);
3436  const FEType fe_type(this->default_order(), mapping_family);
3437 
3438  std::unique_ptr<FEBase> fe (FEBase::build(this->dim(),
3439  fe_type));
3440 
3441  // Use a map with a negative Jacobian tolerance, in case we're asked
3442  // for the net volume of a tangled element
3443  fe->get_fe_map().set_jacobian_tolerance(std::numeric_limits<Real>::lowest());
3444 
3445  const std::vector<Real> & JxW = fe->get_JxW();
3446 
3447  // The default quadrature rule should integrate the mass matrix,
3448  // thus it should be plenty to compute the area
3449  QGauss qrule (this->dim(), fe_type.default_quadrature_order());
3450 
3451  fe->attach_quadrature_rule(&qrule);
3452 
3453  fe->reinit(this);
3454 
3455  Real vol=0.;
3456  for (auto jxw : JxW)
3457  vol += jxw;
3458 
3459  return vol;
3460 
3461 }
static std::unique_ptr< FEGenericBase > build(const unsigned int dim, const FEType &type)
Builds a specific finite element type.
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
virtual unsigned short dim() const =0
FEFamily
defines an enum for finite element families.
virtual Order default_order() const =0
static FEFamily map_fe_type(const Elem &elem)
Definition: fe_map.C:46

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

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

Referenced by libMesh::BoundaryInfo::boundary_ids(), libMesh::BoundaryInfo::edge_boundary_ids(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::Elem::make_links_to_me_remote(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectVertices::operator()(), libMesh::BoundaryInfo::side_with_boundary_id(), libMesh::BoundaryInfo::sides_with_boundary_id(), libMesh::MeshTools::Modification::smooth(), and libMesh::Parallel::sync_element_data_by_parent_id().

3193 {
3194  libmesh_assert(e);
3195  libmesh_assert (this->has_children());
3196 
3197  unsigned int nc = this->n_children();
3198  for (unsigned int c=0; c != nc; c++)
3199  if (this->child_ptr(c) == e)
3200  return c;
3201 
3202  libmesh_error_msg("ERROR: which_child_am_i() was called with a non-child!");
3203 
3204  return libMesh::invalid_uint;
3205 }
const unsigned int invalid_uint
A number which is used quite often to represent an invalid or uninitialized value for an unsigned int...
Definition: libmesh.h:310
virtual unsigned int n_children() const =0
libmesh_assert(ctx)
bool has_children() const
Definition: elem.h:2979
const Elem * child_ptr(unsigned int i) const
Definition: elem.h:3163

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

References libMesh::invalid_uint, libMesh::Elem::level(), libMesh::libmesh_assert(), libMesh::make_range(), libMesh::Elem::n_sides(), libMesh::Elem::neighbor_ptr(), and libMesh::Elem::parent().

Referenced by assemble_ellipticdg(), libMesh::EquationSystems::build_discontinuous_solution_vector(), libMesh::BoundaryInfo::clear_stitched_boundary_side_ids(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_proj_constraints(), libMesh::MeshTools::find_hanging_nodes_and_parents(), libMesh::Poly2TriTriangulator::insert_refinement_points(), libMesh::Elem::libmesh_assert_valid_neighbors(), libMesh::Elem::nullify_neighbors(), libMesh::C0Polyhedron::retriangulate(), and MeshBaseTest::testMeshBaseVerifyIsPrepared().

2920 {
2921  libmesh_assert(e);
2922 
2923  const Elem * eparent = e;
2924 
2925  while (eparent->level() > this->level())
2926  {
2927  eparent = eparent->parent();
2928  libmesh_assert(eparent);
2929  }
2930 
2931  for (auto s : make_range(this->n_sides()))
2932  if (this->neighbor_ptr(s) == eparent)
2933  return s;
2934 
2935  return libMesh::invalid_uint;
2936 }
const unsigned int invalid_uint
A number which is used quite often to represent an invalid or uninitialized value for an unsigned int...
Definition: libmesh.h:310
libmesh_assert(ctx)
Elem(const unsigned int n_nodes, const unsigned int n_sides, Elem *parent, Elem **elemlinkdata, Node **nodelinkdata)
Constructor.
Definition: elem.h:2378
virtual unsigned int n_sides() const =0
const Elem * neighbor_ptr(unsigned int i) const
Definition: elem.h:2598
unsigned int level() const
Definition: elem.h:3074
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140

◆ which_node_am_i()

unsigned int libMesh::Elem::which_node_am_i ( unsigned int  side,
unsigned int  side_node 
) const
inherited

This function is deprecated, call local_side_node(side, side_node) instead.

Definition at line 924 of file elem.C.

References libMesh::Elem::local_side_node().

926 {
927  libmesh_deprecated();
928  return local_side_node(side, side_node);
929 }
virtual unsigned int local_side_node(unsigned int side, unsigned int side_node) const =0

◆ which_side_am_i()

unsigned int libMesh::Elem::which_side_am_i ( const Elem e) const
inherited

This function tells you which side the boundary element e is.

I.e. if e = a->build_side_ptr(s) or e = a->side_ptr(s); then a->which_side_am_i(e) will be s.

Note
An exact floating point comparison of the nodal positions of e is made with the nodal positions of this in order to perform this test. The idea is that the test will return a valid side id if e either directly shares Node pointers with this, or was created by exactly copying some of the nodes of this (e.g. through BoundaryMesh::sync()). In these circumstances, non-fuzzy floating point equality is expected.
Returns
The side of this the element which e is, otherwise invalid_uint.

Definition at line 870 of file elem.C.

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

871 {
872  libmesh_assert(e);
873 
874  const unsigned int ns = this->n_sides();
875  const unsigned int nn = this->n_nodes();
876 
877  const unsigned int en = e->n_nodes();
878 
879  // e might be on any side until proven otherwise
880  std::vector<bool> might_be_side(ns, true);
881 
882  for (unsigned int i=0; i != en; ++i)
883  {
884  Point side_point = e->point(i);
885  unsigned int local_node_id = libMesh::invalid_uint;
886 
887  // Look for a node of this that's contiguous with node i of
888  // e. Note that the exact floating point comparison of Point
889  // positions is intentional, see the class documentation for
890  // this function.
891  for (unsigned int j=0; j != nn; ++j)
892  if (this->point(j) == side_point)
893  local_node_id = j;
894 
895  // If a node of e isn't contiguous with some node of this, then
896  // e isn't a side of this.
897  if (local_node_id == libMesh::invalid_uint)
898  return libMesh::invalid_uint;
899 
900  // If a node of e isn't contiguous with some node on side s of
901  // this, then e isn't on side s.
902  for (unsigned int s=0; s != ns; ++s)
903  if (!this->is_node_on_side(local_node_id, s))
904  might_be_side[s] = false;
905  }
906 
907  for (unsigned int s=0; s != ns; ++s)
908  if (might_be_side[s])
909  {
910 #ifdef DEBUG
911  for (unsigned int s2=s+1; s2 < ns; ++s2)
912  libmesh_assert (!might_be_side[s2]);
913 #endif
914  return s;
915  }
916 
917  // Didn't find any matching side
918  return libMesh::invalid_uint;
919 }
const unsigned int invalid_uint
A number which is used quite often to represent an invalid or uninitialized value for an unsigned int...
Definition: libmesh.h:310
virtual bool is_node_on_side(const unsigned int n, const unsigned int s) const =0
virtual unsigned int n_nodes() const =0
libmesh_assert(ctx)
virtual unsigned int n_sides() const =0
const Point & point(const unsigned int i) const
Definition: elem.h:2453

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

References libMesh::Elem::_nodes, libMesh::Elem::connectivity(), libMesh::INVALID_IO_PACKAGE, libMesh::libmesh_assert(), libMesh::make_range(), libMesh::Elem::n_sub_elem(), libMesh::Elem::node_id(), libMesh::Elem::node_index_range(), libMesh::TECPLOT, and libMesh::UCD.

1733 {
1734  libmesh_assert (out_stream.good());
1736  libmesh_assert_not_equal_to (iop, INVALID_IO_PACKAGE);
1737 
1738  switch (iop)
1739  {
1740  case TECPLOT:
1741  {
1742  // This connectivity vector will be used repeatedly instead
1743  // of being reconstructed inside the loop.
1744  std::vector<dof_id_type> conn;
1745  for (auto sc : make_range(this->n_sub_elem()))
1746  {
1747  this->connectivity(sc, TECPLOT, conn);
1748 
1749  std::copy(conn.begin(),
1750  conn.end(),
1751  std::ostream_iterator<dof_id_type>(out_stream, " "));
1752 
1753  out_stream << '\n';
1754  }
1755  return;
1756  }
1757 
1758  case UCD:
1759  {
1760  for (auto i : this->node_index_range())
1761  out_stream << this->node_id(i)+1 << "\t";
1762 
1763  out_stream << '\n';
1764  return;
1765  }
1766 
1767  default:
1768  libmesh_error_msg("Unsupported IO package " << iop);
1769  }
1770 }
Node ** _nodes
Pointers to the nodes we are connected to.
Definition: elem.h:2245
libmesh_assert(ctx)
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140
virtual void connectivity(const unsigned int sc, const IOPackage iop, std::vector< dof_id_type > &conn) const =0
IntRange< unsigned short > node_index_range() const
Definition: elem.h:2683
virtual unsigned int n_sub_elem() const =0
dof_id_type node_id(const unsigned int i) const
Definition: elem.h:2475

Member Data Documentation

◆ _children

std::unique_ptr<Elem *[]> libMesh::Elem::_children
protectedinherited

unique_ptr to array of this element's children.

A Mesh ultimately owns the child Elems so we are not responsible for deleting them, but we are responsible for cleaning up the array allocated to hold those Elems, hence the unique_ptr.

Definition at line 2261 of file elem.h.

Referenced by libMesh::Elem::add_child(), libMesh::Elem::child_ptr(), libMesh::Elem::child_ref_range(), libMesh::Elem::contract(), libMesh::Elem::has_ancestor_children(), libMesh::Elem::has_children(), libMesh::Elem::raw_child_ptr(), libMesh::Elem::refine(), and libMesh::Elem::set_child().

◆ _counts [1/2]

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts
staticprotectedinherited

Actually holds the data.

Definition at line 124 of file reference_counter.h.

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

◆ _counts [2/2]

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts
staticprotectedinherited

Actually holds the data.

Definition at line 124 of file reference_counter.h.

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

◆ _elemlinks

Elem** libMesh::Elem::_elemlinks
protectedinherited

◆ _elemlinks_data

Elem* libMesh::Edge::_elemlinks_data[3+(LIBMESH_DIM >1)]
protectedinherited

Data for links to parent/neighbor/interior_parent elements.

Definition at line 247 of file edge.h.

◆ _enable_print_counter [1/2]

bool libMesh::ReferenceCounter::_enable_print_counter = true
staticprotectedinherited

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

Definition at line 143 of file reference_counter.h.

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

◆ _enable_print_counter [2/2]

bool libMesh::ReferenceCounter::_enable_print_counter = true
staticprotectedinherited

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

Definition at line 143 of file reference_counter.h.

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

◆ _map_data

unsigned char libMesh::Elem::_map_data
protectedinherited

Mapping function data; currently used when needed to store the RATIONAL_BERNSTEIN nodal weight data index.

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

◆ _mutex [1/2]

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

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 137 of file reference_counter.h.

◆ _mutex [2/2]

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

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 137 of file reference_counter.h.

◆ _n_objects [1/2]

Threads::atomic< unsigned int > libMesh::ReferenceCounter::_n_objects
staticprotectedinherited

The number of objects.

Print the reference count information when the number returns to 0.

Definition at line 132 of file reference_counter.h.

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

◆ _n_objects [2/2]

Threads::atomic< unsigned int > libMesh::ReferenceCounter::_n_objects
staticprotectedinherited

The number of objects.

Print the reference count information when the number returns to 0.

Definition at line 132 of file reference_counter.h.

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

◆ _nodelinks_data

Node* libMesh::InfEdge2::_nodelinks_data[2]
protected

Data for links to nodes.

Definition at line 166 of file edge_inf_edge2.h.

◆ _nodes

Node** libMesh::Elem::_nodes
protectedinherited

◆ _p_level

unsigned char libMesh::Elem::_p_level
protectedinherited

p refinement level - the difference between the polynomial degree on this element and the minimum polynomial degree on the mesh.

This is stored as an unsigned char to save space. In theory, these last four bytes might have been padding anyway.

Definition at line 2290 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 2280 of file elem.h.

Referenced by libMesh::Elem::hack_p_level_and_refinement_flag(), libMesh::Elem::p_refinement_flag(), and libMesh::Elem::set_p_refinement_flag().

◆ _rflag

unsigned char libMesh::Elem::_rflag
protectedinherited

h refinement flag.

This is stored as an unsigned char to save space.

Definition at line 2274 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 2267 of file elem.h.

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

◆ affine_tol

constexpr Real libMesh::Elem::affine_tol = TOLERANCE*TOLERANCE
staticprotectedinherited

◆ invalid_id

const dof_id_type libMesh::DofObject::invalid_id = static_cast<dof_id_type>(-1)
staticinherited

An invalid id to distinguish an uninitialized DofObject.

Definition at line 482 of file dof_object.h.

Referenced by libMesh::DofMap::_dof_indices(), libMesh::DofMap::_node_dof_indices(), libMesh::Node::active(), libMesh::MeshBase::add_elem_datum(), libMesh::MeshBase::add_elem_integers(), libMesh::DofObject::add_extra_integers(), libMesh::StaticCondensation::add_matrix(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::TopologyMap::add_node(), libMesh::MeshRefinement::add_node(), libMesh::MeshBase::add_node_datum(), libMesh::MeshBase::add_node_integers(), libMesh::ReplicatedMesh::add_point(), libMesh::MeshTools::Modification::all_tri(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::DofMap::assert_no_nodes_missed(), libMesh::Elem::bracketing_nodes(), ExtraIntegersTest::checkpoint_helper(), libMesh::StaticCondensation::clear(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_proj_constraints(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DofMap::dof_indices(), libMesh::DofObject::dof_number(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_nodes(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_sides(), libMesh::OldSolutionValue< Output, point_output >::eval_old_dofs(), libMesh::TopologyMap::find(), libMesh::DofMap::gather_constraints(), libMesh::MeshBase::get_elemset_code(), libMesh::ReplicatedMesh::insert_node(), libMesh::Poly2TriTriangulator::insert_refinement_points(), libMesh::Elem::interior_parent(), libMesh::DofObject::invalidate_dofs(), libMesh::DofObject::invalidate_id(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::Node::Node(), libMesh::Elem::node_id(), libMesh::DofMap::old_dof_indices(), libMesh::DistributedMesh::own_node(), libMesh::XdrIO::pack_element(), libMesh::SFCPartitioner::partition_range(), libMesh::Elem::point(), libMesh::ExodusII_IO::read(), libMesh::System::read_legacy_data(), libMesh::DynaIO::read_mesh(), libMesh::System::read_parallel_data(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::StaticCondensationDofMap::reinit(), libMesh::DofMap::SCALAR_dof_indices(), libMesh::DofObject::set_dof_number(), libMesh::DofObject::set_n_comp_group(), libMesh::DofObject::set_n_vars_per_group(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Parallel::sync_node_data_by_element_id_once(), ExtraIntegersTest::test_and_set_initial_data(), DofObjectTest< Node >::testAddExtraData(), DofObjectTest< Node >::testAddSystemExtraInts(), NodalNeighborsTest::testEdge2(), NodalNeighborsTest::testEdge3(), NodalNeighborsTest::testEdge4(), ExtraIntegersTest::testExtraIntegersExodusReading(), InfFERadialTest::testRefinement(), DofObjectTest< Node >::testSetNSystemsExtraInts(), DofObjectTest< Node >::testSetNVariableGroupsExtraInts(), MeshTetTest::testTetInterfaceBase(), DofObjectTest< Node >::testValidId(), WriteElemsetData::testWriteImpl(), libMesh::Poly2TriTriangulator::triangulate_current_points(), libMesh::DofObject::valid_id(), libMesh::System::write_parallel_data(), and libMesh::XdrIO::write_serialized_connectivity().

◆ invalid_processor_id

const processor_id_type libMesh::DofObject::invalid_processor_id = static_cast<processor_id_type>(-1)
staticinherited

An invalid processor_id to distinguish DoFs that have not been assigned to a processor.

Definition at line 493 of file dof_object.h.

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::DistributedMesh::add_elem(), libMesh::DistributedMesh::add_node(), libMesh::MeshRefinement::add_node(), libMesh::MeshCommunication::allgather(), libMesh::Node::choose_processor_id(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubProjector::construct_projection(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::MeshTools::create_bounding_box(), libMesh::MeshTools::create_nodal_bounding_box(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::Elem::Elem(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::find_dofs_to_send(), libMesh::MeshCommunication::find_global_indices(), libMesh::MeshBase::get_info(), libMesh::DistributedMesh::insert_elem(), libMesh::DofObject::invalidate_processor_id(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::MeshCommunication::make_new_node_proc_ids_parallel_consistent(), libMesh::DistributedMesh::n_active_elem(), libMesh::MeshBase::n_constraint_rows(), libMesh::MeshBase::n_elem_on_proc(), libMesh::MeshBase::n_nodes_on_proc(), libMesh::MeshBase::n_unpartitioned_elem(), libMesh::MeshBase::n_unpartitioned_nodes(), libMesh::SparsityPattern::Build::operator()(), libMesh::Partitioner::processor_pairs_to_interface_nodes(), libMesh::Nemesis_IO_Helper::read_var_names_impl(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DistributedMesh::renumber_nodes_and_elements(), OverlappingFunctorTest::run_coupling_functor_test(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::send_and_insert_dof_values(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::Parallel::sync_dofobject_data_by_id(), libMesh::Parallel::sync_dofobject_data_by_xyz(), libMesh::Parallel::sync_element_data_by_parent_id(), libMesh::Parallel::sync_node_data_by_element_id_once(), DofObjectTest< Node >::testValidProcId(), libMesh::MeshTools::total_weight(), libMesh::DofObject::valid_processor_id(), and libMesh::CheckpointIO::write().

◆ invalid_subdomain_id

const subdomain_id_type libMesh::Elem::invalid_subdomain_id = std::numeric_limits<subdomain_id_type>::max()
staticinherited

A static integral constant representing an invalid subdomain id.

See also DofObject::{invalid_id, invalid_unique_id, invalid_processor_id}.

Note
We don't use the static_cast(-1) trick here since subdomain_id_type is sometimes a signed integer for compatibility reasons (see libmesh/id_types.h).
Normally you can declare static const integral types directly in the header file (C++ standard, 9.4.2/4) but std::numeric_limits<T>::max() is not considered a "constant expression". This one is therefore defined in elem.C. http://stackoverflow.com/questions/2738435/using-numeric-limitsmax-in-constant-expressions

Definition at line 251 of file elem.h.

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::BoundaryInfo::add_elements(), libMesh::ReplicatedMesh::get_disconnected_subdomains(), libMesh::MeshBase::get_id_by_name(), libMesh::BoundaryInfo::sync(), and MeshSubdomainIDTest::testMultiple().

◆ invalid_unique_id

const unique_id_type libMesh::DofObject::invalid_unique_id = static_cast<unique_id_type>(-1)
staticinherited

An invalid unique_id to distinguish an uninitialized DofObject.

Definition at line 487 of file dof_object.h.

Referenced by libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DofObject::unique_id(), and libMesh::DofObject::valid_unique_id().

◆ LIBMESH_ENABLE_TOPOLOGY_CACHES

libMesh::InfEdge2::LIBMESH_ENABLE_TOPOLOGY_CACHES
protected

Definition at line 180 of file edge_inf_edge2.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 661 of file elem.h.

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

◆ nodes_per_edge

const int libMesh::Edge::nodes_per_edge = invalid_int
staticinherited

Definition at line 68 of file edge.h.

◆ nodes_per_side

const int libMesh::Edge::nodes_per_side = 1
staticinherited

Definition at line 67 of file edge.h.

◆ num_children

const int libMesh::Edge::num_children = 2
staticinherited

Definition at line 66 of file edge.h.

◆ num_edges

const int libMesh::Edge::num_edges = 0
staticinherited

Definition at line 65 of file edge.h.

◆ num_nodes

const int libMesh::InfEdge2::num_nodes = 2
static

Geometric constants for InfEdge2.

Definition at line 72 of file edge_inf_edge2.h.

◆ num_sides

const int libMesh::Edge::num_sides = 2
staticinherited

Geometric constants for all Edges.

Definition at line 64 of file edge.h.

◆ old_dof_object

std::unique_ptr<DofObject> libMesh::DofObject::old_dof_object
protectedinherited

This object on the last mesh.

Useful for projecting solutions from one mesh to another.

Public access to old_dof_object is now officially deprecated and will be removed in future libMesh versions. Use the get_old_dof_object() accessor instead.

Definition at line 88 of file dof_object.h.

Referenced by libMesh::DofObject::clear_old_dof_object(), libMesh::DofObject::get_old_dof_object(), libMesh::DofObject::get_old_dof_object_ref(), libMesh::DofObject::operator=(), libMesh::DofObject::pack_indexing(), libMesh::DofObject::packed_indexing_size(), libMesh::DofObject::set_old_dof_object(), and libMesh::DofObject::unpack_indexing().

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

Referenced by SystemsTest::test2DProjectVectorFE(), SystemsTest::test3DProjectVectorFE(), and ElemTest< elem_type >::test_static_data().

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

Referenced by FETestBase< order, family, elem_type, 1 >::setUp(), SystemsTest::test2DProjectVectorFE(), SystemsTest::test3DProjectVectorFE(), ElemTest< elem_type >::test_static_data(), and PointLocatorTest::testLocator().

◆ type_to_n_edges_map

const unsigned int libMesh::Elem::type_to_n_edges_map
staticinherited

This array maps the integer representation of the ElemType enum to the number of edges on the element.

This is only usable for simple types for which the node number is fixed; for more general types like Polygon subclasses an actual instantiated Elem must be queried.

Definition at line 743 of file elem.h.

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

◆ type_to_n_nodes_map

const unsigned int libMesh::Elem::type_to_n_nodes_map
staticinherited

This array maps the integer representation of the ElemType enum to the number of nodes in the element.

This is only usable for simple types for which the node number is fixed; for more general types like Polygon subclasses an actual instantiated Elem must be queried.

Definition at line 650 of file elem.h.

Referenced by libMesh::DynaIO::ElementDefinition::ElementDefinition(), libMesh::FEAbstract::get_refspace_nodes(), libMesh::XdrIO::pack_element(), libMesh::CheckpointIO::read_connectivity(), libMesh::XdrIO::read_serialized_connectivity(), ElemTest< elem_type >::test_static_data(), MeshGenerationTest::testBuildCube(), MeshGenerationTest::testBuildLine(), and libMesh::ExodusII_IO_Helper::write_elements().

◆ type_to_n_sides_map

const unsigned int libMesh::Elem::type_to_n_sides_map
staticinherited

This array maps the integer representation of the ElemType enum to the number of sides on the element.

This is only usable for simple types for which the node number is fixed; for more general types like Polygon subclasses an actual instantiated Elem must be queried.

Definition at line 685 of file elem.h.

Referenced by ElemTest< elem_type >::test_static_data(), MeshGenerationTest::testBuildCube(), and MeshGenerationTest::testBuildSquare().


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