PoPS/doxygen/amr__dsl__block_8hpp_source.html

#pragma once


#include <pops/coupling/schur/amr/amr_condensed_schur_source_stepper.hpp>  // GLOBAL condensed source stage (amr-schur)

#include <pops/coupling/amr/amr_coupler_mp.hpp>                      // AmrCouplerMP, AmrLevelMP

#include <pops/mesh/index/box2d.hpp>

#include <pops/mesh/layout/box_array.hpp>

#include <pops/mesh/layout/distribution_mapping.hpp>

#include <pops/mesh/execution/for_each.hpp>  // device_fence

#include <pops/mesh/geometry/geometry.hpp>

#include <pops/mesh/storage/multifab.hpp>

#include <pops/mesh/layout/refinement.hpp>  // coarsen_index

#include <pops/numerics/fv/numerical_flux.hpp>

#include <pops/numerics/fv/reconstruction.hpp>

#include <pops/numerics/spatial_operator.hpp>  // SourceFreeModel (explicit IMEX half-step, transport only)

#include <pops/numerics/time/integrators/implicit_stepper.hpp>  // backward_euler_source + ImplicitMask (stiff IMEX source)

#include <pops/parallel/comm.hpp>                   // n_ranks

#include <pops/runtime/amr/amr_runtime.hpp>  // AmrRuntimeBlock (type-erased multi-block registry)

#include <pops/runtime/amr_system.hpp>

#include <pops/runtime/builders/block/block_builder.hpp>  // detail::make_poisson_rhs (rhs += elliptic_rhs(U))

#include <pops/runtime/config/dispatch_tags.hpp>  // UNIQUE tag registry (validate_limiter/riemann)


#include <algorithm>  // std::find, std::sort (resolving the partial IMEX mask of a compiled block)

#include <functional>

#include <memory>

#include <stdexcept>

#include <string>

#include <utility>

#include <vector>


namespace pops {


template <class L, class F>


struct AmrDiscLF {

  using Limiter = L;

