DecayMode.h

// -*- C++ -*-
//
// DecayMode.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_DecayMode_H
#define ThePEG_DecayMode_H
// This is the declaration of the DecayMode class.

#include "ThePEG/Config/ThePEG.h"
#include "ThePEG/Interface/Interfaced.h"
#include "DecayMode.fh"
#include "MatcherBase.h"
#include "Decayer.h"

namespace ThePEG {

ThePEG_DECLARE_MULTISET(tPDPtr,ParticleMSet);
ThePEG_DECLARE_MULTISET(tPMPtr,MatcherMSet);
ThePEG_DECLARE_MULTISET(tDMPtr,ModeMSet);

class DecayMode: public Interfaced {

public:

  friend class ParticleData;

  friend class RemnantData;

  friend class EventGenerator;

public:

  typedef vector<tcDMPtr> ModeVector;
  typedef vector<tPDPair> LinkVector;

public:

  static DMPtr constructDecayMode(string & tag, vector<DMPtr> * save = 0);

  DecayMode();

  DecayMode(const DecayMode &);

  ~DecayMode();

  virtual DMPtr clone(tPDPtr pd) const;

public:

  const string & tag() const {
    return theTag.size() ? theTag : ( theTag = makeTag() );
  }

  tcPDPtr parent() const { return theParent; }

  const ParticleMSet & products() const { return theProducts; }

  const tPDVector & orderedProducts() const { return theOrderedProducts; }

  PVector produceProducts() const;

  const ModeMSet & cascadeProducts() const { return theCascadeProducts; }

  const MatcherMSet & productMatchers() const { return theMatchers; }

  tPMPtr wildProductMatcher() const { return theWildMatcher; }

  const ParticleMSet & excluded() const { return theExcluded; }

  double brat() const;

  double brat(const Particle &) const;

  tDecayerPtr decayer() const { return theDecayer; }

  bool includes(const DecayMode &) const;

  tDMPtr CC() const { return theAntiPartner; }

  bool operator == (const DecayMode & d) const { 
    return tag() == d.tag() ;
  }

  const LinkVector & links() const { return theLinks; }

  const ModeVector & overlap() const { return theOverlap; }

  void synchronize();

  bool on() const { return isOn; }

public:

  void persistentOutput(PersistentOStream & os) const;

  void persistentInput(PersistentIStream & is, int version);

  static void Init();

protected:

  virtual void doupdate();

  virtual void rebind(const TranslationMap & trans)
   ;

  virtual IVector getReferences();

protected:

  void parent(tPDPtr pd) { theParent = pd; }

  void brat(double);

  void switchOn();

  void switchOff();

  void decayer(tDecayerPtr);

  void addProduct(tPDPtr);

  void addLink(tPDPtr a, tPDPtr b);

  void addCascadeProduct(tDMPtr);

  void addProductMatcher(tPMPtr);

  void setWildMatcher(tPMPtr);

  void addExcluded(tPDPtr);

  static DMPtr Create(tPDPtr newParent, double newBrat = 0.0,
                      bool newOn = false);
  DecayMode(tPDPtr newParticle, double newBrat, bool newOn);

  virtual IBPtr clone() const;

  virtual IBPtr fullclone() const;

  DMPtr dmclone() const;

  virtual void readSetup(istream & is);

  ParticleMSet & products() { return theProducts; }

  ModeMSet & cascadeProducts() { return theCascadeProducts; }

  MatcherMSet & productMatchers() { return theMatchers; }

  tPMPtr & wildProductMatcher() { return theWildMatcher; }

  ParticleMSet & excluded() { return theExcluded; }

private:

  bool addOverlap(tcDMPtr);

  void resetOverlap();

  bool compareId(const ParticleMSet &, const ParticleMSet &) const;

  ParticleMSet::const_iterator findId(const ParticleMSet &,
                                      const ParticleData &) const;
  
  string makeTag() const;

  void resetTag() {
    theTag = "";
    if ( CC() ) CC()->theTag = "";
  }


private:

  void setOn(long);

  long getOn() const;

  void setDecayer(DecayerPtr);

private:

  mutable string theTag;

  double theBrat;

  bool isOn;

  tPDPtr theParent;

  ParticleMSet theProducts;

  tPDVector theOrderedProducts;

  ModeMSet theCascadeProducts;

  MatcherMSet theMatchers;

  tPMPtr theWildMatcher;

  ParticleMSet theExcluded;

  ModeVector theOverlap;

  DecayerPtr theDecayer;

  tDMPtr theAntiPartner;

  LinkVector theLinks;

private:

  static ClassDescription<DecayMode> initDecayMode;

  DecayMode & operator=(const DecayMode &);

};

template <>
struct BaseClassTrait<DecayMode,1>: public ClassTraitsType {
  typedef Interfaced NthBase;
};

template <>
struct ClassTraits<DecayMode>:
    public ClassTraitsBase<DecayMode> {
  static string className() { return "ThePEG::DecayMode"; }
};

}

#endif /* ThePEG_DecayMode_H */

---