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

    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, size_t max_bp_span);

    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 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);

    }; // end class RnaData
}

#endif // LOCARNA_RNA_DATA_HH