Collision.h

// -*- C++ -*-
//
// Collision.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_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 struct ClassTraits<Collision>;
 
  Collision & operator=(const Collision &) = delete;
 
  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 */