src/LocARNA/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 MultipleAlignment;
    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_t> 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