ApplicationUtils::NodeWiseMeshPartitioner Class Reference

Detailed Description

Mesh partitioner.

Definition at line 64 of file NodeWiseMeshPartitioner.h.

#include <NodeWiseMeshPartitioner.h>

Collaboration diagram for ApplicationUtils::NodeWiseMeshPartitioner:

Public Types
using	IntegerType = long

Public Member Functions
	NodeWiseMeshPartitioner (const IntegerType num_partitions, std::unique_ptr< MeshLib::Mesh > &&mesh)
void	partitionByMETIS ()
	Partition by node.
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)
MeshLib::Mesh const &	mesh () const

Private Member Functions
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

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

Member Typedef Documentation

IntegerType

using ApplicationUtils::NodeWiseMeshPartitioner::IntegerType = long

Definition at line 67 of file NodeWiseMeshPartitioner.h.

Constructor & Destructor Documentation

NodeWiseMeshPartitioner()

ApplicationUtils::NodeWiseMeshPartitioner::NodeWiseMeshPartitioner ( const IntegerType num_partitions, std::unique_ptr< MeshLib::Mesh > && mesh )

inline

Parameters

num_partitions	Number of partitions,
mesh	Pointer to a mesh object.

Definition at line 74 of file NodeWiseMeshPartitioner.h.

        : _partitions(num_partitions),
          _partitioned_properties(),
          _mesh(std::move(mesh)),
          _nodes_global_ids(_mesh->getNumberOfNodes()),
          _nodes_partition_ids(_mesh->getNumberOfNodes())
    {
    }

Member Function Documentation

mesh()

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

inline

Definition at line 107 of file NodeWiseMeshPartitioner.h.

{ return *_mesh; }

References _mesh.

Referenced by main(), and partitionOtherMesh().

partitionByMETIS()

void ApplicationUtils::NodeWiseMeshPartitioner::partitionByMETIS

(

)

Partition by node.

Definition at line 742 of file NodeWiseMeshPartitioner.cpp.

{
    std::vector<std::size_t> bulk_node_ids(_mesh->getNumberOfNodes());
    std::iota(bulk_node_ids.begin(), bulk_node_ids.end(), 0);
 
    partitionMesh(_partitions, *_mesh, _nodes_partition_ids, bulk_node_ids);
 
    renumberNodeIndices();
 
    // In case the field data in the vtu file are manually added, e.g. by using
    // some tools, the size of the field property vector has to be checked.
    checkFieldPropertyVectorSize(_mesh->getElements(), _mesh->getProperties());
 
    _partitioned_properties = partitionProperties(_mesh, _partitions);
 
    renumberBulkIdsProperty(_partitions, _partitioned_properties);
}

References _mesh, _nodes_partition_ids, _partitioned_properties, _partitions, ApplicationUtils::checkFieldPropertyVectorSize(), ApplicationUtils::partitionMesh(), ApplicationUtils::partitionProperties(), renumberBulkIdsProperty(), and renumberNodeIndices().

Referenced by main().

partitionOtherMesh()

std::vector< Partition > ApplicationUtils::NodeWiseMeshPartitioner::partitionOtherMesh

(

MeshLib::Mesh const &

mesh

)

const

Definition at line 886 of file NodeWiseMeshPartitioner.cpp.

{
    auto const bulk_node_ids_string =
        MeshLib::getBulkIDString(MeshLib::MeshItemType::Node);
    auto const& bulk_node_ids =
        mesh.getProperties().getPropertyVector<std::size_t>(
            bulk_node_ids_string, MeshLib::MeshItemType::Node, 1);
 
    std::vector<Partition> partitions(_partitions.size());
 
    partitionMesh(partitions, mesh, _nodes_partition_ids, *bulk_node_ids);
 
    return partitions;
}

References _nodes_partition_ids, _partitions, MeshLib::getBulkIDString(), MeshLib::Mesh::getProperties(), MeshLib::Properties::getPropertyVector(), mesh(), MeshLib::Node, and ApplicationUtils::partitionMesh().

Referenced by main().

renumberBulkElementIdsProperty()

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

private

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

Definition at line 828 of file NodeWiseMeshPartitioner.cpp.

