Detailed Description

Initialization routines for the dense water formation and overflow experiment.

This experiment consists of a shelf accumulating dense water, which spills over an upward slope and a sill, before flowing down a slope into an open ocean region. It's intended as a test of one of the motivating situations for the adaptive coordinate.

The nondimensional widths of the 5 regions are controlled by the DENSE_WATER_DOMAIN_PARAMS, and the heights of the sill and shelf as a fraction of the total domain depth are controlled by DENSE_WATER_SILL_HEIGHT and DENSE_WATER_SHELF_HEIGHT.

The density in the domain is governed by a linear equation of state, and is set up with a mixed layer of non-dimensional depth DENSE_WATER_MLD below which there is a linear stratification from S_REF, increasing by S_RANGE to the bottom.

To force the experiment, there are sponges on the inflow and outflow of the domain. The inflow sponge has a salinity anomaly of DENSE_WATER_EAST_SPONGE_SALT through the entire depth. The outflow sponge simply restores to the initial condition. Both sponges have controllable widths and restoring timescales.

Functions/Subroutines
subroutine, public	dense_water_initialize_topography (D, G, param_file, max_depth)
	Initialize the topography field for the dense water experiment. More...

subroutine, public	dense_water_initialize_ts (G, GV, param_file, eqn_of_state, T, S, h, just_read_params)
	Initialize the temperature and salinity for the dense water experiment. More...

subroutine, public	dense_water_initialize_sponges (G, GV, tv, param_file, use_ALE, CSp, ACSp)
	Initialize the restoring sponges for the dense water experiment. More...

Variables
character(len=40)	mdl = "dense_water_initialization"
	Module name. More...

real, parameter	default_sill = 0.2
	Default depth of the sill [nondim]. More...

real, parameter	default_shelf = 0.4
	Default depth of the shelf [nondim]. More...

real, parameter	default_mld = 0.25
	Default depth of the mixed layer [nondim]. More...

Function/Subroutine Documentation

◆ dense_water_initialize_sponges()

subroutine, public dense_water_initialization::dense_water_initialize_sponges	(	type(ocean_grid_type), intent(in)	G,
		type(verticalgrid_type), intent(in)	GV,
		type(thermo_var_ptrs), intent(in)	tv,
		type(param_file_type), intent(in)	param_file,
		logical, intent(in)	use_ALE,
		type(sponge_cs), pointer	CSp,
		type(ale_sponge_cs), pointer	ACSp
	)

Initialize the restoring sponges for the dense water experiment.

Parameters

[in]	g	Horizontal grid control structure
[in]	gv	Vertical grid control structure
[in]	tv	Thermodynamic variables
[in]	param_file	Parameter file structure
[in]	use_ale	ALE flag
	csp	Layered sponge control structure pointer
	acsp	ALE sponge control structure pointer

