StandardEventHandler.h

// -*- C++ -*-
//
// StandardEventHandler.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2019 Leif Lonnblad
//
// ThePEG is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef ThePEG_StandardEventHandler_H
#define ThePEG_StandardEventHandler_H
// This is the declaration of the StandardEventHandler class.
 
#include "ThePEG/Config/ThePEG.h"
#include "ThePEG/Handlers/EventHandler.h"
#include "ThePEG/Repository/Strategy.fh"
#include "ThePEG/Handlers/SamplerBase.fh"
#include "ThePEG/PDF/PartonBin.fh"
#include "ThePEG/MatrixElement/MEBase.fh"
#include "SubProcessHandler.fh"
#include "StandardXComb.fh"
#include "StandardEventHandler.fh"
#include "ThePEG/Utilities/XSecStat.h"
#include <fstream>
 
namespace ThePEG {
 
class StandardEventHandler: public EventHandler {
 
public:
 
  typedef vector<SubHdlPtr> SubHandlerList;
 
  typedef Selector<StdXCombPtr> XSelector;
 
  typedef vector<StdXCombPtr> XVector;
 
  typedef vector<CrossSection> XSVector;
 
  typedef map<tMEPtr,XVector> MEXMap;
 
public:
 
  StandardEventHandler();
 
  virtual ~StandardEventHandler();
 
public:
 
  virtual void initialize();
 
  virtual void statistics(ostream &) const;
 
  tSamplerPtr sampler() { return theSampler; }
 
  tcSamplerPtr sampler() const { return theSampler; }
 
  virtual CrossSection histogramScale() const;
 
  virtual CrossSection integratedXSec() const;
 
  virtual CrossSection integratedXSecErr() const;
 
  virtual CrossSection integratedXSecNoReweight() const;
 
  virtual CrossSection integratedXSecErrNoReweight() const;
 
  virtual CrossSection dSigDR(const vector<double> & r);
 
  virtual EventPtr generateEvent();
 
  virtual EventPtr continueEvent();
 
  void reweight(double factor) const;
 
  const XVector & xCombs() const { return theXCombs; }
 
  virtual void select(tXCombPtr newXComb);
 
  const LorentzRotation & currentEventBoost() const { return theCurrentEventBoost; }
 
  tCutsPtr cuts() const { return theCuts; }
 
  int nBins() const;
 
  int maxDim(int bin) const { return theMaxDims[bin]; }
 
  int lumiDim() const { return theLumiDim; }
 
  int nDim(int bin) const { return lumiDim() + maxDim(bin); }
 
protected:
 
  virtual CrossSection dSigDR(const pair<double,double> ll, Energy2 maxS,
                      int ibin, int nr, const double * r);
 
  tStdXCombPtr select(int bin, double & weight);
 
  void addME(Energy maxEnergy, tSubHdlPtr sub, tPExtrPtr extractor,
             tCutsPtr cuts, tCascHdlPtr ckkw, tMEPtr me, const PBPair & pBins,
             const PartonPairVec& allPBins);
 
  tCollPtr performCollision();
 
  virtual void initGroups();
 
  LorentzRotation & currentEventBoost() { return theCurrentEventBoost; }
 
  void setScale(Energy2);
 
  XVector & xCombs()  { return theXCombs; }
 
  virtual void clean();
 
private:
 
  const SubHandlerList & subProcesses() const { return theSubProcesses; }
 
  SubHandlerList & subProcesses() { return theSubProcesses; }
 
public:
 
  virtual void doupdate();
 
  virtual void doinit();
 
  virtual void doinitrun();
 
  virtual void dofinish();
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
 
  static void Init();
 
protected:
 
  virtual IBPtr clone() const;
 
  virtual IBPtr fullclone() const;
 
  void reject(double weight);
 
private:
 
  PDPtr theIncomingA;
  PDPtr theIncomingB;
 
  SubHandlerList theSubProcesses;
 
  CutsPtr theCuts;
 
  bool collisionCuts;
 
  XVector theXCombs;
 
  vector<int> theMaxDims;
 
  LorentzRotation theCurrentEventBoost;
 
  SamplerPtr theSampler;
 
  int theLumiDim;
 
  mutable XSecStat xSecStats;
 
  static ClassDescription<StandardEventHandler> initStandardEventHandler;
 
  void setIncomingA(PDPtr);
 
  void setIncomingB(PDPtr);
 
protected:
 
  class StandardEventHandlerUpdateException: public UpdateException {};
 
  class StandardEventHandlerInitError: public Exception {};
private:
 
  const StandardEventHandler & operator=(const StandardEventHandler &) = delete;
 
};
 
template <>
struct BaseClassTrait<StandardEventHandler,1>: public ClassTraitsType {
  typedef EventHandler NthBase;
};
 
template <>
struct ClassTraits<StandardEventHandler>
  : public ClassTraitsBase<StandardEventHandler> {
  static string className() { return "ThePEG::StandardEventHandler"; }
};
 
}
 
#endif /* ThePEG_StandardEventHandler_H */