A class to perform decays via the external EvtGen decay program, see http://evtgen.warwick.ac.uk/, the program manual provided with the EvtGen distribution, and D. More...

#include <EvtGenDecays.h>

Classes
struct	Signal
	Map of signal particle info. More...

Public Member Functions
	EvtGenDecays (Pythia8::Pythia pythiaPtrIn, EvtGen evtGen, bool limit=true)
	Expert constructor which takes an already initialized EvtGen instance.

	EvtGenDecays (Pythia8::Pythia pythiaPtrIn, std::string decayFile, std::string particleDataFile, EvtExternalGenList extPtrIn=0, EvtAbsRadCorr *fsrPtrIn=0, int mixing=1, bool xml=false, bool limit=true, bool extUse=true, bool fsrUse=true)
	Constructor.

	~EvtGenDecays ()
	Destructor.

	EvtGenDecays (const EvtGenDecays &)=delete
	forbid copy

EvtGenDecays &	operator= (const EvtGenDecays &)=delete
	forbid assignment

void	getDecayLimits (bool limit)
	Get the Decay limits from Pythia.

double	decay ()
	Perform all decays and return the event weight.

void	exclude (int id)
	Stop EvtGen decaying a particle.

void	updatePythia ()
	Update the Pythia particle database from EvtGen.

void	updateEvtGen ()
	Update the EvtGen particle database from Pythia.

void	readDecayFile (std::string decayFile, bool xml=false)
	Read an EvtGen user decay file.

Public Attributes
bool	extOwner
	bool has external model

bool	fsrOwner
	bool has FSR model

EvtExternalGenList *	extPtr
	External model pointer.

EvtAbsRadCorr *	fsrPtr
	FSR model pointer.

std::list< EvtDecayBase * >	models
	list of model pointers

std::map< int, Signal >	signals
	signal particles and statuses

std::string	signalSuffix
	The suffix indicating an EvtGen particle or alias is signal.

Protected Member Functions
void	updateData (bool final=false)
	Update the particles to decay with EvtGen, and the selected signals.

void	updateEvent (Pythia8::Particle pyPro, EvtParticle egPro, std::vector< int > pySigs=0, std::vector< EvtParticle > egSigs=0, std::vector< double > bfs=0, double *wgt=0)
	Update the Pythia event record with an EvtGen decay tree.

bool	checkVertex (Pythia8::Particle *pyPro)
	Check if a particle can decay.

bool	checkSignal (Pythia8::Particle *pyPro)
	Check if a particle is signal.

bool	checkOsc (EvtParticle *egPro)
	Check if an EvtGen particle has oscillated.

Protected Attributes
Pythia8::Pythia *	pythiaPtr
	The pointer to the associated Pythia object.

EvtGenRandom	rndm
	Random number wrapper for EvtGen.

EvtGen *	evtgen
	The EvtGen object.

std::set< int >	incIds
	Set of particle IDs to include decays with EvtGen.

std::set< int >	excIds
	Set of particle IDs to exclude decays with EvtGen.

bool	updated
	Flag whether the final particle update has been performed.

std::map< int, Signal >::iterator	signal
	The selected signal iterator.

double	tau0Max
	Parameters used to check if a particle should decay (as set via Pythia).

double	tauMax
	the pythia parameter ParticleDecays:tauMax

double	rMax
	the pythia parameter ParticleDecays:rMax

double	xyMax
	the pythia parameter ParticleDecays:xyMax

double	zMax
	the pythia parameter ParticleDecays:zMax

bool	limitTau0
	the pythia parameter ParticleDecays:limitTau0

bool	limitTau
	the pythia parameter ParticleDecays:limitTau

bool	limitRadius
	the pythia parameter ParticleDecays:limitRadius

bool	limitCylinder
	the pythia parameter ParticleDecays:limitCylinder

bool	limitDecay
	is the decay limited

Static Protected Attributes
static constexpr int	NTRYDECAY = 1000
	Number of times to try a decay sampling (constant).

Detailed Description

A class to perform decays via the external EvtGen decay program, see http://evtgen.warwick.ac.uk/, the program manual provided with the EvtGen distribution, and D.

