mod_ocean_vars.f90

Go to the documentation of this file.

!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
module mod_ocean_vars
  !-----------------------------------------------------------------------------
  !
  !++ used modules
  !
  use scale_precision
  use scale_stdio
  use scale_prof
  use scale_debug
  use scale_grid_index

  use scale_const, only: &
     i_sw  => const_i_sw, &
     i_lw  => const_i_lw
  !-----------------------------------------------------------------------------
  implicit none
  private
  !-----------------------------------------------------------------------------
  !
  !++ Public procedure
  !
  public :: ocean_vars_setup
  public :: ocean_vars_restart_read
  public :: ocean_vars_restart_write
  public :: ocean_vars_history
  public :: ocean_vars_total
  public :: ocean_vars_external_in

  public :: ocean_vars_restart_create
  public :: ocean_vars_restart_open
  public :: ocean_vars_restart_def_var
  public :: ocean_vars_restart_enddef
  public :: ocean_vars_restart_close

  !-----------------------------------------------------------------------------
  !
  !++ Public parameters & variables
  !
  logical,               public :: ocean_restart_output                = .false.         

  character(len=H_LONG),  public :: ocean_restart_in_basename           = ''
  logical,                public :: ocean_restart_in_postfix_timelabel  = .false.         
  character(len=H_LONG),  public :: ocean_restart_out_basename          = ''
  logical,                public :: ocean_restart_out_postfix_timelabel = .true.          
  character(len=H_MID),   public :: ocean_restart_out_title             = 'OCEAN restart'
  character(len=H_SHORT), public :: ocean_restart_out_dtype             = 'DEFAULT'

  ! prognostic variables
  real(RP), public, allocatable :: ocean_temp      (:,:)
  real(RP), public, allocatable :: ocean_sfc_temp  (:,:)
  real(RP), public, allocatable :: ocean_sfc_albedo(:,:,:)
  real(RP), public, allocatable :: ocean_sfc_z0m   (:,:)
  real(RP), public, allocatable :: ocean_sfc_z0h   (:,:)
  real(RP), public, allocatable :: ocean_sfc_z0e   (:,:)

  ! tendency variables
  real(RP), public, allocatable :: ocean_temp_t      (:,:)
  real(RP), public, allocatable :: ocean_sfc_temp_t  (:,:)
  real(RP), public, allocatable :: ocean_sfc_albedo_t(:,:,:)
  real(RP), public, allocatable :: ocean_sfc_z0m_t   (:,:)
  real(RP), public, allocatable :: ocean_sfc_z0h_t   (:,:)
  real(RP), public, allocatable :: ocean_sfc_z0e_t   (:,:)

  ! surface variables for restart
  real(RP), public, allocatable :: ocean_sflx_mw  (:,:)
  real(RP), public, allocatable :: ocean_sflx_mu  (:,:)
  real(RP), public, allocatable :: ocean_sflx_mv  (:,:)
  real(RP), public, allocatable :: ocean_sflx_sh  (:,:)
  real(RP), public, allocatable :: ocean_sflx_lh  (:,:)
  real(RP), public, allocatable :: ocean_sflx_wh  (:,:)
  real(RP), public, allocatable :: ocean_sflx_evap(:,:)

  ! diagnostic variables
  real(RP), public, allocatable :: ocean_u10(:,:)
  real(RP), public, allocatable :: ocean_v10(:,:)
  real(RP), public, allocatable :: ocean_t2 (:,:)
  real(RP), public, allocatable :: ocean_q2 (:,:)

  ! recieved atmospheric variables
  real(RP), public, allocatable :: atmos_temp     (:,:)
  real(RP), public, allocatable :: atmos_pres     (:,:)
  real(RP), public, allocatable :: atmos_w        (:,:)
  real(RP), public, allocatable :: atmos_u        (:,:)
  real(RP), public, allocatable :: atmos_v        (:,:)
  real(RP), public, allocatable :: atmos_dens     (:,:)
  real(RP), public, allocatable :: atmos_qv       (:,:)
  real(RP), public, allocatable :: atmos_pbl      (:,:)
  real(RP), public, allocatable :: atmos_sfc_pres (:,:)
  real(RP), public, allocatable :: atmos_sflx_lw  (:,:)
  real(RP), public, allocatable :: atmos_sflx_sw  (:,:)
  real(RP), public, allocatable :: atmos_cossza   (:,:)
  real(RP), public, allocatable :: atmos_sflx_prec(:,:)

  !-----------------------------------------------------------------------------
  !
  !++ Private procedure
  !
  !-----------------------------------------------------------------------------
  !
  !++ Private parameters & variables
  !
  logical,                private :: ocean_vars_checkrange      = .false.

  integer,                private, parameter :: vmax        = 14
  integer,                private, parameter :: i_temp      =  1
  integer,                private, parameter :: i_sfc_temp  =  2
  integer,                private, parameter :: i_alb_lw    =  3
  integer,                private, parameter :: i_alb_sw    =  4
  integer,                private, parameter :: i_sfc_z0m   =  5
  integer,                private, parameter :: i_sfc_z0h   =  6
  integer,                private, parameter :: i_sfc_z0e   =  7
  integer,                private, parameter :: i_sflx_mw   =  8
  integer,                private, parameter :: i_sflx_mu   =  9
  integer,                private, parameter :: i_sflx_mv   = 10
  integer,                private, parameter :: i_sflx_sh   = 11
  integer,                private, parameter :: i_sflx_lh   = 12
  integer,                private, parameter :: i_sflx_wh   = 13
  integer,                private, parameter :: i_sflx_evap = 14

  character(len=H_SHORT), private            :: var_name(vmax)
  character(len=H_MID),   private            :: var_desc(vmax)
  character(len=H_SHORT), private            :: var_unit(vmax)
  integer,                private            :: var_id(vmax)
  integer,                private            :: restart_fid = -1  ! file ID

  logical,                private            :: ocean_restart_in_check_coordinates = .true.

  data var_name / 'OCEAN_TEMP',      &
                  'OCEAN_SFC_TEMP',  &
                  'OCEAN_ALB_LW',    &
                  'OCEAN_ALB_SW',    &
                  'OCEAN_SFC_Z0M',   &
                  'OCEAN_SFC_Z0H',   &
                  'OCEAN_SFC_Z0E',   &
                  'OCEAN_SFLX_MW',   &
                  'OCEAN_SFLX_MU',   &
                  'OCEAN_SFLX_MV',   &
                  'OCEAN_SFLX_SH',   &
                  'OCEAN_SFLX_LH',   &
                  'OCEAN_SFLX_WH',   &
                  'OCEAN_SFLX_evap'  /
  data var_desc / 'temperature at uppermost ocean layer', &
                  'ocean surface skin temperature',             &
                  'ocean surface albedo (longwave)',            &
                  'ocean surface albedo (shortwave)',           &
                  'ocean surface roughness length (momentum)',  &
                  'ocean surface roughness length (heat)',      &
                  'ocean surface roughness length (vapor)',     &
                  'ocean surface w-momentum flux',              &
                  'ocean surface u-momentum flux',              &
                  'ocean surface v-momentum flux',              &
                  'ocean surface sensible heat flux',           &
                  'ocean surface latent heat flux',             &
                  'ocean surface water heat flux',              &
                  'ocean surface water vapor flux'              /
  data var_unit / 'K',       &
                  'K',       &
                  '1',       &
                  '1',       &
                  'm',       &
                  'm',       &
                  'm',       &
                  'kg/m2/s', &
                  'kg/m2/s', &
                  'kg/m2/s', &
                  'J/m2/s',  &
                  'J/m2/s',  &
                  'J/m2/s',  &
                  'kg/m2/s'  /

  !-----------------------------------------------------------------------------
