MOM_coord_initialization.F90

Go to the documentation of this file.

!> Initializes fixed aspects of the related to its vertical coordinate.
module mom_coord_initialization
 
! This file is part of MOM6. See LICENSE.md for the license.
 
use mom_debugging, only : chksum
use mom_eos, only : calculate_density, eos_type
use mom_error_handler, only : mom_mesg, mom_error, fatal, warning, is_root_pe
use mom_error_handler, only : calltree_enter, calltree_leave, calltree_waypoint
use mom_file_parser, only : get_param, read_param, log_param, param_file_type
use mom_file_parser, only : log_version
use mom_io, only : close_file, create_file, fieldtype, file_exists
use mom_io, only : open_file, mom_read_data, read_axis_data, single_file, multiple
use mom_io, only : slasher, vardesc, write_field, var_desc
use mom_string_functions, only : uppercase
use mom_unit_scaling, only : unit_scale_type
use mom_variables, only : thermo_var_ptrs
use mom_verticalgrid, only : verticalgrid_type, setverticalgridaxes
use user_initialization, only : user_set_coord
use bfb_initialization, only : bfb_set_coord
 
use netcdf
 
implicit none ; private
 
public mom_initialize_coord
 
! A note on unit descriptions in comments: MOM6 uses units that can be rescaled for dimensional
! consistency testing. These are noted in comments with units like Z, H, L, and T, along with
! their mks counterparts with notation like "a velocity [Z T-1 ~> m s-1]".  If the units
! vary with the Boussinesq approximation, the Boussinesq variant is given first.
 
character(len=40) :: mdl = "MOM_coord_initialization" !< This module's name.
 
contains
 
!> MOM_initialize_coord sets up time-invariant quantities related to MOM6's
!!   vertical coordinate.
subroutine mom_initialize_coord(GV, US, PF, write_geom, output_dir, tv, max_depth)
  type(verticalgrid_type), intent(inout) :: gv         !< Ocean vertical grid structure.
  type(unit_scale_type),   intent(in)    :: us         !< A dimensional unit scaling type
  type(param_file_type),   intent(in)    :: pf         !< A structure indicating the open file
                                                       !! to parse for model parameter values.
  logical,                 intent(in)    :: write_geom !< If true, write grid geometry files.
  character(len=*),        intent(in)    :: output_dir !< The directory into which to write files.
  type(thermo_var_ptrs),   intent(inout) :: tv         !< The thermodynamic variable structure.
  real,                    intent(in)    :: max_depth  !< The ocean's maximum depth [Z ~> m].
  ! Local
  character(len=200) :: config
  logical :: debug
! This include declares and sets the variable "version".
#include "version_variable.h"
  integer :: nz
  type(eos_type), pointer :: eos => null()
 
  if (associated(tv%eqn_of_state)) eos => tv%eqn_of_state
 
  nz = gv%ke
 
  call calltree_enter("MOM_initialize_coord(), MOM_coord_initialization.F90")
  call log_version(pf, mdl, version, "")
  call get_param(pf, mdl, "DEBUG", debug, default=.false.)
 
