Trait SpectrumSource 

pub trait SpectrumSource<C: CentroidLike = CentroidPeak, D: DeconvolutedCentroidLike = DeconvolutedPeak, S: SpectrumLike<C, D> = MultiLayerSpectrum<C, D>>: Iterator<Item = S> {
    // Required methods
    fn reset(&mut self);
    fn detail_level(&self) -> &DetailLevel;
    fn set_detail_level(&mut self, detail_level: DetailLevel);
    fn get_spectrum_by_id(&mut self, id: &str) -> Option<S>;
    fn get_spectrum_by_index(&mut self, index: usize) -> Option<S>;
    fn get_index(&self) -> &OffsetIndex;
    fn set_index(&mut self, index: OffsetIndex);

    // Provided methods
    fn get_spectrum_by_time(&mut self, time: f64) -> Option<S> { ... }
    fn len(&self) -> usize { ... }
    fn is_empty(&self) -> bool { ... }
    fn _offset_of_id(&self, id: &str) -> Option<u64> { ... }
    fn _offset_of_index(&self, index: usize) -> Option<u64> { ... }
    fn _offset_of_time(&mut self, time: f64) -> Option<u64> { ... }
    fn iter(&mut self) -> SpectrumIterator<'_, C, D, S, Self> 
       where Self: Sized { ... }
    fn get_group_by_index(
        &mut self,
        index: usize,
    ) -> Option<SpectrumGroup<C, D, S>>
       where Self: Sized { ... }
    fn groups(
        &mut self,
    ) -> SpectrumGroupingIterator<SpectrumIterator<'_, C, D, S, Self>, C, D, S> 
       where Self: Sized { ... }
    fn into_groups(self) -> SpectrumGroupingIterator<Self, C, D, S> 
       where Self: Sized { ... }
}

A base trait defining the behaviors of a source of spectra.

A SpectrumSource is the basis for many data access methods in mzdata.

Required Methods

fn reset(&mut self)

Rewind the current position of the source to the beginning

fn detail_level(&self) -> &DetailLevel

Get the DetailLevel the reader currently uses

fn set_detail_level(&mut self, detail_level: DetailLevel)

Set the DetailLevel for the reader, changing the amount of work done immediately on loading a spectrum.

Note

Not all readers support all detail levels, and the behavior when requesting one of those levels will depend upon the underlying reader.

fn get_spectrum_by_id(&mut self, id: &str) -> Option<S>

Retrieve a spectrum by it’s native ID

fn get_spectrum_by_index(&mut self, index: usize) -> Option<S>

Retrieve a spectrum by it’s integer index

fn get_index(&self) -> &OffsetIndex

Access the spectrum offset index to enumerate all spectra by ID

fn set_index(&mut self, index: OffsetIndex)

Set the spectrum offset index. This method shouldn’t be needed if not writing a new adapter

Provided Methods

fn get_spectrum_by_time(&mut self, time: f64) -> Option<S>

Retrieve a spectrum by its scan start time Considerably more complex than seeking by ID or index, this involves a binary search over the spectrum index and assumes that spectra are stored in chronological order.

Examples found in repository

examples/get_scan_by.rs (line 29)

