Struct BinaryArrayMap 

pub struct BinaryArrayMap {
    pub byte_buffer_map: HashMap<ArrayType, DataArray>,
}

A collection of DataArrays that are identified by name.

Examples

use mzdata_bindata::{ArrayType, BinaryArrayMap, BinaryDataArrayType, DataArray};

let mut map = BinaryArrayMap::new();
assert!(!map.has_array(&ArrayType::MZArray));

let array = DataArray::from_name_and_type(&ArrayType::MZArray, BinaryDataArrayType::Float64);
map.add(array);

assert!(map.has_array(&ArrayType::MZArray));
assert_eq!(map.len(), 1);

Fields

byte_buffer_map: HashMap<ArrayType, DataArray>

Implementations

impl BinaryArrayMap

pub fn new() -> BinaryArrayMap

pub fn len(&self) -> usize

Get the number of arrays in the map

pub fn is_empty(&self) -> bool

pub fn has_ion_mobility(&self) -> bool

Check if there is an ion mobility array present

Examples found in repository

examples/mzinfo.rs (line 76)

    pub fn handle_scan(&mut self, scan: MultiLayerSpectrum) {
        let time = scan.start_time();
        self.start_time = self.start_time.min(time);
        self.end_time = self.end_time.max(time);
        let level = scan.ms_level();
        *self.level_table.entry(level).or_default() += 1;
        *self.spectrum_types.entry(scan.spectrum_type()).or_default() += 1;
        if level > 1 {
            if let Some(charge) = scan.precursor().unwrap().ion().and_then(|i| i.charge()) {
                *self.charge_table.entry(charge).or_default() += 1;
            } else {
                *self.charge_table.entry(0).or_default() += 1;
            }
        }
        *self
            .peak_mode_table
            .entry(scan.signal_continuity())
            .or_default() += scan.peaks().len();

        let has_charge = match scan.peaks() {
            RefPeakDataLevel::Missing => false,
            RefPeakDataLevel::RawData(arrays) => arrays.charges().is_ok(),
            RefPeakDataLevel::Centroid(_) => false,
            RefPeakDataLevel::Deconvoluted(_) => true,
        };

        let has_ion_mobility = match scan.peaks() {
            RefPeakDataLevel::RawData(arrays) => arrays.has_ion_mobility(),
            _ => false,
        } || scan.has_ion_mobility();
        self.has_ion_mobility |= has_ion_mobility;

        if has_charge {
            let deconv_scan: DeconvolutedSpectrum = scan.try_into().unwrap();
            deconv_scan.deconvoluted_peaks.iter().for_each(|p| {
                *(*self
                    .peak_charge_table
                    .entry(deconv_scan.ms_level())
                    .or_default())
                .entry(p.charge)
                .or_default() += 1;
                assert!((p.index as usize) < deconv_scan.deconvoluted_peaks.len())
            })
        }
    }

pub fn iter(&self) -> Iter<'_, ArrayType, DataArray>

Iterate over references to the key-value pairs of this map

pub fn iter_mut(&mut self) -> IterMut<'_, ArrayType, DataArray>

Iterate over mutable references to the key-value pairs of this map

pub fn encode_array( &mut self, array_type: &ArrayType, compression: BinaryCompressionType, ) -> Result<(), ArrayRetrievalError>

Compress a specific DataArray with the compression scheme provided, if it is present.

This method may fail if the compression fails or if the array type is missing.

See Also

DataArray::store_compressed

pub fn decode_all_arrays(&mut self) -> Result<(), ArrayRetrievalError>

Decode all DataArray in this map if they have not been decoded already so that they are ready for use. If there are many arrays and the parallelism feature is enabled, arrays may be decoded in parallel.

Examples

use mzdata_bindata::{ArrayType, BinaryArrayMap, BinaryCompressionType, BinaryDataArrayType, DataArray};

let mut mz_array = DataArray::from_name_and_type(&ArrayType::MZArray, BinaryDataArrayType::Float64);
mz_array.extend(&[1.0f64, 2.0, 3.0]).unwrap();
mz_array.store_compressed(BinaryCompressionType::Zlib).unwrap();

let mut map = BinaryArrayMap::new();
map.add(mz_array);
assert_eq!(map.get(&ArrayType::MZArray).unwrap().compression, BinaryCompressionType::Zlib);

map.decode_all_arrays().unwrap();
assert_eq!(map.get(&ArrayType::MZArray).unwrap().compression, BinaryCompressionType::Decoded);

pub fn decode_array( &mut self, array_type: &ArrayType, ) -> Result<(), ArrayRetrievalError>

Decode a specific DataArray if it is present.

This method may fail if decoding fails or if the array type is missing.

See DataArray::decode_and_store

