Pass additional TSM starts and ends through to context.

sebschmi · sebschmi · commit 248ebca065cd · 2026-05-28T12:16:29.000+03:00
diff --git a/lib_tsalign/src/a_star_aligner.rs b/lib_tsalign/src/a_star_aligner.rs
@@ -22,7 +22,10 @@ use traitsequence::interface::Sequence;
 use crate::{
     a_star_aligner::{
         alignment_result::alignment::Alignment,
-        template_switch_distance::context::DynamicStrategies,
+        template_switch_distance::{
+            context::DynamicStrategies,
+            strategies::allow_ts_14_out_of_range::AdditionalExplicitTSMStartsAndEnds,
+        },
     },
     config,
 };
@@ -188,6 +191,7 @@ pub fn template_switch_distance_a_star_align<
     reference_name: &str,
     query_name: &str,
     mut range: AlignmentRange,
+    additional_tsm_starts_and_ends: AdditionalExplicitTSMStartsAndEnds,
     config: &config::TemplateSwitchConfig<
         Strategies::Alphabet,
         <Strategies as AlignmentStrategySelector>::Cost,
@@ -226,6 +230,7 @@ where
             reference_name,
             query_name,
             range.clone(),
+            additional_tsm_starts_and_ends,
             config.clone(),
             memory,
             dynamic_strategies,
