src/coalescemotifs.h

/*****************************************************************************
* This file is provided under the Creative Commons Attribution 3.0 license.
*
* You are free to share, copy, distribute, transmit, or adapt this work
* PROVIDED THAT you attribute the work to the authors listed below.
* For more information, please see the following web page:
* http://creativecommons.org/licenses/by/3.0/
*
* This file is a component of the Sleipnir library for functional genomics,
* authored by:
* Curtis Huttenhower (chuttenh@princeton.edu)
* Mark Schroeder
* Maria D. Chikina
* Olga G. Troyanskaya (ogt@princeton.edu, primary contact)
*
* If you use this library, the included executable tools, or any related
* code in your work, please cite the following publication:
* Curtis Huttenhower, Mark Schroeder, Maria D. Chikina, and
* Olga G. Troyanskaya.
* "The Sleipnir library for computational functional genomics"
*****************************************************************************/
#ifndef COALESCEMOTIFS_H
#define COALESCEMOTIFS_H

#include "coalescemotifsi.h"

namespace Sleipnir {

struct SCoalesceModifierCache;
struct SMotifMatch;

class CCoalesceMotifLibrary : CCoalesceMotifLibraryImpl {
public:
    static bool Open( std::istream& istm, std::vector<SMotifMatch>& vecsMotifs,
        CCoalesceMotifLibrary* pMotifs = NULL );

    static std::string GetReverseComplement( const std::string& strKMer ) {

        return CCoalesceMotifLibraryImpl::GetReverseComplement( strKMer ); }

    CCoalesceMotifLibrary( size_t iK ) : CCoalesceMotifLibraryImpl( iK ) { }

    float GetMatch( const std::string& strSequence, uint32_t iMotif, size_t iOffset,
        SCoalesceModifierCache& sModifiers ) const;
    uint32_t Open( const std::string& strMotif );
    bool OpenKnown( std::istream& istm );
    std::string GetPWM( uint32_t iMotif, float dCutoffPWMs, float dPenaltyGap, float dPenaltyMismatch,
        bool fNoRCs ) const;
    bool Simplify( uint32_t iMotif ) const;
    bool GetKnown( uint32_t iMotif, SMotifMatch::EType eMatchType, float dPenaltyGap, float dPenaltyMismatch,
        std::vector<std::pair<std::string, float> >& vecprstrdKnown, float dPValue = 1 ) const;

    size_t GetKnowns( ) const {

        return m_sKnowns.GetSize( ); }

    std::string GetMotif( uint32_t iMotif ) const {

        return CCoalesceMotifLibraryImpl::GetMotif( iMotif ); }

    uint32_t Merge( uint32_t iOne, uint32_t iTwo, float dCutoff, bool fAllowDuplicates ) {
        std::pair<uint32_t, uint32_t>   priiMerged;
        TMapPrIII::const_iterator       iterMerged;
        uint32_t                        iRet;

        if( iOne == iTwo )
            return ( fAllowDuplicates ? iOne : -1 );
        priiMerged.first = (uint32_t)min( iOne, iTwo );
        priiMerged.second = max( iOne, iTwo );
        if( ( iterMerged = m_mappriiiMerged.find( priiMerged ) ) != m_mappriiiMerged.end( ) )
            return ( fAllowDuplicates ? iterMerged->second : -1 );

        switch( GetType( iOne ) ) {
            case ETypeRC:
                switch( GetType( iTwo ) ) {
                    case ETypeKMer:
                        iRet = MergeKMerRC( iTwo, iOne, dCutoff, fAllowDuplicates );
                        break;

                    case ETypeRC:
                        iRet = MergeRCs( iOne, iTwo, dCutoff, fAllowDuplicates );
                        break;

                    case ETypePST:
                        iRet = MergeRCPST( iOne, *GetPST( iTwo ), dCutoff, fAllowDuplicates );
                        break; }
                break;

            case ETypePST:
                switch( GetType( iTwo ) ) {
                    case ETypeKMer:
                        iRet = MergeKMerPST( GetMotif( iTwo ), *GetPST( iOne ), dCutoff, fAllowDuplicates );
                        break;

                    case ETypeRC:
                        iRet = MergeRCPST( iTwo, *GetPST( iOne ), dCutoff, fAllowDuplicates );
                        break;

                    case ETypePST:
                        iRet = MergePSTs( *GetPST( iOne ), *GetPST( iTwo ), dCutoff, fAllowDuplicates );
                        break; }
                break;

            case ETypeKMer:
                switch( GetType( iTwo ) ) {
                    case ETypeRC:
                        iRet = MergeKMerRC( iOne, iTwo, dCutoff, fAllowDuplicates );
                        break;

                    case ETypePST:
                        iRet = MergeKMerPST( GetMotif( iOne ), *GetPST( iTwo ), dCutoff, fAllowDuplicates );
                        break;

                    case ETypeKMer:
                        iRet = MergeKMers( GetMotif( iOne ), GetMotif( iTwo ), dCutoff, fAllowDuplicates );
                        break; }
                break; }

        if( iRet != -1 )
            m_mappriiiMerged[ priiMerged ] = iRet;
        return iRet; }

