TEvtGenDecayer Class Reference

#include <TEvtGenDecayer.h>

Inheritance diagram for TEvtGenDecayer:

Collaboration diagram for TEvtGenDecayer:

Public Member Functions
	TEvtGenDecayer ()
	~TEvtGenDecayer () override
void	Init () override
void	Decay (Int_t pdg, TLorentzVector *p) override
Int_t	ImportParticles (TClonesArray *particles) override
void	SetForceDecay (Int_t type) override
void	ForceDecay () override
Float_t	GetPartialBranchingRatio (Int_t ipart) override
Float_t	GetLifetime (Int_t kf) override
void	ReadDecayTable () override
void	SetEvtGenDecayFile (const char *decayFile)
void	SetEvtGenParticleFile (const char *particleFile)
void	AddEvtGenParticle (Int_t pdg)
TPythia8Decayer *	GetPythia8Decayer ()

Protected Member Functions
Bool_t	UseEvtGenForParticle (Int_t pdg)
void	DecayWithEvtGen (Int_t pdg, TLorentzVector *p)
void	DecayWithPythia8 (Int_t pdg, TLorentzVector *p)
void	ConvertEvtGenDecay (EvtParticle *parent)

Private Attributes
TPythia8Decayer *	fPythia8Decayer
EvtGen *	fEvtGen
TString	fDecayFile
TString	fParticleFile
std::vector< Int_t >	fEvtGenParticles
TClonesArray *	fEvtGenProducts
Bool_t	fHasEvtGenDecay

Detailed Description

Definition at line 22 of file TEvtGenDecayer.h.

Constructor & Destructor Documentation

TEvtGenDecayer()

TEvtGenDecayer::TEvtGenDecayer

(

)

Definition at line 35 of file TEvtGenDecayer.cxx.

    : TVirtualMCDecayer(),
      fPythia8Decayer(nullptr),
      fEvtGen(nullptr),
      fDecayFile(""),
      fParticleFile(""),
      fEvtGenProducts(nullptr),
      fHasEvtGenDecay(kFALSE) {
  // Default constructor
  fEvtGenParticles.clear();
  fEvtGenProducts = new TClonesArray("TParticle");
}

~TEvtGenDecayer()

TEvtGenDecayer::~TEvtGenDecayer ( )

override

Definition at line 49 of file TEvtGenDecayer.cxx.

                                {
  // Destructor
  if (fPythia8Decayer) delete fPythia8Decayer;
  if (fEvtGen) delete fEvtGen;
  if (fEvtGenProducts) delete fEvtGenProducts;
}

Member Function Documentation

AddEvtGenParticle()

void TEvtGenDecayer::AddEvtGenParticle

(

Int_t

pdg

)

Definition at line 318 of file TEvtGenDecayer.cxx.

                                                {
  fEvtGenParticles.push_back(pdg);
  LOG(info) << "TEvtGenDecayer: Added PDG " << pdg << " to EvtGen particle list"
            << " (Total: " << fEvtGenParticles.size() << ")";
}

ConvertEvtGenDecay()

void TEvtGenDecayer::ConvertEvtGenDecay ( EvtParticle *  parent )

protected

Definition at line 232 of file TEvtGenDecayer.cxx.

                                                           {
  // Convert EvtGen decay products to ROOT/GEANT4 format
  // Clear previous decay products
  fEvtGenProducts->Clear();
  fHasEvtGenDecay = kTRUE;
 
  int nDaughters = parent->getNDaug();
  LOG(debug2) << "ConvertEvtGenDecay: Converting " << nDaughters
              << " daughter particles";
 
  // Convert each daughter particle to TParticle format
  for (int i = 0; i < nDaughters; i++) {
    EvtParticle* daughter = parent->getDaug(i);
    EvtVector4R p4 = daughter->getP4();
    int pdgId = EvtPDL::getStdHep(daughter->getId());
 
    // Create TParticle (ROOT format)
    TParticle* particle = new ((*fEvtGenProducts)[i]) TParticle();
    particle->SetPdgCode(pdgId);
    particle->SetMomentum(p4.get(1), p4.get(2), p4.get(3),
                          p4.get(0));           // px, py, pz, E
    particle->SetProductionVertex(0, 0, 0, 0);  // Produced at origin
    particle->SetStatusCode(1);                 // Stable particle
 
    LOG(debug2) << "  Daughter " << i << ": PDG=" << pdgId
                << ", E=" << p4.get(0) << ", px=" << p4.get(1)
                << ", py=" << p4.get(2) << ", pz=" << p4.get(3);
  }
 
  LOG(debug1) << "ConvertEvtGenDecay: Stored "
              << fEvtGenProducts->GetEntriesFast() << " particles";
}

