Event.h

// -*- C++ -*-
//
// Event.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_Event_H
#define ThePEG_Event_H
// This is the decalaration of the Event class.
 
#include "Particle.h"
#include "StandardSelectors.h"
#include "SubProcess.h"
#include "ThePEG/Utilities/Named.h"
#include "ThePEG/Utilities/AnyReference.h"
 
namespace ThePEG {
 
class Event : public EventRecordBase, public Named {
 
public:
 
  friend class EventHandler;
  friend class Collision;
 
  typedef map<tcColinePtr, int> ColourLineMap;
 
public:
 
  Event(const PPair & newIncoming, tcEventBasePtr newHandler = tcEventBasePtr(),
        string newName = "", long newNumber = -1, double weight = 1.0);
 
  Event(const Event&);
 
  ~Event();
 
  EventPtr clone() const;
 
public:
 
  tcEventBasePtr handler() const { return theHandler; }
 
  template <class OutputIterator>
  void select(OutputIterator r, const SelectorBase & s) const;
 
  template <class OutputIterator>
  void selectFinalState(OutputIterator r) const {
    select(r, SelectFinalState());
  }
 
  template <class Container>
  void getFinalState(Container & c) const {
    selectFinalState(inserter(c));
  }
 
  tPVector getFinalState() const {
    tPVector ret;
    selectFinalState(back_inserter(ret));
    return ret;
  }
 
  tCollPtr primaryCollision() const {
    return collisions().empty() ? tCollPtr() : tCollPtr(collisions()[0]);
  }
 
  const CollisionVector & collisions() const { return theCollisions; }
 
  tSubProPtr primarySubProcess() const;
 
  const PPair & incoming() const { return theIncoming; }
 
 
  tCollPtr newCollision();
 
  tStepPtr newStep();
 
  void transform(const LorentzRotation &);
 
  long number() const { return theNumber; }
 
  int colourLineIndex(tcColinePtr) const;
 
  void removeDecay(tPPtr);
 
  void removeParticle(tPPtr);
 
  void cleanSteps();
 
 
  double weight() const { return theWeight; }
 
  double optionalWeight(const string& name) const;
 
  const map<string,double>& optionalWeights() const { return theOptionalWeights; }
 
  void printGraphviz() const;
 
  void weight(double w) { theWeight = w; }
 
  void optionalWeight(const string& name, double value);
 
  map<string,double>& optionalWeights() { return theOptionalWeights; }
 
  void setInfo(tcEventBasePtr newHandler, string newName,
               long newNumber, double weight);
 
  void addCollision(tCollPtr c);
 
  void primaryCollision(tCollPtr c);
 
public:
 
  bool hasMeta(const string& id) const {
    return theMeta.find(id) != theMeta.end();
  }
 
  template<class T>
  void meta(const string& id, T& ref) {
    theMeta[id] = AnyReference(ref);
  }
 
  void eraseMeta(const string& id) {
    theMeta.erase(id);
  }
 
  template<class T>
  T& meta(const string& id) const {
    return theMeta.find(id)->second.cast<T>();
  }
 
protected:
 
  template <class Iterator>
  void addParticles(Iterator first, Iterator last) {
    while ( first != last ) addParticle(*first++);
  }
 
  void addParticle(tPPtr p);
 
  void addSubProcess(tSubProPtr p) {
    if ( p ) allSubProcesses.insert(p);
  }
 
  void removeSubProcess(tSubProPtr p) { allSubProcesses.erase(p); }
 
  void addStep(tStepPtr s) { 
    if ( s ) allSteps.insert(s); 
  }
 
  void removeEntry(tPPtr p);
 
  void rebind(const EventTranslationMap & trans);
 
public:
 
  void persistentOutput(PersistentOStream &) const;
 
  void persistentInput(PersistentIStream &, int);
 
  static void Init();
 
private:
 
  PPair theIncoming;
 
  CollisionVector theCollisions;
 
  StepSet allSteps;
 
  SubProcessSet allSubProcesses;
 
  ParticleSet allParticles;
 
  tcEventBasePtr theHandler;
 
  mutable ColourLineMap theColourLines;
 
  long theNumber;
 
  double theWeight;
 
  map<string,double> theOptionalWeights;
 
  long theParticleNumber;
 
  map<string,AnyReference> theMeta;
 
public:
 
  virtual void debugme() const;
 
private:
 
  static ClassDescription<Event> initEvent;
 
  Event() : theNumber(-1), theWeight(1.0), theParticleNumber(0) {}
 
  friend struct ClassTraits<Event>;
 
  Event & operator=(const Event&) = delete;
 
};
 
ostream & operator<<(ostream &, const Event &);
 
void printGraphviz(ostream &, tcEventPtr);
 
template <>
struct BaseClassTrait<Event,1>: public ClassTraitsType {
  typedef EventRecordBase NthBase;
};
 
template <>
struct ClassTraits<Event>: public ClassTraitsBase<Event> {
  static string className() { return "ThePEG::Event"; }
  static TPtr create() { return TPtr::Create(Event()); }
};
 
}
 
#include "Collision.h"
 
inline ThePEG::tSubProPtr ThePEG::Event::primarySubProcess() const {
  return collisions().empty() ? ThePEG::tSubProPtr() :
    ThePEG::tSubProPtr(primaryCollision()->primarySubProcess());
}
 
namespace ThePEG {
  template <class OutputIterator>
  void Event::select(OutputIterator r, const SelectorBase & s) const {
    if ( s.allCollisions() ) {
      for ( CollisionVector::const_iterator it = theCollisions.begin();
            it != theCollisions.end(); ++it ) (**it).select(r, s);
    } else {
      primaryCollision()->select(r, s);
    }
  }
}
 
#endif /* ThePEG_Event_H */