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
|
|
|
|
|
!--------------------------------------------------------------------------------------------------
|
2018-11-15 11:58:34 +05:30
|
|
|
module HDF5_utilities
|
2019-06-06 14:11:56 +05:30
|
|
|
use HDF5
|
2018-08-05 10:11:35 +05:30
|
|
|
#ifdef PETSc
|
2019-04-04 15:19:23 +05:30
|
|
|
use PETSC
|
2018-08-05 10:11:35 +05:30
|
|
|
#endif
|
2018-08-03 12:23:37 +05:30
|
|
|
|
2019-06-12 23:29:17 +05:30
|
|
|
use prec
|
2020-09-13 13:49:38 +05:30
|
|
|
use parallelization
|
2019-06-12 23:29:17 +05:30
|
|
|
|
2020-11-11 14:49:47 +05:30
|
|
|
implicit none
|
|
|
|
|
public
|
2018-08-03 12:23:37 +05:30
|
|
|
|
2018-10-09 18:16:57 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-06-15 20:12:16 +05:30
|
|
|
!> @brief reads integer or float data of defined shape from file ! ToDo: order of arguments wrong
|
2019-02-09 14:14:41 +05:30
|
|
|
!> @details for parallel IO, all dimension except for the last need to match
|
2018-10-09 18:16:57 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
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
|
2020-03-15 17:16:10 +05:30
|
|
|
|
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
|
2018-10-09 14:27:06 +05:30
|
|
|
|
2018-10-09 18:16:57 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-06-15 20:12:16 +05:30
|
|
|
!> @brief writes integer or real data of defined shape to file ! ToDo: order of arguments wrong
|
2019-02-09 14:14:41 +05:30
|
|
|
!> @details for parallel IO, all dimension except for the last need to match
|
2018-10-09 18:16:57 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-04-04 15:19:23 +05:30
|
|
|
interface HDF5_write
|
|
|
|
|
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
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
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
|
|
|
|
|
end interface HDF5_write
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2018-12-15 21:51:03 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-06-11 13:18:07 +05:30
|
|
|
!> @brief attached attributes of type char, integer or real to a file/dataset/group
|
2018-12-15 21:51:03 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
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
|
2019-04-11 19:14:08 +05:30
|
|
|
module procedure HDF5_addAttribute_int_array
|
|
|
|
|
module procedure HDF5_addAttribute_real_array
|
2019-04-04 15:19:23 +05:30
|
|
|
end interface HDF5_addAttribute
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2021-02-22 18:07:21 +05:30
|
|
|
#ifdef PETSc
|
|
|
|
|
logical, parameter, private :: parallel_default = .true.
|
|
|
|
|
#else
|
|
|
|
|
logical, parameter, private :: parallel_default = .false.
|
|
|
|
|
#endif
|
|
|
|
|
|
2018-08-03 12:23:37 +05:30
|
|
|
contains
|
|
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
|
|
|
|
|
!--------------------------------------------------------------------------------------------------
|
2020-04-28 14:00:03 +05:30
|
|
|
!> @brief initialize HDF5 libary and do sanity checks
|
2019-04-04 15:19:23 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2018-11-15 11:58:34 +05:30
|
|
|
subroutine HDF5_utilities_init
|
2018-08-03 12:23:37 +05:30
|
|
|
|
2019-09-21 04:37:04 +05:30
|
|
|
integer :: hdferr
|
|
|
|
|
integer(SIZE_T) :: typeSize
|
2018-08-03 12:23:37 +05:30
|
|
|
|
2020-09-17 22:59:49 +05:30
|
|
|
print'(/,a)', ' <<<+- HDF5_Utilities init -+>>>'
|
2018-08-03 12:23:37 +05:30
|
|
|
|
2018-10-09 17:43:51 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
|
|
|
|
!initialize HDF5 library and check if integer and float type size match
|
2019-03-06 21:03:39 +05:30
|
|
|
call h5open_f(hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-03-06 21:03:39 +05:30
|
|
|
|
|
|
|
|
call h5tget_size_f(H5T_NATIVE_INTEGER,typeSize, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-03-06 21:03:39 +05:30
|
|
|
if (int(bit_size(0),SIZE_T)/=typeSize*8) &
|
2020-09-13 15:39:32 +05:30
|
|
|
error stop 'Default integer size does not match H5T_NATIVE_INTEGER'
|
2019-03-06 21:03:39 +05:30
|
|
|
|
|
|
|
|
call h5tget_size_f(H5T_NATIVE_DOUBLE,typeSize, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-03-06 21:03:39 +05:30
|
|
|
if (int(storage_size(0.0_pReal),SIZE_T)/=typeSize*8) &
|
2020-09-13 15:39:32 +05:30
|
|
|
error stop 'pReal does not match H5T_NATIVE_DOUBLE'
|
2018-11-09 20:41:19 +05:30
|
|
|
|
2018-11-15 11:58:34 +05:30
|
|
|
end subroutine HDF5_utilities_init
|
2018-08-03 12:23:37 +05:30
|
|
|
|
|
|
|
|
|
2018-10-04 20:30:24 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
|
|
|
|
!> @brief open and initializes HDF5 output file
|
|
|
|
|
!--------------------------------------------------------------------------------------------------
|
2021-02-22 18:07:21 +05:30
|
|
|
integer(HID_T) function HDF5_openFile(fileName,mode)
|
2018-11-09 20:41:19 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
character(len=*), intent(in) :: fileName
|
|
|
|
|
character, intent(in), optional :: mode
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
character :: m
|
|
|
|
|
integer(HID_T) :: plist_id
|
|
|
|
|
integer :: hdferr
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2021-02-22 18:07:21 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
if (present(mode)) then
|
|
|
|
|
m = mode
|
|
|
|
|
else
|
|
|
|
|
m = 'r'
|
|
|
|
|
endif
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
call h5pcreate_f(H5P_FILE_ACCESS_F, plist_id, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2018-11-16 11:35:43 +05:30
|
|
|
|
2018-11-15 11:58:34 +05:30
|
|
|
#ifdef PETSc
|
2021-02-22 18:07:21 +05:30
|
|
|
call h5pset_fapl_mpio_f(plist_id, PETSC_COMM_WORLD, MPI_INFO_NULL, hdferr)
|
|
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2018-11-15 11:58:34 +05:30
|
|
|
#endif
|
|
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
if (m == 'w') then
|
|
|
|
|
call h5fcreate_f(fileName,H5F_ACC_TRUNC_F,HDF5_openFile,hdferr,access_prp = plist_id)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-04 15:19:23 +05:30
|
|
|
elseif(m == 'a') then
|
|
|
|
|
call h5fopen_f(fileName,H5F_ACC_RDWR_F,HDF5_openFile,hdferr,access_prp = plist_id)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-04 15:19:23 +05:30
|
|
|
elseif(m == 'r') then
|
|
|
|
|
call h5fopen_f(fileName,H5F_ACC_RDONLY_F,HDF5_openFile,hdferr,access_prp = plist_id)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-04 15:19:23 +05:30
|
|
|
else
|
2020-11-11 14:49:47 +05:30
|
|
|
error stop 'unknown access mode'
|
2019-04-04 15:19:23 +05:30
|
|
|
endif
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
call h5pclose_f(plist_id, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2018-11-16 11:35:43 +05:30
|
|
|
|
2018-10-04 20:30:24 +05:30
|
|
|
end function HDF5_openFile
|
2018-08-03 12:23:37 +05:30
|
|
|
|
2018-11-15 11:37:59 +05:30
|
|
|
|
2018-09-20 23:12:58 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2018-10-09 14:27:06 +05:30
|
|
|
!> @brief close the opened HDF5 output file
|
2018-09-20 23:12:58 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
|
|
|
|
subroutine HDF5_closeFile(fileHandle)
|
2018-11-09 20:41:19 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
integer(HID_T), intent(in) :: fileHandle
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
integer :: hdferr
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
call h5fclose_f(fileHandle,hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2018-09-20 23:12:58 +05:30
|
|
|
|
|
|
|
|
end subroutine HDF5_closeFile
|
|
|
|
|
|
2018-08-03 12:23:37 +05:30
|
|
|
|
2018-09-20 23:12:58 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2018-12-05 03:39:25 +05:30
|
|
|
!> @brief adds a new group to the fileHandle
|
2018-09-20 23:12:58 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2018-12-05 03:39:25 +05:30
|
|
|
integer(HID_T) function HDF5_addGroup(fileHandle,groupName)
|
2018-09-20 23:12:58 +05:30
|
|
|
|
2020-12-06 18:02:20 +05:30
|
|
|
integer(HID_T), intent(in) :: fileHandle
|
2019-04-04 15:19:23 +05:30
|
|
|
character(len=*), intent(in) :: groupName
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-09-21 04:37:04 +05:30
|
|
|
integer :: hdferr
|
|
|
|
|
integer(HID_T) :: aplist_id
|
2018-11-22 00:05:37 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
!-------------------------------------------------------------------------------------------------
|
|
|
|
|
! creating a property list for data access properties
|
|
|
|
|
call h5pcreate_f(H5P_GROUP_ACCESS_F, aplist_id, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2018-12-05 03:39:25 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
!-------------------------------------------------------------------------------------------------
|
|
|
|
|
! setting I/O mode to collective
|
2019-03-09 21:21:50 +05:30
|
|
|
#ifdef PETSc
|
2019-04-04 15:19:23 +05:30
|
|
|
call h5pset_all_coll_metadata_ops_f(aplist_id, .true., hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-03-09 21:21:50 +05:30
|
|
|
#endif
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
!-------------------------------------------------------------------------------------------------
|
|
|
|
|
! Create group
|
|
|
|
|
call h5gcreate_f(fileHandle, trim(groupName), HDF5_addGroup, hdferr, OBJECT_NAMELEN_DEFAULT_F,gapl_id = aplist_id)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2018-11-09 20:41:19 +05:30
|
|
|
|
2019-04-07 17:58:08 +05:30
|
|
|
call h5pclose_f(aplist_id,hdferr)
|
2019-04-07 17:35:31 +05:30
|
|
|
|
2018-12-05 03:39:25 +05:30
|
|
|
end function HDF5_addGroup
|
2018-09-20 23:12:58 +05:30
|
|
|
|
2018-08-03 12:23:37 +05:30
|
|
|
|
2018-10-04 20:30:24 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2018-11-09 20:41:19 +05:30
|
|
|
!> @brief open an existing group of a file
|
2018-10-04 20:30:24 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2018-12-05 03:39:25 +05:30
|
|
|
integer(HID_T) function HDF5_openGroup(fileHandle,groupName)
|
2018-10-04 20:30:24 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
integer(HID_T), intent(in) :: fileHandle
|
|
|
|
|
character(len=*), intent(in) :: groupName
|
2020-03-15 17:16:10 +05:30
|
|
|
|
|
|
|
|
|
2019-09-21 04:37:04 +05:30
|
|
|
integer :: hdferr
|
|
|
|
|
integer(HID_T) :: aplist_id
|
|
|
|
|
logical :: is_collective
|
2020-03-15 17:16:10 +05:30
|
|
|
|
|
|
|
|
|
2018-11-30 14:46:04 +05:30
|
|
|
!-------------------------------------------------------------------------------------------------
|
2018-12-05 03:39:25 +05:30
|
|
|
! creating a property list for data access properties
|
2019-04-04 15:19:23 +05:30
|
|
|
call h5pcreate_f(H5P_GROUP_ACCESS_F, aplist_id, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2018-12-05 03:39:25 +05:30
|
|
|
|
2018-11-30 14:46:04 +05:30
|
|
|
!-------------------------------------------------------------------------------------------------
|
2018-12-05 03:39:25 +05:30
|
|
|
! setting I/O mode to collective
|
2019-03-09 21:21:50 +05:30
|
|
|
#ifdef PETSc
|
2019-04-04 15:19:23 +05:30
|
|
|
call h5pget_all_coll_metadata_ops_f(aplist_id, is_collective, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-03-09 21:21:50 +05:30
|
|
|
#endif
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2018-12-05 03:39:25 +05:30
|
|
|
!-------------------------------------------------------------------------------------------------
|
|
|
|
|
! opening the group
|
2019-04-04 15:19:23 +05:30
|
|
|
call h5gopen_f(fileHandle, trim(groupName), HDF5_openGroup, hdferr, gapl_id = aplist_id)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2018-10-04 20:30:24 +05:30
|
|
|
|
2019-04-07 17:58:08 +05:30
|
|
|
call h5pclose_f(aplist_id,hdferr)
|
2019-04-07 17:35:31 +05:30
|
|
|
|
2018-12-05 03:39:25 +05:30
|
|
|
end function HDF5_openGroup
|
2018-10-04 20:30:24 +05:30
|
|
|
|
2018-08-03 12:23:37 +05:30
|
|
|
|
|
|
|
|
!--------------------------------------------------------------------------------------------------
|
2018-11-09 20:41:19 +05:30
|
|
|
!> @brief close a group
|
2018-08-03 12:23:37 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2018-12-18 11:04:18 +05:30
|
|
|
subroutine HDF5_closeGroup(group_id)
|
2018-08-03 12:23:37 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
integer(HID_T), intent(in) :: group_id
|
2020-08-09 09:57:29 +05:30
|
|
|
|
|
|
|
|
integer :: hdferr
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
call h5gclose_f(group_id, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2018-08-03 12:23:37 +05:30
|
|
|
|
|
|
|
|
end subroutine HDF5_closeGroup
|
|
|
|
|
|
|
|
|
|
|
2018-12-18 11:04:18 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
|
|
|
|
!> @brief check whether a group or a dataset exists
|
|
|
|
|
!--------------------------------------------------------------------------------------------------
|
|
|
|
|
logical function HDF5_objectExists(loc_id,path)
|
|
|
|
|
|
2019-04-11 15:52:16 +05:30
|
|
|
integer(HID_T), intent(in) :: loc_id
|
2019-04-04 15:19:23 +05:30
|
|
|
character(len=*), intent(in), optional :: path
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2020-08-09 09:57:29 +05:30
|
|
|
integer :: hdferr
|
|
|
|
|
character(len=:), allocatable :: p
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
if (present(path)) then
|
|
|
|
|
p = trim(path)
|
|
|
|
|
else
|
|
|
|
|
p = '.'
|
|
|
|
|
endif
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
call h5lexists_f(loc_id, p, HDF5_objectExists, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
if(HDF5_objectExists) then
|
|
|
|
|
call h5oexists_by_name_f(loc_id, p, HDF5_objectExists, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-04 15:19:23 +05:30
|
|
|
endif
|
2018-12-18 11:04:18 +05:30
|
|
|
|
|
|
|
|
end function HDF5_objectExists
|
|
|
|
|
|
|
|
|
|
|
2018-11-18 17:11:05 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2018-12-17 20:45:16 +05:30
|
|
|
!> @brief adds a string attribute to the path given relative to the location
|
2018-11-18 17:11:05 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2018-12-17 20:45:16 +05:30
|
|
|
subroutine HDF5_addAttribute_str(loc_id,attrLabel,attrValue,path)
|
2018-11-18 17:11:05 +05:30
|
|
|
|
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
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2020-08-09 09:57:29 +05:30
|
|
|
integer(HID_T) :: attr_id, space_id, type_id
|
|
|
|
|
logical :: attrExists
|
|
|
|
|
integer :: hdferr
|
|
|
|
|
character(len=:), allocatable :: p
|
2020-11-05 20:03:43 +05:30
|
|
|
character(len=:,kind=C_CHAR), allocatable,target :: attrValue_
|
2020-11-06 17:55:00 +05:30
|
|
|
type(c_ptr), target, dimension(1) :: ptr
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
if (present(path)) then
|
|
|
|
|
p = trim(path)
|
|
|
|
|
else
|
|
|
|
|
p = '.'
|
|
|
|
|
endif
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2020-11-06 02:44:49 +05:30
|
|
|
attrValue_ = trim(attrValue)//C_NULL_CHAR
|
2020-11-05 20:03:43 +05:30
|
|
|
ptr(1) = c_loc(attrValue_)
|
2020-11-05 22:26:39 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
call h5screate_f(H5S_SCALAR_F,space_id,hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2020-11-05 20:03:43 +05:30
|
|
|
call h5tcopy_f(H5T_STRING, type_id, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-04 15:19:23 +05:30
|
|
|
call h5aexists_by_name_f(loc_id,trim(p),attrLabel,attrExists,hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-04 15:19:23 +05:30
|
|
|
if (attrExists) then
|
2020-11-05 20:03:43 +05:30
|
|
|
call h5adelete_by_name_f(loc_id, trim(p), attrLabel, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-04 15:19:23 +05:30
|
|
|
endif
|
|
|
|
|
call h5acreate_by_name_f(loc_id,trim(p),trim(attrLabel),type_id,space_id,attr_id,hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2020-11-05 22:26:39 +05:30
|
|
|
call h5awrite_f(attr_id, type_id, c_loc(ptr(1)), hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-04 15:19:23 +05:30
|
|
|
call h5aclose_f(attr_id,hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-04 15:19:23 +05:30
|
|
|
call h5tclose_f(type_id,hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-04 15:19:23 +05:30
|
|
|
call h5sclose_f(space_id,hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2018-11-18 17:11:05 +05:30
|
|
|
|
2018-12-17 20:45:16 +05:30
|
|
|
end subroutine HDF5_addAttribute_str
|
2018-11-18 17:11:05 +05:30
|
|
|
|
|
|
|
|
|
|
|
|
|
!--------------------------------------------------------------------------------------------------
|
2018-12-17 20:45:16 +05:30
|
|
|
!> @brief adds a integer attribute to the path given relative to the location
|
2018-11-18 17:11:05 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-04-04 15:19:23 +05:30
|
|
|
subroutine HDF5_addAttribute_int(loc_id,attrLabel,attrValue,path)
|
2018-11-18 17:11:05 +05:30
|
|
|
|
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
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2020-08-09 09:57:29 +05:30
|
|
|
integer(HID_T) :: attr_id, space_id
|
|
|
|
|
integer :: hdferr
|
|
|
|
|
logical :: attrExists
|
|
|
|
|
character(len=:), allocatable :: p
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
if (present(path)) then
|
|
|
|
|
p = trim(path)
|
|
|
|
|
else
|
|
|
|
|
p = '.'
|
|
|
|
|
endif
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
call h5screate_f(H5S_SCALAR_F,space_id,hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-04 15:19:23 +05:30
|
|
|
call h5aexists_by_name_f(loc_id,trim(p),attrLabel,attrExists,hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-04 15:19:23 +05:30
|
|
|
if (attrExists) then
|
|
|
|
|
call h5adelete_by_name_f(loc_id, trim(p), attrLabel, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-04 15:19:23 +05:30
|
|
|
endif
|
2019-04-11 15:52:16 +05:30
|
|
|
call h5acreate_by_name_f(loc_id,trim(p),trim(attrLabel),H5T_NATIVE_INTEGER,space_id,attr_id,hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-11 15:52:16 +05:30
|
|
|
call h5awrite_f(attr_id, H5T_NATIVE_INTEGER, attrValue, int([1],HSIZE_T), hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-04 15:19:23 +05:30
|
|
|
call h5aclose_f(attr_id,hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-04 15:19:23 +05:30
|
|
|
call h5sclose_f(space_id,hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-04 15:19:23 +05:30
|
|
|
|
|
|
|
|
end subroutine HDF5_addAttribute_int
|
2018-11-18 17:11:05 +05:30
|
|
|
|
|
|
|
|
|
2018-12-15 21:51:03 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2018-12-17 20:45:16 +05:30
|
|
|
!> @brief adds a integer attribute to the path given relative to the location
|
2018-12-15 21:51:03 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-04-04 15:19:23 +05:30
|
|
|
subroutine HDF5_addAttribute_real(loc_id,attrLabel,attrValue,path)
|
2018-12-15 21:51:03 +05:30
|
|
|
|
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
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2020-08-09 09:57:29 +05:30
|
|
|
integer(HID_T) :: attr_id, space_id
|
|
|
|
|
integer :: hdferr
|
|
|
|
|
logical :: attrExists
|
|
|
|
|
character(len=:), allocatable :: p
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
if (present(path)) then
|
|
|
|
|
p = trim(path)
|
|
|
|
|
else
|
|
|
|
|
p = '.'
|
|
|
|
|
endif
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
call h5screate_f(H5S_SCALAR_F,space_id,hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-04 15:19:23 +05:30
|
|
|
call h5aexists_by_name_f(loc_id,trim(p),attrLabel,attrExists,hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-04 15:19:23 +05:30
|
|
|
if (attrExists) then
|
|
|
|
|
call h5adelete_by_name_f(loc_id, trim(p), attrLabel, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-04 15:19:23 +05:30
|
|
|
endif
|
2019-04-11 15:52:16 +05:30
|
|
|
call h5acreate_by_name_f(loc_id,trim(p),trim(attrLabel),H5T_NATIVE_DOUBLE,space_id,attr_id,hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-11 15:52:16 +05:30
|
|
|
call h5awrite_f(attr_id, H5T_NATIVE_DOUBLE, attrValue, int([1],HSIZE_T), hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-04 15:19:23 +05:30
|
|
|
call h5aclose_f(attr_id,hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-04 15:19:23 +05:30
|
|
|
call h5sclose_f(space_id,hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-04 15:19:23 +05:30
|
|
|
|
|
|
|
|
end subroutine HDF5_addAttribute_real
|
2018-12-15 21:51:03 +05:30
|
|
|
|
|
|
|
|
|
2019-04-11 19:14:08 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
|
|
|
|
!> @brief adds a integer attribute to the path given relative to the location
|
|
|
|
|
!--------------------------------------------------------------------------------------------------
|
|
|
|
|
subroutine HDF5_addAttribute_int_array(loc_id,attrLabel,attrValue,path)
|
|
|
|
|
|
|
|
|
|
integer(HID_T), intent(in) :: loc_id
|
|
|
|
|
character(len=*), intent(in) :: attrLabel
|
2019-06-11 13:18:07 +05:30
|
|
|
integer, intent(in), dimension(:) :: attrValue
|
2019-04-11 19:14:08 +05:30
|
|
|
character(len=*), intent(in), optional :: path
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-11 19:14:08 +05:30
|
|
|
integer(HSIZE_T),dimension(1) :: array_size
|
2020-08-09 09:57:29 +05:30
|
|
|
integer(HID_T) :: attr_id, space_id
|
|
|
|
|
integer :: hdferr
|
2019-04-11 19:14:08 +05:30
|
|
|
logical :: attrExists
|
2020-08-09 09:57:29 +05:30
|
|
|
character(len=:), allocatable :: p
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-11 19:14:08 +05:30
|
|
|
if (present(path)) then
|
|
|
|
|
p = trim(path)
|
|
|
|
|
else
|
|
|
|
|
p = '.'
|
|
|
|
|
endif
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-11 19:14:08 +05:30
|
|
|
array_size = size(attrValue,kind=HSIZE_T)
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-11 19:14:08 +05:30
|
|
|
call h5screate_simple_f(1, array_size, space_id, hdferr, array_size)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-11 19:14:08 +05:30
|
|
|
call h5aexists_by_name_f(loc_id,trim(p),attrLabel,attrExists,hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-11 19:14:08 +05:30
|
|
|
if (attrExists) then
|
|
|
|
|
call h5adelete_by_name_f(loc_id, trim(p), attrLabel, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-11 19:14:08 +05:30
|
|
|
endif
|
|
|
|
|
call h5acreate_by_name_f(loc_id,trim(p),trim(attrLabel),H5T_NATIVE_INTEGER,space_id,attr_id,hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-11 19:14:08 +05:30
|
|
|
call h5awrite_f(attr_id, H5T_NATIVE_INTEGER, attrValue, array_size, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-11 19:14:08 +05:30
|
|
|
call h5aclose_f(attr_id,hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-11 19:14:08 +05:30
|
|
|
call h5sclose_f(space_id,hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-11 19:14:08 +05:30
|
|
|
|
|
|
|
|
end subroutine HDF5_addAttribute_int_array
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
!--------------------------------------------------------------------------------------------------
|
|
|
|
|
!> @brief adds a real attribute to the path given relative to the location
|
|
|
|
|
!--------------------------------------------------------------------------------------------------
|
|
|
|
|
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
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-11 19:14:08 +05:30
|
|
|
integer(HSIZE_T),dimension(1) :: array_size
|
2020-08-09 09:57:29 +05:30
|
|
|
integer(HID_T) :: attr_id, space_id
|
|
|
|
|
integer :: hdferr
|
2019-04-11 19:14:08 +05:30
|
|
|
logical :: attrExists
|
2020-08-09 09:57:29 +05:30
|
|
|
character(len=:), allocatable :: p
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-11 19:14:08 +05:30
|
|
|
if (present(path)) then
|
|
|
|
|
p = trim(path)
|
|
|
|
|
else
|
|
|
|
|
p = '.'
|
|
|
|
|
endif
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-11 19:14:08 +05:30
|
|
|
array_size = size(attrValue,kind=HSIZE_T)
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-11 19:14:08 +05:30
|
|
|
call h5screate_simple_f(1, array_size, space_id, hdferr, array_size)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-11 19:14:08 +05:30
|
|
|
call h5aexists_by_name_f(loc_id,trim(p),attrLabel,attrExists,hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-11 19:14:08 +05:30
|
|
|
if (attrExists) then
|
|
|
|
|
call h5adelete_by_name_f(loc_id, trim(p), attrLabel, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-11 19:14:08 +05:30
|
|
|
endif
|
|
|
|
|
call h5acreate_by_name_f(loc_id,trim(p),trim(attrLabel),H5T_NATIVE_DOUBLE,space_id,attr_id,hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-11 19:14:08 +05:30
|
|
|
call h5awrite_f(attr_id, H5T_NATIVE_DOUBLE, attrValue, array_size, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-11 19:14:08 +05:30
|
|
|
call h5aclose_f(attr_id,hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-11 19:14:08 +05:30
|
|
|
call h5sclose_f(space_id,hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-11 19:14:08 +05:30
|
|
|
|
|
|
|
|
end subroutine HDF5_addAttribute_real_array
|
|
|
|
|
|
|
|
|
|
|
2018-12-12 12:15:20 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
|
|
|
|
!> @brief set link to object in results file
|
|
|
|
|
!--------------------------------------------------------------------------------------------------
|
2018-12-17 20:45:16 +05:30
|
|
|
subroutine HDF5_setLink(loc_id,target_name,link_name)
|
2018-12-12 12:15:20 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
character(len=*), intent(in) :: target_name, link_name
|
2019-09-21 04:37:04 +05:30
|
|
|
integer(HID_T), intent(in) :: loc_id
|
|
|
|
|
integer :: hdferr
|
2019-04-04 15:19:23 +05:30
|
|
|
logical :: linkExists
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
call h5lexists_f(loc_id, link_name,linkExists, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-04 15:19:23 +05:30
|
|
|
if (linkExists) then
|
|
|
|
|
call h5ldelete_f(loc_id,link_name, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-04 15:19:23 +05:30
|
|
|
endif
|
|
|
|
|
call h5lcreate_soft_f(target_name, loc_id, link_name, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2018-11-18 17:11:05 +05:30
|
|
|
|
2018-12-12 12:15:20 +05:30
|
|
|
end subroutine HDF5_setLink
|
2018-11-27 23:20:51 +05:30
|
|
|
|
2019-02-09 16:15:02 +05:30
|
|
|
|
2018-09-25 20:12:43 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-06-11 13:18:07 +05:30
|
|
|
!> @brief read dataset of type real with 1 dimension
|
2018-10-09 18:16:57 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-04-04 15:19:23 +05:30
|
|
|
subroutine HDF5_read_real1(loc_id,dataset,datasetName,parallel)
|
2018-10-09 18:16:57 +05:30
|
|
|
|
2020-03-15 17:16:10 +05:30
|
|
|
real(pReal), intent(out), dimension(:) :: dataset !< data read from file
|
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
|
2020-03-15 17:16:10 +05:30
|
|
|
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
|
|
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
|
|
|
|
|
integer(HSIZE_T), dimension(size(shape(dataset))) :: & ! ToDo: Fortran 2018 size(shape(A)) = rank(A)
|
|
|
|
|
myStart, &
|
|
|
|
|
myShape, & !< shape of the dataset (this process)
|
|
|
|
|
totalShape !< shape of the dataset (all processes)
|
|
|
|
|
integer :: hdferr
|
2018-11-27 23:20:51 +05:30
|
|
|
|
2019-02-09 12:35:29 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
2018-11-27 23:20:51 +05:30
|
|
|
! determine shape of dataset
|
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)
|
2018-11-27 23:20:51 +05:30
|
|
|
|
2019-02-09 14:08:49 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
|
|
|
|
! initialize HDF5 data structures
|
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, &
|
2021-02-22 18:07:21 +05:30
|
|
|
myStart, totalShape, loc_id,myShape,datasetName,parallel_default)
|
2019-04-04 15:19:23 +05:30
|
|
|
endif
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
call h5dread_f(dset_id, H5T_NATIVE_DOUBLE,dataset,totalShape, hdferr,&
|
|
|
|
|
file_space_id = filespace_id, xfer_prp = plist_id, mem_space_id = memspace_id)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
end subroutine HDF5_read_real1
|
2018-11-27 23:20:51 +05:30
|
|
|
|
2018-10-10 21:24:55 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-06-11 13:18:07 +05:30
|
|
|
!> @brief read dataset of type real with 2 dimensions
|
2018-10-10 21:24:55 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-04-04 15:19:23 +05:30
|
|
|
subroutine HDF5_read_real2(loc_id,dataset,datasetName,parallel)
|
2018-11-09 20:41:19 +05:30
|
|
|
|
2020-03-15 17:16:10 +05:30
|
|
|
real(pReal), intent(out), dimension(:,:) :: dataset !< data read from file
|
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
|
2020-03-15 17:16:10 +05:30
|
|
|
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
|
|
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
|
|
|
|
|
integer(HSIZE_T), dimension(size(shape(dataset))) :: &
|
|
|
|
|
myStart, &
|
|
|
|
|
myShape, & !< shape of the dataset (this process)
|
|
|
|
|
totalShape !< shape of the dataset (all processes)
|
|
|
|
|
integer :: hdferr
|
2018-11-09 20:41:19 +05:30
|
|
|
|
2019-02-09 12:35:29 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
2018-11-27 23:20:51 +05:30
|
|
|
! determine shape of dataset
|
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)
|
2018-11-09 20:41:19 +05:30
|
|
|
|
2019-02-09 14:08:49 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
|
|
|
|
! initialize HDF5 data structures
|
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, &
|
2021-02-22 18:07:21 +05:30
|
|
|
myStart, totalShape, loc_id,myShape,datasetName,parallel_default)
|
2019-04-04 15:19:23 +05:30
|
|
|
endif
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
call h5dread_f(dset_id, H5T_NATIVE_DOUBLE,dataset,totalShape, hdferr,&
|
|
|
|
|
file_space_id = filespace_id, xfer_prp = plist_id, mem_space_id = memspace_id)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)
|
2018-11-27 23:20:51 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
end subroutine HDF5_read_real2
|
2018-10-10 21:24:55 +05:30
|
|
|
|
|
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-06-11 13:18:07 +05:30
|
|
|
!> @brief read dataset of type real with 2 dimensions
|
2018-10-10 21:24:55 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-04-04 15:19:23 +05:30
|
|
|
subroutine HDF5_read_real3(loc_id,dataset,datasetName,parallel)
|
2018-11-09 20:41:19 +05:30
|
|
|
|
2020-03-15 17:16:10 +05:30
|
|
|
real(pReal), intent(out), dimension(:,:,:) :: dataset !< data read from file
|
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
|
2020-03-15 17:16:10 +05:30
|
|
|
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
|
|
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
|
|
|
|
|
integer(HSIZE_T), dimension(size(shape(dataset))) :: &
|
|
|
|
|
myStart, &
|
|
|
|
|
myShape, & !< shape of the dataset (this process)
|
|
|
|
|
totalShape !< shape of the dataset (all processes)
|
|
|
|
|
integer :: hdferr
|
2018-11-27 23:20:51 +05:30
|
|
|
|
2019-02-09 12:35:29 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
2018-11-27 23:20:51 +05:30
|
|
|
! determine shape of dataset
|
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)
|
2018-11-27 23:20:51 +05:30
|
|
|
|
2019-02-09 14:08:49 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
|
|
|
|
! initialize HDF5 data structures
|
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, &
|
2021-02-22 18:07:21 +05:30
|
|
|
myStart, totalShape, loc_id,myShape,datasetName,parallel_default)
|
2019-04-04 15:19:23 +05:30
|
|
|
endif
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
call h5dread_f(dset_id, H5T_NATIVE_DOUBLE,dataset,totalShape, hdferr,&
|
|
|
|
|
file_space_id = filespace_id, xfer_prp = plist_id, mem_space_id = memspace_id)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2018-11-27 23:20:51 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)
|
2018-11-27 23:20:51 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
end subroutine HDF5_read_real3
|
2018-11-27 23:20:51 +05:30
|
|
|
|
|
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-06-11 13:18:07 +05:30
|
|
|
!> @brief read dataset of type real with 4 dimensions
|
2018-11-27 23:20:51 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-04-04 15:19:23 +05:30
|
|
|
subroutine HDF5_read_real4(loc_id,dataset,datasetName,parallel)
|
2018-10-09 18:16:57 +05:30
|
|
|
|
2020-03-15 17:16:10 +05:30
|
|
|
real(pReal), intent(out), dimension(:,:,:,:) :: dataset !< read data
|
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
|
2020-03-15 17:16:10 +05:30
|
|
|
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
|
2019-04-04 15:19:23 +05:30
|
|
|
|
|
|
|
|
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
|
|
|
|
|
integer(HSIZE_T), dimension(size(shape(dataset))) :: &
|
|
|
|
|
myStart, &
|
|
|
|
|
myShape, & !< shape of the dataset (this process)
|
|
|
|
|
totalShape !< shape of the dataset (all processes)
|
|
|
|
|
integer :: hdferr
|
2018-11-23 20:19:43 +05:30
|
|
|
|
2019-02-09 12:35:29 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
2018-11-27 23:20:51 +05:30
|
|
|
! determine shape of dataset
|
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)
|
2018-11-27 23:20:51 +05:30
|
|
|
|
2019-02-09 14:08:49 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
|
|
|
|
! initialize HDF5 data structures
|
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, &
|
2021-02-22 18:07:21 +05:30
|
|
|
myStart, totalShape, loc_id,myShape,datasetName,parallel_default)
|
2019-04-04 15:19:23 +05:30
|
|
|
endif
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
call h5dread_f(dset_id, H5T_NATIVE_DOUBLE,dataset,totalShape, hdferr,&
|
|
|
|
|
file_space_id = filespace_id, xfer_prp = plist_id, mem_space_id = memspace_id)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)
|
2018-11-27 23:20:51 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
end subroutine HDF5_read_real4
|
2018-10-09 18:16:57 +05:30
|
|
|
|
2018-10-10 21:24:55 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-06-11 13:18:07 +05:30
|
|
|
!> @brief read dataset of type real with 5 dimensions
|
2018-10-10 21:24:55 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-04-04 15:19:23 +05:30
|
|
|
subroutine HDF5_read_real5(loc_id,dataset,datasetName,parallel)
|
2018-10-09 14:27:06 +05:30
|
|
|
|
2020-03-15 17:16:10 +05:30
|
|
|
real(pReal), intent(out), dimension(:,:,:,:,:) :: dataset !< data read from file
|
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
|
2020-03-15 17:16:10 +05:30
|
|
|
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
|
|
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
|
|
|
|
|
integer(HSIZE_T), dimension(size(shape(dataset))) :: &
|
|
|
|
|
myStart, &
|
|
|
|
|
myShape, & !< shape of the dataset (this process)
|
|
|
|
|
totalShape !< shape of the dataset (all processes)
|
|
|
|
|
integer :: hdferr
|
2018-10-09 14:27:06 +05:30
|
|
|
|
2019-02-09 12:35:29 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
2018-11-27 23:20:51 +05:30
|
|
|
! determine shape of dataset
|
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)
|
2018-11-27 23:20:51 +05:30
|
|
|
|
2019-02-09 14:08:49 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
|
|
|
|
! initialize HDF5 data structures
|
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, &
|
2021-02-22 18:07:21 +05:30
|
|
|
myStart, totalShape, loc_id,myShape,datasetName,parallel_default)
|
2019-04-04 15:19:23 +05:30
|
|
|
endif
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
call h5dread_f(dset_id, H5T_NATIVE_DOUBLE,dataset,totalShape, hdferr,&
|
|
|
|
|
file_space_id = filespace_id, xfer_prp = plist_id, mem_space_id = memspace_id)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)
|
2018-11-27 23:20:51 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
end subroutine HDF5_read_real5
|
2018-11-27 23:20:51 +05:30
|
|
|
|
2018-10-09 18:16:57 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-06-11 13:18:07 +05:30
|
|
|
!> @brief read dataset of type real with 6 dimensions
|
2018-11-27 23:20:51 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-04-04 15:19:23 +05:30
|
|
|
subroutine HDF5_read_real6(loc_id,dataset,datasetName,parallel)
|
2018-10-09 18:16:57 +05:30
|
|
|
|
2020-03-15 17:16:10 +05:30
|
|
|
real(pReal), intent(out), dimension(:,:,:,:,:,:) :: dataset !< data read from file
|
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
|
2020-03-15 17:16:10 +05:30
|
|
|
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
|
|
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
|
|
|
|
|
integer(HSIZE_T), dimension(size(shape(dataset))) :: &
|
|
|
|
|
myStart, &
|
|
|
|
|
myShape, & !< shape of the dataset (this process)
|
|
|
|
|
totalShape !< shape of the dataset (all processes)
|
|
|
|
|
integer :: hdferr
|
2018-11-27 23:20:51 +05:30
|
|
|
|
2019-02-09 12:35:29 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
2018-11-27 23:20:51 +05:30
|
|
|
! determine shape of dataset
|
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)
|
2018-11-27 23:20:51 +05:30
|
|
|
|
2019-02-09 14:08:49 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
|
|
|
|
! initialize HDF5 data structures
|
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, &
|
2021-02-22 18:07:21 +05:30
|
|
|
myStart, totalShape, loc_id,myShape,datasetName,parallel_default)
|
2019-04-04 15:19:23 +05:30
|
|
|
endif
|
2018-11-27 23:20:51 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
call h5dread_f(dset_id, H5T_NATIVE_DOUBLE,dataset,totalShape, hdferr,&
|
|
|
|
|
file_space_id = filespace_id, xfer_prp = plist_id, mem_space_id = memspace_id)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2018-11-27 23:20:51 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)
|
2018-11-27 23:20:51 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
end subroutine HDF5_read_real6
|
2018-11-27 23:20:51 +05:30
|
|
|
|
|
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-06-11 13:18:07 +05:30
|
|
|
!> @brief read dataset of type real with 7 dimensions
|
2018-11-27 23:20:51 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-04-04 15:19:23 +05:30
|
|
|
subroutine HDF5_read_real7(loc_id,dataset,datasetName,parallel)
|
2018-11-27 23:20:51 +05:30
|
|
|
|
2020-03-15 17:16:10 +05:30
|
|
|
real(pReal), intent(out), dimension(:,:,:,:,:,:,:) :: dataset !< data read from file
|
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
|
2020-03-15 17:16:10 +05:30
|
|
|
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
|
2019-04-04 15:19:23 +05:30
|
|
|
|
|
|
|
|
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
|
|
|
|
|
integer(HSIZE_T), dimension(size(shape(dataset))) :: &
|
|
|
|
|
myStart, &
|
|
|
|
|
myShape, & !< shape of the dataset (this process)
|
|
|
|
|
totalShape !< shape of the dataset (all processes)
|
|
|
|
|
integer :: hdferr
|
2018-11-27 23:20:51 +05:30
|
|
|
|
2019-02-09 12:35:29 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
2018-11-27 23:20:51 +05:30
|
|
|
! determine shape of dataset
|
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)
|
2018-11-27 23:20:51 +05:30
|
|
|
|
2019-02-09 14:08:49 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
|
|
|
|
! initialize HDF5 data structures
|
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, &
|
2021-02-22 18:07:21 +05:30
|
|
|
myStart, totalShape, loc_id,myShape,datasetName,parallel_default)
|
2019-04-04 15:19:23 +05:30
|
|
|
endif
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
call h5dread_f(dset_id, H5T_NATIVE_DOUBLE,dataset,totalShape, hdferr,&
|
|
|
|
|
file_space_id = filespace_id, xfer_prp = plist_id, mem_space_id = memspace_id)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)
|
2018-11-27 23:20:51 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
end subroutine HDF5_read_real7
|
2018-11-27 23:20:51 +05:30
|
|
|
|
|
|
|
|
|
|
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-06-11 13:18:07 +05:30
|
|
|
!> @brief read dataset of type integer with 1 dimension
|
2018-11-27 23:20:51 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-04-04 15:19:23 +05:30
|
|
|
subroutine HDF5_read_int1(loc_id,dataset,datasetName,parallel)
|
2018-11-27 23:20:51 +05:30
|
|
|
|
2020-03-15 17:16:10 +05:30
|
|
|
integer, intent(out), dimension(:) :: dataset !< data read from file
|
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
|
2020-03-15 17:16:10 +05:30
|
|
|
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
|
|
|
|
|
|
|
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
|
|
|
|
|
integer(HSIZE_T), dimension(size(shape(dataset))) :: &
|
|
|
|
|
myStart, &
|
|
|
|
|
myShape, & !< shape of the dataset (this process)
|
|
|
|
|
totalShape !< shape of the dataset (all processes)
|
|
|
|
|
integer :: hdferr
|
2018-11-27 23:20:51 +05:30
|
|
|
|
2019-02-09 12:35:29 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
2018-11-27 23:20:51 +05:30
|
|
|
! determine shape of dataset
|
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)
|
2018-11-27 23:20:51 +05:30
|
|
|
|
2019-02-09 14:08:49 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
|
|
|
|
! initialize HDF5 data structures
|
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, &
|
2021-02-22 18:07:21 +05:30
|
|
|
myStart, totalShape, loc_id,myShape,datasetName,parallel_default)
|
2019-04-04 15:19:23 +05:30
|
|
|
endif
|
|
|
|
|
|
|
|
|
|
call h5dread_f(dset_id, H5T_NATIVE_INTEGER,dataset,totalShape, hdferr,&
|
|
|
|
|
file_space_id = filespace_id, xfer_prp = plist_id, mem_space_id = memspace_id)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-04 15:19:23 +05:30
|
|
|
|
|
|
|
|
call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
end subroutine HDF5_read_int1
|
2018-11-27 23:20:51 +05:30
|
|
|
|
|
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-06-11 13:18:07 +05:30
|
|
|
!> @brief read dataset of type integer with 2 dimensions
|
2018-11-27 23:20:51 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-04-04 15:19:23 +05:30
|
|
|
subroutine HDF5_read_int2(loc_id,dataset,datasetName,parallel)
|
2018-11-27 23:20:51 +05:30
|
|
|
|
2020-03-15 17:16:10 +05:30
|
|
|
integer, intent(out), dimension(:,:) :: dataset !< data read from file
|
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
|
2020-03-15 17:16:10 +05:30
|
|
|
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
|
2019-04-04 15:19:23 +05:30
|
|
|
|
|
|
|
|
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
|
|
|
|
|
integer(HSIZE_T), dimension(size(shape(dataset))) :: &
|
|
|
|
|
myStart, &
|
|
|
|
|
myShape, & !< shape of the dataset (this process)
|
|
|
|
|
totalShape !< shape of the dataset (all processes)
|
|
|
|
|
integer :: hdferr
|
2018-11-27 23:20:51 +05:30
|
|
|
|
2019-02-09 12:35:29 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
2018-11-27 23:20:51 +05:30
|
|
|
! determine shape of dataset
|
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)
|
2018-11-27 23:20:51 +05:30
|
|
|
|
2019-02-09 14:08:49 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
|
|
|
|
! initialize HDF5 data structures
|
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, &
|
2021-02-22 18:07:21 +05:30
|
|
|
myStart, totalShape, loc_id,myShape,datasetName,parallel_default)
|
2019-04-04 15:19:23 +05:30
|
|
|
endif
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
call h5dread_f(dset_id, H5T_NATIVE_INTEGER,dataset,totalShape, hdferr,&
|
|
|
|
|
file_space_id = filespace_id, xfer_prp = plist_id, mem_space_id = memspace_id)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)
|
2018-11-27 23:20:51 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
end subroutine HDF5_read_int2
|
2018-10-09 18:16:57 +05:30
|
|
|
|
2018-10-10 21:24:55 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-06-11 13:18:07 +05:30
|
|
|
!> @brief read dataset of type integer with 3 dimensions
|
2018-10-10 21:24:55 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-04-04 15:19:23 +05:30
|
|
|
subroutine HDF5_read_int3(loc_id,dataset,datasetName,parallel)
|
2018-11-09 20:41:19 +05:30
|
|
|
|
2020-03-15 17:16:10 +05:30
|
|
|
integer, intent(out), dimension(:,:,:) :: dataset !< data read from file
|
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
|
2020-03-15 17:16:10 +05:30
|
|
|
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
|
2019-04-04 15:19:23 +05:30
|
|
|
|
|
|
|
|
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
|
|
|
|
|
integer(HSIZE_T), dimension(size(shape(dataset))) :: &
|
|
|
|
|
myStart, &
|
|
|
|
|
myShape, & !< shape of the dataset (this process)
|
|
|
|
|
totalShape !< shape of the dataset (all processes)
|
|
|
|
|
integer :: hdferr
|
2018-11-09 20:41:19 +05:30
|
|
|
|
2019-02-09 12:35:29 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
2018-11-27 23:20:51 +05:30
|
|
|
! determine shape of dataset
|
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)
|
2018-10-09 14:27:06 +05:30
|
|
|
|
2019-02-09 14:08:49 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
|
|
|
|
! initialize HDF5 data structures
|
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
|
2019-02-09 12:35:29 +05:30
|
|
|
call initialize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id, &
|
2021-02-22 18:07:21 +05:30
|
|
|
myStart, totalShape, loc_id,myShape,datasetName,parallel_default)
|
2019-04-04 15:19:23 +05:30
|
|
|
endif
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
call h5dread_f(dset_id, H5T_NATIVE_INTEGER,dataset,totalShape, hdferr,&
|
|
|
|
|
file_space_id = filespace_id, xfer_prp = plist_id, mem_space_id = memspace_id)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)
|
2018-11-09 20:41:19 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
end subroutine HDF5_read_int3
|
2019-02-09 12:35:29 +05:30
|
|
|
|
2018-11-30 22:03:30 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-06-11 13:18:07 +05:30
|
|
|
!> @brief read dataset of type integer withh 4 dimensions
|
2018-11-27 23:20:51 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-04-04 15:19:23 +05:30
|
|
|
subroutine HDF5_read_int4(loc_id,dataset,datasetName,parallel)
|
2018-11-26 20:08:31 +05:30
|
|
|
|
2020-03-15 17:16:10 +05:30
|
|
|
integer, intent(out), dimension(:,:,:,:) :: dataset !< data read from file
|
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
|
2020-03-15 17:16:10 +05:30
|
|
|
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
|
|
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
|
|
|
|
|
integer(HSIZE_T), dimension(size(shape(dataset))) :: &
|
|
|
|
|
myStart, &
|
|
|
|
|
myShape, & !< shape of the dataset (this process)
|
|
|
|
|
totalShape !< shape of the dataset (all processes)
|
|
|
|
|
integer :: hdferr
|
2018-11-27 23:20:51 +05:30
|
|
|
|
2019-02-09 12:35:29 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
|
|
|
|
! determine shape of dataset
|
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)
|
2019-02-09 12:35:29 +05:30
|
|
|
|
2019-02-09 14:08:49 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
|
|
|
|
! initialize HDF5 data structures
|
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, &
|
2021-02-22 18:07:21 +05:30
|
|
|
myStart, totalShape, loc_id,myShape,datasetName,parallel_default)
|
2019-04-04 15:19:23 +05:30
|
|
|
endif
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
call h5dread_f(dset_id, H5T_NATIVE_INTEGER,dataset,totalShape, hdferr,&
|
|
|
|
|
file_space_id = filespace_id, xfer_prp = plist_id, mem_space_id = memspace_id)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)
|
2018-11-27 23:20:51 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
end subroutine HDF5_read_int4
|
2018-10-09 18:16:57 +05:30
|
|
|
|
2018-10-10 21:24:55 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-06-11 13:18:07 +05:30
|
|
|
!> @brief read dataset of type integer with 5 dimensions
|
2018-10-10 21:24:55 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-04-04 15:19:23 +05:30
|
|
|
subroutine HDF5_read_int5(loc_id,dataset,datasetName,parallel)
|
2018-11-09 20:41:19 +05:30
|
|
|
|
2020-03-15 17:16:10 +05:30
|
|
|
integer, intent(out), dimension(:,:,:,:,:) :: dataset !< data read from file
|
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
|
2020-03-15 17:16:10 +05:30
|
|
|
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
|
|
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
|
|
|
|
|
integer(HSIZE_T), dimension(size(shape(dataset))) :: &
|
|
|
|
|
myStart, &
|
|
|
|
|
myShape, & !< shape of the dataset (this process)
|
|
|
|
|
totalShape !< shape of the dataset (all processes)
|
|
|
|
|
integer :: hdferr
|
2018-11-27 23:20:51 +05:30
|
|
|
|
2019-02-09 12:35:29 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
2018-11-27 23:20:51 +05:30
|
|
|
! determine shape of dataset
|
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)
|
2018-11-27 23:20:51 +05:30
|
|
|
|
2019-02-09 14:08:49 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
|
|
|
|
! initialize HDF5 data structures
|
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, &
|
2021-02-22 18:07:21 +05:30
|
|
|
myStart, totalShape, loc_id,myShape,datasetName,parallel_default)
|
2019-04-04 15:19:23 +05:30
|
|
|
endif
|
|
|
|
|
|
|
|
|
|
call h5dread_f(dset_id, H5T_NATIVE_INTEGER,dataset,totalShape, hdferr,&
|
|
|
|
|
file_space_id = filespace_id, xfer_prp = plist_id, mem_space_id = memspace_id)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)
|
2018-11-09 20:41:19 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
end subroutine HDF5_read_int5
|
2018-10-10 21:24:55 +05:30
|
|
|
|
2018-09-25 20:12:43 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-06-11 13:18:07 +05:30
|
|
|
!> @brief read dataset of type integer with 6 dimensions
|
2018-10-10 21:24:55 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-04-04 15:19:23 +05:30
|
|
|
subroutine HDF5_read_int6(loc_id,dataset,datasetName,parallel)
|
2018-09-25 20:12:43 +05:30
|
|
|
|
2020-03-15 17:16:10 +05:30
|
|
|
integer, intent(out), dimension(:,:,:,:,:,:) :: dataset !< data read from file
|
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
|
2020-03-15 17:16:10 +05:30
|
|
|
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
|
2019-04-04 15:19:23 +05:30
|
|
|
|
|
|
|
|
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
|
|
|
|
|
integer(HSIZE_T), dimension(size(shape(dataset))) :: &
|
|
|
|
|
myStart, &
|
|
|
|
|
myShape, & !< shape of the dataset (this process)
|
|
|
|
|
totalShape !< shape of the dataset (all processes)
|
|
|
|
|
integer :: hdferr
|
2018-11-27 23:20:51 +05:30
|
|
|
|
2019-02-09 12:35:29 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
2018-11-27 23:20:51 +05:30
|
|
|
! determine shape of dataset
|
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)
|
2018-09-25 20:12:43 +05:30
|
|
|
|
2019-02-09 14:08:49 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
|
|
|
|
! initialize HDF5 data structures
|
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, &
|
2021-02-22 18:07:21 +05:30
|
|
|
myStart, totalShape, loc_id,myShape,datasetName,parallel_default)
|
2019-04-04 15:19:23 +05:30
|
|
|
endif
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
call h5dread_f(dset_id, H5T_NATIVE_INTEGER,dataset,totalShape, hdferr,&
|
|
|
|
|
file_space_id = filespace_id, xfer_prp = plist_id, mem_space_id = memspace_id)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)
|
2018-11-09 20:41:19 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
end subroutine HDF5_read_int6
|
2018-10-05 12:26:06 +05:30
|
|
|
|
2018-10-10 21:24:55 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-06-11 13:18:07 +05:30
|
|
|
!> @brief read dataset of type integer with 7 dimensions
|
2018-10-10 21:24:55 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-04-04 15:19:23 +05:30
|
|
|
subroutine HDF5_read_int7(loc_id,dataset,datasetName,parallel)
|
2018-11-09 20:41:19 +05:30
|
|
|
|
2020-03-15 17:16:10 +05:30
|
|
|
integer, intent(out), dimension(:,:,:,:,:,:,:) :: dataset !< data read from file
|
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
|
2020-03-15 17:16:10 +05:30
|
|
|
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
|
|
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
|
|
|
|
|
integer(HSIZE_T), dimension(size(shape(dataset))) :: &
|
|
|
|
|
myStart, &
|
|
|
|
|
myShape, & !< shape of the dataset (this process)
|
|
|
|
|
totalShape !< shape of the dataset (all processes)
|
|
|
|
|
integer :: hdferr
|
2018-11-27 23:20:51 +05:30
|
|
|
|
2019-02-09 12:35:29 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
2018-11-27 23:20:51 +05:30
|
|
|
! determine shape of dataset
|
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)
|
2018-10-10 21:24:55 +05:30
|
|
|
|
2019-02-09 14:08:49 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
|
|
|
|
! initialize HDF5 data structures
|
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, &
|
2021-02-22 18:07:21 +05:30
|
|
|
myStart, totalShape, loc_id,myShape,datasetName,parallel_default)
|
2019-04-04 15:19:23 +05:30
|
|
|
endif
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
call h5dread_f(dset_id, H5T_NATIVE_INTEGER,dataset,totalShape, hdferr,&
|
|
|
|
|
file_space_id = filespace_id, xfer_prp = plist_id, mem_space_id = memspace_id)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)
|
2018-10-10 21:24:55 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
end subroutine HDF5_read_int7
|
2018-11-18 14:17:50 +05:30
|
|
|
|
2019-02-09 14:14:41 +05:30
|
|
|
|
2018-10-10 21:24:55 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-06-11 13:18:07 +05:30
|
|
|
!> @brief write dataset of type real with 1 dimension
|
2018-10-10 21:24:55 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-04-04 15:19:23 +05:30
|
|
|
subroutine HDF5_write_real1(loc_id,dataset,datasetName,parallel)
|
2018-12-14 16:05:41 +05:30
|
|
|
|
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
|
2020-03-15 17:16:10 +05:30
|
|
|
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
|
2018-10-10 21:24:55 +05:30
|
|
|
|
|
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
integer :: hdferr
|
|
|
|
|
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id
|
|
|
|
|
integer(HSIZE_T), dimension(size(shape(dataset))) :: &
|
|
|
|
|
myStart, &
|
|
|
|
|
myShape, & !< shape of the dataset (this process)
|
|
|
|
|
totalShape !< shape of the dataset (all processes)
|
2018-11-18 14:17:50 +05:30
|
|
|
|
2019-02-09 14:08:49 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
2018-11-26 20:08:31 +05:30
|
|
|
! determine shape of dataset
|
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)
|
2018-11-26 20:08:31 +05:30
|
|
|
|
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, &
|
2021-02-22 18:07:21 +05:30
|
|
|
myStart, totalShape,loc_id,myShape,datasetName,H5T_NATIVE_DOUBLE,parallel_default)
|
2019-04-07 17:35:31 +05:30
|
|
|
endif
|
2018-10-10 21:24:55 +05:30
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
if (product(totalShape) /= 0) then
|
|
|
|
|
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)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-07 17:35:31 +05:30
|
|
|
endif
|
2018-10-05 12:26:06 +05:30
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
call finalize_write(plist_id, dset_id, filespace_id, memspace_id)
|
2018-10-10 21:24:55 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
end subroutine HDF5_write_real1
|
2018-10-10 21:24:55 +05:30
|
|
|
|
|
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-06-11 13:18:07 +05:30
|
|
|
!> @brief write dataset of type real with 2 dimensions
|
2018-10-10 21:24:55 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-04-04 15:19:23 +05:30
|
|
|
subroutine HDF5_write_real2(loc_id,dataset,datasetName,parallel)
|
2018-10-10 21:24:55 +05:30
|
|
|
|
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
|
2020-03-15 17:16:10 +05:30
|
|
|
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
|
2018-10-10 21:24:55 +05:30
|
|
|
|
|
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
integer :: hdferr
|
|
|
|
|
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id
|
|
|
|
|
integer(HSIZE_T), dimension(size(shape(dataset))) :: &
|
|
|
|
|
myStart, &
|
|
|
|
|
myShape, & !< shape of the dataset (this process)
|
|
|
|
|
totalShape !< shape of the dataset (all processes)
|
2018-11-18 14:17:50 +05:30
|
|
|
|
2019-02-09 14:08:49 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
2018-11-26 20:08:31 +05:30
|
|
|
! determine shape of dataset
|
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)
|
2018-11-26 20:08:31 +05:30
|
|
|
|
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, &
|
2021-02-22 18:07:21 +05:30
|
|
|
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_DOUBLE,parallel_default)
|
2019-04-07 17:35:31 +05:30
|
|
|
endif
|
2018-11-18 14:17:50 +05:30
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
if (product(totalShape) /= 0) then
|
|
|
|
|
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)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-07 17:35:31 +05:30
|
|
|
endif
|
2018-10-09 14:27:06 +05:30
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
call finalize_write(plist_id, dset_id, filespace_id, memspace_id)
|
2018-10-10 21:24:55 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
end subroutine HDF5_write_real2
|
2018-10-10 21:24:55 +05:30
|
|
|
|
|
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-06-11 13:18:07 +05:30
|
|
|
!> @brief write dataset of type real with 3 dimensions
|
2018-10-10 21:24:55 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-04-04 15:19:23 +05:30
|
|
|
subroutine HDF5_write_real3(loc_id,dataset,datasetName,parallel)
|
2018-10-10 21:24:55 +05:30
|
|
|
|
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
|
2020-03-15 17:16:10 +05:30
|
|
|
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
|
2018-10-10 21:24:55 +05:30
|
|
|
|
|
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
integer :: hdferr
|
|
|
|
|
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id
|
|
|
|
|
integer(HSIZE_T), dimension(size(shape(dataset))) :: &
|
|
|
|
|
myStart, &
|
|
|
|
|
myShape, & !< shape of the dataset (this process)
|
|
|
|
|
totalShape !< shape of the dataset (all processes)
|
2018-11-18 14:17:50 +05:30
|
|
|
|
2019-02-09 14:08:49 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
2018-11-26 20:08:31 +05:30
|
|
|
! determine shape of dataset
|
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)
|
2018-11-26 20:08:31 +05:30
|
|
|
|
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, &
|
2021-02-22 18:07:21 +05:30
|
|
|
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_DOUBLE,parallel_default)
|
2019-04-07 17:35:31 +05:30
|
|
|
endif
|
2018-10-10 21:24:55 +05:30
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
if (product(totalShape) /= 0) then
|
|
|
|
|
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)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-07 17:35:31 +05:30
|
|
|
endif
|
2018-10-10 21:24:55 +05:30
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
call finalize_write(plist_id, dset_id, filespace_id, memspace_id)
|
2018-10-10 21:24:55 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
end subroutine HDF5_write_real3
|
2018-10-10 21:24:55 +05:30
|
|
|
|
|
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-06-11 13:18:07 +05:30
|
|
|
!> @brief write dataset of type real with 4 dimensions
|
2018-10-10 21:24:55 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-04-04 15:19:23 +05:30
|
|
|
subroutine HDF5_write_real4(loc_id,dataset,datasetName,parallel)
|
2018-10-10 21:24:55 +05:30
|
|
|
|
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
|
2020-03-15 17:16:10 +05:30
|
|
|
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
|
2018-11-18 14:17:50 +05:30
|
|
|
|
|
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
integer :: hdferr
|
|
|
|
|
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id
|
|
|
|
|
integer(HSIZE_T), dimension(size(shape(dataset))) :: &
|
|
|
|
|
myStart, &
|
|
|
|
|
myShape, & !< shape of the dataset (this process)
|
|
|
|
|
totalShape !< shape of the dataset (all processes)
|
2018-11-18 14:17:50 +05:30
|
|
|
|
2019-02-09 14:08:49 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
2018-11-26 20:08:31 +05:30
|
|
|
! determine shape of dataset
|
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)
|
2020-03-15 17:16:10 +05:30
|
|
|
|
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, &
|
2021-02-22 18:07:21 +05:30
|
|
|
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_DOUBLE,parallel_default)
|
2019-04-07 17:35:31 +05:30
|
|
|
endif
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
if (product(totalShape) /= 0) then
|
|
|
|
|
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)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-07 17:35:31 +05:30
|
|
|
endif
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
call finalize_write(plist_id, dset_id, filespace_id, memspace_id)
|
2018-10-10 21:24:55 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
end subroutine HDF5_write_real4
|
2018-10-10 21:24:55 +05:30
|
|
|
|
2018-11-18 14:17:50 +05:30
|
|
|
|
2018-10-10 21:24:55 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-06-11 13:18:07 +05:30
|
|
|
!> @brief write dataset of type real with 5 dimensions
|
2018-10-10 21:24:55 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-04-04 15:19:23 +05:30
|
|
|
subroutine HDF5_write_real5(loc_id,dataset,datasetName,parallel)
|
2018-10-10 21:24:55 +05:30
|
|
|
|
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
|
2020-03-15 17:16:10 +05:30
|
|
|
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
|
2018-11-18 14:17:50 +05:30
|
|
|
|
|
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
integer :: hdferr
|
|
|
|
|
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id
|
|
|
|
|
integer(HSIZE_T), dimension(size(shape(dataset))) :: &
|
|
|
|
|
myStart, &
|
|
|
|
|
myShape, & !< shape of the dataset (this process)
|
|
|
|
|
totalShape !< shape of the dataset (all processes)
|
2018-11-18 14:17:50 +05:30
|
|
|
|
2019-02-09 14:08:49 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
2018-11-26 20:08:31 +05:30
|
|
|
! determine shape of dataset
|
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)
|
2020-03-15 17:16:10 +05:30
|
|
|
|
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, &
|
2021-02-22 18:07:21 +05:30
|
|
|
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_DOUBLE,parallel_default)
|
2019-04-07 17:35:31 +05:30
|
|
|
endif
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
if (product(totalShape) /= 0) then
|
|
|
|
|
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)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-07 17:35:31 +05:30
|
|
|
endif
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
call finalize_write(plist_id, dset_id, filespace_id, memspace_id)
|
2018-10-10 21:24:55 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
end subroutine HDF5_write_real5
|
2018-10-10 21:24:55 +05:30
|
|
|
|
|
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-06-11 13:18:07 +05:30
|
|
|
!> @brief write dataset of type real with 6 dimensions
|
2018-10-10 21:24:55 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-04-04 15:19:23 +05:30
|
|
|
subroutine HDF5_write_real6(loc_id,dataset,datasetName,parallel)
|
2018-10-10 21:24:55 +05:30
|
|
|
|
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
|
2020-03-15 17:16:10 +05:30
|
|
|
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
|
2018-10-10 21:24:55 +05:30
|
|
|
|
|
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
integer :: hdferr
|
|
|
|
|
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id
|
|
|
|
|
integer(HSIZE_T), dimension(size(shape(dataset))) :: &
|
|
|
|
|
myStart, &
|
|
|
|
|
myShape, & !< shape of the dataset (this process)
|
|
|
|
|
totalShape !< shape of the dataset (all processes)
|
2018-11-18 14:17:50 +05:30
|
|
|
|
2019-02-09 14:08:49 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
2018-11-26 20:08:31 +05:30
|
|
|
! determine shape of dataset
|
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)
|
2018-11-26 20:08:31 +05:30
|
|
|
|
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, &
|
2021-02-22 18:07:21 +05:30
|
|
|
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_DOUBLE,parallel_default)
|
2019-04-07 17:35:31 +05:30
|
|
|
endif
|
2018-11-18 14:17:50 +05:30
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
if (product(totalShape) /= 0) then
|
|
|
|
|
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)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-07 17:35:31 +05:30
|
|
|
endif
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
call finalize_write(plist_id, dset_id, filespace_id, memspace_id)
|
2018-10-10 21:24:55 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
end subroutine HDF5_write_real6
|
2018-10-10 21:24:55 +05:30
|
|
|
|
|
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-06-11 13:18:07 +05:30
|
|
|
!> @brief write dataset of type real with 7 dimensions
|
2018-10-10 21:24:55 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-04-04 15:19:23 +05:30
|
|
|
subroutine HDF5_write_real7(loc_id,dataset,datasetName,parallel)
|
2018-10-10 21:24:55 +05:30
|
|
|
|
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
|
2020-03-15 17:16:10 +05:30
|
|
|
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
|
2018-11-18 14:17:50 +05:30
|
|
|
|
|
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
integer :: hdferr
|
|
|
|
|
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id
|
|
|
|
|
integer(HSIZE_T), dimension(size(shape(dataset))) :: &
|
|
|
|
|
myStart, &
|
|
|
|
|
myShape, & !< shape of the dataset (this process)
|
|
|
|
|
totalShape !< shape of the dataset (all processes)
|
2018-11-18 14:17:50 +05:30
|
|
|
|
2019-02-09 14:08:49 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
2018-11-26 20:08:31 +05:30
|
|
|
! determine shape of dataset
|
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)
|
2018-11-26 20:08:31 +05:30
|
|
|
|
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, &
|
2021-02-22 18:07:21 +05:30
|
|
|
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_DOUBLE,parallel_default)
|
2019-04-07 17:35:31 +05:30
|
|
|
endif
|
2018-10-10 21:24:55 +05:30
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
if (product(totalShape) /= 0) then
|
|
|
|
|
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)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-07 17:35:31 +05:30
|
|
|
endif
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
call finalize_write(plist_id, dset_id, filespace_id, memspace_id)
|
2018-10-10 21:24:55 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
end subroutine HDF5_write_real7
|
2018-10-10 21:24:55 +05:30
|
|
|
|
2019-02-09 16:15:02 +05:30
|
|
|
|
2018-10-10 21:24:55 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-06-11 13:18:07 +05:30
|
|
|
!> @brief write dataset of type integer with 1 dimension
|
2018-10-10 21:24:55 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-04-04 15:19:23 +05:30
|
|
|
subroutine HDF5_write_int1(loc_id,dataset,datasetName,parallel)
|
2018-10-10 21:24:55 +05:30
|
|
|
|
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
|
2020-03-15 17:16:10 +05:30
|
|
|
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
|
2018-11-21 21:27:36 +05:30
|
|
|
|
2018-10-10 21:24:55 +05:30
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
integer :: hdferr
|
|
|
|
|
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id
|
|
|
|
|
integer(HSIZE_T), dimension(size(shape(dataset))) :: &
|
|
|
|
|
myStart, &
|
|
|
|
|
myShape, & !< shape of the dataset (this process)
|
|
|
|
|
totalShape !< shape of the dataset (all processes)
|
2018-11-21 21:27:36 +05:30
|
|
|
|
2019-02-09 14:08:49 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
2018-11-26 20:08:31 +05:30
|
|
|
! determine shape of dataset
|
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)
|
2018-11-21 21:27:36 +05:30
|
|
|
|
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, &
|
2021-02-22 18:07:21 +05:30
|
|
|
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_INTEGER,parallel_default)
|
2019-04-07 17:35:31 +05:30
|
|
|
endif
|
2018-11-21 21:27:36 +05:30
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
if (product(totalShape) /= 0) then
|
|
|
|
|
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)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-07 17:35:31 +05:30
|
|
|
endif
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
call finalize_write(plist_id, dset_id, filespace_id, memspace_id)
|
2018-10-10 21:24:55 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
end subroutine HDF5_write_int1
|
2018-10-10 21:24:55 +05:30
|
|
|
|
|
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-06-11 13:18:07 +05:30
|
|
|
!> @brief write dataset of type integer with 2 dimensions
|
2018-10-10 21:24:55 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-04-04 15:19:23 +05:30
|
|
|
subroutine HDF5_write_int2(loc_id,dataset,datasetName,parallel)
|
2018-10-10 21:24:55 +05:30
|
|
|
|
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
|
2020-03-15 17:16:10 +05:30
|
|
|
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
|
2018-11-21 21:27:36 +05:30
|
|
|
|
2018-10-10 21:24:55 +05:30
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
integer :: hdferr
|
|
|
|
|
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id
|
|
|
|
|
integer(HSIZE_T), dimension(size(shape(dataset))) :: &
|
|
|
|
|
myStart, &
|
|
|
|
|
myShape, & !< shape of the dataset (this process)
|
|
|
|
|
totalShape !< shape of the dataset (all processes)
|
2018-11-21 21:27:36 +05:30
|
|
|
|
2019-02-09 14:08:49 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
2018-11-26 20:08:31 +05:30
|
|
|
! determine shape of dataset
|
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)
|
2018-11-21 21:27:36 +05:30
|
|
|
|
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, &
|
2021-02-22 18:07:21 +05:30
|
|
|
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_INTEGER,parallel_default)
|
2019-04-07 17:35:31 +05:30
|
|
|
endif
|
2018-11-21 21:27:36 +05:30
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
if (product(totalShape) /= 0) then
|
|
|
|
|
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)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-07 17:35:31 +05:30
|
|
|
endif
|
2018-10-10 21:24:55 +05:30
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
call finalize_write(plist_id, dset_id, filespace_id, memspace_id)
|
2018-10-10 21:24:55 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
end subroutine HDF5_write_int2
|
2018-10-10 21:24:55 +05:30
|
|
|
|
|
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-06-11 13:18:07 +05:30
|
|
|
!> @brief write dataset of type integer with 3 dimensions
|
2018-10-10 21:24:55 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-04-04 15:19:23 +05:30
|
|
|
subroutine HDF5_write_int3(loc_id,dataset,datasetName,parallel)
|
2018-10-10 21:24:55 +05:30
|
|
|
|
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
|
2020-03-15 17:16:10 +05:30
|
|
|
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
|
2018-11-21 21:27:36 +05:30
|
|
|
|
2018-10-10 21:24:55 +05:30
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
integer :: hdferr
|
|
|
|
|
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id
|
|
|
|
|
integer(HSIZE_T), dimension(size(shape(dataset))) :: &
|
|
|
|
|
myStart, &
|
|
|
|
|
myShape, & !< shape of the dataset (this process)
|
|
|
|
|
totalShape !< shape of the dataset (all processes)
|
2018-11-21 21:27:36 +05:30
|
|
|
|
2019-02-09 14:08:49 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
2018-11-26 20:08:31 +05:30
|
|
|
! determine shape of dataset
|
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)
|
2018-11-21 21:27:36 +05:30
|
|
|
|
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, &
|
2021-02-22 18:07:21 +05:30
|
|
|
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_INTEGER,parallel_default)
|
2019-04-07 17:35:31 +05:30
|
|
|
endif
|
2018-11-21 21:27:36 +05:30
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
if (product(totalShape) /= 0) then
|
|
|
|
|
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)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-07 17:35:31 +05:30
|
|
|
endif
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
call finalize_write(plist_id, dset_id, filespace_id, memspace_id)
|
2018-10-10 21:24:55 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
end subroutine HDF5_write_int3
|
2018-10-10 21:24:55 +05:30
|
|
|
|
|
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-06-11 13:18:07 +05:30
|
|
|
!> @brief write dataset of type integer with 4 dimensions
|
2018-10-10 21:24:55 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-04-04 15:19:23 +05:30
|
|
|
subroutine HDF5_write_int4(loc_id,dataset,datasetName,parallel)
|
2018-10-10 21:24:55 +05:30
|
|
|
|
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
|
2020-03-15 17:16:10 +05:30
|
|
|
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
|
2018-11-21 21:27:36 +05:30
|
|
|
|
2018-10-10 21:24:55 +05:30
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
integer :: hdferr
|
|
|
|
|
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id
|
|
|
|
|
integer(HSIZE_T), dimension(size(shape(dataset))) :: &
|
|
|
|
|
myStart, &
|
|
|
|
|
myShape, & !< shape of the dataset (this process)
|
|
|
|
|
totalShape !< shape of the dataset (all processes)
|
2018-11-21 21:27:36 +05:30
|
|
|
|
2019-02-09 14:08:49 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
2018-11-26 20:08:31 +05:30
|
|
|
! determine shape of dataset
|
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)
|
2018-11-21 21:27:36 +05:30
|
|
|
|
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, &
|
2021-02-22 18:07:21 +05:30
|
|
|
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_INTEGER,parallel_default)
|
2019-04-07 17:35:31 +05:30
|
|
|
endif
|
2018-11-21 21:27:36 +05:30
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
if (product(totalShape) /= 0) then
|
|
|
|
|
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)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-07 17:35:31 +05:30
|
|
|
endif
|
2018-10-10 21:24:55 +05:30
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
call finalize_write(plist_id, dset_id, filespace_id, memspace_id)
|
2018-10-10 21:24:55 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
end subroutine HDF5_write_int4
|
2018-10-10 21:24:55 +05:30
|
|
|
|
|
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-06-11 13:18:07 +05:30
|
|
|
!> @brief write dataset of type integer with 5 dimensions
|
2018-10-10 21:24:55 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-04-04 15:19:23 +05:30
|
|
|
subroutine HDF5_write_int5(loc_id,dataset,datasetName,parallel)
|
2018-10-10 21:24:55 +05:30
|
|
|
|
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
|
2020-03-15 17:16:10 +05:30
|
|
|
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
|
2018-11-21 21:27:36 +05:30
|
|
|
|
2018-10-10 21:24:55 +05:30
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
integer :: hdferr
|
|
|
|
|
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id
|
|
|
|
|
integer(HSIZE_T), dimension(size(shape(dataset))) :: &
|
|
|
|
|
myStart, &
|
|
|
|
|
myShape, & !< shape of the dataset (this process)
|
|
|
|
|
totalShape !< shape of the dataset (all processes)
|
2018-11-21 21:27:36 +05:30
|
|
|
|
2019-02-09 14:08:49 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
2018-11-26 20:08:31 +05:30
|
|
|
! determine shape of dataset
|
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)
|
2018-11-21 21:27:36 +05:30
|
|
|
|
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, &
|
2021-02-22 18:07:21 +05:30
|
|
|
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_INTEGER,parallel_default)
|
2019-04-07 17:35:31 +05:30
|
|
|
endif
|
2018-11-21 21:27:36 +05:30
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
if (product(totalShape) /= 0) then
|
|
|
|
|
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)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-07 17:35:31 +05:30
|
|
|
endif
|
2018-10-10 21:24:55 +05:30
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
call finalize_write(plist_id, dset_id, filespace_id, memspace_id)
|
2018-10-10 21:24:55 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
end subroutine HDF5_write_int5
|
2018-10-10 21:24:55 +05:30
|
|
|
|
|
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-06-11 13:18:07 +05:30
|
|
|
!> @brief write dataset of type integer with 6 dimensions
|
2018-10-10 21:24:55 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-04-04 15:19:23 +05:30
|
|
|
subroutine HDF5_write_int6(loc_id,dataset,datasetName,parallel)
|
2018-10-10 21:24:55 +05:30
|
|
|
|
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
|
2020-03-15 17:16:10 +05:30
|
|
|
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
|
2018-10-10 21:24:55 +05:30
|
|
|
|
2018-11-21 21:27:36 +05:30
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
integer :: hdferr
|
|
|
|
|
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id
|
|
|
|
|
integer(HSIZE_T), dimension(size(shape(dataset))) :: &
|
|
|
|
|
myStart, &
|
|
|
|
|
myShape, & !< shape of the dataset (this process)
|
|
|
|
|
totalShape !< shape of the dataset (all processes)
|
2018-11-21 21:27:36 +05:30
|
|
|
|
2019-02-09 14:08:49 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
2018-11-26 20:08:31 +05:30
|
|
|
! determine shape of dataset
|
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)
|
2018-11-21 21:27:36 +05:30
|
|
|
|
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, &
|
2021-02-22 18:07:21 +05:30
|
|
|
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_INTEGER,parallel_default)
|
2019-04-07 17:35:31 +05:30
|
|
|
endif
|
2018-11-21 21:27:36 +05:30
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
if (product(totalShape) /= 0) then
|
|
|
|
|
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)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-07 17:35:31 +05:30
|
|
|
endif
|
2018-10-10 21:24:55 +05:30
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
call finalize_write(plist_id, dset_id, filespace_id, memspace_id)
|
2018-10-10 21:24:55 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
end subroutine HDF5_write_int6
|
2018-10-10 21:24:55 +05:30
|
|
|
|
|
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-06-11 13:18:07 +05:30
|
|
|
!> @brief write dataset of type integer with 7 dimensions
|
2018-10-10 21:24:55 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-04-04 15:19:23 +05:30
|
|
|
subroutine HDF5_write_int7(loc_id,dataset,datasetName,parallel)
|
2018-10-10 21:24:55 +05:30
|
|
|
|
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
|
2020-03-15 17:16:10 +05:30
|
|
|
logical, intent(in), optional :: parallel !< dataset is distributed over multiple processes
|
2018-11-21 21:27:36 +05:30
|
|
|
|
2018-10-10 21:24:55 +05:30
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
integer :: hdferr
|
|
|
|
|
integer(HID_T) :: dset_id, filespace_id, memspace_id, plist_id
|
|
|
|
|
integer(HSIZE_T), dimension(size(shape(dataset))) :: &
|
|
|
|
|
myStart, &
|
|
|
|
|
myShape, & !< shape of the dataset (this process)
|
|
|
|
|
totalShape !< shape of the dataset (all processes)
|
2018-11-21 21:27:36 +05:30
|
|
|
|
2019-02-09 14:08:49 +05:30
|
|
|
!---------------------------------------------------------------------------------------------------
|
2018-11-26 20:08:31 +05:30
|
|
|
! determine shape of dataset
|
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)
|
2018-11-21 21:27:36 +05:30
|
|
|
|
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, &
|
2021-02-22 18:07:21 +05:30
|
|
|
myStart, totalShape, loc_id,myShape,datasetName,H5T_NATIVE_INTEGER,parallel_default)
|
2019-04-07 17:35:31 +05:30
|
|
|
endif
|
2018-11-21 21:27:36 +05:30
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
if (product(totalShape) /= 0) then
|
|
|
|
|
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)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-07 17:35:31 +05:30
|
|
|
endif
|
2018-10-10 21:24:55 +05:30
|
|
|
|
2019-04-07 17:35:31 +05:30
|
|
|
call finalize_write(plist_id, dset_id, filespace_id, memspace_id)
|
2018-10-10 21:24:55 +05:30
|
|
|
|
2019-04-04 15:19:23 +05:30
|
|
|
end subroutine HDF5_write_int7
|
2018-10-10 21:24:55 +05:30
|
|
|
|
2018-08-03 12:23:37 +05:30
|
|
|
|
2019-02-09 12:35:29 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-02-09 16:15:02 +05:30
|
|
|
!> @brief initialize HDF5 handles, determines global shape and start for parallel read
|
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)
|
|
|
|
|
|
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(:) :: &
|
2020-03-15 17:16:10 +05:30
|
|
|
localShape
|
2019-06-15 20:12:16 +05:30
|
|
|
integer(HSIZE_T), intent(out), dimension(size(localShape,1)):: &
|
|
|
|
|
myStart, &
|
|
|
|
|
globalShape !< shape of the dataset (all processes)
|
|
|
|
|
integer(HID_T), intent(out) :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-06-15 20:12:16 +05:30
|
|
|
integer, dimension(worldsize) :: &
|
|
|
|
|
readSize !< contribution of all processes
|
|
|
|
|
integer :: ierr
|
|
|
|
|
integer :: hdferr
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2019-02-09 12:35:29 +05:30
|
|
|
!-------------------------------------------------------------------------------------------------
|
2019-02-09 16:15:02 +05:30
|
|
|
! creating a property list for transfer properties (is collective for MPI)
|
2019-06-15 20:12:16 +05:30
|
|
|
call h5pcreate_f(H5P_DATASET_XFER_F, plist_id, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-02-09 12:35:29 +05:30
|
|
|
|
|
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-06-15 20:12:16 +05:30
|
|
|
readSize = 0
|
|
|
|
|
readSize(worldrank+1) = int(localShape(ubound(localShape,1)))
|
2019-02-09 12:35:29 +05:30
|
|
|
#ifdef PETSc
|
2019-06-15 20:12:16 +05:30
|
|
|
if (parallel) then
|
|
|
|
|
call h5pset_dxpl_mpio_f(plist_id, H5FD_MPIO_COLLECTIVE_F, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-06-15 20:12:16 +05:30
|
|
|
call MPI_allreduce(MPI_IN_PLACE,readSize,worldsize,MPI_INT,MPI_SUM,PETSC_COMM_WORLD,ierr) ! get total output size over each process
|
2020-11-11 14:49:47 +05:30
|
|
|
if (ierr /= 0) error stop 'MPI error'
|
2019-06-15 20:12:16 +05:30
|
|
|
endif
|
2019-02-09 12:35:29 +05:30
|
|
|
#endif
|
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)]
|
2019-02-09 12:35:29 +05:30
|
|
|
|
|
|
|
|
!--------------------------------------------------------------------------------------------------
|
|
|
|
|
! create dataspace in memory (local shape)
|
2019-06-15 20:12:16 +05:30
|
|
|
call h5screate_simple_f(size(localShape), localShape, memspace_id, hdferr, localShape)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-02-09 16:15:02 +05:30
|
|
|
|
2019-02-09 12:35:29 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-02-09 16:15:02 +05:30
|
|
|
! creating a property list for IO and set it to collective
|
2020-03-15 17:16:10 +05:30
|
|
|
call h5pcreate_f(H5P_DATASET_ACCESS_F, aplist_id, hdferr)
|
2020-12-06 14:50:32 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-03-09 21:21:50 +05:30
|
|
|
#ifdef PETSc
|
2019-06-15 20:12:16 +05:30
|
|
|
call h5pset_all_coll_metadata_ops_f(aplist_id, .true., hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-03-09 21:21:50 +05:30
|
|
|
#endif
|
2019-02-09 12:35:29 +05:30
|
|
|
|
|
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-02-09 16:15:02 +05:30
|
|
|
! open the dataset in the file and get the space ID
|
2019-06-15 20:12:16 +05:30
|
|
|
call h5dopen_f(loc_id,datasetName,dset_id,hdferr, dapl_id = aplist_id)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-06-15 20:12:16 +05:30
|
|
|
call h5dget_space_f(dset_id, filespace_id, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-02-09 12:35:29 +05:30
|
|
|
|
|
|
|
|
!--------------------------------------------------------------------------------------------------
|
|
|
|
|
! select a hyperslab (the portion of the current process) in the file
|
2019-06-15 20:12:16 +05:30
|
|
|
call h5sselect_hyperslab_f(filespace_id, H5S_SELECT_SET_F, myStart, localShape, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-02-09 12:35:29 +05:30
|
|
|
|
|
|
|
|
end subroutine initialize_read
|
|
|
|
|
|
2019-02-09 13:31:37 +05:30
|
|
|
|
|
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-02-09 16:15:02 +05:30
|
|
|
!> @brief closes HDF5 handles
|
2019-02-09 14:08:49 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
|
|
|
|
subroutine finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)
|
|
|
|
|
|
2020-12-06 14:50:32 +05:30
|
|
|
integer(HID_T), intent(in) :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
|
2019-06-15 20:12:16 +05:30
|
|
|
integer :: hdferr
|
2019-02-09 14:08:49 +05:30
|
|
|
|
2019-06-15 20:12:16 +05:30
|
|
|
call h5pclose_f(plist_id, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-06-15 20:12:16 +05:30
|
|
|
call h5pclose_f(aplist_id, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-06-15 20:12:16 +05:30
|
|
|
call h5dclose_f(dset_id, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-06-15 20:12:16 +05:30
|
|
|
call h5sclose_f(filespace_id, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-06-15 20:12:16 +05:30
|
|
|
call h5sclose_f(memspace_id, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-02-09 14:08:49 +05:30
|
|
|
|
|
|
|
|
end subroutine finalize_read
|
|
|
|
|
|
2019-02-09 16:15:02 +05:30
|
|
|
|
2019-02-09 14:08:49 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-02-09 16:15:02 +05:30
|
|
|
!> @brief initialize HDF5 handles, determines global shape and start for parallel write
|
2019-02-09 13:31:37 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
|
|
|
|
subroutine initialize_write(dset_id, filespace_id, memspace_id, plist_id, &
|
2020-12-06 14:50:32 +05:30
|
|
|
myStart, totalShape, &
|
|
|
|
|
loc_id,myShape,datasetName,datatype,parallel)
|
2019-02-09 13:31:37 +05:30
|
|
|
|
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(:) :: &
|
2020-03-15 17:16:10 +05:30
|
|
|
myShape
|
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
|
2020-03-15 17:16:10 +05:30
|
|
|
|
2020-12-06 14:50:32 +05:30
|
|
|
integer, dimension(worldsize) :: writeSize !< contribution of all processes
|
|
|
|
|
integer(HID_T) :: dcpl
|
|
|
|
|
integer :: ierr, hdferr
|
|
|
|
|
integer(HSIZE_T), parameter :: chunkSize = 1024_HSIZE_T**2/8_HSIZE_T
|
2019-02-09 13:31:37 +05:30
|
|
|
|
|
|
|
|
!-------------------------------------------------------------------------------------------------
|
2019-04-04 13:33:52 +05:30
|
|
|
! creating a property list for transfer properties (is collective when reading in parallel)
|
2019-06-15 20:12:16 +05:30
|
|
|
call h5pcreate_f(H5P_DATASET_XFER_F, plist_id, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-04 13:33:52 +05:30
|
|
|
#ifdef PETSc
|
2019-06-15 20:12:16 +05:30
|
|
|
if (parallel) then
|
|
|
|
|
call h5pset_dxpl_mpio_f(plist_id, H5FD_MPIO_COLLECTIVE_F, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-06-15 20:12:16 +05:30
|
|
|
endif
|
2019-04-04 13:33:52 +05:30
|
|
|
#endif
|
2019-02-09 13:31:37 +05:30
|
|
|
|
|
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-04-04 13:33:52 +05:30
|
|
|
! determine the global data layout among all processes
|
2019-06-15 20:12:16 +05:30
|
|
|
writeSize = 0
|
|
|
|
|
writeSize(worldrank+1) = int(myShape(ubound(myShape,1)))
|
2019-02-09 13:31:37 +05:30
|
|
|
#ifdef PETSc
|
2019-06-15 20:12:16 +05:30
|
|
|
if (parallel) then
|
|
|
|
|
call MPI_allreduce(MPI_IN_PLACE,writeSize,worldsize,MPI_INT,MPI_SUM,PETSC_COMM_WORLD,ierr) ! get total output size over each process
|
2020-11-11 14:49:47 +05:30
|
|
|
if (ierr /= 0) error stop 'MPI error'
|
2019-06-15 20:12:16 +05:30
|
|
|
endif
|
2019-02-09 13:31:37 +05:30
|
|
|
#endif
|
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)]
|
2019-02-09 13:31:37 +05:30
|
|
|
|
2020-12-06 14:50:32 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
|
|
|
|
! compress (and chunk) larger datasets
|
|
|
|
|
call h5pcreate_f(H5P_DATASET_CREATE_F, dcpl, hdferr)
|
|
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
|
|
|
|
if(product(totalShape) >= chunkSize*2_HSIZE_T) then
|
|
|
|
|
call h5pset_chunk_f(dcpl, size(totalShape), getChunks(totalShape,chunkSize), hdferr)
|
|
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2020-12-07 00:27:00 +05:30
|
|
|
call h5pset_shuffle_f(dcpl, hdferr)
|
|
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2020-12-06 14:50:32 +05:30
|
|
|
call h5pset_deflate_f(dcpl, 6, hdferr)
|
|
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2020-12-07 00:27:00 +05:30
|
|
|
call h5pset_Fletcher32_f(dcpl,hdferr)
|
|
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2020-12-06 14:50:32 +05:30
|
|
|
endif
|
|
|
|
|
|
2019-02-09 13:31:37 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-02-09 16:15:02 +05:30
|
|
|
! create dataspace in memory (local shape) and in file (global shape)
|
2019-06-15 20:12:16 +05:30
|
|
|
call h5screate_simple_f(size(myShape), myShape, memspace_id, hdferr, myShape)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-06-15 20:12:16 +05:30
|
|
|
call h5screate_simple_f(size(totalShape), totalShape, filespace_id, hdferr, totalShape)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-02-09 13:31:37 +05:30
|
|
|
|
|
|
|
|
!--------------------------------------------------------------------------------------------------
|
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)
|
2020-12-06 14:50:32 +05:30
|
|
|
call h5dcreate_f(loc_id, trim(datasetName), datatype, filespace_id, dset_id, hdferr, dcpl)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-06-15 20:12:16 +05:30
|
|
|
call h5sselect_hyperslab_f(filespace_id, H5S_SELECT_SET_F, myStart, myShape, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-04-04 13:33:52 +05:30
|
|
|
|
2020-12-06 14:50:32 +05:30
|
|
|
call h5pclose_f(dcpl , hdferr)
|
|
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
|
|
|
|
|
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
|
|
|
|
|
|
2019-02-09 13:31:37 +05:30
|
|
|
end subroutine initialize_write
|
|
|
|
|
|
|
|
|
|
|
2019-02-09 14:14:41 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
2019-02-09 16:15:02 +05:30
|
|
|
!> @brief closes HDF5 handles
|
2019-02-09 14:14:41 +05:30
|
|
|
!--------------------------------------------------------------------------------------------------
|
|
|
|
|
subroutine finalize_write(plist_id, dset_id, filespace_id, memspace_id)
|
2018-12-14 16:05:41 +05:30
|
|
|
|
2019-06-15 20:12:16 +05:30
|
|
|
integer(HID_T), intent(in) :: dset_id, filespace_id, memspace_id, plist_id
|
|
|
|
|
integer :: hdferr
|
2018-12-14 16:05:41 +05:30
|
|
|
|
2019-06-15 20:12:16 +05:30
|
|
|
call h5pclose_f(plist_id, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-06-15 20:12:16 +05:30
|
|
|
call h5dclose_f(dset_id, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-06-15 20:12:16 +05:30
|
|
|
call h5sclose_f(filespace_id, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2019-06-15 20:12:16 +05:30
|
|
|
call h5sclose_f(memspace_id, hdferr)
|
2020-11-11 14:49:47 +05:30
|
|
|
if(hdferr < 0) error stop 'HDF5 error'
|
2018-12-14 16:05:41 +05:30
|
|
|
|
2019-02-09 14:14:41 +05:30
|
|
|
end subroutine finalize_write
|
2019-06-15 20:12:16 +05:30
|
|
|
|
2020-12-06 14:50:32 +05:30
|
|
|
|
2019-02-09 14:14:41 +05:30
|
|
|
end module HDF5_Utilities
|
