SubProcess.h

// -*- C++ -*-
//
// SubProcess.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_SubProcess_H
#define ThePEG_SubProcess_H
// This is the declaration of the SubProcess class.


#include <vector>
#include "ThePEG/EventRecord/Particle.h"

namespace ThePEG {

class SubProcess: public EventRecordBase {

public:

  friend class Step;
  friend class Collision;

public:

  SubProcess(const PPair & newIncoming,
             tCollPtr newCollision = tCollPtr(),
             tcEventBasePtr newHandler = tcEventBasePtr());

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

  SubProPtr clone() const;

  bool decayed() const { return isDecayed; }

  void decayed(bool x) { isDecayed = x; }


protected:

  void rebind(const EventTranslationMap & trans);


public:

  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;

public:

  virtual void debugme() const;

private:

  static ClassDescription<SubProcess> initSubProcess;

  SubProcess() : isDecayed(false) {}

  friend class ClassTraits<SubProcess>;

  SubProcess & operator=(const SubProcess &);

};

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

---