Struct SimulationGrid 

pub struct SimulationGrid {
    pub width: u32,
    pub height: u32,
    pub params: AcousticParams,
    /* private fields */
}

The main simulation grid containing all cells.

Uses SoA (Structure of Arrays) memory layout for cache-friendly sequential access and SIMD compatibility. Pressure arrays are double-buffered for in-place FDTD time-stepping.

Fields

width: u32

Grid width (number of columns).

height: u32

Grid height (number of rows).

params: AcousticParams

Acoustic simulation parameters.

Implementations

impl SimulationGrid

pub fn new(width: u32, height: u32, params: AcousticParams) -> Self

Create a new simulation grid.

Arguments

• width - Number of columns
• height - Number of rows
• params - Acoustic simulation parameters

pub fn step(&mut self)

Perform one simulation step using FDTD scheme.

Uses the 2D wave equation: ∂²p/∂t² = c²∇²p

Discretized as: p[n+1] = 2p[n] - p[n-1] + c²(p_N + p_S + p_E + p_W - 4*p)

pub fn inject_impulse(&mut self, x: u32, y: u32, amplitude: f32)

Inject an impulse at the given grid position.

pub fn get_pressure_grid(&self) -> Vec<Vec<f32>>

Get the pressure grid as a 2D vector for visualization.

Returns a Vec of rows, where each row is a Vec of pressure values.

pub fn pressure_slice(&self) -> &[f32]

Get the pressure buffer as a flat slice (row-major order).

This is more efficient than get_pressure_grid() for bulk operations.

pub fn max_pressure(&self) -> f32

Get the maximum absolute pressure in the grid.

pub fn total_energy(&self) -> f32

Get total energy in the system (sum of squared pressures).

pub fn reset(&mut self)

Reset all cells to initial state.

pub fn resize(&mut self, new_width: u32, new_height: u32)

Resize the grid.

pub fn set_params(&mut self, params: AcousticParams)

Update acoustic parameters.

pub fn set_speed_of_sound(&mut self, speed: f32)

Update speed of sound.

pub fn set_cell_size(&mut self, size: f32)

Update cell size in meters.

pub fn cell_count(&self) -> usize

Get the number of cells in the grid.

pub fn get_pressure(&self, x: u32, y: u32) -> Option<f32>

Get pressure at a specific cell (for compatibility with old API).

pub fn is_boundary(&self, x: u32, y: u32) -> bool

Check if a cell is a boundary.

pub fn set_cell_type(&mut self, x: u32, y: u32, cell_type: CellType)

Set the cell type at the given position.

This affects how the cell interacts with waves:

• Normal: waves propagate freely
• Absorber: waves are absorbed (0% reflection)
• Reflector: waves are reflected (100% reflection)

pub fn get_cell_type(&self, x: u32, y: u32) -> Option<CellType>

Get the cell type at the given position.

pub fn cell_types_slice(&self) -> &[CellType]

Get all cell types as a flat slice (row-major order).

pub fn clear_cell_types(&mut self)

Clear all user-defined cell types (reset to Normal).

This keeps the grid boundaries intact.

pub fn get_buffers_mut( &mut self, ) -> (&mut Vec<f32>, &mut Vec<f32>, usize, usize, f32, f32)

Get mutable access to pressure buffers for educational mode processing.

Returns (pressure, pressure_prev, width, height, c2, damping)

pub fn swap_buffers(&mut self)

Swap the pressure buffers (called when educational step completes).