Struct MultiLayerSpectrum 

pub struct MultiLayerSpectrum<C = CentroidPeak, D = DeconvolutedPeak>
where
    C: CentroidLike,
    D: DeconvolutedCentroidLike,
{
    pub description: SpectrumDescription,
    pub arrays: Option<BinaryArrayMap>,
    pub peaks: Option<PeakSetVec<C, MZ>>,
    pub deconvoluted_peaks: Option<PeakSetVec<D, Mass>>,
}

Represent a spectrum with multiple layers of representation of the peak data.

This type is useful because it permits us to hold spectra in incrementally more processed representations without loss of information.

Fields

description: SpectrumDescription

The spectrum metadata describing acquisition conditions and details.

arrays: Option<BinaryArrayMap>

The (potentially absent) data arrays describing the m/z, intensity, and potentially other measured properties

peaks: Option<PeakSetVec<C, MZ>>

deconvoluted_peaks: Option<PeakSetVec<D, Mass>>

Implementations

impl<C, D> MultiLayerSpectrum<C, D>

where C: CentroidLike, D: DeconvolutedCentroidLike,

pub fn new( description: SpectrumDescription, arrays: Option<BinaryArrayMap>, peaks: Option<PeakSetVec<C, MZ>>, deconvoluted_peaks: Option<PeakSetVec<D, Mass>>, ) -> MultiLayerSpectrum<C, D>

Create a new MultiLayerSpectrum from a SpectrumDescription and any/all/none of the different levels of processing details for signal data.

impl<C, D> MultiLayerSpectrum<C, D>

where C: CentroidLike + BuildFromArrayMap + BuildArrayMapFrom, D: DeconvolutedCentroidLike + BuildFromArrayMap + BuildArrayMapFrom,

pub fn into_centroid( self, ) -> Result<CentroidSpectrumType<C>, SpectrumConversionError>

Convert a spectrum into a CentroidSpectrumType.

This will try the following steps to get the peak list to use in the new instance:

1. If the peaks field is populated, use it directly .
2. If the Self::signal_continuity is SignalContinuity::Centroid and Self::arrays is populated, attempt [C::try_from_arrays] to build the peak list from the raw arrays. Otherwise assume the peak list is empty.
3. Fail with SpectrumConversionError::NotCentroided

Examples found in repository

examples/readme.rs (line 23)

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

    let mut ms1_count = 0;
    let mut msn_count = 0;
    for spectrum in reader {
        if spectrum.ms_level() == 1 {
            ms1_count += 1;
        } else {
            msn_count += 1;
        }
        println!(
            "Scan {} => BP {}",
            spectrum.id(),
            spectrum.peaks().base_peak().mz
        );
        if spectrum.signal_continuity() < SignalContinuity::Profile {
            let peak_picked = spectrum.into_centroid().unwrap();
            println!(
                "Matches for 579.155: {:?}",
                peak_picked
                    .peaks
                    .all_peaks_for(579.155, Tolerance::Da(0.02))
            );
        }
    }
    println!("MS1 Count: {}\nMSn Count: {}", ms1_count, msn_count);
    assert_eq!(ms1_count, 14);
    assert_eq!(msn_count, 34);
    Ok(())
}

pub fn into_raw(self) -> Result<RawSpectrum, SpectrumConversionError>

Convert a spectrum into a RawSpectrum

pub fn from_arrays_and_description( arrays: BinaryArrayMap, description: SpectrumDescription, ) -> MultiLayerSpectrum<C, D>

Construct a MultiLayerSpectrum with description and the provided raw data arrays

pub fn from_description( description: SpectrumDescription, ) -> MultiLayerSpectrum<C, D>

Construct a MultiLayerSpectrum with description and no peak data of any kind

pub fn from_peaks_data_levels_and_description( peaks: PeakDataLevel<C, D>, description: SpectrumDescription, ) -> MultiLayerSpectrum<C, D>

Construct a MultiLayerSpectrum with description and a PeakDataLevel containing at most one of the data modalities. This is convenient for reconstructing a spectrum from its parts.

pub fn from_spectrum_like<S>(spectrum: S) -> MultiLayerSpectrum<C, D>

where S: SpectrumLike<C, D>,

Converts an arbitrary SpectrumLike type into a MultiLayerSpectrum with the same peak types.

This is a thin wrapper around SpectrumLike::into_peaks_and_description and MultiLayerSpectrum::from_peaks_data_levels_and_description

pub fn reinterpret<C1, D1>(self) -> MultiLayerSpectrum<C1, D1>

