Step.h

// -*- C++ -*-
//
// Step.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_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 &);

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

---