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, const amrex::MultiFab &) 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
int	Qstate_Moist_NumConc_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
virtual void	GetPlotVar (const std::string &a_name, amrex::MultiFab &a_mf, const int) const
virtual void	SetCurrentLevel (const int &)
virtual void	InitLevel (const int, const amrex::MultiFab &)
virtual int	getDiagnosticsInterval () const
virtual void	Set_dzmin (const amrex::Real)
virtual SurfacePrecipAccumulationSources	Get_Surface_Precip_Accumulation_Ptrs (const int &) const
virtual void	Set_RealWidth (const int)

Static Public Member Functions
AMREX_GPU_HOST_DEVICE static AMREX_FORCE_INLINE amrex::Real	NewtonSolveSatTemperature (const amrex::Real fac_cond, const amrex::Real tabs_old, const amrex::Real pres_mbar, const amrex::Real qv_old, amrex::Real &qsat)
AMREX_GPU_HOST_DEVICE static AMREX_FORCE_INLINE void	AdjustSatAdjCell (const amrex::Real fac_cond, const amrex::Real rdOcp, amrex::Real &tabs, const amrex::Real pres_mbar, amrex::Real &theta, amrex::Real &qv, amrex::Real &qc)

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

Private Attributes
int	m_qmoist_size = 0
int	n_qstate_moist_size = 2
int	n_qstate_moist_numconc_size = 0
amrex::Geometry	m_geom
amrex::Real	dt
amrex::Real	m_fac_cond
amrex::Real	m_rdOcp
bool	m_do_cond
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

AdjustSatAdjCell()

AMREX_GPU_HOST_DEVICE static AMREX_FORCE_INLINE void SatAdj::AdjustSatAdjCell ( const amrex::Real  fac_cond, const amrex::Real  rdOcp, amrex::Real &  tabs, const amrex::Real  pres_mbar, amrex::Real &  theta, amrex::Real &  qv, amrex::Real &  qc  )

inlinestatic

    {
        amrex::Real qsat;
        erf_qsatw(tabs, pres_mbar, qsat);
 
        if ((qv + qc) > qsat) {
            // Total water exceeds saturation at the initial temperature, so the final state
            // is cloudy and saturated. Solve directly for the final saturated temperature.
            // This is algebraically equivalent to evaporating existing cloud water first
            // and then recondensing to the fixed-pressure equilibrium state.
#if defined(AMREX_DEBUG)
            const amrex::Real qvprev = qv;
            const amrex::Real qcprev = qc;
#endif
 
            if (qc < 0) {
                // Repair negative cloud water by transferring the deficit back to vapor
                // before solving the saturated equilibrium and clamping qc to zero.
                qv += qc;
                qc = zero;
            }
 
            tabs = NewtonSolveSatTemperature(fac_cond, tabs, pres_mbar, qv, qsat);
 
            const amrex::Real delta_qv = qv - qsat;
            qv = qsat;
            qc += delta_qv;
 
#if defined(AMREX_DEBUG)
            amrex::Real qsatnew;
            erf_qsatw(tabs, pres_mbar, qsatnew);
            AMREX_ASSERT(std::abs(qv-qsatnew) < 1e-12);
            AMREX_ASSERT(std::abs(qv+qc-qvprev-qcprev) < 1e-14);
#endif
 
            theta = getThgivenTandP(tabs, amrex::Real(100.0)*pres_mbar, rdOcp);
        } else {
            // Total water does not exceed initial saturation. Evaporate all cloud water,
            // cooling the cell by latent heat absorption. The cooled cell can become
            // supersaturated, so recondense if needed.
            const amrex::Real delta_qc = qc;
 
            qv += qc;
            qc = zero;
 
            tabs -= fac_cond * delta_qc;
            theta = getThgivenTandP(tabs, amrex::Real(100.0)*pres_mbar, rdOcp);
 
            erf_qsatw(tabs, pres_mbar, qsat);
            if (qv > qsat) {
#if defined(AMREX_DEBUG)
                const amrex::Real qvprev = qv;
                const amrex::Real qcprev = qc;
                const amrex::Real Tprev = tabs;
#endif
 
                tabs = NewtonSolveSatTemperature(fac_cond, tabs, pres_mbar, qv, qsat);
 
                const amrex::Real delta_qv = qv - qsat;
                qv = qsat;
                qc += delta_qv;
 
#if defined(AMREX_DEBUG)
                amrex::Real qsatnew;
                erf_qsatw(tabs, pres_mbar, qsatnew);
                AMREX_ASSERT(qv < qvprev);
                AMREX_ASSERT(qc > qcprev);
                AMREX_ASSERT(tabs > Tprev);
                AMREX_ASSERT(std::abs(qv-qsatnew) < 1e-14);
                AMREX_ASSERT(std::abs(qv+qc-qvprev-qcprev) < 1e-14);
#endif
 
                theta = getThgivenTandP(tabs, amrex::Real(100.0)*pres_mbar, rdOcp);
            }
        }
    }

