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