EventGenerator.h

// -*- C++ -*-
//
// EventGenerator.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_EventGenerator_H
#define ThePEG_EventGenerator_H
// This is the declaration of the EventGenerator class.
 
#include "ThePEG/Config/ThePEG.h"
#include "ThePEG/Utilities/Named.h"
#include "EventGenerator.fh"
#include "RandomGenerator.h"
#include "ThePEG/Repository/UseRandom.h"
#include "ThePEG/Repository/Strategy.h"
#include "ThePEG/Repository/CurrentGenerator.fh"
#include "ThePEG/Utilities/ClassDescription.h"
#include "ThePEG/Handlers/EventHandler.fh"
#include "ThePEG/Analysis/FactoryBase.fh"
#include <fstream>
#include "EventGenerator.xh"
 
namespace ThePEG {
 
class EventGenerator: public Interfaced {
 
  friend class Repository;
 
public:
 
  //typedef map<const type_info *, int> ExceptionMap;
  //typedef map<Exception, int, ExceptionComparison > ExceptionMap;
  typedef map<pair<string, Exception::Severity>, int> ExceptionMap;
 
public:
 
  EventGenerator();
 
  EventGenerator(const EventGenerator &);
 
  virtual ~EventGenerator();
 
public:
 
  tSMPtr standardModel() const { return theStandardModel; }
 
  tStrategyPtr strategy() const { return theStrategy; }
 
  tEHPtr currentEventHandler() const { return theCurrentEventHandler; }
 
  void currentEventHandler(tEHPtr eh) { theCurrentEventHandler = eh; }
 
  tStepHdlPtr currentStepHandler() const { return theCurrentStepHandler; }
 
  void currentStepHandler(tStepHdlPtr sh) { theCurrentStepHandler = sh; }
 
  tEHPtr eventHandler() const { return theEventHandler; }
 
  AnalysisVector & analysisHandlers() { return theAnalysisHandlers; }
 
  tHistFacPtr histogramFactory() const { return theHistogramFactory; }
 
  tEvtManipPtr manipulator() const { return theEventManipulator; }
 
public:
 
  void initialize(bool initOnly = false);
 
  void go(long next = 1, long maxevent = -1, bool tics = false);
 
  EventPtr shoot();
 
  EventPtr generateEvent(Event & event);
 
  EventPtr generateEvent(Step & step);
 
  void finalize();
 
  bool loadMain(string file);
 
  virtual Energy maximumCMEnergy() const;
 
  long currentEventNumber() const { return ieve; }
 
  tcEventPtr currentEvent() const;
 
  virtual void dump() const;
 
  void use(const Interfaced & i);
 
  void setSeed(long seed);
 
  void logWarning(const Exception &);
 
  long N() const { return theNumberOfEvents; }
 
  CrossSection histogramScale() const;
 
  CrossSection integratedXSec() const;
 
  CrossSection integratedXSecErr() const;
 
  double sumWeights() const { return weightSum; }
 
  string filename() const { return path() + "/" + runName(); }
 
  string runName() const { return theRunName.size()? theRunName: name(); }
 
  string path() const { return thePath; }
 
  bool useStdOut() const { return useStdout; }
 
  void openOutputFiles();
 
  void flushOutputFile();
 
  void closeOutputFiles();
 
  ofstream & outfile() { return theOutfile; }
 
  ofstream & logfile() { return theLogfile; }
 
  ofstream & reffile() { return theReffile; }
 
  ostream & out();
 
  ostream & log();
 
  ostream & misc() {
    return theMiscStream;
  }
 
  ostream & ref();
 
  const ObjectSet & objects() const { return theObjects; }
 
 
  const ObjectMap & objectMap() const { return theObjectMap; }
 
  template <typename T>
  typename Ptr<T>::pointer getPtr(const T &) const;
 
  IBPtr getPointer(string name) const;
 
  template <typename T>
  typename Ptr<T>::pointer getObject(string name) const {
    return dynamic_ptr_cast<typename Ptr<T>::pointer>(getPointer(name));
  }
 
  template <typename T>
  typename Ptr<T>::pointer getDefault() const;
 
  PPtr getParticle(PID id) const;
 
  PDPtr getParticleData(PID id) const;
 
  const MatcherSet & matchers() const { return theMatchers; }
 
  const ParticleMap & particles() const { return theParticles; }
 
  const ObjectSet & used() const { return usedObjects; }
 
protected:
 
  void checkSignalState();
 
  RandomGenerator & random() const { return *theRandom; }
 
  void setup(string newRunName, ObjectSet & newObjects,
             ParticleMap & newParticles, MatcherSet & newMatchers);
 
  virtual void doGo(long next, long maxevent, bool tics);
 
  virtual void doInitialize(bool initOnly = false);
 
  virtual EventPtr doShoot();
 
  void tic(long currev = 0, long totev = 0) const;
 
  virtual EventPtr doGenerateEvent(tEventPtr);
 
