void Partitioner::partition (MeshBase &mesh, const unsigned intn = libMesh::n_processors()) [inherited]Partition the MeshBase into n parts. If the user does not specify a number of pieces into which the mesh should be partitioned, then the default behavior of the partitioner is to partition according to the number of processors defined in libMesh::n_processors(). The partitioner currently does not modify the subdomain_id of each element. This number is reserved for things like material properties, etc.

void Partitioner::repartition (MeshBase &mesh, const unsigned intn = libMesh::n_processors()) [inherited]Repartitions the MeshBase into n parts. This is required since some partitoning algorithms can repartition more efficiently than computing a new partitioning from scratch. The default behavior is to simply call this->partition(n)

{
// we cannot partition into more pieces than we have
// active elements!
const unsigned int n_parts =
std::min(mesh.n_active_elem(), n);
// Set the number of partitions in the mesh
mesh.set_n_partitions()=n_parts;
if (n_parts == 1)
{
this->single_partition (mesh);
return;
}
// First assign a temporary partitioning to any unpartitioned elements
Partitioner::partition_unpartitioned_elements(mesh, n_parts);
// Call the partitioning function
this->_do_repartition(mesh,n_parts);
// Set the parent's processor ids
Partitioner::set_parent_processor_ids(mesh);
// Set the node's processor ids
Partitioner::set_node_processor_ids(mesh);
}

void Partitioner::set_node_processor_ids (MeshBase &mesh) [static, inherited]This function is called after partitioning to set the processor IDs for the nodes. By definition, a Node's processor ID is the minimum processor ID for all of the elements which share the node.

void Partitioner::set_parent_processor_ids (MeshBase &mesh) [static, inherited]This function is called after partitioning to set the processor IDs for the inactive parent elements. A Parent's processor ID is the same as its first child.

void Partitioner::single_partition (MeshBase &mesh) [protected, inherited]Trivially 'partitions' the mesh for one processor. Simply loops through the elements and assigns all of them to processor 0. Is is provided as a separate function so that derived classes may use it without reimplementing it.

Member Data Documentation

const unsigned int Partitioner::communication_blocksize = 1000000 [static, protected, inherited]The blocksize to use when doing blocked parallel communication. This limits the maximum vector size which can be used in a single communication step.