The base class for all 3D infinite hexahedral element types. More...

#include <cell_inf_hex.h>

Inheritance diagram for libMesh::InfHex:

[legend]

Public Types
enum	RefinementState { COARSEN = 0, DO_NOTHING, REFINE, JUST_REFINED, JUST_COARSENED, INACTIVE, COARSEN_INACTIVE, INVALID_REFINEMENTSTATE }

typedef Elem const	NeighborPtrIter

typedef const Elem const	ConstNeighborPtrIter

typedef Predicates::multi_predicate	Predicate

Public Member Functions
	InfHex (const unsigned int nn, Elem p, Node *nodelinkdata)

	InfHex (InfHex &&)=delete

	InfHex (const InfHex &)=delete

InfHex &	operator= (const InfHex &)=delete

InfHex &	operator= (InfHex &&)=delete

virtual	~InfHex ()=default

virtual Point	master_point (const unsigned int i) const override final

virtual unsigned int	n_sides () const override final

virtual unsigned int	n_vertices () const override final

virtual bool	is_mid_infinite_edge_node (const unsigned int i) const override final

virtual unsigned int	n_edges () const override final

virtual unsigned int	n_faces () const override final

virtual unsigned int	n_children () const override final

virtual bool	is_child_on_side (const unsigned int c, const unsigned int s) const override final

virtual bool	is_edge_on_side (const unsigned int e, const unsigned int s) const override final

virtual dof_id_type	key (const unsigned int s) const override

virtual unsigned int	which_node_am_i (unsigned int side, unsigned int side_node) const override

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

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

virtual Real	quality (const ElemQuality q) const override

virtual std::pair< Real, Real >	qual_bounds (const ElemQuality q) const override

virtual bool	contains_point (const Point &p, Real tol=TOLERANCE) const override

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

virtual dof_id_type	key () const

virtual unsigned short	dim () const override

virtual bool	infinite () const override

virtual Point	origin () const override

const Point &	point (const unsigned int i) const

Point &	point (const unsigned int i)

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

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

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

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)

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

unsigned int	which_side_am_i (const Elem *e) const

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

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

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

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

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

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

void	remove_links_to_me ()

void	make_links_to_me_remote ()

void	make_links_to_me_local (unsigned int n)

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

virtual ElemType	type () 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

IntRange< unsigned short >	side_index_range () const

unsigned int	n_neighbors () const

IntRange< unsigned short >	edge_index_range () const

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

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

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

std::unique_ptr< 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

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

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

std::string	get_info () const

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)

const Elem *	top_parent () const

const Elem *	interior_parent () const

Elem *	interior_parent ()

void	set_interior_parent (Elem *p)

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

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

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)

void	add_child (Elem *elem, unsigned int c)

void	replace_child (Elem *elem, unsigned int c)

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

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

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

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

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

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

void	total_family_tree_by_neighbor (std::vector< const Elem > &family, const Elem neighbor, const bool reset=true) const

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

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

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

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, const bool reset=true) const

RefinementState	refinement_flag () const

void	set_refinement_flag (const RefinementState rflag)

RefinementState	p_refinement_flag () const

void	set_p_refinement_flag (const RefinementState pflag)

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)

void	hack_p_level (const unsigned int p)

virtual void	refine (MeshRefinement &mesh_refinement)

void	coarsen ()

void	contract ()

void	libmesh_assert_valid_neighbors () const

void	libmesh_assert_valid_node_pointers () const

side_iterator	boundary_sides_begin ()

side_iterator	boundary_sides_end ()

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

void	clear_old_dof_object ()

void	set_old_dof_object ()

void	clear_dofs ()

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

void	invalidate_id ()

void	invalidate_processor_id ()

void	invalidate ()

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)

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)

bool	valid_processor_id () const

unsigned int	n_systems () const

void	set_n_systems (const unsigned int s)

void	add_system ()

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)

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)

void	set_n_comp_group (const unsigned int s, const unsigned int vg, const unsigned int ncomp)

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)

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)

dof_id_type	vg_dof_base (const unsigned int s, const unsigned int vg) const

unsigned int	packed_indexing_size () const

void	unpack_indexing (std::vector< largest_id_type >::const_iterator begin)

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

void	debug_buffer () const

void	print_dof_info () const

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

Static Public Member Functions
static void	print_info (std::ostream &out=libMesh::out)

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

static std::string	get_info ()

static std::string	get_info ()

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 unsigned int	n_objects ()

static unsigned int	n_objects ()

static void	enable_print_counter_info ()

static void	enable_print_counter_info ()

static void	disable_print_counter_info ()

static void	disable_print_counter_info ()

static unsigned int	unpackable_indexing_size (std::vector< largest_id_type >::const_iterator begin)

Public Attributes
DofObject *	old_dof_object

Static Public Attributes
static const subdomain_id_type	invalid_subdomain_id = std::numeric_limits<subdomain_id_type>::max()

static const unsigned int	type_to_n_nodes_map [INVALID_ELEM]

static const unsigned int	max_n_nodes = 27

static const unsigned int	type_to_n_sides_map [INVALID_ELEM]

static const unsigned int	type_to_n_edges_map [INVALID_ELEM]

static const dof_id_type	invalid_id = static_cast<dof_id_type>(-1)

static const unique_id_type	invalid_unique_id = static_cast<unique_id_type>(-1)

static const processor_id_type	invalid_processor_id = static_cast<processor_id_type>(-1)

Protected Types
typedef std::map< std::string, std::pair< unsigned int, unsigned int > >	Counts

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

Protected Member Functions
template<typename Subclass >
void	simple_build_side_ptr (std::unique_ptr< Elem > &side, const unsigned int i, ElemType sidetype)

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

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

void	increment_constructor_count (const std::string &name)

void	increment_constructor_count (const std::string &name)

void	increment_destructor_count (const std::string &name)

void	increment_destructor_count (const std::string &name)

Static Protected Member Functions
static dof_id_type	compute_key (dof_id_type n0)

static dof_id_type	compute_key (dof_id_type n0, dof_id_type n1)

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

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

Protected Attributes
Elem *	_elemlinks_data [6+(LIBMESH_DIM >3)]

Node **	_nodes

Elem **	_elemlinks

Elem **	_children

subdomain_id_type	_sbd_id

unsigned char	_rflag

unsigned char	_pflag

unsigned char	_p_level

Static Protected Attributes
static const unsigned short int	_second_order_adjacent_vertices [8][2]

static const unsigned short int	_second_order_vertex_child_number [18]

static const unsigned short int	_second_order_vertex_child_index [18]

static const Real	_master_points [18][3]

static Counts	_counts

static Counts	_counts

static Threads::atomic< unsigned int >	_n_objects

static Threads::atomic< unsigned int >	_n_objects

static Threads::spin_mutex	_mutex

static Threads::spin_mutex	_mutex

static bool	_enable_print_counter = true

static bool	_enable_print_counter = true

Detailed Description

The base class for all 3D infinite hexahedral element types.

The InfHex is an element in 3D with 5 sides. The $6^{th}$ side is theoretically located at infinity, and therefore not accounted for. However, one could say that the $6^{th}$ side actually does exist in the mesh, since the outer nodes are located at a specific distance from the mesh origin (and therefore define a side). Still, this face is not to be used!

Author: Daniel Dreyer

Date: 2003

Definition at line 46 of file cell_inf_hex.h.

Member Typedef Documentation

◆ ConstNeighborPtrIter

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

inherited

Definition at line 324 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

inherited

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

Definition at line 323 of file elem.h.

◆ Predicate

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

inherited

Useful iterator typedefs

Definition at line 1499 of file elem.h.

Member Enumeration Documentation

◆ RefinementState

enum libMesh::Elem::RefinementState

inherited

Enumeration of possible element refinement states.

Enumerator
COARSEN
DO_NOTHING
REFINE
JUST_REFINED
JUST_COARSENED
INACTIVE
COARSEN_INACTIVE
INVALID_REFINEMENTSTATE

Definition at line 1198 of file elem.h.

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

Constructor & Destructor Documentation

◆ InfHex() [1/3]

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

inline

Default infinite brick element, takes number of nodes and parent. Derived classes implement 'true' elements.

Definition at line 54 of file cell_inf_hex.h.

References libMesh::Elem::set_interior_parent().

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

◆ InfHex() [2/3]

libMesh::InfHex::InfHex ( InfHex && )

delete

◆ InfHex() [3/3]

libMesh::InfHex::InfHex ( const InfHex & )

delete

◆ ~InfHex()

virtual libMesh::InfHex::~InfHex ( )

virtualdefault

Member Function Documentation

◆ _get_bracketing_node_cache()

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

inlineprotectedvirtualinherited

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

Definition at line 1659 of file elem.h.

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

   {
     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

inlineprotectedvirtualinherited

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

Definition at line 1673 of file elem.h.

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

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

◆ active()

bool libMesh::Elem::active ( ) const

inlineinherited

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

Note: It suffices to check the first child only.

Definition at line 2390 of file elem.h.

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

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

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

inherited

Same as the family_tree() member, but only adds the active children. Can be thought of as removing all the inactive elements from the vector created by family_tree, but is implemented more efficiently.

Definition at line 1577 of file elem.C.

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

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

 {
   // The "family tree" doesn't include subactive elements
   libmesh_assert(!this->subactive());
 
   // Clear the vector if the flag reset tells us to.
   if (reset)
     active_family.clear();
 
   // Add this element to the family tree if it is active
   if (this->active())
     active_family.push_back(this);
 
   // Otherwise recurse into the element's children.
   // Do not clear the vector any more.
   else
     for (auto & c : this->child_ref_range())
       if (!c.is_remote())
         c.active_family_tree (active_family, false);
 }

◆ active_family_tree_by_neighbor()

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

inherited

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

Definition at line 1837 of file elem.C.

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

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

 {
   // The "family tree" doesn't include subactive elements or
   // remote_elements
   libmesh_assert(!this->subactive());
   libmesh_assert(this != remote_elem);
 
   // Clear the vector if the flag reset tells us to.
   if (reset)
     family.clear();
 
   // This only makes sense if we're already a neighbor
 #ifndef NDEBUG
   if (this->level() >= neighbor_in->level())
     libmesh_assert (this->has_neighbor(neighbor_in));
 #endif
 
   // Add an active element to the family tree.
   if (this->active())
     family.push_back(this);
 
   // Or recurse into an ancestor element's children.
   // Do not clear the vector any more.
   else if (!this->active())
     for (auto & c : this->child_ref_range())
       if (&c != remote_elem && c.has_neighbor(neighbor_in))
         c.active_family_tree_by_neighbor (family, neighbor_in, false);
 }

◆ active_family_tree_by_side()

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

inherited

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

Definition at line 1630 of file elem.C.

References libMesh::Elem::active(), libMesh::Elem::active_family_tree_by_side(), libMesh::Elem::child_ptr(), libMesh::Elem::is_child_on_side(), libMesh::Elem::is_remote(), libMesh::Elem::n_children(), libMesh::Elem::n_sides(), libMesh::remote_elem, and libMesh::Elem::subactive().

Referenced by libMesh::Elem::active_family_tree_by_side(), libMesh::Nemesis_IO_Helper::write_sidesets(), and libMesh::ExodusII_IO_Helper::write_sidesets().

 {
   // The "family tree" doesn't include subactive or remote elements
   libmesh_assert(!this->subactive());
   libmesh_assert(this != remote_elem);
 
   // Clear the vector if the flag reset tells us to.
   if (reset)
     family.clear();
 
   libmesh_assert_less (s, this->n_sides());
 
   // Add an active element to the family tree.
   if (this->active())
     family.push_back(this);
 
   // Or recurse into an ancestor element's children.
   // Do not clear the vector any more.
   else
     {
       const unsigned int nc = this->n_children();
       for (unsigned int c = 0; c != nc; c++)
         if (!this->child_ptr(c)->is_remote() && this->is_child_on_side(c, s))
           this->child_ptr(c)->active_family_tree_by_side (family, s, false);
     }
 }

◆ active_family_tree_by_topological_neighbor()

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,
		const bool	reset = `true`
	)		const

inherited

Same as the active_family_tree_by_neighbor() member, but the neighbor here may be a topological (e.g. periodic boundary condition) neighbor, not just a local neighbor.

Definition at line 1795 of file elem.C.

References libMesh::Elem::active(), libMesh::Elem::child_ref_range(), libMesh::Elem::has_topological_neighbor(), libMesh::Elem::level(), mesh, libMesh::remote_elem, and libMesh::Elem::subactive().

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

 {
   // The "family tree" doesn't include subactive elements or
   // remote_elements
   libmesh_assert(!this->subactive());
   libmesh_assert(this != remote_elem);
 
   // Clear the vector if the flag reset tells us to.
   if (reset)
     family.clear();
 
   // This only makes sense if we're already a topological neighbor
 #ifndef NDEBUG
   if (this->level() >= neighbor_in->level())
     libmesh_assert (this->has_topological_neighbor(neighbor_in,
                                                    mesh,
                                                    point_locator,
                                                    pb));
 #endif
 
   // Add an active element to the family tree.
   if (this->active())
     family.push_back(this);
 
   // Or recurse into an ancestor element's children.
   // Do not clear the vector any more.
   else if (!this->active())
     for (auto & c : this->child_ref_range())
       if (&c != remote_elem &&
           c.has_topological_neighbor(neighbor_in, mesh, point_locator,
                                      pb))
         c.active_family_tree_by_topological_neighbor
           (family, neighbor_in, mesh, point_locator, pb, false);
 }

◆ add_child() [1/2]

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

inherited

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

Definition at line 1461 of file elem.C.

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

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

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

◆ add_child() [2/2]

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

inherited

Adds a new child pointer to the specified index in the array of children of this element. If this is the first child to be added, this method allocates memory in the parent's _children array, otherwise, it just sets the pointer.

Definition at line 1488 of file elem.C.

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

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

◆ add_system()

void libMesh::DofObject::add_system ( )

inherited

Adds an additional system to the DofObject

Definition at line 195 of file dof_object.C.

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

 {
   // quick return?
   if (this->n_systems() == 0)
     {
       this->set_n_systems(1);
       return;
     }
 
   DofObject::index_buffer_t::iterator it = _idx_buf.begin();
 
   std::advance(it, this->n_systems());
 
   // this inserts the current vector size at the position for the new system - creating the
   // entry we need for the new system indicating there are 0 variables.
   _idx_buf.insert(it, cast_int<dof_id_type>(_idx_buf.size()));
 
   // cache this value before we screw it up!
   const unsigned int ns_orig = this->n_systems();
 
   // increment the number of systems and the offsets for each of
   // the systems including the new one we just added.
   for (unsigned int i=0; i<ns_orig+1; i++)
     _idx_buf[i]++;
 
   libmesh_assert_equal_to (this->n_systems(), (ns_orig+1));
   libmesh_assert_equal_to (this->n_vars(ns_orig), 0);
   libmesh_assert_equal_to (this->n_var_groups(ns_orig), 0);
 }

◆ ancestor()

bool libMesh::Elem::ancestor ( ) const

inherited

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

Definition at line 1427 of file elem.C.

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

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

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

◆ as_parent_node()

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

virtualinherited

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

Definition at line 1933 of file elem.C.

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

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

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

◆ boundary_sides_begin()

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

inherited

Iterator accessor functions

Definition at line 2808 of file elem.C.

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

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

◆ boundary_sides_end()

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

inherited

Definition at line 2817 of file elem.C.

References libMesh::Elem::_last_side().

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

◆ bracketing_nodes()

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

virtualinherited

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

Definition at line 2206 of file elem.C.

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

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

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

◆ build()

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

staticinherited

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

Definition at line 245 of file elem.C.

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

