erf_auxiliary::CompletedStepFluxLedger Class Reference

#include <ERF_AuxiliaryStage.H>

Collaboration diagram for erf_auxiliary::CompletedStepFluxLedger:

Public Member Functions
	CompletedStepFluxLedger ()=default
	CompletedStepFluxLedger (const CompletedStepFluxLedger &)=delete
CompletedStepFluxLedger &	operator= (const CompletedStepFluxLedger &)=delete
void	define (const amrex::BoxArray &cell_ba, const amrex::DistributionMapping &dm, int ncomp=1)
bool	accept_stage (HostIntegrator method, int stage, double step_old_time, const AuxiliaryStageRecipe &recipe, const MappedFaceFluxRate &rate, std::string &diagnostic)
bool	begin_stage (HostIntegrator method, int stage, double step_old_time, const AuxiliaryStageRecipe &recipe, std::string &diagnostic)
bool	accumulate_stage_component (const MappedFaceFluxRate &rate, int source_component, int ledger_component, std::string &diagnostic)
bool	finish_stage (std::string &diagnostic)
bool	is_defined () const noexcept
bool	step_active () const noexcept
bool	step_complete () const noexcept
int	next_stage () const noexcept
const IntegratedMappedFaceFlux &	integrated_flux () const noexcept

Private Member Functions
void	latch_stage_failure (const std::string &diagnostic)
void	discard_step ()

Private Attributes
IntegratedMappedFaceFlux	m_integral
bool	m_step_active {false}
bool	m_step_complete {false}
bool	m_stage_open {false}
HostIntegrator	m_method {HostIntegrator::CompressibleRK3}
int	m_next_stage {0}
int	m_open_stage {-1}
amrex::Real	m_open_stage_weight {0.0}
double	m_step_old_time {0.0}
std::vector< unsigned char >	m_stage_components_seen
std::string	m_stage_failure_diagnostic

Detailed Description

Completed-step time integral of accepted mapped face rates and stage order.

Constructor & Destructor Documentation

CompletedStepFluxLedger() [1/2]

erf_auxiliary::CompletedStepFluxLedger::CompletedStepFluxLedger ( )

default

CompletedStepFluxLedger() [2/2]

erf_auxiliary::CompletedStepFluxLedger::CompletedStepFluxLedger ( const CompletedStepFluxLedger &  )

delete

Member Function Documentation

accept_stage()

bool erf_auxiliary::CompletedStepFluxLedger::accept_stage	(	HostIntegrator	method,
		int	stage,
		double	step_old_time,
		const AuxiliaryStageRecipe &	recipe,
		const MappedFaceFluxRate &	rate,
		std::string &	diagnostic
	)

MPI-collective completed-stage admission. All participating ranks must enter for the same host stage, including after a local recoverable error; callers must not branch around the call based on rank-local predicates. Asynchronous rank-local Abort or MPI process failure is outside this protection. A rejected in-progress transaction discards its partial accepted transfers everywhere. If every rank instead has a valid completed prior step and no rank has begun the next step, rejection leaves that prior completed transfer intact. Starting a valid new step invalidates the previous completed record. Read a transfer as accepted only while step_complete() is true; this object does not provide a retained snapshot.

{
    diagnostic.clear();
    bool local_stage_ok = true;
    if (!is_defined() || !rate.is_defined() || rate.nComp() != m_integral.nComp()) {
        diagnostic = "completed-step ledger and face-rate layouts are not defined compatibly";
        latch_stage_failure(diagnostic);
        local_stage_ok = false;
    } else if (!SameMappedFaceLayout(m_integral, rate)) {
        diagnostic = "completed-step ledger and face-rate BoxArray/DistributionMapping do not match";
        latch_stage_failure(diagnostic);
        local_stage_ok = false;
    }
    if (local_stage_ok) {
        local_stage_ok = begin_stage(method, stage, step_old_time, recipe, diagnostic);
    }
    if (local_stage_ok) {
        for (int component = 0; component < rate.nComp(); ++component) {
            if (!accumulate_stage_component(rate, component, component, diagnostic)) {
                local_stage_ok = false;
                break;
            }
        }
    }
    const bool accepted = finish_stage(diagnostic);
    return local_stage_ok && accepted;
}

Here is the call graph for this function:

accumulate_stage_component()

bool erf_auxiliary::CompletedStepFluxLedger::accumulate_stage_component	(	const MappedFaceFluxRate &	rate,
		int	source_component,
		int	ledger_component,
		std::string &	diagnostic
	)

Add one accepted source component to its global ledger component.

