main page namespaces classes files
BIU home

src/biu/RNAStructure_TB.hh

Go to the documentation of this file.

#ifndef RNASTRUCTURE_TB_HH_
#define RNASTRUCTURE_TB_HH_


#include "biu/BioMolecule.hh"
#include "biu/AllowedBasePairs.hh"

namespace biu
{
    
    class RNAStructure_TB : public BioMolecule
    {
    protected:
        
            // Before:
            //  -A-B-C-D-E-F-G-H-I-J-K-L-M-N-O-P-Q-R-S-T-U-V-W-X-Y-Z-
            
            // After binding S with K
            //  -A-B-C-D-E-F-G-H-I-J-K-T-U-V-W-X-Y-Z-
            //                       |
            //                      -S-L-M-N-O-P-Q-R-
            
            //      -   <=>     next
            //      |   <=>     pair
        class TreeItem {
        public:
            
            size_t next;    //  next in sequence if there are no bonds, 
                            //  next in the same level, where a new bond does not cause a non-nested structure
            size_t pair;    // (lower/upper) level when paired
                             
            
            bool 
            operator == (const TreeItem& op2) const {
                return ((this->next==op2.next)&&(this->pair==op2.pair));
            }
        };
        
        
        
        
    public: //----------- abstract functions (BioMolecule)
            
        
            Sequence getSequence() const ;

            
            Structure getStructure() const ;
        
            virtual double  getEnergy() const ;
    
            
            size_t  getLength() const ;
        
            
            bool isValid() const;
            
            
            std::string getStringRepresentation() const;
            
        
            //-----------(END) abstract functions (BioMolecule)
        
        
        
        
    protected:


         static const size_t    MIN_LOOP_LENGTH;

        
         static const Alphabet STRUCT_ALPH;
        
        
        const bool      seqShared;

        
        const AllowedBasePairs*     bPair;

        
            // - Detailed status about the structure, i.e. why exactly the structure "is" invalid.
            //   Structure problem, Basepair problem or Loopsize problem 
            // - 0 if valid
            // - Status is used internally to determine whether an invalidity cause is determined or not yet
        mutable size_t strucStatus;
        
        
        Sequence*       rnaSeq;
        

            //  - Storing it as string was prefered because the energy calculation requires a string,
            //      otherwise the Structure datatype could be used instead.  
        std::string bracketStructStr;
        

        std::vector<TreeItem>* validTreeStruc; 
        
        
    public:
        
        
        static const Alphabet::AlphElem STRUCT_BND_OPEN;
        static const Alphabet::AlphElem STRUCT_BND_CLOSE;
        static const Alphabet::AlphElem STRUCT_UNBOUND;
        
            //  i.e. means that it is not pair to any base
        static const size_t INVALID_INDEX;
        
        
            // Structure Status Bits 
        static const size_t BASEPAIRS_VALIDITY ;            //000001
        static const size_t BASEPAIRS_VALIDITY_CALCULATED ; //000010
        static const size_t LOOPSIZE_VALIDITY ;             //000100
        static const size_t LOOPSIZE_VALIDITY_CALCULATED ;  //001000
        static const size_t STRUCTURE_VALIDITY ;            //010000
        static const size_t STRUCTURE_VALIDITY_CALCULATED ; //100000
        
        //  Do not change the following values without checking 
        //size_t moveType(size_t i, size_t j) const;
        static const size_t INSERT_MOVE;
        static const size_t SHIFT_MOVE;
        static const size_t REVERSE_SHIFT_MOVE;
        static const size_t INVALID_DELETE_MOVE;
        static const size_t DELETE_MOVE;
        
        
        
        // All global properties
        static const size_t getMinLoopLength() ;
        
        static const Alphabet* getStructureAlphabet() ;


        
        RNAStructure_TB(    const std::string& rnaSeqStr, 
                        const std::string& rnaStructBracketDotStr, 
                        const AllowedBasePairs* const bPair);
            
        
        RNAStructure_TB(    Sequence* rnaSeq, 
                        const Structure* const rnaStructBracketDot, 
                        const AllowedBasePairs* const bPair,
                        const bool seqIsShared);
                 
                
        RNAStructure_TB(const RNAStructure_TB& rnaStruct);
                
        
        virtual ~RNAStructure_TB();
    
        
        RNAStructure_TB&    operator= (const RNAStructure_TB& rnaStruct2);
        bool                operator== (const RNAStructure_TB& rnaStruct2) const;
        bool                operator!= (const RNAStructure_TB& rnaStruct2) const;

        
        
        virtual void setStructure(const Structure& str);
        
        
        // String representation of the sequence
        std::string getSequenceString() const ;
        
        // String representation of the structure
        std::string getStructureString() const ;

        // Reference to string representation of the structure
        const std::string& getStructureStringRef() const ;

        
        //The following three methods calculate the return value only if not yet calculated (by initialization)
        // and only for once, unless structure is changed
        
        
        bool hasValidStructure() const ;
        
        
        bool hasValidBasePairs() const ;
        
        
        bool hasValidLoopSize() const ;
        
        
        // Single move operations, (insert, delete, shift)

        // Move validity check: i,j order does not matter, k is always the free base
        bool isValidInsertMove(const size_t i, const size_t j) const;
        bool isValidDeleteMove(const size_t i, const size_t j) const;
        
        int isValidSingleMove( const size_t i, const size_t j) const;
        
        bool isValidLeftShiftMove(const size_t i, const size_t j, const size_t k) const;
        bool isValidRightShiftMove(const size_t i, const size_t j, const size_t k) const;
        
    
        
        
        
        
        
        
        
        // Move Set 1: i,j order does not matter
        void insertBond(const size_t i, const size_t j);
        void deleteBond(const size_t i, const size_t j);
                
        //  Move Set 2: i,j are the already existing bond, k is the open base
        void leftShift(const size_t i, const size_t j, const size_t k);
        void rightShift(const size_t i, const size_t j, const size_t k);
        
        void shiftUnordered(const size_t i, const size_t j);
        
        void shiftToBond(const size_t i, const size_t k);
        
        void shiftToBond(const size_t i, const size_t j, const size_t k);
        
        
        
        size_t moveType(size_t i, size_t j) const ;
                
        void executeOrderedMove(size_t i, size_t j);

        bool executeOrderedMoveTry(size_t i, size_t j);
        
        
        bool getNextSingleMove( size_t& i, size_t& j ) const ;
        
        
        
        size_t getCorrespondingBase(size_t basePos) const;
    
        
        bool isAllowedBasePair(size_t pos1, size_t pos2) const;
        
        

        

    
    protected:

        
        bool initTree(const Structure& str);
        
        
        // auxiliary function used by the move validity checking functions
        bool areOnSameLevel(const size_t i, const size_t j) const ;
        
        
        // auxiliary function used to set the brackets in the string representation 
        // for the not necessarily ordered i,j pair 
        void setStringBrackets(const size_t i, const size_t j);

        
        
        
        
        
    private:

        std::string decodedStatus() const;
        
        
        
        
    public:
        bool isValidUnorderedShift(const size_t i, const size_t j) const;
            
            
        bool isValidShift(const size_t i, const size_t j) const;
        
        
        void decodeMoveIndex(size_t const index,  size_t&  i,  size_t&  j) const;
                        
        bool executeOrderedMoveTry(size_t const index);
        
        size_t getMoveIndexCount() const;

        
    };


} // namespace biu

#include "biu/RNAStructure_TB.icc"

#endif /*RNASTRUCTURE_TB_HH_*/