This is the base class from which all geometric element types are derived. More...

#include <elem.h>

Inheritance diagram for libMesh::Elem:

Classes
class	ChildRefIter

class	ConstChildRefIter

class	ConstNodeRefIter

class	NodeRefIter

struct	side_iterator
	The definition of the struct used for iterating over sides. More...

class	SideIter
	The definition of the protected nested SideIter class. More...

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

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

typedef const Elem const	ConstNeighborPtrIter

typedef Predicates::multi_predicate	Predicate
	Useful iterator typedefs. More...

Public Member Functions
	Elem (Elem &&)=delete
	Elems are responsible for allocating and deleting their children during refinement, so they cannot be (default) copied or assigned. More...

	Elem (const Elem &)=delete

Elem &	operator= (const Elem &)=delete

Elem &	operator= (Elem &&)=delete

virtual	~Elem ()
	Destructor. More...

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

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

Node *	get_node (const unsigned int i) const

virtual Node *&	set_node (const unsigned int i)

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

SimpleRange< ConstNodeRefIter >	node_ref_range () const

subdomain_id_type	subdomain_id () const

subdomain_id_type &	subdomain_id ()

const Elem *	reference_elem () const

virtual dof_id_type	key (const unsigned int s) const =0

virtual dof_id_type	key () const

bool	operator== (const Elem &rhs) const

const Elem *	neighbor_ptr (unsigned int i) const

Elem *	neighbor_ptr (unsigned int i)

Elem *	neighbor (const unsigned int i) const

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

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

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

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

virtual unsigned int	which_node_am_i (unsigned int side, unsigned int side_node) const =0

bool	contains_vertex_of (const Elem *e) const

bool	contains_edge_of (const Elem *e) const

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

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

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

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

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

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

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

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

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

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

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

virtual bool	is_remote () const

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

virtual ElemType	type () const =0

virtual unsigned short	dim () const =0

virtual unsigned int	n_nodes () const =0

IntRange< unsigned short >	node_index_range () const

virtual unsigned int	n_nodes_in_child (unsigned int) const

virtual unsigned int	n_sides () const =0

IntRange< unsigned short >	side_index_range () const

unsigned int	n_neighbors () const

virtual unsigned int	n_vertices () const =0

virtual unsigned int	n_edges () const =0

IntRange< unsigned short >	edge_index_range () const

virtual unsigned int	n_faces () const =0

virtual unsigned int	n_children () const =0

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

virtual unsigned int	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

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

virtual std::vector< unsigned int >	nodes_on_side (const unsigned int) const =0

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

virtual bool	is_edge_on_side (const unsigned int e, const unsigned int s) const =0

virtual unsigned int	opposite_side (const unsigned int s) const

virtual unsigned int	opposite_node (const unsigned int n, const unsigned int s) const

virtual unsigned int	n_sub_elem () const =0

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

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

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

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

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

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

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

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

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

std::unique_ptr< Elem >	build_side (const unsigned int i, bool proxy=true) const

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

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

std::unique_ptr< Elem >	build_edge (const unsigned int i) const
	Creates an element coincident with edge `i`. More...

virtual Order	default_order () const =0

virtual Point	centroid () 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

virtual bool	has_affine_map () const

virtual bool	is_linear () const

void	print_info (std::ostream &os=libMesh::out) const
	Prints relevant information about the element. More...

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

bool	active () const

bool	ancestor () const

bool	subactive () const

bool	has_children () const

bool	has_ancestor_children () const

bool	is_ancestor_of (const Elem *descendant) const

const Elem *	parent () const

Elem *	parent ()

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

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

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

virtual unsigned int	n_second_order_adjacent_vertices (const unsigned int n) const

virtual unsigned short int	second_order_adjacent_vertex (const unsigned int n, const unsigned int v) const

virtual std::pair< unsigned short int, unsigned short int >	second_order_child_vertex (const unsigned int n) const

unsigned int	level () const

unsigned int	p_level () const

virtual bool	is_child_on_side (const unsigned int c, const unsigned int s) const =0

const Elem *	raw_child_ptr (unsigned int i) const

const Elem *	child_ptr (unsigned int i) const

Elem *	child_ptr (unsigned int i)

Elem *	child (const unsigned int i) const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

RefinementState	refinement_flag () const

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

RefinementState	p_refinement_flag () const

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

unsigned int	max_descendant_p_level () const

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

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

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

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

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

void	coarsen ()
	Coarsen the element. More...

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

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

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

side_iterator	boundary_sides_begin ()
	Iterator accessor functions. More...

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

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

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

void	clear_dofs ()
	Clear the `DofMap` data structures and return to a pristine state. More...

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

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

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

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

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

dof_id_type	id () const

dof_id_type &	set_id ()

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

unique_id_type	unique_id () const

unique_id_type &	set_unique_id ()

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

bool	valid_processor_id () const

unsigned int	n_systems () const

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

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

unsigned int	n_var_groups (const unsigned int s) const

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

unsigned int	n_vars (const unsigned int s) const

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

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

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

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

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

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

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

std::pair< unsigned int, unsigned 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`. More...

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

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

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

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

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

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

void	debug_buffer () const
	Print our buffer for debugging. More...

void	print_dof_info () const
	Print out info for debugging. More...

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

Static Public Member Functions
static ElemType	second_order_equivalent_type (const ElemType et, const bool full_ordered=true)

static ElemType	first_order_equivalent_type (const ElemType et)

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

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

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

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

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

static void	disable_print_counter_info ()

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

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

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

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

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

static void	disable_print_counter_info ()

Public Attributes
DofObject *	old_dof_object
	This object on the last mesh. More...

Static Public Attributes
static const subdomain_id_type	invalid_subdomain_id
	A static integral constant representing an invalid subdomain id. More...

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

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

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

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

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

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

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

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

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

Protected Member Functions
	Elem (const unsigned int n_nodes, const unsigned int n_sides, Elem parent, Elem elemlinkdata, Node *nodelinkdata)
	Constructor. More...

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

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

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

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

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

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

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

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

Static Protected Member Functions
static dof_id_type	compute_key (dof_id_type n0)

static dof_id_type	compute_key (dof_id_type n0, dof_id_type n1)

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

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

Protected Attributes
Node **	_nodes
	Pointers to the nodes we are connected to. More...

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

Elem **	_children
	Pointers to this element's children. More...

subdomain_id_type	_sbd_id
	The subdomain to which this element belongs. More...

unsigned char	_rflag
	h refinement flag. More...

unsigned char	_pflag
	p refinement flag. More...

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

Static Protected Attributes
static Counts	_counts
	Actually holds the data. More...

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

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

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

static Counts	_counts
	Actually holds the data. More...

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

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

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

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

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

SideIter	_first_side ()
	Side iterator helper functions. More...

SideIter	_last_side ()

Detailed Description

This is the base class from which all geometric element types are derived.

The Elem class provides standard information such as the number of nodes, edges, faces, vertices, children, and neighbors it has, as well as access to (or the ability to construct) these entities.

An Elem has pointers to its Node objects. Some of these nodes live at the vertices of the element, while others may live on edges (and faces in 3D), or interior to the element. The number of nodes in a given element, n_nodes(), is encoded into the name of the class. For example, a Tri3 has three nodes which correspond to the vertices, while a Tri6 has six nodes, three of which are located at vertices, and three which are located at the midpoint of each edge. Nodes on edges, faces, and element interiors are called second-order nodes.

A 1D Elem is an Edge, a 2D Elem is a Face, and a 3D Elem is a Cell. An Elem is composed of a number of sides, which can be accessed as dim-1 dimensional Elem types. For example, a Hex8 is a 3D hexahedral element. A Hex8 has 6 sides, which are Faces of type Quad4.

Author: Benjamin S. Kirk

Date: 2002-2007 The base class for all geometric element types.

Definition at line 101 of file elem.h.

Member Typedef Documentation

◆ ConstNeighborPtrIter

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

Definition at line 325 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 117 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 117 of file reference_counter.h.

◆ NeighborPtrIter

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

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

Definition at line 324 of file elem.h.

◆ Predicate

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

Useful iterator typedefs.

Definition at line 1591 of file elem.h.

Member Enumeration Documentation

◆ RefinementState

enum libMesh::Elem::RefinementState

Enumeration of possible element refinement states.

Enumerator
COARSEN
DO_NOTHING
REFINE
JUST_REFINED
JUST_COARSENED
INACTIVE
COARSEN_INACTIVE
INVALID_REFINEMENTSTATE

Definition at line 1211 of file elem.h.

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

Constructor & Destructor Documentation

◆ Elem() [1/3]

libMesh::Elem::Elem	(	const unsigned int	n_nodes,
		const unsigned int	n_sides,
		Elem *	parent,
		Elem **	elemlinkdata,
		Node **	nodelinkdata
	)

protected

Constructor.

Creates an element with n_nodes nodes, n_sides sides, n_children possible children, and parent p. The constructor allocates the memory necessary to support this data.

Definition at line 1911 of file elem.h.

References _elemlinks, _nodes, libMesh::DofObject::invalid_processor_id, max_n_nodes, p_level(), parent(), libMesh::DofObject::processor_id(), set_p_level(), and subdomain_id().

                                  :
   _nodes(nodelinkdata),
   _elemlinks(elemlinkdata),
 #ifdef LIBMESH_ENABLE_AMR
   _children(nullptr),
 #endif
   _sbd_id(0)
 #ifdef LIBMESH_ENABLE_AMR
   ,
   _rflag(Elem::DO_NOTHING),
   _pflag(Elem::DO_NOTHING),
   _p_level(0)
 #endif
 {
   this->processor_id() = DofObject::invalid_processor_id;
 
   // If this ever legitimately fails we need to increase max_n_nodes
   libmesh_assert_less_equal(nn, max_n_nodes);
 
   // Initialize the nodes data structure
   if (_nodes)
     {
       for (unsigned int n=0; n<nn; n++)
         _nodes[n] = nullptr;
     }
 
   // Initialize the neighbors/parent data structure
   // _elemlinks = new Elem *[ns+1];
 
   if (_elemlinks)
     {
       _elemlinks[0] = p;
 
       for (unsigned int n=1; n<ns+1; n++)
         _elemlinks[n] = nullptr;
     }
 
   // Optionally initialize data from the parent
   if (this->parent() != nullptr)
     {
       this->subdomain_id() = this->parent()->subdomain_id();
       this->processor_id() = this->parent()->processor_id();
     }
 
 #ifdef LIBMESH_ENABLE_AMR
   if (this->parent())
     this->set_p_level(this->parent()->p_level());
 #endif
 }
 
 
 
 inline
 Elem::~Elem()
 {
   // Deleting my parent/neighbor/nodes storage isn't necessary since it's
   // handled by the subclass
 
   // if (_nodes != nullptr)
   //   delete [] _nodes;
   // _nodes = nullptr;
 
   // delete [] _elemlinks;
 
 #ifdef LIBMESH_ENABLE_AMR
 
   // Delete my children's storage
   if (_children != nullptr)
     delete [] _children;
   _children = nullptr;
 
 #endif
 }

◆ Elem() [2/3]

libMesh::Elem::Elem ( Elem && )

delete

Elems are responsible for allocating and deleting their children during refinement, so they cannot be (default) copied or assigned.

We therefore explicitly delete these operations. Note that because _children is a C-style array, an Elem cannot even be safely default move-constructed (we would have to maintain a custom move constructor that explicitly sets _children to nullptr to do this safely).

◆ Elem() [3/3]

libMesh::Elem::Elem ( const Elem & )

delete

◆ ~Elem()

virtual libMesh::Elem::~Elem ( )

virtual

Destructor.

Frees all the memory associated with the element.

Member Function Documentation

◆ _first_side()

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

private

Side iterator helper functions.

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

Definition at line 3083 of file elem.h.

 {
   return SideIter(0, this);
 }

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

protectedvirtual

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

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

◆ _get_parent_indices_cache()

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

protectedvirtual

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

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

◆ _last_side()

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

private

Definition at line 3091 of file elem.h.

References n_neighbors().

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

◆ active()

bool libMesh::Elem::active ( ) const

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

References COARSEN_INACTIVE, INACTIVE, and refinement_flag().

Referenced by max_descendant_p_level(), subactive(), and libMesh::Parallel::sync_element_data_by_parent_id().

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

◆ active_family_tree() [1/2]

void libMesh::Elem::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.

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

◆ active_family_tree() [2/2]

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

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

◆ 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

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

◆ active_family_tree_by_neighbor() [2/2]

void libMesh::Elem::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.

◆ 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

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

◆ 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`
	)

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

