Detailed Description

Initialization routines for the dense water formation and overflow experiment.

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"

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 147 of file dense_water_initialization.F90.

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

Referenced by mom_state_initialization::mom_initialize_state().

   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))
         else if (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) = -gv%max_depth * (real(k - 1) / real(nz))
     enddo
     e0(nz+1) = -gv%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_z
           else
             h(i,j,k) = eta1d(k) - eta1d(k+1)
           endif
         enddo
       enddo
     enddo
 
     call initialize_ale_sponge(idamp, h, nz, g, param_file, acsp)
 
     ! 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%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%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

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	Grid control structure
[out]	d	Output topography field
[in]	param_file	Parameter file structure
[in]	max_depth	Maximum depth of the model

Definition at line 33 of file dense_water_initialization.F90.

References default_shelf, default_sill, and mdl.

Referenced by mom_fixed_initialization::mom_initialize_topography().

   type(dyn_horgrid_type),           intent(in)  :: g !< Grid control structure
   real, dimension(SZI_(G),SZJ_(G)), intent(out) :: d !< Output topography field
   type(param_file_type),            intent(in)  :: param_file !< Parameter file structure
   real,                             intent(in)  :: max_depth !< Maximum depth of the model
 
   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 i = g%isc,g%iec
     do j = g%jsc,g%jec
       ! 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
       else if (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))
       else if (x <= domain_params(3)) then
         ! sill region
         d(i,j) = sill_frac * max_depth
       else if (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

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]	s	Output state
[in]	h	Layer thicknesses
[in]	just_read_params	If present and true, this call will only read parameters without changing h.

Definition at line 93 of file dense_water_initialization.F90.

References default_mld, and mdl.

   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, s !< Output state
   real, dimension(SZI_(G),SZJ_(G),SZK_(GV)), intent(in)  :: h !< Layer thicknesses
   logical,       optional, intent(in)  :: just_read_params !< If present and true, this call will
                                                       !! only read parameters without changing h.
 
   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) / 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) / g%max_depth
       enddo
     enddo
   enddo