aligner_n.hh

#ifndef LOCARNA_ALIGNER_N_HH
#define LOCARNA_ALIGNER_N_HH
 
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
 
#include "sequence.hh"
#include "basepairs.hh"
#include "sparsification_mapper.hh"
#include "arc_matches.hh"
#include "alignment.hh"
 
#include "aligner_params.hh"
#include "scoring.hh"
 
#include "matrix.hh"
 
#include "aligner_restriction.hh"
 
namespace LocARNA {
 
    class AlignerN {
    public:
        typedef BasePairs__Arc Arc; 
        typedef SparsificationMapper::ArcIdx ArcIdx; 
        typedef SparsificationMapper::ArcIdxVec
            ArcIdxVec; 
        typedef SparsificationMapper::matidx_t
            matidx_t; 
        typedef SparsificationMapper::seq_pos_t
            seq_pos_t; 
        typedef SparsificationMapper::index_t index_t; 
 
        typedef ScoreMatrix M_matrix_t;
 
    protected:
        const std::unique_ptr<AlignerNParams> params; 
 
        const Scoring *scoring; 
        Scoring *mod_scoring;   
        const Sequence &seqA;   
        const Sequence &seqB;   
 
        const SparsificationMapper
            &mapperA; 
        const SparsificationMapper
            &mapperB; 
 
        const ArcMatches
            &arc_matches; 
 
        const BasePairs &bpsA; 
        const BasePairs &bpsB; 
 
        AlignerRestriction r;
 
        ScoreMatrix Dmat;
 
        ScoreMatrix IAmat;
        ScoreMatrix IBmat;
 
        ScoreMatrix IADmat;
        ScoreMatrix IBDmat;
 
        ScoreMatrix Emat;
        ScoreMatrix Fmat;
 
        M_matrix_t M;
 
        ScoreMatrix gapCostMatA;
 
        ScoreMatrix gapCostMatB;
 
        int min_i; 
        int min_j; 
        int max_i; 
        int max_j; 
 
        bool D_created; 
 
        Alignment alignment; 
 
        // ============================================================
        class UnmodifiedScoringViewN {
        protected:
            const AlignerN
                *alignerN_; 
        public:
            explicit UnmodifiedScoringViewN(const AlignerN *alignerN)
                : alignerN_(alignerN){};
 
            const Scoring *
            scoring() const {
                return alignerN_->scoring;
            }
 
            infty_score_t
            D(const Arc &a, const Arc &b) const {
                return alignerN_->Dmat(a.idx(), b.idx());
            }
 
            infty_score_t
            D(bool isA, const Arc &arcX, const Arc &arcY) {
                if (isA)
                    return D(arcX, arcY);
                else
                    return D(arcY, arcX);
            }
 
            infty_score_t
            D(const ArcMatch &am) const {
                return D(am.arcA(), am.arcB());
            }
        };
 
        // TODO: required? ModifiedScoringView
        class ModifiedScoringViewN {
        protected:
            const AlignerN
                *alignerN_; 
 
            score_t lambda_; 
 
            size_t
            arc_length(const Arc &a) const {
                return a.right() - a.left() + 1;
            }
 
        public:
            explicit ModifiedScoringViewN(const AlignerN *alignerN)
                : alignerN_(alignerN), lambda_(0) {}
 
            void
            set_lambda(score_t lambda) {
                lambda_ = lambda;
            }
 
            const Scoring *
            scoring() const {
                return alignerN_->mod_scoring;
            }
 
            infty_score_t
            D(const Arc &a, const Arc &b) const {
                return alignerN_->Dmat(a.idx(), b.idx()) -
                    lambda_ * (arc_length(a) + arc_length(b));
            }
 
            infty_score_t
            D(const ArcMatch &am) const {
                return alignerN_->Dmat(am.arcA().idx(), am.arcB().idx()) -
                    lambda_ * (arc_length(am.arcA()) + arc_length(am.arcB()));
            }
        };
 
        const UnmodifiedScoringViewN def_scoring_view; 
        ModifiedScoringViewN mod_scoring_view; 
 
        // ============================================================
 
        template <class ScoringView>
        void
        init_M_E_F(pos_type al,
                   pos_type ar,
                   pos_type bl,
                   pos_type br,
                   ScoringView sv);
 
        template <bool isA, class ScoringView>
        void
        initGapCostMat(ScoringView sv);
 
        template <bool isA>
        infty_score_t
        getGapCostBetween(pos_type leftSide, pos_type rightSide);
 
