mod_realinput_scale.F90

Go to the documentation of this file.

!-------------------------------------------------------------------------------
#include "scalelib.h"
module mod_realinput_scale
  !-----------------------------------------------------------------------------
  !
  !++ used modules
  !
  use scale_precision
  use scale_io
  use scale_tracer
  use scale_cpl_sfc_index
  !-----------------------------------------------------------------------------
  implicit none
  private
  !-----------------------------------------------------------------------------
  !
  !++ Public procedure
  !
  public :: parentatmossetupscale
  public :: parentatmosopenscale
  public :: parentatmosinputscale
  public :: parentlandsetupscale
  public :: parentlandinputscale
  public :: parentoceansetupscale
  public :: parentoceanopenscale
  public :: parentoceaninputscale
 
  !-----------------------------------------------------------------------------
  !
  !++ Public parameters & variables
  !
  !-----------------------------------------------------------------------------
  !
  !++ Private procedure
  !
  !-----------------------------------------------------------------------------
  !
  !++ Private parameters & variables
  !
  integer,  private, parameter   :: handle = 1
 
  real(RP), private, allocatable :: read2D (:,:)
  real(RP), private, allocatable :: read3D (:,:,:)
  real(RP), private, allocatable :: read3DL(:,:,:)
  real(RP), private, allocatable :: read3DO(:,:,:)
 
  ! mapping info
  real(RP), private, allocatable :: rotc_cos(:,:), rotc_sin(:,:)
 
  !-----------------------------------------------------------------------------
contains
  !-----------------------------------------------------------------------------
  subroutine parentatmossetupscale( &
       dims )
    use scale_comm_cartesc_nest, only: &
       parent_kmax,                                     &
       parent_imax,                                     &
       parent_jmax,                                     &
       nest_tile_num_x => comm_cartesc_nest_tile_num_x, &
       nest_tile_num_y => comm_cartesc_nest_tile_num_y
    implicit none
 
    integer, intent(out) :: dims(6)
    !---------------------------------------------------------------------------
 
    log_info("ParentAtmosSetupSCALE",*) 'Real Case/Atmos Input File Type: SCALE-RM'
 
    ! full level
    dims(1) = parent_kmax(handle)
    dims(2) = parent_imax(handle) * nest_tile_num_x
    dims(3) = parent_jmax(handle) * nest_tile_num_y
    ! half level
    dims(4) = dims(1)
    dims(5) = dims(2)
    dims(6) = dims(3)
 
    allocate( read2d(        parent_imax(handle),parent_jmax(handle)) )
    allocate( read3d(dims(1),parent_imax(handle),parent_jmax(handle)) )
 
    allocate( rotc_cos(dims(2),dims(3)), rotc_sin(dims(2),dims(3)) )
 
    return
  end subroutine parentatmossetupscale
 
  !-----------------------------------------------------------------------------
  subroutine parentatmosopenscale( &
       lon_org,      &
       lat_org,      &
       cz_org,       &
       basename_org, &
       dims          )
    use scale_const, only: &
       d2r => const_d2r
    use scale_prc, only: &
       prc_abort
    use scale_comm_cartesc_nest, only: &
       parent_imax,                                     &
       parent_jmax,                                     &
       nest_tile_num_x => comm_cartesc_nest_tile_num_x, &
       nest_tile_id    => comm_cartesc_nest_tile_id
    use scale_file, only: &
       file_open, &
       file_get_attribute
    use scale_file_cartesc, only: &
       file_cartesc_read
    use scale_mapprojection, only: &
       mappinginfo, &
       mappingparam, &
       mapprojection_get_param, &
       mapprojection_rotcoef
    implicit none
 
    real(rp),         intent(out) :: lon_org(:,:)
    real(rp),         intent(out) :: lat_org(:,:)
    real(rp),         intent(out) :: cz_org (:,:,:)
    character(len=*), intent(in)  :: basename_org
    integer,          intent(in)  :: dims(6)
 
    ! mapping information
    character(len=H_SHORT) :: vname
    type(mappinginfo)  :: mapping_info
    type(mappingparam) :: mapping_param
 
    integer :: rank
    integer :: xloc, yloc
    integer :: xs, xe, ys, ye
 
    logical :: existed
 
    integer :: fid
    integer :: i, j
    !---------------------------------------------------------------------------
 
    do i = 1, size( nest_tile_id(:) )
       ! read data from split files
       rank = nest_tile_id(i)
 
       xloc = mod( i-1, nest_tile_num_x ) + 1
       yloc = int( real(i-1) / real(nest_tile_num_x) ) + 1
 
       xs = parent_imax(handle) * (xloc-1) + 1
       xe = parent_imax(handle) * xloc
       ys = parent_jmax(handle) * (yloc-1) + 1
       ye = parent_jmax(handle) * yloc
 
       call file_open( basename_org,                  & ! (in)
                       fid,                           & ! (out)
                       aggregate=.false., rankid=rank ) ! (in)
 
       call file_cartesc_read( fid, "lon", read2d(:,:) )
       lon_org(xs:xe,ys:ye) = read2d(:,:) * d2r
 
       call file_cartesc_read( fid, "lat", read2d(:,:) )
       lat_org(xs:xe,ys:ye) = read2d(:,:) * d2r
 
       call file_cartesc_read( fid, "height", read3d(:,:,:) )
       cz_org(3:dims(1)+2,xs:xe,ys:ye) = read3d(:,:,:)
 
       call file_cartesc_read( fid, "topo", read2d(:,:), existed=existed )
       cz_org(2,xs:xe,ys:ye) = read2d(:,:)
 
       if ( i == 1 ) then
          call file_get_attribute( fid, "DENS", "grid_mapping", vname, existed=existed )
          if ( existed ) then
             call file_get_attribute( fid, vname, "grid_mapping_name", mapping_info%mapping_name )
             call file_get_attribute( fid, vname, "false_easting", mapping_info%false_easting, existed=existed )
             call file_get_attribute( fid, vname, "false_northing", mapping_info%false_northing, existed=existed )
             call file_get_attribute( fid, vname, "longitude_of_central_meridian", mapping_info%longitude_of_central_meridian, existed=existed )
             call file_get_attribute( fid, vname, "longitude_of_projection_origin", mapping_info%longitude_of_projection_origin, existed=existed )
             call file_get_attribute( fid, vname, "latitude_of_projection_origin", mapping_info%latitude_of_projection_origin, existed=existed )
             call file_get_attribute( fid, vname, "straight_vertical_longitude_from_pole", mapping_info%straight_vertical_longitude_from_pole, existed=existed )
             call file_get_attribute( fid, vname, "standard_parallel", mapping_info%standard_parallel(:), existed=existed )
             if ( .not. existed ) then
                call file_get_attribute( fid, vname, "standard_parallel", mapping_info%standard_parallel(1), existed=existed )
             end if
             call file_get_attribute( fid, vname, "rotation", mapping_info%rotation, existed=existed )
             if ( .not. existed ) mapping_info%rotation = 0.0_dp
          else
             mapping_info%mapping_name = ""
          end if
       end if
 
    end do
 
    cz_org(1,:,:) = 0.0_rp
 
    if ( mapping_info%mapping_name .ne. "" ) then
       call mapprojection_get_param( mapping_info, & ! (in)
                                     mapping_param ) ! (out)
       call mapprojection_rotcoef( dims(2), 1, dims(2), dims(3), 1, dims(3), &
                                   lon_org(:,:), lat_org(:,:),  & ! (in)
                                   mapping_info%mapping_name,   & ! (in)
                                   mapping_param,               & ! (in)
                                   rotc_cos(:,:), rotc_sin(:,:) ) ! (out)
    else
