libMesh::DistributedMesh Class Reference

The DistributedMesh class is derived from the MeshBase class, and is intended to provide identical functionality to the user but be distributed rather than replicated across distributed-memory systems. More...

#include <distributed_mesh.h>

Inheritance diagram for libMesh::DistributedMesh:

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

Public Member Functions
	DistributedMesh (const Parallel::Communicator &comm_in, unsigned char dim=1)
	Constructor. More...
	DistributedMesh (const UnstructuredMesh &other_mesh)
	Copy-constructor. More...
	DistributedMesh (const DistributedMesh &other_mesh)
	Copy-constructor, possibly specialized for a distributed mesh. More...
	DistributedMesh (DistributedMesh &&)=default
	Move-constructor. More...
DistributedMesh &	operator= (const DistributedMesh &)=delete
	Copy and move assignment are not allowed. More...
DistributedMesh &	operator= (DistributedMesh &&)=delete
virtual std::unique_ptr< MeshBase >	clone () const override
	Virtual copy-constructor, creates a copy of this mesh. More...
virtual	~DistributedMesh ()
	Destructor. More...
virtual void	clear () override
	Clear all internal data. More...
virtual void	redistribute () override
	Redistribute elements between processors. More...
virtual void	update_post_partitioning () override
	Recalculate cached data after elements and nodes have been repartitioned. More...
virtual bool	is_serial () const override
virtual bool	is_serial_on_zero () const override
virtual void	set_distributed () override
	Asserts that not all elements and nodes of the mesh necessarily exist on the current processor. More...
virtual bool	is_replicated () const override
template<typename T >
void	libmesh_assert_valid_parallel_object_ids (const mapvector< T *, dof_id_type > &) const
	Verify id, processor_id, and if applicable unique_id consistency of a parallel objects container. More...
virtual void	libmesh_assert_valid_parallel_ids () const override
	Verify id and processor_id consistency of our elements and nodes containers. More...
void	libmesh_assert_valid_parallel_p_levels () const
	Verify p_level consistency of our elements containers. More...
void	libmesh_assert_valid_parallel_flags () const
	Verify refinement_flag and p_refinement_flag consistency of our elements containers. More...
template<typename T >
dof_id_type	renumber_dof_objects (mapvector< T *, dof_id_type > &)
	Renumber a parallel objects container. More...
virtual void	renumber_nodes_and_elements () override
	Remove nullptr elements from arrays. More...
virtual void	allgather () override
	Gathers all elements and nodes of the mesh onto every processor. More...
virtual void	gather_to_zero () override
	Gathers all elements and nodes of the mesh onto processor zero. More...
virtual void	delete_remote_elements () override
	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...
virtual void	add_extra_ghost_elem (Elem *e)
	Inserts the element and adds it to a list of elements that should not get deleted or have their descendants deleted by delete_remote_elements. More...
virtual void	clear_extra_ghost_elems ()
	Clears extra ghost elements. More...
virtual void	clear_extra_ghost_elems (const std::set< Elem * > &extra_ghost_elems)
	Clears specified extra ghost elements. More...
const std::set< Elem * > &	extra_ghost_elems () const
	Const accessor to the ghosted elements. More...
virtual dof_id_type	n_nodes () const override
virtual dof_id_type	max_node_id () const override
virtual void	reserve_nodes (const dof_id_type) override
	Reserves space for a known number of nodes. More...
virtual dof_id_type	n_elem () const override
virtual dof_id_type	n_active_elem () const override
virtual dof_id_type	max_elem_id () const override
virtual void	reserve_elem (const dof_id_type) override
	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 dof_id_type	parallel_n_nodes () const override
dof_id_type	parallel_max_node_id () const
virtual dof_id_type	parallel_n_elem () const override
dof_id_type	parallel_max_elem_id () const
virtual unique_id_type	parallel_max_unique_id () const override
virtual const Point &	point (const dof_id_type i) const override
virtual const Node *	node_ptr (const dof_id_type i) const override
virtual Node *	node_ptr (const dof_id_type i) override
virtual const Node *	query_node_ptr (const dof_id_type i) const override
virtual Node *	query_node_ptr (const dof_id_type i) override
virtual const Elem *	elem_ptr (const dof_id_type i) const override
virtual Elem *	elem_ptr (const dof_id_type i) override
virtual const Elem *	query_elem_ptr (const dof_id_type i) const override
virtual Elem *	query_elem_ptr (const dof_id_type i) override
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
	functions for adding /deleting nodes elements. More...
virtual Node *	add_node (Node *n) override
	Add Node n to the end of the vertex array. More...
virtual Node *	insert_node (Node *n) override
	Calls add_node(). More...
virtual void	own_node (Node &n) override
	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...
virtual void	delete_node (Node *n) override
	Removes the Node n from the mesh. More...
virtual void	renumber_node (dof_id_type old_id, dof_id_type new_id) override
	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
	Add elem e to the end of the element array. More...
virtual Elem *	insert_elem (Elem *e) override
	Insert elem e to the element array, preserving its id and replacing/deleting any existing element with the same id. More...
virtual void	delete_elem (Elem *e) override
	Removes element e from the mesh. More...
virtual void	renumber_elem (dof_id_type old_id, dof_id_type new_id) override
	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...
virtual element_iterator	elements_begin () override
	Elem iterator accessor functions. More...
virtual element_iterator	elements_end () override
virtual const_element_iterator	elements_begin () const override
virtual const_element_iterator	elements_end () const override
virtual SimpleRange< element_iterator >	element_ptr_range () override
virtual SimpleRange< const_element_iterator >	element_ptr_range () const override
virtual element_iterator	active_elements_begin () override
	Active, local, and negation forms of the element iterators described above. More...
virtual element_iterator	active_elements_end () override
virtual const_element_iterator	active_elements_begin () const override
virtual const_element_iterator	active_elements_end () const override
virtual SimpleRange< element_iterator >	active_element_ptr_range () override
virtual SimpleRange< const_element_iterator >	active_element_ptr_range () const override
virtual element_iterator	ancestor_elements_begin () override
	Iterate over elements for which elem->ancestor() is true. More...
virtual element_iterator	ancestor_elements_end () override
virtual const_element_iterator	ancestor_elements_begin () const override
virtual const_element_iterator	ancestor_elements_end () const override
virtual element_iterator	subactive_elements_begin () override
	Iterate over elements for which elem->subactive() is true. More...
virtual element_iterator	subactive_elements_end () override
virtual const_element_iterator	subactive_elements_begin () const override
virtual const_element_iterator	subactive_elements_end () const override
virtual element_iterator	not_active_elements_begin () override
virtual element_iterator	not_active_elements_end () override
virtual const_element_iterator	not_active_elements_begin () const override
virtual const_element_iterator	not_active_elements_end () const override
virtual element_iterator	not_ancestor_elements_begin () override
virtual element_iterator	not_ancestor_elements_end () override
virtual const_element_iterator	not_ancestor_elements_begin () const override
virtual const_element_iterator	not_ancestor_elements_end () const override
virtual element_iterator	not_subactive_elements_begin () override
virtual element_iterator	not_subactive_elements_end () override
virtual const_element_iterator	not_subactive_elements_begin () const override
virtual const_element_iterator	not_subactive_elements_end () const override
virtual element_iterator	local_elements_begin () override
virtual element_iterator	local_elements_end () override
virtual const_element_iterator	local_elements_begin () const override
virtual const_element_iterator	local_elements_end () const override
virtual element_iterator	semilocal_elements_begin () override
	Iterate over elements for which elem->is_semilocal() is true for the current processor. More...
virtual element_iterator	semilocal_elements_end () override
virtual const_element_iterator	semilocal_elements_begin () const override
virtual const_element_iterator	semilocal_elements_end () const override
virtual element_iterator	active_semilocal_elements_begin () override
virtual element_iterator	active_semilocal_elements_end () override
virtual const_element_iterator	active_semilocal_elements_begin () const override
virtual const_element_iterator	active_semilocal_elements_end () const override
virtual element_iterator	facelocal_elements_begin () override
	Iterate over elements which are on or have a neighbor on the current processor. More...
virtual element_iterator	facelocal_elements_end () override
virtual const_element_iterator	facelocal_elements_begin () const override
virtual const_element_iterator	facelocal_elements_end () const override
virtual element_iterator	not_local_elements_begin () override
virtual element_iterator	not_local_elements_end () override
virtual const_element_iterator	not_local_elements_begin () const override
virtual const_element_iterator	not_local_elements_end () const override
virtual element_iterator	active_local_elements_begin () override
virtual element_iterator	active_local_elements_end () override
virtual const_element_iterator	active_local_elements_begin () const override
virtual const_element_iterator	active_local_elements_end () const override
virtual SimpleRange< element_iterator >	active_local_element_ptr_range () override
virtual SimpleRange< const_element_iterator >	active_local_element_ptr_range () const override
virtual element_iterator	active_not_local_elements_begin () override
virtual element_iterator	active_not_local_elements_end () override
virtual const_element_iterator	active_not_local_elements_begin () const override
virtual const_element_iterator	active_not_local_elements_end () const override
virtual element_iterator	level_elements_begin (unsigned int level) override
	Iterate over elements of a given level. More...
virtual element_iterator	level_elements_end (unsigned int level) override
virtual const_element_iterator	level_elements_begin (unsigned int level) const override
virtual const_element_iterator	level_elements_end (unsigned int level) const override
virtual element_iterator	not_level_elements_begin (unsigned int level) override
virtual element_iterator	not_level_elements_end (unsigned int level) override
virtual const_element_iterator	not_level_elements_begin (unsigned int level) const override
virtual const_element_iterator	not_level_elements_end (unsigned int level) const override
virtual element_iterator	local_level_elements_begin (unsigned int level) override
virtual element_iterator	local_level_elements_end (unsigned int level) override
virtual const_element_iterator	local_level_elements_begin (unsigned int level) const override
virtual const_element_iterator	local_level_elements_end (unsigned int level) const override
virtual element_iterator	local_not_level_elements_begin (unsigned int level) override
virtual element_iterator	local_not_level_elements_end (unsigned int level) override
virtual const_element_iterator	local_not_level_elements_begin (unsigned int level) const override
virtual const_element_iterator	local_not_level_elements_end (unsigned int level) const override
virtual element_iterator	pid_elements_begin (processor_id_type proc_id) override
	Iterate over all elements with a specified processor id. More...
virtual element_iterator	pid_elements_end (processor_id_type proc_id) override
virtual const_element_iterator	pid_elements_begin (processor_id_type proc_id) const override
virtual const_element_iterator	pid_elements_end (processor_id_type proc_id) const override
virtual element_iterator	type_elements_begin (ElemType type) override
	Iterate over all elements with a specified geometric type. More...
virtual element_iterator	type_elements_end (ElemType type) override
virtual const_element_iterator	type_elements_begin (ElemType type) const override
virtual const_element_iterator	type_elements_end (ElemType type) const override
virtual element_iterator	active_type_elements_begin (ElemType type) override
virtual element_iterator	active_type_elements_end (ElemType type) override
virtual const_element_iterator	active_type_elements_begin (ElemType type) const override
virtual const_element_iterator	active_type_elements_end (ElemType type) const override
virtual element_iterator	active_pid_elements_begin (processor_id_type proc_id) override
virtual element_iterator	active_pid_elements_end (processor_id_type proc_id) override
virtual const_element_iterator	active_pid_elements_begin (processor_id_type proc_id) const override
virtual const_element_iterator	active_pid_elements_end (processor_id_type proc_id) const override
virtual element_iterator	unpartitioned_elements_begin () override
	Iterate over unpartitioned elements in the Mesh. More...
virtual element_iterator	unpartitioned_elements_end () override
virtual const_element_iterator	unpartitioned_elements_begin () const override
virtual const_element_iterator	unpartitioned_elements_end () const override
virtual element_iterator	active_unpartitioned_elements_begin () override
	Iterate over active unpartitioned elements in the Mesh. More...
virtual element_iterator	active_unpartitioned_elements_end () override
virtual const_element_iterator	active_unpartitioned_elements_begin () const override
virtual const_element_iterator	active_unpartitioned_elements_end () const override
virtual element_iterator	active_local_subdomain_elements_begin (subdomain_id_type subdomain_id) override
virtual element_iterator	active_local_subdomain_elements_end (subdomain_id_type subdomain_id) override
virtual const_element_iterator	active_local_subdomain_elements_begin (subdomain_id_type subdomain_id) const override
virtual const_element_iterator	active_local_subdomain_elements_end (subdomain_id_type subdomain_id) const override
virtual SimpleRange< element_iterator >	active_local_subdomain_elements_ptr_range (subdomain_id_type subdomain_id) override
virtual SimpleRange< const_element_iterator >	active_local_subdomain_elements_ptr_range (subdomain_id_type subdomain_id) const override
virtual element_iterator	active_subdomain_elements_begin (subdomain_id_type subdomain_id) override
virtual element_iterator	active_subdomain_elements_end (subdomain_id_type subdomain_id) override
virtual const_element_iterator	active_subdomain_elements_begin (subdomain_id_type subdomain_id) const override
virtual const_element_iterator	active_subdomain_elements_end (subdomain_id_type subdomain_id) const override
virtual SimpleRange< element_iterator >	active_subdomain_elements_ptr_range (subdomain_id_type subdomain_id) override
virtual SimpleRange< const_element_iterator >	active_subdomain_elements_ptr_range (subdomain_id_type subdomain_id) const override
virtual element_iterator	active_subdomain_set_elements_begin (std::set< subdomain_id_type > ss) override
virtual element_iterator	active_subdomain_set_elements_end (std::set< subdomain_id_type > ss) override
virtual const_element_iterator	active_subdomain_set_elements_begin (std::set< subdomain_id_type > ss) const override
virtual const_element_iterator	active_subdomain_set_elements_end (std::set< subdomain_id_type > ss) const override
virtual SimpleRange< element_iterator >	active_subdomain_set_elements_ptr_range (std::set< subdomain_id_type > ss) override
virtual SimpleRange< const_element_iterator >	active_subdomain_set_elements_ptr_range (std::set< subdomain_id_type > ss) const override
virtual element_iterator	ghost_elements_begin () override
	Iterate over "ghost" elements in the Mesh. More...
virtual element_iterator	ghost_elements_end () override
virtual const_element_iterator	ghost_elements_begin () const override
virtual const_element_iterator	ghost_elements_end () const override
virtual element_iterator	evaluable_elements_begin (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint) override
	Iterate over elements in the Mesh where the solution (as distributed by the given DofMap) can be evaluated, for the given variable var_num, or for all variables by default. More...
virtual element_iterator	evaluable_elements_end (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint) override
virtual const_element_iterator	evaluable_elements_begin (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint) const override
virtual const_element_iterator	evaluable_elements_end (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint) const override
virtual element_iterator	flagged_elements_begin (unsigned char rflag) override
	Iterate over all elements with a specified refinement flag. More...
virtual element_iterator	flagged_elements_end (unsigned char rflag) override
virtual const_element_iterator	flagged_elements_begin (unsigned char rflag) const override
virtual const_element_iterator	flagged_elements_end (unsigned char rflag) const override
virtual element_iterator	flagged_pid_elements_begin (unsigned char rflag, processor_id_type pid) override
	Iterate over all elements with a specified refinement flag on a specified processor. More...
virtual element_iterator	flagged_pid_elements_end (unsigned char rflag, processor_id_type pid) override
virtual const_element_iterator	flagged_pid_elements_begin (unsigned char rflag, processor_id_type pid) const override
virtual const_element_iterator	flagged_pid_elements_end (unsigned char rflag, processor_id_type pid) const override
virtual node_iterator	nodes_begin () override
	Node iterator accessor functions. More...
virtual node_iterator	nodes_end () override
virtual const_node_iterator	nodes_begin () const override
virtual const_node_iterator	nodes_end () const override
virtual SimpleRange< node_iterator >	node_ptr_range () override
virtual SimpleRange< const_node_iterator >	node_ptr_range () const override
virtual node_iterator	active_nodes_begin () override
	Iterate over only the active nodes in the Mesh. More...
virtual node_iterator	active_nodes_end () override
virtual const_node_iterator	active_nodes_begin () const override
virtual const_node_iterator	active_nodes_end () const override
virtual node_iterator	local_nodes_begin () override
	Iterate over local nodes (nodes whose processor_id() matches the current processor). More...
virtual node_iterator	local_nodes_end () override
virtual const_node_iterator	local_nodes_begin () const override
virtual const_node_iterator	local_nodes_end () const override
virtual SimpleRange< node_iterator >	local_node_ptr_range () override
virtual SimpleRange< const_node_iterator >	local_node_ptr_range () const override
virtual node_iterator	pid_nodes_begin (processor_id_type proc_id) override
	Iterate over nodes with processor_id() == proc_id. More...
virtual node_iterator	pid_nodes_end (processor_id_type proc_id) override
virtual const_node_iterator	pid_nodes_begin (processor_id_type proc_id) const override
virtual const_node_iterator	pid_nodes_end (processor_id_type proc_id) const override
virtual node_iterator	bid_nodes_begin (boundary_id_type bndry_id) override
	Iterate over nodes for which BoundaryInfo::has_boundary_id(node, bndry_id) is true. More...
virtual node_iterator	bid_nodes_end (boundary_id_type bndry_id) override
virtual const_node_iterator	bid_nodes_begin (boundary_id_type bndry_id) const override
virtual const_node_iterator	bid_nodes_end (boundary_id_type bndry_id) const override
virtual node_iterator	bnd_nodes_begin () override
	Iterate over nodes for which BoundaryInfo::n_boundary_ids(node) > 0. More...
virtual node_iterator	bnd_nodes_end () override
virtual const_node_iterator	bnd_nodes_begin () const override
virtual const_node_iterator	bnd_nodes_end () const override
virtual node_iterator	evaluable_nodes_begin (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint) override
	Iterate over nodes in the Mesh where the solution (as distributed by the given DofMap) can be evaluated, for the given variable var_num, or for all variables by default. More...
virtual node_iterator	evaluable_nodes_end (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint) override
virtual const_node_iterator	evaluable_nodes_begin (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint) const override
virtual const_node_iterator	evaluable_nodes_end (const DofMap &dof_map, unsigned int var_num=libMesh::invalid_uint) const override
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) 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)
	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 (const bool full_ordered=true) override
	Converts a (conforming, non-refined) mesh with linear elements into a mesh with second-order elements. 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...
virtual void	copy_nodes_and_elements (const UnstructuredMesh &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)
	Deep copy of nodes and elements from another unstructured mesh class (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...
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
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
void	set_elem_dimensions (const 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_dims(), therefore only call this if you know what you're doing. 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 ()
void	set_next_unique_id (unique_id_type id)
	Sets the next unique id to be used. More...
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 Node &	node (const dof_id_type i) const
virtual Node &	node (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 const Elem *	elem (const dof_id_type i) const
virtual Elem *	elem (const dof_id_type i)
virtual const Elem *	query_elem (const dof_id_type i) const
virtual Elem *	query_elem (const dof_id_type i)
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...
unsigned int	add_elem_integer (const std::string &name, bool allocate_data=true)
	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)
	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 (const std::string &name) const
bool	has_elem_integer (const std::string &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)
	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)
	Register data (of type T) to be added to each element in the mesh. More...
unsigned int	add_node_integer (const std::string &name, bool allocate_data=true)
	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)
	Register integer data (of type dof_id_type) to be added to each node in the mesh. More...
unsigned int	get_node_integer_index (const std::string &name) const
bool	has_node_integer (const std::string &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)
	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)
	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=false, const bool skip_find_neighbors=false)
	Prepare a newly ecreated (or read) mesh for use. More...
virtual void	partition (const unsigned int n_parts)
	Call the default partitioner (currently metis_partition()). More...
void	partition ()
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_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
	Constructs a list of all subdomain identifiers in the global mesh. More...
subdomain_id_type	n_subdomains () const
unsigned int	n_partitions () const
std::string	get_info () const
void	print_info (std::ostream &os=libMesh::out) const
	Prints relevant information about 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...
const PointLocatorBase &	point_locator () const
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...
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 (const std::string &name) const
std::map< subdomain_id_type, std::string > &	set_subdomain_name_map ()
const std::map< subdomain_id_type, std::string > &	get_subdomain_name_map () const
void	cache_elem_dims ()
	Search the mesh and cache the different dimensions of the elements present in the mesh. More...
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 Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const

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

Protected Member Functions
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
mapvector< Node *, dof_id_type >	_nodes
	The vertices (spatial coordinates) of the mesh. More...
mapvector< Elem *, dof_id_type >	_elements
	The elements in the mesh. More...
bool	_is_serial
	A boolean remembering whether we're serialized or not. More...
bool	_is_serial_on_proc_0
	A boolean remembering whether we're serialized to proc 0 or not. More...
dof_id_type	_n_nodes
	Cached data from the last renumber_nodes_and_elements call. More...
dof_id_type	_n_elem
dof_id_type	_max_node_id
dof_id_type	_max_elem_id
dof_id_type	_next_free_local_node_id
	Guaranteed globally unused IDs for use when adding new nodes or elements. More...
dof_id_type	_next_free_local_elem_id
dof_id_type	_next_free_unpartitioned_node_id
dof_id_type	_next_free_unpartitioned_elem_id
unique_id_type	_next_unpartitioned_unique_id
	The next available unique id for assigning ids to unpartitioned DOF objects. More...
std::set< Elem * >	_extra_ghost_elems
	These are extra ghost elements that we want to make sure not to delete when we call delete_remote_elements() 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...
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	_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...
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< std::string >	_node_integer_names
	The array of names 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...
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 mapvector< Elem *, dof_id_type >::veclike_iterator	elem_iterator_imp
	Typedefs for the container implementation. More...
typedef mapvector< Elem *, dof_id_type >::const_veclike_iterator	const_elem_iterator_imp
typedef mapvector< Node *, dof_id_type >::veclike_iterator	node_iterator_imp
	Typedefs for the container implementation. More...
typedef mapvector< Node *, dof_id_type >::const_veclike_iterator	const_node_iterator_imp

Detailed Description

The DistributedMesh class is derived from the MeshBase class, and is intended to provide identical functionality to the user but be distributed rather than replicated across distributed-memory systems.

Author

Roy Stogner

Date

2007

Mesh data structure which is distributed across all processors.

Definition at line 50 of file distributed_mesh.h.

Member Typedef Documentation

const_elem_iterator_imp

typedef mapvector<Elem *, dof_id_type>::const_veclike_iterator libMesh::DistributedMesh::const_elem_iterator_imp

private

Definition at line 601 of file distributed_mesh.h.

const_node_iterator_imp

typedef mapvector<Node *, dof_id_type>::const_veclike_iterator libMesh::DistributedMesh::const_node_iterator_imp

private

Definition at line 608 of file distributed_mesh.h.

elem_iterator_imp

typedef mapvector<Elem *, dof_id_type>::veclike_iterator libMesh::DistributedMesh::elem_iterator_imp

private

Typedefs for the container implementation.

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

Definition at line 600 of file distributed_mesh.h.

node_iterator_imp

typedef mapvector<Node *, dof_id_type>::veclike_iterator libMesh::DistributedMesh::node_iterator_imp

private

Typedefs for the container implementation.

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

Definition at line 607 of file distributed_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 1209 of file mesh_base.h.

Constructor & Destructor Documentation

DistributedMesh() [1/4]

