PoPS/doxygen/amr__system_8hpp_source.html

#pragma once


#include <pops/mesh/layout/patch_box.hpp>  // PatchBox: index-space signature of a fine patch (patch_boxes())

#include <pops/mesh/boundary/physical_bc.hpp>                // BCRec

#include <pops/numerics/time/integrators/implicit_stepper.hpp>  // NewtonOptions (Newton options of the IMEX source)

#include <pops/runtime/export.hpp>  // POPS_EXPORT: set_compiled_block resolved by the native AMR loader

#include <pops/runtime/facade_options.hpp>  // SourceStageOptions / CoupledSourceProgram (facade PODs, ADC-214)

#include <pops/runtime/config/model_spec.hpp>


#include <functional>

#include <map>

#include <memory>

#include <string>

#include <vector>


namespace pops {


// Forward declarations of the runtime multi-block engine (definitions in amr_runtime.hpp /

// amr_dsl_block.hpp). set_compiled_block stores a DEFERRED runtime-block BUILDER which, given the

// SHARED layout materialized at lazy build, returns the type-erased AmrRuntimeBlock of the compiled

// block: this is what lets SEVERAL compiled blocks (multi-block production DSL) co-exist on the

// SAME AMR hierarchy, exactly like add_block in native multi-block. We forward-declare so as NOT

// to weigh down this public header (read by bindings.cpp and the loaders) with amr_runtime.hpp: only

// the TUs that BUILD/CALL the builder (amr_dsl_block.hpp and python/amr_system.cpp) include the

// complete definitions; a std::function with incomplete-type signature is legal as long as it is

// not instantiated with a concrete callable outside those TUs (PIMPL std::function recipe).

struct AmrRuntimeBlock;

// Forward-declared for the named-elliptic-field RHS closure signature (ADC-428,

// set_block_elliptic_field): a std::function with an incomplete-type parameter is legal as long as it is

// only INSTANTIATED with a concrete callable in the TUs that include the full definition (the native AMR

// loader / python/bindings/amr/amr_system.cpp), per the PIMPL std::function recipe noted above.

class MultiFab;

namespace detail {

struct SharedAmrLayout;

}


struct AmrSystemConfig {

  int n = 128;

  double L = 1.0;

  int regrid_every = 20;

  bool periodic = true;

  bool distribute_coarse = false;

  int coarse_max_grid = 0;

};


struct AmrBuildParams {

  int n = 128;

  double L = 1.0;

  int regrid_every = 20;

  double gamma = 1.4;

  int substeps = 1;

  bool recon_prim = false;

  bool imex = false;

  double refine_threshold = 1e30;

  BCRec poisson_bc;

  std::function<bool(Real, Real)> wall;

  bool has_density = false;

  std::vector<double> density;

  bool distribute_coarse = false;

  int coarse_max_grid = 0;

  // FULL initial conservative state (all components), takes priority over `density` when

  // has_state. ADDED AT THE END OF THE STRUCT: the offsets of the preceding fields are unchanged, so an

  // older mono-block .so loader (which COPIES bp into its own layout then does not read these fields)

  // falls back SILENTLY to the historical density path -- no corruption (append-only).

  bool has_state = false;

  std::vector<double>

      state;

  // Schur-CONDENSED SOURCE STAGE (amr-schur path, counterpart of System::set_source_stage). ADDED AT THE

  // END OF THE STRUCT (append-only, same reason as has_state: an older .so loader does not read these

  // fields and falls back to the historical explicit/imex path). schur==false -> path unchanged.

  bool schur = false;

  double schur_theta = 0.5;

  double schur_alpha = 1.0;

  bool schur_strang =

      false;

  std::vector<double>

      bz_field;

  std::map<int, std::vector<double>> named_aux;

  std::map<int, AuxHaloPolicy> named_aux_bc;

  // Settings of the condensed stage TRANSPORTED by the ABI (audit wave 3, append-only like has_state).

  double schur_krylov_tol = 0.0;

  int schur_krylov_max_iters = 0;

  // Field descriptors of the stage ("" = canonical role, bit-identical; otherwise stable role

  // name OR block variable name, resolved at build against Model::conservative_vars()).

  std::string schur_density, schur_momentum_x, schur_momentum_y, schur_energy;

