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