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 Output.h.

#include <Output.h>

Collaboration diagram for ProcessLib::Output:

Classes
struct	OutputFile

struct	PairRepeatEachSteps

Public Member Functions
	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)
	TODO doc. Opens a PVD file for each process. More...

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

Private Member Functions
void	outputMeshXdmf (OutputFile const &output_file, std::vector< std::reference_wrapper< const MeshLib::Mesh >> meshes, int const timestep, double const t)

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)
	Determines if there should be output at the given `timestep` or `t`. More...

Static Private Member Functions
static void	outputMesh (OutputFile const &output_file, MeshLib::IO::PVDFile *const pvd_file, MeshLib::Mesh const &mesh, double const t)

Private Attributes
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
	Enables or disables zlib-compression of the output files. More...

unsigned int const	_n_files
	Specifies the number of hdf5 output files. More...

int const	_output_file_data_mode

bool const	_output_nonlinear_iteration_results

std::vector< PairRepeatEachSteps >	_repeats_each_steps
	Describes after which timesteps to write output. More...

std::vector< double > const	_fixed_output_times
	Given times that steps have to reach. More...

std::multimap< Process const *, MeshLib::IO::PVDFile >	_process_to_pvd_file

OutputDataSpecification const	_output_data_specification

std::vector< std::string >	_mesh_names_for_output

std::vector< std::unique_ptr< MeshLib::Mesh > > const &	_meshes

Constructor & Destructor Documentation

◆ Output()

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

Definition at line 96 of file Output.cpp.

     : _output_directory(std::move(directory)),
       _output_file_type(file_type),
       _output_file_prefix(std::move(file_prefix)),
       _output_file_suffix(std::move(file_suffix)),
       _output_file_compression(compress_output),
       _n_files(n_files),
       _output_file_data_mode(convertVtkDataMode(data_mode)),
       _output_nonlinear_iteration_results(output_nonlinear_iteration_results),
       _repeats_each_steps(std::move(repeats_each_steps)),
       _fixed_output_times(std::move(fixed_output_times)),
       _output_data_specification(std::move(output_data_specification)),
       _mesh_names_for_output(mesh_names_for_output),
       _meshes(meshes)
 {
     if (!std::is_sorted(cbegin(_fixed_output_times), cend(_fixed_output_times)))
     {
         OGS_FATAL(
             "Vector of fixed output time steps passed to the Output "
             "constructor must be sorted");
     }
 }

References _fixed_output_times, and OGS_FATAL.

Member Function Documentation

◆ addProcess()

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

TODO doc. Opens a PVD file for each process.

Definition at line 128 of file Output.cpp.

 {
     if (_mesh_names_for_output.empty())
     {
         _mesh_names_for_output.push_back(process.getMesh().getName());
     }
  
     for (auto const& mesh_output_name : _mesh_names_for_output)
     {
         auto const filename = constructPVDName(
             _output_directory, _output_file_prefix, mesh_output_name);
         _process_to_pvd_file.emplace(std::piecewise_construct,
                                      std::forward_as_tuple(&process),
                                      std::forward_as_tuple(filename));
     }
 }

References _mesh_names_for_output, _output_directory, _output_file_prefix, _process_to_pvd_file, anonymous_namespace{Output.cpp}::constructPVDName(), ProcessLib::Process::getMesh(), and MeshLib::Mesh::getName().

◆ 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 &	x
	)

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

Definition at line 399 of file Output.cpp.

 {
     if (shallDoOutput(timestep, t))
     {
         doOutputAlways(process, process_id, timestep, t, iteration, x);
     }
 #ifdef 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_directory);
 #endif
 }

References _output_directory, InSituLib::CoProcess(), doOutputAlways(), ProcessLib::Process::getMesh(), and shallDoOutput().

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

◆ 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 &	x
	)

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