    uint32_t RemoveRCs( uint32_t iMotif, float dPenaltyGap, float dPenaltyMismatch ) {

        switch( GetType( iMotif ) ) {
            case ETypePST:
                return CCoalesceMotifLibraryImpl::RemoveRCs( *GetPST( iMotif ), dPenaltyGap,
                    dPenaltyMismatch );

            case ETypeRC:
                return (uint32_t)m_veciRC2KMer[ iMotif - GetBaseRCs( ) ]; }

        return iMotif; }

    float Align( uint32_t iOne, uint32_t iTwo, float dCutoff ) {

        switch( GetType( iOne ) ) {
            case ETypeRC:
                switch( GetType( iTwo ) ) {
                    case ETypeKMer:
                        return AlignKMerRC( GetMotif( iTwo ), iOne, dCutoff );

                    case ETypeRC:
                        return AlignRCs( iOne, iTwo, dCutoff );

                    case ETypePST:
                        return AlignRCPST( iOne, *GetPST( iTwo ), dCutoff ); }

            case ETypePST:
                switch( GetType( iTwo ) ) {
                    case ETypeKMer:
                        return AlignKMerPST( GetMotif( iTwo ), *GetPST( iOne ), dCutoff );

                    case ETypeRC:
                        return AlignRCPST( iTwo, *GetPST( iOne ), dCutoff );

                    case ETypePST:
                        return AlignPSTs( *GetPST( iOne ), *GetPST( iTwo ), dCutoff ); } }

        switch( GetType( iTwo ) ) {
            case ETypeRC:
                return AlignKMerRC( GetMotif( iOne ), iTwo, dCutoff );

            case ETypePST:
                return AlignKMerPST( GetMotif( iOne ), *GetPST( iTwo ), dCutoff ); }

        return AlignKMers( GetMotif( iOne ), GetMotif( iTwo ), dCutoff ); }

    size_t GetMotifs( ) const {

// kmers plus reverse complements plus psts
        return ( GetBasePSTs( ) + GetPSTs( ) ); }

    size_t GetK( ) const {

        return m_iK; }

    bool GetMatches( const std::string& strKMer, std::vector<uint32_t>& veciMotifs ) const {
        uint32_t    iMotif;
        size_t      iRC;

        if( IsIgnorableKMer( strKMer ) )
            return true;
// kmer
        if( ( iMotif = KMer2ID( strKMer ) ) == -1 )
            return false;
        veciMotifs.push_back( iMotif );
// reverse complement
        if( ( iRC = m_veciKMer2RC[ iMotif ] ) != -1 )
            veciMotifs.push_back( GetBaseRCs( ) + iRC );
        return true; }

    void SetPenaltyGap( float dPenalty ) {

        m_dPenaltyGap = dPenalty; }

    float GetPenaltyGap( ) const {

        return m_dPenaltyGap; }

    void SetPenaltyMismatch( float dPenalty ) {

        m_dPenaltyMismatch = dPenalty; }

    float GetPenaltyMismatch( ) const {

        return m_dPenaltyMismatch; }

    const CPST* GetPST( uint32_t iMotif ) const {

        return ( ( GetType( iMotif ) == ETypePST ) ? CCoalesceMotifLibraryImpl::GetPST( iMotif ) : NULL ); }
};

}

#endif // COALESCEMOTIFS_H