◆ 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

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.

◆ 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`
	)

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

◆ add_child() [1/2]

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

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.

◆ add_child() [2/2]

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

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.

◆ add_system()

void libMesh::DofObject::add_system ( )

inherited

Adds an additional system to the DofObject.

◆ ancestor()

bool libMesh::Elem::ancestor ( ) const

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

◆ as_parent_node()

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

virtual

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.

◆ boundary_sides_begin()

side_iterator libMesh::Elem::boundary_sides_begin ( )

Iterator accessor functions.

◆ boundary_sides_end()

side_iterator libMesh::Elem::boundary_sides_end ( )

◆ bracketing_nodes()

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

virtual

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

◆ build()

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

static

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

Referenced by FETest< order, family, elem_type >::setUp().

◆ build_edge()

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

Creates an element coincident with edge i.

Deprecated:: This method will eventually be removed since it hands back a non-const pointer to an edge that could be used to indirectly modify this Elem. Please use the the const-correct build_edge_ptr() function instead.

Definition at line 2420 of file elem.h.

References build_edge_ptr().

 {
   // Call the const version of build_edge_ptr(), and const_cast the result.
   libmesh_deprecated();
   Elem * e = const_cast<Elem *>(this->build_edge_ptr(i).release());
   return std::unique_ptr<Elem>(e);
 }

◆ build_edge_ptr() [1/2]

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

pure virtual

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

The element returned is full-ordered. For example, calling build_edge_ptr(0) on a 20-noded hex will build a 3-noded edge coincident with edge 0 and pass back the pointer. 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.

Implemented in libMesh::Pyramid14, libMesh::Prism18, libMesh::Hex27, libMesh::RemoteElem, libMesh::InfQuad, libMesh::InfHex16, libMesh::Prism15, libMesh::Pyramid13, libMesh::Edge, libMesh::Hex20, libMesh::Tet10, libMesh::InfHex18, libMesh::InfPrism12, libMesh::Tet4, libMesh::InfPrism6, libMesh::InfHex8, libMesh::Hex8, libMesh::NodeElem, libMesh::Prism6, libMesh::Pyramid5, and libMesh::Face.

Referenced by build_edge(), and build_edge_ptr().

◆ build_edge_ptr() [2/2]

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

Definition at line 2406 of file elem.h.

References build_edge_ptr().

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

◆ build_side()

std::unique_ptr< Elem > libMesh::Elem::build_side	(	const unsigned int	i,
		bool	proxy = `true`
	)		const

Returns: A proxy element coincident with side i.

Deprecated:: This method will eventually be removed since it hands back a non-const pointer to a side that could be used to indirectly modify this. Please use the the const-correct build_side_ptr() function instead.

Definition at line 2343 of file elem.h.

References build_side_ptr().

 {
   // Call the const version of build_side_ptr(), and const_cast the result.
   libmesh_deprecated();
   Elem * s = const_cast<Elem *>(this->build_side_ptr(i, proxy).release());
   return std::unique_ptr<Elem>(s);
 }

◆ build_side_ptr() [1/4]

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

pure virtual

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

The element returned is full-ordered, in contrast to the side method. For example, calling build_side_ptr(0) on a 20-noded hex will build a 8-noded quadrilateral coincident with face 0 and pass back the pointer. A std::unique_ptr<Elem> is returned to prevent a memory leak. This way the user need not remember to delete the object.

The second argument, which is true by default, specifies that a "proxy" element (of type Side) will be returned. This type of value is useful because it does not allocate additional memory, and is usually sufficient for FE calculation purposes. If you really need a full-ordered, non-proxy side object, call this function with proxy=false.

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

Implemented in libMesh::RemoteElem, libMesh::Pyramid14, libMesh::Prism18, libMesh::Hex27, libMesh::Quad9, libMesh::Edge, libMesh::Prism15, libMesh::Pyramid13, libMesh::Hex20, libMesh::Tri6, libMesh::Tet10, libMesh::InfHex16, libMesh::Quad8, libMesh::InfQuad6, libMesh::InfHex18, libMesh::Tet4, libMesh::InfPrism12, libMesh::NodeElem, libMesh::Hex8, libMesh::InfPrism6, libMesh::Tri3, libMesh::InfHex8, libMesh::Prism6, libMesh::Pyramid5, libMesh::InfQuad4, and libMesh::Quad4.

Referenced by libMesh::Elem::SideIter::_update_side_ptr(), libMesh::Face::build_edge_ptr(), libMesh::InfQuad::build_edge_ptr(), build_side(), and build_side_ptr().

◆ build_side_ptr() [2/4]

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

Definition at line 2315 of file elem.h.

References build_side_ptr().

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

◆ build_side_ptr() [3/4]

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

pure 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 should not be called with proxy Side elements. 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.

Implemented in libMesh::Pyramid14, libMesh::RemoteElem, libMesh::Prism18, libMesh::Hex27, libMesh::Quad9, libMesh::Edge, libMesh::Prism15, libMesh::Pyramid13, libMesh::Hex20, libMesh::Tri6, libMesh::InfHex16, libMesh::Tet10, libMesh::Quad8, libMesh::InfQuad6, libMesh::InfHex18, libMesh::Tet4, libMesh::InfPrism12, libMesh::InfPrism6, libMesh::NodeElem, libMesh::Hex8, libMesh::Tri3, libMesh::InfHex8, libMesh::Prism6, libMesh::Pyramid5, libMesh::InfQuad4, and libMesh::Quad4.

◆ build_side_ptr() [4/4]

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

Definition at line 2328 of file elem.h.

References build_side_ptr().

 {
   // 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.reset(e.release());
 }

◆ centroid()

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

virtual

Returns: The centroid of the element. The centroid is computed as the average of all the element vertices.

This method is virtual since some derived elements might want to use shortcuts to compute their centroid.

Referenced by A0::interior_assembly(), A1::interior_assembly(), and OutputAssembly::interior_assembly().

◆ child()

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

Returns: A non-constant pointer to the $i^{th}$ child for this element.

Deprecated:: Use the more accurately-named and const correct child_ptr() function instead.

Definition at line 2726 of file elem.h.

References child_ptr().

 {
   // Support the deprecated interface by calling the new,
   // const-correct interface and casting the result to an Elem *.
   libmesh_deprecated();
   return const_cast<Elem *>(this->child_ptr(i));
 }

◆ child_neighbor() [1/2]

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

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

Definition at line 2205 of file elem.h.

References neighbor_ptr_range().

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

◆ child_neighbor() [2/2]

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

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

Definition at line 2217 of file elem.h.

References neighbor_ptr_range().

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

◆ child_ptr() [1/2]

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

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

References _children.

Referenced by child(), libMesh::Parallel::sync_element_data_by_parent_id(), and which_child_am_i().

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

◆ child_ptr() [2/2]

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

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

References _children.

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

◆ child_ref_range() [1/2]

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

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

References _children, and n_children().

Referenced by libMesh::OldSolutionBase< Output, point_output >::check_old_context(), has_ancestor_children(), max_descendant_p_level(), and set_p_level().

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

◆ child_ref_range() [2/2]

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

Definition at line 1887 of file elem.h.

References _children, and n_children().

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

◆ clear_dofs()

void libMesh::DofObject::clear_dofs ( )

inherited

Clear the DofMap data structures and return to a pristine state.

Definition at line 621 of file dof_object.h.

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

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

 {
   // vector swap trick to force deallocation
   index_buffer_t().swap(_idx_buf);
 
   libmesh_assert_equal_to (this->n_systems(), 0);
   libmesh_assert (_idx_buf.empty());
 }

◆ clear_old_dof_object()

void libMesh::DofObject::clear_old_dof_object ( )

inherited

Sets the old_dof_object to nullptr.

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

◆ close_to_point()

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

virtual

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

◆ coarsen()

void libMesh::Elem::coarsen ( )

Coarsen the element.

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

◆ compute_key() [1/4]

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

staticprotected

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

Definition at line 2882 of file elem.h.

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

 {
   return n0;
 }

◆ compute_key() [2/4]

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

staticprotected

Returns: A hash key computed from two node ids.

Definition at line 2890 of file elem.h.

References libMesh::Utility::hashword2(), and swap().

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

◆ compute_key() [3/4]

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

staticprotected

Returns: A hash key computed from three node ids.

Definition at line 2902 of file elem.h.

References libMesh::Utility::hashword(), and swap().

 {
   // Order the numbers such that n0 < n1 < n2.
   // We'll do it in 3 steps like this:
   //
   //     n0         n1                n2
   //     min(n0,n1) max(n0,n1)        n2
   //     min(n0,n1) min(n2,max(n0,n1) max(n2,max(n0,n1)
   //           |\   /|                  |
   //           | \ / |                  |
   //           |  /  |                  |
   //           | /  \|                  |
   //  gb min= min   max              gb max
 
   // Step 1
   if (n0 > n1) std::swap (n0, n1);
 
   // Step 2
   if (n1 > n2) std::swap (n1, n2);
 
   // Step 3
   if (n0 > n1) std::swap (n0, n1);
 
   libmesh_assert ((n0 < n1) && (n1 < n2));
 
   dof_id_type array[3] = {n0, n1, n2};
   return Utility::hashword(array, 3);
 }

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

staticprotected

Returns: A hash key computed from four node ids.

Definition at line 2936 of file elem.h.

References libMesh::Utility::hashword(), and swap().

 {
   // Sort first
   // Step 1
   if (n0 > n1) std::swap (n0, n1);
 
   // Step 2
   if (n2 > n3) std::swap (n2, n3);
 
   // Step 3
   if (n0 > n2) std::swap (n0, n2);
 
   // Step 4
   if (n1 > n3) std::swap (n1, n3);
 
   // Finally sort step 5
   if (n1 > n2) std::swap (n1, n2);
 
   libmesh_assert ((n0 < n1) && (n1 < n2) && (n2 < n3));
 
   dof_id_type array[4] = {n0, n1, n2, n3};
   return Utility::hashword(array, 4);
 }

◆ connectivity()

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

pure virtual

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

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

◆ contains_edge_of()

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

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

◆ contains_point()

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

virtual

Returns: true if the 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::InfHex, libMesh::Tri3, libMesh::InfPrism, and libMesh::InfQuad4.

Referenced by FETest< order, family, elem_type >::testGradU(), FETest< order, family, elem_type >::testGradUComp(), and FETest< order, family, elem_type >::testU().

◆ contains_vertex_of()

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

Returns: true if a vertex of e is contained in this element.

◆ contract()

void libMesh::Elem::contract ( )

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.

◆ debug_buffer()

void libMesh::DofObject::debug_buffer ( ) const

inherited

Print our buffer for debugging.

◆ default_order()

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

pure virtual

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

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

◆ dim()

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

pure virtual

Returns: The dimensionality of the object.

Implemented in libMesh::RemoteElem, libMesh::InfQuad, libMesh::NodeElem, libMesh::InfCell, libMesh::Edge, libMesh::Cell, and libMesh::Face.

Referenced by level().

◆ disable_print_counter_info() [1/2]

static void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

◆ disable_print_counter_info() [2/2]

static void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

◆ dof_number() [1/2]

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

inherited

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

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

Referenced by libMesh::OldSolutionValue< Output, point_output >::eval_at_node(), DofObjectTest< DerivedClass >::testJensEftangBug(), and DofObjectTest< DerivedClass >::testManualDofCalculation().

 {
   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);
 }

◆ 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

inherited

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

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

 {
   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);
 }

◆ edge_index_range()

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

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

Definition at line 2257 of file elem.h.

References n_edges().

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

◆ embedding_matrix()

virtual float libMesh::Elem::embedding_matrix	(	const unsigned int	child_num,
		const unsigned int	child_node_num,
		const unsigned int	parent_node_num
	)		const

pure virtual

Returns: The embedding matrix entry for the requested child.

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

◆ embedding_matrix_version()

virtual unsigned int libMesh::Elem::embedding_matrix_version ( ) const

virtual

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

1701 { return 0; }

◆ enable_print_counter_info() [1/2]

static void libMesh::ReferenceCounter::enable_print_counter_info ( )

staticinherited

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

◆ enable_print_counter_info() [2/2]

static void libMesh::ReferenceCounter::enable_print_counter_info ( )

staticinherited

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

◆ family_tree() [1/2]

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

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

◆ family_tree() [2/2]

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

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

◆ 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

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

◆ family_tree_by_neighbor() [2/2]

void libMesh::Elem::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.

◆ 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

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

◆ family_tree_by_side() [2/2]

void libMesh::Elem::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.

◆ 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

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)

◆ family_tree_by_subneighbor() [2/2]

void libMesh::Elem::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.

◆ find_edge_neighbors() [1/2]

void libMesh::Elem::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.

◆ find_edge_neighbors() [2/2]

void libMesh::Elem::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).

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

◆ find_interior_neighbors() [1/2]

void libMesh::Elem::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.

◆ find_interior_neighbors() [2/2]

void libMesh::Elem::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.

◆ find_point_neighbors() [1/4]

void libMesh::Elem::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.

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.

◆ find_point_neighbors() [2/4]

void libMesh::Elem::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.

◆ find_point_neighbors() [3/4]

void libMesh::Elem::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.

◆ find_point_neighbors() [4/4]

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

Non-const version of function above.

Fills a set of non-const Elem pointers.

◆ first_order_equivalent_type()

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

static

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.

◆ get_info() [1/3]

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

staticinherited

Gets a string containing the reference information.

◆ get_info() [2/3]

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

staticinherited

Gets a string containing the reference information.

◆ get_info() [3/3]

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

Prints relevant information about the element to a string.

◆ get_node()

Node * libMesh::Elem::get_node ( const unsigned int i ) const

Returns: The pointer to local Node i.

Deprecated:: Use the less ambiguously named node_ptr() instead.

Definition at line 2096 of file elem.h.

References node_ptr().

 {
   // This const function has incorrectly returned a non-const pointer
   // for years.  Now that it is reimplemented in terms of the new
   // interface which does return a const pointer, we need to use a
   // const_cast to mimic the old (incorrect) behavior.  This function
   // is now deprecated and eventually will be removed entirely,
   // obviating the need for this ugly cast.
   libmesh_deprecated();
   return const_cast<Node *>(this->node_ptr(i));
 }

◆ get_node_index()

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

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

Definition at line 2112 of file elem.h.

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

 {
   for (unsigned int n=0; n != this->n_nodes(); ++n)
     if (this->_nodes[n] == node_ptr)
       return n;
 
   return libMesh::invalid_uint;
 }

◆ get_nodes()

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

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

Definition at line 2049 of file elem.h.

References _nodes.

 {
   return _nodes;
 }

◆ hack_p_level()

void libMesh::Elem::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.

Definition at line 2867 of file elem.h.

References _p_level, JUST_REFINED, and p_refinement_flag().

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

◆ has_affine_map()

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

virtual

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

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

Definition at line 1001 of file elem.h.

1001 { return false; }

◆ has_ancestor_children()

bool libMesh::Elem::has_ancestor_children ( ) const

Returns: true if the element has any descendants other than its immediate children, false otherwise, or if AMR is disabled.

Definition at line 2570 of file elem.h.

References _children, and child_ref_range().

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

◆ has_children()

bool libMesh::Elem::has_children ( ) const

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

Definition at line 2556 of file elem.h.

References _children.

Referenced by set_child(), subactive(), libMesh::Parallel::sync_element_data_by_parent_id(), and which_child_am_i().

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

◆ has_dofs()

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

inherited

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

Definition at line 913 of file dof_object.h.

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

 {
   if (sys == libMesh::invalid_uint)
     {
       for (unsigned int s=0; s<this->n_systems(); s++)
         if (this->n_vars(s))
           return true;
     }
 
   else
     {
       libmesh_assert_less (sys, this->n_systems());
 
       if (this->n_vars(sys))
         return true;
     }
 
   return false;
 }

◆ has_neighbor()

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

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

Definition at line 2193 of file elem.h.

References neighbor_ptr_range().

Referenced by on_boundary().

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

◆ has_topological_neighbor()

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

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

◆ hmax()

virtual Real libMesh::Elem::hmax ( ) const

virtual

Returns: The maximum vertex separation for the element.

Referenced by libMesh::OldSolutionBase< Output, point_output >::check_old_context().

◆ hmin()

virtual Real libMesh::Elem::hmin ( ) const

virtual

Returns: The minimum vertex separation for the element.

◆ id()

dof_id_type libMesh::DofObject::id ( ) const

inherited

Returns: The id for this DofObject

Definition at line 655 of file dof_object.h.

References libMesh::DofObject::_id, and libMesh::DofObject::valid_id().

Referenced by libMesh::Node::build(), node_id(), libMesh::CompareElemIdsByLevel::operator()(), libMesh::Parallel::sync_dofobject_data_by_id(), libMesh::Parallel::sync_element_data_by_parent_id(), libMesh::Parallel::sync_node_data_by_element_id_once(), and DofObjectTest< DerivedClass >::testSetId().

 {
   libmesh_assert (this->valid_id());
   return _id;
 }

◆ increment_constructor_count() [1/2]

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

protectedinherited

Increments the construction counter.

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

Definition at line 181 of file reference_counter.h.

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

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

 {
   Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
   std::pair<unsigned int, unsigned int> & p = _counts[name];
 
   p.first++;
 }

◆ increment_constructor_count() [2/2]

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

protectedinherited

Increments the construction counter.

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

Definition at line 181 of file reference_counter.h.

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

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

 {
   Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
   std::pair<unsigned int, unsigned int> & p = _counts[name];
 
   p.first++;
 }

◆ increment_destructor_count() [1/2]

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

protectedinherited

Increments the destruction counter.

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

Definition at line 194 of file reference_counter.h.

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

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

 {
   Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
   std::pair<unsigned int, unsigned int> & p = _counts[name];
 
   p.second++;
 }

◆ increment_destructor_count() [2/2]

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

protectedinherited

Increments the destruction counter.

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

Definition at line 194 of file reference_counter.h.

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

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

 {
   Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
   std::pair<unsigned int, unsigned int> & p = _counts[name];
 
   p.second++;
 }

◆ infinite()

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

pure virtual

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

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

Referenced by is_mid_infinite_edge_node().

◆ interior_parent() [1/2]

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

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 is not safe to call if this->dim() == LIBMESH_DIM; in such cases no data storage for an interior parent pointer has been allocated.

◆ interior_parent() [2/2]

Elem* libMesh::Elem::interior_parent ( )

◆ invalidate()

void libMesh::DofObject::invalidate ( )

inherited

Invalidates all the indices for this DofObject.

Definition at line 611 of file dof_object.h.

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

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

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

◆ invalidate_dofs()

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

inherited

Sets all degree of freedom numbers to invalid_id.

Definition at line 575 of file dof_object.h.

References libMesh::DofObject::invalid_id, 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().

 {
   // If the user does not specify the system number...
   if (sys_num >= this->n_systems())
     {
       for (unsigned int s=0; s<this->n_systems(); s++)
         for (unsigned int vg=0; vg<this->n_var_groups(s); vg++)
           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 (unsigned int vg=0; vg<this->n_var_groups(sys_num); vg++)
       if (this->n_comp_group(sys_num,vg))
         this->set_vg_dof_base(sys_num,vg,invalid_id);
 }

◆ invalidate_id()

void libMesh::DofObject::invalidate_id ( )

inherited

Sets the id to invalid_id.

Definition at line 595 of file dof_object.h.

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

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

 {
   this->set_id (invalid_id);
 }

◆ invalidate_processor_id()

void libMesh::DofObject::invalidate_processor_id ( )

inherited

Sets the processor id to invalid_processor_id.

Definition at line 603 of file dof_object.h.

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

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

 {
   this->processor_id (invalid_processor_id);
 }

◆ is_ancestor_of()

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

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

References parent().

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

◆ is_child_on_edge()

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

virtual

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

◆ is_child_on_side()

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

pure virtual

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

Implemented in libMesh::NodeElem, libMesh::RemoteElem, libMesh::InfQuad, libMesh::Tet10, libMesh::Tet4, libMesh::InfHex, libMesh::InfPrism, libMesh::Tri, libMesh::Quad, libMesh::Pyramid, libMesh::Prism, libMesh::Edge, and libMesh::Hex.

◆ is_edge()

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

pure virtual

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

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

◆ is_edge_on_side()

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

pure virtual

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

Implemented in libMesh::NodeElem, libMesh::InfQuad, libMesh::RemoteElem, libMesh::InfHex, libMesh::InfPrism, libMesh::Pyramid, libMesh::Prism, libMesh::Edge, libMesh::Hex, libMesh::Tet, and libMesh::Face.

◆ is_face()

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

pure virtual

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

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

◆ is_linear()

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

virtual

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

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

Definition at line 1007 of file elem.h.

1007 { return false; }

◆ is_mid_infinite_edge_node()

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

virtual

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

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

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

Definition at line 1636 of file elem.h.

References infinite().

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

libMesh::Elem::infinite

virtual bool infinite() const =0

◆ is_node_on_edge()

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

pure virtual

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

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

◆ is_node_on_side()

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

pure virtual

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

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

Referenced by which_side_am_i().

◆ is_remote()

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

virtual

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

569 { return false; }

◆ is_semilocal()

bool libMesh::Elem::is_semilocal ( const processor_id_type my_pid ) const

Returns: true if this element is semilocal to the calling processor, which must specify its rank.

◆ is_vertex()

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

pure virtual

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

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

Referenced by is_vertex_on_child().

◆ is_vertex_on_child()

virtual unsigned int libMesh::Elem::is_vertex_on_child	(	unsigned	int,
		unsigned int	n
	)		const

virtual

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

References is_vertex().

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

libMesh::Elem::is_vertex

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

◆ is_vertex_on_parent()

virtual bool libMesh::Elem::is_vertex_on_parent	(	unsigned int	c,
		unsigned int	n
	)		const

virtual

Returns: true if this element has a vertex at the specified (child-local) node number n of the specified child c.

◆ key() [1/2]

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

pure virtual

Returns: An id associated with the s side of this element. The id is not necessarily unique, but should be close. This is particularly useful in the MeshBase::find_neighbors() routine.

Implemented in libMesh::InfHex18, libMesh::Pyramid14, libMesh::Prism18, libMesh::Hex27, libMesh::InfQuad, libMesh::Tri6, libMesh::Quad8, libMesh::Quad9, libMesh::InfHex, libMesh::Quad, libMesh::InfQuad6, libMesh::InfPrism, libMesh::Edge, libMesh::Hex, libMesh::Pyramid, libMesh::Tri, libMesh::Prism, libMesh::NodeElem, libMesh::Tet, and libMesh::RemoteElem.

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

◆ key() [2/2]

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

virtual

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

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

◆ length()

Real libMesh::Elem::length	(	const unsigned int	n1,
		const unsigned int	n2
	)		const

Returns: The distance between nodes n1 and n2.

Useful for computing the lengths of the sides of elements.

◆ level()

unsigned int libMesh::Elem::level ( ) const

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

References dim(), level(), and parent().

Referenced by level(), libMesh::CompareElemIdsByLevel::operator()(), top_parent(), and which_neighbor_am_i().

 {
 #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
 }

◆ libmesh_assert_valid_neighbors()

void libMesh::Elem::libmesh_assert_valid_neighbors ( ) const

Checks for consistent neighbor links on this element.

◆ libmesh_assert_valid_node_pointers()

void libMesh::Elem::libmesh_assert_valid_node_pointers ( ) const

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

◆ local_node()

unsigned int libMesh::Elem::local_node ( const dof_id_type i ) const

Returns: The local id number of global Node id i, or invalid_uint if Node id i is not local.

Definition at line 2037 of file elem.h.

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

 {
   for (unsigned int n=0; n != this->n_nodes(); ++n)
     if (this->node_id(n) == i)
       return n;
 
   return libMesh::invalid_uint;
 }

◆ loose_bounding_box()

virtual BoundingBox libMesh::Elem::loose_bounding_box ( ) const

virtual

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::Quad9, libMesh::Tri6, libMesh::Quad8, libMesh::Hex8, libMesh::Prism6, libMesh::Tri3, libMesh::Pyramid5, libMesh::Edge3, libMesh::Quad4, libMesh::Edge4, and libMesh::Cell.

◆ make_links_to_me_local()

void libMesh::Elem::make_links_to_me_local ( unsigned int n )

Resets the appropriate neighbor 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.

◆ make_links_to_me_remote()

void libMesh::Elem::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.

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

◆ master_point()

virtual Point libMesh::Elem::master_point ( const unsigned int i ) const

pure virtual

Returns: The Point associated with local Node i, in master element rather than physical coordinates.

Implemented in libMesh::InfQuad, libMesh::RemoteElem, libMesh::Tri, libMesh::Quad, libMesh::InfEdge2, libMesh::InfHex, libMesh::InfPrism, libMesh::Pyramid, libMesh::Edge4, libMesh::Edge2, libMesh::Edge3, libMesh::Tet, libMesh::Hex, and libMesh::Prism.

◆ max_descendant_p_level()

unsigned int libMesh::Elem::max_descendant_p_level ( ) const

Returns: The maximum value of the p-refinement levels of an ancestor element's descendants.

Definition at line 2802 of file elem.h.

References _p_level, active(), child_ref_range(), std::max(), p_level(), and subactive().

 {
   // 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;
 }

◆ min_new_p_level_by_neighbor()

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

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.

◆ min_p_level_by_neighbor()

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

Returns: The minimum p-refinement level of elements which are descended from this element, and which share a side with the active neighbor.

◆ n_children()

virtual unsigned int libMesh::Elem::n_children ( ) const

pure virtual

Returns: The number of children the element that has been derived from this class may have.

Implemented in libMesh::RemoteElem, libMesh::InfQuad, libMesh::InfHex, libMesh::Tri, libMesh::Quad, libMesh::InfPrism, libMesh::Pyramid, libMesh::NodeElem, libMesh::Prism, libMesh::Tet, libMesh::Edge, and libMesh::Hex.

Referenced by child_ref_range(), and which_child_am_i().

◆ n_comp()

unsigned int libMesh::DofObject::n_comp	(	const unsigned int	s,
		const unsigned int	var
	)		const

inherited

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

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

Referenced by libMesh::DofObject::dof_number(), libMesh::OldSolutionValue< Output, point_output >::eval_at_node(), and libMesh::DofObject::n_dofs().

 {
   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));
 }

◆ n_comp_group()

unsigned int libMesh::DofObject::n_comp_group	(	const unsigned int	s,
		const unsigned int	vg
	)		const

inherited

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

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

Referenced by libMesh::DofObject::dof_number(), libMesh::DofObject::invalidate_dofs(), and libMesh::DofObject::n_comp().

 {
   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);
 }

◆ n_dofs()

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

inherited

Returns: The number of degrees of freedom associated with system s for this object. Optionally only counts degrees of freedom for variable number var

Definition at line 633 of file dof_object.h.

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

 {
   libmesh_assert_less (s, this->n_systems());
 
   unsigned int num = 0;
 
   // Count all variables
   if (var == libMesh::invalid_uint)
     for (unsigned int v=0; v<this->n_vars(s); v++)
       num += this->n_comp(s,v);
 
   // Only count specified variable
   else
     num = this->n_comp(s,var);
 
   return num;
 }

◆ n_edges()

virtual unsigned int libMesh::Elem::n_edges ( ) const

pure virtual

Returns: The number of edges the element that has been derived from this class has.

Implemented in libMesh::RemoteElem, libMesh::InfQuad, libMesh::InfHex, libMesh::Tri, libMesh::Quad, libMesh::InfPrism, libMesh::Pyramid, libMesh::NodeElem, libMesh::Prism, libMesh::Tet, libMesh::Edge, and libMesh::Hex.

Referenced by edge_index_range().

◆ n_faces()

virtual unsigned int libMesh::Elem::n_faces ( ) const

pure virtual

Returns: The number of faces the element that has been derived from this class has.

Implemented in libMesh::RemoteElem, libMesh::InfQuad, libMesh::InfHex, libMesh::InfPrism, libMesh::Pyramid, libMesh::NodeElem, libMesh::Prism, libMesh::Tet, libMesh::Edge, libMesh::Hex, and libMesh::Face.

◆ n_neighbors()

unsigned int libMesh::Elem::n_neighbors ( ) const

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

References n_sides().

Referenced by _last_side(), neighbor_ptr(), neighbor_ptr_range(), and set_neighbor().

658 { return this->n_sides(); }

libMesh::Elem::n_sides

virtual unsigned int n_sides() const =0

◆ n_nodes()

virtual unsigned int libMesh::Elem::n_nodes ( ) const

pure virtual

Returns: The number of nodes this element contains.

Implemented in libMesh::RemoteElem, libMesh::Prism15, libMesh::Prism18, libMesh::Hex20, libMesh::Hex27, libMesh::Pyramid14, libMesh::InfHex16, libMesh::InfHex18, libMesh::Pyramid13, libMesh::Tri, libMesh::Tet10, libMesh::Quad, libMesh::InfPrism12, libMesh::Tri6, libMesh::Hex8, libMesh::Tet4, libMesh::InfPrism6, libMesh::Pyramid, libMesh::NodeElem, libMesh::InfHex8, libMesh::Edge4, libMesh::Quad8, libMesh::Quad9, libMesh::Edge3, libMesh::Prism, libMesh::InfQuad6, libMesh::InfQuad4, and libMesh::Edge.

Referenced by get_node_index(), local_node(), libMesh::Hex::master_point(), libMesh::Tet::master_point(), libMesh::InfPrism::master_point(), libMesh::InfHex::master_point(), libMesh::InfQuad::master_point(), n_nodes_in_child(), node_id(), node_index_range(), node_ptr(), node_ref_range(), point(), set_node(), libMesh::Parallel::sync_node_data_by_element_id_once(), and which_side_am_i().

◆ n_nodes_in_child()

virtual unsigned int libMesh::Elem::n_nodes_in_child ( unsigned int ) const

virtual

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

References n_nodes().

627 { return this->n_nodes(); }

libMesh::Elem::n_nodes

virtual unsigned int n_nodes() const =0

◆ n_objects() [1/2]

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

staticinherited

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

Definition at line 83 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects.

84 { return _n_objects; }

libMesh::ReferenceCounter::_n_objects

static Threads::atomic< unsigned int > _n_objects

The number of objects.

Definition: reference_counter.h:130

◆ n_objects() [2/2]

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

staticinherited

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

Definition at line 83 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects.

84 { return _n_objects; }

libMesh::ReferenceCounter::_n_objects

static Threads::atomic< unsigned int > _n_objects

The number of objects.

Definition: reference_counter.h:130

◆ n_second_order_adjacent_vertices()

virtual unsigned int libMesh::Elem::n_second_order_adjacent_vertices ( const unsigned int n ) const

virtual

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::InfHex18, libMesh::Pyramid14, libMesh::Hex27, libMesh::Prism18, libMesh::InfHex16, libMesh::Pyramid13, libMesh::Hex20, libMesh::Prism15, libMesh::Tet10, libMesh::Quad9, libMesh::Tri6, libMesh::InfPrism12, libMesh::Quad8, libMesh::InfQuad6, libMesh::Edge4, and libMesh::Edge3.

◆ n_sides()

virtual unsigned int libMesh::Elem::n_sides ( ) const

pure virtual

Returns: The number of sides the element that has been derived from this class has. In 2D the number of sides is the number of edges, in 3D the number of sides is the number of faces.

Implemented in libMesh::RemoteElem, libMesh::InfQuad, libMesh::Tri, libMesh::Quad, libMesh::InfHex, libMesh::Pyramid, libMesh::NodeElem, libMesh::InfPrism, libMesh::Prism, libMesh::Tet, libMesh::Edge, and libMesh::Hex.

Referenced by n_neighbors(), side_index_range(), simple_build_side_ptr(), simple_side_ptr(), which_neighbor_am_i(), and which_side_am_i().

◆ n_sub_elem()

virtual unsigned int libMesh::Elem::n_sub_elem ( ) const

pure virtual

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::RemoteElem, libMesh::NodeElem, libMesh::Pyramid14, libMesh::InfHex16, libMesh::InfHex18, libMesh::Prism15, libMesh::Prism18, libMesh::Pyramid13, libMesh::Hex20, libMesh::Hex27, libMesh::InfPrism12, libMesh::Tet10, libMesh::InfPrism6, libMesh::InfHex8, libMesh::Tri6, libMesh::Hex8, libMesh::Tet4, libMesh::InfQuad6, libMesh::InfEdge2, libMesh::InfQuad4, libMesh::Edge4, libMesh::Quad8, libMesh::Quad9, libMesh::Tri3, libMesh::Edge3, libMesh::Prism6, libMesh::Pyramid5, libMesh::Quad4, and libMesh::Edge2.

◆ n_systems()

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

inherited

Returns: The number of systems associated with this DofObject

Definition at line 749 of file dof_object.h.

References libMesh::DofObject::_idx_buf.

 {
   return _idx_buf.empty() ?
     0 : cast_int<unsigned int>(_idx_buf[0]);
 }

◆ n_var_groups()

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

inherited

Returns: The number of VariableGroup variable groups associated with system s for this DofObject

Definition at line 758 of file dof_object.h.

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

Referenced by libMesh::DofObject::dof_number(), libMesh::DofObject::invalidate_dofs(), libMesh::DofObject::n_comp_group(), libMesh::DofObject::n_vars(), libMesh::DofObject::set_vg_dof_base(), DofObjectTest< DerivedClass >::testSetNVariableGroups(), libMesh::DofObject::var_to_vg(), libMesh::DofObject::var_to_vg_and_offset(), and libMesh::DofObject::vg_dof_base().

 {
   libmesh_assert_less (s, this->n_systems());
 
   return (this->end_idx(s) - this->start_idx(s)) / 2;
 }

◆ n_vars() [1/2]

unsigned int libMesh::DofObject::n_vars	(	const unsigned int	s,
		const unsigned int	vg
	)		const

inherited

Returns: The number of Variable variables associated with VariableGroup vg in system s for this DofObject

Definition at line 768 of file dof_object.h.

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

Referenced by libMesh::DofObject::dof_number(), libMesh::OldSolutionValue< Output, point_output >::eval_at_node(), libMesh::DofObject::has_dofs(), libMesh::DofObject::n_comp(), libMesh::DofObject::n_dofs(), libMesh::DofObject::n_vars(), libMesh::DofObject::system_var_to_vg_var(), DofObjectTest< DerivedClass >::testSetNVariableGroups(), libMesh::DofObject::var_to_vg(), and libMesh::DofObject::var_to_vg_and_offset().

 {
   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);
 }

◆ n_vars() [2/2]

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

inherited

Returns: The number of Variable variables associated with system s for this DofObject

Definition at line 785 of file dof_object.h.

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

 {
   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;
 }

◆ n_vertices()

virtual unsigned int libMesh::Elem::n_vertices ( ) const

pure virtual

Returns: The number of vertices the element that has been derived from this class has.

Implemented in libMesh::RemoteElem, libMesh::InfQuad, libMesh::Tri, libMesh::Quad, libMesh::InfHex, libMesh::Pyramid, libMesh::NodeElem, libMesh::InfPrism, libMesh::Prism, libMesh::Tet, libMesh::Edge, and libMesh::Hex.

Referenced by libMesh::InfCell::origin().

◆ neighbor()

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

Deprecated:: Use the const-correct neighbor_ptr() function instead.

Definition at line 2171 of file elem.h.

References neighbor_ptr().

 {
   // Support the deprecated interface by calling the new,
   // const-correct interface and casting the result to an Elem *.
   libmesh_deprecated();
   return const_cast<Elem *>(this->neighbor_ptr(i));
 }

◆ neighbor_ptr() [1/2]

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

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

References _elemlinks, and n_neighbors().

Referenced by neighbor(), libMesh::Elem::SideIter::side_on_boundary(), and which_neighbor_am_i().

 {
   libmesh_assert_less (i, this->n_neighbors());
 
   return _elemlinks[i+1];
 }

◆ neighbor_ptr() [2/2]

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

Returns: A non-const pointer to the $i^{th}$ neighbor of this element.

Definition at line 2160 of file elem.h.

References _elemlinks, and n_neighbors().

 {
   libmesh_assert_less (i, this->n_neighbors());
 
   return _elemlinks[i+1];
 }

◆ neighbor_ptr_range() [1/2]

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

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

References _elemlinks, and n_neighbors().

Referenced by child_neighbor(), and has_neighbor().

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

◆ neighbor_ptr_range() [2/2]

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

Definition at line 3123 of file elem.h.

References _elemlinks, and n_neighbors().

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

◆ node()

dof_id_type libMesh::Elem::node ( const unsigned int i ) const

Returns: The global id number of local Node i.

Deprecated:: Use the less ambiguously named node_id() instead.

Definition at line 2027 of file elem.h.

References node_id().

 {
   libmesh_deprecated();
   return this->node_id(i);
 }

◆ node_id()

dof_id_type libMesh::Elem::node_id ( const unsigned int i ) const

Returns: The global id number of local Node i.

Definition at line 2014 of file elem.h.

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

Referenced by libMesh::Edge::key(), local_node(), and node().

 {
   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();
 }

◆ node_index_range()

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

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

Definition at line 2248 of file elem.h.

References n_nodes().

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

◆ node_ptr() [1/2]

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

Returns: A const pointer to local Node i.

Definition at line 2057 of file elem.h.

References _nodes, and n_nodes().

Referenced by get_node(), get_node_index(), node_ref(), simple_build_side_ptr(), and simple_side_ptr().

 {
   libmesh_assert_less (i, this->n_nodes());
   libmesh_assert(_nodes[i]);
 
   return _nodes[i];
 }

◆ node_ptr() [2/2]

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

Returns: A non-const pointer to local Node i.

Definition at line 2068 of file elem.h.

References _nodes, and n_nodes().

 {
   libmesh_assert_less (i, this->n_nodes());
   libmesh_assert(_nodes[i]);
 
   return _nodes[i];
 }

◆ node_ref() [1/2]

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

Returns: A const reference to local Node i.

Definition at line 2079 of file elem.h.

References node_ptr().

Referenced by libMesh::Parallel::sync_node_data_by_element_id_once().

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

◆ node_ref() [2/2]

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

Returns: A writable reference to local Node i.

Definition at line 2087 of file elem.h.

References node_ptr().

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

◆ node_ref_range() [1/2]

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

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

References _nodes, and n_nodes().

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

◆ node_ref_range() [2/2]

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

Definition at line 2239 of file elem.h.

References _nodes, and n_nodes().

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

◆ nodes_on_side()

virtual std::vector<unsigned int> libMesh::Elem::nodes_on_side ( const unsigned int ) const

pure virtual

Returns: the (local) node numbers on the specified side

Implemented in libMesh::NodeElem, libMesh::Edge, libMesh::RemoteElem, libMesh::InfHex18, libMesh::Pyramid14, libMesh::InfHex16, libMesh::Prism15, libMesh::Prism18, libMesh::Pyramid13, libMesh::Hex20, libMesh::Hex27, libMesh::InfPrism12, libMesh::Tet10, libMesh::InfPrism6, libMesh::InfHex8, libMesh::Tri6, libMesh::Hex8, libMesh::Tet4, libMesh::InfQuad6, libMesh::InfEdge2, libMesh::InfQuad4, libMesh::Quad8, libMesh::Quad9, libMesh::Tri3, libMesh::Prism6, libMesh::Pyramid5, and libMesh::Quad4.

◆ nullify_neighbors()

void libMesh::Elem::nullify_neighbors ( )

Replaces this element with nullptr for all of its neighbors.

This is useful when deleting an element.

◆ on_boundary()

bool libMesh::Elem::on_boundary ( ) const

Returns: true if this element has a side coincident with a boundary (indicated by a nullptr neighbor), false otherwise.

Definition at line 2432 of file elem.h.

References has_neighbor().

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

◆ operator=() [1/2]

Elem& libMesh::Elem::operator= ( const Elem & )

delete

◆ operator=() [2/2]

Elem& libMesh::Elem::operator= ( Elem && )

delete

◆ operator==()

bool libMesh::Elem::operator== ( const Elem & rhs ) const

Returns: true if two elements are identical, 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.

◆ opposite_node()

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

virtual

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

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

◆ opposite_side()

virtual unsigned int libMesh::Elem::opposite_side ( const unsigned int s ) const

virtual

Returns: The side number opposite to s (for a tensor product element), or throws an error otherwise.

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

◆ origin()

virtual Point libMesh::Elem::origin ( ) const

virtual

Returns: The origin for an infinite element.

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

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

Definition at line 1645 of file elem.h.

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

◆ p_level()

unsigned int libMesh::Elem::p_level ( ) const

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

References _p_level.

Referenced by Elem(), max_descendant_p_level(), set_p_level(), and set_p_refinement_flag().

 {
 #ifdef LIBMESH_ENABLE_AMR
   return _p_level;
 #else
   return 0;
 #endif
 }

◆ p_refinement_flag()

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

Returns: The value of the p-refinement flag for the element.

Definition at line 2782 of file elem.h.

References _pflag.

Referenced by hack_p_level().

 {
   return static_cast<RefinementState>(_pflag);
 }

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

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

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

◆ parent() [1/2]

const Elem * libMesh::Elem::parent ( ) const

Returns: A const pointer to the element's parent, or nullptr if the element was not created via refinement.

Definition at line 2607 of file elem.h.

References _elemlinks.

Referenced by libMesh::OldSolutionBase< Output, point_output >::check_old_context(), Elem(), is_ancestor_of(), level(), set_p_level(), subactive(), libMesh::Parallel::sync_element_data_by_parent_id(), top_parent(), and which_neighbor_am_i().

 {
   return _elemlinks[0];
 }

◆ parent() [2/2]

Elem * libMesh::Elem::parent ( )

Returns: A pointer to the element's parent, or nullptr if the element was not created via refinement.

Definition at line 2615 of file elem.h.

References _elemlinks.

 {
   return _elemlinks[0];
 }

◆ parent_bracketing_nodes()

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

virtual

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

◆ point() [1/2]

const Point & libMesh::Elem::point ( const unsigned int i ) const

Returns: The Point associated with local Node i.

Definition at line 1992 of file elem.h.

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

Referenced by libMesh::InfCell::origin(), libMesh::InfEdge2::origin(), libMesh::InfQuad::origin(), and which_side_am_i().

 {
   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];
 }

◆ point() [2/2]

Point & libMesh::Elem::point ( const unsigned int i )

Returns: The Point associated with local Node i as a writable reference.

Definition at line 2004 of file elem.h.

References _nodes, and n_nodes().

 {
   libmesh_assert_less (i, this->n_nodes());
 
   return *_nodes[i];
 }

◆ point_test()

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

private

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

◆ print_dof_info()

void libMesh::DofObject::print_dof_info ( ) const

inherited

Print out info for debugging.

◆ print_info() [1/3]

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

staticinherited

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

◆ print_info() [2/3]

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

staticinherited

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

◆ print_info() [3/3]

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

Prints relevant information about the element.

Referenced by libMesh::operator<<().

◆ processor_id() [1/3]

processor_id_type libMesh::DofObject::processor_id ( ) const

inherited

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

References libMesh::DofObject::_processor_id.

Referenced by Elem(), libMesh::DofObject::invalidate_processor_id(), libMesh::DofObject::processor_id(), libMesh::Parallel::sync_dofobject_data_by_id(), libMesh::Parallel::sync_element_data_by_parent_id(), libMesh::Parallel::sync_node_data_by_element_id_once(), DofObjectTest< DerivedClass >::testInvalidateProcId(), DofObjectTest< DerivedClass >::testSetProcId(), and DofObjectTest< DerivedClass >::testValidProcId().

 {
   return _processor_id;
 }

◆ processor_id() [2/3]

processor_id_type & libMesh::DofObject::processor_id ( )

inherited

Returns: The processor that this DofObject belongs to as a writable reference.

Definition at line 725 of file dof_object.h.

References libMesh::DofObject::_processor_id.

 {
   return _processor_id;
 }

◆ processor_id() [3/3]

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

inherited

Sets the processor_id for this DofObject.

Definition at line 733 of file dof_object.h.

References libMesh::DofObject::processor_id().

 {
   this->processor_id() = pid;
 }

◆ qual_bounds()

virtual std::pair<Real,Real> libMesh::Elem::qual_bounds ( const ElemQuality ) const

virtual

Returns: The suggested quality bounds for the Elem based on quality measure q.

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

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

Definition at line 961 of file elem.h.

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

◆ quality()

virtual Real libMesh::Elem::quality ( const ElemQuality q ) const

virtual

Returns: A quantitative assessment of element quality based on the quality metric q specified by the user.

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

◆ raw_child_ptr()

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

Returns: A constant pointer to the $i^{th}$ child for this element. For internal use only - skips assertions about null pointers.

Definition at line 2697 of file elem.h.

References _children.

 {
   if (!_children)
     return nullptr;
 
   return _children[i];
 }

◆ reference_elem()

const Elem* libMesh::Elem::reference_elem ( ) const

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

◆ refine()

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

virtual

Refine the element.

◆ refinement_flag()

Elem::RefinementState libMesh::Elem::refinement_flag ( ) const

Returns: The value of the refinement flag for the element.

Definition at line 2766 of file elem.h.

References _rflag.

Referenced by active(), and libMesh::OldSolutionBase< Output, point_output >::check_old_context().

 {
   return static_cast<RefinementState>(_rflag);
 }

◆ remove_links_to_me()

void libMesh::Elem::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.

Used by the library before an element is deleted from a mesh.

◆ replace_child()

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

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

◆ second_order_adjacent_vertex()

virtual unsigned short int libMesh::Elem::second_order_adjacent_vertex	(	const unsigned int	n,
		const unsigned int	v
	)		const

virtual

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::InfHex18, libMesh::Pyramid14, libMesh::Hex27, libMesh::Prism18, libMesh::InfHex16, libMesh::Hex20, libMesh::Prism15, libMesh::Tet10, libMesh::Pyramid13, libMesh::Quad9, libMesh::Tri6, libMesh::InfPrism12, libMesh::Quad8, libMesh::InfQuad6, libMesh::Edge3, and libMesh::Edge4.

◆ second_order_child_vertex()

virtual std::pair<unsigned short int, unsigned short int> libMesh::Elem::second_order_child_vertex ( const unsigned int n ) const

virtual

Returns: A pair (c,v), where c == child index, and v == element-local index of the 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::InfHex18, libMesh::Hex27, libMesh::Prism18, libMesh::InfHex16, libMesh::Hex20, libMesh::Prism15, libMesh::Tet10, libMesh::Quad9, libMesh::Tri6, libMesh::InfPrism12, libMesh::Quad8, libMesh::InfQuad6, and libMesh::Edge3.

◆ second_order_equivalent_type()

static ElemType libMesh::Elem::second_order_equivalent_type	(	const ElemType	et,
		const bool	full_ordered = `true`
	)

static

Returns: The element type of the associated second-order element, or INVALID_ELEM for second-order or other 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.

◆ set_buffer()

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

inherited

Definition at line 535 of file dof_object.h.

References libMesh::DofObject::_idx_buf.

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

536 { _idx_buf = buf; }

libMesh::DofObject::_idx_buf

index_buffer_t _idx_buf

Definition: dof_object.h:508

◆ set_child()

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

private

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

References _children, and has_children().

 {
   libmesh_assert (this->has_children());
 
   _children[c] = elem;
 }

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

◆ set_id() [1/2]

dof_id_type & libMesh::DofObject::set_id ( )

inherited

Returns: The id for this DofObject as a writable reference.

Definition at line 664 of file dof_object.h.

References libMesh::DofObject::_id.

Referenced by libMesh::DofObject::invalidate_id(), libMesh::Node::Node(), libMesh::RemoteElem::RemoteElem(), libMesh::DofObject::set_id(), DofObjectTest< DerivedClass >::testInvalidateId(), DofObjectTest< DerivedClass >::testSetId(), and DofObjectTest< DerivedClass >::testValidId().

 {
   return _id;
 }

◆ set_id() [2/2]

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

inherited

Sets the id for this DofObject.

Definition at line 151 of file dof_object.h.

References libMesh::DofObject::set_id().

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

libMesh::DofObject::set_id

dof_id_type & set_id()

Definition: dof_object.h:664

◆ set_interior_parent()

void libMesh::Elem::set_interior_parent ( Elem * p )

Sets the pointer to the element's interior_parent.

Dangerous! Only use this if you know what you are doing!

Referenced by libMesh::Edge::Edge(), libMesh::Hex::Hex(), libMesh::InfHex::InfHex(), libMesh::InfQuad::InfQuad(), libMesh::NodeElem::NodeElem(), libMesh::Prism::Prism(), libMesh::Pyramid::Pyramid(), libMesh::Quad::Quad(), libMesh::Tet::Tet(), and libMesh::Tri::Tri().

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

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

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

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

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

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

◆ set_neighbor()

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

Assigns n as the $i^{th}$ neighbor.

Definition at line 2183 of file elem.h.

References _elemlinks, and n_neighbors().

 {
   libmesh_assert_less (i, this->n_neighbors());
 
   _elemlinks[i+1] = n;
 }

◆ set_node()

Node *& libMesh::Elem::set_node ( const unsigned int i )

virtual

Returns: The pointer to local Node i as a writable reference.

Reimplemented in libMesh::RemoteElem.

Definition at line 2124 of file elem.h.

References _nodes, and n_nodes().

Referenced by libMesh::RemoteElem::set_node().

 {
   libmesh_assert_less (i, this->n_nodes());
 
   return _nodes[i];
 }

◆ set_old_dof_object()

void libMesh::DofObject::set_old_dof_object ( )

inherited

Sets the old_dof_object to a copy of this.

◆ set_p_level()

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

Sets the value of the p-refinement level for the element.

Note: The maximum p-refinement level is currently 255.

Definition at line 2820 of file elem.h.

References _p_level, child_ref_range(), JUST_COARSENED, JUST_REFINED, std::min(), p_level(), parent(), set_p_level(), and set_p_refinement_flag().

Referenced by Elem(), and set_p_level().

 {
   // 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;
         }
     }
 
   _p_level = cast_int<unsigned char>(p);
 }

◆ set_p_refinement_flag()

void libMesh::Elem::set_p_refinement_flag ( const RefinementState pflag )

Sets the value of the p-refinement flag for the element.

Definition at line 2790 of file elem.h.

References _pflag, JUST_REFINED, and p_level().

Referenced by set_p_level().

 {
   if (this->p_level() == 0)
     libmesh_assert_not_equal_to
       (pflag, Elem::JUST_REFINED);
 
   _pflag = cast_int<unsigned char>(pflag);
 }

◆ set_parent()

void libMesh::Elem::set_parent ( Elem * p )

Sets the pointer to the element's parent.

Dangerous! Only use this if you know what you are doing!

Definition at line 2623 of file elem.h.

References _elemlinks.

 {
   _elemlinks[0] = p;
 }

◆ set_refinement_flag()

void libMesh::Elem::set_refinement_flag ( const RefinementState rflag )

Sets the value of the refinement flag for the element.

Definition at line 2774 of file elem.h.

References _rflag.

 {
   _rflag = cast_int<RefinementState>(rflag);
 }

◆ set_unique_id()

unique_id_type & libMesh::DofObject::set_unique_id ( )

inherited

Returns: The globally unique_id for this DofObject as a writable reference.

Definition at line 685 of file dof_object.h.

References libMesh::DofObject::_unique_id.

 {
 #ifdef LIBMESH_ENABLE_UNIQUE_ID
   return _unique_id;
 #else
   libmesh_not_implemented();
 #endif
 }

◆ set_vg_dof_base()

void libMesh::DofObject::set_vg_dof_base	(	const unsigned int	s,
		const unsigned int	vg,
		const dof_id_type	db
	)

inherited

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

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

Referenced by libMesh::DofObject::invalidate_dofs(), and DofObjectTest< DerivedClass >::testManualDofCalculation().

 {
   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);
 }

◆ side()

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

Returns: A proxy element coincident with side i.

Deprecated:: This method will eventually be removed since it hands back a non-const pointer to a side that could be used to indirectly modify this. Please use the the const-correct side_ptr() function instead.

Definition at line 2302 of file elem.h.

References side_ptr().

Referenced by simple_build_side_ptr(), and simple_side_ptr().

 {
   // Call the const version of side_ptr(), and const_cast the result.
   libmesh_deprecated();
   Elem * s = const_cast<Elem *>(this->side_ptr(i).release());
   return std::unique_ptr<Elem>(s);
 }

◆ side_index_range()

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

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

Definition at line 2266 of file elem.h.

References n_sides().

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

◆ side_ptr() [1/4]

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

pure virtual

Returns: A proxy element coincident with side i.

Note: This method returns the minimum element necessary to uniquely identify the side. For example, the side of a hexahedron is always returned as a 4-noded quadrilateral, regardless of what type of hex you are dealing with. If you want the full-ordered face (i.e. a 9-noded quad face for a 27-noded hexahedron) use the build_side method.; The const version of this function is non-virtual; it simply calls the virtual non-const version and const_casts the return type.

Implemented in libMesh::RemoteElem, libMesh::InfQuad, libMesh::Quad, libMesh::InfHex, libMesh::InfPrism, libMesh::Edge, libMesh::Tri, libMesh::Hex, libMesh::Pyramid, libMesh::Prism, libMesh::NodeElem, and libMesh::Tet.

Referenced by side(), and side_ptr().

◆ side_ptr() [2/4]

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

Definition at line 2275 of file elem.h.

References side_ptr().

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

◆ side_ptr() [3/4]

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

pure 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 should not be called with proxy Side elements. This will cause side to be a minimum-ordered element, even if it is handed a higher-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.

Implemented in libMesh::RemoteElem, libMesh::InfQuad, libMesh::Quad, libMesh::InfHex, libMesh::InfPrism, libMesh::Edge, libMesh::Tri, libMesh::Hex, libMesh::Pyramid, libMesh::Prism, libMesh::NodeElem, and libMesh::Tet.

◆ side_ptr() [4/4]

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

Definition at line 2288 of file elem.h.

References side_ptr().

 {
   // 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.reset(e.release());
 }

◆ simple_build_side_ptr()

template<typename Subclass >

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

protected

An implementation for simple (all sides equal) elements.

Definition at line 2357 of file elem.h.

References n_sides(), node_ptr(), side(), and subdomain_id().

 {
   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, false);
     }
   else
     {
       side->subdomain_id() = this->subdomain_id();
 
       for (auto n : side->node_index_range())
         side->set_node(n) = this->node_ptr(Subclass::side_nodes_map[i][n]);
     }
 }

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

protected

An implementation for simple (all sides equal) elements.

Definition at line 2382 of file elem.h.

References n_sides(), node_ptr(), side(), and subdomain_id().

 {
   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]);
     }
 }

◆ subactive()

bool libMesh::Elem::subactive ( ) const

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

Definition at line 2536 of file elem.h.

References active(), has_children(), and parent().

Referenced by max_descendant_p_level().

 {
 #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;
 }

◆ subdomain_id() [1/2]

subdomain_id_type libMesh::Elem::subdomain_id ( ) const

Returns: The subdomain that this element belongs to.

Definition at line 2134 of file elem.h.

References _sbd_id.

Referenced by Elem(), simple_build_side_ptr(), and simple_side_ptr().

 {
   return _sbd_id;
 }

◆ subdomain_id() [2/2]

subdomain_id_type & libMesh::Elem::subdomain_id ( )

Returns: The subdomain that this element belongs to as a writable reference.

Definition at line 2142 of file elem.h.

References _sbd_id.

 {
   return _sbd_id;
 }

◆ top_parent()

const Elem * libMesh::Elem::top_parent ( ) const

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

References level(), and parent().

 {
   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;
 }

◆ 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

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.

◆ topological_neighbor() [2/2]

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

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.

◆ total_family_tree() [1/2]

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

Same as the family_tree() member, but also adds any subactive descendants.

◆ total_family_tree() [2/2]

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

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

◆ 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

Same as the family_tree_by_neighbor() member, but also adds any subactive descendants.

◆ total_family_tree_by_neighbor() [2/2]

void libMesh::Elem::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.

◆ 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

Same as the family_tree_by_subneighbor() member, but also adds any subactive descendants.

◆ 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`
	)

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