Definition at line 277 of file Output.cpp.

 {
     BaseLib::RunTime time_output;
     time_output.start();
  
     std::vector<NumLib::LocalToGlobalIndexMap const*> dof_tables;
     dof_tables.reserve(x.size());
     for (std::size_t i = 0; i < x.size(); ++i)
     {
         dof_tables.push_back(&process.getDOFTable(i));
     }
  
     bool output_secondary_variable = true;
     // Need to add variables of process to vtu even no output takes place.
     addProcessDataToMesh(t, x, process_id, process.getMesh(), dof_tables,
                          dof_tables, process.getProcessVariables(process_id),
                          process.getSecondaryVariables(),
                          output_secondary_variable,
                          process.getIntegrationPointWriter(process.getMesh()),
                          _output_data_specification);
  
     // 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.
     if (!(process_id == static_cast<int>(_process_to_pvd_file.size() /
                                          _mesh_names_for_output.size()) -
                             1 ||
           process.isMonolithicSchemeUsed()))
     {
         return;
     }
  
     auto output_bulk_mesh =
         [&](std::vector<std::reference_wrapper<const MeshLib::Mesh>> meshes)
     {
         MeshLib::IO::PVDFile* pvd_file = nullptr;
         if (_output_file_type == ProcessLib::OutputType::vtk)
         {
             for (auto const& mesh : meshes)
             {
                 OutputFile const file(
                     _output_directory, _output_file_type, _output_file_prefix,
                     _output_file_suffix, mesh.get().getName(), timestep, t,
                     iteration, _output_file_data_mode, _output_file_compression,
                     _output_data_specification.output_variables, 1);
  
                 pvd_file =
                     findPVDFile(process, process_id, mesh.get().getName());
                 outputMesh(file, pvd_file, mesh, t);
             }
         }
         else if (_output_file_type == ProcessLib::OutputType::xdmf)
         {
             std::string name = meshes[0].get().getName();
             OutputFile const file(
                 _output_directory, _output_file_type, _output_file_prefix, "",
                 name, timestep, t, iteration, _output_file_data_mode,
                 _output_file_compression,
                 _output_data_specification.output_variables, _n_files);
  
             outputMeshXdmf(std::move(file), std::move(meshes), timestep, t);
         }
     };
  
     std::vector<std::reference_wrapper<const MeshLib::Mesh>> output_meshes;
     for (auto const& mesh_output_name : _mesh_names_for_output)
     {
         // process related output
         if (process.getMesh().getName() == mesh_output_name)
         {
             output_meshes.push_back(process.getMesh());
             continue;
         }
         // mesh related output
         auto& non_bulk_mesh = *BaseLib::findElementOrError(
             begin(_meshes), end(_meshes),
             [&mesh_output_name](auto const& m)
             { return m->getName() == mesh_output_name; },
             "Need mesh '" + mesh_output_name + "' for the output.");
  
         std::vector<MeshLib::Node*> const& nodes = non_bulk_mesh.getNodes();
         DBUG("Found {:d} nodes for output at mesh '{:s}'.", nodes.size(),
              non_bulk_mesh.getName());
  
         std::vector<std::unique_ptr<NumLib::LocalToGlobalIndexMap>>
             mesh_dof_tables;
         mesh_dof_tables.reserve(x.size());
         for (std::size_t i = 0; i < x.size(); ++i)
         {
             mesh_dof_tables.push_back(
                 process.getDOFTable(i).deriveBoundaryConstrainedMap(
                     MeshLib::MeshSubset{non_bulk_mesh, nodes}));
         }
         std::vector<NumLib::LocalToGlobalIndexMap const*>
             mesh_dof_table_pointers;
         mesh_dof_table_pointers.reserve(mesh_dof_tables.size());
         transform(cbegin(mesh_dof_tables), cend(mesh_dof_tables),
                   back_inserter(mesh_dof_table_pointers),
                   [](std::unique_ptr<NumLib::LocalToGlobalIndexMap> const& p)
                   { return p.get(); });
  
         output_secondary_variable = false;
         addProcessDataToMesh(
             t, x, process_id, non_bulk_mesh, dof_tables,
             mesh_dof_table_pointers, process.getProcessVariables(process_id),
             process.getSecondaryVariables(), output_secondary_variable,
             process.getIntegrationPointWriter(non_bulk_mesh),
             _output_data_specification);
  
         output_meshes.push_back(non_bulk_mesh);
     }
  
     output_bulk_mesh(std::move(output_meshes));
     INFO("[time] Output of timestep {:d} took {:g} s.", timestep,
          time_output.elapsed());
 }

