Struct SheetTracker 

pub struct SheetTracker {
    pub particles: Vec<SheetParticle>,
    pub shape: [usize; 3],
    pub domain: Domain,
    pub stream_threshold: f64,
    pub particle_mass: f64,
}

Lagrangian cold dark matter sheet tracker.

Stores N³ particles on a Lagrangian grid. Each particle tracks its initial coordinate q, current position x, and velocity v. The distribution function is a sum of delta functions — a cold (zero-entropy) system.

Fields

particles: Vec<SheetParticle>

shape: [usize; 3]

domain: Domain

stream_threshold: f64

particle_mass: f64

Implementations

impl SheetTracker

pub fn new(domain: Domain) -> Self

Create a new sheet tracker with N³ particles at spatial cell centers, v = 0.

Domain spans [−L_k, L_k] in each dimension. Particles are placed at x_k = −L_k + (i_k + 0.5) * dx_k, with q = x (identity mapping).

pub fn from_zeldovich(ic: &ZeldovichIC, domain: &Domain) -> Self

Place one particle at each Lagrangian grid point, displaced by s(q).

Uses ZeldovichIC::displacement_field() and velocity_field() to set x = q + s(q), v = v₀(q).

pub fn detect_caustics(&self) -> StreamCountField

Detect stream crossings by counting the number of particles per spatial cell.

In a single-stream region each cell contains at most one particle. When the sheet folds (caustic formation), multiple Lagrangian elements map to the same Eulerian cell, so the count exceeds 1.

pub fn interpolate_density(&self, domain: &Domain) -> DensityField

Cloud-in-Cell (CIC) density deposition from particle positions.

Each particle of mass particle_mass at position x is distributed to the 8 surrounding grid nodes using trilinear weights. The result is divided by cell volume to give density ρ(x).

Trait Implementations

impl PhaseSpaceRepr for SheetTracker

fn compute_density(&self) -> DensityField

Integrate f over all velocities: ρ(x) = ∫f dv³. This is the coupling moment to the Poisson equation.

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

Drift sub-step: advect f in spatial coordinates by displacement Δx = v·dt. Pure translation in x at constant v.

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

Kick sub-step: advect f in velocity coordinates by Δv = g·dt. Pure translation in v at constant x.

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

Compute velocity moment of order n at given spatial position. Order 0 = density, 1 = mean velocity, 2 = dispersion tensor.

fn total_mass(&self) -> f64

Total mass M = ∫f dx³dv³. Should be conserved to machine precision.

fn casimir_c2(&self) -> f64

Casimir invariant C₂ = ∫f² dx³dv³. Increase over time indicates numerical diffusion.

fn entropy(&self) -> f64

Boltzmann entropy S = −∫f ln f dx³dv³. Should be exactly conserved; growth = numerical error.

fn total_kinetic_energy(&self) -> f64

Total kinetic energy T = ½∫fv² dx³dv³.

fn stream_count(&self) -> StreamCountField

Number of distinct velocity streams at each spatial point. Detects caustic surfaces (sheet folds).

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

Extract the local velocity distribution f(v|x) at a given spatial position. Used for dark matter detection predictions.

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

Extract a full 6D snapshot of the current state.

fn as_any(&self) -> &dyn Any

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

fn load_snapshot(&mut self, snap: PhaseSpaceSnapshot)

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