main page namespaces classes files
CPSP home

src/cpsp/SideChain/chain_threading_all.h

Go to the documentation of this file.

#ifndef CHAIN_THREADING_ALL
#define CHAIN_THREADING_ALL
#include <biu/LatticeFrame.hh>
#include <cpsp/HCore.hh>
#include "chain_threading.h"
#include <iostream>

#include <gecode/kernel.hh>
#include <gecode/int.hh>
#include <gecode/search.hh>
#include "options/chain_option.h"
#include <cpsp/gecode/GC_ThreadingSymmBreaker.hh>
#include <algorithm>

using namespace Gecode;
using namespace std;
namespace {
class FailTimeStop : public Search::Stop {
private:
    Search::TimeStop *ts;
    Search::FailStop *fs;
    FailTimeStop(int fails, int time) {
        ts = new Search::TimeStop(time);
        fs = new Search::FailStop(fails);
    }
public:
    bool stop(const Search::Statistics& s) {
        return fs->stop(s) || ts->stop(s);
    }
    static Search::Stop* create(int fails, int time) {
        if (fails < 0 && time < 0) return NULL;
        if (fails < 0) return new Search::TimeStop( time);
        if (time  < 0) return new Search::FailStop(fails);
        return new FailTimeStop(fails, time);
    }
};
}

namespace cpsp{
//side chain threading
namespace scth{

class SideChainThreadingHandler{
private:
    int calculateCoreSize(std::string* seq);

    pair<int,int> checkParity(const std::string* seq);

    pair<int,int> checkHCoreParity(const HCore* hCore);

    bool checkSequenceHCoreParity(const std::string *seq, const HCore* hCore);

    int solutionsNum;
public:
    SideChainThreadingHandler(const SideChainOptions& );
    int getSolutionsNum();
};

class RunSideChainThreading{

    //The same input for the ChainThreading contructor,
    //with an option to decide how to print
public:

    static void deleteBrackets(std::string& absMoves){
        for(size_t i=0;i<absMoves.size();){
            if(absMoves[i]=='(' || absMoves[i]==')' ){
                absMoves.erase(i,1);
            }
            i=i+1;
        }
    }

    static void drawElement(const std::string* seq,std::string solution,const std::string* jmlHome, const std::string* viewerHome,const std::string* Description ){
        assert(viewerHome!=NULL);
        assert(Description!=NULL);
        //Just make it upper case
        std::string modifiedSeq= *seq;
//      modifiedSeq=RunSideChainThreading::StringToUpper(modifiedSeq);
        //Remove the brackets from the solution
        std::string solutionWithoutBrackets=solution;
        RunSideChainThreading::deleteBrackets(solutionWithoutBrackets);
        string lat;
        //Draw
        if(*(Description)=="fcc" || *(Description)=="FCC")
            lat="FCC";
        else lat="CUB";
        string binary=*viewerHome+" -seq="+modifiedSeq+" -abs="+solutionWithoutBrackets+" -jmolHome="+*jmlHome+" -jmol -lat="+lat+"";
//      char buff[255];
//      strcpy(buff, binary.c_str());
//      int st1=system(buff);
    }

    template <template<class> class Engine>
    static int run(const std::string *sequence,const biu::LatticeFrame* latFrame, const biu::IndexVec* neighVecs,cpsp::HCore* hCore,const cpsp::scth::SideChainOptions& option, const int maxSol){
        assert(sequence!=NULL);
        assert(latFrame!=NULL);
        assert(neighVecs!=NULL);
        assert(hCore!=NULL);
        //Obtaining the shifting vector
        biu::IPointVec* symmetryShiftVec=NULL;
        if(option.BreakSym)
            symmetryShiftVec = cpsp::gecode::GC_ThreadingSymmBreaker::generateGlobalShiftVec(
                    hCore, latFrame, symmetryShiftVec);
        int solutions=0; //The number of solutions
        SideChainThreading* sideChainInstance=new SideChainThreading(sequence,latFrame,neighVecs,hCore,symmetryShiftVec,option.BreakSym);

        unsigned int n_p = 0;
        unsigned int n_b = 0;
        if (sideChainInstance->status() != SS_FAILED) {
            n_p = sideChainInstance->propagators();
            n_b = sideChainInstance->branchings();
        }

//      Search::Stop* stop = FailTimeStop::create(-1,-1);
        Space* s = dynamic_cast<Space*>(sideChainInstance);
        Engine<Space> e(s,Search::Config::c_d,Search::Config::a_d,NULL);
        delete s;
        while(solutions< maxSol  ){
            SideChainThreading* ex = dynamic_cast<SideChainThreading*>(e.next());
            if (ex == NULL)
                break;
            
             // write move string to stream
            std::string sl = ex->print(sequence,latFrame,option.Output);
            
//          if(option.withOutput){
//              //Selecting draw option
//              if(option.Draw && option.Output==cpsp::scth::MOVES){
//                  cpsp::scth::RunSideChainThreading::drawElement(sequence,sl,option.JmlHome,option.ViewerHome,option.Description);
//                  std::cout<<"Enter to 'c' continue, or any char to stop drawing"<<std::endl;
//                  char drawChar;
//                  std::cin>>drawChar;
//                  if(drawChar!='c')
//                      option.Draw=false;
//              }
//          }

            solutions++;
            delete ex;
        } 
        return solutions;
    }
};
}
}
#endif