scale_file_history_meshfield.F90

Go to the documentation of this file.

!-------------------------------------------------------------------------------
!> module FElib / File / History
!!
!! @par Description
!!          A module for managing file history 
!!
!! @author Yuta Kawai, Team SCALE
!<
!-------------------------------------------------------------------------------
#include "scaleFElib.h"
module scale_file_history_meshfield
  !-----------------------------------------------------------------------------
  !
  !++ Used modules
  !
  use scale_precision
  use scale_io
  use scale_prc, only: &
    prc_abort
 
  use scale_file_history, only: &
    file_history_setup, &
    file_history_set_nowdate, &
    file_history_truncate_1d, &
    file_history_truncate_2d, &
    file_history_truncate_3d, &
    file_history_put,         &
    file_history_write,       &
    file_history_set_dim,     &
    file_history_set_axis,    &
    file_history_query,       &
    file_history_finalize
 
  use scale_element_base, only: elementbase1d, elementbase2d, elementbase3d
  use scale_mesh_base1d, only: meshbase1d
  use scale_mesh_base2d, only: meshbase2d
  use scale_mesh_base3d, only: meshbase3d
  use scale_mesh_rectdom2d, only: meshrectdom2d
  use scale_mesh_cubedom3d, only: meshcubedom3d
  use scale_mesh_cubedspheredom2d, only: meshcubedspheredom2d
  use scale_mesh_cubedspheredom3d, only: meshcubedspheredom3d
  use scale_localmesh_1d, only: localmesh1d
  use scale_localmesh_2d, only: localmesh2d
  use scale_localmesh_3d, only: localmesh3d
 
  use scale_meshfield_base, only: &
    meshfieldbase,                        &
    meshfield1d, meshfield2d, meshfield3d    
 
  !-----------------------------------------------------------------------------
  implicit none
  private
  !-----------------------------------------------------------------------------
  !
  !++ Public type and procedures
  !
 
  integer,          parameter :: nzs = 1
 
  type :: filehistorymeshfieldcomp
    class(MeshBase1D), pointer :: mesh1D
    class(MeshRectDom2D), pointer :: mesh2D
    class(MeshCubeDom3D), pointer :: mesh3D
    class(MeshCubedSphereDom2D), pointer :: meshCubedSphere2D
    class(MeshCubedSphereDom3D), pointer :: meshCubedSphere3D
 
    integer :: dims1D_size(1)
    integer :: dims2D_size(2)
    integer :: dims3D_size(3,nzs)
 
    character(len=H_SHORT) :: dim_name_postfix
  contains
    procedure :: Init => filehistorymeshfieldcomp_init
    procedure :: Final => filehistorymeshfieldcomp_final
    procedure, private :: set_dim_axis1D
    procedure, private :: set_dim_axis2D
    procedure, private :: set_dim_axis3D
    procedure, private :: set_dim_axis2D_cubedsphere
    procedure, private :: set_dim_axis3D_cubedsphere
  end type filehistorymeshfieldcomp
 
  integer, parameter :: component_num_max = 32
  type(filehistorymeshfieldcomp), target :: comp(component_num_max)  !< Array of registered components
 
  public :: file_history_meshfield_setup
  public :: file_history_meshfield_put
  public :: file_history_meshfield_in
  public :: file_history_meshfield_write  
  public :: file_history_meshfield_finalize
 
  interface file_history_meshfield_put
    module procedure file_history_meshfield_put1d
    module procedure file_history_meshfield_put2d
    module procedure file_history_meshfield_put3d
  end interface
  
  interface file_history_meshfield_in
    module procedure file_history_meshfield_in1d
    module procedure file_history_meshfield_in2d
    module procedure file_history_meshfield_in3d
  end interface
 
  !-----------------------------------------------------------------------------
  !
  !++ Public parameters & variables
  !
  !-----------------------------------------------------------------------------
  !
  !++ Private procedures
  !
  private :: history_in_regvar
 
  !-----------------------------------------------------------------------------
  !
  !++ Private variables
  !
  !----------------------------------------------------------------------------
 
  integer :: comp_num  = 0                                 !< Number of registered components
  type(FileHistoryMeshFieldComp), pointer :: default_comp
 
  character(len=8), parameter :: zs(nzs) = (/  "model   " /)
 
  integer  :: FILE_HISTORY_MESHFIELD_STARTDATE(6) !< start time [YYYY MM DD HH MM SS]
  real(DP) :: FILE_HISTORY_MESHFIELD_STARTSUBSEC  !< subsecond part of start time [millisec]
 
 
  logical, private :: FILE_HISTORY_FILEMESHFILED_DISABLE = .true.
 
