NodePartitionedMesh.h

Go to the documentation of this file.

 
#pragma once
 
#include <algorithm>
#include <string>
#include <vector>
 
#include "Mesh.h"
#include "Node.h"
 
namespace MeshLib
{
class NodePartitionedMesh : public Mesh
{
public:
    // Copy a global mesh for the case of the thread number is one,
    // i.e the global mesh is not partitioned.
    // \param mesh The global mesh
    explicit NodePartitionedMesh(const Mesh& mesh)
        : Mesh(mesh),
          _global_node_ids(mesh.getNumberOfNodes()),
          _n_global_base_nodes(mesh.computeNumberOfBaseNodes()),
          _n_global_nodes(mesh.getNumberOfNodes()),
          _n_regular_nodes(mesh.getNumberOfNodes()),
          _is_single_thread(true)
    {
        for (std::size_t i = 0; i < _nodes.size(); i++)
        {
            _global_node_ids[i] = _nodes[i]->getID();
        }
    }
 
    NodePartitionedMesh(
        const std::string& name,
        const std::vector<Node*>& nodes,
        const std::vector<std::size_t>& glb_node_ids,
        const std::vector<Element*>& elements,
        Properties const& properties,
        const std::size_t n_global_base_nodes,
        const std::size_t n_global_nodes,
        const std::size_t n_regular_nodes,
        std::vector<std::size_t>&& n_regular_base_nodes_at_rank,
        std::vector<std::size_t>&& n_regular_high_order_nodes_at_rank);
 
    std::size_t getNumberOfGlobalBaseNodes() const
    {
        return _n_global_base_nodes;
    }
 
    std::size_t getNumberOfGlobalNodes() const { return _n_global_nodes; }
    std::size_t getGlobalNodeID(const std::size_t node_id) const
    {
        return _global_node_ids[node_id];
    }
 
    std::size_t getNumberOfRegularNodes() const { return _n_regular_nodes; }
    bool isGhostNode(const std::size_t node_id) const;
 
    std::size_t getNumberOfRegularBaseNodesAtRank(int const partition_id) const
    {
        return _n_regular_base_nodes_at_rank[partition_id];
    }
 
    std::size_t getNumberOfRegularHighOrderNodesAtRank(
        int const partition_id) const
    {
        return _n_regular_high_order_nodes_at_rank[partition_id];
    }
 
    // TODO I guess that is a simplified version of computeSparsityPattern()
    std::size_t getMaximumNConnectedNodesToNode() const;
 
    std::size_t getPartitionID(const std::size_t global_node_id) const;
 
    int getNumberOfPartitions() const
    {
        return _n_regular_base_nodes_at_rank.size();
    }
 
    bool isForSingleThread() const { return _is_single_thread; }
 
private:
    std::vector<std::size_t> _global_node_ids;
 
    std::size_t _n_global_base_nodes;
 
    std::size_t _n_global_nodes;
 
    std::size_t _n_regular_nodes;
 
    std::vector<std::size_t> _n_regular_base_nodes_at_rank;
 
    std::vector<std::size_t> _n_regular_high_order_nodes_at_rank;
 
    std::vector<int> _end_node_id_at_rank;
 
    const bool _is_single_thread;
};
 
}  // namespace MeshLib