libMesh::DistributedMesh::DistributedMesh ( 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 40 of file distributed_mesh.C.

                                                   :
  UnstructuredMesh (comm_in,d), _is_serial(true),
  _is_serial_on_proc_0(true),
  _n_nodes(0), _n_elem(0), _max_node_id(0), _max_elem_id(0),
  _next_free_local_node_id(this->processor_id()),
  _next_free_local_elem_id(this->processor_id()),
  _next_free_unpartitioned_node_id(this->n_processors()),
  _next_free_unpartitioned_elem_id(this->n_processors())
#ifdef LIBMESH_ENABLE_UNIQUE_ID
  , _next_unpartitioned_unique_id(this->n_processors())
#endif
{
#ifdef LIBMESH_ENABLE_UNIQUE_ID
  _next_unique_id = this->processor_id();
#endif
 
  // FIXME: give parmetis the communicator!
  _partitioner = libmesh_make_unique<ParmetisPartitioner>();
}
 
 
 
DistributedMesh::~DistributedMesh ()
{
  this->clear();  // Free nodes and elements
}

References libMesh::MeshBase::_next_unique_id, libMesh::MeshBase::_partitioner, and libMesh::ParallelObject::processor_id().

DistributedMesh() [2/4]

libMesh::DistributedMesh::DistributedMesh

(

const UnstructuredMesh &

other_mesh

)

Copy-constructor.

This should be able to take a replicated or distributed mesh.

Definition at line 132 of file distributed_mesh.C.

                                                                     :
  UnstructuredMesh (other_mesh), _is_serial(other_mesh.is_serial()),
  _is_serial_on_proc_0(other_mesh.is_serial()),
  _n_nodes(0), _n_elem(0), _max_node_id(0), _max_elem_id(0),
  _next_free_local_node_id(this->processor_id()),
  _next_free_local_elem_id(this->processor_id()),
  _next_free_unpartitioned_node_id(this->n_processors()),
  _next_free_unpartitioned_elem_id(this->n_processors())
{
  this->copy_nodes_and_elements(other_mesh, true);
 
  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();
 
  // Use the first BoundaryInfo object to build the list of side boundary ids
  std::vector<boundary_id_type> side_boundaries;
  other_boundary_info.build_side_boundary_ids(side_boundaries);
 
  // Assign those boundary ids in our BoundaryInfo object
  for (const auto & side_bnd_id : side_boundaries)
    this_boundary_info.sideset_name(side_bnd_id) =
      other_boundary_info.get_sideset_name(side_bnd_id);
 
  // Do the same thing for node boundary ids
  std::vector<boundary_id_type> node_boundaries;
  other_boundary_info.build_node_boundary_ids(node_boundaries);
 
  for (const auto & node_bnd_id : node_boundaries)
    this_boundary_info.nodeset_name(node_bnd_id) =
      other_boundary_info.get_nodeset_name(node_bnd_id);
 
#ifdef LIBMESH_ENABLE_UNIQUE_ID
  _next_unique_id = other_mesh.parallel_max_unique_id();
#endif
  this->update_parallel_id_counts();
}

References libMesh::MeshBase::_next_unique_id, libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::MeshBase::get_boundary_info(), libMesh::MeshBase::get_subdomain_name_map(), libMesh::MeshBase::parallel_max_unique_id(), libMesh::MeshBase::set_subdomain_name_map(), and update_parallel_id_counts().

DistributedMesh() [3/4]

libMesh::DistributedMesh::DistributedMesh

(

const DistributedMesh &

other_mesh

)

Copy-constructor, possibly specialized for a distributed mesh.

Definition at line 72 of file distributed_mesh.C.

                                                                    :
  UnstructuredMesh (other_mesh), _is_serial(other_mesh._is_serial),
  _is_serial_on_proc_0(other_mesh._is_serial_on_proc_0),
  _n_nodes(0), _n_elem(0), _max_node_id(0), _max_elem_id(0),
  _next_free_local_node_id(this->processor_id()),
  _next_free_local_elem_id(this->processor_id()),
  _next_free_unpartitioned_node_id(this->n_processors()),
  _next_free_unpartitioned_elem_id(this->n_processors())
{
  this->copy_nodes_and_elements(other_mesh, true);
  _n_nodes = other_mesh.n_nodes();
  _n_elem  = other_mesh.n_elem();
  _max_node_id = other_mesh.max_node_id();
  _max_elem_id = other_mesh.max_elem_id();
  _next_free_local_node_id =
    other_mesh._next_free_local_node_id;
  _next_free_local_elem_id =
    other_mesh._next_free_local_elem_id;
  _next_free_unpartitioned_node_id =
    other_mesh._next_free_unpartitioned_node_id;
  _next_free_unpartitioned_elem_id =
    other_mesh._next_free_unpartitioned_elem_id;
#ifdef LIBMESH_ENABLE_UNIQUE_ID
  _next_unique_id =
    other_mesh._next_unique_id;
  _next_unpartitioned_unique_id =
    other_mesh._next_unpartitioned_unique_id;
#endif
 
  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();
 
  // Use the first BoundaryInfo object to build the list of side boundary ids
  std::vector<boundary_id_type> side_boundaries;
  other_boundary_info.build_side_boundary_ids(side_boundaries);
 
  // Assign those boundary ids in our BoundaryInfo object
  for (const auto & side_bnd_id : side_boundaries)
    this_boundary_info.sideset_name(side_bnd_id) =
      other_boundary_info.get_sideset_name(side_bnd_id);
 
  // Do the same thing for node boundary ids
  std::vector<boundary_id_type> node_boundaries;
  other_boundary_info.build_node_boundary_ids(node_boundaries);
 
  for (const auto & node_bnd_id : node_boundaries)
    this_boundary_info.nodeset_name(node_bnd_id) =
      other_boundary_info.get_nodeset_name(node_bnd_id);
 
  // Need to copy extra_ghost_elems
  for (auto & elem : other_mesh._extra_ghost_elems)
    _extra_ghost_elems.insert(this->elem_ptr(elem->id()));
}

References _extra_ghost_elems, _max_elem_id, _max_node_id, _n_elem, _n_nodes, _next_free_local_elem_id, _next_free_local_node_id, _next_free_unpartitioned_elem_id, _next_free_unpartitioned_node_id, libMesh::MeshBase::_next_unique_id, _next_unpartitioned_unique_id, libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::MeshBase::elem(), elem_ptr(), libMesh::MeshBase::get_boundary_info(), libMesh::MeshBase::get_subdomain_name_map(), libMesh::DofObject::id(), max_elem_id(), max_node_id(), n_elem(), n_nodes(), and libMesh::MeshBase::set_subdomain_name_map().

DistributedMesh() [4/4]

libMesh::DistributedMesh::DistributedMesh ( DistributedMesh &&  )

default

Move-constructor.

~DistributedMesh()

virtual libMesh::DistributedMesh::~DistributedMesh ( )

virtual

Destructor.

Member Function Documentation

active_element_ptr_range() [1/2]

virtual SimpleRange<const_element_iterator> libMesh::DistributedMesh::active_element_ptr_range ( ) const

inlineoverridevirtual

Implements libMesh::MeshBase.

Definition at line 316 of file distributed_mesh.h.

{ return {active_elements_begin(), active_elements_end()}; }

References active_elements_begin(), and active_elements_end().

active_element_ptr_range() [2/2]

virtual SimpleRange<element_iterator> libMesh::DistributedMesh::active_element_ptr_range ( )

inlineoverridevirtual

Implements libMesh::MeshBase.

Definition at line 315 of file distributed_mesh.h.

{ return {active_elements_begin(), active_elements_end()}; }

References active_elements_begin(), and active_elements_end().

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

active_elements_begin() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::active_elements_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

active_elements_begin() [2/2]

virtual element_iterator libMesh::DistributedMesh::active_elements_begin ( )

overridevirtual

Active, local, and negation forms of the element iterators described above.

An "active" element is an element without children (i.e. has not been refined). A "local" element is one whose processor_id() matches the current processor.

Implements libMesh::MeshBase.

Referenced by active_element_ptr_range().

active_elements_end() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::active_elements_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

active_elements_end() [2/2]

virtual element_iterator libMesh::DistributedMesh::active_elements_end ( )

overridevirtual

Implements libMesh::MeshBase.

Referenced by active_element_ptr_range().

active_local_element_ptr_range() [1/2]

virtual SimpleRange<const_element_iterator> libMesh::DistributedMesh::active_local_element_ptr_range ( ) const

inlineoverridevirtual

Implements libMesh::MeshBase.

Definition at line 373 of file distributed_mesh.h.

{ return {active_local_elements_begin(), active_local_elements_end()}; }

References active_local_elements_begin(), and active_local_elements_end().

active_local_element_ptr_range() [2/2]

virtual SimpleRange<element_iterator> libMesh::DistributedMesh::active_local_element_ptr_range ( )

inlineoverridevirtual

Implements libMesh::MeshBase.

Definition at line 372 of file distributed_mesh.h.

{ return {active_local_elements_begin(), active_local_elements_end()}; }

References active_local_elements_begin(), and active_local_elements_end().

Referenced by RationalMapTest< elem_type >::setUp(), FETest< order, family, elem_type >::setUp(), ElemTest< elem_type >::test_bounding_box(), and SlitMeshRefinedSystemTest::testRestart().

active_local_elements_begin() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::active_local_elements_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

active_local_elements_begin() [2/2]

virtual element_iterator libMesh::DistributedMesh::active_local_elements_begin ( )

overridevirtual

Implements libMesh::MeshBase.

Referenced by active_local_element_ptr_range(), main(), and n_active_elem().

active_local_elements_end() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::active_local_elements_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

active_local_elements_end() [2/2]

virtual element_iterator libMesh::DistributedMesh::active_local_elements_end ( )

overridevirtual

Implements libMesh::MeshBase.

Referenced by active_local_element_ptr_range(), and n_active_elem().

active_local_subdomain_elements_begin() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::active_local_subdomain_elements_begin ( subdomain_id_type  subdomain_id ) const

overridevirtual

Implements libMesh::MeshBase.

active_local_subdomain_elements_begin() [2/2]

virtual element_iterator libMesh::DistributedMesh::active_local_subdomain_elements_begin ( subdomain_id_type  subdomain_id )

overridevirtual

Implements libMesh::MeshBase.

Referenced by active_local_subdomain_elements_ptr_range().

active_local_subdomain_elements_end() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::active_local_subdomain_elements_end ( subdomain_id_type  subdomain_id ) const

overridevirtual

Implements libMesh::MeshBase.

active_local_subdomain_elements_end() [2/2]

virtual element_iterator libMesh::DistributedMesh::active_local_subdomain_elements_end ( subdomain_id_type  subdomain_id )

overridevirtual

Implements libMesh::MeshBase.

Referenced by active_local_subdomain_elements_ptr_range().

active_local_subdomain_elements_ptr_range() [1/2]

virtual SimpleRange<const_element_iterator> libMesh::DistributedMesh::active_local_subdomain_elements_ptr_range ( subdomain_id_type  subdomain_id ) const

inlineoverridevirtual

Implements libMesh::MeshBase.

Definition at line 436 of file distributed_mesh.h.

  { return {active_local_subdomain_elements_begin(subdomain_id), active_local_subdomain_elements_end(subdomain_id)}; }

References active_local_subdomain_elements_begin(), and active_local_subdomain_elements_end().

active_local_subdomain_elements_ptr_range() [2/2]

virtual SimpleRange<element_iterator> libMesh::DistributedMesh::active_local_subdomain_elements_ptr_range ( subdomain_id_type  subdomain_id )

inlineoverridevirtual

Implements libMesh::MeshBase.

Definition at line 434 of file distributed_mesh.h.

  { return {active_local_subdomain_elements_begin(subdomain_id), active_local_subdomain_elements_end(subdomain_id)}; }

References active_local_subdomain_elements_begin(), and active_local_subdomain_elements_end().

active_nodes_begin() [1/2]

virtual const_node_iterator libMesh::DistributedMesh::active_nodes_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

active_nodes_begin() [2/2]

virtual node_iterator libMesh::DistributedMesh::active_nodes_begin ( )

overridevirtual

Iterate over only the active nodes in the Mesh.

Implements libMesh::MeshBase.

active_nodes_end() [1/2]

virtual const_node_iterator libMesh::DistributedMesh::active_nodes_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

active_nodes_end() [2/2]

virtual node_iterator libMesh::DistributedMesh::active_nodes_end ( )

overridevirtual

Implements libMesh::MeshBase.

active_not_local_elements_begin() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::active_not_local_elements_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

active_not_local_elements_begin() [2/2]

virtual element_iterator libMesh::DistributedMesh::active_not_local_elements_begin ( )

overridevirtual

Implements libMesh::MeshBase.

active_not_local_elements_end() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::active_not_local_elements_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

active_not_local_elements_end() [2/2]

virtual element_iterator libMesh::DistributedMesh::active_not_local_elements_end ( )

overridevirtual

Implements libMesh::MeshBase.

active_pid_elements_begin() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::active_pid_elements_begin ( processor_id_type  proc_id ) const

overridevirtual

Implements libMesh::MeshBase.

active_pid_elements_begin() [2/2]

virtual element_iterator libMesh::DistributedMesh::active_pid_elements_begin ( processor_id_type  proc_id )

overridevirtual

Implements libMesh::MeshBase.

Referenced by n_active_elem().

active_pid_elements_end() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::active_pid_elements_end ( processor_id_type  proc_id ) const

overridevirtual

Implements libMesh::MeshBase.

active_pid_elements_end() [2/2]

virtual element_iterator libMesh::DistributedMesh::active_pid_elements_end ( processor_id_type  proc_id )

overridevirtual

Implements libMesh::MeshBase.

Referenced by n_active_elem().

active_semilocal_elements_begin() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::active_semilocal_elements_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

active_semilocal_elements_begin() [2/2]

virtual element_iterator libMesh::DistributedMesh::active_semilocal_elements_begin ( )

overridevirtual

Implements libMesh::MeshBase.

active_semilocal_elements_end() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::active_semilocal_elements_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

active_semilocal_elements_end() [2/2]

virtual element_iterator libMesh::DistributedMesh::active_semilocal_elements_end ( )

overridevirtual

Implements libMesh::MeshBase.

active_subdomain_elements_begin() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::active_subdomain_elements_begin ( subdomain_id_type  subdomain_id ) const

overridevirtual

Implements libMesh::MeshBase.

active_subdomain_elements_begin() [2/2]

virtual element_iterator libMesh::DistributedMesh::active_subdomain_elements_begin ( subdomain_id_type  subdomain_id )

overridevirtual

Implements libMesh::MeshBase.

Referenced by active_subdomain_elements_ptr_range().

active_subdomain_elements_end() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::active_subdomain_elements_end ( subdomain_id_type  subdomain_id ) const

overridevirtual

Implements libMesh::MeshBase.

active_subdomain_elements_end() [2/2]

virtual element_iterator libMesh::DistributedMesh::active_subdomain_elements_end ( subdomain_id_type  subdomain_id )

overridevirtual

Implements libMesh::MeshBase.

Referenced by active_subdomain_elements_ptr_range().

active_subdomain_elements_ptr_range() [1/2]

virtual SimpleRange<const_element_iterator> libMesh::DistributedMesh::active_subdomain_elements_ptr_range ( subdomain_id_type  subdomain_id ) const

inlineoverridevirtual

Implements libMesh::MeshBase.

Definition at line 445 of file distributed_mesh.h.

  { return {active_subdomain_elements_begin(subdomain_id), active_subdomain_elements_end(subdomain_id)}; }

References active_subdomain_elements_begin(), and active_subdomain_elements_end().

active_subdomain_elements_ptr_range() [2/2]

virtual SimpleRange<element_iterator> libMesh::DistributedMesh::active_subdomain_elements_ptr_range ( subdomain_id_type  subdomain_id )

inlineoverridevirtual

Implements libMesh::MeshBase.

Definition at line 443 of file distributed_mesh.h.

  { return {active_subdomain_elements_begin(subdomain_id), active_subdomain_elements_end(subdomain_id)}; }

References active_subdomain_elements_begin(), and active_subdomain_elements_end().

active_subdomain_set_elements_begin() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::active_subdomain_set_elements_begin ( std::set< subdomain_id_type >  ss ) const

overridevirtual

Implements libMesh::MeshBase.

active_subdomain_set_elements_begin() [2/2]

virtual element_iterator libMesh::DistributedMesh::active_subdomain_set_elements_begin ( std::set< subdomain_id_type >  ss )

overridevirtual

Implements libMesh::MeshBase.

Referenced by active_subdomain_set_elements_ptr_range().

active_subdomain_set_elements_end() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::active_subdomain_set_elements_end ( std::set< subdomain_id_type >  ss ) const

overridevirtual

Implements libMesh::MeshBase.

active_subdomain_set_elements_end() [2/2]

virtual element_iterator libMesh::DistributedMesh::active_subdomain_set_elements_end ( std::set< subdomain_id_type >  ss )

overridevirtual

Implements libMesh::MeshBase.

Referenced by active_subdomain_set_elements_ptr_range().

active_subdomain_set_elements_ptr_range() [1/2]

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

inlineoverridevirtual

Implements libMesh::MeshBase.

Definition at line 454 of file distributed_mesh.h.

  { return {active_subdomain_set_elements_begin(ss), active_subdomain_set_elements_end(ss)}; }

References active_subdomain_set_elements_begin(), and active_subdomain_set_elements_end().

active_subdomain_set_elements_ptr_range() [2/2]

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

inlineoverridevirtual

Implements libMesh::MeshBase.

Definition at line 452 of file distributed_mesh.h.

  { return {active_subdomain_set_elements_begin(ss), active_subdomain_set_elements_end(ss)}; }

References active_subdomain_set_elements_begin(), and active_subdomain_set_elements_end().

active_type_elements_begin() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::active_type_elements_begin ( ElemType  type ) const

overridevirtual

Implements libMesh::MeshBase.

active_type_elements_begin() [2/2]

virtual element_iterator libMesh::DistributedMesh::active_type_elements_begin ( ElemType  type )

overridevirtual

Implements libMesh::MeshBase.

active_type_elements_end() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::active_type_elements_end ( ElemType  type ) const

overridevirtual

Implements libMesh::MeshBase.

active_type_elements_end() [2/2]

virtual element_iterator libMesh::DistributedMesh::active_type_elements_end ( ElemType  type )

overridevirtual

Implements libMesh::MeshBase.

active_unpartitioned_elements_begin() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::active_unpartitioned_elements_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

active_unpartitioned_elements_begin() [2/2]

virtual element_iterator libMesh::DistributedMesh::active_unpartitioned_elements_begin ( )

overridevirtual

Iterate over active unpartitioned elements in the Mesh.

Implements libMesh::MeshBase.

active_unpartitioned_elements_end() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::active_unpartitioned_elements_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

active_unpartitioned_elements_end() [2/2]

virtual element_iterator libMesh::DistributedMesh::active_unpartitioned_elements_end ( )

overridevirtual

Implements libMesh::MeshBase.

add_elem()

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

overridevirtual

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 436 of file distributed_mesh.C.

{
  // Don't try to add nullptrs!
  libmesh_assert(e);
 
  // Trying to add an existing element is a no-op
  if (e->valid_id() && _elements[e->id()] == e)
    return e;
 
  const processor_id_type elem_procid = e->processor_id();
 
  if (!e->valid_id())
    {
      // We should only be creating new ids past the end of the range
      // of existing ids
      libmesh_assert_greater_equal(_next_free_unpartitioned_elem_id,
                                   _max_elem_id);
      libmesh_assert_greater_equal(_next_free_local_elem_id, _max_elem_id);
 
      // Use the unpartitioned ids for unpartitioned elems, and
      // temporarily for ghost elems
      dof_id_type * next_id = &_next_free_unpartitioned_elem_id;
      if (elem_procid == this->processor_id())
        next_id = &_next_free_local_elem_id;
      e->set_id (*next_id);
    }
 
  {
    // Advance next_ids up high enough that each is pointing to an
    // unused id and any subsequent increments will still point us
    // to unused ids
    _max_elem_id = std::max(_max_elem_id,
                            static_cast<dof_id_type>(e->id()+1));
 
    if (_next_free_unpartitioned_elem_id < _max_elem_id)
      _next_free_unpartitioned_elem_id =
        ((_max_elem_id-1) / (this->n_processors() + 1) + 1) *
        (this->n_processors() + 1) + this->n_processors();
    if (_next_free_local_elem_id < _max_elem_id)
      _next_free_local_elem_id =
        ((_max_elem_id + this->n_processors() - 1) / (this->n_processors() + 1) + 1) *
        (this->n_processors() + 1) + this->processor_id();
 
#ifndef NDEBUG
    // We need a const mapvector so we don't inadvertently create
    // nullptr entries when testing for non-nullptr ones
    const mapvector<Elem *, dof_id_type> & const_elements = _elements;
#endif
    libmesh_assert(!const_elements[_next_free_unpartitioned_elem_id]);
    libmesh_assert(!const_elements[_next_free_local_elem_id]);
  }
 
  // Don't try to overwrite existing elems
  libmesh_assert (!_elements[e->id()]);
 
  _elements[e->id()] = e;
 
  // Try to make the cached elem data more accurate
  if (elem_procid == this->processor_id() ||
      elem_procid == DofObject::invalid_processor_id)
    _n_elem++;
 
#ifdef LIBMESH_ENABLE_UNIQUE_ID
  if (!e->valid_unique_id())
    {
      if (processor_id() == e->processor_id())
        {
          e->set_unique_id() = _next_unique_id;
          _next_unique_id += this->n_processors() + 1;
        }
      else
        {
          e->set_unique_id() = _next_unpartitioned_unique_id;
          _next_unpartitioned_unique_id += this->n_processors() + 1;
        }
    }
#endif
 
  // Unpartitioned elems should be added on every processor
  // And shouldn't be added in the same batch as ghost elems
  // But we might be just adding on processor 0 to
  // broadcast later
  // #ifdef DEBUG
  //   if (elem_procid == DofObject::invalid_processor_id)
  //     {
  //       dof_id_type elem_id = e->id();
  //       this->comm().max(elem_id);
  //       libmesh_assert_equal_to (elem_id, e->id());
  //     }
  // #endif
 
  // Make sure any new element is given space for any extra integers
  // we've requested
  e->add_extra_integers(_elem_integer_names.size());
 
  // 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;
}

References libMesh::MeshBase::_elem_integer_names, _elements, _max_elem_id, _n_elem, _next_free_local_elem_id, _next_free_unpartitioned_elem_id, libMesh::MeshBase::_next_unique_id, _next_unpartitioned_unique_id, libMesh::DofObject::add_extra_integers(), libMesh::MeshBase::default_mapping_data(), libMesh::MeshBase::default_mapping_type(), libMesh::DofObject::id(), libMesh::DofObject::invalid_processor_id, libMesh::libmesh_assert(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), libMesh::DofObject::set_id(), libMesh::Elem::set_mapping_data(), libMesh::Elem::set_mapping_type(), libMesh::DofObject::set_unique_id(), libMesh::DofObject::valid_id(), and libMesh::DofObject::valid_unique_id().

Referenced by add_extra_ghost_elem(), and SlitMeshTest::build_mesh().

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  )

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.

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

{
  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);
 
  if (allocate_data && old_size != _elem_integer_names.size())
    this->size_elem_extra_integers();
 
  return returnval;
}

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

add_elem_datum()

template<typename T >

unsigned int libMesh::MeshBase::add_elem_datum ( const std::string &  name, bool  allocate_data = true  )

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.

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

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

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

Referenced by ExtraIntegersTest::build_mesh().

add_elem_integer()

unsigned int libMesh::MeshBase::add_elem_integer ( const std::string &  name, bool  allocate_data = true  )

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.

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

{
  for (auto i : index_range(_elem_integer_names))
    if (_elem_integer_names[i] == name)
      return i;
 
  _elem_integer_names.push_back(name);
  if (allocate_data)
    this->size_elem_extra_integers();
  return _elem_integer_names.size()-1;
}

References 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(), ExtraIntegersTest::build_mesh(), ExtraIntegersTest::checkpoint_helper(), libMesh::CheckpointIO::read_header(), and ExtraIntegersTest::test_helper().

add_elem_integers()

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

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.

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

{
  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];
      auto it = name_indices.find(name);
      if (it != name_indices.end())
        returnval[i] = it->second;
      else
        {
          returnval[i] = _elem_integer_names.size();
          name_indices[name] = returnval[i];
          _elem_integer_names.push_back(name);
          added_an_integer = true;
        }
    }
 
  if (allocate_data && added_an_integer)
    this->size_elem_extra_integers();
 
  return returnval;
}

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

Referenced by MeshStitchTest::testMeshStitch().

add_extra_ghost_elem()

void libMesh::DistributedMesh::add_extra_ghost_elem ( Elem *  e )

virtual

Inserts the element and adds it to a list of elements that should not get deleted or have their descendants deleted by delete_remote_elements.

This is handy for inserting otherwise off-processor elements that you want to keep track of on this processor.

Definition at line 1475 of file distributed_mesh.C.

{
  // First add the elem like normal
  add_elem(e);
 
  // Now add it to the set that won't be deleted when we call
  // delete_remote_elements()
  _extra_ghost_elems.insert(e);
}

References _extra_ghost_elems, and add_elem().

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

  { _ghosting_functors.insert(&ghosting_functor); }

References libMesh::MeshBase::_ghosting_functors.

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

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

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

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

add_node()

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

overridevirtual

Add Node n to the end of the vertex array.

Implements libMesh::MeshBase.

Definition at line 663 of file distributed_mesh.C.

