223031012
/
DAMASK_EICMD
mirror of https://github.com/achalhp/DAMASK_EICMD.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
DAMASK_EICMD/src/HDF5_utilities.f90

2185 lines
106 KiB
Fortran
Raw Normal View History

adjusted variable names and added comments
2018-10-09 18:16:57 +05:30
!--------------------------------------------------------------------------------------------------
!> @author Vitesh Shah, Max-Planck-Institut für Eisenforschung GmbH
!> @author Yi-Chin Yang, Max-Planck-Institut für Eisenforschung GmbH
!> @author Jennifer Nastola, Max-Planck-Institut für Eisenforschung GmbH
!> @author Martin Diehl, Max-Planck-Institut für Eisenforschung GmbH
!--------------------------------------------------------------------------------------------------
MPI file access needed for output
2018-11-15 11:58:34 +05:30
module HDF5_utilities
cleaning
2019-06-06 14:11:56 +05:30
use HDF5
consistent capitalization
2021-07-08 18:35:01 +05:30
#ifdef PETSC
PETSc defines are rather complicated now mpi_f08 can be used on newer PETSc installations if old MPI modules are not exposed
2021-07-09 22:18:25 +05:30
#include <petsc/finclude/petscsys.h>
use PETScSys
#if (PETSC_VERSION_MAJOR==3 && PETSC_VERSION_MINOR>14) && !defined(PETSC_HAVE_MPI_F90MODULE_VISIBILITY)
use modern Fortran interface not possible for HDF5...
2022-02-05 23:02:17 +05:30
use MPI_f08
use MPI, only: MPI_INFO_NULL_F90 => MPI_INFO_NULL
ifort does not allow rename of already imported symbols
2022-02-06 00:30:55 +05:30
#endif
MPI write only in case that PETSc is used
2018-08-05 10:11:35 +05:30
#endif
number of helper functions for HDF5
2018-08-03 12:23:37 +05:30
HDF5 is not always available
2019-06-12 23:29:17 +05:30
use prec
handling of MPI in 'parallelization'
2020-09-13 13:49:38 +05:30
use parallelization
HDF5 is not always available
2019-06-12 23:29:17 +05:30
only MPI_f08 is standard conforming
2022-06-22 02:41:22 +05:30
#if (PETSC_VERSION_MAJOR==3 && PETSC_VERSION_MINOR>14) && !defined(PETSC_HAVE_MPI_F90MODULE_VISIBILITY)
[skip sc] enforce interfaces (quick fix: declare as external)
2022-06-22 02:16:54 +05:30
implicit none(type,external)
only MPI_f08 is standard conforming
2022-06-22 02:41:22 +05:30
#else
implicit none
#endif
avoid chained inclusions
2021-07-08 17:57:04 +05:30
private
number of helper functions for HDF5
2018-08-03 12:23:37 +05:30
adjusted variable names and added comments
2018-10-09 18:16:57 +05:30
!--------------------------------------------------------------------------------------------------
more meaningful order and intent(out) variables for read are at the front
2021-06-01 20:16:24 +05:30
!> @brief reads integer or float data of defined shape from file
finalize for write
2019-02-09 14:14:41 +05:30
!> @details for parallel IO, all dimension except for the last need to match
adjusted variable names and added comments
2018-10-09 18:16:57 +05:30
!--------------------------------------------------------------------------------------------------
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
interface HDF5_read
module procedure HDF5_read_real1
module procedure HDF5_read_real2
module procedure HDF5_read_real3
module procedure HDF5_read_real4
module procedure HDF5_read_real5
module procedure HDF5_read_real6
module procedure HDF5_read_real7
documenting for doxygen
2020-03-15 17:16:10 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
module procedure HDF5_read_int1
module procedure HDF5_read_int2
module procedure HDF5_read_int3
module procedure HDF5_read_int4
module procedure HDF5_read_int5
module procedure HDF5_read_int6
module procedure HDF5_read_int7
end interface HDF5_read
Interfacing for subroutines to identify real and integer data
2018-10-09 14:27:06 +05:30
adjusted variable names and added comments
2018-10-09 18:16:57 +05:30
!--------------------------------------------------------------------------------------------------
more meaningful order and intent(out) variables for read are at the front
2021-06-01 20:16:24 +05:30
!> @brief writes integer or real data of defined shape to file
finalize for write
2019-02-09 14:14:41 +05:30
!> @details for parallel IO, all dimension except for the last need to match
adjusted variable names and added comments
2018-10-09 18:16:57 +05:30
!--------------------------------------------------------------------------------------------------
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
interface HDF5_write
assumed rank solution gives wrong results #194
2022-05-19 20:06:50 +05:30
#if defined(__GFORTRAN__)
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
module procedure HDF5_write_real1
module procedure HDF5_write_real2
module procedure HDF5_write_real3
module procedure HDF5_write_real4
module procedure HDF5_write_real5
module procedure HDF5_write_real6
module procedure HDF5_write_real7
module procedure HDF5_write_int1
module procedure HDF5_write_int2
module procedure HDF5_write_int3
module procedure HDF5_write_int4
module procedure HDF5_write_int5
module procedure HDF5_write_int6
module procedure HDF5_write_int7
avoid code duplication by using assumed rank "(..)" - lack of modern Fortran interface for HDF5 still requires branching to call the same code - not sure how to handle the read function (assumed rank and intent(out) ) does not work together
2022-04-18 16:46:45 +05:30
#else
module procedure HDF5_write_real
module procedure HDF5_write_int
#endif
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
end interface HDF5_write
documenting for doxygen
2020-03-15 17:16:10 +05:30
The attribute interface works for single processor output and single valued attribute
2018-12-15 21:51:03 +05:30
!--------------------------------------------------------------------------------------------------
cleaning
2019-06-11 13:18:07 +05:30
!> @brief attached attributes of type char, integer or real to a file/dataset/group
The attribute interface works for single processor output and single valued attribute
2018-12-15 21:51:03 +05:30
!--------------------------------------------------------------------------------------------------
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
interface HDF5_addAttribute
module procedure HDF5_addAttribute_str
module procedure HDF5_addAttribute_int
module procedure HDF5_addAttribute_real
string array support for attributes
2021-07-24 20:48:31 +05:30
module procedure HDF5_addAttribute_str_array
enable more complex attributes
2019-04-11 19:14:08 +05:30
module procedure HDF5_addAttribute_int_array
module procedure HDF5_addAttribute_real_array
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
end interface HDF5_addAttribute
documenting for doxygen
2020-03-15 17:16:10 +05:30
consistent capitalization
2021-07-08 18:35:01 +05:30
#ifdef PETSC
always chunk data for small datasets: - only one chunk - no compression
2021-08-14 18:37:01 +05:30
logical, parameter :: parallel_default = .true.
restore functionality to write non-parallel not needed at the moment, but in general useful. If PETSc = parallel should always hold, we can simplify much more
2021-02-22 18:07:21 +05:30
#else
always chunk data for small datasets: - only one chunk - no compression
2021-08-14 18:37:01 +05:30
logical, parameter :: parallel_default = .false.
restore functionality to write non-parallel not needed at the moment, but in general useful. If PETSc = parallel should always hold, we can simplify much more
2021-02-22 18:07:21 +05:30
#endif
always chunk data for small datasets: - only one chunk - no compression
2021-08-14 18:37:01 +05:30
logical :: compression_possible
avoid chained inclusions
2021-07-08 17:57:04 +05:30
public :: &
HDF5_utilities_init, &
HDF5_read, &
HDF5_write, &
write string, only from one MPI process needed to store simulation setup. I don't see a situation where strings are distributed over multiple processes
2021-07-27 02:09:23 +05:30
HDF5_write_str, &
avoid chained inclusions
2021-07-08 17:57:04 +05:30
HDF5_addAttribute, &
HDF5_addGroup, &
HDF5_openGroup, &
HDF5_closeGroup, &
HDF5_openFile, &
HDF5_closeFile, &
HDF5_objectExists, &
HDF5_setLink
restore functionality to write non-parallel not needed at the moment, but in general useful. If PETSc = parallel should always hold, we can simplify much more
2021-02-22 18:07:21 +05:30
number of helper functions for HDF5
2018-08-03 12:23:37 +05:30
contains
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
!--------------------------------------------------------------------------------------------------
clearer description
2020-04-28 14:00:03 +05:30
!> @brief initialize HDF5 libary and do sanity checks
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
!--------------------------------------------------------------------------------------------------
MPI file access needed for output
2018-11-15 11:58:34 +05:30
subroutine HDF5_utilities_init
number of helper functions for HDF5
2018-08-03 12:23:37 +05:30
bugfix for HDF5 without deflate filter before inquiring whether a filter supports compression/decompression, we first need to check whether it is available at all to avoid raising an error. Extended the check to the shuffle filter
2021-12-02 17:30:59 +05:30
integer :: hdferr, HDF5_major, HDF5_minor, HDF5_release, configFlags
logical :: avail
next try for MARC 2019
2019-09-21 04:37:04 +05:30
integer(SIZE_T) :: typeSize
number of helper functions for HDF5
2018-08-03 12:23:37 +05:30
always chunk data for small datasets: - only one chunk - no compression
2021-08-14 18:37:01 +05:30
consistent indentation and line-spacings in reporting
2021-11-15 23:05:44 +05:30
print'(/,1x,a)', '<<<+- HDF5_Utilities init -+>>>'
number of helper functions for HDF5
2018-08-03 12:23:37 +05:30
always chunk data for small datasets: - only one chunk - no compression
2021-08-14 18:37:01 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Open_f(hdferr)
always chunk data for small datasets: - only one chunk - no compression
2021-08-14 18:37:01 +05:30
if (hdferr < 0) error stop 'HDF5 error'
kind-ID does not need to coincide with the number of bytes
2019-03-06 21:03:39 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Tget_size_f(H5T_NATIVE_INTEGER,typeSize, hdferr)
always chunk data for small datasets: - only one chunk - no compression
2021-08-14 18:37:01 +05:30
if (hdferr < 0) error stop 'HDF5 error'
kind-ID does not need to coincide with the number of bytes
2019-03-06 21:03:39 +05:30
if (int(bit_size(0),SIZE_T)/=typeSize*8) &
use 'error stop' - does not require IO - prints stack trace
2020-09-13 15:39:32 +05:30
error stop 'Default integer size does not match H5T_NATIVE_INTEGER'
kind-ID does not need to coincide with the number of bytes
2019-03-06 21:03:39 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Tget_size_f(H5T_NATIVE_DOUBLE,typeSize, hdferr)
always chunk data for small datasets: - only one chunk - no compression
2021-08-14 18:37:01 +05:30
if (hdferr < 0) error stop 'HDF5 error'
kind-ID does not need to coincide with the number of bytes
2019-03-06 21:03:39 +05:30
if (int(storage_size(0.0_pReal),SIZE_T)/=typeSize*8) &
use 'error stop' - does not require IO - prints stack trace
2020-09-13 15:39:32 +05:30
error stop 'pReal does not match H5T_NATIVE_DOUBLE'
close all objects of type integer(HID_T) created by native hdf5 routines
2018-11-09 20:41:19 +05:30
always chunk data for small datasets: - only one chunk - no compression
2021-08-14 18:37:01 +05:30
call H5get_libversion_f(HDF5_major,HDF5_minor,HDF5_release,hdferr)
if (hdferr < 0) error stop 'HDF5 error'
bugfix for HDF5 without deflate filter before inquiring whether a filter supports compression/decompression, we first need to check whether it is available at all to avoid raising an error. Extended the check to the shuffle filter
2021-12-02 17:30:59 +05:30
compression_possible = (HDF5_major == 1 .and. HDF5_minor >= 12) ! https://forum.hdfgroup.org/t/6186
call H5Zfilter_avail_f(H5Z_FILTER_DEFLATE_F,avail,hdferr)
if (hdferr < 0) error stop 'HDF5 error'
compression_possible = compression_possible .and. avail
if (avail) then
call H5Zget_filter_info_f(H5Z_FILTER_DEFLATE_F,configFlags,hdferr)
if (hdferr < 0) error stop 'HDF5 error'
wrong check iand is used for checking, see https://support.hdfgroup.org/HDF5/doc/RM/H5Z/H5Zget_filter_info.htm
2021-12-03 01:21:33 +05:30
compression_possible = compression_possible .and. iand(H5Z_FILTER_ENCODE_ENABLED_F,configFlags) > 0
bugfix for HDF5 without deflate filter before inquiring whether a filter supports compression/decompression, we first need to check whether it is available at all to avoid raising an error. Extended the check to the shuffle filter
2021-12-02 17:30:59 +05:30
end if
call H5Zfilter_avail_f(H5Z_FILTER_SHUFFLE_F,avail,hdferr)
always chunk data for small datasets: - only one chunk - no compression
2021-08-14 18:37:01 +05:30
if (hdferr < 0) error stop 'HDF5 error'
bugfix for HDF5 without deflate filter before inquiring whether a filter supports compression/decompression, we first need to check whether it is available at all to avoid raising an error. Extended the check to the shuffle filter
2021-12-02 17:30:59 +05:30
compression_possible = compression_possible .and. avail
if (avail) then
call H5Zget_filter_info_f(H5Z_FILTER_SHUFFLE_F,configFlags,hdferr)
if (hdferr < 0) error stop 'HDF5 error'
wrong check iand is used for checking, see https://support.hdfgroup.org/HDF5/doc/RM/H5Z/H5Zget_filter_info.htm
2021-12-03 01:21:33 +05:30
compression_possible = compression_possible .and. iand(H5Z_FILTER_ENCODE_ENABLED_F,configFlags) > 0
bugfix for HDF5 without deflate filter before inquiring whether a filter supports compression/decompression, we first need to check whether it is available at all to avoid raising an error. Extended the check to the shuffle filter
2021-12-02 17:30:59 +05:30
end if
always chunk data for small datasets: - only one chunk - no compression
2021-08-14 18:37:01 +05:30
MPI file access needed for output
2018-11-15 11:58:34 +05:30
end subroutine HDF5_utilities_init
number of helper functions for HDF5
2018-08-03 12:23:37 +05:30
Reading and writing not very efficient method
2018-10-04 20:30:24 +05:30
!--------------------------------------------------------------------------------------------------
also compress string datasets results in different type (numpy string instead of numpy object), tests need to be adjusted
2021-08-14 19:58:51 +05:30
!> @brief Open and initialize HDF5 file.
Reading and writing not very efficient method
2018-10-04 20:30:24 +05:30
!--------------------------------------------------------------------------------------------------
write string to result requires to open file without MPI support
2021-07-27 10:55:44 +05:30
integer(HID_T) function HDF5_openFile(fileName,mode,parallel)
close all objects of type integer(HID_T) created by native hdf5 routines
2018-11-09 20:41:19 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
character(len=*), intent(in) :: fileName
character, intent(in), optional :: mode
write string to result requires to open file without MPI support
2021-07-27 10:55:44 +05:30
logical, intent(in), optional :: parallel
documenting for doxygen
2020-03-15 17:16:10 +05:30
use modern Fortran interface not possible for HDF5...
2022-02-05 23:02:17 +05:30
character :: m
integer(HID_T) :: plist_id
integer :: hdferr
documenting for doxygen
2020-03-15 17:16:10 +05:30
restore functionality to write non-parallel not needed at the moment, but in general useful. If PETSc = parallel should always hold, we can simplify much more
2021-02-22 18:07:21 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
if (present(mode)) then
m = mode
else
m = 'r'
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
documenting for doxygen
2020-03-15 17:16:10 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Pcreate_f(H5P_FILE_ACCESS_F, plist_id, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
setting the property when opening the file
2018-11-16 11:35:43 +05:30
consistent capitalization
2021-07-08 18:35:01 +05:30
#ifdef PETSC
write string to result requires to open file without MPI support
2021-07-27 10:55:44 +05:30
if (present(parallel)) then
ifort does not allow rename of already imported symbols
2022-02-06 00:30:55 +05:30
#if (PETSC_VERSION_MAJOR==3 && PETSC_VERSION_MINOR>14) && !defined(PETSC_HAVE_MPI_F90MODULE_VISIBILITY)
use modern Fortran interface not possible for HDF5...
2022-02-05 23:02:17 +05:30
if (parallel) call H5Pset_fapl_mpio_f(plist_id, PETSC_COMM_WORLD, MPI_INFO_NULL_F90, hdferr)
write string to result requires to open file without MPI support
2021-07-27 10:55:44 +05:30
else
use modern Fortran interface not possible for HDF5...
2022-02-05 23:02:17 +05:30
call H5Pset_fapl_mpio_f(plist_id, PETSC_COMM_WORLD, MPI_INFO_NULL_F90, hdferr)
ifort does not allow rename of already imported symbols
2022-02-06 00:30:55 +05:30
#else
if (parallel) call H5Pset_fapl_mpio_f(plist_id, PETSC_COMM_WORLD, MPI_INFO_NULL, hdferr)
else
call H5Pset_fapl_mpio_f(plist_id, PETSC_COMM_WORLD, MPI_INFO_NULL, hdferr)
#endif
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
MPI file access needed for output
2018-11-15 11:58:34 +05:30
#endif
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
if (m == 'w') then
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Fcreate_f(fileName,H5F_ACC_TRUNC_F,HDF5_openFile,hdferr,access_prp = plist_id)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
elseif (m == 'a') then
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Fopen_f(fileName,H5F_ACC_RDWR_F,HDF5_openFile,hdferr,access_prp = plist_id)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
elseif (m == 'r') then
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Fopen_f(fileName,H5F_ACC_RDONLY_F,HDF5_openFile,hdferr,access_prp = plist_id)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
else
error stop better suited for internal errors error stop gives full stack trace, which is very helpful for debugging.
2020-11-11 14:49:47 +05:30
error stop 'unknown access mode'
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
documenting for doxygen
2020-03-15 17:16:10 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Pclose_f(plist_id, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
setting the property when opening the file
2018-11-16 11:35:43 +05:30
Reading and writing not very efficient method
2018-10-04 20:30:24 +05:30
end function HDF5_openFile
number of helper functions for HDF5
2018-08-03 12:23:37 +05:30
keep only general functionality in HDF5_results
2018-11-15 11:37:59 +05:30
creating hdf5 file to contain restart information first quick and dirty implementation to get started. needs polishing and renaming
2018-09-20 23:12:58 +05:30
!--------------------------------------------------------------------------------------------------
Interfacing for subroutines to identify real and integer data
2018-10-09 14:27:06 +05:30
!> @brief close the opened HDF5 output file
creating hdf5 file to contain restart information first quick and dirty implementation to get started. needs polishing and renaming
2018-09-20 23:12:58 +05:30
!--------------------------------------------------------------------------------------------------
subroutine HDF5_closeFile(fileHandle)
close all objects of type integer(HID_T) created by native hdf5 routines
2018-11-09 20:41:19 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
integer(HID_T), intent(in) :: fileHandle
documenting for doxygen
2020-03-15 17:16:10 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
integer :: hdferr
documenting for doxygen
2020-03-15 17:16:10 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Fclose_f(fileHandle,hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
creating hdf5 file to contain restart information first quick and dirty implementation to get started. needs polishing and renaming
2018-09-20 23:12:58 +05:30
end subroutine HDF5_closeFile
number of helper functions for HDF5
2018-08-03 12:23:37 +05:30
creating hdf5 file to contain restart information first quick and dirty implementation to get started. needs polishing and renaming
2018-09-20 23:12:58 +05:30
!--------------------------------------------------------------------------------------------------
cleaning and separating functions
2018-12-05 03:39:25 +05:30
!> @brief adds a new group to the fileHandle
creating hdf5 file to contain restart information first quick and dirty implementation to get started. needs polishing and renaming
2018-09-20 23:12:58 +05:30
!--------------------------------------------------------------------------------------------------
cleaning and separating functions
2018-12-05 03:39:25 +05:30
integer(HID_T) function HDF5_addGroup(fileHandle,groupName)
creating hdf5 file to contain restart information first quick and dirty implementation to get started. needs polishing and renaming
2018-09-20 23:12:58 +05:30
use variable string length for array, padding is needed to get same length
2020-12-06 18:02:20 +05:30
integer(HID_T), intent(in) :: fileHandle
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
character(len=*), intent(in) :: groupName
documenting for doxygen
2020-03-15 17:16:10 +05:30
next try for MARC 2019
2019-09-21 04:37:04 +05:30
integer :: hdferr
integer(HID_T) :: aplist_id
Parallel works for groups and included write function for integer data
2018-11-22 00:05:37 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
!-------------------------------------------------------------------------------------------------
! creating a property list for data access properties
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Pcreate_f(H5P_GROUP_ACCESS_F, aplist_id, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
cleaning and separating functions
2018-12-05 03:39:25 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
!-------------------------------------------------------------------------------------------------
! setting I/O mode to collective
consistent capitalization
2021-07-08 18:35:01 +05:30
#ifdef PETSC
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Pset_all_coll_metadata_ops_f(aplist_id, .true., hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
required for HDF5 output
2019-03-09 21:21:50 +05:30
#endif
documenting for doxygen
2020-03-15 17:16:10 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
!-------------------------------------------------------------------------------------------------
! Create group
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Gcreate_f(fileHandle, trim(groupName), HDF5_addGroup, hdferr, OBJECT_NAMELEN_DEFAULT_F,gapl_id = aplist_id)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
close all objects of type integer(HID_T) created by native hdf5 routines
2018-11-09 20:41:19 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Pclose_f(aplist_id,hdferr)
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
cleaning and separating functions
2018-12-05 03:39:25 +05:30
end function HDF5_addGroup
creating hdf5 file to contain restart information first quick and dirty implementation to get started. needs polishing and renaming
2018-09-20 23:12:58 +05:30
number of helper functions for HDF5
2018-08-03 12:23:37 +05:30
Reading and writing not very efficient method
2018-10-04 20:30:24 +05:30
!--------------------------------------------------------------------------------------------------
close all objects of type integer(HID_T) created by native hdf5 routines
2018-11-09 20:41:19 +05:30
!> @brief open an existing group of a file
Reading and writing not very efficient method
2018-10-04 20:30:24 +05:30
!--------------------------------------------------------------------------------------------------
cleaning and separating functions
2018-12-05 03:39:25 +05:30
integer(HID_T) function HDF5_openGroup(fileHandle,groupName)
Reading and writing not very efficient method
2018-10-04 20:30:24 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
integer(HID_T), intent(in) :: fileHandle
character(len=*), intent(in) :: groupName
documenting for doxygen
2020-03-15 17:16:10 +05:30
next try for MARC 2019
2019-09-21 04:37:04 +05:30
integer :: hdferr
integer(HID_T) :: aplist_id
logical :: is_collective
documenting for doxygen
2020-03-15 17:16:10 +05:30
Able to read the independent datasets (outside the groups) in parallel
2018-11-30 14:46:04 +05:30
!-------------------------------------------------------------------------------------------------
cleaning and separating functions
2018-12-05 03:39:25 +05:30
! creating a property list for data access properties
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Pcreate_f(H5P_GROUP_ACCESS_F, aplist_id, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
cleaning and separating functions
2018-12-05 03:39:25 +05:30
Able to read the independent datasets (outside the groups) in parallel
2018-11-30 14:46:04 +05:30
!-------------------------------------------------------------------------------------------------
cleaning and separating functions
2018-12-05 03:39:25 +05:30
! setting I/O mode to collective
consistent capitalization
2021-07-08 18:35:01 +05:30
#ifdef PETSC
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Pget_all_coll_metadata_ops_f(aplist_id, is_collective, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
required for HDF5 output
2019-03-09 21:21:50 +05:30
#endif
documenting for doxygen
2020-03-15 17:16:10 +05:30
cleaning and separating functions
2018-12-05 03:39:25 +05:30
!-------------------------------------------------------------------------------------------------
! opening the group
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Gopen_f(fileHandle, trim(groupName), HDF5_openGroup, hdferr, gapl_id = aplist_id)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
Reading and writing not very efficient method
2018-10-04 20:30:24 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Pclose_f(aplist_id,hdferr)
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
cleaning and separating functions
2018-12-05 03:39:25 +05:30
end function HDF5_openGroup
Reading and writing not very efficient method
2018-10-04 20:30:24 +05:30
number of helper functions for HDF5
2018-08-03 12:23:37 +05:30
!--------------------------------------------------------------------------------------------------
close all objects of type integer(HID_T) created by native hdf5 routines
2018-11-09 20:41:19 +05:30
!> @brief close a group
number of helper functions for HDF5
2018-08-03 12:23:37 +05:30
!--------------------------------------------------------------------------------------------------
failed if dataset does not exists empty datasets are not written out
2018-12-18 11:04:18 +05:30
subroutine HDF5_closeGroup(group_id)
number of helper functions for HDF5
2018-08-03 12:23:37 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
integer(HID_T), intent(in) :: group_id
no need to have fixed string here
2020-08-09 09:57:29 +05:30
integer :: hdferr
documenting for doxygen
2020-03-15 17:16:10 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Gclose_f(group_id, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
number of helper functions for HDF5
2018-08-03 12:23:37 +05:30
end subroutine HDF5_closeGroup
failed if dataset does not exists empty datasets are not written out
2018-12-18 11:04:18 +05:30
!--------------------------------------------------------------------------------------------------
string array support for attributes
2021-07-24 20:48:31 +05:30
!> @brief Check whether a group or a dataset exists.
failed if dataset does not exists empty datasets are not written out
2018-12-18 11:04:18 +05:30
!--------------------------------------------------------------------------------------------------
logical function HDF5_objectExists(loc_id,path)
no need to create type for native data types
2019-04-11 15:52:16 +05:30
integer(HID_T), intent(in) :: loc_id
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
character(len=*), intent(in), optional :: path
documenting for doxygen
2020-03-15 17:16:10 +05:30
no need to have fixed string here
2020-08-09 09:57:29 +05:30
integer :: hdferr
character(len=:), allocatable :: p
documenting for doxygen
2020-03-15 17:16:10 +05:30
string array support for attributes
2021-07-24 20:48:31 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
if (present(path)) then
p = trim(path)
else
p = '.'
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
documenting for doxygen
2020-03-15 17:16:10 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Lexists_f(loc_id, p, HDF5_objectExists, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
documenting for doxygen
2020-03-15 17:16:10 +05:30
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (HDF5_objectExists) then
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Oexists_by_name_f(loc_id, p, HDF5_objectExists, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
failed if dataset does not exists empty datasets are not written out
2018-12-18 11:04:18 +05:30
end function HDF5_objectExists
planning the forwarding of the results
2018-11-18 17:11:05 +05:30
!--------------------------------------------------------------------------------------------------
string array support for attributes
2021-07-24 20:48:31 +05:30
!> @brief Add a string attribute to the path given relative to the location.
planning the forwarding of the results
2018-11-18 17:11:05 +05:30
!--------------------------------------------------------------------------------------------------
polished addAttribute and use it to store meta data
2018-12-17 20:45:16 +05:30
subroutine HDF5_addAttribute_str(loc_id,attrLabel,attrValue,path)
planning the forwarding of the results
2018-11-18 17:11:05 +05:30
no need to create type for native data types
2019-04-11 15:52:16 +05:30
integer(HID_T), intent(in) :: loc_id
character(len=*), intent(in) :: attrLabel, attrValue
character(len=*), intent(in), optional :: path
documenting for doxygen
2020-03-15 17:16:10 +05:30
keep it simple
2021-07-27 02:29:53 +05:30
integer(HID_T) :: attr_id, space_id
no need to have fixed string here
2020-08-09 09:57:29 +05:30
logical :: attrExists
integer :: hdferr
character(len=:), allocatable :: p
trying to make sense of HDF5 pointer magic
2021-07-25 13:13:52 +05:30
character(len=len_trim(attrValue)+1,kind=C_CHAR), dimension(1), target :: attrValue_
write variable length string (as other, best compatibility with h5py)
2021-07-25 13:06:56 +05:30
type(C_PTR), target, dimension(1) :: ptr
documenting for doxygen
2020-03-15 17:16:10 +05:30
string array support for attributes
2021-07-24 20:48:31 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
if (present(path)) then
p = trim(path)
else
p = '.'
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
documenting for doxygen
2020-03-15 17:16:10 +05:30
trying to make sense of HDF5 pointer magic
2021-07-25 13:13:52 +05:30
attrValue_(1) = trim(attrValue)//C_NULL_CHAR
ptr(1) = c_loc(attrValue_(1))
black magic compiles also with Intel (complained about non-existing interface before). Direct pointer crashes ..
2020-11-05 22:26:39 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Screate_f(H5S_SCALAR_F,space_id,hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
string array support for attributes
2021-07-24 20:48:31 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Aexists_by_name_f(loc_id,trim(p),attrLabel,attrExists,hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
if (attrExists) then
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Adelete_by_name_f(loc_id, trim(p), attrLabel, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
write variable length string (as other, best compatibility with h5py)
2021-07-25 13:06:56 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Acreate_by_name_f(loc_id,trim(p),trim(attrLabel),H5T_STRING,space_id,attr_id,hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Awrite_f(attr_id, H5T_STRING, c_loc(ptr), hdferr) ! ptr instead of c_loc(ptr) works on gfortran, not on ifort
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
string array support for attributes
2021-07-24 20:48:31 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Aclose_f(attr_id,hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Sclose_f(space_id,hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
planning the forwarding of the results
2018-11-18 17:11:05 +05:30
polished addAttribute and use it to store meta data
2018-12-17 20:45:16 +05:30
end subroutine HDF5_addAttribute_str
planning the forwarding of the results
2018-11-18 17:11:05 +05:30
!--------------------------------------------------------------------------------------------------
string array support for attributes
2021-07-24 20:48:31 +05:30
!> @brief Add an integer attribute to the path given relative to the location.
planning the forwarding of the results
2018-11-18 17:11:05 +05:30
!--------------------------------------------------------------------------------------------------
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
subroutine HDF5_addAttribute_int(loc_id,attrLabel,attrValue,path)
planning the forwarding of the results
2018-11-18 17:11:05 +05:30
no need to have fixed string here
2020-08-09 09:57:29 +05:30
integer(HID_T), intent(in) :: loc_id
character(len=*), intent(in) :: attrLabel
integer, intent(in) :: attrValue
character(len=*), intent(in), optional :: path
documenting for doxygen
2020-03-15 17:16:10 +05:30
no need to have fixed string here
2020-08-09 09:57:29 +05:30
integer(HID_T) :: attr_id, space_id
integer :: hdferr
logical :: attrExists
character(len=:), allocatable :: p
documenting for doxygen
2020-03-15 17:16:10 +05:30
string array support for attributes
2021-07-24 20:48:31 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
if (present(path)) then
p = trim(path)
else
p = '.'
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
documenting for doxygen
2020-03-15 17:16:10 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Screate_f(H5S_SCALAR_F,space_id,hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
string array support for attributes
2021-07-24 20:48:31 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Aexists_by_name_f(loc_id,trim(p),attrLabel,attrExists,hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
if (attrExists) then
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Adelete_by_name_f(loc_id, trim(p), attrLabel, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
write variable length string (as other, best compatibility with h5py)
2021-07-25 13:06:56 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Acreate_by_name_f(loc_id,trim(p),trim(attrLabel),H5T_NATIVE_INTEGER,space_id,attr_id,hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Awrite_f(attr_id, H5T_NATIVE_INTEGER, attrValue, int([1],HSIZE_T), hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
string array support for attributes
2021-07-24 20:48:31 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Aclose_f(attr_id,hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Sclose_f(space_id,hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
end subroutine HDF5_addAttribute_int
planning the forwarding of the results
2018-11-18 17:11:05 +05:30
The attribute interface works for single processor output and single valued attribute
2018-12-15 21:51:03 +05:30
!--------------------------------------------------------------------------------------------------
string array support for attributes
2021-07-24 20:48:31 +05:30
!> @brief Add a real attribute to the path given relative to the location.
The attribute interface works for single processor output and single valued attribute
2018-12-15 21:51:03 +05:30
!--------------------------------------------------------------------------------------------------
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
subroutine HDF5_addAttribute_real(loc_id,attrLabel,attrValue,path)
The attribute interface works for single processor output and single valued attribute
2018-12-15 21:51:03 +05:30
no need to create type for native data types
2019-04-11 15:52:16 +05:30
integer(HID_T), intent(in) :: loc_id
character(len=*), intent(in) :: attrLabel
real(pReal), intent(in) :: attrValue
character(len=*), intent(in), optional :: path
documenting for doxygen
2020-03-15 17:16:10 +05:30
no need to have fixed string here
2020-08-09 09:57:29 +05:30
integer(HID_T) :: attr_id, space_id
integer :: hdferr
logical :: attrExists
character(len=:), allocatable :: p
documenting for doxygen
2020-03-15 17:16:10 +05:30
string array support for attributes
2021-07-24 20:48:31 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
if (present(path)) then
p = trim(path)
else
p = '.'
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
documenting for doxygen
2020-03-15 17:16:10 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Screate_f(H5S_SCALAR_F,space_id,hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
string array support for attributes
2021-07-24 20:48:31 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Aexists_by_name_f(loc_id,trim(p),attrLabel,attrExists,hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
if (attrExists) then
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Adelete_by_name_f(loc_id, trim(p), attrLabel, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
write variable length string (as other, best compatibility with h5py)
2021-07-25 13:06:56 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Acreate_by_name_f(loc_id,trim(p),trim(attrLabel),H5T_NATIVE_DOUBLE,space_id,attr_id,hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Awrite_f(attr_id, H5T_NATIVE_DOUBLE, attrValue, int([1],HSIZE_T), hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
string array support for attributes
2021-07-24 20:48:31 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Aclose_f(attr_id,hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Sclose_f(space_id,hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
end subroutine HDF5_addAttribute_real
The attribute interface works for single processor output and single valued attribute
2018-12-15 21:51:03 +05:30
enable more complex attributes
2019-04-11 19:14:08 +05:30
!--------------------------------------------------------------------------------------------------
string array support for attributes
2021-07-24 20:48:31 +05:30
!> @brief Add a string array attribute to the path given relative to the location.
!--------------------------------------------------------------------------------------------------
subroutine HDF5_addAttribute_str_array(loc_id,attrLabel,attrValue,path)
integer(HID_T), intent(in) :: loc_id
character(len=*), intent(in) :: attrLabel
character(len=*), intent(in), dimension(:) :: attrValue
character(len=*), intent(in), optional :: path
keep it simple
2021-07-27 02:29:53 +05:30
integer(HID_T) :: attr_id, space_id
string array support for attributes
2021-07-24 20:48:31 +05:30
logical :: attrExists
write variable length string (as other, best compatibility with h5py)
2021-07-25 13:06:56 +05:30
integer :: hdferr,i
string array support for attributes
2021-07-24 20:48:31 +05:30
character(len=:), allocatable :: p
write variable length string (as other, best compatibility with h5py)
2021-07-25 13:06:56 +05:30
character(len=len(attrValue)+1,kind=C_CHAR), dimension(size(attrValue)), target :: attrValue_
type(C_PTR), target, dimension(size(attrValue)) :: ptr
string array support for attributes
2021-07-24 20:48:31 +05:30
if (present(path)) then
p = trim(path)
else
p = '.'
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
string array support for attributes
2021-07-24 20:48:31 +05:30
write variable length string (as other, best compatibility with h5py)
2021-07-25 13:06:56 +05:30
do i=1,size(attrValue)
attrValue_(i) = attrValue(i)//C_NULL_CHAR
ptr(i) = c_loc(attrValue_(i))
consistent variants including space
2022-06-09 02:36:01 +05:30
end do
string array support for attributes
2021-07-24 20:48:31 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Screate_simple_f(1,shape(attrValue_,kind=HSIZE_T),space_id,hdferr,shape(attrValue_,kind=HSIZE_T))
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
string array support for attributes
2021-07-24 20:48:31 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Aexists_by_name_f(loc_id,trim(p),attrLabel,attrExists,hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
string array support for attributes
2021-07-24 20:48:31 +05:30
if (attrExists) then
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Adelete_by_name_f(loc_id, trim(p), attrLabel, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
string array support for attributes
2021-07-24 20:48:31 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Acreate_by_name_f(loc_id,trim(p),trim(attrLabel),H5T_STRING,space_id,attr_id,hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Awrite_f(attr_id, H5T_STRING, c_loc(ptr), hdferr) ! ptr instead of c_loc(ptr) works on gfortran, not on ifort
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
write variable length string (as other, best compatibility with h5py)
2021-07-25 13:06:56 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Aclose_f(attr_id,hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Sclose_f(space_id,hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
string array support for attributes
2021-07-24 20:48:31 +05:30
end subroutine HDF5_addAttribute_str_array
!--------------------------------------------------------------------------------------------------
!> @brief Add an integer array attribute to the path given relative to the location.
enable more complex attributes
2019-04-11 19:14:08 +05:30
!--------------------------------------------------------------------------------------------------
subroutine HDF5_addAttribute_int_array(loc_id,attrLabel,attrValue,path)
integer(HID_T), intent(in) :: loc_id
character(len=*), intent(in) :: attrLabel
cleaning
2019-06-11 13:18:07 +05:30
integer, intent(in), dimension(:) :: attrValue
enable more complex attributes
2019-04-11 19:14:08 +05:30
character(len=*), intent(in), optional :: path
documenting for doxygen
2020-03-15 17:16:10 +05:30
enable more complex attributes
2019-04-11 19:14:08 +05:30
integer(HSIZE_T),dimension(1) :: array_size
no need to have fixed string here
2020-08-09 09:57:29 +05:30
integer(HID_T) :: attr_id, space_id
integer :: hdferr
enable more complex attributes
2019-04-11 19:14:08 +05:30
logical :: attrExists
no need to have fixed string here
2020-08-09 09:57:29 +05:30
character(len=:), allocatable :: p
documenting for doxygen
2020-03-15 17:16:10 +05:30
string array support for attributes
2021-07-24 20:48:31 +05:30
enable more complex attributes
2019-04-11 19:14:08 +05:30
if (present(path)) then
p = trim(path)
else
p = '.'
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
documenting for doxygen
2020-03-15 17:16:10 +05:30
enable more complex attributes
2019-04-11 19:14:08 +05:30
array_size = size(attrValue,kind=HSIZE_T)
documenting for doxygen
2020-03-15 17:16:10 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Screate_simple_f(1, array_size, space_id, hdferr, array_size)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
string array support for attributes
2021-07-24 20:48:31 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Aexists_by_name_f(loc_id,trim(p),attrLabel,attrExists,hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
enable more complex attributes
2019-04-11 19:14:08 +05:30
if (attrExists) then
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Adelete_by_name_f(loc_id, trim(p), attrLabel, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
write variable length string (as other, best compatibility with h5py)
2021-07-25 13:06:56 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Acreate_by_name_f(loc_id,trim(p),trim(attrLabel),H5T_NATIVE_INTEGER,space_id,attr_id,hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Awrite_f(attr_id, H5T_NATIVE_INTEGER, attrValue, array_size, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
string array support for attributes
2021-07-24 20:48:31 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Aclose_f(attr_id,hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Sclose_f(space_id,hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
enable more complex attributes
2019-04-11 19:14:08 +05:30
end subroutine HDF5_addAttribute_int_array
!--------------------------------------------------------------------------------------------------
string array support for attributes
2021-07-24 20:48:31 +05:30
!> @brief Add a real array attribute to the path given relative to the location.
enable more complex attributes
2019-04-11 19:14:08 +05:30
!--------------------------------------------------------------------------------------------------
subroutine HDF5_addAttribute_real_array(loc_id,attrLabel,attrValue,path)
integer(HID_T), intent(in) :: loc_id
character(len=*), intent(in) :: attrLabel
real(pReal), intent(in), dimension(:) :: attrValue
character(len=*), intent(in), optional :: path
documenting for doxygen
2020-03-15 17:16:10 +05:30
enable more complex attributes
2019-04-11 19:14:08 +05:30
integer(HSIZE_T),dimension(1) :: array_size
no need to have fixed string here
2020-08-09 09:57:29 +05:30
integer(HID_T) :: attr_id, space_id
integer :: hdferr
enable more complex attributes
2019-04-11 19:14:08 +05:30
logical :: attrExists
no need to have fixed string here
2020-08-09 09:57:29 +05:30
character(len=:), allocatable :: p
documenting for doxygen
2020-03-15 17:16:10 +05:30
string array support for attributes
2021-07-24 20:48:31 +05:30
enable more complex attributes
2019-04-11 19:14:08 +05:30
if (present(path)) then
p = trim(path)
else
p = '.'
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
documenting for doxygen
2020-03-15 17:16:10 +05:30
enable more complex attributes
2019-04-11 19:14:08 +05:30
array_size = size(attrValue,kind=HSIZE_T)
documenting for doxygen
2020-03-15 17:16:10 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Screate_simple_f(1, array_size, space_id, hdferr, array_size)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
string array support for attributes
2021-07-24 20:48:31 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Aexists_by_name_f(loc_id,trim(p),attrLabel,attrExists,hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
enable more complex attributes
2019-04-11 19:14:08 +05:30
if (attrExists) then
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Adelete_by_name_f(loc_id, trim(p), attrLabel, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
write variable length string (as other, best compatibility with h5py)
2021-07-25 13:06:56 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Acreate_by_name_f(loc_id,trim(p),trim(attrLabel),H5T_NATIVE_DOUBLE,space_id,attr_id,hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Awrite_f(attr_id, H5T_NATIVE_DOUBLE, attrValue, array_size, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
string array support for attributes
2021-07-24 20:48:31 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Aclose_f(attr_id,hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Sclose_f(space_id,hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
enable more complex attributes
2019-04-11 19:14:08 +05:30
end subroutine HDF5_addAttribute_real_array
cleaned + suggested structure to write data
2018-12-12 12:15:20 +05:30
!--------------------------------------------------------------------------------------------------
string array support for attributes
2021-07-24 20:48:31 +05:30
!> @brief Set link to object in results file.
cleaned + suggested structure to write data
2018-12-12 12:15:20 +05:30
!--------------------------------------------------------------------------------------------------
polished addAttribute and use it to store meta data
2018-12-17 20:45:16 +05:30
subroutine HDF5_setLink(loc_id,target_name,link_name)
cleaned + suggested structure to write data
2018-12-12 12:15:20 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
character(len=*), intent(in) :: target_name, link_name
next try for MARC 2019
2019-09-21 04:37:04 +05:30
integer(HID_T), intent(in) :: loc_id
integer :: hdferr
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
logical :: linkExists
documenting for doxygen
2020-03-15 17:16:10 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Lexists_f(loc_id, link_name,linkExists, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
if (linkExists) then
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Ldelete_f(loc_id,link_name, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Lcreate_soft_f(target_name, loc_id, link_name, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
planning the forwarding of the results
2018-11-18 17:11:05 +05:30
cleaned + suggested structure to write data
2018-12-12 12:15:20 +05:30
end subroutine HDF5_setLink
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
using functions as far as possible
2019-02-09 16:15:02 +05:30
writing of multidimensional dataset into hdf5 does not appear as multiple pages in hdfviewer
2018-09-25 20:12:43 +05:30
!--------------------------------------------------------------------------------------------------
cleaning
2019-06-11 13:18:07 +05:30
!> @brief read dataset of type real with 1 dimension
adjusted variable names and added comments
2018-10-09 18:16:57 +05:30
!--------------------------------------------------------------------------------------------------
more meaningful order and intent(out) variables for read are at the front
2021-06-01 20:16:24 +05:30
subroutine HDF5_read_real1(dataset,loc_id,datasetName,parallel)
adjusted variable names and added comments
2018-10-09 18:16:57 +05:30
documenting for doxygen
2020-03-15 17:16:10 +05:30
real(pReal), intent(out), dimension(:) :: dataset !< data read from file
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
integer(HID_T), intent(in) :: loc_id !< file or group handle
character(len=*), intent(in) :: datasetName !< name of the dataset in the file
documenting for doxygen
2020-03-15 17:16:10 +05:30
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
supported by recent compilers
2021-07-24 18:05:17 +05:30
integer(HSIZE_T), dimension(rank(dataset)) :: &
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
myStart, &
myShape, & !< shape of the dataset (this process)
totalShape !< shape of the dataset (all processes)
integer :: hdferr
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
avoid HDF5 error in case of empty dataset
2022-10-20 00:16:17 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
myShape = int(shape(dataset),HSIZE_T)
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
if (present(parallel)) then
call initialize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id, &
myStart, totalShape, loc_id,myShape,datasetName,parallel)
else
call initialize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id, &
restore functionality to write non-parallel not needed at the moment, but in general useful. If PETSc = parallel should always hold, we can simplify much more
2021-02-22 18:07:21 +05:30
myStart, totalShape, loc_id,myShape,datasetName,parallel_default)
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
avoid HDF5 error in case of empty dataset
2022-10-20 00:16:17 +05:30
if (any(totalShape == 0)) return
documenting for doxygen
2020-03-15 17:16:10 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Dread_f(dset_id, H5T_NATIVE_DOUBLE,dataset,totalShape, hdferr,&
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
file_space_id = filespace_id, xfer_prp = plist_id, mem_space_id = memspace_id)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
documenting for doxygen
2020-03-15 17:16:10 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)
documenting for doxygen
2020-03-15 17:16:10 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
end subroutine HDF5_read_real1
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
cleaning
2019-06-11 13:18:07 +05:30
!> @brief read dataset of type real with 2 dimensions
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
more meaningful order and intent(out) variables for read are at the front
2021-06-01 20:16:24 +05:30
subroutine HDF5_read_real2(dataset,loc_id,datasetName,parallel)
close all objects of type integer(HID_T) created by native hdf5 routines
2018-11-09 20:41:19 +05:30
documenting for doxygen
2020-03-15 17:16:10 +05:30
real(pReal), intent(out), dimension(:,:) :: dataset !< data read from file
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
integer(HID_T), intent(in) :: loc_id !< file or group handle
character(len=*), intent(in) :: datasetName !< name of the dataset in the file
documenting for doxygen
2020-03-15 17:16:10 +05:30
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
supported by recent compilers
2021-07-24 18:05:17 +05:30
integer(HSIZE_T), dimension(rank(dataset)) :: &
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
myStart, &
myShape, & !< shape of the dataset (this process)
totalShape !< shape of the dataset (all processes)
integer :: hdferr
close all objects of type integer(HID_T) created by native hdf5 routines
2018-11-09 20:41:19 +05:30
avoid HDF5 error in case of empty dataset
2022-10-20 00:16:17 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
myShape = int(shape(dataset),HSIZE_T)
close all objects of type integer(HID_T) created by native hdf5 routines
2018-11-09 20:41:19 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
if (present(parallel)) then
call initialize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id, &
myStart, totalShape, loc_id,myShape,datasetName,parallel)
else
call initialize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id, &
restore functionality to write non-parallel not needed at the moment, but in general useful. If PETSc = parallel should always hold, we can simplify much more
2021-02-22 18:07:21 +05:30
myStart, totalShape, loc_id,myShape,datasetName,parallel_default)
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
avoid HDF5 error in case of empty dataset
2022-10-20 00:16:17 +05:30
if (any(totalShape == 0)) return
documenting for doxygen
2020-03-15 17:16:10 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Dread_f(dset_id, H5T_NATIVE_DOUBLE,dataset,totalShape, hdferr,&
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
file_space_id = filespace_id, xfer_prp = plist_id, mem_space_id = memspace_id)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
documenting for doxygen
2020-03-15 17:16:10 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
end subroutine HDF5_read_real2
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
cleaning
2019-06-11 13:18:07 +05:30
!> @brief read dataset of type real with 2 dimensions
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
more meaningful order and intent(out) variables for read are at the front
2021-06-01 20:16:24 +05:30
subroutine HDF5_read_real3(dataset,loc_id,datasetName,parallel)
close all objects of type integer(HID_T) created by native hdf5 routines
2018-11-09 20:41:19 +05:30
documenting for doxygen
2020-03-15 17:16:10 +05:30
real(pReal), intent(out), dimension(:,:,:) :: dataset !< data read from file
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
integer(HID_T), intent(in) :: loc_id !< file or group handle
character(len=*), intent(in) :: datasetName !< name of the dataset in the file
documenting for doxygen
2020-03-15 17:16:10 +05:30
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
supported by recent compilers
2021-07-24 18:05:17 +05:30
integer(HSIZE_T), dimension(rank(dataset)) :: &
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
myStart, &
myShape, & !< shape of the dataset (this process)
totalShape !< shape of the dataset (all processes)
integer :: hdferr
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
avoid HDF5 error in case of empty dataset
2022-10-20 00:16:17 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
myShape = int(shape(dataset),HSIZE_T)
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
if (present(parallel)) then
call initialize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id, &
myStart, totalShape, loc_id,myShape,datasetName,parallel)
else
call initialize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id, &
restore functionality to write non-parallel not needed at the moment, but in general useful. If PETSc = parallel should always hold, we can simplify much more
2021-02-22 18:07:21 +05:30
myStart, totalShape, loc_id,myShape,datasetName,parallel_default)
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
avoid HDF5 error in case of empty dataset
2022-10-20 00:16:17 +05:30
if (any(totalShape == 0)) return
documenting for doxygen
2020-03-15 17:16:10 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Dread_f(dset_id, H5T_NATIVE_DOUBLE,dataset,totalShape, hdferr,&
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
file_space_id = filespace_id, xfer_prp = plist_id, mem_space_id = memspace_id)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
end subroutine HDF5_read_real3
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
!--------------------------------------------------------------------------------------------------
cleaning
2019-06-11 13:18:07 +05:30
!> @brief read dataset of type real with 4 dimensions
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
!--------------------------------------------------------------------------------------------------
more meaningful order and intent(out) variables for read are at the front
2021-06-01 20:16:24 +05:30
subroutine HDF5_read_real4(dataset,loc_id,datasetName,parallel)
adjusted variable names and added comments
2018-10-09 18:16:57 +05:30
documenting for doxygen
2020-03-15 17:16:10 +05:30
real(pReal), intent(out), dimension(:,:,:,:) :: dataset !< read data
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
integer(HID_T), intent(in) :: loc_id !< file or group handle
character(len=*), intent(in) :: datasetName !< name of the dataset in the file
documenting for doxygen
2020-03-15 17:16:10 +05:30
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
supported by recent compilers
2021-07-24 18:05:17 +05:30
integer(HSIZE_T), dimension(rank(dataset)) :: &
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
myStart, &
myShape, & !< shape of the dataset (this process)
totalShape !< shape of the dataset (all processes)
integer :: hdferr
started read parallelization but getting errors
2018-11-23 20:19:43 +05:30
avoid HDF5 error in case of empty dataset
2022-10-20 00:16:17 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
myShape = int(shape(dataset),HSIZE_T)
if (any(myShape(1:size(myShape)-1) == 0)) return !< empty dataset (last dimension can be empty)
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
if (present(parallel)) then
call initialize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id, &
myStart, totalShape, loc_id,myShape,datasetName,parallel)
else
call initialize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id, &
restore functionality to write non-parallel not needed at the moment, but in general useful. If PETSc = parallel should always hold, we can simplify much more
2021-02-22 18:07:21 +05:30
myStart, totalShape, loc_id,myShape,datasetName,parallel_default)
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
avoid HDF5 error in case of empty dataset
2022-10-20 00:16:17 +05:30
if (any(totalShape == 0)) return
documenting for doxygen
2020-03-15 17:16:10 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Dread_f(dset_id, H5T_NATIVE_DOUBLE,dataset,totalShape, hdferr,&
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
file_space_id = filespace_id, xfer_prp = plist_id, mem_space_id = memspace_id)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
documenting for doxygen
2020-03-15 17:16:10 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
end subroutine HDF5_read_real4
adjusted variable names and added comments
2018-10-09 18:16:57 +05:30
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
cleaning
2019-06-11 13:18:07 +05:30
!> @brief read dataset of type real with 5 dimensions
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
more meaningful order and intent(out) variables for read are at the front
2021-06-01 20:16:24 +05:30
subroutine HDF5_read_real5(dataset,loc_id,datasetName,parallel)
Interfacing for subroutines to identify real and integer data
2018-10-09 14:27:06 +05:30
documenting for doxygen
2020-03-15 17:16:10 +05:30
real(pReal), intent(out), dimension(:,:,:,:,:) :: dataset !< data read from file
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
integer(HID_T), intent(in) :: loc_id !< file or group handle
character(len=*), intent(in) :: datasetName !< name of the dataset in the file
documenting for doxygen
2020-03-15 17:16:10 +05:30
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
supported by recent compilers
2021-07-24 18:05:17 +05:30
integer(HSIZE_T), dimension(rank(dataset)) :: &
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
myStart, &
myShape, & !< shape of the dataset (this process)
totalShape !< shape of the dataset (all processes)
integer :: hdferr
Interfacing for subroutines to identify real and integer data
2018-10-09 14:27:06 +05:30
avoid HDF5 error in case of empty dataset
2022-10-20 00:16:17 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
myShape = int(shape(dataset),HSIZE_T)
if (any(myShape(1:size(myShape)-1) == 0)) return !< empty dataset (last dimension can be empty)
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
if (present(parallel)) then
call initialize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id, &
myStart, totalShape, loc_id,myShape,datasetName,parallel)
else
call initialize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id, &
restore functionality to write non-parallel not needed at the moment, but in general useful. If PETSc = parallel should always hold, we can simplify much more
2021-02-22 18:07:21 +05:30
myStart, totalShape, loc_id,myShape,datasetName,parallel_default)
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
avoid HDF5 error in case of empty dataset
2022-10-20 00:16:17 +05:30
if (any(totalShape == 0)) return
documenting for doxygen
2020-03-15 17:16:10 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Dread_f(dset_id, H5T_NATIVE_DOUBLE,dataset,totalShape, hdferr,&
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
file_space_id = filespace_id, xfer_prp = plist_id, mem_space_id = memspace_id)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
documenting for doxygen
2020-03-15 17:16:10 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
end subroutine HDF5_read_real5
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
adjusted variable names and added comments
2018-10-09 18:16:57 +05:30
!--------------------------------------------------------------------------------------------------
cleaning
2019-06-11 13:18:07 +05:30
!> @brief read dataset of type real with 6 dimensions
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
!--------------------------------------------------------------------------------------------------
more meaningful order and intent(out) variables for read are at the front
2021-06-01 20:16:24 +05:30
subroutine HDF5_read_real6(dataset,loc_id,datasetName,parallel)
adjusted variable names and added comments
2018-10-09 18:16:57 +05:30
documenting for doxygen
2020-03-15 17:16:10 +05:30
real(pReal), intent(out), dimension(:,:,:,:,:,:) :: dataset !< data read from file
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
integer(HID_T), intent(in) :: loc_id !< file or group handle
character(len=*), intent(in) :: datasetName !< name of the dataset in the file
documenting for doxygen
2020-03-15 17:16:10 +05:30
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
supported by recent compilers
2021-07-24 18:05:17 +05:30
integer(HSIZE_T), dimension(rank(dataset)) :: &
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
myStart, &
myShape, & !< shape of the dataset (this process)
totalShape !< shape of the dataset (all processes)
integer :: hdferr
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
avoid HDF5 error in case of empty dataset
2022-10-20 00:16:17 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
myShape = int(shape(dataset),HSIZE_T)
if (any(myShape(1:size(myShape)-1) == 0)) return !< empty dataset (last dimension can be empty)
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
if (present(parallel)) then
call initialize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id, &
myStart, totalShape, loc_id,myShape,datasetName,parallel)
else
call initialize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id, &
restore functionality to write non-parallel not needed at the moment, but in general useful. If PETSc = parallel should always hold, we can simplify much more
2021-02-22 18:07:21 +05:30
myStart, totalShape, loc_id,myShape,datasetName,parallel_default)
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
avoid HDF5 error in case of empty dataset
2022-10-20 00:16:17 +05:30
if (any(totalShape == 0)) return
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Dread_f(dset_id, H5T_NATIVE_DOUBLE,dataset,totalShape, hdferr,&
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
file_space_id = filespace_id, xfer_prp = plist_id, mem_space_id = memspace_id)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
end subroutine HDF5_read_real6
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
!--------------------------------------------------------------------------------------------------
cleaning
2019-06-11 13:18:07 +05:30
!> @brief read dataset of type real with 7 dimensions
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
!--------------------------------------------------------------------------------------------------
more meaningful order and intent(out) variables for read are at the front
2021-06-01 20:16:24 +05:30
subroutine HDF5_read_real7(dataset,loc_id,datasetName,parallel)
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
documenting for doxygen
2020-03-15 17:16:10 +05:30
real(pReal), intent(out), dimension(:,:,:,:,:,:,:) :: dataset !< data read from file
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
integer(HID_T), intent(in) :: loc_id !< file or group handle
character(len=*), intent(in) :: datasetName !< name of the dataset in the file
documenting for doxygen
2020-03-15 17:16:10 +05:30
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
supported by recent compilers
2021-07-24 18:05:17 +05:30
integer(HSIZE_T), dimension(rank(dataset)) :: &
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
myStart, &
myShape, & !< shape of the dataset (this process)
totalShape !< shape of the dataset (all processes)
integer :: hdferr
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
avoid HDF5 error in case of empty dataset
2022-10-20 00:16:17 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
myShape = int(shape(dataset),HSIZE_T)
if (any(myShape(1:size(myShape)-1) == 0)) return !< empty dataset (last dimension can be empty)
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
if (present(parallel)) then
call initialize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id, &
myStart, totalShape, loc_id,myShape,datasetName,parallel)
else
call initialize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id, &
restore functionality to write non-parallel not needed at the moment, but in general useful. If PETSc = parallel should always hold, we can simplify much more
2021-02-22 18:07:21 +05:30
myStart, totalShape, loc_id,myShape,datasetName,parallel_default)
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
avoid HDF5 error in case of empty dataset
2022-10-20 00:16:17 +05:30
if (any(totalShape == 0)) return
documenting for doxygen
2020-03-15 17:16:10 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Dread_f(dset_id, H5T_NATIVE_DOUBLE,dataset,totalShape, hdferr,&
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
file_space_id = filespace_id, xfer_prp = plist_id, mem_space_id = memspace_id)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
documenting for doxygen
2020-03-15 17:16:10 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
end subroutine HDF5_read_real7
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
!--------------------------------------------------------------------------------------------------
cleaning
2019-06-11 13:18:07 +05:30
!> @brief read dataset of type integer with 1 dimension
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
!--------------------------------------------------------------------------------------------------
more meaningful order and intent(out) variables for read are at the front
2021-06-01 20:16:24 +05:30
subroutine HDF5_read_int1(dataset,loc_id,datasetName,parallel)
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
documenting for doxygen
2020-03-15 17:16:10 +05:30
integer, intent(out), dimension(:) :: dataset !< data read from file
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
integer(HID_T), intent(in) :: loc_id !< file or group handle
character(len=*), intent(in) :: datasetName !< name of the dataset in the file
documenting for doxygen
2020-03-15 17:16:10 +05:30
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
supported by recent compilers
2021-07-24 18:05:17 +05:30
integer(HSIZE_T), dimension(rank(dataset)) :: &
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
myStart, &
myShape, & !< shape of the dataset (this process)
totalShape !< shape of the dataset (all processes)
integer :: hdferr
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
myShape = int(shape(dataset),HSIZE_T)
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
if (present(parallel)) then
call initialize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id, &
myStart, totalShape, loc_id,myShape,datasetName,parallel)
else
call initialize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id, &
restore functionality to write non-parallel not needed at the moment, but in general useful. If PETSc = parallel should always hold, we can simplify much more
2021-02-22 18:07:21 +05:30
myStart, totalShape, loc_id,myShape,datasetName,parallel_default)
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
avoid HDF5 error in case of empty dataset
2022-10-20 00:16:17 +05:30
if (any(totalShape == 0)) return
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Dread_f(dset_id, H5T_NATIVE_INTEGER,dataset,totalShape, hdferr,&
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
file_space_id = filespace_id, xfer_prp = plist_id, mem_space_id = memspace_id)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)
documenting for doxygen
2020-03-15 17:16:10 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
end subroutine HDF5_read_int1
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
!--------------------------------------------------------------------------------------------------
cleaning
2019-06-11 13:18:07 +05:30
!> @brief read dataset of type integer with 2 dimensions
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
!--------------------------------------------------------------------------------------------------
more meaningful order and intent(out) variables for read are at the front
2021-06-01 20:16:24 +05:30
subroutine HDF5_read_int2(dataset,loc_id,datasetName,parallel)
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
documenting for doxygen
2020-03-15 17:16:10 +05:30
integer, intent(out), dimension(:,:) :: dataset !< data read from file
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
integer(HID_T), intent(in) :: loc_id !< file or group handle
character(len=*), intent(in) :: datasetName !< name of the dataset in the file
documenting for doxygen
2020-03-15 17:16:10 +05:30
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
supported by recent compilers
2021-07-24 18:05:17 +05:30
integer(HSIZE_T), dimension(rank(dataset)) :: &
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
myStart, &
myShape, & !< shape of the dataset (this process)
totalShape !< shape of the dataset (all processes)
integer :: hdferr
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
avoid HDF5 error in case of empty dataset
2022-10-20 00:16:17 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
myShape = int(shape(dataset),HSIZE_T)
if (any(myShape(1:size(myShape)-1) == 0)) return !< empty dataset (last dimension can be empty)
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
if (present(parallel)) then
call initialize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id, &
myStart, totalShape, loc_id,myShape,datasetName,parallel)
else
call initialize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id, &
restore functionality to write non-parallel not needed at the moment, but in general useful. If PETSc = parallel should always hold, we can simplify much more
2021-02-22 18:07:21 +05:30
myStart, totalShape, loc_id,myShape,datasetName,parallel_default)
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
avoid HDF5 error in case of empty dataset
2022-10-20 00:16:17 +05:30
if (any(totalShape == 0)) return
documenting for doxygen
2020-03-15 17:16:10 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Dread_f(dset_id, H5T_NATIVE_INTEGER,dataset,totalShape, hdferr,&
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
file_space_id = filespace_id, xfer_prp = plist_id, mem_space_id = memspace_id)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
documenting for doxygen
2020-03-15 17:16:10 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
end subroutine HDF5_read_int2
adjusted variable names and added comments
2018-10-09 18:16:57 +05:30
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
cleaning
2019-06-11 13:18:07 +05:30
!> @brief read dataset of type integer with 3 dimensions
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
more meaningful order and intent(out) variables for read are at the front
2021-06-01 20:16:24 +05:30
subroutine HDF5_read_int3(dataset,loc_id,datasetName,parallel)
close all objects of type integer(HID_T) created by native hdf5 routines
2018-11-09 20:41:19 +05:30
documenting for doxygen
2020-03-15 17:16:10 +05:30
integer, intent(out), dimension(:,:,:) :: dataset !< data read from file
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
integer(HID_T), intent(in) :: loc_id !< file or group handle
character(len=*), intent(in) :: datasetName !< name of the dataset in the file
documenting for doxygen
2020-03-15 17:16:10 +05:30
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
supported by recent compilers
2021-07-24 18:05:17 +05:30
integer(HSIZE_T), dimension(rank(dataset)) :: &
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
myStart, &
myShape, & !< shape of the dataset (this process)
totalShape !< shape of the dataset (all processes)
integer :: hdferr
close all objects of type integer(HID_T) created by native hdf5 routines
2018-11-09 20:41:19 +05:30
avoid HDF5 error in case of empty dataset
2022-10-20 00:16:17 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
myShape = int(shape(dataset),HSIZE_T)
Interfacing for subroutines to identify real and integer data
2018-10-09 14:27:06 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
if (present(parallel)) then
call initialize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id, &
myStart, totalShape, loc_id,myShape,datasetName,parallel)
else
avoiding code duplication
2019-02-09 12:35:29 +05:30
call initialize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id, &
restore functionality to write non-parallel not needed at the moment, but in general useful. If PETSc = parallel should always hold, we can simplify much more
2021-02-22 18:07:21 +05:30
myStart, totalShape, loc_id,myShape,datasetName,parallel_default)
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
avoid HDF5 error in case of empty dataset
2022-10-20 00:16:17 +05:30
if (any(totalShape == 0)) return
documenting for doxygen
2020-03-15 17:16:10 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Dread_f(dset_id, H5T_NATIVE_INTEGER,dataset,totalShape, hdferr,&
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
file_space_id = filespace_id, xfer_prp = plist_id, mem_space_id = memspace_id)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
documenting for doxygen
2020-03-15 17:16:10 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)
close all objects of type integer(HID_T) created by native hdf5 routines
2018-11-09 20:41:19 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
end subroutine HDF5_read_int3
avoiding code duplication
2019-02-09 12:35:29 +05:30
Read and write works for all types of data in parallel with test module passed
2018-11-30 22:03:30 +05:30
!--------------------------------------------------------------------------------------------------
cleaning
2019-06-11 13:18:07 +05:30
!> @brief read dataset of type integer withh 4 dimensions
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
!--------------------------------------------------------------------------------------------------
more meaningful order and intent(out) variables for read are at the front
2021-06-01 20:16:24 +05:30
subroutine HDF5_read_int4(dataset,loc_id,datasetName,parallel)
Functionality to avoid creating datasets in HDF5 of zero dimensions
2018-11-26 20:08:31 +05:30
documenting for doxygen
2020-03-15 17:16:10 +05:30
integer, intent(out), dimension(:,:,:,:) :: dataset !< data read from file
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
integer(HID_T), intent(in) :: loc_id !< file or group handle
character(len=*), intent(in) :: datasetName !< name of the dataset in the file
documenting for doxygen
2020-03-15 17:16:10 +05:30
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
supported by recent compilers
2021-07-24 18:05:17 +05:30
integer(HSIZE_T), dimension(rank(dataset)) :: &
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
myStart, &
myShape, & !< shape of the dataset (this process)
totalShape !< shape of the dataset (all processes)
integer :: hdferr
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
avoid HDF5 error in case of empty dataset
2022-10-20 00:16:17 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
myShape = int(shape(dataset),HSIZE_T)
avoiding code duplication
2019-02-09 12:35:29 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
if (present(parallel)) then
call initialize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id, &
myStart, totalShape, loc_id,myShape,datasetName,parallel)
else
call initialize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id, &
restore functionality to write non-parallel not needed at the moment, but in general useful. If PETSc = parallel should always hold, we can simplify much more
2021-02-22 18:07:21 +05:30
myStart, totalShape, loc_id,myShape,datasetName,parallel_default)
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
avoid HDF5 error in case of empty dataset
2022-10-20 00:16:17 +05:30
if (any(totalShape == 0)) return
documenting for doxygen
2020-03-15 17:16:10 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Dread_f(dset_id, H5T_NATIVE_INTEGER,dataset,totalShape, hdferr,&
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
file_space_id = filespace_id, xfer_prp = plist_id, mem_space_id = memspace_id)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
documenting for doxygen
2020-03-15 17:16:10 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
end subroutine HDF5_read_int4
adjusted variable names and added comments
2018-10-09 18:16:57 +05:30
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
cleaning
2019-06-11 13:18:07 +05:30
!> @brief read dataset of type integer with 5 dimensions
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
more meaningful order and intent(out) variables for read are at the front
2021-06-01 20:16:24 +05:30
subroutine HDF5_read_int5(dataset,loc_id,datasetName,parallel)
close all objects of type integer(HID_T) created by native hdf5 routines
2018-11-09 20:41:19 +05:30
documenting for doxygen
2020-03-15 17:16:10 +05:30
integer, intent(out), dimension(:,:,:,:,:) :: dataset !< data read from file
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
integer(HID_T), intent(in) :: loc_id !< file or group handle
character(len=*), intent(in) :: datasetName !< name of the dataset in the file
documenting for doxygen
2020-03-15 17:16:10 +05:30
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
supported by recent compilers
2021-07-24 18:05:17 +05:30
integer(HSIZE_T), dimension(rank(dataset)) :: &
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
myStart, &
myShape, & !< shape of the dataset (this process)
totalShape !< shape of the dataset (all processes)
integer :: hdferr
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
avoid HDF5 error in case of empty dataset
2022-10-20 00:16:17 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
myShape = int(shape(dataset),HSIZE_T)
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
if (present(parallel)) then
call initialize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id, &
myStart, totalShape, loc_id,myShape,datasetName,parallel)
else
call initialize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id, &
restore functionality to write non-parallel not needed at the moment, but in general useful. If PETSc = parallel should always hold, we can simplify much more
2021-02-22 18:07:21 +05:30
myStart, totalShape, loc_id,myShape,datasetName,parallel_default)
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
avoid HDF5 error in case of empty dataset
2022-10-20 00:16:17 +05:30
if (any(totalShape == 0)) return
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Dread_f(dset_id, H5T_NATIVE_INTEGER,dataset,totalShape, hdferr,&
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
file_space_id = filespace_id, xfer_prp = plist_id, mem_space_id = memspace_id)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
documenting for doxygen
2020-03-15 17:16:10 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)
close all objects of type integer(HID_T) created by native hdf5 routines
2018-11-09 20:41:19 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
end subroutine HDF5_read_int5
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
writing of multidimensional dataset into hdf5 does not appear as multiple pages in hdfviewer
2018-09-25 20:12:43 +05:30
!--------------------------------------------------------------------------------------------------
cleaning
2019-06-11 13:18:07 +05:30
!> @brief read dataset of type integer with 6 dimensions
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
more meaningful order and intent(out) variables for read are at the front
2021-06-01 20:16:24 +05:30
subroutine HDF5_read_int6(dataset,loc_id,datasetName,parallel)
writing of multidimensional dataset into hdf5 does not appear as multiple pages in hdfviewer
2018-09-25 20:12:43 +05:30
documenting for doxygen
2020-03-15 17:16:10 +05:30
integer, intent(out), dimension(:,:,:,:,:,:) :: dataset !< data read from file
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
integer(HID_T), intent(in) :: loc_id !< file or group handle
character(len=*), intent(in) :: datasetName !< name of the dataset in the file
documenting for doxygen
2020-03-15 17:16:10 +05:30
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
supported by recent compilers
2021-07-24 18:05:17 +05:30
integer(HSIZE_T), dimension(rank(dataset)) :: &
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
myStart, &
myShape, & !< shape of the dataset (this process)
totalShape !< shape of the dataset (all processes)
integer :: hdferr
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
avoid HDF5 error in case of empty dataset
2022-10-20 00:16:17 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
myShape = int(shape(dataset),HSIZE_T)
if (any(myShape(1:size(myShape)-1) == 0)) return !< empty dataset (last dimension can be empty)
writing of multidimensional dataset into hdf5 does not appear as multiple pages in hdfviewer
2018-09-25 20:12:43 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
if (present(parallel)) then
call initialize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id, &
myStart, totalShape, loc_id,myShape,datasetName,parallel)
else
call initialize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id, &
restore functionality to write non-parallel not needed at the moment, but in general useful. If PETSc = parallel should always hold, we can simplify much more
2021-02-22 18:07:21 +05:30
myStart, totalShape, loc_id,myShape,datasetName,parallel_default)
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
avoid HDF5 error in case of empty dataset
2022-10-20 00:16:17 +05:30
if (any(totalShape == 0)) return
documenting for doxygen
2020-03-15 17:16:10 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Dread_f(dset_id, H5T_NATIVE_INTEGER,dataset,totalShape, hdferr,&
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
file_space_id = filespace_id, xfer_prp = plist_id, mem_space_id = memspace_id)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
documenting for doxygen
2020-03-15 17:16:10 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)
close all objects of type integer(HID_T) created by native hdf5 routines
2018-11-09 20:41:19 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
end subroutine HDF5_read_int6
[skip ci] [skip sc] generic interfaces for HDF5 operations most existing HDF5 functions are only designed for writing output files and more general functionality is needed for storing the restart data
2018-10-05 12:26:06 +05:30
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
cleaning
2019-06-11 13:18:07 +05:30
!> @brief read dataset of type integer with 7 dimensions
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
more meaningful order and intent(out) variables for read are at the front
2021-06-01 20:16:24 +05:30
subroutine HDF5_read_int7(dataset,loc_id,datasetName,parallel)
close all objects of type integer(HID_T) created by native hdf5 routines
2018-11-09 20:41:19 +05:30
documenting for doxygen
2020-03-15 17:16:10 +05:30
integer, intent(out), dimension(:,:,:,:,:,:,:) :: dataset !< data read from file
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
integer(HID_T), intent(in) :: loc_id !< file or group handle
character(len=*), intent(in) :: datasetName !< name of the dataset in the file
documenting for doxygen
2020-03-15 17:16:10 +05:30
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
supported by recent compilers
2021-07-24 18:05:17 +05:30
integer(HSIZE_T), dimension(rank(dataset)) :: &
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
myStart, &
myShape, & !< shape of the dataset (this process)
totalShape !< shape of the dataset (all processes)
integer :: hdferr
Parallel writing and reading of integer datasets working
2018-11-27 23:20:51 +05:30
avoid HDF5 error in case of empty dataset
2022-10-20 00:16:17 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
myShape = int(shape(dataset),HSIZE_T)
if (any(myShape(1:size(myShape)-1) == 0)) return !< empty dataset (last dimension can be empty)
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
if (present(parallel)) then
call initialize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id, &
myStart, totalShape, loc_id,myShape,datasetName,parallel)
else
call initialize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id, &
restore functionality to write non-parallel not needed at the moment, but in general useful. If PETSc = parallel should always hold, we can simplify much more
2021-02-22 18:07:21 +05:30
myStart, totalShape, loc_id,myShape,datasetName,parallel_default)
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
avoid HDF5 error in case of empty dataset
2022-10-20 00:16:17 +05:30
if (any(totalShape == 0)) return
documenting for doxygen
2020-03-15 17:16:10 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Dread_f(dset_id, H5T_NATIVE_INTEGER,dataset,totalShape, hdferr,&
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
file_space_id = filespace_id, xfer_prp = plist_id, mem_space_id = memspace_id)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
documenting for doxygen
2020-03-15 17:16:10 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
end subroutine HDF5_read_int7
parallel writing for pReal
2018-11-18 14:17:50 +05:30
assumed rank solution gives wrong results #194
2022-05-19 20:06:50 +05:30
#if defined(__GFORTRAN__)
finalize for write
2019-02-09 14:14:41 +05:30
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
cleaning
2019-06-11 13:18:07 +05:30
!> @brief write dataset of type real with 1 dimension
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
more meaningful order and intent(out) variables for read are at the front
2021-06-01 20:16:24 +05:30
subroutine HDF5_write_real1(dataset,loc_id,datasetName,parallel)
Made changes with the calling signature
2018-12-14 16:05:41 +05:30
only input
2021-01-27 00:48:04 +05:30
real(pReal), intent(in), dimension(:) :: dataset !< data written to file
integer(HID_T), intent(in) :: loc_id !< file or group handle
character(len=*), intent(in) :: datasetName !< name of the dataset in the file
documenting for doxygen
2020-03-15 17:16:10 +05:30
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
integer :: hdferr
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id
supported by recent compilers
2021-07-24 18:05:17 +05:30
integer(HSIZE_T), dimension(rank(dataset)) :: &
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
myStart, &
myShape, & !< shape of the dataset (this process)
totalShape !< shape of the dataset (all processes)
parallel writing for pReal
2018-11-18 14:17:50 +05:30
merged also finalization
2019-02-09 14:08:49 +05:30
!---------------------------------------------------------------------------------------------------
Functionality to avoid creating datasets in HDF5 of zero dimensions
2018-11-26 20:08:31 +05:30
! determine shape of dataset
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
myShape = int(shape(dataset),HSIZE_T)
if (any(myShape(1:size(myShape)-1) == 0)) return !< empty dataset (last dimension can be empty)
Functionality to avoid creating datasets in HDF5 of zero dimensions
2018-11-26 20:08:31 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
if (present(parallel)) then
call initialize_write(dset_id, filespace_id, memspace_id, plist_id, &
myStart, totalShape,loc_id,myShape,datasetName,H5T_NATIVE_DOUBLE,parallel)
else
call initialize_write(dset_id, filespace_id, memspace_id, plist_id, &
restore functionality to write non-parallel not needed at the moment, but in general useful. If PETSc = parallel should always hold, we can simplify much more
2021-02-22 18:07:21 +05:30
myStart, totalShape,loc_id,myShape,datasetName,H5T_NATIVE_DOUBLE,parallel_default)
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
if (product(totalShape) /= 0) then
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Dwrite_f(dset_id, H5T_NATIVE_DOUBLE,dataset,int(totalShape,HSIZE_T), hdferr,&
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
[skip ci] [skip sc] generic interfaces for HDF5 operations most existing HDF5 functions are only designed for writing output files and more general functionality is needed for storing the restart data
2018-10-05 12:26:06 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
call finalize_write(plist_id, dset_id, filespace_id, memspace_id)
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
end subroutine HDF5_write_real1
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
cleaning
2019-06-11 13:18:07 +05:30
!> @brief write dataset of type real with 2 dimensions
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
more meaningful order and intent(out) variables for read are at the front
2021-06-01 20:16:24 +05:30
subroutine HDF5_write_real2(dataset,loc_id,datasetName,parallel)
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
only input
2021-01-27 00:48:04 +05:30
real(pReal), intent(in), dimension(:,:) :: dataset !< data written to file
integer(HID_T), intent(in) :: loc_id !< file or group handle
character(len=*), intent(in) :: datasetName !< name of the dataset in the file
documenting for doxygen
2020-03-15 17:16:10 +05:30
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
integer :: hdferr
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id
supported by recent compilers
2021-07-24 18:05:17 +05:30
integer(HSIZE_T), dimension(rank(dataset)) :: &
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
myStart, &
myShape, & !< shape of the dataset (this process)
totalShape !< shape of the dataset (all processes)
parallel writing for pReal
2018-11-18 14:17:50 +05:30
merged also finalization
2019-02-09 14:08:49 +05:30
!---------------------------------------------------------------------------------------------------
Functionality to avoid creating datasets in HDF5 of zero dimensions
2018-11-26 20:08:31 +05:30
! determine shape of dataset
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
myShape = int(shape(dataset),HSIZE_T)
if (any(myShape(1:size(myShape)-1) == 0)) return !< empty dataset (last dimension can be empty)
Functionality to avoid creating datasets in HDF5 of zero dimensions
2018-11-26 20:08:31 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
if (present(parallel)) then
call initialize_write(dset_id, filespace_id, memspace_id, plist_id, &
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_DOUBLE,parallel)
else
call initialize_write(dset_id, filespace_id, memspace_id, plist_id, &
restore functionality to write non-parallel not needed at the moment, but in general useful. If PETSc = parallel should always hold, we can simplify much more
2021-02-22 18:07:21 +05:30
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_DOUBLE,parallel_default)
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
parallel writing for pReal
2018-11-18 14:17:50 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
if (product(totalShape) /= 0) then
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Dwrite_f(dset_id, H5T_NATIVE_DOUBLE,dataset,int(totalShape,HSIZE_T), hdferr,&
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
Interfacing for subroutines to identify real and integer data
2018-10-09 14:27:06 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
call finalize_write(plist_id, dset_id, filespace_id, memspace_id)
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
end subroutine HDF5_write_real2
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
cleaning
2019-06-11 13:18:07 +05:30
!> @brief write dataset of type real with 3 dimensions
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
more meaningful order and intent(out) variables for read are at the front
2021-06-01 20:16:24 +05:30
subroutine HDF5_write_real3(dataset,loc_id,datasetName,parallel)
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
only input
2021-01-27 00:48:04 +05:30
real(pReal), intent(in), dimension(:,:,:) :: dataset !< data written to file
integer(HID_T), intent(in) :: loc_id !< file or group handle
character(len=*), intent(in) :: datasetName !< name of the dataset in the file
documenting for doxygen
2020-03-15 17:16:10 +05:30
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
integer :: hdferr
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id
supported by recent compilers
2021-07-24 18:05:17 +05:30
integer(HSIZE_T), dimension(rank(dataset)) :: &
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
myStart, &
myShape, & !< shape of the dataset (this process)
totalShape !< shape of the dataset (all processes)
parallel writing for pReal
2018-11-18 14:17:50 +05:30
merged also finalization
2019-02-09 14:08:49 +05:30
!---------------------------------------------------------------------------------------------------
Functionality to avoid creating datasets in HDF5 of zero dimensions
2018-11-26 20:08:31 +05:30
! determine shape of dataset
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
myShape = int(shape(dataset),HSIZE_T)
if (any(myShape(1:size(myShape)-1) == 0)) return !< empty dataset (last dimension can be empty)
Functionality to avoid creating datasets in HDF5 of zero dimensions
2018-11-26 20:08:31 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
if (present(parallel)) then
call initialize_write(dset_id, filespace_id, memspace_id, plist_id, &
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_DOUBLE,parallel)
else
call initialize_write(dset_id, filespace_id, memspace_id, plist_id, &
restore functionality to write non-parallel not needed at the moment, but in general useful. If PETSc = parallel should always hold, we can simplify much more
2021-02-22 18:07:21 +05:30
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_DOUBLE,parallel_default)
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
if (product(totalShape) /= 0) then
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Dwrite_f(dset_id, H5T_NATIVE_DOUBLE,dataset,int(totalShape,HSIZE_T), hdferr,&
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
call finalize_write(plist_id, dset_id, filespace_id, memspace_id)
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
end subroutine HDF5_write_real3
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
cleaning
2019-06-11 13:18:07 +05:30
!> @brief write dataset of type real with 4 dimensions
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
more meaningful order and intent(out) variables for read are at the front
2021-06-01 20:16:24 +05:30
subroutine HDF5_write_real4(dataset,loc_id,datasetName,parallel)
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
only input
2021-01-27 00:48:04 +05:30
real(pReal), intent(in), dimension(:,:,:,:) :: dataset !< data written to file
integer(HID_T), intent(in) :: loc_id !< file or group handle
character(len=*), intent(in) :: datasetName !< name of the dataset in the file
documenting for doxygen
2020-03-15 17:16:10 +05:30
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
parallel writing for pReal
2018-11-18 14:17:50 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
integer :: hdferr
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id
supported by recent compilers
2021-07-24 18:05:17 +05:30
integer(HSIZE_T), dimension(rank(dataset)) :: &
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
myStart, &
myShape, & !< shape of the dataset (this process)
totalShape !< shape of the dataset (all processes)
parallel writing for pReal
2018-11-18 14:17:50 +05:30
merged also finalization
2019-02-09 14:08:49 +05:30
!---------------------------------------------------------------------------------------------------
Functionality to avoid creating datasets in HDF5 of zero dimensions
2018-11-26 20:08:31 +05:30
! determine shape of dataset
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
myShape = int(shape(dataset),HSIZE_T)
if (any(myShape(1:size(myShape)-1) == 0)) return !< empty dataset (last dimension can be empty)
documenting for doxygen
2020-03-15 17:16:10 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
if (present(parallel)) then
call initialize_write(dset_id, filespace_id, memspace_id, plist_id, &
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_DOUBLE,parallel)
else
call initialize_write(dset_id, filespace_id, memspace_id, plist_id, &
restore functionality to write non-parallel not needed at the moment, but in general useful. If PETSc = parallel should always hold, we can simplify much more
2021-02-22 18:07:21 +05:30
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_DOUBLE,parallel_default)
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
documenting for doxygen
2020-03-15 17:16:10 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
if (product(totalShape) /= 0) then
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Dwrite_f(dset_id, H5T_NATIVE_DOUBLE,dataset,int(totalShape,HSIZE_T), hdferr,&
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
documenting for doxygen
2020-03-15 17:16:10 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
call finalize_write(plist_id, dset_id, filespace_id, memspace_id)
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
end subroutine HDF5_write_real4
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
parallel writing for pReal
2018-11-18 14:17:50 +05:30
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
cleaning
2019-06-11 13:18:07 +05:30
!> @brief write dataset of type real with 5 dimensions
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
more meaningful order and intent(out) variables for read are at the front
2021-06-01 20:16:24 +05:30
subroutine HDF5_write_real5(dataset,loc_id,datasetName,parallel)
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
only input
2021-01-27 00:48:04 +05:30
real(pReal), intent(in), dimension(:,:,:,:,:) :: dataset !< data written to file
integer(HID_T), intent(in) :: loc_id !< file or group handle
character(len=*), intent(in) :: datasetName !< name of the dataset in the file
documenting for doxygen
2020-03-15 17:16:10 +05:30
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
parallel writing for pReal
2018-11-18 14:17:50 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
integer :: hdferr
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id
supported by recent compilers
2021-07-24 18:05:17 +05:30
integer(HSIZE_T), dimension(rank(dataset)) :: &
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
myStart, &
myShape, & !< shape of the dataset (this process)
totalShape !< shape of the dataset (all processes)
parallel writing for pReal
2018-11-18 14:17:50 +05:30
merged also finalization
2019-02-09 14:08:49 +05:30
!---------------------------------------------------------------------------------------------------
Functionality to avoid creating datasets in HDF5 of zero dimensions
2018-11-26 20:08:31 +05:30
! determine shape of dataset
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
myShape = int(shape(dataset),HSIZE_T)
if (any(myShape(1:size(myShape)-1) == 0)) return !< empty dataset (last dimension can be empty)
documenting for doxygen
2020-03-15 17:16:10 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
if (present(parallel)) then
call initialize_write(dset_id, filespace_id, memspace_id, plist_id, &
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_DOUBLE,parallel)
else
call initialize_write(dset_id, filespace_id, memspace_id, plist_id, &
restore functionality to write non-parallel not needed at the moment, but in general useful. If PETSc = parallel should always hold, we can simplify much more
2021-02-22 18:07:21 +05:30
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_DOUBLE,parallel_default)
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
documenting for doxygen
2020-03-15 17:16:10 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
if (product(totalShape) /= 0) then
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Dwrite_f(dset_id, H5T_NATIVE_DOUBLE,dataset,int(totalShape,HSIZE_T), hdferr,&
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
documenting for doxygen
2020-03-15 17:16:10 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
call finalize_write(plist_id, dset_id, filespace_id, memspace_id)
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
end subroutine HDF5_write_real5
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
cleaning
2019-06-11 13:18:07 +05:30
!> @brief write dataset of type real with 6 dimensions
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
more meaningful order and intent(out) variables for read are at the front
2021-06-01 20:16:24 +05:30
subroutine HDF5_write_real6(dataset,loc_id,datasetName,parallel)
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
only input
2021-01-27 00:48:04 +05:30
real(pReal), intent(in), dimension(:,:,:,:,:,:) :: dataset !< data written to file
integer(HID_T), intent(in) :: loc_id !< file or group handle
character(len=*), intent(in) :: datasetName !< name of the dataset in the file
documenting for doxygen
2020-03-15 17:16:10 +05:30
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
integer :: hdferr
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id
supported by recent compilers
2021-07-24 18:05:17 +05:30
integer(HSIZE_T), dimension(rank(dataset)) :: &
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
myStart, &
myShape, & !< shape of the dataset (this process)
totalShape !< shape of the dataset (all processes)
parallel writing for pReal
2018-11-18 14:17:50 +05:30
merged also finalization
2019-02-09 14:08:49 +05:30
!---------------------------------------------------------------------------------------------------
Functionality to avoid creating datasets in HDF5 of zero dimensions
2018-11-26 20:08:31 +05:30
! determine shape of dataset
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
myShape = int(shape(dataset),HSIZE_T)
if (any(myShape(1:size(myShape)-1) == 0)) return !< empty dataset (last dimension can be empty)
Functionality to avoid creating datasets in HDF5 of zero dimensions
2018-11-26 20:08:31 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
if (present(parallel)) then
call initialize_write(dset_id, filespace_id, memspace_id, plist_id, &
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_DOUBLE,parallel)
else
call initialize_write(dset_id, filespace_id, memspace_id, plist_id, &
restore functionality to write non-parallel not needed at the moment, but in general useful. If PETSc = parallel should always hold, we can simplify much more
2021-02-22 18:07:21 +05:30
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_DOUBLE,parallel_default)
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
parallel writing for pReal
2018-11-18 14:17:50 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
if (product(totalShape) /= 0) then
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Dwrite_f(dset_id, H5T_NATIVE_DOUBLE,dataset,int(totalShape,HSIZE_T), hdferr,&
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
documenting for doxygen
2020-03-15 17:16:10 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
call finalize_write(plist_id, dset_id, filespace_id, memspace_id)
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
end subroutine HDF5_write_real6
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
cleaning
2019-06-11 13:18:07 +05:30
!> @brief write dataset of type real with 7 dimensions
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
more meaningful order and intent(out) variables for read are at the front
2021-06-01 20:16:24 +05:30
subroutine HDF5_write_real7(dataset,loc_id,datasetName,parallel)
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
only input
2021-01-27 00:48:04 +05:30
real(pReal), intent(in), dimension(:,:,:,:,:,:,:) :: dataset !< data written to file
integer(HID_T), intent(in) :: loc_id !< file or group handle
character(len=*), intent(in) :: datasetName !< name of the dataset in the file
documenting for doxygen
2020-03-15 17:16:10 +05:30
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
parallel writing for pReal
2018-11-18 14:17:50 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
integer :: hdferr
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id
supported by recent compilers
2021-07-24 18:05:17 +05:30
integer(HSIZE_T), dimension(rank(dataset)) :: &
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
myStart, &
myShape, & !< shape of the dataset (this process)
totalShape !< shape of the dataset (all processes)
parallel writing for pReal
2018-11-18 14:17:50 +05:30
merged also finalization
2019-02-09 14:08:49 +05:30
!---------------------------------------------------------------------------------------------------
Functionality to avoid creating datasets in HDF5 of zero dimensions
2018-11-26 20:08:31 +05:30
! determine shape of dataset
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
myShape = int(shape(dataset),HSIZE_T)
if (any(myShape(1:size(myShape)-1) == 0)) return !< empty dataset (last dimension can be empty)
Functionality to avoid creating datasets in HDF5 of zero dimensions
2018-11-26 20:08:31 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
if (present(parallel)) then
call initialize_write(dset_id, filespace_id, memspace_id, plist_id, &
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_DOUBLE,parallel)
else
call initialize_write(dset_id, filespace_id, memspace_id, plist_id, &
restore functionality to write non-parallel not needed at the moment, but in general useful. If PETSc = parallel should always hold, we can simplify much more
2021-02-22 18:07:21 +05:30
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_DOUBLE,parallel_default)
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
if (product(totalShape) /= 0) then
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Dwrite_f(dset_id, H5T_NATIVE_DOUBLE,dataset,int(totalShape,HSIZE_T), hdferr,&
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
documenting for doxygen
2020-03-15 17:16:10 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
call finalize_write(plist_id, dset_id, filespace_id, memspace_id)
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
end subroutine HDF5_write_real7
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
avoid code duplication by using assumed rank "(..)" - lack of modern Fortran interface for HDF5 still requires branching to call the same code - not sure how to handle the read function (assumed rank and intent(out) ) does not work together
2022-04-18 16:46:45 +05:30
#else
!--------------------------------------------------------------------------------------------------
!> @brief write dataset of type real with 1-7 dimension
!--------------------------------------------------------------------------------------------------
subroutine HDF5_write_real(dataset,loc_id,datasetName,parallel)
real(pReal), intent(in), dimension(..) :: dataset !< data written to file
integer(HID_T), intent(in) :: loc_id !< file or group handle
character(len=*), intent(in) :: datasetName !< name of the dataset in the file
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
integer :: hdferr
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id
integer(HSIZE_T), dimension(rank(dataset)) :: &
myStart, &
myShape, & !< shape of the dataset (this process)
totalShape !< shape of the dataset (all processes)
!---------------------------------------------------------------------------------------------------
! determine shape of dataset
myShape = int(shape(dataset),HSIZE_T)
if (any(myShape(1:size(myShape)-1) == 0)) return !< empty dataset (last dimension can be empty)
if (present(parallel)) then
call initialize_write(dset_id, filespace_id, memspace_id, plist_id, &
myStart, totalShape,loc_id,myShape,datasetName,H5T_NATIVE_DOUBLE,parallel)
else
call initialize_write(dset_id, filespace_id, memspace_id, plist_id, &
myStart, totalShape,loc_id,myShape,datasetName,H5T_NATIVE_DOUBLE,parallel_default)
end if
if (product(totalShape) /= 0) then
select rank(dataset)
rank (1)
call H5Dwrite_f(dset_id, H5T_NATIVE_DOUBLE,dataset,int(totalShape,HSIZE_T), hdferr,&
file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
rank (2)
call H5Dwrite_f(dset_id, H5T_NATIVE_DOUBLE,dataset,int(totalShape,HSIZE_T), hdferr,&
file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
rank (3)
call H5Dwrite_f(dset_id, H5T_NATIVE_DOUBLE,dataset,int(totalShape,HSIZE_T), hdferr,&
file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
rank (4)
call H5Dwrite_f(dset_id, H5T_NATIVE_DOUBLE,dataset,int(totalShape,HSIZE_T), hdferr,&
file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
rank (5)
call H5Dwrite_f(dset_id, H5T_NATIVE_DOUBLE,dataset,int(totalShape,HSIZE_T), hdferr,&
file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
rank (6)
call H5Dwrite_f(dset_id, H5T_NATIVE_DOUBLE,dataset,int(totalShape,HSIZE_T), hdferr,&
file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
rank (7)
call H5Dwrite_f(dset_id, H5T_NATIVE_DOUBLE,dataset,int(totalShape,HSIZE_T), hdferr,&
file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
end select
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
avoid code duplication by using assumed rank "(..)" - lack of modern Fortran interface for HDF5 still requires branching to call the same code - not sure how to handle the read function (assumed rank and intent(out) ) does not work together
2022-04-18 16:46:45 +05:30
end if
call finalize_write(plist_id, dset_id, filespace_id, memspace_id)
end subroutine HDF5_write_real
#endif
using functions as far as possible
2019-02-09 16:15:02 +05:30
taking care of corner cases (e.g. restart) adjusting tests to take care of new 'setup' group
2021-07-27 15:29:46 +05:30
!--------------------------------------------------------------------------------------------------
!> @brief Write dataset of type string (scalar).
!> @details Not collective, must be called by one process at at time.
!--------------------------------------------------------------------------------------------------
write string, only from one MPI process needed to store simulation setup. I don't see a situation where strings are distributed over multiple processes
2021-07-27 02:09:23 +05:30
subroutine HDF5_write_str(dataset,loc_id,datasetName)
character(len=*), intent(in) :: dataset
integer(HID_T), intent(in) :: loc_id
character(len=*), intent(in) :: datasetName !< name of the dataset in the file
also compress string datasets results in different type (numpy string instead of numpy object), tests need to be adjusted
2021-08-14 19:58:51 +05:30
integer(HID_T) :: filetype_id, memtype_id, space_id, dataset_id, dcpl
play it safe
2021-07-27 13:20:23 +05:30
integer :: hdferr
also compress string datasets results in different type (numpy string instead of numpy object), tests need to be adjusted
2021-08-14 19:58:51 +05:30
character(len=len_trim(dataset),kind=C_CHAR), target :: dataset_
write string, only from one MPI process needed to store simulation setup. I don't see a situation where strings are distributed over multiple processes
2021-07-27 02:09:23 +05:30
also compress string datasets results in different type (numpy string instead of numpy object), tests need to be adjusted
2021-08-14 19:58:51 +05:30
dataset_ = trim(dataset)
play it safe
2021-07-27 13:20:23 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Tcopy_f(H5T_C_S1, filetype_id, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Tset_size_f(filetype_id, int(len(dataset_)+1,HSIZE_T), hdferr) ! +1 for NULL
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
play it safe
2021-07-27 13:20:23 +05:30
also compress string datasets results in different type (numpy string instead of numpy object), tests need to be adjusted
2021-08-14 19:58:51 +05:30
call H5Tcopy_f(H5T_FORTRAN_S1, memtype_id, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
also compress string datasets results in different type (numpy string instead of numpy object), tests need to be adjusted
2021-08-14 19:58:51 +05:30
call H5Tset_size_f(memtype_id, int(len(dataset_),HSIZE_T), hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
play it safe
2021-07-27 13:20:23 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Pcreate_f(H5P_DATASET_CREATE_F, dcpl, hdferr)
also compress string datasets results in different type (numpy string instead of numpy object), tests need to be adjusted
2021-08-14 19:58:51 +05:30
if (hdferr < 0) error stop 'HDF5 error'
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Pset_chunk_f(dcpl, 1, [1_HSIZE_T], hdferr)
also compress string datasets results in different type (numpy string instead of numpy object), tests need to be adjusted
2021-08-14 19:58:51 +05:30
if (hdferr < 0) error stop 'HDF5 error'
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Pset_Fletcher32_f(dcpl,hdferr)
also compress string datasets results in different type (numpy string instead of numpy object), tests need to be adjusted
2021-08-14 19:58:51 +05:30
if (hdferr < 0) error stop 'HDF5 error'
bugfix for HDF5 without deflate filter before inquiring whether a filter supports compression/decompression, we first need to check whether it is available at all to avoid raising an error. Extended the check to the shuffle filter
2021-12-02 17:30:59 +05:30
if (compression_possible .and. len(dataset) > 1024*256) then
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Pset_shuffle_f(dcpl, hdferr)
bugfix for HDF5 without deflate filter before inquiring whether a filter supports compression/decompression, we first need to check whether it is available at all to avoid raising an error. Extended the check to the shuffle filter
2021-12-02 17:30:59 +05:30
if (hdferr < 0) error stop 'HDF5 error'
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Pset_deflate_f(dcpl, 6, hdferr)
bugfix for HDF5 without deflate filter before inquiring whether a filter supports compression/decompression, we first need to check whether it is available at all to avoid raising an error. Extended the check to the shuffle filter
2021-12-02 17:30:59 +05:30
if (hdferr < 0) error stop 'HDF5 error'
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
also compress string datasets results in different type (numpy string instead of numpy object), tests need to be adjusted
2021-08-14 19:58:51 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Screate_simple_f(1, [1_HSIZE_T], space_id, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
CALL H5Dcreate_f(loc_id, datasetName, filetype_id, space_id, dataset_id, hdferr, dcpl)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
play it safe
2021-07-27 13:20:23 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Dwrite_f(dataset_id, memtype_id, c_loc(dataset_(1:1)), hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
write string, only from one MPI process needed to store simulation setup. I don't see a situation where strings are distributed over multiple processes
2021-07-27 02:09:23 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Pclose_f(dcpl, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Dclose_f(dataset_id, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Sclose_f(space_id, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Tclose_f(memtype_id, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Tclose_f(filetype_id, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
write string, only from one MPI process needed to store simulation setup. I don't see a situation where strings are distributed over multiple processes
2021-07-27 02:09:23 +05:30
end subroutine HDF5_write_str
assumed rank solution gives wrong results #194
2022-05-19 20:06:50 +05:30
#if defined(__GFORTRAN__)
write string, only from one MPI process needed to store simulation setup. I don't see a situation where strings are distributed over multiple processes
2021-07-27 02:09:23 +05:30
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
cleaning
2019-06-11 13:18:07 +05:30
!> @brief write dataset of type integer with 1 dimension
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
more meaningful order and intent(out) variables for read are at the front
2021-06-01 20:16:24 +05:30
subroutine HDF5_write_int1(dataset,loc_id,datasetName,parallel)
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
only input
2021-01-27 00:48:04 +05:30
integer, intent(in), dimension(:) :: dataset !< data written to file
integer(HID_T), intent(in) :: loc_id !< file or group handle
character(len=*), intent(in) :: datasetName !< name of the dataset in the file
documenting for doxygen
2020-03-15 17:16:10 +05:30
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
Added the parallelized functionality for integer datatypes (works for groups?)
2018-11-21 21:27:36 +05:30
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
integer :: hdferr
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id
supported by recent compilers
2021-07-24 18:05:17 +05:30
integer(HSIZE_T), dimension(rank(dataset)) :: &
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
myStart, &
myShape, & !< shape of the dataset (this process)
totalShape !< shape of the dataset (all processes)
Added the parallelized functionality for integer datatypes (works for groups?)
2018-11-21 21:27:36 +05:30
merged also finalization
2019-02-09 14:08:49 +05:30
!---------------------------------------------------------------------------------------------------
Functionality to avoid creating datasets in HDF5 of zero dimensions
2018-11-26 20:08:31 +05:30
! determine shape of dataset
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
myShape = int(shape(dataset),HSIZE_T)
if (any(myShape(1:size(myShape)-1) == 0)) return !< empty dataset (last dimension can be empty)
Added the parallelized functionality for integer datatypes (works for groups?)
2018-11-21 21:27:36 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
if (present(parallel)) then
call initialize_write(dset_id, filespace_id, memspace_id, plist_id, &
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_INTEGER,parallel)
else
call initialize_write(dset_id, filespace_id, memspace_id, plist_id, &
restore functionality to write non-parallel not needed at the moment, but in general useful. If PETSc = parallel should always hold, we can simplify much more
2021-02-22 18:07:21 +05:30
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_INTEGER,parallel_default)
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
Added the parallelized functionality for integer datatypes (works for groups?)
2018-11-21 21:27:36 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
if (product(totalShape) /= 0) then
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Dwrite_f(dset_id, H5T_NATIVE_INTEGER,dataset,int(totalShape,HSIZE_T), hdferr,&
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
documenting for doxygen
2020-03-15 17:16:10 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
call finalize_write(plist_id, dset_id, filespace_id, memspace_id)
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
end subroutine HDF5_write_int1
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
cleaning
2019-06-11 13:18:07 +05:30
!> @brief write dataset of type integer with 2 dimensions
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
more meaningful order and intent(out) variables for read are at the front
2021-06-01 20:16:24 +05:30
subroutine HDF5_write_int2(dataset,loc_id,datasetName,parallel)
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
only input
2021-01-27 00:48:04 +05:30
integer, intent(in), dimension(:,:) :: dataset !< data written to file
integer(HID_T), intent(in) :: loc_id !< file or group handle
character(len=*), intent(in) :: datasetName !< name of the dataset in the file
documenting for doxygen
2020-03-15 17:16:10 +05:30
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
Added the parallelized functionality for integer datatypes (works for groups?)
2018-11-21 21:27:36 +05:30
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
integer :: hdferr
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id
supported by recent compilers
2021-07-24 18:05:17 +05:30
integer(HSIZE_T), dimension(rank(dataset)) :: &
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
myStart, &
myShape, & !< shape of the dataset (this process)
totalShape !< shape of the dataset (all processes)
Added the parallelized functionality for integer datatypes (works for groups?)
2018-11-21 21:27:36 +05:30
merged also finalization
2019-02-09 14:08:49 +05:30
!---------------------------------------------------------------------------------------------------
Functionality to avoid creating datasets in HDF5 of zero dimensions
2018-11-26 20:08:31 +05:30
! determine shape of dataset
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
myShape = int(shape(dataset),HSIZE_T)
if (any(myShape(1:size(myShape)-1) == 0)) return !< empty dataset (last dimension can be empty)
Added the parallelized functionality for integer datatypes (works for groups?)
2018-11-21 21:27:36 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
if (present(parallel)) then
call initialize_write(dset_id, filespace_id, memspace_id, plist_id, &
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_INTEGER,parallel)
else
call initialize_write(dset_id, filespace_id, memspace_id, plist_id, &
restore functionality to write non-parallel not needed at the moment, but in general useful. If PETSc = parallel should always hold, we can simplify much more
2021-02-22 18:07:21 +05:30
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_INTEGER,parallel_default)
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
Added the parallelized functionality for integer datatypes (works for groups?)
2018-11-21 21:27:36 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
if (product(totalShape) /= 0) then
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Dwrite_f(dset_id, H5T_NATIVE_INTEGER,dataset,int(totalShape,HSIZE_T), hdferr,&
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
call finalize_write(plist_id, dset_id, filespace_id, memspace_id)
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
end subroutine HDF5_write_int2
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
cleaning
2019-06-11 13:18:07 +05:30
!> @brief write dataset of type integer with 3 dimensions
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
more meaningful order and intent(out) variables for read are at the front
2021-06-01 20:16:24 +05:30
subroutine HDF5_write_int3(dataset,loc_id,datasetName,parallel)
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
only input
2021-01-27 00:48:04 +05:30
integer, intent(in), dimension(:,:,:) :: dataset !< data written to file
integer(HID_T), intent(in) :: loc_id !< file or group handle
character(len=*), intent(in) :: datasetName !< name of the dataset in the file
documenting for doxygen
2020-03-15 17:16:10 +05:30
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
Added the parallelized functionality for integer datatypes (works for groups?)
2018-11-21 21:27:36 +05:30
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
integer :: hdferr
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id
supported by recent compilers
2021-07-24 18:05:17 +05:30
integer(HSIZE_T), dimension(rank(dataset)) :: &
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
myStart, &
myShape, & !< shape of the dataset (this process)
totalShape !< shape of the dataset (all processes)
Added the parallelized functionality for integer datatypes (works for groups?)
2018-11-21 21:27:36 +05:30
merged also finalization
2019-02-09 14:08:49 +05:30
!---------------------------------------------------------------------------------------------------
Functionality to avoid creating datasets in HDF5 of zero dimensions
2018-11-26 20:08:31 +05:30
! determine shape of dataset
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
myShape = int(shape(dataset),HSIZE_T)
if (any(myShape(1:size(myShape)-1) == 0)) return !< empty dataset (last dimension can be empty)
Added the parallelized functionality for integer datatypes (works for groups?)
2018-11-21 21:27:36 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
if (present(parallel)) then
call initialize_write(dset_id, filespace_id, memspace_id, plist_id, &
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_INTEGER,parallel)
else
call initialize_write(dset_id, filespace_id, memspace_id, plist_id, &
restore functionality to write non-parallel not needed at the moment, but in general useful. If PETSc = parallel should always hold, we can simplify much more
2021-02-22 18:07:21 +05:30
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_INTEGER,parallel_default)
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
Added the parallelized functionality for integer datatypes (works for groups?)
2018-11-21 21:27:36 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
if (product(totalShape) /= 0) then
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Dwrite_f(dset_id, H5T_NATIVE_INTEGER,dataset,int(totalShape,HSIZE_T), hdferr,&
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
documenting for doxygen
2020-03-15 17:16:10 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
call finalize_write(plist_id, dset_id, filespace_id, memspace_id)
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
end subroutine HDF5_write_int3
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
cleaning
2019-06-11 13:18:07 +05:30
!> @brief write dataset of type integer with 4 dimensions
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
more meaningful order and intent(out) variables for read are at the front
2021-06-01 20:16:24 +05:30
subroutine HDF5_write_int4(dataset,loc_id,datasetName,parallel)
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
only input
2021-01-27 00:48:04 +05:30
integer, intent(in), dimension(:,:,:,:) :: dataset !< data written to file
integer(HID_T), intent(in) :: loc_id !< file or group handle
character(len=*), intent(in) :: datasetName !< name of the dataset in the file
documenting for doxygen
2020-03-15 17:16:10 +05:30
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
Added the parallelized functionality for integer datatypes (works for groups?)
2018-11-21 21:27:36 +05:30
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
integer :: hdferr
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id
supported by recent compilers
2021-07-24 18:05:17 +05:30
integer(HSIZE_T), dimension(rank(dataset)) :: &
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
myStart, &
myShape, & !< shape of the dataset (this process)
totalShape !< shape of the dataset (all processes)
Added the parallelized functionality for integer datatypes (works for groups?)
2018-11-21 21:27:36 +05:30
merged also finalization
2019-02-09 14:08:49 +05:30
!---------------------------------------------------------------------------------------------------
Functionality to avoid creating datasets in HDF5 of zero dimensions
2018-11-26 20:08:31 +05:30
! determine shape of dataset
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
myShape = int(shape(dataset),HSIZE_T)
if (any(myShape(1:size(myShape)-1) == 0)) return !< empty dataset (last dimension can be empty)
Added the parallelized functionality for integer datatypes (works for groups?)
2018-11-21 21:27:36 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
if (present(parallel)) then
call initialize_write(dset_id, filespace_id, memspace_id, plist_id, &
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_INTEGER,parallel)
else
call initialize_write(dset_id, filespace_id, memspace_id, plist_id, &
restore functionality to write non-parallel not needed at the moment, but in general useful. If PETSc = parallel should always hold, we can simplify much more
2021-02-22 18:07:21 +05:30
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_INTEGER,parallel_default)
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
Added the parallelized functionality for integer datatypes (works for groups?)
2018-11-21 21:27:36 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
if (product(totalShape) /= 0) then
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Dwrite_f(dset_id, H5T_NATIVE_INTEGER,dataset,int(totalShape,HSIZE_T), hdferr,&
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
call finalize_write(plist_id, dset_id, filespace_id, memspace_id)
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
end subroutine HDF5_write_int4
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
cleaning
2019-06-11 13:18:07 +05:30
!> @brief write dataset of type integer with 5 dimensions
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
more meaningful order and intent(out) variables for read are at the front
2021-06-01 20:16:24 +05:30
subroutine HDF5_write_int5(dataset,loc_id,datasetName,parallel)
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
only input
2021-01-27 00:48:04 +05:30
integer, intent(in), dimension(:,:,:,:,:) :: dataset !< data written to file
integer(HID_T), intent(in) :: loc_id !< file or group handle
character(len=*), intent(in) :: datasetName !< name of the dataset in the file
documenting for doxygen
2020-03-15 17:16:10 +05:30
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
Added the parallelized functionality for integer datatypes (works for groups?)
2018-11-21 21:27:36 +05:30
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
integer :: hdferr
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id
supported by recent compilers
2021-07-24 18:05:17 +05:30
integer(HSIZE_T), dimension(rank(dataset)) :: &
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
myStart, &
myShape, & !< shape of the dataset (this process)
totalShape !< shape of the dataset (all processes)
Added the parallelized functionality for integer datatypes (works for groups?)
2018-11-21 21:27:36 +05:30
merged also finalization
2019-02-09 14:08:49 +05:30
!---------------------------------------------------------------------------------------------------
Functionality to avoid creating datasets in HDF5 of zero dimensions
2018-11-26 20:08:31 +05:30
! determine shape of dataset
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
myShape = int(shape(dataset),HSIZE_T)
if (any(myShape(1:size(myShape)-1) == 0)) return !< empty dataset (last dimension can be empty)
Added the parallelized functionality for integer datatypes (works for groups?)
2018-11-21 21:27:36 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
if (present(parallel)) then
call initialize_write(dset_id, filespace_id, memspace_id, plist_id, &
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_INTEGER,parallel)
else
call initialize_write(dset_id, filespace_id, memspace_id, plist_id, &
restore functionality to write non-parallel not needed at the moment, but in general useful. If PETSc = parallel should always hold, we can simplify much more
2021-02-22 18:07:21 +05:30
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_INTEGER,parallel_default)
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
Added the parallelized functionality for integer datatypes (works for groups?)
2018-11-21 21:27:36 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
if (product(totalShape) /= 0) then
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Dwrite_f(dset_id, H5T_NATIVE_INTEGER,dataset,int(totalShape,HSIZE_T), hdferr,&
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
call finalize_write(plist_id, dset_id, filespace_id, memspace_id)
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
end subroutine HDF5_write_int5
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
cleaning
2019-06-11 13:18:07 +05:30
!> @brief write dataset of type integer with 6 dimensions
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
more meaningful order and intent(out) variables for read are at the front
2021-06-01 20:16:24 +05:30
subroutine HDF5_write_int6(dataset,loc_id,datasetName,parallel)
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
only input
2021-01-27 00:48:04 +05:30
integer, intent(in), dimension(:,:,:,:,:,:) :: dataset !< data written to file
integer(HID_T), intent(in) :: loc_id !< file or group handle
character(len=*), intent(in) :: datasetName !< name of the dataset in the file
documenting for doxygen
2020-03-15 17:16:10 +05:30
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
Added the parallelized functionality for integer datatypes (works for groups?)
2018-11-21 21:27:36 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
integer :: hdferr
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id
supported by recent compilers
2021-07-24 18:05:17 +05:30
integer(HSIZE_T), dimension(rank(dataset)) :: &
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
myStart, &
myShape, & !< shape of the dataset (this process)
totalShape !< shape of the dataset (all processes)
Added the parallelized functionality for integer datatypes (works for groups?)
2018-11-21 21:27:36 +05:30
merged also finalization
2019-02-09 14:08:49 +05:30
!---------------------------------------------------------------------------------------------------
Functionality to avoid creating datasets in HDF5 of zero dimensions
2018-11-26 20:08:31 +05:30
! determine shape of dataset
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
myShape = int(shape(dataset),HSIZE_T)
if (any(myShape(1:size(myShape)-1) == 0)) return !< empty dataset (last dimension can be empty)
Added the parallelized functionality for integer datatypes (works for groups?)
2018-11-21 21:27:36 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
if (present(parallel)) then
call initialize_write(dset_id, filespace_id, memspace_id, plist_id, &
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_INTEGER,parallel)
else
call initialize_write(dset_id, filespace_id, memspace_id, plist_id, &
restore functionality to write non-parallel not needed at the moment, but in general useful. If PETSc = parallel should always hold, we can simplify much more
2021-02-22 18:07:21 +05:30
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_INTEGER,parallel_default)
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
Added the parallelized functionality for integer datatypes (works for groups?)
2018-11-21 21:27:36 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
if (product(totalShape) /= 0) then
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Dwrite_f(dset_id, H5T_NATIVE_INTEGER,dataset,int(totalShape,HSIZE_T), hdferr,&
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
call finalize_write(plist_id, dset_id, filespace_id, memspace_id)
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
end subroutine HDF5_write_int6
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
cleaning
2019-06-11 13:18:07 +05:30
!> @brief write dataset of type integer with 7 dimensions
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
!--------------------------------------------------------------------------------------------------
more meaningful order and intent(out) variables for read are at the front
2021-06-01 20:16:24 +05:30
subroutine HDF5_write_int7(dataset,loc_id,datasetName,parallel)
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
only input
2021-01-27 00:48:04 +05:30
integer, intent(in), dimension(:,:,:,:,:,:,:) :: dataset !< data written to file
integer(HID_T), intent(in) :: loc_id !< file or group handle
character(len=*), intent(in) :: datasetName !< name of the dataset in the file
documenting for doxygen
2020-03-15 17:16:10 +05:30
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
Added the parallelized functionality for integer datatypes (works for groups?)
2018-11-21 21:27:36 +05:30
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
integer :: hdferr
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id
supported by recent compilers
2021-07-24 18:05:17 +05:30
integer(HSIZE_T), dimension(rank(dataset)) :: &
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
myStart, &
myShape, & !< shape of the dataset (this process)
totalShape !< shape of the dataset (all processes)
Added the parallelized functionality for integer datatypes (works for groups?)
2018-11-21 21:27:36 +05:30
merged also finalization
2019-02-09 14:08:49 +05:30
!---------------------------------------------------------------------------------------------------
Functionality to avoid creating datasets in HDF5 of zero dimensions
2018-11-26 20:08:31 +05:30
! determine shape of dataset
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
myShape = int(shape(dataset),HSIZE_T)
if (any(myShape(1:size(myShape)-1) == 0)) return !< empty dataset (last dimension can be empty)
Added the parallelized functionality for integer datatypes (works for groups?)
2018-11-21 21:27:36 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
if (present(parallel)) then
call initialize_write(dset_id, filespace_id, memspace_id, plist_id, &
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_INTEGER,parallel)
else
call initialize_write(dset_id, filespace_id, memspace_id, plist_id, &
restore functionality to write non-parallel not needed at the moment, but in general useful. If PETSc = parallel should always hold, we can simplify much more
2021-02-22 18:07:21 +05:30
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_INTEGER,parallel_default)
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
Added the parallelized functionality for integer datatypes (works for groups?)
2018-11-21 21:27:36 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
if (product(totalShape) /= 0) then
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Dwrite_f(dset_id, H5T_NATIVE_INTEGER,dataset,int(totalShape,HSIZE_T), hdferr,&
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
implicit none only needed once per module
2019-04-07 17:35:31 +05:30
call finalize_write(plist_id, dset_id, filespace_id, memspace_id)
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
avoid checking of unitialized variables
2019-04-04 15:19:23 +05:30
end subroutine HDF5_write_int7
reading and writing of subroutines of datasets of different ranks
2018-10-10 21:24:55 +05:30
avoid code duplication by using assumed rank "(..)" - lack of modern Fortran interface for HDF5 still requires branching to call the same code - not sure how to handle the read function (assumed rank and intent(out) ) does not work together
2022-04-18 16:46:45 +05:30
#else
!--------------------------------------------------------------------------------------------------
!> @brief write dataset of type integer with 1-7 dimension
!--------------------------------------------------------------------------------------------------
subroutine HDF5_write_int(dataset,loc_id,datasetName,parallel)
integer, intent(in), dimension(..) :: dataset !< data written to file
integer(HID_T), intent(in) :: loc_id !< file or group handle
character(len=*), intent(in) :: datasetName !< name of the dataset in the file
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
integer :: hdferr
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id
integer(HSIZE_T), dimension(rank(dataset)) :: &
myStart, &
myShape, & !< shape of the dataset (this process)
totalShape !< shape of the dataset (all processes)
!---------------------------------------------------------------------------------------------------
! determine shape of dataset
myShape = int(shape(dataset),HSIZE_T)
if (any(myShape(1:size(myShape)-1) == 0)) return !< empty dataset (last dimension can be empty)
if (present(parallel)) then
call initialize_write(dset_id, filespace_id, memspace_id, plist_id, &
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_INTEGER,parallel)
else
call initialize_write(dset_id, filespace_id, memspace_id, plist_id, &
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_INTEGER,parallel_default)
end if
if (product(totalShape) /= 0) then
select rank(dataset)
rank(1)
call H5Dwrite_f(dset_id, H5T_NATIVE_INTEGER,dataset,int(totalShape,HSIZE_T), hdferr,&
file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
rank(2)
call H5Dwrite_f(dset_id, H5T_NATIVE_INTEGER,dataset,int(totalShape,HSIZE_T), hdferr,&
file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
rank(3)
call H5Dwrite_f(dset_id, H5T_NATIVE_INTEGER,dataset,int(totalShape,HSIZE_T), hdferr,&
file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
rank(4)
call H5Dwrite_f(dset_id, H5T_NATIVE_INTEGER,dataset,int(totalShape,HSIZE_T), hdferr,&
file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
rank(5)
call H5Dwrite_f(dset_id, H5T_NATIVE_INTEGER,dataset,int(totalShape,HSIZE_T), hdferr,&
file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
rank(6)
call H5Dwrite_f(dset_id, H5T_NATIVE_INTEGER,dataset,int(totalShape,HSIZE_T), hdferr,&
file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
rank(7)
call H5Dwrite_f(dset_id, H5T_NATIVE_INTEGER,dataset,int(totalShape,HSIZE_T), hdferr,&
file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
end select
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
avoid code duplication by using assumed rank "(..)" - lack of modern Fortran interface for HDF5 still requires branching to call the same code - not sure how to handle the read function (assumed rank and intent(out) ) does not work together
2022-04-18 16:46:45 +05:30
end if
call finalize_write(plist_id, dset_id, filespace_id, memspace_id)
end subroutine HDF5_write_int
#endif
number of helper functions for HDF5
2018-08-03 12:23:37 +05:30
avoiding code duplication
2019-02-09 12:35:29 +05:30
!--------------------------------------------------------------------------------------------------
using functions as far as possible
2019-02-09 16:15:02 +05:30
!> @brief initialize HDF5 handles, determines global shape and start for parallel read
avoiding code duplication
2019-02-09 12:35:29 +05:30
!--------------------------------------------------------------------------------------------------
subroutine initialize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id, &
myStart, globalShape, &
loc_id,localShape,datasetName,parallel)
white space adjustments
2019-06-15 20:12:16 +05:30
integer(HID_T), intent(in) :: loc_id !< file or group handle
character(len=*), intent(in) :: datasetName !< name of the dataset in the file
logical, intent(in) :: parallel
integer(HSIZE_T), intent(in), dimension(:) :: &
documenting for doxygen
2020-03-15 17:16:10 +05:30
localShape
white space adjustments
2019-06-15 20:12:16 +05:30
integer(HSIZE_T), intent(out), dimension(size(localShape,1)):: &
myStart, &
default integer, PETSc integer, and MPI integer might be different
2022-01-13 15:11:36 +05:30
globalShape !< shape of the dataset (all processes)
white space adjustments
2019-06-15 20:12:16 +05:30
integer(HID_T), intent(out) :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
documenting for doxygen
2020-03-15 17:16:10 +05:30
use modern Fortran interface not possible for HDF5...
2022-02-05 23:02:17 +05:30
integer(MPI_INTEGER_KIND), dimension(worldsize) :: &
white space adjustments
2019-06-15 20:12:16 +05:30
readSize !< contribution of all processes
integer :: hdferr
default integer, PETSc integer, and MPI integer might be different
2022-01-13 15:11:36 +05:30
integer(MPI_INTEGER_KIND) :: err_MPI
documenting for doxygen
2020-03-15 17:16:10 +05:30
avoiding code duplication
2019-02-09 12:35:29 +05:30
!-------------------------------------------------------------------------------------------------
using functions as far as possible
2019-02-09 16:15:02 +05:30
! creating a property list for transfer properties (is collective for MPI)
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Pcreate_f(H5P_DATASET_XFER_F, plist_id, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
avoiding code duplication
2019-02-09 12:35:29 +05:30
!--------------------------------------------------------------------------------------------------
use modern Fortran interface not possible for HDF5...
2022-02-05 23:02:17 +05:30
readSize = 0_MPI_INTEGER_KIND
readSize(worldrank+1) = int(localShape(ubound(localShape,1)),MPI_INTEGER_KIND)
consistent capitalization
2021-07-08 18:35:01 +05:30
#ifdef PETSC
white space adjustments
2019-06-15 20:12:16 +05:30
if (parallel) then
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Pset_dxpl_mpio_f(plist_id, H5FD_MPIO_COLLECTIVE_F, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
use modern Fortran interface not possible for HDF5...
2022-02-05 23:02:17 +05:30
call MPI_Allreduce(MPI_IN_PLACE,readSize,worldsize,MPI_INTEGER,MPI_SUM,MPI_COMM_WORLD,err_MPI) ! get total output size over each process
default integer, PETSc integer, and MPI integer might be different
2022-01-13 15:11:36 +05:30
if (err_MPI /= 0_MPI_INTEGER_KIND) error stop 'MPI error'
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
avoiding code duplication
2019-02-09 12:35:29 +05:30
#endif
white space adjustments
2019-06-15 20:12:16 +05:30
myStart = int(0,HSIZE_T)
myStart(ubound(myStart)) = int(sum(readSize(1:worldrank)),HSIZE_T)
globalShape = [localShape(1:ubound(localShape,1)-1),int(sum(readSize),HSIZE_T)]
avoiding code duplication
2019-02-09 12:35:29 +05:30
avoid HDF5 error in case of empty dataset
2022-10-20 00:16:17 +05:30
if (any(globalShape == 0)) then
call H5Pclose_f(plist_id, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
avoid HDF5 error in case of empty dataset
2022-10-20 00:16:17 +05:30
return
end if
avoiding code duplication
2019-02-09 12:35:29 +05:30
!--------------------------------------------------------------------------------------------------
! create dataspace in memory (local shape)
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Screate_simple_f(size(localShape), localShape, memspace_id, hdferr, localShape)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
using functions as far as possible
2019-02-09 16:15:02 +05:30
avoiding code duplication
2019-02-09 12:35:29 +05:30
!--------------------------------------------------------------------------------------------------
using functions as far as possible
2019-02-09 16:15:02 +05:30
! creating a property list for IO and set it to collective
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Pcreate_f(H5P_DATASET_ACCESS_F, aplist_id, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
consistent capitalization
2021-07-08 18:35:01 +05:30
#ifdef PETSC
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Pset_all_coll_metadata_ops_f(aplist_id, .true., hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
required for HDF5 output
2019-03-09 21:21:50 +05:30
#endif
avoiding code duplication
2019-02-09 12:35:29 +05:30
!--------------------------------------------------------------------------------------------------
using functions as far as possible
2019-02-09 16:15:02 +05:30
! open the dataset in the file and get the space ID
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Dopen_f(loc_id,datasetName,dset_id,hdferr, dapl_id = aplist_id)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Dget_space_f(dset_id, filespace_id, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
avoiding code duplication
2019-02-09 12:35:29 +05:30
!--------------------------------------------------------------------------------------------------
! select a hyperslab (the portion of the current process) in the file
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Sselect_hyperslab_f(filespace_id, H5S_SELECT_SET_F, myStart, localShape, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
avoiding code duplication
2019-02-09 12:35:29 +05:30
end subroutine initialize_read
also modularize write
2019-02-09 13:31:37 +05:30
!--------------------------------------------------------------------------------------------------
using functions as far as possible
2019-02-09 16:15:02 +05:30
!> @brief closes HDF5 handles
merged also finalization
2019-02-09 14:08:49 +05:30
!--------------------------------------------------------------------------------------------------
subroutine finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)
compress. Datasets are chunked along first timension. Chunk size (1MB for real) is probably not optimal
2020-12-06 14:50:32 +05:30
integer(HID_T), intent(in) :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
white space adjustments
2019-06-15 20:12:16 +05:30
integer :: hdferr
merged also finalization
2019-02-09 14:08:49 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Pclose_f(plist_id, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Pclose_f(aplist_id, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Dclose_f(dset_id, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Sclose_f(filespace_id, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Sclose_f(memspace_id, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
merged also finalization
2019-02-09 14:08:49 +05:30
end subroutine finalize_read
using functions as far as possible
2019-02-09 16:15:02 +05:30
merged also finalization
2019-02-09 14:08:49 +05:30
!--------------------------------------------------------------------------------------------------
using functions as far as possible
2019-02-09 16:15:02 +05:30
!> @brief initialize HDF5 handles, determines global shape and start for parallel write
also modularize write
2019-02-09 13:31:37 +05:30
!--------------------------------------------------------------------------------------------------
subroutine initialize_write(dset_id, filespace_id, memspace_id, plist_id, &
compress. Datasets are chunked along first timension. Chunk size (1MB for real) is probably not optimal
2020-12-06 14:50:32 +05:30
myStart, totalShape, &
loc_id,myShape,datasetName,datatype,parallel)
also modularize write
2019-02-09 13:31:37 +05:30
white space adjustments
2019-06-15 20:12:16 +05:30
integer(HID_T), intent(in) :: loc_id !< file or group handle
character(len=*), intent(in) :: datasetName !< name of the dataset in the file
logical, intent(in) :: parallel
integer(HID_T), intent(in) :: datatype
integer(HSIZE_T), intent(in), dimension(:) :: &
documenting for doxygen
2020-03-15 17:16:10 +05:30
myShape
white space adjustments
2019-06-15 20:12:16 +05:30
integer(HSIZE_T), intent(out), dimension(size(myShape,1)):: &
myStart, &
totalShape !< shape of the dataset (all processes)
integer(HID_T), intent(out) :: dset_id, filespace_id, memspace_id, plist_id
documenting for doxygen
2020-03-15 17:16:10 +05:30
use modern Fortran interface not possible for HDF5...
2022-02-05 23:02:17 +05:30
integer(MPI_INTEGER_KIND), dimension(worldsize) :: writeSize !< contribution of all processes
integer(HID_T) :: dcpl
default integer, PETSc integer, and MPI integer might be different
2022-01-13 15:11:36 +05:30
integer :: hdferr
integer(MPI_INTEGER_KIND) :: err_MPI
compress. Datasets are chunked along first timension. Chunk size (1MB for real) is probably not optimal
2020-12-06 14:50:32 +05:30
integer(HSIZE_T), parameter :: chunkSize = 1024_HSIZE_T**2/8_HSIZE_T
also modularize write
2019-02-09 13:31:37 +05:30
always chunk data for small datasets: - only one chunk - no compression
2021-08-14 18:37:01 +05:30
also modularize write
2019-02-09 13:31:37 +05:30
!-------------------------------------------------------------------------------------------------
write string, only from one MPI process needed to store simulation setup. I don't see a situation where strings are distributed over multiple processes
2021-07-27 02:09:23 +05:30
! creating a property list for transfer properties (is collective when writing in parallel)
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Pcreate_f(H5P_DATASET_XFER_F, plist_id, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
consistent capitalization
2021-07-08 18:35:01 +05:30
#ifdef PETSC
white space adjustments
2019-06-15 20:12:16 +05:30
if (parallel) then
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Pset_dxpl_mpio_f(plist_id, H5FD_MPIO_COLLECTIVE_F, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
consistent space (as in 'end module' etc)
2021-12-06 12:27:31 +05:30
end if
avoid error for empty datasets
2019-04-04 13:33:52 +05:30
#endif
also modularize write
2019-02-09 13:31:37 +05:30
!--------------------------------------------------------------------------------------------------
avoid error for empty datasets
2019-04-04 13:33:52 +05:30
! determine the global data layout among all processes
use modern Fortran interface not possible for HDF5...
2022-02-05 23:02:17 +05:30
writeSize = 0_MPI_INTEGER_KIND
writeSize(worldrank+1) = int(myShape(ubound(myShape,1)),MPI_INTEGER_KIND)
consistent capitalization
2021-07-08 18:35:01 +05:30
#ifdef PETSC
white space adjustments
2019-06-15 20:12:16 +05:30
if (parallel) then
use modern Fortran interface not possible for HDF5...
2022-02-05 23:02:17 +05:30
call MPI_Allreduce(MPI_IN_PLACE,writeSize,worldsize,MPI_INTEGER,MPI_SUM,MPI_COMM_WORLD,err_MPI) ! get total output size over each process
default integer, PETSc integer, and MPI integer might be different
2022-01-13 15:11:36 +05:30
if (err_MPI /= 0_MPI_INTEGER_KIND) error stop 'MPI error'
bugfix for HDF5 without deflate filter before inquiring whether a filter supports compression/decompression, we first need to check whether it is available at all to avoid raising an error. Extended the check to the shuffle filter
2021-12-02 17:30:59 +05:30
end if
also modularize write
2019-02-09 13:31:37 +05:30
#endif
white space adjustments
2019-06-15 20:12:16 +05:30
myStart = int(0,HSIZE_T)
myStart(ubound(myStart)) = int(sum(writeSize(1:worldrank)),HSIZE_T)
totalShape = [myShape(1:ubound(myShape,1)-1),int(sum(writeSize),HSIZE_T)]
also modularize write
2019-02-09 13:31:37 +05:30
compress. Datasets are chunked along first timension. Chunk size (1MB for real) is probably not optimal
2020-12-06 14:50:32 +05:30
!--------------------------------------------------------------------------------------------------
always chunk data for small datasets: - only one chunk - no compression
2021-08-14 18:37:01 +05:30
! chunk dataset, enable compression for larger datasets
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Pcreate_f(H5P_DATASET_CREATE_F, dcpl, hdferr)
always chunk data for small datasets: - only one chunk - no compression
2021-08-14 18:37:01 +05:30
if (hdferr < 0) error stop 'HDF5 error'
avoid errors for empty datasets empty dataset cannot be chunked, but filters can only be applied to chunked datasets
2021-08-15 00:14:59 +05:30
if (product(totalShape) > 0) then
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Pset_Fletcher32_f(dcpl,hdferr)
avoid errors for empty datasets empty dataset cannot be chunked, but filters can only be applied to chunked datasets
2021-08-15 00:14:59 +05:30
if (hdferr < 0) error stop 'HDF5 error'
always chunk data for small datasets: - only one chunk - no compression
2021-08-14 18:37:01 +05:30
avoid errors for empty datasets empty dataset cannot be chunked, but filters can only be applied to chunked datasets
2021-08-15 00:14:59 +05:30
if (product(totalShape) >= chunkSize*2_HSIZE_T) then
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Pset_chunk_f(dcpl, size(totalShape), getChunks(totalShape,chunkSize), hdferr)
avoid errors for empty datasets empty dataset cannot be chunked, but filters can only be applied to chunked datasets
2021-08-15 00:14:59 +05:30
if (hdferr < 0) error stop 'HDF5 error'
bugfix for HDF5 without deflate filter before inquiring whether a filter supports compression/decompression, we first need to check whether it is available at all to avoid raising an error. Extended the check to the shuffle filter
2021-12-02 17:30:59 +05:30
if (compression_possible) then
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Pset_shuffle_f(dcpl, hdferr)
bugfix for HDF5 without deflate filter before inquiring whether a filter supports compression/decompression, we first need to check whether it is available at all to avoid raising an error. Extended the check to the shuffle filter
2021-12-02 17:30:59 +05:30
if (hdferr < 0) error stop 'HDF5 error'
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Pset_deflate_f(dcpl, 6, hdferr)
bugfix for HDF5 without deflate filter before inquiring whether a filter supports compression/decompression, we first need to check whether it is available at all to avoid raising an error. Extended the check to the shuffle filter
2021-12-02 17:30:59 +05:30
if (hdferr < 0) error stop 'HDF5 error'
end if
avoid errors for empty datasets empty dataset cannot be chunked, but filters can only be applied to chunked datasets
2021-08-15 00:14:59 +05:30
else
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Pset_chunk_f(dcpl, size(totalShape), totalShape, hdferr)
bugfix for HDF5 without deflate filter before inquiring whether a filter supports compression/decompression, we first need to check whether it is available at all to avoid raising an error. Extended the check to the shuffle filter
2021-12-02 17:30:59 +05:30
if (hdferr < 0) error stop 'HDF5 error'
end if
end if
use modern Fortran interface not possible for HDF5...
2022-02-05 23:02:17 +05:30
also modularize write
2019-02-09 13:31:37 +05:30
!--------------------------------------------------------------------------------------------------
using functions as far as possible
2019-02-09 16:15:02 +05:30
! create dataspace in memory (local shape) and in file (global shape)
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Screate_simple_f(size(myShape), myShape, memspace_id, hdferr, myShape)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Screate_simple_f(size(totalShape), totalShape, filespace_id, hdferr, totalShape)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
also modularize write
2019-02-09 13:31:37 +05:30
!--------------------------------------------------------------------------------------------------
avoid error for empty datasets
2019-04-04 13:33:52 +05:30
! create dataset in the file and select a hyperslab from it (the portion of the current process)
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Dcreate_f(loc_id, trim(datasetName), datatype, filespace_id, dset_id, hdferr, dcpl)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Sselect_hyperslab_f(filespace_id, H5S_SELECT_SET_F, myStart, myShape, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
avoid error for empty datasets
2019-04-04 13:33:52 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Pclose_f(dcpl , hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
compress. Datasets are chunked along first timension. Chunk size (1MB for real) is probably not optimal
2020-12-06 14:50:32 +05:30
only used in one function
2020-12-10 05:01:58 +05:30
contains
!------------------------------------------------------------------------------------------------
!> @brief determine chunk layout
!------------------------------------------------------------------------------------------------
pure function getChunks(totalShape,chunkSize)
integer(HSIZE_T), dimension(:), intent(in) :: totalShape
integer(HSIZE_T), intent(in) :: chunkSize
integer(HSIZE_T), dimension(size(totalShape)) :: getChunks
getChunks = [totalShape(1:size(totalShape)-1),&
chunkSize/product(totalShape(1:size(totalShape)-1))]
end function getChunks
also modularize write
2019-02-09 13:31:37 +05:30
end subroutine initialize_write
finalize for write
2019-02-09 14:14:41 +05:30
!--------------------------------------------------------------------------------------------------
using functions as far as possible
2019-02-09 16:15:02 +05:30
!> @brief closes HDF5 handles
finalize for write
2019-02-09 14:14:41 +05:30
!--------------------------------------------------------------------------------------------------
subroutine finalize_write(plist_id, dset_id, filespace_id, memspace_id)
Made changes with the calling signature
2018-12-14 16:05:41 +05:30
white space adjustments
2019-06-15 20:12:16 +05:30
integer(HID_T), intent(in) :: dset_id, filespace_id, memspace_id, plist_id
integer :: hdferr
Made changes with the calling signature
2018-12-14 16:05:41 +05:30
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Pclose_f(plist_id, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Dclose_f(dset_id, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Sclose_f(filespace_id, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
capitalize HDF5 prefix
2021-12-06 12:22:37 +05:30
call H5Sclose_f(memspace_id, hdferr)
Fortran style adjustments
2022-12-07 22:59:03 +05:30
if (hdferr < 0) error stop 'HDF5 error'
Made changes with the calling signature
2018-12-14 16:05:41 +05:30
finalize for write
2019-02-09 14:14:41 +05:30
end subroutine finalize_write
white space adjustments
2019-06-15 20:12:16 +05:30
compress. Datasets are chunked along first timension. Chunk size (1MB for real) is probably not optimal
2020-12-06 14:50:32 +05:30
finalize for write
2019-02-09 14:14:41 +05:30
end module HDF5_Utilities