#include <ERF_DiffStruct.H>

Collaboration diagram for DiffChoice:

[legend]

Public Member Functions
void	init_params (std::string pp_prefix)

void	display ()

Public Attributes
MolecDiffType	molec_diff_type = MolecDiffType::Constant

amrex::Real	alpha_T = 0.0

amrex::Real	alpha_C = 0.0

amrex::Real	rho0_trans = 1.0

amrex::Real	rhoAlpha_T = 0.0

amrex::Real	rhoAlpha_C = 0.0

amrex::Real	dynamic_viscosity = 0.0

bool	eb_diff_constraint_x = false

bool	eb_diff_constraint_y = false

bool	eb_diff_constraint_z = false

Detailed Description

Container holding diffusion-related choices

Member Function Documentation

◆ display()

void DiffChoice::display ( )

inline

     {
         amrex::Print() << "Diffusion choices: " << std::endl;
         amrex::Print() << "    rho0_trans              : " << rho0_trans << std::endl;
         amrex::Print() << "    alpha_T                 : " << alpha_T << std::endl;
         amrex::Print() << "    alpha_C                 : " << alpha_C << std::endl;
         amrex::Print() << "    dynamic_viscosity       : " << dynamic_viscosity << std::endl;
  
         if (molec_diff_type == MolecDiffType::Constant) {
             amrex::Print() << "Using constant molecular diffusivity (relevant for DNS)" << std::endl;
         } else if (molec_diff_type == MolecDiffType::None) {
             amrex::Print() << "Not using any molecular diffusivity, i.e. using the modeled turbulent diffusivity"
             << std::endl;
         }
     }

Referenced by SolverChoice::display().

Here is the caller graph for this function:

◆ init_params()

void DiffChoice::init_params ( std::string pp_prefix )

inline

     {
         amrex::ParmParse pp(pp_prefix);
  
         static std::string molec_diff_type_string = "None";
         pp.query("molec_diff_type",molec_diff_type_string);
  
         if (!molec_diff_type_string.compare("Constant")) {
             molec_diff_type = MolecDiffType::Constant;
         } else if (!molec_diff_type_string.compare("ConstantAlpha")) {
             molec_diff_type = MolecDiffType::ConstantAlpha;
         } else if (!molec_diff_type_string.compare("None")) {
             molec_diff_type = MolecDiffType::None;
         } else {
             amrex::Error("Don't know this molec_diff_type");
         }
  
         if (molec_diff_type != MolecDiffType::None) {
             pp.query("alpha_T", alpha_T);
             pp.query("alpha_C", alpha_C);
             pp.query("dynamic_viscosity", dynamic_viscosity);
             pp.query("rho0_trans", rho0_trans);
             pp.query("eb_diff_constraint_x", eb_diff_constraint_x);
             pp.query("eb_diff_constraint_y", eb_diff_constraint_y);
             pp.query("eb_diff_constraint_z", eb_diff_constraint_z);
         }
  
         // Compute relevant forms of diffusion parameters
         rhoAlpha_T = rho0_trans * alpha_T;
         rhoAlpha_C = rho0_trans * alpha_C;
  
         if (molec_diff_type == MolecDiffType::ConstantAlpha) {
             amrex::Print() << "Using constant kinematic diffusion coefficients" << std::endl;
             amrex::Print() << "  momentum : " << dynamic_viscosity/rho0_trans << " m^2/s" << std::endl;
             amrex::Print() << "  temperature : " << alpha_T << " m^2/s" << std::endl;
             amrex::Print() << "  scalar : " << alpha_C << " m^2/s" << std::endl;
         }
         else if (molec_diff_type == MolecDiffType::Constant) {
             amrex::Print() << "Using constant dynamic diffusion coefficients" << std::endl;
             amrex::Print() << "  momentum : " << dynamic_viscosity << " kg/(m-s)" << std::endl;
             amrex::Print() << "  temperature : " << rhoAlpha_T << " kg/(m-s)" << std::endl;
             amrex::Print() << "  scalar : " << rhoAlpha_C << " kg/(m-s)" << std::endl;
         }
  
     }