  // NEWTON OPTIONS of the IMEX source on the MONO-BLOCK path (wave 3: mono-block AMR options wired).

  // ADDED AT THE END OF THE STRUCT (append-only, same reason as has_state / schur_*: an older .so loader

  // does not read this field and falls back to the historical Newton with 2 frozen iters). DEFAULT {} =

  // historical constants (2 / 0 / 0 / 1e-7 / 1.0 / none) -> backward_euler_source path (2a)

  // bit-identical. Consumed by build_amr_compiled (the mono-block closure passes it to cpl->step).

  NewtonOptions newton_options{};

  // TEMPORAL METHOD of the block, transported as an INTEGER by the flat ABI (0 == kEuler, historical

  // before, 1 == kSsprk3). ADDED AT THE END OF THE STRUCT (append-only, same reason as has_state /

  // schur_* / newton_options: an older .so loader does not read this field and falls back SILENTLY

  // to 0 == kEuler -- no corruption). Consumed by build_amr_compiled (mono-block -> cpl->step).

  int time_method = 0;  // pops::AmrTimeMethod: 0 kEuler (default), 1 kSsprk3

  // Zhang-Shu positivity floor (ADC-259): Density-role face-state + C/F-ghost-mean floor on the AMR

  // transport. ADDED AT THE END OF THE STRUCT (append-only, same reason as has_state / schur_* /

  // newton_options / time_method: an older flat-ABI .so loader does not read this field and falls

  // back SILENTLY to 0 -- inactive, bit-identical). Consumed by build_amr_compiled (mono-block ->

  // cpl->step / advance_transport). The COMPILED .so path now carries it too (ADC-322): the

  // regenerated loader marshals pos_floor (pops_install_native_amr) into add_compiled_model ->

  // set_compiled_block, which stores it here (mono) and passes it to the AmrCompiledBlockBuilder (multi).

  double pos_floor = 0.0;

};


struct AmrCompiledHooks {

  std::shared_ptr<void> coupler_holder;

  std::function<void(double)> step;

  std::function<double()> max_speed;

  std::function<double()> mass;

  std::function<int()> n_patches;

  std::function<std::vector<double>()> density;

  std::function<std::vector<double>()> potential;

  // ADDED AT THE TAIL (additive, moves no existing field): index-space signatures of the fine

  // patches. Mirror of n_patches (same box_array(), the COUNT becomes the BOXES). The .so loader that

  // builds this struct is guarded by pops_native_abi_key: a .so generated BEFORE this addition must be

  // recompiled (the guard already diagnoses it clearly); the tail addition makes it purely additive.

  std::function<std::vector<PatchBox>()>

      patch_boxes;

  // ADDED AT THE TAIL (AMR StabilityPolicy, audit 2026-06, additive like patch_boxes): OPTIONAL step

  // bounds of the block, evaluated on the COARSE level by AmrSystem::step_cfl mono-block. EMPTY if

  // the model does not declare the HasSourceFrequency / HasStabilityDt traits (bit-identical). The

  // pops_native_abi_key guard forces regeneration of older .so files (purely additive addition).

  std::function<double()> source_frequency;

  std::function<double()>

      stability_dt;

  // ADDED AT THE TAIL (IO v1, parity with System::set_clock): restoration of the macro-step counter of

  // the MONO-BLOCK engine (the AmrCouplerMP coupler carries the regrid-cadence phase in a step_state;

  // this hook writes it at restart). EMPTY is never the case (the builder always populates it); the

  // pops_native_abi_key guard forces regeneration of older .so files (purely additive tail addition).

  std::function<void(int)>

      set_macro_step;

  // ADDED AT THE TAIL (mono-rank AMR checkpoint/restart, ADC-65; additive like set_macro_step): FULL

  // CONSERVATIVE state per level (all components) + phi (warm-start) + imposition of a SAVED fine

  // hierarchy. The mono-block coupler (AmrCouplerMP) carries them; the builder always populates them

  // (never empty). The pops_native_abi_key guard forces regeneration of older .so files.

  std::function<int()> n_levels;

  std::function<int()> n_vars;

  std::function<std::vector<double>(int)> level_state;

  std::function<void(int, const std::vector<double>&)>

      set_level_state;

  std::function<std::vector<double>(int)> level_potential;

  std::function<void(int, const std::vector<double>&)>

