OutputFormat.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) OpenGeoSys Community (opengeosys.org)
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
#include <iosfwd>
#include <set>
#include <vector>
 
#include "MeshLib/IO/VtkIO/PVDFile.h"
#include "MeshLib/IO/XDMF/XdmfHdfWriter.h"
 
namespace ProcessLib
{
class Process;
 
struct OutputFormat
{
    OutputFormat(std::string const& directory, std::string prefix,
                 std::string suffix, bool const compression);
    virtual ~OutputFormat() = default;
 
    OutputFormat(OutputFormat const& other) = delete;
    OutputFormat(OutputFormat&& other) = default;
    OutputFormat& operator=(OutputFormat& other) = delete;
    OutputFormat& operator=(OutputFormat&& other) = default;
 
    std::string directory;
    std::string prefix;
    std::string suffix;
    bool compression;
 
    virtual void outputMeshes(
        const int timestep, const double t, const int iteration,
        bool const converged,
        std::vector<std::reference_wrapper<const MeshLib::Mesh>> const& meshes,
        std::set<std::string> const& output_variables) const = 0;
    virtual std::string constructFilename(std::string const& mesh_name,
                                          int const timestep, double const t,
                                          int const iteration,
                                          bool const converged) const = 0;
};
 
inline std::ostream& operator<<(std::ostream& os, OutputFormat const& of)
{
    os << "OutputFormat::directory:" << of.directory << std::endl;
    os << "OutputFormat::prefix:" << of.prefix << std::endl;
    os << "OutputFormat::suffix:" << of.suffix << std::endl;
    os << "OutputFormat::compression:" << of.compression << std::endl;
    return os;
}
 
struct OutputVTKFormat final : public OutputFormat
{
    OutputVTKFormat(std::string const& directory, std::string prefix,
                    std::string suffix, bool const compression,
                    int const data_mode)
        : OutputFormat(directory, std::move(prefix), std::move(suffix),
                       compression),
          data_mode(data_mode)
    {
    }
 
    void outputMeshes(
        const int timestep, const double t, const int iteration,
        bool const converged,
        std::vector<std::reference_wrapper<const MeshLib::Mesh>> const& meshes,
        std::set<std::string> const& output_variables) const override;

    int data_mode;

    mutable std::map<std::string, MeshLib::IO::PVDFile> mesh_name_to_pvd_file;
 
    MeshLib::IO::PVDFile& findOrCreatePVDFile(
        std::string const& mesh_name) const;
 
    std::string constructFilename(std::string const& mesh_name,
                                  int const timestep, double const t,
                                  int const iteration,
                                  bool const converged) const override;
 
    std::string constructPVDName(std::string const& mesh_name) const;
};
 
struct OutputXDMFHDF5Format final : public OutputFormat
{
    OutputXDMFHDF5Format(std::string const& directory, std::string prefix,
                         std::string suffix, bool const compression,
                         unsigned int const n_files,
                         unsigned int const chunk_size_bytes,
                         bool const store_static_data_separately,
                         std::set<std::string> static_variables)
        : OutputFormat(directory, std::move(prefix), std::move(suffix),
                       compression),
          static_variables(std::move(static_variables)),
          n_files(n_files),
          chunk_size_bytes(chunk_size_bytes),
          store_static_data_separately(store_static_data_separately)
    {
    }
 
    void outputMeshes(
        const int timestep, const double t, const int iteration,
        bool const converged,
        std::vector<std::reference_wrapper<const MeshLib::Mesh>> const& meshes,
        std::set<std::string> const& output_variables) const override
    {
        outputMeshXdmf(output_variables, meshes, timestep, t, iteration,
                       converged);
    }
 
    std::string constructFilename(std::string const& mesh_name,
                                  int const timestep, double const t,
                                  int const iteration,
                                  bool const converged) const override;
 
    mutable std::unique_ptr<MeshLib::IO::XdmfHdfWriter> mesh_xdmf_hdf_writer;
    std::set<std::string> const static_variables;
    unsigned int n_files;
    unsigned int const chunk_size_bytes;
    bool const store_static_data_separately;
 
    void outputMeshXdmf(
        std::set<std::string> const& output_variables,
        std::vector<std::reference_wrapper<const MeshLib::Mesh>> const& meshes,
        int const timestep, double const t, int const iteration,
        bool const converged) const;
};
 
void outputMeshVtk(std::string const& file_name, MeshLib::Mesh const& mesh,
                   std::set<std::string> const& output_variables,
                   bool const compress_output, int const data_mode);
}  // namespace ProcessLib