#include <StackingAction.h>

Inheritance diagram for StackingAction:

Public Member Functions
G4ClassificationOfNewTrack	ClassifyNewTrack (const G4Track *aTrack) final

void	NewStage () override

void	PrepareNewEvent () override

	StackingAction (const TrackingAction , const edm::ParameterSet &ps, const CMSSteppingVerbose )

	~StackingAction () override

Private Member Functions
void	initPointer ()

int	isItFromPrimary (const G4Track &, int) const

bool	isItOutOfTimeWindow (const G4Region *, const double &) const

int	isItPrimaryDecayProductOrConversion (const G4Track *, const G4Track &) const

bool	isThisRegion (const G4Region , std::vector< const G4Region > &) const

void	printRegions (const std::vector< const G4Region *> &reg, const std::string &word) const

bool	rrApplicable (const G4Track *, const G4Track &) const

Private Attributes
std::vector< const G4Region * >	caloRegions

std::vector< std::string >	deadRegionNames

std::vector< const G4Region * >	deadRegions

TrackInformationExtractor	extractor

bool	gRRactive

double	gRusRoCastor

double	gRusRoEcal

double	gRusRoEnerLim

double	gRusRoHcal

double	gRusRoMuonIron

double	gRusRoPreShower

double	gRusRoWorld

bool	killDeltaRay

bool	killExtra

bool	killGamma

bool	killHeavy

bool	killInCalo

bool	killInCaloEfH

double	kmaxGamma

double	kmaxIon

double	kmaxNeutron

double	kmaxProton

double	limitEnergyForVacuum

std::vector< const G4Region * >	lowdensRegions

std::vector< std::string >	maxTimeNames

std::vector< const G4Region * >	maxTimeRegions

double	maxTrackTime

double	maxTrackTimeForward

std::vector< double >	maxTrackTimes

double	maxZCentralCMS

std::vector< const G4Region * >	muonRegions

NewTrackAction *	newTA

bool	nRRactive

double	nRusRoCastor

double	nRusRoEcal

double	nRusRoEnerLim

double	nRusRoHcal

double	nRusRoMuonIron

double	nRusRoPreShower

double	nRusRoWorld

unsigned int	numberTimes

const G4Region *	regionCastor

const G4Region *	regionEcal

const G4Region *	regionHcal

const G4Region *	regionMuonIron

const G4Region *	regionPreShower

const G4Region *	regionWorld

bool	saveFirstSecondary

bool	savePDandCinAll

bool	savePDandCinCalo

bool	savePDandCinMuon

bool	savePDandCinTracker

const CMSSteppingVerbose *	steppingVerbose

const TrackingAction *	trackAction

std::vector< const G4Region * >	trackerRegions

bool	trackNeutrino

G4VSolid *	worldSolid

Detailed Description

Definition at line 19 of file StackingAction.h.

Constructor & Destructor Documentation

◆ StackingAction()

StackingAction::StackingAction	(	const TrackingAction *	trka,
		const edm::ParameterSet &	ps,
		const CMSSteppingVerbose *	sv
	)

explicit

Definition at line 19 of file StackingAction.cc.

