erf_sbm::remap_detail Namespace Reference

Classes
struct	RemapCellStateView

Enumerations
enum class	ProductStatus { Ok , Underflow , Invalid }
enum class	QuotientStatus { Ok , Underflow , Invalid }

Functions
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool	finite_nonnegative (const amrex::Real value) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE ProductStatus	checked_product (const amrex::Real left, const amrex::Real right, amrex::Real &result) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE QuotientStatus	checked_quotient (const amrex::Real numerator, const amrex::Real denominator, amrex::Real &result) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool	finite_product (const amrex::Real left, const amrex::Real right, amrex::Real &result) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE RemapStatus	remap_product_status (const ProductStatus status) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE RemapStatus	remap_quotient_status (const QuotientStatus status) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool	within_boundary_roundoff (const amrex::Real value, const amrex::Real endpoint, const bool lower_boundary) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool	route_plan_is_consistent (const PopulationRemapView &population, const PacketRoutingPlan &plan) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool	canonical_two_moment_moments (const PopulationRemapView &population, const int bin, const amrex::Real number, const amrex::Real mass) noexcept
template<typename StateView >
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool	canonical_two_moment_bin_state_view (const PopulationRemapView &population, const int bin, const StateView &state, const int state_count) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool	canonical_two_moment_bin_state (const PopulationRemapView &population, const int bin, const amrex::Real *state, const int state_count) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool	canonical_two_moment_bin_state (const PopulationRemapView &population, const int bin, const RemapCellStateView &state, const int state_count) noexcept
template<typename StateView >
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool	canonical_one_moment_bin_state_view (const PopulationRemapView &population, const int bin, const StateView &state, const int state_count) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool	canonical_one_moment_bin_state (const PopulationRemapView &population, const int bin, const amrex::Real *state, const int state_count) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool	canonical_one_moment_bin_state (const PopulationRemapView &population, const int bin, const RemapCellStateView &state, const int state_count) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool	canonical_persisted_bin_state (const PopulationRemapView &population, const int bin, const amrex::Real *state, const int state_count) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool	canonical_persisted_bin_state (const PopulationRemapView &population, const int bin, const RemapCellStateView &state, const int state_count) noexcept

Enumeration Type Documentation

ProductStatus

enum erf_sbm::remap_detail::ProductStatus

strong

Enumerator
Ok
Underflow
Invalid

{ Ok, Underflow, Invalid };

QuotientStatus

enum erf_sbm::remap_detail::QuotientStatus

strong

Enumerator
Ok
Underflow
Invalid

{ Ok, Underflow, Invalid };

Function Documentation

canonical_one_moment_bin_state() [1/2]

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool erf_sbm::remap_detail::canonical_one_moment_bin_state ( const PopulationRemapView &  population, const int  bin, const amrex::Real *  state, const int  state_count  )

noexcept

{
    if (state == nullptr) return false;
    return canonical_one_moment_bin_state_view(population, bin, state, state_count);
}

Referenced by canonical_persisted_bin_state().

Here is the call graph for this function:

Here is the caller graph for this function:

canonical_one_moment_bin_state() [2/2]

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool erf_sbm::remap_detail::canonical_one_moment_bin_state ( const PopulationRemapView &  population, const int  bin, const RemapCellStateView &  state, const int  state_count  )

noexcept

{
    return canonical_one_moment_bin_state_view(population, bin, state, state_count);
}

Here is the call graph for this function:

canonical_one_moment_bin_state_view()

template<typename StateView >

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool erf_sbm::remap_detail::canonical_one_moment_bin_state_view ( const PopulationRemapView &  population, const int  bin, const StateView &  state, const int  state_count  )

noexcept

Strict persisted-state test for a one-moment bin and its attached inventories.

