libMesh
Public Types | Public Member Functions | Static Public Member Functions | Protected Member Functions | Protected Attributes | Static Protected Attributes | Private Member Functions | Static Private Member Functions | Private Attributes | List of all members
libMesh::CentroidPartitioner Class Reference

Partitions the Mesh based on the locations of element centroids. More...

#include <centroid_partitioner.h>

Inheritance diagram for libMesh::CentroidPartitioner:
[legend]

Public Types

enum  CentroidSortMethod {
  X =0, Y, Z, RADIAL,
  INVALID_METHOD
}
 A typedef which controls the sorting method used for ordering the centroids. More...
 

Public Member Functions

 CentroidPartitioner (const CentroidSortMethod sm=X)
 Constructor. More...
 
 CentroidPartitioner (const CentroidPartitioner &)=default
 Copy/move ctor, copy/move assignment operator, and destructor are all explicitly defaulted for this class. More...
 
 CentroidPartitioner (CentroidPartitioner &&)=default
 
CentroidPartitioneroperator= (const CentroidPartitioner &)=default
 
CentroidPartitioneroperator= (CentroidPartitioner &&)=default
 
virtual ~CentroidPartitioner ()=default
 
virtual std::unique_ptr< Partitionerclone () const override
 
CentroidSortMethod sort_method () const
 Getter for the current sorting method. More...
 
void set_sort_method (const CentroidSortMethod sm)
 Setter for the current sorting method. More...
 
virtual void partition_range (MeshBase &mesh, MeshBase::element_iterator it, MeshBase::element_iterator end, const unsigned int n) override
 Called by the SubdomainPartitioner to partition elements in the range (it, end). More...
 
virtual void partition (MeshBase &mesh, const unsigned int n)
 Partitions the MeshBase into n parts by setting processor_id() on Nodes and Elems. More...
 
virtual void partition (MeshBase &mesh)
 Partitions the MeshBase into mesh.n_processors() by setting processor_id() on Nodes and Elems. More...
 
void repartition (MeshBase &mesh, const unsigned int n)
 Repartitions the MeshBase into n parts. More...
 
void repartition (MeshBase &mesh)
 Repartitions the MeshBase into mesh.n_processors() parts. More...
 
virtual void attach_weights (ErrorVector *)
 Attach weights that can be used for partitioning. More...
 

Static Public Member Functions

static void partition_unpartitioned_elements (MeshBase &mesh)
 These functions assign processor IDs to newly-created elements (in parallel) which are currently assigned to processor 0. More...
 
static void partition_unpartitioned_elements (MeshBase &mesh, const unsigned int n)
 
static void set_parent_processor_ids (MeshBase &mesh)
 This function is called after partitioning to set the processor IDs for the inactive parent elements. More...
 
static void set_node_processor_ids (MeshBase &mesh)
 This function is called after partitioning to set the processor IDs for the nodes. More...
 
static void processor_pairs_to_interface_nodes (MeshBase &mesh, std::map< std::pair< processor_id_type, processor_id_type >, std::set< dof_id_type >> &processor_pair_to_nodes)
 On the partitioning interface, a surface is shared by two and only two processors. More...
 
static void set_interface_node_processor_ids_linear (MeshBase &mesh)
 Nodes on the partitioning interface is linearly assigned to each pair of processors. More...
 
static void set_interface_node_processor_ids_BFS (MeshBase &mesh)
 Nodes on the partitioning interface is clustered into two groups BFS (Breadth First Search)scheme for per pair of processors. More...
 
static void set_interface_node_processor_ids_petscpartitioner (MeshBase &mesh)
 Nodes on the partitioning interface is partitioned into two groups using a PETSc partitioner for each pair of processors. More...
 

Protected Member Functions

virtual void _do_partition (MeshBase &mesh, const unsigned int n) override
 Partitions the mesh into n subdomains. More...
 
void single_partition (MeshBase &mesh)
 Trivially "partitions" the mesh for one processor. More...
 