Decay()

void TEvtGenDecayer::Decay ( Int_t  pdg, TLorentzVector *  p  )

override

Definition at line 131 of file TEvtGenDecayer.cxx.

                                                       {
  // Main decay method - route to EvtGen or Pythia8 based on particle type
 
  // Debug output for decay calls (highest verbosity)
  LOG(debug2) << "TEvtGenDecayer::Decay called for PDG " << pdg
              << " (E=" << p->E() << ", p=" << p->P() << ")";
 
  // Check if this particle should use EvtGen
  Bool_t useEvtGen = UseEvtGenForParticle(pdg);
  Bool_t evtGenAvailable = (fEvtGen != nullptr);
 
  LOG(debug1) << "UseEvtGenForParticle(" << pdg << ") = " << useEvtGen
              << ", EvtGen available = " << evtGenAvailable;
 
  if (useEvtGen && evtGenAvailable) {
    LOG(debug) << "Routing PDG " << pdg << " to EvtGen";
    DecayWithEvtGen(pdg, p);
  } else {
    LOG(debug) << "Routing PDG " << pdg << " to Pythia8 fallback";
    DecayWithPythia8(pdg, p);
  }
}

DecayWithEvtGen()

void TEvtGenDecayer::DecayWithEvtGen ( Int_t  pdg, TLorentzVector *  p  )

protected

Definition at line 174 of file TEvtGenDecayer.cxx.

                                                                 {
  // Decay particle using EvtGen
 
  if (!fEvtGen) {
    // Fall back to Pythia8 if EvtGen not available
    DecayWithPythia8(pdg, p);
    return;
  }
 
  LOG(debug1) << "DecayWithEvtGen: Decaying PDG " << pdg << " with EvtGen";
 
  try {
    // Convert TLorentzVector to EvtGen format
    EvtVector4R p4(p->E(), p->Px(), p->Py(), p->Pz());
 
    // Get EvtGen particle ID from PDG code
    EvtId evtId = EvtPDL::evtIdFromStdHep(pdg);
 
    // Check if EvtId is valid before creating particle
    if (evtId.getId() < 0 ||
        static_cast<size_t>(evtId.getId()) >= EvtPDL::entries()) {
      LOG(warning) << "TEvtGenDecayer: Invalid EvtId for PDG " << pdg
                   << " (EvtId: " << evtId.getId()
                   << "), falling back to Pythia8";
      DecayWithPythia8(pdg, p);
      return;
    }
 
    // Create EvtGen particle
    EvtParticle* parent = EvtParticleFactory::particleFactory(evtId, p4);
 
    if (parent) {
      // Generate decay
      fEvtGen->generateDecay(parent);
 
      // Convert EvtGen decay products to ROOT format
      ConvertEvtGenDecay(parent);
 
      LOG(debug1)
          << "TEvtGenDecayer: EvtGen decay products converted and stored";
 
      // Clean up
      parent->deleteTree();
    } else {
      LOG(warning) << "TEvtGenDecayer: Could not create EvtParticle for PDG "
                   << pdg;
      // Fall back to Pythia8
      DecayWithPythia8(pdg, p);
    }
  } catch (const std::exception& e) {
    LOG(error) << "TEvtGenDecayer: EvtGen exception for PDG " << pdg << ": "
               << e.what();
    // Fall back to Pythia8 on any exception
    DecayWithPythia8(pdg, p);
  }
}

DecayWithPythia8()

void TEvtGenDecayer::DecayWithPythia8 ( Int_t  pdg, TLorentzVector *  p  )

protected

Definition at line 266 of file TEvtGenDecayer.cxx.

                                                                  {
  // Decay particle using Pythia8 decayer
  LOG(debug1) << "DecayWithPythia8: Handling PDG " << pdg << " with Pythia8";
 
  // Mark that this decay will use Pythia8 products
  fHasEvtGenDecay = kFALSE;
 
  if (fPythia8Decayer) {
    fPythia8Decayer->Decay(pdg, p);
  }
}

ForceDecay()

