! SPDX-License-Identifier: AGPL-3.0-or-later
! Copyright 2024-2025 Max-Planck-Institut für Nachhaltige Materialien GmbH
! Copyright 2011-2024 Max-Planck-Institut für Eisenforschung GmbH
!
! DAMASK is free software: you can redistribute it and/or modify
! it under the terms of the GNU Affero General Public License as
! published by the Free Software Foundation, either version 3 of the
! License, or (at your option) any later version.
!
! This program is distributed in the hope that it will be useful,
! but WITHOUT ANY WARRANTY; without even the implied warranty of
! MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
! GNU Affero General Public License for more details.
!
! You should have received a copy of the GNU Affero General Public License
! along with this program.  If not, see <https://www.gnu.org/licenses/>.
!--------------------------------------------------------------------------------------------------
!> @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
!> @author Philip Eisenlohr, Michigan State University
!--------------------------------------------------------------------------------------------------
#ifdef PETSC
#include <petsc/finclude/petscsys.h>
#endif
module HDF5_utilities
  use IO
  use HDF5
#ifdef PETSC
  use PETScSys
#ifndef PETSC_EXPOSES_MPI
  use MPI_f08
  use MPI, only: MPI_INFO_NULL_F90 => MPI_INFO_NULL
#endif
#endif

  use prec
  use parallelization
  use misc

#ifndef PETSC_EXPOSES_MPIF90
  implicit none(type,external)
#else
  implicit none
#endif
  private

!--------------------------------------------------------------------------------------------------
!> @brief Read integer or real data of defined shape from file.
!> @details for parallel IO, all dimension except for the last need to match
!--------------------------------------------------------------------------------------------------
  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_int1
    module procedure HDF5_read_int2
    module procedure HDF5_read_int3
    module procedure HDF5_read_int4
    module procedure HDF5_read_int5
  end interface HDF5_read

!--------------------------------------------------------------------------------------------------
!> @brief Write integer or real data of defined shape to file.
!> @details for parallel IO, all dimension except for the last need to match
!--------------------------------------------------------------------------------------------------
  interface HDF5_write
#if defined(__GFORTRAN__)
    ! https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105674
    ! https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105687
    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_int1
    module procedure HDF5_write_int2
    module procedure HDF5_write_int3
    module procedure HDF5_write_int4
    module procedure HDF5_write_int5
#else
    module procedure HDF5_write_real
    module procedure HDF5_write_int
#endif
  end interface HDF5_write

!--------------------------------------------------------------------------------------------------
!> @brief Attach attribute of type char, integer, or real to a file/dataset/group.
!--------------------------------------------------------------------------------------------------
  interface HDF5_addAttribute
    module procedure HDF5_addAttribute_str
    module procedure HDF5_addAttribute_int
    module procedure HDF5_addAttribute_real
    module procedure HDF5_addAttribute_str_array
    module procedure HDF5_addAttribute_int_array
    module procedure HDF5_addAttribute_real_array
  end interface HDF5_addAttribute

#ifdef PETSC
  logical, parameter :: parallel_default = .true.
#else
  logical, parameter :: parallel_default = .false.
#endif
  logical :: compression_possible

  public :: &
    HDF5_utilities_init, &
    HDF5_chkerr, &
    HDF5_read, &
    HDF5_write, &
    HDF5_write_str, &
    HDF5_addAttribute, &
    HDF5_addGroup, &
    HDF5_openGroup, &
    HDF5_closeGroup, &
    HDF5_openFile, &
    HDF5_closeFile, &
    HDF5_objectExists, &
    HDF5_setLink

contains


