StackingAction Class Reference

#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=default

Private Member Functions
void	initPointer ()
int	isItFromPrimary (const G4Track &, int) const
bool	isItOutOfTimeWindow (const G4Region *, const double &) const
int	isItPrimaryDecayProductOrConversion (const int subtype, 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
bool	gRRactive {false}
double	gRusRoCastor
double	gRusRoEcal
double	gRusRoEnerLim
double	gRusRoHcal
double	gRusRoMuonIron
double	gRusRoPreShower
double	gRusRoWorld
bool	killDeltaRay
bool	killExtra
bool	killGamma
bool	killHeavy
bool	killInCalo {false}
bool	killInCaloEfH {false}
double	kmaxGamma
double	kmaxIon
double	kmaxNeutron
double	kmaxProton
double	limitEnergyForVacuum
std::vector< const G4Region * >	lowdensRegions
const G4VProcess *	m_Compton {nullptr}
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
bool	nRRactive {false}
double	nRusRoCastor
double	nRusRoEcal
double	nRusRoEnerLim
double	nRusRoHcal
double	nRusRoMuonIron
double	nRusRoPreShower
double	nRusRoWorld
unsigned int	numberTimes
const G4Region *	regionCastor {nullptr}
const G4Region *	regionEcal {nullptr}
const G4Region *	regionHcal {nullptr}
const G4Region *	regionMuonIron {nullptr}
const G4Region *	regionPreShower {nullptr}
const G4Region *	regionWorld {nullptr}
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 18 of file StackingAction.h.

Constructor & Destructor Documentation

StackingAction()

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

explicit

Definition at line 20 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, nRRactive, nRusRoCastor, nRusRoEcal, nRusRoEnerLim, nRusRoHcal, nRusRoMuonIron, nRusRoPreShower, nRusRoWorld, numberTimes, AlCaHLTBitMon_ParallelJobs::p, printRegions(), 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);

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

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

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

overridedefault

Member Function Documentation

ClassifyNewTrack()

G4ClassificationOfNewTrack StackingAction::ClassifyNewTrack ( const G4Track *  aTrack )

final

Definition at line 158 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, nRRactive, nRusRoCastor, nRusRoEcal, nRusRoEnerLim, nRusRoHcal, nRusRoMuonIron, nRusRoPreShower, nRusRoWorld, MCTruthUtil::primary(), TtFullHadEvtBuilder_cfi::prob, regionCastor, regionEcal, regionHcal, regionMuonIron, regionPreShower, regionWorld, rrApplicable(), saveFirstSecondary, savePDandCinAll, savePDandCinCalo, savePDandCinMuon, savePDandCinTracker, MCTruthUtil::secondary(), CMSSteppingVerbose::stackFilled(), steppingVerbose, protons_cff::time, HLT_2023v12_cff::track, trackAction, trackerRegions, trackNeutrino, and worldSolid.

Referenced by CMSSimEventManager::StackTracks().

                                                                                 {
  // G4 interface part
  G4ClassificationOfNewTrack classification = fUrgent;
  const int pdg = aTrack->GetDefinition()->GetPDGEncoding();
  const int abspdg = std::abs(pdg);
  auto track = const_cast<G4Track*>(aTrack);
  const G4VProcess* creatorProc = aTrack->GetCreatorProcess();

  if (creatorProc == nullptr && aTrack->GetParentID() != 0) {
    edm::LogWarning("StackingAction::ClassifyNewTrack")
        << " TrackID=" << aTrack->GetTrackID() << " ParentID=" << aTrack->GetParentID() << " "
        << aTrack->GetDefinition()->GetParticleName() << " Ekin(MeV)=" << aTrack->GetKineticEnergy();
  }
  if (aTrack->GetKineticEnergy() < 0.0) {
    edm::LogWarning("StackingAction::ClassifyNewTrack")
        << " TrackID=" << aTrack->GetTrackID() << " ParentID=" << aTrack->GetParentID() << " "
        << aTrack->GetDefinition()->GetParticleName() << " Ekin(MeV)=" << aTrack->GetKineticEnergy() << " creator "
        << creatorProc->GetProcessName();
  }
  // primary
  if (creatorProc == 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 {
      MCTruthUtil::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();
        MCTruthUtil::secondary(track, *mother, 0);
      }

    } else if (isItOutOfTimeWindow(reg, time)) {
      // time window check
      classification = fKill;

    } else {
      // potentially good for tracking
      const double ke = aTrack->GetKineticEnergy();
      G4int subType = (nullptr != creatorProc) ? creatorProc->GetProcessSubType() : 0;

      LogDebug("SimG4CoreApplication") << "##StackingAction:Classify Track " << aTrack->GetTrackID() << " Parent "
                                       << aTrack->GetParentID() << " " << aTrack->GetDefinition()->GetParticleName()
                                       << " Ekin(MeV)=" << ke / CLHEP::MeV << " subType=" << subType << " ";

      // 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 && subType == 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(subType, *mother);
          } else {
            if ((savePDandCinTracker && isThisRegion(reg, trackerRegions)) ||
                (savePDandCinCalo && isThisRegion(reg, caloRegions)) ||
                (savePDandCinMuon && isThisRegion(reg, muonRegions))) {
              flag = isItPrimaryDecayProductOrConversion(subType, *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) {
            MCTruthUtil::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 subType=" << subType << " as " << classification << " Flag: " << flag;
        }
      }
    }
  }
  if (nullptr != steppingVerbose) {
    steppingVerbose->stackFilled(aTrack, (classification == fKill));
  }
  return classification;
}