fn main() -> io::Result<()> {
    env_logger::init();
    let mut args = env::args().skip(1);

    let path = path::PathBuf::from(args.next().expect("Please pass an MS data file path"));

    let key = args
        .next()
        .expect("Please provide a key type, \"id\", \"index\" or \"time\"");
    let key_value = args
        .next()
        .expect("Please provide a key value matching the key type");

    info!("Opening {}", path.display());
    let mut reader = MZReader::open_path(path)?;
    info!("{} spectra detected", reader.len());
    let spectrum = match key.as_str() {
        "id" => reader.get_spectrum_by_id(&key_value).unwrap(),
        "index" => reader
            .get_spectrum_by_index(key_value.parse().unwrap())
            .unwrap(),
        "time" => reader
            .get_spectrum_by_time(key_value.parse().unwrap())
            .unwrap(),
        _ => {
            panic!("Unknown key type {}", key);
        }
    };

    // dbg!(spectrum);
    println!(
        "ID: {}; Index: {}; Time: {}",
        spectrum.id(),
        spectrum.index(),
        spectrum.start_time()
    );
    println!(
        "Num data points: {}",
        spectrum
            .raw_arrays()
            .and_then(|r| Some(r.mzs().ok()?.len()))
            .unwrap_or_default()
    );
    if spectrum.signal_continuity().is_centroid() && spectrum.raw_arrays().is_none() {
        println!("Num peaks: {}", spectrum.peaks().len());
    }
    Ok(())
}

fn len(&self) -> usize

Retrieve the number of spectra in source file, usually by getting the length of the index. If the index isn’t initialized, this will be 0.

Examples found in repository

examples/get_scan_by.rs (line 22)

fn main() -> io::Result<()> {
    env_logger::init();
    let mut args = env::args().skip(1);

    let path = path::PathBuf::from(args.next().expect("Please pass an MS data file path"));

    let key = args
        .next()
        .expect("Please provide a key type, \"id\", \"index\" or \"time\"");
    let key_value = args
        .next()
        .expect("Please provide a key value matching the key type");

    info!("Opening {}", path.display());
    let mut reader = MZReader::open_path(path)?;
    info!("{} spectra detected", reader.len());
    let spectrum = match key.as_str() {
        "id" => reader.get_spectrum_by_id(&key_value).unwrap(),
        "index" => reader
            .get_spectrum_by_index(key_value.parse().unwrap())
            .unwrap(),
        "time" => reader
            .get_spectrum_by_time(key_value.parse().unwrap())
            .unwrap(),
        _ => {
            panic!("Unknown key type {}", key);
        }
    };

    // dbg!(spectrum);
    println!(
        "ID: {}; Index: {}; Time: {}",
        spectrum.id(),
        spectrum.index(),
        spectrum.start_time()
    );
    println!(
        "Num data points: {}",
        spectrum
            .raw_arrays()
            .and_then(|r| Some(r.mzs().ok()?.len()))
            .unwrap_or_default()
    );
    if spectrum.signal_continuity().is_centroid() && spectrum.raw_arrays().is_none() {
        println!("Num peaks: {}", spectrum.peaks().len());
    }
    Ok(())
}

examples/random_access_iter.rs (line 16)

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 is_empty(&self) -> bool

fn _offset_of_id(&self, id: &str) -> Option<u64>

Helper method to support seeking to an ID

fn _offset_of_index(&self, index: usize) -> Option<u64>

Helper method to support seeking to an index

fn _offset_of_time(&mut self, time: f64) -> Option<u64>

Helper method to support seeking to a specific time. Considerably more complex than seeking by ID or index.

fn iter(&mut self) -> SpectrumIterator<'_, C, D, S, Self>

where Self: Sized,

Open a new iterator over this stream

fn get_group_by_index(&mut self, index: usize) -> Option<SpectrumGroup<C, D, S>>

where Self: Sized,

Get the nth SpectrumGroup from this source

fn groups( &mut self, ) -> SpectrumGroupingIterator<SpectrumIterator<'_, C, D, S, Self>, C, D, S>

where Self: Sized,

Create a new SpectrumIterator over self and use that state to drive a SpectrumGroupingIterator

Examples found in repository

