libMesh::MeshCommunication Class Reference

This is the MeshCommunication class. More...

#include <mesh_communication.h>

Public Member Functions
	MeshCommunication ()
	Constructor. More...
	~MeshCommunication ()
	Destructor. More...
void	clear ()
	Clears all data structures and resets to a pristine state. More...
void	broadcast (MeshBase &) const
	Finds all the processors that may contain elements that neighbor my elements. More...
void	redistribute (DistributedMesh &mesh, bool newly_coarsened_only=false) const
	This method takes a parallel distributed mesh and redistributes the elements. More...
void	gather_neighboring_elements (DistributedMesh &) const
void	send_coarse_ghosts (MeshBase &) const
	Examine a just-coarsened mesh, and for any newly-coarsened elements, send the associated ghosted elements to the processor which needs them. More...
void	gather (const processor_id_type root_id, DistributedMesh &) const
	This method takes an input DistributedMesh which may be distributed among all the processors. More...
void	allgather (DistributedMesh &mesh) const
	This method takes an input DistributedMesh which may be distributed among all the processors. More...
void	delete_remote_elements (DistributedMesh &, const std::set< Elem *> &) const
	This method takes an input DistributedMesh which may be distributed among all the processors. More...
void	assign_global_indices (MeshBase &) const
	This method assigns globally unique, partition-agnostic indices to the nodes and elements in the mesh. More...
void	check_for_duplicate_global_indices (MeshBase &) const
	Throw an error if we have any index clashes in the numbering used by assign_global_indices. More...
template<typename ForwardIterator >
void	find_local_indices (const libMesh::BoundingBox &, const ForwardIterator &, const ForwardIterator &, std::unordered_map< dof_id_type, dof_id_type > &) const
	This method determines a locally unique, contiguous index for each object in the input range. More...
template<typename ForwardIterator >
void	find_global_indices (const Parallel::Communicator &communicator, const libMesh::BoundingBox &, const ForwardIterator &, const ForwardIterator &, std::vector< dof_id_type > &) const
	This method determines a globally unique, partition-agnostic index for each object in the input range. More...
void	make_elems_parallel_consistent (MeshBase &)
	Copy ids of ghost elements from their local processors. More...
void	make_p_levels_parallel_consistent (MeshBase &)
	Copy p levels of ghost elements from their local processors. More...
void	make_node_ids_parallel_consistent (MeshBase &)
	Assuming all ids on local nodes are globally unique, and assuming all processor ids are parallel consistent, this function makes all other ids parallel consistent. More...
void	make_node_unique_ids_parallel_consistent (MeshBase &)
	Assuming all unique_ids on local nodes are globally unique, and assuming all processor ids are parallel consistent, this function makes all ghost unique_ids parallel consistent. More...
void	make_node_proc_ids_parallel_consistent (MeshBase &)
	Assuming all processor ids on nodes touching local elements are parallel consistent, this function makes all other processor ids parallel consistent as well. More...
void	make_new_node_proc_ids_parallel_consistent (MeshBase &)
	Assuming all processor ids on nodes touching local elements are parallel consistent, this function makes processor ids on new nodes on other processors parallel consistent as well. More...
void	make_nodes_parallel_consistent (MeshBase &)
	Copy processor_ids and ids on ghost nodes from their local processors. More...
void	make_new_nodes_parallel_consistent (MeshBase &)
	Copy processor_ids and ids on new nodes from their local processors. More...

Detailed Description

This is the MeshCommunication class.

It handles all the details of communicating mesh information from one processor to another. All parallelization of the Mesh data structures is done via this class.

Author

Benjamin S. Kirk

Date

2003

Definition at line 50 of file mesh_communication.h.

Constructor & Destructor Documentation

MeshCommunication()

libMesh::MeshCommunication::MeshCommunication

(

)

Constructor.

Definition at line 57 of file mesh_communication.h.

{}

~MeshCommunication()

libMesh::MeshCommunication::~MeshCommunication

(

)

Destructor.

Definition at line 62 of file mesh_communication.h.

{}

Member Function Documentation

allgather()

void libMesh::MeshCommunication::allgather

(

DistributedMesh &

mesh

)

const

This method takes an input DistributedMesh which may be distributed among all the processors.

Each processor then sends its local nodes and elements to the other processors. The end result is that a previously distributed DistributedMesh will be serialized on each processor. Since this method is collective it must be called by all processors.

Definition at line 135 of file mesh_communication.h.

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

  { MeshCommunication::gather(DofObject::invalid_processor_id, mesh); }

assign_global_indices()

void libMesh::MeshCommunication::assign_global_indices

(

MeshBase &

)

const

This method assigns globally unique, partition-agnostic indices to the nodes and elements in the mesh.

The approach is to compute the Hilbert space-filling curve key and use its value to assign an index in [0,N_global). Since the Hilbert key is unique for each spatial location, two objects occupying the same location will be assigned the same global id. Thus, this method can also be useful for identifying duplicate nodes which may occur during parallel refinement.

broadcast()

void libMesh::MeshCommunication::broadcast

(

MeshBase &

)

const

Finds all the processors that may contain elements that neighbor my elements.

