erf_sbm::SBMStateManager Class Reference

#include <ERF_SBMStateManager.H>

Collaboration diagram for erf_sbm::SBMStateManager:

Classes
struct	LevelState

Public Member Functions
	SBMStateManager (SBMLayout layout, int nlevels)
const SBMLayout &	layout () const noexcept
int	nlevels () const noexcept
bool	is_defined (int lev) const
void	define (int lev, const amrex::BoxArray &grids, const amrex::DistributionMapping &mapping, double current_time, int ngrow=0)
void	destroy (int lev)
const amrex::MultiFab &	old_state (int lev) const
double	old_time (int lev) const
bool	old_valid (int lev) const
const amrex::MultiFab &	new_state (int lev) const
double	new_time (int lev) const
bool	new_valid (int lev) const
amrex::MultiFab &	new_state_for_initialization (int lev)
amrex::MultiFab &	new_target_storage (int lev)
bool	begin_step (int lev, double step_old_time, std::string &diagnostic)
bool	accept_stage_target (int lev, double target_time, bool physical_step_complete, std::string &diagnostic)
bool	step_active (int lev) const
void	project_to_core (int lev, amrex::MultiFab &core, int qc_component, int qr_component) const

Private Member Functions
LevelState &	level (int lev)
const LevelState &	level (int lev) const

Private Attributes
SBMLayout	m_layout
SBMBulkProjection	m_projection
std::vector< LevelState >	m_levels

Detailed Description

Owns the authoritative old/new spectral state and its semantic times.

Constructor & Destructor Documentation

SBMStateManager()

erf_sbm::SBMStateManager::SBMStateManager	(	SBMLayout	layout,
		int	nlevels
	)

    : m_layout(std::move(layout)), m_projection(m_layout)
{
    if (nlevels <= 0) throw std::invalid_argument("SBM state manager needs at least one level");
    m_levels.resize(static_cast<std::size_t>(nlevels));
}

Here is the call graph for this function:

Member Function Documentation

accept_stage_target()

bool erf_sbm::SBMStateManager::accept_stage_target	(	int	lev,
		double	target_time,
		bool	physical_step_complete,
		std::string &	diagnostic
	)

Publish a candidate accepted by the host stage sequence.

{
    diagnostic.clear();
    auto& state = level(lev);
    if (!state.old_state || !state.new_state || !state.step_active || !state.old_valid) {
        diagnostic = "SBM stage target cannot be accepted without an active old/new lifecycle";
        return false;
    }
    if (!std::isfinite(target_time)) {
        diagnostic = "SBM stage target semantic time is nonfinite";
        return false;
    }
    state.new_time = target_time;
    state.new_valid = true;
    if (physical_step_complete) state.step_active = false;
    return true;
}

Referenced by erf_sbm::SBMTransport::advance_stage().

Here is the call graph for this function:

Here is the caller graph for this function:

begin_step()

bool erf_sbm::SBMStateManager::begin_step	(	int	lev,
		double	step_old_time,
		std::string &	diagnostic
	)

Rotate accepted new state into old state at the ERF::Advance seam.

{
    diagnostic.clear();
    auto& state = level(lev);
    if (!state.old_state || !state.new_state) {
        diagnostic = "SBM begin-step requested for an undefined level";
        return false;
    }
    if (!std::isfinite(step_old_time)) {
        diagnostic = "SBM begin-step time is nonfinite";
        return false;
    }
    if (state.step_active) {
        diagnostic = "SBM begin-step requested while the prior physical step is active";
        return false;
    }
    if (!state.new_valid) {
        diagnostic = "SBM begin-step has no accepted current/new spectrum";
        return false;
    }
    if (state.new_time != step_old_time) {
        std::ostringstream message;
        message.precision(17);
        message << "SBM begin-step time mismatch at level " << lev
                << ": expected host step-old time " << step_old_time
                << ", accepted spectral time " << state.new_time
                << ", lifecycle=accepted new state, step inactive";
        diagnostic = message.str();
        return false;
    }
 
    // Match ERF::Advance: rotate storage by swapping ownership, never by
    // copying the full spectral state.
    std::swap(state.old_state, state.new_state);
    state.old_time = state.new_time;
    state.old_valid = true;
    state.new_valid = false;
    state.step_active = true;
    return true;
}

