EventHandler.h

// -*- C++ -*-
//
// EventHandler.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_EventHandler_H
#define ThePEG_EventHandler_H
// This is the declaration of the EventHandler class.

#include "ThePEG/Handlers/HandlerBase.h"
#include "ThePEG/Handlers/HandlerGroup.h"
#include "ThePEG/Handlers/StepHandler.h"
#include "ThePEG/EventRecord/Event.h"
#include "ThePEG/Handlers/LastXCombInfo.h"
#include "ThePEG/Handlers/SubProcessHandler.fh"
#include "ThePEG/Cuts/Cuts.fh"
#include "EventHandler.fh"

namespace ThePEG {

class EventHandler: public HandlerBase, public LastXCombInfo<> {

public:

  enum ConsistencyLevel {
    clNoCheck,        
    clCollision,      
    clStep,           
    clPrintCollision, 
    clPrintStep       
  };

  typedef vector<HandlerGroupBase *> GroupVector;

public:

  EventHandler(bool warnincomplete = true);

  EventHandler(const EventHandler &);

  virtual ~EventHandler();

public:

  virtual void initialize();

  virtual EventPtr generateEvent();

  tEventPtr generateEvent(tEventPtr e);

  tEventPtr generateEvent(tStepPtr s);

  virtual EventPtr continueEvent();

  tCollPtr continueCollision();

  void clearEvent();

  virtual void select(tXCombPtr newXComb);

  virtual bool empty() const;

  virtual void statistics(ostream &) const;

  virtual CrossSection histogramScale() const;

  virtual CrossSection integratedXSec() const;

  virtual CrossSection integratedXSecErr() const;

  long maxLoop() const { return theMaxLoop; }

  const cPDPair & incoming() const { return theIncoming; }

  const LuminosityFunction & lumiFn() const { return *theLumiFn; }

  tcLumiFnPtr lumiFnPtr() const{ return theLumiFn; }

  tLumiFnPtr lumiFnPtr(){ return theLumiFn; }

  tCutsPtr cuts() const { return theCuts; }

  tPExtrPtr partonExtractor() const { return thePartonExtractor; }

  tCascHdlPtr cascadeHandler() const;

  tCascHdlPtr CKKWHandler() const { return cascadeHandler(); }

  tEventPtr currentEvent() const { return theCurrentEvent; }

  tCollPtr currentCollision() const { return theCurrentCollision; }

  tStepPtr currentStep() const { return theCurrentStep; }

  bool weighted() const { return weightedEvents; }

  int statLevel() const { return theStatLevel; }

  ConsistencyLevel consistencyLevel() const { return theConsistencyLevel; }

  double consistencyEpsilon() const { return theConsistencyEpsilon; }


  void performStep(tStepHdlPtr handler, tHintPtr hint);

  void addStep(Group::Level, Group::Handler,
               tStepHdlPtr = tStepHdlPtr(), tHintPtr = tHintPtr());

  tStepPtr newStep(tcStepHdlPtr sh) {
    currentStep(currentCollision()->newStep(sh));
    return currentStep();
  }

  void popStep() {
    currentCollision()->popStep();
    currentStep(currentCollision()->finalStep());
  }

  virtual void initGroups();

  void currentEvent(tEventPtr e) { theCurrentEvent = e; }

  void currentCollision(tCollPtr c) { theCurrentCollision = c; }

  void currentStep(tStepPtr s) { theCurrentStep = s; }

  tStepHdlPtr currentStepHandler() const { return theCurrentStepHandler; }

  void currentStepHandler(tStepHdlPtr sh) { theCurrentStepHandler = sh; }

  void throwCurrent();

  virtual void clean();

  virtual void checkConsistency() 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;

  virtual void dofinish() {
    clean();
    HandlerBase::dofinish();
  }

  virtual void rebind(const TranslationMap & trans);

  virtual IVector getReferences();


protected:

  LuminosityFunction & lumiFn() { return *theLumiFn; }

  void setupGroups();

  GroupVector & groups() { return theGroups; }

  const GroupVector & groups() const { return theGroups; }


protected:

  void lumiFn(LumiFnPtr);

private:

  long theMaxLoop;

  bool weightedEvents;

  int theStatLevel;

  ConsistencyLevel theConsistencyLevel;

  double theConsistencyEpsilon;

  LumiFnPtr theLumiFn;

  CutsPtr theCuts;

  PExtrPtr thePartonExtractor;

  HandlerGroup<SubProcessHandler> theSubprocessGroup;

  HandlerGroup<CascadeHandler> theCascadeGroup;

  HandlerGroup<MultipleInteractionHandler> theMultiGroup;

  HandlerGroup<HadronizationHandler> theHadronizationGroup;

  HandlerGroup<DecayHandler> theDecayGroup;

  GroupVector theGroups;

  EventPtr theCurrentEvent;

  CollPtr theCurrentCollision;

  StepPtr theCurrentStep;

  StepHdlPtr theCurrentStepHandler;

protected:

  HandlerGroup<SubProcessHandler> optSubprocessGroup;

  HandlerGroup<CascadeHandler> optCascadeGroup;

  HandlerGroup<MultipleInteractionHandler> optMultiGroup;

  HandlerGroup<HadronizationHandler> optHadronizationGroup;

  HandlerGroup<DecayHandler> optDecayGroup;

protected:

  GroupVector optGroups;

protected:

  bool warnIncomplete;

  cPDPair theIncoming;

protected:

  class EventHandlerStepError: public Exception {};

  class EventHandlerHistError: public Exception {};

  class EventHandlerIncompleteError: public Exception {};

  struct EventLoopException: public Exception {
    EventLoopException(const EventHandler &);
  };

  struct LumiFuncError: public Exception {};

  struct ConsistencyException: public Exception {};

private:

  ThePEG_DECLARE_PREPOST_GROUP(SubProcessHandler,Post);
  ThePEG_DECLARE_GROUPINTERFACE(CascadeHandler,CascHdlPtr);
  ThePEG_DECLARE_GROUPINTERFACE(MultipleInteractionHandler,MIHdlPtr);
  ThePEG_DECLARE_GROUPINTERFACE(HadronizationHandler,HadrHdlPtr);
  ThePEG_DECLARE_GROUPINTERFACE(DecayHandler,DecayHdlPtr);

  ThePEG_DECLARE_CLASS_DESCRIPTION(EventHandler);

  EventHandler & operator=(const EventHandler &) = delete;

};

ThePEG_DECLARE_CLASS_TRAITS(EventHandler,HandlerBase);
}

#endif /* ThePEG_EventHandler_H */