FEAT: made proper quad_settings_reader that can be recycled

src/io/readers.rs

@@ -2,9 +2,11 @@ pub(crate) mod file_readers;
 mod frame_reader;
 mod metadata_reader;
 mod precursor_reader;
+mod quad_settings_reader;
 mod spectrum_reader;
 
 pub use frame_reader::*;
 pub use metadata_reader::*;
 pub use precursor_reader::*;
+pub use quad_settings_reader::*;
 pub use spectrum_reader::*;

src/io/readers/file_readers/sql_reader.rs

@@ -5,20 +5,24 @@ pub mod pasef_frame_msms;
 pub mod precursors;
 pub mod quad_settings;
 
-use std::{collections::HashMap, path::Path};
+use std::{
+    collections::HashMap,
+    path::{Path, PathBuf},
+};
 
 use rusqlite::Connection;
 
 #[derive(Debug)]
 pub struct SqlReader {
     connection: Connection,
+    path: PathBuf,
 }
 
 impl SqlReader {
     pub fn open(file_name: impl AsRef<Path>) -> Result<Self, SqlError> {
         let path = file_name.as_ref().to_path_buf();
         let connection = Connection::open(&path)?;
-        Ok(Self { connection })
+        Ok(Self { connection, path })
     }
 
     pub fn read_column_from_table<T: rusqlite::types::FromSql + Default>(
@@ -35,6 +39,10 @@ impl SqlReader {
         let result = rows.collect::<Result<Vec<_>, _>>()?;
         Ok(result)
     }
+
+    pub fn get_path(&self) -> PathBuf {
+        self.path.clone()
+    }
 }
 
 pub trait ReadableSqlTable {

src/io/readers/frame_reader.rs

@@ -8,15 +8,18 @@ use rayon::iter::{IntoParallelIterator, ParallelIterator};
 
 use crate::{
     ms_data::{AcquisitionType, Frame, MSLevel, QuadrupoleSettings},
-    utils::{find_extension, vec_utils::argsort},
+    utils::find_extension,
 };
 
-use super::file_readers::{
-    sql_reader::{
-        frame_groups::SqlWindowGroup, frames::SqlFrame,
-        quad_settings::SqlQuadSettings, ReadableSqlTable, SqlReader,
+use super::{
+    file_readers::{
+        sql_reader::{
+            frame_groups::SqlWindowGroup, frames::SqlFrame, ReadableSqlTable,
+            SqlReader,
+        },
+        tdf_blob_reader::{TdfBlob, TdfBlobReader},
     },
-    tdf_blob_reader::{TdfBlob, TdfBlobReader},
+    QuadrupoleSettingsReader,
 };
 
 #[derive(Debug)]
@@ -46,64 +49,16 @@ impl FrameReader {
             AcquisitionType::Unknown
         };
         let mut window_groups = vec![0; sql_frames.len()];
-        let mut quadrupole_settings: Vec<QuadrupoleSettings>;
+        let quadrupole_settings;
         if acquisition == AcquisitionType::DIAPASEF {
             for window_group in
                 SqlWindowGroup::from_sql_reader(&tdf_sql_reader).unwrap()
             {
                 window_groups[window_group.frame - 1] =
                     window_group.window_group;
             }
-            let sql_quadrupole_settings =
-                SqlQuadSettings::from_sql_reader(&tdf_sql_reader).unwrap();
-            let window_group_count =
-                *window_groups.iter().max().unwrap() as usize;
-            quadrupole_settings = (0..window_group_count)
-                .map(|window_group| {
-                    let mut quad = QuadrupoleSettings::default();
-                    quad.index = window_group + 1;
-                    quad
-                })
-                .collect();
-            for window_group in sql_quadrupole_settings {
-                let group = window_group.window_group - 1;
-                quadrupole_settings[group]
-                    .scan_starts
-                    .push(window_group.scan_start);
-                quadrupole_settings[group]
-                    .scan_ends
-                    .push(window_group.scan_end);
-                quadrupole_settings[group]
-                    .collision_energy
-                    .push(window_group.collision_energy);
-                quadrupole_settings[group]
-                    .isolation_mz
-                    .push(window_group.mz_center);
-                quadrupole_settings[group]
-                    .isolation_width
-                    .push(window_group.mz_width);
-            }
-            quadrupole_settings = quadrupole_settings
-                .into_iter()
-                .map(|mut window| {
-                    let order = argsort(&window.scan_starts);
-                    window.isolation_mz =
-                        order.iter().map(|&i| window.isolation_mz[i]).collect();
-                    window.isolation_width = order
-                        .iter()
-                        .map(|&i| window.isolation_width[i])
-                        .collect();
-                    window.collision_energy = order
-                        .iter()
-                        .map(|&i| window.collision_energy[i])
-                        .collect();
-                    window.scan_starts =
-                        order.iter().map(|&i| window.scan_starts[i]).collect();
-                    window.scan_ends =
-                        order.iter().map(|&i| window.scan_ends[i]).collect();
-                    window
-                })
-                .collect();
+            quadrupole_settings =
+                QuadrupoleSettingsReader::new(tdf_sql_reader.get_path());
         } else {
             quadrupole_settings = vec![];
         }

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

@@ -6,13 +6,11 @@ use crate::{
     },
     io::readers::{
         file_readers::sql_reader::{
-            frame_groups::SqlWindowGroup, quad_settings::SqlQuadSettings,
-            ReadableSqlTable, SqlReader,
+            frame_groups::SqlWindowGroup, ReadableSqlTable, SqlReader,
         },
-        MetadataReader,
+        MetadataReader, QuadrupoleSettingsReader,
     },
     ms_data::{Precursor, QuadrupoleSettings},
-    utils::vec_utils::argsort,
 };
 
 use super::PrecursorReaderTrait;
@@ -27,62 +25,15 @@ pub struct DIATDFPrecursorReader {
 
 impl DIATDFPrecursorReader {
     pub fn new(path: impl AsRef<Path>) -> Self {
-        // TODO: refactor or even better: recycle
         let sql_path = path.as_ref();
         let tdf_sql_reader = SqlReader::open(sql_path).unwrap();
         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).unwrap();
-        let mut quadrupole_settings: Vec<QuadrupoleSettings>;
-        let sql_quadrupole_settings =
-            SqlQuadSettings::from_sql_reader(&tdf_sql_reader).unwrap();
-        let window_group_count =
-            window_groups.iter().map(|x| x.window_group).max().unwrap()
-                as usize;
-        quadrupole_settings = (0..window_group_count)
-            .map(|window_group| {
-                let mut quad = QuadrupoleSettings::default();
-                quad.index = window_group + 1;
-                quad
-            })
-            .collect();
-        for window_group in sql_quadrupole_settings {
-            let group = window_group.window_group - 1;
-            quadrupole_settings[group]
-                .scan_starts
-                .push(window_group.scan_start);
-            quadrupole_settings[group]
-                .scan_ends
-                .push(window_group.scan_end);
-            quadrupole_settings[group]
-                .collision_energy
-                .push(window_group.collision_energy);
-            quadrupole_settings[group]
-                .isolation_mz
-                .push(window_group.mz_center);
-            quadrupole_settings[group]
-                .isolation_width
-                .push(window_group.mz_width);
-        }
-        quadrupole_settings = quadrupole_settings
-            .into_iter()
-            .map(|mut window| {
-                let order = argsort(&window.scan_starts);
-                window.isolation_mz =
-                    order.iter().map(|&i| window.isolation_mz[i]).collect();
-                window.isolation_width =
-                    order.iter().map(|&i| window.isolation_width[i]).collect();
-                window.collision_energy =
-                    order.iter().map(|&i| window.collision_energy[i]).collect();
-                window.scan_starts =
-                    order.iter().map(|&i| window.scan_starts[i]).collect();
-                window.scan_ends =
-                    order.iter().map(|&i| window.scan_ends[i]).collect();
-                window
-            })
-            .collect();
+        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;

src/io/readers/quad_settings_reader.rs

@@ -0,0 +1,83 @@
+use std::path::Path;
+
+use crate::{ms_data::QuadrupoleSettings, utils::vec_utils::argsort};
+
+use super::file_readers::sql_reader::{
+    quad_settings::SqlQuadSettings, ReadableSqlTable, SqlReader,
+};
+
+pub struct QuadrupoleSettingsReader {
+    quadrupole_settings: Vec<QuadrupoleSettings>,
+    sql_quadrupole_settings: Vec<SqlQuadSettings>,
+}
+
+impl QuadrupoleSettingsReader {
+    pub fn new(path: impl AsRef<Path>) -> Vec<QuadrupoleSettings> {
+        let sql_path = path.as_ref();
+        let tdf_sql_reader = SqlReader::open(&sql_path).unwrap();
+        let sql_quadrupole_settings =
+            SqlQuadSettings::from_sql_reader(&tdf_sql_reader).unwrap();
+        let window_group_count = sql_quadrupole_settings
+            .iter()
+            .map(|x| x.window_group)
+            .max()
+            .unwrap() as usize;
+        let quadrupole_settings = (0..window_group_count)
+            .map(|window_group| {
+                let mut quad = QuadrupoleSettings::default();
+                quad.index = window_group + 1;
+                quad
+            })
+            .collect();
+        let mut quad_reader = Self {
+            quadrupole_settings,
+            sql_quadrupole_settings,
+        };
+        quad_reader.update_from_sql_quadrupole_settings();
+        quad_reader.resort_groups();
+        quad_reader.quadrupole_settings
+    }
+
+    fn update_from_sql_quadrupole_settings(&mut self) {
+        for window_group in self.sql_quadrupole_settings.iter() {
+            let group = window_group.window_group - 1;
+            self.quadrupole_settings[group]
+                .scan_starts
+                .push(window_group.scan_start);
+            self.quadrupole_settings[group]
+                .scan_ends
+                .push(window_group.scan_end);
+            self.quadrupole_settings[group]
+                .collision_energy
+                .push(window_group.collision_energy);
+            self.quadrupole_settings[group]
+                .isolation_mz
+                .push(window_group.mz_center);
+            self.quadrupole_settings[group]
+                .isolation_width
+                .push(window_group.mz_width);
+        }
+    }
+
+    fn resort_groups(&mut self) {
+        self.quadrupole_settings = self
+            .quadrupole_settings
+            .iter()
+            .map(|_window| {
+                let mut window = _window.clone();
+                let order = argsort(&window.scan_starts);
+                window.isolation_mz =
+                    order.iter().map(|&i| window.isolation_mz[i]).collect();
+                window.isolation_width =
+                    order.iter().map(|&i| window.isolation_width[i]).collect();
+                window.collision_energy =
+                    order.iter().map(|&i| window.collision_energy[i]).collect();
+                window.scan_starts =
+                    order.iter().map(|&i| window.scan_starts[i]).collect();
+                window.scan_ends =
+                    order.iter().map(|&i| window.scan_ends[i]).collect();
+                window
+            })
+            .collect();
+    }
+}

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

@@ -1,13 +1,12 @@
 use crate::{
     io::readers::{
         file_readers::sql_reader::{
-            frame_groups::SqlWindowGroup, quad_settings::SqlQuadSettings,
-            ReadableSqlTable, SqlReader,
+            frame_groups::SqlWindowGroup, ReadableSqlTable, SqlReader,
         },
-        FrameReader,
+        FrameReader, QuadrupoleSettingsReader,
     },
     ms_data::QuadrupoleSettings,
-    utils::vec_utils::{argsort, group_and_sum},
+    utils::vec_utils::group_and_sum,
 };
 
 use super::raw_spectra::{RawSpectrum, RawSpectrumReaderTrait};
@@ -22,54 +21,8 @@ impl DIARawSpectrumReader {
     pub fn new(tdf_sql_reader: &SqlReader, frame_reader: FrameReader) -> Self {
         let window_groups =
             SqlWindowGroup::from_sql_reader(&tdf_sql_reader).unwrap();
-        let mut quadrupole_settings: Vec<QuadrupoleSettings>;
-        let sql_quadrupole_settings =
-            SqlQuadSettings::from_sql_reader(&tdf_sql_reader).unwrap();
-        let window_group_count =
-            window_groups.iter().map(|x| x.window_group).max().unwrap()
-                as usize;
-        quadrupole_settings = (0..window_group_count)
-            .map(|window_group| {
-                let mut quad = QuadrupoleSettings::default();
-                quad.index = window_group + 1;
-                quad
-            })
-            .collect();
-        for window_group in sql_quadrupole_settings {
-            let group = window_group.window_group - 1;
-            quadrupole_settings[group]
-                .scan_starts
-                .push(window_group.scan_start);
-            quadrupole_settings[group]
-                .scan_ends
-                .push(window_group.scan_end);
-            quadrupole_settings[group]
-                .collision_energy
-                .push(window_group.collision_energy);
-            quadrupole_settings[group]
-                .isolation_mz
-                .push(window_group.mz_center);
-            quadrupole_settings[group]
-                .isolation_width
-                .push(window_group.mz_width);
-        }
-        quadrupole_settings = quadrupole_settings
-            .into_iter()
-            .map(|mut window| {
-                let order = argsort(&window.scan_starts);
-                window.isolation_mz =
-                    order.iter().map(|&i| window.isolation_mz[i]).collect();
-                window.isolation_width =
-                    order.iter().map(|&i| window.isolation_width[i]).collect();
-                window.collision_energy =
-                    order.iter().map(|&i| window.collision_energy[i]).collect();
-                window.scan_starts =
-                    order.iter().map(|&i| window.scan_starts[i]).collect();
-                window.scan_ends =
-                    order.iter().map(|&i| window.scan_ends[i]).collect();
-                window
-            })
-            .collect();
+        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;