SatAdj Class Reference

#include <ERF_SatAdj.H>

Inheritance diagram for SatAdj:

Collaboration diagram for SatAdj:

Public Member Functions
	SatAdj ()
virtual	~SatAdj ()=default
void	AdvanceSatAdj (const SolverChoice &)
void	Define (SolverChoice &sc) override
void	Init (const amrex::MultiFab &cons_in, const amrex::BoxArray &, const amrex::Geometry &geom, const amrex::Real &dt_advance, std::unique_ptr< amrex::MultiFab > &, std::unique_ptr< amrex::MultiFab > &) override
void	Copy_State_to_Micro (const amrex::MultiFab &cons_in) override
void	Copy_Micro_to_State (amrex::MultiFab &cons_in) override
void	Update_Micro_Vars (amrex::MultiFab &cons_in) override
void	Update_State_Vars (amrex::MultiFab &cons_in) override
void	Advance (const amrex::Real &dt_advance, const SolverChoice &solverChoice) override
amrex::MultiFab *	Qmoist_Ptr (const int &varIdx) override
int	Qmoist_Size () override
int	Qstate_Moist_Size () override
void	Qmoist_Restart_Vars (const SolverChoice &, std::vector< int > &a_idx, std::vector< std::string > &a_names) const override
Public Member Functions inherited from NullMoist
	NullMoist ()
virtual	~NullMoist ()=default
virtual int	Qstate_NonMoist_Size ()
virtual void	GetPlotVarNames (amrex::Vector< std::string > &a_vec) const
virtual void	GetPlotVar (const std::string &, amrex::MultiFab &) const

Static Public Member Functions
AMREX_GPU_HOST_DEVICE static AMREX_FORCE_INLINE amrex::Real	NewtonIterSat (int &i, int &j, int &k, const amrex::Real &fac_cond, const amrex::Array4< amrex::Real > &tabs_array, const amrex::Array4< amrex::Real > &pres_array, const amrex::Array4< amrex::Real > &qv_array, const amrex::Array4< amrex::Real > &qc_array)

Private Types
using	FabPtr = std::shared_ptr< amrex::MultiFab >

Private Attributes
int	m_qmoist_size = 0
int	n_qstate_moist_size = 2
amrex::Geometry	m_geom
amrex::Real	dt
amrex::Real	m_fac_cond
amrex::Real	m_rdOcp
amrex::Array< FabPtr, MicVar_SatAdj::NumVars >	mic_fab_vars

Member Typedef Documentation

FabPtr

using SatAdj::FabPtr = std::shared_ptr<amrex::MultiFab>

private

Constructor & Destructor Documentation

SatAdj()

SatAdj::SatAdj ( )

inline

{}

~SatAdj()

virtual SatAdj::~SatAdj ( )

virtualdefault

Member Function Documentation

Advance()

void SatAdj::Advance ( const amrex::Real &  dt_advance, const SolverChoice &  solverChoice  )

inlineoverridevirtual

Reimplemented from NullMoist.

    {
        dt = dt_advance;
 
        this->AdvanceSatAdj(solverChoice);
    }

Here is the call graph for this function:

AdvanceSatAdj()

void SatAdj::AdvanceSatAdj

(

const SolverChoice &

)

Compute Precipitation-related Microphysics quantities.