References _mesh_names_for_output, _meshes, _n_files, _output_data_specification, _output_directory, _output_file_compression, _output_file_data_mode, _output_file_prefix, _output_file_suffix, _output_file_type, _process_to_pvd_file, ProcessLib::addProcessDataToMesh(), DBUG(), NumLib::LocalToGlobalIndexMap::deriveBoundaryConstrainedMap(), BaseLib::RunTime::elapsed(), BaseLib::findElementOrError(), findPVDFile(), ProcessLib::Process::getDOFTable(), ProcessLib::Process::getIntegrationPointWriter(), ProcessLib::Process::getMesh(), MeshLib::Mesh::getName(), ProcessLib::Process::getProcessVariables(), ProcessLib::Process::getSecondaryVariables(), INFO(), ProcessLib::Process::isMonolithicSchemeUsed(), MaterialPropertyLib::name, ProcessLib::OutputDataSpecification::output_variables, outputMesh(), outputMeshXdmf(), BaseLib::RunTime::start(), ProcessLib::vtk, and ProcessLib::xdmf.

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 &	x
	)

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

 {
     if (!shallDoOutput(timestep, t))
     {
         doOutputAlways(process, process_id, timestep, t, iteration, x);
     }
 #ifdef USE_INSITU
     InSituLib::CoProcess(process.getMesh(), t, timestep, true,
                          _output_directory);
 #endif
 }

References _output_directory, InSituLib::CoProcess(), doOutputAlways(), ProcessLib::Process::getMesh(), and shallDoOutput().

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

◆ 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 &	x
	)

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

Definition at line 435 of file Output.cpp.

 {
     if (!_output_nonlinear_iteration_results)
     {
         return;
     }
  
     BaseLib::RunTime time_output;
     time_output.start();
  
     std::vector<NumLib::LocalToGlobalIndexMap const*> dof_tables;
     for (std::size_t i = 0; i < x.size(); ++i)
     {
         dof_tables.push_back(&process.getDOFTable(i));
     }
  
     bool const output_secondary_variable = true;
     addProcessDataToMesh(t, x, process_id, process.getMesh(), dof_tables,
                          dof_tables, process.getProcessVariables(process_id),
                          process.getSecondaryVariables(),
                          output_secondary_variable,
                          process.getIntegrationPointWriter(process.getMesh()),
                          _output_data_specification);
  
     // 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.
     if (!(process_id == static_cast<int>(_process_to_pvd_file.size()) - 1 ||
           process.isMonolithicSchemeUsed()))
     {
         return;
     }
  
     // Only check whether a process data is available for output.
     findPVDFile(process, process_id, process.getMesh().getName());
  
     std::string const output_file_name = OutputFile::constructFilename(
         _output_file_type, _output_file_prefix, _output_file_suffix,
         process.getMesh().getName(), timestep, t, iteration);
  
     std::string const output_file_path =
         BaseLib::joinPaths(_output_directory, output_file_name);
  
     DBUG("output iteration results to {:s}", output_file_path);
     makeOutput(output_file_path, process.getMesh(), _output_file_compression,
                _output_file_data_mode);
     INFO("[time] Output took {:g} s.", time_output.elapsed());
 }

References _output_data_specification, _output_directory, _output_file_compression, _output_file_data_mode, _output_file_prefix, _output_file_suffix, _output_file_type, _output_nonlinear_iteration_results, _process_to_pvd_file, ProcessLib::addProcessDataToMesh(), ProcessLib::Output::OutputFile::constructFilename(), DBUG(), BaseLib::RunTime::elapsed(), findPVDFile(), ProcessLib::Process::getDOFTable(), ProcessLib::Process::getIntegrationPointWriter(), ProcessLib::Process::getMesh(), MeshLib::Mesh::getName(), ProcessLib::Process::getProcessVariables(), ProcessLib::Process::getSecondaryVariables(), INFO(), ProcessLib::Process::isMonolithicSchemeUsed(), BaseLib::joinPaths(), ProcessLib::makeOutput(), and BaseLib::RunTime::start().

Referenced by ProcessLib::solveOneTimeStepOneProcess().

◆ findPVDFile()

MeshLib::IO::PVDFile * ProcessLib::Output::findPVDFile	(	Process const &	process,
		const int	process_id,
		std::string const &	mesh_name_for_output
	)

private

Get the address of a PVDFile from corresponding to the given process.

Parameters

process	Process.
process_id	Process ID.
mesh_name_for_output	mesh name for the output.

Returns: Address of a PVDFile.