contains
 
!----------------
!OCL SERIAL
  subroutine filehistorymeshfieldcomp_init( this, &
    mesh1D_, mesh2D_, mesh3D_,                    &
    meshcubedsphere2D_, meshcubedsphere3D_,       & 
    dim_name_postfix )
    implicit none
    class(FileHistoryMeshFieldComp), intent(inout) :: this
 
    class(MeshBase1d), intent(in), target, optional :: mesh1D_     !< An object of 1D mesh when the computational domain is 1D
    class(MeshRectDom2d), intent(in), target, optional :: mesh2D_  !< An object of 2D mesh when the computational domain is rectangular
    class(MeshCubeDom3D), intent(in), target, optional :: mesh3D_  !< An object of 3D mesh when the computational domain is cubed
    class(MeshCubedSphereDom2D), intent(in), target, optional :: meshCubedsphere2D_ !< An object of 2D mesh when the computational domain is 2D cubed-sphere
    class(MeshCubedSphereDom3D), intent(in), target, optional :: meshCubedsphere3D_ !< An object of 3D mesh when the computational domain is 3D cubed-sphere
    character(len=*), intent(in), optional :: dim_name_postfix     !< Postfix for dimension names
    !-----------------------------------------------
 
    if ( present(dim_name_postfix) ) then
      this%dim_name_postfix = dim_name_postfix
    else
      this%dim_name_postfix = ''
    end if
 
    !- Set a pointer to the  variable of mesh 
    !  and set the dimension information for each axis
    
    nullify( this%mesh1D, this%mesh2D, this%mesh3D )
    nullify( this%meshCubedSphere2D, this%meshCubedsphere3D )
 
    if ( present(mesh1d_) ) then
      this%mesh1D => mesh1d_
      call this%set_dim_axis1D()
    else if ( present(mesh2d_) ) then
      this%mesh2D => mesh2d_
      call this%set_dim_axis2D()
    else if ( present(mesh3d_) ) then
      this%mesh3D => mesh3d_
      this%mesh2D => mesh3d_%mesh2D
      call this%set_dim_axis3D()
    else if ( present(meshcubedsphere2d_) ) then
      this%meshCubedSphere2D => meshcubedsphere2d_
      call this%set_dim_axis2D_cubedsphere()
    else if ( present(meshcubedsphere3d_) ) then
      this%meshCubedSphere3D => meshcubedsphere3d_
      this%meshCubedSphere2D => meshcubedsphere3d_%mesh2D
      call this%set_dim_axis3D_cubedsphere()
    else
      log_error("FileHistoryMeshFieldComp_Init",*)   "Any mesh (mesh1d/2d/3d) are not specified."
      call prc_abort
    end if
 
    return
  end subroutine filehistorymeshfieldcomp_init
 
!OCL SERIAL
  subroutine filehistorymeshfieldcomp_final( this )
    implicit none
    class(FileHistoryMeshFieldComp), intent(inout) :: this
    !-----------------------------------------------
    return
  end subroutine filehistorymeshfieldcomp_final
 
  !> Setup a module for file history