References caloRegions, deadRegionNames, deadRegions, gRRactive, gRusRoCastor, gRusRoEcal, gRusRoEnerLim, gRusRoHcal, gRusRoMuonIron, gRusRoPreShower, gRusRoWorld, mps_fire::i, initPointer(), killDeltaRay, killExtra, killGamma, killHeavy, killInCalo, killInCaloEfH, kmaxGamma, kmaxIon, kmaxNeutron, kmaxProton, limitEnergyForVacuum, lowdensRegions, visualization-live-secondInstance_cfg::m, maxTimeNames, maxTrackTime, maxTrackTimeForward, maxTrackTimes, maxZCentralCMS, muonRegions, newTA, nRRactive, nRusRoCastor, nRusRoEcal, nRusRoEnerLim, nRusRoHcal, nRusRoMuonIron, nRusRoPreShower, nRusRoWorld, numberTimes, AlCaHLTBitMon_ParallelJobs::p, printRegions(), regionCastor, regionEcal, regionHcal, regionMuonIron, regionPreShower, regionWorld, saveFirstSecondary, savePDandCinAll, savePDandCinCalo, savePDandCinMuon, savePDandCinTracker, trackerRegions, trackNeutrino, and worldSolid.

     : trackAction(trka), steppingVerbose(sv) {
   trackNeutrino = p.getParameter<bool>("TrackNeutrino");
   killHeavy = p.getParameter<bool>("KillHeavy");
   killGamma = p.getParameter<bool>("KillGamma");
   kmaxGamma = p.getParameter<double>("GammaThreshold") * CLHEP::MeV;
   kmaxIon = p.getParameter<double>("IonThreshold") * CLHEP::MeV;
   kmaxProton = p.getParameter<double>("ProtonThreshold") * CLHEP::MeV;
   kmaxNeutron = p.getParameter<double>("NeutronThreshold") * CLHEP::MeV;
   killDeltaRay = p.getParameter<bool>("KillDeltaRay");
   limitEnergyForVacuum = p.getParameter<double>("CriticalEnergyForVacuum") * CLHEP::MeV;
   maxTrackTime = p.getParameter<double>("MaxTrackTime") * ns;
   maxTrackTimeForward = p.getParameter<double>("MaxTrackTimeForward") * ns;
   maxZCentralCMS = p.getParameter<double>("MaxZCentralCMS") * CLHEP::m;
   maxTrackTimes = p.getParameter<std::vector<double> >("MaxTrackTimes");
   maxTimeNames = p.getParameter<std::vector<std::string> >("MaxTimeNames");
   deadRegionNames = p.getParameter<std::vector<std::string> >("DeadRegions");
   savePDandCinAll = p.getUntrackedParameter<bool>("SaveAllPrimaryDecayProductsAndConversions", true);
   savePDandCinTracker = p.getUntrackedParameter<bool>("SavePrimaryDecayProductsAndConversionsInTracker", false);
   savePDandCinCalo = p.getUntrackedParameter<bool>("SavePrimaryDecayProductsAndConversionsInCalo", false);
   savePDandCinMuon = p.getUntrackedParameter<bool>("SavePrimaryDecayProductsAndConversionsInMuon", false);
   saveFirstSecondary = p.getUntrackedParameter<bool>("SaveFirstLevelSecondary", false);
   killInCalo = false;
   killInCaloEfH = false;
 
   // Russian Roulette
   regionEcal = nullptr;
   regionHcal = nullptr;
   regionMuonIron = nullptr;
   regionPreShower = nullptr;
   regionCastor = nullptr;
   regionWorld = nullptr;
 
   gRusRoEnerLim = p.getParameter<double>("RusRoGammaEnergyLimit") * CLHEP::MeV;
   nRusRoEnerLim = p.getParameter<double>("RusRoNeutronEnergyLimit") * CLHEP::MeV;
 
   gRusRoEcal = p.getParameter<double>("RusRoEcalGamma");
   gRusRoHcal = p.getParameter<double>("RusRoHcalGamma");
   gRusRoMuonIron = p.getParameter<double>("RusRoMuonIronGamma");
   gRusRoPreShower = p.getParameter<double>("RusRoPreShowerGamma");
   gRusRoCastor = p.getParameter<double>("RusRoCastorGamma");
   gRusRoWorld = p.getParameter<double>("RusRoWorldGamma");
 
   nRusRoEcal = p.getParameter<double>("RusRoEcalNeutron");
   nRusRoHcal = p.getParameter<double>("RusRoHcalNeutron");
   nRusRoMuonIron = p.getParameter<double>("RusRoMuonIronNeutron");
   nRusRoPreShower = p.getParameter<double>("RusRoPreShowerNeutron");
   nRusRoCastor = p.getParameter<double>("RusRoCastorNeutron");
   nRusRoWorld = p.getParameter<double>("RusRoWorldNeutron");
 
   gRRactive = false;
   nRRactive = false;
   if (gRusRoEnerLim > 0.0 && (gRusRoEcal < 1.0 || gRusRoHcal < 1.0 || gRusRoMuonIron < 1.0 || gRusRoPreShower < 1.0 ||
                               gRusRoCastor < 1.0 || gRusRoWorld < 1.0)) {
     gRRactive = true;
   }
   if (nRusRoEnerLim > 0.0 && (nRusRoEcal < 1.0 || nRusRoHcal < 1.0 || nRusRoMuonIron < 1.0 || nRusRoPreShower < 1.0 ||
                               nRusRoCastor < 1.0 || nRusRoWorld < 1.0)) {
     nRRactive = true;
   }
 
   if (p.exists("TestKillingOptions")) {
     killInCalo = (p.getParameter<edm::ParameterSet>("TestKillingOptions")).getParameter<bool>("KillInCalo");
     killInCaloEfH = (p.getParameter<edm::ParameterSet>("TestKillingOptions")).getParameter<bool>("KillInCaloEfH");
     edm::LogWarning("SimG4CoreApplication")
         << " *** Activating special test killing options in StackingAction \n"
         << " *** Kill secondaries in Calorimetetrs volume = " << killInCalo << "\n"
         << " *** Kill electromagnetic secondaries from hadrons in Calorimeters volume= " << killInCaloEfH;
   }
 
   initPointer();
   newTA = new NewTrackAction();
 
   edm::LogVerbatim("SimG4CoreApplication")
       << "StackingAction initiated with"
       << " flag for saving decay products in "
       << " Tracker: " << savePDandCinTracker << " in Calo: " << savePDandCinCalo << " in Muon: " << savePDandCinMuon
       << " everywhere: " << savePDandCinAll << "\n  saveFirstSecondary"
       << ": " << saveFirstSecondary << " Tracking neutrino flag: " << trackNeutrino
       << " Kill Delta Ray flag: " << killDeltaRay << " Kill hadrons/ions flag: " << killHeavy
       << " MaxZCentralCMS = " << maxZCentralCMS / CLHEP::m << " m"
       << " MaxTrackTimeForward = " << maxTrackTimeForward / CLHEP::ns << " ns";
 
   if (killHeavy) {
     edm::LogVerbatim("SimG4CoreApplication") << "StackingAction kill protons below " << kmaxProton / CLHEP::MeV
                                              << " MeV, neutrons below " << kmaxNeutron / CLHEP::MeV << " MeV and ions"
                                              << " below " << kmaxIon / CLHEP::MeV << " MeV";
   }
   killExtra = killDeltaRay || killHeavy || killInCalo || killInCaloEfH;
 
   edm::LogVerbatim("SimG4CoreApplication") << "StackingAction kill tracks with "
                                            << "time larger than " << maxTrackTime / CLHEP::ns << " ns ";
   numberTimes = maxTimeNames.size();
   if (0 < numberTimes) {
     for (unsigned int i = 0; i < numberTimes; ++i) {
       edm::LogVerbatim("SimG4CoreApplication")
           << "          MaxTrackTime for " << maxTimeNames[i] << " is " << maxTrackTimes[i] << " ns ";
       maxTrackTimes[i] *= CLHEP::ns;
     }
   }
   if (limitEnergyForVacuum > 0.0) {
     edm::LogVerbatim("SimG4CoreApplication")
         << "StackingAction LowDensity regions - kill if E < " << limitEnergyForVacuum / CLHEP::MeV << " MeV";
     printRegions(lowdensRegions, "LowDensity");
   }
   if (deadRegions.size() > 0.0) {
     edm::LogVerbatim("SimG4CoreApplication") << "StackingAction Dead regions - kill all secondaries ";
     printRegions(deadRegions, "Dead");
   }
   if (gRRactive) {
     edm::LogVerbatim("SimG4CoreApplication")
         << "StackingAction: "
         << "Russian Roulette for gamma Elimit(MeV)= " << gRusRoEnerLim / CLHEP::MeV << "\n"
         << "                 ECAL Prob= " << gRusRoEcal << "\n"
         << "                 HCAL Prob= " << gRusRoHcal << "\n"
         << "             MuonIron Prob= " << gRusRoMuonIron << "\n"
         << "            PreShower Prob= " << gRusRoPreShower << "\n"
         << "               CASTOR Prob= " << gRusRoCastor << "\n"
         << "                World Prob= " << gRusRoWorld;
   }
   if (nRRactive) {
     edm::LogVerbatim("SimG4CoreApplication")
         << "StackingAction: "
         << "Russian Roulette for neutron Elimit(MeV)= " << nRusRoEnerLim / CLHEP::MeV << "\n"
         << "                 ECAL Prob= " << nRusRoEcal << "\n"
         << "                 HCAL Prob= " << nRusRoHcal << "\n"
         << "             MuonIron Prob= " << nRusRoMuonIron << "\n"
         << "            PreShower Prob= " << nRusRoPreShower << "\n"
         << "               CASTOR Prob= " << nRusRoCastor << "\n"
         << "                World Prob= " << nRusRoWorld;
   }
 
   if (savePDandCinTracker) {
     edm::LogVerbatim("SimG4CoreApplication") << "StackingAction Tracker regions: ";
     printRegions(trackerRegions, "Tracker");
   }
   if (savePDandCinCalo) {
     edm::LogVerbatim("SimG4CoreApplication") << "StackingAction Calo regions: ";
     printRegions(caloRegions, "Calo");
   }
   if (savePDandCinMuon) {
     edm::LogVerbatim("SimG4CoreApplication") << "StackingAction Muon regions: ";
     printRegions(muonRegions, "Muon");
   }
   worldSolid = G4TransportationManager::GetTransportationManager()
                    ->GetNavigatorForTracking()
                    ->GetWorldVolume()
                    ->GetLogicalVolume()
                    ->GetSolid();
 }