  using NumericalFlux = F;

};


namespace detail {


// Projection ponctuelle post-pas appliquee PAR NIVEAU (ADC-177) : miroir de PointwiseProject

// (block_builder.hpp) mais sur la pile de niveaux AMR ; aux = lev.aux (cable par AmrRuntime).

// Defini en tete du namespace : utilise par build_amr_compiled (mono-bloc) ET build_amr_block

// (multi-bloc natif), tous deux situes plus bas (la recherche qualifiee detail:: exige la

// declaration AVANT le point d'usage). No-op (else) si le modele ne declare pas m.project.

template <class Model>


void apply_pointwise_project_amr(const Model& m, std::vector<AmrLevelMP>& levels) {

  if constexpr (HasPointwiseProjection<Model>) {

    for (auto& lev : levels) {

      MultiFab& U = lev.U;

      const MultiFab& a = *lev.aux;

      for (int li = 0; li < U.local_size(); ++li)

        for_each_cell(U.box(li),

                      ProjectCellKernel<Model>{m, U.fab(li).array(), U.fab(li).const_array(),

                                               a.fab(li).const_array()});

    }

  } else {

    (void)m;

    (void)levels;

  }

}


inline void amr_write_coarse_bz(MultiFab& bz, const std::vector<double>& field, int n) {

  if (static_cast<int>(field.size()) != n * n)

    throw std::runtime_error(

        "AMR amr-schur: B_z field of size != n*n (call set_magnetic_field before the first step)");

  device_fence();

  for (int li = 0; li < bz.local_size(); ++li) {

    Array4 b = bz.fab(li).array();

    const Box2D v = bz.box(li);

    for (int j = v.lo[1]; j <= v.hi[1]; ++j)

      for (int i = v.lo[0]; i <= v.hi[0]; ++i)

        b(i, j, 0) = field[static_cast<std::size_t>(j) * n + i];

  }

}


template <class Coupler>


void amr_schur_source(Coupler& cpl, AmrCondensedSchurSourceStepper& schur, MultiFab& bz_coarse,

                      MultiFab& phi_coarse, double theta, double dt) {

  device_fence();

  for (int li = 0; li < phi_coarse.local_size(); ++li)

    for_each_cell(phi_coarse.box(li),

                  CopyComp0Kernel{phi_coarse.fab(li).array(), cpl.aux0().fab(li).const_array()});

  schur.step(cpl.levels(), phi_coarse, bz_coarse, /*c_bz=*/0, static_cast<Real>(theta),

             static_cast<Real>(dt));

}


template <class Model, class Limiter, class Flux>


AmrCompiledHooks build_amr_compiled(const Model& model, const AmrBuildParams& bp) {

  using Coupler = AmrCouplerMP<Model>;

  const int nc = Model::n_vars;

  const Geometry g{Box2D::from_extents(bp.n, bp.n), 0.0, bp.L, 0.0, bp.L};

  const double dxc = bp.L / bp.n, dxf = dxc / 2;

  // Level 0 (coarse): layout decided by the ownership policy (replicated mono-box by default,

  // distributed multi-box if bp.distribute_coarse). When replicated, dmap = my_rank() everywhere (the box

  // lives on each rank; a round-robin would place it on rank 0 only -> out-of-bounds fab elsewhere,

  // segfault under np>1). The fine seed (allocated below ONLY when refinement is configured) starts on the

  // SAME dmap as the coarse; the initial regrid REBUILDS it then REDISTRIBUTES round-robin

  // (DistributionMapping(nfine, n_ranks())) -> multi-GPU distribution of the fine patches. When distributed,

  // the coarse is distributed TOO (AMR strong-scaling).

  const auto [bac, dm] = coupler_make_coarse_layout(bp.n, bp.distribute_coarse, bp.coarse_max_grid);

  const int ng = Limiter::n_ghost;  // limiter stencil (1 NoSlope, 2 MUSCL): scheme parity

  MultiFab Uc(bac, dm, nc, ng);

  Uc.set_val(Real(0));

  std::vector<AmrLevelMP> levels;

  levels.push_back({std::move(Uc), nullptr, dxc, dxc});

  // Level 1 (central seed fine patch, reshaped by the regrid): allocated ONLY on the explicit/imex path

  // AND when refinement is actually configured (set_refinement was called -> refine_threshold below its

  // 1e30 "no refinement" sentinel). Two reasons to gate it:

  //   - amr-schur (Step 2/3) runs MONO-LEVEL: the condensed source stage does not yet carry the multi-level

  //     case (cf. AmrCondensedSchurSourceStepper, guard on the number of fine patches), so a seed would trip

  //     that guard at the first step. Multi-level amr-schur (fine reconstruction + cascade + composite

  //     Schur/Poisson) is Step 4.

  //   - NO refinement (ADC-324): with the 1e30 sentinel the build-time regrid below (cpl->regrid(crit)) tags

  //     nothing and amr_regrid_finest is a deliberate no-op on zero tags, so the seed would NEVER be reshaped

  //     or removed -- it would persist as a SINGLE un-chopped fine box on the coarse dmap (box 0 -> rank 0),

  //     dead weight that starves MPI strong-scaling (rank 0 carries its coarse boxes PLUS the whole fine

  //     patch). Gating on refine_threshold keeps the no-refinement hierarchy MONO-LEVEL (n_patches()==0, like

  //     the amr-schur path), so the coarse distributes cleanly. When refinement IS configured the seed is

  //     allocated and the first build regrid chops + distributes it round-robin exactly as before (UNCHANGED).

  if (!bp.schur && bp.refine_threshold < 1e30) {

    const int I0 = bp.n / 4, I1 = 3 * bp.n / 4 - 1, J0 = bp.n / 4, J1 = 3 * bp.n / 4 - 1;

    Box2D fb{{2 * I0, 2 * J0}, {2 * I1 + 1, 2 * J1 + 1}};

    BoxArray baf(std::vector<Box2D>{fb});

    MultiFab Uf(baf, dm, nc, ng);

    Uf.set_val(Real(0));

    levels.push_back({std::move(Uf), nullptr, dxf, dxf});

  }


  auto cpl = std::make_shared<Coupler>(model, g, bac, bp.poisson_bc, std::move(levels), bp.wall,

                                       !bp.distribute_coarse);

  // Coarse seed: COMPLETE conservative state (preferred, set_conservative_state) otherwise density

  // only (historical). coupler_inject_coarse_to_fine_mb prolongs ALL components (loop k<nc), so the

  // momentum of the seed propagates freely to the fine levels -- no change of prolongation.

  // has_state==false -> bit-identical density path (NO-DEFAULT-CHANGE).

  if (bp.has_state)

    coupler_write_coarse_state(cpl->coarse(), bp.state, bp.n, nc);

  else if (bp.has_density)

    coupler_write_coarse(cpl->coarse(), bp.density, bp.n, nc, bp.gamma);

  auto& Lv = cpl->levels();

  for (std::size_t k = 1; k < Lv.size(); ++k)

    coupler_inject_coarse_to_fine_mb(cpl->coarse(), Lv[k].U, !bp.distribute_coarse);


  const double thr = bp.refine_threshold;

  auto crit = [thr](const ConstArray4& a, int i, int j) { return a(i, j, 0) > thr; };

  if (cpl->levels().size() > 1)

    cpl->regrid(crit);  // no regrid on a mono-level hierarchy (amr-schur)

  // model-NAMED aux (ADC-291): seed the static named fields onto the coupler's shared aux BEFORE the

  // first update/step (like density/B_z seeding). The coupler re-applies them in compute_aux each

  // update, so they persist across regrid and reach every level via the aux injection. Empty -> no-op.

  for (const auto& kv : bp.named_aux)

    cpl->set_named_aux(kv.first, std::vector<Real>(kv.second.begin(), kv.second.end()));

  // ADC-369: per-field aux halo policies (compute_aux applies them after the shared fill).

  for (const auto& kv : bp.named_aux_bc)

    cpl->set_named_aux_bc(kv.first, kv.second);

  cpl->update();


  AmrCompiledHooks h;

  h.coupler_holder = cpl;  // lifetime: the closures capture cpl (shared_ptr)

  const int sub = bp.substeps;

  const bool rprim = bp.recon_prim;

  const bool imex = bp.imex;  // implicit stiff source (backward_euler) rather than forward Euler

  const int regrid_every = bp.regrid_every;

  // NEWTON OPTIONS of the mono-block IMEX source (wave 3): threaded to cpl->step -> advance_amr ->

  // backward_euler_source. DEFAULT {} (newton_options not set) = historical constants (2 iters) ->

  // bit-identical path (2a). Captured BY VALUE (POD) in the h.step closure.

  const NewtonOptions nopts = bp.newton_options;

  // TIME METHOD mono-block: integer of the flat ABI (bp.time_method) -> AmrTimeMethod, threaded to

  // cpl->step -> advance_amr. 0 (default / older .so loader) = historical kEuler, bit-identical.

  const AmrTimeMethod tmethod =

      bp.time_method == 1 ? AmrTimeMethod::kSsprk3 : AmrTimeMethod::kEuler;

  // Zhang-Shu positivity floor (ADC-259): threaded to cpl->step / advance_transport -> advance_amr ->

  // compute_face_fluxes + C/F ghost clamp. bp.pos_floor == 0 (default / older flat-ABI .so loader that

  // never sets this append-only field) -> inactive, bit-identical historical path.

  const Real pf = static_cast<Real>(bp.pos_floor);

  auto step_state = std::make_shared<int>(0);  // step counter shared by the closure

  if (bp.schur) {

    // amr-schur PATH: GLOBAL condensed source stage (electrostatic/Lorentz) instead of the LOCAL

    // explicit/imex source. The stage is built on the COARSE grid by COMPOSING the uniform stage #126

    // (Density/MomentumX/MomentumY roles of the Model -> clear error HERE if missing). Coarse B_z required

    // (set_magnetic_field). The model must be SOURCE-FREE (NoSource source brick): advance_transport

    // then runs NO source (the source is the condensed stage alone), mirror of the uniform path where the

    // block is added with its transport only (time.hyperbolic) + the separate condensed source stage.

    //

    // WARNING: OPTION A = INTERMEDIATE. The condensed stage solves the elliptic on the COARSE grid (like the

    // AMR Poisson compute_aux/solve_fields), then grad phi is injected (piecewise constant) to the fines: the

    // fine patches refine the TRANSPORT but NOT the elliptic coupling. For a FAITHFUL paper/AMR reproduction

    // a multi-level COMPOSITE Schur/Poisson will be needed (condensed elliptic solved at the patch

    // resolution, composite MG crossing the levels) -- infrastructure absent today (GeometricMG

    // coarsens ONE grid, != AMR hierarchy). This is the fidelity lock, to do AFTER the mono-level parity.

    // RESOLUTION of the field descriptors (wave 3 audit, parity with System::set_source_stage):

    // "" = canonical role (historical, bit-identical); otherwise stable ROLE name then block VARIABLE name.

    // Failure = explicit error at build (never a silent ignore).

    const VariableSet schur_vs = Model::conservative_vars();

    auto resolve_schur = [&schur_vs](const std::string& spec, VariableRole canonical,

                                     const char* label) -> int {

      if (spec.empty()) {

        const int idx = schur_vs.index_of(canonical);

        if (idx < 0)

          throw std::runtime_error(

              std::string("AmrSystem::set_source_stage: the block does not expose "

                          "the role ") +

              label + " (declare the roles, or pass an explicit descriptor)");

        return idx;

      }

      const VariableRole r = role_from_name(spec);

      if (r != VariableRole::Custom) {

        const int idx = schur_vs.index_of(r);

        if (idx < 0)

          throw std::runtime_error("AmrSystem::set_source_stage: role '" + spec + "' missing (" +

                                   label + ")");

        return idx;

      }

      for (std::size_t i = 0; i < schur_vs.names.size(); ++i)

        if (schur_vs.names[i] == spec)

          return static_cast<int>(i);

      throw std::runtime_error("AmrSystem::set_source_stage: '" + spec +

                               "' is neither a stable role nor a block variable (" + label + ")");

    };

    const int sc_rho = resolve_schur(bp.schur_density, VariableRole::Density, "Density");

    const int sc_mx = resolve_schur(bp.schur_momentum_x, VariableRole::MomentumX, "MomentumX");

    const int sc_my = resolve_schur(bp.schur_momentum_y, VariableRole::MomentumY, "MomentumY");

    const int sc_E = (bp.schur_energy == "none")

                         ? -1

                         : (bp.schur_energy.empty()

                                ? schur_vs.index_of(VariableRole::Energy)

                                : resolve_schur(bp.schur_energy, VariableRole::Energy, "Energy"));

    auto schur = std::make_shared<AmrCondensedSchurSourceStepper>(

        schur_vs, sc_rho, sc_mx, sc_my, sc_E, g, bac, bp.poisson_bc,

        static_cast<Real>(bp.schur_alpha));

    if (bp.schur_krylov_tol > 0.0 || bp.schur_krylov_max_iters > 0)

      schur->set_krylov(

          bp.schur_krylov_tol > 0.0 ? static_cast<Real>(bp.schur_krylov_tol) : Real(1e-10),

          bp.schur_krylov_max_iters > 0 ? bp.schur_krylov_max_iters : 400);

    auto bz_coarse = std::make_shared<MultiFab>(bac, dm, 1, 1);

    amr_write_coarse_bz(*bz_coarse, bp.bz_field, bp.n);

    auto phi_coarse = std::make_shared<MultiFab>(bac, dm, 1, 1);

    phi_coarse->set_val(Real(0));

    const double theta = bp.schur_theta;

    const bool strang = bp.schur_strang;

    h.step = [cpl, crit, sub, rprim, regrid_every, step_state, schur, bz_coarse, phi_coarse, theta,

              strang, model, pf](double dt) {

      // amr-schur Step 2/3: MONO-LEVEL hierarchy (the condensed stage does not carry the multi-level case).

      // So we do NOT regrid (a regrid would create a fine patch -> multi-level guard of the stage). The

      // amr-schur regrid will come with the composite Schur/Poisson (Step 4). cf. levels().size() > 1.

      if (regrid_every > 0 && *step_state > 0 && *step_state % regrid_every == 0 &&

          cpl->levels().size() > 1)

        cpl->regrid(crit);

      const double h2 = dt / sub;

      for (int s = 0; s < sub; ++s) {

        if (strang) {

          // STRANG (2nd order): H(dt/2); S(dt); H(dt/2), with update() (= sync_down + coarse Poisson

          // + grad inject, the AMR counterpart of solve_fields) RE-SOLVED BEFORE each stage that

          // consumes phi -- exactly SystemStepper::step_strang (3 solves: head, pre-source, post-source).

          cpl->update();

          cpl->template advance_transport<AmrDiscLF<Limiter, Flux>>(Real(0.5) * h2, rprim, pf);

          cpl->update();

          amr_schur_source(*cpl, *schur, *bz_coarse, *phi_coarse, theta, h2);

          cpl->update();

          cpl->template advance_transport<AmrDiscLF<Limiter, Flux>>(Real(0.5) * h2, rprim, pf);

        } else {

          // LIE (Godunov, 1st order): H(dt); S(dt). A single update() at the head (the source stage reads

          // the head phi), mirror of SystemStepper::step Lie (a single solve_fields, transport, source).

          cpl->update();

          cpl->template advance_transport<AmrDiscLF<Limiter, Flux>>(h2, rprim, pf);

          amr_schur_source(*cpl, *schur, *bz_coarse, *phi_coarse, theta, h2);

        }

      }

      // PROJECTION PONCTUELLE post-pas (ADC-177) PAR NIVEAU, APRES transport + source condensee de

      // tous les substeps. No-op si le modele ne declare pas m.project (HasPointwiseProjection false).

      detail::apply_pointwise_project_amr(model, cpl->levels());

      ++*step_state;

    };

  } else {

    h.step = [cpl, crit, sub, rprim, imex, regrid_every, step_state, nopts, tmethod, model,

              pf](double dt) {

      if (regrid_every > 0 && *step_state > 0 && *step_state % regrid_every == 0)

        cpl->regrid(crit);

      const double h2 = dt / sub;

      // NEWTON OPTIONS threaded to the coupler (mono-block): nopts={} by default => iters=2 historical,

      // bit-identical; non-default nopts (set_density + pops.IMEX(newton_*)) drives the local Newton.

      // tmethod (kEuler default) selects SSPRK3 if requested (time='ssprk3'); kEuler bit-identical.

      for (int s = 0; s < sub; ++s)

        cpl->template step<AmrDiscLF<Limiter, Flux>>(h2, rprim, imex, nopts, tmethod, pf);

      // PROJECTION PONCTUELLE post-pas (ADC-177) PAR NIVEAU, APRES transport + source de tous les

      // substeps. No-op si le modele ne declare pas m.project (HasPointwiseProjection false).

      detail::apply_pointwise_project_amr(model, cpl->levels());

      ++*step_state;

    };

  }

  // RESTORATION of the CADENCE PHASE (IO v1, parity with System::set_clock): AmrSystem::set_clock sets

  // the macro-step counter of the mono-block (the regrid cadence reads *step_state) on restart. Shares the

  // SAME step_state as the step closure above -> the regrid phase resumes exactly. Without the call,

  // *step_state stays at 0 (default, bit-identical).

  h.set_macro_step = [step_state](int s) { *step_state = s; };

  // CFL SPEED: lambda* (HasStabilitySpeed trait) if declared, otherwise max_wave_speed of the coupler

  // (historical fallback, bit-identical) -- SAME policy as System/make_max_speed, evaluated on the

  // COARSE grid (the AMR mono-block CFL lives at the coarse step).

  if constexpr (HasStabilitySpeed<Model>) {

    h.max_speed = [cpl, model] {

      return static_cast<double>(max_stability_speed_mf(model, cpl->coarse(), cpl->aux0()));

    };

  } else {

    h.max_speed = [cpl] { return static_cast<double>(cpl->max_wave_speed()); };

  }

  // OPTIONAL STEP BOUNDS (AMR mono-block StabilityPolicy): same reductions as System,

  // hooks left EMPTY without the trait (AmrSystem::step_cfl then keeps the historical formula).

  if constexpr (HasSourceFrequency<Model>) {

    h.source_frequency = [cpl, model] {

      return static_cast<double>(max_source_frequency_mf(model, cpl->coarse(), cpl->aux0()));

    };

  }

  if constexpr (HasStabilityDt<Model>) {

    h.stability_dt = [cpl, model] {

      return static_cast<double>(min_stability_dt_mf(model, cpl->coarse(), cpl->aux0()));

    };

  }

  h.mass = [cpl] { return static_cast<double>(cpl->mass()); };

  h.n_patches = [cpl] {

    auto& L = cpl->levels();

    return L.size() >= 2 ? static_cast<int>(L[1].U.box_array().size()) : 0;

  };

  // Index-space signatures of the fine patches (mono-block counterpart of AmrRuntime::patch_boxes).

  // Captures the SAME cpl as the other hooks (no new lifetime concern), reads the already materialized

  // BoxArray -> query between steps, zero cost on the hot path (h.step untouched).

  h.patch_boxes = [cpl] {

    auto& L = cpl->levels();

    std::vector<pops::PatchBox> out;

    for (std::size_t k = 1; k < L.size(); ++k) {

      const auto& bxs = L[k].U.box_array().boxes();

      for (const pops::Box2D& b : bxs)

        out.push_back(pops::PatchBox{static_cast<int>(k), b.lo[0], b.lo[1], b.hi[0], b.hi[1]});

    }

    return out;

  };

  // Coarse-level (base) box counts (ADC-319, MPI ownership diagnostic): per-rank OWNED fabs of level 0

  // (local_size()) and the GLOBAL base box count (box_array().size()). Same cpl capture as the other

  // hooks (no new lifetime concern); a query between steps, zero cost on the hot path. distribute_coarse

  // -> local < total per rank (distributed coarse transport); replicated/single-box -> local == total.

  h.coarse_local_boxes = [cpl] { return cpl->coarse().local_size(); };

  h.coarse_total_boxes = [cpl] { return cpl->coarse().box_array().size(); };

  // AMR CHECKPOINT / RESTART single-rank (ADC-65): COMPLETE conservative state per level + phi

  // (warm-start) + imposing the saved fine hierarchy. Capture the SAME cpl (shared_ptr) as the

  // other hooks (no new lifetime concern). Single-rank: the coupler accessors loop over local_size()

  // (no gather) -- the facade rejects np>1 / multi-block upstream. These hooks are QUERIES/SETTERS

  // between steps: zero cost on the hot path (h.step untouched).

  h.n_levels = [cpl] { return cpl->nlev(); };

  h.n_vars = [] { return Model::n_vars; };

  h.level_state = [cpl](int k) { return cpl->level_state(k); };

  h.set_level_state = [cpl](int k, const std::vector<double>& s) { cpl->set_level_state(k, s); };

  h.level_potential = [cpl](int k) { return cpl->level_potential(k); };

  h.set_level_potential = [cpl](int k, const std::vector<double>& p) {

    cpl->set_level_potential(k, p);

  };

  // GLOBAL (np>1 gather) counterparts (ADC-509): the facade routes to these under MPI np>1 so a

  // bit-identical checkpoint gathers the distributed per-level fabs onto rank 0 (COLLECTIVE, all ranks

  // call). Mono-rank they return the same array as the non-global hooks above (reduce = identity).

  h.level_state_global = [cpl](int k) { return cpl->level_state_global(k); };

  h.level_potential_global = [cpl](int k) { return cpl->level_potential_global(k); };

  h.set_hierarchy = [cpl](const std::vector<pops::PatchBox>& boxes) {

    // Mono-block: all patches live at level 1 -> we filter level == 1 and convert to Box2D

    // (INCLUSIVE corners, fine-level index space), then impose this BoxArray on the coupler.

    std::vector<pops::Box2D> fb;

    for (const pops::PatchBox& b : boxes)

      if (b.level == 1)

        fb.push_back(pops::Box2D{{b.ilo, b.jlo}, {b.ihi, b.jhi}});

    cpl->set_hierarchy(fb);

  };

  const int nn = bp.n;

  const bool repl = !bp.distribute_coarse;

  h.density = [cpl, nn, repl] { return coupler_read_coarse(cpl->coarse(), nn, repl); };

  // Coarse phi: we refresh (update() = sync_down + compute_aux, hence coarse Poisson solve)

  // then read aux0 component 0. Counterpart of System::potential() which calls ensure_elliptic: the

  // value is current even if no step has run yet. update() is already called at each step,

  // so the overhead exists only on a call outside the loop (diagnostic).

  h.potential = [cpl, nn, repl] {

    cpl->update();

    return coupler_read_coarse_phi(cpl->aux0(), nn, repl);

  };

  return h;

}


struct SharedAmrLayout {

