ionic-rs 0.2.0

Streamable binary format for mass-spectrometry data: lossless mzML conversion, random access, WebAssembly support
Documentation
use crate::{
    ion::{
        decoder::decode::Metadatum,
        utilities::{
            children_lookup::{ChildrenLookup, DefaultMetadataPolicy},
            parse_chromatogram_list,
        },
    },
    mzml::structs::{ChromatogramList, CvParam},
};

const PATH: &str = "data/ion/test.ion";

#[allow(clippy::too_many_arguments)]
fn assert_cv_param(
    p: &CvParam,
    cv_ref: Option<&str>,
    accession: Option<&str>,
    name: &str,
    value: Option<&str>,
    unit_cv_ref: Option<&str>,
    unit_name: Option<&str>,
    unit_accession: Option<&str>,
) {
    assert_eq!(p.cv_ref.as_deref(), cv_ref);
    assert_eq!(p.accession.as_deref(), accession);
    assert_eq!(p.name.as_str(), name);
    assert_eq!(p.value.as_deref(), value);
    assert_eq!(p.unit_cv_ref.as_deref(), unit_cv_ref);
    assert_eq!(p.unit_name.as_deref(), unit_name);
    assert_eq!(p.unit_accession.as_deref(), unit_accession);
}

fn parse_chromatogram_list_from_test_file() -> ChromatogramList {
    let meta = super::meta::chromatograms_metadata(PATH);

    let meta_ref: Vec<&Metadatum> = meta.iter().collect();
    let children_lookup = ChildrenLookup::new(&meta);
    let policy = DefaultMetadataPolicy;
    parse_chromatogram_list(&meta_ref, &children_lookup, &policy, 0)
        .expect("parse_chromatogram_list returned None")
}

#[test]
fn chromatogram_list_emits_count_and_default_dp_ref() {
    let cl = parse_chromatogram_list_from_test_file();

    assert_eq!(cl.chromatograms.len(), 2);
    assert_eq!(cl.count, Some(2));
    assert_eq!(
        cl.default_data_processing_ref.as_deref(),
        Some("pwiz_Reader_Bruker_conversion")
    );
}

