mom_cvmix_conv Module Reference

Detailed Description

Interface to CVMix convection scheme.

Data Types
type	cvmix_conv_cs
	Control structure including parameters for CVMix convection. More...
character(len=40)	mdl = "MOM_CVMix_conv"
	This module's name. More...
logical function, public	cvmix_conv_init (Time, G, GV, US, param_file, diag, CS)
	Initialized the CVMix convection mixing routine. More...
subroutine, public	calculate_cvmix_conv (h, tv, G, GV, US, CS, hbl)
	Subroutine for calculating enhanced diffusivity/viscosity due to convection via CVMix. More...
logical function, public	cvmix_conv_is_used (param_file)
	Reads the parameter "USE_CVMix_CONVECTION" 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, public	cvmix_conv_end (CS)
	Clear pointers and dealocate memory. More...

Function/Subroutine Documentation

calculate_cvmix_conv()

subroutine, public mom_cvmix_conv::calculate_cvmix_conv	(	real, dimension( g %isd: g %ied, g %jsd: g %jed, g %ke), intent(in)	h,
		type(thermo_var_ptrs), intent(in)	tv,
		type(ocean_grid_type), intent(in)	G,
		type(verticalgrid_type), intent(in)	GV,
		type(unit_scale_type), intent(in)	US,
		type(cvmix_conv_cs), pointer	CS,
		real, dimension(:,:), optional, pointer	hbl
	)

Subroutine for calculating enhanced diffusivity/viscosity due to convection via CVMix.

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.
	cs	The control structure returned by a previous call to CVMix_conv_init.
	hbl	Depth of ocean boundary layer [m]

Definition at line 151 of file MOM_CVMix_conv.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.
  type(CVMix_conv_cs),                            pointer :: CS !< The control structure returned
                                                                !! by a previous call to CVMix_conv_init.
  real, dimension(:,:),                 optional, pointer :: hbl!< Depth of ocean boundary layer [m]
  ! local variables
  real, dimension(SZK_(G)) :: rho_lwr !< Adiabatic Water Density, this is a dummy
                                      !! variable since here convection is always
                                      !! computed based on Brunt Vaisala.
  real, dimension(SZK_(G)) :: rho_1d  !< water density in a column, this is also
                                      !! a dummy variable, same reason as above.
  real, dimension(SZK_(G)+1) :: kv_col !< Viscosities at interfaces in the column [m2 s-1]
  real, dimension(SZK_(G)+1) :: kd_col !< Diffusivities at interfaces in the column [m2 s-1]
  real, dimension(SZK_(G)+1) :: iFaceHeight !< Height of interfaces [m]
  real, dimension(SZK_(G))   :: cellHeight  !< Height of cell centers [m]
  integer :: kOBL                        !< level of OBL extent
  real :: g_o_rho0  ! Gravitational acceleration divided by density in MKS units [m4 s-2]
  real :: pref, rhok, rhokm1, dz, dh, hcorr
  integer :: i, j, k
 
  g_o_rho0 = gv%mks_g_Earth / (us%R_to_kg_m3*gv%Rho0)
 
  ! initialize dummy variables
  rho_lwr(:) = 0.0; rho_1d(:) = 0.0
 
  if (.not. associated(hbl)) then
    allocate(hbl(szi_(g), szj_(g)))
    hbl(:,:) = 0.0
  endif
 
  do j = g%jsc, g%jec
    do i = g%isc, g%iec
 
      ! set N2 to zero at the top- and bottom-most interfaces
      cs%N2(i,j,1) = 0.
      cs%N2(i,j,g%ke+1) = 0.
 
      ! skip calling at land points
      !if (G%mask2dT(i,j) == 0.) cycle
 
      pref = 0.
      ! Compute Brunt-Vaisala frequency (static stability) on interfaces
      do k=2,g%ke
 
        ! pRef is pressure at interface between k and km1.
        pref = pref + gv%H_to_Pa * h(i,j,k)
        call calculate_density(tv%t(i,j,k), tv%s(i,j,k), pref, rhok, tv%eqn_of_state)
        call calculate_density(tv%t(i,j,k-1), tv%s(i,j,k-1), pref, rhokm1, tv%eqn_of_state)
 
        dz = ((0.5*(h(i,j,k-1) + h(i,j,k))+gv%H_subroundoff)*gv%H_to_m)
        cs%N2(i,j,k) = g_o_rho0 * (rhok - rhokm1) / dz ! Can be negative
 
      enddo
 
      ifaceheight(1) = 0.0 ! BBL is all relative to the surface
      hcorr = 0.0
      ! compute heights at cell center and interfaces
      do k=1,g%ke
        dh = h(i,j,k) * gv%H_to_m ! Nominal thickness to use for increment
        dh = dh + hcorr ! Take away the accumulated error (could temporarily make dh<0)
        hcorr = min( dh - cs%min_thickness, 0. ) ! If inflating then hcorr<0
        dh = max( dh, cs%min_thickness ) ! Limit increment dh>=min_thickness
        cellheight(k)    = ifaceheight(k) - 0.5 * dh
        ifaceheight(k+1) = ifaceheight(k) - dh
      enddo
 
      ! gets index of the level and interface above hbl
      kobl = cvmix_kpp_compute_kobl_depth(ifaceheight, cellheight,hbl(i,j))
 
      kv_col(:) = 0.0 ; kd_col(:) = 0.0
      call cvmix_coeffs_conv(mdiff_out=kv_col(:), &
                               tdiff_out=kd_col(:), &
                               nsqr=cs%N2(i,j,:), &
                               dens=rho_1d(:), &
                               dens_lwr=rho_lwr(:), &
                               nlev=g%ke,    &
                               max_nlev=g%ke, &
                               obl_ind=kobl)
 
      do k=1,g%ke+1
        cs%kv_conv(i,j,k) = us%m2_s_to_Z2_T * kv_col(k)
        cs%Kd_conv(i,j,k) = us%m2_s_to_Z2_T * kd_col(k)
      enddo
      ! Do not apply mixing due to convection within the boundary layer
      do k=1,kobl
        cs%kv_conv(i,j,k) = 0.0
        cs%kd_conv(i,j,k) = 0.0
      enddo
 
    enddo
  enddo
 
  if (cs%debug) then
    call hchksum(cs%N2, "MOM_CVMix_conv: N2",g%HI,haloshift=0)
    call hchksum(cs%kd_conv, "MOM_CVMix_conv: kd_conv",g%HI,haloshift=0,scale=us%Z2_T_to_m2_s)
    call hchksum(cs%kv_conv, "MOM_CVMix_conv: kv_conv",g%HI,haloshift=0,scale=us%m2_s_to_Z2_T)
  endif
 
  ! send diagnostics to post_data
  if (cs%id_N2 > 0) call post_data(cs%id_N2, cs%N2, cs%diag)
  if (cs%id_kd_conv > 0) call post_data(cs%id_kd_conv, cs%kd_conv, cs%diag)
  if (cs%id_kv_conv > 0) call post_data(cs%id_kv_conv, cs%kv_conv, cs%diag)
 