◆ type()

virtual ElemType libMesh::Elem::type ( ) const

pure virtual

Returns: The type of element that has been derived from this base class.

Implemented in libMesh::NodeElem, libMesh::Edge4, libMesh::Edge3, libMesh::Edge2, libMesh::InfEdge2, libMesh::RemoteElem, libMesh::Pyramid14, libMesh::InfHex16, libMesh::InfHex18, libMesh::Pyramid13, libMesh::Prism15, libMesh::Prism18, libMesh::Hex20, libMesh::Hex27, libMesh::InfPrism12, libMesh::InfPrism6, libMesh::InfHex8, libMesh::Tet10, libMesh::InfQuad6, libMesh::InfQuad4, libMesh::Tri3, libMesh::Tri6, libMesh::Hex8, libMesh::Tet4, libMesh::Prism6, libMesh::Pyramid5, libMesh::Quad4, libMesh::Quad8, libMesh::Quad9, libMesh::Tri3Subdivision, libMesh::QuadShell4, libMesh::QuadShell8, and libMesh::TriShell3.

◆ unique_id()

unique_id_type libMesh::DofObject::unique_id ( ) const

inherited

Returns: The globally unique_id for this DofObject

Definition at line 672 of file dof_object.h.

References libMesh::DofObject::_unique_id, libMesh::DofObject::invalid_unique_id, and libMesh::DofObject::valid_unique_id().

 {
 #ifdef LIBMESH_ENABLE_UNIQUE_ID
   libmesh_assert (this->valid_unique_id());
   return _unique_id;
 #else
   return invalid_unique_id;
 #endif
 }

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

