main page namespaces classes files
CPSP home

src/cpsp/gecode/GC_HPThreading.hh

Go to the documentation of this file.

/*
 *  Main authors:
 *     Martin Mann http://www.bioinf.uni-freiburg.de/~mmann/
 *
 *  Contributing authors:
 *     Sebastian Will http://www.bioinf.uni-freiburg.de/~will/
 *
 *  Copyright:
 *     Martin Mann, 2007
 *
 *  This file is part of the CPSP-tools package:
 *     http://www.bioinf.uni-freiburg.de/sw/cpsp/
 *
 *  See the file "LICENSE" for information on usage and
 *  redistribution of this file, and for a
 *     DISCLAIMER OF ALL WARRANTIES.
 *
 */

#ifndef GC_HPTHREADING_HH_
#define GC_HPTHREADING_HH_


#include "cpsp/HPThreadingHandler.hh"
#include "cpsp/gecode/GC_ThreadingSpace.hh"

namespace cpsp
{

  namespace gecode
  {

    class GC_HPThreading : public cpsp::HPThreadingHandler
    {

    public:

        enum CORESELECTS { FIRST, ALL_BEST, ALL };  // steuert kernauswahl
        enum RUNMODE { COUNT, ENUMERATE };
        enum DISTANCE { DIST_POSITIONS, DIST_ABSMOVES, DIST_SHAPES, DIST_NONE }; 
        


    protected:

        bool verboseOutput;
        const biu::LatticeDescriptor* latDescr;
        biu::LatticeFrame* latFrame;
        HCoreDatabase* coreDB;
        std::string sequence;
        GC_ThreadingSpace::HullLevel hullLvl;
        unsigned int coreSize;
        unsigned int minEvenOddHs;
        unsigned int contactsInSeq;
        unsigned int maxPCoreDistance;
        GC_ThreadingSpace::SeqFeatureMap seqFeatureMap;
        bool useSymmetryBreaking;
        bool useDDS;
        unsigned int maxStructures;
        CORESELECTS coreSelection;
        RUNMODE runMode;
        bool noOutput;
        bool statisticsOut;
        bool noRecomputation;
        DISTANCE distanceMode;
        unsigned int distanceMin;
        bool normalizeStructures;
        
        
        template<class ENGINE, class SPACE>
        unsigned int
        enumerateStructures(SPACE *space, unsigned int maxNum, 
            Gecode::Search::Statistics *stat, std::ostream &out);
        
        template<class Int, class SPACE>
        Int
        countBAB(SPACE *space, unsigned int c_d, unsigned int a_d, 
            Gecode::Search::Statistics* stat, Gecode::Search::Stop* st, 
            Int maxNum); 

    public:
        GC_HPThreading(const biu::LatticeDescriptor* latDescr_ = NULL,
            HCoreDatabase* db = NULL, const std::string seq = "")
            throw(cpsp::Exception);
        virtual ~GC_HPThreading();

        unsigned int
        enumerateStructures(SuperSpace * space, unsigned int maxNum,
        Gecode::Search::Statistics *globalStat = NULL, 
        std::ostream &out = std::cout);

        unsigned int
        countStructures(SuperSpace * space,  unsigned int maxNum,
        bool useDDS = true, Gecode::Search::Statistics *statistic = NULL);

            // abstract function implementation
        virtual
        unsigned int
        generateStructures();

        virtual
        unsigned int
        enumerateStructures(StringVec & structs);

    public:

        void
        setVerboseOutput( const bool val ) { verboseOutput = val; }
        const bool
        getVerboseOutput( void ) const { return verboseOutput; }

        void
        setLatticeDescriptor( const biu::LatticeDescriptor* val );
        const biu::LatticeDescriptor*
        getLatticeDescriptor( void ) const { return latDescr; }

        void
        setCoreDB( HCoreDatabase* db ) { coreDB = db; }
        HCoreDatabase*
        getCoreDB( void ) const { return coreDB; }

        void
        setSequence( const std::string& seq ) throw(cpsp::Exception);
        const std::string&
        getSequence( void ) { return sequence; }

        const unsigned int
        getCoreSize( void ) const { return coreSize; }

        const unsigned int
        getContactsInSeq( void ) const { return contactsInSeq; }

