Struct ZeldovichIC 

pub struct ZeldovichIC {
    pub mean_density: Decimal,
    pub h0: Decimal,
    pub omega_m: Decimal,
    pub omega_lambda: Decimal,
    pub scale_factor_init: Decimal,
    pub random_seed: u64,
    /* private fields */
}

Multi-mode Zel’dovich pancake IC: cold dark matter sheet with random perturbations.

The exact distribution is f(x,v,t_0) = rho_bar * delta^3(v - v_0(x)) where v_0 is the Zel’dovich velocity field derived from a Harrison-Zel’dovich-like power spectrum. On a grid this is represented as a thin Gaussian in velocity centred on v_0(x).

Fields

mean_density: Decimal

Mean comoving matter density rho_bar.

h0: Decimal

Hubble constant H_0 in km/s/Mpc.

omega_m: Decimal

Present-day matter density parameter Omega_m.

omega_lambda: Decimal

Present-day dark energy density parameter Omega_Lambda.

scale_factor_init: Decimal

Initial cosmological scale factor a(t_init).

random_seed: u64

RNG seed for Fourier-space Gaussian random field generation.

Implementations

impl ZeldovichIC

pub fn new(mean_density: f64, cosmology: CosmologyParams, seed: u64) -> Self

Create from f64 parameters via CosmologyParams (backward-compatible).

pub fn new_decimal( mean_density: Decimal, h0: Decimal, omega_m: Decimal, omega_lambda: Decimal, scale_factor_init: Decimal, seed: u64, ) -> Self

Create from Decimal parameters for exact config round-tripping.

Caches f64 conversions internally for hot-path computation.

pub fn new_single_mode( mean_density: f64, amplitude: f64, wavenumber: f64, sigma_v: f64, ) -> ZeldovichSingleMode

Create a simple single-mode Zel’dovich pancake for testing.

v₀(x) = -A·sin(k·x₁) f(x,v) = (ρ̄/S) · exp(-(v - v₀(x))² / (2σ_v²))

where S normalises the Gaussian to unity over velocity space.

pub fn displacement_field(&self, domain: &Domain) -> [Vec<f64>; 3]

Generate the Zel’dovich displacement field s(q) from P(k) via FFT.

Uses Xorshift64 RNG with Box-Muller transform for Gaussian random field generation in Fourier space, then IFFT to real space.

pub fn velocity_field(&self, domain: &Domain) -> [Vec<f64>; 3]

Zel’dovich velocity v₀(q) = a·H(a)·f(a)·s(q) (growing mode).

f(a) ≈ Ω_m(a)^{0.55} is the logarithmic growth rate.

pub fn sample_on_grid( &self, domain: &Domain, progress: Option<&StepProgress>, ) -> PhaseSpaceSnapshot

Sample onto 6D grid as a thin Gaussian in velocity centred on v₀(x).

f(x,v) = ρ̄ / ((2π)^{3/2} σ_v³) · exp(-|v - v₀(x)|² / (2σ_v²)) where σ_v = 0.3 · max(Δv) keeps the distribution cold but resolved.