HdfWriter.cpp File Reference

Detailed Description

Copyright

Copyright (c) 2012-2025, OpenGeoSys Community (http://www.opengeosys.org) Distributed under a Modified BSD License. See accompanying file LICENSE.txt or http://www.opengeosys.org/project/license

Definition in file HdfWriter.cpp.

#include "HdfWriter.h"
#include <hdf5.h>
#include <string>
#include <utility>
#include <vector>
#include "BaseLib/Error.h"
#include "BaseLib/Logging.h"
#include "fileIO.h"

Include dependency graph for HdfWriter.cpp:

Go to the source code of this file.

Classes
struct	MeshLib::IO::HdfWriter::HdfMesh

Namespaces
namespace	MeshLib
namespace	MeshLib::IO

Functions
template<typename... Args>
void	checkHdfStatus (const hid_t status, fmt::format_string< Args... > formatting, Args &&... args)
static bool	checkCompression ()
static std::vector< Hdf5DimType >	prependDimension (Hdf5DimType const prepend_value, std::vector< Hdf5DimType > const &dimensions)
static hid_t	createDataSet (hid_t const data_type, std::vector< Hdf5DimType > const &data_dims, std::vector< Hdf5DimType > const &max_dims, std::vector< Hdf5DimType > const &chunk_dims, bool const use_compression, hid_t const section, std::string const &dataset_name)
static void	writeDataSet (void const *nodes_data, hid_t const data_type, std::vector< Hdf5DimType > const &data_dims, std::vector< Hdf5DimType > const &offset_dims, std::vector< Hdf5DimType > const &max_dims, std::vector< Hdf5DimType > const &chunk_dims, std::string const &dataset_name, Hdf5DimType const step, hid_t const dataset)
	Assumes a dataset is already opened by createDatasetFunction.
static void	writeTimeSeries (hid_t const file, std::vector< double > const &step_times, bool const is_file_manager)
	Write vector with time values into open hdf file.

Variables
static unsigned short int const	default_compression_factor = 1

Function Documentation

checkCompression()

bool checkCompression ( )

static

Definition at line 35 of file HdfWriter.cpp.

{
    // Check if gzip compression is available and can be used for both
    // compression and decompression.
    if (htri_t avail = H5Zfilter_avail(H5Z_FILTER_DEFLATE); !avail)
    {
        WARN("gzip filter not available.\n");
        return false;
    }
    unsigned int filter_info;
    H5Zget_filter_info(H5Z_FILTER_DEFLATE, &filter_info);
    if (!(filter_info & H5Z_FILTER_CONFIG_ENCODE_ENABLED) ||
        !(filter_info & H5Z_FILTER_CONFIG_DECODE_ENABLED))
    {
        WARN("gzip filter not available for encoding and decoding.\n");
        return false;
    }
    return true;
}

References WARN().

Referenced by MeshLib::IO::HdfWriter::HdfWriter().

checkHdfStatus()

template<typename... Args>

void checkHdfStatus	(	const hid_t	status,
		fmt::format_string< Args... >	formatting,
		Args &&...	args )

Definition at line 22 of file HdfWriter.cpp.

{
    if (status < 0)
    {
        OGS_FATAL(formatting, std::forward<Args>(args)...);
    }
}

References OGS_FATAL.

Referenced by MeshLib::IO::HdfWriter::HdfWriter().

createDataSet()

hid_t createDataSet ( hid_t const data_type, std::vector< Hdf5DimType > const & data_dims, std::vector< Hdf5DimType > const & max_dims, std::vector< Hdf5DimType > const & chunk_dims, bool const use_compression, hid_t const section, std::string const & dataset_name )

static

Definition at line 63 of file HdfWriter.cpp.

{
    int const time_dim_local_size = data_dims.size() + 1;
 
    std::vector<Hdf5DimType> const time_max_dims =
        prependDimension(H5S_UNLIMITED, max_dims);
    std::vector<Hdf5DimType> const time_data_global_dims =
        prependDimension(1, max_dims);
 
    std::vector<Hdf5DimType> const time_data_chunk_dims =
        prependDimension(1, chunk_dims);
 
    hid_t const fspace =
        H5Screate_simple(time_dim_local_size, time_data_global_dims.data(),
                         time_max_dims.data());
    assert(fspace >= 0);
 
    hid_t const dcpl = H5Pcreate(H5P_DATASET_CREATE);
    assert(dcpl >= 0);
 
    hid_t const status =
        H5Pset_chunk(dcpl, chunk_dims.size() + 1, time_data_chunk_dims.data());
    if (status < 0)
    {
        OGS_FATAL("H5Pset_layout failed for data set: {:s}.", dataset_name);
    }
 
    if (use_compression)
    {
        H5Pset_deflate(dcpl, default_compression_factor);
    }
 
    hid_t const dataset = H5Dcreate2(section, dataset_name.c_str(), data_type,
                                     fspace, H5P_DEFAULT, dcpl, H5P_DEFAULT);
 
    assert(dataset >= 0);
    H5Pclose(dcpl);
    assert(H5Sclose(fspace) >= 0);
 
    return dataset;
}

References default_compression_factor, OGS_FATAL, and prependDimension().

Referenced by MeshLib::IO::HdfWriter::HdfWriter().

prependDimension()

std::vector< Hdf5DimType > prependDimension ( Hdf5DimType const prepend_value, std::vector< Hdf5DimType > const & dimensions )

static

Definition at line 55 of file HdfWriter.cpp.

{
    std::vector<Hdf5DimType> dims = {prepend_value};
    dims.insert(dims.end(), dimensions.begin(), dimensions.end());
    return dims;
}

Referenced by createDataSet(), and writeDataSet().

writeDataSet()

void writeDataSet ( void const * nodes_data, hid_t const data_type, std::vector< Hdf5DimType > const & data_dims, std::vector< Hdf5DimType > const & offset_dims, std::vector< Hdf5DimType > const & max_dims, std::vector< Hdf5DimType > const & chunk_dims, std::string const & dataset_name, Hdf5DimType const step, hid_t const dataset )

static

Assumes a dataset is already opened by createDatasetFunction.

Defines what (nodes_data, data_type) will be written how (data subsections: data_dims, offset_dims, max_dims, chunk_dims, time) where (dataset and dataset_name)

Definition at line 115 of file HdfWriter.cpp.

{
    Hdf5DimType const time_steps = step + 1;
 
    std::vector<Hdf5DimType> const time_data_local_dims = data_dims;
    std::vector<Hdf5DimType> const time_max_dims =
        prependDimension(time_steps, max_dims);
    std::vector<Hdf5DimType> const time_offsets =
        prependDimension(step, offset_dims);
    std::vector<hsize_t> const count =
        prependDimension(1, time_data_local_dims);
 
    hid_t const io_transfer_property = createHDF5TransferPolicy();
 
    hid_t const mspace = H5Screate_simple(time_data_local_dims.size(),
                                          time_data_local_dims.data(), NULL);
    assert(H5Sselect_all(mspace) >= 0);
 
    hid_t status = H5Dset_extent(dataset, time_max_dims.data());
    if (status < 0)
    {
        OGS_FATAL("H5D set extent failed dataset '{:s}'.", dataset_name);
    }
    hid_t const fspace = H5Dget_space(dataset);
 
    H5Sselect_hyperslab(fspace, H5S_SELECT_SET, time_offsets.data(), NULL,
                        count.data(), NULL);
 
    status = H5Dwrite(dataset, data_type, mspace, fspace, io_transfer_property,
                      nodes_data);
    if (status < 0)
    {
        OGS_FATAL("H5Dwrite failed in dataset '{:s}'.", dataset_name);
    }
 
    H5Sclose(mspace);
    H5Pclose(io_transfer_property);
 
    return;
}

References MeshLib::IO::createHDF5TransferPolicy(), OGS_FATAL, and prependDimension().

Referenced by MeshLib::IO::HdfWriter::HdfWriter(), and MeshLib::IO::HdfWriter::writeStep().

writeTimeSeries()

void writeTimeSeries ( hid_t const file, std::vector< double > const & step_times, bool const is_file_manager )

static

Write vector with time values into open hdf file.

In contrast to all other hdf write methods writing is only performed by one process (is_file_manager_true). file handle is to an already opened file

Definition at line 170 of file HdfWriter.cpp.

{
    hsize_t const size = step_times.size();
    hid_t const memspace = H5Screate_simple(1, &size, NULL);
    hid_t const filespace = H5Screate_simple(1, &size, NULL);
 
    if (is_file_manager)
    {
        H5Sselect_all(memspace);
        H5Sselect_all(filespace);
    }
    else
    {
        H5Sselect_none(memspace);
        H5Sselect_none(filespace);
    }
 
    hid_t const dataset =
        H5Dcreate2(file, "/times", H5T_NATIVE_DOUBLE, filespace, H5P_DEFAULT,
                   H5P_DEFAULT, H5P_DEFAULT);
 
    H5Dwrite(dataset, H5T_NATIVE_DOUBLE, memspace, filespace, H5P_DEFAULT,
             step_times.data());
 
    H5Dclose(dataset);
    H5Sclose(memspace);
    H5Sclose(filespace);
};

Referenced by MeshLib::IO::HdfWriter::~HdfWriter().

Variable Documentation

default_compression_factor

unsigned short int const default_compression_factor = 1

static

Definition at line 31 of file HdfWriter.cpp.

Referenced by createDataSet().