erf_sbm::SBMBulkProjection Class Reference

#include <ERF_SBMBulkProjection.H>

Collaboration diagram for erf_sbm::SBMBulkProjection:

Public Member Functions
	SBMBulkProjection (const SBMLayout &layout)
BulkProjection	apply (const std::vector< amrex::Real > &auxiliary) const
void	apply_to_core (const amrex::Box &box, const amrex::Array4< const amrex::Real > &auxiliary, const amrex::Array4< amrex::Real > &core, int qc_component, int qr_component) const
int	cloud_offset () const noexcept
int	cloud_count () const noexcept
int	rain_offset () const noexcept
int	rain_count () const noexcept

Private Attributes
int	m_cloud_offset {0}
int	m_cloud_count {0}
int	m_rain_offset {0}
int	m_rain_count {0}

Detailed Description

Fixed cloud/rain projection from the liquid population's mass bins.

Constructor & Destructor Documentation

SBMBulkProjection()

erf_sbm::SBMBulkProjection::SBMBulkProjection ( const SBMLayout &  layout )

explicit

{
    const auto& projection = layout.liquid_projection();
    const auto p = std::find_if(layout.populations().begin(), layout.populations().end(),
        [&](const PopulationLayout& candidate) {
            return candidate.population_id == projection.population_id;
        });
    if (p == layout.populations().end()) {
        throw std::invalid_argument("SBM liquid projection references an unknown population");
    }
    m_cloud_offset = p->mass_offset;
    m_cloud_count = projection.cloud_rain_split;
    m_rain_offset = m_cloud_offset + m_cloud_count;
    m_rain_count = p->grid.nbins() - m_cloud_count;
}

Here is the call graph for this function:

Member Function Documentation

apply()

BulkProjection erf_sbm::SBMBulkProjection::apply

(

const std::vector< amrex::Real > &

auxiliary

)

const

{
    if (m_rain_offset + m_rain_count > static_cast<int>(auxiliary.size())) {
        throw std::invalid_argument("auxiliary state is smaller than SBM projection");
    }
    BulkProjection result;
    for (int b = 0; b < m_cloud_count; ++b) {
        result.qc += auxiliary[static_cast<std::size_t>(m_cloud_offset + b)];
    }
    for (int b = 0; b < m_rain_count; ++b) {
        result.qr += auxiliary[static_cast<std::size_t>(m_rain_offset + b)];
    }
    return result;
}

apply_to_core()

void erf_sbm::SBMBulkProjection::apply_to_core	(	const amrex::Box &	box,
		const amrex::Array4< const amrex::Real > &	auxiliary,
		const amrex::Array4< amrex::Real > &	core,
		int	qc_component,
		int	qr_component
	)		const

{
    const int cloud_offset = m_cloud_offset;
    const int cloud_count = m_cloud_count;
    const int rain_offset = m_rain_offset;
    const int rain_count = m_rain_count;
    amrex::ParallelFor(box, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
        amrex::Real qc = amrex::Real(0.0);
        amrex::Real qr = amrex::Real(0.0);
        for (int b = 0; b < cloud_count; ++b) qc += auxiliary(i,j,k,cloud_offset+b);
        for (int b = 0; b < rain_count; ++b) qr += auxiliary(i,j,k,rain_offset+b);
        core(i,j,k,qc_component) = qc;
        core(i,j,k,qr_component) = qr;
    });
}

Referenced by erf_sbm::SBMStateManager::project_to_core(), and erf_sbm::restart_projection_matches().

Here is the call graph for this function:

Here is the caller graph for this function:

cloud_count()

int erf_sbm::SBMBulkProjection::cloud_count ( ) const

inlinenoexcept

{ return m_cloud_count; }

Referenced by apply_to_core().

Here is the caller graph for this function:

cloud_offset()

int erf_sbm::SBMBulkProjection::cloud_offset ( ) const

inlinenoexcept

{ return m_cloud_offset; }

Referenced by apply_to_core().

Here is the caller graph for this function:

rain_count()

int erf_sbm::SBMBulkProjection::rain_count ( ) const

inlinenoexcept

{ return m_rain_count; }

Referenced by apply_to_core().

Here is the caller graph for this function:

rain_offset()

int erf_sbm::SBMBulkProjection::rain_offset ( ) const

inlinenoexcept

{ return m_rain_offset; }

Referenced by apply_to_core().

Here is the caller graph for this function:

Member Data Documentation

m_cloud_count

int erf_sbm::SBMBulkProjection::m_cloud_count {0}

private

Referenced by apply(), apply_to_core(), cloud_count(), and SBMBulkProjection().

m_cloud_offset

int erf_sbm::SBMBulkProjection::m_cloud_offset {0}

private

Referenced by apply(), apply_to_core(), cloud_offset(), and SBMBulkProjection().

m_rain_count

int erf_sbm::SBMBulkProjection::m_rain_count {0}

private

Referenced by apply(), apply_to_core(), rain_count(), and SBMBulkProjection().

m_rain_offset

int erf_sbm::SBMBulkProjection::m_rain_offset {0}

private

Referenced by apply(), apply_to_core(), rain_offset(), and SBMBulkProjection().

---

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

• Source/Microphysics/SBM/ERF_SBMBulkProjection.H
• Source/Microphysics/SBM/ERF_SBMBulkProjection.cpp