Skip to main content

ionic/ion/decoder/utilities/
spectrum_source.rs

1use 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}