aligner_p.hh

#ifndef LOCARNA_ALIGNER_P_HH
#define LOCARNA_ALIGNER_P_HH
 
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
 
#include <memory>
 
#include "quadmath.hh"
 
#include "scoring.hh"
#include "aligner_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 AlignerRestriction AlignerPRestriction;
 
    template <typename T>
    class AlignerP {
    public:
        using pf_score_t = typename PFScoring<T>::pf_score_t;
        using PFScoreMatrix = typename PFScoring<T>::PFScoreMatrix;
        using PFScoreVector = typename PFScoring<T>::PFScoreVector;
 
        typedef SparseMatrix<pf_score_t> SparsePFScoreMatrix;
 
        typedef size_t size_type; 
        typedef std::pair<size_type, size_type>
            size_pair; 
 
        typedef BasePairs__Arc Arc; 
    protected:
        const std::unique_ptr<AlignerPParams<T>> params; 
 
        const PFScoring<T> *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 &
            D(const ArcMatch &am);
 
        pf_score_t &
        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 AlignerPParams<T> &ap);
 
        AlignerP(const AlignerP &p);
 
        ~AlignerP();
 
        static AlignerPParams<T>
        create() {
            return AlignerPParams<T>();
        }
 
        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
 
 
#include "aligner_p.icc"
 
#endif