{
    if (bulk_element_ids_pv == nullptr)
    {
        return;
    }
 
    auto& bulk_element_ids = *bulk_element_ids_pv;
 
    std::size_t offset = 0;  // offset in property vector for current partition
 
    assert(_partitions.size() == local_partitions.size());
    int const n_partitions = static_cast<int>(_partitions.size());
    for (int partition_id = 0; partition_id < n_partitions; ++partition_id)
    {
        auto const& bulk_partition = _partitions[partition_id];
        auto const& local_partition = local_partitions[partition_id];
 
        // Create global-to-local element id mapping for the bulk partition.
        std::map<std::size_t, std::size_t> global_to_local;
        auto map_elements =
            [&global_to_local](
                std::vector<MeshLib::Element const*> const& elements,
                std::size_t const offset)
        {
            auto const n_elements = elements.size();
            for (std::size_t e = 0; e < n_elements; ++e)
            {
                global_to_local[elements[e]->getID()] = offset + e;
            }
        };
 
        map_elements(bulk_partition.regular_elements, 0);
        map_elements(bulk_partition.ghost_elements,
                     bulk_partition.regular_elements.size());
 
        // Renumber the local bulk_element_ids map.
        auto renumber_elements =
            [&bulk_element_ids, &global_to_local](
                std::vector<MeshLib::Element const*> const& elements,
                std::size_t const offset)
        {
            auto const n_elements = elements.size();
            for (std::size_t e = 0; e < n_elements; ++e)
            {
                bulk_element_ids[offset + e] =
                    global_to_local[bulk_element_ids[offset + e]];
            }
            return n_elements;
        };
 
        offset += renumber_elements(local_partition.regular_elements, offset);
        offset += renumber_elements(local_partition.ghost_elements, offset);
    }
}

References _partitions.

Referenced by renumberBulkIdsProperty().

renumberBulkIdsProperty()

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

Definition at line 760 of file NodeWiseMeshPartitioner.cpp.

{
    auto const bulk_node_ids_string =
        MeshLib::getBulkIDString(MeshLib::MeshItemType::Node);
    if (partitioned_properties.hasPropertyVector(bulk_node_ids_string))
    {
        renumberBulkNodeIdsProperty(
            partitioned_properties.getPropertyVector<std::size_t>(
                bulk_node_ids_string, MeshLib::MeshItemType::Node, 1),
            partitions);
    }
    auto const bulk_element_ids_string =
        MeshLib::getBulkIDString(MeshLib::MeshItemType::Cell);
    if (partitioned_properties.hasPropertyVector<std::size_t>(
            static_cast<std::string>(bulk_element_ids_string),
            MeshLib::MeshItemType::Cell))
    {
        renumberBulkElementIdsProperty(
            partitioned_properties.getPropertyVector<std::size_t>(
                bulk_element_ids_string, MeshLib::MeshItemType::Cell, 1),
            partitions);
    }
}

References MeshLib::Cell, MeshLib::getBulkIDString(), MeshLib::Properties::getPropertyVector(), MeshLib::Properties::hasPropertyVector(), MeshLib::Node, renumberBulkElementIdsProperty(), and renumberBulkNodeIdsProperty().

Referenced by main(), and partitionByMETIS().

renumberBulkNodeIdsProperty()

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

private

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

Definition at line 786 of file NodeWiseMeshPartitioner.cpp.

{
    if (bulk_node_ids_pv == nullptr)
    {
        return;
    }
 
    auto& bulk_node_ids = *bulk_node_ids_pv;
 
    std::size_t offset = 0;  // offset in property vector for current partition
 
    assert(_partitions.size() == local_partitions.size());
    int const n_partitions = static_cast<int>(_partitions.size());
    for (int partition_id = 0; partition_id < n_partitions; ++partition_id)
    {
        auto const& bulk_partition = _partitions[partition_id];
        auto const& local_partition = local_partitions[partition_id];
 
        // Create global-to-local node id mapping for the bulk partition.
        auto const& bulk_nodes = bulk_partition.nodes;
        auto const n_bulk_nodes = bulk_nodes.size();
        std::map<std::size_t, std::size_t> global_to_local;
        for (std::size_t local_node_id = 0; local_node_id < n_bulk_nodes;
             ++local_node_id)
        {
            global_to_local[bulk_nodes[local_node_id]->getID()] = local_node_id;
        }
 
        auto const& local_nodes = local_partition.nodes;
        auto const n_local_nodes = local_nodes.size();
        for (std::size_t local_node_id = 0; local_node_id < n_local_nodes;
             ++local_node_id)
        {
            bulk_node_ids[offset + local_node_id] =
                global_to_local[bulk_node_ids[offset + local_node_id]];
        }
        offset += n_local_nodes;
    }
}

