Detailed Description

Initial conditions for the 2D Rossby front test.

Description of the 2d Rossby front initial conditions

Consistent with a linear equation of state, the system has a constant stratification below the mixed layer, stratified in temperature only. Isotherms are flat below the mixed layer and vertical within. Salinity is constant. The mixed layer has a half sine form so that there are no mixed layer or temperature gradients at the side walls.

Below the mixed layer the potential temperature, \(\theta(z)\), is given by

\[ \theta(z) = \theta_0 - \Delta \theta \left( z + h_{ML} \right) \]

where \( \theta_0 \) and \( \Delta \theta \) are external model parameters.

The depth of the mixed layer, \(H_{ML}\) is

\[ h_{ML}(y) = h_{min} + \left( h_{max} - h_{min} \right) \cos{\pi y/L} \]

. The temperature in mixed layer is given by the reference temperature at \(z=h_{ML}\) so that

\[ \theta(y,z) = \theta_0 - \Delta \theta \left( z + h_{ML} \right) & \forall & z < h_{ML}(y) T.B.D. \]

Functions/Subroutines
subroutine, public	rossby_front_initialize_thickness (h, G, GV, param_file, just_read_params)
	Initialization of thicknesses in 2D Rossby front test. More...

subroutine, public	rossby_front_initialize_temperature_salinity (T, S, h, G, param_file, eqn_of_state, just_read_params)
	Initialization of temperature and salinity in the Rossby front test. More...

subroutine, public	rossby_front_initialize_velocity (u, v, h, G, GV, param_file, just_read_params)
	Initialization of u and v in the Rossby front test. More...

real function	ypseudo (G, lat)
	Pseudo coordinate across domain used by Hml() and dTdy() returns a coordinate from -PI/2 .. PI/2 squashed towards the center of the domain. More...

real function	hml (G, lat)
	Analytic prescription of mixed layer depth in 2d Rossby front test. More...

real function	dtdy (G, dT, lat)
	Analytic prescription of mixed layer temperature gradient in 2d Rossby front test. More...

Variables
character(len=40)	mdl = "Rossby_front_2d_initialization"
	This module's name. More...

real, parameter	frontfractionalwidth = 0.5
	Width of front as fraction of domain. More...

real, parameter	hmlmin = 0.25
	Shallowest ML as fractional depth of ocean. More...

real, parameter	hmlmax = 0.75
	Deepest ML as fractional depth of ocean. More...

Function/Subroutine Documentation

◆ dtdy()

real function rossby_front_2d_initialization::dtdy	(	type(ocean_grid_type), intent(in)	G,
		real, intent(in)	dT,
		real, intent(in)	lat
	)

private

Analytic prescription of mixed layer temperature gradient in 2d Rossby front test.

Parameters

[in]	g	Grid structure
[in]	dt	Top to bottom temperature difference
[in]	lat	Latitude

Definition at line 247 of file Rossby_front_2d_initialization.F90.

References frontfractionalwidth, hmlmax, hmlmin, and ypseudo().

Referenced by rossby_front_initialize_velocity().

   type(ocean_grid_type), intent(in) :: g     !< Grid structure
   real,                  intent(in) :: dt    !< Top to bottom temperature difference
   real,                  intent(in) :: lat   !< Latitude
   ! Local
   real :: pi, dhml, dhdy
   real :: km = 1.e3 ! AXIS_UNITS = 'k' (1000 m)
 
   pi = 4.0 * atan(1.0)
   dhml = 0.5 * ( hmlmax - hmlmin ) * g%max_depth
   dhdy = dhml * ( pi / ( frontfractionalwidth * g%len_lat * km ) ) * cos( ypseudo(g, lat) )
   dtdy = -( dt / g%max_depth ) * dhdy
 

Here is the call graph for this function:

Here is the caller graph for this function:

◆ hml()

real function rossby_front_2d_initialization::hml	(	type(ocean_grid_type), intent(in)	G,
		real, intent(in)	lat
	)

private

Analytic prescription of mixed layer depth in 2d Rossby front test.

