#include <StackingAction.h>

Inheritance diagram for StackingAction:

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

void	NewStage ()

void	PrepareNewEvent ()

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

virtual	~StackingAction ()

Private Member Functions
void	initPointer ()

int	isItFromPrimary (const G4Track &, int) const

bool	isItLongLived (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

bool	gRRactive

double	gRusRoCastor

double	gRusRoEcal

double	gRusRoEnerLim

double	gRusRoHcal

double	gRusRoMuonIron

double	gRusRoPreShower

double	gRusRoWorld

bool	killDeltaRay

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

bool	pRRactive

double	pRusRoCastor

double	pRusRoEcal

double	pRusRoEnerLim

double	pRusRoHcal

double	pRusRoMuonIron

double	pRusRoPreShower

double	pRusRoWorld

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 TrackingAction *	trackAction

std::vector< const G4Region * >	trackerRegions

bool	trackNeutrino

Detailed Description

Definition at line 17 of file StackingAction.h.

Constructor & Destructor Documentation

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

Definition at line 20 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, i, initPointer(), killDeltaRay, killGamma, killHeavy, killInCalo, killInCaloEfH, kmaxGamma, kmaxIon, kmaxNeutron, kmaxProton, limitEnergyForVacuum, lowdensRegions, maxTimeNames, maxTrackTime, maxTrackTimes, muonRegions, newTA, nRRactive, nRusRoCastor, nRusRoEcal, nRusRoEnerLim, nRusRoHcal, nRusRoMuonIron, nRusRoPreShower, nRusRoWorld, numberTimes, printRegions(), pRRactive, pRusRoCastor, pRusRoEcal, pRusRoEnerLim, pRusRoHcal, pRusRoMuonIron, pRusRoPreShower, pRusRoWorld, regionCastor, regionEcal, regionHcal, regionMuonIron, regionPreShower, regionWorld, saveFirstSecondary, savePDandCinAll, savePDandCinCalo, savePDandCinMuon, savePDandCinTracker, trackerRegions, and trackNeutrino.

   : trackAction(trka) 
 {
   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 = 0;
   regionHcal = 0;
   regionMuonIron = 0;
   regionPreShower= 0;
   regionCastor = 0;
   regionWorld = 0;
 
   gRusRoEnerLim = p.getParameter<double>("RusRoGammaEnergyLimit")*MeV;
   nRusRoEnerLim = p.getParameter<double>("RusRoNeutronEnergyLimit")*MeV;
   pRusRoEnerLim = p.getParameter<double>("RusRoProtonEnergyLimit")*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");
 
   pRusRoEcal = p.getParameter<double>("RusRoEcalProton");
   pRusRoHcal = p.getParameter<double>("RusRoHcalProton");
   pRusRoMuonIron = p.getParameter<double>("RusRoMuonIronProton");
   pRusRoPreShower = p.getParameter<double>("RusRoPreShowerProton");
   pRusRoCastor = p.getParameter<double>("RusRoCastorProton");
   pRusRoWorld = p.getParameter<double>("RusRoWorldProton");
 
   gRRactive = false;
   nRRactive = false;
   pRRactive = 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(pRusRoEnerLim > 0.0 && 
      (pRusRoEcal < 1.0 || pRusRoHcal < 1.0 || 
       pRusRoMuonIron < 1.0 || pRusRoPreShower < 1.0 || pRusRoCastor < 1.0 ||
       pRusRoWorld < 1.0)) { pRRactive = 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";
   }
 
   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(pRRactive) {
     edm::LogInfo("SimG4CoreApplication") 
       << "StackingAction: "
       << "Russian Roulette for proton Elimit(MeV)= " 
       << pRusRoEnerLim/MeV << "\n"
       << "                 ECAL Prob= " << pRusRoEcal << "\n"
       << "                 HCAL Prob= " << pRusRoHcal << "\n"
       << "             MuonIron Prob= " << pRusRoMuonIron << "\n"
       << "            PreShower Prob= " << pRusRoPreShower << "\n"
       << "               CASTOR Prob= " << pRusRoCastor << "\n"
       << "                World Prob= " << pRusRoWorld;
   }
 
   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"); 
   }
 }

StackingAction::~StackingAction ( )

virtual

Definition at line 215 of file StackingAction.cc.

References newTA.

 {
   delete newTA;
 }

Member Function Documentation

G4ClassificationOfNewTrack StackingAction::ClassifyNewTrack ( const G4Track * aTrack )

virtual