J. Lange, Nucl. Instrum. Meth. A462, 152 (2001) for details.

EvtGen performs a series of decays from some initial particle decay, rather than just a single decay, and so EvtGen cannot be interfaced through the standard external DecayHandler class without considerable complication. Consequently, EvtGen is called on the complete event record after all steps of Pythia are completed.

Oftentimes a specific "signal" decay is needed to occur once in an event, and all other decays performed normally. This is possible via reading in a user decay file (with readDecayFile) and creating aliased particles with names ending with signalSuffix. By default, this is "_SIGNAL". When decay() is called, all particles in the Pythia event record that are of the same types as the signal particles are collected. One is selected at random and decayed via the channel(s) defined for that aliased signal particle. All other particles are decayed normally. The weight for the event is calculated and returned.

It is also possible to specify a status needed to consider a particle as a signal candidate. This can be done by modifying the signals map, e.g. if the tau- is a signal candidate, then EvtGenDecays.signals[15].status = 201 will only only select as candidates any tau- with this status. This allows the event record to be changed before decays, so only certain particles are selected as possible signal candidates (e.g. passing kinematic requirements).

Please note that particles produced from a signal candidate decay are not searched for additional signal candidates. This means that if B0 and tau- have been designated as signal, then a tau- from a W- decay would be a signal candidate, while a tau- from a B0 decay would not. This restriction arises from the additional complexity of allowing recursive signal decays. The following statuses are used: 93 for particles decayed with EvtGen, 94 for particles oscillated with EvtGen, 95 for signal particles, and 96 for signal particles from an oscillation.

Definition at line 88 of file EvtGenDecays.h.

Constructor & Destructor Documentation

◆ EvtGenDecays() [1/2]

EvtGenDecays	(	Pythia8::Pythia *	pythiaPtrIn,
		EvtGen *	evtGen,
		bool	limit = `true`
	)

Expert constructor which takes an already initialized EvtGen instance.

Definition at line 255 of file EvtGenDecays.h.

                                                                                :
  extOwner(false), fsrOwner(false), extPtr(nullptr), fsrPtr(nullptr),
  signalSuffix("_SIGNAL"), pythiaPtr(pythiaPtrIn), rndm(nullptr),
  evtgen(evtGen), updated(false)
{
  getDecayLimits(limit);
}

◆ EvtGenDecays() [2/2]

EvtGenDecays	(	Pythia8::Pythia *	pythiaPtrIn,
		std::string	decayFile,
		std::string	particleDataFile,
		EvtExternalGenList *	extPtrIn = `0`,
		EvtAbsRadCorr *	fsrPtrIn = `0`,
		int	mixing = `1`,
		bool	xml = `false`,
		bool	limit = `true`,
		bool	extUse = `true`,
		bool	fsrUse = `true`
	)

Constructor.

Definition at line 263 of file EvtGenDecays.h.

                                                     : extPtr(extPtrIn), fsrPtr(fsrPtrIn),
  signalSuffix("_SIGNAL"), pythiaPtr(pythiaPtrIn), rndm(&pythiaPtr->rndm),
  updated(false)
{
 
  // Initialize EvtGen.
  if (!extPtr && fsrPtr) {
    B2ERROR("Error in EvtGenDecays::EvtGenDecays: extPtr is null but fsrPtr is provided");
    return;
  }
  if (extPtr) extOwner = false;
  else {extOwner = true; extPtr = new EvtExternalGenList();}
  if (fsrPtr) fsrOwner = false;
  else {fsrOwner = true; fsrPtr = extPtr->getPhotosModel();}
  models = extPtr->getListOfModels();
  evtgen = new EvtGen(decayFile.c_str(), particleDataFile.c_str(),
                      &rndm, fsrUse ? fsrPtr : 0, extUse ? &models : 0, mixing, xml);
  getDecayLimits(limit);
}

◆ ~EvtGenDecays()

~EvtGenDecays ( )

inline

Destructor.

Definition at line 102 of file EvtGenDecays.h.

  {
    if (evtgen) delete evtgen;
    if (extOwner && extPtr) delete extPtr;
    if (fsrOwner && fsrPtr) delete fsrPtr;
  }