Referenced by mom_diabatic_driver::diabatic_ale(), mom_diabatic_driver::diabatic_ale_legacy(), and mom_diabatic_driver::layered_diabatic().

Here is the caller graph for this function:

cvmix_conv_end()

subroutine, public mom_cvmix_conv::cvmix_conv_end

(

type(cvmix_conv_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 272 of file MOM_CVMix_conv.F90.

  type(CVMix_conv_cs), pointer :: CS !< Control structure for this module that
                                     !! will be deallocated in this subroutine
 
  if (.not. associated(cs)) return
 
  deallocate(cs%N2)
  deallocate(cs%kd_conv)
  deallocate(cs%kv_conv)
  deallocate(cs)
 

Referenced by mom_diabatic_driver::diabatic_driver_end().

Here is the caller graph for this function:

cvmix_conv_init()

logical function, public mom_cvmix_conv::cvmix_conv_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(cvmix_conv_cs), pointer	CS
	)

Initialized the CVMix convection 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 56 of file MOM_CVMix_conv.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(CVMix_conv_cs),     pointer       :: CS         !< This module's control structure.
  ! Local variables
  real    :: prandtl_conv !< Turbulent Prandtl number used in convective instabilities.
  logical :: useEPBL      !< If True, use the ePBL boundary layer scheme.
 
! This include declares and sets the variable "version".
#include "version_variable.h"
 
  if (associated(cs)) then
    call mom_error(warning, "CVMix_conv_init called with an associated "// &
                            "control structure.")
    return
  endif
  allocate(cs)
 
  ! Read parameters
  call log_version(param_file, mdl, version, &
    "Parameterization of enhanced mixing due to convection via CVMix")
  call get_param(param_file, mdl, "USE_CVMix_CONVECTION", cvmix_conv_init, &
                 "If true, turns on the enhanced mixing due to convection "//&
                 "via CVMix. This scheme increases diapycnal diffs./viscs. "//&
                 "at statically unstable interfaces. Relevant parameters are "//&
                 "contained in the CVMix_CONVECTION% parameter block.", &
                 default=.false.)
 
  if (.not. cvmix_conv_init) return
 
  call get_param(param_file, mdl, "ENERGETICS_SFC_PBL", useepbl, default=.false., &
                do_not_log=.true.)
 
  ! Warn user if EPBL is being used, since in this case mixing due to convection will
  ! be aplied in the boundary layer
  if (useepbl) then
     call mom_error(warning, 'MOM_CVMix_conv_init: '// &
           'CVMix convection may not be properly applied when ENERGETICS_SFC_PBL = True'//&
           'as convective mixing might occur in the boundary layer.')
  endif
 
  call get_param(param_file, mdl, 'DEBUG', cs%debug, default=.false., do_not_log=.true.)
 
  call get_param(param_file, mdl, 'MIN_THICKNESS', cs%min_thickness, default=0.001, do_not_log=.true.)
 
  call openparameterblock(param_file,'CVMix_CONVECTION')
 
  call get_param(param_file, mdl, "PRANDTL_CONV", prandtl_conv, &
                 "The turbulent Prandtl number applied to convective "//&
                 "instabilities (i.e., used to convert KD_CONV into KV_CONV)", &
                 units="nondim", default=1.0)
 
  call get_param(param_file, mdl, 'KD_CONV', cs%kd_conv_const, &
                 "Diffusivity used in convective regime. Corresponding viscosity "//&
                 "(KV_CONV) will be set to KD_CONV * PRANDTL_TURB.", &
                 units='m2/s', default=1.00)
 
  call get_param(param_file, mdl, 'BV_SQR_CONV', cs%bv_sqr_conv, &
                 "Threshold for squared buoyancy frequency needed to trigger "//&
                 "Brunt-Vaisala parameterization.", &
                 units='1/s^2', default=0.0)
 
  call closeparameterblock(param_file)
 
  ! set kv_conv_const based on kd_conv_const and prandtl_conv
  cs%kv_conv_const = cs%kd_conv_const * prandtl_conv
 
  ! allocate arrays and set them to zero
  allocate(cs%N2(szi_(g), szj_(g), szk_(g)+1)); cs%N2(:,:,:) = 0.
  allocate(cs%kd_conv(szi_(g), szj_(g), szk_(g)+1)); cs%kd_conv(:,:,:) = 0.
  allocate(cs%kv_conv(szi_(g), szj_(g), szk_(g)+1)); cs%kv_conv(:,:,:) = 0.
 
  ! Register diagnostics
  cs%diag => diag
  cs%id_N2 = register_diag_field('ocean_model', 'N2_conv', diag%axesTi, time, &
      'Square of Brunt-Vaisala frequency used by MOM_CVMix_conv module', '1/s2')
  cs%id_kd_conv = register_diag_field('ocean_model', 'kd_conv', diag%axesTi, time, &
      'Additional diffusivity added by MOM_CVMix_conv module', 'm2/s', conversion=us%Z2_T_to_m2_s)
  cs%id_kv_conv = register_diag_field('ocean_model', 'kv_conv', diag%axesTi, time, &
      'Additional viscosity added by MOM_CVMix_conv module', 'm2/s', conversion=us%Z2_T_to_m2_s)
 
  call cvmix_init_conv(convect_diff=cs%kd_conv_const, &
                       convect_visc=cs%kv_conv_const, &
                       lbruntvaisala=.true.,    &
                       bvsqr_convect=cs%bv_sqr_conv)
 

References mdl, and mom_error_handler::mom_error().

Here is the call graph for this function:

cvmix_conv_is_used()

logical function, public mom_cvmix_conv::cvmix_conv_is_used

(

type(param_file_type), intent(in)

param_file

)

Reads the parameter "USE_CVMix_CONVECTION" 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 264 of file MOM_CVMix_conv.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_CONVECTION", cvmix_conv_is_used, &
                 default=.false., do_not_log = .true.)
 

References mdl.

Referenced by mom_set_visc::set_visc_register_restarts().

Here is the caller graph for this function:

Variable Documentation

mdl

character(len=40) mom_cvmix_conv::mdl = "MOM_CVMix_conv"

This module's name.

Definition at line 50 of file MOM_CVMix_conv.F90.

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

Referenced by cvmix_conv_init(), and cvmix_conv_is_used().