Detailed Description

Manages writing the solution of processes to disk.

This class decides at which timesteps output is written and initiates the writing process.

Definition at line 29 of file ProcessLib/Output/Output.h.

#include <Output.h>

Collaboration diagram for ProcessLib::Output:

Public Member Functions
	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)
	TODO doc. Opens a PVD file for each 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
	Tells if output will be written at the specified timestep/time.
std::vector< double > const &	getFixedOutputTimes () const
std::vector< std::string >	getFileNamesForOutput () const

Private Member Functions
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

Private Attributes
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
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

Friends
std::ostream &	operator<< (std::ostream &os, Output const &output)

Constructor & Destructor Documentation

◆ Output() [1/3]

ProcessLib::Output::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 )

Definition at line 140 of file ProcessLib/Output/Output.cpp.

    : _output_format(std::move(output_format)),
      _output_nonlinear_iteration_results(output_nonlinear_iteration_results),
      _output_data_specification(std::move(output_data_specification)),
      _mesh_names_for_output(std::move(mesh_names_for_output)),
      _meshes(meshes)
{
}

References _mesh_names_for_output, _meshes, _output_data_specification, _output_format, and _output_nonlinear_iteration_results.

Referenced by Output(), Output(), operator<<, operator=(), and operator=().

◆ Output() [2/3]

ProcessLib::Output::Output ( Output const & other )

delete

References Output().

◆ Output() [3/3]

ProcessLib::Output::Output ( Output && other )

default

References Output().

◆ ~Output()

ProcessLib::Output::~Output ( )

default

Member Function Documentation

◆ addProcess()

void ProcessLib::Output::addProcess ( ProcessLib::Process const & process )

TODO doc. Opens a PVD file for each process.

Definition at line 153 of file ProcessLib/Output/Output.cpp.

{
    _output_processes.push_back(process);
    if (_mesh_names_for_output.empty())
    {
        _mesh_names_for_output.push_back(process.getMesh().getName());
    }
}

References _mesh_names_for_output, _output_processes, ProcessLib::Process::getMesh(), and MeshLib::Mesh::getName().

◆ doNotProjectFromBulkMeshToSubmeshes()

void ProcessLib::Output::doNotProjectFromBulkMeshToSubmeshes	(	std::string const &	property_name,
		MeshLib::MeshItemType const	mesh_item_type )

Declare that the specified mesh property should not be projected from the bulk mesh to submeshes during submesh output.

Definition at line 162 of file ProcessLib/Output/Output.cpp.

{
    _do_not_project_from_bulk_mesh_to_submeshes.emplace(property_name,
                                                        mesh_item_type);
}

References _do_not_project_from_bulk_mesh_to_submeshes.

◆ doOutput()

void ProcessLib::Output::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

Writes output for the given process if it should be written in the given timestep.

Definition at line 331 of file ProcessLib/Output/Output.cpp.

{
    if (isOutputStep(timestep, t))
    {
        doOutputAlways(process, process_id, timestep, t, iteration, converged,
                       xs);
    }
#ifdef OGS_USE_INSITU
    // Note: last time step may be output twice: here and in
    // doOutputLastTimestep() which throws a warning.
    InSituLib::CoProcess(process.getMesh(), t, timestep, false,
                         _output_format->directory);
#endif
}

References _output_format, InSituLib::CoProcess(), doOutputAlways(), ProcessLib::Process::getMesh(), and isOutputStep().

Referenced by ProcessLib::TimeLoop::calculateNextTimeStep(), and ProcessLib::TimeLoop::initialize().

◆ doOutputAlways()

void ProcessLib::Output::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

Writes output for the given process. This method will always write. It is intended to write output in error handling routines.

Definition at line 283 of file ProcessLib/Output/Output.cpp.

{
    BaseLib::RunTime time_output;
    time_output.start();
 
    bool const output_secondary_variables = true;
    auto const process_output_data =
        createProcessOutputData(process, xs.size(), process.getMesh());
 
    // Need to add variables of process to mesh even if no output takes place.
    addProcessDataToMesh(t, xs, process_id, process_output_data,
                         output_secondary_variables,
                         _output_data_specification);
 
    if (!isOutputProcess(process_id, process))
    {
        return;
    }
 
    std::vector<std::reference_wrapper<const MeshLib::Mesh>> output_meshes;
    for (auto const& mesh_output_name : _mesh_names_for_output)
    {
        if (process.getMesh().getName() == mesh_output_name)
        {
            // process related output
            output_meshes.emplace_back(process.getMesh());
        }
        else
        {
            // mesh related output
            auto const& submesh =
                prepareSubmesh(mesh_output_name, process, process_id, t, xs);
            output_meshes.emplace_back(submesh);
        }
    }
 
    outputMeshes(timestep, t(), iteration, converged, std::move(output_meshes));
 
    INFO("[time] Output of timestep {:d} took {:g} s.", timestep,
         time_output.elapsed());
}

