Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 12345]

►Npops
►Ncompiled_block
CHasRuntimeParams	Detects (SFINAE) whether a brick B exposes a `params` member of type pops::RuntimeParams (DSL bricks carry one only if a formula reads a runtime parameter, P7-b)
CHasRuntimeParams< B, std::void_t< decltype(std::declval< B & >().params)> >
CLocalGrid	Local single-grid mesh rebuilt inside the .so + aux filled from the System array
►Ndetail
CAddScaledComponentKernel	NAMED functor (not an POPS_HD lambda) of the accumulation: r(i,j,0) += a * u(i,j,c)
CAdvanceExplicit	EXPLICIT advance: n substeps of the `Stepper` stepper (SSPRK2 by default, SSPRK3 optional) on the transport+source residual
CAdvanceExplicitEb	CUT-CELL / EB EXPLICIT advance: n substeps of the `Stepper` stepper on the EB transport residual
CAdvanceExplicitMasked	MASKED EXPLICIT advance: n substeps of the `Stepper` stepper on the MASKED transport residual
CAdvanceFab1cKernel	Explicit Euler, 1 component: U -= dt div(F) on cell (i,j)
CAdvanceImex	IMEX advance: per substep, EXPLICIT half-step (source-free transport) + stiff IMPLICIT source
CAdvanceImexEb	CUT-CELL / EB IMEX advance: EB EXPLICIT half-step (source-free transport) + stiff IMPLICIT source
CAdvanceImexMasked	MASKED IMEX advance: MASKED EXPLICIT half-step (source-free transport) + stiff IMPLICIT source
CAdvanceImexRkArs222	IMEX-RK ARS(2,2,2) advance (Ascher, Ruuth, Spiteri 1997; "Implicit-explicit Runge-Kutta methods for time-dependent partial differential equations", Appl
CAmrBlockBuildArgs	Non-model inputs of a MULTI-block AMR build (the fields the build_multi visitor read off the BlockSpec)
CAmrLevelMF
CApplyLaplacianKernel
CAssembleRhsHllCachedKernel	AssembleRhsHllCachedKernel: kernel of the residual R = -div Fhat + S for the HLL flux with wave speeds PRE-COMPUTED per cell (scratch `ws`, 4 components)
CAssembleRhsKernel	AssembleRhsKernel<Limiter,NumericalFlux,Model>: device kernel of the central residual of assemble_rhs
CAssembleRhsMaskedKernel	AssembleRhsMaskedKernel: variant of AssembleRhsKernel AWARE of a domain mask
CAverageDownKernel	CONSERVATIVE average of an r x r block: C(I, J, c) = (sum of the r^2 fine cells) * inv
CAvgDownMultiKernel
CBackwardEulerSourceKernel
CBackwardEulerSourceStatKernel
CBCFaceXHiKernel
CBCFaceXLoKernel
CBCFaceYHiKernel
CBCFaceYLoKernel
CBlockBuildArgs	The non-model inputs of a Cartesian block build (a thin bundle so the seam signature stays fixed)
CBlockRhsEval	Residual functor -div F + S (fill_ghosts then assemble_rhs), passed TO THE TimeStepper as RhsEval
CBlockRhsEvalEb	CUT-CELL / EB transport residual (CutCell mode): fill_ghosts then assemble_rhs_eb on the level set of the System embedded boundary (read via `eb_domain`, pointer to Impl::eb_domain_, stable address)
CBlockRhsEvalMasked	MASKED transport residual (Staircase mode): fill_ghosts then assemble_rhs_masked on the cell-centered 0/1 mask of the System (read via `mask`, pointer to Impl::domain_mask_, stable address)
CBuiltBlock	Everything System::add_block reads back from the (former) dispatch_model visitor
CCopyBzKernel	Copies the B_z field (aux channel) into an internal scalar MultiFab (0 ghost is enough, read at (i,j))
CCopyComp0Kernel
CCopyShiftedKernel
CCutFraction	Geometric result of crossing a cut cell: 4 cut distances per face, the 4 apertures alpha_f normalized in [0, 1] (alpha_f = face_distance / h), and the volume fraction kappa of the cell (share of the cell in the active domain)
CDiscDomain	CIRCLE / DISC level-set domain: the canonical instance of the contract and the SINGLE SOURCE of truth for the active circular domain (a disc of radius R; see docs/HOFFART_FIDELITY.md for the reference scenario it was validated against)
CDiscLevelSet	Device-safe adapter wrapping a DiscDomain as the Real(Real, Real) callable expected by cut_fraction and the EB operator
CDivergenceKernel
CDotKernel
CEbAssembleRhsKernel	Kernel assembling the EB residual at cell (i, j): INACTIVE cell -> residual 0 (not advanced, like T2); ACTIVE cell -> R = S - (1/kappa_eff) [ (fx_{i+1} - fx_i)/dx + (fy_{j+1} - fy_i)/dy ] - wall_term
CEbFaceFluxXKernel	FACE FLUX kernel for x (dir 0) of the EB transport: numerical flux at the face between (i-1, j) and (i, j), WEIGHTED by the aperture alpha_x of that face
CEbFaceFluxYKernel	FACE FLUX kernel for y (dir 1) of the EB transport: analogue of EbFaceFluxXKernel in j
CExtractVelocityKernel	Extracts the velocity v = (mx, my) / rho from the state (Density / MomentumX / MomentumY roles) into two scalar fields vx, vy
CFaceFluxXKernel	FaceFluxXKernel: device kernel for the flux at the radial x face (between i-1 and i)
CFaceFluxYKernel	FaceFluxYKernel: device kernel for the flux at the y face (between j-1 and j)
CFieldPostprocessKernel
CForEachBlockProbe	NAMED no-op probe for the CoupledSystemLike concept. A generic lambda in the
CGsColorKernel
CHalfPlaneDomain	HALF-PLANE level-set domain: ls(x, y) = ax + by - c, ACTIVE on the side ax + by < c
CHotspotFn	Frozen residual (fill_ghosts + assemble_rhs) installed as the block's rhs_into
CInterpolateKernel	Piecewise-CONSTANT injection: F(i, j, c) receives the value of its covering coarse cell
CInvStabilityDtKernel	InvStabilityDtKernel: max over cells of 1/model.stability_dt
CLincombKernel
CMaxKernel
CMaxSourceFreq	Block max source frequency functor (HasSourceFrequency trait, bound dt <= cfl/mu without h)
CMaxSpeed	Block max wave speed functor (max_wave_speed_mf, reduction over the seam)
CMaxStabilitySpeed	Block max STABILITY speed functor (HasStabilitySpeed trait): replaces MaxSpeed in the CFL when the model declares stability_speed (the Riemann solvers keep max_wave_speed)
CMaxWaveSpeedKernel	MaxWaveSpeedKernel<Model>: device reduction functor for max_wave_speed_mf
CMinKernel
CMinStabilityDt	Block min admissible step functor (HasStabilityDt trait; 0 = no cell constrains it)
CNegateKernel	Neg(i,j) = -src(i,j) (negation of component 0). Device-clean NAMED functor
CNewtonStatMaxKernel	REDUCTION kernels of the diagnostics scratch (max / sum of one component)
CNewtonStatSumKernel
CNormInfKernel
CPackKernel
CPointwiseProject	Foncteur HOTE de la projection ponctuelle : for_each_cell du kernel sur les cellules VALIDES de chaque fab local
CPoissonResidualKernel
CPoissonRhs	Poisson contribution functor: rhs += elliptic_rhs(U) (pure HOST loop, no device kernel)
CPolarAdvanceExplicit	EXPLICIT polar advance: n substeps of the `Stepper` stepper (SSPRK2 by default, SSPRK3 optional) on the polar transport residual
CPolarApplyKernel	L_int(phi) = div(A grad phi) in polar (apply)
CPolarAssembleRhsKernel	PolarAssembleRhsKernel: device kernel of the polar residual in cell (i,j)
CPolarBlockRhsEval	Polar residual functor R = -div_polar F + S (fill_ghosts then assemble_rhs_polar)
CPolarCopyKernel	Copy component 0 (dst <- src)
CPolarFaceFluxRKernel
CPolarFaceFluxThetaKernel	PolarFaceFluxThetaKernel: device kernel of the flux at the azimuthal face j
CPolarInvDiagKernel	Computes idiag = 1 / diag of the diagonal polar stencil (for Jacobi). diag = polar_diag (< 0)
CPolarJacobiApplyKernel	Out = (f - L0 phi) / \|diag\| – one Jacobi iteration (point-by-point relaxation) on the DIAGONAL polar stencil (cross terms excluded from the Jacobi splitting: they stay on the right-hand side via the residual)
CPolarMaxSpeed	Max wave-speed functor of the POLAR block: reduction over the valid cells of max_wave_speed(model, U, aux) in both directions (r, theta)
CPolarPoissonRhs	POLAR Poisson contribution functor: rhs += elliptic_rhs(U) (pure HOST loop)
CPolarRhsInto	Frozen polar residual (fill_ghosts + assemble_rhs_polar) installed as the block's rhs_into (eval_rhs)
CPolarSchurCopyComp0Kernel	Dst <- src (component 0)
CPolarSchurExplicitFluxKernel	EXPLICIT flux F = rho B^{-1} v^n = B^{-1}(mr, mtheta) at the center (physical components (e_r, e_theta))
CPolarSchurOperatorCoeffKernel	POLAR condensed tensor coefficients A = I + c rho B^{-1} at cell centers
CPolarSchurReconstructKernel	Reconstructs v^{n+theta} = B^{-1}(v^n - theta dt grad_polar phi^{n+theta}) and writes mom = rho^n v^{n+theta}
CPolarSchurRhsAssembleKernel	Rhs_polar(i,j) = lap_polar(i,j) (= Lap_polar phi^n) + g * div_polar F, second-order centered POLAR divergence of a vector field F = (F_r, F_theta) at the center (ghosts filled)
CPolarSourceFreq
CPolarStabilityDt
CPolarStabilitySpeed	Optional STEP BOUND closures of the POLAR block (StabilityPolicy, audit wave 3): same device reductions as the cartesian ones (POINTWISE kernels with no geometry assumption – the geometry enters only through the physical step h of the stepper, min(dr, r_min*dtheta))
CProjectCellKernel	Kernel device de la PROJECTION PONCTUELLE post-pas (ADC-177) : U(i, j) <- m.project(U(i, j), aux(i, j))
CRhsInto
CRusanovFaceXKernel	Rusanov flux at the left face (x axis) of cell (i,j)
CRusanovFaceYKernel	Rusanov flux at the bottom face (y axis) of cell (i,j)
CSaxpyKernel
CSchurEnergyKernel	Energy update: E^{n+1} = E^n + (1/2) rho^n (\|v^{n+1}\|^2 - \|v^n\|^2)
CSchurExplicitFluxKernel	EXPLICIT flux F = rho B^{-1} v^n (v = (mx,my)/rho) ASSEMBLED per cell, WRITTEN at the center into fx/fy
CSchurExtrapolateScalarKernel	Linear extrapolation of a SCALAR field from the theta-stage to the full step: f^{n+1} = f^n + (1/theta) (f^{n+theta} - f^n)
CSchurExtrapolateVelocityKernel	Linear extrapolation of the VELOCITY (vx, vy) from the theta-stage to the full step, then recompose mom = rho^n v^{n+1} into the state
CSchurOperatorCoeffKernel	Coefficients of the tensor operator A_op = I + c rho B^{-1} ASSEMBLED per cell from the fluid state and the B_z field
CSchurReconstructKernel	Reconstructs v^{n+theta} = B^{-1}(v^n - theta dt grad phi^{n+theta}) and writes mom = rho^n v^{n+theta} into the state
CSchurRhsAssembleKernel	Rhs(i,j) = lap(i,j) (= -Lap phi^n, already negated by the caller) - g * div F, second-order centered divergence of a flux F at the center (fx, fy, ghosts filled)
CScopedBlockState
CSharedAmrLayout	SHARED layout of a multi-block AMR hierarchy (PR1 capstone), frozen at construction
CShortleyWellerWeights	Shortley-Weller weights (5-point cut-cell stencil) from the 4 cut distances
CSingleModelEllipticRhsKernel	NAMED functor (not an POPS_HD lambda) of the single-model RHS: f(i,j,0) = model.elliptic_rhs(U)
CSourceFrequencyKernel	SourceFrequencyKernel: max over cells of model.source_frequency (mu >= 0, 1/s)
CSourceInto	SOURCE-ONLY residual R <- S(U, aux) installed as the block's source_only closure (ADC-430)
CSourceOnlyKernel	SOURCE-ONLY residual kernel R(i,j) <- m.source(U(i,j), aux(i,j)): the EXACT source term of AssembleRhsKernel (cf
CStabilitySpeedKernel	StabilitySpeedKernel: max over cells/directions of model.stability_speed (replaces MaxWaveSpeedKernel when the trait is declared)
CSumKernel
CTwoFieldChargeDensityRhsKernel	NAMED functor (not an POPS_HD lambda) of the two-field RHS: r(i,j,0) = a0 u0 + a1 u1
CUnpackKernel
CWaveSpeedCacheKernel	WaveSpeedCacheKernel: evaluates model.wave_speeds per cell in both directions and stores (lo_x, hi_x, lo_y, hi_y) in a 4-component scratch
CWaveSpeedMatchKernel	Locates the cell DOMINATING the CFL (dt_hotspot diagnostic, ADC-182): EQUALITY scan of the recomputed w – same functor and same data as MaxWaveSpeedKernel, hence bit-equal to the max returned by max_wave_speed_mf – which encodes the GLOBAL index jnx + i as Real (exact as long as nxny < 2^53) and reduces to the MIN (first cell in lexicographic order: deterministic)
CZeroConductorKernel
►Nfield_solver
►CSystemFieldSolver	SystemFieldSolver<Impl>: see contract above
CNamedField
►Nnative_loader
CBlockMeta	OPTIONAL metadata read by dlsym on a generated .so (names / roles / gamma)
►Nruntime
►Nprogram
►Ndetail
CSchurEnergyKernelC	Condensed-Schur kinetic-energy increment (ADC-427), mirroring the native detail::SchurEnergyKernel: E^{n+1} = E^n + (1/2) rho (\|v^{n+1}\|^2 - \|v^n\|^2), v = (mx, my)/rho
CSchurExplicitFluxKernelC	Out = B^{-1} (mx, my) at the center (Fx in comp 0, Fy in comp 1): the explicit flux F = rhoB^{-1}v
CSchurOperatorCoeffKernelC	Aux-component-aware variants of the native Schur kernels (coupling/schur/core/schur_condensation.hpp
CSchurReconstructKernelC	Reconstruct v^{n+theta} = B^{-1}(v^n - thetadtgrad phi) and write mom = rho^n*v (rho frozen)
CSchurRhsAssembleKernelC	Rhs = -Lap phi^n - g*div(F), the centered FV divergence of the explicit flux F packed in ONE 2-component buffer (Fx in comp 0, Fy in comp 1 – the layout schur_explicit_flux writes), fused with the already-negated -Lap phi^n
CBrickManifestEntry
CBrickRegistry
CCacheManager
CCacheSlot
CExternalBrickHandle
CModuleMetadata	The GeneratedModule descriptor read from a problem.so
COperatorMetadata	One operator's metadata, as exported by the .so
►CProfiler
CEntry
CProfileScope
CProgramContext
►Nstepper
CSystemStepper	SystemStepper<Impl>: see the contract above
►Nvalidation
CAdvectionDiffusion	Scalar advection-diffusion: d_t u + a
CLangmuirMode	Linearized Langmuir mode: 0D kernel of the asymptotic-preserving two-fluid scheme
CTwoFluidLinear	Isothermal two-fluid electrostatic, linear mode (single Fourier k)
CAmrAdvanceFacesKernel	Device-clean NAMED functor: U <- U - dt div(Fx,Fy) on a valid cell
CAmrApplySourceKernel	Device-clean NAMED functor (template Model, see AmrSspRhsKernel): U <- U + dt S(U, aux) on a valid cell
CAmrAverageDownKernel	Device-clean NAMED functor: 2x2 average fine -> coarse on a coarse cell
CAmrBuildParams	Frozen parameters passed to the deferred build of the compiled path (add_compiled_model)
CAmrCompiledHooks	Type-erased closures of a compiled AMR block, produced by amr_dsl_block::build_amr_compiled and installed via AmrSystem::set_compiled_block
CAmrCondensedSchurSourceStepper	Schur-condensed SOURCE stage over an AMR hierarchy
CAmrCouplerMP	Multi-patch E x B AMR coupler
CAmrDiscLF	Bundle (limiter, Riemann flux) expected by AmrCouplerMP::step<Disc>
CAmrHierarchy	Stack of refined levels (domain + BoxArray + MultiFab per level), level 0 the coarsest
CAmrHierarchyLayout	Single source of truth on the GRID shared by all blocks: per level the BoxArray (boxes AND order), the DistributionMapping (rank per box) and dx/dy
CAmrImplicitSourceStepper	Default implicit callback for AmrSystemCoupler::step: backward-Euler (Newton) on the model source, applied to EACH level of the hierarchy, followed by a fine -> coarse cascade (coverage consistency, cf
CAmrLevelMP
CAmrLevelStack	Owns the AMR level stack and the parallel aux stack
CAmrRuntime	AMR multi-block engine at runtime
CAmrRuntimeBlock	Type-erased closures of ONE AMR block, placed on the shared hierarchy
CAmrSspRhsKernel
►CAmrSystem	Single block carried on an AMR hierarchy, composed at runtime
CSourceNewtonReport	Report of the implicit (IMEX) source Newton of a block, AGGREGATED over the levels and substeps of the block's LAST advance
CAmrSystemConfig	AMR mesh and cadence (per-block physical parameters live in the ModelSpec)
CAmrSystemCoupler	Multi-species system coupler on AMR
CArenaStats	ManagedArena pool statistics: hits/misses/fences and retained bytes
CArray4	WRITE POD handle (raw pointer + strides) over a Fab2D buffer, indexed by (i, j, c) IN GLOBAL INDICES (ig0/jg0 = lower corner of the grown box)
CAux	POINTWISE auxiliary fields shared with the physics: single coupling channel
CAuxHaloPolicy	Per-field aux halo policy (ADC-369): a UNIFORM boundary policy for ONE model-named aux component, declared via pops.AuxHalo
CBackgroundDensity	Neutralizing background f = alpha (n - n0)
CBCRec	Boundary conditions for the FOUR faces of the domain (type + associated Dirichlet value)
CBlockClosures	Compiled block closures, frozen at add time
CBox2D	2D integer index space, cell-centered
CBoxArray	Ordered list of boxes tiling a level
CBoxHash	Spatial index of a BoxArray's boxes via a bin grid
CChargeDensity	Charge density f = q n
CChargeDensityRhs	N-species Poisson RHS: f = Sum_s q_s n_s over ALL blocks of the system
CClusterParams	Berger-Rigoutsos clustering parameters (configuration object)
CCoarseFineInterface
CCompositeFacPoisson	2-level COMPOSITE FAC Poisson solver (scalar)
CCompositeModel	Composite physical model: one HYPERBOLIC brick + one source + one elliptic right-hand side
CCompositeSource	SUM of two source bricks: S(U, aux) = A.apply(U, aux) + B.apply(U, aux)
CCondensedSchurSourceStepper	Schur-condensed SOURCE STAGE, STANDALONE (transport frozen), GENERIC over any fluid block that exposes the Density / MomentumX / MomentumY roles (+ optional Energy)
CConstArray4	READ-only handle (const counterpart of Array4): same layout and same contract (POD device-copyable, global indices, no bounds checking)
CCoupledFreqKernel
CCoupledSourceKernel	Device functor applying ONE coupled source over a box: captures the PODs by VALUE (input/output Array4, programs, constants) -> device-clean
CCoupledSourceProgram	BYTECODE description of a generic inter-species COUPLED SOURCE (cf
CCoupledSystem	Heterogeneous collection of equation blocks, parameterized by their exact types
CCoupler	Single-block hyperbolic-elliptic coupler
CCoverageMask
CCsProgram	Fixed-capacity postfix program (POD device-copyable): len opcodes, arg read only by PushReg (register index)
CDistributedFFTSolver	DIRECT periodic Poisson solver (spectral FFT) DISTRIBUTED, models EllipticSolver
CDistributionMapping	Owning MPI rank of each box, indexed by GLOBAL box index (parallel to a BoxArray)
CEigBounds	Result of real_eig_minmax: real-part extremes + diagnostic
CElectrostaticLorentzCondensation	GENERIC builder of the condensed source stage for the electrostatic + Lorentz source (kind="electrostatic_lorentz" on the future Python facade side, PR5)
CEllipticProblem
CEllipticTag	Builtin ELLIPTIC right-hand-side brick tag
CEquationBlock	Association of a PhysicalModel with its field U (MultiFab), its spatial scheme, its time policy and its boundary conditions
CEuler	2D compressible Euler for an ideal gas: HYPERBOLIC brick (HyperbolicModel concept)
CExBVelocity	Scalar advection by the E x B drift: v = (-d_y phi, d_x phi)/B0 (divergence-free)
CExBVelocityPolar	Scalar advection by the E x B drift in POLAR coordinates (r, theta) – "annular polar grid" effort, Phase 1
CFab2D	Single-grid data on a Box2D: VALID box + ng ghost layers, ncomp components, component-slow layout
CFieldPostProcess
CFluxRegister
►CForwardEuler
CScratch
CGeometricMG
CGeometry	Cartesian geometry of a level: index domain + physical bounds [xlo, xhi] x [ylo, yhi]
CGravityCoupling	Self-consistent coupling f = sign * 4piG * (rho - rho0)
CGravityForce	Gravitational force rho g (+ work if 4 variables)
CGridContext	Mesh + transport BC + aux shared by a block closures
CHaloExchange	Opaque state of an in-flight halo exchange, returned by fill_boundary_begin and consumed by fill_boundary_end
CHaloJob	One halo copy/transfer: the ghost `region` of box `dst` is filled from the shifted valid region of box `src` (shift sx, sy in cells for the periodic wrap; 0 for an interior neighbor)
CHaloSchedule	Memoized schedule for ONE (Periodicity, domain) over a fixed layout
CHaloScheduleCache	Small per-MultiFab cache of halo schedules, one entry per distinct (Periodicity, domain)
CHLLCFlux	HLLCFlux (HLL + Contact wave, Toro): 3 waves, resolves the contact discontinuity
CHLLFlux	HLLFlux (Harten-Lax-van Leer): 2 signal speeds, less diffusive than Rusanov
CIModel	Hyperbolic model seen behind a virtual interface (runtime dispatch)
CImplicitMask
CImplicitSourceStepper
CIsothermalFlux	ISOTHERMAL Euler flux (p = cs2 rho), 3 variables (rho, rho u, rho v)
CIsothermalFluxPolar	ISOTHERMAL Euler flux in POLAR geometry (ring r, theta), 3 variables (rho, rho v_r, rho v_theta) – "polar fluid grid" effort, Path A step 1
CKrylovResult	Outcome of a Krylov solve: iterations performed, final relative residual, convergence flag
CLevelHierarchy
CLimiterTag	Tag of a reconstruction LIMITER: user-facing name + halo width (n_ghost) required by its stencil
CLorentzEliminator	LorentzEliminator: operator B = [[1,-w],[w,1]] and its analytic inverse
CMagneticLorentzForce	MAGNETIC Lorentz force q (v x B) on momentum, field B = B_z z_hat out of plane
CMinmod	Minmod limiter: TVD (Total Variation Diminishing), 2 ghosts, order 2 in smooth regions
CModelAdapter	Adapts a STATIC model M into IModel<M::n_vars>
CModelSpec	Brick composition of a block plus parameters
CModuleCapabilities	The STATIC transport capabilities the built _pops module provides (Spec 5 sec.13.12)
CMultiFab	Field distributed over a level: decomposition (BoxArray) + distribution (DistributionMapping) + ncomp components + ngrow ghosts
CNewtonCellStat	OUTPUT statistic of the Newton of ONE cell (device POD, written into the diagnostics scratch): res = \|\|F\|\|_inf at exit; iters = iterations consumed; failed = 1 if the cell failed (non-finite residual, degenerate/non-finite pivot, or active tolerance not reached within budget), 0 otherwise; comp = index of the conserved COMPONENT carrying the max residual at exit (-1 if nothing implicit)
CNewtonOptions	Options of the local Newton of the implicit source (backward-Euler)
CNewtonReport	AGGREGATED report (whole block, all substeps of one advance) of the implicit-source Newton
CNoCoupledSource	NULL coupling source (default): apply() is a no-op
CNoSlope	First-order reconstruction (piecewise constant): zero slope, 1 ghost
CNoSource	No source: S(U, aux) = 0
COncePerStepCoupling	Tag: solves the elliptic problem ONCE per step (aux frozen during the stages, cheaper)
CPatchBox	INDEX-SPACE footprint of an AMR fine patch, exposed to Python by AmrSystem::patch_boxes()
CPatchRange
CPeriodicity	Per-direction periodicity: halo wrapping in x and/or y during the exchange (false = open edge, left to the physical BCs)
CPerStageCoupling	Tag: solves the elliptic problem at EVERY RK stage (aux follows the intermediate state, more precise)
CPoissonFFT
CPoissonFFTSolver
CPolarCondensedSchurSourceStepper	SOURCE STAGE condensed by Schur in POLAR geometry, STANDALONE (transport frozen), GENERIC over any polar fluid block that exposes the roles Density / MomentumX (radial) / MomentumY (azimuthal) (+ optional Energy)
CPolarGeometry
CPolarGridContext	POLAR mesh + transport BC + aux shared by a block's closures (counterpart of GridContext)
CPolarKrylovResult	Result of a polar BiCGStab solve: iterations, relative residual, convergence
CPolarPoissonSolver
CPolarTensorKrylovSolver	MATRIX-FREE BiCGStab Krylov solver for the FULL-tensor POLAR elliptic operator L_int(phi) = div(A grad phi), A = [[a_rr, a_rt], [a_tr, a_tt]] possibly NON symmetric
CPotentialForce	Electrostatic potential force (q/m) rho E on momentum (+ work on energy if 4 variables)
CRegMP
CRegridParams	Regrid parameters (configuration object)
CRemappedFFTSolver	DIRECT periodic Poisson solver (spectral FFT) under MPI, presenting the SYSTEM LAYOUT, models EllipticSolver (ADC-287)
CRiemannTag	Tag of a Riemann FLUX: name + model CAPABILITY needs (DOCUMENTARY: the real guard is an `if constexpr` per model at the call-site – these flags do NOT drive the dispatch, they document the contract and serve the tests)
CRoeFlux	RoeFlux: Roe linearization + Harten entropy fix (acoustic waves)
CRuntimeParams	FLAT carrier (fixed size, by value) of the runtime parameter values of a block
CRusanovFlux	RusanovFlux (local Lax-Friedrichs): robust flux, compatible with any minimal PhysicalModel
CSchurCondensationOperator	Result of the Schur assembly: the coefficient MultiFab of the tensor operator A_op and the condensed right-hand side
CSingleModelEllipticRhs	SINGLE-model RHS assembler: rhs(.,.,0) = model.elliptic_rhs(U) over the valid cells
CSourceFreeModel	SourceFreeModel<M>: adapter that cancels the source of M (explicit IMEX half-step)
CSourceStageOptions	Settings of the Schur-condensed SOURCE STAGE (cf
CSourceTag	Builtin SOURCE brick tag
CSpatialDiscretisation	SpatialDiscretisation<LimiterT, NumericalFluxT>: tag-type bundling the reconstruction policy and the numerical flux policy into a single template parameter
CSpeciesCharge	Charge (with sign) and density component of a species for the elliptic RHS assembly
CSSPRK2
►CSSPRK2Step
CScratch
CSSPRK3
►CSSPRK3Step
CScratch
CStateVec	Conserved state vector of fixed size, known at compile time
CSubcyclingSchedule
►CSystem	Coupled multi-species system, composed at runtime from generic bricks
CSourceNewtonReport	Report of the implicit source Newton (IMEX) of a block, AGGREGATED over the substeps of the LAST advance of the block
CSystemAssembler	ASSEMBLES the fields (system Poisson + shared aux) and a block residual evaluator
►CSystemBlockStore	ORDERED registry of the System blocks + state marshaling helpers
CBlockState	Compiled closures frozen at block add time (composite model + spatial scheme + time)
CSystemConfig	Mesh and domain shared by all blocks (physical parameters are per block, in the ModelSpec)
CSystemDriver	ADVANCES the system: carries the schedule (per-species subcycling, adaptive multirate, implicit/IMEX delegated) and calls a TimeStepper
CTagBox	Dense grid of 0/1 markers over a box, input to Berger-Rigoutsos clustering
CTensorKrylovSolver
CTimePolicy
CTimePolicyTraits
CTimePolicyTraits< TimePolicy< MethodT, TreatmentT, SubstepsT, StrideT > >
CTransportTag	Builtin TRANSPORT brick tag
CTwoBlockChargeDensityRhs	Two-block RHS: same computation as TwoFieldChargeDensityRhs but reads blocks 0 and 1 of a CoupledSystem (q0 n0 + q1 n1)
CTwoFieldChargeDensityRhs	Two-field RHS: rhs = q0 * U0(.,.,comp0) + q1 * U1(.,.,comp1) (two-species charge density)
CUserTimeIntegrator
CVanLeer	Van Leer limiter: smooth, 2 ghosts, better order at extrema than Minmod
CVariable	A variable: name, physical role, component index in the state
CVariableSet	A model's variable set: kind (cons/prim), names, size, canonical `roles` (optional, parallel to `names`; absent -> Custom), and `user_roles` (optional string labels parallel to `names`, for components whose role is OUTSIDE the canonical enum)
CWeno5	WENO5 tag policy: marks the stencil at 3 ghosts, delegates to weno5z

Class List¶