  virtual EventPtr doGenerateEvent(tStepPtr);
 
  void printException(const Exception &);
 
  bool logException(const Exception &, tcEventPtr);
 
  void N(long n) { theNumberOfEvents = n; }
 
  void runName(string f) { theRunName = f; }
 
public:
 
  virtual void addTag(string tag) {
    runName(runName() + tag);
  }
 
private:
 
  const vector<IPtr> & defaultObjects() const { return theDefaultObjects; }
 
  ParticleMap & localParticles() { return theLocalParticles; }
 
  const ParticleMap & localParticles() const { return theLocalParticles; }
 
  void path(string f) { thePath = f; }
 
  void strategy(StrategyPtr);
 
  string doSaveRun(string);
 
  string doMakeRun(string);
 
public:
 
  bool preinitRegister(IPtr obj, string fullname);
 
  IPtr preinitCreate(string classname, string fullname, string libraries = "");
 
 
  string preinitInterface(string fullname, string ifcname, string cmd,
                          string value);
 
  string preinitInterface(string fullname, string ifcname, int index,
                          string cmd, string value);
 
  string preinitInterface(IPtr obj, string ifcname, string cmd, string value);
 
  string preinitInterface(IPtr obj, string ifcname, int index,
                          string cmd, string value);
 
  bool preinitRemove(IPtr obj);
 
  tDMPtr findDecayMode(string tag) const;
 
  tDMPtr preinitCreateDecayMode(string tag);
 
  tPDPtr findParticle(string pdgname) const;
 
  tPMPtr findMatcher(string name) const;
 
private:
 
  DMPtr constructDecayMode(string & tag);
 
 
public:
 
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
 
  const vector<string> & globalLibraries() const {
    return theGlobalLibraries;
  }
 
 
  static void Init();
 
protected:
 
  virtual IBPtr clone() const;
 
  virtual IBPtr fullclone() const;
 
protected:
 
  virtual void doinit();
 
  virtual void doinitrun();
 
  virtual void dofinish();
 
  void finally();
 
 
  ObjectSet & objects() { return theObjects; }
 
  ObjectMap & objectMap() { return theObjectMap; }
 
  void generateReferences();
 
  int count(const Exception &);
 
private:
 
 
  vector<IPtr> theDefaultObjects;
 
  ParticleMap theLocalParticles;
 
  SMPtr theStandardModel;
 
  StrategyPtr theStrategy;
 
  RanGenPtr theRandom;
 
  EHPtr theEventHandler;
 
  AnalysisVector theAnalysisHandlers;
 
  HistFacPtr theHistogramFactory;
 
  EvtManipPtr theEventManipulator;
 
  string thePath;
 
  string theRunName;
 
  ofstream theOutfile;
 
  ofstream theLogfile;
 
  ofstream theReffile;
 
  ostringstream theMiscStream;
 
  ostringstream theOutStream;
 
  string theOutFileName;
 
  long theNumberOfEvents;
 
  ObjectSet theObjects;
 
  ObjectMap theObjectMap;
 
  ParticleMap theParticles;
  PDVector theQuickParticles;
 
  long theQuickSize;
 
  bool preinitializing;
 
  MatcherSet theMatchers;
 
  ObjectSet usedObjects;
 
protected:
 
  long ieve;
 
  double weightSum;
 
  int theDebugLevel;
 
private:
 
  int logNonDefault;
 
  int printEvent;
 
  long dumpPeriod;
 
  bool keepAllDumps;
 
  long debugEvent;
 
  int maxWarnings;
 
  int maxErrors;
 
  ExceptionMap theExceptions;
 
private:
 
  void setLocalParticles(PDPtr pd, int);
 
  void insLocalParticles(PDPtr pd, int);
 
  void delLocalParticles(int place);
 
  vector<PDPtr> getLocalParticles() const;
 
  void setPath(string newPath);
 
  string defPath() const;
 
  UseRandom * theCurrentRandom;
 
  CurrentGenerator * theCurrentGenerator;
 
  tEHPtr theCurrentEventHandler;
 
  tStepHdlPtr theCurrentStepHandler;
 
 
  bool useStdout;
 
  bool theIntermediateOutput;
 
  vector<string> theGlobalLibraries;
 
private:
 
  static ClassDescription<EventGenerator> initEventGenerator;
 
  EventGenerator & operator=(const EventGenerator &) = delete;
 
};
 
template <>
struct BaseClassTrait<EventGenerator,1>: public ClassTraitsType {
  typedef Interfaced NthBase;
};
 
template <>
struct ClassTraits<EventGenerator>: public ClassTraitsBase<EventGenerator> {
  static string className() { return "ThePEG::EventGenerator"; }
};
 
}
 
#ifndef ThePEG_TEMPLATES_IN_CC_FILE
#include "EventGenerator.tcc"
#endif
 
#endif /* ThePEG_EventGenerator_H */