◆ unpackable_indexing_size()

static 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?

◆ valid_id()

bool libMesh::DofObject::valid_id ( ) const

inherited

Returns: true if this DofObject has a valid id set, false otherwise.

Definition at line 697 of file dof_object.h.

References libMesh::DofObject::_id, and libMesh::DofObject::invalid_id.

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

 {
   return (DofObject::invalid_id != _id);
 }

◆ valid_processor_id()

bool libMesh::DofObject::valid_processor_id ( ) const

inherited

Returns: true if this DofObject has a valid id set, false otherwise.

Definition at line 741 of file dof_object.h.

References libMesh::DofObject::_processor_id, and libMesh::DofObject::invalid_processor_id.

Referenced by DofObjectTest< DerivedClass >::testInvalidateProcId(), and DofObjectTest< DerivedClass >::testValidProcId().

 {
   return (DofObject::invalid_processor_id != _processor_id);
 }

◆ valid_unique_id()

bool libMesh::DofObject::valid_unique_id ( ) const

inherited

Returns: true if this DofObject has a valid unique_id set, false otherwise.

Definition at line 705 of file dof_object.h.

References libMesh::DofObject::_unique_id, and libMesh::DofObject::invalid_unique_id.

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

 {
 #ifdef LIBMESH_ENABLE_UNIQUE_ID
   return (DofObject::invalid_unique_id != _unique_id);
 #else
   return false;
 #endif
 }

