Output.h

Go to the documentation of this file.

 
#pragma once
 
#include <map>
#include <utility>
 
#include "MeshLib/IO/VtkIO/PVDFile.h"
#include "MeshLib/IO/XDMF/XdmfHdfWriter.h"
#include "ProcessOutput.h"
 
namespace ProcessLib
{
class Process;
 
class Output
{
public:
    struct PairRepeatEachSteps
    {
        explicit PairRepeatEachSteps(int c, int e) : repeat(c), each_steps(e) {}
 
        const int repeat;      
        const int each_steps;  
    };
 
public:
    Output(std::string directory, OutputType const type, std::string prefix,
           std::string suffix, bool const compress_output, unsigned int n_files,
           std::string const& data_mode,
           bool const output_nonlinear_iteration_results,
           std::vector<PairRepeatEachSteps> repeats_each_steps,
           std::vector<double>&& fixed_output_times,
           OutputDataSpecification&& output_data_specification,
           std::vector<std::string>&& mesh_names_for_output,
           std::vector<std::unique_ptr<MeshLib::Mesh>> const& meshes);
 
    void addProcess(ProcessLib::Process const& process);
 
    void doOutput(Process const& process, const int process_id,
                  int const timestep, const double t, int const iteration,
                  std::vector<GlobalVector*> const& x);
 
    void doOutputLastTimestep(Process const& process, const int process_id,
                              int const timestep, const double t,
                              int const iteration,
                              std::vector<GlobalVector*> const& x);
 
    void doOutputAlways(Process const& process, const int process_id,
                        int const timestep, const double t, int const iteration,
                        std::vector<GlobalVector*> const& x);
 
    void doOutputNonlinearIteration(Process const& process,
                                    const int process_id, int const timestep,
                                    const double t, const int iteration,
                                    std::vector<GlobalVector*> const& x);
 
    std::vector<double> getFixedOutputTimes() const
    {
        return _fixed_output_times;
    }
 
private:
    struct OutputFile;
 
    static void outputMesh(OutputFile const& output_file,
                           MeshLib::IO::PVDFile* const pvd_file,
                           MeshLib::Mesh const& mesh,
                           double const t);
 
    void outputMeshXdmf(OutputFile const& output_file,
                        std::vector<std::reference_wrapper<const MeshLib::Mesh>>
                            meshes,
                        int const timestep,
                        double const t);
 
private:
    std::unique_ptr<MeshLib::IO::XdmfHdfWriter> _mesh_xdmf_hdf_writer;
 
    std::string const _output_directory;
    OutputType const _output_file_type;
    std::string const _output_file_prefix;
    std::string const _output_file_suffix;
 
    bool const _output_file_compression;
    unsigned int const _n_files;
 
    int const _output_file_data_mode;
    bool const _output_nonlinear_iteration_results;
 
    std::vector<PairRepeatEachSteps> _repeats_each_steps;
 
    std::vector<double> const _fixed_output_times;
 
    std::multimap<Process const*, MeshLib::IO::PVDFile> _process_to_pvd_file;
 
    MeshLib::IO::PVDFile* findPVDFile(Process const& process,
                                      const int process_id,
                                      std::string const& mesh_name_for_output);
 
    bool shallDoOutput(int timestep, double const t);
 
    OutputDataSpecification const _output_data_specification;
    std::vector<std::string> _mesh_names_for_output;
    std::vector<std::unique_ptr<MeshLib::Mesh>> const& _meshes;
};
 
}  // namespace ProcessLib