Parameters

[in]	g	Grid structure
[in]	lat	Latitude

Definition at line 234 of file Rossby_front_2d_initialization.F90.

References hmlmax, hmlmin, and ypseudo().

Referenced by rossby_front_initialize_temperature_salinity(), rossby_front_initialize_thickness(), and rossby_front_initialize_velocity().

   type(ocean_grid_type), intent(in) :: g   !< Grid structure
   real,                  intent(in) :: lat !< Latitude
   ! Local
   real :: dhml, hmlmean
 
   dhml = 0.5 * ( hmlmax - hmlmin ) * g%max_depth
   hmlmean = 0.5 * ( hmlmin + hmlmax ) * g%max_depth
   hml = hmlmean + dhml * sin( ypseudo(g, lat) )

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rossby_front_initialize_temperature_salinity()

subroutine, public rossby_front_2d_initialization::rossby_front_initialize_temperature_salinity	(	real, dimension(szi_(g),szj_(g), szk_(g)), intent(out)	T,
		real, dimension(szi_(g),szj_(g), szk_(g)), intent(out)	S,
		real, dimension(szi_(g),szj_(g), szk_(g)), intent(in)	h,
		type(ocean_grid_type), intent(in)	G,
		type(param_file_type), intent(in)	param_file,
		type(eos_type), pointer	eqn_of_state,
		logical, intent(in), optional	just_read_params
	)

Initialization of temperature and salinity in the Rossby front test.

Parameters

[in]	g	Grid structure
[out]	t	Potential temperature [deg C]
[out]	s	Salinity [ppt]
[in]	h	Thickness
[in]	param_file	Parameter file handle
	eqn_of_state	Equation of state structure
[in]	just_read_params	If present and true, this call will only read parameters without changing h.

Definition at line 114 of file Rossby_front_2d_initialization.F90.

References hml(), and mdl.

   type(ocean_grid_type),                     intent(in)  :: g  !< Grid structure
   real, dimension(SZI_(G),SZJ_(G), SZK_(G)), intent(out) :: t  !< Potential temperature [deg C]
   real, dimension(SZI_(G),SZJ_(G), SZK_(G)), intent(out) :: s  !< Salinity [ppt]
   real, dimension(SZI_(G),SZJ_(G), SZK_(G)), intent(in)  :: h  !< Thickness
   type(param_file_type),                     intent(in)  :: param_file   !< Parameter file handle
   type(eos_type),                            pointer     :: eqn_of_state !< Equation of state structure
   logical,       optional, intent(in)  :: just_read_params !< If present and true, this call will
                                                       !! only read parameters without changing h.
 
   integer   :: i, j, k, is, ie, js, je, nz
   real      :: t_ref, s_ref ! Reference salinity and temerature within surface layer
   real      :: t_range      ! Range of salinities and temperatures over the vertical
   real      :: y, zc, zi, dtdz
   logical :: just_read    ! If true, just read parameters but set nothing.
   character(len=40) :: verticalcoordinate
   real      :: pi                   ! 3.1415926... calculated as 4*atan(1)
 
   is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec ; nz = g%ke
 
   just_read = .false. ; if (present(just_read_params)) just_read = just_read_params
 
   call get_param(param_file, mdl,"REGRIDDING_COORDINATE_MODE", verticalcoordinate, &
             default=default_coordinate_mode, do_not_log=just_read)
   call get_param(param_file, mdl,"S_REF",s_ref,'Reference salinity', units='1e-3', &
                  fail_if_missing=.not.just_read, do_not_log=just_read)
   call get_param(param_file, mdl,"T_REF",t_ref,'Reference temperature',units='C',&
                  fail_if_missing=.not.just_read, do_not_log=just_read)
   call get_param(param_file, mdl,"T_RANGE",t_range,'Initial temperature range',&
                  units='C', default=0.0, do_not_log=just_read)
 
   if (just_read) return ! All run-time parameters have been read, so return.
 
   t(:,:,:) = 0.0
   s(:,:,:) = s_ref
   dtdz = t_range / g%max_depth
 
   do j = g%jsc,g%jec ; do i = g%isc,g%iec
     zi = 0.
     do k = 1, nz
       zi = zi - h(i,j,k)              ! Bottom interface position
       zc = zi - 0.5*h(i,j,k)          ! Position of middle of cell
       zc = min( zc, -hml(g, g%geoLatT(i,j)) ) ! Bound by depth of mixed layer
       t(i,j,k) = t_ref + dtdz * zc ! Linear temperature profile
     enddo
   end do ; end do
 