◆ 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

inherited

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

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

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

 {
   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;
     }
 }

◆ vg_dof_base()

dof_id_type libMesh::DofObject::vg_dof_base	(	const unsigned int	s,
		const unsigned int	vg
	)		const

inherited

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

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

Referenced by libMesh::DofObject::set_vg_dof_base(), and DofObjectTest< DerivedClass >::testManualDofCalculation().

 {
   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 (std:size_t i=0; i<_idx_buf.size(); i++)
   //     std::cout << _idx_buf[i] << " ";
   //   std::cout << "]\n";
   // #endif
 
   return _idx_buf[start_idx_sys + 2*vg + 1];
 }

◆ volume()

virtual Real libMesh::Elem::volume ( ) const

virtual

Returns: The (length/area/volume) of the geometric element.

Reimplemented in libMesh::Hex27, libMesh::Prism18, libMesh::Pyramid14, libMesh::Hex20, libMesh::Prism15, libMesh::Tet10, libMesh::Pyramid13, libMesh::Quad9, libMesh::Tri6, libMesh::Quad8, libMesh::Tet4, libMesh::Hex8, libMesh::Edge4, libMesh::Prism6, libMesh::Pyramid5, libMesh::Tri3, libMesh::Edge3, libMesh::Quad4, and libMesh::Edge2.

