scale_atmos_grid_cartesC.F90

Go to the documentation of this file.

!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
#include "scalelib.h"
module scale_atmos_grid_cartesc
  !-----------------------------------------------------------------------------
  !
  !++ used modules
  !
  use scale_precision
  use scale_io
  use scale_prof
  use scale_atmos_grid_cartesc_index
  !-----------------------------------------------------------------------------
  implicit none
  private
  !-----------------------------------------------------------------------------
  !
  !++ Public procedure
  !
  public :: atmos_grid_cartesc_setup
  public :: atmos_grid_cartesc_allocate
  public :: atmos_grid_cartesc_generate

  !-----------------------------------------------------------------------------
  !
  !++ Public parameters & variables
  !
  character(len=7), public, parameter :: atmos_grid_cartesc_name = 'cartesC'

  real(RP), public              :: dz, dx, dy

  real(RP), public, allocatable :: atmos_grid_cartesc_cz   (:)
  real(RP), public, allocatable :: atmos_grid_cartesc_fz   (:)
  real(RP), public, allocatable :: atmos_grid_cartesc_cdz  (:)
  real(RP), public, allocatable :: atmos_grid_cartesc_fdz  (:)
  real(RP), public, allocatable :: atmos_grid_cartesc_rcdz (:)
  real(RP), public, allocatable :: atmos_grid_cartesc_rfdz (:)
  real(RP), public, allocatable :: atmos_grid_cartesc_cbfz (:)
  real(RP), public, allocatable :: atmos_grid_cartesc_fbfz (:)

  ! land
  real(RP), public, allocatable :: atmos_grid_cartesc_lcz  (:)
  real(RP), public, allocatable :: atmos_grid_cartesc_lfz (:)
  real(RP), public, allocatable :: atmos_grid_cartesc_lcdz(:)

  ! horizontal
  real(RP), public, allocatable :: atmos_grid_cartesc_cx   (:)
  real(RP), public, allocatable :: atmos_grid_cartesc_cy   (:)
  real(RP), public, allocatable :: atmos_grid_cartesc_fx   (:)
  real(RP), public, allocatable :: atmos_grid_cartesc_fy   (:)

  real(RP), public, allocatable :: atmos_grid_cartesc_cdx  (:)
  real(RP), public, allocatable :: atmos_grid_cartesc_cdy  (:)
  real(RP), public, allocatable :: atmos_grid_cartesc_fdx  (:)
  real(RP), public, allocatable :: atmos_grid_cartesc_fdy  (:)

  real(RP), public, allocatable :: atmos_grid_cartesc_rcdx (:)
  real(RP), public, allocatable :: atmos_grid_cartesc_rcdy (:)
  real(RP), public, allocatable :: atmos_grid_cartesc_rfdx (:)
  real(RP), public, allocatable :: atmos_grid_cartesc_rfdy (:)

  real(RP), public, allocatable :: atmos_grid_cartesc_cbfx (:)
  real(RP), public, allocatable :: atmos_grid_cartesc_cbfy (:)
  real(RP), public, allocatable :: atmos_grid_cartesc_fbfx (:)
  real(RP), public, allocatable :: atmos_grid_cartesc_fbfy (:)

  real(RP), public, allocatable :: atmos_grid_cartesc_cxg  (:)
  real(RP), public, allocatable :: atmos_grid_cartesc_cyg  (:)
  real(RP), public, allocatable :: atmos_grid_cartesc_fxg  (:)
  real(RP), public, allocatable :: atmos_grid_cartesc_fyg  (:)

  real(RP), public, allocatable :: atmos_grid_cartesc_cdxg (:)
  real(RP), public, allocatable :: atmos_grid_cartesc_cdyg (:)
  real(RP), public, allocatable :: atmos_grid_cartesc_fdxg (:)
  real(RP), public, allocatable :: atmos_grid_cartesc_fdyg (:)

  real(RP), public, allocatable :: atmos_grid_cartesc_cbfxg(:)
  real(RP), public, allocatable :: atmos_grid_cartesc_cbfyg(:)
  real(RP), public, allocatable :: atmos_grid_cartesc_fbfxg(:)
  real(RP), public, allocatable :: atmos_grid_cartesc_fbfyg(:)

  real(RP), public              :: atmos_grid_cartesc_domain_center_x
  real(RP), public              :: atmos_grid_cartesc_domain_center_y

  !-----------------------------------------------------------------------------
  !
  !++ Private procedure
  !
  !-----------------------------------------------------------------------------
  !
  !++ Private parameters & variables
  !
  !-----------------------------------------------------------------------------
