HelixHandlerNoBulgeMax.h

Go to the documentation of this file.

 
#ifndef INTARNA_HELIXHANDLERNOBULGEMAX_H_
#define INTARNA_HELIXHANDLERNOBULGEMAX_H_
 
#include "IntaRNA/InteractionEnergy.h"
#include "IntaRNA/HelixConstraint.h"
#include "IntaRNA/HelixHandler.h"
 
#include <boost/unordered_map.hpp>
 
namespace IntaRNA {
 
class HelixHandlerNoBulgeMax : public HelixHandler {
 
 
public:
 
    typedef std::pair<E_type, size_t> HelixData;
 
    typedef boost::unordered_map< Interaction::BasePair, HelixData, Interaction::BasePair::Hash > HelixHash;
 
protected:
 
    typedef HelixHash::key_type BP;
 
public:
 
    HelixHandlerNoBulgeMax(
            const InteractionEnergy & energy
            , const HelixConstraint & helixConstraint
            , SeedHandler * const seedHandler = NULL
    );
 
    virtual ~HelixHandlerNoBulgeMax();
 
    virtual
    const HelixConstraint&
    getConstraint() const;
 
    virtual
    const InteractionEnergy&
    getInteractionEnergy() const;
 
 
    virtual
    size_t
    fillHelix( const size_t i1, const size_t j1, const size_t i2, const size_t j2 );
 
    virtual
    size_t
    fillHelixSeed( const size_t i1, const size_t j1, const size_t i2, const size_t j2 );
 
    virtual
    void
    traceBackHelix( Interaction & interaction, const size_t i1, const size_t i2);
 
    virtual
    void
    traceBackHelixSeed( Interaction & interaction, const size_t i1, size_t i2);
 
    virtual
    E_type getHelixE( const size_t i1, const size_t i2 ) const;
 
    virtual
    E_type getHelixSeedE( const size_t i1, const size_t i2 ) const;
 
    virtual
    size_t
    getHelixLength1( const size_t i1, const size_t i2 ) const;
 
    virtual
    size_t
    getHelixLength2( const size_t i1, const size_t i2 ) const;
 
 
    virtual
    size_t
    getHelixSeedLength1( const size_t i1, const size_t i2 ) const;
 
    virtual
    size_t
    getHelixSeedLength2( const size_t i1, const size_t i2 ) const;
 
    void setSeedHandler(SeedHandler & seedHandler);
 
protected:
 
    size_t
    encodeHelixSeedLength( const size_t l1, const size_t l2 ) const;
 
    size_t
    decodeHelixSeedLength1( const size_t code ) const;
 
    size_t
    decodeHelixSeedLength2( const size_t code ) const;
 
protected:
 
    const InteractionEnergy& energy;
 
    const HelixConstraint & helixConstraint;
 
    HelixHash helix;
 
    HelixHash helixSeed;
 
    // seedHandler used in helixSeed computation
    SeedHandler * seedHandler;
};
 
 
inline
HelixHandlerNoBulgeMax::HelixHandlerNoBulgeMax(
        const InteractionEnergy & energy
        , const HelixConstraint & helixConstraint
        , SeedHandler * const seedHandler
)
        :
        energy(energy)
        , helixConstraint(helixConstraint)
        , helix()
        , helixSeed()
{
    if (seedHandler != NULL) {
        setSeedHandler( *seedHandler );
    }
}
 
 
inline
HelixHandlerNoBulgeMax::~HelixHandlerNoBulgeMax()
{
}
 
 
inline
const InteractionEnergy&
HelixHandlerNoBulgeMax::
getInteractionEnergy() const
{
    return energy;
}
 
 
inline
const HelixConstraint&
HelixHandlerNoBulgeMax::
getConstraint() const
{
    return helixConstraint;
}
 
 
inline
E_type
HelixHandlerNoBulgeMax::
getHelixE(const size_t i1, const size_t i2) const
{
    // try to locate helix information
    HelixHash::const_iterator data = helix.find(BP(i1,i2));
    // return respective value
    return (data==helix.end()) ? E_INF : data->second.first;
}
 
 
inline
E_type
HelixHandlerNoBulgeMax::
getHelixSeedE(const size_t i1, const size_t i2) const
{
    // try to locate helix information
    HelixHash::const_iterator data = helixSeed.find(BP(i1,i2));
    // return respective value
    return (data==helixSeed.end()) ? E_INF : data->second.first;
}
 
 
inline
size_t
HelixHandlerNoBulgeMax::
getHelixLength1(const size_t i1, const size_t i2) const
{
    // try to locate helix information
    HelixHash::const_iterator data = helix.find(BP(i1,i2));
    // return respective value
    return (data==helix.end()) ? 0 : data->second.second;
}
 
 
inline
size_t
HelixHandlerNoBulgeMax::
getHelixLength2(const size_t i1, const size_t i2) const
{
    // try to locate helix information
    HelixHash::const_iterator data = helix.find(BP(i1,i2));
    // return respective value
    return (data==helix.end()) ? 0 : data->second.second;
}
 
 
inline
size_t
HelixHandlerNoBulgeMax::
getHelixSeedLength1(const size_t i1, const size_t i2) const
{
    // try to locate helix information
    HelixHash::const_iterator data = helixSeed.find(BP(i1,i2));
    // return respective value
    return (data==helixSeed.end()) ? 0 : decodeHelixSeedLength1(data->second.second);
}
 
 
inline
size_t
HelixHandlerNoBulgeMax::
getHelixSeedLength2(const size_t i1, const size_t i2) const
{
    // try to locate helix information
    HelixHash::const_iterator data = helixSeed.find(BP(i1,i2));
    // return respective value
    return (data==helixSeed.end()) ? 0 : decodeHelixSeedLength2(data->second.second);
}
 
 
inline
size_t
HelixHandlerNoBulgeMax::
encodeHelixSeedLength( const size_t l1, const size_t l2 ) const
{
    return l1 + l2*(helixConstraint.getMaxLength1() + seedHandler->getConstraint().getMaxLength1()+1);
}
 
 
inline
size_t
HelixHandlerNoBulgeMax::
decodeHelixSeedLength1( const size_t code ) const
{
    return code % (helixConstraint.getMaxLength1() + seedHandler->getConstraint().getMaxLength1()+1);
}
 
 
inline
size_t
HelixHandlerNoBulgeMax::
decodeHelixSeedLength2( const size_t code ) const
{
    return code / (helixConstraint.getMaxLength1() + seedHandler->getConstraint().getMaxLength1()+1);
}
 
 
inline
void
HelixHandlerNoBulgeMax::setSeedHandler(SeedHandler & seedHandler) {
    this->seedHandler = &seedHandler;
}
 
 
} // namespace
#endif /* HELIXHANDLERNOBULGEMAX_H_ */