mesh_block.h

Go to the documentation of this file.

 
#ifndef MESH_BLOCK_H
#define MESH_BLOCK_H
 
#include <array>
#include <cstdint>
#include <string>
#include <vector>
 
#include <toml.hpp>
 
#include "common_typedef.h"
#include "mesh.h"
 
struct MeshBlock {
    uint64_t first_cell = 0;
    uint64_t first_node = 0;
    std::vector<uint64_t> cell_offsets{0};  // CSR into cell_nodes
    std::vector<uint64_t> cell_nodes;
    std::vector<std::array<double, N_DIM>> node_coords;
    std::vector<uint64_t> face_offsets{0};  // boundary faces, CSR into face_nodes
    std::vector<uint64_t> face_nodes;
    std::vector<uint32_t> face_zone;        // index into zone_names
    std::vector<std::string> zone_names;    // every zone, on every rank
    // High-order boundary faces: CSR per boundary face (empty if none at all)
    // into the coordinates of all its nodes, corners first in Gmsh order;
    // linear faces have none
    std::vector<uint64_t> face_high_order_offsets;
    std::vector<std::array<double, N_DIM>> face_high_order_nodes;
 
    uint64_t n_cells() const { return cell_offsets.size() - 1; }
    uint64_t n_nodes() const { return node_coords.size(); }
    uint64_t n_faces() const { return face_offsets.size() - 1; }
 
    template <typename Range>
    void add_cell(const Range & nodes) {
        cell_nodes.insert(cell_nodes.end(), std::begin(nodes), std::end(nodes));
        cell_offsets.push_back(cell_nodes.size());
    }
    void add_cell(std::initializer_list<uint64_t> nodes) { add_cell<std::initializer_list<uint64_t>>(nodes); }
 
    template <typename Range>
    void add_face(const Range & nodes, uint32_t zone) {
        face_nodes.insert(face_nodes.end(), std::begin(nodes), std::end(nodes));
        face_offsets.push_back(face_nodes.size());
        face_zone.push_back(zone);
    }
};
 
rtype stretched_coordinate(uint32_t i, uint32_t n, rtype L, rtype beta);
 
Stretching mesh_stretching(const toml::value & input);
 
MeshBlock cartesian_2d_block(uint32_t nx, uint32_t ny, rtype Lx, rtype Ly, MeshType kind, int r, int p,
                             const Stretching & stretching = {});
 
MeshBlock cartesian_3d_block(uint32_t nx, uint32_t ny, uint32_t nz, rtype Lx, rtype Ly, rtype Lz,
                             MeshType kind, uint64_t first_cell, uint64_t end_cell,
                             uint64_t first_node, uint64_t end_node, const Stretching & stretching = {});
 
std::array<uint64_t, 2> cartesian_3d_size(uint32_t nx, uint32_t ny, uint32_t nz, MeshType kind);
 
std::array<rtype, 2> wedge_node(rtype x, rtype y, rtype Ly);
 
inline uint64_t block_begin(uint64_t n, int r, int p) { return n * uint64_t(r) / uint64_t(p); }
 
MeshBlock read_mesh_block(const toml::value & input);
 
MeshBlock read_gmsh_block(const std::string & filename);
 
bool is_hdf5_mesh(const std::string & filename);
 
bool have_hdf5();
 
bool have_parallel_hdf5();
 
MeshBlock read_mesh_h5(const std::string & filename, bool whole = false);
 
void write_mesh_h5(const std::string & filename, const MeshBlock & block);
 
#endif // MESH_BLOCK_H