void single_partition_range (MeshBase::element_iterator it, MeshBase::element_iterator end)
 Slightly generalized version of single_partition which acts on a range of elements defined by the pair of iterators (it, end). More...
 
virtual void _do_repartition (MeshBase &mesh, const unsigned int n)
 This is the actual re-partitioning method which can be overridden in derived classes. More...
 
virtual void _find_global_index_by_pid_map (const MeshBase &mesh)
 Construct contiguous global indices for the current partitioning. More...
 
virtual void build_graph (const MeshBase &mesh)
 Build a dual graph for partitioner. More...
 
void assign_partitioning (const MeshBase &mesh, const std::vector< dof_id_type > &parts)
 Assign the computed partitioning to the mesh. More...
 

Protected Attributes

ErrorVector_weights
 The weights that might be used for partitioning. More...
 
std::unordered_map< dof_id_type, dof_id_type_global_index_by_pid_map
 Maps active element ids into a contiguous range, as needed by parallel partitioner. More...
 
std::vector< dof_id_type_n_active_elem_on_proc
 The number of active elements on each processor. More...
 
std::vector< std::vector< dof_id_type > > _dual_graph
 A dual graph corresponds to the mesh, and it is typically used in paritioner. More...
 
std::vector< Elem * > _local_id_to_elem
 

Static Protected Attributes

static const dof_id_type communication_blocksize
 The blocksize to use when doing blocked parallel communication. More...
 

Private Member Functions

void compute_centroids (MeshBase::element_iterator it, MeshBase::element_iterator end)
 Computes a list of element centroids for the mesh. More...
 

Static Private Member Functions

static bool sort_x (const std::pair< Point, Elem *> &lhs, const std::pair< Point, Elem *> &rhs)
 Helper function which sorts by the centroid's x-coordinate in the internal std::sort call. More...
 
static bool sort_y (const std::pair< Point, Elem *> &lhs, const std::pair< Point, Elem *> &rhs)
 Helper function which sorts by the centroid's y-coordinate in the internal std::sort call. More...
 
static bool sort_z (const std::pair< Point, Elem *> &lhs, const std::pair< Point, Elem *> &rhs)
 Helper function which sorts by the centroid's z-coordinate in the internal std::sort call. More...
 
static bool sort_radial (const std::pair< Point, Elem *> &lhs, const std::pair< Point, Elem *> &rhs)
 Helper function which sorts by the centroid's distance from the origin in the internal std::sort call. More...
 

Private Attributes

CentroidSortMethod _sort_method
 Flag indicating the type of sort method we are using. More...
 
std::vector< std::pair< Point, Elem * > > _elem_centroids
 Vector which holds pairs of centroids and their respective element pointers. More...
 

Detailed Description

Partitions the Mesh based on the locations of element centroids.

You must define what you mean by "less than" for the list of element centroids, e.g. if you only care about distance in the z-direction, you would define "less than" differently than if you cared about radial distance.

Author
John W. Peterson
Benjamin S. Kirk
Date
2003

Definition at line 48 of file centroid_partitioner.h.

Member Enumeration Documentation

◆ CentroidSortMethod

A typedef which controls the sorting method used for ordering the centroids.

If e.g. X is chosen, then the centroids will be sorted according to their x-coordinate.

Enumerator
RADIAL 
INVALID_METHOD 

Definition at line 57 of file centroid_partitioner.h.

Constructor & Destructor Documentation

◆ CentroidPartitioner() [1/3]

libMesh::CentroidPartitioner::CentroidPartitioner ( const CentroidSortMethod  sm = X)
explicit

Constructor.

Takes the CentroidSortMethod to use, which defaults to X ordering.

Definition at line 68 of file centroid_partitioner.h.

68 : _sort_method(sm) {}
CentroidSortMethod _sort_method
Flag indicating the type of sort method we are using.

◆ CentroidPartitioner() [2/3]

libMesh::CentroidPartitioner::CentroidPartitioner ( const CentroidPartitioner )
default

