ParticleData.h

// -*- C++ -*-
//
// ParticleData.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_ParticleData_H
#define ThePEG_ParticleData_H
// This is the declaration of the ParticleData class.
 
#include "ThePEG/Config/ThePEG.h"
#include "ThePEG/PDT/PDT.h"
#include "ThePEG/PDT/PID.h"
#include "ThePEG/Vectors/LorentzVector.h"
#include "ThePEG/Vectors/ThreeVector.h"
#include "ThePEG/Interface/Interfaced.h"
#include "ThePEG/Utilities/Selector.h"
#include "ThePEG/PDT/WidthGenerator.h"
#include "ThePEG/PDT/MassGenerator.h"
#include "ThePEG/PDT/DecayMode.fh"
#include "ThePEG/Utilities/ClassTraits.h"
#include "ThePEG/Utilities/ClassDescription.h"
 
namespace ThePEG {
 
class ParticleData: public Interfaced {
 
public:
 
  friend class Repository;
 
  friend class EventGenerator;
 
  friend class DecayMode;
 
  typedef Selector<tDMPtr> DecaySelector;
 
public:
 
  ParticleData();
 
  static PDPtr Create(PID newId, const string & newPDGName);
 
  static PDPair Create(PID newId, const string & newPDGName, const string & newAntiPDGName);
 
public:
 
  long id() const { return theId; }
 
  const string & PDGName() const { return thePDGName; }
 
  const string & genericName() const { return thePDGName; }
 
  PPtr produceParticle(const Lorentz5Momentum &) const;
 
  PPtr produceParticle(const LorentzMomentum &) const;
 
  PPtr produceParticle(const LorentzMomentum &, Energy m) const;
 
  PPtr produceParticle(const Momentum3 & pp = Momentum3()) const;
 
  PPtr produceParticle(Energy m, const Momentum3 & pp = Momentum3()) const;
 
  PPtr produceParticle(Energy plus, Energy minus, Energy px, Energy py) const;
 
  Energy generateMass() const;
 
  Energy generateWidth(Energy mass) const;
 
  Length generateLifeTime(Energy mass, Energy width) const;
  // Given a mass and a width of an instance of this particle type,
  // generate a life time.
 
  const DecaySelector & decaySelector() const { return theDecaySelector; }
 
  tDMPtr selectMode(Particle & p) const;
 
  const DecaySet & decayModes() const { return theDecayModes; }
 
  Energy mass(Energy);
 
  Energy mass() const { return theMass; }
 
  Energy hardProcessMass() const { 
    return 
      hardProcessMassSet ? theHardProcessMass : mass();
  }
 
  Energy massMax() const { return mass() + widthUpCut(); }
 
  Energy massMin() const { return max(mass() - widthLoCut(), ZERO); }
 
  virtual Energy constituentMass() const { return mass(); }
 
  Energy width(Energy);
 
  Energy width() const {
    return theWidth >= ZERO ? theWidth :
      ( theCTau > Length() ? hbarc/theCTau :
        ( theCTau == Length() ? Constants::MaxEnergy : ZERO ) );
  }
 
  Energy widthCut(Energy wci) {
    widthUpCut(wci);
    return widthLoCut(wci);
  }
 
  Energy widthCut() const { return max(widthUpCut(), widthLoCut()); }
 
  Energy widthUpCut(Energy);
 
  Energy widthUpCut() const {
    return theWidthUpCut >= ZERO? theWidthUpCut: Constants::MaxEnergy;
  }
 
  Energy widthLoCut(Energy);
 
  Energy widthLoCut() const {
    return theWidthLoCut >= ZERO? theWidthLoCut: Constants::MaxEnergy;
  }
 
  Length cTau(Length);
 
  Length cTau() const {
    return theCTau > Length() ? theCTau :
      ( theWidth > ZERO ? hbarc/theWidth :
        ( stable() ? Constants::MaxLength : Length() ) );
  }
 
  Energy hardProcessWidth() const { 
    return 
      hardProcessWidthSet ? theHardProcessWidth : width();
  }
 
  PDT::Charge iCharge(PDT::Charge);
 
  Charge charge() const { return eplus*double(theCharge)/3.0; }
 
  PDT::Charge iCharge() const { return theCharge; }
 
  bool charged() const { return PDT::charged(theCharge); }
 
  bool positive() const { return PDT::positive(theCharge); }
 
  bool negative() const { return PDT::negative(theCharge); }
 
  PDT::Spin iSpin(PDT::Spin);
 
  AngularMomentum spin() const { return hbar_Planck*double(theSpin-1)*0.5; }
 
  PDT::Spin iSpin() const { return theSpin; }
 
  PDT::Colour iColour(PDT::Colour);
 
  PDT::Colour iColour() const { return theColour; }
 
  bool coloured() const { return PDT::coloured(iColour()); }
 
  bool hasColour(bool anti = false) const {
    return anti? hasAntiColour():
      ( iColour() == PDT::Colour3 || iColour() == PDT::Colour6 ||
        iColour() == PDT::Colour8 );
  }
 
