mom_bkgnd_mixing Module Reference

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	sfc_bkgnd_mixing (G, US, CS)
	Get surface vertical background diffusivities/viscosities. More...
subroutine, public	calculate_bkgnd_mixing (h, tv, N2_lay, Kd_lay, Kv, 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. More...

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 576 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%kd_bkgnd)
  deallocate(cs%kv_bkgnd)
  deallocate(cs)
 

Referenced by mom_set_diffusivity::set_diffusivity_end().

Here is the caller graph for this function:

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 119 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.", units="m2 s-1", scale=us%m2_s_to_Z2_T, fail_if_missing=.true.)
 
  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 by pass
  ! 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.")
 
!  call closeParameterBlock(param_file)
 
  ! allocate arrays and set them to zero
  allocate(cs%Kd_bkgnd(szi_(g), szj_(g), szk_(g)+1)); cs%kd_bkgnd(:,:,:) = 0.
  allocate(cs%kv_bkgnd(szi_(g), szj_(g), szk_(g)+1)); cs%kv_bkgnd(:,:,:) = 0.
  allocate(cs%Kd_sfc(szi_(g), szj_(g))); cs%Kd_sfc(:,:) = 0.
 
  ! Register diagnostics
  cs%diag => diag
  cs%id_kd_bkgnd = register_diag_field('ocean_model', 'Kd_bkgnd', diag%axesTi, time, &
      'Background diffusivity added by MOM_bkgnd_mixing module', 'm2/s', conversion=us%Z2_T_to_m2_s)
  cs%id_kv_bkgnd = register_diag_field('ocean_model', 'Kv_bkgnd', diag%axesTi, time, &
      'Background viscosity added by MOM_bkgnd_mixing module', 'm2/s', conversion=us%Z2_T_to_m2_s)
 

References check_bkgnd_scheme(), mdl, and mom_error_handler::mom_error().

Here is the call graph for this function:

calculate_bkgnd_mixing()

subroutine, public mom_bkgnd_mixing::calculate_bkgnd_mixing	(	real, dimension( g %isd: g %ied, g %jsd: g %jed, g %ke), intent(in)	h,
		type(thermo_var_ptrs), intent(in)	tv,
		real, dimension( g %isd: g %ied, g %ke), intent(in)	N2_lay,
		real, dimension( g %isd: g %ied, g %jsd: g %jed, g %ke), intent(inout)	Kd_lay,
		real, dimension(:,:,:), pointer	Kv,
		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]	us	A dimensional unit scaling type
[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]
[in,out]	kd_lay	Diapycnal diffusivity of each layer [Z2 T-1 ~> m2 s-1].
	kv	The "slow" vertical viscosity at each interface (not layer!) [Z2 T-1 ~> m2 s-1]
[in]	j	Meridional grid index
	cs	The control structure returned by a previous call to bkgnd_mixing_init.

