InteractionEnergyIdxOffset.h

Go to the documentation of this file.

 
#ifndef INTARNA_INTERACTIONENERGYIDXOFFSET_H_
#define INTARNA_INTERACTIONENERGYIDXOFFSET_H_
 
#include "IntaRNA/InteractionEnergy.h"
 
namespace IntaRNA {
 
class InteractionEnergyIdxOffset : public InteractionEnergy
{
public:
 
    InteractionEnergyIdxOffset( const InteractionEnergy & energyOriginal
                                , const size_t offset1 = 0
                                , const size_t offset2 = 0 );
 
 
    virtual ~InteractionEnergyIdxOffset();
 
    size_t getOffset1() const;
 
    void setOffset1(size_t offset1);
 
    size_t getOffset2() const;
 
    void setOffset2(size_t offset2);
 
 
    virtual
    E_type
    getE( const size_t i1, const size_t j1
            , const size_t i2, const size_t j2
            , const E_type hybridE ) const;
 
    virtual
    E_type
    getE( const Z_type Z ) const;
 
    virtual
    bool
    areComplementary( const size_t i1, const size_t i2 ) const;
 
    virtual
    bool
    isGU( const size_t i1, const size_t i2 ) const;
 
    virtual
    size_t
    size1() const;
 
    virtual
    size_t
    size2() const;
 
    virtual
    E_type
    getED1( const size_t i1, const size_t j1 ) const;
 
    virtual
    E_type
    getED2( const size_t i2, const size_t j2 ) const;
 
    virtual
    bool
    isAccessible1( const size_t i ) const;
 
    virtual
    bool
    isAccessible2( const size_t i ) const;
 
    virtual
    E_type
    getE_multi(  const size_t i1, const size_t j1
                , const size_t i2, const size_t j2
                , const ES_multi_mode ES_mode ) const;
 
    virtual
    E_type
    getES1( const size_t i1, const size_t j1 ) const;
 
    virtual
    E_type
    getES2( const size_t i2, const size_t j2 ) const;
 
    virtual
    E_type
    getE_multiUnpaired( const size_t numUnpaired ) const;
 
 
    virtual
    E_type
    getE_multiHelix( const size_t j1, const size_t j2 ) const;
 
    virtual
    E_type
    getE_multiClosing() const;
 
    virtual
    E_type
    getE_init( ) const;
 
 
    virtual
    E_type
    getE_interLeft( const size_t i1, const size_t j1, const size_t i2, const size_t j2 ) const;
 
 
    virtual
    E_type
    getE_danglingLeft( const size_t i1, const size_t i2 ) const;
 
 
    virtual
    E_type
    getE_danglingRight( const size_t j1, const size_t j2 ) const;
 
    virtual
    E_type
    getE_endLeft( const size_t i1, const size_t i2 ) const;
 
    virtual
    E_type
    getE_endRight( const size_t j1, const size_t j2 ) const;
 
    virtual
    Z_type
    getPr_danglingLeft( const size_t i1, const size_t j1, const size_t i2, const size_t j2 ) const;
 
    virtual
    Z_type
    getPr_danglingRight( const size_t i1, const size_t j1, const size_t i2, const size_t j2 ) const;
 
 
 
    virtual
    Z_type
    getRT() const;
 
    virtual
    Interaction::BasePair
    getBasePair( const size_t i1, const size_t i2 ) const;
 
 
    virtual
    size_t
    getIndex1( const Interaction::BasePair & bp ) const;
 
 
    virtual
    size_t
    getIndex2( const Interaction::BasePair & bp ) const;
 
 
    virtual
    bool
    isValidInternalLoop( const size_t i1, const size_t j1, const size_t i2, const size_t j2 ) const;
 
    virtual
    E_type
    getEall1() const;
 
    virtual
    E_type
    getEall2() const;
 
 
protected:
 
    const InteractionEnergy & energyOriginal;
 
    size_t offset1;
 
    size_t offset2;
 
};
 
 
 
 
 
inline
InteractionEnergyIdxOffset::
InteractionEnergyIdxOffset( const InteractionEnergy & energyOriginal
            , const size_t offset1
            , const size_t offset2 )
 
