ParallelIoHdf5 Class Reference

#include <parallelio_hdf5.h>

Inheritance diagram for ParallelIoHdf5:

Collaboration diagram for ParallelIoHdf5:

Public Member Functions
	ParallelIoHdf5 (const MString &fileName, MInt fileMode, const MPI_Comm &mpiComm)
	Creates a new object to read and write big data files. [MPI] More...
	~ParallelIoHdf5 () override
	Close open identifiers and release memory. [MPI] More...
template<>
void	b_setAttribute (const MString *value, const MString &name, const MString &datasetName, const size_type totalCount)
	Set an attribute in the file (string version). More...
template<>
void	b_getAttribute (MString *value, const MString &name, const MString &datasetName, const size_type totalCount)
	Retrieve an attribute from file (MString version). More...
template<>
void	b_writeArray (const MString *array, const MString &name, const size_type noDims, MPI_Offset *start, MPI_Offset *count, MPI_Offset memoryStride, const size_type noChunks, MPI_Offset diskStride)
	Writes array data to file (String version). [MPI] More...
template<>
void	b_readArray (MString *array, const MString &name, const size_type noDims, MPI_Offset *start, MPI_Offset *count, MPI_Offset memoryStride, const size_type noChunks, MPI_Offset diskStride)
	Read array data from file (string version). [MPI] More...
template<>
void	b_readScalar (MString *scalar, const MString &name)
	Read scalar data from file (float version). [MPI] More...
template<>
void	b_createAttribute (const MString *value, const MString &name, const MString &datasetName, hid_t dtype_id, const size_type totalCount)
	Creates an attribute in the file (string version). More...
Public Member Functions inherited from ParallelIoBase< ParallelIoHdf5 >
MBool	hasDataset (const MString &name, MInt dimension)
	Check if the file contains an dataset with the given name and dimension. More...
MBool	hasDataset (const MString &name, const MString &path)
MBool	hasDataset (const MString &name)
	Check if the file contains an dataset with the given name. More...
MBool	hasObject (const MString &path)
MInt	getDatasetType (const MString &name)
	Returns the data type of an array. More...
std::vector< MString >	getDatasetNames (const size_type dimensions=-1)
	Returns a vector with the names of all existing datasets with given dimensionality in the file. More...
std::vector< MString >	getDatasetNames (const MString &path)
std::vector< MString >	getGroupNames (const MString &path)
size_type	getDatasetNoDims (const MString &name)
	Get the number of dimensions of a dataset with given name. More...
size_type	getDatasetNoDims (const MString &name, const MString &path)
std::vector< size_type >	getArrayDims (const MString &name)
	Get the lengths of all dimensions of a dataset with given name. More...
size_type	getArraySize (const MString &name, const size_type dimensionId=0)
	Get the length of an array in the file. More...
void	getArraySize (const MString &name, const MString &path, size_type *datasetSize)
MBool	hasAttribute (const MString &name, const MString &path="")
	Check if a given attribute exists in the file. More...
maiabd_type	getAttributeType (const MString &name, const MString &datasetName="")
	Returns the data type of an attribute in the file. More...
void	defineArray (maiabd_type type, const MString &name, size_type totalCount)
	Create a new array in the file. More...
void	defineArray (maiabd_type type, const MString &name, size_type noDims, size_type *totalCount)
	Create a new array in the file. More...
void	defineArray (maiabd_type type, const std::vector< MString > &name, size_type totalCount)
	Create multiple new arrays in the file. More...
void	defineArray (maiabd_type type, const MString &datasetName, const MString &name, size_type noDims, size_type *totalCount)
	Creates new array in the file. More...
void	defineScalar (maiabd_type type, const MString &name)
	Create a new scalar in the file. More...
void	writeArray (const T *array, const MString &name, size_type memoryStride=-1, size_type diskStride=-1)
	Write array data to file. [MPI] More...
void	writeArray (const T *array, const std::vector< MString > &names, size_type memoryStride=-1, size_type diskStride=-1)
	Write array data to file (multi-array version). [MPI] More...
void	writeArray (const T *array, const MString &path, const MString &name, const size_type noDims, size_type *offset, size_type *localCount)
	Write multidimensional array data to file. [MPI] More...
void	writeArray (const T *array, const MString &path, const MString &name, const size_type noDims, size_type *offset, size_type *localCount, size_type *ghost)
	Write multidimensional array data to file [ghost cell version]. [MPI] More...
void	writeScalar (T scalar, const MString &name)
	Write scalar data to file. [MPI] More...
void	setAttribute (const T &value, const MString &name, const MString &datasetName="")
	Set a file or dataset attribute. [MPI] More...
void	setAttribute (const MChar *value, const MString &name, const MString &datasetName="")
void	setAttributes (const T *value, const MString &name, size_type totalCount, const MString &datasetName="")
void	readArray (T *array, const MString &name, size_type memoryStride=-1, size_type diskStride=-1)
	Read array data from file. [MPI] More...
void	readArray (std::vector< T > &array, const MString &name, size_type memoryStride=-1, size_type diskStride=-1)
void	readArray (T *array, const std::vector< MString > &names, size_type memoryStride=-1, size_type diskStride=-1)
	Read array data from file (multi-array version). [MPI] More...
void	readArray (T *array, const MString &datasetName, const MString &name, const size_type noDims, const size_type *offset, const size_type *localCount)
	Read array data from file. [MPI] More...
void	readArray (T *array, const MString &datasetName, const MString &name, const size_type noDims, const size_type *localCount)
	Read array data from file [no offset version]. [MPI] More...
void	readScalar (T *scalar, const MString &name)
	Read scalar data from file. [MPI] More...
void	getAttribute (T *value, const MString &name, const MString &datasetName="")
	Retrieve a file or dataset attribute. More...
void	getAttribute (T *value, const MString &name, const size_type totalCount, const MString &datasetName="")
void	getAttributeCount (const MString &name, size_type *totalCount, const MString &datasetName="")
void	setOffset (const size_type localCount, const size_type offset, const size_type noDims, const size_type noChunks)
	Set the local and global counts, as well the local offset for array operations. More...
void	setOffset (const size_type localCount, const size_type offset, const size_type noDims)
	Set the local and global counts, as well the local offset for array operations (overload). More...
void	setOffset (size_type localCount, size_type offset)
	Set the local and global counts, as well the local offset for array operations (overload). More...

Private Member Functions
void	b_open ()
void	b_saveHeader ()
	Adds all additional header information that are needed in the file. More...
void	b_addAdditionalHeader ()
	Write additional headers to file (e.g. grid file name, creation date etc.). [MPI] More...
void	b_writeAdditionalData ()
	Write additional data to file. [MPI] More...
void	b_defineArray (maiabd_type type, const MString &name, size_type noDims, size_type *totalCount)
	Defines an array in the file. [MPI] More...
void	b_defineArray (maiabd_type, const MString &, const MString &, const size_type, const size_type *)
void	b_defineScalar (maiabd_type type, const MString &name)
	Defines a scalar in the file. [MPI] More...
void	b_createGroup (const MString &path)
	Creates an HDF5 group [MPI] More...
size_type	b_getNoDatasets (const MString &path)
	Gets the number of datasetes in the given group [MPI] More...
size_type	b_getNoGroups (const MString &path)
	Gets the number of groups in the given group [MPI] More...
MBool	b_hasDataset (const MString &name, const size_type dimension)
	Check if the file contains a dataset with the given name and number of dimensions. More...
MBool	b_hasDataset (const MString &name, const MString &path)
	Check if dataset exists. [MPI] More...
MBool	b_hasObject (const MString &path)
MInt	b_getDatasetType (const MString &name)
	Returns the data type of a dataset in the file (can be array, multi-D array or scalar). More...
void	b_getDatasetNames (std::vector< MString > &names, const size_type dimension)
	Returns a vector of all existing datasets with the given number of dimensions in the file (if any). [MPI] More...
void	b_getDatasetNames (std::vector< MString > &names, const MString &path)
	Gets the dataset names in the given group [MPI] More...
void	b_getGroupNames (std::vector< MString > &names, const MString &path)
	Gets the groups in the given group [MPI] More...
size_type	b_getDatasetNoDims (const MString &name)
	Get number of dimensions of a dataset with the given name. More...
size_type	b_getDatasetNoDims (const MString &path, const MString &name)
	Returns number of dimensions of dataset [MPI] More...
size_type	b_getDatasetSize (const MString &name, const size_type dimensionId=0)
	Get the length of one dimension of an arbitrary array in the file. More...
void	b_getDatasetSize (const MString &name, const MString &path, size_type noDims, size_type *data)
	Gets the size of a dataset in space directions. [MPI] More...
MBool	b_hasAttribute (const MString &name, const MString &path="")
	Check if object exists. [MPI] More...
MInt	b_getAttributeType (const MString &name, const MString &datasetName="")
	Returns the data type of an attribute in the file. More...
template<class T >
void	b_writeArray (const T *array, const MString &name, const size_type noDims, MPI_Offset *start, MPI_Offset *count, MPI_Offset memoryStride, const size_type noChunks, MPI_Offset diskStride)
	Writes array data to file (Hdf5 version). [MPI] More...
template<class T >
void	b_writeArray (const T *, const MString &, const MString &, const size_type, const size_type *, const size_type *, const size_type *)
	Write data array, ghost cell version. [MPI] More...
template<class T >
void	b_writeScalar (T scalar, const MString &name)
	Writes scalar data to file (Hdf5 version). [MPI] More...
template<class T >
void	b_readArray (T *, const MString &, const size_type, MPI_Offset *, MPI_Offset *, MPI_Offset, const size_type, MPI_Offset)
	Read array data from file (float version). [MPI] More...
template<class T >
void	b_readArray (T *, const MString &, const MString &, const size_type, const size_type *, const size_type *)
	Read double data from file. [MPI] More...
template<class T >
void	b_readScalar (T *scalar, const MString &name)
	Read scalar data from file (float version). [MPI] More...
template<class T >
void	b_setAttribute (const T *value, const MString &name, const MString &datasetName="", const size_type totalCount=1)
	Set an attribute in the file (generic version). More...
template<class T >
void	b_createAttribute (const T *value, const MString &name, const MString &datasetName, hid_t type_id, const size_type totalCount)
	Creates an attribute in the file (generic version). More...
template<class T >
void	b_getAttribute (T *value, const MString &name, const MString &datasetName="", const size_type totalCount=1)
	Retrieve an attribute from file (float version). More...
void	b_getAttributeCount (const MString &name, size_type *totalCount, const MString &datasetName="")

Static Private Member Functions
static MBool	b_isValidFile (const MString &name, const MPI_Comm &mpiComm)
	Check if specified file is a valid HDF5 file (i.e. can be opened). [MPI] More...
static const MString	b_fileExt ()
	Returns backend-specific ending of filename (either ".Netcdf" or ".Hdf5") More...
static void	b_error (MInt status, const MString &name, const MString &location)
	Check the status code of a HDF5 operation and output a meaningful message. More...
static void	b_warning (MInt status, const MString &name, const MString &location)
	Check the status code of a HDF5 operation and output a meaningful message (Warning) More...

Private Attributes
friend	ParallelIoBase< ParallelIoHdf5 >
hid_t	b_h5Id = -1
hid_t	b_h5DatasetXferHandle
hid_t	b_h5FileXferHandle

Additional Inherited Members
Public Types inherited from ParallelIoBase< ParallelIoHdf5 >
using	size_type = MLong
	Type used for all size- and offset-related values. More...
using	maiabd_type = maia::parallel_io::maiabd_type
	Type used for all constants that are defined in maia::parallel_io. More...
Static Public Member Functions inherited from ParallelIoBase< ParallelIoHdf5 >
static MBool	fileExists (const MString &name, const MPI_Comm &mpiComm)
	Check whether a file exists. [MPI] More...
static void	deleteFile (const MString &name)
	Deletes the specified file. [MPI] More...
static MBool	isParallelIoFile (const MString &name, const MPI_Comm &mpiComm)
	Check if specified file is a valid ParallelIoHdf5 file. [MPI] More...
static MString	fileExt ()
	Returns backend-specific ending of filename (either ".Netcdf" or ".Hdf5") More...
static void	calcOffset (size_type localCount, size_type *offset, size_type *totalCount, const MPI_Comm &mpiComm, size_type *noChunks=nullptr)
	Calculates the totalCount and offset information needed in setOffset(). [MPI] More...
Protected Member Functions inherited from ParallelIoBase< ParallelIoHdf5 >
	ParallelIoBase (MString fileName, MInt fileMode, const MPI_Comm &mpiComm)
	Creates a new object to read and write big data files. [MPI] More...
virtual	~ParallelIoBase ()
	empty destructor. [MPI] More...
void	validateType (const maiabd_type type) const
	Auxiliary method that aborts MAIA if type is not a valid type constant for ParallelIo. More...
Protected Attributes inherited from ParallelIoBase< ParallelIoHdf5 >
const MString	m_fileName
const MInt	m_fileMode
MBool	m_isHeaderSaved
MInt	m_domainId
MInt	m_noDomains
MPI_Comm	m_mpiComm
MPI_Info	m_mpiInfo
MBool	m_offsetsAreSet
std::vector< size_type >	m_localCount
std::vector< size_type >	m_offset
size_type	m_noChunks
MFloat	m_creationTime
std::set< MString >	m_unwrittenArrays
std::set< MString >	m_unwrittenScalars
std::set< MString >	m_writtenArrays
std::set< MString >	m_writtenScalars
std::set< MString >	m_readArrays
std::set< MString >	m_readScalars
Static Protected Attributes inherited from ParallelIoBase< ParallelIoHdf5 >
static const size_type	s_maxChunkSize
static const MPI_Datatype	s_mpiSizeType

Detailed Description

Definition at line 19 of file parallelio_hdf5.h.

Constructor & Destructor Documentation

ParallelIoHdf5()

