scale_file.F90

Go to the documentation of this file.

!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
! Warning: This file was generated from file/scale_file.F90.erb.
!          Do not edit this file.
!-------------------------------------------------------------------------------
#include "scalelib.h"
module scale_file
  !-----------------------------------------------------------------------------
  !
  !++ Used modules
  !
  use scale_precision
  use scale_io
  use scale_prof
  use scale_file_h
  use scale_prc, only: &
     prc_abort
  use iso_c_binding
#ifdef _OPENACC
  use openacc
#endif
  !-----------------------------------------------------------------------------
  implicit none
  private
 
  include 'scale_file_c.inc'
  !-----------------------------------------------------------------------------
  !
  !++ Public procedures
  !
  public :: file_setup
  public :: file_finalize
  public :: file_open
  public :: file_opened
  public :: file_single
  public :: file_allnodes
  public :: file_create
  public :: file_get_dimlength
  public :: file_set_option
  public :: file_def_axis
  public :: file_put_axis
  public :: file_write_axis
  public :: file_def_associatedcoordinate
  public :: file_put_associatedcoordinate
  public :: file_write_associatedcoordinate
  public :: file_add_variable
  public :: file_def_variable
  public :: file_get_shape
  public :: file_get_stepsize
  public :: file_get_commoninfo
  public :: file_get_datainfo
  public :: file_get_all_datainfo
  public :: file_read
  public :: file_write
  public :: file_get_attribute
  public :: file_set_attribute
  public :: file_add_associatedvariable
  public :: file_enddef
  public :: file_redef
  public :: file_flush
  public :: file_close
  public :: file_close_all
  public :: file_attach_buffer
  public :: file_detach_buffer
  public :: file_get_cftunits
  public :: file_get_aggregate
 
  interface file_get_commoninfo
     module procedure file_get_commoninfo_fid
     module procedure file_get_commoninfo_fname
  end interface file_get_commoninfo
 
  interface file_get_shape
     module procedure file_get_shape_fid
     module procedure file_get_shape_fname
  end interface file_get_shape
 
  interface file_get_datainfo
     module procedure file_get_datainfo_fid
     module procedure file_get_datainfo_fname
  end interface file_get_datainfo
 
  interface file_get_all_datainfo
     module procedure file_get_all_datainfo_fid
     module procedure file_get_all_datainfo_fname
  end interface file_get_all_datainfo
 
  interface file_put_axis
     module procedure file_put_axis_realsp
     module procedure file_put_axis_realdp
  end interface file_put_axis
  interface file_write_axis
     module procedure file_write_axis_realsp
     module procedure file_write_axis_realdp
  end interface file_write_axis
  interface file_put_associatedcoordinate
    module procedure file_put_associatedcoordinate_realsp_1d
    module procedure file_put_associatedcoordinate_realdp_1d
    module procedure file_put_associatedcoordinate_realsp_2d
    module procedure file_put_associatedcoordinate_realdp_2d
    module procedure file_put_associatedcoordinate_realsp_3d
    module procedure file_put_associatedcoordinate_realdp_3d
    module procedure file_put_associatedcoordinate_realsp_4d
    module procedure file_put_associatedcoordinate_realdp_4d
  end interface file_put_associatedcoordinate
  interface file_write_associatedcoordinate
    module procedure file_write_associatedcoordinate_realsp_1d
    module procedure file_write_associatedcoordinate_realdp_1d
    module procedure file_write_associatedcoordinate_realsp_2d
    module procedure file_write_associatedcoordinate_realdp_2d
    module procedure file_write_associatedcoordinate_realsp_3d
    module procedure file_write_associatedcoordinate_realdp_3d
    module procedure file_write_associatedcoordinate_realsp_4d
    module procedure file_write_associatedcoordinate_realdp_4d
  end interface file_write_associatedcoordinate
  interface file_add_variable
     module procedure file_add_variable_no_time
     module procedure file_add_variable_with_time
  end interface file_add_variable
  interface file_read
    module procedure file_read_realsp_1d
    module procedure file_read_realdp_1d
    module procedure file_read_realsp_2d
    module procedure file_read_realdp_2d
    module procedure file_read_realsp_3d
    module procedure file_read_realdp_3d
    module procedure file_read_realsp_4d
    module procedure file_read_realdp_4d
    module procedure file_read_var_realsp_1d
    module procedure file_read_var_realdp_1d
    module procedure file_read_var_realsp_2d
    module procedure file_read_var_realdp_2d
    module procedure file_read_var_realsp_3d
    module procedure file_read_var_realdp_3d
    module procedure file_read_var_realsp_4d
    module procedure file_read_var_realdp_4d
  end interface file_read
  interface file_write
    module procedure file_write_realsp_1d
    module procedure file_write_realdp_1d
    module procedure file_write_realsp_2d
    module procedure file_write_realdp_2d
    module procedure file_write_realsp_3d
    module procedure file_write_realdp_3d
    module procedure file_write_realsp_4d
    module procedure file_write_realdp_4d
  end interface file_write
  interface file_get_attribute
     module procedure file_get_attribute_text_fname
     module procedure file_get_attribute_logical_fname
     module procedure file_get_attribute_int_fname_ary
     module procedure file_get_attribute_int_fname
     module procedure file_get_attribute_float_fname_ary
     module procedure file_get_attribute_float_fname
     module procedure file_get_attribute_double_fname_ary
     module procedure file_get_attribute_double_fname
     module procedure file_get_attribute_text_fid
     module procedure file_get_attribute_logical_fid
     module procedure file_get_attribute_int_fid_ary
     module procedure file_get_attribute_int_fid
     module procedure file_get_attribute_float_fid_ary
     module procedure file_get_attribute_float_fid
     module procedure file_get_attribute_double_fid_ary
     module procedure file_get_attribute_double_fid
  end interface file_get_attribute
  interface file_set_attribute
     module procedure file_set_attribute_text
     module procedure file_set_attribute_logical
     module procedure file_set_attribute_int_ary
     module procedure file_set_attribute_int
     module procedure file_set_attribute_float_ary
     module procedure file_set_attribute_float
     module procedure file_set_attribute_double_ary
     module procedure file_set_attribute_double
  end interface file_set_attribute
 
#if defined(__GFORTRAN__) && __GNUC__ < 7
  interface cloc
    module procedure cloc_sp
    module procedure cloc_dp
  end interface cloc
#endif
 
  !-----------------------------------------------------------------------------
  !
  !++ Public parameters & variables
  !
  logical, public :: file_aggregate
 
  !-----------------------------------------------------------------------------
  !
  !++ Private procedures
  !
  private :: file_get_fid
 
  !-----------------------------------------------------------------------------
  !
  !++ Private parameters & variables
  !
  type file
     character(len=FILE_HLONG) :: name
     integer                   :: fid
     logical                   :: aggregate
     logical                   :: single
     logical                   :: allnodes
     integer(8)                :: buffer_size
  end type file
  type(file) :: file_files(file_file_max)
  integer    :: file_nfiles = 0
 
  type var
  character(len=FILE_HLONG) :: name
  integer                   :: fid
  integer                   :: vid
  end type var
  type(var) :: file_vars(file_var_max)
  integer   :: file_nvars = 0
 
  integer                   :: mpi_myrank
 
  !-----------------------------------------------------------------------------
contains
  !-----------------------------------------------------------------------------
  !-----------------------------------------------------------------------------
  subroutine file_setup( &
       myrank )
    use scale_prc, only: &
       prc_set_file_closer
    implicit none
 
    integer, intent(in) :: myrank
 
    namelist / param_file / &
         file_aggregate
 
    integer :: fid
    integer :: ierr
 
    file_aggregate = .false.
 
    !--- read namelist
    rewind(io_fid_conf)
    read(io_fid_conf,nml=param_file,iostat=ierr)
    if( ierr < 0 ) then !--- missing
       log_info("FILE_setup",*) 'Not found namelist. Default used.'
    elseif( ierr > 0 ) then !--- fatal error
       log_error("FILE_setup",*) 'Not appropriate names in namelist PARAM_FILE. Check!'
       call prc_abort
    endif
    log_nml(param_file)
 
    mpi_myrank = myrank
 
    call prc_set_file_closer( file_close_all )
 
    do fid = 1, file_file_max
      file_files(fid)%fid  = -1
      file_files(fid)%name = ""
    end do
 
    return
  end subroutine file_setup
 
  !-----------------------------------------------------------------------------
  !-----------------------------------------------------------------------------
  subroutine file_finalize
 
    file_nfiles = 0
    file_nvars = 0
 
    return
  end subroutine file_finalize
 
  !-----------------------------------------------------------------------------
  subroutine file_create( &
       basename,                   &
       title, source, institution, &
       fid, existed,               &
       rankid, single, aggregate,  &
       time_units, calendar,       &
       allnodes, append            )
    implicit none
 
    character(len=*), intent(in)  :: basename
    character(len=*), intent(in)  :: title
    character(len=*), intent(in)  :: source
    character(len=*), intent(in)  :: institution
 
    integer,          intent(out) :: fid
    logical,          intent(out) :: existed
 
    integer,          intent(in), optional :: rankid
    logical,          intent(in), optional :: single
    logical,          intent(in), optional :: aggregate
    character(len=*), intent(in), optional :: time_units
    character(len=*), intent(in), optional :: calendar
    logical,          intent(in), optional :: allnodes
    logical,          intent(in), optional :: append
 
    character(len=FILE_HMID)   :: time_units_
    character(len=FILE_HSHORT) :: calendar_
    integer :: rankid_
    logical :: single_
    integer :: mode
 
    integer :: error
    !---------------------------------------------------------------------------
 
 
    if ( present(rankid) ) then
       rankid_ = rankid
    else
       rankid_ = mpi_myrank
    end if
 
    single_ = .false.
    if ( present(single) ) then
       single_ = single
    endif
 
    if ( present(time_units) ) then
       time_units_ = time_units
    else
       time_units_ = 'seconds'
    endif
 
    if ( present(calendar) ) then
       calendar_ = calendar
    else
       calendar_ = ""
    end if
 
    mode = file_fwrite
    if ( present(append) ) then
       if( append ) mode = file_fappend
    endif
 
    if ( single_ .and. rankid_ /= 0 ) then
       fid = -1
       existed = .false.
       return
    end if
 
    call file_get_fid( basename, mode,     & ! [IN]
                       rankid_, single_,   & ! [IN]
                       fid, existed,       & ! [OUT]
                       allnodes=allnodes,  & ! [IN]
                       aggregate=aggregate ) ! [IN]
 
    if( existed ) return
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    !--- append package header to the file
    call file_set_attribute( fid, "global", "title"      , title       ) ! [IN]
    call file_set_attribute( fid, "global", "source"     , source      ) ! [IN]
    call file_set_attribute( fid, "global", "institution", institution ) ! [IN]
 
    if ( ( .not. present(aggregate) ) .or. .not. aggregate ) then
       ! for shared-file parallel I/O, skip attributes related to MPI processes
       call file_set_attribute( fid, "global", "rankid"  , (/rankid_/)  ) ! [IN]
    endif
 
    error = file_set_tunits_c( file_files(fid)%fid, & ! [IN]
                               cstr(time_units_),   &
                               cstr(calendar_ )     ) ! [IN]
 
    if ( error /= file_success_code ) then
       log_error("FILE_create",*) 'failed to set time units'
       call prc_abort
    endif
 
    call prof_rapend('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_create
 
  !-----------------------------------------------------------------------------
  subroutine file_get_var_num( &
       fid, nvars_limit, &
       nvars             )
    implicit none
 
    integer, intent(in)  :: fid
    integer, intent(in)  :: nvars_limit
    integer, intent(out) :: nvars
 
    integer :: error
    !---------------------------------------------------------------------------
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_get_var_num",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    error = file_get_nvars_c( nvars,              & ! (out)
                              file_files(fid)%fid ) ! (in)
    if ( error /= file_success_code ) then
       log_error("FILE_get_var_num",*) 'failed to get varnum. fid = ', fid
       call prc_abort
    end if
 
    if ( nvars > nvars_limit ) then
       log_error("FILE_get_var_num",*) 'number of variables exceeds the requested size.', nvars, nvars_limit
       call prc_abort
    endif
 
    call prof_rapend  ('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_get_var_num
 
  !-----------------------------------------------------------------------------
  subroutine file_get_var_name( &
       fid, cvid, &
       varname    )
    implicit none
 
    integer,          intent(in)  :: fid
    integer,          intent(in)  :: cvid
    character(len=*), intent(out) :: varname
 
    integer :: error
    !---------------------------------------------------------------------------
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_get_var_name",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    error = file_get_varname_c( varname, &
                                file_files(fid)%fid, cvid, len(varname) ) ! (in)
    call fstr(varname)
    if ( error /= file_success_code ) then
       log_error("FILE_get_var_name",*) 'failed to get varname. cvid = ', cvid
       call prc_abort
    end if
 
    call prof_rapend  ('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_get_var_name
 
  !-----------------------------------------------------------------------------
  subroutine file_add_associatedvariable( fid, vname, existed )
    integer,           intent(in)  :: fid
    character(len=*),  intent(in)  :: vname
    logical, optional, intent(out) :: existed
 
    integer :: error
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_add_associatedVariable",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    error = file_add_associatedvariable_c( file_files(fid)%fid, cstr(vname) ) ! (in)
 
    call prof_rapend ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    if ( present(existed) ) then
       if ( error == file_already_existed_code ) then
          existed = .true.
          return
       end if
       existed = .false.
    end if
 
    if ( error /= file_success_code ) then
       log_error("FILE_add_associatedvariable",*) 'failed to add associated variable: '//trim(vname)
       call prc_abort
    end if
 
    return
  end subroutine file_add_associatedvariable
 
  !-----------------------------------------------------------------------------
  subroutine file_set_option( &
       fid,               &
       filetype, key, val )
    integer,          intent(in) :: fid
    character(len=*), intent(in) :: filetype
    character(len=*), intent(in) :: key
    character(len=*), intent(in) :: val
 
    integer :: error
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_set_option",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    error = file_set_option_c( file_files(fid)%fid, cstr(filetype), cstr(key), cstr(val) ) ! (in)
    if ( error /= file_success_code ) then
       log_error("FILE_set_option",*) 'failed to set option'
       call prc_abort
    end if
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_set_option
 
  !-----------------------------------------------------------------------------
  subroutine file_open( &
      basename,  &
      fid,       &
      mode,      &
      single,    &
      allnodes,  &
      aggregate, &
      rankid,    &
      postfix    )
    implicit none
 
    character(len=*), intent( in) :: basename
    integer,          intent(out) :: fid
    integer,          intent( in), optional :: mode
    logical,          intent( in), optional :: single
    logical,          intent( in), optional :: allnodes
    logical,          intent( in), optional :: aggregate
    integer,          intent( in), optional :: rankid
    character(len=*), intent( in), optional :: postfix
 
    integer :: mode_
    integer :: rankid_
    logical :: existed
    logical :: single_
 
    single_ = .false.
 
    if ( present(mode) ) then
       mode_ = mode
    else
       mode_ = file_fread
    end if
 
    if ( present(single) ) single_ = single
    if ( present(rankid) ) then
       rankid_ = rankid
    else
       rankid_ = mpi_myrank
    end if
 
    call file_get_fid( basename, mode_, rankid_, single_,   & ! (in)
                       fid, existed,                        & ! (out)
                       allnodes=allnodes,                   & ! (in)
                       aggregate=aggregate, postfix=postfix ) ! (in)
 
    return
  end subroutine file_open
 
  !-----------------------------------------------------------------------------
  function file_opened( fid )
    implicit none
 
    integer, intent( in) :: fid
    logical :: file_opened
 
    if ( fid < 1 ) then
       file_opened = .false.
    else
       file_opened = file_files(fid)%fid >= 0
    end if
 
    return
  end function file_opened
 
  !-----------------------------------------------------------------------------
  function file_single( fid )
    implicit none
 
    integer, intent( in) :: fid
    logical :: file_single
 
    if ( fid < 1 ) then
       file_single = .false.
    else
       file_single = file_files(fid)%single
    end if
 
    return
  end function file_single
 
  !-----------------------------------------------------------------------------
  function file_allnodes( fid )
    implicit none
 
    integer, intent( in) :: fid
    logical :: file_allnodes
 
    if ( fid < 1 ) then
       file_allnodes = .false.
    else
       file_allnodes = file_files(fid)%allnodes
    end if
 
    return
  end function file_allnodes
 
  !-----------------------------------------------------------------------------
  !-----------------------------------------------------------------------------
  subroutine file_get_dimlength( &
       fid, dimname, &
       len,          &
       error         )
    integer,          intent(in) :: fid
    character(len=*), intent(in) :: dimname
 
    integer, intent(out) :: len
 
    logical, intent(out), optional :: error
 
    logical(c_bool) :: suppress
    integer :: ierror
 
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_get_dimLength",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    if ( present(error) ) then
       suppress = .true.
    else
       suppress = .false.
    end if
 
    ierror = file_get_dim_length_c( len,                 & ! (out)
                                    file_files(fid)%fid, & ! (in)
                                    cstr(dimname),       & ! (in)
                                    suppress             ) ! (in)
    if ( ierror /= file_success_code .and. ierror /= file_already_existed_code ) then
       if ( present(error) ) then
          error = .true.
       else
          log_error("FILE_get_dimLength",*) 'failed to get dimension length'
          call prc_abort
       end if
    else
       if ( present(error) ) error = .false.
    end if
 
    call prof_rapend  ('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_get_dimlength
 
  !-----------------------------------------------------------------------------
  ! interface FILE_PutAxis
  !-----------------------------------------------------------------------------
  subroutine file_put_axis_realsp( &
       fid,               &
       name, desc, units, &
       dim_name, dtype,   &
       val                )
    integer,          intent(in) :: fid
    character(len=*), intent(in) :: name
    character(len=*), intent(in) :: desc
    character(len=*), intent(in) :: units
    character(len=*), intent(in) :: dim_name
    integer,          intent(in) :: dtype
    real(sp),    intent(in), target, contiguous :: val(:)
 
    integer :: error
    intrinsic size
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_put_axis_real",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    !$acc update host(val) if(acc_is_present(val))
 
    error = file_put_axis_c( file_files(fid)%fid,                 & ! (in)
                             cstr(name), cstr(desc), cstr(units), & ! (in)
                             cstr(dim_name), dtype,               & ! (in)
#if defined(__GFORTRAN__) && __GNUC__ < 7
                             cloc(val(1)), size(val), sp       ) ! (in)
#else
                             c_loc(val), size(val), sp       ) ! (in)
#endif
    if ( error /= file_success_code .and. error /= file_already_existed_code ) then
       log_error("FILE_put_axis_realSP",*) 'failed to put axis'
       call prc_abort
    end if
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_put_axis_realsp
  subroutine file_put_axis_realdp( &
       fid,               &
       name, desc, units, &
       dim_name, dtype,   &
       val                )
    integer,          intent(in) :: fid
    character(len=*), intent(in) :: name
    character(len=*), intent(in) :: desc
    character(len=*), intent(in) :: units
    character(len=*), intent(in) :: dim_name
    integer,          intent(in) :: dtype
    real(dp),    intent(in), target, contiguous :: val(:)
 
    integer :: error
    intrinsic size
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_put_axis_real",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    !$acc update host(val) if(acc_is_present(val))
 
    error = file_put_axis_c( file_files(fid)%fid,                 & ! (in)
                             cstr(name), cstr(desc), cstr(units), & ! (in)
                             cstr(dim_name), dtype,               & ! (in)
#if defined(__GFORTRAN__) && __GNUC__ < 7
                             cloc(val(1)), size(val), dp       ) ! (in)
#else
                             c_loc(val), size(val), dp       ) ! (in)
#endif
    if ( error /= file_success_code .and. error /= file_already_existed_code ) then
       log_error("FILE_put_axis_realDP",*) 'failed to put axis'
       call prc_abort
    end if
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_put_axis_realdp
 
  subroutine file_def_axis( &
       fid,                       &
       name, desc, units,         &
       dim_name, dtype, dim_size, &
       bounds                     )
    integer,          intent(in) :: fid
    character(len=*), intent(in) :: name
    character(len=*), intent(in) :: desc
    character(len=*), intent(in) :: units
    character(len=*), intent(in) :: dim_name
    integer,          intent(in) :: dtype
    integer,          intent(in) :: dim_size
 
    logical,          intent(in), optional :: bounds
 
    integer :: error
    integer :: bounds_
 
    bounds_ = 0 ! .false.
    if ( present(bounds) ) then
       if ( bounds ) bounds_ = 1 ! .true.
    end if
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_def_axis",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    error = file_def_axis_c( file_files(fid)%fid,                     & ! (in)
                             cstr(name), cstr(desc), cstr(units),     & ! (in)
                             cstr(dim_name), dtype, dim_size, bounds_ ) ! (in)
    if ( error /= file_success_code .and. error /= file_already_existed_code ) then
       log_error("FILE_def_axis",*) 'failed to define axis'
       call prc_abort
    end if
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_def_axis
 
  !-----------------------------------------------------------------------------
  ! interface FILE_WriteAxis
  !-----------------------------------------------------------------------------
  subroutine file_write_axis_realsp( &
       fid,  &
       name, &
       val,  &
       start )
    integer,          intent(in)           :: fid
    character(len=*), intent(in)           :: name
    real(sp),    intent(in), target, contiguous :: val(:)
    integer,          intent(in), optional :: start(:)
 
    integer :: error
    intrinsic shape
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_write_axis_realSP",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    !$acc update host(val) if(acc_is_present(val))
 
    if ( present(start) ) then
       error = file_write_axis_c( file_files(fid)%fid, cstr(name),         & ! (in)
#if defined(__GFORTRAN__) && __GNUC__ < 7
                                  cloc(val(1)), sp, start-1, shape(val) ) ! (in)
#else
                                  c_loc(val), sp, start-1, shape(val) ) ! (in)
#endif
    else
       error = file_write_axis_c( file_files(fid)%fid, cstr(name),       & ! (in)
#if defined(__GFORTRAN__) && __GNUC__ < 7
                                  cloc(val(1)), sp, (/0/), shape(val) ) ! (in)
#else
                                  c_loc(val), sp, (/0/), shape(val) ) ! (in)
#endif
    end if
    if ( error /= file_success_code ) then
       log_error("FILE_write_axis_realSP",*) 'failed to write axis: '//trim(name)
       call prc_abort
    end if
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_write_axis_realsp
  subroutine file_write_axis_realdp( &
       fid,  &
       name, &
       val,  &
       start )
    integer,          intent(in)           :: fid
    character(len=*), intent(in)           :: name
    real(dp),    intent(in), target, contiguous :: val(:)
    integer,          intent(in), optional :: start(:)
 
    integer :: error
    intrinsic shape
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_write_axis_realDP",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    !$acc update host(val) if(acc_is_present(val))
 
    if ( present(start) ) then
       error = file_write_axis_c( file_files(fid)%fid, cstr(name),         & ! (in)
#if defined(__GFORTRAN__) && __GNUC__ < 7
                                  cloc(val(1)), dp, start-1, shape(val) ) ! (in)
