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, US, 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, GV, 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, US, 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, in the same units as Gmax_depth. 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 [nondim]. More...

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

real, parameter	hmlmax = 0.75
	Deepest ML as fractional depth of ocean [nondim]. 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 256 of file Rossby_front_2d_initialization.F90.

   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
  

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

Referenced by rossby_front_initialize_velocity().

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, in the same units as Gmax_depth.

Parameters

[in]	g	Grid structure
[in]	lat	Latitude

Definition at line 243 of file Rossby_front_2d_initialization.F90.

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

References hmlmax, hmlmin, and ypseudo().

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

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( g %isd: g %ied, g %jsd: g %jed, g %ke), intent(out)	T,
		real, dimension( g %isd: g %ied, g %jsd: g %jed, g %ke), intent(out)	S,
		real, dimension( g %isd: g %ied, g %jsd: g %jed, g %ke), intent(in)	h,
		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,
		logical, intent(in), optional	just_read_params
	)

Initialization of temperature and salinity in the Rossby front test.

Parameters

[in]	g	Grid structure
[in]	gv	The ocean's vertical grid structure.
[out]	t	Potential temperature [degC]
[out]	s	Salinity [ppt]
[in]	h	Thickness [H ~> m or kg m-2]
[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 T & S.

Definition at line 114 of file Rossby_front_2d_initialization.F90.

   type(ocean_grid_type),                     intent(in)  :: G  !< Grid structure
   type(verticalGrid_type),                   intent(in)  :: GV !< The ocean's vertical grid structure.
   real, dimension(SZI_(G),SZJ_(G), SZK_(G)), intent(out) :: T  !< Potential temperature [degC]
   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 [H ~> m or kg m-2]
   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 T & S.
  
   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 = gv%H_to_Z * (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
   enddo ; enddo
  

References hml(), and mdl.

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(unit_scale_type), intent(in)	US,
		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
[in]	us	A dimensional unit scaling type
[out]	h	The thickness that is being initialized [H ~> m or kg m-2]
[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 40 of file Rossby_front_2d_initialization.F90.

   type(ocean_grid_type),   intent(in)  :: G           !< Grid structure
   type(verticalGrid_type), intent(in)  :: GV          !< Vertical grid structure
   type(unit_scale_type),   intent(in)  :: US          !< A dimensional unit scaling type
   real, dimension(SZI_(G),SZJ_(G),SZK_(GV)), &
                            intent(out) :: h           !< The thickness that is being initialized [H ~> m or kg m-2]
   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
   real    :: dRho_dT      ! The partial derivative of density with temperature [R degC-1 ~> kg m-3 degC-1]
   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, scale=us%kg_m3_to_R, 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 * gv%Z_to_H
         enddo
       enddo ; enddo
  
     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 * gv%Z_to_H
         enddo
       enddo ; enddo
  
     case default
       call mom_error(fatal,"Rossby_front_initialize: "// &
       "Unrecognized i.c. setup - set REGRIDDING_COORDINATE_MODE")
  
   end select
  

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

Here is the call graph for this function:

◆ rossby_front_initialize_velocity()

subroutine, public rossby_front_2d_initialization::rossby_front_initialize_velocity	(	real, dimension( g %isdb: g %iedb, g %jsd: g %jed, g %ke), intent(out)	u,
		real, dimension( g %isd: g %ied, g %jsdb: g %jedb, g %ke), intent(out)	v,
		real, dimension( g %isd: g %ied, g %jsd: g %jed, g %ke), intent(in)	h,
		type(ocean_grid_type), intent(in)	G,
		type(verticalgrid_type), intent(in)	GV,
		type(unit_scale_type), intent(in)	US,
		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 [L T-1 ~> m s-1]
[out]	v	j-component of velocity [L T-1 ~> m s-1]
[in]	h	Thickness [H ~> m or kg m-2]
[in]	us	A dimensional unit scaling type
[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 setting u & v.

Definition at line 166 of file Rossby_front_2d_initialization.F90.

   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 [L T-1 ~> m s-1]
   real, dimension(SZI_(G),SZJB_(G),SZK_(G)), &
                               intent(out) :: v  !< j-component of velocity [L T-1 ~> m s-1]
   real, dimension(SZI_(G),SZJ_(G), SZK_(G)), &
                               intent(in)  :: h  !< Thickness [H ~> m or kg m-2]
   type(unit_scale_type),      intent(in)  :: US !< A dimensional unit scaling type
   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 setting u & v.
  
   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 [L2 Z-1 T-1 degC-1 ~> m s-1 degC-1]
   real    :: dRho_dT      ! The partial derivative of density with temperature [R degC-1 ~> kg m-3 degC-1]
   real    :: Dml, zi, zc, zm ! Depths [Z ~> m].
   real    :: f            ! The local Coriolis parameter [T-1 ~> s-1]
   real    :: Ty           ! The meridional temperature gradient [degC L-1 ~> degC m-1]
   real    :: hAtU         ! Interpolated layer thickness [Z ~> m].
   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, scale=us%kg_m3_to_R, 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 = us%L_to_m*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)) * gv%H_to_Z
       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
  

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

Referenced by mom_state_initialization::mom_initialize_state().

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 229 of file Rossby_front_2d_initialization.F90.

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

References frontfractionalwidth.

Referenced by dtdy(), and hml().

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 [nondim].

Definition at line 32 of file Rossby_front_2d_initialization.F90.

32 real, parameter :: frontFractionalWidth = 0.5 !< Width of front as fraction of domain [nondim]

Referenced by dtdy(), and ypseudo().

◆ hmlmax

real, parameter rossby_front_2d_initialization::hmlmax = 0.75

private

Deepest ML as fractional depth of ocean [nondim].

Definition at line 34 of file Rossby_front_2d_initialization.F90.

34 real, parameter :: HMLmax = 0.75 !< Deepest ML as fractional depth of ocean [nondim]

Referenced by dtdy(), and hml().

◆ hmlmin

real, parameter rossby_front_2d_initialization::hmlmin = 0.25

private

Shallowest ML as fractional depth of ocean [nondim].

Definition at line 33 of file Rossby_front_2d_initialization.F90.

33 real, parameter :: HMLmin = 0.25 !< Shallowest ML as fractional depth of ocean [nondim]

Referenced by dtdy(), and hml().

◆ mdl

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

private

This module's name.

Definition at line 23 of file Rossby_front_2d_initialization.F90.

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

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

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