This list is guaranteed to include all processors that border any of my elements, but may include additional ones as well. This method computes bounding boxes for the elements on each processor and checks for overlaps. This method takes a mesh (which is assumed to reside on processor 0) and broadcasts it to all the other processors. It also broadcasts any boundary information the mesh has associated with it.

check_for_duplicate_global_indices()

void libMesh::MeshCommunication::check_for_duplicate_global_indices

(

MeshBase &

)

const

Throw an error if we have any index clashes in the numbering used by assign_global_indices.

clear()

void libMesh::MeshCommunication::clear

(

)

Clears all data structures and resets to a pristine state.

delete_remote_elements()

void libMesh::MeshCommunication::delete_remote_elements	(	DistributedMesh &	,
		const std::set< Elem *> &
	)		const

This method takes an input DistributedMesh which may be distributed among all the processors.

Each processor deletes all elements which are neither local elements nor "ghost" elements which touch local elements, and deletes all nodes which are not contained in local or ghost elements. The end result is that a previously serial DistributedMesh will be distributed between processors. Since this method is collective it must be called by all processors.

The std::set is a list of extra elements that you don't want to delete. These will be left on the current processor along with local elements and ghosted neighbors.

find_global_indices()

template<typename ForwardIterator >

void libMesh::MeshCommunication::find_global_indices	(	const Parallel::Communicator &	communicator,
		const libMesh::BoundingBox &	,
		const ForwardIterator &	,
		const ForwardIterator &	,
		std::vector< dof_id_type > &
	)		const

This method determines a globally unique, partition-agnostic index for each object in the input range.

find_local_indices()

template<typename ForwardIterator >

void libMesh::MeshCommunication::find_local_indices	(	const libMesh::BoundingBox &	,
		const ForwardIterator &	,
		const ForwardIterator &	,
		std::unordered_map< dof_id_type, dof_id_type > &
	)		const

This method determines a locally unique, contiguous index for each object in the input range.

gather()

void libMesh::MeshCommunication::gather	(	const processor_id_type	root_id,
		DistributedMesh &
	)		const

This method takes an input DistributedMesh which may be distributed among all the processors.

Each processor then sends its local nodes and elements to processor root_id. The end result is that a previously distributed DistributedMesh will be serialized on processor root_id. Since this method is collective it must be called by all processors. For the special case of root_id equal to DofObject::invalid_processor_id this function performs an allgather.

Referenced by allgather().

gather_neighboring_elements()

void libMesh::MeshCommunication::gather_neighboring_elements

(

DistributedMesh &

)

const

make_elems_parallel_consistent()

void libMesh::MeshCommunication::make_elems_parallel_consistent

(

MeshBase &

)

Copy ids of ghost elements from their local processors.

make_new_node_proc_ids_parallel_consistent()

void libMesh::MeshCommunication::make_new_node_proc_ids_parallel_consistent

(

MeshBase &

)

Assuming all processor ids on nodes touching local elements are parallel consistent, this function makes processor ids on new nodes on other processors parallel consistent as well.

make_new_nodes_parallel_consistent()

void libMesh::MeshCommunication::make_new_nodes_parallel_consistent

(

MeshBase &

)

Copy processor_ids and ids on new nodes from their local processors.

make_node_ids_parallel_consistent()

void libMesh::MeshCommunication::make_node_ids_parallel_consistent

(

MeshBase &

)

Assuming all ids on local nodes are globally unique, and assuming all processor ids are parallel consistent, this function makes all other ids parallel consistent.

make_node_proc_ids_parallel_consistent()

void libMesh::MeshCommunication::make_node_proc_ids_parallel_consistent

(

MeshBase &

)

Assuming all processor ids on nodes touching local elements are parallel consistent, this function makes all other processor ids parallel consistent as well.

make_node_unique_ids_parallel_consistent()

void libMesh::MeshCommunication::make_node_unique_ids_parallel_consistent

(

MeshBase &

)

Assuming all unique_ids on local nodes are globally unique, and assuming all processor ids are parallel consistent, this function makes all ghost unique_ids parallel consistent.

make_nodes_parallel_consistent()

void libMesh::MeshCommunication::make_nodes_parallel_consistent

(

MeshBase &

)

Copy processor_ids and ids on ghost nodes from their local processors.

This is useful for code which wants to add nodes to a distributed mesh.

make_p_levels_parallel_consistent()

void libMesh::MeshCommunication::make_p_levels_parallel_consistent

(

MeshBase &

)

Copy p levels of ghost elements from their local processors.

redistribute()

void libMesh::MeshCommunication::redistribute	(	DistributedMesh &	mesh,
		bool	newly_coarsened_only = false
	)		const

This method takes a parallel distributed mesh and redistributes the elements.

Specifically, any elements stored on a given processor are sent to the processor which "owns" them. Similarly, any elements assigned to the current processor but stored on another are received. Once this step is completed any required ghost elements are updated. The final result is that each processor stores only the elements it actually owns and any ghost elements required to satisfy data dependencies. This method can be invoked after a partitioning step to affect the new partitioning.

Redistribution can also be done with newly coarsened elements' neighbors only.

send_coarse_ghosts()

void libMesh::MeshCommunication::send_coarse_ghosts

(

MeshBase &

)

const

Examine a just-coarsened mesh, and for any newly-coarsened elements, send the associated ghosted elements to the processor which needs them.

---

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

• include/mesh/mesh_communication.h