#include <ERF_TurbStruct.H>

Collaboration diagram for TurbChoice:

[legend]

Public Member Functions
void	init_params (int lev, int max_level, std::string pp_prefix)

void	check_params (amrex::GpuArray< ERF_BC, AMREX_SPACEDIM *2 > &phys_bc_type)

void	display (int lev)

Public Attributes
LESType	les_type

amrex::Real	Pr_t = one / three

amrex::Real	Pr_t_inv = three

amrex::Real	Sc_t = one

amrex::Real	Sc_t_inv = one

amrex::Real	Cs = zero

bool	smag2d = false

amrex::Real	Ce = amrex::Real(0.93)

amrex::Real	Ce_wall = zero

amrex::Real	Ck = amrex::Real(0.1)

amrex::Real	Cmu0 = amrex::Real(0.5562)

amrex::Real	Cb = amrex::Real(0.35)

amrex::Real	Rt_crit = -one

amrex::Real	Rt_min = -three

amrex::Real	l_g_max = amrex::Real(30.0)

amrex::Real	sigma_k = amrex::Real(0.5)

amrex::Real	theta_ref = zero

StratType	strat_type = StratType::theta

bool	mix_isotropic = true

bool	use_Ri_correction = true

amrex::Real	Ri_crit = fourth

RANSType	rans_type

bool	dirichlet_k = false

PBLType	pbl_type

MYNNLevel25	pbl_mynn

MYNNLevel2	pbl_mynn_level2

bool	use_kturb = false

bool	use_keqn

bool	use_pbl_tke

bool	use_tke = false

bool	init_tke_from_ustar = false

amrex::Real	pbl_ysu_coriolis_freq

bool	pbl_ysu_use_consistent_coriolis

bool	pbl_ysu_force_over_water

amrex::Real	pbl_ysu_land_Ribcr

amrex::Real	pbl_ysu_unst_Ribcr

amrex::Real	pbl_mrf_coriolis_freq = amrex::Real(1.0e-4)

amrex::Real	pbl_mrf_Ribcr = amrex::Real(0.5)

amrex::Real	pbl_mrf_const_b = amrex::Real(7.8)

amrex::Real	pbl_mrf_sf = amrex::Real(0.1)

bool	mrf_moistvars = false

bool	advect_tke = true

bool	diffuse_tke_3D = true

Detailed Description

Container holding quantities related to turbulence parametrizations

Member Function Documentation

◆ check_params()

void TurbChoice::check_params ( amrex::GpuArray< ERF_BC, AMREX_SPACEDIM *2 > & phys_bc_type )

inline

   {
       // BC compatibility
       if ( ( (pbl_type == PBLType::MYNN25)   ||
              (pbl_type == PBLType::MYNNEDMF) ||
              (pbl_type == PBLType::YSU) ||
              (pbl_type == PBLType::MRF)
                  ) &&
           phys_bc_type[amrex::Orientation(amrex::Direction::z,amrex::Orientation::low)] != ERF_BC::surface_layer ) {
           amrex::Abort("MYNN2.5/MYNNEDMF/YSU/MRF PBL Model requires MOST at lower boundary");
       }
       if ( (les_type == LESType::Deardorff) && (Ce_wall > 0) &&
            (phys_bc_type[amrex::Orientation(amrex::Direction::z,amrex::Orientation::low)] != ERF_BC::surface_layer) &&
            (phys_bc_type[amrex::Orientation(amrex::Direction::z,amrex::Orientation::low)] != ERF_BC::slip_wall) &&
            (phys_bc_type[amrex::Orientation(amrex::Direction::z,amrex::Orientation::low)] != ERF_BC::no_slip_wall) )
       {
           amrex::Warning("Deardorff LES assumes wall at zlo when applying Ce_wall");
       }
   }

◆ display()

void TurbChoice::display ( int lev )