Definition at line 376 of file MOM_bkgnd_mixing.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_(G)), 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_(G)),         intent(in)    :: N2_lay !< squared buoyancy frequency associated
                                                                 !! with layers [T-2 ~> s-2]
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)), intent(inout) :: Kd_lay !< Diapycnal diffusivity of each layer
                                                                 !! [Z2 T-1 ~> m2 s-1].
  real, dimension(:,:,:),                   pointer       :: Kv  !< The "slow" vertical viscosity at each interface
                                                                 !! (not layer!) [Z2 T-1 ~> m2 s-1]
  integer,                                  intent(in)    :: j   !< Meridional grid index
  type(bkgnd_mixing_cs),                    pointer       :: CS  !< The control structure returned by
                                                                 !! a previous call to bkgnd_mixing_init.
 
  ! local variables
  real, dimension(SZK_(G)+1) :: depth_int  !< distance from surface of the interfaces [m]
  real, dimension(SZK_(G)+1) :: Kd_col     !< Diffusivities at the interfaces [m2 s-1]
  real, dimension(SZK_(G)+1) :: Kv_col     !< Viscosities at the interfaces [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_sin    !< absolute value of sine of latitude [nondim]
  real :: epsilon    ! 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
  epsilon = 1.e-10
 
  ! 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
        cs%Kv_bkgnd(i,j,k) = us%m2_s_to_Z2_T*kv_col(k)
        cs%Kd_bkgnd(i,j,k) = us%m2_s_to_Z2_T*kd_col(k)
      enddo
      do k=1,nz
        kd_lay(i,j,k) = kd_lay(i,j,k) + 0.5 * us%m2_s_to_Z2_T * (kd_col(k) + kd_col(k+1))
      enddo
    enddo ! i loop
 
  elseif ((.not. cs%Bryan_Lewis_diffusivity) .and. (.not.cs%bulkmixedlayer) .and. &
          (.not. cs%horiz_varying_background) .and. (cs%Kd /= cs%Kdml)) then
    i_hmix = 1.0 / cs%Hmix
    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 (depth_c <= cs%Hmix) then ; cs%Kd_bkgnd(i,j,k) = cs%Kdml
      elseif (depth_c >= 2.0*cs%Hmix) then ; cs%Kd_bkgnd(i,j,k) = cs%Kd_sfc(i,j)
      else
        kd_lay(i,j,k) = ((cs%Kd_sfc(i,j) - cs%Kdml) * i_hmix) * depth_c + &
                        (2.0*cs%Kdml - cs%Kd_sfc(i,j))
      endif
 
      depth(i) = depth(i) + gv%H_to_Z*h(i,j,k)
    enddo ; enddo
 
  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)
      !### Add parentheses.
      cs%Kd_bkgnd(i,j,:) = cs%bckgrnd_vdc_eq + bckgrnd_vdc_psin + bckgrnd_vdc_psis
 
      if (g%geoLatT(i,j) < -10.0) then
        cs%Kd_bkgnd(i,j,:) = cs%Kd_bkgnd(i,j,:) + cs%bckgrnd_vdc1
      elseif (g%geoLatT(i,j) <= 10.0) then
        cs%Kd_bkgnd(i,j,:) = cs%Kd_bkgnd(i,j,:) + cs%bckgrnd_vdc1 * (g%geoLatT(i,j)/10.0)**2
      else
        cs%Kd_bkgnd(i,j,:) = cs%Kd_bkgnd(i,j,:) + 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
        cs%Kd_bkgnd(i,j,:) = 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
        cs%Kd_bkgnd(i,j,:) = 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
        cs%Kd_bkgnd(i,j,:) = cs%bckgrnd_vdc_Banda
      endif
 
      ! Compute kv_bkgnd
      cs%kv_bkgnd(i,j,:) = cs%Kd_bkgnd(i,j,:) * cs%prandtl_bkgnd
 
      ! Update Kd (uniform profile; no interpolation needed)
      kd_lay(i,j,:) = cs%Kd_bkgnd(i,j,1)
 
    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_sin = max(epsilon, abs(sin(g%geoLatT(i,j)*deg_to_rad)))
      n_2omega = max(abs_sin, sqrt(n2_lay(i,k))*i_2omega)
      n02_n2 = (cs%N0_2Omega/n_2omega)**2
      kd_lay(i,j,k) = max(cs%Kd_min, cs%Kd_sfc(i,j) * &
           ((abs_sin * invcosh(n_2omega/abs_sin)) * i_x30)*n02_n2)
    enddo ; enddo
 
  else
    do k=1,nz ; do i=is,ie
      kd_lay(i,j,k) = cs%Kd_sfc(i,j)
    enddo ; enddo
  endif
 
  ! Update CS%kd_bkgnd and CS%kv_bkgnd for diagnostic purposes
  if (.not. (cs%Bryan_Lewis_diffusivity .or. cs%horiz_varying_background)) then
    do i=is,ie
      cs%kd_bkgnd(i,j,1) = 0.0; cs%kv_bkgnd(i,j,1) = 0.0
      cs%kd_bkgnd(i,j,nz+1) = 0.0; cs%kv_bkgnd(i,j,nz+1) = 0.0
      do k=2,nz
        cs%Kd_bkgnd(i,j,k) = 0.5*(kd_lay(i,j,k-1) + kd_lay(i,j,k))
        cs%Kv_bkgnd(i,j,k) = cs%Kd_bkgnd(i,j,k) * cs%prandtl_bkgnd
      enddo
    enddo
  endif
 
  ! Update Kv
  if (associated(kv)) then
    do k=1,nz+1 ; do i=is,ie
      kv(i,j,k) = kv(i,j,k) + cs%Kv_bkgnd(i,j,k)
    enddo ; enddo
  endif
 
  ! TODO: In both CS%Bryan_Lewis_diffusivity and CS%horiz_varying_background, KV and KD at surface
  ! and bottom interfaces are set to be nonzero. Make sure this is not problematic.
 

