StandardEventHandler.h

// -*- C++ -*-
//
// StandardEventHandler.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2007 Leif Lonnblad
//
// ThePEG is licenced under version 2 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 <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;

  virtual CrossSection histogramScale() const;

  virtual CrossSection integratedXSec() const;

  virtual CrossSection integratedXSecErr() const;

  virtual CrossSection dSigDR(const vector<double> & r);

  virtual EventPtr generateEvent();

  virtual EventPtr continueEvent();

  const LorentzRotation & currentEventBoost() const { return theCurrentEventBoost; }

  tCutsPtr cuts() const { return theCuts; }

  int nBins() const;

  int maxDim(int bin) const { return theMaxDims[bin]; }

  bool weighted() const { return weightedEvents; }

  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);

  tCollPtr performCollision();

  virtual void initGroups();

  LorentzRotation & currentEventBoost() { return theCurrentEventBoost; }

  void setScale(Energy2);

  const XVector & xCombs() const { return theXCombs; }

  XVector & xCombs()  { return theXCombs; }

  const XSVector & xSecs() const { return theXSecs; }

  XSVector & xSecs() { return theXSecs; }

  int binStrategy() const { return theBinStrategy; }

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);

  tSamplerPtr sampler() { return theSampler; }

  tcSamplerPtr sampler() const { return theSampler; }

private:

  PDPtr theIncomingA;
  PDPtr theIncomingB;

  SubHandlerList theSubProcesses;

  CutsPtr theCuts;

  XVector theXCombs;

  XSVector theXSecs;

  int theBinStrategy;

  MEXMap theMEXMap;

  vector<int> theMaxDims;

  LorentzRotation theCurrentEventBoost;

  bool weightedEvents;

  SamplerPtr theSampler;

  int theLumiDim;

  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 &);

};

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 */

---