◆ ~StackingAction()

StackingAction::~StackingAction ( )

override

Definition at line 170 of file StackingAction.cc.

References newTA.

170 { delete newTA; }

StackingAction::newTA

NewTrackAction * newTA

Definition: StackingAction.h:74

Member Function Documentation

◆ ClassifyNewTrack()

G4ClassificationOfNewTrack StackingAction::ClassifyNewTrack ( const G4Track * aTrack )

final

Definition at line 172 of file StackingAction.cc.

References funct::abs(), caloRegions, deadRegions, RemoveAddSevLevel::flag, TrackingAction::geant4Track(), gRRactive, gRusRoCastor, gRusRoEcal, gRusRoEnerLim, gRusRoHcal, gRusRoMuonIron, gRusRoPreShower, gRusRoWorld, isItFromPrimary(), isItOutOfTimeWindow(), isItPrimaryDecayProductOrConversion(), isThisRegion(), killDeltaRay, killExtra, killGamma, killHeavy, killInCalo, killInCaloEfH, kmaxGamma, kmaxIon, kmaxNeutron, kmaxProton, limitEnergyForVacuum, LogDebug, lowdensRegions, maxTrackTimeForward, maxZCentralCMS, muonRegions, newTA, nRRactive, nRusRoCastor, nRusRoEcal, nRusRoEnerLim, nRusRoHcal, nRusRoMuonIron, nRusRoPreShower, nRusRoWorld, NewTrackAction::primary(), TtFullHadEvtBuilder_cfi::prob, ValidateTausOnZEEFastSim_cff::proc, regionCastor, regionEcal, regionHcal, regionMuonIron, regionPreShower, regionWorld, rrApplicable(), saveFirstSecondary, savePDandCinAll, savePDandCinCalo, savePDandCinMuon, savePDandCinTracker, NewTrackAction::secondary(), CMSSteppingVerbose::StackFilled(), steppingVerbose, protons_cff::time, HLT_2022v14_cff::track, trackAction, trackerRegions, trackNeutrino, and worldSolid.

                                                                                  {
   // G4 interface part
   G4ClassificationOfNewTrack classification = fUrgent;
   const int pdg = aTrack->GetDefinition()->GetPDGEncoding();
   const int abspdg = std::abs(pdg);
   auto track = const_cast<G4Track*>(aTrack);
 
   // primary
   if (aTrack->GetCreatorProcess() == nullptr || aTrack->GetParentID() == 0) {
     if (!trackNeutrino && (abspdg == 12 || abspdg == 14 || abspdg == 16 || abspdg == 18)) {
       classification = fKill;
     } else if (worldSolid->Inside(aTrack->GetPosition()) == kOutside) {
       classification = fKill;
     } else {
       newTA->primary(track);
     }
   } else {
     // secondary
     const G4Region* reg = aTrack->GetVolume()->GetLogicalVolume()->GetRegion();
     const double time = aTrack->GetGlobalTime();
 
     // definetly killed tracks
     if (aTrack->GetTrackStatus() == fStopAndKill) {
       classification = fKill;
     } else if (!trackNeutrino && (abspdg == 12 || abspdg == 14 || abspdg == 16 || abspdg == 18)) {
       classification = fKill;
 
     } else if (std::abs(aTrack->GetPosition().z()) >= maxZCentralCMS) {
       // very forward secondary
       if (time > maxTrackTimeForward) {
         classification = fKill;
       } else {
         const G4Track* mother = trackAction->geant4Track();
         newTA->secondary(track, *mother, 0);
       }
 
     } else if (isItOutOfTimeWindow(reg, time)) {
       // time window check
       classification = fKill;
 
     } else {
       // potentially good for tracking
       const double ke = aTrack->GetKineticEnergy();
       auto proc = aTrack->GetCreatorProcess();
       G4int subType = proc->GetProcessSubType();
       if (subType == 16) {
         auto ptr = static_cast<const G4GammaGeneralProcess*>(proc);
         proc = ptr->GetSelectedProcess();
         subType = proc->GetProcessSubType();
         track->SetCreatorProcess(proc);
       }
       LogDebug("SimG4CoreApplication") << "##StackingAction:Classify Track " << aTrack->GetTrackID() << " Parent "
                                        << aTrack->GetParentID() << " " << aTrack->GetDefinition()->GetParticleName()
                                        << " Ekin(MeV)=" << ke / CLHEP::MeV << " subType=" << subType << " "
                                        << proc->GetProcessName();
 
       // kill tracks in specific regions
       if (isThisRegion(reg, deadRegions)) {
         classification = fKill;
       }
       if (classification != fKill && ke <= limitEnergyForVacuum && isThisRegion(reg, lowdensRegions)) {
         classification = fKill;
 
       } else if (classification != fKill) {
         // very low-energy gamma
         if (pdg == 22 && killGamma && ke < kmaxGamma) {
           classification = fKill;
         }
 
         // specific track killing - not for production
         if (killExtra && classification != fKill) {
           if (killHeavy && classification != fKill) {
             if (((pdg / 1000000000 == 1) && (((pdg / 10000) % 100) > 0) && (((pdg / 10) % 100) > 0) &&
                  (ke < kmaxIon)) ||
                 ((pdg == 2212) && (ke < kmaxProton)) || ((pdg == 2112) && (ke < kmaxNeutron))) {
               classification = fKill;
             }
           }
 
           if (killDeltaRay && classification != fKill &&
               aTrack->GetCreatorProcess()->GetProcessSubType() == fIonisation) {
             classification = fKill;
           }
           if (killInCalo && classification != fKill && isThisRegion(reg, caloRegions)) {
             classification = fKill;
           }
           if (killInCaloEfH && classification != fKill) {
             int pdgMother = std::abs(trackAction->geant4Track()->GetDefinition()->GetPDGEncoding());
             if ((pdg == 22 || abspdg == 11) && pdgMother != 11 && pdgMother != 22 && isThisRegion(reg, caloRegions)) {
               classification = fKill;
             }
           }
         }
 
         // Russian roulette && MC truth
         if (classification != fKill) {
           const G4Track* mother = trackAction->geant4Track();
           int flag = 0;
           if (savePDandCinAll) {
             flag = isItPrimaryDecayProductOrConversion(aTrack, *mother);
           } else {
             if ((savePDandCinTracker && isThisRegion(reg, trackerRegions)) ||
                 (savePDandCinCalo && isThisRegion(reg, caloRegions)) ||
                 (savePDandCinMuon && isThisRegion(reg, muonRegions))) {
               flag = isItPrimaryDecayProductOrConversion(aTrack, *mother);
             }
           }
           if (saveFirstSecondary && 0 == flag) {
             flag = isItFromPrimary(*mother, flag);
           }
 
           // Russian roulette
           if (2112 == pdg || 22 == pdg) {
             double currentWeight = aTrack->GetWeight();
 
             if (1.0 >= currentWeight) {
               double prob = 1.0;
               double elim = 0.0;
 
               // neutron
               if (nRRactive && pdg == 2112) {
                 elim = nRusRoEnerLim;
                 if (reg == regionEcal) {
                   prob = nRusRoEcal;
                 } else if (reg == regionHcal) {
                   prob = nRusRoHcal;
                 } else if (reg == regionMuonIron) {
                   prob = nRusRoMuonIron;
                 } else if (reg == regionPreShower) {
                   prob = nRusRoPreShower;
                 } else if (reg == regionCastor) {
                   prob = nRusRoCastor;
                 } else if (reg == regionWorld) {
                   prob = nRusRoWorld;
                 }
 
                 // gamma
               } else if (gRRactive && pdg == 22) {
                 elim = gRusRoEnerLim;
                 if (reg == regionEcal || reg == regionPreShower) {
                   if (rrApplicable(aTrack, *mother)) {
                     if (reg == regionEcal) {
                       prob = gRusRoEcal;
                     } else {
                       prob = gRusRoPreShower;
                     }
                   }
                 } else {
                   if (reg == regionHcal) {
                     prob = gRusRoHcal;
                   } else if (reg == regionMuonIron) {
                     prob = gRusRoMuonIron;
                   } else if (reg == regionCastor) {
                     prob = gRusRoCastor;
                   } else if (reg == regionWorld) {
                     prob = gRusRoWorld;
                   }
                 }
               }
               if (prob < 1.0 && aTrack->GetKineticEnergy() < elim) {
                 if (G4UniformRand() < prob) {
                   track->SetWeight(currentWeight / prob);
                 } else {
                   classification = fKill;
                 }
               }
             }
           }
           if (classification != fKill) {
             newTA->secondary(track, *mother, flag);
           }
           LogDebug("SimG4CoreApplication")
               << "StackingAction:Classify Track " << aTrack->GetTrackID() << " Parent " << aTrack->GetParentID()
               << " Type " << aTrack->GetDefinition()->GetParticleName() << " Ekin=" << ke / CLHEP::MeV
               << " MeV from process " << proc->GetProcessName() << " subType=" << subType << " as " << classification
               << " Flag: " << flag;
         }
       }
     }
   }
   if (nullptr != steppingVerbose) {
     steppingVerbose->StackFilled(aTrack, (classification == fKill));
   }
   return classification;
 }

