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(:,:,:)

  !-----------------------------------------------------------------------------
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)) )

    return
  end subroutine parentatmossetupscale

  !-----------------------------------------------------------------------------
  subroutine parentatmosopenscale( &
       lon_org,      &
       lat_org,      &
       cz_org,       &
       basename_org, &
       dims          )
    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) :: 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)

    integer :: rank
    integer :: xloc, yloc
    integer :: xs, xe, ys, ye

    logical :: existed

    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_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(:,:)

    end do

    cz_org(1,:,:) = 0.0_rp

    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, &
       same_mptype,  &
       dims,         &
       it            )
    use scale_const, only: &
       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_hydrostatic, only: &
       hydrostatic_buildrho_real => atmos_hydrostatic_buildrho_real
    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)  :: 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

    integer  :: xs, xe
    integer  :: ys, ye
    integer  :: nx, ny
    integer  :: xloc, yloc
    integer  :: rank

    integer  :: fid
    logical  :: existed, existed_t2, existed_mslp
    integer  :: k, i, j, iq
    !---------------------------------------------------------------------------

    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)

       call file_cartesc_read( fid, "T2", read2d(:,:), step=it, existed=existed_t2 )
!OCL XFILL
       if ( existed_t2 ) tsfc_org(xs:xe,ys:ye) = read2d(:,:)

       call file_cartesc_read( fid, "MSLP", read2d(:,:), step=it, existed=existed_mslp )
!OCL XFILL
       if ( existed_mslp ) pres_org(1,xs:xe,ys:ye) = read2d(:,:)

       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(:,:,:)

!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

       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

          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)
             else
!OCL XFILL
                qnum_org(:,:,:,iq) = 0.0_rp
             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
!OCL XFILL
    velx_org(1:2,:,:) = 0.0_rp

    ! 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
!OCL XFILL
    vely_org(1:2,:,:) = 0.0_rp


    !!! must be rotate !!!


    if ( qa_mp > 0 .AND. .NOT. same_mptype ) 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]
    end if

    !$omp parallel do default(none) &
    !$omp private(dz,temp_org,qdry,rtot,cvtot,cptot) &
    !$omp shared(dims,QA,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)
    do j = 1, dims(3)
    do i = 1, dims(2)

       ! diagnose temp and pres
       do k = 3, dims(1)+2

          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)+2, 3, dims(1)+2,                              & ! [IN]
                                         dens_org(:,i,j), rhot_org(:,i,j), rtot, cvtot, cptot, & ! [IN]
                                         temp_org(:), pres_org(:,i,j)                          ) ! [OUT]

       end do

!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

       ! 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 ( .not. existed_mslp ) then
          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)
       else
          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) )
       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, &
       odims           )
    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,          intent(in)  :: odims(2)

    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, &
       odims,          &
       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)  :: odims(2)
    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