Definition at line 220 of file StackingAction.cc.

References funct::abs(), caloRegions, deadRegions, archive::flag, TrackingAction::geant4Track(), gRRactive, gRusRoCastor, gRusRoEcal, gRusRoEnerLim, gRusRoHcal, gRusRoMuonIron, gRusRoPreShower, gRusRoWorld, isItFromPrimary(), isItLongLived(), isItPrimaryDecayProductOrConversion(), isThisRegion(), ke, killDeltaRay, killGamma, killHeavy, killInCalo, killInCaloEfH, kmaxGamma, kmaxIon, kmaxNeutron, kmaxProton, limitEnergyForVacuum, LogDebug, lowdensRegions, muonRegions, newTA, nRRactive, nRusRoCastor, nRusRoEcal, nRusRoEnerLim, nRusRoHcal, nRusRoMuonIron, nRusRoPreShower, nRusRoWorld, NewTrackAction::primary(), mix_2012_Summer_50ns_PoissonOOTPU_cfi::prob, pRRactive, pRusRoCastor, pRusRoEcal, pRusRoEnerLim, pRusRoHcal, pRusRoMuonIron, pRusRoPreShower, pRusRoWorld, regionCastor, regionEcal, regionHcal, regionMuonIron, regionPreShower, regionWorld, rrApplicable(), saveFirstSecondary, savePDandCinAll, savePDandCinCalo, savePDandCinMuon, savePDandCinTracker, NewTrackAction::secondary(), trackAction, trackerRegions, and trackNeutrino.

 {
   // G4 interface part
   G4ClassificationOfNewTrack classification = fUrgent;
   if (aTrack->GetCreatorProcess()==0 || aTrack->GetParentID()==0) {
     /*
     std::cout << "StackingAction: primary weight= " 
           << aTrack->GetWeight() << " "
           << aTrack->GetDefinition()->GetParticleName()
           << " " << aTrack->GetKineticEnergy()
           << " Id=" << aTrack->GetTrackID()
           << "  trackInfo " << aTrack->GetUserInformation() 
           << std::endl;
     */
     newTA->primary(aTrack);
     /*
     if (!trackNeutrino) {
       int pdg = std::abs(aTrack->GetDefinition()->GetPDGEncoding());
       if (pdg == 12 || pdg == 14 || pdg == 16 || pdg == 18) {
     classification = fKill;
       }
     }
     */
   } else if (aTrack->GetTouchable() == 0) {
     edm::LogError("SimG4CoreApplication")
       << "StackingAction: no touchable for track " << aTrack->GetTrackID()
       << " from " << aTrack->GetParentID()
       << " with PDG code " << aTrack->GetDefinition()->GetParticleName();
     classification = fKill;
   } else {
     int pdg = aTrack->GetDefinition()->GetPDGEncoding();
     double ke  = aTrack->GetKineticEnergy();
 
     if (aTrack->GetTrackStatus() == fStopAndKill) { 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 (!trackNeutrino  && classification != fKill) {
       if (pdg == 12 || pdg == 14 || pdg == 16 || pdg == 18) 
     classification = fKill;
     }
     if (classification != fKill && isItLongLived(aTrack)) 
       { classification = fKill; }
     
     if (classification != fKill && killGamma && pdg == 22 && ke < kmaxGamma) 
       { 
     classification = fKill; 
     //std::cout << "### next gamma killed E(MeV)= " << ke
     //    << "  " <<  aTrack->GetCreatorProcess()->GetProcessName()
     //    << std::endl;
       }
     
 
     if (killDeltaRay && classification != fKill 
     && aTrack->GetCreatorProcess()->GetProcessSubType() == fIonisation) {
       classification = fKill;
     }
 
     const G4Region* reg = aTrack->GetVolume()->GetLogicalVolume()->GetRegion();
     if (killInCalo && classification != fKill 
     && isThisRegion(reg, caloRegions)) {
       classification = fKill; 
     }
     if (classification != fKill && ke <= limitEnergyForVacuum  
     && isThisRegion(reg, lowdensRegions)) {
       classification = fKill; 
     }
     if (classification != fKill && isThisRegion(reg, deadRegions)) {
       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 || 2212 == 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; }
         }
 
         // proton
       } else if(pRRactive && pdg == 2212) {
         elim = pRusRoEnerLim;
         if(reg == regionEcal)             { prob = pRusRoEcal; }
         else if(reg == regionHcal)        { prob = pRusRoHcal; }
         else if(reg == regionMuonIron)    { prob = pRusRoMuonIron; }
         else if(reg == regionPreShower)   { prob = pRusRoPreShower; }
         else if(reg == regionCastor)      { prob = pRusRoCastor; }
         else if(reg == regionWorld)       { prob = pRusRoWorld; }
       }
       if(prob < 1.0 && aTrack->GetKineticEnergy() < elim) {
         if(G4UniformRand() < prob) {
           const_cast<G4Track*>(aTrack)->SetWeight(currentWeight/prob);
         } else {
           classification = fKill;
         }
       }
     }
       }
     
       if(classification != fKill && killInCaloEfH) {
     int pdgMother = mother->GetDefinition()->GetPDGEncoding();
     if ( (pdg == 22 || std::abs(pdg) == 11) && 
          (std::abs(pdgMother) < 11 || std::abs(pdgMother) > 17) && 
          pdgMother != 22  ) {
       if ( isThisRegion(reg,caloRegions)) { 
         classification = fKill; 
       }
     }
       }
       
       if (classification != fKill) {
     newTA->secondary(aTrack, *mother, flag);
       }
     }
   /*
   double wt2 = aTrack->GetWeight();
   if(wt2 != 1.0) { 
     G4Region* reg = aTrack->GetVolume()->GetLogicalVolume()->GetRegion();
     std::cout << "StackingAction: weight= " << wt2 << " "
           << aTrack->GetDefinition()->GetParticleName()
           << " " << aTrack->GetKineticEnergy()
           << " Id=" << aTrack->GetTrackID()
           << " IdP=" << aTrack->GetParentID();
     const G4VProcess* pr = aTrack->GetCreatorProcess();
     if(pr) std::cout << " from  " << pr->GetProcessName();
     if(reg) std::cout << " in  " << reg->GetName()
               << "  trackInfo " << aTrack->GetUserInformation(); 
     std::cout << std::endl;
   }
   */
   }
 #ifdef DebugLog
   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;
 #endif
   
   return classification;
 }

