erf_sbm::SpectralGrid Class Reference

#include <ERF_SpectralGrid.H>

Collaboration diagram for erf_sbm::SpectralGrid:

Public Member Functions
	SpectralGrid (SpectralGridSpec spec)
CoordinateKind	coordinate_kind () const noexcept
const std::string &	coordinate_units () const noexcept
const std::vector< amrex::Real > &	edges () const noexcept
const std::vector< amrex::Real > &	pivots () const noexcept
int	nbins () const noexcept
amrex::Real	pivot (const int bin) const
std::string	identity () const

Static Public Member Functions
static GridValidation	validate (const SpectralGridSpec &spec)
static bool	two_moment_realizable (amrex::Real C, amrex::Real M, amrex::Real lower, amrex::Real upper) noexcept
static EndpointTransform	two_moment_to_endpoints (amrex::Real C, amrex::Real M, amrex::Real lower, amrex::Real upper)
static std::pair< amrex::Real, amrex::Real >	endpoints_to_two_moment (amrex::Real L, amrex::Real H, amrex::Real lower, amrex::Real upper)

Private Attributes
SpectralGridSpec	m_spec

Detailed Description

Runtime-sized, immutable-after-construction spectral grid.

Constructor & Destructor Documentation

SpectralGrid()

erf_sbm::SpectralGrid::SpectralGrid ( SpectralGridSpec  spec )

explicit

                                                 : m_spec(std::move(spec))
{
    const auto result = validate(m_spec);
    if (!result.valid) throw std::invalid_argument("invalid spectral grid: " + result.message);
}

Here is the call graph for this function:

Member Function Documentation

coordinate_kind()

CoordinateKind erf_sbm::SpectralGrid::coordinate_kind ( ) const

inlinenoexcept

{ return m_spec.coordinate_kind; }

coordinate_units()

const std::string& erf_sbm::SpectralGrid::coordinate_units ( ) const

inlinenoexcept

{ return m_spec.coordinate_units; }

edges()

const std::vector<amrex::Real>& erf_sbm::SpectralGrid::edges ( ) const

inlinenoexcept

{ return m_spec.edges; }

endpoints_to_two_moment()

std::pair< amrex::Real, amrex::Real > erf_sbm::SpectralGrid::endpoints_to_two_moment ( amrex::Real  L, amrex::Real  H, amrex::Real  lower, amrex::Real  upper  )

static

{
    amrex::Real C = amrex::Real(0.0);
    amrex::Real M = amrex::Real(0.0);
    if (!try_endpoints_to_two_moment(L, H, lower, upper, C, M)) {
        throw std::invalid_argument("invalid two-moment endpoint state");
    }
    return {C, M};
}

Here is the call graph for this function:

identity()

std::string erf_sbm::SpectralGrid::identity

(

)

const

{
    std::ostringstream out;
    out << "spectral-grid-v4|kind=" << static_cast<int>(m_spec.coordinate_kind)
        << "|coordinate_units=" << m_spec.coordinate_units << "|edges=";
    for (const auto x : m_spec.edges) out << canonical_real(x) << ',';
    out << "|pivots=";
    for (const auto x : m_spec.pivots) out << canonical_real(x) << ',';
    return out.str();
}

Here is the call graph for this function:

nbins()

int erf_sbm::SpectralGrid::nbins ( ) const

inlinenoexcept

{ return static_cast<int>(m_spec.edges.size()) - 1; }

pivot()

amrex::Real erf_sbm::SpectralGrid::pivot ( const int  bin ) const

inline

{ return m_spec.pivots.at(static_cast<std::size_t>(bin)); }

Referenced by validate().

Here is the caller graph for this function:

pivots()

const std::vector<amrex::Real>& erf_sbm::SpectralGrid::pivots ( ) const

inlinenoexcept

{ return m_spec.pivots; }

two_moment_realizable()

bool erf_sbm::SpectralGrid::two_moment_realizable ( amrex::Real  C, amrex::Real  M, amrex::Real  lower, amrex::Real  upper  )

staticnoexcept

{
    EndpointTransform result;
    return try_two_moment_to_endpoints(C, M, lower, upper, result);
}

Here is the call graph for this function:

two_moment_to_endpoints()

EndpointTransform erf_sbm::SpectralGrid::two_moment_to_endpoints ( amrex::Real  C, amrex::Real  M, amrex::Real  lower, amrex::Real  upper  )

static

{
    EndpointTransform result;
    if (!try_two_moment_to_endpoints(C, M, lower, upper, result)) {
        throw std::invalid_argument("invalid or materially non-realizable two-moment state");
    }
    return result;
}

Here is the call graph for this function:

validate()

GridValidation erf_sbm::SpectralGrid::validate ( const SpectralGridSpec &  spec )

static

{
    if (spec.edges.size() < 2) return {false, "spectral grid needs at least one bin"};
    if (spec.coordinate_units.empty()) return {false, "spectral coordinate units are required"};
    for (std::size_t i = 0; i < spec.edges.size(); ++i) {
        const auto edge = spec.edges[i];
        if (!std::isfinite(edge) || edge < amrex::Real(0.0)) return {false, "edges must be finite and nonnegative"};
        if (i > 0) {
            const auto lower = spec.edges[i-1];
            if (!(lower < edge)) return {false, "edges must be strictly increasing"};
            const auto width = edge - lower;
            const auto scale = std::max(std::abs(lower), std::abs(edge));
            // This is a relative conditioning rule.  There is deliberately
            // no absolute floor: [0, small] remains a valid scientific bin.
            if (scale > amrex::Real(0.0) &&
                width < amrex::Real(1000.0) * std::numeric_limits<amrex::Real>::epsilon() * scale) {
                return {false, "spectral bin edge separation is below the relative conditioning threshold"};
            }
        }
    }
    if (spec.pivots.size() != spec.edges.size() - 1) return {false, "one positive pivot is required per bin"};
    for (std::size_t i = 0; i < spec.pivots.size(); ++i) {
        const auto pivot = spec.pivots[i];
        if (!std::isfinite(pivot) || pivot <= amrex::Real(0.0)) return {false, "pivots must be finite and positive"};
        if (!(spec.edges[i] <= pivot && pivot <= spec.edges[i+1])) return {false, "pivot must lie inside its bin"};
    }
    return {true, {}};
}

Referenced by SpectralGrid(), and erf_sbm::SBMLayout::validate().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_spec

SpectralGridSpec erf_sbm::SpectralGrid::m_spec

private

Referenced by coordinate_kind(), coordinate_units(), edges(), identity(), nbins(), pivot(), pivots(), and SpectralGrid().

---

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

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