Struct AlignScoring 

pub struct AlignScoring<'a> {
    pub mismatch: i8,
    pub mass_mismatch: i8,
    pub mass_base: i8,
    pub rotated: i8,
    pub isobaric: i8,
    pub gap_start: i8,
    pub gap_extend: i8,
    pub matrix: &'a [[i8; 26]; 26],
    pub tolerance: Tolerance<OrderedMass>,
    pub mass_mode: MassMode,
    pub pair: PairMode,
}

The scoring parameters for the mass alignment.

Design parameters for the scoring systems are as follows:

• A positive mass_base is needed to ensure breaking up of adjecent isobaric/rotated parts. For example IGG vs LN should be 1i2:1i not 3:2i.
• A higher score for rotated is needed to ensure rotation preference over isobaric.
• The matrix should be chosen to have higher scores than the rotated score to prevent spurious rotations from being added.

Fields

mismatch: i8

The score for a mismatch, this is used as the full score of that step.

Default: -1.

mass_mismatch: i8

The additional score for a step if the amino acids are identical but the mass of the sequence elements are not the same. This is the case if the pair mode is PairMode::DatabaseToPeptidoform or PairMode::PeptidoformToDatabase and the peptidoform has a modification at this location that does not occur in the database. The local score for the step is calculated as follows: matrix_score + mass_mismatch.

Default: 0.

mass_base: i8

The base score for mass based steps, added to both rotated and isobaric steps.

Default: 1.

rotated: i8

The per position score for a rotated step match. The full score is calculated as follows mass_base + rotated * len_a.

Default: 3.

isobaric: i8

The per position score for an isobaric step match. The full score is calculated as follows mass_base + isobaric * (len_a + len_b) / 2.

Default: 2.

gap_start: i8

The gap start score for affine gaps, this is the score for starting any gap. The total score for a full gap will be gap_start + gap_extend * len.

Default: -4.

gap_extend: i8

The gap extend for affine gaps.

Default: -1.

matrix: &'a [[i8; 26]; 26]

The matrix to find the score for matching any amino acid to any other aminoacid. It is indexed by the amino acid.

Default: BLOSUM62.

tolerance: Tolerance<OrderedMass>

The tolerance of mass equality.

Default: 10ppm.

mass_mode: MassMode

The mass mode for the alignment.

Default: Monoisotopic.

pair: PairMode

The pair mode for the alignment.

Default: Same.

Trait Implementations

impl<'a> Clone for AlignScoring<'a>

fn clone(&self) -> AlignScoring<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for AlignScoring<'a>

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

Formats the value using the given formatter.

impl Default for AlignScoring<'static>

fn default() -> Self

Returns the “default value” for a type.

impl<'a> Hash for AlignScoring<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> Ord for AlignScoring<'a>

fn cmp(&self, other: &AlignScoring<'a>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<'a> PartialEq for AlignScoring<'a>

fn eq(&self, other: &AlignScoring<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialOrd for AlignScoring<'a>

fn partial_cmp(&self, other: &AlignScoring<'a>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a> Copy for AlignScoring<'a>

impl<'a> Eq for AlignScoring<'a>

impl<'a> StructuralPartialEq for AlignScoring<'a>