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 gapCostAmat;
        
        ScoreMatrix gapCostBmat; 


        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(const Arc &arcX,const Arc &arcY, bool isA) {
                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 <class ScoringView>
        void computeGapCosts(bool isA, ScoringView sv);


        infty_score_t getGapCostBetween( pos_type leftSide, pos_type rightSide, bool isA);


        template<class ScoringView>
        infty_score_t compute_IX(pos_type xl, const Arc& arcY, pos_type i,bool isA, 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 <class ScoringView>
        void trace_IXD(const Arc &arcA, const Arc &arcB, bool isA, 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 <class ScoringView>
        void trace_IX (pos_type xl, pos_type i, const Arc &arcY, bool isA, 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());
        }


        infty_score_t &D(const Arc &arcX,const Arc &arcY, bool isA) {
            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());
        }


        infty_score_t &IX(const pos_type i, const Arc &arc, bool isA) {

                if ( isA )
                        return IAmat(i, arc.idx());
                else
                        return IBmat(arc.idx(), i);

        }

        infty_score_t &IXD(const Arc &arc1, const Arc &arc2, bool isA) {

                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