ionic/ion/decoder/utilities/
spectrum_source.rs1use crate::{
2 accessions as acc_const,
3 ion::attr_meta::parse_accession_tail,
4 mzml::structs::{CvParam, MzML, NumericArray, Spectrum},
5};
6
7#[inline]
8fn acc(s: Option<&str>) -> u32 {
9 parse_accession_tail(s).raw()
10}
11
12#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13pub enum TimeUnit {
14 Second,
15 Minute,
16 Millisecond,
17 Other,
18}
19
20impl TimeUnit {
21 pub(crate) fn code(self) -> u8 {
22 match self {
23 TimeUnit::Other => 0,
24 TimeUnit::Second => 1,
25 TimeUnit::Minute => 2,
26 TimeUnit::Millisecond => 3,
27 }
28 }
29
30 pub(crate) fn from_code(code: u8) -> Self {
31 match code {
32 1 => TimeUnit::Second,
33 2 => TimeUnit::Minute,
34 3 => TimeUnit::Millisecond,
35 _ => TimeUnit::Other,
36 }
37 }
38}
39
40#[derive(Debug, Clone, Copy)]
41pub struct ScanSummary {
42 pub rt: f64,
43 pub rt_unit: TimeUnit,
44 pub ms_level: u8,
45 pub polarity: u8,
46 pub selected_ion_mz: f64,
47 pub base_peak_mz: f64,
48 pub base_peak_int: f64,
49 pub total_ion_current: f64,
50 pub position_x: u32,
51 pub position_y: u32,
52 pub position_z: u32,
53}
54
55pub trait ScanSource {
56 fn for_each_summary(&mut self, callback: &mut dyn FnMut(usize, ScanSummary));
57 fn load_scan(&mut self, index: usize, mz: &mut Vec<f64>, intensity: &mut Vec<f64>) -> bool;
58
59 fn for_each_in_range<F>(&mut self, rt_min: f64, rt_max: f64, ms_level: u8, mut callback: F)
60 where
61 Self: Sized,
62 F: FnMut(&ScanSummary, &[f64], &[f64]),
63 {
64 let mut matching: Vec<(usize, ScanSummary)> = Vec::new();
65 self.for_each_summary(&mut |index, summary| {
66 if summary.rt >= rt_min
67 && summary.rt <= rt_max
68 && (ms_level == 0 || summary.ms_level == ms_level)
69 {
70 matching.push((index, summary));
71 }
72 });
73 let mut mz = Vec::new();
74 let mut intensity = Vec::new();
75 for (index, summary) in &matching {
76 if self.load_scan(*index, &mut mz, &mut intensity) {
77 callback(summary, &mz, &intensity);
78 }
79 }
80 }
81}
82
83impl ScanSource for MzML {
84 fn for_each_summary(&mut self, callback: &mut dyn FnMut(usize, ScanSummary)) {
85 let Some(list) = self.run.spectrum_list.as_ref() else {
86 return;
87 };
88 summary_from_spectra(&list.spectra, callback);
89 }
90
91 fn load_scan(&mut self, index: usize, mz: &mut Vec<f64>, intensity: &mut Vec<f64>) -> bool {
92 let spectra = self
93 .run
94 .spectrum_list
95 .as_ref()
96 .map(|l| l.spectra.as_slice())
97 .unwrap_or_default();
98 load_scan_from_spectra(spectra, index, mz, intensity)
99 }
100
101 fn for_each_in_range<F>(&mut self, rt_min: f64, rt_max: f64, ms_level: u8, mut callback: F)
102 where
103 Self: Sized,
104 F: FnMut(&ScanSummary, &[f64], &[f64]),
105 {
106 let spectra = self
107 .run
108 .spectrum_list
109 .as_ref()
110 .map(|l| l.spectra.as_slice())
111 .unwrap_or_default();
112 let mut mz = Vec::new();
113 let mut intensity = Vec::new();
114 for (index, spectrum) in spectra.iter().enumerate() {
115 let summary = summary_from_spectrum(spectrum);
116 if summary.rt < rt_min
117 || summary.rt > rt_max
118 || (ms_level != 0 && summary.ms_level != ms_level)
119 {
120 continue;
121 }
122 if load_scan_from_spectra(spectra, index, &mut mz, &mut intensity) {
123 callback(&summary, &mz, &intensity);
124 }
125 }
126 }
127}
128
129pub(crate) fn summary_from_spectrum(spectrum: &Spectrum) -> ScanSummary {
130 let mut rt = f64::NAN;
131 let mut rt_unit = TimeUnit::Other;
132 let mut ms_level = spectrum
133 .ms_level
134 .and_then(|level| u8::try_from(level).ok())
135 .unwrap_or(0);
136 let mut polarity = 0u8;
137 let mut base_peak_mz = f64::NAN;
138 let mut base_peak_int = f64::NAN;
139 let mut total_ion_current = f64::NAN;
140
141 for param in &spectrum.cv_params {
142 match acc(param.accession.as_deref()) {
143 acc_const::MS_LEVEL => {
144 if let Some(value) = param.value.as_deref().and_then(|v| v.parse().ok()) {
145 ms_level = value;
146 }
147 }
148 acc_const::BASE_PEAK_MZ => base_peak_mz = parse_f64(param.value.as_deref()),
149 acc_const::BASE_PEAK_INT => base_peak_int = parse_f64(param.value.as_deref()),
150 acc_const::TOTAL_ION_CURRENT => total_ion_current = parse_f64(param.value.as_deref()),
151 acc_const::POSITIVE_SCAN => polarity = 1,
152 acc_const::NEGATIVE_SCAN => polarity = 2,
153 _ => {}
154 }
155 }
156
157 let scan_list = spectrum.scan_list.as_ref().or_else(|| {
158 spectrum
159 .spectrum_description
160 .as_ref()
161 .and_then(|d| d.scan_list.as_ref())
162 });
163
164 'find_rt: {
165 let Some(scan_list) = scan_list else {
166 break 'find_rt;
167 };
168 for scan in &scan_list.scans {
169 if let Some((value, unit)) = rt_from_params(&scan.cv_params) {
170 rt = value;
171 rt_unit = unit;
172 break 'find_rt;
173 }
174 }
175 if let Some((value, unit)) = rt_from_params(&scan_list.cv_params) {
176 rt = value;
177 rt_unit = unit;
178 }
179 }
180
181 let mut position_x = 0u32;
182 let mut position_y = 0u32;
183 let mut position_z = 0u32;
184 if let Some(scan_list) = scan_list {
185 for scan in &scan_list.scans {
186 for param in &scan.cv_params {
187 match acc(param.accession.as_deref()) {
188 acc_const::POSITION_X => position_x = parse_u32(param.value.as_deref()),
189 acc_const::POSITION_Y => position_y = parse_u32(param.value.as_deref()),
190 acc_const::POSITION_Z => position_z = parse_u32(param.value.as_deref()),
191 _ => {}
192 }
193 }
194 }
195 }
196
197 let selected_ion_mz = spectrum
198 .precursor_list
199 .as_ref()
200 .and_then(|precursor_list| precursor_list.precursors.first())
201 .and_then(|precursor| precursor.selected_ion_list.as_ref())
202 .and_then(|selected_ion_list| selected_ion_list.selected_ions.first())
203 .map(|selected_ion| {
204 selected_ion
205 .cv_params
206 .iter()
207 .find(|param| acc(param.accession.as_deref()) == acc_const::SELECTED_ION_MZ)
208 .and_then(|param| param.value.as_deref()?.parse().ok())
209 .unwrap_or(f64::NAN)
210 })
211 .unwrap_or(f64::NAN);
212
213 ScanSummary {
214 rt,
215 rt_unit,
216 ms_level,
217 polarity,
218 base_peak_mz,
219 base_peak_int,
220 total_ion_current,
221 selected_ion_mz,
222 position_x,
223 position_y,
224 position_z,
225 }
226}
227
228pub(crate) fn summary_from_spectra(
229 spectra: &[Spectrum],
230 callback: &mut dyn FnMut(usize, ScanSummary),
231) {
232 for (index, spectrum) in spectra.iter().enumerate() {
233 callback(index, summary_from_spectrum(spectrum));
234 }
235}
236
237#[inline]
238fn rt_from_params(params: &[CvParam]) -> Option<(f64, TimeUnit)> {
239 for param in params {
240 if acc(param.accession.as_deref()) == acc_const::SCAN_START_TIME {
241 let value: f64 = param.value.as_deref()?.parse().ok()?;
242 if !value.is_finite() {
243 return None;
244 }
245 let unit = time_unit_from(param.unit_accession.as_deref(), param.unit_name.as_deref());
246 return Some((value, unit));
247 }
248 }
249 None
250}
251
252fn time_unit_from(unit_accession: Option<&str>, unit_name: Option<&str>) -> TimeUnit {
253 match acc(unit_accession) {
254 acc_const::UNIT_MINUTE => TimeUnit::Minute,
255 acc_const::UNIT_SECOND => TimeUnit::Second,
256 acc_const::UNIT_MS => TimeUnit::Millisecond,
257 _ => match unit_name {
258 Some("minute" | "minutes") => TimeUnit::Minute,
259 Some("second" | "seconds") => TimeUnit::Second,
260 Some("millisecond" | "milliseconds") => TimeUnit::Millisecond,
261 _ => TimeUnit::Other,
262 },
263 }
264}
265
266#[inline]
267fn parse_f64(s: Option<&str>) -> f64 {
268 s.and_then(|v| v.parse().ok()).unwrap_or(f64::NAN)
269}
270
271#[inline]
272fn parse_u32(s: Option<&str>) -> u32 {
273 s.and_then(|v| v.parse().ok()).unwrap_or(0)
274}
275
276pub(crate) fn binary_pair(spectrum: &Spectrum) -> Option<(&NumericArray, &NumericArray)> {
277 let list = spectrum.binary_data_array_list.as_ref()?;
278 let mut mz = None;
279 let mut intensity = None;
280 for array in &list.binary_data_arrays {
281 if mz.is_some() && intensity.is_some() {
282 break;
283 }
284 let mut is_mz = false;
285 let mut is_intensity = false;
286 for param in &array.cv_params {
287 match acc(param.accession.as_deref()) {
288 acc_const::MZ_ARRAY => is_mz = true,
289 acc_const::INTENSITY_ARRAY => is_intensity = true,
290 _ => {}
291 }
292 if is_mz && is_intensity {
293 break;
294 }
295 }
296 if is_mz {
297 mz = array.binary.as_ref();
298 }
299 if is_intensity {
300 intensity = array.binary.as_ref();
301 }
302 }
303 Some((mz?, intensity?))
304}
305
306pub(crate) fn load_scan_from_spectra(
307 spectra: &[Spectrum],
308 index: usize,
309 mz: &mut Vec<f64>,
310 intensity: &mut Vec<f64>,
311) -> bool {
312 let Some(spectrum) = spectra.get(index) else {
313 return false;
314 };
315 let Some((mz_data, int_data)) = binary_pair(spectrum) else {
316 return false;
317 };
318 let len = mz_data.len().min(int_data.len());
319 if len == 0 {
320 return false;
321 }
322 mz.clear();
323 mz.reserve(len);
324 extend_from_binary(mz_data, mz, len);
325 intensity.clear();
326 intensity.reserve(len);
327 extend_from_binary(int_data, intensity, len);
328 true
329}
330
331fn extend_from_binary(data: &NumericArray, out: &mut Vec<f64>, max: usize) {
332 match data {
333 NumericArray::F64(v) => out.extend_from_slice(&v[..max]),
334 NumericArray::F32(v) => out.extend(v[..max].iter().map(|&x| x as f64)),
335 NumericArray::I16(v) => out.extend(v[..max].iter().map(|&x| x as f64)),
336 NumericArray::I32(v) => out.extend(v[..max].iter().map(|&x| x as f64)),
337 NumericArray::I64(v) => out.extend(v[..max].iter().map(|&x| x as f64)),
338 NumericArray::F16(v) => out.extend(v[..max].iter().copied().map(f16_bits_to_f64)),
339 }
340}
341
342pub(crate) fn f16_bits_to_f64(bits: u16) -> f64 {
343 let sign = ((bits & 0x8000) as u32) << 16;
344 let exp = (bits & 0x7C00) >> 10;
345 let mant = (bits & 0x03FF) as u32;
346 let bits32 = match exp {
347 0 if mant == 0 => sign,
348 0 => {
349 let mut mantissa = mant;
350 let mut exponent_shift = 0u32;
351 while mantissa & 0x400 == 0 {
352 mantissa <<= 1;
353 exponent_shift += 1;
354 }
355 sign | ((127 - 14 - exponent_shift) << 23) | ((mantissa & 0x03FF) << 13)
356 }
357 31 => sign | 0x7F80_0000 | (mant << 13),
358 exponent => sign | ((exponent as u32 + 112) << 23) | (mant << 13),
359 };
360 f32::from_bits(bits32) as f64
361}