rna_data.hh

#ifndef LOCARNA_RNA_DATA_HH
#define LOCARNA_RNA_DATA_HH
 
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
 
#include <memory>
#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 RnaStructure;
 
    class RnaData {
        friend class RnaDataImpl;
        friend class ExtRnaDataImpl;
 
    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);
 
        virtual ~RnaData();
 
        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;
 
        std::unique_ptr<vrna_plist_t []>
        plist() const;
 
        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:
        std::unique_ptr<RnaDataImpl> pimpl_;
 
        explicit RnaData(double p_bpcut, size_t max_bp_span);
 
        const arc_prob_matrix_t &
        arc_probs() const;
 
        virtual void
        init_from_fixed_structure(const RnaStructure &structure,
                                  const PFoldParams &pfoldparams);
 
        virtual void
        init_from_rna_ensemble(const RnaEnsemble &rna_ensemble,
                               const PFoldParams &pfoldparams);
 
        bool
        read_autodetect(const std::string &filename,
                        const PFoldParams &pfoldparams);
 
        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);
 
    private:
        RnaData(const RnaData &);
 
 
        RnaData &
        operator=(const RnaData &);
 
 
    }; // end class RnaData
}
 
#endif // LOCARNA_RNA_DATA_HH