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*> 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 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(
    MeshLib::Properties const& properties,
    std::vector<Partition> const& 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(const bool is_mixed_high_order_linear_elems);
 
    std::vector<Partition> partitionOtherMesh(
        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)
    {
        _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(const bool is_mixed_high_order_linear_elems);
 
    void processPartition(std::size_t const part_id,
                          const bool is_mixed_high_order_linear_elems);
};
 
}  // namespace ApplicationUtils