◆ which_child_am_i()

unsigned int libMesh::Elem::which_child_am_i ( const Elem * e ) const

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

References child_ptr(), has_children(), libMesh::invalid_uint, and n_children().

Referenced by libMesh::Parallel::sync_element_data_by_parent_id().

 {
   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;
 }

◆ which_neighbor_am_i()

unsigned int libMesh::Elem::which_neighbor_am_i ( const Elem * e ) const

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

References libMesh::invalid_uint, level(), n_sides(), neighbor_ptr(), and parent().

 {
   libmesh_assert(e);
 
   const Elem * eparent = e;
 
   while (eparent->level() > this->level())
     {
       eparent = eparent->parent();
       libmesh_assert(eparent);
     }
 
   for (unsigned int s=0, n_s = this->n_sides(); s != n_s; ++s)
     if (this->neighbor_ptr(s) == eparent)
       return s;
 
   return libMesh::invalid_uint;
 }

◆ which_node_am_i()

virtual unsigned int libMesh::Elem::which_node_am_i	(	unsigned int	side,
		unsigned int	side_node
	)		const

pure virtual

Returns: The local node id for node side_node on side side of this Elem. Simply relies on the side_nodes_map for each of the derived types. For example, Tri3::which_node_am_i(0, 0) -> 0 Tri3::which_node_am_i(0, 1) -> 1 Tri3::which_node_am_i(1, 0) -> 1 Tri3::which_node_am_i(1, 1) -> 2 etc...

