Develop

.github/workflows/rust.yml

@@ -12,9 +12,7 @@ env:
 
 jobs:
   build:
-
     runs-on: ubuntu-latest
-
     steps:
     - uses: actions/checkout@v3
     - name: Build

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "timsrust"
-version = "0.2.4"
+version = "0.3.0"
 edition = "2021"
 description = "A crate to read Bruker timsTOF data"
 license = "Apache-2.0"

benches/speed_performance.rs

@@ -1,6 +1,13 @@
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use timsrust::FileReader;
 
+const DDA_TEST: &str =
+    "/mnt/c/Users/Sander.Willems/Documents/data/tims05_300SPD/20230505_TIMS05_PaSk_MA_HeLa_6min_ddaP_S1-C10_1_2323.d/";
+const DIA_TEST: &str =
+    "/mnt/c/Users/Sander.Willems/Documents/data/20230505_TIMS05_PaSk_SA_HeLa_6min_diaP_8scans_S1-D3_1_2329.d/";
+const SYP_TEST: &str =
+    "/mnt/c/Users/Sander.Willems/Documents/data/20230505_TIMS05_PaSk_SA_HeLa_6min_syP_5scans_30Da_S1-D4_1_2330.d/";
+
 fn read_all_frames(file_reader: &FileReader) {
     file_reader.read_all_frames();
 }
@@ -17,27 +24,70 @@ fn read_all_spectra(file_reader: &FileReader) {
     file_reader.read_all_spectra();
 }
 