#else
                                  c_loc(val), dp, start-1, shape(val) ) ! (in)
#endif
    else
       error = file_write_axis_c( file_files(fid)%fid, cstr(name),       & ! (in)
#if defined(__GFORTRAN__) && __GNUC__ < 7
                                  cloc(val(1)), dp, (/0/), shape(val) ) ! (in)
#else
                                  c_loc(val), dp, (/0/), shape(val) ) ! (in)
#endif
    end if
    if ( error /= file_success_code ) then
       log_error("FILE_write_axis_realDP",*) 'failed to write axis: '//trim(name)
       call prc_abort
    end if
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_write_axis_realdp
 
  !-----------------------------------------------------------------------------
  ! interface FILE_put_associatedCoordinate
  !-----------------------------------------------------------------------------
  subroutine file_put_associatedcoordinate_realsp_1d( &
       fid,                &
       name, desc,  units, &
       dim_names, dtype,   &
       val                 )
    integer,          intent(in) :: fid
    character(len=*), intent(in) :: name
    character(len=*), intent(in) :: desc
    character(len=*), intent(in) :: units
    character(len=*), intent(in) :: dim_names(:)
    integer,          intent(in) :: dtype
#ifdef NVIDIA
    real(sp),    intent(in) :: val(:)
#else
    real(sp),    intent(in), target, contiguous :: val(:)
#endif
 
    type(c_ptr) :: dim_names_(size(dim_names))
    !character(:,c_char), allocatable, target :: cptr(:)
    character(len=H_SHORT), allocatable, target :: cptr(:)
 
    integer :: i
    integer :: error
    intrinsic size, len
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_put_associatedCoordinate_realSP_1D",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    !allocate( character(len=len(dim_names)+1) :: cptr(size(dim_names)) )
    allocate( cptr(size(dim_names)) )
    do i = 1, size(dim_names)
       cptr(i) = cstr(dim_names(i))
       dim_names_(i) = c_loc(cptr(i))
    end do
 
    !$acc update host(val) if(acc_is_present(val))
 
#ifdef NVIDIA
    block
    real(sp), allocatable, target :: work(:)
    allocate(work, source=val)
#endif
    error = file_put_associatedcoordinate_c( &
         file_files(fid)%fid,                 & ! (in)
         cstr(name), cstr(desc), cstr(units), & ! (in)
         dim_names_, size(dim_names), dtype,  & ! (in)
#if defined(__GFORTRAN__) && __GNUC__ < 7
         cloc(val(1)), sp                  ) ! (in)
#elif defined(NVIDIA)
         c_loc(work), sp                  ) ! (in)
#else
         c_loc(val), sp                  ) ! (in)
#endif
    if ( error /= file_success_code .and. error /= file_already_existed_code ) then
       log_error("FILE_put_associatedCoordinate_realSP_1D",*) 'failed to put associated coordinate: '//trim(name)
       call prc_abort
    end if
 
#ifdef NVIDIA
    end block
#endif
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_put_associatedcoordinate_realsp_1d
  subroutine file_put_associatedcoordinate_realdp_1d( &
       fid,                &
       name, desc,  units, &
       dim_names, dtype,   &
       val                 )
    integer,          intent(in) :: fid
    character(len=*), intent(in) :: name
    character(len=*), intent(in) :: desc
    character(len=*), intent(in) :: units
    character(len=*), intent(in) :: dim_names(:)
    integer,          intent(in) :: dtype
#ifdef NVIDIA
    real(dp),    intent(in) :: val(:)
#else
    real(dp),    intent(in), target, contiguous :: val(:)
#endif
 
    type(c_ptr) :: dim_names_(size(dim_names))
    !character(:,c_char), allocatable, target :: cptr(:)
    character(len=H_SHORT), allocatable, target :: cptr(:)
 
    integer :: i
    integer :: error
    intrinsic size, len
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_put_associatedCoordinate_realDP_1D",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    !allocate( character(len=len(dim_names)+1) :: cptr(size(dim_names)) )
    allocate( cptr(size(dim_names)) )
    do i = 1, size(dim_names)
       cptr(i) = cstr(dim_names(i))
       dim_names_(i) = c_loc(cptr(i))
    end do
 
    !$acc update host(val) if(acc_is_present(val))
 
#ifdef NVIDIA
    block
    real(dp), allocatable, target :: work(:)
    allocate(work, source=val)
#endif
    error = file_put_associatedcoordinate_c( &
         file_files(fid)%fid,                 & ! (in)
         cstr(name), cstr(desc), cstr(units), & ! (in)
         dim_names_, size(dim_names), dtype,  & ! (in)
#if defined(__GFORTRAN__) && __GNUC__ < 7
         cloc(val(1)), dp                  ) ! (in)
#elif defined(NVIDIA)
         c_loc(work), dp                  ) ! (in)
#else
         c_loc(val), dp                  ) ! (in)
#endif
    if ( error /= file_success_code .and. error /= file_already_existed_code ) then
       log_error("FILE_put_associatedCoordinate_realDP_1D",*) 'failed to put associated coordinate: '//trim(name)
       call prc_abort
    end if
 
#ifdef NVIDIA
    end block
#endif
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_put_associatedcoordinate_realdp_1d
  subroutine file_put_associatedcoordinate_realsp_2d( &
       fid,                &
       name, desc,  units, &
       dim_names, dtype,   &
       val                 )
    integer,          intent(in) :: fid
    character(len=*), intent(in) :: name
    character(len=*), intent(in) :: desc
    character(len=*), intent(in) :: units
    character(len=*), intent(in) :: dim_names(:)
    integer,          intent(in) :: dtype
#ifdef NVIDIA
    real(sp),    intent(in) :: val(:,:)
#else
    real(sp),    intent(in), target, contiguous :: val(:,:)
#endif
 
    type(c_ptr) :: dim_names_(size(dim_names))
    !character(:,c_char), allocatable, target :: cptr(:)
    character(len=H_SHORT), allocatable, target :: cptr(:)
 
    integer :: i
    integer :: error
    intrinsic size, len
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_put_associatedCoordinate_realSP_2D",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    !allocate( character(len=len(dim_names)+1) :: cptr(size(dim_names)) )
    allocate( cptr(size(dim_names)) )
    do i = 1, size(dim_names)
       cptr(i) = cstr(dim_names(i))
       dim_names_(i) = c_loc(cptr(i))
    end do
 
    !$acc update host(val) if(acc_is_present(val))
 
#ifdef NVIDIA
    block
    real(sp), allocatable, target :: work(:,:)
    allocate(work, source=val)
#endif
    error = file_put_associatedcoordinate_c( &
         file_files(fid)%fid,                 & ! (in)
         cstr(name), cstr(desc), cstr(units), & ! (in)
         dim_names_, size(dim_names), dtype,  & ! (in)
#if defined(__GFORTRAN__) && __GNUC__ < 7
         cloc(val(1,1)), sp                  ) ! (in)
#elif defined(NVIDIA)
         c_loc(work), sp                  ) ! (in)
#else
         c_loc(val), sp                  ) ! (in)
#endif
    if ( error /= file_success_code .and. error /= file_already_existed_code ) then
       log_error("FILE_put_associatedCoordinate_realSP_2D",*) 'failed to put associated coordinate: '//trim(name)
       call prc_abort
    end if
 
#ifdef NVIDIA
    end block
#endif
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_put_associatedcoordinate_realsp_2d
  subroutine file_put_associatedcoordinate_realdp_2d( &
       fid,                &
       name, desc,  units, &
       dim_names, dtype,   &
       val                 )
    integer,          intent(in) :: fid
    character(len=*), intent(in) :: name
    character(len=*), intent(in) :: desc
    character(len=*), intent(in) :: units
    character(len=*), intent(in) :: dim_names(:)
    integer,          intent(in) :: dtype
#ifdef NVIDIA
    real(dp),    intent(in) :: val(:,:)
#else
    real(dp),    intent(in), target, contiguous :: val(:,:)
#endif
 
    type(c_ptr) :: dim_names_(size(dim_names))
    !character(:,c_char), allocatable, target :: cptr(:)
    character(len=H_SHORT), allocatable, target :: cptr(:)
 
    integer :: i
    integer :: error
    intrinsic size, len
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_put_associatedCoordinate_realDP_2D",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    !allocate( character(len=len(dim_names)+1) :: cptr(size(dim_names)) )
    allocate( cptr(size(dim_names)) )
    do i = 1, size(dim_names)
       cptr(i) = cstr(dim_names(i))
       dim_names_(i) = c_loc(cptr(i))
    end do
 
    !$acc update host(val) if(acc_is_present(val))
 
#ifdef NVIDIA
    block
    real(dp), allocatable, target :: work(:,:)
    allocate(work, source=val)
#endif
    error = file_put_associatedcoordinate_c( &
         file_files(fid)%fid,                 & ! (in)
         cstr(name), cstr(desc), cstr(units), & ! (in)
         dim_names_, size(dim_names), dtype,  & ! (in)
#if defined(__GFORTRAN__) && __GNUC__ < 7
         cloc(val(1,1)), dp                  ) ! (in)
#elif defined(NVIDIA)
         c_loc(work), dp                  ) ! (in)
#else
         c_loc(val), dp                  ) ! (in)
#endif
    if ( error /= file_success_code .and. error /= file_already_existed_code ) then
       log_error("FILE_put_associatedCoordinate_realDP_2D",*) 'failed to put associated coordinate: '//trim(name)
       call prc_abort
    end if
 
#ifdef NVIDIA
    end block
#endif
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_put_associatedcoordinate_realdp_2d
  subroutine file_put_associatedcoordinate_realsp_3d( &
       fid,                &
       name, desc,  units, &
       dim_names, dtype,   &
       val                 )
    integer,          intent(in) :: fid
    character(len=*), intent(in) :: name
    character(len=*), intent(in) :: desc
    character(len=*), intent(in) :: units
    character(len=*), intent(in) :: dim_names(:)
    integer,          intent(in) :: dtype
#ifdef NVIDIA
    real(sp),    intent(in) :: val(:,:,:)
#else
    real(sp),    intent(in), target, contiguous :: val(:,:,:)
#endif
 
    type(c_ptr) :: dim_names_(size(dim_names))
    !character(:,c_char), allocatable, target :: cptr(:)
    character(len=H_SHORT), allocatable, target :: cptr(:)
 
    integer :: i
    integer :: error
    intrinsic size, len
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_put_associatedCoordinate_realSP_3D",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    !allocate( character(len=len(dim_names)+1) :: cptr(size(dim_names)) )
    allocate( cptr(size(dim_names)) )
    do i = 1, size(dim_names)
       cptr(i) = cstr(dim_names(i))
       dim_names_(i) = c_loc(cptr(i))
    end do
 
    !$acc update host(val) if(acc_is_present(val))
 
#ifdef NVIDIA
    block
    real(sp), allocatable, target :: work(:,:,:)
    allocate(work, source=val)
#endif
    error = file_put_associatedcoordinate_c( &
         file_files(fid)%fid,                 & ! (in)
         cstr(name), cstr(desc), cstr(units), & ! (in)
         dim_names_, size(dim_names), dtype,  & ! (in)
#if defined(__GFORTRAN__) && __GNUC__ < 7
         cloc(val(1,1,1)), sp                  ) ! (in)
#elif defined(NVIDIA)
         c_loc(work), sp                  ) ! (in)
#else
         c_loc(val), sp                  ) ! (in)
#endif
    if ( error /= file_success_code .and. error /= file_already_existed_code ) then
       log_error("FILE_put_associatedCoordinate_realSP_3D",*) 'failed to put associated coordinate: '//trim(name)
       call prc_abort
    end if
 
#ifdef NVIDIA
    end block
#endif
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_put_associatedcoordinate_realsp_3d
  subroutine file_put_associatedcoordinate_realdp_3d( &
       fid,                &
       name, desc,  units, &
       dim_names, dtype,   &
       val                 )
    integer,          intent(in) :: fid
    character(len=*), intent(in) :: name
    character(len=*), intent(in) :: desc
    character(len=*), intent(in) :: units
    character(len=*), intent(in) :: dim_names(:)
    integer,          intent(in) :: dtype
#ifdef NVIDIA
    real(dp),    intent(in) :: val(:,:,:)
#else
    real(dp),    intent(in), target, contiguous :: val(:,:,:)
#endif
 
    type(c_ptr) :: dim_names_(size(dim_names))
    !character(:,c_char), allocatable, target :: cptr(:)
    character(len=H_SHORT), allocatable, target :: cptr(:)
 
    integer :: i
    integer :: error
    intrinsic size, len
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_put_associatedCoordinate_realDP_3D",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    !allocate( character(len=len(dim_names)+1) :: cptr(size(dim_names)) )
    allocate( cptr(size(dim_names)) )
    do i = 1, size(dim_names)
       cptr(i) = cstr(dim_names(i))
       dim_names_(i) = c_loc(cptr(i))
    end do
 
    !$acc update host(val) if(acc_is_present(val))
 
#ifdef NVIDIA
    block
    real(dp), allocatable, target :: work(:,:,:)
    allocate(work, source=val)
#endif
    error = file_put_associatedcoordinate_c( &
         file_files(fid)%fid,                 & ! (in)
         cstr(name), cstr(desc), cstr(units), & ! (in)
         dim_names_, size(dim_names), dtype,  & ! (in)
#if defined(__GFORTRAN__) && __GNUC__ < 7
         cloc(val(1,1,1)), dp                  ) ! (in)
#elif defined(NVIDIA)
         c_loc(work), dp                  ) ! (in)
#else
         c_loc(val), dp                  ) ! (in)
#endif
    if ( error /= file_success_code .and. error /= file_already_existed_code ) then
       log_error("FILE_put_associatedCoordinate_realDP_3D",*) 'failed to put associated coordinate: '//trim(name)
       call prc_abort
    end if
 
#ifdef NVIDIA
    end block
#endif
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_put_associatedcoordinate_realdp_3d
  subroutine file_put_associatedcoordinate_realsp_4d( &
       fid,                &
       name, desc,  units, &
       dim_names, dtype,   &
       val                 )
    integer,          intent(in) :: fid
    character(len=*), intent(in) :: name
    character(len=*), intent(in) :: desc
    character(len=*), intent(in) :: units
    character(len=*), intent(in) :: dim_names(:)
    integer,          intent(in) :: dtype
#ifdef NVIDIA
    real(sp),    intent(in) :: val(:,:,:,:)
#else
    real(sp),    intent(in), target, contiguous :: val(:,:,:,:)
#endif
 
    type(c_ptr) :: dim_names_(size(dim_names))
    !character(:,c_char), allocatable, target :: cptr(:)
    character(len=H_SHORT), allocatable, target :: cptr(:)
 
    integer :: i
    integer :: error
    intrinsic size, len
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_put_associatedCoordinate_realSP_4D",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    !allocate( character(len=len(dim_names)+1) :: cptr(size(dim_names)) )
    allocate( cptr(size(dim_names)) )
    do i = 1, size(dim_names)
       cptr(i) = cstr(dim_names(i))
       dim_names_(i) = c_loc(cptr(i))
    end do
 
    !$acc update host(val) if(acc_is_present(val))
 
#ifdef NVIDIA
    block
    real(sp), allocatable, target :: work(:,:,:,:)
    allocate(work, source=val)
#endif
    error = file_put_associatedcoordinate_c( &
         file_files(fid)%fid,                 & ! (in)
         cstr(name), cstr(desc), cstr(units), & ! (in)
         dim_names_, size(dim_names), dtype,  & ! (in)
#if defined(__GFORTRAN__) && __GNUC__ < 7
         cloc(val(1,1,1,1)), sp                  ) ! (in)
#elif defined(NVIDIA)
         c_loc(work), sp                  ) ! (in)
#else
         c_loc(val), sp                  ) ! (in)
#endif
    if ( error /= file_success_code .and. error /= file_already_existed_code ) then
       log_error("FILE_put_associatedCoordinate_realSP_4D",*) 'failed to put associated coordinate: '//trim(name)
       call prc_abort
    end if
 
#ifdef NVIDIA
    end block
#endif
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_put_associatedcoordinate_realsp_4d
  subroutine file_put_associatedcoordinate_realdp_4d( &
       fid,                &
       name, desc,  units, &
       dim_names, dtype,   &
       val                 )
    integer,          intent(in) :: fid
    character(len=*), intent(in) :: name
    character(len=*), intent(in) :: desc
    character(len=*), intent(in) :: units
    character(len=*), intent(in) :: dim_names(:)
    integer,          intent(in) :: dtype
#ifdef NVIDIA
    real(dp),    intent(in) :: val(:,:,:,:)
#else
    real(dp),    intent(in), target, contiguous :: val(:,:,:,:)
#endif
 
    type(c_ptr) :: dim_names_(size(dim_names))
    !character(:,c_char), allocatable, target :: cptr(:)
    character(len=H_SHORT), allocatable, target :: cptr(:)
 
    integer :: i
    integer :: error
    intrinsic size, len
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_put_associatedCoordinate_realDP_4D",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    !allocate( character(len=len(dim_names)+1) :: cptr(size(dim_names)) )
    allocate( cptr(size(dim_names)) )
    do i = 1, size(dim_names)
       cptr(i) = cstr(dim_names(i))
       dim_names_(i) = c_loc(cptr(i))
    end do
 
    !$acc update host(val) if(acc_is_present(val))
 
#ifdef NVIDIA
    block
    real(dp), allocatable, target :: work(:,:,:,:)
    allocate(work, source=val)
#endif
    error = file_put_associatedcoordinate_c( &
         file_files(fid)%fid,                 & ! (in)
         cstr(name), cstr(desc), cstr(units), & ! (in)
         dim_names_, size(dim_names), dtype,  & ! (in)
#if defined(__GFORTRAN__) && __GNUC__ < 7
         cloc(val(1,1,1,1)), dp                  ) ! (in)
#elif defined(NVIDIA)
         c_loc(work), dp                  ) ! (in)
#else
         c_loc(val), dp                  ) ! (in)
#endif
    if ( error /= file_success_code .and. error /= file_already_existed_code ) then
       log_error("FILE_put_associatedCoordinate_realDP_4D",*) 'failed to put associated coordinate: '//trim(name)
       call prc_abort
    end if
 
#ifdef NVIDIA
    end block
#endif
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_put_associatedcoordinate_realdp_4d
 
  subroutine file_def_associatedcoordinate( &
       fid,               &
       name, desc, units, &
       dim_names, dtype   )
    integer,          intent(in) :: fid
    character(len=*), intent(in) :: name
    character(len=*), intent(in) :: desc
    character(len=*), intent(in) :: units
    character(len=*), intent(in) :: dim_names(:)
    integer,          intent(in) :: dtype
 
    type(c_ptr) :: dim_names_(size(dim_names))
!    character(:,c_char), allocatable, target :: cptr(:)
    character(len=H_SHORT+1), allocatable, target :: cptr(:)
 
    integer :: error
    integer :: i
    intrinsic size, len
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_def_associatedCoordinate",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    !allocate( character(len=len(dim_names)+1) :: cptr(size(dim_names)) )
    allocate( cptr(size(dim_names)) )
    do i = 1, size(dim_names)
       cptr(i) = cstr(dim_names(i))
       dim_names_(i) = c_loc(cptr(i))
    end do
 
    error = file_def_associatedcoordinate_c( &
         file_files(fid)%fid,                 & ! (in)
         cstr(name), cstr(desc), cstr(units), & ! (in)
         dim_names_, size(dim_names), dtype   ) ! (in)
    if ( error /= file_success_code .and. error /= file_already_existed_code ) then
       log_error("FILE_def_associatedCoordinate",*) 'failed to define associated coordinate: '//trim(name)
       call prc_abort
    end if
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_def_associatedcoordinate
 
  !-----------------------------------------------------------------------------
  ! interface FILE_write_associatedCoordinate
  !-----------------------------------------------------------------------------
  subroutine file_write_associatedcoordinate_realsp_1d( &
       fid,          &
       name,         &
       val,          &
       start, count, &
       ndims         )
    integer,          intent(in)           :: fid
    character(len=*), intent(in)           :: name
#ifdef NVIDIA
    real(sp),    intent(in) :: val(:)
#else
    real(sp),    intent(in), target, contiguous :: val(:)
#endif
    integer,          intent(in), optional :: start(:)
    integer,          intent(in), optional :: count(:)  ! in case val has been reshaped
    integer,          intent(in), optional :: ndims     ! in case val has been reshaped
 
    integer :: ndims_
    integer, allocatable :: start_(:), count_(:)
    integer :: error
    integer :: i
    intrinsic shape, size
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_write_associatedCoordinate_realSP_1D",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    if ( present(ndims) ) then
       ndims_ = ndims
    else
       ndims_ = 1
    end if
    allocate( start_(ndims_), count_(ndims_) )
 
    if ( present(ndims) ) then
       ! Note this is called for history coordinates which have been reshaped
       ! from 2D/3D into 1D array. In this case, start and count must be also present
       do i = 1, ndims_
          start_(i) = start(ndims_-i+1) - 1
          count_(i) = count(ndims_-i+1)
       end do
    else if ( present(start) ) then
       ! Note this is called for restart coordinates
       do i = 1, ndims_
          start_(i) = start(1-i+1) - 1
          count_(i) = size(val, 1-i+1)
       end do
    else
       ! Note this is for the one-file-per-process I/O method
       do i = 1, 1
          start_(i) = 0
          count_(i) = size(val, 1-i+1)
       end do
    end if
 
    !$acc update host(val) if(acc_is_present(val))
 
#ifdef NVIDIA
    block
    real(sp), allocatable, target :: work(:)
    allocate(work, source=val)
#endif
    error = file_write_associatedcoordinate_c( &
         file_files(fid)%fid, cstr(name), & ! (in)
#if defined(__GFORTRAN__) && __GNUC__ < 7
         cloc(val(1)), & ! (in)
#elif defined(NVIDIA)
         c_loc(work), & ! (in)
#else
         c_loc(val), & ! (in)
#endif
         ndims_, sp,     & ! (in)
         start_, count_                   ) ! (in)
 
    if ( error /= file_success_code .and. error /= file_already_existed_code ) then
       log_error("FILE_write_associatedCoordinate_realSP_1D",*) 'failed to write associated coordinate: '//trim(name)
       call prc_abort
    end if
 
#ifdef NVIDIA
    end block
#endif
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_write_associatedcoordinate_realsp_1d
  subroutine file_write_associatedcoordinate_realdp_1d( &
       fid,          &
       name,         &
       val,          &
       start, count, &
       ndims         )
    integer,          intent(in)           :: fid
    character(len=*), intent(in)           :: name
#ifdef NVIDIA
    real(dp),    intent(in) :: val(:)
#else
    real(dp),    intent(in), target, contiguous :: val(:)