{
  // Don't try to add nullptrs!
  libmesh_assert(n);
 
  // Trying to add an existing node is a no-op
  if (n->valid_id() && _nodes[n->id()] == n)
    return n;
 
  const processor_id_type node_procid = n->processor_id();
 
  if (!n->valid_id())
    {
      // We should only be creating new ids past the end of the range
      // of existing ids
      libmesh_assert_greater_equal(_next_free_unpartitioned_node_id,
                                   _max_node_id);
      libmesh_assert_greater_equal(_next_free_local_node_id, _max_node_id);
 
      // Use the unpartitioned ids for unpartitioned nodes,
      // and temporarily for ghost nodes
      dof_id_type * next_id = &_next_free_unpartitioned_node_id;
      if (node_procid == this->processor_id())
        next_id = &_next_free_local_node_id;
      n->set_id (*next_id);
    }
 
  {
    // Advance next_ids up high enough that each is pointing to an
    // unused id and any subsequent increments will still point us
    // to unused ids
    _max_node_id = std::max(_max_node_id,
                            static_cast<dof_id_type>(n->id()+1));
 
    if (_next_free_unpartitioned_node_id < _max_node_id)
      _next_free_unpartitioned_node_id =
        ((_max_node_id-1) / (this->n_processors() + 1) + 1) *
        (this->n_processors() + 1) + this->n_processors();
    if (_next_free_local_node_id < _max_node_id)
      _next_free_local_node_id =
        ((_max_node_id + this->n_processors() - 1) / (this->n_processors() + 1) + 1) *
        (this->n_processors() + 1) + this->processor_id();
 
#ifndef NDEBUG
    // We need a const mapvector so we don't inadvertently create
    // nullptr entries when testing for non-nullptr ones
    const mapvector<Node *,dof_id_type> & const_nodes = _nodes;
#endif
    libmesh_assert(!const_nodes[_next_free_unpartitioned_node_id]);
    libmesh_assert(!const_nodes[_next_free_local_node_id]);
  }
 
  // Don't try to overwrite existing nodes
  libmesh_assert (!_nodes[n->id()]);
 
  _nodes[n->id()] = n;
 
  // Try to make the cached node data more accurate
  if (node_procid == this->processor_id() ||
      node_procid == DofObject::invalid_processor_id)
    _n_nodes++;
 
#ifdef LIBMESH_ENABLE_UNIQUE_ID
  if (!n->valid_unique_id())
    {
      if (processor_id() == n->processor_id())
        {
          n->set_unique_id() = _next_unique_id;
          _next_unique_id += this->n_processors();
        }
      else
        {
          n->set_unique_id() = _next_unpartitioned_unique_id;
          _next_unpartitioned_unique_id += this->n_processors() + 1;
        }
    }
#endif
 
  n->add_extra_integers(_node_integer_names.size());
 
  // Unpartitioned nodes should be added on every processor
  // And shouldn't be added in the same batch as ghost nodes
  // But we might be just adding on processor 0 to
  // broadcast later
  // #ifdef DEBUG
  //   if (node_procid == DofObject::invalid_processor_id)
  //     {
  //       dof_id_type node_id = n->id();
  //       this->comm().max(node_id);
  //       libmesh_assert_equal_to (node_id, n->id());
  //     }
  // #endif
 
  return n;
}

References _max_node_id, _n_nodes, _next_free_local_node_id, _next_free_unpartitioned_node_id, libMesh::MeshBase::_next_unique_id, _next_unpartitioned_unique_id, libMesh::MeshBase::_node_integer_names, _nodes, libMesh::DofObject::add_extra_integers(), libMesh::DofObject::id(), libMesh::DofObject::invalid_processor_id, libMesh::libmesh_assert(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), libMesh::DofObject::set_id(), libMesh::DofObject::set_unique_id(), libMesh::DofObject::valid_id(), and libMesh::DofObject::valid_unique_id().

Referenced by add_point(), insert_node(), and own_node().

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  )

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.

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

{
  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);
 
  if (allocate_data && old_size != _node_integer_names.size())
    this->size_node_extra_integers();
 
  return returnval;
}

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

add_node_datum()

template<typename T >

unsigned int libMesh::MeshBase::add_node_datum ( const std::string &  name, bool  allocate_data = true  )

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.

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

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

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

Referenced by ExtraIntegersTest::build_mesh(), libMesh::DynaIO::read_mesh(), RationalMapTest< elem_type >::setUp(), and FETest< order, family, elem_type >::setUp().

add_node_integer()

unsigned int libMesh::MeshBase::add_node_integer ( const std::string &  name, bool  allocate_data = true  )

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.

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

{
  for (auto i : index_range(_node_integer_names))
    if (_node_integer_names[i] == name)
      return i;
 
  _node_integer_names.push_back(name);
  if (allocate_data)
    this->size_node_extra_integers();
  return _node_integer_names.size()-1;
}

References libMesh::index_range(), and libMesh::Quality::name().

Referenced by libMesh::MeshBase::add_node_datum(), ExtraIntegersTest::build_mesh(), ExtraIntegersTest::checkpoint_helper(), libMesh::CheckpointIO::read_header(), RationalMapTest< elem_type >::setUp(), FETest< order, family, elem_type >::setUp(), and ExtraIntegersTest::test_helper().

add_node_integers()

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

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.

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

{
  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];
      auto it = name_indices.find(name);
      if (it != name_indices.end())
        returnval[i] = it->second;
      else
        {
          returnval[i] = _node_integer_names.size();
          name_indices[name] = returnval[i];
          _node_integer_names.push_back(name);
          added_an_integer = true;
        }
    }
 
  if (allocate_data && added_an_integer)
    this->size_node_extra_integers();
 
  return returnval;
}

References libMesh::index_range(), and libMesh::Quality::name().

Referenced by MeshStitchTest::testMeshStitch().

add_point()

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

overridevirtual

functions for adding /deleting nodes elements.

Implements libMesh::MeshBase.

Definition at line 625 of file distributed_mesh.C.

{
  auto n_it = _nodes.find(id);
  if (n_it != _nodes.end().it)
    {
      Node * n = n_it->second;
      libmesh_assert (n);
      libmesh_assert_equal_to (n->id(), id);
 
      *n = p;
      n->processor_id() = proc_id;
 
      return n;
    }
 
  Node * n = Node::build(p, id).release();
  n->processor_id() = proc_id;
 
  return DistributedMesh::add_node(n);
}

References _nodes, add_node(), libMesh::Node::build(), libMesh::DofObject::id(), libMesh::libmesh_assert(), and libMesh::DofObject::processor_id().

Referenced by SlitMeshTest::build_mesh().

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 860 of file unstructured_mesh.C.

{
  /*
   * when the mesh is not prepared,
   * at least renumber the nodes and
   * elements, so that the node ids
   * are correct
   */
  if (!this->_is_prepared)
    this->renumber_nodes_and_elements ();
 
  START_LOG("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.
       */
      Elem * lo_elem = Elem::build
        (Elem::first_order_equivalent_type
         (so_elem->type()), so_elem->parent()).release();
 
      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);
            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, 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);
 
      /*
       * 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
      lo_elem->processor_id() = so_elem->processor_id();
      lo_elem->subdomain_id() = so_elem->subdomain_id();
      this->insert_elem(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();
 
  STOP_LOG("all_first_order()", "Mesh");
 
  // 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();
}

References libMesh::MeshBase::_is_prepared, libMesh::Elem::add_child(), libMesh::Elem::build(), libMesh::Elem::child_ptr(), libMesh::BoundaryInfo::copy_boundary_ids(), libMesh::MeshBase::delete_node(), libMesh::MeshBase::element_ptr_range(), libMesh::Elem::first_order_equivalent_type(), libMesh::MeshBase::get_boundary_info(), libMesh::DofObject::id(), libMesh::MeshBase::insert_elem(), libMesh::libmesh_assert(), libMesh::MeshBase::max_node_id(), libMesh::Elem::n_vertices(), libMesh::MeshBase::node(), libMesh::Elem::node_id(), libMesh::MeshBase::node_ptr_range(), libMesh::Elem::parent(), libMesh::MeshBase::prepare_for_use(), libMesh::DofObject::processor_id(), libMesh::BoundaryInfo::regenerate_id_sets(), libMesh::remote_elem, libMesh::MeshBase::renumber_nodes_and_elements(), libMesh::Elem::replace_child(), 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(), libMesh::DofObject::set_unique_id(), and libMesh::Elem::subdomain_id().

all_second_order()

void libMesh::UnstructuredMesh::all_second_order ( 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.

On distributed meshes we currently only support unpartitioned meshes (where we'll add every node in sync) or completely-partitioned meshes (where we'll sync nodes later); let's keep track to make sure we're not in any in-between state.

Loop over the low-ordered elements in the elements vector. First make sure they _are indeed low-order, and then replace them with an equivalent second-order element. Don't forget to delete the low-order element, or else it will leak!

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

Also, prepare_for_use() will reconstruct most of our neighbor links, but if we have any remote_elem links in a distributed mesh, they need to be preserved. We do that in the same loop here.

Implements libMesh::MeshBase.

Definition at line 998 of file unstructured_mesh.C.

{
  // This function must be run on all processors at once
  parallel_object_only();
 
  /*
   * when the mesh is not prepared,
   * at least renumber the nodes and
   * elements, so that the node ids
   * are correct
   */
  if (!this->_is_prepared)
    this->renumber_nodes_and_elements ();
 
  /*
   * If the mesh is empty
   * then we have nothing to do
   */
  if (!this->n_elem())
    return;
 
  /*
   * If the mesh is already second order
   * then we have nothing to do.
   * We have to test for this in a round-about way to avoid
   * a bug on distributed parallel meshes with more processors
   * than elements.
   */
  bool already_second_order = false;
  if (this->elements_begin() != this->elements_end() &&
      (*(this->elements_begin()))->default_order() != FIRST)
    already_second_order = true;
  this->comm().max(already_second_order);
  if (already_second_order)
    return;
 
  START_LOG("all_second_order()", "Mesh");
 
  /*
   * this map helps in identifying second order
   * nodes.  Namely, a second-order node:
   * - edge node
   * - face node
   * - bubble node
   * is uniquely defined through a set of adjacent
   * vertices.  This set of adjacent vertices is
   * used to identify already added higher-order
   * nodes.  We are safe to use node id's since we
   * make sure that these are correctly numbered.
   */
  std::map<std::vector<dof_id_type>, Node *> adj_vertices_to_so_nodes;
 
  /*
   * for speed-up of the \p add_point() method, we
   * can reserve memory.  Guess the number of additional
   * nodes for different dimensions
   */
  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
       */
      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)
       */
      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
       */
      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());
    }
 
 
 
  /*
   * form a vector that will hold the node id's of
   * the vertices that are adjacent to the son-th
   * second-order node.  Pull this outside of the
   * loop so that silly compilers don't repeatedly
   * create and destroy the vector.
   */
  std::vector<dof_id_type> adjacent_vertices_ids;
 
  dof_id_type n_unpartitioned_elem = 0,
              n_partitioned_elem = 0;
  const processor_id_type my_pid = this->processor_id();
 
  element_iterator
    it = elements_begin(),
    endit = elements_end();
 
  for (; it != endit; ++it)
    {
      // the linear-order element
      Elem * lo_elem = *it;
 
      libmesh_assert(lo_elem);
 
      // make sure it is linear order
      if (lo_elem->default_order() != FIRST)
        libmesh_error_msg("ERROR: This is not a linear element: type=" << lo_elem->type());
 
      // this does _not_ work for refined elements
      libmesh_assert_equal_to (lo_elem->level (), 0);
 
      const processor_id_type lo_pid = lo_elem->processor_id();
 
      if (lo_pid == DofObject::invalid_processor_id)
        ++n_unpartitioned_elem;
      else
        ++n_partitioned_elem;
 
      /*
       * build the second-order equivalent, add to
       * the new_elements list.  Note that this here
       * is the only point where \p full_ordered
       * is necessary.  The remaining code works well
       * for either type of second-order equivalent, e.g.
       * Hex20 or Hex27, as equivalents for Hex8
       */
      Elem * so_elem =
        Elem::build (Elem::second_order_equivalent_type(lo_elem->type(),
                                                        full_ordered) ).release();
 
      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, lnv=lo_elem->n_vertices(); v < lnv; v++)
        so_elem->set_node(v) = lo_elem->node_ptr(v);
 
      /*
       * Now handle the additional mid-side nodes.  This
       * is simply handled through a map that remembers
       * the already-added nodes.  This map maps the global
       * ids of the vertices (that uniquely define this
       * higher-order node) to the new node.
       * Notation: son = second-order node
       */
      const unsigned int son_begin = so_elem->n_vertices();
      const unsigned int son_end   = so_elem->n_nodes();
 
 
      for (unsigned int son=son_begin; son<son_end; son++)
        {
          const unsigned int n_adjacent_vertices =
            so_elem->n_second_order_adjacent_vertices(son);
 
          adjacent_vertices_ids.resize(n_adjacent_vertices);
 
          for (unsigned int v=0; v<n_adjacent_vertices; v++)
            adjacent_vertices_ids[v] =
              so_elem->node_id( so_elem->second_order_adjacent_vertex(son,v) );
 
          /*
           * \p adjacent_vertices_ids is now in order of the current
           * side.  sort it, so that comparisons  with the
           * \p adjacent_vertices_ids created through other elements'
           * sides can match
           */
          std::sort(adjacent_vertices_ids.begin(),
                    adjacent_vertices_ids.end());
 
 
          // does this set of vertices already have a mid-node added?
          auto pos = adj_vertices_to_so_nodes.equal_range (adjacent_vertices_ids);
 
          // no, not added yet
          if (pos.first == pos.second)
            {
              /*
               * for this set of vertices, there is no
               * second_order node yet.  Add it.
               *
               * compute the location of the new node as
               * the average over the adjacent vertices.
               */
              Point new_location = this->point(adjacent_vertices_ids[0]);
              for (unsigned int v=1; v<n_adjacent_vertices; v++)
                new_location += this->point(adjacent_vertices_ids[v]);
 
              new_location /= static_cast<Real>(n_adjacent_vertices);
 
              /* Add the new point to the mesh.
               * If we are on a serialized mesh, then we're doing this
               * all in sync, and the node processor_id will be
               * consistent between processors.
               * If we are on a distributed mesh, we can fix
               * inconsistent processor ids later, but only if every
               * processor gives new nodes a *locally* consistent
               * processor id, so we'll give the new node the
               * processor id of an adjacent element for now and then
               * we'll update that later if appropriate.
               */
              Node * so_node = this->add_point
                (new_location, DofObject::invalid_id, lo_pid);
 
              /*
               * insert the new node with its defining vertex
               * set into the map, and relocate pos to this
               * new entry, so that the so_elem can use
               * \p pos for inserting the node
               */
              adj_vertices_to_so_nodes.insert(pos.first,
                                              std::make_pair(adjacent_vertices_ids,
                                                             so_node));
 
              so_elem->set_node(son) = so_node;
            }
          // yes, already added.
          else
            {
              Node * so_node = pos.first->second;
              libmesh_assert(so_node);
 
              so_elem->set_node(son) = so_node;
 
              // We need to ensure that the processor who should own a
              // node *knows* they own the node.  And because
              // Node::choose_processor_id() may depend on Node id,
              // which may not yet be authoritative, we still have to
              // use a dumb-but-id-independent partitioning heuristic.
              processor_id_type chosen_pid =
                std::min (so_node->processor_id(), lo_pid);
 
              // Plus, if we just discovered that we own this node,
              // then on a distributed mesh we need to make sure to
              // give it a valid id, not just a placeholder id!
              if (!this->is_replicated() &&
                  so_node->processor_id() != my_pid &&
                  chosen_pid == my_pid)
                this->own_node(*so_node);
 
              so_node->processor_id() = chosen_pid;
            }
        }
 
      /*
       * find_neighbors relies on remote_elem neighbor links being
       * properly maintained.
       */
      for (auto s : lo_elem->side_index_range())
        {
          if (lo_elem->neighbor_ptr(s) == remote_elem)
            so_elem->set_neighbor(s, const_cast<RemoteElem*>(remote_elem));
        }
 
      this->get_boundary_info().copy_boundary_ids
        (this->get_boundary_info(), lo_elem, so_elem);
 
      /*
       * The new second-order element is ready.
       * Inserting it into the mesh will replace and delete
       * the first-order element.
       */
      so_elem->set_id(lo_elem->id());
#ifdef LIBMESH_ENABLE_UNIQUE_ID
      so_elem->set_unique_id() = lo_elem->unique_id();
#endif
      so_elem->processor_id() = lo_pid;
      so_elem->subdomain_id() = lo_elem->subdomain_id();
      this->insert_elem(so_elem);
    }
 
  // we can clear the map
  adj_vertices_to_so_nodes.clear();
 
 
  STOP_LOG("all_second_order()", "Mesh");
 
  // On a DistributedMesh our ghost node processor ids may be bad,
  // the ids of nodes touching remote elements may be inconsistent,
  // unique_ids of newly added non-local nodes remain unset, and our
  // partitioning of new nodes may not be well balanced.
  //
  // make_nodes_parallel_consistent() will fix all this.
  if (!this->is_replicated())
    {
      dof_id_type max_unpartitioned_elem = n_unpartitioned_elem;
      this->comm().max(max_unpartitioned_elem);
      if (max_unpartitioned_elem)
        {
          // We'd better be effectively serialized here.  In theory we
          // could support more complicated cases but in practice we
          // only support "completely partitioned" and/or "serialized"
          if (!this->comm().verify(n_unpartitioned_elem) ||
              !this->comm().verify(n_partitioned_elem) ||
              !this->is_serial())
            libmesh_not_implemented();
        }
      else
        {
          MeshCommunication().make_nodes_parallel_consistent (*this);
        }
    }
 
  // renumber nodes, elements etc
  this->prepare_for_use(/*skip_renumber =*/ false);
}

References libMesh::MeshBase::_is_prepared, libMesh::MeshBase::add_point(), libMesh::Elem::build(), libMesh::ParallelObject::comm(), libMesh::BoundaryInfo::copy_boundary_ids(), libMesh::Elem::default_order(), libMesh::MeshBase::elements_begin(), libMesh::MeshBase::elements_end(), libMesh::FIRST, libMesh::MeshBase::get_boundary_info(), libMesh::DofObject::id(), libMesh::MeshBase::insert_elem(), libMesh::DofObject::invalid_id, libMesh::DofObject::invalid_processor_id, libMesh::MeshBase::is_replicated(), libMesh::MeshBase::is_serial(), libMesh::Elem::level(), libMesh::libmesh_assert(), libMesh::MeshBase::mesh_dimension(), libMesh::MeshBase::MeshCommunication, libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), libMesh::Elem::n_nodes(), libMesh::Elem::n_second_order_adjacent_vertices(), libMesh::MeshBase::n_unpartitioned_elem(), libMesh::Elem::n_vertices(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::node_id(), libMesh::Elem::node_ptr(), libMesh::MeshBase::own_node(), libMesh::MeshBase::point(), libMesh::MeshBase::prepare_for_use(), libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), libMesh::remote_elem, libMesh::MeshBase::renumber_nodes_and_elements(), libMesh::MeshBase::reserve_nodes(), libMesh::Elem::second_order_adjacent_vertex(), libMesh::Elem::second_order_equivalent_type(), libMesh::DofObject::set_id(), libMesh::Elem::set_neighbor(), libMesh::Elem::set_node(), libMesh::DofObject::set_unique_id(), libMesh::Elem::side_index_range(), libMesh::Elem::subdomain_id(), libMesh::Elem::type(), and libMesh::DofObject::unique_id().

allgather()

void libMesh::DistributedMesh::allgather ( )

overridevirtual

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

Reimplemented from libMesh::MeshBase.

Definition at line 1495 of file distributed_mesh.C.

{
  if (_is_serial)
    return;
  MeshCommunication().allgather(*this);
  _is_serial = true;
  _is_serial_on_proc_0 = true;
 
  // Make sure our caches are up to date and our
  // DofObjects are well packed
#ifdef DEBUG
  libmesh_assert_equal_to (this->n_nodes(), this->parallel_n_nodes());
  libmesh_assert_equal_to (this->n_elem(), this->parallel_n_elem());
  const dof_id_type pmax_node_id = this->parallel_max_node_id();
  const dof_id_type pmax_elem_id = this->parallel_max_elem_id();
  libmesh_assert_equal_to (this->max_node_id(), pmax_node_id);
  libmesh_assert_equal_to (this->max_elem_id(), pmax_elem_id);
 
  // If we've disabled renumbering we can't be sure we're contiguous
  // libmesh_assert_equal_to (this->n_nodes(), this->max_node_id());
  // libmesh_assert_equal_to (this->n_elem(), this->max_elem_id());
 
  // Make sure our neighbor links are all fine
  MeshTools::libmesh_assert_valid_neighbors(*this);
 
  // Make sure our ids and flags are consistent
  this->libmesh_assert_valid_parallel_ids();
  this->libmesh_assert_valid_parallel_flags();
#endif
}

References _is_serial, _is_serial_on_proc_0, libMesh::MeshTools::libmesh_assert_valid_neighbors(), libmesh_assert_valid_parallel_flags(), libmesh_assert_valid_parallel_ids(), max_elem_id(), max_node_id(), libMesh::MeshBase::MeshCommunication, n_elem(), n_nodes(), parallel_max_elem_id(), parallel_max_node_id(), parallel_n_elem(), and parallel_n_nodes().

allow_remote_element_removal() [1/2]

bool libMesh::MeshBase::allow_remote_element_removal ( ) const

inlineinherited

Definition at line 1035 of file mesh_base.h.

{ return _allow_remote_element_removal; }

References libMesh::MeshBase::_allow_remote_element_removal.

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

allow_remote_element_removal() [2/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 1034 of file mesh_base.h.

{ _allow_remote_element_removal = allow; }

References libMesh::MeshBase::_allow_remote_element_removal.

Referenced by libMesh::DynaIO::add_spline_constraints(), AllSecondOrderTest::allSecondOrder(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), main(), MeshInputTest::testDynaReadElem(), and MeshInputTest::testDynaReadPatch().

allow_renumbering() [1/2]

bool libMesh::MeshBase::allow_renumbering ( ) const

inlineinherited

Definition at line 1026 of file mesh_base.h.

{ return !_skip_renumber_nodes_and_elements; }

References libMesh::MeshBase::_skip_renumber_nodes_and_elements.

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

allow_renumbering() [2/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 1025 of file mesh_base.h.

{ _skip_renumber_nodes_and_elements = !allow; }

References libMesh::MeshBase::_skip_renumber_nodes_and_elements.

Referenced by libMesh::DynaIO::add_spline_constraints(), GetBoundaryPointsTest::build_mesh(), SlitMeshTest::build_mesh(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), main(), libMesh::RBEIMEvaluation::RBEIMEvaluation(), libMesh::NameBasedIO::read(), libMesh::GMVIO::read(), MeshInputTest::testDynaReadElem(), MeshInputTest::testDynaReadPatch(), SystemsTest::testProjectMatrix1D(), SystemsTest::testProjectMatrix2D(), SystemsTest::testProjectMatrix3D(), EquationSystemsTest::testRefineThenReinitPreserveFlags(), EquationSystemsTest::testRepartitionThenReinit(), WriteSidesetData::testWrite(), and WriteVecAndScalar::testWrite().

ancestor_elements_begin() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::ancestor_elements_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

ancestor_elements_begin() [2/2]

virtual element_iterator libMesh::DistributedMesh::ancestor_elements_begin ( )

overridevirtual

Iterate over elements for which elem->ancestor() is true.

Implements libMesh::MeshBase.

ancestor_elements_end() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::ancestor_elements_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

ancestor_elements_end() [2/2]

virtual element_iterator libMesh::DistributedMesh::ancestor_elements_end ( )

overridevirtual

Implements libMesh::MeshBase.

bid_nodes_begin() [1/2]

virtual const_node_iterator libMesh::DistributedMesh::bid_nodes_begin ( boundary_id_type  bndry_id ) const

overridevirtual

Implements libMesh::MeshBase.

bid_nodes_begin() [2/2]

virtual node_iterator libMesh::DistributedMesh::bid_nodes_begin ( boundary_id_type  bndry_id )

overridevirtual

Iterate over nodes for which BoundaryInfo::has_boundary_id(node, bndry_id) is true.

Implements libMesh::MeshBase.

bid_nodes_end() [1/2]

virtual const_node_iterator libMesh::DistributedMesh::bid_nodes_end ( boundary_id_type  bndry_id ) const

overridevirtual

Implements libMesh::MeshBase.

bid_nodes_end() [2/2]

virtual node_iterator libMesh::DistributedMesh::bid_nodes_end ( boundary_id_type  bndry_id )

overridevirtual

Implements libMesh::MeshBase.

bnd_nodes_begin() [1/2]

virtual const_node_iterator libMesh::DistributedMesh::bnd_nodes_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

bnd_nodes_begin() [2/2]

virtual node_iterator libMesh::DistributedMesh::bnd_nodes_begin ( )

overridevirtual

Iterate over nodes for which BoundaryInfo::n_boundary_ids(node) > 0.

Implements libMesh::MeshBase.

bnd_nodes_end() [1/2]

virtual const_node_iterator libMesh::DistributedMesh::bnd_nodes_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

bnd_nodes_end() [2/2]

virtual node_iterator libMesh::DistributedMesh::bnd_nodes_end ( )

overridevirtual

Implements libMesh::MeshBase.

cache_elem_dims()

void libMesh::MeshBase::cache_elem_dims ( )

inherited

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

{
  // This requires an inspection on every processor
  parallel_object_only();
 
  // Need to clear _elem_dims first in case all elements of a
  // particular dimension have been deleted.
  _elem_dims.clear();
 
  for (const auto & elem : this->active_element_ptr_range())
    _elem_dims.insert(cast_int<unsigned char>(elem->dim()));
 
  // Some different dimension elements may only live on other processors
  this->comm().set_union(_elem_dims);
 
  // 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 LIBMESH_DIM > 1
  if (_spatial_dimension < 3)
    {
      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)(1) != 0.)
            {
              _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
        }
    }
#endif // LIBMESH_DIM > 1
}

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