!OCL XFILL
       !$omp parallel do
       do j = 1, dims(3)
       do i = 1, dims(2)
          rotc_cos(i,j) = 1.0_rp
          rotc_sin(i,j) = 0.0_rp
       end do
       end do
    end if
 
    return
  end subroutine parentatmosopenscale
 
  !-----------------------------------------------------------------------------
  subroutine parentatmosinputscale( &
       velz_org,      &
       velx_org,      &
       vely_org,      &
       pres_org,      &
       dens_org,      &
       pott_org,      &
       qv_org,        &
       qtrc_org,      &
       cz_org,        &
       basename_org,  &
       sfc_diagnoses, &
       same_mptype,   &
       dims,          &
       it             )
    use scale_const, only: &
       undef => const_undef, &
       p00   => const_pre00, &
       cpdry => const_cpdry, &
       rdry  => const_rdry,  &
       grav  => const_grav,  &
       laps  => const_laps
    use scale_comm_cartesc, only: &
       comm_vars8, &
       comm_wait
    use scale_comm_cartesc_nest, only: &
       parent_imax,                                     &
       parent_jmax,                                     &
       nest_tile_num_x => comm_cartesc_nest_tile_num_x, &
       nest_tile_id    => comm_cartesc_nest_tile_id
    use scale_file, only: &
       file_open
    use scale_file_cartesc, only: &
       file_cartesc_read
    use scale_atmos_grid_cartesc_metric, only: &
       rotc => atmos_grid_cartesc_metric_rotc
    use scale_atmos_thermodyn, only: &
       thermodyn_specific_heat  => atmos_thermodyn_specific_heat, &
       thermodyn_rhot2temp_pres => atmos_thermodyn_rhot2temp_pres
    use scale_atmos_hydrometeor, only: &
       n_hyd,    &
       hyd_name, &
       num_name
    use mod_atmos_phy_mp_driver, only: &
       atmos_phy_mp_driver_qhyd2qtrc
    use mod_atmos_phy_mp_vars, only: &
       qa_mp, &
       qs_mp, &
       qe_mp
    implicit none
 
    real(rp),         intent(out) :: velz_org(:,:,:)
    real(rp),         intent(out) :: velx_org(:,:,:)
    real(rp),         intent(out) :: vely_org(:,:,:)
    real(rp),         intent(out) :: pres_org(:,:,:)
    real(rp),         intent(out) :: dens_org(:,:,:)
    real(rp),         intent(out) :: pott_org(:,:,:)
    real(rp),         intent(out) :: qv_org  (:,:,:)
    real(rp),         intent(out) :: qtrc_org(:,:,:,:)
    real(rp),         intent(in)  :: cz_org  (:,:,:)
    character(len=*), intent(in)  :: basename_org
    logical,          intent(in)  :: sfc_diagnoses
    logical,          intent(in)  :: same_mptype
    integer,          intent(in)  :: dims(6)
    integer,          intent(in)  :: it
 
    real(rp) :: momz_org(dims(1)+2,dims(2),dims(3))
    real(rp) :: momx_org(dims(1)+2,dims(2),dims(3))
    real(rp) :: momy_org(dims(1)+2,dims(2),dims(3))
    real(rp) :: rhot_org(dims(1)+2,dims(2),dims(3))
    real(rp) :: tsfc_org(          dims(2),dims(3))
    real(rp) :: qhyd_org(dims(1)+2,dims(2),dims(3),n_hyd)
    real(rp) :: qnum_org(dims(1)+2,dims(2),dims(3),n_hyd)
    real(rp) :: qdry    (dims(1)+2)
    real(rp) :: rtot    (dims(1)+2)
    real(rp) :: cvtot   (dims(1)+2)
    real(rp) :: cptot   (dims(1)+2)
    real(rp) :: temp_org(dims(1)+2)
    real(rp) :: dz
 
    real(rp) :: u, v
 
    integer  :: xs, xe
    integer  :: ys, ye
    integer  :: nx, ny
    integer  :: xloc, yloc
    integer  :: rank
 
    logical :: qnum_flag
 
    integer  :: fid
    logical  :: existed, existed_t2, existed_mslp
    integer  :: k, i, j, iq
    !---------------------------------------------------------------------------
 
    qnum_flag = .false.
 
    do i = 1, size( nest_tile_id(:) )
       ! read data from split files
       rank = nest_tile_id(i)
 
       xloc = mod( i-1, nest_tile_num_x ) + 1
       yloc = int( real(i-1) / real(nest_tile_num_x) ) + 1
 
       xs = parent_imax(handle) * (xloc-1) + 1
       xe = parent_imax(handle) * xloc
       ys = parent_jmax(handle) * (yloc-1) + 1
       ye = parent_jmax(handle) * yloc
 
       nx = xe - xs + 1
       ny = ye - ys + 1
 
       call file_open( basename_org,                  & ! (in)
                       fid,                           & ! (out)
                       aggregate=.false., rankid=rank ) ! (in)
 
       if ( sfc_diagnoses ) then
          call file_cartesc_read( fid, "T2", read2d(:,:), step=it, existed=existed_t2 )
          if ( existed_t2 ) then