#endif
    integer,          intent(in), optional :: start(:)
    integer,          intent(in), optional :: count(:)  ! in case val has been reshaped
    integer,          intent(in), optional :: ndims     ! in case val has been reshaped
 
    integer :: ndims_
    integer, allocatable :: start_(:), count_(:)
    integer :: error
    integer :: i
    intrinsic shape, size
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_write_associatedCoordinate_realDP_1D",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    if ( present(ndims) ) then
       ndims_ = ndims
    else
       ndims_ = 1
    end if
    allocate( start_(ndims_), count_(ndims_) )
 
    if ( present(ndims) ) then
       ! Note this is called for history coordinates which have been reshaped
       ! from 2D/3D into 1D array. In this case, start and count must be also present
       do i = 1, ndims_
          start_(i) = start(ndims_-i+1) - 1
          count_(i) = count(ndims_-i+1)
       end do
    else if ( present(start) ) then
       ! Note this is called for restart coordinates
       do i = 1, ndims_
          start_(i) = start(1-i+1) - 1
          count_(i) = size(val, 1-i+1)
       end do
    else
       ! Note this is for the one-file-per-process I/O method
       do i = 1, 1
          start_(i) = 0
          count_(i) = size(val, 1-i+1)
       end do
    end if
 
    !$acc update host(val) if(acc_is_present(val))
 
#ifdef NVIDIA
    block
    real(dp), allocatable, target :: work(:)
    allocate(work, source=val)
#endif
    error = file_write_associatedcoordinate_c( &
         file_files(fid)%fid, cstr(name), & ! (in)
#if defined(__GFORTRAN__) && __GNUC__ < 7
         cloc(val(1)), & ! (in)
#elif defined(NVIDIA)
         c_loc(work), & ! (in)
#else
         c_loc(val), & ! (in)
#endif
         ndims_, dp,     & ! (in)
         start_, count_                   ) ! (in)
 
    if ( error /= file_success_code .and. error /= file_already_existed_code ) then
       log_error("FILE_write_associatedCoordinate_realDP_1D",*) 'failed to write associated coordinate: '//trim(name)
       call prc_abort
    end if
 
#ifdef NVIDIA
    end block
#endif
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_write_associatedcoordinate_realdp_1d
  subroutine file_write_associatedcoordinate_realsp_2d( &
       fid,          &
       name,         &
       val,          &
       start, count, &
       ndims         )
    integer,          intent(in)           :: fid
    character(len=*), intent(in)           :: name
#ifdef NVIDIA
    real(sp),    intent(in) :: val(:,:)
#else
    real(sp),    intent(in), target, contiguous :: val(:,:)
#endif
    integer,          intent(in), optional :: start(:)
    integer,          intent(in), optional :: count(:)  ! in case val has been reshaped
    integer,          intent(in), optional :: ndims     ! in case val has been reshaped
 
    integer :: ndims_
    integer, allocatable :: start_(:), count_(:)
    integer :: error
    integer :: i
    intrinsic shape, size
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_write_associatedCoordinate_realSP_2D",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    if ( present(ndims) ) then
       ndims_ = ndims
    else
       ndims_ = 2
    end if
    allocate( start_(ndims_), count_(ndims_) )
 
    if ( present(ndims) ) then
       ! Note this is called for history coordinates which have been reshaped
       ! from 2D/3D into 1D array. In this case, start and count must be also present
       do i = 1, ndims_
          start_(i) = start(ndims_-i+1) - 1
          count_(i) = count(ndims_-i+1)
       end do
    else if ( present(start) ) then
       ! Note this is called for restart coordinates
       do i = 1, ndims_
          start_(i) = start(2-i+1) - 1
          count_(i) = size(val, 2-i+1)
       end do
    else
       ! Note this is for the one-file-per-process I/O method
       do i = 1, 2
          start_(i) = 0
          count_(i) = size(val, 2-i+1)
       end do
    end if
 
    !$acc update host(val) if(acc_is_present(val))
 
#ifdef NVIDIA
    block
    real(sp), allocatable, target :: work(:,:)
    allocate(work, source=val)
#endif
    error = file_write_associatedcoordinate_c( &
         file_files(fid)%fid, cstr(name), & ! (in)
#if defined(__GFORTRAN__) && __GNUC__ < 7
         cloc(val(1,1)), & ! (in)
#elif defined(NVIDIA)
         c_loc(work), & ! (in)
#else
         c_loc(val), & ! (in)
#endif
         ndims_, sp,     & ! (in)
         start_, count_                   ) ! (in)
 
    if ( error /= file_success_code .and. error /= file_already_existed_code ) then
       log_error("FILE_write_associatedCoordinate_realSP_2D",*) 'failed to write associated coordinate: '//trim(name)
       call prc_abort
    end if
 
#ifdef NVIDIA
    end block
#endif
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_write_associatedcoordinate_realsp_2d
  subroutine file_write_associatedcoordinate_realdp_2d( &
       fid,          &
       name,         &
       val,          &
       start, count, &
       ndims         )
    integer,          intent(in)           :: fid
    character(len=*), intent(in)           :: name
#ifdef NVIDIA
    real(dp),    intent(in) :: val(:,:)
#else
    real(dp),    intent(in), target, contiguous :: val(:,:)
#endif
    integer,          intent(in), optional :: start(:)
    integer,          intent(in), optional :: count(:)  ! in case val has been reshaped
    integer,          intent(in), optional :: ndims     ! in case val has been reshaped
 
    integer :: ndims_
    integer, allocatable :: start_(:), count_(:)
    integer :: error
    integer :: i
    intrinsic shape, size
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_write_associatedCoordinate_realDP_2D",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    if ( present(ndims) ) then
       ndims_ = ndims
    else
       ndims_ = 2
    end if
    allocate( start_(ndims_), count_(ndims_) )
 
    if ( present(ndims) ) then
       ! Note this is called for history coordinates which have been reshaped
       ! from 2D/3D into 1D array. In this case, start and count must be also present
       do i = 1, ndims_
          start_(i) = start(ndims_-i+1) - 1
          count_(i) = count(ndims_-i+1)
       end do
    else if ( present(start) ) then
       ! Note this is called for restart coordinates
       do i = 1, ndims_
          start_(i) = start(2-i+1) - 1
          count_(i) = size(val, 2-i+1)
       end do
    else
       ! Note this is for the one-file-per-process I/O method
       do i = 1, 2
          start_(i) = 0
          count_(i) = size(val, 2-i+1)
       end do
    end if
 
    !$acc update host(val) if(acc_is_present(val))
 
#ifdef NVIDIA
    block
    real(dp), allocatable, target :: work(:,:)
    allocate(work, source=val)
#endif
    error = file_write_associatedcoordinate_c( &
         file_files(fid)%fid, cstr(name), & ! (in)
#if defined(__GFORTRAN__) && __GNUC__ < 7
         cloc(val(1,1)), & ! (in)
#elif defined(NVIDIA)
         c_loc(work), & ! (in)
#else
         c_loc(val), & ! (in)
#endif
         ndims_, dp,     & ! (in)
         start_, count_                   ) ! (in)
 
    if ( error /= file_success_code .and. error /= file_already_existed_code ) then
       log_error("FILE_write_associatedCoordinate_realDP_2D",*) 'failed to write associated coordinate: '//trim(name)
       call prc_abort
    end if
 
#ifdef NVIDIA
    end block
#endif
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_write_associatedcoordinate_realdp_2d
  subroutine file_write_associatedcoordinate_realsp_3d( &
       fid,          &
       name,         &
       val,          &
       start, count, &
       ndims         )
    integer,          intent(in)           :: fid
    character(len=*), intent(in)           :: name
#ifdef NVIDIA
    real(sp),    intent(in) :: val(:,:,:)
#else
    real(sp),    intent(in), target, contiguous :: val(:,:,:)
#endif
    integer,          intent(in), optional :: start(:)
    integer,          intent(in), optional :: count(:)  ! in case val has been reshaped
    integer,          intent(in), optional :: ndims     ! in case val has been reshaped
 
    integer :: ndims_
    integer, allocatable :: start_(:), count_(:)
    integer :: error
    integer :: i
    intrinsic shape, size
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_write_associatedCoordinate_realSP_3D",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    if ( present(ndims) ) then
       ndims_ = ndims
    else
       ndims_ = 3
    end if
    allocate( start_(ndims_), count_(ndims_) )
 
    if ( present(ndims) ) then
       ! Note this is called for history coordinates which have been reshaped
       ! from 2D/3D into 1D array. In this case, start and count must be also present
       do i = 1, ndims_
          start_(i) = start(ndims_-i+1) - 1
          count_(i) = count(ndims_-i+1)
       end do
    else if ( present(start) ) then
       ! Note this is called for restart coordinates
       do i = 1, ndims_
          start_(i) = start(3-i+1) - 1
          count_(i) = size(val, 3-i+1)
       end do
    else
       ! Note this is for the one-file-per-process I/O method
       do i = 1, 3
          start_(i) = 0
          count_(i) = size(val, 3-i+1)
       end do
    end if
 
    !$acc update host(val) if(acc_is_present(val))
 
#ifdef NVIDIA
    block
    real(sp), allocatable, target :: work(:,:,:)
    allocate(work, source=val)
#endif
    error = file_write_associatedcoordinate_c( &
         file_files(fid)%fid, cstr(name), & ! (in)
#if defined(__GFORTRAN__) && __GNUC__ < 7
         cloc(val(1,1,1)), & ! (in)
#elif defined(NVIDIA)
         c_loc(work), & ! (in)
#else
         c_loc(val), & ! (in)
#endif
         ndims_, sp,     & ! (in)
         start_, count_                   ) ! (in)
 
    if ( error /= file_success_code .and. error /= file_already_existed_code ) then
       log_error("FILE_write_associatedCoordinate_realSP_3D",*) 'failed to write associated coordinate: '//trim(name)
       call prc_abort
    end if
 
#ifdef NVIDIA
    end block
#endif
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_write_associatedcoordinate_realsp_3d
  subroutine file_write_associatedcoordinate_realdp_3d( &
       fid,          &
       name,         &
       val,          &
       start, count, &
       ndims         )
    integer,          intent(in)           :: fid
    character(len=*), intent(in)           :: name
#ifdef NVIDIA
    real(dp),    intent(in) :: val(:,:,:)
#else
    real(dp),    intent(in), target, contiguous :: val(:,:,:)
#endif
    integer,          intent(in), optional :: start(:)
    integer,          intent(in), optional :: count(:)  ! in case val has been reshaped
    integer,          intent(in), optional :: ndims     ! in case val has been reshaped
 
    integer :: ndims_
    integer, allocatable :: start_(:), count_(:)
    integer :: error
    integer :: i
    intrinsic shape, size
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_write_associatedCoordinate_realDP_3D",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    if ( present(ndims) ) then
       ndims_ = ndims
    else
       ndims_ = 3
    end if
    allocate( start_(ndims_), count_(ndims_) )
 
    if ( present(ndims) ) then
       ! Note this is called for history coordinates which have been reshaped
       ! from 2D/3D into 1D array. In this case, start and count must be also present
       do i = 1, ndims_
          start_(i) = start(ndims_-i+1) - 1
          count_(i) = count(ndims_-i+1)
       end do
    else if ( present(start) ) then
       ! Note this is called for restart coordinates
       do i = 1, ndims_
          start_(i) = start(3-i+1) - 1
          count_(i) = size(val, 3-i+1)
       end do
    else
       ! Note this is for the one-file-per-process I/O method
       do i = 1, 3
          start_(i) = 0
          count_(i) = size(val, 3-i+1)
       end do
    end if
 
    !$acc update host(val) if(acc_is_present(val))
 
#ifdef NVIDIA
    block
    real(dp), allocatable, target :: work(:,:,:)
    allocate(work, source=val)
#endif
    error = file_write_associatedcoordinate_c( &
         file_files(fid)%fid, cstr(name), & ! (in)
#if defined(__GFORTRAN__) && __GNUC__ < 7
         cloc(val(1,1,1)), & ! (in)
#elif defined(NVIDIA)
         c_loc(work), & ! (in)
#else
         c_loc(val), & ! (in)
#endif
         ndims_, dp,     & ! (in)
         start_, count_                   ) ! (in)
 
    if ( error /= file_success_code .and. error /= file_already_existed_code ) then
       log_error("FILE_write_associatedCoordinate_realDP_3D",*) 'failed to write associated coordinate: '//trim(name)
       call prc_abort
    end if
 
#ifdef NVIDIA
    end block
#endif
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_write_associatedcoordinate_realdp_3d
  subroutine file_write_associatedcoordinate_realsp_4d( &
       fid,          &
       name,         &
       val,          &
       start, count, &
       ndims         )
    integer,          intent(in)           :: fid
    character(len=*), intent(in)           :: name
#ifdef NVIDIA
    real(sp),    intent(in) :: val(:,:,:,:)
#else
    real(sp),    intent(in), target, contiguous :: val(:,:,:,:)
#endif
    integer,          intent(in), optional :: start(:)
    integer,          intent(in), optional :: count(:)  ! in case val has been reshaped
    integer,          intent(in), optional :: ndims     ! in case val has been reshaped
 
    integer :: ndims_
    integer, allocatable :: start_(:), count_(:)
    integer :: error
    integer :: i
    intrinsic shape, size
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_write_associatedCoordinate_realSP_4D",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    if ( present(ndims) ) then
       ndims_ = ndims
    else
       ndims_ = 4
    end if
    allocate( start_(ndims_), count_(ndims_) )
 
    if ( present(ndims) ) then
       ! Note this is called for history coordinates which have been reshaped
       ! from 2D/3D into 1D array. In this case, start and count must be also present
       do i = 1, ndims_
          start_(i) = start(ndims_-i+1) - 1
          count_(i) = count(ndims_-i+1)
       end do
    else if ( present(start) ) then
       ! Note this is called for restart coordinates
       do i = 1, ndims_
          start_(i) = start(4-i+1) - 1
          count_(i) = size(val, 4-i+1)
       end do
    else
       ! Note this is for the one-file-per-process I/O method
       do i = 1, 4
          start_(i) = 0
          count_(i) = size(val, 4-i+1)
       end do
    end if
 
    !$acc update host(val) if(acc_is_present(val))
 
#ifdef NVIDIA
    block
    real(sp), allocatable, target :: work(:,:,:,:)
    allocate(work, source=val)
#endif
    error = file_write_associatedcoordinate_c( &
         file_files(fid)%fid, cstr(name), & ! (in)
#if defined(__GFORTRAN__) && __GNUC__ < 7
         cloc(val(1,1,1,1)), & ! (in)
#elif defined(NVIDIA)
         c_loc(work), & ! (in)
#else
         c_loc(val), & ! (in)
#endif
         ndims_, sp,     & ! (in)
         start_, count_                   ) ! (in)
 
    if ( error /= file_success_code .and. error /= file_already_existed_code ) then
       log_error("FILE_write_associatedCoordinate_realSP_4D",*) 'failed to write associated coordinate: '//trim(name)
       call prc_abort
    end if
 
#ifdef NVIDIA
    end block
#endif
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_write_associatedcoordinate_realsp_4d
  subroutine file_write_associatedcoordinate_realdp_4d( &
       fid,          &
       name,         &
       val,          &
       start, count, &
       ndims         )
    integer,          intent(in)           :: fid
    character(len=*), intent(in)           :: name
#ifdef NVIDIA
    real(dp),    intent(in) :: val(:,:,:,:)
#else
    real(dp),    intent(in), target, contiguous :: val(:,:,:,:)
#endif
    integer,          intent(in), optional :: start(:)
    integer,          intent(in), optional :: count(:)  ! in case val has been reshaped
    integer,          intent(in), optional :: ndims     ! in case val has been reshaped
 
    integer :: ndims_
    integer, allocatable :: start_(:), count_(:)
    integer :: error
    integer :: i
    intrinsic shape, size
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_write_associatedCoordinate_realDP_4D",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    if ( present(ndims) ) then
       ndims_ = ndims
    else
       ndims_ = 4
    end if
    allocate( start_(ndims_), count_(ndims_) )
 
    if ( present(ndims) ) then
       ! Note this is called for history coordinates which have been reshaped
       ! from 2D/3D into 1D array. In this case, start and count must be also present
       do i = 1, ndims_
          start_(i) = start(ndims_-i+1) - 1
          count_(i) = count(ndims_-i+1)
       end do
    else if ( present(start) ) then
       ! Note this is called for restart coordinates
       do i = 1, ndims_
          start_(i) = start(4-i+1) - 1
          count_(i) = size(val, 4-i+1)
       end do
    else
       ! Note this is for the one-file-per-process I/O method
       do i = 1, 4
          start_(i) = 0
          count_(i) = size(val, 4-i+1)
       end do
    end if
 
    !$acc update host(val) if(acc_is_present(val))
 
#ifdef NVIDIA
    block
    real(dp), allocatable, target :: work(:,:,:,:)
    allocate(work, source=val)
#endif
    error = file_write_associatedcoordinate_c( &
         file_files(fid)%fid, cstr(name), & ! (in)
#if defined(__GFORTRAN__) && __GNUC__ < 7
         cloc(val(1,1,1,1)), & ! (in)
#elif defined(NVIDIA)
         c_loc(work), & ! (in)
#else
         c_loc(val), & ! (in)
#endif
         ndims_, dp,     & ! (in)
         start_, count_                   ) ! (in)
 
    if ( error /= file_success_code .and. error /= file_already_existed_code ) then
       log_error("FILE_write_associatedCoordinate_realDP_4D",*) 'failed to write associated coordinate: '//trim(name)
       call prc_abort
    end if
 
#ifdef NVIDIA
    end block
