mom_cvmix_ddiff Module Reference

Detailed Description

Interface to CVMix double diffusion scheme.

Data Types
type	cvmix_ddiff_cs
	Control structure including parameters for CVMix double diffusion. More...
character(len=40)	mdl = "MOM_CVMix_ddiff"
	This module's name.
logical function, public	cvmix_ddiff_init (Time, G, GV, US, param_file, diag, CS)
	Initialized the CVMix double diffusion module. More...
subroutine, public	compute_ddiff_coeffs (h, tv, G, GV, US, j, Kd_T, Kd_S, CS)
	Subroutine for computing vertical diffusion coefficients for the double diffusion mixing parameterization. More...
logical function, public	cvmix_ddiff_is_used (param_file)
	Reads the parameter "USE_CVMIX_DDIFF" 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_ddiff_end (CS)
	Clear pointers and dealocate memory. More...

Function/Subroutine Documentation

compute_ddiff_coeffs()

subroutine, public mom_cvmix_ddiff::compute_ddiff_coeffs	(	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,
		integer, intent(in)	j,
		real, dimension( g %isd: g %ied, g %jsd: g %jed, g %ke+1), intent(out)	Kd_T,
		real, dimension( g %isd: g %ied, g %jsd: g %jed, g %ke+1), intent(out)	Kd_S,
		type(cvmix_ddiff_cs), pointer	CS
	)

Subroutine for computing vertical diffusion coefficients for the double diffusion mixing parameterization.

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.
[out]	kd_t	Interface double diffusion diapycnal diffusivity for temp [Z2 T-1 ~> m2 s-1].
[out]	kd_s	Interface double diffusion diapycnal diffusivity for salt [Z2 T-1 ~> m2 s-1].
	cs	The control structure returned by a previous call to CVMix_ddiff_init.
[in]	j	Meridional grid indice.