References _mesh_names_for_output, _output_data_specification, ProcessLib::addProcessDataToMesh(), ProcessLib::createProcessOutputData(), BaseLib::RunTime::elapsed(), ProcessLib::Process::getMesh(), MeshLib::Mesh::getName(), INFO(), isOutputProcess(), outputMeshes(), prepareSubmesh(), and BaseLib::RunTime::start().

Referenced by doOutput(), and doOutputLastTimestep().

◆ doOutputLastTimestep()

void ProcessLib::Output::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

Writes output for the given process if it has not been written yet. This method is intended for doing output after the last timestep in order to make sure that its results are written.

Definition at line 352 of file ProcessLib/Output/Output.cpp.

{
    if (!isOutputStep(timestep, t))
    {
        doOutputAlways(process, process_id, timestep, t, iteration, converged,
                       xs);
    }
#ifdef OGS_USE_INSITU
    InSituLib::CoProcess(process.getMesh(), t, timestep, true,
                         _output_format->directory);
#endif
}

References _output_format, InSituLib::CoProcess(), doOutputAlways(), ProcessLib::Process::getMesh(), and isOutputStep().

Referenced by ProcessLib::TimeLoop::outputLastTimeStep().

◆ doOutputNonlinearIteration()

void ProcessLib::Output::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

Writes output for the given process. To be used for debug output after an iteration of the nonlinear solver.

Definition at line 371 of file ProcessLib/Output/Output.cpp.

{
    if (!_output_nonlinear_iteration_results)
    {
        return;
    }
 
    BaseLib::RunTime time_output;
    time_output.start();
 
    bool const output_secondary_variable = true;
    auto const process_output_data =
        createProcessOutputData(process, xs.size(), process.getMesh());
 
    addProcessDataToMesh(t, xs, process_id, process_output_data,
                         output_secondary_variable, _output_data_specification);
 
    if (!isOutputProcess(process_id, process))
    {
        return;
    }
 
    std::string const output_file_name = _output_format->constructFilename(
        process.getMesh().getName(), timestep, t(), iteration, converged);
 
    std::string const output_file_path =
        BaseLib::joinPaths(_output_format->directory, output_file_name);
 
    DBUG("output iteration results to {:s}", output_file_path);
 
    if (dynamic_cast<OutputVTKFormat*>(_output_format.get()))
    {
        outputMeshVtk(
            output_file_path, process.getMesh(), _output_format->compression,
            dynamic_cast<OutputVTKFormat*>(_output_format.get())->data_mode);
    }
    else
    {
        DBUG("non-linear iterations can only written in Vtk/VTU format.");
    }
    INFO("[time] Output took {:g} s.", time_output.elapsed());
}

References _output_data_specification, _output_format, _output_nonlinear_iteration_results, ProcessLib::addProcessDataToMesh(), ProcessLib::createProcessOutputData(), ProcessLib::OutputVTKFormat::data_mode, DBUG(), BaseLib::RunTime::elapsed(), ProcessLib::Process::getMesh(), MeshLib::Mesh::getName(), INFO(), isOutputProcess(), BaseLib::joinPaths(), ProcessLib::outputMeshVtk(), and BaseLib::RunTime::start().

◆ getFileNamesForOutput()

std::vector< std::string > ProcessLib::Output::getFileNamesForOutput ( ) const

Definition at line 422 of file ProcessLib/Output/Output.cpp.

{
    auto construct_filename = ranges::views::transform(
        [&](auto const& output_name) {
            return _output_format->constructFilename(output_name, 0, 0, 0,
                                                     true);
        });
 
    return _mesh_names_for_output | construct_filename |
           ranges::to<std::vector>;
}

References _mesh_names_for_output, and _output_format.

◆ getFixedOutputTimes()

std::vector< double > const & ProcessLib::Output::getFixedOutputTimes ( ) const

inline

Definition at line 87 of file ProcessLib/Output/Output.h.

    {
        return _output_data_specification.fixed_output_times;
    }

References _output_data_specification.

◆ isOutputProcess()

bool ProcessLib::Output::isOutputProcess	(	int const	process_id,
		Process const &	process ) const

private

Determines if output should be written for the given process.

With staggered coupling not every process writes output.

Definition at line 128 of file ProcessLib/Output/Output.cpp.

{
    auto const is_last_process =
        process_id == static_cast<int>(_output_processes.size()) - 1;
 
    return process.isMonolithicSchemeUsed()
           // For the staggered scheme for the coupling, only the last
           // process, which gives the latest solution within a coupling
           // loop, is allowed to make output.
           || is_last_process;
}

References _output_processes, and ProcessLib::Process::isMonolithicSchemeUsed().

Referenced by doOutputAlways(), and doOutputNonlinearIteration().

◆ isOutputStep()

bool ProcessLib::Output::isOutputStep	(	int const	timestep,
		NumLib::Time const &	t ) const

Tells if output will be written at the specified timestep/time.

Definition at line 417 of file ProcessLib/Output/Output.cpp.

{
    return _output_data_specification.isOutputStep(timestep, t);
}

References _output_data_specification.

Referenced by doOutput(), and doOutputLastTimestep().

◆ operator=() [1/2]