References _partitions.

Referenced by renumberBulkIdsProperty().

renumberNodeIndices()

void ApplicationUtils::NodeWiseMeshPartitioner::renumberNodeIndices ( )

private

Definition at line 902 of file NodeWiseMeshPartitioner.cpp.

{
    std::size_t node_global_id_offset = 0;
    // Renumber the global indices.
    for (auto& partition : _partitions)
    {
        for (std::size_t i = 0; i < partition.number_of_regular_nodes; i++)
        {
            _nodes_global_ids[partition.nodes[i]->getID()] =
                node_global_id_offset++;
        }
    }
}

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 101 of file NodeWiseMeshPartitioner.h.

    {
        _nodes_partition_ids = std::move(node_partition_ids);
    }

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_base

The prefix of the file name.

Definition at line 1234 of file NodeWiseMeshPartitioner.cpp.

{
    writeProperties(file_name_base, _partitioned_properties, _partitions,
                    MeshLib::MeshItemType::Node);
    writeProperties(file_name_base, _partitioned_properties, _partitions,
                    MeshLib::MeshItemType::Cell);
    writeProperties(file_name_base, _partitioned_properties, _partitions,
                    MeshLib::MeshItemType::IntegrationPoint);
 
    const auto elements_offsets = writeConfigData(file_name_base, _partitions);
 
    const std::vector<IntegerType>& regular_element_offsets =
        std::get<0>(elements_offsets);
    const std::vector<IntegerType>& ghost_element_offsets =
        std::get<1>(elements_offsets);
    writeElements(file_name_base, _partitions, regular_element_offsets,
                  ghost_element_offsets);
 
    writeNodes(file_name_base, _partitions, _nodes_global_ids);
}

References _nodes_global_ids, _partitioned_properties, _partitions, MeshLib::Cell, MeshLib::IntegrationPoint, 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 1255 of file NodeWiseMeshPartitioner.cpp.

{
    writeNodes(output_filename_base, partitions, _nodes_global_ids);
 
    const auto elem_integers =
        writeConfigData(output_filename_base, partitions);
 
    const std::vector<IntegerType>& num_elem_integers =
        std::get<0>(elem_integers);
    const std::vector<IntegerType>& num_g_elem_integers =
        std::get<1>(elem_integers);
    writeElements(output_filename_base, partitions, num_elem_integers,
                  num_g_elem_integers);
 
    writeProperties(output_filename_base, partitioned_properties, partitions,
                    MeshLib::MeshItemType::Node);
    writeProperties(output_filename_base, partitioned_properties, partitions,
                    MeshLib::MeshItemType::Cell);
}

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 117 of file NodeWiseMeshPartitioner.h.

Referenced by mesh(), and partitionByMETIS().

_nodes_global_ids

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

private

Global IDs of all nodes after partitioning.

Definition at line 120 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 123 of file NodeWiseMeshPartitioner.h.

Referenced by partitionByMETIS(), partitionOtherMesh(), 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 114 of file NodeWiseMeshPartitioner.h.

Referenced by partitionByMETIS(), and write().

_partitions

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

private

Data for all partitions.

Definition at line 111 of file NodeWiseMeshPartitioner.h.

Referenced by partitionByMETIS(), partitionOtherMesh(), renumberBulkElementIdsProperty(), renumberBulkNodeIdsProperty(), renumberNodeIndices(), and write().

---

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

• Applications/Utils/ModelPreparation/PartitionMesh/NodeWiseMeshPartitioner.h
• Applications/Utils/ModelPreparation/PartitionMesh/NodeWiseMeshPartitioner.cpp