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

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 )

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

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)
{
    for (auto const& mesh : meshes)
    {
        hid_t const group = H5Gcreate2(_meshes_group, mesh.name.c_str(),
                                       H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
 
        auto const createAndWriteDataSet = [&](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;
        };
 
        for (auto const& attribute : mesh.constant_attributes)
        {
            hid_t const dataset = createAndWriteDataSet(attribute);
            H5Dclose(dataset);
        }
 
        std::map<std::string, hid_t> datasets;
        for (auto const& attribute : mesh.variable_attributes)
        {
            hid_t const dataset = createAndWriteDataSet(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, _step_times, _use_compression, checkCompression(), checkHdfStatus(), createDataSet(), MeshLib::IO::createFile(), and writeDataSet().

~HdfWriter()

MeshLib::IO::HdfWriter::~HdfWriter

(

)

Definition at line 258 of file HdfWriter.cpp.

{
    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);
        }
    }
    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);
    }
    H5Fclose(_file);
}

References _file, _hdf5_filepath, _hdf_meshes, _is_file_manager, _meshes_group, _step_times, ERR(), and writeTimeSeries().

Member Function Documentation

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 291 of file HdfWriter.cpp.

{
    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, _step_times, ERR(), OGS_FATAL, and writeDataSet().

Member Data Documentation

_file

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

private

Definition at line 63 of file HdfWriter.h.

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

_hdf5_filepath

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

private

Definition at line 62 of file HdfWriter.h.

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

_hdf_meshes

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

private

Definition at line 65 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 68 of file HdfWriter.h.

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

_meshes_group

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

private

Definition at line 64 of file HdfWriter.h.

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

_step_times

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

private

Definition at line 66 of file HdfWriter.h.

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

_use_compression

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

private

Definition at line 67 of file HdfWriter.h.

Referenced by HdfWriter().

---

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

• HdfWriter.h
• HdfWriter.cpp