Event.h

// -*- C++ -*-
//
// Event.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_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"

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

  void printGraphviz() const;

  void weight(double w) { theWeight = w; }

  void setInfo(tcEventBasePtr newHandler, string newName,
               long newNumber, double weight);

  void addCollision(tCollPtr c);

  void primaryCollision(tCollPtr c);

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;

  long theParticleNumber;

public:

  virtual void debugme() const;

private:

  static ClassDescription<Event> initEvent;

  Event() : theNumber(-1), theWeight(1.0), theParticleNumber(0) {}

  friend class ClassTraits<Event>;

  Event & operator=(const Event&);

};

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

---