void StackingAction::initPointer ( )

private

Definition at line 416 of file StackingAction.cc.

References caloRegions, deadRegionNames, deadRegions, gRusRoCastor, gRusRoEcal, gRusRoHcal, gRusRoMuonIron, gRusRoPreShower, i, lowdensRegions, maxTimeNames, maxTimeRegions, muonRegions, nRusRoCastor, nRusRoEcal, nRusRoHcal, nRusRoMuonIron, nRusRoPreShower, nRusRoWorld, pileupDistInMC::num, pRusRoCastor, pRusRoEcal, pRusRoHcal, pRusRoMuonIron, pRusRoPreShower, pRusRoWorld, regionCastor, regionEcal, regionHcal, regionMuonIron, regionPreShower, regionWorld, savePDandCinCalo, savePDandCinMuon, savePDandCinTracker, and trackerRegions.

Referenced by StackingAction().

 {
   // Russian roulette
   const G4RegionStore * rs = G4RegionStore::GetInstance();
   std::vector<G4Region*>::const_iterator rcite;
   std::vector<std::string>::const_iterator rd;
 
   for (rcite = rs->begin(); rcite != rs->end(); ++rcite) {
     const G4Region* reg = (*rcite);
     G4String rname = reg->GetName(); 
     if ((gRusRoEcal < 1.0 || nRusRoEcal < 1.0 || pRusRoEcal < 1.0) && 
     rname == "EcalRegion") {  
       regionEcal = reg; 
     }
     if ((gRusRoHcal < 1.0 || nRusRoHcal < 1.0 || pRusRoHcal < 1.0) && 
     rname == "HcalRegion") {  
       regionHcal = reg; 
     }
     if ((gRusRoMuonIron < 1.0 || nRusRoMuonIron < 1.0 || pRusRoMuonIron < 1.0) && 
     rname == "MuonIron") {  
       regionMuonIron = reg; 
     }
     if ((gRusRoPreShower < 1.0 || nRusRoPreShower < 1.0 || pRusRoPreShower < 1.0) 
     && rname == "PreshowerRegion") {  
       regionPreShower = reg; 
     }
     if ((gRusRoCastor < 1.0 || nRusRoCastor < 1.0 || pRusRoCastor < 1.0) && 
     rname == "CastorRegion") {  
       regionCastor = reg; 
     }
     if ((nRusRoWorld < 1.0 || nRusRoWorld < 1.0 || pRusRoWorld < 1.0) && 
     rname == "DefaultRegionForTheWorld") {  
       regionWorld = reg; 
     }
 
     // time limits
     unsigned int num = maxTimeNames.size();
     maxTimeRegions.resize(num, 0);
     if (num > 0) {
       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 (rd = deadRegionNames.begin(); rd != deadRegionNames.end(); ++rd) {
       if(rname == (G4String)(*rd)) {
     deadRegions.push_back(reg);
       }
     }
   }
 }

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

private

Definition at line 551 of file StackingAction.cc.

References archive::flag, and TrackInformation::isPrimary().

Referenced by ClassifyNewTrack().

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

bool StackingAction::isItLongLived ( const G4Track * aTrack ) const

private

Definition at line 562 of file StackingAction.cc.

References archive::flag, i, maxTimeRegions, maxTrackTime, maxTrackTimes, and numberTimes.

Referenced by ClassifyNewTrack().

 {
   bool   flag = false;
   double tofM = maxTrackTime;
   if (numberTimes > 0) {
     G4Region* reg = 
       aTrack->GetVolume()->GetLogicalVolume()->GetRegion();
     for (unsigned int i=0; i<numberTimes; ++i) {
       if (reg == maxTimeRegions[i]) {
     tofM = maxTrackTimes[i];
     break;
       }
     }
   }
   if (aTrack->GetGlobalTime() > tofM) { flag = true; }
   return flag;
 }

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

private

Definition at line 506 of file StackingAction.cc.

References archive::flag, and TrackInformation::isPrimary().

Referenced by ClassifyNewTrack().

 {
   int flag = 0;
   TrackInformationExtractor extractor;
   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 492 of file StackingAction.cc.

References archive::flag, and i.

Referenced by ClassifyNewTrack().

 {
   bool flag = false;
   unsigned int nRegions = regions.size();
   for(unsigned int i=0; i<nRegions; ++i) {
     if(reg == regions[i]) {
       flag = true;
       break;
     }
   }
   return flag;
 }

void StackingAction::NewStage ( )

Definition at line 412 of file StackingAction.cc.

412 {}

void StackingAction::PrepareNewEvent ( )

Definition at line 414 of file StackingAction.cc.

414 {}

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

private

Definition at line 580 of file StackingAction.cc.

References 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 523 of file StackingAction.cc.

References archive::flag, and TrackInformation::genParticlePID().

Referenced by ClassifyNewTrack().

 {
   bool flag = true;
   TrackInformationExtractor extractor;
   const TrackInformation & motherInfo(extractor(mother));
   // Check whether mother is a primary
   //if (motherInfo.isPrimary()) {
   // }   
   int genID = motherInfo.genParticlePID();
   if(22 == genID || 11 == genID || -11 == genID) { flag = false; }
     
   /*
   //check if the primary was g, e+, e-
   int genID = motherInfo.genParticlePID();
   double genp = motherInfo.genParticleP();
   std::cout << "Track# " << aTrack->GetTrackID() << "  " 
         << aTrack->GetDefinition()->GetParticleName()  
         << "  E(MeV)= " << aTrack->GetKineticEnergy()/MeV 
         << " mother: " << mother.GetTrackID()
         << "  " << mother.GetDefinition()->GetParticleName()
         << " E(GeV)= " <<  mother.GetKineticEnergy()/GeV
         << " flag: " << flag << " genID= " << genID 
         << " p(GeV)= " << genp/GeV << std::endl; 
     */
   return flag;
 }

Member Data Documentation

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

private

Definition at line 65 of file StackingAction.h.

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

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

private

Definition at line 60 of file StackingAction.h.

Referenced by initPointer(), and StackingAction().

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

private

Definition at line 67 of file StackingAction.h.

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

bool StackingAction::gRRactive

private

Definition at line 105 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

double StackingAction::gRusRoCastor

private

Definition at line 98 of file StackingAction.h.

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

double StackingAction::gRusRoEcal

private

Definition at line 86 of file StackingAction.h.

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

double StackingAction::gRusRoEnerLim

private

Definition at line 81 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

double StackingAction::gRusRoHcal

private

Definition at line 89 of file StackingAction.h.

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

double StackingAction::gRusRoMuonIron

private

Definition at line 92 of file StackingAction.h.

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

double StackingAction::gRusRoPreShower

private

Definition at line 95 of file StackingAction.h.

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

double StackingAction::gRusRoWorld

private

Definition at line 101 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

bool StackingAction::killDeltaRay

private

Definition at line 51 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

bool StackingAction::killGamma

private

Definition at line 52 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

bool StackingAction::killHeavy

private

Definition at line 51 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

bool StackingAction::killInCalo

private

Definition at line 50 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

bool StackingAction::killInCaloEfH

private

Definition at line 50 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

double StackingAction::kmaxGamma

private

Definition at line 55 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

double StackingAction::kmaxIon

private

Definition at line 54 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

double StackingAction::kmaxNeutron

private

Definition at line 54 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

double StackingAction::kmaxProton

private

Definition at line 54 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

double StackingAction::limitEnergyForVacuum

private

Definition at line 53 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

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

private

Definition at line 66 of file StackingAction.h.

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

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

private

Definition at line 59 of file StackingAction.h.

Referenced by initPointer(), and StackingAction().

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

private

Definition at line 62 of file StackingAction.h.

Referenced by initPointer(), and isItLongLived().

double StackingAction::maxTrackTime

private

Definition at line 56 of file StackingAction.h.

Referenced by isItLongLived(), and StackingAction().

std::vector<double> StackingAction::maxTrackTimes

private

Definition at line 58 of file StackingAction.h.

Referenced by isItLongLived(), and StackingAction().

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

private

Definition at line 64 of file StackingAction.h.

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

NewTrackAction* StackingAction::newTA

private

Definition at line 70 of file StackingAction.h.

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

bool StackingAction::nRRactive

private

Definition at line 106 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

double StackingAction::nRusRoCastor

private

Definition at line 99 of file StackingAction.h.

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

double StackingAction::nRusRoEcal

private

Definition at line 87 of file StackingAction.h.

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

double StackingAction::nRusRoEnerLim

private

Definition at line 82 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

double StackingAction::nRusRoHcal

private

Definition at line 90 of file StackingAction.h.

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

double StackingAction::nRusRoMuonIron

private

Definition at line 93 of file StackingAction.h.

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

double StackingAction::nRusRoPreShower

private

Definition at line 96 of file StackingAction.h.

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

double StackingAction::nRusRoWorld

private

Definition at line 102 of file StackingAction.h.

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

unsigned int StackingAction::numberTimes

private

Definition at line 57 of file StackingAction.h.

Referenced by isItLongLived(), and StackingAction().

bool StackingAction::pRRactive

private

Definition at line 107 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

double StackingAction::pRusRoCastor

private

Definition at line 100 of file StackingAction.h.

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

double StackingAction::pRusRoEcal

private

Definition at line 88 of file StackingAction.h.

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

double StackingAction::pRusRoEnerLim

private

Definition at line 83 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

double StackingAction::pRusRoHcal

private

Definition at line 91 of file StackingAction.h.

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

double StackingAction::pRusRoMuonIron

private

Definition at line 94 of file StackingAction.h.

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

double StackingAction::pRusRoPreShower

private

Definition at line 97 of file StackingAction.h.

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

double StackingAction::pRusRoWorld

private

Definition at line 103 of file StackingAction.h.

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

const G4Region* StackingAction::regionCastor

private

Definition at line 77 of file StackingAction.h.

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

const G4Region* StackingAction::regionEcal

private

Definition at line 73 of file StackingAction.h.

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

const G4Region* StackingAction::regionHcal

private

Definition at line 74 of file StackingAction.h.

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

const G4Region* StackingAction::regionMuonIron

private

Definition at line 75 of file StackingAction.h.

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

const G4Region* StackingAction::regionPreShower

private

Definition at line 76 of file StackingAction.h.

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

const G4Region* StackingAction::regionWorld

private

Definition at line 78 of file StackingAction.h.

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

bool StackingAction::saveFirstSecondary

private

Definition at line 48 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

bool StackingAction::savePDandCinAll

private

Definition at line 49 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

bool StackingAction::savePDandCinCalo

private

Definition at line 47 of file StackingAction.h.

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

bool StackingAction::savePDandCinMuon

private

Definition at line 48 of file StackingAction.h.

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

bool StackingAction::savePDandCinTracker

private

Definition at line 47 of file StackingAction.h.

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

const TrackingAction* StackingAction::trackAction

private

Definition at line 69 of file StackingAction.h.

Referenced by ClassifyNewTrack().

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

private

Definition at line 63 of file StackingAction.h.

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

bool StackingAction::trackNeutrino

private

Definition at line 51 of file StackingAction.h.

Referenced by ClassifyNewTrack(), and StackingAction().

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation