SubProcess.h

// -*- C++ -*-
//
// SubProcess.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2019 Leif Lonnblad
// Copyright (C) 2009-2019 Simon Platzer
//
// 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_SubProcess_H
#define ThePEG_SubProcess_H
// This is the declaration of the SubProcess class.
 
 
#include <vector>
#include "ThePEG/EventRecord/Particle.h"
 
namespace ThePEG {
 
  class SubProcessGroup;
 
class SubProcess: public EventRecordBase {
 
public:
 
  friend class Step;
  friend class Collision;
  friend class SubProcessGroup;
 
public:
 
  SubProcess(const PPair & newIncoming,
             tCollPtr newCollision = tCollPtr(),
             tcEventBasePtr newHandler = tcEventBasePtr(),
             tSubProPtr newHead = tSubProPtr(),
             double newGroupWeight = 1.0);
 
  virtual ~SubProcess();
 
  tcEventBasePtr handler() const { return theHandler; }
 
  tCollPtr collision() const { return theCollision; }
 
  const PPair & incoming() const { return theIncoming; }
 
  const ParticleVector & intermediates() const { return theIntermediates; }
 
  const ParticleVector & outgoing() const { return theOutgoing; }
 
  template <class InputIterator>
  void setOutgoing(InputIterator, InputIterator);
 
  void addOutgoing(tPPtr p, bool fixrelations = true);
 
  void changeIncoming(tPPtr pnew, tPPtr pold); 
 
  template <class InputIterator>
  void setIntermediates(InputIterator, InputIterator);
 
  void addIntermediate(tPPtr p, bool fixrelations = true);
 
  void removeEntry(tPPtr p);
 
  virtual SubProPtr clone() const;
 
  bool decayed() const { return isDecayed; }
 
  void decayed(bool x) { isDecayed = x; }
 
  tSubProPtr head() const { return theHead; }
 
  void head(tSubProPtr newHead) { theHead = newHead; }
 
  double groupWeight() const { return theGroupWeight; }
 
  void groupWeight(double w) { theGroupWeight = w; }
 
protected:
 
  virtual void rebind(const EventTranslationMap & trans);
 
 
public:
 
  virtual void transform(const LorentzRotation &);
 
  Energy2 shat() const {
    return (incoming().first->momentum() + incoming().second->momentum()).m2();
  }
 
  Energy2 that() const {
    return (incoming().first->momentum() - outgoing()[0]->momentum()).m2();
  }
 
  Energy2 uhat() const {
    return (incoming().second->momentum() - outgoing()[0]->momentum()).m2();
  }
 
public:
 
  void persistentOutput(PersistentOStream &) const;
 
  void persistentInput(PersistentIStream &, int);
 
  static void Init();
 
private:
 
  tcEventBasePtr theHandler;
 
  tCollPtr theCollision;
 
  PPair theIncoming;
 
  ParticleVector theIntermediates;
 
  ParticleVector theOutgoing;
 
  bool isDecayed;
 
  tSubProPtr theHead;
 
  double theGroupWeight;
 
public:
 
  virtual void debugme() const;
 
  virtual void printMe(ostream&) const;
 
private:
 
  SubProcess() : isDecayed(false), theGroupWeight(1.0) {}
 
  static ClassDescription<SubProcess> initSubProcess;
 
  friend struct ClassTraits<SubProcess>;
 
  SubProcess & operator=(const SubProcess &) = delete;
 
};
 
ostream & operator<<(ostream &, const SubProcess &);
 
 
template <>
struct BaseClassTrait<SubProcess,1>: public ClassTraitsType {
  typedef EventRecordBase NthBase;
};
 
template <>
struct ClassTraits<SubProcess>: public ClassTraitsBase<SubProcess> {
  static string className() { return "ThePEG::SubProcess"; }
  static TPtr create() { return TPtr::Create(SubProcess()); }
};
 
}
 
#ifndef ThePEG_TEMPLATES_IN_CC_FILE
#include "SubProcess.tcc"
#endif
 
#endif /* ThePEG_SubProcess_H */