{
    auto tabs  = mic_fab_vars[MicVar_SatAdj::tabs];
 
    // Expose for GPU
    Real d_fac_cond = m_fac_cond;
    Real rdOcp      = m_rdOcp;
 
    // get the temperature, density, theta, qt and qc from input
    for ( MFIter mfi(*tabs,TilingIfNotGPU()); mfi.isValid(); ++mfi) {
 
        const auto& tbx = mfi.tilebox();
 
        auto qv_array    = mic_fab_vars[MicVar_SatAdj::qv]->array(mfi);
        auto qc_array    = mic_fab_vars[MicVar_SatAdj::qc]->array(mfi);
        auto tabs_array  = mic_fab_vars[MicVar_SatAdj::tabs]->array(mfi);
        auto theta_array = mic_fab_vars[MicVar_SatAdj::theta]->array(mfi);
        auto pres_array  = mic_fab_vars[MicVar_SatAdj::pres]->array(mfi);
 
        ParallelFor(tbx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept
        {
            //qc_array(i,j,k) = std::max(0.0, qc_array(i,j,k));
 
            //------- Evaporation/condensation
            Real qsat;
            erf_qsatw(tabs_array(i,j,k), pres_array(i,j,k), qsat);
 
            // There is enough moisture to drive to equilibrium
            if ((qv_array(i,j,k)+qc_array(i,j,k)) > qsat) {
                Real qvprev = qv_array(i,j,k);
                Real qcprev = qc_array(i,j,k);
 
                // clip qc but maintain total water
                if (qc_array(i,j,k) < 0) {
                    qv_array(i,j,k) += qc_array(i,j,k);
                    qc_array(i,j,k)  = 0.0;
                }
 
                // Update temperature
                tabs_array(i,j,k) = NewtonIterSat(i, j, k   ,
                                                  d_fac_cond, tabs_array, pres_array,
                                                  qv_array  , qc_array  );
 
                Real qsatnew;
                erf_qsatw(tabs_array(i,j,k), pres_array(i,j,k), qsatnew);
 
                AMREX_ASSERT(std::abs(qv_array(i,j,k)-qsatnew) < 1e-12);
 
                amrex::ignore_unused(qvprev);
                amrex::ignore_unused(qcprev);
                AMREX_ASSERT(std::abs(qv_array(i,j,k)+qc_array(i,j,k)-qvprev-qcprev) < 1e-14);
 
                // Update theta (constant pressure)
                theta_array(i,j,k) = getThgivenTandP(tabs_array(i,j,k), 100.0*pres_array(i,j,k), rdOcp);
 
            //
            // We cannot blindly relax to qsat, but we can convert qc/qi -> qv.
            // The concept here is that if we put all the moisture into qv and modify
            // the temperature, we can then check if qv > qsat occurs (for final T/P/qv).
            // If the reduction in T/qsat and increase in qv does trigger the
            // aforementioned condition, we can do Newton iteration to drive qv = qsat.
            //
            } else {
                // Changes in each component
                Real delta_qc = qc_array(i,j,k);
 
                // Partition the change in non-precipitating q
                qv_array(i,j,k) += qc_array(i,j,k);
                qc_array(i,j,k)  = 0.0;
 
                // Update temperature (endothermic since we evap/sublime)
                tabs_array(i,j,k) -= d_fac_cond * delta_qc;
 
                // Update theta
                theta_array(i,j,k) = getThgivenTandP(tabs_array(i,j,k), 100.0*pres_array(i,j,k), rdOcp);
 
                // Verify assumption that qv > qsat does not occur
                erf_qsatw(tabs_array(i,j,k), pres_array(i,j,k), qsat);
                if (qv_array(i,j,k) > qsat) {
                    Real qvprev = qv_array(i,j,k);
                    Real qcprev = qc_array(i,j,k);
                    Real Tprev = tabs_array(i,j,k);
 
                    // Update temperature
                    tabs_array(i,j,k) = NewtonIterSat(i, j, k     ,
                                                      d_fac_cond  , tabs_array, pres_array,
                                                      qv_array    , qc_array  );
 
                    Real qsatnew;
                    erf_qsatw(tabs_array(i,j,k), pres_array(i,j,k), qsatnew);
                    amrex::ignore_unused(qvprev);
                    amrex::ignore_unused(qcprev);
                    amrex::ignore_unused(Tprev);
                    AMREX_ASSERT(qv_array(i,j,k) < qvprev);
                    AMREX_ASSERT(qc_array(i,j,k) > qcprev);
                    AMREX_ASSERT(tabs_array(i,j,k) > Tprev);
                    AMREX_ASSERT(std::abs(qv_array(i,j,k)-qsatnew) < 1e-14);
                    AMREX_ASSERT(std::abs(qv_array(i,j,k)+qc_array(i,j,k)-qvprev-qcprev) < 1e-14);
 
                    // Update theta
                    theta_array(i,j,k) = getThgivenTandP(tabs_array(i,j,k), 100.0*pres_array(i,j,k), rdOcp);
 
                }
            }
        });
    }
}

Referenced by Advance().

Here is the call graph for this function:

Here is the caller graph for this function:

Copy_Micro_to_State()

void SatAdj::Copy_Micro_to_State ( amrex::MultiFab &  cons_in )

overridevirtual

Updates conserved and microphysics variables in the provided MultiFabs from the internal MultiFabs that store Microphysics module data.

Parameters

[out]	cons	Conserved variables
[out]	qmoist	qv, qc

Reimplemented from NullMoist.