  Geometry geom;                         // geometry of the coarse level (Poisson)

  BoxArray ba_coarse;                    // BoxArray of the coarse grid

  DistributionMapping dm_coarse;         // DistributionMapping of the coarse grid

  std::vector<BoxArray> ba;              // [level] shared BoxArray (coarse + fines)

  std::vector<DistributionMapping> dm;   // [level] shared DistributionMapping

  std::vector<Real> dx, dy;              // [level] mesh spacing

  bool replicated_coarse = true;         // ownership of level 0

  BCRec poisson_bc;                      // BC of the coarse Poisson

  std::function<bool(Real, Real)> wall;  // conducting-wall predicate (empty = none)

  int n = 128;                           // coarse cells per direction

  Periodicity base_per{true, true};      // periodicity of the base domain


  int nlev() const { return static_cast<int>(ba.size()); }

};


inline SharedAmrLayout make_shared_amr_layout(const AmrBuildParams& bp) {

  SharedAmrLayout S;

  S.geom = Geometry{Box2D::from_extents(bp.n, bp.n), 0.0, bp.L, 0.0, bp.L};

  S.n = bp.n;

  S.replicated_coarse = !bp.distribute_coarse;

  S.poisson_bc = bp.poisson_bc;

  S.wall = bp.wall;

  const double dxc = bp.L / bp.n, dxf = dxc / 2;

  const auto [bac, dmc] =

      detail::coupler_make_coarse_layout(bp.n, bp.distribute_coarse, bp.coarse_max_grid);

  S.ba_coarse = bac;

  S.dm_coarse = dmc;

  // Central FIXED fine patch: same signatures as build_amr_compiled (coarse cells

  // [n/4 .. 3n/4-1]^2, refined x2). DISTRIBUTED round-robin DistributionMapping(nfine, n_ranks()),

  // EXACTLY like the regrid of the mono-block path (amr_regrid_finest): the fine patches are

  // distributed over the ranks (one per GPU). This is ESSENTIAL under MPI: on the REPLICATED coarse,

  // if the fine were placed on the same replicated dmap ({my_rank()}), EACH rank would hold a copy

  // of the fine box and the reflux (all_reduce_sum_inplace of the flux registers) would sum the SAME

  // contribution n_ranks() times -> mass over-counted (grows with np). In serial (np=1) the round-robin

  // dmap places the box on rank 0, identical to {my_rank()}: bit-identical.

  const int I0 = bp.n / 4, I1 = 3 * bp.n / 4 - 1, J0 = bp.n / 4, J1 = 3 * bp.n / 4 - 1;

  const Box2D fb{{2 * I0, 2 * J0}, {2 * I1 + 1, 2 * J1 + 1}};

  BoxArray baf(std::vector<Box2D>{fb});

  DistributionMapping dmf(baf.size(),

                          n_ranks());  // fine distributed round-robin (one patch per rank)

  S.ba = {bac, baf};

  S.dm = {dmc, dmf};

  S.dx = {dxc, dxf};

  S.dy = {dxc, dxf};

  return S;

}


template <class Model, class Limiter, class Flux>


AmrRuntimeBlock build_amr_block(

    const Model& model, const SharedAmrLayout& S, const std::string& name,

    const std::vector<double>& density, bool has_density, double gamma, int substeps,

    bool recon_prim, bool imex, int stride = 1, const std::vector<int>& implicit_components = {},

    const NewtonOptions& nopts = {}, const std::vector<double>* state = nullptr,

    bool newton_diagnostics = false, AmrTimeMethod time_method = AmrTimeMethod::kEuler,

    double pos_floor = 0.0) {

  const int nc = Model::n_vars;

  const int ng = Limiter::n_ghost;  // limiter stencil (scheme parity, like build_amr_compiled)

  const int nlev = S.nlev();

  auto levels = std::make_shared<std::vector<AmrLevelMP>>();

  levels->reserve(nlev);

  for (int k = 0; k < nlev; ++k) {

    MultiFab U(S.ba[k], S.dm[k], nc, ng);

    U.set_val(Real(0));

    levels->push_back(AmrLevelMP{std::move(U), nullptr, S.dx[k], S.dy[k]});

  }

  // Coarse seed + piecewise-constant injection to the fines, exactly like

  // build_amr_compiled: COMPLETE CONSERVATIVE STATE (set_conservative_state, wave 3: now

  // wired in multi-block, preferred) otherwise density (component 0, rest at rest) otherwise zero.

  if (state && !state->empty())

    detail::coupler_write_coarse_state((*levels)[0].U, *state, S.n, nc);

  else if (has_density)

    detail::coupler_write_coarse((*levels)[0].U, density, S.n, nc, gamma);

  for (int k = 1; k < nlev; ++k)

    detail::coupler_inject_coarse_to_fine_mb((*levels)[0].U, (*levels)[k].U, S.replicated_coarse);


  AmrRuntimeBlock b;

  b.name = name;

  b.ncomp = nc;

  b.gamma = gamma;

  b.substeps = substeps;

  b.stride = stride;

  b.imex = imex;  // time treatment of the block: selects advance vs imex_advance in step()

  b.aux_ncomp = aux_comps<Model>();  // aux width READ by the model (B_z/T_e -> > kAuxBaseComps)

  b.cons_vars =

      Model::conservative_vars();  // names + ROLES: role resolution -> component of coupled sources

  b.levels = levels;


  const bool rprim = recon_prim;

  // advance: ONE AMR transport sub-step of the block (conservative Berger-Oliger + reflux + average_down)

  // of size dt, with ITS scheme (Limiter, Flux) on ITS level stack, source in

  // FORWARD EULER (imex=false always here: the IMEX path lives in imex_advance, selected by

  // step()). The sub-step loop (substeps) and the stride cadence are CARRIED by AmrRuntime::step,

  // not by this closure: thus the multirate semantics are in ONE place in the engine (mirror

  // of AmrSystemCoupler::step) and stay disableable / testable there. Implicit FUNCTOR:

  // advance_amr<Limiter, Flux> is a named template function (no cross-TU extended lambda);

  // we capture it in a std::function from THIS TU (device-clean recipe #64/#97).

  // tmethod (kEuler default) selects SSPRK3 (time='ssprk3') for the explicit transport of the block;

  // kEuler -> historical forward Euler, bit-identical. The explicit source stays carried by advance_amr.

  b.advance = [model, rprim, time_method, pos_floor](std::vector<AmrLevelMP>& L, const Box2D& dom,

                                                     Real dt, Periodicity per, bool repl) {

    advance_amr<Limiter, Flux>(model, L, dom, dt, per, repl, rprim, /*imex=*/false, NewtonOptions{},

                               time_method, static_cast<Real>(pos_floor));

  };

  // imex_advance (capstone vii): ONE Lie step [source-free transport; implicit source] whose

  // SEMANTICS mirror the IMEX branch of AmrSystemCoupler::step (SourceFreeModel + AmrImplicitSourceStepper),

  // populated ONLY if imex. (1) EXPLICIT transport on the SOURCE-FREE model (SourceFreeModel<Model>:

  // flux/CFL of the model, null source) by the SAME AMR engine (conservative reflux); (2) stiff source

  // IMPLICIT backward_euler_source AT EACH LEVEL (local Newton), with the mask @p implicit_components

  // carried by the BLOCK (partial IMEX); (3) cascade fine -> coarse (mf_average_down_mb) for the coherence

  // of the covered coarse cells. AmrRuntime::step calls this closure substeps times: at

  // substeps=1 this is exactly the compile-time IMEX branch, for substeps>1 the runtime SUB-CYCLES the

  // splitting (assumed decision, cf. IMEX SEMANTICS UNDER substeps in amr_runtime.hpp).

  // We CAPTURE the mask in an ImplicitMask<Model::n_vars> (device-clean POD) once here (the

  // width n_vars is known only at build, the mask is inactive if implicit_components is empty ->

  // full backward-Euler, bit-identical to IMEX without a mask). SourceFreeModel<Model> is a concrete

  // type instantiated IN this TU: its advance_amr<Limiter, Flux> stays compiled (no cross-TU extended

  // lambda), captured in the std::function of identical signature to advance. The reconstruction

  // of the source-free half-step stays CONSERVATIVE (recon_prim=false): SAME choice as AmrSystemCoupler::step

  // (which calls advance_amr on SourceFreeModel with the default), and SourceFreeModel does not expose

  // the primitive variables anyway (cf. its header). The EXPLICIT block, for its part, keeps recon_prim=rprim.

  if (imex) {

    ImplicitMask<Model::n_vars> mask;

    for (int c : implicit_components)

      if (c >= 0 && c < Model::n_vars) {

        mask.active = true;

        mask.flag[c] = true;

      }

    // NEWTON DIAGNOSTICS (OPT-IN, wave 3): we allocate the AGGREGATE report of the block in a shared_ptr

    // (STABLE address even after moving the AmrRuntimeBlock into the engine registry) and we

    // capture its raw pointer in the imex_advance closure. newton_diagnostics==false (default) ->

    // nreport=nullptr -> backward_euler_source FAST path, bit-identical. The RESET of the report is the

    // responsibility of AmrRuntime::step (head of the block advance), like System::AdvanceImex.

    std::shared_ptr<NewtonReport> nrep;

    if (newton_diagnostics) {

      nrep = std::make_shared<NewtonReport>();

      b.newton_diagnostics = true;

      b.newton_report = nrep;

    }

    NewtonReport* nreport = nrep.get();  // null without diagnostics; stable address otherwise

    b.imex_advance = [model, mask, nopts, nreport, pos_floor](std::vector<AmrLevelMP>& L,

                                                              const Box2D& dom, Real dt,

                                                              Periodicity per, bool repl) {

      // (1) explicit source-free transport (-div F only), reflux carries the hyperbolic conservation.

      // The Zhang-Shu floor (ADC-259) applies to the source-free TRANSPORT (the half-step that

      // reconstructs faces); the stiff implicit source backward_euler_source below stays unfloored

      // (cell-local, parity with the uniform System IMEX). SourceFreeModel<Model> forwards

      // conservative_vars(), so positivity_comp resolves the SAME Density-role component.

      advance_amr<Limiter, Flux>(SourceFreeModel<Model>{model}, L, dom, dt, per, repl,

                                 /*recon_prim=*/false, /*imex=*/false, NewtonOptions{},

                                 AmrTimeMethod::kEuler, static_cast<Real>(pos_floor));

      // (2) stiff implicit source backward-Euler PER LEVEL (local Newton, block mask). The report

      // nreport (null without diagnostics) AGGREGATES over the levels: backward_euler_source does its own

      // max/sum + MPI all_reduce into *nreport (no reset here -> it also accumulates over the sub-steps,

      // step() having reset at the head of the advance). nreport==nullptr -> fast bit-identical path.

      const int nlev_l = static_cast<int>(L.size());

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

        backward_euler_source<Model>(model, *L[k].aux, L[k].U, dt, nopts, mask, nreport);

      // (3) COVERAGE INVARIANT (cf. AmrImplicitSourceStepper): the implicit source was solved

      // level by level, so a COVERED coarse cell would carry a phantom coarse source

      // instead of the 2x2 average of its children. Cascade fine -> coarse for the coherence (the mass,

      // sum of the coarse grid alone, then does not count the patch source twice). Mono-level: empty loop

      // -> bit-identical. The source remaining CELL-LOCAL (not a face flux), it does NOT enter

      // the reflux registers: conservation at the coarse-fine interfaces stays intact.

      for (int k = nlev_l - 1; k >= 1; --k)

        mf_average_down_mb(L[k].U, L[k - 1].U);

    };

  }

  // PROJECTION PONCTUELLE post-pas (ADC-177) : cablee SEULEMENT si le modele declare m.project

  // (HasPointwiseProjection). AmrRuntime::step l'applique PAR NIVEAU a la FIN de l'avance du bloc

  // (substeps + reflux/cascade faits). Vide sinon -> trajectoire bit-identique. Capture le `model`

  // concret comme advance / imex_advance (foncteur device-clean, pas de lambda etendue cross-TU).

  if constexpr (HasPointwiseProjection<Model>)

    b.project_per_level = [model](std::vector<AmrLevelMP>& L) {

      detail::apply_pointwise_project_amr(model, L);

    };

  // Contribution of the block to the SUMMED Poisson RHS: rhs += elliptic_rhs(U) on the coarse grid (pure

  // host loop). SAME functor as the flat System (make_poisson_rhs -> detail::PoissonRhs) -> each

  // block accumulates (+=) into the SAME cells of the shared coarse grid (per-cell co-location).

  b.add_elliptic_rhs = make_poisson_rhs(model);

  // CFL SPEED of the block: SAME policy as System (make_max_speed) -- stability lambda*

  // (HasStabilitySpeed trait) if the model declares it, otherwise max_wave_speed (historical fallback,

  // bit-identical). The Riemann solvers always read max_wave_speed.

  if constexpr (HasStabilitySpeed<Model>) {

    b.max_speed = [model](const MultiFab& U, const MultiFab& aux) {

      return max_stability_speed_mf(model, U, aux);

    };

  } else {

    b.max_speed = [model](const MultiFab& U, const MultiFab& aux) {

      return max_wave_speed_mf(model, U, aux);

    };

  }

  // OPTIONAL STEP BOUNDS (AMR StabilityPolicy): same reductions as System

  // (max_source_frequency_mf / min_stability_dt_mf), evaluated by AmrRuntime::step_cfl on the

  // COARSE grid. Closures left EMPTY when the model does not declare the trait (bit-identical).

  if constexpr (HasSourceFrequency<Model>) {

    b.source_frequency = [model](const MultiFab& U, const MultiFab& aux) {

      return max_source_frequency_mf(model, U, aux);

    };

  }

  if constexpr (HasStabilityDt<Model>) {

    b.stability_dt = [model](const MultiFab& U, const MultiFab& aux) {

      return min_stability_dt_mf(model, U, aux);

    };

  }

  const Geometry g = S.geom;

  const bool repl = S.replicated_coarse;

  b.mass = [levels, g, repl] {

    const MultiFab& U = (*levels)[0].U;

    const Real dV = g.dx() * g.dy();

    Real M = 0;

    for (int li = 0; li < U.local_size(); ++li) {

      const ConstArray4 u = U.fab(li).const_array();

      M += for_each_cell_reduce_sum(U.box(li),

                                    [u, dV] POPS_HD(int i, int j) { return u(i, j, 0) * dV; });

    }

    return repl ? M : all_reduce_sum(M);

  };

  const int nn = S.n;

  b.density = [levels, nn, repl] { return detail::coupler_read_coarse((*levels)[0].U, nn, repl); };

  b.potential = [nn, repl](const MultiFab& aux0) {

    return detail::coupler_read_coarse_phi(aux0, nn, repl);

  };

  return b;

}


// ADC-359 per-flux branches of dispatch_amr_block, factored so the compressible AMR seam compiles ONE

// flux per TU (build_amr_block_for_flux -> these). Each body is the corresponding `if (riem == "<flux>")`

// branch of dispatch_amr_block VERBATIM (same leaves, same hllc/roe `if constexpr` capability guards, same

// messages); validate_riemann/limiter run in the caller (dispatch_amr_block, or the compressible thin

// dispatcher python/amr_block_compressible.cpp). dispatch_amr_block (below, unchanged) still serves the

// exb/isothermal seam, where the if constexpr guards prune hllc/roe.

template <class Model>


AmrRuntimeBlock dispatch_amr_block_rusanov(

    const Model& m, const std::string& lim, const SharedAmrLayout& S, const std::string& name,

    const std::vector<double>& density, bool has_density, double gamma, int substeps,

    bool recon_prim, bool imex, int stride, const std::vector<int>& implicit_components,

    const NewtonOptions& nopts, const std::vector<double>* state, bool newton_diagnostics,

    AmrTimeMethod time_method, double pos_floor) {

  if (lim == "none")

    return build_amr_block<Model, NoSlope, RusanovFlux>(

        m, S, name, density, has_density, gamma, substeps, recon_prim, imex, stride,

        implicit_components, nopts, state, newton_diagnostics, time_method, pos_floor);

  if (lim == "minmod")

    return build_amr_block<Model, Minmod, RusanovFlux>(

        m, S, name, density, has_density, gamma, substeps, recon_prim, imex, stride,

        implicit_components, nopts, state, newton_diagnostics, time_method, pos_floor);

  if (lim == "vanleer")

    return build_amr_block<Model, VanLeer, RusanovFlux>(

        m, S, name, density, has_density, gamma, substeps, recon_prim, imex, stride,

        implicit_components, nopts, state, newton_diagnostics, time_method, pos_floor);

  if (lim == "weno5")

    return build_amr_block<Model, Weno5, RusanovFlux>(

        m, S, name, density, has_density, gamma, substeps, recon_prim, imex, stride,

        implicit_components, nopts, state, newton_diagnostics, time_method, pos_floor);

  throw_registry_dispatch_mismatch("add_block(AmrSystem, multi-block)", "limiteur", lim);

}


template <class Model>


AmrRuntimeBlock dispatch_amr_block_hll(const Model& m, const std::string& lim,

                                       const SharedAmrLayout& S, const std::string& name,

                                       const std::vector<double>& density, bool has_density,

                                       double gamma, int substeps, bool recon_prim, bool imex,

                                       int stride, const std::vector<int>& implicit_components,

                                       const NewtonOptions& nopts, const std::vector<double>* state,

                                       bool newton_diagnostics, AmrTimeMethod time_method,

                                       double pos_floor) {

  if constexpr (requires(const Model mm, typename Model::State s, Aux a, Real r) {

                  mm.wave_speeds(s, a, 0, r, r);

                }) {

    if (lim == "none")

      return build_amr_block<Model, NoSlope, HLLFlux>(

          m, S, name, density, has_density, gamma, substeps, recon_prim, imex, stride,

          implicit_components, nopts, state, newton_diagnostics, time_method, pos_floor);

    if (lim == "minmod")

      return build_amr_block<Model, Minmod, HLLFlux>(

          m, S, name, density, has_density, gamma, substeps, recon_prim, imex, stride,

          implicit_components, nopts, state, newton_diagnostics, time_method, pos_floor);

    if (lim == "vanleer")

      return build_amr_block<Model, VanLeer, HLLFlux>(

          m, S, name, density, has_density, gamma, substeps, recon_prim, imex, stride,

          implicit_components, nopts, state, newton_diagnostics, time_method, pos_floor);

    if (lim == "weno5")

      return build_amr_block<Model, Weno5, HLLFlux>(

          m, S, name, density, has_density, gamma, substeps, recon_prim, imex, stride,

          implicit_components, nopts, state, newton_diagnostics, time_method, pos_floor);

    throw_registry_dispatch_mismatch("add_block(AmrSystem, multi-block)", "limiteur", lim);

  } else {

    throw std::runtime_error(

        "add_block(AmrSystem, multi-block): flux 'hll' requires signed wave "

        "speeds (model.wave_speeds); this transport -> 'rusanov'");

  }

}


template <class Model>


AmrRuntimeBlock dispatch_amr_block_hllc(const Model& m, const std::string& lim,

                                        const SharedAmrLayout& S, const std::string& name,

                                        const std::vector<double>& density, bool has_density,

                                        double gamma, int substeps, bool recon_prim, bool imex,

                                        int stride, const std::vector<int>& implicit_components,

                                        const NewtonOptions& nopts,

                                        const std::vector<double>* state, bool newton_diagnostics,

                                        AmrTimeMethod time_method, double pos_floor) {

  if constexpr (HasHLLCStructure<Model> ||

                (Model::n_vars == 4 &&

                 requires(const Model mm, typename Model::State s) { mm.pressure(s); })) {

    if (lim == "none")

      return build_amr_block<Model, NoSlope, HLLCFlux>(

          m, S, name, density, has_density, gamma, substeps, recon_prim, imex, stride,

          implicit_components, nopts, state, newton_diagnostics, time_method, pos_floor);

    if (lim == "minmod")

      return build_amr_block<Model, Minmod, HLLCFlux>(

          m, S, name, density, has_density, gamma, substeps, recon_prim, imex, stride,

          implicit_components, nopts, state, newton_diagnostics, time_method, pos_floor);

    if (lim == "vanleer")

      return build_amr_block<Model, VanLeer, HLLCFlux>(

          m, S, name, density, has_density, gamma, substeps, recon_prim, imex, stride,

          implicit_components, nopts, state, newton_diagnostics, time_method, pos_floor);

    if (lim == "weno5")

      return build_amr_block<Model, Weno5, HLLCFlux>(

          m, S, name, density, has_density, gamma, substeps, recon_prim, imex, stride,

          implicit_components, nopts, state, newton_diagnostics, time_method, pos_floor);

    throw_registry_dispatch_mismatch("add_block(AmrSystem, multi-block)", "limiteur", lim);

  } else {

    throw std::runtime_error(

        "add_block(AmrSystem, multi-block): flux 'hllc' requires a "

        "compressible Euler 2D transport (4 variables + pressure) OR the "

        "model's HLLC capability (pressure + wave_speeds + contact_speed + "

        "hllc_star_state, cf. HasHLLCStructure); this transport -> "

        "'hll'/'rusanov'");

  }

}


template <class Model>


AmrRuntimeBlock dispatch_amr_block_roe(const Model& m, const std::string& lim,

                                       const SharedAmrLayout& S, const std::string& name,

                                       const std::vector<double>& density, bool has_density,

                                       double gamma, int substeps, bool recon_prim, bool imex,

                                       int stride, const std::vector<int>& implicit_components,

                                       const NewtonOptions& nopts, const std::vector<double>* state,

                                       bool newton_diagnostics, AmrTimeMethod time_method,

                                       double pos_floor) {

  if constexpr (HasRoeDissipation<Model> ||

                (Model::n_vars == 4 &&

                 requires(const Model mm, typename Model::State s) { mm.pressure(s); })) {

    if (lim == "none")

      return build_amr_block<Model, NoSlope, RoeFlux>(

          m, S, name, density, has_density, gamma, substeps, recon_prim, imex, stride,

          implicit_components, nopts, state, newton_diagnostics, time_method, pos_floor);

    if (lim == "minmod")

      return build_amr_block<Model, Minmod, RoeFlux>(

          m, S, name, density, has_density, gamma, substeps, recon_prim, imex, stride,

          implicit_components, nopts, state, newton_diagnostics, time_method, pos_floor);

    if (lim == "vanleer")

      return build_amr_block<Model, VanLeer, RoeFlux>(

          m, S, name, density, has_density, gamma, substeps, recon_prim, imex, stride,

          implicit_components, nopts, state, newton_diagnostics, time_method, pos_floor);

    if (lim == "weno5")

      return build_amr_block<Model, Weno5, RoeFlux>(

          m, S, name, density, has_density, gamma, substeps, recon_prim, imex, stride,

          implicit_components, nopts, state, newton_diagnostics, time_method, pos_floor);

    throw_registry_dispatch_mismatch("add_block(AmrSystem, multi-block)", "limiteur", lim);

  } else {

    throw std::runtime_error(

        "add_block(AmrSystem, multi-block): flux 'roe' requires a "

        "compressible Euler 2D transport (4 variables + pressure) OR the "

        "model's Roe capability (roe_dissipation, cf. HasRoeDissipation); "

        "this transport -> 'hll'/'rusanov'");

  }

}


template <class Model>


AmrRuntimeBlock dispatch_amr_block(

    const Model& m, const std::string& lim, const std::string& riem, const SharedAmrLayout& S,

    const std::string& name, const std::vector<double>& density, bool has_density, double gamma,

    int substeps, bool recon_prim, bool imex, int stride = 1,

    const std::vector<int>& implicit_components = {}, const NewtonOptions& nopts = {},

    const std::vector<double>* state = nullptr, bool newton_diagnostics = false,

    AmrTimeMethod time_method = AmrTimeMethod::kEuler, double pos_floor = 0.0) {

  // CENTRALIZED VALIDATION (dispatch_tags.hpp registry) BEFORE the dispatch: same tags accepted /

  // rejected as before, identical messages. The template if/else dispatch that follows is UNCHANGED; the

  // capability guards (hllc/roe: 2D Euler or capability) stay `if constexpr` PER MODEL.

  validate_riemann(riem, /*polar=*/false, "add_block(AmrSystem, multi-block)");

  validate_limiter(lim, "add_block(AmrSystem, multi-block)");

  // ADC-359: delegate to the flux-pinned dispatch_amr_block_<flux> helpers above (factored so the

  // compressible seam compiles one flux per TU). Behavior is unchanged: same leaves, same hllc/roe

  // capability guards, same throws. exb/isothermal route here as before (their guards prune hllc/roe).

  if (riem == "rusanov")

    return dispatch_amr_block_rusanov(m, lim, S, name, density, has_density, gamma, substeps,

                                      recon_prim, imex, stride, implicit_components, nopts, state,

                                      newton_diagnostics, time_method, pos_floor);

  if (riem == "hll")

    return dispatch_amr_block_hll(m, lim, S, name, density, has_density, gamma, substeps,

                                  recon_prim, imex, stride, implicit_components, nopts, state,

                                  newton_diagnostics, time_method, pos_floor);

  if (riem == "hllc")

    return dispatch_amr_block_hllc(m, lim, S, name, density, has_density, gamma, substeps,

                                   recon_prim, imex, stride, implicit_components, nopts, state,

                                   newton_diagnostics, time_method, pos_floor);

  if (riem == "roe")

    return dispatch_amr_block_roe(m, lim, S, name, density, has_density, gamma, substeps,

                                  recon_prim, imex, stride, implicit_components, nopts, state,

                                  newton_diagnostics, time_method, pos_floor);

  throw_registry_dispatch_mismatch("add_block(AmrSystem, multi-block)", "flux", riem);

}


// ADC-359 per-flux branches of dispatch_amr_compiled, factored so the compressible compiled AMR seam

// compiles ONE flux per TU (build_amr_compiled_for_flux -> these). Each body is the corresponding

// `if (riem == "<flux>")` branch of dispatch_amr_compiled VERBATIM (same leaves, guards, messages);

// validate_* run in the caller. dispatch_amr_compiled (below, unchanged) still serves exb/isothermal.

template <class Model>


AmrCompiledHooks dispatch_amr_compiled_rusanov(const Model& m, const std::string& lim,

                                               const AmrBuildParams& bp) {

  if (lim == "none")

    return build_amr_compiled<Model, NoSlope, RusanovFlux>(m, bp);

  if (lim == "minmod")

    return build_amr_compiled<Model, Minmod, RusanovFlux>(m, bp);

  if (lim == "vanleer")

    return build_amr_compiled<Model, VanLeer, RusanovFlux>(m, bp);

  if (lim == "weno5")

    return build_amr_compiled<Model, Weno5, RusanovFlux>(m, bp);

  throw_registry_dispatch_mismatch("add_compiled_model(AmrSystem)", "limiteur", lim);

}


template <class Model>


AmrCompiledHooks dispatch_amr_compiled_hll(const Model& m, const std::string& lim,

                                           const AmrBuildParams& bp) {

  if constexpr (requires(const Model mm, typename Model::State s, Aux a, Real r) {

                  mm.wave_speeds(s, a, 0, r, r);

                }) {

    if (lim == "none")

      return build_amr_compiled<Model, NoSlope, HLLFlux>(m, bp);

    if (lim == "minmod")

      return build_amr_compiled<Model, Minmod, HLLFlux>(m, bp);

    if (lim == "vanleer")

      return build_amr_compiled<Model, VanLeer, HLLFlux>(m, bp);

    if (lim == "weno5")

      return build_amr_compiled<Model, Weno5, HLLFlux>(m, bp);

    throw_registry_dispatch_mismatch("add_compiled_model(AmrSystem)", "limiteur", lim);

  } else {

    throw std::runtime_error(

        "add_compiled_model(AmrSystem): flux 'hll' requires signed wave "

        "speeds (model.wave_speeds: declare a primitive 'p'); "

        "this transport -> 'rusanov'");

  }

}


template <class Model>


AmrCompiledHooks dispatch_amr_compiled_hllc(const Model& m, const std::string& lim,

                                            const AmrBuildParams& bp) {

  if constexpr (HasHLLCStructure<Model> ||

                (Model::n_vars == 4 &&

                 requires(const Model mm, typename Model::State s) { mm.pressure(s); })) {

    if (lim == "none")

      return build_amr_compiled<Model, NoSlope, HLLCFlux>(m, bp);

    if (lim == "minmod")

      return build_amr_compiled<Model, Minmod, HLLCFlux>(m, bp);

    if (lim == "vanleer")

      return build_amr_compiled<Model, VanLeer, HLLCFlux>(m, bp);

    if (lim == "weno5")

      return build_amr_compiled<Model, Weno5, HLLCFlux>(m, bp);

    throw_registry_dispatch_mismatch("add_compiled_model(AmrSystem)", "limiteur", lim);

  } else {

    throw std::runtime_error(

        "add_compiled_model(AmrSystem): flux 'hllc' requires a "

        "compressible Euler 2D transport (4 variables + pressure) OR the "

        "model's HLLC capability (pressure + wave_speeds + contact_speed + "

        "hllc_star_state, cf. HasHLLCStructure); this transport -> "

        "'hll'/'rusanov'");

  }

}


template <class Model>


AmrCompiledHooks dispatch_amr_compiled_roe(const Model& m, const std::string& lim,

                                           const AmrBuildParams& bp) {

  if constexpr (HasRoeDissipation<Model> ||

                (Model::n_vars == 4 &&

                 requires(const Model mm, typename Model::State s) { mm.pressure(s); })) {

    if (lim == "none")

      return build_amr_compiled<Model, NoSlope, RoeFlux>(m, bp);

    if (lim == "minmod")

      return build_amr_compiled<Model, Minmod, RoeFlux>(m, bp);

    if (lim == "vanleer")

      return build_amr_compiled<Model, VanLeer, RoeFlux>(m, bp);

    if (lim == "weno5")

      return build_amr_compiled<Model, Weno5, RoeFlux>(m, bp);

    throw_registry_dispatch_mismatch("add_compiled_model(AmrSystem)", "limiteur", lim);

  } else {

    throw std::runtime_error(

        "add_compiled_model(AmrSystem): flux 'roe' requires a "

        "compressible Euler 2D transport (4 variables + pressure) OR the "

        "model's Roe capability (roe_dissipation, cf. HasRoeDissipation); "

        "this transport -> 'hll'/'rusanov'");

  }

}


template <class Model>


AmrCompiledHooks dispatch_amr_compiled(const Model& m, const std::string& lim,

                                       const std::string& riem, const AmrBuildParams& bp) {

  // CENTRALIZED VALIDATION (dispatch_tags.hpp registry) BEFORE the dispatch: same tags accepted /

  // rejected as before. Template if/else dispatch UNCHANGED; per-model hllc/roe capability guards.

  validate_riemann(riem, /*polar=*/false, "add_compiled_model(AmrSystem)");

  validate_limiter(lim, "add_compiled_model(AmrSystem)");

  // ADC-359: delegate to the flux-pinned dispatch_amr_compiled_<flux> helpers above. Behavior unchanged

  // (same leaves, guards, throws); exb/isothermal route here as before (their guards prune hllc/roe).

  if (riem == "rusanov")

    return dispatch_amr_compiled_rusanov(m, lim, bp);

  if (riem == "hll")

    return dispatch_amr_compiled_hll(m, lim, bp);

  if (riem == "hllc")

    return dispatch_amr_compiled_hllc(m, lim, bp);

  if (riem == "roe")

    return dispatch_amr_compiled_roe(m, lim, bp);

  throw_registry_dispatch_mismatch("add_compiled_model(AmrSystem)", "flux", riem);

}


}  // namespace detail


inline std::vector<int> resolve_implicit_components_compiled(

    const std::string& block, const VariableSet& cons, const std::vector<std::string>& names,

    const std::vector<std::string>& roles) {

  std::vector<int> out;

  auto push_unique = [&out](int c) {

    if (std::find(out.begin(), out.end(), c) == out.end())

      out.push_back(c);

  };

  for (const std::string& nm : names) {

    int idx = -1;

    for (int i = 0; i < static_cast<int>(cons.names.size()); ++i)

      if (cons.names[i] == nm) {

        idx = i;

        break;

      }

    if (idx < 0)

      throw std::runtime_error("add_compiled_model(AmrSystem): implicit_vars: variable '" + nm +

                               "' missing from block '" + block + "'");

    push_unique(idx);

  }

  for (const std::string& rn : roles) {

    const VariableRole role = role_from_name(rn);

    const int idx = cons.index_of(role);

    if (role == VariableRole::Custom || idx < 0)

      throw std::runtime_error("add_compiled_model(AmrSystem): implicit_roles: role '" + rn +

                               "' missing from block '" + block + "'");

    push_unique(idx);

  }

  std::sort(out.begin(), out.end());

  return out;

}


template <class 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) {

  if (substeps < 1)

    throw std::runtime_error("add_compiled_model(AmrSystem): substeps >= 1");

  // PROJECTION PONCTUELLE post-pas (ADC-177) : DESORMAIS CABLEE sur AmrSystem. Appliquee PAR NIVEAU

  // a la fin de l'avance du pas (apres le reflux), aussi bien sur le coupleur mono-bloc

  // (build_amr_compiled -> cpl->levels()) que sur le multi-bloc natif (build_amr_block ->

  // AmrRuntime::step -> project_per_level). Cell-local + idempotente : conservation preservee (les

  // flux-registres sont deja regles). No-op si le modele ne declare pas m.project.

  // SSPRK3 IS NOT carried by the COMPILED path: neither the mono_builder nor the multi_builder

  // freezes AmrBuildParams::time_method / passes AmrTimeMethod to dispatch_amr_block (the flat ABI of the

  // .so loader does not marshal the method). EXPLICIT rejection rather than a silent kEuler fallback; an

  // SSPRK3 block must be NATIVE (AmrSystem::add_block / dispatch_amr_block, which threads it).

  if (time == "ssprk3")

    throw std::runtime_error(

        "add_compiled_model(AmrSystem): time='ssprk3' not carried by the "

        "compiled path (.so); use a native block pops.Model(...).");

  if (time != "explicit" && time != "imex")

    throw std::runtime_error("add_compiled_model(AmrSystem): time '" + time +

                             "' unknown (explicit|imex)");

  if (recon != "conservative" && recon != "primitive")

    throw std::runtime_error("add_compiled_model(AmrSystem): recon unknown '" + recon +

                             "' (conservative|primitive)");

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

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

  // (1) MONO-BLOCK builder: captures the concrete Model + the scheme, materializes the AmrCouplerMP at the

  // lazy build (refine/poisson/density parameters frozen at that point). Historical path, untouched.

  auto mono_builder = [model, limiter, riemann, recon_prim, imex](const AmrBuildParams& bp) {

    AmrBuildParams p = bp;

    p.recon_prim = recon_prim;

    p.imex = imex;

    return detail::dispatch_amr_compiled(model, limiter, riemann, p);

  };

  // (2) MULTI-BLOCK builder: captures the SAME concrete Model/scheme, materializes the AmrRuntimeBlock of the

  // block on the SHARED layout (common to all blocks, created once at ensure_built). Resolves ITSELF

  // the partial IMEX mask against cons_vars of the concrete Model (known here), then calls dispatch_amr_block

  // -- EXACTLY the native path of add_block, only the point of type resolution differs (here at

  // the add, there from a ModelSpec at build). FUNCTOR without a cross-TU extended lambda in the kernel:

  // dispatch_amr_block captures advance_amr<Limiter, Flux> (named template function), device-clean

  // recipe #64/#97; the outer lambda only orchestrates (no device kernel in its body).

  auto multi_builder = [model, limiter, riemann](

                           const detail::SharedAmrLayout& S, const std::string& bname,

                           const std::vector<double>& density, bool has_density, double bgamma,

                           int bsub, bool brecon_prim, bool bimex, int bstride,

                           const std::vector<std::string>& ivars,

                           const std::vector<std::string>& iroles, double bpos_floor) {

    const std::vector<int> impl_components =

        bimex

            ? resolve_implicit_components_compiled(bname, Model::conservative_vars(), ivars, iroles)

            : std::vector<int>{};

    // pos_floor (ADC-322): the .so flat ABI now carries the Zhang-Shu floor; forward it to the SAME

    // dispatch_amr_block -> build_amr_block leaf as a native multi-block. The compiled path transports

    // NEITHER Newton options/state/diagnostics NOR SSPRK3 (rejected at the facade / add_compiled_model),

    // so those intermediate arguments stay at their historical defaults (kEuler, no Newton, no state).

    return detail::dispatch_amr_block(

        model, limiter, riemann, S, bname, density, has_density, bgamma, bsub, brecon_prim, bimex,

        bstride, impl_components, NewtonOptions{},

        /*state=*/nullptr, /*newton_diagnostics=*/false, AmrTimeMethod::kEuler, bpos_floor);

  };

  sys.set_compiled_block(Model::n_vars, gamma, substeps, std::move(mono_builder),

                         std::move(multi_builder), name, recon_prim, imex, stride, implicit_vars,

                         implicit_roles, pos_floor);

}


}  // namespace pops

