libMesh::ReplicatedMesh Class Reference

The ReplicatedMesh class is derived from the MeshBase class, and is used to store identical copies of a full mesh data structure on each processor. More...

#include <replicated_mesh.h>

Inheritance diagram for libMesh::ReplicatedMesh:

Public Types
typedef std::set< elemset_id_type >	elemset_type
	Typedef for the "set" container used to store elemset ids. More...
typedef Predicates::multi_predicate	Predicate
	We need an empty, generic class to act as a predicate for this and derived mesh classes. More...
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
	ReplicatedMesh (const Parallel::Communicator &comm_in, unsigned char dim=1)
	Constructor. More...
	ReplicatedMesh (const MeshBase &other_mesh)
	Copy-constructor. More...
	ReplicatedMesh (const ReplicatedMesh &other_mesh)
	Copy-constructor, possibly specialized for a serial mesh. More...
	ReplicatedMesh (ReplicatedMesh &&)=delete
	Move-constructor deleted in MeshBase. More...
ReplicatedMesh &	operator= (const ReplicatedMesh &)=delete
	Copy assignment is not allowed. More...
ReplicatedMesh &	operator= (ReplicatedMesh &&other_mesh)
	Move assignment operator. More...
virtual MeshBase &	assign (MeshBase &&other_mesh) override
	Shim to call the move assignment operator for this class. More...
virtual void	move_nodes_and_elements (MeshBase &&other_mesh) override
	Move node and elements from a ReplicatedMesh. More...
virtual bool	subclass_locally_equals (const MeshBase &other_mesh) const override
	Shim to allow operator == (&) to behave like a virtual function without having to be one. More...
virtual std::unique_ptr< MeshBase >	clone () const override
	Virtual copy-constructor, creates a copy of this mesh. More...
virtual	~ReplicatedMesh ()
	Destructor. More...
virtual void	clear () override
	Clear all internal data. More...
virtual void	clear_elems () override
	Clear internal Elem data. More...
virtual void	renumber_nodes_and_elements () override
	After partitioning a mesh it is useful to renumber the nodes and elements so that they lie in contiguous blocks on the processors. More...
virtual dof_id_type	n_nodes () const override final
virtual dof_id_type	parallel_n_nodes () const override final
virtual dof_id_type	max_node_id () const override final
virtual void	reserve_nodes (const dof_id_type nn) override final
	Reserves space for a known number of nodes. More...
virtual dof_id_type	n_elem () const override final
virtual dof_id_type	parallel_n_elem () const override final
virtual dof_id_type	n_active_elem () const override final
virtual dof_id_type	max_elem_id () const override final
virtual unique_id_type	parallel_max_unique_id () const override final
virtual void	set_next_unique_id (unique_id_type id) override final
	Sets the next available unique id to be used. More...
virtual void	reserve_elem (const dof_id_type ne) override final
	Reserves space for a known number of elements. More...
virtual void	update_parallel_id_counts () override
	Updates parallel caches so that methods like n_elem() accurately reflect changes on other processors. More...
virtual const Point &	point (const dof_id_type i) const override final
virtual const Node *	node_ptr (const dof_id_type i) const override final
virtual Node *	node_ptr (const dof_id_type i) override final
virtual const Node *	query_node_ptr (const dof_id_type i) const override final
virtual Node *	query_node_ptr (const dof_id_type i) override final
virtual const Elem *	elem_ptr (const dof_id_type i) const override final
virtual Elem *	elem_ptr (const dof_id_type i) override final
virtual const Elem *	query_elem_ptr (const dof_id_type i) const override final
virtual Elem *	query_elem_ptr (const dof_id_type i) override final
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) override final
	functions for adding /deleting nodes elements. More...
virtual Node *	add_node (Node *n) override final
	Add Node n to the end of the vertex array. More...
virtual Node *	add_node (std::unique_ptr< Node > n) override final
	Version of add_node() taking a std::unique_ptr by value. More...
virtual Node *	insert_node (Node *n) override final
	These methods are deprecated. More...
virtual Node *	insert_node (std::unique_ptr< Node > n) override final
	This method is deprecated. More...
virtual void	delete_node (Node *n) override final
	Removes the Node n from the mesh. More...
virtual void	renumber_node (dof_id_type old_id, dof_id_type new_id) override final
	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. More...
virtual Elem *	add_elem (Elem *e) override final
	Add elem e to the end of the element array. More...
virtual Elem *	add_elem (std::unique_ptr< Elem > e) override final
	Version of add_elem() taking a std::unique_ptr by value. More...
virtual Elem *	insert_elem (Elem *e) override final
	Insert elem e to the element array, preserving its id and replacing/deleting any existing element with the same id. More...
virtual Elem *	insert_elem (std::unique_ptr< Elem > e) override final
	Version of insert_elem() taking a std::unique_ptr by value. More...
virtual void	delete_elem (Elem *e) override final
	Removes element e from the mesh. More...
virtual void	renumber_elem (dof_id_type old_id, dof_id_type new_id) override final
	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. More...
virtual void	fix_broken_node_and_element_numbering () override
	There is no reason for a user to ever call this function. More...
std::vector< dof_id_type >	get_disconnected_subdomains (std::vector< subdomain_id_type > *subdomain_ids=nullptr) const
	Return IDs of representative elements of all disconnected subdomains. More...