void TEvtGenDecayer::ForceDecay ( )

override

Definition at line 330 of file TEvtGenDecayer.cxx.

                                {
  if (fPythia8Decayer) fPythia8Decayer->ForceDecay();
}

GetLifetime()

Float_t TEvtGenDecayer::GetLifetime ( Int_t  kf )

override

Definition at line 341 of file TEvtGenDecayer.cxx.

                                            {
  if (fPythia8Decayer) return fPythia8Decayer->GetLifetime(kf);
  return 0.0;
}

GetPartialBranchingRatio()

Float_t TEvtGenDecayer::GetPartialBranchingRatio ( Int_t  ipart )

override

Definition at line 335 of file TEvtGenDecayer.cxx.

                                                            {
  if (fPythia8Decayer) return fPythia8Decayer->GetPartialBranchingRatio(ipart);
  return 0.0;
}

GetPythia8Decayer()

TPythia8Decayer * TEvtGenDecayer::GetPythia8Decayer ( )

inline

Definition at line 42 of file TEvtGenDecayer.h.

{ return fPythia8Decayer; }

ImportParticles()

Int_t TEvtGenDecayer::ImportParticles ( TClonesArray *  particles )

override

Definition at line 279 of file TEvtGenDecayer.cxx.

                                                             {
  // Import particles - return EvtGen products if available, otherwise delegate
  // to Pythia8
  if (fHasEvtGenDecay && fEvtGenProducts) {
    LOG(debug1) << "ImportParticles: Returning "
                << fEvtGenProducts->GetEntriesFast() << " EvtGen particles";
 
    // Copy EvtGen particles to the provided array
    particles->Clear();
    int nParticles = fEvtGenProducts->GetEntriesFast();
    for (int i = 0; i < nParticles; i++) {
      TParticle* srcParticle = static_cast<TParticle*>(fEvtGenProducts->At(i));
      new ((*particles)[i]) TParticle(*srcParticle);
    }
 
    // Reset the flag for next decay
    fHasEvtGenDecay = kFALSE;
    return nParticles;
  } else {
    // Fall back to Pythia8
    LOG(debug1) << "ImportParticles: Delegating to Pythia8";
    if (fPythia8Decayer) {
      return fPythia8Decayer->ImportParticles(particles);
    }
    return 0;
  }
}

Init()

void TEvtGenDecayer::Init ( )

override

Definition at line 57 of file TEvtGenDecayer.cxx.

                          {
  // Initialize both EvtGen and Pythia8 decayers
 
  // Initialize fallback Pythia8 decayer
  fPythia8Decayer = new TPythia8Decayer();
  fPythia8Decayer->Init();
 
  // Initialize EvtGen if decay files are specified
  if (fDecayFile != "" && fParticleFile != "") {
    // Set up EvtGen random engine with ROOT's random number generator seed
    UInt_t seed = gRandom->GetSeed();
 
    // Also seed Pythia8 with the same seed for consistency
    TPythia8* pythia8 = TPythia8::Instance();
    if (pythia8) {
      pythia8->Pythia8()->readString(Form("Random:seed = %u", seed));
      pythia8->Pythia8()->readString("Random:setSeed = on");
      pythia8->Pythia8()->init();  // Re-initialize with new seed
      LOG(debug) << "TEvtGenDecayer: Pythia8 RNG seeded with " << seed;
    }
 
    EvtRandomEngine* randomEngine = new EvtMTRandomEngine(seed);
    EvtRandom::setRandomEngine(randomEngine);
 
    LOG(info) << "TEvtGenDecayer: Random engine initialized with seed " << seed;
 
    // Set up external generators with PHOTOS radiative corrections
    std::string photonType("gamma");
    bool useEvtGenRandom(true);
    bool convertPythiaCodes(false);
    std::string pythiaDir("");
 
    EvtExternalGenList* externalGenList = new EvtExternalGenList(
        convertPythiaCodes, pythiaDir, photonType, useEvtGenRandom);
 
    // Get the interface to the radiative correction engine (PHOTOS)
    EvtAbsRadCorr* radCorrEngine = externalGenList->getPhotosModel();
    if (radCorrEngine) {
      LOG(info) << "TEvtGenDecayer: PHOTOS radiative corrections enabled";
    } else {
      LOG(warning) << "TEvtGenDecayer: PHOTOS not available, proceeding "
                      "without radiative corrections";
    }
 
    // Get the interface to other external generators
    std::list<EvtDecayBase*> extraModels = externalGenList->getListOfModels();
 
    // Create EvtGen instance
    fEvtGen = new EvtGen(fDecayFile.Data(), fParticleFile.Data(), randomEngine,
                         radCorrEngine, &extraModels, 1, false);
 
    LOG(debug) << "TEvtGenDecayer: EvtGen created with " << EvtPDL::entries()
               << " particle entries";
 
    LOG(info) << "TEvtGenDecayer: EvtGen initialized with decay file: "
              << fDecayFile.Data()
              << ", particle file: " << fParticleFile.Data();
  } else {
    LOG(debug)
        << "TEvtGenDecayer: No EvtGen files specified, using Pythia8 only";
  }
 
  // Log summary at end of Init
  LOG(info) << "TEvtGenDecayer initialized - EvtGen: "
            << (fEvtGen ? "YES" : "NO")
            << ", Pythia8 fallback: " << (fPythia8Decayer ? "YES" : "NO")
            << ", Particles configured for EvtGen: " << fEvtGenParticles.size();
 
  for (size_t i = 0; i < fEvtGenParticles.size(); i++) {
    LOG(debug) << "  EvtGen particle: PDG " << fEvtGenParticles[i];
  }
}