      set_level_potential;

  std::function<void(const std::vector<PatchBox>&)>

      set_hierarchy;

  // ADDED AT THE TAIL (ADC-319, MPI ownership diagnostic; additive like the fields above): COARSE-level

  // (base) box counts. coarse_local_boxes = cpl->coarse().local_size() (level-0 fabs OWNED by this rank);

  // coarse_total_boxes = cpl->coarse().box_array().size() (total base boxes, all ranks). They reveal

  // whether distribute_coarse actually distributes the base across ranks (local < total) or replicates

  // it (local == total on every rank). The pops_native_abi_key guard forces regeneration of older .so

  // files (purely additive tail addition); the builder always populates them (never empty).

  std::function<int()> coarse_local_boxes;

  std::function<int()> coarse_total_boxes;

  // ADDED AT THE TAIL (np>1 mono-block AMR checkpoint, ADC-509; additive like the fields above): the

  // GLOBAL (all_reduce_sum gather) counterparts of level_state / level_potential. Under MPI np>1 the

  // per-level fabs are distributed (round-robin fine patches, optionally distributed coarse), so a

  // bit-identical checkpoint must GATHER them onto every rank before rank 0 writes -- exactly like

  // System::state_global / potential_global. The pops_native_abi_key guard forces regeneration of

  // older .so files (purely additive tail addition); the builder always populates them (never empty).

  std::function<std::vector<double>(int)> level_state_global;

  std::function<std::vector<double>(int)> level_potential_global;

};


using AmrCompiledBlockBuilder = std::function<AmrRuntimeBlock(

    const detail::SharedAmrLayout& layout, 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<std::string>& implicit_vars,

    const std::vector<std::string>& implicit_roles, double pos_floor)>;


class AmrSystem {

 public:

  explicit AmrSystem(const AmrSystemConfig& cfg);

  ~AmrSystem();

  // RULE OF FIVE (C.21): move-only (PIMPL unique_ptr). The copy was already IMPLICITLY deleted

  // (move ctor declared); we make it EXPLICIT for intent. No API change (the copy was

  // already unusable).

  AmrSystem(const AmrSystem&) = delete;

  AmrSystem& operator=(const AmrSystem&) = delete;

  AmrSystem(AmrSystem&&) noexcept;

  AmrSystem& operator=(AmrSystem&&) noexcept;


  void add_dt_bound(const std::string& label, std::function<double()> fn);


  std::string last_dt_bound() const;


  void add_block(const std::string& name, const ModelSpec& model,

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

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

                 int substeps = 1, int stride = 1,

                 const std::vector<std::string>& implicit_vars = {},

                 const std::vector<std::string>& implicit_roles = {},

                 const NewtonOptions& newton = {}, bool newton_diagnostics = false,

                 double positivity_floor = 0.0);


  struct SourceNewtonReport {

    bool enabled;

    bool converged;

    double max_residual;

    double max_iters_used;

    double

        n_failed;

    double failed_i;

    double failed_j;

    double failed_comp;

  };


  SourceNewtonReport newton_report(const std::string& name);


  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);


  void add_native_block(const std::string& name, const std::string& so_path,

                        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,

                        double positivity_floor = 0.0);


  void set_refinement(double threshold, const std::string& variable = std::string(),

                      const std::string& role = std::string());


  void set_phi_refinement(double grad_threshold);


  void set_poisson(const std::string& rhs = "charge_density",

                   const std::string& solver = "geometric_mg", const std::string& bc = "auto",

                   const std::string& wall = "none", double wall_radius = 0.0);


  void set_density(const std::string& name, const std::vector<double>& rho);


  void set_conservative_state(const std::string& name, const std::vector<double>& U);


  void set_magnetic_field(const std::vector<double>& bz);


  void set_aux_field_component(int comp, const std::vector<double>& field);


  void set_aux_field_halo_component(int comp, int bc_type, double value);


  POPS_EXPORT void register_elliptic_field(const std::string& field, int phi_comp, int gx_comp,

                                           int gy_comp);