! Set-up the layer densities, GV%Rlay, and reduced gravities, GV%g_prime.
  call get_param(pf, mdl, "COORD_CONFIG", config, &
                 "This specifies how layers are to be defined: \n"//&
                 " \t ALE or none - used to avoid defining layers in ALE mode \n"//&
                 " \t file - read coordinate information from the file \n"//&
                 " \t\t specified by (COORD_FILE).\n"//&
                 " \t BFB - Custom coords for buoyancy-forced basin case \n"//&
                 " \t\t based on SST_S, T_BOT and DRHO_DT.\n"//&
                 " \t linear - linear based on interfaces not layers \n"//&
                 " \t layer_ref - linear based on layer densities \n"//&
                 " \t ts_ref - use reference temperature and salinity \n"//&
                 " \t ts_range - use range of temperature and salinity \n"//&
                 " \t\t (T_REF and S_REF) to determine surface density \n"//&
                 " \t\t and GINT calculate internal densities. \n"//&
                 " \t gprime - use reference density (RHO_0) for surface \n"//&
                 " \t\t density and GINT calculate internal densities. \n"//&
                 " \t ts_profile - use temperature and salinity profiles \n"//&
                 " \t\t (read from COORD_FILE) to set layer densities. \n"//&
                 " \t USER - call a user modified routine.", &
                 fail_if_missing=.true.)
  select case ( trim(config) )
    case ("gprime")
      call set_coord_from_gprime(gv%Rlay, gv%g_prime, gv, us, pf)
    case ("layer_ref")
      call set_coord_from_layer_density(gv%Rlay, gv%g_prime, gv, us, pf)
    case ("linear")
      call set_coord_linear(gv%Rlay, gv%g_prime, gv, us, pf)
    case ("ts_ref")
      call set_coord_from_ts_ref(gv%Rlay, gv%g_prime, gv, us, pf, eos, tv%P_Ref)
    case ("ts_profile")
      call set_coord_from_ts_profile(gv%Rlay, gv%g_prime, gv, us, pf, eos, tv%P_Ref)
    case ("ts_range")
      call set_coord_from_ts_range(gv%Rlay, gv%g_prime, gv, us, pf, eos, tv%P_Ref)
    case ("file")
      call set_coord_from_file(gv%Rlay, gv%g_prime, gv, us, pf)
    case ("USER")
      call user_set_coord(gv%Rlay, gv%g_prime, gv, us, pf, eos)
    case ("BFB")
      call bfb_set_coord(gv%Rlay, gv%g_prime, gv, us, pf, eos)
    case ("none", "ALE")
      call set_coord_to_none(gv%Rlay, gv%g_prime, gv, us, pf)
    case default ; call mom_error(fatal,"MOM_initialize_coord: "// &
      "Unrecognized coordinate setup"//trim(config))
  end select
  if (debug) call chksum(us%R_to_kg_m3*gv%Rlay(:), "MOM_initialize_coord: Rlay ", 1, nz)
  if (debug) call chksum(us%m_to_Z*us%L_to_m**2*us%s_to_T**2*gv%g_prime(:), "MOM_initialize_coord: g_prime ", 1, nz)
  call setverticalgridaxes( gv%Rlay, gv, scale=us%R_to_kg_m3 )
 
! Copy the maximum depth across from the input argument
  gv%max_depth = max_depth
 
! Write out all of the grid data used by this run.
  if (write_geom) call write_vertgrid_file(gv, us, pf, output_dir)
 
  call calltree_leave('MOM_initialize_coord()')
 
end subroutine mom_initialize_coord
 
!  The set_coord routines deal with initializing aspects of the vertical grid.
 
!> Sets the layer densities (Rlay) and the interface reduced gravities (g).
subroutine set_coord_from_gprime(Rlay, g_prime, GV, US, param_file)
  real, dimension(:),      intent(out) :: Rlay       !< The layers' target coordinate values
                                                     !! (potential density) [R ~> kg m-3].
  real, dimension(:),      intent(out) :: g_prime    !< The reduced gravity across the interfaces
                                                     !! [L2 Z-1 T-2 ~> m s-2].
  type(verticalgrid_type), intent(in)  :: GV         !< The ocean's vertical grid structure.
  type(unit_scale_type),   intent(in)  :: US         !< A dimensional unit scaling type
  type(param_file_type),   intent(in)  :: param_file !< A structure to parse for run-time parameters
  ! Local variables
  real :: g_int   ! Reduced gravities across the internal interfaces [m s-2].
  real :: g_fs    ! Reduced gravity across the free surface [m s-2].
  character(len=40)  :: mdl = "set_coord_from_gprime" ! This subroutine's name.
  integer :: k, nz
  nz = gv%ke
 
  call calltree_enter(trim(mdl)//"(), MOM_coord_initialization.F90")
 
  call get_param(param_file, mdl, "GFS" , g_fs, &
                 "The reduced gravity at the free surface.", units="m s-2", &
                 default=gv%mks_g_Earth, scale=us%m_s_to_L_T**2*us%Z_to_m)
  call get_param(param_file, mdl, "GINT", g_int, &
                 "The reduced gravity across internal interfaces.", &
                 units="m s-2", fail_if_missing=.true., scale=us%m_s_to_L_T**2*us%Z_to_m)
 
  g_prime(1) = g_fs
  do k=2,nz ; g_prime(k) = g_int ; enddo
  rlay(1) = gv%Rho0
  do k=2,nz ; rlay(k) = rlay(k-1) + g_prime(k)*(gv%Rho0/gv%g_Earth) ; enddo
 
  call calltree_leave(trim(mdl)//'()')
 
end subroutine set_coord_from_gprime
 
!> Sets the layer densities (Rlay) and the interface reduced gravities (g).
subroutine set_coord_from_layer_density(Rlay, g_prime, GV, US, param_file)
  real, dimension(:),      intent(out) :: Rlay       !< The layers' target coordinate values
                                                     !! (potential density) [R ~> kg m-3].
  real, dimension(:),      intent(out) :: g_prime    !< The reduced gravity across the interfaces
                                                     !! [L2 Z-1 T-2 ~> m s-2].
  type(verticalgrid_type), intent(in)  :: GV         !< The ocean's vertical grid structure
  type(unit_scale_type),   intent(in)  :: US         !< A dimensional unit scaling type
  type(param_file_type),   intent(in)  :: param_file !< A structure to parse for run-time parameters
  ! Local variables
  real :: g_fs    ! Reduced gravity across the free surface [m s-2].
  real :: Rlay_Ref! The surface layer's target density [kg m-3].
  real :: RLay_range ! The range of densities [kg m-3].
  character(len=40)  :: mdl = "set_coord_from_layer_density" ! This subroutine's name.
  integer :: k, nz
  nz = gv%ke
 
  call calltree_enter(trim(mdl)//"(), MOM_coord_initialization.F90")
 
  call get_param(param_file, mdl, "GFS", g_fs, &
                 "The reduced gravity at the free surface.", units="m s-2", &
                 default=gv%mks_g_Earth, scale=us%m_s_to_L_T**2*us%Z_to_m)
  call get_param(param_file, mdl, "LIGHTEST_DENSITY", rlay_ref, &
                 "The reference potential density used for layer 1.", &
                 units="kg m-3", default=us%R_to_kg_m3*gv%Rho0, scale=us%kg_m3_to_R)
  call get_param(param_file, mdl, "DENSITY_RANGE", rlay_range, &
                 "The range of reference potential densities in the layers.", &
                 units="kg m-3", default=2.0, scale=us%kg_m3_to_R)
 
  g_prime(1) = g_fs
  rlay(1) = rlay_ref
  do k=2,nz
     rlay(k) = rlay(k-1) + rlay_range/(real(nz-1))
  enddo
!    These statements set the interface reduced gravities.           !
  do k=2,nz
     g_prime(k) = (gv%g_Earth/(gv%Rho0)) * (rlay(k) - rlay(k-1))
  enddo
 
  call calltree_leave(trim(mdl)//'()')
end subroutine set_coord_from_layer_density
 
!> Sets the layer densities (Rlay) and the interface reduced gravities (g) from a profile of g'.
subroutine set_coord_from_ts_ref(Rlay, g_prime, GV, US, param_file, eqn_of_state, &
                                 P_Ref)
  real, dimension(:),      intent(out) :: Rlay         !< The layers' target coordinate values
                                                       !! (potential density) [R ~> kg m-3].
  real, dimension(:),      intent(out) :: g_prime      !< The reduced gravity across the interfaces
                                                       !! [L2 Z-1 T-2 ~> m s-2].
  type(verticalgrid_type), intent(in)  :: GV           !< The ocean's vertical grid structure.
  type(unit_scale_type),   intent(in)  :: US           !< A dimensional unit scaling type
  type(param_file_type),   intent(in)  :: param_file   !< A structure to parse for run-time
                                                       !! parameters
  type(eos_type),          pointer     :: eqn_of_state !< integer selecting the equation of state.
  real,                    intent(in)  :: P_Ref        !< The coordinate-density reference pressure [Pa].
  ! Local variables
  real :: T_ref   ! Reference temperature
  real :: S_ref   ! Reference salinity
  real :: g_int   ! Reduced gravities across the internal interfaces [m s-2].
  real :: g_fs    ! Reduced gravity across the free surface [m s-2].
  character(len=40)  :: mdl = "set_coord_from_TS_ref" ! This subroutine's name.
  integer :: k, nz
  nz = gv%ke
 
  call calltree_enter(trim(mdl)//"(), MOM_coord_initialization.F90")
 
  call get_param(param_file, mdl, "T_REF", t_ref, &
                 "The initial temperature of the lightest layer.", units="degC", &
                 fail_if_missing=.true.)
  call get_param(param_file, mdl, "S_REF", s_ref, &
                 "The initial salinities.", units="PSU", default=35.0)
  call get_param(param_file, mdl, "GFS", g_fs, &
                 "The reduced gravity at the free surface.", units="m s-2", &
                 default=gv%mks_g_Earth, scale=us%m_s_to_L_T**2*us%Z_to_m)
  call get_param(param_file, mdl, "GINT", g_int, &
                 "The reduced gravity across internal interfaces.", &
                 units="m s-2", fail_if_missing=.true., scale=us%m_s_to_L_T**2*us%Z_to_m)
                                      !
!    These statements set the interface reduced gravities.           !
  g_prime(1) = g_fs
  do k=2,nz ; g_prime(k) = g_int ; enddo
 
!    The uppermost layer's density is set here.  Subsequent layers'  !
!  densities are determined from this value and the g values.        !
!        T0 = 28.228 ; S0 = 34.5848 ; Pref = P_Ref
  call calculate_density(t_ref, s_ref, p_ref, rlay(1), eqn_of_state, scale=us%kg_m3_to_R)
 
!    These statements set the layer densities.                       !
  do k=2,nz ; rlay(k) = rlay(k-1) + g_prime(k)*(gv%Rho0/gv%g_Earth) ; enddo
 
  call calltree_leave(trim(mdl)//'()')
end subroutine set_coord_from_ts_ref
 
!> Sets the layer densities (Rlay) and the interface reduced gravities (g) from a T-S profile.
subroutine set_coord_from_ts_profile(Rlay, g_prime, GV, US, param_file, &
                                     eqn_of_state, P_Ref)
  real, dimension(:),      intent(out) :: Rlay         !< The layers' target coordinate values
                                                       !! (potential density) [R ~> kg m-3].
  real, dimension(:),      intent(out) :: g_prime      !< The reduced gravity across the interfaces
                                                       !! [L2 Z-1 T-2 ~> m s-2].
  type(verticalgrid_type), intent(in)  :: GV           !< The ocean's vertical grid structure.
  type(unit_scale_type),   intent(in)  :: US           !< A dimensional unit scaling type
  type(param_file_type),   intent(in)  :: param_file   !< A structure to parse for run-time
                                                       !! parameters
  type(eos_type),          pointer     :: eqn_of_state !< integer that selects equation of state.
  real,                    intent(in)  :: P_Ref        !< The coordinate-density reference pressure [Pa].
  ! Local variables
  real, dimension(GV%ke) :: T0, S0,  Pref
  real :: g_fs    ! Reduced gravity across the free surface [m s-2].
  integer :: k, nz
  character(len=40)  :: mdl = "set_coord_from_TS_profile" ! This subroutine's name.
  character(len=200) :: filename, coord_file, inputdir ! Strings for file/path
  nz = gv%ke
 
  call calltree_enter(trim(mdl)//"(), MOM_coord_initialization.F90")
 
  call get_param(param_file, mdl, "GFS", g_fs, &
                 "The reduced gravity at the free surface.", units="m s-2", &
                 default=gv%mks_g_Earth, scale=us%m_s_to_L_T**2*us%Z_to_m)
  call get_param(param_file, mdl, "COORD_FILE", coord_file, &
                 "The file from which the coordinate temperatures and "//&
                 "salinities are read.", fail_if_missing=.true.)
 
  call get_param(param_file,  mdl, "INPUTDIR", inputdir, default=".")
  filename = trim(slasher(inputdir))//trim(coord_file)
  call log_param(param_file, mdl, "INPUTDIR/COORD_FILE", filename)
 
  call mom_read_data(filename,"PTEMP",t0(:))
  call mom_read_data(filename,"SALT",s0(:))
 
  if (.not.file_exists(filename)) call mom_error(fatal, &
      " set_coord_from_TS_profile: Unable to open " //trim(filename))
!    These statements set the interface reduced gravities.           !
  g_prime(1) = g_fs
  do k=1,nz ; pref(k) = p_ref ; enddo
  call calculate_density(t0, s0, pref, rlay, 1, nz, eqn_of_state, scale=us%kg_m3_to_R)
  do k=2,nz; g_prime(k) = (gv%g_Earth/(gv%Rho0)) * (rlay(k) - rlay(k-1)) ; enddo
 
  call calltree_leave(trim(mdl)//'()')
end subroutine set_coord_from_ts_profile
 
!> Sets the layer densities (Rlay) and the interface reduced gravities (g) from a linear T-S profile.
subroutine set_coord_from_ts_range(Rlay, g_prime, GV, US, param_file, &
                                   eqn_of_state, P_Ref)
  real, dimension(:),      intent(out) :: Rlay         !< The layers' target coordinate values
                                                       !! (potential density) [R ~> kg m-3].
  real, dimension(:),      intent(out) :: g_prime      !< The reduced gravity across the interfaces
                                                       !! [L2 Z-1 T-2 ~> m s-2].
  type(verticalgrid_type), intent(in)  :: GV           !< The ocean's vertical grid structure.
  type(unit_scale_type),   intent(in)  :: US           !< A dimensional unit scaling type
  type(param_file_type),   intent(in)  :: param_file   !< A structure to parse for run-time
                                                       !! parameters
  type(eos_type),          pointer     :: eqn_of_state !< integer that selects equation of state
  real,                    intent(in)  :: P_Ref        !< The coordinate-density reference pressure [Pa]
 
  ! Local variables
  real, dimension(GV%ke) :: T0, S0,  Pref
  real :: S_Ref, S_Light, S_Dense ! Salinity range parameters [ppt].
  real :: T_Ref, T_Light, T_Dense ! Temperature range parameters [decC].
  real :: res_rat ! The ratio of density space resolution in the denser part
                  ! of the range to that in the lighter part of the range.
                  ! Setting this greater than 1 increases the resolution for
                  ! the denser water.
  real :: g_fs    ! Reduced gravity across the free surface [m s-2].
  real :: a1, frac_dense, k_frac
  integer :: k, nz, k_light
  character(len=40)  :: mdl = "set_coord_from_TS_range" ! This subroutine's name.
  character(len=200) :: filename, coord_file, inputdir ! Strings for file/path
  nz = gv%ke
 
  call calltree_enter(trim(mdl)//"(), MOM_coord_initialization.F90")
 
  call get_param(param_file, mdl, "T_REF", t_ref, &
                 "The default initial temperatures.", units="degC", default=10.0)
  call get_param(param_file, mdl, "TS_RANGE_T_LIGHT", t_light, &
                 "The initial temperature of the lightest layer when "//&
                 "COORD_CONFIG is set to ts_range.", units="degC", default=t_ref)
  call get_param(param_file, mdl, "TS_RANGE_T_DENSE", t_dense, &
                 "The initial temperature of the densest layer when "//&
                 "COORD_CONFIG is set to ts_range.", units="degC", default=t_ref)
 
  call get_param(param_file, mdl, "S_REF", s_ref, &
                 "The default initial salinities.", units="PSU", default=35.0)
  call get_param(param_file, mdl, "TS_RANGE_S_LIGHT", s_light, &
                 "The initial lightest salinities when COORD_CONFIG "//&
                 "is set to ts_range.", default = s_ref, units="PSU")
  call get_param(param_file, mdl, "TS_RANGE_S_DENSE", s_dense, &
                 "The initial densest salinities when COORD_CONFIG "//&
                 "is set to ts_range.", default = s_ref, units="PSU")
 
  call get_param(param_file, mdl, "TS_RANGE_RESOLN_RATIO", res_rat, &
                 "The ratio of density space resolution in the densest "//&
                 "part of the range to that in the lightest part of the "//&
                 "range when COORD_CONFIG is set to ts_range. Values "//&
                 "greater than 1 increase the resolution of the denser water.",&
                 default=1.0, units="nondim")
 
  call get_param(param_file, mdl, "GFS", g_fs, &
                 "The reduced gravity at the free surface.", units="m s-2", &
                 default=gv%mks_g_Earth, scale=us%m_s_to_L_T**2*us%Z_to_m)
 
  k_light = gv%nk_rho_varies + 1
 
  ! Set T0(k) to range from T_LIGHT to T_DENSE, and simliarly for S0(k).
  t0(k_light) = t_light ; s0(k_light) = s_light
  a1 = 2.0 * res_rat / (1.0 + res_rat)
  do k=k_light+1,nz
    k_frac = real(k-k_light)/real(nz-k_light)
    frac_dense = a1 * k_frac + (1.0 - a1) * k_frac**2
    t0(k) = frac_dense * (t_dense - t_light) + t_light
    s0(k) = frac_dense * (s_dense - s_light) + s_light
  enddo
 
  g_prime(1) = g_fs
  do k=1,nz ; pref(k) = p_ref ; enddo
  call calculate_density(t0, s0, pref, rlay, k_light, nz-k_light+1, eqn_of_state, scale=us%kg_m3_to_R)
  ! Extrapolate target densities for the variable density mixed and buffer layers.
  do k=k_light-1,1,-1
    rlay(k) = 2.0*rlay(k+1) - rlay(k+2)
  enddo
  do k=2,nz ; g_prime(k) = (gv%g_Earth/(gv%Rho0)) * (rlay(k) - rlay(k-1)) ; enddo
 
  call calltree_leave(trim(mdl)//'()')
end subroutine set_coord_from_ts_range
 
! Sets the layer densities (Rlay) and the interface reduced gravities (g) from data in file.
subroutine set_coord_from_file(Rlay, g_prime, GV, US, param_file)
  real, dimension(:),      intent(out) :: Rlay       !< The layers' target coordinate values
                                                     !! (potential density) [R ~> kg m-3].
  real, dimension(:),      intent(out) :: g_prime    !< The reduced gravity across the interfaces
                                                     !! [L2 Z-1 T-2 ~> m s-2].
  type(verticalgrid_type), intent(in)  :: GV         !< The ocean's vertical grid structure.
  type(unit_scale_type),   intent(in)  :: US         !< A dimensional unit scaling type
  type(param_file_type),   intent(in)  :: param_file !< A structure to parse for run-time parameters
  ! Local variables
  real :: g_fs    ! Reduced gravity across the free surface [m s-2].
  integer :: k, nz
  character(len=40)  :: mdl = "set_coord_from_file" ! This subroutine's name.
  character(len=40)  :: coord_var
  character(len=200) :: filename,coord_file,inputdir ! Strings for file/path
  nz = gv%ke
 
  call calltree_enter(trim(mdl)//"(), MOM_coord_initialization.F90")
 
  call get_param(param_file, mdl, "GFS", g_fs, &
                 "The reduced gravity at the free surface.", units="m s-2", &
                 default=gv%mks_g_Earth, scale=us%m_s_to_L_T**2*us%Z_to_m)
  call get_param(param_file, mdl, "INPUTDIR", inputdir, default=".")
  inputdir = slasher(inputdir)
  call get_param(param_file, mdl, "COORD_FILE", coord_file, &
                 "The file from which the coordinate densities are read.", &
                 fail_if_missing=.true.)
  call get_param(param_file, mdl, "COORD_VAR", coord_var, &
                 "The variable in COORD_FILE that is to be used for the "//&
                 "coordinate densities.", default="Layer")
  filename = trim(inputdir)//trim(coord_file)
  call log_param(param_file, mdl, "INPUTDIR/COORD_FILE", filename)
  if (.not.file_exists(filename)) call mom_error(fatal, &
      " set_coord_from_file: Unable to open "//trim(filename))
 
  call read_axis_data(filename, coord_var, rlay)
  do k=1,nz ; rlay(k) = us%kg_m3_to_R*rlay(k) ; enddo
  g_prime(1) = g_fs
  do k=2,nz ; g_prime(k) = (gv%g_Earth/(gv%Rho0)) * (rlay(k) - rlay(k-1)) ; enddo
  do k=1,nz ; if (g_prime(k) <= 0.0) then
    call mom_error(fatal, "MOM_initialization set_coord_from_file: "//&
       "Zero or negative g_primes read from variable "//"Layer"//" in file "//&
       trim(filename))
  endif ; enddo
 
  call calltree_leave(trim(mdl)//'()')
end subroutine set_coord_from_file
 
!> Sets the layer densities (Rlay) and the interface
!! reduced gravities (g) according to a linear profile starting at a
!! reference surface layer density and spanning a range of densities
!! to the bottom defined by the parameter RLAY_RANGE
!! (defaulting to 2.0 if not defined)
subroutine set_coord_linear(Rlay, g_prime, GV, US, param_file)
  real, dimension(:),      intent(out) :: Rlay       !< The layers' target coordinate values
                                                     !! (potential density) [R ~> kg m-3].
  real, dimension(:),      intent(out) :: g_prime    !< The reduced gravity across the interfaces
                                                     !! [L2 Z-1 T-2 ~> m s-2].
  type(verticalgrid_type), intent(in)  :: GV         !< The ocean's vertical grid structure.
  type(unit_scale_type),   intent(in)  :: US         !< A dimensional unit scaling type
  type(param_file_type),   intent(in)  :: param_file !< A structure to parse for run-time parameters
  ! Local variables
  character(len=40)  :: mdl = "set_coord_linear" ! This subroutine
  real :: Rlay_ref, Rlay_range, g_fs
  integer :: k, nz
  nz = gv%ke
 
  call calltree_enter(trim(mdl)//"(), MOM_coord_initialization.F90")
 
  call get_param(param_file, mdl, "LIGHTEST_DENSITY", rlay_ref, &
                 "The reference potential density used for the surface interface.", &
                 units="kg m-3", default=us%R_to_kg_m3*gv%Rho0, scale=us%kg_m3_to_R)
  call get_param(param_file, mdl, "DENSITY_RANGE", rlay_range, &
                 "The range of reference potential densities across all interfaces.", &
                 units="kg m-3", default=2.0, scale=us%kg_m3_to_R)
  call get_param(param_file, mdl, "GFS", g_fs, &
                 "The reduced gravity at the free surface.", units="m s-2", &
                 default=gv%mks_g_Earth, scale=us%m_s_to_L_T**2*us%Z_to_m)
 
  ! This following sets the target layer densities such that a the
  ! surface interface has density Rlay_ref and the bottom
  ! is Rlay_range larger
  do k=1,nz
     rlay(k) = rlay_ref + rlay_range*((real(k)-0.5)/real(nz))
  enddo
  ! These statements set the interface reduced gravities.
  g_prime(1) = g_fs
  do k=2,nz
     g_prime(k) = (gv%g_Earth/(gv%Rho0)) * (rlay(k) - rlay(k-1))
  enddo
 
  call calltree_leave(trim(mdl)//'()')
end subroutine set_coord_linear
 
!> Sets Rlay to Rho0 and g_prime to zero except for the free surface.
!! This is for use only in ALE mode where Rlay should not be used and g_prime(1) alone
!! might be used.
subroutine set_coord_to_none(Rlay, g_prime, GV, US, param_file)
  real, dimension(:),      intent(out) :: Rlay       !< The layers' target coordinate values
                                                     !! (potential density) [R ~> kg m-3].
  real, dimension(:),      intent(out) :: g_prime    !< The reduced gravity across the interfaces,
                                                     !! [L2 Z-1 T-2 ~> m s-2].
  type(verticalgrid_type), intent(in)  :: GV         !< The ocean's vertical grid structure.
  type(unit_scale_type),   intent(in)  :: US         !< A dimensional unit scaling type
  type(param_file_type),   intent(in)  :: param_file !< A structure to parse for run-time parameters
  ! Local variables
  real :: g_fs    ! Reduced gravity across the free surface [m s-2].
  character(len=40)  :: mdl = "set_coord_to_none" ! This subroutine's name.
  integer :: k, nz
  nz = gv%ke
 
  call calltree_enter(trim(mdl)//"(), MOM_coord_initialization.F90")
 
  call get_param(param_file, mdl, "GFS" , g_fs, &
                 "The reduced gravity at the free surface.", units="m s-2", &
                 default=gv%mks_g_Earth, scale=us%m_s_to_L_T**2*us%Z_to_m)
 
  g_prime(1) = g_fs
  do k=2,nz ; g_prime(k) = 0. ; enddo
  rlay(1) = gv%Rho0
  do k=2,nz ; rlay(k) = rlay(k-1) + g_prime(k)*(gv%Rho0/gv%g_Earth) ; enddo
 
  call calltree_leave(trim(mdl)//'()')
 
end subroutine set_coord_to_none
 
!> Writes out a file containing any available data related
!! to the vertical grid used by the MOM ocean model.
subroutine write_vertgrid_file(GV, US, param_file, directory)
  type(verticalgrid_type), intent(in)  :: GV         !< The ocean's vertical grid structure
  type(unit_scale_type),   intent(in)  :: US         !< A dimensional unit scaling type
  type(param_file_type), intent(in)    :: param_file !< A structure to parse for run-time parameters
  character(len=*),      intent(in)    :: directory  !< The directory into which to place the file.
  ! Local variables
  character(len=240) :: filepath
  type(vardesc) :: vars(2)
  type(fieldtype) :: fields(2)
  integer :: unit
 
  filepath = trim(directory) // trim("Vertical_coordinate")
 
  vars(1) = var_desc("R","kilogram meter-3","Target Potential Density",'1','L','1')
  vars(2) = var_desc("g","meter second-2","Reduced gravity",'1','L','1')
 
  call create_file(unit, trim(filepath), vars, 2, fields, single_file, gv=gv)
 
  call write_field(unit, fields(1), us%R_to_kg_m3*gv%Rlay(:))
  call write_field(unit, fields(2), us%L_T_to_m_s**2*us%m_to_Z*gv%g_prime(:))
 
  call close_file(unit)
 
end subroutine write_vertgrid_file
 
end module mom_coord_initialization