where C1: CentroidLike + BuildArrayMapFrom + BuildFromArrayMap, D1: DeconvolutedCentroidLike + BuildArrayMapFrom + BuildFromArrayMap, C: BuildArrayMapFrom, D: BuildArrayMapFrom,

Convert a MultiLayerSpectrum with one set of peak types to another with any peak type, but recode the peak list as DataArray as an intermediary, potentially losing information if the new peak types do not re-use the same ArrayType during peak reconstruction.

Note

Peak data is not actually reconstructed from the intermediate data arrays. If that is desired, call MultiLayerSpectrum::try_build_peaks

pub fn denoise(&mut self, scale: f32) -> Result<(), SpectrumProcessingError>

Apply a local denoising algorithm to the signal that is suitable for profile mode data using mzsignal::denoise.

pub fn reprofile_with_shape( &mut self, dx: f64, fwhm: f32, ) -> Result<(), SpectrumProcessingError>

When mzsignal is available, use mzsignal::reprofile::PeakSetReprofiler to create new profile m/z and intensity DataArrays from MultiLayerSpectrum::peaks, updating MultiLayerSpectrum::arrays.

NOTE: This does not modify SpectrumLike::signal_continuity, and if it is desired you should update this manually to SignalContinuity::Profile.

Arguments

• dx: The m/z grid spacing that the profile signal will be projected onto. The best value to use here depends upon the spectrum’s resolution, but when resources are not an issue between 0.005 and 0.001 are is a choice. This may produce a lot of wasted space however.
• fwhm: The uniform peak full-width-at-half-max to assume for all peaks. It controls the broadness of the theoretical gaussian profile created around each centroid peak. If non-uniform shapes are needed, directly use PeakSetReprofiler.

impl<C, D> MultiLayerSpectrum<C, D>

where C: CentroidLike + BuildFromArrayMap, D: DeconvolutedCentroidLike + BuildFromArrayMap,

pub fn try_build_peaks( &mut self, ) -> Result<RefPeakDataLevel<'_, C, D>, SpectrumConversionError>

Attempt to reconstruct one of the peak layers based upon the available data arrays if this spectrum is in centroid mode.

Errors

If constructing the peak list encounters an error, or if data array access/decoding fails, a SpectrumConversionError is returned.

pub fn try_build_centroids( &mut self, ) -> Result<&PeakSetVec<C, MZ>, SpectrumConversionError>

pub fn try_build_deconvoluted_centroids( &mut self, ) -> Result<&PeakSetVec<D, Mass>, SpectrumConversionError>

impl<C, D> MultiLayerSpectrum<C, D>

where C: CentroidLike + From<FittedPeak>, D: DeconvolutedCentroidLike,

When mzsignal is available, MultiLayerSpectrum supports in-place signal processing operations.

The peak picking steps need to convert an mzsignal::FittedPeak into C. This is trivial for CentroidPeak and mzsignal::FittedPeak itself.

pub fn pick_peaks_with( &mut self, peak_picker: &PeakPicker, ) -> Result<(), SpectrumProcessingError>

Using a pre-configured mzsignal::PeakPicker to pick peaks from arrays’s signal, populating the peaks field.

If SpectrumLike::signal_continuity returns SignalContinuity::Centroid, then no filtering is performed and all points are directly converted into picked peaks.

NOTE: This does not modify SpectrumLike::signal_continuity, and if it is desired you should update this manually to SignalContinuity::Centroid.

pub fn pick_peaks( &mut self, signal_to_noise_threshold: f32, ) -> Result<(), SpectrumProcessingError>

Pick peaks with a minimum signal-to-noise threshold, populating MultiLayerSpectrum::peaks with an mzpeaks::MZPeakSetType over C.

See also

MultiLayerSpectrum::pick_peaks_with

pub fn pick_peaks_in_intervals( &mut self, signal_to_noise_threshold: f32, intervals: &[(f64, f64)], ) -> Result<(), SpectrumProcessingError>

Pick peaks in the specified m/z intervals with a minimum signal-to-noise threshold, populating MultiLayerSpectrum::peaks with an mzpeaks::MZPeakSetType over C from those intervals.

If SpectrumLike::signal_continuity returns SignalContinuity::Centroid, then array data is converted to peaks as in MultiLayerSpectrum::pick_peaks and then only those peaks in the requested intervals are kept.

NOTE: This does not modify SpectrumLike::signal_continuity, and if it is desired you should update this manually to SignalContinuity::Centroid.

Trait Implementations

impl<C, D> Clone for MultiLayerSpectrum<C, D>

where C: Clone + CentroidLike, D: Clone + DeconvolutedCentroidLike,

