Detailed Description

Interface to background mixing schemes, including the Bryan and Lewis (1979) which is applied via CVMix.

Data Types
type	bkgnd_mixing_cs
	Control structure including parameters for this module. More...

Functions/Subroutines
subroutine, public	bkgnd_mixing_init (Time, G, GV, US, param_file, diag, CS)
	Initialize the background mixing routine. More...

subroutine, public	calculate_bkgnd_mixing (h, tv, N2_lay, Kd_lay, Kd_int, Kv_bkgnd, j, G, GV, US, CS)
	Calculates the vertical background diffusivities/viscosities. More...

logical function	cvmix_bkgnd_is_used (param_file)
	Reads the parameter "USE_CVMix_BACKGROUND" and returns state. This function allows other modules to know whether this parameterization will be used without needing to duplicate the log entry. More...

subroutine	check_bkgnd_scheme (CS, str)
	Sets CSbkgnd_scheme_str to check whether multiple background diffusivity schemes are activated. The string is also for error/log messages. More...

subroutine, public	bkgnd_mixing_end (CS)
	Clear pointers and dealocate memory. More...

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

Function/Subroutine Documentation

◆ bkgnd_mixing_end()

subroutine, public mom_bkgnd_mixing::bkgnd_mixing_end ( type(bkgnd_mixing_cs), pointer CS )

Clear pointers and dealocate memory.

Parameters

cs	Control structure for this module that will be deallocated in this subroutine

Definition at line 551 of file MOM_bkgnd_mixing.F90.

   type(bkgnd_mixing_cs), pointer :: cs !< Control structure for this module that
                                        !! will be deallocated in this subroutine
 
   if (.not. associated(cs)) return
   deallocate(cs)
 

◆ bkgnd_mixing_init()

subroutine, public mom_bkgnd_mixing::bkgnd_mixing_init	(	type(time_type), intent(in)	Time,
		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,
		type(diag_ctrl), intent(inout), target	diag,
		type(bkgnd_mixing_cs), pointer	CS
	)

Initialize the background mixing routine.

Parameters

[in]	time	The current time.
[in]	g	Grid structure.
[in]	gv	Vertical grid structure.
[in]	us	A dimensional unit scaling type
[in]	param_file	Run-time parameter file handle
[in,out]	diag	Diagnostics control structure.
	cs	This module's control structure.