Definition at line 146 of file Output.cpp.

 {
     auto const filename = constructPVDName(
         _output_directory, _output_file_prefix, mesh_name_for_output);
     auto range = _process_to_pvd_file.equal_range(&process);
     int counter = 0;
     MeshLib::IO::PVDFile* pvd_file = nullptr;
     for (auto spd_it = range.first; spd_it != range.second; ++spd_it)
     {
         if (spd_it->second.pvd_filename == filename)
         {
             if (counter == process_id)
             {
                 pvd_file = &spd_it->second;
                 break;
             }
             counter++;
         }
     }
     if (pvd_file == nullptr)
     {
         OGS_FATAL(
             "The given process is not contained in the output configuration. "
             "Aborting.");
     }
  
     return pvd_file;
 }

References _output_directory, _output_file_prefix, _process_to_pvd_file, anonymous_namespace{Output.cpp}::constructPVDName(), and OGS_FATAL.

Referenced by doOutputAlways(), and doOutputNonlinearIteration().

◆ getFixedOutputTimes()

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

inline

Definition at line 82 of file Output.h.

     {
         return _fixed_output_times;
     }

References _fixed_output_times.

◆ outputMesh()

void ProcessLib::Output::outputMesh	(	OutputFile const &	output_file,
		MeshLib::IO::PVDFile *const	pvd_file,
		MeshLib::Mesh const &	mesh,
		double const	t
	)

staticprivate

Definition at line 261 of file Output.cpp.

 {
     DBUG("output to {:s}", output_file.path);
  
     if (output_file.type == OutputType::vtk)
     {
         pvd_file->addVTUFile(output_file.name, t);
     }
  
     makeOutput(output_file.path, mesh, output_file.compression,
                output_file.data_mode);
 }

References MeshLib::IO::PVDFile::addVTUFile(), ProcessLib::Output::OutputFile::compression, ProcessLib::Output::OutputFile::data_mode, DBUG(), ProcessLib::makeOutput(), ProcessLib::Output::OutputFile::name, ProcessLib::Output::OutputFile::path, ProcessLib::Output::OutputFile::type, and ProcessLib::vtk.

Referenced by doOutputAlways().

◆ outputMeshXdmf()

void ProcessLib::Output::outputMeshXdmf	(	OutputFile const &	output_file,
		std::vector< std::reference_wrapper< const MeshLib::Mesh >>	meshes,
		int const	timestep,
		double const	t
	)

private

Definition at line 238 of file Output.cpp.

 {
     // \TODO (tm) Refactor to a dedicated VTKOutput and XdmfOutput
     // The XdmfOutput will create on construction the XdmfHdfWriter
     if (!_mesh_xdmf_hdf_writer)
     {
         std::filesystem::path path(output_file.path);
         _mesh_xdmf_hdf_writer = std::make_unique<MeshLib::IO::XdmfHdfWriter>(
             std::move(meshes), path, timestep, t,
             _output_data_specification.output_variables,
             output_file.compression, output_file.n_files);
     }
     else
     {
         _mesh_xdmf_hdf_writer->writeStep(t);
     };
 }

References _mesh_xdmf_hdf_writer, _output_data_specification, ProcessLib::Output::OutputFile::compression, ProcessLib::Output::OutputFile::n_files, ProcessLib::OutputDataSpecification::output_variables, and ProcessLib::Output::OutputFile::path.

Referenced by doOutputAlways().

◆ shallDoOutput()

bool ProcessLib::Output::shallDoOutput	(	int	timestep,
		double const	t
	)

private

Determines if there should be output at the given timestep or t.

Definition at line 61 of file Output.cpp.

 {
     auto const fixed_output_time = std::lower_bound(
         cbegin(_fixed_output_times), cend(_fixed_output_times), t);
     if ((fixed_output_time != cend(_fixed_output_times)) &&
         (std::abs(*fixed_output_time - t) <
          std::numeric_limits<double>::epsilon()))
     {
         return true;
     }
  
     int each_steps = 1;
  
     for (auto const& pair : _repeats_each_steps)
     {
         each_steps = pair.each_steps;
  
         if (timestep > pair.repeat * each_steps)
         {
             timestep -= pair.repeat * each_steps;
         }
         else
         {
             break;
         }
     }
  
     if (timestep % each_steps == 0)
     {
         return true;
     }
  
     return false;
 }

References _fixed_output_times, and _repeats_each_steps.

Referenced by doOutput(), and doOutputLastTimestep().

Member Data Documentation

◆ _fixed_output_times

std::vector<double> const ProcessLib::Output::_fixed_output_times

private