{
    diagnostic.clear();
    const auto fail = [this, &diagnostic] () {
        latch_stage_failure(diagnostic);
        return false;
    };
    if (!m_stage_open || !m_step_active || m_open_stage != m_next_stage) {
        diagnostic = "spectral component accumulation requires an open host stage";
        return fail();
    }
    if (!rate.is_defined() || !SameMappedFaceLayout(m_integral, rate)) {
        diagnostic = "completed-step ledger and chunk face-rate layouts do not match";
        return fail();
    }
    if (source_component < 0 || source_component >= rate.nComp() ||
        ledger_component < 0 || ledger_component >= m_integral.nComp()) {
        diagnostic = "completed-step chunk component is outside its source or destination";
        return fail();
    }
    auto& seen = m_stage_components_seen[static_cast<std::size_t>(ledger_component)];
    if (seen != 0) {
        diagnostic = "completed-step stage contains a duplicate destination component";
        return fail();
    }
 
    for (int dir = 0; dir < AMREX_SPACEDIM; ++dir) {
        amrex::MultiFab::Saxpy(m_integral.dir(dir), m_open_stage_weight,
                               rate.dir(dir), source_component,
                               ledger_component, 1, 0);
    }
    seen = 1;
    return true;
}

Referenced by accept_stage().

Here is the call graph for this function:

Here is the caller graph for this function:

begin_stage()

bool erf_auxiliary::CompletedStepFluxLedger::begin_stage	(	HostIntegrator	method,
		int	stage,
		double	step_old_time,
		const AuxiliaryStageRecipe &	recipe,
		std::string &	diagnostic
	)

Begin one host stage; chunk accumulation does not advance stage order.

{
    diagnostic.clear();
    if (!m_stage_failure_diagnostic.empty()) {
        diagnostic = m_stage_failure_diagnostic;
        return false;
    }
    if (!is_defined()) {
        diagnostic = "completed-step ledger storage is not defined";
        latch_stage_failure(diagnostic);
        return false;
    }
    if (method == HostIntegrator::AnelasticMidPoint) {
        diagnostic = "AnelasticMidPoint completed-step ledger is not qualified by M2";
        latch_stage_failure(diagnostic);
        return false;
    }
    if (stage < 0 || stage >= stage_count(method)) {
        diagnostic = "stage index is outside the completed-step ledger sequence";
        latch_stage_failure(diagnostic);
        return false;
    }
    if (!std::isfinite(step_old_time) ||
        !finite_nonnegative(recipe.anchor_weight) ||
        !finite_nonnegative(recipe.input_weight) ||
        !std::isfinite(recipe.limiter_trial_interval) || recipe.limiter_trial_interval <= 0.0 ||
        !std::isfinite(recipe.face_rate_time_coefficient) || recipe.face_rate_time_coefficient <= 0.0 ||
        !finite_nonnegative(recipe.completed_ledger_time)) {
        diagnostic = "completed-step ledger received an invalid temporal coefficient";
        latch_stage_failure(diagnostic);
        return false;
    }
    const amrex::Real stage_weight =
        static_cast<amrex::Real>(recipe.completed_ledger_time);
    if (!amrex::Math::isfinite(stage_weight) || stage_weight < amrex::Real(0.0)) {
        diagnostic = "completed-step ledger weight is not representable in amrex::Real";
        latch_stage_failure(diagnostic);
        return false;
    }
    if (m_stage_open) {
        diagnostic = "a completed-step ledger stage transaction is already open";
        latch_stage_failure(diagnostic);
        return false;
    }
 
    if (stage == 0) {
        if (m_step_active) {
            diagnostic = "stage 0 arrived while the previous auxiliary step was unfinished";
            latch_stage_failure(diagnostic);
            return false;
        }
        m_integral.setVal(amrex::Real(0.0));
        m_step_active = true;
        m_step_complete = false;
        m_method = method;
        m_step_old_time = step_old_time;
        m_next_stage = 0;
    } else {
        if (!m_step_active) {
            diagnostic = "auxiliary stage arrived before stage 0";
            latch_stage_failure(diagnostic);
            return false;
        }
        if (method != m_method) {
            diagnostic = "host integrator changed during an auxiliary timestep";
            latch_stage_failure(diagnostic);
            return false;
        }
        if (step_old_time != m_step_old_time) {
            diagnostic = "step-old time changed during an auxiliary timestep";
            latch_stage_failure(diagnostic);
            return false;
        }
    }
    if (stage != m_next_stage) {
        diagnostic = "duplicate, skipped, or out-of-order auxiliary stage";
        latch_stage_failure(diagnostic);
        return false;
    }
 
    std::fill(m_stage_components_seen.begin(), m_stage_components_seen.end(), 0);
    m_stage_open = true;
    m_open_stage = stage;
    m_open_stage_weight = stage_weight;
    return true;
}

Referenced by accept_stage().

Here is the call graph for this function:

Here is the caller graph for this function:

define()

void erf_auxiliary::CompletedStepFluxLedger::define	(	const amrex::BoxArray &	cell_ba,
		const amrex::DistributionMapping &	dm,
		int	ncomp = 1
	)

