ConstTransport.H

Go to the documentation of this file.

#ifndef CONSTTRANSPORT_H
#define CONSTTRANSPORT_H
 
#include "amr-wind/transport_models/TransportModel.H"
#include "AMReX_ParmParse.H"
 
namespace amr_wind::transport {
 
class ConstTransport : public TransportModel
{
public:
    static constexpr bool constant_properties = true;
 
    static std::string identifier() { return "ConstTransport"; }
 
    explicit ConstTransport(CFDSim& sim) : m_repo(sim.repo())
    {
        amrex::ParmParse pp("transport");
        pp.query("viscosity", m_mu);
        pp.query("laminar_prandtl", m_Pr);
        pp.query("turbulent_prandtl", m_Prt);
    }
 
    ~ConstTransport() override = default;
 
    inline amrex::Real viscosity() const { return m_mu; }
 
    inline amrex::Real thermal_diffusivity() const { return m_mu / m_Pr; }
 
    inline amrex::Real laminar_prandtl() const { return m_Pr; }
 
    inline amrex::Real turbulent_prandtl() const { return m_Prt; }
 
    static inline amrex::Real laminar_schmidt(const std::string& scalar_name)
    {
        amrex::ParmParse pp("transport");
        const std::string key = scalar_name + "_laminar_schmidt";
        amrex::Real lam_schmidt = 1.0;
        pp.query(key.c_str(), lam_schmidt);
        return lam_schmidt;
    }
 
    static inline amrex::Real turbulent_schmidt(const std::string& scalar_name)
    {
        amrex::ParmParse pp("transport");
        const std::string key = scalar_name + "_turbulent_schmidt";
        amrex::Real turb_schmidt = 1.0;
        pp.query(key.c_str(), turb_schmidt);
        return turb_schmidt;
    }
 
    inline std::unique_ptr<ScratchField> mu() override
    {
        auto mu = m_repo.create_scratch_field(1, 1);
        for (int lev = 0; lev < m_repo.num_active_levels(); ++lev) {
            (*mu)(lev).setVal(m_mu);
        }
        return mu;
    }
 
    inline std::unique_ptr<ScratchField> alpha() override
    {
        auto alpha = mu();
        amrex::Real inv_Pr = 1.0 / m_Pr;
        for (int lev = 0; lev < m_repo.num_active_levels(); ++lev) {
            (*alpha)(lev).mult(inv_Pr);
        }
        return alpha;
    }
 
    inline std::unique_ptr<ScratchField>
    scalar_diffusivity(const std::string& scalar_name) override
    {
        amrex::Real lam_schmidt = laminar_schmidt(scalar_name);
 
        amrex::Real inv_schmidt = 1.0 / lam_schmidt;
        auto diff = mu();
        for (int lev = 0; lev < m_repo.num_active_levels(); ++lev) {
            (*diff)(lev).mult(inv_schmidt);
        }
 
        return diff;
    }
 
private:
    FieldRepo& m_repo;
 
    amrex::Real m_mu{1.0e-5};
 
    amrex::Real m_Pr{1.0};
 
    amrex::Real m_Prt{1.0};
};
 
} // namespace amr_wind::transport
 
#endif /* CONSTTRANSPORT_H */