ERF_DiffStruct.H

Go to the documentation of this file.

#ifndef ERF_DIFF_STRUCT_H_
#define ERF_DIFF_STRUCT_H_
 
#include <string>
#include <iostream>
 
#include <AMReX_ParmParse.H>
#include <AMReX_Print.H>
#include <AMReX_Gpu.H>
 
/**
 * @brief Molecular diffusion model used for transport coefficients.
 */
enum struct MolecDiffType {
    None, Constant, ConstantAlpha
};
 
/**
 * Container holding diffusion-related choices
 */
 
struct DiffChoice {
  public:
    /**
     * @brief Read diffusion options from the input parameter database.
     * @param pp_prefix ParmParse prefix for the ERF input namespace.
     */
    void init_params (std::string pp_prefix)
    {
        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;
        }
 
    }
 
    /**
     * @brief Print the configured diffusion options.
     */
    void display ()
    {
        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;
        }
    }
 
    // Molecular transport model
    MolecDiffType molec_diff_type = MolecDiffType::Constant;
 
    // Diffusive/viscous coefficients [m2/s]
    amrex::Real alpha_T = zero;
    amrex::Real alpha_C = zero;
 
    // Density for computation of rhoAlpha (which is assumed constant) [kg/m3]
    amrex::Real rho0_trans = one;
 
    // Dynamic diffusion coefficients [kg/(m-s)]
    amrex::Real rhoAlpha_T = zero;
    amrex::Real rhoAlpha_C = zero;
    amrex::Real dynamic_viscosity = zero;
    bool eb_diff_constraint_x = false;
    bool eb_diff_constraint_y = false;
    bool eb_diff_constraint_z = false;
};
 
/**
 * @var DiffChoice::molec_diff_type
 * @brief Selected molecular transport model.
 * @var DiffChoice::alpha_T
 * @brief Kinematic temperature diffusivity [m2/s].
 * @var DiffChoice::alpha_C
 * @brief Kinematic scalar diffusivity [m2/s].
 * @var DiffChoice::rho0_trans
 * @brief Reference density used to compute dynamic diffusion coefficients [kg/m3].
 * @var DiffChoice::rhoAlpha_T
 * @brief Dynamic temperature diffusion coefficient [kg/(m-s)].
 * @var DiffChoice::rhoAlpha_C
 * @brief Dynamic scalar diffusion coefficient [kg/(m-s)].
 * @var DiffChoice::dynamic_viscosity
 * @brief Dynamic viscosity for momentum diffusion [kg/(m-s)].
 * @var DiffChoice::eb_diff_constraint_x
 * @brief Whether to constrain EB diffusion in the x direction.
 * @var DiffChoice::eb_diff_constraint_y
 * @brief Whether to constrain EB diffusion in the y direction.
 * @var DiffChoice::eb_diff_constraint_z
 * @brief Whether to constrain EB diffusion in the z direction.
 */
#endif