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

Private Member Functions
void	initPointer ()
int	isItFromPrimary (const G4Track &, int) const
bool	isItOutOfTimeWindow (const G4Region *, const G4Track *) 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
std::vector< double >	maxTrackTimes
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 ( const TrackingAction *  trka, const edm::ParameterSet &  ps, const CMSSteppingVerbose *  sv  )

explicit

Definition at line 18 of file StackingAction.cc.

References caloRegions, deadRegionNames, deadRegions, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), gRRactive, gRusRoCastor, gRusRoEcal, gRusRoEnerLim, gRusRoHcal, gRusRoMuonIron, gRusRoPreShower, gRusRoWorld, mps_fire::i, initPointer(), killDeltaRay, killExtra, killGamma, killHeavy, killInCalo, killInCaloEfH, kmaxGamma, kmaxIon, kmaxNeutron, kmaxProton, limitEnergyForVacuum, lowdensRegions, maxTimeNames, maxTrackTime, maxTrackTimes, MeV, muonRegions, newTA, nRRactive, nRusRoCastor, nRusRoEcal, nRusRoEnerLim, nRusRoHcal, nRusRoMuonIron, nRusRoPreShower, nRusRoWorld, numberTimes, 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")*MeV;
  kmaxIon        = p.getParameter<double>("IonThreshold")*MeV;
  kmaxProton     = p.getParameter<double>("ProtonThreshold")*MeV;
  kmaxNeutron    = p.getParameter<double>("NeutronThreshold")*MeV;
  killDeltaRay   = p.getParameter<bool>("KillDeltaRay");
  limitEnergyForVacuum = p.getParameter<double>("CriticalEnergyForVacuum")*MeV;
  maxTrackTime   = p.getParameter<double>("MaxTrackTime")*ns;
  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")*MeV;
  nRusRoEnerLim = p.getParameter<double>("RusRoNeutronEnergyLimit")*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::LogInfo("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;


  if(killHeavy) {
    edm::LogInfo("SimG4CoreApplication") << "StackingAction kill protons below " 
                     << kmaxProton/MeV <<" MeV, neutrons below "
                     << kmaxNeutron/MeV << " MeV and ions"
                     << " below " << kmaxIon/MeV << " MeV";
  }
  killExtra = killDeltaRay || killHeavy || killInCalo || killInCaloEfH;

  edm::LogInfo("SimG4CoreApplication") << "StackingAction kill tracks with "
                       << "time larger than " << maxTrackTime/ns
                       << " ns ";
  numberTimes = maxTimeNames.size(); 
  if(0 < numberTimes) {
    for (unsigned int i=0; i<numberTimes; ++i) {
      edm::LogInfo("SimG4CoreApplication") << "StackingAction MaxTrackTime for "
                       << maxTimeNames[i] << " is " 
                       << maxTrackTimes[i] << " ns ";
      maxTrackTimes[i] *= ns;
    }
  }
  if(limitEnergyForVacuum > 0.0) {
    edm::LogInfo("SimG4CoreApplication") 
      << "StackingAction LowDensity regions - kill if E < " 
      << limitEnergyForVacuum/MeV << " MeV";
    printRegions(lowdensRegions,"LowDensity"); 
  }
  if(deadRegions.size() > 0.0) {
    edm::LogInfo("SimG4CoreApplication") 
      << "StackingAction Dead regions - kill all secondaries ";
    printRegions(deadRegions, "Dead"); 
  }
  if(gRRactive) {
    edm::LogInfo("SimG4CoreApplication") 
      << "StackingAction: "
      << "Russian Roulette for gamma Elimit(MeV)= " 
      << gRusRoEnerLim/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::LogInfo("SimG4CoreApplication") 
      << "StackingAction: "
      << "Russian Roulette for neutron Elimit(MeV)= " 
      << nRusRoEnerLim/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::LogInfo("SimG4CoreApplication") << "StackingAction Tracker regions: ";
    printRegions(trackerRegions,"Tracker"); 
  }
  if(savePDandCinCalo) {
    edm::LogInfo("SimG4CoreApplication") << "StackingAction Calo regions: ";
    printRegions(caloRegions, "Calo"); 
  }
  if(savePDandCinMuon) {
    edm::LogInfo("SimG4CoreApplication") << "StackingAction Muon regions: ";
    printRegions(muonRegions,"Muon"); 
  }
  worldSolid = G4TransportationManager::GetTransportationManager()->GetNavigatorForTracking()->GetWorldVolume()->GetLogicalVolume()->GetSolid();
}

