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 31 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 double t, int const iteration, std::vector< GlobalVector * > const &xs) const
void	doOutputLastTimestep (Process const &process, const int process_id, int const timestep, const double t, int const iteration, std::vector< GlobalVector * > const &xs) const
void	doOutputAlways (Process const &process, const int process_id, int const timestep, const double t, int const iteration, std::vector< GlobalVector * > const &xs) const
void	doOutputNonlinearIteration (Process const &process, const int process_id, int const timestep, const double t, const int iteration, std::vector< GlobalVector * > const &xs) const
bool	isOutputStep (int const timestep, double 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, 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, double 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 145 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 158 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 167 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 double	t,
		int const	iteration,
		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, 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 double	t,
		int const	iteration,
		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 291 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, 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 double	t,
		int const	iteration,
		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 357 of file Output.cpp.

{
    if (!isOutputStep(timestep, t))
    {
        doOutputAlways(process, process_id, timestep, t, iteration, 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 double	t,
		const int	iteration,
		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 374 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);
 
    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 425 of file Output.cpp.

{
    auto construct_filename = ranges::views::transform(
        [&](auto const& output_name)
        { return _output_format->constructFilename(output_name, 0, 0, 0); });
 
    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 86 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 133 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,
		double const	t
	)		const

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

Definition at line 420 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, std::vector< std::reference_wrapper< const MeshLib::Mesh > > const &  meshes  ) const

private

Definition at line 175 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, 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, double const  t, std::vector< GlobalVector * > const &  xs  ) const

private

Definition at line 213 of file Output.cpp.

{
    auto& submesh = *BaseLib::findElementOrError(
        _meshes.get().begin(), _meshes.get().end(),
        [&submesh_output_name](auto const& m)
        { return m->getName() == submesh_output_name; },
        "Need mesh '" + submesh_output_name + "' for the output.");
 
    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(), BaseLib::findElementOrError(), ProcessLib::Process::getMesh(), MeshLib::Mesh::getProperties(), and MeshLib::Properties::getPropertyVectorNames().

Referenced by doOutputAlways().

Friends And Related Function Documentation

operator<<

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

friend

Definition at line 449 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 129 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 117 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 126 of file Output.h.

Referenced by prepareSubmesh().

_output_data_specification

OutputDataSpecification ProcessLib::Output::_output_data_specification

private

Definition at line 115 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 111 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 113 of file Output.h.

Referenced by doOutputNonlinearIteration().

_output_processes

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

private

Definition at line 116 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