amr_condensed_schur_source_stepper.hpp
AmrCondensedSchurSourceStepper: AMR counterpart of the Schur-condensed SOURCE stage (CondensedSchurSo...

amr_coupler_mp.hpp
AmrCouplerMP: MULTI-PATCH E x B AMR coupler (coarse Poisson -> aux = grad phi -> fine injection -> co...

amr_runtime.hpp
AMR multi-block engine at RUNTIME (type-erased registry keyed by name).

amr_system.hpp
Multi-species composition on AMR at runtime: the refined counterpart of System.

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

box2d.hpp
Box2D: the integer index space of a 2D cell-centered Cartesian grid.

box_array.hpp
BoxArray: the set of boxes tiling a level (disjoint, covering).

pops::AmrCondensedSchurSourceStepper
Schur-condensed SOURCE stage over an AMR hierarchy.
Definition amr_condensed_schur_source_stepper.hpp:54

pops::AmrCondensedSchurSourceStepper::step
void step(std::vector< AmrLevelMP > &levels, MultiFab &coarse_phi, const MultiFab &coarse_bz, int c_bz, Real theta, Real dt)
Condensed SOURCE stage, IN-PLACE on the hierarchy levels and the coarse potential coarse_phi.
Definition amr_condensed_schur_source_stepper.hpp:105

pops::AmrCouplerMP
Multi-patch E x B AMR coupler.
Definition amr_coupler_mp.hpp:276

pops::AmrSystem
Single block carried on an AMR hierarchy, composed at runtime.
Definition amr_system.hpp:245

pops::AmrSystem::set_compiled_block
POPS_EXPORT void set_compiled_block(int ncomp, double gamma, int substeps, std::function< AmrCompiledHooks(const AmrBuildParams &)> mono_builder, AmrCompiledBlockBuilder multi_builder={}, const std::string &name=std::string(), bool recon_prim=false, bool imex=false, int stride=1, const std::vector< std::string > &implicit_vars={}, const std::vector< std::string > &implicit_roles={}, double pos_floor=0.0)
Registers a COMPILED block (add_compiled_model path, header amr_dsl_block.hpp).

pops::BoxArray
Ordered list of boxes tiling a level.
Definition box_array.hpp:22

pops::Coupler
Single-block hyperbolic-elliptic coupler.
Definition coupler.hpp:74

pops::DistributionMapping
Owning MPI rank of each box, indexed by GLOBAL box index (parallel to a BoxArray).
Definition distribution_mapping.hpp:19

pops::Fab2D::const_array
ConstArray4 const_array() const
READ handle (POD device-copyable) over this Fab. Valid as long as the Fab lives.
Definition fab2d.hpp:96

pops::Fab2D::array
Array4 array()
WRITE handle (POD device-copyable) over this Fab. Valid as long as the Fab lives.
Definition fab2d.hpp:91

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

pops::MultiFab::fab
Fab2D & fab(int li)
Local fab at index li (0 <= li < local_size()), for writing.
Definition multifab.hpp:67

pops::MultiFab::box
const Box2D & box(int li) const
VALID box of local fab li.
Definition multifab.hpp:71

pops::MultiFab::set_val
void set_val(Real v)
Fills all cells (valid + ghosts) of every local fab with v.
Definition multifab.hpp:85

pops::MultiFab::local_size
int local_size() const
Number of fabs OWNED by this rank (bound on local indices).
Definition multifab.hpp:65

comm.hpp
Parallel seam: minimal MPI abstraction (rank/size + collectives) with serial fallback.

pops::HasHLLCStructure
HLLC capability: the model provides the CONTACT wave speed and the STAR STATE on side k.
Definition numerical_flux.hpp:142

pops::HasPointwiseProjection
Trait OPTIONNEL : PROJECTION PONCTUELLE post-pas U -> project(U, aux) (ADC-177).
Definition physical_model.hpp:154

pops::HasRoeDissipation
Roe capability: the model provides its FULL Roe dissipation d = |A_roe(UL, UR)| (UR - UL) – Roe avera...
Definition numerical_flux.hpp:156

pops::HasSourceFrequency
OPTIONAL trait: local source frequency mu [1/s] (bound dt <= cfl / max mu, without h).
Definition physical_model.hpp:137

pops::HasStabilityDt
OPTIONAL trait: direct admissible step per cell (bound dt <= min stability_dt, without cfl).
Definition physical_model.hpp:143

pops::HasStabilitySpeed
OPTIONAL trait: stability speed lambda* replacing max_wave_speed in the block CFL.
Definition physical_model.hpp:131

dispatch_tags.hpp
SINGLE registry of spatial scheme tags (limiters + Riemann fluxes): shared source of truth for ALL di...

distribution_mapping.hpp
DistributionMapping: maps each box (by global index) to its owning MPI rank.

for_each.hpp
for_each_cell and reductions: the parallelism SEAM over the cells of a Box2D; sync_host / sync_device...

geometry.hpp
Geometry: index-space (Box2D) <-> Cartesian physical-space mapping; PolarGeometry: SIBLING for a glob...

implicit_stepper.hpp
Implicit / IMEX block step as a named CONTRACT.

multifab.hpp
MultiFab: a field DISTRIBUTED over a level (equivalent of AMReX's MultiFab).

pops::detail::dispatch_amr_block_hll
AmrRuntimeBlock dispatch_amr_block_hll(const Model &m, const std::string &lim, const SharedAmrLayout &S, const std::string &name, const std::vector< double > &density, bool has_density, double gamma, int substeps, bool recon_prim, bool imex, int stride, const std::vector< int > &implicit_components, const NewtonOptions &nopts, const std::vector< double > *state, bool newton_diagnostics, AmrTimeMethod time_method, double pos_floor)
Definition amr_dsl_block.hpp:707

pops::detail::coupler_read_coarse
std::vector< double > coupler_read_coarse(const MultiFab &U, int n, bool replicated)
Definition amr_coupler_mp.hpp:169

pops::detail::dispatch_amr_compiled_rusanov
AmrCompiledHooks dispatch_amr_compiled_rusanov(const Model &m, const std::string &lim, const AmrBuildParams &bp)
Definition amr_dsl_block.hpp:864

pops::detail::coupler_make_coarse_layout
std::pair< BoxArray, DistributionMapping > coupler_make_coarse_layout(int n, bool distribute, int max_grid)
Definition amr_coupler_mp.hpp:257

pops::detail::dispatch_amr_compiled
AmrCompiledHooks dispatch_amr_compiled(const Model &m, const std::string &lim, const std::string &riem, const AmrBuildParams &bp)
Dispatch of the spatial scheme (limiter x Riemann flux) -> build_amr_compiled.
Definition amr_dsl_block.hpp:953

pops::detail::dispatch_amr_block_rusanov
AmrRuntimeBlock dispatch_amr_block_rusanov(const Model &m, const std::string &lim, const SharedAmrLayout &S, const std::string &name, const std::vector< double > &density, bool has_density, double gamma, int substeps, bool recon_prim, bool imex, int stride, const std::vector< int > &implicit_components, const NewtonOptions &nopts, const std::vector< double > *state, bool newton_diagnostics, AmrTimeMethod time_method, double pos_floor)
Definition amr_dsl_block.hpp:681

pops::detail::dispatch_amr_block_hllc
AmrRuntimeBlock dispatch_amr_block_hllc(const Model &m, const std::string &lim, const SharedAmrLayout &S, const std::string &name, const std::vector< double > &density, bool has_density, double gamma, int substeps, bool recon_prim, bool imex, int stride, const std::vector< int > &implicit_components, const NewtonOptions &nopts, const std::vector< double > *state, bool newton_diagnostics, AmrTimeMethod time_method, double pos_floor)
Definition amr_dsl_block.hpp:743

pops::detail::coupler_read_coarse_phi
std::vector< double > coupler_read_coarse_phi(const MultiFab &aux0, int n, bool replicated)
Definition amr_coupler_mp.hpp:191

pops::detail::coupler_write_coarse
void coupler_write_coarse(MultiFab &U, const std::vector< double > &rho, int n, int ncomp, double gamma)
Definition amr_coupler_mp.hpp:112

pops::detail::amr_schur_source
void amr_schur_source(Coupler &cpl, AmrCondensedSchurSourceStepper &schur, MultiFab &bz_coarse, MultiFab &phi_coarse, double theta, double dt)
A GLOBAL condensed source STAGE on the mono-block coupler hierarchy.
Definition amr_dsl_block.hpp:104

pops::detail::dispatch_amr_block
AmrRuntimeBlock dispatch_amr_block(const Model &m, const std::string &lim, const std::string &riem, const SharedAmrLayout &S, const std::string &name, const std::vector< double > &density, bool has_density, double gamma, int substeps, bool recon_prim, bool imex, int stride=1, const std::vector< int > &implicit_components={}, const NewtonOptions &nopts={}, const std::vector< double > *state=nullptr, bool newton_diagnostics=false, AmrTimeMethod time_method=AmrTimeMethod::kEuler, double pos_floor=0.0)
Dispatch of the spatial scheme (limiter x Riemann flux) -> build_amr_block.
Definition amr_dsl_block.hpp:825

pops::detail::coupler_inject_coarse_to_fine_mb
void coupler_inject_coarse_to_fine_mb(const MultiFab &Uc, MultiFab &Uf, bool replicated)
Definition amr_coupler_mp.hpp:212

pops::detail::dispatch_amr_block_roe
AmrRuntimeBlock dispatch_amr_block_roe(const Model &m, const std::string &lim, const SharedAmrLayout &S, const std::string &name, const std::vector< double > &density, bool has_density, double gamma, int substeps, bool recon_prim, bool imex, int stride, const std::vector< int > &implicit_components, const NewtonOptions &nopts, const std::vector< double > *state, bool newton_diagnostics, AmrTimeMethod time_method, double pos_floor)
Definition amr_dsl_block.hpp:782

pops::detail::make_shared_amr_layout
SharedAmrLayout make_shared_amr_layout(const AmrBuildParams &bp)
Builds the SHARED layout (PR1): coarse (per the ownership policy) + ONE central FIXED fine patch (the...
Definition amr_dsl_block.hpp:440

pops::detail::dispatch_amr_compiled_hll
AmrCompiledHooks dispatch_amr_compiled_hll(const Model &m, const std::string &lim, const AmrBuildParams &bp)
Definition amr_dsl_block.hpp:878

pops::detail::dispatch_amr_compiled_hllc
AmrCompiledHooks dispatch_amr_compiled_hllc(const Model &m, const std::string &lim, const AmrBuildParams &bp)
Definition amr_dsl_block.hpp:901

pops::detail::apply_pointwise_project_amr
void apply_pointwise_project_amr(const Model &m, std::vector< AmrLevelMP > &levels)
Definition amr_dsl_block.hpp:65

pops::detail::dispatch_amr_compiled_roe
AmrCompiledHooks dispatch_amr_compiled_roe(const Model &m, const std::string &lim, const AmrBuildParams &bp)
Definition amr_dsl_block.hpp:926

pops::detail::build_amr_block
AmrRuntimeBlock build_amr_block(const Model &model, const SharedAmrLayout &S, const std::string &name, const std::vector< double > &density, bool has_density, double gamma, int substeps, bool recon_prim, bool imex, int stride=1, const std::vector< int > &implicit_components={}, const NewtonOptions &nopts={}, const std::vector< double > *state=nullptr, bool newton_diagnostics=false, AmrTimeMethod time_method=AmrTimeMethod::kEuler, double pos_floor=0.0)
Builds ONE type-erased AMR block (AmrRuntimeBlock) on the SHARED layout S, for a composite Model + co...
Definition amr_dsl_block.hpp:497

pops::detail::amr_write_coarse_bz
void amr_write_coarse_bz(MultiFab &bz, const std::vector< double > &field, int n)
Fills the COARSE B_z field (component 0, n*n row-major in GLOBAL indices) from field.
Definition amr_dsl_block.hpp:84

pops::detail::build_amr_compiled
AmrCompiledHooks build_amr_compiled(const Model &model, const AmrBuildParams &bp)
Builds the AMR coupler for a composite Model + concrete (Limiter, Flux) and fills the type-erased hoo...
Definition amr_dsl_block.hpp:120

pops::detail::coupler_write_coarse_state
void coupler_write_coarse_state(MultiFab &U, const std::vector< double > &state, int n, int ncomp)
Definition amr_coupler_mp.hpp:143

pops
Definition amr_hierarchy.hpp:29

pops::for_each_cell_reduce_sum
Real for_each_cell_reduce_sum(const Box2D &b, F f)
SUM reduction of f(i, j) over box b.
Definition for_each.hpp:199

pops::throw_registry_dispatch_mismatch
void throw_registry_dispatch_mismatch(const char *ctx, const char *kind, const std::string &tag)
DEFENSE-IN-DEPTH guard: reached only if a VALID tag (already accepted by validate_*) is routed by NO ...
Definition dispatch_tags.hpp:138

pops::validate_riemann
void validate_riemann(const std::string &riem, bool polar=false, const char *ctx="System")
Validates a Riemann FLUX tag against kRiemanns.
Definition dispatch_tags.hpp:111

pops::for_each_cell
void for_each_cell(const Box2D &b, F f)
Applies f to EACH cell (i, j) of box b (bounds inclusive), via Kokkos::parallel_for (Serial / OpenMP ...
Definition for_each.hpp:138

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

pops::mf_average_down_mb
void mf_average_down_mb(const MultiFab &Uf, MultiFab &Uc)
Definition amr_subcycling.hpp:305

pops::n_ranks
int n_ranks()
Definition comm.hpp:139

pops::validate_limiter
void validate_limiter(const std::string &lim, const char *ctx="System")
Validates a LIMITER tag against kLimiters.
Definition dispatch_tags.hpp:99

pops::all_reduce_sum
double all_reduce_sum(double x)
Definition comm.hpp:143

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::min_stability_dt_mf
Real min_stability_dt_mf(const Model &model, const MultiFab &U, const MultiFab &aux)
Global min of the declared admissible step (HasStabilityDt trait), via max(1/dt) (cf.
Definition wave_speed.hpp:222

pops::resolve_implicit_components_compiled
std::vector< int > resolve_implicit_components_compiled(const std::string &block, const VariableSet &cons, const std::vector< std::string > &names, const std::vector< std::string > &roles)
Resolves the partial IMEX MASK (implicit_vars / implicit_roles) of a COMPILED block into indices of c...
Definition amr_dsl_block.hpp:979

pops::device_fence
void device_fence()
Device barrier: waits for in-flight kernels to finish before a HOST access to unified memory.
Definition kokkos_env.hpp:43

pops::max_source_frequency_mf
Real max_source_frequency_mf(const Model &model, const MultiFab &U, const MultiFab &aux)
Global max of the source frequency (HasSourceFrequency trait). 0 if the source does not constrain.
Definition wave_speed.hpp:209

pops::AmrTimeMethod
AmrTimeMethod
Definition amr_flux_helpers.hpp:46

pops::AmrTimeMethod::kSsprk3
@ kSsprk3

pops::AmrTimeMethod::kEuler
@ kEuler

pops::VariableRole
VariableRole
PHYSICAL role of a component.
Definition variables.hpp:27

pops::VariableRole::Energy
@ Energy

pops::VariableRole::Density
@ Density

pops::VariableRole::MomentumX
@ MomentumX

pops::VariableRole::Custom
@ Custom

pops::VariableRole::MomentumY
@ MomentumY

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::role_from_name
VariableRole role_from_name(const std::string &s)
Forward declaration: VariableSet::index_of(const std::string&) resolves a canonical role NAME via rol...
Definition variables.hpp:130

pops::max_stability_speed_mf
Real max_stability_speed_mf(const Model &model, const MultiFab &U, const MultiFab &aux)
Global max of the STABILITY speed (HasStabilitySpeed trait) – counterpart of max_wave_speed_mf.
Definition wave_speed.hpp:197

pops::max_wave_speed_mf
Real max_wave_speed_mf(const Model &model, const MultiFab &U, const MultiFab &aux)
max_wave_speed_mf: global max of the wave speed over the whole MultiFab (CFL).
Definition wave_speed.hpp:66

numerical_flux.hpp
Single-interface numerical flux policies: Rusanov, HLL, HLLC, Roe.

reconstruction.hpp
Interface reconstruction policies: MUSCL limiters and WENO5-Z.

refinement.hpp
AMR inter-level transfer operators (integer ratio r) + parallel_copy.

spatial_operator.hpp
Cartesian spatial operator: assembles R(U, aux) = -div F + S over the cells of a level.

pops::AmrBuildParams
Frozen parameters passed to the deferred build of the compiled path (add_compiled_model).
Definition amr_system.hpp:84

pops::AmrBuildParams::L
double L
Definition amr_system.hpp:86

pops::AmrBuildParams::schur_theta
double schur_theta
theta-scheme of the condensed stage (0.5 = Crank-Nicolson)
Definition amr_system.hpp:110

pops::AmrBuildParams::schur_energy
std::string schur_energy
Definition amr_system.hpp:129

pops::AmrBuildParams::refine_threshold
double refine_threshold
1e30 => no refinement
Definition amr_system.hpp:92

pops::AmrBuildParams::has_state
bool has_state
Definition amr_system.hpp:103

pops::AmrBuildParams::wall
std::function< bool(Real, Real)> wall
conductive wall predicate (empty = none)
Definition amr_system.hpp:94

pops::AmrBuildParams::n
int n
Definition amr_system.hpp:85

pops::AmrBuildParams::coarse_max_grid
int coarse_max_grid
tile size of the distributed coarse (0 => n/2)
Definition amr_system.hpp:98

pops::AmrBuildParams::schur_krylov_max_iters
int schur_krylov_max_iters
iteration budget (<= 0 = default 400)
Definition amr_system.hpp:126

pops::AmrBuildParams::regrid_every
int regrid_every
Definition amr_system.hpp:87

pops::AmrBuildParams::poisson_bc
BCRec poisson_bc
coarse Poisson BC (resolved by set_poisson)
Definition amr_system.hpp:93

pops::AmrBuildParams::state
std::vector< double > state
ncomp*n*n, component-major c*n*n + j*n + i; ncomp == Model::n_vars
Definition amr_system.hpp:105

pops::AmrBuildParams::imex
bool imex
time == "imex": stiff implicit source (backward_euler)
Definition amr_system.hpp:91

pops::AmrBuildParams::named_aux
std::map< int, std::vector< double > > named_aux
Model-NAMED aux fields (ADC-291): component (>= kAuxNamedBase) -> coarse base-level field (n*n row-ma...
Definition amr_system.hpp:119

pops::AmrBuildParams::distribute_coarse
bool distribute_coarse
distributed multi-box coarse (AMR strong-scaling)
Definition amr_system.hpp:97

pops::AmrBuildParams::schur
bool schur
true: GLOBAL condensed source stage (instead of local explicit/imex)
Definition amr_system.hpp:109

pops::AmrBuildParams::pos_floor
double pos_floor
Definition amr_system.hpp:148

pops::AmrBuildParams::schur_alpha
double schur_alpha
electrostatic coupling constant of the condensed stage
Definition amr_system.hpp:111

pops::AmrBuildParams::density
std::vector< double > density
initial coarse density (component 0), n*n
Definition amr_system.hpp:96

pops::AmrBuildParams::schur_momentum_x
std::string schur_momentum_x
Definition amr_system.hpp:129

pops::AmrBuildParams::newton_options
NewtonOptions newton_options
Definition amr_system.hpp:135

pops::AmrBuildParams::named_aux_bc
std::map< int, AuxHaloPolicy > named_aux_bc
Per-field aux HALO policies (ADC-369): component -> uniform boundary policy, seeded onto the engine a...
Definition amr_system.hpp:123

pops::AmrBuildParams::schur_krylov_tol
double schur_krylov_tol
tolerance of the coarse Krylov solve (<= 0 = default 1e-10)
Definition amr_system.hpp:125

pops::AmrBuildParams::has_density
bool has_density
Definition amr_system.hpp:95

pops::AmrBuildParams::schur_momentum_y
std::string schur_momentum_y
Definition amr_system.hpp:129

pops::AmrBuildParams::bz_field
std::vector< double > bz_field
coarse B_z(x,y) field, n*n row-major (required by the condensed stage)
Definition amr_system.hpp:115

pops::AmrBuildParams::gamma
double gamma
Definition amr_system.hpp:88

pops::AmrBuildParams::recon_prim
bool recon_prim
recon == "primitive" (frozen by add_compiled_model)
Definition amr_system.hpp:90

pops::AmrBuildParams::schur_density
std::string schur_density
Definition amr_system.hpp:129

pops::AmrBuildParams::substeps
int substeps
Definition amr_system.hpp:89

pops::AmrBuildParams::schur_strang
bool schur_strang
true: Strang splitting H(dt/2) S(dt) H(dt/2); false: Lie H(dt) S(dt)
Definition amr_system.hpp:112

pops::AmrBuildParams::time_method
int time_method
Definition amr_system.hpp:140

pops::AmrCompiledHooks
Type-erased closures of a compiled AMR block, produced by amr_dsl_block::build_amr_compiled and insta...
Definition amr_system.hpp:153

pops::AmrCompiledHooks::mass
std::function< double()> mass
coarse mass
Definition amr_system.hpp:157

pops::AmrCompiledHooks::step
std::function< void(double)> step
one macro-step (periodic regrid included)
Definition amr_system.hpp:155

pops::AmrCompiledHooks::patch_boxes
std::function< std::vector< PatchBox >()> patch_boxes
index-space signatures of the fine patches
Definition amr_system.hpp:166

pops::AmrCompiledHooks::max_speed
std::function< double()> max_speed
max wave speed (CFL step)
Definition amr_system.hpp:156

pops::AmrCompiledHooks::stability_dt
std::function< double()> stability_dt
coarse min of the admissible step (0 = does not constrain)
Definition amr_system.hpp:173

pops::AmrCompiledHooks::n_patches
std::function< int()> n_patches
number of fine patches
Definition amr_system.hpp:158

pops::AmrCompiledHooks::set_macro_step
std::function< void(int)> set_macro_step
restores the cadence (regrid) phase of the mono-block
Definition amr_system.hpp:179

pops::AmrCompiledHooks::coupler_holder
std::shared_ptr< void > coupler_holder
keeps the AmrCouplerMP<Model> alive
Definition amr_system.hpp:154

pops::AmrCompiledHooks::source_frequency
std::function< double()> source_frequency
coarse max of mu [1/s] (0 = does not constrain)
Definition amr_system.hpp:171

pops::AmrDiscLF
Bundle (limiter, Riemann flux) expected by AmrCouplerMP::step<Disc>.
Definition amr_dsl_block.hpp:52

pops::AmrDiscLF::NumericalFlux
F NumericalFlux
Definition amr_dsl_block.hpp:54

pops::AmrDiscLF::Limiter
L Limiter
Definition amr_dsl_block.hpp:53

pops::AmrRuntimeBlock
Type-erased closures of ONE AMR block, placed on the shared hierarchy.
Definition amr_runtime.hpp:98

pops::Array4
WRITE POD handle (raw pointer + strides) over a Fab2D buffer, indexed by (i, j, c) IN GLOBAL INDICES ...
Definition fab2d.hpp:29

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

pops::BCRec
Boundary conditions for the FOUR faces of the domain (type + associated Dirichlet value).
Definition physical_bc.hpp:29

pops::Box2D
2D integer index space, cell-centered.
Definition box2d.hpp:37

pops::Box2D::from_extents
static Box2D from_extents(int nx, int ny)
Box [0, nx-1] x [0, ny-1] covering nx*ny cells from the index origin.
Definition box2d.hpp:42

pops::Box2D::hi
int hi[2]
Definition box2d.hpp:39

pops::Box2D::lo
int lo[2]
Definition box2d.hpp:38

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

pops::Geometry
Cartesian geometry of a level: index domain + physical bounds [xlo, xhi] x [ylo, yhi].
Definition geometry.hpp:20

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

pops::PatchBox
INDEX-SPACE footprint of an AMR fine patch, exposed to Python by AmrSystem::patch_boxes().
Definition patch_box.hpp:30

pops::Periodicity
Per-direction periodicity: halo wrapping in x and/or y during the exchange (false = open edge,...
Definition fill_boundary.hpp:37

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

pops::VariableSet::names
std::vector< std::string > names
Definition variables.hpp:60

pops::VariableSet::index_of
int index_of(VariableRole role) const
Index of the component carrying role (first occurrence), -1 if absent.
Definition variables.hpp:67

pops::detail::CopyComp0Kernel
Definition geometric_mg.hpp:66

pops::detail::ProjectCellKernel
Kernel device de la PROJECTION PONCTUELLE post-pas (ADC-177) : U(i, j) <- m.project(U(i,...
Definition block_builder.hpp:225

pops::detail::SharedAmrLayout
SHARED layout of a multi-block AMR hierarchy (PR1 capstone), frozen at construction.
Definition amr_dsl_block.hpp:420

pops::detail::SharedAmrLayout::dm_coarse
DistributionMapping dm_coarse
Definition amr_dsl_block.hpp:423

pops::detail::SharedAmrLayout::n
int n
Definition amr_dsl_block.hpp:430

pops::detail::SharedAmrLayout::nlev
int nlev() const
Definition amr_dsl_block.hpp:433

pops::detail::SharedAmrLayout::ba
std::vector< BoxArray > ba
Definition amr_dsl_block.hpp:424

pops::detail::SharedAmrLayout::wall
std::function< bool(Real, Real)> wall
Definition amr_dsl_block.hpp:429

pops::detail::SharedAmrLayout::ba_coarse
BoxArray ba_coarse
Definition amr_dsl_block.hpp:422

pops::detail::SharedAmrLayout::poisson_bc
BCRec poisson_bc
Definition amr_dsl_block.hpp:428

pops::detail::SharedAmrLayout::geom
Geometry geom
Definition amr_dsl_block.hpp:421

pops::detail::SharedAmrLayout::dy
std::vector< Real > dy
Definition amr_dsl_block.hpp:426

pops::detail::SharedAmrLayout::replicated_coarse
bool replicated_coarse
Definition amr_dsl_block.hpp:427

pops::detail::SharedAmrLayout::dm
std::vector< DistributionMapping > dm
Definition amr_dsl_block.hpp:425

pops::detail::SharedAmrLayout::dx
std::vector< Real > dx
Definition amr_dsl_block.hpp:426

POPS_HD
#define POPS_HD
Definition types.hpp:25