Copy/move ctor, copy/move assignment operator, and destructor are all explicitly defaulted for this class.

◆ CentroidPartitioner() [3/3]

libMesh::CentroidPartitioner::CentroidPartitioner ( CentroidPartitioner &&  )
default

◆ ~CentroidPartitioner()

virtual libMesh::CentroidPartitioner::~CentroidPartitioner ( )
virtualdefault

Member Function Documentation

◆ _do_partition()

virtual void libMesh::CentroidPartitioner::_do_partition ( MeshBase mesh,
const unsigned int  n 
)
overrideprotectedvirtual

Partitions the mesh into n subdomains.

Implements libMesh::Partitioner.

◆ _do_repartition()

virtual void libMesh::Partitioner::_do_repartition ( MeshBase mesh,
const unsigned int  n 
)
protectedvirtualinherited

This is the actual re-partitioning method which can be overridden in derived classes.

Note
The default behavior is to simply call the partition function.

Reimplemented in libMesh::ParmetisPartitioner.

Definition at line 237 of file partitioner.h.

References libMesh::Partitioner::_do_partition().

238  { this->_do_partition (mesh, n); }
virtual void _do_partition(MeshBase &mesh, const unsigned int n)=0
This is the actual partitioning method which must be overridden in derived classes.

◆ _find_global_index_by_pid_map()

virtual void libMesh::Partitioner::_find_global_index_by_pid_map ( const MeshBase mesh)
protectedvirtualinherited

Construct contiguous global indices for the current partitioning.

The global indices are ordered part-by-part

◆ assign_partitioning()

void libMesh::Partitioner::assign_partitioning ( const MeshBase mesh,
const std::vector< dof_id_type > &  parts 
)
protectedinherited

Assign the computed partitioning to the mesh.

◆ attach_weights()

virtual void libMesh::Partitioner::attach_weights ( ErrorVector )
virtualinherited

Attach weights that can be used for partitioning.

This ErrorVector should be exactly the same on every processor and should have mesh->max_elem_id() entries.

Reimplemented in libMesh::MetisPartitioner.

Definition at line 203 of file partitioner.h.

203 { libmesh_not_implemented(); }

◆ build_graph()

virtual void libMesh::Partitioner::build_graph ( const MeshBase mesh)
protectedvirtualinherited

Build a dual graph for partitioner.

Reimplemented in libMesh::ParmetisPartitioner.

◆ clone()

virtual std::unique_ptr<Partitioner> libMesh::CentroidPartitioner::clone ( ) const
overridevirtual
Returns
A copy of this partitioner wrapped in a smart pointer.

Implements libMesh::Partitioner.

Definition at line 83 of file centroid_partitioner.h.

84  {
85  return libmesh_make_unique<CentroidPartitioner>(*this);
86  }

◆ compute_centroids()

void libMesh::CentroidPartitioner::compute_centroids ( MeshBase::element_iterator  it,
MeshBase::element_iterator  end 
)
private

Computes a list of element centroids for the mesh.

◆ operator=() [1/2]

CentroidPartitioner& libMesh::CentroidPartitioner::operator= ( const CentroidPartitioner )
default

◆ operator=() [2/2]

CentroidPartitioner& libMesh::CentroidPartitioner::operator= ( CentroidPartitioner &&  )
default

◆ partition() [1/2]

virtual void libMesh::Partitioner::partition ( MeshBase mesh,
const unsigned int  n 
)
virtualinherited

Partitions the MeshBase into n parts by setting processor_id() on Nodes and Elems.

Note
If you are implementing a new type of Partitioner, you most likely do not want to override the partition() function, see instead the protected virtual _do_partition() method below. The partition() function is responsible for doing a lot of libmesh-internals-specific setup and finalization before and after the _do_partition() function is called. The only responsibility of the _do_partition() function, on the other hand, is to set the processor IDs of the elements according to a specific partitioning algorithm. See, e.g. MetisPartitioner for an example.