StackingAction::~StackingAction ( )

override

Definition at line 191 of file StackingAction.cc.

References newTA.

{
  delete newTA;
}

Member Function Documentation

G4ClassificationOfNewTrack StackingAction::ClassifyNewTrack ( const G4Track *  aTrack )

final

Definition at line 196 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(), ke, killDeltaRay, killExtra, killGamma, killHeavy, killInCalo, killInCaloEfH, kmaxGamma, kmaxIon, kmaxNeutron, kmaxProton, limitEnergyForVacuum, LogDebug, lowdensRegions, MeV, muonRegions, newTA, nRRactive, nRusRoCastor, nRusRoEcal, nRusRoEnerLim, nRusRoHcal, nRusRoMuonIron, nRusRoPreShower, nRusRoWorld, NewTrackAction::primary(), TtFullHadEvtBuilder_cfi::prob, regionCastor, regionEcal, regionHcal, regionMuonIron, regionPreShower, regionWorld, rrApplicable(), saveFirstSecondary, savePDandCinAll, savePDandCinCalo, savePDandCinMuon, savePDandCinTracker, NewTrackAction::secondary(), CMSSteppingVerbose::StackFilled(), steppingVerbose, trackAction, trackerRegions, trackNeutrino, and worldSolid.

{
  // G4 interface part
  G4ClassificationOfNewTrack classification = fUrgent;
  int pdg = aTrack->GetDefinition()->GetPDGEncoding();
  int abspdg = std::abs(pdg);

  // 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(aTrack);
    }
  } else {

    // secondary
    const G4Region* reg = aTrack->GetVolume()->GetLogicalVolume()->GetRegion();
    // definetly killed tracks
    if (aTrack->GetTrackStatus() == fStopAndKill) { classification = fKill; }
    else if (!trackNeutrino && (abspdg == 12 || abspdg == 14 || abspdg == 16 || abspdg == 18)) 
      { classification = fKill; }
    else if (isItOutOfTimeWindow(reg, aTrack)) { classification = fKill; }

    // potentially good for tracking
    else {
      double ke  = aTrack->GetKineticEnergy();

      // kill tracks in specific regions
      if (classification != fKill && isThisRegion(reg, deadRegions)) {
    classification = fKill; 
      }
      if (ke <= limitEnergyForVacuum && isThisRegion(reg, lowdensRegions) ) {
    classification = fKill; 

      } else {
    // 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) {
          const_cast<G4Track*>(aTrack)->SetWeight(currentWeight/prob);
        } else {
          classification = fKill;
        }
          }
        }
      }
      if (classification != fKill) {
        newTA->secondary(aTrack, *mother, flag);
      }
      LogDebug("SimG4CoreApplication") << "StackingAction:Classify Track "
                       << aTrack->GetTrackID() << " Parent " 
                       << aTrack->GetParentID() << " Type "
                       << aTrack->GetDefinition()->GetParticleName() 
                       << " K.E. " << aTrack->GetKineticEnergy()/MeV
                       << " MeV from process/subprocess " 
                       << aTrack->GetCreatorProcess()->GetProcessType() 
                       << "|"
                       <<aTrack->GetCreatorProcess()->GetProcessSubType()
                       << " as " << classification << " Flag " << flag;
    }
      }
    }
  }
  if(nullptr != steppingVerbose) { 
    steppingVerbose->StackFilled(aTrack, (classification == fKill)); 
  }
  return classification;
}