Member Function Documentation

◆ checkOsc()

bool checkOsc ( EvtParticle * egPro )

protected

Check if an EvtGen particle has oscillated.

Definition at line 668 of file EvtGenDecays.h.

{
  if (egPro && egPro->getNDaug() == 1 &&
      egPro->getPDGId() != egPro->getDaug(0)->getPDGId()) return true;
  else return false;
}

◆ checkSignal()

bool checkSignal ( Pythia8::Particle * pyPro )

protected

Check if a particle is signal.

Definition at line 653 of file EvtGenDecays.h.

{
  signal = signals.find(pyPro->id());
  if (signal != signals.end() && (signal->second.status < 0 ||
                                  signal->second.status == pyPro->status())) return true;
  else return false;
}

◆ checkVertex()

bool checkVertex ( Pythia8::Particle * pyPro )

protected

Check if a particle can decay.

Definition at line 635 of file EvtGenDecays.h.

{
  using ::Pythia8::pow2;
 
  if (!limitDecay) return true;
  if (limitTau0 && pyPro->tau0() > tau0Max) return false;
  if (limitTau && pyPro->tau() > tauMax) return false;
  if (limitRadius && pow2(pyPro->xDec()) + pow2(pyPro->yDec())
      + pow2(pyPro->zDec()) > pow2(rMax)) return false;
  if (limitCylinder && (pow2(pyPro->xDec()) + pow2(pyPro->yDec())
                        > pow2(xyMax) || abs(pyPro->zDec()) > zMax)) return false;
  return true;
}

◆ decay()

double decay ( )

Perform all decays and return the event weight.

Definition at line 327 of file EvtGenDecays.h.

{
 
  // Reset the signal and signal counters.
  if (!pythiaPtr || !evtgen) return -1;
  if (!updated) updateData(true);
 
  // Loop over all particles in the Pythia event.
  Pythia8::Event& event = pythiaPtr->event;
  std::vector<int> pySigs; std::vector<EvtParticle*> egSigs, egPrts;
  std::vector<double> bfs; double wgt(1.);
  for (int iPro = 0; iPro < event.size(); ++iPro) {
 
    // Check particle is final and can be decayed by EvtGen.
    Pythia8::Particle* pyPro = &event[iPro];
    if (!pyPro->isFinal()) continue;
    if (incIds.find(pyPro->id()) == incIds.end()) continue;
    if (pyPro->status() == 93 || pyPro->status() == 94) continue;
 
    // Decay the progenitor with EvtGen.
    EvtParticle* egPro = EvtParticleFactory::particleFactory
                         (EvtPDL::evtIdFromStdHep(pyPro->id()),
                          EvtVector4R(pyPro->e(), pyPro->px(), pyPro->py(), pyPro->pz()));
    egPrts.push_back(egPro);
    egPro->setDiagonalSpinDensity();
    evtgen->generateDecay(egPro);
    pyPro->tau(egPro->getLifetime());
    if (!checkVertex(pyPro)) continue;
 
    // Add oscillations to event record.
    if (checkOsc(egPro))
      updateEvent(pyPro, egPro, &pySigs, &egSigs, &bfs, &wgt);
 
    // Undo decay if signal (duplicate to stop oscillations).
    else if (checkSignal(pyPro)) {
      pySigs.push_back(pyPro->index());
      egSigs.push_back(egPro);
      bfs.push_back(signal->second.bfs[0]);
      wgt *= 1 - bfs.back();
      egPro->deleteDaughters();
      // The following problematic part of the Pythia's code was removed, see
      // https://gitlab.com/Pythia8/releases/
      // -/blob/pythia8310/include/Pythia8Plugins/EvtGen.h?ref_type=tags#L321-325
 
      // If not signal, add to event record.
    } else updateEvent(pyPro, egPro, &pySigs, &egSigs, &bfs, &wgt);
  }
  if (pySigs.size() == 0) {
    for (int iPrt = 0; iPrt < (int)egPrts.size(); ++iPrt)
      egPrts[iPrt]->deleteTree();
    return 0;
  }
 
  // Determine the decays of the signal particles (signal or background).
  std::vector<int> modes; int force(-1);
  for (int iTry = 1; iTry <= NTRYDECAY; ++iTry) {
    int n(0);
 
    modes.clear(); force = pythiaPtr->rndm.pick(bfs); n = 0;
    for (int iSig = 0; iSig < (int)pySigs.size(); ++iSig) {
      if (iSig == force) modes.push_back(0);
      else modes.push_back(pythiaPtr->rndm.flat() > bfs[iSig]);
      if (modes.back() == 0) ++n;
    }
    if (pythiaPtr->rndm.flat() <= 1.0 / n) break;
    if (iTry == NTRYDECAY) {
      wgt = 2.;
      B2WARNING("Warning in EvtGenDecays::decay: maximum number of signal decay attempts exceeded"
                << LogVar("maxTries", NTRYDECAY));
    }
  }
 
  // Decay the signal particles and mark forced decay.
  for (int iSig = 0; iSig < (int)pySigs.size(); ++iSig) {
    EvtParticle* egSig = egSigs[iSig];
    Pythia8::Particle*    pySig = &event[pySigs[iSig]];
    signal = signals.find(pySig->id());
    if (egSig->getNDaug() > 0) egSig = egSig->getDaug(0);
    if (modes[iSig] == 0) egSig->setId(signal->second.egId);
    else {
      signal->second.modes.getDecayModel(egSig);
      egSig->setChannel(signal->second.map[egSig->getChannel()]);
    }
    if (iSig == force)
      pySig->status(pySig->status() == 92 || pySig->status() == 94 ? 96 : 95);
    evtgen->generateDecay(egSig);
    updateEvent(pySig, egSigs[iSig]);
  }
 
  // Delete all EvtGen particles and return weight.
  for (int iPrt = 0; iPrt < (int)egPrts.size(); ++iPrt)
    egPrts[iPrt]->deleteTree();
  return 1. - wgt;
 
}