{
    if (!valid_population_remap_context(population) ||
        state_count != population.state_components || bin < 0 || bin >= population.nbins ||
        population.moment_mode != MomentMode::OneMoment) return false;
    const amrex::Real mass = state[population.mass_offset + bin];
    if (!finite_nonnegative(mass)) return false;
    amrex::Real number = amrex::Real(0.0);
    if (checked_quotient(mass, population.pivots[bin], number) != QuotientStatus::Ok) {
        return false;
    }
    for (int property = 0; property < population.property_count; ++property) {
        const amrex::Real amount = state[population.property_component_offsets[property] + bin];
        if (!finite_nonnegative(amount)) return false;
        if (number == amrex::Real(0.0)) {
            if (amount != amrex::Real(0.0)) return false;
        } else {
            amrex::Real per_particle = amrex::Real(0.0);
            if (checked_quotient(amount, number, per_particle) != QuotientStatus::Ok) {
                return false;
            }
        }
    }
    return true;
}

Referenced by canonical_one_moment_bin_state().

Here is the call graph for this function:

Here is the caller graph for this function:

canonical_persisted_bin_state() [1/2]

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool erf_sbm::remap_detail::canonical_persisted_bin_state ( const PopulationRemapView &  population, const int  bin, const amrex::Real *  state, const int  state_count  )

noexcept

Shared admission rule for every persisted bin accepted by reconstruction.

{
    return population.moment_mode == MomentMode::OneMoment ?
        canonical_one_moment_bin_state(population, bin, state, state_count) :
        canonical_two_moment_bin_state(population, bin, state, state_count);
}

Referenced by erf_sbm::SBMTransport::advance_stage(), erf_sbm::authoritative_state_admissible(), erf_sbm::reconstruct_bin_core(), and erf_sbm::validate_fixture_initial_state_canonicality().

Here is the call graph for this function:

Here is the caller graph for this function:

canonical_persisted_bin_state() [2/2]

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool erf_sbm::remap_detail::canonical_persisted_bin_state ( const PopulationRemapView &  population, const int  bin, const RemapCellStateView &  state, const int  state_count  )

noexcept

{
    return population.moment_mode == MomentMode::OneMoment ?
        canonical_one_moment_bin_state(population, bin, state, state_count) :
        canonical_two_moment_bin_state(population, bin, state, state_count);
}

Here is the call graph for this function:

canonical_two_moment_bin_state() [1/2]

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool erf_sbm::remap_detail::canonical_two_moment_bin_state ( const PopulationRemapView &  population, const int  bin, const amrex::Real *  state, const int  state_count  )

noexcept

{
    if (state == nullptr) return false;
    return canonical_two_moment_bin_state_view(population, bin, state, state_count);
}

Referenced by erf_sbm::authoritative_state_admissible(), canonical_persisted_bin_state(), and erf_sbm::reconstruct_bin_core().

Here is the call graph for this function:

Here is the caller graph for this function:

canonical_two_moment_bin_state() [2/2]

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool erf_sbm::remap_detail::canonical_two_moment_bin_state ( const PopulationRemapView &  population, const int  bin, const RemapCellStateView &  state, const int  state_count  )

noexcept

{
    return canonical_two_moment_bin_state_view(population, bin, state, state_count);
}

Here is the call graph for this function:

canonical_two_moment_bin_state_view()

template<typename StateView >

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool erf_sbm::remap_detail::canonical_two_moment_bin_state_view ( const PopulationRemapView &  population, const int  bin, const StateView &  state, const int  state_count  )

noexcept

Strict persisted-state test shared by reconstruction, restart, and fixtures.

{
    if (!valid_population_remap_context(population) ||
        state_count != population.state_components || bin < 0 || bin >= population.nbins ||
        population.moment_mode != MomentMode::TwoMoment) return false;
    const amrex::Real mass = state[population.mass_offset + bin];
    const amrex::Real number = state[population.number_offset + bin];
    if (!canonical_two_moment_moments(population, bin, number, mass)) return false;
    if (number == amrex::Real(0.0)) {
        for (int property = 0; property < population.property_count; ++property) {
            if (state[population.property_component_offsets[property] + bin] != amrex::Real(0.0)) {
                return false;
            }
        }
    }
    for (int property = 0; property < population.property_count; ++property) {
        const amrex::Real amount = state[population.property_component_offsets[property] + bin];
        if (!finite_nonnegative(amount)) return false;
        if (number == amrex::Real(0.0)) continue;
        amrex::Real per_particle = amrex::Real(0.0);
        if (checked_quotient(amount, number, per_particle) != QuotientStatus::Ok) return false;
    }
    return true;
}

