MatchboxFactory.h

// -*- C++ -*-
//
// MatchboxFactory.h is a part of Herwig - A multi-purpose Monte Carlo event generator
// Copyright (C) 2002-2019 The Herwig Collaboration
//
// Herwig is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef HERWIG_MatchboxFactory_H
#define HERWIG_MatchboxFactory_H
//
// This is the declaration of the MatchboxFactory class.
//
 
#include "ThePEG/Handlers/SubProcessHandler.h"
 
#include "Herwig/MatrixElement/Matchbox/Base/MatchboxAmplitude.h"
#include "Herwig/MatrixElement/Matchbox/Utility/Tree2toNGenerator.h"
#include "Herwig/MatrixElement/Matchbox/Utility/ProcessData.h"
#include "Herwig/MatrixElement/Matchbox/Utility/MatchboxScaleChoice.h"
#include "Herwig/MatrixElement/Matchbox/Phasespace/MatchboxPhasespace.h"
#include "Herwig/MatrixElement/Matchbox/Base/MatchboxMEBase.h"
#include "Herwig/MatrixElement/Matchbox/Base/SubtractedME.h"
#include "Herwig/MatrixElement/Matchbox/MatchboxFactory.fh"
 
namespace Herwig {
 
using namespace ThePEG;
 
class MatchboxFactory: public SubProcessHandler {
 
public:
 
  MatchboxFactory();
 
public:
 
  static const Ptr<MatchboxFactory>::tptr currentFactory() {
    assert(theCurrentFactory);
    return theCurrentFactory;
  }
 
private:
 
  static Ptr<MatchboxFactory>::tptr theCurrentFactory;
 
public:
 
  static bool isMatchboxRun() {
    return theIsMatchboxRun();
  }
 
 
  Ptr<Tree2toNGenerator>::tptr diagramGenerator() const { return theDiagramGenerator; }
 
  void diagramGenerator(Ptr<Tree2toNGenerator>::ptr dg) { theDiagramGenerator = dg; }
 
  Ptr<ProcessData>::tptr processData() const { return theProcessData; }
 
  void processData(Ptr<ProcessData>::ptr pd) { theProcessData = pd; }
 
  unsigned int nLight() const { return theNLight; }
 
  void nLight(unsigned int n) { theNLight = n; }
 
  vector<long> nLightJetVec() const { return theNLightJetVec; }
 
  void nLightJetVec(long n) { theNLightJetVec.push_back(n); }
 
  vector<long> nHeavyJetVec() const { return theNHeavyJetVec; }
 
  void nHeavyJetVec(long n) { theNHeavyJetVec.push_back(n); }
 
  vector<long> nLightProtonVec() const { return theNLightProtonVec; }
 
  void nLightProtonVec(long n) { theNLightProtonVec.push_back(n); }
 
  unsigned int orderInAlphaS() const { return theOrderInAlphaS; }
 
  void orderInAlphaS(unsigned int o) { theOrderInAlphaS = o; }
 
  unsigned int orderInAlphaEW() const { return theOrderInAlphaEW; }
 
  void orderInAlphaEW(unsigned int o) { theOrderInAlphaEW = o; }
 
  size_t highestVirt() const {return theHighestVirtualSize;}
 
  void setHighestVirt(size_t n){theHighestVirtualSize=n;}
 
   const vector<vector<string> > getProcesses() const {return processes;}
 
  bool allProcesses() const { return theAllProcesses; }
 
  void setAllProcesses(bool on = true) { theAllProcesses = on; }
 
  bool bornContributions() const { return theBornContributions; }
 
  void setBornContributions(bool on = true) { theBornContributions = on; }
 
  bool virtualContributions() const { return theVirtualContributions; }
 
  void setVirtualContributions(bool on = true) { theVirtualContributions = on; }
 
  bool meCorrectionsOnly() const { return theMECorrectionsOnly; }
 
  void setMECorrectionsOnly(bool on = true) { theMECorrectionsOnly = on; }
 
  bool loopSimCorrections() const { return theLoopSimCorrections; }
 
  void setLoopSimCorrections(bool on = true) { theLoopSimCorrections = on; }
 
  bool realContributions() const { return theRealContributions; }
 
  void setRealContributions(bool on = true) { theRealContributions = on; }
 
  bool independentVirtuals() const { return theIndependentVirtuals; }
 
  void setIndependentVirtuals(bool on = true) { theIndependentVirtuals = on; }
 