!OCL XFILL
             tsfc_org(xs:xe,ys:ye) = read2d(:,:)
          end if
 
          call file_cartesc_read( fid, "MSLP", read2d(:,:), step=it, existed=existed_mslp )
          if ( existed_mslp ) then
!OCL XFILL
             pres_org(1,xs:xe,ys:ye) = read2d(:,:)
          end if
       end if
 
       call file_cartesc_read( fid, "DENS", read3d(:,:,:), step=it )
!OCL XFILL
       dens_org(3:dims(1)+2,xs:xe,ys:ye) = read3d(:,:,:)
 
       call file_cartesc_read( fid, "MOMZ", read3d(:,:,:), step=it )
!OCL XFILL
       momz_org(3:dims(1)+2,xs:xe,ys:ye) = read3d(:,:,:)
 
       call file_cartesc_read( fid, "MOMX", read3d(:,:,:), step=it )
!OCL XFILL
       momx_org(3:dims(1)+2,xs:xe,ys:ye) = read3d(:,:,:)
 
       call file_cartesc_read( fid, "MOMY", read3d(:,:,:), step=it )
!OCL XFILL
       momy_org(3:dims(1)+2,xs:xe,ys:ye) = read3d(:,:,:)
 
 
       call file_cartesc_read( fid, "RHOT", read3d(:,:,:), step=it )
!OCL XFILL
       rhot_org(3:dims(1)+2,xs:xe,ys:ye) = read3d(:,:,:)
 
 
       if ( same_mptype ) then
 
          do iq = qs_mp, qe_mp
             call file_cartesc_read( fid, tracer_name(iq), read3d(:,:,:), step=it )
!OCL XFILL
             qtrc_org(3:dims(1)+2,xs:xe,ys:ye,iq) = read3d(:,:,:)
!OCL XFILL
             qtrc_org(2,xs:xe,ys:ye,iq) = qtrc_org(3,xs:xe,ys:ye,iq)
