timsrust 0.6.6

A crate to read Bruker timsTOF data
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use std::collections::HashMap;
use std::path::{Path, PathBuf};

use serde::Deserialize;
use timsrust_core::io::formats::sql::SqlReader;
use timsrust_core::utils::reader::{IndexedReader, Reader};
use timsrust_core::utils::thread::Synced;
use timsrust_core::{
    BitConverter, Converter, IsolationWindow, Mz, Spectrum, TofIndex,
};
use timsrust_sdk::{PressureCompensationStrategy, TimsData};

use crate::{PrecursorReader, PrecursorReaderError, TimsTofPathLike};

/// Lazy DDA-PASEF spectrum reader backed by the Bruker SDK
/// (`tims_read_pasef_msms_v2`).
///
/// Precursor metadata is supplied by the TDF precursor reader; the SDK returns
/// calibrated centroided m/z, which is bit-encoded into `TofIndex` and
/// recovered downstream with a [`BitConverter`].
pub struct SdkSpectrumReader {
    sdk: Synced<TimsData>,
    precursor_reader: PrecursorReader,
    isolation_windows: HashMap<usize, IsolationWindow>,
}

impl SdkSpectrumReader {
    /// `tdf_file` is the path to `analysis.tdf` (used to open the SDK handle
    /// and read isolation windows); `dataset_path` is the `.d` dataset (used to
    /// build the precursor reader).
    pub fn new(
        tdf_file: impl Into<PathBuf>,
        dataset_path: impl TimsTofPathLike,
    ) -> Result<Self, SdkSpectrumReaderError> {
        let tdf_file = tdf_file.into();
        let sdk = TimsData::new(
            tdf_file.clone(),
            false,
            PressureCompensationStrategy::default(),
        );
        let precursor_reader = PrecursorReader::new(dataset_path)?;
        let isolation_windows = read_isolation_windows(&tdf_file);
        Ok(Self {
            sdk: Synced::from(sdk),
            precursor_reader,
            isolation_windows,
        })
    }

    pub fn len(&self) -> usize {
        self.precursor_reader.len()
    }

    pub fn is_empty(&self) -> bool {
        self.len() == 0
    }
}

impl Reader<Spectrum> for SdkSpectrumReader {
    type Error = SdkSpectrumReaderError;

    fn get(&self, index: usize) -> Result<Spectrum, Self::Error> {
        let precursor = self.precursor_reader.get(index)?;
        let id = precursor.index() as i64;
        let (mz_values, area_values) = self
            .sdk
            .with_lock(|sdk| sdk.read_pasef_msms(&[id]))
            .map_err(|_| SdkSpectrumReaderError::Lock)?
            .remove(&id)
            .unwrap_or_default();
        let bit = BitConverter();
        let coordinates: Vec<TofIndex> = mz_values
            .iter()
            .map(|&mz| bit.convert(Mz::from(mz)))
            .collect();
        let intensities: Vec<f64> =
            area_values.iter().map(|&area| area as f64).collect();
        let isolation_window = self
            .isolation_windows
            .get(&precursor.index())
            .cloned()
            .unwrap_or_default();
        Ok(Spectrum::new(
            intensities,
            precursor.index(),
            Some(precursor),
            coordinates,
            isolation_window,
        ))
    }
}

impl IndexedReader<Spectrum> for SdkSpectrumReader {
    type Iter = std::ops::Range<usize>;

    fn iter(&self) -> Self::Iter {
        0..self.len()
    }
}

/// Builds a `precursor id -> isolation window` map from `PasefFrameMsMsInfo`.
/// Best-effort: returns an empty map (default windows) if the table is absent.
fn read_isolation_windows(tdf_file: &Path) -> HashMap<usize, IsolationWindow> {
    #[derive(Deserialize)]
    struct Row {
        #[serde(rename = "Precursor")]
        precursor: usize,
        #[serde(rename = "IsolationMz")]
        isolation_mz: f64,
        #[serde(rename = "IsolationWidth")]
        isolation_width: f64,
        #[serde(rename = "CollisionEnergy")]
        collision_energy: f64,
    }

    let Some(path) = tdf_file.to_str() else {
        return HashMap::new();
    };
    let rows = SqlReader::from(path)
        .ok()
        .and_then(|reader| reader.from_table::<Row>("PasefFrameMsMsInfo").ok())
        .and_then(|table| table.read_all().ok())
        .unwrap_or_default();

    let mut windows = HashMap::new();
    for row in rows {
        windows.insert(
            row.precursor,
            IsolationWindow::new_from_center(
                Mz::from(row.isolation_mz),
                Mz::from(row.isolation_width),
                row.collision_energy,
            ),
        );
    }
    windows
}

#[derive(Debug, thiserror::Error)]
pub enum SdkSpectrumReaderError {
    #[error("{0}")]
    Precursor(#[from] PrecursorReaderError),
    #[error("SDK reader mutex was poisoned")]
    Lock,
}