  POPS_EXPORT void set_block_elliptic_field(const std::string& block_name, const std::string& field,

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

  std::vector<double> named_field_values(const std::string& field);


  void set_source_stage(const std::string& name, const std::string& kind, double theta,

                        double alpha, const SourceStageOptions& opts = {});


  void set_time_scheme(const std::string& scheme);


  void add_coupled_source(const CoupledSourceProgram& prog, double frequency = 0.0,

                          const std::string& label = "coupled_source");


  void step(double dt);

  void advance(double dt, int nsteps);

  double step_cfl(double cfl);


  int nx() const;

  double time() const;

  int macro_step() const;

  void set_clock(double t, int macro_step);


  void enable_profiling();

  void disable_profiling();

  bool is_profiling() const;

  void reset_profiling();

  std::string profile_report() const;

  int n_blocks() const;

  std::vector<std::string> block_names() const;

  int n_patches();

  std::vector<PatchBox> patch_boxes();

  int coarse_local_boxes();

  int coarse_total_boxes();


  int n_levels();

  int n_vars();

  std::vector<double> level_state(int k);

  std::vector<double> level_state_global(int k);

  void set_level_state(int k,

                       const std::vector<double>& s);

  std::vector<double> level_potential(int k);

  std::vector<double> level_potential_global(int k);

  void set_level_potential(int k, const std::vector<double>& p);

  void set_hierarchy(const std::vector<PatchBox>& boxes);


  int block_n_vars(const std::string& name);

  std::vector<double> block_level_state(const std::string& name, int k);

  std::vector<double> block_level_state_global(const std::string& name,

                                               int k);

  void set_block_level_state(const std::string& name, int k, const std::vector<double>& s);


  double mass();

  double mass(

      const std::string& name);

  std::vector<double> density();

  std::vector<double> density(const std::string& name);

  std::vector<double> potential();


 private:

  struct Impl;

  std::unique_ptr<Impl> p_;

};


}  // namespace pops

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

pops::AmrSystem::set_level_potential
void set_level_potential(int k, const std::vector< double > &p)
restores phi of level k

pops::AmrSystem::set_clock
void set_clock(double t, int macro_step)
RESTORES the AMR clock (t, macro_step) – parity with System::set_clock.

pops::AmrSystem::level_potential_global
std::vector< double > level_potential_global(int k)
np>1 gather (all ranks call)

pops::AmrSystem::~AmrSystem
~AmrSystem()

pops::AmrSystem::add_block
void add_block(const std::string &name, const ModelSpec &model, const std::string &limiter="minmod", const std::string &riemann="rusanov", const std::string &recon="conservative", const std::string &time="explicit", int substeps=1, int stride=1, const std::vector< std::string > &implicit_vars={}, const std::vector< std::string > &implicit_roles={}, const NewtonOptions &newton={}, bool newton_diagnostics=false, double positivity_floor=0.0)
Adds a block carried on the AMR.

pops::AmrSystem::set_source_stage
void set_source_stage(const std::string &name, const std::string &kind, double theta, double alpha, const SourceStageOptions &opts={})
Enables the Schur-CONDENSED SOURCE STAGE (amr-schur path) on block name.

pops::AmrSystem::AmrSystem
AmrSystem(AmrSystem &&) noexcept

pops::AmrSystem::disable_profiling
void disable_profiling()