!OCL SERIAL
  subroutine file_history_meshfield_setup( &
    mesh1D_, mesh2D_, mesh3D_,              &
    meshcubedsphere2D_, meshcubedsphere3D_, &
    dim_name_postfix_,                      &
    registered_comp_id                      )
 
    use scale_file_h, only: &
      file_hshort
    use scale_prc, only: &
      prc_masterrank, &
      prc_myrank,     &
      prc_abort
    use scale_time, only: &
      time_nowdate,       &
      time_nowsubsec,     &
      time_startdaysec,   &
      time_dtsec,         &
      time_nowstep
    use scale_calendar, only: &
      calendar_get_name
    implicit none
 
    class(meshbase1d), intent(in), target, optional :: mesh1d_     !< An object of 1D mesh when the computational domain is 1D
    class(meshrectdom2d)       , intent(in), target, optional :: mesh2d_            !< An object of 2D mesh when the computational domain is rectangular
    class(meshcubedom3d)       , intent(in), target, optional :: mesh3d_            !< An object of 3D mesh when the computational domain is cubed
    class(meshcubedspheredom2d), intent(in), target, optional :: meshcubedsphere2d_ !< An object of 2D mesh when the computational domain is 2D cubed-sphere
    class(meshcubedspheredom3d), intent(in), target, optional :: meshcubedsphere3d_ !< An object of 3D mesh when the computational domain is 3D cubed-sphere
    character(len=*), intent(in), optional :: dim_name_postfix_    !< Postfix for dimension names
    integer, intent(out), optional :: registered_comp_id
 
    character(len=H_MID) :: file_history_meshfiled_h_title = 'SCALE-DG FILE_HISTORY_MESHFIELD' !< title of the output file
    character(len=H_MID) :: file_history_meshfield_t_since
    
    character(len=FILE_HSHORT) :: calendar
    real(dp) :: start_daysec
 
    type(filehistorymeshfieldcomp), pointer :: target_comp
    integer :: registered_comp_id_
    !---------------------------------------------------------------------------
 
    !-
    if ( comp_num >= component_num_max ) then
      log_error("FILE_base_meshfield_register_comp",*) 'Exceeding maximum number of components. Check!'
      call prc_abort
    end if
 
    comp_num = comp_num + 1
    registered_comp_id_ = comp_num
    if ( present(registered_comp_id) ) then
      registered_comp_id = registered_comp_id_
    end if
 
    target_comp => comp(registered_comp_id_)
    call target_comp%Init( mesh1d_, mesh2d_, mesh3d_, &
      meshcubedsphere2d_, meshcubedsphere3d_ ,        &
      dim_name_postfix_ )
 
    !-
    if ( registered_comp_id_ == 1 ) then
      default_comp => comp(registered_comp_id_)
 
      file_history_meshfield_startdate(:) = time_nowdate
      file_history_meshfield_startsubsec  = time_nowsubsec
 
      start_daysec = time_startdaysec
      if ( time_nowdate(1) > 0 ) then
        write(file_history_meshfield_t_since,'(I4.4,5(A1,I2.2))') time_nowdate(1), &
                                                            '-', time_nowdate(2), &
                                                            '-', time_nowdate(3), &
                                                            ' ', time_nowdate(4), &
                                                            ':', time_nowdate(5), &
                                                            ':', time_nowdate(6)
        start_daysec = time_nowsubsec
      else
        file_history_meshfield_t_since = ''
      endif
 
      ! get calendar name
      call calendar_get_name( calendar )
 
      call file_history_setup( file_history_meshfiled_h_title,        & ! [IN]
        h_source, h_institute,                                        & ! [IN]
        start_daysec, time_dtsec,                                     & ! [IN]
        time_since = file_history_meshfield_t_since,                  & ! [IN]
        calendar = calendar,                                          & ! [IN]
        default_zcoord = 'model',                                     & ! [IN]
        myrank = prc_myrank                        )                    ! [IN]
 
      call file_history_set_nowdate( time_nowdate, time_nowsubsec, time_nowstep )
 
      file_history_filemeshfiled_disable = .false. 
    end if
 
    return
  end subroutine file_history_meshfield_setup
 
  !> Write history data to the file
!OCL SERIAL
  subroutine file_history_meshfield_write()
    implicit none
    !-------------------------------------------------
 
    call file_history_write
    return
  end subroutine file_history_meshfield_write
 
  !> Finalize the file history module
!OCL SERIAL
  subroutine file_history_meshfield_finalize()
    implicit none
    !-------------------------------------------------
 
    call file_history_finalize()
    call default_comp%Final()
    return
  end subroutine file_history_meshfield_finalize
 
  !-- 1D
 
!OCL SERIAL
  subroutine file_history_meshfield_put1d(hstid, field1d, &
    registered_comp_id )
    use scale_file_common_meshfield, only: &
      file_common_meshfield_put_field1d_cartesbuf
    implicit none
    integer, intent(in) :: hstid
    class(meshfield1d), intent(in) :: field1d
    integer, intent(in), optional :: registered_comp_id
 
    logical :: do_put
    integer :: ldomID
    real(RP), allocatable :: buf(:)
 
    type(filehistorymeshfieldcomp), pointer :: target_comp
    !---------------------------------------------------------------------------
 
    call history_get_comp( registered_comp_id, & ! (in)
      target_comp ) ! (out)
    
    call file_history_query( hstid, do_put )
    if ( .not. do_put ) return
 
    !-
