mzdata 0.58.2

A library to read mass spectrometry data formats and a data model for mass spectra
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

# Writing mass spectrometry data files with `mzdata`


## Table of contents

- [Writing mass spectrometry data files with `mzdata`](#writing-mass-spectrometry-data-files-with-mzdata)
  - [Table of contents](#table-of-contents)
  - [Creating a `SpectrumWriter`](#creating-a-spectrumwriter)
  - [Copying across metadata](#copying-across-metadata)
  - [Writing spectra](#writing-spectra)

## Creating a `SpectrumWriter`


`mzdata` uses the [`SpectrumWriter`] trait to define shared writing behavior across different
data file formats. The [`MzMLWriter`] type writes spectra to mzML files, and [`MGFWriter`] writes
spectra to MGF files, though other formats may be available as well. [`SpectrumWriter`] is agnostic
to the thing being written to, and [`MzMLWriter`] and [`MGFWriter`] can accept an arbitrary [`Write`]
implementation, though not all implementations are.

```rust
use std::{io, fs};

use mzdata::io::MzMLWriter;
use mzdata::prelude::*;

fn main() -> io::Result<()> {
    let fh = io::BufWriter::new(fs::File::create("tmp.mzML")?);
    let mut writer = MzMLWriter::new(fh);

    Ok(())
}
```

## Copying across metadata


If you have a source which implements [`MSDataFileMetadata`], you can easily copy metadata from your
source file to your output file, preserving the trace of information about where your data came from.

```rust
use std::{io, fs};

use mzdata::io::MzMLWriter;
use mzdata::prelude::*;

fn main() -> io::Result<()> {
    let reader = mzdata::MZReader::open_path("test/data/batching_test.mzML")?;

    let fh = io::BufWriter::new(fs::File::create("tmp.mzML")?);
    let mut writer = MzMLWriter::new(fh);

    writer.copy_metadata_from(&reader);

    // mzML files want to list how many spectra they contain
    if let Some(n_spectra) = reader.spectrum_count_hint() {
        writer.set_spectrum_count(n_spectra)
    } else {
        writer.set_spectrum_count(reader.len() as u64)
    }

    Ok(())
}
```

## Writing spectra


```rust
# use std::{io, fs};

# use mzdata::io::MzMLWriter;

# use mzdata::prelude::*;
#
#
# fn main() -> io::Result<()> {
#     let reader = mzdata::MZReader::open_path("test/data/batching_test.mzML")?;
#
#     let fh = io::BufWriter::new(fs::File::create("tmp.mzML")?);
#     let mut writer = MzMLWriter::new(fh);
#
#     writer.copy_metadata_from(&reader);
#
#     // mzML files want to list how many spectra they contain
#     if let Some(n_spectra) = reader.spectrum_count_hint() {
#         writer.set_spectrum_count(n_spectra)
#     } else {
#         writer.set_spectrum_count(reader.len() as u64)
#     }
#
    // Write spectra out one at a time, by reference
    for spec in reader {
        writer.write(&spec)?;
    }
#    Ok(())
# }
```

```rust
# use std::{io, fs};
# use mzdata::io::MzMLWriter;
# use mzdata::prelude::*;
#
#
# fn main() -> io::Result<()> {
#     let reader = mzdata::MZReader::open_path("test/data/batching_test.mzML")?;
#
#     let fh = io::BufWriter::new(fs::File::create("tmp.mzML")?);
#     let mut writer = MzMLWriter::new(fh);
#
#     writer.copy_metadata_from(&reader);
#
#     // mzML files want to list how many spectra they contain
#     if let Some(n_spectra) = reader.spectrum_count_hint() {
#         writer.set_spectrum_count(n_spectra)
#     } else {
#         writer.set_spectrum_count(reader.len() as u64)
#     }
#
    // Write out an iterator over spectra, in this case
    // using the owning variant for an iterator over owned
    // instances.
    writer.write_all_owned(reader)?;
#    Ok(())
# }
```