pops::AmrSystem::add_dt_bound
void add_dt_bound(const std::string &label, std::function< double()> fn)
GLOBAL time-step bound (AMR counterpart of System::add_dt_bound): fn() evaluated ONCE per step_cfl (h...

pops::AmrSystem::is_profiling
bool is_profiling() const

pops::AmrSystem::coarse_total_boxes
int coarse_total_boxes()

pops::AmrSystem::block_names
std::vector< std::string > block_names() const
Names of the blocks in add order (parity with System::block_names): the IO facade iterates over them ...

pops::AmrSystem::level_potential
std::vector< double > level_potential(int k)
Potential phi of level k, flat nf*nf row-major.

pops::AmrSystem::set_hierarchy
void set_hierarchy(const std::vector< PatchBox > &boxes)
Imposes the SAVED fine hierarchy (at restart) instead of Berger-Rigoutsos clustering: boxes are the p...

pops::AmrSystem::potential
std::vector< double > potential()
Electrostatic potential phi of the COARSE LEVEL (base), n*n row-major.

pops::AmrSystem::enable_profiling
void enable_profiling()

pops::AmrSystem::set_block_elliptic_field
POPS_EXPORT void set_block_elliptic_field(const std::string &block_name, const std::string &field, std::function< void(const MultiFab &, MultiFab &)> rhs)
Attaches named field's RHS closure (rhs += elliptic_field_rhs(U)) to block block_name.

pops::AmrSystem::n_vars
int n_vars()
number of conserved components (MONO-BLOCK; multi-block: block_n_vars)

pops::AmrSystem::level_state
std::vector< double > level_state(int k)
FULL conservative state of level k, flat component-major c*nf*nf + j*nf + i (nf = n << k; zeros outsi...

pops::AmrSystem::add_native_block
void add_native_block(const std::string &name, const std::string &so_path, 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, double positivity_floor=0.0)
Wires a NATIVE AMR block from a .so loader generated by the DSL (backend "production",...

pops::AmrSystem::set_time_scheme
void set_time_scheme(const std::string &scheme)
Chooses the time-splitting policy of the condensed source stage: "lie" (default, H(dt) S(dt)) or "str...

pops::AmrSystem::named_field_values
std::vector< double > named_field_values(const std::string &field)
Solved potential of named field on the COARSE level, n*n row-major (read-back).

pops::AmrSystem::mass
double mass()
mass of the 1st block on the coarse (conserved at reflux)

pops::AmrSystem::set_density
void set_density(const std::string &name, const std::vector< double > &rho)
Sets the initial density on the coarse level (component 0), n*n row-major.

pops::AmrSystem::level_state_global
std::vector< double > level_state_global(int k)
MONO-BLOCK, np>1 gather (all ranks call)

pops::AmrSystem::n_blocks
int n_blocks() const
number of blocks (1 = mono-block AmrCouplerMP; >= 2 = AmrRuntime)

pops::AmrSystem::operator=
AmrSystem & operator=(const AmrSystem &)=delete

pops::AmrSystem::set_block_level_state
void set_block_level_state(const std::string &name, int k, const std::vector< double > &s)

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::AmrSystem::block_level_state
std::vector< double > block_level_state(const std::string &name, int k)

pops::AmrSystem::reset_profiling
void reset_profiling()

pops::AmrSystem::profile_report
std::string profile_report() const

pops::AmrSystem::set_conservative_state
void set_conservative_state(const std::string &name, const std::vector< double > &U)
Sets the FULL INITIAL CONSERVATIVE STATE (all components) on the coarse level, then prolongs it to th...

pops::AmrSystem::density
std::vector< double > density()
coarse density of the 1st block (component 0), n*n row-major

pops::AmrSystem::density
std::vector< double > density(const std::string &name)
coarse density of the named block, n*n

pops::AmrSystem::set_level_state
void set_level_state(int k, const std::vector< double > &s)
restores the state of level k (as is)

pops::AmrSystem::register_elliptic_field
POPS_EXPORT void register_elliptic_field(const std::string &field, int phi_comp, int gx_comp, int gy_comp)

pops::AmrSystem::set_magnetic_field
void set_magnetic_field(const std::vector< double > &bz)
Sets the magnetic field B_z(x, y) of the coarse level (n*n row-major), required by the Schur-condense...

pops::AmrSystem::step
void step(double dt)
one AMR macro-step (periodic regrid included)

pops::AmrSystem::newton_report
SourceNewtonReport newton_report(const std::string &name)

pops::AmrSystem::n_levels
int n_levels()
AMR CHECKPOINT / RESTART (ADC-65 single-block single-rank; ADC-509 multi-block + np>1): per-level STA...

pops::AmrSystem::set_refinement
void set_refinement(double threshold, const std::string &variable=std::string(), const std::string &role=std::string())
Refines the cells where the SELECTED conserved variable exceeds threshold.

pops::AmrSystem::block_level_state_global
std::vector< double > block_level_state_global(const std::string &name, int k)
np>1 gather (all ranks call)

pops::AmrSystem::last_dt_bound
std::string last_dt_bound() const
ACTIVE bound of the last step_cfl: "transport:<block>" | "source_frequency:<block>" | "stability_dt:<...

pops::AmrSystem::add_coupled_source
void add_coupled_source(const CoupledSourceProgram &prog, double frequency=0.0, const std::string &label="coupled_source")
Registers an inter-species COUPLED SOURCE (compiled pops.dsl.CoupledSource, flat bytecode ABI P5),...

pops::AmrSystem::coarse_local_boxes
int coarse_local_boxes()
COARSE-level (base) box counts, MPI ownership diagnostic (ADC-319).

pops::AmrSystem::set_phi_refinement
void set_phi_refinement(double grad_threshold)
Adds to the regrid criterion the PHI tag on |grad phi| (D4 of the design docs/AMR_REGRID_UNION_TAGS_D...

pops::AmrSystem::AmrSystem
AmrSystem(const AmrSystem &)=delete

pops::AmrSystem::step_cfl
double step_cfl(double cfl)
Advances at dt = cfl * coarse_dx / max wave speed.

pops::AmrSystem::mass
double mass(const std::string &name)
mass of the named block on the coarse (conserved PER BLOCK)

pops::AmrSystem::patch_boxes
std::vector< PatchBox > patch_boxes()
Index-space signatures of the current fine patches: one PatchBox (level, ilo, jlo,...

pops::AmrSystem::time
double time() const

pops::AmrSystem::advance
void advance(double dt, int nsteps)

pops::AmrSystem::set_aux_field_component
void set_aux_field_component(int comp, const std::vector< double > &field)
Sets a model-NAMED aux field (ADC-291) at shared-channel component comp (>= kAuxNamedBase) from a coa...

pops::AmrSystem::AmrSystem
AmrSystem(const AmrSystemConfig &cfg)

pops::AmrSystem::n_patches
int n_patches()
number of current fine patches (of the shared hierarchy)

pops::AmrSystem::macro_step
int macro_step() const
MACRO-STEP counter (0-indexed; incremented by step / advance / step_cfl), parity with System::macro_s...

pops::AmrSystem::block_n_vars
int block_n_vars(const std::string &name)
MULTI-BLOCK per-BLOCK per-level checkpoint accessors (ADC-509).

pops::AmrSystem::set_poisson
void set_poisson(const std::string &rhs="charge_density", const std::string &solver="geometric_mg", const std::string &bc="auto", const std::string &wall="none", double wall_radius=0.0)
Configures the coarse Poisson (cf.

pops::AmrSystem::nx
int nx() const

pops::AmrSystem::set_aux_field_halo_component
void set_aux_field_halo_component(int comp, int bc_type, double value)
Declares a per-field aux HALO policy (ADC-369) for the NAMED component comp (>= kAuxNamedBase): bc_ty...

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

export.hpp
POPS_EXPORT: force DEFAULT VISIBILITY on an out-of-line symbol, even when the unit is compiled with -...

POPS_EXPORT
#define POPS_EXPORT
Definition export.hpp:25

facade_options.hpp
OPTIONS PODs for the public facades (System / AmrSystem), grouping the long families of HOMOGENEOUS p...

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

model_spec.hpp
Flat specification of a model: chosen bricks plus their parameters.

pops
Definition amr_hierarchy.hpp:29

pops::AmrCompiledBlockBuilder
std::function< AmrRuntimeBlock(const detail::SharedAmrLayout &layout, 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< std::string > &implicit_vars, const std::vector< std::string > &implicit_roles, double pos_floor)> AmrCompiledBlockBuilder
DEFERRED builder of a COMPILED block on the multi-block hierarchy: receives the SHARED layout (create...
Definition amr_system.hpp:227

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

patch_box.hpp
PatchBox: index-space footprint of an AMR fine patch, exposed read-only to Python.

physical_bc.hpp
PHYSICAL boundary conditions at the domain edge (BCType, BCRec, fill_physical_bc, fill_ghosts).

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::set_hierarchy
std::function< void(const std::vector< PatchBox > &)> set_hierarchy
imposes the saved fine patches
Definition amr_system.hpp:193

pops::AmrCompiledHooks::n_vars
std::function< int()> n_vars
conserved components of the block
Definition amr_system.hpp:185

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

pops::AmrCompiledHooks::set_level_state
std::function< void(int, const std::vector< double > &)> set_level_state
restores the state of level k
Definition amr_system.hpp:188

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

pops::AmrCompiledHooks::level_potential
std::function< std::vector< double >(int)> level_potential
phi of level k (nf*nf row-major)
Definition amr_system.hpp:189

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::level_potential_global
std::function< std::vector< double >(int)> level_potential_global
level k phi, gathered
Definition amr_system.hpp:209

pops::AmrCompiledHooks::coarse_total_boxes
std::function< int()> coarse_total_boxes
global coarse box count (identical on all ranks)
Definition amr_system.hpp:201

pops::AmrCompiledHooks::n_levels
std::function< int()> n_levels
number of levels (>= 1)
Definition amr_system.hpp:184

pops::AmrCompiledHooks::set_level_potential
std::function< void(int, const std::vector< double > &)> set_level_potential
restores phi of level k
Definition amr_system.hpp:191

pops::AmrCompiledHooks::level_state
std::function< std::vector< double >(int)> level_state
full state of level k (c*nf*nf+j*nf+i)
Definition amr_system.hpp:186

pops::AmrCompiledHooks::potential
std::function< std::vector< double >()> potential
coarse-level phi, n*n row-major
Definition amr_system.hpp:160

pops::AmrCompiledHooks::density
std::function< std::vector< double >()> density
coarse density, n*n row-major
Definition amr_system.hpp:159

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

pops::AmrCompiledHooks::level_state_global
std::function< std::vector< double >(int)> level_state_global
level k state, gathered
Definition amr_system.hpp:208

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::coarse_local_boxes
std::function< int()> coarse_local_boxes
per-rank owned coarse (level-0) fab count
Definition amr_system.hpp:200

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::AmrRuntimeBlock
Type-erased closures of ONE AMR block, placed on the shared hierarchy.
Definition amr_runtime.hpp:98

pops::AmrSystemConfig
AMR mesh and cadence (per-block physical parameters live in the ModelSpec).
Definition amr_system.hpp:61

pops::AmrSystemConfig::regrid_every
int regrid_every
re-refinement every N steps (0 = never after init)
Definition amr_system.hpp:64

pops::AmrSystemConfig::n
int n
coarse-level cells per direction
Definition amr_system.hpp:62

pops::AmrSystemConfig::distribute_coarse
bool distribute_coarse
OWNERSHIP POLICY of the coarse level (cf.
Definition amr_system.hpp:75

pops::AmrSystemConfig::L
double L
size of the square domain [0,L]^2
Definition amr_system.hpp:63

pops::AmrSystemConfig::coarse_max_grid
int coarse_max_grid
Coarse tile size when distribute_coarse=true (BoxArray::from_domain).
Definition amr_system.hpp:78

pops::AmrSystemConfig::periodic
bool periodic
periodic domain
Definition amr_system.hpp:65

pops::AmrSystem::SourceNewtonReport
Report of the implicit (IMEX) source Newton of a block, AGGREGATED over the levels and substeps of th...
Definition amr_system.hpp:327

pops::AmrSystem::SourceNewtonReport::failed_j
double failed_j
j of the same cell (-1 if none)
Definition amr_system.hpp:335

pops::AmrSystem::SourceNewtonReport::converged
bool converged
no cell failed on the last advance
Definition amr_system.hpp:329

pops::AmrSystem::SourceNewtonReport::max_residual
double max_residual
max over cells/levels/substeps of ||F||_inf at the Newton exit
Definition amr_system.hpp:330

pops::AmrSystem::SourceNewtonReport::failed_i
double failed_i
i of ONE faulty cell (-1 if none; max index encoded)
Definition amr_system.hpp:334

pops::AmrSystem::SourceNewtonReport::n_failed
double n_failed
count (cells x levels x substeps) failed (non-finite / pivot / non-convergence)
Definition amr_system.hpp:333

pops::AmrSystem::SourceNewtonReport::max_iters_used
double max_iters_used
max over cells/levels/substeps of the iterations consumed
Definition amr_system.hpp:331

pops::AmrSystem::SourceNewtonReport::failed_comp
double failed_comp
conserved component of the worst residual of that cell (-1 unknown)
Definition amr_system.hpp:336

pops::AmrSystem::SourceNewtonReport::enabled
bool enabled
a report was computed (at least one IMEX advance played)
Definition amr_system.hpp:328

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

pops::CoupledSourceProgram
BYTECODE description of a generic inter-species COUPLED SOURCE (cf.
Definition facade_options.hpp:77

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

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

pops::SourceStageOptions
Settings of the Schur-condensed SOURCE STAGE (cf.
Definition facade_options.hpp:48

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