PoPS/doxygen/block__seam_8hpp_source.html

#pragma once


#include <pops/core/state/variables.hpp>         // VariableSet (block descriptor carried in BuiltBlock)

#include <pops/runtime/builders/block/block_builder.hpp>  // make_block + makers + BlockClosures + NewtonOptions/Report

#include <pops/runtime/builders/block/block_builder_polar.hpp>  // make_block_polar + polar makers + PolarGridContext

#include <pops/runtime/builders/factory/model_factory.hpp>  // dispatch_model_for + resolve_implicit_components + ModelSpec


#include <functional>

#include <string>

#include <utility>

#include <vector>


namespace pops::detail {


struct BuiltBlock {

  int ncomp = 1;

  VariableSet cons_vs, prim_vs;

  BlockClosures clo;

  std::function<Real(const MultiFab&)> max_speed;

  std::function<void(const MultiFab&, MultiFab&)> add_poisson_rhs;

  std::function<Real(const MultiFab&)> src_freq, stab_dt;  // optional step bounds (model traits)

  std::function<void(const double*, double*)> prim_to_cons, cons_to_prim;  // System::CellConvert

  int aux_width =

      0;  // aux_comps<Model>() (Cartesian); unused on the polar path (no ensure_aux_width)

};


struct BlockBuildArgs {

  std::string name;

  std::string limiter;

  std::string riemann;

  GridContext ctx;

  bool imex;

  bool recon_prim;

  std::string method;

  std::vector<std::string> implicit_vars;

  std::vector<std::string> implicit_roles;

  NewtonOptions nopts;

  NewtonReport* nreport;  // non-owning (report lives in System::Impl::newton_reports_)

  Real positivity_floor;

  bool wave_speed_cache;

};


template <class TR, class MakeFn>


BuiltBlock build_block_for_make(TR tr, const ModelSpec& model, const BlockBuildArgs& a,

                                MakeFn make) {

  BuiltBlock out;

  dispatch_model_for(model, std::move(tr), [&](auto m) {

    using M = decltype(m);

    out.ncomp = M::n_vars;

    out.cons_vs = M::conservative_vars();  // names + physical ROLES (single source of truth)

    out.prim_vs = M::primitive_vars();

    // AUX WIDTH of the composed model (n_aux > 3 for a magnetized brick reading B_z): returned so

    // add_block widens the SHARED channel host-side (ensure_aux_width preserves the aux ADDRESS captured

    // by the closures, so applying it after make_block is equivalent).

    out.aux_width = aux_comps<M>();

    const std::vector<int> impl_components =

        resolve_implicit_components(a.name, out.cons_vs, a.implicit_vars, a.implicit_roles);

    out.clo = make(m, impl_components, a);

    out.max_speed = make_max_speed(m, a.ctx);

    out.add_poisson_rhs = make_poisson_rhs(m);

    out.src_freq = make_source_frequency(m, a.ctx);

    out.stab_dt = make_stability_dt(m, a.ctx);

    auto conv = make_cell_convert(m);

    out.prim_to_cons = std::move(conv.first);

    out.cons_to_prim = std::move(conv.second);

  });

  return out;

}


template <class TR>


BuiltBlock build_block_for(TR tr, const ModelSpec& model, const BlockBuildArgs& a) {

  return build_block_for_make(

      std::move(tr), model, a, [](auto m, const std::vector<int>& impl, const BlockBuildArgs& aa) {

        return make_block(m, aa.limiter, aa.riemann, aa.ctx, aa.imex, aa.recon_prim, aa.method,

                          impl, aa.nopts, aa.nreport, aa.positivity_floor, aa.wave_speed_cache);

      });

}


// Per-transport seam functions (defined in python/system_<transport>.cpp). The TR construction matches

// dispatch_transport's branches VERBATIM (ExBVelocity{B0} / CompressibleFlux{gamma} /

// IsothermalFlux{cs2, vacuum_floor}).

BuiltBlock build_block_exb(const ModelSpec& model, const BlockBuildArgs& a);


// Isothermal (3-var fluid) carries two reachable fluxes (rusanov + hll; hllc/roe need 4-var + pressure)

// x 4 limiters x 15 models -- the post-split long pole -- so it is FLUX-SUBDIVIDED like compressible

// (ADC-342): one .cpp per reachable flux. System dispatches on the riemann string; an unsupported flux

// (incl. hllc/roe) is caught by the shared validate_riemann + the registry throw.

BuiltBlock build_block_isothermal_rusanov(const ModelSpec& model, const BlockBuildArgs& a);

BuiltBlock build_block_isothermal_hll(const ModelSpec& model, const BlockBuildArgs& a);


// Compressible (Euler, 4-var + pressure) is the heaviest transport: all four fluxes are valid, so it is

// FLUX-SUBDIVIDED into one .cpp per flux (ADC-335) -- each instantiates only its flux's build_block

// leaves, so they compile in parallel. System dispatches on the riemann string to the right one (every

// flux is valid for Euler, so no capability rejection to reproduce; an unknown flux is caught by the

// shared validate_riemann + the registry throw, same wording as make_block).

BuiltBlock build_block_compressible_rusanov(const ModelSpec& model, const BlockBuildArgs& a);

BuiltBlock build_block_compressible_hll(const ModelSpec& model, const BlockBuildArgs& a);

BuiltBlock build_block_compressible_hllc(const ModelSpec& model, const BlockBuildArgs& a);

BuiltBlock build_block_compressible_roe(const ModelSpec& model, const BlockBuildArgs& a);


// Polar (ring) seam: VERBATIM polar visitor body (make_block_polar + polar makers). IMEX is rejected on

// the ring by add_block before this is called. @p aux is &System::Impl::aux (the polar makers read it).

BuiltBlock build_block_polar(const ModelSpec& model, const std::string& limiter,

                             const std::string& riemann, const PolarGridContext& pctx,

                             bool recon_prim, const std::string& method, Real positivity_floor,

                             const MultiFab* aux);


}  // namespace pops::detail