◆ initPointer()

void StackingAction::initPointer ( )

private

Definition at line 362 of file StackingAction.cc.

References caloRegions, deadRegionNames, deadRegions, gRusRoCastor, gRusRoEcal, gRusRoHcal, gRusRoMuonIron, gRusRoPreShower, gRusRoWorld, mps_fire::i, lowdensRegions, maxTimeNames, maxTimeRegions, muonRegions, nRusRoCastor, nRusRoEcal, nRusRoHcal, nRusRoMuonIron, nRusRoPreShower, nRusRoWorld, EgammaValidation_cff::num, regionCastor, regionEcal, regionHcal, regionMuonIron, regionPreShower, regionWorld, rname, savePDandCinCalo, savePDandCinMuon, savePDandCinTracker, and trackerRegions.

Referenced by StackingAction().

                                  {
   // prepare region vector
   const unsigned int num = maxTimeNames.size();
   maxTimeRegions.resize(num, nullptr);
 
   // Russian roulette
   const std::vector<G4Region*>* rs = G4RegionStore::GetInstance();
 
   for (auto& reg : *rs) {
     const G4String& rname = reg->GetName();
     if ((gRusRoEcal < 1.0 || nRusRoEcal < 1.0) && rname == "EcalRegion") {
       regionEcal = reg;
     }
     if ((gRusRoHcal < 1.0 || nRusRoHcal < 1.0) && rname == "HcalRegion") {
       regionHcal = reg;
     }
     if ((gRusRoMuonIron < 1.0 || nRusRoMuonIron < 1.0) && rname == "MuonIron") {
       regionMuonIron = reg;
     }
     if ((gRusRoPreShower < 1.0 || nRusRoPreShower < 1.0) && rname == "PreshowerRegion") {
       regionPreShower = reg;
     }
     if ((gRusRoCastor < 1.0 || nRusRoCastor < 1.0) && rname == "CastorRegion") {
       regionCastor = reg;
     }
     if ((gRusRoWorld < 1.0 || nRusRoWorld < 1.0) && rname == "DefaultRegionForTheWorld") {
       regionWorld = reg;
     }
 
     // time limits
     for (unsigned int i = 0; i < num; ++i) {
       if (rname == (G4String)(maxTimeNames[i])) {
         maxTimeRegions[i] = reg;
         break;
       }
     }
     //
     if (savePDandCinTracker &&
         (rname == "BeamPipe" || rname == "BeamPipeVacuum" || rname == "TrackerPixelSensRegion" ||
          rname == "TrackerPixelDeadRegion" || rname == "TrackerDeadRegion" || rname == "TrackerSensRegion" ||
          rname == "FastTimerRegion" || rname == "FastTimerRegionSensBTL" || rname == "FastTimerRegionSensETL")) {
       trackerRegions.push_back(reg);
     }
     if (savePDandCinCalo && (rname == "HcalRegion" || rname == "EcalRegion" || rname == "PreshowerSensRegion" ||
                              rname == "PreshowerRegion" || rname == "APDRegion" || rname == "HGCalRegion")) {
       caloRegions.push_back(reg);
     }
     if (savePDandCinMuon && (rname == "MuonChamber" || rname == "MuonSensitive_RPC" || rname == "MuonIron" ||
                              rname == "Muon" || rname == "MuonSensitive_DT-CSC")) {
       muonRegions.push_back(reg);
     }
     if (rname == "BeamPipeOutside" || rname == "BeamPipeVacuum") {
       lowdensRegions.push_back(reg);
     }
     for (auto& dead : deadRegionNames) {
       if (rname == (G4String)(dead)) {
         deadRegions.push_back(reg);
       }
     }
   }
 }