pub fn add(&mut self, array: DataArray)

Add a DataArray to the map by its ArrayType name

pub fn get(&self, array_type: &ArrayType) -> Option<&DataArray>

Get a reference to a specific DataArray if present

pub fn get_mut(&mut self, array_type: &ArrayType) -> Option<&mut DataArray>

Get a mutable reference to a specific DataArray if present

pub fn has_array(&self, array_type: &ArrayType) -> bool

Check whether a specific ArrayType is present

pub fn clear(&mut self)

Clear the map, discarding any array data

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

Search for a specific m/z within a specified Tolerance.

This effectively calls BinaryArrayMap::mzs to get the m/z array and then performs a binary search to find the best index within range, if one exists.

pub fn mzs(&self) -> Result<Cow<'_, [f64]>, ArrayRetrievalError>

Get a reference to the m/z array if it is present

Examples

use mzdata_bindata::{ArrayType, BinaryArrayMap, BinaryDataArrayType, DataArray};

let mut mz_array = DataArray::from_name_and_type(&ArrayType::MZArray, BinaryDataArrayType::Float64);
mz_array.extend(&[100.0f64, 200.0, 300.0]).unwrap();

let mut map = BinaryArrayMap::new();
map.add(mz_array);

assert_eq!(&*map.mzs().unwrap(), &[100.0f64, 200.0, 300.0][..]);

Examples found in repository

examples/get_scan_by.rs (line 47)

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

pub fn sort_from_indices( &mut self, mask: Vec<usize>, ) -> Result<(), ArrayRetrievalError>

Re-order all arrays of matching length with respect to the provided index mask operating on the decoded native value states.

The mask would be created using an indirect sort from another array:

let vals = self.mzs().unwrap();
let n = vals.len();
let mut mask: Vec<usize> = (0..n).into_iter().collect();
mask.sort_by(|i, j| {
    let a = vals[*i];
    let b = vals[*j];
    a.total_cmp(&b)
});
drop(vals);
self.sort_from_indices(mask)

pub fn sort_by_array( &mut self, name: &ArrayType, ) -> Result<(), ArrayRetrievalError>

Sort all the arrays in the map by name if they are the same length. This operates on the decoded state directly.

This builds the sorting mask and then leaves Self::sort_from_indices to perform the re-ordering.

Not supported for BinaryDataArrayType::ASCII and BinaryDataArrayType::Unknown.

pub fn mzs_mut(&mut self) -> Result<&mut [f64], ArrayRetrievalError>

Get a mutable reference to the m/z array if it is present.

This method obtains the m/z array, calls DataArray::decode_and_store to force the data to be stored natively in memory, and forces the storage to be BinaryDataArrayType::Float64 if not already. Finally it returns a mutable view of that decoded dataas &mut [f64]

pub fn intensities(&self) -> Result<Cow<'_, [f32]>, ArrayRetrievalError>

Get a reference to the intensity array if it is present

pub fn intensities_mut(&mut self) -> Result<&mut [f32], ArrayRetrievalError>

Get a mutable reference to the intensity array if it is present.

See BinaryArrayMap::mzs_mut for an explanation of the intermediate steps, save that the forced storage type is [BinaryArrayDataType::Float32].

pub fn charges(&self) -> Result<Cow<'_, [i32]>, ArrayRetrievalError>

Get a reference to the charge array if it is present

Examples found in repository

examples/mzinfo.rs (line 70)

    pub fn handle_scan(&mut self, scan: MultiLayerSpectrum) {
        let time = scan.start_time();
        self.start_time = self.start_time.min(time);
        self.end_time = self.end_time.max(time);
        let level = scan.ms_level();
        *self.level_table.entry(level).or_default() += 1;
        *self.spectrum_types.entry(scan.spectrum_type()).or_default() += 1;
        if level > 1 {
            if let Some(charge) = scan.precursor().unwrap().ion().and_then(|i| i.charge()) {
                *self.charge_table.entry(charge).or_default() += 1;
            } else {
                *self.charge_table.entry(0).or_default() += 1;
            }
        }
        *self
            .peak_mode_table
            .entry(scan.signal_continuity())
            .or_default() += scan.peaks().len();

        let has_charge = match scan.peaks() {
            RefPeakDataLevel::Missing => false,
            RefPeakDataLevel::RawData(arrays) => arrays.charges().is_ok(),
            RefPeakDataLevel::Centroid(_) => false,
            RefPeakDataLevel::Deconvoluted(_) => true,
        };

        let has_ion_mobility = match scan.peaks() {
            RefPeakDataLevel::RawData(arrays) => arrays.has_ion_mobility(),
            _ => false,
        } || scan.has_ion_mobility();
        self.has_ion_mobility |= has_ion_mobility;

        if has_charge {
            let deconv_scan: DeconvolutedSpectrum = scan.try_into().unwrap();
            deconv_scan.deconvoluted_peaks.iter().for_each(|p| {
                *(*self
                    .peak_charge_table
                    .entry(deconv_scan.ms_level())
                    .or_default())
                .entry(p.charge)
                .or_default() += 1;
                assert!((p.index as usize) < deconv_scan.deconvoluted_peaks.len())
            })
        }
    }