  bool independentPKs() const { return theIndependentPKs; }
 
  void setIndependentPKs(bool on = true) { theIndependentPKs = on; }
 
  virtual bool subProcessGroups() const { return !showerApproximation(); }
 
  bool realEmissionScales() const { return theRealEmissionScales; }
 
  void setRealEmissionScales(bool on = true) { theRealEmissionScales = on; }
 
  void showerApproximation(Ptr<ShowerApproximation>::tptr app) { theShowerApproximation = app; }
 
  Ptr<ShowerApproximation>::tptr showerApproximation() const { return theShowerApproximation; }
 
 
 
  Ptr<MatchboxPhasespace>::tptr phasespace() const { return thePhasespace; }
 
  void phasespace(Ptr<MatchboxPhasespace>::ptr ps) { thePhasespace = ps; }
 
  void scaleChoice(Ptr<MatchboxScaleChoice>::ptr sc) { theScaleChoice = sc; }
 
  Ptr<MatchboxScaleChoice>::tptr scaleChoice() const { return theScaleChoice; }
 
  double factorizationScaleFactor() const { return theFactorizationScaleFactor; }
 
  void factorizationScaleFactor(double f) { theFactorizationScaleFactor = f; }
 
  double renormalizationScaleFactor() const { return theRenormalizationScaleFactor; }
 
  void renormalizationScaleFactor(double f) { theRenormalizationScaleFactor = f; }
 
  bool fixedCouplings() const { return theFixedCouplings; }
 
  void setFixedCouplings(bool on = true) { theFixedCouplings = on; }
 
  bool fixedQEDCouplings() const { return theFixedQEDCouplings; }
 
  void setFixedQEDCouplings(bool on = true) { theFixedQEDCouplings = on; }
 
  bool vetoScales() const { return theVetoScales; }
 
  void doVetoScales() { theVetoScales = true; }
 
  void noVetoScales() { theVetoScales = true; }
 
 
 
  const vector<Ptr<MatchboxAmplitude>::ptr>& amplitudes() const { return theAmplitudes; }
 
  vector<Ptr<MatchboxAmplitude>::ptr>& amplitudes() { return theAmplitudes; }
 
 
 
  const vector<Ptr<MatchboxMEBase>::ptr>& bornMEs() const { return theBornMEs; }
 
  vector<Ptr<MatchboxMEBase>::ptr>& bornMEs() { return theBornMEs; }
 
  const vector<Ptr<MatchboxMEBase>::ptr>& loopInducedMEs() const { return theLoopInducedMEs; }
 
  vector<Ptr<MatchboxMEBase>::ptr>& loopInducedMEs() { return theLoopInducedMEs; }
 
  const map<Ptr<MatchboxAmplitude>::tptr,
            map<pair<Process,int>,int> >&
  olpProcesses() const { return theOLPProcesses; }
 
  map<Ptr<MatchboxAmplitude>::tptr,
      map<pair<Process,int>,int> >& 
  olpProcesses() { return theOLPProcesses; }
 
  int orderOLPProcess(const Process& p,
                      Ptr<MatchboxAmplitude>::tptr amp,
                      int type);
 
  const set<Ptr<MatchboxAmplitude>::tptr>& externalAmplitudes() const {
    return theExternalAmplitudes;
  }
 
  set<Ptr<MatchboxAmplitude>::tptr>& externalAmplitudes() {
    return theExternalAmplitudes;
  }
 
  const vector<Ptr<MatchboxInsertionOperator>::ptr>& virtuals() const { return theVirtuals; }
 
  vector<Ptr<MatchboxInsertionOperator>::ptr>& virtuals() { return theVirtuals; }
 
  const vector<Ptr<MatchboxMEBase>::ptr>& bornVirtualMEs() const { return theBornVirtualMEs; }
 
  vector<Ptr<MatchboxMEBase>::ptr>& bornVirtualMEs() { return theBornVirtualMEs; }
 
  const vector<Ptr<MatchboxMEBase>::ptr>& realEmissionMEs() const { return theRealEmissionMEs; }
 
  vector<Ptr<MatchboxMEBase>::ptr>& realEmissionMEs() { return theRealEmissionMEs; }
 
  int dipoleSet() const { return theDipoleSet; }
 
  void dipoleSet(int s) { theDipoleSet = s; }
 
  const vector<Ptr<SubtractedME>::ptr>& subtractedMEs() const { return theSubtractedMEs; }
 