#ifdef _OPENACC
    do ldomid=1, field1d%mesh%LOCAL_MESH_NUM
      !$acc update host( field1d%local(ldomID)%val ) async(1)
    end do
    !$acc wait(1)
#endif    
    !-
    allocate( buf(target_comp%dims1D_size(1)) )
 
    call file_common_meshfield_put_field1d_cartesbuf( target_comp%mesh1D, field1d, buf )
    call file_history_put( hstid, buf )
 
    return
  end subroutine file_history_meshfield_put1d
 
!OCL SERIAL
  subroutine file_history_meshfield_in1d( field1d, desc, standard_name, &
    registered_comp_id )
    implicit none
    class(meshfield1d), intent(in) :: field1d
    character(len=*), intent(in) :: desc                     !< description of the item
    character(len=*), intent(in), optional :: standard_name
    integer, intent(in), optional :: registered_comp_id
 
    integer :: hstid
    logical :: do_put
    !-------------------------------------------------
 
    call history_in_regvar( hstid, do_put,    & ! (out)
      field1d, desc, 1, standard_name, 'XYZ'  ) ! (in)
 
    if ( do_put ) call file_history_meshfield_put( hstid, field1d, registered_comp_id )
 
    return
  end subroutine file_history_meshfield_in1d
  
  !-- 2D
 
!OCL SERIAL
  subroutine file_history_meshfield_put2d(hstid, field2d, &
    registered_comp_id )
    use scale_file_common_meshfield, only: &
      file_common_meshfield_put_field2d_cartesbuf,            &
      file_common_meshfield_put_field2d_cubedsphere_cartesbuf
 
    implicit none
    integer, intent(in) :: hstid
    class(meshfield2d), intent(in) :: field2d
    integer, intent(in), optional :: registered_comp_id
 
    logical :: do_put
    integer :: ldomID
    real(RP), allocatable :: buf(:,:)
    
    type(filehistorymeshfieldcomp), pointer :: target_comp
    !---------------------------------------------------------------------------
 
    call history_get_comp( registered_comp_id, & ! (in)
      target_comp ) ! (out)
    
    call file_history_query( hstid, do_put )
    if ( .not. do_put ) return
 
    !-
#ifdef _OPENACC
    do ldomid=1, field2d%mesh%LOCAL_MESH_NUM
      !$acc update host( field2d%local(ldomID)%val ) async(1)
    end do
    !$acc wait(1)
#endif    
    allocate( buf(target_comp%dims2D_size(1),target_comp%dims2D_size(2)) )
    
    if ( associated(target_comp%mesh2D) ) then
      call file_common_meshfield_put_field2d_cartesbuf( target_comp%mesh2D, field2d, buf )
    else if ( associated(target_comp%meshCubedSphere2D) ) then
      call file_common_meshfield_put_field2d_cubedsphere_cartesbuf( &
        target_comp%meshCubedSphere2D, field2d, buf )
    end if
    call file_history_put( hstid, buf )
 
    return
  end subroutine file_history_meshfield_put2d
 
!OCL SERIAL
  subroutine file_history_meshfield_in2d( field2d, desc, standard_name, &
    registered_comp_id )
    implicit none
    class(meshfield2d), intent(in) :: field2d
    character(len=*), intent(in) :: desc                     !< description of the item
    character(len=*), intent(in), optional :: standard_name
    integer, intent(in), optional :: registered_comp_id
 
    integer :: hstid
    logical :: do_put
    !-------------------------------------------------
 
    call history_in_regvar( hstid, do_put,  & ! (out)
      field2d, desc, 2, standard_name, 'XY' ) ! (in)
 
    if ( do_put ) call file_history_meshfield_put( hstid, field2d, registered_comp_id )
 
    return
  end subroutine file_history_meshfield_in2d
 
  !-- 3D
 
