src/LocARNA/aligner_impl.hh

#ifndef LOCARNA_ALIGNER_IMPL_HH
#define LOCARNA_ALIGNER_IMPL_HH

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include "aligner.hh"

#include "aligner_restriction.hh"
#include "scoring.hh"
#include "alignment.hh"
#include "arc_matches.hh"
#include "params.hh"

namespace LocARNA {

    class Sequence;
    template <class T>
    class Matrix;

    class AlignerImpl {
    public:
        typedef ScoreMatrix M_matrix_t;

        typedef BasePairs__Arc Arc;

        const AlignerParams *params_; 

        const Scoring *scoring_; 
        Scoring *mod_scoring_; 


        const Sequence &seqA_; 
        const Sequence &seqB_; 

        const ArcMatches
            &arc_matches_; 

        const BasePairs &bpsA_; 
        const BasePairs &bpsB_; 

        AlignerRestriction r_;

        ScoreMatrix Dmat_;

        std::vector<M_matrix_t> Ms_;

        std::vector<ScoreVector> Es_;

        std::vector<infty_score_t> Fs_;

        int min_i_; 
        int min_j_; 

        int max_i_; 
        int max_j_; 

        bool D_created_; 

        Alignment alignment_; 

        enum {
            E_NO_NO,
            E_X_NO,
            E_NO_X,
            E_X_X,
            E_OP_NO,
            E_NO_OP,
            E_OP_X,
            E_X_OP
        };

        // ============================================================
        class UnmodifiedScoringView {
        private:
            const AlignerImpl *
                aligner_impl_; 
        public:
            explicit UnmodifiedScoringView(const AlignerImpl *aligner_impl)
                : aligner_impl_(aligner_impl){};

            const Scoring *
            scoring() const {
                return aligner_impl_->scoring_;
            }

            infty_score_t
            D(const Arc &a, const Arc &b) const {
                return aligner_impl_->Dmat_(a.idx(), b.idx());
            }

            infty_score_t
            D(const ArcMatch &am) const {
                return D(am.arcA(), am.arcB());
            }
        };

        class ModifiedScoringView {
        private:
            const AlignerImpl *
                aligner_impl_; 

            score_t lambda_; 

            size_t
            arc_length(const Arc &a) const {
                return a.right() - a.left() + 1;
            }

        public:
            explicit ModifiedScoringView(const AlignerImpl *aligner_impl)
                : aligner_impl_(aligner_impl), lambda_(0) {}

            void
            set_lambda(score_t lambda) {
                lambda_ = lambda;
            }

            const Scoring *
            scoring() const {
                return aligner_impl_->mod_scoring_;
            }

            infty_score_t
            D(const Arc &a, const Arc &b) const {
                return aligner_impl_->Dmat_(a.idx(), b.idx()) -
                    FiniteInt(lambda_ * (arc_length(a) + arc_length(b)));
            }

            infty_score_t
            D(const ArcMatch &am) const {
                return aligner_impl_->Dmat_(am.arcA().idx(), am.arcB().idx()) -
                    FiniteInt(lambda_ *
                              (arc_length(am.arcA()) + arc_length(am.arcB())));
            }
        };

        const UnmodifiedScoringView def_scoring_view_; 
        ModifiedScoringView mod_scoring_view_; 

        FreeEndgapsDescription free_endgaps_;

        // ============================================================

        AlignerImpl(const AlignerImpl &a);

        AlignerImpl(const Sequence &seqA,
                    const Sequence &seqB,
                    const ArcMatches &arc_matches,
                    const AlignerParams *ap,
                    const Scoring *s);

        ~AlignerImpl();

        // ============================================================

        template <class ScoringView>
        void
        init_state(int state,
                   pos_type al,
                   pos_type ar,
                   pos_type bl,
                   pos_type br,
                   bool globalA,
                   bool exclA,
                   bool globalB,
                   bool exclB,
                   ScoringView sv);

        template <class ScoringView>
        infty_score_t
        align_noex(int state,
                   pos_type al,
                   pos_type bl,
                   pos_type i,
                   pos_type j,
                   ScoringView sv);

        void
        align_in_arcmatch(pos_type al,
                          pos_type ar,
                          pos_type bl,
                          pos_type br,
                          bool allow_exclusion);

        infty_score_t
        align_top_level_free_endgaps();

        template <class ScoringView>
        infty_score_t
        align_top_level_locally(ScoringView sv);

        // infty_score_t align_top_level_localB();

        template <class ScoringView>
        void
        trace_in_arcmatch(int state,
                          int al,
                          int i,
                          int bl,
                          int j,
                          bool top_level,
                          ScoringView sv);

        template <class ScoringView>
        void
        trace_noex(int state,
                   pos_type al,
                   pos_type i,
                   pos_type bl,
                   pos_type j,
                   bool top_level,
                   ScoringView sv);

        void
        trace_arcmatch(const ArcMatch &am);

        void
        trace_arcmatch_noLP(const ArcMatch &am);

        infty_score_t
        align();

        void
        align_D();

        void
        fill_D_entries(pos_type al, pos_type bl);

        void
        fill_D_entries_noLP(pos_type al, pos_type bl);

        infty_score_t &
        D(const ArcMatch &am) {
            return Dmat_(am.arcA().idx(), am.arcB().idx());
        }

        infty_score_t &
        D(const Arc &arcA, const Arc &arcB) {
            return Dmat_(arcA.idx(), arcB.idx());
        }

        template <class ScoringView>
        void
        trace(ScoringView sv);
    };

} // end namespace LocARNA

#endif // LOCARNA_ALIGNER_IMPL_HH