Here is the call graph for this function:

◆ rossby_front_initialize_thickness()

subroutine, public rossby_front_2d_initialization::rossby_front_initialize_thickness	(	real, dimension(szi_(g),szj_(g),szk_(gv)), intent(out)	h,
		type(ocean_grid_type), intent(in)	G,
		type(verticalgrid_type), intent(in)	GV,
		type(param_file_type), intent(in)	param_file,
		logical, intent(in), optional	just_read_params
	)

Initialization of thicknesses in 2D Rossby front test.

Parameters

[in]	g	Grid structure
[in]	gv	Vertical grid structure
[out]	h	The thickness that is being initialized, in m.
[in]	param_file	A structure indicating the open file to parse for model parameter values.
[in]	just_read_params	If present and true, this call will only read parameters without changing h.

Definition at line 42 of file Rossby_front_2d_initialization.F90.

References hml(), mdl, mom_error_handler::mom_error(), mom_error_handler::mom_mesg(), regrid_consts::regridding_rho, and regrid_consts::regridding_sigma.

   type(ocean_grid_type),   intent(in) :: g            !< Grid structure
   type(verticalgrid_type), intent(in) :: gv           !< Vertical grid structure
   real, dimension(SZI_(G),SZJ_(G),SZK_(GV)), &
                            intent(out) :: h           !< The thickness that is being initialized, in m.
   type(param_file_type),   intent(in)  :: param_file  !< A structure indicating the open file
                                                       !! to parse for model parameter values.
   logical,       optional, intent(in)  :: just_read_params !< If present and true, this call will
                                                       !! only read parameters without changing h.
 
   integer :: i, j, k, is, ie, js, je, nz
   real    :: tz, dml, eta, stretch, h0
   real    :: min_thickness, t_range, drho_dt
   logical :: just_read    ! If true, just read parameters but set nothing.
   character(len=40) :: verticalcoordinate
 
   is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec ; nz = g%ke
 
   just_read = .false. ; if (present(just_read_params)) just_read = just_read_params
 
   if (.not.just_read) &
     call mom_mesg("Rossby_front_2d_initialization.F90, Rossby_front_initialize_thickness: setting thickness")
 
   if (.not.just_read) call log_version(param_file, mdl, version, "")
   ! Read parameters needed to set thickness
   call get_param(param_file, mdl, "MIN_THICKNESS", min_thickness, &
                  'Minimum layer thickness',units='m',default=1.e-3, do_not_log=just_read)
   call get_param(param_file, mdl, "REGRIDDING_COORDINATE_MODE", verticalcoordinate, &
                  default=default_coordinate_mode, do_not_log=just_read)
   call get_param(param_file, mdl, "T_RANGE", t_range, 'Initial temperature range', &
                  units='C', default=0.0, do_not_log=just_read)
   call get_param(param_file, mdl, "DRHO_DT", drho_dt, default=-0.2, do_not_log=.true.)
 
   if (just_read) return ! All run-time parameters have been read, so return.
 
   tz = t_range / g%max_depth
 
   select case ( coordinatemode(verticalcoordinate) )
 
     case (regridding_layer, regridding_rho)
       do j = g%jsc,g%jec ; do i = g%isc,g%iec
         dml = hml( g, g%geoLatT(i,j) )
         eta = -( -drho_dt / gv%Rho0 ) * tz * 0.5 * ( dml * dml )
         stretch = ( ( g%max_depth + eta ) / g%max_depth )
         h0 = ( g%max_depth / real(nz) ) * stretch
         do k = 1, nz
           h(i,j,k) = h0
         enddo
       end do ; end do
 
     case (regridding_zstar, regridding_sigma)
       do j = g%jsc,g%jec ; do i = g%isc,g%iec
         dml = hml( g, g%geoLatT(i,j) )
         eta = -( -drho_dt / gv%Rho0 ) * tz * 0.5 * ( dml * dml )
         stretch = ( ( g%max_depth + eta ) / g%max_depth )
         h0 = ( g%max_depth / real(nz) ) * stretch
         do k = 1, nz
           h(i,j,k) = h0
         enddo
       end do ; end do
 
     case default
       call mom_error(fatal,"Rossby_front_initialize: "// &
       "Unrecognized i.c. setup - set REGRIDDING_COORDINATE_MODE")
 
   end select
 