◆ exclude()

void exclude ( int id )

inline

Stop EvtGen decaying a particle.

Definition at line 122 of file EvtGenDecays.h.

122{excIds.insert(id);}

EvtGenDecays::excIds

std::set< int > excIds

Set of particle IDs to exclude decays with EvtGen.

Definition: EvtGenDecays.h:188

◆ getDecayLimits()

void getDecayLimits ( bool limit )

Get the Decay limits from Pythia.

Definition at line 286 of file EvtGenDecays.h.

{
  // Get the Pythia decay limits.
  if (!pythiaPtr) return;
  limitTau0     = pythiaPtr->settings.flag("ParticleDecays:limitTau0");
  tau0Max       = pythiaPtr->settings.parm("ParticleDecays:tau0Max");
  limitTau      = pythiaPtr->settings.flag("ParticleDecays:limitTau");
  tauMax        = pythiaPtr->settings.parm("ParticleDecays:tauMax");
  limitRadius   = pythiaPtr->settings.flag("ParticleDecays:limitRadius");
  rMax          = pythiaPtr->settings.parm("ParticleDecays:rMax");
  limitCylinder = pythiaPtr->settings.flag("ParticleDecays:limitCylinder");
  xyMax         = pythiaPtr->settings.parm("ParticleDecays:xyMax");
  zMax          = pythiaPtr->settings.parm("ParticleDecays:zMax");
  limitDecay    = limit && (limitTau0 || limitTau ||
                            limitRadius || limitCylinder);
 
}

◆ readDecayFile()

void readDecayFile	(	std::string	decayFile,
		bool	xml = `false`
	)

inline

Read an EvtGen user decay file.

Definition at line 131 of file EvtGenDecays.h.

  {
    evtgen->readUDecay(decayFile.c_str(), xml); updateData();
  }

◆ updateData()

void updateData ( bool final = false )

protected

Update the particles to decay with EvtGen, and the selected signals.

Definition at line 481 of file EvtGenDecays.h.