{
    m_integral.define(cell_ba, dm, ncomp, 0);
    m_integral.setVal(amrex::Real(0.0));
    m_step_active = false;
    m_step_complete = false;
    m_stage_open = false;
    m_next_stage = 0;
    m_open_stage = -1;
    m_open_stage_weight = amrex::Real(0.0);
    m_step_old_time = 0.0;
    m_stage_components_seen.assign(static_cast<std::size_t>(ncomp), 0);
    m_stage_failure_diagnostic.clear();
}

Here is the call graph for this function:

discard_step()

void erf_auxiliary::CompletedStepFluxLedger::discard_step ( )

private

{
    if (m_integral.is_defined()) {
        m_integral.setVal(amrex::Real(0.0));
    }
    m_step_active = false;
    m_step_complete = false;
    m_stage_open = false;
    m_next_stage = 0;
    m_open_stage = -1;
    m_open_stage_weight = amrex::Real(0.0);
    m_step_old_time = 0.0;
    std::fill(m_stage_components_seen.begin(), m_stage_components_seen.end(), 0);
    m_stage_failure_diagnostic.clear();
}

Referenced by finish_stage().

Here is the call graph for this function:

Here is the caller graph for this function:

finish_stage()

bool erf_auxiliary::CompletedStepFluxLedger::finish_stage

(

std::string &

diagnostic

)

MPI-collective stage admission. Every rank participating in this level's call must enter despite local recoverable errors; callers must not branch around it using rank-local predicates. Incomplete, invalid, mismatched, or nonfinite in-progress stages invalidate the partial record everywhere. If all ranks instead have a completed prior step and no active next step, a rejected idle call preserves that prior record. A valid new stage zero invalidates it. A rank that never enters, asynchronous Abort, or MPI process failure is outside this protection.

{
    diagnostic.clear();
    if (!m_stage_failure_diagnostic.empty()) {
        diagnostic = m_stage_failure_diagnostic;
    }
    const bool local_stage_valid =
        m_stage_failure_diagnostic.empty() && m_stage_open && m_step_active &&
        m_open_stage == m_next_stage &&
        m_open_stage >= 0 && m_open_stage < stage_count(m_method);
    if (!local_stage_valid && diagnostic.empty()) {
        diagnostic = "completed-step stage finish requires an open host stage";
    }
 
    bool all_components_seen = true;
    for (std::size_t component = 0; component < m_stage_components_seen.size(); ++component) {
        if (m_stage_components_seen[component] == 0) {
            all_components_seen = false;
            if (diagnostic.empty()) {
                diagnostic =
                    "completed-step stage omitted destination component " +
                    std::to_string(component);
            }
        }
    }
 
    // Reserve disjoint ranges for each logical host integrator.  A zero code
    // means that this rank has no locally valid, complete stage transaction.
    int local_stage_code = 0;
    if (local_stage_valid && all_components_seen) {
        switch (m_method) {
        case HostIntegrator::CompressibleRK3:
            local_stage_code = 1 + m_open_stage;
            break;
        case HostIntegrator::AnelasticHeun:
            local_stage_code = 4 + m_open_stage;
            break;
        case HostIntegrator::AnelasticMidPoint:
            local_stage_code = 7 + m_open_stage;
            break;
        }
    }
    const bool completes_step = local_stage_code != 0 &&
                                m_next_stage + 1 == stage_count(m_method);
    bool locally_finite = true;
    if (completes_step) {
        for (int dir = 0; dir < AMREX_SPACEDIM; ++dir) {
            locally_finite =
                m_integral.dir(dir).is_finite(0, m_integral.nComp(), 0, true) &&
                locally_finite;
        }
    }
    const int prior_complete_and_idle =
        m_step_complete && !m_step_active && !m_stage_open ? 1 : 0;
    int vote[4] = {local_stage_code, -local_stage_code, locally_finite ? 0 : -1,
                   prior_complete_and_idle};
    amrex::ParallelDescriptor::ReduceIntMin(vote, 4);
    const bool stage_agreed = vote[0] != 0 && vote[0] == -vote[1];
    const bool globally_finite = vote[2] == 0;
    const bool all_prior_complete_and_idle = vote[3] == 1;
    if (!stage_agreed || !globally_finite) {
        if (!stage_agreed && diagnostic.empty()) {
            diagnostic = vote[0] == 0
                             ? "completed-step stage is invalid or incomplete on another MPI rank"
                             : "completed-step stage identity differs across MPI ranks";
        } else if (stage_agreed && !globally_finite && diagnostic.empty()) {
            diagnostic = locally_finite
                             ? "completed-step integrated face transfer is nonfinite on another MPI rank"
                             : "completed-step integrated face transfer is nonfinite";
        }
        if (all_prior_complete_and_idle) {
            // Keep the diagnostic for this rejected call, but allow a later
            // valid stage zero to start a fresh transaction.
            m_stage_failure_diagnostic.clear();
        } else {
            discard_step();
        }
        return false;
    }
 
    m_stage_open = false;
    m_open_stage = -1;
    m_open_stage_weight = amrex::Real(0.0);
    ++m_next_stage;
    if (completes_step) {
        m_step_active = false;
        m_step_complete = true;
    }
    m_stage_failure_diagnostic.clear();
    return true;
}