ReadDecayTable()

void TEvtGenDecayer::ReadDecayTable ( )

override

Definition at line 347 of file TEvtGenDecayer.cxx.

                                    {
  if (fPythia8Decayer) fPythia8Decayer->ReadDecayTable();
}

SetEvtGenDecayFile()

void TEvtGenDecayer::SetEvtGenDecayFile

(

const char *

decayFile

)

Definition at line 308 of file TEvtGenDecayer.cxx.

                                                             {
  fDecayFile = decayFile;
}

SetEvtGenParticleFile()

void TEvtGenDecayer::SetEvtGenParticleFile

(

const char *

particleFile

)

Definition at line 313 of file TEvtGenDecayer.cxx.

                                                                   {
  fParticleFile = particleFile;
}

SetForceDecay()

void TEvtGenDecayer::SetForceDecay ( Int_t  type )

override

Definition at line 325 of file TEvtGenDecayer.cxx.

                                             {
  if (fPythia8Decayer) fPythia8Decayer->SetForceDecay(type);
}

UseEvtGenForParticle()

Bool_t TEvtGenDecayer::UseEvtGenForParticle ( Int_t  pdg )

protected

Definition at line 155 of file TEvtGenDecayer.cxx.

                                                     {
  // Check if this particle should be handled by EvtGen
  LOG(debug2) << "UseEvtGenForParticle: Checking PDG " << pdg
              << " against EvtGen particle list";
 
  for (Int_t evtGenPdg : fEvtGenParticles) {
    if (pdg == evtGenPdg) {
      LOG(debug2) << "UseEvtGenForParticle: Match found - PDG " << pdg
                  << " should use EvtGen";
      return kTRUE;
    }
  }
 
  LOG(warning) << "UseEvtGenForParticle: PDG " << pdg
               << " not in EvtGen particle list, falling back to Pythia8";
  return kFALSE;
}

Member Data Documentation

fDecayFile

TString TEvtGenDecayer::fDecayFile

private

Definition at line 54 of file TEvtGenDecayer.h.

fEvtGen

EvtGen* TEvtGenDecayer::fEvtGen

private

Definition at line 53 of file TEvtGenDecayer.h.

fEvtGenParticles

std::vector<Int_t> TEvtGenDecayer::fEvtGenParticles

private

Definition at line 57 of file TEvtGenDecayer.h.

fEvtGenProducts

TClonesArray* TEvtGenDecayer::fEvtGenProducts

private

Definition at line 60 of file TEvtGenDecayer.h.

fHasEvtGenDecay

Bool_t TEvtGenDecayer::fHasEvtGenDecay

private

Definition at line 61 of file TEvtGenDecayer.h.

fParticleFile

TString TEvtGenDecayer::fParticleFile

private

Definition at line 55 of file TEvtGenDecayer.h.

fPythia8Decayer

TPythia8Decayer* TEvtGenDecayer::fPythia8Decayer

private

Definition at line 52 of file TEvtGenDecayer.h.

---

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

• shipgen/TEvtGenDecayer.h
• shipgen/TEvtGenDecayer.cxx