DecayMode.h

// -*- C++ -*-
//
// DecayMode.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_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 &);
 
  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; }
 
  void CC(tDMPtr cc) {theAntiPartner = cc;}
 
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 &) = delete;
 
};
 
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 */