(feature) re-parametrized splitting to 1/k0 terms

src/io/readers/precursor_reader.rs

@@ -9,7 +9,7 @@ use tdf::{TDFPrecursorReader, TDFPrecursorReaderError};
 
 use crate::ms_data::Precursor;
 
-use super::quad_settings_reader::FrameWindowSplittingStrategy;
+use super::FrameWindowSplittingConfiguration;
 
 pub struct PrecursorReader {
     precursor_reader: Box<dyn PrecursorReaderTrait>,
@@ -42,7 +42,7 @@ impl PrecursorReader {
 #[derive(Debug, Default, Clone)]
 pub struct PrecursorReaderBuilder {
     path: PathBuf,
-    config: FrameWindowSplittingStrategy,
+    config: FrameWindowSplittingConfiguration,
 }
 
 impl PrecursorReaderBuilder {
@@ -53,7 +53,10 @@ impl PrecursorReaderBuilder {
         }
     }
 
-    pub fn with_config(&self, config: FrameWindowSplittingStrategy) -> Self {
+    pub fn with_config(
+        &self,
+        config: FrameWindowSplittingConfiguration,
+    ) -> Self {
         Self {
             config: config,
             ..self.clone()

src/io/readers/precursor_reader/tdf.rs

@@ -9,7 +9,7 @@ use dia::{DIATDFPrecursorReader, DIATDFPrecursorReaderError};
 use crate::{
     io::readers::{
         file_readers::sql_reader::{SqlError, SqlReader},
-        quad_settings_reader::FrameWindowSplittingStrategy,
+        FrameWindowSplittingConfiguration,
     },
     ms_data::{AcquisitionType, Precursor},
 };
@@ -23,7 +23,7 @@ pub struct TDFPrecursorReader {
 impl TDFPrecursorReader {
     pub fn new(
         path: impl AsRef<Path>,
-        splitting_strategy: FrameWindowSplittingStrategy,
+        splitting_strategy: FrameWindowSplittingConfiguration,
     ) -> Result<Self, TDFPrecursorReaderError> {
         let sql_path = path.as_ref();
         let tdf_sql_reader = SqlReader::open(sql_path)?;

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

@@ -1,6 +1,6 @@
 use std::path::Path;
 
-use crate::io::readers::quad_settings_reader::FrameWindowSplittingStrategy;
+use crate::io::readers::FrameWindowSplittingConfiguration;
 use crate::{
     domain_converters::{
         ConvertableDomain, Frame2RtConverter, Scan2ImConverter,
@@ -25,16 +25,17 @@ pub struct DIATDFPrecursorReader {
 impl DIATDFPrecursorReader {
     pub fn new(
         path: impl AsRef<Path>,
-        splitting_strategy: FrameWindowSplittingStrategy,
+        splitting_config: FrameWindowSplittingConfiguration,
     ) -> 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 splitting_strategy = splitting_config.finalize(im_converter);
         let expanded_quadrupole_settings =
             QuadrupoleSettingsReader::from_splitting(
-                tdf_sql_reader.get_path(),
+                &tdf_sql_reader,
                 splitting_strategy,
             )?;
         let reader = Self {

src/io/readers/quad_settings_reader.rs

@@ -1,6 +1,10 @@
 use std::path::Path;
 
-use crate::{ms_data::QuadrupoleSettings, utils::vec_utils::argsort};
+use crate::{
+    domain_converters::{ConvertableDomain, Scan2ImConverter},
+    ms_data::QuadrupoleSettings,
+    utils::vec_utils::argsort,
+};
 
 use super::file_readers::sql_reader::{
     frame_groups::SqlWindowGroup, quad_settings::SqlQuadSettings,
@@ -48,11 +52,9 @@ impl QuadrupoleSettingsReader {
     }
 
     pub fn from_splitting(
-        path: impl AsRef<Path>,
+        tdf_sql_reader: &SqlReader,
         splitting_strat: FrameWindowSplittingStrategy,
     ) -> Result<Vec<QuadrupoleSettings>, QuadrupoleSettingsReaderError> {
-        let sql_path = path.as_ref();
-        let tdf_sql_reader = SqlReader::open(&sql_path)?;
         let quadrupole_settings = Self::from_sql_settings(&tdf_sql_reader)?;
         let window_groups = SqlWindowGroup::from_sql_reader(&tdf_sql_reader)?;
         let expanded_quadrupole_settings = match splitting_strat {
@@ -120,7 +122,8 @@ pub enum QuadrupoleSettingsReaderError {
     SqlError(#[from] SqlError),
 }
 
-type SpanStep = (usize, usize);
+type MobilitySpanStep = (f64, f64);
+type ScanSpanStep = (usize, usize);
 
 /// Strategy for expanding quadrupole settings
 ///
@@ -135,16 +138,62 @@ type SpanStep = (usize, usize);
 /// * `Even(usize)` - Split the quadrupole settings into `usize` evenly spaced
 /// subwindows; e.g. if `usize` is 2, the window will be split into 2 subwindows
 /// of equal width.
-/// * `Uniform(SpanStep)` - Split the quadrupole settings into subwindows of
-/// width `SpanStep.0` and step `SpanStep.1`; e.g. if `SpanStep` is (100, 50),
-/// the window will be split into subwindows of width 100 and step 50 between their
-/// scan start and end.
+/// * `UniformMobility(SpanStep)` - Split the quadrupole settings into subwindows of
+/// width `SpanStep.0` and step `SpanStep.1` in ion mobility space.
+/// e.g. if `SpanStep` is (0.05, 0.02),
+/// the window will be split into subwindows of width 0.05 and step 0.02 between their
+/// in the mobility dimension.
+/// * `UniformScan(SpanStep)` - Split the quadrupole settings into subwindows of
+/// width `SpanStep.0` and step `SpanStep.1` in scan number space.
+/// e.g. if `SpanStep` is (100, 80),
+/// the window will be split into subwindows of width
+/// 100 and step 80 between their in the scan number.
 ///
 #[derive(Debug, Copy, Clone)]
 pub enum QuadWindowExpansionStrategy {
     None,
     Even(usize),
-    Uniform(SpanStep),
+    UniformMobility(MobilitySpanStep, Scan2ImConverter),
+    UniformScan(ScanSpanStep),
+}
+
+#[derive(Debug, Copy, Clone)]
+pub enum QuadWindowExpansionConfiguration {
+    None,
+    Even(usize),
+    UniformMobility(MobilitySpanStep),
+    UniformScan(ScanSpanStep),
+}
+
+impl Default for QuadWindowExpansionConfiguration {
+    fn default() -> Self {
+        Self::Even(1)
+    }
+}
+
+impl QuadWindowExpansionConfiguration {
+    pub fn finalize(
+        self,
+        scan_converter: Scan2ImConverter,
+    ) -> QuadWindowExpansionStrategy {
+        match self {
+            QuadWindowExpansionConfiguration::None => {
+                QuadWindowExpansionStrategy::None
+            },
+            QuadWindowExpansionConfiguration::Even(x) => {
+                QuadWindowExpansionStrategy::Even(x)
+            },
+            QuadWindowExpansionConfiguration::UniformMobility((span, step)) => {
+                QuadWindowExpansionStrategy::UniformMobility(
+                    (span, step),
+                    scan_converter,
+                )
+            },
+            QuadWindowExpansionConfiguration::UniformScan((span, step)) => {
+                QuadWindowExpansionStrategy::UniformScan((span, step))
+            },
+        }
+    }
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -153,9 +202,33 @@ pub enum FrameWindowSplittingStrategy {
     Window(QuadWindowExpansionStrategy),
 }
 
-impl Default for FrameWindowSplittingStrategy {
+#[derive(Debug, Clone, Copy)]
+pub enum FrameWindowSplittingConfiguration {
+    Quadrupole(QuadWindowExpansionConfiguration),
+    Window(QuadWindowExpansionConfiguration),
+}
+
+impl Default for FrameWindowSplittingConfiguration {
     fn default() -> Self {
-        Self::Quadrupole(QuadWindowExpansionStrategy::Even(1))
+        Self::Quadrupole(QuadWindowExpansionConfiguration::Even(1))
+    }
+}
+
+impl FrameWindowSplittingConfiguration {
+    pub fn finalize(
+        self,
+        scan_converter: Scan2ImConverter,
+    ) -> FrameWindowSplittingStrategy {
+        match self {
+            FrameWindowSplittingConfiguration::Quadrupole(x) => {
+                FrameWindowSplittingStrategy::Quadrupole(
+                    x.finalize(scan_converter),
+                )
+            },
+            FrameWindowSplittingConfiguration::Window(x) => {
+                FrameWindowSplittingStrategy::Window(x.finalize(scan_converter))
+            },
+        }
     }
 }
 
@@ -164,7 +237,7 @@ fn scan_range_subsplit(
     end: usize,
     strategy: &QuadWindowExpansionStrategy,
 ) -> Vec<(usize, usize)> {
-    let out = match strategy {
+    let out: Vec<(usize, usize)> = match strategy {
         QuadWindowExpansionStrategy::None => {
             vec![(start, end)]
         },
@@ -181,17 +254,44 @@ fn scan_range_subsplit(
             }
             out
         },
-        QuadWindowExpansionStrategy::Uniform((span, step)) => {
-            let mut curr_start = start.clone();
-            let mut curr_end = start + span;
+        QuadWindowExpansionStrategy::UniformMobility(
+            (span, step),
+            converter,
+        ) => {
+            // Since scan start < scan end but low scans are high IMs, we need to
+            // subtract instead of adding.
+            let mut curr_start_offset = start.clone();
+            let mut curr_start_im = converter.convert(curr_start_offset as f64);
+
+            let mut curr_end_im = curr_start_im - span;
+            let mut curr_end_offset = converter.invert(curr_end_im) as usize;
+            let mut out = Vec::new();
+            while curr_end_offset < end {
+                out.push((curr_start_offset, curr_end_offset));
+
+                curr_start_im = curr_start_im - step;
+                curr_start_offset = converter.invert(curr_start_im) as usize;
+
+                curr_end_im = curr_start_im - span;
+                curr_end_offset = converter.invert(curr_end_im) as usize;
+            }
+            if curr_start_offset < end {
+                out.push((curr_start_offset, end));
+            }
+            out
+        },
+        QuadWindowExpansionStrategy::UniformScan((span, step)) => {
+            let mut curr_start_offset = start;
+            let mut curr_end_offset = start + span;
             let mut out = Vec::new();
-            while curr_end < end {
-                out.push((curr_start, curr_end));
-                curr_start += step;
-                curr_end += step;
+
+            while curr_end_offset < end {
+                out.push((curr_start_offset, curr_end_offset));
+                curr_start_offset += step;
+                curr_end_offset += step;
             }
-            if curr_start < end {
-                out.push((curr_start, end));
+            if curr_start_offset < end {
+                out.push((curr_start_offset, end));
             }
             out
         },

src/io/readers/spectrum_reader.rs

@@ -9,7 +9,7 @@ use tdf::{TDFSpectrumReader, TDFSpectrumReaderError};
 
 use crate::ms_data::Spectrum;
 
-use super::FrameWindowSplittingStrategy;
+use super::FrameWindowSplittingConfiguration;
 
 pub struct SpectrumReader {
     spectrum_reader: Box<dyn SpectrumReaderTrait>,
@@ -147,5 +147,5 @@ impl Default for SpectrumProcessingParams {
 #[derive(Debug, Default, Clone)]
 pub struct SpectrumReaderConfig {
     pub spectrum_processing_params: SpectrumProcessingParams,
-    pub frame_splitting_params: FrameWindowSplittingStrategy,
+    pub frame_splitting_params: FrameWindowSplittingConfiguration,
 }

src/io/readers/spectrum_reader/tdf.rs

@@ -45,11 +45,14 @@ impl TDFSpectrumReader {
             .with_config(config.frame_splitting_params)
             .finalize()?;
         let acquisition_type = frame_reader.get_acquisition();
+        let splitting_strategy = config
+            .frame_splitting_params
+            .finalize(metadata.im_converter);
         let raw_spectrum_reader = RawSpectrumReader::new(
             &tdf_sql_reader,
             frame_reader,
             acquisition_type,
-            config.frame_splitting_params,
+            splitting_strategy,
         )?;
         let reader = Self {
             path: path_name.as_ref().to_path_buf(),

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

@@ -27,7 +27,7 @@ impl DIARawSpectrumReader {
     ) -> Result<Self, DIARawSpectrumReaderError> {
         let expanded_quadrupole_settings =
             QuadrupoleSettingsReader::from_splitting(
-                tdf_sql_reader.get_path(),
+                &tdf_sql_reader,
                 splitting_strategy,
             )?;
         let reader = Self {