#[test]
fn chromatogram_0_tic_cv_params_and_bdal_shape() {
    let cl = parse_chromatogram_list_from_test_file();
    let c = &cl.chromatograms[0];

    assert_eq!(c.id.as_str(), "TIC");
    assert_eq!(c.index, Some(0));
    assert_eq!(c.default_array_length, Some(3476));
    let p = c
        .cv_params
        .iter()
        .find(|p| p.accession.as_deref() == Some("MS:1000235"))
        .expect("missing MS:1000235 (total ion current chromatogram)");
    assert_cv_param(
        p,
        Some("MS"),
        Some("MS:1000235"),
        "total ion current chromatogram",
        None,
        None,
        None,
        None,
    );

    let bal = c
        .binary_data_array_list
        .as_ref()
        .expect("missing <binaryDataArrayList> on TIC");
    assert_eq!(bal.count, Some(3));
    assert_eq!(bal.binary_data_arrays.len(), 3);

    let ba0 = &bal.binary_data_arrays[0];
    assert_eq!(ba0.encoded_length, Some(37080));
    let p = ba0
        .cv_params
        .iter()
        .find(|p| p.accession.as_deref() == Some("MS:1000523"))
        .expect("missing MS:1000523 (64-bit float) on time array");
    assert_cv_param(
        p,
        Some("MS"),
        Some("MS:1000523"),
        "64-bit float",
        None,
        None,
        None,
        None,
    );

    let p = ba0
        .cv_params
        .iter()
        .find(|p| p.accession.as_deref() == Some("MS:1000576"))
        .expect("missing MS:1000576 (no compression) on time array");
    assert_cv_param(
        p,
        Some("MS"),
        Some("MS:1000576"),
        "no compression",
        None,
        None,
        None,
        None,
    );

    let p = ba0
        .cv_params
        .iter()
        .find(|p| p.accession.as_deref() == Some("MS:1000595"))
        .expect("missing MS:1000595 (time array)");
    assert_cv_param(
        p,
        Some("MS"),
        Some("MS:1000595"),
        "time array",
        None,
        Some("UO"),
        Some("second"),
        Some("UO:0000010"),
    );

    let ba1 = &bal.binary_data_arrays[1];
    assert_eq!(ba1.encoded_length, Some(18540));

    let p = ba1
        .cv_params
        .iter()
        .find(|p| p.accession.as_deref() == Some("MS:1000521"))
        .expect("missing MS:1000521 (32-bit float) on intensity array");
    assert_cv_param(
        p,
        Some("MS"),
        Some("MS:1000521"),
        "32-bit float",
        None,
        None,
        None,
        None,
    );

    let p = ba1
        .cv_params
        .iter()
        .find(|p| p.accession.as_deref() == Some("MS:1000576"))
        .expect("missing MS:1000576 (no compression) on intensity array");
    assert_cv_param(
        p,
        Some("MS"),
        Some("MS:1000576"),
        "no compression",
        None,
        None,
        None,
        None,
    );

    let p = ba1
        .cv_params
        .iter()
        .find(|p| p.accession.as_deref() == Some("MS:1000515"))
        .expect("missing MS:1000515 (intensity array)");
    assert_cv_param(
        p,
        Some("MS"),
        Some("MS:1000515"),
        "intensity array",
        None,
        Some("MS"),
        Some("number of detector counts"),
        Some("MS:1000131"),
    );

    let ba2 = &bal.binary_data_arrays[2];
    assert_eq!(ba2.array_length, Some(3476));
    assert_eq!(ba2.encoded_length, Some(37080));

    let p = ba2
        .cv_params
        .iter()
        .find(|p| p.accession.as_deref() == Some("MS:1000522"))
        .expect("missing MS:1000522 (64-bit integer) on non-standard array");
    assert_cv_param(
        p,
        Some("MS"),
        Some("MS:1000522"),
        "64-bit integer",
        None,
        None,
        None,
        None,
    );

    let p = ba2
        .cv_params
        .iter()
        .find(|p| p.accession.as_deref() == Some("MS:1000576"))
        .expect("missing MS:1000576 (no compression) on non-standard array");
    assert_cv_param(
        p,
        Some("MS"),
        Some("MS:1000576"),
        "no compression",
        None,
        None,
        None,
        None,
    );

    let p = ba2
        .cv_params
        .iter()
        .find(|p| p.accession.as_deref() == Some("MS:1000786"))
        .expect("missing MS:1000786 (non-standard data array)");
    assert_cv_param(
        p,
        Some("MS"),
        Some("MS:1000786"),
        "non-standard data array",
        Some("ms level"),
        Some("UO"),
        Some("dimensionless unit"),
        Some("UO:0000186"),
    );
}

#[test]
fn chromatogram_1_bpc_has_expected_cv_and_bdal_lengths_match() {
    let cl = parse_chromatogram_list_from_test_file();
    let c = &cl.chromatograms[1];

    assert_eq!(c.id.as_str(), "BPC");
    assert_eq!(c.index, Some(1));
    assert_eq!(c.default_array_length, Some(3476));
    let p = c
        .cv_params
        .iter()
        .find(|p| p.accession.as_deref() == Some("MS:1000628"))
        .expect("missing MS:1000628 (basepeak chromatogram)");
    assert_cv_param(
        p,
        Some("MS"),
        Some("MS:1000628"),
        "basepeak chromatogram",
        None,
        None,
        None,
        None,
    );

    let bal = c
        .binary_data_array_list
        .as_ref()
        .expect("missing <binaryDataArrayList> on BPC");
    assert_eq!(bal.count, Some(3));
    assert_eq!(bal.binary_data_arrays.len(), 3);

    assert_eq!(bal.binary_data_arrays[0].encoded_length, Some(37080));
    assert_eq!(bal.binary_data_arrays[1].encoded_length, Some(18540));
    assert_eq!(bal.binary_data_arrays[2].array_length, Some(3476));
    assert_eq!(bal.binary_data_arrays[2].encoded_length, Some(37080));
}