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}