diff --git a/lib_tsalign/src/a_star_aligner/configurable_a_star_align.rs b/lib_tsalign/src/a_star_aligner/configurable_a_star_align.rs
@@ -13,6 +13,9 @@ use crate::{
             context::DynamicStrategies,
             strategies::{
                 AlignmentStrategySelection,
+                allow_ts_14_out_of_range::{
+                    AdditionalExplicitTSMStartsAndEnds, Ts14OutOfRangeStrategy,
+                },
                 descendant::{
                     AnyTemplateSwitchDescendantStrategy, OnlyEqualTemplateSwitchDescendantStrategy,
                     TemplateSwitchDescendantStrategy,
@@ -112,6 +115,7 @@ struct QueryData<'a> {
     query_name: &'a str,
     query: &'a [u8],
     ranges: Option<AlignmentRange>,
+    gap_characters: &'a [u8],
     cost_limit: Option<u64>,
     memory_limit: Option<usize>,
     extend_beyond_range: bool,
@@ -127,6 +131,7 @@ pub struct Aligner<AlphabetType: Alphabet = DnaAlphabetOrN> {
     chaining_strategy: ChainingStrategySelector,
     total_length_strategy: TotalLengthStrategySelector,
     descendant_strategy: DescendantStrategySelector,
+    ts_14_out_of_range_strategy: Ts14OutOfRangeStrategy,
     no_ts: bool,
 }
 
@@ -143,10 +148,11 @@ impl<AlphabetType: Alphabet> Default for Aligner<AlphabetType> {
     fn default() -> Self {
         Self {
             costs: TemplateSwitchConfig::<AlphabetType, U64Cost>::default(),
-            min_length_strategy: MinLengthStrategySelector::default(),
-            chaining_strategy: ChainingStrategySelector::default(),
-            total_length_strategy: TotalLengthStrategySelector::default(),
-            descendant_strategy: DescendantStrategySelector::default(),
+            min_length_strategy: Default::default(),
+            chaining_strategy: Default::default(),
+            total_length_strategy: Default::default(),
+            descendant_strategy: Default::default(),
+            ts_14_out_of_range_strategy: Default::default(),
             no_ts: false,
         }
     }
@@ -204,7 +210,20 @@ impl<AlphabetType: Alphabet> Aligner<AlphabetType> {
         self
     }
 
-    /// This performs the actual alignment and is, depending on the inputs, potentially taking quite long.
+    pub fn set_ts_14_out_of_range_strategy(
+        &mut self,
+        ts_14_out_of_range_strategy: Ts14OutOfRangeStrategy,
+    ) -> &mut Self {
+        self.ts_14_out_of_range_strategy = ts_14_out_of_range_strategy;
+        self
+    }
+
+    /// Perform the actual alignment.
+    ///
+    /// Special gap characters can be specified in order to interpret the given sequences as an alignment with gaps instead of raw sequences.
+    /// In this case, the range coordinates must refer to the ungapped sequences.
+    ///
+    /// Depending on the inputs, this takes quite long.
     /// Consider spawning tasks to not block the user application.
     #[allow(
         clippy::too_many_arguments,
@@ -218,6 +237,7 @@ impl<AlphabetType: Alphabet> Aligner<AlphabetType> {
         query_name: &str,
         query: &[u8],
         ranges: Option<AlignmentRange>,
+        gap_characters: &[u8],
         cost_limit: Option<u64>,
         memory_limit: Option<usize>,
         extend_beyond_range: bool,
@@ -228,6 +248,7 @@ impl<AlphabetType: Alphabet> Aligner<AlphabetType> {
             query_name,
             query,
             ranges,
+            gap_characters,
             cost_limit,
             memory_limit,
             extend_beyond_range,
@@ -336,9 +357,48 @@ impl<AlphabetType: Alphabet> Aligner<AlphabetType> {
         count_strategy_memory: TC::Memory,
     ) -> AlignmentResult<AlignmentType, U64Cost> {
         // TODO error handling
-        let reference = VectorGenome::<AlphabetType>::from_slice_u8(data.reference).unwrap();
-        let query = VectorGenome::from_slice_u8(data.query).unwrap();
+        let reference = VectorGenome::<AlphabetType>::from_iter_u8(
+            data.reference
+                .iter()
+                .copied()
+                .filter(|c| !data.gap_characters.contains(c)),
+        )
+        .unwrap();
+        let query = VectorGenome::from_iter_u8(
+            data.query
+                .iter()
+                .copied()
+                .filter(|c| !data.gap_characters.contains(c)),
+        )
+        .unwrap();
+
+        let range = data
+            .ranges
+            .unwrap_or_else(|| AlignmentRange::new_complete(reference.len(), query.len()));
+        let additional_tsm_starts_and_ends =
+            if self.ts_14_out_of_range_strategy == Ts14OutOfRangeStrategy::Allow {
+                AdditionalExplicitTSMStartsAndEnds::new(
+                    &data
+                        .reference
+                        .iter()
+                        .map(|c| *c as char)
+                        .collect::<String>(),
+                    &data.query.iter().map(|c| *c as char).collect::<String>(),
+                    &range,
+                    &data
+                        .gap_characters
+                        .iter()
+                        .map(|c| *c as char)
+                        .collect::<Vec<_>>(),
+                    false,
+                )
+                .unwrap()
+            } else {
+                AdditionalExplicitTSMStartsAndEnds::default()
+            };
+
         let cost_limit = data.cost_limit.map(U64Cost::from);
+
         template_switch_distance_a_star_align::<
             AlignmentStrategySelection<
                 AlphabetType,
@@ -360,8 +420,8 @@ impl<AlphabetType: Alphabet> Aligner<AlphabetType> {
             query.as_genome_subsequence(),
             data.reference_name,
             data.query_name,
-            data.ranges
-                .unwrap_or_else(|| AlignmentRange::new_complete(reference.len(), query.len())),
+            range,
+            additional_tsm_starts_and_ends,
             &self.costs,
             DynamicStrategies {},
             cost_limit,
@@ -395,6 +455,7 @@ mod tests {
                 AlignmentCoordinates::new(27, 200),
                 AlignmentCoordinates::new(33, 214)
             ).into(),
+            &[],
             None,
             None,
         true);
diff --git a/lib_tsalign/src/a_star_aligner/template_switch_distance/context.rs b/lib_tsalign/src/a_star_aligner/template_switch_distance/context.rs
@@ -7,6 +7,7 @@ use generic_a_star::reset::Reset;
 use generic_a_star::{AStarBuffers, AStarContext};
 use num_traits::{Bounded, Zero};
 
+use crate::a_star_aligner::template_switch_distance::strategies::allow_ts_14_out_of_range::AdditionalExplicitTSMStartsAndEnds;
 use crate::a_star_aligner::template_switch_distance::strategies::primary_range::PrimaryRangeStrategy;
 use crate::a_star_aligner::template_switch_distance::{Node, TemplateSwitchDirection};
 use crate::a_star_aligner::{AlignmentContext, AlignmentRange};
@@ -35,6 +36,7 @@ pub struct Context<
     pub query_name: String,
 
     pub range: AlignmentRange,
+    pub additional_tsm_starts_and_ends: AdditionalExplicitTSMStartsAndEnds,
 
     pub config: TemplateSwitchConfig<Strategies::Alphabet, Strategies::Cost>,
 
@@ -77,6 +79,7 @@ impl<
         reference_name: &str,
         query_name: &str,
         range: AlignmentRange,
+        additional_tsm_starts_and_ends: AdditionalExplicitTSMStartsAndEnds,
         config: TemplateSwitchConfig<Strategies::Alphabet, Strategies::Cost>,
         memory: Memory<Strategies>,
         dynamic_strategies: DynamicStrategies,
@@ -90,6 +93,7 @@ impl<
             reference_name: reference_name.to_owned(),
             query_name: query_name.to_owned(),
             range,
+            additional_tsm_starts_and_ends,
             config,
             a_star_buffers: Default::default(),
             memory,
diff --git a/lib_tsalign/src/a_star_aligner/template_switch_distance/lower_bounds/template_switch.rs b/lib_tsalign/src/a_star_aligner/template_switch_distance/lower_bounds/template_switch.rs
@@ -100,6 +100,7 @@ impl<Cost: AStarCost> TemplateSwitchLowerBoundMatrix<Cost> {
                 "",
                 "",
                 AlignmentRange::new_complete(genome.len(), genome.len()),
+                Default::default(),
                 lower_bound_config.clone(),
                 Memory {
                     template_switch_min_length: (),
diff --git a/lib_tsalign/src/a_star_aligner/template_switch_distance/lower_bounds/template_switch_alignment.rs b/lib_tsalign/src/a_star_aligner/template_switch_distance/lower_bounds/template_switch_alignment.rs
@@ -100,6 +100,7 @@ impl<Cost: AStarCost> TemplateSwitchAlignmentLowerBoundMatrix<Cost> {
                 "",
                 "",
                 AlignmentRange::new_complete(genome.len(), genome.len()),
+                Default::default(),
                 lower_bound_config.clone(),
                 Memory {
                     template_switch_min_length: (),
diff --git a/lib_tsalign/src/a_star_aligner/template_switch_distance/strategies/allow_ts_14_out_of_range.rs b/lib_tsalign/src/a_star_aligner/template_switch_distance/strategies/allow_ts_14_out_of_range.rs
@@ -2,9 +2,12 @@ use thiserror::Error;
 
 use crate::a_star_aligner::alignment_geometry::{AlignmentCoordinates, AlignmentRange};
 
-#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+#[derive(Debug, Default, Clone, Copy, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
 pub enum Ts14OutOfRangeStrategy {
     /// TSMs are not allowed to start or end outside of the specified alignment ranges.
+    #[default]
     Disallow,
     /// TSMs are allowed to start or end outside of the specified alignment ranges.
     Allow,
@@ -30,7 +33,7 @@ impl AdditionalExplicitTSMStartsAndEnds {
         original_reference: &str,
         original_query: &str,
         range: &AlignmentRange,
-        skip_characters: Vec<char>,
+        skip_characters: &[char],
         has_embedded_rq_ranges: bool,
     ) -> Result<Self, AdditionalExplicitTSMStartsAndEndsError> {
         let mut explicit_tsm_starts = Vec::new();
@@ -234,7 +237,7 @@ mod tests {
             original_reference,
             original_query,
             &range,
-            skip_characters,
+            &skip_characters,
             true,
         )
         .unwrap();
diff --git a/lib_tsalign/src/tests.rs b/lib_tsalign/src/tests.rs
@@ -72,6 +72,7 @@ fn test_tsnax_disc1_473() {
         "ref",
         "qry",
         range.clone(),
+        Default::default(),
         &config,
         DynamicStrategies {},
         None,
@@ -115,6 +116,7 @@ fn test_tsnax_disc1_473() {
         "ref",
         "qry",
         range.clone(),
+        Default::default(),
         &config,
         DynamicStrategies {},
         None,
@@ -148,6 +150,7 @@ fn test_tsnax_disc1_473() {
         "ref",
         "qry",
         range.clone(),
+        Default::default(),
         &config,
         DynamicStrategies {},
         None,
@@ -181,6 +184,7 @@ fn test_tsnax_disc1_473() {
         "ref",
         "qry",
         range.clone(),
+        Default::default(),
         &config,
         DynamicStrategies {},
         None,
diff --git a/tsalign/src/align.rs b/tsalign/src/align.rs
@@ -412,13 +412,13 @@ fn execute_with_alphabet<AlphabetType: Alphabet + Debug + Clone + Eq + 'static>(
     };
 
     // If requested, compute the additional starts and ends of TSMs outside of the given ranges.
-    let _additional_tsm_starts_and_ends =
+    let additional_tsm_starts_and_ends =
         if cli.allow_ts_14_out_of_range == Ts14OutOfRangeStrategy::Allow {
             AdditionalExplicitTSMStartsAndEnds::new(
                 &original_reference,
                 &original_query,
                 &range,
-                skip_characters,
+                &skip_characters,
                 cli.use_embedded_rq_ranges,
             )?
         } else {
@@ -455,6 +455,7 @@ fn execute_with_alphabet<AlphabetType: Alphabet + Debug + Clone + Eq + 'static>(
             reference_sequence,
             query_sequence,
             range,
+            additional_tsm_starts_and_ends,
             &format!("{} {}", reference_record.id, reference_record.comment),
             &format!("{} {}", query_record.id, query_record.comment),
         ),
diff --git a/tsalign/src/align/template_switch_distance_type_selectors.rs b/tsalign/src/align/template_switch_distance_type_selectors.rs
