Functions/Subroutines
subroutine, public	bfb_set_coord (Rlay, g_prime, GV, param_file, eqn_of_state)

subroutine, public	bfb_initialize_sponges_southonly (G, use_temperature, tv, param_file, CSp, h)

subroutine	write_bfb_log (param_file)
	Write output about the parameter values being used. More...

Variables
logical	first_call = .true.

Function/Subroutine Documentation

◆ bfb_initialize_sponges_southonly()

subroutine, public bfb_initialization::bfb_initialize_sponges_southonly	(	type(ocean_grid_type), intent(in)	G,
		logical, intent(in)	use_temperature,
		type(thermo_var_ptrs), intent(in)	tv,
		type(param_file_type), intent(in)	param_file,
		type(sponge_cs), pointer	CSp,
		real, dimension(nimem_, njmem_, nkmem_), intent(in)	h
	)

Parameters

[in]	g	The ocean's grid structure
[in]	tv	A structure pointing to various thermodynamic variables
[in]	param_file	A structure to parse for run-time parameters
[in]	h	Layer thicknesses, in H (usually m or kg m-2)

Definition at line 107 of file BFB_initialization.F90.

References first_call, mom_sponge::initialize_sponge(), and write_bfb_log().

Referenced by mom_state_initialization::mom_initialize_state().

 ! This subroutine sets up the sponges for the southern bouundary of the domain. Maximum damping occurs within 2 degrees lat of the
 ! boundary. The damping linearly decreases northward over the next 2 degrees.
   type(ocean_grid_type), intent(in)                   :: g    !< The ocean's grid structure
   logical,               intent(in)                   :: use_temperature
   type(thermo_var_ptrs), intent(in)                   :: tv   !< A structure pointing to various thermodynamic variables
   type(param_file_type), intent(in)                   :: param_file !< A structure to parse for run-time parameters
   type(sponge_cs),       pointer                      :: csp
   real, dimension(NIMEM_, NJMEM_, NKMEM_), intent(in) :: h    !< Layer thicknesses, in H (usually m or kg m-2)
   !call MOM_error(FATAL, &
   ! "BFB_initialization.F90, BFB_initialize_sponges: " // &
   ! "Unmodified user routine called - you must edit the routine to use it")
 
   real :: eta(szi_(g),szj_(g),szk_(g)+1) ! A temporary array for eta.
   real :: idamp(szi_(g),szj_(g))    ! The inverse damping rate, in s-1.
 
   real :: h0(szk_(g))
   real :: min_depth
   real :: damp, e_dense, damp_new, slat, wlon, lenlat, lenlon, nlat
   character(len=40)  :: mdl = "BFB_initialize_sponges_southonly" ! This subroutine's name.
   integer :: i, j, k, is, ie, js, je, isd, ied, jsd, jed, nz
 
   is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec ; nz = g%ke
   isd = g%isd ; ied = g%ied ; jsd = g%jsd ; jed = g%jed
 
   eta(:,:,:) = 0.0 ; idamp(:,:) = 0.0
 
 !  Here the inverse damping time, in s-1, is set. Set Idamp to 0     !
 !  wherever there is no sponge, and the subroutines that are called  !
 !  will automatically set up the sponges only where Idamp is positive!
 !  and mask2dT is 1.                                                   !
 
 !   Set up sponges for DOME configuration
   call get_param(param_file, mdl, "MINIMUM_DEPTH", min_depth, &
                  "The minimum depth of the ocean.", units="m", default=0.0)
 
   call get_param(param_file, mdl, "SOUTHLAT", slat, &
                  "The southern latitude of the domain.", units="degrees")
   call get_param(param_file, mdl, "LENLAT", lenlat, &
                  "The latitudinal length of the domain.", units="degrees")
   call get_param(param_file, mdl, "WESTLON", wlon, &
                  "The western longitude of the domain.", units="degrees", default=0.0)
   call get_param(param_file, mdl, "LENLON", lenlon, &
                  "The longitudinal length of the domain.", units="degrees")
   nlat = slat + lenlat
   do k=1,nz ; h0(k) = -g%max_depth * real(k-1) / real(nz) ; enddo
 !  do k=1,nz ; H0(k) = -G%max_depth * real(k-1) / real(nz-1) ; enddo ! Use for meridional thickness profile initialization
   do i=is,ie; do j=js,je
     if (g%geoLatT(i,j) < slat+2.0) then ; damp = 1.0
     elseif (g%geoLatT(i,j) < slat+4.0) then
        damp_new = 1.0*(slat+4.0-g%geoLatT(i,j))/2.0
     else ; damp = 0.0
     endif
 
     ! These will be streched inside of apply_sponge, so they can be in
     ! depth space for Boussinesq or non-Boussinesq models.
 
     ! This section is used for uniform thickness initialization
     do k = 1,nz; eta(i,j,k) = h0(k); enddo
 
     ! The below section is used for meridional temperature profile thickness initiation
     ! do k = 1,nz; eta(i,j,k) = H0(k); enddo
     ! if (G%geoLatT(i,j) > 40.0) then
     !   do k = 1,nz
     !     eta(i,j,k) = -G%Angstrom_z*(k-1)
     !   enddo
     ! elseif (G%geoLatT(i,j) > 20.0) then
     !   do k = 1,nz
     !     eta(i,j,k) = min(H0(k) + (G%geoLatT(i,j) - 20.0)*(G%max_depth - nz*G%Angstrom_z)/20.0, -(k-1)*G%angstrom_z)
     !   enddo
     ! endif
     eta(i,j,nz+1) = -g%max_depth
 
     if (g%bathyT(i,j) > min_depth) then
       idamp(i,j) = damp/86400.0
     else ; idamp(i,j) = 0.0 ; endif
   enddo ; enddo
 
 !  This call sets up the damping rates and interface heights.
 !  This sets the inverse damping timescale fields in the sponges.    !
   call initialize_sponge(idamp, eta, g, param_file, csp)
 
 !   Now register all of the fields which are damped in the sponge.   !
 ! By default, momentum is advected vertically within the sponge, but !
 ! momentum is typically not damped within the sponge.                !
 
   if (first_call) call write_bfb_log(param_file)
 

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bfb_set_coord()