  vector<Ptr<SubtractedME>::ptr>& subtractedMEs() { return theSubtractedMEs; }
 
  const vector<Ptr<MatchboxMEBase>::ptr>& finiteRealMEs() const { return theFiniteRealMEs; }
 
  vector<Ptr<MatchboxMEBase>::ptr>& finiteRealMEs() { return theFiniteRealMEs; }
 
  const map<cPDVector,set<Ptr<SubtractionDipole>::ptr> >& splittingDipoles() const {
    return theSplittingDipoles;
  }
 
  struct SplittingChannel {
 
    StdXCombPtr bornXComb;
 
    StdXCombPtr realXComb;
 
    vector<StdXCombPtr> tildeXCombs;
 
    Ptr<SubtractionDipole>::ptr dipole;
 
    void print(ostream&) const;
 
  };
 
  list<SplittingChannel> getSplittingChannels(tStdXCombPtr xc) const;
 
  const vector<ReweightPtr>& reweighters() const { return theReweighters; }
 
  vector<ReweightPtr>& reweighters() { return theReweighters; }
 
  const vector<ReweightPtr>& preweighters() const { return thePreweighters; }
 
  vector<ReweightPtr>& preweighters() { return thePreweighters; }
 
 
 
  virtual bool preInitialize() const { return true; }
 
  void prepareME(Ptr<MatchboxMEBase>::ptr);
 
  virtual void productionMode();
 
  virtual void setup();
  
  size_t highestVirt(){return theHighestVirtualsize;}
 
 
 
  bool verbose() const { return theVerbose; }
 
  void setVerbose(bool on = true) { theVerbose = on; }
  
  bool initVerbose() const { return theInitVerbose || verbose(); }
 
  void setInitVerbose(bool on = true) { theInitVerbose = on; }
 
  void print(ostream&) const;
 
  const string& subtractionData() const { return theSubtractionData; }
 
  void subtractionData(const string& s) { theSubtractionData = s; }
 
  const int& subtractionPlotType() const { return theSubtractionPlotType; }
 
  void subtractionPlotType(const int& t) { theSubtractionPlotType = t; }
  
  const bool& subtractionScatterPlot() const { return theSubtractionScatterPlot; }
  
  void subtractionScatterPlot(const bool& s) { theSubtractionScatterPlot = s; }
  
  const string& poleData() const { return thePoleData; }
 
  void poleData(const string& s) { thePoleData = s; }
 
  bool checkPoles() const { return poleData() != ""; }
 
 
 
  const map<string,PDVector>& particleGroups() const { return theParticleGroups; }
 
  map<string,PDVector>& particleGroups() { return theParticleGroups; }
 
  bool isIncoming(cPDPtr p) const {
    return theIncoming.find(p->id()) != theIncoming.end();
  }
 
  bool spinCorrelations() const { return theSpinCorrelations; }
 
  void setSpinCorrelations(bool yes) { theSpinCorrelations = yes; }
 
 
 
  tSubProPtr hardTreeSubprocess() { return theHardtreeSubprocess; }
 
  void setHardTreeSubprocess(tSubProPtr hardTree) { theHardtreeSubprocess = hardTree; }
 
  int hardTreeEmitter() { return theHardtreeEmitter; }
 
  void setHardTreeEmitter(int emitter) { theHardtreeEmitter = emitter; }
 
  int hardTreeSpectator() { return theHardtreeSpectator; }
 
  void setHardTreeSpectator(int spectator) { theHardtreeSpectator = spectator; }
 
 
  const string& buildStorage();
 
  const string& runStorage();
  
  double alphaParameter() const { return theAlphaParameter; }
  
  void setAlphaParameter(double a)const { theAlphaParameter = a; }
  
 
public:
 
  void summary(ostream&) const;
 
public:
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
 
  static void Init();
 
protected:
 
  virtual IBPtr clone() const;
 
  virtual IBPtr fullclone() const;
 
protected:
 
  virtual void doinit();
 
  virtual void doinitrun();
 
private:
 
  static bool& theIsMatchboxRun();
 
  Ptr<Tree2toNGenerator>::ptr theDiagramGenerator;
 
  Ptr<ProcessData>::ptr theProcessData;
 
  unsigned int theNLight;
 
  vector<long> theNLightJetVec;
 
  vector<long> theNHeavyJetVec;
 
  vector<long> theNLightProtonVec;
 