◆ isItFromPrimary()

int StackingAction::isItFromPrimary	(	const G4Track &	mother,
		int	flagIn
	)		const

private

Definition at line 457 of file StackingAction.cc.

References extractor, RemoveAddSevLevel::flag, and TrackInformation::isPrimary().

Referenced by ClassifyNewTrack().

                                                                            {
   int flag = flagIn;
   if (flag != 1) {
     const TrackInformation& motherInfo(extractor(mother));
     if (motherInfo.isPrimary()) {
       flag = 3;
     }
   }
   return flag;
 }

◆ isItOutOfTimeWindow()

bool StackingAction::isItOutOfTimeWindow	(	const G4Region *	reg,
		const double &	t
	)		const

private

Definition at line 468 of file StackingAction.cc.

References mps_fire::i, maxTimeRegions, maxTrackTime, maxTrackTimes, numberTimes, and submitPVValidationJobs::t.

Referenced by ClassifyNewTrack().

                                                                                    {
   double tofM = maxTrackTime;
   for (unsigned int i = 0; i < numberTimes; ++i) {
     if (reg == maxTimeRegions[i]) {
       tofM = maxTrackTimes[i];
       break;
     }
   }
   return (t > tofM);
 }

◆ isItPrimaryDecayProductOrConversion()

