Merge frame splitting into sw dev

README.md

@@ -43,3 +43,11 @@ Two file formats are supported:
 ## Python bindings
 
 The [timsrust_pyo3](https://github.com/jspaezp/timsrust_pyo3) package is an example of how the performance of TimsRust can be utilized in Python
+
+## Planned changes for future versions
+TODO
+* Improve docs
+* Improve tests
+* Pase CompressionType1
+* Make Path of TimsTOF data into special type
+* ...

benches/speed_performance.rs

@@ -1,8 +1,7 @@
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use rayon::iter::ParallelIterator;
-use timsrust::{
-    io::readers::{FrameReader, SpectrumReader},
-    ms_data::Frame,
+use timsrust::io::readers::{
+    FrameReader, SpectrumReader, SpectrumReaderConfig,
 };
 
 const DDA_TEST: &str =
@@ -34,7 +33,7 @@ fn criterion_benchmark_dda(c: &mut Criterion) {
     group.significance_level(0.001).sample_size(10);
     let d_folder_name: &str = DDA_TEST;
     let frame_reader = FrameReader::new(d_folder_name).unwrap();
-    let spectrum_reader = SpectrumReader::new(d_folder_name);
+    let spectrum_reader = SpectrumReader::new(d_folder_name).unwrap();
     group.bench_function("DDA read_all_frames 6m", |b| {
         b.iter(|| read_all_frames(black_box(&frame_reader)))
     });
@@ -56,7 +55,7 @@ fn criterion_benchmark_dia(c: &mut Criterion) {
     group.significance_level(0.001).sample_size(10);
     let d_folder_name: &str = DIA_TEST;
     let frame_reader = FrameReader::new(d_folder_name).unwrap();
-    let spectrum_reader = SpectrumReader::new(d_folder_name);
+    let spectrum_reader = SpectrumReader::new(d_folder_name).unwrap();
     group.bench_function("DIA read_all_frames 6m", |b| {
         b.iter(|| read_all_frames(black_box(&frame_reader)))
     });
@@ -75,7 +74,7 @@ fn criterion_benchmark_syp(c: &mut Criterion) {
     group.significance_level(0.001).sample_size(10);
     let d_folder_name: &str = SYP_TEST;
     let frame_reader = FrameReader::new(d_folder_name).unwrap();
-    let spectrum_reader = SpectrumReader::new(d_folder_name);
+    let spectrum_reader = SpectrumReader::new(d_folder_name).unwrap();
     group.bench_function("SYP read_all_frames 6m", |b| {
         b.iter(|| read_all_frames(black_box(&frame_reader)))
     });

src/domain_converters.rs

@@ -10,4 +10,6 @@ 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;
+
+    fn invert<T: Into<f64> + Copy>(&self, value: T) -> f64;
 }

src/domain_converters/frame_to_rt.rs

@@ -16,4 +16,20 @@ impl super::ConvertableDomain for Frame2RtConverter {
         let upper_value: f64 = self.rt_values[value.into().ceil() as usize];
         (lower_value + upper_value) / 2.
     }
+    fn invert<T: Into<f64> + Copy>(&self, value: T) -> f64 {
+        let rt_value = value.into();
+        match self.rt_values.binary_search_by(|probe| {
+            probe.partial_cmp(&rt_value).expect("Cannot handle NaNs")
+        }) {
+            Ok(index) => index as f64,
+            Err(index) => match index {
+                _ if (index > 0) && (index < self.rt_values.len()) => {
+                    let start = self.rt_values[index - 1];
+                    let end = self.rt_values[index];
+                    index as f64 + (rt_value - start) / (end - start)
+                },
+                _ => index as f64,
+            },
+        }
+    }
 }

src/domain_converters/scan_to_im.rs

@@ -22,7 +22,12 @@ impl Scan2ImConverter {
 
 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
+        let scan_index: f64 = value.into();
+        self.scan_intercept + self.scan_slope * scan_index
+    }
+
+    fn invert<T: Into<f64> + Copy>(&self, value: T) -> f64 {
+        let im_value: f64 = value.into();
+        (im_value - self.scan_intercept) / self.scan_slope
     }
 }

src/domain_converters/tof_to_mz.rs

@@ -36,7 +36,11 @@ impl Tof2MzConverter {
 
 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)
+        let tof_index: f64 = value.into();
+        (self.tof_intercept + self.tof_slope * tof_index).powi(2)
+    }
+    fn invert<T: Into<f64> + Copy>(&self, value: T) -> f64 {
+        let mz_value: f64 = value.into();
+        (mz_value.sqrt() - self.tof_intercept) / self.tof_slope
     }
 }

src/errors.rs

