Predictor.h

Go to the documentation of this file.

 
#ifndef INTARNA_PREDICTOR_H_
#define INTARNA_PREDICTOR_H_
 
#include "IntaRNA/general.h"
#include "IntaRNA/InteractionEnergyIdxOffset.h"
 
#include "IntaRNA/OutputConstraint.h"
#include "IntaRNA/OutputHandler.h"
 
#include "IntaRNA/PredictionTracker.h"
 
namespace IntaRNA {
 
class Predictor {
 
public:
 
    Predictor( const InteractionEnergy & energy
                , OutputHandler & output
                , PredictionTracker * predTracker
                );
 
    virtual ~Predictor();
 
    virtual
    void
    predict( const IndexRange & r1 = IndexRange(0,RnaSequence::lastPos)
            , const IndexRange & r2 = IndexRange(0,RnaSequence::lastPos) ) = 0;
 
    static
    size_t
    getMaxInteractionWidth( const size_t w, const size_t maxLoopSize );
 
    Z_type
    getZall() const;
 
protected:
 
    InteractionEnergyIdxOffset energy;
 
    OutputHandler & output;
 
    PredictionTracker * predTracker;
 
    Z_type Zall;
 
 
    virtual
    void
    initOptima() = 0;
 
    virtual
    void
    updateOptima( const size_t i1, const size_t j1
                , const size_t i2, const size_t j2
                , const E_type energy
                , const bool isHybridE
                , const bool incrementZall ) = 0;
 
    virtual
    void
    updateZall( const size_t i1, const size_t j1
                , const size_t i2, const size_t j2
                , const E_type energy
                , const bool isHybridE );
 
 
 
    virtual
    void
    reportOptima() = 0;
 
    void
    incrementZall( const Z_type partZ );
 
};
 
 
 
inline
Predictor::Predictor( const InteractionEnergy & energy
                    , OutputHandler & output
                    , PredictionTracker * predTracker )
:
    energy(energy)
    , output(output)
    , predTracker(predTracker)
    , Zall(0)
{
}
 
 
inline
Predictor::~Predictor()
{
     INTARNA_CLEANUP(predTracker);
}
 
 
inline
size_t
Predictor::
getMaxInteractionWidth( const size_t w, const size_t maxLoopSize )
{
    // check if no window at all
    if (w==0)
        return 0;
    // compute maximal interaction width, ie each position pairs with max loop size
    return 1 + ((w-1)*(maxLoopSize+1));
}
 
 
inline
Z_type
Predictor::
getZall() const
{
    return Zall;
}
 
 
inline
void
Predictor::
incrementZall( const Z_type partZ )
{
#if INTARNA_IN_DEBUG_MODE
    if ( (std::numeric_limits<Z_type>::max() - partZ) <= Zall) {
        LOG(WARNING) <<"PredictorMfeEns::incrementZall() : partition function overflow! Recompile with larger partition function data type!";
    }
#endif
    // increment overall partition function
    Zall += partZ;
}
 
 
 
 
inline
void
Predictor::
updateZall( const size_t i1, const size_t j1
        , const size_t i2, const size_t j2
        , const E_type interE
        , const bool isHybridE )
{
    // ignore if not needed
    if (!output.getOutputConstraint().needZall) {
        return;
    }
 
    // ignore invalid reports
    if (E_isINF(interE) || interE >= E_MAX) {
        return;
    }
 
    // check GU ends if needed
    if (output.getOutputConstraint().noGUend && (energy.isGU(i1,i2) || energy.isGU(j1,j2)) ) {
        return;
    }
 
    // check ED penalties
    if (output.getOutputConstraint().maxED < Accessibility::ED_UPPER_BOUND
            && (energy.getED1(i1,j1) > output.getOutputConstraint().maxED
                    || energy.getED2(i2,j2) > output.getOutputConstraint().maxED)
            )
    {
        return;
    }
 
    // increment Zall with BW of overall energy
    incrementZall(
            energy.getBoltzmannWeight(
                    isHybridE ?
                            energy.getE( i1,j1, i2,j2, interE )
                            : interE
            ));
}
 
 
} // namespace
 
#endif /* PREDICTOR_H_ */