aligner_impl.hh

#ifndef LOCARNA_ALIGNER_IMPL_HH
#define LOCARNA_ALIGNER_IMPL_HH
 
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
 
#include <memory>
 
#include "aligner.hh"
 
#include "aligner_restriction.hh"
#include "scoring.hh"
#include "alignment.hh"
#include "aligner_params.hh"
 
namespace LocARNA {
 
    class Sequence;
    template <class T>
    class Matrix;
 
    class AlignerImpl {
    public:
        typedef ScoreMatrix M_matrix_t;
 
        typedef BasePairs__Arc Arc;
 
        const std::unique_ptr<AlignerParams> params_; 
 
        const Scoring *scoring_; 
 
        const ArcMatches &arc_matches_;
 
        const Sequence &seqA_; 
        const Sequence &seqB_; 
 
        const BasePairs &bpsA_; 
        const BasePairs &bpsB_; 
 
        AlignerRestriction r_;
 
        ScoreMatrix Dmat_;
 
        std::vector<M_matrix_t> Ms_;
 
        std::vector<ScoreVector> Es_;
 
        std::vector<infty_score_t> Fs_;
 
        int min_i_; 
        int min_j_; 
 
        int max_i_; 
        int max_j_; 
 
        bool D_created_; 
 
        Alignment alignment_; 
 
        enum {
            E_NO_NO,
            E_X_NO,
            E_NO_X,
            E_X_X,
            E_OP_NO,
            E_NO_OP,
            E_OP_X,
            E_X_OP
        };
 
        // ============================================================
        class UnmodifiedScoringView {
        public:
            explicit UnmodifiedScoringView(const AlignerImpl *aligner_impl)
                : aligner_impl_(aligner_impl){};
 
            const Scoring *
            scoring() const {
                return aligner_impl_->scoring_;
            }
 
            infty_score_t
            D(const Arc &a, const Arc &b) const {
                return aligner_impl_->Dmat_(a.idx(), b.idx());
            }
 
            infty_score_t
            D(const ArcMatch &am) const {
                return D(am.arcA(), am.arcB());
            }
        private:
            const AlignerImpl *
                aligner_impl_; 
        };
 
        class ModifiedScoringView {
        public:
            explicit ModifiedScoringView(const AlignerImpl *aligner_impl)
                : aligner_impl_(aligner_impl),
                  mod_scoring_(
                      std::make_unique<Scoring>(*aligner_impl->scoring_)),
                  lambda_(0) {}
 
            void
            set_lambda(score_t lambda) {
                lambda_ = lambda;
                mod_scoring_->modify_by_parameter(lambda);
            }
 
            const Scoring *
            scoring() const {
                return mod_scoring_.get();
            }
 
            infty_score_t
            D(const Arc &a, const Arc &b) const {
                return aligner_impl_->Dmat_(a.idx(), b.idx()) -
                    FiniteInt(lambda_ * (arc_length(a) + arc_length(b)));
            }
 
            infty_score_t
            D(const ArcMatch &am) const {
                return aligner_impl_->Dmat_(am.arcA().idx(), am.arcB().idx()) -
                    FiniteInt(lambda_ *
                              (arc_length(am.arcA()) + arc_length(am.arcB())));
            }
        private:
            const AlignerImpl *aligner_impl_;
 
            const std::unique_ptr<Scoring> mod_scoring_;
 
            score_t lambda_; 
 
            size_t
            arc_length(const Arc &a) const {
                return a.right() - a.left() + 1;
            }
 
        };
 
        const UnmodifiedScoringView def_scoring_view_; 
 
        // ============================================================
 
        AlignerImpl(const AlignerImpl &a);
 
        AlignerImpl(const Sequence &seqA,
                    const Sequence &seqB,
                    const AlignerParams *ap,
                    const Scoring *s);
 
        ~AlignerImpl();
 
        // ============================================================
 
        template <class ScoringView>
        void
        init_state(int state,
                   pos_type al,
                   pos_type ar,
                   pos_type bl,
                   pos_type br,
                   bool globalA,
                   bool exclA,
                   bool globalB,
                   bool exclB,
                   const ScoringView *sv);
 
        template <class ScoringView>
        infty_score_t
        align_noex(int state,
                   pos_type al,
                   pos_type bl,
                   pos_type i,
                   pos_type j,
                   const ScoringView *sv);
 
        void
        align_in_arcmatch(pos_type al,
                          pos_type ar,
                          pos_type bl,
                          pos_type br,
                          bool allow_exclusion);
 
        template <class ScoringView>
        infty_score_t
        align_top_level_free_endgaps(const ScoringView *s);
 
        template <class ScoringView>
        infty_score_t
        align_top_level_locally(const ScoringView *sv);
 
        // infty_score_t align_top_level_localB();
 
        template <class ScoringView>
        void
        trace_in_arcmatch(int state,
                          int al,
                          int i,
                          int bl,
                          int j,
                          bool top_level,
                          const ScoringView *sv);
 
        template <class ScoringView>
        void
        trace_noex(int state,
                   pos_type al,
                   pos_type i,
                   pos_type bl,
                   pos_type j,
                   bool top_level,
                   const ScoringView *sv);
 
        void
        trace_arcmatch(const ArcMatch &am);
 
        void
        trace_arcmatch_noLP(const ArcMatch &am);
 
        infty_score_t
        align();
 
        void
        align_D();
 
        void
        fill_D_entries(pos_type al, pos_type bl);
 
        void
        fill_D_entries_noLP(pos_type al, pos_type bl);
 
        infty_score_t &
        D(const ArcMatch &am) {
            return Dmat_(am.arcA().idx(), am.arcB().idx());
        }
 
        infty_score_t &
        D(const Arc &arcA, const Arc &arcB) {
            return Dmat_(arcA.idx(), arcB.idx());
        }
 
        template <class ScoringView>
        void
        trace(const ScoringView *sv);
 
 
        infty_score_t
        normalized_align(score_t L, bool verbose);
 
        infty_score_t
        penalized_align(score_t position_penalty);
 
    };
 
} // end namespace LocARNA
 
#endif // LOCARNA_ALIGNER_IMPL_HH