Implemented in libMesh::InfHex18, libMesh::Pyramid14, libMesh::Prism18, libMesh::Hex27, libMesh::InfQuad, libMesh::Quad9, libMesh::Quad, libMesh::Tri6, libMesh::Prism15, libMesh::Pyramid13, libMesh::Hex20, libMesh::Tet10, libMesh::Quad8, libMesh::InfHex, libMesh::InfHex16, libMesh::InfQuad6, libMesh::InfPrism, libMesh::Edge, libMesh::Tri, libMesh::Hex, libMesh::InfPrism12, libMesh::Pyramid, libMesh::Prism, libMesh::NodeElem, libMesh::Tet, and libMesh::RemoteElem.

◆ which_side_am_i()

unsigned int libMesh::Elem::which_side_am_i ( const Elem * e ) const

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

References libMesh::invalid_uint, is_node_on_side(), n_nodes(), n_sides(), and point().

 {
   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;
 }

◆ write_connectivity()

void libMesh::Elem::write_connectivity	(	std::ostream &	out,
		const IOPackage	iop
	)		const

Writes the element connectivity for various IO packages to the passed ostream "out".

Not virtual, since it is implemented in the base class.

Member Data Documentation

◆ _children

Elem** libMesh::Elem::_children

protected

Pointers to this element's children.

