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();

  virtual ~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;
  }

  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;

  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;

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