Struct AmrGrid 

pub struct AmrGrid {
    pub root: AmrCell,
    pub domain: Domain,
    pub refinement_threshold: f64,
    pub gradient_threshold: f64,
    pub max_level: usize,
    pub velocity_removal_threshold: f64,
    pub active_block_count: usize,
}

Adaptive mesh refinement grid in 6D phase space.

The root cell spans the full domain. Cells are refined where the distribution function is significant and coarsened when values become uniform. Implements PhaseSpaceRepr by depositing leaf values onto a uniform spatial grid.

Fields

root: AmrCell

Root cell of the tree, spanning the entire 6D domain.

domain: Domain

The simulation domain (spatial/velocity extents, resolutions, BCs).

refinement_threshold: f64

Cells with |f| > refinement_threshold are subdivided.

gradient_threshold: f64

Gradient-based refinement threshold (reserved for future use).

max_level: usize

Maximum refinement level (0 = root only).

velocity_removal_threshold: f64

Velocity block removal threshold: blocks with max(|f|) < this are deallocated. Set to 0 to disable sparse velocity cleanup. Default: 1e-14.

active_block_count: usize

Current active block count (leaves with non-negligible f).

Implementations

impl AmrGrid

pub fn new(domain: Domain, refinement_threshold: f64, max_levels: usize) -> Self

Create a new AmrGrid with a single root cell spanning the full 6D domain.

• refinement_threshold: cells with |f| above this are subdivided.
• max_levels: maximum tree depth (0 = root only, no refinement).

pub fn refine(&mut self)

Refine cells where |f| exceeds the refinement threshold, up to max_level.

pub fn coarsen(&mut self)

Merge children back into parent when their values are nearly uniform (spread < threshold / 10).

pub fn cleanup_sparse_velocity(&mut self)

Remove velocity-space blocks where max(|f|) < velocity_removal_threshold.

Walks the tree and coarsens leaf cells in velocity dimensions whose values are below the threshold. This reduces memory for cold/warm distributions where most of velocity space is empty.

pub fn leaf_count(&self) -> usize

Number of leaf cells currently in the tree.

Trait Implementations

impl PhaseSpaceRepr for AmrGrid

fn compute_density(&self) -> DensityField

Compute density rho(x) = integral of f dv^3 by accumulating leaf cell contributions onto the spatial grid.

fn advect_x(&mut self, _displacement: &DisplacementField, dt: f64)

Drift sub-step: shift leaf cell centers in spatial coordinates by v * dt. The velocity coordinates (center[3..6]) of each leaf encode its velocity, so the spatial drift is center[0..3] += center[3..6] * dt.

fn advect_v(&mut self, acceleration: &AccelerationField, dt: f64)

Kick sub-step: shift leaf cell centers in velocity coordinates by a(x) * dt. The acceleration is interpolated from the AccelerationField at the leaf’s spatial position.

fn moment(&self, position: &[f64; 3], order: usize) -> Tensor

Compute velocity moment of order n at the given spatial position. Sums over leaf cells whose spatial center is in the same grid cell.

fn total_mass(&self) -> f64

Total mass M = integral of f dx^3 dv^3 = sum over leaves of f * cell_volume_6D.

fn casimir_c2(&self) -> f64

Casimir invariant C2 = integral of f^2 dx^3 dv^3.

fn entropy(&self) -> f64

Boltzmann entropy S = -integral of f ln(f) dx^3 dv^3.

fn stream_count(&self) -> StreamCountField

Count distinct velocity streams at each spatial position. For each spatial grid cell, count the number of leaf cells that overlap it with significant value (indicating separate velocity-space populations).

fn velocity_distribution(&self, position: &[f64; 3]) -> Vec<f64>

Extract the velocity distribution f(v | x) at a given spatial position. Returns the values of f from all leaf cells whose spatial center maps to the same grid cell as the query position.

fn total_kinetic_energy(&self) -> Option<f64>

Total kinetic energy T = (1/2) integral of f * v^2 dx^3 dv^3.

fn to_snapshot(&self, time: f64) -> Option<PhaseSpaceSnapshot>

Extract a full 6D snapshot by depositing leaf values onto a uniform grid.

fn as_any(&self) -> &dyn Any

Downcast to concrete type for implementation-specific queries (e.g. HT rank data).

fn as_any_mut(&mut self) -> &mut dyn Any

Mutable downcast for in-place modification (e.g. BUG integrator leaf updates). Returns self as &mut dyn Any. Only HtTensor overrides this; the default returns self but concrete downcasts will yield None.

fn load_snapshot( &mut self, snap: PhaseSpaceSnapshot, ) -> Result<(), CausticError>

Replace the current state with data from a dense 6D snapshot.

fn can_materialize(&self) -> bool

Whether full 6D materialization fits in available memory. Default: true. Compressed representations (HT, TT) should override to check shape vs a memory threshold.

fn memory_bytes(&self) -> usize

Approximate memory usage of this representation in bytes. Default returns 0; implementations should override for accurate tracking.

fn set_progress(&mut self, _progress: Arc<StepProgress>)

Attach shared progress state for intra-phase cell-level reporting. Implementations can use this to report progress via StepProgress::set_intra_progress.