use crate::data::acquisition::AcquisitionMode;
use crate::data::handle::{IndexConverter, TimsData, TimsDataLoader};
use crate::data::meta::{
read_dia_ms_ms_info, read_dia_ms_ms_windows, read_global_meta_sql, read_meta_data_sql,
DiaMsMisInfo, DiaMsMsWindow, FrameMeta, GlobalMetaData,
};
use mscore::timstof::frame::{RawTimsFrame, TimsFrame};
use mscore::timstof::slice::TimsSlice;
use rand::prelude::IteratorRandom;
pub struct TimsDatasetDIA {
pub loader: TimsDataLoader,
pub global_meta_data: GlobalMetaData,
pub meta_data: Vec<FrameMeta>,
pub dia_ms_mis_info: Vec<DiaMsMisInfo>,
pub dia_ms_ms_windows: Vec<DiaMsMsWindow>,
}
impl TimsDatasetDIA {
pub fn new(
bruker_lib_path: &str,
data_path: &str,
in_memory: bool,
use_bruker_sdk: bool,
) -> Self {
let global_meta_data = read_global_meta_sql(data_path).unwrap();
let meta_data = read_meta_data_sql(data_path).unwrap();
let dia_ms_mis_info = read_dia_ms_ms_info(data_path).unwrap();
let dia_ms_ms_windows = read_dia_ms_ms_windows(data_path).unwrap();
let scan_max_index = meta_data.iter().map(|x| x.num_scans).max().unwrap() as u32;
let im_lower = global_meta_data.one_over_k0_range_lower;
let im_upper = global_meta_data.one_over_k0_range_upper;
let tof_max_index = global_meta_data.tof_max_index;
let mz_lower = global_meta_data.mz_acquisition_range_lower;
let mz_upper = global_meta_data.mz_acquisition_range_upper;
let loader = match in_memory {
true => TimsDataLoader::new_in_memory(
bruker_lib_path,
data_path,
use_bruker_sdk,
scan_max_index,
im_lower,
im_upper,
tof_max_index,
mz_lower,
mz_upper,
),
false => TimsDataLoader::new_lazy(
bruker_lib_path,
data_path,
use_bruker_sdk,
scan_max_index,
im_lower,
im_upper,
tof_max_index,
mz_lower,
mz_upper,
),
};
TimsDatasetDIA {
loader,
global_meta_data,
meta_data,
dia_ms_mis_info,
dia_ms_ms_windows,
}
}
pub fn sample_precursor_signal(
&self,
num_frames: usize,
max_intensity: f64,
take_probability: f64,
) -> TimsFrame {
let precursor_frames = self.meta_data.iter().filter(|x| x.ms_ms_type == 0);
let mut rng = rand::thread_rng();
let mut sampled_frames: Vec<TimsFrame> = Vec::new();
for frame in precursor_frames.choose_multiple(&mut rng, num_frames) {
let frame_id = frame.id;
let frame_data = self
.loader
.get_frame(frame_id as u32)
.filter_ranged(0.0, 2000.0, 0, 1000, 0.0, 5.0, 1.0, max_intensity)
.generate_random_sample(take_probability);
sampled_frames.push(frame_data);
}
let mut sampled_frame = sampled_frames.remove(0);
for frame in sampled_frames {
sampled_frame = sampled_frame + frame;
}
sampled_frame
}
pub fn sample_fragment_signal(
&self,
num_frames: usize,
window_group: u32,
max_intensity: f64,
take_probability: f64,
) -> TimsFrame {
let fragment_frames: Vec<u32> = self
.dia_ms_mis_info
.iter()
.filter(|x| x.window_group == window_group)
.map(|x| x.frame_id)
.collect();
let mut rng = rand::thread_rng();
let mut sampled_frames: Vec<TimsFrame> = Vec::new();
for frame_id in fragment_frames
.into_iter()
.choose_multiple(&mut rng, num_frames)
{
let frame_data = self
.loader
.get_frame(frame_id)
.filter_ranged(0.0, 2000.0, 0, 1000, 0.0, 5.0, 1.0, max_intensity)
.generate_random_sample(take_probability);
sampled_frames.push(frame_data);
}
let mut sampled_frame = sampled_frames.remove(0);
for frame in sampled_frames {
sampled_frame = sampled_frame + frame;
}
sampled_frame
}
}
impl TimsData for TimsDatasetDIA {
fn get_frame(&self, frame_id: u32) -> TimsFrame {
self.loader.get_frame(frame_id)
}
fn get_raw_frame(&self, frame_id: u32) -> RawTimsFrame {
self.loader.get_raw_frame(frame_id)
}
fn get_slice(&self, frame_ids: Vec<u32>, num_threads: usize) -> TimsSlice {
self.loader.get_slice(frame_ids, num_threads)
}
fn get_acquisition_mode(&self) -> AcquisitionMode {
self.loader.get_acquisition_mode().clone()
}
fn get_frame_count(&self) -> i32 {
self.loader.get_frame_count()
}
fn get_data_path(&self) -> &str {
&self.loader.get_data_path()
}
}
impl IndexConverter for TimsDatasetDIA {
fn tof_to_mz(&self, frame_id: u32, tof_values: &Vec<u32>) -> Vec<f64> {
self.loader
.get_index_converter()
.tof_to_mz(frame_id, tof_values)
}
fn mz_to_tof(&self, frame_id: u32, mz_values: &Vec<f64>) -> Vec<u32> {
self.loader
.get_index_converter()
.mz_to_tof(frame_id, mz_values)
}
fn scan_to_inverse_mobility(&self, frame_id: u32, scan_values: &Vec<u32>) -> Vec<f64> {
self.loader
.get_index_converter()
.scan_to_inverse_mobility(frame_id, scan_values)
}
fn inverse_mobility_to_scan(
&self,
frame_id: u32,
inverse_mobility_values: &Vec<f64>,
) -> Vec<u32> {
self.loader
.get_index_converter()
.inverse_mobility_to_scan(frame_id, inverse_mobility_values)
}
}