The Edge is an element in 1D. More...

#include <edge.h>

Inheritance diagram for libMesh::Edge:

Public Types
enum	RefinementState { COARSEN = 0 , DO_NOTHING , REFINE , JUST_REFINED , JUST_COARSENED , INACTIVE , COARSEN_INACTIVE , INVALID_REFINEMENTSTATE }
	Enumeration of possible element refinement states. More...

typedef Elem const	NeighborPtrIter
	Nested "classes" for use iterating over all neighbors of an element.

typedef const Elem const	ConstNeighborPtrIter

typedef Predicates::multi_predicate	Predicate
	Useful iterator typedefs.

Public Member Functions
	Edge (const unsigned int nn, Elem p, Node *nodelinkdata)
	Default line element, takes number of nodes and parent.

	Edge (Edge &&)=delete

	Edge (const Edge &)=delete

Edge &	operator= (const Edge &)=delete

Edge &	operator= (Edge &&)=delete

virtual	~Edge ()=default

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

virtual std::unique_ptr< Elem >	side_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.

virtual std::unique_ptr< Elem >	build_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.

virtual std::unique_ptr< Elem >	build_edge_ptr (const unsigned int) override final
	The `Elem::build_edge_ptr()` member makes no sense for edges.

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.

virtual std::vector< unsigned int >	nodes_on_side (const unsigned int s) const override

virtual std::vector< unsigned int >	nodes_on_edge (const unsigned int e) const override

virtual std::vector< unsigned int >	sides_on_edge (const unsigned int) const override final

virtual std::vector< unsigned int >	edges_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.

virtual Point	quasicircumcenter () const override

virtual unsigned int	n_permutations () const override final
	Returns the number of independent permutations of element nodes - e.g.

virtual void	permute (unsigned int) override final
	Permutes the element (by swapping node and neighbor pointers) according to the specified index.

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

virtual dof_id_type	key (const unsigned int s) const=0
	Don't hide Elem::key() defined in the base class.

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

virtual std::unique_ptr< Elem >	build_side_ptr (const unsigned int i)=0

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

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

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

virtual void	build_side_ptr (std::unique_ptr< Elem > &side, const unsigned int i)=0
	Resets the loose element `side`, which may currently point to a different side than `i` or even a different element than `this`, to point to side `i` on `this`.

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

const Point &	point (const unsigned int i) const

Point &	point (const unsigned int i)

virtual Point	master_point (const unsigned int i) const =0

dof_id_type	node_id (const unsigned int i) const

unsigned int	local_node (const dof_id_type i) const

unsigned int	get_node_index (const Node *node_ptr) const

const Node const	get_nodes () const

const Node *	node_ptr (const unsigned int i) const

Node *	node_ptr (const unsigned int i)

const Node &	node_ref (const unsigned int i) const

Node &	node_ref (const unsigned int i)

virtual Node *&	set_node (const unsigned int i)

virtual void	set_node (const unsigned int i, Node *node)
	Sets local `Node` `i` to refer to `node`.

SimpleRange< NodeRefIter >	node_ref_range ()
	Returns a range with all nodes of an element, usable in range-based for loops.

SimpleRange< ConstNodeRefIter >	node_ref_range () const

subdomain_id_type	subdomain_id () const

subdomain_id_type &	subdomain_id ()

virtual bool	runtime_topology () const

const Elem *	reference_elem () const

bool	operator== (const Elem &rhs) const

bool	operator!= (const Elem &rhs) const

bool	topologically_equal (const Elem &rhs) const

const Elem *	neighbor_ptr (unsigned int i) const

Elem *	neighbor_ptr (unsigned int i)

SimpleRange< NeighborPtrIter >	neighbor_ptr_range ()
	Returns a range with all neighbors of an element, usable in range-based for loops.

SimpleRange< ConstNeighborPtrIter >	neighbor_ptr_range () const

const Elem *	topological_neighbor (const unsigned int i, const MeshBase &mesh, const PointLocatorBase &point_locator, const PeriodicBoundaries *pb) const

Elem *	topological_neighbor (const unsigned int i, MeshBase &mesh, const PointLocatorBase &point_locator, const PeriodicBoundaries *pb)

bool	has_topological_neighbor (const Elem elem, const MeshBase &mesh, const PointLocatorBase &point_locator, const PeriodicBoundaries pb) const

void	set_neighbor (const unsigned int i, Elem *n)
	Assigns `n` as the \( i^{th} \) neighbor.

bool	has_neighbor (const Elem *elem) const

Elem *	child_neighbor (Elem *elem)

const Elem *	child_neighbor (const Elem *elem) const

bool	on_boundary () const

bool	is_semilocal (const processor_id_type my_pid) const

unsigned int	which_neighbor_am_i (const Elem *e) const
	This function tells you which neighbor `e` is.

unsigned int	which_side_am_i (const Elem *e) const
	This function tells you which side the boundary element `e` is.

bool	contains_vertex_of (const Elem *e, bool mesh_connection=false) const

bool	contains_edge_of (const Elem *e) const

void	find_point_neighbors (const Point &p, std::set< const Elem * > &neighbor_set) const
	This function finds all active elements (including this one) which are in the same manifold as this element and which touch the current active element at the specified point, which should be a point in the current element.

void	find_point_neighbors (std::set< const Elem * > &neighbor_set) const
	This function finds all active elements (including this one) in the same manifold as this element which touch this active element at any point.

void	find_point_neighbors (std::set< const Elem * > &neighbor_set, const Elem *start_elem) const
	This function finds all active elements (including this one) in the same manifold as start_elem (which must be active and must touch this element) which touch this element at any point.

void	find_point_neighbors (std::set< Elem * > &neighbor_set, Elem *start_elem)
	Non-const version of function above.

void	find_edge_neighbors (const Point &p1, const Point &p2, std::set< const Elem * > &neighbor_set) const
	This function finds all active elements in the same manifold as this element which touch the current active element along the whole edge defined by the two points `p1` and `p2`.

void	find_edge_neighbors (std::set< const Elem * > &neighbor_set) const
	This function finds all active elements in the same manifold as this element which touch the current active element along any edge (more precisely, at at least two points).

void	find_interior_neighbors (std::set< const Elem * > &neighbor_set) const
	This function finds all active elements (not including this one) in the parent manifold of this element whose intersection with this element has non-zero measure.

void	find_interior_neighbors (std::set< Elem * > &neighbor_set)
	Non-const version of function above that fills up a vector of non-const Elem pointers instead.

void	remove_links_to_me ()
	Resets this element's neighbors' appropriate neighbor pointers and its parent's and children's appropriate pointers to point to null instead of to this.

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

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

virtual bool	is_remote () const

virtual void	connectivity (const unsigned int sc, const IOPackage iop, std::vector< dof_id_type > &conn) const =0

void	write_connectivity (std::ostream &out, const IOPackage iop) const
	Writes the element connectivity for various IO packages to the passed ostream "out".

virtual ElemType	type () const =0

IntRange< unsigned short >	node_index_range () const

virtual unsigned int	n_nodes_in_child (unsigned int) const

virtual Point	side_vertex_average_normal (const unsigned int s) const

IntRange< unsigned short >	side_index_range () const

unsigned int	n_neighbors () const

IntRange< unsigned short >	edge_index_range () const

IntRange< unsigned short >	face_index_range () const

virtual bool	is_vertex (const unsigned int i) const =0

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

virtual bool	is_edge (const unsigned int i) const =0

virtual bool	is_face (const unsigned int i) const =0

bool	is_internal (const unsigned int i) const

virtual bool	is_node_on_side (const unsigned int n, const unsigned int s) const =0

virtual bool	is_node_on_edge (const unsigned int n, const unsigned int e) const =0

virtual unsigned int	n_sub_elem () const =0

std::unique_ptr< const Elem >	side_ptr (unsigned int i) const

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

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

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

virtual Order	default_order () const =0

virtual Order	supported_nodal_order () const

virtual Order	default_side_order () const

virtual Point	true_centroid () const

Point	vertex_average () const

virtual Real	hmin () const

virtual Real	hmax () const

virtual Real	volume () const

virtual BoundingBox	loose_bounding_box () const

virtual Real	quality (const ElemQuality q) const

virtual std::pair< Real, Real >	qual_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

unsigned int	face_orientation (const unsigned int i) const

std::vector< unsigned int >	oriented_face_vertices (const unsigned int i) const

bool	relative_edge_face_order (const unsigned int e, const unsigned int s) const

void	inherit_data_from (const Elem &src)
	A helper function for copying generic element data (mapping, subdomain, processor) from an element to a derived (child, side, edge) element.

virtual bool	has_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.

std::string	get_info () const
	Prints relevant information about the element to a string.

bool	active () const

bool	ancestor () const

bool	subactive () const

bool	has_children () const

bool	has_ancestor_children () const

bool	is_ancestor_of (const Elem *descendant) const

const Elem *	parent () const

Elem *	parent ()

void	set_parent (Elem *p)
	Sets the pointer to the element's parent.

const Elem *	top_parent () const

const Elem *	interior_parent () const

Elem *	interior_parent ()

void	set_interior_parent (Elem *p)
	Sets the pointer to the element's interior_parent.

Real	length (const unsigned int n1, const unsigned int n2) const

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 int >	second_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.

unsigned char	mapping_data () const

void	set_mapping_data (const unsigned char data)
	Sets the value of the mapping data for the element.

const Elem *	raw_child_ptr (unsigned int i) const

const Elem *	child_ptr (unsigned int i) const

Elem *	child_ptr (unsigned int i)

SimpleRange< ChildRefIter >	child_ref_range ()
	Returns a range with all children of a parent element, usable in range-based for loops.

SimpleRange< ConstChildRefIter >	child_ref_range () const

unsigned int	which_child_am_i (const Elem *e) const

virtual bool	is_child_on_edge (const unsigned int c, const unsigned int e) const

void	add_child (Elem *elem)
	Adds a child pointer to the array of children of this element.

void	add_child (Elem *elem, unsigned int c)
	Adds a new child pointer to the specified index in the array of children of this element.

void	replace_child (Elem *elem, unsigned int c)
	Replaces the child pointer at the specified index in the child array.

void	family_tree (std::vector< const Elem * > &family, bool reset=true) const
	Fills the vector `family` with the children of this element, recursively.

void	family_tree (std::vector< Elem * > &family, bool reset=true)
	Non-const version of function above; fills a vector of non-const pointers.

void	total_family_tree (std::vector< const Elem * > &family, bool reset=true) const
	Same as the `family_tree()` member, but also adds any subactive descendants.

void	total_family_tree (std::vector< Elem * > &family, bool reset=true)
	Non-const version of function above; fills a vector of non-const pointers.

void	active_family_tree (std::vector< const Elem * > &active_family, bool reset=true) const
	Same as the `family_tree()` member, but only adds the active children.

void	active_family_tree (std::vector< Elem * > &active_family, bool reset=true)
	Non-const version of function above; fills a vector of non-const pointers.

void	family_tree_by_side (std::vector< const Elem * > &family, unsigned int side, bool reset=true) const
	Same as the `family_tree()` member, but only adds elements which are next to `side`.

void	family_tree_by_side (std::vector< Elem * > &family, unsigned int side, bool reset=true)
	Non-const version of function above; fills a vector of non-const pointers.

void	total_family_tree_by_side (std::vector< const Elem * > &family, unsigned int side, bool reset=true) const
	Same as the `total_family_tree()` member, but only adds elements which are next to `side`.

void	total_family_tree_by_side (std::vector< Elem * > &family, unsigned int side, bool reset=true)
	Non-const version of function above; fills a vector of non-const pointers.

void	active_family_tree_by_side (std::vector< const Elem * > &family, unsigned int side, bool reset=true) const
	Same as the `active_family_tree()` member, but only adds elements which are next to `side`.

void	active_family_tree_by_side (std::vector< Elem * > &family, unsigned int side, bool reset=true)
	Non-const version of function above; fills a vector of non-const pointers.

void	family_tree_by_neighbor (std::vector< const Elem * > &family, const Elem *neighbor, bool reset=true) const
	Same as the `family_tree()` member, but only adds elements which are next to `neighbor`.

void	family_tree_by_neighbor (std::vector< Elem * > &family, Elem *neighbor, bool reset=true)
	Non-const version of function above; fills a vector of non-const pointers.

void	total_family_tree_by_neighbor (std::vector< const Elem * > &family, const Elem *neighbor, bool reset=true) const
	Same as the `family_tree_by_neighbor()` member, but also adds any subactive descendants.

void	total_family_tree_by_neighbor (std::vector< Elem * > &family, Elem *neighbor, bool reset=true)
	Non-const version of function above; fills a vector of non-const pointers.

void	family_tree_by_subneighbor (std::vector< const Elem * > &family, const Elem neighbor, const Elem subneighbor, bool reset=true) const
	Same as the `family_tree()` member, but only adds elements which are next to `subneighbor`.

void	family_tree_by_subneighbor (std::vector< Elem * > &family, Elem neighbor, Elem subneighbor, bool reset=true)
	Non-const version of function above; fills a vector of non-const pointers.

void	total_family_tree_by_subneighbor (std::vector< const Elem * > &family, const Elem neighbor, const Elem subneighbor, bool reset=true) const
	Same as the `family_tree_by_subneighbor()` member, but also adds any subactive descendants.

void	total_family_tree_by_subneighbor (std::vector< Elem * > &family, Elem neighbor, Elem subneighbor, bool reset=true)
	Non-const version of function above; fills a vector of non-const pointers.

void	active_family_tree_by_neighbor (std::vector< const Elem * > &family, const Elem *neighbor, bool reset=true) const
	Same as the `active_family_tree()` member, but only adds elements which are next to `neighbor`.

void	active_family_tree_by_neighbor (std::vector< Elem * > &family, Elem *neighbor, bool reset=true)
	Non-const version of function above; fills a vector of non-const pointers.

void	active_family_tree_by_topological_neighbor (std::vector< const Elem * > &family, const Elem neighbor, const MeshBase &mesh, const PointLocatorBase &point_locator, const PeriodicBoundaries pb, bool reset=true) const
	Same as the `active_family_tree_by_neighbor()` member, but the `neighbor` here may be a topological (e.g.

void	active_family_tree_by_topological_neighbor (std::vector< Elem * > &family, Elem neighbor, const MeshBase &mesh, const PointLocatorBase &point_locator, const PeriodicBoundaries pb, bool reset=true)
	Non-const version of function above; fills a vector of non-const pointers.

RefinementState	refinement_flag () const

void	set_refinement_flag (const RefinementState rflag)
	Sets the value of the refinement flag for the element.

RefinementState	p_refinement_flag () const

void	set_p_refinement_flag (const RefinementState pflag)
	Sets the value of the p-refinement flag for the element.

unsigned int	max_descendant_p_level () const

unsigned int	min_p_level_by_neighbor (const Elem *neighbor, unsigned int current_min) const

unsigned int	min_new_p_level_by_neighbor (const Elem *neighbor, unsigned int current_min) const

void	set_p_level (const unsigned int p)
	Sets the value of the p-refinement level for the element.

void	hack_p_level (const unsigned int p)
	Sets the value of the p-refinement level for the element without altering the p-level of its ancestors.

void	hack_p_level_and_refinement_flag (const unsigned int p, RefinementState pflag)
	Sets the value of the p-refinement level for the element without altering the p-level of its ancestors; also sets the p_refinement_flag, simultaneously so that they can be safely checked for mutual consistency.

virtual void	refine (MeshRefinement &mesh_refinement)
	Refine the element.

void	coarsen ()
	Coarsen the element.

void	contract ()
	Contract an active element, i.e.

void	libmesh_assert_valid_neighbors () const
	Checks for consistent neighbor links on this element.

void	libmesh_assert_valid_node_pointers () const
	Checks for a valid id and pointers to nodes with valid ids on this element.

virtual unsigned int	local_singular_node (const Point &, const Real=TOLERANCE *TOLERANCE) const

virtual bool	is_singular_node (unsigned int) const

side_iterator	boundary_sides_begin ()
	Iterator accessor functions.

side_iterator	boundary_sides_end ()

virtual bool	infinite () const =0

virtual bool	is_mid_infinite_edge_node (const unsigned int) const

virtual Point	origin () const

virtual std::unique_ptr< Elem >	disconnected_clone () const

virtual void	flip (BoundaryInfo *boundary_info)=0
	Flips the element (by swapping node and neighbor pointers) to have a mapping Jacobian of opposite sign.

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

virtual unsigned int	as_parent_node (unsigned int c, unsigned int n) const

virtual const std::vector< std::pair< unsigned char, unsigned char > > &	parent_bracketing_nodes (unsigned int c, unsigned int n) const

virtual const std::vector< std::pair< dof_id_type, dof_id_type > >	bracketing_nodes (unsigned int c, unsigned int n) const

virtual 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	embedding_matrix_version () const

void	nullify_neighbors ()
	Replaces this element with `nullptr` for all of its neighbors.

DofObject *	get_old_dof_object ()
	Pointer accessor for previously public old_dof_object.

const DofObject *	get_old_dof_object () const

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

const DofObject &	get_old_dof_object_ref () const

void	clear_old_dof_object ()
	Sets the `old_dof_object` to nullptr.

void	set_old_dof_object ()
	Sets the `old_dof_object` to a copy of `this`.

void	clear_dofs ()
	Clear the `DofMap` data structures holding degree of freedom data.

void	invalidate_dofs (const unsigned int sys_num=libMesh::invalid_uint)
	Sets all degree of freedom numbers to `invalid_id`.

void	invalidate_id ()
	Sets the id to `invalid_id`.

void	invalidate_processor_id ()
	Sets the processor id to `invalid_processor_id`.

void	invalidate ()
	Invalidates all the indices for this `DofObject`.

unsigned int	n_dofs (const unsigned int s, const unsigned int var=libMesh::invalid_uint) const

dof_id_type	id () const

dof_id_type &	set_id ()

void	set_id (const dof_id_type dofid)
	Sets the `id` for this `DofObject`.

unique_id_type	unique_id () const

void	set_unique_id (unique_id_type new_id)
	Sets the `unique_id` for this `DofObject`.

bool	valid_id () const

bool	valid_unique_id () const

processor_id_type	processor_id () const

processor_id_type &	processor_id ()

void	processor_id (const processor_id_type pid)
	Sets the `processor_id` for this `DofObject`.

bool	valid_processor_id () const

unsigned int	n_systems () const

unsigned int	n_pseudo_systems () const

void	set_n_systems (const unsigned int s)
	Sets the number of systems for this `DofObject`.

void	set_extra_integer (const unsigned int index, const dof_id_type value)
	Sets the value on this object of the extra integer associated with `index`, which should have been obtained via a call to `MeshBase::add_elem_integer` or `MeshBase::add_node_integer`.

dof_id_type	get_extra_integer (const unsigned int index) const
	Gets the value on this object of the extra integer associated with `index`, which should have been obtained via a call to `MeshBase::add_elem_integer` or `MeshBase::add_node_integer`.

template<typename T >
void	set_extra_datum (const unsigned int index, const T value)
	Sets the value on this object of the extra datum associated with `index`, which should have been obtained via a call to `MeshBase::add_elem_datum` or `MeshBase::add_node_datum` using the same type T.

template<typename T >
T	get_extra_datum (const unsigned int index) const
	Gets the value on this object of the extra datum associated with `index`, which should have been obtained via a call to `MeshBase::add_elem_datum` or `MeshBase::add_node_datum` using the same type T.

void	add_system ()
	Adds an additional system to the `DofObject`.

unsigned int	n_var_groups (const unsigned int s) const

unsigned int	n_vars (const unsigned int s, const unsigned int vg) const

unsigned int	n_vars (const unsigned int s) const

void	set_n_vars_per_group (const unsigned int s, const std::vector< unsigned int > &nvpg)
	Sets number of variables in each group associated with system `s` for this `DofObject`.

unsigned int	n_comp (const unsigned int s, const unsigned int var) const

unsigned int	n_comp_group (const unsigned int s, const unsigned int vg) const

void	set_n_comp (const unsigned int s, const unsigned int var, const unsigned int ncomp)
	Sets the number of components for `Variable` `var` of system `s` associated with this `DofObject`.

void	set_n_comp_group (const unsigned int s, const unsigned int vg, const unsigned int ncomp)
	Sets the number of components for `VariableGroup` `vg` of system `s` associated with this `DofObject`.

dof_id_type	dof_number (const unsigned int s, const unsigned int var, const unsigned int comp) const

dof_id_type	dof_number (const unsigned int s, const unsigned int vg, const unsigned int vig, const unsigned int comp, const unsigned int n_comp) const

std::pair< unsigned int, unsigned int >	var_to_vg_and_offset (const unsigned int s, const unsigned int var) const

void	set_dof_number (const unsigned int s, const unsigned int var, const unsigned int comp, const dof_id_type dn)
	Sets the global degree of freedom number for variable `var`, component `comp` for system `s` associated with this `DofObject`.

bool	has_dofs (const unsigned int s=libMesh::invalid_uint) const

void	set_vg_dof_base (const unsigned int s, const unsigned int vg, const dof_id_type db)
	`VariableGroup` DoF indices are indexed as id = base + var_in_vg*ncomp + comp This method allows for direct access to the base.

dof_id_type	vg_dof_base (const unsigned int s, const unsigned int vg) const
	`VariableGroup` DoF indices are indexed as id = base + var_in_vg*ncomp + comp This method allows for direct access to the base.

void	add_extra_integers (const unsigned int n_integers)
	Assigns a set of extra integers to this `DofObject`.

void	add_extra_integers (const unsigned int n_integers, const std::vector< dof_id_type > &default_values)
	Assigns a set of extra integers to this `DofObject`.

unsigned int	n_extra_integers () const
	Returns how many extra integers are associated to the `DofObject`.

bool	has_extra_integers () const
	Returns whether extra integers are associated to the `DofObject`.

unsigned int	packed_indexing_size () const
	If we pack our indices into an buffer for communications, how many ints do we need?

void	unpack_indexing (std::vector< largest_id_type >::const_iterator begin)
	A method for creating our index buffer from packed data - basically with our current implementation we investigate the size term and then copy.

void	pack_indexing (std::back_insert_iterator< std::vector< largest_id_type > > target) const
	A method for creating packed data from our index buffer - basically a copy with prepended size with our current implementation.

void	debug_buffer () const
	Print our buffer for debugging.

void	print_dof_info () const
	Print out info for debugging.

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

Static Public Member Functions
static unsigned int	local_side_node (ElemType t, unsigned int side, unsigned int side_node)

static unsigned int	local_edge_node (ElemType t, unsigned int edge, unsigned int edge_node)

static ElemType	side_type (const ElemType t, const unsigned int s)

static ElemType	edge_type (const ElemType t)

static void	print_info (std::ostream &out_stream=libMesh::out)
	Prints the reference information, by default to `libMesh::out`.

static void	print_info (std::ostream &out_stream=libMesh::out)
	Prints the reference information, by default to `libMesh::out`.

static std::string	get_info ()
	Gets a string containing the reference information.

static std::string	get_info ()
	Gets a string containing the reference information.

static ElemType	second_order_equivalent_type (const ElemType et, const bool full_ordered=true)

static ElemType	first_order_equivalent_type (const ElemType et)

static ElemType	complete_order_equivalent_type (const ElemType et)

static constexpr bool	infinite ()

static std::unique_ptr< Elem >	build (const ElemType type, Elem *p=nullptr)

static std::unique_ptr< Elem >	build_with_id (const ElemType type, dof_id_type id)
	Calls the build() method above with a nullptr parent, and additionally sets the newly-created Elem's id.

static unsigned int	n_objects ()
	Prints the number of outstanding (created, but not yet destroyed) objects.

static unsigned int	n_objects ()
	Prints the number of outstanding (created, but not yet destroyed) objects.

static void	enable_print_counter_info ()
	Methods to enable/disable the reference counter output from print_info().

static void	enable_print_counter_info ()
	Methods to enable/disable the reference counter output from print_info().

static void	disable_print_counter_info ()

static void	disable_print_counter_info ()

static unsigned int	unpackable_indexing_size (std::vector< largest_id_type >::const_iterator begin)
	If we have indices packed into an buffer for communications, how much of that buffer applies to this dof object?

Static Public Attributes
static const int	num_sides = 2
	Geometric constants for all Edges.

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 constexpr subdomain_id_type	invalid_subdomain_id = std::numeric_limits<subdomain_id_type>::max()
	A static integral constant representing an invalid subdomain id.

static const unsigned int	type_to_dim_map [INVALID_ELEM]
	This array maps the integer representation of the `ElemType` enum to the geometric dimension of the element.

static constexpr unsigned int	type_to_n_nodes_map [INVALID_ELEM]
	This array maps the integer representation of the `ElemType` enum to the number of nodes in the element.

static const unsigned int	max_n_nodes = 27
	The maximum number of nodes any element can contain.

static const unsigned int	type_to_n_sides_map [INVALID_ELEM]
	This array maps the integer representation of the `ElemType` enum to the number of sides on the element.

static const unsigned int	type_to_n_edges_map [INVALID_ELEM]
	This array maps the integer representation of the `ElemType` enum to the number of edges on the element.

static const Order	type_to_default_order_map [INVALID_ELEM]
	This array maps the integer representation of the `ElemType` enum to the default approximation order of elements of that type.

static constexpr dof_id_type	invalid_id = static_cast<dof_id_type>(-1)
	An invalid `id` to distinguish an uninitialized `DofObject`.

static constexpr unique_id_type	invalid_unique_id = static_cast<unique_id_type>(-1)
	An invalid `unique_id` to distinguish an uninitialized `DofObject`.

static constexpr processor_id_type	invalid_processor_id = static_cast<processor_id_type>(-1)
	An invalid `processor_id` to distinguish DoFs that have not been assigned to a processor.

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

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

Protected Member Functions
unsigned int	side_children_matrix (const unsigned int, const unsigned int) const
	Matrix that allows children to inherit boundary conditions.

void	swap2nodes (unsigned int n1, unsigned int n2)
	Swaps two node_ptrs.

void	swap2neighbors (unsigned int n1, unsigned int n2)
	Swaps two neighbor_ptrs.

void	swap2boundarysides (unsigned short s1, unsigned short s2, BoundaryInfo *boundary_info) const
	Swaps two sides in `boundary_info`, if it is non-null.

void	swap2boundaryedges (unsigned short e1, unsigned short e2, BoundaryInfo *boundary_info) const
	Swaps two edges in `boundary_info`, if it is non-null.

void	swap3nodes (unsigned int n1, unsigned int n2, unsigned int n3)
	Swaps three node_ptrs, "rotating" them.

void	swap3neighbors (unsigned int n1, unsigned int n2, unsigned int n3)
	Swaps three neighbor_ptrs, "rotating" them.

void	swap4nodes (unsigned int n1, unsigned int n2, unsigned int n3, unsigned int n4)
	Swaps four node_ptrs, "rotating" them.

void	swap4neighbors (unsigned int n1, unsigned int n2, unsigned int n3, unsigned int n4)
	Swaps four neighbor_ptrs, "rotating" them.

template<typename Sideclass , typename Subclass >
std::unique_ptr< Elem >	simple_build_side_ptr (const unsigned int i)
	An implementation for simple (all sides equal) elements.

template<typename Subclass >
void	simple_build_side_ptr (std::unique_ptr< Elem > &side, const unsigned int i, ElemType sidetype)
	An implementation for simple (all sides equal) elements.

template<typename Subclass , typename Mapclass >
void	simple_side_ptr (std::unique_ptr< Elem > &side, const unsigned int i, ElemType sidetype)
	An implementation for simple (all sides equal) elements.

template<typename Edgeclass , typename Subclass >
std::unique_ptr< Elem >	simple_build_edge_ptr (const unsigned int i)
	An implementation for simple (all edges equal) elements.

template<typename Subclass >
void	simple_build_edge_ptr (std::unique_ptr< Elem > &edge, const unsigned int i, ElemType edgetype)
	An implementation for simple (all edges equal) elements.

virtual std::vector< std::vector< std::vector< std::vector< std::pair< unsigned char, unsigned char > > > > > &	_get_bracketing_node_cache () const
	Elem subclasses which don't do their own bracketing node calculations will need to supply a static cache, since the default calculation is slow.

virtual std::vector< std::vector< std::vector< signed char > > > &	_get_parent_indices_cache () const
	Elem subclasses which don't do their own child-to-parent node calculations will need to supply a static cache, since the default calculation is slow.

void	increment_constructor_count (const std::string &name) noexcept
	Increments the construction counter.

void	increment_constructor_count (const std::string &name) noexcept
	Increments the construction counter.

void	increment_destructor_count (const std::string &name) noexcept
	Increments the destruction counter.

void	increment_destructor_count (const std::string &name) noexcept
	Increments the destruction counter.

Static Protected Member Functions
static dof_id_type	compute_key (dof_id_type n0)

static dof_id_type	compute_key (dof_id_type n0, dof_id_type n1)

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

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

Protected Attributes
Elem *	_elemlinks_data [3+(LIBMESH_DIM >1)]
	Data for links to parent/neighbor/interior_parent elements.

Node **	_nodes
	Pointers to the nodes we are connected to.

Elem **	_elemlinks
	Pointers to this element's parent and neighbors, and for lower-dimensional elements' interior_parent.

std::unique_ptr< Elem *[]>	_children
	unique_ptr to array of this element's children.

subdomain_id_type	_sbd_id
	The subdomain to which this element belongs.

unsigned char	_rflag
	h refinement flag.

unsigned char	_pflag
	p refinement flag.

unsigned char	_p_level
	p refinement level - the difference between the polynomial degree on this element and the minimum polynomial degree on the mesh.

unsigned char	_map_type
	Mapping function type; currently either 0 (LAGRANGE) or 1 (RATIONAL_BERNSTEIN).

unsigned char	_map_data
	Mapping function data; currently used when needed to store the RATIONAL_BERNSTEIN nodal weight data index.

std::unique_ptr< DofObject >	old_dof_object
	This object on the last mesh.

Static Protected Attributes
static constexpr Real	affine_tol = TOLERANCE*TOLERANCE
	Default tolerance to use in has_affine_map().

static Counts	_counts
	Actually holds the data.

static Counts	_counts
	Actually holds the data.

static Threads::atomic< unsigned int >	_n_objects
	The number of objects.

static Threads::atomic< unsigned int >	_n_objects
	The number of objects.

static Threads::spin_mutex	_mutex
	Mutual exclusion object to enable thread-safe reference counting.

static Threads::spin_mutex	_mutex
	Mutual exclusion object to enable thread-safe reference counting.

static bool	_enable_print_counter = true
	Flag to control whether reference count information is printed when print_info is called.

static bool	_enable_print_counter = true
	Flag to control whether reference count information is printed when print_info is called.

Private Types
typedef dof_id_type	index_t
	DoF index information.

typedef std::vector< index_t >	index_buffer_t

Private Member Functions
bool	point_test (const Point &p, Real box_tol, Real map_tol) const
	Shared private implementation used by the contains_point() and close_to_point() routines.

void	set_child (unsigned int c, Elem *elem)
	Sets the pointer to the \( i^{th} \) child for this element.

SideIter	_first_side ()
	Side iterator helper functions.

SideIter	_last_side ()

std::unique_ptr< DofObject >	construct (const DofObject *other=nullptr)
	Convenient factory function that calls either the (deep) copy constructor or the default constructor depending on the input arg.

unsigned int	var_to_vg (const unsigned int s, const unsigned int var) const
	Utility function - for variable `var` in system `s`, figure out what variable group it lives in.

unsigned int	system_var_to_vg_var (const unsigned int s, const unsigned int vg, const unsigned int var) const
	Utility function - for variable `var` in system `s`, figure out what variable group it lives in.

unsigned int	start_idx (const unsigned int s) const
	The starting index for system `s`.

unsigned int	end_idx (const unsigned int s) const
	The ending index for system `s`.

unsigned int	start_idx_ints () const
	The starting index for an extra_integers pseudosystem.

unsigned int	end_idx_ints () const
	The ending index for an extra_integers pseudosystem.

Private Attributes
unique_id_type	_unique_id
	A globally unique id, guaranteed not to change as the mesh is repartitioned or adapted.

dof_id_type	_id
	The `id` of the `DofObject`.

processor_id_type	_processor_id
	The `processor_id` of the `DofObject`.

index_buffer_t	_idx_buf

Static Private Attributes
static constexpr index_t	ncv_magic_exp = sizeof(index_t)*3
	Above we introduced the chimera ncv, which is a hybrid of the form ncv = ncv_magic*nv + nc where nv are the number of identical variables of a given type, and nc is the number of components for this set of variables.

static constexpr index_t	ncv_magic = index_t(1) << ncv_magic_exp

Detailed Description

The Edge is an element in 1D.

It can be thought of as a line segment.

Author: Benjamin S. Kirk

Date: 2002

The base class for all 1D geometric element types.

Definition at line 37 of file edge.h.

Member Typedef Documentation

◆ ConstNeighborPtrIter

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

inherited

Definition at line 335 of file elem.h.

◆ Counts [1/2]

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

protectedinherited

Data structure to log the information.

The log is identified by the class name.

Definition at line 119 of file reference_counter.h.

◆ Counts [2/2]

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

protectedinherited

Data structure to log the information.

The log is identified by the class name.

Definition at line 119 of file reference_counter.h.

◆ index_buffer_t

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

privateinherited

Definition at line 670 of file dof_object.h.

◆ index_t

typedef dof_id_type libMesh::DofObject::index_t

privateinherited

DoF index information.

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

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

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

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

The total number of true systems is

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

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

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

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

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

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

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

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

start_s = abs(_idx_buf[s])

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

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

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

idx_var = idx_# + n_comp*v + c

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

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

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

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

Definition at line 669 of file dof_object.h.

◆ NeighborPtrIter

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

inherited

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

Definition at line 334 of file elem.h.

◆ Predicate

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

inherited

Useful iterator typedefs.

Definition at line 1996 of file elem.h.

Member Enumeration Documentation

◆ RefinementState

enum libMesh::Elem::RefinementState

inherited

Enumeration of possible element refinement states.

Enumerator
COARSEN
DO_NOTHING
REFINE
JUST_REFINED
JUST_COARSENED
INACTIVE
COARSEN_INACTIVE
INVALID_REFINEMENTSTATE

Definition at line 1567 of file elem.h.

                       { COARSEN = 0,
                         DO_NOTHING,
                         REFINE,
                         JUST_REFINED,
                         JUST_COARSENED,
                         INACTIVE,
                         COARSEN_INACTIVE,
                         INVALID_REFINEMENTSTATE };

Constructor & Destructor Documentation

◆ Edge() [1/3]

libMesh::Edge::Edge	(	const unsigned int	nn,
		Elem *	p,
		Node **	nodelinkdata
	)

inline

Default line element, takes number of nodes and parent.

Derived classes implement 'true' elements.

Definition at line 45 of file edge.h.

                              :
    Elem(nn, num_sides, p, _elemlinks_data, nodelinkdata)
  {
    // Make sure the interior parent isn't undefined
    if (LIBMESH_DIM > 1)
      this->set_interior_parent(nullptr);
  }

References libMesh::Elem::set_interior_parent().

◆ Edge() [2/3]

libMesh::Edge::Edge ( Edge && )

delete

◆ Edge() [3/3]

libMesh::Edge::Edge ( const Edge & )

delete

◆ ~Edge()

virtual libMesh::Edge::~Edge ( )

virtualdefault

Member Function Documentation

◆ _first_side()

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

inlineprivateinherited

Side iterator helper functions.

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

Definition at line 3608 of file elem.h.

{
  return SideIter(0, this);
}

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

◆ _get_bracketing_node_cache()

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

inlineprotectedvirtualinherited

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

Definition at line 2339 of file elem.h.

  {
    static std::vector<std::vector<std::vector<std::vector<std::pair<unsigned char, unsigned char>>>>> c;
    libmesh_error();
    return c;
  }

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

◆ _get_parent_indices_cache()

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

inlineprotectedvirtualinherited

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

Definition at line 2353 of file elem.h.

  {
    static std::vector<std::vector<std::vector<signed char>>> c;
    libmesh_error();
    return c;
  }

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

◆ _last_side()

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

inlineprivateinherited

Definition at line 3616 of file elem.h.

{
  return SideIter(this->n_neighbors(), this);
}

References libMesh::Elem::n_neighbors().

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

◆ active()

bool libMesh::Elem::active ( ) const

inlineinherited

Returns: true if the element is active (i.e. has no active descendants) or AMR is disabled, false otherwise.

Note: It suffices to check the first child only.

Definition at line 3079 of file elem.h.

{
#ifdef LIBMESH_ENABLE_AMR
  if ((this->refinement_flag() == INACTIVE) ||
      (this->refinement_flag() == COARSEN_INACTIVE))
    return false;
  else
    return true;
#else
  return true;
#endif
}

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

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

◆ active_family_tree() [1/2]

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

inherited

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

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

Definition at line 2244 of file elem.C.

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

References libMesh::ElemInternal::active_family_tree().

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

◆ active_family_tree() [2/2]

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

inherited

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

Definition at line 2252 of file elem.C.

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

References libMesh::ElemInternal::active_family_tree().

◆ active_family_tree_by_neighbor() [1/2]

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

inherited

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

Definition at line 2390 of file elem.C.

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

References libMesh::ElemInternal::active_family_tree_by_neighbor().

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

◆ active_family_tree_by_neighbor() [2/2]

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

inherited

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

Definition at line 2399 of file elem.C.

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

References libMesh::ElemInternal::active_family_tree_by_neighbor().

◆ active_family_tree_by_side() [1/2]

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

inherited

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

Definition at line 2296 of file elem.C.

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

References libMesh::ElemInternal::active_family_tree_by_side().

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

◆ active_family_tree_by_side() [2/2]

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

inherited

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

Definition at line 2305 of file elem.C.

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

References libMesh::ElemInternal::active_family_tree_by_side().

◆ active_family_tree_by_topological_neighbor() [1/2]

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

inherited

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

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

Definition at line 2408 of file elem.C.

{
  ElemInternal::active_family_tree_by_topological_neighbor(this, family, neighbor,
                                                           mesh, point_locator, pb,
                                                           reset);
}

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

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

◆ active_family_tree_by_topological_neighbor() [2/2]

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

inherited

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

Definition at line 2422 of file elem.C.

{
  ElemInternal::active_family_tree_by_topological_neighbor(this, family, neighbor,
                                                           mesh, point_locator, pb,
                                                           reset);
}

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

◆ add_child() [1/2]

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

inherited

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

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

Definition at line 2155 of file elem.C.

{
  const unsigned int nc = this->n_children();
 
  if (!_children)
    {
      _children = std::make_unique<Elem *[]>(nc);
 
      for (unsigned int c = 0; c != nc; c++)
        this->set_child(c, nullptr);
    }
 
  for (unsigned int c = 0; c != nc; c++)
    {
      if (this->_children[c] == nullptr || this->_children[c] == remote_elem)
        {
          libmesh_assert_equal_to (this, elem->parent());
          this->set_child(c, elem);
          return;
        }
    }
 
  libmesh_error_msg("Error: Tried to add a child to an element with full children array");
}

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

Referenced by libMesh::BoundaryInfo::add_elements(), libMesh::UnstructuredMesh::all_first_order(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::CheckpointIO::read_connectivity(), libMesh::CheckpointIO::read_remote_elem(), libMesh::XdrIO::read_serialized_connectivity(), and libMesh::Parallel::Packing< Elem * >::unpack().

◆ add_child() [2/2]

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

inherited

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

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

Definition at line 2182 of file elem.C.

{
  if (!this->has_children())
    {
      const unsigned int nc = this->n_children();
      _children = std::make_unique<Elem *[]>(nc);
 
      for (unsigned int i = 0; i != nc; i++)
        this->set_child(i, nullptr);
    }
 
  libmesh_assert (this->_children[c] == nullptr || this->child_ptr(c) == remote_elem);
  libmesh_assert (elem == remote_elem || this == elem->parent());
 
  this->set_child(c, elem);
}

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

◆ add_extra_integers() [1/2]

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

inherited

Assigns a set of extra integers to this DofObject.

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

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

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

Definition at line 482 of file dof_object.C.

{
  if (_idx_buf.empty())
    {
      if (n_integers)
        {
          _idx_buf.resize(n_integers+1, DofObject::invalid_id);
          _idx_buf[0] = dof_id_type(-1);
        }
      return;
    }
  else
    {
      const int hdr = dof_id_signed_type(_idx_buf[0]);
 
      // We already have some extra integers, but may need more or
      // less now.
      if (hdr < 0)
        {
          const unsigned int old_n_integers = this->n_extra_integers();
          if (n_integers != old_n_integers)
            {
              // Make or remove space as needed by count change
              _idx_buf.resize(_idx_buf.size()+n_integers-old_n_integers, DofObject::invalid_id);
 
              // The start index for the extra integers is unchanged.
            }
        }
      else if (n_integers)
      // We had no extra integers, but need to add some
        {
          // Mark the DofObject as holding extra integers
          _idx_buf[0] = dof_id_type(-hdr-1);
 
          // Insert the integer start position
          DofObject::index_buffer_t::iterator it = _idx_buf.begin() + hdr;
          _idx_buf.insert(it, _idx_buf.size()+1);
 
          // Increment the previous system start positions to account
          // for the new header entry creating an offset
          for (int i=1; i<hdr; i++)
            _idx_buf[i]++;
 
          // Append space for extra integers
          _idx_buf.resize(_idx_buf.size()+n_integers, DofObject::invalid_id);
        }
    }
}

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

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

◆ add_extra_integers() [2/2]

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

inherited

Assigns a set of extra integers to this DofObject.

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

Any newly-added values will be copied from default_values.

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

Definition at line 534 of file dof_object.C.

{
  libmesh_assert_equal_to(n_integers, default_values.size());
 
  const unsigned int n_old_integers = this->n_extra_integers();
  this->add_extra_integers(n_integers);
  if (n_integers > n_old_integers)
    {
      const unsigned int n_more_integers = n_integers - n_old_integers;
      std::copy(default_values.begin()+n_old_integers,
                default_values.end(),
                _idx_buf.end()-n_more_integers);
    }
}

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

◆ add_system()

void libMesh::DofObject::add_system ( )

inherited

Adds an additional system to the DofObject.

Definition at line 187 of file dof_object.C.

{
  // quick return?
  if (this->n_systems() == 0)
    {
      this->set_n_systems(1);
      return;
    }
 
  // cache this value before we screw it up!
  const unsigned int ns_orig = this->n_systems();
 
  DofObject::index_buffer_t::iterator it = _idx_buf.begin() + ns_orig;
 
  // Create the entry for the new system indicating 0 variables.
  //
  // increment the number of systems and the offsets for each of
  // the systems including the new one we just added.
  if (this->has_extra_integers())
    {
      // this inserts the extra_integers' start position as the start
      // position for the new system.  We'll increment all those
      // counts in one sweep next, to account for header expansion.
      _idx_buf.insert(it, *it);
 
      _idx_buf[0]--;
      for (unsigned int i=1; i<ns_orig+2; i++)
        {
          libmesh_assert_less(i, _idx_buf.size());
          _idx_buf[i]++;
        }
    }
  else
    {
      // this inserts the current vector size at the position for the
      // new system
      _idx_buf.insert(it, cast_int<dof_id_type>(_idx_buf.size()));
 
      for (unsigned int i=0; i<ns_orig+1; i++)
        {
          libmesh_assert_less(i, _idx_buf.size());
          _idx_buf[i]++;
        }
    }
 
  libmesh_assert_equal_to (this->n_systems(), (ns_orig+1));
  libmesh_assert_equal_to (this->n_vars(ns_orig), 0);
  libmesh_assert_equal_to (this->n_var_groups(ns_orig), 0);
}

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

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

◆ ancestor()

bool libMesh::Elem::ancestor ( ) const

inherited

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

Definition at line 2121 of file elem.C.

{
#ifdef LIBMESH_ENABLE_AMR
 
  // Use a fast, DistributedMesh-safe definition
  const bool is_ancestor =
    !this->active() && !this->subactive();
 
  // But check for inconsistencies if we have time
#ifdef DEBUG
  if (!is_ancestor && this->has_children())
    {
      for (auto & c : this->child_ref_range())
        {
          if (&c != remote_elem)
            {
              libmesh_assert(!c.active());
              libmesh_assert(!c.ancestor());
            }
        }
    }
#endif // DEBUG
 
  return is_ancestor;
 
#else
  return false;
#endif
}

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

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

◆ as_parent_node()

unsigned int libMesh::Elem::as_parent_node	(	unsigned int	c,
		unsigned int	n
	)		const

virtualinherited

Returns: The local node id on the parent which corresponds to node n of child c, or invalid_uint if no such parent node exists.

Definition at line 2515 of file elem.C.

{
  const unsigned int nc = this->n_children();
  libmesh_assert_less(child, nc);
 
  // Cached return values, indexed first by embedding_matrix version,
  // then by child number, then by child node number.
  std::vector<std::vector<std::vector<signed char>>> &
    cached_parent_indices = this->_get_parent_indices_cache();
 
  unsigned int em_vers = this->embedding_matrix_version();
 
  // We may be updating the cache on one thread, and while that
  // happens we can't safely access the cache from other threads.
  Threads::spin_mutex::scoped_lock lock(parent_indices_mutex);
 
  if (em_vers >= cached_parent_indices.size())
    cached_parent_indices.resize(em_vers+1);
 
  if (child >= cached_parent_indices[em_vers].size())
    {
      const signed char nn = cast_int<signed char>(this->n_nodes());
 
      cached_parent_indices[em_vers].resize(nc);
 
      for (unsigned int c = 0; c != nc; ++c)
        {
          const unsigned int ncn = this->n_nodes_in_child(c);
          cached_parent_indices[em_vers][c].resize(ncn);
          for (unsigned int cn = 0; cn != ncn; ++cn)
            {
              for (signed char n = 0; n != nn; ++n)
                {
                  const Real em_val = this->embedding_matrix
                    (c, cn, n);
                  if (em_val == 1)
                    {
                      cached_parent_indices[em_vers][c][cn] = n;
                      break;
                    }
 
                  if (em_val != 0)
                    {
                      cached_parent_indices[em_vers][c][cn] =
                        -1;
                      break;
                    }
 
                  // We should never see an all-zero embedding matrix
                  // row
                  libmesh_assert_not_equal_to (n+1, nn);
                }
            }
        }
    }
 
  const signed char cache_val =
    cached_parent_indices[em_vers][child][child_node];
  if (cache_val == -1)
    return libMesh::invalid_uint;
 
  return cached_parent_indices[em_vers][child][child_node];
}

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

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

◆ boundary_sides_begin()

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

inherited

Iterator accessor functions.

Definition at line 3847 of file elem.C.

{
  Predicates::BoundarySide<SideIter> bsp;
  return side_iterator(this->_first_side(), this->_last_side(), bsp);
}

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

◆ boundary_sides_end()

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

inherited

Definition at line 3856 of file elem.C.

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

References libMesh::Elem::_last_side().

◆ bracketing_nodes()

const std::vector< std::pair< dof_id_type, dof_id_type > > libMesh::Elem::bracketing_nodes	(	unsigned int	c,
		unsigned int	n
	)		const

virtualinherited

Returns: All the pairs of nodes (indexed by global node id) which should bracket node n of child c.

Definition at line 2786 of file elem.C.

{
  std::vector<std::pair<dof_id_type, dof_id_type>> returnval;
 
  const std::vector<std::pair<unsigned char, unsigned char>> & pbc =
    this->parent_bracketing_nodes(child,child_node);
 
  for (const auto & pb : pbc)
    {
      const unsigned short n_n = this->n_nodes();
      if (pb.first < n_n && pb.second < n_n)
        returnval.emplace_back(this->node_id(pb.first), this->node_id(pb.second));
      else
        {
          // We must be on a non-full-order higher order element...
          libmesh_assert_not_equal_to(this->default_order(), FIRST);
          libmesh_assert_not_equal_to
            (second_order_equivalent_type (this->type(), true),
             this->type());
          libmesh_assert_equal_to
            (second_order_equivalent_type (this->type(), false),
             this->type());
 
          // And that's a shame, because this is a nasty search:
 
          // Build the full-order type
          ElemType full_type =
            second_order_equivalent_type(this->type(), /*full_ordered=*/ true);
          std::unique_ptr<Elem> full_elem = Elem::build(full_type);
 
          dof_id_type pt1 = DofObject::invalid_id;
          dof_id_type pt2 = DofObject::invalid_id;
 
          // Find the bracketing nodes by figuring out what
          // already-created children will have them.
 
          // This only doesn't break horribly because we add children
          // and nodes in straightforward + hierarchical orders...
          for (unsigned int c=0; c <= child; ++c)
            {
              libmesh_assert(this->child_ptr(c));
              if (this->child_ptr(c) == remote_elem)
                continue;
 
              for (auto n : make_range(this->n_nodes_in_child(c)))
                {
                  if (c == child && n == child_node)
                    break;
 
                  if (pb.first == full_elem->as_parent_node(c,n))
                    {
                      // We should be consistent
                      if (pt1 != DofObject::invalid_id)
                        libmesh_assert_equal_to(pt1, this->child_ptr(c)->node_id(n));
 
                      pt1 = this->child_ptr(c)->node_id(n);
                    }
 
                  if (pb.second == full_elem->as_parent_node(c,n))
                    {
                      // We should be consistent
                      if (pt2 != DofObject::invalid_id)
                        libmesh_assert_equal_to(pt2, this->child_ptr(c)->node_id(n));
 
                      pt2 = this->child_ptr(c)->node_id(n);
                    }
                }
            }
 
          // We should *usually* find all bracketing nodes by the time
          // we query them (again, because of the child & node add
          // order)
          //
          // The exception is if we're a HEX20, in which case we will
          // find pairs of vertex nodes and edge nodes bracketing the
          // new central node but we *won't* find the pairs of face
          // nodes which we would have had on a HEX27.  In that case
          // we'll still have enough bracketing nodes for a
          // topological lookup, but we won't be able to make the
          // following assertions.
          if (this->type() != HEX20)
            {
              libmesh_assert_not_equal_to (pt1, DofObject::invalid_id);
              libmesh_assert_not_equal_to (pt2, DofObject::invalid_id);
            }
 
          if (pt1 != DofObject::invalid_id &&
              pt2 != DofObject::invalid_id)
            returnval.emplace_back(pt1, pt2);
        }
    }
 
  return returnval;
}

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

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

◆ build()

std::unique_ptr< Elem > libMesh::Elem::build	(	const ElemType	type,
		Elem *	p = `nullptr`
	)

staticinherited

Returns: An Elem of type type wrapped in a smart pointer.

Definition at line 382 of file elem.C.

{
  switch (type)
    {
      // 0D elements
    case NODEELEM:
      return std::make_unique<NodeElem>(p);
 
      // 1D elements
    case EDGE2:
      return std::make_unique<Edge2>(p);
    case EDGE3:
      return std::make_unique<Edge3>(p);
    case EDGE4:
      return std::make_unique<Edge4>(p);
 
      // 2D elements
    case TRI3:
      return std::make_unique<Tri3>(p);
    case TRISHELL3:
      return std::make_unique<TriShell3>(p);
    case TRI3SUBDIVISION:
      return std::make_unique<Tri3Subdivision>(p);
    case TRI6:
      return std::make_unique<Tri6>(p);
    case TRI7:
      return std::make_unique<Tri7>(p);
    case QUAD4:
      return std::make_unique<Quad4>(p);
    case QUADSHELL4:
      return std::make_unique<QuadShell4>(p);
    case QUAD8:
      return std::make_unique<Quad8>(p);
    case QUADSHELL8:
      return std::make_unique<QuadShell8>(p);
    case QUAD9:
      return std::make_unique<Quad9>(p);
    case QUADSHELL9:
      return std::make_unique<QuadShell9>(p);
 
    // Well, a hexagon is *a* polygon...
    case C0POLYGON:
      return std::make_unique<C0Polygon>(6, p);
 
    // Building a polyhedron can't currently be done without creating
    // its nodes first
    case C0POLYHEDRON:
      libmesh_not_implemented_msg
        ("Polyhedra cannot be built via Elem::build()");
 
      // 3D elements
    case TET4:
      return std::make_unique<Tet4>(p);
    case TET10:
      return std::make_unique<Tet10>(p);
    case TET14:
      return std::make_unique<Tet14>(p);
    case HEX8:
      return std::make_unique<Hex8>(p);
    case HEX20:
      return std::make_unique<Hex20>(p);
    case HEX27:
      return std::make_unique<Hex27>(p);
    case PRISM6:
      return std::make_unique<Prism6>(p);
    case PRISM15:
      return std::make_unique<Prism15>(p);
    case PRISM18:
      return std::make_unique<Prism18>(p);
    case PRISM20:
      return std::make_unique<Prism20>(p);
    case PRISM21:
      return std::make_unique<Prism21>(p);
    case PYRAMID5:
      return std::make_unique<Pyramid5>(p);
    case PYRAMID13:
      return std::make_unique<Pyramid13>(p);
    case PYRAMID14:
      return std::make_unique<Pyramid14>(p);
    case PYRAMID18:
      return std::make_unique<Pyramid18>(p);
 
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
      // 1D infinite elements
    case INFEDGE2:
      return std::make_unique<InfEdge2>(p);
 
      // 2D infinite elements
    case INFQUAD4:
      return std::make_unique<InfQuad4>(p);
    case INFQUAD6:
      return std::make_unique<InfQuad6>(p);
 
      // 3D infinite elements
    case INFHEX8:
      return std::make_unique<InfHex8>(p);
    case INFHEX16:
      return std::make_unique<InfHex16>(p);
    case INFHEX18:
      return std::make_unique<InfHex18>(p);
    case INFPRISM6:
      return std::make_unique<InfPrism6>(p);
    case INFPRISM12:
      return std::make_unique<InfPrism12>(p);
#endif
 
    default:
      libmesh_error_msg("ERROR: Undefined element type == " << Utility::enum_to_string(type));
    }
}

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

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

◆ build_edge_ptr() [1/4]

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

inlineinherited

Definition at line 2978 of file elem.h.

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

References libMesh::Elem::build_edge_ptr().

◆ build_edge_ptr() [2/4]

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

inlinefinaloverridevirtual

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() [3/4]

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

inlineinherited

Definition at line 2990 of file elem.h.

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

References libMesh::Elem::build_edge_ptr().

◆ build_edge_ptr() [4/4]

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

inlinefinaloverridevirtual

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_side_ptr() [1/8]

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

inline

Definition at line 1019 of file elem.h.

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

◆ build_side_ptr() [2/8]

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

finaloverridevirtual

Returns: A pointer to a NodeElem for the specified node.

Implements libMesh::Elem.

Definition at line 86 of file edge.C.

{
  libmesh_assert_less (i, 2);
  std::unique_ptr<Elem> nodeelem = std::make_unique<NodeElem>();
  nodeelem->set_node(0, this->node_ptr(i));
 
  nodeelem->set_interior_parent(this);
  nodeelem->inherit_data_from(*this);
 
  return nodeelem;
}

References libMesh::Elem::node_ptr().

Referenced by build_side_ptr(), and side_ptr().

◆ build_side_ptr() [3/8]

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

virtual

Returns: An temporary element coincident with side i wrapped in a smart pointer.

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

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

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

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

Implements libMesh::Elem.

◆ build_side_ptr() [4/8]

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

inlinevirtual

Reimplemented from libMesh::Elem.

Definition at line 1025 of file elem.h.

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

libMesh::Edge::build_side_ptr

virtual std::unique_ptr< Elem > build_side_ptr(const unsigned int i) override final

Definition edge.C:86

◆ build_side_ptr() [5/8]

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

inline

Definition at line 1028 of file elem.h.

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

◆ build_side_ptr() [6/8]

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

inline

Definition at line 1047 of file elem.h.

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

◆ build_side_ptr() [7/8]

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

finaloverridevirtual

Rebuilds a NODEELEM for the specified node.

Implements libMesh::Elem.

Definition at line 99 of file edge.C.

{
  libmesh_assert_less (i, this->n_sides());
 
  if (!side.get() || side->type() != NODEELEM)
    side = this->build_side_ptr(i);
  else
    {
      side->set_interior_parent(this);
      side->inherit_data_from(*this);
      side->set_node(0, this->node_ptr(i));
    }
}

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

◆ build_side_ptr() [8/8]

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

virtual

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

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

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

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

Implements libMesh::Elem.

◆ build_with_id()

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

staticinherited

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

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

Definition at line 496 of file elem.C.

{
  // Call the other build() method with nullptr parent, then set the
  // required id.
  auto temp = Elem::build(type, nullptr);
  temp->set_id(id);
  return temp;
}

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

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

◆ center_node_on_side()

unsigned int libMesh::Edge::center_node_on_side ( const unsigned short side ) const

finaloverridevirtual

Returns: The local index of the center node on the side side.

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

Reimplemented from libMesh::Elem.

Definition at line 159 of file edge.C.

{
  libmesh_assert_less (side, this->n_sides());
  return side;
}

References n_sides().

◆ child_neighbor() [1/2]

const Elem * libMesh::Elem::child_neighbor ( const Elem * elem ) const

inlineinherited

Returns: If elem is a neighbor of a child of this element, a pointer to that child, otherwise nullptr.

Definition at line 2790 of file elem.h.

{
  for (auto n : elem->neighbor_ptr_range())
    if (n && n->parent() == this)
      return n;
 
  return nullptr;
}

References libMesh::Elem::neighbor_ptr_range().

◆ child_neighbor() [2/2]

Elem * libMesh::Elem::child_neighbor ( Elem * elem )

inlineinherited

Returns: If elem is a neighbor of a child of this element, a pointer to that child, otherwise nullptr.

Definition at line 2778 of file elem.h.

{
  for (auto n : elem->neighbor_ptr_range())
    if (n && n->parent() == this)
      return n;
 
  return nullptr;
}

References libMesh::Elem::neighbor_ptr_range().

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

◆ child_ptr() [1/2]

Elem * libMesh::Elem::child_ptr ( unsigned int i )

inlineinherited

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

Definition at line 3310 of file elem.h.

{
  libmesh_assert(_children);
  libmesh_assert(_children[i]);
 
  return _children[i];
}

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

◆ child_ptr() [2/2]

const Elem * libMesh::Elem::child_ptr ( unsigned int i ) const

inlineinherited

Returns: A constant pointer to the \( i^{th} \) child for this element. Do not call if this element has no children, i.e. is active.

Definition at line 3301 of file elem.h.

{
  libmesh_assert(_children);
  libmesh_assert(_children[i]);
 
  return _children[i];
}

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

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

◆ child_ref_range() [1/2]

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

inlineinherited

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

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

Definition at line 2476 of file elem.h.

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

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

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

◆ child_ref_range() [2/2]

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

inlineinherited

Definition at line 2484 of file elem.h.

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

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

◆ clear_dofs()

void libMesh::DofObject::clear_dofs ( )

inlineinherited

Clear the DofMap data structures holding degree of freedom data.

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

Definition at line 803 of file dof_object.h.

{
  this->set_n_systems(0);
}

References libMesh::DofObject::set_n_systems().

◆ clear_old_dof_object()

void libMesh::DofObject::clear_old_dof_object ( )

inherited

Sets the old_dof_object to nullptr.

Definition at line 120 of file dof_object.C.

{
  this->old_dof_object.reset(nullptr);
}

References libMesh::DofObject::old_dof_object.

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

◆ close_to_point()

bool libMesh::Elem::close_to_point	(	const Point &	p,
		Real	tol
	)		const

virtualinherited

Returns: true if this element is "close" to the point p, where "close" is determined by the tolerance tol.

Reimplemented in libMesh::NodeElem.

Definition at line 2911 of file elem.C.

{
  // This test uses the user's passed-in tolerance for the
  // bounding box test as well, thereby allowing the routine to
  // find points which are not only "in" the element, but also
  // "nearby" to within some tolerance.
  return this->point_test(p, tol, tol);
}

References libMesh::Elem::point_test().

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

◆ coarsen()

void libMesh::Elem::coarsen ( )

inherited

Coarsen the element.

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

Definition at line 180 of file elem_refinement.C.

{
  libmesh_assert_equal_to (this->refinement_flag(), Elem::COARSEN_INACTIVE);
  libmesh_assert (!this->active());
 
  // We no longer delete children until MeshRefinement::contract()
 
  unsigned int parent_p_level = 0;
 
  const unsigned int n_n = this->n_nodes();
 
  // re-compute hanging node nodal locations
  for (unsigned int c = 0, nc = this->n_children(); c != nc; ++c)
    {
      Elem * mychild = this->child_ptr(c);
      if (mychild == remote_elem)
        continue;
      for (auto cnode : mychild->node_index_range())
        {
          Point new_pos;
          bool calculated_new_pos = false;
 
          for (unsigned int n=0; n<n_n; n++)
            {
              // The value from the embedding matrix
              const Real em_val = this->embedding_matrix(c,cnode,n);
 
              // The node location is somewhere between existing vertices
              if ((em_val != 0.) && (em_val != 1.))
                {
                  new_pos.add_scaled (this->point(n), em_val);
                  calculated_new_pos = true;
                }
            }
 
          if (calculated_new_pos)
            {
              //Move the existing node back into it's original location
              for (unsigned int i=0; i<LIBMESH_DIM; i++)
                {
                  Point & child_node = mychild->point(cnode);
                  child_node(i)=new_pos(i);
                }
            }
        }
    }
 
  for (auto & mychild : this->child_ref_range())
    {
      if (&mychild == remote_elem)
        continue;
      libmesh_assert_equal_to (mychild.refinement_flag(), Elem::COARSEN);
      mychild.set_refinement_flag(Elem::INACTIVE);
      if (mychild.p_level() > parent_p_level)
        parent_p_level = mychild.p_level();
    }
 
  this->set_refinement_flag(Elem::JUST_COARSENED);
  this->set_p_level(parent_p_level);
 
  libmesh_assert (this->active());
}

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

◆ complete_order_equivalent_type()

ElemType libMesh::Elem::complete_order_equivalent_type ( const ElemType et )

staticinherited

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

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

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

Definition at line 3755 of file elem.C.

{
  switch (et)
    {
    case NODEELEM:
      return NODEELEM;
    case EDGE2:
    case EDGE3:
      return EDGE3;
 
    case EDGE4:
      return EDGE4;
 
    case TRI3:
    case TRI6:
    case TRI7:
      return TRI7;
 
      // Currently there is no TRISHELL6, so similarly to other types
      // where this is the case, we just return the input.
    case TRISHELL3:
      return TRISHELL3;
 
    case QUAD4:
    case QUAD8:
    case QUAD9:
      return QUAD9;
 
    case QUADSHELL4:
    case QUADSHELL8:
    case QUADSHELL9:
      return QUADSHELL9;
 
    case TET4:
    case TET10:
    case TET14:
      return TET14;
 
    case HEX8:
    case HEX20:
    case HEX27:
      return HEX27;
 
    // We don't strictly need the 21st node for DoFs, but some code
    // depends on it for e.g. refinement patterns
    case PRISM6:
    case PRISM15:
    case PRISM18:
    case PRISM20:
    case PRISM21:
      return PRISM21;
 
    case PYRAMID5:
    case PYRAMID13:
    case PYRAMID14:
    case PYRAMID18:
      return PYRAMID18;
 
 
 
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
    case INFEDGE2:
      return INFEDGE2;
 
    case INFQUAD4:
    case INFQUAD6:
      return INFQUAD6;
 
    case INFHEX8:
    case INFHEX16:
    case INFHEX18:
      return INFHEX18;
 
    // Probably ought to implement INFPRISM13 and/or 14; until then
    // we'll just return the not-complete-order ElemType, in
    // accordance which what seems like bad precedent...
    case INFPRISM6:
    case INFPRISM12:
      return INFPRISM12;
#endif // LIBMESH_ENABLE_INFINITE_ELEMENTS
 
    default:
      {
        // what did we miss?
        libmesh_error_msg("No complete order equivalent element type for et =  "
                          << Utility::enum_to_string(et));
      }
    }
}

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

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

◆ compute_key() [1/4]

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

inlinestaticprotectedinherited

Returns: A hash key computed from a single node id.

Definition at line 3432 of file elem.h.

{
  return n0;
}

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

{
  // Order the two so that n0 < n1
  if (n0 > n1) std::swap (n0, n1);
 
  return Utility::hashword2(n0, n1);
}

References libMesh::Utility::hashword2().

◆ compute_key() [3/4]

dof_id_type libMesh::Elem::compute_key	(	dof_id_type	n0,
		dof_id_type	n1,
		dof_id_type	n2
	)

inlinestaticprotectedinherited

Returns: A hash key computed from three node ids.

Definition at line 3452 of file elem.h.

{
  std::array<dof_id_type, 3> array = {{n0, n1, n2}};
  std::sort(array.begin(), array.end());
  return Utility::hashword(array);
}

References libMesh::Utility::hashword().

◆ compute_key() [4/4]

dof_id_type libMesh::Elem::compute_key	(	dof_id_type	n0,
		dof_id_type	n1,
		dof_id_type	n2,
		dof_id_type	n3
	)

inlinestaticprotectedinherited

Returns: A hash key computed from four node ids.

Definition at line 3464 of file elem.h.

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

References libMesh::Utility::hashword().

◆ connectivity()

virtual void libMesh::Elem::connectivity	(	const unsigned int	sc,
		const IOPackage	iop,
		std::vector< dof_id_type > &	conn
	)		const

pure virtualinherited

Returns: The connectivity for this element in a specific format, which is specified by the IOPackage tag.

Implemented in libMesh::Hex20, libMesh::Hex27, libMesh::Hex8, libMesh::InfHex16, libMesh::InfHex18, libMesh::InfHex8, libMesh::InfPrism12, libMesh::InfPrism6, libMesh::Prism15, libMesh::Prism18, libMesh::Prism20, libMesh::Prism21, libMesh::Prism6, libMesh::Pyramid13, libMesh::Pyramid14, libMesh::Pyramid18, libMesh::Pyramid5, libMesh::Tet10, libMesh::Tet14, libMesh::Tet4, libMesh::Edge2, libMesh::Edge3, libMesh::Edge4, libMesh::NodeElem, libMesh::InfEdge2, libMesh::C0Polyhedron, libMesh::C0Polygon, libMesh::InfQuad4, libMesh::InfQuad6, libMesh::Quad4, libMesh::Quad8, libMesh::Quad9, libMesh::Tri3, libMesh::Tri6, libMesh::Tri7, and libMesh::RemoteElem.

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

◆ construct()

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

inlineprivateinherited

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

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

Definition at line 746 of file dof_object.h.

{
  return other
    ? std::unique_ptr<DofObject>(new DofObject(*other))
    : std::unique_ptr<DofObject>(new DofObject());
}

References libMesh::DofObject::DofObject().

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

◆ contains_edge_of()

bool libMesh::Elem::contains_edge_of ( const Elem * e ) const

inherited

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

Definition at line 886 of file elem.C.

{
  unsigned int num_contained_edges = 0;
 
  // Our vertices are the first numbered nodes
  for (auto n : make_range(e->n_vertices()))
    {
      if (this->contains_point(e->point(n)))
        {
          num_contained_edges++;
          if (num_contained_edges>=2)
            {
              return true;
            }
        }
    }
  return false;
}

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

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

◆ contains_point()

bool libMesh::Elem::contains_point	(	const Point &	p,
		Real	tol = `TOLERANCE`
	)		const

virtualinherited

Returns: true if the physical point p is contained in this element, false otherwise.

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

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

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

Definition at line 2886 of file elem.C.

{
  // We currently allow the user to enlarge the bounding box by
  // providing a tol > TOLERANCE (so this routine is identical to
  // Elem::close_to_point()), but print a warning so that the
  // user can eventually switch his code over to calling close_to_point()
  // instead, which is intended to be used for this purpose.
  if (tol > TOLERANCE)
    {
      libmesh_do_once(libMesh::err
                      << "WARNING: Resizing bounding box to match user-specified tolerance!\n"
                      << "In the future, calls to Elem::contains_point() with tol > TOLERANCE\n"
                      << "will be more optimized, but should not be used\n"
                      << "to search for points 'close to' elements!\n"
                      << "Instead, use Elem::close_to_point() for this purpose.\n"
                      << std::endl;);
      return this->point_test(p, tol, tol);
    }
  else
    return this->point_test(p, TOLERANCE, tol);
}

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

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

◆ contains_vertex_of()

bool libMesh::Elem::contains_vertex_of	(	const Elem *	e,
		bool	mesh_connection = `false`
	)		const

inherited

Returns: true if a vertex of e is contained in this element. If mesh_connection is true, looks specifically for containment possibilities of an element e that is connected to this via membership in the same manifold of the same mesh.

Definition at line 848 of file elem.C.

{
  // Our vertices are the first numbered nodes
  const unsigned int nv = e->n_vertices();
  const unsigned int my_nv = this->n_vertices();
 
  // Check for vertex-to-vertex containment first; contains_point() is
  // expensive
  for (auto n : make_range(nv))
    {
      const Node * vertex = e->node_ptr(n);
      for (auto my_n : make_range(my_nv))
        if (&this->node_ref(my_n) == vertex)
          return true;
    }
 
  // If e is in our mesh, then we might be done testing
  if (mesh_connection)
    {
      const unsigned int l = this->level();
      const unsigned int el = e->level();
 
      if (l >= el)
        return false;
 
      // We could also return false for l==el-1 iff we knew we had no
      // triangular faces, but we don't have an API to check that.
    }
 
  // Our vertices are the first numbered nodes
  for (auto n : make_range(nv))
    if (this->contains_point(e->point(n)))
      return true;
  return false;
}

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

◆ contract()

void libMesh::Elem::contract ( )

inherited

Contract an active element, i.e.

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

Definition at line 245 of file elem_refinement.C.

{
  // Subactive elements get deleted entirely, not contracted
  libmesh_assert (this->active());
 
  // Active contracted elements no longer can have children
  _children.reset(nullptr);
 
  if (this->refinement_flag() == Elem::JUST_COARSENED)
    this->set_refinement_flag(Elem::DO_NOTHING);
}

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

◆ debug_buffer()

void libMesh::DofObject::debug_buffer ( ) const

inherited

Print our buffer for debugging.

Definition at line 652 of file dof_object.C.

{
  libMesh::out << " [ ";
  for (const auto & idx : _idx_buf)
    libMesh::out << idx << " ";
  libMesh::out << "]\n";
}

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

◆ default_order()

virtual Order libMesh::Elem::default_order ( ) const

pure virtualinherited

Returns: The default approximation order for this element. This is the order that will be used to compute the map to the reference element.

Implemented in libMesh::C0Polyhedron, libMesh::Hex20, libMesh::Hex27, libMesh::Hex8, libMesh::InfHex16, libMesh::InfHex18, libMesh::InfHex8, libMesh::InfPrism12, libMesh::InfPrism6, libMesh::Prism15, libMesh::Prism18, libMesh::Prism20, libMesh::Prism21, libMesh::Prism6, libMesh::Pyramid13, libMesh::Pyramid14, libMesh::Pyramid18, libMesh::Pyramid5, libMesh::Tet10, libMesh::Tet14, libMesh::Tet4, libMesh::Edge2, libMesh::Edge3, libMesh::Edge4, libMesh::InfEdge2, libMesh::C0Polygon, libMesh::InfQuad4, libMesh::InfQuad6, libMesh::Quad4, libMesh::Quad8, libMesh::Quad9, libMesh::Tri3, libMesh::Tri3Subdivision, libMesh::Tri6, libMesh::Tri7, libMesh::NodeElem, and libMesh::RemoteElem.

Referenced by libMesh::MeshTools::Modification::all_rbb(), libMesh::Elem::bracketing_nodes(), libMesh::FEMap::compute_face_map(), libMesh::FEAbstract::compute_node_constraints(), libMesh::InfHex::contains_point(), libMesh::InfPrism::contains_point(), libMesh::MeshBase::copy_constraint_rows(), libMesh::Elem::default_side_order(), libMesh::FEMap::init_face_shape_functions(), libMesh::FEMap::init_reference_to_physical_map(), libMesh::FEMap::map(), libMesh::FEMap::map_deriv(), libMesh::Elem::parent_bracketing_nodes(), libMesh::Elem::point_test(), libMesh::ExodusII_IO::read(), libMesh::Elem::side_vertex_average_normal(), libMesh::Elem::supported_nodal_order(), libMesh::Elem::true_centroid(), and libMesh::Elem::volume().

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

1110{ return default_order(); }

References libMesh::Elem::default_order().

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

◆ dim()

virtual unsigned short libMesh::Edge::dim ( ) const

inlinefinaloverridevirtual

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.

{
  _enable_print_counter = false;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

◆ disable_print_counter_info() [2/2]

void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

Definition at line 100 of file reference_counter.C.

{
  _enable_print_counter = false;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

◆ disconnected_clone()

std::unique_ptr< Elem > libMesh::Elem::disconnected_clone ( ) const

virtualinherited

Returns: An Elem of the same type as this, wrapped in a smart pointer.

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

Reimplemented in libMesh::C0Polyhedron.

Definition at line 350 of file elem.C.

{
  std::unique_ptr<Elem> returnval;
 
  switch (this->type())
    {
    case C0POLYGON:
      returnval = std::make_unique<C0Polygon>(this->n_sides());
      break;
 
    default:
      returnval = Elem::build(this->type());
    }
 
  returnval->set_id() = this->id();
#ifdef LIBMESH_ENABLE_UNIQUE_ID
  if (this->valid_unique_id())
    returnval->set_unique_id(this->unique_id());
#endif
 
  const auto n_elem_ints = this->n_extra_integers();
  returnval->add_extra_integers(n_elem_ints);
  for (unsigned int i = 0; i != n_elem_ints; ++i)
    returnval->set_extra_integer(i, this->get_extra_integer(i));
 
  returnval->inherit_data_from(*this);
 
  return returnval;
}

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

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

◆ dof_number() [1/2]

dof_id_type libMesh::DofObject::dof_number	(	const unsigned int	s,
		const unsigned int	var,
		const unsigned int	comp
	)		const

inlineinherited

Returns: The global degree of freedom number for variable var, component comp for system s associated with this DofObject

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

Definition at line 1022 of file dof_object.h.

{
  libmesh_assert_less (s,    this->n_systems());
  libmesh_assert_less (var,  this->n_vars(s));
  libmesh_assert_less (comp, this->n_comp(s,var));
 
  const std::pair<unsigned int, unsigned int>
    vg_vig = this->var_to_vg_and_offset(s,var);
 
  const unsigned int
    n_comp = this->n_comp_group(s,vg_vig.first);
 
  return this->dof_number(s, vg_vig.first, vg_vig.second,
                          comp, n_comp);
}

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

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

{
  libmesh_assert_less (s,   this->n_systems());
  libmesh_assert_less (vg,  this->n_var_groups(s));
  libmesh_assert_less (vig, this->n_vars(s,vg));
 
  const unsigned int
    start_idx_sys = this->start_idx(s);
 
  libmesh_assert_less ((start_idx_sys + 2*vg + 1), _idx_buf.size());
 
  const dof_id_type
    base_idx = _idx_buf[start_idx_sys + 2*vg + 1];
 
  // if the first component is invalid, they
  // are all invalid
  if (base_idx == invalid_id)
    return invalid_id;
 
  // otherwise the index is the first component
  // index augmented by the component number
  else
    return cast_int<dof_id_type>(base_idx + vig*n_comp + comp);
}

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

◆ edge_index_range()

IntRange< unsigned short > libMesh::Elem::edge_index_range ( ) const

inlineinherited

Returns: An integer range from 0 up to (but not including) the number of edges this element has.

Definition at line 2830 of file elem.h.

{
  return {0, cast_int<unsigned short>(this->n_edges())};
}

References libMesh::Elem::n_edges().

Referenced by libMesh::MeshTools::Modification::all_rbb(), libMesh::FE< Dim, T >::cache(), libMesh::FEGenericBase< OutputType >::coarsened_dof_values(), libMesh::BoundaryInfo::copy_boundary_ids(), libMesh::ElemCutter::find_intersection_points(), libMesh::Elem::quality(), libMesh::ExodusII_IO_Helper::read_edge_blocks(), FETest< order, family, elem_type, CaseName >::testPastVerticesLoop(), and libMesh::Parallel::Packing< Elem * >::unpack().

◆ edge_type()

ElemType libMesh::Elem::edge_type ( const ElemType t )

staticinherited

Returns: The type of every edge of an element of type t, or INVALID_ELEM for the 1D types, which have no edges. Unlike its sides, a finite element's edges all have the same type, so no edge index is needed; the infinite elements, whose finite and infinite edges differ, are not answered here.

Definition at line 3380 of file elem.C.

{
  switch (t)
    {
      // 1D elements have no edges
    case EDGE2:
    case EDGE3:
    case EDGE4:
      return INVALID_ELEM;
      // A 2D element's edges are its sides
    case TRI3:
    case TRISHELL3:
    case TRI6:
    case TRI7:
    case QUAD4:
    case QUADSHELL4:
    case QUAD8:
    case QUADSHELL8:
    case QUAD9:
    case QUADSHELL9:
    case C0POLYGON:
      return side_type(t, 0);
      // A first-order 3D element's edges hold their two vertices
    case TET4:
    case HEX8:
    case PRISM6:
    case PYRAMID5:
    case C0POLYHEDRON:
      return EDGE2;
      // and a second-order element's add the midpoint
    case TET10:
    case TET14:
    case HEX20:
    case HEX27:
    case PRISM15:
    case PRISM18:
    case PRISM20:
    case PRISM21:
    case PYRAMID13:
    case PYRAMID14:
    case PYRAMID18:
      return EDGE3;
    default:
      libmesh_error_msg("No edge type for element type " << Utility::enum_to_string(t));
    }
 
  return INVALID_ELEM;
}

References libMesh::C0POLYGON, libMesh::C0POLYHEDRON, libMesh::EDGE2, libMesh::EDGE3, libMesh::EDGE4, libMesh::Utility::enum_to_string(), libMesh::HEX20, libMesh::HEX27, libMesh::HEX8, libMesh::INVALID_ELEM, 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::Elem::side_type(), libMesh::TET10, libMesh::TET14, libMesh::TET4, libMesh::TRI3, libMesh::TRI6, libMesh::TRI7, and libMesh::TRISHELL3.

Referenced by libMesh::Elem::local_edge_node(), and ElemTest< elem_type >::test_static_topology().

◆ edges_adjacent_to_node()

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

inlinefinaloverridevirtual

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::Elem::embedding_matrix	(	const unsigned int	child_num,
		const unsigned int	child_node_num,
		const unsigned int	parent_node_num
	)		const

pure virtualinherited

Returns: The embedding matrix entry for the requested child.

Implemented in libMesh::Hex20, libMesh::Hex27, libMesh::Hex8, libMesh::InfHex16, libMesh::InfHex18, libMesh::InfHex8, libMesh::InfPrism12, libMesh::InfPrism6, libMesh::Prism15, libMesh::Prism18, libMesh::Prism21, libMesh::Prism6, libMesh::Tet10, libMesh::Tet14, libMesh::Tet4, libMesh::Edge2, libMesh::Edge3, libMesh::Edge4, libMesh::InfQuad4, libMesh::InfQuad6, libMesh::Quad4, libMesh::Quad8, libMesh::Quad9, libMesh::Tri3, libMesh::Tri6, libMesh::Tri7, libMesh::NodeElem, libMesh::C0Polyhedron, libMesh::Prism20, libMesh::Pyramid13, libMesh::Pyramid14, libMesh::Pyramid18, libMesh::Pyramid5, libMesh::InfEdge2, libMesh::C0Polygon, and libMesh::RemoteElem.

Referenced by libMesh::MeshRefinement::add_node(), libMesh::Elem::as_parent_node(), libMesh::Elem::coarsen(), libMesh::Tet::is_child_on_side_helper(), main(), libMesh::Elem::parent_bracketing_nodes(), and libMesh::MeshTools::Modification::smooth().

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

2181{ return 0; }

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

◆ enable_print_counter_info() [1/2]

void libMesh::ReferenceCounter::enable_print_counter_info ( )

staticinherited

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

Enabled by default.

Definition at line 94 of file reference_counter.C.

{
  _enable_print_counter = true;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

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

◆ enable_print_counter_info() [2/2]

void libMesh::ReferenceCounter::enable_print_counter_info ( )

staticinherited

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

Enabled by default.

Definition at line 94 of file reference_counter.C.

{
  _enable_print_counter = true;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

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

◆ end_idx()

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

inlineprivateinherited

The ending index for system s.

Definition at line 1250 of file dof_object.h.

{
  libmesh_assert_less (s, this->n_systems());
  libmesh_assert_less (s, _idx_buf.size());
 
  return ((s+1) == this->n_pseudo_systems()) ?
    cast_int<unsigned int>(_idx_buf.size()) :
    cast_int<unsigned int>(_idx_buf[s+1]);
}

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

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

◆ end_idx_ints()

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

inlineprivateinherited

The ending index for an extra_integers pseudosystem.

Definition at line 1277 of file dof_object.h.

{
  libmesh_assert (this->has_extra_integers());
 
  return cast_int<unsigned int>(_idx_buf.size());
}

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

◆ face_index_range()

IntRange< unsigned short > libMesh::Elem::face_index_range ( ) const

inlineinherited

Returns: An integer range from 0 up to (but not including) the number of faces this element has.

Definition at line 2839 of file elem.h.

{
  return {0, cast_int<unsigned short>(this->n_faces())};
}

References libMesh::Elem::n_faces().

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

◆ face_orientation()

unsigned int libMesh::Elem::face_orientation ( const unsigned int i ) const

inherited

Returns: An index over the symmetries of face i (six for a triangle, eight for a quadrilateral): twice the position of the lexicographically least vertex in the face's node map, plus 1 if the face is positively oriented.

Unlike positive_face_orientation(), this fixes the full ordering of the face's vertices, which a basis with face degrees of freedom (e.g. HIERARCHIC of order three or above) needs in order to be conforming across the face.

Definition at line 4053 of file elem.C.

{
  libmesh_assert_less (i, this->n_faces());
 
  // Get the number of vertices N of face i. Note that for 3d elements, i.e.
  // elements for which this->n_faces() > 0, the number of vertices on any of
  // its sides (or faces) is just the number of that face's sides (or edges).
  const unsigned int N = Elem::type_to_n_sides_map[this->side_type(i)];
 
  const std::vector<unsigned int> nodes = this->nodes_on_side(i);
 
  auto cmp = [&](const unsigned int & m, const unsigned int & n) -> bool
             { return this->point(m) < this->point(n); };
 
  const unsigned int v = std::distance(nodes.begin(),
                         std::min_element(nodes.begin(), nodes.begin() + N, cmp));
 
  // v is the position of the least vertex. Compare its neighbors just
  // before and after it, cyclically: the face is positively oriented iff
  // the lesser neighbor precedes v, i.e. the vertices run backward from
  // the least vertex through the face's node map.
  return 2 * v + cmp(nodes[(v - 1 + N) % N], nodes[(v + 1) % N]);
}

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

Referenced by FEOrientationTestBase< order, family >::entity_orientation(), libMesh::Elem::oriented_face_vertices(), and libMesh::Elem::positive_face_orientation().

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

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

References libMesh::ElemInternal::family_tree().

◆ family_tree() [2/2]

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

inherited

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

Definition at line 2220 of file elem.C.

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

References libMesh::ElemInternal::family_tree().

◆ family_tree_by_neighbor() [1/2]

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

inherited

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

Definition at line 2314 of file elem.C.

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

References libMesh::ElemInternal::family_tree_by_neighbor().

◆ family_tree_by_neighbor() [2/2]

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

inherited

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

Definition at line 2323 of file elem.C.

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

References libMesh::ElemInternal::family_tree_by_neighbor().

◆ family_tree_by_side() [1/2]

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

inherited

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

Definition at line 2260 of file elem.C.

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

References libMesh::ElemInternal::family_tree_by_side().

◆ family_tree_by_side() [2/2]

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

inherited

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

Definition at line 2269 of file elem.C.

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

References libMesh::ElemInternal::family_tree_by_side().

◆ family_tree_by_subneighbor() [1/2]

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

inherited

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

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

Definition at line 2350 of file elem.C.

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

References libMesh::ElemInternal::family_tree_by_subneighbor().

◆ family_tree_by_subneighbor() [2/2]

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

inherited

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

Definition at line 2360 of file elem.C.

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

References libMesh::ElemInternal::family_tree_by_subneighbor().

◆ find_edge_neighbors() [1/2]

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

inherited

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

Definition at line 997 of file elem.C.

{
  // Simple but perhaps suboptimal code: find elements containing the
  // first point, then winnow this set down by removing elements which
  // don't also contain the second point
 
  libmesh_assert(this->contains_point(p2));
  this->find_point_neighbors(p1, neighbor_set);
 
  std::set<const Elem *>::iterator        it = neighbor_set.begin();
  const std::set<const Elem *>::iterator end = neighbor_set.end();
 
  while (it != end)
    {
      // As of C++11, set::erase returns an iterator to the element
      // following the erased element, or end.
      if (!(*it)->contains_point(p2))
        it = neighbor_set.erase(it);
      else
        ++it;
    }
}

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

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

◆ find_edge_neighbors() [2/2]

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

inherited

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

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

Definition at line 1024 of file elem.C.

{
  neighbor_set.clear();
  neighbor_set.insert(this);
 
  std::set<const Elem *> untested_set, next_untested_set;
  untested_set.insert(this);
 
  while (!untested_set.empty())
    {
      // Loop over all the elements in the patch that haven't already
      // been tested
      for (const auto & elem : untested_set)
        {
          for (auto current_neighbor : elem->neighbor_ptr_range())
            {
              if (current_neighbor &&
                  current_neighbor != remote_elem)    // we have a real neighbor on this side
                {
                  if (current_neighbor->active())                // ... if it is active
                    {
                      if (this->contains_edge_of(current_neighbor) // ... and touches us
                          || current_neighbor->contains_edge_of(this))
                        {
                          // Make sure we'll test it
                          if (!neighbor_set.count(current_neighbor))
                            next_untested_set.insert (current_neighbor);
 
                          // And add it
                          neighbor_set.insert (current_neighbor);
                        }
                    }
#ifdef LIBMESH_ENABLE_AMR
                  else                                 // ... the neighbor is *not* active,
                    {                                  // ... so add *all* neighboring
                                                       // active children
                      std::vector<const Elem *> active_neighbor_children;
 
                      current_neighbor->active_family_tree_by_neighbor
                        (active_neighbor_children, elem);
 
                      for (const auto & current_child : active_neighbor_children)
                        if (this->contains_edge_of(current_child) || current_child->contains_edge_of(this))
                          {
                            // Make sure we'll test it
                            if (!neighbor_set.count(current_child))
                              next_untested_set.insert (current_child);
 
                            neighbor_set.insert (current_child);
                          }
                    }
#endif // #ifdef LIBMESH_ENABLE_AMR
                }
            }
        }
      untested_set.swap(next_untested_set);
      next_untested_set.clear();
    }
}

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

◆ find_interior_neighbors() [1/2]

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

inherited

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

Definition at line 1086 of file elem.C.

{
  ElemInternal::find_interior_neighbors(this, neighbor_set);
}

References libMesh::ElemInternal::find_interior_neighbors().

◆ find_interior_neighbors() [2/2]

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

inherited

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

Definition at line 1093 of file elem.C.

{
  ElemInternal::find_interior_neighbors(this, neighbor_set);
}

References libMesh::ElemInternal::find_interior_neighbors().

◆ find_point_neighbors() [1/4]

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

inherited

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

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

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

Definition at line 907 of file elem.C.

{
  libmesh_assert(this->contains_point(p));
  libmesh_assert(this->active());
 
  neighbor_set.clear();
  neighbor_set.insert(this);
 
  std::set<const Elem *> untested_set, next_untested_set;
  untested_set.insert(this);
 
#ifdef LIBMESH_ENABLE_AMR
  std::vector<const Elem *> active_neighbor_children;
#endif // #ifdef LIBMESH_ENABLE_AMR
 
  while (!untested_set.empty())
    {
      // Loop over all the elements in the patch that haven't already
      // been tested
      for (const auto & elem : untested_set)
          for (auto current_neighbor : elem->neighbor_ptr_range())
            {
              if (current_neighbor &&
                  current_neighbor != remote_elem)    // we have a real neighbor on this side
                {
                  if (current_neighbor->active())                // ... if it is active
                    {
                      auto it = neighbor_set.lower_bound(current_neighbor);
                      if ((it == neighbor_set.end() || *it != current_neighbor) &&
                          current_neighbor->contains_point(p))   // ... don't have and touches p
                        {
                          // Add it and test it
                          next_untested_set.insert(current_neighbor);
                          neighbor_set.emplace_hint(it, current_neighbor);
                        }
                    }
#ifdef LIBMESH_ENABLE_AMR
                  else                                 // ... the neighbor is *not* active,
                    {                                  // ... so add *all* neighboring
                                                       // active children that touch p
                      active_neighbor_children.clear();
                      current_neighbor->active_family_tree_by_neighbor
                        (active_neighbor_children, elem);
 
                      for (const auto & current_child : active_neighbor_children)
                        {
                          auto it = neighbor_set.lower_bound(current_child);
                          if ((it == neighbor_set.end() || *it != current_child) &&
                              current_child->contains_point(p))
                            {
                              // Add it and test it
                              next_untested_set.insert(current_child);
                              neighbor_set.emplace_hint(it, current_child);
                            }
                        }
                    }
#endif // #ifdef LIBMESH_ENABLE_AMR
                }
            }
      untested_set.swap(next_untested_set);
      next_untested_set.clear();
    }
}

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

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

◆ find_point_neighbors() [2/4]

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

inherited

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

Definition at line 974 of file elem.C.

{
  this->find_point_neighbors(neighbor_set, this);
}

References libMesh::Elem::find_point_neighbors().

◆ find_point_neighbors() [3/4]

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

inherited

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

Definition at line 981 of file elem.C.

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

References libMesh::ElemInternal::find_point_neighbors().

◆ find_point_neighbors() [4/4]

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

inherited

Non-const version of function above.

Fills a set of non-const Elem pointers.

Definition at line 989 of file elem.C.

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

References libMesh::ElemInternal::find_point_neighbors().

◆ first_order_equivalent_type()

ElemType libMesh::Elem::first_order_equivalent_type ( const ElemType et )

staticinherited

Returns: The element type of the associated first-order element, or INVALID_ELEM for first-order or other elements that cannot be converted into lower order equivalents.

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

Definition at line 3201 of file elem.C.

{
  switch (et)
    {
    case NODEELEM:
      return NODEELEM;
    case EDGE2:
    case EDGE3:
    case EDGE4:
      return EDGE2;
    case TRI3:
    case TRI6:
    case TRI7:
      return TRI3;
    case TRISHELL3:
      return TRISHELL3;
    case QUAD4:
    case QUAD8:
    case QUAD9:
      return QUAD4;
    case QUADSHELL4:
    case QUADSHELL8:
    case QUADSHELL9:
      return QUADSHELL4;
    case TET4:
    case TET10:
    case TET14:
      return TET4;
    case HEX8:
    case HEX27:
    case HEX20:
      return HEX8;
    case PRISM6:
    case PRISM15:
    case PRISM18:
    case PRISM20:
    case PRISM21:
      return PRISM6;
    case PYRAMID5:
    case PYRAMID13:
    case PYRAMID14:
    case PYRAMID18:
      return PYRAMID5;
 
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
 
    case INFEDGE2:
      return INFEDGE2;
    case INFQUAD4:
    case INFQUAD6:
      return INFQUAD4;
    case INFHEX8:
    case INFHEX16:
    case INFHEX18:
      return INFHEX8;
    case INFPRISM6:
    case INFPRISM12:
      return INFPRISM6;
 
#endif
 
    default:
      // unknown element
      return INVALID_ELEM;
    }
}

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

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

◆ flip()

virtual void libMesh::Elem::flip ( BoundaryInfo * boundary_info )

pure virtualinherited

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

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

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

Implemented in libMesh::Hex20, libMesh::Hex27, libMesh::Hex8, libMesh::InfHex16, libMesh::InfHex18, libMesh::InfHex8, libMesh::InfPrism12, libMesh::InfPrism6, libMesh::Polyhedron, libMesh::Prism15, libMesh::Prism18, libMesh::Prism20, libMesh::Prism21, libMesh::Prism6, libMesh::Pyramid13, libMesh::Pyramid14, libMesh::Pyramid18, libMesh::Pyramid5, libMesh::Tet10, libMesh::Tet14, libMesh::Tet4, libMesh::Edge2, libMesh::Edge3, libMesh::Edge4, libMesh::InfEdge2, libMesh::C0Polygon, libMesh::InfQuad4, libMesh::InfQuad6, libMesh::Quad4, libMesh::Quad8, libMesh::Quad9, libMesh::Tri3, libMesh::Tri6, libMesh::Tri7, libMesh::NodeElem, and libMesh::RemoteElem.

Referenced by libMesh::MeshTetInterface::improve_hull_integrity(), libMesh::Elem::orient(), VolumeTest::testC0PolygonMethods(), and libMesh::MeshTetInterface::volume_to_surface_mesh().

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

{
#ifndef NDEBUG
  const unsigned int n_more_integers = (sizeof(T)-1)/sizeof(dof_id_type);
#endif
  libmesh_assert_less(index+n_more_integers, this->n_extra_integers());
  libmesh_assert_less(this->n_systems(), _idx_buf.size());
 
  const unsigned int start_idx_i = this->start_idx_ints();
 
  libmesh_assert_less(start_idx_i+index+n_more_integers, _idx_buf.size());
  T returnval;
  std::memcpy(&returnval, &_idx_buf[start_idx_i+index], sizeof(T));
  return returnval;
}

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

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

◆ get_extra_integer()

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

inlineinherited

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

Definition at line 1092 of file dof_object.h.

{
  libmesh_assert_less(index, this->n_extra_integers());
  libmesh_assert_less(this->n_systems(), _idx_buf.size());
 
  const unsigned int start_idx_i = this->start_idx_ints();
 
  libmesh_assert_less(start_idx_i+index, _idx_buf.size());
  return _idx_buf[start_idx_i+index];
}

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

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

◆ get_info() [1/3]

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

staticinherited

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

{
#if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
 
  std::ostringstream oss;
 
  oss << '\n'
      << " ---------------------------------------------------------------------------- \n"
      << "| Reference count information                                                |\n"
      << " ---------------------------------------------------------------------------- \n";
 
  for (const auto & [name, cd] : _counts)
    oss << "| " << name << " reference count information:\n"
        << "|  Creations:    " << cd.first    << '\n'
        << "|  Destructions: " << cd.second << '\n';
 
  oss << " ---------------------------------------------------------------------------- \n";
 
  return oss.str();
 
#else
 
  return "";
 
#endif
}

References libMesh::ReferenceCounter::_counts.

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

◆ get_info() [2/3]

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

staticinherited

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

{
#if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
 
  std::ostringstream oss;
 
  oss << '\n'
      << " ---------------------------------------------------------------------------- \n"
      << "| Reference count information                                                |\n"
      << " ---------------------------------------------------------------------------- \n";
 
  for (const auto & [name, cd] : _counts)
    oss << "| " << name << " reference count information:\n"
        << "|  Creations:    " << cd.first    << '\n'
        << "|  Destructions: " << cd.second << '\n';
 
  oss << " ---------------------------------------------------------------------------- \n";
 
  return oss.str();
 
#else
 
  return "";
 
#endif
}

References libMesh::ReferenceCounter::_counts.

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

◆ get_info() [3/3]

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

inherited

Prints relevant information about the element to a string.

Definition at line 3058 of file elem.C.

{
  std::ostringstream oss;
 
  oss << "  Elem Information"                                      << '\n'
      << "   id()=";
 
  if (this->valid_id())
    oss << this->id();
  else
    oss << "invalid";
 
#ifdef LIBMESH_ENABLE_UNIQUE_ID
  oss << ", unique_id()=";
  if (this->valid_unique_id())
    oss << this->unique_id();
  else
    oss << "invalid";
#endif
 
  oss << ", subdomain_id()=" << this->subdomain_id();
  oss << ", processor_id()=" << this->processor_id()               << '\n';
 
  oss << "   type()="    << Utility::enum_to_string(this->type())  << '\n'
      << "   dim()="     << this->dim()                            << '\n'
      << "   n_nodes()=" << this->n_nodes()                        << '\n';
 
  oss << "   mapping=" << Utility::enum_to_string(this->mapping_type()) << '\n';
 
  for (auto n : this->node_index_range())
    {
      oss << "    " << n << this->node_ref(n);
      if (this->mapping_type() == RATIONAL_BERNSTEIN_MAP)
        {
          const unsigned char datum_index = this->mapping_data();
          oss << "    weight=" <<
            this->node_ref(n).get_extra_datum<Real>(datum_index) << '\n';
        }
    }
 
  oss << "   n_sides()=" << this->n_sides()                        << '\n';
 
  for (auto s : this->side_index_range())
    {
      oss << "    neighbor(" << s << ")=";
      if (this->neighbor_ptr(s))
        oss << this->neighbor_ptr(s)->id() << '\n';
      else
        oss << "nullptr\n";
    }
 
  if (!this->infinite())
    {
    oss << "   hmin()=" << this->hmin()
        << ", hmax()=" << this->hmax()                             << '\n'
        << "   volume()=" << this->volume()                        << '\n';
    }
  oss << "   active()=" << this->active()
    << ", ancestor()=" << this->ancestor()
    << ", subactive()=" << this->subactive()
    << ", has_children()=" << this->has_children()               << '\n'
    << "   parent()=";
  if (this->parent())
    oss << this->parent()->id() << '\n';
  else
    oss << "nullptr\n";
  oss << "   level()=" << this->level()
      << ", p_level()=" << this->p_level()                         << '\n'
#ifdef LIBMESH_ENABLE_AMR
      << "   refinement_flag()=" << Utility::enum_to_string(this->refinement_flag())        << '\n'
      << "   p_refinement_flag()=" << Utility::enum_to_string(this->p_refinement_flag())    << '\n'
#endif
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
      << "   infinite()=" << this->infinite()    << '\n';
  if (this->infinite())
    oss << "   origin()=" << this->origin()    << '\n'
#endif
      ;
 
  oss << "   DoFs=";
  for (auto s : make_range(this->n_systems()))
    for (auto v : make_range(this->n_vars(s)))
      for (auto c : make_range(this->n_comp(s,v)))
        oss << '(' << s << '/' << v << '/' << this->dof_number(s,v,c) << ") ";
 
 
  return oss.str();
}

Referenced by libMesh::MeshTetInterface::check_hull_integrity(), libMesh::FEMap::compute_single_point_map(), libMesh::FEMap::inverse_map(), and libMesh::Elem::print_info().

◆ get_node_index()

unsigned int libMesh::Elem::get_node_index ( const Node * node_ptr ) const

inlineinherited

Returns: The local index for the Node pointer node_ptr, or invalid_uint if node_ptr is not a local node.

Definition at line 2675 of file elem.h.

{
  for (auto n : make_range(this->n_nodes()))
    if (this->_nodes[n] == node_ptr)
      return n;
 
  return libMesh::invalid_uint;
}

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

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

◆ get_nodes()

const Node *const * libMesh::Elem::get_nodes ( ) const

inlineinherited

Returns: A pointer to an array of local node pointers.

Definition at line 2629 of file elem.h.

{
  return _nodes;
}

References libMesh::Elem::_nodes.

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

◆ get_old_dof_object() [1/2]

DofObject * libMesh::DofObject::get_old_dof_object ( )

inlineinherited

Pointer accessor for previously public old_dof_object.

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

Definition at line 96 of file dof_object.h.

96{ return old_dof_object.get(); }

References libMesh::DofObject::old_dof_object.

◆ get_old_dof_object() [2/2]

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

inlineinherited

Definition at line 97 of file dof_object.h.

97{ return old_dof_object.get(); }

References libMesh::DofObject::old_dof_object.

◆ get_old_dof_object_ref() [1/2]

DofObject & libMesh::DofObject::get_old_dof_object_ref ( )

inlineinherited

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

Definition at line 104 of file dof_object.h.

  {
    libmesh_assert(old_dof_object);
    return *old_dof_object;
  }

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

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

◆ get_old_dof_object_ref() [2/2]

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

inlineinherited

Definition at line 110 of file dof_object.h.

  {
    libmesh_assert(old_dof_object);
    return *old_dof_object;
  }

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

◆ hack_p_level()

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

inlineinherited

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

Definition at line 3402 of file elem.h.

{
  if (p == 0)
    libmesh_assert_not_equal_to
      (this->p_refinement_flag(), Elem::JUST_REFINED);
 
  _p_level = cast_int<unsigned char>(p);
}

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

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

◆ hack_p_level_and_refinement_flag()

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

inlineinherited

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

Definition at line 3413 of file elem.h.

{
  _pflag = cast_int<unsigned char>(pflag);
  this->hack_p_level(p);
}

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

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

◆ has_affine_map()

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

inlinevirtualinherited

Returns: true if the element map is definitely affine (i.e. the same at every quadrature point) within numerical tolerances.

Reimplemented in libMesh::C0Polyhedron, libMesh::Hex20, libMesh::Hex27, libMesh::Hex8, libMesh::Prism15, libMesh::Prism18, libMesh::Prism20, libMesh::Prism21, libMesh::Prism6, libMesh::Pyramid13, libMesh::Pyramid14, libMesh::Pyramid18, libMesh::Pyramid5, libMesh::Tet10, libMesh::Tet14, libMesh::Tet4, libMesh::Edge2, libMesh::Edge3, libMesh::Edge4, libMesh::C0Polygon, libMesh::Quad4, libMesh::Quad8, libMesh::Quad9, libMesh::Tri3, libMesh::Tri3Subdivision, libMesh::Tri6, libMesh::Tri7, and libMesh::NodeElem.

Definition at line 1312 of file elem.h.

1312{ return false; }

Referenced by libMesh::FEMap::compute_map(), libMesh::HDivFETransformation< OutputShape >::map_dphi(), and ElemTest< elem_type >::test_n_refinements().

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

{
#ifdef LIBMESH_ENABLE_AMR
  if (!_children)
    return false;
  else
    for (auto & c : child_ref_range())
      if (c.has_children())
        return true;
#endif
  return false;
}

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

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

◆ has_children()

bool libMesh::Elem::has_children ( ) const

inlineinherited

Returns: true if the element has any children (active or not), false otherwise, or if AMR is disabled.

Definition at line 3117 of file elem.h.

{
#ifdef LIBMESH_ENABLE_AMR
  if (!_children)
    return false;
  else
    return true;
#else
  return false;
#endif
}

References libMesh::Elem::_children.

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

◆ has_dofs()

bool libMesh::DofObject::has_dofs ( const unsigned int s = libMesh::invalid_uint ) const

inlineinherited

Returns: true if any system has variables which have been assigned, false otherwise.

Definition at line 1216 of file dof_object.h.

{
  if (sys == libMesh::invalid_uint)
    {
      for (auto s : make_range(this->n_systems()))
        if (this->n_vars(s))
          return true;
    }
 
  else
    {
      libmesh_assert_less (sys, this->n_systems());
 
      if (this->n_vars(sys))
        return true;
    }
 
  return false;
}

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

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

◆ has_extra_integers()

bool libMesh::DofObject::has_extra_integers ( ) const

inlineinherited

Returns whether extra integers are associated to the DofObject.

Definition at line 1178 of file dof_object.h.

{
  if (_idx_buf.empty())
    return 0;
 
  return (dof_id_signed_type(_idx_buf[0]) < 0);
}

References libMesh::DofObject::_idx_buf.

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

◆ has_invertible_map()

bool libMesh::Elem::has_invertible_map ( Real tol = TOLERANCE*TOLERANCE ) const

virtualinherited

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

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

Definition at line 3016 of file elem.C.

{
  QNodal qnodal {this->dim()};
  FEMap fe_map;
  auto & jac = fe_map.get_jacobian();
 
  // We have a separate check for is_singular_node() below, so in this
  // case its "OK" to do nodal quadrature on pyramids.
  qnodal.allow_nodal_pyramid_quadrature = true;
  qnodal.init(*this);
  auto & qp = qnodal.get_points();
  libmesh_assert_equal_to(qp.size(), this->n_nodes());
 
  std::vector<Point> one_point(1);
  std::vector<Real> one_weight(1,1);
  for (auto i : index_range(qp))
    {
      if (this->is_singular_node(i))
        continue;
 
      one_point[0] = qp[i];
 
      fe_map.init_reference_to_physical_map(this->dim(), one_point, this);
      fe_map.compute_map(this->dim(), one_weight, this, false);
 
      if (jac[0] <= 0)
        return false;
    }
 
  return true;
}

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

Referenced by VolumeTest::testEdge4Invertible().

◆ has_neighbor()

bool libMesh::Elem::has_neighbor ( const Elem * elem ) const

inlineinherited

Returns: true if the element elem in question is a neighbor of this element, false otherwise.

Definition at line 2766 of file elem.h.

{
  for (auto n : this->neighbor_ptr_range())
    if (n == elem)
      return true;
 
  return false;
}

References libMesh::Elem::neighbor_ptr_range().

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

◆ has_topological_neighbor()

bool libMesh::Elem::has_topological_neighbor	(	const Elem *	elem,
		const MeshBase &	mesh,
		const PointLocatorBase &	point_locator,
		const PeriodicBoundaries *	pb
	)		const

inherited

Returns: true if the element elem in question is a neighbor or topological neighbor of this element, false otherwise.

Definition at line 1264 of file elem.C.

{
  // First see if this is a normal "interior" neighbor
  if (has_neighbor(elem))
    return true;
 
  for (auto n : this->side_index_range())
    if (this->topological_neighbor(n, mesh, point_locator, pb))
      return true;
 
  return false;
}

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

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

◆ hmax()

Real libMesh::Elem::hmax ( ) const

virtualinherited

Returns: The maximum vertex separation for the element.

Definition at line 647 of file elem.C.

{
  Real h_max=0;
 
  // Avoid calling a virtual a lot of times
  const auto n_vertices = this->n_vertices();
 
  for (unsigned int n_outer=0; n_outer<n_vertices; n_outer++)
    for (unsigned int n_inner=n_outer+1; n_inner<n_vertices; n_inner++)
      {
        const auto diff = (this->point(n_outer) - this->point(n_inner));
 
        h_max = std::max(h_max, diff.norm_sq());
      }
 
  return std::sqrt(h_max);
}

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

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

◆ hmin()

Real libMesh::Elem::hmin ( ) const

virtualinherited

Returns: The minimum vertex separation for the element.

Definition at line 623 of file elem.C.

{
  // Avoid calling a virtual a lot of times
  const auto n_vertices = this->n_vertices();
 
  // Special case for NodeElem
  if (!n_vertices)
    return 0;
 
  Real h_min=std::numeric_limits<Real>::max();
 
  for (unsigned int n_outer=0; n_outer<n_vertices; n_outer++)
    for (unsigned int n_inner=n_outer+1; n_inner<n_vertices; n_inner++)
      {
        const auto diff = (this->point(n_outer) - this->point(n_inner));
 
        h_min = std::min(h_min, diff.norm_sq());
      }
 
  return std::sqrt(h_min);
}

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

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

◆ id()

dof_id_type libMesh::DofObject::id ( ) const

inlineinherited

Returns: The id for this DofObject

Definition at line 833 of file dof_object.h.

{
  return _id;
}

References libMesh::DofObject::_id.

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

{
  libmesh_try
  {
    Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
    std::pair<unsigned int, unsigned int> & p = _counts[name];
    p.first++;
  }
  libmesh_catch (...)
  {
    auto stream = libMesh::err.get();
    stream->exceptions(stream->goodbit); // stream must not throw
    libMesh::err << "Encountered unrecoverable error while calling "
                 << "ReferenceCounter::increment_constructor_count() "
                 << "for a(n) " << name << " object." << std::endl;
    std::terminate();
  }
}

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

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

◆ increment_constructor_count() [2/2]

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

inlineprotectednoexceptinherited

Increments the construction counter.

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

Definition at line 183 of file reference_counter.h.

{
  libmesh_try
  {
    Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
    std::pair<unsigned int, unsigned int> & p = _counts[name];
    p.first++;
  }
  libmesh_catch (...)
  {
    auto stream = libMesh::err.get();
    stream->exceptions(stream->goodbit); // stream must not throw
    libMesh::err << "Encountered unrecoverable error while calling "
                 << "ReferenceCounter::increment_constructor_count() "
                 << "for a(n) " << name << " object." << std::endl;
    std::terminate();
  }
}

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

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

◆ increment_destructor_count() [1/2]

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

inlineprotectednoexceptinherited

Increments the destruction counter.

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

Definition at line 207 of file reference_counter.h.

{
  libmesh_try
  {
    Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
    std::pair<unsigned int, unsigned int> & p = _counts[name];
    p.second++;
  }
  libmesh_catch (...)
  {
    auto stream = libMesh::err.get();
    stream->exceptions(stream->goodbit); // stream must not throw
    libMesh::err << "Encountered unrecoverable error while calling "
                 << "ReferenceCounter::increment_destructor_count() "
                 << "for a(n) " << name << " object." << std::endl;
    std::terminate();
  }
}

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

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

◆ increment_destructor_count() [2/2]

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

inlineprotectednoexceptinherited

Increments the destruction counter.

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

Definition at line 207 of file reference_counter.h.

{
  libmesh_try
  {
    Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
    std::pair<unsigned int, unsigned int> & p = _counts[name];
    p.second++;
  }
  libmesh_catch (...)
  {
    auto stream = libMesh::err.get();
    stream->exceptions(stream->goodbit); // stream must not throw
    libMesh::err << "Encountered unrecoverable error while calling "
                 << "ReferenceCounter::increment_destructor_count() "
                 << "for a(n) " << name << " object." << std::endl;
    std::terminate();
  }
}

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

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

◆ infinite() [1/2]

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

inlinestaticconstexprinherited

Definition at line 2048 of file elem.h.

2048{ return false; }

◆ infinite() [2/2]

virtual bool libMesh::Elem::infinite ( ) const

pure virtualinherited

Returns: true if the element is an infinite element, false otherwise.

Implemented in libMesh::Cell, libMesh::InfCell, libMesh::Edge2, libMesh::Edge3, libMesh::Edge4, libMesh::InfEdge2, libMesh::NodeElem, libMesh::RemoteElem, libMesh::Face, and libMesh::InfQuad.

Referenced by libMesh::DofMap::_dof_indices(), libMesh::MeshFunction::_gradient_on_elem(), libMesh::MeshTools::Modification::all_rbb(), libMesh::FEInterface::all_shapes(), libMesh::FEMContext::cached_fe(), libMesh::FEAbstract::compute_node_constraints(), libMesh::FEGenericBase< OutputType >::compute_periodic_constraints(), libMesh::FEGenericBase< OutputType >::compute_proj_constraints(), libMesh::Elem::get_info(), libMesh::MeshFunction::hessian(), libMesh::InfFE< Dim, T_radial, T_map >::init_face_shape_functions(), libMesh::TreeNode< N >::insert(), libMesh::FEMap::inverse_map(), libMesh::FEMap::inverse_map(), libMesh::Elem::is_mid_infinite_edge_node(), libMesh::FEMap::map(), libMesh::FEMap::map_deriv(), libMesh::DofMap::old_dof_indices(), libMesh::System::point_hessian(), libMesh::FEInterface::shape(), libMesh::FEInterface::shape_deriv(), libMesh::FEInterface::shape_deriv(), libMesh::FEInterface::shape_second_deriv(), libMesh::FEInterface::shape_second_deriv(), libMesh::FEInterface::shapes(), ElemTest< elem_type >::test_orientation_conformity(), InfFERadialTest::testInfQuants(), InfFERadialTest::testInfQuants_numericDeriv(), FETest< order, family, elem_type, CaseName >::testPastVerticesLoop(), InfFERadialTest::testRefinement(), FETest< order, family, elem_type, CaseName >::testRefspaceNodes(), InfFERadialTest::testSides(), and InfFERadialTest::testSingleOrder().

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

{
  this->set_mapping_type(src.mapping_type());
  this->set_mapping_data(src.mapping_data());
  this->subdomain_id() = src.subdomain_id();
  this->processor_id(src.processor_id());
#ifdef LIBMESH_ENABLE_AMR
  this->set_p_level(src.p_level());
#endif
}

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

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

◆ interior_parent() [1/2]

Elem * libMesh::Elem::interior_parent ( )

inherited

Definition at line 1145 of file elem.C.

{
  // See the const version for comments
  if (this->dim() >= LIBMESH_DIM)
      return nullptr;
 
  Elem * interior_p = _elemlinks[1+this->n_sides()];
 
  libmesh_assert (!interior_p ||
                  (interior_p == remote_elem) ||
                  (interior_p->dim() > this->dim()));
 
  return interior_p;
}

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

◆ interior_parent() [2/2]

const Elem * libMesh::Elem::interior_parent ( ) const

inherited

Returns: The higher-dimensional Elem for which this Elem is a face.

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

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

Definition at line 1100 of file elem.C.

{
  // interior parents make no sense for full-dimensional elements.
  if (this->dim() >= LIBMESH_DIM)
      return nullptr;
 
  // they USED TO BE only good for level-0 elements, but we now
  // support keeping interior_parent() valid on refined boundary
  // elements.
  // if (this->level() != 0)
  // return this->parent()->interior_parent();
 
  // We store the interior_parent pointer after both the parent
  // neighbor and neighbor pointers
  Elem * interior_p = _elemlinks[1+this->n_sides()];
 
  // If we have an interior_parent, we USED TO assume it was a
  // one-higher-dimensional interior element, but we now allow e.g.
  // edge elements to have a 3D interior_parent with no
  // intermediate 2D element.
  // libmesh_assert (!interior_p ||
  //                interior_p->dim() == (this->dim()+1));
  libmesh_assert (!interior_p ||
                  (interior_p == remote_elem) ||
                  (interior_p->dim() > this->dim()));
 
  // If an element in a multi-dimensional mesh has an interior_parent
  // link, it should be at our level or coarser, just like a neighbor
  // link.  Our collect_families() code relies on this, but it might
  // be tempting for users to manually assign something that breaks
  // it.
  //
  // However, we *also* create temporary side elements, and we don't
  // bother with creating ancestors for those, so they can be at level
  // 0 even when they're sides of non-level-0 elements.
  libmesh_assert (!interior_p ||
                  (interior_p->level() <= this->level()) ||
                  (this->level() == 0 &&
                   this->id() == DofObject::invalid_id));
 
  return interior_p;
}

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

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

◆ invalidate()

void libMesh::DofObject::invalidate ( )

inlineinherited

Invalidates all the indices for this DofObject.

Definition at line 793 of file dof_object.h.

{
  this->invalidate_dofs ();
  this->invalidate_id ();
  this->invalidate_processor_id ();
}

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

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

◆ invalidate_dofs()

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

inlineinherited

Sets all degree of freedom numbers to invalid_id.

Definition at line 756 of file dof_object.h.

{
  const unsigned int n_sys = this->n_systems();
  // If the user does not specify the system number...
  if (sys_num >= n_sys)
    {
      for (auto s : make_range(n_sys))
        for (auto vg : make_range(this->n_var_groups(s)))
          if (this->n_comp_group(s,vg))
            this->set_vg_dof_base(s,vg,invalid_id);
    }
  // ...otherwise invalidate the dofs for all systems
  else
    for (auto vg : make_range(this->n_var_groups(sys_num)))
      if (this->n_comp_group(sys_num,vg))
        this->set_vg_dof_base(sys_num,vg,invalid_id);
}

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

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

◆ invalidate_id()

void libMesh::DofObject::invalidate_id ( )

inlineinherited

Sets the id to invalid_id.

Definition at line 777 of file dof_object.h.

{
  this->set_id (invalid_id);
}

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

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

◆ invalidate_processor_id()

void libMesh::DofObject::invalidate_processor_id ( )

inlineinherited

Sets the processor id to invalid_processor_id.

Definition at line 785 of file dof_object.h.

{
  this->processor_id (invalid_processor_id);
}

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

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

◆ is_ancestor_of()

bool libMesh::Elem::is_ancestor_of ( const Elem * descendant ) const

inlineinherited

Returns: true if descendant is a child of this, or a child of a child of this, etc., false otherwise or if AMR is disabled.

Definition at line 3147 of file elem.h.

{
#ifdef LIBMESH_ENABLE_AMR
  const Elem * e = descendant;
  while (e)
    {
      if (this == e)
        return true;
      e = e->parent();
    }
#endif
  return false;
}

References libMesh::Elem::parent().

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

◆ is_child_on_edge()

bool libMesh::Elem::is_child_on_edge	(	const unsigned int	c,
		const unsigned int	e
	)		const

virtualinherited

Returns: true if the specified child is on the specified edge.

Definition at line 2435 of file elem.C.

{
  libmesh_assert_less (c, this->n_children());
  libmesh_assert_less (e, this->n_edges());
 
  std::unique_ptr<const Elem> my_edge = this->build_edge_ptr(e);
  std::unique_ptr<const Elem> child_edge = this->child_ptr(c)->build_edge_ptr(e);
 
  // We're assuming that an overlapping child edge has the same
  // number and orientation as its parent
  return (child_edge->node_id(0) == my_edge->node_id(0) ||
          child_edge->node_id(1) == my_edge->node_id(1));
}

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

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

◆ is_child_on_side()

bool libMesh::Edge::is_child_on_side	(	const unsigned int	c,
		const unsigned int	s
	)		const

finaloverridevirtual

Returns: true if the specified child is on the specified side.

Implements libMesh::Elem.

Definition at line 117 of file edge.C.

{
  libmesh_assert_less (c, this->n_children());
  libmesh_assert_less (s, this->n_sides());
 
  return (c == s);
}

References n_children(), and n_sides().

◆ is_edge()

virtual bool libMesh::Elem::is_edge ( const unsigned int i ) const

pure virtualinherited

Returns: true if the specified (local) node number is an edge node. For 1D elements, is_edge() is equivalent to is_internal().

Implemented in libMesh::C0Polyhedron, libMesh::Hex20, libMesh::Hex27, libMesh::Hex8, libMesh::Prism15, libMesh::Prism18, libMesh::Prism20, libMesh::Prism21, libMesh::Prism6, libMesh::Pyramid13, libMesh::Pyramid14, libMesh::Pyramid18, libMesh::Pyramid5, libMesh::Tet10, libMesh::Tet14, libMesh::Tet4, libMesh::Edge2, libMesh::Edge3, libMesh::Edge4, libMesh::InfEdge2, libMesh::C0Polygon, libMesh::Quad4, libMesh::Quad8, libMesh::Quad9, libMesh::Tri3, libMesh::Tri6, libMesh::Tri7, libMesh::InfHex, libMesh::InfPrism, libMesh::InfQuad, libMesh::NodeElem, and libMesh::RemoteElem.

Referenced by libMesh::FEGenericBase< OutputType >::compute_periodic_constraints(), libMesh::Hex::edges_adjacent_to_node(), libMesh::Prism::edges_adjacent_to_node(), libMesh::Pyramid::edges_adjacent_to_node(), libMesh::Tet::edges_adjacent_to_node(), libMesh::Quad::edges_adjacent_to_node(), libMesh::Tri::edges_adjacent_to_node(), libMesh::Elem::is_internal(), FEOrientationTestBase< order, family >::node_entity(), VolumeTest::testC0PolygonMethods(), and VolumeTest::testC0PolyhedronMethods().

◆ is_edge_on_side()

virtual bool libMesh::Edge::is_edge_on_side	(	const unsigned int	,
		const unsigned int
	)		const

inlinefinaloverridevirtual

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

virtual bool libMesh::Elem::is_face ( const unsigned int i ) const

pure virtualinherited

Returns: true if the specified (local) node number is a face node. For 2D elements, is_face() is equivalent to is_internal(). For 1D elements, is_face() == false.

Implemented in libMesh::C0Polyhedron, libMesh::Hex20, libMesh::Hex27, libMesh::Hex8, libMesh::Prism15, libMesh::Prism18, libMesh::Prism20, libMesh::Prism21, libMesh::Prism6, libMesh::Pyramid13, libMesh::Pyramid14, libMesh::Pyramid18, libMesh::Pyramid5, libMesh::Tet10, libMesh::Tet14, libMesh::Tet4, libMesh::Edge2, libMesh::Edge3, libMesh::Edge4, libMesh::InfEdge2, libMesh::C0Polygon, libMesh::Quad4, libMesh::Quad8, libMesh::Quad9, libMesh::Tri3, libMesh::Tri6, libMesh::Tri7, libMesh::InfHex, libMesh::InfPrism, libMesh::InfQuad, libMesh::NodeElem, and libMesh::RemoteElem.

Referenced by libMesh::FEGenericBase< OutputType >::compute_periodic_constraints(), libMesh::Hex::edges_adjacent_to_node(), libMesh::Prism::edges_adjacent_to_node(), libMesh::Pyramid::edges_adjacent_to_node(), libMesh::Tet::edges_adjacent_to_node(), libMesh::Quad::edges_adjacent_to_node(), libMesh::Tri::edges_adjacent_to_node(), libMesh::Elem::is_internal(), FEOrientationTestBase< order, family >::node_entity(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectSides::operator()(), VolumeTest::testC0PolygonMethods(), and VolumeTest::testC0PolyhedronMethods().

◆ is_flipped()

bool libMesh::Edge::is_flipped ( ) const

finaloverridevirtual

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.

{
  // Don't trigger on 1D elements embedded in 2D/3D
  return (
#if LIBMESH_DIM > 2
          !this->point(0)(2) && !this->point(1)(2) &&
#endif
#if LIBMESH_DIM > 1
          !this->point(0)(1) && !this->point(1)(1) &&
#endif
          this->point(0)(0) > this->point(1)(0));
}

References libMesh::Elem::point().

◆ is_internal()

bool libMesh::Elem::is_internal ( const unsigned int i ) const

inherited

Returns: true if the specified (local) node number is an internal node.

Definition at line 4014 of file elem.C.

{
  switch (this->dim())
  {
    case 0:
      return false;
 
    case 1:
      return !this->is_vertex(i);
 
    case 2:
      return !this->is_vertex(i) && !this->is_edge(i);
 
    case 3:
      return !this->is_vertex(i) && !this->is_edge(i) && !this->is_face(i);
 
    default:
      libmesh_error_msg("impossible element dimension " << std::to_string(this->dim()));
      return 0;
  }
}

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

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

◆ is_linear()

virtual bool libMesh::Elem::is_linear ( ) const

inlinevirtualinherited

Returns: true if the Lagrange shape functions on this element are linear.

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

Definition at line 1328 of file elem.h.

1328{ return false; }

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

◆ is_mid_infinite_edge_node()

virtual bool libMesh::Elem::is_mid_infinite_edge_node ( const unsigned int ) const

inlinevirtualinherited

Returns: true if the specified (local) node number is a "mid-edge" node on an infinite element edge.

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

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

Definition at line 2035 of file elem.h.

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

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

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

◆ is_node_on_edge()

virtual bool libMesh::Elem::is_node_on_edge	(	const unsigned int	n,
		const unsigned int	e
	)		const

pure virtualinherited

Returns: true if the specified (local) node number is on the specified edge.

Implemented in libMesh::C0Polyhedron, libMesh::Hex20, libMesh::Hex27, libMesh::Hex8, libMesh::InfHex16, libMesh::InfHex18, libMesh::InfHex8, libMesh::InfPrism12, libMesh::InfPrism6, libMesh::Prism15, libMesh::Prism18, libMesh::Prism20, libMesh::Prism21, libMesh::Prism6, libMesh::Pyramid13, libMesh::Pyramid14, libMesh::Pyramid18, libMesh::Pyramid5, libMesh::Tet10, libMesh::Tet14, libMesh::Tet4, libMesh::Edge2, libMesh::Edge3, libMesh::Edge4, libMesh::InfEdge2, libMesh::C0Polygon, libMesh::InfQuad4, libMesh::InfQuad6, libMesh::Quad4, libMesh::Quad8, libMesh::Quad9, libMesh::Tri3, libMesh::Tri6, libMesh::Tri7, libMesh::NodeElem, and libMesh::RemoteElem.

Referenced by libMesh::FEGenericBase< OutputType >::compute_periodic_constraints(), libMesh::FE< Dim, CLOUGH >::FE(), FEOrientationTestBase< order, family >::node_entity(), and VolumeTest::testC0PolygonMethods().

◆ is_node_on_side()

virtual bool libMesh::Elem::is_node_on_side	(	const unsigned int	n,
		const unsigned int	s
	)		const

pure virtualinherited

Returns: true if the specified (local) node number is on the specified side.

Implemented in libMesh::C0Polyhedron, libMesh::Hex20, libMesh::Hex27, libMesh::Hex8, libMesh::InfHex16, libMesh::InfHex18, libMesh::InfHex8, libMesh::InfPrism12, libMesh::InfPrism6, libMesh::Prism15, libMesh::Prism18, libMesh::Prism20, libMesh::Prism21, libMesh::Prism6, libMesh::Pyramid13, libMesh::Pyramid14, libMesh::Pyramid18, libMesh::Pyramid5, libMesh::Tet10, libMesh::Tet14, libMesh::Tet4, libMesh::Edge2, libMesh::Edge3, libMesh::Edge4, libMesh::InfEdge2, libMesh::C0Polygon, libMesh::InfQuad4, libMesh::InfQuad6, libMesh::Quad4, libMesh::Quad8, libMesh::Quad9, libMesh::Tri3, libMesh::Tri6, libMesh::Tri7, libMesh::NodeElem, and libMesh::RemoteElem.

Referenced by libMesh::BoundaryInfo::add_elements(), libMesh::FEGenericBase< OutputType >::compute_periodic_constraints(), libMesh::DofMap::constrain_p_dofs(), libMesh::FE< Dim, T >::dofs_on_side(), libMesh::MeshTools::find_hanging_nodes_and_parents(), FEOrientationTestBase< order, family >::node_entity(), libMesh::VariationalSmootherConstraint::nodes_share_boundary_id(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectSides::operator()(), libMesh::Hex::opposite_node(), opposite_node(), libMesh::Quad::opposite_node(), VolumeTest::testC0PolygonMethods(), VolumeTest::testC0PolyhedronMethods(), and libMesh::Elem::which_side_am_i().

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

618 { return false; }

Referenced by libMesh::Elem::make_links_to_me_local(), MeshGenerationTest::polyhedronTetNeighbor(), and MeshGenerationTest::testBuildCube().

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

{
  std::set<const Elem *> point_neighbors;
 
  this->find_point_neighbors(point_neighbors);
 
  for (const auto & elem : point_neighbors)
    if (elem->processor_id() == my_pid)
      return true;
 
  return false;
}

References libMesh::Elem::find_point_neighbors().

◆ is_singular_node()

virtual bool libMesh::Elem::is_singular_node ( unsigned int ) const

inlinevirtualinherited

Returns: true iff the node at the given index has a singular mapping; i.e. is the degree-4 node on a Pyramid.

Reimplemented in libMesh::Pyramid.

Definition at line 1968 of file elem.h.

1968{ return false; }

Referenced by libMesh::Elem::has_invertible_map(), and FETest< order, family, elem_type, CaseName >::testPastVerticesLoop().

◆ is_vertex()

virtual bool libMesh::Elem::is_vertex ( const unsigned int i ) const

pure virtualinherited

Returns: true if the specified (local) node number is a vertex node.

Implemented in libMesh::C0Polyhedron, libMesh::Hex20, libMesh::Hex27, libMesh::Hex8, libMesh::Prism15, libMesh::Prism18, libMesh::Prism20, libMesh::Prism21, libMesh::Prism6, libMesh::Pyramid13, libMesh::Pyramid14, libMesh::Pyramid18, libMesh::Pyramid5, libMesh::Tet10, libMesh::Tet14, libMesh::Tet4, libMesh::Edge2, libMesh::Edge3, libMesh::Edge4, libMesh::InfEdge2, libMesh::C0Polygon, libMesh::Quad4, libMesh::Quad8, libMesh::Quad9, libMesh::Tri3, libMesh::Tri6, libMesh::Tri7, libMesh::InfHex, libMesh::InfPrism, libMesh::InfQuad, and libMesh::RemoteElem.

Referenced by libMesh::DofMap::_dof_indices(), libMesh::DofMap::_node_dof_indices(), libMesh::FEGenericBase< OutputType >::coarsened_dof_values(), libMesh::FEGenericBase< OutputType >::compute_periodic_constraints(), libMesh::DofMap::constrain_p_dofs(), libMesh::Hex::edges_adjacent_to_node(), libMesh::Prism::edges_adjacent_to_node(), libMesh::Pyramid::edges_adjacent_to_node(), libMesh::Tet::edges_adjacent_to_node(), libMesh::Polygon::edges_adjacent_to_node(), libMesh::Quad::edges_adjacent_to_node(), libMesh::Tri::edges_adjacent_to_node(), libMesh::ElemCutter::find_intersection_points(), libMesh::MeshTools::SidesToElemMap::get_sorted_vertex_ids(), libMesh::Elem::is_internal(), libMesh::Elem::is_vertex_on_child(), FEOrientationTestBase< order, family >::node_entity(), libMesh::DofMap::old_dof_indices(), ElemTest< elem_type >::test_n_refinements(), VolumeTest::testC0PolygonMethods(), and VolumeTest::testC0PolyhedronMethods().

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

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

References libMesh::Elem::is_vertex().

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

◆ is_vertex_on_parent()

bool libMesh::Elem::is_vertex_on_parent	(	unsigned int	c,
		unsigned int	n
	)		const

virtualinherited

Returns: true if this element has a vertex at the specified (child-local) node number n of the specified child c.

Definition at line 3935 of file elem.C.

{
#ifdef LIBMESH_ENABLE_AMR
 
  unsigned int my_n_vertices = this->n_vertices();
  for (unsigned int n_parent = 0; n_parent != my_n_vertices;
       ++n_parent)
    if (this->node_ptr(n_parent) == this->child_ptr(c)->node_ptr(n))
      return true;
  return false;
 
#else
 
  // No AMR?
  libmesh_ignore(c,n);
  libmesh_error_msg("ERROR: AMR disabled, how did we get here?");
  return true;
 
#endif
}

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

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

◆ key() [1/3]

dof_id_type libMesh::Elem::key ( ) const

virtual

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

Reimplemented from libMesh::Elem.

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

Definition at line 290 of file elem.C.

{
  const unsigned short n_n = this->n_nodes();
 
  std::array<dof_id_type, Elem::max_n_nodes> node_ids;
 
  for (unsigned short n=0; n != n_n; ++n)
    node_ids[n] = this->node_id(n);
 
  // Always sort, so that different local node numberings hash to the
  // same value.
  std::sort (node_ids.begin(), node_ids.begin()+n_n);
 
  return Utility::hashword(node_ids.data(), n_n);
}

◆ key() [2/3]

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

inlinefinaloverridevirtual

Returns: An id associated with the s side of this element. The id is not necessarily unique, but should be close.

Implements libMesh::Elem.

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

Definition at line 141 of file edge.h.

142 { return this->compute_key(this->node_id(s)); }

libMesh::Elem::compute_key

static dof_id_type compute_key(dof_id_type n0)

Definition elem.h:3432

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

◆ key() [3/3]

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

virtual

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

Implements libMesh::Elem.

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

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

{
  libmesh_assert_less ( n1, this->n_vertices() );
  libmesh_assert_less ( n2, this->n_vertices() );
 
  return (this->point(n1) - this->point(n2)).norm();
}

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

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

◆ level()

unsigned int libMesh::Elem::level ( ) const

inlineinherited

Returns: The refinement level of the current element.

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

Definition at line 3212 of file elem.h.

{
#ifdef LIBMESH_ENABLE_AMR
 
  // if I don't have a parent I was
  // created directly from file
  // or by the user, so I am a
  // level-0 element
  if (this->parent() == nullptr)
    return 0;
 
  // if the parent and this element are of different
  // dimensionality we are at the same level as
  // the parent (e.g. we are the 2D side of a
  // 3D element)
  if (this->dim() != this->parent()->dim())
    return this->parent()->level();
 
  // otherwise we are at a level one
  // higher than our parent
  return (this->parent()->level() + 1);
 
#else
 
  // Without AMR all elements are
  // at level 0.
  return 0;
 
#endif
}

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

◆ libmesh_assert_valid_neighbors()

void libMesh::Elem::libmesh_assert_valid_neighbors ( ) const

inherited

Checks for consistent neighbor links on this element.

Definition at line 1297 of file elem.C.

{
  for (auto n : this->side_index_range())
    {
      const Elem * neigh = this->neighbor_ptr(n);
 
      // Any element might have a remote neighbor; checking
      // to make sure that's not inaccurate is tough.
      if (neigh == remote_elem)
        continue;
 
      if (neigh)
        {
          // Only subactive elements have subactive neighbors
          libmesh_assert (this->subactive() || !neigh->subactive());
 
          const Elem * elem = this;
 
          // If we're subactive but our neighbor isn't, its
          // return neighbor link will be to our first active
          // ancestor OR to our inactive ancestor of the same
          // level as neigh,
          if (this->subactive() && !neigh->subactive())
            {
              for (elem = this; !elem->active();
                   elem = elem->parent())
                libmesh_assert(elem);
            }
          else
            {
              unsigned int rev = neigh->which_neighbor_am_i(elem);
              libmesh_assert_less (rev, neigh->n_neighbors());
 
              if (this->subactive() && !neigh->subactive())
                {
                  while (neigh->neighbor_ptr(rev) != elem)
                    {
                      libmesh_assert(elem->parent());
                      elem = elem->parent();
                    }
                }
              else
                {
                  const Elem * nn = neigh->neighbor_ptr(rev);
                  libmesh_assert(nn);
 
                  for (; elem != nn; elem = elem->parent())
                    libmesh_assert(elem);
                }
            }
        }
      // If we don't have a neighbor and we're not subactive, our
      // ancestors shouldn't have any neighbors in this same
      // direction.
      else if (!this->subactive())
        {
          const Elem * my_parent = this->parent();
          if (my_parent &&
              // A parent with a different dimension isn't really one of
              // our ancestors, it means we're on a boundary mesh and this
              // is an interior mesh element for which we're on a side.
              // Nothing to test for in that case.
              (my_parent->dim() == this->dim()))
            libmesh_assert (!my_parent->neighbor_ptr(n));
        }
    }
}

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

◆ libmesh_assert_valid_node_pointers()

void libMesh::Elem::libmesh_assert_valid_node_pointers ( ) const

inherited

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

Definition at line 1285 of file elem.C.

{
  libmesh_assert(this->valid_id());
  for (auto n : this->node_index_range())
    {
      libmesh_assert(this->node_ptr(n));
      libmesh_assert(this->node_ptr(n)->valid_id());
    }
}

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

◆ local_edge_node() [1/2]

unsigned int libMesh::Elem::local_edge_node	(	ElemType	t,
		unsigned int	edge,
		unsigned int	edge_node
	)

staticinherited

Returns: The local node id for node edge_node on edge edge of an element of type t, without needing an instantiated Elem. For 2D types this is local_side_node(); 1D types have no edges. The same types are unsupported here as in local_side_node().

Definition at line 3512 of file elem.C.

{
  libmesh_assert_less (edge, type_to_n_edges_map[t]);
  libmesh_assert_less (edge_node, type_to_n_nodes_map[edge_type(t)]);
 
  switch (t)
    {
    case TRI3:
    case TRISHELL3:
    case TRI6:
    case TRI7:
    case QUAD4:
    case QUADSHELL4:
    case QUAD8:
    case QUADSHELL8:
    case QUAD9:
    case QUADSHELL9:
      return local_side_node(t, edge, edge_node);
    case TET4:
      return Tet4::edge_nodes_map[edge][edge_node];
    case TET10:
      return Tet10::edge_nodes_map[edge][edge_node];
    case TET14:
      return Tet14::edge_nodes_map[edge][edge_node];
    case HEX8:
      return Hex8::edge_nodes_map[edge][edge_node];
    case HEX20:
      return Hex20::edge_nodes_map[edge][edge_node];
    case HEX27:
      return Hex27::edge_nodes_map[edge][edge_node];
    case PRISM6:
      return Prism6::edge_nodes_map[edge][edge_node];
    case PRISM15:
      return Prism15::edge_nodes_map[edge][edge_node];
    case PRISM18:
      return Prism18::edge_nodes_map[edge][edge_node];
    case PRISM20:
      return Prism20::edge_nodes_map[edge][edge_node];
    case PRISM21:
      return Prism21::edge_nodes_map[edge][edge_node];
    case PYRAMID5:
      return Pyramid5::edge_nodes_map[edge][edge_node];
    case PYRAMID13:
      return Pyramid13::edge_nodes_map[edge][edge_node];
    case PYRAMID14:
      return Pyramid14::edge_nodes_map[edge][edge_node];
    case PYRAMID18:
      return Pyramid18::edge_nodes_map[edge][edge_node];
    default:
      libmesh_error_msg("No static edge node map for element type " << Utility::enum_to_string(t));
    }
 
  return invalid_uint;
}

◆ local_edge_node() [2/2]

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

finaloverridevirtual

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.

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

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

{
  for (auto n : make_range(this->n_nodes()))
    if (this->node_id(n) == i)
      return n;
 
  return libMesh::invalid_uint;
}

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

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

◆ local_side_node() [1/2]

unsigned int libMesh::Elem::local_side_node	(	ElemType	t,
		unsigned int	side,
		unsigned int	side_node
	)

staticinherited

Returns: The local node id for node side_node on side side of an element of type t, without needing an instantiated Elem. The Polygon and Polyhedron subclasses have no such map, and the infinite elements' maps are not read here, so those must be queried through an actual Elem.

Definition at line 3431 of file elem.C.

{
  // The nodes on a side are the nodes of the side's own element type, so
  // we compose the two lookups here rather than tabulating side node
  // counts a second time.  That also keeps us inside the meaningful part
  // of a row: the prisms' and pyramids' triangular sides carry fewer
  // nodes than their quadrilateral ones, and their rows are padded out
  // to the longer length
  libmesh_assert_less (side, type_to_n_sides_map[t]);
  libmesh_assert_less (side_node, type_to_n_nodes_map[side_type(t, side)]);
 
  switch (t)
    {
      // A 1D element's sides are its end nodes
    case EDGE2:
    case EDGE3:
    case EDGE4:
      return side;
      // The shell elements are numbered like the elements they shadow
    case TRI3:
    case TRISHELL3:
      return Tri3::side_nodes_map[side][side_node];
    case TRI6:
      return Tri6::side_nodes_map[side][side_node];
    case TRI7:
      return Tri7::side_nodes_map[side][side_node];
    case QUAD4:
    case QUADSHELL4:
      return Quad4::side_nodes_map[side][side_node];
    case QUAD8:
    case QUADSHELL8:
      return Quad8::side_nodes_map[side][side_node];
    case QUAD9:
    case QUADSHELL9:
      return Quad9::side_nodes_map[side][side_node];
    case TET4:
      return Tet4::side_nodes_map[side][side_node];
    case TET10:
      return Tet10::side_nodes_map[side][side_node];
    case TET14:
      return Tet14::side_nodes_map[side][side_node];
    case HEX8:
      return Hex8::side_nodes_map[side][side_node];
    case HEX20:
      return Hex20::side_nodes_map[side][side_node];
    case HEX27:
      return Hex27::side_nodes_map[side][side_node];
    case PRISM6:
      return Prism6::side_nodes_map[side][side_node];
    case PRISM15:
      return Prism15::side_nodes_map[side][side_node];
    case PRISM18:
      return Prism18::side_nodes_map[side][side_node];
    case PRISM20:
      return Prism20::side_nodes_map[side][side_node];
    case PRISM21:
      return Prism21::side_nodes_map[side][side_node];
    case PYRAMID5:
      return Pyramid5::side_nodes_map[side][side_node];
    case PYRAMID13:
      return Pyramid13::side_nodes_map[side][side_node];
    case PYRAMID14:
      return Pyramid14::side_nodes_map[side][side_node];
    case PYRAMID18:
      return Pyramid18::side_nodes_map[side][side_node];
    default:
      libmesh_error_msg("No static side node map for element type " << Utility::enum_to_string(t));
    }
 
  return invalid_uint;
}

◆ local_side_node() [2/2]

unsigned int libMesh::Edge::local_side_node	(	unsigned int	side,
		unsigned int
	)		const

finaloverridevirtual

Returns: side after doing some range checking. side_node is ignored.

Implements libMesh::Elem.

Definition at line 38 of file edge.C.

{
  libmesh_assert_less (side, this->n_sides());
  return side;
}

References n_sides().

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

1962 { return invalid_uint; }

References libMesh::invalid_uint.

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

◆ loose_bounding_box()

BoundingBox libMesh::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::Cell, libMesh::Hex8, libMesh::Prism6, libMesh::Pyramid5, libMesh::Edge3, libMesh::Edge4, libMesh::Quad4, libMesh::Quad8, libMesh::Quad9, libMesh::Tri3, libMesh::Tri6, and libMesh::Tri7.

Definition at line 3901 of file elem.C.

{
  Point pmin = this->point(0);
  Point pmax = pmin;
 
  unsigned int n_points = this->n_nodes();
  for (unsigned int p=0; p != n_points; ++p)
    for (unsigned d=0; d<LIBMESH_DIM; ++d)
      {
        const Point & pt = this->point(p);
        if (pmin(d) > pt(d))
          pmin(d) = pt(d);
 
        if (pmax(d) < pt(d))
          pmax(d) = pt(d);
      }
 
  return BoundingBox(pmin, pmax);
}

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

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

◆ low_order_key()

virtual dof_id_type libMesh::Edge::low_order_key ( const unsigned int s ) const

inlinefinaloverridevirtual

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.

151 { return this->compute_key(this->node_id(s)); }

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

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

{
  Elem * neigh = this->neighbor_ptr(n);
 
  // Don't bother calling this function unless it's necessary
  libmesh_assert(neigh);
  libmesh_assert(!neigh->is_remote());
 
  const unsigned int this_level = this->level();
  const unsigned int neigh_level = neigh->level();
 
  // We never have neighbors more refined than us
  libmesh_assert_less_equal (neigh_level, this_level);
 
  // We never have subactive neighbors of non subactive elements
  libmesh_assert(!neigh->subactive() || this->subactive());
 
  // If we have a neighbor less refined than us then it must not
  // have any more refined descendants we could have pointed to
  // instead.
  libmesh_assert((neigh_level == this_level) ||
                 (neigh->active() && !this->subactive()) ||
                 (!neigh->has_children() && this->subactive()));
 
  // What side of neigh are we on?  nn.
  //
  // We can't use the usual Elem method because we're in the middle of
  // restoring topology.  We can't compare side_ptr nodes because
  // users want to abuse neighbor_ptr to point to
  // not-technically-neighbors across mesh slits.  We can't compare
  // node locations because users want to move those
  // not-technically-neighbors until they're
  // not-even-geometrically-neighbors.
 
  // Find any elements that might need to point to elem
  std::vector<Elem *> neigh_family;
#ifdef LIBMESH_ENABLE_AMR
  neigh->total_family_tree_by_side(neigh_family, nn);
#else
  neigh_family.push_back(neigh);
#endif
 
  // Pull objects out of the loop to reduce heap operations
  std::unique_ptr<Elem> my_side, neigh_side;
 
  // And point them to elem
  for (auto & neigh_family_member : neigh_family)
    {
      // Only subactive elements point to other subactive elements
      const bool member_subactive = neigh_family_member->subactive();
      if (this->subactive() && !member_subactive)
        continue;
 
      // neigh (and possibly some of its family) might be at a lower
      // level than us, with a neighbor at that lower level.  We
      // would exit early if neigh was at a lower level, except we do
      // want to handle neighbor links from subactive descendents.
      const unsigned int member_level = neigh_family_member->level();
      if (member_level < this_level)
        continue;
 
      // Ideally, the neighbor link ought to either be correct
      // already or ought to be to remote_elem.
      //
      // However, if we're redistributing a newly created elem,
      // after an AMR step but before find_neighbors has fixed up
      // neighbor links, we might have an out of date neighbor
      // link to elem's parent instead.
#ifdef LIBMESH_ENABLE_AMR
      libmesh_assert((neigh_family_member->neighbor_ptr(nn) &&
                      (neigh_family_member->neighbor_ptr(nn)->active() ||
                       this->is_ancestor_of(neigh_family_member->neighbor_ptr(nn)) ||
                       neigh_family_member->neighbor_ptr(nn)->is_ancestor_of(this))) ||
                     (neigh_family_member->neighbor_ptr(nn) == remote_elem) ||
                     ((this->refinement_flag() == JUST_REFINED) &&
                      (this->parent() != nullptr) &&
                      (neigh_family_member->neighbor_ptr(nn) == this->parent())));
#else
      libmesh_assert((neigh_family_member->neighbor_ptr(nn) == this) ||
                     (neigh_family_member->neighbor_ptr(nn) == remote_elem));
#endif
 
      // Some of neigh's family might be at a higher (finer) level
      // than us, and might need to point back to one of our children
      // rather than to us.
      if (member_level > this_level)
        {
          if (this->ancestor())
            continue;
 
          if (member_subactive && this->has_children())
            continue;
        }
 
      // If neigh is at a coarser level than us, some of neigh's
      // subactive family just won't line up with us!
      if (neigh_level < this_level &&
          member_level > neigh_level)
        {
          libmesh_assert(member_subactive);
 
          this->side_ptr(my_side, n);
          neigh_family_member->side_ptr(neigh_side, nn);
 
          if (*my_side != *neigh_side)
            continue;
        }
 
      neigh_family_member->set_neighbor(nn, this);
    }
}

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

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

◆ make_links_to_me_remote()

void libMesh::Elem::make_links_to_me_remote ( )

inherited

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

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

Definition at line 1482 of file elem.C.

{
  libmesh_assert_not_equal_to (this, remote_elem);
 
  // We need to have handled any children first
#if defined(LIBMESH_ENABLE_AMR) && defined(DEBUG)
  if (this->has_children())
    for (auto & child : this->child_ref_range())
      libmesh_assert_equal_to (&child, remote_elem);
#endif
 
  // Remotify any neighbor links
  for (auto neigh : this->neighbor_ptr_range())
    {
      if (neigh && neigh != remote_elem)
        {
          // My neighbor should never be more refined than me; my real
          // neighbor would have been its parent in that case.
          libmesh_assert_greater_equal (this->level(), neigh->level());
 
          if (this->level() == neigh->level() &&
              neigh->has_neighbor(this))
            {
#ifdef LIBMESH_ENABLE_AMR
              // My neighbor may have descendants which also consider me a
              // neighbor
              std::vector<Elem *> family;
              neigh->total_family_tree_by_neighbor (family, this);
 
              // FIXME - There's a lot of ugly const_casts here; we
              // may want to make remote_elem non-const
              for (auto & n : family)
                {
                  libmesh_assert (n);
                  if (n == remote_elem)
                    continue;
                  unsigned int my_s = n->which_neighbor_am_i(this);
                  libmesh_assert_less (my_s, n->n_neighbors());
                  libmesh_assert_equal_to (n->neighbor_ptr(my_s), this);
                  n->set_neighbor(my_s, const_cast<RemoteElem *>(remote_elem));
                }
#else
              unsigned int my_s = neigh->which_neighbor_am_i(this);
              libmesh_assert_less (my_s, neigh->n_neighbors());
              libmesh_assert_equal_to (neigh->neighbor_ptr(my_s), this);
              neigh->set_neighbor(my_s, const_cast<RemoteElem *>(remote_elem));
#endif
            }
#ifdef LIBMESH_ENABLE_AMR
          // Even if my neighbor doesn't link back to me, it might
          // have subactive descendants which do
          else if (neigh->has_children())
            {
              // If my neighbor at the same level doesn't have me as a
              // neighbor, I must be subactive
              libmesh_assert(this->level() > neigh->level() ||
                             this->subactive());
 
              // My neighbor must have some ancestor of mine as a
              // neighbor
              Elem * my_ancestor = this->parent();
              libmesh_assert(my_ancestor);
              while (!neigh->has_neighbor(my_ancestor))
                {
                  my_ancestor = my_ancestor->parent();
                  libmesh_assert(my_ancestor);
                }
 
              // My neighbor may have descendants which consider me a
              // neighbor
              std::vector<Elem *> family;
              neigh->total_family_tree_by_subneighbor (family, my_ancestor, this);
 
              for (auto & n : family)
                {
                  libmesh_assert (n);
                  if (n->is_remote())
                    continue;
                  unsigned int my_s = n->which_neighbor_am_i(this);
                  libmesh_assert_less (my_s, n->n_neighbors());
                  libmesh_assert_equal_to (n->neighbor_ptr(my_s), this);
                  // TODO: we may want to make remote_elem non-const.
                  n->set_neighbor(my_s, const_cast<RemoteElem *>(remote_elem));
                }
            }
#endif
        }
    }
 
#ifdef LIBMESH_ENABLE_AMR
  // Remotify parent's child link
  Elem * my_parent = this->parent();
  if (my_parent &&
      // As long as it's not already remote
      my_parent != remote_elem &&
      // And it's a real parent, not an interior parent
      this->dim() == my_parent->dim())
    {
      unsigned int me = my_parent->which_child_am_i(this);
      libmesh_assert_equal_to (my_parent->child_ptr(me), this);
      my_parent->set_child(me, const_cast<RemoteElem *>(remote_elem));
    }
#endif
}

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

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

◆ mapping_data()

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

inlineinherited

Returns: The value of the mapping data for the element.

Definition at line 3274 of file elem.h.

{
  return _map_data;
}

References libMesh::Elem::_map_data.

Referenced by libMesh::MeshTools::Modification::all_tri(), libMesh::MeshTools::Modification::flatten(), libMesh::Elem::get_info(), libMesh::Elem::inherit_data_from(), libMesh::Polygon::Polygon(), libMesh::Polyhedron::Polyhedron(), libMesh::rational_fe_shape(), libMesh::rational_fe_shape_deriv(), libMesh::rational_fe_shape_second_deriv(), libMesh::rational_fe_weighted_shapes(), and libMesh::rational_fe_weighted_shapes_derivs().

◆ mapping_type()

ElemMappingType libMesh::Elem::mapping_type ( ) const

inlineinherited

Returns: The value of the mapping type for the element.

Definition at line 3258 of file elem.h.

{
  return static_cast<ElemMappingType>(_map_type);
}

References libMesh::Elem::_map_type.

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

◆ master_point()

virtual Point libMesh::Elem::master_point ( const unsigned int i ) const

pure virtualinherited

Returns: The Point associated with local Node i, in master element rather than physical coordinates.

Implemented in libMesh::Polyhedron, libMesh::Pyramid, libMesh::Edge2, libMesh::Edge3, libMesh::Edge4, libMesh::InfEdge2, libMesh::Polygon, libMesh::Hex, libMesh::InfHex, libMesh::InfPrism, libMesh::Prism, libMesh::Tet, libMesh::InfQuad, libMesh::Quad, libMesh::Tri, and libMesh::RemoteElem.

Referenced by libMesh::FEMap::inverse_map(), FEGLLLagrangeAgreementTest< elem_type, order >::node_at(), libMesh::Elem::parent_bracketing_nodes(), FETest< order, family, elem_type, CaseName >::testNodalSoln(), FETest< order, family, elem_type, CaseName >::testPastVerticesLoop(), and FETest< order, family, elem_type, CaseName >::testRefspaceNodes().

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

{
  // This is undefined for subactive elements,
  // which have no active descendants
  libmesh_assert (!this->subactive());
  if (this->active())
    return this->p_level();
 
  unsigned int max_p_level = _p_level;
  for (auto & c : child_ref_range())
    max_p_level = std::max(max_p_level,
                           c.max_descendant_p_level());
  return max_p_level;
}

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

Referenced by libMesh::FEGenericBase< OutputType >::coarsened_dof_values().

◆ min_new_p_level_by_neighbor()

unsigned int libMesh::Elem::min_new_p_level_by_neighbor	(	const Elem *	neighbor,
		unsigned int	current_min
	)		const

inherited

Returns: The minimum new p-refinement level (i.e. after refinement and coarsening is done) of elements which are descended from this element and which share a side with the active neighbor.

Definition at line 2481 of file elem.C.

{
  libmesh_assert(!this->subactive());
  libmesh_assert(neighbor_in->active());
 
  // If we're an active element this is simple
  if (this->active())
    {
      unsigned int new_p_level = this->p_level();
      if (this->p_refinement_flag() == Elem::REFINE)
        new_p_level += 1;
      if (this->p_refinement_flag() == Elem::COARSEN)
        {
          libmesh_assert_greater (new_p_level, 0);
          new_p_level -= 1;
        }
      return std::min(current_min, new_p_level);
    }
 
  libmesh_assert(has_neighbor(neighbor_in));
 
  unsigned int min_p_level = current_min;
 
  for (auto & c : this->child_ref_range())
    if (&c != remote_elem && c.has_neighbor(neighbor_in))
      min_p_level =
        c.min_new_p_level_by_neighbor(neighbor_in, min_p_level);
 
  return min_p_level;
}

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

◆ min_p_level_by_neighbor()

unsigned int libMesh::Elem::min_p_level_by_neighbor	(	const Elem *	neighbor,
		unsigned int	current_min
	)		const

inherited

Returns: The minimum p-refinement level of elements which are descended from this element, and which share a side with the active neighbor.

Definition at line 2452 of file elem.C.

{
  libmesh_assert(!this->subactive());
  libmesh_assert(neighbor_in->active());
 
  // If we're an active element this is simple
  if (this->active())
    return std::min(current_min, this->p_level());
 
  libmesh_assert(has_neighbor(neighbor_in));
 
  // The p_level() of an ancestor element is already the minimum
  // p_level() of its children - so if that's high enough, we don't
  // need to examine any children.
  if (current_min <= this->p_level())
    return current_min;
 
  unsigned int min_p_level = current_min;
 
  for (auto & c : this->child_ref_range())
    if (&c != remote_elem && c.has_neighbor(neighbor_in))
      min_p_level =
        c.min_p_level_by_neighbor(neighbor_in, min_p_level);
 
  return min_p_level;
}

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

Referenced by libMesh::FEGenericBase< OutputType >::compute_periodic_constraints(), and libMesh::FEGenericBase< OutputType >::compute_proj_constraints().

◆ n_children()

virtual unsigned int libMesh::Edge::n_children ( ) const

inlinefinaloverridevirtual

Returns: 2.

Implements libMesh::Elem.

Definition at line 103 of file edge.h.

103{ return 2; }

Referenced by is_child_on_side().

◆ n_comp()

unsigned int libMesh::DofObject::n_comp	(	const unsigned int	s,
		const unsigned int	var
	)		const

inlineinherited

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

Definition at line 992 of file dof_object.h.

{
  libmesh_assert_less (s,   this->n_systems());
  libmesh_assert_less (var, this->n_vars(s));
 
  return this->n_comp_group(s,this->var_to_vg(s,var));
}

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

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

{
  libmesh_assert_less (s,  this->n_systems());
  libmesh_assert_less (vg, this->n_var_groups(s));
 
  const unsigned int
    start_idx_sys = this->start_idx(s);
 
  libmesh_assert_less ((start_idx_sys + 2*vg), _idx_buf.size());
 
  return (_idx_buf[start_idx_sys + 2*vg] % ncv_magic);
}

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

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

◆ n_dofs()

unsigned int libMesh::DofObject::n_dofs	(	const unsigned int	s,
		const unsigned int	var = `libMesh::invalid_uint`
	)		const

inlineinherited

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

Definition at line 811 of file dof_object.h.

{
  libmesh_assert_less (s, this->n_systems());
 
  unsigned int num = 0;
 
  // Count all variables
  if (var == libMesh::invalid_uint)
    for (auto v : make_range(this->n_vars(s)))
      num += this->n_comp(s,v);
 
  // Only count specified variable
  else
    num = this->n_comp(s,var);
 
  return num;
}

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

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

◆ n_edges()

virtual unsigned int libMesh::Edge::n_edges ( ) const

inlinefinaloverridevirtual

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

{
  if (_idx_buf.empty())
    return 0;
 
  const int hdr = dof_id_signed_type(_idx_buf[0]);
  if (hdr >= 0)
    return 0;
 
  const unsigned int start_idx_i = this->start_idx_ints();
 
  return _idx_buf.size() - start_idx_i;
}

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

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

◆ n_faces()

virtual unsigned int libMesh::Edge::n_faces ( ) const

inlinefinaloverridevirtual

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

813 { return this->n_sides(); }

References libMesh::Elem::n_sides().

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

◆ n_nodes()

virtual unsigned int libMesh::Edge::n_nodes ( ) const

inlineoverridevirtual

Returns: 2. Every edge is guaranteed to have at least 2 nodes.

Implements libMesh::Elem.

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

Definition at line 78 of file edge.h.

78{ return 2; }

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

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

749 { return this->n_nodes(); }

References libMesh::Elem::n_nodes().

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

◆ n_objects() [1/2]

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

inlinestaticinherited

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

Definition at line 85 of file reference_counter.h.

86 { return _n_objects; }

libMesh::ReferenceCounter::_n_objects

static Threads::atomic< unsigned int > _n_objects

The number of objects.

Definition reference_counter.h:132

References libMesh::ReferenceCounter::_n_objects.

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

◆ n_objects() [2/2]

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

inlinestaticinherited

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

Definition at line 85 of file reference_counter.h.

86 { return _n_objects; }

References libMesh::ReferenceCounter::_n_objects.

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

◆ n_permutations()

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

inlinefinaloverridevirtual

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

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

References libMesh::DofObject::_idx_buf.

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

◆ n_second_order_adjacent_vertices()

unsigned int libMesh::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::Pyramid13, libMesh::Pyramid14, libMesh::Pyramid18, libMesh::Quad9, libMesh::Hex20, libMesh::Hex27, libMesh::InfHex16, libMesh::InfHex18, libMesh::InfPrism12, libMesh::Prism15, libMesh::Prism18, libMesh::Prism20, libMesh::Prism21, libMesh::Tet10, libMesh::Tet14, libMesh::Edge3, libMesh::Edge4, libMesh::C0Polygon, libMesh::InfQuad6, libMesh::Quad8, libMesh::Tri6, and libMesh::Tri7.

Definition at line 3175 of file elem.C.

{
  // for linear elements, always return 0
  return 0;
}

Referenced by libMesh::MeshTools::Modification::smooth(), and DualShapeTest::testTransformedDual().

◆ n_sides()

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

inlinefinaloverridevirtual

Returns: 2.

Implements libMesh::Elem.

Definition at line 83 of file edge.h.

83{ return 2; }

Referenced by build_side_ptr(), center_node_on_side(), is_child_on_side(), local_side_node(), opposite_node(), and side_ptr().

◆ n_sub_elem()

virtual unsigned int libMesh::Elem::n_sub_elem ( ) const

pure virtualinherited

Returns: The number of sub-elements this element may be broken down into for visualization purposes. For example, 1 for a linear triangle, 4 for a quadratic (6-noded) triangle, etc...

Implemented in libMesh::C0Polyhedron, libMesh::Hex20, libMesh::Hex27, libMesh::Hex8, libMesh::InfHex16, libMesh::InfHex18, libMesh::InfHex8, libMesh::InfPrism12, libMesh::InfPrism6, libMesh::Prism15, libMesh::Prism18, libMesh::Prism20, libMesh::Prism21, libMesh::Prism6, libMesh::Pyramid13, libMesh::Pyramid14, libMesh::Pyramid18, libMesh::Pyramid5, libMesh::Tet10, libMesh::Tet14, libMesh::Tet4, libMesh::Edge2, libMesh::Edge3, libMesh::Edge4, libMesh::InfEdge2, libMesh::C0Polygon, libMesh::InfQuad4, libMesh::InfQuad6, libMesh::Quad4, libMesh::Quad8, libMesh::Quad9, libMesh::Tri3, libMesh::Tri6, libMesh::Tri7, libMesh::NodeElem, and libMesh::RemoteElem.

Referenced by AllTriTest::test_helper_c0polyhedron(), VolumeTest::testC0PolygonMethods(), and libMesh::Elem::write_connectivity().

◆ n_systems()

unsigned int libMesh::DofObject::n_systems ( ) const

inlineinherited

Returns: The number of systems associated with this DofObject

Definition at line 927 of file dof_object.h.

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

References libMesh::DofObject::_idx_buf.

◆ n_var_groups()

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

inlineinherited

Returns: The number of VariableGroup variable groups associated with system s for this DofObject

Definition at line 947 of file dof_object.h.

{
  libmesh_assert_less (s, this->n_systems());
 
  return (this->end_idx(s) - this->start_idx(s)) / 2;
}

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

◆ n_vars() [1/2]

unsigned int libMesh::DofObject::n_vars ( const unsigned int s ) const

inlineinherited

Returns: The number of Variable variables associated with system s for this DofObject

Definition at line 974 of file dof_object.h.

{
  libmesh_assert_less (s, this->n_systems());
 
  const unsigned int nvg = this->n_var_groups(s);
 
  unsigned int val=0;
 
  for (unsigned int vg=0; vg<nvg; vg++)
    val += this->n_vars(s,vg);
 
  return val;
}

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

◆ n_vars() [2/2]

unsigned int libMesh::DofObject::n_vars	(	const unsigned int	s,
		const unsigned int	vg
	)		const

inlineinherited

Returns: The number of Variable variables associated with VariableGroup vg in system s for this DofObject

Definition at line 957 of file dof_object.h.

{
  libmesh_assert_less (s,  this->n_systems());
  libmesh_assert_less (vg, this->n_var_groups(s));
 
  const unsigned int start_idx_sys = this->start_idx(s);
 
  libmesh_assert_less ((start_idx_sys + 2*vg), _idx_buf.size());
 
  return (cast_int<unsigned int>
          (_idx_buf[start_idx_sys + 2*vg] >> ncv_magic_exp));
}

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

Referenced by libMesh::DofMap::allgather_recursive_constraints(), libMesh::DofMap::distribute_dofs(), libMesh::DofObject::DofObject(), libMesh::OldSolutionValue< Output, point_output >::eval_at_node(), libMesh::OldSolutionCoefs< Output, point_output >::eval_at_node(), libMesh::OldSolutionValue< Output, point_output >::eval_at_node(), libMesh::OldSolutionCoefs< Output, point_output >::eval_at_node(), libMesh::OldSolutionCoefs< Output, point_output >::eval_mixed_derivatives(), libMesh::OldSolutionValue< Output, point_output >::eval_mixed_derivatives(), libMesh::BuildProjectionList::operator()(), libMesh::DofObject::operator=(), libMesh::DofMap::set_nonlocal_dof_objects(), DofObjectTest< DerivedClass >::testAddSystemExtraInts(), DofObjectTest< DerivedClass >::testSetNVariableGroups(), and DofObjectTest< DerivedClass >::testSetNVariableGroupsExtraInts().

◆ n_vertices()

virtual unsigned int libMesh::Edge::n_vertices ( ) const

inlinefinaloverridevirtual

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]

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

{
  libmesh_assert_less (i, this->n_neighbors());
 
  return _elemlinks[i+1];
}

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

◆ neighbor_ptr() [2/2]

const Elem * libMesh::Elem::neighbor_ptr ( unsigned int i ) const

inlineinherited

Returns: A const pointer to the \( i^{th} \) neighbor of this element, or nullptr if MeshBase::find_neighbors() has not been called.

Note: If MeshBase::find_neighbors() has been called and this function still returns nullptr, then the side is on a boundary of the domain.

Definition at line 2736 of file elem.h.

{
  libmesh_assert_less (i, this->n_neighbors());
 
  return _elemlinks[i+1];
}

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

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

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

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

Referenced by libMesh::Elem::child_neighbor(), libMesh::Elem::child_neighbor(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::Elem::has_neighbor(), libMesh::InfFE< Dim, T_radial, T_map >::inf_compute_constraints(), libMesh::Elem::make_links_to_me_remote(), and libMesh::Elem::remove_links_to_me().

◆ neighbor_ptr_range() [2/2]

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

inlineinherited

Definition at line 3648 of file elem.h.

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

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

◆ node_id()

dof_id_type libMesh::Elem::node_id ( const unsigned int i ) const

inlineinherited

Returns: The global id number of local Node i.

Definition at line 2605 of file elem.h.

{
  libmesh_assert_less (i, this->n_nodes());
  libmesh_assert(_nodes[i]);
  libmesh_assert_not_equal_to (_nodes[i]->id(), Node::invalid_id);
 
  return _nodes[i]->id();
}

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

◆ node_index_range()

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

inlineinherited

Returns: An integer range from 0 up to (but not including) the number of nodes this element contains.

Definition at line 2821 of file elem.h.

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

References libMesh::Elem::n_nodes().

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

◆ node_ptr() [1/2]

Node * libMesh::Elem::node_ptr ( const unsigned int i )

inlineinherited

Returns: A non-const pointer to local Node i.

Definition at line 2648 of file elem.h.

{
  libmesh_assert_less (i, this->n_nodes());
  libmesh_assert(_nodes[i]);
 
  return _nodes[i];
}

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

◆ node_ptr() [2/2]

const Node * libMesh::Elem::node_ptr ( const unsigned int i ) const

inlineinherited

Returns: A const pointer to local Node i.

Definition at line 2637 of file elem.h.

{
  libmesh_assert_less (i, this->n_nodes());
  libmesh_assert(_nodes[i]);
 
  return _nodes[i];
}

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

◆ node_ref() [1/2]

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

inlineinherited

Returns: A writable reference to local Node i.

Definition at line 2667 of file elem.h.

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

References libMesh::Elem::node_ptr().

◆ node_ref() [2/2]

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

inlineinherited

Returns: A const reference to local Node i.

Definition at line 2659 of file elem.h.

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

References libMesh::Elem::node_ptr().

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

◆ node_ref_range() [1/2]

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

inlineinherited

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

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

Definition at line 2803 of file elem.h.

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

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

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

◆ node_ref_range() [2/2]

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

inlineinherited

Definition at line 2812 of file elem.h.

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

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

◆ nodes_on_edge()

std::vector< unsigned > libMesh::Edge::nodes_on_edge ( const unsigned int ) const

overridevirtual

Returns: the (local) node numbers on the specified edge

Implements libMesh::Elem.

Definition at line 154 of file edge.C.

{
  return nodes_on_side(e);
}

References nodes_on_side().

◆ nodes_on_side()

std::vector< unsigned > libMesh::Edge::nodes_on_side ( const unsigned int ) const

overridevirtual

Returns: the (local) node numbers on the specified side

Implements libMesh::Elem.

Reimplemented in libMesh::InfEdge2.

Definition at line 147 of file edge.C.

{
  libmesh_assert_less(s, 2);
  return {s};
}

Referenced by nodes_on_edge().

◆ nullify_neighbors()

void libMesh::Elem::nullify_neighbors ( )

inherited

Replaces this element with nullptr for all of its neighbors.

This is useful when deleting an element.

Definition at line 3149 of file elem.C.

{
  // Tell any of my neighbors about my death...
  // Looks strange, huh?
  for (auto n : this->side_index_range())
    {
      Elem * current_neighbor = this->neighbor_ptr(n);
      if (current_neighbor && current_neighbor != remote_elem)
        {
          // Note:  it is possible that I see the neighbor
          // (which is coarser than me)
          // but they don't see me, so avoid that case.
          if (current_neighbor->level() == this->level())
            {
              const unsigned int w_n_a_i = current_neighbor->which_neighbor_am_i(this);
              libmesh_assert_less (w_n_a_i, current_neighbor->n_neighbors());
              current_neighbor->set_neighbor(w_n_a_i, nullptr);
              this->set_neighbor(n, nullptr);
            }
        }
    }
}

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

◆ on_boundary()

bool libMesh::Elem::on_boundary ( ) const

inlineinherited

Returns: true if this element has a side coincident with a boundary (indicated by a nullptr neighbor), false otherwise.

Definition at line 3047 of file elem.h.

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

References libMesh::Elem::has_neighbor().

◆ on_reference_element()

bool libMesh::Edge::on_reference_element	(	const Point &	p,
		const Real	eps = `TOLERANCE`
	)		const

finaloverridevirtual

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.

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

◆ operator!=()

bool libMesh::Elem::operator!= ( const Elem & rhs ) const

inlineinherited

Returns: false if two elements are equivalent, true otherwise.

Definition at line 2728 of file elem.h.

{
  return !(*this == rhs);
}

◆ operator=() [1/2]

Edge & libMesh::Edge::operator= ( const Edge & )

delete

◆ operator=() [2/2]

Edge & libMesh::Edge::operator= ( Edge && )

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

{
  // If the elements aren't the same type, they aren't equal
  if (this->type() != rhs.type())
    return false;
 
  const unsigned short n_n = this->n_nodes();
  libmesh_assert_equal_to(n_n, rhs.n_nodes());
 
  // Make two sorted arrays of global node ids and compare them for
  // equality.
  std::array<dof_id_type, Elem::max_n_nodes> this_ids, rhs_ids;
 
  for (unsigned short n = 0; n != n_n; n++)
    {
      this_ids[n] = this->node_id(n);
      rhs_ids[n] = rhs.node_id(n);
    }
 
  // Sort the vectors to rule out different local node numberings.
  std::sort(this_ids.begin(), this_ids.begin()+n_n);
  std::sort(rhs_ids.begin(), rhs_ids.begin()+n_n);
 
  // If the node ids match, the elements are equal!
  for (unsigned short n = 0; n != n_n; ++n)
    if (this_ids[n] != rhs_ids[n])
      return false;
  return true;
}

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

◆ opposite_node()

unsigned int libMesh::Edge::opposite_node	(	const unsigned int	n,
		const unsigned int	s
	)		const

finaloverridevirtual

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.

{
  libmesh_assert_less (node_in, 2);
  libmesh_assert_less (side_in, this->n_sides());
  libmesh_assert(this->is_node_on_side(node_in, side_in));
 
  return 1 - node_in;
}

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

◆ opposite_side()

unsigned int libMesh::Edge::opposite_side ( const unsigned int s ) const

finaloverridevirtual

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.

{
  libmesh_assert_less (side_in, 2);
  return 1 - side_in;
}

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

{
  if (this->is_flipped())
    this->flip(boundary_info);
}

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

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

◆ oriented_face_vertices()

std::vector< unsigned int > libMesh::Elem::oriented_face_vertices ( const unsigned int i ) const

inherited

Returns: The local indices of the vertices of face i, starting at its lexicographically least vertex and continuing toward the lesser of that vertex's two neighbors on the face, as encoded by face_orientation(). Every element sharing the face returns the same vertices in the same order.

Definition at line 4078 of file elem.C.

{
  const unsigned int N = Elem::type_to_n_sides_map[this->side_type(i)];
  const unsigned int orientation = this->face_orientation(i);
  const unsigned int least = orientation / 2;
 
  // A positively oriented face has the lesser neighbor before the least
  // vertex in its side node map
  const bool backward = orientation % 2;
 
  std::vector<unsigned int> vertices(N);
  for (const auto k : make_range(N))
    vertices[k] = this->local_side_node(i, (least + (backward ? N - k : k)) % N);
 
  return vertices;
}

References libMesh::Elem::face_orientation(), libMesh::Elem::local_side_node(), libMesh::make_range(), libMesh::Elem::side_type(), and libMesh::Elem::type_to_n_sides_map.

Referenced by ElemTest< elem_type >::oriented_face_nodes(), and libMesh::FE< Dim, T >::shape().

◆ origin()

virtual Point libMesh::Elem::origin ( ) const

inlinevirtualinherited

Returns: The origin for an infinite element.

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

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

Definition at line 2044 of file elem.h.

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

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

◆ p_level()

unsigned int libMesh::Elem::p_level ( ) const

inlineinherited

Returns: The value of the p refinement level of an active element, or the minimum value of the p refinement levels of an ancestor element's descendants.

Definition at line 3246 of file elem.h.

{
#ifdef LIBMESH_ENABLE_AMR
  return _p_level;
#else
  return 0;
#endif
}

References libMesh::Elem::_p_level.

◆ p_refinement_flag()

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

inlineinherited

Returns: The value of the p-refinement flag for the element.

Definition at line 3364 of file elem.h.

{
  return static_cast<RefinementState>(_pflag);
}

References libMesh::Elem::_pflag.

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

◆ pack_indexing()

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

inherited

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

Definition at line 634 of file dof_object.C.

{
#ifdef LIBMESH_ENABLE_AMR
  // We might need to pack old_dof_object too
  *target++ = (old_dof_object == nullptr) ? 0 : 1;
#endif
 
  *target++ = _idx_buf.size();
  std::copy(_idx_buf.begin(), _idx_buf.end(), target);
 
#ifdef LIBMESH_ENABLE_AMR
  if (old_dof_object)
    old_dof_object->pack_indexing(target);
#endif
}

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

◆ packed_indexing_size()

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

inherited

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

Definition at line 552 of file dof_object.C.

{
  return
    cast_int<unsigned int> (
#ifdef LIBMESH_ENABLE_AMR
                            ((old_dof_object == nullptr) ? 0 : old_dof_object->packed_indexing_size()) + 2 +
#else
                            1 +
#endif
                            _idx_buf.size());
}

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

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

◆ parent() [1/2]

Elem * libMesh::Elem::parent ( )

inlineinherited

Returns: A pointer to the element's parent, or nullptr if the element was not created via refinement.

Definition at line 3176 of file elem.h.

{
  return _elemlinks[0];
}

References libMesh::Elem::_elemlinks.

◆ parent() [2/2]

const Elem * libMesh::Elem::parent ( ) const

inlineinherited

Returns: A const pointer to the element's parent, or nullptr if the element was not created via refinement.

Definition at line 3168 of file elem.h.

{
  return _elemlinks[0];
}

References libMesh::Elem::_elemlinks.

◆ parent_bracketing_nodes()

const std::vector< std::pair< unsigned char, unsigned char > > & libMesh::Elem::parent_bracketing_nodes	(	unsigned int	c,
		unsigned int	n
	)		const

virtualinherited

Returns: All the pairs of nodes (indexed by local node id) which should bracket node n of child c.

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

Definition at line 2583 of file elem.C.

{
  // Indexed first by embedding matrix type, then by child id, then by
  // child node, then by bracketing pair
  std::vector<std::vector<std::vector<std::vector<std::pair<unsigned char, unsigned char>>>>> &
    cached_bracketing_nodes = this->_get_bracketing_node_cache();
 
  const unsigned int em_vers = this->embedding_matrix_version();
 
  // We may be updating the cache on one thread, and while that
  // happens we can't safely access the cache from other threads.
  Threads::spin_mutex::scoped_lock lock(parent_bracketing_nodes_mutex);
 
  if (cached_bracketing_nodes.size() <= em_vers)
    cached_bracketing_nodes.resize(em_vers+1);
 
  const unsigned int nc = this->n_children();
 
  // If we haven't cached the bracketing nodes corresponding to this
  // embedding matrix yet, let's do so now.
  if (cached_bracketing_nodes[em_vers].size() < nc)
    {
      // If we're a second-order element but we're not a full-order
      // element, then some of our bracketing nodes may not exist
      // except on the equivalent full-order element.  Let's build an
      // equivalent full-order element and make a copy of its cache to
      // use.
      if (this->default_order() != FIRST &&
          second_order_equivalent_type(this->type(), /*full_ordered=*/ true) != this->type())
        {
          // Check that we really are the non-full-order type
          libmesh_assert_equal_to
            (second_order_equivalent_type (this->type(), false),
             this->type());
 
          // Build the full-order type
          ElemType full_type =
            second_order_equivalent_type(this->type(), /*full_ordered=*/ true);
          std::unique_ptr<Elem> full_elem = Elem::build(full_type);
 
          // This won't work for elements with multiple
          // embedding_matrix versions, but every such element is full
          // order anyways.
          libmesh_assert_equal_to(em_vers, 0);
 
          // Make sure its cache has been built.  We temporarily
          // release our mutex lock so that the inner call can
          // re-acquire it.
          lock.release();
          full_elem->parent_bracketing_nodes(0,0);
 
          // And then we need to lock again, so that if someone *else*
          // grabbed our lock before we did we don't risk accessing
          // cached_bracketing_nodes while they're working on it.
          // Threading is hard.
          lock.acquire(parent_bracketing_nodes_mutex);
 
          // Copy its cache
          cached_bracketing_nodes =
            full_elem->_get_bracketing_node_cache();
 
          // Now we don't need to build the cache ourselves.
          return cached_bracketing_nodes[em_vers][child][child_node];
        }
 
      cached_bracketing_nodes[em_vers].resize(nc);
 
      const unsigned int nn = this->n_nodes();
 
      // We have to examine each child
      for (unsigned int c = 0; c != nc; ++c)
        {
          const unsigned int ncn = this->n_nodes_in_child(c);
 
          cached_bracketing_nodes[em_vers][c].resize(ncn);
 
          // We have to examine each node in that child
          for (unsigned int n = 0; n != ncn; ++n)
            {
              // If this child node isn't a vertex or an infinite
              // child element's mid-infinite-edge node, then we need
              // to find bracketing nodes on the child.
              if (!this->is_vertex_on_child(c, n)
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
                  && !this->is_mid_infinite_edge_node(n)
#endif
                  )
                {
                  // Use the embedding matrix to find the child node
                  // location in parent master element space
                  Point bracketed_pt;
 
                  for (unsigned int pn = 0; pn != nn; ++pn)
                    {
                      const Real em_val =
                        this->embedding_matrix(c,n,pn);
 
                      libmesh_assert_not_equal_to (em_val, 1);
                      if (em_val != 0.)
                        bracketed_pt.add_scaled(this->master_point(pn), em_val);
                    }
 
                  // Check each pair of nodes on the child which are
                  // also both parent nodes
                  for (unsigned int n1 = 0; n1 != ncn; ++n1)
                    {
                      if (n1 == n)
                        continue;
 
                      unsigned int parent_n1 =
                        this->as_parent_node(c,n1);
 
                      if (parent_n1 == libMesh::invalid_uint)
                        continue;
 
                      Point p1 = this->master_point(parent_n1);
 
                      for (unsigned int n2 = n1+1; n2 < nn; ++n2)
                        {
                          if (n2 == n)
                            continue;
 
                          unsigned int parent_n2 =
                            this->as_parent_node(c,n2);
 
                          if (parent_n2 == libMesh::invalid_uint)
                            continue;
 
                          Point p2 = this->master_point(parent_n2);
 
                          Point pmid = (p1 + p2)/2;
 
                          if (pmid == bracketed_pt)
                            {
                              cached_bracketing_nodes[em_vers][c][n].emplace_back(parent_n1, parent_n2);
                              break;
                            }
                          else
                            libmesh_assert(!pmid.absolute_fuzzy_equals(bracketed_pt));
                        }
                    }
                }
              // If this child node is a parent node, we need to
              // find bracketing nodes on the parent.
              else
                {
                  unsigned int parent_node = this->as_parent_node(c,n);
 
                  Point bracketed_pt;
 
                  // If we're not a parent node, use the embedding
                  // matrix to find the child node location in parent
                  // master element space
                  if (parent_node == libMesh::invalid_uint)
                    {
                      for (unsigned int pn = 0; pn != nn; ++pn)
                        {
                          const Real em_val =
                            this->embedding_matrix(c,n,pn);
 
                          libmesh_assert_not_equal_to (em_val, 1);
                          if (em_val != 0.)
                            bracketed_pt.add_scaled(this->master_point(pn), em_val);
                        }
                    }
                  // If we're a parent node then we need no arithmetic
                  else
                    bracketed_pt = this->master_point(parent_node);
 
                  for (unsigned int n1 = 0; n1 != nn; ++n1)
                    {
                      if (n1 == parent_node)
                        continue;
 
                      Point p1 = this->master_point(n1);
 
                      for (unsigned int n2 = n1+1; n2 < nn; ++n2)
                        {
                          if (n2 == parent_node)
                            continue;
 
                          Point pmid = (p1 + this->master_point(n2))/2;
 
                          if (pmid == bracketed_pt)
                            {
                              cached_bracketing_nodes[em_vers][c][n].emplace_back(n1, n2);
                              break;
                            }
                          else
                            libmesh_assert(!pmid.absolute_fuzzy_equals(bracketed_pt));
                        }
                    }
                }
            }
        }
    }
 
  return cached_bracketing_nodes[em_vers][child][child_node];
}

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

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

◆ permute()

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

inlinefinaloverridevirtual

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]

Point & libMesh::Elem::point ( const unsigned int i )

inlineinherited

Returns: The Point associated with local Node i as a writable reference.

Definition at line 2595 of file elem.h.

{
  libmesh_assert_less (i, this->n_nodes());
 
  return *_nodes[i];
}

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

◆ point() [2/2]

const Point & libMesh::Elem::point ( const unsigned int i ) const

inlineinherited

Returns: The Point associated with local Node i.

Definition at line 2583 of file elem.h.

{
  libmesh_assert_less (i, this->n_nodes());
  libmesh_assert(_nodes[i]);
  libmesh_assert_not_equal_to (_nodes[i]->id(), Node::invalid_id);
 
  return *_nodes[i];
}

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

◆ point_test()

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

privateinherited

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

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

Definition at line 2923 of file elem.C.

{
  libmesh_assert_greater (box_tol, 0.);
  libmesh_assert_greater (map_tol, 0.);
 
  // This is a great optimization on first order elements, but it
  // could return false negatives on higher orders
  if (this->default_order() == FIRST)
    {
      // Check to make sure the element *could* contain this point, so we
      // can avoid an expensive inverse_map call if it doesn't.
      bool
#if LIBMESH_DIM > 2
        point_above_min_z = false,
        point_below_max_z = false,
#endif
#if LIBMESH_DIM > 1
        point_above_min_y = false,
        point_below_max_y = false,
#endif
        point_above_min_x = false,
        point_below_max_x = false;
 
      // For relative bounding box checks in physical space
      const Real my_hmax = this->hmax();
 
      for (auto & n : this->node_ref_range())
        {
          point_above_min_x = point_above_min_x || (n(0) - my_hmax*box_tol <= p(0));
          point_below_max_x = point_below_max_x || (n(0) + my_hmax*box_tol >= p(0));
#if LIBMESH_DIM > 1
          point_above_min_y = point_above_min_y || (n(1) - my_hmax*box_tol <= p(1));
          point_below_max_y = point_below_max_y || (n(1) + my_hmax*box_tol >= p(1));
#endif
#if LIBMESH_DIM > 2
          point_above_min_z = point_above_min_z || (n(2) - my_hmax*box_tol <= p(2));
          point_below_max_z = point_below_max_z || (n(2) + my_hmax*box_tol >= p(2));
#endif
        }
 
      if (
#if LIBMESH_DIM > 2
          !point_above_min_z ||
          !point_below_max_z ||
#endif
#if LIBMESH_DIM > 1
          !point_above_min_y ||
          !point_below_max_y ||
#endif
          !point_above_min_x ||
          !point_below_max_x)
        return false;
    }
 
  // To be on the safe side, we converge the inverse_map() iteration
  // to a slightly tighter tolerance than that requested by the
  // user...
  const Point mapped_point = FEMap::inverse_map(this->dim(),
                                                this,
                                                p,
                                                0.1*map_tol, // <- this is |dx| tolerance, the Newton residual should be ~ |dx|^2
                                                /*secure=*/ false,
                                                /*extra_checks=*/ false);
 
  // Check that the refspace point maps back to p!  This is only necessary
  // for 1D and 2D elements, 3D elements always live in 3D.
  //
  // TODO: The contains_point() function could most likely be implemented
  // more efficiently in the element sub-classes themselves, at least for
  // the linear element types.
  if (this->dim() < 3)
    {
      Point xyz = FEMap::map(this->dim(), this, mapped_point);
 
      // Compute the distance between the original point and the re-mapped point.
      // They should be in the same place.
      Real dist = (xyz - p).norm();
 
 
      // If dist is larger than some fraction of the tolerance, then return false.
      // This can happen when e.g. a 2D element is living in 3D, and
      // FEMap::inverse_map() maps p onto the projection of the element,
      // effectively "tricking" on_reference_element().
      if (dist > this->hmax() * map_tol)
        return false;
    }
 
  return this->on_reference_element(mapped_point, map_tol);
}

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

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

◆ positive_edge_orientation()

bool libMesh::Elem::positive_edge_orientation ( const unsigned int i ) const

inherited

Returns: true if edge i is positively oriented. An edge is positively oriented iff its first vertex (i.e. zeroth node) is lexicographically greater than its second vertex (i.e. first node).

Definition at line 4037 of file elem.C.

{
  libmesh_assert_less (i, this->n_edges());
 
  return this->point(this->local_edge_node(i, 0)) >
         this->point(this->local_edge_node(i, 1));
}

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

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

◆ positive_face_orientation()

bool libMesh::Elem::positive_face_orientation ( const unsigned int i ) const

inherited

Returns: true if face i is positively oriented. A face is positively oriented iff the triangle defined by the lexicographically least vertex and its two adjacent vertices on the same face is positively oriented. Said triangle is positively oriented iff its vertices are an odd permutation of their lexicographic ordering.

Definition at line 4046 of file elem.C.

{
  return this->face_orientation(i) % 2;
}

References libMesh::Elem::face_orientation().

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

◆ print_dof_info()

void libMesh::DofObject::print_dof_info ( ) const

inherited

Print out info for debugging.

Definition at line 662 of file dof_object.C.

{
  libMesh::out << this->id() << " [ ";
 
  for (auto s : make_range(this->n_systems()))
    {
      libMesh::out << "s:" << s << " ";
      for (auto var : make_range(this->n_vars(s)))
        {
          libMesh::out << "v:" << var << " ";
          for (auto comp : make_range(this->n_comp(s,var)))
            {
              libMesh::out << "c:" << comp << " dof:" << this->dof_number(s,var,comp) << " ";
            }
        }
    }
 
  libMesh::out << "]\n";
}

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

◆ print_info() [1/3]

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

inherited

Prints relevant information about the element.

Definition at line 3050 of file elem.C.

{
  os << this->get_info()
     << std::endl;
}

References libMesh::Elem::get_info().

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

◆ print_info() [2/3]

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

staticinherited

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

Definition at line 81 of file reference_counter.C.

{
  if (_enable_print_counter)
    out_stream << ReferenceCounter::get_info();
}

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

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

◆ print_info() [3/3]

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

staticinherited

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

Definition at line 81 of file reference_counter.C.

{
  if (_enable_print_counter)
    out_stream << ReferenceCounter::get_info();
}

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

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

◆ processor_id() [1/3]

processor_id_type & libMesh::DofObject::processor_id ( )

inlineinherited

Returns: The processor that this DofObject belongs to as a writable reference.

Definition at line 903 of file dof_object.h.

{
  return _processor_id;
}

References libMesh::DofObject::_processor_id.

◆ processor_id() [2/3]

processor_id_type libMesh::DofObject::processor_id ( ) const

inlineinherited

Returns: The processor that this DofObject belongs to.

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

Definition at line 895 of file dof_object.h.

{
  return _processor_id;
}

References libMesh::DofObject::_processor_id.

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

◆ processor_id() [3/3]

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

inlineinherited

Sets the processor_id for this DofObject.

Definition at line 911 of file dof_object.h.

{
  this->processor_id() = pid;
}

References libMesh::DofObject::processor_id().

◆ 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::Hex, libMesh::InfHex, libMesh::Polyhedron, libMesh::Prism, libMesh::Pyramid, libMesh::Tet, libMesh::InfQuad, libMesh::Polygon, libMesh::Quad, and libMesh::Tri.

Definition at line 1208 of file elem.h.

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

Referenced by main().

◆ 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. In 3D, these are not the dihedral angles between adjacent planar faces of the element. In 2D, we compute the angle between adjacent sides for this metric. .) MIN,MAX_DIHEDRAL_ANGLE - In 3D, the minimum (respectively maximum) unoriented angle between adjacent side planes, folded into the range [0, 90] degrees. In 2D, these are equivalent to MIN,MAX_ANGLE.

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

Definition at line 1723 of file elem.C.

{
  switch (q)
    {
      // Return the maximum ratio of edge lengths, or zero if that
      // maximum would otherwise be infinity.
    case EDGE_LENGTH_RATIO:
      {
        if (this->dim() < 2)
          return 1;
 
        std::vector<Real> edge_lengths(this->n_edges());
        for (auto e : index_range(edge_lengths))
          edge_lengths[e] = (this->point(this->local_edge_node(e,1)) -
                             this->point(this->local_edge_node(e,0))).norm();
 
        auto [min, max] =
          std::minmax_element(edge_lengths.begin(), edge_lengths.end());
 
        if (*min == 0.)
          return 0.;
        else
          return *max / *min;
      }
 
    case MIN_ANGLE:
    case MAX_ANGLE:
      {
        // 1D elements don't have interior angles, so just return some
        // dummy value in that case.
        if (this->dim() < 2)
          return 0.;
 
        // Initialize return values
        Real min_angle = std::numeric_limits<Real>::max();
        Real max_angle = -std::numeric_limits<Real>::max();
 
        for (auto n : this->node_index_range())
          {
            // Get list of edge ids adjacent to this node.
            const auto adjacent_edge_ids = this->edges_adjacent_to_node(n);
 
            // Skip any nodes with fewer than 2 adjacent edges. You
            // need at least two adjacent edges to form an interior
            // element angle.
            auto N = adjacent_edge_ids.size();
            if (N < 2)
              continue;
 
            // Consider all possible pairs of edges adjacent to node n
            for (unsigned int first = 0; first < N-1; ++first)
              for (unsigned int second = first+1; second < N; ++second)
                {
                  // Get ids of first and second edges
                  auto first_edge = adjacent_edge_ids[first];
                  auto second_edge = adjacent_edge_ids[second];
 
                  // Get node ids of first and second edge
                  auto first_edge_node_0 = this->local_edge_node(first_edge, 0);
                  auto first_edge_node_1 = this->local_edge_node(first_edge, 1);
                  auto second_edge_node_0 = this->local_edge_node(second_edge, 0);
                  auto second_edge_node_1 = this->local_edge_node(second_edge, 1);
 
                  // Orient both edges so that edge node 0 == n
                  if (first_edge_node_0 != n)
                    std::swap(first_edge_node_0, first_edge_node_1);
                  if (second_edge_node_0 != n)
                    std::swap(second_edge_node_0, second_edge_node_1);
 
                  libmesh_assert_equal_to(first_edge_node_0, n);
                  libmesh_assert_equal_to(second_edge_node_0, n);
 
                  // Locally oriented edge vectors
                  Point
                    first_ev = this->point(first_edge_node_1) - this->point(first_edge_node_0),
                    second_ev = this->point(second_edge_node_1) - this->point(second_edge_node_0);
 
                  // Angle between them in the range [0, pi]
                  Real theta = std::acos(first_ev.unit() * second_ev.unit());
 
                  // Track min and max angles seen
                  min_angle = std::min(theta, min_angle);
                  max_angle = std::max(theta, max_angle);
                }
          }
 
        // Return requested extreme value (in degrees)
        return Real(180)/libMesh::pi * ((q == MIN_ANGLE) ? min_angle : max_angle);
      }
 
    case MIN_DIHEDRAL_ANGLE:
    case MAX_DIHEDRAL_ANGLE:
      {
        // For 1D and 2D elements, just call this function with MIN,MAX_ANGLE instead.
        if (this->dim() < 3)
          return this->quality((q == MIN_DIHEDRAL_ANGLE) ? MIN_ANGLE : MAX_ANGLE);
 
        // Initialize return values
        Real min_angle = std::numeric_limits<Real>::max();
        Real max_angle = -std::numeric_limits<Real>::max();
 
        // Algorithm for computing dihedral angles:
        // .) Loop over the edges, use the edge_sides_map to get the
        //    two sides adjacent to the edge.
        // .) For each adjacent side, use the side_nodes_map to get the
        //    list of three (or more) node ids on that side.
        // .) Use the node ids to compute the (approximate) inward
        //    normal for the side.  Note: this is approximate since 3D
        //    elements with four-sided faces and quadratic tetrahedra
        //    do not necessarily have planar faces.
        // .) Compute the dihedral angle for the current edge, compare
        //    it to the current min and max dihedral angles.
        for (auto e : this->edge_index_range())
          {
            // Get list of edge ids adjacent to this node.
            const auto adjacent_side_ids = this->sides_on_edge(e);
 
            // All 3D elements should have exactly two sides adjacent to each edge.
            libmesh_assert_equal_to(adjacent_side_ids.size(), 2);
 
            // Get lists of node ids on each side
            const auto side_0_node_ids = this->nodes_on_side(adjacent_side_ids[0]);
            const auto side_1_node_ids = this->nodes_on_side(adjacent_side_ids[1]);
 
            // All 3D elements have at least three nodes on each side
            libmesh_assert_greater_equal(side_0_node_ids.size(), 3);
            libmesh_assert_greater_equal(side_1_node_ids.size(), 3);
 
            // Construct (approximate) inward normal on each adjacent side
            const auto side_0_normal =
              (this->point(side_0_node_ids[2]) - this->point(side_0_node_ids[0])).cross
              (this->point(side_0_node_ids[1]) - this->point(side_0_node_ids[0])).unit();
            const auto side_1_normal =
              (this->point(side_1_node_ids[2]) - this->point(side_1_node_ids[0])).cross
              (this->point(side_1_node_ids[1]) - this->point(side_1_node_ids[0])).unit();
 
            // Compute dihedral angle between the planes.
            // Using the absolute value ensures that we get the same result
            // even if the orientation of one of the planes is flipped, i.e.
            // it always gives us a value in the range [0, pi/2].
            // https://en.wikipedia.org/wiki/Dihedral_angle
            Real theta = std::acos(std::abs(side_0_normal * side_1_normal));
 
            // Track min and max angles seen
            min_angle = std::min(theta, min_angle);
            max_angle = std::max(theta, max_angle);
          }
 
        // Return requested extreme value (in degrees)
        return Real(180)/libMesh::pi * ((q == MIN_DIHEDRAL_ANGLE) ? min_angle : max_angle);
      }
 
    case JACOBIAN:
    case SCALED_JACOBIAN:
      {
        // 1D elements don't have interior corners, so this metric
        // does not really apply to them.
        const auto N = this->dim();
        if (N < 2)
          return 1.;
 
        // Initialize return value
        Real min_node_area = std::numeric_limits<Real>::max();
 
        for (auto n : this->node_index_range())
          {
            // Get list of edge ids adjacent to this node.
            auto adjacent_edge_ids = this->edges_adjacent_to_node(n);
 
            // Skip any nodes that don't have dim() adjacent edges. In 2D,
            // you need at least two adjacent edges to compute the cross
            // product, and in 3D, you need at least three adjacent edges
            // to compute the scalar triple product. The only element
            // type which has an unusual topology in this regard is the
            // Pyramid element in 3D, where 4 edges meet at the apex node.
            // For now, we just skip this node when computing the JACOBIAN
            // metric for Pyramids.
            if (adjacent_edge_ids.size() != N)
              continue;
 
            // Construct oriented edges
            std::vector<Point> oriented_edges(N);
            for (auto i : make_range(N))
              {
                auto node_0 = this->local_edge_node(adjacent_edge_ids[i], 0);
                auto node_1 = this->local_edge_node(adjacent_edge_ids[i], 1);
                if (node_0 != n)
                  std::swap(node_0, node_1);
                oriented_edges[i] = this->point(node_1) - this->point(node_0);
              }
 
            // Compute unscaled area (2D) or volume (3D) using the
            // cross product (2D) or scalar triple product (3D) of the
            // oriented edges. We take the absolute value so that we
            // don't have to worry about the sign of the area.
            Real node_area = (N == 2) ?
              cross_norm(oriented_edges[0], oriented_edges[1]) :
              std::abs(triple_product(oriented_edges[0], oriented_edges[1], oriented_edges[2]));
 
            // Divide by (non-zero) edge lengths if computing scaled Jacobian.
            // If any length is zero, then set node_area to zero. This means that
            // e.g. degenerate quadrilaterals will have a zero SCALED_JACOBIAN metric.
            if (q == SCALED_JACOBIAN)
              for (auto i : make_range(N))
                {
                  Real len_i = oriented_edges[i].norm();
                  node_area = (len_i == 0.) ? 0. : (node_area / len_i);
                }
 
            // Update minimum
            min_node_area = std::min(node_area, min_node_area);
          }
 
        return min_node_area;
      }
 
      // Relative size metric: min over the corner nodes of min(tau,
      // 1/tau), where tau is the ratio of the corner's nodal Jacobian
      // determinant to that of the ideal (regular) element of the same
      // volume -- ReferenceElem::ideal_target(), rescaled to this
      // element's volume via the volume ratio. tau = 1 at every corner
      // of an element whose Jacobian is uniform (any affine element:
      // parallelogram, box, or regular simplex, at any scale), so the
      // metric is 1; non-uniform (tapered/sheared) elements score below
      // 1, and a degenerate corner drives it to 0.
    case SIZE:
      {
        // 1D elements don't have interior corners, so this metric does
        // not really apply to them.
        const auto N = this->dim();
        if (N < 2)
          return 1.;
 
        const Real vol = this->volume();
        if (vol == 0.)
          return 0.;
 
        // Ideal (regular) element of the same type; its Jacobian is
        // uniform. We compare nodal determinants after rescaling it to
        // this element's volume, i.e. multiply by ideal_vol / this_vol.
        const auto ideal_pair = ReferenceElem::ideal_target(this->type());
        const Elem & ideal = *ideal_pair.first;
        const Real vol_ratio = ideal.volume() / vol;
 
        // Nodal Jacobian determinant at node n of element el (the same
        // construction as the JACOBIAN metric above).
        auto nodal_det = [](const Elem & el, const unsigned int n,
                            const std::vector<unsigned int> & edge_ids,
                            const unsigned int dim)
        {
          std::vector<Point> e(dim);
          for (unsigned int i = 0; i != dim; ++i)
            {
              auto n0 = el.local_edge_node(edge_ids[i], 0);
              auto n1 = el.local_edge_node(edge_ids[i], 1);
              if (n0 != n)
                std::swap(n0, n1);
              e[i] = el.point(n1) - el.point(n0);
            }
          return (dim == 2) ? cross_norm(e[0], e[1])
                            : std::abs(triple_product(e[0], e[1], e[2]));
        };
 
        Real size = 1.;
        bool have_corner = false;
        for (auto n : this->node_index_range())
          {
            // Skip any nodes that don't have dim() adjacent edges (see
            // the JACOBIAN metric above for the Pyramid apex caveat).
            const auto adjacent_edge_ids = this->edges_adjacent_to_node(n);
            if (adjacent_edge_ids.size() != N)
              continue;
            have_corner = true;
 
            const Real a  = nodal_det(*this, n, adjacent_edge_ids, N);
            const Real aw = nodal_det(ideal, n, adjacent_edge_ids, N);
 
            // Degenerate corner: worst quality.
            if (a == 0. || aw == 0.)
              return 0.;
 
            const Real tau = (a / aw) * vol_ratio;
            size = std::min(size, std::min(tau, Real(1) / tau));
          }
 
        return have_corner ? size : 0.;
      }
 
      // Maximum condition number of the nodal Jacobian over the corner
      // nodes, measured against the ideal (regular) element rather than
      // the reference element. At each corner the physical nodal
      // Jacobian A and the ideal nodal Jacobian W (taken from the same
      // corner of ReferenceElem::ideal_target) give the weighted
      // Jacobian A W^{-1}, whose Frobenius condition number, via the
      // corner metric tensors T_A = A^T A and T_W = W^T W (which also
      // handles a lower-dimensional element embedded in 3D), is
      //   kappa = sqrt(tr(T_A T_W^{-1}) * tr(T_W T_A^{-1})) / N.
      // This is 1 for a corner similar to the ideal one -- so an
      // equilateral triangle or regular tetrahedron scores 1, not just
      // a right-angled corner -- and grows with distortion. A
      // degenerate corner has an infinite condition number, reported as
      // 0 (0 stands in for infinity, cf. EDGE_LENGTH_RATIO).
    case CONDITION:
      {
        // 1D elements don't have interior corners, so this metric does
        // not really apply to them.
        const auto N = this->dim();
        if (N < 2)
          return 1.;
 
        // Ideal (regular) element of the same type; W is its nodal
        // Jacobian. Its scale is irrelevant here (the condition number
        // is scale invariant), so the reference-volume sizing is fine.
        const auto ideal_pair = ReferenceElem::ideal_target(this->type());
        const Elem & ideal = *ideal_pair.first;
 
        // Corner metric tensor T = A^T A at node n of element el, padded
        // with the identity in unused dimensions so that RealTensor's
        // 3x3 inverse yields the correct NxN inverse.
        auto metric_tensor = [](const Elem & el, const unsigned int n,
                                const std::vector<unsigned int> & edge_ids,
                                const unsigned int dim)
        {
          std::vector<Point> e(dim);
          for (unsigned int i = 0; i != dim; ++i)
            {
              auto n0 = el.local_edge_node(edge_ids[i], 0);
              auto n1 = el.local_edge_node(edge_ids[i], 1);
              if (n0 != n)
                std::swap(n0, n1);
              e[i] = el.point(n1) - el.point(n0);
            }
          RealTensor T(1, 0, 0,  0, 1, 0,  0, 0, 1);
          for (unsigned int i = 0; i != dim; ++i)
            for (unsigned int j = 0; j != dim; ++j)
              T(i, j) = e[i] * e[j];
          return T;
        };
 
        // kappa >= 1 for every matrix, so 1 is both the ideal value and
        // a safe floor for the running maximum.
        Real max_cond = 1.;
 
        for (auto n : this->node_index_range())
          {
            // Skip any nodes that don't have dim() adjacent edges (see
            // the JACOBIAN metric above for the Pyramid apex caveat).
            const auto adjacent_edge_ids = this->edges_adjacent_to_node(n);
            if (adjacent_edge_ids.size() != N)
              continue;
 
            const RealTensor Ta = metric_tensor(*this, n, adjacent_edge_ids, N);
 
            // Degenerate corner: infinite condition number.
            if (Ta.det() == 0.)
              return 0.;
 
            const RealTensor Tw = metric_tensor(ideal, n, adjacent_edge_ids, N);
            const RealTensor Ta_inv = Ta.inverse();
            const RealTensor Tw_inv = Tw.inverse();
 
            // num1 = tr(T_A T_W^{-1}), num2 = tr(T_W T_A^{-1}) over the
            // NxN blocks (both symmetric, so summed as elementwise dot
            // products).
            Real num1 = 0., num2 = 0.;
            for (auto i : make_range(N))
              for (auto j : make_range(N))
                {
                  num1 += Ta(i, j) * Tw_inv(i, j);
                  num2 += Tw(i, j) * Ta_inv(i, j);
                }
 
            max_cond = std::max(max_cond, std::sqrt(num1 * num2) / N);
          }
 
        return max_cond;
      }
 
      // Return 1 if we made it here
    default:
      {
        libmesh_do_once( libmesh_here();
 
                         libMesh::err << "ERROR: quality metric "
                         << Utility::enum_to_string(q)
                         << " not implemented on element type "
                         << Utility::enum_to_string(this->type())
                         << std::endl
                         << "Returning 1."
                         << std::endl; );
 
        return 1.;
      }
    }
}

References libMesh::CONDITION, libMesh::cross_norm(), libMesh::TypeTensor< T >::det(), 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::ReferenceElem::ideal_target(), libMesh::index_range(), libMesh::TypeTensor< T >::inverse(), 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::pi, libMesh::Elem::point(), libMesh::Elem::quality(), libMesh::Real, libMesh::SCALED_JACOBIAN, libMesh::Elem::sides_on_edge(), libMesh::SIZE, libMesh::triple_product(), libMesh::Elem::type(), libMesh::TypeVector< T >::unit(), and libMesh::Elem::volume().

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

◆ quasicircumcenter()

virtual Point libMesh::Edge::quasicircumcenter ( ) const

inlineoverridevirtual

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.

226 { return (this->point(0) + this->point(1)) / 2; }

References libMesh::Elem::point().

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

{
  if (!_children)
    return nullptr;
 
  return _children[i];
}

References libMesh::Elem::_children.

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

◆ reference_elem()

const Elem * libMesh::Elem::reference_elem ( ) const

inherited

Returns: A pointer to the "reference element" associated with this element. The reference element is the image of this element in reference parametric space. Importantly, it is not an actual element in the mesh, but rather a Singleton-type object, so for example all Quad4 elements share the same reference_elem().

If the element is of a type that can admit multiple topologies, such as a Polygon subtype, then there is no reference element; for such types this method should not be used.

Definition at line 508 of file elem.C.

{
  return &(ReferenceElem::get(this->type()));
}

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

Referenced by libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors(), libMesh::VariationalSmootherSystem::get_target_to_reference_jacobian(), libMesh::QComposite< QSubCell >::init(), libMesh::RBParametrizedFunction::preevaluate_parametrized_function_on_mesh(), and ElemTest< elem_type >::test_ref_elem().

◆ refine()

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

virtualinherited

Refine the element.

Definition at line 87 of file elem_refinement.C.

{
  libmesh_assert_equal_to (this->refinement_flag(), Elem::REFINE);
  libmesh_assert (this->active());
 
  const unsigned int nc = this->n_children();
 
  // Create my children if necessary
  if (!_children)
    {
      _children = std::make_unique<Elem *[]>(nc);
 
      unsigned int parent_p_level = this->p_level();
      const unsigned int nei = this->n_extra_integers();
      for (unsigned int c = 0; c != nc; c++)
        {
          auto current_child = Elem::build(this->type(), this);
          _children[c] = current_child.get();
 
          current_child->set_refinement_flag(Elem::JUST_REFINED);
          current_child->set_p_level(parent_p_level);
          current_child->set_p_refinement_flag(this->p_refinement_flag());
 
          for (auto cnode : current_child->node_index_range())
            {
              Node * node =
                mesh_refinement.add_node(*this, c, cnode,
                                         current_child->processor_id());
              node->set_n_systems (this->n_systems());
              current_child->set_node(cnode, node);
            }
 
          Elem * added_child = mesh_refinement.add_elem (std::move(current_child));
          added_child->set_n_systems(this->n_systems());
          libmesh_assert_equal_to (added_child->n_extra_integers(),
                                   this->n_extra_integers());
          for (unsigned int i=0; i != nei; ++i)
            added_child->set_extra_integer(i, this->get_extra_integer(i));
        }
    }
  else
    {
      unsigned int parent_p_level = this->p_level();
      for (unsigned int c = 0; c != nc; c++)
        {
          Elem * current_child = this->child_ptr(c);
          if (current_child != remote_elem)
            {
              libmesh_assert(current_child->subactive());
              current_child->set_refinement_flag(Elem::JUST_REFINED);
              current_child->set_p_level(parent_p_level);
              current_child->set_p_refinement_flag(this->p_refinement_flag());
            }
        }
    }
 
  // Get any new remote neighbor links right; even find_neighbors
  // relies on those
  for (unsigned int s : this->side_index_range())
    {
      if (this->neighbor_ptr(s) != remote_elem)
        continue;
 
      for (unsigned int c = 0; c != nc; c++)
        {
          Elem * current_child = this->child_ptr(c);
          if (current_child != remote_elem &&
              this->is_child_on_side(c, s))
            current_child->set_neighbor
              (s, const_cast<RemoteElem *>(remote_elem));
        }
    }
 
  // Un-set my refinement flag now
  this->set_refinement_flag(Elem::INACTIVE);
 
  // Leave the p refinement flag set - we will need that later to get
  // projection operations correct
  // this->set_p_refinement_flag(Elem::INACTIVE);
 
#ifndef NDEBUG
  for (unsigned int c = 0; c != nc; c++)
    if (this->child_ptr(c) != remote_elem)
      {
        libmesh_assert_equal_to (this->child_ptr(c)->parent(), this);
        libmesh_assert(this->child_ptr(c)->active());
      }
#endif
  libmesh_assert (this->ancestor());
}

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

◆ refinement_flag()

Elem::RefinementState libMesh::Elem::refinement_flag ( ) const

inlineinherited

Returns: The value of the refinement flag for the element.

Definition at line 3348 of file elem.h.

{
  return static_cast<RefinementState>(_rflag);
}

References libMesh::Elem::_rflag.

◆ relative_edge_face_order()

bool libMesh::Elem::relative_edge_face_order	(	const unsigned int	e,
		const unsigned int	s
	)		const

inherited

Returns: true iff, for an edge e on side s, the node map for side s is such that the first vertex (i.e. zeroth node) of e is lower positioned than the second vertex (i.e. first node) of e.

Definition at line 4096 of file elem.C.

{
  libmesh_assert_less (e, this->n_edges());
  libmesh_assert_less (s, this->n_faces());
  libmesh_assert (is_edge_on_side(e, s));
 
  const unsigned int N = Elem::type_to_n_sides_map[this->side_type(s)];
 
  unsigned int v;
  for (v = 0; v < N; v++)
    if (this->local_side_node(s, v) == this->local_edge_node(e, 0))
      break;
 
  libmesh_assert (this->local_side_node(s, (v + 1) % N) ==
                  this->local_edge_node(e, 1) ||
                  this->local_side_node(s, (v - 1 + N) % N) ==
                  this->local_edge_node(e, 1));
 
  return this->local_side_node(s, (v + 1) % N) ==
         this->local_edge_node(e, 1);
}

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

◆ remove_links_to_me()

void libMesh::Elem::remove_links_to_me ( )

inherited

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

To be used before an element is deleted from a mesh.

Definition at line 1588 of file elem.C.

{
  libmesh_assert_not_equal_to (this, remote_elem);
 
  // We need to have handled any children first
#ifdef LIBMESH_ENABLE_AMR
  libmesh_assert (!this->has_children());
#endif
 
  // Nullify any neighbor links
  for (auto neigh : this->neighbor_ptr_range())
    {
      if (neigh && neigh != remote_elem)
        {
          // My neighbor should never be more refined than me; my real
          // neighbor would have been its parent in that case.
          libmesh_assert_greater_equal (this->level(), neigh->level());
 
          if (this->level() == neigh->level() &&
              neigh->has_neighbor(this))
            {
#ifdef LIBMESH_ENABLE_AMR
              // My neighbor may have descendants which also consider me a
              // neighbor
              std::vector<Elem *> family;
              neigh->total_family_tree_by_neighbor (family, this);
 
              for (auto & n : family)
                {
                  libmesh_assert (n);
                  if (n->is_remote())
                    continue;
                  unsigned int my_s = n->which_neighbor_am_i(this);
                  libmesh_assert_less (my_s, n->n_neighbors());
                  libmesh_assert_equal_to (n->neighbor_ptr(my_s), this);
                  n->set_neighbor(my_s, nullptr);
                }
#else
              unsigned int my_s = neigh->which_neighbor_am_i(this);
              libmesh_assert_less (my_s, neigh->n_neighbors());
              libmesh_assert_equal_to (neigh->neighbor_ptr(my_s), this);
              neigh->set_neighbor(my_s, nullptr);
#endif
            }
#ifdef LIBMESH_ENABLE_AMR
          // Even if my neighbor doesn't link back to me, it might
          // have subactive descendants which do
          else if (neigh->has_children())
            {
              // If my neighbor at the same level doesn't have me as a
              // neighbor, I must be subactive
              libmesh_assert(this->level() > neigh->level() ||
                             this->subactive());
 
              // My neighbor must have some ancestor of mine as a
              // neighbor
              Elem * my_ancestor = this->parent();
              libmesh_assert(my_ancestor);
              while (!neigh->has_neighbor(my_ancestor))
                {
                  my_ancestor = my_ancestor->parent();
                  libmesh_assert(my_ancestor);
                }
 
              // My neighbor may have descendants which consider me a
              // neighbor
              std::vector<Elem *> family;
              neigh->total_family_tree_by_subneighbor (family, my_ancestor, this);
 
              for (auto & n : family)
                {
                  libmesh_assert (n);
                  if (n->is_remote())
                    continue;
                  unsigned int my_s = n->which_neighbor_am_i(this);
                  libmesh_assert_less (my_s, n->n_neighbors());
                  libmesh_assert_equal_to (n->neighbor_ptr(my_s), this);
                  n->set_neighbor(my_s, nullptr);
                }
            }
#endif
        }
    }
 
#ifdef LIBMESH_ENABLE_AMR
  // We can't currently delete a child with a parent!
  libmesh_assert (!this->parent());
#endif
}

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

Referenced by MeshDeletionsTest::testDeleteElem().

◆ replace_child()

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

inherited

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

Definition at line 2201 of file elem.C.

{
  libmesh_assert(this->has_children());
 
  libmesh_assert(this->child_ptr(c));
 
  this->set_child(c, elem);
}

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

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

◆ runtime_topology()

virtual bool libMesh::Elem::runtime_topology ( ) const

inlinevirtualinherited

Returns: true iff this element type can vary in topology (e.g. have different numbers of sides and/or nodes) at runtime. For such general polygons or polyhedra, APIs which assume a fixed topology are not safe to use.

Reimplemented in libMesh::Polyhedron, and libMesh::Polygon.

Definition at line 254 of file elem.h.

254{ return false; }

Referenced by libMesh::FE< Dim, T >::edge_map(), libMesh::FE< Dim, T >::edge_reinit(), libMesh::Elem::Elem(), libMesh::QBase::init(), libMesh::FE< Dim, T >::reinit(), libMesh::FE< Dim, T >::reinit(), libMesh::FE< Dim, T >::side_map(), FETest< order, family, elem_type, CaseName >::testNodalSoln(), FETest< order, family, elem_type, CaseName >::testRefspaceNodes(), and libMesh::Parallel::Packing< Elem * >::unpack().

◆ 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::Hex20, libMesh::Hex27, libMesh::InfHex16, libMesh::InfHex18, libMesh::InfPrism12, libMesh::Prism15, libMesh::Prism18, libMesh::Prism20, libMesh::Prism21, libMesh::Pyramid13, libMesh::Pyramid14, libMesh::Pyramid18, libMesh::Tet10, libMesh::Tet14, libMesh::InfQuad6, libMesh::Quad8, libMesh::Quad9, libMesh::Tri6, libMesh::Tri7, libMesh::Edge3, and libMesh::Edge4.

Definition at line 3183 of file elem.C.

{
  // for linear elements, always return 0
  return 0;
}

Referenced by libMesh::MeshTools::Modification::smooth(), and DualShapeTest::testTransformedDual().

◆ 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::C0Polyhedron, libMesh::Hex20, libMesh::Hex27, libMesh::InfHex16, libMesh::InfHex18, libMesh::InfPrism12, libMesh::Prism15, libMesh::Prism18, libMesh::Prism20, libMesh::Prism21, libMesh::Tet10, libMesh::Tet14, libMesh::Edge3, libMesh::C0Polygon, libMesh::InfQuad6, libMesh::Quad8, libMesh::Quad9, libMesh::Tri6, and libMesh::Tri7.

Definition at line 3193 of file elem.C.

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

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

{
  switch (et)
    {
    case NODEELEM:
      return NODEELEM;
    case EDGE2:
    case EDGE3:
      {
        // full_ordered not relevant
        return EDGE3;
      }
 
    case EDGE4:
      {
        // full_ordered not relevant
        return EDGE4;
      }
 
    case TRI3:
    case TRI6:
      {
        // full_ordered not relevant
        return TRI6;
      }
 
    case TRI7:
      return TRI7;
 
      // Currently there is no TRISHELL6, so similarly to other types
      // where this is the case, we just return the input.
    case TRISHELL3:
      return TRISHELL3;
 
    case QUAD4:
    case QUAD8:
      {
        if (full_ordered)
          return QUAD9;
        else
          return QUAD8;
      }
 
    case QUADSHELL4:
    case QUADSHELL8:
      {
        if (full_ordered)
          return QUADSHELL9;
        else
          return QUADSHELL8;
      }
 
    case QUAD9:
      {
        // full_ordered not relevant
        return QUAD9;
      }
 
    case QUADSHELL9:
      {
        // full_ordered not relevant
        return QUADSHELL9;
      }
 
    case TET4:
    case TET10:
      {
        // full_ordered not relevant
        return TET10;
      }
 
    case TET14:
      return TET14;
 
    case HEX8:
    case HEX20:
      {
        // see below how this correlates with INFHEX8
        if (full_ordered)
          return HEX27;
        else
          return HEX20;
      }
 
    case HEX27:
      {
        // full_ordered not relevant
        return HEX27;
      }
 
    case PRISM6:
    case PRISM15:
      {
        if (full_ordered)
          return PRISM18;
        else
          return PRISM15;
      }
 
    // full_ordered not relevant, already fully second order
    case PRISM18:
      return PRISM18;
    case PRISM20:
      return PRISM20;
    case PRISM21:
      return PRISM21;
    case PYRAMID18:
      return PYRAMID18;
 
    case PYRAMID5:
    case PYRAMID13:
      {
        if (full_ordered)
          return PYRAMID14;
        else
          return PYRAMID13;
      }
 
    case PYRAMID14:
      {
        // full_ordered not relevant
        return PYRAMID14;
      }
 
 
 
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
 
      // infinite elements
    case INFEDGE2:
      {
        return INFEDGE2;
      }
 
    case INFQUAD4:
    case INFQUAD6:
      {
        // full_ordered not relevant
        return INFQUAD6;
      }
 
    case INFHEX8:
    case INFHEX16:
      {
        /*
         * Note that this matches with \p Hex8:
         * For full-ordered, \p InfHex18 and \p Hex27
         * belong together, and for not full-ordered,
         * \p InfHex16 and \p Hex20 belong together.
         */
        if (full_ordered)
          return INFHEX18;
        else
          return INFHEX16;
      }
 
    case INFHEX18:
      {
        // full_ordered not relevant
        return INFHEX18;
      }
 
    case INFPRISM6:
    case INFPRISM12:
      {
        // full_ordered not relevant
        return INFPRISM12;
      }
 
#endif
 
 
    default:
      {
        // what did we miss?
        libmesh_error_msg("No second order equivalent element type for et =  "
                          << Utility::enum_to_string(et));
      }
    }
}

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

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

◆ set_buffer()

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

inlineinherited

Definition at line 722 of file dof_object.h.

723 { _idx_buf = buf; }

References libMesh::DofObject::_idx_buf.

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

◆ set_child()

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

inlineprivateinherited

Sets the pointer to the \( i^{th} \) child for this element.

Do not call if this element has no children, i.e. is active.

Definition at line 3320 of file elem.h.

{
  libmesh_assert (this->has_children());
 
  _children[c] = elem;
}

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

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

◆ set_dof_number()

void libMesh::DofObject::set_dof_number	(	const unsigned int	s,
		const unsigned int	var,
		const unsigned int	comp,
		const dof_id_type	dn
	)

inherited

Sets the global degree of freedom number for variable var, component comp for system s associated with this DofObject.

Definition at line 446 of file dof_object.C.

{
  libmesh_assert_less (s,    this->n_systems());
  libmesh_assert_less (var,  this->n_vars(s));
  libmesh_assert_less (comp, this->n_comp(s,var));
 
  const unsigned int
    vg            = this->var_to_vg(s,var),
#ifndef NDEBUG
    ncg           = this->n_comp_group(s,vg),
#endif
    vig           = this->system_var_to_vg_var(s,vg,var),
    start_idx_sys = this->start_idx(s);
 
  libmesh_assert_less ((start_idx_sys + 2*vg + 1), _idx_buf.size());
 
  dof_id_type & base_idx = _idx_buf[start_idx_sys + 2*vg + 1];
 
  // We intend to change all dof numbers together or not at all
  if (comp || vig)
    libmesh_assert ((dn == invalid_id && base_idx == invalid_id) ||
                    (dn == base_idx + vig*ncg + comp));
 
  // only explicitly store the base index for vig==0, comp==0
  else
    base_idx = dn;
 
  libmesh_assert_equal_to (this->dof_number(s, var, comp), dn);
}

References libMesh::DofObject::_idx_buf, libMesh::DofObject::dof_number(), libMesh::DofObject::invalid_id, libMesh::libmesh_assert(), libMesh::DofObject::n_comp(), libMesh::DofObject::n_comp_group(), libMesh::DofObject::n_systems(), n_vars, libMesh::DofObject::start_idx(), libMesh::DofObject::system_var_to_vg_var(), and libMesh::DofObject::var_to_vg().

◆ set_extra_datum()

template<typename T >

void libMesh::DofObject::set_extra_datum	(	const unsigned int	index,
		const T	value
	)

inlineinherited

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

Definition at line 1116 of file dof_object.h.

{
#ifndef NDEBUG
  const unsigned int n_more_integers = (sizeof(T)-1)/sizeof(dof_id_type);
#endif
  libmesh_assert_less(index+n_more_integers, this->n_extra_integers());
  libmesh_assert_less(this->n_pseudo_systems(), _idx_buf.size());
 
  const unsigned int start_idx_i = this->start_idx_ints();
 
  libmesh_assert_less(start_idx_i+index+n_more_integers, _idx_buf.size());
  std::memcpy(&_idx_buf[start_idx_i+index], &value, sizeof(T));
}

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

Referenced by libMesh::MeshTools::Modification::all_rbb(), libMesh::ExodusII_IO::read(), libMesh::DynaIO::read_mesh(), RationalMapTest< elem_type >::setUp(), FETestBase< order, family, elem_type, build_nx, CaseName >::setUp(), and DofObjectTest< DerivedClass >::testAddExtraData().

◆ set_extra_integer()

void libMesh::DofObject::set_extra_integer	(	const unsigned int	index,
		const dof_id_type	value
	)

inlineinherited

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

Definition at line 1076 of file dof_object.h.

{
  libmesh_assert_less(index, this->n_extra_integers());
  libmesh_assert_less(this->n_pseudo_systems(), _idx_buf.size());
 
  const unsigned int start_idx_i = this->start_idx_ints();
 
  libmesh_assert_less(start_idx_i+index, _idx_buf.size());
  _idx_buf[start_idx_i+index] = value;
}

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

Referenced by libMesh::SyncElementIntegers::act_on_data(), libMesh::BoundaryInfo::add_elements(), libMesh::UnstructuredMesh::all_first_order(), libMesh::UnstructuredMesh::create_submesh(), libMesh::ExodusII_IO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::CheckpointIO::read_nodes(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::Elem::refine(), DofObjectTest< DerivedClass >::testAddExtraData(), DofObjectTest< DerivedClass >::testAddSystemExtraInts(), DofObjectTest< DerivedClass >::testSetNSystemsExtraInts(), and DofObjectTest< DerivedClass >::testSetNVariableGroupsExtraInts().

◆ set_id() [1/2]

dof_id_type & libMesh::DofObject::set_id ( )

inlineinherited

Returns: The id for this DofObject as a writable reference.

Definition at line 841 of file dof_object.h.

{
  return _id;
}

References libMesh::DofObject::_id.

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

◆ set_id() [2/2]

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

inlineinherited

Sets the id for this DofObject.

Definition at line 192 of file dof_object.h.

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

References libMesh::DofObject::set_id().

◆ set_interior_parent()

void libMesh::Elem::set_interior_parent ( Elem * p )

inherited

Sets the pointer to the element's interior_parent.

Dangerous! Only use this if you know what you are doing!

Definition at line 1162 of file elem.C.

{
  // interior parents make no sense for full-dimensional elements.
  libmesh_assert (!p ||
                  this->dim() < LIBMESH_DIM);
 
  // If we have an interior_parent, we USED TO assume it was a
  // one-higher-dimensional interior element, but we now allow e.g.
  // edge elements to have a 3D interior_parent with no
  // intermediate 2D element.
  // libmesh_assert (!p ||
  //                 p->dim() == (this->dim()+1));
  libmesh_assert (!p ||
                  (p == remote_elem) ||
                  (p->dim() > this->dim()));
 
  _elemlinks[1+this->n_sides()] = p;
}

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

Referenced by libMesh::BoundaryInfo::add_elements(), Edge(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::Hex::Hex(), libMesh::InfHex::InfHex(), libMesh::InfQuad::InfQuad(), libMesh::NodeElem::NodeElem(), libMesh::Polygon::Polygon(), libMesh::Polyhedron::Polyhedron(), libMesh::Prism::Prism(), libMesh::Pyramid::Pyramid(), libMesh::Quad::Quad(), libMesh::Tet::Tet(), libMesh::Tri::Tri(), libMesh::Parallel::Packing< Elem * >::unpack(), and libMesh::MeshTetInterface::volume_to_surface_mesh().

◆ set_mapping_data()

void libMesh::Elem::set_mapping_data ( const unsigned char data )

inlineinherited

Sets the value of the mapping data for the element.

Definition at line 3282 of file elem.h.

{
  _map_data = data;
}

References libMesh::Elem::_map_data.

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

◆ set_mapping_type()

void libMesh::Elem::set_mapping_type ( const ElemMappingType type )

inlineinherited

Sets the value of the mapping type for the element.

Definition at line 3266 of file elem.h.

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

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

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

◆ set_n_comp()

void libMesh::DofObject::set_n_comp	(	const unsigned int	s,
		const unsigned int	var,
		const unsigned int	ncomp
	)

inherited

Sets the number of components for Variable var of system s associated with this DofObject.

Definition at line 377 of file dof_object.C.

{
  libmesh_assert_less (s,   this->n_systems());
  libmesh_assert_less (var, this->n_vars(s));
 
  this->set_n_comp_group(s, this->var_to_vg(s,var), ncomp);
}

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

◆ set_n_comp_group()

void libMesh::DofObject::set_n_comp_group	(	const unsigned int	s,
		const unsigned int	vg,
		const unsigned int	ncomp
	)

inherited

Sets the number of components for VariableGroup vg of system s associated with this DofObject.

Definition at line 389 of file dof_object.C.

{
  libmesh_assert_less (s,  this->n_systems());
  libmesh_assert_less (vg, this->n_var_groups(s));
 
  // Check for trivial return
  if (ncomp == this->n_comp_group(s,vg)) return;
 
#ifndef NDEBUG
  if (index_t(ncomp) >= ncv_magic)
    {
      const index_t ncvm = ncv_magic;
      libmesh_error_msg("ERROR: ncomp must be less than DofObject::ncv_magic!\n" \
                        << "ncomp = "                                   \
                        << ncomp                                \
                        << ", ncv_magic = "                     \
                        << ncvm                                 \
                        << "\nrecompile and try again!");
    }
#endif
 
  const unsigned int
    start_idx_sys = this->start_idx(s),
    n_vars_group  = this->n_vars(s,vg),
    base_offset   = start_idx_sys + 2*vg;
 
  libmesh_assert_less ((base_offset + 1), _idx_buf.size());
 
  // if (ncomp)
  //   libMesh::out << "s,vg,ncomp="
  //       << s  << ","
  //       << vg << ","
  //       << ncomp << '\n';
 
  // set the number of components, maintaining the number
  // of variables in the group
  _idx_buf[base_offset] = ncv_magic*n_vars_group + ncomp;
 
  // We use (invalid_id - 1) to signify no
  // components for this object
  _idx_buf[base_offset + 1] = (ncomp == 0) ? invalid_id - 1 : invalid_id;
 
  // this->debug_buffer();
  // libMesh::out << "s,vg = " << s << "," << vg << '\n'
  //     << "base_offset=" << base_offset << '\n'
  //     << "this->n_comp(s,vg)=" << this->n_comp(s,vg) << '\n'
  //     << "this->n_comp_group(s,vg)=" << this->n_comp_group(s,vg) << '\n'
  //     << "this->n_vars(s,vg)=" << this->n_vars(s,vg) << '\n'
  //     << "this->n_var_groups(s)=" << this->n_var_groups(s) << '\n';
 
  libmesh_assert_equal_to (ncomp, this->n_comp_group(s,vg));
}

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

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

◆ set_n_systems()

void libMesh::DofObject::set_n_systems ( const unsigned int s )

inherited

Sets the number of systems for this DofObject.

If this number is a change, also clears all variable count and DoF indexing associated with this DofObject.

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

Definition at line 142 of file dof_object.C.

{
  const unsigned int old_ns = this->n_systems();
 
  // Check for trivial return
  if (ns == old_ns)
    return;
 
  const unsigned int nei = this->n_extra_integers();
  const dof_id_type header_size = ns + bool(nei);
  const dof_id_type hdr = nei ?
    static_cast<dof_id_type>(-static_cast<std::ptrdiff_t>(header_size))
    : header_size;
  index_buffer_t new_buf(header_size + nei, hdr);
  if (nei)
    {
      const unsigned int start_idx_ints = old_ns ?
        cast_int<unsigned int>(_idx_buf[old_ns]) :
        1;
      libmesh_assert_less(start_idx_ints, _idx_buf.size());
      std::copy(_idx_buf.begin()+start_idx_ints,
                _idx_buf.end(),
                new_buf.begin()+header_size);
      if (ns)
        std::fill(new_buf.begin()+1, new_buf.begin()+ns+1, ns+1);
    }
 
  // vector swap trick to force deallocation when shrinking
  new_buf.swap(_idx_buf);
 
#ifdef DEBUG
  libmesh_assert_equal_to(nei, this->n_extra_integers());
 
  // check that all systems now exist and that they have 0 size
  libmesh_assert_equal_to (ns, this->n_systems());
  for (auto s : make_range(this->n_systems()))
    {
      libmesh_assert_equal_to (this->n_vars(s),       0);
      libmesh_assert_equal_to (this->n_var_groups(s), 0);
    }
#endif
}

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

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

◆ set_n_vars_per_group()

void libMesh::DofObject::set_n_vars_per_group	(	const unsigned int	s,
		const std::vector< unsigned int > &	nvpg
	)

inherited

Sets number of variables in each group associated with system s for this DofObject.

Implicit in this is also setting the number of VariableGroup variable groups for the system. Has the effect of setting the number of components to 0 even when called even with (nvg == this->n_var_groups(s)).

Definition at line 239 of file dof_object.C.

{
  const unsigned int n_sys = this->n_systems();
 
  libmesh_assert_less (s, n_sys);
 
  // number of variable groups for this system - inferred
  const unsigned int nvg = cast_int<unsigned int>(nvpg.size());
 
  // BSK - note that for compatibility with the previous implementation
  // calling this method when (nvars == this->n_vars()) requires that
  // we invalidate the DOF indices and set the number of components to 0.
  // Note this was a bit of a surprise to me - there was no quick return in
  // the old method, which caused removal and readdition of the DOF indices
  // even in the case of (nvars == this->n_vars()), resulting in n_comp(s,v)
  // implicitly becoming 0 regardless of any previous value.
  // quick return?
  if (nvg == this->n_var_groups(s))
    {
      for (unsigned int vg=0; vg<nvg; vg++)
        {
          this->set_n_comp_group(s,vg,0);
          libmesh_assert_equal_to (this->n_vars(s,vg), nvpg[vg]);
        }
      return;
    }
 
  const bool hei = this->has_extra_integers();
 
  // since there is ample opportunity to screw up other systems, let us
  // cache their current sizes and later assert that they are unchanged.
#ifdef DEBUG
  const unsigned int nei = this->n_extra_integers();
 
  DofObject::index_buffer_t old_system_sizes, old_extra_integers;
  old_system_sizes.reserve(n_sys);
  old_extra_integers.reserve(nei);
 
  for (unsigned int s_ctr=0; s_ctr<n_sys; s_ctr++)
    old_system_sizes.push_back(this->n_var_groups(s_ctr));
 
  for (unsigned int ei=0; ei != nei; ++ei)
    old_extra_integers.push_back(this->get_extra_integer(ei));
#endif
 
  // remove current indices if we have some
  if (this->n_var_groups(s) != 0)
    {
      const unsigned int old_nvg_s = this->n_var_groups(s);
 
      DofObject::index_buffer_t::iterator
        it  = _idx_buf.begin(),
        end = _idx_buf.begin();
 
      std::advance(it,  this->start_idx(s));
      std::advance(end, this->end_idx(s));
      _idx_buf.erase(it,end);
 
      for (unsigned int ctr=(s+1); ctr<n_sys; ctr++)
        _idx_buf[ctr] -= 2*old_nvg_s;
 
      if (hei)
        _idx_buf[n_sys] -= 2*old_nvg_s;
    }
 
  // better not have any now!
  libmesh_assert_equal_to (this->n_var_groups(s), 0);
 
  // Make sure we didn't screw up any of our sizes!
#ifdef DEBUG
  for (auto s_ctr : make_range(this->n_systems()))
    if (s_ctr != s)
      libmesh_assert_equal_to (this->n_var_groups(s_ctr), old_system_sizes[s_ctr]);
 
  libmesh_assert_equal_to (nei, this->n_extra_integers());
 
  for (unsigned int ei=0; ei != nei; ++ei)
    libmesh_assert_equal_to(old_extra_integers[ei], this->get_extra_integer(ei));
#endif
 
  // OK, if the user requested 0 that is what we have
  if (nvg == 0)
    return;
 
  {
    // array to hold new indices
    DofObject::index_buffer_t var_idxs(2*nvg);
    for (unsigned int vg=0; vg<nvg; vg++)
      {
        var_idxs[2*vg    ] = ncv_magic*nvpg[vg] + 0;
        var_idxs[2*vg + 1] = invalid_id - 1;
      }
 
    DofObject::index_buffer_t::iterator it = _idx_buf.begin();
    std::advance(it, this->end_idx(s));
    _idx_buf.insert(it, var_idxs.begin(), var_idxs.end());
 
    for (unsigned int ctr=(s+1); ctr<n_sys; ctr++)
      _idx_buf[ctr] += 2*nvg;
 
    if (hei)
      _idx_buf[n_sys] += 2*nvg;
 
    // resize _idx_buf to fit so no memory is wasted.
    DofObject::index_buffer_t(_idx_buf).swap(_idx_buf);
  }
 
  libmesh_assert_equal_to (nvg, this->n_var_groups(s));
 
#ifdef DEBUG
 
  libmesh_assert_equal_to (this->n_var_groups(s), nvpg.size());
 
  for (auto vg : make_range(this->n_var_groups(s)))
    {
      libmesh_assert_equal_to (this->n_vars(s,vg), nvpg[vg]);
      libmesh_assert_equal_to (this->n_comp_group(s,vg), 0);
    }
 
  for (auto v : make_range(this->n_vars(s)))
    libmesh_assert_equal_to (this->n_comp(s,v), 0);
 
  // again, all other system sizes should be unchanged!
  for (auto s_ctr : make_range(this->n_systems()))
    if (s_ctr != s)
      libmesh_assert_equal_to (this->n_var_groups(s_ctr), old_system_sizes[s_ctr]);
 
  // Extra integers count and values should also be unchanged!
  libmesh_assert_equal_to (nei, this->n_extra_integers());
 
  for (unsigned int ei=0; ei != nei; ++ei)
    libmesh_assert_equal_to(old_extra_integers[ei], this->get_extra_integer(ei));
#endif
}

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

◆ set_neighbor()

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

inlineinherited

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

Definition at line 2756 of file elem.h.

{
  libmesh_assert_less (i, this->n_neighbors());
 
  _elemlinks[i+1] = n;
}

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

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

◆ set_node() [1/2]

Node *& libMesh::Elem::set_node ( const unsigned int i )

inlinevirtualinherited

Returns: The pointer to the Node with local number i as a writable reference.

Deprecated:: This setter cannot update the multiple node pointers used in a general polyhedron; use the set_node overload that takes an argument.

Reimplemented in libMesh::RemoteElem.

Definition at line 2688 of file elem.h.

{
  libmesh_assert_less (i, this->n_nodes());
 
  libmesh_deprecated();
 
  return _nodes[i];
}

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

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

◆ set_node() [2/2]

void libMesh::Elem::set_node	(	const unsigned int	i,
		Node *	node
	)

inlinevirtualinherited

Sets local Node i to refer to node.

Reimplemented in libMesh::RemoteElem.

Definition at line 2701 of file elem.h.

{
  libmesh_assert_less (i, this->n_nodes());
 
  _nodes[i] = node;
}

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

◆ set_old_dof_object()

void libMesh::DofObject::set_old_dof_object ( )

inherited

Sets the old_dof_object to a copy of this.

Definition at line 127 of file dof_object.C.

{
  this->clear_old_dof_object();
 
  libmesh_assert (!this->old_dof_object);
 
  // Make a new DofObject, assign a copy of \p this.
  // Make sure the copy ctor for DofObject works!!
  this->old_dof_object = this->construct(this);
}

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

◆ set_p_level()

void libMesh::Elem::set_p_level ( const unsigned int p )

inherited

Sets the value of the p-refinement level for the element.

The following functions only apply when AMR is enabled and thus are not present otherwise.

Note: The maximum p-refinement level is currently 255.

Definition at line 41 of file elem_refinement.C.

{
  // Maintain the parent's p level as the minimum of it's children
  if (this->parent() != nullptr)
    {
      unsigned int parent_p_level = this->parent()->p_level();
 
      // If our new p level is less than our parents, our parents drops
      if (parent_p_level > p)
        {
          this->parent()->set_p_level(p);
 
          // And we should keep track of the drop, in case we need to
          // do a projection later.
          this->parent()->set_p_refinement_flag(Elem::JUST_COARSENED);
        }
      // If we are the lowest p level and it increases, so might
      // our parent's, but we have to check every other child to see
      else if (parent_p_level == _p_level && _p_level < p)
        {
          _p_level = cast_int<unsigned char>(p);
          parent_p_level = cast_int<unsigned char>(p);
          for (auto & c : this->parent()->child_ref_range())
            parent_p_level = std::min(parent_p_level,
                                      c.p_level());
 
          // When its children all have a higher p level, the parent's
          // should rise
          if (parent_p_level > this->parent()->p_level())
            {
              this->parent()->set_p_level(parent_p_level);
 
              // And we should keep track of the rise, in case we need to
              // do a projection later.
              this->parent()->set_p_refinement_flag(Elem::JUST_REFINED);
            }
 
          return;
        }
    }
 
  this->hack_p_level(p);
}

References libMesh::Elem::_p_level, libMesh::Elem::child_ref_range(), libMesh::Elem::hack_p_level(), libMesh::Elem::JUST_COARSENED, libMesh::Elem::JUST_REFINED, libMesh::Elem::p_level(), libMesh::Elem::parent(), libMesh::Elem::set_p_level(), and libMesh::Elem::set_p_refinement_flag().

Referenced by libMesh::UnstructuredMesh::all_first_order(), libMesh::Elem::coarsen(), libMesh::Elem::Elem(), libMesh::Elem::inherit_data_from(), libMesh::Polygon::Polygon(), libMesh::Polyhedron::Polyhedron(), libMesh::Elem::refine(), libMesh::Elem::set_p_level(), VolumeTest::testHex20PLevelTrueCentroid(), and libMesh::Parallel::Packing< Elem * >::unpack().

◆ set_p_refinement_flag()

void libMesh::Elem::set_p_refinement_flag ( const RefinementState pflag )

inlineinherited

Sets the value of the p-refinement flag for the element.

Definition at line 3372 of file elem.h.

{
  if (this->p_level() == 0)
    libmesh_assert_not_equal_to
      (pflag, Elem::JUST_REFINED);
 
  _pflag = cast_int<unsigned char>(pflag);
}

References libMesh::Elem::_pflag, libMesh::Elem::JUST_REFINED, and libMesh::Elem::p_level().

Referenced by libMesh::BoundaryInfo::add_elements(), libMesh::UnstructuredMesh::all_first_order(), libMesh::MeshRefinement::enforce_mismatch_limit_prior_to_refinement(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::Elem::refine(), libMesh::Elem::set_p_level(), and libMesh::Parallel::Packing< Elem * >::unpack().

◆ set_parent()

void libMesh::Elem::set_parent ( Elem * p )

inlineinherited

Sets the pointer to the element's parent.

Dangerous! Only use this if you know what you are doing!

Definition at line 3184 of file elem.h.

{
  // We no longer support using parent() as interior_parent()
  libmesh_assert_equal_to(this->dim(), p ? p->dim() : this->dim());
  _elemlinks[0] = p;
}

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

Referenced by libMesh::BoundaryInfo::add_elements(), and libMesh::UnstructuredMesh::all_first_order().

◆ set_refinement_flag()

void libMesh::Elem::set_refinement_flag ( const RefinementState rflag )

inlineinherited

Sets the value of the refinement flag for the element.

Definition at line 3356 of file elem.h.

{
  _rflag = cast_int<unsigned char>(rflag);
}

References libMesh::Elem::_rflag.

Referenced by libMesh::BoundaryInfo::add_elements(), libMesh::UnstructuredMesh::all_first_order(), libMesh::Elem::coarsen(), libMesh::Elem::contract(), libMesh::MeshRefinement::enforce_mismatch_limit_prior_to_refinement(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), main(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::Elem::refine(), InfFERadialTest::testRefinement(), EquationSystemsTest::testRefineThenReinitPreserveFlags(), EquationSystemsTest::testSelectivePRefine(), libMesh::MeshRefinement::uniformly_coarsen(), and libMesh::Parallel::Packing< Elem * >::unpack().

◆ set_unique_id()

void libMesh::DofObject::set_unique_id ( unique_id_type new_id )

inlineinherited

Sets the unique_id for this DofObject.

Definition at line 862 of file dof_object.h.

{
#ifdef LIBMESH_ENABLE_UNIQUE_ID
  _unique_id = new_id;
#else
  libmesh_ignore(new_id);
  libmesh_not_implemented();
#endif
}

References libMesh::DofObject::_unique_id, and libMesh::libmesh_ignore().

Referenced by libMesh::DistributedMesh::add_elem(), libMesh::ReplicatedMesh::add_elem(), libMesh::DistributedMesh::add_node(), libMesh::ReplicatedMesh::add_node(), libMesh::ReplicatedMesh::add_point(), libMesh::UnstructuredMesh::all_first_order(), libMesh::UnstructuredMesh::create_submesh(), libMesh::DistributedMesh::insert_elem(), libMesh::ReplicatedMesh::insert_elem(), MeshPerElemTest< elem_type >::meshes_equal_enough(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read_nodes(), libMesh::XdrIO::read_serialized_nodes(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::ExodusII_IO_Helper::set_dof_object_unique_id(), libMesh::Parallel::Packing< Elem * >::unpack(), and libMesh::MeshTetInterface::volume_to_surface_mesh().

◆ set_vg_dof_base()

void libMesh::DofObject::set_vg_dof_base	(	const unsigned int	s,
		const unsigned int	vg,
		const dof_id_type	db
	)

inlineinherited

VariableGroup DoF indices are indexed as id = base + var_in_vg*ncomp + comp This method allows for direct access to the base.

Definition at line 1287 of file dof_object.h.

{
  libmesh_assert_less (s,  this->n_systems());
  libmesh_assert_less (vg, this->n_var_groups(s));
 
  const unsigned int
    start_idx_sys = this->start_idx(s);
 
  libmesh_assert_less ((start_idx_sys + 2*vg + 1), _idx_buf.size());
 
  _idx_buf[start_idx_sys + 2*vg + 1] = db;
 
  libmesh_assert_equal_to (this->vg_dof_base(s,vg), db);
}

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

Referenced by libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DofObject::invalidate_dofs(), libMesh::DofMap::set_nonlocal_dof_objects(), and DofObjectTest< DerivedClass >::testManualDofCalculation().

◆ side_children_matrix()

unsigned int libMesh::Edge::side_children_matrix	(	const unsigned int	,
		const unsigned int
	)		const

inlineprotected

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

{
  return {0, cast_int<unsigned short>(this->n_sides())};
}

References libMesh::Elem::n_sides().

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::MeshTools::Subdivision::add_boundary_ghosts(), libMesh::BoundaryInfo::add_elements(), libMesh::MeshTools::Modification::all_rbb(), libMesh::MeshTools::Modification::all_tri(), assemble_advection_diffusion(), MeshBaseTest::BrokenNeighborMesh(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_side_list_from_node_list(), libMesh::MeshTetInterface::check_hull_integrity(), MeshInputTest::checkHexPrismPolyhedron(), libMesh::FEGenericBase< OutputType >::coarsened_dof_values(), compute_enriched_soln(), libMesh::FEAbstract::compute_node_constraints(), libMesh::FEAbstract::compute_periodic_node_constraints(), libMesh::FEGenericBase< OutputType >::compute_proj_constraints(), libMesh::BoundaryInfo::copy_boundary_ids(), libMesh::BoundaryInfo::edge_boundary_ids(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::MeshTools::Modification::flatten(), libMesh::ReplicatedMesh::get_disconnected_subdomains(), libMesh::Elem::get_info(), libMesh::VariationalSmootherConstraint::get_neighbors_for_boundary_constraint(), libMesh::VariationalSmootherConstraint::get_neighbors_for_subdomain_constraint(), libMesh::BoundaryInfo::get_side_and_node_maps(), libMesh::Elem::has_topological_neighbor(), libMesh::MeshTetInterface::improve_hull_integrity(), libMesh::InfFE< Dim, T_radial, T_map >::inf_compute_constraints(), libMesh::InfFE< Dim, T_radial, T_map >::inf_compute_node_constraints(), libMesh::LaplaceMeshSmoother::init(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::MeshTools::Modification::interpolate_surface(), libMesh::Elem::libmesh_assert_valid_neighbors(), libMesh::VariationalSmootherConstraint::nodes_share_boundary_id(), libMesh::Elem::nullify_neighbors(), libMesh::PostscriptIO::plot_quadratic_elem(), libMesh::Elem::refine(), libMesh::MeshTools::Modification::smooth(), libMesh::UnstructuredMesh::stitching_helper(), ExodusC0PolyhedronTest::test_write_and_read_hexagonal_prism(), libMesh::Parallel::Packing< Elem * >::unpack(), libMesh::MeshTetInterface::volume_to_surface_mesh(), libMesh::ExodusII_IO_Helper::write_elements(), and libMesh::ExodusII_IO_Helper::write_nodal_coordinates().

◆ side_ptr() [1/4]

std::unique_ptr< Elem > libMesh::Edge::side_ptr ( const unsigned int i )

finaloverridevirtual

Returns: A pointer to a NodeElem for the specified node.

Implements libMesh::Elem.

Definition at line 56 of file edge.C.

{
  libmesh_assert_less (i, 2);
  std::unique_ptr<Elem> nodeelem = std::make_unique<NodeElem>();
  nodeelem->set_node(0, this->node_ptr(i));
 
  nodeelem->set_interior_parent(this);
  nodeelem->inherit_data_from(*this);
 
  return nodeelem;
}

References libMesh::Elem::node_ptr().

◆ side_ptr() [2/4]

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

inlineinherited

Definition at line 2869 of file elem.h.

{
  // Hand off to the non-const version of this function
  Elem * me = const_cast<Elem *>(this);
  std::unique_ptr<Elem> e {const_cast<Elem *>(elem.release())};
  me->side_ptr(e, i);
  elem = std::move(e);
}

References libMesh::Elem::side_ptr().

◆ side_ptr() [3/4]

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

finaloverridevirtual

Rebuilds a pointer to a NodeElem for the specified node.

Implements libMesh::Elem.

Definition at line 69 of file edge.C.

{
  libmesh_assert_less (i, this->n_sides());
 
  if (!side.get() || side->type() != NODEELEM)
    side = this->build_side_ptr(i);
  else
    {
      side->inherit_data_from(*this);
      side->set_node(0, this->node_ptr(i));
    }
}

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

◆ side_ptr() [4/4]

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

inlineinherited

Definition at line 2857 of file elem.h.

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

References libMesh::Elem::side_ptr().

◆ side_type() [1/2]

ElemType libMesh::Elem::side_type	(	const ElemType	t,
		const unsigned int	s
	)

staticinherited

Returns: The type of side s of an element of type t, without needing an instantiated Elem. The Polygon and Polyhedron subclasses have one side type but no fixed number of sides, so s goes unchecked for them; query an actual Elem when you have one.

Definition at line 3275 of file elem.C.

{
  libmesh_assert_less (s, type_to_n_sides_map[t]);
 
  switch (t)
    {
    case EDGE2:
    case EDGE3:
    case EDGE4:
      return NODEELEM;
    case TRI3:
    case TRISHELL3:
    case QUAD4:
    case QUADSHELL4:
      // A polygon's sides are all edges and a polyhedron's are all
      // polygons, however many a given element turns out to have
    case C0POLYGON:
      return EDGE2;
    case TRI6:
    case TRI7:
    case QUAD8:
    case QUADSHELL8:
    case QUAD9:
    case QUADSHELL9:
      return EDGE3;
    case TET4:
      return TRI3;
    case TET10:
      return TRI6;
    case TET14:
      return TRI7;
    case HEX8:
      return QUAD4;
    case HEX20:
      return QUAD8;
    case HEX27:
      return QUAD9;
      // Sides 0 and 4 of a prism are its triangles
    case PRISM6:
      return (s == 0 || s == 4) ? TRI3 : QUAD4;
    case PRISM15:
      return (s == 0 || s == 4) ? TRI6 : QUAD8;
    case PRISM18:
      return (s == 0 || s == 4) ? TRI6 : QUAD9;
    case PRISM20:
    case PRISM21:
      return (s == 0 || s == 4) ? TRI7 : QUAD9;
      // Side 4 of a pyramid is its quadrilateral base
    case PYRAMID5:
      return (s < 4) ? TRI3 : QUAD4;
    case PYRAMID13:
      return (s < 4) ? TRI6 : QUAD8;
    case PYRAMID14:
      return (s < 4) ? TRI6 : QUAD9;
    case PYRAMID18:
      return (s < 4) ? TRI7 : QUAD9;
    case C0POLYHEDRON:
      return C0POLYGON;
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
      // An InfEdge2's sides are its end nodes, like any other 1D element's
    case INFEDGE2:
      return NODEELEM;
      // A 2D or 3D infinite element's side 0 is the finite base it was
      // built from; its remaining sides run out to infinity with it
    case INFQUAD4:
      return (s == 0) ? EDGE2 : INFEDGE2;
    case INFQUAD6:
      return (s == 0) ? EDGE3 : INFEDGE2;
    case INFHEX8:
      return (s == 0) ? QUAD4 : INFQUAD4;
    case INFHEX16:
      return (s == 0) ? QUAD8 : INFQUAD6;
    case INFHEX18:
      return (s == 0) ? QUAD9 : INFQUAD6;
    case INFPRISM6:
      return (s == 0) ? TRI3 : INFQUAD4;
    case INFPRISM12:
      return (s == 0) ? TRI6 : INFQUAD6;
#endif
    default:
      libmesh_error_msg("No side type for element type " << Utility::enum_to_string(t));
    }
 
  return INVALID_ELEM;
}

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::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, libMesh::TRISHELL3, and libMesh::Elem::type_to_n_sides_map.

◆ side_type() [2/2]

ElemType libMesh::Edge::side_type ( const unsigned int s ) const

finaloverridevirtual

Returns: The type of element for side s.

Implements libMesh::Elem.

Definition at line 165 of file edge.C.

{
  libmesh_assert_less (s, 2);
  return NODEELEM;
}

References libMesh::NODEELEM.

◆ side_vertex_average_normal()

Point libMesh::Elem::side_vertex_average_normal ( const unsigned int s ) const

virtualinherited

Returns: the normal (outwards-facing) of the side of the element at the vertex-average of the side

Parameters

s	the side of interest

Reimplemented in libMesh::C0Polyhedron, libMesh::Hex8, libMesh::Prism6, libMesh::Pyramid5, libMesh::Tet4, libMesh::Edge2, libMesh::C0Polygon, libMesh::Quad4, and libMesh::Tri3.

Definition at line 3922 of file elem.C.

{
  unsigned int dim = this->dim();
  const std::unique_ptr<const Elem> face = this->build_side_ptr(s);
  std::unique_ptr<libMesh::FEBase> fe(
      libMesh::FEBase::build(dim, libMesh::FEType(this->default_order())));
  fe->add_p_level_in_reinit(false); // Yes, really use the default order
  const std::vector<Point> & normals = fe->get_normals();
  std::vector<Point> ref_side_vertex_average_v = {face->reference_elem()->vertex_average()};
  fe->reinit(this, s, TOLERANCE, &ref_side_vertex_average_v);
  return normals[0];
}

References libMesh::FEGenericBase< OutputType >::build(), libMesh::Elem::build_side_ptr(), libMesh::Elem::default_order(), libMesh::Elem::dim(), and libMesh::TOLERANCE.

Referenced by SideVertexAverageNormalTest::testEdge2(), and SideVertexAverageNormalTest::testEdge3().

◆ sides_on_edge()

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

inlinefinaloverridevirtual

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

{
  libmesh_assert_less (i, this->n_edges());
 
  std::unique_ptr<Elem> edge = std::make_unique<Edgeclass>();
 
  for (auto n : edge->node_index_range())
    edge->set_node(n, this->node_ptr(Subclass::edge_nodes_map[i][n]));
 
  edge->set_interior_parent(this);
  edge->inherit_data_from(*this);
 
  return edge;
}

References libMesh::Elem::n_edges().

◆ simple_build_edge_ptr() [2/2]

template<typename Subclass >

void libMesh::Elem::simple_build_edge_ptr	(	std::unique_ptr< Elem > &	edge,
		const unsigned int	i,
		ElemType	edgetype
	)

inlineprotectedinherited

An implementation for simple (all edges equal) elements.

Definition at line 3025 of file elem.h.

{
  libmesh_assert_less (i, this->n_edges());
 
  if (!edge.get() || edge->type() != edgetype)
    {
      Subclass & real_me = cast_ref<Subclass&>(*this);
      edge = real_me.Subclass::build_edge_ptr(i);
    }
  else
    {
      edge->inherit_data_from(*this);
      for (auto n : edge->node_index_range())
        edge->set_node(n, this->node_ptr(Subclass::edge_nodes_map[i][n]));
    }
}

References libMesh::Elem::n_edges().

◆ simple_build_side_ptr() [1/2]

template<typename Sideclass , typename Subclass >

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

inlineprotectedinherited

An implementation for simple (all sides equal) elements.

Definition at line 2910 of file elem.h.

{
  libmesh_assert_less (i, this->n_sides());
 
  std::unique_ptr<Elem> face = std::make_unique<Sideclass>();
  for (auto n : face->node_index_range())
    face->set_node(n, this->node_ptr(Subclass::side_nodes_map[i][n]));
 
  face->set_interior_parent(this);
  face->inherit_data_from(*this);
 
  return face;
}

References libMesh::Elem::n_sides().

◆ simple_build_side_ptr() [2/2]

template<typename Subclass >

void libMesh::Elem::simple_build_side_ptr	(	std::unique_ptr< Elem > &	side,
		const unsigned int	i,
		ElemType	sidetype
	)

inlineprotectedinherited

An implementation for simple (all sides equal) elements.

Definition at line 2929 of file elem.h.

{
  libmesh_assert_less (i, this->n_sides());
 
  if (!side.get() || side->type() != sidetype)
    {
      Subclass & real_me = cast_ref<Subclass&>(*this);
      side = real_me.Subclass::build_side_ptr(i);
    }
  else
    {
      side->set_interior_parent(this);
      side->inherit_data_from(*this);
      for (auto n : side->node_index_range())
        side->set_node(n, this->node_ptr(Subclass::side_nodes_map[i][n]));
    }
}

References libMesh::Elem::n_sides().

◆ simple_side_ptr()

template<typename Subclass , typename Mapclass >

void libMesh::Elem::simple_side_ptr	(	std::unique_ptr< Elem > &	side,
		const unsigned int	i,
		ElemType	sidetype
	)

inlineprotectedinherited

An implementation for simple (all sides equal) elements.

Definition at line 2954 of file elem.h.

{
  libmesh_assert_less (i, this->n_sides());
 
  if (!side.get() || side->type() != sidetype)
    {
      Subclass & real_me = cast_ref<Subclass&>(*this);
      side = real_me.Subclass::side_ptr(i);
    }
  else
    {
      side->subdomain_id() = this->subdomain_id();
 
      for (auto n : side->node_index_range())
        side->set_node(n, this->node_ptr(Mapclass::side_nodes_map[i][n]));
    }
}

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

◆ start_idx()

unsigned int libMesh::DofObject::start_idx ( const unsigned int s ) const

inlineprivateinherited

The starting index for system s.

Definition at line 1239 of file dof_object.h.

{
  libmesh_assert_less (s, this->n_systems());
  libmesh_assert_less (s, _idx_buf.size());
 
  return cast_int<unsigned int>(std::abs(dof_id_signed_type(_idx_buf[s])));
}

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

Referenced by libMesh::DofObject::dof_number(), libMesh::DofObject::n_comp_group(), libMesh::DofObject::n_var_groups(), libMesh::DofObject::n_vars(), libMesh::DofObject::set_dof_number(), libMesh::DofObject::set_n_comp_group(), libMesh::DofObject::set_n_vars_per_group(), libMesh::DofObject::set_vg_dof_base(), and libMesh::DofObject::vg_dof_base().

◆ start_idx_ints()

unsigned int libMesh::DofObject::start_idx_ints ( ) const

inlineprivateinherited

The starting index for an extra_integers pseudosystem.

Definition at line 1263 of file dof_object.h.

{
  libmesh_assert (this->has_extra_integers());
 
  unsigned int n_sys = this->n_systems();
 
  libmesh_assert_less(this->n_systems(), _idx_buf.size());
  return n_sys ? cast_int<unsigned int>(_idx_buf[this->n_systems()]) :
                 (n_sys+1);
}

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

Referenced by libMesh::DofObject::get_extra_datum(), libMesh::DofObject::get_extra_integer(), libMesh::DofObject::n_extra_integers(), libMesh::DofObject::set_extra_datum(), libMesh::DofObject::set_extra_integer(), and libMesh::DofObject::set_n_systems().

◆ subactive()

bool libMesh::Elem::subactive ( ) const

inlineinherited

Returns: true if the element is subactive (i.e. has no active descendants), false otherwise or if AMR is disabled.

Definition at line 3097 of file elem.h.

{
#ifdef LIBMESH_ENABLE_AMR
  if (this->active())
    return false;
  if (!this->has_children())
    return true;
  for (const Elem * my_ancestor = this->parent();
       my_ancestor != nullptr;
       my_ancestor = my_ancestor->parent())
    if (my_ancestor->active())
      return true;
#endif
 
  return false;
}

References libMesh::Elem::active(), libMesh::Elem::has_children(), and libMesh::Elem::parent().

Referenced by libMesh::HPCoarsenTest::add_projection(), libMesh::Elem::ancestor(), libMesh::FEAbstract::compute_node_constraints(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::Elem::get_info(), libMesh::InfFE< Dim, T_radial, T_map >::inf_compute_constraints(), libMesh::InfFE< Dim, T_radial, T_map >::inf_compute_node_constraints(), libMesh::Elem::libmesh_assert_valid_neighbors(), libMesh::Elem::make_links_to_me_local(), libMesh::Elem::max_descendant_p_level(), libMesh::Elem::min_new_p_level_by_neighbor(), libMesh::Elem::min_p_level_by_neighbor(), libMesh::Elem::refine(), libMesh::UnstructuredMesh::stitching_helper(), ElemTest< elem_type >::test_n_refinements(), and libMesh::Parallel::Packing< Elem * >::unpack().

◆ subdomain_id() [1/2]

subdomain_id_type & libMesh::Elem::subdomain_id ( )

inlineinherited

Returns: The subdomain that this element belongs to as a writable reference.

Definition at line 2720 of file elem.h.

{
  return _sbd_id;
}

References libMesh::Elem::_sbd_id.

◆ subdomain_id() [2/2]

subdomain_id_type libMesh::Elem::subdomain_id ( ) const

inlineinherited

Returns: The subdomain that this element belongs to.

Definition at line 2712 of file elem.h.

{
  return _sbd_id;
}

References libMesh::Elem::_sbd_id.

Referenced by libMesh::DofMap::_dof_indices(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::SyncSubdomainIds::act_on_data(), LinearElasticityWithContact::add_contact_edge_elements(), libMesh::BoundaryInfo::add_elements(), libMesh::MeshTools::Modification::all_tri(), AllSecondOrderTest::allCompleteOrderRange(), AllSecondOrderTest::allSecondOrderRange(), libMesh::AbaqusIO::assign_subdomain_ids(), ExodusC0PolyhedronTest::build_c0polyhedron(), libMesh::EquationSystems::build_discontinuous_solution_vector(), MixedDimensionMeshTest::build_mesh(), MixedDimensionNonUniformRefinement::build_mesh(), MixedDimensionNonUniformRefinementTriangle::build_mesh(), MixedDimensionNonUniformRefinement3D::build_mesh(), ExodusC0PolygonTest::build_pentagon(), OverlappingTestBase::build_quad_mesh(), libMesh::BoundaryInfo::build_side_list_from_node_list(), libMesh::InfQuad6::build_side_ptr(), libMesh::FEGenericBase< OutputType >::compute_proj_constraints(), libMesh::TriangleWrapper::copy_tri_to_mesh(), libMesh::DofMap::dof_indices(), libMesh::DofMap::dof_indices(), libMesh::Elem::Elem(), libMesh::TetGenIO::element_in(), HilbertSystem::element_time_derivative(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::find_dofs_to_send(), libMesh::MeshTools::Modification::flatten(), libMesh::SyncSubdomainIds::gather_data(), libMesh::Elem::get_info(), libMesh::VariationalSmootherConstraint::get_neighbors_for_subdomain_constraint(), MeshExtruderTest::QueryElemSubdomainID::get_subdomain_for_layer(), libMesh::UNVIO::groups_in(), libMesh::Elem::inherit_data_from(), libMesh::MeshTools::Modification::interpolate_surface(), libMesh::DofMap::old_dof_indices(), libMesh::PointLocatorNanoflann::operator()(), libMesh::PointLocatorNanoflann::operator()(), libMesh::XdrIO::pack_element(), libMesh::Polygon::Polygon(), libMesh::Polyhedron::Polyhedron(), libMesh::CheckpointIO::read_connectivity(), libMesh::DynaIO::read_mesh(), libMesh::GmshIO::read_mesh(), libMesh::Polygon::side_ptr(), libMesh::Pyramid::side_ptr(), libMesh::InfHex::side_ptr(), libMesh::InfPrism::side_ptr(), libMesh::Prism::side_ptr(), libMesh::InfQuad::side_ptr(), libMesh::Elem::simple_side_ptr(), BoundaryInfoTest::testBuildSideListFromNodeListThinMesh(), SystemsTest::testDofCouplingWithVarGroups(), MeshExtruderTest::testExtruder(), MeshBaseTest::testMeshBaseVerifyHasCachedElemData(), SystemsTest::testSetSystemParameterOverEquationSystem(), SystemsTest::tripleValueTest(), libMesh::Parallel::Packing< Elem * >::unpack(), libMesh::ExodusII_IO_Helper::write_element_values(), libMesh::ExodusII_IO_Helper::write_element_values_element_major(), and libMesh::ExodusII_IO_Helper::write_elements().

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

1103{ return default_order(); }

References libMesh::Elem::default_order().

Referenced by libMesh::MeshBase::copy_constraint_rows().

◆ swap2boundaryedges()

void libMesh::Elem::swap2boundaryedges	(	unsigned short	e1,
		unsigned short	e2,
		BoundaryInfo *	boundary_info
	)		const

protectedinherited

Swaps two edges in boundary_info, if it is non-null.

Definition at line 3998 of file elem.C.

{
  std::vector<boundary_id_type> ids1, ids2;
  boundary_info->edge_boundary_ids(this, e1, ids1);
  boundary_info->edge_boundary_ids(this, e2, ids2);
  boundary_info->remove_edge(this, e1);
  boundary_info->remove_edge(this, e2);
  if (!ids1.empty())
    boundary_info->add_edge(this, e2, ids1);
  if (!ids2.empty())
    boundary_info->add_edge(this, e1, ids2);
}

References libMesh::BoundaryInfo::add_edge(), libMesh::BoundaryInfo::edge_boundary_ids(), and libMesh::BoundaryInfo::remove_edge().

Referenced by libMesh::Hex20::flip(), libMesh::Hex27::flip(), libMesh::Hex8::flip(), libMesh::InfHex16::flip(), libMesh::InfHex18::flip(), libMesh::InfHex8::flip(), libMesh::InfPrism12::flip(), libMesh::InfPrism6::flip(), libMesh::Prism15::flip(), libMesh::Prism18::flip(), libMesh::Prism20::flip(), libMesh::Prism21::flip(), libMesh::Prism6::flip(), libMesh::Pyramid13::flip(), libMesh::Pyramid14::flip(), libMesh::Pyramid18::flip(), libMesh::Pyramid5::flip(), libMesh::Tet10::flip(), libMesh::Tet14::flip(), libMesh::Tet4::flip(), libMesh::InfQuad4::flip(), libMesh::InfQuad6::flip(), libMesh::Quad4::flip(), libMesh::Quad8::flip(), libMesh::Quad9::flip(), libMesh::Tri3::flip(), libMesh::Tri6::flip(), and libMesh::Tri7::flip().

◆ swap2boundarysides()

void libMesh::Elem::swap2boundarysides	(	unsigned short	s1,
		unsigned short	s2,
		BoundaryInfo *	boundary_info
	)		const

protectedinherited

Swaps two sides in boundary_info, if it is non-null.

Definition at line 3982 of file elem.C.

{
  std::vector<boundary_id_type> ids1, ids2;
  boundary_info->boundary_ids(this, s1, ids1);
  boundary_info->boundary_ids(this, s2, ids2);
  boundary_info->remove_side(this, s1);
  boundary_info->remove_side(this, s2);
  if (!ids1.empty())
    boundary_info->add_side(this, s2, ids1);
  if (!ids2.empty())
    boundary_info->add_side(this, s1, ids2);
}

References libMesh::BoundaryInfo::add_side(), libMesh::BoundaryInfo::boundary_ids(), and libMesh::BoundaryInfo::remove_side().

Referenced by libMesh::Hex20::flip(), libMesh::Hex27::flip(), libMesh::Hex8::flip(), libMesh::InfHex16::flip(), libMesh::InfHex18::flip(), libMesh::InfHex8::flip(), libMesh::InfPrism12::flip(), libMesh::InfPrism6::flip(), libMesh::Prism15::flip(), libMesh::Prism18::flip(), libMesh::Prism20::flip(), libMesh::Prism21::flip(), libMesh::Prism6::flip(), libMesh::Pyramid13::flip(), libMesh::Pyramid14::flip(), libMesh::Pyramid18::flip(), libMesh::Pyramid5::flip(), libMesh::Tet10::flip(), libMesh::Tet14::flip(), libMesh::Tet4::flip(), libMesh::Edge2::flip(), libMesh::Edge3::flip(), libMesh::Edge4::flip(), libMesh::InfQuad4::flip(), libMesh::InfQuad6::flip(), libMesh::Quad4::flip(), libMesh::Quad8::flip(), libMesh::Quad9::flip(), libMesh::Tri3::flip(), libMesh::Tri6::flip(), and libMesh::Tri7::flip().

◆ swap2neighbors()

void libMesh::Elem::swap2neighbors	(	unsigned int	n1,
		unsigned int	n2
	)

inlineprotectedinherited

Swaps two neighbor_ptrs.

Definition at line 2232 of file elem.h.

  {
    Elem * temp = this->neighbor_ptr(n1);
    this->set_neighbor(n1, this->neighbor_ptr(n2));
    this->set_neighbor(n2, temp);
  }

References libMesh::Elem::neighbor_ptr(), and libMesh::Elem::set_neighbor().

Referenced by libMesh::Hex20::flip(), libMesh::Hex27::flip(), libMesh::Hex8::flip(), libMesh::InfHex16::flip(), libMesh::InfHex18::flip(), libMesh::InfHex8::flip(), libMesh::InfPrism12::flip(), libMesh::InfPrism6::flip(), libMesh::Prism15::flip(), libMesh::Prism18::flip(), libMesh::Prism20::flip(), libMesh::Prism21::flip(), libMesh::Prism6::flip(), libMesh::Pyramid13::flip(), libMesh::Pyramid14::flip(), libMesh::Pyramid18::flip(), libMesh::Pyramid5::flip(), libMesh::Tet10::flip(), libMesh::Tet14::flip(), libMesh::Tet4::flip(), libMesh::Edge2::flip(), libMesh::Edge3::flip(), libMesh::Edge4::flip(), libMesh::InfQuad4::flip(), libMesh::InfQuad6::flip(), libMesh::Quad4::flip(), libMesh::Quad8::flip(), libMesh::Quad9::flip(), libMesh::Tri3::flip(), libMesh::Tri6::flip(), libMesh::Tri7::flip(), libMesh::Hex20::permute(), libMesh::Hex27::permute(), libMesh::Hex8::permute(), libMesh::Prism15::permute(), libMesh::Prism18::permute(), libMesh::Prism20::permute(), libMesh::Prism21::permute(), libMesh::Prism6::permute(), libMesh::Elem::swap3neighbors(), and libMesh::Elem::swap4neighbors().

◆ swap2nodes()

void libMesh::Elem::swap2nodes	(	unsigned int	n1,
		unsigned int	n2
	)

inlineprotectedinherited

Swaps two node_ptrs.

Definition at line 2222 of file elem.h.

  {
    Node * temp = this->node_ptr(n1);
    this->set_node(n1, this->node_ptr(n2));
    this->set_node(n2, temp);
  }

References libMesh::Elem::node_ptr(), and libMesh::Elem::set_node().

Referenced by libMesh::Hex20::flip(), libMesh::Hex27::flip(), libMesh::Hex8::flip(), libMesh::InfHex16::flip(), libMesh::InfHex18::flip(), libMesh::InfHex8::flip(), libMesh::InfPrism12::flip(), libMesh::InfPrism6::flip(), libMesh::Prism15::flip(), libMesh::Prism18::flip(), libMesh::Prism20::flip(), libMesh::Prism21::flip(), libMesh::Prism6::flip(), libMesh::Pyramid13::flip(), libMesh::Pyramid14::flip(), libMesh::Pyramid18::flip(), libMesh::Pyramid5::flip(), libMesh::Tet10::flip(), libMesh::Tet14::flip(), libMesh::Tet4::flip(), libMesh::Edge2::flip(), libMesh::Edge3::flip(), libMesh::Edge4::flip(), libMesh::InfQuad4::flip(), libMesh::InfQuad6::flip(), libMesh::Quad4::flip(), libMesh::Quad8::flip(), libMesh::Quad9::flip(), libMesh::Tri3::flip(), libMesh::Tri6::flip(), libMesh::Tri7::flip(), libMesh::Hex20::permute(), libMesh::Hex27::permute(), libMesh::Hex8::permute(), libMesh::Prism15::permute(), libMesh::Prism18::permute(), libMesh::Prism20::permute(), libMesh::Prism21::permute(), libMesh::Prism6::permute(), libMesh::Elem::swap3nodes(), and libMesh::Elem::swap4nodes().

◆ swap3neighbors()

void libMesh::Elem::swap3neighbors	(	unsigned int	n1,
		unsigned int	n2,
		unsigned int	n3
	)

inlineprotectedinherited

Swaps three neighbor_ptrs, "rotating" them.

Definition at line 2263 of file elem.h.

  {
    swap2neighbors(n1, n2);
    swap2neighbors(n2, n3);
  }

References libMesh::Elem::swap2neighbors().

Referenced by libMesh::InfPrism12::permute(), libMesh::InfPrism6::permute(), libMesh::Prism15::permute(), libMesh::Prism18::permute(), libMesh::Prism20::permute(), libMesh::Prism21::permute(), libMesh::Prism6::permute(), libMesh::Tet10::permute(), libMesh::Tet14::permute(), libMesh::Tet4::permute(), libMesh::Tri3::permute(), libMesh::Tri6::permute(), libMesh::Tri7::permute(), and libMesh::Elem::swap4neighbors().

◆ swap3nodes()

void libMesh::Elem::swap3nodes	(	unsigned int	n1,
		unsigned int	n2,
		unsigned int	n3
	)

inlineprotectedinherited

Swaps three node_ptrs, "rotating" them.

Definition at line 2254 of file elem.h.

  {
    swap2nodes(n1, n2);
    swap2nodes(n2, n3);
  }

References libMesh::Elem::swap2nodes().

Referenced by libMesh::InfPrism12::permute(), libMesh::InfPrism6::permute(), libMesh::Prism15::permute(), libMesh::Prism18::permute(), libMesh::Prism20::permute(), libMesh::Prism21::permute(), libMesh::Prism6::permute(), libMesh::Tet10::permute(), libMesh::Tet14::permute(), libMesh::Tet4::permute(), libMesh::Tri3::permute(), libMesh::Tri6::permute(), libMesh::Tri7::permute(), and libMesh::Elem::swap4nodes().

◆ swap4neighbors()

void libMesh::Elem::swap4neighbors	(	unsigned int	n1,
		unsigned int	n2,
		unsigned int	n3,
		unsigned int	n4
	)

inlineprotectedinherited

Swaps four neighbor_ptrs, "rotating" them.

Definition at line 2283 of file elem.h.

  {
    swap3neighbors(n1, n2, n3);
    swap2neighbors(n3, n4);
  }

References libMesh::Elem::swap2neighbors(), and libMesh::Elem::swap3neighbors().

Referenced by libMesh::Hex20::permute(), libMesh::Hex27::permute(), libMesh::Hex8::permute(), libMesh::InfHex16::permute(), libMesh::InfHex18::permute(), libMesh::InfHex8::permute(), libMesh::Pyramid13::permute(), libMesh::Pyramid14::permute(), libMesh::Pyramid18::permute(), libMesh::Pyramid5::permute(), libMesh::Quad4::permute(), libMesh::Quad8::permute(), and libMesh::Quad9::permute().

◆ swap4nodes()

void libMesh::Elem::swap4nodes	(	unsigned int	n1,
		unsigned int	n2,
		unsigned int	n3,
		unsigned int	n4
	)

inlineprotectedinherited

Swaps four node_ptrs, "rotating" them.

Definition at line 2273 of file elem.h.

  {
    swap3nodes(n1, n2, n3);
    swap2nodes(n3, n4);
  }

References libMesh::Elem::swap2nodes(), and libMesh::Elem::swap3nodes().

Referenced by libMesh::Hex20::permute(), libMesh::Hex27::permute(), libMesh::Hex8::permute(), libMesh::InfHex16::permute(), libMesh::InfHex18::permute(), libMesh::InfHex8::permute(), libMesh::Pyramid13::permute(), libMesh::Pyramid14::permute(), libMesh::Pyramid18::permute(), libMesh::Pyramid5::permute(), libMesh::Quad4::permute(), libMesh::Quad8::permute(), and libMesh::Quad9::permute().

◆ system_var_to_vg_var()

unsigned int libMesh::DofObject::system_var_to_vg_var	(	const unsigned int	s,
		const unsigned int	vg,
		const unsigned int	var
	)		const

inlineprivateinherited

Utility function - for variable var in system s, figure out what variable group it lives in.

Definition at line 1349 of file dof_object.h.

{
  unsigned int accumulated_sum=0;
 
  for (unsigned int vgc=0; vgc<vg; vgc++)
    accumulated_sum += this->n_vars(s,vgc);
 
  libmesh_assert_less_equal (accumulated_sum, var);
 
  return (var - accumulated_sum);
}

References n_vars.

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

◆ top_parent()

const Elem * libMesh::Elem::top_parent ( ) const

inlineinherited

Returns: A pointer to the element's top-most (i.e. level-0) parent.

That is, this if this is a level-0 element, this element's parent if this is a level-1 element, this element's grandparent if this is a level-2 element, etc...

Definition at line 3194 of file elem.h.

{
  const Elem * tp = this;
 
  // Keep getting the element's parent
  // until that parent is at level-0
  while (tp->parent() != nullptr)
    tp = tp->parent();
 
  libmesh_assert(tp);
  libmesh_assert_equal_to (tp->level(), 0);
 
  return tp;
}

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

Referenced by libMesh::BoundaryInfo::boundary_ids(), libMesh::BoundaryInfo::edge_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_amr_interior_parents(), libMesh::ExodusII_IO::read_elemental_variable(), libMesh::BoundaryInfo::side_boundary_ids(), libMesh::BoundaryInfo::side_with_boundary_id(), libMesh::BoundaryInfo::sides_with_boundary_id(), ExtraIntegersTest::test_final_integers(), and ElemTest< elem_type >::test_n_refinements().

◆ topological_neighbor() [1/2]

const Elem * libMesh::Elem::topological_neighbor	(	const unsigned int	i,
		const MeshBase &	mesh,
		const PointLocatorBase &	point_locator,
		const PeriodicBoundaries *	pb
	)		const

inherited

Returns: A pointer to the \( i^{th} \) neighbor of this element for interior elements. If an element is on a periodic boundary, it will return a corresponding element on the opposite side.

Definition at line 1227 of file elem.C.

{
  libmesh_assert_less (i, this->n_neighbors());
 
  const Elem * neighbor_i = this->neighbor_ptr(i);
  if (neighbor_i != nullptr)
    return neighbor_i;
 
  if (pb)
    {
      // Since the neighbor is nullptr it must be on a boundary. We need
      // see if this is a periodic boundary in which case it will have a
      // topological neighbor
      std::vector<boundary_id_type> bc_ids;
      mesh.get_boundary_info().boundary_ids(this, cast_int<unsigned short>(i), bc_ids);
      for (const auto & id : bc_ids)
        if (pb->boundary(id))
          {
            neighbor_i = pb->neighbor(id, point_locator, this, i);
 
            // Since coarse elements do not have more refined
            // neighbors we need to make sure that we don't return one
            // of these types of neighbors.
            if (neighbor_i)
              while (level() < neighbor_i->level())
                neighbor_i = neighbor_i->parent();
            return neighbor_i;
          }
    }
 
  return nullptr;
}

References libMesh::PeriodicBoundaries::boundary(), libMesh::Elem::level(), mesh, libMesh::Elem::n_neighbors(), libMesh::PeriodicBoundaries::neighbor(), libMesh::Elem::neighbor_ptr(), and libMesh::Elem::parent().

Referenced by libMesh::Elem::has_topological_neighbor(), libMesh::DefaultCoupling::operator()(), libMesh::GhostPointNeighbors::operator()(), and libMesh::MeshRefinement::topological_neighbor().

◆ topological_neighbor() [2/2]

Elem * libMesh::Elem::topological_neighbor	(	const unsigned int	i,
		MeshBase &	mesh,
		const PointLocatorBase &	point_locator,
		const PeriodicBoundaries *	pb
	)

inherited

Returns: A writable pointer to the \( i^{th} \) neighbor of this element for interior elements. If an element is on a periodic boundary, it will return a corresponding element on the opposite side.

Definition at line 1185 of file elem.C.

{
  libmesh_assert_less (i, this->n_neighbors());
 
  Elem * neighbor_i = this->neighbor_ptr(i);
  if (neighbor_i != nullptr)
    return neighbor_i;
 
  if (pb)
    {
      // Since the neighbor is nullptr it must be on a boundary. We need
      // see if this is a periodic boundary in which case it will have a
      // topological neighbor
      std::vector<boundary_id_type> bc_ids;
      mesh.get_boundary_info().boundary_ids(this, cast_int<unsigned short>(i), bc_ids);
      for (const auto & id : bc_ids)
        if (pb->boundary(id))
          {
            // Since the point locator inside of periodic boundaries
            // returns a const pointer we will retrieve the proper
            // pointer directly from the mesh object.
            const Elem * const cn = pb->neighbor(id, point_locator, this, i);
            neighbor_i = const_cast<Elem *>(cn);
 
            // Since coarse elements do not have more refined
            // neighbors we need to make sure that we don't return one
            // of these types of neighbors.
            if (neighbor_i)
              while (level() < neighbor_i->level())
                neighbor_i = neighbor_i->parent();
            return neighbor_i;
          }
    }
 
  return nullptr;
}

References libMesh::PeriodicBoundaries::boundary(), libMesh::Elem::level(), mesh, libMesh::Elem::n_neighbors(), libMesh::PeriodicBoundaries::neighbor(), libMesh::Elem::neighbor_ptr(), and libMesh::Elem::parent().

◆ topologically_equal()

bool libMesh::Elem::topologically_equal ( const Elem & rhs ) const

inherited

Returns: true if two elements have equal topologies, false otherwise. This is true if the elements connect to nodes of the same id in the same order, and neighbors of the same id on each side, the same id on any parent and/or interior_parent link, etc.

Definition at line 728 of file elem.C.

{
  // If the elements aren't the same type, they aren't equal
  if (this->type() != rhs.type())
    return false;
 
  libmesh_assert_equal_to(this->n_nodes(), rhs.n_nodes());
 
  for (auto n : make_range(this->n_nodes()))
    if (this->node_id(n) != rhs.node_id(n))
      return false;
 
  for (auto neigh : make_range(this->n_neighbors()))
    {
      if (!this->neighbor_ptr(neigh))
        {
          if (rhs.neighbor_ptr(neigh))
            return false;
          continue;
        }
      if (!rhs.neighbor_ptr(neigh) ||
          this->neighbor_ptr(neigh)->id() !=
          rhs.neighbor_ptr(neigh)->id())
        return false;
    }
 
  if (this->parent())
    {
      if (!rhs.parent())
        return false;
      if (this->parent()->id() != rhs.parent()->id())
        return false;
    }
  else if (rhs.parent())
    return false;
 
  if (this->interior_parent())
    {
      if (!rhs.interior_parent())
        return false;
      if (this->interior_parent()->id() !=
          rhs.interior_parent()->id())
        return false;
    }
  else if (rhs.interior_parent())
    return false;
 
  return true;
}

References libMesh::DofObject::id(), libMesh::Elem::interior_parent(), libMesh::make_range(), libMesh::Elem::n_neighbors(), libMesh::Elem::n_nodes(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::node_id(), libMesh::Elem::parent(), and libMesh::Elem::type().

◆ total_family_tree() [1/2]

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

inherited

Same as the family_tree() member, but also adds any subactive descendants.

Definition at line 2228 of file elem.C.

{
  ElemInternal::total_family_tree(this, family, reset);
}

References libMesh::ElemInternal::total_family_tree().

Referenced by libMesh::Partitioner::set_parent_processor_ids().

◆ total_family_tree() [2/2]

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

inherited

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

Definition at line 2236 of file elem.C.

{
  ElemInternal::total_family_tree(this, family, reset);
}

References libMesh::ElemInternal::total_family_tree().

◆ total_family_tree_by_neighbor() [1/2]

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

inherited

Same as the family_tree_by_neighbor() member, but also adds any subactive descendants.

Definition at line 2332 of file elem.C.

{
  ElemInternal::total_family_tree_by_neighbor(this, family, neighbor, reset);
}

References libMesh::ElemInternal::total_family_tree_by_neighbor().

◆ total_family_tree_by_neighbor() [2/2]

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

inherited

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

Definition at line 2341 of file elem.C.

{
  ElemInternal::total_family_tree_by_neighbor(this, family, neighbor, reset);
}

References libMesh::ElemInternal::total_family_tree_by_neighbor().

◆ total_family_tree_by_side() [1/2]

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

inherited

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

Definition at line 2278 of file elem.C.

{
  ElemInternal::total_family_tree_by_side(this, family, side, reset);
}

References libMesh::ElemInternal::total_family_tree_by_side().

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

◆ total_family_tree_by_side() [2/2]

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

inherited

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

Definition at line 2287 of file elem.C.

{
  ElemInternal::total_family_tree_by_side(this, family, side, reset);
}

References libMesh::ElemInternal::total_family_tree_by_side().

◆ total_family_tree_by_subneighbor() [1/2]

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

inherited

Same as the family_tree_by_subneighbor() member, but also adds any subactive descendants.

Definition at line 2370 of file elem.C.

{
  ElemInternal::total_family_tree_by_subneighbor(this, family, neighbor, subneighbor, reset);
}

References libMesh::ElemInternal::total_family_tree_by_subneighbor().

◆ total_family_tree_by_subneighbor() [2/2]

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

inherited

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

Definition at line 2380 of file elem.C.

{
  ElemInternal::total_family_tree_by_subneighbor(this, family, neighbor, subneighbor, reset);
}

References libMesh::ElemInternal::total_family_tree_by_subneighbor().

◆ true_centroid()

Point libMesh::Elem::true_centroid ( ) const

virtualinherited

Returns: The "true" geometric centroid of the element, c=(cx, cy, cz), where:

[cx] [\int x dV] [cy] := (1/V) * [\int y dV] [cz] [\int z dV]

This method is virtual since some derived elements might want to use shortcuts to compute their centroid. For most element types, this method is more expensive than calling vertex_average(), so if you only need a point which is located "somewhere" in the interior of the element, consider calling vertex_average() instead.

Reimplemented in libMesh::C0Polyhedron, libMesh::Hex8, libMesh::Prism6, libMesh::Pyramid5, libMesh::Tet4, libMesh::Edge2, libMesh::C0Polygon, libMesh::Quad4, and libMesh::Tri3.

Definition at line 515 of file elem.C.

{
  // The base class implementation builds a finite element of the correct
  // order and computes the centroid, c=(cx, cy, cz), where:
  //
  // [cx]            [\int x dV]
  // [cy] := (1/V) * [\int y dV]
  // [cz]            [\int z dV]
  //
  // using quadrature. Note that we can expand "x" in the FE space as:
  //
  // x = \sum_i x_i \phi_i
  //
  // where x_i are the nodal positions of the element and \phi_i are the
  // associated Lagrange shape functions. This allows us to write the
  // integrals above as e.g.:
  //
  // \int x dV = \sum_i x_i \int \phi_i dV
  //
  // Defining:
  //
  // V_i := \int \phi_i dV
  //
  // we then have:
  //
  // [cx]           [\sum_i x_i V_i]
  // [cy] = (1/V) * [\sum_i y_i V_i]
  // [cz]           [\sum_i z_i V_i]
  //
  // where:
  // V = \sum_i V_i
  //
  // Derived element types can overload this method to compute
  // the centroid more efficiently when possible.
 
  // If this Elem has an elevated p_level, then we need to generate a
  // barebones copy of it with zero p_level and call true_centroid()
  // on that instead.  This workaround allows us to avoid issues with
  // calling FE::reinit() with a default_order() FEType, and then
  // having that order incorrectly boosted by p_level.
  if (this->p_level())
    {
      auto elem_copy = this->disconnected_clone();
#ifdef LIBMESH_ENABLE_AMR
      elem_copy->set_p_level(0);
#endif
 
      // Set node pointers
      for (auto n : this->node_index_range())
        elem_copy->set_node(n, _nodes[n]);
 
      return elem_copy->true_centroid();
    }
 
  const FEFamily mapping_family = FEMap::map_fe_type(*this);
  const FEType fe_type(this->default_order(), mapping_family);
 
  // Build FE and attach quadrature rule.  The default quadrature rule
  // integrates the mass matrix exactly, thus it is overkill to
  // integrate the basis functions, but this is convenient.
  std::unique_ptr<FEBase> fe = FEBase::build(this->dim(), fe_type);
  QGauss qrule (this->dim(), fe_type.default_quadrature_order());
  fe->attach_quadrature_rule(&qrule);
 
  // Pre-request required data
  const auto & JxW = fe->get_JxW();
  const auto & phi = fe->get_phi();
 
  // Re-compute element-specific values
  fe->reinit(this);
 
  // Number of basis functions
  auto N = phi.size();
  libmesh_assert_equal_to(N, this->n_nodes());
 
  // Compute V_i
  std::vector<Real> V(N);
  for (auto qp : index_range(JxW))
    for (auto i : make_range(N))
      V[i] += JxW[qp] * phi[i][qp];
 
  // Compute centroid
  Point cp;
  Real vol = 0.;
 
  for (auto i : make_range(N))
    {
      cp += this->point(i) * V[i];
      vol += V[i];
    }
 
  return cp / vol;
}

References libMesh::Elem::_nodes, libMesh::FEGenericBase< OutputType >::build(), libMesh::Elem::default_order(), libMesh::FEType::default_quadrature_order(), libMesh::Elem::dim(), libMesh::Elem::disconnected_clone(), libMesh::index_range(), libMesh::make_range(), libMesh::FEMap::map_fe_type(), libMesh::Elem::n_nodes(), libMesh::Elem::node_index_range(), libMesh::Elem::p_level(), libMesh::Elem::point(), and libMesh::Real.

Referenced by assemble_advection_diffusion(), centroid_l2_error(), VolumeTest::testHex20PLevelTrueCentroid(), VolumeTest::testPyramid5TrueCentroid(), VolumeTest::testQuad4TrueCentroid(), VolumeTest::testTri3TrueCentroid(), and libMesh::C0Polyhedron::true_centroid().

◆ type()

virtual ElemType libMesh::Elem::type ( ) const

pure virtualinherited

Returns: The type of element that has been derived from this base class.

Implemented in libMesh::Hex20, libMesh::Hex27, libMesh::Hex8, libMesh::InfHex16, libMesh::InfHex18, libMesh::InfHex8, libMesh::InfPrism12, libMesh::InfPrism6, libMesh::Prism15, libMesh::Prism18, libMesh::Prism20, libMesh::Prism21, libMesh::Prism6, libMesh::Pyramid13, libMesh::Pyramid14, libMesh::Pyramid18, libMesh::Pyramid5, libMesh::Tet10, libMesh::Tet14, libMesh::Tet4, libMesh::Edge2, libMesh::Edge3, libMesh::Edge4, libMesh::InfEdge2, libMesh::InfQuad4, libMesh::InfQuad6, libMesh::Quad4, libMesh::QuadShell4, libMesh::Quad8, libMesh::QuadShell8, libMesh::Quad9, libMesh::QuadShell9, libMesh::Tri3, libMesh::TriShell3, libMesh::Tri3Subdivision, libMesh::Tri6, libMesh::Tri7, libMesh::NodeElem, libMesh::RemoteElem, libMesh::C0Polyhedron, and libMesh::C0Polygon.

◆ unique_id()

unique_id_type libMesh::DofObject::unique_id ( ) const

inlineinherited

Returns: The globally unique_id for this DofObject

Definition at line 849 of file dof_object.h.

{
#ifdef LIBMESH_ENABLE_UNIQUE_ID
  libmesh_assert (this->valid_unique_id());
  return _unique_id;
#else
  return invalid_unique_id;
#endif
}

References libMesh::DofObject::_unique_id, libMesh::DofObject::invalid_unique_id, libMesh::libmesh_assert(), and libMesh::DofObject::valid_unique_id().

Referenced by libMesh::DistributedMesh::add_elem(), libMesh::ReplicatedMesh::add_elem(), libMesh::DistributedMesh::add_node(), libMesh::ReplicatedMesh::add_node(), libMesh::ReplicatedMesh::add_point(), libMesh::MeshTools::Modification::all_tri(), libMesh::Elem::disconnected_clone(), libMesh::C0Polyhedron::disconnected_clone(), libMesh::MeshTools::Modification::flatten(), libMesh::Elem::get_info(), libMesh::DistributedMesh::insert_elem(), libMesh::ReplicatedMesh::insert_elem(), libMesh::XdrIO::pack_element(), libMesh::ExodusII_IO::read_elemental_variable(), libMesh::CheckpointIO::read_nodes(), MeshInputTest::testExodusSetNodeUniqueIdsFromMaps_implementation(), SlitMeshRefinedSystemTest::testRestart(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), and libMesh::XdrIO::write_serialized_nodes().

◆ unpack_indexing()

void libMesh::DofObject::unpack_indexing ( std::vector< largest_id_type >::const_iterator begin )

inherited

A method for creating our index buffer from packed data - basically with our current implementation we investigate the size term and then copy.

Definition at line 587 of file dof_object.C.

{
  _idx_buf.clear();
 
#ifdef LIBMESH_ENABLE_AMR
  this->clear_old_dof_object();
  const bool has_old_dof_object = cast_int<bool>(*begin++);
#endif
 
  const largest_id_type size = *begin++;
  _idx_buf.reserve(size);
  std::copy(begin, begin+size, back_inserter(_idx_buf));
 
  // Check as best we can for internal consistency now
  libmesh_assert(_idx_buf.empty() ||
                 (std::abs(dof_id_signed_type(_idx_buf[0])) <=
                  cast_int<dof_id_signed_type>(_idx_buf.size())));
#ifdef DEBUG
  if (!_idx_buf.empty())
    {
      const int hdr = cast_int<int>(dof_id_signed_type(_idx_buf[0]));
      const unsigned int ns = hdr >= 0 ? hdr : (-hdr-1);
      for (unsigned int i=1; i < ns; ++i)
        {
          if (hdr > 0 || i > 1)
            libmesh_assert_greater_equal (_idx_buf[i], _idx_buf[i-1]);
          else
            libmesh_assert_greater_equal (_idx_buf[i], ns);
          libmesh_assert_equal_to ((_idx_buf[i] - _idx_buf[i-1])%2, 0);
          libmesh_assert_less_equal (_idx_buf[i], _idx_buf.size());
        }
      if (hdr < 0 && ns > 0)
        libmesh_assert_less_equal(_idx_buf[ns], _idx_buf.size());
    }
#endif
 
#ifdef LIBMESH_ENABLE_AMR
  if (has_old_dof_object)
    {
      this->old_dof_object = this->construct();
      this->old_dof_object->unpack_indexing(begin+size);
    }
#endif
}

References libMesh::DofObject::_idx_buf, libMesh::DofObject::clear_old_dof_object(), libMesh::DofObject::construct(), libMesh::libmesh_assert(), and libMesh::DofObject::old_dof_object.

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

◆ unpackable_indexing_size()

unsigned int libMesh::DofObject::unpackable_indexing_size ( std::vector< largest_id_type >::const_iterator begin )

staticinherited

If we have indices packed into an buffer for communications, how much of that buffer applies to this dof object?

Definition at line 567 of file dof_object.C.

{
#ifdef LIBMESH_ENABLE_AMR
  const bool has_old_dof_object = cast_int<bool>(*begin++);
 
  static const int dof_header_size = 2;
#else
  static const bool has_old_dof_object = false;
  static const int dof_header_size = 1;
#endif
 
  const largest_id_type this_indexing_size = *begin++;
 
  return cast_int<unsigned int>
    (dof_header_size + this_indexing_size +
     (has_old_dof_object ?
      unpackable_indexing_size(begin+this_indexing_size) : 0));
}

References libMesh::DofObject::unpackable_indexing_size().

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

◆ valid_id()

bool libMesh::DofObject::valid_id ( ) const

inlineinherited

Returns: true if this DofObject has a valid id set, false otherwise.

Definition at line 875 of file dof_object.h.

{
  return (DofObject::invalid_id != _id);
}

References libMesh::DofObject::_id, and libMesh::DofObject::invalid_id.

Referenced by libMesh::DistributedMesh::add_elem(), libMesh::ReplicatedMesh::add_elem(), libMesh::DistributedMesh::add_node(), libMesh::ReplicatedMesh::add_node(), libMesh::Elem::get_info(), libMesh::Node::get_info(), libMesh::Poly2TriTriangulator::insert_refinement_points(), libMesh::Elem::libmesh_assert_valid_node_pointers(), DofObjectTest< DerivedClass >::testInvalidateId(), and DofObjectTest< DerivedClass >::testValidId().

◆ valid_processor_id()

bool libMesh::DofObject::valid_processor_id ( ) const

inlineinherited

Returns: true if this DofObject has a valid id set, false otherwise.

Definition at line 919 of file dof_object.h.

{
  return (DofObject::invalid_processor_id != _processor_id);
}

References libMesh::DofObject::_processor_id, and libMesh::DofObject::invalid_processor_id.

Referenced by DofObjectTest< DerivedClass >::testInvalidateProcId(), and DofObjectTest< DerivedClass >::testValidProcId().

◆ valid_unique_id()

bool libMesh::DofObject::valid_unique_id ( ) const

inlineinherited

Returns: true if this DofObject has a valid unique_id set, false otherwise.

Definition at line 883 of file dof_object.h.

{
#ifdef LIBMESH_ENABLE_UNIQUE_ID
  return (DofObject::invalid_unique_id != _unique_id);
#else
  return false;
#endif
}

References libMesh::DofObject::_unique_id, and libMesh::DofObject::invalid_unique_id.

Referenced by libMesh::DistributedMesh::add_elem(), libMesh::ReplicatedMesh::add_elem(), libMesh::DistributedMesh::add_node(), libMesh::ReplicatedMesh::add_node(), libMesh::ReplicatedMesh::add_point(), libMesh::Elem::disconnected_clone(), libMesh::C0Polyhedron::disconnected_clone(), libMesh::Elem::get_info(), libMesh::DistributedMesh::insert_elem(), libMesh::ReplicatedMesh::insert_elem(), and libMesh::DofObject::unique_id().

◆ var_to_vg()

unsigned int libMesh::DofObject::var_to_vg	(	const unsigned int	s,
		const unsigned int	var
	)		const

inlineprivateinherited

Utility function - for variable var in system s, figure out what variable group it lives in.

Definition at line 1331 of file dof_object.h.

{
  const unsigned int
    nvg = this->n_var_groups(s);
 
  for (unsigned int vg=0, vg_end=0; vg<nvg; vg++)
    {
      vg_end += this->n_vars(s,vg);
      if (var < vg_end) return vg;
    }
 
  libmesh_error_msg("Error: could not map variable " << var << " to variable group.");
}

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

Referenced by libMesh::DofObject::n_comp(), libMesh::DofObject::set_dof_number(), and libMesh::DofObject::set_n_comp().

◆ var_to_vg_and_offset()

std::pair< unsigned int, unsigned int > libMesh::DofObject::var_to_vg_and_offset	(	const unsigned int	s,
		const unsigned int	var
	)		const

inlineinherited

Returns: A pair consisting of the variable group number and the offset index from the start of that group for variable var on system s associated with this DofObject

Definition at line 1190 of file dof_object.h.

{
  std::pair<unsigned int, unsigned int> returnval(0,0);
 
  unsigned int & vg = returnval.first;
  unsigned int & offset = returnval.second;
 
  unsigned int vg_start = 0;
  for (; ; vg++)
    {
      libmesh_assert_less(vg, this->n_var_groups(s));
 
      const unsigned int vg_end = vg_start + this->n_vars(s,vg);
      if (var < vg_end)
        {
          offset = var - vg_start;
          return returnval;
        }
      vg_start = vg_end;
    }
}

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

Referenced by libMesh::DofMap::_dof_indices(), libMesh::DofMap::_node_dof_indices(), libMesh::DofObject::dof_number(), libMesh::OldSolutionValue< Output, point_output >::eval_old_dofs(), and libMesh::OldSolutionCoefs< Output, point_output >::eval_old_dofs().

◆ vertex_average()

Point libMesh::Elem::vertex_average ( ) const

inherited

Returns: A Point at the average of the elment's vertices.

Note: This used to be the base class centroid() implementation, but the centroid is only equal to the vertex average in some special cases. The centroid() implementation now returns the "true" centroid of the element (up to quadrature error).

Definition at line 609 of file elem.C.

{
  Point cp;
 
  const auto n_vertices = this->n_vertices();
 
  for (unsigned int n=0; n<n_vertices; n++)
    cp.add (this->point(n));
 
  return (cp /= static_cast<Real>(n_vertices));
}

References libMesh::TypeVector< T >::add(), libMesh::Elem::n_vertices(), and libMesh::Real.

Referenced by libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::BoundaryInfo::get_side_and_node_maps(), libMesh::Poly2TriTriangulator::insert_refinement_points(), OutputAssembly::interior_assembly(), A0::interior_assembly(), A1::interior_assembly(), SlitFunc::operator()(), libMesh::LocationMap< T >::point_of(), libMesh::RBParametrizedFunction::preevaluate_parametrized_function_on_mesh(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::C0Polyhedron::retriangulate(), libMesh::FE< Dim, T >::shape_deriv(), libMesh::FE< Dim, T >::shape_deriv(), libMesh::FE< Dim, T >::shape_second_deriv(), libMesh::FE< Dim, T >::shape_second_deriv(), DefaultCouplingTest::testCoupling(), PointNeighborCouplingTest::testCoupling(), HDivGradTest::testGradByFiniteDifference(), libMesh::Tet4::true_centroid(), and libMesh::Tri3::true_centroid().

◆ vg_dof_base()

dof_id_type libMesh::DofObject::vg_dof_base	(	const unsigned int	s,
		const unsigned int	vg
	)		const

inlineinherited

VariableGroup DoF indices are indexed as id = base + var_in_vg*ncomp + comp This method allows for direct access to the base.

Definition at line 1307 of file dof_object.h.

{
  libmesh_assert_less (s,  this->n_systems());
  libmesh_assert_less (vg, this->n_var_groups(s));
 
  const unsigned int
    start_idx_sys = this->start_idx(s);
 
  libmesh_assert_less ((start_idx_sys + 2*vg + 1), _idx_buf.size());
 
  // #ifdef DEBUG
  //   std::cout << " [ ";
  //   for (auto i : _idx_buf)
  //     std::cout << i << " ";
  //   std::cout << "]\n";
  // #endif
 
  return _idx_buf[start_idx_sys + 2*vg + 1];
}

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

Referenced by libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::DofObject::set_vg_dof_base(), and DofObjectTest< DerivedClass >::testManualDofCalculation().

◆ volume()

Real libMesh::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::C0Polyhedron, libMesh::Hex20, libMesh::Hex27, libMesh::Hex8, libMesh::Prism15, libMesh::Prism18, libMesh::Prism6, libMesh::Pyramid13, libMesh::Pyramid14, libMesh::Pyramid5, libMesh::Tet10, libMesh::Tet4, libMesh::Edge2, libMesh::Edge3, libMesh::Edge4, libMesh::C0Polygon, libMesh::Quad4, libMesh::Quad8, libMesh::Quad9, libMesh::Tri3, libMesh::Tri6, and libMesh::NodeElem.

Definition at line 3865 of file elem.C.

{
  // The default implementation builds a finite element of the correct
  // order and sums up the JxW contributions.  This can be expensive,
  // so the various element types can overload this method and compute
  // the volume more efficiently.
  const FEFamily mapping_family = FEMap::map_fe_type(*this);
  const FEType fe_type(this->default_order(), mapping_family);
 
  std::unique_ptr<FEBase> fe (FEBase::build(this->dim(),
                                            fe_type));
 
  // Use a map with a negative Jacobian tolerance, in case we're asked
  // for the net volume of a tangled element
  fe->get_fe_map().set_jacobian_tolerance(std::numeric_limits<Real>::lowest());
 
  const std::vector<Real> & JxW = fe->get_JxW();
 
  // The default quadrature rule should integrate the mass matrix,
  // thus it should be plenty to compute the area
  QGauss qrule (this->dim(), fe_type.default_quadrature_order());
 
  fe->attach_quadrature_rule(&qrule);
 
  fe->reinit(this);
 
  Real vol=0.;
  for (auto jxw : JxW)
    vol += jxw;
 
  return vol;
 
}

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.

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

{
  libmesh_assert(e);
  libmesh_assert (this->has_children());
 
  unsigned int nc = this->n_children();
  for (unsigned int c=0; c != nc; c++)
    if (this->child_ptr(c) == e)
      return c;
 
  libmesh_error_msg("ERROR:  which_child_am_i() was called with a non-child!");
 
  return libMesh::invalid_uint;
}

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

Referenced by libMesh::BoundaryInfo::boundary_ids(), libMesh::BoundaryInfo::edge_boundary_ids(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::Elem::make_links_to_me_remote(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectVertices::operator()(), libMesh::BoundaryInfo::side_boundary_ids(), libMesh::BoundaryInfo::side_with_boundary_id(), libMesh::BoundaryInfo::sides_with_boundary_id(), libMesh::MeshTools::Modification::smooth(), libMesh::Parallel::sync_element_data_by_parent_id(), and ElemTest< elem_type >::test_n_refinements().

◆ which_neighbor_am_i()

unsigned int libMesh::Elem::which_neighbor_am_i ( const Elem * e ) const

inlineinherited

This function tells you which neighbor e is.

I.e. if s = a->which_neighbor_am_i(e); then a->neighbor(s) will be an ancestor of e.

Definition at line 3057 of file elem.h.

{
  libmesh_assert(e);
 
  const Elem * eparent = e;
 
  while (eparent->level() > this->level())
    {
      eparent = eparent->parent();
      libmesh_assert(eparent);
    }
 
  for (auto s : make_range(this->n_sides()))
    if (this->neighbor_ptr(s) == eparent)
      return s;
 
  return libMesh::invalid_uint;
}

References libMesh::invalid_uint, libMesh::Elem::level(), libMesh::libmesh_assert(), libMesh::make_range(), libMesh::Elem::n_sides(), libMesh::Elem::neighbor_ptr(), and libMesh::Elem::parent().

Referenced by assemble_ellipticdg(), assemble_temperature_jump(), MeshBaseTest::BrokenNeighborMesh(), libMesh::EquationSystems::build_discontinuous_solution_vector(), libMesh::MeshTetInterface::check_hull_integrity(), libMesh::BoundaryInfo::clear_stitched_boundary_side_ids(), libMesh::FEGenericBase< OutputType >::compute_proj_constraints(), libMesh::MeshTools::find_hanging_nodes_and_parents(), libMesh::MeshTetInterface::improve_hull_integrity(), libMesh::Poly2TriTriangulator::insert_refinement_points(), libMesh::Elem::libmesh_assert_valid_neighbors(), libMesh::Elem::nullify_neighbors(), MeshGenerationTest::polyhedronTetNeighbor(), libMesh::C0Polyhedron::retriangulate(), ElemTest< elem_type >::test_orientation_conformity(), and MeshGenerationTest::testBuildCube().

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

{
  libmesh_assert(e);
 
  const unsigned int ns = this->n_sides();
  const unsigned int nn = this->n_nodes();
 
  const unsigned int en = e->n_nodes();
 
  // e might be on any side until proven otherwise
  std::vector<bool> might_be_side(ns, true);
 
  for (unsigned int i=0; i != en; ++i)
    {
      Point side_point = e->point(i);
      unsigned int local_node_id = libMesh::invalid_uint;
 
      // Look for a node of this that's contiguous with node i of
      // e. Note that the exact floating point comparison of Point
      // positions is intentional, see the class documentation for
      // this function.
      for (unsigned int j=0; j != nn; ++j)
        if (this->point(j) == side_point)
          local_node_id = j;
 
      // If a node of e isn't contiguous with some node of this, then
      // e isn't a side of this.
      if (local_node_id == libMesh::invalid_uint)
        return libMesh::invalid_uint;
 
      // If a node of e isn't contiguous with some node on side s of
      // this, then e isn't on side s.
      for (unsigned int s=0; s != ns; ++s)
        if (!this->is_node_on_side(local_node_id, s))
          might_be_side[s] = false;
    }
 
  for (unsigned int s=0; s != ns; ++s)
    if (might_be_side[s])
      {
#ifdef DEBUG
        for (unsigned int s2=s+1; s2 < ns; ++s2)
          libmesh_assert (!might_be_side[s2]);
#endif
        return s;
      }
 
  // Didn't find any matching side
  return libMesh::invalid_uint;
}

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

◆ write_connectivity()

void libMesh::Elem::write_connectivity	(	std::ostream &	out,
		const IOPackage	iop
	)		const

inherited

Writes the element connectivity for various IO packages to the passed ostream "out".

Not virtual, since it is implemented in the base class.

Definition at line 1680 of file elem.C.

{
  libmesh_assert (out_stream.good());
  libmesh_assert(_nodes);
  libmesh_assert_not_equal_to (iop, INVALID_IO_PACKAGE);
 
  switch (iop)
    {
    case TECPLOT:
      {
        // This connectivity vector will be used repeatedly instead
        // of being reconstructed inside the loop.
        std::vector<dof_id_type> conn;
        for (auto sc : make_range(this->n_sub_elem()))
          {
            this->connectivity(sc, TECPLOT, conn);
 
            std::copy(conn.begin(),
                      conn.end(),
                      std::ostream_iterator<dof_id_type>(out_stream, " "));
 
            out_stream << '\n';
          }
        return;
      }
 
    case UCD:
      {
        for (auto i : this->node_index_range())
          out_stream << this->node_id(i)+1 << "\t";
 
        out_stream << '\n';
        return;
      }
 
    default:
      libmesh_error_msg("Unsupported IO package " << iop);
    }
}

References libMesh::Elem::_nodes, libMesh::Elem::connectivity(), libMesh::INVALID_IO_PACKAGE, libMesh::libmesh_assert(), libMesh::make_range(), libMesh::Elem::n_sub_elem(), libMesh::Elem::node_id(), libMesh::Elem::node_index_range(), libMesh::TECPLOT, and libMesh::UCD.

Member Data Documentation

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

Referenced by libMesh::Elem::add_child(), libMesh::Elem::add_child(), libMesh::Elem::child_ptr(), libMesh::Elem::child_ptr(), libMesh::Elem::child_ref_range(), libMesh::Elem::child_ref_range(), libMesh::Elem::contract(), libMesh::Elem::has_ancestor_children(), libMesh::Elem::has_children(), libMesh::Elem::raw_child_ptr(), libMesh::Elem::refine(), and libMesh::Elem::set_child().

◆ _counts [1/2]

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

Definition at line 124 of file reference_counter.h.

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

◆ _counts [2/2]

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

Definition at line 124 of file reference_counter.h.

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

◆ _elemlinks

Elem** libMesh::Elem::_elemlinks

protectedinherited

Pointers to this element's parent and neighbors, and for lower-dimensional elements' interior_parent.

Definition at line 2381 of file elem.h.

Referenced by libMesh::Elem::Elem(), libMesh::Elem::interior_parent(), libMesh::Elem::interior_parent(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::neighbor_ptr_range(), libMesh::Elem::neighbor_ptr_range(), libMesh::Elem::parent(), libMesh::Elem::parent(), libMesh::Polygon::Polygon(), libMesh::Polyhedron::Polyhedron(), libMesh::Elem::set_interior_parent(), libMesh::Elem::set_neighbor(), and libMesh::Elem::set_parent().

◆ _elemlinks_data

Elem* libMesh::Edge::_elemlinks_data[3+(LIBMESH_DIM >1)]

protected

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

◆ _id

dof_id_type libMesh::DofObject::_id

privateinherited

The id of the DofObject.

Definition at line 574 of file dof_object.h.

Referenced by libMesh::DofObject::id(), libMesh::DofObject::operator=(), libMesh::DofObject::set_id(), and libMesh::DofObject::valid_id().

◆ _idx_buf

index_buffer_t libMesh::DofObject::_idx_buf

privateinherited

Definition at line 671 of file dof_object.h.

◆ _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 2433 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 2427 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(), libMesh::ReferenceCounter::ReferenceCounter(), libMesh::ReferenceCounter::ReferenceCounter(), and libMesh::ReferenceCounter::~ReferenceCounter().

◆ _n_objects [2/2]

Threads::atomic< unsigned int > libMesh::ReferenceCounter::_n_objects

staticprotectedinherited

The number of objects.

Print the reference count information when the number returns to 0.

Definition at line 132 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::n_objects(), libMesh::ReferenceCounter::ReferenceCounter(), libMesh::ReferenceCounter::ReferenceCounter(), libMesh::ReferenceCounter::ReferenceCounter(), and libMesh::ReferenceCounter::~ReferenceCounter().

◆ _nodes

Node** libMesh::Elem::_nodes

protectedinherited

Pointers to the nodes we are connected to.

Definition at line 2375 of file elem.h.

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

Referenced by libMesh::Elem::hack_p_level_and_refinement_flag(), libMesh::Elem::p_refinement_flag(), and libMesh::Elem::set_p_refinement_flag().

◆ _processor_id

processor_id_type libMesh::DofObject::_processor_id

privateinherited

The processor_id of the DofObject.

Degrees of freedom are wholly owned by processors, however they may be duplicated on other processors.

This is stored as an unsigned short int since we cannot expect to be solving on 65000+ processors any time soon, can we??

Definition at line 585 of file dof_object.h.

Referenced by libMesh::DofObject::operator=(), libMesh::DofObject::processor_id(), libMesh::DofObject::processor_id(), and libMesh::DofObject::valid_processor_id().

◆ _rflag

unsigned char libMesh::Elem::_rflag

protectedinherited

h refinement flag.

This is stored as an unsigned char to save space.

Definition at line 2404 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 2397 of file elem.h.

Referenced by libMesh::Elem::subdomain_id(), and libMesh::Elem::subdomain_id().

◆ _unique_id

unique_id_type libMesh::DofObject::_unique_id

privateinherited

A globally unique id, guaranteed not to change as the mesh is repartitioned or adapted.

Definition at line 568 of file dof_object.h.

Referenced by libMesh::DofObject::operator=(), libMesh::DofObject::set_unique_id(), libMesh::DofObject::unique_id(), and libMesh::DofObject::valid_unique_id().

◆ affine_tol

constexpr Real libMesh::Elem::affine_tol = TOLERANCE*TOLERANCE

staticconstexprprotectedinherited

Default tolerance to use in has_affine_map().

Definition at line 2191 of file elem.h.

◆ invalid_id

constexpr dof_id_type libMesh::DofObject::invalid_id = static_cast<dof_id_type>(-1)

staticconstexprinherited

An invalid id to distinguish an uninitialized DofObject.

Definition at line 473 of file dof_object.h.

Referenced by libMesh::DofMap::_dof_indices(), libMesh::Node::active(), libMesh::MeshBase::add_elem_datum(), libMesh::MeshBase::add_elem_integers(), libMesh::DofObject::add_extra_integers(), libMesh::StaticCondensation::add_matrix(), libMesh::TopologyMap::add_node(), libMesh::MeshRefinement::add_node(), libMesh::MeshBase::add_node_datum(), libMesh::MeshBase::add_node_integers(), libMesh::ReplicatedMesh::add_point(), libMesh::MeshTools::Modification::all_tri(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::Elem::bracketing_nodes(), ExtraIntegersTest::checkpoint_helper(), libMesh::StaticCondensation::clear(), libMesh::FEGenericBase< OutputType >::compute_periodic_constraints(), libMesh::FEGenericBase< OutputType >::compute_proj_constraints(), libMesh::DofObject::dof_number(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_nodes(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_sides(), libMesh::OldSolutionValue< Output, point_output >::eval_old_dofs(), libMesh::OldSolutionValue< Output, point_output >::eval_old_dofs(), libMesh::TopologyMap::find(), libMesh::TopologyMap::find(), libMesh::DofMap::gather_constraints(), libMesh::MeshBase::get_elemset_code(), libMesh::Poly2TriTriangulator::insert_refinement_points(), libMesh::Elem::interior_parent(), libMesh::DofObject::invalidate_dofs(), libMesh::DofObject::invalidate_id(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::Node::Node(), libMesh::Elem::node_id(), libMesh::DistributedMesh::own_node(), libMesh::XdrIO::pack_element(), libMesh::SFCPartitioner::partition_range(), libMesh::Elem::point(), libMesh::ExodusII_IO::read(), libMesh::DynaIO::read_mesh(), libMesh::System::read_parallel_data(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::StaticCondensationDofMap::reinit(), libMesh::DofObject::set_dof_number(), libMesh::DofObject::set_n_comp_group(), libMesh::DofObject::set_n_vars_per_group(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Parallel::sync_node_data_by_element_id_once(), ExtraIntegersTest::test_and_set_initial_data(), DofObjectTest< DerivedClass >::testAddExtraData(), DofObjectTest< DerivedClass >::testAddSystemExtraInts(), ExtraIntegersTest::testExtraIntegersExodusReading(), InfFERadialTest::testRefinement(), DofObjectTest< DerivedClass >::testSetNSystemsExtraInts(), DofObjectTest< DerivedClass >::testSetNVariableGroupsExtraInts(), MeshTetTest::testTetInterfaceBase(), DofObjectTest< DerivedClass >::testValidId(), MeshSmootherTest::testVariationalSmoother(), WriteElemsetData::testWriteImpl(), libMesh::NetGenMeshInterface::triangulate(), libMesh::Poly2TriTriangulator::triangulate_current_points(), libMesh::Parallel::Packing< Elem * >::unpack(), libMesh::DofObject::valid_id(), libMesh::System::write_parallel_data(), and libMesh::XdrIO::write_serialized_connectivity().

◆ invalid_processor_id

constexpr processor_id_type libMesh::DofObject::invalid_processor_id = static_cast<processor_id_type>(-1)

staticconstexprinherited

An invalid processor_id to distinguish DoFs that have not been assigned to a processor.

Definition at line 484 of file dof_object.h.

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::DistributedMesh::add_elem(), libMesh::MeshRefinement::add_node(), libMesh::DistributedMesh::add_node(), libMesh::MeshCommunication::allgather(), libMesh::Node::choose_processor_id(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubProjector::construct_projection(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::MeshBase::count_constraint_rows(), 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_elem_on_proc(), libMesh::MeshBase::n_nodes_on_proc(), libMesh::MeshBase::n_unpartitioned_elem(), libMesh::MeshBase::n_unpartitioned_nodes(), libMesh::SparsityPattern::Build::operator()(), libMesh::Partitioner::processor_pairs_to_interface_nodes(), libMesh::Nemesis_IO_Helper::read_var_names_impl(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DistributedMesh::renumber_nodes_and_elements(), OverlappingFunctorTest::run_coupling_functor_test(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::send_and_insert_dof_values(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::Parallel::sync_dofobject_data_by_id(), libMesh::Parallel::sync_dofobject_data_by_xyz(), libMesh::Parallel::sync_element_data_by_parent_id(), libMesh::Parallel::sync_node_data_by_element_id_once(), DofObjectTest< DerivedClass >::testValidProcId(), libMesh::MeshTools::total_weight(), libMesh::Parallel::Packing< Elem * >::unpack(), libMesh::Parallel::Packing< Node * >::unpack(), libMesh::DofObject::valid_processor_id(), and libMesh::CheckpointIO::write().

◆ invalid_subdomain_id

constexpr subdomain_id_type libMesh::Elem::invalid_subdomain_id = std::numeric_limits<subdomain_id_type>::max()

staticconstexprinherited

A static integral constant representing an invalid subdomain id.

See also DofObject::{invalid_id, invalid_unique_id, invalid_processor_id}.

Note: We don't use the static_cast(-1) trick here since subdomain_id_type is sometimes a signed integer for compatibility reasons (see libmesh/id_types.h).

Definition at line 245 of file elem.h.

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::BoundaryInfo::add_elements(), libMesh::BoundaryInfo::add_elements(), libMesh::ReplicatedMesh::get_disconnected_subdomains(), libMesh::MeshBase::get_id_by_name(), libMesh::BoundaryInfo::sync(), and MeshSubdomainIDTest::testMultiple().

◆ invalid_unique_id

constexpr unique_id_type libMesh::DofObject::invalid_unique_id = static_cast<unique_id_type>(-1)

staticconstexprinherited

An invalid unique_id to distinguish an uninitialized DofObject.

Definition at line 478 of file dof_object.h.

Referenced by libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DofObject::unique_id(), and libMesh::DofObject::valid_unique_id().

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

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

◆ ncv_magic

constexpr index_t libMesh::DofObject::ncv_magic = index_t(1) << ncv_magic_exp

staticconstexprprivateinherited

Definition at line 697 of file dof_object.h.

Referenced by libMesh::DofObject::n_comp_group(), libMesh::DofObject::set_n_comp_group(), and libMesh::DofObject::set_n_vars_per_group().

◆ ncv_magic_exp

constexpr index_t libMesh::DofObject::ncv_magic_exp = sizeof(index_t)*3

staticconstexprprivateinherited

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

It is hoped that by setting this to a power of two, an optimizing compiler will recognize later that #/ncv_magic is simply a bitshift

I want ncv_magic to be low enough so we can still do some testing with multiphysics and 16-bit DoF indices occasionally, but high enough that we don't fail with only a few hundred components (e.g. a p=6 L2_HIERARCIC Hex has 7^3 and already exceeds 2^8).

Let's make it what our indices can store to the 3/8 power. That leaves 5/8 for n_vars. On a 32-bit build this lets us have n_vars up to 2^20 (good for 1M variables, passing our 100K unit test) and n_comp up to 2^12 (good for 16^3 components, so we can go up to p=15 even on an L2_HIERARCHIC hex).

For a 64-bit build we instead get 2^40 and 2^24, 1T vars and p=30, which should be enough for anybody.

Definition at line 696 of file dof_object.h.

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

◆ nodes_per_edge

const int libMesh::Edge::nodes_per_edge = invalid_int

static

Definition at line 68 of file edge.h.

◆ nodes_per_side

const int libMesh::Edge::nodes_per_side = 1

static

Definition at line 67 of file edge.h.

◆ num_children

const int libMesh::Edge::num_children = 2

static

Definition at line 66 of file edge.h.

◆ num_edges

const int libMesh::Edge::num_edges = 0

static

Definition at line 65 of file edge.h.

◆ num_sides

const int libMesh::Edge::num_sides = 2

static

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(), libMesh::DofObject::get_old_dof_object_ref(), libMesh::DofObject::get_old_dof_object_ref(), libMesh::DofObject::operator=(), libMesh::DofObject::pack_indexing(), libMesh::DofObject::packed_indexing_size(), libMesh::DofObject::set_old_dof_object(), and libMesh::DofObject::unpack_indexing().

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

Referenced by NodalNeighborsTest::do_test(), SystemsTest::test2DProjectVectorFE(), SystemsTest::test3DProjectVectorFE(), ElemTest< elem_type >::test_static_data(), and MeshSmootherTest::testVariationalSmoother().

◆ type_to_dim_map

const unsigned int libMesh::Elem::type_to_dim_map

staticinherited

This array maps the integer representation of the ElemType enum to the geometric dimension of the element.

This is currently usable even for complicated subclasses with runtime-varying topology.

Definition at line 649 of file elem.h.

Referenced by FEOrientationTest< elem_type, order, family >::build_mesh(), FEGLLCollocationTest< elem_type, order >::setUp(), FEGLLLagrangeAgreementTest< elem_type, order >::setUp(), FETestBase< order, family, elem_type, build_nx, CaseName >::setUp(), SystemsTest::test2DProjectVectorFE(), SystemsTest::test3DProjectVectorFE(), AllRBBTest::test_box(), AllTriTest::test_helper(), ElemTest< elem_type >::test_static_data(), FEGLLLagrangeAgreementTest< elem_type, order >::testAgreesWithLagrange(), PointLocatorTest::testLocator(), FEGLLCollocationTest< elem_type, order >::testMassMatrixIsDiagonal(), FEGLLCollocationTest< elem_type, order >::testShapesAreIdentity(), and libMesh::Parallel::Packing< Elem * >::unpack().

◆ type_to_n_edges_map

const unsigned int libMesh::Elem::type_to_n_edges_map

staticinherited

This array maps the integer representation of the ElemType enum to the number of edges on the element.

This is only usable for simple types for which the node number is fixed; for more general types like Polygon subclasses an actual instantiated Elem must be queried.

Definition at line 841 of file elem.h.

Referenced by libMesh::Elem::local_edge_node(), ElemTest< elem_type >::test_static_data(), and libMesh::Parallel::Packing< Elem * >::unpack().

◆ type_to_n_nodes_map

constexpr unsigned int libMesh::Elem::type_to_n_nodes_map[INVALID_ELEM]

staticconstexprinherited

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

    {
      2,  // EDGE2
      3,  // EDGE3
      4,  // EDGE4
 
      3,  // TRI3
      6,  // TRI6
 
      4,  // QUAD4
      8,  // QUAD8
      9,  // QUAD9
 
      4,  // TET4
      10, // TET10
 
      8,  // HEX8
      20, // HEX20
      27, // HEX27
 
      6,  // PRISM6
      15, // PRISM15
      18, // PRISM18
 
      5,  // PYRAMID5
      13, // PYRAMID13
      14, // PYRAMID14
 
      2,  // INFEDGE2
 
      4,  // INFQUAD4
      6,  // INFQUAD6
 
      8,  // INFHEX8
      16, // INFHEX16
      18, // INFHEX18
 
      6,  // INFPRISM6
      12, // INFPRISM12
 
      1,  // NODEELEM
 
      0,  // REMOTEELEM
 
      3,  // TRI3SUBDIVISION
      3,  // TRISHELL3
      4,  // QUADSHELL4
      8,  // QUADSHELL8
 
      7,  // TRI7
      14, // TET14
      20, // PRISM20
      21, // PRISM21
      18, // PYRAMID18
 
      9,  // QUADSHELL9
 
      invalid_uint,  // C0POLYGON
      invalid_uint,  // C0POLYHEDRON
 
    };

Referenced by libMesh::DynaIO::ElementDefinition::ElementDefinition(), libMesh::FEAbstract::get_refspace_nodes(), libMesh::Elem::local_edge_node(), libMesh::Elem::local_side_node(), libMesh::XdrIO::pack_element(), libMesh::CheckpointIO::read_connectivity(), libMesh::XdrIO::read_serialized_connectivity(), ElemTest< elem_type >::test_static_data(), ElemTest< elem_type >::test_static_topology(), MeshGenerationTest::testBuildCube(), MeshGenerationTest::testBuildLine(), libMesh::Parallel::Packing< Elem * >::unpack(), and libMesh::ExodusII_IO_Helper::write_elements().

◆ type_to_n_sides_map

const unsigned int libMesh::Elem::type_to_n_sides_map

staticinherited

This array maps the integer representation of the ElemType enum to the number of sides on the element.

This is only usable for simple types for which the node number is fixed; for more general types like Polygon subclasses an actual instantiated Elem must be queried.

Definition at line 759 of file elem.h.

Referenced by libMesh::Elem::face_orientation(), libMesh::Elem::local_side_node(), libMesh::Elem::oriented_face_vertices(), libMesh::Elem::relative_edge_face_order(), libMesh::PetscPreconditioner< T >::set_hypre_ads_data(), libMesh::Elem::side_type(), ElemTest< elem_type >::test_orientation(), ElemTest< elem_type >::test_static_data(), MeshGenerationTest::testBuildCube(), MeshGenerationTest::testBuildSquare(), and libMesh::Parallel::Packing< Elem * >::unpack().

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

include/geom/edge.h
src/geom/edge.C

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Types

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ ConstNeighborPtrIter

◆ Counts [1/2]

◆ Counts [2/2]

◆ index_buffer_t

◆ index_t

◆ NeighborPtrIter

◆ Predicate

Member Enumeration Documentation

◆ RefinementState

Constructor & Destructor Documentation

◆ Edge() [1/3]

◆ Edge() [2/3]

◆ Edge() [3/3]

◆ ~Edge()

Member Function Documentation

◆ _first_side()

◆ _get_bracketing_node_cache()

◆ _get_parent_indices_cache()

◆ _last_side()

◆ active()

◆ active_family_tree() [1/2]

◆ active_family_tree() [2/2]

◆ active_family_tree_by_neighbor() [1/2]

◆ active_family_tree_by_neighbor() [2/2]

◆ active_family_tree_by_side() [1/2]

◆ active_family_tree_by_side() [2/2]

◆ active_family_tree_by_topological_neighbor() [1/2]

◆ active_family_tree_by_topological_neighbor() [2/2]

◆ add_child() [1/2]

◆ add_child() [2/2]

◆ add_extra_integers() [1/2]

◆ add_extra_integers() [2/2]

◆ add_system()

◆ ancestor()

◆ as_parent_node()

◆ boundary_sides_begin()

◆ boundary_sides_end()

◆ bracketing_nodes()

◆ build()

◆ build_edge_ptr() [1/4]

◆ build_edge_ptr() [2/4]

◆ build_edge_ptr() [3/4]

◆ build_edge_ptr() [4/4]

◆ build_side_ptr() [1/8]

◆ build_side_ptr() [2/8]

◆ build_side_ptr() [3/8]

◆ build_side_ptr() [4/8]

◆ build_side_ptr() [5/8]

◆ build_side_ptr() [6/8]

◆ build_side_ptr() [7/8]

◆ build_side_ptr() [8/8]

◆ build_with_id()

◆ center_node_on_side()

◆ child_neighbor() [1/2]

◆ child_neighbor() [2/2]

◆ child_ptr() [1/2]

◆ child_ptr() [2/2]

◆ child_ref_range() [1/2]

◆ child_ref_range() [2/2]

◆ clear_dofs()

◆ clear_old_dof_object()

◆ close_to_point()

◆ coarsen()

◆ complete_order_equivalent_type()

◆ compute_key() [1/4]