aligner_p.hh

#ifndef LOCARNA_ALIGNER_P_HH
#define LOCARNA_ALIGNER_P_HH

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

#include "scoring.hh"
#include "params.hh"

#include "matrix.hh"

#include "sparse_matrix.hh"

#include "aligner_restriction.hh"


namespace LocARNA {

    class Sequence;
    class BasePairs;
    class BasePairs__Arc;
    class ArcMatch;
    class ArcMatches;

    typedef Matrix<double> ProbMatrix;
    
    typedef SparseMatrix<double> SparseProbMatrix; 
    
    typedef SparseMatrix<pf_score_t> SparsePFScoreMatrix; 

    typedef AlignerRestriction AlignerPRestriction;
    
    class AlignerP {
    public:
        typedef size_t size_type; 
        typedef std::pair<size_type,size_type> size_pair; 
    
        typedef BasePairs__Arc Arc; 
    protected:
        const AlignerPParams *params; 
        
        const Scoring *scoring; 
    
        const Sequence &seqA; 
        const BasePairs &bpsA; 
        const Sequence &seqB; 
        const BasePairs &bpsB; 
    
        const ArcMatches &arc_matches; 

        AlignerPRestriction r;
        
    
        pf_score_t pf_scale;
    
    
        pf_score_t partFunc; 

        PFScoreMatrix Dmat;
    

        PFScoreVector E;

        pf_score_t F;
    
    
        PFScoreMatrix M;


        PFScoreMatrix Mrev;
  
        PFScoreVector Erev; 

        pf_score_t    Frev;
        
        PFScoreMatrix Erev_mat;
        
        PFScoreMatrix Frev_mat;
 

        PFScoreMatrix Dmatprime;

        PFScoreVector Eprime; // one could slightly optimize space by PFScoreVector &Eprime = E;
    
        pf_score_t Fprime;

        PFScoreMatrix Mprime;
        
        SparseProbMatrix am_prob;

        SparsePFScoreMatrix bm_prob;
  
        bool D_created; 
        bool Dprime_created; 


        void init_M(size_type al, size_type ar, size_type bl, size_type br);

        void init_E(size_type al, size_type ar, size_type bl, size_type br);
    
        void init_Mrev(size_type al, size_type ar, size_type bl, size_type br); 

        void init_Erev(size_type al, size_type ar, size_type bl, size_type br); 

        // void init_Mprime(size_type al, size_type ar, size_type bl, size_type br);

        // void init_Eprime(size_type al, size_type ar, size_type bl, size_type br);

        pf_score_t comp_E_entry(size_type al, size_type bl, size_type i, size_type j);

        pf_score_t comp_F_entry(size_type al, size_type bl, size_type i, size_type j);
    
        pf_score_t comp_M_entry(size_type al, size_type bl, size_type i, size_type j);

        pf_score_t comp_Mprime_entry(size_type al, size_type bl, size_type i, size_type j, size_type max_ar, size_type max_br);

        pf_score_t comp_Eprime_entry(size_type al, size_type bl, size_type i, size_type j);

        pf_score_t comp_Fprime_entry(size_type al, size_type bl, size_type i, size_type j);

        pf_score_t comp_Erev_entry( size_type i, size_type j );

        pf_score_t comp_Frev_entry( size_type i, size_type j );

        pf_score_t comp_Mrev_entry( size_type i, size_type j, size_type ar, size_type br);
    
        void align_inside_arcmatch(size_type al,size_type ar,size_type bl,size_type br);
    
        void
        align_outside_arcmatch(size_type al,size_type ar,size_type max_ar,size_type bl,size_type br,size_type max_br);
    
        void align_reverse(size_type al, size_type ar, size_type bl, size_type br, bool copy=false);
    
        void align_D();
    
        void align_Dprime();
    
        void 
        fill_D(size_type al, size_type bl,
               size_type max_ar, size_type max_br);
    
        void 
        fill_Dprime(size_type al, size_type bl,
                    size_type min_ar, size_type min_br,
                    size_type max_ar, size_type max_br
                    );

        pf_score_t &//SparsePFScoreMatrix::element
        D(const ArcMatch &am);

        pf_score_t &//SparsePFScoreMatrix::element
        D(const Arc &arcA,const Arc &arcB);

        pf_score_t &//SparsePFScoreMatrix::element
        Dprime(const ArcMatch &am);

        pf_score_t &//SparsePFScoreMatrix::element
        Dprime(const Arc &arcA,const Arc &arcB);
    
        size_type
        leftmost_covering_arc(size_type s,const BasePairs &bps,size_type l,size_type r) const;
  
        std::pair<size_type,size_type>
        leftmost_covering_arcmatch(size_type al,size_type bl,size_type ar,size_type br) const;

        size_type 
        rightmost_covering_arc(const BasePairs &bps,size_type l,size_type r,size_type s) const;
  
        std::pair<size_type,size_type>
        rightmost_covering_arcmatch(size_type al,size_type bl,size_type ar,size_type br) const;


        void
        alloc_inside_matrices();

        void 
        alloc_outside_matrices();

    public:  
    
        AlignerP(const AlignerParams &ap);

        AlignerP(const AlignerP &p);
        
        ~AlignerP();

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

        pf_score_t
        align_inside();
       
        void
        align_outside();
    
        void
        compute_basematch_probabilities( bool basematch_probs_include_arcmatch );

        void 
        compute_arcmatch_probabilities();
  
        void
        write_arcmatch_probabilities(std::ostream &out);
  
  
        void
        write_basematch_probabilities(std::ostream &out); 
    
        pf_score_t
        virtual_Mprime(size_type al, size_type bl, size_type i, size_type j, size_type max_ar, size_type max_br) const;
    
        // const Matrix *get_basematch_probabilities(){}
        // const SparseMatrix *get_arcmatch_probabilities(){}    
    
        
        double
        compute_fragment_match_prob(size_type i,size_type j,size_type k,size_type l);
    

        void freeD() { Dmat.clear(); }

        void freeMprime() { Mprime.clear(); }

    };

} //end namespace 

#endif