match_probs.hh

#ifndef LOCARNA_MATCH_PROBS
#define LOCARNA_MATCH_PROBS

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

#include <string>

#include "matrix.hh"

namespace LocARNA {

    class StralScore;
    class RnaData;
    template <class T> class Alphabet;
    class Sequence;

    class MatchProbs {
    public:    
        typedef size_t size_type; 
        
        MatchProbs();

        explicit
        MatchProbs(const std::string &filename);
    
        void
        pairHMM_probs(const Sequence &seqA,
                      const Sequence &seqB,
                      const std::string & file);
    
        void
        pf_probs(const RnaData &rnaA,
                 const RnaData &rnaB,
                 const Matrix<double> &sim_mat,
                 const Alphabet<char> &alphabet,
                 double gap_opening,
                 double gap_extension,
                 double pf_struct_weight,
                 double temp,
                 bool flag_local);
    
        std::istream &
        read(std::istream &in);

        void
        read(const std::string &filename);


        std::istream &
        read_sparse(std::istream &in, size_type lenA, size_type lenB);

        void
        read_sparse(const std::string &filename, size_type lenA, size_type lenB);
    
        std::ostream &
        write(std::ostream &out) const;
    
        void
        write(const std::string &filename) const;

        std::ostream &
        write_sparse(std::ostream &out, double threshold) const;
    
        void
        write_sparse(const std::string &filename, double threshold) const;

        size_type get_lenA() const {return probs.sizes().first;}
    
        size_type get_lenB() const {return probs.sizes().second;}
    
        double prob(size_t i, size_t j) const {
            assert(1<=i && i<probs.sizes().first);
            assert(1<=j && j<probs.sizes().second);

            return probs(i,j);
        }
    
    private:
        void
        pf_gotoh(size_type lenA,
                 size_type lenB,
                 Matrix<double> &zM,
                 Matrix<double> &zA,
                 Matrix<double> &zB,
             
                 const StralScore &score,

                 double temp,
             
                 bool local
                 );
    
        Matrix<double> probs; 
    
        class ProbConsParameter {
        public:
            // ------------------------------------------------------------
            // transition probabilities
            // there are three states M, X, Y (plus implicitely start and end state)
            double initM; 
            double initX; 
            double initY; 
            double startX; 
            double startY; 
            double extendM; 
            double extendX; 
            double extendY; 
            double startMFromX; 
            double startMFromY; 

            std::string basenames; 
    
            Matrix<double> emmission; 
            std::vector<double> background; 
    
            explicit
            ProbConsParameter(const std::string &filename);
        };

    };
    
}

#endif // LOCARNA_MATCH_PROBS