ProcessLib::Output Class Reference

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 36 of file 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 147 of file 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)
{
}

Output() [2/3]

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

delete

Output() [3/3]

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

default

~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 160 of file 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 169 of file 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 338 of file 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 290 of file 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 359 of file 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 378 of file 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 429 of file 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 94 of file Output.h.

    {
        return _output_data_specification.fixed_output_times;
    }

References _output_data_specification, and ProcessLib::OutputDataSpecification::fixed_output_times.

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 135 of file 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 424 of file Output.cpp.

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

References _output_data_specification, and ProcessLib::OutputDataSpecification::isOutputStep().

Referenced by doOutput(), and doOutputLastTimestep().

operator=() [1/2]

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

default

operator=() [2/2]

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

delete

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 177 of file 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, _output_format, and ProcessLib::OutputDataSpecification::output_variables.

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 216 of file 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().

Friends And Related Symbol Documentation

operator<<

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

friend

Definition at line 455 of file Output.cpp.

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

Member Data Documentation

_do_not_project_from_bulk_mesh_to_submeshes

std::set<std::pair<std::string, MeshLib::MeshItemType> > ProcessLib::Output::_do_not_project_from_bulk_mesh_to_submeshes

private

Definition at line 138 of file Output.h.

Referenced by doNotProjectFromBulkMeshToSubmeshes(), and prepareSubmesh().

_mesh_names_for_output

std::vector<std::string> ProcessLib::Output::_mesh_names_for_output

private

Definition at line 126 of file Output.h.

Referenced by addProcess(), doOutputAlways(), and getFileNamesForOutput().

_meshes

std::reference_wrapper<std::vector<std::unique_ptr<MeshLib::Mesh> > const> ProcessLib::Output::_meshes

private

Definition at line 135 of file Output.h.

Referenced by prepareSubmesh().

_output_data_specification

OutputDataSpecification ProcessLib::Output::_output_data_specification

private

Definition at line 124 of file Output.h.

Referenced by doOutputAlways(), doOutputNonlinearIteration(), getFixedOutputTimes(), isOutputStep(), outputMeshes(), and prepareSubmesh().

_output_format

std::unique_ptr<OutputFormat> ProcessLib::Output::_output_format

private

Definition at line 120 of file Output.h.

Referenced by doOutput(), doOutputLastTimestep(), doOutputNonlinearIteration(), getFileNamesForOutput(), and outputMeshes().

_output_nonlinear_iteration_results

bool ProcessLib::Output::_output_nonlinear_iteration_results

private

Definition at line 122 of file Output.h.

Referenced by doOutputNonlinearIteration().

_output_processes

std::vector<std::reference_wrapper<Process const> > ProcessLib::Output::_output_processes

private

Definition at line 125 of file Output.h.

Referenced by addProcess(), and isOutputProcess().

---

The documentation for this class was generated from the following files:

• ProcessLib/Output/Output.h
• ProcessLib/Output/Output.cpp