Referenced by canonical_two_moment_bin_state().

Here is the call graph for this function:

Here is the caller graph for this function:

canonical_two_moment_moments()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool erf_sbm::remap_detail::canonical_two_moment_moments ( const PopulationRemapView &  population, const int  bin, const amrex::Real  number, const amrex::Real  mass  )

noexcept

{
    if (!valid_population_remap_context(population) ||
        population.moment_mode != MomentMode::TwoMoment || bin < 0 || bin >= population.nbins ||
        !finite_nonnegative(number) || !finite_nonnegative(mass)) return false;
    if (number == amrex::Real(0.0)) return mass == amrex::Real(0.0);
    if (mass <= amrex::Real(0.0)) return false;
    amrex::Real mean = amrex::Real(0.0);
    if (checked_quotient(mass, number, mean) != QuotientStatus::Ok) return false;
    const amrex::Real lower = population.edges[bin];
    const amrex::Real upper = population.edges[bin + 1];
    return amrex::Math::isfinite(mean) && mean >= lower &&
           (mean < upper || (bin == population.nbins - 1 && mean <= upper));
}

Referenced by erf_sbm::apply_packet_routing_core(), canonical_two_moment_bin_state_view(), and erf_sbm::project_reconstruction_bin_core().

Here is the call graph for this function:

Here is the caller graph for this function:

checked_product()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE ProductStatus erf_sbm::remap_detail::checked_product ( const amrex::Real  left, const amrex::Real  right, amrex::Real &  result  )

noexcept

{
    if (!finite_nonnegative(left) || !finite_nonnegative(right)) return ProductStatus::Invalid;
    result = left * right;
    if (!amrex::Math::isfinite(result)) return ProductStatus::Invalid;
    if (left > amrex::Real(0.0) && right > amrex::Real(0.0) &&
        result == amrex::Real(0.0)) return ProductStatus::Underflow;
    return ProductStatus::Ok;
}

Referenced by erf_sbm::apply_packet_routing_core(), and finite_product().

Here is the call graph for this function:

Here is the caller graph for this function:

checked_quotient()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE QuotientStatus erf_sbm::remap_detail::checked_quotient ( const amrex::Real  numerator, const amrex::Real  denominator, amrex::Real &  result  )

noexcept

{
    if (!finite_nonnegative(numerator) || !amrex::Math::isfinite(denominator) ||
        !(denominator > amrex::Real(0.0))) return QuotientStatus::Invalid;
    result = numerator / denominator;
    if (!amrex::Math::isfinite(result)) return QuotientStatus::Invalid;
    if (numerator > amrex::Real(0.0) && result == amrex::Real(0.0)) {
        return QuotientStatus::Underflow;
    }
    return QuotientStatus::Ok;
}

Referenced by erf_sbm::apply_packet_routing_core(), canonical_one_moment_bin_state_view(), canonical_two_moment_bin_state_view(), canonical_two_moment_moments(), erf_sbm::plan_packet_routing(), erf_sbm::project_reconstruction_bin_core(), erf_sbm::reconstruct_bin_core(), and route_plan_is_consistent().

Here is the call graph for this function:

Here is the caller graph for this function:

finite_nonnegative()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool erf_sbm::remap_detail::finite_nonnegative ( const amrex::Real  value )

noexcept

{
    return amrex::Math::isfinite(value) && value >= amrex::Real(0.0);
}

Referenced by erf_sbm::apply_packet_routing_core(), erf_auxiliary::CompletedStepFluxLedger::begin_stage(), canonical_one_moment_bin_state_view(), canonical_two_moment_bin_state_view(), canonical_two_moment_moments(), checked_product(), checked_quotient(), erf_sbm::integrate_interval_core(), erf_sbm::project_reconstruction_bin_core(), erf_sbm::reconstruct_bin_core(), and route_plan_is_consistent().

Here is the caller graph for this function:

finite_product()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool erf_sbm::remap_detail::finite_product ( const amrex::Real  left, const amrex::Real  right, amrex::Real &  result  )

noexcept

{
    return checked_product(left, right, result) == ProductStatus::Ok;
}

Referenced by erf_sbm::integrate_interval_core(), and erf_sbm::project_reconstruction_bin_core().

Here is the call graph for this function:

Here is the caller graph for this function:

remap_product_status()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE RemapStatus erf_sbm::remap_detail::remap_product_status ( const ProductStatus  status )

noexcept

{
    return status == ProductStatus::Underflow ? RemapStatus::NumericalUnderflow :
           status == ProductStatus::Ok ? RemapStatus::Ok : RemapStatus::Invalid;
}

Referenced by erf_sbm::apply_packet_routing_core().

Here is the caller graph for this function:

remap_quotient_status()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE RemapStatus erf_sbm::remap_detail::remap_quotient_status ( const QuotientStatus  status )

noexcept

{
    return status == QuotientStatus::Underflow ? RemapStatus::NumericalUnderflow :
           status == QuotientStatus::Ok ? RemapStatus::Ok : RemapStatus::Invalid;
}

Referenced by erf_sbm::apply_packet_routing_core(), and erf_sbm::plan_packet_routing().

Here is the caller graph for this function:

route_plan_is_consistent()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool erf_sbm::remap_detail::route_plan_is_consistent ( const PopulationRemapView &  population, const PacketRoutingPlan &  plan  )

noexcept

Validate a route against its local claimed bin(s), without searching.

