src/LocARNA/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 "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;

    private:
    protected:
        const 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 AlignerParams &ap);

        static AlignerNParams
        create() {
            return AlignerNParams();
        }

        ~AlignerN();

        Alignment const &
        get_alignment() const {
            return alignment;
        }

        infty_score_t
        align();

        void
        trace();
    };

} // end namespace LocARNA

#endif // LOCARNA_ALIGNER_N_HH