rna_data.hh

#ifndef LOCARNA_RNA_DATA_HH
#define LOCARNA_RNA_DATA_HH

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

#include <iosfwd>
#include "aux.hh"
#include "sparse_matrix.hh"

extern "C" {
#   include <ViennaRNA/data_structures.h>
}

namespace LocARNA {

    class MultipleAlignment;
    class Sequence;
    class Alignment;
    class RnaEnsemble;
    class RnaDataImpl;
    class PFoldParams;
    class SequenceAnnotation;
    
    class RnaData {
    protected:
        friend class RnaDataImpl;
        friend class ExtRnaDataImpl;
        RnaDataImpl *pimpl_;  

    public:
        
        typedef SparseMatrix<double> arc_prob_matrix_t;
        
        typedef size_t size_type; 
        
        RnaData(const RnaEnsemble &rna_ensemble,
                double p_bpcut,
                double max_bps_length_ratio,
                const PFoldParams &pfoldparams);

        RnaData(const std::string &filename,
                double p_bpcut,
                double max_bps_length_ratio,
                const PFoldParams &pfoldparams
                );
        
        RnaData(const RnaData &rna_dataA,
                const RnaData &rna_dataB,
                const Alignment &alignment,
                double p_expA,
                double p_expB, 
                bool only_local=false
                );
        
    protected:
        explicit
        RnaData(double p_bpcut);
        
    private:
        RnaData(const RnaData &);
    public:
        
        virtual 
        ~RnaData();

    private:
        RnaData &
        operator =(const RnaData &);

    public:

        const Sequence &
        sequence() const;

        const MultipleAlignment &
        multiple_alignment() const;

        size_type
        length() const;

        double
        arc_cutoff_prob() const;
        
        double 
        arc_prob(pos_type i, pos_type j) const;
                
        std::string
        mea_structure(double gamma=1.) const;

        vrna_plist_t *
        plist() const;

    protected:
        typedef arc_prob_matrix_t::const_iterator arc_probs_const_iterator;
        
        arc_probs_const_iterator
        arc_probs_begin() const;

        arc_probs_const_iterator
        arc_probs_end() const;
    public:
        

        double 
        joint_arc_prob(pos_type i, pos_type j) const;
        
        double 
        stacked_arc_prob(pos_type i, pos_type j) const;
        
        // some computed probabilities (for convenience)
        double
        prob_paired_upstream(pos_type i) const;
        
        double
        prob_paired_downstream(pos_type i) const;
    
        double
        prob_unpaired(pos_type i) const;
        
        // IO
        std::ostream &
        write_pp(std::ostream &out, double p_outbpcut=0) const;

        std::ostream &
        write_size_info(std::ostream &out) const;

        bool
        has_stacking() const;

        void
        set_anchors(const SequenceAnnotation &anchors);

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

        virtual
        void
        init_from_rna_ensemble(const RnaEnsemble &rna_ensemble,
                               const PFoldParams &pfoldparams);
        

        bool
        read_autodetect(const std::string &filename,
                        bool stacking);
                
        virtual
        bool
        inloopprobs_ok() const {return true;}
                
        
        virtual
        void
        read_pp(const std::string &filename);
        
        virtual
        std::istream &
        read_pp(std::istream &in);

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

        void
        read_ps(const std::string &filename);
        
    }; // end class RnaData
  
}


#endif // LOCARNA_RNA_DATA_HH