int StackingAction::isItPrimaryDecayProductOrConversion	(	const G4Track *	aTrack,
		const G4Track &	mother
	)		const

private

Definition at line 435 of file StackingAction.cc.

References extractor, hydjet2DefaultParameters_cff::fDecay, RemoveAddSevLevel::flag, and TrackInformation::isPrimary().

Referenced by ClassifyNewTrack().

                                                                                                           {
   int flag = 0;
   const TrackInformation& motherInfo(extractor(mother));
   // Check whether mother is a primary
   if (motherInfo.isPrimary()) {
     if (aTrack->GetCreatorProcess()->GetProcessType() == fDecay) {
       flag = 1;
     } else if (aTrack->GetCreatorProcess()->GetProcessSubType() == fGammaConversion) {
       flag = 2;
     }
   }
   return flag;
 }

◆ isThisRegion()

bool StackingAction::isThisRegion	(	const G4Region *	reg,
		std::vector< const G4Region *> &	regions
	)		const

private

Definition at line 424 of file StackingAction.cc.

References RemoveAddSevLevel::flag, and HLT_2022v14_cff::region.

Referenced by ClassifyNewTrack().

                                                                                                 {
   bool flag = false;
   for (auto& region : regions) {
     if (reg == region) {
       flag = true;
       break;
     }
   }
   return flag;
 }

◆ NewStage()

void StackingAction::NewStage ( )

override

Definition at line 358 of file StackingAction.cc.

358 {}

◆ PrepareNewEvent()

void StackingAction::PrepareNewEvent ( )

override

Definition at line 360 of file StackingAction.cc.

360 {}

◆ printRegions()

void StackingAction::printRegions	(	const std::vector< const G4Region *> &	reg,
		const std::string &	word
	)		const

private

Definition at line 479 of file StackingAction.cc.

References mps_fire::i.

Referenced by StackingAction().

                                                                                                     {
   for (unsigned int i = 0; i < reg.size(); ++i) {
     edm::LogVerbatim("SimG4CoreApplication")
         << " StackingAction: " << word << "Region " << i << ". " << reg[i]->GetName();
   }
 }

◆ rrApplicable()

bool StackingAction::rrApplicable	(	const G4Track *	aTrack,
		const G4Track &	mother
	)		const

private

Definition at line 449 of file StackingAction.cc.

References funct::abs(), extractor, and TrackInformation::genParticlePID().

Referenced by ClassifyNewTrack().

                                                                                     {
   const TrackInformation& motherInfo(extractor(mother));
 
   // Check whether mother is gamma, e+, e-
   const int genID = motherInfo.genParticlePID();
   return (22 != genID && 11 != std::abs(genID));
 }

Member Data Documentation

◆ caloRegions

std::vector<const G4Region*> StackingAction::caloRegions

private

Definition at line 67 of file StackingAction.h.

Referenced by ClassifyNewTrack(), initPointer(), and StackingAction().

◆ deadRegionNames

std::vector<std::string> StackingAction::deadRegionNames

private

Definition at line 62 of file StackingAction.h.

Referenced by initPointer(), and StackingAction().

◆ deadRegions

std::vector<const G4Region*> StackingAction::deadRegions

private

Definition at line 69 of file StackingAction.h.

Referenced by ClassifyNewTrack(), initPointer(), and StackingAction().

◆ extractor

TrackInformationExtractor StackingAction::extractor

private

Definition at line 75 of file StackingAction.h.

Referenced by isItFromPrimary(), isItPrimaryDecayProductOrConversion(), and rrApplicable().

