Struct DeconvolutedSpectrumType 

pub struct DeconvolutedSpectrumType<D: DeconvolutedCentroidLike> {
    pub description: SpectrumDescription,
    pub deconvoluted_peaks: MassPeakSetType<D>,
}

Represents a spectrum that has been centroided, deisotoped, and charge state deconvolved.

This type of spectrum represents data in exactly one format.

Fields

description: SpectrumDescription

The spectrum metadata describing acquisition conditions and details.

deconvoluted_peaks: MassPeakSetType<D>

The deisotoped and charge state deconvolved peaks, sorted by neutral mass in a fast searchable structure.

Implementations

impl<D: DeconvolutedCentroidLike> DeconvolutedSpectrumType<D>

pub fn new( description: SpectrumDescription, deconvoluted_peaks: MassPeakSetType<D>, ) -> Self

pub fn into_spectrum<C>( self, ) -> Result<MultiLayerSpectrum<C, D>, SpectrumConversionError>

where C: CentroidLike,

Convert a spectrum into a MultiLayerSpectrum on D, but preserve all information associated with this spectrum as-is.

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

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

Convert a CentroidSpectrumType into a MultiLayerSpectrum over any peak type, but recode the peak list as DataArray, potentially losing information if the new peak types do not re-use the same ArrayType during peak reconstruction.

Trait Implementations

impl<D: Clone + DeconvolutedCentroidLike> Clone for DeconvolutedSpectrumType<D>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<D: Debug + DeconvolutedCentroidLike> Debug for DeconvolutedSpectrumType<D>

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

Formats the value using the given formatter.

impl<D: DeconvolutedCentroidLike> Default for DeconvolutedSpectrumType<D>

fn default() -> Self

Returns the “default value” for a type.

impl<D: DeconvolutedPeakAdapting> Index<usize> for DeconvolutedSpectrumType<D>

type Output = <PeakSetVec<D, Mass> as Index<usize>>::Output

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<D: DeconvolutedCentroidLike> ParamDescribed for DeconvolutedSpectrumType<D>

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

Obtain an immutable slice over the encapsulated Param list

fn params_mut(&mut self) -> &mut ParamList

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<D: DeconvolutedPeakAdapting> PeakCollection<D, Mass> for DeconvolutedSpectrumType<D>

where MassPeakSetType<D>: PeakCollection<D, Mass>, <MassPeakSetType<D> as Index<usize>>::Output: CoordinateLike<Mass>,

fn len(&self) -> usize

Get the number of peaks in the collection

fn get_item(&self, i: usize) -> &D

Implement index access

fn get_slice(&self, i: Range<usize>) -> &[D]

fn search_by(&self, query: f64) -> Result<usize, usize>

Most basic method for coordinate search, find the index in this collection whose coordinate value is nearest to query. The return signature is identical to slice::binary_search_by

fn iter<'a>(&'a self) -> impl Iterator<Item = &'a D>

where D: 'a,

fn is_empty(&self) -> bool

Test if the collection is empty

unsafe fn get_item_unchecked(&self, i: usize) -> &T

Implement index access without bounds checking.

fn _earliest_peak( &self, query: f64, error_tolerance: Tolerance, i: usize, ) -> Option<usize>

Implementation details of PeakCollection::_search_earliest

fn _latest_peak( &self, query: f64, error_tolerance: Tolerance, i: usize, ) -> Option<usize>

Implementation details of PeakCollection::_search_latest

fn _search_earliest( &self, query: f64, error_tolerance: Tolerance, ) -> Option<usize>

Find the first index for query within error_tolerance in this peak collection, or None.

fn _search_latest( &self, query: f64, error_tolerance: Tolerance, ) -> Option<usize>

Find the last index for query within error_tolerance in this peak collection, or None.

fn _closest_peak( &self, query: f64, error_tolerance: Tolerance, i: usize, ) -> Option<usize>

fn most_intense_peak_for( &self, query: f64, error_tolerance: Tolerance, i: usize, ) -> Option<usize>

where T: IntensityMeasurement,

Find the peak for query that satisfies error_tolerance with the maximum intensity, starting from index i.

fn total_ion_current(&self) -> f32

where T: IntensityMeasurement,

fn base_peak(&self) -> Option<&T>

where T: IntensityMeasurement,

fn search(&self, query: f64, error_tolerance: Tolerance) -> Option<usize>

Find the nearest index for query within error_tolerance in this peak collection, or None.

fn has_peak(&self, query: f64, error_tolerance: Tolerance) -> Option<&T>

Return the peak nearest to query within error_tolerance in this peak collection, or None.

fn between(&self, low: f64, high: f64, error_tolerance: Tolerance) -> &[T]

Return a slice containing all peaks between low and high coordinates within error_tolerance.

fn all_peaks_for(&self, query: f64, error_tolerance: Tolerance) -> &[T]

Find all peaks which could match query within error_tolerance units

fn search_sorted_all_indices<Q>( &self, queries: &[Q], error_tolerance: Tolerance, ) -> Vec<(usize, usize)>

where Q: CoordinateLike<C>,

Given a sorted list of query values that are on the same coordinate system C, find the pairs of indices from query to self within error_tolerance units of error.

fn search_sorted_all_indices_iter<'a, Q>( &'a self, queries: &'a [Q], error_tolerance: Tolerance, ) -> SearchSortedIter<'a, C, T, Self, Q>

where Q: CoordinateLike<C>, Self: Sized,

This alternative implementation of PeakCollection::search_sorted_all_indices that uses an iterator instead of creating intermediate storage. It should be equivalent in behavior but touch the heap less.

impl<D: DeconvolutedCentroidLike> SpectrumLike<CentroidPeak, D> for DeconvolutedSpectrumType<D>

DeconvolutedSpectrumType implements SpectrumLike for D.

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<'_, CentroidPeak, 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<CentroidPeak, 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<C, D> TryFrom<MultiLayerSpectrum<C, D>> for DeconvolutedSpectrumType<D>

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

type Error = SpectrumConversionError

The type returned in the event of a conversion error.

fn try_from(value: MultiLayerSpectrum<C, D>) -> Result<Self, Self::Error>

Performs the conversion.