pub fn charge_mut(&mut self) -> Result<&mut [i32], ArrayRetrievalError>

Get a mutable reference to the charge array if it is present.

See BinaryArrayMap::mzs_mut for an explanation of the intermediate steps, save that the forced storage type is [BinaryArrayDataType::Int32].

pub fn ion_mobility( &self, ) -> Result<(Cow<'_, [f64]>, ArrayType), ArrayRetrievalError>

Get a reference to the ion mobility array if it is present

pub fn ion_mobility_mut( &mut self, ) -> Result<(&mut [f64], ArrayType), ArrayRetrievalError>

Get a mutable reference to the ion mobility array if it is present.

See BinaryArrayMap::mzs_mut for an explanation of the intermediate steps.

pub fn stack_ion_mobility(self) -> Result<BinaryArrayMap3D, ArrayRetrievalError>

Split an array map along the ion mobility dimension if it is present.

This function will fail if there is no ion mobility dimension.

Trait Implementations

impl Clone for BinaryArrayMap

fn clone(&self) -> BinaryArrayMap

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BinaryArrayMap

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

Formats the value using the given formatter.

impl Default for BinaryArrayMap

fn default() -> BinaryArrayMap

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for BinaryArrayMap

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&PeakSetVec<CentroidPeak, MZ>> for BinaryArrayMap

fn from(peaks: &PeakSetVec<CentroidPeak, MZ>) -> BinaryArrayMap

Converts to this type from the input type.

impl From<&PeakSetVec<DeconvolutedPeak, Mass>> for BinaryArrayMap

fn from(peaks: &PeakSetVec<DeconvolutedPeak, Mass>) -> BinaryArrayMap

Converts to this type from the input type.

impl From<ArrayPair<'_>> for BinaryArrayMap

fn from(value: ArrayPair<'_>) -> BinaryArrayMap

Converts to this type from the input type.

impl IntoIterator for BinaryArrayMap

type Item = (ArrayType, DataArray)

The type of the elements being iterated over.

type IntoIter = <HashMap<ArrayType, DataArray> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> <BinaryArrayMap as IntoIterator>::IntoIter

Creates an iterator from a value.

impl Serialize for BinaryArrayMap

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 TryFrom<&BinaryArrayMap3D> for BinaryArrayMap

A BinaryArrayMap aliases TryFrom on BinaryArrayMap3D with BinaryArrayMap3D::unstack

type Error = ArrayRetrievalError

The type returned in the event of a conversion error.

fn try_from( value: &BinaryArrayMap3D, ) -> Result<BinaryArrayMap, <BinaryArrayMap as TryFrom<&BinaryArrayMap3D>>::Error>

Performs the conversion.

impl<C, D> TryFrom<&BinaryArrayMap> for PeakDataLevel<C, D>

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

type Error = ArrayRetrievalError

The type returned in the event of a conversion error.

fn try_from( value: &BinaryArrayMap, ) -> Result<PeakDataLevel<C, D>, <PeakDataLevel<C, D> as TryFrom<&BinaryArrayMap>>::Error>

Performs the conversion.

impl TryFrom<&BinaryArrayMap> for BinaryArrayMap3D

A BinaryArrayMap3D aliases TryFrom on BinaryArrayMap with BinaryArrayMap3D::stack

type Error = ArrayRetrievalError

The type returned in the event of a conversion error.

fn try_from( value: &BinaryArrayMap, ) -> Result<BinaryArrayMap3D, <BinaryArrayMap3D as TryFrom<&BinaryArrayMap>>::Error>

Performs the conversion.

impl TryFrom<BinaryArrayMap3D> for BinaryArrayMap

type Error = ArrayRetrievalError

The type returned in the event of a conversion error.

fn try_from( value: BinaryArrayMap3D, ) -> Result<BinaryArrayMap, <BinaryArrayMap as TryFrom<BinaryArrayMap3D>>::Error>

Performs the conversion.

impl TryFrom<BinaryArrayMap> for BinaryArrayMap3D

fn try_from( value: BinaryArrayMap, ) -> Result<BinaryArrayMap3D, <BinaryArrayMap3D as TryFrom<BinaryArrayMap>>::Error>

A wrapper around BinaryArrayMap3D::stack

type Error = ArrayRetrievalError

The type returned in the event of a conversion error.