PoPS/doxygen/state__access_8hpp_source.html

#pragma once


#include <pops/core/model/physical_model.hpp>  // aux_comps, HasPrimitiveVars: optional primitive reconstruction

#include <pops/core/state/state.hpp>

#include <pops/core/foundation/types.hpp>

#include <pops/core/state/variables.hpp>  // VariableSet: SourceFreeModel::conservative_vars forwarding

#include <pops/mesh/storage/fab2d.hpp>      // ConstArray4: load_state / load_aux read path


#include <concepts>


namespace pops {


// aux_comps<Model>() (aux channel width of a model) now lives in the contract header

// pops/core/physical_model.hpp (included above) so that CompositeModel can propagate it.


template <class M>


concept DiffusiveModel = requires(const M m) {

  { m.diffusivity() } -> std::convertible_to<Real>;

};


template <class M>


struct SourceFreeModel {

  using State = typename M::State;

  using Aux = typename M::Aux;

  static constexpr int n_vars = M::n_vars;

  static constexpr int n_aux = aux_comps<M>();  // transparent to the wrapped model's aux width

  M m;

  POPS_HD State flux(const State& u, const Aux& a, int dir) const { return m.flux(u, a, dir); }


  POPS_HD Real max_wave_speed(const State& u, const Aux& a, int dir) const {

    return m.max_wave_speed(u, a, dir);

  }


  POPS_HD State source(const State&, const Aux&) const { return State{}; }

  POPS_HD Real elliptic_rhs(const State& u) const { return m.elliptic_rhs(u); }

  // SourceFreeModel does not expose the primitive variables: the explicit IMEX half-step that

  // uses it therefore reconstructs in conservative variables (the direct explicit path itself

  // has the composite model's conversions and can reconstruct in primitive variables).

  // Transparent to the HLL/HLLC contract: forwards pressure and signed wave speeds ONLY if M

  // exposes them (requires clause), so an IMEX half-step can stay on the HLLC flux.


  POPS_HD Real pressure(const State& u) const

    requires requires(const M& mm, const State& s) { mm.pressure(s); }

  {

    return m.pressure(u);

  }


  POPS_HD void wave_speeds(const State& u, const Aux& a, int dir, Real& smin, Real& smax) const

    requires requires(const M& mm, const State& s, const Aux& aa, int d, Real& lo, Real& hi) {

      mm.wave_speeds(s, aa, d, lo, hi);

    }

  {

    m.wave_speeds(u, a, dir, smin, smax);

  }


  // Roe / HLLC CAPABILITIES (HasRoeDissipation / HasHLLCStructure): forwarded ONLY if M exposes

  // them (requires clause), exactly like pressure / wave_speeds above and like composite.hpp.

  // WITHOUT these, an IMEX explicit half-step on riemann='roe' / 'hllc' loses the model's GENERIC

  // hooks, so RoeFlux / HLLCFlux silently fall back to the canonical Euler-4var path -- which fails

  // to even COMPILE for a non-Euler model (e.g. a moment hierarchy: n_vars != 4, no pressure). The

  // 4-var Euler models compiled before only because that fallback happens to fit them.


  POPS_HD Real contact_speed(const State& ul, const State& ur, Real pl, Real pr, Real sl, Real sr,

                            int dir) const

    requires requires(const M& mm, const State a_, const State b_, Real p, Real q, Real x, Real y,

                      int d) { mm.contact_speed(a_, b_, p, q, x, y, d); }

  {

    return m.contact_speed(ul, ur, pl, pr, sl, sr, dir);

  }


  POPS_HD State hllc_star_state(const State& u, Real p, Real s, Real sStar, int dir) const

    requires requires(const M& mm, const State a_, Real p_, Real s_, Real ss_, int d) {

      mm.hllc_star_state(a_, p_, s_, ss_, d);

    }

  {

    return m.hllc_star_state(u, p, s, sStar, dir);

  }


  POPS_HD State roe_dissipation(const State& ul, const Aux& al, const State& ur, const Aux& ar,

                               int dir) const

    requires requires(const M& mm, const State a_, const Aux x_, const State b_, const Aux y_,

                      int d) { mm.roe_dissipation(a_, x_, b_, y_, d); }

  {

    return m.roe_dissipation(ul, al, ur, ar, dir);

  }


  // Forward the VariableSet introspection (HOST): lets positivity_comp resolve the Density role

  // through the explicit IMEX half-step. Conditional (requires), like pressure / wave_speeds.


  static VariableSet conservative_vars()

    requires requires { M::conservative_vars(); }

