distributed_mesh.h

Go to the documentation of this file.

 
#ifndef DISTRIBUTED_MESH_H
#define DISTRIBUTED_MESH_H
 
#include <array>
#include <cstdint>
#include <memory>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
#include "distribution.h"
#include "mesh_block.h"
#include "periodic.h"
 
class Mesh;
 
class DistributedMesh {
    public:
        using PeriodicMap = std::unordered_map<uint64_t, std::pair<uint64_t, std::array<int8_t, 3>>>;
 
        explicit DistributedMesh(MeshBlock block, const std::vector<Mesh::PeriodicPair> & periodic = {});
 
        uint64_t n_global_cells() const { return cell_dist.back(); }
        uint64_t first_cell() const { return block.first_cell; }
        uint32_t n_block_cells() const { return static_cast<uint32_t>(block.n_cells()); }
 
        const std::vector<uint64_t> & cell_distribution() const { return cell_dist; }
 
        const std::vector<uint64_t> & graph_offsets() const { return graph_offsets_; }
        const std::vector<uint64_t> & graph_neighbors() const { return graph_neighbors_; }
 
        const PeriodicMap & block_periodic_classes() const { return block_periodic; }
 
        const MeshBlock & mesh_block() const { return block; }
 
        std::vector<std::array<double, N_DIM>> block_cell_centers() const;
 
        void distribute(const std::vector<int> & owner);
 
        std::shared_ptr<Mesh> build_local_mesh(int halo_layers, Distribution & dist);
 
    private:
        struct Cells {
            std::vector<uint64_t> gid;
            std::vector<int> owner;
            std::vector<uint8_t> layer;
            std::vector<uint64_t> node_offsets{0}, nodes;            // global node ids
            std::vector<uint32_t> boundary_offsets{0};
            std::vector<std::array<uint32_t, 2>> boundary;           // (local face, zone)
            PeriodicMap periodic;                                    // classes of their periodic nodes
        };
 
        void match_periodic(const std::vector<Mesh::PeriodicPair> & pairs);
 
        const std::pair<uint64_t, std::array<int8_t, 3>> * periodic_class(uint64_t g) const;
 
        uint64_t node_key(uint64_t g) const;
 
        size_t rank_of_cell(uint64_t g) const;
        size_t rank_of_node(uint64_t g) const;
        void append_record(std::vector<uint64_t> & out, uint32_t i) const;
        void read_records(const std::vector<uint64_t> & in, uint8_t layer);
        std::vector<std::array<double, N_DIM>> fetch_nodes(const std::vector<uint64_t> & sorted_ids) const;
        void grow_layer();
 
        MeshBlock block;
        std::vector<uint64_t> cell_dist, node_dist;
        std::vector<std::string> zones;  // the block's zones, then "unassigned"
        PeriodicNodes periodic_classes;  // translations and zones only
        PeriodicMap block_periodic;      // classes of the periodic nodes of the block's cells and faces
        std::vector<uint64_t> graph_offsets_, graph_neighbors_;
        std::vector<uint32_t> boundary_offsets{0};
        std::vector<std::array<uint32_t, 2>> boundary;  // per block cell: (local face, zone)
 
        // After distribute()
        std::vector<int> owner;                         // per block cell
        std::vector<uint64_t> directory_offsets{0};     // per block node: cells using it (by node key)
        std::vector<std::pair<uint64_t, int>> directory;  // (cell, owner)
        Cells cells;
        std::unordered_map<uint64_t, uint32_t> halo_index;  // halo cell -> index in cells
        std::vector<uint64_t> owned_nodes;                   // keys of the owned cells' nodes, sorted
        std::unordered_set<uint64_t> searched_nodes;         // halo nodes whose cells are all here
        std::vector<std::pair<uint64_t, int>> next_layer;    // layer 1, found by distribute()
        int layers = 0;
};
 
#endif // DISTRIBUTED_MESH_H