Step.h

// -*- C++ -*-
//
// Step.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_BasicStep_H
#define ThePEG_BasicStep_H
// This is the declaration of the Step class.
 
#include "ThePEG/EventRecord/Particle.h"
#include "ThePEG/EventRecord/StandardSelectors.h"
 
namespace ThePEG {
 
class Step: public EventRecordBase {
 
public:
 
  friend class Collision;
  friend class Event;
 
public:
 
  Step(tCollPtr newCollision = tCollPtr(),
       tcEventBasePtr newHandler = tcEventBasePtr())
    : theCollision(newCollision), theHandler(newHandler) {}
 
  Step(const Step &);
 
  ~Step();
 
  tcEventBasePtr handler() const { return theHandler; }
 
  tCollPtr collision() const { return theCollision; }
 
  template <typename OutputIterator>
  void select(OutputIterator r, const SelectorBase & s) const;
 
  template <typename OutputIterator>
  void selectFinalState(OutputIterator r) const {
    select(r, SelectFinalState());
  }
 
  tPVector getFinalState() const {
    tPVector ret;
    selectFinalState(back_inserter(ret));
    return ret;
  }
 
  template <typename PIterator>
  static vector<tPVector> getSinglets(PIterator first, PIterator last) {
    tParticleSet left(first, last);
    return getSinglets(left);
  }
 
  const ParticleSet & all() const { return allParticles; }
 
  const ParticleSet & particles() const { return theParticles; }
 
  const ParticleSet & intermediates() const { return theIntermediates; }
 
  const SubProcessVector & subProcesses() const {
    return theSubProcesses;
  }
 
  const PPair & incoming() const;
 
  tPPtr find(tcPPtr p) const {
    tPPtr r = const_ptr_cast<tPPtr>(p);
    if ( !member(all(), r) ) return tPPtr();
    return r;
  }
 
 
  tPPtr copyParticle(tcPPtr p);
 
  bool setCopy(tcPPtr pold, tPPtr pnew);
 
  tPPtr insertCopy(tcPPtr p);
 
  bool addDecayProduct(tcPPtr parent, tPPtr child, bool fixColour = true);
 
  template <typename CIterator>
  bool addDecayProduct(tcPPtr parent,
                       CIterator firstChild, CIterator lastChild,
                       bool fixColour = true) {
    for ( ; firstChild != lastChild; ++firstChild )
      if ( !addDecayProduct(parent, *firstChild, fixColour) ) return false;
    return true;
  }
 
  void addDecayNoCheck(tPPtr parent, tPPtr child);
 
  void addDecayProduct(tPPtr child);
 
  bool removeDecayProduct(tcPPtr parent, tPPtr child);
 
  template <typename CIterator>
  bool removeDecayProduct(tcPPtr parent,
                          CIterator firstChild, CIterator lastChild) {
    bool success = true;
    for ( ; firstChild != lastChild; ++firstChild )
      if ( !removeDecayProduct(parent, *firstChild) ) success = false;
    return success;
  }
 
  template <typename Iterator>
  bool addDecayProduct(Iterator firstParent, Iterator lastParent, tPPtr child,
                       bool checkfinal = true);
 
  template <typename PIterator, typename CIterator>
  bool addDecayProduct(PIterator firstParent, PIterator lastParent,
                       CIterator firstChild, CIterator lastChild);
 
  void fixColourFlow();
 
  tPPtr colourNeighbour(tcPPtr particle, bool anti = false) const;
 
  tPPtr antiColourNeighbour(tcPPtr particle) const;
 
  template <typename Iterator>
  void addParticles(Iterator first, Iterator last);
 
  void addParticle(tPPtr p);
 
  template <typename Iterator>
  void addIntermediates(Iterator first, Iterator last);
 
  void addIntermediate(tPPtr p);
 
  void insertIntermediate(tPPtr p, tPPtr parent, tPPtr child);
 
  void addSubProcess(tSubProPtr);
 
  void removeSubProcess(tSubProPtr);
 
  void removeParticle(tPPtr p);
 
  bool nullStep() const;
 
  template <typename Cont>
  tParticleSet getCurrent(const Cont & c) const {
    return getCurrent(c.begin(), c.end());
  }
 
  template <typename Iterator>
  tParticleSet getCurrent(Iterator first, Iterator last) const;
 
  StepPtr clone() const;
 
public:
 
  void persistentOutput(PersistentOStream &) const;
  void persistentInput(PersistentIStream &, int);
 
  static void Init();
 
protected:
 
  static vector<tPVector> getSinglets(tParticleSet &);
 
  void removeEntry(tPPtr p);
 
  void rebind(const EventTranslationMap & trans);
 
  template <typename Inserter, typename PPointer>
  void addIfFinal(Inserter o, PPointer p);
 
private:
 
  Step & operator=(const Step &) = delete;
 
  void collision(tCollPtr c) { theCollision = c; }
 
  void handler(tcEventBasePtr sh) { theHandler = sh; }
 
private:
 
  ParticleSet theParticles;
 
  ParticleSet theIntermediates;
 
  SubProcessVector theSubProcesses;
 
  ParticleSet allParticles;
 
  tCollPtr theCollision;
 
  tcEventBasePtr theHandler;
 
public:
 
  virtual void debugme() const;
 
private:
 
  static ClassDescription<Step> initStep;
 
};
 
ostream & operator<<(ostream &, const Step &);
 
ThePEG_DECLARE_CLASS_TRAITS(Step,EventRecordBase);
}
 
#include "Collision.h"
 
inline const ThePEG::PPair & ThePEG::Step::incoming() const {
  return collision()->incoming(); 
}
 
#ifndef ThePEG_TEMPLATES_IN_CC_FILE
#include "Step.tcc"
#endif
 
#endif /* ThePEG_BasicStep_H */