Referenced by libMesh::GMVIO::_read_one_cell(), libMesh::UnstructuredMesh::all_first_order(), libMesh::UnstructuredMesh::all_second_order(), libMesh::Elem::bracketing_nodes(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::UnstructuredMesh::create_submesh(), libMesh::MeshTools::Modification::flatten(), libMesh::Elem::parent_bracketing_nodes(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::VTKIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::AbaqusIO::read_elements(), libMesh::UCDIO::read_implementation(), libMesh::GmshIO::read_mesh(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::Elem::refine(), libMesh::Parallel::Packing< T >::unpack(), and libMesh::GMVIO::write_ascii_old_impl().

 {
   switch (type)
     {
       // 0D elements
     case NODEELEM:
       return libmesh_make_unique<NodeElem>(p);
 
       // 1D elements
     case EDGE2:
       return libmesh_make_unique<Edge2>(p);
     case EDGE3:
       return libmesh_make_unique<Edge3>(p);
     case EDGE4:
       return libmesh_make_unique<Edge4>(p);
 
       // 2D elements
     case TRI3:
       return libmesh_make_unique<Tri3>(p);
     case TRISHELL3:
       return libmesh_make_unique<TriShell3>(p);
     case TRI3SUBDIVISION:
       return libmesh_make_unique<Tri3Subdivision>(p);
     case TRI6:
       return libmesh_make_unique<Tri6>(p);
     case QUAD4:
       return libmesh_make_unique<Quad4>(p);
     case QUADSHELL4:
       return libmesh_make_unique<QuadShell4>(p);
     case QUAD8:
       return libmesh_make_unique<Quad8>(p);
     case QUADSHELL8:
       return libmesh_make_unique<QuadShell8>(p);
     case QUAD9:
       return libmesh_make_unique<Quad9>(p);
 
       // 3D elements
     case TET4:
       return libmesh_make_unique<Tet4>(p);
     case TET10:
       return libmesh_make_unique<Tet10>(p);
     case HEX8:
       return libmesh_make_unique<Hex8>(p);
     case HEX20:
       return libmesh_make_unique<Hex20>(p);
     case HEX27:
       return libmesh_make_unique<Hex27>(p);
     case PRISM6:
       return libmesh_make_unique<Prism6>(p);
     case PRISM15:
       return libmesh_make_unique<Prism15>(p);
     case PRISM18:
       return libmesh_make_unique<Prism18>(p);
     case PYRAMID5:
       return libmesh_make_unique<Pyramid5>(p);
     case PYRAMID13:
       return libmesh_make_unique<Pyramid13>(p);
     case PYRAMID14:
       return libmesh_make_unique<Pyramid14>(p);
 
 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
       // 1D infinite elements
     case INFEDGE2:
       return libmesh_make_unique<InfEdge2>(p);
 
       // 2D infinite elements
     case INFQUAD4:
       return libmesh_make_unique<InfQuad4>(p);
     case INFQUAD6:
       return libmesh_make_unique<InfQuad6>(p);
 
       // 3D infinite elements
     case INFHEX8:
       return libmesh_make_unique<InfHex8>(p);
     case INFHEX16:
       return libmesh_make_unique<InfHex16>(p);
     case INFHEX18:
       return libmesh_make_unique<InfHex18>(p);
     case INFPRISM6:
       return libmesh_make_unique<InfPrism6>(p);
     case INFPRISM12:
       return libmesh_make_unique<InfPrism12>(p);
 #endif
 
     default:
       libmesh_error_msg("ERROR: Undefined element type!");
     }
 }

◆ build_edge()

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

inlineinherited

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

References libMesh::Elem::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 virtualinherited

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 libMesh::Elem::build_edge(), libMesh::Elem::build_edge_ptr(), libMesh::FE< Dim, LAGRANGE_VEC >::edge_reinit(), libMesh::ElemCutter::find_intersection_points(), and libMesh::Elem::is_child_on_edge().

◆ build_edge_ptr() [2/2]

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

inlineinherited

Definition at line 2278 of file elem.h.

References libMesh::Elem::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

inlineinherited

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

References libMesh::Elem::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 virtualinherited

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::BoundaryInfo::_find_id_maps(), libMesh::Elem::SideIter::_update_side_ptr(), libMesh::BoundaryInfo::add_elements(), libMesh::MeshTools::Modification::all_tri(), libMesh::Face::build_edge_ptr(), libMesh::InfQuad::build_edge_ptr(), libMesh::InfFE< Dim, T_radial, T_map >::Base::build_elem(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::Elem::build_side(), libMesh::Elem::build_side_ptr(), libMesh::InfFE< Dim, T_radial, T_map >::compute_data(), libMesh::FEAbstract::compute_node_constraints(), libMesh::FEAbstract::compute_periodic_node_constraints(), libMesh::BoundaryInfo::get_side_and_node_maps(), libMesh::Cell::loose_bounding_box(), libMesh::PeriodicBoundaries::neighbor(), libMesh::PostscriptIO::plot_quadratic_elem(), libMesh::FE< Dim, LAGRANGE_VEC >::reinit(), libMesh::InfFE< Dim, T_radial, T_map >::reinit(), libMesh::FEXYZ< Dim >::reinit(), libMesh::InfFE< Dim, T_radial, T_map >::shape(), libMesh::Elem::simple_build_side_ptr(), libMesh::MeshTools::Modification::smooth(), libMesh::FroIO::write(), and libMesh::GmshIO::write_mesh().

◆ build_side_ptr() [2/4]

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

inlineinherited

Definition at line 2215 of file elem.h.

References libMesh::Elem::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 virtualinherited

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

inlineinherited

Definition at line 2228 of file elem.h.

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

Point libMesh::Elem::centroid ( ) const

virtualinherited

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.

Definition at line 344 of file elem.C.

References libMesh::TypeVector< T >::add(), and libMesh::Elem::n_vertices().

Referenced by libMesh::UnstructuredMesh::find_neighbors(), libMesh::LocationMap< T >::point_of(), libMesh::FE< Dim, LAGRANGE_VEC >::shape(), libMesh::FE< Dim, LAGRANGE_VEC >::shape_deriv(), and libMesh::FE< Dim, LAGRANGE_VEC >::shape_second_deriv().

 {
   Point cp;
 
   for (unsigned int n=0; n<this->n_vertices(); n++)
     cp.add (this->point(n));
 
   return (cp /= static_cast<Real>(this->n_vertices()));
 }

◆ child()

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

inlineinherited

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

References libMesh::Elem::child_ptr().

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

 {
   // 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 )

inlineinherited

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

Definition at line 2105 of file elem.h.

References libMesh::Elem::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

inlineinherited

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

Definition at line 2117 of file elem.h.

References libMesh::Elem::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

inlineinherited

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

Definition at line 2578 of file elem.h.

References libMesh::Elem::_children.

Referenced by libMesh::Elem::active_family_tree_by_side(), libMesh::Elem::add_child(), libMesh::UnstructuredMesh::all_first_order(), libMesh::Elem::bracketing_nodes(), libMesh::Elem::child(), libMesh::Elem::coarsen(), libMesh::FEGenericBase< FEOutputType< T >::type >::coarsened_dof_values(), libMesh::Elem::family_tree_by_side(), libMesh::TopologyMap::fill(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::Elem::is_vertex_on_parent(), libMesh::Elem::make_links_to_me_remote(), libMesh::Elem::refine(), libMesh::Elem::replace_child(), libMesh::Parallel::sync_element_data_by_parent_id(), libMesh::Parallel::Packing< T >::unpack(), libMesh::Elem::which_child_am_i(), and libMesh::CheckpointIO::write_remote_elem().

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

◆ child_ptr() [2/2]

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

inlineinherited

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

Definition at line 2587 of file elem.h.

References libMesh::Elem::_children.

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

◆ child_ref_range() [1/2]

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

inlineinherited

Returns a range with all children of a parent element, usable in range-based for loops. The exact type of the return value here may be subject to change in future libMesh releases, but the iterators will always dereference to produce a reference to a child element.

Definition at line 1779 of file elem.h.

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

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

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

◆ child_ref_range() [2/2]

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

inlineinherited

Definition at line 1787 of file elem.h.

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

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

◆ clear_dofs()

void libMesh::DofObject::clear_dofs ( )

inlineinherited

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::set_n_systems(), and 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

Definition at line 142 of file dof_object.C.

References libMesh::DofObject::old_dof_object.

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

 {
   delete this->old_dof_object;
   this->old_dof_object = nullptr;
 }

◆ close_to_point()

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

virtualinherited

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

Definition at line 2326 of file elem.C.

References libMesh::Elem::point_test().

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

◆ coarsen()

void libMesh::Elem::coarsen ( )

inherited

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

Definition at line 106 of file elem_refinement.C.

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

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

◆ compute_key() [1/4]

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

inlinestaticprotectedinherited

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

Definition at line 2754 of file elem.h.

Referenced by libMesh::Tet::key(), libMesh::Prism::key(), libMesh::Tri::key(), libMesh::Pyramid::key(), libMesh::Hex::key(), libMesh::Edge::key(), libMesh::InfPrism::key(), libMesh::InfQuad6::key(), libMesh::Quad::key(), key(), libMesh::Quad9::key(), libMesh::Quad8::key(), libMesh::Tri6::key(), libMesh::InfQuad::key(), libMesh::Edge2::key(), libMesh::Hex27::key(), libMesh::Prism18::key(), libMesh::Pyramid14::key(), libMesh::Edge4::key(), libMesh::InfHex18::key(), libMesh::Edge3::key(), and libMesh::Tet4::key().

 {
   return n0;
 }

◆ compute_key() [2/4]

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

inlinestaticprotectedinherited

Returns: A hash key computed from two node ids.

Definition at line 2762 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
	)

inlinestaticprotectedinherited

Returns: A hash key computed from three node ids.

Definition at line 2774 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
	)

inlinestaticprotectedinherited

Returns: A hash key computed from four node ids.

Definition at line 2808 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 virtualinherited

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.

Referenced by libMesh::VTKIO::read(), and libMesh::Elem::write_connectivity().

◆ contains_edge_of()

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

inherited

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

Definition at line 477 of file elem.C.

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

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

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

◆ contains_point()

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

overridevirtual

Returns: true when this element contains the point p. Customized for infinite elements, since knowledge about the envelope can be helpful.

Reimplemented from libMesh::Elem.

Definition at line 440 of file cell_inf_hex.C.

References libMesh::Elem::default_order(), libMesh::InfCell::dim(), libMesh::FEInterface::inverse_map(), std::max(), std::min(), libMesh::TypeVector< T >::norm(), libMesh::TensorTools::norm_sq(), libMesh::TypeVector< T >::norm_sq(), libMesh::FEInterface::on_reference_element(), libMesh::InfCell::origin(), libMesh::Elem::point(), libMesh::Real, and libMesh::Elem::type().

 {
   // For infinite elements with linear base interpolation:
   // make use of the fact that infinite elements do not
   // live inside the envelope.  Use a fast scheme to
   // check whether point \p p is inside or outside
   // our relevant part of the envelope.  Note that
   // this is not exclusive: only when the distance is less,
   // we are safe.  Otherwise, we cannot say anything. The
   // envelope may be non-spherical, the physical point may lie
   // inside the envelope, outside the envelope, or even inside
   // this infinite element.  Therefore if this fails,
   // fall back to the FEInterface::inverse_map()
   const Point my_origin (this->origin());
 
   // determine the minimal distance of the base from the origin
   // Use norm_sq() instead of norm(), it is faster
   Point pt0_o(this->point(0) - my_origin);
   Point pt1_o(this->point(1) - my_origin);
   Point pt2_o(this->point(2) - my_origin);
   Point pt3_o(this->point(3) - my_origin);
   const Real min_distance_sq = std::min(pt0_o.norm_sq(),
                                         std::min(pt1_o.norm_sq(),
                                                  std::min(pt2_o.norm_sq(),
                                                           pt3_o.norm_sq())));
 
   // work with 1% allowable deviation.  We can still fall
   // back to the InfFE::inverse_map()
   const Real conservative_p_dist_sq = 1.01 * (Point(p - my_origin).norm_sq());
 
 
 
   if (conservative_p_dist_sq < min_distance_sq)
     {
       // the physical point is definitely not contained in the element
       return false;
     }
 
   // this captures the case that the point is not (almost) in the direction of the element.:
   // first, project the problem onto the unit sphere:
   Point p_o(p - my_origin);
   pt0_o /= pt0_o.norm();
   pt1_o /= pt1_o.norm();
   pt2_o /= pt2_o.norm();
   pt3_o /= pt3_o.norm();
   p_o /= p_o.norm();
 
 
   // now, check if it is in the projected face; using that the diagonal contains
   // the largest distance between points in it
   Real max_h = std::max((pt0_o - pt2_o).norm_sq(),
                         (pt1_o - pt2_o).norm_sq())*1.01;
 
   if ((p_o - pt0_o).norm_sq() > max_h ||
       (p_o - pt1_o).norm_sq() > max_h ||
       (p_o - pt2_o).norm_sq() > max_h ||
       (p_o - pt3_o).norm_sq() > max_h )
     {
       // the physical point is definitely not contained in the element
       return false;
     }
 
   // Declare a basic FEType.  Will use default in the base,
   // and something else (not important) in radial direction.
   FEType fe_type(default_order());
 
   const Point mapped_point = FEInterface::inverse_map(dim(),
                                                       fe_type,
                                                       this,
                                                       p,
                                                       tol,
                                                       false);
 
   return FEInterface::on_reference_element(mapped_point, this->type(), tol);
 }

◆ contains_vertex_of()

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

inherited

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

Definition at line 466 of file elem.C.

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

Referenced by libMesh::Elem::find_interior_neighbors(), and libMesh::Elem::find_point_neighbors().

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

◆ contract()

void libMesh::Elem::contract ( )

inherited

Contract an active element, i.e. remove pointers to any subactive children. This should only be called via MeshRefinement::contract, which will also remove subactive children from the mesh.

Definition at line 171 of file elem_refinement.C.

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

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

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

◆ debug_buffer()

void libMesh::DofObject::debug_buffer ( ) const

inherited

Print our buffer for debugging.

Definition at line 538 of file dof_object.C.

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

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

◆ default_order()

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

pure virtualinherited

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.

Referenced by libMesh::UnstructuredMesh::all_second_order(), libMesh::Elem::bracketing_nodes(), libMesh::FEAbstract::compute_node_constraints(), libMesh::FEAbstract::compute_periodic_node_constraints(), libMesh::InfPrism::contains_point(), contains_point(), libMesh::FEMContext::elem_position_get(), libMesh::FEMap::init_edge_shape_functions(), libMesh::FEMap::init_reference_to_physical_map(), libMesh::FE< Dim, LAGRANGE_VEC >::map(), libMesh::FE< Dim, LAGRANGE_VEC >::map_eta(), libMesh::FE< Dim, LAGRANGE_VEC >::map_xi(), libMesh::FE< Dim, LAGRANGE_VEC >::map_zeta(), libMesh::Elem::parent_bracketing_nodes(), libMesh::Elem::point_test(), and libMesh::Elem::volume().

◆ dim()

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

inlineoverridevirtualinherited

Returns: 3, the dimensionality of the object.

Implements libMesh::Elem.

Definition at line 66 of file cell_inf.h.

Referenced by libMesh::InfPrism::contains_point(), and contains_point().

66 { return 3; }

◆ disable_print_counter_info() [1/2]

void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

Definition at line 106 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

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

 {
   _enable_print_counter = false;
   return;
 }

◆ disable_print_counter_info() [2/2]

void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

Definition at line 106 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

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

 {
   _enable_print_counter = false;
   return;
 }

◆ dof_number() [1/2]

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

inlineinherited

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

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

Definition at line 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::DofMap::_dof_indices(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), libMesh::DofMap::constrain_p_dofs(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::dof_indices(), libMesh::DofObject::DofObject(), libMesh::OldSolutionValue< Output, point_output >::eval_at_node(), libMesh::OldSolutionCoefs< Output, point_output >::eval_at_node(), libMesh::Node::get_info(), libMesh::Elem::get_info(), libMesh::DofMap::local_variable_indices(), libMesh::DofMap::old_dof_indices(), libMesh::BuildProjectionList::operator()(), libMesh::DofObject::operator=(), libMesh::DofObject::print_dof_info(), libMesh::HPCoarsenTest::select_refinement(), libMesh::DofObject::set_dof_number(), and libMesh::DofMap::set_nonlocal_dof_objects().

 {
   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

inlineinherited

Returns: The global degree of freedom number for variable group vg, variable index vig within the group, component comp out of n_comp, for system s on this DofObject

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

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

inlineinherited

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

Definition at line 2157 of file elem.h.

References libMesh::Elem::n_edges().

Referenced by libMesh::FEGenericBase< FEOutputType< T >::type >::coarsened_dof_values(), libMesh::BoundaryInfo::copy_boundary_ids(), libMesh::Parallel::Packing< T >::pack(), and libMesh::Parallel::Packing< T >::unpack().

 {
   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 virtualinherited

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.

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

◆ embedding_matrix_version()

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

inlinevirtualinherited

Returns: A "version number" that identifies which embedding matrix is in use.

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

Reimplemented in libMesh::Tet.

Definition at line 1609 of file elem.h.

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

1609 { return 0; }

◆ enable_print_counter_info() [1/2]

void libMesh::ReferenceCounter::enable_print_counter_info ( )

staticinherited

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

Definition at line 100 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

 {
   _enable_print_counter = true;
   return;
 }

◆ enable_print_counter_info() [2/2]

void libMesh::ReferenceCounter::enable_print_counter_info ( )

staticinherited

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

Definition at line 100 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

 {
   _enable_print_counter = true;
   return;
 }

◆ family_tree()

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

inherited

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

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

Definition at line 1534 of file elem.C.

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

 {
   // The "family tree" doesn't include subactive elements
   libmesh_assert(!this->subactive());
 
   // Clear the vector if the flag reset tells us to.
   if (reset)
     family.clear();
 
   // Add this element to the family tree.
   family.push_back(this);
 
   // Recurse into the elements children, if it has them.
   // Do not clear the vector any more.
   if (!this->active())
     for (auto & c : this->child_ref_range())
       if (!c.is_remote())
         c.family_tree (family, false);
 }

◆ family_tree_by_neighbor()

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

inherited

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

Definition at line 1661 of file elem.C.

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

 {
   // The "family tree" doesn't include subactive elements
   libmesh_assert(!this->subactive());
 
   // Clear the vector if the flag reset tells us to.
   if (reset)
     family.clear();
 
   // This only makes sense if we're already a neighbor
   libmesh_assert (this->has_neighbor(neighbor_in));
 
   // Add this element to the family tree.
   family.push_back(this);
 
   // Recurse into the elements children, if it's not active.
   // Do not clear the vector any more.
   if (!this->active())
     for (auto & c : this->child_ref_range())
       if (&c != remote_elem && c.has_neighbor(neighbor_in))
         c.family_tree_by_neighbor (family, neighbor_in, false);
 }

◆ family_tree_by_side()

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

inherited

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

Definition at line 1601 of file elem.C.

References libMesh::Elem::active(), libMesh::Elem::child_ptr(), libMesh::Elem::family_tree_by_side(), libMesh::Elem::is_child_on_side(), libMesh::Elem::is_remote(), libMesh::Elem::n_children(), libMesh::Elem::n_sides(), and libMesh::Elem::subactive().

Referenced by libMesh::Elem::family_tree_by_side(), and libMesh::Elem::make_links_to_me_local().

 {
   // The "family tree" doesn't include subactive elements
   libmesh_assert(!this->subactive());
 
   // Clear the vector if the flag reset tells us to.
   if (reset)
     family.clear();
 
   libmesh_assert_less (s, this->n_sides());
 
   // Add this element to the family tree.
   family.push_back(this);
 
   // Recurse into the elements children, if it has them.
   // Do not clear the vector any more.
   if (!this->active())
     {
       const unsigned int nc = this->n_children();
       for (unsigned int c = 0; c != nc; c++)
         if (!this->child_ptr(c)->is_remote() && this->is_child_on_side(c, s))
           this->child_ptr(c)->family_tree_by_side (family, s, false);
     }
 }

◆ family_tree_by_subneighbor()

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

inherited

Same as the family_tree() member, but only adds elements which are next to subneighbor. Only applicable when this->has_neighbor(neighbor) and neighbor->is_ancestor(subneighbor)

Definition at line 1712 of file elem.C.

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

 {
   // The "family tree" doesn't include subactive elements
   libmesh_assert(!this->subactive());
 
   // Clear the vector if the flag reset tells us to.
   if (reset)
     family.clear();
 
   // To simplify this function we need an existing neighbor
   libmesh_assert (neighbor_in);
   libmesh_assert_not_equal_to (neighbor_in, remote_elem);
   libmesh_assert (this->has_neighbor(neighbor_in));
 
   // This only makes sense if subneighbor descends from neighbor
   libmesh_assert (subneighbor);
   libmesh_assert_not_equal_to (subneighbor, remote_elem);
   libmesh_assert (neighbor_in->is_ancestor_of(subneighbor));
 
   // Add this element to the family tree if applicable.
   if (neighbor_in == subneighbor)
     family.push_back(this);
 
   // Recurse into the elements children, if it's not active.
   // Do not clear the vector any more.
   if (!this->active())
     for (auto & c : this->child_ref_range())
       if (&c != remote_elem)
         for (auto child_neigh : c.neighbor_ptr_range())
           if (child_neigh &&
               (child_neigh == neighbor_in ||
                (child_neigh->parent() == neighbor_in &&
                 child_neigh->is_ancestor_of(subneighbor))))
             c.family_tree_by_subneighbor (family, child_neigh,
                                           subneighbor, false);
 }

◆ find_edge_neighbors() [1/2]

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

inherited

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

Definition at line 637 of file elem.C.

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

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

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

◆ find_edge_neighbors() [2/2]

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

inherited

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

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

Definition at line 664 of file elem.C.

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

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

◆ find_interior_neighbors()

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

inherited

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

Definition at line 725 of file elem.C.

References libMesh::Elem::active(), libMesh::Elem::child(), libMesh::Elem::child_ref_range(), libMesh::Elem::contains_point(), libMesh::Elem::contains_vertex_of(), libMesh::Elem::dim(), end, libMesh::Elem::find_point_neighbors(), libMesh::Elem::interior_parent(), libMesh::Elem::level(), libMesh::Elem::node_ref_range(), and libMesh::Elem::subactive().

Referenced by libMesh::MetisPartitioner::partition_range().

 {
   neighbor_set.clear();
 
   if ((this->dim() >= LIBMESH_DIM) ||
       !this->interior_parent())
     return;
 
   const Elem * ip = this->interior_parent();
   libmesh_assert (ip->contains_vertex_of(this) ||
                   this->contains_vertex_of(ip));
 
   libmesh_assert (!ip->subactive());
 
 #ifdef LIBMESH_ENABLE_AMR
   while (!ip->active()) // only possible with AMR, be careful because
     {                   // ip->child_ptr(c) is only good with AMR.
       for (auto & child : ip->child_ref_range())
         {
           if (child.contains_vertex_of(this) ||
               this->contains_vertex_of(&child))
             {
               ip = &child;
               break;
             }
         }
     }
 #endif
 
   this->find_point_neighbors(neighbor_set, ip);
 
   // Now we have all point neighbors from the interior manifold, but
   // we need to weed out any neighbors that *only* intersect us at one
   // point (or at one edge, if we're a 1-D element in 3D).
   //
   // The refinement hierarchy helps us here: if the interior element
   // has a lower or equal refinement level then we can discard it iff
   // it doesn't contain all our vertices.  If it has a higher
   // refinement level then we can discard it iff we don't contain at
   // least dim()+1 of its vertices
   std::set<const Elem *>::iterator        it = neighbor_set.begin();
   const std::set<const Elem *>::iterator end = neighbor_set.end();
 
   while (it != end)
     {
       std::set<const Elem *>::iterator current = it++;
       const Elem * elem = *current;
 
       // This won't invalidate iterator it, because it is already
       // pointing to the next element
       if (elem->level() > this->level())
         {
           unsigned int vertices_contained = 0;
           for (auto & n : elem->node_ref_range())
             if (this->contains_point(n))
               vertices_contained++;
 
           if (vertices_contained <= this->dim())
             {
               neighbor_set.erase(current);
               continue;
             }
         }
       else
         {
           for (auto & n : this->node_ref_range())
             {
               if (!elem->contains_point(n))
                 {
                   neighbor_set.erase(current);
                   break;
                 }
             }
         }
     }
 }

◆ find_point_neighbors() [1/3]

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

inherited

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

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

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

Definition at line 498 of file elem.C.

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

Referenced by libMesh::MeshRefinement::enforce_mismatch_limit_prior_to_refinement(), libMesh::Elem::find_edge_neighbors(), libMesh::MeshFunction::find_element(), libMesh::Elem::find_interior_neighbors(), libMesh::Elem::find_point_neighbors(), and libMesh::Elem::is_semilocal().

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

◆ find_point_neighbors() [2/3]

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

inherited

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

Definition at line 561 of file elem.C.

References libMesh::Elem::find_point_neighbors().

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

◆ find_point_neighbors() [3/3]

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

inherited

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

Definition at line 568 of file elem.C.

References libMesh::Elem::active(), libMesh::Elem::contains_vertex_of(), and libMesh::remote_elem.

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

◆ first_order_equivalent_type()

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

staticinherited

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

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

Definition at line 2584 of file elem.C.

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

Referenced by libMesh::UnstructuredMesh::all_first_order(), and libMesh::GMVIO::write_ascii_old_impl().

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

◆ get_info() [1/3]

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

staticinherited

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

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

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

 {
 #if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
 
   std::ostringstream oss;
 
   oss << '\n'
       << " ---------------------------------------------------------------------------- \n"
       << "| Reference count information                                                |\n"
       << " ---------------------------------------------------------------------------- \n";
 
   for (const auto & pr : _counts)
     {
       const std::string name(pr.first);
       const unsigned int creations    = pr.second.first;
       const unsigned int destructions = pr.second.second;
 
       oss << "| " << name << " reference count information:\n"
           << "|  Creations:    " << creations    << '\n'
           << "|  Destructions: " << destructions << '\n';
     }
 
   oss << " ---------------------------------------------------------------------------- \n";
 
   return oss.str();
 
 #else
 
   return "";
 
 #endif
 }

◆ get_info() [2/3]

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

staticinherited

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

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

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

 {
 #if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
 
   std::ostringstream oss;
 
   oss << '\n'
       << " ---------------------------------------------------------------------------- \n"
       << "| Reference count information                                                |\n"
       << " ---------------------------------------------------------------------------- \n";
 
   for (const auto & pr : _counts)
     {
       const std::string name(pr.first);
       const unsigned int creations    = pr.second.first;
       const unsigned int destructions = pr.second.second;
 
       oss << "| " << name << " reference count information:\n"
           << "|  Creations:    " << creations    << '\n'
           << "|  Destructions: " << destructions << '\n';
     }
 
   oss << " ---------------------------------------------------------------------------- \n";
 
   return oss.str();
 
 #else
 
   return "";
 
 #endif
 }

◆ get_info() [3/3]

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

inherited

Prints relevant information about the element to a string.

Definition at line 2448 of file elem.C.

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

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

◆ get_node()

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

inlineinherited

Returns: The pointer to local Node i.

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

Definition at line 1996 of file elem.h.

References libMesh::Elem::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

inlineinherited

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

Definition at line 2012 of file elem.h.

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

Referenced by libMesh::ElemCutter::find_intersection_points().

 {
   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

inlineinherited

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

Definition at line 1949 of file elem.h.

References libMesh::Elem::_nodes.

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

 {
   return _nodes;
 }

◆ hack_p_level()

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

inlineinherited

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

Definition at line 2739 of file elem.h.

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

Referenced by libMesh::CheckpointIO::read_connectivity(), libMesh::XdrIO::read_serialized_connectivity(), and libMesh::Parallel::Packing< T >::unpack().

 {
   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

inlinevirtualinherited

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

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

988 { return false; }

◆ has_ancestor_children()

bool libMesh::Elem::has_ancestor_children ( ) const

inlineinherited

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

Definition at line 2442 of file elem.h.

References libMesh::Elem::_children, and libMesh::Elem::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

inlineinherited

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

Definition at line 2428 of file elem.h.

References libMesh::Elem::_children.

Referenced by libMesh::Elem::add_child(), libMesh::Elem::ancestor(), libMesh::connect_children(), libMesh::connect_families(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::Elem::get_info(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Elem >(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::Elem::make_links_to_me_local(), libMesh::Elem::make_links_to_me_remote(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::FEMSystem::mesh_position_set(), libMesh::Parallel::Packing< T >::pack(), libMesh::Elem::remove_links_to_me(), libMesh::Elem::replace_child(), libMesh::Elem::set_child(), libMesh::Elem::subactive(), libMesh::Parallel::sync_element_data_by_parent_id(), libMesh::Elem::total_family_tree(), libMesh::Elem::total_family_tree_by_neighbor(), libMesh::Elem::total_family_tree_by_subneighbor(), libMesh::Parallel::Packing< T >::unpack(), and libMesh::Elem::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

inlineinherited

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

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

 {
   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

inlineinherited

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

Definition at line 2093 of file elem.h.

References libMesh::Elem::neighbor_ptr_range().

Referenced by libMesh::Elem::active_family_tree_by_neighbor(), libMesh::Elem::family_tree_by_neighbor(), libMesh::Elem::family_tree_by_subneighbor(), libMesh::Elem::has_topological_neighbor(), libMesh::MeshRefinement::has_topological_neighbor(), libMesh::Elem::min_new_p_level_by_neighbor(), libMesh::Elem::min_p_level_by_neighbor(), libMesh::Elem::on_boundary(), libMesh::Elem::total_family_tree_by_neighbor(), and libMesh::Elem::total_family_tree_by_subneighbor().

 {
   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

inherited

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

Definition at line 957 of file elem.C.

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

Referenced by libMesh::Elem::active_family_tree_by_topological_neighbor(), and libMesh::MeshRefinement::has_topological_neighbor().

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

◆ hmax()

Real libMesh::Elem::hmax ( ) const

virtualinherited

Returns: The maximum vertex separation for the element.

Definition at line 373 of file elem.C.

References std::max(), libMesh::Elem::n_vertices(), libMesh::TypeVector< T >::norm_sq(), libMesh::Elem::point(), and libMesh::Real.

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

 {
   Real h_max=0;
 
   for (unsigned int n_outer=0; n_outer<this->n_vertices(); n_outer++)
     for (unsigned int n_inner=n_outer+1; n_inner<this->n_vertices(); n_inner++)
       {
         const Point diff = (this->point(n_outer) - this->point(n_inner));
 
         h_max = std::max(h_max, diff.norm_sq());
       }
 
   return std::sqrt(h_max);
 }

◆ hmin()

Real libMesh::Elem::hmin ( ) const

virtualinherited

Returns: The minimum vertex separation for the element.

Definition at line 356 of file elem.C.

References std::max(), std::min(), libMesh::Elem::n_vertices(), libMesh::TypeVector< T >::norm_sq(), libMesh::Elem::point(), and libMesh::Real.

Referenced by libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), libMesh::MeshTools::Modification::distort(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::Elem::get_info(), libMesh::FEMSystem::numerical_jacobian(), and libMesh::ReplicatedMesh::stitching_helper().

 {
   Real h_min=std::numeric_limits<Real>::max();
 
   for (unsigned int n_outer=0; n_outer<this->n_vertices(); n_outer++)
     for (unsigned int n_inner=n_outer+1; n_inner<this->n_vertices(); n_inner++)
       {
         const Point diff = (this->point(n_outer) - this->point(n_inner));
 
         h_min = std::min(h_min, diff.norm_sq());
       }
 
   return std::sqrt(h_min);
 }

◆ id()

dof_id_type libMesh::DofObject::id ( ) const

inlineinherited

Returns: The id for this DofObject

Definition at line 655 of file dof_object.h.

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

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

◆ increment_constructor_count() [1/2]

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

inlineprotectedinherited

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 )

inlineprotectedinherited

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 )

inlineprotectedinherited

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 )

inlineprotectedinherited

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::InfCell::infinite ( ) const

inlineoverridevirtualinherited

Returns: true. All classes derived from InfCell are infinite elements.

Implements libMesh::Elem.

Definition at line 72 of file cell_inf.h.

72 { return true; }

◆ interior_parent() [1/2]

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

inherited

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

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

This method is not safe to call if this->dim() == LIBMESH_DIM; in such cases no data storage for an interior parent pointer has been allocated.

Definition at line 804 of file elem.C.

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

Referenced by libMesh::Elem::find_interior_neighbors(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::BoundaryInfo::get_side_and_node_maps(), libMesh::MeshTools::libmesh_assert_valid_amr_interior_parents(), libMesh::Parallel::Packing< T >::pack(), and libMesh::Parallel::Packing< T >::unpack().

 {
   // interior parents make no sense for full-dimensional elements.
   libmesh_assert_less (this->dim(), LIBMESH_DIM);
 
   // they USED TO BE only good for level-0 elements, but we now
   // support keeping interior_parent() valid on refined boundary
   // elements.
   // if (this->level() != 0)
   // return this->parent()->interior_parent();
 
   // We store the interior_parent pointer after both the parent
   // neighbor and neighbor pointers
   Elem * interior_p = _elemlinks[1+this->n_sides()];
 
   // If we have an interior_parent, we USED TO assume it was a
   // one-higher-dimensional interior element, but we now allow e.g.
   // edge elements to have a 3D interior_parent with no
   // intermediate 2D element.
   // libmesh_assert (!interior_p ||
   //                interior_p->dim() == (this->dim()+1));
   libmesh_assert (!interior_p ||
                   (interior_p == remote_elem) ||
                   (interior_p->dim() > this->dim()));
 
   // We require consistency between AMR of interior and of boundary
   // elements
   if (interior_p && (interior_p != remote_elem))
     libmesh_assert_less_equal (interior_p->level(), this->level());
 
   return interior_p;
 }

◆ interior_parent() [2/2]

Elem * libMesh::Elem::interior_parent ( )

inherited

Definition at line 839 of file elem.C.

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

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

◆ invalidate()

void libMesh::DofObject::invalidate ( )

inlineinherited

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 )

inlineinherited

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

inlineinherited

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

 {
   this->set_id (invalid_id);
 }

◆ invalidate_processor_id()

void libMesh::DofObject::invalidate_processor_id ( )

inlineinherited

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 libMesh::Partitioner::set_parent_processor_ids().

 {
   this->processor_id (invalid_processor_id);
 }

◆ is_ancestor_of()

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

inlineinherited

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

Definition at line 2458 of file elem.h.

References libMesh::Elem::parent().

Referenced by libMesh::Elem::family_tree_by_subneighbor(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::Elem::make_links_to_me_local(), and libMesh::Elem::total_family_tree_by_subneighbor().

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

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

virtualinherited

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

Definition at line 1518 of file elem.C.

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

Referenced by libMesh::FEGenericBase< FEOutputType< T >::type >::coarsened_dof_values(), and libMesh::BoundaryInfo::edge_boundary_ids().

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

◆ is_child_on_side()

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

finaloverridevirtual

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

Implements libMesh::Elem.

Definition at line 196 of file cell_inf_hex.C.

References n_children(), and n_sides().

 {
   libmesh_assert_less (c, this->n_children());
   libmesh_assert_less (s, this->n_sides());
 
   return (s == 0 || c+1 == s || c == s%4);
 }

◆ is_edge()

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

pure virtualinherited

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

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 libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints().

◆ is_edge_on_side()

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

finaloverridevirtual

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

Implements libMesh::Elem.

Definition at line 207 of file cell_inf_hex.C.

References libMesh::InfHex8::edge_nodes_map, libMesh::Elem::is_node_on_side(), n_edges(), and n_sides().

 {
   libmesh_assert_less (e, this->n_edges());
   libmesh_assert_less (s, this->n_sides());
 
   return (is_node_on_side(InfHex8::edge_nodes_map[e][0],s) &&
           is_node_on_side(InfHex8::edge_nodes_map[e][1],s));
 }

◆ is_face()

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

pure virtualinherited

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

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 libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints().

◆ is_linear()

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

inlinevirtualinherited

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

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

Definition at line 994 of file elem.h.

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

994 { return false; }

◆ is_mid_infinite_edge_node()

virtual bool libMesh::InfHex::is_mid_infinite_edge_node ( const unsigned int i ) const

inlinefinaloverridevirtual

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

Reimplemented from libMesh::Elem.

Definition at line 97 of file cell_inf_hex.h.

98 { return (i > 3 && i < 8); }

◆ is_node_on_edge()

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

pure virtualinherited

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

Implemented in libMesh::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.

Referenced by libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), libMesh::FE< Dim, LAGRANGE_VEC >::dofs_on_edge(), and libMesh::MeshTools::find_nodal_neighbors().

◆ is_node_on_side()

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

pure virtualinherited

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

Implemented in libMesh::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 libMesh::BoundaryInfo::add_elements(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), libMesh::DofMap::constrain_p_dofs(), libMesh::FE< Dim, LAGRANGE_VEC >::dofs_on_side(), libMesh::MeshTools::find_hanging_nodes_and_parents(), libMesh::Tet::is_edge_on_side(), libMesh::Hex::is_edge_on_side(), libMesh::Prism::is_edge_on_side(), libMesh::Pyramid::is_edge_on_side(), libMesh::InfPrism::is_edge_on_side(), is_edge_on_side(), libMesh::Hex::opposite_node(), libMesh::Edge::opposite_node(), libMesh::Quad::opposite_node(), and libMesh::Elem::which_side_am_i().

◆ is_remote()

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

inlinevirtualinherited

Returns: true if this element is remote, false otherwise.

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

Reimplemented in libMesh::RemoteElem.

Definition at line 555 of file elem.h.

Referenced by libMesh::Elem::active_family_tree_by_side(), libMesh::Elem::family_tree_by_side(), and libMesh::Elem::make_links_to_me_local().

556 { return false; }

◆ is_semilocal()

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

inherited

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

Definition at line 451 of file elem.C.

References libMesh::Elem::find_point_neighbors().

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

◆ is_vertex()

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

pure virtualinherited

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

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 libMesh::DofMap::_dof_indices(), libMesh::FEGenericBase< FEOutputType< T >::type >::coarsened_dof_values(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), libMesh::DofMap::constrain_p_dofs(), libMesh::ElemCutter::find_intersection_points(), libMesh::Elem::is_vertex_on_child(), and libMesh::DofMap::old_dof_indices().

◆ is_vertex_on_child()

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

inlinevirtualinherited

Returns: true if the specified child has a vertex at the specified (child-local) node number. Except in odd cases like pyramid refinement the child will have the same local structure as the parent element.

Definition at line 694 of file elem.h.

References libMesh::Elem::is_vertex().

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

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

libMesh::Elem::is_vertex

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

◆ is_vertex_on_parent()

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

virtualinherited

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

Definition at line 2879 of file elem.C.

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

 {
 #ifdef LIBMESH_ENABLE_AMR
 
   unsigned int my_n_vertices = this->n_vertices();
   for (unsigned int n_parent = 0; n_parent != my_n_vertices;
        ++n_parent)
     if (this->node_ptr(n_parent) == this->child_ptr(c)->node_ptr(n))
       return true;
   return false;
 
 #else
 
   // No AMR?
   libmesh_ignore(c,n);
   libmesh_error_msg("ERROR: AMR disabled, how did we get here?");
   return true;
 
 #endif
 }

◆ key() [1/4]

virtual dof_id_type libMesh::Elem::key

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

◆ key() [2/4]

dof_id_type libMesh::Elem::key

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

Definition at line 401 of file elem.C.

 {
   const unsigned short n_n = this->n_nodes();
 
   std::array<dof_id_type, Elem::max_n_nodes> node_ids;
 
   for (unsigned short n=0; n != n_n; ++n)
     node_ids[n] = this->node_id(n);
 
   // Always sort, so that different local node numberings hash to the
   // same value.
   std::sort (node_ids.begin(), node_ids.begin()+n_n);
 
   return Utility::hashword(node_ids.data(), n_n);
 }

◆ key() [3/4]

dof_id_type libMesh::InfHex::key ( const unsigned int s ) const

overridevirtual

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

Implements libMesh::Elem.

Reimplemented in libMesh::InfHex18.

Definition at line 75 of file cell_inf_hex.C.

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

 {
   libmesh_assert_less (s, this->n_sides());
 
   // The order of the node ids does not matter, they are sorted by the
   // compute_key() function.
   return this->compute_key(this->node_id(InfHex8::side_nodes_map[s][0]),
                            this->node_id(InfHex8::side_nodes_map[s][1]),
                            this->node_id(InfHex8::side_nodes_map[s][2]),
                            this->node_id(InfHex8::side_nodes_map[s][3]));
 }

◆ key() [4/4]

dof_id_type libMesh::Elem::key ( ) const

virtualinherited

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

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

Definition at line 401 of file elem.C.

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

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

 {
   const unsigned short n_n = this->n_nodes();
 
   std::array<dof_id_type, Elem::max_n_nodes> node_ids;
 
   for (unsigned short n=0; n != n_n; ++n)
     node_ids[n] = this->node_id(n);
 
   // Always sort, so that different local node numberings hash to the
   // same value.
   std::sort (node_ids.begin(), node_ids.begin()+n_n);
 
   return Utility::hashword(node_ids.data(), n_n);
 }

◆ length()

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

inherited

Returns: The distance between nodes n1 and n2.

Useful for computing the lengths of the sides of elements.

Definition at line 390 of file elem.C.

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

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

 {
   libmesh_assert_less ( n1, this->n_vertices() );
   libmesh_assert_less ( n2, this->n_vertices() );
 
   return (this->point(n1) - this->point(n2)).norm();
 }

◆ level()

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

inlineinherited

Returns: The refinement level of the current element.

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

Definition at line 2521 of file elem.h.

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

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

inherited

Checks for consistent neighbor links on this element.

Definition at line 990 of file elem.C.

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

 {
   for (auto n : this->side_index_range())
     {
       const Elem * neigh = this->neighbor_ptr(n);
 
       // Any element might have a remote neighbor; checking
       // to make sure that's not inaccurate is tough.
       if (neigh == remote_elem)
         continue;
 
       if (neigh)
         {
           // Only subactive elements have subactive neighbors
           libmesh_assert (this->subactive() || !neigh->subactive());
 
           const Elem * elem = this;
 
           // If we're subactive but our neighbor isn't, its
           // return neighbor link will be to our first active
           // ancestor OR to our inactive ancestor of the same
           // level as neigh,
           if (this->subactive() && !neigh->subactive())
             {
               for (elem = this; !elem->active();
                    elem = elem->parent())
                 libmesh_assert(elem);
             }
           else
             {
               unsigned int rev = neigh->which_neighbor_am_i(elem);
               libmesh_assert_less (rev, neigh->n_neighbors());
 
               if (this->subactive() && !neigh->subactive())
                 {
                   while (neigh->neighbor_ptr(rev) != elem)
                     {
                       libmesh_assert(elem->parent());
                       elem = elem->parent();
                     }
                 }
               else
                 {
                   const Elem * nn = neigh->neighbor_ptr(rev);
                   libmesh_assert(nn);
 
                   for (; elem != nn; elem = elem->parent())
                     libmesh_assert(elem);
                 }
             }
         }
       // If we don't have a neighbor and we're not subactive, our
       // ancestors shouldn't have any neighbors in this same
       // direction.
       else if (!this->subactive())
         {
           const Elem * my_parent = this->parent();
           if (my_parent &&
               // A parent with a different dimension isn't really one of
               // our ancestors, it means we're on a boundary mesh and this
               // is an interior mesh element for which we're on a side.
               // Nothing to test for in that case.
               (my_parent->dim() == this->dim()))
             libmesh_assert (!my_parent->neighbor_ptr(n));
         }
     }
 }

◆ libmesh_assert_valid_node_pointers()

void libMesh::Elem::libmesh_assert_valid_node_pointers ( ) const

inherited

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

Definition at line 978 of file elem.C.

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

 {
   libmesh_assert(this->valid_id());
   for (unsigned int n=0; n != this->n_nodes(); ++n)
     {
       libmesh_assert(this->node_ptr(n));
       libmesh_assert(this->node_ptr(n)->valid_id());
     }
 }

◆ local_node()

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

inlineinherited

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

Definition at line 1937 of file elem.h.

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

Referenced by libMesh::MeshTools::find_nodal_neighbors(), and libMesh::ReplicatedMesh::stitching_helper().

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

BoundingBox libMesh::Elem::loose_bounding_box ( ) const

virtualinherited

Returns: A bounding box (not necessarily the minimal bounding box) containing the geometric element.

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

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

Definition at line 2857 of file elem.C.

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

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

 {
   Point pmin = this->point(0);
   Point pmax = pmin;
 
   unsigned int n_points = this->n_nodes();
   for (unsigned int p=0; p != n_points; ++p)
     for (unsigned d=0; d<LIBMESH_DIM; ++d)
       {
         const Point & pt = this->point(p);
         if (pmin(d) > pt(d))
           pmin(d) = pt(d);
 
         if (pmax(d) < pt(d))
           pmax(d) = pt(d);
       }
 
   return BoundingBox(pmin, pmax);
 }

◆ make_links_to_me_local()

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

inherited

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.

Definition at line 1062 of file elem.C.

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

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

 {
   Elem * neigh = this->neighbor_ptr(n);
 
   // Don't bother calling this function unless it's necessary
   libmesh_assert(neigh);
   libmesh_assert(!neigh->is_remote());
 
   // We never have neighbors more refined than us
   libmesh_assert_less_equal (neigh->level(), this->level());
 
   // We never have subactive neighbors of non subactive elements
   libmesh_assert(!neigh->subactive() || this->subactive());
 
   // If we have a neighbor less refined than us then it must not
   // have any more refined descendants we could have pointed to
   // instead.
   libmesh_assert((neigh->level() == this->level()) ||
                  (neigh->active() && !this->subactive()) ||
                  (!neigh->has_children() && this->subactive()));
 
   // If neigh is at our level, then its family might have
   // remote_elem neighbor links which need to point to us
   // instead, but if not, then we're done.
   if (neigh->level() != this->level())
     return;
 
   // What side of neigh are we on?  We can't use the usual Elem
   // method because we're in the middle of restoring topology
   const std::unique_ptr<Elem> my_side = this->side_ptr(n);
   unsigned int nn = 0;
   for (; nn != neigh->n_sides(); ++nn)
     {
       const std::unique_ptr<Elem> neigh_side = neigh->side_ptr(nn);
       if (*my_side == *neigh_side)
         break;
     }
 
   // we had better be on *some* side of neigh
   libmesh_assert_less (nn, neigh->n_sides());
 
   // Find any elements that ought to point to elem
   std::vector<const Elem *> neigh_family;
 #ifdef LIBMESH_ENABLE_AMR
   if (this->active())
     neigh->family_tree_by_side(neigh_family, nn);
   else if (neigh->subactive())
 #endif
     neigh_family.push_back(neigh);
 
   // And point them to elem
   for (auto & const_elem : neigh_family)
     {
       // This const_cast is necessary until we have a version of
       // family_tree_by_side that returns a vector of non-constant
       // pointers when called on a non-constant Elem.
       Elem * neigh_family_member = const_cast<Elem *>(const_elem);
 
       // Only subactive elements point to other subactive elements
       if (this->subactive() && !neigh_family_member->subactive())
         continue;
 
       // Ideally, the neighbor link ought to either be correct
       // already or ought to be to remote_elem.
       //
       // However, if we're redistributing a newly created elem,
       // after an AMR step but before find_neighbors has fixed up
       // neighbor links, we might have an out of date neighbor
       // link to elem's parent instead.
 #ifdef LIBMESH_ENABLE_AMR
       libmesh_assert((neigh_family_member->neighbor_ptr(nn) &&
                       (neigh_family_member->neighbor_ptr(nn)->active() ||
                        neigh_family_member->neighbor_ptr(nn)->is_ancestor_of(this))) ||
                      (neigh_family_member->neighbor_ptr(nn) == remote_elem) ||
                      ((this->refinement_flag() == JUST_REFINED) &&
                       (this->parent() != nullptr) &&
                       (neigh_family_member->neighbor_ptr(nn) == this->parent())));
 #else
       libmesh_assert((neigh_family_member->neighbor_ptr(nn) == this) ||
                      (neigh_family_member->neighbor_ptr(nn) == remote_elem));
 #endif
 
       neigh_family_member->set_neighbor(nn, this);
     }
 }

◆ make_links_to_me_remote()

void libMesh::Elem::make_links_to_me_remote ( )

inherited

Resets this element's neighbors' appropriate neighbor pointers and its parent's and children's appropriate pointers to point to the global remote_elem instead of this. Used by the library before an element becomes remote on the local processor.

Definition at line 1149 of file elem.C.

References libMesh::Elem::child(), libMesh::Elem::child_ptr(), libMesh::Elem::child_ref_range(), libMesh::Elem::dim(), libMesh::Elem::has_children(), libMesh::Elem::level(), libMesh::Elem::n_neighbors(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::neighbor_ptr_range(), libMesh::Elem::parent(), libMesh::remote_elem, libMesh::Elem::set_child(), libMesh::Elem::set_neighbor(), libMesh::Elem::subactive(), libMesh::Elem::which_child_am_i(), and libMesh::Elem::which_neighbor_am_i().

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

 {
   libmesh_assert_not_equal_to (this, remote_elem);
 
   // We need to have handled any children first
 #if defined(LIBMESH_ENABLE_AMR) && defined(DEBUG)
   if (this->has_children())
     for (auto & child : this->child_ref_range())
       libmesh_assert_equal_to (&child, remote_elem);
 #endif
 
   // Remotify any neighbor links
   for (auto neigh : this->neighbor_ptr_range())
     {
       if (neigh && neigh != remote_elem)
         {
           // My neighbor should never be more refined than me; my real
           // neighbor would have been its parent in that case.
           libmesh_assert_greater_equal (this->level(), neigh->level());
 
           if (this->level() == neigh->level() &&
               neigh->has_neighbor(this))
             {
 #ifdef LIBMESH_ENABLE_AMR
               // My neighbor may have descendants which also consider me a
               // neighbor
               std::vector<const Elem *> family;
               neigh->total_family_tree_by_neighbor (family, this);
 
               // FIXME - There's a lot of ugly const_casts here; we
               // may want to make remote_elem non-const and create
               // non-const versions of the family_tree methods
               for (auto & const_elem : family)
                 {
                   Elem * n = const_cast<Elem *>(const_elem);
                   libmesh_assert (n);
                   if (n == remote_elem)
                     continue;
                   unsigned int my_s = n->which_neighbor_am_i(this);
                   libmesh_assert_less (my_s, n->n_neighbors());
                   libmesh_assert_equal_to (n->neighbor_ptr(my_s), this);
                   n->set_neighbor(my_s, const_cast<RemoteElem *>(remote_elem));
                 }
 #else
               unsigned int my_s = neigh->which_neighbor_am_i(this);
               libmesh_assert_less (my_s, neigh->n_neighbors());
               libmesh_assert_equal_to (neigh->neighbor_ptr(my_s), this);
               neigh->set_neighbor(my_s, const_cast<RemoteElem *>(remote_elem));
 #endif
             }
 #ifdef LIBMESH_ENABLE_AMR
           // Even if my neighbor doesn't link back to me, it might
           // have subactive descendants which do
           else if (neigh->has_children())
             {
               // If my neighbor at the same level doesn't have me as a
               // neighbor, I must be subactive
               libmesh_assert(this->level() > neigh->level() ||
                              this->subactive());
 
               // My neighbor must have some ancestor of mine as a
               // neighbor
               Elem * my_ancestor = this->parent();
               libmesh_assert(my_ancestor);
               while (!neigh->has_neighbor(my_ancestor))
                 {
                   my_ancestor = my_ancestor->parent();
                   libmesh_assert(my_ancestor);
                 }
 
               // My neighbor may have descendants which consider me a
               // neighbor
               std::vector<const Elem *> family;
               neigh->total_family_tree_by_subneighbor (family, my_ancestor, this);
 
               // FIXME - There's a lot of ugly const_casts here; we
               // may want to make remote_elem non-const and create
               // non-const versions of the family_tree methods
               for (auto & const_elem : family)
                 {
                   Elem * n = const_cast<Elem *>(const_elem);
                   libmesh_assert (n);
                   if (n == remote_elem)
                     continue;
                   unsigned int my_s = n->which_neighbor_am_i(this);
                   libmesh_assert_less (my_s, n->n_neighbors());
                   libmesh_assert_equal_to (n->neighbor_ptr(my_s), this);
                   n->set_neighbor(my_s, const_cast<RemoteElem *>(remote_elem));
                 }
             }
 #endif
         }
     }
 
 #ifdef LIBMESH_ENABLE_AMR
   // Remotify parent's child link
   Elem * my_parent = this->parent();
   if (my_parent &&
       // As long as it's not already remote
       my_parent != remote_elem &&
       // And it's a real parent, not an interior parent
       this->dim() == my_parent->dim())
     {
       unsigned int me = my_parent->which_child_am_i(this);
       libmesh_assert_equal_to (my_parent->child_ptr(me), this);
       my_parent->set_child(me, const_cast<RemoteElem *>(remote_elem));
     }
 #endif
 }

◆ master_point()

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

inlinefinaloverridevirtual

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

Implements libMesh::Elem.

Definition at line 72 of file cell_inf_hex.h.

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

   {
     libmesh_assert_less(i, this->n_nodes());
     return Point(_master_points[i][0],
                  _master_points[i][1],
                  _master_points[i][2]);
   }

◆ max_descendant_p_level()

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

inlineinherited

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

Definition at line 2674 of file elem.h.

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

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

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

inherited

Returns: The minimum new p-refinement level (i.e. after refinement and coarsening is done) of elements which are descended from this element and which share a side with the active neighbor.

Definition at line 1899 of file elem.C.

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

 {
   libmesh_assert(!this->subactive());
   libmesh_assert(neighbor_in->active());
 
   // If we're an active element this is simple
   if (this->active())
     {
       unsigned int new_p_level = this->p_level();
       if (this->p_refinement_flag() == Elem::REFINE)
         new_p_level += 1;
       if (this->p_refinement_flag() == Elem::COARSEN)
         {
           libmesh_assert_greater (new_p_level, 0);
           new_p_level -= 1;
         }
       return std::min(current_min, new_p_level);
     }
 
   libmesh_assert(has_neighbor(neighbor_in));
 
   unsigned int min_p_level = current_min;
 
   for (auto & c : this->child_ref_range())
     if (&c != remote_elem && c.has_neighbor(neighbor_in))
       min_p_level =
         c.min_new_p_level_by_neighbor(neighbor_in, min_p_level);
 
   return min_p_level;
 }

◆ min_p_level_by_neighbor()

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

inherited

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

Definition at line 1870 of file elem.C.

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

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

 {
   libmesh_assert(!this->subactive());
   libmesh_assert(neighbor_in->active());
 
   // If we're an active element this is simple
   if (this->active())
     return std::min(current_min, this->p_level());
 
   libmesh_assert(has_neighbor(neighbor_in));
 
   // The p_level() of an ancestor element is already the minimum
   // p_level() of its children - so if that's high enough, we don't
   // need to examine any children.
   if (current_min <= this->p_level())
     return current_min;
 
   unsigned int min_p_level = current_min;
 
   for (auto & c : this->child_ref_range())
     if (&c != remote_elem && c.has_neighbor(neighbor_in))
       min_p_level =
         c.min_p_level_by_neighbor(neighbor_in, min_p_level);
 
   return min_p_level;
 }

◆ n_children()

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

inlinefinaloverridevirtual

Returns: 4.

Implements libMesh::Elem.

Definition at line 114 of file cell_inf_hex.h.

Referenced by is_child_on_side().

114 { return 4; }

◆ n_comp()

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

inlineinherited

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

Definition at line 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::DofMap::allgather_recursive_constraints(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), libMesh::DofMap::constrain_p_dofs(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::DofMap::distribute_dofs(), libMesh::DofObject::dof_number(), libMesh::DofObject::DofObject(), libMesh::OldSolutionValue< Output, point_output >::eval_at_node(), libMesh::OldSolutionCoefs< Output, point_output >::eval_at_node(), libMesh::Node::get_info(), libMesh::Elem::get_info(), libMesh::DofMap::local_variable_indices(), libMesh::DofObject::n_dofs(), libMesh::DofObject::operator=(), libMesh::DofObject::print_dof_info(), libMesh::DofObject::set_dof_number(), libMesh::DofObject::set_n_vars_per_group(), and libMesh::DofMap::set_nonlocal_dof_objects().

 {
   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

inlineinherited

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

Definition at line 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::DofMap::_dof_indices(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DofMap::dof_indices(), libMesh::DofObject::dof_number(), libMesh::DofObject::invalidate_dofs(), libMesh::DofObject::n_comp(), libMesh::DofMap::old_dof_indices(), libMesh::BuildProjectionList::operator()(), libMesh::DofMap::reinit(), libMesh::DofObject::set_dof_number(), libMesh::DofObject::set_n_comp_group(), libMesh::DofObject::set_n_vars_per_group(), and libMesh::DofMap::set_nonlocal_dof_objects().

 {
   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

inlineinherited

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

Referenced by libMesh::PetscDMWrapper::add_dofs_helper().

 {
   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::InfHex::n_edges ( ) const

inlinefinaloverridevirtual

Returns: 8. All infinite hexahedra have 8 edges, 4 lying in the base, and 4 perpendicular to the base.

Implements libMesh::Elem.

Definition at line 104 of file cell_inf_hex.h.

Referenced by libMesh::InfHex8::build_edge_ptr(), libMesh::InfHex18::build_edge_ptr(), libMesh::InfHex16::build_edge_ptr(), is_edge_on_side(), libMesh::InfHex8::is_node_on_edge(), libMesh::InfHex16::is_node_on_edge(), and libMesh::InfHex18::is_node_on_edge().

104 { return 8; }

◆ n_faces()

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

inlinefinaloverridevirtual

Returns: 5. All infinite hexahedra have 5 faces.

Implements libMesh::Elem.

Definition at line 109 of file cell_inf_hex.h.

109 { return 5; }

◆ n_neighbors()

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

inlineinherited

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

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

Definition at line 644 of file elem.h.

References libMesh::Elem::n_sides().

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

645 { 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 virtualinherited

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 libMesh::FEMContext::_do_elem_position_set(), libMesh::BoundaryInfo::add_elements(), libMesh::Elem::as_parent_node(), libMesh::TetGenMeshInterface::assign_nodes_to_elem(), libMesh::Elem::bracketing_nodes(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::Elem::coarsen(), libMesh::FEGenericBase< FEOutputType< T >::type >::coarsened_dof_values(), libMesh::FEMap::compute_affine_map(), libMesh::FEMap::compute_map(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_proj_constraints(), libMesh::DofMap::constrain_p_dofs(), libMesh::DofMap::dof_indices(), libMesh::FE< Dim, LAGRANGE_VEC >::dofs_on_edge(), libMesh::FE< Dim, LAGRANGE_VEC >::dofs_on_side(), libMesh::FEMContext::elem_position_get(), libMesh::MeshTools::find_nodal_neighbors(), libMesh::Elem::get_info(), libMesh::Elem::get_node_index(), libMesh::Elem::key(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::Elem::libmesh_assert_valid_node_pointers(), libMesh::Elem::local_node(), libMesh::Elem::loose_bounding_box(), libMesh::Hex::master_point(), libMesh::Tet::master_point(), libMesh::InfPrism::master_point(), master_point(), libMesh::InfQuad::master_point(), libMesh::Elem::n_nodes_in_child(), libMesh::Elem::node_id(), libMesh::Elem::node_index_range(), libMesh::Elem::node_ptr(), libMesh::Elem::node_ref_range(), libMesh::DofMap::old_dof_indices(), libMesh::Elem::operator==(), libMesh::Hex::opposite_node(), libMesh::Parallel::Packing< T >::pack(), libMesh::XdrIO::pack_element(), libMesh::Parallel::Packing< T >::packable_size(), libMesh::Elem::parent_bracketing_nodes(), libMesh::Elem::point(), libMesh::TetGenMeshInterface::pointset_convexhull(), libMesh::VTKIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::UCDIO::read_implementation(), libMesh::GmshIO::read_mesh(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::Elem::refine(), libMesh::FE< Dim, LAGRANGE_VEC >::reinit(), libMesh::DistributedMesh::renumber_nodes_and_elements(), libMesh::Elem::set_node(), libMesh::FE< Dim, LAGRANGE_VEC >::shape(), libMesh::FE< Dim, LAGRANGE_VEC >::shape_deriv(), libMesh::FE< Dim, LAGRANGE_VEC >::shape_second_deriv(), libMesh::FE< Dim, LAGRANGE_VEC >::side_map(), libMesh::MeshTools::Modification::smooth(), libMesh::Parallel::sync_node_data_by_element_id_once(), libMesh::TetGenMeshInterface::triangulate_conformingDelaunayMesh_carvehole(), libMesh::TetGenMeshInterface::triangulate_pointset(), libMesh::Parallel::Packing< T >::unpack(), libMesh::Elem::which_side_am_i(), libMesh::Nemesis_IO_Helper::write_elements(), and libMesh::ExodusII_IO_Helper::write_elements().

◆ n_nodes_in_child()

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

inlinevirtualinherited

Returns: The number of nodes the given child of this element contains. Except in odd cases like pyramid refinement this will be the same as the number of nodes in the parent element.

Definition at line 613 of file elem.h.

References libMesh::Elem::n_nodes().

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

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

inlinestaticinherited

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

Definition: reference_counter.h:130

◆ n_objects() [2/2]

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

inlinestaticinherited

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

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

Definition: reference_counter.h:130

◆ n_second_order_adjacent_vertices()

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

virtualinherited

Returns: The number of adjacent vertices that uniquely define the location of the $n^{th}$ second-order node, or 0 for linear elements.

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

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

Reimplemented in libMesh::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.

Definition at line 2558 of file elem.C.

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

 {
   // for linear elements, always return 0
   return 0;
 }

◆ n_sides()

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

inlinefinaloverridevirtual

Returns: 5. Infinite elements have one side less than their conventional counterparts, since one side is supposed to be located at infinity.

Implements libMesh::Elem.

Definition at line 85 of file cell_inf_hex.h.

Referenced by libMesh::InfHex8::build_side_ptr(), libMesh::InfHex18::build_side_ptr(), libMesh::InfHex16::build_side_ptr(), is_child_on_side(), is_edge_on_side(), libMesh::InfHex8::is_node_on_side(), libMesh::InfHex16::is_node_on_side(), libMesh::InfHex18::is_node_on_side(), key(), libMesh::InfHex18::key(), libMesh::InfHex8::nodes_on_side(), libMesh::InfHex16::nodes_on_side(), libMesh::InfHex18::nodes_on_side(), side_ptr(), libMesh::InfHex16::which_node_am_i(), which_node_am_i(), and libMesh::InfHex18::which_node_am_i().

85 { return 5; }

◆ n_sub_elem()

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

pure virtualinherited

Returns: The number of sub-elements this element may be broken down into for visualization purposes. For example, 1 for a linear triangle, 4 for a quadratic (6-noded) triangle, etc...

Implemented in libMesh::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.

Referenced by libMesh::MeshBase::n_active_sub_elem(), libMesh::MeshBase::n_sub_elem(), and libMesh::Elem::write_connectivity().

◆ n_systems()

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

inlineinherited

Returns: The number of systems associated with this DofObject

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

inlineinherited

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

 {
   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

inlineinherited

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

 {
   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

inlineinherited

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::InfHex::n_vertices ( ) const

inlinefinaloverridevirtual

Returns: 8. All infinite hexahedra (in our setting) have 8 vertices.

Implements libMesh::Elem.

Definition at line 91 of file cell_inf_hex.h.

Referenced by libMesh::InfHex16::second_order_adjacent_vertex(), libMesh::InfHex18::second_order_adjacent_vertex(), libMesh::InfHex16::second_order_child_vertex(), and libMesh::InfHex18::second_order_child_vertex().

91 { return 8; }

◆ neighbor()

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

inlineinherited

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

Definition at line 2071 of file elem.h.

References libMesh::Elem::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

inlineinherited

Returns: A const pointer to the $i^{th}$ neighbor of this element, or nullptr if MeshBase::find_neighbors() has not been called.

Note: If MeshBase::find_neighbors() has been called and this function still returns nullptr, then the side is on a boundary of the domain.

Definition at line 2050 of file elem.h.

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

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::MeshTools::Subdivision::add_boundary_ghosts(), libMesh::BoundaryInfo::add_elements(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::BoundaryInfo::boundary_ids(), libMesh::Partitioner::build_graph(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::FEAbstract::compute_node_constraints(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), libMesh::FEAbstract::compute_periodic_node_constraints(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_proj_constraints(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::BoundaryInfo::edge_boundary_ids(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::MeshTools::find_hanging_nodes_and_parents(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::MeshTools::Subdivision::find_one_ring(), libMesh::MeshTools::Modification::flatten(), libMesh::Elem::get_info(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::Elem::libmesh_assert_valid_neighbors(), libMesh::Elem::make_links_to_me_local(), libMesh::Elem::make_links_to_me_remote(), libMesh::Elem::neighbor(), libMesh::Elem::nullify_neighbors(), libMesh::DefaultCoupling::operator()(), libMesh::MetisPartitioner::partition_range(), libMesh::CheckpointIO::read_remote_elem(), libMesh::FE< Dim, LAGRANGE_VEC >::reinit(), libMesh::Elem::remove_links_to_me(), libMesh::FE< Dim, LAGRANGE_VEC >::side_map(), libMesh::Elem::SideIter::side_on_boundary(), libMesh::BoundaryInfo::side_with_boundary_id(), libMesh::MeshTools::Modification::smooth(), libMesh::ReplicatedMesh::stitching_helper(), libMesh::Elem::topological_neighbor(), libMesh::MeshRefinement::topological_neighbor(), libMesh::Parallel::Packing< T >::unpack(), libMesh::Elem::which_neighbor_am_i(), and libMesh::CheckpointIO::write_remote_elem().

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

◆ neighbor_ptr() [2/2]

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

inlineinherited

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

Definition at line 2060 of file elem.h.

References libMesh::Elem::_elemlinks, and libMesh::Elem::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 ( )

inlineinherited

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

Definition at line 2988 of file elem.h.

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

Referenced by libMesh::Elem::child_neighbor(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::Elem::has_neighbor(), libMesh::Elem::make_links_to_me_remote(), libMesh::Parallel::Packing< T >::pack(), and libMesh::Elem::remove_links_to_me().

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

◆ neighbor_ptr_range() [2/2]

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

inlineinherited

Definition at line 2995 of file elem.h.

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

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

◆ node()

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

inlineinherited

Returns: The global id number of local Node i.

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

Definition at line 1927 of file elem.h.

References libMesh::Elem::node_id().

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

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

◆ node_id()

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

inlineinherited

Returns: The global id number of local Node i.

Definition at line 1914 of file elem.h.

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

 {
   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

inlineinherited

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

Definition at line 2148 of file elem.h.

References libMesh::Elem::n_nodes().

Referenced by libMesh::MeshRefinement::add_node(), libMesh::MeshTools::Modification::flatten(), libMesh::XdrIO::pack_element(), libMesh::MeshTools::Modification::smooth(), and libMesh::Elem::write_connectivity().

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

◆ node_ptr() [1/2]

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

inlineinherited

Returns: A const pointer to local Node i.

Definition at line 1957 of file elem.h.

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

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

inlineinherited

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

Definition at line 1968 of file elem.h.

References libMesh::Elem::_nodes, and libMesh::Elem::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

inlineinherited

Returns: A const reference to local Node i.

Definition at line 1979 of file elem.h.

References libMesh::Elem::node_ptr().

Referenced by libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), libMesh::DofMap::constrain_p_dofs(), libMesh::TopologyMap::fill(), libMesh::Elem::get_info(), libMesh::MeshCommunication::make_new_node_proc_ids_parallel_consistent(), and 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 )

inlineinherited

Returns: A writable reference to local Node i.

Definition at line 1987 of file elem.h.

References libMesh::Elem::node_ptr().

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

◆ node_ref_range() [1/2]

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

inlineinherited

Returns a range with all nodes of an element, usable in range-based for loops. The exact type of the return value here may be subject to change in future libMesh releases, but the iterators will always dereference to produce a reference to a Node.

Definition at line 2130 of file elem.h.

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

Referenced by libMesh::MeshTools::Modification::distort(), libMesh::Elem::find_interior_neighbors(), libMesh::MeshCommunication::make_new_node_proc_ids_parallel_consistent(), libMesh::Elem::point_test(), libMesh::reconnect_nodes(), and libMesh::ReplicatedMesh::renumber_nodes_and_elements().

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

◆ node_ref_range() [2/2]

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

inlineinherited

Definition at line 2139 of file elem.h.

References libMesh::Elem::_nodes, and libMesh::Elem::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 virtualinherited

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

inherited

Replaces this element with nullptr for all of its neighbors. This is useful when deleting an element.

Definition at line 2532 of file elem.C.

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

 {
   // Tell any of my neighbors about my death...
   // Looks strange, huh?
   for (auto n : this->side_index_range())
     {
       Elem * current_neighbor = this->neighbor_ptr(n);
       if (current_neighbor && current_neighbor != remote_elem)
         {
           // Note:  it is possible that I see the neighbor
           // (which is coarser than me)
           // but they don't see me, so avoid that case.
           if (current_neighbor->level() == this->level())
             {
               const unsigned int w_n_a_i = current_neighbor->which_neighbor_am_i(this);
               libmesh_assert_less (w_n_a_i, current_neighbor->n_neighbors());
               current_neighbor->set_neighbor(w_n_a_i, nullptr);
               this->set_neighbor(n, nullptr);
             }
         }
     }
 }

◆ on_boundary()

bool libMesh::Elem::on_boundary ( ) const

inlineinherited

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

Definition at line 2304 of file elem.h.

References libMesh::Elem::has_neighbor().

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

◆ operator=() [1/2]

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

delete

◆ operator=() [2/2]

InfHex& libMesh::InfHex::operator= ( InfHex && )

delete

◆ operator==()

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

inherited

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.

Definition at line 419 of file elem.C.

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

 {
   // If the elements aren't the same type, they aren't equal
   if (this->type() != rhs.type())
     return false;
 
   const unsigned short n_n = this->n_nodes();
   libmesh_assert_equal_to(n_n, rhs.n_nodes());
 
   // Make two sorted arrays of global node ids and compare them for
   // equality.
   std::array<dof_id_type, Elem::max_n_nodes> this_ids, rhs_ids;
 
   for (unsigned short n = 0; n != n_n; n++)
     {
       this_ids[n] = this->node_id(n);
       rhs_ids[n] = rhs.node_id(n);
     }
 
   // Sort the vectors to rule out different local node numberings.
   std::sort(this_ids.begin(), this_ids.begin()+n_n);
   std::sort(rhs_ids.begin(), rhs_ids.begin()+n_n);
 
   // If the node ids match, the elements are equal!
   for (unsigned short n = 0; n != n_n; ++n)
     if (this_ids[n] != rhs_ids[n])
       return false;
   return true;
 }

◆ opposite_node()

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

virtualinherited

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

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

Definition at line 2911 of file elem.C.

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

◆ opposite_side()

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

virtualinherited

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

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

Definition at line 2903 of file elem.C.

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

◆ origin()

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

inlineoverridevirtualinherited

Returns: The origin of this infinite element.

Reimplemented from libMesh::Elem.

Definition at line 77 of file cell_inf.h.

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

Referenced by libMesh::InfPrism::contains_point(), and contains_point().

   {
     return (this->point(0)*2 - this->point(this->n_vertices()/2));
   }

◆ p_level()

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

inlineinherited

Returns: The value of the p refinement level of an active element, or the minimum value of the p refinement levels of an ancestor element's descendants.

Definition at line 2555 of file elem.h.

References libMesh::Elem::_p_level.

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

◆ p_refinement_flag()

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

inlineinherited

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

Definition at line 2654 of file elem.h.

References libMesh::Elem::_pflag.

Referenced by libMesh::FEMContext::build_new_fe(), libMesh::Elem::get_info(), libMesh::Elem::hack_p_level(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_flags(), libMesh::MeshRefinement::limit_overrefined_boundary(), libMesh::MeshRefinement::limit_underrefined_boundary(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshRefinement::make_flags_parallel_consistent(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::Elem::min_new_p_level_by_neighbor(), libMesh::DofMap::old_dof_indices(), libMesh::Parallel::Packing< T >::pack(), libMesh::Elem::refine(), and libMesh::Parallel::Packing< T >::unpack().

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

Definition at line 520 of file dof_object.C.

References libMesh::DofObject::_idx_buf, libMesh::DofObject::old_dof_object, and libMesh::DofObject::pack_indexing().

Referenced by libMesh::Parallel::Packing< T >::pack(), and libMesh::DofObject::pack_indexing().

 {
 #ifdef LIBMESH_ENABLE_AMR
   // We might need to pack old_dof_object too
   *target++ = (old_dof_object == nullptr) ? 0 : 1;
 #endif
 
   *target++ = _idx_buf.size();
   std::copy(_idx_buf.begin(), _idx_buf.end(), target);
 
 #ifdef LIBMESH_ENABLE_AMR
   if (old_dof_object)
     old_dof_object->pack_indexing(target);
 #endif
 }

◆ packed_indexing_size()

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

inherited

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

Definition at line 445 of file dof_object.C.

References libMesh::DofObject::_idx_buf, libMesh::DofObject::old_dof_object, and libMesh::DofObject::packed_indexing_size().

Referenced by libMesh::Parallel::Packing< T >::packable_size(), libMesh::DofObject::packed_indexing_size(), libMesh::Node::packed_size(), and libMesh::Parallel::Packing< T >::unpack().

 {
   return
     cast_int<unsigned int> (
 #ifdef LIBMESH_ENABLE_AMR
                             ((old_dof_object == nullptr) ? 0 : old_dof_object->packed_indexing_size()) + 2 +
 #else
                             1 +
 #endif
                             _idx_buf.size());
 }

◆ parent() [1/2]

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

inlineinherited

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

Definition at line 2479 of file elem.h.

References libMesh::Elem::_elemlinks.

Referenced by libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::Elem::add_child(), libMesh::BoundaryInfo::add_elements(), libMesh::UnstructuredMesh::all_first_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::BoundaryInfo::boundary_ids(), libMesh::OldSolutionBase< Output, point_output >::check_old_context(), libMesh::FEAbstract::compute_node_constraints(), libMesh::connect_families(), libMesh::UnstructuredMesh::contract(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::MeshRefinement::create_parent_error_vector(), libMesh::BoundaryInfo::edge_boundary_ids(), libMesh::Elem::Elem(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::MeshTools::find_hanging_nodes_and_parents(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_error_fraction(), libMesh::MeshRefinement::flag_elements_by_error_tolerance(), libMesh::Elem::get_info(), libMesh::Elem::is_ancestor_of(), libMesh::Elem::level(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_amr_elem_ids(), libMesh::MeshTools::libmesh_assert_valid_amr_interior_parents(), libMesh::Elem::libmesh_assert_valid_neighbors(), libMesh::MeshTools::libmesh_assert_valid_remote_elems(), libMesh::MeshRefinement::limit_level_mismatch_at_edge(), libMesh::Elem::make_links_to_me_local(), libMesh::Elem::make_links_to_me_remote(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::SiblingCoupling::operator()(), libMesh::BuildProjectionList::operator()(), libMesh::Parallel::Packing< T >::pack(), libMesh::BoundaryInfo::raw_boundary_ids(), libMesh::BoundaryInfo::raw_edge_boundary_ids(), libMesh::BoundaryInfo::raw_shellface_boundary_ids(), libMesh::CheckpointIO::read_connectivity(), libMesh::Elem::refine(), libMesh::Elem::remove_links_to_me(), libMesh::HPCoarsenTest::select_refinement(), libMesh::Elem::set_p_level(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::BoundaryInfo::shellface_boundary_ids(), libMesh::BoundaryInfo::side_with_boundary_id(), libMesh::MeshTools::Modification::smooth(), libMesh::Elem::subactive(), libMesh::Parallel::sync_element_data_by_parent_id(), libMesh::Elem::top_parent(), libMesh::Elem::topological_neighbor(), libMesh::Parallel::Packing< T >::unpack(), and libMesh::Elem::which_neighbor_am_i().

 {
   return _elemlinks[0];
 }

◆ parent() [2/2]

Elem * libMesh::Elem::parent ( )

inlineinherited

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

Definition at line 2487 of file elem.h.

References libMesh::Elem::_elemlinks.

 {
   return _elemlinks[0];
 }

◆ parent_bracketing_nodes()

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

virtualinherited

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

Definition at line 2001 of file elem.C.

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

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

 {
   // Indexed first by embedding matrix type, then by child id, then by
   // child node, then by bracketing pair
   std::vector<std::vector<std::vector<std::vector<std::pair<unsigned char, unsigned char>>>>> &
     cached_bracketing_nodes = this->_get_bracketing_node_cache();
 
   const unsigned int em_vers = this->embedding_matrix_version();
 
   // We may be updating the cache on one thread, and while that
   // happens we can't safely access the cache from other threads.
   Threads::spin_mutex::scoped_lock lock(parent_bracketing_nodes_mutex);
 
   if (cached_bracketing_nodes.size() <= em_vers)
     cached_bracketing_nodes.resize(em_vers+1);
 
   const unsigned int nc = this->n_children();
 
   // If we haven't cached the bracketing nodes corresponding to this
   // embedding matrix yet, let's do so now.
   if (cached_bracketing_nodes[em_vers].size() < nc)
     {
       // If we're a second-order element but we're not a full-order
       // element, then some of our bracketing nodes may not exist
       // except on the equivalent full-order element.  Let's build an
       // equivalent full-order element and make a copy of its cache to
       // use.
       if (this->default_order() != FIRST &&
           second_order_equivalent_type(this->type(), /*full_ordered=*/ true) != this->type())
         {
           // Check that we really are the non-full-order type
           libmesh_assert_equal_to
             (second_order_equivalent_type (this->type(), false),
              this->type());
 
           // Build the full-order type
           ElemType full_type =
             second_order_equivalent_type(this->type(), /*full_ordered=*/ true);
           std::unique_ptr<Elem> full_elem = Elem::build(full_type);
 
           // This won't work for elements with multiple
           // embedding_matrix versions, but every such element is full
           // order anyways.
           libmesh_assert_equal_to(em_vers, 0);
 
           // Make sure its cache has been built.  We temporarily
           // release our mutex lock so that the inner call can
           // re-acquire it.
           lock.release();
           full_elem->parent_bracketing_nodes(0,0);
 
           // And then we need to lock again, so that if someone *else*
           // grabbed our lock before we did we don't risk accessing
           // cached_bracketing_nodes while they're working on it.
           // Threading is hard.
           lock.acquire(parent_bracketing_nodes_mutex);
 
           // Copy its cache
           cached_bracketing_nodes =
             full_elem->_get_bracketing_node_cache();
 
           // Now we don't need to build the cache ourselves.
           return cached_bracketing_nodes[em_vers][child][child_node];
         }
 
       cached_bracketing_nodes[em_vers].resize(nc);
 
       const unsigned int nn = this->n_nodes();
 
       // We have to examine each child
       for (unsigned int c = 0; c != nc; ++c)
         {
           const unsigned int ncn = this->n_nodes_in_child(c);
 
           cached_bracketing_nodes[em_vers][c].resize(ncn);
 
           // We have to examine each node in that child
           for (unsigned int n = 0; n != ncn; ++n)
             {
               // If this child node isn't a vertex or an infinite
               // child element's mid-infinite-edge node, then we need
               // to find bracketing nodes on the child.
               if (!this->is_vertex_on_child(c, n)
 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
                   && !this->is_mid_infinite_edge_node(n)
 #endif
                   )
                 {
                   // Use the embedding matrix to find the child node
                   // location in parent master element space
                   Point bracketed_pt;
 
                   for (unsigned int pn = 0; pn != nn; ++pn)
                     {
                       const float em_val =
                         this->embedding_matrix(c,n,pn);
 
                       libmesh_assert_not_equal_to (em_val, 1);
                       if (em_val != 0.)
                         bracketed_pt.add_scaled(this->master_point(pn), em_val);
                     }
 
                   // Check each pair of nodes on the child which are
                   // also both parent nodes
                   for (unsigned int n1 = 0; n1 != ncn; ++n1)
                     {
                       if (n1 == n)
                         continue;
 
                       unsigned int parent_n1 =
                         this->as_parent_node(c,n1);
 
                       if (parent_n1 == libMesh::invalid_uint)
                         continue;
 
                       Point p1 = this->master_point(parent_n1);
 
                       for (unsigned int n2 = n1+1; n2 < nn; ++n2)
                         {
                           if (n2 == n)
                             continue;
 
                           unsigned int parent_n2 =
                             this->as_parent_node(c,n2);
 
                           if (parent_n2 == libMesh::invalid_uint)
                             continue;
 
                           Point p2 = this->master_point(parent_n2);
 
                           Point pmid = (p1 + p2)/2;
 
                           if (pmid == bracketed_pt)
                             {
                               cached_bracketing_nodes[em_vers][c][n].push_back
                                 (std::make_pair(parent_n1,parent_n2));
                               break;
                             }
                           else
                             libmesh_assert(!pmid.absolute_fuzzy_equals(bracketed_pt));
                         }
                     }
                 }
               // If this child node is a parent node, we need to
               // find bracketing nodes on the parent.
               else
                 {
                   unsigned int parent_node = this->as_parent_node(c,n);
 
                   Point bracketed_pt;
 
                   // If we're not a parent node, use the embedding
                   // matrix to find the child node location in parent
                   // master element space
                   if (parent_node == libMesh::invalid_uint)
                     {
                       for (unsigned int pn = 0; pn != nn; ++pn)
                         {
                           const float em_val =
                             this->embedding_matrix(c,n,pn);
 
                           libmesh_assert_not_equal_to (em_val, 1);
                           if (em_val != 0.)
                             bracketed_pt.add_scaled(this->master_point(pn), em_val);
                         }
                     }
                   // If we're a parent node then we need no arithmetic
                   else
                     bracketed_pt = this->master_point(parent_node);
 
                   for (unsigned int n1 = 0; n1 != nn; ++n1)
                     {
                       if (n1 == parent_node)
                         continue;
 
                       Point p1 = this->master_point(n1);
 
                       for (unsigned int n2 = n1+1; n2 < nn; ++n2)
                         {
                           if (n2 == parent_node)
                             continue;
 
                           Point pmid = (p1 + this->master_point(n2))/2;
 
                           if (pmid == bracketed_pt)
                             {
                               cached_bracketing_nodes[em_vers][c][n].push_back
                                 (std::make_pair(n1,n2));
                               break;
                             }
                           else
                             libmesh_assert(!pmid.absolute_fuzzy_equals(bracketed_pt));
                         }
                     }
                 }
             }
         }
     }
 
   return cached_bracketing_nodes[em_vers][child][child_node];
 }

◆ point() [1/2]

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

inlineinherited

Returns: The Point associated with local Node i.

Definition at line 1892 of file elem.h.

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

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

inlineinherited

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

Definition at line 1904 of file elem.h.

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

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

◆ print_dof_info()

void libMesh::DofObject::print_dof_info ( ) const

inherited

Print out info for debugging.

Definition at line 548 of file dof_object.C.

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

 {
   libMesh::out << this->id() << " [ ";
 
   for (unsigned int s=0; s<this->n_systems(); s++)
     {
       libMesh::out << "s:" << s << " ";
       for (unsigned int var=0; var<this->n_vars(s); var++)
         {
           libMesh::out << "v:" << var << " ";
           for (unsigned int comp=0; comp<this->n_comp(s,var); comp++)
             {
               libMesh::out << "c:" << comp << " dof:" << this->dof_number(s,var,comp) << " ";
             }
         }
     }
 
   libMesh::out << "]\n";
 }

◆ print_info() [1/3]

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

staticinherited

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

Definition at line 87 of file reference_counter.C.

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

 {
   if (_enable_print_counter)
     out_stream << ReferenceCounter::get_info();
 }

◆ print_info() [2/3]

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

staticinherited

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

Definition at line 87 of file reference_counter.C.

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

 {
   if (_enable_print_counter)
     out_stream << ReferenceCounter::get_info();
 }

◆ print_info() [3/3]

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

inherited

Prints relevant information about the element.

Definition at line 2440 of file elem.C.

References libMesh::Elem::get_info().

Referenced by libMesh::FEMap::compute_single_point_map(), libMesh::FE< Dim, LAGRANGE_VEC >::inverse_map(), and libMesh::operator<<().

 {
   os << this->get_info()
      << std::endl;
 }

◆ processor_id() [1/3]

processor_id_type libMesh::DofObject::processor_id ( ) const

inlineinherited

Returns: The processor that this DofObject belongs to.

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

Definition at line 717 of file dof_object.h.

References libMesh::DofObject::_processor_id.

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::DistributedMesh::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::MeshRefinement::add_node(), libMesh::ReplicatedMesh::add_point(), libMesh::DistributedMesh::add_point(), libMesh::UnstructuredMesh::all_first_order(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::Patch::build_around_element(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::UnstructuredMesh::create_submesh(), libMesh::DistributedMesh::delete_elem(), libMesh::DistributedMesh::delete_node(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::Elem::Elem(), libMesh::MeshFunction::find_element(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::MeshTools::Modification::flatten(), libMesh::Node::get_info(), libMesh::Elem::get_info(), libMesh::DofMap::get_info(), libMesh::DofMap::get_local_constraints(), libMesh::DistributedMesh::insert_elem(), libMesh::DofObject::invalidate_processor_id(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_amr_elem_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DofMap::local_variable_indices(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshCommunication::make_new_node_proc_ids_parallel_consistent(), libMesh::DistributedMesh::own_node(), libMesh::Parallel::Packing< T >::pack(), libMesh::XdrIO::pack_element(), libMesh::LinearPartitioner::partition_range(), libMesh::SFCPartitioner::partition_range(), libMesh::CentroidPartitioner::partition_range(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::DofObject::processor_id(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::MeshBase::recalculate_n_partitions(), libMesh::Elem::refine(), libMesh::DofMap::scatter_constraints(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::Parallel::sync_dofobject_data_by_id(), libMesh::Parallel::sync_element_data_by_parent_id(), libMesh::Parallel::sync_node_data_by_element_id_once(), libMesh::Parallel::Packing< T >::unpack(), libMesh::GmshIO::write_mesh(), and libMesh::Nemesis_IO_Helper::write_sidesets().

 {
   return _processor_id;
 }

◆ processor_id() [2/3]

processor_id_type & libMesh::DofObject::processor_id ( )

inlineinherited

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

Definition at line 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 )

inlineinherited

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

std::pair< Real, Real > libMesh::InfHex::qual_bounds ( const ElemQuality q ) const

overridevirtual

Returns: The suggested quality bounds for the hex based on quality measure q. These are the values suggested by the CUBIT User's Manual.

Reimplemented from libMesh::Elem.

Definition at line 331 of file cell_inf_hex.C.

 {
   libmesh_not_implemented();
 
   std::pair<Real, Real> bounds;
 
   /*
     switch (q)
     {
 
     case ASPECT_RATIO:
     bounds.first  = 1.;
     bounds.second = 4.;
     break;
 
     case SKEW:
     bounds.first  = 0.;
     bounds.second = 0.5;
     break;
 
     case SHEAR:
     case SHAPE:
     bounds.first  = 0.3;
     bounds.second = 1.;
     break;
 
     case CONDITION:
     bounds.first  = 1.;
     bounds.second = 8.;
     break;
 
     case JACOBIAN:
     bounds.first  = 0.5;
     bounds.second = 1.;
     break;
 
     case DISTORTION:
     bounds.first  = 0.6;
     bounds.second = 1.;
     break;
 
     case TAPER:
     bounds.first  = 0.;
     bounds.second = 0.4;
     break;
 
     case STRETCH:
     bounds.first  = 0.25;
     bounds.second = 1.;
     break;
 
     case DIAGONAL:
     bounds.first  = 0.65;
     bounds.second = 1.;
     break;
 
     case SIZE:
     bounds.first  = 0.5;
     bounds.second = 1.;
     break;
 
     default:
     libMesh::out << "Warning: Invalid quality measure chosen." << std::endl;
     bounds.first  = -1;
     bounds.second = -1;
     }
   */
 
   return bounds;
 }

◆ quality()

Real libMesh::InfHex::quality ( const ElemQuality q ) const

overridevirtual

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

Compute the min/max diagonal ratio. Source: CUBIT User's Manual.

For infinite elements, we just only compute the diagonal in the face... Don't know whether this makes sense, but should be a feasible way.

Minimum ratio of lengths derived from opposite edges. Source: CUBIT User's Manual.

For IFEMs, do this only for the base face... Does this make sense?

Compute the side lengths.

Minimum edge length divided by max diagonal length. Source: CUBIT User's Manual.

And again, we mess around a bit, for the IFEMs... Do this only for the base.

Should this be a sqrt2, when we do this for the base only?

Compute the maximum diagonal in the base.

Compute the minimum edge length in the base.

I don't know what to do for this metric. Maybe the base class knows...

Reimplemented from libMesh::Elem.

Definition at line 220 of file cell_inf_hex.C.

References libMesh::DIAGONAL, libMesh::Elem::length(), std::max(), std::min(), libMesh::Elem::quality(), libMesh::Real, libMesh::STRETCH, and libMesh::TAPER.

 {
   switch (q)
     {
 
     case DIAGONAL:
       {
         // Diagonal between node 0 and node 2
         const Real d02 = this->length(0,2);
 
         // Diagonal between node 1 and node 3
         const Real d13 = this->length(1,3);
 
         // Find the biggest and smallest diagonals
         const Real min = std::min(d02, d13);
         const Real max = std::max(d02, d13);
 
         libmesh_assert_not_equal_to (max, 0.0);
 
         return min / max;
 
         break;
       }
 
     case TAPER:
       {
 
         const Real d01 = this->length(0,1);
         const Real d12 = this->length(1,2);
         const Real d23 = this->length(2,3);
         const Real d03 = this->length(0,3);
 
         std::vector<Real> edge_ratios(2);
 
         // Bottom
         edge_ratios[8] = std::min(d01, d23) / std::max(d01, d23);
         edge_ratios[9] = std::min(d03, d12) / std::max(d03, d12);
 
         return *(std::min_element(edge_ratios.begin(), edge_ratios.end())) ;
 
         break;
       }
 
 
     case STRETCH:
       {
         const Real sqrt3 = 1.73205080756888;
 
         const Real d02 = this->length(0,2);
         const Real d13 = this->length(1,3);
         const Real max_diag = std::max(d02, d13);
 
         libmesh_assert_not_equal_to ( max_diag, 0.0 );
 
         std::vector<Real> edges(4);
         edges[0]  = this->length(0,1);
         edges[1]  = this->length(1,2);
         edges[2]  = this->length(2,3);
         edges[3]  = this->length(0,3);
 
         const Real min_edge = *(std::min_element(edges.begin(), edges.end()));
         return sqrt3 * min_edge / max_diag ;
       }
 
 
     default:
       return Elem::quality(q);
     }
 }

◆ raw_child_ptr()

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

inlineinherited

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

Definition at line 2569 of file elem.h.

References libMesh::Elem::_children.

Referenced by libMesh::CheckpointIO::read_remote_elem().

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

◆ reference_elem()

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

inherited

Returns: A pointer to the "reference element" associated with this element. The reference element is the image of this element in reference parametric space. Importantly, it is not an actual element in the mesh, but rather a Singleton-type object, so for example all Quad4 elements share the same reference_elem().

Definition at line 337 of file elem.C.

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

Referenced by libMesh::QComposite< QSubCell >::init().

 {
   return &(ReferenceElem::get(this->type()));
 }

◆ refine()

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

virtualinherited

Refine the element.

The following functions only apply when AMR is enabled and thus are not present otherwise.

Definition at line 41 of file elem_refinement.C.

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

 {
   libmesh_assert_equal_to (this->refinement_flag(), Elem::REFINE);
   libmesh_assert (this->active());
 
   const unsigned int nc = this->n_children();
 
   // Create my children if necessary
   if (!_children)
     {
       _children = new Elem *[nc];
 
       unsigned int parent_p_level = this->p_level();
       for (unsigned int c = 0; c != nc; c++)
         {
           _children[c] = Elem::build(this->type(), this).release();
           Elem * current_child = this->child_ptr(c);
 
           current_child->set_refinement_flag(Elem::JUST_REFINED);
           current_child->set_p_level(parent_p_level);
           current_child->set_p_refinement_flag(this->p_refinement_flag());
 
           for (unsigned int cnode=0; cnode != current_child->n_nodes(); ++cnode)
             {
               Node * node =
                 mesh_refinement.add_node(*this, c, cnode,
                                          current_child->processor_id());
               node->set_n_systems (this->n_systems());
               current_child->set_node(cnode) = node;
             }
 
           mesh_refinement.add_elem (current_child);
           current_child->set_n_systems(this->n_systems());
         }
     }
   else
     {
       unsigned int parent_p_level = this->p_level();
       for (unsigned int c = 0; c != nc; c++)
         {
           Elem * current_child = this->child_ptr(c);
           libmesh_assert(current_child->subactive());
           current_child->set_refinement_flag(Elem::JUST_REFINED);
           current_child->set_p_level(parent_p_level);
           current_child->set_p_refinement_flag(this->p_refinement_flag());
         }
     }
 
   // Un-set my refinement flag now
   this->set_refinement_flag(Elem::INACTIVE);
 
   // Leave the p refinement flag set - we will need that later to get
   // projection operations correct
   // this->set_p_refinement_flag(Elem::INACTIVE);
 
   for (unsigned int c = 0; c != nc; c++)
     {
       libmesh_assert_equal_to (this->child_ptr(c)->parent(), this);
       libmesh_assert(this->child_ptr(c)->active());
     }
   libmesh_assert (this->ancestor());
 }

◆ refinement_flag()

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

inlineinherited

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

Definition at line 2638 of file elem.h.

References libMesh::Elem::_rflag.

Referenced by libMesh::Elem::active(), libMesh::OldSolutionBase< Output, point_output >::check_old_context(), libMesh::Elem::coarsen(), libMesh::Elem::contract(), libMesh::MeshRefinement::enforce_mismatch_limit_prior_to_refinement(), libMesh::Elem::get_info(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_flags(), libMesh::MeshRefinement::limit_overrefined_boundary(), libMesh::MeshRefinement::limit_underrefined_boundary(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshRefinement::make_flags_parallel_consistent(), libMesh::Elem::make_links_to_me_local(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::DofMap::old_dof_indices(), libMesh::Parallel::Packing< T >::pack(), libMesh::Elem::refine(), libMesh::MeshRefinement::uniformly_coarsen(), and libMesh::Parallel::Packing< T >::unpack().

 {
   return static_cast<RefinementState>(_rflag);
 }

◆ remove_links_to_me()

void libMesh::Elem::remove_links_to_me ( )

inherited

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

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

Definition at line 1260 of file elem.C.

References libMesh::Elem::has_children(), libMesh::Elem::level(), libMesh::Elem::n_neighbors(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::neighbor_ptr_range(), libMesh::Elem::parent(), libMesh::remote_elem, libMesh::Elem::set_neighbor(), libMesh::Elem::subactive(), and libMesh::Elem::which_neighbor_am_i().

 {
   libmesh_assert_not_equal_to (this, remote_elem);
 
   // We need to have handled any children first
 #ifdef LIBMESH_ENABLE_AMR
   libmesh_assert (!this->has_children());
 #endif
 
   // Nullify any neighbor links
   for (auto neigh : this->neighbor_ptr_range())
     {
       if (neigh && neigh != remote_elem)
         {
           // My neighbor should never be more refined than me; my real
           // neighbor would have been its parent in that case.
           libmesh_assert_greater_equal (this->level(), neigh->level());
 
           if (this->level() == neigh->level() &&
               neigh->has_neighbor(this))
             {
 #ifdef LIBMESH_ENABLE_AMR
               // My neighbor may have descendants which also consider me a
               // neighbor
               std::vector<const Elem *> family;
               neigh->total_family_tree_by_neighbor (family, this);
 
               // FIXME - There's a lot of ugly const_casts here; we
               // may want to make remote_elem non-const and create
               // non-const versions of the family_tree methods
               for (auto & const_elem : family)
                 {
                   Elem * n = const_cast<Elem *>(const_elem);
                   libmesh_assert (n);
                   if (n == remote_elem)
                     continue;
                   unsigned int my_s = n->which_neighbor_am_i(this);
                   libmesh_assert_less (my_s, n->n_neighbors());
                   libmesh_assert_equal_to (n->neighbor_ptr(my_s), this);
                   n->set_neighbor(my_s, nullptr);
                 }
 #else
               unsigned int my_s = neigh->which_neighbor_am_i(this);
               libmesh_assert_less (my_s, neigh->n_neighbors());
               libmesh_assert_equal_to (neigh->neighbor(my_s), this);
               neigh->set_neighbor(my_s, nullptr);
 #endif
             }
 #ifdef LIBMESH_ENABLE_AMR
           // Even if my neighbor doesn't link back to me, it might
           // have subactive descendants which do
           else if (neigh->has_children())
             {
               // If my neighbor at the same level doesn't have me as a
               // neighbor, I must be subactive
               libmesh_assert(this->level() > neigh->level() ||
                              this->subactive());
 
               // My neighbor must have some ancestor of mine as a
               // neighbor
               Elem * my_ancestor = this->parent();
               libmesh_assert(my_ancestor);
               while (!neigh->has_neighbor(my_ancestor))
                 {
                   my_ancestor = my_ancestor->parent();
                   libmesh_assert(my_ancestor);
                 }
 
               // My neighbor may have descendants which consider me a
               // neighbor
               std::vector<const Elem *> family;
               neigh->total_family_tree_by_subneighbor (family, my_ancestor, this);
 
               // FIXME - There's a lot of ugly const_casts here; we
               // may want to make remote_elem non-const and create
               // non-const versions of the family_tree methods
               for (auto & const_elem : family)
                 {
                   Elem * n = const_cast<Elem *>(const_elem);
                   libmesh_assert (n);
                   if (n == remote_elem)
                     continue;
                   unsigned int my_s = n->which_neighbor_am_i(this);
                   libmesh_assert_less (my_s, n->n_neighbors());
                   libmesh_assert_equal_to (n->neighbor_ptr(my_s), this);
                   n->set_neighbor(my_s, nullptr);
                 }
             }
 #endif
         }
     }
 
 #ifdef LIBMESH_ENABLE_AMR
   // We can't currently delete a child with a parent!
   libmesh_assert (!this->parent());
 #endif
 }

◆ replace_child()

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

inherited

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

Definition at line 1507 of file elem.C.

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

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

 {
   libmesh_assert(this->has_children());
 
   libmesh_assert(this->child_ptr(c));
 
   this->set_child(c, elem);
 }

◆ second_order_adjacent_vertex()

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

virtualinherited

Returns: The element-local number of the $v^{th}$ vertex that defines the $n^{th}$ second-order node, or 0 for linear elements.

Note: The value is always less than this->n_vertices(), while n has to be greater than or equal to this->n_vertices().

Reimplemented in libMesh::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.

Definition at line 2566 of file elem.C.

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

 {
   // for linear elements, always return 0
   return 0;
 }

◆ second_order_child_vertex()

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

virtualinherited

Returns: A pair (c,v), where c == child index, and v == element-local index of the 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.

Definition at line 2576 of file elem.C.

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

◆ second_order_equivalent_type()

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

staticinherited

Returns: The 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.

Definition at line 2643 of file elem.C.

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

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

 {
   /* for second-order elements, always return \p INVALID_ELEM
    * since second-order elements should not be converted
    * into something else.  Only linear elements should
    * return something sensible here
    */
   switch (et)
     {
     case EDGE2:
     case EDGE3:
       {
         // full_ordered not relevant
         return EDGE3;
       }
 
     case EDGE4:
       {
         // full_ordered not relevant
         return EDGE4;
       }
 
     case TRI3:
     case TRI6:
       {
         // full_ordered not relevant
         return TRI6;
       }
 
     case QUAD4:
     case QUAD8:
       {
         if (full_ordered)
           return QUAD9;
         else
           return QUAD8;
       }
 
     case QUADSHELL4:
     case QUADSHELL8:
       {
         if (full_ordered)
           libmesh_error();
         else
           return QUADSHELL8;
       }
 
     case QUAD9:
       {
         // full_ordered not relevant
         return QUAD9;
       }
 
     case TET4:
     case TET10:
       {
         // full_ordered not relevant
         return TET10;
       }
 
     case HEX8:
     case HEX20:
       {
         // see below how this correlates with INFHEX8
         if (full_ordered)
           return HEX27;
         else
           return HEX20;
       }
 
     case HEX27:
       {
         // full_ordered not relevant
         return HEX27;
       }
 
     case PRISM6:
     case PRISM15:
       {
         if (full_ordered)
           return PRISM18;
         else
           return PRISM15;
       }
 
     case PRISM18:
       {
         // full_ordered not relevant
         return PRISM18;
       }
 
     case PYRAMID5:
     case PYRAMID13:
       {
         if (full_ordered)
           return PYRAMID14;
         else
           return PYRAMID13;
       }
 
     case PYRAMID14:
       {
         // full_ordered not relevant
         return PYRAMID14;
       }
 
 
 
 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
 
       // infinite elements
     case INFEDGE2:
       {
         return INVALID_ELEM;
       }
 
     case INFQUAD4:
     case INFQUAD6:
       {
         // full_ordered not relevant
         return INFQUAD6;
       }
 
     case INFHEX8:
     case INFHEX16:
       {
         /*
          * Note that this matches with \p Hex8:
          * For full-ordered, \p InfHex18 and \p Hex27
          * belong together, and for not full-ordered,
          * \p InfHex16 and \p Hex20 belong together.
          */
         if (full_ordered)
           return INFHEX18;
         else
           return INFHEX16;
       }
 
     case INFHEX18:
       {
         // full_ordered not relevant
         return INFHEX18;
       }
 
     case INFPRISM6:
     case INFPRISM12:
       {
         // full_ordered not relevant
         return INFPRISM12;
       }
 
 #endif
 
 
     default:
       {
         // what did we miss?
         libmesh_error();
       }
     }
 }

◆ set_buffer()

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

inlineinherited

Definition at line 535 of file dof_object.h.

References libMesh::DofObject::_idx_buf.

536 { _idx_buf = buf; }

libMesh::DofObject::_idx_buf

index_buffer_t _idx_buf

Definition: dof_object.h:508

◆ set_dof_number()

void libMesh::DofObject::set_dof_number	(	const unsigned int	s,
		const unsigned int	var,
		const unsigned int	comp,
		const dof_id_type	dn
	)

inherited

Sets the global degree of freedom number for variable var, component comp for system s associated with this DofObject

Definition at line 409 of file dof_object.C.

References libMesh::DofObject::_idx_buf, libMesh::DofObject::dof_number(), libMesh::DofObject::invalid_id, libMesh::DofObject::n_comp(), libMesh::DofObject::n_comp_group(), libMesh::DofObject::n_systems(), libMesh::DofObject::n_vars(), libMesh::DofObject::start_idx(), libMesh::DofObject::system_var_to_vg_var(), and libMesh::DofObject::var_to_vg().

 {
   libmesh_assert_less (s,    this->n_systems());
   libmesh_assert_less (var,  this->n_vars(s));
   libmesh_assert_less (comp, this->n_comp(s,var));
 
   const unsigned int
     vg            = this->var_to_vg(s,var),
 #ifndef NDEBUG
     ncg           = this->n_comp_group(s,vg),
 #endif
     vig           = this->system_var_to_vg_var(s,vg,var),
     start_idx_sys = this->start_idx(s);
 
   libmesh_assert_less ((start_idx_sys + 2*vg + 1), _idx_buf.size());
 
   dof_id_type & base_idx = _idx_buf[start_idx_sys + 2*vg + 1];
 
   // We intend to change all dof numbers together or not at all
   if (comp || vig)
     libmesh_assert ((dn == invalid_id && base_idx == invalid_id) ||
                     (dn == base_idx + vig*ncg + comp));
 
   // only explicitly store the base index for vig==0, comp==0
   else
     base_idx = dn;
 
   libmesh_assert_equal_to (this->dof_number(s, var, comp), dn);
 }

◆ set_id() [1/2]

dof_id_type & libMesh::DofObject::set_id ( )

inlineinherited

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

Definition at line 664 of file dof_object.h.

References libMesh::DofObject::_id.

Referenced by libMesh::GMVIO::_read_one_cell(), libMesh::ReplicatedMesh::add_elem(), libMesh::DistributedMesh::add_elem(), libMesh::ReplicatedMesh::add_node(), libMesh::DistributedMesh::add_node(), libMesh::UnstructuredMesh::all_first_order(), libMesh::MeshTools::Subdivision::all_subdivision(), libMesh::MeshTools::Generation::build_cube(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::UnstructuredMesh::create_submesh(), libMesh::UNVIO::elements_in(), libMesh::MeshTools::Modification::flatten(), libMesh::DofObject::invalidate_id(), libMesh::Node::Node(), libMesh::DistributedMesh::own_node(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::VTKIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::UCDIO::read_implementation(), libMesh::GmshIO::read_mesh(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::OFFIO::read_stream(), libMesh::MatlabIO::read_stream(), libMesh::RemoteElem::RemoteElem(), libMesh::ReplicatedMesh::renumber_elem(), libMesh::DistributedMesh::renumber_elem(), libMesh::ReplicatedMesh::renumber_node(), libMesh::DistributedMesh::renumber_node(), libMesh::ReplicatedMesh::renumber_nodes_and_elements(), libMesh::DofObject::set_id(), and libMesh::Parallel::Packing< T >::unpack().

 {
   return _id;
 }

◆ set_id() [2/2]

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

inlineinherited

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 )

inherited

Sets the pointer to the element's interior_parent. Dangerous! Only use this if you know what you are doing!

Definition at line 856 of file elem.C.

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

Referenced by libMesh::BoundaryInfo::add_elements(), libMesh::Edge::Edge(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::Hex::Hex(), InfHex(), libMesh::InfQuad::InfQuad(), libMesh::NodeElem::NodeElem(), libMesh::Prism::Prism(), libMesh::Pyramid::Pyramid(), libMesh::Quad::Quad(), libMesh::Tet::Tet(), libMesh::Tri::Tri(), and libMesh::Parallel::Packing< T >::unpack().

 {
   // interior parents make no sense for full-dimensional elements.
   libmesh_assert_less (this->dim(), LIBMESH_DIM);
 
   // If we have an interior_parent, we USED TO assume it was a
   // one-higher-dimensional interior element, but we now allow e.g.
   // edge elements to have a 3D interior_parent with no
   // intermediate 2D element.
   // libmesh_assert (!p ||
   //                 p->dim() == (this->dim()+1));
   libmesh_assert (!p ||
                   (p == remote_elem) ||
                   (p->dim() > this->dim()));
 
   _elemlinks[1+this->n_sides()] = p;
 }

◆ set_n_comp()

void libMesh::DofObject::set_n_comp	(	const unsigned int	s,
		const unsigned int	var,
		const unsigned int	ncomp
	)

inherited

Sets the number of components for Variable var of system s associated with this DofObject

Definition at line 340 of file dof_object.C.

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

 {
   libmesh_assert_less (s,   this->n_systems());
   libmesh_assert_less (var, this->n_vars(s));
 
   this->set_n_comp_group(s, this->var_to_vg(s,var), ncomp);
 }

◆ set_n_comp_group()

void libMesh::DofObject::set_n_comp_group	(	const unsigned int	s,
		const unsigned int	vg,
		const unsigned int	ncomp
	)

inherited

Sets the number of components for VariableGroup vg of system s associated with this DofObject

Definition at line 352 of file dof_object.C.

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

Referenced by libMesh::DofMap::reinit(), libMesh::DofObject::set_n_comp(), libMesh::DofObject::set_n_vars_per_group(), and libMesh::DofMap::set_nonlocal_dof_objects().

 {
   libmesh_assert_less (s,  this->n_systems());
   libmesh_assert_less (vg, this->n_var_groups(s));
 
   // Check for trivial return
   if (ncomp == this->n_comp_group(s,vg)) return;
 
 #ifndef NDEBUG
   if (ncomp >= ncv_magic)
     {
       const index_t ncvm = ncv_magic;
       libmesh_error_msg("ERROR: ncomp must be less than DofObject::ncv_magic!\n" \
                         << "ncomp = "                                   \
                         << ncomp                                \
                         << ", ncv_magic = "                     \
                         << ncvm                                 \
                         << "\nrecompile and try again!");
     }
 #endif
 
   const unsigned int
     start_idx_sys = this->start_idx(s),
     n_vars_group  = this->n_vars(s,vg),
     base_offset   = start_idx_sys + 2*vg;
 
   libmesh_assert_less ((base_offset + 1), _idx_buf.size());
 
   // if (ncomp)
   //   libMesh::out << "s,vg,ncomp="
   //       << s  << ","
   //       << vg << ","
   //       << ncomp << '\n';
 
   // set the number of components, maintaining the number
   // of variables in the group
   _idx_buf[base_offset] = ncv_magic*n_vars_group + ncomp;
 
   // We use (invalid_id - 1) to signify no
   // components for this object
   _idx_buf[base_offset + 1] = (ncomp == 0) ? invalid_id - 1 : invalid_id;
 
   // this->debug_buffer();
   // libMesh::out << "s,vg = " << s << "," << vg << '\n'
   //     << "base_offset=" << base_offset << '\n'
   //     << "this->n_comp(s,vg)=" << this->n_comp(s,vg) << '\n'
   //     << "this->n_comp_group(s,vg)=" << this->n_comp_group(s,vg) << '\n'
   //     << "this->n_vars(s,vg)=" << this->n_vars(s,vg) << '\n'
   //     << "this->n_var_groups(s)=" << this->n_var_groups(s) << '\n';
 
   libmesh_assert_equal_to (ncomp, this->n_comp_group(s,vg));
 }

◆ set_n_systems()

void libMesh::DofObject::set_n_systems ( const unsigned int s )

inherited

Sets the number of systems for this DofObject

Definition at line 165 of file dof_object.C.

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

Referenced by libMesh::DofObject::add_system(), and libMesh::Elem::refine().

 {
   // Check for trivial return
   if (ns == this->n_systems())
     return;
 
   // Clear any existing data.  This is safe to call
   // even if we don't have any data.
   this->clear_dofs();
 
   // Set the new number of systems
   _idx_buf.resize(ns, ns);
   _idx_buf[0] = ns;
 
 
 #ifdef DEBUG
 
   // check that all systems now exist and that they have 0 size
   libmesh_assert_equal_to (ns, this->n_systems());
   for (unsigned int s=0; s<this->n_systems(); s++)
     {
       libmesh_assert_equal_to (this->n_vars(s),       0);
       libmesh_assert_equal_to (this->n_var_groups(s), 0);
     }
 
 #endif
 }

◆ set_n_vars_per_group()

void libMesh::DofObject::set_n_vars_per_group	(	const unsigned int	s,
		const std::vector< unsigned int > &	nvpg
	)

inherited

Sets number of variables in each group associated with system s for this DofObject. Implicit in this is also setting the number of VariableGroup variable groups for the system. Has the effect of setting the number of components to 0 even when called even with (nvg == this->n_var_groups(s)).

Definition at line 227 of file dof_object.C.

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

 {
 
   libmesh_assert_less (s, this->n_systems());
 
   // number of variable groups for this system - inferred
   const unsigned int nvg = cast_int<unsigned int>(nvpg.size());
 
   // BSK - note that for compatibility with the previous implementation
   // calling this method when (nvars == this->n_vars()) requires that
   // we invalidate the DOF indices and set the number of components to 0.
   // Note this was a bit of a surprise to me - there was no quick return in
   // the old method, which caused removal and readdition of the DOF indices
   // even in the case of (nvars == this->n_vars()), resulting in n_comp(s,v)
   // implicitly becoming 0 regardless of any previous value.
   // quick return?
   if (nvg == this->n_var_groups(s))
     {
       for (unsigned int vg=0; vg<nvg; vg++)
         {
           this->set_n_comp_group(s,vg,0);
           libmesh_assert_equal_to (this->n_vars(s,vg), nvpg[vg]);
         }
       return;
     }
 
   // since there is ample opportunity to screw up other systems, let us
   // cache their current sizes and later assert that they are unchanged.
 #ifdef DEBUG
   DofObject::index_buffer_t old_system_sizes;
   old_system_sizes.reserve(this->n_systems());
 
   for (unsigned int s_ctr=0; s_ctr<this->n_systems(); s_ctr++)
     old_system_sizes.push_back(this->n_var_groups(s_ctr));
 #endif
 
   // remove current indices if we have some
   if (this->n_var_groups(s) != 0)
     {
       const unsigned int old_nvg_s = this->n_var_groups(s);
 
       DofObject::index_buffer_t::iterator
         it  = _idx_buf.begin(),
         end = _idx_buf.begin();
 
       std::advance(it,  this->start_idx(s));
       std::advance(end, this->end_idx(s));
       _idx_buf.erase(it,end);
 
       for (unsigned int ctr=(s+1); ctr<this->n_systems(); ctr++)
         _idx_buf[ctr] -= 2*old_nvg_s;
     }
 
   // better not have any now!
   libmesh_assert_equal_to (this->n_var_groups(s), 0);
 
   // Make sure we didn't screw up any of our sizes!
 #ifdef DEBUG
   for (unsigned int s_ctr=0; s_ctr<this->n_systems(); s_ctr++)
     if (s_ctr != s)
       libmesh_assert_equal_to (this->n_var_groups(s_ctr), old_system_sizes[s_ctr]);
 #endif
 
   // OK, if the user requested 0 that is what we have
   if (nvg == 0)
     return;
 
   {
     // array to hold new indices
     DofObject::index_buffer_t var_idxs(2*nvg);
     for (unsigned int vg=0; vg<nvg; vg++)
       {
         var_idxs[2*vg    ] = ncv_magic*nvpg[vg] + 0;
         var_idxs[2*vg + 1] = invalid_id - 1;
       }
 
     DofObject::index_buffer_t::iterator it = _idx_buf.begin();
     std::advance(it, this->end_idx(s));
     _idx_buf.insert(it, var_idxs.begin(), var_idxs.end());
 
     for (unsigned int ctr=(s+1); ctr<this->n_systems(); ctr++)
       _idx_buf[ctr] += 2*nvg;
 
     // resize _idx_buf to fit so no memory is wasted.
     DofObject::index_buffer_t(_idx_buf).swap(_idx_buf);
   }
 
   libmesh_assert_equal_to (nvg, this->n_var_groups(s));
 
 #ifdef DEBUG
 
   libmesh_assert_equal_to (this->n_var_groups(s), nvpg.size());
 
   for (unsigned int vg=0; vg<this->n_var_groups(s); vg++)
     {
       libmesh_assert_equal_to (this->n_vars(s,vg), nvpg[vg]);
       libmesh_assert_equal_to (this->n_comp_group(s,vg), 0);
     }
 
   for (unsigned int v=0; v<this->n_vars(s); v++)
     libmesh_assert_equal_to (this->n_comp(s,v), 0);
 
   // again, all other system sizes should be unchanged!
   for (unsigned int s_ctr=0; s_ctr<this->n_systems(); s_ctr++)
     if (s_ctr != s)
       libmesh_assert_equal_to (this->n_var_groups(s_ctr), old_system_sizes[s_ctr]);
 
 #endif
 }

◆ set_neighbor()

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

inlineinherited

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

Definition at line 2083 of file elem.h.

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

Referenced by libMesh::MeshTools::Subdivision::add_boundary_ghosts(), libMesh::BoundaryInfo::add_elements(), libMesh::UnstructuredMesh::all_first_order(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::MeshTools::Modification::flatten(), libMesh::Elem::make_links_to_me_local(), libMesh::Elem::make_links_to_me_remote(), libMesh::Elem::nullify_neighbors(), libMesh::CheckpointIO::read_remote_elem(), libMesh::Elem::remove_links_to_me(), libMesh::ReplicatedMesh::stitching_helper(), and libMesh::Parallel::Packing< T >::unpack().

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

◆ set_node()

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

inlinevirtualinherited

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

Reimplemented in libMesh::RemoteElem.

Definition at line 2024 of file elem.h.

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

Referenced by libMesh::GMVIO::_read_one_cell(), libMesh::MeshTools::Subdivision::add_boundary_ghosts(), libMesh::UnstructuredMesh::all_first_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::TetGenMeshInterface::assign_nodes_to_elem(), libMesh::MeshTools::Generation::build_cube(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::TriangleWrapper::copy_tri_to_mesh(), libMesh::UnstructuredMesh::create_submesh(), libMesh::UNVIO::elements_in(), libMesh::MeshTools::Modification::flatten(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::VTKIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::AbaqusIO::read_elements(), libMesh::UCDIO::read_implementation(), libMesh::GmshIO::read_mesh(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::OFFIO::read_stream(), libMesh::MatlabIO::read_stream(), libMesh::Elem::refine(), libMesh::RemoteElem::set_node(), libMesh::ReplicatedMesh::stitching_helper(), and libMesh::Parallel::Packing< T >::unpack().

 {
   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

Definition at line 150 of file dof_object.C.

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

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

 {
   this->clear_old_dof_object();
 
   libmesh_assert (!this->old_dof_object);
 
   // Make a new DofObject, assign a copy of \p this.
   // Make sure the copy ctor for DofObject works!!
   this->old_dof_object = new DofObject(*this);
 }

◆ set_p_level()

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

inlineinherited

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

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

Definition at line 2692 of file elem.h.

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

Referenced by libMesh::UnstructuredMesh::all_first_order(), libMesh::Elem::coarsen(), libMesh::Elem::Elem(), libMesh::Elem::refine(), libMesh::Elem::set_p_level(), and libMesh::Parallel::Packing< T >::unpack().

 {
   // 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 )

inlineinherited

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

Definition at line 2662 of file elem.h.

References libMesh::Elem::_pflag, libMesh::Elem::JUST_REFINED, and libMesh::Elem::p_level().

Referenced by libMesh::UnstructuredMesh::all_first_order(), libMesh::MeshRefinement::enforce_mismatch_limit_prior_to_refinement(), libMesh::MeshRefinement::limit_overrefined_boundary(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshRefinement::make_flags_parallel_consistent(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::CheckpointIO::read_connectivity(), libMesh::Elem::refine(), libMesh::Elem::set_p_level(), and libMesh::Parallel::Packing< T >::unpack().

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

inlineinherited

Sets the pointer to the element's parent. Dangerous! Only use this if you know what you are doing!

Definition at line 2495 of file elem.h.

References libMesh::Elem::_elemlinks.

Referenced by libMesh::BoundaryInfo::add_elements(), and libMesh::UnstructuredMesh::all_first_order().

 {
   _elemlinks[0] = p;
 }

◆ set_refinement_flag()

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

inlineinherited

Sets the value of the refinement flag for the element.

Definition at line 2646 of file elem.h.

References libMesh::Elem::_rflag.

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

◆ set_unique_id()

unique_id_type & libMesh::DofObject::set_unique_id ( )

inlineinherited

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.

Referenced by libMesh::ReplicatedMesh::add_elem(), libMesh::DistributedMesh::add_elem(), libMesh::ReplicatedMesh::add_node(), libMesh::DistributedMesh::add_node(), libMesh::ReplicatedMesh::add_point(), libMesh::UnstructuredMesh::all_first_order(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::UnstructuredMesh::create_submesh(), libMesh::MeshTools::Modification::flatten(), libMesh::ReplicatedMesh::insert_elem(), libMesh::DistributedMesh::insert_elem(), libMesh::ReplicatedMesh::insert_node(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::CheckpointIO::read_nodes(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), and libMesh::Parallel::Packing< T >::unpack().

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

inlineinherited

VariableGroup DoF indices are indexed as id = base + var_in_vg*ncomp + comp This method allows for direct access to the base.

Definition at line 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::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DofObject::invalidate_dofs(), libMesh::DofMap::reinit(), and libMesh::DofMap::set_nonlocal_dof_objects().

 {
   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

inlineinherited

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

References libMesh::Elem::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

inlineinherited

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

Definition at line 2166 of file elem.h.

References libMesh::Elem::n_sides().

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::MeshTools::Subdivision::add_boundary_ghosts(), libMesh::BoundaryInfo::add_elements(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::FEGenericBase< FEOutputType< T >::type >::coarsened_dof_values(), libMesh::FEAbstract::compute_node_constraints(), libMesh::FEAbstract::compute_periodic_node_constraints(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_proj_constraints(), libMesh::BoundaryInfo::copy_boundary_ids(), libMesh::BoundaryInfo::edge_boundary_ids(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::MeshTools::Modification::flatten(), libMesh::BoundaryInfo::get_side_and_node_maps(), libMesh::Elem::has_topological_neighbor(), libMesh::Elem::libmesh_assert_valid_neighbors(), libMesh::Elem::nullify_neighbors(), libMesh::Parallel::Packing< T >::pack(), libMesh::PostscriptIO::plot_quadratic_elem(), libMesh::MeshTools::Modification::smooth(), libMesh::ReplicatedMesh::stitching_helper(), and libMesh::Parallel::Packing< T >::unpack().

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

◆ side_ptr() [1/4]

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

finaloverridevirtual

Returns: A primitive (4-noded) quad or infquad for face i.

Implements libMesh::Elem.

Definition at line 100 of file cell_inf_hex.C.

References n_sides(), libMesh::Elem::node_ptr(), and libMesh::InfHex8::side_nodes_map.

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

 {
   libmesh_assert_less (i, this->n_sides());
 
   // Return value
   std::unique_ptr<Elem> face;
 
   // Think of a unit cube: (-1,1) x (-1,1) x (-1,1),
   // with (in general) the normals pointing outwards
   switch (i)
     {
       // the face at z = -1
       // the base, where the infinite element couples to conventional
       // elements
     case 0:
       {
         // Oops, here we are, claiming the normal of the face
         // elements point outwards -- and this is the exception:
         // For the side built from the base face,
         // the normal is pointing _into_ the element!
         // Why is that? - In agreement with build_side_ptr(),
         // which in turn _has_ to build the face in this
         // way as to enable the cool way \p InfFE re-uses \p FE.
         face = libmesh_make_unique<Quad4>();
         break;
       }
 
       // These faces connect to other infinite elements.
     case 1: // the face at y = -1
     case 2: // the face at x = 1
     case 3: // the face at y = 1
     case 4: // the face at x = -1
       {
         face = libmesh_make_unique<InfQuad4>();
         break;
       }
 
     default:
       libmesh_error_msg("Invalid side i = " << i);
     }
 
   // Set the nodes
   for (unsigned n=0; n<face->n_nodes(); ++n)
     face->set_node(n) = this->node_ptr(InfHex8::side_nodes_map[i][n]);
 
   return face;
 }

◆ side_ptr() [2/4]

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

finaloverridevirtual

Rebuilds a primitive (4-noded) quad or infquad for face i.

Implements libMesh::Elem.

Definition at line 150 of file cell_inf_hex.C.

References libMesh::INFQUAD4, n_sides(), libMesh::Elem::node_ptr(), libMesh::QUAD4, libMesh::Elem::side(), libMesh::InfHex8::side_nodes_map, side_ptr(), and libMesh::Elem::subdomain_id().

 {
   libmesh_assert_less (i, this->n_sides());
 
   // Think of a unit cube: (-1,1) x (-1,1) x (1,1)
   switch (i)
     {
       // the base face
     case 0:
       {
         if (!side.get() || side->type() != QUAD4)
           {
             side = this->side_ptr(i);
             return;
           }
         break;
       }
 
       // connecting to another infinite element
     case 1:
     case 2:
     case 3:
     case 4:
       {
         if (!side.get() || side->type() != INFQUAD4)
           {
             side = this->side_ptr(i);
             return;
           }
         break;
       }
 
     default:
       libmesh_error_msg("Invalid side i = " << i);
     }
 
   side->subdomain_id() = this->subdomain_id();
 
   // Set the nodes
   for (auto n : side->node_index_range())
     side->set_node(n) = this->node_ptr(InfHex8::side_nodes_map[i][n]);
 }

◆ side_ptr() [3/4]

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

inlineinherited

Definition at line 2175 of file elem.h.

References libMesh::Elem::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() [4/4]

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

inlineinherited

Definition at line 2188 of file elem.h.

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

inlineprotectedinherited

An implementation for simple (all sides equal) elements

Definition at line 2257 of file elem.h.

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

 {
   libmesh_assert_less (i, this->n_sides());
 
   if (!side.get() || side->type() != sidetype)
     side = this->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]);
     }
 }

◆ subactive()

bool libMesh::Elem::subactive ( ) const

inlineinherited

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

Definition at line 2408 of file elem.h.

References libMesh::Elem::active(), libMesh::Elem::has_children(), and libMesh::Elem::parent().

Referenced by libMesh::Elem::active_family_tree(), libMesh::Elem::active_family_tree_by_neighbor(), libMesh::Elem::active_family_tree_by_side(), libMesh::Elem::active_family_tree_by_topological_neighbor(), libMesh::HPCoarsenTest::add_projection(), libMesh::Elem::ancestor(), libMesh::FEAbstract::compute_node_constraints(), libMesh::UnstructuredMesh::contract(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::Elem::family_tree(), libMesh::Elem::family_tree_by_neighbor(), libMesh::Elem::family_tree_by_side(), libMesh::Elem::family_tree_by_subneighbor(), libMesh::Elem::find_interior_neighbors(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::Elem::get_info(), libMesh::Elem::libmesh_assert_valid_neighbors(), libMesh::Elem::make_links_to_me_local(), libMesh::Elem::make_links_to_me_remote(), libMesh::Elem::max_descendant_p_level(), libMesh::Elem::min_new_p_level_by_neighbor(), libMesh::Elem::min_p_level_by_neighbor(), libMesh::Elem::refine(), libMesh::Elem::remove_links_to_me(), libMesh::ReplicatedMesh::stitching_helper(), and libMesh::Parallel::Packing< T >::unpack().

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

inlineinherited

Returns: The subdomain that this element belongs to.

Definition at line 2034 of file elem.h.

References libMesh::Elem::_sbd_id.

 {
   return _sbd_id;
 }

◆ subdomain_id() [2/2]

subdomain_id_type & libMesh::Elem::subdomain_id ( )

inlineinherited

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

Definition at line 2042 of file elem.h.

References libMesh::Elem::_sbd_id.

 {
   return _sbd_id;
 }

◆ top_parent()

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

inlineinherited

Returns: A pointer to the element's top-most (i.e. level-0) parent.

That is, this if this is a level-0 element, this element's parent if this is a level-1 element, this element's grandparent if this is a level-2 element, etc...

Definition at line 2503 of file elem.h.

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

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::BoundaryInfo::add_elements(), libMesh::BoundaryInfo::boundary_ids(), libMesh::BoundaryInfo::edge_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_amr_interior_parents(), libMesh::ExodusII_IO::read_elemental_variable(), and libMesh::BoundaryInfo::side_with_boundary_id().

 {
   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

inherited

Returns: A pointer to the $i^{th}$ neighbor of this element for interior elements. If an element is on a periodic boundary, it will return a corresponding element on the opposite side.

Definition at line 920 of file elem.C.

References libMesh::PeriodicBoundaries::boundary(), libMesh::Elem::level(), mesh, libMesh::Elem::n_neighbors(), libMesh::PeriodicBoundaries::neighbor(), libMesh::Elem::neighbor_ptr(), and libMesh::Elem::parent().

Referenced by libMesh::Elem::has_topological_neighbor(), libMesh::DefaultCoupling::operator()(), and libMesh::MeshRefinement::topological_neighbor().

 {
   libmesh_assert_less (i, this->n_neighbors());
 
   const Elem * neighbor_i = this->neighbor_ptr(i);
   if (neighbor_i != nullptr)
     return neighbor_i;
 
   if (pb)
     {
       // Since the neighbor is nullptr it must be on a boundary. We need
       // see if this is a periodic boundary in which case it will have a
       // topological neighbor
       std::vector<boundary_id_type> bc_ids;
       mesh.get_boundary_info().boundary_ids(this, cast_int<unsigned short>(i), bc_ids);
       for (const auto & id : bc_ids)
         if (pb->boundary(id))
           {
             neighbor_i = pb->neighbor(id, point_locator, this, i);
 
             // Since coarse elements do not have more refined
             // neighbors we need to make sure that we don't return one
             // of these types of neighbors.
             if (neighbor_i)
               while (level() < neighbor_i->level())
                 neighbor_i = neighbor_i->parent();
             return neighbor_i;
           }
     }
 
   return nullptr;
 }

◆ topological_neighbor() [2/2]

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

inherited

Returns: A writable pointer to the $i^{th}$ neighbor of this element for interior elements. If an element is on a periodic boundary, it will return a corresponding element on the opposite side.

Definition at line 878 of file elem.C.

References libMesh::PeriodicBoundaries::boundary(), libMesh::Elem::level(), mesh, libMesh::Elem::n_neighbors(), libMesh::PeriodicBoundaries::neighbor(), libMesh::Elem::neighbor_ptr(), and libMesh::Elem::parent().

 {
   libmesh_assert_less (i, this->n_neighbors());
 
   Elem * neighbor_i = this->neighbor_ptr(i);
   if (neighbor_i != nullptr)
     return neighbor_i;
 
   if (pb)
     {
       // Since the neighbor is nullptr it must be on a boundary. We need
       // see if this is a periodic boundary in which case it will have a
       // topological neighbor
       std::vector<boundary_id_type> bc_ids;
       mesh.get_boundary_info().boundary_ids(this, cast_int<unsigned short>(i), bc_ids);
       for (const auto & id : bc_ids)
         if (pb->boundary(id))
           {
             // Since the point locator inside of periodic boundaries
             // returns a const pointer we will retrieve the proper
             // pointer directly from the mesh object.
             const Elem * const cn = pb->neighbor(id, point_locator, this, i);
             neighbor_i = const_cast<Elem *>(cn);
 
             // Since coarse elements do not have more refined
             // neighbors we need to make sure that we don't return one
             // of these types of neighbors.
             if (neighbor_i)
               while (level() < neighbor_i->level())
                 neighbor_i = neighbor_i->parent();
             return neighbor_i;
           }
     }
 
   return nullptr;
 }

◆ total_family_tree()

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

inherited

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

Definition at line 1557 of file elem.C.

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

Referenced by libMesh::connect_families(), and libMesh::Partitioner::set_parent_processor_ids().

 {
   // Clear the vector if the flag reset tells us to.
   if (reset)
     family.clear();
 
   // Add this element to the family tree.
   family.push_back(this);
 
   // Recurse into the elements children, if it has them.
   // Do not clear the vector any more.
   if (this->has_children())
     for (auto & c : this->child_ref_range())
       if (!c.is_remote())
         c.total_family_tree (family, false);
 }

◆ total_family_tree_by_neighbor()

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

inherited

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

Definition at line 1688 of file elem.C.

References libMesh::Elem::child_ref_range(), libMesh::Elem::has_children(), libMesh::Elem::has_neighbor(), and libMesh::remote_elem.

 {
   // Clear the vector if the flag reset tells us to.
   if (reset)
     family.clear();
 
   // This only makes sense if we're already a neighbor
   libmesh_assert (this->has_neighbor(neighbor_in));
 
   // Add this element to the family tree.
   family.push_back(this);
 
   // Recurse into the elements children, if it has any.
   // Do not clear the vector any more.
   if (this->has_children())
     for (auto & c : this->child_ref_range())
       if (&c != remote_elem && c.has_neighbor(neighbor_in))
         c.total_family_tree_by_neighbor (family, neighbor_in, false);
 }

◆ total_family_tree_by_subneighbor()

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

inherited

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

Definition at line 1754 of file elem.C.

References libMesh::Elem::child_ref_range(), libMesh::Elem::has_children(), libMesh::Elem::has_neighbor(), libMesh::Elem::is_ancestor_of(), and libMesh::remote_elem.

 {
   // Clear the vector if the flag reset tells us to.
   if (reset)
     family.clear();
 
   // To simplify this function we need an existing neighbor
   libmesh_assert (neighbor_in);
   libmesh_assert_not_equal_to (neighbor_in, remote_elem);
   libmesh_assert (this->has_neighbor(neighbor_in));
 
   // This only makes sense if subneighbor descends from neighbor
   libmesh_assert (subneighbor);
   libmesh_assert_not_equal_to (subneighbor, remote_elem);
   libmesh_assert (neighbor_in->is_ancestor_of(subneighbor));
 
   // Add this element to the family tree if applicable.
   if (neighbor_in == subneighbor)
     family.push_back(this);
 
   // Recurse into the elements children, if it has any.
   // Do not clear the vector any more.
   if (this->has_children())
     for (auto & c : this->child_ref_range())
       if (&c != remote_elem)
         for (auto child_neigh : c.neighbor_ptr_range())
           if (child_neigh &&
               (child_neigh == neighbor_in ||
                (child_neigh->parent() == neighbor_in &&
                 child_neigh->is_ancestor_of(subneighbor))))
             c.total_family_tree_by_subneighbor
               (family, child_neigh, subneighbor, false);
 }

◆ type()

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

pure virtualinherited

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

Implemented in libMesh::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

inlineinherited

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

Referenced by libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::MeshTools::Modification::flatten(), libMesh::Elem::get_info(), libMesh::MeshTools::libmesh_assert_valid_unique_ids(), libMesh::Parallel::Packing< T >::pack(), libMesh::XdrIO::pack_element(), and libMesh::ExodusII_IO::read_elemental_variable().

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

Definition at line 482 of file dof_object.C.

References libMesh::DofObject::_idx_buf, libMesh::DofObject::clear_old_dof_object(), libMesh::DofObject::DofObject(), libMesh::DofObject::old_dof_object, and libMesh::DofObject::unpack_indexing().

Referenced by libMesh::Parallel::Packing< T >::unpack(), and libMesh::DofObject::unpack_indexing().

 {
   _idx_buf.clear();
 
 #ifdef LIBMESH_ENABLE_AMR
   this->clear_old_dof_object();
   const bool has_old_dof_object = cast_int<bool>(*begin++);
 #endif
 
   const largest_id_type size = *begin++;
   _idx_buf.reserve(size);
   std::copy(begin, begin+size, back_inserter(_idx_buf));
 
   // Check as best we can for internal consistency now
   libmesh_assert(_idx_buf.empty() ||
                  (_idx_buf[0] <= _idx_buf.size()));
 #ifdef DEBUG
   if (!_idx_buf.empty())
     for (unsigned int i=1; i < _idx_buf[0]; ++i)
       {
         libmesh_assert_greater_equal (_idx_buf[i], _idx_buf[i-1]);
         libmesh_assert_equal_to ((_idx_buf[i] - _idx_buf[i-1])%2, 0);
         libmesh_assert_less_equal (_idx_buf[i], _idx_buf.size());
       }
 #endif
 
 #ifdef LIBMESH_ENABLE_AMR
   if (has_old_dof_object)
     {
       this->old_dof_object = new DofObject();
       this->old_dof_object->unpack_indexing(begin+size);
     }
 #endif
 }

◆ unpackable_indexing_size()

unsigned int libMesh::DofObject::unpackable_indexing_size ( std::vector< largest_id_type >::const_iterator begin )

staticinherited

If we have indices packed into an buffer for communications, how much of that buffer applies to this dof object?

Definition at line 461 of file dof_object.C.

Referenced by libMesh::Parallel::Packing< T >::packed_size(), and libMesh::Parallel::Packing< T >::unpack().

 {
 #ifdef LIBMESH_ENABLE_AMR
   const bool has_old_dof_object = cast_int<bool>(*begin++);
 
   static const int dof_header_size = 2;
 #else
   static const bool has_old_dof_object = false;
   static const int dof_header_size = 1;
 #endif
 
   const largest_id_type this_indexing_size = *begin++;
 
   return cast_int<unsigned int>
     (dof_header_size + this_indexing_size +
      (has_old_dof_object ?
       unpackable_indexing_size(begin+this_indexing_size) : 0));
 }

◆ valid_id()

bool libMesh::DofObject::valid_id ( ) const

inlineinherited

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::ReplicatedMesh::add_elem(), libMesh::DistributedMesh::add_elem(), libMesh::ReplicatedMesh::add_node(), libMesh::DistributedMesh::add_node(), libMesh::Node::get_info(), libMesh::Elem::get_info(), libMesh::DofObject::id(), and libMesh::Elem::libmesh_assert_valid_node_pointers().

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

◆ valid_processor_id()

bool libMesh::DofObject::valid_processor_id ( ) const

inlineinherited

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

Definition at line 741 of file dof_object.h.

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

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

◆ valid_unique_id()

bool libMesh::DofObject::valid_unique_id ( ) const

inlineinherited

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

Definition at line 705 of file dof_object.h.

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

Referenced by libMesh::ReplicatedMesh::add_elem(), libMesh::DistributedMesh::add_elem(), libMesh::ReplicatedMesh::add_node(), libMesh::DistributedMesh::add_node(), libMesh::ReplicatedMesh::add_point(), libMesh::Elem::get_info(), libMesh::ReplicatedMesh::insert_elem(), libMesh::DistributedMesh::insert_elem(), libMesh::ReplicatedMesh::insert_node(), libMesh::Parallel::Packing< T >::pack(), and 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

inlineinherited

Returns: A pair consisting of the variable group number and the offset index from the start of that group for variable var on system s associated with this DofObject

Definition at line 887 of file dof_object.h.

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

Referenced by libMesh::DofMap::_dof_indices(), and 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

inlineinherited

VariableGroup DoF indices are indexed as id = base + var_in_vg*ncomp + comp This method allows for direct access to the base.

Definition at line 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::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DofMap::reinit(), libMesh::DofMap::set_nonlocal_dof_objects(), and libMesh::DofObject::set_vg_dof_base().

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

Real libMesh::Elem::volume ( ) const

virtualinherited

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.

Definition at line 2826 of file elem.C.

References libMesh::FEGenericBase< OutputType >::build(), libMesh::Elem::default_order(), libMesh::FEType::default_quadrature_order(), libMesh::Elem::dim(), libMesh::LAGRANGE, and libMesh::Real.

Referenced by libMesh::ElemCutter::cut_3D(), and libMesh::Elem::get_info().

 {
   // The default implementation builds a finite element of the correct
   // order and sums up the JxW contributions.  This can be expensive,
   // so the various element types can overload this method and compute
   // the volume more efficiently.
   FEType fe_type (this->default_order() , LAGRANGE);
 
   std::unique_ptr<FEBase> fe (FEBase::build(this->dim(),
                                             fe_type));
 
   const std::vector<Real> & JxW = fe->get_JxW();
 
   // The default quadrature rule should integrate the mass matrix,
   // thus it should be plenty to compute the area
   QGauss qrule (this->dim(), fe_type.default_quadrature_order());
 
   fe->attach_quadrature_rule(&qrule);
 
   fe->reinit(this);
 
   Real vol=0.;
   for (unsigned int qp=0; qp<qrule.n_points(); ++qp)
     vol += JxW[qp];
 
   return vol;
 
 }

◆ which_child_am_i()

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

inlineinherited

Returns: The child index which e corresponds to.

I.e. if c = a->which_child_am_i(e); then a->child_ptr(c) will be e.

Definition at line 2620 of file elem.h.

References libMesh::Elem::child_ptr(), libMesh::Elem::has_children(), libMesh::invalid_uint, and libMesh::Elem::n_children().

Referenced by libMesh::BoundaryInfo::boundary_ids(), libMesh::BoundaryInfo::edge_boundary_ids(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::Elem::make_links_to_me_remote(), libMesh::Parallel::Packing< T >::pack(), libMesh::BoundaryInfo::side_with_boundary_id(), libMesh::MeshTools::Modification::smooth(), and 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

inlineinherited

This function tells you which neighbor e is. I.e. if s = a->which_neighbor_am_i(e); then a->neighbor(s) will be an ancestor of e.

Definition at line 2314 of file elem.h.

References libMesh::invalid_uint, libMesh::Elem::level(), libMesh::Elem::n_sides(), libMesh::Elem::neighbor_ptr(), and libMesh::Elem::parent().

Referenced by libMesh::FEGenericBase< FEOutputType< T >::type >::compute_proj_constraints(), libMesh::MeshTools::find_hanging_nodes_and_parents(), libMesh::Elem::libmesh_assert_valid_neighbors(), libMesh::Elem::make_links_to_me_remote(), libMesh::Elem::nullify_neighbors(), and libMesh::Elem::remove_links_to_me().

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

unsigned int libMesh::InfHex::which_node_am_i	(	unsigned int	side,
		unsigned int	side_node
	)		const

overridevirtual

Returns: InfHex8::side_nodes_map[side][side_node] after doing some range checking.

Implements libMesh::Elem.

Reimplemented in libMesh::InfHex18, and libMesh::InfHex16.

Definition at line 89 of file cell_inf_hex.C.

References n_sides(), libMesh::Elem::side(), and libMesh::InfHex8::side_nodes_map.

 {
   libmesh_assert_less (side, this->n_sides());
   libmesh_assert_less (side_node, 4);
 
   return InfHex8::side_nodes_map[side][side_node];
 }

◆ which_side_am_i()

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

inlineinherited

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

References libMesh::invalid_uint, libMesh::Elem::is_node_on_side(), libMesh::Elem::n_nodes(), libMesh::Elem::n_sides(), and libMesh::Elem::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

inherited

Writes the element connectivity for various IO packages to the passed ostream "out". Not virtual, since it is implemented in the base class.

Definition at line 1360 of file elem.C.

References libMesh::Elem::_nodes, libMesh::Elem::connectivity(), libMesh::INVALID_IO_PACKAGE, libMesh::Elem::n_sub_elem(), libMesh::Elem::node_id(), libMesh::Elem::node_index_range(), libMesh::TECPLOT, and libMesh::UCD.

 {
   libmesh_assert (out_stream.good());
   libmesh_assert(_nodes);
   libmesh_assert_not_equal_to (iop, INVALID_IO_PACKAGE);
 
   switch (iop)
     {
     case TECPLOT:
       {
         // This connectivity vector will be used repeatedly instead
         // of being reconstructed inside the loop.
         std::vector<dof_id_type> conn;
         for (unsigned int sc=0; sc <this->n_sub_elem(); sc++)
           {
             this->connectivity(sc, TECPLOT, conn);
 
             std::copy(conn.begin(),
                       conn.end(),
                       std::ostream_iterator<dof_id_type>(out_stream, " "));
 
             out_stream << '\n';
           }
         return;
       }
 
     case UCD:
       {
         for (auto i : this->node_index_range())
           out_stream << this->node_id(i)+1 << "\t";
 
         out_stream << '\n';
         return;
       }
 
     default:
       libmesh_error_msg("Unsupported IO package " << iop);
     }
 }

Member Data Documentation

◆ _children

Elem** libMesh::Elem::_children

protectedinherited

Pointers to this element's children.

Definition at line 1707 of file elem.h.

Referenced by libMesh::Elem::add_child(), libMesh::Elem::child_ptr(), libMesh::Elem::child_ref_range(), libMesh::Elem::contract(), libMesh::Elem::has_ancestor_children(), libMesh::Elem::has_children(), libMesh::Elem::raw_child_ptr(), libMesh::Elem::refine(), and libMesh::Elem::set_child().

◆ _counts [1/2]

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

Definition at line 122 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::get_info(), libMesh::ReferenceCounter::increment_constructor_count(), and libMesh::ReferenceCounter::increment_destructor_count().

◆ _counts [2/2]

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

Definition at line 122 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::get_info(), libMesh::ReferenceCounter::increment_constructor_count(), and libMesh::ReferenceCounter::increment_destructor_count().

◆ _elemlinks

Elem** libMesh::Elem::_elemlinks

protectedinherited

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

Definition at line 1701 of file elem.h.

Referenced by libMesh::Elem::Elem(), libMesh::Elem::interior_parent(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::neighbor_ptr_range(), libMesh::Elem::parent(), libMesh::Elem::set_interior_parent(), libMesh::Elem::set_neighbor(), and libMesh::Elem::set_parent().

◆ _elemlinks_data

Elem* libMesh::InfHex::_elemlinks_data[6+(LIBMESH_DIM >3)]

protected

Data for links to parent/neighbor/interior_parent elements.

Definition at line 182 of file cell_inf_hex.h.

◆ _enable_print_counter [1/2]

bool libMesh::ReferenceCounter::_enable_print_counter = true

staticprotectedinherited

Flag to control whether reference count information is printed when print_info is called.

Definition at line 141 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::disable_print_counter_info(), libMesh::ReferenceCounter::enable_print_counter_info(), and libMesh::ReferenceCounter::print_info().

◆ _enable_print_counter [2/2]

bool libMesh::ReferenceCounter::_enable_print_counter = true

staticprotectedinherited

Flag to control whether reference count information is printed when print_info is called.

Definition at line 141 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::disable_print_counter_info(), libMesh::ReferenceCounter::enable_print_counter_info(), and libMesh::ReferenceCounter::print_info().

◆ _master_points

const Real libMesh::InfHex::_master_points

staticprotected

Initial value:

=
  {
    {-1, -1, 0},
    {1, -1, 0},
    {1, 1, 0},
    {-1, 1, 0},
    {-1, -1, 1},
    {1, -1, 1},
    {1, 1, 1},
    {-1, 1, 1},
    {0, -1, 0},
    {1, 0, 0},
    {0, 1, 0},
    {-1, 0, 0},
    {0, -1, 1},
    {1, 0, 1},
    {0, 1, 1},
    {-1, 0, 1},
    {0, 0, 0},
    {0, 0, 1}
  }

Master element node locations

Definition at line 210 of file cell_inf_hex.h.

Referenced by master_point().

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

protectedinherited

Pointers to the nodes we are connected to.

Definition at line 1695 of file elem.h.

◆ _p_level

unsigned char libMesh::Elem::_p_level

protectedinherited

p refinement level - the difference between the polynomial degree on this element and the minimum polynomial degree on the mesh. This is stored as an unsigned char to save space. In theory, these last four bytes might have been padding anyway.

Definition at line 1736 of file elem.h.

Referenced by libMesh::Elem::hack_p_level(), libMesh::Elem::max_descendant_p_level(), libMesh::Elem::p_level(), and libMesh::Elem::set_p_level().

◆ _pflag

unsigned char libMesh::Elem::_pflag

protectedinherited

p refinement flag. This is stored as an unsigned char to save space.

Definition at line 1726 of file elem.h.

Referenced by libMesh::Elem::p_refinement_flag(), and libMesh::Elem::set_p_refinement_flag().

◆ _rflag

unsigned char libMesh::Elem::_rflag

protectedinherited

h refinement flag. This is stored as an unsigned char to save space.

Definition at line 1720 of file elem.h.

Referenced by libMesh::Elem::refinement_flag(), and libMesh::Elem::set_refinement_flag().

◆ _sbd_id

subdomain_id_type libMesh::Elem::_sbd_id

protectedinherited

The subdomain to which this element belongs.

Definition at line 1713 of file elem.h.

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

◆ _second_order_adjacent_vertices

const unsigned short int libMesh::InfHex::_second_order_adjacent_vertices

staticprotected

Initial value:

=
  {
    { 0,  1}, 
    { 1,  2}, 
    { 2,  3}, 
    { 0,  3}, 
    { 4,  5}, 
    { 5,  6}, 
    { 6,  7}, 
    { 4,  7}  
  }

For higher-order elements, namely InfHex16 and InfHex18, the matrices for adjacent vertices of second order nodes are quite similar (apart from the face nodes, which are directly handled by InfHex18). Therefore hold this matrix here, so that both can re-use this. Matrix that tells which vertices define the location of mid-side (or second-order) nodes.

Definition at line 195 of file cell_inf_hex.h.

Referenced by libMesh::InfHex16::second_order_adjacent_vertex(), and libMesh::InfHex18::second_order_adjacent_vertex().

◆ _second_order_vertex_child_index

const unsigned short int libMesh::InfHex::_second_order_vertex_child_index

staticprotected

Initial value:

=
  {
    99,99,99,99,99,99,99,99, 
    1,2,3,3,                 
    5,6,7,7,2,               
    6                        
  }

Vector that names the child vertex index for each second order node.

Definition at line 205 of file cell_inf_hex.h.

Referenced by libMesh::InfHex16::second_order_child_vertex(), and libMesh::InfHex18::second_order_child_vertex().

◆ _second_order_vertex_child_number

const unsigned short int libMesh::InfHex::_second_order_vertex_child_number

staticprotected

Initial value:

=
  {
    99,99,99,99,99,99,99,99, 
    0,1,2,0,                 
    0,1,2,0,0,               
    0                        
  }

Vector that names a child sharing each second order node.

Definition at line 200 of file cell_inf_hex.h.

Referenced by libMesh::InfHex16::second_order_child_vertex(), and libMesh::InfHex18::second_order_child_vertex().

◆ 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::DofMap::_dof_indices(), libMesh::Node::active(), libMesh::TopologyMap::add_node(), libMesh::MeshRefinement::add_node(), libMesh::ReplicatedMesh::add_point(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::Elem::bracketing_nodes(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_proj_constraints(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DofMap::dof_indices(), libMesh::DofObject::dof_number(), libMesh::TopologyMap::find(), libMesh::ReplicatedMesh::insert_node(), libMesh::DofObject::invalidate_dofs(), libMesh::DofObject::invalidate_id(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::Elem::node_id(), libMesh::DofMap::old_dof_indices(), libMesh::DistributedMesh::own_node(), libMesh::Parallel::Packing< T >::pack(), libMesh::XdrIO::pack_element(), libMesh::SFCPartitioner::partition_range(), libMesh::Elem::point(), libMesh::System::read_legacy_data(), libMesh::System::read_parallel_data(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::DofMap::SCALAR_dof_indices(), libMesh::DofObject::set_dof_number(), libMesh::DofObject::set_n_comp_group(), libMesh::DofObject::set_n_vars_per_group(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Parallel::sync_node_data_by_element_id_once(), libMesh::Parallel::Packing< T >::unpack(), libMesh::DofObject::valid_id(), and libMesh::System::write_parallel_data().

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

◆ invalid_subdomain_id

const subdomain_id_type libMesh::Elem::invalid_subdomain_id = std::numeric_limits<subdomain_id_type>::max()

staticinherited

A static integral constant representing an invalid subdomain id. See also DofObject::{invalid_id, invalid_unique_id, invalid_processor_id}.

Note: We don't use the static_cast(-1) trick here since subdomain_id_type is sometimes a signed integer for compatibility reasons (see libmesh/id_types.h).; Normally you can declare static const integral types directly in the header file (C++ standard, 9.4.2/4) but std::numeric_limits<T>::max() is not considered a "constant expression". This one is therefore defined in elem.C. http://stackoverflow.com/questions/2738435/using-numeric-limitsmax-in-constant-expressions

Definition at line 262 of file elem.h.

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::BoundaryInfo::add_elements(), libMesh::MeshBase::get_id_by_name(), and libMesh::BoundaryInfo::sync().

◆ 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::Parallel::Packing< T >::pack(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DofObject::unique_id(), and libMesh::DofObject::valid_unique_id().

◆ max_n_nodes

const unsigned int libMesh::Elem::max_n_nodes = 27

staticinherited

The maximum number of nodes any element can contain. This is useful for replacing heap vectors with stack arrays.

Definition at line 600 of file elem.h.

Referenced by libMesh::Elem::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(), libMesh::DofObject::clear_old_dof_object(), libMesh::OldSolutionValue< Output, point_output >::eval_at_node(), libMesh::OldSolutionCoefs< Output, point_output >::eval_at_node(), libMesh::DofMap::old_dof_indices(), libMesh::BuildProjectionList::operator()(), libMesh::DofObject::operator=(), libMesh::DofObject::pack_indexing(), libMesh::DofObject::packed_indexing_size(), libMesh::DofMap::reinit(), libMesh::DofObject::set_old_dof_object(), and libMesh::DofObject::unpack_indexing().

◆ type_to_n_edges_map

const unsigned int libMesh::Elem::type_to_n_edges_map

staticinherited

This array maps the integer representation of the ElemType enum to the number of edges on the element.

Definition at line 669 of file elem.h.

Referenced by libMesh::Parallel::Packing< T >::packed_size().

◆ type_to_n_nodes_map

const unsigned int libMesh::Elem::type_to_n_nodes_map

staticinherited

This array maps the integer representation of the ElemType enum to the number of nodes in the element.

Definition at line 589 of file elem.h.

Referenced by libMesh::XdrIO::pack_element(), libMesh::Parallel::Packing< T >::packed_size(), libMesh::CheckpointIO::read_connectivity(), libMesh::XdrIO::read_serialized_connectivity(), and libMesh::Parallel::Packing< T >::unpack().

◆ type_to_n_sides_map

const unsigned int libMesh::Elem::type_to_n_sides_map

staticinherited

This array maps the integer representation of the ElemType enum to the number of sides on the element.

Definition at line 620 of file elem.h.

Referenced by libMesh::Parallel::Packing< T >::packed_size().

The documentation for this class was generated from the following files:

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

Detailed Description

Member Typedef Documentation

◆ ConstNeighborPtrIter

◆ Counts [1/2]

◆ Counts [2/2]

◆ NeighborPtrIter

◆ Predicate

Member Enumeration Documentation

◆ RefinementState

Constructor & Destructor Documentation

◆ InfHex() [1/3]

◆ InfHex() [2/3]

◆ InfHex() [3/3]

◆ ~InfHex()

Member Function Documentation

◆ _get_bracketing_node_cache()

◆ _get_parent_indices_cache()

◆ active()

◆ active_family_tree()

◆ active_family_tree_by_neighbor()

◆ active_family_tree_by_side()

◆ active_family_tree_by_topological_neighbor()

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

◆ dim()

◆ disable_print_counter_info() [1/2]

◆ disable_print_counter_info() [2/2]

◆ dof_number() [1/2]

◆ dof_number() [2/2]

◆ edge_index_range()

◆ embedding_matrix()

◆ embedding_matrix_version()