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_;
        
        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);
        
        // ----------------------------------------
        // METHODS


        void
        init_from_fixed_structure(const SequenceAnnotation &structure,
                                  bool stacking);

        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,
                                   bool stacking
                                   );
        
        double
        consensus_probability(double pA,
                              double pB, 
                              size_t sizeA,
                              size_t sizeB,
                              double p_expA,
                              double p_expB) 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