Definition at line 1807 of file elem.h.

Referenced by child_ptr(), child_ref_range(), has_ancestor_children(), has_children(), raw_child_ptr(), and set_child().

◆ _counts [1/2]

Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

Definition at line 122 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::increment_constructor_count(), and libMesh::ReferenceCounter::increment_destructor_count().

◆ _counts [2/2]

Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

Definition at line 122 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::increment_constructor_count(), and libMesh::ReferenceCounter::increment_destructor_count().

◆ _elemlinks

Elem** libMesh::Elem::_elemlinks

protected

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

Definition at line 1801 of file elem.h.

Referenced by Elem(), neighbor_ptr(), neighbor_ptr_range(), parent(), set_neighbor(), and set_parent().

◆ _enable_print_counter [1/2]

bool libMesh::ReferenceCounter::_enable_print_counter

staticprotectedinherited

Flag to control whether reference count information is printed when print_info is called.

Definition at line 141 of file reference_counter.h.

◆ _enable_print_counter [2/2]

bool libMesh::ReferenceCounter::_enable_print_counter

staticprotectedinherited

Flag to control whether reference count information is printed when print_info is called.

Definition at line 141 of file reference_counter.h.

◆ _mutex [1/2]

Threads::spin_mutex libMesh::ReferenceCounter::_mutex

staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 135 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 135 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 130 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::n_objects(), libMesh::ReferenceCounter::ReferenceCounter(), and libMesh::ReferenceCounter::~ReferenceCounter().

◆ _n_objects [2/2]

Threads::atomic<unsigned int> libMesh::ReferenceCounter::_n_objects

staticprotectedinherited

The number of objects.

Print the reference count information when the number returns to 0.

Definition at line 130 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::n_objects(), libMesh::ReferenceCounter::ReferenceCounter(), and libMesh::ReferenceCounter::~ReferenceCounter().

◆ _nodes

Node** libMesh::Elem::_nodes

protected

Pointers to the nodes we are connected to.

Definition at line 1795 of file elem.h.

Referenced by Elem(), get_node_index(), get_nodes(), node_id(), node_ptr(), node_ref_range(), point(), and set_node().

◆ _p_level

unsigned char libMesh::Elem::_p_level

protected

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

Referenced by hack_p_level(), max_descendant_p_level(), p_level(), and set_p_level().

◆ _pflag

unsigned char libMesh::Elem::_pflag

protected

p refinement flag.

This is stored as an unsigned char to save space.

Definition at line 1826 of file elem.h.

Referenced by p_refinement_flag(), and set_p_refinement_flag().

◆ _rflag

unsigned char libMesh::Elem::_rflag

protected

h refinement flag.

This is stored as an unsigned char to save space.

Definition at line 1820 of file elem.h.

Referenced by refinement_flag(), and set_refinement_flag().

◆ _sbd_id

subdomain_id_type libMesh::Elem::_sbd_id

protected

The subdomain to which this element belongs.

Definition at line 1813 of file elem.h.

Referenced by subdomain_id().

◆ invalid_id

const dof_id_type libMesh::DofObject::invalid_id = static_cast<dof_id_type>(-1)

staticinherited

An invalid id to distinguish an uninitialized DofObject.

Definition at line 347 of file dof_object.h.

Referenced by libMesh::Node::active(), libMesh::DofObject::dof_number(), libMesh::DofObject::invalidate_dofs(), libMesh::DofObject::invalidate_id(), node_id(), point(), libMesh::Parallel::sync_node_data_by_element_id_once(), DofObjectTest< DerivedClass >::testValidId(), and libMesh::DofObject::valid_id().

◆ invalid_processor_id

const processor_id_type libMesh::DofObject::invalid_processor_id = static_cast<processor_id_type>(-1)

staticinherited

An invalid processor_id to distinguish DoFs that have not been assigned to a processor.

Definition at line 358 of file dof_object.h.

Referenced by libMesh::MeshCommunication::allgather(), Elem(), libMesh::DofObject::invalidate_processor_id(), libMesh::MeshBase::n_unpartitioned_elem(), libMesh::MeshBase::n_unpartitioned_nodes(), 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(), and libMesh::DofObject::valid_processor_id().

◆ invalid_subdomain_id

const subdomain_id_type libMesh::Elem::invalid_subdomain_id

static

A static integral constant representing an invalid subdomain id.

See also DofObject::{invalid_id, invalid_unique_id, invalid_processor_id}.

Note: We don't use the static_cast(-1) trick here since subdomain_id_type is sometimes a signed integer for compatibility reasons (see libmesh/id_types.h).; Normally you can declare static const integral types directly in the header file (C++ standard, 9.4.2/4) but std::numeric_limits<T>::max() is not considered a "constant expression". This one is therefore defined in elem.C. http://stackoverflow.com/questions/2738435/using-numeric-limitsmax-in-constant-expressions

Definition at line 263 of file elem.h.

◆ invalid_unique_id

const unique_id_type libMesh::DofObject::invalid_unique_id = static_cast<unique_id_type>(-1)

staticinherited

An invalid unique_id to distinguish an uninitialized DofObject.

Definition at line 352 of file dof_object.h.

Referenced by libMesh::DofObject::unique_id(), and libMesh::DofObject::valid_unique_id().

◆ max_n_nodes

const unsigned int libMesh::Elem::max_n_nodes = 27

static

The maximum number of nodes any element can contain.

This is useful for replacing heap vectors with stack arrays.

Definition at line 613 of file elem.h.

Referenced by Elem().

◆ old_dof_object

DofObject* libMesh::DofObject::old_dof_object

inherited

This object on the last mesh.

Useful for projecting solutions from one mesh to another.

Definition at line 79 of file dof_object.h.

Referenced by libMesh::OldSolutionBase< Output, point_output >::check_old_context(), and libMesh::OldSolutionValue< Output, point_output >::eval_at_node().

◆ type_to_n_edges_map

const unsigned int libMesh::Elem::type_to_n_edges_map[INVALID_ELEM]

static

This array maps the integer representation of the ElemType enum to the number of edges on the element.

Definition at line 682 of file elem.h.

◆ type_to_n_nodes_map

const unsigned int libMesh::Elem::type_to_n_nodes_map[INVALID_ELEM]

static

This array maps the integer representation of the ElemType enum to the number of nodes in the element.

Definition at line 602 of file elem.h.

◆ type_to_n_sides_map

const unsigned int libMesh::Elem::type_to_n_sides_map[INVALID_ELEM]

static

This array maps the integer representation of the ElemType enum to the number of sides on the element.

Definition at line 633 of file elem.h.

The documentation for this class was generated from the following file:

include/geom/elem.h

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Types

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Detailed Description

Member Typedef Documentation

◆ ConstNeighborPtrIter

◆ Counts [1/2]

◆ Counts [2/2]

◆ NeighborPtrIter

◆ Predicate

Member Enumeration Documentation

◆ RefinementState

Constructor & Destructor Documentation

◆ Elem() [1/3]

◆ Elem() [2/3]

◆ Elem() [3/3]

◆ ~Elem()

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

◆ ancestor()

◆ as_parent_node()

◆ boundary_sides_begin()

◆ boundary_sides_end()

◆ bracketing_nodes()

◆ build()

◆ build_edge()

◆ build_edge_ptr() [1/2]

◆ build_edge_ptr() [2/2]

◆ build_side()

◆ build_side_ptr() [1/4]

◆ build_side_ptr() [2/4]

◆ build_side_ptr() [3/4]

◆ build_side_ptr() [4/4]

◆ centroid()

◆ child()

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

◆ compute_key() [1/4]

◆ compute_key() [2/4]

◆ compute_key() [3/4]

◆ compute_key() [4/4]

◆ connectivity()

◆ contains_edge_of()

◆ contains_point()

◆ contains_vertex_of()

◆ contract()

◆ debug_buffer()

◆ default_order()