MergingFactory.h

 
  //
  //
  //
#ifndef HERWIG_MergingFactory_H
#define HERWIG_MergingFactory_H
  //
  //
 
#include "MergingFactory.fh"
#include "Herwig/MatrixElement/Matchbox/MatchboxFactory.h"
#include "Node.fh"
#include "Merger.h"
#include "ThePEG/Persistency/PersistentOStream.h"
#include "ThePEG/Persistency/PersistentIStream.h"
namespace Herwig {
  
  using namespace ThePEG;
  
  class MergingFactory : public MatchboxFactory {
  public:
    void productionMode();
    virtual void setup();
    void fillMEsMap();
    void prepare_BV(int i);
    void prepare_R(int i);
    void pushB(MatchboxMEBasePtr, int);
      //push the virtual contributions to the ME vector.
    void pushV(MatchboxMEBasePtr, int);
    void pushR(MatchboxMEBasePtr, int);
    void orderOLPs();
    int onlymulti()const {
      return theonlymulti==-1?-1:(theonlymulti+int(processMap.find(0)->second.size()));
    }
    MergerPtr MH() {return theMergingHelper;}
    int M() const {return theM-1;}
    int N() const {return theN;}
    const map<int, vector<MatchboxMEBasePtr> >& pureMEsMap() const {
      return thePureMEsMap;
    }
    map<int, vector<MatchboxMEBasePtr> >& pureMEsMap() {
      return thePureMEsMap;
    }
      //Parse a process description
    virtual vector<string> parseProcess(string);
      // fill the virtuals vector (these are IPK-operators)
    void getVirtuals(MatchboxMEBasePtr nlo, bool clone );
      // In the merged setup we only produce single phase space points. 
    bool subProcessGroups() const { return false;}
      // Cut on non-QCD observables. 
    Ptr<Cuts>::ptr nonQCDCuts(){return theNonQCDCuts;}
 
  public:
    
    void persistentOutput(PersistentOStream & os) const;
    
    void persistentInput(PersistentIStream & is, int);
    
    static void Init();
    
  protected:
    
    virtual void doinit();
    
    
  protected:
    
    virtual IBPtr clone() const;
    
    virtual IBPtr fullclone() const;
    
  private:
    
    bool unitarized = true;
    bool ransetup = false;
    int theonlymulti = -1;
    int theM = -1;
    int theN = -1;
    map< int, vector<string> > processMap;
      //The matrix elements: int = number of additional jets
    map< int, vector<MatchboxMEBasePtr> > thePureMEsMap;
    MergerPtr theMergingHelper;
    Ptr<Cuts>::ptr theNonQCDCuts;
    
    int theChunk=0;
    int theChunkPart=0;
    
    
    MergingFactory & operator=(const MergingFactory &) = delete;
 
    
  };
  
}
 
#endif /* HERWIG_MergingFactory_H */