Here is the call graph for this function:

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 &

)

AdvanceSatAdj is a local valid-cell update over MFIter tileboxes. It uses pressure diagnosed in Copy_State_to_Micro and holds that pressure fixed inside each cell adjustment. There are no stencils, face fluxes, or ghost-cell reads in this kernel.

{
    // Saturation adjustment can be disabled by solver choice, e.g. when SHOC
    // owns moist thermodynamics instead of the standalone SatAdj module.
    if (!m_do_cond) { return; }
 
    auto tabs  = mic_fab_vars[MicVar_SatAdj::tabs];
 
    // Expose for GPU
    Real d_fac_cond = m_fac_cond;
    Real rdOcp      = m_rdOcp;
 
    for ( MFIter mfi(*tabs,TilingIfNotGPU()); mfi.isValid(); ++mfi) {
 
        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
        {
            Real T  = tabs_array(i,j,k);
            Real p  = pres_array(i,j,k);
            Real th = theta_array(i,j,k);
            Real qv = qv_array(i,j,k);
            Real qc = qc_array(i,j,k);
 
            AdjustSatAdjCell(d_fac_cond, rdOcp, T, p, th, qv, qc);
 
            tabs_array(i,j,k)  = T;
            theta_array(i,j,k) = th;
            qv_array(i,j,k)    = qv;
            qc_array(i,j,k)    = qc;
        });
    }
}

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

Copies SatAdj's adjusted specific variables back into ERF's conserved state. The copied rho is used only to reconstruct rhoTheta, rhoQv, and rhoQc. Density itself is intentionally not written back because SatAdj does not own or modify rho.

Parameters

[out]

cons

Conserved variables

Reimplemented from NullMoist.

{
    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);
 
        // Density is intentionally not written back. SatAdj does not modify density;
        // it uses the copied rho only to form conserved rhoTheta, rhoQv, and rhoQc
        // from the adjusted specific variables.
        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 ghost and periodic boundary values after the valid-cell copy-back.
    cons.FillBoundary(m_geom.periodicity());
}

Referenced by Update_State_Vars().

Here is the call graph for this function:

Here is the caller graph for this function:

Copy_State_to_Micro()

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

overridevirtual

Copies conserved ERF state into SatAdj's internal specific variables. rho is copied but not modified by SatAdj. theta, qv, and qc are formed by dividing conserved densities by rho. tabs and pressure are diagnosed from the same conserved state snapshot. pressure is converted from Pa to mbar/hPa for saturation helper calls.

Parameters

[in]

cons_in

Conserved variables input

Reimplemented from NullMoist.