contains
  !-----------------------------------------------------------------------------
  subroutine atmos_grid_cartesc_setup( &
       basename, &
       aggregate )
    use scale_prc, only: &
       prc_abort
    use scale_file, only: &
       file_aggregate
    implicit none
    character(len=*), intent(in), optional :: basename
    logical,          intent(in), optional :: aggregate

    character(len=H_LONG) :: ATMOS_GRID_CARTESC_IN_BASENAME  = ''
    logical               :: ATMOS_GRID_CARTESC_IN_AGGREGATE

    real(RP)              :: OFFSET_X     = 0.0_rp
    real(RP)              :: OFFSET_Y     = 0.0_rp

    real(RP)              :: BUFFER_DZ  =  0.0_rp 
    real(RP)              :: BUFFER_DX  =  0.0_rp 
    real(RP)              :: BUFFER_DY  =  0.0_rp 
    real(RP)              :: BUFFFACT   =  1.0_rp 
    real(RP)              :: BUFFFACT_Z = -1.0_rp 
    real(RP)              :: BUFFFACT_X = -1.0_rp 
    real(RP)              :: BUFFFACT_Y = -1.0_rp 

    integer               :: BUFFER_NZ = -1
    integer               :: BUFFER_NX = -1
    integer               :: BUFFER_NY = -1

    integer,    parameter :: FZ_MAX = 300
    real(RP)              :: FZ(fz_max)

    namelist / param_atmos_grid_cartesc / &
       atmos_grid_cartesc_in_basename,  &
       atmos_grid_cartesc_in_aggregate, &
       dz,         &
       dx,         &
       dy,         &
       buffer_dz,  &
       buffer_dx,  &
       buffer_dy,  &
       buffer_nz,  &
       buffer_nx,  &
       buffer_ny,  &
       bufffact,   &
       bufffact_z, &
       bufffact_x, &
       bufffact_y, &
       fz,         &
       offset_x, &
       offset_y

    integer :: ierr
    !---------------------------------------------------------------------------

    log_newline
    log_info("ATMOS_GRID_CARTESC_setup",*) 'Setup'

    if ( kmax < 1 ) then
       log_info("ATMOS_GRID_CARTESC_setup",*) 'Skip because KMAX < 1'
       return
    end if

    fz(:) = -1.0_rp

    if ( present(basename)  ) atmos_grid_cartesc_in_basename = basename
    if ( present(aggregate) ) then
       atmos_grid_cartesc_in_aggregate = aggregate
    else
       atmos_grid_cartesc_in_aggregate = file_aggregate
    end if

    !--- read namelist
    rewind(io_fid_conf)
    read(io_fid_conf,nml=param_atmos_grid_cartesc,iostat=ierr)
    if( ierr < 0 ) then !--- missing
       log_info("ATMOS_GRID_CARTESC_setup",*) 'Not found namelist. Default used.'
    elseif( ierr > 0 ) then !--- fatal error
       log_error("ATMOS_GRID_CARTESC_setup",*) 'Not appropriate names in namelist PARAM_ATMOS_GRID_CARTESC. Check!'
       call prc_abort
    endif
    log_nml(param_atmos_grid_cartesc)


    call atmos_grid_cartesc_allocate

    if ( atmos_grid_cartesc_in_basename /= '' ) then

       call atmos_grid_cartesc_read( atmos_grid_cartesc_in_basename, atmos_grid_cartesc_in_aggregate )

    else

       call atmos_grid_cartesc_generate( &
            dz, dx, dy, fz(:), fz_max,         &
            offset_x, offset_y,                &
            buffer_dz, buffer_dx, buffer_dy,   &
            buffer_nz, buffer_nx, buffer_ny,   &
            bufffact,                          &
            bufffact_z, bufffact_x, bufffact_y )

    end if

    call atmos_grid_cartesc_output_info

    return
  end subroutine atmos_grid_cartesc_setup

  !-----------------------------------------------------------------------------
  ! private
  !-----------------------------------------------------------------------------

  subroutine atmos_grid_cartesc_allocate
    implicit none
    !---------------------------------------------------------------------------

    ! local domain
    allocate( atmos_grid_cartesc_cz(  ka) )
    allocate( atmos_grid_cartesc_cx(  ia) )
    allocate( atmos_grid_cartesc_cy(  ja) )
    allocate( atmos_grid_cartesc_fz(0:ka) )
    allocate( atmos_grid_cartesc_fx(0:ia) )
    allocate( atmos_grid_cartesc_fy(0:ja) )

    allocate( atmos_grid_cartesc_cdz(ka)   )
    allocate( atmos_grid_cartesc_cdx(ia)   )
    allocate( atmos_grid_cartesc_cdy(ja)   )
    allocate( atmos_grid_cartesc_fdz(ka-1) )
    allocate( atmos_grid_cartesc_fdx(ia-1) )
    allocate( atmos_grid_cartesc_fdy(ja-1) )

    allocate( atmos_grid_cartesc_rcdz(ka)   )
    allocate( atmos_grid_cartesc_rcdx(ia)   )
    allocate( atmos_grid_cartesc_rcdy(ja)   )
    allocate( atmos_grid_cartesc_rfdz(ka-1) )
    allocate( atmos_grid_cartesc_rfdx(ia-1) )
    allocate( atmos_grid_cartesc_rfdy(ja-1) )

    allocate( atmos_grid_cartesc_cbfz(  ka) )
    allocate( atmos_grid_cartesc_cbfx(  ia) )
    allocate( atmos_grid_cartesc_cbfy(  ja) )
    allocate( atmos_grid_cartesc_fbfz(0:ka) )
    allocate( atmos_grid_cartesc_fbfx(0:ia) )
    allocate( atmos_grid_cartesc_fbfy(0:ja) )

    ! global domain
    allocate( atmos_grid_cartesc_cxg(  iag) )
    allocate( atmos_grid_cartesc_cyg(  jag) )
    allocate( atmos_grid_cartesc_fxg(0:iag) )
    allocate( atmos_grid_cartesc_fyg(0:jag) )

    allocate( atmos_grid_cartesc_cdxg(iag)   )
    allocate( atmos_grid_cartesc_cdyg(jag)   )
    allocate( atmos_grid_cartesc_fdxg(iag-1) )
    allocate( atmos_grid_cartesc_fdyg(jag-1) )

    allocate( atmos_grid_cartesc_cbfxg(  iag) )
    allocate( atmos_grid_cartesc_cbfyg(  jag) )
    allocate( atmos_grid_cartesc_fbfxg(0:iag) )
    allocate( atmos_grid_cartesc_fbfyg(0:jag) )

    return
  end subroutine atmos_grid_cartesc_allocate

  !-----------------------------------------------------------------------------
  subroutine atmos_grid_cartesc_read( &
       basename, aggregate )
    use scale_file, only: &
       file_open, &
       file_read
    use scale_prc, only: &
       prc_myrank
    implicit none

    character(len=*), intent(in) :: basename
    logical, intent(in), optional :: aggregate

    integer :: fid

    real(RP) :: FDXG(0:iag), FDYG(0:jag)
    real(RP) :: FDX(0:ia), FDY(0:ja)
    !---------------------------------------------------------------------------


    call file_open( basename, fid, rankid=prc_myrank, aggregate=aggregate )

    call file_read( fid, 'CZ', atmos_grid_cartesc_cz(:) )
    call file_read( fid, 'CX', atmos_grid_cartesc_cx(:) )
    call file_read( fid, 'CY', atmos_grid_cartesc_cy(:) )

    call file_read( fid, 'FZ', atmos_grid_cartesc_fz(:) )
    call file_read( fid, 'FX', atmos_grid_cartesc_fx(:) )
    call file_read( fid, 'FY', atmos_grid_cartesc_fy(:) )

    call file_read( fid, 'CDZ', atmos_grid_cartesc_cdz(:) )
    call file_read( fid, 'CDX', atmos_grid_cartesc_cdx(:) )
    call file_read( fid, 'CDY', atmos_grid_cartesc_cdy(:) )

    call file_read( fid, 'FDZ', atmos_grid_cartesc_fdz(:) )
    call file_read( fid, 'FDX',                    fdx(:) )
    call file_read( fid, 'FDY',                    fdy(:) )
    atmos_grid_cartesc_fdx(:) = fdx(1:ia-1)
    atmos_grid_cartesc_fdy(:) = fdy(1:ja-1)

    atmos_grid_cartesc_rcdz(:) = 1.0_rp / atmos_grid_cartesc_cdz(:)
    atmos_grid_cartesc_rcdx(:) = 1.0_rp / atmos_grid_cartesc_cdx(:)
    atmos_grid_cartesc_rcdy(:) = 1.0_rp / atmos_grid_cartesc_cdy(:)
    atmos_grid_cartesc_rfdz(:) = 1.0_rp / atmos_grid_cartesc_fdz(:)
    atmos_grid_cartesc_rfdx(:) = 1.0_rp / atmos_grid_cartesc_fdx(:)
    atmos_grid_cartesc_rfdy(:) = 1.0_rp / atmos_grid_cartesc_fdy(:)

    call file_read( fid, 'CBFZ', atmos_grid_cartesc_cbfz(:) )
    call file_read( fid, 'CBFX', atmos_grid_cartesc_cbfx(:) )
    call file_read( fid, 'CBFY', atmos_grid_cartesc_cbfy(:) )
    call file_read( fid, 'FBFZ', atmos_grid_cartesc_fbfz(:) )
    call file_read( fid, 'FBFX', atmos_grid_cartesc_fbfx(:) )
    call file_read( fid, 'FBFY', atmos_grid_cartesc_fbfy(:) )

    call file_read( fid, 'CXG', atmos_grid_cartesc_cxg(:) )
    call file_read( fid, 'CYG', atmos_grid_cartesc_cyg(:) )
    call file_read( fid, 'FXG', atmos_grid_cartesc_fxg(:) )
    call file_read( fid, 'FYG', atmos_grid_cartesc_fyg(:) )

    call file_read( fid, 'CDXG', atmos_grid_cartesc_cdxg(:) )
    call file_read( fid, 'CDYG', atmos_grid_cartesc_cdyg(:) )
    call file_read( fid, 'FDXG',                    fdxg(:) )
    call file_read( fid, 'FDYG',                    fdyg(:) )
    atmos_grid_cartesc_fdxg(:) = fdxg(1:ia-1)
    atmos_grid_cartesc_fdyg(:) = fdyg(1:ja-1)


    atmos_grid_cartesc_domain_center_x = 0.5_rp * ( atmos_grid_cartesc_fxg(ihalo) + atmos_grid_cartesc_fxg(iag-ihalo) )
    atmos_grid_cartesc_domain_center_y = 0.5_rp * ( atmos_grid_cartesc_fyg(jhalo) + atmos_grid_cartesc_fyg(jag-jhalo) )

    return
  end subroutine atmos_grid_cartesc_read

  !-----------------------------------------------------------------------------
  subroutine atmos_grid_cartesc_generate( &
       DZ, DX, DY, FZ, FZ_MAX,            &
       OFFSET_X, OFFSET_Y,                &
       BUFFER_DZ, BUFFER_DX, BUFFER_DY,   &
       BUFFER_NZ, BUFFER_NX, BUFFER_NY,   &
       BUFFFACT,                          &
       BUFFFACT_Z, BUFFFACT_X, BUFFFACT_Y )
    use scale_prc, only: &
       prc_abort, &
       prc_myrank
    use scale_prc_cartesc, only: &
       prc_2drank,  &
       prc_num_x,   &
       prc_num_y
    implicit none
    real(RP), intent(in) :: DZ, DX, DY
    real(RP), intent(in), optional :: FZ(:)
    integer,  intent(in), optional :: FZ_MAX
    real(RP), intent(in), optional :: OFFSET_X, OFFSET_Y
    real(RP), intent(in), optional :: BUFFER_DZ, BUFFER_DX, BUFFER_DY
    integer,  intent(in), optional :: BUFFER_NZ, BUFFER_NX, BUFFER_NY
    real(RP), intent(in), optional :: BUFFFACT
    real(RP), intent(in), optional :: BUFFFACT_Z, BUFFFACT_X, BUFFFACT_Y

    real(RP), allocatable :: buffz(:), buffx(:), buffy(:)
    real(RP)              :: bufftotz, bufftotx, bufftoty
    real(RP)              :: fact

    integer :: kbuff, ibuff, jbuff
    integer :: kmain, imain, jmain

    real(RP) :: dz_tmp

    logical :: use_user_input

    integer :: k, i, j, ii, jj
    !---------------------------------------------------------------------------

    !##### coordinate in global domain #####

    allocate( buffx(0:iag) )
    allocate( buffy(0:jag) )


    ! X-direction
    ! calculate buffer grid size

    fact = -1.0_rp
    if ( present(bufffact_x) ) fact = bufffact_x
    if ( fact < 0.0_rp .and. present(bufffact) ) fact = bufffact
    if ( fact < 0.0_rp ) fact = 1.0_rp

    buffx(0) = dx
    bufftotx = 0.0_rp
    ibuff = -1
    if ( present(buffer_nx) ) ibuff = buffer_nx
    if ( ibuff > 0 ) then
       if ( 2*ibuff > imaxg ) then
          log_error("ATMOS_GRID_CARTESC_generate",*) 'Buffer grid size (', ibuff, &
                     'x2) must be smaller than global domain size (X). Use smaller BUFFER_NX!'
          call prc_abort
       endif

       do i = 1, ibuff
          buffx(i) = buffx(i-1) * fact
          bufftotx = bufftotx + buffx(i)
       enddo
       imain = imaxg - 2*ibuff
    else if ( present(buffer_dz) ) then
       do i = 1, iag
          if( bufftotx >= buffer_dx ) exit
          buffx(i) = buffx(i-1) * fact
          bufftotx = bufftotx + buffx(i)
       enddo
       ibuff = i - 1
       imain = imaxg - 2*ibuff

       if ( imain < 0 ) then
          log_error("ATMOS_GRID_CARTESC_generate",*) 'Buffer length (', bufftotx, &
                     'x2[m]) must be smaller than global domain size (X). Use smaller BUFFER_DX!'
          call prc_abort
       endif
    else
       ibuff = 0
       imain = imaxg
    endif

    ! horizontal coordinate (global domain)
    if ( present(offset_x) ) then
       atmos_grid_cartesc_fxg(ihalo) = offset_x
    else
       atmos_grid_cartesc_fxg(ihalo) = 0.0_rp
    end if
    do i = ihalo-1, 0, -1
       atmos_grid_cartesc_fxg(i) = atmos_grid_cartesc_fxg(i+1) - buffx(ibuff)
    enddo

    do i = 1, ihalo
       atmos_grid_cartesc_cxg(i) = 0.5_rp * ( atmos_grid_cartesc_fxg(i)+atmos_grid_cartesc_fxg(i-1) )
    enddo

    if ( ibuff > 0 ) then
       do i = ihalo+1, ihalo+ibuff
          atmos_grid_cartesc_fxg(i) = atmos_grid_cartesc_fxg(i-1) + buffx(ibuff+ihalo+1-i)
          atmos_grid_cartesc_cxg(i) = 0.5_rp * ( atmos_grid_cartesc_fxg(i)+atmos_grid_cartesc_fxg(i-1) )
       enddo
    endif

    do i = ihalo+ibuff+1, ihalo+ibuff+imain
       atmos_grid_cartesc_fxg(i) = atmos_grid_cartesc_fxg(i-1) + dx
       atmos_grid_cartesc_cxg(i) = 0.5_rp * ( atmos_grid_cartesc_fxg(i)+atmos_grid_cartesc_fxg(i-1) )
    enddo

    if ( ibuff > 0 ) then
       do i = ihalo+ibuff+imain+1, ihalo+ibuff+imain+ibuff
          atmos_grid_cartesc_fxg(i) = atmos_grid_cartesc_fxg(i-1) + buffx(i-ihalo-ibuff-imain)
          atmos_grid_cartesc_cxg(i) = 0.5_rp * ( atmos_grid_cartesc_fxg(i)+atmos_grid_cartesc_fxg(i-1) )
       enddo
    endif

    do i = ihalo+ibuff+imain+ibuff+1, ihalo+ibuff+imain+ibuff+ihalo
       atmos_grid_cartesc_fxg(i) = atmos_grid_cartesc_fxg(i-1) + buffx(ibuff)
       atmos_grid_cartesc_cxg(i) = 0.5_rp * ( atmos_grid_cartesc_fxg(i)+atmos_grid_cartesc_fxg(i-1) )
    enddo

    do i = 1, iag
       atmos_grid_cartesc_cdxg(i) = atmos_grid_cartesc_fxg(i) - atmos_grid_cartesc_fxg(i-1)
    end do
    do i = 1, iag-1
       atmos_grid_cartesc_fdxg(i) = atmos_grid_cartesc_cxg(i+1)-atmos_grid_cartesc_cxg(i)
    end do

    ! calc buffer factor (global domain)
    atmos_grid_cartesc_cbfxg(:) = 0.0_rp
    atmos_grid_cartesc_fbfxg(:) = 0.0_rp
    do i = 1, ihalo
       atmos_grid_cartesc_cbfxg(i) = 1.0_rp
    enddo
    do i = 0, ihalo
       atmos_grid_cartesc_fbfxg(i) = 1.0_rp
    enddo

    if ( ibuff > 0 ) then
       do i = ihalo+1, ihalo+ibuff
          atmos_grid_cartesc_cbfxg(i) = (bufftotx+atmos_grid_cartesc_fxg(ihalo)-atmos_grid_cartesc_cxg(i)) / bufftotx
          atmos_grid_cartesc_fbfxg(i) = (bufftotx+atmos_grid_cartesc_fxg(ihalo)-atmos_grid_cartesc_fxg(i)) / bufftotx
       enddo

       do i = ihalo+ibuff+imain+1, ihalo+ibuff+imain+ibuff
          atmos_grid_cartesc_cbfxg(i) = (bufftotx-atmos_grid_cartesc_fxg(iag-ihalo)+atmos_grid_cartesc_cxg(i)) / bufftotx
          atmos_grid_cartesc_fbfxg(i) = (bufftotx-atmos_grid_cartesc_fxg(iag-ihalo)+atmos_grid_cartesc_fxg(i)) / bufftotx
       enddo
    endif

    do i = ihalo+ibuff+imain+ibuff+1, ihalo+ibuff+imain+ibuff+ihalo
       atmos_grid_cartesc_cbfxg(i) = 1.0_rp
       atmos_grid_cartesc_fbfxg(i) = 1.0_rp
    enddo

    atmos_grid_cartesc_cbfxg(:) = max( min( atmos_grid_cartesc_cbfxg(:), 1.0_rp ), 0.0_rp )
    atmos_grid_cartesc_fbfxg(:) = max( min( atmos_grid_cartesc_fbfxg(:), 1.0_rp ), 0.0_rp )

    ! Y-direction
    ! calculate buffer grid size

    fact = -1.0_rp
    if ( present(bufffact_y) ) fact = bufffact_y
    if ( fact < 0.0_rp .and. present(bufffact) )fact = bufffact
    if ( fact < 0.0_rp ) fact = 1.0_rp

    buffy(0) = dy
    bufftoty = 0.0_rp
    jbuff = -1
    if ( present(buffer_ny) ) jbuff = buffer_ny
    if ( jbuff > 0 ) then
       if ( 2*jbuff > jmaxg ) then
          log_error("ATMOS_GRID_CARTESC_generate",*) 'Buffer grid size (', jbuff, &
                     'x2) must be smaller than global domain size (Y). Use smaller BUFFER_NY!'
          call prc_abort
       endif

       do j = 1, jbuff
          buffy(j) = buffy(j-1) * fact
          bufftoty = bufftoty + buffy(j)
       enddo
       jmain = jmaxg - 2*jbuff
    else if ( present(buffer_dy) ) then
       do j = 1, jag
          if( bufftoty >= buffer_dy ) exit
          buffy(j) = buffy(j-1) * fact
          bufftoty = bufftoty + buffy(j)
       enddo
       jbuff = j - 1
       jmain = jmaxg - 2*jbuff

       if ( jmain < 0 ) then
          log_error("ATMOS_GRID_CARTESC_generate",*) 'Buffer length (', bufftoty, &
                     'x2[m]) must be smaller than global domain size (Y). Use smaller BUFFER_DY!'
          call prc_abort
       endif
    else
       jbuff = 0
       jmain = jmaxg
    endif

    ! horizontal coordinate (global domain)
    if ( present(offset_y) ) then
       atmos_grid_cartesc_fyg(jhalo) = offset_y
    else
       atmos_grid_cartesc_fyg(jhalo) = 0.0_rp
    end if
    do j = jhalo-1, 0, -1
       atmos_grid_cartesc_fyg(j) = atmos_grid_cartesc_fyg(j+1) - buffy(jbuff)
    enddo

    do j = 1, jhalo
       atmos_grid_cartesc_cyg(j) = 0.5_rp * ( atmos_grid_cartesc_fyg(j)+atmos_grid_cartesc_fyg(j-1) )
    enddo

    if ( jbuff > 0 ) then
       do j = jhalo+1, jhalo+jbuff
          atmos_grid_cartesc_fyg(j) = atmos_grid_cartesc_fyg(j-1) + buffy(jbuff+jhalo+1-j)
          atmos_grid_cartesc_cyg(j) = 0.5_rp * ( atmos_grid_cartesc_fyg(j)+atmos_grid_cartesc_fyg(j-1) )
       enddo
    endif

    do j = jhalo+jbuff+1, jhalo+jbuff+jmain
       atmos_grid_cartesc_fyg(j) = atmos_grid_cartesc_fyg(j-1) + dy
       atmos_grid_cartesc_cyg(j) = 0.5_rp * ( atmos_grid_cartesc_fyg(j)+atmos_grid_cartesc_fyg(j-1) )
    enddo

    if ( jbuff > 0 ) then
       do j = jhalo+jbuff+jmain+1, jhalo+jbuff+jmain+jbuff
          atmos_grid_cartesc_fyg(j) = atmos_grid_cartesc_fyg(j-1) + buffy(j-jhalo-jbuff-jmain)
          atmos_grid_cartesc_cyg(j) = 0.5_rp * ( atmos_grid_cartesc_fyg(j)+atmos_grid_cartesc_fyg(j-1) )
       enddo
    endif

    do j = jhalo+jbuff+jmain+jbuff+1, jhalo+jbuff+jmain+jbuff+jhalo
       atmos_grid_cartesc_fyg(j) = atmos_grid_cartesc_fyg(j-1) + buffy(jbuff)
       atmos_grid_cartesc_cyg(j) = 0.5_rp * ( atmos_grid_cartesc_fyg(j)+atmos_grid_cartesc_fyg(j-1) )
    enddo

    do j = 1, jag
       atmos_grid_cartesc_cdyg(j) = atmos_grid_cartesc_fyg(j) - atmos_grid_cartesc_fyg(j-1)
    end do
    do j = 1, jag-1
       atmos_grid_cartesc_fdyg(j) = atmos_grid_cartesc_cyg(j+1)-atmos_grid_cartesc_cyg(j)
    end do

    ! calc buffer factor (global domain)
    atmos_grid_cartesc_cbfyg(:) = 0.0_rp
    atmos_grid_cartesc_fbfyg(:) = 0.0_rp
    do j = 1, jhalo
       atmos_grid_cartesc_cbfyg(j) = 1.0_rp
    enddo
    do j = 0, jhalo
       atmos_grid_cartesc_fbfyg(j) = 1.0_rp
    enddo

    if ( jbuff > 0 ) then
       do j = jhalo+1, jhalo+jbuff
          atmos_grid_cartesc_cbfyg(j) = (bufftoty+atmos_grid_cartesc_fyg(jhalo)-atmos_grid_cartesc_cyg(j)) / bufftoty
          atmos_grid_cartesc_fbfyg(j) = (bufftoty+atmos_grid_cartesc_fyg(jhalo)-atmos_grid_cartesc_fyg(j)) / bufftoty
       enddo

       do j = jhalo+jbuff+jmain+1, jhalo+jbuff+jmain+jbuff
          atmos_grid_cartesc_cbfyg(j) = (bufftoty-atmos_grid_cartesc_fyg(jag-jhalo)+atmos_grid_cartesc_cyg(j)) / bufftoty
          atmos_grid_cartesc_fbfyg(j) = (bufftoty-atmos_grid_cartesc_fyg(jag-jhalo)+atmos_grid_cartesc_fyg(j)) / bufftoty
       enddo
    endif

    do j = jhalo+jbuff+jmain+jbuff+1, jhalo+jbuff+jmain+jbuff+jhalo
       atmos_grid_cartesc_cbfyg(j) = 1.0_rp
       atmos_grid_cartesc_fbfyg(j) = 1.0_rp
    enddo
    atmos_grid_cartesc_cbfyg(:) = max( min( atmos_grid_cartesc_cbfyg(:), 1.0_rp ), 0.0_rp )
    atmos_grid_cartesc_fbfyg(:) = max( min( atmos_grid_cartesc_fbfyg(:), 1.0_rp ), 0.0_rp )

    deallocate( buffx )
    deallocate( buffy )

    !##### coordinate in local domain #####

    allocate( buffz(0:ka) )

    use_user_input = .false.
    if ( present(fz) ) then
       if ( maxval(fz(:)) > 0.0_rp ) then ! try to use input from namelist
          log_info("ATMOS_GRID_CARTESC_generate",*) 'Z coordinate is given from NAMELIST.'

          if ( kmax < 2 ) then
             log_error("ATMOS_GRID_CARTESC_generate",*) 'KMAX must be larger than 1. Check!', kmax
             call prc_abort
          endif

          if ( kmax > fz_max ) then
             log_error("ATMOS_GRID_CARTESC_generate",*) 'KMAX must be smaller than ', fz_max, '. Check!', kmax
             call prc_abort
          endif

          if ( minval(fz(1:kmax)) <= 0.0_rp ) then
             log_error("ATMOS_GRID_CARTESC_generate",*) 'FZ must be positive. Check! minval(FZ(1:KMAX))=', minval(fz(1:kmax))
             call prc_abort
          endif

          use_user_input = .true.
       endif
    end if

    if ( use_user_input ) then ! input from namelist

       ! Z-direction
       ! calculate buffer grid size

       kbuff = -1
       if ( present(buffer_nz) ) kbuff = buffer_nz
       if ( kbuff > 0 ) then
          if ( kbuff > kmax ) then
             log_error("ATMOS_GRID_CARTESC_generate",*) 'Buffer grid size (', kbuff, &
                        ') must be smaller than global domain size (Z). Use smaller BUFFER_NZ!'
             call prc_abort
          endif

          bufftotz = 0.0_rp
          do k = kmax, kmax-kbuff+1, -1
             bufftotz = bufftotz + ( fz(k) - fz(k-1) )
          enddo
          kmain = kmax - kbuff
       else if ( present(buffer_dz) ) then
          if ( buffer_dz > fz(kmax) ) then
             log_error("ATMOS_GRID_CARTESC_generate",*) 'Buffer length (', buffer_dz, &
                        '[m]) must be smaller than global domain size (Z). Use smaller BUFFER_DZ!'
             call prc_abort
          endif

          bufftotz = 0.0_rp
          do k = kmax, 2, -1
             if( bufftotz >= buffer_dz ) exit
             bufftotz = bufftotz + ( fz(k) - fz(k-1) )
          enddo
          kbuff = kmax - k
          kmain = k
       else
          bufftotz = 0.0_rp
          kbuff = 0
          kmain = kmax
       endif

       ! vertical coordinate (local=global domain)
       atmos_grid_cartesc_fz(ks-1) = 0.0_rp

       dz_tmp = fz(1)
       do k = ks-2, 0, -1
          atmos_grid_cartesc_fz(k) = atmos_grid_cartesc_fz(k+1) - dz_tmp
       enddo

       do k = ks, ke
          atmos_grid_cartesc_fz(k) = fz(k-ks+1)
       enddo

       dz_tmp = fz(kmax) - fz(kmax-1)
       do k = ke+1, ka
          atmos_grid_cartesc_fz(k) = atmos_grid_cartesc_fz(k-1) + dz_tmp
       enddo

       do k = 1, ka
          atmos_grid_cartesc_cz(k) = 0.5_rp * ( atmos_grid_cartesc_fz(k)+atmos_grid_cartesc_fz(k-1) )
       enddo

    else ! calc using DZ

       ! Z-direction
       ! calculate buffer grid size

       fact = -1.0_rp
       if ( present(bufffact_z) ) fact = bufffact_z
       if ( fact < 0.0_rp .and. present(bufffact) ) fact = bufffact
       if ( fact < 0.0_rp ) fact = 1.0_rp

       buffz(0) = dz
       bufftotz = 0.0_rp
       kbuff = -1
       if ( present(buffer_nz) ) kbuff = buffer_nz
       if ( kbuff > 0 ) then
          if ( kbuff > kmax ) then
             log_error("ATMOS_GRID_CARTESC_generate",*) 'Buffer grid size (', kbuff, &
                        ') must be smaller than global domain size (Z). Use smaller BUFFER_NZ!'
             call prc_abort
          endif

          do k = 1, kbuff
             buffz(k) = buffz(k-1) * fact
             bufftotz = bufftotz + buffz(k)
          enddo
          kmain = kmax - kbuff
       else if ( present(buffer_dz) ) then
          do k = 1, ka
             if( bufftotz >= buffer_dz ) exit
             buffz(k) = buffz(k-1) * fact
             bufftotz = bufftotz + buffz(k)
          enddo
          kbuff = k - 1
          kmain = kmax - kbuff

          if ( kmain < 0 ) then
             log_error("ATMOS_GRID_CARTESC_generate",*) 'Buffer length (', bufftotz, &
                        '[m]) must be smaller than global domain size (Z). Use smaller BUFFER_DZ!'
             call prc_abort
          endif
       else
          kbuff = 0
          kmain = kmax
       endif

       ! vertical coordinate (local=global domain)
       atmos_grid_cartesc_fz(ks-1) = 0.0_rp
       do k = ks-2, 0, -1
          atmos_grid_cartesc_fz(k) = atmos_grid_cartesc_fz(k+1) - dz
       enddo

       do k = 1, ks-1
          atmos_grid_cartesc_cz(k) = 0.5_rp * ( atmos_grid_cartesc_fz(k)+atmos_grid_cartesc_fz(k-1) )
       enddo

       do k = ks, ks+kmain-1
          atmos_grid_cartesc_fz(k) = atmos_grid_cartesc_fz(k-1) + dz
          atmos_grid_cartesc_cz(k) = 0.5_rp * ( atmos_grid_cartesc_fz(k)+atmos_grid_cartesc_fz(k-1) )
       enddo

       if ( kbuff > 0 ) then
          do k = ks+kmain, ke
             atmos_grid_cartesc_fz(k) = atmos_grid_cartesc_fz(k-1) + buffz(k-ks-kmain+1)
             atmos_grid_cartesc_cz(k) = 0.5_rp * ( atmos_grid_cartesc_fz(k)+atmos_grid_cartesc_fz(k-1) )
          enddo
       endif

       do k = ke+1, ka
          atmos_grid_cartesc_fz(k) = atmos_grid_cartesc_fz(k-1) + buffz(kbuff)
          atmos_grid_cartesc_cz(k) = 0.5_rp * ( atmos_grid_cartesc_fz(k)+atmos_grid_cartesc_fz(k-1) )
       enddo

    endif

    ! calc buffer factor (global domain)
    atmos_grid_cartesc_cbfz(:) = 0.0_rp
    atmos_grid_cartesc_fbfz(:) = 0.0_rp
    if ( kbuff > 0 ) then
       do k = ks+kmain, ke
          atmos_grid_cartesc_cbfz(k) = (bufftotz-atmos_grid_cartesc_fz(ke)+atmos_grid_cartesc_cz(k)) / bufftotz
          atmos_grid_cartesc_fbfz(k) = (bufftotz-atmos_grid_cartesc_fz(ke)+atmos_grid_cartesc_fz(k)) / bufftotz
       enddo
    endif

    do k = ke+1, ka
       atmos_grid_cartesc_cbfz(k) = 1.0_rp
       atmos_grid_cartesc_fbfz(k) = 1.0_rp
    enddo
    atmos_grid_cartesc_cbfz(:) = max( min( atmos_grid_cartesc_cbfz(:), 1.0_rp ), 0.0_rp )
    atmos_grid_cartesc_fbfz(:) = max( min( atmos_grid_cartesc_fbfz(:), 1.0_rp ), 0.0_rp )

    deallocate( buffz )

    ! vertical coordinate (local domain)
    do k = 1, ka
       atmos_grid_cartesc_cdz(k) = atmos_grid_cartesc_fz(k) - atmos_grid_cartesc_fz(k-1)
       atmos_grid_cartesc_rcdz(k) = 1.0_rp / atmos_grid_cartesc_cdz(k)
    enddo

    do k = 1, ka-1
       atmos_grid_cartesc_fdz(k) = atmos_grid_cartesc_cz(k+1)-atmos_grid_cartesc_cz(k)
       atmos_grid_cartesc_rfdz(k) = 1.0_rp / atmos_grid_cartesc_fdz(k)
    enddo

    ! X-direction
    ! horizontal coordinate (local domain)
    do i = 0, ia
       ii = i + prc_2drank(prc_myrank,1) * imax

       atmos_grid_cartesc_fx(i) = atmos_grid_cartesc_fxg(ii)
    enddo

    ii = prc_2drank(prc_myrank,1) * imax
    atmos_grid_cartesc_fbfx(0) = atmos_grid_cartesc_fbfxg(ii)
    do i = 1, ia
       ii = i + prc_2drank(prc_myrank,1) * imax

       atmos_grid_cartesc_cx(i) = atmos_grid_cartesc_cxg(ii)
       atmos_grid_cartesc_cbfx(i) = atmos_grid_cartesc_cbfxg(ii)
       atmos_grid_cartesc_fbfx(i) = atmos_grid_cartesc_fbfxg(ii)

       atmos_grid_cartesc_cdx(i) = atmos_grid_cartesc_fx(i) - atmos_grid_cartesc_fx(i-1)
       atmos_grid_cartesc_rcdx(i) = 1.0_rp / atmos_grid_cartesc_cdx(i)
    enddo

    do i = 1, ia-1
       atmos_grid_cartesc_fdx(i) = atmos_grid_cartesc_cx(i+1)-atmos_grid_cartesc_cx(i)
       atmos_grid_cartesc_rfdx(i) = 1.0_rp / atmos_grid_cartesc_fdx(i)
    enddo

    ! Y-direction
    ! horizontal coordinate (local domain)
    do j = 0, ja
       jj = j + prc_2drank(prc_myrank,2) * jmax

       atmos_grid_cartesc_fy(j) = atmos_grid_cartesc_fyg(jj)
    enddo

    jj = prc_2drank(prc_myrank,2) * jmax
    atmos_grid_cartesc_fbfy(0) = atmos_grid_cartesc_fbfyg(jj)
    do j = 1, ja
       jj = j + prc_2drank(prc_myrank,2) * jmax

       atmos_grid_cartesc_cy(j) = atmos_grid_cartesc_cyg(jj)
       atmos_grid_cartesc_cbfy(j) = atmos_grid_cartesc_cbfyg(jj)
       atmos_grid_cartesc_fbfy(j) = atmos_grid_cartesc_fbfyg(jj)

       atmos_grid_cartesc_cdy(j) = atmos_grid_cartesc_fy(j) - atmos_grid_cartesc_fy(j-1)
       atmos_grid_cartesc_rcdy(j) = 1.0_rp / atmos_grid_cartesc_cdy(j)
    enddo

    do j = 1, ja-1
       atmos_grid_cartesc_fdy(j) = atmos_grid_cartesc_cy(j+1)-atmos_grid_cartesc_cy(j)
       atmos_grid_cartesc_rfdy(j) = 1.0_rp / atmos_grid_cartesc_fdy(j)
    enddo

    atmos_grid_cartesc_domain_center_x = 0.5_rp * ( atmos_grid_cartesc_fxg(ihalo) + atmos_grid_cartesc_fxg(iag-ihalo) )
    atmos_grid_cartesc_domain_center_y = 0.5_rp * ( atmos_grid_cartesc_fyg(jhalo) + atmos_grid_cartesc_fyg(jag-jhalo) )

    ! report
    log_newline
    log_info("ATMOS_GRID_CARTESC_generate",*)                   'Grid information '
    log_info_cont('(1x,A,3(1x,F9.3))') 'delta Z, X, Y [m]        :', dz, dx, dy

    log_newline
    log_info("ATMOS_GRID_CARTESC_generate",*)                'Main/buffer Grid (global) :'
    log_info_cont('(1x,2(A,I6))')   'Z: buffer = ', kbuff,' x 1, main = ',kmain
    log_info_cont('(1x,2(A,I6))')   'X: buffer = ', ibuff,' x 2, main = ',imain
    log_info_cont('(1x,2(A,I6))')   'Y: buffer = ', jbuff,' x 2, main = ',jmain

    log_newline
    log_info("ATMOS_GRID_CARTESC_generate",*)                'Domain size [km] (global) :'
    log_info_cont('(1x,7(A,F9.3))') 'Z:', &
                                                  atmos_grid_cartesc_fz(0)       *1.e-3_rp, ' -HALO-                    ',   &
                                                  atmos_grid_cartesc_fz(ks-1)    *1.e-3_rp, ' | ',        &
                                                  atmos_grid_cartesc_cz(ks)      *1.e-3_rp, ' - ',        &
                                                  atmos_grid_cartesc_cz(ke-kbuff)*1.e-3_rp, ' | ',        &
                                                  atmos_grid_cartesc_fz(ke-kbuff)*1.e-3_rp, ' -buffer- ', &
                                                  atmos_grid_cartesc_fz(ke)      *1.e-3_rp, ' -HALO- ',   &
                                                  atmos_grid_cartesc_fz(ka)      *1.e-3_rp
    log_info_cont('(1x,8(A,F9.3))') 'X:', &
                                                  atmos_grid_cartesc_fxg(0)              *1.e-3_rp, ' -HALO- ',   &
                                                  atmos_grid_cartesc_fxg(ihalo)          *1.e-3_rp, ' -buffer- ', &
                                                  atmos_grid_cartesc_fxg(ihalo+ibuff)    *1.e-3_rp, ' | ',        &
                                                  atmos_grid_cartesc_cxg(ihalo+ibuff+1)  *1.e-3_rp, ' - ',        &
                                                  atmos_grid_cartesc_cxg(iag-ihalo-ibuff)*1.e-3_rp, ' | ',        &
                                                  atmos_grid_cartesc_fxg(iag-ihalo-ibuff)*1.e-3_rp, ' -buffer- ', &
                                                  atmos_grid_cartesc_fxg(iag-ihalo)      *1.e-3_rp, ' -HALO- ',   &
                                                  atmos_grid_cartesc_fxg(iag)            *1.e-3_rp
    log_info_cont('(1x,8(A,F9.3))') 'Y:', &
                                                  atmos_grid_cartesc_fyg(0)              *1.e-3_rp, ' -HALO- ',   &
                                                  atmos_grid_cartesc_fyg(jhalo)          *1.e-3_rp, ' -buffer- ', &
                                                  atmos_grid_cartesc_fyg(jhalo+jbuff)    *1.e-3_rp, ' | ',        &
                                                  atmos_grid_cartesc_cyg(jhalo+jbuff+1)  *1.e-3_rp, ' - ',        &
                                                  atmos_grid_cartesc_cyg(jag-jhalo-jbuff)*1.e-3_rp, ' | ',        &
                                                  atmos_grid_cartesc_fyg(jag-jhalo-jbuff)*1.e-3_rp, ' -buffer- ', &
                                                  atmos_grid_cartesc_fyg(jag-jhalo)      *1.e-3_rp, ' -HALO- ',   &
                                                  atmos_grid_cartesc_fyg(jag)            *1.e-3_rp

    return
  end subroutine atmos_grid_cartesc_generate

  !-----------------------------------------------------------------------------
  subroutine atmos_grid_cartesc_output_info
    integer :: k

    log_newline
    log_info("ATMOS_GRID_CARTESC_output_info",*)                'Center Position of Grid (global) :'
    log_info_cont('(1x,A,F12.3)')   'X: ', atmos_grid_cartesc_domain_center_x
    log_info_cont('(1x,A,F12.3)')   'Y: ', atmos_grid_cartesc_domain_center_y


    log_newline
    log_info("ATMOS_GRID_CARTESC_output_info",*)                'Domain size [km] (local) :'
    log_info_cont('(1x,6(A,F9.3))') 'X:',                                                          &
                                                  atmos_grid_cartesc_fx(0) *1.e-3_rp, ' -HALO- ', atmos_grid_cartesc_fx(is-1)*1.e-3_rp, ' | ', &
                                                  atmos_grid_cartesc_cx(is)*1.e-3_rp, ' - ',      atmos_grid_cartesc_cx(ie)  *1.e-3_rp, ' | ', &
                                                  atmos_grid_cartesc_fx(ie)*1.e-3_rp, ' -HALO- ', atmos_grid_cartesc_fx(ia)  *1.e-3_rp
    log_info_cont('(1x,6(A,F9.3))') 'Y:',                    &
                                                  atmos_grid_cartesc_fy(0) *1.e-3_rp, ' -HALO- ', atmos_grid_cartesc_fy(js-1)*1.e-3_rp, ' | ', &
                                                  atmos_grid_cartesc_cy(js)*1.e-3_rp, ' - ',      atmos_grid_cartesc_cy(je)  *1.e-3_rp, ' | ', &
                                                  atmos_grid_cartesc_fy(je)*1.e-3_rp, ' -HALO- ', atmos_grid_cartesc_fy(ja)  *1.e-3_rp


    log_newline
    log_info("ATMOS_GRID_CARTESC_output_info",'(1x,A)') 'Vertical Coordinate'
    log_info_cont('(1x,A)') '|===============================================|'
    log_info_cont('(1x,A)') '|    k        z       zh       dz   buffer    k |'
    log_info_cont('(1x,A)') '|           [m]      [m]      [m]   factor      |'

    do k = ka, ke+1, -1
    log_info_cont('(1x,A,F9.2,A,F9.2,I5,A)')  '|              ',atmos_grid_cartesc_fz(k),'         ', atmos_grid_cartesc_fbfz(k),k,' |'
    log_info_cont('(1x,A,I5,F9.2,A,2F9.2,A)') '|',k,atmos_grid_cartesc_cz(k),'         ',atmos_grid_cartesc_cdz(k), atmos_grid_cartesc_cbfz(k),'      |'
    enddo

    k = ke
    log_info_cont('(1x,A,F9.2,A,F9.2,I5,A)')  '|              ',atmos_grid_cartesc_fz(k),'         ', atmos_grid_cartesc_fbfz(k),k,' | KE = TOA'
    log_info_cont('(1x,A,I5,F9.2,A,2F9.2,A)') '|',k,atmos_grid_cartesc_cz(k),'         ',atmos_grid_cartesc_cdz(k), atmos_grid_cartesc_cbfz(k),'      |'

    do k = ke-1, ks, -1
    log_info_cont('(1x,A,F9.2,A,F9.2,I5,A)')  '|              ',atmos_grid_cartesc_fz(k),'         ', atmos_grid_cartesc_fbfz(k),k,' |'
    log_info_cont('(1x,A,I5,F9.2,A,2F9.2,A)') '|',k,atmos_grid_cartesc_cz(k),'         ',atmos_grid_cartesc_cdz(k), atmos_grid_cartesc_cbfz(k),'      |'
    enddo

    k = ks-1
    log_info_cont('(1x,A,F9.2,A,F9.2,I5,A)')  '|              ',atmos_grid_cartesc_fz(k),'         ', atmos_grid_cartesc_fbfz(k),k,' | KS-1 = surface'
    log_info_cont('(1x,A,I5,F9.2,A,2F9.2,A)') '|',k,atmos_grid_cartesc_cz(k),'         ',atmos_grid_cartesc_cdz(k), atmos_grid_cartesc_cbfz(k),'      |'

    do k = ks-2, 1, -1
    log_info_cont('(1x,A,F9.2,A,F9.2,I5,A)')  '|              ',atmos_grid_cartesc_fz(k),'         ', atmos_grid_cartesc_fbfz(k),k,' |'
    log_info_cont('(1x,A,I5,F9.2,A,2F9.2,A)') '|',k,atmos_grid_cartesc_cz(k),'         ',atmos_grid_cartesc_cdz(k), atmos_grid_cartesc_cbfz(k),'      |'
    enddo

    k = 0
    log_info_cont('(1x,A,F9.2,A,F9.2,I5,A)') '|              ',atmos_grid_cartesc_fz(k),'         ', atmos_grid_cartesc_fbfz(k),k,' |'

    log_info_cont('(1x,A)') '|===============================================|'


    return
  end subroutine atmos_grid_cartesc_output_info

end module scale_atmos_grid_cartesc