Output & ProcessLib::Output::operator= ( Output && src )

default

References Output().

◆ operator=() [2/2]

Output & ProcessLib::Output::operator= ( Output const & src )

delete

References Output().

◆ outputMeshes()

void ProcessLib::Output::outputMeshes	(	int const	timestep,
		const double	t,
		int const	iteration,
		bool const	converged,
		std::vector< std::reference_wrapper< const MeshLib::Mesh > > const &	meshes ) const

private

Definition at line 170 of file ProcessLib/Output/Output.cpp.

{
    if (_output_data_specification.output_variables.empty())
    {
        // special case: no output properties specified => output all properties
        for (auto const& mesh : meshes)
        {
            for (auto [name, property] : mesh.get().getProperties())
            {
                property->is_for_output = true;
            }
        }
    }
    else
    {
        for (auto const& mesh : meshes)
        {
            for (auto [name, property] : mesh.get().getProperties())
            {
                // special case: always output OGS_VERSION
                if (name == "OGS_VERSION")
                {
                    property->is_for_output = true;
                    continue;
                }
 
                property->is_for_output =
                    _output_data_specification.output_variables.contains(name);
            }
        }
    }
    _output_format->outputMeshes(timestep, t, iteration, converged, meshes,
                                 _output_data_specification.output_variables);
}

References _output_data_specification, and _output_format.

Referenced by doOutputAlways().

◆ prepareSubmesh()

MeshLib::Mesh const & ProcessLib::Output::prepareSubmesh	(	std::string const &	submesh_output_name,
		Process const &	process,
		const int	process_id,
		NumLib::Time const &	t,
		std::vector< GlobalVector * > const &	xs ) const

private

Definition at line 209 of file ProcessLib/Output/Output.cpp.

{
    auto& submesh = MeshLib::findMeshByName(_meshes.get(), submesh_output_name);
 
    DBUG("Found {:d} nodes for output at mesh '{:s}'.",
         submesh.getNumberOfNodes(), submesh.getName());
 
    bool const output_secondary_variables = false;
 
    // TODO Under the assumption that xs.size() and submesh do not change during
    // the simulation, process output data should not be recreated every time,
    // but should rather be computed only once and stored for later reuse.
    auto const process_output_data =
        createProcessOutputData(process, xs.size(), submesh);
 
    addProcessDataToMesh(t, xs, process_id, process_output_data,
                         output_secondary_variables,
                         _output_data_specification);
 
    auto const& bulk_mesh = process.getMesh();
    auto const& property_names =
        bulk_mesh.getProperties().getPropertyVectorNames();
 
    // TODO Once all processes have been refactored to use the new residuum
    // assembly logic, the functionality of this lambda should be refactored.
    // Currently (Jan '23) there is a difference between the logic using this
    // lambda and doNotProjectFromBulkMeshToSubmeshes(): The latter is
    // considered regardless of submesh dimension.
    auto is_residuum_field = [](std::string const& name) -> bool
    {
        using namespace std::literals::string_view_literals;
        static constexpr std::string_view endings[] = {
            "FlowRate"sv, "heat_flux"sv, "MaterialForces"sv, "NodalForces"sv,
            "NodalForcesJump"sv};
        auto ends_with = [&](std::string_view const& ending)
        { return name.ends_with(ending); };
        return std::find_if(std::begin(endings), std::end(endings),
                            ends_with) != std::end(endings);
    };
 
    for (auto const& name : property_names)
    {
        if (_do_not_project_from_bulk_mesh_to_submeshes.contains(
                {name, MeshLib::MeshItemType::Node}))
        {
            // the projection is disabled regardless of mesh and submesh
            // dimension
            continue;
        }
 
        if (bulk_mesh.getDimension() == submesh.getDimension())
        {
            // omit the 'simple' transfer of the properties in the if condition
            // on submeshes with equal dimension to the bulk mesh
            // for those data extra assembly is required
            if (is_residuum_field(name))
            {
                continue;
            }
            addBulkMeshPropertyToSubMesh(bulk_mesh, submesh, name);
        }
        else
        {
            // For residuum based properties it is assumed that the lower
            // dimensional mesh is a boundary mesh!
            addBulkMeshPropertyToSubMesh(bulk_mesh, submesh, name);
        }
    }
    return submesh;
}

References _do_not_project_from_bulk_mesh_to_submeshes, _meshes, _output_data_specification, ProcessLib::addBulkMeshPropertyToSubMesh(), ProcessLib::addProcessDataToMesh(), ProcessLib::createProcessOutputData(), DBUG(), MeshLib::findMeshByName(), ProcessLib::Process::getMesh(), MeshLib::Mesh::getProperties(), and MeshLib::Properties::getPropertyVectorNames().

Referenced by doOutputAlways().

◆ operator<<

std::ostream & operator<<	(	std::ostream &	os,
		Output const &	output )

friend

Definition at line 448 of file ProcessLib/Output/Output.cpp.

{
    os << "Output::_output_data_specification:\t"
       << output._output_data_specification;
    os << "Output::_output_format:\t" << *(output._output_format);
    return os;
}