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