Skip to main content

ionic/mzml/
structs.rs

1use serde::{Deserialize, Serialize};
2
3use crate::accessions::{
4    ACC_COMPRESSION_NONE, FLOAT_64BIT, INTENSITY_ARRAY, MZ_ARRAY, format_accession,
5};
6
7#[derive(Debug, Clone, Serialize, Deserialize, Default)]
8pub struct MzML {
9    pub cv_list: Option<CvList>,
10    pub file_description: Option<FileDescription>,
11    pub referenceable_param_group_list: Option<ReferenceableParamGroupList>,
12    pub sample_list: Option<SampleList>,
13    pub instrument_list: Option<InstrumentList>,
14    pub software_list: Option<SoftwareList>,
15    pub data_processing_list: Option<DataProcessingList>,
16    pub scan_settings_list: Option<ScanSettingsList>,
17    pub run: Run,
18}
19
20impl MzML {
21    pub fn from_spectra(spectra: Vec<Spectrum>) -> Self {
22        let count = spectra.len();
23        Self {
24            run: Run {
25                spectrum_list: Some(SpectrumList {
26                    count: Some(count),
27                    spectra,
28                    ..Default::default()
29                }),
30                ..Default::default()
31            },
32            ..Default::default()
33        }
34    }
35}
36
37#[derive(Debug, Clone, Serialize, Deserialize, Default)]
38pub struct CvList {
39    pub count: Option<usize>,
40    pub cv: Vec<CvEntry>,
41}
42
43#[derive(Debug, Clone, Serialize, Deserialize)]
44pub struct CvEntry {
45    pub id: String,
46    pub full_name: Option<String>,
47    pub version: Option<String>,
48    pub uri: Option<String>,
49}
50
51#[derive(Debug, Clone, Serialize, Deserialize)]
52pub struct IndexOffset {
53    pub id_ref: Option<String>,
54    pub offset: u64,
55}
56
57#[derive(Debug, Clone, Serialize, Deserialize)]
58pub struct IndexList {
59    pub spectrum: Vec<IndexOffset>,
60    pub chromatogram: Vec<IndexOffset>,
61    pub index_list_offset: Option<u64>,
62    pub file_checksum: Option<String>,
63}
64
65#[derive(Debug, Clone, Serialize, Deserialize)]
66pub struct IndexedmzML {
67    pub mzml: MzML,
68    pub index_list: IndexList,
69    pub index_list_offset: Option<u64>,
70    pub file_checksum: Option<String>,
71}
72
73#[derive(Debug, Clone, Serialize, Deserialize, Default)]
74pub struct CvParam {
75    pub cv_ref: Option<String>,
76    pub accession: Option<String>,
77    pub name: String,
78    pub value: Option<String>,
79    pub unit_cv_ref: Option<String>,
80    pub unit_name: Option<String>,
81    pub unit_accession: Option<String>,
82}
83
84#[derive(Debug, Clone, Serialize, Deserialize, Default)]
85pub struct UserParam {
86    pub name: String,
87    pub r#type: Option<String>,
88    pub unit_accession: Option<String>,
89    pub unit_cv_ref: Option<String>,
90    pub unit_name: Option<String>,
91    pub value: Option<String>,
92}
93
94#[derive(Debug, Clone, Serialize, Deserialize, Default)]
95pub struct ReferenceableParamGroupRef {
96    pub r#ref: String,
97}
98
99#[derive(Debug, Clone, Serialize, Deserialize, Default)]
100pub struct DataProcessingList {
101    pub count: Option<usize>,
102    pub data_processing: Vec<DataProcessing>,
103}
104
105#[derive(Debug, Clone, Serialize, Deserialize, Default)]
106pub struct DataProcessing {
107    pub id: String,
108    pub software_ref: Option<String>,
109    pub processing_method: Vec<ProcessingMethod>,
110}
111
112#[derive(Debug, Clone, Serialize, Deserialize, Default)]
113pub struct ProcessingMethod {
114    pub order: Option<u32>,
115    pub software_ref: Option<String>,
116    pub referenceable_param_group_ref: Vec<ReferenceableParamGroupRef>,
117    pub cv_param: Vec<CvParam>,
118    pub user_param: Vec<UserParam>,
119}
120
121#[derive(Debug, Clone, Serialize, Deserialize, Default)]
122pub struct FileDescription {
123    pub file_content: FileContent,
124    pub source_file_list: SourceFileList,
125    pub contacts: Vec<Contact>,
126}
127
128#[derive(Debug, Clone, Serialize, Deserialize, Default)]
129pub struct SourceFileList {
130    pub count: Option<usize>,
131    pub source_file: Vec<SourceFile>,
132}
133
134#[derive(Debug, Clone, Serialize, Deserialize, Default)]
135pub struct SourceFile {
136    pub id: String,
137    pub name: String,
138    pub location: String,
139    pub referenceable_param_group_ref: Vec<ReferenceableParamGroupRef>,
140    pub cv_param: Vec<CvParam>,
141    pub user_param: Vec<UserParam>,
142}
143
144#[derive(Debug, Clone, Serialize, Deserialize, Default)]
145pub struct FileContent {
146    pub referenceable_param_group_refs: Vec<ReferenceableParamGroupRef>,
147    pub cv_params: Vec<CvParam>,
148    pub user_params: Vec<UserParam>,
149}
150
151#[derive(Debug, Clone, Serialize, Deserialize, Default)]
152pub struct Contact {
153    pub referenceable_param_group_refs: Vec<ReferenceableParamGroupRef>,
154    pub cv_params: Vec<CvParam>,
155    pub user_params: Vec<UserParam>,
156}
157
158#[derive(Debug, Clone, Serialize, Deserialize, Default)]
159pub struct InstrumentList {
160    pub count: Option<usize>,
161    pub instrument: Vec<Instrument>,
162}
163
164#[derive(Debug, Clone, Serialize, Deserialize, Default)]
165pub struct Instrument {
166    pub id: String,
167    pub scan_settings_ref: Option<ScanSettingsRef>,
168    pub cv_param: Vec<CvParam>,
169    pub user_param: Vec<UserParam>,
170    pub referenceable_param_group_ref: Vec<ReferenceableParamGroupRef>,
171    pub component_list: Option<ComponentList>,
172    pub software_ref: Option<InstrumentSoftwareRef>,
173}
174
175#[derive(Debug, Clone, Serialize, Deserialize, Default)]
176pub struct ScanSettingsRef {
177    pub r#ref: String,
178}
179
180#[derive(Debug, Clone, Serialize, Deserialize, Default)]
181pub struct ComponentList {
182    pub count: Option<usize>,
183    pub source: Vec<Source>,
184    pub analyzer: Vec<Analyzer>,
185    pub detector: Vec<Detector>,
186}
187
188#[derive(Debug, Clone, Serialize, Deserialize, Default)]
189pub struct Source {
190    pub order: Option<u32>,
191    pub referenceable_param_group_ref: Vec<ReferenceableParamGroupRef>,
192    pub cv_param: Vec<CvParam>,
193    pub user_param: Vec<UserParam>,
194}
195
196#[derive(Debug, Clone, Serialize, Deserialize, Default)]
197pub struct Analyzer {
198    pub order: Option<u32>,
199    pub referenceable_param_group_ref: Vec<ReferenceableParamGroupRef>,
200    pub cv_param: Vec<CvParam>,
201    pub user_param: Vec<UserParam>,
202}
203
204#[derive(Debug, Clone, Serialize, Deserialize, Default)]
205pub struct Detector {
206    pub order: Option<u32>,
207    pub referenceable_param_group_ref: Vec<ReferenceableParamGroupRef>,
208    pub cv_param: Vec<CvParam>,
209    pub user_param: Vec<UserParam>,
210}
211
212#[derive(Debug, Clone, Serialize, Deserialize, Default)]
213pub struct InstrumentSoftwareRef {
214    pub r#ref: String,
215}
216
217#[derive(Debug, Clone, Serialize, Deserialize, Default)]
218pub struct ReferenceableParamGroupList {
219    pub count: Option<usize>,
220    pub referenceable_param_groups: Vec<ReferenceableParamGroup>,
221}
222
223#[derive(Debug, Clone, Serialize, Deserialize, Default)]
224pub struct ReferenceableParamGroup {
225    pub id: String,
226    pub cv_params: Vec<CvParam>,
227    pub user_params: Vec<UserParam>,
228}
229
230#[derive(Debug, Clone, Serialize, Deserialize, Default)]
231pub struct SampleList {
232    pub count: Option<u32>,
233    pub samples: Vec<Sample>,
234    pub cv_params: Vec<CvParam>,
235    pub user_params: Vec<UserParam>,
236}
237
238#[derive(Debug, Clone, Serialize, Deserialize, Default)]
239pub struct Sample {
240    pub id: String,
241    pub name: String,
242    pub referenceable_param_group_refs: Vec<ReferenceableParamGroupRef>,
243    pub cv_params: Vec<CvParam>,
244    pub user_params: Vec<UserParam>,
245}
246
247#[derive(Debug, Clone, Serialize, Deserialize, Default)]
248pub struct ScanSettingsList {
249    pub count: Option<usize>,
250    pub scan_settings: Vec<ScanSettings>,
251}
252
253#[derive(Debug, Clone, Serialize, Deserialize, Default)]
254pub struct ScanSettings {
255    pub id: Option<String>,
256    pub instrument_configuration_ref: Option<String>,
257    pub referenceable_param_group_refs: Vec<ReferenceableParamGroupRef>,
258    pub cv_params: Vec<CvParam>,
259    pub user_params: Vec<UserParam>,
260    pub source_file_ref_list: Option<SourceFileRefList>,
261    pub target_list: Option<TargetList>,
262}
263
264#[derive(Debug, Clone, Serialize, Deserialize, Default)]
265pub struct SourceFileRefList {
266    pub count: Option<usize>,
267    pub source_file_refs: Vec<SourceFileRef>,
268}
269
270#[derive(Debug, Clone, Serialize, Deserialize, Default)]
271pub struct SourceFileRef {
272    pub r#ref: String,
273}
274
275#[derive(Debug, Clone, Serialize, Deserialize, Default)]
276pub struct TargetList {
277    pub count: Option<usize>,
278    pub targets: Vec<Target>,
279}
280
281#[derive(Debug, Clone, Serialize, Deserialize, Default)]
282pub struct Target {
283    pub referenceable_param_group_refs: Vec<ReferenceableParamGroupRef>,
284    pub cv_params: Vec<CvParam>,
285    pub user_params: Vec<UserParam>,
286}
287
288#[derive(Debug, Clone, Serialize, Deserialize, Default)]
289pub struct SoftwareList {
290    pub count: Option<usize>,
291    pub software: Vec<Software>,
292}
293
294#[derive(Debug, Clone, Serialize, Deserialize, Default)]
295pub struct Software {
296    pub id: String,
297    pub version: Option<String>,
298    pub software_param: Vec<SoftwareParam>,
299    pub cv_param: Vec<CvParam>,
300    pub user_params: Vec<UserParam>,
301    pub referenceable_param_group_refs: Vec<ReferenceableParamGroupRef>,
302}
303
304#[derive(Debug, Clone, Serialize, Deserialize, Default)]
305pub struct SoftwareParam {
306    pub cv_ref: Option<String>,
307    pub accession: String,
308    pub name: String,
309    pub version: Option<String>,
310}
311
312#[derive(Debug, Clone, Serialize, Deserialize, Default)]
313pub struct Run {
314    pub id: String,
315    pub start_time_stamp: Option<String>,
316    pub default_instrument_configuration_ref: Option<String>,
317    pub default_source_file_ref: Option<String>,
318    pub sample_ref: Option<String>,
319
320    pub referenceable_param_group_refs: Vec<ReferenceableParamGroupRef>,
321    pub cv_params: Vec<CvParam>,
322    pub user_params: Vec<UserParam>,
323
324    pub source_file_ref_list: Option<SourceFileRefList>,
325    pub spectrum_list: Option<SpectrumList>,
326    pub chromatogram_list: Option<ChromatogramList>,
327}
328
329#[derive(Debug, Clone, Serialize, Deserialize, Default)]
330pub struct SpectrumList {
331    pub count: Option<usize>,
332    pub default_data_processing_ref: Option<String>,
333    pub spectra: Vec<Spectrum>,
334}
335
336#[derive(Debug, Clone, Serialize, Deserialize, Default)]
337pub struct SpectrumDescription {
338    pub referenceable_param_group_refs: Vec<ReferenceableParamGroupRef>,
339    pub cv_params: Vec<CvParam>,
340    pub user_params: Vec<UserParam>,
341
342    pub scan_list: Option<ScanList>,
343    pub precursor_list: Option<PrecursorList>,
344    pub product_list: Option<ProductList>,
345}
346
347#[derive(Debug, Clone, Serialize, Deserialize, Default)]
348pub struct ScanList {
349    pub count: Option<usize>,
350    pub cv_params: Vec<CvParam>,
351    pub user_params: Vec<UserParam>,
352    pub referenceable_param_group_refs: Vec<ReferenceableParamGroupRef>,
353    pub scans: Vec<Scan>,
354}
355
356#[derive(Debug, Clone, Serialize, Deserialize, Default)]
357pub struct Scan {
358    pub instrument_configuration_ref: Option<String>,
359    pub external_spectrum_id: Option<String>,
360    pub source_file_ref: Option<String>,
361    pub spectrum_ref: Option<String>,
362
363    pub referenceable_param_group_refs: Vec<ReferenceableParamGroupRef>,
364    pub cv_params: Vec<CvParam>,
365    pub user_params: Vec<UserParam>,
366
367    pub scan_window_list: Option<ScanWindowList>,
368}
369
370#[derive(Debug, Clone, Serialize, Deserialize, Default)]
371pub struct ScanWindowList {
372    pub count: Option<usize>,
373    pub scan_windows: Vec<ScanWindow>,
374}
375
376#[derive(Debug, Clone, Serialize, Deserialize, Default)]
377pub struct ScanWindow {
378    pub cv_params: Vec<CvParam>,
379    pub user_params: Vec<UserParam>,
380}
381
382#[derive(Debug, Clone, Serialize, Deserialize, Default)]
383pub struct PrecursorList {
384    pub count: Option<usize>,
385    pub cv_params: Vec<CvParam>,
386    pub user_params: Vec<UserParam>,
387    pub precursors: Vec<Precursor>,
388}
389
390#[derive(Debug, Clone, Serialize, Deserialize, Default)]
391pub struct Precursor {
392    pub spectrum_ref: Option<String>,
393    pub source_file_ref: Option<String>,
394    pub external_spectrum_id: Option<String>,
395
396    pub isolation_window: Option<IsolationWindow>,
397    pub selected_ion_list: Option<SelectedIonList>,
398    pub activation: Option<Activation>,
399}
400
401#[derive(Debug, Clone, Serialize, Deserialize, Default)]
402pub struct IsolationWindow {
403    pub referenceable_param_group_refs: Vec<ReferenceableParamGroupRef>,
404    pub cv_params: Vec<CvParam>,
405    pub user_params: Vec<UserParam>,
406}
407
408#[derive(Debug, Clone, Serialize, Deserialize, Default)]
409pub struct SelectedIonList {
410    pub count: Option<usize>,
411    pub selected_ions: Vec<SelectedIon>,
412}
413
414#[derive(Debug, Clone, Serialize, Deserialize, Default)]
415pub struct SelectedIon {
416    pub referenceable_param_group_refs: Vec<ReferenceableParamGroupRef>,
417    pub cv_params: Vec<CvParam>,
418    pub user_params: Vec<UserParam>,
419}
420
421#[derive(Debug, Clone, Serialize, Deserialize, Default)]
422pub struct Activation {
423    pub referenceable_param_group_refs: Vec<ReferenceableParamGroupRef>,
424    pub cv_params: Vec<CvParam>,
425    pub user_params: Vec<UserParam>,
426}
427
428#[derive(Debug, Clone, Serialize, Deserialize, Default)]
429pub struct ProductList {
430    pub count: Option<usize>,
431    pub products: Vec<Product>,
432    pub cv_params: Vec<CvParam>,
433    pub user_params: Vec<UserParam>,
434}
435
436#[derive(Debug, Clone, Serialize, Deserialize, Default)]
437pub struct Product {
438    pub spectrum_ref: Option<String>,
439    pub source_file_ref: Option<String>,
440    pub external_spectrum_id: Option<String>,
441    pub isolation_window: Option<IsolationWindow>,
442    pub cv_params: Vec<CvParam>,
443    pub user_params: Vec<UserParam>,
444}
445
446#[derive(Debug, Clone, Serialize, Deserialize, Default)]
447pub struct BinaryDataArrayList {
448    pub count: Option<usize>,
449    pub binary_data_arrays: Vec<BinaryDataArray>,
450}
451
452#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Copy, Eq)]
453#[serde(rename_all = "snake_case")]
454pub enum NumericType {
455    Float16,
456    Float32,
457    Float64,
458    Int64,
459    Int32,
460    Int16,
461}
462
463#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
464#[serde(untagged)]
465pub enum NumericArray {
466    F64(Vec<f64>),
467    F32(Vec<f32>),
468    F16(Vec<u16>),
469    I64(Vec<i64>),
470    I32(Vec<i32>),
471    I16(Vec<i16>),
472}
473
474impl NumericArray {
475    pub fn len(&self) -> usize {
476        match self {
477            Self::F64(v) => v.len(),
478            Self::F32(v) => v.len(),
479            Self::F16(v) => v.len(),
480            Self::I64(v) => v.len(),
481            Self::I32(v) => v.len(),
482            Self::I16(v) => v.len(),
483        }
484    }
485
486    pub fn is_empty(&self) -> bool {
487        self.len() == 0
488    }
489}
490
491#[derive(Debug, Clone, Serialize, Deserialize, Default)]
492pub struct BinaryDataArray {
493    pub array_length: Option<usize>,
494    pub encoded_length: Option<usize>,
495    pub data_processing_ref: Option<String>,
496
497    pub referenceable_param_group_refs: Vec<ReferenceableParamGroupRef>,
498    pub cv_params: Vec<CvParam>,
499    pub user_params: Vec<UserParam>,
500
501    pub numeric_type: Option<NumericType>,
502    pub binary: Option<NumericArray>,
503
504    #[serde(skip)]
505    pub pending_base64: Option<Vec<u8>>,
506    #[serde(skip)]
507    pub pending_zlib: bool,
508}
509
510#[derive(Debug, Clone, Serialize, Deserialize, Default)]
511pub struct ChromatogramList {
512    pub count: Option<usize>,
513    pub default_data_processing_ref: Option<String>,
514    pub chromatograms: Vec<Chromatogram>,
515}
516
517#[derive(Debug, Clone, Serialize, Deserialize, Default)]
518pub struct Chromatogram {
519    pub id: String,
520    pub native_id: Option<String>,
521    pub index: Option<u32>,
522    pub default_array_length: Option<usize>,
523    pub data_processing_ref: Option<String>,
524
525    pub referenceable_param_group_refs: Vec<ReferenceableParamGroupRef>,
526    pub cv_params: Vec<CvParam>,
527    pub user_params: Vec<UserParam>,
528
529    pub precursor: Option<Precursor>,
530    pub product: Option<Product>,
531
532    pub binary_data_array_list: Option<BinaryDataArrayList>,
533}
534
535#[derive(Debug, Clone, Serialize, Deserialize, Default)]
536pub struct Spectrum {
537    pub id: String,
538    pub index: Option<u32>,
539    pub scan_number: Option<u32>,
540    pub default_array_length: Option<usize>,
541    pub native_id: Option<String>,
542    pub data_processing_ref: Option<String>,
543    pub source_file_ref: Option<String>,
544    pub spot_id: Option<String>,
545    pub ms_level: Option<u32>,
546
547    pub referenceable_param_group_refs: Vec<ReferenceableParamGroupRef>,
548    pub cv_params: Vec<CvParam>,
549    pub user_params: Vec<UserParam>,
550
551    pub spectrum_description: Option<SpectrumDescription>,
552
553    pub scan_list: Option<ScanList>,
554    pub precursor_list: Option<PrecursorList>,
555    pub product_list: Option<ProductList>,
556    pub binary_data_array_list: Option<BinaryDataArrayList>,
557}
558
559impl Spectrum {
560    pub fn new(id: impl Into<String>, mz: Vec<f64>, intensity: Vec<f64>) -> Self {
561        let default_array_length = mz.len();
562        let mz_array = float64_array(MZ_ARRAY, "m/z array", mz);
563        let intensity_array = float64_array(INTENSITY_ARRAY, "intensity array", intensity);
564        Self {
565            id: id.into(),
566            default_array_length: Some(default_array_length),
567            binary_data_array_list: Some(BinaryDataArrayList {
568                count: Some(2),
569                binary_data_arrays: vec![mz_array, intensity_array],
570            }),
571            ..Default::default()
572        }
573    }
574}
575
576fn float64_array(accession_tail: u32, name: &str, values: Vec<f64>) -> BinaryDataArray {
577    BinaryDataArray {
578        array_length: Some(values.len()),
579        numeric_type: Some(NumericType::Float64),
580        cv_params: vec![
581            CvParam {
582                cv_ref: Some("MS".to_string()),
583                accession: Some(format_accession(accession_tail)),
584                name: name.to_string(),
585                ..Default::default()
586            },
587            CvParam {
588                cv_ref: Some("MS".to_string()),
589                accession: Some(format_accession(FLOAT_64BIT)),
590                name: "64-bit float".to_string(),
591                ..Default::default()
592            },
593            CvParam {
594                cv_ref: Some("MS".to_string()),
595                accession: Some(ACC_COMPRESSION_NONE.to_string()),
596                name: "no compression".to_string(),
597                ..Default::default()
598            },
599        ],
600        binary: Some(NumericArray::F64(values)),
601        ..Default::default()
602    }
603}