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