NodeWiseMeshPartitioner.h

Go to the documentation of this file.

 
#pragma once
 
#include <memory>
#include <string>
#include <tuple>
#include <vector>
 
#include "MeshLib/Elements/Element.h"
#include "MeshLib/IO/MPI_IO/PropertyVectorMetaData.h"
#include "MeshLib/Mesh.h"
#include "MeshLib/Node.h"
 
namespace ApplicationUtils
{
struct Partition
{
    std::vector<MeshLib::Node const*> nodes;  
    std::size_t number_of_regular_base_nodes;
    std::size_t number_of_regular_nodes;
    std::size_t number_of_base_nodes;
    std::size_t number_of_mesh_base_nodes;
    std::size_t number_of_mesh_all_nodes;
    std::vector<const MeshLib::Element*> regular_elements;
    std::vector<const MeshLib::Element*> ghost_elements;
    std::vector<bool> duplicate_ghost_cell;
 
    std::size_t number_of_integration_points = 0;
 
    // Note: for property vector OGS_VERSION or IntegrationPointMetaData, the
    // number gotten from this function is not used for reading the property
    // vector under MPI because the sizes of the partitions of such vectors are
    // the same.
    std::size_t numberOfMeshItems(MeshLib::MeshItemType const item_type) const;
 
    std::ostream& writeNodes(
        std::ostream& os,
        std::vector<std::size_t> const& global_node_ids) const;
 
    std::ostream& writeConfig(std::ostream& os) const;
};
 
MeshLib::Properties partitionProperties(
    std::unique_ptr<MeshLib::Mesh> const& mesh,
    std::vector<Partition>& partitions);
 
class NodeWiseMeshPartitioner
{
public:
    using IntegerType = long;
 
public:
    NodeWiseMeshPartitioner(const IntegerType num_partitions,
                            std::unique_ptr<MeshLib::Mesh>&& mesh)
        : _partitions(num_partitions),
          _partitioned_properties(),
          _mesh(std::move(mesh)),
          _nodes_global_ids(_mesh->getNumberOfNodes()),
          _nodes_partition_ids(_mesh->getNumberOfNodes())
    {
    }
 
    void partitionByMETIS();
 
    std::vector<Partition> partitionOtherMesh(MeshLib::Mesh const& mesh) const;
 
    void renumberBulkIdsProperty(std::vector<Partition> const& partitions,
                                 MeshLib::Properties& partitioned_properties);
 
    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)
    {
        _nodes_partition_ids = std::move(node_partition_ids);
    }
 
    MeshLib::Mesh const& mesh() const { return *_mesh; }
 
private:
    std::vector<Partition> _partitions;
 
    MeshLib::Properties _partitioned_properties;
 
    std::unique_ptr<MeshLib::Mesh> _mesh;
 
    std::vector<std::size_t> _nodes_global_ids;
 
    std::vector<std::size_t> _nodes_partition_ids;
 
    // Renumber the global indices of nodes,
    void renumberNodeIndices();
 
    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;
};
 
}  // namespace ApplicationUtils