Struct MzSpectrum

pub struct MzSpectrum {
    pub mz: Vec<f64>,
    pub intensity: Vec<f64>,
}

Represents a mass spectrum with associated m/z values and intensities.

Fields

mz: Vec<f64>

intensity: Vec<f64>

Implementations

impl MzSpectrum

pub fn new(mz: Vec<f64>, intensity: Vec<f64>) -> Self

Constructs a new MzSpectrum.

Arguments

• mz - A vector of m/z values.
• intensity - A vector of intensity values corresponding to the m/z values.

Panics

Panics if the lengths of mz and intensity are not the same. (actually, it doesn’t at the moment, planning on adding this later)

Example

let spectrum = MzSpectrum::new(vec![100.0, 200.0], vec![10.0, 20.0]);
assert_eq!(spectrum.mz, vec![100.0, 200.0]);
assert_eq!(spectrum.intensity, vec![10.0, 20.0]);

pub fn filter_ranged( &self, mz_min: f64, mz_max: f64, intensity_min: f64, intensity_max: f64, ) -> Self

pub fn to_windows( &self, window_length: f64, overlapping: bool, min_peaks: usize, min_intensity: f64, ) -> BTreeMap<i32, MzSpectrum>

Splits the spectrum into a collection of windows based on m/z values.

This function divides the spectrum into smaller spectra (windows) based on a specified window length. Each window contains peaks from the original spectrum that fall within the m/z range of that window.

Arguments

• window_length: The size (in terms of m/z values) of each window.

• overlapping: If true, each window will overlap with its neighboring windows by half of the window_length. This means that a peak may belong to multiple windows. If false, windows do not overlap.

• min_peaks: The minimum number of peaks a window must have to be retained in the result.

• min_intensity: The minimum intensity value a window must have (in its highest intensity peak) to be retained in the result.

Returns

A BTreeMap where the keys represent the window indices and the values are the spectra (MzSpectrum) within those windows. Windows that do not meet the criteria of having at least min_peaks peaks or a highest intensity peak greater than or equal to min_intensity are discarded.

Example

let spectrum = MzSpectrum::new(vec![100.0, 101.0, 102.5, 103.0], vec![10.0, 20.0, 30.0, 40.0]);
let windowed_spectrum = spectrum.to_windows(1.0, false, 1, 10.0);
assert!(windowed_spectrum.contains_key(&100));
assert!(windowed_spectrum.contains_key(&102));

pub fn to_centroid( &self, baseline_noise_level: i32, sigma: f64, normalize: bool, ) -> MzSpectrum

pub fn from_collection(collection: Vec<MzSpectrum>) -> MzSpectrum

pub fn add_mz_noise_uniform(&self, ppm: f64, right_drag: bool) -> Self

pub fn add_mz_noise_normal(&self, ppm: f64) -> Self

Trait Implementations

impl Add for MzSpectrum

fn add(self, other: Self) -> MzSpectrum

Combines two MzSpectrum instances by summing up the intensities of matching m/z values.

Description

Each m/z value is quantized to retain at least 6 decimals. If two spectra have m/z values that quantize to the same integer value, their intensities are summed.

Example

let spectrum1 = MzSpectrum { mz: vec![100.523, 101.923], intensity: vec![10.0, 20.0] };
let spectrum2 = MzSpectrum { mz: vec![101.235, 105.112], intensity: vec![15.0, 30.0] };

let combined = spectrum1 + spectrum2;

assert_eq!(combined.mz, vec![100.523, 101.235, 101.923, 105.112]);
assert_eq!(combined.intensity, vec![10.0, 15.0, 20.0, 30.0]);

type Output = MzSpectrum

The resulting type after applying the + operator.

impl<'__de> BorrowDecode<'__de> for MzSpectrum

fn borrow_decode<__D: BorrowDecoder<'__de>>( decoder: &mut __D, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given BorrowDecode.

impl Clone for MzSpectrum

fn clone(&self) -> MzSpectrum

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MzSpectrum

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Decode for MzSpectrum

fn decode<__D: Decoder>(decoder: &mut __D) -> Result<Self, DecodeError>

Attempt to decode this type with the given Decode.

impl<'de> Deserialize<'de> for MzSpectrum

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for MzSpectrum

Formats the MzSpectrum for display.

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Encode for MzSpectrum

fn encode<__E: Encoder>(&self, encoder: &mut __E) -> Result<(), EncodeError>

Encode a given type.

impl Mul<f64> for MzSpectrum

type Output = MzSpectrum

The resulting type after applying the * operator.

fn mul(self, scale: f64) -> Self::Output

Performs the * operation.

impl Serialize for MzSpectrum

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub for MzSpectrum

type Output = MzSpectrum

The resulting type after applying the - operator.

fn sub(self, other: Self) -> Self::Output

Performs the - operation.

impl ToResolution for MzSpectrum

fn to_resolution(&self, resolution: i32) -> Self

Bins the spectrum’s m/z values to a given resolution and sums the intensities.

Arguments

• resolution - The desired resolution in terms of decimal places. For instance, a resolution of 2 would bin m/z values to two decimal places.

Returns

A new MzSpectrum where m/z values are binned according to the given resolution.

Example

let spectrum = MzSpectrum::new(vec![100.123, 100.121, 100.131], vec![10.0, 20.0, 30.0]);
let binned_spectrum_1 = spectrum.to_resolution(1);
let binned_spectrum_2 = spectrum.to_resolution(2);
/// assert_eq!(binned_spectrum_2.mz, vec![100.1]);
assert_eq!(binned_spectrum_1.intensity, vec![60.0]);
assert_eq!(binned_spectrum_2.mz, vec![100.12, 100.13]);
assert_eq!(binned_spectrum_2.intensity, vec![30.0, 30.0]);

impl Vectorized<MzSpectrumVectorized> for MzSpectrum

fn vectorized(&self, resolution: i32) -> MzSpectrumVectorized

Convert the MzSpectrum to a MzSpectrumVectorized using the given resolution for binning.

After binning to the desired resolution, the binned m/z values are translated into integer indices.