std::unordered_map< dof_id_type, std::vector< std::vector< Point > > >	get_boundary_points () const
	Return all points on boundary. More...
	DECLARE_ELEM_ITERATORS (,,)
	Elem and Node iterator accessor functions. More...
	DECLARE_ELEM_ITERATORS (active_,,)
	DECLARE_ELEM_ITERATORS (ancestor_,,) DECLARE_ELEM_ITERATORS(subactive_
	DECLARE_ELEM_ITERATORS (local_,,) DECLARE_ELEM_ITERATORS(unpartitioned_
	DECLARE_ELEM_ITERATORS (facelocal_,,) DECLARE_ELEM_ITERATORS(level_
unsigned int level	DECLARE_ELEM_ITERATORS (pid_, processor_id_type pid, pid) DECLARE_ELEM_ITERATORS(type_
unsigned int level ElemType type	DECLARE_ELEM_ITERATORS (active_subdomain_, subdomain_id_type sid, sid) DECLARE_ELEM_ITERATORS(active_subdomain_set_
unsigned int level ElemType type std::set< subdomain_id_type > ss	DECLARE_ELEM_ITERATORS (not_active_,,)
	DECLARE_ELEM_ITERATORS (not_ancestor_,,)
	DECLARE_ELEM_ITERATORS (not_subactive_,,)
	DECLARE_ELEM_ITERATORS (not_local_,,)
	DECLARE_ELEM_ITERATORS (not_level_, unsigned int level, level) DECLARE_ELEM_ITERATORS(active_local_
	DECLARE_ELEM_ITERATORS (active_not_local_,,) DECLARE_ELEM_ITERATORS(active_unpartitioned_
	DECLARE_ELEM_ITERATORS (active_type_, ElemType type, type) DECLARE_ELEM_ITERATORS(active_pid_
processor_id_type pid	DECLARE_ELEM_ITERATORS (local_level_, unsigned int level, level) DECLARE_ELEM_ITERATORS(local_not_level_
processor_id_type pid unsigned int level	DECLARE_ELEM_ITERATORS (active_local_subdomain_, subdomain_id_type sid, sid) DECLARE_ELEM_ITERATORS(active_local_subdomain_set_
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) override final
virtual SimpleRange< const_element_iterator >	active_subdomain_elements_ptr_range (subdomain_id_type sid) const override final
virtual SimpleRange< element_iterator >	active_local_subdomain_elements_ptr_range (subdomain_id_type sid) override final
virtual SimpleRange< const_element_iterator >	active_local_subdomain_elements_ptr_range (subdomain_id_type sid) const override final
virtual SimpleRange< element_iterator >	active_subdomain_set_elements_ptr_range (std::set< subdomain_id_type > ss) override final
virtual SimpleRange< const_element_iterator >	active_subdomain_set_elements_ptr_range (std::set< subdomain_id_type > ss) const override final
	DECLARE_ELEM_ITERATORS (semilocal_,,) DECLARE_ELEM_ITERATORS(ghost_
	DECLARE_ELEM_ITERATORS (active_semilocal_,,) DECLARE_ELEM_ITERATORS(evaluable_
const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num	DECLARE_ELEM_ITERATORS (multi_evaluable_, std::vector< const DofMap *> dof_maps, dof_maps) DECLARE_ELEM_ITERATORS(flagged_
const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag	DECLARE_ELEM_ITERATORS (flagged_pid_, unsigned char rflag LIBMESH_COMMA processor_id_type pid, rflag LIBMESH_COMMA pid) DECLARE_NODE_ITERATORS(
const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag	DECLARE_NODE_ITERATORS (active_,,) DECLARE_NODE_ITERATORS(local_
const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag	DECLARE_NODE_ITERATORS (bnd_,,) DECLARE_NODE_ITERATORS(pid_
const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag processor_id_type pid	DECLARE_NODE_ITERATORS (bid_, boundary_id_type bid, bid) DECLARE_NODE_ITERATORS(evaluable_
virtual void	read (const std::string &name, void *mesh_data=nullptr, bool skip_renumber_nodes_and_elements=false, bool skip_find_neighbors=false) override
	Reads the file specified by name. More...
virtual void	write (const std::string &name) const override
	Write the file specified by name. More...
void	write (const std::string &name, const std::vector< Number > &values, const std::vector< std::string > &variable_names) const
	Write to the file specified by name. More...
virtual void	all_first_order () override
	Converts a mesh with higher-order elements into a mesh with linear elements. More...
virtual void	all_second_order_range (const SimpleRange< element_iterator > &range, const bool full_ordered=true) override
	Converts a (conforming, non-refined) mesh with linear elements into a mesh with second-order elements. More...
virtual void	all_complete_order_range (const SimpleRange< element_iterator > &range) override
	Converts a (conforming, non-refined) mesh with linear elements into a mesh with "complete" order elements, i.e. More...
void	create_pid_mesh (UnstructuredMesh &pid_mesh, const processor_id_type pid) const
	Generates a new mesh containing all the elements which are assigned to processor pid. More...
void	create_submesh (UnstructuredMesh &new_mesh, const const_element_iterator &it, const const_element_iterator &it_end) const
	Constructs a mesh called "new_mesh" from the current mesh by iterating over the elements between it and it_end and adding them to the new mesh. More...
std::size_t	stitch_meshes (const MeshBase &other_mesh, boundary_id_type this_mesh_boundary, boundary_id_type other_mesh_boundary, Real tol=TOLERANCE, bool clear_stitched_boundary_ids=false, bool verbose=true, bool use_binary_search=true, bool enforce_all_nodes_match_on_boundaries=false, bool merge_boundary_nodes_all_or_nothing=false, bool remap_subdomain_ids=false)
	Stitch other_mesh to this mesh so that this mesh is the union of the two meshes. More...
std::size_t	stitch_surfaces (boundary_id_type boundary_id_1, boundary_id_type boundary_id_2, Real tol=TOLERANCE, bool clear_stitched_boundary_ids=false, bool verbose=true, bool use_binary_search=true, bool enforce_all_nodes_match_on_boundaries=false, bool merge_boundary_nodes_all_or_nothing=false)
	Similar to stitch_meshes, except that we stitch two adjacent surfaces within this mesh. More...
virtual void	copy_nodes_and_elements (const MeshBase &other_mesh, const bool skip_find_neighbors=false, dof_id_type element_id_offset=0, dof_id_type node_id_offset=0, unique_id_type unique_id_offset=0, std::unordered_map< subdomain_id_type, subdomain_id_type > *id_remapping=nullptr)
	Deep copy of nodes and elements from another mesh object (used by subclass copy constructors and by mesh merging operations) More...
virtual void	find_neighbors (const bool reset_remote_elements=false, const bool reset_current_list=true) override
	Other functions from MeshBase requiring re-definition. More...
virtual bool	contract () override
	Delete subactive (i.e. More...
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). More...
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. More...
virtual std::unique_ptr< Partitioner > &	partitioner ()
	A partitioner to use at each prepare_for_use() More...
const BoundaryInfo &	get_boundary_info () const
	The information about boundary ids on the mesh. More...
BoundaryInfo &	get_boundary_info ()
	Writable information about boundary ids on the mesh. More...
bool	is_prepared () const
void	set_isnt_prepared ()
	Tells this we have done some operation where we should no longer consider ourself prepared. More...
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. More...
virtual bool	is_replicated () const
virtual void	allgather ()
	Gathers all elements and nodes of the mesh onto every processor. More...
virtual void	gather_to_zero ()
	Gathers all elements and nodes of the mesh onto processor zero. More...
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. More...
void	reinit_ghosting_functors ()
	Loops over ghosting functors and calls mesh_reinit() More...
unsigned int	mesh_dimension () const
void	set_mesh_dimension (unsigned char d)
	Resets the logical dimension of the mesh. More...
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. More...
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. More...
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. More...
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. More...
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. More...
void	change_elemset_code (dof_id_type old_code, dof_id_type new_code)
	Replace elemset code "old_code" with "new_code". More...
void	change_elemset_id (elemset_id_type old_id, elemset_id_type new_id)
	Replace elemset id "old_id" with "new_id". More...
unsigned int	spatial_dimension () const
void	set_spatial_dimension (unsigned char d)
	Sets the "spatial dimension" of the Mesh. More...
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
unique_id_type	next_unique_id ()
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. More...
virtual const Node &	node_ref (const dof_id_type i) const
virtual Node &	node_ref (const dof_id_type i)
virtual const Elem &	elem_ref (const dof_id_type i) const
virtual Elem &	elem_ref (const dof_id_type i)
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. More...
ElemMappingType	default_mapping_type () const
	Returns the default master space to physical space mapping basis functions to be used on newly added elements. More...
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. More...
unsigned char	default_mapping_data () const
	Returns any default data value used by the master space to physical space mapping. More...
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. More...
void	remove_orphaned_nodes ()
	Removes any orphaned nodes, nodes not connected to any elements. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
void	prepare_for_use (const bool skip_renumber_nodes_and_elements, const bool skip_find_neighbors)
	Prepare a newly ecreated (or read) mesh for use. More...
void	prepare_for_use (const bool skip_renumber_nodes_and_elements)
void	prepare_for_use ()
virtual void	partition (const unsigned int n_parts)
	Call the default partitioner (currently metis_partition()). More...
void	partition ()
virtual void	redistribute ()
	Redistribute elements between processors. More...
virtual void	update_post_partitioning ()
	Recalculate any cached data after elements and nodes have been repartitioned. More...
void	allow_renumbering (bool allow)
	If false is passed in then this mesh will no longer be renumbered when being prepared for use. More...
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. More...
bool	allow_find_neighbors () 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. More...
bool	allow_remote_element_removal () 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. More...
bool	skip_noncritical_partitioning () const
void	skip_partitioning (bool skip)
	If true is passed in then nothing on this mesh will be (re)partitioned. More...
bool	skip_partitioning () const
void	add_ghosting_functor (GhostingFunctor &ghosting_functor)
	Adds a functor which can specify ghosting requirements for use on distributed meshes. More...
void	add_ghosting_functor (std::shared_ptr< GhostingFunctor > ghosting_functor)
	Adds a functor which can specify ghosting requirements for use on distributed meshes. More...
void	remove_ghosting_functor (GhostingFunctor &ghosting_functor)
	Removes a functor which was previously added to the set of ghosting functors. More...
std::set< GhostingFunctor * >::const_iterator	ghosting_functors_begin () const
	Beginning of range of ghosting functors. More...
std::set< GhostingFunctor * >::const_iterator	ghosting_functors_end () const
	End of range of ghosting functors. More...
GhostingFunctor &	default_ghosting ()
	Default ghosting functor. More...
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). More...
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. More...
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. More...
virtual void	all_complete_order ()
	Calls the range-based version of this function with a range consisting of all elements in the mesh. More...
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. More...
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(). More...
Real	get_point_locator_close_to_point_tol () const
void	clear_point_locator ()
	Releases the current PointLocator object. More...
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. More...
bool	get_count_lower_dim_elems_in_point_locator () const
	Get the current value of _count_lower_dim_elems_in_point_locator. More...
virtual void	libmesh_assert_valid_parallel_ids () const
	Verify id and processor_id consistency of our elements and nodes containers. More...
std::string &	subdomain_name (subdomain_id_type id)
const std::string &	subdomain_name (subdomain_id_type id) const
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_
	ABSTRACT_ELEM_ITERATORS (semilocal_,) ABSTRACT_ELEM_ITERATORS(ghost_
	ABSTRACT_ELEM_ITERATORS (active_semilocal_,) ABSTRACT_ELEM_ITERATORS(evaluable_
const DofMap &dof_map LIBMESH_COMMA unsigned int 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. More...
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. More...
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. More...
void	print_constraint_rows (std::ostream &os=libMesh::out, bool print_nonlocal=false) const
	Prints (from processor 0) all mesh constraint rows. More...
std::string	get_local_constraints (bool print_nonlocal=false) const
	Gets a string reporting all mesh constraint rows local to this processor. More...
void	cache_elem_dims ()
void	cache_elem_data ()
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. More...
const MeshBase &	interior_mesh () const
MeshBase &	interior_mesh ()
void	set_interior_mesh (MeshBase &int_mesh)
	Sets the interior mesh. More...
const std::set< subdomain_id_type > &	get_mesh_subdomains () const
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const

Public Attributes
unsigned int	level
unsigned int level ElemType	type
unsigned int level ElemType type std::set< subdomain_id_type >	ss
processor_id_type	pid
processor_id_type pid unsigned int	level
processor_id_type pid unsigned int level std::set< subdomain_id_type >	ss
const DofMap &dof_map LIBMESH_COMMA unsigned int	var_num = libMesh::invalid_uint
const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char	rflag
const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag processor_id_type	pid
const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag processor_id_type pid const DofMap &dof_map LIBMESH_COMMA unsigned int	var_num = libMesh::invalid_uint
const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag processor_id_type pid const DofMap &dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num DECLARE_NODE_ITERATORS(multi_evaluable_, std::vector< const DofMap * > dof_maps, dof_maps) protected dof_id_typ	_n_nodes )
	The vertices (spatial coordinates) of the mesh. More...
std::vector< Elem * >	_elements
	The elements in the mesh. More...
dof_id_type	_n_elem

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. More...
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, Elem *const, Elem *const &, Elem *const * >	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 * >	node_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, Node *const, Node *const &, Node *const * >	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. More...
void	copy_cached_data (const MeshBase &other_mesh)
	Helper class to copy cached data, to synchronize with a possibly unprepared other_mesh. More...
bool	nodes_and_elements_equal (const MeshBase &other_mesh) const
	Tests for equality of all elements and nodes in the mesh. More...
unsigned int &	set_n_partitions ()
void	size_elem_extra_integers ()
	Size extra-integer arrays of all elements in the mesh. More...
void	size_node_extra_integers ()
	Size extra-integer arrays of all nodes in the mesh. More...
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. More...

Protected Attributes
std::unique_ptr< BoundaryInfo >	boundary_info
	This class holds the boundary information. More...
unsigned int	_n_parts
	The number of partitions the mesh has. More...
ElemMappingType	_default_mapping_type
	The default mapping type (typically Lagrange) between master and physical space to assign to newly added elements. More...
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. More...
bool	_is_prepared
	Flag indicating if the mesh has been prepared for use. More...
std::unique_ptr< PointLocatorBase >	_point_locator
	A PointLocator class for this mesh. More...
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. More...
std::unique_ptr< Partitioner >	_partitioner
	A partitioner to use at each prepare_for_use(). More...
unique_id_type	_next_unique_id
	The next available unique id for assigning ids to DOF objects. More...
MeshBase *	_interior_mesh
	Defaulting to this, a pointer to the mesh used to generate boundary elements on this. More...
bool	_skip_noncritical_partitioning
	If this is true then no partitioning should be done with the possible exception of orphaned nodes. More...
bool	_skip_all_partitioning
	If this is true then no partitioning should be done. More...
bool	_skip_renumber_nodes_and_elements
	If this is true then renumbering will be kept to a minimum. More...
bool	_skip_find_neighbors
	If this is true then we will skip find_neighbors in prepare_for_use. More...
bool	_allow_remote_element_removal
	If this is false then even on DistributedMesh remote elements will not be deleted during mesh preparation. More...
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. More...
std::set< unsigned char >	_elem_dims
	We cache the dimension of the elements present in the mesh. More...
std::set< Order >	_elem_default_orders
	We cache the (default) order of the geometric elements present in the mesh. More...
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) More...
std::set< subdomain_id_type >	_mesh_subdomains
	We cache the subdomain ids of the elements present in the mesh. More...
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). More...
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. More...
std::vector< std::string >	_elem_integer_names
	The array of names for integer data associated with each element in the mesh. More...
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. More...
std::vector< std::string >	_node_integer_names
	The array of names for integer data associated with each node in the mesh. More...
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. More...
std::unique_ptr< GhostingFunctor >	_default_ghosting
	The default geometric GhostingFunctor, used to implement standard libMesh element ghosting behavior. More...
std::set< GhostingFunctor * >	_ghosting_functors
	The list of all GhostingFunctor objects to be used when distributing a DistributedMesh. More...
std::map< GhostingFunctor *, std::shared_ptr< GhostingFunctor > >	_shared_functors
	Hang on to references to any GhostingFunctor objects we were passed in shared_ptr form. More...
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. More...
const Parallel::Communicator &	_communicator

Private Types
typedef std::vector< Elem * >::iterator	elem_iterator_imp
	Typedefs for the container implementation. More...
typedef std::vector< Elem * >::const_iterator	const_elem_iterator_imp
typedef std::vector< Node * >::iterator	node_iterator_imp
	Typedefs for the container implementation. More...
typedef std::vector< Node * >::const_iterator	const_node_iterator_imp

Detailed Description

The ReplicatedMesh class is derived from the MeshBase class, and is used to store identical copies of a full mesh data structure on each processor.

Most methods for this class are found in MeshBase, and most implementation details are found in UnstructuredMesh.

Author

Roy Stogner

Date

2007 Mesh data structure replicated on all processors.

Definition at line 46 of file replicated_mesh.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

protectedinherited

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

protectedinherited

Definition at line 2167 of file mesh_base.h.

const_elem_iterator_imp

typedef std::vector<Elem *>::const_iterator libMesh::ReplicatedMesh::const_elem_iterator_imp

private

Definition at line 347 of file replicated_mesh.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

protectedinherited

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

protectedinherited

Definition at line 2180 of file mesh_base.h.

const_node_iterator_imp

typedef std::vector<Node *>::const_iterator libMesh::ReplicatedMesh::const_node_iterator_imp

private

Definition at line 354 of file replicated_mesh.h.

constraint_rows_mapped_type

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

inherited

Definition at line 1697 of file mesh_base.h.

constraint_rows_type

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

inherited

Definition at line 1698 of file mesh_base.h.

elem_filter_iter [1/2]

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

protectedinherited

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

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

protectedinherited

Definition at line 2162 of file mesh_base.h.

elem_iterator_imp

typedef std::vector<Elem *>::iterator libMesh::ReplicatedMesh::elem_iterator_imp

private

Typedefs for the container implementation.

In this case, it's just a std::vector<Elem *>.

Definition at line 346 of file replicated_mesh.h.

elemset_type

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

inherited

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 318 of file mesh_base.h.

node_filter_iter [1/2]

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

protectedinherited

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

protectedinherited

Definition at line 2175 of file mesh_base.h.

node_iterator_imp

typedef std::vector<Node *>::iterator libMesh::ReplicatedMesh::node_iterator_imp

private

Typedefs for the container implementation.

In this case, it's just a std::vector<Node *>.

Definition at line 353 of file replicated_mesh.h.

Predicate

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

inherited

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

Definition at line 1403 of file mesh_base.h.

Constructor & Destructor Documentation

ReplicatedMesh() [1/4]

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

explicit

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 42 of file replicated_mesh.C.

References libMesh::MeshBase::_next_unique_id, libMesh::MeshBase::_partitioner, libMesh::Partitioner::build(), and libMesh::command_line_value().

                                                 :
  UnstructuredMesh (comm_in,d),
  _n_nodes(0), _n_elem(0)
{
#ifdef LIBMESH_ENABLE_UNIQUE_ID
  // In serial we just need to reset the next unique id to zero
  // here in the constructor.
  _next_unique_id = 0;
#endif

  const std::string default_partitioner = "metis";
  const std::string my_partitioner =
    libMesh::command_line_value("--default-partitioner",
                                default_partitioner);
  _partitioner = Partitioner::build
    (Utility::string_to_enum<PartitionerType>(my_partitioner));
}

ReplicatedMesh() [2/4]

libMesh::ReplicatedMesh::ReplicatedMesh

(

const MeshBase &

other_mesh

)

Copy-constructor.

This should be able to take a serial or parallel mesh.

Definition at line 100 of file replicated_mesh.C.

References libMesh::MeshBase::_is_prepared, libMesh::MeshBase::allow_find_neighbors(), libMesh::MeshBase::allow_remote_element_removal(), libMesh::MeshBase::allow_renumbering(), libMesh::MeshBase::copy_cached_data(), libMesh::MeshBase::copy_constraint_rows(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::MeshBase::get_boundary_info(), libMesh::MeshBase::get_subdomain_name_map(), libMesh::MeshBase::is_prepared(), libMesh::MeshBase::is_serial(), libMesh::MeshBase::MeshCommunication, libMesh::MeshBase::set_subdomain_name_map(), and libMesh::MeshBase::skip_partitioning().

                                                           :
  UnstructuredMesh (other_mesh),
  _n_nodes(0), _n_elem(0) // copy_* will increment this
{
  this->copy_nodes_and_elements(other_mesh, true);

  this->allow_find_neighbors(other_mesh.allow_find_neighbors());
  this->allow_renumbering(other_mesh.allow_renumbering());
  this->allow_remote_element_removal(other_mesh.allow_remote_element_removal());
  this->skip_partitioning(other_mesh.skip_partitioning());

  // The prepare_for_use() in copy_nodes_and_elements() is going to be
  // tricky to remove without breaking backwards compatibility, but it
  // updates some things we want to just copy.
  this->copy_cached_data(other_mesh);

  this->copy_constraint_rows(other_mesh);

  this->_is_prepared = other_mesh.is_prepared();

  auto & this_boundary_info = this->get_boundary_info();
  const auto & other_boundary_info = other_mesh.get_boundary_info();

  this_boundary_info = other_boundary_info;

  this->set_subdomain_name_map() = other_mesh.get_subdomain_name_map();

  // If other_mesh is distributed, then we've got parts of it on each
  // processor but we're not replicated yet; fix that.
  if (!other_mesh.is_serial())
    MeshCommunication().allgather(*this);
}

ReplicatedMesh() [3/4]

libMesh::ReplicatedMesh::ReplicatedMesh

(

const ReplicatedMesh &

other_mesh

)

Copy-constructor, possibly specialized for a serial mesh.

Definition at line 91 of file replicated_mesh.C.

References libMesh::MeshBase::_next_unique_id.

                                                                 :
  ReplicatedMesh(static_cast<const MeshBase&>(other_mesh))
{
#ifdef LIBMESH_ENABLE_UNIQUE_ID
  this->_next_unique_id = other_mesh._next_unique_id;
#endif
}

ReplicatedMesh() [4/4]

libMesh::ReplicatedMesh::ReplicatedMesh ( ReplicatedMesh &&  )

delete

Move-constructor deleted in MeshBase.

~ReplicatedMesh()

libMesh::ReplicatedMesh::~ReplicatedMesh ( )

virtual

Destructor.

Definition at line 82 of file replicated_mesh.C.

References clear().

{
  this->ReplicatedMesh::clear();  // Free nodes and elements
}

Member Function Documentation

ABSTRACT_ELEM_ITERATORS() [1/15]

libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS ( )

inherited

ABSTRACT_ELEM_ITERATORS() [2/15]

libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS ( ancestor_  )

inherited

ABSTRACT_ELEM_ITERATORS() [3/15]

libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS ( local_  )

inherited

ABSTRACT_ELEM_ITERATORS() [4/15]

libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS ( facelocal_  )

inherited

ABSTRACT_ELEM_ITERATORS() [5/15]

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

inherited

ABSTRACT_ELEM_ITERATORS() [6/15]

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

inherited

ABSTRACT_ELEM_ITERATORS() [7/15]

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

inherited

ABSTRACT_ELEM_ITERATORS() [8/15]

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

inherited

ABSTRACT_ELEM_ITERATORS() [9/15]

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

inherited

ABSTRACT_ELEM_ITERATORS() [10/15]

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

inherited

ABSTRACT_ELEM_ITERATORS() [11/15]

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

inherited

ABSTRACT_ELEM_ITERATORS() [12/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  )

inherited

ABSTRACT_ELEM_ITERATORS() [13/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  )

inherited

ABSTRACT_ELEM_ITERATORS() [14/15]

libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS ( semilocal_  )

inherited

ABSTRACT_ELEM_ITERATORS() [15/15]

libMesh::MeshBase::ABSTRACT_ELEM_ITERATORS ( active_semilocal_  )

inherited

active_local_subdomain_elements_ptr_range() [1/2]

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

inlinefinaloverridevirtual

Implements libMesh::MeshBase.

Definition at line 293 of file replicated_mesh.h.

{ return active_local_subdomain_element_ptr_range(sid); }

active_local_subdomain_elements_ptr_range() [2/2]

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

inlinefinaloverridevirtual

Implements libMesh::MeshBase.

Definition at line 294 of file replicated_mesh.h.

{ return active_local_subdomain_element_ptr_range(sid); }

active_subdomain_elements_ptr_range() [1/2]

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

inlinefinaloverridevirtual

Implements libMesh::MeshBase.

Definition at line 291 of file replicated_mesh.h.

{ return active_subdomain_element_ptr_range(sid); }

active_subdomain_elements_ptr_range() [2/2]

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

inlinefinaloverridevirtual

Implements libMesh::MeshBase.

Definition at line 292 of file replicated_mesh.h.

{ return active_subdomain_element_ptr_range(sid); }

active_subdomain_set_elements_ptr_range() [1/2]

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

inlinefinaloverridevirtual

Implements libMesh::MeshBase.

Definition at line 295 of file replicated_mesh.h.

References ss.

{ return active_subdomain_set_element_ptr_range(ss); }

active_subdomain_set_elements_ptr_range() [2/2]

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

inlinefinaloverridevirtual

Implements libMesh::MeshBase.

Definition at line 296 of file replicated_mesh.h.

References ss.

{ return active_subdomain_set_element_ptr_range(ss); }

add_elem() [1/2]

Elem * libMesh::ReplicatedMesh::add_elem ( Elem *  e )

finaloverridevirtual

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::prepare_for_use() after elements are added to and/or deleted from the mesh.

Implements libMesh::MeshBase.

Definition at line 278 of file replicated_mesh.C.

References libMesh::MeshBase::_elem_integer_default_values, libMesh::MeshBase::_elem_integer_names, _elements, _n_elem, libMesh::MeshBase::_next_unique_id, libMesh::DofObject::add_extra_integers(), libMesh::MeshBase::default_mapping_data(), libMesh::MeshBase::default_mapping_type(), libMesh::DofObject::id(), libMesh::libmesh_assert(), libMesh::DofObject::set_id(), libMesh::Elem::set_mapping_data(), libMesh::Elem::set_mapping_type(), libMesh::DofObject::set_unique_id(), libMesh::DofObject::unique_id(), libMesh::DofObject::valid_id(), and libMesh::DofObject::valid_unique_id().

Referenced by add_elem(), and libMesh::C0Polyhedron::retriangulate().

{
  libmesh_assert(e);

  // We no longer merely append elements with ReplicatedMesh

  // If the user requests a valid id that doesn't correspond to an
  // existing element, let's give them that id, resizing the elements
  // container if necessary.
  if (!e->valid_id())
    e->set_id (cast_int<dof_id_type>(_elements.size()));

#ifdef LIBMESH_ENABLE_UNIQUE_ID
  if (!e->valid_unique_id())
    e->set_unique_id(_next_unique_id++);
  else
   _next_unique_id = std::max(_next_unique_id, e->unique_id()+1);
#endif

  const dof_id_type id = e->id();

  if (id < _elements.size())
    {
      // This should *almost* never happen, but we rely on it when
      // using allgather to replicate a not-yet-actually-replicated
      // ReplicatedMesh under construction in parallel.
      if (e == _elements[id])
        return e;

      // Overwriting existing elements is still probably a mistake.
      libmesh_assert(!_elements[id]);
    }
  else
    {
      _elements.resize(id+1, nullptr);
    }

  ++_n_elem;
  _elements[id] = e;

  // Make sure any new element is given space for any extra integers
  // we've requested
  e->add_extra_integers(_elem_integer_names.size(),
                        _elem_integer_default_values);

  // And set mapping type and data on any new element
  e->set_mapping_type(this->default_mapping_type());
  e->set_mapping_data(this->default_mapping_data());

  return e;
}

add_elem() [2/2]

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

finaloverridevirtual

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.

Implements libMesh::MeshBase.

Definition at line 330 of file replicated_mesh.C.

References add_elem().

{
  // The mesh now takes ownership of the Elem. Eventually the guts of
  // add_elem() will get moved to a private helper function, and
  // calling add_elem() directly will be deprecated.
  return add_elem(e.release());
}

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  )

inlineinherited

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 2316 of file mesh_base.h.

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

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

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  )

inlineinherited

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

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

Referenced by ExtraIntegersTest::build_mesh().

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

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  )

inherited

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 560 of file mesh_base.C.

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

Referenced by libMesh::MeshBase::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().

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

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  )

inherited

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 583 of file mesh_base.C.

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

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

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

add_elemset_code()

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

inherited

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 398 of file mesh_base.C.

References libMesh::MeshBase::_all_elemset_ids, libMesh::MeshBase::_elemset_codes, and libMesh::MeshBase::_elemset_codes_inverse_map.

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

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

add_ghosting_functor() [1/2]

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

inlineinherited

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 1267 of file mesh_base.h.

References libMesh::MeshBase::_ghosting_functors.

Referenced by libMesh::DofMap::add_algebraic_ghosting_functor(), libMesh::DofMap::add_coupling_functor(), libMesh::MeshBase::add_ghosting_functor(), main(), libMesh::MeshBase::MeshBase(), and EquationSystemsTest::testDisableDefaultGhosting().

  { _ghosting_functors.insert(&ghosting_functor); }

add_ghosting_functor() [2/2]

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

inlineinherited

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 1278 of file mesh_base.h.

References libMesh::MeshBase::_shared_functors, and libMesh::MeshBase::add_ghosting_functor().

  { _shared_functors[ghosting_functor.get()] = ghosting_functor;
    this->add_ghosting_functor(*ghosting_functor); }

add_node() [1/2]

Node * libMesh::ReplicatedMesh::add_node ( Node *  n )

finaloverridevirtual

Add Node n to the end of the vertex array.

Implements libMesh::MeshBase.

Definition at line 502 of file replicated_mesh.C.

References _n_nodes, libMesh::MeshBase::_next_unique_id, libMesh::MeshBase::_node_integer_default_values, libMesh::MeshBase::_node_integer_names, libMesh::DofObject::add_extra_integers(), libMesh::DofObject::id(), libMesh::libmesh_assert(), libMesh::DofObject::set_id(), libMesh::DofObject::set_unique_id(), libMesh::DofObject::unique_id(), libMesh::DofObject::valid_id(), and libMesh::DofObject::valid_unique_id().

Referenced by add_node().

{
  libmesh_assert(n);

  // If the user requests a valid id, either set the existing
  // container entry or resize the container to fit the new node.
  if (n->valid_id())
    {
      const dof_id_type id = n->id();
      if (id < _nodes.size())
        libmesh_assert(!_nodes[id]);
      else
        _nodes.resize(id+1); // default nullptr

      _nodes[id] = n;
    }
  else
    {
      n->set_id (cast_int<dof_id_type>(_nodes.size()));
      _nodes.push_back(n);
    }

  ++_n_nodes;

#ifdef LIBMESH_ENABLE_UNIQUE_ID
  if (!n->valid_unique_id())
    n->set_unique_id(_next_unique_id++);
  else
   _next_unique_id = std::max(_next_unique_id, n->unique_id()+1);
#endif

  n->add_extra_integers(_node_integer_names.size(),
                        _node_integer_default_values);

  return n;
}

add_node() [2/2]

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

finaloverridevirtual

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.

Implements libMesh::MeshBase.

Definition at line 539 of file replicated_mesh.C.

References add_node().

{
  // The mesh now takes ownership of the Node. Eventually the guts of
  // add_node() will get moved to a private helper function, and
  // calling add_node() directly will be deprecated.
  return add_node(n.release());
}

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  )

inlineinherited

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 2365 of file mesh_base.h.

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

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

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  )

inlineinherited

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 2341 of file mesh_base.h.

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

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

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

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  )

inherited

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 649 of file mesh_base.C.

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

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

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

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  )

inherited

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 672 of file mesh_base.C.

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

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

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

add_point()

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

finaloverridevirtual

functions for adding /deleting nodes elements.

Implements libMesh::MeshBase.

Definition at line 449 of file replicated_mesh.C.

References _n_nodes, libMesh::MeshBase::_next_unique_id, libMesh::MeshBase::_node_integer_default_values, libMesh::MeshBase::_node_integer_names, libMesh::DofObject::add_extra_integers(), libMesh::Node::build(), libMesh::DofObject::invalid_id, libMesh::libmesh_assert(), libMesh::DofObject::processor_id(), libMesh::DofObject::set_unique_id(), libMesh::DofObject::unique_id(), and libMesh::DofObject::valid_unique_id().

Referenced by libMesh::C0Polyhedron::retriangulate().

{
  Node * n = nullptr;

  // If the user requests a valid id, either
  // provide the existing node or resize the container
  // to fit the new node.
  if (id != DofObject::invalid_id)
    if (id < _nodes.size())
      n = _nodes[id];
    else
      _nodes.resize(id+1);
  else
    _nodes.push_back (static_cast<Node *>(nullptr));

  // if the node already exists, then assign new (x,y,z) values
  if (n)
    *n = p;
  // otherwise build a new node, put it in the right spot, and return
  // a valid pointer.
  else
    {
      n = Node::build(p, (id == DofObject::invalid_id) ?
                      cast_int<dof_id_type>(_nodes.size()-1) : id).release();
      n->processor_id() = proc_id;

      n->add_extra_integers(_node_integer_names.size(),
                            _node_integer_default_values);

#ifdef LIBMESH_ENABLE_UNIQUE_ID
      if (!n->valid_unique_id())
        n->set_unique_id(_next_unique_id++);
      else
       _next_unique_id = std::max(_next_unique_id, n->unique_id()+1);
#endif

      ++_n_nodes;
      if (id == DofObject::invalid_id)
        _nodes.back() = n;
      else
        _nodes[id] = n;
    }

  // better not pass back a nullptr.
  libmesh_assert (n);

  return n;
}

all_complete_order()

void libMesh::MeshBase::all_complete_order ( )

virtualinherited

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

Definition at line 1613 of file mesh_base.C.

References libMesh::MeshBase::all_complete_order_range().

Referenced by AllSecondOrderTest::allCompleteOrder(), libMesh::TriangulatorInterface::increase_triangle_order(), and main().

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

all_complete_order_range()

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

overridevirtualinherited

Converts a (conforming, non-refined) mesh with linear elements into a mesh with "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.

Implements libMesh::MeshBase.

Definition at line 1660 of file unstructured_mesh.C.

References libMesh::Elem::complete_order_equivalent_type(), libMesh::MeshBase::mesh_dimension(), libMesh::MeshBase::n_nodes(), and libMesh::MeshBase::reserve_nodes().

{
  LOG_SCOPE("all_complete_order()", "Mesh");

  /*
   * The maximum number of new higher-order nodes we might be adding,
   * for use when picking unique unique_id values later. This variable
   * is not used unless unique ids are enabled.
   */
  unsigned int max_new_nodes_per_elem;

  /*
   * for speed-up of the \p add_point() method, we
   * can reserve memory.  Guess the number of additional
   * nodes based on the element spatial dimensions and the
   * total number of nodes in the mesh as an upper bound.
   */
  switch (this->mesh_dimension())
    {
    case 1:
      /*
       * in 1D, there can only be order-increase from Edge2
       * to Edge3.  Something like 1/2 of n_nodes() have
       * to be added
       */
      max_new_nodes_per_elem = 3 - 2;
      this->reserve_nodes(static_cast<unsigned int>
                          (1.5*static_cast<double>(this->n_nodes())));
      break;

    case 2:
      /*
       * in 2D, we typically refine from Tri6 to Tri7 (1.1667 times
       * the nodes) but might refine from Quad4 to Quad9
       * (2.25 times the nodes)
       */
      max_new_nodes_per_elem = 9 - 4;
      this->reserve_nodes(static_cast<unsigned int>
                          (2*static_cast<double>(this->n_nodes())));
      break;


    case 3:
      /*
       * in 3D, we typically refine from Tet10 to Tet14 (factor = 1.4)
       * but may go Hex8 to Hex27 (something  > 3).  Since in 3D there
       * _are_ already quite some nodes, and since we do not want to
       * overburden the memory by a too conservative guess, use a
       * moderate bound
       */
      max_new_nodes_per_elem = 27 - 8;
      this->reserve_nodes(static_cast<unsigned int>
                          (2.5*static_cast<double>(this->n_nodes())));
      break;

    default:
      // Hm?
      libmesh_error_msg("Unknown mesh dimension " << this->mesh_dimension());
    }

  // All the real work is done in the helper function
  all_increased_order_range(*this, range, max_new_nodes_per_elem,
    [](ElemType t) {
      return Elem::complete_order_equivalent_type(t);
    });
}

all_first_order()

void libMesh::UnstructuredMesh::all_first_order ( )

overridevirtualinherited

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.

Prepare to identify (and then delete) a bunch of no-longer-used nodes.

If the second order element had any boundary conditions they should be transferred to the first-order element. The old boundary conditions will be removed from the BoundaryInfo data structure by insert_elem.

Implements libMesh::MeshBase.

Definition at line 1458 of file unstructured_mesh.C.

References libMesh::Elem::add_child(), libMesh::DofObject::add_extra_integers(), libMesh::Elem::build(), libMesh::Elem::child_ptr(), libMesh::BoundaryInfo::copy_boundary_ids(), libMesh::MeshBase::delete_node(), libMesh::Elem::first_order_equivalent_type(), libMesh::MeshBase::get_boundary_info(), libMesh::Elem::inherit_data_from(), libMesh::MeshBase::insert_elem(), libMesh::libmesh_assert(), libMesh::MeshBase::max_node_id(), libMesh::Elem::n_vertices(), libMesh::Elem::node_id(), libMesh::Elem::parent(), libMesh::MeshBase::prepare_for_use(), libMesh::BoundaryInfo::regenerate_id_sets(), libMesh::remote_elem, libMesh::Elem::replace_child(), libMesh::DofObject::set_extra_integer(), libMesh::DofObject::set_id(), libMesh::Elem::set_neighbor(), libMesh::Elem::set_node(), libMesh::Partitioner::set_node_processor_ids(), libMesh::Elem::set_p_level(), libMesh::Elem::set_p_refinement_flag(), libMesh::Elem::set_parent(), libMesh::Elem::set_refinement_flag(), and libMesh::DofObject::set_unique_id().

{
  LOG_SCOPE("all_first_order()", "Mesh");

  std::vector<bool> node_touched_by_me(this->max_node_id(), false);

  // Loop over the high-ordered elements.
  // First make sure they _are_ indeed high-order, and then replace
  // them with an equivalent first-order element.
  for (auto & so_elem : element_ptr_range())
    {
      libmesh_assert(so_elem);

      /*
       * build the first-order equivalent, add to
       * the new_elements list.
       */
      auto lo_elem = Elem::build
        (Elem::first_order_equivalent_type
         (so_elem->type()), so_elem->parent());

      const unsigned short n_sides = so_elem->n_sides();

      for (unsigned short s=0; s != n_sides; ++s)
        if (so_elem->neighbor_ptr(s) == remote_elem)
          lo_elem->set_neighbor(s, const_cast<RemoteElem *>(remote_elem));

#ifdef LIBMESH_ENABLE_AMR
      /*
       * Reset the parent links of any child elements
       */
      if (so_elem->has_children())
        for (unsigned int c = 0, nc = so_elem->n_children(); c != nc; ++c)
          {
            Elem * child = so_elem->child_ptr(c);
            if (child != remote_elem)
              child->set_parent(lo_elem.get());
            lo_elem->add_child(child, c);
          }

      /*
       * Reset the child link of any parent element
       */
      if (so_elem->parent())
        {
          unsigned int c =
            so_elem->parent()->which_child_am_i(so_elem);
          lo_elem->parent()->replace_child(lo_elem.get(), c);
        }

      /*
       * Copy as much data to the new element as makes sense
       */
      lo_elem->set_p_level(so_elem->p_level());
      lo_elem->set_refinement_flag(so_elem->refinement_flag());
      lo_elem->set_p_refinement_flag(so_elem->p_refinement_flag());
#endif

      libmesh_assert_equal_to (lo_elem->n_vertices(), so_elem->n_vertices());

      /*
       * By definition the vertices of the linear and
       * second order element are identically numbered.
       * transfer these.
       */
      for (unsigned int v=0, snv=so_elem->n_vertices(); v < snv; v++)
        {
          lo_elem->set_node(v, so_elem->node_ptr(v));
          node_touched_by_me[lo_elem->node_id(v)] = true;
        }

      /*
       * find_neighbors relies on remote_elem neighbor links being
       * properly maintained.
       */
      for (unsigned short s=0; s != n_sides; s++)
        {
          if (so_elem->neighbor_ptr(s) == remote_elem)
            lo_elem->set_neighbor(s, const_cast<RemoteElem*>(remote_elem));
        }

      this->get_boundary_info().copy_boundary_ids
        (this->get_boundary_info(), so_elem, lo_elem.get());

      /*
       * The new first-order element is ready.
       * Inserting it into the mesh will replace and delete
       * the second-order element.
       */
      lo_elem->set_id(so_elem->id());
#ifdef LIBMESH_ENABLE_UNIQUE_ID
      lo_elem->set_unique_id(so_elem->unique_id());
#endif

      const unsigned int nei = so_elem->n_extra_integers();
      lo_elem->add_extra_integers(nei);
      for (unsigned int i=0; i != nei; ++i)
        lo_elem->set_extra_integer(i, so_elem->get_extra_integer(i));

      lo_elem->inherit_data_from(*so_elem);

      this->insert_elem(std::move(lo_elem));
    }

  // Deleting nodes does not invalidate iterators, so this is safe.
  for (const auto & node : this->node_ptr_range())
    if (!node_touched_by_me[node->id()])
      this->delete_node(node);

  // If crazy people applied boundary info to non-vertices and then
  // deleted those non-vertices, we should make sure their boundary id
  // caches are correct.
  this->get_boundary_info().regenerate_id_sets();

  // On hanging nodes that used to also be second order nodes, we
  // might now have an invalid nodal processor_id()
  Partitioner::set_node_processor_ids(*this);

  // delete or renumber nodes if desired
  this->prepare_for_use();
}

all_second_order()

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

inherited

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

Definition at line 1608 of file mesh_base.C.

References libMesh::MeshBase::all_second_order_range().

Referenced by AllSecondOrderTest::allSecondOrder(), build_domain(), libMesh::TriangulatorInterface::increase_triangle_order(), main(), ExtraIntegersTest::test_helper(), and InfFERadialTest::testRefinement().

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

all_second_order_range()

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

overridevirtualinherited

Converts a (conforming, non-refined) mesh with linear elements into a mesh with second-order elements.

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.

Implements libMesh::MeshBase.

Definition at line 1592 of file unstructured_mesh.C.

References libMesh::MeshBase::mesh_dimension(), libMesh::MeshBase::n_nodes(), libMesh::MeshBase::reserve_nodes(), and libMesh::Elem::second_order_equivalent_type().

{
  LOG_SCOPE("all_second_order_range()", "Mesh");

  /*
   * The maximum number of new second order nodes we might be adding,
   * for use when picking unique unique_id values later. This variable
   * is not used unless unique ids are enabled.
   */
  unsigned int max_new_nodes_per_elem;

  /*
   * For speed-up of the \p add_point() method, we
   * can reserve memory.  Guess the number of additional
   * nodes based on the element spatial dimensions and the
   * total number of nodes in the mesh as an upper bound.
   */
  switch (this->mesh_dimension())
    {
    case 1:
      /*
       * in 1D, there can only be order-increase from Edge2
       * to Edge3.  Something like 1/2 of n_nodes() have
       * to be added
       */
      max_new_nodes_per_elem = 3 - 2;
      this->reserve_nodes(static_cast<unsigned int>
                          (1.5*static_cast<double>(this->n_nodes())));
      break;

    case 2:
      /*
       * in 2D, either refine from Tri3 to Tri6 (double the nodes)
       * or from Quad4 to Quad8 (again, double) or Quad9 (2.25 that much)
       */
      max_new_nodes_per_elem = 9 - 4;
      this->reserve_nodes(static_cast<unsigned int>
                          (2*static_cast<double>(this->n_nodes())));
      break;


    case 3:
      /*
       * in 3D, either refine from Tet4 to Tet10 (factor = 2.5) up to
       * Hex8 to Hex27 (something  > 3).  Since in 3D there _are_ already
       * quite some nodes, and since we do not want to overburden the memory by
       * a too conservative guess, use the lower bound
       */
      max_new_nodes_per_elem = 27 - 8;
      this->reserve_nodes(static_cast<unsigned int>
                          (2.5*static_cast<double>(this->n_nodes())));
      break;

    default:
      // Hm?
      libmesh_error_msg("Unknown mesh dimension " << this->mesh_dimension());
    }

  // All the real work is done in the helper function
  all_increased_order_range(*this, range, max_new_nodes_per_elem,
    [full_ordered](ElemType t) {
      return Elem::second_order_equivalent_type(t, full_ordered);
    });
}

allgather()

virtual void libMesh::MeshBase::allgather ( )

inlinevirtualinherited

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

Reimplemented in libMesh::DistributedMesh.

Definition at line 240 of file mesh_base.h.

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

{}

allow_find_neighbors() [1/2]

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

inlineinherited

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

Definition at line 1203 of file mesh_base.h.

References libMesh::MeshBase::_skip_find_neighbors.

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

{ _skip_find_neighbors = !allow; }

allow_find_neighbors() [2/2]

bool libMesh::MeshBase::allow_find_neighbors ( ) const

inlineinherited

Definition at line 1204 of file mesh_base.h.

References libMesh::MeshBase::_skip_find_neighbors.

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

{ return !_skip_find_neighbors; }

allow_remote_element_removal() [1/2]

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

inlineinherited

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 1212 of file mesh_base.h.

References libMesh::MeshBase::_allow_remote_element_removal.

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

{ _allow_remote_element_removal = allow; }

allow_remote_element_removal() [2/2]

bool libMesh::MeshBase::allow_remote_element_removal ( ) const

inlineinherited

Definition at line 1213 of file mesh_base.h.

References libMesh::MeshBase::_allow_remote_element_removal.

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

{ return _allow_remote_element_removal; }

allow_renumbering() [1/2]

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

inlineinherited

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 1196 of file mesh_base.h.

References libMesh::MeshBase::_skip_renumber_nodes_and_elements.

Referenced by AllSecondOrderTest::allSecondOrderMixedFixing(), libMesh::DistributedMesh::DistributedMesh(), AllSecondOrderTest::MixedFixingImpl(), libMesh::NameBasedIO::read(), libMesh::GMVIO::read(), ReplicatedMesh(), libMesh::C0Polyhedron::retriangulate(), WriteVecAndScalar::setupTests(), ConstraintOperatorTest::test1DCoarseningNewNodes(), ConstraintOperatorTest::test1DCoarseningOperator(), MeshGenerationTest::testBuildSphere(), MeshInputTest::testCopyElementSolutionImpl(), MeshInputTest::testCopyElementVectorImpl(), MeshInputTest::testCopyNodalSolutionImpl(), ConstraintOperatorTest::testCoreform(), MeshGenerationTest::tester(), ExtraIntegersTest::testExtraIntegersExodusReading(), SystemsTest::testProjectMatrix1D(), SystemsTest::testProjectMatrix2D(), SystemsTest::testProjectMatrix3D(), EquationSystemsTest::testRefineThenReinitPreserveFlags(), EquationSystemsTest::testRepartitionThenReinit(), BoundaryInfoTest::testShellFaceConstraints(), MeshInputTest::testVTKPreserveElemIds(), MeshInputTest::testVTKPreserveSubdomainIds(), WriteNodesetData::testWriteImpl(), WriteSidesetData::testWriteImpl(), and WriteElemsetData::testWriteImpl().

{ _skip_renumber_nodes_and_elements = !allow; }

allow_renumbering() [2/2]

bool libMesh::MeshBase::allow_renumbering ( ) const

inlineinherited

Definition at line 1197 of file mesh_base.h.

References libMesh::MeshBase::_skip_renumber_nodes_and_elements.

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

{ return !_skip_renumber_nodes_and_elements; }

assign()

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

overridevirtual

Shim to call the move assignment operator for this class.

Implements libMesh::UnstructuredMesh.

Definition at line 151 of file replicated_mesh.C.

{
  *this = std::move(cast_ref<ReplicatedMesh&>(other_mesh));

  return *this;
}

cache_elem_data()

void libMesh::MeshBase::cache_elem_data ( )

inherited

Definition at line 1733 of file mesh_base.C.

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

Referenced by libMesh::MeshBase::cache_elem_dims(), libMesh::MeshBase::prepare_for_use(), and libMesh::MeshBase::set_elem_dimensions().

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

cache_elem_dims()

void libMesh::MeshBase::cache_elem_dims ( )

inherited

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 1725 of file mesh_base.C.

References libMesh::MeshBase::cache_elem_data().

{
  libmesh_deprecated();

  this->cache_elem_data();
}

change_elemset_code()

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

inherited

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 454 of file mesh_base.C.

References libMesh::MeshBase::_elemset_codes, libMesh::MeshBase::_elemset_codes_inverse_map, libMesh::MeshBase::add_elemset_code(), libMesh::MeshBase::get_elem_integer_index(), and libMesh::MeshBase::has_elem_integer().

{
  // 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
  for (auto & elem : this->element_ptr_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);
    }
}

change_elemset_id()

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

inherited

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 502 of file mesh_base.C.

References libMesh::MeshBase::_all_elemset_ids, libMesh::MeshBase::_elemset_codes, and libMesh::MeshBase::_elemset_codes_inverse_map.

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

clear()

void libMesh::ReplicatedMesh::clear ( )

overridevirtual

Clear all internal data.

Reimplemented from libMesh::MeshBase.

Definition at line 670 of file replicated_mesh.C.

References _n_nodes, libMesh::MeshBase::clear(), libMesh::DofMap::clear(), and clear_elems().

Referenced by ~ReplicatedMesh().

{
  // Call parent clear function
  MeshBase::clear();

  // Clear our elements and nodes
  // There is no need to remove them from
  // the BoundaryInfo data structure since we
  // already cleared it.
  this->ReplicatedMesh::clear_elems();

  for (auto & node : _nodes)
    delete node;

  _n_nodes = 0;
  _nodes.clear();
}

clear_elems()

void libMesh::ReplicatedMesh::clear_elems ( )

overridevirtual

Clear internal Elem data.

Implements libMesh::MeshBase.

Definition at line 690 of file replicated_mesh.C.

References _elements, and _n_elem.

Referenced by clear().

{
  for (auto & elem : _elements)
    delete elem;

  _n_elem = 0;
  _elements.clear();
}

clear_point_locator()

void libMesh::MeshBase::clear_point_locator ( )

inherited

Releases the current PointLocator object.

Definition at line 1671 of file mesh_base.C.

References libMesh::MeshBase::_point_locator.

Referenced by libMesh::MeshBase::clear(), libMesh::UnstructuredMesh::contract(), libMesh::MeshCommunication::delete_remote_elements(), and libMesh::MeshBase::prepare_for_use().

{
  _point_locator.reset(nullptr);
}

clone()

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

inlineoverridevirtual

Virtual copy-constructor, creates a copy of this mesh.

Implements libMesh::MeshBase.

Reimplemented in libMesh::SerialMesh.

Definition at line 105 of file replicated_mesh.h.

References libMesh::libmesh_assert().

  {
    auto returnval = std::make_unique<ReplicatedMesh>(*this);
#ifdef DEBUG
    libmesh_assert(*returnval == *this);
#endif
    return returnval;
  }

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.

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::__libmesh_petsc_diff_solver_jacobian(), libMesh::__libmesh_petsc_diff_solver_monitor(), libMesh::__libmesh_petsc_diff_solver_residual(), libMesh::__libmesh_tao_equality_constraints(), libMesh::__libmesh_tao_equality_constraints_jacobian(), libMesh::__libmesh_tao_gradient(), libMesh::__libmesh_tao_hessian(), libMesh::__libmesh_tao_inequality_constraints(), libMesh::__libmesh_tao_inequality_constraints_jacobian(), libMesh::__libmesh_tao_objective(), libMesh::MeshRefinement::_coarsen_elements(), libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::Partitioner::_find_global_index_by_pid_map(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< libMesh::Number >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_mult(), libMesh::SlepcEigenSolver< libMesh::Number >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_mult_add(), libMesh::MeshRefinement::_refine_elements(), libMesh::MeshRefinement::_smooth_flags(), libMesh::DofMap::add_constraints_to_send_list(), add_cube_convex_hull_to_mesh(), libMesh::PetscDMWrapper::add_dofs_helper(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::TransientRBConstruction::add_IC_to_RB_space(), libMesh::RBEIMEvaluation::add_interpolation_data(), libMesh::CondensedEigenSystem::add_matrices(), libMesh::EigenSystem::add_matrices(), libMesh::System::add_matrix(), libMesh::RBConstruction::add_scaled_matrix_and_vector(), libMesh::System::add_variable(), libMesh::System::add_variables(), libMesh::System::add_vector(), libMesh::MeshTools::Modification::all_tri(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::TransientRBConstruction::allocate_data_structures(), libMesh::RBConstruction::allocate_data_structures(), libMesh::TransientRBConstruction::assemble_affine_expansion(), libMesh::AdvectionSystem::assemble_claw_rhs(), libMesh::FEMSystem::assemble_qoi(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::MeshCommunication::assign_global_indices(), libMesh::Partitioner::assign_partitioning(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::Partitioner::build_graph(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::PetscDMWrapper::build_section(), libMesh::PetscDMWrapper::build_sf(), libMesh::MeshBase::cache_elem_data(), libMesh::System::calculate_norm(), libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::RBConstruction::compute_Fq_representor_innerprods(), libMesh::RBConstruction::compute_max_error_bound(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::RBConstruction::compute_output_dual_innerprods(), libMesh::RBConstruction::compute_residual_dual_norm_slow(), libMesh::RBSCMConstruction::compute_SCM_bounds_on_training_set(), libMesh::DofMap::computed_sparsity_already(), libMesh::Problem_Interface::computeF(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), libMesh::ContinuationSystem::ContinuationSystem(), libMesh::MeshBase::copy_constraint_rows(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::CondensedEigenSystem::copy_super_to_sub(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::MeshTools::create_bounding_box(), libMesh::DofMap::create_dof_constraints(), libMesh::MeshTools::create_nodal_bounding_box(), libMesh::MeshRefinement::create_parent_error_vector(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::MeshTools::create_subdomain_bounding_box(), libMesh::PetscMatrix< T >::create_submatrix_nosort(), create_wrapped_function(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::RBEIMEvaluation::distribute_bfs(), DMlibMeshFunction(), DMlibMeshJacobian(), DMlibMeshSetSystem_libMesh(), DMVariableBounds_libMesh(), libMesh::DTKSolutionTransfer::DTKSolutionTransfer(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_nodes(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_sides(), libMesh::TransientRBConstruction::enrich_RB_space(), libMesh::EpetraVector< T >::EpetraVector(), AssembleOptimization::equality_constraints(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_error_fraction(), libMesh::MeshRefinement::flag_elements_by_error_tolerance(), libMesh::MeshRefinement::flag_elements_by_mean_stddev(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::RBEIMEvaluation::gather_bfs(), libMesh::DofMap::gather_constraints(), libMesh::MeshfreeInterpolation::gather_remote_data(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::RBEIMEvaluation::get_eim_basis_function_node_value(), libMesh::RBEIMEvaluation::get_eim_basis_function_side_value(), libMesh::RBEIMEvaluation::get_eim_basis_function_value(), libMesh::MeshBase::get_info(), libMesh::System::get_info(), libMesh::DofMap::get_info(), libMesh::RBEIMEvaluation::get_interior_basis_functions_as_vecs(), libMesh::ImplicitSystem::get_linear_solver(), libMesh::RBEIMConstruction::get_max_abs_value(), libMesh::RBEIMConstruction::get_node_max_abs_value(), libMesh::RBEIMEvaluation::get_parametrized_function_node_value(), libMesh::RBEIMEvaluation::get_parametrized_function_side_value(), libMesh::RBEIMEvaluation::get_parametrized_function_value(), libMesh::RBEIMConstruction::get_random_point(), AssembleOptimization::inequality_constraints(), AssembleOptimization::inequality_constraints_jacobian(), libMesh::LocationMap< T >::init(), libMesh::TimeSolver::init(), libMesh::StaticCondensation::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::AdvectionSystem::init_data(), libMesh::ClawSystem::init_data(), libMesh::PetscDMWrapper::init_petscdm(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::OptimizationSystem::initialize_equality_constraints_storage(), libMesh::OptimizationSystem::initialize_inequality_constraints_storage(), libMesh::RBEIMConstruction::initialize_parametrized_functions_in_training_set(), libMesh::RBEIMConstruction::inner_product(), integrate_function(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_equal_connectivity(), libMesh::MeshTools::libmesh_assert_equal_points(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_constraint_rows(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_flags(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_p_levels(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::MeshTools::libmesh_assert_valid_unique_ids(), libMesh::libmesh_petsc_linesearch_shellfunc(), libMesh::libmesh_petsc_preconditioner_apply(), libMesh::libmesh_petsc_recalculate_monitor(), libMesh::libmesh_petsc_snes_fd_residual(), libMesh::libmesh_petsc_snes_jacobian(), libMesh::libmesh_petsc_snes_mffd_interface(), libMesh::libmesh_petsc_snes_mffd_residual(), libMesh::libmesh_petsc_snes_postcheck(), libMesh::libmesh_petsc_snes_precheck(), libMesh::libmesh_petsc_snes_residual(), libMesh::libmesh_petsc_snes_residual_helper(), libMesh::MeshRefinement::limit_level_mismatch_at_edge(), libMesh::MeshRefinement::limit_level_mismatch_at_node(), libMesh::MeshRefinement::limit_overrefined_boundary(), libMesh::MeshRefinement::limit_underrefined_boundary(), libMesh::LinearImplicitSystem::LinearImplicitSystem(), main(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshCommunication::make_elems_parallel_consistent(), libMesh::MeshRefinement::make_flags_parallel_consistent(), libMesh::MeshCommunication::make_new_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_new_nodes_parallel_consistent(), libMesh::MeshCommunication::make_node_bcids_parallel_consistent(), libMesh::MeshCommunication::make_node_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_unique_ids_parallel_consistent(), libMesh::MeshCommunication::make_nodes_parallel_consistent(), libMesh::MeshCommunication::make_p_levels_parallel_consistent(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::TransientRBConstruction::mass_matrix_scaled_matvec(), libMesh::FEMSystem::mesh_position_set(), libMesh::TriangulatorInterface::MeshedHole::MeshedHole(), LinearElasticityWithContact::move_mesh(), libMesh::DistributedMesh::n_active_elem(), libMesh::MeshTools::n_active_levels(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::MeshTools::n_connected_components(), libMesh::DofMap::n_constrained_dofs(), libMesh::MeshBase::n_constraint_rows(), libMesh::DofMap::n_dofs(), libMesh::DofMap::n_dofs_per_processor(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::CondensedEigenSystem::n_global_non_condensed_dofs(), libMesh::MeshTools::n_levels(), MixedOrderTest::n_neighbor_links(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::SparsityPattern::Build::n_nonzeros(), libMesh::MeshTools::n_p_levels(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::RBEIMEvaluation::node_distribute_bfs(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::RBEIMConstruction::node_inner_product(), libMesh::MeshBase::operator==(), libMesh::DistributedMesh::parallel_max_elem_id(), libMesh::DistributedMesh::parallel_max_node_id(), parallel_max_unique_id(), libMesh::DistributedMesh::parallel_max_unique_id(), libMesh::DistributedMesh::parallel_n_elem(), libMesh::DistributedMesh::parallel_n_nodes(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::BoundaryInfo::parallel_sync_node_ids(), libMesh::BoundaryInfo::parallel_sync_side_ids(), libMesh::MeshTools::paranoid_n_levels(), libMesh::Partitioner::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::petsc_auto_fieldsplit(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::MeshBase::prepare_for_use(), libMesh::MeshBase::print_constraint_rows(), libMesh::DofMap::print_dof_constraints(), libMesh::DofMap::process_mesh_constraint_rows(), libMesh::Partitioner::processor_pairs_to_interface_nodes(), libMesh::InterMeshProjection::project_system_vectors(), FEMParameters::read(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::EquationSystems::read(), libMesh::ExodusII_IO::read_header(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::System::read_header(), libMesh::RBEIMEvaluation::read_in_interior_basis_functions(), libMesh::RBEIMEvaluation::read_in_node_basis_functions(), libMesh::RBEIMEvaluation::read_in_side_basis_functions(), libMesh::RBEvaluation::read_in_vectors_from_multiple_files(), libMesh::System::read_legacy_data(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::Nemesis_IO_Helper::read_var_names_impl(), libMesh::MeshBase::recalculate_n_partitions(), libMesh::MeshRefinement::refine_and_coarsen_elements(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::StaticCondensationDofMap::reinit(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DistributedMesh::renumber_nodes_and_elements(), LinearElasticityWithContact::residual_and_jacobian(), OverlappingAlgebraicGhostingTest::run_ghosting_test(), OverlappingCouplingGhostingTest::run_sparsity_pattern_test(), scale_mesh_and_plot(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::send_and_insert_dof_values(), libMesh::TransientRBConstruction::set_error_temporal_data(), libMesh::Partitioner::set_interface_node_processor_ids_BFS(), libMesh::Partitioner::set_interface_node_processor_ids_linear(), libMesh::Partitioner::set_interface_node_processor_ids_petscpartitioner(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::PetscDiffSolver::setup_petsc_data(), libMesh::RBEIMEvaluation::side_distribute_bfs(), libMesh::RBEIMEvaluation::side_gather_bfs(), libMesh::RBEIMConstruction::side_inner_product(), libMesh::Partitioner::single_partition(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::VariationalMeshSmoother::smooth(), libMesh::ClawSystem::solve_conservation_law(), libMesh::split_mesh(), libMesh::RBEIMConstruction::store_eim_solutions_for_training_set(), libMesh::MeshBase::subdomain_ids(), libMesh::BoundaryInfo::sync(), ConstraintOperatorTest::test1DCoarseningNewNodes(), ConstraintOperatorTest::test1DCoarseningOperator(), libMesh::MeshRefinement::test_level_one(), MeshfunctionDFEM::test_mesh_function_dfem(), MeshfunctionDFEM::test_mesh_function_dfem_grad(), MeshFunctionTest::test_p_level(), libMesh::MeshRefinement::test_unflagged(), DofMapTest::testBadElemFECombo(), SystemsTest::testBlockRestrictedVarNDofs(), BoundaryInfoTest::testBoundaryOnChildrenErrors(), VolumeTest::testC0PolygonMethods(), VolumeTest::testC0PolyhedronMethods(), ConstraintOperatorTest::testCoreform(), ConnectedComponentsTest::testEdge(), MeshInputTest::testExodusIGASidesets(), MeshTriangulationTest::testFoundCenters(), PointLocatorTest::testLocator(), BoundaryInfoTest::testMesh(), PointLocatorTest::testPlanar(), MeshTriangulationTest::testPoly2TriRefinementBase(), SystemsTest::testProjectCubeWithMeshFunction(), BoundaryInfoTest::testRenumber(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), MeshTriangulationTest::testTriangulatorInterp(), MeshTriangulationTest::testTriangulatorMeshedHoles(), MeshTriangulationTest::testTriangulatorRoundHole(), libMesh::MeshTools::total_weight(), libMesh::RBConstruction::train_reduced_basis_with_POD(), libMesh::MeshFunctionSolutionTransfer::transfer(), libMesh::MeshfreeSolutionTransfer::transfer(), libMesh::Poly2TriTriangulator::triangulate(), libMesh::TransientRBConstruction::truth_assembly(), libMesh::RBConstruction::truth_assembly(), libMesh::MeshRefinement::uniformly_coarsen(), update_current_local_solution(), libMesh::TransientRBConstruction::update_RB_initial_condition_all_N(), libMesh::TransientRBConstruction::update_RB_system_matrices(), libMesh::RBConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_residual_terms(), libMesh::RBConstruction::update_residual_terms(), libMesh::MeshTools::volume(), libMesh::STLIO::write(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::VTKIO::write_nodal_data(), libMesh::RBEIMEvaluation::write_out_interior_basis_functions(), libMesh::RBEIMEvaluation::write_out_node_basis_functions(), libMesh::RBEIMEvaluation::write_out_side_basis_functions(), libMesh::RBEvaluation::write_out_vectors(), libMesh::TransientRBConstruction::write_riesz_representors_to_files(), libMesh::RBConstruction::write_riesz_representors_to_files(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::RBDataSerialization::RBEvaluationSerialization::write_to_file(), libMesh::RBDataSerialization::TransientRBEvaluationSerialization::write_to_file(), libMesh::RBDataSerialization::RBEIMEvaluationSerialization::write_to_file(), and libMesh::RBDataSerialization::RBSCMEvaluationSerialization::write_to_file().

  { return _communicator; }

contract()

bool libMesh::UnstructuredMesh::contract ( )

overridevirtualinherited

Delete subactive (i.e.

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

Implements libMesh::MeshBase.

Definition at line 1395 of file unstructured_mesh.C.

References libMesh::as_range(), libMesh::MeshBase::clear_point_locator(), libMesh::MeshBase::delete_elem(), libMesh::MeshBase::ghosting_functors_begin(), libMesh::MeshBase::ghosting_functors_end(), libMesh::libmesh_assert(), and libMesh::MeshBase::renumber_nodes_and_elements().

{
  LOG_SCOPE ("contract()", "Mesh");

  // Flag indicating if this call actually changes the mesh
  bool mesh_changed = false;

#ifdef DEBUG
  for (const auto & elem : this->element_ptr_range())
    libmesh_assert(elem->active() || elem->subactive() || elem->ancestor());
#endif

  // Loop over the elements.
  for (auto & elem : this->element_ptr_range())
    {
      // Delete all the subactive ones
      if (elem->subactive())
        {
          // No level-0 element should be subactive.
          // Note that we CAN'T test elem->level(), as that
          // touches elem->parent()->dim(), and elem->parent()
          // might have already been deleted!
          libmesh_assert(elem->parent());

          // Delete the element
          // This just sets a pointer to nullptr, and doesn't
          // invalidate any iterators
          this->delete_elem(elem);

          // the mesh has certainly changed
          mesh_changed = true;
        }
      else
        {
          // Compress all the active ones
          if (elem->active())
            elem->contract();
          else
            libmesh_assert (elem->ancestor());
        }
    }

  // Strip any newly-created nullptr voids out of the element array
  this->renumber_nodes_and_elements();

  // FIXME: Need to understand why deleting subactive children
  // invalidates the point locator.  For now we will clear it explicitly
  this->clear_point_locator();

  // Allow our GhostingFunctor objects to reinit if necessary.
  for (auto & gf : as_range(this->ghosting_functors_begin(),
                            this->ghosting_functors_end()))
    {
      libmesh_assert(gf);
      gf->mesh_reinit();
    }

  return mesh_changed;
}

copy_cached_data()

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

protectedinherited

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

Definition at line 2004 of file mesh_base.C.

References libMesh::MeshBase::_elem_default_orders, libMesh::MeshBase::_elem_dims, libMesh::MeshBase::_mesh_subdomains, libMesh::MeshBase::_spatial_dimension, and libMesh::MeshBase::_supported_nodal_order.

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

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

copy_constraint_rows() [1/2]

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

inherited

Copy the constraints from the other mesh to this mesh.

Definition at line 2063 of file mesh_base.C.

References libMesh::MeshBase::_constraint_rows, libMesh::MeshBase::elem_ptr(), libMesh::MeshBase::get_constraint_rows(), and libMesh::MeshBase::node_ptr().

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

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

copy_constraint_rows() [2/2]

template<typename T >

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

inherited

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 2087 of file mesh_base.C.

References libMesh::MeshBase::_constraint_rows, libMesh::MeshBase::_elem_default_orders, libMesh::MeshBase::_elem_dims, libMesh::MeshBase::_mesh_subdomains, libMesh::MeshBase::_supported_nodal_order, libMesh::MeshBase::add_elem(), libMesh::MeshBase::add_point(), TIMPI::Communicator::allgather(), libMesh::Elem::build(), libMesh::ParallelObject::comm(), libMesh::Elem::default_order(), libMesh::MeshBase::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(), libMesh::MeshBase::n_nodes(), libMesh::MeshBase::node_ptr(), libMesh::MeshBase::node_ref(), libMesh::NODEELEM, libMesh::DofObject::processor_id(), libMesh::Real, libMesh::SparseMatrix< T >::row_start(), libMesh::SparseMatrix< T >::row_stop(), TIMPI::Communicator::set_union(), libMesh::MeshBase::subdomain_ids(), libMesh::Elem::supported_nodal_order(), and libMesh::TOLERANCE.

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

copy_nodes_and_elements()

void libMesh::UnstructuredMesh::copy_nodes_and_elements ( const MeshBase &  other_mesh, const bool  skip_find_neighbors = false, dof_id_type  element_id_offset = 0, dof_id_type  node_id_offset = 0, unique_id_type  unique_id_offset = 0, std::unordered_map< subdomain_id_type, subdomain_id_type > *  id_remapping = nullptr  )

virtualinherited

Deep copy of nodes and elements from another mesh object (used by subclass copy constructors and by mesh merging operations)

This will not copy most "high level" data in the mesh; that is done separately by constructors. An exception is that, if the other_mesh has element or node extra_integer data, any names for that data which do not already exist on this mesh are added so that all such data can be copied.

If an id_remapping map is provided, then element subdomain ids in other_mesh will be converted using it before adding them to this mesh.

Definition at line 639 of file unstructured_mesh.C.

References libMesh::MeshBase::_elem_integer_names, libMesh::MeshBase::_node_integer_names, libMesh::Elem::add_child(), libMesh::MeshBase::add_elem(), libMesh::DofObject::add_extra_integers(), libMesh::MeshBase::add_point(), libMesh::MeshBase::allow_find_neighbors(), libMesh::MeshBase::allow_remote_element_removal(), libMesh::MeshBase::allow_renumbering(), libMesh::Elem::disconnected_clone(), libMesh::MeshBase::elem_ptr(), libMesh::MeshBase::is_prepared(), libMesh::MeshTools::libmesh_assert_valid_amr_elem_ids(), libMesh::MeshBase::merge_extra_integer_names(), libMesh::MeshBase::mesh_dimension(), libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), libMesh::MeshBase::n_partitions(), libMesh::ParallelObject::n_processors(), libMesh::Elem::neighbor_ptr(), libMesh::MeshBase::parallel_max_unique_id(), libMesh::Elem::parent(), libMesh::MeshBase::prepare_for_use(), libMesh::remote_elem, libMesh::MeshBase::reserve_elem(), libMesh::MeshBase::reserve_nodes(), libMesh::Elem::set_interior_parent(), libMesh::MeshBase::set_isnt_prepared(), libMesh::Elem::set_neighbor(), libMesh::MeshBase::set_next_unique_id(), and libMesh::MeshBase::skip_partitioning().

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

{
  LOG_SCOPE("copy_nodes_and_elements()", "UnstructuredMesh");

  std::pair<std::vector<unsigned int>, std::vector<unsigned int>>
    extra_int_maps = this->merge_extra_integer_names(other_mesh);

  const unsigned int n_old_node_ints = extra_int_maps.second.size(),
                     n_new_node_ints = _node_integer_names.size(),
                     n_old_elem_ints = extra_int_maps.first.size(),
                     n_new_elem_ints = _elem_integer_names.size();

  // If we are partitioned into fewer parts than the incoming mesh has
  // processors to handle, then we need to "wrap" the other Mesh's
  // processor ids to fit within our range. This can happen, for
  // example, while stitching meshes with small numbers of elements in
  // parallel...
  bool wrap_proc_ids = (this->n_processors() <
                        other_mesh.n_partitions());

  // We're assuming the other mesh has proper element number ordering,
  // so that we add parents before their children, and that the other
  // mesh is consistently partitioned.
#ifdef DEBUG
  MeshTools::libmesh_assert_valid_amr_elem_ids(other_mesh);
  MeshTools::libmesh_assert_valid_procids<Node>(other_mesh);
#endif

  //Copy in Nodes
  {
    //Preallocate Memory if necessary
    this->reserve_nodes(other_mesh.n_nodes());

    for (const auto & oldn : other_mesh.node_ptr_range())
      {
        processor_id_type added_pid = cast_int<processor_id_type>
          (wrap_proc_ids ? oldn->processor_id() % this->n_processors() : oldn->processor_id());

        // Add new nodes in old node Point locations
        Node * newn =
          this->add_point(*oldn,
                          oldn->id() + node_id_offset,
                          added_pid);

        newn->add_extra_integers(n_new_node_ints);
        for (unsigned int i = 0; i != n_old_node_ints; ++i)
          newn->set_extra_integer(extra_int_maps.second[i],
                                  oldn->get_extra_integer(i));

#ifdef LIBMESH_ENABLE_UNIQUE_ID
        newn->set_unique_id(oldn->unique_id() + unique_id_offset);
#endif
      }
  }

  //Copy in Elements
  {
    //Preallocate Memory if necessary
    this->reserve_elem(other_mesh.n_elem());

    // Declare a map linking old and new elements, needed to copy the neighbor lists
    typedef std::unordered_map<const Elem *, Elem *> map_type;
    map_type old_elems_to_new_elems, ip_map;

    // Loop over the elements
    for (const auto & old : other_mesh.element_ptr_range())
      {
        // Build a new element
        Elem * newparent = old->parent() ?
          this->elem_ptr(old->parent()->id() + element_id_offset) :
          nullptr;
        auto el = old->disconnected_clone();
        el->set_parent(newparent);

        subdomain_id_type sbd_id = old->subdomain_id();
        if (id_remapping)
          {
            auto remapping_it = id_remapping->find(sbd_id);
            if (remapping_it != id_remapping->end())
              sbd_id = remapping_it->second;
          }
        el->subdomain_id() = sbd_id;

        // Hold off on trying to set the interior parent because we may actually
        // add lower dimensional elements before their interior parents
        if (el->dim() < other_mesh.mesh_dimension() && old->interior_parent())
          ip_map[old] = el.get();

#ifdef LIBMESH_ENABLE_AMR
        if (old->has_children())
          for (unsigned int c = 0, nc = old->n_children(); c != nc; ++c)
            if (old->child_ptr(c) == remote_elem)
              el->add_child(const_cast<RemoteElem *>(remote_elem), c);

        //Create the parent's child pointers if necessary
        if (newparent)
          {
            unsigned int oldc = old->parent()->which_child_am_i(old);
            newparent->add_child(el.get(), oldc);
          }

        // Copy the refinement flags
        el->set_refinement_flag(old->refinement_flag());

        // Use hack_p_level since we may not have sibling elements
        // added yet
        el->hack_p_level(old->p_level());

        el->set_p_refinement_flag(old->p_refinement_flag());
#endif // #ifdef LIBMESH_ENABLE_AMR

        //Assign all the nodes
        for (auto i : el->node_index_range())
          el->set_node(i,
            this->node_ptr(old->node_id(i) + node_id_offset));

        // And start it off with the same processor id (mod _n_parts).
        el->processor_id() = cast_int<processor_id_type>
          (wrap_proc_ids ? old->processor_id() % this->n_processors() : old->processor_id());

        // Give it the same element and unique ids
        el->set_id(old->id() + element_id_offset);

        el->add_extra_integers(n_new_elem_ints);
        for (unsigned int i = 0; i != n_old_elem_ints; ++i)
          el->set_extra_integer(extra_int_maps.first[i],
                                old->get_extra_integer(i));

#ifdef LIBMESH_ENABLE_UNIQUE_ID
        el->set_unique_id(old->unique_id() + unique_id_offset);
#endif

        //Hold onto it
        if (!skip_find_neighbors)
          {
            for (auto s : old->side_index_range())
              if (old->neighbor_ptr(s) == remote_elem)
                el->set_neighbor(s, const_cast<RemoteElem *>(remote_elem));
            this->add_elem(std::move(el));
          }
        else
          {
            Elem * new_el = this->add_elem(std::move(el));
            old_elems_to_new_elems[old] = new_el;
          }
      }

    for (auto & elem_pair : ip_map)
      elem_pair.second->set_interior_parent(
        this->elem_ptr(elem_pair.first->interior_parent()->id() + element_id_offset));

    // Loop (again) over the elements to fill in the neighbors
    if (skip_find_neighbors)
      {
        old_elems_to_new_elems[remote_elem] = const_cast<RemoteElem*>(remote_elem);

        for (const auto & old_elem : other_mesh.element_ptr_range())
          {
            Elem * new_elem = old_elems_to_new_elems[old_elem];
            for (auto s : old_elem->side_index_range())
              {
                const Elem * old_neighbor = old_elem->neighbor_ptr(s);
                Elem * new_neighbor = old_elems_to_new_elems[old_neighbor];
                new_elem->set_neighbor(s, new_neighbor);
              }
          }
      }
  }

#ifdef LIBMESH_ENABLE_UNIQUE_ID
  // We set the unique ids of nodes after adding them to the mesh such that our value of
  // _next_unique_id may be wrong. So we amend that here
  this->set_next_unique_id(other_mesh.parallel_max_unique_id() + unique_id_offset + 1);
#endif

  // Finally, partially prepare the new Mesh for use.
  // This is for backwards compatibility, so we don't want to prepare
  // everything.
  //
  // Keep the same numbering and partitioning and distribution status
  // for now, but save our original policies to restore later.
  const bool allowed_renumbering = this->allow_renumbering();
  const bool allowed_find_neighbors = this->allow_find_neighbors();
  const bool allowed_elem_removal = this->allow_remote_element_removal();
  this->allow_renumbering(false);
  this->allow_remote_element_removal(false);
  this->allow_find_neighbors(!skip_find_neighbors);

  // We should generally be able to skip *all* partitioning here
  // because we're only adding one already-consistent mesh to another.
  const bool skipped_partitioning = this->skip_partitioning();
  this->skip_partitioning(true);

  const bool was_prepared = this->is_prepared();
  this->prepare_for_use();

  //But in the long term, don't change our policies.
  this->allow_find_neighbors(allowed_find_neighbors);
  this->allow_renumbering(allowed_renumbering);
  this->allow_remote_element_removal(allowed_elem_removal);
  this->skip_partitioning(skipped_partitioning);

  // That prepare_for_use() call marked us as prepared, but we
  // specifically avoided some important preparation, so we might not
  // actually be prepared now.
  if (skip_find_neighbors ||
      !was_prepared || !other_mesh.is_prepared())
    this->set_isnt_prepared();
}

create_pid_mesh()

void libMesh::UnstructuredMesh::create_pid_mesh ( UnstructuredMesh &  pid_mesh, const processor_id_type  pid  ) const

inherited

Generates a new mesh containing all the elements which are assigned to processor pid.

This mesh is written to the pid_mesh reference which you must create and pass to the function.

Definition at line 1283 of file unstructured_mesh.C.

References libMesh::UnstructuredMesh::create_submesh(), libMesh::ParallelObject::n_processors(), and libMesh::out.

{

  // Issue a warning if the number the number of processors
  // currently available is less that that requested for
  // partitioning.  This is not necessarily an error since
  // you may run on one processor and still partition the
  // mesh into several partitions.
#ifdef DEBUG
  if (this->n_processors() < pid)
    {
      libMesh::out << "WARNING:  You are creating a "
                   << "mesh for a processor id (="
                   << pid
                   << ") greater than "
                   << "the number of processors available for "
                   << "the calculation. (="
                   << this->n_processors()
                   << ")."
                   << std::endl;
    }
#endif

  this->create_submesh (pid_mesh,
                        this->active_pid_elements_begin(pid),
                        this->active_pid_elements_end(pid));
}

create_submesh()

void libMesh::UnstructuredMesh::create_submesh ( UnstructuredMesh &  new_mesh, const const_element_iterator &  it, const const_element_iterator &  it_end  ) const

inherited

Constructs a mesh called "new_mesh" from the current mesh by iterating over the elements between it and it_end and adding them to the new mesh.

Definition at line 1318 of file unstructured_mesh.C.

References libMesh::MeshBase::_node_integer_names, libMesh::MeshBase::add_elem(), libMesh::DofObject::add_extra_integers(), libMesh::MeshBase::add_point(), libMesh::BoundaryInfo::add_side(), libMesh::as_range(), libMesh::BoundaryInfo::boundary_ids(), libMesh::MeshBase::clear(), libMesh::MeshBase::delete_remote_elements(), libMesh::MeshBase::get_boundary_info(), libMesh::MeshBase::is_serial(), libMesh::libmesh_assert(), libMesh::MeshBase::merge_extra_integer_names(), libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), libMesh::MeshBase::node_ptr(), libMesh::MeshBase::prepare_for_use(), libMesh::MeshBase::query_node_ptr(), libMesh::DofObject::set_extra_integer(), libMesh::Elem::set_node(), and libMesh::DofObject::set_unique_id().

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

{
  // Just in case the subdomain_mesh already has some information
  // in it, get rid of it.
  new_mesh.clear();

  // If we're not serial, our submesh isn't either.
  // There are no remote elements to delete on an empty mesh, but
  // calling the method to do so marks the mesh as parallel.
  if (!this->is_serial())
    new_mesh.delete_remote_elements();

  // Fail if (*this == new_mesh), we cannot create a submesh inside ourself!
  // This may happen if the user accidentally passes the original mesh into
  // this function!  We will check this by making sure we did not just
  // clear ourself.
  libmesh_assert_not_equal_to (this->n_nodes(), 0);
  libmesh_assert_not_equal_to (this->n_elem(), 0);

  // Container to catch boundary IDs handed back by BoundaryInfo
  std::vector<boundary_id_type> bc_ids;

  // Put any extra integers on the new mesh too
  new_mesh.merge_extra_integer_names(*this);
  const unsigned int n_node_ints = _node_integer_names.size();

  for (const auto & old_elem : as_range(it, it_end))
    {
      // Add an equivalent element type to the new_mesh.
      // disconnected_clone() copies ids, extra element integers, etc.
      auto uelem = old_elem->disconnected_clone();
      Elem * new_elem = new_mesh.add_elem(std::move(uelem));
      libmesh_assert(new_elem);

      // Loop over the nodes on this element.
      for (auto n : old_elem->node_index_range())
        {
          const dof_id_type this_node_id = old_elem->node_id(n);

          // Add this node to the new mesh if it's not there already
          if (!new_mesh.query_node_ptr(this_node_id))
            {
              Node * newn =
                new_mesh.add_point (old_elem->point(n),
                                    this_node_id,
                                    old_elem->node_ptr(n)->processor_id());

              newn->add_extra_integers(n_node_ints);
              for (unsigned int i = 0; i != n_node_ints; ++i)
                newn->set_extra_integer(i, old_elem->node_ptr(n)->get_extra_integer(i));

#ifdef LIBMESH_ENABLE_UNIQUE_ID
              newn->set_unique_id(old_elem->node_ptr(n)->unique_id());
#endif
            }

          // Define this element's connectivity on the new mesh
          new_elem->set_node(n, new_mesh.node_ptr(this_node_id));
        }

      // Maybe add boundary conditions for this element
      for (auto s : old_elem->side_index_range())
        {
          this->get_boundary_info().boundary_ids(old_elem, s, bc_ids);
          new_mesh.get_boundary_info().add_side (new_elem, s, bc_ids);
        }
    } // end loop over elements

  // Prepare the new_mesh for use
  new_mesh.prepare_for_use();
}

DECLARE_ELEM_ITERATORS() [1/20]

libMesh::ReplicatedMesh::DECLARE_ELEM_ITERATORS

(

)

Elem and Node iterator accessor functions.

See MeshBase for documentation.

DECLARE_ELEM_ITERATORS() [2/20]

libMesh::ReplicatedMesh::DECLARE_ELEM_ITERATORS

(

active_

)

DECLARE_ELEM_ITERATORS() [3/20]

libMesh::ReplicatedMesh::DECLARE_ELEM_ITERATORS

(

ancestor_

)

DECLARE_ELEM_ITERATORS() [4/20]

libMesh::ReplicatedMesh::DECLARE_ELEM_ITERATORS

(

local_

)

DECLARE_ELEM_ITERATORS() [5/20]

libMesh::ReplicatedMesh::DECLARE_ELEM_ITERATORS

(

facelocal_

)

DECLARE_ELEM_ITERATORS() [6/20]

unsigned int level libMesh::ReplicatedMesh::DECLARE_ELEM_ITERATORS	(	pid_	,
		processor_id_type	pid,
		pid
	)

DECLARE_ELEM_ITERATORS() [7/20]

unsigned int level ElemType type libMesh::ReplicatedMesh::DECLARE_ELEM_ITERATORS	(	active_subdomain_	,
		subdomain_id_type	sid,
		sid
	)

DECLARE_ELEM_ITERATORS() [8/20]

unsigned int level ElemType type std::set<subdomain_id_type> ss libMesh::ReplicatedMesh::DECLARE_ELEM_ITERATORS

(

not_active_

)

DECLARE_ELEM_ITERATORS() [9/20]

libMesh::ReplicatedMesh::DECLARE_ELEM_ITERATORS

(

not_ancestor_

)

DECLARE_ELEM_ITERATORS() [10/20]

libMesh::ReplicatedMesh::DECLARE_ELEM_ITERATORS

(

not_subactive_

)

DECLARE_ELEM_ITERATORS() [11/20]

libMesh::ReplicatedMesh::DECLARE_ELEM_ITERATORS

(

not_local_

)

DECLARE_ELEM_ITERATORS() [12/20]

libMesh::ReplicatedMesh::DECLARE_ELEM_ITERATORS	(	not_level_	,
		unsigned int	level,
		level
	)

DECLARE_ELEM_ITERATORS() [13/20]

libMesh::ReplicatedMesh::DECLARE_ELEM_ITERATORS

(

active_not_local_

)

DECLARE_ELEM_ITERATORS() [14/20]

libMesh::ReplicatedMesh::DECLARE_ELEM_ITERATORS	(	active_type_	,
		ElemType	type,
		type
	)

DECLARE_ELEM_ITERATORS() [15/20]

processor_id_type pid libMesh::ReplicatedMesh::DECLARE_ELEM_ITERATORS	(	local_level_	,
		unsigned int	level,
		level
	)

DECLARE_ELEM_ITERATORS() [16/20]

processor_id_type pid unsigned int level libMesh::ReplicatedMesh::DECLARE_ELEM_ITERATORS	(	active_local_subdomain_	,
		subdomain_id_type	sid,
		sid
	)

DECLARE_ELEM_ITERATORS() [17/20]

libMesh::ReplicatedMesh::DECLARE_ELEM_ITERATORS

(

semilocal_

)

DECLARE_ELEM_ITERATORS() [18/20]

libMesh::ReplicatedMesh::DECLARE_ELEM_ITERATORS

(

active_semilocal_

)

DECLARE_ELEM_ITERATORS() [19/20]

const DofMap& dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num libMesh::ReplicatedMesh::DECLARE_ELEM_ITERATORS	(	multi_evaluable_	,
		std::vector< const DofMap *>	dof_maps,
		dof_maps
	)

DECLARE_ELEM_ITERATORS() [20/20]

const DofMap& dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag libMesh::ReplicatedMesh::DECLARE_ELEM_ITERATORS	(	flagged_pid_	,
		unsigned char rflag LIBMESH_COMMA processor_id_type	pid,
		rflag LIBMESH_COMMA	pid
	)

DECLARE_NODE_ITERATORS() [1/3]

const DofMap& dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag libMesh::ReplicatedMesh::DECLARE_NODE_ITERATORS

(

active_

)

DECLARE_NODE_ITERATORS() [2/3]

const DofMap& dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag libMesh::ReplicatedMesh::DECLARE_NODE_ITERATORS

(

bnd_

)

DECLARE_NODE_ITERATORS() [3/3]

const DofMap& dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag processor_id_type pid libMesh::ReplicatedMesh::DECLARE_NODE_ITERATORS	(	bid_	,
		boundary_id_type	bid,
		bid
	)

default_ghosting()

GhostingFunctor& libMesh::MeshBase::default_ghosting ( )

inlineinherited

Default ghosting functor.

Definition at line 1303 of file mesh_base.h.

References libMesh::MeshBase::_default_ghosting.

{ return *_default_ghosting; }

default_mapping_data()

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

inlineinherited

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

Definition at line 830 of file mesh_base.h.

References libMesh::MeshBase::_default_mapping_data.

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

  {
    return _default_mapping_data;
  }

default_mapping_type()

ElemMappingType libMesh::MeshBase::default_mapping_type ( ) const

inlineinherited

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

Definition at line 812 of file mesh_base.h.

References libMesh::MeshBase::_default_mapping_type.

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

  {
    return _default_mapping_type;
  }

delete_elem()

void libMesh::ReplicatedMesh::delete_elem ( Elem *  e )

finaloverridevirtual

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

Implements libMesh::MeshBase.

Definition at line 384 of file replicated_mesh.C.

References _elements, _n_elem, libMesh::MeshBase::get_boundary_info(), libMesh::DofObject::id(), libMesh::libmesh_assert(), and libMesh::BoundaryInfo::remove().

Referenced by insert_elem(), and libMesh::C0Polyhedron::retriangulate().

{
  libmesh_assert(e);

  // Initialize an iterator to eventually point to the element we want to delete
  std::vector<Elem *>::iterator pos = _elements.end();

  // In many cases, e->id() gives us a clue as to where e
  // is located in the _elements vector.  Try that first
  // before trying the O(n_elem) search.
  libmesh_assert_less (e->id(), _elements.size());

  if (_elements[e->id()] == e)
    {
      // We found it!
      pos = _elements.begin();
      std::advance(pos, e->id());
    }

  else
    {
      // This search is O(n_elem)
      pos = std::find (_elements.begin(),
                       _elements.end(),
                       e);
    }

  // Huh? Element not in the vector?
  libmesh_assert (pos != _elements.end());

  // Remove the element from the BoundaryInfo object
  this->get_boundary_info().remove(e);

  // delete the element
  --_n_elem;
  delete e;

  // explicitly zero the pointer
  *pos = nullptr;
}

delete_node()

void libMesh::ReplicatedMesh::delete_node ( Node *  n )

finaloverridevirtual

Removes the Node n from the mesh.

Implements libMesh::MeshBase.

Definition at line 607 of file replicated_mesh.C.

References libMesh::MeshBase::_constraint_rows, _n_nodes, libMesh::MeshBase::get_boundary_info(), libMesh::DofObject::id(), libMesh::libmesh_assert(), and libMesh::BoundaryInfo::remove().

{
  libmesh_assert(n);
  libmesh_assert_less (n->id(), _nodes.size());

  // Initialize an iterator to eventually point to the element we want
  // to delete
  std::vector<Node *>::iterator pos;

  // In many cases, e->id() gives us a clue as to where e
  // is located in the _elements vector.  Try that first
  // before trying the O(n_elem) search.
  if (_nodes[n->id()] == n)
    {
      pos = _nodes.begin();
      std::advance(pos, n->id());
    }
  else
    {
      pos = std::find (_nodes.begin(),
                       _nodes.end(),
                       n);
    }

  // Huh? Node not in the vector?
  libmesh_assert (pos != _nodes.end());

  // Delete the node from the BoundaryInfo object
  this->get_boundary_info().remove(n);
  _constraint_rows.erase(n);

  // delete the node
  --_n_nodes;
  delete n;

  // explicitly zero the pointer
  *pos = nullptr;
}

delete_remote_elements()

virtual void libMesh::MeshBase::delete_remote_elements ( )

inlinevirtualinherited

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 253 of file mesh_base.h.

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

{}

detect_interior_parents()

void libMesh::MeshBase::detect_interior_parents ( )

inherited

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

Definition at line 1811 of file mesh_base.C.

References dim, libMesh::MeshBase::elem_dimensions(), libMesh::MeshBase::elem_ptr(), libMesh::MeshBase::elem_ref(), libMesh::MeshBase::interior_mesh(), libMesh::make_range(), and libMesh::MeshBase::max_elem_id().

Referenced by libMesh::MeshBase::prepare_for_use().

{
  // This requires an inspection on every processor
  parallel_object_only();

  // Check if the mesh contains mixed dimensions. If so, then we may
  // have interior parents to set.  Otherwise return.
  if (this->elem_dimensions().size() == 1)
    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())
    {
      // 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 an 3D element or an element that already has an interior parent
      if (element->dim()>=LIBMESH_DIM || element->interior_parent())
        continue;

      // Start by generating a SET of elements that are dim+1 to the current
      // element at each vertex of the current element, thus ignoring interior nodes.
      // If one of the SET of elements is empty, then we will not have an interior parent
      // since an interior parent must be connected to all vertices of the current element
      std::vector<std::set<dof_id_type>> neighbors( element->n_vertices() );

      bool found_interior_parents = false;

      for (auto n : make_range(element->n_vertices()))
        {
          std::vector<dof_id_type> & element_ids = node_to_elem[element->node_id(n)];
          for (const auto & eid : element_ids)
            if (this->elem_ref(eid).dim() == element->dim()+1)
              neighbors[n].insert(eid);

          if (neighbors[n].size()>0)
            {
              found_interior_parents = true;
            }
          else
            {
              // We have found an empty set, no reason to continue
              // Ensure we set this flag to false before the break since it could have
              // been set to true for previous vertex
              found_interior_parents = false;
              break;
            }
        }

      // If we have successfully generated a set of elements for each vertex, we will compare
      // the set for vertex 0 will the sets for the vertices until we find a id that exists in
      // all sets.  If found, this is our an interior parent id.  The interior parent id found
      // will be the lowest element id if there is potential for multiple interior parents.
      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.");
        }
    }
}

elem_default_orders()

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

inlineinherited

Returns

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

Definition at line 289 of file mesh_base.h.

References libMesh::MeshBase::_elem_default_orders.

  { return _elem_default_orders; }

elem_dimensions()

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

inlineinherited

Returns

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

Definition at line 282 of file mesh_base.h.

References libMesh::MeshBase::_elem_dims.

Referenced by libMesh::System::calculate_norm(), libMesh::MeshBase::detect_interior_parents(), libMesh::TreeNode< N >::insert(), and libMesh::VariationalMeshSmoother::smooth().

  { return _elem_dims; }

elem_ptr() [1/2]

const Elem * libMesh::ReplicatedMesh::elem_ptr ( const dof_id_type  i ) const

finaloverridevirtual

Returns

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

Implements libMesh::MeshBase.

Definition at line 228 of file replicated_mesh.C.

References _elements, libMesh::libmesh_assert(), and max_elem_id().

Referenced by libMesh::C0Polyhedron::retriangulate().

{
  libmesh_assert_less (i, this->max_elem_id());
  libmesh_assert(_elements[i]);
  libmesh_assert_equal_to (_elements[i]->id(), i); // This will change soon

  return _elements[i];
}

elem_ptr() [2/2]

Elem * libMesh::ReplicatedMesh::elem_ptr ( const dof_id_type  i )

finaloverridevirtual

Returns

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

Implements libMesh::MeshBase.

Definition at line 240 of file replicated_mesh.C.

References _elements, libMesh::libmesh_assert(), and max_elem_id().

{
  libmesh_assert_less (i, this->max_elem_id());
  libmesh_assert(_elements[i]);
  libmesh_assert_equal_to (_elements[i]->id(), i); // This will change soon

  return _elements[i];
}

elem_ref() [1/2]

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

inlinevirtualinherited

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 639 of file mesh_base.h.

References libMesh::MeshBase::elem_ptr().

Referenced by libMesh::SyncRefinementFlags::act_on_data(), libMesh::SyncSubdomainIds::act_on_data(), libMesh::SyncElementIntegers::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::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::MeshBase::detect_interior_parents(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_sides(), libMesh::SyncRefinementFlags::gather_data(), libMesh::SyncSubdomainIds::gather_data(), libMesh::SyncElementIntegers::gather_data(), main(), libMesh::MeshRefinement::make_coarsening_compatible(), ExodusTest< 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::MeshRefinement::uniformly_coarsen(), libMesh::FroIO::write(), libMesh::Nemesis_IO_Helper::write_elements(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::GmshIO::write_mesh(), and libMesh::ExodusII_IO_Helper::write_sidesets().

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

elem_ref() [2/2]

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

inlinevirtualinherited

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 649 of file mesh_base.h.

References libMesh::MeshBase::elem_ptr().

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

find_neighbors()

void libMesh::UnstructuredMesh::find_neighbors ( const bool  reset_remote_elements = false, const bool  reset_current_list = true  )

overridevirtualinherited

Other functions from MeshBase requiring re-definition.

Here we look at all of the child elements which don't already have valid neighbors.

If a child element has a nullptr neighbor it is either because it is on the boundary or because its neighbor is at a different level. In the latter case we must get the neighbor from the parent.

If a child element has a remote_elem neighbor on a boundary it shares with its parent, that info may have become out-dated through coarsening of the neighbor's parent. In this case, if the parent's neighbor is active then the child should share it.

Furthermore, that neighbor better be active, otherwise we missed a child somewhere.

We also need to look through children ordered by increasing refinement level in order to add new interior_parent() links in boundary elements which have just been generated by refinement, and fix links in boundary elements whose previous interior_parent() has just been coarsened away.

Implements libMesh::MeshBase.

Definition at line 872 of file unstructured_mesh.C.

References libMesh::Elem::active(), libMesh::Elem::ancestor(), libMesh::as_range(), libMesh::Elem::child_ptr(), libMesh::Elem::child_ref_range(), libMesh::err, libMesh::Elem::has_children(), libMesh::Elem::hmin(), libMesh::DofObject::id(), libMesh::Elem::interior_parent(), libMesh::Elem::is_ancestor_of(), libMesh::Elem::is_child_on_side(), libMesh::Elem::level(), libMesh::libmesh_assert(), libMesh::MeshTools::libmesh_assert_valid_amr_interior_parents(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::Elem::n_children(), libMesh::MeshTools::n_levels(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::neighbor_ptr_range(), libMesh::Elem::parent(), libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), libMesh::Real, libMesh::remote_elem, libMesh::Elem::set_interior_parent(), libMesh::Elem::set_neighbor(), libMesh::Elem::side_ptr(), libMesh::Elem::subactive(), libMesh::TOLERANCE, libMesh::Elem::vertex_average(), libMesh::Elem::which_child_am_i(), and libMesh::NameBasedIO::write().

Referenced by libMesh::TriangleWrapper::copy_tri_to_mesh(), libMesh::Poly2TriTriangulator::insert_refinement_points(), libMesh::UnstructuredMesh::stitching_helper(), and libMesh::TriangleInterface::triangulate().

{
  // We might actually want to run this on an empty mesh
  // (e.g. the boundary mesh for a nonexistent bcid!)
  // libmesh_assert_not_equal_to (this->n_nodes(), 0);
  // libmesh_assert_not_equal_to (this->n_elem(), 0);

  // This function must be run on all processors at once
  parallel_object_only();

  LOG_SCOPE("find_neighbors()", "Mesh");

  //TODO:[BSK] This should be removed later?!
  if (reset_current_list)
    for (const auto & e : this->element_ptr_range())
      for (auto s : e->side_index_range())
        if (e->neighbor_ptr(s) != remote_elem || reset_remote_elements)
          e->set_neighbor(s, nullptr);

  // Find neighboring elements by first finding elements
  // with identical side keys and then check to see if they
  // are neighbors
  {
    // data structures -- Use the hash_multimap if available
    typedef dof_id_type                     key_type;
    typedef std::pair<Elem *, unsigned char> val_type;
    typedef std::unordered_multimap<key_type, val_type> map_type;

    // A map from side keys to corresponding elements & side numbers
    map_type side_to_elem_map;

    // Pull objects out of the loop to reduce heap operations
    std::unique_ptr<Elem> my_side, their_side;

    for (const auto & element : this->element_ptr_range())
      {
        for (auto ms : element->side_index_range())
          {
          next_side:
            // If we haven't yet found a neighbor on this side, try.
            // Even if we think our neighbor is remote, that
            // information may be out of date.
            if (element->neighbor_ptr(ms) == nullptr ||
                element->neighbor_ptr(ms) == remote_elem)
              {
                // Get the key for the side of this element.  Use the
                // low_order_key so we can find neighbors in
                // mixed-order meshes if necessary.
                const dof_id_type key = element->low_order_key(ms);

                // Look for elements that have an identical side key
                auto bounds = side_to_elem_map.equal_range(key);

                // May be multiple keys, check all the possible
                // elements which _might_ be neighbors.
                if (bounds.first != bounds.second)
                  {
                    // Get the side for this element
                    element->side_ptr(my_side, ms);

                    // Look at all the entries with an equivalent key
                    while (bounds.first != bounds.second)
                      {
                        // Get the potential element
                        Elem * neighbor = bounds.first->second.first;

                        // Get the side for the neighboring element
                        const unsigned int ns = bounds.first->second.second;
                        neighbor->side_ptr(their_side, ns);
                        //libmesh_assert(my_side.get());
                        //libmesh_assert(their_side.get());

                        // If found a match with my side
                        //
                        // In 1D, since parents and children have an
                        // equal side (i.e. a node) we need to check
                        // for matching level() to avoid setting our
                        // neighbor pointer to any of our neighbor's
                        // descendants.
                        if ((*my_side == *their_side) &&
                            (element->level() == neighbor->level()))
                          {
                            // So share a side.  Is this a mixed pair
                            // of subactive and active/ancestor
                            // elements?
                            // If not, then we're neighbors.
                            // If so, then the subactive's neighbor is

                            if (element->subactive() ==
                                neighbor->subactive())
                              {
                                // an element is only subactive if it has
                                // been coarsened but not deleted
                                element->set_neighbor (ms,neighbor);
                                neighbor->set_neighbor(ns,element);
                              }
                            else if (element->subactive())
                              {
                                element->set_neighbor(ms,neighbor);
                              }
                            else if (neighbor->subactive())
                              {
                                neighbor->set_neighbor(ns,element);
                              }
                            side_to_elem_map.erase (bounds.first);

                            // get out of this nested crap
                            goto next_side;
                          }

                        ++bounds.first;
                      }
                  }

                // didn't find a match...
                // Build the map entry for this element
                side_to_elem_map.emplace
                  (key, std::make_pair(element, cast_int<unsigned char>(ms)));
              }
          }
      }
  }

#ifdef LIBMESH_ENABLE_AMR

  const unsigned int n_levels = MeshTools::n_levels(*this);
  for (unsigned int level = 1; level < n_levels; ++level)
    {
      for (auto & current_elem : as_range(level_elements_begin(level),
                                          level_elements_end(level)))
        {
          libmesh_assert(current_elem);
          Elem * parent = current_elem->parent();
          libmesh_assert(parent);
          const unsigned int my_child_num = parent->which_child_am_i(current_elem);

          for (auto s : current_elem->side_index_range())
            {
              if (current_elem->neighbor_ptr(s) == nullptr ||
                  (current_elem->neighbor_ptr(s) == remote_elem &&
                   parent->is_child_on_side(my_child_num, s)))
                {
                  Elem * neigh = parent->neighbor_ptr(s);

                  // If neigh was refined and had non-subactive children
                  // made remote earlier, then our current elem should
                  // actually have one of those remote children as a
                  // neighbor
                  if (neigh &&
                      (neigh->ancestor() ||
                       // If neigh has subactive children which should have
                       // matched as neighbors of the current element but
                       // did not, then those likewise must be remote
                       // children.
                       (current_elem->subactive() && neigh->has_children() &&
                        (neigh->level()+1) == current_elem->level())))
                    {
#ifdef DEBUG
                      // Let's make sure that "had children made remote"
                      // situation is actually the case
                      libmesh_assert(neigh->has_children());
                      bool neigh_has_remote_children = false;
                      for (auto & child : neigh->child_ref_range())
                        if (&child == remote_elem)
                          neigh_has_remote_children = true;
                      libmesh_assert(neigh_has_remote_children);

                      // And let's double-check that we don't have
                      // a remote_elem neighboring an active local element
                      if (current_elem->active())
                        libmesh_assert_not_equal_to (current_elem->processor_id(),
                                                     this->processor_id());
#endif // DEBUG
                      neigh = const_cast<RemoteElem *>(remote_elem);
                    }
                  // If neigh and current_elem are more than one level
                  // apart, figuring out whether we have a remote
                  // neighbor here becomes much harder.
                  else if (neigh && (current_elem->subactive() &&
                                     neigh->has_children()))
                    {
                      // Find the deepest descendant of neigh which
                      // we could consider for a neighbor.  If we run
                      // out of neigh children, then that's our
                      // neighbor.  If we find a potential neighbor
                      // with remote_children and we don't find any
                      // potential neighbors among its non-remote
                      // children, then our neighbor must be remote.
                      while (neigh != remote_elem &&
                             neigh->has_children())
                        {
                          bool found_neigh = false;
                          for (unsigned int c = 0, nc = neigh->n_children();
                               !found_neigh && c != nc; ++c)
                            {
                              Elem * child = neigh->child_ptr(c);
                              if (child == remote_elem)
                                continue;
                              for (auto ncn : child->neighbor_ptr_range())
                                {
                                  if (ncn != remote_elem &&
                                      ncn->is_ancestor_of(current_elem))
                                    {
                                      neigh = ncn;
                                      found_neigh = true;
                                      break;
                                    }
                                }
                            }
                          if (!found_neigh)
                            neigh = const_cast<RemoteElem *>(remote_elem);
                        }
                    }
                  current_elem->set_neighbor(s, neigh);
#ifdef DEBUG
                  if (neigh != nullptr && neigh != remote_elem)
                    // We ignore subactive elements here because
                    // we don't care about neighbors of subactive element.
                    if ((!neigh->active()) && (!current_elem->subactive()))
                      {
                        libMesh::err << "On processor " << this->processor_id()
                                     << std::endl;
                        libMesh::err << "Bad element ID = " << current_elem->id()
                                     << ", Side " << s << ", Bad neighbor ID = " << neigh->id() << std::endl;
                        libMesh::err << "Bad element proc_ID = " << current_elem->processor_id()
                                     << ", Bad neighbor proc_ID = " << neigh->processor_id() << std::endl;
                        libMesh::err << "Bad element size = " << current_elem->hmin()
                                     << ", Bad neighbor size = " << neigh->hmin() << std::endl;
                        libMesh::err << "Bad element center = " << current_elem->vertex_average()
                                     << ", Bad neighbor center = " << neigh->vertex_average() << std::endl;
                        libMesh::err << "ERROR: "
                                     << (current_elem->active()?"Active":"Ancestor")
                                     << " Element at level "
                                     << current_elem->level() << std::endl;
                        libMesh::err << "with "
                                     << (parent->active()?"active":
                                         (parent->subactive()?"subactive":"ancestor"))
                                     << " parent share "
                                     << (neigh->subactive()?"subactive":"ancestor")
                                     << " neighbor at level " << neigh->level()
                                     << std::endl;
                        NameBasedIO(*this).write ("bad_mesh.gmv");
                        libmesh_error_msg("Problematic mesh written to bad_mesh.gmv.");
                      }
#endif // DEBUG
                }
            }

          // We can skip to the next element if we're full-dimension
          // and therefore don't have any interior parents
          if (current_elem->dim() >= LIBMESH_DIM)
            continue;

          // We have no interior parents unless we can find one later
          current_elem->set_interior_parent(nullptr);

          Elem * pip = parent->interior_parent();

          if (!pip)
            continue;

          // If there's no interior_parent children, whether due to a
          // remote element or a non-conformity, then there's no
          // children to search.
          if (pip == remote_elem || pip->active())
            {
              current_elem->set_interior_parent(pip);
              continue;
            }

          // For node comparisons we'll need a sensible tolerance
          Real node_tolerance = current_elem->hmin() * TOLERANCE;

          // Otherwise our interior_parent should be a child of our
          // parent's interior_parent.
          for (auto & child : pip->child_ref_range())
            {
              // If we have a remote_elem, that might be our
              // interior_parent.  We'll set it provisionally now and
              // keep trying to find something better.
              if (&child == remote_elem)
                {
                  current_elem->set_interior_parent
                    (const_cast<RemoteElem *>(remote_elem));
                  continue;
                }

              bool child_contains_our_nodes = true;
              for (auto & n : current_elem->node_ref_range())
                {
                  bool child_contains_this_node = false;
                  for (auto & cn : child.node_ref_range())
                    if (cn.absolute_fuzzy_equals
                        (n, node_tolerance))
                      {
                        child_contains_this_node = true;
                        break;
                      }
                  if (!child_contains_this_node)
                    {
                      child_contains_our_nodes = false;
                      break;
                    }
                }
              if (child_contains_our_nodes)
                {
                  current_elem->set_interior_parent(&child);
                  break;
                }
            }

          // We should have found *some* interior_parent at this
          // point, whether semilocal or remote.
          libmesh_assert(current_elem->interior_parent());
        }
    }

#endif // AMR


#ifdef DEBUG
  MeshTools::libmesh_assert_valid_neighbors(*this,
                                            !reset_remote_elements);
  MeshTools::libmesh_assert_valid_amr_interior_parents(*this);
#endif
}

fix_broken_node_and_element_numbering()

void libMesh::ReplicatedMesh::fix_broken_node_and_element_numbering ( )

overridevirtual

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.

Implements libMesh::MeshBase.

Definition at line 891 of file replicated_mesh.C.

References _elements, and libMesh::index_range().

{
  // Nodes first
  for (auto n : index_range(_nodes))
    if (this->_nodes[n] != nullptr)
      this->_nodes[n]->set_id() = cast_int<dof_id_type>(n);

  // Elements next
  for (auto e : index_range(_elements))
    if (this->_elements[e] != nullptr)
      this->_elements[e]->set_id() = cast_int<dof_id_type>(e);
}

gather_to_zero()

virtual void libMesh::MeshBase::gather_to_zero ( )

inlinevirtualinherited

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

Reimplemented in libMesh::DistributedMesh.

Definition at line 246 of file mesh_base.h.

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

{}

get_boundary_info() [1/2]

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

inlineinherited

The information about boundary ids on the mesh.

Definition at line 165 of file mesh_base.h.

References libMesh::MeshBase::boundary_info.

Referenced by libMesh::MeshRefinement::_coarsen_elements(), libMesh::MeshTools::Subdivision::add_boundary_ghosts(), libMesh::UnstructuredMesh::all_first_order(), libMesh::MeshTools::Subdivision::all_subdivision(), libMesh::MeshTools::Modification::all_tri(), LinearElasticity::assemble(), assemble_elasticity(), assemble_poisson(), assemble_shell(), libMesh::AbaqusIO::assign_boundary_node_ids(), libMesh::AbaqusIO::assign_sideset_ids(), AssemblyA0::boundary_assembly(), AssemblyA1::boundary_assembly(), AssemblyF0::boundary_assembly(), AssemblyF1::boundary_assembly(), AssemblyA2::boundary_assembly(), AssemblyF2::boundary_assembly(), libMesh::MeshTools::Generation::build_delaunay_square(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::MeshTools::Modification::change_boundary_id(), libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), libMesh::TriangleWrapper::copy_tri_to_mesh(), libMesh::UnstructuredMesh::create_submesh(), libMesh::MeshTetInterface::delete_2D_hull_elements(), delete_elem(), libMesh::DistributedMesh::delete_elem(), delete_node(), libMesh::DistributedMesh::delete_node(), libMesh::DistributedMesh::delete_remote_elements(), libMesh::DistributedMesh::DistributedMesh(), libMesh::MeshTools::Modification::flatten(), libMesh::MeshBase::get_info(), libMesh::UNVIO::groups_in(), libMesh::HDGProblem::init(), libMesh::ExodusII_IO_Helper::initialize(), LinearElasticityWithContact::initialize_contact_load_paths(), libMesh::Poly2TriTriangulator::insert_refinement_points(), libMesh::HDGProblem::jacobian(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), main(), AugmentSparsityOnInterface::mesh_reinit(), libMesh::TriangulatorInterface::MeshedHole::MeshedHole(), libMesh::MeshTools::Modification::orient_elements(), libMesh::TetGenMeshInterface::pointset_convexhull(), libMesh::MeshBase::prepare_for_use(), libMesh::Nemesis_IO::prepare_to_write_nodal_data(), libMesh::AbaqusIO::read(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::CheckpointIO::read_bcs(), libMesh::ExodusII_IO_Helper::read_edge_blocks(), libMesh::CheckpointIO::read_header(), libMesh::GmshIO::read_mesh(), libMesh::CheckpointIO::read_nodesets(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::SimplexRefiner::refine_via_edges(), MeshStitchTest::renameAndShift(), renumber_nodes_and_elements(), libMesh::DistributedMesh::renumber_nodes_and_elements(), ReplicatedMesh(), libMesh::HDGProblem::residual(), SolidSystem::side_time_derivative(), libMesh::PetscDiffSolver::solve(), libMesh::UnstructuredMesh::stitching_helper(), libMesh::MeshTools::Generation::surface_octahedron(), libMesh::BoundaryInfo::sync(), AllTriTest::test_helper_2D(), AllTriTest::test_helper_3D(), BoundaryInfoTest::testBoundaryOnChildrenBoundaryIDs(), BoundaryInfoTest::testBoundaryOnChildrenBoundarySides(), BoundaryInfoTest::testBoundaryOnChildrenElementsRefineCoarsen(), BoundaryInfoTest::testBoundaryOnChildrenErrors(), SystemsTest::testBoundaryProjectCube(), VolumeTest::testC0PolygonMethods(), BoundaryInfoTest::testEdgeBoundaryConditions(), MeshInputTest::testExodusIGASidesets(), MeshInputTest::testGmshBCIDOverlap(), MeshInputTest::testLowOrderEdgeBlocks(), BoundaryInfoTest::testMesh(), BoundaryInfoTest::testNameCopying(), PeriodicBCTest::testPeriodicBC(), MeshTriangulationTest::testPoly2TriHolesInteriorRefinedBase(), BoundaryInfoTest::testRenumber(), BoundaryInfoTest::testShellFaceConstraints(), MeshSmootherTest::testSmoother(), WriteNodesetData::testWriteImpl(), WriteEdgesetData::testWriteImpl(), WriteSidesetData::testWriteImpl(), libMesh::NetGenMeshInterface::triangulate(), libMesh::Poly2TriTriangulator::triangulate_current_points(), libMesh::MeshTetInterface::volume_to_surface_mesh(), libMesh::FroIO::write(), libMesh::Nemesis_IO::write(), libMesh::XdrIO::write(), libMesh::CheckpointIO::write(), libMesh::ExodusII_IO::write(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::GmshIO::write_mesh(), libMesh::ExodusII_IO_Helper::write_nodesets(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::XdrIO::write_serialized_nodesets(), and libMesh::ExodusII_IO_Helper::write_sidesets().

{ return *boundary_info; }

get_boundary_info() [2/2]

BoundaryInfo& libMesh::MeshBase::get_boundary_info ( )

inlineinherited

Writable information about boundary ids on the mesh.

Definition at line 170 of file mesh_base.h.

References libMesh::MeshBase::boundary_info.

{ return *boundary_info; }

get_boundary_points()

std::unordered_map< dof_id_type, std::vector< std::vector< Point > > > libMesh::ReplicatedMesh::get_boundary_points

(

)

const

Return all points on boundary.

The key of the returned unordered map is the ID of a representative element of all disconnected subdomains. Subdomains are considered connected only when they are sharing at least one d-1 dimensional object (side in 2D), where d is the mesh dimension. The size of the unordered map value is the number of disconnected boundaries for a subdomain. Boundaries are considered connected only when they are sharing a d-2 dimensional object. This function currently only works for 2D meshes. The points of each boundary are ordered to form an enclosure.

Definition at line 979 of file replicated_mesh.C.

References libMesh::Elem::find_point_neighbors(), get_disconnected_subdomains(), libMesh::DofObject::id(), libMesh::index_range(), libMesh::libmesh_assert(), libMesh::MeshBase::mesh_dimension(), libMesh::Elem::node_ptr(), libMesh::Elem::nodes_on_side(), and ss.

{
  libmesh_error_msg_if(mesh_dimension() != 2,
                       "Error: get_boundary_points only works for 2D now");

  // find number of disconnected subdomains
  // subdomains will hold the IDs of disconnected subdomains for all elements.
  std::vector<subdomain_id_type> subdomains;
  std::vector<dof_id_type> elem_ids = get_disconnected_subdomains(&subdomains);

  std::unordered_map<dof_id_type, std::vector<std::vector<Point>>> boundary_points;

  // get all boundary sides that are to be erased later during visiting
  // use a comparison functor to avoid run-time randomness due to pointers
  struct boundary_side_compare
  {
    bool operator()(const std::pair<const Elem *, unsigned int> & lhs,
                    const std::pair<const Elem *, unsigned int> & rhs) const
      {
        if (lhs.first->id() < rhs.first->id())
          return true;
        else if (lhs.first->id() == rhs.first->id())
        {
          if (lhs.second < rhs.second)
            return true;
        }
        return false;
      }
  };
  std::set<std::pair<const Elem *, unsigned int>, boundary_side_compare> boundary_elements;
  for (const auto & elem : active_element_ptr_range())
    for (auto s : elem->side_index_range())
      if (elem->neighbor_ptr(s) == nullptr)
        boundary_elements.insert(std::pair<const Elem *, unsigned int>(elem, s));

  while (!boundary_elements.empty())
  {
    // get the first entry as the seed
    const Elem * eseed = boundary_elements.begin()->first;
    unsigned int sseed = boundary_elements.begin()->second;

    // get the subdomain ID that these boundary sides attached to
    subdomain_id_type subdomain_id = subdomains[eseed->id()];

    // start visiting the mesh to find all boundary nodes with the seed
    std::vector<Point> bpoints;
    const Elem * elem = eseed;
    unsigned int s = sseed;
    std::vector<unsigned int> local_side_nodes = elem->nodes_on_side(s);
    while (true)
    {
      std::pair<const Elem *, unsigned int> side(elem, s);
      libmesh_assert(boundary_elements.count(side));
      boundary_elements.erase(side);

      // push all nodes on the side except the node on the other end of the side (index 1)
      for (auto i : index_range(local_side_nodes))
        if (i != 1)
          bpoints.push_back(*static_cast<const Point *>(elem->node_ptr(local_side_nodes[i])));

      // use the last node to find next element and side
      const Node * node = elem->node_ptr(local_side_nodes[1]);
      std::set<const Elem *> neighbors;
      elem->find_point_neighbors(*node, neighbors);

      // if only one neighbor is found (itself), this node is a cornor node on boundary
      if (neighbors.size() != 1)
        neighbors.erase(elem);

      // find the connecting side
      bool found = false;
      for (const auto & neighbor : neighbors)
      {
        for (auto ss : neighbor->side_index_range())
          if (neighbor->neighbor_ptr(ss) == nullptr && !(elem == neighbor && s == ss))
          {
            local_side_nodes = neighbor->nodes_on_side(ss);
            // we expect the starting point of the side to be the same as the end of the previous side
            if (neighbor->node_ptr(local_side_nodes[0]) == node)
            {
              elem = neighbor;
              s = ss;
              found = true;
              break;
            }
            else if (neighbor->node_ptr(local_side_nodes[1]) == node)
            {
              elem = neighbor;
              s = ss;
              found = true;
              // flip nodes in local_side_nodes because the side is in an opposite direction
              auto temp(local_side_nodes);
              local_side_nodes[0] = temp[1];
              local_side_nodes[1] = temp[0];
              for (unsigned int i = 2; i < temp.size(); ++i)
                local_side_nodes[temp.size() + 1 - i] = temp[i];
              break;
            }
          }
        if (found)
          break;
      }

      libmesh_error_msg_if(!found, "ERROR: mesh topology error on visiting boundary sides");

      // exit if we reach the starting point
      if (elem == eseed && s == sseed)
        break;
    }
    boundary_points[elem_ids[subdomain_id]].push_back(bpoints);
  }

  return boundary_points;
}

get_constraint_rows() [1/2]

constraint_rows_type& libMesh::MeshBase::get_constraint_rows ( )

inlineinherited

Constraint rows accessors.

Definition at line 1703 of file mesh_base.h.

References libMesh::MeshBase::_constraint_rows.

Referenced by libMesh::Partitioner::build_graph(), libMesh::DofMap::calculate_constraining_subdomains(), libMesh::MeshTools::clear_spline_nodes(), libMesh::MeshBase::copy_constraint_rows(), libMesh::DofMap::create_dof_constraints(), libMesh::MeshTools::libmesh_assert_valid_constraint_rows(), libMesh::MeshBase::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().

  { return _constraint_rows; }

get_constraint_rows() [2/2]

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

inlineinherited

Definition at line 1706 of file mesh_base.h.

References libMesh::MeshBase::_constraint_rows.

  { return _constraint_rows; }

get_count_lower_dim_elems_in_point_locator()

bool libMesh::MeshBase::get_count_lower_dim_elems_in_point_locator ( ) const

inherited

Get the current value of _count_lower_dim_elems_in_point_locator.

Definition at line 1685 of file mesh_base.C.

References libMesh::MeshBase::_count_lower_dim_elems_in_point_locator.

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

{
  return _count_lower_dim_elems_in_point_locator;
}

get_disconnected_subdomains()

std::vector< dof_id_type > libMesh::ReplicatedMesh::get_disconnected_subdomains

(

std::vector< subdomain_id_type > *

subdomain_ids = nullptr

)

const

Return IDs of representative elements of all disconnected subdomains.

Subdomains are considered connected only when they are sharing at least one d-1 dimensional object (side in 2D, face in 3D), where d is the mesh dimension. The optional argument can be used for getting the subdomain IDs of all elements with element IDs as the index. This function cannot be called for a mesh with hanging nodes from adaptive mesh refinement.

Definition at line 912 of file replicated_mesh.C.

References libMesh::Elem::active(), libMesh::DofObject::id(), libMesh::Elem::invalid_subdomain_id, libMesh::libmesh_assert(), max_elem_id(), n_active_elem(), n_elem(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::side_index_range(), and libMesh::MeshBase::subdomain_ids().

Referenced by get_boundary_points().

{
  // find number of disconnected subdomains
  std::vector<dof_id_type> representative_elem_ids;

  // use subdomain_ids as markers for all elements to indicate if the elements
  // have been visited. Note: here subdomain ID is unrelated with element
  // subdomain_id().
  std::vector<subdomain_id_type> subdomains;
  if (!subdomain_ids)
    subdomain_ids = &subdomains;
  subdomain_ids->clear();
  subdomain_ids->resize(max_elem_id() + 1, Elem::invalid_subdomain_id);

  // counter of disconnected subdomains
  subdomain_id_type subdomain_counter = 0;

  // a stack for visiting elements, make its capacity sufficiently large to avoid
  // memory allocation and deallocation when the vector size changes
  std::vector<const Elem *> list;
  list.reserve(n_elem());

  // counter of visited elements
  dof_id_type visited = 0;
  dof_id_type n_active = n_active_elem();
  do
  {
    for (const auto & elem : active_element_ptr_range())
      if ((*subdomain_ids)[elem->id()] == Elem::invalid_subdomain_id)
      {
        list.push_back(elem);
        (*subdomain_ids)[elem->id()] = subdomain_counter;
        break;
      }
    // we should be able to find a seed here
    libmesh_assert(list.size() > 0);

    dof_id_type min_id = std::numeric_limits<dof_id_type>::max();
    while (list.size() > 0)
    {
      // pop up an element
      const Elem * elem = list.back(); list.pop_back(); ++visited;

      min_id = std::min(elem->id(), min_id);

      for (auto s : elem->side_index_range())
      {
        const Elem * neighbor = elem->neighbor_ptr(s);
        if (neighbor != nullptr && (*subdomain_ids)[neighbor->id()] == Elem::invalid_subdomain_id)
        {
          // neighbor must be active
          libmesh_assert(neighbor->active());
          list.push_back(neighbor);
          (*subdomain_ids)[neighbor->id()] = subdomain_counter;
        }
      }
    }

    representative_elem_ids.push_back(min_id);
    subdomain_counter++;
  }
  while (visited != n_active);

  return representative_elem_ids;
}

get_elem_integer_index()

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

inherited

Definition at line 626 of file mesh_base.C.

References libMesh::MeshBase::_elem_integer_names, libMesh::index_range(), libMesh::invalid_uint, and libMesh::Quality::name().

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

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

get_elem_integer_name()

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

inlineinherited

Definition at line 944 of file mesh_base.h.

References libMesh::MeshBase::_elem_integer_names.

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

  { return _elem_integer_names[i]; }

get_elemset_code()

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

inherited

Definition at line 439 of file mesh_base.C.

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

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

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

get_elemset_codes()

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

inherited

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

We get this by looping over the _elemset_codes map.

Definition at line 445 of file mesh_base.C.

References libMesh::MeshBase::_elemset_codes.

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

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

get_elemsets()

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

inherited

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 429 of file mesh_base.C.

References libMesh::MeshBase::_elemset_codes.

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

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

get_id_by_name()

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

inherited

Returns

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

Definition at line 1712 of file mesh_base.C.

References libMesh::MeshBase::_block_id_to_name, libMesh::Elem::invalid_subdomain_id, and libMesh::Quality::name().

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

get_info()

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

inherited

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 1082 of file mesh_base.C.

References libMesh::MeshBase::_elem_default_orders, libMesh::MeshBase::_elem_dims, libMesh::MeshBase::_elemset_codes, libMesh::Elem::build_edge_ptr(), libMesh::ParallelObject::comm(), libMesh::MeshTools::create_bounding_box(), libMesh::MeshTools::create_local_bounding_box(), libMesh::MeshTools::elem_types(), libMesh::Utility::enum_to_string(), libMesh::MeshBase::get_boundary_info(), libMesh::BoundaryInfo::get_edge_boundary_ids(), libMesh::BoundaryInfo::get_edgeset_name_map(), libMesh::BoundaryInfo::get_node_boundary_ids(), libMesh::BoundaryInfo::get_nodeset_name_map(), libMesh::BoundaryInfo::get_side_boundary_ids(), libMesh::BoundaryInfo::get_sideset_name_map(), libMesh::MeshBase::get_subdomain_name_map(), libMesh::DofObject::id(), libMesh::DofObject::invalid_processor_id, libMesh::MeshBase::is_prepared(), libMesh::MeshBase::is_replicated(), libMesh::libmesh_assert(), libMesh::Elem::loose_bounding_box(), TIMPI::Communicator::max(), TIMPI::Communicator::min(), libMesh::MeshBase::n_active_elem(), libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_elemsets(), libMesh::MeshBase::n_local_elem(), libMesh::MeshBase::n_local_nodes(), libMesh::MeshBase::n_local_subdomains(), libMesh::MeshBase::n_nodes(), libMesh::MeshBase::n_partitions(), libMesh::ParallelObject::n_processors(), libMesh::MeshBase::n_subdomains(), libMesh::n_threads(), libMesh::Quality::name(), libMesh::Elem::node_ref_range(), libMesh::ParallelObject::processor_id(), libMesh::Real, TIMPI::Communicator::set_union(), libMesh::MeshBase::spatial_dimension(), TIMPI::Communicator::sum(), libMesh::MeshBase::supported_nodal_order(), libMesh::Elem::type(), libMesh::BoundingBox::union_with(), libMesh::MeshTools::volume(), and libMesh::Elem::volume().

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

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

get_local_constraints()

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

inherited

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 2384 of file mesh_base.C.

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

Referenced by libMesh::MeshBase::print_constraint_rows().

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

get_mesh_subdomains()

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

inlineinherited

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 1814 of file mesh_base.h.

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

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

get_node_integer_index()

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

inherited

Definition at line 715 of file mesh_base.C.

References libMesh::MeshBase::_node_integer_names, libMesh::index_range(), libMesh::invalid_uint, and libMesh::Quality::name().

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

get_node_integer_name()

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

inlineinherited

Definition at line 1066 of file mesh_base.h.

References libMesh::MeshBase::_node_integer_names.

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

  { return _node_integer_names[i]; }

get_point_locator_close_to_point_tol()

Real libMesh::MeshBase::get_point_locator_close_to_point_tol ( ) const

inherited

Definition at line 1933 of file mesh_base.C.

References libMesh::MeshBase::_point_locator_close_to_point_tol.

{
  return _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

inlineinherited

Definition at line 1694 of file mesh_base.h.

References libMesh::MeshBase::_block_id_to_name.

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

  { return _block_id_to_name; }

ghosting_functors_begin()

std::set<GhostingFunctor *>::const_iterator libMesh::MeshBase::ghosting_functors_begin ( ) const

inlineinherited

Beginning of range of ghosting functors.

Definition at line 1291 of file mesh_base.h.

References libMesh::MeshBase::_ghosting_functors.

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

  { return _ghosting_functors.begin(); }

ghosting_functors_end()

std::set<GhostingFunctor *>::const_iterator libMesh::MeshBase::ghosting_functors_end ( ) const

inlineinherited

End of range of ghosting functors.

Definition at line 1297 of file mesh_base.h.

References libMesh::MeshBase::_ghosting_functors.

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

  { return _ghosting_functors.end(); }

has_elem_integer()

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

inherited

Definition at line 638 of file mesh_base.C.

References libMesh::MeshBase::_elem_integer_names, and libMesh::Quality::name().

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

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

  return false;
}

has_node_integer()

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

inherited

Definition at line 727 of file mesh_base.C.

References libMesh::MeshBase::_node_integer_names, and libMesh::Quality::name().

Referenced by ExtraIntegersTest::checkpoint_helper().

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

  return false;
}

insert_elem() [1/2]

Elem * libMesh::ReplicatedMesh::insert_elem ( Elem *  e )

finaloverridevirtual

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

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

Implements libMesh::MeshBase.

Definition at line 340 of file replicated_mesh.C.

References libMesh::MeshBase::_elem_integer_default_values, libMesh::MeshBase::_elem_integer_names, _elements, _n_elem, libMesh::MeshBase::_next_unique_id, libMesh::DofObject::add_extra_integers(), libMesh::MeshBase::default_mapping_data(), libMesh::MeshBase::default_mapping_type(), delete_elem(), libMesh::DofObject::id(), libMesh::Elem::set_mapping_data(), libMesh::Elem::set_mapping_type(), libMesh::DofObject::set_unique_id(), libMesh::DofObject::unique_id(), and libMesh::DofObject::valid_unique_id().

Referenced by insert_elem().

{
#ifdef LIBMESH_ENABLE_UNIQUE_ID
  if (!e->valid_unique_id())
    e->set_unique_id(_next_unique_id++);
  else
   _next_unique_id = std::max(_next_unique_id, e->unique_id()+1);
#endif

  dof_id_type eid = e->id();
  libmesh_assert_less (eid, _elements.size());
  Elem * oldelem = _elements[eid];

  if (oldelem)
    {
      libmesh_assert_equal_to (oldelem->id(), eid);
      this->delete_elem(oldelem);
    }

  ++_n_elem;
  _elements[eid] = e;

  // Make sure any new element is given space for any extra integers
  // we've requested
  e->add_extra_integers(_elem_integer_names.size(),
                        _elem_integer_default_values);

  // And set mapping type and data on any new element
  e->set_mapping_type(this->default_mapping_type());
  e->set_mapping_data(this->default_mapping_data());

  return e;
}

insert_elem() [2/2]

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

finaloverridevirtual

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.

Implements libMesh::MeshBase.

Definition at line 374 of file replicated_mesh.C.

References insert_elem().

{
  // The mesh now takes ownership of the Elem. Eventually the guts of
  // insert_elem(Elem*) will get moved to a private helper function, and
  // calling insert_elem(Elem*) directly will be deprecated.
  return insert_elem(e.release());
}

insert_node() [1/2]

Node * libMesh::ReplicatedMesh::insert_node ( Node *  n )

finaloverridevirtual

These methods are deprecated.

Please use add_node instead Insert Node n into the Mesh at a location consistent with n->id(), allocating extra storage if necessary. Throws an error if: .) n==nullptr .) n->id() == DofObject::invalid_id .) A node already exists in position n->id().

This function differs from the ReplicatedMesh::add_node() function, which is only capable of appending nodes at the end of the nodes storage.

Implements libMesh::MeshBase.

Definition at line 549 of file replicated_mesh.C.

References _n_nodes, libMesh::MeshBase::_next_unique_id, libMesh::MeshBase::_node_integer_default_values, libMesh::MeshBase::_node_integer_names, libMesh::DofObject::add_extra_integers(), libMesh::DofObject::id(), libMesh::DofObject::invalid_id, libMesh::DofObject::set_unique_id(), libMesh::DofObject::unique_id(), libMesh::DofObject::valid_id(), and libMesh::DofObject::valid_unique_id().

Referenced by insert_node().

{
  libmesh_deprecated();
  libmesh_error_msg_if(!n, "Error, attempting to insert nullptr node.");
  libmesh_error_msg_if(n->id() == DofObject::invalid_id, "Error, cannot insert node with invalid id.");

  if (n->id() < _nodes.size())
    {
      // Trying to add an existing node is a no-op.  This lets us use
      // a straightforward MeshCommunication::allgather() to fix a
      // not-actually-replicated-yet ReplicatedMesh, as occurs when
      // reading Nemesis files.
      if (n->valid_id() && _nodes[n->id()] == n)
        return n;

      // Don't allow anything else to replace an existing Node.
      libmesh_error_msg_if(_nodes[ n->id() ] != nullptr,
                           "Error, cannot insert new node on top of existing node.");
    }
  else
    {
      // Allocate just enough space to store the new node.  This will
      // cause highly non-ideal memory allocation behavior if called
      // repeatedly...
      _nodes.resize(n->id() + 1);
    }

#ifdef LIBMESH_ENABLE_UNIQUE_ID
  if (!n->valid_unique_id())
    n->set_unique_id(_next_unique_id++);
  else
   _next_unique_id = std::max(_next_unique_id, n->unique_id()+1);
#endif

  n->add_extra_integers(_node_integer_names.size(),
                        _node_integer_default_values);

  // We have enough space and this spot isn't already occupied by
  // another node, so go ahead and add it.
  ++_n_nodes;
  _nodes[ n->id() ] = n;

  // If we made it this far, we just inserted the node the user handed
  // us, so we can give it right back.
  return n;
}

insert_node() [2/2]

Node * libMesh::ReplicatedMesh::insert_node ( std::unique_ptr< Node >  n )

finaloverridevirtual

This method is deprecated.

Please use add_node instead Version of insert_node() taking a std::unique_ptr by value. 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.

Implements libMesh::MeshBase.

Definition at line 596 of file replicated_mesh.C.

References insert_node().

{
  libmesh_deprecated();
  // The mesh now takes ownership of the Node. Eventually the guts of
  // insert_node(Node*) will get moved to a private helper function, and
  // calling insert_node(Node*) directly will be deprecated.
  return insert_node(n.release());
}

interior_mesh() [1/2]

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

inlineinherited

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 1797 of file mesh_base.h.

References libMesh::MeshBase::_interior_mesh.

Referenced by libMesh::BoundaryInfo::add_elements(), and libMesh::MeshBase::detect_interior_parents().

{ return *_interior_mesh; }

interior_mesh() [2/2]

MeshBase& libMesh::MeshBase::interior_mesh ( )

inlineinherited

Returns

A writeable reference to the interior mesh.

Definition at line 1802 of file mesh_base.h.

References libMesh::MeshBase::_interior_mesh.

{ return *_interior_mesh; }

is_prepared()

bool libMesh::MeshBase::is_prepared ( ) const

inlineinherited

Returns

true if the mesh has been prepared via a call to prepare_for_use, false otherwise.

Definition at line 198 of file mesh_base.h.

References libMesh::MeshBase::_is_prepared.

Referenced by libMesh::MeshRefinement::_refine_elements(), libMesh::MeshTools::Modification::all_tri(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::DofMap::create_dof_constraints(), libMesh::DistributedMesh::DistributedMesh(), libMesh::MeshTools::Modification::flatten(), libMesh::BoundaryInfo::get_global_boundary_ids(), libMesh::MeshBase::get_info(), libMesh::MeshBase::get_mesh_subdomains(), libMesh::SimplexRefiner::refine_elements(), libMesh::DofMap::reinit(), ReplicatedMesh(), libMesh::UnstructuredMesh::stitching_helper(), ConstraintOperatorTest::test1DCoarseningNewNodes(), ConstraintOperatorTest::test1DCoarseningOperator(), ConstraintOperatorTest::testCoreform(), libMesh::MeshTools::valid_is_prepared(), and libMesh::MeshTetInterface::volume_to_surface_mesh().

  { return _is_prepared; }

is_replicated()

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

inlinevirtualinherited

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 233 of file mesh_base.h.

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

  { return true; }

is_serial()

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

inlinevirtualinherited

Returns

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

Reimplemented in libMesh::DistributedMesh.

Definition at line 211 of file mesh_base.h.

Referenced by libMesh::MeshRefinement::_coarsen_elements(), libMesh::MeshRefinement::_smooth_flags(), libMesh::BoundaryInfo::add_elements(), libMesh::MeshTools::Modification::all_tri(), libMesh::EquationSystems::allgather(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::MeshTools::build_nodes_to_elem_map(), libMesh::MeshBase::cache_elem_data(), libMesh::DofMap::create_dof_constraints(), libMesh::UnstructuredMesh::create_submesh(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::LocationMap< T >::init(), main(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshSerializer::MeshSerializer(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::MeshBase::partition(), libMesh::MeshBase::prepare_for_use(), libMesh::Nemesis_IO::read(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::BoundaryInfo::regenerate_id_sets(), ReplicatedMesh(), scale_mesh_and_plot(), libMesh::DofMap::scatter_constraints(), libMesh::Partitioner::set_node_processor_ids(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::BoundaryInfo::sync(), MeshInputTest::testExodusIGASidesets(), PointLocatorTest::testLocator(), MeshInputTest::testLowOrderEdgeBlocks(), BoundaryInfoTest::testMesh(), PointLocatorTest::testPlanar(), BoundaryInfoTest::testRenumber(), MeshInputTest::testTetgenIO(), WriteNodesetData::testWriteImpl(), WriteSidesetData::testWriteImpl(), libMesh::MeshTools::total_weight(), libMesh::MeshFunctionSolutionTransfer::transfer(), libMesh::STLIO::write(), libMesh::CheckpointIO::write(), and libMesh::XdrIO::write_parallel().

  { return true; }

is_serial_on_zero()

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

inlinevirtualinherited

Returns

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

Reimplemented in libMesh::DistributedMesh.

Definition at line 218 of file mesh_base.h.

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

  { return true; }

libmesh_assert_valid_parallel_ids()

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

inlinevirtualinherited

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 1516 of file mesh_base.h.

Referenced by libMesh::MeshRefinement::_refine_elements(), libMesh::InfElemBuilder::build_inf_elem(), and libMesh::MeshRefinement::refine_and_coarsen_elements().

{}

locally_equals()

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

inherited

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 236 of file mesh_base.C.

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

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

{
  // 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 (_is_prepared != other_mesh._is_prepared)
    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 (_allow_remote_element_removal != other_mesh._allow_remote_element_removal)
    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 (bool(_default_ghosting) != bool(other_mesh._default_ghosting))
    return false;
  if (bool(_partitioner) != bool(other_mesh._partitioner))
    return false;
  if (*boundary_info != *other_mesh.boundary_info)
    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 set sorted by pointer, 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);
}

max_elem_id()

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

inlinefinaloverridevirtual

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

Implements libMesh::MeshBase.

Definition at line 159 of file replicated_mesh.h.

References _elements.

Referenced by elem_ptr(), get_disconnected_subdomains(), and query_elem_ptr().

  { return cast_int<dof_id_type>(_elements.size()); }

max_node_id()

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

inlinefinaloverridevirtual

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

Implements libMesh::MeshBase.

Definition at line 145 of file replicated_mesh.h.

Referenced by node_ptr(), and query_node_ptr().

  { return cast_int<dof_id_type>(_nodes.size()); }

merge_extra_integer_names()

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

protectedinherited

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 1958 of file mesh_base.C.

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

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

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

mesh_dimension()

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

inherited

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 372 of file mesh_base.C.

References libMesh::MeshBase::_elem_dims.

Referenced by libMesh::HPCoarsenTest::add_projection(), libMesh::UnstructuredMesh::all_complete_order_range(), libMesh::UnstructuredMesh::all_second_order_range(), libMesh::MeshTools::Modification::all_tri(), alternative_fe_assembly(), assemble(), LinearElasticity::assemble(), assemble_1D(), AssembleOptimization::assemble_A_and_F(), assemble_biharmonic(), assemble_cd(), assemble_divgrad(), assemble_elasticity(), assemble_ellipticdg(), assemble_func(), assemble_graddiv(), assemble_helmholtz(), assemble_laplace(), assemble_mass(), assemble_matrices(), assemble_poisson(), assemble_SchroedingerEquation(), assemble_shell(), assemble_stokes(), assemble_wave(), libMesh::MeshBase::cache_elem_data(), compute_enriched_soln(), compute_jacobian(), compute_residual(), compute_stresses(), LinearElasticityWithContact::compute_stresses(), LinearElasticity::compute_stresses(), LargeDeformationElasticity::compute_stresses(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::DofMap::create_dof_constraints(), libMesh::MeshTools::Modification::distort(), SolidSystem::element_time_derivative(), HeatSystem::element_time_derivative(), fe_assembly(), libMesh::VariationalSmootherConstraint::fix_node(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), form_functionA(), form_functionB(), form_matrixA(), get_boundary_points(), libMesh::LaplaceMeshSmoother::init(), SolidSystem::init_data(), libMesh::ExodusII_IO_Helper::initialize(), integrate_function(), LaplaceYoung::jacobian(), LargeDeformationElasticity::jacobian(), main(), libMesh::GMVIO::read(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::VTKIO::read(), libMesh::System::read_header(), libMesh::UCDIO::read_implementation(), libMesh::XdrIO::read_serialized_connectivity(), LaplaceYoung::residual(), LargeDeformationElasticity::residual(), LinearElasticityWithContact::residual_and_jacobian(), SolidSystem::save_initial_mesh(), setup(), libMesh::VariationalMeshSmoother::smooth(), libMesh::MeshTools::Modification::smooth(), MeshSpatialDimensionTest::test1D(), MeshSpatialDimensionTest::test2D(), InfFERadialTest::testInfQuants(), InfFERadialTest::testInfQuants_numericDeriv(), InfFERadialTest::testSides(), InfFERadialTest::testSingleOrder(), libMesh::BoundaryVolumeSolutionTransfer::transfer(), libMesh::DTKSolutionTransfer::transfer(), libMesh::MeshTools::volume(), libMesh::PostscriptIO::write(), libMesh::CheckpointIO::write(), libMesh::TecplotIO::write_binary(), libMesh::GMVIO::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().

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

move_nodes_and_elements()

void libMesh::ReplicatedMesh::move_nodes_and_elements ( MeshBase &&  other_mesh )

overridevirtual

Move node and elements from a ReplicatedMesh.

Implements libMesh::UnstructuredMesh.

Definition at line 158 of file replicated_mesh.C.

References _elements, _n_elem, _n_nodes, n_elem(), and n_nodes().

Referenced by operator=().

{
  ReplicatedMesh & other_mesh = cast_ref<ReplicatedMesh&>(other_meshbase);

  this->_nodes = std::move(other_mesh._nodes);
  this->_n_nodes = other_mesh.n_nodes();

  this->_elements = std::move(other_mesh._elements);
  this->_n_elem = other_mesh.n_elem();
}

n_active_elem()

dof_id_type libMesh::ReplicatedMesh::n_active_elem ( ) const

finaloverridevirtual

Returns

The number of active elements in the mesh.

Implemented in terms of active_element_iterators.

Implements libMesh::MeshBase.

Definition at line 905 of file replicated_mesh.C.

References distance().

Referenced by get_disconnected_subdomains().

{
  return static_cast<dof_id_type>(std::distance (this->active_elements_begin(),
                                                 this->active_elements_end()));
}

n_active_elem_on_proc()

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

inherited

Returns

The number of active elements on processor proc.

Definition at line 1049 of file mesh_base.C.

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

Referenced by libMesh::MeshBase::n_active_local_elem().

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

n_active_local_elem()

dof_id_type libMesh::MeshBase::n_active_local_elem ( ) const

inlineinherited

Returns

The number of active elements on the local processor.

Definition at line 565 of file mesh_base.h.

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

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

n_active_sub_elem()

dof_id_type libMesh::MeshBase::n_active_sub_elem ( ) const

inherited

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

Definition at line 1070 of file mesh_base.C.

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

{
  dof_id_type ne=0;

  for (const auto & elem : this->active_element_ptr_range())
    ne += elem->n_sub_elem();

  return ne;
}

n_constraint_rows()

dof_id_type libMesh::MeshBase::n_constraint_rows ( ) const

inherited

Definition at line 2044 of file mesh_base.C.

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

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

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

n_elem()

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

inlinefinaloverridevirtual

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.

Implements libMesh::MeshBase.

Definition at line 151 of file replicated_mesh.h.

References _n_elem.

Referenced by get_disconnected_subdomains(), move_nodes_and_elements(), and libMesh::C0Polyhedron::retriangulate().

  { return _n_elem; }

n_elem_integers()

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

inlineinherited

Definition at line 955 of file mesh_base.h.

References libMesh::MeshBase::_elem_integer_names.

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

{ return _elem_integer_names.size(); }

n_elem_on_proc()

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

inherited

Returns

The number of elements on processor proc.

Definition at line 1036 of file mesh_base.C.

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

Referenced by libMesh::MeshBase::n_local_elem(), and libMesh::MeshBase::n_unpartitioned_elem().

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

n_elemsets()

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

inherited

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 424 of file mesh_base.C.

References libMesh::MeshBase::_all_elemset_ids.

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

{
  return _all_elemset_ids.size();
}

n_local_elem()

dof_id_type libMesh::MeshBase::n_local_elem ( ) const

inlineinherited

Returns

The number of elements on the local processor.

Definition at line 548 of file mesh_base.h.

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

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

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

n_local_nodes()

dof_id_type libMesh::MeshBase::n_local_nodes ( ) const

inlineinherited

Returns

The number of nodes on the local processor.

Definition at line 442 of file mesh_base.h.

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

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

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

n_local_subdomains()

subdomain_id_type libMesh::MeshBase::n_local_subdomains ( ) const

inherited

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 1011 of file mesh_base.C.

References libMesh::MeshBase::subdomain_ids().

Referenced by libMesh::MeshBase::get_info().

{
  std::set<subdomain_id_type> ids;

  this->subdomain_ids (ids, /* global = */ false);

  return cast_int<subdomain_id_type>(ids.size());
}

n_node_integers()

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

inlineinherited

Definition at line 1077 of file mesh_base.h.

References libMesh::MeshBase::_node_integer_names.

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

{ return _node_integer_names.size(); }

n_nodes()

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

inlinefinaloverridevirtual

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.

Implements libMesh::MeshBase.

Definition at line 139 of file replicated_mesh.h.

References _n_nodes.

Referenced by move_nodes_and_elements().

  { return _n_nodes; }

n_nodes_on_proc()

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

inherited

Returns

The number of nodes on processor proc.

Definition at line 1023 of file mesh_base.C.

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

Referenced by libMesh::MeshBase::n_local_nodes(), and libMesh::MeshBase::n_unpartitioned_nodes().

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

n_partitions()

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

inlineinherited

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 1345 of file mesh_base.h.

References libMesh::MeshBase::_n_parts.

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

  { return _n_parts; }

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.

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

Referenced by libMesh::Partitioner::_find_global_index_by_pid_map(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::DofMap::add_constraints_to_send_list(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::System::add_vector(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEMSystem::assembly(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::Partitioner::assign_partitioning(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::Partitioner::build_graph(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::DistributedMesh::clear(), libMesh::DistributedMesh::clear_elems(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::Nemesis_IO::copy_scalar_solution(), libMesh::UnstructuredMesh::create_pid_mesh(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_scalar_dofs(), libMesh::DistributedMesh::DistributedMesh(), libMesh::EnsightIO::EnsightIO(), libMesh::RBEIMEvaluation::gather_bfs(), libMesh::MeshBase::get_info(), libMesh::StaticCondensation::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_petscdm(), libMesh::Nemesis_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::DistributedMesh::insert_elem(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::DofMap::local_variable_indices(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshBase::n_active_elem_on_proc(), libMesh::DofMap::n_dofs_per_processor(), libMesh::MeshBase::n_elem_on_proc(), libMesh::MeshBase::n_nodes_on_proc(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::Partitioner::partition(), libMesh::MeshBase::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::DofMap::prepare_send_list(), libMesh::MeshBase::print_constraint_rows(), libMesh::DofMap::print_dof_constraints(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::XdrIO::read_header(), libMesh::CheckpointIO::read_nodes(), libMesh::System::read_parallel_data(), libMesh::System::read_SCALAR_dofs(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::System::read_serialized_vector(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::Partitioner::repartition(), OverlappingFunctorTest::run_partitioner_test(), libMesh::DofMap::scatter_constraints(), libMesh::DistributedMesh::set_next_unique_id(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), WriteVecAndScalar::setupTests(), libMesh::RBEIMEvaluation::side_gather_bfs(), DistributedMeshTest::testRemoteElemError(), CheckpointIOTest::testSplitter(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::VTKIO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::System::write_parallel_data(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::XdrIO::write_serialized_nodesets().

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

n_sub_elem()

dof_id_type libMesh::MeshBase::n_sub_elem ( ) const

inherited

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

inherited

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 997 of file mesh_base.C.

References libMesh::MeshBase::subdomain_ids().

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

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

n_unpartitioned_elem()

dof_id_type libMesh::MeshBase::n_unpartitioned_elem ( ) const

inlineinherited

Returns

The number of elements owned by no processor.

Definition at line 554 of file mesh_base.h.

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

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

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

n_unpartitioned_nodes()

dof_id_type libMesh::MeshBase::n_unpartitioned_nodes ( ) const

inlineinherited

Returns

The number of nodes owned by no processor.

Definition at line 448 of file mesh_base.h.

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

Referenced by libMesh::DistributedMesh::parallel_n_nodes().

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

next_unique_id()

unique_id_type libMesh::MeshBase::next_unique_id ( )

inlineinherited

Returns

The next unique id to be used.

Definition at line 461 of file mesh_base.h.

References libMesh::MeshBase::_next_unique_id.

{ return _next_unique_id; }

node_ptr() [1/2]

const Node * libMesh::ReplicatedMesh::node_ptr ( const dof_id_type  i ) const

finaloverridevirtual

Returns

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

Implements libMesh::MeshBase.

Definition at line 178 of file replicated_mesh.C.

References libMesh::libmesh_assert(), and max_node_id().

{
  libmesh_assert_less (i, this->max_node_id());
  libmesh_assert(_nodes[i]);
  libmesh_assert_equal_to (_nodes[i]->id(), i); // This will change soon

  return _nodes[i];
}

node_ptr() [2/2]

Node * libMesh::ReplicatedMesh::node_ptr ( const dof_id_type  i )

finaloverridevirtual

Returns

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

Implements libMesh::MeshBase.

Definition at line 190 of file replicated_mesh.C.

References libMesh::libmesh_assert(), and max_node_id().

{
  libmesh_assert_less (i, this->max_node_id());
  libmesh_assert(_nodes[i]);
  libmesh_assert_equal_to (_nodes[i]->id(), i); // This will change soon

  return _nodes[i];
}

node_ref() [1/2]

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

inlinevirtualinherited

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 596 of file mesh_base.h.

References libMesh::MeshBase::node_ptr().

Referenced by libMesh::SyncNodalPositions::act_on_data(), LinearElasticityWithContact::add_contact_edge_elements(), assemble_matrix_and_rhs(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::MeshBase::copy_constraint_rows(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::DTKAdapter::DTKAdapter(), fill_dirichlet_bc(), main(), point(), libMesh::DistributedMesh::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(), libMesh::DTKAdapter::update_variable_values(), and libMesh::GmshIO::write_mesh().

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

node_ref() [2/2]

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

inlinevirtualinherited

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 605 of file mesh_base.h.

References libMesh::MeshBase::node_ptr().

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

nodes_and_elements_equal()

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

protectedinherited

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

Helper function for subclass_equals() in unstructured mesh subclasses.

Definition at line 2014 of file mesh_base.C.

References libMesh::MeshBase::query_elem_ptr(), and libMesh::MeshBase::query_node_ptr().

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

operator!=()

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

inlineinherited

Definition at line 133 of file mesh_base.h.

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

operator=() [1/2]

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

delete

Copy assignment is not allowed.

operator=() [2/2]

ReplicatedMesh & libMesh::ReplicatedMesh::operator=

(

ReplicatedMesh &&

other_mesh

)

Move assignment operator.

Definition at line 133 of file replicated_mesh.C.

References move_nodes_and_elements(), libMesh::UnstructuredMesh::operator=(), and libMesh::MeshBase::post_dofobject_moves().

{
  LOG_SCOPE("operator=(&&)", "ReplicatedMesh");

  // Move assign as an UnstructuredMesh
  this->UnstructuredMesh::operator=(std::move(other_mesh));

  // Nodes and elements belong to ReplicatedMesh and have to be
  // moved before we can move arbitrary GhostingFunctor, Partitioner,
  // etc. subclasses.
  this->move_nodes_and_elements(std::move(other_mesh));

  // Handle those remaining moves.
  this->post_dofobject_moves(std::move(other_mesh));

  return *this;
}

operator==()

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

inherited

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 226 of file mesh_base.C.

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

{
  LOG_SCOPE("operator==()", "MeshBase");

  bool is_equal = this->locally_equals(other_mesh);
  this->comm().min(is_equal);
  return is_equal;
}

own_node()

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

inlinevirtualinherited

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 740 of file mesh_base.h.

{}

parallel_max_unique_id()

unique_id_type libMesh::ReplicatedMesh::parallel_max_unique_id ( ) const

finaloverridevirtual

Returns

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

Implements libMesh::MeshBase.

Definition at line 711 of file replicated_mesh.C.

References libMesh::MeshBase::_next_unique_id, libMesh::ParallelObject::comm(), and TIMPI::Communicator::max().

Referenced by update_parallel_id_counts().

{
  // This function must be run on all processors at once
  parallel_object_only();

  unique_id_type max_local = _next_unique_id;
  this->comm().max(max_local);
  return max_local;
}

parallel_n_elem()

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

inlinefinaloverridevirtual

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.

Implements libMesh::MeshBase.

Definition at line 154 of file replicated_mesh.h.

References _n_elem.

  { return _n_elem; }

parallel_n_nodes()

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

inlinefinaloverridevirtual

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.

Implements libMesh::MeshBase.

Definition at line 142 of file replicated_mesh.h.

References _n_nodes.

  { return _n_nodes; }

partition() [1/2]

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

virtualinherited

Call the default partitioner (currently metis_partition()).

Definition at line 1576 of file mesh_base.C.

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

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

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

partition() [2/2]

void libMesh::MeshBase::partition ( )

inlineinherited

Definition at line 1162 of file mesh_base.h.

References libMesh::ParallelObject::n_processors().

Referenced by libMesh::MeshBase::prepare_for_use().

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

partitioner()

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

inlinevirtualinherited

A partitioner to use at each prepare_for_use()

Definition at line 160 of file mesh_base.h.

References libMesh::MeshBase::_partitioner.

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

{ return _partitioner; }

point()

const Point & libMesh::ReplicatedMesh::point ( const dof_id_type  i ) const

finaloverridevirtual

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.

Implements libMesh::MeshBase.

Definition at line 170 of file replicated_mesh.C.

References libMesh::MeshBase::node_ref().

{
  return this->node_ref(i);
}

post_dofobject_moves()

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

protectedinherited

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 1969 of file mesh_base.C.

References libMesh::MeshBase::_constraint_rows, libMesh::MeshBase::_default_ghosting, libMesh::MeshBase::_ghosting_functors, libMesh::MeshBase::_partitioner, and libMesh::MeshBase::_shared_functors.

Referenced by operator=().

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

prepare_for_use() [1/3]

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

inherited

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

This involves 4 steps: 1.) call find_neighbors() 2.) call partition() 3.) call renumber_nodes_and_elements() 4.) call cache_elem_data()

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 759 of file mesh_base.C.

References libMesh::MeshBase::allow_find_neighbors(), libMesh::MeshBase::allow_renumbering(), and libMesh::MeshBase::prepare_for_use().

Referenced by LinearElasticityWithContact::add_contact_edge_elements(), libMesh::MeshTools::Subdivision::all_subdivision(), libMesh::MeshTools::Modification::all_tri(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::MeshRefinement::coarsen_elements(), libMesh::UnstructuredMesh::create_submesh(), libMesh::MeshTools::Modification::flatten(), main(), libMesh::MeshTools::Subdivision::prepare_subdivision_mesh(), libMesh::GMVIO::read(), libMesh::MeshRefinement::refine_and_coarsen_elements(), libMesh::SimplexRefiner::refine_elements(), libMesh::MeshRefinement::refine_elements(), libMesh::C0Polyhedron::retriangulate(), libMesh::MeshTools::Generation::surface_octahedron(), libMesh::BoundaryInfo::sync(), MeshSpatialDimensionTest::test1D(), ConstraintOperatorTest::test1DCoarseningNewNodes(), ConstraintOperatorTest::test1DCoarseningOperator(), MeshSpatialDimensionTest::test2D(), ExodusTest< elem_type >::test_read_gold(), ExodusTest< elem_type >::test_write(), MeshInputTest::testAbaqusRead(), SystemsTest::testBlockRestrictedVarNDofs(), BoundaryInfoTest::testBoundaryOnChildrenBoundaryIDs(), BoundaryInfoTest::testBoundaryOnChildrenBoundarySides(), BoundaryInfoTest::testBoundaryOnChildrenElementsRefineCoarsen(), BoundaryInfoTest::testBoundaryOnChildrenErrors(), MeshInputTest::testCopyElementSolutionImpl(), MeshInputTest::testCopyElementVectorImpl(), MeshInputTest::testCopyNodalSolutionImpl(), ConstraintOperatorTest::testCoreform(), MeshDeletionsTest::testDeleteElem(), SystemsTest::testDofCouplingWithVarGroups(), MeshInputTest::testDynaFileMappings(), MeshInputTest::testDynaNoSplines(), MeshInputTest::testDynaReadElem(), MeshInputTest::testDynaReadPatch(), ConnectedComponentsTest::testEdge(), MeshTriangulationTest::testEdgesMesh(), MeshInputTest::testExodusFileMappings(), MeshInputTest::testExodusIGASidesets(), MeshInputTest::testExodusWriteElementDataFromDiscontinuousNodalData(), MeshInputTest::testLowOrderEdgeBlocks(), MeshInputTest::testNemesisReadImpl(), NodalNeighborsTest::testOrientation(), MeshTriangulationTest::testPoly2TriBad1DMultiBoundary(), MeshTriangulationTest::testPoly2TriBad2DMultiBoundary(), MeshTriangulationTest::testPoly2TriBadEdges(), EquationSystemsTest::testPostInitAddElem(), SystemsTest::testProjectMatrix3D(), InfFERadialTest::testRefinement(), EquationSystemsTest::testReinitWithNodeElem(), SystemsTest::testSetSystemParameterOverEquationSystem(), BoundaryInfoTest::testShellFaceConstraints(), MeshInputTest::testSingleElementImpl(), MeshInputTest::testTetgenIO(), MeshTetTest::testTetsToTets(), MeshTetTest::testTrisToTetsError(), MeshInputTest::testVTKPreserveElemIds(), MeshInputTest::testVTKPreserveSubdomainIds(), tetrahedralize_domain(), libMesh::TriangleInterface::triangulate(), libMesh::Poly2TriTriangulator::triangulate(), libMesh::NetGenMeshInterface::triangulate(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::MeshRefinement::uniformly_refine(), and libMesh::MeshTetInterface::volume_to_surface_mesh().

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

prepare_for_use() [2/3]

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

inherited

Definition at line 778 of file mesh_base.C.

References libMesh::MeshBase::allow_renumbering(), and libMesh::MeshBase::prepare_for_use().

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

prepare_for_use() [3/3]

void libMesh::MeshBase::prepare_for_use ( )

inherited

Definition at line 794 of file mesh_base.C.

References libMesh::MeshBase::_allow_remote_element_removal, libMesh::MeshBase::_is_prepared, libMesh::MeshBase::_skip_find_neighbors, libMesh::MeshBase::_skip_renumber_nodes_and_elements, libMesh::MeshBase::cache_elem_data(), libMesh::MeshBase::clear_point_locator(), libMesh::ParallelObject::comm(), libMesh::MeshBase::delete_remote_elements(), libMesh::MeshBase::detect_interior_parents(), libMesh::MeshBase::find_neighbors(), libMesh::MeshBase::get_boundary_info(), libMesh::MeshBase::is_serial(), libMesh::libmesh_assert(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_constraint_rows(), libMesh::MeshTools::libmesh_assert_valid_unique_ids(), libMesh::MeshBase::partition(), libMesh::BoundaryInfo::regenerate_id_sets(), libMesh::MeshBase::reinit_ghosting_functors(), libMesh::MeshBase::remove_orphaned_nodes(), libMesh::MeshBase::renumber_nodes_and_elements(), libMesh::MeshBase::skip_partitioning(), and libMesh::MeshBase::update_parallel_id_counts().

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

{
  LOG_SCOPE("prepare_for_use()", "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)
    this->renumber_nodes_and_elements();
  else
    {
      this->remove_orphaned_nodes();
      this->update_parallel_id_counts();
    }

  // Let all the elements find their neighbors
  if (!_skip_find_neighbors)
    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.
  this->cache_elem_data();

  // Search the mesh for elements that have a neighboring element
  // of dim+1 and set that element as the interior parent
  this->detect_interior_parents();

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

  // Reset our PointLocator.  Any old locator is invalidated any time
  // the elements in the underlying elements in the mesh have changed,
  // so we clear it here.
  this->clear_point_locator();

  // Allow our GhostingFunctor objects to reinit if necessary.
  // Do this before partitioning and redistributing, and before
  // deleting remote elements.
  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())
    this->partition();

  // If we're using DistributedMesh, we'll probably want it
  // parallelized.
  if (this->_allow_remote_element_removal)
    this->delete_remote_elements();

  // 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
  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.
  _is_prepared = true;

#ifdef DEBUG
  MeshTools::libmesh_assert_valid_boundary_ids(*this);
#ifdef LIBMESH_ENABLE_UNIQUE_ID
  MeshTools::libmesh_assert_valid_unique_ids(*this);
#endif
#endif
}

print_constraint_rows()

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

inherited

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 2356 of file mesh_base.C.

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

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

print_info()

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

inherited

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 1562 of file mesh_base.C.

References libMesh::MeshBase::get_info().

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

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

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.

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

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::MeshTools::Modification::all_tri(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEMSystem::assembly(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::Partitioner::assign_partitioning(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::Partitioner::build_graph(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::MeshFunction::check_found_elem(), libMesh::DistributedMesh::clear(), libMesh::DistributedMesh::clear_elems(), libMesh::ExodusII_IO_Helper::close(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::compute_communication_map_parameters(), libMesh::Nemesis_IO_Helper::compute_internal_and_border_elems_and_internal_nodes(), libMesh::RBConstruction::compute_max_error_bound(), libMesh::Nemesis_IO_Helper::compute_node_communication_maps(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::Nemesis_IO::copy_scalar_solution(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::ExodusII_IO_Helper::create(), libMesh::DistributedMesh::delete_elem(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_scalar_dofs(), libMesh::DistributedMesh::DistributedMesh(), libMesh::DofMapBase::end_dof(), libMesh::DofMapBase::end_old_dof(), libMesh::EnsightIO::EnsightIO(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::find_dofs_to_send(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::DofMapBase::first_dof(), libMesh::DofMapBase::first_old_dof(), libMesh::RBEIMEvaluation::gather_bfs(), libMesh::Nemesis_IO_Helper::get_cmap_params(), libMesh::Nemesis_IO_Helper::get_eb_info_global(), libMesh::Nemesis_IO_Helper::get_elem_cmap(), libMesh::Nemesis_IO_Helper::get_elem_map(), libMesh::MeshBase::get_info(), libMesh::DofMap::get_info(), libMesh::Nemesis_IO_Helper::get_init_global(), libMesh::Nemesis_IO_Helper::get_init_info(), libMesh::RBEIMEvaluation::get_interior_basis_functions_as_vecs(), libMesh::Nemesis_IO_Helper::get_loadbal_param(), libMesh::DofMap::get_local_constraints(), libMesh::MeshBase::get_local_constraints(), libMesh::Nemesis_IO_Helper::get_node_cmap(), libMesh::Nemesis_IO_Helper::get_node_map(), libMesh::Nemesis_IO_Helper::get_ns_param_global(), libMesh::Nemesis_IO_Helper::get_ss_param_global(), libMesh::SparsityPattern::Build::handle_vi_vj(), libMesh::LaplaceMeshSmoother::init(), libMesh::SystemSubsetBySubdomain::init(), HeatSystem::init_data(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize_element_variables(), libMesh::ExodusII_IO_Helper::initialize_global_variables(), libMesh::ExodusII_IO_Helper::initialize_nodal_variables(), libMesh::DistributedMesh::insert_elem(), libMesh::DofMap::is_evaluable(), libMesh::SparsityPattern::Build::join(), libMesh::TransientRBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBSCMEvaluation::legacy_write_offline_data_to_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DofMap::local_variable_indices(), main(), libMesh::MeshRefinement::make_coarsening_compatible(), AugmentSparsityOnInterface::mesh_reinit(), libMesh::TriangulatorInterface::MeshedHole::MeshedHole(), libMesh::MeshBase::n_active_local_elem(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::MeshTools::n_connected_components(), libMesh::MeshBase::n_constraint_rows(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::DofMapBase::n_local_dofs(), libMesh::MeshBase::n_local_elem(), libMesh::MeshBase::n_local_nodes(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::DistributedMesh::own_node(), libMesh::BoundaryInfo::parallel_sync_node_ids(), libMesh::BoundaryInfo::parallel_sync_side_ids(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::MeshBase::print_constraint_rows(), libMesh::DofMap::print_dof_constraints(), libMesh::DofMap::process_mesh_constraint_rows(), libMesh::Nemesis_IO_Helper::put_cmap_params(), libMesh::Nemesis_IO_Helper::put_elem_cmap(), libMesh::Nemesis_IO_Helper::put_elem_map(), libMesh::Nemesis_IO_Helper::put_loadbal_param(), libMesh::Nemesis_IO_Helper::put_node_cmap(), libMesh::Nemesis_IO_Helper::put_node_map(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read(), libMesh::EquationSystems::read(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::ExodusII_IO_Helper::read_global_values(), libMesh::ExodusII_IO::read_header(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::System::read_header(), libMesh::System::read_legacy_data(), libMesh::DynaIO::read_mesh(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::System::read_parallel_data(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::System::read_serialized_data(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::System::read_serialized_vectors(), libMesh::Nemesis_IO_Helper::read_var_names_impl(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::StaticCondensationDofMap::reinit(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DistributedMesh::renumber_nodes_and_elements(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::DistributedMesh::set_next_unique_id(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::RBEIMEvaluation::side_gather_bfs(), ExodusTest< elem_type >::test_read_gold(), ExodusTest< elem_type >::test_write(), MeshInputTest::testAbaqusRead(), MeshInputTest::testBadGmsh(), MeshInputTest::testCopyElementSolutionImpl(), MeshInputTest::testCopyElementVectorImpl(), MeshInputTest::testCopyNodalSolutionImpl(), DefaultCouplingTest::testCoupling(), PointNeighborCouplingTest::testCoupling(), MeshInputTest::testDynaFileMappings(), MeshInputTest::testDynaNoSplines(), MeshInputTest::testDynaReadElem(), MeshInputTest::testDynaReadPatch(), MeshInputTest::testExodusFileMappings(), MeshInputTest::testExodusIGASidesets(), MeshInputTest::testExodusWriteElementDataFromDiscontinuousNodalData(), MeshInputTest::testGmshBCIDOverlap(), MeshInputTest::testGoodGmsh(), MeshInputTest::testGoodSTL(), MeshInputTest::testGoodSTLBinary(), MeshInputTest::testLowOrderEdgeBlocks(), SystemsTest::testProjectMatrix3D(), BoundaryInfoTest::testShellFaceConstraints(), MeshInputTest::testSingleElementImpl(), WriteVecAndScalar::testSolution(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), libMesh::MeshTools::total_weight(), libMesh::NetGenMeshInterface::triangulate(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::DTKAdapter::update_variable_values(), libMesh::MeshTools::volume(), libMesh::STLIO::write(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::CheckpointIO::write(), libMesh::EquationSystems::write(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO::write_element_data(), libMesh::ExodusII_IO_Helper::write_element_values(), libMesh::ExodusII_IO_Helper::write_element_values_element_major(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO_Helper::write_elemset_data(), libMesh::ExodusII_IO_Helper::write_elemsets(), libMesh::ExodusII_IO::write_global_data(), libMesh::ExodusII_IO_Helper::write_global_values(), libMesh::System::write_header(), libMesh::ExodusII_IO::write_information_records(), libMesh::ExodusII_IO_Helper::write_information_records(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::UCDIO::write_nodal_data(), libMesh::VTKIO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data_common(), libMesh::ExodusII_IO::write_nodal_data_discontinuous(), libMesh::ExodusII_IO_Helper::write_nodal_values(), libMesh::ExodusII_IO_Helper::write_nodeset_data(), libMesh::Nemesis_IO_Helper::write_nodesets(), libMesh::ExodusII_IO_Helper::write_nodesets(), libMesh::RBEIMEvaluation::write_out_interior_basis_functions(), libMesh::RBEIMEvaluation::write_out_node_basis_functions(), libMesh::RBEIMEvaluation::write_out_side_basis_functions(), write_output_solvedata(), libMesh::System::write_parallel_data(), libMesh::RBConstruction::write_riesz_representors_to_files(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bc_names(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::System::write_serialized_data(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::XdrIO::write_serialized_subdomain_names(), libMesh::System::write_serialized_vector(), libMesh::System::write_serialized_vectors(), libMesh::ExodusII_IO_Helper::write_sideset_data(), libMesh::Nemesis_IO_Helper::write_sidesets(), libMesh::ExodusII_IO_Helper::write_sidesets(), libMesh::ExodusII_IO::write_timestep(), libMesh::ExodusII_IO_Helper::write_timestep(), and libMesh::ExodusII_IO::write_timestep_discontinuous().

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

query_elem_ptr() [1/2]

const Elem * libMesh::ReplicatedMesh::query_elem_ptr ( const dof_id_type  i ) const

finaloverridevirtual

Returns

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

Implements libMesh::MeshBase.

Definition at line 252 of file replicated_mesh.C.

References _elements, libMesh::libmesh_assert(), and max_elem_id().

{
  if (i >= this->max_elem_id())
    return nullptr;
  libmesh_assert (_elements[i] == nullptr ||
                  _elements[i]->id() == i); // This will change soon

  return _elements[i];
}

query_elem_ptr() [2/2]

Elem * libMesh::ReplicatedMesh::query_elem_ptr ( const dof_id_type  i )

finaloverridevirtual

Returns

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

Implements libMesh::MeshBase.

Definition at line 265 of file replicated_mesh.C.

References _elements, libMesh::libmesh_assert(), and max_elem_id().

{
  if (i >= this->max_elem_id())
    return nullptr;
  libmesh_assert (_elements[i] == nullptr ||
                  _elements[i]->id() == i); // This will change soon

  return _elements[i];
}

query_node_ptr() [1/2]

const Node * libMesh::ReplicatedMesh::query_node_ptr ( const dof_id_type  i ) const

finaloverridevirtual

Returns

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

Implements libMesh::MeshBase.

Definition at line 202 of file replicated_mesh.C.

References libMesh::libmesh_assert(), and max_node_id().

Referenced by libMesh::C0Polyhedron::retriangulate().

{
  if (i >= this->max_node_id())
    return nullptr;
  libmesh_assert (_nodes[i] == nullptr ||
                  _nodes[i]->id() == i); // This will change soon

  return _nodes[i];
}

query_node_ptr() [2/2]

Node * libMesh::ReplicatedMesh::query_node_ptr ( const dof_id_type  i )

finaloverridevirtual

Returns

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

Implements libMesh::MeshBase.

Definition at line 215 of file replicated_mesh.C.

References libMesh::libmesh_assert(), and max_node_id().

{
  if (i >= this->max_node_id())
    return nullptr;
  libmesh_assert (_nodes[i] == nullptr ||
                  _nodes[i]->id() == i); // This will change soon

  return _nodes[i];
}

read()

void libMesh::UnstructuredMesh::read ( const std::string &  name, void *  mesh_data = nullptr, bool  skip_renumber_nodes_and_elements = false, bool  skip_find_neighbors = false  )

overridevirtualinherited

Reads the file specified by name.

Attempts to figure out the proper method by the file extension. This is now the only way to read a mesh. The UnstructuredMesh then initializes its data structures and is ready for use.

The skip_renumber_nodes_and_elements argument is now deprecated - to disallow renumbering, set MeshBase::allow_renumbering(false).

Set skip_find_neighbors=true to skip the find-neighbors operation during prepare_for_use. This operation isn't always necessary and it can be time-consuming, which is why we provide an option to skip it.

Implements libMesh::MeshBase.

Definition at line 1229 of file unstructured_mesh.C.

References libMesh::MeshBase::allow_find_neighbors(), libMesh::MeshBase::allow_renumbering(), libMesh::Quality::name(), libMesh::MeshBase::prepare_for_use(), and libMesh::NameBasedIO::read().

Referenced by ExtraIntegersTest::checkpoint_helper(), main(), ExtraIntegersTest::test_helper(), SlitMeshRefinedSystemTest::testRestart(), and WriteElemsetData::testWriteImpl().

{
  // Set the skip_renumber_nodes_and_elements flag on all processors
  // if necessary.
  // This ensures that renumber_nodes_and_elements is *not* called
  // during prepare_for_use() for certain types of mesh files.
  // This is required in cases where there is an associated solution
  // file which expects a certain ordering of the nodes.
  if (name.rfind(".gmv") == name.size() - 4)
    this->allow_renumbering(false);

  NameBasedIO(*this).read(name);

  if (skip_renumber_nodes_and_elements)
    {
      // Use MeshBase::allow_renumbering() yourself instead.
      libmesh_deprecated();
      this->allow_renumbering(false);
    }

  // Done reading the mesh.  Now prepare it for use.
  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);
}

recalculate_n_partitions()

unsigned int libMesh::MeshBase::recalculate_n_partitions ( )

inherited

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 1618 of file mesh_base.C.

References libMesh::MeshBase::_n_parts, libMesh::ParallelObject::comm(), and TIMPI::Communicator::max().

Referenced by libMesh::MeshBase::partition(), and libMesh::CheckpointIO::read().

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

redistribute()

void libMesh::MeshBase::redistribute ( )

virtualinherited

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 985 of file mesh_base.C.

References libMesh::as_range(), libMesh::MeshBase::ghosting_functors_begin(), and libMesh::MeshBase::ghosting_functors_end().

Referenced by libMesh::Partitioner::partition(), libMesh::DistributedMesh::redistribute(), and libMesh::Partitioner::single_partition().

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

reinit_ghosting_functors()

void libMesh::MeshBase::reinit_ghosting_functors ( )

inherited

Loops over ghosting functors and calls mesh_reinit()

Definition at line 911 of file mesh_base.C.

References libMesh::MeshBase::_ghosting_functors, and libMesh::libmesh_assert().

Referenced by libMesh::MeshBase::prepare_for_use().

{
  for (auto & gf : _ghosting_functors)
    {
      libmesh_assert(gf);
      gf->mesh_reinit();
    }
}

remove_ghosting_functor()

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

inherited

Removes a functor which was previously added to the set of ghosting functors.

Definition at line 948 of file mesh_base.C.

References libMesh::MeshBase::_ghosting_functors, and libMesh::MeshBase::_shared_functors.

Referenced by libMesh::DofMap::clear(), libMesh::DofMap::remove_algebraic_ghosting_functor(), libMesh::DofMap::remove_coupling_functor(), EquationSystemsTest::testDisableDefaultGhosting(), and libMesh::DofMap::~DofMap().

{
  _ghosting_functors.erase(&ghosting_functor);

  if (const auto it = _shared_functors.find(&ghosting_functor);
      it != _shared_functors.end())
    _shared_functors.erase(it);
}

remove_orphaned_nodes()

void libMesh::MeshBase::remove_orphaned_nodes ( )

inherited

Removes any orphaned nodes, nodes not connected to any elements.

Typically done automatically in prepare_for_use

Definition at line 738 of file mesh_base.C.

References libMesh::MeshBase::delete_node().

Referenced by libMesh::MeshBase::prepare_for_use().

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

renumber_elem()

void libMesh::ReplicatedMesh::renumber_elem ( dof_id_type  old_id, dof_id_type  new_id  )

finaloverridevirtual

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.

Implements libMesh::MeshBase.

Definition at line 427 of file replicated_mesh.C.

References _elements, libMesh::libmesh_assert(), and libMesh::DofObject::set_id().

{
  // This could be a no-op
  if (old_id == new_id)
    return;

  // This doesn't get used in serial yet
  Elem * el = _elements[old_id];
  libmesh_assert (el);

  if (new_id >= _elements.size())
    _elements.resize(new_id+1, nullptr);

  el->set_id(new_id);
  libmesh_assert (!_elements[new_id]);
  _elements[new_id] = el;
  _elements[old_id] = nullptr;
}

renumber_node()

void libMesh::ReplicatedMesh::renumber_node ( dof_id_type  old_id, dof_id_type  new_id  )

finaloverridevirtual

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.

Implements libMesh::MeshBase.

Definition at line 648 of file replicated_mesh.C.

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

{
  // This could be a no-op
  if (old_id == new_id)
    return;

  // This doesn't get used in serial yet
  Node * nd = _nodes[old_id];
  libmesh_assert (nd);

  if (new_id >= _nodes.size())
    _nodes.resize(new_id+1, nullptr);

  nd->set_id(new_id);
  libmesh_assert (!_nodes[new_id]);
  _nodes[new_id] = nd;
  _nodes[old_id] = nullptr;
}

renumber_nodes_and_elements()

void libMesh::ReplicatedMesh::renumber_nodes_and_elements ( )

overridevirtual

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.

Note that regardless of whether _skip_renumber_nodes_and_elements is true, this method will always remove nullptr nodes and elements from arrays and consequently will always renumber. So in practice _skip_renumber_nodes_and_elements means skip reordering of non-null nodes and elements while allowing renumbering

Implements libMesh::MeshBase.

Definition at line 731 of file replicated_mesh.C.

References libMesh::MeshBase::_constraint_rows, _elements, _n_nodes, libMesh::MeshBase::_skip_renumber_nodes_and_elements, libMesh::as_range(), libMesh::MeshBase::get_boundary_info(), libMesh::libmesh_assert(), libMesh::Elem::node_ref_range(), libMesh::BoundaryInfo::remove(), libMesh::DofObject::set_id(), and update_parallel_id_counts().

{
  LOG_SCOPE("renumber_nodes_and_elem()", "Mesh");

  // node and element id counters
  dof_id_type next_free_elem = 0;
  dof_id_type next_free_node = 0;

  // Will hold the set of nodes that are currently connected to elements
  std::unordered_set<Node *> connected_nodes;

  // Loop over the elements.  Note that there may
  // be nullptrs in the _elements vector from the coarsening
  // process.  Pack the elements in to a contiguous array
  // and then trim any excess.
  {
    std::vector<Elem *>::iterator in        = _elements.begin();
    std::vector<Elem *>::iterator out_iter  = _elements.begin();
    const std::vector<Elem *>::iterator end = _elements.end();

    for (; in != end; ++in)
      if (*in != nullptr)
        {
          Elem * el = *in;

          *out_iter = *in;
          ++out_iter;

          // Increment the element counter
          el->set_id (next_free_elem++);

          if (_skip_renumber_nodes_and_elements)
            {
              // Add this elements nodes to the connected list
              for (auto & n : el->node_ref_range())
                connected_nodes.insert(&n);
            }
          else  // We DO want node renumbering
            {
              // Loop over this element's nodes.  Number them,
              // if they have not been numbered already.  Also,
              // position them in the _nodes vector so that they
              // are packed contiguously from the beginning.
              for (auto & n : el->node_ref_range())
                if (n.id() == next_free_node)    // don't need to process
                  next_free_node++;                      // [(src == dst) below]

                else if (n.id() > next_free_node) // need to process
                  {
                    // The source and destination indices
                    // for this node
                    const dof_id_type src_idx = n.id();
                    const dof_id_type dst_idx = next_free_node++;

                    // ensure we want to swap a valid nodes
                    libmesh_assert(_nodes[src_idx]);

                    // Swap the source and destination nodes
                    std::swap(_nodes[src_idx],
                              _nodes[dst_idx] );

                    // Set proper indices where that makes sense
                    if (_nodes[src_idx] != nullptr)
                      _nodes[src_idx]->set_id (src_idx);
                    _nodes[dst_idx]->set_id (dst_idx);
                  }
            }
        }

    // Erase any additional storage. These elements have been
    // copied into nullptr voids by the procedure above, and are
    // thus repeated and unnecessary.
    _elements.erase (out_iter, end);
  }


  if (_skip_renumber_nodes_and_elements)
    {
      // Loop over the nodes.  Note that there may
      // be nullptrs in the _nodes vector from the coarsening
      // process.  Pack the nodes in to a contiguous array
      // and then trim any excess.

      std::vector<Node *>::iterator in        = _nodes.begin();
      std::vector<Node *>::iterator out_iter  = _nodes.begin();
      const std::vector<Node *>::iterator end = _nodes.end();

      for (; in != end; ++in)
        if (*in != nullptr)
          {
            // This is a reference so that if we change the pointer it will change in the vector
            Node * & nd = *in;

            // If this node is still connected to an elem, put it in the list
            if (connected_nodes.count(nd))
              {
                *out_iter = nd;
                ++out_iter;

                // Increment the node counter
                nd->set_id (next_free_node++);
              }
            else // This node is orphaned, delete it!
              {
                this->get_boundary_info().remove (nd);
                _constraint_rows.erase(nd);

                // delete the node
                --_n_nodes;
                delete nd;
                nd = nullptr;
              }
          }

      // Erase any additional storage.  Whatever was
      _nodes.erase (out_iter, end);
    }
  else // We really DO want node renumbering
    {
      // Any nodes in the vector >= _nodes[next_free_node]
      // are not connected to any elements and may be deleted
      // if desired.

      // Now, delete the unused nodes
      {
        std::vector<Node *>::iterator nd        = _nodes.begin();
        const std::vector<Node *>::iterator end = _nodes.end();

        std::advance (nd, next_free_node);

        for (auto & node : as_range(nd, end))
          {
            // Mesh modification code might have already deleted some
            // nodes
            if (node == nullptr)
              continue;

            // remove any boundary information associated with
            // this node
            this->get_boundary_info().remove (node);
            _constraint_rows.erase(node);

            // delete the node
            --_n_nodes;
            delete node;
            node = nullptr;
          }

        _nodes.erase (nd, end);
      }
    }

  libmesh_assert_equal_to (next_free_elem, _elements.size());
  libmesh_assert_equal_to (next_free_node, _nodes.size());

  this->update_parallel_id_counts();
}

reserve_elem()

virtual void libMesh::ReplicatedMesh::reserve_elem ( const dof_id_type  ne )

inlinefinaloverridevirtual

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.

Implements libMesh::MeshBase.

Definition at line 167 of file replicated_mesh.h.

References _elements.

  { _elements.reserve (ne); }

reserve_nodes()

virtual void libMesh::ReplicatedMesh::reserve_nodes ( const dof_id_type  nn )

inlinefinaloverridevirtual

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.

Implements libMesh::MeshBase.

Definition at line 148 of file replicated_mesh.h.

  { _nodes.reserve (nn); }

set_count_lower_dim_elems_in_point_locator()

void libMesh::MeshBase::set_count_lower_dim_elems_in_point_locator ( bool  count_lower_dim_elems )

inherited

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 1678 of file mesh_base.C.

References libMesh::MeshBase::_count_lower_dim_elems_in_point_locator.

{
  _count_lower_dim_elems_in_point_locator = count_lower_dim_elems;
}

set_default_mapping_data()

void libMesh::MeshBase::set_default_mapping_data ( const unsigned char  data )

inlineinherited

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

Definition at line 839 of file mesh_base.h.

References libMesh::MeshBase::_default_mapping_data.

Referenced by libMesh::ExodusII_IO::read(), and libMesh::DynaIO::read_mesh().

  {
    _default_mapping_data = data;
  }

set_default_mapping_type()

void libMesh::MeshBase::set_default_mapping_type ( const ElemMappingType  type )

inlineinherited

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

Definition at line 821 of file mesh_base.h.

References libMesh::MeshBase::_default_mapping_type.

Referenced by libMesh::ExodusII_IO::read(), and libMesh::DynaIO::read_mesh().

  {
    _default_mapping_type = type;
  }

set_distributed()

virtual void libMesh::MeshBase::set_distributed ( )

inlinevirtualinherited

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 226 of file mesh_base.h.

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

  { libmesh_error(); }

set_elem_dimensions()

void libMesh::MeshBase::set_elem_dimensions ( std::set< unsigned char >  elem_dims )

inherited

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 381 of file mesh_base.C.

References libMesh::MeshBase::_elem_dims, and libMesh::MeshBase::cache_elem_data().

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

set_interior_mesh()

void libMesh::MeshBase::set_interior_mesh ( MeshBase &  int_mesh )

inlineinherited

Sets the interior mesh.

For advanced use only.

Definition at line 1807 of file mesh_base.h.

References libMesh::MeshBase::_interior_mesh.

Referenced by libMesh::BoundaryInfo::add_elements().

{ _interior_mesh = &int_mesh; }

set_isnt_prepared()

void libMesh::MeshBase::set_isnt_prepared ( )

inlineinherited

Tells this we have done some operation where we should no longer consider ourself prepared.

Definition at line 204 of file mesh_base.h.

References libMesh::MeshBase::_is_prepared.

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

  { _is_prepared = false; }

set_mesh_dimension()

void libMesh::MeshBase::set_mesh_dimension ( unsigned char  d )

inlineinherited

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 275 of file mesh_base.h.

References libMesh::MeshBase::_elem_dims.

Referenced by libMesh::MeshTools::Generation::build_delaunay_square(), libMesh::TriangleWrapper::copy_tri_to_mesh(), libMesh::AbaqusIO::read(), libMesh::GMVIO::read(), libMesh::STLIO::read(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::VTKIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::CheckpointIO::read_header(), libMesh::UCDIO::read_implementation(), libMesh::GmshIO::read_mesh(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::OFFIO::read_stream(), libMesh::MatlabIO::read_stream(), InfFERadialTest::testRefinement(), libMesh::TriangleInterface::triangulate(), and libMesh::Poly2TriTriangulator::triangulate().

  { _elem_dims.clear(); _elem_dims.insert(d); }

set_n_partitions()

unsigned int& libMesh::MeshBase::set_n_partitions ( )

inlineprotectedinherited

Returns

A writable reference to the number of partitions.

Definition at line 1865 of file mesh_base.h.

References libMesh::MeshBase::_n_parts.

Referenced by libMesh::Partitioner::partition(), libMesh::Partitioner::repartition(), and libMesh::BoundaryInfo::sync().

  { return _n_parts; }

set_next_unique_id()

void libMesh::ReplicatedMesh::set_next_unique_id ( unique_id_type  id )

finaloverridevirtual

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.

Implements libMesh::MeshBase.

Definition at line 723 of file replicated_mesh.C.

References libMesh::MeshBase::_next_unique_id.

{
  _next_unique_id = id;
}

set_point_locator_close_to_point_tol()

void libMesh::MeshBase::set_point_locator_close_to_point_tol ( Real  val )

inherited

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 1919 of file mesh_base.C.

References libMesh::MeshBase::_point_locator, and libMesh::MeshBase::_point_locator_close_to_point_tol.

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

set_spatial_dimension()

void libMesh::MeshBase::set_spatial_dimension ( unsigned char  d )

inherited

Sets the "spatial dimension" of the Mesh.

See the documentation for Mesh::spatial_dimension() for more information.

Definition at line 550 of file mesh_base.C.

References libMesh::MeshBase::_spatial_dimension.

Referenced by libMesh::MeshTools::Modification::rotate(), MeshSpatialDimensionTest::test2D(), and InfFERadialTest::testRefinement().

{
  // The user can set the _spatial_dimension however they wish,
  // libMesh will only *increase* the spatial dimension, however,
  // never decrease it.
  _spatial_dimension = d;
}

set_subdomain_name_map()

const DofMap& dof_map LIBMESH_COMMA unsigned int std::string& libMesh::MeshBase::set_subdomain_name_map ( )

inlineinherited

Definition at line 1692 of file mesh_base.h.

References libMesh::MeshBase::_block_id_to_name.

Referenced by libMesh::DistributedMesh::DistributedMesh(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::CheckpointIO::read_subdomain_names(), and ReplicatedMesh().

  { return _block_id_to_name; }

size_elem_extra_integers()

void libMesh::MeshBase::size_elem_extra_integers ( )

protectedinherited

Size extra-integer arrays of all elements in the mesh.

Definition at line 1940 of file mesh_base.C.

References libMesh::MeshBase::_elem_integer_default_values, and libMesh::MeshBase::_elem_integer_names.

Referenced by libMesh::MeshBase::add_elem_data(), libMesh::MeshBase::add_elem_datum(), libMesh::MeshBase::add_elem_integer(), and libMesh::MeshBase::add_elem_integers().

{
  const std::size_t new_size = _elem_integer_names.size();
  for (auto elem : this->element_ptr_range())
    elem->add_extra_integers(new_size, _elem_integer_default_values);
}

size_node_extra_integers()

void libMesh::MeshBase::size_node_extra_integers ( )

protectedinherited

Size extra-integer arrays of all nodes in the mesh.

Definition at line 1949 of file mesh_base.C.

References libMesh::MeshBase::_node_integer_default_values, and libMesh::MeshBase::_node_integer_names.

Referenced by libMesh::MeshBase::add_node_data(), libMesh::MeshBase::add_node_datum(), libMesh::MeshBase::add_node_integer(), and libMesh::MeshBase::add_node_integers().

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

skip_noncritical_partitioning() [1/2]

void libMesh::MeshBase::skip_noncritical_partitioning ( bool  skip )

inlineinherited

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 1236 of file mesh_base.h.

References libMesh::MeshBase::_skip_noncritical_partitioning.

Referenced by libMesh::MeshTools::correct_node_proc_ids(), MeshInputTest::testCopyElementSolutionImpl(), MeshInputTest::testCopyElementVectorImpl(), and MeshInputTest::testCopyNodalSolutionImpl().

  { _skip_noncritical_partitioning = skip; }

skip_noncritical_partitioning() [2/2]

bool libMesh::MeshBase::skip_noncritical_partitioning ( ) const

inlineinherited

Definition at line 1239 of file mesh_base.h.

References libMesh::MeshBase::_partitioner, libMesh::MeshBase::_skip_all_partitioning, and libMesh::MeshBase::_skip_noncritical_partitioning.

Referenced by libMesh::MeshBase::partition().

  { return _skip_noncritical_partitioning || _skip_all_partitioning || !_partitioner.get(); }

skip_partitioning() [1/2]

void libMesh::MeshBase::skip_partitioning ( bool  skip )

inlineinherited

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 1254 of file mesh_base.h.

References libMesh::MeshBase::_skip_all_partitioning.

Referenced by libMesh::DistributedMesh::DistributedMesh(), libMesh::CheckpointIO::read(), ReplicatedMesh(), and CheckpointIOTest::testSplitter().

{ _skip_all_partitioning = skip; }

skip_partitioning() [2/2]

bool libMesh::MeshBase::skip_partitioning ( ) const

inlineinherited

Definition at line 1256 of file mesh_base.h.

References libMesh::MeshBase::_skip_all_partitioning.

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

{ return _skip_all_partitioning; }

spatial_dimension()

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

inherited

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 prepare_for_use() based on the dimensions of the various elements present in the Mesh, but is never automatically decreased by this function.

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(). 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 543 of file mesh_base.C.

References libMesh::MeshBase::_spatial_dimension.

Referenced by libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::EquationSystems::build_variable_names(), libMesh::MeshBase::get_info(), libMesh::ExodusII_IO_Helper::initialize(), MeshSpatialDimensionTest::test1D(), and MeshSpatialDimensionTest::test2D().

{
  return cast_int<unsigned int>(_spatial_dimension);
}

stitch_meshes()

std::size_t libMesh::UnstructuredMesh::stitch_meshes ( const MeshBase &  other_mesh, boundary_id_type  this_mesh_boundary, boundary_id_type  other_mesh_boundary, Real  tol = TOLERANCE, bool  clear_stitched_boundary_ids = false, bool  verbose = true, bool  use_binary_search = true, bool  enforce_all_nodes_match_on_boundaries = false, bool  merge_boundary_nodes_all_or_nothing = false, bool  remap_subdomain_ids = false  )

inherited

Stitch other_mesh to this mesh so that this mesh is the union of the two meshes.

this_mesh_boundary and other_mesh_boundary are used to specify a dim-1 dimensional surface on which we seek to merge any "overlapping" nodes, where we use the parameter tol as a relative tolerance (relative to the smallest edge length on the surfaces being stitched) to determine whether or not nodes are overlapping. If clear_stitched_boundary_ids==true, this function clears boundary_info IDs in this mesh associated this_mesh_boundary and other_mesh_boundary. If use_binary_search is true, we use an optimized "sort then binary search" algorithm for finding matching nodes. Otherwise we use a N^2 algorithm (which can be more reliable at dealing with slightly misaligned meshes). If enforce_all_nodes_match_on_boundaries is true, we throw an error if the number of nodes on the specified boundaries don't match the number of nodes that were merged. This is a helpful error check in some cases. If this is true, it overrides the value of merge_boundary_nodes_all_or_nothing. If skip_find_neighbors is true, a faster stitching method is used, where the lists of neighbors for each elements are copied as well and patched, without calling the time-consuming find_neighbors() function. This option is now hard-coded to true. If merge_boundary_nodes_all_or_nothing is true, instead of throwing an error like enforce_all_nodes_match_on_boundaries, the meshes are combined anyway but coincident nodes are not merged into single nodes. This is useful in cases where you are not sure if the boundaries are fully conforming beforehand and you want to handle the non-conforming cases differently.

Note that the element IDs for elements in the stitched mesh corresponding to "this" mesh will be unchanged. The IDs for elements corresponding to other_mesh will be incremented by this->max_elem_id().

There is no simple a priori relationship between node IDs in "this" mesh and other_mesh and node IDs in the stitched mesh because the number of nodes (and hence the node IDs) in the stitched mesh depend on how many nodes are stitched.

If remap_subdomain_ids is true then we assume that some subdomain ids might have been autogenerated, so we remap them as necessary, treating subdomain names as the important thing for consistency; if we have missing names and cannot infer a consistent resolution to an id conflict then we exit with an error. If remap_subdomain_ids is false then we revert to the older libMesh behavior: leave all subdomain ids alone and woe unto you if you weren't keeping track of them.

Returns

the count of how many nodes were merged between the two meshes. This can be zero in the case of no matching nodes or if merge_boundary_nodes_all_or_nothing was active and relevant.

Definition at line 1729 of file unstructured_mesh.C.

References libMesh::UnstructuredMesh::stitching_helper().

{
  LOG_SCOPE("stitch_meshes()", "UnstructuredMesh");
  return stitching_helper(&other_mesh,
                          this_mesh_boundary_id,
                          other_mesh_boundary_id,
                          tol,
                          clear_stitched_boundary_ids,
                          verbose,
                          use_binary_search,
                          enforce_all_nodes_match_on_boundaries,
                          true,
                          merge_boundary_nodes_all_or_nothing,
                          remap_subdomain_ids);
}

stitch_surfaces()

std::size_t libMesh::UnstructuredMesh::stitch_surfaces ( boundary_id_type  boundary_id_1, boundary_id_type  boundary_id_2, Real  tol = TOLERANCE, bool  clear_stitched_boundary_ids = false, bool  verbose = true, bool  use_binary_search = true, bool  enforce_all_nodes_match_on_boundaries = false, bool  merge_boundary_nodes_all_or_nothing = false  )

inherited

Similar to stitch_meshes, except that we stitch two adjacent surfaces within this mesh.

Definition at line 1756 of file unstructured_mesh.C.

References libMesh::UnstructuredMesh::stitching_helper().

{
  return stitching_helper(nullptr,
                          boundary_id_1,
                          boundary_id_2,
                          tol,
                          clear_stitched_boundary_ids,
                          verbose,
                          use_binary_search,
                          enforce_all_nodes_match_on_boundaries,
                          true,
                          merge_boundary_nodes_all_or_nothing,
                          false);
}

sub_point_locator()

std::unique_ptr< PointLocatorBase > libMesh::MeshBase::sub_point_locator ( ) const

inherited

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 1638 of file mesh_base.C.

References libMesh::MeshBase::_point_locator, libMesh::MeshBase::_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::MeshFunction::init(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::OverlapCoupling::mesh_reinit(), libMesh::DefaultCoupling::mesh_reinit(), libMesh::PointNeighborCoupling::mesh_reinit(), ExodusTest< elem_type >::meshes_equal_enough(), libMesh::MeshRefinement::test_level_one(), PointLocatorTest::testLocator(), MeshInputTest::testMasterCenters(), PointLocatorTest::testPlanar(), SystemsTest::testProjectCube(), SystemsTest::testProjectLine(), and SystemsTest::testProjectSquare().

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

subclass_locally_equals()

bool libMesh::ReplicatedMesh::subclass_locally_equals ( const MeshBase &  other_mesh ) const

overridevirtual

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

Implements libMesh::MeshBase.

Definition at line 62 of file replicated_mesh.C.

References _n_elem, _n_nodes, and libMesh::MeshBase::_next_unique_id.

{
  const ReplicatedMesh * rep_mesh_ptr =
    dynamic_cast<const ReplicatedMesh *>(&other_mesh_base);
  if (!rep_mesh_ptr)
    return false;
  const ReplicatedMesh & other_mesh = *rep_mesh_ptr;

  if (_n_nodes != other_mesh._n_nodes ||
      _n_elem != other_mesh._n_elem ||
#ifdef LIBMESH_ENABLE_UNIQUE_ID
      _next_unique_id != other_mesh._next_unique_id ||
#endif
      !this->nodes_and_elements_equal(other_mesh))
    return false;

  return true;
}

subdomain_ids()

void libMesh::MeshBase::subdomain_ids ( std::set< subdomain_id_type > &  ids, const bool  global = true  ) const

inherited

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 959 of file mesh_base.C.

References libMesh::ParallelObject::comm(), and TIMPI::Communicator::set_union().

Referenced by libMesh::MeshBase::copy_constraint_rows(), get_disconnected_subdomains(), libMesh::MeshBase::n_local_subdomains(), libMesh::MeshBase::n_subdomains(), libMesh::TecplotIO::TecplotIO(), MeshSubdomainIDTest::testMultiple(), and MeshSubdomainIDTest::testUnpartitioned().

{
  // This requires an inspection on every processor
  if (global)
    parallel_object_only();

  ids.clear();

  for (const auto & elem : this->active_local_element_ptr_range())
    ids.insert(elem->subdomain_id());

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

subdomain_name() [1/2]

std::string & libMesh::MeshBase::subdomain_name ( subdomain_id_type  id )

inherited

Returns

A writable reference for getting/setting an optional name for a subdomain.

Definition at line 1692 of file mesh_base.C.

References libMesh::MeshBase::_block_id_to_name.

Referenced by libMesh::AbaqusIO::assign_subdomain_ids(), DMlibMeshSetSystem_libMesh(), libMesh::UNVIO::groups_in(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::GmshIO::read_mesh(), libMesh::UnstructuredMesh::stitching_helper(), MeshStitchTest::testAmbiguousRemappingStitch(), MeshInputTest::testGmshBCIDOverlap(), MeshStitchTest::testRemappingStitch(), libMesh::TecplotIO::write_binary(), and libMesh::ExodusII_IO_Helper::write_elements().

{
  return _block_id_to_name[id];
}

subdomain_name() [2/2]

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

inherited

Definition at line 1697 of file mesh_base.C.

References libMesh::MeshBase::_block_id_to_name.

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

supported_nodal_order()

Order libMesh::MeshBase::supported_nodal_order ( ) const

inlineinherited

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 297 of file mesh_base.h.

References libMesh::MeshBase::_supported_nodal_order.

Referenced by libMesh::MeshBase::get_info().

  { return _supported_nodal_order; }

update_parallel_id_counts()

void libMesh::ReplicatedMesh::update_parallel_id_counts ( )

overridevirtual

Updates parallel caches so that methods like n_elem() accurately reflect changes on other processors.

Implements libMesh::MeshBase.

Definition at line 701 of file replicated_mesh.C.

References libMesh::MeshBase::_next_unique_id, and parallel_max_unique_id().

Referenced by renumber_nodes_and_elements().

{
#ifdef LIBMESH_ENABLE_UNIQUE_ID
  _next_unique_id = this->parallel_max_unique_id();
#endif
}

update_post_partitioning()

virtual void libMesh::MeshBase::update_post_partitioning ( )

inlinevirtualinherited

Recalculate any cached data after elements and nodes have been repartitioned.

Reimplemented in libMesh::DistributedMesh.

Definition at line 1177 of file mesh_base.h.

Referenced by libMesh::Partitioner::partition(), libMesh::MeshBase::partition(), libMesh::Nemesis_IO::read(), and libMesh::CheckpointIO::read().

{}

write() [1/2]

void libMesh::UnstructuredMesh::write ( const std::string &  name ) const

overridevirtualinherited

Write the file specified by name.

Attempts to figure out the proper method by the file extension.

Implements libMesh::MeshBase.

Definition at line 1261 of file unstructured_mesh.C.

References libMesh::Quality::name(), and libMesh::NameBasedIO::write().

Referenced by main().

{
  LOG_SCOPE("write()", "Mesh");

  NameBasedIO(*this).write(name);
}

write() [2/2]

void libMesh::UnstructuredMesh::write ( const std::string &  name, const std::vector< Number > &  values, const std::vector< std::string > &  variable_names  ) const

inherited

Write to the file specified by name.

Attempts to figure out the proper method by the file extension. Also writes data.

Definition at line 1270 of file unstructured_mesh.C.

References libMesh::Quality::name(), and libMesh::NameBasedIO::write_nodal_data().

{
  LOG_SCOPE("write()", "Mesh");

  NameBasedIO(*this).write_nodal_data(name, v, vn);
}

Member Data Documentation

_all_elemset_ids

MeshBase::elemset_type libMesh::MeshBase::_all_elemset_ids

protectedinherited

Definition at line 2021 of file mesh_base.h.

Referenced by libMesh::MeshBase::add_elemset_code(), libMesh::MeshBase::change_elemset_id(), libMesh::MeshBase::locally_equals(), libMesh::MeshBase::n_elemsets(), and libMesh::MeshBase::operator=().

_allow_remote_element_removal

bool libMesh::MeshBase::_allow_remote_element_removal

protectedinherited

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 1963 of file mesh_base.h.

Referenced by libMesh::MeshBase::allow_remote_element_removal(), libMesh::MeshBase::locally_equals(), libMesh::MeshBase::operator=(), and libMesh::MeshBase::prepare_for_use().

_block_id_to_name

std::map<subdomain_id_type, std::string> libMesh::MeshBase::_block_id_to_name

protectedinherited

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 1970 of file mesh_base.h.

Referenced by libMesh::MeshBase::get_id_by_name(), libMesh::MeshBase::get_subdomain_name_map(), libMesh::MeshBase::locally_equals(), libMesh::MeshBase::operator=(), libMesh::MeshBase::set_subdomain_name_map(), and libMesh::MeshBase::subdomain_name().

_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(), and libMesh::StaticCondensationDofMap::reinit().

_constraint_rows

constraint_rows_type libMesh::MeshBase::_constraint_rows

protectedinherited

Definition at line 2104 of file mesh_base.h.

Referenced by libMesh::MeshBase::clear(), libMesh::MeshBase::copy_constraint_rows(), delete_node(), libMesh::DistributedMesh::delete_node(), libMesh::MeshBase::get_constraint_rows(), libMesh::MeshBase::get_local_constraints(), libMesh::MeshBase::locally_equals(), libMesh::MeshBase::n_constraint_rows(), libMesh::MeshBase::post_dofobject_moves(), renumber_nodes_and_elements(), and libMesh::DistributedMesh::renumber_nodes_and_elements().

_count_lower_dim_elems_in_point_locator

bool libMesh::MeshBase::_count_lower_dim_elems_in_point_locator

protectedinherited

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

Definition at line 1911 of file mesh_base.h.

Referenced by libMesh::MeshBase::get_count_lower_dim_elems_in_point_locator(), libMesh::MeshBase::locally_equals(), libMesh::MeshBase::operator=(), and libMesh::MeshBase::set_count_lower_dim_elems_in_point_locator().

_default_ghosting

std::unique_ptr<GhostingFunctor> libMesh::MeshBase::_default_ghosting

protectedinherited

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 2077 of file mesh_base.h.

Referenced by libMesh::MeshBase::default_ghosting(), libMesh::MeshBase::locally_equals(), libMesh::MeshBase::MeshBase(), and libMesh::MeshBase::post_dofobject_moves().

_default_mapping_data

unsigned char libMesh::MeshBase::_default_mapping_data

protectedinherited

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 1891 of file mesh_base.h.

Referenced by libMesh::MeshBase::default_mapping_data(), libMesh::MeshBase::locally_equals(), libMesh::MeshBase::operator=(), and libMesh::MeshBase::set_default_mapping_data().

_default_mapping_type

ElemMappingType libMesh::MeshBase::_default_mapping_type

protectedinherited

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

Definition at line 1884 of file mesh_base.h.

Referenced by libMesh::MeshBase::default_mapping_type(), libMesh::MeshBase::locally_equals(), libMesh::MeshBase::operator=(), and libMesh::MeshBase::set_default_mapping_type().

_elem_default_orders

std::set<Order> libMesh::MeshBase::_elem_default_orders

protectedinherited

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 1984 of file mesh_base.h.

Referenced by libMesh::MeshBase::cache_elem_data(), libMesh::MeshBase::clear(), libMesh::MeshBase::copy_cached_data(), libMesh::MeshBase::copy_constraint_rows(), libMesh::MeshBase::elem_default_orders(), libMesh::MeshBase::get_info(), libMesh::MeshBase::locally_equals(), and libMesh::MeshBase::operator=().

_elem_dims

std::set<unsigned char> libMesh::MeshBase::_elem_dims

protectedinherited

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 1977 of file mesh_base.h.

Referenced by libMesh::MeshBase::cache_elem_data(), libMesh::MeshBase::clear(), libMesh::MeshBase::copy_cached_data(), libMesh::MeshBase::copy_constraint_rows(), libMesh::MeshBase::elem_dimensions(), libMesh::MeshBase::get_info(), libMesh::MeshBase::locally_equals(), libMesh::MeshBase::mesh_dimension(), libMesh::MeshBase::MeshBase(), libMesh::MeshBase::operator=(), libMesh::MeshBase::set_elem_dimensions(), and libMesh::MeshBase::set_mesh_dimension().

_elem_integer_default_values

std::vector<dof_id_type> libMesh::MeshBase::_elem_integer_default_values

protectedinherited

The array of default initialization values for integer data associated with each element in the mesh.

Definition at line 2039 of file mesh_base.h.

Referenced by add_elem(), libMesh::DistributedMesh::add_elem(), libMesh::MeshBase::add_elem_integer(), libMesh::MeshBase::add_elem_integers(), insert_elem(), libMesh::DistributedMesh::insert_elem(), libMesh::MeshBase::locally_equals(), libMesh::MeshBase::merge_extra_integer_names(), libMesh::MeshBase::operator=(), and libMesh::MeshBase::size_elem_extra_integers().

_elem_integer_names

std::vector<std::string> libMesh::MeshBase::_elem_integer_names

protectedinherited

The array of names for integer data associated with each element in the mesh.

Definition at line 2033 of file mesh_base.h.

Referenced by add_elem(), libMesh::DistributedMesh::add_elem(), libMesh::MeshBase::add_elem_data(), libMesh::MeshBase::add_elem_datum(), libMesh::MeshBase::add_elem_integer(), libMesh::MeshBase::add_elem_integers(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::MeshBase::get_elem_integer_index(), libMesh::MeshBase::get_elem_integer_name(), libMesh::MeshBase::has_elem_integer(), insert_elem(), libMesh::DistributedMesh::insert_elem(), libMesh::MeshBase::locally_equals(), libMesh::MeshBase::merge_extra_integer_names(), libMesh::MeshBase::n_elem_integers(), libMesh::MeshBase::operator=(), and libMesh::MeshBase::size_elem_extra_integers().

_elements

std::vector<Elem *> libMesh::ReplicatedMesh::_elements

The elements in the mesh.

Definition at line 336 of file replicated_mesh.h.

Referenced by add_elem(), clear_elems(), delete_elem(), elem_ptr(), fix_broken_node_and_element_numbering(), insert_elem(), max_elem_id(), move_nodes_and_elements(), query_elem_ptr(), renumber_elem(), renumber_nodes_and_elements(), and reserve_elem().

_elemset_codes

std::map<dof_id_type, const MeshBase::elemset_type *> libMesh::MeshBase::_elemset_codes

protectedinherited

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 2019 of file mesh_base.h.

Referenced by libMesh::MeshBase::add_elemset_code(), libMesh::MeshBase::change_elemset_code(), libMesh::MeshBase::change_elemset_id(), libMesh::MeshBase::clear(), libMesh::MeshBase::get_elemset_codes(), libMesh::MeshBase::get_elemsets(), libMesh::MeshBase::get_info(), libMesh::MeshBase::locally_equals(), libMesh::MeshBase::MeshBase(), and libMesh::MeshBase::operator=().

_elemset_codes_inverse_map

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

protectedinherited

Definition at line 2020 of file mesh_base.h.

Referenced by libMesh::MeshBase::add_elemset_code(), libMesh::MeshBase::change_elemset_code(), libMesh::MeshBase::change_elemset_id(), libMesh::MeshBase::clear(), libMesh::MeshBase::get_elemset_code(), libMesh::MeshBase::MeshBase(), and libMesh::MeshBase::operator=().

_ghosting_functors

std::set<GhostingFunctor *> libMesh::MeshBase::_ghosting_functors

protectedinherited

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 2086 of file mesh_base.h.

Referenced by libMesh::MeshBase::add_ghosting_functor(), libMesh::MeshBase::ghosting_functors_begin(), libMesh::MeshBase::ghosting_functors_end(), libMesh::MeshBase::locally_equals(), libMesh::MeshBase::MeshBase(), libMesh::MeshBase::post_dofobject_moves(), libMesh::MeshBase::reinit_ghosting_functors(), and libMesh::MeshBase::remove_ghosting_functor().

_interior_mesh

MeshBase* libMesh::MeshBase::_interior_mesh

protectedinherited

Defaulting to this, a pointer to the mesh used to generate boundary elements on this.

Definition at line 1932 of file mesh_base.h.

Referenced by libMesh::MeshBase::interior_mesh(), libMesh::MeshBase::locally_equals(), libMesh::MeshBase::operator=(), and libMesh::MeshBase::set_interior_mesh().

_is_prepared

bool libMesh::MeshBase::_is_prepared

protectedinherited

Flag indicating if the mesh has been prepared for use.

Definition at line 1896 of file mesh_base.h.

Referenced by libMesh::MeshBase::clear(), libMesh::DistributedMesh::DistributedMesh(), libMesh::MeshBase::is_prepared(), libMesh::MeshBase::locally_equals(), libMesh::MeshBase::operator=(), libMesh::MeshBase::prepare_for_use(), ReplicatedMesh(), and libMesh::MeshBase::set_isnt_prepared().

_mesh_subdomains

std::set<subdomain_id_type> libMesh::MeshBase::_mesh_subdomains

protectedinherited

We cache the subdomain ids of the elements present in the mesh.

Definition at line 1995 of file mesh_base.h.

Referenced by libMesh::MeshBase::cache_elem_data(), libMesh::MeshBase::copy_cached_data(), libMesh::MeshBase::copy_constraint_rows(), libMesh::MeshBase::get_mesh_subdomains(), and libMesh::MeshBase::locally_equals().

_n_elem

dof_id_type libMesh::ReplicatedMesh::_n_elem

Definition at line 338 of file replicated_mesh.h.

Referenced by add_elem(), clear_elems(), delete_elem(), insert_elem(), move_nodes_and_elements(), n_elem(), parallel_n_elem(), and subclass_locally_equals().

_n_nodes

const DofMap& dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag processor_id_type pid const DofMap& dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num DECLARE_NODE_ITERATORS (multi_evaluable_, std::vector<const DofMap *> dof_maps, dof_maps) protected dof_id_typ libMesh::ReplicatedMesh::_n_nodes)

The vertices (spatial coordinates) of the mesh.

Definition at line 321 of file replicated_mesh.h.

Referenced by add_node(), add_point(), clear(), delete_node(), insert_node(), move_nodes_and_elements(), n_nodes(), parallel_n_nodes(), renumber_nodes_and_elements(), and subclass_locally_equals().

_n_parts

unsigned int libMesh::MeshBase::_n_parts

protectedinherited

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 1878 of file mesh_base.h.

Referenced by libMesh::MeshBase::clear(), libMesh::MeshBase::locally_equals(), libMesh::MeshBase::n_partitions(), libMesh::MeshBase::operator=(), libMesh::MeshBase::recalculate_n_partitions(), and libMesh::MeshBase::set_n_partitions().

_next_unique_id

unique_id_type libMesh::MeshBase::_next_unique_id

protectedinherited

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

Definition at line 1925 of file mesh_base.h.

Referenced by add_elem(), libMesh::DistributedMesh::add_elem(), add_node(), libMesh::DistributedMesh::add_node(), add_point(), libMesh::DistributedMesh::DistributedMesh(), insert_elem(), libMesh::DistributedMesh::insert_elem(), insert_node(), libMesh::MeshBase::next_unique_id(), libMesh::MeshBase::operator=(), parallel_max_unique_id(), libMesh::DistributedMesh::parallel_max_unique_id(), ReplicatedMesh(), set_next_unique_id(), libMesh::DistributedMesh::set_next_unique_id(), subclass_locally_equals(), update_parallel_id_counts(), and libMesh::DistributedMesh::update_parallel_id_counts().

_node_integer_default_values

std::vector<dof_id_type> libMesh::MeshBase::_node_integer_default_values

protectedinherited

The array of default initialization values for integer data associated with each node in the mesh.

Definition at line 2051 of file mesh_base.h.

Referenced by add_node(), libMesh::DistributedMesh::add_node(), libMesh::MeshBase::add_node_integer(), libMesh::MeshBase::add_node_integers(), add_point(), insert_node(), libMesh::MeshBase::locally_equals(), libMesh::MeshBase::merge_extra_integer_names(), libMesh::MeshBase::operator=(), and libMesh::MeshBase::size_node_extra_integers().

_node_integer_names

std::vector<std::string> libMesh::MeshBase::_node_integer_names

protectedinherited

The array of names for integer data associated with each node in the mesh.

Definition at line 2045 of file mesh_base.h.

Referenced by add_node(), libMesh::DistributedMesh::add_node(), libMesh::MeshBase::add_node_data(), libMesh::MeshBase::add_node_datum(), libMesh::MeshBase::add_node_integer(), libMesh::MeshBase::add_node_integers(), add_point(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::UnstructuredMesh::create_submesh(), libMesh::MeshBase::get_node_integer_index(), libMesh::MeshBase::get_node_integer_name(), libMesh::MeshBase::has_node_integer(), insert_node(), libMesh::MeshBase::locally_equals(), libMesh::MeshBase::merge_extra_integer_names(), libMesh::MeshBase::n_node_integers(), libMesh::MeshBase::operator=(), and libMesh::MeshBase::size_node_extra_integers().

_partitioner

std::unique_ptr<Partitioner> libMesh::MeshBase::_partitioner

protectedinherited

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 1919 of file mesh_base.h.

Referenced by libMesh::DistributedMesh::DistributedMesh(), libMesh::MeshBase::locally_equals(), libMesh::MeshBase::MeshBase(), libMesh::MeshBase::partitioner(), libMesh::MeshBase::post_dofobject_moves(), ReplicatedMesh(), and libMesh::MeshBase::skip_noncritical_partitioning().

_point_locator

std::unique_ptr<PointLocatorBase> libMesh::MeshBase::_point_locator

mutableprotectedinherited

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 1905 of file mesh_base.h.

Referenced by libMesh::MeshBase::clear_point_locator(), libMesh::MeshBase::operator=(), libMesh::MeshBase::set_point_locator_close_to_point_tol(), and libMesh::MeshBase::sub_point_locator().

_point_locator_close_to_point_tol

Real libMesh::MeshBase::_point_locator_close_to_point_tol

protectedinherited

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

Definition at line 2110 of file mesh_base.h.

Referenced by libMesh::MeshBase::get_point_locator_close_to_point_tol(), libMesh::MeshBase::locally_equals(), libMesh::MeshBase::operator=(), libMesh::MeshBase::set_point_locator_close_to_point_tol(), and libMesh::MeshBase::sub_point_locator().

_shared_functors

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

protectedinherited

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

Definition at line 2092 of file mesh_base.h.

Referenced by libMesh::MeshBase::add_ghosting_functor(), libMesh::MeshBase::post_dofobject_moves(), and libMesh::MeshBase::remove_ghosting_functor().

_skip_all_partitioning

bool libMesh::MeshBase::_skip_all_partitioning

protectedinherited

If this is true then no partitioning should be done.

Definition at line 1943 of file mesh_base.h.

Referenced by libMesh::MeshBase::locally_equals(), libMesh::MeshBase::operator=(), libMesh::MeshBase::skip_noncritical_partitioning(), and libMesh::MeshBase::skip_partitioning().

_skip_find_neighbors

bool libMesh::MeshBase::_skip_find_neighbors

protectedinherited

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

Definition at line 1955 of file mesh_base.h.

Referenced by libMesh::MeshBase::allow_find_neighbors(), libMesh::MeshBase::locally_equals(), libMesh::MeshBase::operator=(), and libMesh::MeshBase::prepare_for_use().

_skip_noncritical_partitioning

bool libMesh::MeshBase::_skip_noncritical_partitioning

protectedinherited

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

Definition at line 1938 of file mesh_base.h.

Referenced by libMesh::MeshBase::locally_equals(), libMesh::MeshBase::operator=(), and libMesh::MeshBase::skip_noncritical_partitioning().

_skip_renumber_nodes_and_elements

bool libMesh::MeshBase::_skip_renumber_nodes_and_elements

protectedinherited

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

This is set when prepare_for_use() is called.

Definition at line 1950 of file mesh_base.h.

Referenced by libMesh::MeshBase::allow_renumbering(), libMesh::MeshBase::locally_equals(), libMesh::MeshBase::operator=(), libMesh::MeshBase::prepare_for_use(), renumber_nodes_and_elements(), and libMesh::DistributedMesh::renumber_nodes_and_elements().

_spatial_dimension

unsigned char libMesh::MeshBase::_spatial_dimension

protectedinherited

The "spatial dimension" of the Mesh.

See the documentation for Mesh::spatial_dimension() for more information.

Definition at line 2027 of file mesh_base.h.

Referenced by libMesh::MeshBase::cache_elem_data(), libMesh::MeshBase::copy_cached_data(), libMesh::MeshBase::locally_equals(), libMesh::MeshBase::operator=(), libMesh::MeshBase::set_spatial_dimension(), and libMesh::MeshBase::spatial_dimension().

_supported_nodal_order

Order libMesh::MeshBase::_supported_nodal_order

protectedinherited

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

Definition at line 1990 of file mesh_base.h.

Referenced by libMesh::MeshBase::cache_elem_data(), libMesh::MeshBase::clear(), libMesh::MeshBase::copy_cached_data(), libMesh::MeshBase::copy_constraint_rows(), libMesh::MeshBase::locally_equals(), libMesh::MeshBase::operator=(), and libMesh::MeshBase::supported_nodal_order().

boundary_info

std::unique_ptr<BoundaryInfo> libMesh::MeshBase::boundary_info

protectedinherited

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 1830 of file mesh_base.h.

Referenced by libMesh::MeshBase::clear(), libMesh::MeshBase::get_boundary_info(), libMesh::MeshBase::locally_equals(), and libMesh::MeshBase::operator=().

level [1/2]

unsigned int libMesh::ReplicatedMesh::level

Definition at line 267 of file replicated_mesh.h.

level [2/2]

processor_id_type pid unsigned int libMesh::ReplicatedMesh::level

Definition at line 286 of file replicated_mesh.h.

pid [1/2]

processor_id_type libMesh::ReplicatedMesh::pid

Definition at line 284 of file replicated_mesh.h.

pid [2/2]

const DofMap& dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag processor_id_type libMesh::ReplicatedMesh::pid

Definition at line 316 of file replicated_mesh.h.

rflag

const DofMap& dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char libMesh::ReplicatedMesh::rflag

Definition at line 306 of file replicated_mesh.h.

ss [1/2]

unsigned int level ElemType type std::set<subdomain_id_type> libMesh::ReplicatedMesh::ss

Definition at line 272 of file replicated_mesh.h.

Referenced by active_subdomain_set_elements_ptr_range(), and get_boundary_points().

ss [2/2]

processor_id_type pid unsigned int level std::set<subdomain_id_type> libMesh::ReplicatedMesh::ss

Definition at line 288 of file replicated_mesh.h.

type

unsigned int level ElemType libMesh::ReplicatedMesh::type

Definition at line 269 of file replicated_mesh.h.

var_num [1/2]

const DofMap& dof_map LIBMESH_COMMA unsigned int libMesh::ReplicatedMesh::var_num = libMesh::invalid_uint

Definition at line 302 of file replicated_mesh.h.

var_num [2/2]

const DofMap& dof_map LIBMESH_COMMA unsigned int dof_map LIBMESH_COMMA var_num unsigned char rflag processor_id_type pid const DofMap& dof_map LIBMESH_COMMA unsigned int libMesh::ReplicatedMesh::var_num = libMesh::invalid_uint

Definition at line 319 of file replicated_mesh.h.

---

The documentation for this class was generated from the following files:

• include/mesh/replicated_mesh.h
• src/mesh/replicated_mesh.C