Definition at line 154 of file dense_water_initialization.F90.

   type(ocean_grid_type),   intent(in) :: G !< Horizontal grid control structure
   type(verticalGrid_type), intent(in) :: GV !< Vertical grid control structure
   type(thermo_var_ptrs),   intent(in) :: tv !< Thermodynamic variables
   type(param_file_type),   intent(in) :: param_file !< Parameter file structure
   logical,                 intent(in) :: use_ALE !< ALE flag
   type(sponge_CS),         pointer    :: CSp !< Layered sponge control structure pointer
   type(ALE_sponge_CS),     pointer    :: ACSp !< ALE sponge control structure pointer
   ! Local variables
   real :: west_sponge_time_scale, west_sponge_width
   real :: east_sponge_time_scale, east_sponge_width
  
   real, dimension(SZI_(G),SZJ_(G)) :: Idamp ! inverse damping timescale
   real, dimension(SZI_(G),SZJ_(G),SZK_(GV)) :: h, T, S ! sponge thicknesses, temp and salt
   real, dimension(SZK_(GV)+1) :: e0, eta1D ! interface positions for ALE sponge
  
   integer :: i, j, k, nz
   real :: x, zi, zmid, dist
   real :: mld, S_ref, S_range, S_dense, T_ref, sill_height
  
   nz = gv%ke
  
   call get_param(param_file, mdl, "DENSE_WATER_WEST_SPONGE_TIME_SCALE", west_sponge_time_scale, &
        "The time scale on the west (outflow) of the domain for restoring. If zero, the sponge is disabled.", &
        units="s", default=0.)
   call get_param(param_file, mdl, "DENSE_WATER_WEST_SPONGE_WIDTH", west_sponge_width, &
        "The fraction of the domain in which the western (outflow) sponge is active.", &
        units="nondim", default=0.1)
   call get_param(param_file, mdl, "DENSE_WATER_EAST_SPONGE_TIME_SCALE", east_sponge_time_scale, &
        "The time scale on the east (outflow) of the domain for restoring. If zero, the sponge is disabled.", &
        units="s", default=0.)
   call get_param(param_file, mdl, "DENSE_WATER_EAST_SPONGE_WIDTH", east_sponge_width, &
        "The fraction of the domain in which the eastern (outflow) sponge is active.", &
        units="nondim", default=0.1)
  
   call get_param(param_file, mdl, "DENSE_WATER_EAST_SPONGE_SALT", s_dense, &
        "Salt anomaly of the dense water being formed in the overflow region.", &
        units="1e-3", default=4.0)
  
   call get_param(param_file, mdl, "DENSE_WATER_MLD", mld, default=default_mld, do_not_log=.true.)
   call get_param(param_file, mdl, "DENSE_WATER_SILL_HEIGHT", sill_height, default=default_sill, do_not_log=.true.)
  
   call get_param(param_file, mdl, "S_REF", s_ref, do_not_log=.true.)
   call get_param(param_file, mdl, "S_RANGE", s_range, do_not_log=.true.)
   call get_param(param_file, mdl, "T_REF", t_ref, do_not_log=.true.)
  
   ! no active sponges
   if (west_sponge_time_scale <= 0. .and. east_sponge_time_scale <= 0.) return
  
   ! everywhere is initially unsponged
   idamp(:,:) = 0.0
  
   do j = g%jsc, g%jec
     do i = g%isc,g%iec
       if (g%mask2dT(i,j) > 0.) then
         ! nondimensional x position
         x = (g%geoLonT(i,j) - g%west_lon) / g%len_lon
  
         if (west_sponge_time_scale > 0. .and. x < west_sponge_width) then
           dist = 1. - x / west_sponge_width
           ! scale restoring by depth into sponge
           idamp(i,j) = 1. / west_sponge_time_scale * max(0., min(1., dist))
         elseif (east_sponge_time_scale > 0. .and. x > (1. - east_sponge_width)) then
           dist = 1. - (1. - x) / east_sponge_width
           idamp(i,j) = 1. / east_sponge_time_scale * max(0., min(1., dist))
         endif
       endif
     enddo
   enddo
  
   if (use_ale) then
     ! construct a uniform grid for the sponge
     do k = 1,nz
       e0(k) = -g%max_depth * (real(k - 1) / real(nz))
     enddo
     e0(nz+1) = -g%max_depth
  
     do j = g%jsc,g%jec
       do i = g%isc,g%iec
         eta1d(nz+1) = -g%bathyT(i,j)
         do k = nz,1,-1
           eta1d(k) = e0(k)
  
           if (eta1d(k) < (eta1d(k+1) + gv%Angstrom_Z)) then
             ! is this layer vanished?
             eta1d(k) = eta1d(k+1) + gv%Angstrom_Z
             h(i,j,k) = gv%Angstrom_H
           else
             h(i,j,k) = gv%Z_to_H * (eta1d(k) - eta1d(k+1))
           endif
         enddo
       enddo
     enddo
  
     call initialize_ale_sponge(idamp, g, param_file, acsp, h, nz)
  
     ! construct temperature and salinity for the sponge
     ! start with initial condition
     t(:,:,:) = t_ref
     s(:,:,:) = s_ref
  
     do j = g%jsc,g%jec
       do i = g%isc,g%iec
         zi = 0.
         x = (g%geoLonT(i,j) - g%west_lon) / g%len_lon
         do k = 1,nz
           ! nondimensional middle of layer
           zmid = zi + 0.5 * h(i,j,k) / (gv%Z_to_H * g%max_depth)
  
           if (x > (1. - east_sponge_width)) then
             !if (zmid >= 0.9 * sill_height) &
                  s(i,j,k) = s_ref + s_dense
           else
             ! linear between bottom of mixed layer and bottom
             if (zmid >= mld) &
                  s(i,j,k) = s_ref + s_range * (zmid - mld) / (1.0 - mld)
           endif
  
           zi = zi + h(i,j,k) / (gv%Z_to_H * g%max_depth)
         enddo
       enddo
     enddo
  
     if (associated(tv%T)) call set_up_ale_sponge_field(t, g, tv%T, acsp)
     if (associated(tv%S)) call set_up_ale_sponge_field(s, g, tv%S, acsp)
   else
     call mom_error(fatal, "dense_water_initialize_sponges: trying to use non ALE sponge")
   endif