 :
    InteractionEnergy( energyOriginal )
    , energyOriginal(energyOriginal)
    , offset1(offset1)
    , offset2(offset2)
{
#if INTARNA_IN_DEBUG_MODE
    // input sanity checks
    setOffset1(offset1);
    setOffset2(offset2);
#endif
}
 
 
inline
InteractionEnergyIdxOffset::~InteractionEnergyIdxOffset()
{
}
 
 
inline
size_t
InteractionEnergyIdxOffset::
getOffset1() const
{
    return offset1;
}
 
 
inline
void
InteractionEnergyIdxOffset::
setOffset1(size_t offset1)
{
#if INTARNA_IN_DEBUG_MODE
    if (offset1 >= energyOriginal.size1()) {
        throw std::runtime_error("InteractionEnergyIdxOffset : offset1 "+toString(offset1)
                +" > seq1.length "+toString(energyOriginal.size1()));
    }
#endif
    this->offset1 = offset1;
}
 
 
inline
size_t
InteractionEnergyIdxOffset::
getOffset2() const
{
    return offset2;
}
 
 
inline
void
InteractionEnergyIdxOffset::
setOffset2(size_t offset2)
{
#if INTARNA_IN_DEBUG_MODE
    if (offset2 >= energyOriginal.size2()) {
        throw std::runtime_error("InteractionEnergyIdxOffset : offset2 "+toString(offset2)
                +" > seq2.length "+toString(energyOriginal.size2()));
    }
#endif
    this->offset2 = offset2;
}
 
 
inline
E_type
InteractionEnergyIdxOffset::
getED1( const size_t i1, const size_t j1 ) const
{
    return energyOriginal.getED1( i1+offset1, j1+offset1 );
}
 
 
inline
E_type
InteractionEnergyIdxOffset::
getED2( const size_t i2, const size_t j2 ) const
{
    return energyOriginal.getED2( i2+offset2, j2+offset2 );
}
 
 
inline
bool
InteractionEnergyIdxOffset::
isAccessible1( const size_t i ) const
{
    return energyOriginal.isAccessible1(i+offset1);
}
 
 
inline
bool
InteractionEnergyIdxOffset::
isAccessible2( const size_t i ) const
{
    return energyOriginal.isAccessible2(i+offset2);
}
 
 
inline
bool
InteractionEnergyIdxOffset::
isGU( const size_t i1, const size_t i2 ) const
{
    return energyOriginal.isGU( i1+offset1, i2+offset2);
}
 
 
inline
bool
InteractionEnergyIdxOffset::
areComplementary( const size_t i1, const size_t i2 ) const
{
    return energyOriginal.areComplementary( i1+offset1, i2+offset2 );
}
 
 
inline
size_t
InteractionEnergyIdxOffset::
size1() const
{
    return energyOriginal.size1()-offset1;
}
 
 
inline
size_t
InteractionEnergyIdxOffset::
size2() const
{
    return energyOriginal.size2()-offset2;
}
 
 
inline
E_type
InteractionEnergyIdxOffset::
getES1( const size_t i1, const size_t j1 ) const
{
    return energyOriginal.getES1( i1+offset1, j1+offset1 );
}
 
 
inline
E_type
InteractionEnergyIdxOffset::
getES2( const size_t i2, const size_t j2 ) const
{
    return energyOriginal.getES2( i2+offset2, j2+offset2 );
}
 
 
inline
E_type
InteractionEnergyIdxOffset::
getE_multiUnpaired( const size_t numUnpaired ) const
{
    return energyOriginal.getE_multiUnpaired( numUnpaired );
}
 
 
 
inline
E_type
InteractionEnergyIdxOffset::
getE_multiHelix( const size_t j1, const size_t j2 ) const
{
    return energyOriginal.getE_multiHelix(j1+offset1, j2+offset2);
}
 
 
inline
E_type
InteractionEnergyIdxOffset::
getE_multiClosing() const
{
    return energyOriginal.getE_multiClosing();
}
 
 
inline
E_type
InteractionEnergyIdxOffset::
getE_init( ) const
{
    return energyOriginal.getE_init();
}
 
 
inline
E_type
InteractionEnergyIdxOffset::
getE_interLeft( const size_t i1, const size_t j1, const size_t i2, const size_t j2 ) const
{
    return energyOriginal.getE_interLeft(i1+offset1, j1+offset1, i2+offset2, j2+offset2);
}
 
 
 
inline
E_type
InteractionEnergyIdxOffset::
getE_danglingLeft( const size_t i1, const size_t i2 ) const
{
    return energyOriginal.getE_danglingLeft( i1+offset1, i2+offset2 );
}
 
 
inline
E_type
InteractionEnergyIdxOffset::
getE_danglingRight( const size_t j1, const size_t j2 ) const
{
    return energyOriginal.getE_danglingRight( j1+offset1, j2+offset2 );
}
 
 
inline
E_type
InteractionEnergyIdxOffset::
getE_endLeft( const size_t i1, const size_t i2 ) const
{
    return energyOriginal.getE_endLeft( i1+offset1, i2+offset2 );
}
 
 
inline
E_type
InteractionEnergyIdxOffset::
getE_endRight( const size_t j1, const size_t j2 ) const
{
    return energyOriginal.getE_endRight( j1+offset1, j2+offset2 );
}
 
 
inline
Z_type
InteractionEnergyIdxOffset::
getPr_danglingLeft( const size_t i1, const size_t j1, const size_t i2, const size_t j2 ) const
{
    return energyOriginal.getPr_danglingLeft(i1+offset1, j1+offset1, i2+offset2, j2+offset2);
}
 
 
inline
Z_type
InteractionEnergyIdxOffset::
getPr_danglingRight( const size_t i1, const size_t j1, const size_t i2, const size_t j2 ) const
{
    return energyOriginal.getPr_danglingRight(i1+offset1, j1+offset1, i2+offset2, j2+offset2);
}
 
 
inline
Interaction::BasePair
InteractionEnergyIdxOffset::
getBasePair( const size_t i1, const size_t i2 ) const
{
    return energyOriginal.getBasePair( i1+offset1, i2+offset2 );
}
 
 
inline
size_t
InteractionEnergyIdxOffset::
getIndex1( const Interaction::BasePair & bp ) const
{
#if INTARNA_IN_DEBUG_MODE
    if (energyOriginal.getIndex1(bp)<offset1) throw std::runtime_error("InteractionEnergyIdxOffset::getIndex1("+toString(energyOriginal.getIndex1(bp))+") < offset1 = "+toString(offset1));
#endif
    return energyOriginal.getIndex1(bp)-offset1;
}
 
 
inline
size_t
InteractionEnergyIdxOffset::
getIndex2( const Interaction::BasePair & bp ) const
{
#if INTARNA_IN_DEBUG_MODE
    if (energyOriginal.getIndex2(bp)<offset2) throw std::runtime_error("InteractionEnergyIdxOffset::getIndex2("+toString(energyOriginal.getIndex2(bp))+") < offset2 = "+toString(offset2));
#endif
    return energyOriginal.getIndex2(bp)-offset2;
}
 
 
inline
Z_type
InteractionEnergyIdxOffset::
getRT() const
{
    return energyOriginal.getRT();
}
 
 
inline
E_type
InteractionEnergyIdxOffset::
getE( const Z_type Z ) const
{
    return energyOriginal.getE( Z );
}
 
 
inline
E_type
InteractionEnergyIdxOffset::
getE( const size_t i1, const size_t j1
        , const size_t i2, const size_t j2
        , const E_type hybridE ) const
{
    return energyOriginal.getE( i1+offset1, j1+offset1, i2+offset2, j2+offset2, hybridE );
}
 
 
inline
E_type
InteractionEnergyIdxOffset::
getE_multi(  const size_t i1, const size_t j1
            , const size_t i2, const size_t j2
            , const ES_multi_mode ES_mode ) const
{
    return energyOriginal.getE_multi( i1+offset1, j1+offset1, i2+offset2, j2+offset2, ES_mode );
}
 
 
inline
bool
InteractionEnergyIdxOffset::
isValidInternalLoop( const size_t i1, const size_t j1, const size_t i2, const size_t j2 ) const
{
    return energyOriginal.isValidInternalLoop( i1+offset1, j1+offset1, i2+offset2, j2+offset2 );
}
 
 
inline
E_type
InteractionEnergyIdxOffset::
getEall1() const
{
    return energyOriginal.getEall1();
}
 
 
inline
E_type
InteractionEnergyIdxOffset::
getEall2() const
{
    return energyOriginal.getEall2();
}
 
 
 
} // namespace
 
 
#endif /* INTERACTIONENERGYIDXOFFSET_H_ */