◆ partition() [2/2]

virtual void libMesh::Partitioner::partition ( MeshBase mesh)
virtualinherited

Partitions the MeshBase into mesh.n_processors() by setting processor_id() on Nodes and Elems.

Note
If you are implementing a new type of Partitioner, you most likely do not want to override the partition() function, see instead the protected virtual _do_partition() method below. The partition() function is responsible for doing a lot of libmesh-internals-specific setup and finalization before and after the _do_partition() function is called. The only responsibility of the _do_partition() function, on the other hand, is to set the processor IDs of the elements according to a specific partitioning algorithm. See, e.g. MetisPartitioner for an example.

◆ partition_range()

virtual void libMesh::CentroidPartitioner::partition_range ( MeshBase mesh,
MeshBase::element_iterator  it,
MeshBase::element_iterator  end,
const unsigned int  n 
)
overridevirtual

Called by the SubdomainPartitioner to partition elements in the range (it, end).

Reimplemented from libMesh::Partitioner.

◆ partition_unpartitioned_elements() [1/2]

static void libMesh::Partitioner::partition_unpartitioned_elements ( MeshBase mesh)
staticinherited

These functions assign processor IDs to newly-created elements (in parallel) which are currently assigned to processor 0.

◆ partition_unpartitioned_elements() [2/2]

static void libMesh::Partitioner::partition_unpartitioned_elements ( MeshBase mesh,
const unsigned int  n 
)
staticinherited

◆ processor_pairs_to_interface_nodes()

static void libMesh::Partitioner::processor_pairs_to_interface_nodes ( MeshBase mesh,
std::map< std::pair< processor_id_type, processor_id_type >, std::set< dof_id_type >> &  processor_pair_to_nodes 
)
staticinherited

On the partitioning interface, a surface is shared by two and only two processors.

Try to find which pair of processors corresponds to which surfaces, and store their nodes.

◆ repartition() [1/2]

void libMesh::Partitioner::repartition ( MeshBase mesh,
const unsigned int  n 
)
inherited

Repartitions the MeshBase into n parts.

(Some partitioning algorithms can repartition more efficiently than computing a new partitioning from scratch.) The default behavior is to simply call this->partition(mesh,n).

◆ repartition() [2/2]

void libMesh::Partitioner::repartition ( MeshBase mesh)
inherited

Repartitions the MeshBase into mesh.n_processors() parts.

This is required since some partitioning algorithms can repartition more efficiently than computing a new partitioning from scratch.

◆ set_interface_node_processor_ids_BFS()

static void libMesh::Partitioner::set_interface_node_processor_ids_BFS ( MeshBase mesh)
staticinherited

Nodes on the partitioning interface is clustered into two groups BFS (Breadth First Search)scheme for per pair of processors.

◆ set_interface_node_processor_ids_linear()

static void libMesh::Partitioner::set_interface_node_processor_ids_linear ( MeshBase mesh)
staticinherited

Nodes on the partitioning interface is linearly assigned to each pair of processors.

◆ set_interface_node_processor_ids_petscpartitioner()

static void libMesh::Partitioner::set_interface_node_processor_ids_petscpartitioner ( MeshBase mesh)
staticinherited

Nodes on the partitioning interface is partitioned into two groups using a PETSc partitioner for each pair of processors.

◆ set_node_processor_ids()

static void libMesh::Partitioner::set_node_processor_ids ( MeshBase mesh)
staticinherited

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.

◆ set_parent_processor_ids()

static void libMesh::Partitioner::set_parent_processor_ids ( MeshBase mesh)
staticinherited

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.

◆ set_sort_method()

void libMesh::CentroidPartitioner::set_sort_method ( const CentroidSortMethod  sm)

Setter for the current sorting method.

Definition at line 96 of file centroid_partitioner.h.

References _sort_method.

96 { _sort_method = sm; }
CentroidSortMethod _sort_method
Flag indicating the type of sort method we are using.

◆ single_partition()