ParallelIoHdf5::ParallelIoHdf5	(	const MString &	fileName,
		MInt	fileMode,
		const MPI_Comm &	mpiComm
	)

Author

Michael Schlottke (mic) mic@a.nosp@m.ia.r.nosp@m.wth-a.nosp@m.ache.nosp@m.n.de

Date

2013-03-2

Author

(Modified by: )Ramandeep Jain (HiWi) raman.nosp@m.deep.nosp@m.jain@.nosp@m.gmai.nosp@m.l.com, Konstantin Froehlich

Date

2015-03-01

Parameters

[in]	fileName
[in]	fileMode	The file mode can be either maia::parallel_io::PIO_CREATE, maia::parallel_io::PIO_APPEND, or maia::parallel_io::PIO_READ.
[in]	mpiComm	The MPI communicator that should be used to open/create the file.

Definition at line 185 of file parallelio_hdf5.cpp.

  : ParallelIoBase<ParallelIoHdf5>(fileName, fileMode, mpiComm) {
  TRACE();
 
#ifdef DISABLE_OUTPUT
  if(m_fileMode != PIO_READ) return;
#endif
 
  // Store MPI IO communicator
  b_h5FileXferHandle = H5Pcreate(H5P_FILE_ACCESS);
  herr_t status = H5Pset_fapl_mpio(b_h5FileXferHandle, m_mpiComm, m_mpiInfo);
  b_error(status, m_fileName, AT_);
 
  // Setting b_h5DatasetXferHandle to collective access
  b_h5DatasetXferHandle = H5Pcreate(H5P_DATASET_XFER);
 
  status = H5Pset_dxpl_mpio(b_h5DatasetXferHandle, H5FD_MPIO_COLLECTIVE);
  b_error(status, m_fileName, AT_);
 
  switch(m_fileMode) {
    case PIO_CREATE: {
      b_h5Id = H5Fcreate(m_fileName.c_str(), H5F_ACC_EXCL, H5P_DEFAULT, b_h5FileXferHandle);
      b_error(b_h5Id, m_fileName + " :: CREATE", AT_);
    } break;
 
    case PIO_REPLACE: {
      b_h5Id = H5Fcreate(m_fileName.c_str(), H5F_ACC_TRUNC, H5P_DEFAULT, b_h5FileXferHandle);
      b_error(b_h5Id, m_fileName + " :: REPLACE", AT_);
    } break;
 
    case PIO_APPEND: {
      // Attempt to open an existing file to append data
      b_h5Id = H5Fopen(m_fileName.c_str(), H5F_ACC_RDWR, b_h5FileXferHandle);
      b_error(b_h5Id, m_fileName + " :: APPEND", AT_);
    } break;
 
    case PIO_READ: {
      b_h5Id = H5Fopen(m_fileName.c_str(), H5F_ACC_RDONLY, b_h5FileXferHandle);
      b_error(b_h5Id, m_fileName + " :: READ", AT_);
    } break;
 
    default: {
      mTerm(1, AT_, "Unsupported file mode.");
    } break;
  }
}

~ParallelIoHdf5()

ParallelIoHdf5::~ParallelIoHdf5 ( )

override

Author

Konstantin Froehlich

Date

2015-07-01

Definition at line 238 of file parallelio_hdf5.cpp.

                                {
  TRACE();
 
  // Close all identifiers used for collective writing
  herr_t status = H5Pclose(b_h5DatasetXferHandle);
  b_error(status, m_fileName, AT_);
  status = H5Pclose(b_h5FileXferHandle);
  b_error(status, m_fileName, AT_);
  status = H5Fclose(b_h5Id);
  b_error(status, m_fileName, AT_);
 
#ifdef MAIA_EXTRA_DEBUG
  for(set<MString>::iterator it = m_unwrittenArrays.begin(); it != m_unwrittenArrays.end(); ++it) {
    cerr << "Warning: array '" << *it << "' in file '" << m_fileName << "' was defined but never written. "
         << "Make sure that this is the intended behavior." << endl;
  }
  for(set<MString>::iterator it = m_unwrittenScalars.begin(); it != m_unwrittenScalars.end(); ++it) {
    cerr << "Warning: scalar '" << *it << "' in file '" << m_fileName << "' was defined but never written. "
         << "Make sure that this is the intended behavior." << endl;
  }
#endif
}

Member Function Documentation

b_addAdditionalHeader()

void ParallelIoHdf5::b_addAdditionalHeader ( )

private

Author

Michael Schlottke (mic) mic@a.nosp@m.ia.r.nosp@m.wth-a.nosp@m.ache.nosp@m.n.de

Date

2013-04-12

Definition at line 294 of file parallelio_hdf5.cpp.

                                           {
  TRACE();
 
  // For a newly created or modified file, add some meta information
  if(m_fileMode != PIO_READ) {
    const MInt maxNoChars = 256;
 
    // Get all meta-data on root process & communicate, since some of the C
    // functions might not be thread-safe (at least getpwuid() is not)
    MChar user[maxNoChars];
    MChar host[maxNoChars];
    MChar dir[maxNoChars];
    MChar date[maxNoChars];
 
    // Create object & initialize data
    fill(user, user + maxNoChars, '\0');
    fill(host, host + maxNoChars, '\0');
    fill(dir, dir + maxNoChars, '\0');
    fill(date, date + maxNoChars, '\0');
 
    if(m_domainId == 0) {
      // Gets the current username
      passwd* p;
#if not defined(MAIA_WINDOWS)
      p = getpwuid(getuid());
      if(p) {
        strncpy(user, p->pw_name, maxNoChars - 1);
      } else {
        strncpy(user, "n/a", maxNoChars - 1);
      }
#else
      strncpy(user, "windows", maxNoChars - 1);
#endif
 
      // Gets the current hostname
      gethostname(host, maxNoChars - 1);
 
      // Gets the current directory
#if defined(MAIA_WINDOWS)
      _getcwd(dir, maxNoChars - 1);
#else
      char* retv = getcwd(dir, maxNoChars - 1);
      ASSERT(retv != nullptr, "");
#endif
 
      // Get the current time and write it to rawTime
      time_t rawTime;
      time(&rawTime);
 
      // Convert to time struct
      tm* timeInfo;
      timeInfo = localtime(&rawTime);
 
      // Format time to string and save to buffer
      strftime(date, maxNoChars, "%Y-%m-%d %H:%M:%S", timeInfo);
    }
 
    // Pack data
    const MInt noItems = 4;
    MChar buffer[noItems * maxNoChars];
    memcpy(buffer + 0 * maxNoChars, user, maxNoChars);
    memcpy(buffer + 1 * maxNoChars, host, maxNoChars);
    memcpy(buffer + 2 * maxNoChars, dir, maxNoChars);
    memcpy(buffer + 3 * maxNoChars, date, maxNoChars);
 
    // Broadcast time from rank 0 to ensure that every rank has the same
    // information
    MPI_Bcast(&buffer, 4 * maxNoChars, MPI_CHAR, 0, m_mpiComm, AT_, "buffer");
 
    // Unpack data
    memcpy(user, buffer + 0 * maxNoChars, maxNoChars);
    memcpy(host, buffer + 1 * maxNoChars, maxNoChars);
    memcpy(dir, buffer + 2 * maxNoChars, maxNoChars);
    memcpy(date, buffer + 3 * maxNoChars, maxNoChars);
 
    MString version = MString(XSTRINGIFY(MAIA_VERSION_STRING));
    MString build = MString(XSTRINGIFY(MAIA_COMPILER_STRING)) + " " + MString(XSTRINGIFY(MAIA_BUILD_TYPE_STRING)) + " ("
                    + MString(XSTRINGIFY(MAIA_COMPILER_VERSION_STRING)) + ")";
 
    if(m_fileMode == PIO_CREATE || m_fileMode == PIO_REPLACE) {
      // Add file attributes only needed for creation
      ParallelIoBase<ParallelIoHdf5>::setAttribute(MString(user), "meta_creation_user");
      ParallelIoBase<ParallelIoHdf5>::setAttribute(MString(host), "meta_creation_host");
      ParallelIoBase<ParallelIoHdf5>::setAttribute(MString(dir), "meta_creation_directory");
      ParallelIoBase<ParallelIoHdf5>::setAttribute(MString(date), "meta_creation_date");
      ParallelIoBase<ParallelIoHdf5>::setAttribute(m_noDomains, "meta_creation_noDomains");
      ParallelIoBase<ParallelIoHdf5>::setAttribute(MString(date), "_meta_creation_date");
      ParallelIoBase<ParallelIoHdf5>::setAttribute(version, "_meta_creation_revision");
      ParallelIoBase<ParallelIoHdf5>::setAttribute(build, "_meta_creation_build");
    }
 
    // Add file attributes that should be set at each modification
    ParallelIoBase<ParallelIoHdf5>::setAttribute(MString(user), "meta_lastModified_user");
    ParallelIoBase<ParallelIoHdf5>::setAttribute(MString(host), "meta_lastModified_host");
    ParallelIoBase<ParallelIoHdf5>::setAttribute(MString(dir), "meta_lastModified_directory");
    ParallelIoBase<ParallelIoHdf5>::setAttribute(MString(date), "meta_lastModified_date");
    ParallelIoBase<ParallelIoHdf5>::setAttribute(m_noDomains, "meta_lastModified_noDomains");
    ParallelIoBase<ParallelIoHdf5>::setAttribute(version, "_meta_lastModified_revision");
    ParallelIoBase<ParallelIoHdf5>::setAttribute(build, "_meta_lastModified_build");
  }
}

b_createAttribute() [1/2]

template<>

void ParallelIoHdf5::b_createAttribute	(	const MString *	value,
		const MString &	name,
		const MString &	datasetName,
		hid_t	dtype_id,
		const size_type	totalCount
	)

Author

Konstantin Froehlich, Felix Wietbuescher

Date

2015-07-01

Parameters

[in]	value	Attribute value.
[in]	name	Attribute name.
[in]	datasetName	Dataset (scalar or array) to which the attribute is attached (leave empty for file attributes).