fn clone(&self) -> MultiLayerSpectrum<C, D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C, D> Debug for MultiLayerSpectrum<C, D>

where C: Debug + CentroidLike, D: Debug + DeconvolutedCentroidLike,

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

Formats the value using the given formatter.

impl<C, D> Default for MultiLayerSpectrum<C, D>

where C: CentroidLike, D: DeconvolutedCentroidLike,

fn default() -> MultiLayerSpectrum<C, D>

Returns the “default value” for a type.

impl<'de, C, D> Deserialize<'de> for MultiLayerSpectrum<C, D>

where C: CentroidLike + Deserialize<'de>, D: DeconvolutedCentroidLike + Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D, ) -> Result<MultiLayerSpectrum<C, D>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<C, D> From<CentroidSpectrumType<C>> for MultiLayerSpectrum<C, D>

where C: CentroidLike, D: DeconvolutedCentroidLike,

fn from(spectrum: CentroidSpectrumType<C>) -> MultiLayerSpectrum<C, D>

Converts to this type from the input type.

impl<C, D> From<MultiLayerSpectrum<C, D>> for RawSpectrum

where C: CentroidLike + BuildFromArrayMap + BuildArrayMapFrom, D: DeconvolutedCentroidLike + BuildFromArrayMap + BuildArrayMapFrom,

fn from(spectrum: MultiLayerSpectrum<C, D>) -> RawSpectrum

Converts to this type from the input type.

impl<C: CentroidLike + BuildFromArrayMap + BuildArrayMapFrom, D: DeconvolutedCentroidLike + BuildFromArrayMap + BuildArrayMapFrom> From<PROXISpectrum> for MultiLayerSpectrum<C, D>

fn from(value: PROXISpectrum) -> Self

Converts to this type from the input type.

impl<C, D> From<RawSpectrum> for MultiLayerSpectrum<C, D>

where C: CentroidLike + BuildFromArrayMap, D: DeconvolutedCentroidLike + BuildFromArrayMap,

fn from(spectrum: RawSpectrum) -> MultiLayerSpectrum<C, D>

Converts to this type from the input type.

impl<C, D> ParamDescribed for MultiLayerSpectrum<C, D>

where C: CentroidLike, D: DeconvolutedCentroidLike,

fn params(&self) -> &[Param]

Obtain an immutable slice over the encapsulated Param list

fn params_mut(&mut self) -> &mut Vec<Param>

Obtain an mutable slice over the encapsulated Param list

fn add_param(&mut self, param: Param)

Add a new Param to the entity

fn extend_params(&mut self, it: impl IntoIterator<Item = Param>)

Add all parameters from an iterator of Param to the entity

fn remove_param(&mut self, index: usize) -> Param

Remove the ith Param from the entity.

fn get_param_by_name(&self, name: &str) -> Option<&Param>

Find the first Param whose name matches name

fn get_param_by_curie(&self, curie: &CURIE) -> Option<&Param>

Find the first Param whose CURIE matches curie

fn get_param_by_accession(&self, accession: &str) -> Option<&Param>

Find the first Param whose Param::accession matches accession

fn iter_params(&self) -> Iter<'_, Param>

Iterate over the encapsulated parameter list

fn iter_params_mut(&mut self) -> IterMut<'_, Param>

Iterate mutably over the encapsulated parameter list

impl<C: CentroidLike + BuildArrayMapFrom + BuildFromArrayMap, D: DeconvolutedCentroidLike + BuildArrayMapFrom + BuildFromArrayMap, G: SpectrumGrouping<C, D, MultiLayerSpectrum<C, D>>, R: RandomAccessSpectrumGroupingIterator<C, D, MultiLayerSpectrum<C, D>, G>> RandomAccessSpectrumGroupingIterator<C, D, MultiLayerSpectrum<C, D>, G> for SpectrumAveragingIterator<'_, C, D, G, R>

fn reset_state(&mut self)

fn start_from_id(&mut self, id: &str) -> Result<&Self, SpectrumAccessError>

fn start_from_index( &mut self, index: usize, ) -> Result<&Self, SpectrumAccessError>

fn start_from_time(&mut self, time: f64) -> Result<&Self, SpectrumAccessError>

impl<C, D> Serialize for MultiLayerSpectrum<C, D>

where C: CentroidLike + Serialize, D: DeconvolutedCentroidLike + Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a, C: CentroidLike + BuildFromArrayMap, D: DeconvolutedCentroidLike + BuildFromArrayMap> SpectrumBuilding<'a, C, D, MultiLayerSpectrum<C, D>> for ImzMLSpectrumBuilder<'a, C, D>

