Trait SpectrumGrouping 

pub trait SpectrumGrouping<C = CentroidPeak, D = DeconvolutedPeak, S = MultiLayerSpectrum<C, D>>: Default
where
    C: CentroidLike,
    D: DeconvolutedCentroidLike,
    S: SpectrumLike<C, D>,
{
    // Required methods
    fn precursor(&self) -> Option<&S>;
    fn precursor_mut(&mut self) -> Option<&mut S>;
    fn set_precursor(&mut self, prec: S);
    fn products(&self) -> &[S];
    fn products_mut(&mut self) -> &mut Vec<S>;
    fn into_parts(self) -> (Option<S>, Vec<S>);

    // Provided methods
    fn total_spectra(&self) -> usize { ... }
    fn earliest_spectrum(&self) -> Option<&S> { ... }
    fn latest_spectrum(&self) -> Option<&S> { ... }
    fn lowest_ms_level(&self) -> Option<u8> { ... }
    fn highest_ms_level(&self) -> Option<u8> { ... }
}

An abstraction over SpectrumGroup’s interface.

Required Methods

fn precursor(&self) -> Option<&S>

Get the precursor spectrum, which may be absent

fn precursor_mut(&mut self) -> Option<&mut S>

Get a mutable reference to the precursor spectrum, which may be absent

fn set_precursor(&mut self, prec: S)

Explicitly set the precursor spectrum directly.

fn products(&self) -> &[S]

Get a reference to the collection of product spectra

fn products_mut(&mut self) -> &mut Vec<S>

Get a mutable reference to the collection of product spectra

fn into_parts(self) -> (Option<S>, Vec<S>)

Decompose the group into its components, discarding any additional metrics

Provided Methods

fn total_spectra(&self) -> usize

The total number of spectra in the group

fn earliest_spectrum(&self) -> Option<&S>

The spectrum that occurred first chronologically

Examples found in repository

examples/msn_target_mapping.rs (line 157)

    fn initial_feed(&mut self) {
        let group = self.source.next();
        let start_time = group
            .as_ref()
            .and_then(|s| s.earliest_spectrum().map(|s| s.start_time()))
            .unwrap();
        let end_time = start_time + self.time_width;
        eprintln!("Initial time window {start_time} to {end_time}");
        if let Some(g) = group {
            self.observe(&g);
            self.buffer.push_back((g, start_time));
        }
        while let Some(group) = self.source.next() {
            let t = group.earliest_spectrum().map(|s| s.start_time()).unwrap();
            if t < end_time {
                self.observe(&group);
                self.buffer.push_back((group, t));
            } else {
                self.pushback_buffer = Some((group, t));
                break;
            }
        }
        eprintln!(
            "{} targets extracted from buffer size {}",
            self.targets.len(),
            self.buffer.len()
        );
    }

    fn get_current_window_end(&self) -> f64 {
        if self.buffer.is_empty() {
            return f64::NEG_INFINITY;
        }
        let start = self.buffer.front().map(|(_, t)| *t).unwrap();
        let end = self.buffer.back().map(|(_, t)| *t).unwrap();
        let mid = start + (end - start) / 2.0;
        mid + self.time_width
    }

    fn feed_next(&mut self) {
        let threshold = self.get_current_window_end();
        let (use_pushback, pushback_populated) = if let Some((_, t)) = self.pushback_buffer.as_ref()
        {
            (*t < threshold, true)
        } else {
            (false, false)
        };
        if use_pushback {
            let (group, t) = self.pushback_buffer.take().unwrap();
            self.observe(&group);
            self.buffer.push_back((group, t));
        }
        if !pushback_populated {
            if let Some(group) = self.source.next() {
                let t = group.earliest_spectrum().map(|s| s.start_time()).unwrap();
                if t < threshold {
                    self.observe(&group);
                    self.buffer.push_back((group, t));
                } else {
                    self.pushback_buffer = Some((group, t));
                }
            }
        }
    }

examples/random_access_iter.rs (line 44)

fn main() -> io::Result<()> {
    let path = path::PathBuf::from(
        env::args()
            .nth(1)
            .expect("Please pass an MS data file path"),
        // "test/data/batching_test.mzML"
    );

    let mut reader = mzml::MzMLReader::open_path(path)?;

    let n_spectra = reader.len();

    // Find the spectrum at the midpoint of the run
    let spec = reader.get_spectrum_by_index(n_spectra / 2).unwrap();
    eprintln!(
        "Midpoint spectrum {} (level {}) at time {}",
        spec.id(),
        spec.ms_level(),
        spec.start_time()
    );

    // Jump the iterator to that point in time
    reader.start_from_time(spec.start_time())?;
    let s = reader.next().unwrap();
    eprintln!(
        "Resuming at {} (level {}) at time {}",
        s.id(),
        s.ms_level(),
        s.start_time()
    );

    // Convert the iterator into a group iterator
    let mut group_iter = reader.into_groups();
    // Jump the group iterator to that point in time (If an MSn spectrum was found, the next MS1 may be shown instead)
    group_iter.start_from_time(spec.start_time())?;
    let g = group_iter.next().unwrap();
    eprintln!(
        "Resuming at group having {:?} at time {:?}",
        g.earliest_spectrum().map(|s| s.id()),
        g.earliest_spectrum().map(|s| s.start_time())
    );

    // Convert the group iterator into an averaging group iterator
    let mut avg_iter = group_iter.averaging(1, 200.0, 2200.0, 0.005);
    // Jump the group iterator to that point in time (If an MSn spectrum was found, the next MS1 may be shown instead)
    avg_iter.start_from_time(spec.start_time())?;
    let g = avg_iter.next().unwrap();
    eprintln!(
        "Resuming at group having {:?} at time {:?}",
        g.earliest_spectrum().map(|s| s.id()),
        g.earliest_spectrum().map(|s| s.start_time())
    );

    Ok(())
}

fn latest_spectrum(&self) -> Option<&S>

The spectrum that occurred last chronologically

fn lowest_ms_level(&self) -> Option<u8>

The lowest MS level in the group. Returns None if the group is empty or the MS level is 0.

fn highest_ms_level(&self) -> Option<u8>

The highest MS level in the group. Returns None if the group is empty or the MS level is 0.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl<C, D, S> SpectrumGrouping<C, D, S> for SpectrumGroup<C, D, S>

where C: CentroidLike, D: DeconvolutedCentroidLike, S: SpectrumLike<C, D>,