Here is the call graph for this function:

define()

void erf_sbm::SBMStateManager::define	(	int	lev,
		const amrex::BoxArray &	grids,
		const amrex::DistributionMapping &	mapping,
		double	current_time,
		int	ngrow = 0
	)

{
    if (ngrow < 0) throw std::invalid_argument("SBM ghost width cannot be negative");
    if (!std::isfinite(current_time)) {
        throw std::invalid_argument("SBM current semantic time must be finite");
    }
    auto& state = level(lev);
    if (state.old_state || state.new_state) {
        throw std::logic_error("SBM level state is already defined");
    }
 
    state.old_state = std::make_unique<amrex::MultiFab>(
        grids, mapping, m_layout.ncomp(), ngrow);
    state.new_state = std::make_unique<amrex::MultiFab>(
        grids, mapping, m_layout.ncomp(), ngrow);
    // Both buffers are deterministic. Zero is a valid physical spectrum;
    // validity is carried only by the semantic flags below.
    state.old_state->setVal(amrex::Real(0.0));
    state.new_state->setVal(amrex::Real(0.0));
    state.old_valid = false;
    state.new_valid = true;
    state.old_time = 0.0;
    state.new_time = current_time;
    state.step_active = false;
}

Here is the call graph for this function:

destroy()

void erf_sbm::SBMStateManager::destroy

(

int

lev

)

{
    level(lev) = LevelState{};
}

Here is the call graph for this function:

is_defined()

bool erf_sbm::SBMStateManager::is_defined

(

int

lev

)

const

{
    const auto& state = level(lev);
    return state.old_state != nullptr && state.new_state != nullptr;
}

Referenced by erf_sbm::SBMTransport::advance_stage().

Here is the call graph for this function:

Here is the caller graph for this function:

layout()

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

inlinenoexcept

{ return m_layout; }

level() [1/2]

SBMStateManager::LevelState & erf_sbm::SBMStateManager::level ( int  lev )

private

{
    if (lev < 0 || lev >= nlevels()) throw std::out_of_range("SBM level is outside the manager");
    return m_levels[static_cast<std::size_t>(lev)];
}

Referenced by accept_stage_target(), begin_step(), define(), destroy(), is_defined(), new_state(), new_state_for_initialization(), new_target_storage(), new_time(), new_valid(), old_state(), old_time(), old_valid(), and step_active().

Here is the call graph for this function:

Here is the caller graph for this function:

level() [2/2]

const SBMStateManager::LevelState & erf_sbm::SBMStateManager::level ( int  lev ) const

private

{
    if (lev < 0 || lev >= nlevels()) throw std::out_of_range("SBM level is outside the manager");
    return m_levels[static_cast<std::size_t>(lev)];
}

Here is the call graph for this function:

new_state()

const amrex::MultiFab & erf_sbm::SBMStateManager::new_state

(

int

lev

)

const

Accepted/current state. Throws while the target buffer is invalid.

{
    const auto& state = level(lev);
    if (!state.new_state || !state.new_valid) {
        throw std::logic_error("SBM new spectral view is invalid until a stage is accepted");
    }
    return *state.new_state;
}

Referenced by erf_sbm::SBMTransport::advance_stage(), new_time(), and project_to_core().

Here is the call graph for this function:

Here is the caller graph for this function:

new_state_for_initialization()

amrex::MultiFab & erf_sbm::SBMStateManager::new_state_for_initialization

(

int

lev

)

Mutable accepted state for initialization and synchronized restart I/O.

{
    auto& state = level(lev);
    if (!state.new_state || !state.new_valid || state.old_valid || state.step_active) {
        throw std::logic_error(
            "SBM accepted new state can be edited only before the first physical step");
    }
    return *state.new_state;
}