void StackingAction::initPointer ( )

private

Definition at line 349 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, pileupDistInMC::num, regionCastor, regionEcal, regionHcal, regionMuonIron, regionPreShower, regionWorld, savePDandCinCalo, savePDandCinMuon, savePDandCinTracker, and trackerRegions.

Referenced by StackingAction().

{
  // prepare region vector
  unsigned int num = maxTimeNames.size();
  maxTimeRegions.resize(num, nullptr);

  // Russian roulette
  std::vector<G4Region*> *rs = G4RegionStore::GetInstance();

  for (auto & reg : *rs) {
    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")) {
      trackerRegions.push_back(reg);
    }
    if(savePDandCinCalo && 
       (rname == "HcalRegion" || rname == "EcalRegion" 
    || rname == "PreshowerSensRegion" || rname == "PreshowerRegion")) {
      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);
      }
    }
  }
}

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

private

Definition at line 455 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;
}

bool StackingAction::isItOutOfTimeWindow ( const G4Region *  reg, const G4Track *  aTrack  ) const

private

Definition at line 465 of file StackingAction.cc.

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

Referenced by ClassifyNewTrack().

{
  double tofM = maxTrackTime;
  for (unsigned int i=0; i<numberTimes; ++i) {
    if (reg == maxTimeRegions[i]) {
      tofM = maxTrackTimes[i];
      break;
    }
  }
  return (aTrack->GetGlobalTime() > tofM) ? true : false;
}

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

private

Definition at line 429 of file StackingAction.cc.

References extractor, 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;
}

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

private

Definition at line 416 of file StackingAction.cc.

References RemoveAddSevLevel::flag.

Referenced by ClassifyNewTrack().

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

void StackingAction::NewStage ( )

override

Definition at line 345 of file StackingAction.cc.

{}

void StackingAction::PrepareNewEvent ( )

override

Definition at line 347 of file StackingAction.cc.

{}

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

private

Definition at line 477 of file StackingAction.cc.

References mps_fire::i.

Referenced by StackingAction().

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

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

private

Definition at line 445 of file StackingAction.cc.

References extractor, and TrackInformation::genParticlePID().

Referenced by ClassifyNewTrack().

{
  const TrackInformation & motherInfo(extractor(mother));

  // Check whether mother is gamma, e+, e-
  int genID = motherInfo.genParticlePID();
  return (22 == genID || 11 == genID || -11 == genID) ? false : true;     
}

Member Data Documentation

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

private

Definition at line 70 of file StackingAction.h.

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

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

private

Definition at line 65 of file StackingAction.h.

Referenced by initPointer(), and StackingAction().

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

private

Definition at line 72 of file StackingAction.h.

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

TrackInformationExtractor StackingAction::extractor

private

Definition at line 78 of file StackingAction.h.

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

bool StackingAction::gRRactive

private

Definition at line 106 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

double StackingAction::gRusRoCastor

private

Definition at line 101 of file StackingAction.h.

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

double StackingAction::gRusRoEcal

private

Definition at line 93 of file StackingAction.h.

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

double StackingAction::gRusRoEnerLim

private

Definition at line 89 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

double StackingAction::gRusRoHcal

private

Definition at line 95 of file StackingAction.h.

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

double StackingAction::gRusRoMuonIron

private

Definition at line 97 of file StackingAction.h.

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

double StackingAction::gRusRoPreShower

private

Definition at line 99 of file StackingAction.h.

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

double StackingAction::gRusRoWorld

private

Definition at line 103 of file StackingAction.h.

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

bool StackingAction::killDeltaRay

private

Definition at line 55 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

bool StackingAction::killExtra

private

Definition at line 56 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

bool StackingAction::killGamma

