PoPS/doxygen/system__stepper_8hpp_source.html

#pragma once


#include <pops/core/state/state.hpp>  // kAuxBaseComps (B_z channel read by the condensed source stage)

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

#include <pops/coupling/source/coupled_source_program.hpp>  // CoupledFreqKernel (per-cell coupled frequency)

#include <pops/mesh/execution/for_each.hpp>  // reduce_max_cell (max mu over the cells, device-clean functor)

#include <pops/parallel/comm.hpp>  // all_reduce_min/max (global bounds: identical dt on all ranks)

#include <pops/runtime/context/grid_context.hpp>  // GeometryMode (disk transport dispatch)


#include <stdexcept>  // std::runtime_error (disk mode requested without disk advance on a block)


#include <algorithm>  // std::min, std::max (CFL: min grid physical step, min dt over the blocks)

#include <cmath>      // std::isfinite, std::ceil (step_cfl / step_adaptive)

#include <limits>     // std::numeric_limits (per-block CFL: dt = min over the blocks)

#include <string>     // last_dt_bound (name of the active bound of the last step_cfl)

#include <vector>


namespace pops {


namespace stepper {


enum class SplitScheme { Lie, Strang };


template <class Impl>


class SystemStepper {

 public:

  explicit SystemStepper(Impl* owner) : owner_(owner) {}


  void set_scheme(SplitScheme scheme) { scheme_ = scheme; }

  SplitScheme scheme() const { return scheme_; }


  static bool stride_due(int macro_step, int stride) { return (macro_step + 1) % stride == 0; }


  void apply_couplings(Real dt) {

    if (owner_->couplings.empty())

      return;

    for (auto& c : owner_->couplings)

      c(dt);

  }


  void apply_coupled_freq_expr_bounds(double cfl, double& dt, std::string* reason) const {

    Impl* P = owner_;

    for (const auto& ce : P->coupled_freq_exprs_) {

      Real m = 0;

      if (ce.n_in > 0) {

        auto& Uref = P->sp[static_cast<std::size_t>(ce.ins[0].sidx)].U;

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

          CoupledFreqKernel kern;

          kern.n_in = ce.n_in;

          kern.n_const = static_cast<int>(ce.kconsts.size());

          for (int c = 0; c < ce.n_in; ++c) {

            kern.in[c] = P->sp[static_cast<std::size_t>(ce.ins[static_cast<std::size_t>(c)].sidx)]

                             .U.fab(li)

                             .array();

            kern.in_comp[c] = ce.ins[static_cast<std::size_t>(c)].comp;

          }

          for (int c = 0; c < kern.n_const; ++c)

            kern.consts[c] = ce.kconsts[static_cast<std::size_t>(c)];

          kern.prog = ce.prog;

          m = std::max(m, reduce_max_cell(Uref.box(li), kern));

        }

      } else {

        // Program WITHOUT an input field (constant frequency expressed in bytecode): evaluated once

        // on the constants alone (no box to traverse); identical on all ranks.

        Real reg[kCsMaxReg];

        const int nc = static_cast<int>(ce.kconsts.size());

        for (int c = 0; c < nc; ++c)

          reg[c] = ce.kconsts[static_cast<std::size_t>(c)];

        const Real mu0 = ce.prog.eval(reg);

        if (mu0 > Real(0))

          m = mu0;

      }

      const double mu = all_reduce_max(static_cast<double>(m));  // ALL ranks (collective symmetry)

      if (mu > 0.0) {

        const double dt_cs = cfl / mu;

        if (dt_cs < dt) {

          dt = dt_cs;

          if (reason)

            *reason = "coupled_source:" + ce.label;

        }

      }

    }

  }


  Real cfl_grid_h() const {

    Impl* P = owner_;

    return P->polar_ ? std::min(P->pgeom_.dr(), P->pgeom_.r_min * P->pgeom_.dtheta())

                     : std::min(P->geom.dx(), P->geom.dy());

  }


