MeshLib::IO::HdfWriter Class Reference

Detailed Description

Definition at line 24 of file HdfWriter.h.

#include <HdfWriter.h>

Classes
struct	HdfMesh

Public Member Functions
	HdfWriter (std::vector< MeshHdfData > const &meshes, unsigned long long initial_step, double initial_time, std::filesystem::path const &filepath, bool use_compression, bool is_file_manager, unsigned int n_files, bool static_file)
	Write file with geometry and topology data. The data itself is held by a structure outside of this class. The writer assumes the data holder to not change during writing.
void	writeStep (double time)
	Writes attributes. The data itself is hold by a structure outside of this class. The writer assumes the data holder to not change during writing and HdfData given to constructor to be still valid.
	~HdfWriter ()

Private Member Functions
void	closeMeshesGroupAndFile ()

Private Attributes
std::filesystem::path const	_hdf5_filepath
hid_t const	_file
hid_t const	_meshes_group
std::vector< std::unique_ptr< HdfMesh > >	_hdf_meshes
std::vector< double >	_step_times
bool const	_use_compression
bool const	_is_file_manager
bool const	_static_file

Constructor & Destructor Documentation

HdfWriter()

MeshLib::IO::HdfWriter::HdfWriter	(	std::vector< MeshHdfData > const &	meshes,
		unsigned long long	initial_step,
		double	initial_time,
		std::filesystem::path const &	filepath,
		bool	use_compression,
		bool	is_file_manager,
		unsigned int	n_files,
		bool	static_file )

Write file with geometry and topology data. The data itself is held by a structure outside of this class. The writer assumes the data holder to not change during writing.

Parameters

meshes	meta data of meshes to be written
initial_step	number of the step (temporal collection), usually 0, greater 0 with continuation of simulation
initial_time	start time; usually 0, but may differ (e.g. for restart).
filepath	absolute or relative filepath to the hdf5 file
use_compression	if true gzip compression is enabled
is_file_manager	True if process (in parallel execution) is
n_files	Number of output files
static_file	If true, only the constant_attributes of each mesh are written, the file is flushed and closed inside the constructor, and subsequent calls to writeStep() are no-ops. Use this for data that does not change over time (e.g. mesh geometry/topology).

