Data Types
type	diffconvection_cs

Functions/Subroutines
logical function, public	diffconvection_init (paramFile, G, diag, Time, CS)

subroutine, public	diffconvection_calculate (CS, G, GV, h, Temp, Salt, EOS, Kd_int)

subroutine, public	diffconvection_end (CS)

Variables
logical, parameter	verbose = .False.

Function/Subroutine Documentation

◆ diffconvection_calculate()

subroutine, public mom_diffconvection::diffconvection_calculate	(	type(diffconvection_cs), pointer	CS,
		type(ocean_grid_type), intent(in)	G,
		type(verticalgrid_type), intent(in)	GV,
		real, dimension(szi_(g),szj_(g),szk_(g)), intent(in)	h,
		real, dimension(szi_(g),szj_(g),szk_(g)), intent(in)	Temp,
		real, dimension(szi_(g),szj_(g),szk_(g)), intent(in)	Salt,
		type(eos_type), pointer	EOS,
		real, dimension(szi_(g),szj_(g),szk_(g)+1), intent(inout)	Kd_int
	)

Parameters

	cs	Control structure
[in]	g	Ocean grid
[in]	gv	Ocean vertical grid
[in]	h	Layer/level thicknesses (units of H)
[in]	temp	Pot. temperature (degrees C)
[in]	salt	Salinity (ppt)
	eos	Equation of state
[in,out]	kd_int	(in) Vertical diffusivity on interfaces (m2/s) (out) Modified vertical diffusivity (m2/s)

Definition at line 99 of file MOM_diffConvection.F90.

Referenced by mom_diabatic_driver::diabatic().

 !< Calculates diffusivity and non-local transport for KPP parameterization
 
 ! Arguments
   type(diffconvection_cs),                   pointer       :: cs    !< Control structure
   type(ocean_grid_type),                     intent(in)    :: g     !< Ocean grid
   type(verticalgrid_type),                   intent(in)    :: gv    !< Ocean vertical grid
   real, dimension(SZI_(G),SZJ_(G),SZK_(G)),  intent(in)    :: h     !< Layer/level thicknesses (units of H)
   real, dimension(SZI_(G),SZJ_(G),SZK_(G)),  intent(in)    :: temp  !< Pot. temperature (degrees C)
   real, dimension(SZI_(G),SZJ_(G),SZK_(G)),  intent(in)    :: salt  !< Salinity (ppt)
   type(eos_type),                            pointer       :: eos   !< Equation of state
   real, dimension(SZI_(G),SZJ_(G),SZK_(G)+1), intent(inout) :: kd_int !< (in) Vertical diffusivity on interfaces (m2/s)
                                                                  !! (out) Modified vertical diffusivity (m2/s)
 ! Local variables
   integer :: i, j, k
   real, dimension( G%ke+1 ) :: n2_1d ! Brunt-Vaisala frequency squared, at interfaces (1/s2)
   real, dimension( G%ke+1 ) :: kd_1d ! Vertical diffusivity at interfaces (m2/s)
   real :: gorho, pref, rhok, rhokm1
 
   gorho = gv%g_Earth / gv%Rho0
 
   n2_1d( 1 ) = 0.
   n2_1d( g%ke+1 ) = 0.
   kd_1d( 1 ) = 0.
   kd_1d( g%ke+1 ) = 0.
   do j=g%jsc,g%jec ; do i=g%isc,g%iec
     ! This k-loop calculates external quantities independent of any iterations
     ! Start at bottom of top level
     pref = 0. ! Ignore atmospheric pressure
     do k = 2, g%ke
       ! Pressure at interface K is incremented by mass of level above
       pref = pref + gv%g_Earth * gv%Rho0 * h(i,j,k-1) * gv%H_to_m ! Boussinesq approximation!!!! ?????
       ! Compute Brunt-Vaisala frequency (static stability) on interfaces
       call calculate_density(temp(i,j,k),   salt(i,j,k),   pref, rhok,   eos)
       call calculate_density(temp(i,j,k-1), salt(i,j,k-1), pref, rhokm1, eos)
       n2_1d(k) = gorho * (rhok - rhokm1) / &
               (0.5*(h(i,j,k-1) + h(i,j,k)) + gv%H_subroundoff) ! Can be negative
       kd_1d(k) = 0.
       if (n2_1d(k) < 0.) kd_1d(k) = cs%Kd_convection
     enddo ! k
 
     if (.not. cs%passiveMode) kd_int(i,j,:) = kd_int(i,j,:) + kd_1d(:)
 
     if (cs%id_N2 > 0) cs%N2(i,j,:) = n2_1d(:)
     if (cs%id_Kd_conv > 0) cs%Kd_conv(i,j,:) = kd_1d(:)
 
   enddo ; enddo ! j
 
   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)
 