fn into_spectrum(self, spectrum: &mut MultiLayerSpectrum<C, D>)

Move all the data into the provided spectrum reference

fn into_chromatogram(self, chromatogram: &mut Chromatogram)

Move all the data into the provided chromatogram reference

fn set_run_data_processing(&mut self, run_data_processing: Option<Box<str>>)

Optionally set the global data processing identifier for the run to be used if a data processing reference isn’t specified locally.

fn borrow_metadata( self, instrument_id_map: &'a mut IncrementingIdMap, reference_param_groups: &'a HashMap<String, Vec<Param>>, ) -> Self

fn fill_spectrum<P: ParamLike + Into<Param> + ParamValue>(&mut self, param: P)

Put a parameter-like instance into the current top-level instance

fn current_array_mut(&mut self) -> &mut DataArray

Get the current DataArray being built. This may be an empty instance if if there is no array being built currently.

fn precursor_mut(&mut self) -> &mut Precursor

Get the current Precursor being built.

fn new_precursor_mut(&mut self) -> &mut Precursor

Add a new Precursor to the stack. This will be the current Precursor.

fn new_selected_ion(&mut self) -> &mut SelectedIon

Add a new SelectedIon to the stack for the current Precursor. This will be the current SelectedIon.

fn selected_ion_mut(&mut self) -> &mut SelectedIon

Get the current SelectedIon being built.

fn scan_window_mut(&mut self) -> &mut ScanWindow

Get the last scan window being constructed.

fn isolation_window_mut(&mut self) -> &mut IsolationWindow

Get the last isolation window being constructed

fn product_isolation_window_mut(&mut self) -> &mut IsolationWindow

fn new_product(&mut self) -> &mut Product

fn set_current_compression(&mut self, compression: BinaryCompressionType)

Set the compression method for the current DataArray

fn fill_binary_data_array<P: ParamLike + Into<Param> + ParamValue>( &mut self, param: P, )

Put a parameter-like instance into the current DataArray

fn fill_selected_ion(&mut self, param: Param)

Put a parameter-like instance into the current SelectedIon

fn populate_isolation_window(param: Param, window: &mut IsolationWindow)

fn fill_isolation_window(&mut self, param: Param)

Put a parameter-like instance into the current IsolationWindow

fn fill_product_isolation_window(&mut self, param: Param)

Put a parameter-like instance into the current IsolationWindow from a Product

fn fill_scan_window(&mut self, param: Param)

Put a parameter-like instance into the current ScanWindow

impl<C, D> SpectrumLike<C, D> for MultiLayerSpectrum<C, D>

where C: CentroidLike, D: DeconvolutedCentroidLike,

fn description(&self) -> &SpectrumDescription

The method to access the spectrum description itself, which supplies the data for most other methods on this trait.

fn description_mut(&mut self) -> &mut SpectrumDescription

The method to access the spectrum descript itself, mutably.

fn peaks(&self) -> RefPeakDataLevel<'_, C, D>

Retrieve the most processed representation of the mass spectrum’s signal

fn raw_arrays(&self) -> Option<&BinaryArrayMap>

Obtain a reference to the BinaryArrayMap if one is available for the peak information. This may not be the most refined version of the peak signal if it has been processed further.

fn into_peaks_and_description( self, ) -> (PeakDataLevel<C, D>, SpectrumDescription)

Consume the spectrum, decomposing it into the SpectrumDescription and an owning PeakDataLevel.

fn acquisition(&self) -> &Acquisition

Access the acquisition information for this spectrum.

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

Access the (first) precursor information, if it exists.

fn precursor_iter(&self) -> impl Iterator<Item = &Precursor> + ExactSizeIterator

Iterate over all precursors of the spectrum

fn precursor_count(&self) -> usize

The number of precursor levels recorded

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

Mutably access the (first) precursor information, if it exists

fn precursor_iter_mut( &mut self, ) -> impl Iterator<Item = &mut Precursor> + ExactSizeIterator

Iterate over all precursors of the spectrum mutably

fn add_precursor(&mut self, precursor: Precursor)

Add a precursor to the list of precursors for this spectrum.

fn remove_precursor(&mut self, index: usize) -> Precursor

Remove the precursor entry at index in the precursor list.

fn start_time(&self) -> f64

A shortcut method to retrieve the scan start time of a spectrum

fn ms_level(&self) -> u8

Access the MS exponentiation level

fn id(&self) -> &str

Access the native ID string for the spectrum

fn index(&self) -> usize

Access the index of the spectrum in the source file

fn signal_continuity(&self) -> SignalContinuity