private

Definition at line 57 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

bool StackingAction::killHeavy

private

Definition at line 55 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

bool StackingAction::killInCalo

private

Definition at line 54 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

bool StackingAction::killInCaloEfH

private

Definition at line 54 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

double StackingAction::kmaxGamma

private

Definition at line 60 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

double StackingAction::kmaxIon

private

Definition at line 59 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

double StackingAction::kmaxNeutron

private

Definition at line 59 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

double StackingAction::kmaxProton

private

Definition at line 59 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

double StackingAction::limitEnergyForVacuum

private

Definition at line 58 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

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

private

Definition at line 71 of file StackingAction.h.

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

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

private

Definition at line 64 of file StackingAction.h.

Referenced by initPointer(), and StackingAction().

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

private

Definition at line 67 of file StackingAction.h.

Referenced by initPointer(), and isItOutOfTimeWindow().

double StackingAction::maxTrackTime

private

Definition at line 61 of file StackingAction.h.

Referenced by isItOutOfTimeWindow(), and StackingAction().

std::vector<double> StackingAction::maxTrackTimes

private

Definition at line 63 of file StackingAction.h.

Referenced by isItOutOfTimeWindow(), and StackingAction().

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

private

Definition at line 69 of file StackingAction.h.

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

NewTrackAction* StackingAction::newTA

private

Definition at line 77 of file StackingAction.h.

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

bool StackingAction::nRRactive

private

Definition at line 107 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

double StackingAction::nRusRoCastor

private

Definition at line 102 of file StackingAction.h.

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

double StackingAction::nRusRoEcal

private

Definition at line 94 of file StackingAction.h.

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

double StackingAction::nRusRoEnerLim

private

Definition at line 90 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

double StackingAction::nRusRoHcal

private

Definition at line 96 of file StackingAction.h.

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

double StackingAction::nRusRoMuonIron

private

Definition at line 98 of file StackingAction.h.

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

double StackingAction::nRusRoPreShower

private

Definition at line 100 of file StackingAction.h.

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

double StackingAction::nRusRoWorld

private

Definition at line 104 of file StackingAction.h.

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

unsigned int StackingAction::numberTimes

private

Definition at line 62 of file StackingAction.h.

Referenced by isItOutOfTimeWindow(), and StackingAction().

const G4Region* StackingAction::regionCastor

private

Definition at line 85 of file StackingAction.h.

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

const G4Region* StackingAction::regionEcal

private

Definition at line 81 of file StackingAction.h.

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

const G4Region* StackingAction::regionHcal

private

Definition at line 82 of file StackingAction.h.

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

const G4Region* StackingAction::regionMuonIron

private

Definition at line 83 of file StackingAction.h.

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

const G4Region* StackingAction::regionPreShower

private

Definition at line 84 of file StackingAction.h.

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

const G4Region* StackingAction::regionWorld

private

Definition at line 86 of file StackingAction.h.

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

bool StackingAction::saveFirstSecondary

private

Definition at line 52 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

bool StackingAction::savePDandCinAll

private

Definition at line 53 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

bool StackingAction::savePDandCinCalo

private

Definition at line 51 of file StackingAction.h.

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

bool StackingAction::savePDandCinMuon

private

Definition at line 52 of file StackingAction.h.

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

bool StackingAction::savePDandCinTracker

private

Definition at line 51 of file StackingAction.h.

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

const CMSSteppingVerbose* StackingAction::steppingVerbose

private

Definition at line 76 of file StackingAction.h.

Referenced by ClassifyNewTrack().

const TrackingAction* StackingAction::trackAction

private

Definition at line 75 of file StackingAction.h.

Referenced by ClassifyNewTrack().

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

private

Definition at line 68 of file StackingAction.h.

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

bool StackingAction::trackNeutrino

private

Definition at line 55 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

G4VSolid* StackingAction::worldSolid

private

Definition at line 74 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().