OGS
ApplicationUtils::NodeWiseMeshPartitioner Class Reference

Detailed Description

Mesh partitioner.

Definition at line 58 of file NodeWiseMeshPartitioner.h.

#include <NodeWiseMeshPartitioner.h>

Collaboration diagram for ApplicationUtils::NodeWiseMeshPartitioner:
[legend]

Public Types

using IntegerType = long
 

Public Member Functions

 NodeWiseMeshPartitioner (const IntegerType num_partitions, std::unique_ptr< MeshLib::Mesh > &&mesh)
 
void partitionByMETIS (const bool is_mixed_high_order_linear_elems)
 
std::vector< PartitionpartitionOtherMesh (MeshLib::Mesh const &mesh, bool const is_mixed_high_order_linear_elems) const
 
void renumberBulkNodeIdsProperty (MeshLib::PropertyVector< std::size_t > *const bulk_node_ids, std::vector< Partition > const &local_partitions) const
 
void renumberBulkElementIdsProperty (MeshLib::PropertyVector< std::size_t > *const bulk_element_ids_pv, std::vector< Partition > const &local_partitions) const
 
void write (const std::string &file_name_base)
 
void writeOtherMesh (std::string const &output_filename_base, std::vector< Partition > const &partitions, MeshLib::Properties const &partitioned_properties) const
 
void resetPartitionIdsForNodes (std::vector< std::size_t > &&node_partition_ids)
 
MeshLib::Mesh const & mesh () const
 

Private Member Functions

void renumberNodeIndices (const bool is_mixed_high_order_linear_elems)
 
void processPartition (std::size_t const part_id, const bool is_mixed_high_order_linear_elems)
 

Private Attributes

std::vector< Partition_partitions
 Data for all partitions. More...
 
MeshLib::Properties _partitioned_properties
 Properties where values at ghost nodes and extra nodes are inserted. More...
 
std::unique_ptr< MeshLib::Mesh_mesh
 Pointer to a mesh object. More...
 
std::vector< std::size_t > _nodes_global_ids
 Global IDs of all nodes after partitioning. More...
 
std::vector< std::size_t > _nodes_partition_ids
 Partition IDs of each nodes. More...
 

Member Typedef Documentation

◆ IntegerType

Constructor & Destructor Documentation

◆ NodeWiseMeshPartitioner()

ApplicationUtils::NodeWiseMeshPartitioner::NodeWiseMeshPartitioner ( const IntegerType  num_partitions,
std::unique_ptr< MeshLib::Mesh > &&  mesh 
)
inline
Parameters
num_partitionsNumber of partitions,
meshPointer to a mesh object.

Definition at line 68 of file NodeWiseMeshPartitioner.h.

70  : _partitions(num_partitions),
72  _mesh(std::move(mesh)),
73  _nodes_global_ids(_mesh->getNumberOfNodes()),
74  _nodes_partition_ids(_mesh->getNumberOfNodes())
75  {
76  }
std::unique_ptr< MeshLib::Mesh > _mesh
Pointer to a mesh object.
MeshLib::Properties _partitioned_properties
Properties where values at ghost nodes and extra nodes are inserted.
std::vector< std::size_t > _nodes_global_ids
Global IDs of all nodes after partitioning.
std::vector< Partition > _partitions
Data for all partitions.
std::vector< std::size_t > _nodes_partition_ids
Partition IDs of each nodes.

Member Function Documentation

◆ mesh()

MeshLib::Mesh const& ApplicationUtils::NodeWiseMeshPartitioner::mesh ( ) const
inline

Definition at line 115 of file NodeWiseMeshPartitioner.h.

115 { return *_mesh; }

References _mesh.

Referenced by MeshLib::addPropertyToMesh(), MeshLib::getOrCreateMeshProperty(), main(), and partitionOtherMesh().

◆ partitionByMETIS()

void ApplicationUtils::NodeWiseMeshPartitioner::partitionByMETIS ( const bool  is_mixed_high_order_linear_elems)

Partition by node.

