Struct bio_types::alignment::Alignment

pub struct Alignment {
    pub score: i32,
    pub ystart: usize,
    pub xstart: usize,
    pub yend: usize,
    pub xend: usize,
    pub ylen: usize,
    pub xlen: usize,
    pub operations: Vec<AlignmentOperation>,
    pub mode: AlignmentMode,
}

We consider alignment between two sequences x and y. x is the query or read sequence and y is the reference or template sequence. An alignment, consisting of a score, the start and end position of the alignment on sequence x and sequence y, the lengths of sequences x and y, and the alignment edit operations. The start position and end position of the alignment does not include the clipped regions. The length of clipped regions are already encapsulated in the Alignment Operation.

Fields

score: i32

Smith-Waterman alignment score

ystart: usize

Start position of alignment in reference

xstart: usize

Start position of alignment in query

yend: usize

End position of alignment in reference

xend: usize

End position of alignment in query

ylen: usize

Length of the reference sequence

xlen: usize

Length of the query sequence

operations: Vec<AlignmentOperation>

Vector of alignment operations

mode: AlignmentMode

Implementations

impl Alignment

pub fn cigar(&self, hard_clip: bool) -> String

Calculate the cigar string from the alignment struct. x is the target string

Example

use bio_types::alignment::{Alignment,AlignmentMode};
use bio_types::alignment::AlignmentOperation::{Match, Subst, Ins, Del};
let alignment = Alignment {
    score: 5,
    xstart: 3,
    ystart: 0,
    xend: 9,
    yend: 10,
    ylen: 10,
    xlen: 10,
    operations: vec![Match, Match, Match, Subst, Ins, Ins, Del, Del],
    mode: AlignmentMode::Semiglobal
};
assert_eq!(alignment.cigar(false), "3S3=1X2I2D1S");

pub fn pretty(&self, x: TextSlice<'_>, y: TextSlice<'_>, ncol: usize) -> String

Return the pretty formatted alignment as a String. The string contains sets of 3 lines of length 100. First line is for the sequence x, second line is for the alignment operation and the the third line is for the sequence y. A ‘-’ in the sequence indicates a blank (insertion/deletion). The operations follow the following convention: ‘|’ for a match, ‘\’ (a single backslash) for a mismatch, ‘+’ for an insertion, ‘x’ for a deletion and ’ ’ for clipping

Example

If we align the strings “CCGTCCGGCAAGGG” and “AAAAACCGTTGACGGCCAA” in various modes, we will get the following output:

Semiglobal:

        CCGTCCGGCAAGGG
        ||||++++\\|\||
   AAAAACCGT----TGACGGCCAA

Local:

        CCGTCCGGCAAGGG
        ||||
   AAAAACCGT          TGACGGCCAA

Global:

   -----CCGT--CCGGCAAGGG
   xxxxx||||xx\||||\|++\
   AAAAACCGTTGACGGCCA--A

pub fn path(&self) -> Vec<(usize, usize, AlignmentOperation)>

Returns the optimal path in the alignment matrix

Example

use bio_types::alignment::{Alignment,AlignmentMode};
use bio_types::alignment::AlignmentOperation::*;
let alignment = Alignment {
    score: 5,
    xstart: 3,
    ystart: 0,
    xend: 9,
    yend: 10,
    ylen: 10,
    xlen: 10,
    operations: vec![Match, Match, Match, Subst, Ins, Ins, Del, Del],
    mode: AlignmentMode::Semiglobal,
};
assert_eq!(alignment.path(),[
    (4, 5, Match),
    (5, 6, Match),
    (6, 7, Match),
    (7, 8, Subst),
    (8, 8, Ins),
    (9, 8, Ins),
    (9, 9, Del),
    (9, 10, Del)])

pub fn filter_clip_operations(&mut self)

Filter out Xclip and Yclip operations from the list of operations. Useful when invoking the standard modes.

pub fn y_aln_len(&self) -> usize

Number of bases in reference sequence that are aligned

pub fn x_aln_len(&self) -> usize

Number of bases in query sequence that are aigned

Trait Implementations

impl Clone for Alignment

fn clone(&self) -> Alignment

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Alignment

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

Formats the value using the given formatter.

impl Default for Alignment

fn default() -> Alignment

Returns the “default value” for a type.

impl PartialEq<Alignment> for Alignment

fn eq(&self, other: &Alignment) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for Alignment

impl StructuralEq for Alignment

impl StructuralPartialEq for Alignment