Here is the caller graph for this function:

◆ diffconvection_end()

subroutine, public mom_diffconvection::diffconvection_end ( type(diffconvection_cs), pointer CS )

Definition at line 153 of file MOM_diffConvection.F90.

Referenced by mom_diabatic_driver::diabatic_driver_end().

 ! Clear pointers, dealocate memory
   type(diffconvection_cs), pointer :: cs ! Control structure
 
   if (cs%id_N2 > 0) deallocate(cs%N2, cs%diag)
   if (cs%id_Kd_conv > 0) deallocate(cs%Kd_conv, cs%diag)
   deallocate(cs)

Here is the caller graph for this function:

◆ diffconvection_init()

logical function, public mom_diffconvection::diffconvection_init	(	type(param_file_type), intent(in)	paramFile,
		type(ocean_grid_type), intent(in)	G,
		type(diag_ctrl), intent(in), target	diag,
		type(time_type), intent(in)	Time,
		type(diffconvection_cs), pointer	CS
	)

Parameters

[in]	paramfile	File parser
[in]	g	Ocean grid
[in]	diag	Diagnostics
	cs	Control structure

Definition at line 42 of file MOM_diffConvection.F90.

References mom_file_parser::closeparameterblock(), mom_error_handler::mom_error(), mom_file_parser::openparameterblock(), and mom_diag_mediator::register_diag_field().

 !< Initialize the CVmix KPP module and set up diagnostics
 !! Returns True if module is to be used, otherwise returns False.
 
 ! Arguments
   type(param_file_type),   intent(in)    :: paramfile !< File parser
   type(ocean_grid_type),   intent(in)    :: g         !< Ocean grid
   type(diag_ctrl), target, intent(in)    :: diag      !< Diagnostics
   type(time_type),         intent(in)    :: time      !< Time
   type(diffconvection_cs), pointer       :: cs        !< Control structure
 ! Local variables
 #include "version_variable.h"
   character(len=40) :: mdl = 'MOM_diffConvection' ! This module's name.
 
   if (associated(cs)) call mom_error(fatal, 'MOM_diffConvection, diffConvection_init: '// &
            'Control structure has already been initialized')
   allocate(cs)
 
 ! Read parameters
   call log_version(paramfile, mdl, version, &
             'This module implements enhanced diffusivity as a\n' // &
             'function of static stability, N^2.')
   call get_param(paramfile, mdl, "USE_CONVECTION", diffconvection_init, &
                  "If true, turns on the diffusive convection scheme that\n"// &
                  "increases diapycnal diffusivities at statically unstable\n"// &
                  "interfaces. Relevant parameters are contained in the\n"// &
                  "CONVECTION% parameter block.", &
                  default=.false.)
 
   call openparameterblock(paramfile,'CONVECTION')
   call get_param(paramfile, mdl, 'PASSIVE', cs%passiveMode,           &
                  'If True, puts KPP into a passive-diagnostic mode.', &
                  default=.false.)
   call get_param(paramfile, mdl, 'KD_CONV', cs%Kd_convection,                  &
                  'DIffusivity used in statically unstable regions of column.', &
                  units='m2/s', default=1.00)
   call closeparameterblock(paramfile)
   call get_param(paramfile, mdl, 'DEBUG', cs%debug, default=.false., do_not_log=.true.)
 
 ! Forego remainder of initialization if not using this scheme
   if (.not. diffconvection_init) return
 
 ! Register diagnostics
   cs%diag => diag
   cs%id_N2 = register_diag_field('ocean_model', 'Conv_N2', diag%axesTi, time, &
       'Square of Brunt-Vaisala frequency used by diffConvection module', '1/s2')
   if (cs%id_N2 > 0) allocate( cs%N2( szi_(g), szj_(g), szk_(g)+1 ) )
   cs%id_Kd_conv = register_diag_field('ocean_model', 'Conv_Kd', diag%axesTi, time, &
       'Additional diffusivity added by diffConvection module', 'm2/s')
   if (cs%id_Kd_conv > 0) allocate( cs%Kd_conv( szi_(g), szj_(g), szk_(g)+1 ) )
 
   if (cs%id_N2 > 0) cs%N2(:,:,:) = 0.
   if (cs%id_Kd_conv > 0) cs%Kd_conv(:,:,:) = 0.
 

Here is the call graph for this function:

Variable Documentation

◆ verbose

logical, parameter mom_diffconvection::verbose = .False.

Definition at line 37 of file MOM_diffConvection.F90.

37 logical, parameter :: verbose = .false.

Data Types