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