timsrust 0.4.2

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

use crate::{
    domain_converters::{
        ConvertableDomain, Frame2RtConverter, Scan2ImConverter,
    },
    io::readers::{
        file_readers::sql_reader::{
            precursors::SqlPrecursor, ReadableSqlTable, SqlReader,
            SqlReaderError,
        },
        MetadataReader, MetadataReaderError,
    },
    ms_data::Precursor,
    readers::TimsTofPathLike,
};

use super::PrecursorReaderTrait;

#[derive(Debug)]
pub struct DDATDFPrecursorReader {
    sql_precursors: Vec<SqlPrecursor>,
    rt_converter: Frame2RtConverter,
    im_converter: Scan2ImConverter,
}

impl DDATDFPrecursorReader {
    pub fn new(
        path: impl TimsTofPathLike,
    ) -> Result<Self, DDATDFPrecursorReaderError> {
        let tdf_sql_reader = SqlReader::open(&path)?;
        let metadata = MetadataReader::new(&path)?;
        let rt_converter: Frame2RtConverter = metadata.rt_converter;
        let im_converter: Scan2ImConverter = metadata.im_converter;
        let sql_precursors = SqlPrecursor::from_sql_reader(&tdf_sql_reader)?;
        let reader = Self {
            sql_precursors,
            rt_converter,
            im_converter,
        };
        Ok(reader)
    }
}

impl PrecursorReaderTrait for DDATDFPrecursorReader {
    fn get(&self, index: usize) -> Option<Precursor> {
        let sql_precursor = &self.sql_precursors.get(index)?;
        let frame_id: usize = sql_precursor.precursor_frame;
        let scan_id: f64 = sql_precursor.scan_average;
        let precursor = Precursor {
            mz: sql_precursor.mz,
            rt: self.rt_converter.convert(frame_id as u32),
            im: self.im_converter.convert(scan_id),
            charge: Some(sql_precursor.charge),
            intensity: Some(sql_precursor.intensity),
            index: index + 1,
            frame_index: frame_id,
        };
        Some(precursor)
    }

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

#[derive(Debug, thiserror::Error)]
pub enum DDATDFPrecursorReaderError {
    #[error("{0}")]
    SqlReaderError(#[from] SqlReaderError),
    #[error("{0}")]
    MetadataReaderError(#[from] MetadataReaderError),
}