{
    // Get the temperature, density, theta, qt and qp from input
    for (MFIter mfi(cons,TilingIfNotGPU()); mfi.isValid(); ++mfi) {
        const auto& tbx = mfi.tilebox();
 
        auto states_arr = cons.array(mfi);
 
        auto rho_arr    = mic_fab_vars[MicVar_SatAdj::rho]->array(mfi);
        auto theta_arr  = mic_fab_vars[MicVar_SatAdj::theta]->array(mfi);
        auto qv_arr     = mic_fab_vars[MicVar_SatAdj::qv]->array(mfi);
        auto qc_arr     = mic_fab_vars[MicVar_SatAdj::qc]->array(mfi);
 
        // get potential total density, temperature, qt, qp
        ParallelFor(tbx, [=] AMREX_GPU_DEVICE (int i, int j, int k)
        {
            states_arr(i,j,k,RhoTheta_comp) = rho_arr(i,j,k)*theta_arr(i,j,k);
            states_arr(i,j,k,RhoQ1_comp)    = rho_arr(i,j,k)*qv_arr(i,j,k);
            states_arr(i,j,k,RhoQ2_comp)    = rho_arr(i,j,k)*qc_arr(i,j,k);
        });
    }
 
    // Fill interior ghost cells and periodic boundaries
    cons.FillBoundary(m_geom.periodicity());
}

Referenced by Update_State_Vars().

Here is the caller graph for this function:

Copy_State_to_Micro()

void SatAdj::Copy_State_to_Micro ( const amrex::MultiFab &  cons_in )

overridevirtual

Initializes the Microphysics module.

Parameters

[in]

cons_in

Conserved variables input

Reimplemented from NullMoist.

{
    // Get the temperature, density, theta, qt and qp from input
    for (MFIter mfi(cons_in); mfi.isValid(); ++mfi) {
        const auto& tbx = mfi.tilebox();
 
        auto states_array = cons_in.array(mfi);
 
        auto qv_array    = mic_fab_vars[MicVar_SatAdj::qv]->array(mfi);
        auto qc_array    = mic_fab_vars[MicVar_SatAdj::qc]->array(mfi);
 
        auto rho_array   = mic_fab_vars[MicVar_SatAdj::rho]->array(mfi);
        auto theta_array = mic_fab_vars[MicVar_SatAdj::theta]->array(mfi);
        auto tabs_array  = mic_fab_vars[MicVar_SatAdj::tabs]->array(mfi);
        auto pres_array  = mic_fab_vars[MicVar_SatAdj::pres]->array(mfi);
 
        // Get pressure, theta, temperature, density, and qt, qp
        ParallelFor(tbx, [=] AMREX_GPU_DEVICE (int i, int j, int k)
        {
            rho_array(i,j,k)   = states_array(i,j,k,Rho_comp);
            theta_array(i,j,k) = states_array(i,j,k,RhoTheta_comp)/states_array(i,j,k,Rho_comp);
            qv_array(i,j,k)    = states_array(i,j,k,RhoQ1_comp)/states_array(i,j,k,Rho_comp);
            qc_array(i,j,k)    = states_array(i,j,k,RhoQ2_comp)/states_array(i,j,k,Rho_comp);
 
            tabs_array(i,j,k)  = getTgivenRandRTh(states_array(i,j,k,Rho_comp),
                                                  states_array(i,j,k,RhoTheta_comp),
                                                  qv_array(i,j,k));
 
            // Pressure in [mbar] for qsat evaluation
            pres_array(i,j,k)  = getPgivenRTh(states_array(i,j,k,RhoTheta_comp), qv_array(i,j,k)) * 0.01;
        });
    }
}

Referenced by Update_Micro_Vars().

Here is the call graph for this function:

Here is the caller graph for this function:

Define()

void SatAdj::Define ( SolverChoice &  sc )

inlineoverridevirtual

Reimplemented from NullMoist.

    {
        m_fac_cond = lcond / sc.c_p;
        m_rdOcp    = sc.rdOcp;
    }

Init()

void SatAdj::Init ( const amrex::MultiFab &  cons_in, const amrex::BoxArray &  , const amrex::Geometry &  geom, const amrex::Real &  dt_advance, std::unique_ptr< amrex::MultiFab > &  , std::unique_ptr< amrex::MultiFab > &    )

overridevirtual

Initializes the Microphysics module.

Parameters

[in]	cons_in	Conserved variables input
[in]	qc_in	Cloud variables input
[in,out]	qv_in	Vapor variables input
[in]	qi_in	Ice variables input
[in]	grids	The boxes on which we will evolve the solution
[in]	geom	Geometry associated with these MultiFabs and grids
[in]	dt_advance	Timestep for the advance

Reimplemented from NullMoist.

{
    dt = dt_advance;
    m_geom = geom;
 
    // initialize microphysics variables
    for (auto ivar = 0; ivar < MicVar_SatAdj::NumVars; ++ivar) {
        mic_fab_vars[ivar] = std::make_shared<MultiFab>(cons_in.boxArray(), cons_in.DistributionMap(),
                                                        1, cons_in.nGrowVect());
        mic_fab_vars[ivar]->setVal(0.);
    }
}

NewtonIterSat()

