mcc_matrices.hh

#ifndef LOCARNA_MCC_MATRICES_HH
#define LOCARNA_MCC_MATRICES_HH
 
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
 
#include <assert.h>
 
#define PUBLIC // for Vienna
 
extern "C" {
#include <ViennaRNA/params.h> // import pf_paramT definition
}
 
namespace LocARNA {
    class PFoldParams;
    class MultipleAlignment;
 
    class McC_matrices_base {
    public:
        virtual ~McC_matrices_base();
 
        size_t
        iidx(size_t i, size_t j) const {
            assert(1 <= i);
            assert(i <= j);
            assert(j <= vc_->length);
 
            return vc_->iindx[i] - j;
        }
 
        size_t
        jidx(size_t i, size_t j) const {
            assert(1 <= i);
            assert(i <= j);
            assert(j <= vc_->length);
 
            return vc_->jindx[j] + i;
        }
 
        FLT_OR_DBL
        bppm(size_t i, size_t j) const {
            return vc_->exp_matrices->probs[iidx(i, j)];
        }
 
        FLT_OR_DBL
        qb(size_t i, size_t j) const {
            return vc_->exp_matrices->qb[iidx(i, j)];
        }
 
        FLT_OR_DBL
        qm(size_t i, size_t j) const {
            return vc_->exp_matrices->qm[iidx(i, j)];
        }
 
        vrna_exp_param_t *
        exp_params() const {
            return vc_->exp_params;
        }
 
        FLT_OR_DBL
        scale(size_t i) const {
            return vc_->exp_matrices->scale[i];
        }
 
        FLT_OR_DBL
        expMLbase(size_t i) const {
            return vc_->exp_matrices->expMLbase[i];
        }
 
        FLT_OR_DBL
        kT() const {
            return vc_->exp_params->kT;
        }
 
        FLT_OR_DBL
        q1k(size_t k) const {
            return vc_->exp_matrices->q1k[k];
        }
 
        FLT_OR_DBL
        qln(size_t l) const {
            return vc_->exp_matrices->qln[l];
        }
 
        int
        pair(size_t c, size_t d) const {
            assert(vc_);
            assert(vc_->exp_params);
            return vc_->exp_params->model_details.pair[c][d];
        }
 
        int
        rtype(size_t x) const {
            assert(vc_);
            assert(vc_->exp_params);
            return vc_->exp_params->model_details.rtype[x];
        }
 
        vrna_fold_compound_t *vc() {return vc_;}
 
    protected:
 
        // /** @brief free vrna fold compound
        //     @param vc pointer to the fold compound
        //  */
        // static
        // const
        // auto free_vfc = [](vrna_fold_compound_t *vc) {vrna_fold_compound_free(vc);};
 
        vrna_fold_compound_t* vc_;
 
        explicit
        McC_matrices_base(vrna_fold_compound_t* vc = nullptr);
 
    }; // end class McC_matrices_base
 
    class McC_matrices_t : public McC_matrices_base {
    public:
        McC_matrices_t(const MultipleAlignment &sequence, const PFoldParams &params);
 
        virtual ~McC_matrices_t();
 
        char
        ptype(size_t i, size_t j) const {
            return vc_->ptype[jidx(i, j)];
        }
 
        char
        rev_ptype(size_t i, size_t j) const {
            return vc_->exp_params->model_details.rtype[(size_t)ptype(i, j)];
        }
 
        short
        S1(size_t i) const {
            return vc_->sequence_encoding[i];
        }
 
        char *
        sequence() const {
            return vc_->sequence;
        }
    };
 
    class McC_ali_matrices_t : public McC_matrices_base {
    public:
        McC_ali_matrices_t(const MultipleAlignment &ma, const PFoldParams &params);
 
        virtual ~McC_ali_matrices_t();
 
        short
        pscore(size_t i, size_t j) const {
            return vc_->pscore[jidx(i, j)];
        }
 
        short
        S(size_t s, size_t i) const {
            assert(vc_);
            return vc_->S[s][i];
        }
 
        short
        S3(size_t s, size_t i) const {
            assert(vc_);
            return vc_->S3[s][i];
        }
 
        short
        S5(size_t s, size_t i) const {
            assert(vc_);
            return vc_->S5[s][i];
        }
 
        short
        a2s(size_t s, size_t i) const {
            return vc_->a2s[s][i];
        }
 
        char *
        Ss(size_t s) const {
            return vc_->Ss[s];
        }
    };
 
} // end namespace LocARNA
 
#endif // LOCARNA_MCC_MATRICES_HH