Given times that steps have to reach.

Definition at line 124 of file Output.h.

Referenced by Output(), getFixedOutputTimes(), and shallDoOutput().

◆ _mesh_names_for_output

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

private

Definition at line 143 of file Output.h.

Referenced by addProcess(), and doOutputAlways().

◆ _mesh_xdmf_hdf_writer

std::unique_ptr<MeshLib::IO::XdmfHdfWriter> ProcessLib::Output::_mesh_xdmf_hdf_writer

private

Definition at line 102 of file Output.h.

Referenced by outputMeshXdmf().

◆ _meshes

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

private

Definition at line 144 of file Output.h.

Referenced by doOutputAlways().

◆ _n_files

unsigned int const ProcessLib::Output::_n_files

private

Specifies the number of hdf5 output files.

Definition at line 112 of file Output.h.

Referenced by doOutputAlways().

◆ _output_data_specification

OutputDataSpecification const ProcessLib::Output::_output_data_specification

private

Definition at line 142 of file Output.h.

Referenced by doOutputAlways(), doOutputNonlinearIteration(), and outputMeshXdmf().

◆ _output_directory

std::string const ProcessLib::Output::_output_directory

private

Definition at line 104 of file Output.h.

Referenced by addProcess(), doOutput(), doOutputAlways(), doOutputLastTimestep(), doOutputNonlinearIteration(), and findPVDFile().

◆ _output_file_compression

bool const ProcessLib::Output::_output_file_compression

private

Enables or disables zlib-compression of the output files.

Definition at line 110 of file Output.h.

Referenced by doOutputAlways(), and doOutputNonlinearIteration().

◆ _output_file_data_mode

int const ProcessLib::Output::_output_file_data_mode

private

Chooses vtk's data mode for output following the enumeration given in the vtkXMLWriter: {Ascii, Binary, Appended}. See vtkXMLWriter documentation http://www.vtk.org/doc/nightly/html/classvtkXMLWriter.html

Definition at line 117 of file Output.h.

Referenced by doOutputAlways(), and doOutputNonlinearIteration().

◆ _output_file_prefix

std::string const ProcessLib::Output::_output_file_prefix

private

Definition at line 106 of file Output.h.

Referenced by addProcess(), doOutputAlways(), doOutputNonlinearIteration(), and findPVDFile().

◆ _output_file_suffix

std::string const ProcessLib::Output::_output_file_suffix

private

Definition at line 107 of file Output.h.

Referenced by doOutputAlways(), and doOutputNonlinearIteration().

◆ _output_file_type

OutputType const ProcessLib::Output::_output_file_type

private

Definition at line 105 of file Output.h.

Referenced by doOutputAlways(), and doOutputNonlinearIteration().

◆ _output_nonlinear_iteration_results

bool const ProcessLib::Output::_output_nonlinear_iteration_results

private

Definition at line 118 of file Output.h.

Referenced by doOutputNonlinearIteration().

◆ _process_to_pvd_file

std::multimap<Process const*, MeshLib::IO::PVDFile> ProcessLib::Output::_process_to_pvd_file

private

Definition at line 126 of file Output.h.

Referenced by addProcess(), doOutputAlways(), doOutputNonlinearIteration(), and findPVDFile().

◆ _repeats_each_steps

std::vector<PairRepeatEachSteps> ProcessLib::Output::_repeats_each_steps

private

Describes after which timesteps to write output.

Definition at line 121 of file Output.h.

Referenced by shallDoOutput().

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

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

Detailed Description

Classes

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Constructor & Destructor Documentation

◆ Output()

Member Function Documentation

◆ addProcess()

◆ doOutput()

◆ doOutputAlways()

◆ doOutputLastTimestep()

◆ doOutputNonlinearIteration()

◆ findPVDFile()

◆ getFixedOutputTimes()

◆ outputMesh()

◆ outputMeshXdmf()

◆ shallDoOutput()

Member Data Documentation

◆ _fixed_output_times

◆ _mesh_names_for_output

◆ _mesh_xdmf_hdf_writer

◆ _meshes

◆ _n_files

◆ _output_data_specification

◆ _output_directory

◆ _output_file_compression

◆ _output_file_data_mode

◆ _output_file_prefix

◆ _output_file_suffix

◆ _output_file_type

◆ _output_nonlinear_iteration_results

◆ _process_to_pvd_file

◆ _repeats_each_steps