!OCL XFILL
             qtrc_org(1,xs:xe,ys:ye,iq) = qtrc_org(3,xs:xe,ys:ye,iq)
          enddo
 
       else
 
!OCL XFILL
          do iq = 1, n_hyd
             qhyd_org(:,xs:xe,ys:ye,iq) = 0.0_rp
             qnum_org(:,xs:xe,ys:ye,iq) = 0.0_rp
          end do
 
          call file_cartesc_read( fid, "QV", read3d(:,:,:), step=it, existed=existed )
          if ( existed ) then
!OCL XFILL
             qv_org(3:dims(1)+2,xs:xe,ys:ye) = read3d(:,:,:)
!OCL XFILL
             qv_org(2,xs:xe,ys:ye) = qv_org(3,xs:xe,ys:ye)
!OCL XFILL
             qv_org(1,xs:xe,ys:ye) = qv_org(3,xs:xe,ys:ye)
          else
!OCL XFILL
             qv_org(:,:,:) = 0.0_rp
          end if
 
          do iq = 1, n_hyd
             call file_cartesc_read( fid, hyd_name(iq), read3d(:,:,:), step=it, existed=existed )
             if ( existed ) then
!OCL XFILL
                qhyd_org(3:dims(1)+2,xs:xe,ys:ye,iq) = read3d(:,:,:)
!OCL XFILL
                qhyd_org(2,xs:xe,ys:ye,iq) = qhyd_org(3,xs:xe,ys:ye,iq)
!OCL XFILL
                qhyd_org(1,xs:xe,ys:ye,iq) = qhyd_org(3,xs:xe,ys:ye,iq)
             else
!OCL XFILL
                qhyd_org(:,:,:,iq) = 0.0_rp
             end if
 
             ! number density
             call file_cartesc_read( fid, num_name(iq), read3d(:,:,:), step=it, existed=existed )
             if ( existed ) then
!OCL XFILL
                qnum_org(3:dims(1)+2,xs:xe,ys:ye,iq) = read3d(:,:,:)
!OCL XFILL
                qnum_org(2,xs:xe,ys:ye,iq) = qnum_org(3,xs:xe,ys:ye,iq)
!OCL XFILL
                qnum_org(1,xs:xe,ys:ye,iq) = qnum_org(3,xs:xe,ys:ye,iq)
                qnum_flag = .true.
             else
!OCL XFILL
                qnum_org(:,:,:,iq) = undef
             end if
          end do
 
       endif
 
!       call FILE_CARTESC_read( fid, "Q2", read2D(:,:), step=it )
!       qv_org(2,xs:xe,ys:ye) = read2D(:,:)
 
    end do
 
    ! convert from momentum to velocity
!OCL XFILL
    do j = 1, dims(3)
    do i = 1, dims(2)
    do k = 4, dims(1)+2
       velz_org(k,i,j) = ( momz_org(k-1,i,j) + momz_org(k,i,j) ) / dens_org(k,i,j) * 0.5_rp
    end do
    end do
    end do
!OCL XFILL
    do j = 1, dims(3)
    do i = 1, dims(2)
       velz_org(1:3    ,i,j) = 0.0_rp
       velz_org(dims(1)+2,i,j) = 0.0_rp
    end do
    end do
 
    ! convert from momentum to velocity
!OCL XFILL
    do j = 1, dims(3)
    do i = 2, dims(2)
    do k = 3, dims(1)+2
       velx_org(k,i,j) = ( momx_org(k,i-1,j) + momx_org(k,i,j) ) / dens_org(k,i,j) * 0.5_rp
    end do
    end do
    end do
!OCL XFILL
    do j = 1, dims(3)
    do k = 3, dims(1)+2
       velx_org(k,1,j) = momx_org(k,1,j) / dens_org(k,1,j)
    end do
    end do
    if ( sfc_diagnoses ) then
!OCL XFILL
       velx_org(1:2,:,:) = 0.0_rp
    else
!OCL XFILL
       velx_org(1:2,:,:) = undef
    end if
 
    ! convert from momentum to velocity
!OCL XFILL
    do j = 2, dims(3)
    do i = 1, dims(2)
    do k = 3, dims(1)+2
       vely_org(k,i,j) = ( momy_org(k,i,j-1) + momy_org(k,i,j) ) / dens_org(k,i,j) * 0.5_rp
    end do
    end do
    end do
!OCL XFILL
    do i = 1, dims(2)
    do k = 3, dims(1)+2
       vely_org(k,i,1) = momy_org(k,i,1) / dens_org(k,i,1)
    end do
    end do
    if ( sfc_diagnoses ) then
!OCL XFILL
       vely_org(1:2,:,:) = 0.0_rp
    else