{
    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);
 
        // Use local scalars so temperature and pressure are diagnosed from the same
        // conserved state values copied into the microphysics arrays. This avoids
        // hidden read-after-write dependencies inside the kernel body.
        ParallelFor(tbx, [=] AMREX_GPU_DEVICE (int i, int j, int k)
        {
            const Real rho      = states_array(i,j,k,Rho_comp);
            const Real rhoTheta = states_array(i,j,k,RhoTheta_comp);
            const Real qv       = states_array(i,j,k,RhoQ1_comp) / rho;
            const Real qc       = states_array(i,j,k,RhoQ2_comp) / rho;
            const Real theta    = rhoTheta / rho;
 
            rho_array(i,j,k)   = rho;
            theta_array(i,j,k) = theta;
            qv_array(i,j,k)    = qv;
            qc_array(i,j,k)    = qc;
            tabs_array(i,j,k)  = getTgivenRandRTh(rho, rhoTheta, qv);
 
            // Pressure is stored in mbar/hPa because erf_qsatw expects that unit.
            pres_array(i,j,k)  = getPgivenRTh(rhoTheta, qv) * Real(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;
        m_do_cond  = (!sc.uses_shoc_family());
    }

Here is the call graph for this function:

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.);
    }
}

NewtonSolveSatTemperature()

AMREX_GPU_HOST_DEVICE static AMREX_FORCE_INLINE amrex::Real SatAdj::NewtonSolveSatTemperature ( const amrex::Real  fac_cond, const amrex::Real  tabs_old, const amrex::Real  pres_mbar, const amrex::Real  qv_old, amrex::Real &  qsat  )

inlinestatic

    {
#ifdef AMREX_USE_FLOAT
        constexpr amrex::Real tol = amrex::Real(1.e-4);
#else
        constexpr amrex::Real tol = amrex::Real(1.e-8);
#endif
        constexpr int max_iter = 20;
 
        int  niter = 0;
        amrex::Real F, dFdT, dqsat;
        amrex::Real tabs = tabs_old;
 
        //==================================================
        // Newton iteration to qv=qsat (cloud phase only)
        //==================================================
        // Saturation moisture fractions
        erf_qsatw(tabs, pres_mbar, qsat);
        erf_dtqsatw(tabs, pres_mbar, dqsat);
 
        // Function for root finding:
        // 0 = -T_new + T_old + L_eff/C_p * (qv - qsat)
        F = -tabs + tabs_old + fac_cond*(qv_old - qsat);
 
        // Iterate when necessary
        while (std::abs(F) > tol && niter < max_iter) {
            // Derivative of function (T_new iterated on)
            dFdT  = -one - fac_cond*dqsat;
 
            // Update the temperature
            tabs -= F/dFdT;
 
            // Saturation moisture fractions
            erf_qsatw(tabs, pres_mbar, qsat);
            erf_dtqsatw(tabs, pres_mbar, dqsat);
 
            // Function for root finding:
            // 0 = -T_new + T_old + L_eff/C_p * (qv - qsat)
            F = -tabs + tabs_old + fac_cond*(qv_old - qsat);
 
            // Update iteration
            ++niter;
        }
 
        bool valid_solution = (std::abs(F) <= tol && niter < max_iter);
        AMREX_ALWAYS_ASSERT_WITH_MESSAGE(valid_solution, "SatAdj single phase saturation adjustment failed to converge.");
 
        return tabs;
    }

Referenced by AdjustSatAdjCell().

Here is the call graph for this function:

Here is the caller 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;
    }

Here is the call graph for this function:

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_NumConc_Size()

int SatAdj::Qstate_Moist_NumConc_Size ( )

inlineoverridevirtual

Reimplemented from NullMoist.

{ return SatAdj::n_qstate_moist_numconc_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, const amrex::MultiFab &    )

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_do_cond

bool SatAdj::m_do_cond

private

Referenced by Define().

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_numconc_size

int SatAdj::n_qstate_moist_numconc_size = 0

private

Referenced by Qstate_Moist_NumConc_Size().

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