  {

    return M::conservative_vars();

  }


};


template <class Model>


POPS_HD inline typename Model::State load_state(const ConstArray4& a, int i, int j) {

  typename Model::State u;

  for (int c = 0; c < Model::n_vars; ++c)

    u[c] = a(i, j, c);

  return u;

}


//

// The extra fields are loaded from the SINGLE SOURCE POPS_AUX_FIELDS (state.hpp): each

// X(name, idx) generates `if constexpr (NComp > idx) x.name = a(i,j,idx);`, exactly the

// sequence written by hand before. Adding an extra field => 1 line in POPS_AUX_FIELDS is

// enough for this device read path to cover it (and the host marshaling, generated from the

// same table). NComp = kAuxBaseComps: all guards are false -> bit-identical.

template <int NComp = kAuxBaseComps>


POPS_HD inline Aux load_aux(const ConstArray4& a, int i, int j) {

  Aux x{a(i, j, 0), a(i, j, 1), a(i, j, 2)};

#define POPS_AUX_LOAD(name, idx) \

  if constexpr (NComp > (idx))  \

    x.name = a(i, j, idx);

  POPS_AUX_FIELDS(POPS_AUX_LOAD)

#undef POPS_AUX_LOAD

  // NAMED aux fields (ADC-70 phase 1): components from kAuxNamedBase (= 5). Loaded

  // ONLY if the model declares n_aux > kAuxNamedBase (otherwise if constexpr false -> no codegen,

  // NComp = kAuxBaseComps stays strictly bit-identical). The bound n_extra is known at

  // compile time (NComp template): the loop is unrolled and clamped to kAuxMaxExtra (size of

  // x.extra) -- never an out-of-bounds access on the C array, device-clean.

  if constexpr (NComp > kAuxNamedBase) {

    constexpr int n_extra =

        (NComp - kAuxNamedBase) < kAuxMaxExtra ? (NComp - kAuxNamedBase) : kAuxMaxExtra;

    for (int k = 0; k < n_extra; ++k)

      x.extra[k] = a(i, j, kAuxNamedBase + k);

  }

  return x;

}


}  // namespace pops

pops::DiffusiveModel
DiffusiveModel: optional concept for models with isotropic scalar diffusion.
Definition state_access.hpp:38

fab2d.hpp
Fab2D: single-grid data on a Box2D (in-house equivalent of AMReX's FArrayBox); Array4 / ConstArray4: ...

pops
Definition amr_hierarchy.hpp:29

pops::Real
double Real
Definition types.hpp:30

pops::load_aux
POPS_HD Aux load_aux(const ConstArray4 &a, int i, int j)
load_aux<NComp>: reads NComp components of the auxiliary from an Array4 at (i,j).
Definition state_access.hpp:141

pops::kAuxMaxExtra
constexpr int kAuxMaxExtra
Definition state.hpp:100

pops::kAuxNamedBase
constexpr int kAuxNamedBase
Definition state.hpp:154

pops::load_state
POPS_HD Model::State load_state(const ConstArray4 &a, int i, int j)
load_state<Model>: reads Model::n_vars scalars at (i,j) from an Array4.
Definition state_access.hpp:120

physical_model.hpp
C++20 concepts defining the contract of the physics layer.

state.hpp
Pointwise types of the physics layer: StateVec<N> (conserved state) and Aux (auxiliary fields from th...

POPS_AUX_FIELDS
#define POPS_AUX_FIELDS(X)
SINGLE SOURCE of the layout of the EXTRA aux fields (X-macro).
Definition state.hpp:92

POPS_AUX_LOAD
#define POPS_AUX_LOAD(name, idx)

pops::Aux
POINTWISE auxiliary fields shared with the physics: single coupling channel.
Definition state.hpp:123

pops::ConstArray4
READ-only handle (const counterpart of Array4): same layout and same contract (POD device-copyable,...
Definition fab2d.hpp:44

pops::SourceFreeModel
SourceFreeModel<M>: adapter that cancels the source of M (explicit IMEX half-step).
Definition state_access.hpp:50

pops::SourceFreeModel::hllc_star_state
POPS_HD State hllc_star_state(const State &u, Real p, Real s, Real sStar, int dir) const
Definition state_access.hpp:92

pops::SourceFreeModel::pressure
POPS_HD Real pressure(const State &u) const
Definition state_access.hpp:67

pops::SourceFreeModel::n_aux
static constexpr int n_aux
Definition state_access.hpp:54

pops::SourceFreeModel::m
M m
Definition state_access.hpp:55

pops::SourceFreeModel::wave_speeds
POPS_HD void wave_speeds(const State &u, const Aux &a, int dir, Real &smin, Real &smax) const
Definition state_access.hpp:72

pops::SourceFreeModel::elliptic_rhs
POPS_HD Real elliptic_rhs(const State &u) const
Definition state_access.hpp:61

pops::SourceFreeModel::conservative_vars
static VariableSet conservative_vars()
Definition state_access.hpp:108

pops::SourceFreeModel::source
POPS_HD State source(const State &, const Aux &) const
Definition state_access.hpp:60

pops::SourceFreeModel::Aux
typename M::Aux Aux
Definition state_access.hpp:52

pops::SourceFreeModel::roe_dissipation
POPS_HD State roe_dissipation(const State &ul, const Aux &al, const State &ur, const Aux &ar, int dir) const
Definition state_access.hpp:99

pops::SourceFreeModel::flux
POPS_HD State flux(const State &u, const Aux &a, int dir) const
Definition state_access.hpp:56

pops::SourceFreeModel::contact_speed
POPS_HD Real contact_speed(const State &ul, const State &ur, Real pl, Real pr, Real sl, Real sr, int dir) const
Definition state_access.hpp:85

pops::SourceFreeModel::State
typename M::State State
Definition state_access.hpp:51

pops::SourceFreeModel::n_vars
static constexpr int n_vars
Definition state_access.hpp:53

pops::SourceFreeModel::max_wave_speed
POPS_HD Real max_wave_speed(const State &u, const Aux &a, int dir) const
Definition state_access.hpp:57

pops::VariableSet
A model's variable set: kind (cons/prim), names, size, canonical roles (optional, parallel to names; ...
Definition variables.hpp:58

types.hpp
Base scalar types and the POPS_HD macro (host+device portability).

POPS_HD
#define POPS_HD
Definition types.hpp:25

variables.hpp
Descriptor of a model's variables (Vars).