Definition at line 166 of file MOM_CVMix_ddiff.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),SZJ_(G),SZK_(G)+1), intent(out) :: Kd_T !< Interface double diffusion diapycnal
                                                                  !! diffusivity for temp [Z2 T-1 ~> m2 s-1].
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)+1), intent(out) :: Kd_S !< Interface double diffusion diapycnal
                                                                  !! diffusivity for salt [Z2 T-1 ~> m2 s-1].
  type(CVMix_ddiff_cs),                       pointer     :: CS   !< The control structure returned
                                                                  !! by a previous call to CVMix_ddiff_init.
  integer,                                    intent(in)  :: j    !< Meridional grid indice.
  ! Local variables
  real, dimension(SZK_(G)) :: &
    cellHeight, &  !< Height of cell centers [m]
    dRho_dT,    &  !< partial derivatives of density wrt temp [kg m-3 degC-1]
    dRho_dS,    &  !< partial derivatives of density wrt saln [kg m-3 ppt-1]
    pres_int,   &  !< pressure at each interface [Pa]
    temp_int,   &  !< temp and at interfaces [degC]
    salt_int,   &  !< salt at at interfaces [ppt]
    alpha_dT,   &  !< alpha*dT across interfaces
    beta_dS,    &  !< beta*dS across interfaces
    dT,         &  !< temp. difference between adjacent layers [degC]
    dS             !< salt difference between adjacent layers [ppt]
  real, dimension(SZK_(G)+1) :: &
    Kd1_T,      &  !< Diapycanal diffusivity of temperature [m2 s-1].
    Kd1_S          !< Diapycanal diffusivity of salinity [m2 s-1].
 
  real, dimension(SZK_(G)+1) :: iFaceHeight !< Height of interfaces [m]
  integer :: kOBL                        !< level of OBL extent
  real :: pref, g_o_rho0, rhok, rhokm1, dz, dh, hcorr
  integer :: i, k
 
  ! initialize dummy variables
  pres_int(:) = 0.0; temp_int(:) = 0.0; salt_int(:) = 0.0
  alpha_dt(:) = 0.0; beta_ds(:) = 0.0; drho_dt(:) = 0.0
  drho_ds(:) = 0.0; dt(:) = 0.0; ds(:) = 0.0
 
 
  ! GMM, I am leaving some code commented below. We need to pass BLD to
  ! this soubroutine to avoid adding diffusivity above that. This needs
  ! to be done once we re-structure the order of the calls.
  !if (.not. associated(hbl)) then
  !  allocate(hbl(SZI_(G), SZJ_(G)));
  !  hbl(:,:) = 0.0
  !endif
 
  do i = g%isc, g%iec
 
    ! skip calling at land points
    if (g%mask2dT(i,j) == 0.) cycle
 
    pref = 0.
    pres_int(1) = pref
    ! we don't have SST and SSS, so let's use values at top-most layer
    temp_int(1) = tv%T(i,j,1); salt_int(1) = tv%S(i,j,1)
    do k=2,g%ke
      ! pressure at interface
      pres_int(k) = pref + gv%H_to_Pa * h(i,j,k-1)
      ! temp and salt at interface
      ! for temp: (t1*h1 + t2*h2)/(h1+h2)
      temp_int(k) = (tv%T(i,j,k-1)*h(i,j,k-1) + tv%T(i,j,k)*h(i,j,k))/(h(i,j,k-1)+h(i,j,k))
      salt_int(k) = (tv%S(i,j,k-1)*h(i,j,k-1) + tv%S(i,j,k)*h(i,j,k))/(h(i,j,k-1)+h(i,j,k))
      ! dT and dS
      dt(k) = (tv%T(i,j,k-1)-tv%T(i,j,k))
      ds(k) = (tv%S(i,j,k-1)-tv%S(i,j,k))
      pref = pref + gv%H_to_Pa * h(i,j,k-1)
    enddo ! k-loop finishes
 
    call calculate_density_derivs(temp_int(:), salt_int(:), pres_int(:), drho_dt(:), drho_ds(:), 1, &
                                  g%ke, tv%EQN_OF_STATE)
 
    ! The "-1.0" below is needed so that the following criteria is satisfied:
    ! if ((alpha_dT > beta_dS) .and. (beta_dS > 0.0)) then "salt finger"
    ! if ((alpha_dT < 0.) .and. (beta_dS < 0.) .and. (alpha_dT > beta_dS)) then "diffusive convection"
    do k=1,g%ke
      alpha_dt(k) = -1.0*drho_dt(k) * dt(k)
      beta_ds(k)  = drho_ds(k) * ds(k)
    enddo
 
    if (cs%id_R_rho > 0.0)  then
      do k=1,g%ke
        cs%R_rho(i,j,k) = alpha_dt(k)/beta_ds(k)
        ! avoid NaN's
        if(cs%R_rho(i,j,k) /= cs%R_rho(i,j,k)) cs%R_rho(i,j,k) = 0.0
      enddo
    endif
 
    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))
 
    kd1_t(:) = 0.0 ; kd1_s(:) = 0.0
    call cvmix_coeffs_ddiff(tdiff_out=kd1_t(:), &
                            sdiff_out=kd1_s(:), &
                            strat_param_num=alpha_dt(:), &
                            strat_param_denom=beta_ds(:), &
                            nlev=g%ke,    &
                            max_nlev=g%ke)
    do k=1,g%ke+1
      kd_t(i,j,k) = us%m2_s_to_Z2_T * kd1_t(k)
      kd_s(i,j,k) = us%m2_s_to_Z2_T * kd1_s(k)
    enddo
 
    ! Do not apply mixing due to convection within the boundary layer
    !do k=1,kOBL
    !  Kd_T(i,j,k) = 0.0
    !  Kd_S(i,j,k) = 0.0
    !enddo
 
  enddo ! i-loop
 

cvmix_ddiff_end()

subroutine, public mom_cvmix_ddiff::cvmix_ddiff_end

(

type(cvmix_ddiff_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 304 of file MOM_CVMix_ddiff.F90.

  type(CVMix_ddiff_cs), pointer :: CS !< Control structure for this module that
                                      !! will be deallocated in this subroutine
 
  deallocate(cs)
 

cvmix_ddiff_init()

logical function, public mom_cvmix_ddiff::cvmix_ddiff_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_ddiff_cs), pointer	CS
	)

Initialized the CVMix double diffusion module.

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 62 of file MOM_CVMix_ddiff.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_ddiff_cs),    pointer       :: CS         !< This module's control structure.
 
