data_writer.h

Go to the documentation of this file.

 
#ifndef DATA_WRITER_H
#define DATA_WRITER_H
 
#include <limits>
#include <memory>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
#include <toml.hpp>
 
#include "data.h"
#include "global_order.h"
#include "mesh.h"
 
enum class DataFormat {
    VTU,
    RESTART,
    HDF5,
};
 
static const std::unordered_map<std::string, DataFormat> FORMAT_TYPES = {
    {"vtu", DataFormat::VTU},
    {"restart", DataFormat::RESTART},
    {"hdf5", DataFormat::HDF5},
};
 
static const std::unordered_map<DataFormat, std::string> FORMAT_NAMES = {
    {DataFormat::VTU, "vtu"},
    {DataFormat::RESTART, "restart"},
    {DataFormat::HDF5, "hdf5"},
};
 
using RestartAttributes = std::vector<std::pair<std::string, double>>;
 
constexpr uint64_t RESTART_FACES_PER_CELL = 8;
 
struct RestartFaces {
    static constexpr uint32_t WIDTH = 2;
    std::vector<uint64_t> keys;  // [face]
    std::vector<rtype> values;   // [face][WIDTH]
};
 
struct RestartData {
    uint64_t step = 0;
    double t = 0.0;
    uint64_t n_cells = 0;                    // in the file
    std::vector<std::string> names;          // [variable]
    std::vector<std::vector<rtype>> fields;  // [variable][cell read]
    RestartAttributes attributes;
    RestartFaces faces;                      // every face of the file, in increasing key
 
    const std::vector<rtype> * find(const std::string & name) const;
 
    const double * attribute(const std::string & name) const;
 
    const rtype * face(uint64_t key) const;
};
 
RestartData read_restart(const std::string & filename, const std::vector<uint64_t> * cells = nullptr);
 
class DataWriter {
    public:
        void init(const toml::value & input,
                  std::vector<Data> & data,
                  std::shared_ptr<Mesh> mesh,
                  const std::vector<std::string> & restart_variables = {});
 
        bool due(uint64_t step, rtype t) const;
 
        void write(uint64_t step, rtype t, bool force = false, const RestartAttributes & attributes = {},
                   const RestartFaces & faces = {});
 
        rtype next_time() const;
 
        void resume(uint64_t step, rtype t);
 
        std::pair<std::string, std::string> summary() const;
 
        DataFormat get_format() const { return format; }
        const std::string & get_prefix() const { return prefix; }
        uint64_t files_written() const { return n_files; }
 
    protected:
        void write_vtu(const std::string & filename, rtype t) const;
        void write_vtu_faces(const std::string & filename, rtype t) const;
        void write_restart(const std::string & filename, uint64_t step, rtype t,
                           const RestartAttributes & attributes, const RestartFaces & faces) const;
        void write_pvd() const;
 
        void write_hdf5_mesh();
        void write_hdf5(const std::string & stem, uint64_t step, rtype t) const;
        void write_xdmf(const std::string & stem) const;
        std::string xdmf_grid(const std::string & stem, double t, const std::string & indent) const;
        void resume_xdmf(rtype t);
 
        struct Field {
            std::string name;
            std::vector<const Data *> components;
            uint32_t n_vtk_components() const { return components.size() == 1 ? 1 : 3; }
            rtype value(uint32_t i_cell, uint32_t i_comp) const {
                return i_comp < components.size() ? (*components[i_comp])[i_cell] : rtype(0);
            }
        };
 
        std::string prefix;
        uint64_t interval = 0;
        rtype time_interval = 0.0;
        uint64_t n_written = 0;
        rtype t_last = -std::numeric_limits<rtype>::infinity();
        uint64_t step_last = std::numeric_limits<uint64_t>::max();
        DataFormat format;
        std::vector<Field> fields;
        std::shared_ptr<Mesh> mesh;
        std::vector<std::pair<rtype, std::string>> history;
        bool surface = false;
        std::string geometry = "all";
        uint64_t n_files = 0;
        void write_pvtu(const std::string & filename, const std::string & stem) const;
        void write_restart_distributed(const std::string & filename, uint64_t step, rtype t,
                                       const RestartAttributes & attributes, const RestartFaces & faces) const;
        std::vector<uint32_t> geometry_faces;  // Empty: write all cells
        // HDF5 output: owned cells in global order, and the sizes of the mesh written
        GlobalOrder cell_order;
        bool hdf5_mesh_written = false;
        uint64_t hdf5_n_nodes = 0, hdf5_topology_size = 0;
};
 
#endif // DATA_WRITER_H