mzannotate 0.1.0

Handle fragmentation of (complex) peptidoforms.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use mzcore::{
    chemistry::CachedCharge,
    glycan::MonoSaccharide,
    prelude::{AminoAcid, Chemical, MolecularFormula, SequencePosition},
    quantities::Multi,
    system::isize::Charge,
};

use crate::{
    annotation::model::GlycanModel,
    fragment::{DiagnosticPosition, FragmentType},
    prelude::{Fragment, FragmentationModel},
};

/// Generate the theoretical fragments, if any monosaccharide is present a negative number of times no fragments are generated.
pub(crate) fn theoretical_fragments(
    composition: &[(MonoSaccharide, isize)],
    model: &FragmentationModel,
    peptidoform_ion_index: usize,
    peptidoform_index: usize,
    charge_carriers: &mut CachedCharge,
    full_formula: &Multi<MolecularFormula>,
    attachment: Option<(AminoAcid, SequencePosition)>,
) -> Vec<Fragment> {
    if composition.iter().any(|(_, a)| u16::try_from(*a).is_err()) {
        // u16: negative + also ensure it fits within the bounds of the molecular formula structure
        return Vec::new();
    }
    let mut fragments = Vec::new();
    let compositions =
        MonoSaccharide::composition_options(composition, model.glycan.compositional_range);

    // Generate compositional B and Y ions
    let charges_other = charge_carriers.range(model.glycan.other_charge_range);
    let charges_oxonium = charge_carriers.range(model.glycan.oxonium_charge_range);
    for fragment_composition in compositions {
        let formula: MolecularFormula = fragment_composition
            .iter()
            .map(|s| {
                s.0.formula_inner(SequencePosition::default(), peptidoform_index) * s.1 as i32
            })
            .sum();
        fragments.extend(
            Fragment::new(
                formula.clone(),
                Charge::default(),
                peptidoform_ion_index,
                peptidoform_index,
                FragmentType::BComposition(fragment_composition.clone(), attachment),
            )
            .with_charge_range_slice(&charges_oxonium)
            .flat_map(|o| o.with_neutral_losses(&model.glycan.neutral_losses)),
        );

        fragments.extend(full_formula.to_vec().iter().flat_map(|base| {
            Fragment::new(
                base - &formula,
                Charge::default(),
                peptidoform_ion_index,
                peptidoform_index,
                FragmentType::YComposition(
                    MonoSaccharide::composition_left_over(composition, &fragment_composition),
                    attachment,
                ),
            )
            .with_charge_range_slice(&charges_other)
            .flat_map(|o| o.with_neutral_losses(&model.glycan.neutral_losses))
        }));
    }

    // Generate compositional diagnostic ions
    for (sugar, _) in composition {
        fragments.extend(
            diagnostic_ions(
                sugar,
                peptidoform_ion_index,
                peptidoform_index,
                DiagnosticPosition::GlycanCompositional(sugar.clone(), attachment),
                false,
                &model.glycan,
            )
            .into_iter()
            .flat_map(|d| d.with_charge_range_slice(&charges_oxonium)),
        );
    }

    fragments
}

/// Generate all uncharged diagnostic ions for this monosaccharide.
pub(crate) fn diagnostic_ions(
    monosaccharide: &MonoSaccharide,
    peptidoform_ion_index: usize,
    peptidoform_index: usize,
    position: DiagnosticPosition,
    add_base: bool,
    model: &GlycanModel,
) -> Vec<Fragment> {
    let base = Fragment::new(
        monosaccharide.formula(),
        Charge::default(),
        peptidoform_ion_index,
        peptidoform_index,
        FragmentType::Diagnostic(position),
    );
    model
        .specific_neutral_losses
        .iter()
        .filter(|(ms, precise, _)| ms.equivalent(monosaccharide, *precise))
        .flat_map(|(_, _, losses)| losses)
        .map(|loss| base.with_neutral_loss(loss))
        .chain(std::iter::repeat_n(base.clone(), usize::from(add_base)))
        .collect()
}