!--------------------------------------------------------------------------------------------------
!> @brief Initialize HDF5 libary and perform sanity checks.
!--------------------------------------------------------------------------------------------------
subroutine HDF5_utilities_init()

  integer :: hdferr, HDF5_major, HDF5_minor, HDF5_release, configFlags
  logical :: avail
  integer(SIZE_T) :: typeSize


  print'(/,1x,a)', '<<<+-  HDF5_utilities init  -+>>>'


  call H5Open_f(hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

  call H5Tget_size_f(H5T_NATIVE_INTEGER,typeSize, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  if (int(bit_size(0),SIZE_T)/=typeSize*8) &
    error stop 'Default integer size does not match H5T_NATIVE_INTEGER'

  call H5Tget_size_f(H5T_NATIVE_DOUBLE,typeSize, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  if (int(storage_size(0.0_pREAL),SIZE_T)/=typeSize*8) &
    error stop 'pREAL does not match H5T_NATIVE_DOUBLE'

  call H5get_libversion_f(HDF5_major,HDF5_minor,HDF5_release,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  compression_possible = (HDF5_major == 1 .and. HDF5_minor >= 12)                                   ! https://forum.hdfgroup.org/t/6186

  call H5Zfilter_avail_f(H5Z_FILTER_DEFLATE_F,avail,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  compression_possible = compression_possible .and. avail

  if (avail) then
    call H5Zget_filter_info_f(H5Z_FILTER_DEFLATE_F,configFlags,hdferr)
    call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
    compression_possible = compression_possible .and. iand(H5Z_FILTER_ENCODE_ENABLED_F,configFlags) > 0
  end if

  call H5Zfilter_avail_f(H5Z_FILTER_SHUFFLE_F,avail,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  compression_possible = compression_possible .and. avail

  if (avail) then
    call H5Zget_filter_info_f(H5Z_FILTER_SHUFFLE_F,configFlags,hdferr)
    call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
    compression_possible = compression_possible .and. iand(H5Z_FILTER_ENCODE_ENABLED_F,configFlags) > 0
  end if

end subroutine HDF5_utilities_init


!--------------------------------------------------------------------------------------------------
!> @brief Check for HDF5 error.
!--------------------------------------------------------------------------------------------------
subroutine HDF5_chkerr(e,msg)

  integer, intent(in) :: e                                                                         !< error code (negative for failure)

  character(len=*), intent(in), optional :: msg                                                    !< error message


  if (present(msg)) then
    if (e<0) error stop 'HDF5 error ('//msg//')'
  else
    if (e<0) error stop 'HDF5 error'
  end if

end subroutine HDF5_chkerr


!--------------------------------------------------------------------------------------------------
!> @brief Open and initialize HDF5 file.
!--------------------------------------------------------------------------------------------------
integer(HID_T) function HDF5_openFile(fileName,mode,parallel)

  character(len=*), intent(in)           :: fileName
  character,        intent(in), optional :: mode
  logical,          intent(in), optional :: parallel

  character      :: m
  integer(HID_T) :: plist_access_id,plist_create_id
  integer :: hdferr
  logical :: exist


  m = misc_optional(mode,'r')

  call H5Pcreate_f(H5P_FILE_CREATE_F,plist_create_id,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  call H5Pset_link_creation_order_f(plist_create_id,ior(H5P_CRT_ORDER_INDEXED_F,H5P_CRT_ORDER_TRACKED_F),hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

  call H5Pcreate_f(H5P_FILE_ACCESS_F, plist_access_id,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
#ifdef PETSC
  if (misc_optional(parallel,.true.)) &
#if defined(PETSC_EXPOSES_MPIF90)
    call H5Pset_fapl_mpio_f(plist_access_id, PETSC_COMM_WORLD,       MPI_INFO_NULL,     hdferr)
#elif !defined(HDF5_SUPPORTS_MPIF08)
    call H5Pset_fapl_mpio_f(plist_access_id, MPI_COMM_WORLD%MPI_val, MPI_INFO_NULL_F90, hdferr)
#else
    call H5Pset_fapl_mpio_f(plist_access_id, MPI_COMM_WORLD,         MPI_INFO_NULL, hdferr)
#endif
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
#endif

  if     (m == 'w') then
    call H5Fcreate_f(fileName,H5F_ACC_TRUNC_F,HDF5_openFile,hdferr,&
                     access_prp=plist_access_id,creation_prp=plist_create_id)
    call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  elseif (m == 'a') then
    call H5Fopen_f(fileName,H5F_ACC_RDWR_F,HDF5_openFile,hdferr,access_prp=plist_access_id)
    call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  elseif (m == 'r') then
    inquire(file=fileName,exist=exist)
    if (.not. exist) call IO_error(100_pI16,'file does not exist',trim(fileName),emph=[2])
    call H5Fopen_f(fileName,H5F_ACC_RDONLY_F,HDF5_openFile,hdferr,access_prp=plist_access_id)
    call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  else
    error stop 'unknown access mode'
  end if

  call H5Pclose_f(plist_access_id, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  call H5Pclose_f(plist_create_id, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

end function HDF5_openFile


!--------------------------------------------------------------------------------------------------
!> @brief Close an open HDF5 file.
!--------------------------------------------------------------------------------------------------
subroutine HDF5_closeFile(fileHandle)

  integer(HID_T), intent(in) :: fileHandle

  integer     :: hdferr


  call H5Fclose_f(fileHandle,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

end subroutine HDF5_closeFile


!--------------------------------------------------------------------------------------------------
!> @brief Add a new group to the file.
!--------------------------------------------------------------------------------------------------
integer(HID_T) function HDF5_addGroup(fileHandle,groupName)

  integer(HID_T),   intent(in) :: fileHandle
  character(len=*), intent(in) :: groupName

  integer        :: hdferr
  integer(HID_T) :: gapl_id, gcpl_id


!-------------------------------------------------------------------------------------------------
! set I/O mode to collective (for MPI parallel simulations)
  call H5Pcreate_f(H5P_GROUP_ACCESS_F,gapl_id,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
#ifdef PETSC
  call H5Pset_all_coll_metadata_ops_f(gapl_id,.true.,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
#endif

!-------------------------------------------------------------------------------------------------
! keep creation order in group
  call H5Pcreate_f(H5P_GROUP_CREATE_F,gcpl_id,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  call H5Pset_link_creation_order_f(gcpl_id,ior(H5P_CRT_ORDER_INDEXED_F,H5P_CRT_ORDER_TRACKED_F),hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

!-------------------------------------------------------------------------------------------------
! Create group
  call H5Gcreate_f(fileHandle,trim(groupName),HDF5_addGroup,hdferr, &
                   OBJECT_NAMELEN_DEFAULT_F,gcpl_id=gcpl_id,gapl_id=gapl_id)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

  call H5Pclose_f(gcpl_id,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  call H5Pclose_f(gapl_id,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

end function HDF5_addGroup


!--------------------------------------------------------------------------------------------------
!> @brief Open an existing group in a file.
!--------------------------------------------------------------------------------------------------
integer(HID_T) function HDF5_openGroup(fileHandle,groupName)

  integer(HID_T),   intent(in) :: fileHandle
  character(len=*), intent(in) :: groupName


  integer        :: hdferr
  integer(HID_T) :: aplist_id
  logical        :: is_collective


 !-------------------------------------------------------------------------------------------------
 ! creating a property list for data access properties
  call H5Pcreate_f(H5P_GROUP_ACCESS_F, aplist_id, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

 !-------------------------------------------------------------------------------------------------
 ! setting I/O mode to collective
#ifdef PETSC
  call H5Pget_all_coll_metadata_ops_f(aplist_id, is_collective, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
#endif

 !-------------------------------------------------------------------------------------------------
 ! opening the group
  call H5Gopen_f(fileHandle, trim(groupName), HDF5_openGroup, hdferr, gapl_id = aplist_id)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

  call H5Pclose_f(aplist_id,hdferr)

end function HDF5_openGroup


!--------------------------------------------------------------------------------------------------
!> @brief Close a group.
!--------------------------------------------------------------------------------------------------
subroutine HDF5_closeGroup(group_id)

  integer(HID_T), intent(in) :: group_id

  integer :: hdferr


  call H5Gclose_f(group_id, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

end subroutine HDF5_closeGroup


!--------------------------------------------------------------------------------------------------
!> @brief Check whether a group or a dataset exists.
!--------------------------------------------------------------------------------------------------
logical function HDF5_objectExists(loc_id,path)

  integer(HID_T),   intent(in)            :: loc_id
  character(len=*), intent(in), optional  :: path

  integer :: hdferr
  character(len=:), allocatable :: p


  p = trim(misc_optional(path,'.'))

  call H5Lexists_f(loc_id, p, HDF5_objectExists, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

  if (HDF5_objectExists) then
    call H5Oexists_by_name_f(loc_id, p, HDF5_objectExists, hdferr)
    call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  end if

end function HDF5_objectExists


!--------------------------------------------------------------------------------------------------
!> @brief Add a string attribute to the path given relative to the location.
!--------------------------------------------------------------------------------------------------
subroutine HDF5_addAttribute_str(loc_id,attrLabel,attrValue,path)

  integer(HID_T),   intent(in)           :: loc_id
  character(len=*), intent(in)           :: attrLabel, attrValue
  character(len=*), intent(in), optional :: path

  integer(HID_T) :: attr_id, space_id
  logical        :: attrExists
  integer        :: hdferr
  character(len=:), allocatable :: p
  character(len=len_trim(attrValue)+1,kind=C_CHAR), dimension(1), target :: attrValue_
  type(C_PTR), target, dimension(1) :: ptr


  p = trim(misc_optional(path,'.'))

  attrValue_(1) = trim(attrValue)//C_NULL_CHAR
  ptr(1) = c_loc(attrValue_(1))

  call H5Screate_f(H5S_SCALAR_F,space_id,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

  call H5Aexists_by_name_f(loc_id,p,attrLabel,attrExists,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  if (attrExists) then
    call H5Adelete_by_name_f(loc_id,p,attrLabel,hdferr)
    call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  end if

  call H5Acreate_by_name_f(loc_id,p,trim(attrLabel),H5T_STRING,space_id,attr_id,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  call H5Awrite_f(attr_id, H5T_STRING, c_loc(ptr), hdferr)                                          ! ptr instead of c_loc(ptr) works on gfortran, not on ifort
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

  call H5Aclose_f(attr_id,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  call H5Sclose_f(space_id,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

end subroutine HDF5_addAttribute_str


!--------------------------------------------------------------------------------------------------
!> @brief Add an integer attribute to the path given relative to the location.
!--------------------------------------------------------------------------------------------------
subroutine HDF5_addAttribute_int(loc_id,attrLabel,attrValue,path)

  integer(HID_T),   intent(in)           :: loc_id
  character(len=*), intent(in)           :: attrLabel
  integer,          intent(in)           :: attrValue
  character(len=*), intent(in), optional :: path

  integer(HID_T) :: attr_id, space_id
  integer        :: hdferr
  logical        :: attrExists
  character(len=:), allocatable :: p


  p = trim(misc_optional(path,'.'))

  call H5Screate_f(H5S_SCALAR_F,space_id,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

  call H5Aexists_by_name_f(loc_id,p,attrLabel,attrExists,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  if (attrExists) then
    call H5Adelete_by_name_f(loc_id,p,attrLabel,hdferr)
    call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  end if

  call H5Acreate_by_name_f(loc_id,p,trim(attrLabel),H5T_NATIVE_INTEGER,space_id,attr_id,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  call H5Awrite_f(attr_id, H5T_NATIVE_INTEGER, attrValue, int([1],HSIZE_T), hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

  call H5Aclose_f(attr_id,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  call H5Sclose_f(space_id,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

end subroutine HDF5_addAttribute_int


!--------------------------------------------------------------------------------------------------
!> @brief Add a real attribute to the path given relative to the location.
!--------------------------------------------------------------------------------------------------
subroutine HDF5_addAttribute_real(loc_id,attrLabel,attrValue,path)

  integer(HID_T),   intent(in)           :: loc_id
  character(len=*), intent(in)           :: attrLabel
  real(pREAL),      intent(in)           :: attrValue
  character(len=*), intent(in), optional :: path

  integer(HID_T) :: attr_id, space_id
  integer        :: hdferr
  logical        :: attrExists
  character(len=:), allocatable :: p


  p = trim(misc_optional(path,'.'))

  call H5Screate_f(H5S_SCALAR_F,space_id,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

  call H5Aexists_by_name_f(loc_id,p,attrLabel,attrExists,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  if (attrExists) then
    call H5Adelete_by_name_f(loc_id,p,attrLabel,hdferr)
    call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  end if

  call H5Acreate_by_name_f(loc_id,p,trim(attrLabel),H5T_NATIVE_DOUBLE,space_id,attr_id,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  call H5Awrite_f(attr_id, H5T_NATIVE_DOUBLE, attrValue, int([1],HSIZE_T), hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

  call H5Aclose_f(attr_id,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  call H5Sclose_f(space_id,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

end subroutine HDF5_addAttribute_real


!--------------------------------------------------------------------------------------------------
!> @brief Add a string array attribute to the path given relative to the location.
!--------------------------------------------------------------------------------------------------
subroutine HDF5_addAttribute_str_array(loc_id,attrLabel,attrValue,path)

  integer(HID_T),   intent(in)               :: loc_id
  character(len=*), intent(in)               :: attrLabel
  character(len=*), intent(in), dimension(:) :: attrValue
  character(len=*), intent(in), optional     :: path

  integer(HID_T)                :: attr_id, space_id
  logical                       :: attrExists
  integer                       :: hdferr,i
  character(len=:), allocatable :: p
  character(len=len(attrValue)+1,kind=C_CHAR), dimension(size(attrValue)), target :: attrValue_
  type(C_PTR), target, dimension(size(attrValue))  :: ptr


  p = trim(misc_optional(path,'.'))

  do i=1,size(attrValue)
    attrValue_(i) = attrValue(i)//C_NULL_CHAR
    ptr(i) = c_loc(attrValue_(i))
  end do

  call H5Screate_simple_f(1,shape(attrValue_,kind=HSIZE_T),space_id,hdferr,shape(attrValue_,kind=HSIZE_T))
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

  call H5Aexists_by_name_f(loc_id,p,attrLabel,attrExists,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  if (attrExists) then
    call H5Adelete_by_name_f(loc_id,p,attrLabel,hdferr)
    call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  end if

  call H5Acreate_by_name_f(loc_id,p,trim(attrLabel),H5T_STRING,space_id,attr_id,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  call H5Awrite_f(attr_id, H5T_STRING, c_loc(ptr), hdferr)                                          ! ptr instead of c_loc(ptr) works on gfortran, not on ifort
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

  call H5Aclose_f(attr_id,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  call H5Sclose_f(space_id,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

end subroutine HDF5_addAttribute_str_array


!--------------------------------------------------------------------------------------------------
!> @brief Add an integer array 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
  integer,          intent(in), dimension(:) :: attrValue
  character(len=*), intent(in), optional     :: path

  integer(HSIZE_T),dimension(1) :: array_size
  integer(HID_T)                :: attr_id, space_id
  integer                       :: hdferr
  logical                       :: attrExists
  character(len=:), allocatable :: p


  p = trim(misc_optional(path,'.'))

  array_size = size(attrValue,kind=HSIZE_T)

  call H5Screate_simple_f(1, array_size, space_id, hdferr, array_size)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

  call H5Aexists_by_name_f(loc_id,p,attrLabel,attrExists,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  if (attrExists) then
    call H5Adelete_by_name_f(loc_id,p,attrLabel,hdferr)
    call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  end if

  call H5Acreate_by_name_f(loc_id,p,trim(attrLabel),H5T_NATIVE_INTEGER,space_id,attr_id,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  call H5Awrite_f(attr_id, H5T_NATIVE_INTEGER, attrValue, array_size, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

  call H5Aclose_f(attr_id,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  call H5Sclose_f(space_id,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

end subroutine HDF5_addAttribute_int_array


!--------------------------------------------------------------------------------------------------
!> @brief Add a real array 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

  integer(HSIZE_T),dimension(1) :: array_size
  integer(HID_T)                :: attr_id, space_id
  integer                       :: hdferr
  logical                       :: attrExists
  character(len=:), allocatable :: p


  p = trim(misc_optional(path,'.'))

  array_size = size(attrValue,kind=HSIZE_T)

  call H5Screate_simple_f(1, array_size, space_id, hdferr, array_size)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

  call H5Aexists_by_name_f(loc_id,p,attrLabel,attrExists,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  if (attrExists) then
    call H5Adelete_by_name_f(loc_id,p,attrLabel,hdferr)
    call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  end if

  call H5Acreate_by_name_f(loc_id,p,trim(attrLabel),H5T_NATIVE_DOUBLE,space_id,attr_id,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  call H5Awrite_f(attr_id, H5T_NATIVE_DOUBLE, attrValue, array_size, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

  call H5Aclose_f(attr_id,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  call H5Sclose_f(space_id,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

end subroutine HDF5_addAttribute_real_array


!--------------------------------------------------------------------------------------------------
!> @brief Set link to object in results file.
!--------------------------------------------------------------------------------------------------
subroutine HDF5_setLink(loc_id,target_name,link_name)

  character(len=*), intent(in) :: target_name, link_name
  integer(HID_T),   intent(in) :: loc_id
  integer                      :: hdferr
  logical                      :: linkExists

  call H5Lexists_f(loc_id, link_name,linkExists, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  if (linkExists) then
    call H5Ldelete_f(loc_id,link_name, hdferr)
    call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  end if
  call H5Lcreate_soft_f(target_name, loc_id, link_name, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

end subroutine HDF5_setLink


!--------------------------------------------------------------------------------------------------
!> @brief Read dataset of type real with 1 dimension.
!--------------------------------------------------------------------------------------------------
subroutine HDF5_read_real1(dataset,loc_id,datasetName,parallel)

  real(pREAL),      intent(out), dimension(:) :: dataset                                            !< data read from file
  integer(HID_T),   intent(in) :: loc_id                                                            !< file or group handle
  character(len=*), intent(in) :: datasetName                                                       !< name of the dataset in the file
  logical, intent(in), optional :: parallel                                                         !< dataset is distributed over multiple processes

  integer(HID_T)   :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
  integer(HSIZE_T), dimension(rank(dataset)) :: &
    myStart, &
    myShape, &                                                                                      !< shape of the dataset (this process)
    totalShape                                                                                      !< shape of the dataset (all processes)
  integer :: hdferr


  myShape = int(shape(dataset),HSIZE_T)

  call initialize_read(myStart,totalShape,dset_id,filespace_id,memspace_id,plist_id, aplist_id, &
                       loc_id,myShape,datasetName,misc_optional(parallel,parallel_default))

  if (any(totalShape == 0)) return

  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)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

  call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)

end subroutine HDF5_read_real1

!--------------------------------------------------------------------------------------------------
!> @brief Read dataset of type real with 2 dimensions.
!--------------------------------------------------------------------------------------------------
subroutine HDF5_read_real2(dataset,loc_id,datasetName,parallel)

  real(pREAL),      intent(out), dimension(:,:) :: dataset                                          !< data read from file
  integer(HID_T),   intent(in) :: loc_id                                                            !< file or group handle
  character(len=*), intent(in) :: datasetName                                                       !< name of the dataset in the file
  logical, intent(in), optional :: parallel                                                         !< dataset is distributed over multiple processes

  integer(HID_T)   :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
  integer(HSIZE_T), dimension(rank(dataset)) :: &
    myStart, &
    myShape, &                                                                                      !< shape of the dataset (this process)
    totalShape                                                                                      !< shape of the dataset (all processes)
  integer :: hdferr


  myShape = int(shape(dataset),HSIZE_T)

  call initialize_read(myStart,totalShape,dset_id,filespace_id,memspace_id,plist_id, aplist_id, &
                       loc_id,myShape,datasetName,misc_optional(parallel,parallel_default))

  if (any(totalShape == 0)) return

  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)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

  call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)

end subroutine HDF5_read_real2

!--------------------------------------------------------------------------------------------------
!> @brief Read dataset of type real with 2 dimensions.
!--------------------------------------------------------------------------------------------------
subroutine HDF5_read_real3(dataset,loc_id,datasetName,parallel)

  real(pREAL),      intent(out), dimension(:,:,:) :: dataset                                        !< data read from file
  integer(HID_T),   intent(in) :: loc_id                                                            !< file or group handle
  character(len=*), intent(in) :: datasetName                                                       !< name of the dataset in the file
  logical, intent(in), optional :: parallel                                                         !< dataset is distributed over multiple processes

  integer(HID_T)   :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
  integer(HSIZE_T), dimension(rank(dataset)) :: &
    myStart, &
    myShape, &                                                                                      !< shape of the dataset (this process)
    totalShape                                                                                      !< shape of the dataset (all processes)
  integer :: hdferr


  myShape = int(shape(dataset),HSIZE_T)

  call initialize_read(myStart,totalShape,dset_id,filespace_id,memspace_id,plist_id, aplist_id, &
                       loc_id,myShape,datasetName,misc_optional(parallel,parallel_default))

  if (any(totalShape == 0)) return

  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)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

  call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)

end subroutine HDF5_read_real3

!--------------------------------------------------------------------------------------------------
!> @brief Read dataset of type real with 4 dimensions.
!--------------------------------------------------------------------------------------------------
subroutine HDF5_read_real4(dataset,loc_id,datasetName,parallel)

  real(pREAL),      intent(out), dimension(:,:,:,:) :: dataset                                      !< data read from file
  integer(HID_T),   intent(in) :: loc_id                                                            !< file or group handle
  character(len=*), intent(in) :: datasetName                                                       !< name of the dataset in the file
  logical, intent(in), optional :: parallel                                                         !< dataset is distributed over multiple processes

  integer(HID_T)   :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
  integer(HSIZE_T), dimension(rank(dataset)) :: &
    myStart, &
    myShape, &                                                                                      !< shape of the dataset (this process)
    totalShape                                                                                      !< shape of the dataset (all processes)
  integer :: hdferr


  myShape = int(shape(dataset),HSIZE_T)
  if (any(myShape(1:size(myShape)-1) == 0)) return                                                  !< empty dataset (last dimension can be empty)

  call initialize_read(myStart,totalShape,dset_id,filespace_id,memspace_id,plist_id, aplist_id, &
                       loc_id,myShape,datasetName,misc_optional(parallel,parallel_default))

  if (any(totalShape == 0)) return

  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)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

  call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)

end subroutine HDF5_read_real4

!--------------------------------------------------------------------------------------------------
!> @brief Read dataset of type real with 5 dimensions.
!--------------------------------------------------------------------------------------------------
subroutine HDF5_read_real5(dataset,loc_id,datasetName,parallel)

  real(pREAL),      intent(out), dimension(:,:,:,:,:) :: dataset                                    !< data read from file
  integer(HID_T),   intent(in) :: loc_id                                                            !< file or group handle
  character(len=*), intent(in) :: datasetName                                                       !< name of the dataset in the file
  logical, intent(in), optional :: parallel                                                         !< dataset is distributed over multiple processes

  integer(HID_T)   :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
  integer(HSIZE_T), dimension(rank(dataset)) :: &
    myStart, &
    myShape, &                                                                                      !< shape of the dataset (this process)
    totalShape                                                                                      !< shape of the dataset (all processes)
  integer :: hdferr


  myShape = int(shape(dataset),HSIZE_T)
  if (any(myShape(1:size(myShape)-1) == 0)) return                                                  !< empty dataset (last dimension can be empty)

  call initialize_read(myStart,totalShape,dset_id,filespace_id,memspace_id,plist_id, aplist_id, &
                       loc_id,myShape,datasetName,misc_optional(parallel,parallel_default))

  if (any(totalShape == 0)) return

  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)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

  call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)

end subroutine HDF5_read_real5


!--------------------------------------------------------------------------------------------------
!> @brief Read dataset of type integer with 1 dimension.
!--------------------------------------------------------------------------------------------------
subroutine HDF5_read_int1(dataset,loc_id,datasetName,parallel)

  integer,          intent(out), dimension(:) :: dataset                                            !< data read from file
  integer(HID_T),   intent(in) :: loc_id                                                            !< file or group handle
  character(len=*), intent(in) :: datasetName                                                       !< name of the dataset in the file
  logical, intent(in), optional :: parallel                                                         !< dataset is distributed over multiple processes


  integer(HID_T)   :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
  integer(HSIZE_T), dimension(rank(dataset)) :: &
    myStart, &
    myShape, &                                                                                      !< shape of the dataset (this process)
    totalShape                                                                                      !< shape of the dataset (all processes)
  integer :: hdferr

  myShape = int(shape(dataset),HSIZE_T)

  call initialize_read(myStart,totalShape,dset_id,filespace_id,memspace_id,plist_id, aplist_id, &
                       loc_id,myShape,datasetName,misc_optional(parallel,parallel_default))

if (any(totalShape == 0)) return

  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)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

  call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)

end subroutine HDF5_read_int1

!--------------------------------------------------------------------------------------------------
!> @brief Read dataset of type integer with 2 dimensions.
!--------------------------------------------------------------------------------------------------
subroutine HDF5_read_int2(dataset,loc_id,datasetName,parallel)

  integer,          intent(out), dimension(:,:) :: dataset                                          !< data read from file
  integer(HID_T),   intent(in) :: loc_id                                                            !< file or group handle
  character(len=*), intent(in) :: datasetName                                                       !< name of the dataset in the file
  logical, intent(in), optional :: parallel                                                         !< dataset is distributed over multiple processes

  integer(HID_T)   :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
  integer(HSIZE_T), dimension(rank(dataset)) :: &
    myStart, &
    myShape, &                                                                                      !< shape of the dataset (this process)
    totalShape                                                                                      !< shape of the dataset (all processes)
  integer :: hdferr


  myShape = int(shape(dataset),HSIZE_T)
  if (any(myShape(1:size(myShape)-1) == 0)) return                                                  !< empty dataset (last dimension can be empty)

  call initialize_read(myStart,totalShape,dset_id,filespace_id,memspace_id,plist_id, aplist_id, &
                       loc_id,myShape,datasetName,misc_optional(parallel,parallel_default))

  if (any(totalShape == 0)) return

  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)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

  call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)

end subroutine HDF5_read_int2

!--------------------------------------------------------------------------------------------------
!> @brief Read dataset of type integer with 3 dimensions.
!--------------------------------------------------------------------------------------------------
subroutine HDF5_read_int3(dataset,loc_id,datasetName,parallel)

  integer,          intent(out), dimension(:,:,:) :: dataset                                        !< data read from file
  integer(HID_T),   intent(in) :: loc_id                                                            !< file or group handle
  character(len=*), intent(in) :: datasetName                                                       !< name of the dataset in the file
  logical, intent(in), optional :: parallel                                                         !< dataset is distributed over multiple processes

  integer(HID_T)   :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
  integer(HSIZE_T), dimension(rank(dataset)) :: &
    myStart, &
    myShape, &                                                                                      !< shape of the dataset (this process)
    totalShape                                                                                      !< shape of the dataset (all processes)
  integer :: hdferr


  myShape = int(shape(dataset),HSIZE_T)

  call initialize_read(myStart,totalShape,dset_id,filespace_id,memspace_id,plist_id, aplist_id, &
                       loc_id,myShape,datasetName,misc_optional(parallel,parallel_default))

  if (any(totalShape == 0)) return

  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)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

  call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)

end subroutine HDF5_read_int3

!--------------------------------------------------------------------------------------------------
!> @brief Read dataset of type integer with 4 dimensions.
!--------------------------------------------------------------------------------------------------
subroutine HDF5_read_int4(dataset,loc_id,datasetName,parallel)

  integer,          intent(out), dimension(:,:,:,:) :: dataset                                      !< data read from file
  integer(HID_T),   intent(in) :: loc_id                                                            !< file or group handle
  character(len=*), intent(in) :: datasetName                                                       !< name of the dataset in the file
  logical, intent(in), optional :: parallel                                                         !< dataset is distributed over multiple processes

  integer(HID_T)   :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
  integer(HSIZE_T), dimension(rank(dataset)) :: &
    myStart, &
    myShape, &                                                                                      !< shape of the dataset (this process)
    totalShape                                                                                      !< shape of the dataset (all processes)
  integer :: hdferr


  myShape = int(shape(dataset),HSIZE_T)

  call initialize_read(myStart,totalShape,dset_id,filespace_id,memspace_id,plist_id, aplist_id, &
                       loc_id,myShape,datasetName,misc_optional(parallel,parallel_default))

  if (any(totalShape == 0)) return

  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)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

  call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)

end subroutine HDF5_read_int4

!--------------------------------------------------------------------------------------------------
!> @brief Read dataset of type integer with 5 dimensions.
!--------------------------------------------------------------------------------------------------
subroutine HDF5_read_int5(dataset,loc_id,datasetName,parallel)

  integer,          intent(out), dimension(:,:,:,:,:) :: dataset                                    !< data read from file
  integer(HID_T),   intent(in) :: loc_id                                                            !< file or group handle
  character(len=*), intent(in) :: datasetName                                                       !< name of the dataset in the file
  logical, intent(in), optional :: parallel                                                         !< dataset is distributed over multiple processes

  integer(HID_T)   :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
  integer(HSIZE_T), dimension(rank(dataset)) :: &
    myStart, &
    myShape, &                                                                                      !< shape of the dataset (this process)
    totalShape                                                                                      !< shape of the dataset (all processes)
  integer :: hdferr


  myShape = int(shape(dataset),HSIZE_T)

  call initialize_read(myStart,totalShape,dset_id,filespace_id,memspace_id,plist_id, aplist_id, &
                       loc_id,myShape,datasetName,misc_optional(parallel,parallel_default))

  if (any(totalShape == 0)) return

  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)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

  call finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)

end subroutine HDF5_read_int5


#if defined(__GFORTRAN__)
!--------------------------------------------------------------------------------------------------
!> @brief Write dataset of type real with 1 dimension.
!--------------------------------------------------------------------------------------------------
subroutine HDF5_write_real1(dataset,loc_id,datasetName,parallel)

  real(pREAL),      intent(in), dimension(:) :: dataset                                             !< data written to file
  integer(HID_T),   intent(in)  :: loc_id                                                           !< file or group handle
  character(len=*), intent(in)  :: datasetName                                                      !< name of the dataset in the file
  logical, intent(in), optional :: parallel                                                         !< dataset is distributed over multiple processes


  integer :: hdferr
  integer(HID_T)   :: dset_id, filespace_id, memspace_id, plist_id
  integer(HSIZE_T), dimension(rank(dataset)) :: &
    myStart, &
    myShape, &                                                                                      !< shape of the dataset (this process)
    totalShape                                                                                      !< shape of the dataset (all processes)

!---------------------------------------------------------------------------------------------------
! determine shape of dataset
  myShape = int(shape(dataset),HSIZE_T)
  if (any(myShape(1:size(myShape)-1) == 0)) return                                                  !< empty dataset (last dimension can be empty)

  call initialize_write(myStart,totalShape,dset_id,filespace_id,memspace_id,plist_id, &
                        loc_id,myShape,datasetName,H5T_NATIVE_DOUBLE, &
                        misc_optional(parallel,parallel_default))

  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)
    call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  end if

  call finalize_write(plist_id, dset_id, filespace_id, memspace_id)

end subroutine HDF5_write_real1

!--------------------------------------------------------------------------------------------------
!> @brief Write dataset of type real with 2 dimensions.
!--------------------------------------------------------------------------------------------------
subroutine HDF5_write_real2(dataset,loc_id,datasetName,parallel)

  real(pREAL),      intent(in), dimension(:,:) :: dataset                                           !< data written to file
  integer(HID_T),   intent(in)  :: loc_id                                                           !< file or group handle
  character(len=*), intent(in)  :: datasetName                                                      !< name of the dataset in the file
  logical, intent(in), optional :: parallel                                                         !< dataset is distributed over multiple processes


  integer :: hdferr
  integer(HID_T)   :: dset_id, filespace_id, memspace_id, plist_id
  integer(HSIZE_T), dimension(rank(dataset)) :: &
    myStart, &
    myShape, &                                                                                      !< shape of the dataset (this process)
    totalShape                                                                                      !< shape of the dataset (all processes)

!---------------------------------------------------------------------------------------------------
! determine shape of dataset
  myShape = int(shape(dataset),HSIZE_T)
  if (any(myShape(1:size(myShape)-1) == 0)) return                                                  !< empty dataset (last dimension can be empty)

  call initialize_write(myStart,totalShape,dset_id,filespace_id,memspace_id,plist_id, &
                        loc_id,myShape,datasetName,H5T_NATIVE_DOUBLE, &
                        misc_optional(parallel,parallel_default))

  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)
    call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  end if

  call finalize_write(plist_id, dset_id, filespace_id, memspace_id)

end subroutine HDF5_write_real2

!--------------------------------------------------------------------------------------------------
!> @brief Write dataset of type real with 3 dimensions.
!--------------------------------------------------------------------------------------------------
subroutine HDF5_write_real3(dataset,loc_id,datasetName,parallel)

  real(pREAL),      intent(in), dimension(:,:,:) :: dataset                                         !< data written to file
  integer(HID_T),   intent(in)  :: loc_id                                                           !< file or group handle
  character(len=*), intent(in)  :: datasetName                                                      !< name of the dataset in the file
  logical, intent(in), optional :: parallel                                                         !< dataset is distributed over multiple processes


  integer :: hdferr
  integer(HID_T)   :: dset_id, filespace_id, memspace_id, plist_id
  integer(HSIZE_T), dimension(rank(dataset)) :: &
    myStart, &
    myShape, &                                                                                      !< shape of the dataset (this process)
    totalShape                                                                                      !< shape of the dataset (all processes)

!---------------------------------------------------------------------------------------------------
! determine shape of dataset
  myShape = int(shape(dataset),HSIZE_T)
  if (any(myShape(1:size(myShape)-1) == 0)) return                                                  !< empty dataset (last dimension can be empty)

  call initialize_write(myStart,totalShape,dset_id,filespace_id,memspace_id,plist_id, &
                        loc_id,myShape,datasetName,H5T_NATIVE_DOUBLE, &
                        misc_optional(parallel,parallel_default))

  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)
    call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  end if

  call finalize_write(plist_id, dset_id, filespace_id, memspace_id)

end subroutine HDF5_write_real3

!--------------------------------------------------------------------------------------------------
!> @brief Write dataset of type real with 4 dimensions.
!--------------------------------------------------------------------------------------------------
subroutine HDF5_write_real4(dataset,loc_id,datasetName,parallel)

  real(pREAL),      intent(in), dimension(:,:,:,:) :: dataset                                       !< data written to file
  integer(HID_T),   intent(in)  :: loc_id                                                           !< file or group handle
  character(len=*), intent(in)  :: datasetName                                                      !< name of the dataset in the file
  logical, intent(in), optional :: parallel                                                         !< dataset is distributed over multiple processes


  integer :: hdferr
  integer(HID_T)   :: dset_id, filespace_id, memspace_id, plist_id
  integer(HSIZE_T), dimension(rank(dataset)) :: &
    myStart, &
    myShape, &                                                                                      !< shape of the dataset (this process)
    totalShape                                                                                      !< shape of the dataset (all processes)

!---------------------------------------------------------------------------------------------------
! determine shape of dataset
  myShape = int(shape(dataset),HSIZE_T)
  if (any(myShape(1:size(myShape)-1) == 0)) return                                                  !< empty dataset (last dimension can be empty)

  call initialize_write(myStart,totalShape,dset_id,filespace_id,memspace_id,plist_id, &
                        loc_id,myShape,datasetName,H5T_NATIVE_DOUBLE, &
                        misc_optional(parallel,parallel_default))

  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)
    call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  end if

  call finalize_write(plist_id, dset_id, filespace_id, memspace_id)

end subroutine HDF5_write_real4


!--------------------------------------------------------------------------------------------------
!> @brief Write dataset of type real with 5 dimensions.
!--------------------------------------------------------------------------------------------------
subroutine HDF5_write_real5(dataset,loc_id,datasetName,parallel)

  real(pREAL),      intent(in), dimension(:,:,:,:,:) :: dataset                                     !< data written to file
  integer(HID_T),   intent(in)  :: loc_id                                                           !< file or group handle
  character(len=*), intent(in)  :: datasetName                                                      !< name of the dataset in the file
  logical, intent(in), optional :: parallel                                                         !< dataset is distributed over multiple processes


  integer :: hdferr
  integer(HID_T)   :: dset_id, filespace_id, memspace_id, plist_id
  integer(HSIZE_T), dimension(rank(dataset)) :: &
    myStart, &
    myShape, &                                                                                      !< shape of the dataset (this process)
    totalShape                                                                                      !< shape of the dataset (all processes)

!---------------------------------------------------------------------------------------------------
! determine shape of dataset
  myShape = int(shape(dataset),HSIZE_T)
  if (any(myShape(1:size(myShape)-1) == 0)) return                                                  !< empty dataset (last dimension can be empty)

  call initialize_write(myStart,totalShape,dset_id,filespace_id,memspace_id,plist_id, &
                        loc_id,myShape,datasetName,H5T_NATIVE_DOUBLE, &
                        misc_optional(parallel,parallel_default))

  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)
    call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  end if

  call finalize_write(plist_id, dset_id, filespace_id, memspace_id)

end subroutine HDF5_write_real5

#else

!--------------------------------------------------------------------------------------------------
!> @brief Write dataset of type real with 1-5 dimensions.
!--------------------------------------------------------------------------------------------------
subroutine HDF5_write_real(dataset,loc_id,datasetName,parallel)

  real(pREAL),      intent(in), dimension(..) :: dataset                                            !< data written to file
  integer(HID_T),   intent(in)  :: loc_id                                                           !< file or group handle
  character(len=*), intent(in)  :: datasetName                                                      !< name of the dataset in the file
  logical, intent(in), optional :: parallel                                                         !< dataset is distributed over multiple processes


  integer :: hdferr
  integer(HID_T)   :: dset_id, filespace_id, memspace_id, plist_id
  integer(HSIZE_T), dimension(rank(dataset)) :: &
    myStart, &
    myShape, &                                                                                      !< shape of the dataset (this process)
    totalShape                                                                                      !< shape of the dataset (all processes)

!---------------------------------------------------------------------------------------------------
! determine shape of dataset
  myShape = int(shape(dataset),HSIZE_T)
  if (any(myShape(1:size(myShape)-1) == 0)) return                                                  !< empty dataset (last dimension can be empty)

  call initialize_write(myStart,totalShape,dset_id,filespace_id,memspace_id,plist_id, &
                        loc_id,myShape,datasetName,H5T_NATIVE_DOUBLE, &
                        misc_optional(parallel,parallel_default))

  if (product(totalShape) /= 0) then
    select rank(dataset)
      rank (1)
        call H5Dwrite_f(dset_id, H5T_NATIVE_DOUBLE,dataset,int(totalShape,HSIZE_T), hdferr,&
                        file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
      rank (2)
        call H5Dwrite_f(dset_id, H5T_NATIVE_DOUBLE,dataset,int(totalShape,HSIZE_T), hdferr,&
                        file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
      rank (3)
        call H5Dwrite_f(dset_id, H5T_NATIVE_DOUBLE,dataset,int(totalShape,HSIZE_T), hdferr,&
                        file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
      rank (4)
        call H5Dwrite_f(dset_id, H5T_NATIVE_DOUBLE,dataset,int(totalShape,HSIZE_T), hdferr,&
                        file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
      rank (5)
        call H5Dwrite_f(dset_id, H5T_NATIVE_DOUBLE,dataset,int(totalShape,HSIZE_T), hdferr,&
                        file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
    end select
    call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  end if

  call finalize_write(plist_id, dset_id, filespace_id, memspace_id)

end subroutine HDF5_write_real
#endif


!--------------------------------------------------------------------------------------------------
!> @brief Write dataset of type string (scalar).
!> @details Not collective, must be called by one process at at time.
!--------------------------------------------------------------------------------------------------
subroutine HDF5_write_str(dataset,loc_id,datasetName)

  character(len=*), intent(in) :: dataset
  integer(HID_T),   intent(in) :: loc_id
  character(len=*), intent(in) :: datasetName                                                      !< name of the dataset in the file

  integer(HID_T)  :: filetype_id, memtype_id, space_id, dataset_id, dcpl
  integer :: hdferr
  character(len=len_trim(dataset,pI64),kind=C_CHAR), target :: dataset_


  dataset_ = trim(dataset)

  call H5Tcopy_f(H5T_C_S1, filetype_id, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  call H5Tset_size_f(filetype_id, len(dataset_,SIZE_T)+1_SIZE_T, hdferr)                            ! +1 for NULL
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

  call H5Tcopy_f(H5T_FORTRAN_S1, memtype_id, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  call H5Tset_size_f(memtype_id, len(dataset_,SIZE_T), hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

  call H5Pcreate_f(H5P_DATASET_CREATE_F, dcpl, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  call H5Pset_chunk_f(dcpl, 1, [1_HSIZE_T], hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  call H5Pset_Fletcher32_f(dcpl,hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  if (compression_possible .and. len(dataset,pI64) > 1024_pI64*256_pI64) then
    call H5Pset_shuffle_f(dcpl, hdferr)
    call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
    call H5Pset_deflate_f(dcpl, 6, hdferr)
    call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  end if

  call H5Screate_simple_f(1, [1_HSIZE_T], space_id, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  CALL H5Dcreate_f(loc_id, datasetName, filetype_id, space_id, dataset_id, hdferr, dcpl)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

  call H5Dwrite_f(dataset_id, memtype_id, c_loc(dataset_(1:1)), hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

  call H5Pclose_f(dcpl, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  call H5Dclose_f(dataset_id, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  call H5Sclose_f(space_id, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  call H5Tclose_f(memtype_id, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  call H5Tclose_f(filetype_id, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

end subroutine HDF5_write_str


#if defined(__GFORTRAN__)
!--------------------------------------------------------------------------------------------------
!> @brief Write dataset of type integer with 1 dimensions.
!--------------------------------------------------------------------------------------------------
subroutine HDF5_write_int1(dataset,loc_id,datasetName,parallel)

  integer,          intent(in), dimension(:) :: dataset                                             !< data written to file
  integer(HID_T),   intent(in)  :: loc_id                                                           !< file or group handle
  character(len=*), intent(in)  :: datasetName                                                      !< name of the dataset in the file
  logical, intent(in), optional :: parallel                                                         !< dataset is distributed over multiple processes


  integer :: hdferr
  integer(HID_T)   :: dset_id, filespace_id, memspace_id, plist_id
  integer(HSIZE_T), dimension(rank(dataset)) :: &
    myStart, &
    myShape, &                                                                                      !< shape of the dataset (this process)
    totalShape                                                                                      !< shape of the dataset (all processes)

!---------------------------------------------------------------------------------------------------
! determine shape of dataset
  myShape = int(shape(dataset),HSIZE_T)
  if (any(myShape(1:size(myShape)-1) == 0)) return                                                  !< empty dataset (last dimension can be empty)

  call initialize_write(myStart,totalShape,dset_id,filespace_id,memspace_id,plist_id, &
                        loc_id,myShape,datasetName,H5T_NATIVE_INTEGER, &
                        misc_optional(parallel,parallel_default))

  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)
    call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  end if

  call finalize_write(plist_id, dset_id, filespace_id, memspace_id)

end subroutine HDF5_write_int1

!--------------------------------------------------------------------------------------------------
!> @brief Write dataset of type integer with 2 dimensions.
!--------------------------------------------------------------------------------------------------
subroutine HDF5_write_int2(dataset,loc_id,datasetName,parallel)

  integer,          intent(in), dimension(:,:) :: dataset                                           !< data written to file
  integer(HID_T),   intent(in)  :: loc_id                                                           !< file or group handle
  character(len=*), intent(in)  :: datasetName                                                      !< name of the dataset in the file
  logical, intent(in), optional :: parallel                                                         !< dataset is distributed over multiple processes


  integer :: hdferr
  integer(HID_T)   :: dset_id, filespace_id, memspace_id, plist_id
  integer(HSIZE_T), dimension(rank(dataset)) :: &
    myStart, &
    myShape, &                                                                                      !< shape of the dataset (this process)
    totalShape                                                                                      !< shape of the dataset (all processes)

!---------------------------------------------------------------------------------------------------
! determine shape of dataset
  myShape = int(shape(dataset),HSIZE_T)
  if (any(myShape(1:size(myShape)-1) == 0)) return                                                  !< empty dataset (last dimension can be empty)

  call initialize_write(myStart,totalShape,dset_id,filespace_id,memspace_id,plist_id, &
                        loc_id,myShape,datasetName,H5T_NATIVE_INTEGER, &
                        misc_optional(parallel,parallel_default))

  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)
    call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  end if

  call finalize_write(plist_id, dset_id, filespace_id, memspace_id)

end subroutine HDF5_write_int2

!--------------------------------------------------------------------------------------------------
!> @brief Write dataset of type integer with 3 dimensions.
!--------------------------------------------------------------------------------------------------
subroutine HDF5_write_int3(dataset,loc_id,datasetName,parallel)

  integer,          intent(in), dimension(:,:,:) :: dataset                                         !< data written to file
  integer(HID_T),   intent(in)  :: loc_id                                                           !< file or group handle
  character(len=*), intent(in)  :: datasetName                                                      !< name of the dataset in the file
  logical, intent(in), optional :: parallel                                                         !< dataset is distributed over multiple processes


  integer :: hdferr
  integer(HID_T)   :: dset_id, filespace_id, memspace_id, plist_id
  integer(HSIZE_T), dimension(rank(dataset)) :: &
    myStart, &
    myShape, &                                                                                      !< shape of the dataset (this process)
    totalShape                                                                                      !< shape of the dataset (all processes)

!---------------------------------------------------------------------------------------------------
! determine shape of dataset
  myShape = int(shape(dataset),HSIZE_T)
  if (any(myShape(1:size(myShape)-1) == 0)) return                                                  !< empty dataset (last dimension can be empty)

  call initialize_write(myStart,totalShape,dset_id,filespace_id,memspace_id,plist_id, &
                        loc_id,myShape,datasetName,H5T_NATIVE_INTEGER, &
                        misc_optional(parallel,parallel_default))

  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)
    call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  end if

  call finalize_write(plist_id, dset_id, filespace_id, memspace_id)

end subroutine HDF5_write_int3

!--------------------------------------------------------------------------------------------------
!> @brief Write dataset of type integer with 4 dimensions.
!--------------------------------------------------------------------------------------------------
subroutine HDF5_write_int4(dataset,loc_id,datasetName,parallel)

  integer,          intent(in), dimension(:,:,:,:) :: dataset                                       !< data written to file
  integer(HID_T),   intent(in)  :: loc_id                                                           !< file or group handle
  character(len=*), intent(in)  :: datasetName                                                      !< name of the dataset in the file
  logical, intent(in), optional :: parallel                                                         !< dataset is distributed over multiple processes


  integer :: hdferr
  integer(HID_T)   :: dset_id, filespace_id, memspace_id, plist_id
  integer(HSIZE_T), dimension(rank(dataset)) :: &
    myStart, &
    myShape, &                                                                                      !< shape of the dataset (this process)
    totalShape                                                                                      !< shape of the dataset (all processes)

!---------------------------------------------------------------------------------------------------
! determine shape of dataset
  myShape = int(shape(dataset),HSIZE_T)
  if (any(myShape(1:size(myShape)-1) == 0)) return                                                  !< empty dataset (last dimension can be empty)

  call initialize_write(myStart,totalShape,dset_id,filespace_id,memspace_id,plist_id, &
                        loc_id,myShape,datasetName,H5T_NATIVE_INTEGER, &
                        misc_optional(parallel,parallel_default))

  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)
    call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  end if

  call finalize_write(plist_id, dset_id, filespace_id, memspace_id)

end subroutine HDF5_write_int4

!--------------------------------------------------------------------------------------------------
!> @brief Write dataset of type integer with 5 dimensions.
!--------------------------------------------------------------------------------------------------
subroutine HDF5_write_int5(dataset,loc_id,datasetName,parallel)

  integer,          intent(in), dimension(:,:,:,:,:) :: dataset                                     !< data written to file
  integer(HID_T),   intent(in)  :: loc_id                                                           !< file or group handle
  character(len=*), intent(in)  :: datasetName                                                      !< name of the dataset in the file
  logical, intent(in), optional :: parallel                                                         !< dataset is distributed over multiple processes


  integer :: hdferr
  integer(HID_T)   :: dset_id, filespace_id, memspace_id, plist_id
  integer(HSIZE_T), dimension(rank(dataset)) :: &
    myStart, &
    myShape, &                                                                                      !< shape of the dataset (this process)
    totalShape                                                                                      !< shape of the dataset (all processes)

!---------------------------------------------------------------------------------------------------
! determine shape of dataset
  myShape = int(shape(dataset),HSIZE_T)
  if (any(myShape(1:size(myShape)-1) == 0)) return                                                  !< empty dataset (last dimension can be empty)

  call initialize_write(myStart,totalShape,dset_id,filespace_id,memspace_id,plist_id, &
                        loc_id,myShape,datasetName,H5T_NATIVE_INTEGER, &
                        misc_optional(parallel,parallel_default))

  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)
   call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  end if

  call finalize_write(plist_id, dset_id, filespace_id, memspace_id)

end subroutine HDF5_write_int5

#else

!--------------------------------------------------------------------------------------------------
!> @brief Write dataset of type integer with 1-5 dimensions.
!--------------------------------------------------------------------------------------------------
subroutine HDF5_write_int(dataset,loc_id,datasetName,parallel)

  integer,          intent(in), dimension(..) :: dataset                                            !< data written to file
  integer(HID_T),   intent(in)  :: loc_id                                                           !< file or group handle
  character(len=*), intent(in)  :: datasetName                                                      !< name of the dataset in the file
  logical, intent(in), optional :: parallel                                                         !< dataset is distributed over multiple processes


  integer :: hdferr
  integer(HID_T)   :: dset_id, filespace_id, memspace_id, plist_id
  integer(HSIZE_T), dimension(rank(dataset)) :: &
    myStart, &
    myShape, &                                                                                      !< shape of the dataset (this process)
    totalShape                                                                                      !< shape of the dataset (all processes)

!---------------------------------------------------------------------------------------------------
! determine shape of dataset
  myShape = int(shape(dataset),HSIZE_T)
  if (any(myShape(1:size(myShape)-1) == 0)) return                                                  !< empty dataset (last dimension can be empty)

  call initialize_write(myStart,totalShape,dset_id,filespace_id,memspace_id,plist_id, &
                        loc_id,myShape,datasetName,H5T_NATIVE_INTEGER, &
                        misc_optional(parallel,parallel_default))

  if (product(totalShape) /= 0) then
    select rank(dataset)
      rank(1)
        call H5Dwrite_f(dset_id, H5T_NATIVE_INTEGER,dataset,int(totalShape,HSIZE_T), hdferr,&
                       file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
      rank(2)
        call H5Dwrite_f(dset_id, H5T_NATIVE_INTEGER,dataset,int(totalShape,HSIZE_T), hdferr,&
                       file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
      rank(3)
        call H5Dwrite_f(dset_id, H5T_NATIVE_INTEGER,dataset,int(totalShape,HSIZE_T), hdferr,&
                       file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
      rank(4)
        call H5Dwrite_f(dset_id, H5T_NATIVE_INTEGER,dataset,int(totalShape,HSIZE_T), hdferr,&
                       file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
      rank(5)
        call H5Dwrite_f(dset_id, H5T_NATIVE_INTEGER,dataset,int(totalShape,HSIZE_T), hdferr,&
                       file_space_id = filespace_id, mem_space_id = memspace_id, xfer_prp = plist_id)
    end select
    call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  end if

  call finalize_write(plist_id, dset_id, filespace_id, memspace_id)

end subroutine HDF5_write_int
#endif


!--------------------------------------------------------------------------------------------------
!> @brief Initialize read handles and determine global shape in case of parallel IO.
!--------------------------------------------------------------------------------------------------
subroutine initialize_read(myStart, globalShape, dset_id, filespace_id, memspace_id, plist_id, aplist_id, &
                           loc_id,localShape,datasetName,parallel)

  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(:) :: localShape
  integer(HSIZE_T),  intent(out), dimension(size(localShape)) :: &
    myStart, &
    globalShape                                                                                     !< shape of the dataset (all processes)
  integer(HID_T),    intent(out) :: dset_id, filespace_id, memspace_id, plist_id, aplist_id

  integer(MPI_INTEGER_KIND), dimension(worldsize) :: readSize                                       !< contribution of all processes
  integer :: hdferr
  integer(MPI_INTEGER_KIND) :: err_MPI

!-------------------------------------------------------------------------------------------------
! creating a property list for transfer properties (is collective for MPI)
  call H5Pcreate_f(H5P_DATASET_XFER_F, plist_id, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

!--------------------------------------------------------------------------------------------------
  readSize = 0_MPI_INTEGER_KIND
  readSize(worldrank+1) = int(localShape(ubound(localShape,1)),MPI_INTEGER_KIND)
#ifdef PETSC
  if (parallel) then
    call H5Pset_dxpl_mpio_f(plist_id, H5FD_MPIO_COLLECTIVE_F, hdferr)
    call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
    call MPI_Allgather(int(localShape(ubound(localShape,1)),MPI_INTEGER_KIND),1_MPI_INTEGER_KIND,MPI_INTEGER,&
                       readSize,1_MPI_INTEGER_KIND,MPI_INTEGER,MPI_COMM_WORLD,err_MPI)
    call parallelization_chkerr(err_MPI)
  end if
#endif
  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)]

  if (any(globalShape == 0)) then
    call H5Pclose_f(plist_id, hdferr)
    call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
    return
  end if

!--------------------------------------------------------------------------------------------------
! create dataspace in memory (local shape)
  call H5Screate_simple_f(size(localShape), localShape, memspace_id, hdferr, localShape)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

!--------------------------------------------------------------------------------------------------
! creating a property list for IO and set it to collective
  call H5Pcreate_f(H5P_DATASET_ACCESS_F, aplist_id, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
#ifdef PETSC
  call H5Pset_all_coll_metadata_ops_f(aplist_id, .true., hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
#endif

!--------------------------------------------------------------------------------------------------
! open the dataset in the file and get the space ID
  call H5Dopen_f(loc_id,datasetName,dset_id,hdferr, dapl_id = aplist_id)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  call H5Dget_space_f(dset_id, filespace_id, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

!--------------------------------------------------------------------------------------------------
! select a hyperslab (the portion of the current process) in the file
  call H5Sselect_hyperslab_f(filespace_id, H5S_SELECT_SET_F, myStart, localShape, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

end subroutine initialize_read


!--------------------------------------------------------------------------------------------------
!> @brief Close read handles.
!--------------------------------------------------------------------------------------------------
subroutine finalize_read(dset_id, filespace_id, memspace_id, plist_id, aplist_id)

  integer(HID_T), intent(in) :: dset_id, filespace_id, memspace_id, plist_id, aplist_id
  integer :: hdferr

  call H5Pclose_f(plist_id, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  call H5Pclose_f(aplist_id, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  call H5Dclose_f(dset_id, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  call H5Sclose_f(filespace_id, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  call H5Sclose_f(memspace_id, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

end subroutine finalize_read


!--------------------------------------------------------------------------------------------------
!> @brief Initialize write handles and determine global shape in case of parallel IO.
!--------------------------------------------------------------------------------------------------
subroutine initialize_write(myStart, totalShape, dset_id, filespace_id, memspace_id, plist_id, &
                            loc_id, localShape, datasetName, datatype, parallel)

  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(:) :: localShape
  integer(HSIZE_T),  intent(out), dimension(size(localShape)) :: &
    myStart, &
    totalShape                                                                                      !< shape of the dataset (all processes)
  integer(HID_T),    intent(out) :: dset_id, filespace_id, memspace_id, plist_id

  integer(MPI_INTEGER_KIND), dimension(worldsize) :: writeSize                                      !< contribution of all processes
  integer(HID_T) :: dcpl
  integer :: hdferr
  integer(MPI_INTEGER_KIND) :: err_MPI
  integer(HSIZE_T), parameter :: chunkSize = 1024_HSIZE_T**2/8_HSIZE_T


!-------------------------------------------------------------------------------------------------
! creating a property list for transfer properties (is collective when writing in parallel)
  call H5Pcreate_f(H5P_DATASET_XFER_F, plist_id, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
#ifdef PETSC
  if (parallel) then
    call H5Pset_dxpl_mpio_f(plist_id, H5FD_MPIO_COLLECTIVE_F, hdferr)
    call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  end if
#endif

!--------------------------------------------------------------------------------------------------
! determine the global data layout among all processes
  writeSize              = 0_MPI_INTEGER_KIND
  writeSize(worldrank+1) = int(localShape(ubound(localShape,1)),MPI_INTEGER_KIND)
#ifdef PETSC
  if (parallel) then
    call MPI_Allgather(int(localShape(ubound(localShape,1)),MPI_INTEGER_KIND),1_MPI_INTEGER_KIND,MPI_INTEGER,&
                       writeSize,1_MPI_INTEGER_KIND,MPI_INTEGER,MPI_COMM_WORLD,err_MPI)
    call parallelization_chkerr(err_MPI)
  end if
#endif
  myStart                   = int(0,HSIZE_T)
  myStart(ubound(myStart))  = int(sum(writeSize(1:worldrank)),HSIZE_T)
  totalShape = [localShape(1:ubound(localShape,1)-1),int(sum(writeSize),HSIZE_T)]

!--------------------------------------------------------------------------------------------------
! chunk dataset, enable compression for larger datasets
  call H5Pcreate_f(H5P_DATASET_CREATE_F, dcpl, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

  if (product(totalShape) > 0) then
    call H5Pset_Fletcher32_f(dcpl,hdferr)
    call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

    if (product(totalShape) >= chunkSize*2_HSIZE_T) then
      call H5Pset_chunk_f(dcpl, size(totalShape), get_chunks(totalShape,chunkSize), hdferr)
      call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
      if (compression_possible) then
        call H5Pset_shuffle_f(dcpl, hdferr)
        call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
        call H5Pset_deflate_f(dcpl, 6, hdferr)
        call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
      end if
    else
      call H5Pset_chunk_f(dcpl, size(totalShape), totalShape, hdferr)
      call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
    end if
  end if

!--------------------------------------------------------------------------------------------------
! create dataspace in memory (local shape) and in file (global shape)
  call H5Screate_simple_f(size(localShape), localShape, memspace_id, hdferr, localShape)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  call H5Screate_simple_f(size(totalShape), totalShape, filespace_id, hdferr, totalShape)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

!--------------------------------------------------------------------------------------------------
! create dataset in the file and select a hyperslab from it (the portion of the current process)
  call H5Dcreate_f(loc_id, trim(datasetName), datatype, filespace_id, dset_id, hdferr, dcpl)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  call H5Sselect_hyperslab_f(filespace_id, H5S_SELECT_SET_F, myStart, localShape, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

  call H5Pclose_f(dcpl, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

  contains
  !------------------------------------------------------------------------------------------------
  !> @brief Determine chunk layout.
  !------------------------------------------------------------------------------------------------
  pure function get_chunks(totalShape,chunkSize)
#ifndef __GFORTRAN__
    use HDF5
    import, none
#endif

    integer(HSIZE_T), dimension(:), intent(in)    :: totalShape
    integer(HSIZE_T),               intent(in)    :: chunkSize
    integer(HSIZE_T), dimension(size(totalShape)) :: get_chunks

    get_chunks = [totalShape(1:size(totalShape)-1),&
                  chunkSize/product(totalShape(1:size(totalShape)-1))]

  end function get_chunks

end subroutine initialize_write


!--------------------------------------------------------------------------------------------------
!> @brief Closes write handles.
!--------------------------------------------------------------------------------------------------
subroutine finalize_write(plist_id, dset_id, filespace_id, memspace_id)

  integer(HID_T), intent(in) :: dset_id, filespace_id, memspace_id, plist_id
  integer :: hdferr

  call H5Pclose_f(plist_id, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  call H5Dclose_f(dset_id, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  call H5Sclose_f(filespace_id, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))
  call H5Sclose_f(memspace_id, hdferr)
  call HDF5_chkerr(hdferr,__FILE__//':'//IO_intAsStr(__LINE__))

end subroutine finalize_write


end module HDF5_Utilities