        template <bool isA, class ScoringView>
        infty_score_t
        compute_IX(pos_type xl, const Arc &arcY, pos_type i, ScoringView sv);
 
        void
        fill_IA_entries(pos_type al, Arc arcB, pos_type max_ar);
 
        void
        fill_IB_entries(Arc arcA, pos_type bl, pos_type max_br);
 
        template <class ScoringView>
        infty_score_t
        compute_E_entry(index_t al,
                        matidx_t i_index,
                        matidx_t j_index,
                        seq_pos_t i_seq_pos,
                        seq_pos_t i_prev_seq_pos,
                        ScoringView sv);
 
        template <class ScoringView>
        infty_score_t
        compute_F_entry(index_t bl,
                        matidx_t i_index,
                        matidx_t j_index,
                        seq_pos_t i_seq_pos,
                        seq_pos_t i_prev_seq_pos,
                        ScoringView sv);
        template <class ScoringView>
        infty_score_t
        compute_M_entry(index_t al,
                        index_t bl,
                        matidx_t index_i,
                        matidx_t index_j,
                        ScoringView sv);
        //---------------------------------------------------------------------------------
 
        void
        fill_M_entries(pos_type al, pos_type ar, pos_type bl, pos_type br);
 
        template <class ScoringView>
        void
        trace_E(pos_type al,
                matidx_t i_index,
                pos_type bl,
                matidx_t j_index,
                bool top_level,
                ScoringView sv);
 
        template <class ScoringView>
        void
        trace_F(pos_type al,
                matidx_t i_index,
                pos_type bl,
                matidx_t j_index,
                bool top_level,
                ScoringView sv);
 
        template <class ScoringView>
        void
        trace_M(pos_type al,
                matidx_t i_index,
                pos_type bl,
                matidx_t j_index,
                bool tl,
                ScoringView sv);
 
        template <class ScoringView>
        void
        trace_M_noex(pos_type al,
                     pos_type i,
                     pos_type bl,
                     pos_type j,
                     bool top_level,
                     ScoringView sv);
 
        template <bool isA, class ScoringView>
        void
        trace_IXD(const Arc &arcA, const Arc &arcB, ScoringView sv);
 
        template <class ScoringView>
        void
        trace_D(const Arc &arcA, const Arc &arcB, ScoringView sv);
 
        // /**
        //  * trace D matrix
        //  * @param am the corresponding arcs which defines the D element
        //  * @param sv scoring view
        //  */
        // template <class ScoringView>
        // void trace_D(const ArcMatch &am, ScoringView sv);
 
        template <bool isA, class ScoringView>
        void
        trace_IX(pos_type xl, pos_type i, const Arc &arcY, ScoringView sv);
 
        void
        align_D();
 
        void
        fill_D_entries(pos_type al, pos_type bl);
 
        infty_score_t &
        D(const ArcMatch &am) {
            return Dmat(am.arcA().idx(), am.arcB().idx());
        }
 
        template <bool isA>
        infty_score_t &
        D(const Arc &arcX, const Arc &arcY) {
            if (isA)
                return Dmat(arcX.idx(), arcY.idx());
            else
                return Dmat(arcY.idx(), arcX.idx());
        }
 
        infty_score_t &
        D(const Arc &arcA, const Arc &arcB) {
            return Dmat(arcA.idx(), arcB.idx());
        }
 
        template <bool isA>
        infty_score_t &
        IX(const pos_type i, const Arc &arc) {
            if (isA)
                return IAmat(i, arc.idx());
            else
                return IBmat(arc.idx(), i);
        }
 
        template <bool isA>
        infty_score_t &
        IXD(const Arc &arc1, const Arc &arc2) {
            if (isA)
                return IADmat(arc1.idx(), arc2.idx());
            else
                return IBDmat(arc2.idx(), arc1.idx());
        }
 
        infty_score_t &
        IA(const pos_type i, const Arc &b) {
            return IAmat(i, b.idx());
        }
 
        infty_score_t &
        IB(const Arc &a, const pos_type k) {
            return IBmat(a.idx(), k);
        }
 
        template <class ScoringView>
        void
        trace(ScoringView sv);
 
    public:
        AlignerN(const AlignerN &a);
 
        AlignerN(const AlignerNParams &ap);
 
        ~AlignerN();
 
        Alignment const &
        get_alignment() const {
            return alignment;
        }
 
        infty_score_t
        align();
 
        void
        trace();
    };
 
} // end namespace LocARNA
 
#endif // LOCARNA_ALIGNER_N_HH