@@ -1,23 +1,19 @@
-#[derive(thiserror::Error, Debug)]
-pub enum FileFormatError {
-    #[error("DirectoryDoesNotExist")]
-    DirectoryDoesNotExist,
-    #[error("NoParentWithBrukerExtension")]
-    NoParentWithBrukerExtension,
-    #[error("BinaryFilesAreMissing")]
-    BinaryFilesAreMissing,
-    #[error("MetadataFilesAreMissing")]
-    MetadataFilesAreMissing,
-}
+use crate::io::readers::{
+    FrameReaderError, MetadataReaderError, PrecursorReaderError,
+    QuadrupoleSettingsReaderError, SpectrumReaderError,
+};
 
 /// 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] FileFormatError),
-    // #[error("SqlError: {0}")]
-    // SqlError(#[from] SqlError),
-    // #[error("BinError: {0}")]
-    // BinError(#[from] TdfBlobError),
+    #[error("{0}")]
+    FrameReaderError(#[from] FrameReaderError),
+    #[error("{0}")]
+    SpectrumReaderError(#[from] SpectrumReaderError),
+    #[error("{0}")]
+    MetadataReaderError(#[from] MetadataReaderError),
+    #[error("{0}")]
+    PrecursorReaderError(#[from] PrecursorReaderError),
+    #[error("{0}")]
+    QuadrupoleSettingsReaderError(#[from] QuadrupoleSettingsReaderError),
 }

src/io/readers/file_readers/tdf_blob_reader.rs

@@ -75,7 +75,7 @@ impl IndexedTdfBlobReader {
     pub fn new(
         file_name: impl AsRef<Path>,
         binary_offsets: Vec<usize>,
-    ) -> Result<Self, TdfBlobReaderError> {
+    ) -> Result<Self, IndexedTdfBlobReaderError> {
         let blob_reader = TdfBlobReader::new(file_name)?;
         let reader = Self {
             binary_offsets,

src/io/readers/precursor_reader.rs

@@ -2,13 +2,15 @@ mod minitdf;
 mod tdf;
 
 use core::fmt;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 
 use minitdf::{MiniTDFPrecursorReader, MiniTDFPrecursorReaderError};
 use tdf::{TDFPrecursorReader, TDFPrecursorReaderError};
 
 use crate::ms_data::Precursor;
 
+use super::quad_settings_reader::FrameWindowSplittingStrategy;
+
 pub struct PrecursorReader {
     precursor_reader: Box<dyn PrecursorReaderTrait>,
 }
@@ -20,15 +22,12 @@ impl fmt::Debug for PrecursorReader {
 }
 
 impl PrecursorReader {
+    pub fn build() -> PrecursorReaderBuilder {
+        PrecursorReaderBuilder::default()
+    }
+
     pub fn new(path: impl AsRef<Path>) -> Result<Self, PrecursorReaderError> {
-        let precursor_reader: Box<dyn PrecursorReaderTrait> =
-            match path.as_ref().extension().and_then(|e| e.to_str()) {
-                Some("parquet") => Box::new(MiniTDFPrecursorReader::new(path)?),
-                Some("tdf") => Box::new(TDFPrecursorReader::new(path)?),
-                _ => panic!(),
-            };
-        let reader = Self { precursor_reader };
-        Ok(reader)
+        Self::build().with_path(path).finalize()
     }
 
     pub fn get(&self, index: usize) -> Option<Precursor> {
@@ -40,6 +39,48 @@ impl PrecursorReader {
     }
 }
 
+#[derive(Debug, Default, Clone)]
+pub struct PrecursorReaderBuilder {
+    path: PathBuf,
+    config: FrameWindowSplittingStrategy,
+}
+
+impl PrecursorReaderBuilder {
+    pub fn with_path(&self, path: impl AsRef<Path>) -> Self {
+        Self {
+            path: path.as_ref().to_path_buf(),
+            ..self.clone()
+        }
+    }
+
+    pub fn with_config(&self, config: FrameWindowSplittingStrategy) -> Self {
+        Self {
+            config: config,
+            ..self.clone()
+        }
+    }
+
+    pub fn finalize(&self) -> Result<PrecursorReader, PrecursorReaderError> {
+        let precursor_reader: Box<dyn PrecursorReaderTrait> =
+            match self.path.extension().and_then(|e| e.to_str()) {
+                Some("parquet") => {
+                    Box::new(MiniTDFPrecursorReader::new(self.path.clone())?)
+                },
+                Some("tdf") => Box::new(TDFPrecursorReader::new(
+                    self.path.clone(),
+                    self.config.clone(),
+                )?),
+                _ => {
+                    return Err(PrecursorReaderError::PrecursorReaderFileError(
+                        self.path.clone(),
+                    ))
+                },
+            };
+        let reader = PrecursorReader { precursor_reader };
+        Ok(reader)
+    }
+}
+
 trait PrecursorReaderTrait: Sync {
     fn get(&self, index: usize) -> Option<Precursor>;
     fn len(&self) -> usize;
@@ -51,4 +92,6 @@ pub enum PrecursorReaderError {
     MiniTDFPrecursorReaderError(#[from] MiniTDFPrecursorReaderError),
     #[error("{0}")]
     TDFPrecursorReaderError(#[from] TDFPrecursorReaderError),
+    #[error("File {0} not valid")]
+    PrecursorReaderFileError(PathBuf),
 }

src/io/readers/precursor_reader/tdf.rs

@@ -7,7 +7,10 @@ use dda::{DDATDFPrecursorReader, DDATDFPrecursorReaderError};
 use dia::{DIATDFPrecursorReader, DIATDFPrecursorReaderError};
 
 use crate::{
-    io::readers::file_readers::sql_reader::{SqlError, SqlReader},
+    io::readers::{
+        file_readers::sql_reader::{SqlError, SqlReader},
+        quad_settings_reader::FrameWindowSplittingStrategy,
+    },
     ms_data::{AcquisitionType, Precursor},
 };
 
@@ -20,6 +23,7 @@ pub struct TDFPrecursorReader {
 impl TDFPrecursorReader {
     pub fn new(
         path: impl AsRef<Path>,
+        splitting_strategy: FrameWindowSplittingStrategy,
     ) -> Result<Self, TDFPrecursorReaderError> {
         let sql_path = path.as_ref();
         let tdf_sql_reader = SqlReader::open(sql_path)?;
@@ -37,13 +41,15 @@ impl TDFPrecursorReader {
                 AcquisitionType::DDAPASEF => {
                     Box::new(DDATDFPrecursorReader::new(path)?)
                 },
-                AcquisitionType::DIAPASEF => {
-                    Box::new(DIATDFPrecursorReader::new(path)?)
-                },
+                AcquisitionType::DIAPASEF => Box::new(
+                    DIATDFPrecursorReader::new(path, splitting_strategy)?,
+                ),
                 acquisition_type => {
-                    return Err(TDFPrecursorReaderError::UnknownPrecursorType(
-                        format!("{:?}", acquisition_type),
-                    ))
+                    return Err(
+                        TDFPrecursorReaderError::UnsupportedAcquisition(
+                            format!("{:?}", acquisition_type),
+                        ),
+                    )
                 },
             };
         let reader = Self { precursor_reader };
@@ -70,5 +76,5 @@ pub enum TDFPrecursorReaderError {
     #[error("{0}")]
     DIATDFPrecursorReaderError(#[from] DIATDFPrecursorReaderError),
     #[error("Invalid acquistion type for precursor reader: {0}")]
-    UnknownPrecursorType(String),
+    UnsupportedAcquisition(String),
 }

src/io/readers/precursor_reader/tdf/dia.rs

@@ -1,13 +1,12 @@
 use std::path::Path;
 
+use crate::io::readers::quad_settings_reader::FrameWindowSplittingStrategy;
 use crate::{
     domain_converters::{
         ConvertableDomain, Frame2RtConverter, Scan2ImConverter,
     },
     io::readers::{
-        file_readers::sql_reader::{
-            frame_groups::SqlWindowGroup, ReadableSqlTable, SqlError, SqlReader,
-        },
+        file_readers::sql_reader::{SqlError, SqlReader},
         MetadataReader, MetadataReaderError, QuadrupoleSettingsReader,
         QuadrupoleSettingsReaderError,
     },
@@ -26,32 +25,18 @@ pub struct DIATDFPrecursorReader {
 impl DIATDFPrecursorReader {
     pub fn new(
         path: impl AsRef<Path>,
+        splitting_strategy: FrameWindowSplittingStrategy,
     ) -> Result<Self, DIATDFPrecursorReaderError> {
         let sql_path = path.as_ref();
         let tdf_sql_reader = SqlReader::open(sql_path)?;
         let metadata = MetadataReader::new(&path)?;
         let rt_converter: Frame2RtConverter = metadata.rt_converter;
         let im_converter: Scan2ImConverter = metadata.im_converter;
-        let window_groups = SqlWindowGroup::from_sql_reader(&tdf_sql_reader)?;
-        let quadrupole_settings =
-            QuadrupoleSettingsReader::new(tdf_sql_reader.get_path())?;
-        let mut expanded_quadrupole_settings: Vec<QuadrupoleSettings> = vec![];
-        for window_group in window_groups {
-            let window = window_group.window_group;
-            let frame = window_group.frame;
-            let group = &quadrupole_settings[window as usize - 1];
-            for sub_window in 0..group.isolation_mz.len() {
-                let sub_quad_settings = QuadrupoleSettings {
-                    index: frame,
-                    scan_starts: vec![group.scan_starts[sub_window]],
-                    scan_ends: vec![group.scan_ends[sub_window]],
-                    isolation_mz: vec![group.isolation_mz[sub_window]],
-                    isolation_width: vec![group.isolation_width[sub_window]],
-                    collision_energy: vec![group.collision_energy[sub_window]],
-                };
-                expanded_quadrupole_settings.push(sub_quad_settings)
-            }
-        }
+        let expanded_quadrupole_settings =
+            QuadrupoleSettingsReader::from_splitting(
+                tdf_sql_reader.get_path(),
+                splitting_strategy,
+            )?;
         let reader = Self {
             expanded_quadrupole_settings,
             rt_converter,