Access a description of how raw the signal is, whether a profile spectrum is available or only centroids are present.

fn polarity(&self) -> ScanPolarity

Access a description of the spectrum polarity

fn ion_mobility(&self) -> Option<f64>

Access the point measure of ion mobility associated with the scan if present. This is distinct from having a frame-level scan across the ion mobility dimension.

fn has_ion_mobility(&self) -> bool

Check if this spectrum has a point measure of ion mobility. This is distinct from having a frame-level scan across the ion mobility dimension.

fn has_ion_mobility_dimension(&self) -> bool

Check if this spectrum has an ion mobility dimension/array. This is distinct from having a scan-level point measure of ion mobility.

fn has_ion_mobility_class(&self) -> HasIonMobility

A single point of entry for checking if ion mobility is present.

fn spectrum_type(&self) -> Option<SpectrumType>

Find the type of spectrum described.

fn set_spectrum_type(&mut self, spectrum_type: SpectrumType)

Set the kind of spectrum represented.

fn update_summaries(&mut self)

Compute and update the the total ion current, base peak, and m/z range for the spectrum based upon its current peak data.

impl<CFeat, DFeat, CPeak, DPeak> TryFrom<MultiLayerIonMobilityFrame<CFeat, DFeat>> for MultiLayerSpectrum<CPeak, DPeak>

where CFeat: FeatureLike<MZ, IonMobility> + BuildArrayMap3DFrom, DFeat: FeatureLike<Mass, IonMobility> + KnownCharge + BuildArrayMap3DFrom, CPeak: CentroidLike + BuildFromArrayMap, DPeak: DeconvolutedCentroidLike + BuildFromArrayMap,

A MultiLayerIonMobilityFrame can be converted to MultiLayerSpectrum by flattening the feature data into a BinaryArrayMap.

type Error = ArrayRetrievalError

The type returned in the event of a conversion error.

fn try_from( value: MultiLayerIonMobilityFrame<CFeat, DFeat>, ) -> Result<MultiLayerSpectrum<CPeak, DPeak>, <MultiLayerSpectrum<CPeak, DPeak> as TryFrom<MultiLayerIonMobilityFrame<CFeat, DFeat>>>::Error>

Performs the conversion.

impl<C, D> TryFrom<MultiLayerSpectrum<C, D>> for CentroidSpectrumType<C>

where C: CentroidLike + BuildFromArrayMap + BuildArrayMapFrom, D: DeconvolutedCentroidLike + BuildFromArrayMap + BuildArrayMapFrom,

type Error = SpectrumConversionError

The type returned in the event of a conversion error.

fn try_from( spectrum: MultiLayerSpectrum<C, D>, ) -> Result<CentroidSpectrumType<C>, <CentroidSpectrumType<C> as TryFrom<MultiLayerSpectrum<C, D>>>::Error>

Performs the conversion.

impl<C, D> TryFrom<MultiLayerSpectrum<C, D>> for DeconvolutedSpectrumType<D>

where C: CentroidLike + BuildFromArrayMap + BuildArrayMapFrom, D: DeconvolutedCentroidLike + BuildFromArrayMap + BuildArrayMapFrom,

type Error = SpectrumConversionError

The type returned in the event of a conversion error.

fn try_from( value: MultiLayerSpectrum<C, D>, ) -> Result<DeconvolutedSpectrumType<D>, <DeconvolutedSpectrumType<D> as TryFrom<MultiLayerSpectrum<C, D>>>::Error>

Performs the conversion.

impl<CFeat, DFeat, CPeak, DPeak> TryFrom<MultiLayerSpectrum<CPeak, DPeak>> for MultiLayerIonMobilityFrame<CFeat, DFeat>

where CFeat: FeatureLike<MZ, IonMobility>, DFeat: FeatureLike<Mass, IonMobility> + KnownCharge, CPeak: CentroidLike, DPeak: DeconvolutedCentroidLike,

MultiLayerSpectrum instances can be converted to MultiLayerIonMobilityFrame by using BinaryArrayMap3D::stack on the flat MultiLayerSpectrum::arrays.

Errors

This will fail if BinaryArrayMap3D::stack fails

type Error = ArrayRetrievalError

The type returned in the event of a conversion error.

fn try_from( value: MultiLayerSpectrum<CPeak, DPeak>, ) -> Result<MultiLayerIonMobilityFrame<CFeat, DFeat>, <MultiLayerIonMobilityFrame<CFeat, DFeat> as TryFrom<MultiLayerSpectrum<CPeak, DPeak>>>::Error>

Performs the conversion.