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