AMREX_GPU_HOST_DEVICE static AMREX_FORCE_INLINE amrex::Real SatAdj::NewtonIterSat ( int &  i, int &  j, int &  k, const amrex::Real &  fac_cond, const amrex::Array4< amrex::Real > &  tabs_array, const amrex::Array4< amrex::Real > &  pres_array, const amrex::Array4< amrex::Real > &  qv_array, const amrex::Array4< amrex::Real > &  qc_array  )

inlinestatic

    {
        // Solution tolerance
        amrex::Real tol = 1.0e-8;
 
        // Saturation moisture fractions
        amrex::Real qsat, dqsat;
 
        // Newton iteration vars
        int  niter;
        amrex::Real fff, dfff;
        amrex::Real dtabs, delta_qv;
 
        // Initial guess for temperature & pressure
        amrex::Real tabs = tabs_array(i,j,k);
        amrex::Real pres = pres_array(i,j,k);
 
        niter = 0;
        dtabs = 1;
 
        //==================================================
        // Newton iteration to qv=qsat (cloud phase only)
        //==================================================
        do {
            // Saturation moisture fractions
            erf_qsatw(tabs, pres, qsat);
            erf_dtqsatw(tabs, pres, dqsat);
 
            // Function for root finding:
            // 0 = -T_new + T_old + L_eff/C_p * (qv - qsat)
            fff   = -tabs + tabs_array(i,j,k) + fac_cond*(qv_array(i,j,k) - qsat);
 
            // Derivative of function (T_new iterated on)
            dfff  = -1.0 - fac_cond*dqsat;
 
            // Update the temperature
            dtabs = -fff/dfff;
            tabs += dtabs;
 
            // Update iteration
            niter = niter+1;
        } while(std::abs(dtabs) > tol && niter < 20);
 
        // Update qsat from last iteration (dq = dq/dt * dt)
        qsat += dqsat*dtabs;
 
        // Changes in each component
        delta_qv = qv_array(i,j,k) - qsat;
 
        // Partition the change in non-precipitating q
        qv_array(i,j,k)  = qsat;
        qc_array(i,j,k) += delta_qv;
 
        // Return to temperature
        return tabs;
    }

Here is the call graph for this function:

Qmoist_Ptr()

amrex::MultiFab* SatAdj::Qmoist_Ptr ( const int &  varIdx )

inlineoverridevirtual

Reimplemented from NullMoist.

    {
        AMREX_ALWAYS_ASSERT(varIdx < m_qmoist_size);
        return nullptr;
    }

Qmoist_Restart_Vars()

void SatAdj::Qmoist_Restart_Vars ( const SolverChoice &  , std::vector< int > &  a_idx, std::vector< std::string > &  a_names  ) const

inlineoverridevirtual

Reimplemented from NullMoist.

    {
        a_idx.clear();
        a_names.clear();
    }

Qmoist_Size()

int SatAdj::Qmoist_Size ( )

inlineoverridevirtual

Reimplemented from NullMoist.

{ return SatAdj::m_qmoist_size; }

Qstate_Moist_Size()

int SatAdj::Qstate_Moist_Size ( )

inlineoverridevirtual

Reimplemented from NullMoist.

{ return SatAdj::n_qstate_moist_size; }

Update_Micro_Vars()

void SatAdj::Update_Micro_Vars ( amrex::MultiFab &  cons_in )

inlineoverridevirtual

Reimplemented from NullMoist.

    {
        this->Copy_State_to_Micro(cons_in);
    }

Here is the call graph for this function:

Update_State_Vars()

void SatAdj::Update_State_Vars ( amrex::MultiFab &  cons_in )

inlineoverridevirtual

Reimplemented from NullMoist.

    {
        this->Copy_Micro_to_State(cons_in);
    }

Here is the call graph for this function:

Member Data Documentation

dt

amrex::Real SatAdj::dt

private

Referenced by Advance().

m_fac_cond

amrex::Real SatAdj::m_fac_cond

private

Referenced by Define().

m_geom

amrex::Geometry SatAdj::m_geom

private

m_qmoist_size

int SatAdj::m_qmoist_size = 0

private

Referenced by Qmoist_Ptr(), and Qmoist_Size().

m_rdOcp

amrex::Real SatAdj::m_rdOcp

private

Referenced by Define().

mic_fab_vars

amrex::Array<FabPtr, MicVar_SatAdj::NumVars> SatAdj::mic_fab_vars

private

n_qstate_moist_size

int SatAdj::n_qstate_moist_size = 2

private

Referenced by Qstate_Moist_Size().

---

The documentation for this class was generated from the following files:

• Source/Microphysics/SatAdj/ERF_SatAdj.H
• Source/Microphysics/SatAdj/ERF_InitSatAdj.cpp
• Source/Microphysics/SatAdj/ERF_SatAdj.cpp
• Source/Microphysics/SatAdj/ERF_UpdateSatAdj.cpp