inline

   {
     amrex::Print() << "Turbulence Settings at level " << lev << std::endl;
  
     if (
       les_type == LESType::None && rans_type == RANSType::None &&
       pbl_type == PBLType::None) {
       amrex::Print() << "    Using DNS model at level " << lev << std::endl;
     } else if (les_type == LESType::Smagorinsky) {
       if (smag2d) {
         amrex::Print() << "    Using 2D Smagorinsky LES model at level " << lev << std::endl;
       } else {
         amrex::Print() << "    Using Smagorinsky LES model at level " << lev << std::endl;
       }
       if (use_Ri_correction) {
         amrex::Print() << "    Smagorinsky uses Richardson number correction with Ri_crit = "
                        << Ri_crit << std::endl;
       }
     } else if (les_type == LESType::Deardorff) {
       amrex::Print() << "    Using Deardorff LES model at level " << lev << std::endl;
     } else if (rans_type == RANSType::kEqn) {
       amrex::Print()
         << "    Using Axell & Liungman one-equation RANS k model at level " << lev
         << std::endl;
     } else if (pbl_type == PBLType::MYJ) {
       amrex::Print() << "    Using MYJ PBL model at level " << lev << std::endl;
     } else if (pbl_type == PBLType::MYNN25) {
       amrex::Print() << "    Using MYNN2.5 PBL model at level " << lev << std::endl;
     } else if (pbl_type == PBLType::MYNNEDMF) {
       amrex::Print() << "    Using MYNNEDMF PBL model at level " << lev << std::endl;
     } else if (pbl_type == PBLType::YSU) {
       amrex::Print() << "    Using YSU PBL model at level " << lev << std::endl;
     } else if (pbl_type == PBLType::MRF) {
       amrex::Print() << "    Using MRF PBL model at level " << lev << std::endl;
     } else {
       amrex::Error("Unknown turbulence model");
     }
  
     if (les_type != LESType::None) {
       if (les_type == LESType::Smagorinsky) {
         amrex::Print() << "    Cs                      : " << Cs << std::endl;
       }
       if (les_type == LESType::Deardorff) {
         amrex::Print() << "    Ce                      : " << Ce      << std::endl;
         amrex::Print() << "    Ce at wall              : " << Ce_wall << std::endl;
         amrex::Print() << "    Ck                      : " << Ck      << std::endl;
         amrex::Print() << "    sigma_k                 : " << sigma_k << std::endl;
  
         // Sullivan et al 1994, Eqn 14
         amrex::Real Cs_equiv = std::sqrt(Ck * std::sqrt(Ck / Ce));
         amrex::Print() << "    equivalent Cs           : " << Cs_equiv
                        << std::endl;
       }
       amrex::Print() << "    isotropic mixing        : " << mix_isotropic
                      << std::endl;
     }
  
     if (rans_type != RANSType::None) {
       if (rans_type == RANSType::kEqn) {
         amrex::Print() << "Cmu0                        : " << Cmu0 << std::endl;
         amrex::Print() << "sigma_k                     : " << sigma_k << std::endl;
         amrex::Print() << "Cb                          : " << Cb << std::endl;
         amrex::Print() << "Rt_crit                     : " << Rt_crit << std::endl;
         amrex::Print() << "Rt_min                      : " << Rt_min << std::endl;
         amrex::Print() << "max_geom_lscale             : " << l_g_max << std::endl;
       }
     }
  
     if ((les_type  == LESType::Deardorff) ||
         (rans_type == RANSType::kEqn)) {
       if (theta_ref > 0) {
         amrex::Print() << "    reference theta         : " << theta_ref << std::endl;
       } else {
         amrex::Print() << "    reference theta         : n/a" << std::endl;
       }
     }
  
     if ((les_type != LESType::None) || (rans_type != RANSType::None)) {
       amrex::Print() << "    Pr_t                    : " << Pr_t << std::endl;
       amrex::Print() << "    Sc_t                    : " << Sc_t << std::endl;
     }
  
     if (pbl_type == PBLType::MYNN25 || pbl_type == PBLType::MYNNEDMF) {
       amrex::Print() << "    pbl_mynn_A1 : " << pbl_mynn.A1 << std::endl;
       amrex::Print() << "    pbl_mynn_A2 : " << pbl_mynn.A2 << std::endl;
       amrex::Print() << "    pbl_mynn_B1 : " << pbl_mynn.B1 << std::endl;
       amrex::Print() << "    pbl_mynn_B2 : " << pbl_mynn.B2 << std::endl;
       amrex::Print() << "    pbl_mynn_C1 : " << pbl_mynn.C1 << std::endl;
       amrex::Print() << "    pbl_mynn_C2 : " << pbl_mynn.C2 << std::endl;
       amrex::Print() << "    pbl_mynn_C3 : " << pbl_mynn.C3 << std::endl;
       amrex::Print() << "    pbl_mynn_C4 : " << pbl_mynn.C4 << std::endl;
       amrex::Print() << "    pbl_mynn_C5 : " << pbl_mynn.C5 << std::endl;
     } else if (pbl_type == PBLType::YSU) {
       amrex::Print() << "    pbl_ysu_coriolis_freq           : "
                      << pbl_ysu_coriolis_freq << std::endl;
       amrex::Print() << "    pbl_ysu_use_consistent_coriolis : "
                      << pbl_ysu_use_consistent_coriolis << std::endl;
       amrex::Print() << "    pbl_ysu_force_over_water        : "
                      << pbl_ysu_force_over_water << std::endl;
       amrex::Print() << "    pbl_ysu_land_Ribcr              : "
                      << pbl_ysu_land_Ribcr << std::endl;
       amrex::Print() << "    pbl_ysu_unst_Ribcr              : "
                      << pbl_ysu_unst_Ribcr << std::endl;
     } else if (pbl_type == PBLType::MRF) {
       amrex::Print() << "    pbl_mrf_coriolis_freq : " << pbl_mrf_coriolis_freq
                      << std::endl;
       amrex::Print() << "    pbl_mrf_Ribcr         : " << pbl_mrf_Ribcr
                      << std::endl;
       amrex::Print() << "    pbl_mrf_const_b       : " << pbl_mrf_const_b
                      << std::endl;
       amrex::Print() << "    pbl_mrf_sf            : " << pbl_mrf_sf
                      << std::endl;
       amrex::Print() << "    mrf_moistvars         : " << mrf_moistvars
                      << std::endl;
     }
   }