Parameters
is_mixed_high_order_linear_elemsFlag to indicate whether the elements of a mesh can be used for both linear and high order interpolation

Definition at line 547 of file NodeWiseMeshPartitioner.cpp.

549 {
550  for (std::size_t part_id = 0; part_id < _partitions.size(); part_id++)
551  {
552  INFO("Processing partition: {:d}", part_id);
553  processPartition(part_id, is_mixed_high_order_linear_elems);
554  }
555 
557 
558  renumberNodeIndices(is_mixed_high_order_linear_elems);
559 
561  partitionProperties(_mesh->getProperties(), _partitions);
562 }
void INFO(char const *fmt, Args const &... args)
Definition: Logging.h:32
void processPartition(std::size_t const part_id, const bool is_mixed_high_order_linear_elems)
void renumberNodeIndices(const bool is_mixed_high_order_linear_elems)
MeshLib::Properties partitionProperties(MeshLib::Properties const &properties, std::vector< Partition > const &partitions)
Partition existing properties and add vtkGhostType cell data array property.
void markDuplicateGhostCells(MeshLib::Mesh const &mesh, std::vector< Partition > &partitions)

References _mesh, _partitioned_properties, _partitions, INFO(), ApplicationUtils::markDuplicateGhostCells(), ApplicationUtils::partitionProperties(), processPartition(), and renumberNodeIndices().

Referenced by main().

◆ partitionOtherMesh()

std::vector< Partition > ApplicationUtils::NodeWiseMeshPartitioner::partitionOtherMesh ( MeshLib::Mesh const &  mesh,
bool const  is_mixed_high_order_linear_elems 
) const

Definition at line 664 of file NodeWiseMeshPartitioner.cpp.

667 {
668  auto const& bulk_node_ids =
669  mesh.getProperties().getPropertyVector<std::size_t>(
670  "bulk_node_ids", MeshLib::MeshItemType::Node, 1);
671 
672  std::vector<Partition> partitions(_partitions.size());
673  for (std::size_t part_id = 0; part_id < _partitions.size(); part_id++)
674  {
675  auto& partition = partitions[part_id];
676  INFO("Processing partition: {:d}", part_id);
677  // Set the node numbers of base and all mesh nodes.
678  partition.number_of_mesh_base_nodes = mesh.getNumberOfBaseNodes();
679  partition.number_of_mesh_all_nodes = mesh.getNumberOfNodes();
680 
681  std::vector<MeshLib::Node*> higher_order_regular_nodes;
682  std::tie(partition.nodes, higher_order_regular_nodes) =
684  part_id, is_mixed_high_order_linear_elems, mesh.getNodes(),
685  _nodes_partition_ids, mesh, bulk_node_ids);
686 
687  partition.number_of_regular_base_nodes = partition.nodes.size();
688  partition.number_of_regular_nodes =
689  partition.number_of_regular_base_nodes +
690  higher_order_regular_nodes.size();
691 
692  std::tie(partition.regular_elements, partition.ghost_elements) =
694  _nodes_partition_ids, bulk_node_ids);
695 
696  std::vector<MeshLib::Node*> base_ghost_nodes;
697  std::vector<MeshLib::Node*> higher_order_ghost_nodes;
698  std::tie(base_ghost_nodes, higher_order_ghost_nodes) =
699  findGhostNodesInPartition(part_id, is_mixed_high_order_linear_elems,
700  mesh.getNodes(), partition.ghost_elements,
702  bulk_node_ids);
703 
704  std::copy(begin(base_ghost_nodes), end(base_ghost_nodes),
705  std::back_inserter(partition.nodes));
706 
707  partition.number_of_base_nodes = partition.nodes.size();
708 
709  if (is_mixed_high_order_linear_elems)
710  {
711  std::copy(begin(higher_order_regular_nodes),
712  end(higher_order_regular_nodes),
713  std::back_inserter(partition.nodes));
714  std::copy(begin(higher_order_ghost_nodes),
715  end(higher_order_ghost_nodes),
716  std::back_inserter(partition.nodes));
717  }
718  }
719 
720  markDuplicateGhostCells(mesh, partitions);
721  return partitions;
722 }
std::size_t getNumberOfBaseNodes() const
Get the number of base nodes.
Definition: Mesh.cpp:214
std::vector< Node * > const & getNodes() const
Get the nodes-vector for the mesh.
Definition: Mesh.h:95
std::vector< Element * > const & getElements() const
Get the element-vector for the mesh.
Definition: Mesh.h:98
Properties & getProperties()
Definition: Mesh.h:123
std::size_t getNumberOfNodes() const
Get the number of nodes.
Definition: Mesh.h:89
PropertyVector< T > const * getPropertyVector(std::string const &name) const
std::tuple< std::vector< MeshLib::Node * >, std::vector< MeshLib::Node * > > findGhostNodesInPartition(std::size_t const part_id, const bool is_mixed_high_order_linear_elems, std::vector< MeshLib::Node * > const &nodes, std::vector< MeshLib::Element const * > const &ghost_elements, std::vector< std::size_t > const &partition_ids, MeshLib::Mesh const &mesh, std::vector< std::size_t > const *node_id_mapping=nullptr)
std::tuple< std::vector< MeshLib::Element const * >, std::vector< MeshLib::Element const * > > findElementsInPartition(std::size_t const part_id, std::vector< MeshLib::Element * > const &elements, std::vector< std::size_t > const &partition_ids, std::vector< std::size_t > const *node_id_mapping=nullptr)
std::pair< std::vector< MeshLib::Node * >, std::vector< MeshLib::Node * > > findRegularNodesInPartition(std::size_t const part_id, const bool is_mixed_high_order_linear_elems, std::vector< MeshLib::Node * > const &nodes, std::vector< std::size_t > const &partition_ids, MeshLib::Mesh const &mesh, std::vector< std::size_t > const *node_id_mapping=nullptr)
void copy(PETScVector const &x, PETScVector &y)
Definition: LinAlg.cpp:37

