Loading [MathJax]/extensions/tex2jax.js
OGS
MeshLib::IO::HdfWriter Class Referencefinal

Detailed Description

Definition at line 33 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
meshesmeta data of meshes to be written
initial_stepnumber of the step (temporal collection), usually 0, greater 0 with continuation of simulation
initial_timestart time; usually 0, but may differ (e.g. for restart).
filepathabsolute or relative filepath to the hdf5 file
use_compressionif true gzip compression is enabled
is_file_managerTrue if process (in parallel execution) is
n_filesNumber of output files

Definition at line 209 of file HdfWriter.cpp.

216 : _hdf5_filepath(filepath),
217 _file(createFile(filepath, n_files)),
219 H5Gcreate2(_file, "/meshes", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)),
220 _step_times{initial_time},
221 _use_compression(checkCompression() && use_compression),
222 _is_file_manager(is_file_manager)
223{
224 for (auto const& mesh : meshes)
225 {
226 hid_t const group = H5Gcreate2(_meshes_group, mesh.name.c_str(),
227 H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
228
229 auto const createAndWriteDataSet = [&](auto const& attribute) -> hid_t
230 {
231 hid_t const dataset = createDataSet(
232 attribute.data_type, attribute.data_space, attribute.file_space,
233 attribute.chunk_space, _use_compression, group, attribute.name);
234
235 checkHdfStatus(dataset, "Creating HDF5 Dataset: {:s} failed.",
236 attribute.name);
237
238 writeDataSet(attribute.data_start, attribute.data_type,
239 attribute.data_space, attribute.offsets,
240 attribute.file_space, attribute.chunk_space,
241 attribute.name, initial_step, dataset);
242 return dataset;
243 };
244
245 for (auto const& attribute : mesh.constant_attributes)
246 {
247 hid_t const dataset = createAndWriteDataSet(attribute);
248 H5Dclose(dataset);
249 }
250
251 std::map<std::string, hid_t> datasets;
252 for (auto const& attribute : mesh.variable_attributes)
253 {
254 hid_t const dataset = createAndWriteDataSet(attribute);
255 // datasets are kept open
256 datasets.insert({attribute.name, dataset});
257 }
258
259 _hdf_meshes.push_back(std::make_unique<HdfMesh>(
260 HdfMesh{group, datasets, mesh.variable_attributes}));
261 }
262}
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.
void checkHdfStatus(const hid_t status, fmt::format_string< Args... > formatting, Args &&... args)
Definition HdfWriter.cpp:22
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)
Definition HdfWriter.cpp:63
static bool checkCompression()
Definition HdfWriter.cpp:35
bool const _use_compression
Definition HdfWriter.h:76
std::filesystem::path const _hdf5_filepath
Definition HdfWriter.h:71
std::vector< std::unique_ptr< HdfMesh > > _hdf_meshes
Definition HdfWriter.h:74
bool const _is_file_manager
Definition HdfWriter.h:77
hid_t const _meshes_group
Definition HdfWriter.h:73
std::vector< double > _step_times
Definition HdfWriter.h:75
int64_t createFile(std::filesystem::path const &filepath, unsigned int n_files)
Definition fileIO.cpp:38

References _hdf_meshes, _meshes_group, _use_compression, checkHdfStatus(), createDataSet(), and writeDataSet().

◆ ~HdfWriter()

MeshLib::IO::HdfWriter::~HdfWriter ( )

Definition at line 264 of file HdfWriter.cpp.

265{
267
268 for (auto const& mesh : _hdf_meshes)
269 {
270 for (auto const& dataset : mesh->datasets)
271 {
272 if (auto const status = H5Dclose(dataset.second); status < 0)
273 {
274 ERR("Could not close dataset with id '{}' - status is '{}'.",
275 dataset.second, status);
276 }
277 }
278 if (auto const err = H5Gclose(mesh->group); err < 0)
279 {
280 ERR("Could not close group with group id '{}' - status is '{}'.",
281 mesh->group, err);
282 }
283 }
284 if (auto const group_err = H5Gclose(_meshes_group); group_err < 0)
285 {
286 ERR("Could not close group with group id '{}' - status is '{}'.",
287 _meshes_group, group_err);
288 }
289 if (auto const status = H5Fflush(_file, H5F_SCOPE_LOCAL); status < 0)
290 {
291 ERR("Could not flush data to file '{}' - status is '{}'.",
292 _hdf5_filepath.string(), status);
293 }
294 H5Fclose(_file);
295}
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.
void ERR(fmt::format_string< Args... > fmt, Args &&... args)
Definition Logging.h:45

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
timetime_value of step to be written to temporal collection

Definition at line 297 of file HdfWriter.cpp.

298{
299 auto const output_step = _step_times.size();
300 _step_times.push_back(time);
301
302 for (auto const& mesh : _hdf_meshes)
303 {
304 for (auto const& attribute : mesh->variable_attributes)
305 {
306 auto const& dataset_hid = mesh->datasets.find(attribute.name);
307 if (dataset_hid == mesh->datasets.end())
308 {
309 OGS_FATAL("Writing HDF5 Dataset: '{:s}' to file '{}' failed.",
310 attribute.name, _hdf5_filepath.string());
311 }
312
314 attribute.data_start, attribute.data_type, attribute.data_space,
315 attribute.offsets, attribute.file_space, attribute.chunk_space,
316 attribute.name, output_step, mesh->datasets.at(attribute.name));
317 if (auto const flush_status = H5Fflush(_file, H5F_SCOPE_LOCAL);
318 flush_status < 0)
319 {
320 ERR("HdfWriter::writeStep(): Could not flush to file '{}' - "
321 "status is '{}'.",
322 _hdf5_filepath.string(), flush_status);
323 }
324 }
325 }
326}
#define OGS_FATAL(...)
Definition Error.h:26

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 72 of file HdfWriter.h.

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

◆ _hdf5_filepath

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

Definition at line 71 of file HdfWriter.h.

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

◆ _hdf_meshes

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

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

Referenced by ~HdfWriter().

◆ _meshes_group

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

Definition at line 73 of file HdfWriter.h.

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

◆ _step_times

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

Definition at line 75 of file HdfWriter.h.

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

◆ _use_compression

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

Definition at line 76 of file HdfWriter.h.

Referenced by HdfWriter().


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