Here is the call graph for this function:

new_target_storage()

amrex::MultiFab & erf_sbm::SBMStateManager::new_target_storage

(

int

lev

)

Mutable target storage for transport; semantic reads remain invalid until accepted.

{
    auto& state = level(lev);
    if (!state.new_state || !state.step_active) {
        throw std::logic_error("SBM new target storage requires an active physical step");
    }
    return *state.new_state;
}

Referenced by erf_sbm::SBMTransport::advance_stage().

Here is the call graph for this function:

Here is the caller graph for this function:

new_time()

double erf_sbm::SBMStateManager::new_time

(

int

lev

)

const

{
    static_cast<void>(new_state(lev));
    return level(lev).new_time;
}

Referenced by erf_sbm::SBMTransport::advance_stage().

Here is the call graph for this function:

Here is the caller graph for this function:

new_valid()

bool erf_sbm::SBMStateManager::new_valid

(

int

lev

)

const

{
    return level(lev).new_state != nullptr && level(lev).new_valid;
}

Here is the call graph for this function:

nlevels()

int erf_sbm::SBMStateManager::nlevels ( ) const

inlinenoexcept

{ return static_cast<int>(m_levels.size()); }

Referenced by level(), and SBMStateManager().

Here is the caller graph for this function:

old_state()

const amrex::MultiFab & erf_sbm::SBMStateManager::old_state

(

int

lev

)

const

Accepted state at the beginning of an active physical step.

{
    const auto& state = level(lev);
    if (!state.old_state || !state.old_valid) {
        throw std::logic_error("SBM old spectral view is invalid at this lifecycle point");
    }
    return *state.old_state;
}

Referenced by erf_sbm::SBMTransport::advance_stage(), and old_time().

Here is the call graph for this function:

Here is the caller graph for this function:

old_time()

double erf_sbm::SBMStateManager::old_time

(

int

lev

)

const

{
    static_cast<void>(old_state(lev));
    return level(lev).old_time;
}

Referenced by erf_sbm::SBMTransport::advance_stage().

Here is the call graph for this function:

Here is the caller graph for this function:

old_valid()

bool erf_sbm::SBMStateManager::old_valid

(

int

lev

)

const

{
    return level(lev).old_state != nullptr && level(lev).old_valid;
}

Here is the call graph for this function:

project_to_core()

void erf_sbm::SBMStateManager::project_to_core	(	int	lev,
		amrex::MultiFab &	core,
		int	qc_component,
		int	qr_component
	)		const

One-way projection from the spectrum into ERF's compact qc and qr lanes.

{
    const auto& spectrum = new_state(lev);
    if (qc_component < 0 || qr_component < 0 ||
        qc_component >= core.nComp() || qr_component >= core.nComp()) {
        throw std::invalid_argument("SBM compact projection target is outside core state");
    }
    if (!(spectrum.boxArray() == core.boxArray()) ||
        !(spectrum.DistributionMap() == core.DistributionMap())) {
        throw std::invalid_argument("SBM spectrum and core state must share a level layout");
    }
    for (amrex::MFIter mfi(core); mfi.isValid(); ++mfi) {
        m_projection.apply_to_core(mfi.validbox(), spectrum.const_array(mfi),
                                   core.array(mfi), qc_component, qr_component);
    }
}

Referenced by erf_sbm::SBMTransport::advance_stage().

Here is the call graph for this function:

Here is the caller graph for this function:

step_active()

bool erf_sbm::SBMStateManager::step_active

(

int

lev

)

const

{
    return level(lev).step_active;
}

Referenced by erf_sbm::SBMTransport::advance_stage().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_layout

SBMLayout erf_sbm::SBMStateManager::m_layout

private

Referenced by define(), and layout().

m_levels

std::vector<LevelState> erf_sbm::SBMStateManager::m_levels

private

Referenced by level(), nlevels(), and SBMStateManager().

m_projection

SBMBulkProjection erf_sbm::SBMStateManager::m_projection

private

Referenced by project_to_core().

---

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

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