!OCL SERIAL
  subroutine file_history_meshfield_put3d(hstid, field3d, &
    registered_comp_id )
    use scale_file_common_meshfield, only: &
      file_common_meshfield_put_field3d_cartesbuf,            &
      file_common_meshfield_put_field3d_cubedsphere_cartesbuf
 
    implicit none
    integer, intent(in) :: hstid
    class(meshfield3d), intent(in) :: field3d
    integer, intent(in), optional :: registered_comp_id
 
    logical :: do_put
    integer :: ldomID
    real(RP), allocatable :: buf(:,:,:)
 
    type(filehistorymeshfieldcomp), pointer :: target_comp
    !---------------------------------------------------------------------------
 
    call history_get_comp( registered_comp_id, & ! (in)
      target_comp ) ! (out)
 
    call file_history_query( hstid, do_put )
    if ( .not. do_put ) return
 
    !-
#ifdef _OPENACC
    do ldomid=1, field3d%mesh%LOCAL_MESH_NUM
      !$acc update host( field3d%local(ldomID)%val ) async(1)
    end do
    !$acc wait(1)
#endif
 
    allocate( buf(target_comp%dims3D_size(1,1),target_comp%dims3D_size(2,1),target_comp%dims3D_size(3,1)) )
 
    if ( associated(target_comp%mesh3D) ) then
      call file_common_meshfield_put_field3d_cartesbuf( target_comp%mesh3D, field3d, buf )
    else if ( associated(target_comp%meshCubedSphere3D) ) then
      call file_common_meshfield_put_field3d_cubedsphere_cartesbuf( &
        target_comp%meshCubedSphere3D, field3d, buf )
    end if
    call file_history_put( hstid, buf )
 
    return
  end subroutine file_history_meshfield_put3d
  
!OCL SERIAL
  subroutine file_history_meshfield_in3d( field3d, desc, standard_name, &
    registered_comp_id )
    implicit none
    class(meshfield3d), intent(in) :: field3d
    character(len=*), intent(in) :: desc                     !< description of the item
    character(len=*), intent(in), optional :: standard_name
    integer, intent(in), optional :: registered_comp_id
 
    integer :: hstid
    logical :: do_put
    !-------------------------------------------------
 
    call history_in_regvar( hstid, do_put,   & ! (out)
      field3d, desc, 3, standard_name, 'XYZ' ) ! (in)
 
    if ( do_put ) call file_history_meshfield_put( hstid, field3d, registered_comp_id )
 
    return
  end subroutine file_history_meshfield_in3d
 
!- Private subroutines ---------------
 
!OCL SERIAL
  subroutine history_in_regvar( hstid, do_put,  &
    field, desc, ndim, standard_name, dim_type  )
 
    use scale_file_history, only: &
      file_history_reg
    
    implicit none
 
    integer, intent(out) :: hstid
    logical, intent(out) :: do_put
    class(meshfieldbase), intent(in) :: field  
    character(len=*), intent(in) :: desc       !< description of the item
    integer, intent(in)          :: ndim
    character(len=*), intent(in), optional :: standard_name
    character(len=*), intent(in), optional :: dim_type
 
    logical, parameter     :: fill_halo = .false.
    !------------------------------------------------------
 
    hstid = -1
    do_put = .false.
 
    if ( file_history_filemeshfiled_disable ) return
 
    ! Check whether the item has been already registered
    call file_history_reg( field%varname, desc, field%unit, & ! [IN]
                           hstid,                           & ! [OUT]
                           standard_name=standard_name,     & ! [IN]
                           ndims=ndim,                      & ! [IN]
                           dim_type=dim_type,               & ! [IN]
                           fill_halo=fill_halo              ) ! [IN]
    
    if ( hstid < 0 ) return
 
    ! Check whether it is time to input the item
    call file_history_query( hstid, do_put ) ! [IN], [OUT]
    
    return
  end subroutine history_in_regvar
 
!OCL SERIAL
  subroutine history_get_comp( comp_id, & ! (in)
    comp_ptr ) ! (out)
    implicit none
    integer, intent(in), optional :: comp_id
    type(filehistorymeshfieldcomp), intent(out), pointer :: comp_ptr
    !--------------------------------------------------------------
 
    if ( .not. present(comp_id) ) then
      comp_ptr => default_comp
      return
    end if
 
    if ( comp_id < 1 .or. comp_id > comp_num ) then
      log_error("FILE_history_get_comp",*) 'Invalid component ID. Check!'
      call prc_abort
    end if
    comp_ptr => comp(comp_id)
    return
  end subroutine history_get_comp
 
