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 McC_matrices_base {
    protected:
        vrna_fold_compound_t *vc_;        
        
        McC_matrices_base(vrna_fold_compound_t *vc);

    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];
        }


    };
    
    class McC_matrices_t : public McC_matrices_base {
    public:

        McC_matrices_t(vrna_fold_compound_t *vc);
        
        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(vrna_fold_compound_t *vc);
        
        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 { 
            return vc_->S[s][i];
        }

        short
        S3(size_t s,size_t i) const { return vc_->S3[s][i]; }

        short
        S5(size_t s,size_t i) const { 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