rna_data_impl.hh

#ifndef LOCARNA_RNA_DATA_IMPL_HH
#define LOCARNA_RNA_DATA_IMPL_HH
 
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
 
#include <iosfwd>
#include "rna_data.hh"
#include "sequence.hh"
 
namespace LocARNA {
 
    class RnaEnsemble;
    class PFoldParams;
    //    template<class T> class SparseVector<T>;
 
    class RnaDataImpl {
    public:
        typedef RnaData::arc_prob_matrix_t arc_prob_matrix_t;
 
        RnaData *self_; 
 
        MultipleAlignment sequence_;
 
        double p_bpcut_;
        size_t max_bp_span_;
 
        arc_prob_matrix_t arc_probs_;
 
        arc_prob_matrix_t arc_2_probs_;
 
        bool has_stacking_;
 
        RnaDataImpl(RnaData *self,
                    const RnaData &rna_dataA,
                    const RnaData &rna_dataB,
                    const Alignment::edges_t &alignment,
                    double p_expA,
                    double p_expB);
 
        RnaDataImpl(RnaData *self, double p_bpcut, size_t max_bp_span);
 
        // ----------------------------------------
        // METHODS
 
        void
        init_from_fixed_structure(const RnaStructure &structure,
                                  const PFoldParams &pfoldparams);
 
        void
        init_from_rna_ensemble(const RnaEnsemble &rna_ensemble,
                               const PFoldParams &pfoldparams);
 
        std::istream &
        read_pp_sequence(std::istream &in);
 
        std::istream &
        read_pp_arc_probabilities(std::istream &in);
 
        std::ostream &
        write_pp_sequence(std::ostream &out) const;
 
        std::ostream &
        write_pp_arc_probabilities(std::ostream &out,
                                   double p_outbpcut,
                                   bool stacking) const;
 
        void
        init_as_consensus_dot_plot(const Alignment::edges_t &edges,
                                   const RnaData &rna_dataA,
                                   const RnaData &rna_dataB,
                                   double p_expA,
                                   double p_expB,
                                   double f_penalty,
                                   bool stacking);
 
        double
        consensus_probability(double pA,
                              double pB,
                              size_t sizeA,
                              size_t sizeB,
                              double p_expA,
                              double p_expB,
                              double p_penalty) const;
 
        template <class KEY>
        class keyvec {
        public:
            typedef std::pair<KEY, arc_prob_matrix_t::value_type> kvpair_t;
 
            typedef std::vector<kvpair_t> vec_t;
 
            // compare for min heap
            static bool
            comp(const kvpair_t &x, const kvpair_t &y) {
                return x.second > y.second;
            }
        };
 
        void
        drop_worst_bps(size_t keep);
 
    }; // end class RnaDataImpl
 
} // end namespace LocARNA
 
#endif // LOCARNA_RNA_DATA_IMPL_HH