subroutine, public bfb_initialization::bfb_set_coord	(	real, dimension( : ), intent(out)	Rlay,
		real, dimension( : ), intent(out)	g_prime,
		type(verticalgrid_type), intent(in)	GV,
		type(param_file_type), intent(in)	param_file,
		type(eos_type), pointer	eqn_of_state
	)

Parameters

[in]	gv	The ocean's vertical grid structure
[in]	param_file	A structure to parse for run-time parameters

Definition at line 66 of file BFB_initialization.F90.

References first_call, and write_bfb_log().

Referenced by mom_coord_initialization::mom_initialize_coord().

 ! This subroutine specifies the vertical coordinate in terms of temperature at the surface and at the bottom. This case is set up in
 ! such a way that the temperature of the topmost layer is equal to the SST at the southern edge of the domain. The temperatures are
 ! then converted to densities of the top and bottom layers and linearly interpolated for the intermediate layers.
   real, dimension(NKMEM_), intent(out) :: rlay, g_prime
   type(verticalgrid_type), intent(in)  :: gv   !< The ocean's vertical grid structure
   type(param_file_type),   intent(in)  :: param_file !< A structure to parse for run-time parameters
   type(eos_type),          pointer     :: eqn_of_state
   real                                 :: drho_dt, sst_s, t_bot, rho_top, rho_bot
   integer                              :: k, nz
   character(len=40)  :: mdl = "BFB_set_coord" ! This subroutine's name.
 
   call get_param(param_file, mdl, "DRHO_DT", drho_dt, &
           "Rate of change of density with temperature.", &
            units="kg m-3 K-1", default=-0.2)
   call get_param(param_file, mdl, "SST_S", sst_s, &
           "SST at the suothern edge of the domain.", units="C", default=20.0)
   call get_param(param_file, mdl, "T_BOT", t_bot, &
                  "Bottom Temp", units="C", default=5.0)
   rho_top = gv%rho0 + drho_dt*sst_s
   rho_bot = gv%rho0 + drho_dt*t_bot
   nz = gv%ke
 
   !call MOM_error(FATAL, &
   ! "BFB_initialization.F90, BFB_set_coord: " // &
   ! "Unmodified user routine called - you must edit the routine to use it")
   do k = 1,nz
     rlay(k) = (rho_bot - rho_top)/(nz-1)*real(k-1) + rho_top
     if (k >1) then
       g_prime(k) = (rlay(k) - rlay(k-1))*gv%g_earth/gv%rho0
     else
       g_prime(k) = gv%g_earth
     end if
     !Rlay(:) = 0.0
     !g_prime(:) = 0.0
   end do
 
   if (first_call) call write_bfb_log(param_file)
 

Here is the call graph for this function:

Here is the caller graph for this function:

◆ write_bfb_log()

subroutine bfb_initialization::write_bfb_log ( type(param_file_type), intent(in) param_file )

private

Write output about the parameter values being used.

Parameters

[in] param_file A structure indicating the open file to parse for model parameter values.

Definition at line 198 of file BFB_initialization.F90.

References first_call.

Referenced by bfb_initialize_sponges_southonly(), and bfb_set_coord().

   type(param_file_type), intent(in) :: param_file !< A structure indicating the
                                                   !! open file to parse for model
                                                   !! parameter values.
 
 ! This include declares and sets the variable "version".
 #include "version_variable.h"
   character(len=40)  :: mdl = "BFB_initialization" ! This module's name.
 
   call log_version(param_file, mdl, version)
   first_call = .false.
 

Here is the caller graph for this function:

Variable Documentation

◆ first_call

logical bfb_initialization::first_call = .true.

private

Definition at line 61 of file BFB_initialization.F90.

Referenced by bfb_initialize_sponges_southonly(), bfb_set_coord(), and write_bfb_log().

61 logical :: first_call = .true.

Functions/Subroutines

Variables

Function/Subroutine Documentation

◆ bfb_initialize_sponges_southonly()

◆ bfb_set_coord()

◆ write_bfb_log()

Variable Documentation

◆ first_call