◆ gRRactive

bool StackingAction::gRRactive

private

Definition at line 103 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

◆ gRusRoCastor

double StackingAction::gRusRoCastor

private

Definition at line 98 of file StackingAction.h.

Referenced by ClassifyNewTrack(), initPointer(), and StackingAction().

◆ gRusRoEcal

double StackingAction::gRusRoEcal

private

Definition at line 90 of file StackingAction.h.

Referenced by ClassifyNewTrack(), initPointer(), and StackingAction().

◆ gRusRoEnerLim

double StackingAction::gRusRoEnerLim

private

Definition at line 86 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

◆ gRusRoHcal

double StackingAction::gRusRoHcal

private

Definition at line 92 of file StackingAction.h.

Referenced by ClassifyNewTrack(), initPointer(), and StackingAction().

◆ gRusRoMuonIron

double StackingAction::gRusRoMuonIron

private

Definition at line 94 of file StackingAction.h.

Referenced by ClassifyNewTrack(), initPointer(), and StackingAction().

◆ gRusRoPreShower

double StackingAction::gRusRoPreShower

private

Definition at line 96 of file StackingAction.h.

Referenced by ClassifyNewTrack(), initPointer(), and StackingAction().

◆ gRusRoWorld

double StackingAction::gRusRoWorld

private

Definition at line 100 of file StackingAction.h.

Referenced by ClassifyNewTrack(), initPointer(), and StackingAction().

◆ killDeltaRay

bool StackingAction::killDeltaRay

private

Definition at line 50 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

◆ killExtra

bool StackingAction::killExtra

private

Definition at line 51 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

◆ killGamma

bool StackingAction::killGamma

private

Definition at line 52 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

◆ killHeavy

bool StackingAction::killHeavy

private

Definition at line 50 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

◆ killInCalo

bool StackingAction::killInCalo

private

Definition at line 49 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

◆ killInCaloEfH

bool StackingAction::killInCaloEfH

private

Definition at line 49 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

◆ kmaxGamma

double StackingAction::kmaxGamma

private

Definition at line 55 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

◆ kmaxIon

double StackingAction::kmaxIon

private

Definition at line 54 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

◆ kmaxNeutron

double StackingAction::kmaxNeutron

private

Definition at line 54 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

◆ kmaxProton

double StackingAction::kmaxProton

private

Definition at line 54 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

◆ limitEnergyForVacuum

double StackingAction::limitEnergyForVacuum

private

Definition at line 53 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

◆ lowdensRegions

std::vector<const G4Region*> StackingAction::lowdensRegions

private

Definition at line 68 of file StackingAction.h.

Referenced by ClassifyNewTrack(), initPointer(), and StackingAction().

◆ maxTimeNames

std::vector<std::string> StackingAction::maxTimeNames

private

Definition at line 61 of file StackingAction.h.

Referenced by initPointer(), and StackingAction().

◆ maxTimeRegions

std::vector<const G4Region*> StackingAction::maxTimeRegions

private

Definition at line 64 of file StackingAction.h.

Referenced by initPointer(), and isItOutOfTimeWindow().

◆ maxTrackTime

double StackingAction::maxTrackTime

private

Definition at line 56 of file StackingAction.h.

Referenced by isItOutOfTimeWindow(), and StackingAction().

◆ maxTrackTimeForward

double StackingAction::maxTrackTimeForward

private

Definition at line 57 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

◆ maxTrackTimes

std::vector<double> StackingAction::maxTrackTimes

private

Definition at line 60 of file StackingAction.h.

Referenced by isItOutOfTimeWindow(), and StackingAction().

◆ maxZCentralCMS

double StackingAction::maxZCentralCMS

private

Definition at line 58 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

◆ muonRegions

std::vector<const G4Region*> StackingAction::muonRegions

private

Definition at line 66 of file StackingAction.h.

Referenced by ClassifyNewTrack(), initPointer(), and StackingAction().

◆ newTA

NewTrackAction* StackingAction::newTA

private

Definition at line 74 of file StackingAction.h.

Referenced by ClassifyNewTrack(), StackingAction(), and ~StackingAction().

◆ nRRactive

bool StackingAction::nRRactive

private

Definition at line 104 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

◆ nRusRoCastor

double StackingAction::nRusRoCastor

private

Definition at line 99 of file StackingAction.h.

Referenced by ClassifyNewTrack(), initPointer(), and StackingAction().

◆ nRusRoEcal

double StackingAction::nRusRoEcal

private

Definition at line 91 of file StackingAction.h.

Referenced by ClassifyNewTrack(), initPointer(), and StackingAction().

◆ nRusRoEnerLim

double StackingAction::nRusRoEnerLim

private

Definition at line 87 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

◆ nRusRoHcal

double StackingAction::nRusRoHcal

private

Definition at line 93 of file StackingAction.h.

Referenced by ClassifyNewTrack(), initPointer(), and StackingAction().

◆ nRusRoMuonIron

double StackingAction::nRusRoMuonIron

private

Definition at line 95 of file StackingAction.h.

Referenced by ClassifyNewTrack(), initPointer(), and StackingAction().

◆ nRusRoPreShower

double StackingAction::nRusRoPreShower

private

Definition at line 97 of file StackingAction.h.