References default_mld, default_sill, mdl, and mom_error_handler::mom_error().

Referenced by mom_state_initialization::mom_initialize_state().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dense_water_initialize_topography()

subroutine, public dense_water_initialization::dense_water_initialize_topography	(	real, dimension(g%isd:g%ied,g%jsd:g%jed), intent(out)	D,
		type(dyn_horgrid_type), intent(in)	G,
		type(param_file_type), intent(in)	param_file,
		real, intent(in)	max_depth
	)

Initialize the topography field for the dense water experiment.

Parameters

[in]	g	The dynamic horizontal grid type
[out]	d	Ocean bottom depth in the units of depth_max
[in]	param_file	Parameter file structure
[in]	max_depth	Maximum ocean depth in arbitrary units

Definition at line 36 of file dense_water_initialization.F90.

   type(dyn_horgrid_type),  intent(in)  :: G !< The dynamic horizontal grid type
   real, dimension(G%isd:G%ied,G%jsd:G%jed), &
                            intent(out) :: D !< Ocean bottom depth in the units of depth_max
   type(param_file_type),   intent(in)  :: param_file !< Parameter file structure
   real,                    intent(in)  :: max_depth !< Maximum ocean depth in arbitrary units
  
   ! Local variables
   real, dimension(5) :: domain_params ! nondimensional widths of all domain sections
   real :: sill_frac, shelf_frac
   integer :: i, j
   real :: x
  
   call get_param(param_file, mdl, "DENSE_WATER_DOMAIN_PARAMS", domain_params, &
        "Fractional widths of all the domain sections for the dense water experiment.\n"//&
        "As a 5-element vector:\n"//&
        "  - open ocean, the section at maximum depth\n"//&
        "  - downslope, the downward overflow slope\n"//&
        "  - sill separating downslope from upslope\n"//&
        "  - upslope, the upward slope accumulating dense water\n"//&
        "  - the shelf in the dense formation region.", &
        units="nondim", fail_if_missing=.true.)
   call get_param(param_file, mdl, "DENSE_WATER_SILL_DEPTH", sill_frac, &
        "Depth of the sill separating downslope from upslope, as fraction of basin depth.", &
        units="nondim", default=default_sill)
   call get_param(param_file, mdl, "DENSE_WATER_SHELF_DEPTH", shelf_frac, &
        "Depth of the shelf region accumulating dense water for overflow, as fraction of basin depth.", &
        units="nondim", default=default_shelf)
  
   do i = 2, 5
     ! turn widths into positions
     domain_params(i) = domain_params(i-1) + domain_params(i)
   enddo
  
   do j = g%jsc,g%jec
     do i = g%isc,g%iec
       ! compute normalised zonal coordinate
       x = (g%geoLonT(i,j) - g%west_lon) / g%len_lon
  
       if (x <= domain_params(1)) then
         ! open ocean region
         d(i,j) = max_depth
       elseif (x <= domain_params(2)) then
         ! downslope region, linear
         d(i,j) = max_depth - (1.0 - sill_frac) * max_depth * &
              (x - domain_params(1)) / (domain_params(2) - domain_params(1))
       elseif (x <= domain_params(3)) then
         ! sill region
         d(i,j) = sill_frac * max_depth
       elseif (x <= domain_params(4)) then
         ! upslope region
         d(i,j) = sill_frac * max_depth + (shelf_frac - sill_frac) * max_depth * &
              (x - domain_params(3)) / (domain_params(4) - domain_params(3))
       else
         ! shelf region
         d(i,j) = shelf_frac * max_depth
       endif
     enddo
   enddo
  

