Output.h

Go to the documentation of this file.

 
#pragma once
 
#include <iosfwd>
#include <map>
#include <utility>
#include <vector>
 
#include "MathLib/LinAlg/GlobalMatrixVectorTypes.h"
#include "OutputDataSpecification.h"
#include "OutputFormat.h"
 
namespace NumLib
{
struct Time;
}
 
namespace ProcessLib
{
class Process;
 
class Output
{
public:
    Output(std::unique_ptr<OutputFormat>&& output_format,
           bool const output_nonlinear_iteration_results,
           OutputDataSpecification&& output_data_specification,
           std::vector<std::string>&& mesh_names_for_output,
           std::vector<std::unique_ptr<MeshLib::Mesh>> const& meshes);
 
    Output(Output const& other) = delete;
    Output(Output&& other) = default;
    Output& operator=(Output const& src) = delete;
    Output& operator=(Output&& src) = default;
    ~Output() = default;
 
    void addProcess(ProcessLib::Process const& process);
 
    void doNotProjectFromBulkMeshToSubmeshes(
        std::string const& property_name,
        MeshLib::MeshItemType const mesh_item_type);
 
    void doOutput(Process const& process, const int process_id,
                  int const timestep, const NumLib::Time& t,
                  int const iteration, bool const converged,
                  std::vector<GlobalVector*> const& xs) const;
 
    void doOutputLastTimestep(Process const& process, const int process_id,
                              int const timestep, const NumLib::Time& t,
                              int const iteration, bool const converged,
                              std::vector<GlobalVector*> const& xs) const;
 
    void doOutputAlways(Process const& process, const int process_id,
                        int const timestep, const NumLib::Time& t,
                        int const iteration, bool const converged,
                        std::vector<GlobalVector*> const& xs) const;
 
    void doOutputNonlinearIteration(Process const& process,
                                    const int process_id, int const timestep,
                                    const NumLib::Time& t, const int iteration,
                                    bool const converged,
                                    std::vector<GlobalVector*> const& xs) const;
 
    bool isOutputStep(int const timestep, NumLib::Time const& t) const;
 
    std::vector<double> const& getFixedOutputTimes() const
    {
        return _output_data_specification.fixed_output_times;
    }
    std::vector<double> const& getFixedOutputTimes() const {…}
 
    std::vector<std::string> getFileNamesForOutput() const;
 
    friend std::ostream& operator<<(std::ostream& os, Output const& output);
 
private:
    bool isOutputProcess(int const process_id, Process const& process) const;
 
    void outputMeshes(
        int const timestep, const double t, int const iteration,
        bool const converged,
        std::vector<std::reference_wrapper<const MeshLib::Mesh>> const& meshes)
        const;
 
    MeshLib::Mesh const& prepareSubmesh(
        std::string const& submesh_output_name, Process const& process,
        const int process_id, NumLib::Time const& t,
        std::vector<GlobalVector*> const& xs) const;
 
    std::unique_ptr<OutputFormat> _output_format;
 
    bool _output_nonlinear_iteration_results;
 
    OutputDataSpecification _output_data_specification;
    std::vector<std::reference_wrapper<Process const>> _output_processes;
    std::vector<std::string> _mesh_names_for_output;
    // The reference wrapper enables the compiler to generate a move constructor
    // and move assignment operator
    // - another possibility would be to transform the
    // std::vector<std::unique_ptr<MeshLib::Mesh>> to
    // std::vector<MeshLib::Mesh*>
    // - this issue could also be solved by (globally) storing the meshes into a
    // std::vector<std::shared_ptr<MeshLib::Mesh>>
    std::reference_wrapper<std::vector<std::unique_ptr<MeshLib::Mesh>> const>
        _meshes;
 
    std::set<std::pair<std::string, MeshLib::MeshItemType>>
        _do_not_project_from_bulk_mesh_to_submeshes;
};
class Output {…};
 
std::vector<double> calculateUniqueFixedTimesForAllOutputs(
    std::vector<Output> const& outputs);
 
}  // namespace ProcessLib