Referenced by accept_stage().

Here is the call graph for this function:

Here is the caller graph for this function:

integrated_flux()

const IntegratedMappedFaceFlux& erf_auxiliary::CompletedStepFluxLedger::integrated_flux ( ) const

inlinenoexcept

                                                                                    {
        return m_integral;
    }

is_defined()

bool erf_auxiliary::CompletedStepFluxLedger::is_defined ( ) const

inlinenoexcept

{ return m_integral.is_defined(); }

Referenced by accept_stage(), and begin_stage().

Here is the call graph for this function:

Here is the caller graph for this function:

latch_stage_failure()

void erf_auxiliary::CompletedStepFluxLedger::latch_stage_failure ( const std::string &  diagnostic )

private

{
    if (m_stage_failure_diagnostic.empty()) {
        m_stage_failure_diagnostic = diagnostic.empty()
                                         ? "completed-step ledger stage operation failed"
                                         : diagnostic;
    }
}

Referenced by accept_stage(), accumulate_stage_component(), and begin_stage().

Here is the caller graph for this function:

next_stage()

int erf_auxiliary::CompletedStepFluxLedger::next_stage ( ) const

inlinenoexcept

{ return m_next_stage; }

operator=()

CompletedStepFluxLedger& erf_auxiliary::CompletedStepFluxLedger::operator= ( const CompletedStepFluxLedger &  )

delete

step_active()

bool erf_auxiliary::CompletedStepFluxLedger::step_active ( ) const

inlinenoexcept

{ return m_step_active; }

step_complete()

bool erf_auxiliary::CompletedStepFluxLedger::step_complete ( ) const

inlinenoexcept

{ return m_step_complete; }

Member Data Documentation

m_integral

IntegratedMappedFaceFlux erf_auxiliary::CompletedStepFluxLedger::m_integral

private

Referenced by accept_stage(), accumulate_stage_component(), begin_stage(), define(), discard_step(), finish_stage(), integrated_flux(), and is_defined().

m_method

HostIntegrator erf_auxiliary::CompletedStepFluxLedger::m_method {HostIntegrator::CompressibleRK3}

private

Referenced by begin_stage(), and finish_stage().

m_next_stage

int erf_auxiliary::CompletedStepFluxLedger::m_next_stage {0}

private

Referenced by accumulate_stage_component(), begin_stage(), define(), discard_step(), finish_stage(), and next_stage().

m_open_stage

int erf_auxiliary::CompletedStepFluxLedger::m_open_stage {-1}

private

Referenced by accumulate_stage_component(), begin_stage(), define(), discard_step(), and finish_stage().

m_open_stage_weight

amrex::Real erf_auxiliary::CompletedStepFluxLedger::m_open_stage_weight {0.0}

private

Referenced by accumulate_stage_component(), begin_stage(), define(), discard_step(), and finish_stage().

m_stage_components_seen

std::vector<unsigned char> erf_auxiliary::CompletedStepFluxLedger::m_stage_components_seen

private

Referenced by accumulate_stage_component(), begin_stage(), define(), discard_step(), and finish_stage().

m_stage_failure_diagnostic

std::string erf_auxiliary::CompletedStepFluxLedger::m_stage_failure_diagnostic

private

Referenced by begin_stage(), define(), discard_step(), finish_stage(), and latch_stage_failure().

m_stage_open

bool erf_auxiliary::CompletedStepFluxLedger::m_stage_open {false}

private

Referenced by accumulate_stage_component(), begin_stage(), define(), discard_step(), and finish_stage().

m_step_active

bool erf_auxiliary::CompletedStepFluxLedger::m_step_active {false}

private

Referenced by accumulate_stage_component(), begin_stage(), define(), discard_step(), finish_stage(), and step_active().

m_step_complete

bool erf_auxiliary::CompletedStepFluxLedger::m_step_complete {false}

private

Referenced by begin_stage(), define(), discard_step(), finish_stage(), and step_complete().

m_step_old_time

double erf_auxiliary::CompletedStepFluxLedger::m_step_old_time {0.0}

private

Referenced by begin_stage(), define(), and discard_step().

---

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

• Source/AuxiliaryState/ERF_AuxiliaryStage.H
• Source/AuxiliaryState/ERF_AuxiliaryStage.cpp