examples/averaging_writer.rs (line 38)

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

    let mut reader = MZReader::open_path(path)?;
    let mut writer = MzMLWriter::new(io::BufWriter::new(io::stdout()));
    writer.copy_metadata_from(&reader);

    let (input_sender, input_receiver) = sync_channel(5000);
    let (output_sender, output_receiver) = sync_channel(5000);

    let start = Instant::now();
    let reader_task = thread::spawn(move || {
        let (grouper, averager, _reprofiler) =
            reader.groups().averaging_deferred(1, 120.0, 2000.1, 0.002);
        grouper
            .enumerate()
            .par_bridge()
            .map_init(
                || averager.clone(),
                |averager, (i, g)| {
                    let (mut g, arrays) = g.average_with(averager);
                    if let Some(p) = g.precursor_mut() {
                        p.arrays = Some(arrays.into());
                        p.description_mut().signal_continuity = SignalContinuity::Profile;
                    }
                    (i, g)
                },
            )
            .for_each(|(i, g)| {
                input_sender.send((i, g)).unwrap();
            });
        let end_read = Instant::now();
        eprintln!(
            "Finished reading all spectra and averaging in {:0.3?}",
            end_read - start
        );
    });

    let collator_task =
        thread::spawn(move || Collator::collate_sync(input_receiver, output_sender));

    let writer_task = thread::spawn(move || -> io::Result<()> {
        for (_, group) in output_receiver {
            writer.write_group(&group)?;
        }
        writer.close().unwrap();
        let end_write = Instant::now();
        eprintln!("Finished writing all spectra in {:0.3?}", end_write - start);
        Ok(())
    });

    if let Err(e) = reader_task.join() {
        eprintln!("An error occurred while joining processing spectra task: {e:?}")
    }

    if let Err(e) = collator_task.join() {
        eprintln!("An error occurred while joining collating spectra task: {e:?}")
    }

    match writer_task.join() {
        Ok(r) => {
            r?;
        }
        Err(e) => {
            eprintln!("An error occurred while joining writing spectra task: {e:?}")
        }
    }

    Ok(())
}

fn into_groups(self) -> SpectrumGroupingIterator<Self, C, D, S>

where Self: Sized,

Consume self to create a SpectrumGroupingIterator. This is ideal for non-rewindable streams like io::stdin which don’t implement io::Seek

Examples found in repository

examples/msn_target_mapping.rs (line 264)

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

    let reader = mzdata::MzMLReader::new(fs::File::open(path)?);
    let group_iter = reader.into_groups();
    let tracking_iter = MSnTargetTrackingIterator::new(group_iter, 2.0, Tolerance::PPM(5.0));
    for (group, targets) in tracking_iter {
        if group.precursor.is_some() {
            let prec = group.precursor.as_ref().unwrap();
            eprintln!("{} {}: {}", prec.id(), prec.start_time(), targets.len());
        }
    }
    Ok(())
}

examples/compressed_mzml.rs (line 24)

fn main() -> io::Result<()> {
    let input = env::args().nth(1).unwrap_or_else(|| {
        eprintln!("Please provide a file path or '-' for STDIN");
        exit(1)
    });
    let start = Instant::now();
    let groups = if input == "-" {
        let stream =
            RestartableGzDecoder::new(io::BufReader::new(PreBufferedStream::new(io::stdin())?));
        let reader = MzMLReader::new(stream);
        let groups: Vec<_> = reader.into_groups().collect();
        groups
    } else {
        let stream = RestartableGzDecoder::new(io::BufReader::new(fs::File::open(input)?));
        let reader = MzMLReader::new(stream);
        let groups: Vec<_> = reader.into_groups().collect();
        groups
    };
    let spectra: Vec<_> = groups
        .iter()
        .flat_map(|g| g.precursor.iter().chain(g.products.iter()))
        .collect();
    let end = Instant::now();
    eprintln!(
        "Read {} groups with {} spectra in {:0.3?}",
        groups.len(),
        spectra.len(),
        end - start
    );
    assert!(!spectra.is_empty());

    Ok(())
}

examples/from_stdin.rs (line 24)

