diff --git a/benches/speed_performance.rs b/benches/speed_performance.rs index d9bd813..daab1cc 100644 --- a/benches/speed_performance.rs +++ b/benches/speed_performance.rs @@ -34,7 +34,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 +56,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 +75,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))) }); diff --git a/src/io/readers/file_readers/tdf_blob_reader.rs b/src/io/readers/file_readers/tdf_blob_reader.rs index 1c2fe97..d8e64fc 100644 --- a/src/io/readers/file_readers/tdf_blob_reader.rs +++ b/src/io/readers/file_readers/tdf_blob_reader.rs @@ -75,7 +75,7 @@ impl IndexedTdfBlobReader { pub fn new( file_name: impl AsRef, binary_offsets: Vec, - ) -> Result { + ) -> Result { let blob_reader = TdfBlobReader::new(file_name)?; let reader = Self { binary_offsets, diff --git a/src/io/readers/precursor_reader/tdf.rs b/src/io/readers/precursor_reader/tdf.rs index 30e1dd5..8c02020 100644 --- a/src/io/readers/precursor_reader/tdf.rs +++ b/src/io/readers/precursor_reader/tdf.rs @@ -41,9 +41,11 @@ impl TDFPrecursorReader { Box::new(DIATDFPrecursorReader::new(path)?) }, acquisition_type => { - return Err(TDFPrecursorReaderError::UnknownPrecursorType( - format!("{:?}", acquisition_type), - )) + return Err( + TDFPrecursorReaderError::UnsupportedAcquisition( + format!("{:?}", acquisition_type), + ), + ) }, }; let reader = Self { precursor_reader }; @@ -70,5 +72,5 @@ pub enum TDFPrecursorReaderError { #[error("{0}")] DIATDFPrecursorReaderError(#[from] DIATDFPrecursorReaderError), #[error("Invalid acquistion type for precursor reader: {0}")] - UnknownPrecursorType(String), + UnsupportedAcquisition(String), } diff --git a/src/io/readers/spectrum_reader.rs b/src/io/readers/spectrum_reader.rs index 336634a..d8851f9 100644 --- a/src/io/readers/spectrum_reader.rs +++ b/src/io/readers/spectrum_reader.rs @@ -2,10 +2,10 @@ mod minitdf; mod tdf; use core::fmt; -use minitdf::MiniTDFSpectrumReader; +use minitdf::{MiniTDFSpectrumReader, MiniTDFSpectrumReaderError}; use rayon::iter::{IntoParallelIterator, ParallelIterator}; use std::path::{Path, PathBuf}; -use tdf::TDFSpectrumReader; +use tdf::{TDFSpectrumReader, TDFSpectrumReaderError}; use crate::ms_data::Spectrum; @@ -20,14 +20,15 @@ impl fmt::Debug for SpectrumReader { } impl SpectrumReader { - pub fn new(path: impl AsRef) -> Self { + pub fn new(path: impl AsRef) -> Result { let spectrum_reader: Box = match path.as_ref().extension().and_then(|e| e.to_str()) { - Some("ms2") => Box::new(MiniTDFSpectrumReader::new(path)), - Some("d") => Box::new(TDFSpectrumReader::new(path)), + Some("ms2") => Box::new(MiniTDFSpectrumReader::new(path)?), + Some("d") => Box::new(TDFSpectrumReader::new(path)?), _ => panic!(), }; - Self { spectrum_reader } + let reader = Self { spectrum_reader }; + Ok(reader) } pub fn get(&self, index: usize) -> Spectrum { @@ -62,3 +63,11 @@ trait SpectrumReaderTrait: Sync { fn len(&self) -> usize; fn calibrate(&mut self); } + +#[derive(Debug, thiserror::Error)] +pub enum SpectrumReaderError { + #[error("{0}")] + MiniTDFSpectrumReaderError(#[from] MiniTDFSpectrumReaderError), + #[error("{0}")] + TDFSpectrumReaderError(#[from] TDFSpectrumReaderError), +} diff --git a/src/io/readers/spectrum_reader/minitdf.rs b/src/io/readers/spectrum_reader/minitdf.rs index 83c50bd..9d3938b 100644 --- a/src/io/readers/spectrum_reader/minitdf.rs +++ b/src/io/readers/spectrum_reader/minitdf.rs @@ -4,11 +4,15 @@ use crate::{ io::readers::{ file_readers::{ parquet_reader::{ - precursors::ParquetPrecursor, ReadableParquetTable, + precursors::ParquetPrecursor, ParquetError, + ReadableParquetTable, + }, + sql_reader::SqlError, + tdf_blob_reader::{ + IndexedTdfBlobReader, IndexedTdfBlobReaderError, }, - tdf_blob_reader::IndexedTdfBlobReader, }, - PrecursorReader, + PrecursorReader, PrecursorReaderError, }, ms_data::Spectrum, utils::find_extension, @@ -25,31 +29,36 @@ pub struct MiniTDFSpectrumReader { } impl MiniTDFSpectrumReader { - pub fn new(path: impl AsRef) -> Self { - let parquet_file_name = - find_extension(&path, "ms2spectrum.parquet").unwrap(); - let precursor_reader = - PrecursorReader::new(&parquet_file_name).unwrap(); - let offsets = ParquetPrecursor::from_parquet_file(&parquet_file_name) - .unwrap() + pub fn new( + path: impl AsRef, + ) -> Result { + let parquet_file_name = find_extension(&path, "ms2spectrum.parquet") + .ok_or(MiniTDFSpectrumReaderError::FileNotFound( + "analysis.tdf".to_string(), + ))?; + let precursor_reader = PrecursorReader::new(&parquet_file_name)?; + let offsets = ParquetPrecursor::from_parquet_file(&parquet_file_name)? .iter() .map(|x| x.offset as usize) .collect(); let collision_energies = - ParquetPrecursor::from_parquet_file(&parquet_file_name) - .unwrap() + ParquetPrecursor::from_parquet_file(&parquet_file_name)? .iter() .map(|x| x.collision_energy) .collect(); - let bin_file_name = find_extension(&path, "bin").unwrap(); - let blob_reader = - IndexedTdfBlobReader::new(&bin_file_name, offsets).unwrap(); - Self { + let bin_file_name = find_extension(&path, "bin").ok_or( + MiniTDFSpectrumReaderError::FileNotFound( + "analysis.tdf".to_string(), + ), + )?; + let blob_reader = IndexedTdfBlobReader::new(&bin_file_name, offsets)?; + let reader = Self { path: path.as_ref().to_path_buf(), precursor_reader, blob_reader, collision_energies, - } + }; + Ok(reader) } } @@ -100,3 +109,17 @@ impl SpectrumReaderTrait for MiniTDFSpectrumReader { fn calibrate(&mut self) {} } + +#[derive(Debug, thiserror::Error)] +pub enum MiniTDFSpectrumReaderError { + #[error("{0}")] + SqlError(#[from] SqlError), + #[error("{0}")] + PrecursorReaderError(#[from] PrecursorReaderError), + #[error("{0}")] + ParquetError(#[from] ParquetError), + #[error("{0}")] + IndexedTdfBlobReaderError(#[from] IndexedTdfBlobReaderError), + #[error("{0}")] + FileNotFound(String), +} diff --git a/src/io/readers/spectrum_reader/tdf.rs b/src/io/readers/spectrum_reader/tdf.rs index 511730e..559010d 100644 --- a/src/io/readers/spectrum_reader/tdf.rs +++ b/src/io/readers/spectrum_reader/tdf.rs @@ -2,15 +2,16 @@ mod dda; mod dia; mod raw_spectra; -use raw_spectra::{RawSpectrum, RawSpectrumReader}; +use raw_spectra::{RawSpectrum, RawSpectrumReader, RawSpectrumReaderError}; use rayon::iter::{IntoParallelIterator, ParallelIterator}; use std::path::{Path, PathBuf}; use crate::{ domain_converters::{ConvertableDomain, Tof2MzConverter}, io::readers::{ - file_readers::sql_reader::SqlReader, FrameReader, MetadataReader, - PrecursorReader, + file_readers::sql_reader::{SqlError, SqlReader}, + FrameReader, FrameReaderError, MetadataReader, MetadataReaderError, + PrecursorReader, PrecursorReaderError, }, ms_data::Spectrum, utils::find_extension, @@ -31,25 +32,30 @@ pub struct TDFSpectrumReader { } impl TDFSpectrumReader { - pub fn new(path_name: impl AsRef) -> Self { - let frame_reader: FrameReader = FrameReader::new(&path_name).unwrap(); - let sql_path = find_extension(&path_name, "analysis.tdf").unwrap(); - let metadata = MetadataReader::new(&sql_path).unwrap(); + pub fn new( + path_name: impl AsRef, + ) -> Result { + let frame_reader: FrameReader = FrameReader::new(&path_name)?; + let sql_path = find_extension(&path_name, "analysis.tdf").ok_or( + TDFSpectrumReaderError::FileNotFound("analysis.tdf".to_string()), + )?; + let metadata = MetadataReader::new(&sql_path)?; let mz_reader: Tof2MzConverter = metadata.mz_converter; - let tdf_sql_reader = SqlReader::open(&sql_path).unwrap(); - let precursor_reader = PrecursorReader::new(&sql_path).unwrap(); + let tdf_sql_reader = SqlReader::open(&sql_path)?; + let precursor_reader = PrecursorReader::new(&sql_path)?; let acquisition_type = frame_reader.get_acquisition(); let raw_spectrum_reader = RawSpectrumReader::new( &tdf_sql_reader, frame_reader, acquisition_type, - ); - Self { + )?; + let reader = Self { path: path_name.as_ref().to_path_buf(), precursor_reader, mz_reader, raw_spectrum_reader, - } + }; + Ok(reader) } pub fn read_single_raw_spectrum(&self, index: usize) -> RawSpectrum { @@ -104,3 +110,19 @@ impl SpectrumReaderTrait for TDFSpectrumReader { } } } + +#[derive(Debug, thiserror::Error)] +pub enum TDFSpectrumReaderError { + #[error("{0}")] + SqlError(#[from] SqlError), + #[error("{0}")] + PrecursorReaderError(#[from] PrecursorReaderError), + #[error("{0}")] + MetadaReaderError(#[from] MetadataReaderError), + #[error("{0}")] + FrameReaderError(#[from] FrameReaderError), + #[error("{0}")] + RawSpectrumReaderError(#[from] RawSpectrumReaderError), + #[error("{0}")] + FileNotFound(String), +} diff --git a/src/io/readers/spectrum_reader/tdf/dda.rs b/src/io/readers/spectrum_reader/tdf/dda.rs index 93ab962..be674ab 100644 --- a/src/io/readers/spectrum_reader/tdf/dda.rs +++ b/src/io/readers/spectrum_reader/tdf/dda.rs @@ -1,7 +1,8 @@ use crate::{ io::readers::{ file_readers::sql_reader::{ - pasef_frame_msms::SqlPasefFrameMsMs, ReadableSqlTable, SqlReader, + pasef_frame_msms::SqlPasefFrameMsMs, ReadableSqlTable, SqlError, + SqlReader, }, FrameReader, }, @@ -19,13 +20,15 @@ pub struct DDARawSpectrumReader { } impl DDARawSpectrumReader { - pub fn new(tdf_sql_reader: &SqlReader, frame_reader: FrameReader) -> Self { - let pasef_frames = - SqlPasefFrameMsMs::from_sql_reader(&tdf_sql_reader).unwrap(); + pub fn new( + tdf_sql_reader: &SqlReader, + frame_reader: FrameReader, + ) -> Result { + let pasef_frames = SqlPasefFrameMsMs::from_sql_reader(&tdf_sql_reader)?; let pasef_precursors = &pasef_frames.iter().map(|x| x.precursor).collect(); let order: Vec = argsort(&pasef_precursors); - let max_precursor = pasef_precursors.iter().max().unwrap(); + let max_precursor = pasef_precursors.iter().max().unwrap(); // SqlReader cannot return empty vecs, so always succeeds let mut offsets: Vec = Vec::with_capacity(max_precursor + 1); offsets.push(0); for (offset, &index) in order.iter().enumerate().take(order.len() - 1) { @@ -35,12 +38,13 @@ impl DDARawSpectrumReader { } } offsets.push(order.len()); - Self { + let reader = Self { order, offsets, pasef_frames, frame_reader, - } + }; + Ok(reader) } pub fn iterate_over_pasef_frames( @@ -97,3 +101,9 @@ impl RawSpectrumReaderTrait for DDARawSpectrumReader { raw_spectrum } } + +#[derive(Debug, thiserror::Error)] +pub enum DDARawSpectrumReaderError { + #[error("{0}")] + SqlError(#[from] SqlError), +} diff --git a/src/io/readers/spectrum_reader/tdf/dia.rs b/src/io/readers/spectrum_reader/tdf/dia.rs index e0342e4..13e4a6a 100644 --- a/src/io/readers/spectrum_reader/tdf/dia.rs +++ b/src/io/readers/spectrum_reader/tdf/dia.rs @@ -1,9 +1,9 @@ use crate::{ io::readers::{ file_readers::sql_reader::{ - frame_groups::SqlWindowGroup, ReadableSqlTable, SqlReader, + frame_groups::SqlWindowGroup, ReadableSqlTable, SqlError, SqlReader, }, - FrameReader, QuadrupoleSettingsReader, + FrameReader, QuadrupoleSettingsReader, QuadrupoleSettingsReaderError, }, ms_data::QuadrupoleSettings, utils::vec_utils::group_and_sum, @@ -18,11 +18,13 @@ pub struct DIARawSpectrumReader { } impl DIARawSpectrumReader { - pub fn new(tdf_sql_reader: &SqlReader, frame_reader: FrameReader) -> Self { - let window_groups = - SqlWindowGroup::from_sql_reader(&tdf_sql_reader).unwrap(); + pub fn new( + tdf_sql_reader: &SqlReader, + frame_reader: FrameReader, + ) -> Result { + let window_groups = SqlWindowGroup::from_sql_reader(&tdf_sql_reader)?; let quadrupole_settings = - QuadrupoleSettingsReader::new(&tdf_sql_reader.get_path()).unwrap(); + QuadrupoleSettingsReader::new(&tdf_sql_reader.get_path())?; let mut expanded_quadrupole_settings: Vec = vec![]; for window_group in window_groups { let window = window_group.window_group; @@ -40,10 +42,11 @@ impl DIARawSpectrumReader { expanded_quadrupole_settings.push(sub_quad_settings) } } - Self { + let reader = Self { expanded_quadrupole_settings, frame_reader, - } + }; + Ok(reader) } } @@ -76,3 +79,11 @@ impl RawSpectrumReaderTrait for DIARawSpectrumReader { raw_spectrum } } + +#[derive(Debug, thiserror::Error)] +pub enum DIARawSpectrumReaderError { + #[error("{0}")] + SqlError(#[from] SqlError), + #[error("{0}")] + QuadrupoleSettingsReaderError(#[from] QuadrupoleSettingsReaderError), +} diff --git a/src/io/readers/spectrum_reader/tdf/raw_spectra.rs b/src/io/readers/spectrum_reader/tdf/raw_spectra.rs index 7172940..8b78d65 100644 --- a/src/io/readers/spectrum_reader/tdf/raw_spectra.rs +++ b/src/io/readers/spectrum_reader/tdf/raw_spectra.rs @@ -7,7 +7,10 @@ use crate::{ utils::vec_utils::{filter_with_mask, find_sparse_local_maxima_mask}, }; -use super::{dda::DDARawSpectrumReader, dia::DIARawSpectrumReader}; +use super::{ + dda::{DDARawSpectrumReader, DDARawSpectrumReaderError}, + dia::{DIARawSpectrumReader, DIARawSpectrumReaderError}, +}; #[derive(Debug, PartialEq, Default, Clone)] pub(crate) struct RawSpectrum { @@ -91,20 +94,25 @@ impl RawSpectrumReader { tdf_sql_reader: &SqlReader, frame_reader: FrameReader, acquisition_type: AcquisitionType, - ) -> Self { + ) -> Result { let raw_spectrum_reader: Box = match acquisition_type { AcquisitionType::DDAPASEF => Box::new( - DDARawSpectrumReader::new(tdf_sql_reader, frame_reader), + DDARawSpectrumReader::new(tdf_sql_reader, frame_reader)?, ), AcquisitionType::DIAPASEF => Box::new( - DIARawSpectrumReader::new(tdf_sql_reader, frame_reader), + DIARawSpectrumReader::new(tdf_sql_reader, frame_reader)?, ), - _ => panic!(), + acquisition_type => { + return Err(RawSpectrumReaderError::UnsupportedAcquisition( + format!("{:?}", acquisition_type), + )) + }, }; - Self { + let reader = Self { raw_spectrum_reader, - } + }; + Ok(reader) } pub fn get(&self, index: usize) -> RawSpectrum { @@ -115,3 +123,13 @@ impl RawSpectrumReader { pub trait RawSpectrumReaderTrait: Sync { fn get(&self, index: usize) -> RawSpectrum; } + +#[derive(Debug, thiserror::Error)] +pub enum RawSpectrumReaderError { + #[error("{0}")] + DDARawSpectrumReaderError(#[from] DDARawSpectrumReaderError), + #[error("{0}")] + DIARawSpectrumReaderError(#[from] DIARawSpectrumReaderError), + #[error("Invalid acquistion type for Raw spectrum reader: {0}")] + UnsupportedAcquisition(String), +} diff --git a/tests/spectrum_readers.rs b/tests/spectrum_readers.rs index 3473d18..43ff4b8 100644 --- a/tests/spectrum_readers.rs +++ b/tests/spectrum_readers.rs @@ -18,7 +18,8 @@ fn minitdf_reader() { .to_str() .unwrap() .to_string(); - let spectra: Vec = SpectrumReader::new(file_path).get_all(); + let spectra: Vec = + SpectrumReader::new(file_path).unwrap().get_all(); let expected: Vec = vec![ Spectrum { mz_values: vec![100.0, 200.002, 300.03, 400.4], @@ -68,7 +69,8 @@ fn tdf_reader_dda() { .to_str() .unwrap() .to_string(); - let spectra: Vec = SpectrumReader::new(file_path).get_all(); + let spectra: Vec = + SpectrumReader::new(file_path).unwrap().get_all(); let expected: Vec = vec![ Spectrum { mz_values: vec![199.7633445943076],