!OCL SERIAL
  subroutine set_dim_axis1d( comp )
    use scale_file_common_meshfield, only: &
      file_common_meshfield_diminfo,    &
      file_common_meshfield_get_dims1d, &
      file_common_meshfield_get_axis1d
    use scale_mesh_base1d, only: &
      dimtype_num => meshbase1d_dimtype_num, &
      dimtype_x   => meshbase1d_dimtypeid_x
  
    implicit none
    class(filehistorymeshfieldcomp), intent(inout) :: comp
 
    type(file_common_meshfield_diminfo) :: dimsinfo(DIMTYPE_NUM)
    real(RP), allocatable :: x(:)
    integer :: start(1,1), count(1,1)
    character(len=H_SHORT) :: dims(1,1)
    integer :: n, ndim
    !-------------------------------------------------
    
    call file_common_meshfield_get_dims1d( comp%mesh1D, comp%dim_name_postfix, & ! (in)
      dimsinfo    )                                                              ! (out)
    
    comp%dims1D_size(1) = dimsinfo(dimtype_x)%size
    allocate( x(comp%dims1D_size(1)) )
    call file_common_meshfield_get_axis1d( comp%mesh1D, dimsinfo, & ! (in)
      x )                                                           ! (out)
 
    start(:,:) = 1
    do n=1, dimtype_num
      ndim = dimsinfo(n)%ndim
      dims(1:ndim,1)  = dimsinfo(n)%dims(1:ndim)
      count(1:ndim,1) = dimsinfo(n)%count(1:ndim)
      call file_history_set_dim ( dimsinfo(n)%type, ndim, 1, dims(1:ndim,:), zs(:), start(1:ndim,:), count(1:ndim,:))
    end do
    
    call file_history_set_axis( dimsinfo(dimtype_x)%name, dimsinfo(dimtype_x)%desc, &
      dimsinfo(dimtype_x)%unit, dimsinfo(dimtype_x)%name, x )
 
    return
  end subroutine set_dim_axis1d
 
!OCL SERIAL
  subroutine set_dim_axis2d( comp )
    use scale_file_common_meshfield, only: &
      file_common_meshfield_diminfo,       &
      file_common_meshfield_get_dims2d,    &
      file_common_meshfield_get_axis2d
    use scale_mesh_base2d, only: &
      dimtype_num => meshbase2d_dimtype_num, &
      dimtype_x   => meshbase2d_dimtypeid_x, &
      dimtype_y   => meshbase2d_dimtypeid_y
   
    implicit none
    class(filehistorymeshfieldcomp), intent(inout) :: comp
 
    type(file_common_meshfield_diminfo) :: dimsinfo(DIMTYPE_NUM)
    real(RP), allocatable :: x(:), y(:)
    integer :: start(2,1), count(2,1)
    character(len=H_SHORT) :: dims(2,1)
    integer :: n, ndim
    !-------------------------------------------------
    
    call file_common_meshfield_get_dims2d( comp%mesh2D, comp%dim_name_postfix, & ! (in)
      dimsinfo    )                                                              ! (out)
    
    comp%dims2D_size(1) = dimsinfo(dimtype_x)%size
    comp%dims2D_size(2) = dimsinfo(dimtype_y)%size
    allocate( x(comp%dims2D_size(1)), y(comp%dims2D_size(2)) )
    call file_common_meshfield_get_axis2d( comp%mesh2D, dimsinfo, & ! (in)
      x, y )                                                        ! (out)
 
    start(:,:) = 1
 
    do n=1, dimtype_num
      ndim = dimsinfo(n)%ndim
      dims(1:ndim,1)  = dimsinfo(n)%dims(1:ndim)
      count(1:ndim,1) = dimsinfo(n)%count(1:ndim)
      call file_history_set_dim ( dimsinfo(n)%type, ndim, 1, dims(1:ndim,:), zs(:), start(1:ndim,:), count(1:ndim,:))
    end do
    
    call file_history_set_axis( dimsinfo(dimtype_x)%name, dimsinfo(dimtype_x)%desc, dimsinfo(dimtype_x)%unit, dimsinfo(dimtype_x)%name, x(:))
    call file_history_set_axis( dimsinfo(dimtype_y)%name, dimsinfo(dimtype_y)%desc, dimsinfo(dimtype_y)%unit, dimsinfo(dimtype_y)%name, y(:))
    
    return
  end subroutine set_dim_axis2d
 