  void apply_global_dt_bounds(double& dt, std::string* reason) const {

    Impl* P = owner_;

    for (const auto& g : P->dt_bounds_) {

      if (!g.fn)

        continue;

      double v = g.fn();

      if (!(v > 0.0) || !std::isfinite(v))

        v = std::numeric_limits<double>::infinity();

      v = all_reduce_min(v);

      if (v < dt) {

        dt = v;

        if (reason)

          *reason = "global:" + g.label;

      }

    }

  }


  void apply_projections() {

    for (auto& s : owner_->sp) {

      if (!s.evolve)

        continue;  // bloc gele : fond fixe jamais modifie, rien a projeter

      if (s.project)

        s.project(s.U);

    }

  }


  void run_source_stage(typename Impl::Species& s, Real eff_dt) {

    // GEOMETRY DISPATCH (Path A step 2c): a block carries AT MOST ONE condensed source stage (set_source_stage

    // builds the Cartesian OR the polar one depending on the System geometry). The POLAR one

    // (PolarCondensedSchurSourceStepper, #212) has the SAME step(state, phi, bz, c_bz, theta, dt) signature as

    // the Cartesian one (#126): only the pointer changes. The Cartesian path stays BIT-IDENTICAL (schur_polar

    // == nullptr in Cartesian -> we take the original schur branch, unchanged).

    if (s.schur_polar) {

      s.schur_polar->step(s.U, owner_->fields_.ell_phi(), owner_->aux, s.schur_bz_comp,

                          static_cast<Real>(s.schur_theta), eff_dt);

      return;

    }

    if (s.schur) {

      s.schur->step(s.U, owner_->fields_.ell_phi(), owner_->aux, s.schur_bz_comp,

                    static_cast<Real>(s.schur_theta), eff_dt);

      return;

    }

    // GENERIC SOURCE STAGE (fallback): plays ONLY if NO condensed Schur stage (production path

    // UNTOUCHED, bit-identical). Advances the block source stage IN PLACE on eff_dt. nullptr

    // (default) -> no-op, as before. Used by generic splitting (pops.Strang) and order tests.

    if (s.source_step)

      s.source_step(s.U, eff_dt);

  }


  void advance_transport_n(typename Impl::Species& s, Real dt, int n) {

    const GeometryMode mode = owner_->geometry_mode_;

    if (mode == GeometryMode::None || !owner_->eb_set_) {

      s.advance(s.U, dt,

                n);  // default path (or mode without a fixed embedded boundary): BIT-IDENTICAL

      return;

    }

    if (mode == GeometryMode::Staircase) {

      if (!s.advance_masked)

        throw std::runtime_error(

            "SystemStepper: embedded-boundary mode 'staircase' requested but block '" + s.name +

            "' exposes no masked transport advance (level-set transport not wired for this block)");

      s.advance_masked(s.U, dt, n);

      return;

    }

    // CutCell

    if (!s.advance_eb)

      throw std::runtime_error(

          "SystemStepper: embedded-boundary mode 'cutcell' requested but block '" + s.name +

          "' exposes no cut-cell EB transport advance (level-set transport not wired for this "

          "block)");

    s.advance_eb(s.U, dt, n);

  }


  void advance_transport(typename Impl::Species& s, Real eff_dt) {

    advance_transport_n(s, eff_dt, s.substeps);

  }


  void advance_transport_half(typename Impl::Species& s, Real eff_dt) {

    advance_transport_n(s, Real(0.5) * eff_dt, s.substeps);

  }


  void advance_due_blocks(double dt) {

    Impl* P = owner_;

    for (auto& s : P->sp) {

      if (!s.evolve)

        continue;  // frozen block: not advanced

      if (!stride_due(P->macro_step_, s.stride))

        continue;                                     // hold: not at the stride window end

      const Real eff_dt = Real(dt) * Real(s.stride);  // catch-up: effective step s.stride * dt

      advance_transport(s,

                        eff_dt);  // transport DISPATCHED by the geometry mode (None: assemble_rhs)

      run_source_stage(s, eff_dt);  // OPT-IN: Schur-condensed source stage (no-op otherwise)

    }

  }