clear()

void libMesh::DistributedMesh::clear ( )

overridevirtual

Clear all internal data.

Reimplemented from libMesh::MeshBase.

Definition at line 832 of file distributed_mesh.C.

{
  // Call parent clear function
  MeshBase::clear();
 
  // Clear our elements and nodes
  // There is no need to remove the elements from
  // the BoundaryInfo data structure since we
  // already cleared it.
  for (auto & elem : _elements)
    delete elem;
 
  // clear the nodes data structure
  // There is no need to remove the nodes from
  // the BoundaryInfo data structure since we
  // already cleared it.
  for (auto & node : _nodes)
    delete node;
 
  _elements.clear();
  _nodes.clear();
 
  // We're no longer distributed if we were before
  _is_serial = true;
  _is_serial_on_proc_0 = true;
 
  // Correct our caches
  _n_nodes = 0;
  _n_elem = 0;
  _max_node_id = 0;
  _max_elem_id = 0;
  _next_free_local_node_id = this->processor_id();
  _next_free_local_elem_id = this->processor_id();
  _next_free_unpartitioned_node_id = this->n_processors();
  _next_free_unpartitioned_elem_id = this->n_processors();
}

References _elements, _is_serial, _is_serial_on_proc_0, _max_elem_id, _max_node_id, _n_elem, _n_nodes, _next_free_local_elem_id, _next_free_local_node_id, _next_free_unpartitioned_elem_id, _next_free_unpartitioned_node_id, _nodes, libMesh::MeshBase::clear(), libMesh::MeshBase::elem(), libMesh::ParallelObject::n_processors(), libMesh::MeshBase::node(), and libMesh::ParallelObject::processor_id().

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

clear_extra_ghost_elems() [1/2]

virtual void libMesh::DistributedMesh::clear_extra_ghost_elems ( )

inlinevirtual

Clears extra ghost elements.

Definition at line 216 of file distributed_mesh.h.

{ _extra_ghost_elems.clear(); }

References _extra_ghost_elems.

clear_extra_ghost_elems() [2/2]

void libMesh::DistributedMesh::clear_extra_ghost_elems ( const std::set< Elem * > &  extra_ghost_elems )

virtual

Clears specified extra ghost elements.

Definition at line 1486 of file distributed_mesh.C.

{
  std::set<Elem *> tmp;
  std::set_difference(_extra_ghost_elems.begin(), _extra_ghost_elems.end(),
                      extra_ghost_elems.begin(), extra_ghost_elems.end(),
                      std::inserter(tmp, tmp.begin()));
  _extra_ghost_elems = tmp;
}

References _extra_ghost_elems, and extra_ghost_elems().

clear_point_locator()

void libMesh::MeshBase::clear_point_locator ( )

inherited

Releases the current PointLocator object.

Definition at line 696 of file mesh_base.C.

{
  _point_locator.reset(nullptr);
}

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

clone()

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

inlineoverridevirtual

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

Implements libMesh::MeshBase.

Reimplemented in libMesh::ParallelMesh.

Definition at line 89 of file distributed_mesh.h.

  { return libmesh_make_unique<DistributedMesh>(*this); }

comm()

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

inlineinherited

Returns

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