{
 
  // Loop over the EvtGen entries.
  if (!pythiaPtr) return;
  EvtDecayTable* egTable = EvtDecayTable::getInstance();
  if (!egTable) return;
  for (int iEntry = 0; iEntry < (int)EvtPDL::entries(); ++iEntry) {
    EvtId egId = EvtPDL::getEntry(iEntry);
    int   pyId = EvtPDL::getStdHep(egId);
    if (egTable->getNModes(egId) == 0) continue;
    if (excIds.find(pyId) != excIds.end()) continue;
 
    // Stop Pythia from decaying the particle and include in decay set.
    if (final)  {
      incIds.insert(pyId);
      pythiaPtr->particleData.mayDecay(pyId, false);
    }
 
    // Check for signal.
    std::string egName = EvtPDL::name(egId);
    if (egName.size() <= signalSuffix.size() || egName.substr
        (egName.size() - signalSuffix.size()) != signalSuffix) continue;
    signal = signals.find(pyId);
    if (signal == signals.end()) {
      signals[pyId].status = -1;
      signal = signals.find(pyId);
    }
    signal->second.egId  = egId;
    signal->second.bfs   = std::vector<double>(2, 0);
    if (!final) continue;
 
    // Get the signal and background decay modes.
    std::vector<EvtParticleDecayList> egList = egTable->getDecayTable();
    int sigIdx = egId.getAlias();
    int bkgIdx = EvtPDL::evtIdFromStdHep(pyId).getAlias();
    if (sigIdx > (int)egList.size() || bkgIdx > (int)egList.size()) continue;
    EvtParticleDecayList sigModes = egList[sigIdx];
    EvtParticleDecayList bkgModes = egList[bkgIdx];
    EvtParticleDecayList allModes = egList[bkgIdx];
    double sum(0);
 
    // Sum signal branching fractions.
    for (int iMode = 0; iMode < sigModes.getNMode(); ++iMode) {
      EvtDecayBase* mode = sigModes.getDecayModel(iMode);
      if (!mode) continue;
      signal->second.bfs[0] += mode->getBranchingFraction();
      sum += mode->getBranchingFraction();
    }
 
    // Sum remaining background branching fractions.
    for (int iMode = 0; iMode < allModes.getNMode(); ++iMode) {
      EvtDecayBase* mode = allModes.getDecayModel(iMode);
      if (!mode) continue;
      bool match(false);
      for (int jMode = 0; jMode < sigModes.getNMode(); ++jMode)
        if (mode->matchingDecay(*(sigModes.getDecayModel(jMode)))) {
          match = true; break;
        }
      if (match) bkgModes.removeMode(mode);
      else {
        signal->second.map.push_back(iMode);
        signal->second.bfs[1] += mode->getBranchingFraction();
        sum += mode->getBranchingFraction();
      }
    }
    signal->second.modes = bkgModes;
    for (int iBf = 0; iBf < (int)signal->second.bfs.size(); ++iBf)
      signal->second.bfs[iBf] /= sum;
  }
  if (final) updated = true;
 
}

◆ updateEvent()

void updateEvent	(	Pythia8::Particle *	pyPro,
		EvtParticle *	egPro,
		std::vector< int > *	pySigs = `0`,
		std::vector< EvtParticle * > *	egSigs = `0`,
		std::vector< double > *	bfs = `0`,
		double *	wgt = `0`
	)

protected

Update the Pythia event record with an EvtGen decay tree.

Definition at line 574 of file EvtGenDecays.h.

