#include <ERF_TurbStruct.H>

Collaboration diagram for TurbChoice:

[legend]

Public Member Functions
void	init_params (int lev, int max_level)

void	display (int lev)

Public Attributes
std::string	pp_prefix {"erf"}

LESType	les_type

amrex::Real	Pr_t = amrex::Real(1.0) / amrex::Real(3.0)

amrex::Real	Pr_t_inv = amrex::Real(3.0)

amrex::Real	Sc_t = 1.0

amrex::Real	Sc_t_inv = 1.0

amrex::Real	Cs = 0.0

amrex::Real	Ce = 0.93

amrex::Real	Ce_wall = 0.0

amrex::Real	Ck = 0.1

amrex::Real	Cmu0 = 0.5562

amrex::Real	Cb = 0.35

amrex::Real	Rt_crit = -1.0

amrex::Real	Rt_min = -3.0

amrex::Real	l_g_max = 1e99

amrex::Real	sigma_k = 0.5

amrex::Real	theta_ref = 300.0

RANSType	rans_type

PBLType	pbl_type

MYNNLevel25	pbl_mynn

MYNNLevel2	pbl_mynn_level2

amrex::Real	pbl_ysu_coriolis_freq = 1.0e-4

bool	pbl_ysu_use_consistent_coriolis = false

bool	pbl_ysu_force_over_water = false

amrex::Real	pbl_ysu_land_Ribcr = 0.25

amrex::Real	pbl_ysu_unst_Ribcr = 0.0

bool	use_KE = true

bool	diffuse_KE_3D = true

bool	advect_KE = true

Detailed Description

Container holding quantities related to turbulence parametrizations

Member Function Documentation

◆ 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) {
             amrex::Print() << "    Using Smagorinsky LES model at level " << lev << 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::MYNN25) {
             amrex::Print() << "    Using MYNN2.5 PBL model at level " << lev << std::endl;
         } else if  (pbl_type == PBLType::YSU) {
             amrex::Print() << "    Using YSU PBL model at level " << lev << std::endl;
         }
  
         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;
                 amrex::Print() << "reference theta             : " << theta_ref << 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;
             }
         }
  
         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;
                 amrex::Print() << "reference theta             : " << theta_ref << 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) {
             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;
         }
     }

◆ init_params()

void TurbChoice::init_params	(	int	lev,
		int	max_level
	)

inline

     {
         amrex::ParmParse pp(pp_prefix);
  
         // Which LES closure?
         std::string les_type_string = "None";
         query_one_or_per_level(pp, "les_type", les_type, lev, max_level);
  
         // Which RANS closure?
         std::string rans_type_string = "None";
         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
         static std::string pbl_type_string = "None";
         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;
             } 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) {
                 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);
             } 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);
             }
         }
  
         // Right now, solving the QKE equation is only supported when MYNN PBL is turned on
         if (pbl_type == PBLType::MYNN25) {
             use_KE = true;
             query_one_or_per_level(pp, "advect_KE"    , advect_KE, lev, max_level);
             query_one_or_per_level(pp, "diffuse_KE_3D", diffuse_KE_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 = amrex::Real(1.0) / Pr_t;
         Sc_t_inv = amrex::Real(1.0) / Sc_t;
  
         query_one_or_per_level(pp, "Ce"      , Ce, lev, max_level);
         query_one_or_per_level(pp, "Ce_wall" , Ce_wall, lev, max_level);
  
         if (les_type == LESType::Deardorff) {
             query_one_or_per_level(pp, "Ck" , Ck, lev, max_level);
         }
  
         // 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);
  
         // Common inputs (LES or RANS)
         query_one_or_per_level(pp, "sigma_k" , sigma_k, lev, max_level);
         query_one_or_per_level(pp, "theta_ref", theta_ref, lev, max_level);
  
         // Validate inputs
         if (les_type == LESType::Smagorinsky) {
             if (Cs == 0) {
                 amrex::Error("Need to specify Cs for Smagorsinky LES");
             }
         }
     }