Detailed Description

The module configures the model for the non-rotating sloshing test case.

Functions/Subroutines
subroutine, public	sloshing_initialize_topography (D, G, param_file, max_depth)
	Initialization of topography. More...

subroutine, public	sloshing_initialize_thickness (h, G, GV, param_file, just_read_params)
	Initialization of thicknesses This routine is called when THICKNESS_CONFIG is set to 'sloshing'. More...

subroutine, public	sloshing_initialize_temperature_salinity (T, S, h, G, param_file, eqn_of_state, just_read_params)
	Initialization of temperature and salinity. More...

Variables
character(len=40)	mdl = "sloshing_initialization"

Function/Subroutine Documentation

◆ sloshing_initialize_temperature_salinity()

subroutine, public sloshing_initialization::sloshing_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.

This subroutine initializes linear profiles for T and S according to reference surface layer salinity and temperature and a specified range. Note that the linear distribution is set up with respect to the layer number, not the physical position).

Parameters

[in]	g	Ocean grid structure.
[out]	t	Potential temperature (degC).
[out]	s	Salinity (ppt).
[in]	h	Layer thickness (m or Pa).
[in]	param_file	A structure indicating the open file to parse for model parameter values.
	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 208 of file sloshing_initialization.F90.

Referenced by mom_state_initialization::mom_initialize_state().

   type(ocean_grid_type),                     intent(in)  :: g !< Ocean 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 !< Layer thickness (m or Pa).
   type(param_file_type),                     intent(in)  :: param_file !< A structure indicating the
                                                             !! open file to parse for model
                                                             !! parameter values.
   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    :: delta_s, delta_t
   real    :: s_ref, t_ref;      ! Reference salinity and temerature within
                                 ! surface layer
   real    :: s_range, t_range;  ! Range of salinities and temperatures over the
                                 ! vertical
   integer :: kdelta
   real    :: deltah
   real    :: xi0, xi1
   logical :: just_read    ! If true, just read parameters but set nothing.
   character(len=40)  :: mdl = "initialize_temp_salt_linear" ! This subroutine's
                                                             ! name.
 
   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,"S_REF",s_ref,'Reference value for 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,'Refernce value for temperature', &
                  units='C', fail_if_missing=.not.just_read, do_not_log=just_read)
 
   ! The default is to assume an increase by 2 for the salinity and a uniform
   ! temperature
   call get_param(param_file, mdl,"S_RANGE",s_range,'Initial salinity range.', &
                  units='1e-3', default=2.0, 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.
 
   ! Prescribe salinity
   !delta_S = S_range / ( G%ke - 1.0 )
 
   !S(:,:,1) = S_ref
   !do k = 2,G%ke
   !  S(:,:,k) = S(:,:,k-1) + delta_S
   !end do
 
   deltah = g%max_depth / nz;
   do j=js,je ; do i=is,ie
     xi0 = 0.0
     do k = 1,nz
       xi1 = xi0 + deltah / g%max_depth
       s(i,j,k) = 34.0 + 0.5 * s_range * (xi0 + xi1)
       xi0 = xi1
     enddo
   enddo ; enddo
 
   ! Prescribe temperature
   delta_t = t_range / ( g%ke - 1.0 )
 
   t(:,:,1) = t_ref
   do k = 2,g%ke
     t(:,:,k) = t(:,:,k-1) + delta_t
   end do
   kdelta = 2
   t(:,:,g%ke/2 - (kdelta-1):g%ke/2 + kdelta) = 1.0
 

Here is the caller graph for this function:

◆ sloshing_initialize_thickness()

subroutine, public sloshing_initialization::sloshing_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 This routine is called when THICKNESS_CONFIG is set to 'sloshing'.

This routine initializes layer positions to set off a sloshing motion in the zonal direction in a rectangular basin. All layers have initially the same thickness but all interfaces (except bottom and sea surface) are displaced according to a half-period cosine, with maximum value on the left and minimum value on the right. This sets off a regular sloshing motion.

Parameters

[in]	g	The ocean's grid structure.
[in]	gv	The ocean's 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 86 of file sloshing_initialization.F90.

   type(ocean_grid_type),   intent(in)  :: g           !< The ocean's grid structure.
   type(verticalgrid_type), intent(in)  :: gv          !< The ocean's 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.
 
   real    :: displ(szk_(g)+1)
   real    :: z_unif(szk_(g)+1)
   real    :: z_inter(szk_(g)+1)
   real    :: x
   real    :: a0
   real    :: deltah
   real    :: total_height
   real    :: weight_z
   real    :: x1, y1, x2, y2
   real    :: t
   logical :: just_read    ! If true, just read parameters but set nothing.
   integer :: n
 
   integer :: i, j, k, is, ie, js, je, nx, nz
 
   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 (just_read) return ! This subroutine has no run-time parameters.
 
   deltah = g%max_depth / nz
 
   ! Define thicknesses
   do j=g%jsc,g%jec ; do i=g%isc,g%iec
 
     ! Define uniform interfaces
     do k = 0,nz
       z_unif(k+1) = -real(k)/real(nz)
     end do
 
     ! 1. Define stratification
     n = 3
     do k = 1,nz+1
 
       ! Thin pycnocline in the middle
       !z_inter(k) = (2.0**(n-1)) * (z_unif(k) + 0.5)**n - 0.5
 
       ! Thin pycnocline in the middle (piecewise linear profile)
       x1 = 0.30; y1 = 0.48; x2 = 0.70; y2 = 0.52
 
       x = -z_unif(k)
 
       if ( x .le. x1 ) then
         t = y1*x/x1;
       else if ( (x .gt. x1 ) .and. ( x .lt. x2 )) then
         t = y1 + (y2-y1) * (x-x1) / (x2-x1)
       else
         t = y2 + (1.0-y2) * (x-x2) / (1.0-x2)
       end if
 
       t = - z_unif(k)
 
       z_inter(k) = -t * g%max_depth
 
     end do
 
     ! 2. Define displacement
     a0 = 75.0;      ! Displacement amplitude (meters)
     do k = 1,nz+1
 
       weight_z = - 4.0 * ( z_unif(k) + 0.5 )**2 + 1
 
       x = g%geoLonT(i,j) / g%len_lon
       displ(k) = a0 * cos(acos(-1.0)*x) + weight_z;
 
       if ( k .EQ. 1 ) then
         displ(k) = 0.0
       end if
 
       if ( k .EQ. nz+1 ) then
         displ(k) = 0.0
       end if
 
       z_inter(k) = z_inter(k) + displ(k)
 
     end do
 
     ! 3. The last interface must coincide with the seabed
     z_inter(nz+1) = -g%bathyT(i,j)
 
     ! Modify interface heights to make sure all thicknesses
     ! are strictly positive
     do k = nz,1,-1
 
       if ( z_inter(k) .LT. (z_inter(k+1) + gv%Angstrom) ) then
         z_inter(k) = z_inter(k+1) + gv%Angstrom
       end if
 
     end do
 
     ! 4. Define layers
     total_height = 0.0
     do k = 1,nz
       h(i,j,k) = z_inter(k) - z_inter(k+1)
 
       total_height = total_height + h(i,j,k)
     end do
 
   enddo ; enddo
 

◆ sloshing_initialize_topography()

subroutine, public sloshing_initialization::sloshing_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
	)

Initialization of topography.

Parameters

[in]	g	The dynamic horizontal grid type
[out]	d	Ocean bottom depth in m
[in]	param_file	Parameter file structure
[in]	max_depth	Maximum depth of model in m

Definition at line 57 of file sloshing_initialization.F90.

Referenced by mom_fixed_initialization::mom_initialize_topography().

   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 m
   type(param_file_type),              intent(in)  :: param_file !< Parameter file structure
   real,                               intent(in)  :: max_depth  !< Maximum depth of model in m
 
   ! Local variables
   integer   :: i, j
 
   do i=g%isc,g%iec
     do j=g%jsc,g%jec
 
       d(i,j) = max_depth
 
     enddo
   enddo
 

Here is the caller graph for this function:

Variable Documentation

◆ mdl

character(len=40) sloshing_initialization::mdl = "sloshing_initialization"

private

Definition at line 48 of file sloshing_initialization.F90.

48 character(len=40) :: mdl = "sloshing_initialization" ! This module's name.

Detailed Description

Functions/Subroutines

Variables

Function/Subroutine Documentation

◆ sloshing_initialize_temperature_salinity()

◆ sloshing_initialize_thickness()

◆ sloshing_initialize_topography()

Variable Documentation

◆ mdl