{
 
  // Set up the mother vector.
  if (!pythiaPtr) return;
  EvtParticle* egMom = egPro;
  if (egPro->getNDaug() == 1 && egPro->getPDGId() ==
      egPro->getDaug(0)->getPDGId()) egMom = egPro->getDaug(0);
  Pythia8::Event& event = pythiaPtr->event;
  std::vector< std::pair<EvtParticle*, int> >
  moms(1, std::pair<EvtParticle*, int>(egMom, pyPro->index()));
 
  // Loop over the mothers.
  while (moms.size() != 0) {
 
    // Check if particle can decay.
    egMom = moms.back().first;
    int       iMom  = moms.back().second;
    Pythia8::Particle* pyMom = &event[iMom];
    moms.pop_back();
    if (!checkVertex(pyMom)) continue;
    bool osc(checkOsc(egMom));
 
    // Set the children of the mother.
    pyMom->daughters(event.size(), event.size() + egMom->getNDaug() - 1);
    pyMom->statusNeg();
    Pythia8::Vec4 vProd = pyMom->vDec();
    for (int iDtr = 0 ; iDtr < (int)egMom->getNDaug(); ++iDtr) {
      EvtParticle* egDtr = egMom->getDaug(iDtr);
      int          id    = egDtr->getPDGId();
      EvtVector4R  p     = egDtr->getP4Lab();
      int idx = event.append(id, 93, iMom, 0, 0, 0, 0, 0, p.get(1),
                             p.get(2), p.get(3), p.get(0), egDtr->mass());
      Pythia8::Particle* pyDtr = &event.back();
      pyDtr->vProd(vProd);
      pyDtr->tau(egDtr->getLifetime());
      if (pySigs && egSigs && bfs && wgt && checkSignal(pyDtr)) {
        pySigs->push_back(pyDtr->index());
        egSigs->push_back(egDtr);
        bfs->push_back(signal->second.bfs[0]);
        (*wgt) *= 1 - bfs->back();
        egDtr->deleteDaughters();
      }
      if (osc) pyDtr->status(94);
      if (egDtr->getAttribute("FSR"))
        pyDtr->status(Belle2::GeneratorConst::FSR_STATUS_CODE);
      if (egDtr->getNDaug() > 0)
        moms.push_back(std::pair<EvtParticle*, int>(egDtr, idx));
    }
  }
 
}

◆ updateEvtGen()

void updateEvtGen ( )

Update the EvtGen particle database from Pythia.

Definition at line 455 of file EvtGenDecays.h.

{
  if (!pythiaPtr || !evtgen) return;
  int pyId = pythiaPtr->particleData.nextId(0);
  while (pyId != 0) {
    EvtId egId = EvtPDL::evtIdFromStdHep(pyId);
    EvtPDL::reSetMass(egId, pythiaPtr->particleData.m0(pyId));
    EvtPDL::reSetWidth(egId, pythiaPtr->particleData.mWidth(pyId));
    EvtPDL::reSetMassMin(egId, pythiaPtr->particleData.mMin(pyId));
    EvtPDL::reSetMassMax(egId, pythiaPtr->particleData.mMax(pyId));
    pyId = pythiaPtr->particleData.nextId(pyId);
  }
}

◆ updatePythia()

void updatePythia ( )

Update the Pythia particle database from EvtGen.

Definition at line 431 of file EvtGenDecays.h.

{
  if (!pythiaPtr || !evtgen) return;
  for (int entry = 0; entry < (int)EvtPDL::entries(); ++entry) {
    EvtId egId = EvtPDL::getEntry(entry);
    int   pyId = EvtPDL::getStdHep(egId);
    pythiaPtr->particleData.spinType(pyId, EvtPDL::getSpinType(egId));
    pythiaPtr->particleData.chargeType(pyId, EvtPDL::chg3(egId));
    pythiaPtr->particleData.m0(pyId, EvtPDL::getMass(egId));
    pythiaPtr->particleData.mWidth(pyId, EvtPDL::getWidth(egId));
    pythiaPtr->particleData.mMin(pyId, EvtPDL::getMinMass(egId));
    pythiaPtr->particleData.mMax(pyId, EvtPDL::getMaxMass(egId));
    pythiaPtr->particleData.tau0(pyId, EvtPDL::getctau(egId));
  }
}

Member Data Documentation

◆ evtgen

EvtGen* evtgen

protected

The EvtGen object.

Definition at line 185 of file EvtGenDecays.h.

◆ excIds

std::set<int> excIds

protected

Set of particle IDs to exclude decays with EvtGen.

Definition at line 188 of file EvtGenDecays.h.

◆ extOwner

bool extOwner

bool has external model

Definition at line 136 of file EvtGenDecays.h.

◆ extPtr

EvtExternalGenList* extPtr

External model pointer.

Definition at line 138 of file EvtGenDecays.h.

◆ fsrOwner

bool fsrOwner

bool has FSR model

Definition at line 137 of file EvtGenDecays.h.

◆ fsrPtr

EvtAbsRadCorr* fsrPtr

FSR model pointer.