fn main() -> io::Result<()> {
    env_logger::init();
    let start = Instant::now();
    let stream = io::stdin();
    let mut stream = PreBufferedStream::new(stream)?;
    let (fmt, compressed) = infer_from_stream(&mut stream)?;
    stream.seek(io::SeekFrom::Start(0))?;
    let groups: Vec<_> = match fmt {
        MassSpectrometryFormat::MGF => {
            if compressed {
                MGFReader::new(RestartableGzDecoder::new(io::BufReader::new(stream)))
                    .into_groups()
                    .collect()
            } else {
                MGFReader::new(stream).into_groups().collect()
            }
        }
        MassSpectrometryFormat::MzML => {
            if compressed {
                MzMLReader::new(RestartableGzDecoder::new(io::BufReader::new(stream)))
                    .into_groups()
                    .collect()
            } else {
                MzMLReader::new(stream).into_groups().collect()
            }
        }
        x => {
            panic!("Cannot identify file format ({:?})", x)
        }
    };
    let spectra: Vec<_> = groups
        .iter()
        .flat_map(|g| g.precursor.iter().chain(g.products.iter()))
        .collect();
    let end = Instant::now();
    eprintln!(
        "Read {} groups with {} spectra in {:0.3?}",
        groups.len(),
        spectra.len(),
        end - start
    );
    assert!(!spectra.is_empty());
    Ok(())
}

examples/random_access_iter.rs (line 38)

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(())
}

Dyn Compatibility

This trait is dyn compatible.

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

Implementors

impl<C: CentroidLike + From<CentroidPeak> + BuildFromArrayMap, D: DeconvolutedCentroidLike + From<DeconvolutedPeak> + BuildFromArrayMap, R: Read + Seek> SpectrumSource<C, D> for MZReaderType<R, C, D>

impl<C: CentroidLike + From<CentroidPeak>, D: DeconvolutedCentroidLike> SpectrumSource<C, D> for ThermoRawReaderType<C, D>

impl<C: CentroidLike, D: DeconvolutedCentroidLike, S: SpectrumLike<C, D> + Clone> SpectrumSource<C, D, S> for MemorySpectrumSource<C, D, S>

impl<C: CentroidLike, D: DeconvolutedCentroidLike, S: SpectrumLike<C, D>, I: Iterator<Item = S>> SpectrumSource<C, D, S> for StreamingSpectrumIterator<C, D, S, I>

impl<C: CentroidLike, D: DeconvolutedCentroidLike, S: SpectrumLike<C, D>, R: SpectrumSource<C, D, S>> SpectrumSource<C, D, S> for SpectrumIterator<'_, C, D, S, R>

impl<C: FeatureLike<MZ, IonMobility>, D: FeatureLike<Mass, IonMobility> + KnownCharge, CP: CentroidLike + From<CentroidPeak>, DP: DeconvolutedCentroidLike> SpectrumSource<CP, DP> for TDFSpectrumReaderType<C, D, CP, DP>

impl<R: Read + Seek, S: Read + Seek, C: CentroidLike + BuildFromArrayMap, D: DeconvolutedCentroidLike + BuildFromArrayMap> SpectrumSource<C, D> for ImzMLReaderType<R, S, C, D>

They can also be used to fetch specific spectra by ID, index, or start time when the underlying file stream supports io::Seek.

impl<R: SeekRead, C: CentroidLike + BuildFromArrayMap, D: DeconvolutedCentroidLike + BuildFromArrayMap> SpectrumSource<C, D> for MzMLReaderType<R, C, D>

They can also be used to fetch specific spectra by ID, index, or start time when the underlying file stream supports io::Seek.

impl<R: SeekRead, C: CentroidLike + From<CentroidPeak>, D: DeconvolutedCentroidLike + From<DeconvolutedPeak>> SpectrumSource<C, D> for MGFReaderType<R, C, D>

impl<R: SpectrumSource<C, D>, C: CentroidLike + BuildFromArrayMap + From<FittedPeak>, D: DeconvolutedCentroidLike + BuildFromArrayMap> SpectrumSource<C, D> for PeakPicking<R, C, D>