!OCL SERIAL
  subroutine set_dim_axis3d( comp )
    use scale_file_common_meshfield, only: &
      file_common_meshfield_diminfo,       &
      file_common_meshfield_get_dims3d,    &
      file_common_meshfield_get_axis3d
    use scale_mesh_base3d, only: &
      dimtype_num => meshbase3d_dimtype_num, &
      dimtype_x   => meshbase3d_dimtypeid_x, &
      dimtype_y   => meshbase3d_dimtypeid_y, &
      dimtype_z   => meshbase3d_dimtypeid_z
 
    implicit none
    class(filehistorymeshfieldcomp), intent(inout) :: comp
 
    type(file_common_meshfield_diminfo) :: dimsinfo(DIMTYPE_NUM)
    real(RP), allocatable :: x(:), y(:), z(:)
    integer :: start(3,1), count(3,1)
    character(len=H_SHORT) :: dims(3,1)
    integer :: n, ndim
    !-------------------------------------------------
    
    call file_common_meshfield_get_dims3d( comp%mesh3D, comp%dim_name_postfix, & ! (in)
      dimsinfo    )                                                              ! (out)
  
    comp%dims2D_size(1) = dimsinfo(dimtype_x)%size
    comp%dims2D_size(2) = dimsinfo(dimtype_y)%size  
    comp%dims3D_size(1,1) = dimsinfo(dimtype_x)%size
    comp%dims3D_size(2,1) = dimsinfo(dimtype_y)%size
    comp%dims3D_size(3,1) = dimsinfo(dimtype_z)%size
    allocate( x(comp%dims3D_size(1,1)), y(comp%dims3D_size(2,1)), z(comp%dims3D_size(3,1)) )
    call file_common_meshfield_get_axis3d( comp%mesh3D, dimsinfo, & ! (in)
      x, y, z )                                                     ! (out)
 
    start(:,:) = 1
    do n=1, dimtype_num
      ndim = dimsinfo(n)%ndim
      dims(1:ndim,1)  = dimsinfo(n)%dims(1:ndim)
      count(1:ndim,1) = dimsinfo(n)%count(1:ndim)
      call file_history_set_dim ( dimsinfo(n)%type, ndim, 1, dims(1:ndim,:), zs(:), start(1:ndim,:), count(1:ndim,:))
    end do
    
    call file_history_set_axis( dimsinfo(dimtype_x)%name, dimsinfo(dimtype_x)%desc, dimsinfo(dimtype_x)%unit, dimsinfo(dimtype_x)%name, x(:) )
    call file_history_set_axis( dimsinfo(dimtype_y)%name, dimsinfo(dimtype_y)%desc, dimsinfo(dimtype_y)%unit, dimsinfo(dimtype_y)%name, y(:) )
    call file_history_set_axis( dimsinfo(dimtype_z)%name, dimsinfo(dimtype_z)%desc, dimsinfo(dimtype_z)%unit, dimsinfo(dimtype_z)%name, z(:), &
      down=dimsinfo(dimtype_z)%positive_down(1) )
 
    return
  end subroutine set_dim_axis3d
 
!OCL SERIAL
  subroutine set_dim_axis2d_cubedsphere( comp )
    use scale_file_common_meshfield, only: &
      file_common_meshfield_diminfo,  &
      file_common_meshfield_get_dims, &
      file_common_meshfield_get_axis
    use scale_mesh_base2d, only: &
      dimtype_num => meshbase2d_dimtype_num, &
      dimtype_x  => meshbase2d_dimtypeid_x,  &
      dimtype_y  => meshbase2d_dimtypeid_y
 
    implicit none
    class(filehistorymeshfieldcomp), intent(inout) :: comp
 
    type(file_common_meshfield_diminfo) :: dimsinfo(DIMTYPE_NUM)
    real(RP), allocatable :: x(:), y(:)
    integer :: start(2,1), count(2,1)
    character(len=H_SHORT) :: dims(2,1)
    integer :: n, ndim
    !-------------------------------------------------
    
    call file_common_meshfield_get_dims( comp%meshCubedSphere2D, comp%dim_name_postfix, & ! (in)
      dimsinfo    )                                                                       ! (out)
    
    comp%dims2D_size(1) = dimsinfo(dimtype_x)%size
    comp%dims2D_size(2) = dimsinfo(dimtype_y)%size
    allocate( x(comp%dims2D_size(1)), y(comp%dims2D_size(2)) )
    
    call file_common_meshfield_get_axis( comp%meshCubedSphere2D, dimsinfo, & ! (in)
      x, y )                                                                 ! (out)
    
    start(:,:) = 1
 
    do n=1, dimtype_num
      ndim = dimsinfo(n)%ndim
      dims(1:ndim,1)  = dimsinfo(n)%dims(1:ndim)
      count(1:ndim,1) = dimsinfo(n)%count(1:ndim)
      call file_history_set_dim ( dimsinfo(n)%type, ndim, 1, dims(1:ndim,:), zs(:), start(1:ndim,:), count(1:ndim,:))
    end do
    
    call file_history_set_axis( dimsinfo(dimtype_x)%name, dimsinfo(dimtype_x)%desc, dimsinfo(dimtype_x)%unit, dimsinfo(dimtype_x)%name, x )
    call file_history_set_axis( dimsinfo(dimtype_y)%name, dimsinfo(dimtype_y)%desc, dimsinfo(dimtype_y)%unit, dimsinfo(dimtype_y)%name, y )
    
    return
  end subroutine set_dim_axis2d_cubedsphere
 