References _nodes_partition_ids, _partitions, MathLib::LinAlg::copy(), ApplicationUtils::findElementsInPartition(), ApplicationUtils::findGhostNodesInPartition(), ApplicationUtils::findRegularNodesInPartition(), MeshLib::Mesh::getElements(), MeshLib::Mesh::getNodes(), MeshLib::Mesh::getNumberOfBaseNodes(), MeshLib::Mesh::getNumberOfNodes(), MeshLib::Mesh::getProperties(), MeshLib::Properties::getPropertyVector(), INFO(), ApplicationUtils::markDuplicateGhostCells(), mesh(), and MeshLib::Node.

Referenced by main().

◆ processPartition()

void ApplicationUtils::NodeWiseMeshPartitioner::processPartition ( std::size_t const  part_id,
const bool  is_mixed_high_order_linear_elems 
)
private

Definition at line 274 of file NodeWiseMeshPartitioner.cpp.

276 {
277  auto& partition = _partitions[part_id];
278  std::vector<MeshLib::Node*> higher_order_regular_nodes;
279  std::tie(partition.nodes, higher_order_regular_nodes) =
280  findRegularNodesInPartition(part_id, is_mixed_high_order_linear_elems,
281  _mesh->getNodes(), _nodes_partition_ids,
282  *_mesh);
283 
284  partition.number_of_regular_base_nodes = partition.nodes.size();
285  partition.number_of_regular_nodes = partition.number_of_regular_base_nodes +
286  higher_order_regular_nodes.size();
287 
288  std::tie(partition.regular_elements, partition.ghost_elements) =
289  findElementsInPartition(part_id, _mesh->getElements(),
291  std::vector<MeshLib::Node*> base_ghost_nodes;
292  std::vector<MeshLib::Node*> higher_order_ghost_nodes;
293  std::tie(base_ghost_nodes, higher_order_ghost_nodes) =
294  findGhostNodesInPartition(part_id, is_mixed_high_order_linear_elems,
295  _mesh->getNodes(), partition.ghost_elements,
297 
298  std::copy(begin(base_ghost_nodes), end(base_ghost_nodes),
299  std::back_inserter(partition.nodes));
300 
301  partition.number_of_base_nodes = partition.nodes.size();
302 
303  if (is_mixed_high_order_linear_elems)
304  {
305  std::copy(begin(higher_order_regular_nodes),
306  end(higher_order_regular_nodes),
307  std::back_inserter(partition.nodes));
308  std::copy(begin(higher_order_ghost_nodes),
309  end(higher_order_ghost_nodes),
310  std::back_inserter(partition.nodes));
311  }
312 
313  // Set the node numbers of base and all mesh nodes.
314  partition.number_of_mesh_base_nodes = _mesh->getNumberOfBaseNodes();
315  partition.number_of_mesh_all_nodes = _mesh->getNumberOfNodes();
316 }

References _mesh, _nodes_partition_ids, _partitions, MathLib::LinAlg::copy(), ApplicationUtils::findElementsInPartition(), ApplicationUtils::findGhostNodesInPartition(), and ApplicationUtils::findRegularNodesInPartition().

Referenced by partitionByMETIS().

◆ renumberBulkElementIdsProperty()

void ApplicationUtils::NodeWiseMeshPartitioner::renumberBulkElementIdsProperty ( MeshLib::PropertyVector< std::size_t > *const  bulk_element_ids_pv,
std::vector< Partition > const &  local_partitions 
) const

Renumber the bulk_element_ids property for each partition to match the partitioned bulk mesh elements.

Definition at line 606 of file NodeWiseMeshPartitioner.cpp.

609 {
610  if (bulk_element_ids_pv == nullptr)
611  {
612  return;
613  }
614 
615  auto& bulk_element_ids = *bulk_element_ids_pv;
616 
617  std::size_t offset = 0; // offset in property vector for current partition
618 
619  assert(_partitions.size() == local_partitions.size());
620  int const n_partitions = static_cast<int>(_partitions.size());
621  for (int partition_id = 0; partition_id < n_partitions; ++partition_id)
622  {
623  auto const& bulk_partition = _partitions[partition_id];
624  auto const& local_partition = local_partitions[partition_id];
625 
626  // Create global-to-local element id mapping for the bulk partition.
627  std::map<std::size_t, std::size_t> global_to_local;
628  auto map_elements =
629  [&global_to_local](
630  std::vector<MeshLib::Element const*> const& elements,
631  std::size_t const offset)
632  {
633  auto const n_elements = elements.size();
634  for (std::size_t e = 0; e < n_elements; ++e)
635  {
636  global_to_local[elements[e]->getID()] = offset + e;
637  }
638  };
639 
640  map_elements(bulk_partition.regular_elements, 0);
641  map_elements(bulk_partition.ghost_elements,
642  bulk_partition.regular_elements.size());
643 
644  // Renumber the local bulk_element_ids map.
645  auto renumber_elements =
646  [&bulk_element_ids, &global_to_local](
647  std::vector<MeshLib::Element const*> const& elements,
648  std::size_t const offset)
649  {
650  auto const n_elements = elements.size();
651  for (std::size_t e = 0; e < n_elements; ++e)
652  {
653  bulk_element_ids[offset + e] =
654  global_to_local[bulk_element_ids[offset + e]];
655  }
656  return n_elements;
657  };
658 
659  offset += renumber_elements(local_partition.regular_elements, offset);
660  offset += renumber_elements(local_partition.ghost_elements, offset);
661  }
662 }

References _partitions.

Referenced by main().

◆ renumberBulkNodeIdsProperty()

void ApplicationUtils::NodeWiseMeshPartitioner::renumberBulkNodeIdsProperty ( MeshLib::PropertyVector< std::size_t > *const  bulk_node_ids,
std::vector< Partition > const &  local_partitions 
) const

Renumber the bulk_node_ids property for each partition to match the partitioned bulk mesh nodes.

Definition at line 564 of file NodeWiseMeshPartitioner.cpp.

567 {
568  if (bulk_node_ids_pv == nullptr)
569  {
570  return;
571  }
572 
573  auto& bulk_node_ids = *bulk_node_ids_pv;
574 
575  std::size_t offset = 0; // offset in property vector for current partition
576 
577  assert(_partitions.size() == local_partitions.size());
578  int const n_partitions = static_cast<int>(_partitions.size());
579  for (int partition_id = 0; partition_id < n_partitions; ++partition_id)
580  {
581  auto const& bulk_partition = _partitions[partition_id];
582  auto const& local_partition = local_partitions[partition_id];
583 
584  // Create global-to-local node id mapping for the bulk partition.
585  auto const& bulk_nodes = bulk_partition.nodes;
586  auto const n_bulk_nodes = bulk_nodes.size();
587  std::map<std::size_t, std::size_t> global_to_local;
588  for (std::size_t local_node_id = 0; local_node_id < n_bulk_nodes;
589  ++local_node_id)
590  {
591  global_to_local[bulk_nodes[local_node_id]->getID()] = local_node_id;
592  }
593 
594  auto const& local_nodes = local_partition.nodes;
595  auto const n_local_nodes = local_nodes.size();
596  for (std::size_t local_node_id = 0; local_node_id < n_local_nodes;
597  ++local_node_id)
598  {
599  bulk_node_ids[offset + local_node_id] =
600  global_to_local[bulk_node_ids[offset + local_node_id]];
601  }
602  offset += n_local_nodes;
603  }
604 }

References _partitions.

Referenced by main().

◆ renumberNodeIndices()

void ApplicationUtils::NodeWiseMeshPartitioner::renumberNodeIndices ( const bool  is_mixed_high_order_linear_elems)
private
Parameters
is_mixed_high_order_linear_elemsFlag to indicate whether the elements of a mesh can be used for both linear and high order interpolation

Definition at line 724 of file NodeWiseMeshPartitioner.cpp.

726 {
727  std::size_t node_global_id_offset = 0;
728  // Renumber the global indices.
729  // -- Base nodes
730  for (auto& partition : _partitions)
731  {
732  for (std::size_t i = 0; i < partition.number_of_regular_base_nodes; i++)
733  {
734  _nodes_global_ids[partition.nodes[i]->getID()] =
735  node_global_id_offset;
736  node_global_id_offset++;
737  }
738  }
739 
740  if (!is_mixed_high_order_linear_elems)
741  {
742  return;
743  }
744 
745  // -- Nodes for high order elements.
746  for (auto& partition : _partitions)
747  {
748  const std::size_t end_id = partition.number_of_base_nodes +
749  partition.number_of_regular_nodes -
750  partition.number_of_regular_base_nodes;
751  for (std::size_t i = partition.number_of_base_nodes; i < end_id; i++)
752  {
753  _nodes_global_ids[partition.nodes[i]->getID()] =
754  node_global_id_offset;
755  node_global_id_offset++;
756  }
757  }
758 }

References _nodes_global_ids, and _partitions.

Referenced by partitionByMETIS().

◆ resetPartitionIdsForNodes()

void ApplicationUtils::NodeWiseMeshPartitioner::resetPartitionIdsForNodes ( std::vector< std::size_t > &&  node_partition_ids)
inline

Definition at line 109 of file NodeWiseMeshPartitioner.h.

111  {
112  _nodes_partition_ids = std::move(node_partition_ids);
113  }

References _nodes_partition_ids.

Referenced by main().

◆ write()

void ApplicationUtils::NodeWiseMeshPartitioner::write ( const std::string &  file_name_base)

Write the partitions into binary files

Parameters
file_name_baseThe prefix of the file name.

Definition at line 1078 of file NodeWiseMeshPartitioner.cpp.

1079 {
1084 
1085  const auto elements_offsets = writeConfigData(file_name_base, _partitions);
1086 
1087  const std::vector<IntegerType>& regular_element_offsets =
1088  std::get<0>(elements_offsets);
1089  const std::vector<IntegerType>& ghost_element_offsets =
1090  std::get<1>(elements_offsets);
1091  writeElements(file_name_base, _partitions, regular_element_offsets,
1092  ghost_element_offsets);
1093 
1094  writeNodes(file_name_base, _partitions, _nodes_global_ids);
1095 }
void writeNodes(const std::string &file_name_base, std::vector< Partition > const &partitions, std::vector< std::size_t > const &global_node_ids)
std::tuple< std::vector< long >, std::vector< long > > writeConfigData(const std::string &file_name_base, std::vector< Partition > const &partitions)
void writeProperties(const std::string &file_name_base, MeshLib::Properties const &partitioned_properties, std::vector< Partition > const &partitions, MeshLib::MeshItemType const mesh_item_type)
void writeElements(std::string const &file_name_base, std::vector< Partition > const &partitions, std::vector< long > const &regular_element_offsets, std::vector< long > const &ghost_element_offsets)

References _nodes_global_ids, _partitioned_properties, _partitions, MeshLib::Cell, MeshLib::Node, ApplicationUtils::writeConfigData(), ApplicationUtils::writeElements(), ApplicationUtils::writeNodes(), and ApplicationUtils::writeProperties().

Referenced by main().

◆ writeOtherMesh()

void ApplicationUtils::NodeWiseMeshPartitioner::writeOtherMesh ( std::string const &  output_filename_base,
std::vector< Partition > const &  partitions,
MeshLib::Properties const &  partitioned_properties 
) const

Definition at line 1097 of file NodeWiseMeshPartitioner.cpp.

1101 {
1102  writeNodes(output_filename_base, partitions, _nodes_global_ids);
1103 
1104  const auto elem_integers =
1105  writeConfigData(output_filename_base, partitions);
1106 
1107  const std::vector<IntegerType>& num_elem_integers =
1108  std::get<0>(elem_integers);
1109  const std::vector<IntegerType>& num_g_elem_integers =
1110  std::get<1>(elem_integers);
1111  writeElements(output_filename_base, partitions, num_elem_integers,
1112  num_g_elem_integers);
1113 
1114  writeProperties(output_filename_base, partitioned_properties, partitions,
1116  writeProperties(output_filename_base, partitioned_properties, partitions,
1118 }

References _nodes_global_ids, MeshLib::Cell, MeshLib::Node, ApplicationUtils::writeConfigData(), ApplicationUtils::writeElements(), ApplicationUtils::writeNodes(), and ApplicationUtils::writeProperties().

Referenced by main().

Member Data Documentation

◆ _mesh

std::unique_ptr<MeshLib::Mesh> ApplicationUtils::NodeWiseMeshPartitioner::_mesh
private

Pointer to a mesh object.

Definition at line 125 of file NodeWiseMeshPartitioner.h.

Referenced by mesh(), partitionByMETIS(), and processPartition().

◆ _nodes_global_ids

std::vector<std::size_t> ApplicationUtils::NodeWiseMeshPartitioner::_nodes_global_ids
private

Global IDs of all nodes after partitioning.

Definition at line 128 of file NodeWiseMeshPartitioner.h.

Referenced by renumberNodeIndices(), write(), and writeOtherMesh().

◆ _nodes_partition_ids

std::vector<std::size_t> ApplicationUtils::NodeWiseMeshPartitioner::_nodes_partition_ids
private

Partition IDs of each nodes.

Definition at line 131 of file NodeWiseMeshPartitioner.h.

Referenced by partitionOtherMesh(), processPartition(), and resetPartitionIdsForNodes().

◆ _partitioned_properties

MeshLib::Properties ApplicationUtils::NodeWiseMeshPartitioner::_partitioned_properties
private

Properties where values at ghost nodes and extra nodes are inserted.

Definition at line 122 of file NodeWiseMeshPartitioner.h.

Referenced by partitionByMETIS(), and write().

◆ _partitions

std::vector<Partition> ApplicationUtils::NodeWiseMeshPartitioner::_partitions
private

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