        void
        setSymmetryBreaking( const bool val ) { useSymmetryBreaking = val; }
        const bool
        getSymmetryBreaking( void ) const { return useSymmetryBreaking; }

        void
        setUsingDDS( const bool val ) { useDDS = val; }
        const bool
        getUsingDDS( void ) const { return useDDS; }

        void
        setMaxStructures( const unsigned int val ) { maxStructures = val; }
        const unsigned int
        getMaxStructures( void ) const { return maxStructures; }

        void
        setCoreSelection( const CORESELECTS val ) { coreSelection = val; }
        const CORESELECTS
        getCoreSelection( void ) const { return coreSelection; }

        void
        setRunMode( const RUNMODE val ) { runMode = val; }
        const RUNMODE
        getRunMode( void ) const { return runMode; }

        void
        setNoOutput( const bool val ) { noOutput = val; if(noOutput) setVerboseOutput(false);}
        const bool
        getNoOutput( void ) const { return noOutput; }

        void
        setStatOutput( const bool val ) { statisticsOut = val; }
        const bool
        getStatOutput( void ) const { return statisticsOut; }

        void
        setNoRecomputation( const bool val ) { noRecomputation = val; }
        const bool
        getNoRecomputation( void ) const { return noRecomputation; }

        void 
        setDistanceMode( const DISTANCE val ) { distanceMode = val; }
        const DISTANCE
        getDistanceMode( void ) const { return distanceMode; }
        
        void 
        setDistanceMin( const unsigned int val ) { distanceMin = val; }
        const unsigned int
        getDistanceMin( void ) const { return distanceMin; }
        
        void 
        setNormalizeStructures( const bool val ) { normalizeStructures = val; }
        const bool
        getNormalizeStructures( void ) const { return normalizeStructures; }
        

    };
    
    template<class ENGINE, class SPACE>
    inline
    unsigned int
    GC_HPThreading::enumerateStructures(SPACE *space,
        unsigned int maxNum, Gecode::Search::Statistics *stat, 
        std::ostream &out)
    {
        unsigned int sols = 0;
        SPACE* s = dynamic_cast<SPACE*>(space);
            // e = searchengine
        ENGINE dfs_e( s,
                    (noRecomputation?1:Gecode::Search::Config::c_d),
                    (noRecomputation?1:Gecode::Search::Config::a_d),
                    NULL );
            // first solution if any
        SPACE* solution = dfs_e.next();
            // enumerate solutions
        while (solution != NULL && ++sols <= maxNum) {
            // ausgabe der struktur
            if (normalizeStructures) {
                out <<latFrame->getString(
                        latFrame->getDescriptor()->normalizeSequence(
                            latFrame->indicesToAbsMoves(
                                solution->getSolution())))
                    <<std::endl;
            } else {
                out <<latFrame->getString(
                            latFrame->indicesToAbsMoves(
                                solution->getSolution()))
                    <<std::endl;
            }
            // handle solution if neccessary
            solution->handleSolution(solution);
            delete solution;        // clear memory
            solution = dfs_e.next();
        } ;
        
        if (solution != NULL)
            delete solution;        // clear memory

        if (stat != NULL) {
                // get statistics
            *stat = dfs_e.statistics();
        }
        return (sols > maxNum ? maxNum : sols);
    }

    template<class Int, class SPACE>
    inline
    Int
    GC_HPThreading::countBAB(SPACE *space, unsigned int c_d, unsigned int a_d, 
        Gecode::Search::Statistics* stat, Gecode::Search::Stop* st,
        Int maxNum) 
    {
            // init branch and bound search engine
        Gecode::BAB<SPACE> engine( space, c_d, a_d, st);
            // counter
        Int sols = 0;
    
            // get first solution if available
        SPACE* nextSol = engine.next();
            // while solution found
        while( nextSol != NULL && ++sols <= maxNum) {
    
            sols++; // count for statistics
                // handle solution
            nextSol->handleSolution(nextSol);
            delete nextSol;             // clean up
            nextSol = engine.next();    // get next solution
        }
        if (nextSol != NULL)
            delete nextSol;             // clean up
        if (stat != NULL)
           *stat = engine.statistics();
        return (sols > maxNum ? maxNum : sols);
    }
    

  } // namespace gecode
} // namespace cpsp

#endif /*GC_HPTHREADING_HH_*/