Struct mzsignal::average::SignalAverager

pub struct SignalAverager<'lifespan> {
    pub mz_grid: Vec<f64>,
    pub mz_start: f64,
    pub mz_end: f64,
    pub dx: f64,
    pub array_pairs: VecDeque<ArrayPair<'lifespan>>,
}

A linear interpolation spectrum intensity averager over a shared m/z axis.

Fields

mz_grid: Vec<f64>

The evenly spaced m/z axis over which spectra are averaged.

mz_start: f64

The lowest m/z in the spectrum. If an input spectrum has lower m/z values, they will be ignored.

mz_end: f64

The highest m/z in the spectrum. If an input spectrum has higher m/z values, they will be ignored.

dx: f64

The spacing between m/z values in mz_grid. This value should be chosen relative to the sharpness of the peak shape of the mass analyzer used, but the smaller it is, the more computationally intensive the averaging process is, and the more memory it consumes.

array_pairs: VecDeque<ArrayPair<'lifespan>>

The current set of spectra to be averaged together. This uses a deque because the usecase of pushing spectra into an averaging window while removing them from the other side fits with the way one might average spectra over time.

Implementations

impl<'a, 'b: 'a> SignalAverager<'a>

pub fn new(mz_start: f64, mz_end: f64, dx: f64) -> SignalAverager<'a>

pub fn push(&mut self, pair: ArrayPair<'b>)

Put pair into the queue of arrays being averaged together.

pub fn pop(&mut self) -> Option<ArrayPair<'a>>

Remove the least recently added array pair from the queue.

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn interpolate_point( &self, mz_j: f64, mz_x: f64, mz_j1: f64, inten_j: f64, inten_j1: f64 ) -> f64

Linear interpolation between two control points to find the intensity at a third point between them.

Arguments

• mz_j - The first control point’s m/z
• mz_x - The interpolated m/z
• mz_j1 - The second control point’s m/z
• inten_j - The first control point’s intensity
• inten_j1 - The second control point’s intensity

pub fn interpolate_into( &self, out: &mut [f32], start_mz: f64, end_mz: f64 ) -> usize

A linear interpolation across all spectra between start_mz and end_mz, with their intensities written into out.

pub fn interpolate_chunks(&self, n_chunks: usize) -> Vec<f32>

pub fn interpolate(&'a self) -> Vec<f32>

Allocate a new intensity array, interpolate_into it, and return it.

Trait Implementations

impl<'lifespan> Clone for SignalAverager<'lifespan>

fn clone(&self) -> SignalAverager<'lifespan>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'lifespan> Debug for SignalAverager<'lifespan>

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

Formats the value using the given formatter.

impl<'lifespan> Default for SignalAverager<'lifespan>

fn default() -> SignalAverager<'lifespan>

Returns the “default value” for a type.

impl<'lifespan> Extend<ArrayPair<'lifespan>> for SignalAverager<'lifespan>

fn extend<T: IntoIterator<Item = ArrayPair<'lifespan>>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'lifespan> MZGrid for SignalAverager<'lifespan>

fn mz_grid(&self) -> &[f64]

fn create_intensity_array(&self) -> Vec<f32>

fn create_intensity_array_of_size(&self, size: usize) -> Vec<f32>

fn find_offset(&self, mz: f64) -> usize

fn points_between(&self, start_mz: f64, end_mz: f64) -> usize

fn copy_mz_array(&self) -> Vec<f64>