  unsigned int theOrderInAlphaS;
 
  unsigned int theOrderInAlphaEW;
 
  unsigned int theHighestVirtualSize;
 
  bool theBornContributions;
 
  bool theVirtualContributions;
 
  bool theRealContributions;
 
  bool theIndependentVirtuals;
 
  bool theIndependentPKs;
 
  Ptr<MatchboxPhasespace>::ptr thePhasespace;
 
  Ptr<MatchboxScaleChoice>::ptr theScaleChoice;
 
  double theFactorizationScaleFactor;
 
  double theRenormalizationScaleFactor;
 
  bool theFixedCouplings;
 
  bool theFixedQEDCouplings;
 
  bool theVetoScales;
 
  vector<Ptr<MatchboxAmplitude>::ptr> theAmplitudes;
 
  vector<Ptr<MatchboxMEBase>::ptr> theBornMEs;
 
  vector<Ptr<MatchboxMEBase>::ptr> theLoopInducedMEs;
 
  vector<Ptr<MatchboxInsertionOperator>::ptr> theVirtuals;
 
  vector<Ptr<MatchboxMEBase>::ptr> theRealEmissionMEs;
 
  vector<Ptr<MatchboxMEBase>::ptr> theBornVirtualMEs;
 
  vector<Ptr<SubtractedME>::ptr> theSubtractedMEs;
 
  vector<Ptr<MatchboxMEBase>::ptr> theFiniteRealMEs;
 
  int theDipoleSet;
 
  bool theVerbose;
  
  bool theInitVerbose;
 
  string theSubtractionData;
 
  int theSubtractionPlotType;
  
  bool theSubtractionScatterPlot;
  
  string thePoleData;
 
  string doSingleRealProcess(string);
 
  vector<vector<string> > realEmissionProcesses;
 
  map<string,PDVector> theParticleGroups;
 
  string startParticleGroup(string);
 
  string particleGroupName;
 
  PDVector particleGroup;
 
  string endParticleGroup(string);
 
protected:
  
  virtual vector<string> parseProcess(string);
 
private:
  
  string doProcess(string);
 
  string doLoopInducedProcess(string);
 
  vector<vector<string> > processes;
 
  vector<vector<string> > loopInducedProcesses;
 
  set<PDVector> makeSubProcesses(const vector<string>&) const;
 
 
public: 
  
  vector<Ptr<MatchboxMEBase>::ptr> makeMEs(const vector<string>&, 
                                           unsigned int orderas,
                                           bool virt);
 
  
private:
  Ptr<ShowerApproximation>::ptr theShowerApproximation;
 
  map<cPDVector,set<Ptr<SubtractionDipole>::ptr> > theSplittingDipoles;
 
  bool theRealEmissionScales;
 
  bool theAllProcesses;
 
  map<Ptr<MatchboxAmplitude>::tptr,map<pair<Process,int>,int> > theOLPProcesses;
 
  set<Ptr<MatchboxAmplitude>::tptr> theExternalAmplitudes;
 
  vector<Ptr<MatchboxAmplitude>::ptr> theSelectedAmplitudes;
 
  vector<Ptr<MatchboxAmplitude>::ptr> theDeselectedAmplitudes;
 
  vector<ReweightPtr> theReweighters;
 
  vector<ReweightPtr> thePreweighters;
 
  bool theMECorrectionsOnly;
 
  int theHighestVirtualsize;
 
  bool theLoopSimCorrections;
 
  bool ranSetup;
 
  set<long> theIncoming;
 
  bool theFirstPerturbativePDF;
 
  bool theSecondPerturbativePDF;
 
  bool inProductionMode;
 
  tSubProPtr theHardtreeSubprocess;
 
  int theHardtreeEmitter;
 
  int theHardtreeSpectator;
 
  bool theSpinCorrelations;
 
  mutable double theAlphaParameter;
 
  bool theEnforceChargeConservation;
 
  bool theEnforceColourConservation;
 
  bool theEnforceLeptonNumberConservation;
 
  bool theEnforceQuarkNumberConservation;
 
  bool theLeptonFlavourDiagonal;
 
  bool theQuarkFlavourDiagonal;
 
  string doProductionMode(string) {
    productionMode(); return "";
  }
 
private:
 
  MatchboxFactory & operator=(const MatchboxFactory &) = delete;
 
};
 
}
 
#endif /* HERWIG_MatchboxFactory_H */