References default_shelf, default_sill, and mdl.

Referenced by mom_fixed_initialization::mom_initialize_topography().

Here is the caller graph for this function:

◆ dense_water_initialize_ts()

subroutine, public dense_water_initialization::dense_water_initialize_ts	(	type(ocean_grid_type), intent(in)	G,
		type(verticalgrid_type), intent(in)	GV,
		type(param_file_type), intent(in)	param_file,
		type(eos_type), pointer	eqn_of_state,
		real, dimension( g %isd: g %ied, g %jsd: g %jed, gv %ke), intent(out)	T,
		real, dimension( g %isd: g %ied, g %jsd: g %jed, gv %ke), intent(out)	S,
		real, dimension( g %isd: g %ied, g %jsd: g %jed, gv %ke), intent(in)	h,
		logical, intent(in), optional	just_read_params
	)

Initialize the temperature and salinity for the dense water experiment.

Parameters

[in]	g	Horizontal grid control structure
[in]	gv	Vertical grid control structure
[in]	param_file	Parameter file structure
	eqn_of_state	EOS structure
[out]	t	Output temperature [degC]
[out]	s	Output salinity [ppt]
[in]	h	Layer thicknesses [H ~> m or kg m-2]
[in]	just_read_params	If present and true, this call will only read parameters without changing h.

Definition at line 99 of file dense_water_initialization.F90.

   type(ocean_grid_type),                     intent(in)  :: G !< Horizontal grid control structure
   type(verticalGrid_type),                   intent(in)  :: GV !< Vertical grid control structure
   type(param_file_type),                     intent(in)  :: param_file !< Parameter file structure
   type(EOS_type),                            pointer     :: eqn_of_state !< EOS structure
   real, dimension(SZI_(G),SZJ_(G),SZK_(GV)), intent(out) :: T !< Output temperature [degC]
   real, dimension(SZI_(G),SZJ_(G),SZK_(GV)), intent(out) :: S !< Output salinity [ppt]
   real, dimension(SZI_(G),SZJ_(G),SZK_(GV)), intent(in)  :: h !< Layer thicknesses [H ~> m or kg m-2]
   logical,       optional, intent(in)  :: just_read_params !< If present and true, this call will
                                                       !! only read parameters without changing h.
   ! Local variables
   real :: mld, S_ref, S_range, T_ref
   real :: zi, zmid
   logical :: just_read    ! If true, just read parameters but set nothing.
   integer :: i, j, k, nz
  
   nz = gv%ke
  
   just_read = .false. ; if (present(just_read_params)) just_read = just_read_params
  
   call get_param(param_file, mdl, "DENSE_WATER_MLD", mld, &
        "Depth of unstratified mixed layer as a fraction of the water column.", &
        units="nondim", default=default_mld, do_not_log=just_read)
  
   call get_param(param_file, mdl, "S_REF", s_ref, do_not_log=.true.)
   call get_param(param_file, mdl, "S_RANGE", s_range, do_not_log=.true.)
   call get_param(param_file, mdl, "T_REF", t_ref, do_not_log=.true.)
  
   if (just_read) return ! All run-time parameters have been read, so return.
  
   ! uniform temperature everywhere
   t(:,:,:) = t_ref
  
   do j = g%jsc,g%jec
     do i = g%isc,g%iec
       zi = 0.
       do k = 1,nz
         ! nondimensional middle of layer
         zmid = zi + 0.5 * h(i,j,k) / (gv%Z_to_H * g%max_depth)
  
         if (zmid < mld) then
           ! use reference salinity in the mixed layer
           s(i,j,k) = s_ref
         else
           ! linear between bottom of mixed layer and bottom
           s(i,j,k) = s_ref + s_range * (zmid - mld) / (1.0 - mld)
         endif
  
         zi = zi + h(i,j,k) / (gv%Z_to_H * g%max_depth)
       enddo
     enddo
   enddo