This is the MeshBase class. More...

#include <mesh_base.h>

Inheritance diagram for libMesh::MeshBase:

Classes
struct	const_element_iterator
	The definition of the const_element_iterator struct. More...

struct	const_node_iterator
	The definition of the const_node_iterator struct. More...

struct	element_iterator
	The definition of the element_iterator struct. More...

struct	node_iterator
	The definition of the node_iterator struct. More...

struct	Preparation
	Flags indicating in what ways a mesh has been prepared for use. More...

Public Types
typedef std::set< elemset_id_type >	elemset_type
	Typedef for the "set" container used to store elemset ids.

typedef std::vector< GhostingFunctor * >::const_iterator	GhostingFunctorIterator
	Iterator type for ghosting functor ranges.

typedef Predicates::multi_predicate	Predicate
	We need an empty, generic class to act as a predicate for this and derived mesh classes.

typedef StoredRange< MeshBase::const_element_iterator, const Elem * >	ConstElemRange

typedef std::vector< std::pair< std::pair< const Elem *, unsigned int >, Real > >	constraint_rows_mapped_type

typedef std::map< const Node *, constraint_rows_mapped_type >	constraint_rows_type

Public Member Functions
	MeshBase (const Parallel::Communicator &comm_in, unsigned char dim=1)
	Constructor.

	MeshBase (const MeshBase &other_mesh)
	Copy-constructor.

	MeshBase (MeshBase &&)=delete
	Move-constructor - deleted because after a theoretical move-construction and then destruction of the moved-from object, the moved `BoundaryInfo` would hold an invalid reference to the moved-from mesh.

MeshBase &	operator= (const MeshBase &)=delete
	Copy and move assignment are not allowed because MeshBase subclasses manually manage memory (Elems and Nodes) and therefore the default versions of these operators would leak memory.

MeshBase &	operator= (MeshBase &&other_mesh)

virtual MeshBase &	assign (MeshBase &&other_mesh)=0
	Shim to allow operator = (&&) to behave like a virtual function without having to be one.

bool	operator== (const MeshBase &other_mesh) const
	This tests for exactly-equal data in all the senses that a mathematician would care about (element connectivity, nodal coordinates), but in the senses a programmer would care about it allows for non-equal equivalence in some ways (we accept different Elem/Node addresses in memory) but not others (we do not accept different subclass types, nor even different Elem/Node ids).

bool	operator!= (const MeshBase &other_mesh) const

bool	locally_equals (const MeshBase &other_mesh) const
	This behaves the same as operator==, but only for the local and ghosted aspects of the mesh; i.e.

virtual std::unique_ptr< MeshBase >	clone () const =0
	Virtual "copy constructor".

virtual	~MeshBase ()
	Destructor.

virtual std::unique_ptr< Partitioner > &	partitioner ()
	A partitioner to use at each partitioning.

const BoundaryInfo &	get_boundary_info () const
	The information about boundary ids on the mesh.

BoundaryInfo &	get_boundary_info ()
	Writable information about boundary ids on the mesh.

virtual void	clear ()
	Deletes all the element and node data that is currently stored.

virtual void	clear_elems ()=0
	Deletes all the element data that is currently stored.

bool	is_prepared () const

Preparation	preparation () const

void	set_isnt_prepared ()
	Tells this we have done some operation where we should no longer consider ourself prepared.

void	unset_is_prepared ()
	Tells this we have done some operation where we should no longer consider ourself prepared.

void	unset_is_partitioned ()
	Tells this we have done some operation creating unpartitioned elements.

