sigalign-core 0.2.1

A core crate for sigalign
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

use crate::{
    algorithm::{
        SparePenaltyCalculator, TraversedAnchor,
    },
    aligner::{
        regulator::AlignmentRegulator, workspace::{
            AllocationStrategy, DefaultDoublingStrategy, QueryLengthChecker, WaveFrontBuffer
        }
    },
    results::AlignmentOperations,
};

#[derive(Clone)]
pub struct SemiGlobalWorkspace {
    query_length_checker: QueryLengthChecker<DefaultDoublingStrategy>,
    pub spare_penalty_calculator: SparePenaltyCalculator,
    pub wave_front_buffer: WaveFrontBuffer,
    pub traversed_anchors_buffer: Vec<TraversedAnchor>,
    pub operations_buffer: Vec<AlignmentOperations>,
}
impl SemiGlobalWorkspace {
    pub fn init(regulator: &AlignmentRegulator) -> Self {
        let allocation_strategy = DefaultDoublingStrategy::new();
        let query_length_checker = QueryLengthChecker::new(allocation_strategy);
        let initial_query_length = query_length_checker.get_allocated_length();

        let spare_penalty_calculator = SparePenaltyCalculator::new(
            &regulator.penalties,
            regulator.cutoff.maximum_scaled_penalty_per_length,
            regulator.pattern_size,
            initial_query_length / regulator.pattern_size,
        );

        let wave_front_buffer = WaveFrontBuffer::new(initial_query_length, regulator.cutoff.maximum_scaled_penalty_per_length, &regulator.penalties);
        Self {
            query_length_checker,
            spare_penalty_calculator,
            wave_front_buffer,
            traversed_anchors_buffer: Vec::new(),
            operations_buffer: Vec::new(),
        }
    }
    pub fn allocate_more_space_if_needed(
        &mut self,
        query_length: u32,
        regulator: &AlignmentRegulator,
    ) {
        if let Some(required_query_length) = self.query_length_checker.optional_length_to_be_allocated(query_length) {
            let k = regulator.pattern_size;
            let max_pattern_count = required_query_length / k;
            self.spare_penalty_calculator.precalculate_right_spare_penalty(
                max_pattern_count,
            );

            self.wave_front_buffer.allocate(
                required_query_length,
                regulator.cutoff.maximum_scaled_penalty_per_length,
                &regulator.penalties,
            );
        }
    }
}