Definition at line 114 of file MOM_bkgnd_mixing.F90.

 
   type(time_type),         intent(in)    :: time       !< The current time.
   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
   type(param_file_type),   intent(in)    :: param_file !< Run-time parameter file handle
   type(diag_ctrl), target, intent(inout) :: diag       !< Diagnostics control structure.
   type(bkgnd_mixing_cs),    pointer      :: cs         !< This module's control structure.
 
   ! Local variables
   real :: kv                    ! The interior vertical viscosity [Z2 T-1 ~> m2 s-1] - read to set Prandtl
                                 ! number unless it is provided as a parameter
   real :: prandtl_bkgnd_comp    ! Kv/CS%Kd. Gets compared with user-specified prandtl_bkgnd.
 
 ! This include declares and sets the variable "version".
 #include "version_variable.h"
 
   if (associated(cs)) then
     call mom_error(warning, "bkgnd_mixing_init called with an associated "// &
                             "control structure.")
     return
   endif
   allocate(cs)
 
   ! Read parameters
   call log_version(param_file, mdl, version, &
     "Adding static vertical background mixing coefficients")
 
   call get_param(param_file, mdl, "KD", cs%Kd, &
                  "The background diapycnal diffusivity of density in the "//&
                  "interior. Zero or the molecular value, ~1e-7 m2 s-1, "//&
                  "may be used.", default=0.0, units="m2 s-1", scale=us%m2_s_to_Z2_T)
 
   call get_param(param_file, mdl, "KV", kv, &
                  "The background kinematic viscosity in the interior. "//&
                  "The molecular value, ~1e-6 m2 s-1, may be used.", &
                  units="m2 s-1", scale=us%m2_s_to_Z2_T, fail_if_missing=.true.)
 
   call get_param(param_file, mdl, "KD_MIN", cs%Kd_min, &
                  "The minimum diapycnal diffusivity.", &
                  units="m2 s-1", default=0.01*cs%Kd*us%Z2_T_to_m2_s, scale=us%m2_s_to_Z2_T)
 
   ! The following is needed to set one of the choices of vertical background mixing
 
   ! BULKMIXEDLAYER is not always defined (e.g., CM2G63L), so the following line by passes
   ! the need to include BULKMIXEDLAYER in MOM_input
   cs%bulkmixedlayer = (gv%nkml > 0)
   if (cs%bulkmixedlayer) then
     ! Check that Kdml is not set when using bulk mixed layer
     call get_param(param_file, mdl, "KDML", cs%Kdml, default=-1.)
     if (cs%Kdml>0.) call mom_error(fatal, &
                  "bkgnd_mixing_init: KDML cannot be set when using bulk mixed layer.")
     cs%Kdml = cs%Kd ! This is not used with a bulk mixed layer, but also cannot be a NaN.
   else
     call get_param(param_file, mdl, "KDML", cs%Kdml, &
                  "If BULKMIXEDLAYER is false, KDML is the elevated "//&
                  "diapycnal diffusivity in the topmost HMIX of fluid. "//&
                  "KDML is only used if BULKMIXEDLAYER is false.", &
                  units="m2 s-1", default=cs%Kd*us%Z2_T_to_m2_s, scale=us%m2_s_to_Z2_T)
     call get_param(param_file, mdl, "HMIX_FIXED", cs%Hmix, &
                  "The prescribed depth over which the near-surface "//&
                  "viscosity and diffusivity are elevated when the bulk "//&
                  "mixed layer is not used.", units="m", scale=us%m_to_Z, fail_if_missing=.true.)
   endif
 
   call get_param(param_file, mdl, 'DEBUG', cs%debug, default=.false., do_not_log=.true.)
 
 !  call openParameterBlock(param_file,'MOM_BACKGROUND_MIXING')
 
   call get_param(param_file, mdl, "BRYAN_LEWIS_DIFFUSIVITY", cs%Bryan_Lewis_diffusivity, &
                  "If true, use a Bryan & Lewis (JGR 1979) like tanh "//&
                  "profile of background diapycnal diffusivity with depth. "//&
                  "This is done via CVMix.", default=.false.)
 
   if (cs%Bryan_Lewis_diffusivity) then
     call check_bkgnd_scheme(cs, "BRYAN_LEWIS_DIFFUSIVITY")
 
     call get_param(param_file, mdl, "BRYAN_LEWIS_C1", cs%Bryan_Lewis_c1, &
                    "The vertical diffusivity values for Bryan-Lewis profile at |z|=D.", &
                    units="m2 s-1", fail_if_missing=.true.)
 
     call get_param(param_file, mdl, "BRYAN_LEWIS_C2", cs%Bryan_Lewis_c2, &
                    "The amplitude of variation in diffusivity for the Bryan-Lewis profile", &
                    units="m2 s-1", fail_if_missing=.true.)
 
     call get_param(param_file, mdl, "BRYAN_LEWIS_C3", cs%Bryan_Lewis_c3, &
                    "The inverse length scale for transition region in the Bryan-Lewis profile", &
                    units="m-1", fail_if_missing=.true.)
 
     call get_param(param_file, mdl, "BRYAN_LEWIS_C4", cs%Bryan_Lewis_c4, &
                    "The depth where diffusivity is BRYAN_LEWIS_C1 in the Bryan-Lewis profile",&
                    units="m", fail_if_missing=.true.)
 
   endif ! CS%Bryan_Lewis_diffusivity
 
   call get_param(param_file, mdl, "HORIZ_VARYING_BACKGROUND", cs%horiz_varying_background, &
                  "If true, apply vertically uniform, latitude-dependent background "//&
                  "diffusivity, as described in Danabasoglu et al., 2012", &
                  default=.false.)
 
   if (cs%horiz_varying_background) then
     call check_bkgnd_scheme(cs, "HORIZ_VARYING_BACKGROUND")
 
     call get_param(param_file, mdl, "BCKGRND_VDC1", cs%bckgrnd_vdc1, &
                    "Background diffusivity (Ledwell) when HORIZ_VARYING_BACKGROUND=True", &
                    units="m2 s-1",default = 0.16e-04, scale=us%m2_s_to_Z2_T)
 
     call get_param(param_file, mdl, "BCKGRND_VDC_EQ", cs%bckgrnd_vdc_eq, &
                    "Equatorial diffusivity (Gregg) when HORIZ_VARYING_BACKGROUND=True", &
                    units="m2 s-1",default = 0.01e-04, scale=us%m2_s_to_Z2_T)
 
     call get_param(param_file, mdl, "BCKGRND_VDC_PSIM", cs%bckgrnd_vdc_psim, &
                    "Max. PSI induced diffusivity (MacKinnon) when HORIZ_VARYING_BACKGROUND=True", &
                    units="m2 s-1",default = 0.13e-4, scale=us%m2_s_to_Z2_T)
 
     call get_param(param_file, mdl, "BCKGRND_VDC_BAN", cs%bckgrnd_vdc_Banda, &
                    "Banda Sea diffusivity (Gordon) when HORIZ_VARYING_BACKGROUND=True", &
                    units="m2 s-1",default = 1.0e-4, scale=us%m2_s_to_Z2_T)
   endif
 
   call get_param(param_file, mdl, "PRANDTL_BKGND", cs%prandtl_bkgnd, &
                  "Turbulent Prandtl number used to convert vertical "//&
                  "background diffusivities into viscosities.", &
                  units="nondim", default=1.0)
 
   if (cs%Bryan_Lewis_diffusivity .or. cs%horiz_varying_background) then
 
     prandtl_bkgnd_comp = cs%prandtl_bkgnd
     if (cs%Kd /= 0.0) prandtl_bkgnd_comp = kv/cs%Kd
 
     if ( abs(cs%prandtl_bkgnd - prandtl_bkgnd_comp)>1.e-14) then
       call mom_error(fatal,"set_diffusivity_init: The provided KD, KV,"//&
                            "and PRANDTL_BKGND values are incompatible. The following "//&
                            "must hold: KD*PRANDTL_BKGND==KV")
     endif
 
   endif
 
   call get_param(param_file, mdl, "HENYEY_IGW_BACKGROUND", cs%Henyey_IGW_background, &
                  "If true, use a latitude-dependent scaling for the near "//&
                  "surface background diffusivity, as described in "//&
                  "Harrison & Hallberg, JPO 2008.", default=.false.)
   if (cs%Henyey_IGW_background) call check_bkgnd_scheme(cs, "HENYEY_IGW_BACKGROUND")
 
 
   call get_param(param_file, mdl, "HENYEY_IGW_BACKGROUND_NEW", cs%Henyey_IGW_background_new, &
                  "If true, use a better latitude-dependent scaling for the "//&
                  "background diffusivity, as described in "//&
                  "Harrison & Hallberg, JPO 2008.", default=.false.)
   if (cs%Henyey_IGW_background_new) call check_bkgnd_scheme(cs, "HENYEY_IGW_BACKGROUND_NEW")
 
   if (cs%Kd>0.0 .and. (trim(cs%bkgnd_scheme_str)=="BRYAN_LEWIS_DIFFUSIVITY" .or.&
                           trim(cs%bkgnd_scheme_str)=="HORIZ_VARYING_BACKGROUND" )) then
     call mom_error(warning, "set_diffusivity_init: a nonzero constant background "//&
          "diffusivity (KD) is specified along with "//trim(cs%bkgnd_scheme_str))
   endif
 
   if (cs%Henyey_IGW_background) then
     call get_param(param_file, mdl, "HENYEY_N0_2OMEGA", cs%N0_2Omega, &
                   "The ratio of the typical Buoyancy frequency to twice "//&
                   "the Earth's rotation period, used with the Henyey "//&
                   "scaling from the mixing.", units="nondim", default=20.0)
     call get_param(param_file, mdl, "OMEGA", cs%omega, &
                  "The rotation rate of the earth.", units="s-1", &
                  default=7.2921e-5, scale=us%T_to_s)
   endif
 
   call get_param(param_file, mdl, "KD_TANH_LAT_FN", cs%Kd_tanh_lat_fn, &
                  "If true, use a tanh dependence of Kd_sfc on latitude, "//&
                  "like CM2.1/CM2M.  There is no physical justification "//&
                  "for this form, and it can not be used with "//&
                  "HENYEY_IGW_BACKGROUND.", default=.false.)
 
   if (cs%Kd_tanh_lat_fn) &
     call get_param(param_file, mdl, "KD_TANH_LAT_SCALE", cs%Kd_tanh_lat_scale, &
                  "A nondimensional scaling for the range ofdiffusivities "//&
                  "with KD_TANH_LAT_FN. Valid values are in the range of "//&
                  "-2 to 2; 0.4 reproduces CM2M.", units="nondim", default=0.0)
 
   if (cs%Henyey_IGW_background .and. cs%Kd_tanh_lat_fn) call mom_error(fatal, &
     "MOM_bkgnd_mixing: KD_TANH_LAT_FN can not be used with HENYEY_IGW_BACKGROUND.")
 
   cs%Kd_via_Kdml_bug = .false.
   if ((cs%Kd /= cs%Kdml) .and. .not.(cs%Kd_tanh_lat_fn .or. cs%bulkmixedlayer .or. &
                                      cs%Henyey_IGW_background .or. cs%Henyey_IGW_background_new .or. &
                                      cs%horiz_varying_background .or. cs%Bryan_Lewis_diffusivity)) then
     call get_param(param_file, mdl, "KD_BACKGROUND_VIA_KDML_BUG", cs%Kd_via_Kdml_bug, &
                  "If true and KDML /= KD and several other conditions apply, the background "//&
                  "diffusivity is set incorrectly using a bug that was introduced in March, 2018.", &
                  default=.true.)  ! The default should be changed to false and this parameter obsoleted.
   endif
 
 !  call closeParameterBlock(param_file)
 

◆ calculate_bkgnd_mixing()

subroutine, public mom_bkgnd_mixing::calculate_bkgnd_mixing	(	real, dimension( g %isd: g %ied, g %jsd: g %jed, gv %ke), intent(in)	h,
		type(thermo_var_ptrs), intent(in)	tv,
		real, dimension( g %isd: g %ied, gv %ke), intent(in)	N2_lay,
		real, dimension( g %isd: g %ied, gv %ke), intent(out)	Kd_lay,
		real, dimension( g %isd: g %ied, gv %ke+1), intent(out)	Kd_int,
		real, dimension( g %isd: g %ied, gv %ke+1), intent(out)	Kv_bkgnd,
		integer, intent(in)	j,
		type(ocean_grid_type), intent(in)	G,
		type(verticalgrid_type), intent(in)	GV,
		type(unit_scale_type), intent(in)	US,
		type(bkgnd_mixing_cs), pointer	CS
	)

Calculates the vertical background diffusivities/viscosities.

Parameters

[in]	g	Grid structure.
[in]	gv	Vertical grid structure.
[in]	h	Layer thickness [H ~> m or kg m-2].
[in]	tv	Thermodynamics structure.
[in]	n2_lay	squared buoyancy frequency associated with layers [T-2 ~> s-2]
[out]	kd_lay	The background diapycnal diffusivity of each layer [Z2 T-1 ~> m2 s-1].
[out]	kd_int	The background diapycnal diffusivity of each interface [Z2 T-1 ~> m2 s-1].
[out]	kv_bkgnd	The background vertical viscosity at each interface [Z2 T-1 ~> m2 s-1]
[in]	j	Meridional grid index
[in]	us	A dimensional unit scaling type
	cs	The control structure returned by a previous call to bkgnd_mixing_init.

Definition at line 312 of file MOM_bkgnd_mixing.F90.

 
   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(in)    :: h   !< Layer thickness [H ~> m or kg m-2].
   type(thermo_var_ptrs),                     intent(in)    :: tv  !< Thermodynamics structure.
   real, dimension(SZI_(G),SZK_(GV)),         intent(in)    :: n2_lay !< squared buoyancy frequency associated
                                                                   !! with layers [T-2 ~> s-2]
   real, dimension(SZI_(G),SZK_(GV)),         intent(out)   :: kd_lay !< The background diapycnal diffusivity
                                                                   !! of each layer [Z2 T-1 ~> m2 s-1].
   real, dimension(SZI_(G),SZK_(GV)+1),       intent(out)   :: kd_int !< The background diapycnal diffusivity
                                                                   !! of each interface [Z2 T-1 ~> m2 s-1].
   real, dimension(SZI_(G),SZK_(GV)+1),       intent(out)   :: kv_bkgnd !< The background vertical viscosity at
                                                                   !! each interface [Z2 T-1 ~> m2 s-1]
   integer,                                   intent(in)    :: j   !< Meridional grid index
   type(unit_scale_type),                     intent(in)    :: us  !< A dimensional unit scaling type
   type(bkgnd_mixing_cs),                     pointer       :: cs  !< The control structure returned by
                                                                   !! a previous call to bkgnd_mixing_init.
 
   ! local variables
   real, dimension(SZK_(GV)+1) :: depth_int  !< Distance from surface of the interfaces [m]
   real, dimension(SZK_(GV)+1) :: kd_col     !< Diffusivities at the interfaces [m2 s-1]
   real, dimension(SZK_(GV)+1) :: kv_col     !< Viscosities at the interfaces [m2 s-1]
   real, dimension(SZI_(G))    :: kd_sfc     !< Surface value of the diffusivity [Z2 T-1 ~> m2 s-1]
   real, dimension(SZI_(G))    :: depth      !< Distance from surface of an interface [Z ~> m]
   real :: depth_c    !< depth of the center of a layer [Z ~> m]
   real :: i_hmix     !< inverse of fixed mixed layer thickness [Z-1 ~> m-1]
   real :: i_2omega   !< 1/(2 Omega) [T ~> s]
   real :: n_2omega   !  The ratio of the stratification to the Earth's rotation rate [nondim]
   real :: n02_n2     !  The ratio a reference stratification to the actual stratification [nondim]
   real :: i_x30      !< 2/acos(2) = 1/(sin(30 deg) * acosh(1/sin(30 deg)))
   real :: deg_to_rad !< factor converting degrees to radians, pi/180.
   real :: abs_sinlat !< absolute value of sine of latitude [nondim]
   real :: min_sinlat ! The minimum value of the sine of latitude [nondim]
   real :: bckgrnd_vdc_psin !< PSI diffusivity in northern hemisphere [Z2 T-1 ~> m2 s-1]
   real :: bckgrnd_vdc_psis !< PSI diffusivity in southern hemisphere [Z2 T-1 ~> m2 s-1]
   integer :: i, k, is, ie, js, je, nz
 
   is  = g%isc ; ie  = g%iec ; js  = g%jsc ; je  = g%jec ; nz = g%ke
 
   ! set some parameters
   deg_to_rad = atan(1.0)/45.0 ! = PI/180
   min_sinlat = 1.e-10
 
   ! Start with a constant value that may be replaced below.
   kd_lay(:,:) = cs%Kd
   kv_bkgnd(:,:) = 0.0
 
   ! Set up the background diffusivity.
   if (cs%Bryan_Lewis_diffusivity) then
 
     do i=is,ie
       depth_int(1) = 0.0
       do k=2,nz+1
         depth_int(k) = depth_int(k-1) + gv%H_to_m*h(i,j,k-1)
       enddo
 
       call cvmix_init_bkgnd(max_nlev=nz, &
                             zw = depth_int(:), &  !< interface depths relative to the surface in m, must be positive.
                             bl1 = cs%Bryan_Lewis_c1, &
                             bl2 = cs%Bryan_Lewis_c2, &
                             bl3 = cs%Bryan_Lewis_c3, &
                             bl4 = cs%Bryan_Lewis_c4, &
                             prandtl = cs%prandtl_bkgnd)
 
       kd_col(:) = 0.0 ; kv_col(:) = 0.0  ! Is this line necessary?
       call cvmix_coeffs_bkgnd(mdiff_out=kv_col, tdiff_out=kd_col, nlev=nz, max_nlev=nz)
 
       ! Update Kd and Kv.
       do k=1,nz+1
         kv_bkgnd(i,k) = us%m2_s_to_Z2_T*kv_col(k)
         kd_int(i,k) = us%m2_s_to_Z2_T*kd_col(k)
       enddo
       do k=1,nz
         kd_lay(i,k) = kd_lay(i,k) + 0.5 * us%m2_s_to_Z2_T * (kd_col(k) + kd_col(k+1))
       enddo
     enddo ! i loop
 
   elseif (cs%horiz_varying_background) then
     !### Note that there are lots of hard-coded parameters (mostly latitudes and longitudes) here.
     do i=is,ie
       bckgrnd_vdc_psis = cs%bckgrnd_vdc_psim * exp(-(0.4*(g%geoLatT(i,j)+28.9))**2)
       bckgrnd_vdc_psin = cs%bckgrnd_vdc_psim * exp(-(0.4*(g%geoLatT(i,j)-28.9))**2)
       kd_int(i,1) = (cs%bckgrnd_vdc_eq + bckgrnd_vdc_psin) + bckgrnd_vdc_psis
 
       if (g%geoLatT(i,j) < -10.0) then
         kd_int(i,1) = kd_int(i,1) + cs%bckgrnd_vdc1
       elseif (g%geoLatT(i,j) <= 10.0) then
         kd_int(i,1) = kd_int(i,1) + cs%bckgrnd_vdc1 * (g%geoLatT(i,j)/10.0)**2
       else
         kd_int(i,1) = kd_int(i,1) + cs%bckgrnd_vdc1
       endif
 
       ! North Banda Sea
       if ( (g%geoLatT(i,j) < -1.0)  .and. (g%geoLatT(i,j) > -4.0) .and. &
            ( mod(g%geoLonT(i,j)+360.0,360.0) > 103.0) .and. &
            ( mod(g%geoLonT(i,j)+360.0,360.0) < 134.0) ) then
         kd_int(i,1) = cs%bckgrnd_vdc_Banda
       endif
 
       ! Middle Banda Sea
       if ( (g%geoLatT(i,j) <= -4.0) .and. (g%geoLatT(i,j) > -7.0) .and. &
            ( mod(g%geoLonT(i,j)+360.0,360.0) > 106.0) .and. &
            ( mod(g%geoLonT(i,j)+360.0,360.0) < 140.0) ) then
         kd_int(i,1) = cs%bckgrnd_vdc_Banda
       endif
 
       ! South Banda Sea
       if ( (g%geoLatT(i,j) <= -7.0) .and. (g%geoLatT(i,j) > -8.3) .and. &
            ( mod(g%geoLonT(i,j)+360.0,360.0) > 111.0) .and. &
            ( mod(g%geoLonT(i,j)+360.0,360.0) < 142.0) ) then
         kd_int(i,1) = cs%bckgrnd_vdc_Banda
       endif
 
     enddo
     ! Update interior values of Kd and Kv (uniform profile; no interpolation needed)
     do k=1,nz+1 ; do i=is,ie
       kd_int(i,k) = kd_int(i,1)
       kv_bkgnd(i,k) = kd_int(i,1) * cs%prandtl_bkgnd
     enddo ; enddo
     do k=1,nz ; do i=is,ie
       kd_lay(i,k) = kd_int(i,1)
     enddo ; enddo
 
   elseif (cs%Henyey_IGW_background_new) then
     i_x30 = 2.0 / invcosh(cs%N0_2Omega*2.0) ! This is evaluated at 30 deg.
     i_2omega = 0.5 / cs%omega
     do k=1,nz ; do i=is,ie
       abs_sinlat = max(min_sinlat, abs(sin(g%geoLatT(i,j)*deg_to_rad)))
       n_2omega = max(abs_sinlat, sqrt(n2_lay(i,k))*i_2omega)
       n02_n2 = (cs%N0_2Omega/n_2omega)**2
       kd_lay(i,k) = max(cs%Kd_min, cs%Kd * &
            ((abs_sinlat * invcosh(n_2omega/abs_sinlat)) * i_x30)*n02_n2)
     enddo ; enddo
     ! Update Kd_int and Kv_bkgnd, based on Kd_lay.  These might be just used for diagnostic purposes.
     do i=is,ie
       kd_int(i,1) = 0.0; kv_bkgnd(i,1) = 0.0
       kd_int(i,nz+1) = 0.0; kv_bkgnd(i,nz+1) = 0.0
     enddo
     do k=2,nz ; do i=is,ie
       kd_int(i,k) = 0.5*(kd_lay(i,k-1) + kd_lay(i,k))
       kv_bkgnd(i,k) = kd_int(i,k) * cs%prandtl_bkgnd
     enddo ; enddo
   else
     ! Set a potentially spatially varying surface value of diffusivity.
     if (cs%Henyey_IGW_background) then
       i_x30 = 2.0 / invcosh(cs%N0_2Omega*2.0) ! This is evaluated at 30 deg.
       do i=is,ie
         abs_sinlat = abs(sin(g%geoLatT(i,j)*deg_to_rad))
         kd_sfc(i) = max(cs%Kd_min, cs%Kd * &
              ((abs_sinlat * invcosh(cs%N0_2Omega / max(min_sinlat, abs_sinlat))) * i_x30) )
       enddo
     elseif (cs%Kd_tanh_lat_fn) then
       do i=is,ie
         !   The transition latitude and latitude range are hard-scaled here, since
         ! this is not really intended for wide-spread use, but rather for
         ! comparison with CM2M / CM2.1 settings.
         kd_sfc(i) = max(cs%Kd_min, cs%Kd * (1.0 + &
             cs%Kd_tanh_lat_scale * 0.5*tanh((abs(g%geoLatT(i,j)) - 35.0)/5.0) ))
       enddo
     else ! Use a spatially constant surface value.
       do i=is,ie
         kd_sfc(i) = cs%Kd
       enddo
     endif
 
     ! Now set background diffusivies based on these surface values, possibly with vertical structure.
     if ((.not.cs%bulkmixedlayer) .and. (cs%Kd /= cs%Kdml)) then
       ! This is a crude way to put in a diffusive boundary layer without an explicit boundary
       ! layer turbulence scheme.  It should not be used for any realistic ocean models.
       i_hmix = 1.0 / (cs%Hmix + gv%H_subroundoff*gv%H_to_Z)
       do i=is,ie ; depth(i) = 0.0 ; enddo
       do k=1,nz ; do i=is,ie
         depth_c = depth(i) + 0.5*gv%H_to_Z*h(i,j,k)
         if (cs%Kd_via_Kdml_bug) then
           ! These two lines should update Kd_lay, not Kd_int.  They were correctly working on the
           ! same variables until MOM6 commit 7a818716 (PR#750), which was added on March 26, 2018.
           if (depth_c <= cs%Hmix) then ; kd_int(i,k) = cs%Kdml
           elseif (depth_c >= 2.0*cs%Hmix) then ; kd_int(i,k) = kd_sfc(i)
           else
             kd_lay(i,k) = ((kd_sfc(i) - cs%Kdml) * i_hmix) * depth_c + (2.0*cs%Kdml - kd_sfc(i))
           endif
         else
           if (depth_c <= cs%Hmix) then ; kd_lay(i,k) = cs%Kdml
           elseif (depth_c >= 2.0*cs%Hmix) then ; kd_lay(i,k) = kd_sfc(i)
           else
             kd_lay(i,k) = ((kd_sfc(i) - cs%Kdml) * i_hmix) * depth_c + (2.0*cs%Kdml - kd_sfc(i))
           endif
         endif
 
         depth(i) = depth(i) + gv%H_to_Z*h(i,j,k)
       enddo ; enddo
 
     else ! There is no vertical structure to the background diffusivity.
       do k=1,nz ; do i=is,ie
         kd_lay(i,k) = kd_sfc(i)
       enddo ; enddo
     endif
 
     ! Update Kd_int and Kv_bkgnd, based on Kd_lay.  These might be just used for diagnostic purposes.
     do i=is,ie
       kd_int(i,1) = 0.0; kv_bkgnd(i,1) = 0.0
       kd_int(i,nz+1) = 0.0; kv_bkgnd(i,nz+1) = 0.0
     enddo
     do k=2,nz ; do i=is,ie
       kd_int(i,k) = 0.5*(kd_lay(i,k-1) + kd_lay(i,k))
       kv_bkgnd(i,k) = kd_int(i,k) * cs%prandtl_bkgnd
     enddo ; enddo
   endif
 

◆ check_bkgnd_scheme()

subroutine mom_bkgnd_mixing::check_bkgnd_scheme	(	type(bkgnd_mixing_cs), pointer	CS,
		character(len=*), intent(in)	str
	)

private

Sets CSbkgnd_scheme_str to check whether multiple background diffusivity schemes are activated. The string is also for error/log messages.

Parameters

	cs	Control structure
[in]	str	Background scheme identifier deducted from MOM_input parameters

Definition at line 536 of file MOM_bkgnd_mixing.F90.

   type(bkgnd_mixing_cs), pointer :: cs  !< Control structure
   character(len=*), intent(in)   :: str !< Background scheme identifier deducted from MOM_input
                                         !! parameters
 
   if (trim(cs%bkgnd_scheme_str)=="none") then
     cs%bkgnd_scheme_str = str
   else
     call mom_error(fatal, "set_diffusivity_init: Cannot activate both "//trim(str)//" and "//&
                    trim(cs%bkgnd_scheme_str)//".")
   endif
 

◆ cvmix_bkgnd_is_used()

logical function mom_bkgnd_mixing::cvmix_bkgnd_is_used ( type(param_file_type), intent(in) param_file )

private

Reads the parameter "USE_CVMix_BACKGROUND" and returns state. This function allows other modules to know whether this parameterization will be used without needing to duplicate the log entry.

Parameters

[in] param_file A structure to parse for run-time parameters

Definition at line 527 of file MOM_bkgnd_mixing.F90.

   type(param_file_type), intent(in) :: param_file !< A structure to parse for run-time parameters
   call get_param(param_file, mdl, "USE_CVMix_BACKGROUND", cvmix_bkgnd_is_used, &
                  default=.false., do_not_log = .true.)
 

Detailed Description

Data Types

Functions/Subroutines

Variables

Function/Subroutine Documentation

◆ bkgnd_mixing_end()

◆ bkgnd_mixing_init()

◆ calculate_bkgnd_mixing()

◆ check_bkgnd_scheme()

◆ cvmix_bkgnd_is_used()