  void run_program_cadence(double dt) {

    Impl* P = owner_;

    if (stride_due(P->macro_step_, P->program_stride_)) {

      const Real eff_dt = Real(dt) * Real(P->program_stride_);  // catch-up: effective step M*dt

      const int n = P->program_substeps_;

      const Real h = eff_dt / Real(n);  // substeps subdivide the EFFECTIVE step (native: eff_dt/n)

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

        P->program_step_(h);

    }

    P->t += dt;  // clock ticks EVERY macro-step (held steps included), like native

    P->macro_step_++;

  }


  void step(double dt) {

    if (scheme_ == SplitScheme::Strang) {

      step_strang(dt);

      return;

    }

    Impl* P = owner_;

    // Compiled time Program (epic ADC-399): when a problem.so has installed a macro-step body, IT owns

    // the whole step (solve_fields, RHS, combine, commit -- all via ProgramContext). The runtime only

    // keeps the clock coherent (the SYSTEM-level substeps + stride cadence + clock tick are factored

    // into run_program_cadence, shared with step_cfl so both route a program the same way -- ADC-413).

    // No implicit solve_fields / couplings / projections here: the Program expresses them explicitly.

    if (P->program_step_) {

      run_program_cadence(dt);

      return;

    }

    // COUPLING / POISSON: solve_fields assembles f = Sum_s elliptic_rhs_s(U_s) on the CURRENT state of

    // each block. A HELD block (cadence M, outside the window end) contributes with its STALE state (its

    // last advance, thus frozen until its next catch-up): stale density / charge in the Poisson sum as

    // long as it has not caught up. Assumed stride choice (loose coupling of the slow block).

    P->solve_fields();

    advance_due_blocks(

        dt);  // DUE blocks: catch-up transport + opt-in source stage (shared with step_cfl)

    apply_couplings(Real(dt));  // inter-species coupled sources (splitting), after transport

    apply_projections();  // projection ponctuelle POST-PAS ENTIER (ADC-177) ; no-op sans projection

    P->t += dt;

    P->macro_step_++;

  }


  void step_strang(double dt) {

    Impl* P = owner_;

    // (1) phi consistent with rho^n, for the 1st transport half-advance.

    P->solve_fields();

    // (2) H(dt/2): 1st transport half-advance of each DUE block. s.substeps substeps (unchanged).

    // Dispatched by the geometry mode (None: assemble_rhs; Staircase/CutCell: disk operator).

    for (auto& s : P->sp) {

      if (!s.evolve)

        continue;

      if (!stride_due(P->macro_step_, s.stride))

        continue;

      const Real eff_dt = Real(dt) * Real(s.stride);

      advance_transport_half(s, eff_dt);

    }

    // (3) phi RE-SOLVED on the post-H(dt/2) density, for the source stage.

    P->solve_fields();

    // (4) S(dt): FULL source stage of each DUE block (no-op if no Schur stage, like Lie).

    for (auto& s : P->sp) {

      if (!s.evolve)

        continue;

      if (!stride_due(P->macro_step_, s.stride))

        continue;

      const Real eff_dt = Real(dt) * Real(s.stride);

      run_source_stage(s, eff_dt);

    }

    // (5) phi RE-SOLVED on the post-source density: WITHOUT this solve the 2nd half-advance would read a

    //     stale phi (cf. docs/HOFFART_STEP_SEQUENCE.md, the single head solve_fields is insufficient).

    P->solve_fields();

    // (6) H(dt/2): 2nd transport half-advance, closing the symmetric Strang step. SAME dispatch.

    for (auto& s : P->sp) {

      if (!s.evolve)

        continue;

      if (!stride_due(P->macro_step_, s.stride))

        continue;

      const Real eff_dt = Real(dt) * Real(s.stride);

      advance_transport_half(s, eff_dt);

    }

    apply_couplings(

        Real(dt));  // inter-species coupled sources (splitting), after the symmetric step

    // Projection ponctuelle POST-PAS ENTIER (ADC-177) : UNE application apres le pas Strang complet

    // H(dt/2) S(dt) H(dt/2), jamais entre les etages (semantique post-pas, pas post-etage).

    apply_projections();

    P->t += dt;

    P->macro_step_++;

  }


