med64 0.0.2

Headless MED64 electrophysiology toolkit: .modat I/O, spike/burst analysis, assays, spike-rate maps, and CSV/HTML/SVG/HDF5 export
Documentation
//! Current-source density (CSD).

use serde::{Deserialize, Serialize};

use crate::error::{Med64Error, Result};
use crate::recording::Recording;
use std::path::Path;

#[derive(Debug, Clone)]
pub struct CsdOptions {
    pub max_blocks: Option<usize>,
    pub grid_cols: usize,
    pub grid_rows: usize,
    pub electrode_pitch_um: f64,
    /// Time index (sample) to snapshot; None = mid-block average.
    pub sample_index: Option<usize>,
}

impl Default for CsdOptions {
    fn default() -> Self {
        Self {
            max_blocks: Some(5),
            grid_cols: 8,
            grid_rows: 8,
            electrode_pitch_um: 150.0,
            sample_index: None,
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CsdCell {
    pub channel: usize,
    pub row: usize,
    pub col: usize,
    pub potential_mv: f64,
    pub csd: f64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CsdReport {
    pub path: std::path::PathBuf,
    pub cells: Vec<CsdCell>,
}

/// 2-D discrete Laplacian CSD on the electrode grid (second spatial derivative).
pub fn compute_csd(path: impl AsRef<Path>, options: &CsdOptions) -> Result<CsdReport> {
    let path = path.as_ref();
    let mut rec = Recording::open(path)?;
    let header = rec.header().clone();
    let block = rec.blocks().next().ok_or_else(|| Med64Error::InvalidHeader {
        path: path.to_path_buf(),
        message: "no data blocks".into(),
    })??;
    let idx = options
        .sample_index
        .unwrap_or(block.samples.len() / 2)
        .min(block.samples.len().saturating_sub(1));

    let n = options.grid_rows * options.grid_cols;
    let mut potential = vec![0.0_f64; n];
    for (col, &ch) in block.channel_indices.iter().enumerate() {
        if ch < n {
            potential[ch] = header.counts_to_millivolts(block.samples[idx][col]);
        }
    }

    let h = options.electrode_pitch_um / 1000.0; // mm
    let mut cells = Vec::with_capacity(n);
    for ch in 0..n {
        let row = ch / options.grid_cols;
        let col = ch % options.grid_cols;
        let v = potential[ch];
        let left = if col > 0 { potential[ch - 1] } else { v };
        let right = if col + 1 < options.grid_cols { potential[ch + 1] } else { v };
        let up = if row > 0 { potential[ch - options.grid_cols] } else { v };
        let down = if row + 1 < options.grid_rows { potential[ch + options.grid_cols] } else { v };
        // −∇²V ≈ -(Vleft + Vright + Vup + Vdown - 4V) / h²
        let lap = (left + right + up + down - 4.0 * v) / (h * h);
        cells.push(CsdCell { channel: ch, row, col, potential_mv: v, csd: -lap });
    }

    Ok(CsdReport { path: path.to_path_buf(), cells })
}

#[cfg(test)]
mod tests {
    #[test]
    fn laplacian_of_constant_is_zero() {
        let pot: [f64; 64] = [1.0; 64];
        let h: f64 = 0.15;
        let mut max_abs: f64 = 0.0;
        for ch in 0..64 {
            let row = ch / 8;
            let col = ch % 8;
            let v: f64 = pot[ch];
            let left: f64 = if col > 0 { pot[ch - 1] } else { v };
            let right: f64 = if col + 1 < 8 { pot[ch + 1] } else { v };
            let up: f64 = if row > 0 { pot[ch - 8] } else { v };
            let down: f64 = if row + 1 < 8 { pot[ch + 8] } else { v };
            let lap: f64 = (left + right + up + down - 4.0 * v) / (h * h);
            max_abs = max_abs.max(lap.abs());
        }
        assert!(max_abs < 1e-9);
    }
}