CHORE: refactored pasefmsmsframes

src/file_readers/common/sql_reader.rs

@@ -1,7 +1,7 @@
 mod metadata;
-mod tables;
+// mod tables;
 
-pub use tables::*;
+// pub use tables::*;
 
 use rusqlite::{Connection, Result, Statement};
 use std::path::Path;

src/file_readers/spectrum_readers/dda_reader.rs

@@ -60,7 +60,7 @@ impl DDASpectrumReader {
         let mut intensities: Vec<u32> = vec![];
         for &index in selection.iter() {
             let frame_index: usize =
-                self.precursor_reader.pasef_frames.frame[index] - 1;
+                self.precursor_reader.pasef_frames[index].frame - 1;
             // let frame: &Frame = &self.ms2_frames[frame_index];
             let frame: &Frame = &self
                 .ms2_frames
@@ -71,9 +71,9 @@ impl DDASpectrumReader {
                 continue;
             }
             let scan_start: usize =
-                self.precursor_reader.pasef_frames.scan_start[index];
+                self.precursor_reader.pasef_frames[index].scan_start;
             let scan_end: usize =
-                self.precursor_reader.pasef_frames.scan_end[index];
+                self.precursor_reader.pasef_frames[index].scan_end;
             let offset_start: usize = frame.scan_offsets[scan_start] as usize;
             let offset_end: usize = frame.scan_offsets[scan_end] as usize;
             let tof_selection: &[u32] =

src/file_readers/spectrum_readers/dda_reader/precursors.rs

@@ -4,14 +4,12 @@ use rayon::prelude::*;
 
 use crate::{
     domain_converters::{
-        ConvertableDomain, Frame2RtConverter, Scan2ImConverter, Tof2MzConverter,
-    },
-    file_readers::{
-        self,
-        common::sql_reader::{PasefFrameMsMsTable, ReadableFromSql},
+        ConvertableDomain, Frame2RtConverter, Scan2ImConverter,
     },
+    file_readers::{self, common::sql_reader::ReadableFromSql},
     io::readers::file_readers::sql_reader::{
-        precursors::SqlPrecursor, SqlReadable, SqlReader,
+        pasef_frame_msms::SqlPasefFrameMsMs, precursors::SqlPrecursor,
+        SqlReadable, SqlReader,
     },
     ms_data::Precursor,
     utils::vec_utils::argsort,
@@ -20,7 +18,7 @@ use crate::{
 #[derive(Debug)]
 pub struct PrecursorReader {
     pub precursors: Vec<Precursor>,
-    pub pasef_frames: PasefFrameMsMsTable,
+    pub pasef_frames: Vec<SqlPasefFrameMsMs>,
     pub order: Vec<usize>,
     pub offsets: Vec<usize>,
     pub count: usize,
@@ -38,14 +36,10 @@ impl PrecursorReader {
         let select_collision_energy_sql = String::from(
             "SELECT CollisionEnergy FROM PasefFrameMsMsInfo GROUP BY Precursor",
         );
-        let pasef_frames: PasefFrameMsMsTable =
-            PasefFrameMsMsTable::from_sql(&tdf_sql_reader);
-        // let precursor_table: PrecursorTable =
-        //     PrecursorTable::from_sql(&tdf_sql_reader);
-
         let tdf_sql_reader2 =
             SqlReader::open(Path::new(path).join("analysis.tdf")).unwrap();
-
+        let pasef_frames =
+            SqlPasefFrameMsMs::from_sql_reader(&tdf_sql_reader2).unwrap();
         let precursors =
             SqlPrecursor::from_sql_reader(&tdf_sql_reader2).unwrap();
         let collision_energies =
@@ -67,15 +61,15 @@ impl PrecursorReader {
                 }
             })
             .collect();
-        let order: Vec<usize> = argsort(&pasef_frames.precursor);
-        let count: usize = *pasef_frames.precursor.iter().max().unwrap();
+        let pasef_precursors =
+            &pasef_frames.iter().map(|x| x.precursor).collect();
+        let order: Vec<usize> = argsort(&pasef_precursors);
+        let count: usize = *pasef_precursors.iter().max().unwrap();
         let mut offsets: Vec<usize> = Vec::with_capacity(count + 1);
         offsets.push(0);
         for (offset, &index) in order.iter().enumerate().take(order.len() - 1) {
             let second_index: usize = order[offset + 1];
-            if pasef_frames.precursor[index]
-                != pasef_frames.precursor[second_index]
-            {
+            if pasef_precursors[index] != pasef_precursors[second_index] {
                 offsets.push(offset + 1)
             }
         }

src/io/readers/file_readers/sql_reader.rs

@@ -1,4 +1,5 @@
 pub mod frames;
+pub mod pasef_frame_msms;
 pub mod precursors;
 
 use std::path::{Path, PathBuf};

src/io/readers/file_readers/sql_reader/pasef_frame_msms.rs

@@ -0,0 +1,30 @@
+use super::SqlReadable;
+
+#[derive(Debug, PartialEq)]
+pub struct SqlPasefFrameMsMs {
+    pub frame: usize,
+    pub scan_start: usize,
+    pub scan_end: usize,
+    pub mz_center: f64,
+    pub mz_width: f64,
+    pub collision_energy: f64,
+    pub precursor: usize,
+}
+
+impl SqlReadable for SqlPasefFrameMsMs {
+    fn get_sql_query() -> String {
+        "SELECT Frame, ScanNumBegin, ScanNumEnd, IsolationMz, IsolationWidth, CollisionEnergy, Precursor FROM PasefFrameMsMsInfo".to_string()
+    }
+
+    fn from_sql_row(row: &rusqlite::Row) -> Self {
+        Self {
+            frame: row.get(0).unwrap_or_default(),
+            scan_start: row.get(1).unwrap_or_default(),
+            scan_end: row.get(2).unwrap_or_default(),
+            mz_center: row.get(3).unwrap_or_default(),
+            mz_width: row.get(4).unwrap_or_default(),
+            collision_energy: row.get(5).unwrap_or_default(),
+            precursor: row.get(6).unwrap_or_default(),
+        }
+    }
+}