!OCL XFILL
       vely_org(1:2,:,:) = undef
    end if
 
 
    ! rotation
    !$omp parallel do &
    !$omp private(u,v)
    do j = 1, dims(3)
    do i = 1, dims(2)
    do k = 1, dims(1)+2
       u = velx_org(k,i,j)
       v = vely_org(k,i,j)
       if ( u .ne. undef .and. v .ne.undef ) then
          velx_org(k,i,j) = u * rotc_cos(i,j) - v * rotc_sin(i,j)
          vely_org(k,i,j) = u * rotc_sin(i,j) + v * rotc_cos(i,j)
       else
          velx_org(k,i,j) = undef
          vely_org(k,i,j) = undef
       end if
    end do
    end do
    end do
 
 
    do iq = 1, size(qtrc_org,4)
       if ( iq >= qs_mp .and. iq <= qe_mp ) cycle
!OCL XFILL
       qtrc_org(:,:,:,iq) = 0.0_rp
    end do
 
    if ( qa_mp > 0 .AND. .NOT. same_mptype ) then
       if ( qnum_flag ) then
          call atmos_phy_mp_driver_qhyd2qtrc( dims(1)+2, 1, dims(1)+2, dims(2), 1, dims(2), dims(3), 1, dims(3), &
                                              qv_org(:,:,:), qhyd_org(:,:,:,:), & ! [IN]
                                              qtrc_org(:,:,:,qs_mp:qe_mp),      & ! [OUT]
                                              qnum=qnum_org(:,:,:,:)            ) ! [IN]
       else
          call atmos_phy_mp_driver_qhyd2qtrc( dims(1)+2, 1, dims(1)+2, dims(2), 1, dims(2), dims(3), 1, dims(3), &
                                              qv_org(:,:,:), qhyd_org(:,:,:,:), & ! [IN]
                                              qtrc_org(:,:,:,qs_mp:qe_mp)       ) ! [OUT]
       end if
    end if
 
    !$omp parallel do default(none) &
    !$omp private(dz,temp_org,qdry,rtot,cvtot,cptot) &
    !$omp shared(dims,QA,UNDEF,LAPS,P00,Rdry,CPdry,GRAV,TRACER_MASS,TRACER_R,TRACER_CV,TRACER_CP, &
    !$omp        dens_org,rhot_org,qtrc_org,pres_org,pott_org,tsfc_org,cz_org, &
    !$omp        existed_t2,existed_mslp,sfc_diagnoses)
    do j = 1, dims(3)
    do i = 1, dims(2)
 
       ! diagnose temp and pres
       call thermodyn_specific_heat( dims(1)+2, 3, dims(1)+2, qa,                             & ! [IN]
                                     qtrc_org(:,i,j,:),                                       & ! [IN]
                                     tracer_mass(:), tracer_r(:), tracer_cv(:), tracer_cp(:), & ! [IN]
                                     qdry(:), rtot(:), cvtot(:), cptot(:)                     ) ! [OUT]
 
       call thermodyn_rhot2temp_pres( dims(1), 1, dims(1),                                       & ! [IN]
                                      dens_org(3:dims(1)+2,i,j), rhot_org(3:dims(1)+2,i,j),      & ! [IN]
                                      rtot(3:dims(1)+2), cvtot(3:dims(1)+2), cptot(3:dims(1)+2), & ! [IN]
                                      temp_org(3:dims(1)+2), pres_org(3:dims(1)+2,i,j)           ) ! [OUT]
 