Here is the call graph for this function:

◆ rossby_front_initialize_velocity()

subroutine, public rossby_front_2d_initialization::rossby_front_initialize_velocity	(	real, dimension(szib_(g),szj_(g),szk_(g)), intent(out)	u,
		real, dimension(szi_(g),szjb_(g),szk_(g)), intent(out)	v,
		real, dimension(szi_(g),szj_(g), szk_(g)), intent(in)	h,
		type(ocean_grid_type), intent(in)	G,
		type(verticalgrid_type), intent(in)	GV,
		type(param_file_type), intent(in)	param_file,
		logical, intent(in), optional	just_read_params
	)

Initialization of u and v in the Rossby front test.

Parameters

[in]	g	Grid structure
[in]	gv	Vertical grid structure
[out]	u	i-component of velocity [m/s]
[out]	v	j-component of velocity [m/s]
[in]	h	Thickness [H]
[in]	param_file	A structure indicating the open file to parse for model parameter values.
[in]	just_read_params	If present and true, this call will only read parameters without changing h.

Definition at line 165 of file Rossby_front_2d_initialization.F90.

References dtdy(), hml(), and mdl.

Referenced by mom_state_initialization::mom_initialize_state().

   type(ocean_grid_type),                  intent(in)     :: g  !< Grid structure
   type(verticalgrid_type),                intent(in)     :: gv !< Vertical grid structure
   real, dimension(SZIB_(G),SZJ_(G),SZK_(G)), intent(out) :: u  !< i-component of velocity [m/s]
   real, dimension(SZI_(G),SZJB_(G),SZK_(G)), intent(out) :: v  !< j-component of velocity [m/s]
   real, dimension(SZI_(G),SZJ_(G), SZK_(G)), intent(in)  :: h  !< Thickness [H]
   type(param_file_type),                  intent(in)     :: param_file !< A structure indicating the
                                                                !! open file to parse for model
                                                                !! parameter values.
   logical,       optional, intent(in)  :: just_read_params !< If present and true, this call will
                                                       !! only read parameters without changing h.
 
   real    :: y              ! Non-dimensional coordinate across channel, 0..pi
   real    :: t_range        ! Range of salinities and temperatures over the vertical
   real    :: dudt           ! Factor to convert dT/dy into dU/dz, g*alpha/f
   real    :: drho_dt, zi, zc, zm, f, ty, dml, hatu
   integer :: i, j, k, is, ie, js, je, nz
   logical :: just_read    ! If true, just read parameters but set nothing.
   character(len=40) :: verticalcoordinate
 
   is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec ; nz = g%ke
 
   just_read = .false. ; if (present(just_read_params)) just_read = just_read_params
 
   call get_param(param_file, mdl, "REGRIDDING_COORDINATE_MODE", verticalcoordinate, &
                  default=default_coordinate_mode, do_not_log=just_read)
   call get_param(param_file, mdl, "T_RANGE", t_range, 'Initial temperature range', &
                  units='C', default=0.0, do_not_log=just_read)
   call get_param(param_file, mdl, "DRHO_DT", drho_dt, default=-0.2, do_not_log=.true.)
 
   if (just_read) return ! All run-time parameters have been read, so return.
 
   v(:,:,:) = 0.0
   u(:,:,:) = 0.0
 
   do j = g%jsc,g%jec ; do i = g%isc-1,g%iec+1
     f = 0.5*( g%CoriolisBu(i,j) + g%CoriolisBu(i,j-1) )
     dudt = 0.0 ; if (abs(f) > 0.0) &
       dudt = ( gv%g_Earth * drho_dt ) / ( f * gv%Rho0 )
     dml = hml( g, g%geoLatT(i,j) )
     ty = dtdy( g, t_range, g%geoLatT(i,j) )
     zi = 0.
     do k = 1, nz
       hatu = 0.5*(h(i,j,k)+h(i+1,j,k))
       zi = zi - hatu              ! Bottom interface position
       zc = zi - 0.5*hatu          ! Position of middle of cell
       zm = max( zc + dml, 0. )    ! Height above bottom of mixed layer
       u(i,j,k) = dudt * ty * zm   ! Thermal wind starting at base of ML
     enddo
   enddo ; enddo
 

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ypseudo()