  void advance(double dt, int nsteps) {

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

      step(dt);

  }


  double step_cfl(double cfl) {

    Impl* P = owner_;

    P->solve_fields();

    // MIN physical step of the grid (Cartesian min(dx,dy) / polar min(dr, r_min*dtheta), cf.

    // cfl_grid_h). The rest of the CFL formula (per block, substeps/stride) is unchanged.

    const Real h = cfl_grid_h();

    // PER-BLOCK CFL, STRIDE AND SUBSTEPS FACTOR INCLUDED. A block of cadence M advances by an effective

    // step M*dt in substeps_b substeps, so each substep is worth stride_b * dt / substeps_b: the stable

    // condition per substep is stride_b * dt / substeps_b <= cfl * h / w_b, that is

    //   dt <= cfl * h * substeps_b / (stride_b * w_b).

    // The GLOBAL dt is the min over the evolving blocks (the most constraining). Without this, the step

    // computed on w_max alone then multiplied by M would violate the CFL by a factor M on the stride block.

    //

    // BACKWARD COMPATIBILITY (post-#121). The formula is SUBSTEPS-AWARE: with substeps_b > 1, the dt

    // returned is substeps_b times larger than the old formula dt = cfl*h/(stride*w).

    // bit-identical only for substeps=1 (at any stride); step_cfl is now substeps-aware

    // (dt = cfl*h*substeps/(stride*w)), so a step_cfl run with substeps>1 advances a larger dt

    // than before #121 (CFL-maximal step, each substep at the stability limit).

    // To reproduce a run calibrated with the old formula, use step(dt) with the explicit historical

    // dt, NOT step_cfl.

    double dt = std::numeric_limits<double>::infinity();

    std::string reason = "degenerate";

    for (auto& s : P->sp) {

      if (!s.evolve)

        continue;  // frozen block: does not constrain the step

      const Real w = std::max(s.max_speed(s.U), kCflSpeedFloor);

      double dt_b = cfl * static_cast<double>(h) * static_cast<double>(s.substeps) /

                    (static_cast<double>(s.stride) * static_cast<double>(w));

      const char* why = "transport";

      // SOURCE FREQUENCY bound (optional; mu <= 0 = does not constrain).

      if (s.source_frequency) {

        const Real mu = s.source_frequency(s.U);

        if (mu > Real(0)) {

          const double dt_src = cfl * static_cast<double>(s.substeps) /

                                (static_cast<double>(s.stride) * static_cast<double>(mu));

          if (dt_src < dt_b) {

            dt_b = dt_src;

            why = "source_frequency";

          }

        }

      }

      // Direct ADMISSIBLE STEP (optional; <= 0 = does not constrain; cfl NOT applied).

      if (s.stability_dt) {

        const Real db = s.stability_dt(s.U);

        if (db > Real(0)) {

          const double dt_adm = static_cast<double>(db) * static_cast<double>(s.substeps) /

                                static_cast<double>(s.stride);

          if (dt_adm < dt_b) {

            dt_b = dt_adm;

            why = "stability_dt";

          }

        }

      }

      if (dt_b < dt) {

        dt = dt_b;

        reason = std::string(why) + ":" + s.name;

      }

    }

    // DECLARED frequencies of the coupled sources (CoupledSource.frequency): the couplings

    // apply ONCE per MACRO-step (apply_couplings(dt)), so the bound applies to the

    // macro-dt directly: dt <= cfl / mu (NO substeps/stride factor -- those apply

    // only to the block subcycled transport, not to the coupling splitting).

    for (const auto& cs : P->coupled_freqs_) {

      if (!(cs.mu > 0.0))

        continue;

      const double dt_cs = cfl / cs.mu;

      if (dt_cs < dt) {

        dt = dt_cs;

        reason = "coupled_source:" + cs.label;

      }

    }

    // PER-CELL frequencies (CoupledSource.frequency with an Expr): mu(U) reduced (MAX) per cell at

    // this step, global all_reduce_max, dt <= cfl / max(mu). Same reason "coupled_source:<label>" as the

    // constant. No per-cell source -> no-op (bit-identical).

    apply_coupled_freq_expr_bounds(cfl, dt, &reason);

    // GLOBAL bounds (System::add_dt_bound): all_reduce_min over the registered bounds, tracking the

    // winning reason (see apply_global_dt_bounds for the MPI deadlock-safety rationale).

    apply_global_dt_bounds(dt, &reason);

    // OPTIONAL compiled-Program dt bound (epic ADC-399 / ADC-417, spec s18). When the installed Program

    // exported one (System::install_program stored program_dt_bound_), it TIGHTENS dt to the min of the

    // native CFL dt above and the program's own bound. No program / no bound -> the closure is empty and

    // dt is the native CFL UNCHANGED. The native CFL logic above is left intact: this only reduces dt.

    // MPI-SAFE: program_dt_bound_ runs the SAME collective reduction (block_max_speed / reductions) on

    // every rank, so the bound is rank-uniform -- like apply_global_dt_bounds, the min keeps the step

    // collectives symmetric (no desync / deadlock).

    if (P->program_dt_bound_) {

      const double pb = static_cast<double>(P->program_dt_bound_(static_cast<Real>(cfl)));

      if (std::isfinite(pb) && pb > 0.0 && pb < dt) {

        dt = pb;

        reason = "program:dt_bound";

      }

    }

    if (!std::isfinite(dt)) {

      dt = cfl * static_cast<double>(h) /

           static_cast<double>(kCflSpeedFloor);  // all frozen: degenerate step

      reason = "degenerate";

    }

    last_dt_reason_ = std::move(reason);

    // Compiled time Program (epic ADC-399, criterion 7): the CFL dt above is computed in adc_cpp ON

    // THE NATIVE STATE (per-block bounds + global bounds, UNCHANGED -- the CFL logic stays here), then

    // the installed Program drives the macro-step at that dt via the SHARED cadence helper. step_cfl

    // thus conserves the existing CFL logic AND calls the Program. Semantics match step()'s program

    // branch EXACTLY: run the cadence + tick the clock, with NO apply_couplings / apply_projections

    // (the Program expresses solve_fields / couplings / projections itself). The native advance path

    // below is taken ONLY when no program is installed. (step_adaptive -- multirate -- still drives

    // only the native path; a Program is whole-system, so multirate subcycling does not apply.)

    if (P->program_step_) {

      run_program_cadence(dt);

      return dt;

    }

    advance_due_blocks(

        dt);  // DUE blocks: catch-up transport + opt-in source stage (shared with step Lie)

    apply_couplings(Real(dt));

    apply_projections();  // projection ponctuelle POST-PAS ENTIER (ADC-177) ; no-op sans projection

    P->t += dt;

    P->macro_step_++;

    return dt;

  }