References mom_intrinsic_functions::invcosh().

Here is the call graph for this function:

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

References mom_error_handler::mom_error().

Referenced by bkgnd_mixing_init().

Here is the call graph for this function:

Here is the caller graph for this function:

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

References mdl.

sfc_bkgnd_mixing()

subroutine, public mom_bkgnd_mixing::sfc_bkgnd_mixing	(	type(ocean_grid_type), intent(in)	G,
		type(unit_scale_type), intent(in)	US,
		type(bkgnd_mixing_cs), intent(inout), pointer	CS
	)

Get surface vertical background diffusivities/viscosities.

Parameters

[in]	g	Grid structure.
[in]	us	A dimensional unit scaling type
[in,out]	cs	The control structure returned by a previous call to bkgnd_mixing_init.

Definition at line 322 of file MOM_bkgnd_mixing.F90.

 
  type(ocean_grid_type),          intent(in)    :: G  !< Grid structure.
  type(unit_scale_type),          intent(in)    :: US !< A dimensional unit scaling type
  type(bkgnd_mixing_cs), pointer, intent(inout) :: CS !< The control structure returned by
                                                      !! a previous call to bkgnd_mixing_init.
  ! local variables
  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_sin    !< absolute value of sine of latitude [nondim]
  real :: epsilon
  integer :: i, j, k, is, ie, js, je
 
  is  = g%isc ; ie  = g%iec ; js  = g%jsc ; je  = g%jec
 
  ! set some parameters
  deg_to_rad = atan(1.0)/45.0 ! = PI/180
  epsilon = 1.e-10
 
 
  if (.not. (cs%Bryan_Lewis_diffusivity .or. cs%horiz_varying_background)) then
!$OMP parallel do default(none) shared(is,ie,js,je,CS)
    do j=js,je ; do i=is,ie
      cs%Kd_sfc(i,j) = cs%Kd
    enddo ; enddo
  endif
 
  if (cs%Henyey_IGW_background) then
    i_x30 = 2.0 / invcosh(cs%N0_2Omega*2.0) ! This is evaluated at 30 deg.
!$OMP parallel do default(none) &
!$OMP shared(is,ie,js,je,CS,G,deg_to_rad,epsilon,I_x30) &
!$OMP private(abs_sin)
    do j=js,je ; do i=is,ie
      abs_sin = abs(sin(g%geoLatT(i,j)*deg_to_rad))
      cs%Kd_sfc(i,j) = max(cs%Kd_min, cs%Kd_sfc(i,j) * &
           ((abs_sin * invcosh(cs%N0_2Omega/max(epsilon,abs_sin))) * i_x30) )
    enddo ; enddo
  elseif (cs%Kd_tanh_lat_fn) then
!$OMP parallel do default(none) shared(is,ie,js,je,CS,G)
    do j=js,je ; 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.
      cs%Kd_sfc(i,j) = max(cs%Kd_min, cs%Kd_sfc(i,j) * (1.0 + &
          cs%Kd_tanh_lat_scale * 0.5*tanh((abs(g%geoLatT(i,j)) - 35.0)/5.0) ))
    enddo ; enddo
  endif
 
  if (cs%debug) call hchksum(cs%Kd_sfc,"After sfc_bkgnd_mixing: Kd_sfc",g%HI,haloshift=0, scale=us%Z2_T_to_m2_s)
 

References mom_intrinsic_functions::invcosh().

Referenced by mom_set_diffusivity::set_diffusivity().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

mdl

character(len=40) mom_bkgnd_mixing::mdl = "MOM_bkgnd_mixing"

This module's name.

Definition at line 113 of file MOM_bkgnd_mixing.F90.

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

Referenced by bkgnd_mixing_init(), and cvmix_bkgnd_is_used().