Collision.h

// -*- C++ -*-
//
// Collision.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_Collision_H
#define ThePEG_Collision_H
// This is the decalaration of the Collision class. It

#include "EventConfig.h"
#include "Particle.h"
#include "StandardSelectors.h"
#include "ThePEG/Vectors/LorentzVector.h"
#include "ThePEG/Vectors/LorentzRotation.h"

namespace ThePEG {

class Collision: public EventRecordBase {

public:

  friend class EventHandler;
  friend class Event;
  friend class Step;

public:

  Collision(const PPair & newIncoming, tEventPtr newEvent = tEventPtr(),
            tcEventBasePtr newHandler = tcEventBasePtr()) 
    : theIncoming(newIncoming), theEvent(newEvent), theHandler(newHandler) {
    addParticle(incoming().first);
    addParticle(incoming().second);
  }

  ~Collision();

public:

  tStepPtr newStep(tcEventBasePtr newHandler = tcEventBasePtr());

  void addStep(tStepPtr s);

  tcEventBasePtr handler() const { return theHandler; }

  tEventPtr event() const { return theEvent; }

  template <class OutputIterator>
  void select(OutputIterator r, const SelectorBase & s) const;

  template <class OutputIterator>
  void selectFinalState(OutputIterator r) const {
    select(r, SelectFinalState());
  }

  tPVector getFinalState() const {
    tPVector ret;
    selectFinalState(back_inserter(ret));
    return ret;
  }

  tSubProPtr primarySubProcess() const {
    return subProcesses().empty()? SubProPtr(): subProcesses().front();
  }

  const SubProcessVector & subProcesses() const {
    return theSubProcesses;
  }

  tcStepPtr finalStep() const {
    return steps().empty()? tcStepPtr(): tcStepPtr(steps().back());
  }

  tStepPtr finalStep() {
    return steps().empty()? StepPtr(): steps().back();
  }

  const StepVector & steps() const { return theSteps; }

  tcStepPtr step(unsigned int i) const {
    return i < steps().size()? tcStepPtr(theSteps[i]): tcStepPtr();
  }

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

  tParticleSet getRemnants() const;

  bool isRemnant(tPPtr p) const { return member(getRemnants(), p); }


  const LorentzPoint & vertex() const { return theVertex; }

  void vertex(const LorentzPoint & p) { theVertex = p; }

  void transform(const LorentzRotation &);

  Energy2 m2() const {
    return ( incoming().first->momentum() + incoming().second->momentum() ).m2();
  }

  void removeDecay(tPPtr);

  void removeParticle(tPPtr);

  void cleanSteps();

  void popStep();


public:

  void persistentOutput(PersistentOStream &) const;

  void persistentInput(PersistentIStream &, int);

  static void Init();

protected:

  void addSubProcess(tSubProPtr p);

  void removeSubProcess(tSubProPtr p);

  template <class Iterator>
  void addParticles(Iterator first, Iterator last);

  void addParticle(tPPtr p);

  void removeEntry(tPPtr p);


  const ParticleSet & all() const { return allParticles; }

  CollPtr clone() const;

  void rebind(const EventTranslationMap & trans);

private:

  PPair theIncoming;

  StepVector theSteps;

  SubProcessVector theSubProcesses;

  ParticleSet allParticles;

  tEventPtr theEvent;

  tcEventBasePtr theHandler;

  LorentzPoint theVertex;

private:

  static ClassDescription<Collision> initCollision;

  Collision() {}

  friend class ClassTraits<Collision>;

  Collision & operator=(const Collision &);

  friend ostream & operator<<(ostream & os, const Collision & c);

};

ostream & operator<<(ostream &, const Collision &);


template <>
struct BaseClassTrait<Collision,1>: public ClassTraitsType {
  typedef EventRecordBase NthBase;
};

template <>
struct ClassTraits<Collision>: public ClassTraitsBase<Collision> {
  static string className() { return "ThePEG::Collision"; }
  static TPtr create() { return TPtr::Create(Collision()); }
};

}

#ifndef ThePEG_TEMPLATES_IN_CC_FILE
#include "Collision.tcc"
#endif

#endif /* ThePEG_Collision_H */

---