block_builder.hpp
Builds the closures of a block (time advance + residual + Poisson contribution) from a COMPILED model...

block_builder_polar.hpp
POLAR counterpart of block_builder.hpp: builds a block's closures (time advance + residual + Poisson ...

pops::MultiFab
Field distributed over a level: decomposition (BoxArray) + distribution (DistributionMapping) + ncomp...
Definition multifab.hpp:33

model_factory.hpp
Assemble a CompositeModel from a ModelSpec (bricks + parameters).

pops::detail
Definition cluster.hpp:37

pops::detail::build_block_compressible_roe
BuiltBlock build_block_compressible_roe(const ModelSpec &model, const BlockBuildArgs &a)

pops::detail::build_block_isothermal_hll
BuiltBlock build_block_isothermal_hll(const ModelSpec &model, const BlockBuildArgs &a)

pops::detail::build_block_compressible_hllc
BuiltBlock build_block_compressible_hllc(const ModelSpec &model, const BlockBuildArgs &a)

pops::detail::build_block_for_make
BuiltBlock build_block_for_make(TR tr, const ModelSpec &model, const BlockBuildArgs &a, MakeFn make)
VERBATIM Cartesian visitor body of the former dispatch_model lambda (system.cpp), with the transport ...
Definition block_seam.hpp:73

pops::detail::build_block_compressible_hll
BuiltBlock build_block_compressible_hll(const ModelSpec &model, const BlockBuildArgs &a)

pops::detail::dispatch_model_for
POPS_COLD_FN void dispatch_model_for(const ModelSpec &m, TR tr, Visitor &&visitor)
Same as dispatch_model but with the transport brick ALREADY chosen (tr).
Definition model_factory.hpp:196

pops::detail::resolve_implicit_components
POPS_COLD_FN std::vector< int > resolve_implicit_components(const std::string &block, const VariableSet &cons, const std::vector< std::string > &names, const std::vector< std::string > &roles)
Resolves the IMPLICIT MASK of a block (add_block: implicit_vars / implicit_roles) into a list of cons...
Definition model_factory.hpp:213

pops::detail::build_block_exb
BuiltBlock build_block_exb(const ModelSpec &model, const BlockBuildArgs &a)

pops::detail::build_block_isothermal_rusanov
BuiltBlock build_block_isothermal_rusanov(const ModelSpec &model, const BlockBuildArgs &a)

pops::detail::build_block_polar
BuiltBlock build_block_polar(const ModelSpec &model, const std::string &limiter, const std::string &riemann, const PolarGridContext &pctx, bool recon_prim, const std::string &method, Real positivity_floor, const MultiFab *aux)

pops::detail::build_block_compressible_rusanov
BuiltBlock build_block_compressible_rusanov(const ModelSpec &model, const BlockBuildArgs &a)

pops::detail::build_block_for
BuiltBlock build_block_for(TR tr, const ModelSpec &model, const BlockBuildArgs &a)
Per-transport seam body: the full make_block dispatcher (all fluxes).
Definition block_seam.hpp:102

