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
//! Multi-bandpass voltage charts (`bandpass99`).

use serde::{Deserialize, Serialize};

use crate::analysis::filter::{BandpassFilter, LowPassKind};
use crate::error::{Med64Error, Result};
use crate::toolkit::spectrum::load_channel_mv;
use std::path::Path;

#[derive(Debug, Clone)]
pub struct BandpassBand {
    pub name: String,
    pub highpass_hz: f64,
    pub lowpass_hz: f64,
}

#[derive(Debug, Clone)]
pub struct MultiBandpassOptions {
    pub channel: usize,
    pub max_blocks: Option<usize>,
    pub bands: Vec<BandpassBand>,
}

impl Default for MultiBandpassOptions {
    fn default() -> Self {
        Self {
            channel: 0,
            max_blocks: Some(5),
            bands: vec![
                BandpassBand { name: "delta".into(), highpass_hz: 0.5, lowpass_hz: 4.0 },
                BandpassBand { name: "theta".into(), highpass_hz: 4.0, lowpass_hz: 8.0 },
                BandpassBand { name: "alpha".into(), highpass_hz: 8.0, lowpass_hz: 13.0 },
                BandpassBand { name: "beta".into(), highpass_hz: 13.0, lowpass_hz: 30.0 },
                BandpassBand { name: "gamma".into(), highpass_hz: 30.0, lowpass_hz: 100.0 },
            ],
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MultiBandpassTrace {
    pub name: String,
    pub highpass_hz: f64,
    pub lowpass_hz: f64,
    pub millivolts: Vec<f64>,
    pub rms_mv: f64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MultiBandpassReport {
    pub path: std::path::PathBuf,
    pub channel: usize,
    pub times_ms: Vec<f64>,
    pub raw_mv: Vec<f64>,
    pub bands: Vec<MultiBandpassTrace>,
}

/// Filter one channel into several simultaneous bandpass bands (`bandpass99`).
pub fn multi_bandpass(
    path: impl AsRef<Path>,
    options: &MultiBandpassOptions,
) -> Result<MultiBandpassReport> {
    let path = path.as_ref();
    let (header, samples) = load_channel_mv(path, options.channel, options.max_blocks)?;
    let fs = header.sampling_frequency_hz;
    let period = 1.0 / fs;
    let times_ms: Vec<f64> = (0..samples.len()).map(|i| i as f64 * 1000.0 / fs).collect();
    let mut bands = Vec::new();
    for band in &options.bands {
        let mut filter = BandpassFilter::new(
            period,
            band.highpass_hz,
            band.lowpass_hz,
            LowPassKind::Butterworth,
        );
        let mut filtered = samples.clone();
        filter.filter_block(&mut filtered);
        let rms = if filtered.is_empty() {
            0.0
        } else {
            (filtered.iter().map(|v| v * v).sum::<f64>() / filtered.len() as f64).sqrt()
        };
        bands.push(MultiBandpassTrace {
            name: band.name.clone(),
            highpass_hz: band.highpass_hz,
            lowpass_hz: band.lowpass_hz,
            millivolts: filtered,
            rms_mv: rms,
        });
    }
    Ok(MultiBandpassReport {
        path: path.to_path_buf(),
        channel: options.channel,
        times_ms,
        raw_mv: samples,
        bands,
    })
}

pub fn write_multi_bandpass_csv(
    report: &MultiBandpassReport,
    path: impl AsRef<Path>,
) -> Result<()> {
    let path = path.as_ref();
    let mut header = String::from("time_ms,raw_mv");
    for b in &report.bands {
        header.push(',');
        header.push_str(&b.name);
    }
    header.push('\n');
    let mut body = header;
    let n = report.times_ms.len();
    for i in 0..n {
        body.push_str(&format!("{:.3},{:.8}", report.times_ms[i], report.raw_mv[i]));
        for b in &report.bands {
            let v = b.millivolts.get(i).copied().unwrap_or(0.0);
            body.push_str(&format!(",{v:.8}"));
        }
        body.push('\n');
    }
    std::fs::write(path, body)
        .map_err(|source| Med64Error::WriteIo { path: path.to_path_buf(), source })?;
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn bands_have_rms() {
        let report = multi_bandpass(
            crate::fixture_paths::sample_data1(),
            &MultiBandpassOptions { max_blocks: Some(1), ..Default::default() },
        )
        .unwrap();
        assert_eq!(report.bands.len(), 5);
        assert!(report.bands.iter().any(|b| b.rms_mv > 0.0));
    }
}