#endif
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_write_associatedcoordinate_realdp_4d
 
  !-----------------------------------------------------------------------------
  ! interface FILE_add_variable
  !-----------------------------------------------------------------------------
  subroutine file_add_variable_no_time( &
       fid,                  &
       varname, desc, units, &
       standard_name,        &
       dims, dtype,          &
       vid,                  &
       time_stats            )
    integer,          intent( in) :: fid
    character(len=*), intent( in) :: varname
    character(len=*), intent( in) :: desc
    character(len=*), intent( in) :: units
    character(len=*), intent( in) :: standard_name
    character(len=*), intent( in) :: dims(:)
    integer,          intent( in) :: dtype
    integer,          intent(out) :: vid
    character(len=*), intent( in), optional :: time_stats
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_add_variable_no_time",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    call file_add_variable_with_time( fid,    & ! (in)
         varname, desc, units, standard_name, & ! (in)
         dims, dtype, -1.0_dp,                & ! (in)
         vid,                                 & ! (out)
         time_stats = time_stats              ) ! (in)
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_add_variable_no_time
 
  !-----------------------------------------------------------------------------
  subroutine file_add_variable_with_time( &
       fid,                  &
       varname, desc, units, &
       standard_name,        &
       dims, dtype,          &
       time_int,             &
       vid,                  &
       time_stats            )
    implicit none
    integer,          intent(in)  :: fid
    character(len=*), intent(in)  :: varname
    character(len=*), intent(in)  :: desc
    character(len=*), intent(in)  :: units
    character(len=*), intent(in)  :: standard_name
    character(len=*), intent(in)  :: dims(:)
    integer,          intent(in)  :: dtype
    real(dp),         intent(in)  :: time_int
 
    integer,          intent(out) :: vid
 
    character(len=*), intent(in), optional :: time_stats
 
    type(c_ptr) :: dims_(size(dims))
    !character(:,c_char), allocatable, target :: cptr(:)
    character(len=H_SHORT), allocatable, target :: cptr(:)
 
    character(len=4) :: ctstats
 
    integer  :: cvid
    integer  :: ndims
    integer  :: error
    integer  :: n
 
    intrinsic size
    !---------------------------------------------------------------------------
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_add_variable_with_time",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    vid = -1
    do n = 1, file_nvars
       if ( file_vars(n)%fid == fid .and. file_vars(n)%name == varname ) then
          vid = file_vars(n)%vid
          exit
       endif
    enddo
 
    if ( vid < 0 ) then ! variable registration
 
       ndims = size(dims)
 
       ctstats = "none"
       if ( present(time_stats) ) then
          ctstats = time_stats
       endif
 
       !allocate( character(len=len(dims)+1) :: cptr(ndims) )
       allocate( cptr(ndims) )
       do n = 1, ndims
          cptr(n) = cstr(dims(n))
          dims_(n) = c_loc(cptr(n))
       end do
    
       error = file_add_variable_c( cvid,                             & ! [OUT]
                                    file_files(fid)%fid,              & ! [IN]
                                    cstr(varname), cstr(desc),        & ! [IN]
                                    cstr(units), cstr(standard_name), & ! [IN]
                                    dims_, ndims, dtype,              & ! [IN]
                                    time_int, cstr(ctstats)           ) ! [IN]
 
       if ( error /= file_success_code ) then
          log_error("FILE_add_variable_with_time",*) 'failed to add variable: '//trim(varname)
          call prc_abort
       endif
 
       file_nvars = file_nvars + 1
       vid = file_nvars
       file_vars(vid)%name = varname
       file_vars(vid)%vid  = cvid
       file_vars(vid)%fid  = fid
 
       log_info("FILE_add_variable_with_time",'(1x,A,I3.3,A,I4.4,2A)') &
       'Variable registration : NO.', fid, ', vid = ', vid, ', name = ', trim(varname)
    endif
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_add_variable_with_time
 
  subroutine file_def_variable( &
       fid,                  &
       varname, desc, units, &
       standard_name,        &
       ndims, dims,          &
       dtype,                &
       vid,                  &
       time_int, time_stats, &
       existed               )
    integer,          intent( in) :: fid
    character(len=*), intent( in) :: varname
    character(len=*), intent( in) :: desc
    character(len=*), intent( in) :: units
    character(len=*), intent( in) :: standard_name
    integer,          intent( in) :: ndims
    character(len=*), intent( in) :: dims(:)
    integer,          intent( in) :: dtype
    integer,          intent(out) :: vid
    real(dp),         intent( in), optional :: time_int
    character(len=*), intent( in), optional :: time_stats
    logical,          intent(out), optional :: existed
 
    type(c_ptr) :: dims_(size(dims))
    !character(:,c_char), allocatable, target :: cptr(:)
    character(len=H_SHORT), allocatable, target :: cptr(:)
 
    character(len=4) :: ctstats
 
    real(dp) :: tint_
    integer  :: cvid
    integer  :: error
    integer  :: n
 
    !---------------------------------------------------------------------------
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_def_variable",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    vid = -1
    do n = 1, file_nvars
       if ( file_vars(n)%fid == fid .and. file_vars(n)%name == varname ) then
          vid = n
       end if
    enddo
 
    if ( vid < 0 ) then ! variable registration
 
       if ( present(time_int) ) then
          tint_ = time_int
       else
          tint_ = -1.0_dp
       endif
 
       ctstats = "none"
       if ( present(time_stats) ) then
          ctstats = time_stats
       end if
 
       !allocate( character(len=len(dims)+1) :: cptr(ndims) )
       allocate( cptr(ndims) )
       do n = 1, ndims
          cptr(n) = cstr(dims(n))
          dims_(n) = c_loc(cptr(n))
       end do
 
       error = file_add_variable_c( cvid,                                     & ! [OUT]
                                    file_files(fid)%fid,                      & ! [IN]
                                    cstr(varname), cstr(desc),                & ! [IN]
                                    cstr(units), cstr(standard_name),         & ! [IN]
                                    dims_, ndims, dtype, tint_, cstr(ctstats) ) ! [IN]
 
       if ( error /= file_success_code ) then
          log_error("FILE_def_variable",*) 'failed to add variable: '//trim(varname)
          call prc_abort
       end if
 
       file_nvars = file_nvars + 1
       vid = file_nvars
       file_vars(vid)%name = varname
       file_vars(vid)%vid  = cvid
       file_vars(vid)%fid  = fid
 
       log_info("FILE_def_variable",'(1x,A,I3.3,A,I4.4,2A)') &
       'Variable registration : NO.', fid, ', vid = ', vid, ', name = ', trim(varname)
 
       if ( present(existed) ) existed = .false.
    else
       if ( present(existed) ) existed = .true.
    endif
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_def_variable
 
  !-----------------------------------------------------------------------------
  ! FILE_Get_Attribute
  !-----------------------------------------------------------------------------
  subroutine file_get_attribute_text_fid( &
       fid,        &
       vname, key, &
       val,        &
       existed     )
    integer,          intent(in ) :: fid
    character(len=*), intent(in ) :: vname
    character(len=*), intent(in ) :: key
    character(len=*), intent(out) :: val
 
    logical, intent(out), optional :: existed
 
    logical(c_bool) :: suppress
    integer :: error
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_get_attribute_text_fid",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    if ( present(existed) ) then
       suppress = .true.
    else
       suppress = .false.
    end if
    error = file_get_attribute_text_c( val,                    & ! (out)
                                       file_files(fid)%fid,    & ! (in)
                                       cstr(vname), cstr(key), & ! (in)
                                       suppress, len(val)      ) ! (in)
    call fstr(val)
    if ( error /= file_success_code ) then
       if ( present(existed) ) then
          existed = .false.
       else
          log_error("FILE_get_attribute_text_fid",*) 'failed to get text attribute for '//trim(vname)//': '//trim(key)
          call prc_abort
       end if
    else
       if ( present(existed) ) existed = .true.
    end if
 
    call prof_rapend  ('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_get_attribute_text_fid
  subroutine file_get_attribute_text_fname( &
      basename, vname, key,      &
      val,                       &
      single, aggregate, rankid, &
      existed                    )
    implicit none
 
    character(len=*), intent(in) :: basename
    character(len=*), intent(in) :: vname
    character(len=*), intent(in) :: key
 
    character(len=*), intent(out) :: val
 
    logical, intent(in), optional :: single
    logical, intent(in), optional :: aggregate
    integer, intent(in), optional :: rankid
 
    logical, intent(out), optional :: existed
    integer :: fid
 
    call file_open( basename, & ! (in)
         fid,                 & ! (out)
         single=single,       & ! (in)
         aggregate=aggregate, & ! (in)
         rankid=rankid        ) ! (in)
 
    call file_get_attribute_text_fid( &
         fid, vname, key, & ! (in)
         val,             & ! (out)
         existed          ) ! (out)
 
    return
  end subroutine file_get_attribute_text_fname
 
  !-----------------------------------------------------------------------------
  subroutine file_get_attribute_logical_fid( &
       fid,        &
       vname, key, &
       val,        &
       existed     )
    integer,          intent(in ) :: fid
    character(len=*), intent(in ) :: vname
    character(len=*), intent(in ) :: key
    logical,          intent(out) :: val
 
    logical, intent(out), optional :: existed
 
    character(len=6) :: buf ! max length is for "false\0"
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_get_attribute_logical_fid",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    call file_get_attribute_text_fid( fid, vname, key, & ! (in)
                                      buf, existed     ) ! (out)
 
    if ( present(existed) ) then
       if ( .not. existed ) return
    end if
 
    if ( buf == "true" ) then
       val = .true.
    else if ( buf == "false" ) then
       val = .false.
    else
       log_error("FILE_get_attribute_logical_fid",*) 'value is not eigher true or false'
       call prc_abort
    end if
 
    call prof_rapend  ('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_get_attribute_logical_fid
  subroutine file_get_attribute_logical_fname( &
      basename, vname, key,      &
      val,                       &
      single, aggregate, rankid, &
      existed                    )
    implicit none
 
    character(len=*), intent(in) :: basename
    character(len=*), intent(in) :: vname
    character(len=*), intent(in) :: key
 
    logical, intent(out) :: val
 
    logical, intent(in), optional :: single
    logical, intent(in), optional :: aggregate
    integer, intent(in), optional :: rankid
 
    logical, intent(out), optional :: existed
    integer :: fid
 
    call file_open( basename, & ! (in)
         fid,                 & ! (out)
         single=single,       & ! (in)
         aggregate=aggregate, & ! (in)
         rankid=rankid        ) ! (in)
 
    call file_get_attribute_logical_fid( &
         fid, vname, key, & ! (in)
         val,             & ! (out)
         existed          ) ! (out)
 
    return
  end subroutine file_get_attribute_logical_fname
 
  !-----------------------------------------------------------------------------
  subroutine file_get_attribute_int_fid_ary( &
       fid, vname, key, &
       val,             &
       existed          )
    integer,          intent(in ) :: fid
    character(len=*), intent(in ) :: vname
    character(len=*), intent(in ) :: key
    integer,          intent(out) :: val(:)
 
    logical, intent(out), optional :: existed
 
    logical(c_bool) :: suppress
    integer :: error
 
    intrinsic size
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_get_attribute_int_fid",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    if ( present(existed) ) then
       suppress = .true.
    else
       suppress = .false.
    end if
    error = file_get_attribute_int_c( val(:),                 & ! (out)
                                      file_files(fid)%fid,    & ! (in)
                                      cstr(vname), cstr(key), & ! (in)
                                      suppress, size(val)     ) ! (in)
    if ( error /= file_success_code ) then
       if ( present(existed) ) then
          existed = .false.
       else
          log_error("FILE_get_attribute_int_fid",*) 'failed to get integer attribute for '//trim(vname)//': '//trim(key)
          call prc_abort
       end if
    else
       if ( present(existed) ) existed = .true.
    end if
 
    call prof_rapend  ('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_get_attribute_int_fid_ary
  subroutine file_get_attribute_int_fid( &
       fid, vname, key, &
       val,             &
       existed          )
    integer,          intent(in ) :: fid
    character(len=*), intent(in ) :: vname
    character(len=*), intent(in ) :: key
    integer,          intent(out) :: val
    logical, intent(out), optional :: existed
    integer :: ary(1)
 
    call file_get_attribute_int_fid_ary( &
       fid, vname, key, &
       ary(:),          &
       existed          )
    if ( present(existed) ) then
       if ( .not. existed ) return
    end if
    val = ary(1)
 
    return
  end subroutine file_get_attribute_int_fid
  subroutine file_get_attribute_int_fname_ary( &
      basename, vname, key,      &
      val,                       &
      single, aggregate, rankid, &
      existed                    )
    implicit none
 
    character(len=*), intent(in) :: basename
    character(len=*), intent(in) :: vname
    character(len=*), intent(in) :: key
 
    integer, intent(out) :: val(:)
 
    logical, intent(in), optional :: single
    logical, intent(in), optional :: aggregate
    integer, intent(in), optional :: rankid
 
    logical, intent(out), optional :: existed
 
    integer :: fid
 
    call file_open( basename, & ! (in)
         fid,                 & ! (out)
         single=single,       & ! (in)
         aggregate=aggregate, &
         rankid=rankid        ) ! (in)
 
    call file_get_attribute_int_fid_ary( &
         fid, vname, key, & ! (in)
         val,             & ! (out)
         existed          ) ! (out)
 
    return
  end subroutine file_get_attribute_int_fname_ary
  subroutine file_get_attribute_int_fname( &
      basename, vname, key,      &
      val,                       &
      single, aggregate, rankid, &
      existed                    )
    implicit none
    character(len=*), intent(in) :: basename
    character(len=*), intent(in) :: vname
    character(len=*), intent(in) :: key
    integer, intent(out) :: val
    logical, intent(in), optional :: single
    logical, intent(in), optional :: aggregate
    integer, intent(in), optional :: rankid
    logical, intent(out), optional :: existed
    integer :: ary(1)
 
    call file_get_attribute_int_fname_ary( &
         basename, vname, key,      &
         ary(:),                    &
         single, aggregate, rankid, &
         existed                    )
    val = ary(1)
 
    return
  end subroutine file_get_attribute_int_fname
  !-----------------------------------------------------------------------------
 
  subroutine file_get_attribute_float_fid_ary( &
       fid, vname, key, &
       val,             &
       existed          )
    integer,          intent(in ) :: fid
    character(len=*), intent(in ) :: vname
    character(len=*), intent(in ) :: key
    real(sp),    intent(out) :: val(:)
 
    logical, intent(out), optional :: existed
 
    logical(c_bool) :: suppress
    integer :: error
 
    intrinsic size
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_get_attribute_float_fid",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    if ( present(existed) ) then
       suppress = .true.
    else
       suppress = .false.
    end if
    error = file_get_attribute_float_c( val,                    & ! (out)
                                            file_files(fid)%fid,    & ! (in)
                                            cstr(vname), cstr(key), & ! (in)
                                            suppress, size(val)     ) ! (in)
    if ( error /= file_success_code ) then
       if ( present(existed) ) then
          existed = .false.
       else
          log_error("FILE_get_attribute_float_fid",*) 'failed to get float attribute for '//trim(vname)//': '//trim(key)
          call prc_abort
       end if
    else
       if ( present(existed) ) existed = .true.
    end if
 
    call prof_rapend  ('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_get_attribute_float_fid_ary
  subroutine file_get_attribute_float_fid( &
       fid, vname, key, &
       val,             &
       existed          )
    integer,          intent(in ) :: fid
    character(len=*), intent(in ) :: vname
    character(len=*), intent(in ) :: key
    real(sp),    intent(out) :: val
    logical, intent(out), optional :: existed
    real(sp) :: ary(1)
 
    call file_get_attribute_float_fid_ary( &
       fid, vname, key, &
       ary(:),          &
       existed          )
    if ( present(existed) ) then
       if ( .not. existed ) return
    end if
    val = ary(1)
 
    return
  end subroutine file_get_attribute_float_fid
  subroutine file_get_attribute_float_fname_ary( &
      basename, vname, key,      &
      val,                       &
      single, aggregate, rankid, &
      existed                    )
    implicit none
 
    character(len=*), intent(in) :: basename
    character(len=*), intent(in) :: vname
    character(len=*), intent(in) :: key
 
    real(sp), intent(out) :: val(:)
 
    logical, intent(in), optional :: single
    logical, intent(in), optional :: aggregate
    integer, intent(in), optional :: rankid
 
    logical, intent(out), optional :: existed
 
    integer :: fid
 
    call file_open( basename, & ! (in)
         fid,                 & ! (out)
         single=single,       & ! (in)
         aggregate=aggregate, & ! (in)
         rankid=rankid        ) ! (in)
 
    call file_get_attribute_float_fid_ary( &
         fid, vname, key, & ! (in)
         val,             & ! (out)
         existed          ) ! (out)
 
    return
  end subroutine file_get_attribute_float_fname_ary
  subroutine file_get_attribute_float_fname( &
      basename, vname, key,      &
      val,                       &
      single, aggregate, rankid, &
      existed                    )
    implicit none
    character(len=*), intent(in) :: basename
    character(len=*), intent(in) :: vname
    character(len=*), intent(in) :: key
    real(sp), intent(out) :: val
    logical, intent(in), optional :: single
    logical, intent(in), optional :: aggregate
    integer, intent(in), optional :: rankid
    logical, intent(out), optional :: existed
    real(sp) :: ary(1)
 
    call file_get_attribute_float_fname_ary( &
      basename, vname, key,      &
      ary(:),                    &
      single, aggregate, rankid, &
      existed                    )
    val = ary(1)
 
    return
  end subroutine file_get_attribute_float_fname
  subroutine file_get_attribute_double_fid_ary( &
       fid, vname, key, &
       val,             &
       existed          )
    integer,          intent(in ) :: fid
    character(len=*), intent(in ) :: vname
    character(len=*), intent(in ) :: key
    real(dp),    intent(out) :: val(:)
 
    logical, intent(out), optional :: existed
 
    logical(c_bool) :: suppress
    integer :: error
 
    intrinsic size
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_get_attribute_double_fid",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    if ( present(existed) ) then
       suppress = .true.
    else
       suppress = .false.
    end if
    error = file_get_attribute_double_c( val,                    & ! (out)
                                            file_files(fid)%fid,    & ! (in)
                                            cstr(vname), cstr(key), & ! (in)
                                            suppress, size(val)     ) ! (in)
    if ( error /= file_success_code ) then
       if ( present(existed) ) then
          existed = .false.
       else
          log_error("FILE_get_attribute_double_fid",*) 'failed to get double attribute for '//trim(vname)//': '//trim(key)
          call prc_abort
       end if
    else
       if ( present(existed) ) existed = .true.
    end if
 
    call prof_rapend  ('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_get_attribute_double_fid_ary
  subroutine file_get_attribute_double_fid( &
       fid, vname, key, &
       val,             &
       existed          )
    integer,          intent(in ) :: fid
    character(len=*), intent(in ) :: vname
    character(len=*), intent(in ) :: key
    real(dp),    intent(out) :: val
    logical, intent(out), optional :: existed
    real(dp) :: ary(1)
 
    call file_get_attribute_double_fid_ary( &
       fid, vname, key, &
       ary(:),          &
       existed          )
    if ( present(existed) ) then
       if ( .not. existed ) return
    end if
    val = ary(1)
 
    return
  end subroutine file_get_attribute_double_fid
  subroutine file_get_attribute_double_fname_ary( &
      basename, vname, key,      &
      val,                       &
      single, aggregate, rankid, &
      existed                    )
    implicit none
 
    character(len=*), intent(in) :: basename
    character(len=*), intent(in) :: vname
    character(len=*), intent(in) :: key
 
    real(dp), intent(out) :: val(:)
 
    logical, intent(in), optional :: single
    logical, intent(in), optional :: aggregate
    integer, intent(in), optional :: rankid
 
    logical, intent(out), optional :: existed
 
    integer :: fid
 
    call file_open( basename, & ! (in)
         fid,                 & ! (out)
         single=single,       & ! (in)
         aggregate=aggregate, & ! (in)
         rankid=rankid        ) ! (in)
 
    call file_get_attribute_double_fid_ary( &
         fid, vname, key, & ! (in)
         val,             & ! (out)
         existed          ) ! (out)
 
    return
  end subroutine file_get_attribute_double_fname_ary
  subroutine file_get_attribute_double_fname( &
      basename, vname, key,      &
      val,                       &
      single, aggregate, rankid, &
      existed                    )
    implicit none
    character(len=*), intent(in) :: basename
    character(len=*), intent(in) :: vname
    character(len=*), intent(in) :: key
    real(dp), intent(out) :: val
    logical, intent(in), optional :: single
    logical, intent(in), optional :: aggregate
    integer, intent(in), optional :: rankid
    logical, intent(out), optional :: existed
    real(dp) :: ary(1)
 
    call file_get_attribute_double_fname_ary( &
      basename, vname, key,      &
      ary(:),                    &
      single, aggregate, rankid, &
      existed                    )
    val = ary(1)
 
    return
  end subroutine file_get_attribute_double_fname
 
  !-----------------------------------------------------------------------------
  ! FILE_set_attribute
  !-----------------------------------------------------------------------------
  subroutine file_set_attribute_text( &
     fid, vname, &
     key, val    )
    integer,          intent(in) :: fid
    character(len=*), intent(in) :: vname
    character(len=*), intent(in) :: key
    character(len=*), intent(in) :: val
 
    integer :: error
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_set_attribute_text",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    error = file_set_attribute_text_c( file_files(fid)%fid,    & ! (in)
                                       cstr(vname), cstr(key), & ! (in)
                                       cstr(val)               ) ! (in)
    if ( error /= file_success_code .and. error /= file_already_existed_code ) then
       log_error("FILE_set_attribute_text",*) 'failed to set text attribute for '//trim(vname)//': '//trim(key)
       call prc_abort
    end if
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_set_attribute_text
 
  subroutine file_set_attribute_logical( &
     fid, vname, &
     key, val    )
    integer,          intent(in) :: fid
    character(len=*), intent(in) :: vname
    character(len=*), intent(in) :: key
    logical,          intent(in) :: val
 
    character(len=5) :: buf
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_set_attribute_logical",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    if ( val ) then
       buf = "true"
    else
       buf = "false"
    end if
 
    call file_set_attribute_text( fid, vname, key, buf )
 
    return
  end subroutine file_set_attribute_logical
 
  !-----------------------------------------------------------------------------
  subroutine file_set_attribute_int_ary( &
     fid, vname, &
     key, val    )
    integer,          intent(in) :: fid
    character(len=*), intent(in) :: vname
    character(len=*), intent(in) :: key
    integer,          intent(in) :: val(:)
 
    integer :: error
 
    intrinsic size
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_set_attribute_int",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    error = file_set_attribute_int_c( file_files(fid)%fid,    & ! (in)
                                      cstr(vname), cstr(key), & ! (in)
                                      val(:), size(val(:))    ) ! (in)
    if ( error /= file_success_code .and. error /= file_already_existed_code ) then
       log_error("FILE_set_attribute_int",*) 'failed to set integer attribute for '//trim(vname)//': '//trim(key)
       call prc_abort
    end if
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_set_attribute_int_ary
 
  subroutine file_set_attribute_int( &
     fid, vname, &
     key, val    )
    integer,          intent(in) :: fid
    character(len=*), intent(in) :: vname
    character(len=*), intent(in) :: key
    integer,          intent(in) :: val
 
    integer :: ary(1)
 
    ary(1) = val
    call file_set_attribute_int_ary( fid, vname, &
                                     key, ary(:) )
 
    return
  end subroutine file_set_attribute_int
 
  !-----------------------------------------------------------------------------
  subroutine file_set_attribute_float_ary( &
     fid, vname, &
     key, val    )
    integer,          intent(in) :: fid
    character(len=*), intent(in) :: vname
    character(len=*), intent(in) :: key
    real(sp),    intent(in) :: val(:)
 
    integer :: error
 
    intrinsic size
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_set_attributefloat",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    error = file_set_attribute_float_c( file_files(fid)%fid,    & ! (in)
                                            cstr(vname), cstr(key), & ! (in)
                                            val(:), size(val(:))    ) ! (in)
    if ( error /= file_success_code .and. error /= file_already_existed_code ) then
       log_error("FILE_set_attribute_float",*) 'failed to set float attribute for '//trim(vname)//': '//trim(key)
       call prc_abort
    end if
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_set_attribute_float_ary
 
  subroutine file_set_attribute_float( &
     fid, vname, &
     key, val    )
    integer,          intent(in) :: fid
    character(len=*), intent(in) :: vname
    character(len=*), intent(in) :: key
    real(sp),    intent(in) :: val
 
    real(sp) :: ary(1)
 
    ary(1) = val
    call file_set_attribute_float_ary( fid, vname, &
                                           key, ary(:) )
 
    return
  end subroutine file_set_attribute_float
  !-----------------------------------------------------------------------------
  subroutine file_set_attribute_double_ary( &
     fid, vname, &
     key, val    )
    integer,          intent(in) :: fid
    character(len=*), intent(in) :: vname
    character(len=*), intent(in) :: key
    real(dp),    intent(in) :: val(:)
 
    integer :: error
 
    intrinsic size
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_set_attributedouble",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    error = file_set_attribute_double_c( file_files(fid)%fid,    & ! (in)
                                            cstr(vname), cstr(key), & ! (in)
                                            val(:), size(val(:))    ) ! (in)
    if ( error /= file_success_code .and. error /= file_already_existed_code ) then
       log_error("FILE_set_attribute_double",*) 'failed to set double attribute for '//trim(vname)//': '//trim(key)
       call prc_abort
    end if
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_set_attribute_double_ary
 
  subroutine file_set_attribute_double( &
     fid, vname, &
     key, val    )
    integer,          intent(in) :: fid
    character(len=*), intent(in) :: vname
    character(len=*), intent(in) :: key
    real(dp),    intent(in) :: val
 
    real(dp) :: ary(1)
 
    ary(1) = val
    call file_set_attribute_double_ary( fid, vname, &
                                           key, ary(:) )
 
    return
  end subroutine file_set_attribute_double
  !-----------------------------------------------------------------------------
  ! FILE_get_shape
  !-----------------------------------------------------------------------------
  subroutine file_get_shape_fname( &
      basename, varname, &
      dims,              &
      rankid, single,    &
      has_tdim,          &
      error              )
    implicit none
 
    character(len=*), intent( in)           :: basename
    character(len=*), intent( in)           :: varname
    integer,          intent(out)           :: dims(:)
    integer,          intent( in), optional :: rankid
    logical,          intent( in), optional :: single
    logical,          intent(out), optional :: has_tdim
    logical,          intent(out), optional :: error
 
    integer :: fid
    !---------------------------------------------------------------------------
 
    !--- search/register file
    call file_open( basename,                    & ! (in)
                    fid,                         & ! (out)
                    rankid=rankid, single=single ) ! (in)
 
    call file_get_shape_fid( fid, varname,        & ! (in)
                             dims(:),             & ! (out)
                             has_tdim = has_tdim, & ! (out)
                             error = error        ) ! (out)
 
    return
  end subroutine file_get_shape_fname
 
  subroutine file_get_shape_fid( &
       fid, varname, &
       dims,         &
       has_tdim,     &
       error         )
    implicit none
    integer,          intent( in)           :: fid
    character(len=*), intent( in)           :: varname
    integer,          intent(out)           :: dims(:)
    logical,          intent(out), optional :: has_tdim
    logical,          intent(out), optional :: error
 
    type(datainfo) :: dinfo
    integer :: ierror
    integer :: n
 
    logical(c_bool) :: suppress
 
    intrinsic size
    !---------------------------------------------------------------------------
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_get_shape_id",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    if ( present(error) ) then
       suppress = .true.
    else
       suppress = .false.
    end if
 
    !--- get data information
    ierror = file_get_datainfo_c( dinfo,               & ! (out)
                                  file_files(fid)%fid, & ! (in)
                                  cstr(varname),       & ! (in)
                                  1, suppress          ) ! (in)
 
    call prof_rapend  ('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    !--- verify
    if ( ierror /= file_success_code ) then
       if ( present(error) ) then
          error = .true.
          return
       else
          log_error("FILE_get_shape_fid",*) 'failed to get data information : ', trim(varname)
          call prc_abort
       end if
    end if
 
    if ( dinfo%rank /= size(dims) ) then
       log_error("FILE_get_shape_fid",*) 'rank is different, ', trim(varname), size(dims), dinfo%rank
       call prc_abort
    end if
    do n = 1, size(dims)
       dims(n) = dinfo%dim_size(n)
    end do
 
    if ( present(has_tdim) ) has_tdim = dinfo%has_tdim
    if ( present(error) ) error = .false.
 
    return
  end subroutine file_get_shape_fid
 
  !-----------------------------------------------------------------------------
  !-----------------------------------------------------------------------------
  subroutine file_get_stepsize( &
       fid, varname, &
       len,          &
       error         )
    integer,          intent(in) :: fid
    character(len=*), intent(in) :: varname
 
    integer, intent(out) :: len
 
    logical, intent(out), optional :: error
 
    integer :: ierror
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_get_stepSize",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    ierror = file_get_step_size_c( len,                               & ! (out)
                                   file_files(fid)%fid, cstr(varname) ) ! (in)
    if ( ierror /= file_success_code .and. ierror /= file_already_existed_code ) then
       if ( present(error) ) then
          error = .true.
       else
          log_error("FILE_get_stepSize",*) 'failed to get number of steps'
          call prc_abort
       end if
    else
       if ( present(error) ) error = .false.
    end if
 
    call prof_rapend  ('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_get_stepsize
 
  !-----------------------------------------------------------------------------
  ! FILE_get_commonInfo
  !-----------------------------------------------------------------------------
  subroutine file_get_commoninfo_fname( &
       basename,    &
       rankid,      &
       nvars_limit, &
       title,       &
       source,      &
       institution, &
       nvars,       &
       varname      )
    implicit none
 
    character(len=*),           intent(in)  :: basename
    integer,                    intent(in)  :: rankid
    integer,                    intent(in)  :: nvars_limit
    character(len=FILE_HMID),   intent(out) :: title                ! title of the file
    character(len=FILE_HMID),   intent(out) :: source               ! for file header
    character(len=FILE_HMID),   intent(out) :: institution          ! for file header
    integer,                    intent(out) :: nvars                ! number of variables
    character(len=FILE_HSHORT), intent(out) :: varname(nvars_limit) ! name of variables
 
    integer :: fid
    !---------------------------------------------------------------------------
 
    call file_open( basename,             & ! [IN]
                    fid,                  & ! [OUT]
                    rankid=rankid         ) ! [IN]
 
    call file_get_commoninfo_fid( fid,         & ! [IN]
                                  nvars_limit, & ! [IN]
                                  title,       & ! [OUT]
                                  source,      & ! [OUT]
                                  institution, & ! [OUT]
                                  nvars,       & ! [OUT]
                                  varname(:)   ) ! [OUT]
 
    return
  end subroutine file_get_commoninfo_fname
 
  subroutine file_get_commoninfo_fid( &
       fid,         &
       nvars_limit, &
       title,       &
       source,      &
       institution, &
       nvars,       &
       varname      )
    implicit none
 
    integer,                    intent(in)  :: fid
    integer,                    intent(in)  :: nvars_limit
    character(len=FILE_HMID),   intent(out) :: title                ! title of the file
    character(len=FILE_HMID),   intent(out) :: source               ! for file header
    character(len=FILE_HMID),   intent(out) :: institution          ! for file header
    integer,                    intent(out) :: nvars                ! number of variables
    character(len=FILE_HSHORT), intent(out) :: varname(nvars_limit) ! name of variables
 
    integer :: v
    !---------------------------------------------------------------------------
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_get_commonInfo_fid",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    call file_get_attribute( fid, 'global', 'title',       title       )
    call file_get_attribute( fid, 'global', 'source',      source      )
    call file_get_attribute( fid, 'global', 'institution', institution )
 
    call file_get_var_num( fid, nvars_limit, nvars )
 
    do v = 1, nvars
       call file_get_var_name( fid, v, varname(v) )
    enddo
 
    call prof_rapend  ('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_get_commoninfo_fid
 
  !-----------------------------------------------------------------------------
  ! FILE_get_dataInfo
  !-----------------------------------------------------------------------------
  subroutine file_get_datainfo_fname( &
       basename, varname,                  &
       rankid, istep, single,              &
       existed,                            &
       description, units, standard_name,  &
       datatype,                           &
       dim_rank, dim_name, dim_size,       &
       natts, att_name, att_type, att_len, &
       has_tdim,                           &
       time_start, time_end, time_units,   &
       calendar                            )
    implicit none
 
    character(len=*),           intent(in)  :: basename
    character(len=*),           intent(in)  :: varname
 
    integer,                    intent(in),  optional :: rankid
    integer,                    intent(in),  optional :: istep
    logical,                    intent(in),  optional :: single
    logical,                    intent(out), optional :: existed
    character(len=FILE_HMID),   intent(out), optional :: description
    character(len=FILE_HSHORT), intent(out), optional :: units
    character(len=FILE_HMID),   intent(out), optional :: standard_name
    integer,                    intent(out), optional :: datatype
    integer,                    intent(out), optional :: dim_rank
    character(len=FILE_HSHORT), intent(out), optional :: dim_name(:)
    integer,                    intent(out), optional :: dim_size(:)
    integer,                    intent(out), optional :: natts
    character(len=FILE_HSHORT), intent(out), optional :: att_name(:)
    integer,                    intent(out), optional :: att_type(:)
    integer,                    intent(out), optional :: att_len (:)
    logical,                    intent(out), optional :: has_tdim
    real(dp),                   intent(out), optional :: time_start
    real(dp),                   intent(out), optional :: time_end
    character(len=FILE_HMID),   intent(out), optional :: time_units
    character(len=FILE_HSHORT), intent(out), optional :: calendar
 
    logical :: single_
    integer :: fid
    !---------------------------------------------------------------------------
 
    if ( present(single) ) then
       single_ = single
    else
       single_ = .false.
    endif
 
    !--- search/register file
    call file_open( basename,                     & ! [IN]
                    fid,                          & ! [OUT]
                    rankid=rankid, single=single_ ) ! [IN]
 
    call file_get_datainfo_fid( fid, varname,                       & ! [IN]
                                istep,                              & ! [IN] , optional
                                existed,                            & ! [OUT], optional
                                description, units, standard_name,  & ! [OUT], optional
                                datatype,                           & ! [OUT], optional
                                dim_rank, dim_name, dim_size,       & ! [OUT], optional
                                natts, att_name, att_type, att_len, & ! [OUT], optional
                                has_tdim,                           & ! [OUT], optional
                                time_start, time_end, time_units,   & ! [OUT], optional
                                calendar                            ) ! [OUT], optional
 
    return
  end subroutine file_get_datainfo_fname
 
  subroutine file_get_datainfo_fid( &
       fid, varname,                       &
       istep,                              &
       existed,                            &
       description, units, standard_name,  &
       datatype,                           &
       dim_rank, dim_name, dim_size,       &
       natts, att_name, att_type, att_len, &
       has_tdim,                           &
       time_start, time_end, time_units,   &
       calendar                            )
    implicit none
 
    integer,          intent(in)  :: fid
    character(len=*), intent(in)  :: varname
 
    integer,          intent(in),  optional :: istep
    logical,          intent(out), optional :: existed
    character(len=*), intent(out), optional :: description
    character(len=*), intent(out), optional :: units
    character(len=*), intent(out), optional :: standard_name
    integer,          intent(out), optional :: datatype
    integer,          intent(out), optional :: dim_rank
    character(len=*), intent(out), optional :: dim_name(:)
    integer,          intent(out), optional :: dim_size(:)
    integer,          intent(out), optional :: natts
    character(len=*), intent(out), optional :: att_name(:)
    integer,          intent(out), optional :: att_type(:)
    integer,          intent(out), optional :: att_len (:)
    logical,          intent(out), optional :: has_tdim
    real(dp),         intent(out), optional :: time_start
    real(dp),         intent(out), optional :: time_end
    character(len=*), intent(out), optional :: time_units
    character(len=*), intent(out), optional :: calendar
 
    type(datainfo) :: dinfo
 
    integer  :: istep_
    real(dp) :: time(1)
    integer  :: i
    integer  :: error
 
    logical(c_bool) :: suppress
    logical :: existed2
 
    character(len=FILE_HMID) :: tu
 
    intrinsic size
    !---------------------------------------------------------------------------
 
    if ( present(istep) ) then
       istep_ = istep
    else
       istep_ = 1
    end if
 
    if ( present(existed) ) then
       suppress = .true.
    else
       suppress = .false.
    end if
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_get_dataInfo_fid",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    !--- get data information
    error = file_get_datainfo_c( dinfo,               & ! [OUT]
                                 file_files(fid)%fid, & ! [IN]
                                 cstr(varname),       & ! [IN]
                                 istep_,              & ! [IN]
                                 suppress             ) ! [IN]
 
    call prof_rapend  ('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    !--- verify and exit
    if ( error /= file_success_code ) then
       if ( present( existed ) ) then
          existed = .false.
          return
       else
          log_error("FILE_get_dataInfo_fid",*) 'data info not found'
          call prc_abort
       end if
    endif
 
    call prof_rapstart('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    if ( present(existed) ) existed = .true.
 
    if ( present(description)   ) call fstr(description, dinfo%description)
    if ( present(units)         ) call fstr(units, dinfo%units)
    if ( present(standard_name) ) call fstr(standard_name, dinfo%standard_name)
    if ( present(datatype)      ) datatype      = dinfo%datatype
    if ( present(dim_rank)      ) dim_rank      = dinfo%rank
 
    if ( present(dim_name) ) then
       do i = 1, min( dinfo%rank, size(dim_name) ) ! limit dimension rank
          call fstr(dim_name(i), dinfo%dim_name(:,i))
       enddo
    endif
 
    if ( present(dim_size) ) then
       do i = 1, min( dinfo%rank, size(dim_size) ) ! limit dimension rank
          dim_size(i) = dinfo%dim_size(i)
       enddo
    endif
 
    if ( present(natts) ) natts = dinfo%natts
    if ( present(att_name) ) then
       do i = 1, min( dinfo%natts, size(att_name) )
          call fstr(att_name(i), dinfo%att_name(:,i))
       end do
    end if
    if ( present(att_type) ) then
       do i = 1, min( dinfo%natts, size(att_type) )
          att_type(i) = dinfo%att_type(i)
       end do
    end if
    if ( present(att_len) ) then
       do i = 1, min( dinfo%natts, size(att_len) )
          att_len(i) = dinfo%att_len(i)
       end do
    end if
 
    call fstr(tu, dinfo%time_units)
 
    if ( present(time_units)  ) then
       if ( tu == "" ) then
          call file_get_attribute( fid, "global", "time_units", time_units )
       else
          time_units = tu
       endif
    endif
 
    if ( present(calendar) ) then
       if ( tu == "" ) then
          call file_get_attribute( fid, "global", "calendar", calendar, existed2 )
          if ( .not. existed2 ) calendar = ""
       else
          call fstr(calendar, dinfo%calendar)
       end if
    end if
 
    if ( present(has_tdim) ) then
       has_tdim = dinfo%has_tdim
    end if
 
    if ( present(time_start)  ) then
       if ( tu == "" ) then
          call file_get_attribute( fid, "global", "time_start", time )
          time_start = time(1)
       else
          time_start = dinfo%time_start
       endif
    endif
 
    if ( present(time_end)  ) then
       if ( tu == "" ) then
          call file_get_attribute( fid, "global", "time_start", time )
          time_end = time(1)
       else
          time_end = dinfo%time_end
       end if
    endif
 
    call prof_rapend  ('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_get_datainfo_fid
 
  !-----------------------------------------------------------------------------
  ! FILE_get_data_all_dataInfo
  !-----------------------------------------------------------------------------
  subroutine file_get_all_datainfo_fname(  &
       basename, varname,                  &
       step_nmax,                          &
       description, units, standard_name,  &
       datatype,                           &
       dim_rank, dim_name, dim_size,       &
       natts, att_name, att_type, att_len, &
       time_start, time_end,               &
       time_units, calendar,               &
       rankid, single                      )
    implicit none
    character(len=*),           intent(in)  :: basename
    character(len=*),           intent(in)  :: varname
    integer,                    intent(out) :: step_nmax
    character(len=FILE_HMID),   intent(out) :: description
    character(len=FILE_HSHORT), intent(out) :: units
    character(len=FILE_HMID),   intent(out) :: standard_name
    integer,                    intent(out) :: datatype
    integer,                    intent(out) :: dim_rank
    character(len=FILE_HSHORT), intent(out) :: dim_name  (:)
    integer,                    intent(out) :: dim_size  (:)
    integer,                    intent(out) :: natts
    character(len=FILE_HSHORT), intent(out) :: att_name  (:)
    integer,                    intent(out) :: att_type  (:)
    integer,                    intent(out) :: att_len   (:)
    real(dp),                   intent(out) :: time_start(:)
    real(dp),                   intent(out) :: time_end  (:)
    character(len=FILE_HMID),   intent(out) :: time_units
    character(len=FILE_HSHORT), intent(out) :: calendar
 
    integer,                    intent(in), optional :: rankid
    logical,                    intent(in), optional :: single
 
    integer :: fid
    logical :: single_
    !---------------------------------------------------------------------------
 
    if ( present(single) ) then
       single_ = single
    else
       single_ = .false.
    endif
 
    !--- search/register file
    call file_open( basename,                     & ! [IN]
                    fid,                          & ! [OUT]
                    rankid=rankid, single=single_ ) ! [IN]
 
    call file_get_all_datainfo_fid( fid, varname,                                & ! [IN]
                                    step_nmax,                                   & ! [OUT]
                                    description, units, standard_name,           & ! [OUT]
                                    datatype,                                    & ! [OUT]
                                    dim_rank, dim_name(:), dim_size(:),          & ! [OUT]
                                    natts, att_name(:), att_type(:), att_len(:), & ! [OUT]
                                    time_start(:), time_end(:),                  & ! [OUT]
                                    time_units, calendar                         ) ! [OUT]
 
    return
  end subroutine file_get_all_datainfo_fname
 
  subroutine file_get_all_datainfo_fid( &
       fid, varname,                       &
       step_nmax,                          &
       description, units, standard_name,  &
       datatype,                           &
       dim_rank, dim_name, dim_size,       &
       natts, att_name, att_type, att_len, &
       time_start, time_end,               &
       time_units, calendar                )
    implicit none
 
    integer,          intent(in)  :: fid
    character(len=*), intent(in)  :: varname
    integer,          intent(out) :: step_nmax
    character(len=*), intent(out) :: description
    character(len=*), intent(out) :: units
    character(len=*), intent(out) :: standard_name
    integer,          intent(out) :: datatype
    integer,          intent(out) :: dim_rank
    character(len=*), intent(out) :: dim_name  (:)
    integer,          intent(out) :: dim_size  (:)
    integer,          intent(out) :: natts
    character(len=*), intent(out) :: att_name  (:)
    integer,          intent(out) :: att_type  (:)
    integer,          intent(out) :: att_len   (:)
    real(dp),         intent(out) :: time_start(:)
    real(dp),         intent(out) :: time_end  (:)
    character(len=*), intent(out) :: time_units
    character(len=*), intent(out) :: calendar
 
    type(datainfo) :: dinfo
 
    real(dp) :: time(1)
    integer  :: i
    integer  :: error
    logical  :: existed
 
    integer  :: istep
    integer  :: istep_max
 
    logical(c_bool) :: suppress
    character(len=FILE_HMID) :: tu
 
    intrinsic size
    !---------------------------------------------------------------------------
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_get_all_dataInfo_fid",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    ! initialize
    description   = ""
    units         = ""
    standard_name = ""
    datatype      = -1
    dim_rank      = -1
    dim_name(:) = ""
    dim_size(:) = -1
    time_start(:) = file_rmiss
    time_end(:) = file_rmiss
 
    suppress = .true.
    istep_max = min( size(time_start), size(time_end) )
    do istep = 1, istep_max
       !--- get data information
       error = file_get_datainfo_c( dinfo,               & ! [OUT]
                                    file_files(fid)%fid, & ! [IN]
                                    cstr(varname),       & ! [IN]
                                    istep, suppress      ) ! [IN]
 
       !--- verify and exit
       if ( error /= file_success_code ) then
          step_nmax = istep - 1
          exit
       endif
 
       if ( istep == 1 ) then
          call fstr(description, dinfo%description)
          call fstr(units, dinfo%units)
          call fstr(standard_name, dinfo%standard_name)
          datatype      = dinfo%datatype
          dim_rank      = dinfo%rank
          natts         = dinfo%natts
 
          do i = 1, min( dinfo%rank, size(dim_name) ) ! limit dimension rank
             call fstr(dim_name(i), dinfo%dim_name(:,i))
             dim_size(i) = dinfo%dim_size(i)
          enddo
 
          do i = 1, min( dinfo%natts, size(att_name) )
             call fstr(att_name(i), dinfo%att_name(:,i))
             att_type(i) = dinfo%att_type(i)
             att_len(i) = dinfo%att_len (i)
          end do
 
          call fstr(tu, dinfo%time_units)
          if ( tu == "" ) then
             call file_get_attribute( fid, "global", "time_units", time_units )
             call file_get_attribute( fid, "global", "calendar", calendar, existed )
             if ( .not. existed ) calendar = ""
             call file_get_attribute( fid, "global", "time_start", time )
             time_start(1) = time(1)
             time_end(1) = time(1)
             step_nmax = 1
             exit
          else
             time_units    = tu
             time_start(1) = dinfo%time_start
             time_end(1) = dinfo%time_end
             call fstr(calendar, dinfo%calendar)
          endif
       else
          time_start(istep) = dinfo%time_start
          time_end(istep) = dinfo%time_end
       endif
    enddo
 
    if ( istep == istep_max + 1 ) then
       if ( error /= file_success_code ) then
          log_error("FILE_get_all_dataInfo_fid",*) 'size of time is not enough: ', istep_max
          call prc_abort
       else
          step_nmax = istep - 1
       end if
    end if
 
    call prof_rapend  ('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_get_all_datainfo_fid
 
  !-----------------------------------------------------------------------------
  ! interface FILE_read
  !-----------------------------------------------------------------------------
  subroutine file_read_realsp_1d( &
      basename, varname,             &
      var,                           &
      step, rankid, single, postfix, &
      allow_missing, missing_value   )
    implicit none
 
    character(len=*), intent( in)           :: basename
    character(len=*), intent( in)           :: varname
    real(sp),    intent(out)           :: var(:)
    integer,          intent( in), optional :: step
    integer,          intent( in), optional :: rankid
    logical,          intent( in), optional :: single
    character(len=*), intent( in), optional :: postfix
    logical,          intent( in), optional :: allow_missing
    real(sp),    intent( in), optional :: missing_value
 
    integer :: fid
 
    intrinsic shape
    !---------------------------------------------------------------------------
 
    !--- search/register file
    call file_open( basename,                     & ! (in)
                    fid,                          & ! (out)
                    rankid=rankid, single=single, & ! (in)
                    postfix=postfix               ) ! (in)
 
    call file_read_var_realsp_1d( &
         fid, varname,                                            & ! (in)
         var(:),                                           & ! (out)
         step=step,                                               & ! (in)
         allow_missing=allow_missing, missing_value=missing_value ) ! (in)
 
    return
  end subroutine file_read_realsp_1d
  subroutine file_read_realdp_1d( &
      basename, varname,             &
      var,                           &
      step, rankid, single, postfix, &
      allow_missing, missing_value   )
    implicit none
 
    character(len=*), intent( in)           :: basename
    character(len=*), intent( in)           :: varname
    real(dp),    intent(out)           :: var(:)
    integer,          intent( in), optional :: step
    integer,          intent( in), optional :: rankid
    logical,          intent( in), optional :: single
    character(len=*), intent( in), optional :: postfix
    logical,          intent( in), optional :: allow_missing
    real(dp),    intent( in), optional :: missing_value
 
    integer :: fid
 
    intrinsic shape
    !---------------------------------------------------------------------------
 
    !--- search/register file
    call file_open( basename,                     & ! (in)
                    fid,                          & ! (out)
                    rankid=rankid, single=single, & ! (in)
                    postfix=postfix               ) ! (in)
 
    call file_read_var_realdp_1d( &
         fid, varname,                                            & ! (in)
         var(:),                                           & ! (out)
         step=step,                                               & ! (in)
         allow_missing=allow_missing, missing_value=missing_value ) ! (in)
 
    return
  end subroutine file_read_realdp_1d
  subroutine file_read_realsp_2d( &
      basename, varname,             &
      var,                           &
      step, rankid, single, postfix, &
      allow_missing, missing_value   )
    implicit none
 
    character(len=*), intent( in)           :: basename
    character(len=*), intent( in)           :: varname
    real(sp),    intent(out)           :: var(:,:)
    integer,          intent( in), optional :: step
    integer,          intent( in), optional :: rankid
    logical,          intent( in), optional :: single
    character(len=*), intent( in), optional :: postfix
    logical,          intent( in), optional :: allow_missing
    real(sp),    intent( in), optional :: missing_value
 
    integer :: fid
 
    intrinsic shape
    !---------------------------------------------------------------------------
 
    !--- search/register file
    call file_open( basename,                     & ! (in)
                    fid,                          & ! (out)
                    rankid=rankid, single=single, & ! (in)
                    postfix=postfix               ) ! (in)
 
    call file_read_var_realsp_2d( &
         fid, varname,                                            & ! (in)
         var(:,:),                                           & ! (out)
         step=step,                                               & ! (in)
         allow_missing=allow_missing, missing_value=missing_value ) ! (in)
 
    return
  end subroutine file_read_realsp_2d
  subroutine file_read_realdp_2d( &
      basename, varname,             &
      var,                           &
      step, rankid, single, postfix, &
      allow_missing, missing_value   )
    implicit none
 
    character(len=*), intent( in)           :: basename
    character(len=*), intent( in)           :: varname
    real(dp),    intent(out)           :: var(:,:)
    integer,          intent( in), optional :: step
    integer,          intent( in), optional :: rankid
    logical,          intent( in), optional :: single
    character(len=*), intent( in), optional :: postfix
    logical,          intent( in), optional :: allow_missing
    real(dp),    intent( in), optional :: missing_value
 
    integer :: fid
 
    intrinsic shape
    !---------------------------------------------------------------------------
 
    !--- search/register file
    call file_open( basename,                     & ! (in)
                    fid,                          & ! (out)
                    rankid=rankid, single=single, & ! (in)
                    postfix=postfix               ) ! (in)
 
    call file_read_var_realdp_2d( &
         fid, varname,                                            & ! (in)
         var(:,:),                                           & ! (out)
         step=step,                                               & ! (in)
         allow_missing=allow_missing, missing_value=missing_value ) ! (in)
 
    return
  end subroutine file_read_realdp_2d
  subroutine file_read_realsp_3d( &
      basename, varname,             &
      var,                           &
      step, rankid, single, postfix, &
      allow_missing, missing_value   )
    implicit none
 
    character(len=*), intent( in)           :: basename
    character(len=*), intent( in)           :: varname
    real(sp),    intent(out)           :: var(:,:,:)
    integer,          intent( in), optional :: step
    integer,          intent( in), optional :: rankid
    logical,          intent( in), optional :: single
    character(len=*), intent( in), optional :: postfix
    logical,          intent( in), optional :: allow_missing
    real(sp),    intent( in), optional :: missing_value
 
    integer :: fid
 
    intrinsic shape
    !---------------------------------------------------------------------------
 
    !--- search/register file
    call file_open( basename,                     & ! (in)
                    fid,                          & ! (out)
                    rankid=rankid, single=single, & ! (in)
                    postfix=postfix               ) ! (in)
 
    call file_read_var_realsp_3d( &
         fid, varname,                                            & ! (in)
         var(:,:,:),                                           & ! (out)
         step=step,                                               & ! (in)
         allow_missing=allow_missing, missing_value=missing_value ) ! (in)
 
    return
  end subroutine file_read_realsp_3d
  subroutine file_read_realdp_3d( &
      basename, varname,             &
      var,                           &
      step, rankid, single, postfix, &
      allow_missing, missing_value   )
    implicit none
 
    character(len=*), intent( in)           :: basename
    character(len=*), intent( in)           :: varname
    real(dp),    intent(out)           :: var(:,:,:)
    integer,          intent( in), optional :: step
    integer,          intent( in), optional :: rankid
    logical,          intent( in), optional :: single
    character(len=*), intent( in), optional :: postfix
    logical,          intent( in), optional :: allow_missing
    real(dp),    intent( in), optional :: missing_value
 
    integer :: fid
 
    intrinsic shape
    !---------------------------------------------------------------------------
 
    !--- search/register file
    call file_open( basename,                     & ! (in)
                    fid,                          & ! (out)
                    rankid=rankid, single=single, & ! (in)
                    postfix=postfix               ) ! (in)
 
    call file_read_var_realdp_3d( &
         fid, varname,                                            & ! (in)
         var(:,:,:),                                           & ! (out)
         step=step,                                               & ! (in)
         allow_missing=allow_missing, missing_value=missing_value ) ! (in)
 
    return
  end subroutine file_read_realdp_3d
  subroutine file_read_realsp_4d( &
      basename, varname,             &
      var,                           &
      step, rankid, single, postfix, &
      allow_missing, missing_value   )
    implicit none
 
    character(len=*), intent( in)           :: basename
    character(len=*), intent( in)           :: varname
    real(sp),    intent(out)           :: var(:,:,:,:)
    integer,          intent( in), optional :: step
    integer,          intent( in), optional :: rankid
    logical,          intent( in), optional :: single
    character(len=*), intent( in), optional :: postfix
    logical,          intent( in), optional :: allow_missing
    real(sp),    intent( in), optional :: missing_value
 
    integer :: fid
 
    intrinsic shape
    !---------------------------------------------------------------------------
 
    !--- search/register file
    call file_open( basename,                     & ! (in)
                    fid,                          & ! (out)
                    rankid=rankid, single=single, & ! (in)
                    postfix=postfix               ) ! (in)
 
    call file_read_var_realsp_4d( &
         fid, varname,                                            & ! (in)
         var(:,:,:,:),                                           & ! (out)
         step=step,                                               & ! (in)
         allow_missing=allow_missing, missing_value=missing_value ) ! (in)
 
    return
  end subroutine file_read_realsp_4d
  subroutine file_read_realdp_4d( &
      basename, varname,             &
      var,                           &
      step, rankid, single, postfix, &
      allow_missing, missing_value   )
    implicit none
 
    character(len=*), intent( in)           :: basename
    character(len=*), intent( in)           :: varname
    real(dp),    intent(out)           :: var(:,:,:,:)
    integer,          intent( in), optional :: step
    integer,          intent( in), optional :: rankid
    logical,          intent( in), optional :: single
    character(len=*), intent( in), optional :: postfix
    logical,          intent( in), optional :: allow_missing
    real(dp),    intent( in), optional :: missing_value
 
    integer :: fid
 
    intrinsic shape
    !---------------------------------------------------------------------------
 
    !--- search/register file
    call file_open( basename,                     & ! (in)
                    fid,                          & ! (out)
                    rankid=rankid, single=single, & ! (in)
                    postfix=postfix               ) ! (in)
 
    call file_read_var_realdp_4d( &
         fid, varname,                                            & ! (in)
         var(:,:,:,:),                                           & ! (out)
         step=step,                                               & ! (in)
         allow_missing=allow_missing, missing_value=missing_value ) ! (in)
 
    return
  end subroutine file_read_realdp_4d
 
  subroutine file_read_var_realsp_1d( &
      fid, varname,  &
      var,           &
      step,          &
      allow_missing, &
      missing_value, &
      ntypes, dtype, &
      start, count   )
    implicit none
 
    integer,          intent( in)           :: fid
    character(len=*), intent( in)           :: varname
#ifdef NVIDIA
    real(sp),    intent(out), target :: var(:)
#else
    real(sp),    intent(out), target, contiguous :: var(:)
#endif
    integer,          intent( in), optional :: step
    logical,          intent( in), optional :: allow_missing
    real(sp),    intent( in), optional :: missing_value
    integer,          intent( in), optional :: ntypes
    integer,          intent( in), optional :: dtype
    integer,          intent( in), optional :: start(:)
    integer,          intent( in), optional :: count(:)
 
    integer :: step_
    logical(c_bool) :: allow_missing_
    real(sp) :: missing_value_
 
    type(datainfo) :: dinfo
    integer :: dim_size(1)
 
    integer :: error
    integer :: n
 
    intrinsic size, shape
    !---------------------------------------------------------------------------
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_read_var_realSP_1D",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    if ( present(step) ) then
       step_ = step
    else
       step_ = 1
    end if
 
    if ( present(allow_missing) ) then
       allow_missing_ = allow_missing
    else
       allow_missing_ = .false.
    end if
 
    if ( present(missing_value) ) then
       missing_value_ = missing_value
    else
       missing_value_ = 0.0_sp
    end if
 
    !--- get data information
    error = file_get_datainfo_c( dinfo,                & ! (out)
                                 file_files(fid)%fid,  & ! (in)
                                 cstr(varname),        & ! (in)
                                 step_, allow_missing_ ) ! (in)
 
    !--- verify
    if ( error /= file_success_code ) then
       if ( allow_missing_ ) then
          log_info("FILE_read_var_realSP_1D",*) '[INPUT]/[FILE] data not found! : ', &
               'varname= ',trim(varname),', step=',step_
          log_info("FILE_read_var_realSP_1D",*) '[INPUT]/[FILE] Value is set to ', missing_value_
          var(:) = missing_value_
          return
       else
          log_error("FILE_read_var_realSP_1D",*) 'failed to get data information :'//trim(varname)
          call prc_abort
       end if
    end if
 
    if ( dinfo%rank /= 1 ) then
       if ( (.not. present(start)) .and. (.not. present(count)) ) then
          log_error("FILE_read_var_realSP_1D",*) 'rank of '//trim(varname)//' is not 1', dinfo%rank
          call prc_abort
       end if
    end if
 
    if ( present(ntypes) ) then
#if defined(__GFORTRAN__) && __GNUC__ < 7
       error = file_read_data_c( cloc(var(1)),                  & ! (out)
#else
       error = file_read_data_c( c_loc(var),                  & ! (out)
#endif
            dinfo, sp, ntypes, dtype, start(:), count(:) ) ! (in)
    else if ( present(start) .and. present(count) ) then
#ifdef NVIDIA
       block
       real(sp), allocatable, target :: work(:)
       allocate(work, mold=var)
#endif
       error = file_read_data_c( &
#if defined(__GFORTRAN__) && __GNUC__ < 7
            cloc(var(1)), & ! (out)
#elif defined(NVIDIA)
            c_loc(work), & ! (out)
#else
            c_loc(var), & ! (out)
#endif
            dinfo, sp, 0, 0, start(:), count(:) ) ! (in)
#ifdef NVIDIA
       var = work
       end block
#endif
    else
       dim_size(:) = shape(var)
       do n = 1, 1
          if ( dinfo%dim_size(n) /= dim_size(n) ) then
             log_error("FILE_read_var_realSP_1D",*) 'shape is different: ', trim(varname), n, dinfo%dim_size(n), dim_size(n)
             call prc_abort
          end if
       end do
#ifdef NVIDIA
       block
       real(sp), allocatable, target :: work(:)
       allocate(work, mold=var)
#endif
       error = file_read_data_c( &
#if defined(__GFORTRAN__) && __GNUC__ < 7
            cloc(var(1)), & ! (out)
#elif defined(NVIDIA)
            c_loc(work), & ! (out)
#else
            c_loc(var), & ! (out)
#endif
            dinfo, sp, 0, 0, (/0/), (/0/) ) ! (in)
#ifdef NVIDIA
       var = work
       end block
#endif
    end if
    if ( error /= file_success_code ) then
       log_error("FILE_read_var_realSP_1D",*) 'failed to get data value: ', trim(varname)
       call prc_abort
    end if
 
    !$acc update device(var) if(acc_is_present(var))
 
    call prof_rapend  ('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_read_var_realsp_1d
  subroutine file_read_var_realdp_1d( &
      fid, varname,  &
      var,           &
      step,          &
      allow_missing, &
      missing_value, &
      ntypes, dtype, &
      start, count   )
    implicit none
 
    integer,          intent( in)           :: fid
    character(len=*), intent( in)           :: varname
#ifdef NVIDIA
    real(dp),    intent(out), target :: var(:)
#else
    real(dp),    intent(out), target, contiguous :: var(:)
#endif
    integer,          intent( in), optional :: step
    logical,          intent( in), optional :: allow_missing
    real(dp),    intent( in), optional :: missing_value
    integer,          intent( in), optional :: ntypes
    integer,          intent( in), optional :: dtype
    integer,          intent( in), optional :: start(:)
    integer,          intent( in), optional :: count(:)
 
    integer :: step_
    logical(c_bool) :: allow_missing_
    real(dp) :: missing_value_
 
    type(datainfo) :: dinfo
    integer :: dim_size(1)
 
    integer :: error
    integer :: n
 
    intrinsic size, shape
    !---------------------------------------------------------------------------
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_read_var_realDP_1D",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    if ( present(step) ) then
       step_ = step
    else
       step_ = 1
    end if
 
    if ( present(allow_missing) ) then
       allow_missing_ = allow_missing
    else
       allow_missing_ = .false.
    end if
 
    if ( present(missing_value) ) then
       missing_value_ = missing_value
    else
       missing_value_ = 0.0_dp
    end if
 
    !--- get data information
    error = file_get_datainfo_c( dinfo,                & ! (out)
                                 file_files(fid)%fid,  & ! (in)
                                 cstr(varname),        & ! (in)
                                 step_, allow_missing_ ) ! (in)
 
    !--- verify
    if ( error /= file_success_code ) then
       if ( allow_missing_ ) then
          log_info("FILE_read_var_realDP_1D",*) '[INPUT]/[FILE] data not found! : ', &
               'varname= ',trim(varname),', step=',step_
          log_info("FILE_read_var_realDP_1D",*) '[INPUT]/[FILE] Value is set to ', missing_value_
          var(:) = missing_value_
          return
       else
          log_error("FILE_read_var_realDP_1D",*) 'failed to get data information :'//trim(varname)
          call prc_abort
       end if
    end if
 
    if ( dinfo%rank /= 1 ) then
       if ( (.not. present(start)) .and. (.not. present(count)) ) then
          log_error("FILE_read_var_realDP_1D",*) 'rank of '//trim(varname)//' is not 1', dinfo%rank
          call prc_abort
       end if
    end if
 
    if ( present(ntypes) ) then
#if defined(__GFORTRAN__) && __GNUC__ < 7
       error = file_read_data_c( cloc(var(1)),                  & ! (out)
#else
       error = file_read_data_c( c_loc(var),                  & ! (out)
#endif
            dinfo, dp, ntypes, dtype, start(:), count(:) ) ! (in)
    else if ( present(start) .and. present(count) ) then
#ifdef NVIDIA
       block
       real(dp), allocatable, target :: work(:)
       allocate(work, mold=var)
#endif
       error = file_read_data_c( &
#if defined(__GFORTRAN__) && __GNUC__ < 7
            cloc(var(1)), & ! (out)
#elif defined(NVIDIA)
            c_loc(work), & ! (out)
#else
            c_loc(var), & ! (out)
#endif
            dinfo, dp, 0, 0, start(:), count(:) ) ! (in)
#ifdef NVIDIA
       var = work
       end block
#endif
    else
       dim_size(:) = shape(var)
       do n = 1, 1
          if ( dinfo%dim_size(n) /= dim_size(n) ) then
             log_error("FILE_read_var_realDP_1D",*) 'shape is different: ', trim(varname), n, dinfo%dim_size(n), dim_size(n)
             call prc_abort
          end if
       end do
#ifdef NVIDIA
       block
       real(dp), allocatable, target :: work(:)
       allocate(work, mold=var)
#endif
       error = file_read_data_c( &
#if defined(__GFORTRAN__) && __GNUC__ < 7
            cloc(var(1)), & ! (out)
#elif defined(NVIDIA)
            c_loc(work), & ! (out)
#else
            c_loc(var), & ! (out)
#endif
            dinfo, dp, 0, 0, (/0/), (/0/) ) ! (in)
#ifdef NVIDIA
       var = work
       end block
#endif
    end if
    if ( error /= file_success_code ) then
       log_error("FILE_read_var_realDP_1D",*) 'failed to get data value: ', trim(varname)
       call prc_abort
    end if
 
    !$acc update device(var) if(acc_is_present(var))
 
    call prof_rapend  ('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_read_var_realdp_1d
  subroutine file_read_var_realsp_2d( &
      fid, varname,  &
      var,           &
      step,          &
      allow_missing, &
      missing_value, &
      ntypes, dtype, &
      start, count   )
    implicit none
 
    integer,          intent( in)           :: fid
    character(len=*), intent( in)           :: varname
#ifdef NVIDIA
    real(sp),    intent(out), target :: var(:,:)
#else
    real(sp),    intent(out), target, contiguous :: var(:,:)
#endif
    integer,          intent( in), optional :: step
    logical,          intent( in), optional :: allow_missing
    real(sp),    intent( in), optional :: missing_value
    integer,          intent( in), optional :: ntypes
    integer,          intent( in), optional :: dtype
    integer,          intent( in), optional :: start(:)
    integer,          intent( in), optional :: count(:)
 
    integer :: step_
    logical(c_bool) :: allow_missing_
    real(sp) :: missing_value_
 
    type(datainfo) :: dinfo
    integer :: dim_size(2)
 
    integer :: error
    integer :: n
 
    intrinsic size, shape
    !---------------------------------------------------------------------------
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_read_var_realSP_2D",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    if ( present(step) ) then
       step_ = step
    else
       step_ = 1
    end if
 
    if ( present(allow_missing) ) then
       allow_missing_ = allow_missing
    else
       allow_missing_ = .false.
    end if
 
    if ( present(missing_value) ) then
       missing_value_ = missing_value
    else
       missing_value_ = 0.0_sp
    end if
 
    !--- get data information
    error = file_get_datainfo_c( dinfo,                & ! (out)
                                 file_files(fid)%fid,  & ! (in)
                                 cstr(varname),        & ! (in)
                                 step_, allow_missing_ ) ! (in)
 
    !--- verify
    if ( error /= file_success_code ) then
       if ( allow_missing_ ) then
          log_info("FILE_read_var_realSP_2D",*) '[INPUT]/[FILE] data not found! : ', &
               'varname= ',trim(varname),', step=',step_
          log_info("FILE_read_var_realSP_2D",*) '[INPUT]/[FILE] Value is set to ', missing_value_
          var(:,:) = missing_value_
          return
       else
          log_error("FILE_read_var_realSP_2D",*) 'failed to get data information :'//trim(varname)
          call prc_abort
       end if
    end if
 
    if ( dinfo%rank /= 2 ) then
       if ( (.not. present(start)) .and. (.not. present(count)) ) then
          log_error("FILE_read_var_realSP_2D",*) 'rank of '//trim(varname)//' is not 2', dinfo%rank
          call prc_abort
       end if
    end if
 
    if ( present(ntypes) ) then
#if defined(__GFORTRAN__) && __GNUC__ < 7
       error = file_read_data_c( cloc(var(1,1)),                  & ! (out)
#else
       error = file_read_data_c( c_loc(var),                  & ! (out)
#endif
            dinfo, sp, ntypes, dtype, start(:), count(:) ) ! (in)
    else if ( present(start) .and. present(count) ) then
#ifdef NVIDIA
       block
       real(sp), allocatable, target :: work(:,:)
       allocate(work, mold=var)
#endif
       error = file_read_data_c( &
#if defined(__GFORTRAN__) && __GNUC__ < 7
            cloc(var(1,1)), & ! (out)
#elif defined(NVIDIA)
            c_loc(work), & ! (out)
#else
            c_loc(var), & ! (out)
#endif
            dinfo, sp, 0, 0, start(:), count(:) ) ! (in)
#ifdef NVIDIA
       var = work
       end block
#endif
    else
       dim_size(:) = shape(var)
       do n = 1, 2
          if ( dinfo%dim_size(n) /= dim_size(n) ) then
             log_error("FILE_read_var_realSP_2D",*) 'shape is different: ', trim(varname), n, dinfo%dim_size(n), dim_size(n)
             call prc_abort
          end if
       end do
#ifdef NVIDIA
       block
       real(sp), allocatable, target :: work(:,:)
       allocate(work, mold=var)
#endif
       error = file_read_data_c( &
#if defined(__GFORTRAN__) && __GNUC__ < 7
            cloc(var(1,1)), & ! (out)
#elif defined(NVIDIA)
            c_loc(work), & ! (out)
#else
            c_loc(var), & ! (out)
#endif
            dinfo, sp, 0, 0, (/0/), (/0/) ) ! (in)
#ifdef NVIDIA
       var = work
       end block
#endif
    end if
    if ( error /= file_success_code ) then
       log_error("FILE_read_var_realSP_2D",*) 'failed to get data value: ', trim(varname)
       call prc_abort
    end if
 
    !$acc update device(var) if(acc_is_present(var))
 
    call prof_rapend  ('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_read_var_realsp_2d
  subroutine file_read_var_realdp_2d( &
      fid, varname,  &
      var,           &
      step,          &
      allow_missing, &
      missing_value, &
      ntypes, dtype, &
      start, count   )
    implicit none
 
    integer,          intent( in)           :: fid
    character(len=*), intent( in)           :: varname
#ifdef NVIDIA
    real(dp),    intent(out), target :: var(:,:)
#else
    real(dp),    intent(out), target, contiguous :: var(:,:)
#endif
    integer,          intent( in), optional :: step
    logical,          intent( in), optional :: allow_missing
    real(dp),    intent( in), optional :: missing_value
    integer,          intent( in), optional :: ntypes
    integer,          intent( in), optional :: dtype
    integer,          intent( in), optional :: start(:)
    integer,          intent( in), optional :: count(:)
 
    integer :: step_
    logical(c_bool) :: allow_missing_
    real(dp) :: missing_value_
 
    type(datainfo) :: dinfo
    integer :: dim_size(2)
 
    integer :: error
    integer :: n
 
    intrinsic size, shape
    !---------------------------------------------------------------------------
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_read_var_realDP_2D",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    if ( present(step) ) then
       step_ = step
    else
       step_ = 1
    end if
 
    if ( present(allow_missing) ) then
       allow_missing_ = allow_missing
    else
       allow_missing_ = .false.
    end if
 
    if ( present(missing_value) ) then
       missing_value_ = missing_value
    else
       missing_value_ = 0.0_dp
    end if
 
    !--- get data information
    error = file_get_datainfo_c( dinfo,                & ! (out)
                                 file_files(fid)%fid,  & ! (in)
                                 cstr(varname),        & ! (in)
                                 step_, allow_missing_ ) ! (in)
 
    !--- verify
    if ( error /= file_success_code ) then
       if ( allow_missing_ ) then
          log_info("FILE_read_var_realDP_2D",*) '[INPUT]/[FILE] data not found! : ', &
               'varname= ',trim(varname),', step=',step_
          log_info("FILE_read_var_realDP_2D",*) '[INPUT]/[FILE] Value is set to ', missing_value_
          var(:,:) = missing_value_
          return
       else
          log_error("FILE_read_var_realDP_2D",*) 'failed to get data information :'//trim(varname)
          call prc_abort
       end if
    end if
 
    if ( dinfo%rank /= 2 ) then
       if ( (.not. present(start)) .and. (.not. present(count)) ) then
          log_error("FILE_read_var_realDP_2D",*) 'rank of '//trim(varname)//' is not 2', dinfo%rank
          call prc_abort
       end if
    end if
 
    if ( present(ntypes) ) then
#if defined(__GFORTRAN__) && __GNUC__ < 7
       error = file_read_data_c( cloc(var(1,1)),                  & ! (out)
#else
       error = file_read_data_c( c_loc(var),                  & ! (out)
#endif
            dinfo, dp, ntypes, dtype, start(:), count(:) ) ! (in)
    else if ( present(start) .and. present(count) ) then
#ifdef NVIDIA
       block
       real(dp), allocatable, target :: work(:,:)
       allocate(work, mold=var)
#endif
       error = file_read_data_c( &
#if defined(__GFORTRAN__) && __GNUC__ < 7
            cloc(var(1,1)), & ! (out)
#elif defined(NVIDIA)
            c_loc(work), & ! (out)
#else
            c_loc(var), & ! (out)
#endif
            dinfo, dp, 0, 0, start(:), count(:) ) ! (in)
#ifdef NVIDIA
       var = work
       end block
#endif
    else
       dim_size(:) = shape(var)
       do n = 1, 2
          if ( dinfo%dim_size(n) /= dim_size(n) ) then
             log_error("FILE_read_var_realDP_2D",*) 'shape is different: ', trim(varname), n, dinfo%dim_size(n), dim_size(n)
             call prc_abort
          end if
       end do
#ifdef NVIDIA
       block
       real(dp), allocatable, target :: work(:,:)
       allocate(work, mold=var)
#endif
       error = file_read_data_c( &
#if defined(__GFORTRAN__) && __GNUC__ < 7
            cloc(var(1,1)), & ! (out)
#elif defined(NVIDIA)
            c_loc(work), & ! (out)
#else
            c_loc(var), & ! (out)
#endif
            dinfo, dp, 0, 0, (/0/), (/0/) ) ! (in)
#ifdef NVIDIA
       var = work
       end block
#endif
    end if
    if ( error /= file_success_code ) then
       log_error("FILE_read_var_realDP_2D",*) 'failed to get data value: ', trim(varname)
       call prc_abort
    end if
 
    !$acc update device(var) if(acc_is_present(var))
 
    call prof_rapend  ('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_read_var_realdp_2d
  subroutine file_read_var_realsp_3d( &
      fid, varname,  &
      var,           &
      step,          &
      allow_missing, &
      missing_value, &
      ntypes, dtype, &
      start, count   )
    implicit none
 
    integer,          intent( in)           :: fid
    character(len=*), intent( in)           :: varname
#ifdef NVIDIA
    real(sp),    intent(out), target :: var(:,:,:)
#else
    real(sp),    intent(out), target, contiguous :: var(:,:,:)
#endif
    integer,          intent( in), optional :: step
    logical,          intent( in), optional :: allow_missing
    real(sp),    intent( in), optional :: missing_value
    integer,          intent( in), optional :: ntypes
    integer,          intent( in), optional :: dtype
    integer,          intent( in), optional :: start(:)
    integer,          intent( in), optional :: count(:)
 
    integer :: step_
    logical(c_bool) :: allow_missing_
    real(sp) :: missing_value_
 
    type(datainfo) :: dinfo
    integer :: dim_size(3)
 
    integer :: error
    integer :: n
 
    intrinsic size, shape
    !---------------------------------------------------------------------------
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_read_var_realSP_3D",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    if ( present(step) ) then
       step_ = step
    else
       step_ = 1
    end if
 
    if ( present(allow_missing) ) then
       allow_missing_ = allow_missing
    else
       allow_missing_ = .false.
    end if
 
    if ( present(missing_value) ) then
       missing_value_ = missing_value
    else
       missing_value_ = 0.0_sp
    end if
 
    !--- get data information
    error = file_get_datainfo_c( dinfo,                & ! (out)
                                 file_files(fid)%fid,  & ! (in)
                                 cstr(varname),        & ! (in)
                                 step_, allow_missing_ ) ! (in)
 
    !--- verify
    if ( error /= file_success_code ) then
       if ( allow_missing_ ) then
          log_info("FILE_read_var_realSP_3D",*) '[INPUT]/[FILE] data not found! : ', &
               'varname= ',trim(varname),', step=',step_
          log_info("FILE_read_var_realSP_3D",*) '[INPUT]/[FILE] Value is set to ', missing_value_
          var(:,:,:) = missing_value_
          return
       else
          log_error("FILE_read_var_realSP_3D",*) 'failed to get data information :'//trim(varname)
          call prc_abort
       end if
    end if
 
    if ( dinfo%rank /= 3 ) then
       if ( (.not. present(start)) .and. (.not. present(count)) ) then
          log_error("FILE_read_var_realSP_3D",*) 'rank of '//trim(varname)//' is not 3', dinfo%rank
          call prc_abort
       end if
    end if
 
    if ( present(ntypes) ) then
#if defined(__GFORTRAN__) && __GNUC__ < 7
       error = file_read_data_c( cloc(var(1,1,1)),                  & ! (out)
#else
       error = file_read_data_c( c_loc(var),                  & ! (out)
#endif
            dinfo, sp, ntypes, dtype, start(:), count(:) ) ! (in)
    else if ( present(start) .and. present(count) ) then
#ifdef NVIDIA
       block
       real(sp), allocatable, target :: work(:,:,:)
       allocate(work, mold=var)
#endif
       error = file_read_data_c( &
#if defined(__GFORTRAN__) && __GNUC__ < 7
            cloc(var(1,1,1)), & ! (out)
#elif defined(NVIDIA)
            c_loc(work), & ! (out)
#else
            c_loc(var), & ! (out)
#endif
            dinfo, sp, 0, 0, start(:), count(:) ) ! (in)
#ifdef NVIDIA
       var = work
       end block
#endif
    else
       dim_size(:) = shape(var)
       do n = 1, 3
          if ( dinfo%dim_size(n) /= dim_size(n) ) then
             log_error("FILE_read_var_realSP_3D",*) 'shape is different: ', trim(varname), n, dinfo%dim_size(n), dim_size(n)
             call prc_abort
          end if
       end do
#ifdef NVIDIA
       block
       real(sp), allocatable, target :: work(:,:,:)
       allocate(work, mold=var)
#endif
       error = file_read_data_c( &
#if defined(__GFORTRAN__) && __GNUC__ < 7
            cloc(var(1,1,1)), & ! (out)
#elif defined(NVIDIA)
            c_loc(work), & ! (out)
#else
            c_loc(var), & ! (out)
#endif
            dinfo, sp, 0, 0, (/0/), (/0/) ) ! (in)
#ifdef NVIDIA
       var = work
       end block
#endif
    end if
    if ( error /= file_success_code ) then
       log_error("FILE_read_var_realSP_3D",*) 'failed to get data value: ', trim(varname)
       call prc_abort
    end if
 
    !$acc update device(var) if(acc_is_present(var))
 
    call prof_rapend  ('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_read_var_realsp_3d
  subroutine file_read_var_realdp_3d( &
      fid, varname,  &
      var,           &
      step,          &
      allow_missing, &
      missing_value, &
      ntypes, dtype, &
      start, count   )
    implicit none
 
    integer,          intent( in)           :: fid
    character(len=*), intent( in)           :: varname
#ifdef NVIDIA
    real(dp),    intent(out), target :: var(:,:,:)
#else
    real(dp),    intent(out), target, contiguous :: var(:,:,:)
#endif
    integer,          intent( in), optional :: step
    logical,          intent( in), optional :: allow_missing
    real(dp),    intent( in), optional :: missing_value
    integer,          intent( in), optional :: ntypes
    integer,          intent( in), optional :: dtype
    integer,          intent( in), optional :: start(:)
    integer,          intent( in), optional :: count(:)
 
    integer :: step_
    logical(c_bool) :: allow_missing_
    real(dp) :: missing_value_
 
    type(datainfo) :: dinfo
    integer :: dim_size(3)
 
    integer :: error
    integer :: n
 
    intrinsic size, shape
    !---------------------------------------------------------------------------
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_read_var_realDP_3D",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    if ( present(step) ) then
       step_ = step
    else
       step_ = 1
    end if
 
    if ( present(allow_missing) ) then
       allow_missing_ = allow_missing
    else
       allow_missing_ = .false.
    end if
 
    if ( present(missing_value) ) then
       missing_value_ = missing_value
    else
       missing_value_ = 0.0_dp
    end if
 
    !--- get data information
    error = file_get_datainfo_c( dinfo,                & ! (out)
                                 file_files(fid)%fid,  & ! (in)
                                 cstr(varname),        & ! (in)
                                 step_, allow_missing_ ) ! (in)
 
    !--- verify
    if ( error /= file_success_code ) then
       if ( allow_missing_ ) then
          log_info("FILE_read_var_realDP_3D",*) '[INPUT]/[FILE] data not found! : ', &
               'varname= ',trim(varname),', step=',step_
          log_info("FILE_read_var_realDP_3D",*) '[INPUT]/[FILE] Value is set to ', missing_value_
          var(:,:,:) = missing_value_
          return
       else
          log_error("FILE_read_var_realDP_3D",*) 'failed to get data information :'//trim(varname)
          call prc_abort
       end if
    end if
 
    if ( dinfo%rank /= 3 ) then
       if ( (.not. present(start)) .and. (.not. present(count)) ) then
          log_error("FILE_read_var_realDP_3D",*) 'rank of '//trim(varname)//' is not 3', dinfo%rank
          call prc_abort
       end if
    end if
 
    if ( present(ntypes) ) then
#if defined(__GFORTRAN__) && __GNUC__ < 7
       error = file_read_data_c( cloc(var(1,1,1)),                  & ! (out)
#else
       error = file_read_data_c( c_loc(var),                  & ! (out)
#endif
            dinfo, dp, ntypes, dtype, start(:), count(:) ) ! (in)
    else if ( present(start) .and. present(count) ) then
#ifdef NVIDIA
       block
       real(dp), allocatable, target :: work(:,:,:)
       allocate(work, mold=var)
#endif
       error = file_read_data_c( &
#if defined(__GFORTRAN__) && __GNUC__ < 7
            cloc(var(1,1,1)), & ! (out)
#elif defined(NVIDIA)
            c_loc(work), & ! (out)
#else
            c_loc(var), & ! (out)
#endif
            dinfo, dp, 0, 0, start(:), count(:) ) ! (in)
#ifdef NVIDIA
       var = work
       end block
#endif
    else
       dim_size(:) = shape(var)
       do n = 1, 3
          if ( dinfo%dim_size(n) /= dim_size(n) ) then
             log_error("FILE_read_var_realDP_3D",*) 'shape is different: ', trim(varname), n, dinfo%dim_size(n), dim_size(n)
             call prc_abort
          end if
       end do
#ifdef NVIDIA
       block
       real(dp), allocatable, target :: work(:,:,:)
       allocate(work, mold=var)
#endif
       error = file_read_data_c( &
#if defined(__GFORTRAN__) && __GNUC__ < 7
            cloc(var(1,1,1)), & ! (out)
#elif defined(NVIDIA)
            c_loc(work), & ! (out)
#else
            c_loc(var), & ! (out)
#endif
            dinfo, dp, 0, 0, (/0/), (/0/) ) ! (in)
#ifdef NVIDIA
       var = work
       end block
#endif
    end if
    if ( error /= file_success_code ) then
       log_error("FILE_read_var_realDP_3D",*) 'failed to get data value: ', trim(varname)
       call prc_abort
    end if
 
    !$acc update device(var) if(acc_is_present(var))
 
    call prof_rapend  ('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_read_var_realdp_3d
  subroutine file_read_var_realsp_4d( &
      fid, varname,  &
      var,           &
      step,          &
      allow_missing, &
      missing_value, &
      ntypes, dtype, &
      start, count   )
    implicit none
 
    integer,          intent( in)           :: fid
    character(len=*), intent( in)           :: varname
#ifdef NVIDIA
    real(sp),    intent(out), target :: var(:,:,:,:)
#else
    real(sp),    intent(out), target, contiguous :: var(:,:,:,:)
#endif
    integer,          intent( in), optional :: step
    logical,          intent( in), optional :: allow_missing
    real(sp),    intent( in), optional :: missing_value
    integer,          intent( in), optional :: ntypes
    integer,          intent( in), optional :: dtype
    integer,          intent( in), optional :: start(:)
    integer,          intent( in), optional :: count(:)
 
    integer :: step_
    logical(c_bool) :: allow_missing_
    real(sp) :: missing_value_
 
    type(datainfo) :: dinfo
    integer :: dim_size(4)
 
    integer :: error
    integer :: n
 
    intrinsic size, shape
    !---------------------------------------------------------------------------
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_read_var_realSP_4D",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    if ( present(step) ) then
       step_ = step
    else
       step_ = 1
    end if
 
    if ( present(allow_missing) ) then
       allow_missing_ = allow_missing
    else
       allow_missing_ = .false.
    end if
 
    if ( present(missing_value) ) then
       missing_value_ = missing_value
    else
       missing_value_ = 0.0_sp
    end if
 
    !--- get data information
    error = file_get_datainfo_c( dinfo,                & ! (out)
                                 file_files(fid)%fid,  & ! (in)
                                 cstr(varname),        & ! (in)
                                 step_, allow_missing_ ) ! (in)
 
    !--- verify
    if ( error /= file_success_code ) then
       if ( allow_missing_ ) then
          log_info("FILE_read_var_realSP_4D",*) '[INPUT]/[FILE] data not found! : ', &
               'varname= ',trim(varname),', step=',step_
          log_info("FILE_read_var_realSP_4D",*) '[INPUT]/[FILE] Value is set to ', missing_value_
          var(:,:,:,:) = missing_value_
          return
       else
          log_error("FILE_read_var_realSP_4D",*) 'failed to get data information :'//trim(varname)
          call prc_abort
       end if
    end if
 
    if ( dinfo%rank /= 4 ) then
       if ( (.not. present(start)) .and. (.not. present(count)) ) then
          log_error("FILE_read_var_realSP_4D",*) 'rank of '//trim(varname)//' is not 4', dinfo%rank
          call prc_abort
       end if
    end if
 
    if ( present(ntypes) ) then
#if defined(__GFORTRAN__) && __GNUC__ < 7
       error = file_read_data_c( cloc(var(1,1,1,1)),                  & ! (out)
#else
       error = file_read_data_c( c_loc(var),                  & ! (out)
#endif
            dinfo, sp, ntypes, dtype, start(:), count(:) ) ! (in)
    else if ( present(start) .and. present(count) ) then
#ifdef NVIDIA
       block
       real(sp), allocatable, target :: work(:,:,:,:)
       allocate(work, mold=var)
#endif
       error = file_read_data_c( &
#if defined(__GFORTRAN__) && __GNUC__ < 7
            cloc(var(1,1,1,1)), & ! (out)
#elif defined(NVIDIA)
            c_loc(work), & ! (out)
#else
            c_loc(var), & ! (out)
#endif
            dinfo, sp, 0, 0, start(:), count(:) ) ! (in)
#ifdef NVIDIA
       var = work
       end block
#endif
    else
       dim_size(:) = shape(var)
       do n = 1, 4
          if ( dinfo%dim_size(n) /= dim_size(n) ) then
             log_error("FILE_read_var_realSP_4D",*) 'shape is different: ', trim(varname), n, dinfo%dim_size(n), dim_size(n)
             call prc_abort
          end if
       end do
#ifdef NVIDIA
       block
       real(sp), allocatable, target :: work(:,:,:,:)
       allocate(work, mold=var)
#endif
       error = file_read_data_c( &
#if defined(__GFORTRAN__) && __GNUC__ < 7
            cloc(var(1,1,1,1)), & ! (out)
#elif defined(NVIDIA)
            c_loc(work), & ! (out)
#else
            c_loc(var), & ! (out)
#endif
            dinfo, sp, 0, 0, (/0/), (/0/) ) ! (in)
#ifdef NVIDIA
       var = work
       end block
#endif
    end if
    if ( error /= file_success_code ) then
       log_error("FILE_read_var_realSP_4D",*) 'failed to get data value: ', trim(varname)
       call prc_abort
    end if
 
    !$acc update device(var) if(acc_is_present(var))
 
    call prof_rapend  ('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_read_var_realsp_4d
  subroutine file_read_var_realdp_4d( &
      fid, varname,  &
      var,           &
      step,          &
      allow_missing, &
      missing_value, &
      ntypes, dtype, &
      start, count   )
    implicit none
 
    integer,          intent( in)           :: fid
    character(len=*), intent( in)           :: varname
#ifdef NVIDIA
    real(dp),    intent(out), target :: var(:,:,:,:)
#else
    real(dp),    intent(out), target, contiguous :: var(:,:,:,:)
#endif
    integer,          intent( in), optional :: step
    logical,          intent( in), optional :: allow_missing
    real(dp),    intent( in), optional :: missing_value
    integer,          intent( in), optional :: ntypes
    integer,          intent( in), optional :: dtype
    integer,          intent( in), optional :: start(:)
    integer,          intent( in), optional :: count(:)
 
    integer :: step_
    logical(c_bool) :: allow_missing_
    real(dp) :: missing_value_
 
    type(datainfo) :: dinfo
    integer :: dim_size(4)
 
    integer :: error
    integer :: n
 
    intrinsic size, shape
    !---------------------------------------------------------------------------
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_read_var_realDP_4D",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    if ( present(step) ) then
       step_ = step
    else
       step_ = 1
    end if
 
    if ( present(allow_missing) ) then
       allow_missing_ = allow_missing
    else
       allow_missing_ = .false.
    end if
 
    if ( present(missing_value) ) then
       missing_value_ = missing_value
    else
       missing_value_ = 0.0_dp
    end if
 
    !--- get data information
    error = file_get_datainfo_c( dinfo,                & ! (out)
                                 file_files(fid)%fid,  & ! (in)
                                 cstr(varname),        & ! (in)
                                 step_, allow_missing_ ) ! (in)
 
    !--- verify
    if ( error /= file_success_code ) then
       if ( allow_missing_ ) then
          log_info("FILE_read_var_realDP_4D",*) '[INPUT]/[FILE] data not found! : ', &
               'varname= ',trim(varname),', step=',step_
          log_info("FILE_read_var_realDP_4D",*) '[INPUT]/[FILE] Value is set to ', missing_value_
          var(:,:,:,:) = missing_value_
          return
       else
          log_error("FILE_read_var_realDP_4D",*) 'failed to get data information :'//trim(varname)
          call prc_abort
       end if
    end if
 
    if ( dinfo%rank /= 4 ) then
       if ( (.not. present(start)) .and. (.not. present(count)) ) then
          log_error("FILE_read_var_realDP_4D",*) 'rank of '//trim(varname)//' is not 4', dinfo%rank
          call prc_abort
       end if
    end if
 
    if ( present(ntypes) ) then
#if defined(__GFORTRAN__) && __GNUC__ < 7
       error = file_read_data_c( cloc(var(1,1,1,1)),                  & ! (out)
#else
       error = file_read_data_c( c_loc(var),                  & ! (out)
#endif
            dinfo, dp, ntypes, dtype, start(:), count(:) ) ! (in)
    else if ( present(start) .and. present(count) ) then
#ifdef NVIDIA
       block
       real(dp), allocatable, target :: work(:,:,:,:)
       allocate(work, mold=var)
#endif
       error = file_read_data_c( &
#if defined(__GFORTRAN__) && __GNUC__ < 7
            cloc(var(1,1,1,1)), & ! (out)
#elif defined(NVIDIA)
            c_loc(work), & ! (out)
#else
            c_loc(var), & ! (out)
#endif
            dinfo, dp, 0, 0, start(:), count(:) ) ! (in)
#ifdef NVIDIA
       var = work
       end block
#endif
    else
       dim_size(:) = shape(var)
       do n = 1, 4
          if ( dinfo%dim_size(n) /= dim_size(n) ) then
             log_error("FILE_read_var_realDP_4D",*) 'shape is different: ', trim(varname), n, dinfo%dim_size(n), dim_size(n)
             call prc_abort
          end if
       end do
#ifdef NVIDIA
       block
       real(dp), allocatable, target :: work(:,:,:,:)
       allocate(work, mold=var)
#endif
       error = file_read_data_c( &
#if defined(__GFORTRAN__) && __GNUC__ < 7
            cloc(var(1,1,1,1)), & ! (out)
#elif defined(NVIDIA)
            c_loc(work), & ! (out)
#else
            c_loc(var), & ! (out)
#endif
            dinfo, dp, 0, 0, (/0/), (/0/) ) ! (in)
#ifdef NVIDIA
       var = work
       end block
#endif
    end if
    if ( error /= file_success_code ) then
       log_error("FILE_read_var_realDP_4D",*) 'failed to get data value: ', trim(varname)
       call prc_abort
    end if
 
    !$acc update device(var) if(acc_is_present(var))
 
    call prof_rapend  ('FILE_Read', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_read_var_realdp_4d
 
  !-----------------------------------------------------------------------------
  ! interface FILE_write
  !-----------------------------------------------------------------------------
  subroutine file_write_realsp_1d( &
      vid, var,       &
      t_start, t_end, &
      ndims,          &
      count,          &
      start           )
    implicit none
 
    integer,  intent(in)           :: vid
#ifdef NVIDIA
    real(sp), intent(in) :: var(:)
#else
    real(sp), intent(in), target, contiguous :: var(:)
#endif
    real(dp), intent(in)           :: t_start
    real(dp), intent(in)           :: t_end
    integer,  intent(in), optional :: ndims    ! when var has been reshaped to 1D
    integer,  intent(in), optional :: count(:)
    integer,  intent(in), optional :: start(:)
    real(dp) :: ts, te
 
    integer :: start_(1)
 
    integer :: fid
    integer :: error
 
    intrinsic shape
    !---------------------------------------------------------------------------
 
    ts = t_start
    te = t_end
 
    fid = file_vars(vid)%fid
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_write_realSP_1D",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    if ( present(ndims) ) then
       ! history variable has been reshaped to 1D
       ! In this case, start and count must be present
 
       if ( .not. present(start) ) then
          log_error("FILE_write_realSP_1D",*) 'start argument is neccessary when ndims is specified'
          call prc_abort
       end if
       if ( .not. present(count) ) then
          log_error("FILE_write_realSP_1D",*) 'count argument is neccessary when ndims is specified'
          call prc_abort
       end if
 
       error = file_write_data_c( file_files(fid)%fid, file_vars(vid)%vid, & ! (in)
#if defined(__GFORTRAN__) && __GNUC__ < 7
                                  cloc(var(1)), ts, te, ndims, sp,      & ! (in)
#else
                                  c_loc(var), ts, te, ndims, sp,      & ! (in)
#endif
                                  start, count                             ) ! (in)
    else
       ! this is for restart variable which keeps its original shape
       if ( present(start) ) then
          start_(:) = start(:)
       else
          start_(:) = 1
       end if
 
       !$acc update host(var) if(acc_is_present(var))
 
#ifdef NVIDIA
       block
       real(sp), allocatable, target :: work(:)
       allocate(work, source=var)
#endif
       error = file_write_data_c( file_files(fid)%fid, file_vars(vid)%vid, & ! (in)
#if defined(__GFORTRAN__) && __GNUC__ < 7
                                  cloc(var(1)), & ! (in)
#elif defined(NVIDIA)
                                  c_loc(work), & ! (in)
#else
                                  c_loc(var), & ! (in)
#endif
                                  ts, te, 1, sp,     & ! (in)
                                  start_, shape(var)                       ) ! (in)
#ifdef NVIDIA
       end block
#endif
    end if
    if ( error /= file_success_code ) then
       log_error("FILE_write_realSP_1D",*) 'failed to write data: ', trim(file_vars(vid)%name)
       call prc_abort
    end if
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_write_realsp_1d
  subroutine file_write_realdp_1d( &
      vid, var,       &
      t_start, t_end, &
      ndims,          &
      count,          &
      start           )
    implicit none
 
    integer,  intent(in)           :: vid
#ifdef NVIDIA
    real(dp), intent(in) :: var(:)
#else
    real(dp), intent(in), target, contiguous :: var(:)
#endif
    real(dp), intent(in)           :: t_start
    real(dp), intent(in)           :: t_end
    integer,  intent(in), optional :: ndims    ! when var has been reshaped to 1D
    integer,  intent(in), optional :: count(:)
    integer,  intent(in), optional :: start(:)
    real(dp) :: ts, te
 
    integer :: start_(1)
 
    integer :: fid
    integer :: error
 
    intrinsic shape
    !---------------------------------------------------------------------------
 
    ts = t_start
    te = t_end
 
    fid = file_vars(vid)%fid
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_write_realDP_1D",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    if ( present(ndims) ) then
       ! history variable has been reshaped to 1D
       ! In this case, start and count must be present
 
       if ( .not. present(start) ) then
          log_error("FILE_write_realDP_1D",*) 'start argument is neccessary when ndims is specified'
          call prc_abort
       end if
       if ( .not. present(count) ) then
          log_error("FILE_write_realDP_1D",*) 'count argument is neccessary when ndims is specified'
          call prc_abort
       end if
 
       error = file_write_data_c( file_files(fid)%fid, file_vars(vid)%vid, & ! (in)
#if defined(__GFORTRAN__) && __GNUC__ < 7
                                  cloc(var(1)), ts, te, ndims, dp,      & ! (in)
#else
                                  c_loc(var), ts, te, ndims, dp,      & ! (in)
#endif
                                  start, count                             ) ! (in)
    else
       ! this is for restart variable which keeps its original shape
       if ( present(start) ) then
          start_(:) = start(:)
       else
          start_(:) = 1
       end if
 
       !$acc update host(var) if(acc_is_present(var))
 
#ifdef NVIDIA
       block
       real(dp), allocatable, target :: work(:)
       allocate(work, source=var)
#endif
       error = file_write_data_c( file_files(fid)%fid, file_vars(vid)%vid, & ! (in)
#if defined(__GFORTRAN__) && __GNUC__ < 7
                                  cloc(var(1)), & ! (in)
#elif defined(NVIDIA)
                                  c_loc(work), & ! (in)
#else
                                  c_loc(var), & ! (in)
#endif
                                  ts, te, 1, dp,     & ! (in)
                                  start_, shape(var)                       ) ! (in)
#ifdef NVIDIA
       end block
#endif
    end if
    if ( error /= file_success_code ) then
       log_error("FILE_write_realDP_1D",*) 'failed to write data: ', trim(file_vars(vid)%name)
       call prc_abort
    end if
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_write_realdp_1d
  subroutine file_write_realsp_2d( &
      vid, var,       &
      t_start, t_end, &
      start           )
    implicit none
 
    integer,  intent(in)           :: vid
#ifdef NVIDIA
    real(sp), intent(in) :: var(:,:)
#else
    real(sp), intent(in), target, contiguous :: var(:,:)
#endif
    real(dp), intent(in)           :: t_start
    real(dp), intent(in)           :: t_end
    integer,  intent(in), optional :: start(:)
    real(dp) :: ts, te
 
    integer :: start_(2)
 
    integer :: fid
    integer :: error
 
    intrinsic shape
    !---------------------------------------------------------------------------
 
    ts = t_start
    te = t_end
 
    fid = file_vars(vid)%fid
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_write_realSP_2D",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
       ! this is for restart variable which keeps its original shape
       if ( present(start) ) then
          start_(:) = start(:)
       else
          start_(:) = 1
       end if
 
       !$acc update host(var) if(acc_is_present(var))
 
#ifdef NVIDIA
       block
       real(sp), allocatable, target :: work(:,:)
       allocate(work, source=var)
#endif
       error = file_write_data_c( file_files(fid)%fid, file_vars(vid)%vid, & ! (in)
#if defined(__GFORTRAN__) && __GNUC__ < 7
                                  cloc(var(1,1)), & ! (in)
#elif defined(NVIDIA)
                                  c_loc(work), & ! (in)
#else
                                  c_loc(var), & ! (in)
#endif
                                  ts, te, 2, sp,     & ! (in)
                                  start_, shape(var)                       ) ! (in)
#ifdef NVIDIA
       end block
#endif
    if ( error /= file_success_code ) then
       log_error("FILE_write_realSP_2D",*) 'failed to write data: ', trim(file_vars(vid)%name)
       call prc_abort
    end if
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_write_realsp_2d
  subroutine file_write_realdp_2d( &
      vid, var,       &
      t_start, t_end, &
      start           )
    implicit none
 
    integer,  intent(in)           :: vid
#ifdef NVIDIA
    real(dp), intent(in) :: var(:,:)
#else
    real(dp), intent(in), target, contiguous :: var(:,:)
#endif
    real(dp), intent(in)           :: t_start
    real(dp), intent(in)           :: t_end
    integer,  intent(in), optional :: start(:)
    real(dp) :: ts, te
 
    integer :: start_(2)
 
    integer :: fid
    integer :: error
 
    intrinsic shape
    !---------------------------------------------------------------------------
 
    ts = t_start
    te = t_end
 
    fid = file_vars(vid)%fid
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_write_realDP_2D",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
       ! this is for restart variable which keeps its original shape
       if ( present(start) ) then
          start_(:) = start(:)
       else
          start_(:) = 1
       end if
 
       !$acc update host(var) if(acc_is_present(var))
 
#ifdef NVIDIA
       block
       real(dp), allocatable, target :: work(:,:)
       allocate(work, source=var)
#endif
       error = file_write_data_c( file_files(fid)%fid, file_vars(vid)%vid, & ! (in)
#if defined(__GFORTRAN__) && __GNUC__ < 7
                                  cloc(var(1,1)), & ! (in)
#elif defined(NVIDIA)
                                  c_loc(work), & ! (in)
#else
                                  c_loc(var), & ! (in)
#endif
                                  ts, te, 2, dp,     & ! (in)
                                  start_, shape(var)                       ) ! (in)
#ifdef NVIDIA
       end block
#endif
    if ( error /= file_success_code ) then
       log_error("FILE_write_realDP_2D",*) 'failed to write data: ', trim(file_vars(vid)%name)
       call prc_abort
    end if
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_write_realdp_2d
  subroutine file_write_realsp_3d( &
      vid, var,       &
      t_start, t_end, &
      start           )
    implicit none
 
    integer,  intent(in)           :: vid
#ifdef NVIDIA
    real(sp), intent(in) :: var(:,:,:)
#else
    real(sp), intent(in), target, contiguous :: var(:,:,:)
#endif
    real(dp), intent(in)           :: t_start
    real(dp), intent(in)           :: t_end
    integer,  intent(in), optional :: start(:)
    real(dp) :: ts, te
 
    integer :: start_(3)
 
    integer :: fid
    integer :: error
 
    intrinsic shape
    !---------------------------------------------------------------------------
 
    ts = t_start
    te = t_end
 
    fid = file_vars(vid)%fid
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_write_realSP_3D",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
       ! this is for restart variable which keeps its original shape
       if ( present(start) ) then
          start_(:) = start(:)
       else
          start_(:) = 1
       end if
 
       !$acc update host(var) if(acc_is_present(var))
 
#ifdef NVIDIA
       block
       real(sp), allocatable, target :: work(:,:,:)
       allocate(work, source=var)
#endif
       error = file_write_data_c( file_files(fid)%fid, file_vars(vid)%vid, & ! (in)
#if defined(__GFORTRAN__) && __GNUC__ < 7
                                  cloc(var(1,1,1)), & ! (in)
#elif defined(NVIDIA)
                                  c_loc(work), & ! (in)
#else
                                  c_loc(var), & ! (in)
#endif
                                  ts, te, 3, sp,     & ! (in)
                                  start_, shape(var)                       ) ! (in)
#ifdef NVIDIA
       end block
#endif
    if ( error /= file_success_code ) then
       log_error("FILE_write_realSP_3D",*) 'failed to write data: ', trim(file_vars(vid)%name)
       call prc_abort
    end if
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_write_realsp_3d
  subroutine file_write_realdp_3d( &
      vid, var,       &
      t_start, t_end, &
      start           )
    implicit none
 
    integer,  intent(in)           :: vid
#ifdef NVIDIA
    real(dp), intent(in) :: var(:,:,:)
#else
    real(dp), intent(in), target, contiguous :: var(:,:,:)
#endif
    real(dp), intent(in)           :: t_start
    real(dp), intent(in)           :: t_end
    integer,  intent(in), optional :: start(:)
    real(dp) :: ts, te
 
    integer :: start_(3)
 
    integer :: fid
    integer :: error
 
    intrinsic shape
    !---------------------------------------------------------------------------
 
    ts = t_start
    te = t_end
 
    fid = file_vars(vid)%fid
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_write_realDP_3D",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
       ! this is for restart variable which keeps its original shape
       if ( present(start) ) then
          start_(:) = start(:)
       else
          start_(:) = 1
       end if
 
       !$acc update host(var) if(acc_is_present(var))
 
#ifdef NVIDIA
       block
       real(dp), allocatable, target :: work(:,:,:)
       allocate(work, source=var)
#endif
       error = file_write_data_c( file_files(fid)%fid, file_vars(vid)%vid, & ! (in)
#if defined(__GFORTRAN__) && __GNUC__ < 7
                                  cloc(var(1,1,1)), & ! (in)
#elif defined(NVIDIA)
                                  c_loc(work), & ! (in)
#else
                                  c_loc(var), & ! (in)
#endif
                                  ts, te, 3, dp,     & ! (in)
                                  start_, shape(var)                       ) ! (in)
#ifdef NVIDIA
       end block
#endif
    if ( error /= file_success_code ) then
       log_error("FILE_write_realDP_3D",*) 'failed to write data: ', trim(file_vars(vid)%name)
       call prc_abort
    end if
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_write_realdp_3d
  subroutine file_write_realsp_4d( &
      vid, var,       &
      t_start, t_end, &
      start           )
    implicit none
 
    integer,  intent(in)           :: vid
#ifdef NVIDIA
    real(sp), intent(in) :: var(:,:,:,:)
#else
    real(sp), intent(in), target, contiguous :: var(:,:,:,:)
#endif
    real(dp), intent(in)           :: t_start
    real(dp), intent(in)           :: t_end
    integer,  intent(in), optional :: start(:)
    real(dp) :: ts, te
 
    integer :: start_(4)
 
    integer :: fid
    integer :: error
 
    intrinsic shape
    !---------------------------------------------------------------------------
 
    ts = t_start
    te = t_end
 
    fid = file_vars(vid)%fid
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_write_realSP_4D",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
       ! this is for restart variable which keeps its original shape
       if ( present(start) ) then
          start_(:) = start(:)
       else
          start_(:) = 1
       end if
 
       !$acc update host(var) if(acc_is_present(var))
 
#ifdef NVIDIA
       block
       real(sp), allocatable, target :: work(:,:,:,:)
       allocate(work, source=var)
#endif
       error = file_write_data_c( file_files(fid)%fid, file_vars(vid)%vid, & ! (in)
#if defined(__GFORTRAN__) && __GNUC__ < 7
                                  cloc(var(1,1,1,1)), & ! (in)
#elif defined(NVIDIA)
                                  c_loc(work), & ! (in)
#else
                                  c_loc(var), & ! (in)
#endif
                                  ts, te, 4, sp,     & ! (in)
                                  start_, shape(var)                       ) ! (in)
#ifdef NVIDIA
       end block
#endif
    if ( error /= file_success_code ) then
       log_error("FILE_write_realSP_4D",*) 'failed to write data: ', trim(file_vars(vid)%name)
       call prc_abort
    end if
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_write_realsp_4d
  subroutine file_write_realdp_4d( &
      vid, var,       &
      t_start, t_end, &
      start           )
    implicit none
 
    integer,  intent(in)           :: vid
#ifdef NVIDIA
    real(dp), intent(in) :: var(:,:,:,:)
#else
    real(dp), intent(in), target, contiguous :: var(:,:,:,:)
#endif
    real(dp), intent(in)           :: t_start
    real(dp), intent(in)           :: t_end
    integer,  intent(in), optional :: start(:)
    real(dp) :: ts, te
 
    integer :: start_(4)
 
    integer :: fid
    integer :: error
 
    intrinsic shape
    !---------------------------------------------------------------------------
 
    ts = t_start
    te = t_end
 
    fid = file_vars(vid)%fid
 
    if ( .not. file_opened(fid) ) then
       log_error("FILE_write_realDP_4D",*) 'File is not opened. fid = ', fid
       call prc_abort
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
       ! this is for restart variable which keeps its original shape
       if ( present(start) ) then
          start_(:) = start(:)
       else
          start_(:) = 1
       end if
 
       !$acc update host(var) if(acc_is_present(var))
 
#ifdef NVIDIA
       block
       real(dp), allocatable, target :: work(:,:,:,:)
       allocate(work, source=var)
#endif
       error = file_write_data_c( file_files(fid)%fid, file_vars(vid)%vid, & ! (in)
#if defined(__GFORTRAN__) && __GNUC__ < 7
                                  cloc(var(1,1,1,1)), & ! (in)
#elif defined(NVIDIA)
                                  c_loc(work), & ! (in)
#else
                                  c_loc(var), & ! (in)
#endif
                                  ts, te, 4, dp,     & ! (in)
                                  start_, shape(var)                       ) ! (in)
#ifdef NVIDIA
       end block
#endif
    if ( error /= file_success_code ) then
       log_error("FILE_write_realDP_4D",*) 'failed to write data: ', trim(file_vars(vid)%name)
       call prc_abort
    end if
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_write_realdp_4d
 
  !-----------------------------------------------------------------------------
  ! exit netCDF define mode and enter data mode
  subroutine file_enddef( fid )
    implicit none
 
    integer, intent(in) :: fid
 
    integer :: error
    !---------------------------------------------------------------------------
 
    if ( .not. file_opened(fid) ) return
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    error = file_enddef_c( file_files(fid)%fid )
 
    if ( error == file_success_code ) then
 
       log_newline
       log_info("FILE_enddef",'(1x,A,I3.3,2A)') &
            'End define mode : No.', fid, ', name = ', trim(file_files(fid)%name)
 
    else
       log_error("FILE_enddef",*) 'failed to exit define mode'
       call prc_abort
    end if
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_enddef
 
  !-----------------------------------------------------------------------------
  ! enter netCDF define mode and enter data mode
  subroutine file_redef( fid )
    implicit none
 
    integer, intent(in) :: fid
 
    integer :: error
    !---------------------------------------------------------------------------
 
    if ( .not. file_opened(fid) ) return
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    error = file_redef_c( file_files(fid)%fid )
 
    if ( error == file_success_code ) then
 
       log_newline
       log_info("FILE_redef",'(1x,A,I3.3,2A)') &
            'Enter to define mode : No.', fid, ', name = ', trim(file_files(fid)%name)
 
    else
       log_error("FILE_redef",*) 'failed to enter to define mode'
       call prc_abort
    end if
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_redef
 
  !-----------------------------------------------------------------------------
  ! This subroutine is used when PnetCDF I/O method is enabled
  subroutine file_attach_buffer( &
       fid,       &
       buf_amount )
    implicit none
 
    integer,    intent(in) :: fid
    integer(8), intent(in) :: buf_amount
 
    integer :: error
    !---------------------------------------------------------------------------
 
    if ( .not. file_opened(fid) ) return
 
    if ( file_files(fid)%buffer_size > 0 ) then
       call file_detach_buffer(fid)
    end if
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    error = file_attach_buffer_c( file_files(fid)%fid, buf_amount )
 
    if ( error /= file_success_code ) then
       log_error("FILE_attach_buffer",*) 'failed to attach buffer in PnetCDF'
       call prc_abort
    end if
 
    log_newline
    log_info("FILE_attach_buffer",'(1x,A,I3.3,3A,I10)') &
            'Attach buffer : No.', fid, ', name = ', trim(file_files(fid)%name), &
            ', size = ', buf_amount
 
    file_files(fid)%buffer_size = buf_amount
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_attach_buffer
 
  !-----------------------------------------------------------------------------
  ! This subroutine is used when PnetCDF I/O method is enabled
  subroutine file_detach_buffer( fid )
    implicit none
 
    integer, intent(in) :: fid
 
    integer :: error
    !---------------------------------------------------------------------------
 
    if ( .not. file_opened(fid) ) return
 
    if ( file_files(fid)%fid < 0 ) return  ! already closed
 
    if ( file_files(fid)%buffer_size < 0 ) return ! not attached
 
    call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    error = file_detach_buffer_c( file_files(fid)%fid )
 
    if ( error /= file_success_code ) then
       log_error("FILE_detach_buffer",*) 'failed to detach buffer in PnetCDF'
       call prc_abort
    end if
 
    log_newline
    log_info("FILE_detach_buffer",'(1x,A,I3.3,2A)') &
            'Detach buffer : No.', fid, ', name = ', trim(file_files(fid)%name)
 
    file_files(fid)%buffer_size = -1
 
    call prof_rapend  ('FILE_Write', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_detach_buffer
 
  !-----------------------------------------------------------------------------
  ! flush data
  subroutine file_flush( fid )
    implicit none
 
    integer, intent(in) :: fid
 
    integer :: error
    !---------------------------------------------------------------------------
 
    if ( .not. file_opened(fid) ) return
 
    if ( file_files(fid)%fid < 0 ) return  ! already closed
 
    call prof_rapstart('FILE', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    error = file_flush_c( file_files(fid)%fid )
 
    if ( error == file_success_code ) then
 
!!$       LOG_NEWLINE
!!$       LOG_INFO("FILE_flush",'(1xA,I3.3,2A)') &
!!$            'Flush : No.', fid, ', name = ', trim(FILE_files(fid)%name)
 
    else
       log_error("FILE_flush",*) 'failed to flush data to netcdf file'
       call prc_abort
    end if
 
    call prof_rapend  ('FILE', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_flush
 
  !-----------------------------------------------------------------------------
  subroutine file_close( fid, abort )
    implicit none
    integer, intent(in) :: fid
    logical, intent(in), optional :: abort
 
    logical(c_bool) :: abort_
    integer :: error
    integer :: n
    !---------------------------------------------------------------------------
 
    if ( .not. file_opened(fid) ) return
 
    if ( file_files(fid)%fid < 0 ) return  ! already closed
 
    call prof_rapstart('FILE', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    if ( present(abort) ) then
       abort_ = abort
    else
       abort_ = .false.
    end if
 
    error = file_close_c( file_files(fid)%fid, abort_ )
 
    if ( error == file_success_code ) then
 
       log_newline
       log_info("FILE_close",'(1x,A,I3.3,2A)') &
            'Close : No.', fid, ', name = ', trim(file_files(fid)%name)
 
    elseif( error /= file_already_closed_code ) then
       log_error("FILE_close",*) 'failed to close file: ', trim(file_files(fid)%name)
       if ( .not. abort_ ) call prc_abort
    end if
 
    file_files(fid)%fid = -1
    file_files(fid)%name = ''
    file_files(fid)%aggregate = .false.
    file_files(fid)%buffer_size = -1
 
    do n = 1, file_nvars
       if ( file_vars(n)%fid == fid ) then
          file_vars(n)%vid = -1
          file_vars(n)%name = ''
       end if
    end do
 
    call prof_rapend  ('FILE', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_close
  !-----------------------------------------------------------------------------
  subroutine file_close_all( &
       skip_abort )
    implicit none
    logical, intent(in), optional :: skip_abort
 
    integer :: fid
    !---------------------------------------------------------------------------
 
    do fid = 1, file_nfiles
       call file_close( fid, skip_abort )
    enddo
 
    return
  end subroutine file_close_all
 
  !-----------------------------------------------------------------------------
  !-----------------------------------------------------------------------------
  subroutine file_get_cftunits(date, tunits)
    implicit none
 
    integer,          intent(in)  :: date(6)
    character(len=*), intent(out) :: tunits
    !---------------------------------------------------------------------------
 
    write(tunits,'(a,i4.4,"-",i2.2,"-",i2.2," ",i2.2,":",i2.2,":",i2.2)') 'seconds since ', date
 
    return
  end subroutine file_get_cftunits
 
  function file_get_aggregate( fid )
    integer, intent(in) :: fid
    logical :: file_get_aggregate
 
    if ( .not. file_opened(fid) ) then
       file_get_aggregate = .false.
    else
       file_get_aggregate = file_files(fid)%aggregate
    end if
 
    return
  end function file_get_aggregate
 
  !-----------------------------------------------------------------------------
  ! private
  !-----------------------------------------------------------------------------
 
  !-----------------------------------------------------------------------------
  subroutine file_get_fid( &
      basename,  &
      mode,      &
      rankid,    &
      single,    &
      fid,       &
      existed,   &
      allnodes,  &
      aggregate, &
      postfix    )
    use scale_prc, only: &
       prc_local_comm_world, &
       prc_comm_null
    implicit none
 
    character(len=*), intent( in) :: basename
    integer,          intent( in) :: mode
    integer,          intent( in) :: rankid
    logical,          intent( in) :: single
 
    integer,          intent(out) :: fid
    logical,          intent(out) :: existed
 
    logical,          intent( in), optional :: allnodes
    logical,          intent( in), optional :: aggregate
    character(len=*), intent( in), optional :: postfix
 
    character(len=FILE_HSHORT) :: rwname(0:2)
    data rwname / 'READ','WRITE','APPEND' /
 
    character(len=FILE_HLONG) :: fname
    integer                   :: n
 
    logical :: allnodes_
    logical :: aggregate_
    integer :: cfid
    integer :: error
    integer :: mpi_comm
    !---------------------------------------------------------------------------
 
    !--- check aggregate (parallel I/O on a single shared netCDF file)
 
    if ( present(allnodes) ) then
       allnodes_ = allnodes
    else
       allnodes_ = .true.
    end if
 
    ! check to do PnetCDF I/O
    if ( present(aggregate) ) then
       aggregate_ = aggregate
    else
       aggregate_ = file_aggregate
    end if
 
    if ( aggregate_ ) then
       mpi_comm = prc_local_comm_world
    else
       mpi_comm = prc_comm_null
    end if
 
    if ( present(postfix) ) then
       call io_get_fname(fname, trim(basename)//trim(postfix))
    elseif ( aggregate_ ) then
       call io_get_fname(fname, basename)
    elseif ( single ) then
       call io_get_fname(fname, basename, rank=-1)
    else
       call io_get_fname(fname, basename, rank=rankid)
    endif
 
    !--- search existing file
    fid = -1
    do n = 1, file_nfiles
       if ( fname == file_files(n)%name ) then
          fid = n
          exit
       end if
    enddo
 
    if ( file_opened(fid) ) then
       existed = .true.
       return
    end if
 
    call prof_rapstart('FILE', 2, disable_barrier = ( .not. allnodes_ ) .or. single )
 
    error = file_open_c( cfid,                       & ! (out)
                         cstr(fname), mode, mpi_comm ) ! (in)
 
    if ( error /= file_success_code ) then
       log_error("FILE_get_fid",*) 'failed to open file :'//trim(fname)//'.nc'
       call prc_abort
    end if
 
    file_nfiles = file_nfiles + 1
    fid         = file_nfiles
 
    file_files(fid)%name      = fname
    file_files(fid)%fid       = cfid
    file_files(fid)%aggregate = aggregate_
    file_files(fid)%single    = single
    file_files(fid)%allnodes  = allnodes_ .and. (.not. single)
    file_files(fid)%buffer_size = -1
 
    log_newline
    log_info("FILE_get_fid",'(1x,A,A6,A,I3.3,2A)') &
    'Registration (', trim(rwname(mode)), ') : No.', fid, ', name = ', trim(fname)
 
    existed = .false.
 
    call prof_rapend  ('FILE', 2, disable_barrier = .not. file_files(fid)%allnodes )
 
    return
  end subroutine file_get_fid
 
#if defined(__GFORTRAN__) && __GNUC__ < 7
  function cloc_sp( x )
    use iso_c_binding
    implicit none
    real(sp), target, intent(in) :: x
    type(c_ptr) :: cloc_sp
    cloc_sp = c_loc(x)
    return
  end function cloc_sp
  function cloc_dp( x )
    use iso_c_binding
    implicit none
    real(dp), target, intent(in) :: x
    type(c_ptr) :: cloc_dp
    cloc_dp = c_loc(x)
    return
  end function cloc_dp
#endif
 
end module scale_file
!-------------------------------------------------------------------------------
 
 
!--
! vi:set readonly sw=4 ts=8
!
!Local Variables:
!mode: f90
!buffer-read-only: t
!End:
!
!++