CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
StackingAction.cc
Go to the documentation of this file.
1 #include "SimG4Core/Application/interface/StackingAction.h"
2 #include "SimG4Core/Application/interface/EventAction.h"
3 #include "SimG4Core/Notification/interface/CurrentG4Track.h"
4 #include "SimG4Core/Notification/interface/NewTrackAction.h"
5 #include "SimG4Core/Notification/interface/TrackInformation.h"
6 #include "SimG4Core/Notification/interface/TrackInformationExtractor.h"
7 
8 #include "FWCore/MessageLogger/interface/MessageLogger.h"
9 
10 #include "G4VProcess.hh"
11 #include "G4EmProcessSubType.hh"
12 #include "G4LogicalVolumeStore.hh"
13 #include "G4RegionStore.hh"
14 #include "Randomize.hh"
15 #include "G4SystemOfUnits.hh"
16 
17 #include<algorithm>
18 
19 //#define DebugLog
20 
21 StackingAction::StackingAction(EventAction* e, const edm::ParameterSet & p)
22  : eventAction_(e)
23 {
24  trackNeutrino = p.getParameter<bool>("TrackNeutrino");
25  killHeavy = p.getParameter<bool>("KillHeavy");
26  kmaxIon = p.getParameter<double>("IonThreshold")*MeV;
27  kmaxProton = p.getParameter<double>("ProtonThreshold")*MeV;
28  kmaxNeutron = p.getParameter<double>("NeutronThreshold")*MeV;
29  killDeltaRay = p.getParameter<bool>("KillDeltaRay");
30  maxTrackTime = p.getParameter<double>("MaxTrackTime")*ns;
31  maxTrackTimes = p.getParameter<std::vector<double> >("MaxTrackTimes");
32  for(unsigned int i=0; i<maxTrackTimes.size(); ++i) { maxTrackTimes[i] *= ns; }
33  maxTimeNames = p.getParameter<std::vector<std::string> >("MaxTimeNames");
34  savePDandCinTracker =
35  p.getUntrackedParameter<bool>("SavePrimaryDecayProductsAndConversionsInTracker",
36  false);
37  savePDandCinCalo =
38  p.getUntrackedParameter<bool>("SavePrimaryDecayProductsAndConversionsInCalo",
39  false);
40  savePDandCinMuon =
41  p.getUntrackedParameter<bool>("SavePrimaryDecayProductsAndConversionsInMuon",
42  false);
43  saveFirstSecondary =
44  p.getUntrackedParameter<bool>("SaveFirstLevelSecondary",false);
45  killInCalo = false;
46  killInCaloEfH = false;
47 
48  // Russian Roulette
49  regionEcal = 0;
50  regionHcal = 0;
51  regionMuonIron = 0;
52  regionPreShower= 0;
53  regionCastor = 0;
54  regionWorld = 0;
55 
56  gRusRoEnerLim = p.getParameter<double>("RusRoGammaEnergyLimit")*MeV;
57  nRusRoEnerLim = p.getParameter<double>("RusRoNeutronEnergyLimit")*MeV;
58  pRusRoEnerLim = p.getParameter<double>("RusRoProtonEnergyLimit")*MeV;
59 
60  gRusRoEcal = p.getParameter<double>("RusRoEcalGamma");
61  gRusRoHcal = p.getParameter<double>("RusRoHcalGamma");
62  gRusRoMuonIron = p.getParameter<double>("RusRoMuonIronGamma");
63  gRusRoPreShower = p.getParameter<double>("RusRoPreShowerGamma");
64  gRusRoCastor = p.getParameter<double>("RusRoCastorGamma");
65  gRusRoWorld = p.getParameter<double>("RusRoWorldGamma");
66 
67  nRusRoEcal = p.getParameter<double>("RusRoEcalNeutron");
68  nRusRoHcal = p.getParameter<double>("RusRoHcalNeutron");
69  nRusRoMuonIron = p.getParameter<double>("RusRoMuonIronNeutron");
70  nRusRoPreShower = p.getParameter<double>("RusRoPreShowerNeutron");
71  nRusRoCastor = p.getParameter<double>("RusRoCastorNeutron");
72  nRusRoWorld = p.getParameter<double>("RusRoWorldNeutron");
73 
74  pRusRoEcal = p.getParameter<double>("RusRoEcalProton");
75  pRusRoHcal = p.getParameter<double>("RusRoHcalProton");
76  pRusRoMuonIron = p.getParameter<double>("RusRoMuonIronProton");
77  pRusRoPreShower = p.getParameter<double>("RusRoPreShowerProton");
78  pRusRoCastor = p.getParameter<double>("RusRoCastorProton");
79  pRusRoWorld = p.getParameter<double>("RusRoWorldProton");
80 
81  gRRactive = false;
82  nRRactive = false;
83  pRRactive = false;
84  if(gRusRoEcal < 1.0 || gRusRoHcal < 1.0 ||
85  gRusRoMuonIron < 1.0 || gRusRoPreShower < 1.0 || gRusRoCastor < 1.0 ||
86  gRusRoWorld < 1.0) { gRRactive = true; }
87  if(nRusRoEcal < 1.0 || nRusRoHcal < 1.0 ||
88  nRusRoMuonIron < 1.0 || nRusRoPreShower < 1.0 || nRusRoCastor < 1.0 ||
89  nRusRoWorld < 1.0) { nRRactive = true; }
90  if(pRusRoEcal < 1.0 || pRusRoHcal < 1.0 ||
91  pRusRoMuonIron < 1.0 || pRusRoPreShower < 1.0 || pRusRoCastor < 1.0 ||
92  pRusRoWorld < 1.0) { pRRactive = true; }
93 
94  if ( p.exists("TestKillingOptions") ) {
95 
96  killInCalo = (p.getParameter<edm::ParameterSet>("TestKillingOptions")).getParameter<bool>("KillInCalo");
97  killInCaloEfH = (p.getParameter<edm::ParameterSet>("TestKillingOptions")).getParameter<bool>("KillInCaloEfH");
98  edm::LogWarning("SimG4CoreApplication")
99  << " *** Activating special test killing options in StackingAction \n"
100  << " *** Kill secondaries in Calorimetetrs volume = " << killInCalo << "\n"
101  << " *** Kill electromagnetic secondaries from hadrons in Calorimeters volume = " << killInCaloEfH;
102 
103  }
104 
105  edm::LogInfo("SimG4CoreApplication") << "StackingAction initiated with"
106  << " flag for saving decay products in "
107  << " Tracker: " << savePDandCinTracker
108  << " in Calo: " << savePDandCinCalo
109  << " in Muon: " << savePDandCinMuon
110  << "\n saveFirstSecondary"
111  << ": " << saveFirstSecondary
112  << " Flag for tracking neutrino: "
113  << trackNeutrino << " Killing Flag "
114  << killHeavy << " protons below "
115  << kmaxProton <<" MeV, neutrons below "
116  << kmaxNeutron << " MeV and ions"
117  << " below " << kmaxIon << " MeV\n"
118  << " kill tracks with "
119  << "time larger than " << maxTrackTime
120  << " ns and kill Delta Ray flag set to "
121  << killDeltaRay;
122  for (unsigned int i=0; i<maxTrackTimes.size(); i++) {
123  maxTrackTimes[i] *= ns;
124  edm::LogInfo("SimG4CoreApplication") << "StackingAction::MaxTrackTime for "
125  << maxTimeNames[i] << " is "
126  << maxTrackTimes[i];
127  }
128  if(gRRactive) {
129  edm::LogInfo("SimG4CoreApplication")
130  << "StackingAction: "
131  << "Russian Roulette for gamma Elimit(MeV)= "
132  << nRusRoEnerLim/MeV << "\n"
133  << " ECAL Prob= " << gRusRoEcal << "\n"
134  << " HCAL Prob= " << gRusRoHcal << "\n"
135  << " MuonIron Prob= " << gRusRoMuonIron << "\n"
136  << " PreShower Prob= " << gRusRoPreShower << "\n"
137  << " CASTOR Prob= " << gRusRoCastor << "\n"
138  << " World Prob= " << gRusRoWorld;
139  }
140  if(nRRactive) {
141  edm::LogInfo("SimG4CoreApplication")
142  << "StackingAction: "
143  << "Russian Roulette for neutron Elimit(MeV)= "
144  << nRusRoEnerLim/MeV << "\n"
145  << " ECAL Prob= " << nRusRoEcal << "\n"
146  << " HCAL Prob= " << nRusRoHcal << "\n"
147  << " MuonIron Prob= " << nRusRoMuonIron << "\n"
148  << " PreShower Prob= " << nRusRoPreShower << "\n"
149  << " CASTOR Prob= " << nRusRoCastor << "\n"
150  << " World Prob= " << nRusRoWorld;
151  }
152  if(pRRactive) {
153  edm::LogInfo("SimG4CoreApplication")
154  << "StackingAction: "
155  << "Russian Roulette for proton Elimit(MeV)= "
156  << pRusRoEnerLim/MeV << "\n"
157  << " ECAL Prob= " << pRusRoEcal << "\n"
158  << " HCAL Prob= " << pRusRoHcal << "\n"
159  << " MuonIron Prob= " << pRusRoMuonIron << "\n"
160  << " PreShower Prob= " << pRusRoPreShower << "\n"
161  << " CASTOR Prob= " << pRusRoCastor << "\n"
162  << " World Prob= " << pRusRoWorld;
163  }
164  initPointer();
165  newTA = new NewTrackAction();
166 }
167 
168 StackingAction::~StackingAction()
169 {
170  delete newTA;
171 }
172 
173 G4ClassificationOfNewTrack StackingAction::ClassifyNewTrack(const G4Track * aTrack)
174 {
175  // G4 interface part
176  G4ClassificationOfNewTrack classification = fUrgent;
177  if (aTrack->GetCreatorProcess()==0 || aTrack->GetParentID()==0) {
178  /*
179  std::cout << "StackingAction: primary weight= "
180  << aTrack->GetWeight() << " "
181  << aTrack->GetDefinition()->GetParticleName()
182  << " " << aTrack->GetKineticEnergy()
183  << " Id=" << aTrack->GetTrackID()
184  << " trackInfo " << aTrack->GetUserInformation()
185  << std::endl;
186  */
187  newTA->primary(aTrack);
188  /*
189  if (!trackNeutrino) {
190  int pdg = std::abs(aTrack->GetDefinition()->GetPDGEncoding());
191  if (pdg == 12 || pdg == 14 || pdg == 16 || pdg == 18) {
192  classification = fKill;
193  }
194  }
195  */
196  } else if (aTrack->GetTouchable() == 0) {
197  edm::LogError("SimG4CoreApplication")
198  << "StackingAction: no touchable for track " << aTrack->GetTrackID()
199  << " from " << aTrack->GetParentID()
200  << " with PDG code " << aTrack->GetDefinition()->GetParticleName();
201  classification = fKill;
202  } else {
203  int pdg = aTrack->GetDefinition()->GetPDGEncoding();
204 
205  if (aTrack->GetTrackStatus() == fStopAndKill) { classification = fKill; }
206  if (killHeavy && classification != fKill) {
207  double ke = aTrack->GetKineticEnergy()/MeV;
208  if (((pdg/1000000000 == 1) && (((pdg/10000)%100) > 0) &&
209  (((pdg/10)%100) > 0) && (ke<kmaxIon)) ||
210  ((pdg == 2212) && (ke < kmaxProton)) ||
211  ((pdg == 2112) && (ke < kmaxNeutron))) { classification = fKill; }
212  }
213  if (!trackNeutrino && classification != fKill) {
214  if (pdg == 12 || pdg == 14 || pdg == 16 || pdg == 18)
215  classification = fKill;
216  }
217  if (classification != fKill && isItLongLived(aTrack))
218  { classification = fKill; }
219  if (killDeltaRay && classification != fKill) {
220  if (aTrack->GetCreatorProcess()->GetProcessType() == fElectromagnetic &&
221  aTrack->GetCreatorProcess()->GetProcessSubType() == fIonisation)
222  classification = fKill;
223  }
224  if (killInCalo && classification != fKill) {
225  if ( isThisVolume(aTrack->GetTouchable(),calo)) {
226  classification = fKill;
227  }
228  }
229  // Russian roulette && MC truth
230  if(classification != fKill) {
231  const G4Track * mother = CurrentG4Track::track();
232  int flag = 0;
233  if (savePDandCinTracker && isThisVolume(aTrack->GetTouchable(),tracker)) {
234  flag = isItPrimaryDecayProductOrConversion(aTrack, *mother);
235  }
236  if (savePDandCinCalo && 0 == flag
237  && isThisVolume(aTrack->GetTouchable(),calo)) {
238  flag = isItPrimaryDecayProductOrConversion(aTrack, *mother);
239  }
240  if (savePDandCinMuon && 0 == flag
241  && isThisVolume(aTrack->GetTouchable(),muon)) {
242  flag = isItPrimaryDecayProductOrConversion(aTrack, *mother);
243  }
244 
245  // Russian roulette
246  if(2112 == pdg || 22 == pdg || 2212 == pdg) {
247  double currentWeight = aTrack->GetWeight();
248 
249  if(1.0 >= currentWeight) {
250  double prob = 1.0;
251  double elim = 0.0;
252 
253  // neutron
254  if(nRRactive && pdg == 2112) {
255  elim = nRusRoEnerLim;
256  G4Region* reg = aTrack->GetVolume()->GetLogicalVolume()->GetRegion();
257  if(reg == regionEcal) { prob = nRusRoEcal; }
258  else if(reg == regionHcal) { prob = nRusRoHcal; }
259  else if(reg == regionMuonIron) { prob = nRusRoMuonIron; }
260  else if(reg == regionPreShower) { prob = nRusRoPreShower; }
261  else if(reg == regionCastor) { prob = nRusRoCastor; }
262  else if(reg == regionWorld) { prob = nRusRoWorld; }
263 
264  // gamma
265  } else if(gRRactive && pdg == 22) {
266  elim = gRusRoEnerLim;
267 
268  G4Region* reg = aTrack->GetVolume()->GetLogicalVolume()->GetRegion();
269  if(reg == regionEcal || reg == regionPreShower) {
270  if(rrApplicable(aTrack, *mother)) {
271  if(reg == regionEcal) { prob = gRusRoEcal; }
272  else { prob = gRusRoPreShower; }
273  }
274  } else {
275  if(reg == regionHcal) { prob = gRusRoHcal; }
276  else if(reg == regionMuonIron) { prob = gRusRoMuonIron; }
277  else if(reg == regionCastor) { prob = gRusRoCastor; }
278  else if(reg == regionWorld) { prob = gRusRoWorld; }
279  }
280 
281  // proton
282  } else if(pRRactive && pdg == 2212) {
283  elim = pRusRoEnerLim;
284  G4Region* reg = aTrack->GetVolume()->GetLogicalVolume()->GetRegion();
285  if(reg == regionEcal) { prob = pRusRoEcal; }
286  else if(reg == regionHcal) { prob = pRusRoHcal; }
287  else if(reg == regionMuonIron) { prob = pRusRoMuonIron; }
288  else if(reg == regionPreShower) { prob = pRusRoPreShower; }
289  else if(reg == regionCastor) { prob = pRusRoCastor; }
290  else if(reg == regionWorld) { prob = pRusRoWorld; }
291  }
292  if(prob < 1.0 && aTrack->GetKineticEnergy() < elim) {
293  if(G4UniformRand() < prob) {
294  const_cast<G4Track*>(aTrack)->SetWeight(currentWeight/prob);
295  } else {
296  classification = fKill;
297  }
298  }
299  }
300  }
301 
302  if(classification != fKill && killInCaloEfH) {
303  int pdgMother = mother->GetDefinition()->GetPDGEncoding();
304  if ( (pdg == 22 || std::abs(pdg) == 11) &&
305  (std::abs(pdgMother) < 11 || std::abs(pdgMother) > 17) &&
306  pdgMother != 22 ) {
307  if ( isThisVolume(aTrack->GetTouchable(),calo)) {
308  classification = fKill;
309  }
310  }
311  }
312 
313  if (classification != fKill) {
314  newTA->secondary(aTrack, *mother, flag);
315  }
316  }
317  /*
318  double wt2 = aTrack->GetWeight();
319  if(wt2 != 1.0) {
320  G4Region* reg = aTrack->GetVolume()->GetLogicalVolume()->GetRegion();
321  std::cout << "StackingAction: weight= " << wt2 << " "
322  << aTrack->GetDefinition()->GetParticleName()
323  << " " << aTrack->GetKineticEnergy()
324  << " Id=" << aTrack->GetTrackID()
325  << " IdP=" << aTrack->GetParentID();
326  const G4VProcess* pr = aTrack->GetCreatorProcess();
327  if(pr) std::cout << " from " << pr->GetProcessName();
328  if(reg) std::cout << " in " << reg->GetName()
329  << " trackInfo " << aTrack->GetUserInformation();
330  std::cout << std::endl;
331  }
332  */
333  }
334 #ifdef DebugLog
335  LogDebug("SimG4CoreApplication") << "StackingAction:Classify Track "
336  << aTrack->GetTrackID() << " Parent "
337  << aTrack->GetParentID() << " Type "
338  << aTrack->GetDefinition()->GetParticleName()
339  << " K.E. " << aTrack->GetKineticEnergy()/MeV
340  << " MeV from process/subprocess "
341  << aTrack->GetCreatorProcess()->GetProcessType()
342  << "|"
343  <<aTrack->GetCreatorProcess()->GetProcessSubType()
344  << " as " << classification << " Flag " << flag;
345 #endif
346 
347  return classification;
348 }
349 
350 void StackingAction::NewStage() {}
351 
352 void StackingAction::PrepareNewEvent() {}
353 
354 void StackingAction::initPointer() {
355 
356  const G4LogicalVolumeStore * lvs = G4LogicalVolumeStore::GetInstance();
357  if (lvs) {
358  std::vector<G4LogicalVolume*>::const_iterator lvcite;
359  for (lvcite = lvs->begin(); lvcite != lvs->end(); lvcite++) {
360  if (savePDandCinTracker) {
361  if (strcmp("Tracker",(*lvcite)->GetName().c_str()) == 0) {
362  tracker.push_back(*lvcite);
363  }
364  if (strcmp("BEAM",(*lvcite)->GetName().substr(0,4).c_str()) == 0) {
365  tracker.push_back(*lvcite);
366  }
367  }
368  if (savePDandCinCalo || killInCalo || killInCaloEfH ) {
369  if (strcmp("CALO",(*lvcite)->GetName().c_str()) == 0) {
370  calo.push_back(*lvcite);
371  }
372  if (strcmp("VCAL",(*lvcite)->GetName().c_str()) == 0) {
373  calo.push_back(*lvcite);
374  }
375  }
376  if (savePDandCinMuon) {
377  if (strcmp("MUON",(*lvcite)->GetName().c_str()) == 0) {
378  muon.push_back(*lvcite);
379  }
380  }
381  }
382  edm::LogInfo("SimG4CoreApplication") << "# of LV for Tracker "
383  << tracker.size() << " for Calo "
384  << calo.size() << " for Muon "
385  << muon.size();
386  for (unsigned int i=0; i<tracker.size(); ++i)
387  edm::LogInfo("SimG4CoreApplication") << "Tracker vol " << i << " name "
388  << tracker[i]->GetName();
389  for (unsigned int i=0; i<calo.size(); ++i)
390  edm::LogInfo("SimG4CoreApplication") << "Calorimeter vol " <<i <<" name "
391  << calo[i]->GetName();
392  for (unsigned int i=0; i<muon.size(); ++i)
393  edm::LogInfo("SimG4CoreApplication") << "Muon vol " << i << " name "
394  << muon[i]->GetName();
395  }
396 
397  std::vector<double> tofs;
398 
399  // Russian roulette
400  const G4RegionStore * rs = G4RegionStore::GetInstance();
401  std::vector<G4Region*>::const_iterator rcite;
402  for (rcite = rs->begin(); rcite != rs->end(); rcite++) {
403  if ((gRusRoEcal < 1.0 || nRusRoEcal < 1.0 || pRusRoEcal < 1.0) &&
404  (*rcite)->GetName() == "EcalRegion") {
405  regionEcal = (*rcite);
406  }
407  if ((gRusRoHcal < 1.0 || nRusRoHcal < 1.0 || pRusRoHcal < 1.0) &&
408  (*rcite)->GetName() == "HcalRegion") {
409  regionHcal = (*rcite);
410  }
411  if ((gRusRoMuonIron < 1.0 || nRusRoMuonIron < 1.0 || pRusRoMuonIron < 1.0) &&
412  (*rcite)->GetName() == "MuonIron") {
413  regionMuonIron = (*rcite);
414  }
415  if ((gRusRoPreShower < 1.0 || nRusRoPreShower < 1.0 || pRusRoPreShower < 1.0)
416  && (*rcite)->GetName() == "PreshowerRegion") {
417  regionPreShower = (*rcite);
418  }
419  if ((gRusRoCastor < 1.0 || nRusRoCastor < 1.0 || pRusRoCastor < 1.0) &&
420  (*rcite)->GetName() == "CastorRegion") {
421  regionCastor = (*rcite);
422  }
423  if ((nRusRoWorld < 1.0 || nRusRoWorld < 1.0 || pRusRoWorld < 1.0) &&
424  (*rcite)->GetName() == "DefaultRegionForTheWorld") {
425  regionWorld = (*rcite);
426  }
427 
428  // time limits
429  unsigned int num = maxTimeNames.size();
430  if (num > 0) {
431  for (unsigned int i=0; i<num; i++) {
432  if ((*rcite)->GetName() == (G4String)(maxTimeNames[i])) {
433  maxTimeRegions.push_back(*rcite);
434  tofs.push_back(maxTrackTimes[i]);
435  break;
436  }
437  }
438  }
439  }
440  if(0 < tofs.size()) {
441  for (unsigned int i=0; i<tofs.size(); i++) {
442  maxTrackTimes[i] = tofs[i];
443  G4String name = "Unknown";
444  if (maxTimeRegions[i]) { name = maxTimeRegions[i]->GetName(); }
445  edm::LogInfo("SimG4CoreApplication") << name << " with pointer "
446  << maxTimeRegions[i]<<" KE cut off "
447  << maxTrackTimes[i];
448  }
449  }
450 }
451 
452 bool StackingAction::isThisVolume(const G4VTouchable* touch,
453  std::vector<G4LogicalVolume*> & lvs) const
454 {
455  bool flag = false;
456  if (lvs.size() > 0 && touch !=0) {
457  int level = ((touch->GetHistoryDepth())+1);
458  if (level >= 3) {
459  unsigned int ii = (unsigned int)(level - 3);
460  flag = (std::count(lvs.begin(),lvs.end(),
461  (touch->GetVolume(ii)->GetLogicalVolume())) != 0);
462  }
463  }
464  return flag;
465 }
466 
467 int StackingAction::isItPrimaryDecayProductOrConversion(const G4Track * aTrack,
468  const G4Track & mother) const
469 {
470  int flag = 0;
471  TrackInformationExtractor extractor;
472  const TrackInformation & motherInfo(extractor(mother));
473  // Check whether mother is a primary
474  if (motherInfo.isPrimary()) {
475  if (aTrack->GetCreatorProcess()->GetProcessType() == fDecay) {
476  flag = 1;
477  } else if (aTrack->GetCreatorProcess()->GetProcessSubType()==fGammaConversion) {
478  flag = 2;
479  } else {
480  flag = 3;
481  }
482  }
483  return flag;
484 }
485 
486 bool StackingAction::rrApplicable(const G4Track * aTrack,
487  const G4Track & mother) const
488 {
489  bool flag = true;
490  TrackInformationExtractor extractor;
491  const TrackInformation & motherInfo(extractor(mother));
492  // Check whether mother is a primary
493  //if (motherInfo.isPrimary()) {
494  // }
495  int genID = motherInfo.genParticlePID();
496  if(22 == genID || 11 == genID || -11 == genID) { flag = false; }
497 
498  /*
499  //check if the primary was g, e+, e-
500  int genID = motherInfo.genParticlePID();
501  double genp = motherInfo.genParticleP();
502  std::cout << "Track# " << aTrack->GetTrackID() << " "
503  << aTrack->GetDefinition()->GetParticleName()
504  << " E(MeV)= " << aTrack->GetKineticEnergy()/MeV
505  << " mother: " << mother.GetTrackID()
506  << " " << mother.GetDefinition()->GetParticleName()
507  << " E(GeV)= " << mother.GetKineticEnergy()/GeV
508  << " flag: " << flag << " genID= " << genID
509  << " p(GeV)= " << genp/GeV << std::endl;
510  */
511  return flag;
512 }
513 
514 bool StackingAction::isItLongLived(const G4Track * aTrack) const
515 {
516  bool flag = false;
517  double time = (aTrack->GetGlobalTime())/nanosecond;
518  double tofM = maxTrackTime;
519  if (maxTimeRegions.size() > 0) {
520  G4Region* reg =
521  aTrack->GetTouchable()->GetVolume(0)->GetLogicalVolume()->GetRegion();
522  for (unsigned int i=0; i<maxTimeRegions.size(); i++) {
523  if (reg == maxTimeRegions[i]) {
524  tofM = maxTrackTimes[i];
525  break;
526  }
527  }
528  }
529  if (time > tofM) { flag = true; }
530  return flag;
531 }
532 
533 
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:501
NewTrackAction::primary
void primary(const G4Track *aSecondary) const
Definition: NewTrackAction.cc:14
StackingAction::nRusRoPreShower
double nRusRoPreShower
Definition: StackingAction.h:74
StackingAction::tracker
std::vector< G4LogicalVolume * > tracker
Definition: StackingAction.h:46
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
StackingAction::newTA
NewTrackAction * newTA
Definition: StackingAction.h:48
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
i
int i
Definition: DBlmapReader.cc:9
StackingAction::maxTimeRegions
std::vector< G4Region * > maxTimeRegions
Definition: StackingAction.h:45
StackingAction::StackingAction
StackingAction(EventAction *e, const edm::ParameterSet &ps)
Definition: StackingAction.cc:21
StackingAction::maxTrackTimes
std::vector< double > maxTrackTimes
Definition: StackingAction.h:43
mix_2012_Summer_inTimeOnly_cff.prob
tuple prob
Definition: mix_2012_Summer_inTimeOnly_cff.py:4
StackingAction::regionPreShower
G4Region * regionPreShower
Definition: StackingAction.h:54
edm::ParameterSet::exists
bool exists(std::string const &parameterName) const
checks if a parameter exists
Definition: ParameterSet.cc:759
StackingAction::gRusRoPreShower
double gRusRoPreShower
Definition: StackingAction.h:73
StackingAction::regionHcal
G4Region * regionHcal
Definition: StackingAction.h:52
StackingAction::nRusRoEnerLim
double nRusRoEnerLim
Definition: StackingAction.h:60
StackingAction::pRusRoEnerLim
double pRusRoEnerLim
Definition: StackingAction.h:61
StackingAction::regionMuonIron
G4Region * regionMuonIron
Definition: StackingAction.h:53
cuy.ii
int ii
Definition: cuy.py:588
StackingAction::regionEcal
G4Region * regionEcal
Definition: StackingAction.h:51
StackingAction::rrApplicable
bool rrApplicable(const G4Track *, const G4Track &) const
Definition: StackingAction.cc:486
StackingAction::isItPrimaryDecayProductOrConversion
int isItPrimaryDecayProductOrConversion(const G4Track *, const G4Track &) const
Definition: StackingAction.cc:467
StackingAction::~StackingAction
virtual ~StackingAction()
Definition: StackingAction.cc:168
StackingAction::ClassifyNewTrack
virtual G4ClassificationOfNewTrack ClassifyNewTrack(const G4Track *aTrack)
Definition: StackingAction.cc:173
StackingAction::maxTimeNames
std::vector< std::string > maxTimeNames
Definition: StackingAction.h:44
TrackInformation::genParticlePID
int genParticlePID() const
Definition: TrackInformation.h:50
StackingAction::pRusRoPreShower
double pRusRoPreShower
Definition: StackingAction.h:75
NewTrackAction::secondary
void secondary(const G4Track *aSecondary, const G4Track &mother, int) const
Definition: NewTrackAction.cc:22
StackingAction::nRusRoMuonIron
double nRusRoMuonIron
Definition: StackingAction.h:71
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
StackingAction::regionCastor
G4Region * regionCastor
Definition: StackingAction.h:55
StackingAction::regionWorld
G4Region * regionWorld
Definition: StackingAction.h:56
StackingAction::calo
std::vector< G4LogicalVolume * > calo
Definition: StackingAction.h:46
ke
int ke
Definition: CascadeWrapper.h:14
TrackInformation::isPrimary
bool isPrimary() const
Definition: TrackInformation.h:20
StackingAction::savePDandCinTracker
bool savePDandCinTracker
Definition: StackingAction.h:37
StackingAction::gRusRoEnerLim
double gRusRoEnerLim
Definition: StackingAction.h:59
AlCaHLTBitMon_ParallelJobs.p
tuple p
Definition: AlCaHLTBitMon_ParallelJobs.py:152
StackingAction::muon
std::vector< G4LogicalVolume * > muon
Definition: StackingAction.h:46
StackingAction::isThisVolume
bool isThisVolume(const G4VTouchable *, std::vector< G4LogicalVolume * > &) const
Definition: StackingAction.cc:452
testEve_cfg.level
tuple level
Definition: testEve_cfg.py:34
StackingAction::gRusRoMuonIron
double gRusRoMuonIron
Definition: StackingAction.h:70
StackingAction::pRusRoMuonIron
double pRusRoMuonIron
Definition: StackingAction.h:72
StackingAction::isItLongLived
bool isItLongLived(const G4Track *) const
Definition: StackingAction.cc:514
CurrentG4Track::track
static const G4Track * track()
Definition: CurrentG4Track.h:22
Generated for CMSSW Reference Manual by doxygen 1.8.5