!OCL XFILL
       do k = 3, dims(1)+2
          pott_org(k,i,j) = rhot_org(k,i,j) / dens_org(k,i,j)
       end do
 
       if ( sfc_diagnoses ) then
          ! at the surface
          dz = cz_org(3,i,j) - cz_org(2,i,j)
 
          if ( .not. existed_t2 ) then
             tsfc_org(i,j) = temp_org(3) + laps * dz
          end if
          dens_org(2,i,j) = ( pres_org(3,i,j) + grav * dens_org(3,i,j) * dz * 0.5_rp ) &
                          / ( rdry * tsfc_org(i,j) - grav * dz * 0.5_rp )
          pres_org(2,i,j) = dens_org(2,i,j) * rdry * tsfc_org(i,j)
          pott_org(2,i,j) = tsfc_org(i,j) * ( p00 / pres_org(2,i,j) )**(rdry/cpdry)
 
          ! at the sea-level
          temp_org(1) = tsfc_org(i,j) + laps * cz_org(2,i,j)
          if ( existed_mslp ) then
             pott_org(1,i,j) = temp_org(1) * ( p00 / pres_org(1,i,j) )**(rdry/cpdry)
             dens_org(1,i,j) = pres_org(1,i,j) / ( rdry * temp_org(1) )
          else
             dens_org(1,i,j) = ( pres_org(2,i,j) + grav * dens_org(2,i,j) * cz_org(2,i,j) * 0.5_rp ) &
                             / ( rdry * temp_org(1) - grav * cz_org(2,i,j) * 0.5_rp )
             pres_org(1,i,j) = dens_org(1,i,j) * rdry * temp_org(1)
             pott_org(1,i,j) = temp_org(1) * ( p00 / pres_org(1,i,j) )**(rdry/cpdry)
          end if
       else
          dens_org(1:2,i,j) = undef
          pres_org(1:2,i,j) = undef
          pott_org(1:2,i,j) = undef
       end if
 
    end do
    end do
 
    return
  end subroutine parentatmosinputscale
 
  !-----------------------------------------------------------------------------
  subroutine parentlandsetupscale( &
       ldims )
    use scale_comm_cartesc_nest, only: &
       parent_imax,                                     &
       parent_jmax,                                     &
       parent_lkmax,                                    &
       nest_tile_num_x => comm_cartesc_nest_tile_num_x, &
       nest_tile_num_y => comm_cartesc_nest_tile_num_y
    implicit none
 
    integer, intent(out) :: ldims(3)
    !---------------------------------------------------------------------------
 
    log_info("ParentLandSetupSCALE",*) 'Real Case/Land Input File Type: SCALE-RM'
 
    ldims(1) = parent_lkmax(handle)
    ldims(2) = parent_imax(handle) * nest_tile_num_x
    ldims(3) = parent_jmax(handle) * nest_tile_num_y
 
    if ( .NOT. allocated(read2d) ) then
       allocate( read2d(parent_imax(handle),parent_jmax(handle)) )
    endif
 
    allocate( read3dl(ldims(1),parent_imax(handle),parent_jmax(handle)) )
 
    return
  end subroutine parentlandsetupscale
 
  !-----------------------------------------------------------------------------
  subroutine parentlandinputscale( &
      tg_org,             &
      strg_org,           &
      lst_org,            &
      ust_org,            &
      albg_org,           &
      topo_org,           &
      lmask_org,          &
      llon_org,           &
      llat_org,           &
      lz_org,             &
      basename_land,      &
      ldims,              &
      use_file_landwater, &
      it                  )
    use scale_const, only: &
       undef => const_undef, &
       d2r   => const_d2r
    use scale_comm_cartesc_nest, only: &
       parent_imax,                                     &
       parent_jmax,                                     &
       nest_tile_num_x => comm_cartesc_nest_tile_num_x, &
       nest_tile_id    => comm_cartesc_nest_tile_id
    use scale_file, only: &
       file_open, &
       file_read, &
       file_get_datainfo
    use scale_file_cartesc, only: &
       file_cartesc_read
    implicit none
 
    real(rp),         intent(out) :: tg_org   (:,:,:)
    real(rp),         intent(out) :: strg_org (:,:,:)
    real(rp),         intent(out) :: lst_org  (:,:)
    real(rp),         intent(out) :: ust_org  (:,:)
    real(rp),         intent(out) :: albg_org (:,:,:,:)
    real(rp),         intent(out) :: topo_org (:,:)
    real(rp),         intent(out) :: lmask_org(:,:)
    real(rp),         intent(out) :: llon_org (:,:)
    real(rp),         intent(out) :: llat_org (:,:)
    real(rp),         intent(out) :: lz_org   (:)
    character(len=*), intent(in)  :: basename_land
    integer,          intent(in)  :: ldims(3)
    logical,          intent(in)  :: use_file_landwater ! use land water data from files
    integer,          intent(in)  :: it
 
    integer :: rank
    integer :: fid
    integer :: xloc, yloc
    integer :: xs, xe
    integer :: ys, ye
    logical :: existed
 
    integer :: i
    !---------------------------------------------------------------------------
 
    do i = 1, size( nest_tile_id(:) )
       ! read data from split files
       rank = nest_tile_id(i)
 
       xloc = mod( i-1, nest_tile_num_x ) + 1
       yloc = int( real(i-1) / real(nest_tile_num_x) ) + 1
 
       xs = parent_imax(handle) * (xloc-1) + 1
       xe = parent_imax(handle) * xloc
       ys = parent_jmax(handle) * (yloc-1) + 1
       ye = parent_jmax(handle) * yloc
 
       call file_open( basename_land,                 & ! (in)
                       fid,                           & ! (out)
                       aggregate=.false., rankid=rank ) ! (in)
 
       call file_cartesc_read( fid, "LAND_TEMP",  read3dl(:,:,:), step=it )
       tg_org(1:ldims(1),xs:xe,ys:ye) = read3dl(:,:,:)
 
       if( use_file_landwater )then
          call file_cartesc_read( fid, "LAND_WATER", read3dl(:,:,:), step=it )
          strg_org(1:ldims(1),xs:xe,ys:ye) = read3dl(:,:,:)
       endif
 
       call file_cartesc_read( fid, "lon", read2d(:,:) )
       llon_org(xs:xe,ys:ye)  = read2d(:,:) * d2r
 
       call file_cartesc_read( fid, "lat", read2d(:,:) )
       llat_org(xs:xe,ys:ye)  = read2d(:,:) * d2r
 
       call file_cartesc_read( fid, "LAND_SFC_TEMP", read2d(:,:), step=it )
       lst_org(xs:xe,ys:ye) = read2d(:,:)
 
       call file_get_datainfo( fid, "URBAN_SFC_TEMP", istep=it, existed=existed )
       if ( existed ) then
          call file_cartesc_read( fid, "URBAN_SFC_TEMP", read2d(:,:), step=it )
          ust_org(xs:xe,ys:ye) = read2d(:,:)
       else
          ust_org(xs:xe,ys:ye) = undef
       end if
 
       call file_cartesc_read( fid, "LAND_SFC_ALB_IR_dir", read2d(:,:), step=it )
       albg_org(xs:xe,ys:ye,i_r_direct ,i_r_ir ) = read2d(:,:)
 
       call file_cartesc_read( fid, "LAND_SFC_ALB_IR_dif", read2d(:,:), step=it )
       albg_org(xs:xe,ys:ye,i_r_diffuse,i_r_ir ) = read2d(:,:)
 
       call file_cartesc_read( fid, "LAND_SFC_ALB_NIR_dir", read2d(:,:), step=it )
       albg_org(xs:xe,ys:ye,i_r_direct ,i_r_nir) = read2d(:,:)
 
       call file_cartesc_read( fid, "LAND_SFC_ALB_NIR_dif", read2d(:,:), step=it )
       albg_org(xs:xe,ys:ye,i_r_diffuse,i_r_nir) = read2d(:,:)
 
       call file_cartesc_read( fid, "LAND_SFC_ALB_VIS_dir", read2d(:,:), step=it )
       albg_org(xs:xe,ys:ye,i_r_direct ,i_r_vis) = read2d(:,:)
 
       call file_cartesc_read( fid, "LAND_SFC_ALB_VIS_dif", read2d(:,:), step=it )
       albg_org(xs:xe,ys:ye,i_r_diffuse,i_r_vis) = read2d(:,:)
 
       call file_cartesc_read( fid, "topo", read2d(:,:) )
       topo_org(xs:xe,ys:ye) = read2d(:,:)
 
       call file_cartesc_read( fid, "lsmask", read2d(:,:) )
       lmask_org(xs:xe,ys:ye) = read2d(:,:)
 
    end do
 
    call file_read( fid, "lz", lz_org(:) )
 
    return
  end subroutine parentlandinputscale
 
  !-----------------------------------------------------------------------------
  subroutine parentoceansetupscale( &
       odims )
    use scale_comm_cartesc_nest, only: &
       parent_imax,                                     &
       parent_jmax,                                     &
       nest_tile_num_x => comm_cartesc_nest_tile_num_x, &
       nest_tile_num_y => comm_cartesc_nest_tile_num_y
    implicit none
 
    integer, intent(out) :: odims(2)
    !---------------------------------------------------------------------------
 
    log_info("ParentOceanSetupSCALE",*) 'Real Case/Ocean Input File Type: SCALE-RM'
 
    odims(1) = parent_imax(handle) * nest_tile_num_x
    odims(2) = parent_jmax(handle) * nest_tile_num_y
 
    if ( .NOT. allocated(read2d) ) then
       allocate( read2d(parent_imax(handle),parent_jmax(handle)) )
    end if
 
    allocate( read3do(1,parent_imax(handle),parent_jmax(handle)) )
 
    return
  end subroutine parentoceansetupscale
 
  !-----------------------------------------------------------------------------
  subroutine parentoceanopenscale( &
       olon_org,      &
       olat_org,      &
       omask_org,     &
       basename_ocean )
    use scale_const, only: &
       d2r => const_d2r
    use scale_comm_cartesc_nest, only: &
       parent_imax,                                     &
       parent_jmax,                                     &
       nest_tile_num_x => comm_cartesc_nest_tile_num_x, &
       nest_tile_id    => comm_cartesc_nest_tile_id
    use scale_file, only: &
       file_open
    use scale_file_cartesc, only: &
       file_cartesc_read
    implicit none
 
    real(rp),         intent(out) :: olon_org (:,:)
    real(rp),         intent(out) :: olat_org (:,:)
    real(rp),         intent(out) :: omask_org(:,:)
    character(len=*), intent(in)  :: basename_ocean
 
    integer :: rank
    integer :: xloc, yloc
    integer :: xs, xe, ys, ye
 
    integer :: fid
    integer :: i
    !---------------------------------------------------------------------------
 
    do i = 1, size( nest_tile_id(:) )
       ! read data from split files
       rank = nest_tile_id(i)
 
       xloc = mod( i-1, nest_tile_num_x ) + 1
       yloc = int( real(i-1) / real(nest_tile_num_x) ) + 1
 
       xs = parent_imax(handle) * (xloc-1) + 1
       xe = parent_imax(handle) * xloc
       ys = parent_jmax(handle) * (yloc-1) + 1
       ye = parent_jmax(handle) * yloc
 
       call file_open( basename_ocean,                & ! (in)
                       fid,                           & ! (out)
                       aggregate=.false., rankid=rank ) ! (in)
 
       call file_cartesc_read( fid, "lon", read2d(:,:) )
       olon_org(xs:xe,ys:ye) = read2d(:,:) * d2r
 
       call file_cartesc_read( fid, "lat", read2d(:,:) )
       olat_org(xs:xe,ys:ye) = read2d(:,:) * d2r
 
       call file_cartesc_read( fid, "lsmask", read2d(:,:) )
       omask_org(xs:xe,ys:ye) = read2d(:,:)
 
    end do
 
    return
  end subroutine parentoceanopenscale
 
  !-----------------------------------------------------------------------------
  subroutine parentoceaninputscale( &
       tw_org,         &
       sst_org,        &
       albw_org,       &
       z0w_org,        &
       omask_org,      &
       basename_ocean, &
       it              )
    use scale_comm_cartesc_nest, only: &
       parent_imax,                                     &
       parent_jmax,                                     &
       nest_tile_num_x => comm_cartesc_nest_tile_num_x, &
       nest_tile_id    => comm_cartesc_nest_tile_id
    use scale_file, only: &
       file_open, &
       file_get_datainfo
    use scale_file_cartesc, only: &
       file_cartesc_read
    implicit none
 
    real(rp),         intent(out) :: tw_org   (:,:)
    real(rp),         intent(out) :: sst_org  (:,:)
    real(rp),         intent(out) :: albw_org (:,:,:,:)
    real(rp),         intent(out) :: z0w_org  (:,:)
    real(rp),         intent(out) :: omask_org(:,:)
    character(len=*), intent(in)  :: basename_ocean
    integer,          intent(in)  :: it
 
    integer :: rank
 
    integer :: fid
    integer :: ndim
    integer :: i
    integer :: xloc, yloc
    integer :: xs, xe
    integer :: ys, ye
    !---------------------------------------------------------------------------
 
    do i = 1, size( nest_tile_id(:) )
       ! read data from split files
       rank = nest_tile_id(i)
 
       xloc = mod( i-1, nest_tile_num_x ) + 1
       yloc = int( real(i-1) / real(nest_tile_num_x) ) + 1
 
       xs = parent_imax(handle) * (xloc-1) + 1
       xe = parent_imax(handle) * xloc
       ys = parent_jmax(handle) * (yloc-1) + 1
       ye = parent_jmax(handle) * yloc
 
       call file_open( basename_ocean,                & ! (in)
                       fid,                           & ! (out)
                       aggregate=.false., rankid=rank ) ! (in)
 
       call file_get_datainfo( fid, "OCEAN_TEMP", dim_rank=ndim )
       select case (ndim)
       case ( 2 ) ! for old file
          call file_cartesc_read( fid, "OCEAN_TEMP", read2d(:,:), step=it )
          tw_org(xs:xe,ys:ye) = read2d(:,:)
       case ( 3 )
          call file_cartesc_read( fid, "OCEAN_TEMP", read3do(:,:,:), step=it )
          tw_org(xs:xe,ys:ye) = read3do(1,:,:)
       end select
 
       call file_cartesc_read( fid, "OCEAN_SFC_TEMP", read2d(:,:), step=it )
       sst_org(xs:xe,ys:ye) = read2d(:,:)
 
       call file_cartesc_read( fid, "OCEAN_SFC_ALB_IR_dir", read2d(:,:), step=it )
       albw_org(xs:xe,ys:ye,i_r_direct ,i_r_ir ) = read2d(:,:)
 
       call file_cartesc_read( fid, "OCEAN_SFC_ALB_IR_dif", read2d(:,:), step=it )
       albw_org(xs:xe,ys:ye,i_r_diffuse,i_r_ir ) = read2d(:,:)
 
       call file_cartesc_read( fid, "OCEAN_SFC_ALB_NIR_dir", read2d(:,:), step=it )
       albw_org(xs:xe,ys:ye,i_r_direct ,i_r_nir) = read2d(:,:)
 
       call file_cartesc_read( fid, "OCEAN_SFC_ALB_NIR_dif", read2d(:,:), step=it )
       albw_org(xs:xe,ys:ye,i_r_diffuse,i_r_nir) = read2d(:,:)
 
       call file_cartesc_read( fid, "OCEAN_SFC_ALB_VIS_dir", read2d(:,:), step=it )
       albw_org(xs:xe,ys:ye,i_r_direct ,i_r_vis) = read2d(:,:)
 
       call file_cartesc_read( fid, "OCEAN_SFC_ALB_VIS_dif", read2d(:,:), step=it )
       albw_org(xs:xe,ys:ye,i_r_diffuse,i_r_vis) = read2d(:,:)
 
       call file_cartesc_read( fid, "OCEAN_SFC_Z0M", read2d(:,:), step=it )
       z0w_org(xs:xe,ys:ye) = read2d(:,:)
 
       call file_cartesc_read( fid, "lsmask", read2d(:,:) )
       omask_org(xs:xe,ys:ye) = read2d(:,:)
 
    end do
 
    return
  end subroutine parentoceaninputscale
 
end module mod_realinput_scale