!OCL SERIAL
  subroutine set_dim_axis3d_cubedsphere( comp )
    use scale_file_common_meshfield, only: &
      file_common_meshfield_diminfo,  &
      file_common_meshfield_get_dims, &
      file_common_meshfield_get_axis
    use scale_mesh_base3d, only: &
      dimtype_num => meshbase3d_dimtype_num, &
      dimtype_x   => meshbase3d_dimtypeid_x, &
      dimtype_y   => meshbase3d_dimtypeid_y, &
      dimtype_z   => meshbase3d_dimtypeid_z
 
    implicit none
    class(filehistorymeshfieldcomp), intent(inout) :: comp
 
    type(file_common_meshfield_diminfo) :: dimsinfo(DIMTYPE_NUM)
    real(RP), allocatable :: x(:), y(:), z(:)
    integer :: start(3,1), count(3,1)
    character(len=H_SHORT) :: dims(3,1)
    integer :: n, ndim
    !-------------------------------------------------
    
    call file_common_meshfield_get_dims( comp%meshCubedSphere3D, comp%dim_name_postfix, & ! (in)
      dimsinfo    )                                                                       ! (out)
 
    comp%dims2D_size(1) = dimsinfo(dimtype_x)%size
    comp%dims2D_size(2) = dimsinfo(dimtype_y)%size
    comp%dims3D_size(1,1) = dimsinfo(dimtype_x)%size
    comp%dims3D_size(2,1) = dimsinfo(dimtype_y)%size
    comp%dims3D_size(3,1) = dimsinfo(dimtype_z)%size
    allocate( x(comp%dims3D_size(1,1)), y(comp%dims3D_size(2,1)), z(comp%dims3D_size(3,1)) )
    call file_common_meshfield_get_axis( comp%meshCubedSphere3D, dimsinfo, & ! (in)
      x, y, z )                                                              ! (out)
 
    start(:,:) = 1
    do n=1, dimtype_num
      ndim = dimsinfo(n)%ndim
      dims(1:ndim,1)  = dimsinfo(n)%dims(1:ndim)
      count(1:ndim,1) = dimsinfo(n)%count(1:ndim)
      call file_history_set_dim ( dimsinfo(n)%type, ndim, 1, dims(1:ndim,:), zs(:), start(1:ndim,:), count(1:ndim,:))
    end do
    
    call file_history_set_axis( dimsinfo(dimtype_x)%name, dimsinfo(dimtype_x)%desc, dimsinfo(dimtype_x)%unit, dimsinfo(dimtype_x)%name, x )
    call file_history_set_axis( dimsinfo(dimtype_y)%name, dimsinfo(dimtype_y)%desc, dimsinfo(dimtype_y)%unit, dimsinfo(dimtype_y)%name, y )
    call file_history_set_axis( dimsinfo(dimtype_z)%name, dimsinfo(dimtype_z)%desc, dimsinfo(dimtype_z)%unit, dimsinfo(dimtype_z)%name, z, &
      down=dimsinfo(dimtype_z)%positive_down(1) )
      
    return
  end subroutine set_dim_axis3d_cubedsphere
 
!----------------
 
end module scale_file_history_meshfield