pops::make_stability_dt
std::function< Real(const MultiFab &)> make_stability_dt(const Model &m, const GridContext &ctx)
Closure of the block min admissible step (bound dt <= stability_dt * substeps / stride,...
Definition block_builder.hpp:852

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

pops::make_block
POPS_COLD_FN BlockClosures make_block(const Model &m, const std::string &lim, const std::string &riem, const GridContext &ctx, bool imex, bool recon_prim, const std::string &method="ssprk2", const std::vector< int > &implicit_components={}, const NewtonOptions &newton_opts={}, NewtonReport *newton_report=nullptr, Real pos_floor=Real(0), bool wave_speed_cache=false)
Definition block_builder.hpp:726

pops::make_poisson_rhs
std::function< void(const MultiFab &, MultiFab &)> make_poisson_rhs(const Model &m)
Block contribution to the Poisson right-hand side: rhs += elliptic_rhs(U) (host loop).
Definition block_builder.hpp:861

pops::make_max_speed
std::function< Real(const MultiFab &)> make_max_speed(const Model &m, const GridContext &ctx)
Closure of the speed used by the block CFL step.
Definition block_builder.hpp:831

pops::make_source_frequency
std::function< Real(const MultiFab &)> make_source_frequency(const Model &m, const GridContext &ctx)
Closure of the block max source frequency (bound dt <= cfl * substeps / (stride * mu)).
Definition block_builder.hpp:842

pops::make_cell_convert
std::pair< std::function< void(const double *, double *)>, std::function< void(const double *, double *)> > make_cell_convert(const Model &m)
PER-CELL (one cell) cons <-> prim conversions of the MODEL, type-erased over arrays of Model::n_vars ...
Definition block_builder.hpp:875

pops::BlockClosures
Compiled block closures, frozen at add time.
Definition grid_context.hpp:61

pops::GridContext
Mesh + transport BC + aux shared by a block closures.
Definition grid_context.hpp:41

pops::ModelSpec
Brick composition of a block plus parameters.
Definition model_spec.hpp:27

pops::NewtonOptions
Options of the local Newton of the implicit source (backward-Euler).
Definition implicit_stepper.hpp:114

pops::NewtonReport
AGGREGATED report (whole block, all substeps of one advance) of the implicit-source Newton.
Definition implicit_stepper.hpp:165

pops::PolarGridContext
POLAR mesh + transport BC + aux shared by a block's closures (counterpart of GridContext).
Definition block_builder_polar.hpp:49

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

pops::detail::BlockBuildArgs
The non-model inputs of a Cartesian block build (a thin bundle so the seam signature stays fixed).
Definition block_seam.hpp:50

pops::detail::BlockBuildArgs::wave_speed_cache
bool wave_speed_cache
Definition block_seam.hpp:63

pops::detail::BlockBuildArgs::limiter
std::string limiter
Definition block_seam.hpp:52

pops::detail::BlockBuildArgs::method
std::string method
Definition block_seam.hpp:57

pops::detail::BlockBuildArgs::recon_prim
bool recon_prim
Definition block_seam.hpp:56

pops::detail::BlockBuildArgs::implicit_vars
std::vector< std::string > implicit_vars
Definition block_seam.hpp:58

pops::detail::BlockBuildArgs::name
std::string name
Definition block_seam.hpp:51

pops::detail::BlockBuildArgs::ctx
GridContext ctx
Definition block_seam.hpp:54

pops::detail::BlockBuildArgs::implicit_roles
std::vector< std::string > implicit_roles
Definition block_seam.hpp:59

pops::detail::BlockBuildArgs::nreport
NewtonReport * nreport
Definition block_seam.hpp:61

pops::detail::BlockBuildArgs::riemann
std::string riemann
Definition block_seam.hpp:53

pops::detail::BlockBuildArgs::nopts
NewtonOptions nopts
Definition block_seam.hpp:60

pops::detail::BlockBuildArgs::imex
bool imex
Definition block_seam.hpp:55

pops::detail::BlockBuildArgs::positivity_floor
Real positivity_floor
Definition block_seam.hpp:62

pops::detail::BuiltBlock
Everything System::add_block reads back from the (former) dispatch_model visitor.
Definition block_seam.hpp:35

pops::detail::BuiltBlock::ncomp
int ncomp
Definition block_seam.hpp:36

pops::detail::BuiltBlock::prim_vs
VariableSet prim_vs
Definition block_seam.hpp:37

pops::detail::BuiltBlock::cons_vs
VariableSet cons_vs
Definition block_seam.hpp:37

pops::detail::BuiltBlock::aux_width
int aux_width
Definition block_seam.hpp:43

pops::detail::BuiltBlock::cons_to_prim
std::function< void(const double *, double *)> cons_to_prim
Definition block_seam.hpp:42

pops::detail::BuiltBlock::add_poisson_rhs
std::function< void(const MultiFab &, MultiFab &)> add_poisson_rhs
Definition block_seam.hpp:40

pops::detail::BuiltBlock::prim_to_cons
std::function< void(const double *, double *)> prim_to_cons
Definition block_seam.hpp:42

pops::detail::BuiltBlock::max_speed
std::function< Real(const MultiFab &)> max_speed
Definition block_seam.hpp:39

pops::detail::BuiltBlock::clo
BlockClosures clo
Definition block_seam.hpp:38

pops::detail::BuiltBlock::src_freq
std::function< Real(const MultiFab &)> src_freq
Definition block_seam.hpp:41

pops::detail::BuiltBlock::stab_dt
std::function< Real(const MultiFab &)> stab_dt
Definition block_seam.hpp:41

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