{
    if (!valid_population_remap_context(population) ||
        !same_population_context(population, plan.population) ||
        !amrex::Math::isfinite(plan.packet_number) ||
        !amrex::Math::isfinite(plan.packet_particle_mass) ||
        plan.packet_number < amrex::Real(0.0) || plan.packet_particle_mass < amrex::Real(0.0) ||
        plan.destination_count < 0 || plan.destination_count > 2 ||
        !finite_nonnegative(plan.residual_number_weight) ||
        plan.residual_number_weight > amrex::Real(1.0)) return false;
 
    if (plan.packet_number == amrex::Real(0.0)) {
        return plan.status == RemapStatus::Ok && plan.destination_count == 0 &&
               plan.residual_number_weight == amrex::Real(0.0) &&
               !plan.normalized_roundoff;
    }
 
    if (population.moment_mode == MomentMode::TwoMoment) {
        if (plan.packet_particle_mass == amrex::Real(0.0)) {
            return plan.status == RemapStatus::ZeroWaterResidual &&
                   plan.destination_count == 0 &&
                   plan.residual_number_weight == amrex::Real(1.0) &&
                   !plan.normalized_roundoff;
        }
        const amrex::Real lower = population.edges[0];
        const amrex::Real top = population.edges[population.nbins];
        int required_bin = -1;
        amrex::Real expected_mass = plan.packet_particle_mass;
        bool normalized = false;
        if (plan.packet_particle_mass < lower) {
            if (!within_boundary_roundoff(plan.packet_particle_mass, lower, true)) return false;
            required_bin = 0;
            expected_mass = lower;
            normalized = true;
        } else if (plan.packet_particle_mass > top) {
            if (!within_boundary_roundoff(plan.packet_particle_mass, top, false)) return false;
            required_bin = population.nbins - 1;
            expected_mass = top;
            normalized = true;
        }
        if (plan.status != RemapStatus::Ok || plan.destination_count != 1 ||
            plan.residual_number_weight != amrex::Real(0.0) ||
            plan.normalized_roundoff != normalized) return false;
        const auto& route = plan.destinations[0];
        return (required_bin < 0 || route.bin == required_bin) &&
               route.number_weight == amrex::Real(1.0) &&
               route.particle_mass == expected_mass && route.bin >= 0 &&
               route.bin < population.nbins && expected_mass >= population.edges[route.bin] &&
               (expected_mass < population.edges[route.bin + 1] ||
                (route.bin == population.nbins - 1 &&
                 expected_mass <= population.edges[route.bin + 1]));
    }
 
    const amrex::Real first = population.pivots[0];
    const amrex::Real last = population.pivots[population.nbins - 1];
    if (plan.packet_particle_mass == amrex::Real(0.0)) {
        return plan.status == RemapStatus::ZeroWaterResidual &&
               plan.destination_count == 0 &&
               plan.residual_number_weight == amrex::Real(1.0) &&
               !plan.normalized_roundoff;
    }
    if (plan.packet_particle_mass < first) {
        amrex::Real wet_weight = amrex::Real(0.0);
        if (checked_quotient(plan.packet_particle_mass, first, wet_weight) !=
            QuotientStatus::Ok) return false;
        return plan.status == RemapStatus::ZeroWaterResidual && !plan.normalized_roundoff &&
               plan.destination_count == 1 && plan.residual_number_weight ==
               amrex::Real(1.0) - wet_weight && plan.destinations[0].bin == 0 &&
               plan.destinations[0].number_weight == wet_weight &&
               plan.destinations[0].particle_mass == first;
    }
    if (plan.packet_particle_mass > last || plan.status == RemapStatus::ZeroWaterResidual) {
        return false;
    }
    if (plan.destination_count == 1) {
        const int pivot_bin = plan.destinations[0].bin;
        if (pivot_bin < 0 || pivot_bin >= population.nbins) return false;
        return plan.status == RemapStatus::Ok && !plan.normalized_roundoff &&
               plan.destination_count == 1 && plan.residual_number_weight == amrex::Real(0.0) &&
               plan.packet_particle_mass == population.pivots[pivot_bin] &&
               plan.destinations[0].bin == pivot_bin &&
               plan.destinations[0].number_weight == amrex::Real(1.0) &&
               plan.destinations[0].particle_mass == population.pivots[pivot_bin];
    }
    if (plan.destination_count != 2) return false;
    const int lower_bin = plan.destinations[0].bin;
    if (lower_bin < 0 || lower_bin + 1 >= population.nbins ||
        plan.destinations[1].bin != lower_bin + 1) return false;
    const amrex::Real lower = population.pivots[lower_bin];
    const amrex::Real upper = population.pivots[lower_bin + 1];
    if (!(plan.packet_particle_mass > lower && plan.packet_particle_mass < upper)) return false;
    const amrex::Real width = upper - lower;
    amrex::Real lower_weight = amrex::Real(0.0);
    amrex::Real upper_weight = amrex::Real(0.0);
    if (checked_quotient(upper - plan.packet_particle_mass, width, lower_weight) !=
            QuotientStatus::Ok ||
        checked_quotient(plan.packet_particle_mass - lower, width, upper_weight) !=
            QuotientStatus::Ok) return false;
    return plan.status == RemapStatus::Ok && !plan.normalized_roundoff &&
           plan.destination_count == 2 && plan.residual_number_weight == amrex::Real(0.0) &&
           plan.destinations[0].bin == lower_bin &&
           plan.destinations[0].number_weight == lower_weight &&
           plan.destinations[0].particle_mass == lower &&
           plan.destinations[1].bin == lower_bin + 1 &&
           plan.destinations[1].number_weight == upper_weight &&
           plan.destinations[1].particle_mass == upper;
}

Referenced by erf_sbm::apply_packet_routing_core().

Here is the call graph for this function:

Here is the caller graph for this function:

within_boundary_roundoff()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool erf_sbm::remap_detail::within_boundary_roundoff ( const amrex::Real  value, const amrex::Real  endpoint, const bool  lower_boundary  )

noexcept

Accept at most four representable steps outward from a global endpoint.

{
    const amrex::Real direction = lower_boundary ?
        -std::numeric_limits<amrex::Real>::infinity() :
         std::numeric_limits<amrex::Real>::infinity();
    amrex::Real allowance = endpoint;
    for (int step = 0; step < 4; ++step) {
        allowance = std::nextafter(allowance, direction);
    }
    return lower_boundary ? value >= allowance : value <= allowance;
}

Referenced by erf_sbm::plan_packet_routing(), and route_plan_is_consistent().

Here is the caller graph for this function: