Struct IsolationWindow 

pub struct IsolationWindow {
    pub target: f64,
    pub lower: f64,
    pub upper: f64,
}

Precursor isolation window for an MS2 spectrum (mzML coordinates).

All values in m/z. lower and upper are absolute boundaries (already expanded from any target offset in the source file).

Fields

target: f64

lower: f64

upper: f64

Implementations

impl IsolationWindow

pub fn key(&self) -> (i64, i64, i64)

Stable integer key for grouping MS2 scans that share an isolation window. Encodes (target, lower, upper) to 4 decimal places.

Examples found in repository

examples/thermo_parity.rs (line 117)

fn ms2(raw: &Path, mzml: &Path) -> anyhow::Result<()> {
    let t = Instant::now();
    let a = io::thermo::read_thermo_ms2(raw)?;
    println!(
        "raw: {} MS2 spectra in {:.2} s",
        a.len(),
        t.elapsed().as_secs_f64()
    );
    let b: Vec<Spectrum> = io::mzml::stream_mzml_ms2(mzml)?.collect();
    println!("mzML: {} MS2 spectra", b.len());
    let windows = |v: &[Spectrum]| {
        let mut m: BTreeMap<(i64, i64, i64), usize> = BTreeMap::new();
        for s in v {
            *m.entry(s.isolation_window.unwrap().key()).or_default() += 1;
        }
        m
    };
    let (wa, wb) = (windows(&a), windows(&b));
    println!("distinct windows: raw {} mzML {}", wa.len(), wb.len());
    let fmt = |k: &(i64, i64, i64)| {
        format!(
            "{:.3} [{:.3}, {:.3}]",
            k.0 as f64 / 1e4,
            k.1 as f64 / 1e4,
            k.2 as f64 / 1e4
        )
    };
    for (k, c) in wa.iter().take(5) {
        println!("  raw  {} x{c}", fmt(k));
    }
    for (k, c) in wb.iter().take(5) {
        println!("  mzML {} x{c}", fmt(k));
    }
    // Pair scans in RT order and compare windows and peaks.
    let n = a.len().min(b.len());
    let (mut same_w, mut same_n, mut max_rt, mut max_bound) = (0usize, 0usize, 0.0f64, 0.0f64);
    for (sa, sb) in a.iter().zip(&b).take(n) {
        let (wa, wb) = (sa.isolation_window.unwrap(), sb.isolation_window.unwrap());
        max_rt = max_rt.max((sa.retention_time - sb.retention_time).abs());
        let d = (wa.target - wb.target)
            .abs()
            .max((wa.lower - wb.lower).abs())
            .max((wa.upper - wb.upper).abs());
        max_bound = max_bound.max(d);
        if wa.key() == wb.key() {
            same_w += 1;
        }
        if sa.peaks.len() == sb.peaks.len() {
            same_n += 1;
        }
    }
    println!(
        "paired {n}: identical window key {same_w}, identical peak count {same_n}, \
         max |dRT| {max_rt:.3e} min, max window bound diff {max_bound:.4} Th"
    );
    Ok(())
}

Trait Implementations

impl Clone for IsolationWindow

fn clone(&self) -> IsolationWindow

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for IsolationWindow

impl Debug for IsolationWindow

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for IsolationWindow

fn deserialize<__D>( __deserializer: __D, ) -> Result<IsolationWindow, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for IsolationWindow

impl PartialEq for IsolationWindow

fn eq(&self, other: &IsolationWindow) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for IsolationWindow

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.