Definition at line 139 of file EvtGenDecays.h.

◆ incIds

std::set<int> incIds

protected

Set of particle IDs to include decays with EvtGen.

Definition at line 187 of file EvtGenDecays.h.

◆ limitCylinder

bool limitCylinder

protected

the pythia parameter ParticleDecays:limitCylinder

Definition at line 208 of file EvtGenDecays.h.

◆ limitDecay

bool limitDecay

protected

is the decay limited

Definition at line 209 of file EvtGenDecays.h.

◆ limitRadius

bool limitRadius

protected

the pythia parameter ParticleDecays:limitRadius

Definition at line 207 of file EvtGenDecays.h.

◆ limitTau

bool limitTau

protected

the pythia parameter ParticleDecays:limitTau

Definition at line 206 of file EvtGenDecays.h.

◆ limitTau0

bool limitTau0

protected

the pythia parameter ParticleDecays:limitTau0

Definition at line 205 of file EvtGenDecays.h.

◆ models

std::list<EvtDecayBase*> models

list of model pointers

Definition at line 140 of file EvtGenDecays.h.

◆ NTRYDECAY

constexpr int NTRYDECAY = 1000

staticconstexprprotected

Number of times to try a decay sampling (constant).

Definition at line 176 of file EvtGenDecays.h.

◆ pythiaPtr

Pythia8::Pythia* pythiaPtr

protected

The pointer to the associated Pythia object.

Definition at line 179 of file EvtGenDecays.h.

◆ rMax

double rMax

protected

the pythia parameter ParticleDecays:rMax

Definition at line 202 of file EvtGenDecays.h.

◆ rndm

EvtGenRandom rndm

protected

Random number wrapper for EvtGen.

Definition at line 182 of file EvtGenDecays.h.

◆ signal

std::map<int,Signal>::iterator signal

protected

The selected signal iterator.

Definition at line 194 of file EvtGenDecays.h.

◆ signals

std::map<int, Signal> signals

signal particles and statuses

Definition at line 151 of file EvtGenDecays.h.

◆ signalSuffix

std::string signalSuffix

The suffix indicating an EvtGen particle or alias is signal.

Definition at line 154 of file EvtGenDecays.h.

◆ tau0Max

double tau0Max

protected

Parameters used to check if a particle should decay (as set via Pythia).

http://home.thep.lu.se/Pythia/pythia82html/ParticleDecays.html the pythia parameter ParticleDecays:tau0Max

Definition at line 200 of file EvtGenDecays.h.

◆ tauMax

double tauMax

protected

the pythia parameter ParticleDecays:tauMax

Definition at line 201 of file EvtGenDecays.h.

◆ updated

bool updated

protected

Flag whether the final particle update has been performed.

Definition at line 191 of file EvtGenDecays.h.

◆ xyMax

double xyMax

protected

the pythia parameter ParticleDecays:xyMax

Definition at line 203 of file EvtGenDecays.h.

◆ zMax

double zMax

protected

the pythia parameter ParticleDecays:zMax

Definition at line 204 of file EvtGenDecays.h.

The documentation for this class was generated from the following file:

generators/modules/fragmentation/include/EvtGenDecays.h

Classes

Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ EvtGenDecays() [1/2]

◆ EvtGenDecays() [2/2]

◆ ~EvtGenDecays()

Member Function Documentation

◆ checkOsc()

◆ checkSignal()

◆ checkVertex()

◆ decay()

◆ exclude()

◆ getDecayLimits()

◆ readDecayFile()

◆ updateData()

◆ updateEvent()

◆ updateEvtGen()

◆ updatePythia()

Member Data Documentation

◆ evtgen

◆ excIds

◆ extOwner

◆ extPtr

◆ fsrOwner

◆ fsrPtr

◆ incIds

◆ limitCylinder

◆ limitDecay

◆ limitRadius

◆ limitTau

◆ limitTau0

◆ models

◆ NTRYDECAY

◆ pythiaPtr

◆ rMax

◆ rndm

◆ signal

◆ signals

◆ signalSuffix

◆ tau0Max

◆ tauMax

◆ updated

◆ xyMax

◆ zMax