! This include declares and sets the variable "version".
#include "version_variable.h"
 
  if (associated(cs)) then
    call mom_error(warning, "CVMix_ddiff_init called with an associated "// &
                            "control structure.")
    return
  endif
  allocate(cs)
 
  ! Read parameters
  call log_version(param_file, mdl, version, &
    "Parameterization of mixing due to double diffusion processes via CVMix")
  call get_param(param_file, mdl, "USE_CVMIX_DDIFF", cvmix_ddiff_init, &
                 "If true, turns on double diffusive processes via CVMix. "//&
                 "Note that double diffusive processes on viscosity are ignored "//&
                 "in CVMix, see http://cvmix.github.io/ for justification.", &
                 default=.false.)
 
  if (.not. cvmix_ddiff_init) return
 
  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_DDIFF')
 
  call get_param(param_file, mdl, "STRAT_PARAM_MAX", cs%strat_param_max, &
                 "The maximum value for the double dissusion stratification parameter", &
                 units="nondim", default=2.55)
 
  call get_param(param_file, mdl, "KAPPA_DDIFF_S", cs%kappa_ddiff_s, &
                 "Leading coefficient in formula for salt-fingering regime "//&
                 "for salinity diffusion.", units="m2 s-1", default=1.0e-4)
 
  call get_param(param_file, mdl, "DDIFF_EXP1", cs%ddiff_exp1, &
                 "Interior exponent in salt-fingering regime formula.", &
                 units="nondim", default=1.0)
 
  call get_param(param_file, mdl, "DDIFF_EXP2", cs%ddiff_exp2, &
                 "Exterior exponent in salt-fingering regime formula.", &
                 units="nondim", default=3.0)
 
  call get_param(param_file, mdl, "KAPPA_DDIFF_PARAM1", cs%kappa_ddiff_param1, &
                "Exterior coefficient in diffusive convection regime.", &
                 units="nondim", default=0.909)
 
  call get_param(param_file, mdl, "KAPPA_DDIFF_PARAM2", cs%kappa_ddiff_param2, &
                "Middle coefficient in diffusive convection regime.", &
                 units="nondim", default=4.6)
 
  call get_param(param_file, mdl, "KAPPA_DDIFF_PARAM3", cs%kappa_ddiff_param3, &
                "Interior coefficient in diffusive convection regime.", &
                 units="nondim", default=-0.54)
 
  call get_param(param_file, mdl, "MOL_DIFF", cs%mol_diff, &
                 "Molecular diffusivity used in CVMix double diffusion.", &
                 units="m2 s-1", default=1.5e-6)
 
  call get_param(param_file, mdl, "DIFF_CONV_TYPE", cs%diff_conv_type, &
                 "type of diffusive convection to use. Options are Marmorino \n" //&
                 "and Caldwell 1976 (MC76) and Kelley 1988, 1990 (K90).", &
                 default="MC76")
 
  call closeparameterblock(param_file)
 
  ! Register diagnostics
  cs%diag => diag
 
  cs%id_KT_extra = register_diag_field('ocean_model','KT_extra',diag%axesTi,time, &
         'Double-diffusive diffusivity for temperature', 'm2 s-1', conversion=us%Z2_T_to_m2_s)
 
  cs%id_KS_extra = register_diag_field('ocean_model','KS_extra',diag%axesTi,time, &
         'Double-diffusive diffusivity for salinity', 'm2 s-1', conversion=us%Z2_T_to_m2_s)
 
  cs%id_R_rho = register_diag_field('ocean_model','R_rho',diag%axesTi,time, &
         'Double-diffusion density ratio', 'nondim')
  if (cs%id_R_rho > 0) &
     allocate(cs%R_rho( szi_(g), szj_(g), szk_(g)+1)); cs%R_rho(:,:,:) = 0.0
 
  call cvmix_init_ddiff(strat_param_max=cs%strat_param_max,          &
                        kappa_ddiff_s=cs%kappa_ddiff_s,           &
                        ddiff_exp1=cs%ddiff_exp1,                 &
                        ddiff_exp2=cs%ddiff_exp2,                 &
                        mol_diff=cs%mol_diff,                     &
                        kappa_ddiff_param1=cs%kappa_ddiff_param1, &
                        kappa_ddiff_param2=cs%kappa_ddiff_param2, &
                        kappa_ddiff_param3=cs%kappa_ddiff_param3, &
                        diff_conv_type=cs%diff_conv_type)
 

cvmix_ddiff_is_used()

logical function, public mom_cvmix_ddiff::cvmix_ddiff_is_used

(

type(param_file_type), intent(in)

param_file

)

Reads the parameter "USE_CVMIX_DDIFF" 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 296 of file MOM_CVMix_ddiff.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_DDIFF", cvmix_ddiff_is_used, &
                 default=.false., do_not_log = .true.)