  double step_adaptive(double cfl) {

    Impl* P = owner_;

    P->solve_fields();

    // Multirate: macro-step = stable step of the SLOWEST block; each faster block is

    // subcycled n_b. aux frozen over the macro-step (coupling once-per-step). STRIDE SEMANTICS =

    // hold-then-catch-up: a block of cadence M is HELD as long as (macro_step + 1) % M != 0, then

    // advances by an effective step M*macro_dt at the window end (cf. stride_due).

    Real wmin = Real(1e30);

    std::vector<Real> wb;

    wb.reserve(P->sp.size());

    for (auto& s : P->sp) {

      const Real w = s.evolve ? s.max_speed(s.U) : Real(0);  // frozen block: out of cadence

      wb.push_back(w);

      if (s.evolve)

        wmin = std::min(wmin, w);

    }

    if (wmin >= Real(1e30))

      wmin = kCflSpeedFloor;      // no evolving block (all frozen)

    const Real h = cfl_grid_h();  // Cartesian min(dx,dy) / polar min(dr, r_min*dtheta)

    double macro_dt = cfl * static_cast<double>(h) / static_cast<double>(wmin);

    // OPTIONAL block bounds: each block subcycles n_b times its effective step

    // stride_b*macro_dt; the substep stride_b*macro_dt/n_b must satisfy the source / admissible

    // step bounds of the block. n_b (formula identical to the advance loop below) does not depend

    // on macro_dt: the clamp is done BEFORE the advance, n_b stays consistent.

    for (std::size_t b = 0; b < P->sp.size(); ++b) {

      auto& s = P->sp[b];

      if (!s.evolve)

        continue;

      if (!s.source_frequency && !s.stability_dt)

        continue;

      int n = static_cast<int>(

          std::ceil(static_cast<double>(s.stride) * static_cast<double>(wb[b] / wmin)));

      if (n < 1)

        n = 1;

      if (s.source_frequency) {

        const Real mu = s.source_frequency(s.U);

        if (mu > Real(0))

          macro_dt =

              std::min(macro_dt, cfl * static_cast<double>(n) /

                                     (static_cast<double>(s.stride) * static_cast<double>(mu)));

      }

      if (s.stability_dt) {

        const Real db = s.stability_dt(s.U);

        if (db > Real(0))

          macro_dt = std::min(macro_dt, static_cast<double>(db) * static_cast<double>(n) /

                                            static_cast<double>(s.stride));

      }

    }

    // Declared frequencies of the coupled sources (cf. step_cfl): bound on the MACRO-step.

    for (const auto& cs : P->coupled_freqs_) {

      if (cs.mu > 0.0)

        macro_dt = std::min(macro_dt, cfl / cs.mu);

    }

    // PER-CELL frequencies (Expr): MAX of mu(U) per cell, all_reduce_max, bound on the macro-step

    // (cf. step_cfl). step_adaptive does not track the active reason -> reason = nullptr.

    apply_coupled_freq_expr_bounds(cfl, macro_dt, nullptr);

    // GLOBAL bounds (System::add_dt_bound), like step_cfl; step_adaptive does not track the active

    // reason -> nullptr (same all_reduce_min, identical dt on all ranks).

    apply_global_dt_bounds(macro_dt, nullptr);

    for (std::size_t b = 0; b < P->sp.size(); ++b) {

      auto& s = P->sp[b];

      if (!s.evolve)

        continue;  // frozen block: not advanced

      if (!stride_due(P->macro_step_, s.stride))

        continue;  // hold: not at the stride window end

      // Stable subcycling of the EFFECTIVE step M*macro_dt: each substep must satisfy

      // M*macro_dt / n <= cfl*h / w_b, i.e. n >= ceil(M * w_b / w_min). The stride factor M is thus

      // carried by the number of substeps (without it, n on w_b/w_min alone would violate the CFL by a factor M).

      int n = static_cast<int>(

          std::ceil(static_cast<double>(s.stride) * static_cast<double>(wb[b] / wmin)));

      if (n < 1)

        n = 1;

      const Real eff_dt = Real(macro_dt) * Real(s.stride);  // catch-up: effective step M*macro_dt

      advance_transport_n(s, eff_dt,

                          n);  // transport DISPATCHED by the geometry mode (n adaptive substeps)

      run_source_stage(s, eff_dt);  // OPT-IN: Schur-condensed source stage (no-op otherwise)

    }

    apply_couplings(Real(macro_dt));

    apply_projections();  // projection ponctuelle POST-MACRO-PAS (ADC-177), pas par sous-cycle

    P->t += macro_dt;

    P->macro_step_++;

    return macro_dt;

  }


