affine_gap_policy.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2006-2025 Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2025 Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
#include <seqan3/alignment/configuration/align_config_gap_cost_affine.hpp>
#include <seqan3/alignment/matrix/detail/trace_directions.hpp>
#include <seqan3/alignment/pairwise/detail/alignment_algorithm_state.hpp>
#include <seqan3/utility/concept.hpp>
 
namespace seqan3::detail
{
 
// ----------------------------------------------------------------------------
// affine_gap_policy
// ----------------------------------------------------------------------------
 
template <typename alignment_algorithm_t, typename score_t, typename align_local_t = std::false_type>
class affine_gap_policy
{
private:
    friend alignment_algorithm_t;
 
    using alignment_state_t = alignment_algorithm_state<score_t>;
 
    constexpr affine_gap_policy() noexcept = default;                                      
    constexpr affine_gap_policy(affine_gap_policy const &) noexcept = default;             
    constexpr affine_gap_policy(affine_gap_policy &&) noexcept = default;                  
    constexpr affine_gap_policy & operator=(affine_gap_policy const &) noexcept = default; 
    constexpr affine_gap_policy & operator=(affine_gap_policy &&) noexcept = default;      
    ~affine_gap_policy() noexcept = default;                                               
 
    template <typename configuration_t>
    affine_gap_policy(configuration_t const & /*config*/)
    {}
 
    template <typename cell_t>
    constexpr void
    compute_cell(cell_t && current_cell, alignment_algorithm_state<score_t> & cache, score_t const score) const noexcept
    {
        // score_cell = seqan3::detail::alignment_score_matrix_proxy
        // trace_cell = seqan3::detail::alignment_trace_matrix_proxy
        auto & [score_cell, trace_cell] = current_cell;
        constexpr bool with_trace = !decays_to_ignore_v<std::remove_reference_t<decltype(trace_cell.current)>>;
        // Precompute the diagonal score.
        score_t tmp = score_cell.diagonal + score;
 
        if constexpr (with_trace)
        {
            tmp = (tmp < score_cell.up) ? (trace_cell.current = trace_cell.up, score_cell.up)
                                        : (trace_cell.current = trace_directions::diagonal | trace_cell.up, tmp);
            tmp = (tmp < score_cell.r_left)
                    ? (trace_cell.current = trace_cell.r_left | (trace_cell.current & trace_directions::carry_up_open),
                       score_cell.r_left)
                    : (trace_cell.current |= trace_cell.r_left, tmp);
        }
        else
        {
            tmp = (tmp < score_cell.up) ? score_cell.up : tmp;
            tmp = (tmp < score_cell.r_left) ? score_cell.r_left : tmp;
        }
 
        if constexpr (align_local_t::value)
            tmp = (tmp < 0) ? (trace_cell.current = trace_directions::none, 0) : tmp;
 
        // Store the current max score.
        score_cell.current = tmp;
        // Check if this was the optimum. Possibly a noop.
        static_cast<alignment_algorithm_t const &>(*this).check_score_of_cell(current_cell, cache);
 
        // Prepare horizontal and vertical score for next column.
        tmp += cache.gap_open_score;
        score_cell.up += cache.gap_extension_score;
        score_cell.w_left = score_cell.r_left + cache.gap_extension_score;
 
        score_cell.up = (score_cell.up < tmp) ? (trace_cell.up = trace_directions::up_open, tmp)
                                              : (trace_cell.up = trace_directions::up, score_cell.up);
        score_cell.w_left = (score_cell.w_left < tmp) ? (trace_cell.w_left = trace_directions::left_open, tmp)
                                                      : (trace_cell.w_left = trace_directions::left, score_cell.w_left);
    }
 
    template <typename cell_t>
    constexpr void compute_first_band_cell(cell_t && current_cell,
                                           alignment_algorithm_state<score_t> & cache,
                                           score_t const score) const noexcept
    {
        // Compute the diagonal score and the compare with the previous horizontal value.
        // score_cell = seqan3::detail::alignment_score_matrix_proxy
        // trace_cell = seqan3::detail::alignment_trace_matrix_proxy
        auto & [score_cell, trace_cell] = current_cell;
        score_cell.current = score_cell.diagonal + score;
 
        score_cell.current = (score_cell.current < score_cell.r_left)
                               ? (trace_cell.current = trace_cell.r_left, score_cell.r_left)
                               : (trace_cell.current = trace_directions::diagonal, score_cell.current);
 
        if constexpr (align_local_t::value)
        {
            score_cell.current =
                (score_cell.current < 0) ? (trace_cell.current = trace_directions::none, 0) : score_cell.current;
        }
        // Check if this was the optimum. Possibly a noop.
        static_cast<alignment_algorithm_t const &>(*this).check_score_of_cell(current_cell, cache);
 
        // At the top of the band we can not come from up but only diagonal or left, so the next vertical must be a
        // gap open.
        score_cell.up = score_cell.current + cache.gap_open_score; // add gap open cost
        trace_cell.up = trace_directions::up_open;
    }
 
    template <typename alignment_configuration_t>
    constexpr void initialise_alignment_state(alignment_configuration_t const & config) noexcept
    {
        auto scheme =
            config.get_or(align_cfg::gap_cost_affine{align_cfg::open_score{0}, align_cfg::extension_score{-1}});
 
        alignment_state.gap_extension_score = static_cast<score_t>(scheme.extension_score);
        alignment_state.gap_open_score = static_cast<score_t>(scheme.extension_score + scheme.open_score);
    }
 
    alignment_state_t alignment_state{}; 
};
 
} // namespace seqan3::detail