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}