  const std::string& last_dt_reason() const { return last_dt_reason_; }


 private:

  Impl* owner_;

  SplitScheme scheme_ = SplitScheme::Lie;  // default Lie (Godunov): bit-identical to history

  std::string last_dt_reason_;             // active bound of the last step_cfl (diagnostic)

};


}  // namespace stepper


}  // namespace pops

pops::stepper::SystemStepper
SystemStepper<Impl>: see the contract above.
Definition system_stepper.hpp:68

pops::stepper::SystemStepper::cfl_grid_h
Real cfl_grid_h() const
MIN physical step of the grid, shared by step_cfl / step_adaptive: Cartesian = min(dx,...
Definition system_stepper.hpp:160

pops::stepper::SystemStepper::SystemStepper
SystemStepper(Impl *owner)
Definition system_stepper.hpp:71

pops::stepper::SystemStepper::run_program_cadence
void run_program_cadence(double dt)
Runs ONE macro-step of length dt through an INSTALLED compiled time Program (epic ADC-399): the SYSTE...
Definition system_stepper.hpp:337

pops::stepper::SystemStepper::apply_projections
void apply_projections()
PROJECTION PONCTUELLE post-pas (ADC-177) : U <- project(U, aux) par bloc, appliquee UNE fois a la FIN...
Definition system_stepper.hpp:202

pops::stepper::SystemStepper::advance_transport
void advance_transport(typename Impl::Species &s, Real eff_dt)
TRANSPORT ADVANCE of block s over eff_dt in s.substeps substeps, dispatched by the mode (cf.
Definition system_stepper.hpp:283

pops::stepper::SystemStepper::apply_couplings
void apply_couplings(Real dt)
Inter-species COUPLING sources: applied by SPLITTING (one explicit additive step of dt) AFTER the tra...
Definition system_stepper.hpp:92

pops::stepper::SystemStepper::stride_due
static bool stride_due(int macro_step, int stride)
True if a block of cadence stride CATCHES UP at this macro-step (END of window).
Definition system_stepper.hpp:86

pops::stepper::SystemStepper::step_cfl
double step_cfl(double cfl)
One macro-step at CFL dt: dt = min over the evolving blocks of the block step BOUNDS,...
Definition system_stepper.hpp:482

pops::stepper::SystemStepper::step_adaptive
double step_adaptive(double cfl)
One MULTIRATE macro-step: the macro-step = stable step of the SLOWEST block; each faster block is sub...
Definition system_stepper.hpp:609

pops::stepper::SystemStepper::advance_transport_n
void advance_transport_n(typename Impl::Species &s, Real dt, int n)
TRANSPORT ADVANCE of block s over dt in n substeps, DISPATCHED by the System geometry mode (worksite ...
Definition system_stepper.hpp:257

pops::stepper::SystemStepper::scheme
SplitScheme scheme() const
Definition system_stepper.hpp:75

pops::stepper::SystemStepper::advance_transport_half
void advance_transport_half(typename Impl::Species &s, Real eff_dt)
HALF transport advance (Strang): dispatch of advance_transport over half_dt = eff_dt/2 – the disk mod...
Definition system_stepper.hpp:289

pops::stepper::SystemStepper::apply_global_dt_bounds
void apply_global_dt_bounds(double &dt, std::string *reason) const
GLOBAL step bounds (System::add_dt_bound): multi-block coupling, Schur/Poisson, AMR/scheduler.
Definition system_stepper.hpp:175

pops::stepper::SystemStepper::apply_coupled_freq_expr_bounds
void apply_coupled_freq_expr_bounds(double cfl, double &dt, std::string *reason) const
Step bound from PER-CELL COUPLED FREQUENCIES (CoupledSource.frequency with an Expr,...
Definition system_stepper.hpp:112

pops::stepper::SystemStepper::run_source_stage
void run_source_stage(typename Impl::Species &s, Real eff_dt)
Schur-CONDENSED SOURCE STAGE (OPT-IN, cf.
Definition system_stepper.hpp:221

pops::stepper::SystemStepper::advance
void advance(double dt, int nsteps)
Advances by nsteps macro-steps of length dt (loop over step).
Definition system_stepper.hpp:453

pops::stepper::SystemStepper::step
void step(double dt)
One macro-step of length dt.
Definition system_stepper.hpp:355

pops::stepper::SystemStepper::set_scheme
void set_scheme(SplitScheme scheme)
Chooses the time splitting policy (default Lie = bit-identical). See SplitScheme.
Definition system_stepper.hpp:74

pops::stepper::SystemStepper::step_strang
void step_strang(double dt)
One STRANG macro-step (symmetric, 2nd order): H(dt/2); S(dt); H(dt/2).
Definition system_stepper.hpp:406

pops::stepper::SystemStepper::advance_due_blocks
void advance_due_blocks(double dt)
FULL-STEP advance of every DUE block over dt: effective step eff_dt = stride * dt (cadence catch-up),...
Definition system_stepper.hpp:303

pops::stepper::SystemStepper::last_dt_reason
const std::string & last_dt_reason() const
Name of the ACTIVE bound (the one that fixed dt) of the last step_cfl: "transport:<block>",...
Definition system_stepper.hpp:696

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

coupled_source_program.hpp
Generic COUPLED SOURCE interpreter: postfix bytecode evaluated on device (P5 phase 1).

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

grid_context.hpp
Block grid context plus closures, shared between System (which installs them) and block_builder....

pops::stepper::SplitScheme
SplitScheme
Time SPLITTING policy of the macro-step (hyperbolic transport H + source stage S).
Definition system_stepper.hpp:62

pops::stepper::SplitScheme::Strang
@ Strang

pops::stepper::SplitScheme::Lie
@ Lie

pops
Definition amr_hierarchy.hpp:29

pops::kCflSpeedFloor
constexpr Real kCflSpeedFloor
Speed FLOOR for the CFL step policies (audit 2026-06, explicit constant instead of the scattered lite...
Definition types.hpp:38

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

pops::kCsMaxReg
constexpr int kCsMaxReg
Definition coupled_source_program.hpp:40

pops::reduce_max_cell
Real reduce_max_cell(const Box2D &b, F f)
MAX reduction with a REDUCING FUNCTOR: f receives (i, j, Real& acc) and updates acc,...
Definition for_each.hpp:240

pops::all_reduce_max
double all_reduce_max(double x)
Definition comm.hpp:146

pops::all_reduce_min
double all_reduce_min(double x)
Definition comm.hpp:149

pops::GeometryMode
GeometryMode
TRANSPORT GEOMETRY MODE of the macro-step (T5-PR3 effort, disc wiring in System::step).
Definition grid_context.hpp:29

pops::GeometryMode::None
@ None

pops::GeometryMode::Staircase
@ Staircase

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

pops::CoupledFreqKernel
Definition coupled_source_program.hpp:175

pops::CoupledFreqKernel::prog
CsProgram prog
Definition coupled_source_program.hpp:183

pops::CoupledFreqKernel::consts
Real consts[kCsMaxReg]
Definition coupled_source_program.hpp:180

pops::CoupledFreqKernel::in_comp
int in_comp[kCsMaxReg]
Definition coupled_source_program.hpp:177

pops::CoupledFreqKernel::n_const
int n_const
Definition coupled_source_program.hpp:181

pops::CoupledFreqKernel::n_in
int n_in
Definition coupled_source_program.hpp:178

pops::CoupledFreqKernel::in
Array4 in[kCsMaxReg]
Definition coupled_source_program.hpp:176

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