void	unset_has_synched_id_counts ()
	Tells this we have done some operation (e.g.

void	unset_has_neighbor_ptrs ()
	Tells this we have done some operation (e.g.

void	unset_has_cached_elem_data ()
	Tells this we have done some operation (e.g.

void	unset_has_interior_parent_ptrs ()
	Tells this we have done some operation (e.g.

void	unset_has_removed_remote_elements ()
	Tells this we have done some operation (e.g.

void	unset_has_removed_orphaned_nodes ()
	Tells this we have done some operation (e.g.

void	unset_has_reinit_ghosting_functors ()
	Tells this we have done some operation (e.g.

void	unset_has_boundary_id_sets ()
	Tells this we have done some operation which may have invalidated our cached boundary id sets.

void	unset_has_synched_subdomain_name_map ()
	Tells this we have done some operation which may have left the subdomain id to name map inconsistent across processors.

virtual bool	is_serial () const

virtual bool	is_serial_on_zero () const

virtual void	set_distributed ()
	Asserts that not all elements and nodes of the mesh necessarily exist on the current processor.

virtual bool	is_replicated () const

virtual void	allgather ()
	Gathers all elements and nodes of the mesh onto every processor.

virtual void	gather_to_zero ()
	Gathers all elements and nodes of the mesh onto processor zero.

virtual void	delete_remote_elements ()
	When supported, deletes all nonlocal elements of the mesh except for "ghosts" which touch a local element, and deletes all nodes which are not part of a local or ghost element.

void	reinit_ghosting_functors ()
	Loops over ghosting functors and calls mesh_reinit()

unsigned int	mesh_dimension () const

void	set_mesh_dimension (unsigned char d)
	Resets the logical dimension of the mesh.

const std::set< unsigned char > &	elem_dimensions () const

const std::set< Order > &	elem_default_orders () const

Order	supported_nodal_order () const

void	set_elem_dimensions (std::set< unsigned char > elem_dims)
	Most of the time you should not need to call this, as the element dimensions will be set automatically by a call to cache_elem_data(), therefore only call this if you know what you're doing.

void	add_elemset_code (dof_id_type code, MeshBase::elemset_type id_set)
	Tabulate a user-defined "code" for elements which belong to the element sets specified in `id_set`.

unsigned int	n_elemsets () const
	Returns the number of unique elemset ids which have been added via add_elemset_code(), which is the size of the _all_elemset_ids set.

void	get_elemsets (dof_id_type elemset_code, MeshBase::elemset_type &id_set_to_fill) const
	Look up the element sets for a given elemset code and vice-versa.

dof_id_type	get_elemset_code (const MeshBase::elemset_type &id_set) const

std::vector< dof_id_type >	get_elemset_codes () const
	Return a vector of all elemset codes defined on the mesh.

void	change_elemset_code (dof_id_type old_code, dof_id_type new_code)
	Replace elemset code "old_code" with "new_code".

void	change_elemset_id (elemset_id_type old_id, elemset_id_type new_id)
	Replace elemset id "old_id" with "new_id".

unsigned int	spatial_dimension () const

void	set_spatial_dimension (unsigned char d)
	Sets the "spatial dimension" of the Mesh.

virtual dof_id_type	n_nodes () const =0

virtual dof_id_type	parallel_n_nodes () const =0

dof_id_type	n_nodes_on_proc (const processor_id_type proc) const

dof_id_type	n_local_nodes () const

dof_id_type	n_unpartitioned_nodes () const

virtual dof_id_type	max_node_id () const =0

unique_id_type	next_unique_id () const

virtual void	set_next_unique_id (unique_id_type id)=0
	Sets the next available unique id to be used.

virtual void	reserve_nodes (const dof_id_type nn)=0
	Reserves space for a known number of nodes.

virtual dof_id_type	n_elem () const =0

virtual dof_id_type	parallel_n_elem () const =0

virtual dof_id_type	max_elem_id () const =0

virtual unique_id_type	parallel_max_unique_id () const =0

virtual void	reserve_elem (const dof_id_type ne)=0
	Reserves space for a known number of elements.

virtual void	update_parallel_id_counts ()=0
	Updates parallel caches so that methods like n_elem() accurately reflect changes on other processors.

virtual dof_id_type	n_active_elem () const =0

dof_id_type	n_elem_on_proc (const processor_id_type proc) const

dof_id_type	n_local_elem () const

dof_id_type	n_unpartitioned_elem () const

dof_id_type	n_active_elem_on_proc (const processor_id_type proc) const

dof_id_type	n_active_local_elem () const

dof_id_type	n_sub_elem () const

dof_id_type	n_active_sub_elem () const
	Same as `n_sub_elem()`, but only counts active elements.

virtual const Point &	point (const dof_id_type i) const =0

virtual const Node &	node_ref (const dof_id_type i) const

virtual Node &	node_ref (const dof_id_type i)

virtual const Node *	node_ptr (const dof_id_type i) const =0

virtual Node *	node_ptr (const dof_id_type i)=0

virtual const Node *	query_node_ptr (const dof_id_type i) const =0

virtual Node *	query_node_ptr (const dof_id_type i)=0

virtual const Elem &	elem_ref (const dof_id_type i) const

virtual Elem &	elem_ref (const dof_id_type i)

virtual const Elem *	elem_ptr (const dof_id_type i) const =0

virtual Elem *	elem_ptr (const dof_id_type i)=0

virtual const Elem *	query_elem_ptr (const dof_id_type i) const =0

virtual Elem *	query_elem_ptr (const dof_id_type i)=0

virtual Node *	add_point (const Point &p, const dof_id_type id=DofObject::invalid_id, const processor_id_type proc_id=DofObject::invalid_processor_id)=0
	Add a new `Node` at `Point` `p` to the end of the vertex array, with processor_id `procid`.

virtual Node *	add_node (Node *n)=0
	Add `Node` `n` to the end of the vertex array.

virtual Node *	add_node (std::unique_ptr< Node > n)=0
	Version of add_node() taking a std::unique_ptr by value.

virtual void	delete_node (Node *n)=0
	Removes the Node n from the mesh.

virtual void	own_node (Node &)
	Takes ownership of node `n` on this partition of a distributed mesh, by setting n.processor_id() to this->processor_id(), as well as changing n.id() and moving it in the mesh's internal container to give it a new authoritative id.

virtual void	renumber_node (dof_id_type old_id, dof_id_type new_id)=0
	Changes the id of node `old_id`, both by changing node(old_id)->id() and by moving node(old_id) in the mesh's internal container.

virtual Elem *	add_elem (Elem *e)=0
	Add elem `e` to the end of the element array.

virtual Elem *	add_elem (std::unique_ptr< Elem > e)=0
	Version of add_elem() taking a std::unique_ptr by value.

virtual Elem *	insert_elem (Elem *e)=0
	Insert elem `e` to the element array, preserving its id and replacing/deleting any existing element with the same id.

virtual Elem *	insert_elem (std::unique_ptr< Elem > e)=0
	Version of insert_elem() taking a std::unique_ptr by value.

virtual void	delete_elem (Elem *e)=0
	Removes element `e` from the mesh.

virtual void	renumber_elem (dof_id_type old_id, dof_id_type new_id)=0
	Changes the id of element `old_id`, both by changing elem(old_id)->id() and by moving elem(old_id) in the mesh's internal container.

ElemMappingType	default_mapping_type () const
	Returns the default master space to physical space mapping basis functions to be used on newly added elements.

void	set_default_mapping_type (const ElemMappingType type)
	Set the default master space to physical space mapping basis functions to be used on newly added elements.

unsigned char	default_mapping_data () const
	Returns any default data value used by the master space to physical space mapping.

void	set_default_mapping_data (const unsigned char data)
	Set the default master space to physical space mapping basis functions to be used on newly added elements.

virtual void	find_neighbors (const bool reset_remote_elements=false, const bool reset_current_list=true, const bool assert_valid=true)=0
	Locate element face (edge in 2D) neighbors.

void	remove_orphaned_nodes ()
	Removes any orphaned nodes, nodes not connected to any elements.

virtual void	renumber_nodes_and_elements ()=0
	After partitioning a mesh it is useful to renumber the nodes and elements so that they lie in contiguous blocks on the processors.

virtual void	fix_broken_node_and_element_numbering ()=0
	There is no reason for a user to ever call this function.

virtual bool	contract ()=0
	Delete subactive (i.e.

unsigned int	add_elem_integer (std::string name, bool allocate_data=true, dof_id_type default_value=DofObject::invalid_id)
	Register an integer datum (of type dof_id_type) to be added to each element in the mesh.

std::vector< unsigned int >	add_elem_integers (const std::vector< std::string > &names, bool allocate_data=true, const std::vector< dof_id_type > *default_values=nullptr)
	Register integer data (of type dof_id_type) to be added to each element in the mesh, one string name for each new integer.

unsigned int	get_elem_integer_index (std::string_view name) const

bool	has_elem_integer (std::string_view name) const

const std::string &	get_elem_integer_name (unsigned int i) const

unsigned int	n_elem_integers () const

template<typename T >
unsigned int	add_elem_datum (const std::string &name, bool allocate_data=true, const T *default_value=nullptr)
	Register a datum (of type T) to be added to each element in the mesh.

template<typename T >
std::vector< unsigned int >	add_elem_data (const std::vector< std::string > &names, bool allocate_data=true, const std::vector< T > *default_values=nullptr)
	Register data (of type T) to be added to each element in the mesh.

unsigned int	add_node_integer (std::string name, bool allocate_data=true, dof_id_type default_value=DofObject::invalid_id)
	Register an integer datum (of type dof_id_type) to be added to each node in the mesh.

std::vector< unsigned int >	add_node_integers (const std::vector< std::string > &names, bool allocate_data=true, const std::vector< dof_id_type > *default_values=nullptr)
	Register integer data (of type dof_id_type) to be added to each node in the mesh.

unsigned int	get_node_integer_index (std::string_view name) const

bool	has_node_integer (std::string_view name) const

const std::string &	get_node_integer_name (unsigned int i) const

unsigned int	n_node_integers () const

template<typename T >
unsigned int	add_node_datum (const std::string &name, bool allocate_data=true, const T *default_value=nullptr)
	Register a datum (of type T) to be added to each node in the mesh.

template<typename T >
std::vector< unsigned int >	add_node_data (const std::vector< std::string > &name, bool allocate_data=true, const std::vector< T > *default_values=nullptr)
	Register data (of type T) to be added to each node in the mesh.

void	prepare_for_use (const bool skip_renumber_nodes_and_elements, const bool skip_find_neighbors)
	Prepare a newly created (or read) mesh for use.

void	prepare_for_use (const bool skip_renumber_nodes_and_elements)

void	prepare_for_use ()

void	complete_preparation ()

virtual void	partition (const unsigned int n_parts)
	Call the default partitioner (currently `metis_partition()`).

void	partition ()

virtual void	redistribute ()
	Redistribute elements between processors.

virtual void	update_post_partitioning ()
	Recalculate any cached data (or invalidate any caches that are computed on the fly) after elements and nodes have been repartitioned.

void	allow_renumbering (bool allow)
	If false is passed in then this mesh will no longer be renumbered when being prepared for use.

bool	allow_renumbering () const

void	allow_find_neighbors (bool allow)
	If `false` is passed then this mesh will no longer work to find element neighbors when being prepared for use.

bool	allow_find_neighbors () const

void	allow_detect_interior_parents (bool allow)
	If `false` is passed then this mesh will no longer work to detect interior parents when being prepared for use.

bool	allow_detect_interior_parents () const

void	allow_remote_element_removal (bool allow)
	If false is passed in then this mesh will no longer have remote elements deleted when being prepared for use; i.e.

bool	allow_remote_element_removal () const

void	allow_node_and_elem_unique_id_overlap (bool allow)
	If `true` is passed, then this mesh will no longer require unique_ids to be unique across the set of all DofObjects.

bool	allow_node_and_elem_unique_id_overlap () const

void	skip_noncritical_partitioning (bool skip)
	If true is passed in then the elements on this mesh will no longer be (re)partitioned, and the nodes on this mesh will only be repartitioned if they are found "orphaned" via coarsening or other removal of the last element responsible for their node/element processor id consistency.

bool	skip_noncritical_partitioning () const

void	skip_partitioning (bool skip)
	If true is passed in then nothing on this mesh will be (re)partitioned.

bool	skip_partitioning () const

void	add_ghosting_functor (GhostingFunctor &ghosting_functor)
	Adds a functor which can specify ghosting requirements for use on distributed meshes.

void	add_ghosting_functor (std::shared_ptr< GhostingFunctor > ghosting_functor)
	Adds a functor which can specify ghosting requirements for use on distributed meshes.

void	remove_ghosting_functor (GhostingFunctor &ghosting_functor)
	Removes a functor which was previously added to the set of ghosting functors.

GhostingFunctorIterator	ghosting_functors_begin () const
	Beginning of range of ghosting functors.

GhostingFunctorIterator	ghosting_functors_end () const
	End of range of ghosting functors.

GhostingFunctor &	default_ghosting ()
	Default ghosting functor.

void	subdomain_ids (std::set< subdomain_id_type > &ids, const bool global=true) const
	Constructs a list of all subdomain identifiers in the local mesh if `global` == false, and in the global mesh if `global` == true (default).

subdomain_id_type	n_subdomains () const

subdomain_id_type	n_local_subdomains () const

unsigned int	n_partitions () const

std::string	get_info (const unsigned int verbosity=0, const bool global=true) const

void	print_info (std::ostream &os=libMesh::out, const unsigned int verbosity=0, const bool global=true) const
	Prints relevant information about the mesh.

virtual void	read (const std::string &name, void *mesh_data=nullptr, bool skip_renumber_nodes_and_elements=false, bool skip_find_neighbors=false, bool skip_detect_interior_parents=false)=0
	Interfaces for reading/writing a mesh to/from a file.

virtual void	write (const std::string &name) const =0

virtual void	all_first_order ()=0
	Converts a mesh with higher-order elements into a mesh with linear elements.

virtual void	all_second_order_range (const SimpleRange< element_iterator > &range, const bool full_ordered=true)=0
	Converts a set of this Mesh's elements defined by `range` from FIRST order to SECOND order.

void	all_second_order (const bool full_ordered=true)
	Calls the range-based version of this function with a range consisting of all elements in the mesh.

virtual void	all_complete_order_range (const SimpleRange< element_iterator > &range)=0
	Converts a set of elements in this (conforming, non-refined) mesh into "complete" order elements, i.e.

virtual void	all_complete_order ()
	Calls the range-based version of this function with a range consisting of all elements in the mesh.

unsigned int	recalculate_n_partitions ()
	In a few (very rare) cases, the user may have manually tagged the elements with specific processor IDs by hand, without using a partitioner.

std::unique_ptr< PointLocatorBase >	sub_point_locator () const

void	set_point_locator_close_to_point_tol (Real val)
	Set value used by PointLocatorBase::close_to_point_tol().

Real	get_point_locator_close_to_point_tol () const

void	clear_point_locator ()
	Releases the current `PointLocator` object.

void	set_count_lower_dim_elems_in_point_locator (bool count_lower_dim_elems)
	In the point locator, do we count lower dimensional elements when we refine point locator regions? This is relevant in tree-based point locators, for example.

bool	get_count_lower_dim_elems_in_point_locator () const
	Get the current value of _count_lower_dim_elems_in_point_locator.

virtual void	libmesh_assert_valid_parallel_ids () const
	Verify id and processor_id consistency of our elements and nodes containers.

std::string &	subdomain_name (subdomain_id_type id)

const std::string &	subdomain_name (subdomain_id_type id) const

void	set_subdomain_name (subdomain_id_type id, const std::string &name, bool synchronous=false)
	Sets the `name` for the provided `id`.

subdomain_id_type	get_id_by_name (std::string_view name) const

	ABSTRACT_ELEM_ITERATORS (,) ABSTRACT_ELEM_ITERATORS(active_

	ABSTRACT_ELEM_ITERATORS (ancestor_,) ABSTRACT_ELEM_ITERATORS(subactive_

	ABSTRACT_ELEM_ITERATORS (local_,) ABSTRACT_ELEM_ITERATORS(unpartitioned_

	ABSTRACT_ELEM_ITERATORS (facelocal_,) ABSTRACT_ELEM_ITERATORS(level_

unsigned int level	ABSTRACT_ELEM_ITERATORS (pid_, processor_id_type pid) ABSTRACT_ELEM_ITERATORS(type_

unsigned int level ElemType type	ABSTRACT_ELEM_ITERATORS (active_subdomain_, subdomain_id_type sid) ABSTRACT_ELEM_ITERATORS(active_subdomain_set_

unsigned int level ElemType type std::set< subdomain_id_type > ss	ABSTRACT_ELEM_ITERATORS (not_active_,) ABSTRACT_ELEM_ITERATORS(not_ancestor_

unsigned int level ElemType type std::set< subdomain_id_type > ss	ABSTRACT_ELEM_ITERATORS (not_subactive_,) ABSTRACT_ELEM_ITERATORS(not_local_

unsigned int level ElemType type std::set< subdomain_id_type > ss	ABSTRACT_ELEM_ITERATORS (not_level_, unsigned int level) ABSTRACT_ELEM_ITERATORS(active_local_

unsigned int level ElemType type std::set< subdomain_id_type > ss	ABSTRACT_ELEM_ITERATORS (active_not_local_,) ABSTRACT_ELEM_ITERATORS(active_unpartitioned_

unsigned int level ElemType type std::set< subdomain_id_type > ss	ABSTRACT_ELEM_ITERATORS (active_type_, ElemType type) ABSTRACT_ELEM_ITERATORS(active_pid_

unsigned int level ElemType type std::set< subdomain_id_type > ss processor_id_type pid	ABSTRACT_ELEM_ITERATORS (local_level_, unsigned int level) ABSTRACT_ELEM_ITERATORS(local_not_level_

unsigned int level ElemType type std::set< subdomain_id_type > ss processor_id_type pid unsigned int level	ABSTRACT_ELEM_ITERATORS (active_local_subdomain_, subdomain_id_type sid) ABSTRACT_ELEM_ITERATORS(active_local_subdomain_set_

unsigned int level ElemType type std::set< subdomain_id_type > ss processor_id_type pid unsigned int level std::set< subdomain_id_type > virtual ss SimpleRange< element_iterator >	active_subdomain_elements_ptr_range (subdomain_id_type sid)=0

virtual SimpleRange< const_element_iterator >	active_subdomain_elements_ptr_range (subdomain_id_type sid) const =0

virtual SimpleRange< element_iterator >	active_local_subdomain_elements_ptr_range (subdomain_id_type sid)=0

virtual SimpleRange< const_element_iterator >	active_local_subdomain_elements_ptr_range (subdomain_id_type sid) const =0

virtual SimpleRange< element_iterator >	active_subdomain_set_elements_ptr_range (std::set< subdomain_id_type > ss)=0

virtual SimpleRange< const_element_iterator >	active_subdomain_set_elements_ptr_range (std::set< subdomain_id_type > ss) const =0

	ABSTRACT_ELEM_ITERATORS (semilocal_,) ABSTRACT_ELEM_ITERATORS(ghost_

	ABSTRACT_ELEM_ITERATORS (active_semilocal_,) ABSTRACT_ELEM_ITERATORS(evaluable_

const ElemRange &	element_stored_range ()

const ConstElemRange &	active_local_element_stored_range () const

void	clear_stored_ranges ()
	Clears stored ranges, to indicate that the mesh has changed and they should be regenerated when next needed.

std::map< subdomain_id_type, std::string > &	set_subdomain_name_map ()

const std::map< subdomain_id_type, std::string > &	get_subdomain_name_map () const

constraint_rows_type &	get_constraint_rows ()
	Constraint rows accessors.

const constraint_rows_type &	get_constraint_rows () const

dof_id_type	n_constraint_rows () const

void	copy_constraint_rows (const MeshBase &other_mesh)
	Copy the constraints from the other mesh to this mesh.

template<typename T >
void	copy_constraint_rows (const SparseMatrix< T > &constraint_operator, bool precondition_constraint_operator=false)
	Copy the constraints from the given matrix to this mesh.

void	print_constraint_rows (std::ostream &os=libMesh::out, bool print_nonlocal=false) const
	Prints (from processor 0) all mesh constraint rows.

std::string	get_local_constraints (bool print_nonlocal=false) const
	Gets a string reporting all mesh constraint rows local to this processor.

void	cache_elem_dims ()

void	cache_elem_data ()

void	sync_subdomain_name_map ()
	libMesh often expects all processors to know about names of all subdomain ids, but distributed mesh generators may only know about part of a mesh when creating names.

void	detect_interior_parents ()
	Search the mesh for elements that have a neighboring element of dim+1 and set that element as the interior parent.

const MeshBase &	interior_mesh () const

MeshBase &	interior_mesh ()

void	set_interior_mesh (MeshBase &int_mesh)
	Sets the interior mesh.

const std::set< subdomain_id_type > &	get_mesh_subdomains () const

void	add_disjoint_neighbor_boundary_pairs (const boundary_id_type b1, const boundary_id_type b2, const RealVectorValue &translation)
	Register a pair of boundaries as disjoint neighbor boundary pairs.

PeriodicBoundaries *	get_disjoint_neighbor_boundary_pairs ()

const PeriodicBoundaries *	get_disjoint_neighbor_boundary_pairs () const

void	remove_disjoint_boundary_pair (const boundary_id_type b1, const boundary_id_type b2)

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Public Attributes
const DofMap &dof_map LIBMESH_COMMA unsigned int	var_num

const DofMap &dof_map LIBMESH_COMMA unsigned int Elem *	ElemRange

Protected Types
typedef variant_filter_iterator< MeshBase::Predicate, Elem * >	elem_filter_iter
	The original iterator classes weren't properly const-safe; relying on their const-incorrectness is now deprecated.

typedef variant_filter_iterator< MeshBase::Predicate, Elem const, Elem const &, Elem const >	const_elem_filter_iter

typedef variant_filter_iterator< MeshBase::Predicate, Node * >	node_filter_iter

typedef variant_filter_iterator< MeshBase::Predicate, Node const, Node const &, Node const >	const_node_filter_iter

typedef variant_filter_iterator< MeshBase::Predicate, Elem const, Elem const &, Elem const , const Elem const, const Elem const &, const Elem const >	elem_filter_iter

typedef variant_filter_iterator< MeshBase::Predicate, const Elem const, const Elem const &, const Elem const >	const_elem_filter_iter

typedef variant_filter_iterator< MeshBase::Predicate, Node const, Node const &, Node const , const Node const, const Node const &, const Node const >	node_filter_iter

typedef variant_filter_iterator< MeshBase::Predicate, const Node const, const Node const &, const Node const >	const_node_filter_iter

Protected Member Functions
void	post_dofobject_moves (MeshBase &&other_mesh)
	Moves any superclass data (e.g.

void	copy_cached_data (const MeshBase &other_mesh)
	Helper class to copy cached data, to synchronize with a possibly unprepared `other_mesh`.

virtual bool	subclass_locally_equals (const MeshBase &other_mesh) const =0
	Shim to allow operator == (&) to behave like a virtual function without having to be one.

bool	nodes_and_elements_equal (const MeshBase &other_mesh) const
	Tests for equality of all elements and nodes in the mesh.

unsigned int &	set_n_partitions ()

void	size_elem_extra_integers ()
	Size extra-integer arrays of all elements in the mesh.

void	size_node_extra_integers ()
	Size extra-integer arrays of all nodes in the mesh.

std::pair< std::vector< unsigned int >, std::vector< unsigned int > >	merge_extra_integer_names (const MeshBase &other)
	Merge extra-integer arrays from an `other` mesh.

Protected Attributes
std::unique_ptr< PeriodicBoundaries >	_disjoint_neighbor_boundary_pairs
	The disjoint neighbor boundary id pairs.

std::unique_ptr< BoundaryInfo >	boundary_info
	This class holds the boundary information.

unsigned int	_n_parts
	The number of partitions the mesh has.

ElemMappingType	_default_mapping_type
	The default mapping type (typically Lagrange) between master and physical space to assign to newly added elements.

unsigned char	_default_mapping_data
	The default mapping data (unused with Lagrange, used for nodal weight lookup index with rational bases) to assign to newly added elements.

Preparation	_preparation
	Flags indicating in what ways `this` mesh has been prepared.

std::unique_ptr< ElemRange >	_element_stored_range
	A cached `ElemRange` for threaded mutation of all semilocal elements of this mesh.

std::unique_ptr< ConstElemRange >	_const_active_local_element_stored_range
	A cached `ConstElemRange` for threaded calculation on all local elements of this mesh.

std::unique_ptr< PointLocatorBase >	_point_locator
	A `PointLocator` class for this mesh.

bool	_count_lower_dim_elems_in_point_locator
	Do we count lower dimensional elements in point locator refinement? This is relevant in tree-based point locators, for example.

std::unique_ptr< Partitioner >	_partitioner
	A partitioner to use at each prepare_for_use().

unique_id_type	_next_unique_id
	The next available unique id for assigning ids to DOF objects.

MeshBase *	_interior_mesh
	Defaulting to `this`, a pointer to the mesh used to generate boundary elements on `this`.

bool	_skip_noncritical_partitioning
	If this is true then no partitioning should be done with the possible exception of orphaned nodes.

bool	_skip_all_partitioning
	If this is true then no partitioning should be done.

bool	_skip_renumber_nodes_and_elements
	If this is true then renumbering will be kept to a minimum.

bool	_skip_find_neighbors
	If this is `true` then we will skip `find_neighbors` in `prepare_for_use`.

bool	_skip_detect_interior_parents
	If this is `true` then we will skip `detect_interior_parents` in `prepare_for_use`.

bool	_allow_remote_element_removal
	If this is false then even on DistributedMesh remote elements will not be deleted during mesh preparation.

bool	_allow_node_and_elem_unique_id_overlap
	The Exodus reader (and potentially other readers in the future?) now supports setting Node and Elem unique_ids based on values from within the Exodus file itself, rather than generating them automatically in LibMesh.

std::map< subdomain_id_type, std::string >	_block_id_to_name
	This structure maintains the mapping of named blocks for file formats that support named blocks.

std::set< unsigned char >	_elem_dims
	We cache the dimension of the elements present in the mesh.

std::set< Order >	_elem_default_orders
	We cache the (default) order of the geometric elements present in the mesh.

Order	_supported_nodal_order
	We cache the maximum nodal order supported by all the mesh's elements (the minimum supported_nodal_order() of any element)

std::set< subdomain_id_type >	_mesh_subdomains
	We cache the subdomain ids of the elements present in the mesh.

std::map< dof_id_type, const MeshBase::elemset_type * >	_elemset_codes
	Map from "element set code" to list of set ids to which that element belongs (and vice-versa).

std::map< MeshBase::elemset_type, dof_id_type >	_elemset_codes_inverse_map

MeshBase::elemset_type	_all_elemset_ids

unsigned char	_spatial_dimension
	The "spatial dimension" of the Mesh.

std::vector< std::string >	_elem_integer_names
	The array of names for integer data associated with each element in the mesh.

std::vector< dof_id_type >	_elem_integer_default_values
	The array of default initialization values for integer data associated with each element in the mesh.

std::vector< std::string >	_node_integer_names
	The array of names for integer data associated with each node in the mesh.

std::vector< dof_id_type >	_node_integer_default_values
	The array of default initialization values for integer data associated with each node in the mesh.

std::unique_ptr< GhostingFunctor >	_default_ghosting
	The default geometric GhostingFunctor, used to implement standard libMesh element ghosting behavior.

std::vector< GhostingFunctor * >	_ghosting_functors
	The list of all GhostingFunctor objects to be used when distributing a DistributedMesh.

std::map< GhostingFunctor *, std::shared_ptr< GhostingFunctor > >	_shared_functors
	Hang on to references to any GhostingFunctor objects we were passed in shared_ptr form.

constraint_rows_type	_constraint_rows

Real	_point_locator_close_to_point_tol
	If nonzero, we will call PointLocatorBase::set_close_to_point_tol() on any PointLocators that we create.

const Parallel::Communicator &	_communicator

Friends
class	Partitioner
	The partitioner class is a friend so that it can set the number of partitions.

class	MeshInput< MeshBase >
	The MeshInput classes are friends so that they can set the number of partitions.

class	BoundaryInfo
	Make the `BoundaryInfo` class a friend so that it can create and interact with `BoundaryMesh`.

class	MeshCommunication
	Make the `MeshCommunication` class a friend so that it can directly broadcast *_integer_names.

std::ostream &	operator<< (std::ostream &os, const MeshBase &m)
	Equivalent to calling print_info() above, but now you can write: Mesh mesh; libMesh::out << mesh << std::endl;.

Detailed Description

This is the MeshBase class.

This class provides all the data necessary to describe a geometric entity. It allows for the description of a dim dimensional object that lives in LIBMESH_DIM-dimensional space.

: A mesh is made of nodes and elements, and this class provides data structures to store and access both. A mesh may be partitioned into a number of subdomains, and this class provides that functionality. Furthermore, this class provides functions for reading and writing a mesh to disk in various formats.

Author: Benjamin S. Kirk

Date: 2002

Base class for Mesh.

Definition at line 80 of file mesh_base.h.

Member Typedef Documentation

◆ const_elem_filter_iter [1/2]

typedef variant_filter_iterator<MeshBase::Predicate, Elem * const, Elem * const &, Elem * const *> libMesh::MeshBase::const_elem_filter_iter

protected

Definition at line 2485 of file mesh_base.h.

◆ const_elem_filter_iter [2/2]

typedef variant_filter_iterator<MeshBase::Predicate, const Elem * const, const Elem * const &, const Elem * const *> libMesh::MeshBase::const_elem_filter_iter

protected

Definition at line 2505 of file mesh_base.h.

◆ const_node_filter_iter [1/2]

typedef variant_filter_iterator<MeshBase::Predicate, Node * const, Node * const &, Node * const *> libMesh::MeshBase::const_node_filter_iter

protected

Definition at line 2492 of file mesh_base.h.

◆ const_node_filter_iter [2/2]

typedef variant_filter_iterator<MeshBase::Predicate, const Node * const, const Node * const &, const Node * const *> libMesh::MeshBase::const_node_filter_iter

protected

Definition at line 2518 of file mesh_base.h.

◆ ConstElemRange

typedef StoredRange<MeshBase::const_element_iterator, const Elem *> libMesh::MeshBase::ConstElemRange

Definition at line 1895 of file mesh_base.h.

◆ constraint_rows_mapped_type

typedef std::vector<std::pair<std::pair<const Elem *, unsigned int>, Real> > libMesh::MeshBase::constraint_rows_mapped_type

Definition at line 1929 of file mesh_base.h.

◆ constraint_rows_type

typedef std::map<const Node *, constraint_rows_mapped_type> libMesh::MeshBase::constraint_rows_type

Definition at line 1930 of file mesh_base.h.

◆ elem_filter_iter [1/2]

typedef variant_filter_iterator<MeshBase::Predicate, Elem *> libMesh::MeshBase::elem_filter_iter

protected

The original iterator classes weren't properly const-safe; relying on their const-incorrectness is now deprecated.

Definition at line 2480 of file mesh_base.h.

◆ elem_filter_iter [2/2]

typedef variant_filter_iterator<MeshBase::Predicate, Elem * const, Elem * const &, Elem * const *, const Elem * const, const Elem * const &, const Elem * const *> libMesh::MeshBase::elem_filter_iter

protected

Definition at line 2500 of file mesh_base.h.

◆ elemset_type

typedef std::set<elemset_id_type> libMesh::MeshBase::elemset_type

Typedef for the "set" container used to store elemset ids.

The main requirements are that the entries be sorted and unique, so std::set works for this, but there may be more efficient alternatives.

Definition at line 466 of file mesh_base.h.

◆ GhostingFunctorIterator

typedef std::vector<GhostingFunctor*>::const_iterator libMesh::MeshBase::GhostingFunctorIterator

Iterator type for ghosting functor ranges.

This has changed in the past and may change again; code should use auto or the type here.

Definition at line 1467 of file mesh_base.h.

◆ node_filter_iter [1/2]

typedef variant_filter_iterator<MeshBase::Predicate, Node *> libMesh::MeshBase::node_filter_iter

protected

Definition at line 2487 of file mesh_base.h.

◆ node_filter_iter [2/2]

typedef variant_filter_iterator<MeshBase::Predicate, Node * const, Node * const &, Node * const *, const Node * const, const Node * const &, const Node * const *> libMesh::MeshBase::node_filter_iter

protected

Definition at line 2513 of file mesh_base.h.

◆ Predicate

typedef Predicates::multi_predicate libMesh::MeshBase::Predicate

We need an empty, generic class to act as a predicate for this and derived mesh classes.

Definition at line 1585 of file mesh_base.h.

Constructor & Destructor Documentation

◆ MeshBase() [1/3]

libMesh::MeshBase::MeshBase	(	const Parallel::Communicator &	comm_in,
		unsigned char	dim = `1`
	)

Constructor.

Takes dim, the dimension of the mesh. The mesh dimension can be changed (and may automatically be changed by mesh generation/loading) later.

Definition at line 64 of file mesh_base.C.

                                     :
  ParallelObject (comm_in),
  boundary_info  (new BoundaryInfo(*this)), // BoundaryInfo has protected ctor, can't use std::make_unique
  _n_parts       (1),
  _default_mapping_type(LAGRANGE_MAP),
  _default_mapping_data(0),
  _preparation (),
  _element_stored_range (),
  _const_active_local_element_stored_range (),
  _point_locator (),
  _count_lower_dim_elems_in_point_locator(true),
  _partitioner   (),
#ifdef LIBMESH_ENABLE_UNIQUE_ID
  _next_unique_id(DofObject::invalid_unique_id),
#endif
  _interior_mesh(this),
  _skip_noncritical_partitioning(false),
  _skip_all_partitioning(libMesh::on_command_line("--skip-partitioning")),
  _skip_renumber_nodes_and_elements(false),
  _skip_find_neighbors(false),
  _skip_detect_interior_parents(false),
  _allow_remote_element_removal(true),
  _allow_node_and_elem_unique_id_overlap(false),
  _spatial_dimension(d),
  _default_ghosting(std::make_unique<GhostPointNeighbors>(*this)),
  _point_locator_close_to_point_tol(0.)
{
  _elem_dims.insert(d);
  _ghosting_functors.push_back(_default_ghosting.get());
  libmesh_assert_less_equal (LIBMESH_DIM, 3);
  libmesh_assert_greater_equal (LIBMESH_DIM, d);
  libmesh_assert (libMesh::initialized());
}

References _default_ghosting, _elem_dims, _ghosting_functors, libMesh::initialized(), and libMesh::libmesh_assert().

◆ MeshBase() [2/3]

libMesh::MeshBase::MeshBase ( const MeshBase & other_mesh )

Copy-constructor.

Definition at line 101 of file mesh_base.C.

                                               :
  ParallelObject (other_mesh),
  boundary_info  (new BoundaryInfo(*this)), // BoundaryInfo has protected ctor, can't use std::make_unique
  _n_parts       (other_mesh._n_parts),
  _default_mapping_type(other_mesh._default_mapping_type),
  _default_mapping_data(other_mesh._default_mapping_data),
  _preparation (other_mesh._preparation),
  _element_stored_range (),
  _const_active_local_element_stored_range (),
  _point_locator (),
  _count_lower_dim_elems_in_point_locator(other_mesh._count_lower_dim_elems_in_point_locator),
  _partitioner   (),
#ifdef LIBMESH_ENABLE_UNIQUE_ID
  _next_unique_id(other_mesh._next_unique_id),
#endif
  // If the other mesh interior_parent pointers just go back to
  // itself, so should we
  _interior_mesh((other_mesh._interior_mesh == &other_mesh) ?
                 this : other_mesh._interior_mesh),
  _skip_noncritical_partitioning(other_mesh._skip_noncritical_partitioning),
  _skip_all_partitioning(other_mesh._skip_all_partitioning),
  _skip_renumber_nodes_and_elements(other_mesh._skip_renumber_nodes_and_elements),
  _skip_find_neighbors(other_mesh._skip_find_neighbors),
  _skip_detect_interior_parents(other_mesh._skip_detect_interior_parents),
  _allow_remote_element_removal(other_mesh._allow_remote_element_removal),
  _allow_node_and_elem_unique_id_overlap(other_mesh._allow_node_and_elem_unique_id_overlap),
  _elem_dims(other_mesh._elem_dims),
  _elem_default_orders(other_mesh._elem_default_orders),
  _supported_nodal_order(other_mesh._supported_nodal_order),
  _mesh_subdomains(other_mesh._mesh_subdomains),
  _elemset_codes_inverse_map(other_mesh._elemset_codes_inverse_map),
  _all_elemset_ids(other_mesh._all_elemset_ids),
  _spatial_dimension(other_mesh._spatial_dimension),
  _default_ghosting(std::make_unique<GhostPointNeighbors>(*this)),
  _point_locator_close_to_point_tol(other_mesh._point_locator_close_to_point_tol)
{
  const GhostingFunctor * const other_default_ghosting = other_mesh._default_ghosting.get();
 
  for (GhostingFunctor * const gf : other_mesh._ghosting_functors)
    {
      // If the other mesh is using default ghosting, then we will use our own
      // default ghosting
      if (gf == other_default_ghosting)
        {
          _ghosting_functors.push_back(_default_ghosting.get());
          continue;
        }
 
      std::shared_ptr<GhostingFunctor> clone_gf = gf->clone();
      // Some subclasses of GhostingFunctor might not override the
      // clone function yet. If this is the case, GhostingFunctor will
      // return nullptr by default. The clone function should be overridden
      // in all derived classes. This following code ("else") is written
      // for API upgrade. That will allow users gradually to update their code.
      // Once the API upgrade is done, we will come back and delete "else."
      if (clone_gf)
        {
          clone_gf->set_mesh(this);
          add_ghosting_functor(clone_gf);
        }
      else
        {
          libmesh_deprecated();
          add_ghosting_functor(*gf);
        }
    }
 
  if (other_mesh._partitioner.get())
    _partitioner = other_mesh._partitioner->clone();
 
#ifdef LIBMESH_ENABLE_PERIODIC
  // Deep copy of all periodic boundaries
  if (other_mesh._disjoint_neighbor_boundary_pairs)
    {
      _disjoint_neighbor_boundary_pairs = std::make_unique<PeriodicBoundaries>();
 
      for (const auto & [id, pb] : *other_mesh._disjoint_neighbor_boundary_pairs)
        if (pb)
          (*_disjoint_neighbor_boundary_pairs)[id] = pb->clone();
    }
#endif
 
  // _elemset_codes stores pointers to entries in _elemset_codes_inverse_map,
  // so it is not possible to simply copy it directly from other_mesh
  for (const auto & [set, code] : _elemset_codes_inverse_map)
    _elemset_codes.emplace(code, &set);
}

References _default_ghosting, _disjoint_neighbor_boundary_pairs, _elemset_codes, _elemset_codes_inverse_map, _ghosting_functors, _partitioner, and add_ghosting_functor().

◆ MeshBase() [3/3]

libMesh::MeshBase::MeshBase ( MeshBase && )

delete

Move-constructor - deleted because after a theoretical move-construction and then destruction of the moved-from object, the moved BoundaryInfo would hold an invalid reference to the moved-from mesh.

◆ ~MeshBase()

libMesh::MeshBase::~MeshBase ( )

virtual

Destructor.

Definition at line 421 of file mesh_base.C.

{
  this->MeshBase::clear();
 
  libmesh_exceptionless_assert (!libMesh::closed());
}

References clear(), and libMesh::closed().

Member Function Documentation

◆ ABSTRACT_ELEM_ITERATORS() [1/15]

libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS ( )

◆ ABSTRACT_ELEM_ITERATORS() [2/15]

unsigned int level ElemType type std::set< subdomain_id_type > ss processor_id_type pid unsigned int level libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS	(	active_local_subdomain_	,
		subdomain_id_type	sid
	)

◆ ABSTRACT_ELEM_ITERATORS() [3/15]

unsigned int level ElemType type std::set< subdomain_id_type > ss libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS ( active_not_local_ )

◆ ABSTRACT_ELEM_ITERATORS() [4/15]

libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS ( active_semilocal_ )

◆ ABSTRACT_ELEM_ITERATORS() [5/15]

unsigned int level ElemType type libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS	(	active_subdomain_	,
		subdomain_id_type	sid
	)

◆ ABSTRACT_ELEM_ITERATORS() [6/15]

unsigned int level ElemType type std::set< subdomain_id_type > ss libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS	(	active_type_	,
		ElemType	type
	)

◆ ABSTRACT_ELEM_ITERATORS() [7/15]

libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS ( ancestor_ )

◆ ABSTRACT_ELEM_ITERATORS() [8/15]

libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS ( facelocal_ )

◆ ABSTRACT_ELEM_ITERATORS() [9/15]

libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS ( local_ )

◆ ABSTRACT_ELEM_ITERATORS() [10/15]

unsigned int level ElemType type std::set< subdomain_id_type > ss processor_id_type pid libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS	(	local_level_	,
		unsigned int	level
	)

◆ ABSTRACT_ELEM_ITERATORS() [11/15]

unsigned int level ElemType type std::set< subdomain_id_type > ss libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS ( not_active_ )

◆ ABSTRACT_ELEM_ITERATORS() [12/15]

unsigned int level ElemType type std::set< subdomain_id_type > ss libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS	(	not_level_	,
		unsigned int	level
	)

◆ ABSTRACT_ELEM_ITERATORS() [13/15]

unsigned int level ElemType type std::set< subdomain_id_type > ss libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS ( not_subactive_ )

◆ ABSTRACT_ELEM_ITERATORS() [14/15]

unsigned int level libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS	(	pid_	,
		processor_id_type	pid
	)

◆ ABSTRACT_ELEM_ITERATORS() [15/15]

libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS ( semilocal_ )

◆ active_local_element_stored_range()

const ConstElemRange & libMesh::MeshBase::active_local_element_stored_range ( ) const

Returns: A reference to a cached vector copy of a range of pointers to all active local elements, suitable for threading.

Iterating over only local elements is most useful for computing on the mesh, so we only have a non-const version for now.

Definition at line 1954 of file mesh_base.C.

{
  if (!_const_active_local_element_stored_range)
  {
    // Range construction may not be safe within threads
    libmesh_assert(!Threads::in_threads);
 
    _const_active_local_element_stored_range =
      std::make_unique<ConstElemRange>(this->active_local_elements_begin(),
                                  this->active_local_elements_end());
  }
 
  return *_const_active_local_element_stored_range;
}

References _const_active_local_element_stored_range, libMesh::Threads::in_threads, and libMesh::libmesh_assert().

Referenced by libMesh::FEMSystem::assemble_qoi(), libMesh::FEMSystem::assemble_qoi_derivative(), libMesh::FEMSystem::assembly(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::MeshTetInterface::check_hull_integrity(), libMesh::MeshRefinement::create_parent_error_vector(), libMesh::MeshTools::n_active_local_levels(), libMesh::FEMSystem::postprocess(), and subdomain_ids().

◆ active_local_subdomain_elements_ptr_range() [1/2]

virtual SimpleRange< const_element_iterator > libMesh::MeshBase::active_local_subdomain_elements_ptr_range ( subdomain_id_type sid ) const

pure virtual

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

◆ active_local_subdomain_elements_ptr_range() [2/2]

virtual SimpleRange< element_iterator > libMesh::MeshBase::active_local_subdomain_elements_ptr_range ( subdomain_id_type sid )

pure virtual

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by assemble_SchroedingerEquation().

◆ active_subdomain_elements_ptr_range() [1/2]

virtual SimpleRange< const_element_iterator > libMesh::MeshBase::active_subdomain_elements_ptr_range ( subdomain_id_type sid ) const

pure virtual

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

◆ active_subdomain_elements_ptr_range() [2/2]

unsigned int level ElemType type std::set< subdomain_id_type > ss processor_id_type pid unsigned int level std::set< subdomain_id_type > virtual ss SimpleRange< element_iterator > libMesh::MeshBase::active_subdomain_elements_ptr_range ( subdomain_id_type sid )

pure virtual

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by AllSecondOrderTest::allCompleteOrderRange(), AllSecondOrderTest::allSecondOrderRange(), and OverlappingTestPartitioner::assign_proc_id_subdomain().

◆ active_subdomain_set_elements_ptr_range() [1/2]

virtual SimpleRange< const_element_iterator > libMesh::MeshBase::active_subdomain_set_elements_ptr_range ( std::set< subdomain_id_type > ss ) const

pure virtual

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

◆ active_subdomain_set_elements_ptr_range() [2/2]

virtual SimpleRange< element_iterator > libMesh::MeshBase::active_subdomain_set_elements_ptr_range ( std::set< subdomain_id_type > ss )

pure virtual

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

◆ add_disjoint_neighbor_boundary_pairs()

void libMesh::MeshBase::add_disjoint_neighbor_boundary_pairs	(	const boundary_id_type	b1,
		const boundary_id_type	b2,
		const RealVectorValue &	translation
	)

Register a pair of boundaries as disjoint neighbor boundary pairs.

Definition at line 2272 of file mesh_base.C.

    {
      // Lazily allocate the container the first time it’s needed
      if (!_disjoint_neighbor_boundary_pairs)
        _disjoint_neighbor_boundary_pairs = std::make_unique<PeriodicBoundaries>();
 
      PeriodicBoundaries & db = *_disjoint_neighbor_boundary_pairs;
 
      // Create forward and inverse boundary mappings
      PeriodicBoundary forward(translation);
      PeriodicBoundary inverse(translation * -1.0);
 
      forward.myboundary       = b1;
      forward.pairedboundary   = b2;
      inverse.myboundary       = b2;
      inverse.pairedboundary   = b1;
 
      // Add both directions into the container
      db.emplace(b1, forward.clone());
      db.emplace(b2, inverse.clone());
    }

References _disjoint_neighbor_boundary_pairs, libMesh::PeriodicBoundary::clone(), libMesh::PeriodicBoundaryBase::myboundary, and libMesh::PeriodicBoundaryBase::pairedboundary.

Referenced by DisjointNeighborTest::build_four_disjoint_elems(), DisjointNeighborTest::build_split_mesh_with_interface(), DisjointNeighborTest::build_two_disjoint_elems(), libMesh::UnstructuredMesh::stitching_helper(), DisjointNeighborTest::testDisjointNeighborConflictError(), and DisjointNeighborTest::testStitchCrossMesh().

◆ add_elem() [1/2]

virtual Elem * libMesh::MeshBase::add_elem ( Elem * e )

pure virtual

Add elem e to the end of the element array.

To add an element locally, set e->processor_id() before adding it. To ensure a specific element id, call e->set_id() before adding it; only do this in parallel if you are manually keeping ids consistent.

Users should call MeshBase::complete_preparation() after elements are added to and/or deleted from the mesh.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by libMesh::GMVIO::_read_one_cell(), libMesh::MeshTools::Subdivision::add_boundary_ghosts(), LinearElasticityWithContact::add_contact_edge_elements(), add_cube_convex_hull_to_mesh(), libMesh::MeshRefinement::add_elem(), libMesh::MeshRefinement::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::MeshTools::Modification::all_tri(), AllSecondOrderTest::allCompleteOrderMixed(), AllSecondOrderTest::allCompleteOrderRange(), AllSecondOrderTest::allSecondOrderMixed(), AllSecondOrderTest::allSecondOrderRange(), ExodusC0PolyhedronTest::build_c0polyhedron(), libMesh::MeshTools::Generation::build_cube(), libMesh::MeshTools::Generation::build_extrusion(), DisjointNeighborTest::build_four_disjoint_elems(), libMesh::InfElemBuilder::build_inf_elem(), ExodusC0PolygonTest::build_pentagon(), DisjointNeighborTest::build_split_mesh_with_interface(), DisjointNeighborTest::build_two_disjoint_elems(), VolumeTest::buildC0Polyhedron(), copy_constraint_rows(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::TriangleWrapper::copy_tri_to_mesh(), libMesh::UnstructuredMesh::create_submesh(), libMesh::TetGenIO::element_in(), libMesh::UNVIO::elements_in(), libMesh::MeshTools::Modification::flatten(), libMesh::Poly2TriTriangulator::insert_refinement_points(), libMesh::TetGenMeshInterface::pointset_convexhull(), libMesh::VTKIO::read(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::AbaqusIO::read_elements(), libMesh::UCDIO::read_implementation(), libMesh::DynaIO::read_mesh(), libMesh::GmshIO::read_mesh(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::MatlabIO::read_stream(), libMesh::OFFIO::read_stream(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::MeshTools::Generation::surface_octahedron(), AllTriTest::test_helper_c0polyhedron(), AllTriTest::testAllTriC0PolygonOctagon(), VolumeTest::testC0Polygon(), CheckpointIOTest::testC0PolygonCheckpoint(), CheckpointIOTest::testC0PolyhedronCheckpoint(), SystemsTest::testDofCouplingWithVarGroups(), MeshTriangulationTest::testEdge3Mesh(), MeshTriangulationTest::testEdgesMesh(), MeshTriangulationTest::testHalfDomain(), NodalNeighborsTest::testOrientation(), MeshTriangulationTest::testPoly2TriBad1DMultiBoundary(), MeshTriangulationTest::testPoly2TriBad2DMultiBoundary(), MeshTriangulationTest::testPoly2TriBadEdges(), MeshTriangulationTest::testPoly2TriEdge3ToTri6FlipThrows(), EquationSystemsTest::testPostInitAddElem(), SystemsTest::testProjectMatrix3D(), InfFERadialTest::testRefinement(), EquationSystemsTest::testReinitWithNodeElem(), SystemsTest::testSetSystemParameterOverEquationSystem(), BoundaryInfoTest::testShellFaceConstraints(), MeshTetTest::testTetsToTets(), MeshSubdomainIDTest::testUnpartitioned(), libMesh::NetGenMeshInterface::triangulate(), libMesh::TetGenMeshInterface::triangulate_conformingDelaunayMesh_carvehole(), libMesh::Poly2TriTriangulator::triangulate_current_points(), libMesh::TetGenMeshInterface::triangulate_pointset(), libMesh::Parallel::Packing< Elem * >::unpack(), and libMesh::MeshTetInterface::volume_to_surface_mesh().

◆ add_elem() [2/2]

virtual Elem * libMesh::MeshBase::add_elem ( std::unique_ptr< Elem > e )

pure virtual

Version of add_elem() taking a std::unique_ptr by value.

The version taking a dumb pointer will eventually be deprecated in favor of this version. This API is intended to indicate that ownership of the Elem is transferred to the Mesh when this function is called, and it should play more nicely with the Elem::build() API which has always returned a std::unique_ptr.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

◆ add_elem_data()

template<typename T >

std::vector< unsigned int > libMesh::MeshBase::add_elem_data	(	const std::vector< std::string > &	names,
		bool	allocate_data = `true`,
		const std::vector< T > *	default_values = `nullptr`
	)

inline

Register data (of type T) to be added to each element in the mesh.

If the mesh already has elements, data is allocated in each.

Newly allocated values for the new datum with name names[i] will be initialized to default_values[i], or to meaningless memcpy output if default_values is null.

Returns: The starting index number for the new data, or for the existing data if one by the same name has already been added.

If type T is larger than dof_id_type, each datum will end up spanning multiple index values, but will be queried with the starting index number.

No type checking is done with this function! If you add data of type T, don't try to access it with a call specifying type U.

Definition at line 2654 of file mesh_base.h.

{
  libmesh_assert(!default_values || default_values->size() == names.size());
 
  std::vector<unsigned int> returnval(names.size());
 
  const std::size_t old_size = _elem_integer_names.size();
 
  for (auto i : index_range(names))
    returnval[i] =
      this->add_elem_datum<T>(names[i], false,
                              default_values ?
                              (*default_values)[i] : nullptr);
 
  if (allocate_data && old_size != _elem_integer_names.size())
    this->size_elem_extra_integers();
 
  return returnval;
}

References _elem_integer_names, libMesh::index_range(), libMesh::libmesh_assert(), and size_elem_extra_integers().

◆ add_elem_datum()

template<typename T >

unsigned int libMesh::MeshBase::add_elem_datum	(	const std::string &	name,
		bool	allocate_data = `true`,
		const T *	default_value = `nullptr`
	)

inline

Register a datum (of type T) to be added to each element in the mesh.

If the mesh already has elements, data by default is allocated in each of them. This may be expensive to do repeatedly; use add_elem_data instead. Alternatively, the allocate_data option can be manually set to false, but if this is done then a manual call to size_elem_extra_integers() will need to be done before the new space is usable.

Newly allocated values for the new datum will be initialized to *default_value if default_value is not null, or to meaningless memcpy output otherwise.

Returns: The index numbers for the new data, and/or for existing data if data by some of the same names has already been added.

If type T is larger than dof_id_type, its data will end up spanning multiple index values, but will be queried with the starting index number.

No type checking is done with this function! If you add data of type T, don't try to access it with a call specifying type U.

Definition at line 2630 of file mesh_base.h.

{
  const std::size_t old_size = _elem_integer_names.size();
 
  unsigned int n_more_integers = (sizeof(T)-1)/sizeof(dof_id_type);
  std::vector<dof_id_type> int_data(n_more_integers+1, DofObject::invalid_id);
  if (default_value)
    std::memcpy(int_data.data(), default_value, sizeof(T));
 
  unsigned int start_idx = this->add_elem_integer(name, false, int_data[0]);
  for (unsigned int i=0; i != n_more_integers; ++i)
    this->add_elem_integer(name+"__"+std::to_string(i), false, int_data[i+1]);
 
  if (allocate_data && old_size != _elem_integer_names.size())
    this->size_elem_extra_integers();
 
  return start_idx;
}

References _elem_integer_names, add_elem_integer(), libMesh::DofObject::invalid_id, and size_elem_extra_integers().

Referenced by ExtraIntegersTest::build_mesh().

◆ add_elem_integer()

unsigned int libMesh::MeshBase::add_elem_integer	(	std::string	name,
		bool	allocate_data = `true`,
		dof_id_type	default_value = `DofObject::invalid_id`
	)

Register an integer datum (of type dof_id_type) to be added to each element in the mesh.

If the mesh already has elements, data by default is allocated in each of them. This may be expensive to do repeatedly; use add_elem_integers instead. Alternatively, the allocate_data option can be manually set to false, but if this is done then a manual call to size_elem_extra_integers() will need to be done before the new space is usable.

Newly allocated values for the new datum will be initialized to default_value

Returns: The index number for the new datum, or for the existing datum if one by the same name has already been added.

Definition at line 623 of file mesh_base.C.

{
  for (auto i : index_range(_elem_integer_names))
    if (_elem_integer_names[i] == name)
      {
        libmesh_assert_less(i, _elem_integer_default_values.size());
        _elem_integer_default_values[i] = default_value;
        return i;
      }
 
  libmesh_assert_equal_to(_elem_integer_names.size(),
                          _elem_integer_default_values.size());
  _elem_integer_names.push_back(std::move(name));
  _elem_integer_default_values.push_back(default_value);
  if (allocate_data)
    this->size_elem_extra_integers();
  return _elem_integer_names.size()-1;
}

References _elem_integer_default_values, _elem_integer_names, libMesh::index_range(), and size_elem_extra_integers().

Referenced by add_elem_datum(), libMesh::BoundaryInfo::add_elements(), ExtraIntegersTest::build_mesh(), ExtraIntegersTest::checkpoint_helper(), libMesh::ExodusII_IO::read(), libMesh::CheckpointIO::read_header(), ExtraIntegersTest::test_helper(), MeshStitchTest::testMeshStitchElemsets(), and WriteElemsetData::testWriteImpl().

◆ add_elem_integers()

std::vector< unsigned int > libMesh::MeshBase::add_elem_integers	(	const std::vector< std::string > &	names,
		bool	allocate_data = `true`,
		const std::vector< dof_id_type > *	default_values = `nullptr`
	)

Register integer data (of type dof_id_type) to be added to each element in the mesh, one string name for each new integer.

If the mesh already has elements, data by default is allocated in each of them.

Newly allocated values for the new datum with name names[i] will be initialized to default_values[i], or to DofObject::invalid_id if default_values is null.

Returns: The index numbers for the new data, and/or for existing data if data by some of the same names has already been added.

Definition at line 646 of file mesh_base.C.

{
  libmesh_assert(!default_values || default_values->size() == names.size());
  libmesh_assert_equal_to(_elem_integer_names.size(), _elem_integer_default_values.size());
 
  std::unordered_map<std::string, std::size_t> name_indices;
  for (auto i : index_range(_elem_integer_names))
    name_indices[_elem_integer_names[i]] = i;
 
  std::vector<unsigned int> returnval(names.size());
 
  bool added_an_integer = false;
  for (auto i : index_range(names))
    {
      const std::string & name = names[i];
      if (const auto it = name_indices.find(name);
          it != name_indices.end())
        {
          returnval[i] = it->second;
          _elem_integer_default_values[it->second] =
            default_values ? (*default_values)[i] : DofObject::invalid_id;
        }
      else
        {
          returnval[i] = _elem_integer_names.size();
          name_indices[name] = returnval[i];
          _elem_integer_names.push_back(name);
          _elem_integer_default_values.push_back
            (default_values ? (*default_values)[i] : DofObject::invalid_id);
          added_an_integer = true;
        }
    }
 
  if (allocate_data && added_an_integer)
    this->size_elem_extra_integers();
 
  return returnval;
}

References _elem_integer_default_values, _elem_integer_names, libMesh::index_range(), libMesh::DofObject::invalid_id, libMesh::libmesh_assert(), and size_elem_extra_integers().

Referenced by merge_extra_integer_names(), and libMesh::XdrIO::read_header().

◆ add_elemset_code()

void libMesh::MeshBase::add_elemset_code	(	dof_id_type	code,
		MeshBase::elemset_type	id_set
	)

Tabulate a user-defined "code" for elements which belong to the element sets specified in id_set.

For example, suppose that we have two elemsets A and B with the following Elem ids: Elemset A = {1, 3} Elemset B = {2, 3}

This implies the following mapping from elem id to elemset id: Elem 1 -> {A} Elem 2 -> {B} Elem 3 -> {A,B}

In this case, we would need to tabulate three different elemset codes, e.g.: 0 -> {A} 1 -> {B} 2 -> {A,B}

Also sets up the inverse mapping, so that if one knows all the element sets an Elem belongs to, one can look up the corresponding elemset code.

Definition at line 456 of file mesh_base.C.

{
  // Populate inverse map, stealing id_set's resources
  auto [it1, inserted1] = _elemset_codes_inverse_map.emplace(std::move(id_set), code);
 
  // Reference to the newly inserted (or previously existing) id_set
  const auto & inserted_id_set = it1->first;
 
  // Keep track of all elemset ids ever added for O(1) n_elemsets()
  // performance. Only need to do this if we didn't know about this
  // id_set before...
  if (inserted1)
    _all_elemset_ids.insert(inserted_id_set.begin(), inserted_id_set.end());
 
  // Take the address of the newly emplaced set to use in
  // _elemset_codes, avoid duplicating std::set storage
  auto [it2, inserted2] = _elemset_codes.emplace(code, &inserted_id_set);
 
  // Throw an error if this code already exists with a pointer to a
  // different set of ids.
  libmesh_error_msg_if(!inserted2 && it2->second != &inserted_id_set,
                       "The elemset code " << code << " already exists with a different id_set.");
}

References _all_elemset_ids, _elemset_codes, and _elemset_codes_inverse_map.

Referenced by change_elemset_code(), libMesh::ExodusII_IO::read(), libMesh::XdrIO::read_header(), libMesh::UnstructuredMesh::stitching_helper(), MeshStitchTest::testMeshStitchElemsets(), and WriteElemsetData::testWriteImpl().

◆ add_ghosting_functor() [1/2]

void libMesh::MeshBase::add_ghosting_functor ( GhostingFunctor & ghosting_functor )

Adds a functor which can specify ghosting requirements for use on distributed meshes.

Multiple ghosting functors can be added; any element which is required by any functor will be ghosted.

GhostingFunctor memory must be managed by the code which calls this function; the GhostingFunctor lifetime is expected to extend until either the functor is removed or the Mesh is destructed.

Definition at line 1078 of file mesh_base.C.

{
  // We used to implicitly support duplicate inserts to std::set
#ifdef LIBMESH_ENABLE_DEPRECATED
  _ghosting_functors.erase
    (std::remove(_ghosting_functors.begin(),
                 _ghosting_functors.end(),
                 &ghosting_functor),
     _ghosting_functors.end());
#endif
 
  // We shouldn't have two copies of the same functor
  libmesh_assert(std::find(_ghosting_functors.begin(),
                           _ghosting_functors.end(),
                           &ghosting_functor) ==
                 _ghosting_functors.end());
 
  _ghosting_functors.push_back(&ghosting_functor);
}

References _ghosting_functors, and libMesh::libmesh_assert().

Referenced by add_ghosting_functor(), main(), MeshBase(), and EquationSystemsTest::testDisableDefaultGhosting().

◆ add_ghosting_functor() [2/2]

void libMesh::MeshBase::add_ghosting_functor ( std::shared_ptr< GhostingFunctor > ghosting_functor )

inline

Adds a functor which can specify ghosting requirements for use on distributed meshes.

Multiple ghosting functors can be added; any element which is required by any functor will be ghosted.

GhostingFunctor memory when using this method is managed by the shared_ptr mechanism.

Definition at line 1452 of file mesh_base.h.

1453 { _shared_functors[ghosting_functor.get()] = ghosting_functor;

1454 this->add_ghosting_functor(*ghosting_functor); }

libMesh::MeshBase::_shared_functors

std::map< GhostingFunctor *, std::shared_ptr< GhostingFunctor > > _shared_functors

Hang on to references to any GhostingFunctor objects we were passed in shared_ptr form.

Definition mesh_base.h:2430

References _shared_functors, and add_ghosting_functor().

◆ add_node() [1/2]

virtual Node * libMesh::MeshBase::add_node ( Node * n )

pure virtual

Add Node n to the end of the vertex array.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by ExodusC0PolyhedronTest::build_c0polyhedron(), libMesh::MeshTools::Generation::build_cube(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::InfElemBuilder::build_inf_elem(), VolumeTest::buildC0Polyhedron(), libMesh::ExodusII_IO::read(), libMesh::XdrIO::read_serialized_connectivity(), AllTriTest::test_helper_c0polyhedron(), CheckpointIOTest::testC0PolyhedronCheckpoint(), and libMesh::Parallel::Packing< Node * >::unpack().

◆ add_node() [2/2]

virtual Node * libMesh::MeshBase::add_node ( std::unique_ptr< Node > n )

pure virtual

Version of add_node() taking a std::unique_ptr by value.

The version taking a dumb pointer will eventually be deprecated in favor of this version. This API is intended to indicate that ownership of the Node is transferred to the Mesh when this function is called, and it should play more nicely with the Node::build() API which has always returned a std::unique_ptr.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

◆ add_node_data()

template<typename T >

std::vector< unsigned int > libMesh::MeshBase::add_node_data	(	const std::vector< std::string > &	name,
		bool	allocate_data = `true`,
		const std::vector< T > *	default_values = `nullptr`
	)

inline

Register data (of type T) to be added to each node in the mesh.

If the mesh already has nodes, data by default is allocated in each.

Newly allocated values for the new datum with name names[i] will be initialized to default_values[i], or to meaningless memcpy output if default_values is null.

Returns: The starting index number for the new data, or for the existing data if one by the same name has already been added.

If type T is larger than dof_id_type, its data will end up spanning multiple index values, but will be queried with the starting index number.

No type checking is done with this function! If you add data of type T, don't try to access it with a call specifying type U.

Definition at line 2703 of file mesh_base.h.

{
  libmesh_assert(!default_values || default_values->size() == names.size());
 
  std::vector<unsigned int> returnval(names.size());
 
  const std::size_t old_size = _node_integer_names.size();
 
  for (auto i : index_range(names))
    returnval[i] =
      this->add_node_datum<T>(names[i], false,
                              default_values ?
                              (*default_values)[i] : nullptr);
 
  if (allocate_data && old_size != _node_integer_names.size())
    this->size_node_extra_integers();
 
  return returnval;
}

References _node_integer_names, libMesh::index_range(), libMesh::libmesh_assert(), and size_node_extra_integers().

◆ add_node_datum()

template<typename T >

unsigned int libMesh::MeshBase::add_node_datum	(	const std::string &	name,
		bool	allocate_data = `true`,
		const T *	default_value = `nullptr`
	)

inline

Register a datum (of type T) to be added to each node in the mesh.

If the mesh already has nodes, data by default is allocated in each of them. This may be expensive to do repeatedly; use add_node_data instead. Alternatively, the allocate_data option can be manually set to false, but if this is done then a manual call to size_node_extra_integers() will need to be done before the new space is usable.

Newly allocated values for the new datum will be initialized to *default_value if default_value is not null, or to meaningless memcpy output otherwise.

Returns: The starting index number for the new datum, or for the existing datum if one by the same name has already been added.

If type T is larger than dof_id_type, its data will end up spanning multiple index values, but will be queried with the starting index number.

No type checking is done with this function! If you add data of type T, don't try to access it with a call specifying type U.

Definition at line 2679 of file mesh_base.h.

{
  const std::size_t old_size = _node_integer_names.size();
 
  unsigned int n_more_integers = (sizeof(T)-1)/sizeof(dof_id_type);
  std::vector<dof_id_type> int_data(n_more_integers+1, DofObject::invalid_id);
  if (default_value)
    std::memcpy(int_data.data(), default_value, sizeof(T));
 
  unsigned int start_idx = this->add_node_integer(name, false, int_data[0]);
  for (unsigned int i=0; i != n_more_integers; ++i)
    this->add_node_integer(name+"__"+std::to_string(i), false, int_data[i+1]);
 
  if (allocate_data && old_size != _node_integer_names.size())
    this->size_node_extra_integers();
 
  return start_idx;
}

References _node_integer_names, add_node_integer(), libMesh::DofObject::invalid_id, and size_node_extra_integers().

Referenced by libMesh::MeshTools::Modification::all_rbb(), ExtraIntegersTest::build_mesh(), libMesh::ExodusII_IO::read(), and libMesh::DynaIO::read_mesh().

◆ add_node_integer()

unsigned int libMesh::MeshBase::add_node_integer	(	std::string	name,
		bool	allocate_data = `true`,
		dof_id_type	default_value = `DofObject::invalid_id`
	)

Register an integer datum (of type dof_id_type) to be added to each node in the mesh.

If the mesh already has nodes, data by default is allocated in each of them. This may be expensive to do repeatedly; use add_node_integers instead. Alternatively, the allocate_data option can be manually set to false, but if this is done then a manual call to size_node_extra_integers() will need to be done before the new space is usable.

Newly allocated values for the new datum will be initialized to default_value

Returns: The index number for the new datum, or for the existing datum if one by the same name has already been added.

Definition at line 712 of file mesh_base.C.

{
  for (auto i : index_range(_node_integer_names))
    if (_node_integer_names[i] == name)
      {
        libmesh_assert_less(i, _node_integer_default_values.size());
        _node_integer_default_values[i] = default_value;
        return i;
      }
 
  libmesh_assert_equal_to(_node_integer_names.size(),
                          _node_integer_default_values.size());
  _node_integer_names.push_back(std::move(name));
  _node_integer_default_values.push_back(default_value);
  if (allocate_data)
    this->size_node_extra_integers();
  return _node_integer_names.size()-1;
}

References _node_integer_default_values, _node_integer_names, libMesh::index_range(), and size_node_extra_integers().

Referenced by add_node_datum(), ExtraIntegersTest::build_mesh(), ExtraIntegersTest::checkpoint_helper(), libMesh::CheckpointIO::read_header(), and ExtraIntegersTest::test_helper().

◆ add_node_integers()

std::vector< unsigned int > libMesh::MeshBase::add_node_integers	(	const std::vector< std::string > &	names,
		bool	allocate_data = `true`,
		const std::vector< dof_id_type > *	default_values = `nullptr`
	)

Register integer data (of type dof_id_type) to be added to each node in the mesh.

If the mesh already has nodes, data by default is allocated in each.

Newly allocated values for the new datum with name names[i] will be initialized to default_values[i], or to DofObject::invalid_id if default_values is null.

Returns: The index numbers for the new data, and/or for existing data if data by some of the same names has already been added.

Definition at line 735 of file mesh_base.C.

{
  libmesh_assert(!default_values || default_values->size() == names.size());
  libmesh_assert_equal_to(_node_integer_names.size(), _node_integer_default_values.size());
 
  std::unordered_map<std::string, std::size_t> name_indices;
  for (auto i : index_range(_node_integer_names))
    name_indices[_node_integer_names[i]] = i;
 
  std::vector<unsigned int> returnval(names.size());
 
  bool added_an_integer = false;
  for (auto i : index_range(names))
    {
      const std::string & name = names[i];
      if (const auto it = name_indices.find(name);
          it != name_indices.end())
        {
          returnval[i] = it->second;
          _node_integer_default_values[it->second] =
            default_values ? (*default_values)[i] : DofObject::invalid_id;
        }
      else
        {
          returnval[i] = _node_integer_names.size();
          name_indices[name] = returnval[i];
          _node_integer_names.push_back(name);
          _node_integer_default_values.push_back
            (default_values ? (*default_values)[i] : DofObject::invalid_id);
          added_an_integer = true;
        }
    }
 
  if (allocate_data && added_an_integer)
    this->size_node_extra_integers();
 
  return returnval;
}

References _node_integer_default_values, _node_integer_names, libMesh::index_range(), libMesh::DofObject::invalid_id, libMesh::libmesh_assert(), and size_node_extra_integers().

Referenced by merge_extra_integer_names(), and libMesh::XdrIO::read_header().

◆ add_point()

virtual Node * libMesh::MeshBase::add_point	(	const Point &	p,
		const dof_id_type	id = `DofObject::invalid_id`,
		const processor_id_type	proc_id = `DofObject::invalid_processor_id`
	)

pure virtual

Add a new Node at Point p to the end of the vertex array, with processor_id procid.

Use DofObject::invalid_processor_id (default) to add a node to all processors, or this->processor_id() to add a node to the local processor only. If adding a node locally, passing an id other than DofObject::invalid_id will set that specific node id. Only do this in parallel if you are manually keeping ids consistent.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

◆ all_complete_order()

void libMesh::MeshBase::all_complete_order ( )

virtual

Calls the range-based version of this function with a range consisting of all elements in the mesh.

Definition at line 1808 of file mesh_base.C.

{
  this->all_complete_order_range(this->element_ptr_range());
}

References all_complete_order_range().

Referenced by AllSecondOrderTest::allCompleteOrder(), libMesh::MeshTools::Generation::build_cube(), libMesh::MeshTetInterface::increase_tet_order(), libMesh::TriangulatorInterface::increase_triangle_order(), main(), and MeshTetTest::testNetGenTet14Curved().

◆ all_complete_order_range()

virtual void libMesh::MeshBase::all_complete_order_range ( const SimpleRange< element_iterator > & range )

pure virtual

Converts a set of elements in this (conforming, non-refined) mesh into "complete" order elements, i.e.

elements which can store degrees of freedom on any vertex, edge, or face. For example, a mesh consisting of Tet4 or Tet10 will be converted to a mesh with Tet14 etc.

Implemented in libMesh::UnstructuredMesh.

Referenced by all_complete_order(), AllSecondOrderTest::allCompleteOrderDoNothing(), AllSecondOrderTest::allCompleteOrderMixed(), AllSecondOrderTest::allCompleteOrderMixedFixing(), AllSecondOrderTest::allCompleteOrderMixedFixing3D(), and AllSecondOrderTest::allCompleteOrderRange().

◆ all_first_order()

virtual void libMesh::MeshBase::all_first_order ( )

pure virtual

Converts a mesh with higher-order elements into a mesh with linear elements.

For example, a mesh consisting of Tet10 will be converted to a mesh with Tet4 etc.

Implemented in libMesh::UnstructuredMesh.

Referenced by main(), and ExtraIntegersTest::test_helper().

◆ all_second_order()

void libMesh::MeshBase::all_second_order ( const bool full_ordered = true )

Calls the range-based version of this function with a range consisting of all elements in the mesh.

Definition at line 1803 of file mesh_base.C.

{
  this->all_second_order_range(this->element_ptr_range(), full_ordered);
}

References all_second_order_range().

Referenced by AllSecondOrderTest::allSecondOrder(), libMesh::MeshTools::Generation::build_cube(), build_domain(), libMesh::MeshTetInterface::increase_tet_order(), libMesh::TriangulatorInterface::increase_triangle_order(), main(), ExtraIntegersTest::test_helper(), MeshTetTest::testNetGenQuadraticCurved(), and InfFERadialTest::testRefinement().

◆ all_second_order_range()

virtual void libMesh::MeshBase::all_second_order_range	(	const SimpleRange< element_iterator > &	range,
		const bool	full_ordered = `true`
	)

pure virtual

Converts a set of this Mesh's elements defined by range from FIRST order to SECOND order.

Must be called on conforming, non-refined meshes. For example, a mesh consisting of Tet4 will be converted to a mesh with Tet10 etc.

Note: For some elements like Hex8 there exist two higher order equivalents, Hex20 and Hex27. When full_ordered is true (default), then Hex27 is built. Otherwise, Hex20 is built. The same holds obviously for Quad4, Prism6, etc.

Implemented in libMesh::UnstructuredMesh.

Referenced by all_second_order(), AllSecondOrderTest::allSecondOrderDoNothing(), AllSecondOrderTest::allSecondOrderMixed(), AllSecondOrderTest::allSecondOrderMixedFixing(), AllSecondOrderTest::allSecondOrderMixedFixing3D(), AllSecondOrderTest::allSecondOrderRange(), and MixedOrderTest::testFindNeighbors().

◆ allgather()

virtual void libMesh::MeshBase::allgather ( )

inlinevirtual

Gathers all elements and nodes of the mesh onto every processor.

Reimplemented in libMesh::DistributedMesh.

Definition at line 386 of file mesh_base.h.

386{}

Referenced by libMesh::EquationSystems::allgather(), libMesh::MeshSerializer::MeshSerializer(), and PartitionerTest< PartitionerSubclass, MeshClass >::testPartition().

◆ allow_detect_interior_parents() [1/2]

bool libMesh::MeshBase::allow_detect_interior_parents ( ) const

inline

Definition at line 1370 of file mesh_base.h.

1370{ return !_skip_detect_interior_parents; }

References _skip_detect_interior_parents.

Referenced by libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::DistributedMesh::DistributedMesh(), libMesh::UnstructuredMesh::read(), and libMesh::ReplicatedMesh::ReplicatedMesh().

◆ allow_detect_interior_parents() [2/2]

void libMesh::MeshBase::allow_detect_interior_parents ( bool allow )

inline

If false is passed then this mesh will no longer work to detect interior parents when being prepared for use.

Definition at line 1369 of file mesh_base.h.

1369{ _skip_detect_interior_parents = !allow; }

References _skip_detect_interior_parents.

Referenced by libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::DistributedMesh::DistributedMesh(), and libMesh::ReplicatedMesh::ReplicatedMesh().

◆ allow_find_neighbors() [1/2]

bool libMesh::MeshBase::allow_find_neighbors ( ) const

inline

Definition at line 1363 of file mesh_base.h.

1363{ return !_skip_find_neighbors; }

References _skip_find_neighbors.

Referenced by libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::DistributedMesh::DistributedMesh(), prepare_for_use(), libMesh::UnstructuredMesh::read(), libMesh::ReplicatedMesh::ReplicatedMesh(), and libMesh::UnstructuredMesh::stitching_helper().

◆ allow_find_neighbors() [2/2]

void libMesh::MeshBase::allow_find_neighbors ( bool allow )

inline

If false is passed then this mesh will no longer work to find element neighbors when being prepared for use.

Definition at line 1362 of file mesh_base.h.

1362{ _skip_find_neighbors = !allow; }

References _skip_find_neighbors.

Referenced by libMesh::DistributedMesh::DistributedMesh(), and libMesh::ReplicatedMesh::ReplicatedMesh().

◆ allow_node_and_elem_unique_id_overlap() [1/2]

bool libMesh::MeshBase::allow_node_and_elem_unique_id_overlap ( ) const

inline

Definition at line 1388 of file mesh_base.h.

1388{ return _allow_node_and_elem_unique_id_overlap; }

References _allow_node_and_elem_unique_id_overlap.

◆ allow_node_and_elem_unique_id_overlap() [2/2]

void libMesh::MeshBase::allow_node_and_elem_unique_id_overlap ( bool allow )

inline

If true is passed, then this mesh will no longer require unique_ids to be unique across the set of all DofObjects.

That is, although no two Elems (resp. Nodes) will share the same unique_id, a given Elem and Node might share the same unique_id.

Definition at line 1387 of file mesh_base.h.

1387{ _allow_node_and_elem_unique_id_overlap = allow; }

References _allow_node_and_elem_unique_id_overlap.

Referenced by libMesh::MeshTools::libmesh_assert_valid_unique_ids(), and libMesh::ExodusII_IO::read().

◆ allow_remote_element_removal() [1/2]

bool libMesh::MeshBase::allow_remote_element_removal ( ) const

inline

Definition at line 1379 of file mesh_base.h.

1379{ return _allow_remote_element_removal; }

References _allow_remote_element_removal.

Referenced by libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::DistributedMesh::DistributedMesh(), libMesh::ReplicatedMesh::ReplicatedMesh(), and libMesh::UnstructuredMesh::stitching_helper().

◆ allow_remote_element_removal() [2/2]

void libMesh::MeshBase::allow_remote_element_removal ( bool allow )

inline

If false is passed in then this mesh will no longer have remote elements deleted when being prepared for use; i.e.

even a DistributedMesh will remain (if it is already) serialized. This may adversely affect performance and memory use.

Definition at line 1378 of file mesh_base.h.

1378{ _allow_remote_element_removal = allow; }

References _allow_remote_element_removal.

Referenced by AllSecondOrderTest::allCompleteOrder(), AllSecondOrderTest::allCompleteOrderDoNothing(), AllSecondOrderTest::allSecondOrder(), AllSecondOrderTest::allSecondOrderDoNothing(), libMesh::DistributedMesh::DistributedMesh(), libMesh::MeshSerializer::MeshSerializer(), libMesh::ReplicatedMesh::ReplicatedMesh(), ConnectedComponentsTest::testEdge(), PeriodicBCTest::testPeriodicBC(), and libMesh::MeshSerializer::~MeshSerializer().

◆ allow_renumbering() [1/2]

bool libMesh::MeshBase::allow_renumbering ( ) const

inline

Definition at line 1356 of file mesh_base.h.

1356{ return !_skip_renumber_nodes_and_elements; }

References _skip_renumber_nodes_and_elements.

Referenced by libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::DistributedMesh::DistributedMesh(), prepare_for_use(), prepare_for_use(), libMesh::UnstructuredMesh::read(), and libMesh::ReplicatedMesh::ReplicatedMesh().

◆ allow_renumbering() [2/2]

void libMesh::MeshBase::allow_renumbering ( bool allow )

inline

If false is passed in then this mesh will no longer be renumbered when being prepared for use.

This may slightly adversely affect performance during subsequent element access, particularly when using a distributed mesh.

Important! When allow_renumbering(false) is set, ReplicatedMesh::n_elem() and ReplicatedMesh::n_nodes() will return wrong values whenever adaptive refinement is followed by adaptive coarsening. (Uniform refinement followed by uniform coarsening is OK.) This is due to the fact that n_elem() and n_nodes() are currently O(1) functions that just return the size of the respective underlying vectors, and this size is wrong when the numbering includes "gaps" from nodes and elements that have been deleted. We plan to implement a caching mechanism in the near future that will fix this incorrect behavior.

Definition at line 1355 of file mesh_base.h.

1355{ _skip_renumber_nodes_and_elements = !allow; }

References _skip_renumber_nodes_and_elements.

Referenced by AllSecondOrderTest::allSecondOrderMixedFixing(), DisjointNeighborTest::build_four_disjoint_elems(), DisjointNeighborTest::build_two_disjoint_elems(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::DistributedMesh::DistributedMesh(), main(), AllSecondOrderTest::MixedFixingImpl(), libMesh::ErrorVector::plot_error(), libMesh::GMVIO::read(), libMesh::NameBasedIO::read(), libMesh::ReplicatedMesh::ReplicatedMesh(), libMesh::C0Polyhedron::retriangulate(), WriteVecAndScalar::setupTests(), ConstraintOperatorTest::test1DCoarseningNewNodes(), ConstraintOperatorTest::test1DCoarseningOperator(), MeshGenerationTest::testBuildSphere(), CheckpointIOTest::testC0PolygonCheckpoint(), CheckpointIOTest::testC0PolyhedronCheckpoint(), MeshInputTest::testCopyElementSolutionImpl(), MeshInputTest::testCopyElementVectorImpl(), MeshInputTest::testCopyNodalSolutionImpl(), ConstraintOperatorTest::testCoreform(), DisjointNeighborTest::testDisjointNeighborConflictError(), MeshGenerationTest::tester(), MeshInputTest::testExodusWriteElementDataFromDiscontinuousNodalData(), ExtraIntegersTest::testExtraIntegersExodusReading(), SystemsTest::testProjectMatrix1D(), SystemsTest::testProjectMatrix2D(), SystemsTest::testProjectMatrix3D(), EquationSystemsTest::testRefineThenReinitPreserveFlags(), EquationSystemsTest::testRepartitionThenReinit(), BoundaryInfoTest::testShellFaceConstraints(), MeshInputTest::testSingleElementImpl(), DisjointNeighborTest::testStitchCrossMesh(), MeshSmootherTest::testVariationalPrism21MultipleSubdomains(), MeshInputTest::testVTKPreserveElemIds(), MeshInputTest::testVTKPreserveSubdomainIds(), WriteElemsetData::testWriteImpl(), WriteNodesetData::testWriteImpl(), and WriteSidesetData::testWriteImpl().

◆ assign()

virtual MeshBase & libMesh::MeshBase::assign ( MeshBase && other_mesh )

pure virtual

Shim to allow operator = (&&) to behave like a virtual function without having to be one.

Implemented in libMesh::DistributedMesh, libMesh::ReplicatedMesh, and libMesh::UnstructuredMesh.

Referenced by MeshAssignTest::testMeshMoveAssign().

◆ cache_elem_data()

void libMesh::MeshBase::cache_elem_data ( )

Definition at line 1985 of file mesh_base.C.

{
  // This requires an inspection on every processor
  parallel_object_only();
 
  // Need to clear containers first in case all elements of a
  // particular dimension/order/subdomain have been deleted.
  _elem_dims.clear();
  _elem_default_orders.clear();
  _mesh_subdomains.clear();
  _supported_nodal_order = MAXIMUM;
 
  for (const auto & elem : this->active_element_ptr_range())
  {
    _elem_dims.insert(cast_int<unsigned char>(elem->dim()));
    _elem_default_orders.insert(elem->default_order());
    _mesh_subdomains.insert(elem->subdomain_id());
    _supported_nodal_order =
      static_cast<Order>
        (std::min(static_cast<int>(_supported_nodal_order),
                  static_cast<int>(elem->supported_nodal_order())));
  }
 
  if (!this->is_serial())
  {
    // Some different dimension/order/subdomain elements may only live
    // on other processors
    this->comm().set_union(_elem_dims);
    this->comm().set_union(_elem_default_orders);
    this->comm().min(_supported_nodal_order);
    this->comm().set_union(_mesh_subdomains);
  }
 
  // If the largest element dimension found is larger than the current
  // _spatial_dimension, increase _spatial_dimension.
  unsigned int max_dim = this->mesh_dimension();
  if (max_dim > _spatial_dimension)
    _spatial_dimension = cast_int<unsigned char>(max_dim);
 
  // _spatial_dimension may need to increase from 1->2 or 2->3 if the
  // mesh is full of 1D elements but they are not x-aligned, or the
  // mesh is full of 2D elements but they are not in the x-y plane.
  // If the mesh is x-aligned or x-y planar, we will end up checking
  // every node's coordinates and not breaking out of the loop
  // early...
  if (_spatial_dimension < LIBMESH_DIM)
    {
      for (const auto & node : this->node_ptr_range())
        {
          // Note: the exact floating point comparison is intentional,
          // we don't want to get tripped up by tolerances.
          if ((*node)(0) != 0. && _spatial_dimension < 1)
            _spatial_dimension = 1;
 
          if ((*node)(1) != 0. && _spatial_dimension < 2)
            {
              _spatial_dimension = 2;
#if LIBMESH_DIM == 2
              // If libmesh is compiled in 2D mode, this is the
              // largest spatial dimension possible so we can break
              // out.
              break;
#endif
            }
 
#if LIBMESH_DIM > 2
          if ((*node)(2) != 0.)
            {
              // Spatial dimension can't get any higher than this, so
              // we can break out.
              _spatial_dimension = 3;
              break;
            }
#endif
        }
    }
 
  _preparation.has_cached_elem_data = true;
}

References _elem_default_orders, _elem_dims, _mesh_subdomains, _preparation, _spatial_dimension, _supported_nodal_order, libMesh::ParallelObject::comm(), libMesh::MeshBase::Preparation::has_cached_elem_data, is_serial(), libMesh::MAXIMUM, mesh_dimension(), libMesh::Parallel::Communicator::min(), and libMesh::Parallel::Communicator::set_union().

Referenced by ExodusC0PolyhedronTest::build_c0polyhedron(), cache_elem_dims(), complete_preparation(), main(), set_elem_dimensions(), ExodusC0PolyhedronTest::test_write_cube_header(), MeshSmootherTest::testVariationalSmoother(), and libMesh::NetGenMeshInterface::triangulate().

◆ cache_elem_dims()

void libMesh::MeshBase::cache_elem_dims ( )

Deprecated:: This method has ben replaced by cache_elem_data which caches data in addition to elem dimensions (e.g. elem subdomain ids) Search the mesh and cache the different dimensions of the elements present in the mesh. This is done in prepare_for_use(), but can be done manually by other classes after major mesh modifications.

Definition at line 1977 of file mesh_base.C.

{
  libmesh_deprecated();
 
  this->cache_elem_data();
}

References cache_elem_data().

◆ change_elemset_code()

void libMesh::MeshBase::change_elemset_code	(	dof_id_type	old_code,
		dof_id_type	new_code
	)

Replace elemset code "old_code" with "new_code".

This function loops over all elements and changes the extra integer corresponding to the "elemset_code" label, and updates the _elemset_codes and _elemset_codes_inverse_map members. Does not change the elemset ids of any of the sets.

Definition at line 512 of file mesh_base.C.

{
  // Look up elemset ids for old_code
  auto it = _elemset_codes.find(old_code);
 
  // If we don't have the old_code, then do nothing. Alternatively, we
  // could throw an error since trying to change an elemset code you
  // don't have could indicate there's a problem...
  if (it == _elemset_codes.end())
    return;
 
  // Make copy of the set of elemset ids. We are not changing these,
  // only updating the elemset code it corresponds to.
  elemset_type id_set_copy = *(it->second);
 
  // Look up the corresponding entry in the inverse map. Note: we want
  // the iterator because we are going to remove it.
  auto inverse_it = _elemset_codes_inverse_map.find(id_set_copy);
  libmesh_error_msg_if(inverse_it == _elemset_codes_inverse_map.end(),
                       "Expected _elemset_codes_inverse_map entry for elemset code " << old_code);
 
  // Erase entry from inverse map
  _elemset_codes_inverse_map.erase(inverse_it);
 
  // Erase entry from forward map
  _elemset_codes.erase(it);
 
  // Add new code with original set of ids.
  this->add_elemset_code(new_code, id_set_copy);
 
  // We can't update any actual elemset codes if there is no extra integer defined for it.
  if (!this->has_elem_integer("elemset_code"))
    return;
 
  // Get index of elemset_code extra integer
  unsigned int elemset_index = this->get_elem_integer_index("elemset_code");
 
  // Loop over all elems and update code
  Threads::parallel_for
    (this->element_stored_range(),
     [elemset_index, old_code, new_code](const ElemRange & range)
     {
       for (Elem * elem : range)
         {
           dof_id_type elemset_code =
             elem->get_extra_integer(elemset_index);
 
           if (elemset_code == old_code)
             elem->set_extra_integer(elemset_index, new_code);
         }
     });
}

References _elemset_codes, _elemset_codes_inverse_map, add_elemset_code(), element_stored_range(), get_elem_integer_index(), has_elem_integer(), and libMesh::Threads::parallel_for().

◆ change_elemset_id()

void libMesh::MeshBase::change_elemset_id	(	elemset_id_type	old_id,
		elemset_id_type	new_id
	)

Replace elemset id "old_id" with "new_id".

Does not change any of the elemset codes, so does not need to loop over the elements themselves.

Definition at line 565 of file mesh_base.C.

{
  // Early return if we don't have old_id
  if (!_all_elemset_ids.count(old_id))
    return;
 
  // Throw an error if the new_id is already used
  libmesh_error_msg_if(_all_elemset_ids.count(new_id),
                       "Cannot change elemset id " << old_id <<
                       " to " << new_id << ", " << new_id << " already exists.");
 
  // We will build up a new version of the inverse map so we can iterate over
  // the current one without invalidating anything.
  std::map<MeshBase::elemset_type, dof_id_type> new_elemset_codes_inverse_map;
  for (const auto & [id_set, elemset_code] : _elemset_codes_inverse_map)
    {
      auto id_set_copy = id_set;
      if (id_set_copy.count(old_id))
        {
          // Remove old_id, insert new_id
          id_set_copy.erase(old_id);
          id_set_copy.insert(new_id);
        }
 
      // Store in new version of map
      new_elemset_codes_inverse_map.emplace(id_set_copy, elemset_code);
    }
 
  // Swap existing map with newly-built one
  _elemset_codes_inverse_map.swap(new_elemset_codes_inverse_map);
 
  // Reconstruct _elemset_codes map
  _elemset_codes.clear();
  for (const auto & [id_set, elemset_code] : _elemset_codes_inverse_map)
    _elemset_codes.emplace(elemset_code, &id_set);
 
  // Update _all_elemset_ids
  _all_elemset_ids.erase(old_id);
  _all_elemset_ids.insert(new_id);
}

References _all_elemset_ids, _elemset_codes, and _elemset_codes_inverse_map.

◆ clear()

void libMesh::MeshBase::clear ( )

virtual

Deletes all the element and node data that is currently stored.

elem and node extra_integer data is nevertheless retained here, for better compatibility between that feature and older code's use of MeshBase::clear()

Reimplemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Definition at line 1036 of file mesh_base.C.

{
  // Reset the number of partitions
  _n_parts = 1;
 
  // Reset the preparation flags
  _preparation = false;
 
  // Clear boundary information
  if (boundary_info)
    boundary_info->clear();
 
  // Clear cached element data
  _elem_dims.clear();
  _elem_default_orders.clear();
  _supported_nodal_order = MAXIMUM;
 
  _elemset_codes.clear();
  _elemset_codes_inverse_map.clear();
 
  _constraint_rows.clear();
 
  // Clear our point locator.
  this->clear_point_locator();
  this->clear_stored_ranges();
}

References _constraint_rows, _elem_default_orders, _elem_dims, _elemset_codes, _elemset_codes_inverse_map, _n_parts, _preparation, _supported_nodal_order, boundary_info, clear_point_locator(), clear_stored_ranges(), and libMesh::MAXIMUM.

Referenced by libMesh::MeshTools::Generation::build_cube(), libMesh::MeshTools::Generation::build_delaunay_square(), DisjointNeighborTest::build_four_disjoint_elems(), DisjointNeighborTest::build_split_mesh_with_interface(), libMesh::DistributedMesh::clear(), libMesh::ReplicatedMesh::clear(), libMesh::TriangleWrapper::copy_tri_to_mesh(), libMesh::UnstructuredMesh::create_submesh(), LinearElasticityWithContact::initialize_contact_load_paths(), main(), libMesh::VTKIO::read(), libMesh::GMVIO::read(), libMesh::STLIO::read(), libMesh::AbaqusIO::read(), libMesh::ExodusII_IO::read(), libMesh::DynaIO::read_mesh(), libMesh::GmshIO::read_mesh(), libMesh::MatlabIO::read_stream(), libMesh::OFFIO::read_stream(), libMesh::BoundaryInfo::sync(), MeshAssignTest::testMeshMoveAssign(), libMesh::NetGenMeshInterface::triangulate(), and ~MeshBase().

◆ clear_elems()

virtual void libMesh::MeshBase::clear_elems ( )

pure virtual

Deletes all the element data that is currently stored.

No Node is removed from the mesh, however even NodeElem elements are deleted, so the remaining Nodes will be considered "unused" and cleared unless they are reconnected to new elements before the next preparation step.

This does not affect BoundaryInfo data; any boundary information associated elements should already be cleared.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by libMesh::TriangulatorInterface::elems_to_segments(), and libMesh::Poly2TriTriangulator::triangulate_current_points().

◆ clear_point_locator()

void libMesh::MeshBase::clear_point_locator ( )

Releases the current PointLocator object.

Definition at line 1866 of file mesh_base.C.

{
  _point_locator.reset(nullptr);
}

References _point_locator.

Referenced by libMesh::DistributedMesh::add_elem(), libMesh::ReplicatedMesh::add_elem(), clear(), libMesh::UnstructuredMesh::contract(), libMesh::DistributedMesh::delete_elem(), libMesh::ReplicatedMesh::delete_elem(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::MeshTools::Modification::distort(), libMesh::DistributedMesh::insert_elem(), libMesh::ReplicatedMesh::insert_elem(), libMesh::MeshTools::Modification::interpolate_surface(), prepare_for_use(), libMesh::MeshTools::Modification::redistribute(), libMesh::MeshTools::Modification::rotate(), libMesh::MeshTools::Modification::scale(), libMesh::MeshTools::Modification::smooth(), libMesh::MeshTools::Modification::translate(), and unset_is_prepared().

◆ clear_stored_ranges()

void libMesh::MeshBase::clear_stored_ranges ( )

Clears stored ranges, to indicate that the mesh has changed and they should be regenerated when next needed.

Definition at line 1969 of file mesh_base.C.

{
  _element_stored_range.reset(nullptr);
  _const_active_local_element_stored_range.reset(nullptr);
}

References _const_active_local_element_stored_range, and _element_stored_range.

Referenced by libMesh::DistributedMesh::add_elem(), libMesh::ReplicatedMesh::add_elem(), clear(), libMesh::DistributedMesh::delete_elem(), libMesh::ReplicatedMesh::delete_elem(), libMesh::DistributedMesh::insert_elem(), libMesh::ReplicatedMesh::insert_elem(), prepare_for_use(), libMesh::DistributedMesh::renumber_elem(), libMesh::ReplicatedMesh::renumber_elem(), and unset_is_prepared().

◆ clone()

virtual std::unique_ptr< MeshBase > libMesh::MeshBase::clone ( ) const

pure virtual

Virtual "copy constructor".

The copy will be of the same subclass as this, and will satisfy "copy == this" when it is created.

Implemented in libMesh::DistributedMesh, libMesh::ParallelMesh, libMesh::ReplicatedMesh, and libMesh::SerialMesh.

Referenced by LinearElasticityWithContact::get_least_and_max_gap_function(), libMesh::ErrorVector::plot_error(), LinearElasticityWithContact::residual_and_jacobian(), libMesh::BoundaryInfo::sync(), DisjointNeighborTest::testCloneEquality(), BoundaryInfoTest::testEdgeBoundaryConditions(), BoundaryInfoTest::testMesh(), MeshInputTest::testProjectionRegression(), BoundaryInfoTest::testShellFaceConstraints(), and libMesh::MeshTools::valid_is_prepared().

◆ comm()

const Parallel::Communicator & libMesh::ParallelObject::comm ( ) const

inlineinherited

Returns: A reference to the Parallel::Communicator object used by this mesh.

Definition at line 97 of file parallel_object.h.

98 { return _communicator; }

libMesh::ParallelObject::_communicator

const Parallel::Communicator & _communicator

Definition parallel_object.h:120

References libMesh::ParallelObject::_communicator.

◆ complete_preparation()

void libMesh::MeshBase::complete_preparation ( )

Definition at line 874 of file mesh_base.C.

{
  LOG_SCOPE("complete_preparation()", "MeshBase");
 
  parallel_object_only();
 
  libmesh_assert(this->comm().verify(this->is_serial()));
 
  // If we don't go into this method with valid constraint rows, we're
  // only going to be able to make that worse.
#ifdef DEBUG
  MeshTools::libmesh_assert_valid_constraint_rows(*this);
#endif
 
  // A distributed mesh may have processors with no elements (or
  // processors with no elements of higher dimension, if we ever
  // support mixed-dimension meshes), but we want consistent
  // mesh_dimension anyways.
  //
  // cache_elem_data() should get the elem_dimensions() and
  // mesh_dimension() correct later, and we don't need it earlier.
 
 
  // Renumber the nodes and elements so that they in contiguous
  // blocks.  By default, _skip_renumber_nodes_and_elements is false.
  //
  // Instances where you if prepare_for_use() should not renumber the nodes
  // and elements include reading in e.g. an xda/r or gmv file. In
  // this case, the ordering of the nodes may depend on an accompanying
  // solution, and the node ordering cannot be changed.
 
 
  // Mesh modification operations might not leave us with consistent
  // id counts, or might leave us with orphaned nodes we're no longer
  // using, but our partitioner might need that consistency and/or
  // might be confused by orphaned nodes.
  if (!_skip_renumber_nodes_and_elements)
    {
      if (!_preparation.has_removed_orphaned_nodes ||
          !_preparation.has_synched_id_counts)
        this->renumber_nodes_and_elements();
    }
  else
    {
      if (!_preparation.has_removed_orphaned_nodes)
        this->remove_orphaned_nodes();
      if (!_preparation.has_synched_id_counts)
        this->update_parallel_id_counts();
    }
 
  // Let all the elements find their neighbors
  if (!_skip_find_neighbors && !_preparation.has_neighbor_ptrs)
    this->find_neighbors();
 
  // The user may have set boundary conditions.  We require that the
  // boundary conditions were set consistently.  Because we examine
  // neighbors when evaluating non-raw boundary condition IDs, this
  // assert is only valid when our neighbor links are in place.
#ifdef DEBUG
  MeshTools::libmesh_assert_valid_boundary_ids(*this);
#endif
 
  // Search the mesh for all the dimensions of the elements
  // and cache them.
  if (!_preparation.has_cached_elem_data)
    this->cache_elem_data();
 
  // libMesh expects every processor to know about every subdomain
  // name, but distributed mesh generators may only have set names for
  // the part of the mesh they know about, so make sure the map is
  // consistent everywhere.
  if (!_preparation.has_synched_subdomain_name_map)
    this->sync_subdomain_name_map();
 
  // Search the mesh for elements that have a neighboring element
  // of dim+1 and set that element as the interior parent
  if (!_preparation.has_interior_parent_ptrs)
    {
      if (!_skip_detect_interior_parents)
        this->detect_interior_parents();
      else
        {
          // We must set the flag that says "interior parent pointers have been set up"
          // even though we skip detect_interior_parents().
          _preparation.has_interior_parent_ptrs = true;
        }
    }
 
  // Fix up node unique ids in case mesh generation code didn't take
  // exceptional care to do so.
  //  MeshCommunication().make_node_unique_ids_parallel_consistent(*this);
 
  // We're going to still require that mesh generation code gets
  // element unique ids consistent.
#if defined(DEBUG) && defined(LIBMESH_ENABLE_UNIQUE_ID)
  MeshTools::libmesh_assert_valid_unique_ids(*this);
#endif
 
  // Allow our GhostingFunctor objects to reinit if necessary.
  // Do this before partitioning and redistributing, and before
  // deleting remote elements.
  if (!_preparation.has_reinit_ghosting_functors)
    this->reinit_ghosting_functors();
 
  // Partition the mesh unless *all* partitioning is to be skipped.
  // If only noncritical partitioning is to be skipped, the
  // partition() call will still check for orphaned nodes.
  if (!skip_partitioning() && !_preparation.is_partitioned)
    this->partition();
  else if (!this->n_unpartitioned_elem() &&
           !this->n_unpartitioned_nodes())
    _preparation.is_partitioned = true;
 
  // If we're using DistributedMesh, we'll probably want it
  // parallelized.
  if (this->_allow_remote_element_removal &&
      !_preparation.has_removed_remote_elements)
    this->delete_remote_elements();
  else
    _preparation.has_removed_remote_elements = true;
 
  // Much of our boundary info may have been for now-remote parts of the mesh,
  // in which case we don't want to keep local copies of data meant to be
  // local. On the other hand we may have deleted, or the user may have added in
  // a distributed fashion, boundary data that is meant to be global. So we
  // handle both of those scenarios here
  if (!_preparation.has_boundary_id_sets)
    this->get_boundary_info().regenerate_id_sets();
 
  if (!_skip_renumber_nodes_and_elements)
    this->renumber_nodes_and_elements();
 
  // The mesh is now prepared for use, with the possible exception of
  // partitioning that was supposed to be skipped, and it should know
  // it.
#ifndef NDEBUG
  Preparation completed_preparation = _preparation;
  if (skip_partitioning())
    completed_preparation.is_partitioned = true;
  libmesh_assert(completed_preparation);
#endif
 
#ifdef DEBUG
  MeshTools::libmesh_assert_valid_boundary_ids(*this);
#ifdef LIBMESH_ENABLE_UNIQUE_ID
  MeshTools::libmesh_assert_valid_unique_ids(*this);
#endif
#endif
}

Referenced by main(), prepare_for_use(), BoundaryMeshSubdomainTest::testDefaultSubdomain(), MeshBaseTest::testMeshBaseVerifyHasCachedElemData(), MeshBaseTest::testMeshBaseVerifyHasNeighborPtrs(), MeshBaseTest::testMeshBaseVerifyRemovalPreparation(), BoundaryMeshSubdomainTest::testPerBoundarySubdomain(), and BoundaryMeshSubdomainTest::testSingleSubdomain().

◆ contract()

virtual bool libMesh::MeshBase::contract ( )

pure virtual

Delete subactive (i.e.

children of coarsened) elements. This removes all elements descended from currently active elements in the mesh.

Implemented in libMesh::UnstructuredMesh.

Referenced by libMesh::EquationSystems::reinit_solutions().

◆ copy_cached_data()

void libMesh::MeshBase::copy_cached_data ( const MeshBase & other_mesh )

protected

Helper class to copy cached data, to synchronize with a possibly unprepared other_mesh.

Definition at line 2431 of file mesh_base.C.

{
  this->_spatial_dimension = other_mesh._spatial_dimension;
  this->_elem_dims = other_mesh._elem_dims;
  this->_elem_default_orders = other_mesh._elem_default_orders;
  this->_supported_nodal_order = other_mesh._supported_nodal_order;
  this->_mesh_subdomains = other_mesh._mesh_subdomains;
}

References _elem_default_orders, _elem_dims, _mesh_subdomains, _spatial_dimension, and _supported_nodal_order.

◆ copy_constraint_rows() [1/2]

void libMesh::MeshBase::copy_constraint_rows ( const MeshBase & other_mesh )

Copy the constraints from the other mesh to this mesh.

Definition at line 2490 of file mesh_base.C.

{
  LOG_SCOPE("copy_constraint_rows(mesh)", "MeshBase");
 
  _constraint_rows.clear();
 
  const auto & other_constraint_rows = other_mesh.get_constraint_rows();
  for (const auto & [other_node, other_node_constraints] : other_constraint_rows)
  {
    const Node * const our_node = this->node_ptr(other_node->id());
    constraint_rows_mapped_type our_node_constraints;
    for (const auto & [other_inner_key_pair, constraint_value] : other_node_constraints)
    {
      const auto & [other_elem, local_node_id] = other_inner_key_pair;
      const Elem * const our_elem = this->elem_ptr(other_elem->id());
      our_node_constraints.emplace_back(std::make_pair(our_elem, local_node_id), constraint_value);
    }
    _constraint_rows[our_node] = std::move(our_node_constraints);
  }
}

References _constraint_rows, elem_ptr(), get_constraint_rows(), and node_ptr().

Referenced by libMesh::DistributedMesh::DistributedMesh(), main(), libMesh::ReplicatedMesh::ReplicatedMesh(), ConstraintOperatorTest::test1DCoarseningNewNodes(), ConstraintOperatorTest::test1DCoarseningOperator(), ConstraintOperatorTest::testCoreform(), and ConnectedComponentsTest::testEdge().

◆ copy_constraint_rows() [2/2]

template<typename T >

void libMesh::MeshBase::copy_constraint_rows	(	const SparseMatrix< T > &	constraint_operator,
		bool	precondition_constraint_operator = `false`
	)

Copy the constraints from the given matrix to this mesh.

The constraint_operator should be an mxn matrix, where m == this->n_nodes() and the operator indexing matches the current node indexing. This may require users to disable mesh renumbering in between loading a mesh file and loading a constraint matrix which matches it.

If any "constraint" rows in the matrix are unit vectors, the node corresponding to that row index will be left unconstrained, and will be used to constrain any other nodes which have a non-zero in the column index of that unit vector.

For each matrix column index which does not correspond to an existing node, a new NodeElem will be added to the mesh on which to store the new unconstrained degree(s) of freedom.

If precondition_constraint_operator is true, then the values of those new unconstrained degrees of freedom may be scaled to improve the conditioning of typical PDE matrices integrated on constrained mesh elements.

T for the constraint_operator in this function should be Real or Number ... and the data should be Real - we just allow complex T for the sake of subclasses which have to be configured and compiled with only one runtime option.

Definition at line 2514 of file mesh_base.C.

{
  LOG_SCOPE("copy_constraint_rows(mat)", "MeshBase");
 
  this->_constraint_rows.clear();
 
  // We're not going to support doing this distributed yet; it'd be
  // pointless unless we temporarily had a linear partitioning to
  // better match the constraint operator.
  MeshSerializer serialize(*this);
 
  // Our current mesh should already reflect the desired assembly space
  libmesh_error_msg_if(this->n_nodes() != constraint_operator.m(),
                       "Constraint operator matrix with " <<
                       constraint_operator.m() <<
                       "rows does not match this mesh with " <<
                       this->n_nodes() << " nodes");
 
  // First, find what new unconstrained DoFs we need to add.  We can't
  // iterate over columns in a SparseMatrix, so we'll iterate over
  // rows and keep track of columns.
 
  // If we have nodes that will work unconstrained, keep track of
  // their node ids and corresponding column indices.
  // existing_unconstrained_nodes[column_id] = node_id
  std::map<dof_id_type, dof_id_type> existing_unconstrained_columns;
  std::set<dof_id_type> existing_unconstrained_nodes;
 
  // In case we need new nodes, keep track of their columns.
  // columns[j][k] will be the kth row index and value of column j
  typedef
    std::unordered_map<dof_id_type,
                       std::vector<std::pair<dof_id_type, Real>>>
    columns_type;
  columns_type columns(constraint_operator.n());
 
  // If we need to precondition the constraint operator (e.g.  it's an
  // unpreconditioned extraction operator for a Flex IGA matrix),
  // we'll want to keep track of the sum of each column, because we'll
  // be dividing each column by that sum (Jacobi preconditioning on
  // the right, which then leads to symmetric preconditioning on a
  // physics Jacobian).
  std::unordered_map<dof_id_type, Real> column_sums;
 
  // Work in parallel, though we'll have to sync shortly
  for (auto i : make_range(constraint_operator.row_start(),
                           constraint_operator.row_stop()))
    {
      std::vector<numeric_index_type> indices;
      std::vector<T> values;
 
      constraint_operator.get_row(i, indices, values);
      libmesh_assert_equal_to(indices.size(), values.size());
 
      if (indices.size() == 1 &&
          values[0] == T(1))
        {
          // If we have multiple simple Ui=Uj constraints, let the
          // first one be our "unconstrained" node and let the others
          // be constrained to it.
          if (existing_unconstrained_columns.find(indices[0]) !=
              existing_unconstrained_columns.end())
            {
              const auto j = indices[0];
              columns[j].emplace_back(i, 1);
            }
          else
            {
              existing_unconstrained_nodes.insert(i);
              existing_unconstrained_columns.emplace(indices[0],i);
            }
        }
      else
        for (auto jj : index_range(indices))
          {
            const auto j = indices[jj];
            const Real coef = libmesh_real(values[jj]);
            libmesh_assert_equal_to(coef, values[jj]);
            columns[j].emplace_back(i, coef);
          }
    }
 
  // Merge data from different processors' slabs of the matrix
  this->comm().set_union(existing_unconstrained_nodes);
  this->comm().set_union(existing_unconstrained_columns);
 
  std::vector<columns_type> all_columns;
  this->comm().allgather(columns, all_columns);
 
  columns.clear();
  for (auto p : index_range(all_columns))
    for (auto & [j, subcol] : all_columns[p])
      for (auto [i, v] : subcol)
        columns[j].emplace_back(i,v);
 
  // Keep track of elements on which unconstrained nodes exist, and
  // their local node indices.
  // node_to_elem_ptrs[node] = [elem_id, local_node_num]
  std::unordered_map<const Node *, std::pair<dof_id_type, unsigned int>> node_to_elem_ptrs;
 
  // Find elements attached to any existing nodes that will stay
  // unconstrained.  We'll also build a subdomain set here so we don't
  // have to assert that the mesh is already prepared before we pick a
  // new subdomain for any NodeElems we need to add.
  std::set<subdomain_id_type> subdomain_ids;
  for (const Elem * elem : this->element_ptr_range())
    {
      subdomain_ids.insert(elem->subdomain_id());
      for (auto n : make_range(elem->n_nodes()))
        {
          const Node * node = elem->node_ptr(n);
          if (existing_unconstrained_nodes.count(node->id()))
            node_to_elem_ptrs.emplace(node, std::make_pair(elem->id(), n));
        }
    }
 
  const subdomain_id_type new_sbd_id = *subdomain_ids.rbegin() + 1;
 
  for (auto j : make_range(constraint_operator.n()))
    {
      // If we already have a good node for this then we're done
      if (existing_unconstrained_columns.count(j))
        continue;
 
      // Get a half-decent spot to place a new NodeElem for
      // unconstrained DoF(s) here.  Getting a *fully*-decent spot
      // would require finding a Moore-Penrose pseudoinverse, and I'm
      // not going to do that, but scaling a transpose will at least
      // get us a little uniqueness to make visualization reasonable.
      Point newpt;
      Real total_scaling = 0;
      unsigned int total_entries = 0;
 
      // We'll get a decent initial pid choice here too, if only to
      // aid in later repartitioning.
      std::map<processor_id_type, int> pids;
 
      auto & column = columns[j];
      for (auto [i, r] : column)
        {
          Node & constrained_node = this->node_ref(i);
          const Point constrained_pt = constrained_node;
          newpt += r*constrained_pt;
          total_scaling += r;
          ++total_entries;
          ++pids[constrained_node.processor_id()];
        }
 
      if (precondition_constraint_operator)
        column_sums[j] = total_scaling;
 
      libmesh_error_msg_if
        (!total_entries,
         "Empty column " << j <<
         " found in constraint operator matrix");
 
      // If we have *cancellation* here then we can end up dividing by
      // zero; try just evenly scaling across all constrained node
      // points instead.
      if (total_scaling > TOLERANCE)
        newpt /= total_scaling;
      else
        newpt /= total_entries;
 
      Node *n = this->add_point(newpt);
      std::unique_ptr<Elem> elem = Elem::build(NODEELEM);
      elem->set_node(0, n);
      elem->subdomain_id() = new_sbd_id;
 
      Elem * added_elem = this->add_elem(std::move(elem));
      this->_elem_dims.insert(0);
      this->_elem_default_orders.insert(added_elem->default_order());
      this->_supported_nodal_order =
        static_cast<Order>
          (std::min(static_cast<int>(this->_supported_nodal_order),
                    static_cast<int>(added_elem->supported_nodal_order())));
      this->_mesh_subdomains.insert(new_sbd_id);
      node_to_elem_ptrs.emplace(n, std::make_pair(added_elem->id(), 0));
      existing_unconstrained_columns.emplace(j,n->id());
 
      // Repartition the new objects *after* adding them, so a
      // DistributedMesh doesn't get confused and think you're not
      // adding them on all processors at once.
      int n_pids = 0;
      for (auto [pid, count] : pids)
        if (count >= n_pids)
          {
            n_pids = count;
            added_elem->processor_id() = pid;
            n->processor_id() = pid;
          }
    }
 
  // Calculate constraint rows in an indexed form that's easy for us
  // to allgather
  std::unordered_map<dof_id_type,
    std::vector<std::pair<std::pair<dof_id_type, unsigned int>,Real>>>
    indexed_constraint_rows;
 
  for (auto i : make_range(constraint_operator.row_start(),
                           constraint_operator.row_stop()))
    {
      if (existing_unconstrained_nodes.count(i))
        continue;
 
      std::vector<numeric_index_type> indices;
      std::vector<T> values;
 
      constraint_operator.get_row(i, indices, values);
 
      std::vector<std::pair<std::pair<dof_id_type, unsigned int>, Real>> constraint_row;
 
      for (auto jj : index_range(indices))
        {
          const dof_id_type node_id =
            existing_unconstrained_columns[indices[jj]];
 
          Node & constraining_node = this->node_ref(node_id);
 
          libmesh_assert(node_to_elem_ptrs.count(&constraining_node));
 
          auto p = node_to_elem_ptrs[&constraining_node];
 
          Real coef = libmesh_real(values[jj]);
          libmesh_assert_equal_to(coef, values[jj]);
 
          // If we're preconditioning and we created a nodeelem then
          // we can scale the meaning of that nodeelem's value to give
          // us a better-conditioned matrix after the constraints are
          // applied.
          if (precondition_constraint_operator)
            if (auto sum_it = column_sums.find(indices[jj]);
                sum_it != column_sums.end())
              {
                const Real scaling = sum_it->second;
 
                if (scaling > TOLERANCE)
                  coef /= scaling;
              }
 
          constraint_row.emplace_back(std::make_pair(p, coef));
        }
 
      indexed_constraint_rows.emplace(i, std::move(constraint_row));
    }
 
  this->comm().set_union(indexed_constraint_rows);
 
  // Add constraint rows as mesh constraint rows
  for (auto & [node_id, indexed_row] : indexed_constraint_rows)
    {
      Node * constrained_node = this->node_ptr(node_id);
 
      constraint_rows_mapped_type constraint_row;
 
      for (auto [p, coef] : indexed_row)
        {
          const Elem * elem = this->elem_ptr(p.first);
          constraint_row.emplace_back
            (std::make_pair(std::make_pair(elem, p.second), coef));
        }
 
      this->_constraint_rows.emplace(constrained_node,
                                     std::move(constraint_row));
    }
}

References _constraint_rows, _elem_default_orders, _elem_dims, _mesh_subdomains, _supported_nodal_order, add_elem(), add_point(), libMesh::Parallel::Communicator::allgather(), libMesh::Elem::build(), libMesh::ParallelObject::comm(), libMesh::Elem::default_order(), elem_ptr(), libMesh::SparseMatrix< T >::get_row(), libMesh::DofObject::id(), libMesh::index_range(), libMesh::libmesh_assert(), libMesh::libmesh_real(), libMesh::SparseMatrix< T >::m(), libMesh::make_range(), libMesh::SparseMatrix< T >::n(), n_nodes(), node_ptr(), node_ref(), libMesh::NODEELEM, libMesh::DofObject::processor_id(), libMesh::Real, libMesh::SparseMatrix< T >::row_start(), libMesh::SparseMatrix< T >::row_stop(), libMesh::Parallel::Communicator::set_union(), subdomain_ids(), libMesh::Elem::supported_nodal_order(), and libMesh::TOLERANCE.

◆ default_ghosting()

GhostingFunctor & libMesh::MeshBase::default_ghosting ( )

inline

Default ghosting functor.

Definition at line 1484 of file mesh_base.h.

1484{ return *_default_ghosting; }

References _default_ghosting.

◆ default_mapping_data()

unsigned char libMesh::MeshBase::default_mapping_data ( ) const

inline

Returns any default data value used by the master space to physical space mapping.

Definition at line 959 of file mesh_base.h.

  {
    return _default_mapping_data;
  }

References _default_mapping_data.

Referenced by libMesh::DistributedMesh::add_elem(), libMesh::ReplicatedMesh::add_elem(), MeshInputTest::helperTestingDynaQuad(), libMesh::DistributedMesh::insert_elem(), libMesh::ReplicatedMesh::insert_elem(), libMesh::VTKIO::nodes_to_vtk(), AllRBBTest::test_box(), and MeshInputTest::testDynaReadPatch().

◆ default_mapping_type()

ElemMappingType libMesh::MeshBase::default_mapping_type ( ) const

inline

Returns the default master space to physical space mapping basis functions to be used on newly added elements.

Definition at line 941 of file mesh_base.h.

  {
    return _default_mapping_type;
  }

References _default_mapping_type.

Referenced by libMesh::DistributedMesh::add_elem(), libMesh::ReplicatedMesh::add_elem(), libMesh::VTKIO::cells_to_vtk(), MeshInputTest::helperTestingDynaQuad(), libMesh::DistributedMesh::insert_elem(), libMesh::ReplicatedMesh::insert_elem(), libMesh::VTKIO::nodes_to_vtk(), libMesh::VTKIO::read(), MeshInputTest::testDynaFileMappings(), MeshInputTest::testDynaReadPatch(), and MeshInputTest::testExodusFileMappings().

◆ delete_elem()

virtual void libMesh::MeshBase::delete_elem ( Elem * e )

pure virtual

Removes element e from the mesh.

This method must be implemented in derived classes in such a way that it does not invalidate element iterators. Users should call MeshBase::complete_preparation() after elements are added to and/or deleted from the mesh.

Note: Calling this method may produce isolated nodes, i.e. nodes not connected to any element.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by libMesh::MeshTools::Modification::all_tri(), libMesh::MeshTools::Generation::build_cube(), libMesh::MeshTools::clear_spline_nodes(), libMesh::UnstructuredMesh::contract(), libMesh::MeshTetInterface::delete_2D_hull_elements(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::MeshTools::Modification::flatten(), libMesh::Poly2TriTriangulator::insert_refinement_points(), libMesh::TetGenMeshInterface::pointset_convexhull(), libMesh::AbaqusIO::read(), libMesh::UNVIO::read_implementation(), libMesh::GmshIO::read_mesh(), libMesh::SimplexRefiner::refine_via_edges(), MeshDeletionsTest::testDeleteElem(), ConnectedComponentsTest::testEdge(), MeshBaseTest::testMeshBaseVerifyRemovalPreparation(), MeshTetTest::testTrisToTetsError(), libMesh::NetGenMeshInterface::triangulate(), and libMesh::MeshTetInterface::volume_to_surface_mesh().

◆ delete_node()

virtual void libMesh::MeshBase::delete_node ( Node * n )

pure virtual

Removes the Node n from the mesh.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by libMesh::UnstructuredMesh::all_first_order(), libMesh::MeshTools::clear_spline_nodes(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::TriangulatorInterface::elems_to_segments(), remove_orphaned_nodes(), and libMesh::UnstructuredMesh::stitching_helper().

◆ delete_remote_elements()

virtual void libMesh::MeshBase::delete_remote_elements ( )

inlinevirtual

When supported, deletes all nonlocal elements of the mesh except for "ghosts" which touch a local element, and deletes all nodes which are not part of a local or ghost element.

Reimplemented in libMesh::DistributedMesh.

Definition at line 399 of file mesh_base.h.

                                         {
    _preparation.has_removed_remote_elements = true;
  }

References _preparation, and libMesh::MeshBase::Preparation::has_removed_remote_elements.

Referenced by libMesh::MeshTools::Generation::build_extrusion(), complete_preparation(), libMesh::UnstructuredMesh::create_submesh(), libMesh::Nemesis_IO::read(), libMesh::BoundaryInfo::sync(), and libMesh::MeshSerializer::~MeshSerializer().

◆ detect_interior_parents()

void libMesh::MeshBase::detect_interior_parents ( )

Search the mesh for elements that have a neighboring element of dim+1 and set that element as the interior parent.

Definition at line 2077 of file mesh_base.C.

{
  LOG_SCOPE("detect_interior_parents()", "MeshBase");
 
  // This requires an inspection on every processor
  parallel_object_only();
 
  // This requires up-to-date mesh dimensions, but if we don't have
  // them cached then we can't update them without changing the mesh
  // in unexpected ways that interfere with our tests of
  // partially-prepared meshes in MeshTools::*valid_is_prepared
  std::set<unsigned char> elem_dims_copy;
  if (_preparation.has_cached_elem_data)
    elem_dims_copy = this->elem_dimensions();
  else
    {
      for (const auto & elem : this->active_element_ptr_range())
        elem_dims_copy.insert(cast_int<unsigned char>(elem->dim()));
      if (!this->is_serial())
        this->comm().set_union(elem_dims_copy);
    }
 
  // Early return if the mesh is empty or has elements of a single spatial dimension.
  if (elem_dims_copy.size() <= 1)
    {
      _preparation.has_interior_parent_ptrs = true;
      return;
    }
 
  // Convenient elem_dimensions iterators
  const auto dim_start = elem_dims_copy.begin();
  const auto dim_end = elem_dims_copy.end();
 
  // In this function we find only +1 dimensional interior parents,
  // (so, for a given element el, the interior parent p must satisfy p.dim() == el.dim() + 1).
  // Therefore, we can avoid checking the existence of interior parents
  // for all those elements el such there there is no p with p.dim() == el.dim() + 1.
  // We store whether to skip any given dimension in the construction of interior parents
  // inside the vector in dimensions_to_skip_for_interior_parents.
  std::vector<bool> skip_dimension_for_interior_parents(/*count=*/LIBMESH_DIM+1, /*value=*/false);
  skip_dimension_for_interior_parents.back() = true;
 
  // Moreover, in the following, we will build a node-to-elem map.
  // It is among the elems of this map that we will look for interior parents.
  // Therefore, we can skip all elems p such that there is no el with el.dim() == p.dim() - 1.
  // We store whether to skip any given dimension in the construction of the node-to-elem map
  // in the vector skip_dimensions_for_node_to_el_map.
  std::vector<bool> skip_dimensions_for_node_to_el_map(/*count=*/LIBMESH_DIM+1, /*value=*/false);
  skip_dimensions_for_node_to_el_map[*dim_start] = true;
 
  // We also create a flag to know if all dimensions should be skipped,
  // and if we should therefore return early.
  bool skip_all_dimensions = true;
 
  // Fill dimensions_to_skip_for_interior_parents and dimensions_to_skip_for_node_to_el_map.
  for (auto [it, next] = std::make_tuple(dim_start, std::next(dim_start));
       next != dim_end; ++it, ++next)
    {
      if (*it + 1 != *next) // if sequential dimensions differ by exactly 1
        {
          skip_dimension_for_interior_parents[*it] = true;
          skip_dimensions_for_node_to_el_map[*next] = true;
        }
      else if (!skip_dimension_for_interior_parents[*it])
        skip_all_dimensions = false;
    }
 
  // There is nothing to do if all dimensions should be
  // skipped. Before returning, we must also set the flag that says
  // "interior parent pointers have been set up" even though we
  // determined there was no work to be done.
  if (skip_all_dimensions)
    {
      _preparation.has_interior_parent_ptrs = true;
      return;
    }
 
  // Do we have interior parent pointers going to a different mesh?
  // If so then we'll still check to make sure that's the only place
  // they go, so we can libmesh_not_implemented() if not.
  const bool separate_interior_mesh = (&(this->interior_mesh()) != this);
 
  // This map will be used to set interior parents
  std::unordered_map<dof_id_type, std::vector<dof_id_type>> node_to_elem;
 
  for (const auto & elem : this->element_ptr_range())
    {
      // Ignore element if it cannot be interior parent of any other elem.
      if (skip_dimensions_for_node_to_el_map[elem->dim()])
        continue;
 
      // Populating the node_to_elem map, same as MeshTools::build_nodes_to_elem_map
      for (auto n : make_range(elem->n_vertices()))
        {
          libmesh_assert_less (elem->id(), this->max_elem_id());
 
          node_to_elem[elem->node_id(n)].push_back(elem->id());
        }
    }
 
  // Automatically set interior parents
  for (const auto & element : this->element_ptr_range())
    {
      // Ignore elements with dimensions to skip
      // or elements that already have an interior parent.
      if (skip_dimension_for_interior_parents[element->dim()] || element->interior_parent())
        continue;
 
      // Start by generating sets of dim+1 dimensional elements that
      // touch each vertex of the current element.  If we encounter a
      // vertex not connected to _any_ dim+1 dimensional elements,
      // then we can exit the loop without checking the remaining
      // vertices since an interior parent (if it exists) will be
      // connected to all vertices of the current element.
      std::vector<std::set<dof_id_type>> neighbors( element->n_vertices() );
 
      bool found_interior_parents = true;
 
      for (auto n : make_range(element->n_vertices()))
        {
          auto it = node_to_elem.find(element->node_id(n));
 
          // Check at first that this node is not isolated.
          if (it == node_to_elem.end())
            {
              found_interior_parents = false;
              break; // out of n-loop
            }
 
          for (const auto & vertex_neighbor_id : it->second)
            if (this->elem_ref(vertex_neighbor_id).dim() == element->dim()+1)
              neighbors[n].insert(vertex_neighbor_id);
 
          if (neighbors[n].empty())
            {
              // We have found an empty set for one vertex, no reason
              // to continue.
              found_interior_parents = false;
              break; // out of n-loop
            }
        }
 
      // If we have generated a non-empty set of elements for each
      // vertex, we will now look for a vertex_neighbor_id that
      // appears in _all_ of those sets.  If found, this is our interior
      // parent id.  If multiple such common ids are found, we will
      // take the lowest such id to be the interior parent id.
      if (found_interior_parents)
        {
          std::set<dof_id_type> & neighbors_0 = neighbors[0];
          for (const auto & interior_parent_id : neighbors_0)
            {
              found_interior_parents = false;
              for (auto n : make_range(1u, element->n_vertices()))
                {
                  if (neighbors[n].count(interior_parent_id))
                    {
                      found_interior_parents = true;
                    }
                  else
                    {
                      found_interior_parents = false;
                      break;
                    }
                }
 
              if (found_interior_parents)
                {
                  element->set_interior_parent(this->elem_ptr(interior_parent_id));
                  break;
                }
            }
 
          // Do we have a mixed dimensional mesh that contains some of
          // its own interior parents, but we already expect to have
          // interior parents on a different mesh?  That's going to
          // take some work to support if anyone needs it.
          if (separate_interior_mesh)
            libmesh_not_implemented_msg
              ("interior_parent() values in multiple meshes are unsupported.");
        }
    }
 
  // This flag doesn't necessarily mean any Elems actually have
  // interior parent pointers, just that we did all the work to
  // determine whether or not they do.
  _preparation.has_interior_parent_ptrs = true;
}

References _preparation, libMesh::ParallelObject::comm(), libMesh::Elem::dim(), elem_dimensions(), elem_ptr(), elem_ref(), libMesh::MeshBase::Preparation::has_cached_elem_data, libMesh::MeshBase::Preparation::has_interior_parent_ptrs, interior_mesh(), is_serial(), libMesh::make_range(), and libMesh::Parallel::Communicator::set_union().

Referenced by complete_preparation().

◆ elem_default_orders()

const std::set< Order > & libMesh::MeshBase::elem_default_orders ( ) const

inline

Returns: A const reference to a std::set of element default orders present in the mesh.

Definition at line 437 of file mesh_base.h.

438 { return _elem_default_orders; }

References _elem_default_orders.

Referenced by MeshSmootherTest::testVariationalSmoother().

◆ elem_dimensions()

const std::set< unsigned char > & libMesh::MeshBase::elem_dimensions ( ) const

inline

Returns: A const reference to a std::set of element dimensions present in the mesh.

Definition at line 430 of file mesh_base.h.

431 { return _elem_dims; }

References _elem_dims.

Referenced by detect_interior_parents(), libMesh::TreeNode< N >::insert(), and libMesh::VariationalMeshSmoother::setup().

◆ elem_ptr() [1/2]

virtual const Elem * libMesh::MeshBase::elem_ptr ( const dof_id_type i ) const

pure virtual

Returns: A pointer to the \( i^{th} \) element, which should be present in this processor's subset of the mesh data structure.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by NonManifoldTestPartitioner::_do_partition(), libMesh::MeshTools::Subdivision::add_boundary_ghosts(), libMesh::BoundaryInfo::add_edge(), libMesh::BoundaryInfo::add_elements(), libMesh::BoundaryInfo::add_shellface(), libMesh::BoundaryInfo::add_side(), AllSecondOrderTest::allCompleteOrderMixed(), AllSecondOrderTest::allCompleteOrderRange(), AllSecondOrderTest::allSecondOrderMixed(), AllSecondOrderTest::allSecondOrderRange(), DisjointNeighborTest::build_four_disjoint_elems(), copy_constraint_rows(), copy_constraint_rows(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), detect_interior_parents(), libMesh::DTKAdapter::DTKAdapter(), elem_ref(), elem_ref(), libMesh::DTKEvaluator::evaluate(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::ExodusII_IO_Helper::get_sideset_data_indices(), libMesh::UNVIO::groups_in(), libMesh::MeshTetInterface::improve_hull_integrity(), libMesh::ErrorVector::is_active_elem(), libMesh::MeshTools::libmesh_assert_valid_constraint_rows(), LinearElasticityWithContact::move_mesh(), libMesh::MeshTools::n_connected_components(), AugmentSparsityOnNodes::operator()(), libMesh::BoundaryInfo::operator=(), libMesh::BoundaryInfo::parallel_sync_side_ids(), libMesh::DofMap::process_mesh_constraint_rows(), libMesh::query_ghosting_functors(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::ExodusII_IO_Helper::read_edge_blocks(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::ExodusII_IO_Helper::read_sideset_data(), libMesh::UnstructuredMesh::stitching_helper(), VolumeTest::testHex20PLevelTrueCentroid(), InfFERadialTest::testInfQuants(), InfFERadialTest::testInfQuants_numericDeriv(), InfFERadialTest::testRefinement(), EquationSystemsTest::testRefineThenReinitPreserveFlags(), InfFERadialTest::testSides(), InfFERadialTest::testSingleOrder(), VolumeTest::testTwistedVolume(), libMesh::Parallel::Packing< Elem * >::unpack(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO_Helper::write_sideset_data(), and libMesh::ExodusII_IO_Helper::write_sidesets().

◆ elem_ptr() [2/2]

virtual Elem * libMesh::MeshBase::elem_ptr ( const dof_id_type i )

pure virtual

Returns: A writable pointer to the \( i^{th} \) element, which should be present in this processor's subset of the mesh data structure.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

◆ elem_ref() [1/2]

virtual Elem & libMesh::MeshBase::elem_ref ( const dof_id_type i )

inlinevirtual

Returns: A writable reference to the \( i^{th} \) element, which should be present in this processor's subset of the mesh data structure.

Definition at line 798 of file mesh_base.h.

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

References elem_ptr().

◆ elem_ref() [2/2]

virtual const Elem & libMesh::MeshBase::elem_ref ( const dof_id_type i ) const

inlinevirtual

Returns: A reference to the \( i^{th} \) element, which should be present in this processor's subset of the mesh data structure.

Definition at line 788 of file mesh_base.h.

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

References elem_ptr().

Referenced by libMesh::SyncSubdomainIds::act_on_data(), libMesh::SyncElementIntegers::act_on_data(), libMesh::SyncRefinementFlags::act_on_data(), libMesh::AbaqusIO::assign_sideset_ids(), libMesh::AbaqusIO::assign_subdomain_ids(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), detect_interior_parents(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_sides(), libMesh::SyncSubdomainIds::gather_data(), libMesh::SyncElementIntegers::gather_data(), libMesh::SyncRefinementFlags::gather_data(), libMesh::MeshTetInterface::improve_hull_integrity(), main(), MeshPerElemTest< elem_type >::meshes_equal_enough(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectVertices::operator()(), libMesh::RBParametrizedFunction::preevaluate_parametrized_function_on_mesh(), libMesh::RBParametrizedFunction::preevaluate_parametrized_function_on_mesh_sides(), libMesh::ExodusII_IO::read(), libMesh::CheckpointIO::read_remote_elem(), SystemsTest::testDofCouplingWithVarGroups(), MeshExtruderTest::testExtruder(), SystemsTest::testSetSystemParameterOverEquationSystem(), libMesh::FroIO::write(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::Nemesis_IO_Helper::write_elements(), libMesh::GmshIO::write_mesh(), and libMesh::ExodusII_IO_Helper::write_sidesets().

◆ element_stored_range()

const ElemRange & libMesh::MeshBase::element_stored_range ( )

Returns: A reference to a cached vector copy of a range of pointers to all semilocal elements, suitable for threading.

Iterating over all semilocal elements is most useful for modifying the mesh, so we only have a non-const version for now.

Definition at line 1939 of file mesh_base.C.

{
  if (!_element_stored_range)
  {
    // Range construction may not be safe within threads
    libmesh_assert(!Threads::in_threads);
 
    _element_stored_range =
      std::make_unique<ElemRange>(this->elements_begin(),
                                  this->elements_end());
  }
 
  return *_element_stored_range;
}

References _element_stored_range, libMesh::Threads::in_threads, and libMesh::libmesh_assert().

Referenced by libMesh::EquationSystems::allgather(), change_elemset_code(), libMesh::MeshTools::Modification::change_subdomain_id(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::EquationSystems::reinit_mesh(), libMesh::EquationSystems::reinit_solutions(), and size_elem_extra_integers().

◆ find_neighbors()

virtual void libMesh::MeshBase::find_neighbors	(	const bool	reset_remote_elements = `false`,
		const bool	reset_current_list = `true`,
		const bool	assert_valid = `true`
	)

pure virtual

Locate element face (edge in 2D) neighbors.

This is done with the help of a std::map that functions like a hash table. After this routine is called all the elements with a nullptr neighbor pointer are guaranteed to be on the boundary. Thus this routine is useful for automatically determining the boundaries of the domain.

If reset_remote_elements is left to false, remote neighbor links are not reset and searched for in the local mesh.

If reset_current_list is left as true, then any existing links will be reset before initiating the algorithm, while honoring the value of the reset_remote_elements flag.

If assert_valid is left as true, then in dbg mode extensive consistency checking is performed before returning.

Implemented in libMesh::UnstructuredMesh.

Referenced by libMesh::InfElemBuilder::build_inf_elem(), complete_preparation(), main(), MixedOrderTest::testFindNeighbors(), and tetrahedralize_domain().

◆ fix_broken_node_and_element_numbering()

virtual void libMesh::MeshBase::fix_broken_node_and_element_numbering ( )

pure virtual

There is no reason for a user to ever call this function.

This function restores a previously broken element/node numbering such that mesh.node_ref(n).id() == n.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by libMesh::EquationSystems::read(), libMesh::RBEvaluation::read_in_vectors_from_multiple_files(), and libMesh::RBEvaluation::write_out_vectors().

◆ gather_to_zero()

virtual void libMesh::MeshBase::gather_to_zero ( )

inlinevirtual

Gathers all elements and nodes of the mesh onto processor zero.

Reimplemented in libMesh::DistributedMesh.

Definition at line 392 of file mesh_base.h.

392{}

Referenced by libMesh::MeshSerializer::MeshSerializer().

◆ get_boundary_info() [1/2]

BoundaryInfo & libMesh::MeshBase::get_boundary_info ( )

inline

Writable information about boundary ids on the mesh.

Definition at line 175 of file mesh_base.h.

175{ return *boundary_info; }

References boundary_info.

◆ get_boundary_info() [2/2]

const BoundaryInfo & libMesh::MeshBase::get_boundary_info ( ) const

inline

The information about boundary ids on the mesh.

Definition at line 170 of file mesh_base.h.

170{ return *boundary_info; }

References boundary_info.

◆ get_constraint_rows() [1/2]

constraint_rows_type & libMesh::MeshBase::get_constraint_rows ( )

inline

Constraint rows accessors.

Definition at line 1935 of file mesh_base.h.

1936 { return _constraint_rows; }

References _constraint_rows.

Referenced by libMesh::Partitioner::build_graph(), libMesh::MeshTools::clear_spline_nodes(), copy_constraint_rows(), libMesh::DofMap::create_dof_constraints(), libMesh::MeshTools::libmesh_assert_valid_constraint_rows(), locally_equals(), libMesh::MeshTools::n_connected_components(), libMesh::DofMap::process_mesh_constraint_rows(), libMesh::ExodusII_IO::read(), libMesh::DynaIO::read_mesh(), and scale_mesh_and_plot().

◆ get_constraint_rows() [2/2]

const constraint_rows_type & libMesh::MeshBase::get_constraint_rows ( ) const

inline

Definition at line 1938 of file mesh_base.h.

1939 { return _constraint_rows; }

References _constraint_rows.

◆ get_count_lower_dim_elems_in_point_locator()

bool libMesh::MeshBase::get_count_lower_dim_elems_in_point_locator ( ) const

Get the current value of _count_lower_dim_elems_in_point_locator.

Definition at line 1880 of file mesh_base.C.

{
  return _count_lower_dim_elems_in_point_locator;
}

References _count_lower_dim_elems_in_point_locator.

Referenced by libMesh::TreeNode< N >::insert().

◆ get_disjoint_neighbor_boundary_pairs() [1/2]

PeriodicBoundaries * libMesh::MeshBase::get_disjoint_neighbor_boundary_pairs ( )

Definition at line 2296 of file mesh_base.C.

    {
      return _disjoint_neighbor_boundary_pairs.get();
    }

References _disjoint_neighbor_boundary_pairs.

Referenced by libMesh::UnstructuredMesh::find_neighbors(), libMesh::UnstructuredMesh::stitching_helper(), DisjointNeighborTest::testPreserveDisjointNeighborPairsAfterStitch(), and DisjointNeighborTest::testStitchCrossMesh().

◆ get_disjoint_neighbor_boundary_pairs() [2/2]

const PeriodicBoundaries * libMesh::MeshBase::get_disjoint_neighbor_boundary_pairs ( ) const

Definition at line 2301 of file mesh_base.C.

    {
      return _disjoint_neighbor_boundary_pairs.get();
    }

References _disjoint_neighbor_boundary_pairs.

◆ get_elem_integer_index()

unsigned int libMesh::MeshBase::get_elem_integer_index ( std::string_view name ) const

Definition at line 689 of file mesh_base.C.

{
  for (auto i : index_range(_elem_integer_names))
    if (_elem_integer_names[i] == name)
      return i;
 
  libmesh_error_msg("Unknown elem integer " << name);
  return libMesh::invalid_uint;
}

References _elem_integer_names, libMesh::index_range(), and libMesh::invalid_uint.

Referenced by change_elemset_code(), WriteElemsetData::checkElemsetCodes(), ExtraIntegersTest::testExtraIntegersExodusReading(), and libMesh::ExodusII_IO_Helper::write_elemsets().

◆ get_elem_integer_name()

const std::string & libMesh::MeshBase::get_elem_integer_name ( unsigned int i ) const

inline

Definition at line 1079 of file mesh_base.h.

1080 { return _elem_integer_names[i]; }

References _elem_integer_names.

Referenced by libMesh::XdrIO::write(), and libMesh::CheckpointIO::write().

◆ get_elemset_code()

dof_id_type libMesh::MeshBase::get_elemset_code ( const MeshBase::elemset_type & id_set ) const

Definition at line 497 of file mesh_base.C.

{
  auto it = _elemset_codes_inverse_map.find(id_set);
  return (it == _elemset_codes_inverse_map.end()) ? DofObject::invalid_id : it->second;
}

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

Referenced by WriteElemsetData::checkElemsetCodes(), and libMesh::ExodusII_IO::read().

◆ get_elemset_codes()

std::vector< dof_id_type > libMesh::MeshBase::get_elemset_codes ( ) const

Return a vector of all elemset codes defined on the mesh.

We get this by looping over the _elemset_codes map.

Definition at line 503 of file mesh_base.C.

{
  std::vector<dof_id_type> ret;
  ret.reserve(_elemset_codes.size());
  for (const auto & pr : _elemset_codes)
    ret.push_back(pr.first);
  return ret;
}

References _elemset_codes.

Referenced by libMesh::UnstructuredMesh::stitching_helper(), and libMesh::XdrIO::write().

◆ get_elemsets()

void libMesh::MeshBase::get_elemsets	(	dof_id_type	elemset_code,
		MeshBase::elemset_type &	id_set_to_fill
	)		const

Look up the element sets for a given elemset code and vice-versa.

The elemset must have been previously stored by calling add_elemset_code(). If no such code/set is found, returns the empty set or DofObject::invalid_id, respectively.

Definition at line 487 of file mesh_base.C.

{
  // If we don't recognize this elemset_code, hand back an empty set
  id_set_to_fill.clear();
 
  if (const auto it = _elemset_codes.find(elemset_code);
      it != _elemset_codes.end())
    id_set_to_fill.insert(it->second->begin(), it->second->end());
}

References _elemset_codes.

Referenced by libMesh::UnstructuredMesh::stitching_helper(), WriteElemsetData::testWriteImpl(), libMesh::XdrIO::write(), and libMesh::ExodusII_IO_Helper::write_elemsets().

◆ get_id_by_name()

subdomain_id_type libMesh::MeshBase::get_id_by_name ( std::string_view name ) const

Returns: The id of the named subdomain if it exists, Elem::invalid_subdomain_id otherwise.

Definition at line 1926 of file mesh_base.C.

{
  // Linear search over the map values.
  for (const auto & [sbd_id, sbd_name] : _block_id_to_name)
    if (sbd_name == name)
      return sbd_id;
 
  // If we made it here without returning, we don't have a subdomain
  // with the requested name, so return Elem::invalid_subdomain_id.
  return Elem::invalid_subdomain_id;
}

References _block_id_to_name, and libMesh::Elem::invalid_subdomain_id.

◆ get_info()

std::string libMesh::MeshBase::get_info	(	const unsigned int	verbosity = `0`,
		const bool	global = `true`
	)		const

Returns: A string containing relevant information about the mesh.

verbosity sets the verbosity, with 0 being the least and 2 being the greatest. 0 - Dimensions, number of nodes, number of elems, number of subdomains, number of partitions, prepared status. 1 - Adds the mesh bounding box, mesh element types, specific nodesets/edgesets/sidesets with element types, number of nodes/edges/sides. 2 - Adds volume information and bounding boxes to boundary information.

The global parameter pertains primarily to verbosity levels 1 and above. When global == true, information is only output on rank 0 and the information is reduced. When global == false, information is output on all ranks that pertains only to that local partition.

Definition at line 1275 of file mesh_base.C.

{
  std::ostringstream oss;
 
  oss << " Mesh Information:" << '\n';
 
  if (!_elem_dims.empty())
    {
      oss << "  elem_dimensions()={";
      std::copy(_elem_dims.begin(),
                --_elem_dims.end(), // --end() is valid if the set is non-empty
                std::ostream_iterator<unsigned int>(oss, ", "));
      oss << cast_int<unsigned int>(*_elem_dims.rbegin());
      oss << "}\n";
    }
 
  if (!_elem_default_orders.empty())
    {
      oss << "  elem_default_orders()={";
      std::transform(_elem_default_orders.begin(),
                     --_elem_default_orders.end(),
                     std::ostream_iterator<std::string>(oss, ", "),
                     [](Order o)
                       { return Utility::enum_to_string<Order>(o); });
      oss << Utility::enum_to_string<Order>(*_elem_default_orders.rbegin());
      oss << "}\n";
    }
 
  oss << "  supported_nodal_order()=" << this->supported_nodal_order()                        << '\n'
      << "  spatial_dimension()="     << this->spatial_dimension()                            << '\n'
      << "  n_nodes()="               << this->n_nodes()                                      << '\n'
      << "    n_local_nodes()="       << this->n_local_nodes()                                << '\n'
      << "  n_elem()="                << this->n_elem()                                       << '\n'
      << "    n_local_elem()="        << this->n_local_elem()                                 << '\n';
#ifdef LIBMESH_ENABLE_AMR
  oss << "    n_active_elem()="       << this->n_active_elem()                                << '\n';
#endif
  if (global)
    oss << "  n_subdomains()="        << static_cast<std::size_t>(this->n_subdomains())       << '\n';
  else
    oss << "  n_local_subdomains()= " << static_cast<std::size_t>(this->n_local_subdomains()) << '\n';
  oss << "  n_elemsets()="            << static_cast<std::size_t>(this->n_elemsets())         << '\n';
  if (!_elemset_codes.empty())
    oss << "    n_elemset_codes="     << _elemset_codes.size()                                << '\n';
  oss << "  n_partitions()="          << static_cast<std::size_t>(this->n_partitions())       << '\n'
      << "  n_processors()="          << static_cast<std::size_t>(this->n_processors())       << '\n'
      << "  n_threads()="             << static_cast<std::size_t>(libMesh::n_threads())       << '\n'
      << "  processor_id()="          << static_cast<std::size_t>(this->processor_id())       << '\n'
      << "  is_prepared()="           << (this->is_prepared() ? "true" : "false")             << '\n'
      << "  is_replicated()="         << (this->is_replicated() ? "true" : "false")           << '\n';
 
  if (verbosity > 0)
    {
      if (global)
        {
          libmesh_parallel_only(this->comm());
          if (this->processor_id() != 0)
            oss << "\n Detailed global get_info() (verbosity > 0) is reduced and output to only rank 0.";
        }
 
      // Helper for printing element types
      const auto elem_type_helper = [](const std::set<int> & elem_types) {
        std::stringstream ss;
        for (auto it = elem_types.begin(); it != elem_types.end();)
          {
            ss << Utility::enum_to_string((ElemType)*it);
            if (++it != elem_types.end())
              ss << ", ";
          }
        return ss.str();
      };
 
      // Helper for whether or not the given DofObject is to be included. If we're doing
      // a global reduction, we also count unpartitioned objects on rank 0.
      const auto include_object = [this, &global](const DofObject & dof_object) {
        return this->processor_id() == dof_object.processor_id() ||
               (global &&
                this->processor_id() == 0 &&
                dof_object.processor_id() == DofObject::invalid_processor_id);
      };
 
      Real volume = 0;
 
      // Add bounding box information
      const auto bbox = global ? MeshTools::create_bounding_box(*this) : MeshTools::create_local_bounding_box(*this);
      if (!global || this->processor_id() == 0)
        oss << "\n " << (global ? "" : "Local ") << "Mesh Bounding Box:\n"
            << "  Minimum: " << bbox.min()                << "\n"
            << "  Maximum: " << bbox.max()                << "\n"
            << "  Delta:   " << (bbox.max() - bbox.min()) << "\n";
 
      // Obtain the global or local element types
      std::set<int> elem_types;
      for (const Elem * elem : this->active_local_element_ptr_range())
        elem_types.insert(elem->type());
      if (global)
        {
          // Pick up unpartitioned elems on rank 0
          if (this->processor_id() == 0)
            for (const Elem * elem : this->active_unpartitioned_element_ptr_range())
              elem_types.insert(elem->type());
 
          this->comm().set_union(elem_types);
        }
 
      // Add element types
      if (!global || this->processor_id() == 0)
        oss << "\n " << (global ? "" : "Local ") << "Mesh Element Type(s):\n  "
            << elem_type_helper(elem_types) << "\n";
 
      // Reduce the nodeset ids
      auto nodeset_ids = this->get_boundary_info().get_node_boundary_ids();
      if (global)
        this->comm().set_union(nodeset_ids);
 
      // Accumulate local information for each nodeset
      struct NodesetInfo
      {
        std::size_t num_nodes = 0;
        BoundingBox bbox;
      };
      std::map<boundary_id_type, NodesetInfo> nodeset_info_map;
      for (const auto & [node, id] : this->get_boundary_info().get_nodeset_map())
        {
          if (!include_object(*node))
            continue;
 
          NodesetInfo & info = nodeset_info_map[id];
 
          ++info.num_nodes;
 
          if (verbosity > 1)
            info.bbox.union_with(*node);
        }
 
      // Add nodeset info
      if (!global || this->processor_id() == 0)
        {
          oss << "\n " << (global ? "" : "Local ") << "Mesh Nodesets:\n";
          if (nodeset_ids.empty())
            oss << "  None\n";
        }
 
      const auto & nodeset_name_map = this->get_boundary_info().get_nodeset_name_map();
      for (const auto id : nodeset_ids)
        {
          NodesetInfo & info = nodeset_info_map[id];
 
          // Reduce the local information for this nodeset if required
          if (global)
            {
              this->comm().sum(info.num_nodes);
              if (verbosity > 1)
                {
                  this->comm().min(info.bbox.min());
                  this->comm().max(info.bbox.max());
                }
            }
 
          const bool has_name = nodeset_name_map.count(id) && nodeset_name_map.at(id).size();
          const std::string name = has_name ? nodeset_name_map.at(id) : "";
          if (global)
            libmesh_assert(this->comm().verify(name));
 
          if (global ? this->processor_id() == 0 : info.num_nodes > 0)
            {
              oss << "  Nodeset " << id;
              if (has_name)
                oss << " (" << name << ")";
              oss << ", " << info.num_nodes << " " << (global ? "" : "local ") << "nodes\n";
 
              if (verbosity > 1)
              {
                oss << "   " << (global ? "Bounding" : "Local bounding") << " box minimum: "
                    << info.bbox.min() << "\n"
                    << "   " << (global ? "Bounding" : "Local bounding") << " box maximum: "
                    << info.bbox.max() << "\n"
                    << "   " << (global ? "Bounding" : "Local bounding") << " box delta: "
                    << (info.bbox.max() - info.bbox.min()) << "\n";
              }
            }
        }
 
      // Reduce the sideset ids
      auto sideset_ids = this->get_boundary_info().get_side_boundary_ids();
      if (global)
        this->comm().set_union(sideset_ids);
 
      // Accumulate local information for each sideset
      struct SidesetInfo
      {
        std::size_t num_sides = 0;
        Real volume = 0;
        std::set<int> side_elem_types;
        std::set<int> elem_types;
        std::set<dof_id_type> elem_ids;
        std::set<dof_id_type> node_ids;
        BoundingBox bbox;
      };
      ElemSideBuilder side_builder;
      std::map<boundary_id_type, SidesetInfo> sideset_info_map;
      for (const auto & pair : this->get_boundary_info().get_sideset_map())
        {
          const Elem * elem = pair.first;
          if (!include_object(*elem))
            continue;
 
          const auto id = pair.second.second;
          SidesetInfo & info = sideset_info_map[id];
 
          const auto s = pair.second.first;
          const Elem & side = side_builder(*elem, s);
 
          ++info.num_sides;
          info.side_elem_types.insert(side.type());
          info.elem_types.insert(elem->type());
          info.elem_ids.insert(elem->id());
 
          for (const Node & node : side.node_ref_range())
            if (include_object(node))
              info.node_ids.insert(node.id());
 
          if (verbosity > 1)
          {
            info.volume += side.volume();
            info.bbox.union_with(side.loose_bounding_box());
          }
        }
 
      // Add sideset info
      if (!global || this->processor_id() == 0)
        {
          oss << "\n " << (global ? "" : "Local ") << "Mesh Sidesets:\n";
          if (sideset_ids.empty())
            oss << "  None\n";
        }
      const auto & sideset_name_map = this->get_boundary_info().get_sideset_name_map();
      for (const auto id : sideset_ids)
        {
          SidesetInfo & info = sideset_info_map[id];
 
          auto num_elems = info.elem_ids.size();
          auto num_nodes = info.node_ids.size();
 
          // Reduce the local information for this sideset if required
          if (global)
            {
              this->comm().sum(info.num_sides);
              this->comm().set_union(info.side_elem_types, 0);
              this->comm().sum(num_elems);
              this->comm().set_union(info.elem_types, 0);
              this->comm().sum(num_nodes);
              if (verbosity > 1)
              {
                this->comm().sum(info.volume);
                this->comm().min(info.bbox.min());
                this->comm().max(info.bbox.max());
              }
            }
 
          const bool has_name = sideset_name_map.count(id) && sideset_name_map.at(id).size();
          const std::string name = has_name ? sideset_name_map.at(id) : "";
          if (global)
            libmesh_assert(this->comm().verify(name));
 
          if (global ? this->processor_id() == 0 : info.num_sides > 0)
            {
              oss << "  Sideset " << id;
              if (has_name)
                oss << " (" << name << ")";
              oss << ", " << info.num_sides << " sides (" << elem_type_helper(info.side_elem_types) << ")"
                  << ", " << num_elems << " " << (global ? "" : "local ") << "elems (" << elem_type_helper(info.elem_types) << ")"
                  << ", " << num_nodes << " " << (global ? "" : "local ") << "nodes\n";
 
              if (verbosity > 1)
              {
                oss << "   " << (global ? "Side" : "Local side") << " volume: " << info.volume << "\n"
                    << "   " << (global ? "Bounding" : "Local bounding") << " box minimum: "
                    << info.bbox.min() << "\n"
                    << "   " << (global ? "Bounding" : "Local bounding") << " box maximum: "
                    << info.bbox.max() << "\n"
                    << "   " << (global ? "Bounding" : "Local bounding") << " box delta: "
                    << (info.bbox.max() - info.bbox.min()) << "\n";
              }
            }
        }
 
      // Reduce the edgeset ids
      auto edgeset_ids = this->get_boundary_info().get_edge_boundary_ids();
      if (global)
        this->comm().set_union(edgeset_ids);
 
      // Accumulate local information for each edgeset
      struct EdgesetInfo
      {
        std::size_t num_edges = 0;
        std::set<int> edge_elem_types;
        BoundingBox bbox;
      };
      std::map<boundary_id_type, EdgesetInfo> edgeset_info_map;
      std::unique_ptr<const Elem> edge;
 
      for (const auto & pair : this->get_boundary_info().get_edgeset_map())
        {
          const Elem * elem = pair.first;
          if (!include_object(*elem))
            continue;
 
          const auto id = pair.second.second;
          EdgesetInfo & info = edgeset_info_map[id];
 
          elem->build_edge_ptr(edge, pair.second.first);
 
          ++info.num_edges;
          info.edge_elem_types.insert(edge->type());
 
          if (verbosity > 1)
            info.bbox.union_with(edge->loose_bounding_box());
        }
 
      // Add edgeset info
      if (!global || this->processor_id() == 0)
        {
          oss << "\n " << (global ? "" : "Local ") << "Mesh Edgesets:\n";
          if (edgeset_ids.empty())
            oss << "  None\n";
        }
 
      const auto & edgeset_name_map = this->get_boundary_info().get_edgeset_name_map();
      for (const auto id : edgeset_ids)
        {
          EdgesetInfo & info = edgeset_info_map[id];
 
          // Reduce the local information for this edgeset if required
          if (global)
            {
              this->comm().sum(info.num_edges);
              this->comm().set_union(info.edge_elem_types, 0);
              if (verbosity > 1)
                {
                  this->comm().min(info.bbox.min());
                  this->comm().min(info.bbox.max());
                }
            }
 
          const bool has_name = edgeset_name_map.count(id) && edgeset_name_map.at(id).size();
          const std::string name = has_name ? edgeset_name_map.at(id) : "";
          if (global)
            libmesh_assert(this->comm().verify(name));
 
          if (global ? this->processor_id() == 0 : info.num_edges > 0)
            {
              oss << "  Edgeset " << id;
              if (has_name)
                oss << " (" << name << ")";
              oss << ", " << info.num_edges << " " << (global ? "" : "local ") << "edges ("
                  << elem_type_helper(info.edge_elem_types) << ")\n";
 
              if (verbosity > 1)
              {
                oss << "   " << (global ? "Bounding" : "Local bounding") << " box minimum: "
                    << info.bbox.min() << "\n"
                    << "   " << (global ? "Bounding" : "Local bounding") << " box maximum: "
                    << info.bbox.max() << "\n"
                    << "   " << (global ? "Bounding" : "Local bounding") << " box delta: "
                    << (info.bbox.max() - info.bbox.min()) << "\n";
              }
            }
        }
 
      // Reduce the block IDs and block names
      std::set<subdomain_id_type> subdomains;
      for (const Elem * elem : this->active_element_ptr_range())
        if (include_object(*elem))
          subdomains.insert(elem->subdomain_id());
      if (global)
        this->comm().set_union(subdomains);
 
      // Accumulate local information for each subdomain
      struct SubdomainInfo
      {
        std::size_t num_elems = 0;
        Real volume = 0;
        std::set<int> elem_types;
        std::set<dof_id_type> active_node_ids;
#ifdef LIBMESH_ENABLE_AMR
        std::size_t num_active_elems = 0;
#endif
        BoundingBox bbox;
      };
      std::map<subdomain_id_type, SubdomainInfo> subdomain_info_map;
      for (const Elem * elem : this->element_ptr_range())
        if (include_object(*elem))
          {
            SubdomainInfo & info = subdomain_info_map[elem->subdomain_id()];
 
            ++info.num_elems;
            info.elem_types.insert(elem->type());
 
#ifdef LIBMESH_ENABLE_AMR
            if (elem->active())
              ++info.num_active_elems;
#endif
 
            for (const Node & node : elem->node_ref_range())
              if (include_object(node) && node.active())
                info.active_node_ids.insert(node.id());
 
            if (verbosity > 1 && elem->active())
              {
                info.volume += elem->volume();
                info.bbox.union_with(elem->loose_bounding_box());
              }
          }
 
      // Add subdomain info
      oss << "\n " << (global ? "" : "Local ") << "Mesh Subdomains:\n";
      const auto & subdomain_name_map = this->get_subdomain_name_map();
      for (const auto id : subdomains)
      {
        SubdomainInfo & info = subdomain_info_map[id];
 
        auto num_active_nodes = info.active_node_ids.size();
 
        // Reduce the information for this subdomain if needed
        if (global)
          {
            this->comm().sum(info.num_elems);
#ifdef LIBMESH_ENABLE_AMR
            this->comm().sum(info.num_active_elems);
#endif
            this->comm().sum(num_active_nodes);
            this->comm().set_union(info.elem_types, 0);
            if (verbosity > 1)
            {
              this->comm().min(info.bbox.min());
              this->comm().max(info.bbox.max());
              this->comm().sum(info.volume);
            }
          }
        if (verbosity > 1)
          volume += info.volume;
 
        const bool has_name = subdomain_name_map.count(id);
        const std::string name = has_name ? subdomain_name_map.at(id) : "";
        if (global)
          libmesh_assert(this->comm().verify(name));
 
        if (!global || this->processor_id() == 0)
          {
            oss << "  Subdomain " << id;
            if (has_name)
              oss << " (" << name << ")";
            oss << ": " << info.num_elems << " " << (global ? "" : "local ") << "elems "
                << "(" << elem_type_helper(info.elem_types);
#ifdef LIBMESH_ENABLE_AMR
            oss << ", " << info.num_active_elems << " active";
#endif
            oss << "), " << num_active_nodes << " " << (global ? "" : "local ") << "active nodes\n";
            if (verbosity > 1)
            {
              oss << "   " << (global ? "Volume" : "Local volume") << ": " << info.volume << "\n";
              oss << "   " << (global ? "Bounding" : "Local bounding") << " box minimum: "
                  << info.bbox.min() << "\n"
                  << "   " << (global ? "Bounding" : "Local bounding") << " box maximum: "
                  << info.bbox.max() << "\n"
                  << "   " << (global ? "Bounding" : "Local bounding") << " box delta: "
                  << (info.bbox.max() - info.bbox.min()) << "\n";
            }
          }
      }
 
      oss << "  " << (global ? "Global" : "Local") << " mesh volume = " << volume << "\n";
 
    }
 
  return oss.str();
}

Referenced by print_info().

◆ get_local_constraints()

std::string libMesh::MeshBase::get_local_constraints ( bool print_nonlocal = false ) const

Gets a string reporting all mesh constraint rows local to this processor.

If print_nonlocal is true, then nonlocal constraints which are locally known are included.

Definition at line 2811 of file mesh_base.C.

{
  std::ostringstream os;
 
  if (print_nonlocal)
    os << "All ";
  else
    os << "Local ";
 
  os << "Mesh Constraint Rows:"
     << std::endl;
 
  for (const auto & [node, row] : _constraint_rows)
    {
      const bool local = (node->processor_id() == this->processor_id());
 
      // Skip non-local dofs if requested
      if (!print_nonlocal && !local)
        continue;
 
      os << "Constraints for " << (local ? "Local" : "Ghost") << " Node " << node->id()
         << ": \t";
 
      for (const auto & [elem_and_node, coef] : row)
        os << " ((" << elem_and_node.first->id() << ',' << elem_and_node.second << "), " << coef << ")\t";
 
      os << std::endl;
    }
 
  return os.str();
}

References _constraint_rows, and libMesh::ParallelObject::processor_id().

Referenced by print_constraint_rows().

◆ get_mesh_subdomains()

const std::set< subdomain_id_type > & libMesh::MeshBase::get_mesh_subdomains ( ) const

inline

Returns: The cached mesh subdomains. As long as the mesh is prepared, this should contain all the subdomain ids across processors. Relies on the mesh being prepared

Definition at line 2057 of file mesh_base.h.

2058 { libmesh_assert(this->is_prepared()); return _mesh_subdomains; }

References _mesh_subdomains, is_prepared(), and libMesh::libmesh_assert().

◆ get_node_integer_index()

unsigned int libMesh::MeshBase::get_node_integer_index ( std::string_view name ) const

Definition at line 778 of file mesh_base.C.

{
  for (auto i : index_range(_node_integer_names))
    if (_node_integer_names[i] == name)
      return i;
 
  libmesh_error_msg("Unknown node integer " << name);
  return libMesh::invalid_uint;
}

References _node_integer_names, libMesh::index_range(), and libMesh::invalid_uint.

◆ get_node_integer_name()

const std::string & libMesh::MeshBase::get_node_integer_name ( unsigned int i ) const

inline

Definition at line 1201 of file mesh_base.h.

1202 { return _node_integer_names[i]; }

References _node_integer_names.

Referenced by libMesh::XdrIO::write(), and libMesh::CheckpointIO::write().

◆ get_point_locator_close_to_point_tol()

Real libMesh::MeshBase::get_point_locator_close_to_point_tol ( ) const

Definition at line 2354 of file mesh_base.C.

{
  return _point_locator_close_to_point_tol;
}

References _point_locator_close_to_point_tol.

◆ get_subdomain_name_map()

const std::map< subdomain_id_type, std::string > & libMesh::MeshBase::get_subdomain_name_map ( ) const

inline

Definition at line 1926 of file mesh_base.h.

1927 { return _block_id_to_name; }

References _block_id_to_name.

Referenced by libMesh::DistributedMesh::DistributedMesh(), get_info(), libMesh::ReplicatedMesh::ReplicatedMesh(), libMesh::UnstructuredMesh::stitching_helper(), MeshInputTest::testGmshBCIDOverlap(), libMesh::XdrIO::write_serialized_subdomain_names(), and libMesh::CheckpointIO::write_subdomain_names().

◆ ghosting_functors_begin()

GhostingFunctorIterator libMesh::MeshBase::ghosting_functors_begin ( ) const

inline

Beginning of range of ghosting functors.

Definition at line 1472 of file mesh_base.h.

1473 { return _ghosting_functors.begin(); }

References _ghosting_functors.

Referenced by libMesh::UnstructuredMesh::contract(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::query_ghosting_functors(), redistribute(), and EquationSystemsTest::testDisableDefaultGhosting().

◆ ghosting_functors_end()

GhostingFunctorIterator libMesh::MeshBase::ghosting_functors_end ( ) const

inline

End of range of ghosting functors.

Definition at line 1478 of file mesh_base.h.

1479 { return _ghosting_functors.end(); }

References _ghosting_functors.

Referenced by libMesh::UnstructuredMesh::contract(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::query_ghosting_functors(), redistribute(), and EquationSystemsTest::testDisableDefaultGhosting().

◆ has_elem_integer()

bool libMesh::MeshBase::has_elem_integer ( std::string_view name ) const

Definition at line 701 of file mesh_base.C.

{
  for (auto & entry : _elem_integer_names)
    if (entry == name)
      return true;
 
  return false;
}

References _elem_integer_names.

Referenced by change_elemset_code(), WriteElemsetData::checkElemsetCodes(), ExtraIntegersTest::checkpoint_helper(), libMesh::ExodusII_IO_Helper::initialize(), ExtraIntegersTest::testExtraIntegersExodusReading(), and libMesh::ExodusII_IO_Helper::write_elemsets().

◆ has_node_integer()

bool libMesh::MeshBase::has_node_integer ( std::string_view name ) const

Definition at line 790 of file mesh_base.C.

{
  for (auto & entry : _node_integer_names)
    if (entry == name)
      return true;
 
  return false;
}

References _node_integer_names.

Referenced by ExtraIntegersTest::checkpoint_helper().

◆ insert_elem() [1/2]

virtual Elem * libMesh::MeshBase::insert_elem ( Elem * e )

pure virtual

Insert elem e to the element array, preserving its id and replacing/deleting any existing element with the same id.

Users should call MeshBase::complete_preparation() after elements are added to and/or deleted from the mesh.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by libMesh::UnstructuredMesh::all_first_order(), and libMesh::MeshTools::Subdivision::all_subdivision().

◆ insert_elem() [2/2]

virtual Elem * libMesh::MeshBase::insert_elem ( std::unique_ptr< Elem > e )

pure virtual

Version of insert_elem() taking a std::unique_ptr by value.

The version taking a dumb pointer will eventually be deprecated in favor of this version. This API is intended to indicate that ownership of the Elem is transferred to the Mesh when this function is called, and it should play more nicely with the Elem::build() API which has always returned a std::unique_ptr.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

◆ interior_mesh() [1/2]

MeshBase & libMesh::MeshBase::interior_mesh ( )

inline

Returns: A writeable reference to the interior mesh.

Definition at line 2045 of file mesh_base.h.

2045{ return *_interior_mesh; }

References _interior_mesh.

◆ interior_mesh() [2/2]

const MeshBase & libMesh::MeshBase::interior_mesh ( ) const

inline

Returns: A mesh that may own interior parents of elements in this mesh. In most cases this mesh includes its own interior parents, but in cases where a separate "interior" mesh was used to create this mesh as a distinct lower-dimensional boundary (or boundary subset) mesh, the original mesh will be returned here.

Definition at line 2040 of file mesh_base.h.

2040{ return *_interior_mesh; }

References _interior_mesh.

Referenced by libMesh::BoundaryInfo::add_elements(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), detect_interior_parents(), and libMesh::Parallel::Packing< Elem * >::unpack().

◆ is_prepared()

bool libMesh::MeshBase::is_prepared ( ) const

Returns: true if the mesh is marked as having undergone all of the preparation done in a call to prepare_for_use, false otherwise.

Definition at line 1064 of file mesh_base.C.

{
  return static_cast<bool>(_preparation);
}

References _preparation.

Referenced by libMesh::MeshTools::Modification::all_tri(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::DofMap::create_dof_constraints(), libMesh::MeshTools::Modification::flatten(), get_info(), get_mesh_subdomains(), libMesh::SimplexRefiner::refine_elements(), libMesh::UnstructuredMesh::stitching_helper(), ConstraintOperatorTest::test1DCoarseningNewNodes(), ConstraintOperatorTest::test1DCoarseningOperator(), ConstraintOperatorTest::testCoreform(), MeshBaseTest::testMeshBaseVerifyHasCachedElemData(), MeshBaseTest::testMeshBaseVerifyHasNeighborPtrs(), MeshBaseTest::testMeshBaseVerifyRemovalPreparation(), libMesh::MeshTools::valid_is_prepared(), and libMesh::MeshTetInterface::volume_to_surface_mesh().

◆ is_replicated()

virtual bool libMesh::MeshBase::is_replicated ( ) const

inlinevirtual

Returns: true if new elements and nodes can and should be created in synchronization on all processors, false otherwise

Reimplemented in libMesh::DistributedMesh.

Definition at line 379 of file mesh_base.h.

380 { return true; }

Referenced by libMesh::BoundaryInfo::add_elements(), libMesh::MeshTools::Modification::all_tri(), libMesh::MeshTools::Modification::flatten(), get_info(), main(), libMesh::CheckpointIO::read(), libMesh::SimplexRefiner::refine_via_edges(), and libMesh::MeshTetInterface::volume_to_surface_mesh().

◆ is_serial()

virtual bool libMesh::MeshBase::is_serial ( ) const

inlinevirtual

Returns: true if all elements and nodes of the mesh exist on the current processor, false otherwise

Reimplemented in libMesh::DistributedMesh.

Definition at line 357 of file mesh_base.h.

358 { return true; }

◆ is_serial_on_zero()

virtual bool libMesh::MeshBase::is_serial_on_zero ( ) const

inlinevirtual

Returns: true if all elements and nodes of the mesh exist on the processor 0, false otherwise

Reimplemented in libMesh::DistributedMesh.

Definition at line 364 of file mesh_base.h.

365 { return true; }

Referenced by libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_nodal_solution(), and libMesh::MeshTools::n_connected_components().

◆ libmesh_assert_valid_parallel_ids()

virtual void libMesh::MeshBase::libmesh_assert_valid_parallel_ids ( ) const

inlinevirtual

Verify id and processor_id consistency of our elements and nodes containers.

Calls libmesh_assert() on each possible failure. Currently only implemented on DistributedMesh; a serial data structure is much harder to get out of sync.

Reimplemented in libMesh::DistributedMesh.

Definition at line 1698 of file mesh_base.h.

1698{}

Referenced by libMesh::InfElemBuilder::build_inf_elem().

◆ locally_equals()

bool libMesh::MeshBase::locally_equals ( const MeshBase & other_mesh ) const

This behaves the same as operator==, but only for the local and ghosted aspects of the mesh; i.e.

operator== is true iff local equality is true on every rank.

Definition at line 281 of file mesh_base.C.

{
  // Check whether (almost) everything in the base is equal
  //
  // We don't check _next_unique_id here, because it's expected to
  // change in a DistributedMesh prepare_for_use(); it's conceptually
  // "mutable".
  //
  // We use separate if statements instead of logical operators here,
  // to make it easy to see the failing condition when using a
  // debugger to figure out why a MeshTools::valid_is_prepared(mesh)
  // is failing.
  if (_n_parts != other_mesh._n_parts)
    return false;
  if (_default_mapping_type != other_mesh._default_mapping_type)
    return false;
  if (_default_mapping_data != other_mesh._default_mapping_data)
    return false;
  if (_preparation != other_mesh._preparation)
    return false;
  if (_count_lower_dim_elems_in_point_locator !=
        other_mesh._count_lower_dim_elems_in_point_locator)
    return false;
 
  // We should either both have our own interior parents or both not;
  // but if we both don't then we can't really assert anything else
  // because pointing at the same interior mesh is fair but so is
  // pointing at two different copies of "the same" interior mesh.
  if ((_interior_mesh == this) !=
      (other_mesh._interior_mesh == &other_mesh))
    return false;
 
  if (_skip_noncritical_partitioning != other_mesh._skip_noncritical_partitioning)
    return false;
  if (_skip_all_partitioning != other_mesh._skip_all_partitioning)
    return false;
  if (_skip_renumber_nodes_and_elements != other_mesh._skip_renumber_nodes_and_elements)
    return false;
  if (_skip_find_neighbors != other_mesh._skip_find_neighbors)
    return false;
  if (_skip_detect_interior_parents != other_mesh._skip_detect_interior_parents)
    return false;
  if (_allow_remote_element_removal != other_mesh._allow_remote_element_removal)
    return false;
  if (_allow_node_and_elem_unique_id_overlap != other_mesh._allow_node_and_elem_unique_id_overlap)
    return false;
  if (_spatial_dimension != other_mesh._spatial_dimension)
    return false;
  if (_point_locator_close_to_point_tol != other_mesh._point_locator_close_to_point_tol)
    return false;
  if (_block_id_to_name != other_mesh._block_id_to_name)
    return false;
  if (_elem_dims != other_mesh._elem_dims)
    return false;
  if (_elem_default_orders != other_mesh._elem_default_orders)
    return false;
  if (_supported_nodal_order != other_mesh._supported_nodal_order)
    return false;
  if (_mesh_subdomains != other_mesh._mesh_subdomains)
    return false;
  if (_all_elemset_ids != other_mesh._all_elemset_ids)
    return false;
  if (_elem_integer_names != other_mesh._elem_integer_names)
    return false;
  if (_elem_integer_default_values != other_mesh._elem_integer_default_values)
    return false;
  if (_node_integer_names != other_mesh._node_integer_names)
    return false;
  if (_node_integer_default_values != other_mesh._node_integer_default_values)
    return false;
  if (static_cast<bool>(_default_ghosting) != static_cast<bool>(other_mesh._default_ghosting))
    return false;
  if (static_cast<bool>(_partitioner) != static_cast<bool>(other_mesh._partitioner))
    return false;
  if (*boundary_info != *other_mesh.boundary_info)
    return false;
 
  // First check whether the "existence" of the two pointers differs (one present, one absent)
  if (static_cast<bool>(_disjoint_neighbor_boundary_pairs) !=
      static_cast<bool>(other_mesh._disjoint_neighbor_boundary_pairs))
    return false;
  // If both exist, compare the contents (Weak Test: just compare sizes like `_ghosting_functors`)
  if (_disjoint_neighbor_boundary_pairs &&
      (_disjoint_neighbor_boundary_pairs->size() != other_mesh._disjoint_neighbor_boundary_pairs->size()))
    return false;
 
  const constraint_rows_type & other_rows =
    other_mesh.get_constraint_rows();
  for (const auto & [node, row] : this->_constraint_rows)
    {
      const dof_id_type node_id = node->id();
      const Node * other_node = other_mesh.query_node_ptr(node_id);
      if (!other_node)
        return false;
 
      auto it = other_rows.find(other_node);
      if (it == other_rows.end())
        return false;
 
      const auto & other_row = it->second;
      if (row.size() != other_row.size())
        return false;
 
      for (auto i : index_range(row))
        {
          const auto & [elem_pair, coef] = row[i];
          const auto & [other_elem_pair, other_coef] = other_row[i];
          libmesh_assert(elem_pair.first);
          libmesh_assert(other_elem_pair.first);
          if (elem_pair.first->id() !=
              other_elem_pair.first->id() ||
              elem_pair.second !=
              other_elem_pair.second ||
              coef != other_coef)
            return false;
        }
    }
 
  for (const auto & [elemset_code, elemset_ptr] : this->_elemset_codes)
    if (const auto it = other_mesh._elemset_codes.find(elemset_code);
        it == other_mesh._elemset_codes.end() || *elemset_ptr != *it->second)
      return false;
 
  // FIXME: we have no good way to compare ghosting functors, since
  // they're in a vector of pointers, and we have no way *at all*
  // to compare ghosting functors, since they don't have operator==
  // defined and we encourage users to subclass them.  We can check if
  // we have the same number, is all.
  if (_ghosting_functors.size() !=
      other_mesh._ghosting_functors.size())
    return false;
 
  // Same deal for partitioners.  We tested that we both have one or
  // both don't, but are they equivalent?  Let's guess "yes".
 
  // Now let the subclasses decide whether everything else is equal
  return this->subclass_locally_equals(other_mesh);
}

References _all_elemset_ids, _allow_node_and_elem_unique_id_overlap, _allow_remote_element_removal, _block_id_to_name, _constraint_rows, _count_lower_dim_elems_in_point_locator, _default_ghosting, _default_mapping_data, _default_mapping_type, _disjoint_neighbor_boundary_pairs, _elem_default_orders, _elem_dims, _elem_integer_default_values, _elem_integer_names, _elemset_codes, _ghosting_functors, _interior_mesh, _mesh_subdomains, _n_parts, _node_integer_default_values, _node_integer_names, _partitioner, _point_locator_close_to_point_tol, _preparation, _skip_all_partitioning, _skip_detect_interior_parents, _skip_find_neighbors, _skip_noncritical_partitioning, _skip_renumber_nodes_and_elements, _spatial_dimension, _supported_nodal_order, boundary_info, get_constraint_rows(), libMesh::index_range(), libMesh::libmesh_assert(), query_node_ptr(), and subclass_locally_equals().

Referenced by operator==().

◆ max_elem_id()

virtual dof_id_type libMesh::MeshBase::max_elem_id ( ) const

pure virtual

Returns: A number one greater than the maximum element id in the mesh. A more apt name for this method would be end_elem_id

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

◆ max_node_id()

virtual dof_id_type libMesh::MeshBase::max_node_id ( ) const

pure virtual

Returns: A number one greater than the maximum node id in the mesh. A more apt name for this method would be end_node_id

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

◆ merge_extra_integer_names()

std::pair< std::vector< unsigned int >, std::vector< unsigned int > > libMesh::MeshBase::merge_extra_integer_names ( const MeshBase & other )

protected

Merge extra-integer arrays from an other mesh.

Returns two mappings from index values in other to (possibly newly created) index values with the same string name in this mesh, the first for element integers and the second for node integers.

Definition at line 2385 of file mesh_base.C.

{
  std::pair<std::vector<unsigned int>, std::vector<unsigned int>> returnval;
  returnval.first = this->add_elem_integers(other._elem_integer_names, true, &other._elem_integer_default_values);
  returnval.second = this->add_node_integers(other._node_integer_names, true, &other._node_integer_default_values);
  return returnval;
}

References _elem_integer_default_values, _elem_integer_names, _node_integer_default_values, _node_integer_names, add_elem_integers(), and add_node_integers().

Referenced by libMesh::UnstructuredMesh::copy_nodes_and_elements(), and libMesh::UnstructuredMesh::create_submesh().

◆ mesh_dimension()

unsigned int libMesh::MeshBase::mesh_dimension ( ) const

Returns: The logical dimension of the mesh; i.e. the manifold dimension of the elements in the mesh. When we have multi-dimensional meshes (e.g. hexes and quads in the same mesh) then this will return the largest such dimension.

Definition at line 430 of file mesh_base.C.

{
  if (!_elem_dims.empty())
    return cast_int<unsigned int>(*_elem_dims.rbegin());
  return 0;
}

References _elem_dims.

Referenced by libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::HPCoarsenTest::add_projection(), libMesh::UnstructuredMesh::all_complete_order_range(), libMesh::UnstructuredMesh::all_second_order_range(), libMesh::MeshTools::Modification::all_tri(), alternative_fe_assembly(), LinearElasticity::assemble(), assemble(), assemble(), assemble_1D(), AssembleOptimization::assemble_A_and_F(), assemble_biharmonic(), assemble_cd(), assemble_cd(), assemble_divgrad(), assemble_elasticity(), assemble_ellipticdg(), assemble_func(), assemble_graddiv(), assemble_helmholtz(), assemble_laplace(), assemble_mass(), assemble_matrices(), assemble_poisson(), assemble_poisson(), assemble_poisson(), assemble_SchroedingerEquation(), assemble_shell(), assemble_stokes(), assemble_temperature_jump(), assemble_wave(), assemble_wave(), libMesh::MeshTools::Generation::build_cube(), cache_elem_data(), compute_enriched_soln(), compute_jacobian(), compute_residual(), LinearElasticity::compute_stresses(), LargeDeformationElasticity::compute_stresses(), LinearElasticityWithContact::compute_stresses(), compute_stresses(), libMesh::VariationalSmootherConstraint::constrain(), libMesh::VariationalSmootherConstraint::constrain_node_to_line(), libMesh::VariationalSmootherConstraint::constrain_node_to_plane(), libMesh::DofMap::create_dof_constraints(), libMesh::MeshTools::Modification::distort(), NavierSystem::element_constraint(), HeatSystem::element_time_derivative(), NavierSystem::element_time_derivative(), SolidSystem::element_time_derivative(), libMesh::ExactErrorEstimator::estimate_error(), fe_assembly(), libMesh::VariationalSmootherConstraint::fix_node(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), NavierSystem::forcing(), form_functionA(), form_functionB(), form_matrixA(), libMesh::ReplicatedMesh::get_boundary_points(), libMesh::LaplaceMeshSmoother::init(), libMesh::PointLocatorTree::init(), NavierSystem::init_data(), SolidSystem::init_data(), ElasticityRBConstruction::init_data(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::Nemesis_IO_Helper::initialize(), integrate_function(), LargeDeformationElasticity::jacobian(), LaplaceYoung::jacobian(), main(), NavierSystem::mass_residual(), Integrate::operator()(), libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::SmoothnessEstimator::EstimateSmoothness::operator()(), libMesh::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), NavierSystem::postprocess(), libMesh::VTKIO::read(), libMesh::Nemesis_IO::read(), libMesh::GMVIO::read(), libMesh::ExodusII_IO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::System::read_header(), libMesh::UCDIO::read_implementation(), libMesh::XdrIO::read_serialized_connectivity(), LargeDeformationElasticity::residual(), LaplaceYoung::residual(), LinearElasticityWithContact::residual_and_jacobian(), SolidSystem::save_initial_mesh(), libMesh::HPCoarsenTest::select_refinement(), libMesh::PetscPreconditioner< T >::set_hypre_ads_data(), libMesh::PetscPreconditioner< T >::set_hypre_ams_data(), libMesh::PetscPreconditioner< T >::set_petsc_aux_data(), setup(), NavierSystem::side_constraint(), libMesh::MeshTools::Modification::smooth(), MeshSpatialDimensionTest::test1D(), MeshSpatialDimensionTest::test2D(), CheckpointIOTest::testC0PolygonCheckpoint(), CheckpointIOTest::testC0PolyhedronCheckpoint(), BoundaryMeshSubdomainTest::testDefaultSubdomain(), InfFERadialTest::testInfQuants(), InfFERadialTest::testInfQuants_numericDeriv(), BoundaryMeshSubdomainTest::testPerBoundarySubdomain(), InfFERadialTest::testSides(), InfFERadialTest::testSingleOrder(), BoundaryMeshSubdomainTest::testSingleSubdomain(), MeshSmootherTest::testVariationalSmootherRegression(), libMesh::BoundaryVolumeSolutionTransfer::transfer(), libMesh::DTKSolutionTransfer::transfer(), libMesh::MeshTools::volume(), libMesh::PostscriptIO::write(), libMesh::CheckpointIO::write(), libMesh::GMVIO::write_binary(), libMesh::TecplotIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::UCDIO::write_implementation(), libMesh::UCDIO::write_nodal_data(), libMesh::EnsightIO::write_scalar_ascii(), libMesh::GnuPlotIO::write_solution(), and libMesh::EnsightIO::write_vector_ascii().

◆ n_active_elem()

virtual dof_id_type libMesh::MeshBase::n_active_elem ( ) const

pure virtual

Returns: The number of active elements in the mesh.

Implemented in terms of active_element_iterators.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by OverlappingTestPartitioner::_do_partition(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_error_tolerance(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::MeshTools::Modification::flatten(), get_info(), libMesh::ExodusII_IO_Helper::initialize(), main(), libMesh::Partitioner::partition(), libMesh::Partitioner::repartition(), libMesh::GMVIO::write_ascii_new_impl(), libMesh::GMVIO::write_ascii_old_impl(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::GmshIO::write_mesh(), write_output_solvedata(), and libMesh::GnuPlotIO::write_solution().

◆ n_active_elem_on_proc()

dof_id_type libMesh::MeshBase::n_active_elem_on_proc ( const processor_id_type proc ) const

Returns: The number of active elements on processor proc.

Definition at line 1242 of file mesh_base.C.

{
  libmesh_assert_less (proc_id, this->n_processors());
  return static_cast<dof_id_type>(std::distance (this->active_pid_elements_begin(proc_id),
                                                 this->active_pid_elements_end  (proc_id)));
}

References libMesh::ParallelObject::n_processors().

Referenced by n_active_local_elem().

◆ n_active_local_elem()

dof_id_type libMesh::MeshBase::n_active_local_elem ( ) const

inline

Returns: The number of active elements on the local processor.

Definition at line 714 of file mesh_base.h.

715 { return this->n_active_elem_on_proc (this->processor_id()); }

libMesh::MeshBase::n_active_elem_on_proc

dof_id_type n_active_elem_on_proc(const processor_id_type proc) const

Definition mesh_base.C:1242

References n_active_elem_on_proc(), and libMesh::ParallelObject::processor_id().

Referenced by libMesh::Partitioner::_find_global_index_by_pid_map(), libMesh::Partitioner::assign_partitioning(), libMesh::Partitioner::build_graph(), libMesh::VTKIO::cells_to_vtk(), and BoundaryInfoTest::testBoundaryOnChildrenElementsRefineCoarsen().

◆ n_active_sub_elem()

dof_id_type libMesh::MeshBase::n_active_sub_elem ( ) const

Same as n_sub_elem(), but only counts active elements.

Definition at line 1263 of file mesh_base.C.

{
  dof_id_type ne=0;
 
  for (const auto & elem : this->active_element_ptr_range())
    ne += elem->n_sub_elem();
 
  return ne;
}

Referenced by libMesh::TecplotIO::write_ascii(), libMesh::GMVIO::write_ascii_old_impl(), and libMesh::TecplotIO::write_binary().

◆ n_constraint_rows()

dof_id_type libMesh::MeshBase::n_constraint_rows ( ) const

Definition at line 2471 of file mesh_base.C.

{
  dof_id_type n_local_rows=0, n_unpartitioned_rows=0;
  for (const auto & [node, node_constraints] : _constraint_rows)
    {
      // Unpartitioned nodes
      if (node->processor_id() == DofObject::invalid_processor_id)
        n_unpartitioned_rows++;
      else if (node->processor_id() == this->processor_id())
        n_local_rows++;
    }
 
  this->comm().sum(n_local_rows);
 
  return n_unpartitioned_rows + n_local_rows;
}

References _constraint_rows, libMesh::ParallelObject::comm(), libMesh::DofObject::invalid_processor_id, libMesh::ParallelObject::processor_id(), and libMesh::Parallel::Communicator::sum().

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

◆ n_elem()

virtual dof_id_type libMesh::MeshBase::n_elem ( ) const

pure virtual

Returns: The number of elements in the mesh.

The standard n_elem() function may return a cached value on distributed meshes, and so can be called by any processor at any time.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by libMesh::MeshTools::Subdivision::add_boundary_ghosts(), libMesh::MeshTools::Modification::all_tri(), AllSecondOrderTest::allCompleteOrderDoNothing(), AllSecondOrderTest::allCompleteOrderMixed(), AllSecondOrderTest::allCompleteOrderRange(), AllSecondOrderTest::allSecondOrderDoNothing(), AllSecondOrderTest::allSecondOrderMixed(), AllSecondOrderTest::allSecondOrderRange(), libMesh::MeshCommunication::assign_global_indices(), libMesh::MeshTools::Generation::build_cube(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::MeshTools::build_nodes_to_elem_map(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::MeshTetInterface::check_hull_integrity(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::DofMap::create_dof_constraints(), libMesh::UnstructuredMesh::create_submesh(), libMesh::MeshTools::Modification::distort(), libMesh::TriangulatorInterface::elems_to_segments(), get_info(), main(), AllSecondOrderTest::MixedFixingImpl(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::XdrIO::read_serialized_nodes(), libMesh::System::read_serialized_vector(), libMesh::System::read_serialized_vectors(), libMesh::MeshTools::Modification::redistribute(), ConstraintOperatorTest::test1DCoarseningNewNodes(), AllRBBTest::test_box(), AllRBBTest::test_cylinder(), AllRBBTest::test_disk(), AllTriTest::test_helper(), AllTriTest::test_helper_c0polyhedron(), MeshInputTest::testAbaqusRead(), AllTriTest::testAllTriC0Polygon(), AllTriTest::testAllTriC0PolygonOctagon(), MeshGenerationTest::testBuildCube(), MeshGenerationTest::testBuildLine(), MeshGenerationTest::testBuildSquare(), CheckpointIOTest::testC0PolygonCheckpoint(), CheckpointIOTest::testC0PolyhedronCheckpoint(), MeshDeletionsTest::testDeleteElem(), MeshInputTest::testDynaNoSplines(), MeshInputTest::testDynaReadElem(), MeshInputTest::testDynaReadPatch(), MeshTriangulationTest::testEdge3ToTri6Base(), MeshInputTest::testExodusIGASidesets(), MeshInputTest::testGoodGmsh(), MeshInputTest::testGoodSTL(), MeshInputTest::testGoodSTLBinary(), InfFERadialTest::testInfQuants(), InfFERadialTest::testInfQuants_numericDeriv(), MeshAssignTest::testMeshMoveAssign(), MeshInputTest::testNemesisReadImpl(), MeshTriangulationTest::testPoly2TriEdge3ToTri7CenterFixup(), MeshTriangulationTest::testPoly2TriRefinementBase(), EquationSystemsTest::testSelectivePRefine(), InfFERadialTest::testSides(), InfFERadialTest::testSingleOrder(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), MeshTetTest::testTetInterfaceBase(), MeshTriangulationTest::testTriangulatorBase(), MeshTriangulationTest::testTriangulatorHolePerturbed(), MeshTriangulationTest::testTriangulatorHoles(), MeshTriangulationTest::testTriangulatorHoleTangentPerturbed(), MeshTriangulationTest::testTriangulatorInterp(), MeshTriangulationTest::testTriangulatorMeshedHoles(), MeshTriangulationTest::testTriangulatorRoundHole(), MeshInputTest::testVTKPreserveElemIds(), MeshInputTest::testVTKPreserveSubdomainIds(), libMesh::NetGenMeshInterface::triangulate(), libMesh::TetGenMeshInterface::triangulate_conformingDelaunayMesh_carvehole(), libMesh::FroIO::write(), libMesh::TetGenIO::write(), libMesh::XdrIO::write(), libMesh::ExodusII_IO_Helper::write_element_values(), libMesh::UCDIO::write_implementation(), libMesh::UCDIO::write_nodal_data(), libMesh::XdrIO::write_serialized_connectivity(), and libMesh::System::write_serialized_vectors().

◆ n_elem_integers()

unsigned int libMesh::MeshBase::n_elem_integers ( ) const

inline

Definition at line 1090 of file mesh_base.h.

1090{ return _elem_integer_names.size(); }

References _elem_integer_names.

Referenced by libMesh::CheckpointIO::read_connectivity(), libMesh::XdrIO::write(), and libMesh::CheckpointIO::write().

◆ n_elem_on_proc()

dof_id_type libMesh::MeshBase::n_elem_on_proc ( const processor_id_type proc ) const

Returns: The number of elements on processor proc.

Definition at line 1229 of file mesh_base.C.

{
  // We're either counting a processor's elements or unpartitioned
  // elements
  libmesh_assert (proc_id < this->n_processors() ||
                  proc_id == DofObject::invalid_processor_id);
 
  return static_cast<dof_id_type>(std::distance (this->pid_elements_begin(proc_id),
                                                 this->pid_elements_end  (proc_id)));
}

References libMesh::DofObject::invalid_processor_id, libMesh::libmesh_assert(), and libMesh::ParallelObject::n_processors().

Referenced by n_local_elem(), and n_unpartitioned_elem().

◆ n_elemsets()

unsigned int libMesh::MeshBase::n_elemsets ( ) const

Returns the number of unique elemset ids which have been added via add_elemset_code(), which is the size of the _all_elemset_ids set.

Definition at line 482 of file mesh_base.C.

{
  return _all_elemset_ids.size();
}

References _all_elemset_ids.

Referenced by get_info(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO::read(), and libMesh::ExodusII_IO_Helper::write_elemsets().

◆ n_local_elem()

dof_id_type libMesh::MeshBase::n_local_elem ( ) const

inline

Returns: The number of elements on the local processor.

Definition at line 697 of file mesh_base.h.

698 { return this->n_elem_on_proc (this->processor_id()); }

libMesh::MeshBase::n_elem_on_proc

dof_id_type n_elem_on_proc(const processor_id_type proc) const

Definition mesh_base.C:1229

References n_elem_on_proc(), and libMesh::ParallelObject::processor_id().

Referenced by libMesh::DTKAdapter::DTKAdapter(), get_info(), libMesh::DistributedMesh::parallel_n_elem(), and DofMapTest::testBadElemFECombo().

◆ n_local_nodes()

dof_id_type libMesh::MeshBase::n_local_nodes ( ) const

inline

Returns: The number of nodes on the local processor.

Definition at line 591 of file mesh_base.h.

592 { return this->n_nodes_on_proc (this->processor_id()); }

libMesh::MeshBase::n_nodes_on_proc

dof_id_type n_nodes_on_proc(const processor_id_type proc) const

Definition mesh_base.C:1216

References n_nodes_on_proc(), and libMesh::ParallelObject::processor_id().

Referenced by get_info(), libMesh::VTKIO::nodes_to_vtk(), and libMesh::DistributedMesh::parallel_n_nodes().

◆ n_local_subdomains()

subdomain_id_type libMesh::MeshBase::n_local_subdomains ( ) const

Returns: The number of subdomains in the local mesh. Subdomains correspond to separate subsets of the mesh which could correspond e.g. to different materials in a solid mechanics application, or regions where different physical processes are important. The subdomain mapping is independent from the parallel decomposition.

Definition at line 1204 of file mesh_base.C.

{
  std::set<subdomain_id_type> ids;
 
  this->subdomain_ids (ids, /* global = */ false);
 
  return cast_int<subdomain_id_type>(ids.size());
}

References subdomain_ids().

Referenced by get_info().

◆ n_node_integers()

unsigned int libMesh::MeshBase::n_node_integers ( ) const

inline

Definition at line 1212 of file mesh_base.h.

1212{ return _node_integer_names.size(); }

References _node_integer_names.

Referenced by libMesh::CheckpointIO::read_nodes(), libMesh::XdrIO::write(), and libMesh::CheckpointIO::write().

◆ n_nodes()

virtual dof_id_type libMesh::MeshBase::n_nodes ( ) const

pure virtual

Returns: The number of nodes in the mesh.

This function and others must be defined in derived classes since the MeshBase class has no specific storage for nodes or elements. The standard n_nodes() function may return a cached value on distributed meshes, and so can be called by any processor at any time.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by libMesh::UnstructuredMesh::all_complete_order_range(), libMesh::UnstructuredMesh::all_second_order_range(), AllSecondOrderTest::allCompleteOrderDoNothing(), AllSecondOrderTest::allCompleteOrderMixed(), AllSecondOrderTest::allCompleteOrderRange(), AllSecondOrderTest::allSecondOrderDoNothing(), AllSecondOrderTest::allSecondOrderMixed(), AllSecondOrderTest::allSecondOrderRange(), libMesh::MeshCommunication::assign_global_indices(), libMesh::MeshTools::Generation::build_delaunay_square(), libMesh::MeshTools::Generation::build_extrusion(), copy_constraint_rows(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::UnstructuredMesh::create_submesh(), libMesh::MeshTools::Modification::distort(), fill_dirichlet_bc(), libMesh::TetGenMeshInterface::fill_pointlist(), get_info(), libMesh::VTKIO::get_local_node_values(), libMesh::TreeNode< N >::insert(), libMesh::MeshRefinement::limit_level_mismatch_at_node(), main(), AllSecondOrderTest::MixedFixingImpl(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::UCDIO::read_implementation(), libMesh::XdrIO::read_serialized_nodes(), libMesh::System::read_serialized_vector(), libMesh::System::read_serialized_vectors(), libMesh::MeshTools::Modification::redistribute(), libMesh::MeshTools::Modification::smooth(), ConstraintOperatorTest::test1DCoarseningNewNodes(), MeshInputTest::testAbaqusRead(), SystemsTest::testBoundaryProjectCube(), MeshGenerationTest::testBuildCube(), MeshGenerationTest::testBuildLine(), MeshGenerationTest::testBuildSquare(), CheckpointIOTest::testC0PolygonCheckpoint(), CheckpointIOTest::testC0PolyhedronCheckpoint(), SystemsTest::testDofCouplingWithVarGroups(), MeshInputTest::testDynaNoSplines(), MeshInputTest::testDynaReadElem(), MeshInputTest::testDynaReadPatch(), ConnectedComponentsTest::testEdge(), VolumeTest::testEdge3Volume(), MeshInputTest::testExodusIGASidesets(), MeshInputTest::testGoodSTLBinary(), MeshInputTest::testNemesisReadImpl(), MeshInputTest::testTetgenIO(), MeshTetTest::testTetInterfaceBase(), MeshTriangulationTest::testTriangulatorInterp(), MeshTriangulationTest::testTriangulatorRoundHole(), MeshSmootherTest::testVariationalSmootherRegression(), MeshInputTest::testVTKPreserveElemIds(), MeshInputTest::testVTKPreserveSubdomainIds(), libMesh::DirectSolutionTransfer::transfer(), libMesh::TreeNode< N >::transform_nodes_to_elements(), libMesh::TreeNode< N >::transform_nodes_to_elements(), libMesh::NetGenMeshInterface::triangulate(), libMesh::TriangleInterface::triangulate(), libMesh::TetGenMeshInterface::triangulate_conformingDelaunayMesh_carvehole(), libMesh::Poly2TriTriangulator::triangulate_current_points(), libMesh::FroIO::write(), libMesh::TetGenIO::write(), libMesh::MEDITIO::write_ascii(), libMesh::TecplotIO::write_ascii(), libMesh::GMVIO::write_ascii_new_impl(), libMesh::GMVIO::write_ascii_old_impl(), libMesh::GMVIO::write_binary(), libMesh::TecplotIO::write_binary(), libMesh::UCDIO::write_header(), libMesh::GmshIO::write_mesh(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::GmshIO::write_post(), libMesh::System::write_serialized_vectors(), and libMesh::UCDIO::write_soln().

◆ n_nodes_on_proc()

dof_id_type libMesh::MeshBase::n_nodes_on_proc ( const processor_id_type proc ) const

Returns: The number of nodes on processor proc.

Definition at line 1216 of file mesh_base.C.

{
  // We're either counting a processor's nodes or unpartitioned
  // nodes
  libmesh_assert (proc_id < this->n_processors() ||
                  proc_id == DofObject::invalid_processor_id);
 
  return static_cast<dof_id_type>(std::distance (this->pid_nodes_begin(proc_id),
                                                 this->pid_nodes_end  (proc_id)));
}

References libMesh::DofObject::invalid_processor_id, libMesh::libmesh_assert(), and libMesh::ParallelObject::n_processors().

Referenced by n_local_nodes(), and n_unpartitioned_nodes().

◆ n_partitions()

unsigned int libMesh::MeshBase::n_partitions ( ) const

inline

Returns: The number of partitions which have been defined via a call to either mesh.partition() or by building a Partitioner object and calling partition.

Note: The partitioner object is responsible for setting this value.

Definition at line 1526 of file mesh_base.h.

1527 { return _n_parts; }

References _n_parts.

Referenced by libMesh::Partitioner::assign_partitioning(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), get_info(), libMesh::BoundaryInfo::sync(), CheckpointIOTest::testSplitter(), libMesh::NameBasedIO::write(), libMesh::GMVIO::write_ascii_new_impl(), and libMesh::GMVIO::write_ascii_old_impl().

◆ n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const

inlineinherited

Returns: The number of processors in the group.

Definition at line 103 of file parallel_object.h.

  {
    processor_id_type returnval =
      cast_int<processor_id_type>(_communicator.size());
    libmesh_assert(returnval); // We never have an empty comm
    return returnval;
  }

References libMesh::ParallelObject::_communicator, libMesh::libmesh_assert(), and libMesh::Parallel::Communicator::size().

◆ n_sub_elem()

dof_id_type libMesh::MeshBase::n_sub_elem ( ) const

Returns: The number of elements that will be written out in certain I/O formats.

For example, a 9-noded quadrilateral will be broken into 4 linear sub-elements for plotting purposes. Thus, for a mesh of 2 QUAD9 elements n_tecplot_elem() will return 8. Implemented in terms of element_iterators.

Definition at line 1251 of file mesh_base.C.

{
  dof_id_type ne=0;
 
  for (const auto & elem : this->element_ptr_range())
    ne += elem->n_sub_elem();
 
  return ne;
}

◆ n_subdomains()

subdomain_id_type libMesh::MeshBase::n_subdomains ( ) const

Returns: The number of subdomains in the global mesh. Subdomains correspond to separate subsets of the mesh which could correspond e.g. to different materials in a solid mechanics application, or regions where different physical processes are important. The subdomain mapping is independent from the parallel decomposition.

Definition at line 1190 of file mesh_base.C.

{
  // This requires an inspection on every processor
  parallel_object_only();
 
  std::set<subdomain_id_type> ids;
 
  this->subdomain_ids (ids);
 
  return cast_int<subdomain_id_type>(ids.size());
}

References subdomain_ids().

Referenced by get_info(), OverlappingCouplingFunctor::OverlappingCouplingFunctor(), MeshSubdomainIDTest::testUnpartitioned(), libMesh::XdrIO::write(), and libMesh::NameBasedIO::write_nodal_data().

◆ n_unpartitioned_elem()

dof_id_type libMesh::MeshBase::n_unpartitioned_elem ( ) const

inline

Returns: The number of elements owned by no processor.

Definition at line 703 of file mesh_base.h.

704 { return this->n_elem_on_proc (DofObject::invalid_processor_id); }

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

Referenced by complete_preparation(), libMesh::DistributedMesh::parallel_n_elem(), and partition().

◆ n_unpartitioned_nodes()

dof_id_type libMesh::MeshBase::n_unpartitioned_nodes ( ) const

inline

Returns: The number of nodes owned by no processor.

Definition at line 597 of file mesh_base.h.

598 { return this->n_nodes_on_proc (DofObject::invalid_processor_id); }

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

Referenced by complete_preparation(), and libMesh::DistributedMesh::parallel_n_nodes().

◆ next_unique_id()

unique_id_type libMesh::MeshBase::next_unique_id ( ) const

inline

Returns: The next unique id to be used.

Definition at line 610 of file mesh_base.h.

610{ return _next_unique_id; }

References _next_unique_id.

Referenced by libMesh::ExodusII_IO_Helper::set_dof_object_unique_id(), and libMesh::ExodusII_IO_Helper::write_elements().

◆ node_ptr() [1/2]

virtual const Node * libMesh::MeshBase::node_ptr ( const dof_id_type i ) const

pure virtual

Returns: A pointer to the \( i^{th} \) node, which should be present in this processor's subset of the mesh data structure.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by libMesh::GMVIO::_read_one_cell(), add_cube_convex_hull_to_mesh(), libMesh::MeshRefinement::add_node(), AllSecondOrderTest::allCompleteOrderMixed(), AllSecondOrderTest::allCompleteOrderRange(), libMesh::DofMap::allgather_recursive_constraints(), AllSecondOrderTest::allSecondOrderMixed(), AllSecondOrderTest::allSecondOrderRange(), libMesh::AbaqusIO::assign_boundary_node_ids(), libMesh::TetGenMeshInterface::assign_nodes_to_elem(), ExodusC0PolyhedronTest::build_c0polyhedron(), libMesh::MeshTools::Generation::build_cube(), libMesh::MeshTools::Generation::build_extrusion(), DisjointNeighborTest::build_four_disjoint_elems(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), ExodusC0PolygonTest::build_pentagon(), DisjointNeighborTest::build_split_mesh_with_interface(), DisjointNeighborTest::build_two_disjoint_elems(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), copy_constraint_rows(), copy_constraint_rows(), libMesh::TriangleWrapper::copy_tri_to_mesh(), libMesh::UnstructuredMesh::create_submesh(), libMesh::TetGenIO::element_in(), libMesh::TriangulatorInterface::elems_to_segments(), libMesh::TriangulatorInterface::insert_any_extra_boundary_points(), libMesh::Poly2TriTriangulator::insert_refinement_points(), libMesh::MeshTools::libmesh_assert_valid_constraint_rows(), main(), node_ref(), node_ref(), libMesh::BoundaryInfo::operator=(), libMesh::BoundaryInfo::parallel_sync_node_ids(), libMesh::DofMap::process_mesh_constraint_rows(), libMesh::VTKIO::read(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::ExodusII_IO_Helper::read_edge_blocks(), libMesh::AbaqusIO::read_elements(), libMesh::UCDIO::read_implementation(), libMesh::GmshIO::read_mesh(), libMesh::MatlabIO::read_stream(), libMesh::OFFIO::read_stream(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::DofMap::scatter_constraints(), libMesh::UnstructuredMesh::stitching_helper(), libMesh::MeshTools::Generation::surface_octahedron(), libMesh::BoundaryInfo::sync(), AllTriTest::test_helper_c0polyhedron(), VolumeTest::testC0PolygonMethods(), CheckpointIOTest::testC0PolyhedronCheckpoint(), VolumeTest::testC0PolyhedronCube(), VolumeTest::testC0PolyhedronHexagonalPrism(), MeshInputTest::testExodusSetNodeUniqueIdsFromMaps_implementation(), NodalNeighborsTest::testOrientation(), EquationSystemsTest::testPostInitAddElem(), SystemsTest::testProjectMatrix3D(), InfFERadialTest::testRefinement(), EquationSystemsTest::testReinitWithNodeElem(), BoundaryInfoTest::testShellFaceConstraints(), MeshTetTest::testTetsToTets(), MeshSubdomainIDTest::testUnpartitioned(), libMesh::NetGenMeshInterface::triangulate(), libMesh::Parallel::Packing< Elem * >::unpack(), and libMesh::CheckpointIO::write_nodesets().

◆ node_ptr() [2/2]

virtual Node * libMesh::MeshBase::node_ptr ( const dof_id_type i )

pure virtual

Returns: A writable pointer to the \( i^{th} \) node, which should be present in this processor's subset of the mesh data structure.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

◆ node_ref() [1/2]

virtual Node & libMesh::MeshBase::node_ref ( const dof_id_type i )

inlinevirtual

Returns: A reference to the \( i^{th} \) node, which should be present in this processor's subset of the mesh data structure.

Definition at line 754 of file mesh_base.h.

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

References node_ptr().

◆ node_ref() [2/2]

virtual const Node & libMesh::MeshBase::node_ref ( const dof_id_type i ) const

inlinevirtual

Returns: A constant reference (for reading only) to the \( i^{th} \) node, which should be present in this processor's subset of the mesh data structure.

Definition at line 745 of file mesh_base.h.

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

References node_ptr().

Referenced by libMesh::SyncNodalPositions::act_on_data(), LinearElasticityWithContact::add_contact_edge_elements(), add_cube_convex_hull_to_mesh(), assemble_matrix_and_rhs(), libMesh::InfElemBuilder::build_inf_elem(), copy_constraint_rows(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::DTKAdapter::DTKAdapter(), fill_dirichlet_bc(), libMesh::MeshTools::Modification::interpolate_surface(), main(), libMesh::DistributedMesh::point(), libMesh::ReplicatedMesh::point(), libMesh::ExodusII_IO::read(), libMesh::XdrIO::read_serialized_nodes(), libMesh::DistributedMesh::renumber_nodes_and_elements(), LinearElasticityWithContact::residual_and_jacobian(), libMesh::Partitioner::set_interface_node_processor_ids_BFS(), libMesh::Partitioner::set_interface_node_processor_ids_linear(), libMesh::Partitioner::set_interface_node_processor_ids_petscpartitioner(), libMesh::Partitioner::set_node_processor_ids(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::VariationalMeshSmoother::smooth(), libMesh::MeshTools::Modification::smooth(), libMesh::UnstructuredMesh::stitching_helper(), MeshTriangulationTest::testPoly2TriHolesInterpRefined(), MeshSmootherTest::testVariationalSmoother(), MeshSmootherTest::testVariationalSmootherRegression(), libMesh::DTKAdapter::update_variable_values(), and libMesh::GmshIO::write_mesh().

◆ nodes_and_elements_equal()

bool libMesh::MeshBase::nodes_and_elements_equal ( const MeshBase & other_mesh ) const

protected

Tests for equality of all elements and nodes in the mesh.

Helper function for subclass_equals() in unstructured mesh subclasses.

Definition at line 2441 of file mesh_base.C.

{
  for (const auto & other_node : other_mesh.node_ptr_range())
    {
      const Node * node = this->query_node_ptr(other_node->id());
      if (!node)
        return false;
      if (*other_node != *node)
        return false;
    }
  for (const auto & node : this->node_ptr_range())
    if (!other_mesh.query_node_ptr(node->id()))
      return false;
 
  for (const auto & other_elem : other_mesh.element_ptr_range())
    {
      const Elem * elem = this->query_elem_ptr(other_elem->id());
      if (!elem)
        return false;
      if (!other_elem->topologically_equal(*elem))
        return false;
    }
  for (const auto & elem : this->element_ptr_range())
    if (!other_mesh.query_elem_ptr(elem->id()))
      return false;
 
  return true;
}

References query_elem_ptr(), and query_node_ptr().

◆ operator!=()

bool libMesh::MeshBase::operator!= ( const MeshBase & other_mesh ) const

inline

Definition at line 138 of file mesh_base.h.

  {
    return !(*this == other_mesh);
  }

◆ operator=() [1/2]

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

delete

Copy and move assignment are not allowed because MeshBase subclasses manually manage memory (Elems and Nodes) and therefore the default versions of these operators would leak memory.

Since we don't want to maintain non-default copy and move assignment operators at this time, the safest and most self-documenting approach is to delete them.

If you need to copy a Mesh, use the clone() method.

◆ operator=() [2/2]

MeshBase & libMesh::MeshBase::operator= ( MeshBase && other_mesh )

Definition at line 189 of file mesh_base.C.

{
  LOG_SCOPE("operator=(&&)", "MeshBase");
 
  // Move assign as a ParallelObject.
  this->ParallelObject::operator=(other_mesh);
 
  _n_parts = other_mesh.n_partitions();
  _default_mapping_type = other_mesh.default_mapping_type();
  _default_mapping_data = other_mesh.default_mapping_data();
  _preparation = other_mesh._preparation;
  _element_stored_range = std::move(other_mesh._element_stored_range);
  _const_active_local_element_stored_range = std::move(other_mesh._const_active_local_element_stored_range);
  _point_locator = std::move(other_mesh._point_locator);
  _count_lower_dim_elems_in_point_locator = other_mesh.get_count_lower_dim_elems_in_point_locator();
#ifdef LIBMESH_ENABLE_UNIQUE_ID
  _next_unique_id = other_mesh.next_unique_id();
#endif
  // If the other mesh interior_parent pointers just go back to
  // itself, so should we
  _interior_mesh = (other_mesh._interior_mesh == &other_mesh) ?
                   this : other_mesh._interior_mesh;
  _skip_noncritical_partitioning = other_mesh.skip_noncritical_partitioning();
  _skip_all_partitioning = other_mesh.skip_partitioning();
  _skip_renumber_nodes_and_elements = !(other_mesh.allow_renumbering());
  _skip_find_neighbors = !(other_mesh.allow_find_neighbors());
  _skip_detect_interior_parents = !(other_mesh.allow_detect_interior_parents());
  _allow_remote_element_removal = other_mesh.allow_remote_element_removal();
  _allow_node_and_elem_unique_id_overlap = other_mesh.allow_node_and_elem_unique_id_overlap();
  _block_id_to_name = std::move(other_mesh._block_id_to_name);
  _elem_dims = std::move(other_mesh.elem_dimensions());
  _elem_default_orders = std::move(other_mesh.elem_default_orders());
  _supported_nodal_order = other_mesh.supported_nodal_order();
  _mesh_subdomains = other_mesh._mesh_subdomains;
  _elemset_codes = std::move(other_mesh._elemset_codes);
  _elemset_codes_inverse_map = std::move(other_mesh._elemset_codes_inverse_map);
  _all_elemset_ids = std::move(other_mesh._all_elemset_ids);
  _spatial_dimension = other_mesh.spatial_dimension();
  _elem_integer_names = std::move(other_mesh._elem_integer_names);
  _elem_integer_default_values = std::move(other_mesh._elem_integer_default_values);
  _node_integer_names = std::move(other_mesh._node_integer_names);
  _node_integer_default_values = std::move(other_mesh._node_integer_default_values);
  _point_locator_close_to_point_tol = other_mesh.get_point_locator_close_to_point_tol();
 
#ifdef LIBMESH_ENABLE_PERIODIC
  // Deep copy of all periodic boundaries:
  // We must clone each PeriodicBoundaryBase in the source map,
  // since unique_ptr cannot be copied and we need independent instances
  if (other_mesh._disjoint_neighbor_boundary_pairs)
    {
      _disjoint_neighbor_boundary_pairs = std::make_unique<PeriodicBoundaries>();
 
      for (const auto & [id, pb] : *other_mesh._disjoint_neighbor_boundary_pairs)
        if (pb)
          (*_disjoint_neighbor_boundary_pairs)[id] = pb->clone();
    }
#endif
 
  // This relies on our subclasses *not* invalidating pointers when we
  // do their portion of the move assignment later!
  boundary_info = std::move(other_mesh.boundary_info);
  boundary_info->set_mesh(*this);
 
#ifdef DEBUG
  // Make sure that move assignment worked for pointers
  for (const auto & [set, code] : _elemset_codes_inverse_map)
    {
      auto it = _elemset_codes.find(code);
      libmesh_assert_msg(it != _elemset_codes.end(),
                         "Elemset code " << code << " not found in _elmset_codes container.");
      libmesh_assert_equal_to(it->second, &set);
    }
#endif
 
  // We're *not* really done at this point, but we have the problem
  // that some of our data movement might be expecting subclasses data
  // movement to happen first.  We'll let subclasses handle that by
  // calling our post_dofobject_moves()
  return *this;
}

References _all_elemset_ids, _allow_node_and_elem_unique_id_overlap, _allow_remote_element_removal, _block_id_to_name, _const_active_local_element_stored_range, _count_lower_dim_elems_in_point_locator, _default_mapping_data, _default_mapping_type, _disjoint_neighbor_boundary_pairs, _elem_default_orders, _elem_dims, _elem_integer_default_values, _elem_integer_names, _element_stored_range, _elemset_codes, _elemset_codes_inverse_map, _interior_mesh, _mesh_subdomains, _n_parts, _next_unique_id, _node_integer_default_values, _node_integer_names, _point_locator, _point_locator_close_to_point_tol, _preparation, _skip_all_partitioning, _skip_detect_interior_parents, _skip_find_neighbors, _skip_noncritical_partitioning, _skip_renumber_nodes_and_elements, _spatial_dimension, _supported_nodal_order, boundary_info, and libMesh::ParallelObject::operator=().

◆ operator==()

bool libMesh::MeshBase::operator== ( const MeshBase & other_mesh ) const

This tests for exactly-equal data in all the senses that a mathematician would care about (element connectivity, nodal coordinates), but in the senses a programmer would care about it allows for non-equal equivalence in some ways (we accept different Elem/Node addresses in memory) but not others (we do not accept different subclass types, nor even different Elem/Node ids).

Though this method is non-virtual, its implementation calls the virtual function subclass_locally_equals() to test for equality of subclass-specific data as well.

Definition at line 271 of file mesh_base.C.

{
  LOG_SCOPE("operator==()", "MeshBase");
 
  bool is_equal = this->locally_equals(other_mesh);
  this->comm().min(is_equal);
  return is_equal;
}

References libMesh::ParallelObject::comm(), locally_equals(), and libMesh::Parallel::Communicator::min().

◆ own_node()

virtual void libMesh::MeshBase::own_node ( Node & )

inlinevirtual

Takes ownership of node n on this partition of a distributed mesh, by setting n.processor_id() to this->processor_id(), as well as changing n.id() and moving it in the mesh's internal container to give it a new authoritative id.

Reimplemented in libMesh::DistributedMesh.

Definition at line 869 of file mesh_base.h.

869{}

◆ parallel_max_unique_id()

virtual unique_id_type libMesh::MeshBase::parallel_max_unique_id ( ) const

pure virtual

Returns: A number greater than or equal to the maximum unique_id in the mesh.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by libMesh::BoundaryInfo::add_elements(), libMesh::MeshTools::Modification::all_tri(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::InfElemBuilder::build_inf_elem(), CopyNodesAndElementsTest::collectMeshes(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::DistributedMesh::DistributedMesh(), main(), libMesh::Nemesis_IO::read(), libMesh::UnstructuredMesh::stitching_helper(), and libMesh::MeshTetInterface::volume_to_surface_mesh().

◆ parallel_n_elem()

virtual dof_id_type libMesh::MeshBase::parallel_n_elem ( ) const

pure virtual

Returns: The number of elements in the mesh.

The parallel_n_elem() function computes a parallel-synchronized value on distributed meshes, and so must be called in parallel only.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by libMesh::Nemesis_IO_Helper::initialize(), and libMesh::Nemesis_IO::read().

◆ parallel_n_nodes()

virtual dof_id_type libMesh::MeshBase::parallel_n_nodes ( ) const

pure virtual

Returns: The number of nodes in the mesh.

This function and others must be overridden in derived classes since the MeshBase class has no specific storage for nodes or elements. The parallel_n_nodes() function computes a parallel-synchronized value on distributed meshes, and so must be called in parallel only.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by libMesh::Nemesis_IO_Helper::initialize(), libMesh::Nemesis_IO::read(), DisjointNeighborTest::testPreserveDisjointNeighborPairsAfterStitch(), and DisjointNeighborTest::testStitchingDiscontinuousBoundaries().

◆ partition() [1/2]

void libMesh::MeshBase::partition ( )

inline

Definition at line 1320 of file mesh_base.h.

1321 { this->partition(this->n_processors()); }

References libMesh::ParallelObject::n_processors(), and partition().

Referenced by complete_preparation(), and partition().

◆ partition() [2/2]

void libMesh::MeshBase::partition ( const unsigned int n_parts )

virtual

Call the default partitioner (currently metis_partition()).

Definition at line 1769 of file mesh_base.C.

{
  // If we get here and we have unpartitioned elements, we need that
  // fixed.
  if (this->n_unpartitioned_elem() > 0)
    {
      libmesh_assert (partitioner().get());
      libmesh_assert (this->is_serial());
      partitioner()->partition (*this, n_parts);
    }
  // A nullptr partitioner or a skip_partitioning(true) call or a
  // skip_noncritical_partitioning(true) call means don't repartition;
  // skip_noncritical_partitioning() checks all these.
  else if (!skip_noncritical_partitioning())
    {
      partitioner()->partition (*this, n_parts);
    }
  else
    {
      // Adaptive coarsening may have "orphaned" nodes on processors
      // whose elements no longer share them.  We need to check for
      // and possibly fix that.
      MeshTools::correct_node_proc_ids(*this);
 
      // Make sure locally cached partition count is correct
      this->recalculate_n_partitions();
 
      // Make sure any other locally cached data is correct
      this->update_post_partitioning();
    }
 
  _preparation.is_partitioned = true;
}

References _preparation, libMesh::MeshTools::correct_node_proc_ids(), libMesh::MeshBase::Preparation::is_partitioned, is_serial(), libMesh::libmesh_assert(), n_unpartitioned_elem(), partitioner(), recalculate_n_partitions(), skip_noncritical_partitioning(), and update_post_partitioning().

Referenced by main(), libMesh::split_mesh(), ExtraIntegersTest::test_helper(), MappedSubdomainPartitionerTest::testMappedSubdomainPartitioner(), EquationSystemsTest::testRepartitionThenReinit(), and CheckpointIOTest::testSplitter().

◆ partitioner()

virtual std::unique_ptr< Partitioner > & libMesh::MeshBase::partitioner ( )

inlinevirtual

A partitioner to use at each partitioning.

Definition at line 165 of file mesh_base.h.

165{ return _partitioner; }

References _partitioner.

Referenced by main(), partition(), libMesh::BoundaryInfo::sync(), MultiEvaluablePredTest::test(), MeshDeletionsTest::testDeleteElem(), and MappedSubdomainPartitionerTest::testMappedSubdomainPartitioner().

◆ point()

virtual const Point & libMesh::MeshBase::point ( const dof_id_type i ) const

pure virtual

Returns: A constant reference (for reading only) to the \( i^{th} \) point, which should be present in this processor's subset of the mesh data structure.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by libMesh::MeshTools::Modification::all_tri(), AllSecondOrderTest::allCompleteOrderMixed(), AllSecondOrderTest::allCompleteOrderRange(), AllSecondOrderTest::allSecondOrderMixed(), AllSecondOrderTest::allSecondOrderRange(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::VTKIO::cells_to_vtk(), libMesh::SyncNodalPositions::gather_data(), LinearElasticityWithContact::initialize_contact_load_paths(), main(), libMesh::TriangulatorInterface::nodes_to_segments(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::UnstructuredMesh::stitching_helper(), libMesh::FroIO::write(), libMesh::TetGenIO::write(), libMesh::MEDITIO::write_ascii(), libMesh::TecplotIO::write_ascii(), libMesh::GMVIO::write_ascii_new_impl(), libMesh::GMVIO::write_ascii_old_impl(), libMesh::GMVIO::write_binary(), libMesh::TecplotIO::write_binary(), and libMesh::GnuPlotIO::write_solution().

◆ post_dofobject_moves()

void libMesh::MeshBase::post_dofobject_moves ( MeshBase && other_mesh )

protected

Moves any superclass data (e.g.

GhostingFunctors that might rely on element and nodal data (which is managed by subclasses!) being already moved first.

Must be manually called in dofobject-managing subclass move operators.

Definition at line 2396 of file mesh_base.C.

{
  // Now that all the DofObject moving is done, we can move the GhostingFunctor objects
  // which include the _default_ghosting,_ghosting_functors and _shared_functors. We also need
  // to set the mesh object associated with these functors to the assignee mesh.
 
   // _default_ghosting
  _default_ghosting = std::move(other_mesh._default_ghosting);
  _default_ghosting->set_mesh(this);
 
  // _ghosting_functors
  _ghosting_functors = std::move(other_mesh._ghosting_functors);
 
  for (const auto gf : _ghosting_functors )
  {
    gf->set_mesh(this);
  }
 
  // _shared_functors
  _shared_functors = std::move(other_mesh._shared_functors);
 
  for (const auto & sf : _shared_functors )
  {
    (sf.second)->set_mesh(this);
  }
 
  // _constraint_rows
  _constraint_rows = std::move(other_mesh._constraint_rows);
 
  if (other_mesh.partitioner())
    _partitioner = std::move(other_mesh.partitioner());
}

References _constraint_rows, _default_ghosting, _ghosting_functors, _partitioner, and _shared_functors.

Referenced by libMesh::ReplicatedMesh::operator=().

◆ preparation()

Preparation libMesh::MeshBase::preparation ( ) const

inline

Definition at line 213 of file mesh_base.h.

214 { return _preparation; }

References _preparation.

Referenced by libMesh::DistributedMesh::DistributedMesh(), and libMesh::ReplicatedMesh::ReplicatedMesh().

◆ prepare_for_use() [1/3]

void libMesh::MeshBase::prepare_for_use ( )

Definition at line 860 of file mesh_base.C.

{
  // Mark everything as unprepared, except for those things we've been
  // told we don't need to prepare, for backwards compatibility
  this->clear_point_locator();
  this->clear_stored_ranges();
  _preparation = false;
  _preparation.has_neighbor_ptrs = _skip_find_neighbors;
  _preparation.has_removed_remote_elements = !_allow_remote_element_removal;
 
  this->complete_preparation();
}

References _allow_remote_element_removal, _preparation, _skip_find_neighbors, clear_point_locator(), clear_stored_ranges(), complete_preparation(), libMesh::MeshBase::Preparation::has_neighbor_ptrs, and libMesh::MeshBase::Preparation::has_removed_remote_elements.

Referenced by libMesh::UnstructuredMesh::all_first_order(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), prepare_for_use(), prepare_for_use(), libMesh::UnstructuredMesh::read(), and libMesh::UnstructuredMesh::stitching_helper().

◆ prepare_for_use() [2/3]

void libMesh::MeshBase::prepare_for_use ( const bool skip_renumber_nodes_and_elements )

Definition at line 843 of file mesh_base.C.

{
  libmesh_deprecated();
 
  // We only respect the users wish if they tell us to skip renumbering. If they tell us not to
  // skip renumbering but someone previously called allow_renumbering(false), then the latter takes
  // precedence
  if (skip_renumber_nodes_and_elements)
    this->allow_renumbering(false);
 
  this->prepare_for_use();
}

References allow_renumbering(), and prepare_for_use().

◆ prepare_for_use() [3/3]

void libMesh::MeshBase::prepare_for_use	(	const bool	skip_renumber_nodes_and_elements,
		const bool	skip_find_neighbors
	)

Prepare a newly created (or read) mesh for use.

This involves several steps: 1.) renumbering (if enabled) 2.) removing any orphaned nodes 3.) updating parallel id counts 4.) finding neighbor links 5.) caching summarized element data 6.) finding interior parent links 7.) clearing any old point locator 8.) calling reinit() on ghosting functors 9.) repartitioning (if enabled) 10.) removing any remote elements (if enabled) 11.) regenerating summarized boundary id sets

For backwards compatibility, prepare_for_use() performs all those steps, regardless of the official preparation() state of the mesh. In codes which have maintained a valid preparation() state via methods such as unset_has_synched_id_counts(), calling complete_preparation() will result in a fully-prepared mesh at less cost.

The argument to skip renumbering is now deprecated - to prevent a mesh from being renumbered, set allow_renumbering(false). The argument to skip finding neighbors is also deprecated. To prevent find_neighbors, set allow_find_neighbors(false)

If this is a distributed mesh, local copies of remote elements will be deleted here - to keep those elements replicated during preparation, set allow_remote_element_removal(false).

Definition at line 824 of file mesh_base.C.

{
  libmesh_deprecated();
 
  // We only respect the users wish if they tell us to skip renumbering. If they tell us not to
  // skip renumbering but someone previously called allow_renumbering(false), then the latter takes
  // precedence
  if (skip_renumber_nodes_and_elements)
    this->allow_renumbering(false);
 
  // We always accept the user's value for skip_find_neighbors, in contrast to skip_renumber
  const bool old_allow_find_neighbors = this->allow_find_neighbors();
  this->allow_find_neighbors(!skip_find_neighbors);
 
  this->prepare_for_use();
 
  this->allow_find_neighbors(old_allow_find_neighbors);
}

References allow_find_neighbors(), allow_renumbering(), and prepare_for_use().

◆ print_constraint_rows()

void libMesh::MeshBase::print_constraint_rows	(	std::ostream &	os = `libMesh::out`,
		bool	print_nonlocal = `false`
	)		const

Prints (from processor 0) all mesh constraint rows.

If print_nonlocal is true, then each constraint is printed once for each processor that knows about it, which may be useful for DistributedMesh debugging.

Definition at line 2783 of file mesh_base.C.

{
  parallel_object_only();
 
  std::string local_constraints =
    this->get_local_constraints(print_nonlocal);
 
  if (this->processor_id())
    {
      this->comm().send(0, local_constraints);
    }
  else
    {
      os << "Processor 0:\n";
      os << local_constraints;
 
      for (auto p : IntRange<processor_id_type>(1, this->n_processors()))
        {
          this->comm().receive(p, local_constraints);
          os << "Processor " << p << ":\n";
          os << local_constraints;
        }
    }
}

References libMesh::ParallelObject::comm(), get_local_constraints(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::processor_id(), libMesh::Parallel::Communicator::receive(), and libMesh::Parallel::Communicator::send().

◆ print_info()

void libMesh::MeshBase::print_info	(	std::ostream &	os = `libMesh::out`,
		const unsigned int	verbosity = `0`,
		const bool	global = `true`
	)		const

Prints relevant information about the mesh.

Take note of the docstring for get_info() for more information pretaining to the verbosity and global parameters.

Definition at line 1755 of file mesh_base.C.

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

References get_info().

Referenced by assemble_and_solve(), libMesh::InfElemBuilder::build_inf_elem(), main(), main(), and setup().

◆ processor_id()

processor_id_type libMesh::ParallelObject::processor_id ( ) const

inlineinherited

Returns: The rank of this processor in the group.

Definition at line 114 of file parallel_object.h.

115 { return cast_int<processor_id_type>(_communicator.rank()); }

libMesh::Parallel::Communicator::rank

processor_id_type rank() const

References libMesh::ParallelObject::_communicator, and libMesh::Parallel::Communicator::rank().

◆ query_elem_ptr() [1/2]

virtual const Elem * libMesh::MeshBase::query_elem_ptr ( const dof_id_type i ) const

pure virtual

Returns: A pointer to the \( i^{th} \) element, or nullptr if no such element exists in this processor's mesh data structure.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

◆ query_elem_ptr() [2/2]

virtual Elem * libMesh::MeshBase::query_elem_ptr ( const dof_id_type i )

pure virtual

Returns: A writable pointer to the \( i^{th} \) element, or nullptr if no such element exists in this processor's mesh data structure.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

◆ query_node_ptr() [1/2]

virtual const Node * libMesh::MeshBase::query_node_ptr ( const dof_id_type i ) const

pure virtual

Returns: A pointer to the \( i^{th} \) node, or nullptr if no such node exists in this processor's mesh data structure.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

◆ query_node_ptr() [2/2]

virtual Node * libMesh::MeshBase::query_node_ptr ( const dof_id_type i )

pure virtual

Returns: A writable pointer to the \( i^{th} \) node, or nullptr if no such node exists in this processor's mesh data structure.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

◆ read()

virtual void libMesh::MeshBase::read	(	const std::string &	name,
		void *	mesh_data = `nullptr`,
		bool	skip_renumber_nodes_and_elements = `false`,
		bool	skip_find_neighbors = `false`,
		bool	skip_detect_interior_parents = `false`
	)

pure virtual

Interfaces for reading/writing a mesh to/from a file.

Must be implemented in derived classes.

Implemented in libMesh::UnstructuredMesh.

Referenced by build_domain(), main(), MeshFunctionTest::read_variable_info_from_output_data(), ConstraintOperatorTest::testCoreform(), BoundaryInfoTest::testEdgeBoundaryConditions(), PeriodicBCTest::testPeriodicBC(), MeshSmootherTest::testVariationalMixed2D(), MeshSmootherTest::testVariationalMixed3D(), MeshInputTest::testVTKPreserveElemIds(), and MeshInputTest::testVTKPreserveSubdomainIds().

◆ recalculate_n_partitions()

unsigned int libMesh::MeshBase::recalculate_n_partitions ( )

In a few (very rare) cases, the user may have manually tagged the elements with specific processor IDs by hand, without using a partitioner.

In this case, the Mesh will not know that the total number of partitions, _n_parts, has changed, unless you call this function. This is an O(N active elements) calculation. The return value is the number of partitions, and _n_parts is also set by this function.

Definition at line 1813 of file mesh_base.C.

{
  // This requires an inspection on every processor
  parallel_object_only();
 
  unsigned int max_proc_id=0;
 
  for (const auto & elem : this->active_local_element_ptr_range())
    max_proc_id = std::max(max_proc_id, static_cast<unsigned int>(elem->processor_id()));
 
  // The number of partitions is one more than the max processor ID.
  _n_parts = max_proc_id+1;
 
  this->comm().max(_n_parts);
 
  return _n_parts;
}

References _n_parts, libMesh::ParallelObject::comm(), and libMesh::Parallel::Communicator::max().

Referenced by partition(), and libMesh::CheckpointIO::read().

◆ redistribute()

void libMesh::MeshBase::redistribute ( )

virtual

Redistribute elements between processors.

This gets called automatically by the Partitioner, and merely notifies any GhostingFunctors of redistribution in the case of a ReplicatedMesh or serialized DistributedMesh

Reimplemented in libMesh::DistributedMesh.

Definition at line 1168 of file mesh_base.C.

{
  // We now have all elements and nodes redistributed; our ghosting
  // functors should be ready to redistribute and/or recompute any
  // cached data they use too.
  for (auto & gf : as_range(this->ghosting_functors_begin(),
                            this->ghosting_functors_end()))
    gf->redistribute();
}

References libMesh::as_range(), ghosting_functors_begin(), and ghosting_functors_end().

Referenced by libMesh::Partitioner::partition(), libMesh::DistributedMesh::redistribute(), and libMesh::Partitioner::single_partition().

◆ reinit_ghosting_functors()

void libMesh::MeshBase::reinit_ghosting_functors ( )

Loops over ghosting functors and calls mesh_reinit()

Definition at line 1025 of file mesh_base.C.

{
  for (auto & gf : _ghosting_functors)
    {
      libmesh_assert(gf);
      gf->mesh_reinit();
    }
 
  _preparation.has_reinit_ghosting_functors = true;
}

References _ghosting_functors, _preparation, libMesh::MeshBase::Preparation::has_reinit_ghosting_functors, and libMesh::libmesh_assert().

Referenced by complete_preparation().

◆ remove_disjoint_boundary_pair()

void libMesh::MeshBase::remove_disjoint_boundary_pair	(	const boundary_id_type	b1,
		const boundary_id_type	b2
	)

Definition at line 2306 of file mesh_base.C.

    {
      // Nothing to remove if not allocated or empty
      if (!_disjoint_neighbor_boundary_pairs || _disjoint_neighbor_boundary_pairs->empty())
        return;
 
      auto & pairs = *_disjoint_neighbor_boundary_pairs;
 
      // Helper to check and erase both directions
      auto erase_if_match = [](boundary_id_type key,
                              boundary_id_type pair,
                              PeriodicBoundaries & pb_map)
        {
          auto it = pb_map.find(key);
          if (it != pb_map.end())
            {
              const auto & pb = *(it->second);
              // Check both directions
              if ((pb.myboundary == key && pb.pairedboundary == pair) ||
                  (pb.pairedboundary == key && pb.myboundary == pair))
                pb_map.erase(it);
            }
        };
 
      erase_if_match(b1, b2, pairs);
      erase_if_match(b2, b1, pairs);
    }

References _disjoint_neighbor_boundary_pairs.

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

◆ remove_ghosting_functor()

void libMesh::MeshBase::remove_ghosting_functor ( GhostingFunctor & ghosting_functor )

Removes a functor which was previously added to the set of ghosting functors.

Definition at line 1100 of file mesh_base.C.

{
  auto raw_it = std::find(_ghosting_functors.begin(),
                          _ghosting_functors.end(), &ghosting_functor);
 
  // The DofMap has a "to_mesh" parameter that tells it to avoid
  // registering a new functor with the mesh, but it doesn't keep
  // track of which functors weren't added, so we'll support "remove a
  // functor that isn't there" just like we did with set::erase
  // before.
  if (raw_it != _ghosting_functors.end())
    _ghosting_functors.erase(raw_it);
 
  // We shouldn't have had two copies of the same functor
  libmesh_assert(std::find(_ghosting_functors.begin(),
                           _ghosting_functors.end(),
                           &ghosting_functor) ==
                 _ghosting_functors.end());
 
  if (const auto it = _shared_functors.find(&ghosting_functor);
      it != _shared_functors.end())
    _shared_functors.erase(it);
}

References _ghosting_functors, _shared_functors, and libMesh::libmesh_assert().

Referenced by EquationSystemsTest::testDisableDefaultGhosting(), and libMesh::DofMap::~DofMap().

◆ remove_orphaned_nodes()

void libMesh::MeshBase::remove_orphaned_nodes ( )

Removes any orphaned nodes, nodes not connected to any elements.

Typically done automatically in a preparation step

Definition at line 801 of file mesh_base.C.

{
  LOG_SCOPE("remove_orphaned_nodes()", "MeshBase");
 
  // Will hold the set of nodes that are currently connected to elements
  std::unordered_set<Node *> connected_nodes;
 
  // Loop over the elements.  Find which nodes are connected to at
  // least one of them.
  for (const auto & element : this->element_ptr_range())
    for (auto & n : element->node_ref_range())
      connected_nodes.insert(&n);
 
  for (const auto & node : this->node_ptr_range())
    if (!connected_nodes.count(node))
      this->delete_node(node);
 
  _preparation.has_removed_orphaned_nodes = true;
}

References _preparation, delete_node(), and libMesh::MeshBase::Preparation::has_removed_orphaned_nodes.

Referenced by complete_preparation().

◆ renumber_elem()

virtual void libMesh::MeshBase::renumber_elem	(	dof_id_type	old_id,
		dof_id_type	new_id
	)

pure virtual

Changes the id of element old_id, both by changing elem(old_id)->id() and by moving elem(old_id) in the mesh's internal container.

No element with the id new_id should already exist.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by libMesh::MeshCommunication::make_elems_parallel_consistent(), libMesh::SimplexRefiner::refine_via_edges(), and MeshInputTest::testVTKPreserveElemIds().

◆ renumber_node()

virtual void libMesh::MeshBase::renumber_node	(	dof_id_type	old_id,
		dof_id_type	new_id
	)

pure virtual

Changes the id of node old_id, both by changing node(old_id)->id() and by moving node(old_id) in the mesh's internal container.

No element with the id new_id should already exist.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by libMesh::SimplexRefiner::refine_via_edges().

◆ renumber_nodes_and_elements()

virtual void libMesh::MeshBase::renumber_nodes_and_elements ( )

pure virtual

After partitioning a mesh it is useful to renumber the nodes and elements so that they lie in contiguous blocks on the processors.

This method does just that.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by complete_preparation(), libMesh::UnstructuredMesh::contract(), and write_output().

◆ reserve_elem()

virtual void libMesh::MeshBase::reserve_elem ( const dof_id_type ne )

pure virtual

Reserves space for a known number of elements.

Note: This method may or may not do anything, depending on the actual Mesh implementation. If you know the number of elements you will add and call this method before repeatedly calling add_point() the implementation will be more efficient.

Implemented in libMesh::ReplicatedMesh, and libMesh::DistributedMesh.

Referenced by libMesh::MeshTools::Generation::build_cube(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::ExodusII_IO::read(), libMesh::XdrIO::read_header(), and libMesh::GmshIO::read_mesh().

◆ reserve_nodes()

virtual void libMesh::MeshBase::reserve_nodes ( const dof_id_type nn )

pure virtual

Reserves space for a known number of nodes.

Note: This method may or may not do anything, depending on the actual Mesh implementation. If you know the number of nodes you will add and call this method before repeatedly calling add_point() the implementation will be more efficient.

Implemented in libMesh::ReplicatedMesh, and libMesh::DistributedMesh.

Referenced by libMesh::UnstructuredMesh::all_complete_order_range(), libMesh::UnstructuredMesh::all_second_order_range(), libMesh::MeshTools::Generation::build_cube(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::ExodusII_IO::read(), libMesh::XdrIO::read_header(), and libMesh::GmshIO::read_mesh().

◆ set_count_lower_dim_elems_in_point_locator()

void libMesh::MeshBase::set_count_lower_dim_elems_in_point_locator ( bool count_lower_dim_elems )

In the point locator, do we count lower dimensional elements when we refine point locator regions? This is relevant in tree-based point locators, for example.

Definition at line 1873 of file mesh_base.C.

{
  _count_lower_dim_elems_in_point_locator = count_lower_dim_elems;
}

References _count_lower_dim_elems_in_point_locator.

◆ set_default_mapping_data()

void libMesh::MeshBase::set_default_mapping_data ( const unsigned char data )

inline

Set the default master space to physical space mapping basis functions to be used on newly added elements.

Definition at line 968 of file mesh_base.h.

  {
    _default_mapping_data = data;
  }

References _default_mapping_data.

Referenced by libMesh::MeshTools::Modification::all_rbb(), libMesh::ExodusII_IO::read(), and libMesh::DynaIO::read_mesh().

◆ set_default_mapping_type()

void libMesh::MeshBase::set_default_mapping_type ( const ElemMappingType type )

inline

Set the default master space to physical space mapping basis functions to be used on newly added elements.

Definition at line 950 of file mesh_base.h.

  {
    _default_mapping_type = type;
  }

References _default_mapping_type.

Referenced by libMesh::MeshTools::Modification::all_rbb(), libMesh::ExodusII_IO::read(), and libMesh::DynaIO::read_mesh().

◆ set_distributed()

virtual void libMesh::MeshBase::set_distributed ( )

inlinevirtual

Asserts that not all elements and nodes of the mesh necessarily exist on the current processor.

Only valid to call on classes which can be created in a distributed form.

Reimplemented in libMesh::DistributedMesh.

Definition at line 372 of file mesh_base.h.

373 { libmesh_error(); }

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

◆ set_elem_dimensions()

void libMesh::MeshBase::set_elem_dimensions ( std::set< unsigned char > elem_dims )

Most of the time you should not need to call this, as the element dimensions will be set automatically by a call to cache_elem_data(), therefore only call this if you know what you're doing.

In some specialized situations, for example when adding a single Elem on all procs, it can be faster to skip calling cache_elem_data() and simply specify the element dimensions manually, which is why this setter exists.

Definition at line 439 of file mesh_base.C.

{
#ifdef DEBUG
  // In debug mode, we call cache_elem_data() and then make sure
  // the result actually agrees with what the user specified.
  parallel_object_only();
 
  this->cache_elem_data();
  libmesh_assert_msg(_elem_dims == elem_dims, \
                     "Specified element dimensions does not match true element dimensions!");
#endif
 
  _elem_dims = std::move(elem_dims);
}

References _elem_dims, and cache_elem_data().

◆ set_interior_mesh()

void libMesh::MeshBase::set_interior_mesh ( MeshBase & int_mesh )

inline

Sets the interior mesh.

For advanced use only.

Definition at line 2050 of file mesh_base.h.

2050{ _interior_mesh = &int_mesh; }

References _interior_mesh.

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

◆ set_isnt_prepared()

void libMesh::MeshBase::set_isnt_prepared ( )

inline

Tells this we have done some operation where we should no longer consider ourself prepared.

This is a very coarse setting; it is generally more efficient to mark finer-grained settings instead.

This method name is now deprecated, in part to match the less awkward unset_has_ names of the more fine-grained methods, in part as a way to prompt older user codes to use the more fine-grained methods where they can, to speed up the complete_preparation() calls afterward.

Definition at line 228 of file mesh_base.h.

229 { libmesh_deprecated(); _preparation = false; }

References _preparation.

◆ set_mesh_dimension()

void libMesh::MeshBase::set_mesh_dimension ( unsigned char d )

inline

Resets the logical dimension of the mesh.

If the mesh has elements of multiple dimensions, this should be set to the largest dimension. E.g. if the mesh has 1D and 2D elements, this should be set to 2. If the mesh has 2D and 3D elements, this should be set to 3.

Definition at line 423 of file mesh_base.h.

424 { _elem_dims.clear(); _elem_dims.insert(d); }

References _elem_dims.

Referenced by libMesh::MeshTools::Generation::build_cube(), libMesh::MeshTools::Generation::build_delaunay_square(), DisjointNeighborTest::build_four_disjoint_elems(), DisjointNeighborTest::build_split_mesh_with_interface(), libMesh::TriangleWrapper::copy_tri_to_mesh(), libMesh::VTKIO::read(), libMesh::Nemesis_IO::read(), libMesh::GMVIO::read(), libMesh::STLIO::read(), libMesh::AbaqusIO::read(), libMesh::ExodusII_IO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::CheckpointIO::read_header(), libMesh::UCDIO::read_implementation(), libMesh::GmshIO::read_mesh(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::MatlabIO::read_stream(), libMesh::OFFIO::read_stream(), InfFERadialTest::testRefinement(), libMesh::TriangleInterface::triangulate(), and libMesh::Poly2TriTriangulator::triangulate().

◆ set_n_partitions()

unsigned int & libMesh::MeshBase::set_n_partitions ( )

inlineprotected

Returns: A writable reference to the number of partitions.

Definition at line 2164 of file mesh_base.h.

2165 { return _n_parts; }

References _n_parts.

Referenced by libMesh::Partitioner::partition(), libMesh::Partitioner::repartition(), and libMesh::BoundaryInfo::sync().

◆ set_next_unique_id()

virtual void libMesh::MeshBase::set_next_unique_id ( unique_id_type id )

pure virtual

Sets the next available unique id to be used.

On a ReplicatedMesh, or when adding unpartitioned objects to a DistributedMesh, this must be kept in sync on all processors.

On a DistributedMesh, other unique_id values (larger than this one) may be chosen next, to allow unique_id assignment without communication.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read_serialized_nodes(), and libMesh::ExodusII_IO_Helper::set_dof_object_unique_id().

◆ set_point_locator_close_to_point_tol()

void libMesh::MeshBase::set_point_locator_close_to_point_tol ( Real val )

Set value used by PointLocatorBase::close_to_point_tol().

Defaults to 0.0. If nonzero, calls close_to_point_tol() whenever a new PointLocator is built for use by this Mesh. Since the Mesh controls the creation and destruction of the PointLocator, if there are any parameters we need to customize on it, the Mesh will need to know about them.

Definition at line 2340 of file mesh_base.C.

{
  _point_locator_close_to_point_tol = val;
  if (_point_locator)
    {
      if (val > 0.)
        _point_locator->set_close_to_point_tol(val);
      else
        _point_locator->unset_close_to_point_tol();
    }
}

References _point_locator, and _point_locator_close_to_point_tol.

◆ set_spatial_dimension()

void libMesh::MeshBase::set_spatial_dimension ( unsigned char d )

Sets the "spatial dimension" of the Mesh.

See the documentation for Mesh::spatial_dimension() for more information.

Definition at line 613 of file mesh_base.C.

{
  // The user can set the _spatial_dimension however they wish,
  // libMesh will only *increase* the spatial dimension, however,
  // never decrease it.
  _spatial_dimension = d;
}

References _spatial_dimension.

Referenced by libMesh::MeshTools::Generation::build_cube(), MeshSpatialDimensionTest::test2D(), and InfFERadialTest::testRefinement().

◆ set_subdomain_name()

void libMesh::MeshBase::set_subdomain_name	(	subdomain_id_type	id,
		const std::string &	name,
		bool	synchronous = `false`
	)

Sets the name for the provided id.

Parameters

id	The subdomain id to set the name for
name	The subdomain name
synchronous	Whether this method is being called across all mesh ranks. If this is true, then we don't have to register this collective container as being out of sync

Definition at line 1914 of file mesh_base.C.

{
  if (synchronous)
    parallel_object_only();
  else
    this->unset_has_synched_subdomain_name_map();
  _block_id_to_name[id] =  name;
}

References _block_id_to_name, and unset_has_synched_subdomain_name_map().

Referenced by libMesh::AbaqusIO::assign_subdomain_ids(), libMesh::UNVIO::groups_in(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::GmshIO::read_mesh(), libMesh::UnstructuredMesh::stitching_helper(), MeshStitchTest::testAmbiguousRemappingStitch(), and MeshStitchTest::testRemappingStitch().

◆ set_subdomain_name_map()

std::map< subdomain_id_type, std::string > & libMesh::MeshBase::set_subdomain_name_map ( )

inline

Returns: A writable reference to the whole subdomain name map

Definition at line 1924 of file mesh_base.h.

1925 { this->unset_has_synched_subdomain_name_map(); return _block_id_to_name; }

References _block_id_to_name, and unset_has_synched_subdomain_name_map().

Referenced by libMesh::DistributedMesh::DistributedMesh(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::CheckpointIO::read_subdomain_names(), and libMesh::ReplicatedMesh::ReplicatedMesh().

◆ size_elem_extra_integers()

void libMesh::MeshBase::size_elem_extra_integers ( )

protected

Size extra-integer arrays of all elements in the mesh.

Definition at line 2361 of file mesh_base.C.

{
  const std::size_t new_size = _elem_integer_names.size();
 
  Threads::parallel_for
    (this->element_stored_range(),
     [new_size, this](const ElemRange & range)
     {
       for (Elem * elem : range)
         elem->add_extra_integers(new_size, this->_elem_integer_default_values);
     });
}

References _elem_integer_names, element_stored_range(), and libMesh::Threads::parallel_for().

Referenced by add_elem_data(), add_elem_datum(), add_elem_integer(), and add_elem_integers().

◆ size_node_extra_integers()

void libMesh::MeshBase::size_node_extra_integers ( )

protected

Size extra-integer arrays of all nodes in the mesh.

Definition at line 2376 of file mesh_base.C.

{
  const std::size_t new_size = _node_integer_names.size();
  for (auto node : this->node_ptr_range())
    node->add_extra_integers(new_size, _node_integer_default_values);
}

References _node_integer_default_values, and _node_integer_names.

Referenced by add_node_data(), add_node_datum(), add_node_integer(), and add_node_integers().

◆ skip_noncritical_partitioning() [1/2]

bool libMesh::MeshBase::skip_noncritical_partitioning ( ) const

inline

Definition at line 1414 of file mesh_base.h.

1415 { return _skip_noncritical_partitioning || _skip_all_partitioning || !_partitioner.get(); }

References _partitioner, _skip_all_partitioning, and _skip_noncritical_partitioning.

Referenced by partition().

◆ skip_noncritical_partitioning() [2/2]

void libMesh::MeshBase::skip_noncritical_partitioning ( bool skip )

inline

If true is passed in then the elements on this mesh will no longer be (re)partitioned, and the nodes on this mesh will only be repartitioned if they are found "orphaned" via coarsening or other removal of the last element responsible for their node/element processor id consistency.

Note: It would probably be a bad idea to call this on a DistributedMesh before the first partitioning has happened... because no elements would get assigned to your processor pool.; Skipping partitioning can have adverse effects on your performance when using AMR... i.e. you could get large load imbalances. However you might still want to use this if the communication and computation of the rebalance and repartition is too high for your application.

It is also possible, for backwards-compatibility purposes, to skip noncritical partitioning by resetting the partitioner() pointer for this mesh.

Definition at line 1411 of file mesh_base.h.

1412 { _skip_noncritical_partitioning = skip; }

References _skip_noncritical_partitioning.

Referenced by libMesh::MeshTools::correct_node_proc_ids(), MeshInputTest::testCopyElementSolutionImpl(), MeshInputTest::testCopyElementVectorImpl(), and MeshInputTest::testCopyNodalSolutionImpl().

◆ skip_partitioning() [1/2]

bool libMesh::MeshBase::skip_partitioning ( ) const

inline

Definition at line 1431 of file mesh_base.h.

1431{ return _skip_all_partitioning; }

References _skip_all_partitioning.

Referenced by complete_preparation(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::DistributedMesh::DistributedMesh(), and libMesh::ReplicatedMesh::ReplicatedMesh().

◆ skip_partitioning() [2/2]

void libMesh::MeshBase::skip_partitioning ( bool skip )

inline

If true is passed in then nothing on this mesh will be (re)partitioned.

Note: The caveats for skip_noncritical_partitioning() still apply, and removing elements from a mesh with this setting enabled can leave node processor ids in an inconsistent state (not matching any attached element), causing failures in other library code. Do not use this setting along with element deletion or coarsening.

Definition at line 1429 of file mesh_base.h.

1429{ _skip_all_partitioning = skip; }

References _skip_all_partitioning.

Referenced by libMesh::DistributedMesh::DistributedMesh(), libMesh::CheckpointIO::read(), libMesh::ReplicatedMesh::ReplicatedMesh(), and CheckpointIOTest::testSplitter().

◆ spatial_dimension()

unsigned int libMesh::MeshBase::spatial_dimension ( ) const

Returns: The "spatial dimension" of the mesh.

The spatial dimension is defined as:

1 - for an exactly x-aligned mesh of 1D elements 2 - for an exactly x-y planar mesh of 2D elements 3 - otherwise

No tolerance checks are performed to determine whether the Mesh is x-aligned or x-y planar, only strict equality with zero in the higher dimensions is checked. Also, x-z and y-z planar meshes are considered to have spatial dimension == 3.

The spatial dimension is updated during mesh preparation based on the dimensions of the various elements present in the Mesh, but is never automatically decreased.

For example, if the user calls set_spatial_dimension(2) and then later inserts 3D elements into the mesh, Mesh::spatial_dimension() will return 3 after the next call to prepare_for_use() or complete_preparation(). On the other hand, if the user calls set_spatial_dimension(3) and then inserts only x-aligned 1D elements into the Mesh, mesh.spatial_dimension() will remain 3.

Definition at line 606 of file mesh_base.C.

{
  return cast_int<unsigned int>(_spatial_dimension);
}

References _spatial_dimension.

Referenced by libMesh::EquationSystems::build_elemental_data_variable_names(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::EquationSystems::build_variable_names(), libMesh::EquationSystems::find_variable_numbers_by_predicate(), get_info(), libMesh::ExodusII_IO_Helper::initialize(), MeshSpatialDimensionTest::test1D(), and MeshSpatialDimensionTest::test2D().

◆ sub_point_locator()

std::unique_ptr< PointLocatorBase > libMesh::MeshBase::sub_point_locator ( ) const

Returns: A pointer to a subordinate PointLocatorBase object for this mesh, constructing a master PointLocator first if necessary. This should not be used in threaded or non-parallel_only code unless the master has already been constructed.

Definition at line 1833 of file mesh_base.C.

{
  // If there's no master point locator, then we need one.
  if (_point_locator.get() == nullptr)
    {
      // PointLocator construction may not be safe within threads
      libmesh_assert(!Threads::in_threads);
 
      // And it may require parallel communication
      parallel_object_only();
 
#ifdef LIBMESH_ENABLE_NANOFLANN_POINTLOCATOR
      _point_locator = PointLocatorBase::build(NANOFLANN, *this);
#else
      _point_locator = PointLocatorBase::build(TREE_ELEMENTS, *this);
#endif
 
      if (_point_locator_close_to_point_tol > 0.)
        _point_locator->set_close_to_point_tol(_point_locator_close_to_point_tol);
    }
 
  // Otherwise there was a master point locator, and we can grab a
  // sub-locator easily.
  return
#ifdef LIBMESH_ENABLE_NANOFLANN_POINTLOCATOR
    PointLocatorBase::build(NANOFLANN, *this, _point_locator.get());
#else
    PointLocatorBase::build(TREE_ELEMENTS, *this, _point_locator.get());
#endif
}

References _point_locator, _point_locator_close_to_point_tol, libMesh::PointLocatorBase::build(), libMesh::Threads::in_threads, libMesh::libmesh_assert(), libMesh::NANOFLANN, and libMesh::TREE_ELEMENTS.

Referenced by WriteElemsetData::checkElemsetCodes(), libMesh::DofMap::create_dof_constraints(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::MeshFunction::init(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), main(), libMesh::DefaultCoupling::mesh_reinit(), libMesh::OverlapCoupling::mesh_reinit(), libMesh::PointNeighborCoupling::mesh_reinit(), MeshPerElemTest< elem_type >::meshes_equal_enough(), OverlappingCouplingFunctor::operator()(), MeshFunctionTest::test_bad_gradient_var_with_out_of_mesh_value(), MeshFunctionTest::test_bad_hessian_var_with_out_of_mesh_value(), PointLocatorTest::testLocator(), MeshInputTest::testMasterCenters(), PointLocatorTest::testPlanar(), SystemsTest::testProjectCube(), SystemsTest::testProjectLine(), and SystemsTest::testProjectSquare().

◆ subclass_locally_equals()

virtual bool libMesh::MeshBase::subclass_locally_equals ( const MeshBase & other_mesh ) const

protectedpure virtual

Shim to allow operator == (&) to behave like a virtual function without having to be one.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by locally_equals().

◆ subdomain_ids()

void libMesh::MeshBase::subdomain_ids	(	std::set< subdomain_id_type > &	ids,
		const bool	global = `true`
	)		const

Constructs a list of all subdomain identifiers in the local mesh if global == false, and in the global mesh if global == true (default).

Subdomains correspond to separate subsets of the mesh which could correspond e.g. to different materials in a solid mechanics application, or regions where different physical processes are important. The subdomain mapping is independent from the parallel decomposition.

Unpartitioned elements are included in the set in the case that global == true. If global == false, the unpartitioned elements are not included because unpartitioned elements do not have a sense of locality.

Definition at line 1126 of file mesh_base.C.

{
  // This requires an inspection on every processor
  if (global)
    parallel_object_only();
 
  struct SBDInserter {
    std::set<subdomain_id_type> my_ids;
 
    SBDInserter () {}
    SBDInserter (SBDInserter &, Threads::split) {}
 
    void operator()(const ConstElemRange & range) {
      for (const Elem * elem : range)
        my_ids.insert(elem->subdomain_id());
    }
 
    void join(SBDInserter & other) {
      my_ids.merge(other.my_ids);
    }
  };
 
  SBDInserter inserter;
  Threads::parallel_reduce(this->active_local_element_stored_range(), inserter);
 
  ids.swap(inserter.my_ids);
 
  if (global)
    {
      // Only include the unpartitioned elements if the user requests the global IDs.
      // In the case of the local subdomain IDs, it doesn't make sense to include the
      // unpartitioned elements because said elements do not have a sense of locality.
      for (const auto & elem : this->active_unpartitioned_element_ptr_range())
        ids.insert(elem->subdomain_id());
 
      // Some subdomains may only live on other processors
      this->comm().set_union(ids);
    }
}

References active_local_element_stored_range(), libMesh::ParallelObject::comm(), libMesh::Threads::parallel_reduce(), and libMesh::Parallel::Communicator::set_union().

Referenced by copy_constraint_rows(), libMesh::ReplicatedMesh::get_disconnected_subdomains(), n_local_subdomains(), n_subdomains(), OverlappingCouplingFunctor::OverlappingCouplingFunctor(), libMesh::TecplotIO::TecplotIO(), MeshSubdomainIDTest::testMultiple(), and MeshSubdomainIDTest::testUnpartitioned().

◆ subdomain_name() [1/2]

std::string & libMesh::MeshBase::subdomain_name ( subdomain_id_type id )

Deprecated:

Returns: A writable reference for setting an optional name for a subdomain. This method is deprecated; use set_subdomain_name() instead.

Definition at line 1887 of file mesh_base.C.

{
  // Use set_subdomain_name() instead
  libmesh_deprecated();
 
  // We'd like to do this so our preparation isn't invalidated by a
  // write, but for all we know the user is just reading from a
  // non-const mesh!
  // this->unset_has_synched_subdomain_name_map();
 
  return _block_id_to_name[id];
}

References _block_id_to_name.

Referenced by DMlibMeshSetSystem_libMesh(), MeshInputTest::testGmshBCIDOverlap(), libMesh::TecplotIO::write_binary(), and libMesh::ExodusII_IO_Helper::write_elements().

◆ subdomain_name() [2/2]

const std::string & libMesh::MeshBase::subdomain_name ( subdomain_id_type id ) const

Returns: A reference for getting an optional name for a subdomain.

Definition at line 1902 of file mesh_base.C.

{
  // An empty string to return when no matching subdomain name is found
  static const std::string empty;
 
  if (const auto iter = _block_id_to_name.find(id);
      iter == _block_id_to_name.end())
    return empty;
  else
    return iter->second;
}

References _block_id_to_name.

◆ supported_nodal_order()

Order libMesh::MeshBase::supported_nodal_order ( ) const

inline

Returns: The smallest supported_nodal_order() of any element present in the mesh, which is thus the maximum supported nodal order on the mesh as a whole.

Definition at line 445 of file mesh_base.h.

446 { return _supported_nodal_order; }

References _supported_nodal_order.

Referenced by get_info().

◆ sync_subdomain_name_map()

void libMesh::MeshBase::sync_subdomain_name_map ( )

libMesh often expects all processors to know about names of all subdomain ids, but distributed mesh generators may only know about part of a mesh when creating names.

This method can synchronize the subdomain id to name map across processors, assuming no conflicts exist. It is called automatically during complete_preparation() unless the map is already known to be synchronized.

Definition at line 2066 of file mesh_base.C.

{
  // This requires every processor
  parallel_object_only();
 
  this->comm().set_union(_block_id_to_name);
 
  _preparation.has_synched_subdomain_name_map = true;
}

References _block_id_to_name, _preparation, libMesh::ParallelObject::comm(), libMesh::MeshBase::Preparation::has_synched_subdomain_name_map, and libMesh::Parallel::Communicator::set_union().

Referenced by complete_preparation().

◆ unset_has_boundary_id_sets()

void libMesh::MeshBase::unset_has_boundary_id_sets ( )

inline

Tells this we have done some operation which may have invalidated our cached boundary id sets.

User code which removes elements, or which adds or removes boundary entries, should call this method.

Definition at line 340 of file mesh_base.h.

341 { _preparation.has_boundary_id_sets = false; }

References _preparation, and libMesh::MeshBase::Preparation::has_boundary_id_sets.

Referenced by libMesh::BoundaryInfo::add_elements(), and MeshBaseTest::testMeshBaseVerifyRemovalPreparation().

◆ unset_has_cached_elem_data()

void libMesh::MeshBase::unset_has_cached_elem_data ( )

inline

Tells this we have done some operation (e.g.

adding elements with a new dimension or subdomain value) which may invalidate cached summaries of element data.

User code which adds new elements to this mesh must call this function.

Definition at line 281 of file mesh_base.h.

282 { _preparation.has_cached_elem_data = false; }

References _preparation, and libMesh::MeshBase::Preparation::has_cached_elem_data.

Referenced by libMesh::BoundaryInfo::add_elements(), libMesh::MeshTools::Modification::change_subdomain_id(), libMesh::MeshTools::Modification::redistribute(), libMesh::MeshTools::Modification::rotate(), libMesh::MeshTools::Modification::scale(), MeshBaseTest::testMeshBaseVerifyHasCachedElemData(), and libMesh::MeshTools::Modification::translate().

◆ unset_has_interior_parent_ptrs()

void libMesh::MeshBase::unset_has_interior_parent_ptrs ( )

inline

Tells this we have done some operation (e.g.

refining elements with interior parents) which requires interior parent pointers to be found later.

Most user code will not need to call this method; any user code that manipulates interior parents or their boundary elements may be an exception.

Definition at line 293 of file mesh_base.h.

294 { _preparation.has_interior_parent_ptrs = false; }

References _preparation, and libMesh::MeshBase::Preparation::has_interior_parent_ptrs.

◆ unset_has_neighbor_ptrs()

void libMesh::MeshBase::unset_has_neighbor_ptrs ( )

inline

Tells this we have done some operation (e.g.

adding elements without setting their neighbor pointers, or adding disjoint neighbor boundary pairs) which requires neighbor pointers to be determined later.

User code which adds new elements to this mesh must call this function or manually set neighbor pointer from and to those elements.

Definition at line 270 of file mesh_base.h.

271 { _preparation.has_neighbor_ptrs = false; }

References _preparation, and libMesh::MeshBase::Preparation::has_neighbor_ptrs.

Referenced by libMesh::BoundaryInfo::add_elements(), and MeshBaseTest::testMeshBaseVerifyHasNeighborPtrs().

◆ unset_has_reinit_ghosting_functors()

void libMesh::MeshBase::unset_has_reinit_ghosting_functors ( )

inline

Tells this we have done some operation (e.g.

adding or removing elements) which may require a reinit() of custom ghosting functors.

User code which adds or removes elements should call this method. User code which moves nodes ... should probably call this method, in case ghosting functors depending on position exist?

Definition at line 330 of file mesh_base.h.

331 { _preparation.has_reinit_ghosting_functors = false; }

References _preparation, and libMesh::MeshBase::Preparation::has_reinit_ghosting_functors.

Referenced by libMesh::BoundaryInfo::add_elements().

◆ unset_has_removed_orphaned_nodes()

void libMesh::MeshBase::unset_has_removed_orphaned_nodes ( )

inline

Tells this we have done some operation (e.g.

coarsening) which may have left orphaned nodes in need of removal.

Most user code should probably never need to use this; we can set it in MeshRefinement. User code which deletes elements without carefully deleting orphaned nodes should call this manually.

Definition at line 318 of file mesh_base.h.

319 { _preparation.has_removed_orphaned_nodes = false; }

References _preparation, and libMesh::MeshBase::Preparation::has_removed_orphaned_nodes.

Referenced by MeshBaseTest::testMeshBaseVerifyRemovalPreparation().

◆ unset_has_removed_remote_elements()

void libMesh::MeshBase::unset_has_removed_remote_elements ( )

inline

Tells this we have done some operation (e.g.

repartitioning) which may have left elements as ghosted which on a distributed mesh should be remote.

User code should probably never need to use this; we can set it in Partitioner. Any user code which manually repartitions elements on distributed meshes may need to call this manually, in addition to manually communicating elements with newly-created ghosting requirements.

Definition at line 307 of file mesh_base.h.

308 { _preparation.has_removed_remote_elements = false; }

References _preparation, and libMesh::MeshBase::Preparation::has_removed_remote_elements.

◆ unset_has_synched_id_counts()

void libMesh::MeshBase::unset_has_synched_id_counts ( )

inline

Tells this we have done some operation (e.g.

adding objects to a distributed mesh on one processor only) which can lose synchronization of id counts.

User code which does distributed additions of nodes or elements must call either this method or update_parallel_id_counts().

Definition at line 257 of file mesh_base.h.

258 { _preparation.has_synched_id_counts = false; }

References _preparation, and libMesh::MeshBase::Preparation::has_synched_id_counts.

◆ unset_has_synched_subdomain_name_map()

void libMesh::MeshBase::unset_has_synched_subdomain_name_map ( )

inline

Tells this we have done some operation which may have left the subdomain id to name map inconsistent across processors.

User code which adds or changes subdomain names should call this method.

Definition at line 350 of file mesh_base.h.

351 { _preparation.has_synched_subdomain_name_map = false; }

References _preparation, and libMesh::MeshBase::Preparation::has_synched_subdomain_name_map.

Referenced by set_subdomain_name(), and set_subdomain_name_map().

◆ unset_is_partitioned()

void libMesh::MeshBase::unset_is_partitioned ( )

inline

Tells this we have done some operation creating unpartitioned elements.

User code which adds elements to this mesh must either partition them too or call this method.

Definition at line 246 of file mesh_base.h.

247 { _preparation.is_partitioned = false; }

References _preparation, and libMesh::MeshBase::Preparation::is_partitioned.

Referenced by MeshBaseTest::testMeshBaseVerifyRemovalPreparation().

◆ unset_is_prepared()

void libMesh::MeshBase::unset_is_prepared ( )

Tells this we have done some operation where we should no longer consider ourself prepared.

This is a very coarse setting; it is generally more efficient to mark finer-grained settings instead.

Definition at line 1070 of file mesh_base.C.

{
  _preparation = false;
  this->clear_point_locator();
  this->clear_stored_ranges();
}

References _preparation, clear_point_locator(), and clear_stored_ranges().

Referenced by libMesh::UnstructuredMesh::copy_nodes_and_elements(), and MeshTetTest::testTrisToTets().

◆ update_parallel_id_counts()

virtual void libMesh::MeshBase::update_parallel_id_counts ( )

pure virtual

Updates parallel caches so that methods like n_elem() accurately reflect changes on other processors.

Implemented in libMesh::DistributedMesh, and libMesh::ReplicatedMesh.

Referenced by complete_preparation().

◆ update_post_partitioning()

void libMesh::MeshBase::update_post_partitioning ( )

virtual

Recalculate any cached data (or invalidate any caches that are computed on the fly) after elements and nodes have been repartitioned.

Reimplemented in libMesh::DistributedMesh.

Definition at line 1180 of file mesh_base.C.

{
  // A range over all elements might still be fine here, but any range
  // over local elements is obsolete if our partitioner changed the
  // definition of "local".
  _const_active_local_element_stored_range.reset(nullptr);
}

References _const_active_local_element_stored_range.

Referenced by partition(), libMesh::Partitioner::partition(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), and libMesh::DistributedMesh::update_post_partitioning().

◆ write()

virtual void libMesh::MeshBase::write ( const std::string & name ) const

pure virtual

Implemented in libMesh::UnstructuredMesh.

Referenced by ExtraIntegersTest::checkpoint_helper(), main(), ExtraIntegersTest::test_helper(), BoundaryInfoTest::testEdgeBoundaryConditions(), MeshInputTest::testExodusReadHeader(), MeshAssignTest::testMeshMoveAssign(), MeshInputTest::testNemesisReadImpl(), tetrahedralize_domain(), triangulate_domain(), and write_output().

Friends And Related Symbol Documentation

◆ BoundaryInfo

friend class BoundaryInfo

friend

Make the BoundaryInfo class a friend so that it can create and interact with BoundaryMesh.

Definition at line 2466 of file mesh_base.h.

◆ MeshCommunication

friend class MeshCommunication

friend

Make the MeshCommunication class a friend so that it can directly broadcast *_integer_names.

Definition at line 2472 of file mesh_base.h.

◆ MeshInput< MeshBase >

friend class MeshInput< MeshBase >

friend

The MeshInput classes are friends so that they can set the number of partitions.

Definition at line 2454 of file mesh_base.h.

◆ operator<<

std::ostream & operator<<	(	std::ostream &	os,
		const MeshBase &	m
	)

friend

Equivalent to calling print_info() above, but now you can write: Mesh mesh; libMesh::out << mesh << std::endl;.

Definition at line 1762 of file mesh_base.C.

{
  m.print_info(os);
  return os;
}

◆ Partitioner

friend class Partitioner

friend

The partitioner class is a friend so that it can set the number of partitions.

Definition at line 2454 of file mesh_base.h.

Member Data Documentation

◆ _all_elemset_ids

MeshBase::elemset_type libMesh::MeshBase::_all_elemset_ids

protected

Definition at line 2359 of file mesh_base.h.

Referenced by add_elemset_code(), change_elemset_id(), locally_equals(), n_elemsets(), and operator=().

◆ _allow_node_and_elem_unique_id_overlap

bool libMesh::MeshBase::_allow_node_and_elem_unique_id_overlap

protected

The Exodus reader (and potentially other readers in the future?) now supports setting Node and Elem unique_ids based on values from within the Exodus file itself, rather than generating them automatically in LibMesh.

In this case, the unique_ids will not necessarily be unique across the set of all DofObjects, although they should still be unique within the individual sets of Elems and Nodes. The reader can therefore set this Mesh flag (which defaults to false) to indicate we should be less strict when checking the "uniqueness" of unique_ids.

Definition at line 2301 of file mesh_base.h.

Referenced by allow_node_and_elem_unique_id_overlap(), allow_node_and_elem_unique_id_overlap(), locally_equals(), and operator=().

◆ _allow_remote_element_removal

bool libMesh::MeshBase::_allow_remote_element_removal

protected

If this is false then even on DistributedMesh remote elements will not be deleted during mesh preparation.

This is true by default.

Definition at line 2288 of file mesh_base.h.

Referenced by allow_remote_element_removal(), allow_remote_element_removal(), complete_preparation(), locally_equals(), operator=(), and prepare_for_use().

◆ _block_id_to_name

std::map<subdomain_id_type, std::string> libMesh::MeshBase::_block_id_to_name

protected

This structure maintains the mapping of named blocks for file formats that support named blocks.

Currently this is only implemented for ExodusII

Definition at line 2308 of file mesh_base.h.

Referenced by get_id_by_name(), get_subdomain_name_map(), locally_equals(), operator=(), set_subdomain_name(), set_subdomain_name_map(), subdomain_name(), subdomain_name(), and sync_subdomain_name_map().

◆ _communicator

const Parallel::Communicator& libMesh::ParallelObject::_communicator

protectedinherited

Definition at line 120 of file parallel_object.h.

Referenced by libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::StaticCondensation::close(), libMesh::ParallelObject::comm(), libMesh::CondensedEigenSystem::initialize_condensed_matrices(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::operator=(), libMesh::ParallelObject::processor_id(), libMesh::BoundaryInfo::regenerate_id_sets(), libMesh::StaticCondensationDofMap::reinit(), and libMesh::BoundaryInfo::synchronize_global_id_set().

◆ _const_active_local_element_stored_range

std::unique_ptr<ConstElemRange> libMesh::MeshBase::_const_active_local_element_stored_range

mutableprotected

A cached ConstElemRange for threaded calculation on all local elements of this mesh.

This will not actually be built unless needed. Further, since we want our elem_stored_range() method to be const (yet do the dynamic allocating) this needs to be mutable.

Definition at line 2216 of file mesh_base.h.

Referenced by active_local_element_stored_range(), clear_stored_ranges(), operator=(), and update_post_partitioning().

◆ _constraint_rows

constraint_rows_type libMesh::MeshBase::_constraint_rows

protected

Definition at line 2442 of file mesh_base.h.

Referenced by clear(), copy_constraint_rows(), copy_constraint_rows(), libMesh::DistributedMesh::delete_node(), libMesh::ReplicatedMesh::delete_node(), get_constraint_rows(), get_constraint_rows(), get_local_constraints(), locally_equals(), n_constraint_rows(), post_dofobject_moves(), libMesh::DistributedMesh::renumber_nodes_and_elements(), and libMesh::ReplicatedMesh::renumber_nodes_and_elements().

◆ _count_lower_dim_elems_in_point_locator

bool libMesh::MeshBase::_count_lower_dim_elems_in_point_locator

protected

Do we count lower dimensional elements in point locator refinement? This is relevant in tree-based point locators, for example.

Definition at line 2231 of file mesh_base.h.

Referenced by get_count_lower_dim_elems_in_point_locator(), locally_equals(), operator=(), and set_count_lower_dim_elems_in_point_locator().

◆ _default_ghosting

std::unique_ptr<GhostingFunctor> libMesh::MeshBase::_default_ghosting

protected

The default geometric GhostingFunctor, used to implement standard libMesh element ghosting behavior.

We use a base class pointer here to avoid dragging in more header dependencies.

Definition at line 2415 of file mesh_base.h.

Referenced by default_ghosting(), locally_equals(), MeshBase(), MeshBase(), and post_dofobject_moves().

◆ _default_mapping_data

unsigned char libMesh::MeshBase::_default_mapping_data

protected

The default mapping data (unused with Lagrange, used for nodal weight lookup index with rational bases) to assign to newly added elements.

Definition at line 2190 of file mesh_base.h.

Referenced by default_mapping_data(), locally_equals(), operator=(), and set_default_mapping_data().

◆ _default_mapping_type

ElemMappingType libMesh::MeshBase::_default_mapping_type

protected

The default mapping type (typically Lagrange) between master and physical space to assign to newly added elements.

Definition at line 2183 of file mesh_base.h.

Referenced by default_mapping_type(), locally_equals(), operator=(), and set_default_mapping_type().

◆ _disjoint_neighbor_boundary_pairs

std::unique_ptr<PeriodicBoundaries> libMesh::MeshBase::_disjoint_neighbor_boundary_pairs

protected

The disjoint neighbor boundary id pairs.

Definition at line 2119 of file mesh_base.h.

Referenced by add_disjoint_neighbor_boundary_pairs(), get_disjoint_neighbor_boundary_pairs(), get_disjoint_neighbor_boundary_pairs(), locally_equals(), MeshBase(), operator=(), and remove_disjoint_boundary_pair().

◆ _elem_default_orders

std::set<Order> libMesh::MeshBase::_elem_default_orders

protected

We cache the (default) order of the geometric elements present in the mesh.

E.g. if we have a mesh with TRI3 and TRI6 elements, this structure will contain FIRST and SECOND.

Definition at line 2322 of file mesh_base.h.

Referenced by cache_elem_data(), clear(), copy_cached_data(), copy_constraint_rows(), elem_default_orders(), get_info(), locally_equals(), and operator=().

◆ _elem_dims

std::set<unsigned char> libMesh::MeshBase::_elem_dims

protected

We cache the dimension of the elements present in the mesh.

So, if we have a mesh with 1D and 2D elements, this structure will contain 1 and 2.

Definition at line 2315 of file mesh_base.h.

Referenced by cache_elem_data(), clear(), copy_cached_data(), copy_constraint_rows(), elem_dimensions(), get_info(), locally_equals(), mesh_dimension(), MeshBase(), operator=(), set_elem_dimensions(), and set_mesh_dimension().

◆ _elem_integer_default_values

std::vector<dof_id_type> libMesh::MeshBase::_elem_integer_default_values

protected

The array of default initialization values for integer data associated with each element in the mesh.

Definition at line 2377 of file mesh_base.h.

Referenced by libMesh::DistributedMesh::add_elem(), libMesh::ReplicatedMesh::add_elem(), add_elem_integer(), add_elem_integers(), libMesh::DistributedMesh::insert_elem(), libMesh::ReplicatedMesh::insert_elem(), locally_equals(), merge_extra_integer_names(), and operator=().

◆ _elem_integer_names

std::vector<std::string> libMesh::MeshBase::_elem_integer_names

protected

The array of names for integer data associated with each element in the mesh.

Definition at line 2371 of file mesh_base.h.

Referenced by libMesh::DistributedMesh::add_elem(), libMesh::ReplicatedMesh::add_elem(), add_elem_data(), add_elem_datum(), add_elem_integer(), add_elem_integers(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), get_elem_integer_index(), get_elem_integer_name(), has_elem_integer(), libMesh::DistributedMesh::insert_elem(), libMesh::ReplicatedMesh::insert_elem(), locally_equals(), merge_extra_integer_names(), n_elem_integers(), operator=(), and size_elem_extra_integers().

◆ _element_stored_range

std::unique_ptr<ElemRange> libMesh::MeshBase::_element_stored_range

mutableprotected

A cached ElemRange for threaded mutation of all semilocal elements of this mesh.

This will not actually be built unless needed. Further, since we want our elem_stored_range() method to be const (yet do the dynamic allocating) this needs to be mutable.

Definition at line 2205 of file mesh_base.h.

Referenced by clear_stored_ranges(), element_stored_range(), and operator=().

◆ _elemset_codes

std::map<dof_id_type, const MeshBase::elemset_type *> libMesh::MeshBase::_elemset_codes

protected

Map from "element set code" to list of set ids to which that element belongs (and vice-versa).

Remarks: 1.) The elemset code is a dof_id_type because (if used) it is stored as an extra_integer (named "elemset_code") on all elements, and extra_integers are of type dof_id_type. Elements which do not belong to any set should be assigned an elemset code of DofObject::invalid_id. 2.) Element sets can be thought of as a generalization of the concept of a subdomain. Subdomains have the following restrictions: a.) A given element can only belong to a single subdomain b.) When using Exodus file input/output, subdomains are (unfortunately) tied to the concept of exodus element blocks, which consist of a single geometric element type, somewhat limiting their generality. 3.) The user is responsible for filling in the values of this map in a consistent manner, unless the elemsets are read in from an Exodus file, in which case the elemset codes will be set up automatically. The codes can basically be chosen arbitrarily, with the one requirement that elements which belong to no sets should have a set code of DofObject::invalid_id. 4.) We also keep a list of all the elemset ids which have been added in order to support O(1) performance behavior in n_elemsets() calls.

Definition at line 2357 of file mesh_base.h.

Referenced by add_elemset_code(), change_elemset_code(), change_elemset_id(), clear(), get_elemset_codes(), get_elemsets(), get_info(), locally_equals(), MeshBase(), and operator=().

◆ _elemset_codes_inverse_map

std::map<MeshBase::elemset_type, dof_id_type> libMesh::MeshBase::_elemset_codes_inverse_map

protected

Definition at line 2358 of file mesh_base.h.

Referenced by add_elemset_code(), change_elemset_code(), change_elemset_id(), clear(), get_elemset_code(), MeshBase(), and operator=().

◆ _ghosting_functors

std::vector<GhostingFunctor *> libMesh::MeshBase::_ghosting_functors

protected

The list of all GhostingFunctor objects to be used when distributing a DistributedMesh.

Basically unused by ReplicatedMesh for now, but belongs to MeshBase because the cost is trivial.

Definition at line 2424 of file mesh_base.h.

Referenced by add_ghosting_functor(), ghosting_functors_begin(), ghosting_functors_end(), locally_equals(), MeshBase(), MeshBase(), post_dofobject_moves(), reinit_ghosting_functors(), and remove_ghosting_functor().

◆ _interior_mesh

MeshBase* libMesh::MeshBase::_interior_mesh

protected

Defaulting to this, a pointer to the mesh used to generate boundary elements on this.

Definition at line 2252 of file mesh_base.h.

Referenced by libMesh::UnstructuredMesh::copy_nodes_and_elements(), interior_mesh(), interior_mesh(), locally_equals(), operator=(), and set_interior_mesh().

◆ _mesh_subdomains

std::set<subdomain_id_type> libMesh::MeshBase::_mesh_subdomains

protected

We cache the subdomain ids of the elements present in the mesh.

Definition at line 2333 of file mesh_base.h.

Referenced by cache_elem_data(), copy_cached_data(), copy_constraint_rows(), get_mesh_subdomains(), locally_equals(), and operator=().

◆ _n_parts

unsigned int libMesh::MeshBase::_n_parts

protected

The number of partitions the mesh has.

This is set by the partitioners, and may not be changed directly by the user.

Note: The number of partitions need not equal this->n_processors(), consider for example the case where you simply want to partition a mesh on one processor and view the result in GMV.

Definition at line 2177 of file mesh_base.h.

Referenced by clear(), locally_equals(), n_partitions(), operator=(), recalculate_n_partitions(), and set_n_partitions().

◆ _next_unique_id

unique_id_type libMesh::MeshBase::_next_unique_id

protected

The next available unique id for assigning ids to DOF objects.

Definition at line 2245 of file mesh_base.h.

◆ _node_integer_default_values

std::vector<dof_id_type> libMesh::MeshBase::_node_integer_default_values

protected

The array of default initialization values for integer data associated with each node in the mesh.

Definition at line 2389 of file mesh_base.h.

Referenced by libMesh::DistributedMesh::add_node(), libMesh::ReplicatedMesh::add_node(), add_node_integer(), add_node_integers(), libMesh::ReplicatedMesh::add_point(), locally_equals(), merge_extra_integer_names(), operator=(), and size_node_extra_integers().

◆ _node_integer_names

std::vector<std::string> libMesh::MeshBase::_node_integer_names

protected

The array of names for integer data associated with each node in the mesh.

Definition at line 2383 of file mesh_base.h.

Referenced by libMesh::DistributedMesh::add_node(), libMesh::ReplicatedMesh::add_node(), add_node_data(), add_node_datum(), add_node_integer(), add_node_integers(), libMesh::ReplicatedMesh::add_point(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::UnstructuredMesh::create_submesh(), get_node_integer_index(), get_node_integer_name(), has_node_integer(), locally_equals(), merge_extra_integer_names(), n_node_integers(), operator=(), and size_node_extra_integers().

◆ _partitioner

std::unique_ptr<Partitioner> libMesh::MeshBase::_partitioner

protected

A partitioner to use at each prepare_for_use().

This will be built in the constructor of each derived class, but can be replaced by the user through the partitioner() accessor.

Definition at line 2239 of file mesh_base.h.

Referenced by libMesh::DistributedMesh::DistributedMesh(), locally_equals(), MeshBase(), partitioner(), post_dofobject_moves(), libMesh::ReplicatedMesh::ReplicatedMesh(), and skip_noncritical_partitioning().

◆ _point_locator

std::unique_ptr<PointLocatorBase> libMesh::MeshBase::_point_locator

mutableprotected

A PointLocator class for this mesh.

This will not actually be built unless needed. Further, since we want our point_locator() method to be const (yet do the dynamic allocating) this needs to be mutable. Since the PointLocatorBase::build() member is used, and it operates on a constant reference to the mesh, this is OK.

Definition at line 2225 of file mesh_base.h.

Referenced by clear_point_locator(), operator=(), set_point_locator_close_to_point_tol(), and sub_point_locator().

◆ _point_locator_close_to_point_tol

Real libMesh::MeshBase::_point_locator_close_to_point_tol

protected

If nonzero, we will call PointLocatorBase::set_close_to_point_tol() on any PointLocators that we create.

Definition at line 2448 of file mesh_base.h.

Referenced by get_point_locator_close_to_point_tol(), locally_equals(), operator=(), set_point_locator_close_to_point_tol(), and sub_point_locator().

◆ _preparation

Preparation libMesh::MeshBase::_preparation

protected

Flags indicating in what ways this mesh has been prepared.

Definition at line 2195 of file mesh_base.h.

Referenced by cache_elem_data(), clear(), complete_preparation(), delete_remote_elements(), libMesh::DistributedMesh::delete_remote_elements(), detect_interior_parents(), libMesh::DistributedMesh::DistributedMesh(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::BoundaryInfo::get_global_boundary_ids(), is_prepared(), locally_equals(), operator=(), partition(), preparation(), prepare_for_use(), reinit_ghosting_functors(), remove_orphaned_nodes(), libMesh::DistributedMesh::renumber_nodes_and_elements(), libMesh::ReplicatedMesh::renumber_nodes_and_elements(), libMesh::ReplicatedMesh::ReplicatedMesh(), set_isnt_prepared(), sync_subdomain_name_map(), libMesh::BoundaryInfo::synchronize_global_id_set(), unset_has_boundary_id_sets(), unset_has_cached_elem_data(), unset_has_interior_parent_ptrs(), unset_has_neighbor_ptrs(), unset_has_reinit_ghosting_functors(), unset_has_removed_orphaned_nodes(), unset_has_removed_remote_elements(), unset_has_synched_id_counts(), unset_has_synched_subdomain_name_map(), unset_is_partitioned(), unset_is_prepared(), libMesh::DistributedMesh::update_parallel_id_counts(), and libMesh::ReplicatedMesh::update_parallel_id_counts().

◆ _shared_functors

std::map<GhostingFunctor *, std::shared_ptr<GhostingFunctor> > libMesh::MeshBase::_shared_functors

protected

Hang on to references to any GhostingFunctor objects we were passed in shared_ptr form.

Definition at line 2430 of file mesh_base.h.

Referenced by add_ghosting_functor(), post_dofobject_moves(), and remove_ghosting_functor().

◆ _skip_all_partitioning

bool libMesh::MeshBase::_skip_all_partitioning

protected

If this is true then no partitioning should be done.

Definition at line 2263 of file mesh_base.h.

Referenced by locally_equals(), operator=(), skip_noncritical_partitioning(), skip_partitioning(), and skip_partitioning().

◆ _skip_detect_interior_parents

bool libMesh::MeshBase::_skip_detect_interior_parents

protected

If this is true then we will skip detect_interior_parents in prepare_for_use.

Definition at line 2280 of file mesh_base.h.

Referenced by allow_detect_interior_parents(), allow_detect_interior_parents(), complete_preparation(), locally_equals(), and operator=().

◆ _skip_find_neighbors

bool libMesh::MeshBase::_skip_find_neighbors

protected

If this is true then we will skip find_neighbors in prepare_for_use.

Definition at line 2275 of file mesh_base.h.

Referenced by allow_find_neighbors(), allow_find_neighbors(), complete_preparation(), locally_equals(), operator=(), and prepare_for_use().

◆ _skip_noncritical_partitioning

bool libMesh::MeshBase::_skip_noncritical_partitioning

protected

If this is true then no partitioning should be done with the possible exception of orphaned nodes.

Definition at line 2258 of file mesh_base.h.

Referenced by locally_equals(), operator=(), skip_noncritical_partitioning(), and skip_noncritical_partitioning().

◆ _skip_renumber_nodes_and_elements

bool libMesh::MeshBase::_skip_renumber_nodes_and_elements

protected

If this is true then renumbering will be kept to a minimum.

This is set when prepare_for_use() is called.

Definition at line 2270 of file mesh_base.h.

Referenced by allow_renumbering(), allow_renumbering(), complete_preparation(), locally_equals(), operator=(), libMesh::DistributedMesh::renumber_nodes_and_elements(), and libMesh::ReplicatedMesh::renumber_nodes_and_elements().

◆ _spatial_dimension

unsigned char libMesh::MeshBase::_spatial_dimension

protected

The "spatial dimension" of the Mesh.

See the documentation for Mesh::spatial_dimension() for more information.

Definition at line 2365 of file mesh_base.h.

Referenced by cache_elem_data(), copy_cached_data(), locally_equals(), operator=(), set_spatial_dimension(), and spatial_dimension().

◆ _supported_nodal_order

Order libMesh::MeshBase::_supported_nodal_order

protected

We cache the maximum nodal order supported by all the mesh's elements (the minimum supported_nodal_order() of any element)

Definition at line 2328 of file mesh_base.h.

Referenced by cache_elem_data(), clear(), copy_cached_data(), copy_constraint_rows(), locally_equals(), operator=(), and supported_nodal_order().

◆ boundary_info

std::unique_ptr<BoundaryInfo> libMesh::MeshBase::boundary_info

protected

This class holds the boundary information.

It can store nodes, edges, and faces with a corresponding id that facilitates setting boundary conditions.

Direct access to this class is now officially deprecated and will be removed in future libMesh versions. Use the get_boundary_info() accessor instead.

Definition at line 2131 of file mesh_base.h.

Referenced by clear(), get_boundary_info(), get_boundary_info(), locally_equals(), and operator=().

◆ ElemRange

const DofMap& dof_map LIBMESH_COMMA unsigned int Elem* libMesh::MeshBase::ElemRange

Definition at line 1894 of file mesh_base.h.

◆ var_num

const DofMap& dof_map LIBMESH_COMMA unsigned int libMesh::MeshBase::var_num

Definition at line 1846 of file mesh_base.h.

The documentation for this class was generated from the following files:

include/mesh/mesh_base.h
src/mesh/mesh_base.C

Classes

Public Types

Public Member Functions

Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ const_elem_filter_iter [1/2]

◆ const_elem_filter_iter [2/2]

◆ const_node_filter_iter [1/2]

◆ const_node_filter_iter [2/2]

◆ ConstElemRange

◆ constraint_rows_mapped_type

◆ constraint_rows_type

◆ elem_filter_iter [1/2]

◆ elem_filter_iter [2/2]

◆ elemset_type

◆ GhostingFunctorIterator

◆ node_filter_iter [1/2]

◆ node_filter_iter [2/2]

◆ Predicate

Constructor & Destructor Documentation

◆ MeshBase() [1/3]

◆ MeshBase() [2/3]

◆ MeshBase() [3/3]

◆ ~MeshBase()

Member Function Documentation

◆ ABSTRACT_ELEM_ITERATORS() [1/15]

◆ ABSTRACT_ELEM_ITERATORS() [2/15]

◆ ABSTRACT_ELEM_ITERATORS() [3/15]

◆ ABSTRACT_ELEM_ITERATORS() [4/15]

◆ ABSTRACT_ELEM_ITERATORS() [5/15]

◆ ABSTRACT_ELEM_ITERATORS() [6/15]

◆ ABSTRACT_ELEM_ITERATORS() [7/15]

◆ ABSTRACT_ELEM_ITERATORS() [8/15]

◆ ABSTRACT_ELEM_ITERATORS() [9/15]

◆ ABSTRACT_ELEM_ITERATORS() [10/15]

◆ ABSTRACT_ELEM_ITERATORS() [11/15]

◆ ABSTRACT_ELEM_ITERATORS() [12/15]

◆ ABSTRACT_ELEM_ITERATORS() [13/15]

◆ ABSTRACT_ELEM_ITERATORS() [14/15]

◆ ABSTRACT_ELEM_ITERATORS() [15/15]

◆ active_local_element_stored_range()

◆ active_local_subdomain_elements_ptr_range() [1/2]

◆ active_local_subdomain_elements_ptr_range() [2/2]

◆ active_subdomain_elements_ptr_range() [1/2]

◆ active_subdomain_elements_ptr_range() [2/2]

◆ active_subdomain_set_elements_ptr_range() [1/2]

◆ active_subdomain_set_elements_ptr_range() [2/2]

◆ add_disjoint_neighbor_boundary_pairs()

◆ add_elem() [1/2]

◆ add_elem() [2/2]

◆ add_elem_data()

◆ add_elem_datum()

◆ add_elem_integer()

◆ add_elem_integers()

◆ add_elemset_code()

◆ add_ghosting_functor() [1/2]

◆ add_ghosting_functor() [2/2]

◆ add_node() [1/2]

◆ add_node() [2/2]

◆ add_node_data()

◆ add_node_datum()

◆ add_node_integer()

◆ add_node_integers()

◆ add_point()

◆ all_complete_order()

◆ all_complete_order_range()

◆ all_first_order()

◆ all_second_order()

◆ all_second_order_range()

◆ allgather()

◆ allow_detect_interior_parents() [1/2]

◆ allow_detect_interior_parents() [2/2]

◆ allow_find_neighbors() [1/2]

◆ allow_find_neighbors() [2/2]

◆ allow_node_and_elem_unique_id_overlap() [1/2]