Definition at line 94 of file parallel_object.h.

  { return _communicator; }

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::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::EquationSystems::_read_impl(), 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::ImplicitSystem::add_matrix(), libMesh::RBConstruction::add_scaled_matrix_and_vector(), libMesh::DynaIO::add_spline_constraints(), libMesh::System::add_vector(), libMesh::UnstructuredMesh::all_second_order(), 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::FEMSystem::assemble_qoi(), libMesh::MeshCommunication::assign_global_indices(), libMesh::DofMap::attach_matrix(), libMesh::MeshTools::Generation::build_extrusion(), 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::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::Problem_Interface::computeF(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_scalar_solution(), 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::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), DMlibMeshFunction(), DMlibMeshJacobian(), DMlibMeshSetSystem_libMesh(), DMVariableBounds_libMesh(), libMesh::DTKSolutionTransfer::DTKSolutionTransfer(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::RBEIMConstruction::enrich_RB_space(), libMesh::TransientRBConstruction::enrich_RB_space(), libMesh::RBConstruction::enrich_RB_space(), libMesh::EpetraVector< T >::EpetraVector(), AssembleOptimization::equality_constraints(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::RBEIMConstruction::evaluate_mesh_function(), 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::DofMap::gather_constraints(), libMesh::MeshfreeInterpolation::gather_remote_data(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::DofMap::get_info(), libMesh::ImplicitSystem::get_linear_solver(), AssembleOptimization::inequality_constraints(), AssembleOptimization::inequality_constraints_jacobian(), libMesh::LocationMap< T >::init(), libMesh::TimeSolver::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::EigenSystem::init_matrices(), libMesh::OptimizationSystem::initialize_equality_constraints_storage(), libMesh::OptimizationSystem::initialize_inequality_constraints_storage(), libMesh::RBEIMConstruction::initialize_rb_construction(), 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_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_assert_valid_parallel_flags(), libmesh_assert_valid_parallel_object_ids(), libmesh_assert_valid_parallel_p_levels(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::MeshTools::libmesh_assert_valid_unique_ids(), libMesh::libmesh_petsc_preconditioner_apply(), libMesh::libmesh_petsc_snes_fd_residual(), libMesh::libmesh_petsc_snes_jacobian(), libMesh::libmesh_petsc_snes_mffd_residual(), libMesh::libmesh_petsc_snes_postcheck(), 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(), 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_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(), LinearElasticityWithContact::move_mesh(), n_active_elem(), libMesh::MeshTools::n_active_levels(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::DofMap::n_constrained_dofs(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::CondensedEigenSystem::n_global_non_condensed_dofs(), libMesh::MeshTools::n_levels(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::MeshTools::n_p_levels(), libMesh::BoundaryInfo::n_shellface_conds(), parallel_max_elem_id(), parallel_max_node_id(), libMesh::ReplicatedMesh::parallel_max_unique_id(), parallel_max_unique_id(), parallel_n_elem(), parallel_n_nodes(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::MeshTools::paranoid_n_levels(), libMesh::petsc_auto_fieldsplit(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::DofMap::print_dof_constraints(), FEMParameters::read(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::System::read_header(), 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::MeshRefinement::refine_and_coarsen_elements(), renumber_dof_objects(), LinearElasticityWithContact::residual_and_jacobian(), OverlappingAlgebraicGhostingTest::run_ghosting_test(), OverlappingCouplingGhostingTest::run_sparsity_pattern_test(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::TransientRBConstruction::set_error_temporal_data(), libMesh::RBEIMConstruction::set_explicit_sys_subvector(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::PetscDiffSolver::setup_petsc_data(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::split_mesh(), libMesh::BoundaryInfo::sync(), libMesh::MeshRefinement::test_level_one(), MeshfunctionDFEM::test_mesh_function_dfem(), MeshfunctionDFEM::test_mesh_function_dfem_grad(), MeshFunctionTest::test_p_level(), libMesh::MeshRefinement::test_unflagged(), SystemsTest::testBlockRestrictedVarNDofs(), PointLocatorTest::testLocator(), BoundaryInfoTest::testMesh(), SystemsTest::testProjectCubeWithMeshFunction(), CheckpointIOTest::testSplitter(), libMesh::MeshTools::total_weight(), libMesh::MeshFunctionSolutionTransfer::transfer(), libMesh::MeshfreeSolutionTransfer::transfer(), libMesh::TransientRBConstruction::truth_assembly(), libMesh::RBConstruction::truth_assembly(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::TransientRBConstruction::update_RB_initial_condition_all_N(), libMesh::RBEIMConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_RB_system_matrices(), libMesh::RBConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_residual_terms(), libMesh::RBConstruction::update_residual_terms(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::VTKIO::write_nodal_data(), 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().

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 797 of file unstructured_mesh.C.

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

References libMesh::Elem::active(), libMesh::Elem::ancestor(), libMesh::as_range(), libMesh::MeshBase::clear_point_locator(), libMesh::Elem::contract(), libMesh::MeshBase::delete_elem(), libMesh::MeshBase::elem(), libMesh::MeshBase::element_ptr_range(), libMesh::MeshBase::ghosting_functors_begin(), libMesh::MeshBase::ghosting_functors_end(), libMesh::libmesh_assert(), libMesh::Elem::parent(), libMesh::MeshBase::renumber_nodes_and_elements(), and libMesh::Elem::subactive().

copy_nodes_and_elements()

void libMesh::UnstructuredMesh::copy_nodes_and_elements ( const UnstructuredMesh &  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  )

virtualinherited

Deep copy of nodes and elements from another unstructured mesh class (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.

Definition at line 61 of file unstructured_mesh.C.

{
  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,
  // then we need to "wrap" the other Mesh's processor ids to fit
  // within our range. This can happen, for example, while stitching
  // ReplicatedMeshes with small numbers of elements in parallel...
  bool wrap_proc_ids = (_n_parts < other_mesh._n_parts);
 
  // We're assuming our subclass data needs no copy
  libmesh_assert_equal_to (_is_prepared, other_mesh._is_prepared);
 
  // 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() % _n_parts : 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;
 
    // 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;
        std::unique_ptr<Elem> ap = Elem::build(old->type(), newparent);
        Elem * el = ap.release();
 
        el->subdomain_id() = old->subdomain_id();
 
#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, 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() % _n_parts : 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(el);
          }
        else
          {
            Elem * new_el = this->add_elem(el);
            old_elems_to_new_elems[old] = new_el;
          }
      }
 
    // 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);
              }
          }
      }
  }
 
  //Finally prepare the new Mesh for use.  Keep the same numbering and
  //partitioning for now.
  this->allow_renumbering(false);
  this->allow_remote_element_removal(false);
 
  // We should generally be able to skip *all* partitioning here
  // because we're only adding one already-consistent mesh to another.
  this->skip_partitioning(true);
 
  this->prepare_for_use(false, skip_find_neighbors);
 
  //But in the long term, use the same renumbering and partitioning
  //policies as our source mesh.
  this->allow_renumbering(other_mesh.allow_renumbering());
  this->allow_remote_element_removal(other_mesh.allow_remote_element_removal());
  this->skip_partitioning(other_mesh._skip_all_partitioning);
  this->skip_noncritical_partitioning(other_mesh._skip_noncritical_partitioning);
}

References libMesh::MeshBase::_elem_integer_names, libMesh::MeshBase::_is_prepared, libMesh::MeshBase::_n_parts, libMesh::MeshBase::_node_integer_names, libMesh::MeshBase::_skip_all_partitioning, libMesh::MeshBase::_skip_noncritical_partitioning, libMesh::Elem::add_child(), libMesh::MeshBase::add_elem(), libMesh::DofObject::add_extra_integers(), libMesh::MeshBase::add_point(), libMesh::MeshBase::allow_remote_element_removal(), libMesh::MeshBase::allow_renumbering(), libMesh::Elem::build(), libMesh::MeshBase::elem_ptr(), libMesh::MeshBase::element_ptr_range(), libMesh::MeshTools::libmesh_assert_valid_amr_elem_ids(), libMesh::MeshBase::merge_extra_integer_names(), libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), libMesh::Elem::neighbor_ptr(), libMesh::MeshBase::node_ptr(), libMesh::MeshBase::node_ptr_range(), libMesh::Elem::parent(), libMesh::MeshBase::prepare_for_use(), libMesh::DofObject::processor_id(), libMesh::remote_elem, libMesh::MeshBase::reserve_elem(), libMesh::MeshBase::reserve_nodes(), libMesh::Elem::set_neighbor(), libMesh::MeshBase::skip_noncritical_partitioning(), libMesh::MeshBase::skip_partitioning(), and libMesh::Elem::subdomain_id().

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

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

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

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

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 707 of file unstructured_mesh.C.

{
  // 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(),
                     n_elem_ints = _elem_integer_names.size();
 
  for (const auto & old_elem : as_range(it, it_end))
    {
      // Add an equivalent element type to the new_mesh.
      // Copy ids for this element.
      Elem * new_elem = Elem::build(old_elem->type()).release();
      new_elem->set_id() = old_elem->id();
#ifdef LIBMESH_ENABLE_UNIQUE_ID
      new_elem->set_unique_id() = old_elem->unique_id();
#endif
      new_elem->subdomain_id() = old_elem->subdomain_id();
      new_elem->processor_id() = old_elem->processor_id();
 
      new_elem->add_extra_integers(n_elem_ints);
      for (unsigned int i = 0; i != n_elem_ints; ++i)
        new_elem->set_extra_integer(i, old_elem->get_extra_integer(i));
 
      new_mesh.add_elem (new_elem);
 
      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(/*skip_renumber =*/false);
}

References libMesh::MeshBase::_elem_integer_names, 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::Elem::build(), 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::DofObject::processor_id(), libMesh::MeshBase::query_node_ptr(), libMesh::DofObject::set_extra_integer(), libMesh::DofObject::set_id(), libMesh::Elem::set_node(), libMesh::DofObject::set_unique_id(), and libMesh::Elem::subdomain_id().

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

default_ghosting()

GhostingFunctor& libMesh::MeshBase::default_ghosting ( )

inlineinherited

Default ghosting functor.

Definition at line 1125 of file mesh_base.h.

{ return *_default_ghosting; }

References libMesh::MeshBase::_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 724 of file mesh_base.h.

                                              {
    return _default_mapping_data;
  }

References libMesh::MeshBase::_default_mapping_data.

Referenced by libMesh::ReplicatedMesh::add_elem(), add_elem(), libMesh::ReplicatedMesh::insert_elem(), insert_elem(), MeshInputTest::testDynaReadElem(), and MeshInputTest::testDynaReadPatch().

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

                                                {
    return _default_mapping_type;
  }

References libMesh::MeshBase::_default_mapping_type.

Referenced by libMesh::ReplicatedMesh::add_elem(), add_elem(), libMesh::ReplicatedMesh::insert_elem(), insert_elem(), MeshInputTest::testDynaReadElem(), and MeshInputTest::testDynaReadPatch().

delete_elem()

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

overridevirtual

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 582 of file distributed_mesh.C.

{
  libmesh_assert (e);
 
  // Try to make the cached elem data more accurate
  processor_id_type elem_procid = e->processor_id();
  if (elem_procid == this->processor_id() ||
      elem_procid == DofObject::invalid_processor_id)
    _n_elem--;
 
  // Delete the element from the BoundaryInfo object
  this->get_boundary_info().remove(e);
 
  // But not yet from the container; we might invalidate
  // an iterator that way!
 
  //_elements.erase(e->id());
 
  // Instead, we set it to nullptr for now
 
  _elements[e->id()] = nullptr;
 
  // delete the element
  delete e;
}

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

Referenced by insert_elem().

delete_node()

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

overridevirtual

Removes the Node n from the mesh.

Implements libMesh::MeshBase.

Definition at line 768 of file distributed_mesh.C.

{
  libmesh_assert(n);
  libmesh_assert(_nodes[n->id()]);
 
  // Try to make the cached elem data more accurate
  processor_id_type node_procid = n->processor_id();
  if (node_procid == this->processor_id() ||
      node_procid == DofObject::invalid_processor_id)
    _n_nodes--;
 
  // Delete the node from the BoundaryInfo object
  this->get_boundary_info().remove(n);
 
  // But not yet from the container; we might invalidate
  // an iterator that way!
 
  //_nodes.erase(n->id());
 
  // Instead, we set it to nullptr for now
 
  _nodes[n->id()] = nullptr;
 
  // delete the node
  delete n;
}

References _n_nodes, _nodes, libMesh::MeshBase::get_boundary_info(), libMesh::DofObject::id(), libMesh::DofObject::invalid_processor_id, libMesh::libmesh_assert(), libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), and libMesh::BoundaryInfo::remove().

delete_remote_elements()

void libMesh::DistributedMesh::delete_remote_elements ( )

overridevirtual

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 from libMesh::MeshBase.

Definition at line 1406 of file distributed_mesh.C.

{
#ifdef DEBUG
  // Make sure our neighbor links are all fine
  MeshTools::libmesh_assert_valid_neighbors(*this);
 
  // And our child/parent links, and our flags
  MeshTools::libmesh_assert_valid_refinement_tree(*this);
 
  // Make sure our ids and flags are consistent
  this->libmesh_assert_valid_parallel_ids();
  this->libmesh_assert_valid_parallel_flags();
 
  libmesh_assert_equal_to (this->n_nodes(), this->parallel_n_nodes());
  libmesh_assert_equal_to (this->n_elem(), this->parallel_n_elem());
  const dof_id_type pmax_node_id = this->parallel_max_node_id();
  const dof_id_type pmax_elem_id = this->parallel_max_elem_id();
  libmesh_assert_equal_to (this->max_node_id(), pmax_node_id);
  libmesh_assert_equal_to (this->max_elem_id(), pmax_elem_id);
#endif
 
  _is_serial = false;
  _is_serial_on_proc_0 = false;
 
  MeshCommunication().delete_remote_elements(*this, _extra_ghost_elems);
 
  libmesh_assert_equal_to (this->max_elem_id(), this->parallel_max_elem_id());
 
  // Now make sure the containers actually shrink - strip
  // any newly-created nullptr voids out of the element array
  mapvector<Elem *,dof_id_type>::veclike_iterator e_it        = _elements.begin();
  const mapvector<Elem *,dof_id_type>::veclike_iterator e_end = _elements.end();
  while (e_it != e_end)
    if (!*e_it)
      e_it = _elements.erase(e_it);
    else
      ++e_it;
 
  mapvector<Node *,dof_id_type>::veclike_iterator n_it        = _nodes.begin();
  const mapvector<Node *,dof_id_type>::veclike_iterator n_end = _nodes.end();
  while (n_it != n_end)
    if (!*n_it)
      n_it = _nodes.erase(n_it);
    else
      ++n_it;
 
  // We may have deleted no-longer-connected nodes or coarsened-away
  // elements; let's update our caches.
  this->update_parallel_id_counts();
 
#ifdef DEBUG
  // We might not have well-packed objects if the user didn't allow us
  // to renumber
  // libmesh_assert_equal_to (this->n_nodes(), this->max_node_id());
  // libmesh_assert_equal_to (this->n_elem(), this->max_elem_id());
 
  // Make sure our neighbor links are all fine
  MeshTools::libmesh_assert_valid_neighbors(*this);
 
  // And our child/parent links, and our flags
  MeshTools::libmesh_assert_valid_refinement_tree(*this);
 
  // Make sure our ids and flags are consistent
  this->libmesh_assert_valid_parallel_ids();
  this->libmesh_assert_valid_parallel_flags();
#endif
}

References _elements, _extra_ghost_elems, _is_serial, _is_serial_on_proc_0, _nodes, libMesh::MeshTools::libmesh_assert_valid_neighbors(), libmesh_assert_valid_parallel_flags(), libmesh_assert_valid_parallel_ids(), libMesh::MeshTools::libmesh_assert_valid_refinement_tree(), max_elem_id(), max_node_id(), libMesh::MeshBase::MeshCommunication, n_elem(), n_nodes(), parallel_max_elem_id(), parallel_max_node_id(), parallel_n_elem(), parallel_n_nodes(), and update_parallel_id_counts().

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

{
  // This requires an inspection on every processor
  parallel_object_only();
 
  // Check if the mesh contains mixed dimensions. If so, then set interior parents, otherwise return.
  if (this->elem_dimensions().size() == 1)
    return;
 
  //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->active_element_ptr_range())
    {
      // Populating the node_to_elem map, same as MeshTools::build_nodes_to_elem_map
      for (auto n : IntRange<unsigned int>(0, 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 : IntRange<unsigned int>(0, 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 : IntRange<unsigned int>(1, element->n_vertices()))
                {
                  if (neighbors[n].find(interior_parent_id)!=neighbors[n].end())
                    {
                      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;
                }
            }
        }
    }
}

References dim.

elem() [1/2]

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

inlinevirtualinherited

Returns

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

Definition at line 569 of file mesh_base.h.

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

References libMesh::MeshBase::elem_ptr().

elem() [2/2]

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

inlinevirtualinherited

Returns

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

Definition at line 554 of file mesh_base.h.

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

References libMesh::MeshBase::elem_ptr().

Referenced by libMesh::ReplicatedMesh::clear(), clear(), libMesh::UnstructuredMesh::contract(), DistributedMesh(), libMesh::ReplicatedMesh::get_boundary_points(), libMesh::ReplicatedMesh::get_disconnected_subdomains(), renumber_nodes_and_elements(), and libMesh::ReplicatedMesh::stitching_helper().

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

  { return _elem_dims; }

References libMesh::MeshBase::_elem_dims.

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

elem_ptr() [1/2]

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

overridevirtual

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 382 of file distributed_mesh.C.

{
  libmesh_assert(_elements[i]);
  libmesh_assert_equal_to (_elements[i]->id(), i);
 
  return _elements[i];
}

References _elements, and libMesh::libmesh_assert().

Referenced by DistributedMesh().

elem_ptr() [2/2]

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

overridevirtual

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 393 of file distributed_mesh.C.

{
  libmesh_assert(_elements[i]);
  libmesh_assert_equal_to (_elements[i]->id(), i);
 
  return _elements[i];
}

References _elements, and libMesh::libmesh_assert().

elem_ref() [1/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 530 of file mesh_base.h.

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

References libMesh::MeshBase::elem_ptr().

elem_ref() [2/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 521 of file mesh_base.h.

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

References libMesh::MeshBase::elem_ptr().

Referenced by libMesh::SyncRefinementFlags::act_on_data(), libMesh::AbaqusIO::assign_sideset_ids(), libMesh::AbaqusIO::assign_subdomain_ids(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::InfElemBuilder::build_inf_elem(), MixedDimensionNonUniformRefinement::build_mesh(), MixedDimensionNonUniformRefinementTriangle::build_mesh(), MixedDimensionNonUniformRefinement3D::build_mesh(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::find_dofs_to_send(), libMesh::SyncRefinementFlags::gather_data(), main(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::ExodusII_IO::read(), libMesh::CheckpointIO::read_remote_elem(), SystemsTest::testDofCouplingWithVarGroups(), MeshExtruderTest::testExtruder(), MixedDimensionMeshTest::testMesh(), SlitMeshTest::testMesh(), MixedDimensionNonUniformRefinement::testMesh(), MixedDimensionNonUniformRefinementTriangle::testMesh(), MixedDimensionNonUniformRefinement3D::testMesh(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::FroIO::write(), libMesh::Nemesis_IO_Helper::write_elements(), and libMesh::GmshIO::write_mesh().

element_ptr_range() [1/2]

virtual SimpleRange<const_element_iterator> libMesh::DistributedMesh::element_ptr_range ( ) const

inlineoverridevirtual

Implements libMesh::MeshBase.

Definition at line 309 of file distributed_mesh.h.

{ return {elements_begin(), elements_end()}; }

References elements_begin(), and elements_end().

element_ptr_range() [2/2]

virtual SimpleRange<element_iterator> libMesh::DistributedMesh::element_ptr_range ( )

inlineoverridevirtual

Implements libMesh::MeshBase.

Definition at line 308 of file distributed_mesh.h.

{ return {elements_begin(), elements_end()}; }

References elements_begin(), and elements_end().

Referenced by renumber_nodes_and_elements(), and RationalMapTest< elem_type >::setUp().

elements_begin() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::elements_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

elements_begin() [2/2]

virtual element_iterator libMesh::DistributedMesh::elements_begin ( )

overridevirtual

Elem iterator accessor functions.

Implements libMesh::MeshBase.

Referenced by element_ptr_range().

elements_end() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::elements_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

elements_end() [2/2]

virtual element_iterator libMesh::DistributedMesh::elements_end ( )

overridevirtual

Implements libMesh::MeshBase.

Referenced by element_ptr_range().

evaluable_elements_begin() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::evaluable_elements_begin ( const DofMap &  dof_map, unsigned int  var_num = libMesh::invalid_uint  ) const

overridevirtual

Implements libMesh::MeshBase.

evaluable_elements_begin() [2/2]

virtual element_iterator libMesh::DistributedMesh::evaluable_elements_begin ( const DofMap &  dof_map, unsigned int  var_num = libMesh::invalid_uint  )

overridevirtual

Iterate over elements in the Mesh where the solution (as distributed by the given DofMap) can be evaluated, for the given variable var_num, or for all variables by default.

Implements libMesh::MeshBase.

evaluable_elements_end() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::evaluable_elements_end ( const DofMap &  dof_map, unsigned int  var_num = libMesh::invalid_uint  ) const

overridevirtual

Implements libMesh::MeshBase.

evaluable_elements_end() [2/2]

virtual element_iterator libMesh::DistributedMesh::evaluable_elements_end ( const DofMap &  dof_map, unsigned int  var_num = libMesh::invalid_uint  )

overridevirtual

Implements libMesh::MeshBase.

evaluable_nodes_begin() [1/2]

virtual const_node_iterator libMesh::DistributedMesh::evaluable_nodes_begin ( const DofMap &  dof_map, unsigned int  var_num = libMesh::invalid_uint  ) const

overridevirtual

Implements libMesh::MeshBase.

evaluable_nodes_begin() [2/2]

virtual node_iterator libMesh::DistributedMesh::evaluable_nodes_begin ( const DofMap &  dof_map, unsigned int  var_num = libMesh::invalid_uint  )

overridevirtual

Iterate over nodes in the Mesh where the solution (as distributed by the given DofMap) can be evaluated, for the given variable var_num, or for all variables by default.

Implements libMesh::MeshBase.

evaluable_nodes_end() [1/2]

virtual const_node_iterator libMesh::DistributedMesh::evaluable_nodes_end ( const DofMap &  dof_map, unsigned int  var_num = libMesh::invalid_uint  ) const

overridevirtual

Implements libMesh::MeshBase.

evaluable_nodes_end() [2/2]

virtual node_iterator libMesh::DistributedMesh::evaluable_nodes_end ( const DofMap &  dof_map, unsigned int  var_num = libMesh::invalid_uint  )

overridevirtual

Implements libMesh::MeshBase.

extra_ghost_elems()

const std::set<Elem *>& libMesh::DistributedMesh::extra_ghost_elems ( ) const

inline

Const accessor to the ghosted elements.

Definition at line 226 of file distributed_mesh.h.

{ return _extra_ghost_elems; }

References _extra_ghost_elems.

Referenced by clear_extra_ghost_elems().

facelocal_elements_begin() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::facelocal_elements_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

facelocal_elements_begin() [2/2]

virtual element_iterator libMesh::DistributedMesh::facelocal_elements_begin ( )

overridevirtual

Iterate over elements which are on or have a neighbor on the current processor.

Implements libMesh::MeshBase.

facelocal_elements_end() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::facelocal_elements_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

facelocal_elements_end() [2/2]

virtual element_iterator libMesh::DistributedMesh::facelocal_elements_end ( )

overridevirtual

Implements libMesh::MeshBase.

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 257 of file unstructured_mesh.C.

{
  // 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 unsigned int                    key_type;
    typedef std::pair<Elem *, unsigned char> val_type;
    typedef std::pair<key_type, val_type>   key_val_pair;
 
    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
                const unsigned int key = element->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
                        //
                        // We need special tests here for 1D:
                        // since parents and children have an equal
                        // side (i.e. a node), we need to check
                        // ns != ms, and we also check level() to
                        // avoid setting our neighbor pointer to
                        // any of our neighbor's descendants
                        if ((*my_side == *their_side) &&
                            (element->level() == neighbor->level()) &&
                            ((element->dim() != 1) || (ns != ms)))
                          {
                            // 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
                key_val_pair kvp;
 
                kvp.first         = key;
                kvp.second.first  = element;
                kvp.second.second = cast_int<unsigned char>(ms);
                side_to_elem_map.insert (kvp);
              }
          }
      }
  }
 
#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->centroid()
                                     << ", Bad neighbor center = " << neigh->centroid() << 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
}

References libMesh::Elem::active(), libMesh::Elem::ancestor(), libMesh::as_range(), libMesh::Elem::centroid(), libMesh::Elem::child_ptr(), libMesh::Elem::child_ref_range(), libMesh::MeshBase::element_ptr_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::MeshBase::level_elements_begin(), libMesh::MeshBase::level_elements_end(), 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::which_child_am_i(), and libMesh::NameBasedIO::write().

Referenced by libMesh::TriangleWrapper::copy_tri_to_mesh(), and redistribute().

fix_broken_node_and_element_numbering()

void libMesh::DistributedMesh::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 1365 of file distributed_mesh.C.

{
  // We need access to iterators for the underlying containers,
  // not the mapvector<> reimplementations.
  mapvector<Node *,dof_id_type>::maptype & nodes = this->_nodes;
  mapvector<Elem *,dof_id_type>::maptype & elems = this->_elements;
 
  // Nodes first
  for (auto & pr : nodes)
    if (pr.second != nullptr)
      pr.second->set_id() = pr.first;
 
  // Elements next
  for (const auto & pr : elems)
    if (pr.second != nullptr)
      pr.second->set_id() = pr.first;
}

References _elements, and _nodes.

flagged_elements_begin() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::flagged_elements_begin ( unsigned char  rflag ) const

overridevirtual

Implements libMesh::MeshBase.

flagged_elements_begin() [2/2]

virtual element_iterator libMesh::DistributedMesh::flagged_elements_begin ( unsigned char  rflag )

overridevirtual

Iterate over all elements with a specified refinement flag.

Implements libMesh::MeshBase.

flagged_elements_end() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::flagged_elements_end ( unsigned char  rflag ) const

overridevirtual

Implements libMesh::MeshBase.

flagged_elements_end() [2/2]

virtual element_iterator libMesh::DistributedMesh::flagged_elements_end ( unsigned char  rflag )

overridevirtual

Implements libMesh::MeshBase.

flagged_pid_elements_begin() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::flagged_pid_elements_begin ( unsigned char  rflag, processor_id_type  pid  ) const

overridevirtual

Implements libMesh::MeshBase.

flagged_pid_elements_begin() [2/2]

virtual element_iterator libMesh::DistributedMesh::flagged_pid_elements_begin ( unsigned char  rflag, processor_id_type  pid  )

overridevirtual

Iterate over all elements with a specified refinement flag on a specified processor.

Implements libMesh::MeshBase.

flagged_pid_elements_end() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::flagged_pid_elements_end ( unsigned char  rflag, processor_id_type  pid  ) const

overridevirtual

Implements libMesh::MeshBase.

flagged_pid_elements_end() [2/2]

virtual element_iterator libMesh::DistributedMesh::flagged_pid_elements_end ( unsigned char  rflag, processor_id_type  pid  )

overridevirtual

Implements libMesh::MeshBase.

gather_to_zero()

void libMesh::DistributedMesh::gather_to_zero ( )

overridevirtual

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

Reimplemented from libMesh::MeshBase.

Definition at line 1526 of file distributed_mesh.C.

{
  if (_is_serial_on_proc_0)
    return;
 
  _is_serial_on_proc_0 = true;
  MeshCommunication().gather(0, *this);
}

References _is_serial_on_proc_0, and libMesh::MeshBase::MeshCommunication.

get_boundary_info() [1/2]

BoundaryInfo& libMesh::MeshBase::get_boundary_info ( )

inlineinherited

Writable information about boundary ids on the mesh.

Definition at line 137 of file mesh_base.h.

{ return *boundary_info; }

References libMesh::MeshBase::boundary_info.

get_boundary_info() [2/2]

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

inlineinherited

The information about boundary ids on the mesh.

Definition at line 132 of file mesh_base.h.

{ return *boundary_info; }

References libMesh::MeshBase::boundary_info.

Referenced by libMesh::MeshRefinement::_coarsen_elements(), libMesh::MeshTools::Subdivision::add_boundary_ghosts(), libMesh::RBConstruction::add_scaled_matrix_and_vector(), libMesh::UnstructuredMesh::all_first_order(), libMesh::UnstructuredMesh::all_second_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(), AssemblyF0::boundary_assembly(), AssemblyA1::boundary_assembly(), AssemblyF1::boundary_assembly(), AssemblyF2::boundary_assembly(), AssemblyA2::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::TetGenMeshInterface::delete_2D_hull_elements(), libMesh::ReplicatedMesh::delete_elem(), delete_elem(), libMesh::ReplicatedMesh::delete_node(), delete_node(), libMesh::MeshCommunication::delete_remote_elements(), DistributedMesh(), libMesh::MeshTools::Modification::flatten(), libMesh::UNVIO::groups_in(), LinearElasticityWithContact::initialize_contact_load_paths(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), main(), AugmentSparsityOnInterface::mesh_reinit(), libMesh::Parallel::Packing< const Node * >::pack(), libMesh::Parallel::Packing< const Elem * >::pack(), libMesh::Parallel::Packing< const Node * >::packable_size(), libMesh::Parallel::Packing< const Elem * >::packable_size(), libMesh::TetGenMeshInterface::pointset_convexhull(), libMesh::Nemesis_IO::prepare_to_write_nodal_data(), libMesh::AbaqusIO::read(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::CheckpointIO::read_bcs(), libMesh::CheckpointIO::read_header(), libMesh::GmshIO::read_mesh(), libMesh::CheckpointIO::read_nodesets(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::ReplicatedMesh::renumber_nodes_and_elements(), renumber_nodes_and_elements(), libMesh::ReplicatedMesh::ReplicatedMesh(), libMesh::ReplicatedMesh::stitching_helper(), libMesh::BoundaryInfo::sync(), AllTriTest::test_helper_2D(), AllTriTest::test_helper_3D(), SystemsTest::testBoundaryProjectCube(), BoundaryInfoTest::testEdgeBoundaryConditions(), BoundaryInfoTest::testMesh(), BoundaryInfoTest::testShellFaceConstraints(), WriteEdgesetData::testWrite(), WriteSidesetData::testWrite(), libMesh::Parallel::Packing< Node * >::unpack(), libMesh::Parallel::Packing< Elem * >::unpack(), libMesh::FroIO::write(), libMesh::Nemesis_IO::write(), libMesh::ExodusII_IO::write(), libMesh::XdrIO::write(), libMesh::CheckpointIO::write(), libMesh::GmshIO::write_mesh(), libMesh::XdrIO::write_serialized_bcs_helper(), and libMesh::XdrIO::write_serialized_nodesets().

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

{
  return _count_lower_dim_elems_in_point_locator;
}

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

get_elem_integer_index()

unsigned int libMesh::MeshBase::get_elem_integer_index ( const std::string &  name ) const

inherited

Definition at line 224 of file mesh_base.C.

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

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

get_elem_integer_name()

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

inlineinherited

Definition at line 818 of file mesh_base.h.

  { return _elem_integer_names[i]; }

References libMesh::MeshBase::_elem_integer_names.

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

get_id_by_name()

subdomain_id_type libMesh::MeshBase::get_id_by_name ( const std::string &  name ) const

inherited

Returns

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

Definition at line 737 of file mesh_base.C.

{
  // Linear search over the map values.
  std::map<subdomain_id_type, std::string>::const_iterator
    iter = _block_id_to_name.begin(),
    end_iter = _block_id_to_name.end();
 
  for ( ; iter != end_iter; ++iter)
    if (iter->second == name)
      return iter->first;
 
  // If we made it here without returning, we don't have a subdomain
  // with the requested name, so return Elem::invalid_subdomain_id.
  return Elem::invalid_subdomain_id;
}

References libMesh::Quality::name().

get_info()

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

inherited

Returns

A string containing relevant information about the mesh.

Definition at line 551 of file mesh_base.C.

{
  std::ostringstream oss;
 
  oss << " Mesh Information:"                                  << '\n';
 
  if (!_elem_dims.empty())
    {
      oss << "  elem_dimensions()={";
      std::copy(_elem_dims.begin(),
                --_elem_dims.end(), // --end() is valid if the set is non-empty
                std::ostream_iterator<unsigned int>(oss, ", "));
      oss << cast_int<unsigned int>(*_elem_dims.rbegin());
      oss << "}\n";
    }
 
  oss << "  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
      << "    n_active_elem()="   << this->n_active_elem()     << '\n'
#endif
      << "  n_subdomains()="      << static_cast<std::size_t>(this->n_subdomains()) << '\n'
      << "  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';
 
  return oss.str();
}

References libMesh::MeshTools::n_elem(), n_nodes, and libMesh::n_threads().

get_node_integer_index()

unsigned int libMesh::MeshBase::get_node_integer_index ( const std::string &  name ) const

inherited

Definition at line 295 of file mesh_base.C.

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

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

get_node_integer_name()

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

inlineinherited

Definition at line 915 of file mesh_base.h.

  { return _node_integer_names[i]; }

References libMesh::MeshBase::_node_integer_names.

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

get_point_locator_close_to_point_tol()

Real libMesh::MeshBase::get_point_locator_close_to_point_tol ( ) const

inherited

Definition at line 919 of file mesh_base.C.

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

  { return _block_id_to_name; }

References libMesh::MeshBase::_block_id_to_name.

Referenced by DistributedMesh(), libMesh::ReplicatedMesh::ReplicatedMesh(), libMesh::XdrIO::write_serialized_subdomain_names(), and libMesh::CheckpointIO::write_subdomain_names().

ghost_elements_begin() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::ghost_elements_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

ghost_elements_begin() [2/2]

virtual element_iterator libMesh::DistributedMesh::ghost_elements_begin ( )

overridevirtual

Iterate over "ghost" elements in the Mesh.

A ghost element is one which is not local, but is semilocal.

Implements libMesh::MeshBase.

ghost_elements_end() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::ghost_elements_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

ghost_elements_end() [2/2]

virtual element_iterator libMesh::DistributedMesh::ghost_elements_end ( )

overridevirtual

Implements libMesh::MeshBase.

ghosting_functors_begin()

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

inlineinherited

Beginning of range of ghosting functors.

Definition at line 1113 of file mesh_base.h.

  { return _ghosting_functors.begin(); }

References libMesh::MeshBase::_ghosting_functors.

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

ghosting_functors_end()

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

inlineinherited

End of range of ghosting functors.

Definition at line 1119 of file mesh_base.h.

  { return _ghosting_functors.end(); }

References libMesh::MeshBase::_ghosting_functors.

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

has_elem_integer()

bool libMesh::MeshBase::has_elem_integer ( const std::string &  name ) const

inherited

Definition at line 236 of file mesh_base.C.

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

References libMesh::Quality::name().

has_node_integer()

bool libMesh::MeshBase::has_node_integer ( const std::string &  name ) const

inherited

Definition at line 307 of file mesh_base.C.

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

References libMesh::Quality::name().

insert_elem()

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

overridevirtual

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 540 of file distributed_mesh.C.

{
  if (_elements[e->id()])
    this->delete_elem(_elements[e->id()]);
 
#ifdef LIBMESH_ENABLE_UNIQUE_ID
  if (!e->valid_unique_id())
    {
      if (processor_id() == e->processor_id())
        {
          e->set_unique_id() = _next_unique_id;
          _next_unique_id += this->n_processors() + 1;
        }
      else
        {
          e->set_unique_id() = _next_unpartitioned_unique_id;
          _next_unpartitioned_unique_id += this->n_processors() + 1;
        }
    }
#endif
 
  // Try to make the cached elem data more accurate
  processor_id_type elem_procid = e->processor_id();
  if (elem_procid == this->processor_id() ||
      elem_procid == DofObject::invalid_processor_id)
    _n_elem++;
 
  _elements[e->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());
 
  // 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;
}

References libMesh::MeshBase::_elem_integer_names, _elements, _n_elem, libMesh::MeshBase::_next_unique_id, _next_unpartitioned_unique_id, libMesh::DofObject::add_extra_integers(), libMesh::MeshBase::default_mapping_data(), libMesh::MeshBase::default_mapping_type(), delete_elem(), libMesh::DofObject::id(), libMesh::DofObject::invalid_processor_id, libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), libMesh::Elem::set_mapping_data(), libMesh::Elem::set_mapping_type(), libMesh::DofObject::set_unique_id(), and libMesh::DofObject::valid_unique_id().

insert_node()

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

overridevirtual

Calls add_node().

Implements libMesh::MeshBase.

Definition at line 761 of file distributed_mesh.C.

{
  return DistributedMesh::add_node(n);
}

References add_node().

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

  { return _is_prepared; }

References libMesh::MeshBase::_is_prepared.

Referenced by libMesh::MeshRefinement::_refine_elements(), and libMesh::DofMap::create_dof_constraints().

is_replicated()

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

inlineoverridevirtual

Returns

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

Reimplemented from libMesh::MeshBase.

Definition at line 141 of file distributed_mesh.h.

  { return false; }

is_serial()

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

inlineoverridevirtual

Returns

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

Reimplemented from libMesh::MeshBase.

Definition at line 119 of file distributed_mesh.h.

  { return _is_serial; }

References _is_serial.

Referenced by redistribute().

is_serial_on_zero()

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

inlineoverridevirtual

Returns

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

Reimplemented from libMesh::MeshBase.

Definition at line 126 of file distributed_mesh.h.

  { return _is_serial || _is_serial_on_proc_0; }

References _is_serial, and _is_serial_on_proc_0.

level_elements_begin() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::level_elements_begin ( unsigned int  level ) const

overridevirtual

Implements libMesh::MeshBase.

level_elements_begin() [2/2]

virtual element_iterator libMesh::DistributedMesh::level_elements_begin ( unsigned int  level )

overridevirtual

Iterate over elements of a given level.

Implements libMesh::MeshBase.

level_elements_end() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::level_elements_end ( unsigned int  level ) const

overridevirtual

Implements libMesh::MeshBase.

level_elements_end() [2/2]

virtual element_iterator libMesh::DistributedMesh::level_elements_end ( unsigned int  level )

overridevirtual

Implements libMesh::MeshBase.

libmesh_assert_valid_parallel_flags()

void libMesh::DistributedMesh::libmesh_assert_valid_parallel_flags

(

)

const

Verify refinement_flag and p_refinement_flag consistency of our elements containers.

Calls libmesh_assert() on each possible failure.

Definition at line 999 of file distributed_mesh.C.

{
#if defined(LIBMESH_ENABLE_AMR) && !defined(NDEBUG)
  // This function must be run on all processors at once
  parallel_object_only();
 
  dof_id_type pmax_elem_id = this->parallel_max_elem_id();
 
  for (dof_id_type i=0; i != pmax_elem_id; ++i)
    {
      Elem * el = _elements[i]; // Returns nullptr if there's no map entry
 
      unsigned int refinement_flag   = el ?
        static_cast<unsigned int> (el->refinement_flag()) : libMesh::invalid_uint;
      unsigned int p_refinement_flag = el ?
        static_cast<unsigned int> (el->p_refinement_flag()) : libMesh::invalid_uint;
 
      libmesh_assert(this->comm().semiverify(el ? &refinement_flag : nullptr));
 
      // p refinement flags aren't always kept correct on inactive
      // ghost elements
      libmesh_assert(this->comm().semiverify((el && el->active()) ? &p_refinement_flag : nullptr));
    }
#endif // LIBMESH_ENABLE_AMR
}

References _elements, libMesh::Elem::active(), libMesh::ParallelObject::comm(), libMesh::invalid_uint, libMesh::libmesh_assert(), libMesh::Elem::p_refinement_flag(), parallel_max_elem_id(), and libMesh::Elem::refinement_flag().

Referenced by allgather(), delete_remote_elements(), and renumber_nodes_and_elements().

libmesh_assert_valid_parallel_ids()

void libMesh::DistributedMesh::libmesh_assert_valid_parallel_ids ( ) const

overridevirtual

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

Calls libmesh_assert() on each possible failure.

Reimplemented from libMesh::MeshBase.

Definition at line 968 of file distributed_mesh.C.

{
  this->libmesh_assert_valid_parallel_object_ids (this->_elements);
  this->libmesh_assert_valid_parallel_object_ids (this->_nodes);
}

References _elements, _nodes, and libmesh_assert_valid_parallel_object_ids().

Referenced by libMesh::BoundaryInfo::add_elements(), allgather(), delete_remote_elements(), and renumber_nodes_and_elements().

libmesh_assert_valid_parallel_object_ids()

template<typename T >

void libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids

(

const mapvector< T *, dof_id_type > &

objects

)

const

Verify id, processor_id, and if applicable unique_id consistency of a parallel objects container.

Calls libmesh_assert() on each possible failure in that container.

Definition at line 912 of file distributed_mesh.C.

{
  // This function must be run on all processors at once
  parallel_object_only();
 
  const dof_id_type pmax_node_id = this->parallel_max_node_id();
  const dof_id_type pmax_elem_id = this->parallel_max_elem_id();
  const dof_id_type pmax_id = std::max(pmax_node_id, pmax_elem_id);
 
  for (dof_id_type i=0; i != pmax_id; ++i)
    {
      T * obj = objects[i]; // Returns nullptr if there's no map entry
 
      // Local lookups by id should return the requested object
      libmesh_assert(!obj || obj->id() == i);
 
      // All processors with an object should agree on id
#ifndef NDEBUG
      const dof_id_type dofid = obj && obj->valid_id() ?
        obj->id() : DofObject::invalid_id;
      libmesh_assert(this->comm().semiverify(obj ? &dofid : nullptr));
#endif
 
      // All processors with an object should agree on processor id
      const dof_id_type procid = obj && obj->valid_processor_id() ?
        obj->processor_id() : DofObject::invalid_processor_id;
      libmesh_assert(this->comm().semiverify(obj ? &procid : nullptr));
 
      dof_id_type min_procid = procid;
      this->comm().min(min_procid);
 
      // Either:
      // 1.) I own this elem (min_procid == this->processor_id()) *and* I have a valid pointer to it (obj != nullptr)
      // or
      // 2.) I don't own this elem (min_procid != this->processor_id()).  (In this case I may or may not have a valid pointer to it.)
 
      // Original assert logic
      // libmesh_assert (min_procid != this->processor_id() || obj);
 
      // More human-understandable logic...
      libmesh_assert (
                      ((min_procid == this->processor_id()) && obj)
                      ||
                      (min_procid != this->processor_id())
                      );
 
#if defined(LIBMESH_ENABLE_UNIQUE_ID) && !defined(NDEBUG)
      // All processors with an object should agree on unique id
      const unique_id_type uniqueid = obj ? obj->unique_id() : 0;
      libmesh_assert(this->comm().semiverify(obj ? &uniqueid : nullptr));
#endif
    }
}

References libMesh::ParallelObject::comm(), libMesh::DofObject::invalid_id, libMesh::DofObject::invalid_processor_id, libMesh::libmesh_assert(), parallel_max_elem_id(), parallel_max_node_id(), and libMesh::ParallelObject::processor_id().

Referenced by libmesh_assert_valid_parallel_ids().

libmesh_assert_valid_parallel_p_levels()

void libMesh::DistributedMesh::libmesh_assert_valid_parallel_p_levels

(

)

const

Verify p_level consistency of our elements containers.

Calls libmesh_assert() on each possible failure.

Definition at line 976 of file distributed_mesh.C.

{
#ifndef NDEBUG
  // This function must be run on all processors at once
  parallel_object_only();
 
  dof_id_type pmax_elem_id = this->parallel_max_elem_id();
 
  for (dof_id_type i=0; i != pmax_elem_id; ++i)
    {
      Elem * el = _elements[i]; // Returns nullptr if there's no map entry
 
      unsigned int p_level = el ?  (el->p_level()) : libMesh::invalid_uint;
 
      // All processors with an active element should agree on p level
      libmesh_assert(this->comm().semiverify((el && el->active()) ? &p_level : nullptr));
    }
#endif
}

References _elements, libMesh::Elem::active(), libMesh::ParallelObject::comm(), libMesh::invalid_uint, libMesh::libmesh_assert(), libMesh::Elem::p_level(), and parallel_max_elem_id().

Referenced by renumber_nodes_and_elements().

local_elements_begin() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::local_elements_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

local_elements_begin() [2/2]

virtual element_iterator libMesh::DistributedMesh::local_elements_begin ( )

overridevirtual

Implements libMesh::MeshBase.

local_elements_end() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::local_elements_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

local_elements_end() [2/2]

virtual element_iterator libMesh::DistributedMesh::local_elements_end ( )

overridevirtual

Implements libMesh::MeshBase.

local_level_elements_begin() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::local_level_elements_begin ( unsigned int  level ) const

overridevirtual

Implements libMesh::MeshBase.

local_level_elements_begin() [2/2]

virtual element_iterator libMesh::DistributedMesh::local_level_elements_begin ( unsigned int  level )

overridevirtual

Implements libMesh::MeshBase.

local_level_elements_end() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::local_level_elements_end ( unsigned int  level ) const

overridevirtual

Implements libMesh::MeshBase.

local_level_elements_end() [2/2]

virtual element_iterator libMesh::DistributedMesh::local_level_elements_end ( unsigned int  level )

overridevirtual

Implements libMesh::MeshBase.

local_node_ptr_range() [1/2]

virtual SimpleRange<const_node_iterator> libMesh::DistributedMesh::local_node_ptr_range ( ) const

inlineoverridevirtual

Implements libMesh::MeshBase.

Definition at line 514 of file distributed_mesh.h.

{ return {local_nodes_begin(), local_nodes_end()}; }

References local_nodes_begin(), and local_nodes_end().

local_node_ptr_range() [2/2]

virtual SimpleRange<node_iterator> libMesh::DistributedMesh::local_node_ptr_range ( )

inlineoverridevirtual

Implements libMesh::MeshBase.

Definition at line 513 of file distributed_mesh.h.

{ return {local_nodes_begin(), local_nodes_end()}; }

References local_nodes_begin(), and local_nodes_end().

local_nodes_begin() [1/2]

virtual const_node_iterator libMesh::DistributedMesh::local_nodes_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

local_nodes_begin() [2/2]

virtual node_iterator libMesh::DistributedMesh::local_nodes_begin ( )

overridevirtual

Iterate over local nodes (nodes whose processor_id() matches the current processor).

Implements libMesh::MeshBase.

Referenced by local_node_ptr_range(), and main().

local_nodes_end() [1/2]

virtual const_node_iterator libMesh::DistributedMesh::local_nodes_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

local_nodes_end() [2/2]

virtual node_iterator libMesh::DistributedMesh::local_nodes_end ( )

overridevirtual

Implements libMesh::MeshBase.

Referenced by local_node_ptr_range().

local_not_level_elements_begin() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::local_not_level_elements_begin ( unsigned int  level ) const

overridevirtual

Implements libMesh::MeshBase.

local_not_level_elements_begin() [2/2]

virtual element_iterator libMesh::DistributedMesh::local_not_level_elements_begin ( unsigned int  level )

overridevirtual

Implements libMesh::MeshBase.

local_not_level_elements_end() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::local_not_level_elements_end ( unsigned int  level ) const

overridevirtual

Implements libMesh::MeshBase.

local_not_level_elements_end() [2/2]

virtual element_iterator libMesh::DistributedMesh::local_not_level_elements_end ( unsigned int  level )

overridevirtual

Implements libMesh::MeshBase.

max_elem_id()

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

inlineoverridevirtual

Returns

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

Implements libMesh::MeshBase.

Definition at line 234 of file distributed_mesh.h.

{ return _max_elem_id; }

References _max_elem_id.

Referenced by allgather(), delete_remote_elements(), DistributedMesh(), and renumber_nodes_and_elements().

max_node_id()

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

inlineoverridevirtual

Returns

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

Implements libMesh::MeshBase.

Definition at line 230 of file distributed_mesh.h.

{ return _max_node_id; }

References _max_node_id.

Referenced by allgather(), delete_remote_elements(), DistributedMesh(), and renumber_nodes_and_elements().

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

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

References libMesh::MeshBase::_elem_integer_names, and libMesh::MeshBase::_node_integer_names.

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

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. If we ever support multi-dimensional meshes (e.g. hexes and quads in the same mesh) then this will return the largest such dimension.

Definition at line 135 of file mesh_base.C.

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

References libMesh::MeshBase::_elem_dims.

Referenced by libMesh::HPCoarsenTest::add_projection(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), assemble(), LinearElasticity::assemble(), assemble_1D(), AssembleOptimization::assemble_A_and_F(), assemble_biharmonic(), assemble_cd(), assemble_elasticity(), assemble_ellipticdg(), assemble_helmholtz(), assemble_laplace(), assemble_mass(), assemble_matrices(), assemble_poisson(), assemble_SchroedingerEquation(), assemble_shell(), assemble_stokes(), assemble_wave(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::EquationSystems::build_variable_names(), compute_jacobian(), compute_residual(), LinearElasticityWithContact::compute_stresses(), LinearElasticity::compute_stresses(), compute_stresses(), LargeDeformationElasticity::compute_stresses(), libMesh::DofMap::create_dof_constraints(), libMesh::MeshTools::Modification::distort(), SolidSystem::element_time_derivative(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::ReplicatedMesh::get_boundary_points(), libMesh::LaplaceMeshSmoother::init(), libMesh::PointLocatorTree::init(), SolidSystem::init_data(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::RBEIMAssembly::initialize_fe(), integrate_function(), LaplaceYoung::jacobian(), LargeDeformationElasticity::jacobian(), main(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::GMVIO::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::MeshTools::Modification::smooth(), MeshSpatialDimensionTest::test1D(), MeshSpatialDimensionTest::test2D(), InfFERadialTest::testSingleOrder(), libMesh::BoundaryVolumeSolutionTransfer::transfer(), libMesh::DTKSolutionTransfer::transfer(), libMesh::DofMap::use_coupled_neighbor_dofs(), 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().

n_active_elem()

dof_id_type libMesh::DistributedMesh::n_active_elem ( ) const

overridevirtual

Returns

The number of active elements in the mesh.

Implemented in terms of active_element_iterators.

Implements libMesh::MeshBase.

Definition at line 1385 of file distributed_mesh.C.

{
  parallel_object_only();
 
  // Get local active elements first
  dof_id_type active_elements =
    static_cast<dof_id_type>(std::distance (this->active_local_elements_begin(),
                                            this->active_local_elements_end()));
  this->comm().sum(active_elements);
 
  // Then add unpartitioned active elements, which should exist on
  // every processor
  active_elements +=
    static_cast<dof_id_type>(std::distance
                             (this->active_pid_elements_begin(DofObject::invalid_processor_id),
                              this->active_pid_elements_end(DofObject::invalid_processor_id)));
  return active_elements;
}

References active_local_elements_begin(), active_local_elements_end(), active_pid_elements_begin(), active_pid_elements_end(), libMesh::ParallelObject::comm(), distance(), and libMesh::DofObject::invalid_processor_id.

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

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

References distance().

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

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

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

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

Referenced by libMesh::VTKIO::cells_to_vtk().

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

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

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

n_elem()

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

inlineoverridevirtual

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 232 of file distributed_mesh.h.

{ return _n_elem; }

References _n_elem.

Referenced by allgather(), delete_remote_elements(), DistributedMesh(), renumber_nodes_and_elements(), SlitMeshTest::testMesh(), and MeshInputTest::testMeshMoveConstructor().

n_elem_integers()

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

inlineinherited

Definition at line 829 of file mesh_base.h.

{ return _elem_integer_names.size(); }

References libMesh::MeshBase::_elem_integer_names.

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

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

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

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

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

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

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

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

Referenced by libMesh::DTKAdapter::DTKAdapter(), and parallel_n_elem().

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

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

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

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

n_node_integers()

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

inlineinherited

Definition at line 926 of file mesh_base.h.

{ return _node_integer_names.size(); }

References libMesh::MeshBase::_node_integer_names.

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

n_nodes()

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

inlineoverridevirtual

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 229 of file distributed_mesh.h.

{ return _n_nodes; }

References _n_nodes.

Referenced by allgather(), delete_remote_elements(), DistributedMesh(), renumber_nodes_and_elements(), and SlitMeshTest::testMesh().

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

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

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

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

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

  { return _n_parts; }

References libMesh::MeshBase::_n_parts.

Referenced by libMesh::BoundaryInfo::sync(), libMesh::NameBasedIO::write(), libMesh::GMVIO::write_ascii_new_impl(), and libMesh::GMVIO::write_ascii_old_impl().

n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const

inlineinherited

Returns

The number of processors in the group.

Definition at line 100 of file parallel_object.h.

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

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::DofMap::add_constraints_to_send_list(), libMesh::PetscDMWrapper::add_dofs_to_section(), add_elem(), libMesh::DofMap::add_neighbors_to_send_list(), add_node(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEMSystem::assembly(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), clear(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::UnstructuredMesh::create_pid_mesh(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::EnsightIO::EnsightIO(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::Nemesis_IO_Helper::initialize(), 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::partition(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::DofMap::prepare_send_list(), 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(), renumber_dof_objects(), OverlappingFunctorTest::run_partitioner_test(), libMesh::DofMap::scatter_constraints(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), CheckpointIOTest::testSplitter(), WriteVecAndScalar::testWrite(), libMesh::MeshRefinement::uniformly_coarsen(), update_parallel_id_counts(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::VTKIO::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().

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

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

Referenced by libMesh::XdrIO::write(), and libMesh::NameBasedIO::write_nodal_data().

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

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

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

Referenced by libMesh::UnstructuredMesh::all_second_order(), and parallel_n_elem().

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

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

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

Referenced by parallel_n_nodes().

next_unique_id()

unique_id_type libMesh::MeshBase::next_unique_id ( )

inlineinherited

Returns

The next unique id to be used.

Definition at line 322 of file mesh_base.h.

{ return _next_unique_id; }

References libMesh::MeshBase::_next_unique_id.

node() [1/2]

virtual Node& libMesh::MeshBase::node ( 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 485 of file mesh_base.h.

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

References libMesh::MeshBase::node_ptr().

node() [2/2]

virtual const Node& libMesh::MeshBase::node ( 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 471 of file mesh_base.h.

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

References libMesh::MeshBase::node_ptr().

Referenced by libMesh::UnstructuredMesh::all_first_order(), libMesh::ReplicatedMesh::clear(), clear(), libMesh::ReplicatedMesh::get_boundary_points(), libMesh::ReplicatedMesh::renumber_nodes_and_elements(), renumber_nodes_and_elements(), and libMesh::ReplicatedMesh::stitching_helper().

node_ptr() [1/2]

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

overridevirtual

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 328 of file distributed_mesh.C.

{
  libmesh_assert(_nodes[i]);
  libmesh_assert_equal_to (_nodes[i]->id(), i);
 
  return _nodes[i];
}

References _nodes, and libMesh::libmesh_assert().

Referenced by SlitMeshTest::build_mesh().

node_ptr() [2/2]

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

overridevirtual

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 339 of file distributed_mesh.C.

{
  libmesh_assert(_nodes[i]);
  libmesh_assert_equal_to (_nodes[i]->id(), i);
 
  return _nodes[i];
}

References _nodes, and libMesh::libmesh_assert().

node_ptr_range() [1/2]

virtual SimpleRange<const_node_iterator> libMesh::DistributedMesh::node_ptr_range ( ) const

inlineoverridevirtual

Implements libMesh::MeshBase.

Definition at line 502 of file distributed_mesh.h.

{ return {nodes_begin(), nodes_end()}; }

References nodes_begin(), and nodes_end().

node_ptr_range() [2/2]

virtual SimpleRange<node_iterator> libMesh::DistributedMesh::node_ptr_range ( )

inlineoverridevirtual

Implements libMesh::MeshBase.

Definition at line 501 of file distributed_mesh.h.

{ return {nodes_begin(), nodes_end()}; }

References nodes_begin(), and nodes_end().

Referenced by RationalMapTest< elem_type >::setUp(), and WriteVecAndScalar::testWrite().

node_ref() [1/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 459 of file mesh_base.h.

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

References libMesh::MeshBase::node_ptr().

node_ref() [2/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 451 of file mesh_base.h.

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

References libMesh::MeshBase::node_ptr().

Referenced by libMesh::SyncNodalPositions::act_on_data(), LinearElasticityWithContact::add_contact_edge_elements(), libMesh::DynaIO::add_spline_constraints(), assemble_matrix_and_rhs(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::DTKAdapter::DTKAdapter(), fill_dirichlet_bc(), main(), libMesh::ReplicatedMesh::point(), point(), libMesh::XdrIO::read_serialized_nodes(), LinearElasticityWithContact::residual_and_jacobian(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::MeshTools::Modification::smooth(), libMesh::ReplicatedMesh::stitching_helper(), libMesh::DTKAdapter::update_variable_values(), and libMesh::GmshIO::write_mesh().

nodes_begin() [1/2]

virtual const_node_iterator libMesh::DistributedMesh::nodes_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

nodes_begin() [2/2]

virtual node_iterator libMesh::DistributedMesh::nodes_begin ( )

overridevirtual

Node iterator accessor functions.

Implements libMesh::MeshBase.

Referenced by node_ptr_range().

nodes_end() [1/2]

virtual const_node_iterator libMesh::DistributedMesh::nodes_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

nodes_end() [2/2]

virtual node_iterator libMesh::DistributedMesh::nodes_end ( )

overridevirtual

Implements libMesh::MeshBase.

Referenced by node_ptr_range().

not_active_elements_begin() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::not_active_elements_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

not_active_elements_begin() [2/2]

virtual element_iterator libMesh::DistributedMesh::not_active_elements_begin ( )

overridevirtual

Implements libMesh::MeshBase.

not_active_elements_end() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::not_active_elements_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

not_active_elements_end() [2/2]

virtual element_iterator libMesh::DistributedMesh::not_active_elements_end ( )

overridevirtual

Implements libMesh::MeshBase.

not_ancestor_elements_begin() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::not_ancestor_elements_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

not_ancestor_elements_begin() [2/2]

virtual element_iterator libMesh::DistributedMesh::not_ancestor_elements_begin ( )

overridevirtual

Implements libMesh::MeshBase.

not_ancestor_elements_end() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::not_ancestor_elements_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

not_ancestor_elements_end() [2/2]

virtual element_iterator libMesh::DistributedMesh::not_ancestor_elements_end ( )

overridevirtual

Implements libMesh::MeshBase.

not_level_elements_begin() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::not_level_elements_begin ( unsigned int  level ) const

overridevirtual

Implements libMesh::MeshBase.

not_level_elements_begin() [2/2]

virtual element_iterator libMesh::DistributedMesh::not_level_elements_begin ( unsigned int  level )

overridevirtual

Implements libMesh::MeshBase.

not_level_elements_end() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::not_level_elements_end ( unsigned int  level ) const

overridevirtual

Implements libMesh::MeshBase.

not_level_elements_end() [2/2]

virtual element_iterator libMesh::DistributedMesh::not_level_elements_end ( unsigned int  level )

overridevirtual

Implements libMesh::MeshBase.

not_local_elements_begin() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::not_local_elements_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

not_local_elements_begin() [2/2]

virtual element_iterator libMesh::DistributedMesh::not_local_elements_begin ( )

overridevirtual

Implements libMesh::MeshBase.

not_local_elements_end() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::not_local_elements_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

not_local_elements_end() [2/2]

virtual element_iterator libMesh::DistributedMesh::not_local_elements_end ( )

overridevirtual

Implements libMesh::MeshBase.

not_subactive_elements_begin() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::not_subactive_elements_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

not_subactive_elements_begin() [2/2]

virtual element_iterator libMesh::DistributedMesh::not_subactive_elements_begin ( )

overridevirtual

Implements libMesh::MeshBase.

not_subactive_elements_end() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::not_subactive_elements_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

not_subactive_elements_end() [2/2]

virtual element_iterator libMesh::DistributedMesh::not_subactive_elements_end ( )

overridevirtual

Implements libMesh::MeshBase.

operator=() [1/2]

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

delete

Copy and move assignment are not allowed.

operator=() [2/2]

DistributedMesh& libMesh::DistributedMesh::operator= ( DistributedMesh &&  )

delete

own_node()

void libMesh::DistributedMesh::own_node ( Node &  n )

overridevirtual

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 from libMesh::MeshBase.

Definition at line 649 of file distributed_mesh.C.

{
  // This had better be a node in our mesh
  libmesh_assert(_nodes[n.id()] == &n);
 
  _nodes[n.id()] = nullptr;
 
  n.set_id(DofObject::invalid_id);
  n.processor_id() = this->processor_id();
 
  this->add_node(&n);
}

References _nodes, add_node(), libMesh::DofObject::id(), libMesh::DofObject::invalid_id, libMesh::libmesh_assert(), libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), and libMesh::DofObject::set_id().

parallel_max_elem_id()

dof_id_type libMesh::DistributedMesh::parallel_max_elem_id

(

)

const

Definition at line 233 of file distributed_mesh.C.

{
  // This function must be run on all processors at once
  parallel_object_only();
 
  dof_id_type max_local = 0;
 
  mapvector<Elem *,dof_id_type>::maptype::const_reverse_iterator
    rit = _elements.rbegin();
 
  const mapvector<Elem *,dof_id_type>::maptype::const_reverse_iterator
    rend = _elements.rend();
 
  // Look for the maximum element id.  Search backwards through
  // elements so we can break out early.  Beware of nullptr entries that
  // haven't yet been cleared from _elements.
  for (; rit != rend; ++rit)
    if (rit->second)
      {
        libmesh_assert_equal_to(rit->second->id(), rit->first);
        max_local = rit->first + 1;
        break;
      }
 
  this->comm().max(max_local);
  return max_local;
}

References _elements, and libMesh::ParallelObject::comm().

Referenced by allgather(), delete_remote_elements(), libmesh_assert_valid_parallel_flags(), libmesh_assert_valid_parallel_object_ids(), libmesh_assert_valid_parallel_p_levels(), renumber_nodes_and_elements(), and update_parallel_id_counts().

parallel_max_node_id()

dof_id_type libMesh::DistributedMesh::parallel_max_node_id

(

)

const

Definition at line 291 of file distributed_mesh.C.

{
  // This function must be run on all processors at once
  parallel_object_only();
 
  dof_id_type max_local = 0;
 
  mapvector<Node *,dof_id_type>::maptype::const_reverse_iterator
    rit = _nodes.rbegin();
 
  const mapvector<Node *,dof_id_type>::maptype::const_reverse_iterator
    rend = _nodes.rend();
 
  // Look for the maximum element id.  Search backwards through
  // elements so we can break out early.  Beware of nullptr entries that
  // haven't yet been cleared from _elements.
  for (; rit != rend; ++rit)
    if (rit->second)
      {
        libmesh_assert_equal_to(rit->second->id(), rit->first);
        max_local = rit->first + 1;
        break;
      }
 
  this->comm().max(max_local);
  return max_local;
}

References _nodes, and libMesh::ParallelObject::comm().

Referenced by allgather(), delete_remote_elements(), libmesh_assert_valid_parallel_object_ids(), renumber_nodes_and_elements(), and update_parallel_id_counts().

parallel_max_unique_id()

unique_id_type libMesh::DistributedMesh::parallel_max_unique_id ( ) const

overridevirtual

Returns

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

Implements libMesh::MeshBase.

Definition at line 264 of file distributed_mesh.C.

{
  // This function must be run on all processors at once
  parallel_object_only();
 
  unique_id_type max_local = std::max(_next_unique_id,
                                      _next_unpartitioned_unique_id);
  this->comm().max(max_local);
  return max_local;
}

References libMesh::MeshBase::_next_unique_id, _next_unpartitioned_unique_id, and libMesh::ParallelObject::comm().

Referenced by update_parallel_id_counts().

parallel_n_elem()

dof_id_type libMesh::DistributedMesh::parallel_n_elem ( ) const

overridevirtual

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 220 of file distributed_mesh.C.

{
  // This function must be run on all processors at once
  parallel_object_only();
 
  dof_id_type n_local = this->n_local_elem();
  this->comm().sum(n_local);
  n_local += this->n_unpartitioned_elem();
  return n_local;
}

References libMesh::ParallelObject::comm(), libMesh::MeshBase::n_local_elem(), and libMesh::MeshBase::n_unpartitioned_elem().

Referenced by allgather(), delete_remote_elements(), renumber_nodes_and_elements(), and update_parallel_id_counts().

parallel_n_nodes()

dof_id_type libMesh::DistributedMesh::parallel_n_nodes ( ) const

overridevirtual

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 278 of file distributed_mesh.C.

{
  // This function must be run on all processors at once
  parallel_object_only();
 
  dof_id_type n_local = this->n_local_nodes();
  this->comm().sum(n_local);
  n_local += this->n_unpartitioned_nodes();
  return n_local;
}

References libMesh::ParallelObject::comm(), libMesh::MeshBase::n_local_nodes(), and libMesh::MeshBase::n_unpartitioned_nodes().

Referenced by allgather(), delete_remote_elements(), renumber_nodes_and_elements(), and update_parallel_id_counts().

partition() [1/2]

void libMesh::MeshBase::partition ( )

inlineinherited

Definition at line 992 of file mesh_base.h.

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

References libMesh::ParallelObject::n_processors().

partition() [2/2]

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

virtualinherited

Call the default partitioner (currently metis_partition()).

Definition at line 599 of file mesh_base.C.

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

References libMesh::MeshTools::correct_node_proc_ids(), libMesh::ReferenceElem::get(), and libMesh::libmesh_assert().

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

partitioner()

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

inlinevirtualinherited

A partitioner to use at each prepare_for_use()

Definition at line 127 of file mesh_base.h.

{ return _partitioner; }

References libMesh::MeshBase::_partitioner.

Referenced by main(), libMesh::BoundaryInfo::sync(), MappedSubdomainPartitionerTest::testMappedSubdomainPartitioner(), and MeshInputTest::testMeshMoveConstructor().

pid_elements_begin() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::pid_elements_begin ( processor_id_type  proc_id ) const

overridevirtual

Implements libMesh::MeshBase.

pid_elements_begin() [2/2]

virtual element_iterator libMesh::DistributedMesh::pid_elements_begin ( processor_id_type  proc_id )

overridevirtual

Iterate over all elements with a specified processor id.

Implements libMesh::MeshBase.

pid_elements_end() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::pid_elements_end ( processor_id_type  proc_id ) const

overridevirtual

Implements libMesh::MeshBase.

pid_elements_end() [2/2]

virtual element_iterator libMesh::DistributedMesh::pid_elements_end ( processor_id_type  proc_id )

overridevirtual

Implements libMesh::MeshBase.

pid_nodes_begin() [1/2]

virtual const_node_iterator libMesh::DistributedMesh::pid_nodes_begin ( processor_id_type  proc_id ) const

overridevirtual

Implements libMesh::MeshBase.

pid_nodes_begin() [2/2]

virtual node_iterator libMesh::DistributedMesh::pid_nodes_begin ( processor_id_type  proc_id )

overridevirtual

Iterate over nodes with processor_id() == proc_id.

Implements libMesh::MeshBase.

pid_nodes_end() [1/2]

virtual const_node_iterator libMesh::DistributedMesh::pid_nodes_end ( processor_id_type  proc_id ) const

overridevirtual

Implements libMesh::MeshBase.

pid_nodes_end() [2/2]

virtual node_iterator libMesh::DistributedMesh::pid_nodes_end ( processor_id_type  proc_id )

overridevirtual

Implements libMesh::MeshBase.

point()

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

overridevirtual

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 321 of file distributed_mesh.C.

{
  return this->node_ref(i);
}

References libMesh::MeshBase::node_ref().

point_locator()

const PointLocatorBase & libMesh::MeshBase::point_locator ( ) const

inherited

Returns

A pointer to a PointLocatorBase object for this mesh, constructing a master PointLocator first if necessary.

Definition at line 652 of file mesh_base.C.

{
  libmesh_deprecated();
 
  if (_point_locator.get() == nullptr)
    {
      // PointLocator construction may not be safe within threads
      libmesh_assert(!Threads::in_threads);
 
      _point_locator = PointLocatorBase::build(TREE_ELEMENTS, *this);
 
      if (_point_locator_close_to_point_tol > 0.)
        _point_locator->set_close_to_point_tol(_point_locator_close_to_point_tol);
    }
 
  return *_point_locator;
}

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

prepare_for_use()

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

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

The argument to skip renumbering is now deprecated - to prevent a mesh from being renumbered, set allow_renumbering(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 318 of file mesh_base.C.

{
  LOG_SCOPE("prepare_for_use()", "MeshBase");
 
  parallel_object_only();
 
  libmesh_assert(this->comm().verify(this->is_serial()));
 
  // 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_dims() 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.
  //
  // We may currently change that by passing
  // skip_renumber_nodes_and_elements==true to this function, but we
  // should use the allow_renumbering() accessor instead.
  //
  // 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.
 
  if (skip_renumber_nodes_and_elements)
    {
      libmesh_deprecated();
      this->allow_renumbering(false);
    }
 
  // Mesh modification operations might not leave us with consistent
  // id counts, but our partitioner might need that consistency.
  if (!_skip_renumber_nodes_and_elements)
    this->renumber_nodes_and_elements();
  else
    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_dims();
 
  // 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.
  for (auto & gf : _ghosting_functors)
    {
      libmesh_assert(gf);
      gf->mesh_reinit();
    }
 
  // 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();
 
  if (!_skip_renumber_nodes_and_elements)
    this->renumber_nodes_and_elements();
 
  // The mesh is now prepared for use.
  _is_prepared = true;
 
#if defined(DEBUG) && defined(LIBMESH_ENABLE_UNIQUE_ID)
  MeshTools::libmesh_assert_valid_boundary_ids(*this);
  MeshTools::libmesh_assert_valid_unique_ids(*this);
#endif
}

References libMesh::libmesh_assert(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), and libMesh::MeshTools::libmesh_assert_valid_unique_ids().

Referenced by LinearElasticityWithContact::add_contact_edge_elements(), libMesh::UnstructuredMesh::all_first_order(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Subdivision::all_subdivision(), libMesh::MeshTools::Modification::all_tri(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::InfElemBuilder::build_inf_elem(), GetBoundaryPointsTest::build_mesh(), MixedDimensionMeshTest::build_mesh(), MeshfunctionDFEM::build_mesh(), SlitMeshTest::build_mesh(), MixedDimensionNonUniformRefinement::build_mesh(), MixedDimensionNonUniformRefinementTriangle::build_mesh(), MixedDimensionNonUniformRefinement3D::build_mesh(), libMesh::MeshRefinement::coarsen_elements(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::UnstructuredMesh::create_submesh(), libMesh::MeshTools::Modification::flatten(), main(), libMesh::MeshTools::Subdivision::prepare_subdivision_mesh(), libMesh::GMVIO::read(), libMesh::UnstructuredMesh::read(), libMesh::MeshRefinement::refine_and_coarsen_elements(), libMesh::MeshRefinement::refine_elements(), libMesh::ReplicatedMesh::stitching_helper(), libMesh::BoundaryInfo::sync(), MeshSpatialDimensionTest::test1D(), MeshSpatialDimensionTest::test2D(), SystemsTest::testBlockRestrictedVarNDofs(), SystemsTest::testDofCouplingWithVarGroups(), MeshInputTest::testDynaReadElem(), MeshInputTest::testDynaReadPatch(), MeshInputTest::testExodusCopyElementSolution(), MeshInputTest::testExodusWriteElementDataFromDiscontinuousNodalData(), EquationSystemsTest::testPostInitAddElem(), SystemsTest::testProjectMatrix3D(), EquationSystemsTest::testReinitWithNodeElem(), BoundaryInfoTest::testShellFaceConstraints(), WriteVecAndScalar::testWrite(), tetrahedralize_domain(), libMesh::TriangleInterface::triangulate(), libMesh::MeshRefinement::uniformly_coarsen(), and libMesh::MeshRefinement::uniformly_refine().

print_info()

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

inherited

Prints relevant information about the mesh.

Definition at line 585 of file mesh_base.C.

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

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

processor_id()

processor_id_type libMesh::ParallelObject::processor_id ( ) const

inlineinherited

Returns

The rank of this processor in the group.

Definition at line 106 of file parallel_object.h.

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

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::EquationSystems::_read_impl(), libMesh::PetscDMWrapper::add_dofs_to_section(), add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::DofMap::add_neighbors_to_send_list(), add_node(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEMSystem::assembly(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), clear(), 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_scalar_solution(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::ExodusII_IO_Helper::create(), delete_elem(), delete_node(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), DistributedMesh(), libMesh::DofMap::end_dof(), libMesh::DofMap::end_old_dof(), libMesh::EnsightIO::EnsightIO(), libMesh::RBEIMConstruction::evaluate_mesh_function(), libMesh::MeshFunction::find_element(), libMesh::MeshFunction::find_elements(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::DofMap::first_dof(), libMesh::DofMap::first_old_dof(), 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::DofMap::get_info(), libMesh::Nemesis_IO_Helper::get_init_global(), libMesh::Nemesis_IO_Helper::get_init_info(), libMesh::Nemesis_IO_Helper::get_loadbal_param(), libMesh::DofMap::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::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), 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(), insert_elem(), libMesh::DofMap::is_evaluable(), libMesh::SparsityPattern::Build::join(), libMesh::DofMap::last_dof(), libMesh::TransientRBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBEIMEvaluation::legacy_write_offline_data_to_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBSCMEvaluation::legacy_write_offline_data_to_files(), libMesh::RBEIMEvaluation::legacy_write_out_interpolation_points_elem(), 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_assert_valid_parallel_object_ids(), libMesh::DofMap::local_variable_indices(), main(), libMesh::MeshRefinement::make_coarsening_compatible(), AugmentSparsityOnInterface::mesh_reinit(), libMesh::MeshBase::n_active_local_elem(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::DofMap::n_local_dofs(), libMesh::System::n_local_dofs(), libMesh::MeshBase::n_local_elem(), libMesh::MeshBase::n_local_nodes(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::SparsityPattern::Build::operator()(), own_node(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::DofMap::print_dof_constraints(), 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::ExodusII_IO_Helper::read_elem_num_map(), libMesh::ExodusII_IO_Helper::read_global_values(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::System::read_header(), libMesh::RBEvaluation::read_in_vectors_from_multiple_files(), libMesh::System::read_legacy_data(), 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(), renumber_dof_objects(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::LaplaceMeshSmoother::smooth(), DefaultCouplingTest::testCoupling(), PointNeighborCouplingTest::testCoupling(), MeshInputTest::testDynaReadElem(), MeshInputTest::testDynaReadPatch(), MeshInputTest::testExodusCopyElementSolution(), MeshInputTest::testExodusWriteElementDataFromDiscontinuousNodalData(), SystemsTest::testProjectMatrix1D(), SystemsTest::testProjectMatrix2D(), SystemsTest::testProjectMatrix3D(), BoundaryInfoTest::testShellFaceConstraints(), CheckpointIOTest::testSplitter(), WriteVecAndScalar::testWrite(), libMesh::MeshTools::total_weight(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::Parallel::Packing< Node * >::unpack(), libMesh::Parallel::Packing< Elem * >::unpack(), update_parallel_id_counts(), libMesh::DTKAdapter::update_variable_values(), 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::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::VTKIO::write_nodal_data(), libMesh::UCDIO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data_discontinuous(), libMesh::ExodusII_IO_Helper::write_nodal_values(), libMesh::Nemesis_IO_Helper::write_nodesets(), libMesh::ExodusII_IO_Helper::write_nodesets(), libMesh::RBEvaluation::write_out_vectors(), 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().

query_elem() [1/2]

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

inlinevirtualinherited

Returns

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

Definition at line 609 of file mesh_base.h.

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

References libMesh::MeshBase::query_elem_ptr().

query_elem() [2/2]

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

inlinevirtualinherited

Returns

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

Definition at line 595 of file mesh_base.h.

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

References libMesh::MeshBase::query_elem_ptr().

query_elem_ptr() [1/2]

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

overridevirtual

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 404 of file distributed_mesh.C.

{
  std::map<dof_id_type, Elem *>::const_iterator it = _elements.find(i);
  if (it != _elements.end().it)
    {
      const Elem * e = it->second;
      libmesh_assert (!e || e->id() == i);
      return e;
    }
 
  return nullptr;
}

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

Referenced by SlitMeshTest::testMesh().

query_elem_ptr() [2/2]

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

overridevirtual

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 420 of file distributed_mesh.C.

{
  std::map<dof_id_type, Elem *>::const_iterator it = _elements.find(i);
  if (it != _elements.end().it)
    {
      Elem * e = _elements[i];
      libmesh_assert (!e || e->id() == i);
      return e;
    }
 
  return nullptr;
}

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

query_node_ptr() [1/2]

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

overridevirtual

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 350 of file distributed_mesh.C.

{
  std::map<dof_id_type, Node *>::const_iterator it = _nodes.find(i);
  if (it != _nodes.end().it)
    {
      const Node * n = it->second;
      libmesh_assert (!n || n->id() == i);
      return n;
    }
 
  return nullptr;
}

References _nodes, libMesh::DofObject::id(), and libMesh::libmesh_assert().

query_node_ptr() [2/2]

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

overridevirtual

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 366 of file distributed_mesh.C.

{
  std::map<dof_id_type, Node *>::const_iterator it = _nodes.find(i);
  if (it != _nodes.end().it)
    {
      Node * n = it->second;
      libmesh_assert (!n || n->id() == i);
      return n;
    }
 
  return nullptr;
}

References _nodes, libMesh::DofObject::id(), and libMesh::libmesh_assert().

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 620 of file unstructured_mesh.C.

{
  // 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") + 4 == name.size())
    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.
  this->prepare_for_use(/*skip_renumber (deprecated)*/ false,
                        skip_find_neighbors);
}

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

Referenced by ExtraIntegersTest::checkpoint_helper(), libMesh::RBEIMEvaluation::legacy_read_in_interpolation_points_elem(), main(), and SlitMeshRefinedSystemTest::testRestart().

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

{
  // This requires an inspection on every processor
  parallel_object_only();
 
  unsigned int max_proc_id=0;
 
  for (const auto & elem : this->active_local_element_ptr_range())
    max_proc_id = std::max(max_proc_id, static_cast<unsigned int>(elem->processor_id()));
 
  // The number of partitions is one more than the max processor ID.
  _n_parts = max_proc_id+1;
 
  this->comm().max(_n_parts);
 
  return _n_parts;
}

redistribute()

void libMesh::DistributedMesh::redistribute ( )

overridevirtual

Redistribute elements between processors.

This gets called automatically by the Partitioner, and is a no-op in the case of a serialized mesh.

Reimplemented from libMesh::MeshBase.

Definition at line 871 of file distributed_mesh.C.

{
  // If this is a truly parallel mesh, go through the redistribution/gather/delete remote steps
  if (!this->is_serial())
    {
      // Construct a MeshCommunication object to actually redistribute the nodes
      // and elements according to the partitioner, and then to re-gather the neighbors.
      MeshCommunication mc;
      mc.redistribute(*this);
 
      this->update_parallel_id_counts();
 
      // We probably had valid neighbors previously, so that a quality
      // new partitioning could be found, but we might not have valid
      // neighbor links on the newly-redistributed elements
      this->find_neighbors();
 
      // Is this necessary?  If we are called from prepare_for_use(), this will be called
      // anyway... but users can always call partition directly, in which case we do need
      // to call delete_remote_elements()...
      //
      // Regardless of whether it's necessary, it isn't safe.  We
      // haven't communicated new node processor_ids yet, and we can't
      // delete nodes until we do.
      // this->delete_remote_elements();
    }
}

References libMesh::UnstructuredMesh::find_neighbors(), is_serial(), libMesh::MeshCommunication::redistribute(), and update_parallel_id_counts().

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

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

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

renumber_dof_objects()

template<typename T >

dof_id_type libMesh::DistributedMesh::renumber_dof_objects

(

mapvector< T *, dof_id_type > &

objects

)

Renumber a parallel objects container.

Returns

The smallest globally unused id for that container.

Definition at line 1029 of file distributed_mesh.C.

{
  // This function must be run on all processors at once
  parallel_object_only();
 
  typedef typename mapvector<T *,dof_id_type>::veclike_iterator object_iterator;
 
  // In parallel we may not know what objects other processors have.
  // Start by figuring out how many
  dof_id_type unpartitioned_objects = 0;
 
  std::unordered_map<processor_id_type, dof_id_type>
    ghost_objects_from_proc;
 
  object_iterator it  = objects.begin();
  object_iterator end = objects.end();
 
  while (it != end)
    {
      T * obj = *it;
 
      // Remove any nullptr container entries while we're here.
      if (!obj)
        it = objects.erase(it);
      else
        {
          processor_id_type obj_procid = obj->processor_id();
          if (obj_procid == DofObject::invalid_processor_id)
            unpartitioned_objects++;
          else
            ghost_objects_from_proc[obj_procid]++;
 
          // Finally, increment the iterator
          ++it;
        }
    }
 
  std::vector<dof_id_type> objects_on_proc(this->n_processors(), 0);
  auto this_it = ghost_objects_from_proc.find(this->processor_id());
  this->comm().allgather
    ((this_it == ghost_objects_from_proc.end()) ?
     dof_id_type(0) : this_it->second, objects_on_proc);
 
#ifndef NDEBUG
  libmesh_assert(this->comm().verify(unpartitioned_objects));
  for (processor_id_type p=0, np=this->n_processors(); p != np; ++p)
    if (ghost_objects_from_proc.count(p))
      libmesh_assert_less_equal (ghost_objects_from_proc[p], objects_on_proc[p]);
    else
      libmesh_assert_less_equal (0, objects_on_proc[p]);
#endif
 
  // We'll renumber objects in blocks by processor id
  std::vector<dof_id_type> first_object_on_proc(this->n_processors());
  for (processor_id_type i=1, np=this->n_processors(); i != np; ++i)
    first_object_on_proc[i] = first_object_on_proc[i-1] +
      objects_on_proc[i-1];
  dof_id_type next_id = first_object_on_proc[this->processor_id()];
  dof_id_type first_free_id =
    first_object_on_proc[this->n_processors()-1] +
    objects_on_proc[this->n_processors()-1] +
    unpartitioned_objects;
 
  // First set new local object ids and build request sets
  // for non-local object ids
 
  // Request sets to send to each processor
  std::map<processor_id_type, std::vector<dof_id_type>>
    requested_ids;
 
  // We know how many objects live on each processor, so reserve() space for
  // each.
  auto ghost_end = ghost_objects_from_proc.end();
  for (auto p : IntRange<processor_id_type>(0, this->n_processors()))
    if (p != this->processor_id())
      {
        const auto p_it = ghost_objects_from_proc.find(p);
        if (p_it != ghost_end)
          requested_ids[p].reserve(p_it->second);
      }
 
  end = objects.end();
  for (it = objects.begin(); it != end; ++it)
    {
      T * obj = *it;
      if (obj->processor_id() == this->processor_id())
        obj->set_id(next_id++);
      else if (obj->processor_id() != DofObject::invalid_processor_id)
        requested_ids[obj->processor_id()].push_back(obj->id());
    }
 
  // Next set ghost object ids from other processors
 
  auto gather_functor =
    [
#ifndef NDEBUG
     this,
     &first_object_on_proc,
     &objects_on_proc,
#endif
     &objects]
    (processor_id_type, const std::vector<dof_id_type> & ids,
     std::vector<dof_id_type> & new_ids)
    {
      std::size_t ids_size = ids.size();
      new_ids.resize(ids_size);
 
      for (std::size_t i=0; i != ids_size; ++i)
        {
          T * obj = objects[ids[i]];
          libmesh_assert(obj);
          libmesh_assert_equal_to (obj->processor_id(), this->processor_id());
          new_ids[i] = obj->id();
 
          libmesh_assert_greater_equal (new_ids[i],
                                        first_object_on_proc[this->processor_id()]);
          libmesh_assert_less (new_ids[i],
                               first_object_on_proc[this->processor_id()] +
                               objects_on_proc[this->processor_id()]);
        }
    };
 
  auto action_functor =
    [
#ifndef NDEBUG
     &first_object_on_proc,
     &objects_on_proc,
#endif
     &objects]
    (processor_id_type libmesh_dbg_var(pid),
     const std::vector<dof_id_type> & ids,
     const std::vector<dof_id_type> & data)
    {
      // Copy the id changes we've now been informed of
      for (auto i : index_range(ids))
        {
          T * obj = objects[ids[i]];
          libmesh_assert (obj);
          libmesh_assert_equal_to (obj->processor_id(), pid);
          libmesh_assert_greater_equal (data[i],
                                        first_object_on_proc[pid]);
          libmesh_assert_less (data[i],
                               first_object_on_proc[pid] +
                               objects_on_proc[pid]);
          obj->set_id(data[i]);
        }
    };
 
  const dof_id_type * ex = nullptr;
  Parallel::pull_parallel_vector_data
    (this->comm(), requested_ids, gather_functor, action_functor, ex);
 
#ifdef LIBMESH_ENABLE_UNIQUE_ID
  auto unique_gather_functor =
    [
#ifndef NDEBUG
     this,
#endif
     &objects]
    (processor_id_type, const std::vector<dof_id_type> & ids,
     std::vector<unique_id_type> & data)
    {
      std::size_t ids_size = ids.size();
      data.resize(ids_size);
 
      for (std::size_t i=0; i != ids_size; ++i)
        {
          T * obj = objects[ids[i]];
          libmesh_assert(obj);
          libmesh_assert_equal_to (obj->processor_id(), this->processor_id());
          data[i] = obj->valid_unique_id() ? obj->unique_id() : DofObject::invalid_unique_id;
        }
    };
 
  auto unique_action_functor =
    [&objects]
    (processor_id_type libmesh_dbg_var(pid),
     const std::vector<dof_id_type> & ids,
     const std::vector<unique_id_type> & data)
    {
      for (auto i : index_range(ids))
        {
          T * obj = objects[ids[i]];
          libmesh_assert (obj);
          libmesh_assert_equal_to (obj->processor_id(), pid);
          if (!obj->valid_unique_id() && data[i] != DofObject::invalid_unique_id)
            obj->set_unique_id() = (data[i]);
        }
    };
 
  const unique_id_type * unique_ex = nullptr;
  Parallel::pull_parallel_vector_data
    (this->comm(), requested_ids, unique_gather_functor,
     unique_action_functor, unique_ex);
#endif
 
  // Next set unpartitioned object ids
  next_id = 0;
  for (auto i : IntRange<processor_id_type>(0, this->n_processors()))
    next_id += objects_on_proc[i];
  for (it = objects.begin(); it != end; ++it)
    {
      T * obj = *it;
      if (obj->processor_id() == DofObject::invalid_processor_id)
        obj->set_id(next_id++);
    }
 
  // Finally shuffle around objects so that container indices
  // match ids
  it = objects.begin();
  end = objects.end();
  while (it != end)
    {
      T * obj = *it;
      if (obj) // don't try shuffling already-nullptr entries
        {
          T * next = objects[obj->id()];
          // If we have to move this object
          if (next != obj)
            {
              // nullptr out its original position for now
              // (our shuffling may put another object there shortly)
              *it = nullptr;
 
              // There may already be another object with this id that
              // needs to be moved itself
              while (next)
                {
                  // We shouldn't be trying to give two objects the
                  // same id
                  libmesh_assert_not_equal_to (next->id(), obj->id());
                  objects[obj->id()] = obj;
                  obj = next;
                  next = objects[obj->id()];
                }
              objects[obj->id()] = obj;
            }
        }
 
      // Remove any container entries that were left as nullptr.
      if (!obj)
        it = objects.erase(it);
      else
        ++it;
    }
 
  return first_free_id;
}

References libMesh::mapvector< Val, index_t >::begin(), libMesh::ParallelObject::comm(), data, libMesh::mapvector< Val, index_t >::end(), end, libMesh::mapvector< Val, index_t >::erase(), libMesh::index_range(), libMesh::DofObject::invalid_processor_id, libMesh::DofObject::invalid_unique_id, libMesh::libmesh_assert(), libMesh::ParallelObject::n_processors(), libMesh::MeshTools::Subdivision::next, and libMesh::ParallelObject::processor_id().

Referenced by renumber_nodes_and_elements().

renumber_elem()

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

overridevirtual

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 610 of file distributed_mesh.C.

{
  Elem * el = _elements[old_id];
  libmesh_assert (el);
  libmesh_assert_equal_to (el->id(), old_id);
 
  el->set_id(new_id);
  libmesh_assert (!_elements[new_id]);
  _elements[new_id] = el;
  _elements.erase(old_id);
}

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

renumber_node()

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

overridevirtual

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 797 of file distributed_mesh.C.

{
  Node * nd = _nodes[old_id];
  libmesh_assert (nd);
  libmesh_assert_equal_to (nd->id(), old_id);
 
  nd->set_id(new_id);
 
  // If we have nodes shipped to this processor for NodeConstraints
  // use, then those nodes will exist in _nodes, but may not be
  // locatable via a TopologyMap due to the insufficiency of elements
  // connecting to them.  If local refinement then wants to create a
  // *new* node in the same location, it will initially get a temporary
  // id, and then make_node_ids_parallel_consistent() will try to move
  // it to the canonical id.  We need to account for this case to
  // avoid false positives and memory leaks.
#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
  if (_nodes[new_id])
    {
      libmesh_assert_equal_to (*(Point *)_nodes[new_id],
                               *(Point *)_nodes[old_id]);
      _nodes.erase(new_id);
    }
#else
  // If we aren't shipping nodes for NodeConstraints, there should be
  // no reason for renumbering one node onto another.
  libmesh_assert (!_nodes[new_id]);
#endif
  _nodes[new_id] = nd;
  _nodes.erase(old_id);
}

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

renumber_nodes_and_elements()

void libMesh::DistributedMesh::renumber_nodes_and_elements ( )

overridevirtual

Remove nullptr elements from arrays.

Implements libMesh::MeshBase.

Definition at line 1279 of file distributed_mesh.C.

{
  parallel_object_only();
 
#ifdef DEBUG
  // Make sure our ids and flags are consistent
  this->libmesh_assert_valid_parallel_ids();
  this->libmesh_assert_valid_parallel_flags();
  this->libmesh_assert_valid_parallel_p_levels();
#endif
 
  LOG_SCOPE("renumber_nodes_and_elements()", "DistributedMesh");
 
  std::set<dof_id_type> used_nodes;
 
  // flag the nodes we need
  for (auto & elem : this->element_ptr_range())
    for (const Node & node : elem->node_ref_range())
      used_nodes.insert(node.id());
 
  // Nodes not connected to any local elements, and nullptr node entries
  // in our container, are deleted
  {
    node_iterator_imp  it = _nodes.begin();
    node_iterator_imp end = _nodes.end();
 
    while (it != end)
      {
        Node * nd = *it;
        if (!nd)
          it = _nodes.erase(it);
        else if (!used_nodes.count(nd->id()))
          {
            // remove any boundary information associated with
            // this node
            this->get_boundary_info().remove (nd);
 
            // delete the node
            delete nd;
 
            it = _nodes.erase(it);
          }
        else
          ++it;
      }
  }
 
  if (_skip_renumber_nodes_and_elements)
    {
      this->update_parallel_id_counts();
      return;
    }
 
  // Finally renumber all the elements
  _n_elem = this->renumber_dof_objects (this->_elements);
 
  // and all the remaining nodes
  _n_nodes = this->renumber_dof_objects (this->_nodes);
 
  // And figure out what IDs we should use when adding new nodes and
  // new elements
  this->update_parallel_id_counts();
 
  // Make sure our caches are up to date and our
  // DofObjects are well packed
#ifdef DEBUG
  libmesh_assert_equal_to (this->n_nodes(), this->parallel_n_nodes());
  libmesh_assert_equal_to (this->n_elem(), this->parallel_n_elem());
  const dof_id_type pmax_node_id = this->parallel_max_node_id();
  const dof_id_type pmax_elem_id = this->parallel_max_elem_id();
  libmesh_assert_equal_to (this->max_node_id(), pmax_node_id);
  libmesh_assert_equal_to (this->max_elem_id(), pmax_elem_id);
  libmesh_assert_equal_to (this->n_nodes(), this->max_node_id());
  libmesh_assert_equal_to (this->n_elem(), this->max_elem_id());
 
  // Make sure our ids and flags are consistent
  this->libmesh_assert_valid_parallel_ids();
  this->libmesh_assert_valid_parallel_flags();
 
  // And make sure we've made our numbering monotonic
  MeshTools::libmesh_assert_valid_elem_ids(*this);
#endif
}

References _elements, _n_elem, _n_nodes, _nodes, libMesh::MeshBase::_skip_renumber_nodes_and_elements, libMesh::MeshBase::elem(), element_ptr_range(), end, libMesh::MeshBase::get_boundary_info(), libMesh::DofObject::id(), libMesh::MeshTools::libmesh_assert_valid_elem_ids(), libmesh_assert_valid_parallel_flags(), libmesh_assert_valid_parallel_ids(), libmesh_assert_valid_parallel_p_levels(), max_elem_id(), max_node_id(), n_elem(), n_nodes(), libMesh::MeshBase::node(), libMesh::Elem::node_ref_range(), parallel_max_elem_id(), parallel_max_node_id(), parallel_n_elem(), parallel_n_nodes(), libMesh::BoundaryInfo::remove(), renumber_dof_objects(), and update_parallel_id_counts().

reserve_elem()

virtual void libMesh::DistributedMesh::reserve_elem ( const  ne )

inlineoverridevirtual

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 235 of file distributed_mesh.h.

{}

reserve_nodes()

virtual void libMesh::DistributedMesh::reserve_nodes ( const  nn )

inlineoverridevirtual

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 231 of file distributed_mesh.h.

{}

semilocal_elements_begin() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::semilocal_elements_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

semilocal_elements_begin() [2/2]

virtual element_iterator libMesh::DistributedMesh::semilocal_elements_begin ( )

overridevirtual

Iterate over elements for which elem->is_semilocal() is true for the current processor.

Implements libMesh::MeshBase.

semilocal_elements_end() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::semilocal_elements_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

semilocal_elements_end() [2/2]

virtual element_iterator libMesh::DistributedMesh::semilocal_elements_end ( )

overridevirtual

Implements libMesh::MeshBase.

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

{
  _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 732 of file mesh_base.h.

                                                           {
    _default_mapping_data = data;
  }

References libMesh::MeshBase::_default_mapping_data, and data.

Referenced by libMesh::DynaIO::read_mesh(), RationalMapTest< elem_type >::setUp(), and FETest< order, family, elem_type >::setUp().

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

                                                             {
    _default_mapping_type = type;
  }

References libMesh::MeshBase::_default_mapping_type.

Referenced by libMesh::DynaIO::read_mesh(), and RationalMapTest< elem_type >::setUp().

set_distributed()

virtual void libMesh::DistributedMesh::set_distributed ( )

inlineoverridevirtual

Asserts that not all elements and nodes of the mesh necessarily exist on the current processor.

Reimplemented from libMesh::MeshBase.

Definition at line 133 of file distributed_mesh.h.

  { _is_serial = false;
    _is_serial_on_proc_0 = false; }

References _is_serial, and _is_serial_on_proc_0.

set_elem_dimensions()

void libMesh::MeshBase::set_elem_dimensions ( const 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_dims(), 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_dims() and simply specify the element dimensions manually, which is why this setter exists.

Definition at line 144 of file mesh_base.C.

{
#ifdef DEBUG
  // In debug mode, we call cache_elem_dims() and then make sure
  // the result actually agrees with what the user specified.
  parallel_object_only();
 
  this->cache_elem_dims();
  libmesh_assert_msg(_elem_dims == elem_dims, \
                     "Specified element dimensions does not match true element dimensions!");
#endif
 
  _elem_dims = elem_dims;
}

References libMesh::MeshBase::_elem_dims, and libMesh::MeshBase::cache_elem_dims().

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

  { _elem_dims.clear(); _elem_dims.insert(d); }

References libMesh::MeshBase::_elem_dims.

Referenced by libMesh::MeshTools::Generation::build_delaunay_square(), MixedDimensionMeshTest::build_mesh(), MeshfunctionDFEM::build_mesh(), SlitMeshTest::build_mesh(), MixedDimensionNonUniformRefinement::build_mesh(), MixedDimensionNonUniformRefinementTriangle::build_mesh(), MixedDimensionNonUniformRefinement3D::build_mesh(), libMesh::TriangleWrapper::copy_tri_to_mesh(), libMesh::AbaqusIO::read(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::GMVIO::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(), and libMesh::TriangleInterface::triangulate().

set_n_partitions()

unsigned int& libMesh::MeshBase::set_n_partitions ( )

inlineprotectedinherited

Returns

A writable reference to the number of partitions.

Definition at line 1667 of file mesh_base.h.

  { return _n_parts; }

References libMesh::MeshBase::_n_parts.

Referenced by libMesh::BoundaryInfo::sync().

set_next_unique_id()

void libMesh::MeshBase::set_next_unique_id ( unique_id_type  id )

inlineinherited

Sets the next unique id to be used.

Definition at line 327 of file mesh_base.h.

{ _next_unique_id = id; }

References libMesh::MeshBase::_next_unique_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 905 of file mesh_base.C.

{
  _point_locator_close_to_point_tol = val;
  if (_point_locator)
    {
      if (val > 0.)
        _point_locator->set_close_to_point_tol(val);
      else
        _point_locator->unset_close_to_point_tol();
    }
}

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

{
  // The user can set the _spatial_dimension however they wish,
  // libMesh will only *increase* the spatial dimension, however,
  // never decrease it.
  _spatial_dimension = d;
}

References libMesh::MeshBase::_spatial_dimension.

Referenced by MeshSpatialDimensionTest::test2D().

set_subdomain_name_map()

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

inlineinherited

Returns

A writable reference to the whole subdomain name map

Definition at line 1631 of file mesh_base.h.

  { return _block_id_to_name; }

References libMesh::MeshBase::_block_id_to_name.

Referenced by DistributedMesh(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::CheckpointIO::read_subdomain_names(), and libMesh::ReplicatedMesh::ReplicatedMesh().

size_elem_extra_integers()

void libMesh::MeshBase::size_elem_extra_integers ( )

protectedinherited

Size extra-integer arrays of all elements in the mesh.

Definition at line 926 of file mesh_base.C.

{
  const std::size_t new_size = _elem_integer_names.size();
  for (auto elem : this->element_ptr_range())
    elem->add_extra_integers(new_size);
}

Referenced by libMesh::MeshBase::add_elem_data(), libMesh::MeshBase::add_elem_datum(), and libMesh::MeshBase::add_elem_integer().

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

{
  const std::size_t new_size = _node_integer_names.size();
  for (auto node : this->node_ptr_range())
    node->add_extra_integers(new_size);
}

Referenced by libMesh::MeshBase::add_node_data(), and libMesh::MeshBase::add_node_datum().

skip_noncritical_partitioning() [1/2]

bool libMesh::MeshBase::skip_noncritical_partitioning ( ) const

inlineinherited

Definition at line 1061 of file mesh_base.h.

  { return _skip_noncritical_partitioning || _skip_all_partitioning || !_partitioner.get(); }

References libMesh::MeshBase::_partitioner, libMesh::MeshBase::_skip_all_partitioning, and libMesh::MeshBase::_skip_noncritical_partitioning.

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

skip_noncritical_partitioning() [2/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 1058 of file mesh_base.h.

  { _skip_noncritical_partitioning = skip; }

References libMesh::MeshBase::_skip_noncritical_partitioning.

Referenced by libMesh::MeshTools::correct_node_proc_ids().

skip_partitioning() [1/2]

bool libMesh::MeshBase::skip_partitioning ( ) const

inlineinherited

Definition at line 1078 of file mesh_base.h.

{ return _skip_all_partitioning; }

References libMesh::MeshBase::_skip_all_partitioning.

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

skip_partitioning() [2/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 1076 of file mesh_base.h.

{ _skip_all_partitioning = skip; }

References libMesh::MeshBase::_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 159 of file mesh_base.C.

{
  return cast_int<unsigned int>(_spatial_dimension);
}

References libMesh::MeshBase::_spatial_dimension.

Referenced by MeshSpatialDimensionTest::test1D(), and MeshSpatialDimensionTest::test2D().

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

{
  // If there's no master point locator, then we need one.
  if (_point_locator.get() == nullptr)
    {
      // PointLocator construction may not be safe within threads
      libmesh_assert(!Threads::in_threads);
 
      // And it may require parallel communication
      parallel_object_only();
 
      _point_locator = PointLocatorBase::build(TREE_ELEMENTS, *this);
 
      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 PointLocatorBase::build(TREE_ELEMENTS, *this, _point_locator.get());
}

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

Referenced by MeshfunctionDFEM::build_mesh(), 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::DefaultCoupling::mesh_reinit(), libMesh::PointNeighborCoupling::mesh_reinit(), libMesh::MeshRefinement::test_level_one(), PointLocatorTest::testLocator(), MixedDimensionMeshTest::testPointLocatorTree(), SystemsTest::testProjectCube(), SystemsTest::testProjectLine(), and SystemsTest::testProjectSquare().

subactive_elements_begin() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::subactive_elements_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

subactive_elements_begin() [2/2]

virtual element_iterator libMesh::DistributedMesh::subactive_elements_begin ( )

overridevirtual

Iterate over elements for which elem->subactive() is true.

Implements libMesh::MeshBase.

subactive_elements_end() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::subactive_elements_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

subactive_elements_end() [2/2]

virtual element_iterator libMesh::DistributedMesh::subactive_elements_end ( )

overridevirtual

Implements libMesh::MeshBase.

subdomain_ids()

void libMesh::MeshBase::subdomain_ids ( std::set< subdomain_id_type > &  ids ) const

inherited

Constructs a list of all subdomain identifiers 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 461 of file mesh_base.C.

{
  // This requires an inspection on every processor
  parallel_object_only();
 
  ids.clear();
 
  for (const auto & elem : this->active_local_element_ptr_range())
    ids.insert(elem->subdomain_id());
 
  // Some subdomains may only live on other processors
  this->comm().set_union(ids);
}

Referenced by libMesh::ReplicatedMesh::get_disconnected_subdomains(), and libMesh::TecplotIO::TecplotIO().

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

{
  return _block_id_to_name[id];
}

Referenced by libMesh::AbaqusIO::assign_subdomain_ids(), DMlibMeshSetSystem_libMesh(), libMesh::UNVIO::groups_in(), libMesh::ExodusII_IO::read(), libMesh::GmshIO::read_mesh(), and libMesh::TecplotIO::write_binary().

subdomain_name() [2/2]

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

inherited

Definition at line 722 of file mesh_base.C.

{
  // An empty string to return when no matching subdomain name is found
  static const std::string empty;
 
  std::map<subdomain_id_type, std::string>::const_iterator iter = _block_id_to_name.find(id);
  if (iter == _block_id_to_name.end())
    return empty;
  else
    return iter->second;
}

type_elements_begin() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::type_elements_begin ( ElemType  type ) const

overridevirtual

Implements libMesh::MeshBase.

type_elements_begin() [2/2]

virtual element_iterator libMesh::DistributedMesh::type_elements_begin ( ElemType  type )

overridevirtual

Iterate over all elements with a specified geometric type.

Implements libMesh::MeshBase.

type_elements_end() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::type_elements_end ( ElemType  type ) const

overridevirtual

Implements libMesh::MeshBase.

type_elements_end() [2/2]

virtual element_iterator libMesh::DistributedMesh::type_elements_end ( ElemType  type )

overridevirtual

Implements libMesh::MeshBase.

unpartitioned_elements_begin() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::unpartitioned_elements_begin ( ) const

overridevirtual

Implements libMesh::MeshBase.

unpartitioned_elements_begin() [2/2]

virtual element_iterator libMesh::DistributedMesh::unpartitioned_elements_begin ( )

overridevirtual

Iterate over unpartitioned elements in the Mesh.

Implements libMesh::MeshBase.

unpartitioned_elements_end() [1/2]

virtual const_element_iterator libMesh::DistributedMesh::unpartitioned_elements_end ( ) const

overridevirtual

Implements libMesh::MeshBase.

unpartitioned_elements_end() [2/2]

virtual element_iterator libMesh::DistributedMesh::unpartitioned_elements_end ( )

overridevirtual

Implements libMesh::MeshBase.

update_parallel_id_counts()

void libMesh::DistributedMesh::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 178 of file distributed_mesh.C.

{
  // This function must be run on all processors at once
  parallel_object_only();
 
  _n_elem  = this->parallel_n_elem();
  _n_nodes = this->parallel_n_nodes();
  _max_node_id = this->parallel_max_node_id();
  _max_elem_id = this->parallel_max_elem_id();
 
  if (_next_free_unpartitioned_elem_id < _max_elem_id)
    _next_free_unpartitioned_elem_id =
      ((_max_elem_id-1) / (this->n_processors() + 1) + 1) *
      (this->n_processors() + 1) + this->n_processors();
  if (_next_free_local_elem_id < _max_elem_id)
    _next_free_local_elem_id =
      ((_max_elem_id + this->n_processors() - 1) / (this->n_processors() + 1) + 1) *
      (this->n_processors() + 1) + this->processor_id();
 
  if (_next_free_unpartitioned_node_id < _max_node_id)
    _next_free_unpartitioned_node_id =
      ((_max_node_id-1) / (this->n_processors() + 1) + 1) *
      (this->n_processors() + 1) + this->n_processors();
  if (_next_free_local_node_id < _max_node_id)
    _next_free_local_node_id =
      ((_max_node_id + this->n_processors() - 1) / (this->n_processors() + 1) + 1) *
      (this->n_processors() + 1) + this->processor_id();
 
#ifdef LIBMESH_ENABLE_UNIQUE_ID
  _next_unique_id = this->parallel_max_unique_id();
  _next_unpartitioned_unique_id =
    ((_next_unique_id-1) / (this->n_processors() + 1) + 1) *
    (this->n_processors() + 1) + this->n_processors();
  _next_unique_id =
    ((_next_unique_id + this->n_processors() - 1) / (this->n_processors() + 1) + 1) *
    (this->n_processors() + 1) + this->processor_id();
#endif
}

References _max_elem_id, _max_node_id, _n_elem, _n_nodes, _next_free_local_elem_id, _next_free_local_node_id, _next_free_unpartitioned_elem_id, _next_free_unpartitioned_node_id, libMesh::MeshBase::_next_unique_id, _next_unpartitioned_unique_id, libMesh::ParallelObject::n_processors(), parallel_max_elem_id(), parallel_max_node_id(), parallel_max_unique_id(), parallel_n_elem(), parallel_n_nodes(), and libMesh::ParallelObject::processor_id().

Referenced by delete_remote_elements(), DistributedMesh(), redistribute(), renumber_nodes_and_elements(), and update_post_partitioning().

update_post_partitioning()

void libMesh::DistributedMesh::update_post_partitioning ( )

overridevirtual

Recalculate cached data after elements and nodes have been repartitioned.

Reimplemented from libMesh::MeshBase.

Definition at line 901 of file distributed_mesh.C.

{
  // this->recalculate_n_partitions();
 
  // Partitioning changes our numbers of unpartitioned objects
  this->update_parallel_id_counts();
}

References update_parallel_id_counts().

write() [1/2]

void libMesh::UnstructuredMesh::write ( const std::string &  name )

overridevirtualinherited

Write the file specified by name.

Attempts to figure out the proper method by the file extension.

Implements libMesh::MeshBase.

Definition at line 650 of file unstructured_mesh.C.

{
  LOG_SCOPE("write()", "Mesh");
 
  NameBasedIO(*this).write(name);
}

References libMesh::Quality::name(), and libMesh::NameBasedIO::write().

Referenced by libMesh::RBEIMEvaluation::legacy_write_out_interpolation_points_elem(), and main().

write() [2/2]

void libMesh::UnstructuredMesh::write ( const std::string &  name, const std::vector< Number > &  values, const std::vector< std::string > &  variable_names  )

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 659 of file unstructured_mesh.C.

{
  LOG_SCOPE("write()", "Mesh");
 
  NameBasedIO(*this).write_nodal_data(name, v, vn);
}

References libMesh::Quality::name(), and libMesh::NameBasedIO::write_nodal_data().

Member Data Documentation

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

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

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

Referenced by libMesh::MeshBase::get_subdomain_name_map(), and libMesh::MeshBase::set_subdomain_name_map().

_communicator

const Parallel::Communicator& libMesh::ParallelObject::_communicator

protectedinherited

Definition at line 112 of file parallel_object.h.

Referenced by libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::ParallelObject::comm(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::operator=(), and libMesh::ParallelObject::processor_id().

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

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

Referenced by libMesh::MeshBase::default_ghosting(), and libMesh::MeshBase::MeshBase().

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

Referenced by libMesh::MeshBase::default_mapping_data(), 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 1686 of file mesh_base.h.

Referenced by libMesh::MeshBase::default_mapping_type(), and libMesh::MeshBase::set_default_mapping_type().

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

Referenced by libMesh::MeshBase::elem_dimensions(), libMesh::MeshBase::mesh_dimension(), libMesh::MeshBase::MeshBase(), libMesh::MeshBase::set_elem_dimensions(), and libMesh::MeshBase::set_mesh_dimension().

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

Referenced by libMesh::ReplicatedMesh::add_elem(), 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::UnstructuredMesh::create_submesh(), libMesh::MeshBase::get_elem_integer_name(), libMesh::ReplicatedMesh::insert_elem(), insert_elem(), libMesh::MeshBase::merge_extra_integer_names(), and libMesh::MeshBase::n_elem_integers().

_elements

mapvector<Elem *, dof_id_type> libMesh::DistributedMesh::_elements

protected

The elements in the mesh.

Definition at line 555 of file distributed_mesh.h.

Referenced by add_elem(), clear(), delete_elem(), delete_remote_elements(), elem_ptr(), fix_broken_node_and_element_numbering(), insert_elem(), libmesh_assert_valid_parallel_flags(), libmesh_assert_valid_parallel_ids(), libmesh_assert_valid_parallel_p_levels(), parallel_max_elem_id(), query_elem_ptr(), renumber_elem(), and renumber_nodes_and_elements().

_extra_ghost_elems

std::set<Elem *> libMesh::DistributedMesh::_extra_ghost_elems

protected

These are extra ghost elements that we want to make sure not to delete when we call delete_remote_elements()

Definition at line 592 of file distributed_mesh.h.

Referenced by add_extra_ghost_elem(), clear_extra_ghost_elems(), delete_remote_elements(), DistributedMesh(), and extra_ghost_elems().

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

Referenced by libMesh::MeshBase::add_ghosting_functor(), libMesh::MeshBase::ghosting_functors_begin(), libMesh::MeshBase::ghosting_functors_end(), and libMesh::MeshBase::MeshBase().

_is_prepared

bool libMesh::MeshBase::_is_prepared

protectedinherited

Flag indicating if the mesh has been prepared for use.

Definition at line 1698 of file mesh_base.h.

Referenced by libMesh::UnstructuredMesh::all_first_order(), libMesh::UnstructuredMesh::all_second_order(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), and libMesh::MeshBase::is_prepared().

_is_serial

bool libMesh::DistributedMesh::_is_serial

protected

A boolean remembering whether we're serialized or not.

Definition at line 560 of file distributed_mesh.h.

Referenced by allgather(), clear(), delete_remote_elements(), is_serial(), is_serial_on_zero(), and set_distributed().

_is_serial_on_proc_0

bool libMesh::DistributedMesh::_is_serial_on_proc_0

protected

A boolean remembering whether we're serialized to proc 0 or not.

Definition at line 565 of file distributed_mesh.h.

Referenced by allgather(), clear(), delete_remote_elements(), gather_to_zero(), is_serial_on_zero(), and set_distributed().

_max_elem_id

dof_id_type libMesh::DistributedMesh::_max_elem_id

protected

Definition at line 570 of file distributed_mesh.h.

Referenced by add_elem(), clear(), DistributedMesh(), max_elem_id(), and update_parallel_id_counts().

_max_node_id

dof_id_type libMesh::DistributedMesh::_max_node_id

protected

Definition at line 570 of file distributed_mesh.h.

Referenced by add_node(), clear(), DistributedMesh(), max_node_id(), and update_parallel_id_counts().

_n_elem

dof_id_type libMesh::DistributedMesh::_n_elem

protected

Definition at line 570 of file distributed_mesh.h.

Referenced by add_elem(), clear(), delete_elem(), DistributedMesh(), insert_elem(), n_elem(), renumber_nodes_and_elements(), and update_parallel_id_counts().

_n_nodes

dof_id_type libMesh::DistributedMesh::_n_nodes

protected

Cached data from the last renumber_nodes_and_elements call.

Definition at line 570 of file distributed_mesh.h.

Referenced by add_node(), clear(), delete_node(), DistributedMesh(), n_nodes(), renumber_nodes_and_elements(), and update_parallel_id_counts().

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

Referenced by libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::MeshBase::n_partitions(), and libMesh::MeshBase::set_n_partitions().

_next_free_local_elem_id

dof_id_type libMesh::DistributedMesh::_next_free_local_elem_id

protected

Definition at line 576 of file distributed_mesh.h.

Referenced by add_elem(), clear(), DistributedMesh(), and update_parallel_id_counts().

_next_free_local_node_id

dof_id_type libMesh::DistributedMesh::_next_free_local_node_id

protected

Guaranteed globally unused IDs for use when adding new nodes or elements.

Definition at line 576 of file distributed_mesh.h.

Referenced by add_node(), clear(), DistributedMesh(), and update_parallel_id_counts().

_next_free_unpartitioned_elem_id

dof_id_type libMesh::DistributedMesh::_next_free_unpartitioned_elem_id

protected

Definition at line 578 of file distributed_mesh.h.

Referenced by add_elem(), clear(), DistributedMesh(), and update_parallel_id_counts().

_next_free_unpartitioned_node_id

dof_id_type libMesh::DistributedMesh::_next_free_unpartitioned_node_id

protected

Definition at line 578 of file distributed_mesh.h.

Referenced by add_node(), clear(), DistributedMesh(), and update_parallel_id_counts().

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

Referenced by libMesh::ReplicatedMesh::add_elem(), add_elem(), libMesh::ReplicatedMesh::add_node(), add_node(), libMesh::ReplicatedMesh::add_point(), DistributedMesh(), libMesh::ReplicatedMesh::insert_elem(), insert_elem(), libMesh::ReplicatedMesh::insert_node(), libMesh::MeshBase::next_unique_id(), libMesh::ReplicatedMesh::parallel_max_unique_id(), parallel_max_unique_id(), libMesh::ReplicatedMesh::ReplicatedMesh(), libMesh::MeshBase::set_next_unique_id(), libMesh::ReplicatedMesh::update_parallel_id_counts(), and update_parallel_id_counts().

_next_unpartitioned_unique_id

unique_id_type libMesh::DistributedMesh::_next_unpartitioned_unique_id

protected

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

Definition at line 585 of file distributed_mesh.h.

Referenced by add_elem(), add_node(), DistributedMesh(), insert_elem(), parallel_max_unique_id(), and update_parallel_id_counts().

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

Referenced by libMesh::ReplicatedMesh::add_node(), add_node(), libMesh::MeshBase::add_node_data(), libMesh::MeshBase::add_node_datum(), libMesh::ReplicatedMesh::add_point(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::UnstructuredMesh::create_submesh(), libMesh::MeshBase::get_node_integer_name(), libMesh::ReplicatedMesh::insert_node(), libMesh::MeshBase::merge_extra_integer_names(), and libMesh::MeshBase::n_node_integers().

_nodes

mapvector<Node *, dof_id_type> libMesh::DistributedMesh::_nodes

protected

The vertices (spatial coordinates) of the mesh.

Definition at line 550 of file distributed_mesh.h.

Referenced by add_node(), add_point(), clear(), delete_node(), delete_remote_elements(), fix_broken_node_and_element_numbering(), libmesh_assert_valid_parallel_ids(), node_ptr(), own_node(), parallel_max_node_id(), query_node_ptr(), renumber_node(), and renumber_nodes_and_elements().

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

Referenced by DistributedMesh(), libMesh::MeshBase::MeshBase(), libMesh::MeshBase::partitioner(), libMesh::ReplicatedMesh::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 1707 of file mesh_base.h.

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

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

Referenced by libMesh::MeshBase::add_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 1739 of file mesh_base.h.

Referenced by libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::MeshBase::skip_noncritical_partitioning(), and libMesh::MeshBase::skip_partitioning().

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

Referenced by libMesh::UnstructuredMesh::copy_nodes_and_elements(), 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 1746 of file mesh_base.h.

Referenced by libMesh::MeshBase::allow_renumbering(), libMesh::ReplicatedMesh::renumber_nodes_and_elements(), and 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 1774 of file mesh_base.h.

Referenced by libMesh::MeshBase::set_spatial_dimension(), and libMesh::MeshBase::spatial_dimension().

boundary_info

std::unique_ptr<BoundaryInfo> libMesh::MeshBase::boundary_info

inherited

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 will be removed in future libMesh versions. Use the get_boundary_info() accessor instead.

Definition at line 1659 of file mesh_base.h.

Referenced by libMesh::MeshBase::get_boundary_info(), and MeshInputTest::testMeshMoveConstructor().

---

The documentation for this class was generated from the following files:

• include/mesh/distributed_mesh.h
• src/mesh/distributed_mesh.C