-fn criterion_benchmark(c: &mut Criterion) {
+fn criterion_benchmark_dda(c: &mut Criterion) {
     // c.bench_function("fib 20", |b| b.iter(|| fibonacci(black_box(20))));
     let mut group = c.benchmark_group("sample-size-example");
     group.significance_level(0.001).sample_size(10);
-    let d_folder_name: &str = "/home/sander/data/20230505_TIMS05_PaSk_MA_HeLa_6min_ddaP_S1-C10_1_2323.d/";
+    let d_folder_name: &str = DDA_TEST;
     let file_reader: FileReader =
         FileReader::new(d_folder_name.to_string()).unwrap();
-    group.bench_function("read_all_frames 6m dda", |b| {
+    group.bench_function("DDA read_all_frames 6m", |b| {
         b.iter(|| read_all_frames(black_box(&file_reader)))
     });
-    group.bench_function("read_all_ms1_frames 6m dda", |b| {
+    group.bench_function("DDA read_all_ms1_frames 6m", |b| {
         b.iter(|| read_all_ms1_frames(black_box(&file_reader)))
     });
-    group.bench_function("read_all_ms2_frames 6m dda", |b| {
+    group.bench_function("DDA read_all_ms2_frames 6m", |b| {
         b.iter(|| read_all_ms2_frames(black_box(&file_reader)))
     });
-    group.bench_function("read_all_spectra 6m dda", |b| {
+    group.bench_function("DDA read_all_spectra 6m", |b| {
         b.iter(|| read_all_spectra(black_box(&file_reader)))
     });
     group.finish();
 }
 
-criterion_group!(benches, criterion_benchmark);
+fn criterion_benchmark_dia(c: &mut Criterion) {
+    // c.bench_function("fib 20", |b| b.iter(|| fibonacci(black_box(20))));
+    let mut group = c.benchmark_group("sample-size-example");
+    group.significance_level(0.001).sample_size(10);
+    let d_folder_name: &str = DIA_TEST;
+    let file_reader: FileReader =
+        FileReader::new(d_folder_name.to_string()).unwrap();
+    group.bench_function("DIA read_all_frames 6m", |b| {
+        b.iter(|| read_all_frames(black_box(&file_reader)))
+    });
+    group.bench_function("DIA read_all_ms1_frames 6m", |b| {
+        b.iter(|| read_all_ms1_frames(black_box(&file_reader)))
+    });
+    group.bench_function("DIA read_all_ms2_frames 6m", |b| {
+        b.iter(|| read_all_ms2_frames(black_box(&file_reader)))
+    });
+    group.finish();
+}
+
+fn criterion_benchmark_syp(c: &mut Criterion) {
+    // c.bench_function("fib 20", |b| b.iter(|| fibonacci(black_box(20))));
+    let mut group = c.benchmark_group("sample-size-example");
+    group.significance_level(0.001).sample_size(10);
+    let d_folder_name: &str = SYP_TEST;
+    let file_reader: FileReader =
+        FileReader::new(d_folder_name.to_string()).unwrap();
+    group.bench_function("SYP read_all_frames 6m", |b| {
+        b.iter(|| read_all_frames(black_box(&file_reader)))
+    });
+    group.bench_function("SYP read_all_ms1_frames 6m", |b| {
+        b.iter(|| read_all_ms1_frames(black_box(&file_reader)))
+    });
+    group.bench_function("SYP read_all_ms2_frames 6m", |b| {
+        b.iter(|| read_all_ms2_frames(black_box(&file_reader)))
+    });
+    group.finish();
+}
+
+criterion_group!(
+    benches,
+    criterion_benchmark_dda,
+    // criterion_benchmark_dia,
+    // criterion_benchmark_syp
+);
 criterion_main!(benches);

src/domain_converters.rs

@@ -0,0 +1,13 @@
+//! Allows conversions between domains (e.g. Time of Flight and m/z)
+mod frame_to_rt;
+mod scan_to_im;
+mod tof_to_mz;
+
+pub use frame_to_rt::Frame2RtConverter;
+pub use scan_to_im::Scan2ImConverter;
+pub use tof_to_mz::Tof2MzConverter;
+
+/// Convert from one domain (e.g. Time of Flight) to another (m/z).
+pub trait ConvertableDomain {
+    fn convert<T: Into<f64> + Copy>(&self, value: T) -> f64;
+}

src/domain_converters/frame_to_rt.rs

@@ -0,0 +1,19 @@
+/// A converter from Frame -> retention time.
+#[derive(Debug, Clone)]
+pub struct Frame2RtConverter {
+    rt_values: Vec<f64>,
+}
+
+impl Frame2RtConverter {
+    pub fn from_values(rt_values: Vec<f64>) -> Self {
+        Self { rt_values }
+    }
+}
+
+impl super::ConvertableDomain for Frame2RtConverter {
+    fn convert<T: Into<f64> + Copy>(&self, value: T) -> f64 {
+        let lower_value: f64 = self.rt_values[value.into().floor() as usize];
+        let upper_value: f64 = self.rt_values[value.into().ceil() as usize];
+        (lower_value + upper_value) / 2.
+    }
+}

src/domain_converters/scan_to_im.rs

@@ -0,0 +1,28 @@
+/// A converter from Scan -> (inversed) ion mobility.
+#[derive(Debug, Clone)]
+pub struct Scan2ImConverter {
+    scan_intercept: f64,
+    scan_slope: f64,
+}
+
+impl Scan2ImConverter {
+    pub fn from_boundaries(
+        im_min: f64,
+        im_max: f64,
+        scan_max_index: u32,
+    ) -> Self {
+        let scan_intercept: f64 = im_max;
+        let scan_slope: f64 = (im_min - scan_intercept) / scan_max_index as f64;
+        Self {
+            scan_intercept,
+            scan_slope,
+        }
+    }
+}
+
+impl super::ConvertableDomain for Scan2ImConverter {
+    fn convert<T: Into<f64> + Copy>(&self, value: T) -> f64 {
+        let scan_index_f64: f64 = value.into();
+        self.scan_intercept + self.scan_slope * scan_index_f64
+    }
+}

src/domain_converters/tof_to_mz.rs

@@ -0,0 +1,42 @@
+use linreg::linear_regression;
+
+/// A converter from TOF -> m/z.
+#[derive(Debug, Clone)]
+pub struct Tof2MzConverter {
+    tof_intercept: f64,
+    tof_slope: f64,
+}
+
+impl Tof2MzConverter {
+    pub fn from_boundaries(
+        mz_min: f64,
+        mz_max: f64,
+        tof_max_index: u32,
+    ) -> Self {
+        let tof_intercept: f64 = mz_min.sqrt();
+        let tof_slope: f64 =
+            (mz_max.sqrt() - tof_intercept) / tof_max_index as f64;
+        Self {
+            tof_intercept,
+            tof_slope,
+        }
+    }
+
+    pub fn from_pairs(data: &Vec<(f64, u32)>) -> Self {
+        let x: Vec<u32> = data.iter().map(|(_, x_val)| *x_val).collect();
+        let y: Vec<f64> =
+            data.iter().map(|(y_val, _)| (*y_val).sqrt()).collect();
+        let (tof_slope, tof_intercept) = linear_regression(&x, &y).unwrap();
+        Self {
+            tof_intercept,
+            tof_slope,
+        }
+    }
+}
+
+impl super::ConvertableDomain for Tof2MzConverter {
+    fn convert<T: Into<f64> + Copy>(&self, value: T) -> f64 {
+        let tof_index_f64: f64 = value.into();
+        (self.tof_intercept + self.tof_slope * tof_index_f64).powi(2)
+    }
+}

src/errors.rs

@@ -1,9 +1,16 @@
-use crate::file_readers;
+use crate::{
+    file_readers,
+    // io::readers::common::{sql_reader::SqlError, tdf_blobs::TdfBlobError},
+};
 
 /// An error that is produced by timsrust (uses [thiserror]).
 #[derive(thiserror::Error, Debug)]
 pub enum Error {
     /// An error to indicate a path is not a Bruker File Format.
     #[error("FileFormatError: {0}")]
     FileFormatError(#[from] file_readers::FileFormatError),
+    // #[error("SqlError: {0}")]
+    // SqlError(#[from] SqlError),
+    // #[error("BinError: {0}")]
+    // BinError(#[from] TdfBlobError),
 }