Definition at line 1533 of file parallelio_hdf5.cpp.

                                                                                   {
  TRACE();
 
  // Allocate dataspace for a scalar
  if(totalCount > 1) {
    mTerm(1, AT_, "Array of strings attributes not yet supported.");
  }
 
  hid_t link_id = H5Pcreate(H5P_LINK_ACCESS);
  b_error(link_id, name, AT_);
 
  hsize_t dims = 1;
  hid_t dspace_id = H5Screate_simple(1, &dims, nullptr);
  dtype_id = H5Tcopy(H5T_C_S1);
  MInt length = strlen(value->c_str());
  H5Tset_size(dtype_id, length + 1);
  b_error(dspace_id, name, AT_);
 
  hid_t attribute_id = -1;
  herr_t status = -1;
 
  hid_t loc_id = 0;
  if(!datasetName.empty()) {
    // Create the group if not existent
    status = H5Lexists(b_h5Id, datasetName.c_str(), link_id);
    if(status == 0) {
      hid_t group_id = H5Gcreate(b_h5Id, datasetName.c_str(), H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
      b_error(group_id, datasetName, AT_);
      H5Gclose(group_id);
    }
    // Open path
    loc_id = H5Oopen(b_h5Id, datasetName.c_str(), H5P_DEFAULT);
    b_error(loc_id, datasetName, AT_);
  } else {
    loc_id = b_h5Id;
  }
 
  // If the attribute already exists, delete it.
  if(b_hasAttribute(name, datasetName)) {
    if(datasetName.empty()) { // The attribute is attached to the file
      status = H5Adelete(loc_id, name.c_str());
      b_error(status, name, AT_);
    } else { // The attribute is attached to a group
      status = H5Adelete_by_name(loc_id, datasetName.c_str(), name.c_str(), H5P_DEFAULT);
      b_error(status, datasetName, AT_);
    }
  }
  // Create a new attribute
  attribute_id = H5Acreate(loc_id, name.c_str(), dtype_id, dspace_id, H5P_DEFAULT, H5P_DEFAULT);
  b_error(attribute_id, name, AT_);
 
  // Write out the attribute
  status = H5Awrite(attribute_id, dtype_id, value->c_str());
  b_error(status, name, AT_);
 
  // Close all identifiers which have been created (except b_h5Id)
  status = H5Aclose(attribute_id);
  b_error(status, name, AT_);
  status = H5Sclose(dspace_id);
  b_error(status, name, AT_);
  status = H5Tclose(dtype_id);
  b_error(status, name, AT_);
  if(!datasetName.empty()) {
    status = H5Oclose(loc_id);
    b_error(status, name, AT_);
  }
}

b_createAttribute() [2/2]

template<class T >

void ParallelIoHdf5::b_createAttribute ( const T *  value, const MString &  name, const MString &  datasetName, hid_t  dtype_id, const size_type  totalCount  )

private

Author

Konstantin Froehlich

Date

2015-07-01

Parameters

[in]	value	Attribute value.
[in]	name	Attribute name.
[in]	datasetName	Dataset (scalar or array) to which the attribute is attached (leave empty for file attributes).

Definition at line 1461 of file parallelio_hdf5.cpp.

                                                                   {
  TRACE();
 
  hid_t link_id = H5Pcreate(H5P_LINK_ACCESS);
  b_error(link_id, name, AT_);
  // Allocate dataspace for a scalar
  const auto tmpCnt = (hsize_t)totalCount;
  hid_t dspace_id = (totalCount > 1) ? H5Screate_simple(1, &tmpCnt, nullptr) : H5Screate(H5S_SCALAR);
  b_error(dspace_id, name, AT_);
 
  hid_t attribute_id = -1;
  herr_t status = -1;
 
  hid_t loc_id = 0;
  if(!datasetName.empty()) {
    // Create the group if not existent
    status = H5Lexists(b_h5Id, datasetName.c_str(), link_id);
    if(status == 0) {
      hid_t group_id = H5Gcreate(b_h5Id, datasetName.c_str(), H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
      b_error(group_id, datasetName, AT_);
      H5Gclose(group_id);
    }
    // Open path
    loc_id = H5Oopen(b_h5Id, datasetName.c_str(), H5P_DEFAULT);
    b_error(loc_id, datasetName, AT_);
  } else {
    loc_id = b_h5Id;
  }
 
  // If the attribute already exists, delete it.
  if(b_hasAttribute(name, datasetName)) {
    if(datasetName.empty()) { // The attribute is attached to the file
      status = H5Adelete(loc_id, name.c_str());
      b_error(status, name, AT_);
    } else { // The attribute is attached to a group
      status = H5Adelete_by_name(loc_id, datasetName.c_str(), name.c_str(), H5P_DEFAULT);
      b_error(status, datasetName, AT_);
    }
  }
  // Create a new attribute
  attribute_id = H5Acreate(loc_id, name.c_str(), dtype_id, dspace_id, H5P_DEFAULT, H5P_DEFAULT);
  b_error(attribute_id, name, AT_);
 
  // Write out the attribute
  status = H5Awrite(attribute_id, dtype_id, value);
  b_error(status, name, AT_);
 
  // Close all identifiers which have been created (except b_h5Id)
  status = H5Aclose(attribute_id);
  b_error(status, name, AT_);
  status = H5Sclose(dspace_id);
  b_error(status, name, AT_);
  if(!datasetName.empty()) {
    status = H5Oclose(loc_id);
    b_error(status, name, AT_);
  }
}

b_createGroup()

void ParallelIoHdf5::b_createGroup ( const MString &  path )

private

Author

Rodrigo Barros Miguez (rodrigo) rodri.nosp@m.go.m.nosp@m.iguez.nosp@m.@rwt.nosp@m.h-aac.nosp@m.hen..nosp@m.de (HIWI), Marian Albers (marian) maria.nosp@m.n.al.nosp@m.bers@.nosp@m.aia..nosp@m.rwth-.nosp@m.aach.nosp@m.en.de

Date

2021-09-18

Parameters

[in]

path

of group

Definition at line 2407 of file parallelio_hdf5.cpp.

                                                      {
  TRACE();
 
  hid_t link_id = H5Pcreate(H5P_LINK_ACCESS);
  b_error(link_id, path, AT_);
 
  // Get path tokens
  std::vector<MString> p;
  tokenize(path, p, "/", false);
 
  MString parentpath = "/";
  MString objectpath = "/";
  // Get the count number of groups, datasets etc in the path
  MInt num = distance(p.begin(), p.end()) - 1;
 
  for(MInt i = 0; i < num; ++i) {
    if(p[i] == "") {
      continue;
    }
 
    if(i != 0) {
      objectpath.append("/");
      parentpath.append(p[i - 1]);
      parentpath.append("/");
    }
    objectpath.append(p[i]);
    herr_t status = H5Lexists(b_h5Id, objectpath.c_str(), link_id);
    b_error(status, path, AT_);
 
    if(status == 0) { // Path does not exist
      if(i == 0) {
        hid_t group_id = H5Gcreate(b_h5Id, p[i].c_str(), H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
        b_error(group_id, path, AT_);
        status = H5Gclose(group_id);
        b_error(status, path, AT_);
      } else { // We are in another group
        hid_t group_id = H5Gopen(b_h5Id, parentpath.c_str(), H5P_DEFAULT);
        b_error(group_id, path, AT_);
        hid_t new_group_id = H5Gcreate(group_id, p[i].c_str(), H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
        b_error(new_group_id, path, AT_);
 
        // Close current groups
        status = H5Gclose(new_group_id);
        b_error(status, path, AT_);
        status = H5Gclose(group_id);
        b_error(status, path, AT_);
      }
    }
  }
 
  herr_t status = H5Pclose(link_id);
  b_error(status, path, AT_);
}

b_defineArray() [1/2]

void ParallelIoHdf5::b_defineArray ( maiabd_type  type, const MString &  name, size_type  noDims, size_type *  totalCount  )

private

Author

Ramandeep Jain (HiWi) raman.nosp@m.deep.nosp@m.jain@.nosp@m.gmai.nosp@m.l.com, Konstantin Froehlich

Date

2015-Mar

Parameters

[in]	type	Data type of the array (may be either maia::parallel_io::PIO_FLOAT or maia::parallel_io::PIO_INT or maia::parallel_io::PIO_STRING maia::parallel_io::PIO_UCHAR).
[in]	name	Name of the array (must not be empty).
[in]	noDims	Number of array dimensions
[in]	totalCount	Total size of the array in each dimension.

Definition at line 426 of file parallelio_hdf5.cpp.

                                                                                                                 {
  TRACE();
 
  // Choose the HDF5 specific native datatype or a string of variable length
  herr_t status = -1;
  hid_t dtype_id;
  switch(type) {
    case PIO_FLOAT: {
      dtype_id = H5T_NATIVE_DOUBLE;
      break;
    }
    case PIO_INT: {
      dtype_id = H5T_NATIVE_INT;
      break;
    }
    case PIO_LONG: {
      dtype_id = H5T_NATIVE_LONG;
      break;
    }
    case PIO_STRING: {
      dtype_id = H5Tcopy(H5T_C_S1);
      b_error(dtype_id, name, AT_);
      status = H5Tset_size(dtype_id, H5T_VARIABLE);
      b_error(dtype_id, name, AT_);
      break;
    }
    case PIO_UCHAR: {
      dtype_id = H5T_NATIVE_UCHAR;
      break;
    }
    case PIO_ULONGLONG: {
      dtype_id = H5T_NATIVE_ULLONG;
      break;
    }
 
    default: {
      TERMM(1, "Invalid ParallelIo data type!");
    }
  }
 
  // Allocate Dataspace as big as specified by totalCount and noDims
  hid_t dspace_id = H5Screate_simple(noDims, (hsize_t*)(totalCount), nullptr);
  b_error(dspace_id, name, AT_);
  hid_t dset_id = H5Dcreate2(b_h5Id, name.c_str(), dtype_id, dspace_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
  b_error(dset_id, name, AT_);
 
  // Close all identifiers which have been created (except b_h5Id)
  status = H5Dclose(dset_id);
  b_error(status, name, AT_);
  status = H5Sclose(dspace_id);
  b_error(status, name, AT_);
  if(type == PIO_STRING) {
    status = H5Tclose(dtype_id);
    b_error(status, name, AT_);
  }
}

b_defineArray() [2/2]

void ParallelIoHdf5::b_defineArray ( maiabd_type  , const MString &  , const MString &  , const  size_type, const size_type *    )

private

b_defineScalar()

void ParallelIoHdf5::b_defineScalar ( maiabd_type  type, const MString &  name  )

private

Author

Michael Schlottke (mic) mic@a.nosp@m.ia.r.nosp@m.wth-a.nosp@m.ache.nosp@m.n.de, Konstantin Froehlich

Date

2013-04-09

Parameters

[in]	type	Data type of the scalar (may be either maia::parallel_io::PIO_FLOAT or maia::parallel_io::PIO_INT).
[in]	name	Name of the scalar (must not be empty).

Definition at line 494 of file parallelio_hdf5.cpp.

                                                                         {
  TRACE();
 
  // Choose the HDF5 specific native datatype or a string of variable length
  herr_t status = -1;
  hid_t dtype_id;
  switch(type) {
    case PIO_FLOAT: {
      dtype_id = H5T_NATIVE_DOUBLE;
      break;
    }
    case PIO_INT: {
      dtype_id = H5T_NATIVE_INT;
      break;
    }
    case PIO_LONG: {
      dtype_id = H5T_NATIVE_LONG;
      break;
    }
    case PIO_STRING: {
      dtype_id = H5Tcopy(H5T_C_S1);
      b_error(dtype_id, name, AT_);
      status = H5Tset_size(dtype_id, H5T_VARIABLE);
      b_error(dtype_id, name, AT_);
      break;
    }
    case PIO_UCHAR: {
      dtype_id = H5T_NATIVE_UCHAR;
      break;
    }
    case PIO_ULONGLONG: {
      dtype_id = H5T_NATIVE_ULLONG;
      break;
    }
    default: {
      TERMM(1, "Invalid ParallelIo data type!");
    }
  }
 
  // Create a dataspace and dataset for a scalar
  hid_t dspace_id = H5Screate(H5S_SCALAR);
  b_error(dspace_id, name, AT_);
  hid_t dset_id = H5Dcreate2(b_h5Id, name.c_str(), dtype_id, dspace_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
  b_error(dset_id, name, AT_);
 
  // Close all identifiers which have been created (except b_h5Id)
  status = H5Dclose(dset_id);
  b_error(status, name, AT_);
  status = H5Sclose(dspace_id);
  b_error(status, name, AT_);
  if(type == PIO_STRING) {
    status = H5Tclose(dtype_id);
    b_error(status, name, AT_);
  }
}

b_error()

void ParallelIoHdf5::b_error ( MInt  status, const MString &  name, const MString &  location  )

staticprivate

Author

Ramandeep Jain (HiWi) raman.nosp@m.deep.nosp@m.jain@.nosp@m.gmai.nosp@m.l.com, Konstantin Froehlich

Date

2015-Mar

Parameters

[in]	status	HDF5 status code (negative if unexspected behaviour)
[in]	name	Name of the file / variable / attribute
[in]	location	Function which called the error message

Returns

The status message if there was an error, or zero if everything is ok.

Definition at line 1671 of file parallelio_hdf5.cpp.

                                                                                      {
  TRACE();
  if(status < 0) {
    cerr << endl;
    cerr << "*** ERROR in parallelio_hdf5 ***" << endl;
    cerr << "HDF5 error in function " << location << endl;
    cerr << "HDF5 returns status " << status << endl;
    cerr << "The file/variable/attribute in question was: " << name << endl;
    cerr << endl;
    TERMM(1, "HDF5 error in ParallelIoHdf5.");
  }
}

b_fileExt()

const MString ParallelIoHdf5::b_fileExt ( )

staticprivate

Author

Konstantin Froehlich

Date

2015-10-21

Definition at line 161 of file parallelio_hdf5.cpp.

                                        {
  TRACE();
 
  return ".Hdf5";
}

b_getAttribute() [1/2]

template<>

void ParallelIoHdf5::b_getAttribute	(	MString *	value,
		const MString &	name,
		const MString &	datasetName,
		const size_type	totalCount
	)

Author

Ramandeep Jain (HiWi) raman.nosp@m.deep.nosp@m.jain@.nosp@m.gmai.nosp@m.l.com, Konstantin Froehlich

Date

2015-Mar

Parameters

[out]	value	Attribute value
[in]	name	Attribute name
[in]	datasetName	Dataset (scalar or array) to which the attribute is attached (leave empty for file attributes).

Definition at line 855 of file parallelio_hdf5.cpp.

                                                                {
  TRACE();
 
  if(totalCount > 1) {
    mTerm(1, AT_, "String array attributes not supported.");
  }
 
  // Open the attribute
  hid_t attribute_id;
  if(datasetName == "") { // Attribute is attached to the file
    attribute_id = H5Aopen(b_h5Id, name.c_str(), H5P_DEFAULT);
    b_error(attribute_id, name, AT_);
  } else { // Attribute is attached to a dataset
    attribute_id = H5Aopen_by_name(b_h5Id, datasetName.c_str(), name.c_str(), H5P_DEFAULT, H5P_DEFAULT);
    b_error(attribute_id, name, AT_);
  }
  hid_t attribute_type_id = H5Aget_type(attribute_id);
  b_error(attribute_type_id, name, AT_);
  hsize_t length = H5Tget_size(attribute_type_id);
 
  hid_t filetype = H5Tcopy(H5T_C_S1);
  H5Tset_size(filetype, length);
  ScratchSpace<char> buf(length, FUN_, "buf");
 
  herr_t status = H5Aread(attribute_id, filetype, &buf[0]);
  b_error(status, name, AT_);
 
  // Extract strings from buffer
  value[0].append(&buf[0], length);
 
  // Close all identifiers which have been created (except b_h5Id)
  status = H5Tclose(attribute_type_id);
  b_error(status, name, AT_);
  status = H5Aclose(attribute_id);
  b_error(status, name, AT_);
}

b_getAttribute() [2/2]

template<class T >

void ParallelIoHdf5::b_getAttribute ( T *  value, const MString &  name, const MString &  datasetName = "", const size_type  totalCount = 1  )

private

Author

Ramandeep Jain (HiWi) raman.nosp@m.deep.nosp@m.jain@.nosp@m.gmai.nosp@m.l.com, Konstantin Froehlich

Date

2015-Mar

Parameters

[out]	value	Attribute value
[in]	name	Attribute name
[in]	datasetName	Dataset (scalar or array) to which the attribute is attached (leave empty for file attributes).

Definition at line 905 of file parallelio_hdf5.cpp.

                                                                {
  TRACE();
 
  // Open the attribute
  hid_t attribute_id;
  if(datasetName == "") { // Attribute is attached to the file
    attribute_id = H5Aopen(b_h5Id, name.c_str(), H5P_DEFAULT);
    b_error(attribute_id, name, AT_);
  } else { // Attribute is attached to a dataset
    attribute_id = H5Aopen_by_name(b_h5Id, datasetName.c_str(), name.c_str(), H5P_DEFAULT, H5P_DEFAULT);
    b_error(attribute_id, name, AT_);
  }
 
  hid_t attribute_type_id = H5Aget_type(attribute_id);
  b_error(attribute_type_id, name, AT_);
 
  hsize_t length = H5Aget_storage_size(attribute_id) / H5Tget_size(attribute_type_id);
  if(length != (hsize_t)totalCount) {
    TERMM(1, "Requested attribute (" + name
                 + ") has different number of elements than given. Use getAttributeCount() to "
                   "query number of elements first");
  }
 
  herr_t status = H5Aread(attribute_id, attribute_type_id, value);
  b_error(status, name, AT_);
 
  // Close all identifiers which have been created (except b_h5Id)
  status = H5Tclose(attribute_type_id);
  b_error(status, name, AT_);
  status = H5Aclose(attribute_id);
  b_error(status, name, AT_);
}

b_getAttributeCount()

void ParallelIoHdf5::b_getAttributeCount ( const MString &  name, size_type *  totalCount, const MString &  datasetName = ""  )

private

Definition at line 1012 of file parallelio_hdf5.cpp.

                                                                                                               {
  TRACE();
 
  // Open the attribute
  hid_t attribute_id;
  if(datasetName.empty()) { // Attribute is attached to the file
    attribute_id = H5Aopen(b_h5Id, name.c_str(), H5P_DEFAULT);
    b_error(attribute_id, name, AT_);
  } else { // Attribute is attached to a dataset
    attribute_id = H5Aopen_by_name(b_h5Id, datasetName.c_str(), name.c_str(), H5P_DEFAULT, H5P_DEFAULT);
    b_error(attribute_id, name, AT_);
  }
 
  hid_t attribute_type_id = H5Aget_type(attribute_id);
  b_error(attribute_type_id, name, AT_);
 
  hsize_t length = H5Aget_storage_size(attribute_id) / H5Tget_size(attribute_type_id);
 
  *totalCount = (size_type)length;
 
  // Close all identifiers which have been created (except b_h5Id)
  herr_t status = H5Tclose(attribute_type_id);
  b_error(status, name, AT_);
  status = H5Aclose(attribute_id);
  b_error(status, name, AT_);
}

b_getAttributeType()

MInt ParallelIoHdf5::b_getAttributeType ( const MString &  name, const MString &  datasetName = ""  )

private

Author

Michael Schlottke (mic) mic@a.nosp@m.ia.r.nosp@m.wth-a.nosp@m.ache.nosp@m.n.de, Konstantin Froehlich

Date

2013-04-01

Parameters

[in]	name	Name of the attribute to be checked.
[in]	datasetName	Name of the dataset for which the attribute is checked. If empty, a file attribute is checked.

Returns

The data type as defined in the namespace maia::parallel_io.

Definition at line 1052 of file parallelio_hdf5.cpp.

                                                                                       {
  TRACE();
 
  // TERMM(1, "untested Hdf5 specific I/O method, please see comment for how"
  //         " to proceed");
  // WARNING: This method is untested, yet. It is implemented due to be
  // consistent with parallel NetCDF. However, it was not used by any of the
  // testcases.If your code uses this part of the code, please make sure that
  // the I/O still works as expected and then remove this warning as well as
  // the subsequent TERMM().
  // Determine variable id
  hid_t varId;
  if(datasetName.empty()) { // File attribute
    varId = b_h5Id;
  } else { // Dataset attribute
    varId = H5Dopen2(b_h5Id, datasetName.c_str(), H5P_DEFAULT);
    b_error(varId, name, AT_);
  }
 
  // Get attribute type
  hid_t attribute_id = H5Aopen(varId, name.c_str(), H5P_DEFAULT);
  b_error(attribute_id, name, AT_);
  hid_t attrType_id = H5Aget_type(attribute_id);
  b_error(attrType_id, name, AT_);
 
  // Translate native HDF5 data type to ParallelIo type
  MInt typeId;
  if(H5Tequal(attrType_id, H5T_NATIVE_INT) > 0) {
    typeId = PIO_INT;
  } else if(H5Tequal(attrType_id, H5T_NATIVE_DOUBLE) > 0) {
    typeId = PIO_FLOAT;
  } else if(H5Tequal(attrType_id, H5T_NATIVE_LONG) > 0) {
    typeId = PIO_LONG;
  } else if(H5Tequal(attrType_id, H5T_C_S1) > 0) {
    typeId = PIO_STRING;
  } else if(H5Tequal(attrType_id, H5T_NATIVE_UCHAR) > 0) {
    typeId = PIO_UCHAR;
  } else if(H5Tequal(attrType_id, H5T_NATIVE_ULLONG) > 0) {
    typeId = PIO_ULONGLONG;
  } else {
    typeId = PIO_UNKNOWN_TYPE;
  }
 
  // Close all previously created identifiers (except b_h5Id)
  herr_t status;
  if(varId != b_h5Id) {
    status = H5Dclose(varId);
    b_error(status, name, AT_);
  }
  status = H5Aclose(attribute_id);
  b_error(status, name, AT_);
  status = H5Tclose(attrType_id);
  b_error(status, name, AT_);
 
  return typeId;
}

b_getDatasetNames() [1/2]

void ParallelIoHdf5::b_getDatasetNames ( std::vector< MString > &  names, const MString &  path  )

private

Author

Rodrigo Barros Miguez (rodrigo) rodri.nosp@m.go.m.nosp@m.iguez.nosp@m.@rwt.nosp@m.h-aac.nosp@m.hen..nosp@m.de (HIWI), Marian Albers (marian) maria.nosp@m.n.al.nosp@m.bers@.nosp@m.aia..nosp@m.rwth-.nosp@m.aach.nosp@m.en.de

Date

2021-09-18

Parameters

[out]	name	of datasets in given group
[in]	path	of group

Definition at line 2559 of file parallelio_hdf5.cpp.

                                                                                  {
  TRACE();
  if(b_getNoDatasets(path) <= 0) {
    return;
  }
 
  MString pathStr = "/";
  if(!path.empty()) {
    pathStr = path;
  }
 
  hid_t group_id = H5Gopen(b_h5Id, pathStr.c_str(), H5P_DEFAULT);
  b_error(group_id, m_fileName, AT_);
 
  // Iterate through each object in the group.
  hsize_t noObj = 0;
  herr_t status = H5Gget_num_objs(group_id, &noObj);
  for(MInt idx = 0; idx < (signed)noObj; idx++) {
    int obj_type = H5Gget_objtype_by_idx(group_id, (size_t)idx);
    b_error(obj_type, m_fileName, AT_);
    if(obj_type == H5G_DATASET) {
      char DatasetName[NC_MAX_NAME];
      status = H5Gget_objname_by_idx(group_id, (hsize_t)idx, DatasetName, NC_MAX_NAME);
      b_error(status, m_fileName, AT_);
      names.emplace_back(DatasetName);
    }
  }
 
  status = H5Gclose(group_id);
  b_error(status, m_fileName, AT_);
}

b_getDatasetNames() [2/2]

void ParallelIoHdf5::b_getDatasetNames ( std::vector< MString > &  names, const size_type  dimension  )

private

Author

Michael Schlottke (mic) mic@a.nosp@m.ia.r.nosp@m.wth-a.nosp@m.ache.nosp@m.n.de, Konstantin Froehlich

Date

2013-04-09

Parameters

[in]	dimension	Match only datasets with given number of dimensions, default -1 which will return all datasets, 0 will only return scalars, 1 arrays with one dimension, ...
[out]	names	List of dataset names.

Definition at line 716 of file parallelio_hdf5.cpp.

                                                                                        {
  TRACE();
 
  vector<MString>().swap(names);
 
  herr_t status = -1;
 
  // Get access to the root group "/" (currently group functionality of HDF5 is
  // completely ignored, thus it is the only existent group).
  hid_t group_id = H5Gopen(b_h5Id, "/", H5P_DEFAULT);
  b_error(group_id, m_fileName, AT_);
  // Iterate through each object in the group.
  hsize_t noObj = 0;
  status = H5Gget_num_objs(group_id, &noObj);
  b_error(status, m_fileName, AT_);
  for(MInt idx = 0; idx < (signed)noObj; idx++) {
    // Check if the current object is a dataset
    int obj_type = H5Gget_objtype_by_idx(group_id, (size_t)idx);
    b_error(obj_type, m_fileName, AT_);
    if(obj_type == H5G_DATASET) {
      // Determine the name and the dimension of the dataset
      // The maximal name length is NC_MAX_NAME for consistency with PnetCDF
      char DatasetName[NC_MAX_NAME];
      status = H5Gget_objname_by_idx(group_id, (hsize_t)idx, DatasetName, NC_MAX_NAME);
      b_error(status, m_fileName, AT_);
      hid_t dset_id = H5Dopen(b_h5Id, DatasetName, H5P_DEFAULT);
      b_error(dset_id, m_fileName + " :: " + string(DatasetName), AT_);
      hid_t dspace_id = H5Dget_space(dset_id);
      b_error(dspace_id, m_fileName + " :: " + string(DatasetName), AT_);
      int noDims = H5Sget_simple_extent_ndims(dspace_id);
      b_error(noDims, m_fileName + " :: " + string(DatasetName), AT_);
      if(noDims == dimension || dimension == -1) {
        names.emplace_back(DatasetName);
      }
      // Close all previously created identifiers (except b_h5Id)
      status = H5Sclose(dspace_id);
      b_error(dspace_id, m_fileName + " :: " + string(DatasetName), AT_);
      status = H5Dclose(dset_id);
      b_error(dspace_id, m_fileName + " :: " + string(DatasetName), AT_);
    }
  }
  status = H5Gclose(group_id);
  b_error(status, m_fileName, AT_);
}

b_getDatasetNoDims() [1/2]

ParallelIo::size_type ParallelIoHdf5::b_getDatasetNoDims ( const MString &  name )

private

Author

Konstantin Froehlich

Date

2015-10-09

Parameters

[in]

name

Dataset name for which the number of dimensions is returned

The number of dimensions of a dataset is returned, 0 is a scalar, 1 an array with one dimension, ...

Returns

Number of dimensions of the specified dataset

Definition at line 775 of file parallelio_hdf5.cpp.

                                                                          {
  TRACE();
 
  // Get variable id
  hid_t dset_id = H5Dopen2(b_h5Id, name.c_str(), H5P_DEFAULT);
  b_error(dset_id, name, AT_);
 
  // Get number of variable dimensions
  hid_t dspace_id = H5Dget_space(dset_id);
  b_error(dspace_id, name, AT_);
  int noDims = H5Sget_simple_extent_ndims(dspace_id);
  b_error(noDims, name, AT_);
 
  // Close all previously created identifiers (except b_h5Id)
  herr_t status = H5Sclose(dspace_id);
  b_error(status, name, AT_);
  status = H5Dclose(dset_id);
  b_error(status, name, AT_);
 
  return noDims;
}

b_getDatasetNoDims() [2/2]

ParallelIo::size_type ParallelIoHdf5::b_getDatasetNoDims ( const MString &  name, const MString &  path  )

private

Author

Rodrigo Barros Miguez (rodrigo) rodri.nosp@m.go.m.nosp@m.iguez.nosp@m.@rwt.nosp@m.h-aac.nosp@m.hen..nosp@m.de (HIWI), Marian Albers (marian) maria.nosp@m.n.al.nosp@m.bers@.nosp@m.aia..nosp@m.rwth-.nosp@m.aach.nosp@m.en.de

Date

2021-09-18

Parameters

[out]	number	of space dimensions of dataset
[in]	name	of dataset
[in]	preceding	path of dataset

Definition at line 2352 of file parallelio_hdf5.cpp.

                                                                                               {
  TRACE();
 
  hid_t link_id = H5Pcreate(H5P_LINK_ACCESS);
  b_error(link_id, name, AT_);
  // Handle whether or not path was given
  hid_t loc_id = 0;
  MBool checkLoc_id = false;
  if(path.empty()) {
    loc_id = b_h5Id;
  } else {
    loc_id = H5Oopen(b_h5Id, path.c_str(), H5P_DEFAULT);
    b_error(loc_id, path, AT_);
    checkLoc_id = true;
  }
 
  hid_t data_id = H5Oopen(loc_id, name.c_str(), H5P_DEFAULT);
  b_error(data_id, name, AT_);
 
  // 1) Get space information
  hid_t dspace_id = H5Dget_space(data_id);
  b_error(dspace_id, name, AT_);
 
  size_type noDims = H5Sget_simple_extent_ndims(dspace_id);
  b_error(noDims, name, AT_);
 
  herr_t status = H5Sclose(dspace_id);
  b_error(status, name, AT_);
 
  status = H5Oclose(data_id);
  b_error(status, name, AT_);
 
  status = H5Pclose(link_id);
  b_error(status, name, AT_);
 
  if(checkLoc_id) {
    status = H5Oclose(loc_id);
    b_error(status, name, AT_);
  }
 
  return noDims;
}

b_getDatasetSize() [1/2]

void ParallelIoHdf5::b_getDatasetSize ( const MString &  name, const MString &  path, size_type  noDims, size_type *  data  )

private

Author

Rodrigo Barros Miguez (rodrigo) rodri.nosp@m.go.m.nosp@m.iguez.nosp@m.@rwt.nosp@m.h-aac.nosp@m.hen..nosp@m.de (HIWI), Marian Albers (marian) maria.nosp@m.n.al.nosp@m.bers@.nosp@m.aia..nosp@m.rwth-.nosp@m.aach.nosp@m.en.de

Date

2021-09-18

Parameters

[in]	name	of dataset
[in]	preceding	path of dataset
[in]	number	of dimensions
[out]	number	of cells in different space directions

Definition at line 2300 of file parallelio_hdf5.cpp.

                                                                                                                 {
  TRACE();
 
  hid_t link_id = H5Pcreate(H5P_LINK_ACCESS);
  b_error(link_id, name, AT_);
  // Handle whether or not path was given
  hid_t loc_id = 0;
  MInt checkLoc_id = 0;
  if(path.empty()) {
    loc_id = b_h5Id;
  } else {
    loc_id = H5Oopen(b_h5Id, path.c_str(), H5P_DEFAULT);
    b_error(loc_id, path, AT_);
    checkLoc_id = 1;
  }
 
  // Check if object exists
  herr_t status = H5Lexists(loc_id, name.c_str(), link_id);
  if(status == 0) { // Object does not exsit
    m_log << "WARNING: Datatset " << name << " does not exist at path " << path << std::endl;
  } else {
    hid_t data_id = H5Oopen(loc_id, name.c_str(), H5P_DEFAULT);
    // 1) Get space information
    hid_t filespace = H5Dget_space(data_id);
    ScratchSpace<hsize_t> count(noDims, FUN_, "count");
    ScratchSpace<hsize_t> maxcount(noDims, FUN_, "maxcount");
    H5Sget_simple_extent_dims(filespace, &count[0], &maxcount[0]);
    // 2) Get the size
    for(size_type i = 0; i < noDims; i++) {
      data[i] = count[i];
    }
    H5Sclose(filespace);
    H5Oclose(data_id);
  }
  H5Pclose(link_id);
  if(checkLoc_id) H5Oclose(loc_id);
}

b_getDatasetSize() [2/2]

ParallelIo::size_type ParallelIoHdf5::b_getDatasetSize ( const MString &  name, const size_type  dimensionId = 0  )

private

Author

Michael Schlottke (mic) mic@a.nosp@m.ia.r.nosp@m.wth-a.nosp@m.ache.nosp@m.n.de, Konstantin Froehlich

Date

2013-04-01

Parameters

[in]	name	Name of the array to check.
[in]	dimensionId	dimension of the array to check.

Returns

Total number of elements of the array in the given dimension.

Definition at line 809 of file parallelio_hdf5.cpp.

                                                                                                     {
  TRACE();
 
  // Get variable id
  hid_t dset_id = H5Dopen2(b_h5Id, name.c_str(), H5P_DEFAULT);
  b_error(dset_id, name, AT_);
 
  // Get number of array dimensions
  size_type noDims = b_getDatasetNoDims(name);
 
  // Get variable size for each dimension
  hid_t dspace_id = H5Dget_space(dset_id);
  b_error(dspace_id, name, AT_);
 
  ScratchSpace<hsize_t> dimId(noDims, FUN_, "dimId");
 
  herr_t status = H5Sget_simple_extent_dims(dspace_id, &dimId[0], nullptr);
  b_error(status, name, AT_);
  hid_t dtype_id = H5Dget_type(dset_id);
  b_error(dtype_id, name, AT_);
 
  // Close all previously created identifiers (except b_h5Id)
  status = H5Sclose(dspace_id);
  b_error(status, name, AT_);
  status = H5Dclose(dset_id);
  b_error(status, name, AT_);
 
  return static_cast<size_type>(dimId[dimensionId]);
}

b_getDatasetType()

MInt ParallelIoHdf5::b_getDatasetType ( const MString &  name )

private

Author

Michael Schlottke (mic) mic@a.nosp@m.ia.r.nosp@m.wth-a.nosp@m.ache.nosp@m.n.de, Konstantin Froehlich

Date

2013-04-01

Parameters

[in]

name

Name of the dataset to check.

Returns

The data type as defined in the namespace maia::parallel_io.

Definition at line 666 of file parallelio_hdf5.cpp.

                                                         {
  TRACE();
 
  // Determine variable id
  hid_t dset_id = H5Dopen2(b_h5Id, name.c_str(), H5P_DEFAULT);
  b_error(dset_id, name, AT_);
  hid_t dtype_id = H5Dget_type(dset_id);
  b_error(dtype_id, name, AT_);
 
  MInt typeId;
  if(H5Tequal(dtype_id, H5T_NATIVE_INT) > 0) {
    typeId = PIO_INT;
  } else if(H5Tequal(dtype_id, H5T_NATIVE_DOUBLE) > 0) {
    typeId = PIO_FLOAT;
  } else if(H5Tequal(dtype_id, H5T_NATIVE_LONG) > 0) {
    typeId = PIO_LONG;
  } else if(H5Tget_class(dtype_id) == H5T_STRING || H5Tequal(dtype_id, H5T_C_S1) > 0) {
    typeId = PIO_STRING;
  } else if(H5Tequal(dtype_id, H5T_NATIVE_UCHAR) > 0) {
    typeId = PIO_UCHAR;
  } else if(H5Tequal(dtype_id, H5T_NATIVE_ULLONG) > 0) {
    typeId = PIO_ULONGLONG;
  } else {
    typeId = PIO_UNKNOWN_TYPE;
    TERMM(1, "ERROR: Unknown type for dataset " + name + "!");
  }
 
  // Close all previously created identifiers (except b_h5Id)
  herr_t status = H5Tclose(dtype_id);
  b_error(status, name, AT_);
  status = H5Dclose(dset_id);
  b_error(status, name, AT_);
 
  return typeId;
}

b_getGroupNames()

void ParallelIoHdf5::b_getGroupNames ( std::vector< MString > &  names, const MString &  path  )

private

Author

Rodrigo Barros Miguez (rodrigo) rodri.nosp@m.go.m.nosp@m.iguez.nosp@m.@rwt.nosp@m.h-aac.nosp@m.hen..nosp@m.de (HIWI), Marian Albers (marian) maria.nosp@m.n.al.nosp@m.bers@.nosp@m.aia..nosp@m.rwth-.nosp@m.aach.nosp@m.en.de

Date

2021-09-18

Parameters

[out]	name	of the groups inside the given group
[in]	path	of group

Definition at line 2473 of file parallelio_hdf5.cpp.

                                                                                {
  TRACE();
  if(b_getNoGroups(path) <= 0) {
    return;
  }
 
  MString pathStr = "/";
  if(!path.empty()) {
    pathStr = path;
  }
 
  hid_t group_id = H5Gopen(b_h5Id, pathStr.c_str(), H5P_DEFAULT);
  b_error(group_id, m_fileName, AT_);
 
  // Iterate through each object in the group.
  hsize_t noObj = 0;
  herr_t status = H5Gget_num_objs(group_id, &noObj);
  for(MInt idx = 0; idx < (signed)noObj; idx++) {
    int obj_type = H5Gget_objtype_by_idx(group_id, (size_t)idx);
    b_error(obj_type, m_fileName, AT_);
    if(obj_type == H5G_GROUP) {
      char GroupName[NC_MAX_NAME];
      status = H5Gget_objname_by_idx(group_id, (hsize_t)idx, GroupName, NC_MAX_NAME);
      b_error(status, m_fileName, AT_);
      names.emplace_back(GroupName);
    }
  }
 
  status = H5Gclose(group_id);
  b_error(status, m_fileName, AT_);
}

b_getNoDatasets()

ParallelIo::size_type ParallelIoHdf5::b_getNoDatasets ( const MString &  path )

private

Author

Rodrigo Barros Miguez (rodrigo) rodri.nosp@m.go.m.nosp@m.iguez.nosp@m.@rwt.nosp@m.h-aac.nosp@m.hen..nosp@m.de (HIWI), Marian Albers (marian) maria.nosp@m.n.al.nosp@m.bers@.nosp@m.aia..nosp@m.rwth-.nosp@m.aach.nosp@m.en.de

Date

2021-09-18

Parameters

[out]	number	of datasets in given group
[in]	path	of group

Definition at line 2602 of file parallelio_hdf5.cpp.

                                                                       {
  TRACE();
 
  MString pathStr = "/";
  if(!path.empty()) {
    pathStr = path;
  }
 
  hid_t group_id = H5Gopen(b_h5Id, pathStr.c_str(), H5P_DEFAULT);
  b_error(group_id, m_fileName, AT_);
 
  // Iterate through each object in the group.
  hsize_t noObj = 0;
  ParallelIo::size_type noDatasets = 0;
 
  herr_t status = H5Gget_num_objs(group_id, &noObj);
  b_error(status, m_fileName, AT_);
  for(MInt idx = 0; idx < (signed)noObj; idx++) {
    int obj_type = H5Gget_objtype_by_idx(group_id, (size_t)idx);
    b_error(obj_type, m_fileName, AT_);
    if(obj_type == H5G_DATASET) {
      noDatasets++;
    }
  }
 
  status = H5Gclose(group_id);
  b_error(status, m_fileName, AT_);
 
  return noDatasets;
}

b_getNoGroups()

ParallelIo::size_type ParallelIoHdf5::b_getNoGroups ( const MString &  path )

private

Author

Rodrigo Barros Miguez (rodrigo) rodri.nosp@m.go.m.nosp@m.iguez.nosp@m.@rwt.nosp@m.h-aac.nosp@m.hen..nosp@m.de (HIWI), Marian Albers (marian) maria.nosp@m.n.al.nosp@m.bers@.nosp@m.aia..nosp@m.rwth-.nosp@m.aach.nosp@m.en.de

Date

2021-09-18

Parameters

[out]	number	of groups inside given group
[in]	path	of group

Definition at line 2516 of file parallelio_hdf5.cpp.

                                                                     {
  TRACE();
 
  MString pathStr = "/";
  if(!path.empty()) {
    pathStr = path;
  }
 
  hid_t group_id = H5Gopen(b_h5Id, pathStr.c_str(), H5P_DEFAULT);
  b_error(group_id, m_fileName, AT_);
 
  // Iterate through each object in the group.
  hsize_t noObj = 0;
  ParallelIo::size_type noGroups = 0;
 
  herr_t status = H5Gget_num_objs(group_id, &noObj);
  b_error(status, m_fileName, AT_);
  for(MInt idx = 0; idx < (signed)noObj; idx++) {
    int obj_type = H5Gget_objtype_by_idx(group_id, (size_t)idx);
    b_error(obj_type, m_fileName, AT_);
    if(obj_type == H5G_GROUP) {
      noGroups++;
    }
  }
 
  status = H5Gclose(group_id);
  b_error(status, m_fileName, AT_);
 
  return noGroups;
}

b_hasAttribute()

MBool ParallelIoHdf5::b_hasAttribute ( const MString &  name, const MString &  path = ""  )

private

Author

Rodrigo Barros Miguez (rodrigo) rodri.nosp@m.go.m.nosp@m.iguez.nosp@m.@rwt.nosp@m.h-aac.nosp@m.hen..nosp@m.de (HIWI), Marian Albers (marian) maria.nosp@m.n.al.nosp@m.bers@.nosp@m.aia..nosp@m.rwth-.nosp@m.aach.nosp@m.en.de

Date

2021-09-18

Parameters

[out]	attribute	exists or not
[in]	name	of the attribute
[in]	preceding	path of attribute

Definition at line 953 of file parallelio_hdf5.cpp.

                                                                             {
  TRACE();
 
  hid_t link_id = H5Pcreate(H5P_LINK_ACCESS);
  b_error(link_id, name, AT_);
  // Handle whether or not path was given
  hid_t loc_id = 0;
  MBool checkGroup = false;
  if(path.empty()) {
    loc_id = b_h5Id;
  } else {
    herr_t pathExists = H5Lexists(b_h5Id, path.c_str(), link_id);
    if(pathExists != 0) {
      // Group path exists, opening it
      loc_id = H5Oopen(b_h5Id, path.c_str(), H5P_DEFAULT);
      b_error(loc_id, path, AT_);
    } else {
      // Group path doesn't exist, then object cannot exist
      H5Pclose(link_id);
      return 0;
    }
 
    checkGroup = true;
  }
 
  // Check if object exists
  herr_t status = H5Lexists(loc_id, name.c_str(), link_id);
  if(status == 0) { // Object does not exist, check if attribute exists
    status = H5Aexists(loc_id, name.c_str());
  }
 
  H5Pclose(link_id);
  if(checkGroup) H5Oclose(loc_id);
  return status;
}

b_hasDataset() [1/2]

MBool ParallelIoHdf5::b_hasDataset ( const MString &  name, const MString &  path  )

private

Author

Rodrigo Barros Miguez (rodrigo) rodri.nosp@m.go.m.nosp@m.iguez.nosp@m.@rwt.nosp@m.h-aac.nosp@m.hen..nosp@m.de (HIWI), Marian Albers (marian) maria.nosp@m.n.al.nosp@m.bers@.nosp@m.aia..nosp@m.rwth-.nosp@m.aach.nosp@m.en.de

Date

2021-09-18

Parameters

[out]

param [in]

Definition at line 618 of file parallelio_hdf5.cpp.

                                                                           {
  TRACE();
 
  hid_t link_id = H5Pcreate(H5P_LINK_ACCESS);
  b_error(link_id, name, AT_);
  // Handle whether or not path was given
  MBool exists = false;
  hid_t loc_id = 0;
  MBool checkGroup = false;
  if(path.empty()) {
    loc_id = b_h5Id;
  } else {
    herr_t pathExists = H5Lexists(b_h5Id, path.c_str(), link_id);
    if(pathExists != 0) {
      // Group path exists, opening it
      loc_id = H5Oopen(b_h5Id, path.c_str(), H5P_DEFAULT);
      b_error(loc_id, path, AT_);
    } else {
      // Group path doesn't exist, then object cannot exist
      H5Pclose(link_id);
      return 0;
    }
 
    checkGroup = true;
  }
 
  // Check if object exists
  herr_t status = H5Lexists(loc_id, name.c_str(), link_id);
  if(status != 0) {
    exists = true;
  }
 
  H5Pclose(link_id);
  if(checkGroup) H5Oclose(loc_id);
  return exists;
}

b_hasDataset() [2/2]

MBool ParallelIoHdf5::b_hasDataset ( const MString &  name, const size_type  noDimensions  )

private

Author

Michael Schlottke (mic) mic@a.nosp@m.ia.r.nosp@m.wth-a.nosp@m.ache.nosp@m.n.de, Konstantin Froehlich

Date

2013-04-01

Parameters

[in]	name	The name of the dataset that should be checked.
[in]	noDimensions	Number of dimensions of the dataset to match, default -1 which is any dimensionality, 0 will only check scalars, 1 arrays with one dimension, ...

Returns

True if an dataset of the given name with the given number of dimensions exists.

Definition at line 569 of file parallelio_hdf5.cpp.

                                                                                    {
  TRACE();
 
  MBool varExists = false;
 
  herr_t status = -1;
  hid_t dset_id = -1, dspace_id = -1;
  hid_t link_id = H5Pcreate(H5P_LINK_ACCESS);
  b_error(link_id, name, AT_);
  htri_t linkExists = H5Lexists(b_h5Id, name.c_str(), link_id);
  b_error(linkExists, name, AT_);
  if(linkExists != 0) {
    dset_id = H5Dopen2(b_h5Id, name.c_str(), H5P_DEFAULT);
    b_error(dset_id, name, AT_);
    dspace_id = H5Dget_space(dset_id);
    b_error(dspace_id, name, AT_);
    int nDims = H5Sget_simple_extent_ndims(dspace_id);
    b_error(nDims, name, AT_);
    if(nDims == noDimensions || noDimensions == -1) {
      varExists = true;
    }
  }
 
  // Close all previously created identifiers (except b_h5Id)
  if(dset_id > 0) {
    status = H5Sclose(dspace_id);
    b_error(status, name, AT_);
    status = H5Dclose(dset_id);
    b_error(status, name, AT_);
  }
  status = H5Pclose(link_id);
  b_error(status, name, AT_);
 
  return varExists;
}

b_hasObject()

MBool ParallelIoHdf5::b_hasObject ( const MString &  path )

private

Definition at line 989 of file parallelio_hdf5.cpp.

                                                     {
  TRACE();
 
  hid_t link_id = H5Pcreate(H5P_LINK_ACCESS);
  b_error(link_id, path, AT_);
  // Handle whether or not path was given
  MBool exists = false;
  if(path.empty()) {
    exists = true;
  } else {
    herr_t pathExists = H5Lexists(b_h5Id, path.c_str(), link_id);
    if(pathExists != 0) {
      exists = true;
    } else {
      exists = false;
    }
  }
 
  H5Pclose(link_id);
  return exists;
}

b_isValidFile()

MBool ParallelIoHdf5::b_isValidFile ( const MString &  name, const MPI_Comm &  mpiComm  )

staticprivate

Author

Michael Schlottke (mic) mic@a.nosp@m.ia.r.nosp@m.wth-a.nosp@m.ache.nosp@m.n.de, Konstantin Froehlich

Date

2013-04-01

Parameters

[in]	name	Name of the file that is to be checked.
[in]	Not	used by Hdf5 specific version.

Definition at line 129 of file parallelio_hdf5.cpp.

                                                                          {
  TRACE();
 
  // WARNING: This method is untested, yet. It is implemented due to be
  // consistent with parallel NetCDF. However, it was not used by any of the
  // testcases.If your code uses this part of the code, please make sure that
  // the I/O still works as expected and then remove this warning as well as
  // the subsequent TERMM().
  MBool returnValue;
 
  herr_t status;
  hid_t fileId;
  fileId = H5Fopen(name.c_str(), H5F_ACC_RDONLY, H5P_DEFAULT);
  if(fileId > 0) {
    returnValue = true;
    status = H5Fclose(fileId);
    b_error(status, name, AT_);
  } else {
    returnValue = false;
  }
 
  return returnValue;
}

b_open()

void ParallelIoHdf5::b_open ( )

private

b_readArray() [1/3]

template<>

void ParallelIoHdf5::b_readArray	(	MString *	array,
		const MString &	name,
		const size_type	noDims,
		MPI_Offset *	start,
		MPI_Offset *	count,
		MPI_Offset	memoryStride,
		const size_type	noChunks,
		MPI_Offset	diskStride
	)

Author

Ansgar Niemoeller, Konstantin Froehlich

Date

2015-08-19

Parameters

[in]	array	Pointer to data in memory.
[in]	name	Name of the dataset.
[in]	noDims	Number of array dimensions
[in]	start	Start offset in the file (i.e. the domain should start reading from here).
[in]	count	Number of elements read from this domain.
[in]	memoryStride	Stride in memory between data values.

This method is the exact counterpart to h5WriteArray().

Definition at line 1262 of file parallelio_hdf5.cpp.

                                                        {
  TRACE();
 
  // Get variable id
  hid_t dset_id = H5Dopen(b_h5Id, name.c_str(), H5P_DEFAULT);
  b_error(dset_id, name, AT_);
  hid_t dspace_id = H5Dget_space(dset_id);
  b_error(dspace_id, name, AT_);
  hid_t dtype_id = H5Dget_type(dset_id); // H5Tcopy(H5T_C_S1);
 
 
  int length = (int)H5Tget_size(dtype_id);
 
  if(H5Tget_cset(dtype_id)) {
    dtype_id = H5Tcopy(H5T_C_S1);
    H5Tset_cset(dtype_id, H5T_CSET_UTF8);
  } else {
    dtype_id = H5Tcopy(H5T_C_S1);
  }
 
  b_error(dtype_id, name, AT_);
  // herr_t status = H5Tset_size(dtype_id, 1);
  herr_t status = H5Tset_size(dtype_id, length);
  b_error(status, name, AT_);
 
  // Determine total data count
  size_type totalCount = 1;
  for(size_type d = 0; d < noDims - 1; d++) {
    totalCount *= count[d];
  }
 
  // Determine length of one string
  size_type strLen = length; // count[noDims - 1];
 
  // Create temporary storage space if needed and set data pointers
  MInt tmpScratchSize = (memoryStride == 1 ? 1 : totalCount);
  ScratchSpace<MString> tmpScratch(tmpScratchSize, FUN_, "tmpStorage");
  MString* data = 0;
  if(memoryStride == 1) {
    data = array;
  } else {
    // data = tmpScratch.begin();
    data = &tmpScratch[0];
  }
 
  // Create buffer for reading
  size_type nCount = totalCount * strLen;
  ScratchSpace<char> buf(nCount, FUN_, "buf");
 
  hid_t memory_dspace_id = -1;
  // Read array
  if(noChunks == 1) {
    // If number of chunks is one, write everything at once
 
    count[0] = 1;
 
    memory_dspace_id = H5Screate_simple(noDims, (hsize_t*)count, nullptr);
    b_error(memory_dspace_id, name, AT_);
    //    if ( diskStride == 1 ) {
    status = H5Sselect_hyperslab(dspace_id, H5S_SELECT_SET, (hsize_t*)start, nullptr, (hsize_t*)count, nullptr);
    //    }
    //    else {
    //      status = H5Sselect_hyperslab(dspace_id, H5S_SELECT_SET, (hsize_t*)start, (hsize_t*)diskStride,
    //      (hsize_t*)count, nullptr);
    //    }
    b_error(status, name, AT_);
    status = H5Dread(dset_id, dtype_id, memory_dspace_id, dspace_id, H5P_DEFAULT, &buf[0]);
    b_error(status, name, AT_);
 
    // Extract strings from buffer
    for(size_type i = 0; i < totalCount; i++) {
      MString tmp;
      tmp.append(&buf[i * strLen], strLen);
      data[i].append(tmp.c_str(), 0, strLen);
    }
  } else {
    // Read in chunks
    MPI_Offset chunkSize = count[0] / noChunks;
    if(count[0] % noChunks > 0) {
      chunkSize += 1;
    }
 
    // Determine number of entries for a fixed first dimension index
    size_type nDSize = 1;
    for(size_type d = 1; d < noDims; d++) {
      nDSize *= count[d];
    }
 
    ScratchSpace<hsize_t> start_(noDims, FUN_, "start_");
    ScratchSpace<hsize_t> count_(noDims, FUN_, "count_");
 
    std::copy(start, start + noDims, &start_[0]);
    std::copy(count, count + noDims, &count_[0]);
 
    for(size_type i = 0; i < noChunks; i++) {
      start_[0] = min(start[0] + i * chunkSize * diskStride, count[0] * diskStride - 1);
      count_[0] = max(min(chunkSize, count[0] - i * chunkSize), 0ll);
      memory_dspace_id = H5Screate_simple(noDims, &count_[0], nullptr);
      b_error(memory_dspace_id, name, AT_);
      //      if ( diskStride == 1 ) {
      status = H5Sselect_hyperslab(dspace_id, H5S_SELECT_SET, &start_[0], nullptr, &count_[0], nullptr);
      //      }
      //      else {
      //        status = H5Sselect_hyperslab(dspace_id, H5S_SELECT_SET, &start_[0],
      //                                     (hsize_t*)diskStride, &count_[0], nullptr);
      //      }
      b_error(status, name, AT_);
      status = H5Dread(dset_id, dtype_id, memory_dspace_id, dspace_id, H5P_DEFAULT, &buf[0]);
      b_error(status, name, AT_);
 
      // Extract strings from buffer
      for(size_type j = start_[0]; j < totalCount; j++) {
        MString tmp;
        tmp.append(&buf[(j - start_[0]) * strLen], strLen);
        data[j].append(tmp.c_str(), 0, strLen);
      }
    }
  }
 
  // Unpack strided data if necessary
  if(memoryStride != 1) {
    for(MPI_Offset i = 0; i < totalCount; i++) {
      array[memoryStride * i] = tmpScratch[i];
    }
  }
 
  // Close all identifiers which have been created (except b_h5Id)
  status = H5Sclose(memory_dspace_id);
  b_error(status, name, AT_);
  status = H5Sclose(dspace_id);
  b_error(status, name, AT_);
  status = H5Dclose(dset_id);
  b_error(status, name, AT_);
  status = H5Tclose(dtype_id);
  b_error(status, name, AT_);
}

b_readArray() [2/3]

template<class T >

void ParallelIoHdf5::b_readArray ( T *  array, const MString &  path, const MString &  name, const size_type  noDims, const size_type *  start, const size_type *  count  )

private

Author

Rodrigo Barros Miguez (rodrigo) rodri.nosp@m.go.m.nosp@m.iguez.nosp@m.@rwt.nosp@m.h-aac.nosp@m.hen..nosp@m.de (HIWI), Marian Albers (marian) maria.nosp@m.n.al.nosp@m.bers@.nosp@m.aia..nosp@m.rwth-.nosp@m.aach.nosp@m.en.de

Date

2021-09-09

Parameters

[in]	array	to read
[in]	preceding	path of dataset
[in]	name	of dataset
[in]	number	of dimensions
[in]	offset	in different space directions
[in]	number	of cells in different space directions

Definition at line 2040 of file parallelio_hdf5.cpp.

                                                                                 {
  TRACE();
 
  // Handle whether or not path was given
  hid_t loc_id = 0;
  MInt checkLoc_id = 0;
  if(path.empty()) {
    loc_id = b_h5Id;
  } else {
    loc_id = H5Oopen(b_h5Id, path.c_str(), H5P_DEFAULT);
    b_error(loc_id, path, AT_);
    checkLoc_id = 1;
  }
  // Get variable id
  hid_t dset_id = H5Oopen(loc_id, name.c_str(), H5P_DEFAULT);
  b_error(dset_id, name, AT_);
  // Get file space
  hid_t fspace_id = H5Dget_space(dset_id);
  b_error(fspace_id, name, AT_);
 
  hid_t dtype_id = H5Dget_type(dset_id);
  b_error(dtype_id, name, AT_);
 
  // Prepare data
  ScratchSpace<hsize_t> start_(noDims, FUN_, "start_");
  ScratchSpace<hsize_t> count_(noDims, FUN_, "count_");
 
  std::copy(start, start + noDims, &start_[0]);
  std::copy(count, count + noDims, &count_[0]);
 
  herr_t status = -1;
  status = H5Sselect_hyperslab(fspace_id, H5S_SELECT_SET, &start_[0], NULL, &count_[0], NULL);
  b_error(status, name, AT_);
  hid_t dspace_id = H5Screate_simple(noDims, &count_[0], NULL);
  b_error(dspace_id, name, AT_);
  status = H5Dread(dset_id, dtype_id, dspace_id, fspace_id, H5P_DEFAULT, array);
  b_error(status, name, AT_);
 
  // Close all indetifiers
  if(checkLoc_id) {
    status = H5Oclose(loc_id);
    b_error(status, name, AT_);
  }
  status = H5Dclose(dset_id);
  b_error(status, path, AT_);
  status = H5Sclose(fspace_id);
  b_error(status, name, AT_);
  status = H5Sclose(dspace_id);
  b_error(status, name, AT_);
}

b_readArray() [3/3]

template<class T >

void ParallelIoHdf5::b_readArray ( T *  array, const MString &  name, const size_type  noDims, MPI_Offset *  start, MPI_Offset *  count, MPI_Offset  memoryStride, const size_type  noChunks, MPI_Offset  diskStride  )

private

Author

Michael Schlottke (mic) mic@a.nosp@m.ia.r.nosp@m.wth-a.nosp@m.ache.nosp@m.n.de, Konstantin Froehlich

Date

2013-04-09

Parameters

[in]	array	Pointer to data in memory.
[in]	name	Name of the dataset.
[in]	noDims	Number of array dimensions
[in]	start	Start offset in the file (i.e. the domain should start reading from here).
[in]	count	Number of elements read from this domain.
[in]	memoryStride	Stride in memory between data values.
[in]	noChunks	Number of Chunks for chunked IO.

This method is the exact counterpart to h5WriteArray().

Definition at line 1885 of file parallelio_hdf5.cpp.

                                                        {
  TRACE();
 
  // Get variable id
  hid_t dset_id = H5Dopen(b_h5Id, name.c_str(), H5P_DEFAULT);
  b_error(dset_id, name, AT_);
  hid_t dspace_id = H5Dget_space(dset_id);
  b_error(dspace_id, name, AT_);
  hid_t dtype_id = H5Dget_type(dset_id);
  b_error(dtype_id, name, AT_);
 
  // Determine total data count
  size_type totalCount = 1;
  for(size_type d = 0; d < noDims; d++) {
    totalCount *= count[d];
  }
 
  // Create temporary storage space if needed and set data pointers
  MInt tmpScratchSize = (memoryStride == 1 ? 1 : totalCount);
  ScratchSpace<T> tmpScratch(tmpScratchSize, FUN_, "tmpStorage");
  T* data = 0;
  if(memoryStride == 1) {
    data = array;
  } else {
    // data = tmpScratch.begin();
    data = &tmpScratch[0];
  }
 
  hid_t memory_dspace_id;
  herr_t status = -1;
  // Read array
  if(noChunks == 1) {
    // If number of chunks is one, write everything at once
    memory_dspace_id = H5Screate_simple(noDims, (hsize_t*)count, nullptr);
    b_error(memory_dspace_id, name, AT_);
    if(diskStride == 1) {
      status = H5Sselect_hyperslab(dspace_id, H5S_SELECT_SET, (hsize_t*)start, nullptr, (hsize_t*)count, nullptr);
    } else {
      status = H5Sselect_hyperslab(dspace_id, H5S_SELECT_SET, (hsize_t*)start, (hsize_t*)diskStride, (hsize_t*)count,
                                   nullptr);
    }
    b_error(status, name, AT_);
    status = H5Dread(dset_id, dtype_id, memory_dspace_id, dspace_id, H5P_DEFAULT, data);
    b_error(status, name, AT_);
  } else {
    TERMM(1, "untested Hdf5 specific I/O method, please see comment for how"
             " to proceed");
    // WARNING: This method is untested, yet. It is implemented due to be
    // consistent with parallel NetCDF. However, it was not used by any of the
    // testcases.If your code uses this part of the code, please make sure that
    // the I/O still works as expected and then remove this warning as well as
    // the subsequent TERMM().
    // Determine variable id
    // Read in chunks
    MPI_Offset chunkSize = count[0] / noChunks;
    if(count[0] % noChunks > 0) {
      chunkSize += 1;
    }
 
    // Determine number of entries for a fixed first dimension index
    size_type nDSize = 1;
    for(size_type d = 1; d < noDims; d++) {
      nDSize *= count[d];
    }
 
    ScratchSpace<hsize_t> start_(noDims, FUN_, "start_");
    ScratchSpace<hsize_t> count_(noDims, FUN_, "count_");
 
    std::copy(start, start + noDims, &start_[0]);
    std::copy(count, count + noDims, &count_[0]);
 
    for(size_type i = 0; i < noChunks; i++) {
      start_[0] = std::min(start[0] + i * chunkSize * diskStride, count[0] * diskStride - 1);
      count_[0] = std::max(std::min(chunkSize, count[0] - i * chunkSize), 0ll);
      T* data_ = data + std::min(i * chunkSize * nDSize, (count[0] - 1) * nDSize);
      memory_dspace_id = H5Screate_simple(noDims, &count_[0], nullptr);
      b_error(memory_dspace_id, name, AT_);
      if(diskStride == 1) {
        status = H5Sselect_hyperslab(dspace_id, H5S_SELECT_SET, &start_[0], nullptr, &count_[0], nullptr);
      } else {
        status = H5Sselect_hyperslab(dspace_id, H5S_SELECT_SET, &start_[0], (hsize_t*)diskStride, &count_[0], nullptr);
      }
      b_error(status, name, AT_);
      status = H5Dread(dset_id, dtype_id, memory_dspace_id, dspace_id, H5P_DEFAULT, data_);
      b_error(status, name, AT_);
    }
  }
 
  // Unpack strided data if necessary
  if(memoryStride != 1) {
    for(MPI_Offset i = 0; i < totalCount; i++) {
      array[memoryStride * i] = tmpScratch[i];
    }
  }
 
  // Close all identifiers which have been created (except b_h5Id)
  status = H5Sclose(memory_dspace_id);
  b_error(status, name, AT_);
  status = H5Sclose(dspace_id);
  b_error(status, name, AT_);
  status = H5Tclose(dtype_id);
  b_error(status, name, AT_);
  status = H5Dclose(dset_id);
  b_error(status, name, AT_);
}

b_readScalar() [1/2]

template<>

void ParallelIoHdf5::b_readScalar	(	MString *	scalar,
		const MString &	name
	)

Author

Michael Schlottke (mic) mic@a.nosp@m.ia.r.nosp@m.wth-a.nosp@m.ache.nosp@m.n.de, Konstantin Froehlich

Date

2013-04-09

Parameters

[out]	scalar	Value to read.
[in]	name	Name of the dataset.

This method is the exact counterpart to h5WriteScalar().

Definition at line 1414 of file parallelio_hdf5.cpp.

                                                                      {
  TRACE();
 
  TERMM(1, "untested Hdf5 specific I/O method, please see comment for how"
           " to proceed");
  // WARNING: This method is untested, yet. It is implemented due to be
  // consistent with parallel NetCDF. However, it was not used by any of the
  // testcases.If your code uses this part of the code, please make sure that
  // the I/O still works as expected and then remove this warning as well as
  // the subsequent TERMM().
  // Get variable id
  hid_t dset_id = H5Dopen(b_h5Id, name.c_str(), H5P_DEFAULT);
  b_error(dset_id, name, AT_);
 
  // Read scalar
  hid_t dtype_id = H5Tcopy(H5T_C_S1);
  b_error(dtype_id, name, AT_);
  herr_t status = H5Tset_size(dtype_id, H5T_VARIABLE);
  b_error(status, name, AT_);
  status = H5Dread(dset_id, dtype_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, (char*)(scalar));
  b_error(status, name, AT_);
 
  // Close all identifiers
  status = H5Dclose(dset_id);
  b_error(status, name, AT_);
  status = H5Tclose(dtype_id);
  b_error(status, name, AT_);
}

b_readScalar() [2/2]

template<class T >

void ParallelIoHdf5::b_readScalar ( T *  scalar, const MString &  name  )

private

Author

Michael Schlottke (mic) mic@a.nosp@m.ia.r.nosp@m.wth-a.nosp@m.ache.nosp@m.n.de, Konstantin Froehlich

Date

2013-04-09

Parameters

[out]	scalar	Value to read.
[in]	name	Name of the dataset.

This method is the exact counterpart to h5WriteScalar().

Definition at line 2006 of file parallelio_hdf5.cpp.

                                                                {
  TRACE();
 
  // Get variable id
  hid_t dset_id = H5Dopen(b_h5Id, name.c_str(), H5P_DEFAULT);
  b_error(dset_id, name, AT_);
  hid_t dtype_id = H5Dget_type(dset_id);
  b_error(dtype_id, name, AT_);
 
  // Read scalar
  herr_t status = H5Dread(dset_id, dtype_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, scalar);
  b_error(status, name, AT_);
 
  // Close all identifiers
  status = H5Dclose(dset_id);
  b_error(status, name, AT_);
}

b_saveHeader()

void ParallelIoHdf5::b_saveHeader ( )

private

Author

Michael Schlottke (mic) mic@a.nosp@m.ia.r.nosp@m.wth-a.nosp@m.ache.nosp@m.n.de, Konstantin Froehlich

Date

2013-04-09

This method must be called exactly once for newly created files.

Definition at line 273 of file parallelio_hdf5.cpp.

                                  {
  TRACE();
 
  b_addAdditionalHeader();
  b_writeAdditionalData();
}

b_setAttribute() [1/2]

template<>

void ParallelIoHdf5::b_setAttribute	(	const MString *	value,
		const MString &	name,
		const MString &	datasetName,
		const size_type	totalCount
	)

Author

Ramandeep Jain (HiWi) raman.nosp@m.deep.nosp@m.jain@.nosp@m.gmai.nosp@m.l.com, Konstantin Froehlich

Date

2015-Mar

Parameters

[in]	value	Attribute value.
[in]	name	Attribute name.
[in]	datasetName	Dataset (scalar or array) to which the attribute is attached (leave empty for file attributes).

Definition at line 1639 of file parallelio_hdf5.cpp.

                                                                {
  TRACE();
 
  if(totalCount > 1) mTerm(1, AT_, "Array of strings attributes not yet supported.");
 
  // Create the type and specify its length
  hid_t dtype_id = H5Tcopy(H5T_C_S1);
  b_error(dtype_id, name, AT_);
  herr_t status = H5Tset_size(dtype_id, H5T_VARIABLE);
  b_error(status, name, AT_);
  b_createAttribute(value, name, datasetName, dtype_id, 1);
}

b_setAttribute() [2/2]

template<class T >

void ParallelIoHdf5::b_setAttribute ( const T *  value, const MString &  name, const MString &  datasetName = "", const size_type  totalCount = 1  )

private

Author

Ramandeep Jain (HiWi) raman.nosp@m.deep.nosp@m.jain@.nosp@m.gmai.nosp@m.l.com, Konstantin Froehlich

Date

2015-Mar

Parameters

[in]	value	Attribute value.
[in]	name	Attribute name.
[in]	datasetName	Dataset (scalar or array) to which the attribute is attached (leave empty for file attributes).

Definition at line 1615 of file parallelio_hdf5.cpp.

                                                                {
  TRACE();
 
  // Create the type and specify its length
  hid_t dtype_id = H5Tcopy(hdf5_traits<T>::type());
  b_error(dtype_id, name, AT_);
 
  b_createAttribute(value, name, datasetName, dtype_id, totalCount);
}

b_warning()

void ParallelIoHdf5::b_warning ( MInt  status, const MString &  name, const MString &  location  )

staticprivate

Author

Ramandeep Jain (HiWi) raman.nosp@m.deep.nosp@m.jain@.nosp@m.gmai.nosp@m.l.com, Konstantin Froehlich

Date

2015-Mar

Parameters

[in]	status	HDF5 status code (negative if unexspected behaviour)
[in]	name	Name of the file / variable / attribute
[in]	location	Function which called the error message

Returns

The status message if there was an error, or zero if everything is ok.

Definition at line 1699 of file parallelio_hdf5.cpp.

                                                                                        {
  TRACE();
  if(status < 0) {
    cerr << endl;
    cerr << "*** HDF5 Warning ***" << endl;
    cerr << "HDF5 warning in function " << location << endl;
    cerr << "HDF5 returns status " << status << endl;
    cerr << "The file/variable/attribute in question was: " << name << endl;
    cerr << endl;
  }
}

b_writeAdditionalData()

void ParallelIoHdf5::b_writeAdditionalData ( )

private

Author

Michael Schlottke (mic) mic@a.nosp@m.ia.r.nosp@m.wth-a.nosp@m.ache.nosp@m.n.de

Date

2013-03-26

Definition at line 403 of file parallelio_hdf5.cpp.

                                           {
  TRACE();
 
  // At the moment, nothing happens here
}

b_writeArray() [1/3]

template<>

void ParallelIoHdf5::b_writeArray	(	const MString *	array,
		const MString &	name,
		const size_type	noDims,
		MPI_Offset *	start,
		MPI_Offset *	count,
		MPI_Offset	memoryStride,
		const size_type	noChunks,
		MPI_Offset	diskStride
	)

Author

Michael Schlottke (mic) mic@a.nosp@m.ia.r.nosp@m.wth-a.nosp@m.ache.nosp@m.n.de, Konstantin Froehlich

Date

2013-04-09

Parameters

[in]	array	Pointer to data in memory.
[in]	name	Name of the dataset.
[in]	noDims	Number of array dimensions
[in]	start	Start offset in the file (i.e. the domain should start writing from here).
[in]	count	Number of elements written from this domain.
[in]	memoryStride	Stride in memory between data values.

Definition at line 1127 of file parallelio_hdf5.cpp.

                                                         {
  TRACE();
  TERMM(1, "untested Hdf5 specific I/O method, please see comment for how"
           " to proceed");
  // WARNING: This method is untested, yet. It is implemented due to be
  // consistent with parallel NetCDF. However, it was not used by any of the
  // testcases.If your code uses this part of the code, please make sure that
  // the I/O still works as expected and then remove this warning as well as
  // the subsequent TERMM().
 
  // Get variable id
  hid_t dset_id = H5Dopen2(b_h5Id, name.c_str(), H5P_DEFAULT);
  b_error(dset_id, name, AT_);
  hid_t dspace_id = H5Dget_space(dset_id);
  b_error(dspace_id, name, AT_);
  hid_t dtype_id = H5Tcopy(H5T_C_S1);
  b_error(dtype_id, name, AT_);
  herr_t status = H5Tset_size(dtype_id, H5T_VARIABLE);
  b_error(status, name, AT_);
 
  // Determine total number of strings (last dimension is string length)
  size_type totalCount = 1;
  for(size_type d = 0; d < noDims - 1; d++) {
    totalCount *= count[d];
  }
 
  // Determine length of one string
  size_type strLen = count[noDims - 1];
 
  // Create temporary storage space if needed and set data pointers
  MInt tmpScratchSize = (memoryStride == 1 ? 1 : totalCount);
  ScratchSpace<MString> tmpScratch(tmpScratchSize, FUN_, "tmpStorage");
 
  // Pack strided data
  const MString* data = 0;
  if(memoryStride == 1) {
    data = array;
  } else {
    for(MPI_Offset i = 0; i < totalCount; i++) {
      tmpScratch[i] = array[memoryStride * i];
    }
    // data = tmpScratch.begin();
    data = &tmpScratch[0];
  }
 
  // Create buffer for writing
  size_type nCount = totalCount * strLen;
  ScratchSpace<char> buf(nCount, FUN_, "buf");
 
  // Copy data to buffer
  for(MPI_Offset i = 0; i < totalCount; i++) {
    data[i].copy(&buf[i * strLen], strLen, 0);
  }
 
  hid_t memory_dspace_id = -1;
  // Write array
  if(noChunks == 1) {
    // If number of chunks is one, write everything at once
    memory_dspace_id = H5Screate_simple(noDims, (hsize_t*)count, nullptr);
    b_error(memory_dspace_id, name, AT_);
    if(diskStride == 1) {
      status = H5Sselect_hyperslab(dspace_id, H5S_SELECT_SET, (hsize_t*)start, nullptr, (hsize_t*)count, nullptr);
    } else {
      status = H5Sselect_hyperslab(dspace_id, H5S_SELECT_SET, (hsize_t*)start, (hsize_t*)diskStride, (hsize_t*)count,
                                   nullptr);
    }
    b_error(status, name, AT_);
    status = H5Dwrite(dset_id, dtype_id, memory_dspace_id, dspace_id, b_h5DatasetXferHandle, &buf[0]);
    b_error(status, name, AT_);
  } else {
    // Write in chunks
    MPI_Offset chunkSize = count[0] / noChunks;
    if(count[0] % noChunks > 0) {
      chunkSize += 1;
    }
 
    // Determine number of entries for a fixed first dimension index
    size_type nDSize = 1;
    for(size_type d = 1; d < noDims; d++) {
      nDSize *= count[d];
    }
 
    ScratchSpace<hsize_t> start_(noDims, FUN_, "start_");
    ScratchSpace<hsize_t> count_(noDims, FUN_, "count_");
 
    std::copy(start, start + noDims, &start_[0]);
    std::copy(count, count + noDims, &count_[0]);
 
    for(size_type i = 0; i < noChunks; i++) {
      start_[0] = min(start[0] + i * chunkSize * diskStride, count[0] * diskStride - 1);
      count_[0] = max(min(chunkSize, count[0] - i * chunkSize), 0ll);
      const char* buf_ = &buf[0] + min(i * chunkSize * nDSize, (count[0] - 1) * nDSize);
      memory_dspace_id = H5Screate_simple(noDims, &count_[0], nullptr);
      b_error(memory_dspace_id, name, AT_);
      if(diskStride == 1) {
        status = H5Sselect_hyperslab(dspace_id, H5S_SELECT_SET, &start_[0], nullptr, &count_[0], nullptr);
      } else {
        status = H5Sselect_hyperslab(dspace_id, H5S_SELECT_SET, &start_[0], (hsize_t*)diskStride, &count_[0], nullptr);
      }
      b_error(status, name, AT_);
      status = H5Dwrite(dset_id, dtype_id, memory_dspace_id, dspace_id, b_h5DatasetXferHandle, &buf_[0]);
      b_error(status, name, AT_);
    }
  }
  // Close all identifiers which have been created (except b_h5Id)
  status = H5Sclose(memory_dspace_id);
  b_error(status, name, AT_);
  status = H5Sclose(dspace_id);
  b_error(status, name, AT_);
  status = H5Dclose(dset_id);
  b_error(status, name, AT_);
  status = H5Tclose(dtype_id);
  b_error(status, name, AT_);
}

b_writeArray() [2/3]

template<class T >

void ParallelIoHdf5::b_writeArray ( const T *  array, const MString &  path, const MString &  name, const size_type  noDims, const size_type *  start, const size_type *  count, const size_type *  ghost  )

private

Author

Rodrigo Barros Miguez (rodrigo) rodri.nosp@m.go.m.nosp@m.iguez.nosp@m.@rwt.nosp@m.h-aac.nosp@m.hen..nosp@m.de (HIWI), Marian Albers (marian) maria.nosp@m.n.al.nosp@m.bers@.nosp@m.aia..nosp@m.rwth-.nosp@m.aach.nosp@m.en.de

Date

2021-09-09

Parameters

[in]	array	to write
[in]	preceding	path of dataset
[in]	name	of dataset
[in]	number	of dimensions
[in]	offset	in different space directions
[in]	number	of cells in different space directions
[in]	number	of ghost cells

Definition at line 2111 of file parallelio_hdf5.cpp.

                                                                                                          {
  TRACE();
 
  hid_t link_id = H5Pcreate(H5P_LINK_ACCESS);
  b_error(link_id, name, AT_);
  // Handle whether or not path was given
  hid_t loc_id = b_h5Id;
  MInt checkLoc_id = 0;
  herr_t status = -1;
  if(path.empty()) {
    loc_id = b_h5Id;
  } else {
    loc_id = H5Oopen(b_h5Id, path.c_str(), H5P_DEFAULT);
    b_error(loc_id, path, AT_);
    checkLoc_id = 1;
  }
 
  // Check if dataset exists
  status = H5Lexists(loc_id, name.c_str(), link_id);
  b_error(status, name, AT_);
  // Get variable id
  hid_t dset_id = H5Oopen(loc_id, name.c_str(), H5P_DEFAULT);
  b_error(dset_id, name, AT_);
 
  hid_t dtype_id = H5Dget_type(dset_id);
  b_error(dtype_id, name, AT_);
 
  // Set memory information
  ScratchSpace<hsize_t> count_(noDims, FUN_, "count_");
  ScratchSpace<hsize_t> start_(noDims, FUN_, "start_");
  ScratchSpace<hsize_t> ghost_(noDims, FUN_, "ghost_");
 
  for(size_type i = 0; i < noDims; i++) {
    count_[i] = count[i] + (2 * ghost[i]);
  }
  std::copy(start, start + noDims, &start_[0]);
  std::copy(ghost, ghost + noDims, &ghost_[0]);
 
  hid_t dspace_id = H5Screate_simple(noDims, &count_[0], nullptr);
  b_error(dspace_id, name, AT_);
  // Reassing count values to count_ array before selecting hyperslab
  std::copy(count, count + noDims, &count_[0]);
  status = H5Sselect_hyperslab(dspace_id, H5S_SELECT_SET, &ghost_[0], nullptr, &count_[0], nullptr);
  b_error(status, name, AT_);
  // Obtain space
  hid_t fspace_id = H5Dget_space(dset_id);
  b_error(fspace_id, name, AT_);
  // Select hyperslab
  status = H5Sselect_hyperslab(fspace_id, H5S_SELECT_SET, &start_[0], nullptr, &count_[0], nullptr);
  b_error(status, name, AT_);
  status = H5Dwrite(dset_id, dtype_id, dspace_id, fspace_id, b_h5DatasetXferHandle, array);
 
#if !defined(HOST_Hawk)
  // HDF5 installation on Hawk produces strange warnings/errors, although files are ok
  b_error(status, name, AT_);
#endif
 
  status = H5Pclose(link_id);
  b_error(status, name, AT_);
  if(checkLoc_id) {
    status = H5Oclose(loc_id);
    b_error(status, name, AT_);
  }
  status = H5Dclose(dset_id);
  b_error(status, path, AT_);
  status = H5Sclose(dspace_id);
  b_error(status, name, AT_);
  status = H5Sclose(fspace_id);
  b_error(status, name, AT_);
}

b_writeArray() [3/3]

template<class T >

void ParallelIoHdf5::b_writeArray ( const T *  array, const MString &  name, const size_type  noDims, MPI_Offset *  start, MPI_Offset *  count, MPI_Offset  memoryStride, const size_type  noChunks, MPI_Offset  diskStride  )

private

Author

Michael Schlottke (mic) mic@a.nosp@m.ia.r.nosp@m.wth-a.nosp@m.ache.nosp@m.n.de, Konstantin Froehlich

Date

2013-04-09

Parameters

[in]	array	Pointer to data in memory.
[in]	name	Name of the dataset.
[in]	noDims	Number of array dimensions
[in]	start	Start offset in the file (i.e. the domain should start writing from here).
[in]	count	Number of elements written from this domain.
[in]	memoryStride	Stride in memory between data values.
[in]	noChunks	Number of Chunks for chunked IO.

Definition at line 1731 of file parallelio_hdf5.cpp.

                                                         {
  TRACE();
 
  // Get variable id
  hid_t dset_id = H5Dopen2(b_h5Id, name.c_str(), H5P_DEFAULT);
  b_error(dset_id, name, AT_);
  hid_t dspace_id = H5Dget_space(dset_id);
  b_error(dspace_id, name, AT_);
  hid_t dtype_id = H5Dget_type(dset_id);
  b_error(dtype_id, name, AT_);
 
  // Determine total data count
  size_type totalCount = 1;
  for(size_type d = 0; d < noDims; d++) {
    totalCount *= count[d];
  }
 
  // Create temporary storage space if needed and set data pointers
  MInt tmpScratchSize = (memoryStride == 1 ? 1 : totalCount);
  ScratchSpace<T> tmpScratch(tmpScratchSize, FUN_, "tmpStorage");
 
  // Pack strided data
  const T* data = 0;
  if(memoryStride == 1) {
    data = array;
  } else {
    for(MPI_Offset i = 0; i < totalCount; i++) {
      tmpScratch[i] = array[memoryStride * i];
    }
    // data = tmpScratch.begin();
    data = &tmpScratch[0];
  }
 
  hid_t memory_dspace_id;
  herr_t status = -1;
  // Write array
  if(noChunks == 1) {
    // If number of chunks is one, write everything at once
    memory_dspace_id = H5Screate_simple(noDims, (hsize_t*)count, nullptr);
    b_error(memory_dspace_id, name, AT_);
    if(diskStride == 1) {
      status = H5Sselect_hyperslab(dspace_id, H5S_SELECT_SET, (hsize_t*)start, nullptr, (hsize_t*)count, nullptr);
    } else {
      status = H5Sselect_hyperslab(dspace_id, H5S_SELECT_SET, (hsize_t*)start, (hsize_t*)diskStride, (hsize_t*)count,
                                   nullptr);
    }
    b_error(status, name, AT_);
    status = H5Dwrite(dset_id, dtype_id, memory_dspace_id, dspace_id, b_h5DatasetXferHandle, data);
    b_error(status, name, AT_);
  } else {
    TERMM(1, "untested Hdf5 specific I/O method, please see comment for how"
             " to proceed");
    // WARNING: This method is untested, yet. It is implemented due to be
    // consistent with parallel NetCDF. However, it was not used by any of the
    // testcases.If your code uses this part of the code, please make sure that
    // the I/O still works as expected and then remove this warning as well as
    // the subsequent TERMM().
    // Determine variable id
    // Write in chunks
    MPI_Offset chunkSize = count[0] / noChunks;
    if(count[0] % noChunks > 0) {
      chunkSize += 1;
    }
 
    // Determine number of entries for a fixed first dimension index
    size_type nDSize = 1;
    for(size_type d = 1; d < noDims; d++) {
      nDSize *= count[d];
    }
 
    ScratchSpace<hsize_t> start_(noDims, FUN_, "start_");
    ScratchSpace<hsize_t> count_(noDims, FUN_, "count_");
 
    std::copy(start, start + noDims, &start_[0]);
    std::copy(count, count + noDims, &count_[0]);
 
    for(size_type i = 0; i < noChunks; i++) {
      start_[0] = std::min(start[0] + i * chunkSize * diskStride, count[0] * diskStride - 1);
      count_[0] = std::max(std::min(chunkSize, count[0] - i * chunkSize), 0ll);
      const T* data_ = data + std::min(i * chunkSize * nDSize, (count[0] - 1) * nDSize);
      memory_dspace_id = H5Screate_simple(noDims, &count_[0], nullptr);
      b_error(memory_dspace_id, name, AT_);
      if(diskStride == 1) {
        status = H5Sselect_hyperslab(dspace_id, H5S_SELECT_SET, &start_[0], nullptr, &count_[0], nullptr);
      } else {
        status = H5Sselect_hyperslab(dspace_id, H5S_SELECT_SET, &start_[0], (hsize_t*)diskStride, &count_[0], nullptr);
      }
      b_error(status, name, AT_);
      status = H5Dwrite(dset_id, dtype_id, memory_dspace_id, dspace_id, b_h5DatasetXferHandle, data_);
      b_error(status, name, AT_);
    }
  }
 
  // Close all identifiers which have been created (except b_h5Id)
  status = H5Sclose(memory_dspace_id);
  b_error(status, name, AT_);
  status = H5Sclose(dspace_id);
  b_error(status, name, AT_);
  status = H5Tclose(dtype_id);
  b_error(status, name, AT_);
  status = H5Dclose(dset_id);
  b_error(status, name, AT_);
}

b_writeScalar()

template<class T >

template void ParallelIoHdf5::b_writeScalar ( T  scalar, const MString &  name  )

private

Author

Michael Schlottke (mic) mic@a.nosp@m.ia.r.nosp@m.wth-a.nosp@m.ache.nosp@m.n.de, Konstantin Froehlich

Date

2013-04-09

Parameters

[in]	scalar	Value to write.
[in]	name	Name of the dataset.

Definition at line 1848 of file parallelio_hdf5.cpp.

                                                                {
  TRACE();
 
  // Get variable id
  hid_t dset_id = H5Dopen(b_h5Id, name.c_str(), H5P_DEFAULT);
  b_error(dset_id, name, AT_);
  hid_t dtype_id = H5Dget_type(dset_id);
  b_error(dtype_id, name, AT_);
 
  // Write scalar
  herr_t status = H5Dwrite(dset_id, dtype_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, &scalar);
  b_error(status, name, AT_);
 
  // Close all identifiers which have been created (except b_h5Id)
  status = H5Dclose(dset_id);
  b_error(status, name, AT_);
}

Member Data Documentation

b_h5DatasetXferHandle

hid_t ParallelIoHdf5::b_h5DatasetXferHandle

private

Definition at line 105 of file parallelio_hdf5.h.

b_h5FileXferHandle

hid_t ParallelIoHdf5::b_h5FileXferHandle

private

Definition at line 106 of file parallelio_hdf5.h.

b_h5Id

hid_t ParallelIoHdf5::b_h5Id = -1

private

Definition at line 103 of file parallelio_hdf5.h.

ParallelIoBase< ParallelIoHdf5 >

friend ParallelIoHdf5::ParallelIoBase< ParallelIoHdf5 >

private

Definition at line 20 of file parallelio_hdf5.h.

---

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

• /home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/IO/parallelio_hdf5.h
• /home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/IO/parallelio_hdf5.cpp