real function rossby_front_2d_initialization::ypseudo	(	type(ocean_grid_type), intent(in)	G,
		real, intent(in)	lat
	)

private

Pseudo coordinate across domain used by Hml() and dTdy() returns a coordinate from -PI/2 .. PI/2 squashed towards the center of the domain.

Parameters

[in]	g	Grid structure
[in]	lat	Latitude

Definition at line 221 of file Rossby_front_2d_initialization.F90.

References frontfractionalwidth.

Referenced by dtdy(), and hml().

   type(ocean_grid_type), intent(in) :: g   !< Grid structure
   real,                  intent(in) :: lat !< Latitude
   ! Local
   real :: y, pi
 
   pi = 4.0 * atan(1.0)
   ypseudo = ( ( lat - g%south_lat ) / g%len_lat ) - 0.5 ! -1/2 .. 1/.2
   ypseudo = pi * max(-0.5, min(0.5, ypseudo / frontfractionalwidth))

Here is the caller graph for this function:

Variable Documentation

◆ frontfractionalwidth

real, parameter rossby_front_2d_initialization::frontfractionalwidth = 0.5

private

Width of front as fraction of domain.

Definition at line 34 of file Rossby_front_2d_initialization.F90.

Referenced by dtdy(), and ypseudo().

34 real, parameter :: frontfractionalwidth = 0.5 !< Width of front as fraction of domain

◆ hmlmax

real, parameter rossby_front_2d_initialization::hmlmax = 0.75

private

Deepest ML as fractional depth of ocean.

Definition at line 36 of file Rossby_front_2d_initialization.F90.

Referenced by dtdy(), and hml().

36 real, parameter :: hmlmax = 0.75 !< Deepest ML as fractional depth of ocean

◆ hmlmin

real, parameter rossby_front_2d_initialization::hmlmin = 0.25

private

Shallowest ML as fractional depth of ocean.

Definition at line 35 of file Rossby_front_2d_initialization.F90.

Referenced by dtdy(), and hml().

35 real, parameter :: hmlmin = 0.25 !< Shallowest ML as fractional depth of ocean

◆ mdl

character(len=40) rossby_front_2d_initialization::mdl = "Rossby_front_2d_initialization"

private

This module's name.

Definition at line 25 of file Rossby_front_2d_initialization.F90.

Referenced by rossby_front_initialize_temperature_salinity(), rossby_front_initialize_thickness(), and rossby_front_initialize_velocity().

25 character(len=40) :: mdl = "Rossby_front_2d_initialization" !< This module's name.

Detailed Description

Description of the 2d Rossby front initial conditions

Functions/Subroutines

Variables

Function/Subroutine Documentation

◆ dtdy()

◆ hml()

◆ rossby_front_initialize_temperature_salinity()

◆ rossby_front_initialize_thickness()

◆ rossby_front_initialize_velocity()

◆ ypseudo()

Variable Documentation

◆ frontfractionalwidth

◆ hmlmax

◆ hmlmin

◆ mdl