Referenced by ClassifyNewTrack(), initPointer(), and StackingAction().

◆ nRusRoWorld

double StackingAction::nRusRoWorld

private

Definition at line 101 of file StackingAction.h.

Referenced by ClassifyNewTrack(), initPointer(), and StackingAction().

◆ numberTimes

unsigned int StackingAction::numberTimes

private

Definition at line 59 of file StackingAction.h.

Referenced by isItOutOfTimeWindow(), and StackingAction().

◆ regionCastor

const G4Region* StackingAction::regionCastor

private

Definition at line 82 of file StackingAction.h.

Referenced by ClassifyNewTrack(), initPointer(), and StackingAction().

◆ regionEcal

const G4Region* StackingAction::regionEcal

private

Definition at line 78 of file StackingAction.h.

Referenced by ClassifyNewTrack(), initPointer(), and StackingAction().

◆ regionHcal

const G4Region* StackingAction::regionHcal

private

Definition at line 79 of file StackingAction.h.

Referenced by ClassifyNewTrack(), initPointer(), and StackingAction().

◆ regionMuonIron

const G4Region* StackingAction::regionMuonIron

private

Definition at line 80 of file StackingAction.h.

Referenced by ClassifyNewTrack(), initPointer(), and StackingAction().

◆ regionPreShower

const G4Region* StackingAction::regionPreShower

private

Definition at line 81 of file StackingAction.h.

Referenced by ClassifyNewTrack(), initPointer(), and StackingAction().

◆ regionWorld

const G4Region* StackingAction::regionWorld

private

Definition at line 83 of file StackingAction.h.

Referenced by ClassifyNewTrack(), initPointer(), and StackingAction().

◆ saveFirstSecondary

bool StackingAction::saveFirstSecondary

private

Definition at line 47 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

◆ savePDandCinAll

bool StackingAction::savePDandCinAll

private

Definition at line 48 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

◆ savePDandCinCalo

bool StackingAction::savePDandCinCalo

private

Definition at line 46 of file StackingAction.h.

Referenced by ClassifyNewTrack(), initPointer(), and StackingAction().

◆ savePDandCinMuon

bool StackingAction::savePDandCinMuon

private

Definition at line 47 of file StackingAction.h.

Referenced by ClassifyNewTrack(), initPointer(), and StackingAction().

◆ savePDandCinTracker

bool StackingAction::savePDandCinTracker

private

Definition at line 46 of file StackingAction.h.

Referenced by ClassifyNewTrack(), initPointer(), and StackingAction().

◆ steppingVerbose

const CMSSteppingVerbose* StackingAction::steppingVerbose

private

Definition at line 73 of file StackingAction.h.

Referenced by ClassifyNewTrack().

◆ trackAction

const TrackingAction* StackingAction::trackAction

private

Definition at line 72 of file StackingAction.h.

Referenced by ClassifyNewTrack().

◆ trackerRegions

std::vector<const G4Region*> StackingAction::trackerRegions

private

Definition at line 65 of file StackingAction.h.

Referenced by ClassifyNewTrack(), initPointer(), and StackingAction().

◆ trackNeutrino

bool StackingAction::trackNeutrino

private

Definition at line 50 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

◆ worldSolid

G4VSolid* StackingAction::worldSolid

private

Definition at line 71 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ StackingAction()

◆ ~StackingAction()

Member Function Documentation

◆ ClassifyNewTrack()

◆ initPointer()

◆ isItFromPrimary()

◆ isItOutOfTimeWindow()

◆ isItPrimaryDecayProductOrConversion()

◆ isThisRegion()

◆ NewStage()

◆ PrepareNewEvent()

◆ printRegions()

◆ rrApplicable()

Member Data Documentation

◆ caloRegions

◆ deadRegionNames

◆ deadRegions

◆ extractor

◆ gRRactive

◆ gRusRoCastor

◆ gRusRoEcal

◆ gRusRoEnerLim

◆ gRusRoHcal

◆ gRusRoMuonIron

◆ gRusRoPreShower

◆ gRusRoWorld

◆ killDeltaRay

◆ killExtra

◆ killGamma

◆ killHeavy

◆ killInCalo

◆ killInCaloEfH

◆ kmaxGamma

◆ kmaxIon

◆ kmaxNeutron

◆ kmaxProton

◆ limitEnergyForVacuum

◆ lowdensRegions

◆ maxTimeNames

◆ maxTimeRegions

◆ maxTrackTime

◆ maxTrackTimeForward

◆ maxTrackTimes

◆ maxZCentralCMS

◆ muonRegions

◆ newTA

◆ nRRactive

◆ nRusRoCastor

◆ nRusRoEcal

◆ nRusRoEnerLim

◆ nRusRoHcal

◆ nRusRoMuonIron

◆ nRusRoPreShower

◆ nRusRoWorld

◆ numberTimes

◆ regionCastor

◆ regionEcal

◆ regionHcal

◆ regionMuonIron

◆ regionPreShower

◆ regionWorld

◆ saveFirstSecondary

◆ savePDandCinAll

◆ savePDandCinCalo

◆ savePDandCinMuon

◆ savePDandCinTracker

◆ steppingVerbose

◆ trackAction

◆ trackerRegions

◆ trackNeutrino

◆ worldSolid