◆ init_params()

void TurbChoice::init_params	(	int	lev,
		int	max_level,
		std::string	pp_prefix
	)

inline

   {
     amrex::ParmParse pp(pp_prefix);
  
     // Which LES closure?
     query_one_or_per_level(pp, "les_type", les_type, lev, max_level);
  
     // Handle 2-D Smag
     if (les_type == LESType::Smagorinsky2D) {
         les_type = LESType::Smagorinsky;
         smag2d = true;
     }
  
     // Which RANS closure?
     query_one_or_per_level(pp, "rans_type", rans_type, lev, max_level);
  
     if ((rans_type != RANSType::None) && (les_type != LESType::None)) {
         amrex::Error("Hybrid RANS-LES not implemented");
     }
  
     // Which PBL Closure
     query_one_or_per_level(pp, "pbl_type", pbl_type, lev, max_level);
  
     // Do some more stuff for PBL Modeling
     if (pbl_type != PBLType::None) {
       // Check for compatibility between PBL, LES, Molec Transport
       if (les_type != LESType::None) {
         amrex::Print() << "Selected a PBL model and an LES model: "
                        << "Using PBL for vertical transport, LES for horizontal"
                        << std::endl;
       }
       if (les_type == LESType::Smagorinsky) {
         if (!smag2d)
           amrex::Error("If using Smagorinsky with a PBL model, the 2-D "
                        "formulation should be used");
       } else if (les_type == LESType::Deardorff) {
         amrex::Error(
           "It is not recommended to use Deardorff LES and a PBL model");
       }
  
       if (pbl_type == PBLType::MYNN25 || pbl_type == PBLType::MYNNEDMF) {
         query_one_or_per_level(pp, "pbl_mynn_A1", pbl_mynn.A1, lev, max_level);
         query_one_or_per_level(pp, "pbl_mynn_A2", pbl_mynn.A2, lev, max_level);
         query_one_or_per_level(pp, "pbl_mynn_B1", pbl_mynn.B1, lev, max_level);
         query_one_or_per_level(pp, "pbl_mynn_B2", pbl_mynn.B2, lev, max_level);
         query_one_or_per_level(pp, "pbl_mynn_C1", pbl_mynn.C1, lev, max_level);
         query_one_or_per_level(pp, "pbl_mynn_C2", pbl_mynn.C2, lev, max_level);
         query_one_or_per_level(pp, "pbl_mynn_C3", pbl_mynn.C3, lev, max_level);
         query_one_or_per_level(pp, "pbl_mynn_C4", pbl_mynn.C4, lev, max_level);
         query_one_or_per_level(pp, "pbl_mynn_C5", pbl_mynn.C5, lev, max_level);
         pbl_mynn_level2.init_coeffs(
           pbl_mynn.A1, pbl_mynn.A2, pbl_mynn.B1, pbl_mynn.B2, pbl_mynn.C1,
           pbl_mynn.C2, pbl_mynn.C3, pbl_mynn.C4, pbl_mynn.C5);
         query_one_or_per_level(
           pp, "pbl_mynn_diffuse_moistvars", pbl_mynn.diffuse_moistvars, lev,
           max_level);
         query_one_or_per_level(
           pp, "pbl_mynn_SMmin", pbl_mynn.SMmin, lev, max_level);
         query_one_or_per_level(
           pp, "pbl_mynn_SMmax", pbl_mynn.SMmax, lev, max_level);
         query_one_or_per_level(
           pp, "pbl_mynn_SHmin", pbl_mynn.SHmin, lev, max_level);
         query_one_or_per_level(
           pp, "pbl_mynn_SHmax", pbl_mynn.SHmax, lev, max_level);
         query_one_or_per_level(
           pp, "pbl_mynn_SQfactor", pbl_mynn.SQfac, lev, max_level);
       } else if (pbl_type == PBLType::YSU) {
         query_one_or_per_level(
           pp, "pbl_ysu_coriolis_freq", pbl_ysu_coriolis_freq, lev, max_level);
         query_one_or_per_level(
           pp, "pbl_ysu_use_consistent_coriolis",
           pbl_ysu_use_consistent_coriolis, lev, max_level);
         query_one_or_per_level(
           pp, "pbl_ysu_force_over_water", pbl_ysu_force_over_water, lev,
           max_level);
         query_one_or_per_level(
           pp, "pbl_ysu_land_Ribcr", pbl_ysu_land_Ribcr, lev, max_level);
         query_one_or_per_level(
           pp, "pbl_ysu_unst_Ribcr", pbl_ysu_unst_Ribcr, lev, max_level);
       } else if (pbl_type == PBLType::MRF) {
         query_one_or_per_level(
           pp, "pbl_mrf_coriolis_freq", pbl_mrf_coriolis_freq, lev, max_level);
         query_one_or_per_level(
           pp, "pbl_mrf_Ribcr", pbl_mrf_Ribcr, lev, max_level);
         query_one_or_per_level(
           pp, "pbl_mrf_const_b", pbl_mrf_const_b, lev, max_level);
         query_one_or_per_level(pp, "pbl_mrf_sf", pbl_mrf_sf, lev, max_level);
         query_one_or_per_level(
           pp, "mrf_moistvars", mrf_moistvars, lev, max_level);
       } else if (pbl_type == PBLType::SHOC) {
 #ifndef ERF_USE_SHOC
           amrex::Abort("You set use_shoc to true but didn't build with SHOC; you must rebuild the executable");
 #endif
           std::string zlo_bc = "none";
           amrex::ParmParse pp_bc("zlo");
           pp_bc.get("type",zlo_bc);
           if (amrex::toLower(zlo_bc) != "surface_layer") {
                amrex::Abort("You must use the surface_layer BC at zlo with SHOC.");
           }
       }
     }
  
     // Flags for QKE/TKE equation
     if (pbl_type == PBLType::MYJ || pbl_type == PBLType::MYNN25 || pbl_type == PBLType::MYNNEDMF) {
         // Add sources/sinks to QKE/TKE? (MYJ does this inline)
         if (pbl_type == PBLType::MYNN25 || pbl_type == PBLType::MYNNEDMF) {
             use_pbl_tke = true;
         }
         // Advect QKE/TKE?
         query_one_or_per_level(pp, "advect_tke"    , advect_tke    , lev, max_level);
         // Apply numerical diffusion to QKE/TKE?
         query_one_or_per_level(pp, "diffuse_tke_3D", diffuse_tke_3D, lev, max_level);
     }
  
     // LES constants...
     query_one_or_per_level(pp, "Cs", Cs, lev, max_level);
  
     query_one_or_per_level(pp, "Pr_t", Pr_t, lev, max_level);
     query_one_or_per_level(pp, "Sc_t", Sc_t, lev, max_level);
  
     // Compute relevant forms of diffusion parameters
     Pr_t_inv = one / Pr_t;
     Sc_t_inv = one / Sc_t;
  
     if (les_type == LESType::Deardorff) {
         query_one_or_per_level(pp, "Ck", Ck, lev, max_level);
         query_one_or_per_level(pp, "Ce", Ce, lev, max_level);
         query_one_or_per_level(pp, "Ce_wall", Ce_wall, lev, max_level);
     }
  
     // To quantify atmospheric stability for subgrid modeling
     query_one_or_per_level(pp, "thermal_stratification", strat_type, lev, max_level);
     if (strat_type == StratType::theta) {
         amrex::Print() << "Thermal stratification based on gradient of potential temperature" << std::endl;
     } else if (strat_type == StratType::thetav) {
         amrex::Print() << "Thermal stratification based on gradient of virtual potential temperature" << std::endl;
     } else if (strat_type == StratType::thetal) {
         amrex::Print() << "Thermal stratification based on gradient of linearized liquid-water potential temperature" << std::endl;
     }
  
     // k-eqn constants
     query_one_or_per_level(pp, "Cmu0", Cmu0, lev, max_level);
     query_one_or_per_level(pp, "Cb", Cb, lev, max_level);
     query_one_or_per_level(pp, "Rt_crit", Rt_crit, lev, max_level);
     query_one_or_per_level(pp, "Rt_min", Rt_min, lev, max_level);
     query_one_or_per_level(pp, "max_geom_lscale", l_g_max, lev, max_level);
     query_one_or_per_level(pp, "dirichlet_k", dirichlet_k, lev, max_level);
  
     // Common inputs (LES or RANS)
     if (!query_one_or_per_level(pp, "sigma_k", sigma_k, lev, max_level) && rans_type == RANSType::kEqn) {
         amrex::Print() << "Overriding default sigma_k for k-eqn RANS" << std::endl;
         sigma_k = one;
     };
     query_one_or_per_level(pp, "theta_ref", theta_ref, lev, max_level);
  
     query_one_or_per_level(pp, "mix_isotropic", mix_isotropic, lev, max_level);
     query_one_or_per_level(pp, "use_Ri_correction", use_Ri_correction, lev, max_level);
     query_one_or_per_level(pp, "Ri_crit", Ri_crit, lev, max_level);
  
     // Set common flags
     use_kturb =
       ((les_type != LESType::None) || (rans_type != RANSType::None) ||
        (pbl_type != PBLType::None));
     use_keqn =
       ((les_type == LESType::Deardorff) || (rans_type == RANSType::kEqn));
     use_tke =
       ((les_type == LESType::Deardorff) || (rans_type == RANSType::kEqn) ||
        (pbl_type == PBLType::MYJ)       || (pbl_type == PBLType::MYNN25) ||
        (pbl_type == PBLType::MYNNEDMF)  || (pbl_type == PBLType::SHOC));
  
     if (use_tke) {
         query_one_or_per_level(pp, "init_tke_from_ustar", init_tke_from_ustar, lev, max_level);
     }
  
     // Validate inputs
     if (les_type == LESType::Smagorinsky) {
       if (Cs == 0) {
         amrex::Error("Need to specify Cs for Smagorsinky LES");
       }
       if (smag2d && mix_isotropic) {
         amrex::Print() << "Turning off mix_isotropic for 2-D Smagorinsky" << std::endl;
         mix_isotropic = false;
       }
     }
   }