main page namespaces classes files
CPSP home

src/cpsp/gecode/GC_ThreadingSpace.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_THREADINGSPACE_HH_
#define GC_THREADINGSPACE_HH_

#include <gecode/kernel.hh>
#include <gecode/int.hh>
#include <gecode/search.hh>
#include <gecode/minimodel.hh>

#include <string>
#include <vector>

#include "cpsp/HCore.hh"
#include "cpsp/HPThreadingOptions.hh"
#include "cpsp/gecode/GC_ThreadingSymmBreaker.hh"
#include "cpsp/gecode/GC_StlSetRangeIterator.hh"

#include "cpsp/gecode/gecodeExtensions.hh"

namespace cpsp
{
  namespace gecode
  {


  class IntDomSize {
  public:
      unsigned int operator()(const Gecode::Int::IntView& i) const {
        return i.size();
      }
  };

    typedef Gecode::Space SuperSpace;
//  typedef Gecode::Search::DDSSpace SuperSpace;

    enum BranchingType { 
            BR_NONE = 0,    
            BR_DFS = 1,     
    //  BR_DDS  ==>  currently not supported  ==> no branching posted 
            BR_DDS = 2,     
            BR_SYM = 4      
        };


    class GC_ThreadingSpace : public SuperSpace
    {
    public:
        enum SeqFeatures{ P_SINGLET, H_SINGLET };

        typedef std::map< SeqFeatures, std::vector <unsigned int> > SeqFeatureMap;

        typedef std::vector<unsigned int> HullLevel;
        
        enum NeighPropLvl{ 
                CUSTOM_2,   
                NO_PROP     
            };
        
        
    protected:

        Gecode::IntVarArray domains;
        
        std::vector<int> rank;

    public:
        GC_ThreadingSpace(const std::string *sequence,
            const biu::LatticeFrame* latFrame,
            const biu::IndexVec* neighVecs,
            SeqFeatureMap* seqFeatureMap,
            const HullLevel *hullLvl,
            HCore* hCore,
            const GC_ThreadingSymmBreaker::GlobalShiftVec* shiftVec,
            int branchingType = BR_DFS|BR_SYM,
            NeighPropLvl neighPropLvl = CUSTOM_2);
        GC_ThreadingSpace(bool share, GC_ThreadingSpace& toCopy);
        virtual ~GC_ThreadingSpace();

        virtual SuperSpace* copy(bool share);

        virtual biu::IndexVec getSolution() const ;
        virtual void print() const;

        int getRank(int index) const;

        virtual void handleSolution(GC_ThreadingSpace* solution)
        {}

/*
    */

    virtual
    int getIndex(const Gecode::Int::IntView &v)  const   {
        for (int i=0;i <domains.size(); i++) {
            Gecode::Int::IntView vd(domains[i]);
            if (vd.variable() == v.variable())
                return i;
        }
        return -1;
    }
    virtual
    int getIndex(const Gecode::VarBase *vb) const
    {
        for (int i=0;i <domains.size(); i++) {
            if (domains[i].variable() == vb)
                return i;
        }
        return -1;
    }
    };


    

    
    class GC_ThreadingSpacePosDist : public GC_ThreadingSpace {
    public:
    
        typedef std::vector<Gecode::IntArgs> SolutionVec;

        SolutionVec* solPositions;

    protected:
        unsigned int maxEqual;

    public:
    
        GC_ThreadingSpacePosDist(const std::string *sequence,
            const biu::LatticeFrame* latFrame,
            const biu::IndexVec* neighVecs,
            SeqFeatureMap* seqFeatureMap,
            const HullLevel *hullLvl,
            HCore* hCore,
            const GC_ThreadingSymmBreaker::GlobalShiftVec* shiftVec,
            int branchingType = BR_DFS|BR_SYM,
            SolutionVec* solPositions_ = NULL,
            unsigned int maxEqual_ = 0)
          : GC_ThreadingSpace( sequence, latFrame, neighVecs, seqFeatureMap,
                hullLvl, hCore, shiftVec, branchingType),
            solPositions(solPositions_), maxEqual(maxEqual_) 
        {
            // apply addition constraints of already found solutions on 
            // different cores
            constrain(this);
        }
            
        GC_ThreadingSpacePosDist(bool share, GC_ThreadingSpacePosDist& toCopy)
          : GC_ThreadingSpace(share, toCopy), 
            solPositions(toCopy.solPositions),
            maxEqual(toCopy.maxEqual)
        {}
        
        virtual ~GC_ThreadingSpacePosDist() 
        {}

        virtual SuperSpace* copy(bool share)
        { return new GC_ThreadingSpacePosDist(share,*this); }

        virtual void constrain(GC_ThreadingSpacePosDist* lastSolution)
        {
                // add one distance constrain for each solution found so far
            for(SolutionVec::iterator sol = solPositions->begin(); 
                    sol != solPositions->end(); sol++) 
            {
                Gecode::atmost(this, domains, (*sol), maxEqual, Gecode::ICL_DOM);
            }
        }
        virtual void handleSolution(GC_ThreadingSpacePosDist* solution)
        {
//@TODO : add all symmetric solutions !?!?!?
            assert(solPositions != NULL);
            solPositions->push_back(Gecode::IntArgs(domains.size()));   // new sol data
            Gecode::IntArgs& y = *(solPositions->rbegin()); // access to last element
            for (int i = y.size(); i--; )           // daten kopieren 
                y[i] = solution->domains[i].val();
        }

    };
    
    
    class GC_ThreadingSpaceMoveDist : public GC_ThreadingSpace {
    public:
    
