PoPS/doxygen/dsl__block_8hpp_source.html

#pragma once


#include <pops/core/model/physical_model.hpp>  // aux_comps<Model>: aux width requested by the model

#include <pops/runtime/builders/block/block_builder.hpp>

#include <pops/runtime/system.hpp>


#include <functional>

#include <string>

#include <utility>


namespace pops {


template <class Model>


void add_compiled_model(System& sys, const std::string& name, Model model,

                        const std::string& limiter = "minmod",

                        const std::string& riemann = "rusanov",

                        const std::string& recon = "conservative",

                        const std::string& time = "explicit", double gamma = 1.4, int substeps = 1,

                        bool evolve = true, int stride = 1, double positivity_floor = 0) {

  const bool imex = (time == "imex");

  const bool recon_prim = (recon == "primitive");

  // EXPLICIT RK scheme marshaled by the production path (add_native_block -> pops_install_native

  // -> this template): "ssprk3" (3 stages, order 3, less dissipative, to pair with weno5), "euler"

  // (ForwardEuler, order 1: fidelity to first-order references, validation) vs "ssprk2"

  // (historical default, bit-identical). Has effect ONLY on the explicit advance -- IMEX keeps its

  // ForwardEuler half-step + implicit source, so method is ignored when imex. We thus align the

  // production .so with the native add_block path (system.cpp) which already exposed ssprk3; any

  // other string ("explicit"/unknown) falls back to ssprk2 (add_native_block validates the upstream string).

  const std::string method = (time == "ssprk3") ? "ssprk3" : (time == "euler") ? "euler" : "ssprk2";

  // The block may read extra auxiliary fields (aux_comps<Model> > 3, e.g. B_z of a magnetized

  // source): we widen the System's SHARED aux channel BEFORE capturing its address, so that the

  // closure reads a wide enough aux. Base model (3) -> no-op, unchanged.

  sys.ensure_aux_width(aux_comps<Model>());

  const GridContext ctx = sys.grid_context();

  BlockClosures clo = make_block(model, limiter, riemann, ctx, imex, recon_prim, method, {}, {},

                                 nullptr, static_cast<Real>(positivity_floor));

  std::function<Real(const MultiFab&)> ms = make_max_speed(model, ctx);

  std::function<void(const MultiFab&, MultiFab&)> pr = make_poisson_rhs(model);

  sys.install_block(name, Model::n_vars, Model::conservative_vars(), Model::primitive_vars(), gamma,

                    std::move(clo), std::move(ms), std::move(pr), substeps, evolve, stride);

  // cons <-> prim conversions OF THE MODEL (set/get_primitive_state): same formulas as the flux of

  // the production path. Set AFTER install_block (like set_block_ghosts); a native .so loader

  // recompiled against this header (ABI key verified) carries them too.

  auto conv = make_cell_convert(model);

  sys.set_block_conversion(name, std::move(conv.first), std::move(conv.second));

  // OPTIONAL step bounds of the model (HasSourceFrequency / HasStabilityDt traits, see

  // core/physical_model.hpp): compiled here like flux/source (a DSL model declaring

  // m.source_frequency(...) / m.stability_dt(...) carries them down to the System's step_cfl).

  // EMPTY functions if the model does not declare the traits -> historical step policy. The

  // STABILITY speed (HasStabilitySpeed) is already carried by make_max_speed above.

  sys.set_block_dt_bounds(name, make_source_frequency(model, ctx), make_stability_dt(model, ctx));

  // Scheme GHOSTS: WENO5 reads a 5-point stencil (3 ghosts) > the 2 allocated by install_block.

  // We reallocate the block state with block_n_ghost(limiter) -- SAME mechanism as add_block (PR #88) --

  // so that fill_boundary + assemble_rhs do not read out of bounds on the System's real MultiFab.

  // none/minmod/vanleer (<= 2 ghosts): no-op, allocation and result bit-identical to before.

  sys.set_block_ghosts(name, block_n_ghost(limiter));

}


}  // namespace pops

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

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

pops::System
Coupled multi-species system, composed at runtime from generic bricks.
Definition system.hpp:89

pops::System::grid_context
POPS_EXPORT GridContext grid_context()
REAL mesh + BC + aux of the System (aux not owned)

pops::System::set_block_dt_bounds
POPS_EXPORT void set_block_dt_bounds(const std::string &name, std::function< Real(const MultiFab &)> source_frequency, std::function< Real(const MultiFab &)> stability_dt)
Installs the optional STEP BOUNDS of a block (after install_block): reduction of the max source frequ...

pops::System::ensure_aux_width
POPS_EXPORT void ensure_aux_width(int ncomp)
Guarantees that the SHARED aux channel has at least ncomp components.

pops::System::install_block
POPS_EXPORT void install_block(const std::string &name, int ncomp, const VariableSet &cons_vars, const VariableSet &prim_vars, double gamma, BlockClosures closures, std::function< Real(const MultiFab &)> max_speed, std::function< void(const MultiFab &, MultiFab &)> poisson_rhs, int substeps, bool evolve, int stride=1)
Installs a block from already-built closures (cf.

pops::System::set_block_conversion
POPS_EXPORT void set_block_conversion(const std::string &name, CellConvert prim_to_cons, CellConvert cons_to_prim)
Installs the pointwise cons <-> prim conversions of a block (after install_block).

pops::System::set_block_ghosts
POPS_EXPORT void set_block_ghosts(const std::string &name, int n_ghost)
Guarantees that the state U of block name carries at least n_ghost ghosts (width of the spatial stenc...

pops
Definition amr_hierarchy.hpp:29

pops::block_n_ghost
int block_n_ghost(const std::string &lim)
Number of ghosts required by the spatial scheme lim (single source: Limiter::n_ghost).
Definition block_builder.hpp:759

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::add_compiled_model
void add_compiled_model(AmrSystem &sys, const std::string &name, Model model, const std::string &limiter="minmod", const std::string &riemann="rusanov", const std::string &recon="conservative", const std::string &time="explicit", double gamma=1.4, int substeps=1, int stride=1, const std::vector< std::string > &implicit_vars={}, const std::vector< std::string > &implicit_roles={}, double pos_floor=0.0)
Wires model (concrete CompositeModel) as an AMR block of sys, with the requested scheme.
Definition amr_dsl_block.hpp:1028

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

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

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

system.hpp
Runtime multi-species composition: one coupled system, block by block.