void libMesh::Partitioner::single_partition ( MeshBase mesh)
protectedinherited

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.

◆ single_partition_range()

void libMesh::Partitioner::single_partition_range ( MeshBase::element_iterator  it,
MeshBase::element_iterator  end 
)
protectedinherited

Slightly generalized version of single_partition which acts on a range of elements defined by the pair of iterators (it, end).

◆ sort_method()

CentroidSortMethod libMesh::CentroidPartitioner::sort_method ( ) const

Getter for the current sorting method.

Definition at line 91 of file centroid_partitioner.h.

References _sort_method.

91 { return _sort_method; }
CentroidSortMethod _sort_method
Flag indicating the type of sort method we are using.

◆ sort_radial()

static bool libMesh::CentroidPartitioner::sort_radial ( const std::pair< Point, Elem *> &  lhs,
const std::pair< Point, Elem *> &  rhs 
)
staticprivate

Helper function which sorts by the centroid's distance from the origin in the internal std::sort call.

◆ sort_x()

static bool libMesh::CentroidPartitioner::sort_x ( const std::pair< Point, Elem *> &  lhs,
const std::pair< Point, Elem *> &  rhs 
)
staticprivate

Helper function which sorts by the centroid's x-coordinate in the internal std::sort call.

◆ sort_y()

static bool libMesh::CentroidPartitioner::sort_y ( const std::pair< Point, Elem *> &  lhs,
const std::pair< Point, Elem *> &  rhs 
)
staticprivate

Helper function which sorts by the centroid's y-coordinate in the internal std::sort call.

◆ sort_z()

static bool libMesh::CentroidPartitioner::sort_z ( const std::pair< Point, Elem *> &  lhs,
const std::pair< Point, Elem *> &  rhs 
)
staticprivate

Helper function which sorts by the centroid's z-coordinate in the internal std::sort call.

Member Data Documentation

◆ _dual_graph

std::vector<std::vector<dof_id_type> > libMesh::Partitioner::_dual_graph
protectedinherited

A dual graph corresponds to the mesh, and it is typically used in paritioner.

A vertex represents an element, and its neighbors are the element neighbors.

Definition at line 288 of file partitioner.h.

◆ _elem_centroids

std::vector<std::pair<Point, Elem *> > libMesh::CentroidPartitioner::_elem_centroids
private

Vector which holds pairs of centroids and their respective element pointers.

Definition at line 159 of file centroid_partitioner.h.

◆ _global_index_by_pid_map

std::unordered_map<dof_id_type, dof_id_type> libMesh::Partitioner::_global_index_by_pid_map
protectedinherited

Maps active element ids into a contiguous range, as needed by parallel partitioner.

Definition at line 272 of file partitioner.h.

◆ _local_id_to_elem

std::vector<Elem *> libMesh::Partitioner::_local_id_to_elem
protectedinherited

Definition at line 291 of file partitioner.h.

◆ _n_active_elem_on_proc

std::vector<dof_id_type> libMesh::Partitioner::_n_active_elem_on_proc
protectedinherited

The number of active elements on each processor.

Note
ParMETIS requires that each processor have some active elements; it will abort if any processor passes a nullptr _part array.

Definition at line 281 of file partitioner.h.

◆ _sort_method

CentroidSortMethod libMesh::CentroidPartitioner::_sort_method
private

Flag indicating the type of sort method we are using.

Definition at line 153 of file centroid_partitioner.h.

Referenced by set_sort_method(), and sort_method().

◆ _weights

ErrorVector* libMesh::Partitioner::_weights
protectedinherited

The weights that might be used for partitioning.

Definition at line 267 of file partitioner.h.

Referenced by libMesh::MetisPartitioner::attach_weights().

◆ communication_blocksize

const dof_id_type libMesh::Partitioner::communication_blocksize
staticprotectedinherited

The blocksize to use when doing blocked parallel communication.

This limits the maximum vector size which can be used in a single communication step.

Definition at line 244 of file partitioner.h.


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