        typedef std::vector<Gecode::IntArgs> SolutionVec;

        SolutionVec* solMoves;

    protected:
        unsigned int maxEqual;
        
        Gecode::IntVarArray absMoves;
        
        using GC_ThreadingSpace::domains; 
        
    public:
    
        GC_ThreadingSpaceMoveDist(const std::string *sequence,
            const biu::LatticeFrame* latFrame,
            const biu::IndexVec* neighVecs,
            SeqFeatureMap* seqFeatureMap,
            const HullLevel *hullLvl,
            HCore* hCore,
            const GC_ThreadingSymmBreaker::GlobalShiftVec* shiftVec,
            int branchingType = BR_DFS|BR_SYM,
            SolutionVec* solMoves_ = NULL,
            unsigned int maxEqual_ = 0)
          : GC_ThreadingSpace( sequence, latFrame, neighVecs, seqFeatureMap,
                hullLvl, hCore, shiftVec, branchingType, NO_PROP),
            solMoves(solMoves_), maxEqual(maxEqual_), 
            absMoves(this,domains.size()-1)
             
        {
            std::set<int> tmp;
            assert(neighVecs != NULL);
            for(biu::IndexVec::const_iterator it = neighVecs->begin();
                    it != neighVecs->end(); it++)
                tmp.insert(*it);
            int neighMin = *(tmp.begin()), neighMax = *(tmp.rbegin());
            
            using namespace Gecode;
            // adding redundant neighboring constraints for absMoves propagation
            for (int i=absMoves.size(); i--; ) {
                    // init move var
                absMoves[i] = Gecode::IntVar(this, neighMin, neighMax);
                    // shrink move var to allowed moves
                GC_StlSetRangeIterator it(&tmp);
                Gecode::Int::IntView(absMoves[i]).narrow<GC_StlSetRangeIterator>(this, it);
                    // add propagation on move var and position vars
                post(this, (domains[i+1]-domains[i]) == absMoves[i], Gecode::ICL_DOM);
            }
            // apply addition constraints of already found solutions on 
            // different cores
            constrain(this);
        }
            
        GC_ThreadingSpaceMoveDist(bool share, GC_ThreadingSpaceMoveDist& toCopy)
          : GC_ThreadingSpace(share, toCopy), 
            solMoves(toCopy.solMoves),
            maxEqual(toCopy.maxEqual), absMoves()
        {
            absMoves.update(this, share, toCopy.absMoves);
        }
        
        virtual ~GC_ThreadingSpaceMoveDist() 
        {}

        virtual SuperSpace* copy(bool share)
        { return new GC_ThreadingSpaceMoveDist(share,*this); }

        virtual void constrain(GC_ThreadingSpaceMoveDist* lastSolution)
        {
                // add one distance constrain for each solution found so far
            for(SolutionVec::iterator sol = solMoves->begin(); 
                    sol != solMoves->end(); sol++) 
            {
                Gecode::atmost(this, absMoves, (*sol), maxEqual, Gecode::ICL_DOM);
            }
        }
        virtual void handleSolution(GC_ThreadingSpaceMoveDist* solution)
        {
//@TODO : add all symmetric solutions !?!?!?

//@TODO : POS_DIST : was nach kernwechsel? alte löschen? irgendwie umrechnen? normieren?
            assert(solMoves != NULL );
            // original data
            solMoves->push_back(Gecode::IntArgs(absMoves.size()));  // new sol data
            Gecode::IntArgs& y = *(solMoves->rbegin()); // access to last element
            for (int i = y.size(); i--; ) {         // daten kopieren 
                y[i] = solution->absMoves[i].val();
            }
            
        }

    };
    
    
    
    class GC_ThreadingSpaceShapes : public GC_ThreadingSpace {
    
    protected:
    
        using GC_ThreadingSpace::domains;

    public:
    
        GC_ThreadingSpaceShapes(const std::string *sequence,
            const biu::LatticeFrame* latFrame,
            const biu::IndexVec* neighVecs,
            SeqFeatureMap* seqFeatureMap,
            const HullLevel *hullLvl,
            HCore* hCore,
            const GC_ThreadingSymmBreaker::GlobalShiftVec* shiftVec,
            int branchingType = BR_DFS|BR_SYM);
            
        GC_ThreadingSpaceShapes(bool share, GC_ThreadingSpaceShapes& toCopy)
          : GC_ThreadingSpace(share, toCopy)
        {}
        
        virtual ~GC_ThreadingSpaceShapes() 
        {}

        virtual SuperSpace* copy(bool share)
        { return new GC_ThreadingSpaceShapes(share,*this); }

    };
    
    

  } // namespace gecode
} // namespace cpsp

#endif /*GC_THREADINGSPACE_HH_*/