initPointer()

void StackingAction::initPointer ( )

private

Definition at line 351 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 == "FastTimerRegionBTL" || rname == "FastTimerRegionETL" || 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 447 of file StackingAction.cc.

References RemoveAddSevLevel::flag.

Referenced by ClassifyNewTrack().

                                                                           {
  int flag = flagIn;
  if (flag != 1) {
    auto ptr = static_cast<const TrackInformation*>(mother.GetUserInformation());
    if (ptr->isPrimary()) {
      flag = 3;
    }
  }
  return flag;
}

isItOutOfTimeWindow()

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

private

Definition at line 458 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 int  subtype, const G4Track &  mother  ) const

private

Definition at line 425 of file StackingAction.cc.

References hydjet2DefaultParameters_cff::fDecay, and RemoveAddSevLevel::flag.

Referenced by ClassifyNewTrack().

                                                                                                    {
  int flag = 0;
  auto motherInfo = static_cast<const TrackInformation*>(mother.GetUserInformation());
  // Check whether mother is a primary
  if (motherInfo->isPrimary()) {
    if (stype == fDecay) {
      flag = 1;
    } else if (stype == fGammaConversion) {
      flag = 2;
    }
  }
  return flag;
}

isThisRegion()

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

private

Definition at line 414 of file StackingAction.cc.

References RemoveAddSevLevel::flag, and HLT_2023v12_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 347 of file StackingAction.cc.

{}

PrepareNewEvent()

void StackingAction::PrepareNewEvent ( )

override

Definition at line 349 of file StackingAction.cc.

{}

printRegions()

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

private

Definition at line 469 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 439 of file StackingAction.cc.

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

Referenced by ClassifyNewTrack().

                                                                                    {
  auto motherInfo = static_cast<const TrackInformation*>(mother.GetUserInformation());

  // 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().

gRRactive

bool StackingAction::gRRactive {false}

private

Definition at line 102 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

gRusRoCastor

double StackingAction::gRusRoCastor

private

Definition at line 97 of file StackingAction.h.

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

gRusRoEcal

double StackingAction::gRusRoEcal

private

Definition at line 89 of file StackingAction.h.

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

gRusRoEnerLim

double StackingAction::gRusRoEnerLim

private

Definition at line 85 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

gRusRoHcal

double StackingAction::gRusRoHcal

private

Definition at line 91 of file StackingAction.h.

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

gRusRoMuonIron

double StackingAction::gRusRoMuonIron

private

Definition at line 93 of file StackingAction.h.

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

gRusRoPreShower

double StackingAction::gRusRoPreShower

private

Definition at line 95 of file StackingAction.h.

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

gRusRoWorld

double StackingAction::gRusRoWorld

private

Definition at line 99 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 {false}

private

Definition at line 48 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

killInCaloEfH

bool StackingAction::killInCaloEfH {false}

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

m_Compton

const G4VProcess* StackingAction::m_Compton {nullptr}

private

Definition at line 74 of file StackingAction.h.

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

nRRactive

bool StackingAction::nRRactive {false}

private

Definition at line 103 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

nRusRoCastor

double StackingAction::nRusRoCastor

private

Definition at line 98 of file StackingAction.h.

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

nRusRoEcal

double StackingAction::nRusRoEcal

private

Definition at line 90 of file StackingAction.h.

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

nRusRoEnerLim

double StackingAction::nRusRoEnerLim

private

Definition at line 86 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

nRusRoHcal

double StackingAction::nRusRoHcal

private

Definition at line 92 of file StackingAction.h.

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

nRusRoMuonIron

double StackingAction::nRusRoMuonIron

private

Definition at line 94 of file StackingAction.h.

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

nRusRoPreShower

double StackingAction::nRusRoPreShower

private

Definition at line 96 of file StackingAction.h.

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

nRusRoWorld

double StackingAction::nRusRoWorld

private

Definition at line 100 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 {nullptr}

private

Definition at line 81 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and initPointer().

regionEcal

const G4Region* StackingAction::regionEcal {nullptr}

private

Definition at line 77 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and initPointer().

regionHcal

const G4Region* StackingAction::regionHcal {nullptr}

private

Definition at line 78 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and initPointer().

regionMuonIron

const G4Region* StackingAction::regionMuonIron {nullptr}

private

Definition at line 79 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and initPointer().

regionPreShower

const G4Region* StackingAction::regionPreShower {nullptr}

private

Definition at line 80 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and initPointer().

regionWorld

const G4Region* StackingAction::regionWorld {nullptr}

private

Definition at line 82 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and initPointer().

saveFirstSecondary

bool StackingAction::saveFirstSecondary

private

Definition at line 46 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

savePDandCinAll

bool StackingAction::savePDandCinAll

private

Definition at line 47 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

savePDandCinCalo

bool StackingAction::savePDandCinCalo

private

Definition at line 45 of file StackingAction.h.

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

savePDandCinMuon

bool StackingAction::savePDandCinMuon

private

Definition at line 46 of file StackingAction.h.

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

savePDandCinTracker

bool StackingAction::savePDandCinTracker

private

Definition at line 45 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().