contains
  !-----------------------------------------------------------------------------
  subroutine ocean_vars_setup
    use scale_process, only: &
       prc_mpistop
    use scale_const, only: &
       undef => const_undef
    implicit none

    namelist / param_ocean_vars /  &
       ocean_restart_in_basename,           &
       ocean_restart_in_postfix_timelabel,  &
       ocean_restart_in_check_coordinates,  &
       ocean_restart_output,                &
       ocean_restart_out_basename,          &
       ocean_restart_out_postfix_timelabel, &
       ocean_restart_out_title,             &
       ocean_restart_out_dtype,             &
       ocean_vars_checkrange

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

    if( io_l ) write(io_fid_log,*)
    if( io_l ) write(io_fid_log,*) '++++++ Module[VARS] / Categ[OCEAN] / Origin[SCALE-RM]'

    allocate( ocean_temp(ia,ja)   )
    allocate( ocean_sfc_temp(ia,ja)   )
    allocate( ocean_sfc_albedo(ia,ja,2) )
    allocate( ocean_sfc_z0m(ia,ja)   )
    allocate( ocean_sfc_z0h(ia,ja)   )
    allocate( ocean_sfc_z0e(ia,ja)   )
    ocean_temp(:,:)   = undef
    ocean_sfc_temp(:,:)   = undef
    ocean_sfc_albedo(:,:,:) = undef
    ocean_sfc_z0m(:,:)   = undef
    ocean_sfc_z0h(:,:)   = undef
    ocean_sfc_z0e(:,:)   = undef

    allocate( ocean_temp_t(ia,ja)   )
    allocate( ocean_sfc_temp_t(ia,ja)   )
    allocate( ocean_sfc_albedo_t(ia,ja,2) )
    allocate( ocean_sfc_z0m_t(ia,ja)   )
    allocate( ocean_sfc_z0h_t(ia,ja)   )
    allocate( ocean_sfc_z0e_t(ia,ja)   )
    ocean_temp_t(:,:)   = undef
    ocean_sfc_temp_t(:,:)   = undef
    ocean_sfc_albedo_t(:,:,:) = undef
    ocean_sfc_z0m_t(:,:)   = undef
    ocean_sfc_z0h_t(:,:)   = undef
    ocean_sfc_z0e_t(:,:)   = undef

    allocate( ocean_sflx_mw(ia,ja) )
    allocate( ocean_sflx_mu(ia,ja) )
    allocate( ocean_sflx_mv(ia,ja) )
    allocate( ocean_sflx_sh(ia,ja) )
    allocate( ocean_sflx_lh(ia,ja) )
    allocate( ocean_sflx_wh(ia,ja) )
    allocate( ocean_sflx_evap(ia,ja) )
    ocean_sflx_mw(:,:) = undef
    ocean_sflx_mu(:,:) = undef
    ocean_sflx_mv(:,:) = undef
    ocean_sflx_sh(:,:) = undef
    ocean_sflx_lh(:,:) = undef
    ocean_sflx_wh(:,:) = undef
    ocean_sflx_evap(:,:) = undef

    allocate( ocean_u10(ia,ja) )
    allocate( ocean_v10(ia,ja) )
    allocate( ocean_t2(ia,ja) )
    allocate( ocean_q2(ia,ja) )
    ocean_u10(:,:) = undef
    ocean_v10(:,:) = undef
    ocean_t2(:,:) = undef
    ocean_q2(:,:) = undef

    allocate( atmos_temp(ia,ja) )
    allocate( atmos_pres(ia,ja) )
    allocate( atmos_w(ia,ja) )
    allocate( atmos_u(ia,ja) )
    allocate( atmos_v(ia,ja) )
    allocate( atmos_dens(ia,ja) )
    allocate( atmos_qv(ia,ja) )
    allocate( atmos_pbl(ia,ja) )
    allocate( atmos_sfc_pres(ia,ja) )
    allocate( atmos_sflx_lw(ia,ja) )
    allocate( atmos_sflx_sw(ia,ja) )
    allocate( atmos_cossza(ia,ja) )
    allocate( atmos_sflx_prec(ia,ja) )
    atmos_temp(:,:) = undef
    atmos_pres(:,:) = undef
    atmos_w(:,:) = undef
    atmos_u(:,:) = undef
    atmos_v(:,:) = undef
    atmos_dens(:,:) = undef
    atmos_qv(:,:) = undef
    atmos_pbl(:,:) = undef
    atmos_sfc_pres(:,:) = undef
    atmos_sflx_lw(:,:) = undef
    atmos_sflx_sw(:,:) = undef
    atmos_cossza(:,:) = undef
    atmos_sflx_prec(:,:) = undef

    !--- read namelist
    rewind(io_fid_conf)
    read(io_fid_conf,nml=param_ocean_vars,iostat=ierr)
    if( ierr < 0 ) then !--- missing
       if( io_l ) write(io_fid_log,*) '*** Not found namelist. Default used.'
    elseif( ierr > 0 ) then !--- fatal error
       write(*,*) 'xxx Not appropriate names in namelist PARAM_OCEAN_VARS. Check!'
       call prc_mpistop
    endif
    if( io_nml ) write(io_fid_nml,nml=param_ocean_vars)

    if( io_l ) write(io_fid_log,*)
    if( io_l ) write(io_fid_log,*) '*** List of prognostic variables (OCEAN) ***'
    if( io_l ) write(io_fid_log,'(1x,A,A24,A,A48,A,A12,A)') &
               '***       |', 'VARNAME                 ','|', &
               'DESCRIPTION                                     ', '[', 'UNIT        ', ']'
    do iv = 1, vmax
       if( io_l ) write(io_fid_log,'(1x,A,I3,A,A24,A,A48,A,A12,A)') &
                  '*** NO.',iv,'|',var_name(iv),'|',var_desc(iv),'[',var_unit(iv),']'

    enddo

    if( io_l ) write(io_fid_log,*)
    if ( ocean_restart_in_basename /= '' ) then
       if( io_l ) write(io_fid_log,*) '*** Restart input?  : YES, file = ', trim(ocean_restart_in_basename)
       if( io_l ) write(io_fid_log,*) '*** Add timelabel?  : ', ocean_restart_in_postfix_timelabel
    else
       if( io_l ) write(io_fid_log,*) '*** Restart input?  : NO'
    endif
    if (       ocean_restart_output             &
         .AND. ocean_restart_out_basename /= '' ) then
       if( io_l ) write(io_fid_log,*) '*** Restart output? : YES, file = ', trim(ocean_restart_out_basename)
       if( io_l ) write(io_fid_log,*) '*** Add timelabel?  : ', ocean_restart_out_postfix_timelabel
    else
       if( io_l ) write(io_fid_log,*) '*** Restart output? : NO'
       ocean_restart_output = .false.
    endif

    return
  end subroutine ocean_vars_setup

  !-----------------------------------------------------------------------------
  subroutine ocean_vars_restart_open
    use scale_time, only: &
       time_gettimelabel
    use scale_fileio, only: &
       fileio_open, &
       fileio_check_coordinates
    use mod_ocean_admin, only: &
       ocean_sw
    implicit none

    character(len=19)     :: timelabel
    character(len=H_LONG) :: basename
    !---------------------------------------------------------------------------

    if( io_l ) write(io_fid_log,*)
    if( io_l ) write(io_fid_log,*) '*** Open restart file (OCEAN) ***'

    if ( ocean_sw .and. ocean_restart_in_basename /= '' ) then

       if ( ocean_restart_in_postfix_timelabel ) then
          call time_gettimelabel( timelabel )
          basename = trim(ocean_restart_in_basename)//'_'//trim(timelabel)
       else
          basename = trim(ocean_restart_in_basename)
       endif

       if( io_l ) write(io_fid_log,*) '*** basename: ', trim(basename)

       call fileio_open( restart_fid, & ! [OUT]
                         basename     ) ! [IN]

       if ( ocean_restart_in_check_coordinates ) then
          call fileio_check_coordinates( restart_fid )
       end if

    else
       if( io_l ) write(io_fid_log,*) '*** restart file for ocean is not specified.'
    endif

    return
  end subroutine ocean_vars_restart_open

  !-----------------------------------------------------------------------------
  subroutine ocean_vars_restart_read
    use scale_fileio, only: &
       fileio_read, &
       fileio_flush
    implicit none
    !---------------------------------------------------------------------------

    if ( restart_fid /= -1 ) then
       if( io_l ) write(io_fid_log,*)
       if( io_l ) write(io_fid_log,*) '*** Read from restart file (OCEAN) ***'

       call fileio_read( ocean_temp(:,:),                                 & ! [OUT]
                         restart_fid, var_name(i_temp),      'XY', step=1 ) ! [IN]
       call fileio_read( ocean_sfc_temp(:,:),                             & ! [OUT]
                         restart_fid, var_name(i_sfc_temp),  'XY', step=1 ) ! [IN]
       call fileio_read( ocean_sfc_albedo(:,:,i_lw),                      & ! [OUT]
                         restart_fid, var_name(i_alb_lw),    'XY', step=1 ) ! [IN]
       call fileio_read( ocean_sfc_albedo(:,:,i_sw),                      & ! [OUT]
                         restart_fid, var_name(i_alb_sw),    'XY', step=1 ) ! [IN]
       call fileio_read( ocean_sfc_z0m(:,:),                              & ! [OUT]
                         restart_fid, var_name(i_sfc_z0m),   'XY', step=1 ) ! [IN]
       call fileio_read( ocean_sfc_z0h(:,:),                              & ! [OUT]
                         restart_fid, var_name(i_sfc_z0h),   'XY', step=1 ) ! [IN]
       call fileio_read( ocean_sfc_z0e(:,:),                              & ! [OUT]
                         restart_fid, var_name(i_sfc_z0e),   'XY', step=1 ) ! [IN]

       call fileio_read( ocean_sflx_mw(:,:),                              & ! [OUT]
                         restart_fid, var_name(i_sflx_mw),   'XY', step=1 ) ! [IN]
       call fileio_read( ocean_sflx_mu(:,:),                              & ! [OUT]
                         restart_fid, var_name(i_sflx_mu),   'XY', step=1 ) ! [IN]
       call fileio_read( ocean_sflx_mv(:,:),                              & ! [OUT]
                         restart_fid, var_name(i_sflx_mv),   'XY', step=1 ) ! [IN]
       call fileio_read( ocean_sflx_sh(:,:),                              & ! [OUT]
                         restart_fid, var_name(i_sflx_sh),   'XY', step=1 ) ! [IN]
       call fileio_read( ocean_sflx_lh(:,:),                              & ! [OUT]
                         restart_fid, var_name(i_sflx_lh),   'XY', step=1 ) ! [IN]
       call fileio_read( ocean_sflx_wh(:,:),                              & ! [OUT]
                         restart_fid, var_name(i_sflx_wh),   'XY', step=1 ) ! [IN]
       call fileio_read( ocean_sflx_evap(:,:),                            & ! [OUT]
                         restart_fid, var_name(i_sflx_evap), 'XY', step=1 ) ! [IN]

       if( io_aggregate ) call fileio_flush( restart_fid ) ! commit all pending read requests

       call ocean_vars_total
    else
       if( io_l ) write(io_fid_log,*) '*** invalid restart file ID for ocean.'
    endif

    return
  end subroutine ocean_vars_restart_read

  !-----------------------------------------------------------------------------
  subroutine ocean_vars_history
    use scale_history, only: &
       hist_in
    implicit none
    !---------------------------------------------------------------------------

    if ( ocean_vars_checkrange ) then
       call valcheck( ocean_temp(is:ie,js:je),      0.0_rp, 1000.0_rp, var_name(i_temp),     &
                     __file__, __line__ )
       call valcheck( ocean_sfc_temp(is:ie,js:je),      0.0_rp, 1000.0_rp, var_name(i_sfc_temp), &
                     __file__, __line__ )
       call valcheck( ocean_sfc_albedo(is:ie,js:je,i_lw), 0.0_rp,    2.0_rp, var_name(i_alb_lw),   &
                     __file__, __line__ )
       call valcheck( ocean_sfc_albedo(is:ie,js:je,i_sw), 0.0_rp,    2.0_rp, var_name(i_alb_sw),   &
                     __file__, __line__ )
       call valcheck( ocean_sfc_z0m(is:ie,js:je),      0.0_rp, 1000.0_rp, var_name(i_sfc_z0m),  &
                     __file__, __line__ )
       call valcheck( ocean_sfc_z0h(is:ie,js:je),      0.0_rp, 1000.0_rp, var_name(i_sfc_z0h),  &
                     __file__, __line__ )
       call valcheck( ocean_sfc_z0e(is:ie,js:je),      0.0_rp, 1000.0_rp, var_name(i_sfc_z0e),  &
                     __file__, __line__ )
    endif

    call hist_in( ocean_temp(:,:),      var_name(i_temp),     var_desc(i_temp),     var_unit(i_temp)     )
    call hist_in( ocean_sfc_temp(:,:),      var_name(i_sfc_temp), var_desc(i_sfc_temp), var_unit(i_sfc_temp) )
    call hist_in( ocean_sfc_albedo(:,:,i_lw), var_name(i_alb_lw),   var_desc(i_alb_lw),   var_unit(i_alb_lw)   )
    call hist_in( ocean_sfc_albedo(:,:,i_sw), var_name(i_alb_sw),   var_desc(i_alb_sw),   var_unit(i_alb_sw)   )
    call hist_in( ocean_sfc_z0m(:,:),      var_name(i_sfc_z0m),  var_desc(i_sfc_z0m),  var_unit(i_sfc_z0m)  )
    call hist_in( ocean_sfc_z0h(:,:),      var_name(i_sfc_z0h),  var_desc(i_sfc_z0h),  var_unit(i_sfc_z0h)  )
    call hist_in( ocean_sfc_z0e(:,:),      var_name(i_sfc_z0e),  var_desc(i_sfc_z0e),  var_unit(i_sfc_z0e)  )

    call hist_in( ocean_sflx_mw(:,:), var_name(i_sflx_mw),   var_desc(i_sflx_mw),   var_unit(i_sflx_mw)   )
    call hist_in( ocean_sflx_mu(:,:), var_name(i_sflx_mu),   var_desc(i_sflx_mu),   var_unit(i_sflx_mu)   )
    call hist_in( ocean_sflx_mv(:,:), var_name(i_sflx_mv),   var_desc(i_sflx_mv),   var_unit(i_sflx_mv)   )
    call hist_in( ocean_sflx_sh(:,:), var_name(i_sflx_sh),   var_desc(i_sflx_sh),   var_unit(i_sflx_sh)   )
    call hist_in( ocean_sflx_lh(:,:), var_name(i_sflx_lh),   var_desc(i_sflx_lh),   var_unit(i_sflx_lh)   )
    call hist_in( ocean_sflx_wh(:,:), var_name(i_sflx_wh),   var_desc(i_sflx_wh),   var_unit(i_sflx_wh)   )
    call hist_in( ocean_sflx_evap(:,:), var_name(i_sflx_evap), var_desc(i_sflx_evap), var_unit(i_sflx_evap) )

    return
  end subroutine ocean_vars_history

  !-----------------------------------------------------------------------------
  subroutine ocean_vars_total
    use scale_rm_statistics, only: &
       statistics_checktotal, &
       stat_total
    implicit none

    real(RP) :: total
    !---------------------------------------------------------------------------

    if ( statistics_checktotal ) then

       call stat_total( total, ocean_temp(:,:),      var_name(i_temp)     )
       call stat_total( total, ocean_sfc_temp(:,:),      var_name(i_sfc_temp) )
       call stat_total( total, ocean_sfc_albedo(:,:,i_lw), var_name(i_alb_lw)   )
       call stat_total( total, ocean_sfc_albedo(:,:,i_sw), var_name(i_alb_sw)   )
       call stat_total( total, ocean_sfc_z0m(:,:),      var_name(i_sfc_z0m)  )
       call stat_total( total, ocean_sfc_z0h(:,:),      var_name(i_sfc_z0h)  )
       call stat_total( total, ocean_sfc_z0e(:,:),      var_name(i_sfc_z0e)  )

       call stat_total( total, ocean_sflx_mw(:,:), var_name(i_sflx_mw)   )
       call stat_total( total, ocean_sflx_mu(:,:), var_name(i_sflx_mu)   )
       call stat_total( total, ocean_sflx_mv(:,:), var_name(i_sflx_mv)   )
       call stat_total( total, ocean_sflx_sh(:,:), var_name(i_sflx_sh)   )
       call stat_total( total, ocean_sflx_lh(:,:), var_name(i_sflx_lh)   )
       call stat_total( total, ocean_sflx_wh(:,:), var_name(i_sflx_wh)   )
       call stat_total( total, ocean_sflx_evap(:,:), var_name(i_sflx_evap) )

    endif

    return
  end subroutine ocean_vars_total

  !-----------------------------------------------------------------------------
  subroutine ocean_vars_external_in( &
       OCEAN_TEMP_in,       &
       OCEAN_SFC_TEMP_in,   &
       OCEAN_SFC_albedo_in, &
       OCEAN_SFC_Z0M_in,    &
       OCEAN_SFC_Z0H_in,    &
       OCEAN_SFC_Z0E_in     )
    implicit none

    real(RP), intent(in) :: ocean_temp_in      (ia,ja)
    real(RP), intent(in) :: ocean_sfc_temp_in  (ia,ja)
    real(RP), intent(in) :: ocean_sfc_albedo_in(ia,ja,2)
    real(RP), intent(in) :: ocean_sfc_z0m_in   (ia,ja)
    real(RP), intent(in) :: ocean_sfc_z0h_in   (ia,ja)
    real(RP), intent(in) :: ocean_sfc_z0e_in   (ia,ja)
    !---------------------------------------------------------------------------

    if( io_l ) write(io_fid_log,*)
    if( io_l ) write(io_fid_log,*) '*** External Input file (ocean) ***'

    ocean_temp(:,:)   = ocean_temp_in(:,:)
    ocean_sfc_temp(:,:)   = ocean_sfc_temp_in(:,:)
    ocean_sfc_albedo(:,:,:) = ocean_sfc_albedo_in(:,:,:)
    ocean_sfc_z0m(:,:)   = ocean_sfc_z0m_in(:,:)
    ocean_sfc_z0h(:,:)   = ocean_sfc_z0h_in(:,:)
    ocean_sfc_z0e(:,:)   = ocean_sfc_z0e_in(:,:)

    ocean_sflx_mw(:,:) = 0.0_rp
    ocean_sflx_mu(:,:) = 0.0_rp
    ocean_sflx_mv(:,:) = 0.0_rp
    ocean_sflx_sh(:,:) = 0.0_rp
    ocean_sflx_lh(:,:) = 0.0_rp
    ocean_sflx_wh(:,:) = 0.0_rp
    ocean_sflx_evap(:,:) = 0.0_rp

    call ocean_vars_total

    return
  end subroutine ocean_vars_external_in

  !-----------------------------------------------------------------------------
  subroutine ocean_vars_restart_create
    use scale_time, only: &
       time_gettimelabel
    use scale_fileio, only: &
       fileio_create
    use mod_ocean_admin, only: &
       ocean_sw
    implicit none

    character(len=19)     :: timelabel
    character(len=H_LONG) :: basename
    !---------------------------------------------------------------------------

    if ( ocean_sw .and. ocean_restart_out_basename /= '' ) then

       if( io_l ) write(io_fid_log,*)
       if( io_l ) write(io_fid_log,*) '*** Create restart file (OCEAN) ***'

       if ( ocean_restart_out_postfix_timelabel ) then
          call time_gettimelabel( timelabel )
          basename = trim(ocean_restart_out_basename)//'_'//trim(timelabel)
       else
          basename = trim(ocean_restart_out_basename)
       endif

       if( io_l ) write(io_fid_log,*) '*** basename: ', trim(basename)

       call fileio_create( restart_fid,                                               & ! [OUT]
                           basename, ocean_restart_out_title, ocean_restart_out_dtype ) ! [IN]

    endif

    return
  end subroutine ocean_vars_restart_create

  !-----------------------------------------------------------------------------
  subroutine ocean_vars_restart_enddef
    use scale_fileio, only: &
       fileio_enddef
    implicit none

    if ( restart_fid /= -1 ) then
       call fileio_enddef( restart_fid ) ! [IN]
    endif

    return
  end subroutine ocean_vars_restart_enddef

  !-----------------------------------------------------------------------------
  subroutine ocean_vars_restart_close
    use scale_fileio, only: &
       fileio_close
    implicit none
    !---------------------------------------------------------------------------

    if ( restart_fid /= -1 ) then
       if( io_l ) write(io_fid_log,*)
       if( io_l ) write(io_fid_log,*) '*** Close restart file (OCEAN) ***'

       call fileio_close( restart_fid ) ! [IN]

       restart_fid = -1
    endif

    return
  end subroutine ocean_vars_restart_close

  !-----------------------------------------------------------------------------
  subroutine ocean_vars_restart_def_var
    use scale_fileio, only: &
       fileio_def_var
    implicit none
    !---------------------------------------------------------------------------

    if ( restart_fid /= -1 ) then

       call fileio_def_var( restart_fid, var_id(i_temp),      var_name(i_temp),      var_desc(i_temp),      &
                            var_unit(i_temp),      'XY', ocean_restart_out_dtype)
       call fileio_def_var( restart_fid, var_id(i_sfc_temp),  var_name(i_sfc_temp),  var_desc(i_sfc_temp),  &
                            var_unit(i_sfc_temp),  'XY', ocean_restart_out_dtype)
       call fileio_def_var( restart_fid, var_id(i_alb_lw),    var_name(i_alb_lw),    var_desc(i_alb_lw),    &
                            var_unit(i_alb_lw),    'XY', ocean_restart_out_dtype)
       call fileio_def_var( restart_fid, var_id(i_alb_sw),    var_name(i_alb_sw),    var_desc(i_alb_sw),    &
                            var_unit(i_alb_sw),    'XY', ocean_restart_out_dtype)
       call fileio_def_var( restart_fid, var_id(i_sfc_z0m),   var_name(i_sfc_z0m),   var_desc(i_sfc_z0m),   &
                            var_unit(i_sfc_z0m),   'XY', ocean_restart_out_dtype)
       call fileio_def_var( restart_fid, var_id(i_sfc_z0h),   var_name(i_sfc_z0h),   var_desc(i_sfc_z0h),   &
                            var_unit(i_sfc_z0h),   'XY', ocean_restart_out_dtype)
       call fileio_def_var( restart_fid, var_id(i_sfc_z0e),   var_name(i_sfc_z0e),   var_desc(i_sfc_z0e),   &
                            var_unit(i_sfc_z0e),   'XY', ocean_restart_out_dtype)
       call fileio_def_var( restart_fid, var_id(i_sflx_mw),   var_name(i_sflx_mw),   var_desc(i_sflx_mw),   &
                            var_unit(i_sflx_mw),   'XY', ocean_restart_out_dtype)
       call fileio_def_var( restart_fid, var_id(i_sflx_mu),   var_name(i_sflx_mu),   var_desc(i_sflx_mu),   &
                             var_unit(i_sflx_mu),  'XY', ocean_restart_out_dtype)
       call fileio_def_var( restart_fid, var_id(i_sflx_mv),   var_name(i_sflx_mv),   var_desc(i_sflx_mv),   &
                            var_unit(i_sflx_mv),   'XY', ocean_restart_out_dtype)
       call fileio_def_var( restart_fid, var_id(i_sflx_sh),   var_name(i_sflx_sh),   var_desc(i_sflx_sh),   &
                            var_unit(i_sflx_sh),   'XY', ocean_restart_out_dtype)
       call fileio_def_var( restart_fid, var_id(i_sflx_lh),   var_name(i_sflx_lh),   var_desc(i_sflx_lh),   &
                            var_unit(i_sflx_lh),   'XY', ocean_restart_out_dtype)
       call fileio_def_var( restart_fid, var_id(i_sflx_wh),   var_name(i_sflx_wh),   var_desc(i_sflx_wh),   &
                            var_unit(i_sflx_wh),   'XY', ocean_restart_out_dtype)
       call fileio_def_var( restart_fid, var_id(i_sflx_evap), var_name(i_sflx_evap), var_desc(i_sflx_evap), &
                            var_unit(i_sflx_evap), 'XY', ocean_restart_out_dtype)

    endif

    return
  end subroutine ocean_vars_restart_def_var

  !-----------------------------------------------------------------------------
  subroutine ocean_vars_restart_write
    use scale_fileio, only: &
       fileio_write_var
    implicit none
    !---------------------------------------------------------------------------

    if ( restart_fid /= -1 ) then

       call ocean_vars_total

       call fileio_write_var( restart_fid, var_id(i_temp), ocean_temp(:,:),              & ! [IN]
                              var_name(i_temp),      'XY', nohalo=.true.                 ) ! [IN]
       call fileio_write_var( restart_fid, var_id(i_sfc_temp), ocean_sfc_temp(:,:),      & ! [IN]
                              var_name(i_sfc_temp),  'XY', nohalo=.true.                 ) ! [IN]
       call fileio_write_var( restart_fid, var_id(i_alb_lw), ocean_sfc_albedo(:,:,i_lw), & ! [IN]
                              var_name(i_alb_lw),    'XY', nohalo=.true.                 ) ! [IN]
       call fileio_write_var( restart_fid, var_id(i_alb_sw), ocean_sfc_albedo(:,:,i_sw), & ! [IN]
                              var_name(i_alb_sw),    'XY',  nohalo=.true.                ) ! [IN]
       call fileio_write_var( restart_fid, var_id(i_sfc_z0m), ocean_sfc_z0m(:,:),        & ! [IN]
                              var_name(i_sfc_z0m),   'XY', nohalo=.true.                 ) ! [IN]
       call fileio_write_var( restart_fid, var_id(i_sfc_z0h), ocean_sfc_z0h(:,:),        & ! [IN]
                              var_name(i_sfc_z0h),   'XY', nohalo=.true.                 ) ! [IN]
       call fileio_write_var( restart_fid, var_id(i_sfc_z0e), ocean_sfc_z0e(:,:),        & ! [IN]
                              var_name(i_sfc_z0e),   'XY', nohalo=.true.                 ) ! [IN]
       call fileio_write_var( restart_fid, var_id(i_sflx_mw), ocean_sflx_mw(:,:),        & ! [IN]
                              var_name(i_sflx_mw),   'XY', nohalo=.true.                 ) ! [IN]
       call fileio_write_var( restart_fid, var_id(i_sflx_mu), ocean_sflx_mu(:,:),        & ! [IN]
                              var_name(i_sflx_mu),   'XY', nohalo=.true.                 ) ! [IN]
       call fileio_write_var( restart_fid, var_id(i_sflx_mv), ocean_sflx_mv(:,:),        & ! [IN]
                              var_name(i_sflx_mv),   'XY', nohalo=.true.                 ) ! [IN]
       call fileio_write_var( restart_fid, var_id(i_sflx_sh), ocean_sflx_sh(:,:),        & ! [IN]
                              var_name(i_sflx_sh),   'XY', nohalo=.true.                 ) ! [IN]
       call fileio_write_var( restart_fid, var_id(i_sflx_lh), ocean_sflx_lh(:,:),        & ! [IN]
                              var_name(i_sflx_lh),   'XY', nohalo=.true.                 ) ! [IN]
       call fileio_write_var( restart_fid, var_id(i_sflx_wh), ocean_sflx_wh(:,:),        & ! [IN]
                              var_name(i_sflx_wh),   'XY', nohalo=.true.                 ) ! [IN]
       call fileio_write_var( restart_fid, var_id(i_sflx_evap), ocean_sflx_evap(:,:),    & ! [IN]
                              var_name(i_sflx_evap), 'XY', nohalo=.true.                 ) ! [IN]

    endif

    return
  end subroutine ocean_vars_restart_write

end module mod_ocean_vars