  bool hasAntiColour() const {
    return iColour() == PDT::Colour3bar || iColour() == PDT::Colour6bar || 
      iColour() == PDT::Colour8;
  }
 
  PDT::ColouredInteraction colouredInteraction() const {
    return theColouredInteraction;
  }
 
  void stable(bool stab);
 
  bool stable() const { return isStable; }
 
  tPDPtr CC() const { return theAntiPartner; }
 
  void synchronized(bool sync);
 
  bool synchronized() const { return syncAnti; }
 
  void synchronize();
 
  void massGenerator(tMassGenPtr);
 
  tMassGenPtr massGenerator() const { return theMassGenerator; }
 
  void widthGenerator(tWidthGeneratorPtr);
 
  tWidthGeneratorPtr widthGenerator() const { return theWidthGenerator; }
 
  void variableRatio(bool varRatio);
 
  bool variableRatio() const { return theVariableRatio; }
 
public:
 
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
 
  static void Init();
 
protected:
 
  virtual IBPtr clone() const;
 
  virtual IBPtr fullclone() const;
 
  virtual PDPtr pdclone() const;
 
  ParticleData(PID newId, const string & newPDGName);
 
  virtual void readSetup(istream & is);
 
  static void antiSetup(const PDPair & pap);
 
 
protected:
 
  virtual void doupdate();
 
  virtual void doinit();
 
  virtual void rebind(const TranslationMap & trans)
   ;
 
  virtual IVector getReferences();
 
  virtual void doinitrun();
 
protected:
 
  void addDecayMode(tDMPtr);
 
  void removeDecayMode(tDMPtr);
 
private:
 
  PID theId;
 
  string thePDGName;
 
  Energy theMass;
 
  Energy theWidth;
 
  Energy theHardProcessMass;
 
  bool hardProcessMassSet;
 
  Energy theHardProcessWidth;
 
  bool hardProcessWidthSet;
 
  Energy theWidthUpCut;
 
  Energy theWidthLoCut;
 
  Length theCTau;
 
  PDT::Charge theCharge;
 
  PDT::Spin theSpin;
 
  PDT::Colour theColour;
 
  PDT::ColouredInteraction theColouredInteraction;
 
  MassGenPtr theMassGenerator;
 
  bool isStable;
 
  DecaySelector theDecaySelector;
 
  DecaySet theDecayModes;
 
  WidthGeneratorPtr theWidthGenerator;
 
  bool theVariableRatio;
 
  tPDPtr theAntiPartner;
 
  bool syncAnti;
 
  Energy theDefMass;
 
  Energy theDefWidth;
 
  Energy theDefCut;
 
  Length theDefCTau;
 
  PDT::Charge theDefCharge;
 
  PDT::Spin theDefSpin;
 
  PDT::Colour theDefColour;
 
  PDT::ColouredInteraction theDefColouredInteraction;
 
  void setMass(Energy);
 
  void setHardProcessMass(Energy);
 
  string doUnsetHardProcessMass(string);
 
  string doAdjustNominalMass(string);
 
  Energy defMass() const;
 
  void setWidth(Energy);
 
  void setHardProcessWidth(Energy);
 
  string doUnsetHardProcessWidth(string);
 
  Energy getWidth() const;
 
  Energy defWidth() const;
 
  void setCut(Energy);
 
  Energy getCut() const;
 
  Energy defCut() const;
 
  void setUpCut(Energy);
 
  Energy getUpCut() const;
 
  void setLoCut(Energy);
 
  Energy getLoCut() const;
 
  void setCTau(Length);
 
  Length getCTau() const;
 
  Length defCTau() const;
 
  void setStable(long);
 
  long getStable() const;
 
  void setSync(long);
 
  long getSync() const;
 
  void setVariableRatio(long);
 
  long getVariableRatio() const;
 
  string doSync(string);
 
  void setMassGenerator(MassGenPtr);
 
  void setWidthGenerator(WidthGeneratorPtr);
 
  void setCharge(int);
 
  string ssetCharge(string);
 
  int getCharge() const;
 
  int defCharge() const;
 
  void setSpin(int);
 
  int getSpin() const;
 
  int defSpin() const;
 
  void setColour(long);
 
  long getColour() const;
 
  long defColour() const;
 
  void setColouredInteraction(long);
 
  long getColouredInteraction() const;
 
  long defColouredInteraction() const;
 
  void insDecayModes(DMPtr dm, int);
 
  void delDecayModes(int i);
 
  vector<DMPtr> getDecayModes() const;
 
  string doSelectDecayModes(string);
 
  string doPrintDecayModes(string);
 
  static ClassDescription<ParticleData> initParticleData;
 
};
 
template <>
struct BaseClassTrait<ParticleData,1>: public ClassTraitsType {
  typedef Interfaced NthBase;
};
 
template <>
struct ClassTraits<ParticleData>: public ClassTraitsBase<ParticleData> {
  static string className() { return "ThePEG::ParticleData"; }
};
 
}
 
#endif /* ThePEG_ParticleData_H */