Definition at line 203 of file HdfWriter.cpp.

    : _hdf5_filepath(filepath),
      _file(createFile(filepath, n_files)),
      _meshes_group(
          H5Gcreate2(_file, "/meshes", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)),
      _step_times{initial_time},
      _use_compression(checkCompression() && use_compression),
      _is_file_manager(is_file_manager),
      _static_file(static_file)
{
    auto const createAndWriteDataSet = [&](hid_t const group,
                                           auto const& attribute) -> hid_t
    {
        hid_t const dataset = createDataSet(
            attribute.data_type, attribute.data_space, attribute.file_space,
            attribute.chunk_space, _use_compression, group, attribute.name);
 
        checkHdfStatus(dataset, "Creating HDF5 Dataset: {:s} failed.",
                       attribute.name);
 
        writeDataSet(attribute.data_start, attribute.data_type,
                     attribute.data_space, attribute.offsets,
                     attribute.file_space, attribute.chunk_space,
                     attribute.name, initial_step, dataset);
        return dataset;
    };
 
    if (_static_file)
    {
        for (auto const& mesh : meshes)
        {
            hid_t const group =
                H5Gcreate2(_meshes_group, mesh.name.c_str(), H5P_DEFAULT,
                           H5P_DEFAULT, H5P_DEFAULT);
 
            for (auto const& attribute : mesh.constant_attributes)
            {
                hid_t const dataset = createAndWriteDataSet(group, attribute);
                if (auto const err = H5Dclose(dataset); err < 0)
                {
                    ERR("Could not close dataset with dataset id '{}' - status "
                        "is '{}'.",
                        dataset, err);
                }
            }
 
            if (auto const err = H5Gclose(group); err < 0)
            {
                ERR("Could not close group with group id '{}' - status is "
                    "'{}'.",
                    group, err);
            }
        }
        closeMeshesGroupAndFile();
        return;
    }
 
    for (auto const& mesh : meshes)
    {
        hid_t const group = H5Gcreate2(_meshes_group, mesh.name.c_str(),
                                       H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
 
        for (auto const& attribute : mesh.constant_attributes)
        {
            hid_t const dataset = createAndWriteDataSet(group, attribute);
            if (auto const err = H5Dclose(dataset); err < 0)
            {
                ERR("Could not close dataset with dataset id '{}' - status is "
                    "'{}'.",
                    dataset, err);
            }
        }
 
        std::map<std::string, hid_t> datasets;
        for (auto const& attribute : mesh.variable_attributes)
        {
            hid_t const dataset = createAndWriteDataSet(group, attribute);
            // datasets are kept open
            datasets.insert({attribute.name, dataset});
        }
 
        _hdf_meshes.push_back(std::make_unique<HdfMesh>(
            HdfMesh{group, datasets, mesh.variable_attributes}));
    }
}

References _file, _hdf5_filepath, _hdf_meshes, _is_file_manager, _meshes_group, _static_file, _step_times, _use_compression, checkCompression(), checkHdfStatus(), closeMeshesGroupAndFile(), createDataSet(), MeshLib::IO::createFile(), ERR(), and writeDataSet().

~HdfWriter()

MeshLib::IO::HdfWriter::~HdfWriter

(

)

Definition at line 296 of file HdfWriter.cpp.

{
    if (_static_file)
    {
        return;
    }
 
    writeTimeSeries(_file, _step_times, _is_file_manager);
 
    for (auto const& mesh : _hdf_meshes)
    {
        for (auto const& dataset : mesh->datasets)
        {
            if (auto const status = H5Dclose(dataset.second); status < 0)
            {
                ERR("Could not close dataset with id '{}' - status is '{}'.",
                    dataset.second, status);
            }
        }
        if (auto const err = H5Gclose(mesh->group); err < 0)
        {
            ERR("Could not close group with group id '{}' - status is '{}'.",
                mesh->group, err);
        }
    }
    closeMeshesGroupAndFile();
}

References _file, _hdf_meshes, _is_file_manager, _static_file, _step_times, closeMeshesGroupAndFile(), ERR(), and writeTimeSeries().

Member Function Documentation

closeMeshesGroupAndFile()

void MeshLib::IO::HdfWriter::closeMeshesGroupAndFile ( )

private

Closes the meshes group, flushes and closes the HDF5 file, logging a diagnostic on any failure. Shared by the static-file constructor path and the destructor.

Definition at line 324 of file HdfWriter.cpp.

{
    if (auto const group_err = H5Gclose(_meshes_group); group_err < 0)
    {
        ERR("Could not close group with group id '{}' - status is '{}'.",
            _meshes_group, group_err);
    }
    if (auto const status = H5Fflush(_file, H5F_SCOPE_LOCAL); status < 0)
    {
        ERR("Could not flush data to file '{}' - status is '{}'.",
            _hdf5_filepath.string(), status);
    }
    if (auto const err = H5Fclose(_file); err < 0)
    {
        ERR("Could not close file '{}' - status is '{}'.",
            _hdf5_filepath.string(), err);
    }
}

References _file, _hdf5_filepath, _meshes_group, and ERR().

Referenced by HdfWriter(), and ~HdfWriter().

writeStep()

void MeshLib::IO::HdfWriter::writeStep

(

double

time

)

Writes attributes. The data itself is hold by a structure outside of this class. The writer assumes the data holder to not change during writing and HdfData given to constructor to be still valid.

Parameters

time	time_value of step to be written to temporal collection

Definition at line 343 of file HdfWriter.cpp.

{
    if (_static_file)
    {
        return;
    }
 
    auto const output_step = _step_times.size();
    _step_times.push_back(time);
 
    for (auto const& mesh : _hdf_meshes)
    {
        for (auto const& attribute : mesh->variable_attributes)
        {
            auto const& dataset_hid = mesh->datasets.find(attribute.name);
            if (dataset_hid == mesh->datasets.end())
            {
                OGS_FATAL("Writing HDF5 Dataset: '{:s}' to file '{}' failed.",
                          attribute.name, _hdf5_filepath.string());
            }
 
            writeDataSet(
                attribute.data_start, attribute.data_type, attribute.data_space,
                attribute.offsets, attribute.file_space, attribute.chunk_space,
                attribute.name, output_step, mesh->datasets.at(attribute.name));
            if (auto const flush_status = H5Fflush(_file, H5F_SCOPE_LOCAL);
                flush_status < 0)
            {
                ERR("HdfWriter::writeStep(): Could not flush to file '{}' - "
                    "status is '{}'.",
                    _hdf5_filepath.string(), flush_status);
            }
        }
    }
}

References _file, _hdf5_filepath, _hdf_meshes, _static_file, _step_times, ERR(), OGS_FATAL, and writeDataSet().

Member Data Documentation

_file

hid_t const MeshLib::IO::HdfWriter::_file

private

Definition at line 73 of file HdfWriter.h.

Referenced by HdfWriter(), ~HdfWriter(), closeMeshesGroupAndFile(), and writeStep().

_hdf5_filepath

std::filesystem::path const MeshLib::IO::HdfWriter::_hdf5_filepath

private

Definition at line 72 of file HdfWriter.h.

Referenced by HdfWriter(), closeMeshesGroupAndFile(), and writeStep().

_hdf_meshes

std::vector<std::unique_ptr<HdfMesh> > MeshLib::IO::HdfWriter::_hdf_meshes

private

Definition at line 75 of file HdfWriter.h.

Referenced by HdfWriter(), ~HdfWriter(), and writeStep().

_is_file_manager

bool const MeshLib::IO::HdfWriter::_is_file_manager

private

Definition at line 78 of file HdfWriter.h.

Referenced by HdfWriter(), and ~HdfWriter().

_meshes_group

hid_t const MeshLib::IO::HdfWriter::_meshes_group

private

Definition at line 74 of file HdfWriter.h.

Referenced by HdfWriter(), and closeMeshesGroupAndFile().

_static_file

bool const MeshLib::IO::HdfWriter::_static_file

private

Definition at line 79 of file HdfWriter.h.

Referenced by HdfWriter(), ~HdfWriter(), and writeStep().

_step_times

std::vector<double> MeshLib::IO::HdfWriter::_step_times

private

Definition at line 76 of file HdfWriter.h.

Referenced by HdfWriter(), ~HdfWriter(), and writeStep().

_use_compression

bool const MeshLib::IO::HdfWriter::_use_compression

private

Definition at line 77 of file HdfWriter.h.

Referenced by HdfWriter().

---

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

• HdfWriter.h
• HdfWriter.cpp