dense_water_initialization Module Reference

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, US, 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.
real, parameter	default_sill = 0.2
	Default depth of the sill [nondim].
real, parameter	default_shelf = 0.4
	Default depth of the shelf [nondim].
real, parameter	default_mld = 0.25
	Default depth of the mixed layer [nondim].

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(unit_scale_type), intent(in)	US,
		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]	us	A dimensional unit scaling type
[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 155 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(unit_scale_type),   intent(in) :: US !< A dimensional unit scaling type
  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, east_sponge_time_scale ! Sponge timescales [T ~> s]
  real :: west_sponge_width, east_sponge_width
 
  real, dimension(SZI_(G),SZJ_(G)) :: Idamp ! inverse damping timescale [T-1 ~> s-1]
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)) :: h  ! sponge thicknesses [H ~> m or kg m-2]
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)) :: T  ! sponge temperature [degC]
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)) :: S  ! sponge salinity [ppt]
  real, dimension(SZK_(GV)+1) :: e0, eta1D ! interface positions for ALE sponge [Z ~> m]
 
  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., scale=us%s_to_T)
  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., scale=us%s_to_T)
  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, default=35.0, 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

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 35 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
 

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 98 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, 'Reference salinity', &
                 default=35.0, units='1e-3', do_not_log=just_read)
  call get_param(param_file, mdl,"T_REF", t_ref, 'Reference temperature', units='degC', &
                fail_if_missing=.not.just_read, do_not_log=just_read)
  call get_param(param_file, mdl,"S_RANGE", s_range, 'Initial salinity range', &
                units='1e-3', default=2.0, do_not_log=just_read)
 
  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