]> git.uio.no Git - u/mrichter/AliRoot.git/blame - TGeant4/TG4PhysicsList.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Possibility to set field map by passing pointer to objet of type AliMagF via
[u/mrichter/AliRoot.git] / TGeant4 / TG4PhysicsList.cxx
CommitLineData
2817d3e2 1// $Id$
2// Category: physics
3//
4// According to:
5// ExN04PhysicsList.cc,v 1.7 1999/12/15 14:49:26 gunter
6// GEANT4 tag Name: geant4-01-01
7
8#include "TG4PhysicsList.h"
9#include "TG4PhysicsListMessenger.h"
10#include "TG4PhysicsManager.h"
2817d3e2 11#include "TG4FlagVector.h"
12#include "TG4SpecialCuts.h"
13#include "TG4SpecialFlags.h"
14
15#include <G4ParticleDefinition.hh>
2817d3e2 16#include <G4ProcessManager.hh>
17#include <G4ProcessVector.hh>
2817d3e2 18#include <G4BosonConstructor.hh>
19#include <G4LeptonConstructor.hh>
20#include <G4MesonConstructor.hh>
21#include <G4BaryonConstructor.hh>
22#include <G4IonConstructor.hh>
23#include <G4ShortLivedConstructor.hh>
2817d3e2 24#include <G4ProcessTable.hh>
2817d3e2 25
26
27TG4PhysicsList::TG4PhysicsList()
28 : G4VUserPhysicsList(),
29 fSetOptical(false),
30 fSetHadron(false),
31 fSetSpecialCuts(false),
32 fSetSpecialFlags(false)
33{
34 // default cut value (1.0mm)
35 defaultCutValue = 1.0*mm;
36
37 // messenger
38 fMessenger = new TG4PhysicsListMessenger(this);
39
40 SetVerboseLevel(1);
41}
42
43TG4PhysicsList::TG4PhysicsList(const TG4PhysicsList& right)
44 : G4VUserPhysicsList(right)
45{
46 // messenger
47 fMessenger = new TG4PhysicsListMessenger(this);
48
49 fSetOptical = right.fSetOptical;
50 fSetHadron = right.fSetHadron;
51 fSetSpecialCuts = right.fSetSpecialCuts;
52 fSetSpecialFlags = right.fSetSpecialFlags;
53}
54
55TG4PhysicsList::~TG4PhysicsList() {
56//
57}
58
59// operators
60
61TG4PhysicsList& TG4PhysicsList::operator=(const TG4PhysicsList& right)
62{
63 // check assignement to self
64 if (this == &right) return *this;
65
66 // base class assignement
67 G4VUserPhysicsList::operator=(right);
68
69 fSetOptical = right.fSetOptical;
70 fSetHadron = right.fSetHadron;
71 fSetSpecialCuts = right.fSetSpecialCuts;
72 fSetSpecialFlags = right.fSetSpecialFlags;
73
74 return *this;
75}
76
77// public methods
78
79void TG4PhysicsList::ConstructParticle()
80{
81// In this method, static member functions should be called
82// for all particles which you want to use.
83// This ensures that objects of these particle types will be
84// created in the program.
85// ---
86
87 // lock physics manager
88 TG4PhysicsManager* physicsManager = TG4PhysicsManager::Instance();
89 physicsManager->Lock();
90 physicsManager->SetPhysicsList(this);
91
92 // create all particles
93 ConstructAllBosons();
94 ConstructAllLeptons();
95 ConstructAllMesons();
96 ConstructAllBaryons();
97 ConstructAllIons();
98 ConstructAllShortLiveds();
99}
100
101void TG4PhysicsList::ConstructProcess()
102{
103// Constructs all processes.
104// ---
105
106 AddTransportation();
107
108 ConstructEM();
109 if (fSetHadron) ConstructHad();
110 if (fSetOptical) ConstructOp();
111 if (fSetSpecialCuts) ConstructSpecialCuts();
112 if (fSetSpecialFlags) ConstructSpecialFlags();
113 ConstructGeneral();
114 if (verboseLevel>1) PrintAllProcesses();
115 // InActivateEM();
116}
117
118void TG4PhysicsList::SetProcessActivation()
119{
120// (In)Activates built processes according
121// to the setup in TG4PhysicsManager::fFlagVector.
122// ---
123
3c7cd15a 124 G4cout << "TG4PhysicsList::SetProcessActivation() start" << G4endl;
2817d3e2 125
126 TG4PhysicsManager* physicsManager = TG4PhysicsManager::Instance();
127 TG4FlagVector* flagVector = physicsManager->GetFlagVector();
128
129 // uncomment following lines to print
130 // the flagVector values
131 //for (G4int i=0; i<kNoG3Flags; i++)
3c7cd15a 132 //{ cout << i << " flag: " << (*flagVector)[i] << G4endl; }
2817d3e2 133
134 if (flagVector) {
135 theParticleIterator->reset();
136 while ((*theParticleIterator)())
137 {
138 G4ParticleDefinition* particle = theParticleIterator->value();
139 G4ProcessManager* processManager = particle->GetProcessManager();
140 G4ProcessVector* processVector = processManager->GetProcessList();
141
142 // set processes flags
143 for (G4int i=0; i<processManager->GetProcessListLength(); i++) {
144 G4int flag = flagVector->GetFlag((*processVector)[i]);
145 if ((flag == kInActivate) &&
146 (processManager->GetProcessActivation(i))) {
147 if (verboseLevel>1) {
148 G4cout << "Set process inactivation for "
3c7cd15a 149 << (*processVector)[i]->GetProcessName() << G4endl;
2817d3e2 150 }
151 processManager->SetProcessActivation(i,false);
152 }
153 else if (((flag == kActivate) || (flag == kActivate2)) &&
154 (!processManager->GetProcessActivation(i))) {
155 if (verboseLevel>1) {
156 G4cout << "Set process activation for "
3c7cd15a 157 << (*processVector)[i]->GetProcessName() << G4endl;
2817d3e2 158 }
159 processManager->SetProcessActivation(i,true);
160 }
161 }
162 }
163 }
164 else {
165 G4String text = "TG4PhysicsList::SetProcessActivation: \n";
166 text = text + " Vector of processes flags is not set.";
167 TG4Globals::Warning(text);
168 }
3c7cd15a 169 G4cout << "TG4PhysicsList::SetProcessActivation() end" << G4endl;
2817d3e2 170}
171
172void TG4PhysicsList::PrintAllProcesses() const
173{
174// Prints all processes.
175// ---
176
3c7cd15a 177 G4cout << "TG4PhysicsList processes: " << G4endl;
178 G4cout << "========================= " << G4endl;
2817d3e2 179
180 G4ProcessTable* processTable = G4ProcessTable::GetProcessTable();
055b749a 181 G4ProcessTable::G4ProcNameVector* processNameList
182 = processTable->GetNameList();
2817d3e2 183
055b749a 184 for (G4int i=0; i <processNameList->size(); i++){
3c7cd15a 185 G4cout << " " << (*processNameList)[i] << G4endl;
2817d3e2 186 }
187}
188
189// protected methods
190
191#include <G4ComptonScattering.hh>
192#include <G4GammaConversion.hh>
193#include <G4PhotoElectricEffect.hh>
194
195#include <G4MultipleScattering.hh>
196
197#include <G4eIonisation.hh>
198#include <G4eBremsstrahlung.hh>
199#include <G4eplusAnnihilation.hh>
200
201#include <G4MuIonisation.hh>
202#include <G4MuBremsstrahlung.hh>
203#include <G4MuPairProduction.hh>
204
205#include <G4hIonisation.hh>
206#include <G4ionIonisation.hh>
207
208void TG4PhysicsList::ConstructEM()
209{
210// Constructs electromagnetic processes.
211// ---
212
213 theParticleIterator->reset();
214 while( (*theParticleIterator)() ){
215 G4ParticleDefinition* particle = theParticleIterator->value();
216 G4ProcessManager* pmanager = particle->GetProcessManager();
217 G4String particleName = particle->GetParticleName();
218
219 if (particleName == "gamma") {
220 // gamma
221 // Construct processes for gamma
222 pmanager->AddDiscreteProcess(new G4GammaConversion());
223 pmanager->AddDiscreteProcess(new G4ComptonScattering());
224 pmanager->AddDiscreteProcess(new G4PhotoElectricEffect());
225
226 } else if (particleName == "e-") {
227 //electron
228 // Construct processes for electron
229 G4VProcess* theeminusMultipleScattering = new G4MultipleScattering();
230 G4VProcess* theeminusIonisation = new G4eIonisation();
231 G4VProcess* theeminusBremsstrahlung = new G4eBremsstrahlung();
232 // add processes
233 pmanager->AddProcess(theeminusMultipleScattering);
234 pmanager->AddProcess(theeminusIonisation);
235 pmanager->AddProcess(theeminusBremsstrahlung);
236 // set ordering for AlongStepDoIt
237 pmanager->SetProcessOrdering(theeminusMultipleScattering, idxAlongStep, 1);
238 pmanager->SetProcessOrdering(theeminusIonisation, idxAlongStep, 2);
239 // set ordering for PostStepDoIt
240 pmanager->SetProcessOrdering(theeminusMultipleScattering, idxPostStep, 1);
241 pmanager->SetProcessOrdering(theeminusIonisation, idxPostStep, 2);
242 pmanager->SetProcessOrdering(theeminusBremsstrahlung, idxPostStep, 3);
243
244 } else if (particleName == "e+") {
245 //positron
246 // Construct processes for positron
247 G4VProcess* theeplusMultipleScattering = new G4MultipleScattering();
248 G4VProcess* theeplusIonisation = new G4eIonisation();
249 G4VProcess* theeplusBremsstrahlung = new G4eBremsstrahlung();
250 G4VProcess* theeplusAnnihilation = new G4eplusAnnihilation();
251 // add processes
252 pmanager->AddProcess(theeplusMultipleScattering);
253 pmanager->AddProcess(theeplusIonisation);
254 pmanager->AddProcess(theeplusBremsstrahlung);
255 pmanager->AddProcess(theeplusAnnihilation);
256 // set ordering for AtRestDoIt
257 pmanager->SetProcessOrderingToFirst(theeplusAnnihilation, idxAtRest);
258 // set ordering for AlongStepDoIt
259 pmanager->SetProcessOrdering(theeplusMultipleScattering, idxAlongStep, 1);
260 pmanager->SetProcessOrdering(theeplusIonisation, idxAlongStep, 2);
261 // set ordering for PostStepDoIt
262 pmanager->SetProcessOrdering(theeplusMultipleScattering, idxPostStep, 1);
263 pmanager->SetProcessOrdering(theeplusIonisation, idxPostStep, 2);
264 pmanager->SetProcessOrdering(theeplusBremsstrahlung, idxPostStep, 3);
265 pmanager->SetProcessOrdering(theeplusAnnihilation, idxPostStep, 4);
266
267 } else if( particleName == "mu+" ||
268 particleName == "mu-" ) {
269 //muon
270 // Construct processes for muon+
271 G4VProcess* aMultipleScattering = new G4MultipleScattering();
272 G4VProcess* aBremsstrahlung = new G4MuBremsstrahlung();
273 G4VProcess* aPairProduction = new G4MuPairProduction();
274 G4VProcess* anIonisation = new G4MuIonisation();
275 // add processes
276 pmanager->AddProcess(anIonisation);
277 pmanager->AddProcess(aMultipleScattering);
278 pmanager->AddProcess(aBremsstrahlung);
279 pmanager->AddProcess(aPairProduction);
280 // set ordering for AlongStepDoIt
281 pmanager->SetProcessOrdering(aMultipleScattering, idxAlongStep, 1);
282 pmanager->SetProcessOrdering(anIonisation, idxAlongStep, 2);
283 // set ordering for PostStepDoIt
284 pmanager->SetProcessOrdering(aMultipleScattering, idxPostStep, 1);
285 pmanager->SetProcessOrdering(anIonisation, idxPostStep, 2);
286 pmanager->SetProcessOrdering(aBremsstrahlung, idxPostStep, 3);
287 pmanager->SetProcessOrdering(aPairProduction, idxPostStep, 4);
288
289 } else if( particleName == "GenericIon" ) {
290 G4VProcess* aionIonization = new G4ionIonisation;
291 G4VProcess* aMultipleScattering = new G4MultipleScattering();
292 pmanager->AddProcess(aionIonization);
293 pmanager->AddProcess(aMultipleScattering);
294 // set ordering for AlongStepDoIt
295 pmanager->SetProcessOrdering(aMultipleScattering, idxAlongStep, 1);
296 pmanager->SetProcessOrdering(aionIonization, idxAlongStep, 2);
297 // set ordering for PostStepDoIt
298 pmanager->SetProcessOrdering(aMultipleScattering, idxPostStep, 1);
299 pmanager->SetProcessOrdering(aionIonization, idxPostStep, 2);
300
301 } else if ((!particle->IsShortLived()) &&
302 (particle->GetPDGCharge() != 0.0) &&
303 (particle->GetParticleName() != "chargedgeantino")) {
304 // all others charged particles except geantino
305 G4VProcess* aMultipleScattering = new G4MultipleScattering();
306 G4VProcess* anIonisation = new G4hIonisation();
307 // add processes
308 pmanager->AddProcess(anIonisation);
309 pmanager->AddProcess(aMultipleScattering);
310 // set ordering for AlongStepDoIt
311 pmanager->SetProcessOrdering(aMultipleScattering, idxAlongStep, 1);
312 pmanager->SetProcessOrdering(anIonisation, idxAlongStep, 2);
313 // set ordering for PostStepDoIt
314 pmanager->SetProcessOrdering(aMultipleScattering, idxPostStep, 1);
315 pmanager->SetProcessOrdering(anIonisation, idxPostStep, 2);
316 }
317 }
318}
319
320
321// Hadron Processes
322
323#include <G4HadronElasticProcess.hh>
324
325#include <G4PionPlusInelasticProcess.hh>
326#include <G4PionMinusInelasticProcess.hh>
327#include <G4KaonPlusInelasticProcess.hh>
328#include <G4KaonZeroSInelasticProcess.hh>
329#include <G4KaonZeroLInelasticProcess.hh>
330#include <G4KaonMinusInelasticProcess.hh>
331#include <G4ProtonInelasticProcess.hh>
332#include <G4AntiProtonInelasticProcess.hh>
333#include <G4NeutronInelasticProcess.hh>
334#include <G4AntiNeutronInelasticProcess.hh>
335#include <G4LambdaInelasticProcess.hh>
336#include <G4AntiLambdaInelasticProcess.hh>
337#include <G4SigmaPlusInelasticProcess.hh>
338#include <G4SigmaMinusInelasticProcess.hh>
339#include <G4AntiSigmaPlusInelasticProcess.hh>
340#include <G4AntiSigmaMinusInelasticProcess.hh>
341#include <G4XiZeroInelasticProcess.hh>
342#include <G4XiMinusInelasticProcess.hh>
343#include <G4AntiXiZeroInelasticProcess.hh>
344#include <G4AntiXiMinusInelasticProcess.hh>
345#include <G4DeuteronInelasticProcess.hh>
346#include <G4TritonInelasticProcess.hh>
347#include <G4AlphaInelasticProcess.hh>
348#include <G4OmegaMinusInelasticProcess.hh>
349#include <G4AntiOmegaMinusInelasticProcess.hh>
350
351// Low-energy Models
352
353#include <G4LElastic.hh>
354
355#include <G4LEPionPlusInelastic.hh>
356#include <G4LEPionMinusInelastic.hh>
357#include <G4LEKaonPlusInelastic.hh>
358#include <G4LEKaonZeroSInelastic.hh>
359#include <G4LEKaonZeroLInelastic.hh>
360#include <G4LEKaonMinusInelastic.hh>
361#include <G4LEProtonInelastic.hh>
362#include <G4LEAntiProtonInelastic.hh>
363#include <G4LENeutronInelastic.hh>
364#include <G4LEAntiNeutronInelastic.hh>
365#include <G4LELambdaInelastic.hh>
366#include <G4LEAntiLambdaInelastic.hh>
367#include <G4LESigmaPlusInelastic.hh>
368#include <G4LESigmaMinusInelastic.hh>
369#include <G4LEAntiSigmaPlusInelastic.hh>
370#include <G4LEAntiSigmaMinusInelastic.hh>
371#include <G4LEXiZeroInelastic.hh>
372#include <G4LEXiMinusInelastic.hh>
373#include <G4LEAntiXiZeroInelastic.hh>
374#include <G4LEAntiXiMinusInelastic.hh>
375#include <G4LEDeuteronInelastic.hh>
376#include <G4LETritonInelastic.hh>
377#include <G4LEAlphaInelastic.hh>
378#include <G4LEOmegaMinusInelastic.hh>
379#include <G4LEAntiOmegaMinusInelastic.hh>
380
381// High-energy Models
382
383#include <G4HEPionPlusInelastic.hh>
384#include <G4HEPionMinusInelastic.hh>
385#include <G4HEKaonPlusInelastic.hh>
386#include <G4HEKaonZeroInelastic.hh>
387#include <G4HEKaonZeroInelastic.hh>
388#include <G4HEKaonMinusInelastic.hh>
389#include <G4HEProtonInelastic.hh>
390#include <G4HEAntiProtonInelastic.hh>
391#include <G4HENeutronInelastic.hh>
392#include <G4HEAntiNeutronInelastic.hh>
393#include <G4HELambdaInelastic.hh>
394#include <G4HEAntiLambdaInelastic.hh>
395#include <G4HESigmaPlusInelastic.hh>
396#include <G4HESigmaMinusInelastic.hh>
397#include <G4HEAntiSigmaPlusInelastic.hh>
398#include <G4HEAntiSigmaMinusInelastic.hh>
399#include <G4HEXiZeroInelastic.hh>
400#include <G4HEXiMinusInelastic.hh>
401#include <G4HEAntiXiZeroInelastic.hh>
402#include <G4HEAntiXiMinusInelastic.hh>
403#include <G4HEOmegaMinusInelastic.hh>
404#include <G4HEAntiOmegaMinusInelastic.hh>
405
406// Stopping processes
407
408#ifdef TRIUMF_STOP_PIMINUS
409#include <G4PionMinusAbsorptionAtRest.hh>
410#else
411#include <G4PiMinusAbsorptionAtRest.hh>
412#endif
413#ifdef TRIUMF_STOP_KMINUS
414#include <G4KaonMinusAbsorption.hh>
415#else
416#include <G4KaonMinusAbsorptionAtRest.hh>
417#endif
418
419void TG4PhysicsList::ConstructHad()
420{
421//
422// ConstructHad()
423//
424// Makes discrete physics processes for the hadrons, at present limited
425// to those particles with GHEISHA interactions (INTRC > 0).
426// The processes are: Elastic scattering and Inelastic scattering.
427//
428// F.W.Jones 09-JUL-1998
429// ---
430
3c7cd15a 431 G4cout << "### TG4PhysicsList::ConstructHad()" << G4endl;
2817d3e2 432
433 G4HadronElasticProcess* theElasticProcess =
434 new G4HadronElasticProcess;
435 G4LElastic* theElasticModel = new G4LElastic;
436 theElasticProcess->RegisterMe(theElasticModel);
437
438 theParticleIterator->reset();
439 while ((*theParticleIterator)()) {
440 G4ParticleDefinition* particle = theParticleIterator->value();
441 G4ProcessManager* pmanager = particle->GetProcessManager();
442 G4String particleName = particle->GetParticleName();
443
444 if (particleName == "pi+") {
445 pmanager->AddDiscreteProcess(theElasticProcess);
446 G4PionPlusInelasticProcess* theInelasticProcess =
447 new G4PionPlusInelasticProcess("inelastic");
448 G4LEPionPlusInelastic* theLEInelasticModel =
449 new G4LEPionPlusInelastic;
450 theInelasticProcess->RegisterMe(theLEInelasticModel);
451 G4HEPionPlusInelastic* theHEInelasticModel =
452 new G4HEPionPlusInelastic;
453 theInelasticProcess->RegisterMe(theHEInelasticModel);
454 pmanager->AddDiscreteProcess(theInelasticProcess);
455 }
456 else if (particleName == "pi-") {
457 pmanager->AddDiscreteProcess(theElasticProcess);
458 G4PionMinusInelasticProcess* theInelasticProcess =
459 new G4PionMinusInelasticProcess("inelastic");
460 G4LEPionMinusInelastic* theLEInelasticModel =
461 new G4LEPionMinusInelastic;
462 theInelasticProcess->RegisterMe(theLEInelasticModel);
463 G4HEPionMinusInelastic* theHEInelasticModel =
464 new G4HEPionMinusInelastic;
465 theInelasticProcess->RegisterMe(theHEInelasticModel);
466 pmanager->AddDiscreteProcess(theInelasticProcess);
467#ifdef TRIUMF_STOP_PIMINUS
468 pmanager->AddRestProcess(new G4PionMinusAbsorptionAtRest, ordDefault);
469#else
470 G4String prcNam;
471 pmanager->AddRestProcess(
472 new G4PiMinusAbsorptionAtRest(
473 prcNam="PiMinusAbsorptionAtRest"), ordDefault);
474#endif
475 }
476 else if (particleName == "kaon+") {
477 pmanager->AddDiscreteProcess(theElasticProcess);
478 G4KaonPlusInelasticProcess* theInelasticProcess =
479 new G4KaonPlusInelasticProcess("inelastic");
480 G4LEKaonPlusInelastic* theLEInelasticModel =
481 new G4LEKaonPlusInelastic;
482 theInelasticProcess->RegisterMe(theLEInelasticModel);
483 G4HEKaonPlusInelastic* theHEInelasticModel =
484 new G4HEKaonPlusInelastic;
485 theInelasticProcess->RegisterMe(theHEInelasticModel);
486 pmanager->AddDiscreteProcess(theInelasticProcess);
487 }
488 else if (particleName == "kaon0S") {
489 pmanager->AddDiscreteProcess(theElasticProcess);
490 G4KaonZeroSInelasticProcess* theInelasticProcess =
491 new G4KaonZeroSInelasticProcess("inelastic");
492 G4LEKaonZeroSInelastic* theLEInelasticModel =
493 new G4LEKaonZeroSInelastic;
494 theInelasticProcess->RegisterMe(theLEInelasticModel);
495 G4HEKaonZeroInelastic* theHEInelasticModel =
496 new G4HEKaonZeroInelastic;
497 theInelasticProcess->RegisterMe(theHEInelasticModel);
498 pmanager->AddDiscreteProcess(theInelasticProcess);
499 }
500 else if (particleName == "kaon0L") {
501 pmanager->AddDiscreteProcess(theElasticProcess);
502 G4KaonZeroLInelasticProcess* theInelasticProcess =
503 new G4KaonZeroLInelasticProcess("inelastic");
504 G4LEKaonZeroLInelastic* theLEInelasticModel =
505 new G4LEKaonZeroLInelastic;
506 theInelasticProcess->RegisterMe(theLEInelasticModel);
507 G4HEKaonZeroInelastic* theHEInelasticModel =
508 new G4HEKaonZeroInelastic;
509 theInelasticProcess->RegisterMe(theHEInelasticModel);
510 pmanager->AddDiscreteProcess(theInelasticProcess);
511 }
512 else if (particleName == "kaon-") {
513 pmanager->AddDiscreteProcess(theElasticProcess);
514 G4KaonMinusInelasticProcess* theInelasticProcess =
515 new G4KaonMinusInelasticProcess("inelastic");
516 G4LEKaonMinusInelastic* theLEInelasticModel =
517 new G4LEKaonMinusInelastic;
518 theInelasticProcess->RegisterMe(theLEInelasticModel);
519 G4HEKaonMinusInelastic* theHEInelasticModel =
520 new G4HEKaonMinusInelastic;
521 theInelasticProcess->RegisterMe(theHEInelasticModel);
522 pmanager->AddDiscreteProcess(theInelasticProcess);
523#ifdef TRIUMF_STOP_KMINUS
524 pmanager->AddRestProcess(new G4KaonMinusAbsorption, ordDefault);
525#else
526 pmanager->AddRestProcess(new G4KaonMinusAbsorptionAtRest, ordDefault);
527#endif
528 }
529 else if (particleName == "proton") {
530 pmanager->AddDiscreteProcess(theElasticProcess);
531 G4ProtonInelasticProcess* theInelasticProcess =
532 new G4ProtonInelasticProcess("inelastic");
533 G4LEProtonInelastic* theLEInelasticModel = new G4LEProtonInelastic;
534 theInelasticProcess->RegisterMe(theLEInelasticModel);
535 G4HEProtonInelastic* theHEInelasticModel = new G4HEProtonInelastic;
536 theInelasticProcess->RegisterMe(theHEInelasticModel);
537 pmanager->AddDiscreteProcess(theInelasticProcess);
538 }
539 else if (particleName == "anti_proton") {
540 pmanager->AddDiscreteProcess(theElasticProcess);
541 G4AntiProtonInelasticProcess* theInelasticProcess =
542 new G4AntiProtonInelasticProcess("inelastic");
543 G4LEAntiProtonInelastic* theLEInelasticModel =
544 new G4LEAntiProtonInelastic;
545 theInelasticProcess->RegisterMe(theLEInelasticModel);
546 G4HEAntiProtonInelastic* theHEInelasticModel =
547 new G4HEAntiProtonInelastic;
548 theInelasticProcess->RegisterMe(theHEInelasticModel);
549 pmanager->AddDiscreteProcess(theInelasticProcess);
550 }
551 else if (particleName == "neutron") {
552 pmanager->AddDiscreteProcess(theElasticProcess);
553 G4NeutronInelasticProcess* theInelasticProcess =
554 new G4NeutronInelasticProcess("inelastic");
555 G4LENeutronInelastic* theLEInelasticModel =
556 new G4LENeutronInelastic;
557 theInelasticProcess->RegisterMe(theLEInelasticModel);
558 G4HENeutronInelastic* theHEInelasticModel =
559 new G4HENeutronInelastic;
560 theInelasticProcess->RegisterMe(theHEInelasticModel);
561 pmanager->AddDiscreteProcess(theInelasticProcess);
562 }
563 else if (particleName == "anti_neutron") {
564 pmanager->AddDiscreteProcess(theElasticProcess);
565 G4AntiNeutronInelasticProcess* theInelasticProcess =
566 new G4AntiNeutronInelasticProcess("inelastic");
567 G4LEAntiNeutronInelastic* theLEInelasticModel =
568 new G4LEAntiNeutronInelastic;
569 theInelasticProcess->RegisterMe(theLEInelasticModel);
570 G4HEAntiNeutronInelastic* theHEInelasticModel =
571 new G4HEAntiNeutronInelastic;
572 theInelasticProcess->RegisterMe(theHEInelasticModel);
573 pmanager->AddDiscreteProcess(theInelasticProcess);
574 }
575 else if (particleName == "lambda") {
576 pmanager->AddDiscreteProcess(theElasticProcess);
577 G4LambdaInelasticProcess* theInelasticProcess =
578 new G4LambdaInelasticProcess("inelastic");
579 G4LELambdaInelastic* theLEInelasticModel = new G4LELambdaInelastic;
580 theInelasticProcess->RegisterMe(theLEInelasticModel);
581 G4HELambdaInelastic* theHEInelasticModel = new G4HELambdaInelastic;
582 theInelasticProcess->RegisterMe(theHEInelasticModel);
583 pmanager->AddDiscreteProcess(theInelasticProcess);
584 }
585 else if (particleName == "anti_lambda") {
586 pmanager->AddDiscreteProcess(theElasticProcess);
587 G4AntiLambdaInelasticProcess* theInelasticProcess =
588 new G4AntiLambdaInelasticProcess("inelastic");
589 G4LEAntiLambdaInelastic* theLEInelasticModel =
590 new G4LEAntiLambdaInelastic;
591 theInelasticProcess->RegisterMe(theLEInelasticModel);
592 G4HEAntiLambdaInelastic* theHEInelasticModel =
593 new G4HEAntiLambdaInelastic;
594 theInelasticProcess->RegisterMe(theHEInelasticModel);
595 pmanager->AddDiscreteProcess(theInelasticProcess);
596 }
597 else if (particleName == "sigma+") {
598 pmanager->AddDiscreteProcess(theElasticProcess);
599 G4SigmaPlusInelasticProcess* theInelasticProcess =
600 new G4SigmaPlusInelasticProcess("inelastic");
601 G4LESigmaPlusInelastic* theLEInelasticModel =
602 new G4LESigmaPlusInelastic;
603 theInelasticProcess->RegisterMe(theLEInelasticModel);
604 G4HESigmaPlusInelastic* theHEInelasticModel =
605 new G4HESigmaPlusInelastic;
606 theInelasticProcess->RegisterMe(theHEInelasticModel);
607 pmanager->AddDiscreteProcess(theInelasticProcess);
608 }
609 else if (particleName == "sigma-") {
610 pmanager->AddDiscreteProcess(theElasticProcess);
611 G4SigmaMinusInelasticProcess* theInelasticProcess =
612 new G4SigmaMinusInelasticProcess("inelastic");
613 G4LESigmaMinusInelastic* theLEInelasticModel =
614 new G4LESigmaMinusInelastic;
615 theInelasticProcess->RegisterMe(theLEInelasticModel);
616 G4HESigmaMinusInelastic* theHEInelasticModel =
617 new G4HESigmaMinusInelastic;
618 theInelasticProcess->RegisterMe(theHEInelasticModel);
619 pmanager->AddDiscreteProcess(theInelasticProcess);
620 }
621 else if (particleName == "anti_sigma+") {
622 pmanager->AddDiscreteProcess(theElasticProcess);
623 G4AntiSigmaPlusInelasticProcess* theInelasticProcess =
624 new G4AntiSigmaPlusInelasticProcess("inelastic");
625 G4LEAntiSigmaPlusInelastic* theLEInelasticModel =
626 new G4LEAntiSigmaPlusInelastic;
627 theInelasticProcess->RegisterMe(theLEInelasticModel);
628 G4HEAntiSigmaPlusInelastic* theHEInelasticModel =
629 new G4HEAntiSigmaPlusInelastic;
630 theInelasticProcess->RegisterMe(theHEInelasticModel);
631 pmanager->AddDiscreteProcess(theInelasticProcess);
632 }
633 else if (particleName == "anti_sigma-") {
634 pmanager->AddDiscreteProcess(theElasticProcess);
635 G4AntiSigmaMinusInelasticProcess* theInelasticProcess =
636 new G4AntiSigmaMinusInelasticProcess("inelastic");
637 G4LEAntiSigmaMinusInelastic* theLEInelasticModel =
638 new G4LEAntiSigmaMinusInelastic;
639 theInelasticProcess->RegisterMe(theLEInelasticModel);
640 G4HEAntiSigmaMinusInelastic* theHEInelasticModel =
641 new G4HEAntiSigmaMinusInelastic;
642 theInelasticProcess->RegisterMe(theHEInelasticModel);
643 pmanager->AddDiscreteProcess(theInelasticProcess);
644 }
645 else if (particleName == "xi0") {
646 pmanager->AddDiscreteProcess(theElasticProcess);
647 G4XiZeroInelasticProcess* theInelasticProcess =
648 new G4XiZeroInelasticProcess("inelastic");
649 G4LEXiZeroInelastic* theLEInelasticModel =
650 new G4LEXiZeroInelastic;
651 theInelasticProcess->RegisterMe(theLEInelasticModel);
652 G4HEXiZeroInelastic* theHEInelasticModel =
653 new G4HEXiZeroInelastic;
654 theInelasticProcess->RegisterMe(theHEInelasticModel);
655 pmanager->AddDiscreteProcess(theInelasticProcess);
656 }
657 else if (particleName == "xi-") {
658 pmanager->AddDiscreteProcess(theElasticProcess);
659 G4XiMinusInelasticProcess* theInelasticProcess =
660 new G4XiMinusInelasticProcess("inelastic");
661 G4LEXiMinusInelastic* theLEInelasticModel =
662 new G4LEXiMinusInelastic;
663 theInelasticProcess->RegisterMe(theLEInelasticModel);
664 G4HEXiMinusInelastic* theHEInelasticModel =
665 new G4HEXiMinusInelastic;
666 theInelasticProcess->RegisterMe(theHEInelasticModel);
667 pmanager->AddDiscreteProcess(theInelasticProcess);
668 }
669 else if (particleName == "anti_xi0") {
670 pmanager->AddDiscreteProcess(theElasticProcess);
671 G4AntiXiZeroInelasticProcess* theInelasticProcess =
672 new G4AntiXiZeroInelasticProcess("inelastic");
673 G4LEAntiXiZeroInelastic* theLEInelasticModel =
674 new G4LEAntiXiZeroInelastic;
675 theInelasticProcess->RegisterMe(theLEInelasticModel);
676 G4HEAntiXiZeroInelastic* theHEInelasticModel =
677 new G4HEAntiXiZeroInelastic;
678 theInelasticProcess->RegisterMe(theHEInelasticModel);
679 pmanager->AddDiscreteProcess(theInelasticProcess);
680 }
681 else if (particleName == "anti_xi-") {
682 pmanager->AddDiscreteProcess(theElasticProcess);
683 G4AntiXiMinusInelasticProcess* theInelasticProcess =
684 new G4AntiXiMinusInelasticProcess("inelastic");
685 G4LEAntiXiMinusInelastic* theLEInelasticModel =
686 new G4LEAntiXiMinusInelastic;
687 theInelasticProcess->RegisterMe(theLEInelasticModel);
688 G4HEAntiXiMinusInelastic* theHEInelasticModel =
689 new G4HEAntiXiMinusInelastic;
690 theInelasticProcess->RegisterMe(theHEInelasticModel);
691 pmanager->AddDiscreteProcess(theInelasticProcess);
692 }
693 else if (particleName == "deuteron") {
694 pmanager->AddDiscreteProcess(theElasticProcess);
695 G4DeuteronInelasticProcess* theInelasticProcess =
696 new G4DeuteronInelasticProcess("inelastic");
697 G4LEDeuteronInelastic* theLEInelasticModel =
698 new G4LEDeuteronInelastic;
699 theInelasticProcess->RegisterMe(theLEInelasticModel);
700 pmanager->AddDiscreteProcess(theInelasticProcess);
701 }
702 else if (particleName == "triton") {
703 pmanager->AddDiscreteProcess(theElasticProcess);
704 G4TritonInelasticProcess* theInelasticProcess =
705 new G4TritonInelasticProcess("inelastic");
706 G4LETritonInelastic* theLEInelasticModel =
707 new G4LETritonInelastic;
708 theInelasticProcess->RegisterMe(theLEInelasticModel);
709 pmanager->AddDiscreteProcess(theInelasticProcess);
710 }
711 else if (particleName == "alpha") {
712 pmanager->AddDiscreteProcess(theElasticProcess);
713 G4AlphaInelasticProcess* theInelasticProcess =
714 new G4AlphaInelasticProcess("inelastic");
715 G4LEAlphaInelastic* theLEInelasticModel =
716 new G4LEAlphaInelastic;
717 theInelasticProcess->RegisterMe(theLEInelasticModel);
718 pmanager->AddDiscreteProcess(theInelasticProcess);
719 }
720 else if (particleName == "omega-") {
721 pmanager->AddDiscreteProcess(theElasticProcess);
722 G4OmegaMinusInelasticProcess* theInelasticProcess =
723 new G4OmegaMinusInelasticProcess("inelastic");
724 G4LEOmegaMinusInelastic* theLEInelasticModel =
725 new G4LEOmegaMinusInelastic;
726 theInelasticProcess->RegisterMe(theLEInelasticModel);
727 G4HEOmegaMinusInelastic* theHEInelasticModel =
728 new G4HEOmegaMinusInelastic;
729 theInelasticProcess->RegisterMe(theHEInelasticModel);
730 pmanager->AddDiscreteProcess(theInelasticProcess);
731 }
732 else if (particleName == "anti_omega-") {
733 pmanager->AddDiscreteProcess(theElasticProcess);
734 G4AntiOmegaMinusInelasticProcess* theInelasticProcess =
735 new G4AntiOmegaMinusInelasticProcess("inelastic");
736 G4LEAntiOmegaMinusInelastic* theLEInelasticModel =
737 new G4LEAntiOmegaMinusInelastic;
738 theInelasticProcess->RegisterMe(theLEInelasticModel);
739 G4HEAntiOmegaMinusInelastic* theHEInelasticModel =
740 new G4HEAntiOmegaMinusInelastic;
741 theInelasticProcess->RegisterMe(theHEInelasticModel);
742 pmanager->AddDiscreteProcess(theInelasticProcess);
743 }
744 }
745
3c7cd15a 746 G4cout << "### TG4PhysicsList::ConstructHad() finished." << G4endl;
2817d3e2 747
748}
749
750
751#include <G4Cerenkov.hh>
752#include <G4OpAbsorption.hh>
753#include <G4OpRayleigh.hh>
754#include <G4OpBoundaryProcess.hh>
755
756void TG4PhysicsList::ConstructOp()
757{
758// Constructs optical processes.
759// According to ExN06PhysicsList.cc.
760// (geant4 1.1)
761// ---
762
763 G4Cerenkov* theCerenkovProcess = new G4Cerenkov("Cerenkov");
764 G4OpAbsorption* theAbsorptionProcess = new G4OpAbsorption();
765 G4OpRayleigh* theRayleighScatteringProcess = new G4OpRayleigh();
766 G4OpBoundaryProcess* theBoundaryProcess = new G4OpBoundaryProcess();
767
768 theCerenkovProcess->DumpPhysicsTable();
769 //theAbsorptionProcess->DumpPhysicsTable();
770 //theRayleighScatteringProcess->DumpPhysicsTable();
771
772 // add verbose
773 //theCerenkovProcess->SetVerboseLevel(1);
774 //theAbsorptionProcess->SetVerboseLevel(1);
775 //theRayleighScatteringProcess->SetVerboseLevel(1);
776 //theBoundaryProcess->SetVerboseLevel(1);
777
778 G4int maxNumPhotons = 300;
779
780 theCerenkovProcess->SetTrackSecondariesFirst(true);
781 theCerenkovProcess->SetMaxNumPhotonsPerStep(maxNumPhotons);
782
783 //G4OpticalSurfaceModel themodel = unified;
784 // model from GEANT3
785 G4OpticalSurfaceModel themodel = glisur;
786 theBoundaryProcess->SetModel(themodel);
787
788 theParticleIterator->reset();
789 while( (*theParticleIterator)() ){
790 G4ParticleDefinition* particle = theParticleIterator->value();
791 G4ProcessManager* processManager = particle->GetProcessManager();
792 G4String particleName = particle->GetParticleName();
793 if (theCerenkovProcess->IsApplicable(*particle)) {
794 processManager->AddContinuousProcess(theCerenkovProcess);
795 }
796 if (particleName == "opticalphoton") {
797 G4cout << " AddDiscreteProcess to OpticalPhoton " << G4endl;
798 processManager->AddDiscreteProcess(theAbsorptionProcess);
799 processManager->AddDiscreteProcess(theRayleighScatteringProcess);
800 processManager->AddDiscreteProcess(theBoundaryProcess);
801 }
802 }
803}
804
805#include <G4Decay.hh>
806
807void TG4PhysicsList::ConstructGeneral()
808{
809// Constructs general processes.
810// ---
811
812 // Add Decay Process
813 G4Decay* theDecayProcess = new G4Decay();
814 theParticleIterator->reset();
815 while( (*theParticleIterator)() ){
816 G4ParticleDefinition* particle = theParticleIterator->value();
817 G4ProcessManager* pmanager = particle->GetProcessManager();
818 if (theDecayProcess->IsApplicable(*particle)) {
819 pmanager ->AddProcess(theDecayProcess);
820 // set ordering for PostStepDoIt and AtRestDoIt
821 pmanager ->SetProcessOrdering(theDecayProcess, idxPostStep);
822 pmanager ->SetProcessOrdering(theDecayProcess, idxAtRest);
823 }
824 }
825}
826
827void TG4PhysicsList::ConstructSpecialCuts()
828{
829// Adds TG4SpecialCuts "process" that activates
830// the kinetic energy cuts defined in
831// the vector of cuts (PhysicsManager::fCutVector) or in TG4Limits.
832// ---
833
834 TG4PhysicsManager* physicsManager
835 = TG4PhysicsManager::Instance();
836
837 if (physicsManager->IsSpecialCuts())
838 {
839 TG4CutVector* cutVector
840 = physicsManager->GetCutVector();
841 TG4boolVector* isCutVector
842 = physicsManager->GetIsCutVector();
843
844 theParticleIterator->reset();
845 while ((*theParticleIterator)())
846 {
847 G4ParticleDefinition* particle = theParticleIterator->value();
848 TG3ParticleWSP particleWSP
849 = physicsManager->GetG3ParticleWSP(particle);
850 G4String name;
851 physicsManager->GetG3ParticleWSPName(particleWSP, name);
852
853 // uncomment this to see all particles "WSP"
854 //G4cout << "Iterating particle: "
855 // << particle->GetParticleName() << " " << particleWSP << " "
3c7cd15a 856 // << name << G4endl;
2817d3e2 857
858 // special process is created in case
859 // cutVector (vector of kinetic energy cuts) is set
860 // or the special cut is set by TG4Limits
861 if ((particleWSP !=kNofParticlesWSP) &&
862 ((*isCutVector)[particleWSP])) {
863 // check if process already exists
864 G4String processName = "specialCutFor" + name;
865 G4VProcess* process = FindProcess(processName);
866 if (!process) {
867 process = new TG4SpecialCuts(particleWSP, cutVector, processName);
868 }
869 //particle->GetProcessManager()->AddProcess(process, 0, -1, 1);
870 particle->GetProcessManager()->AddDiscreteProcess(process);
871 }
872 }
873
874 if (verboseLevel>0) {
3c7cd15a 875 G4cout << "TG4PhysicsList::ConstructSpecialCuts: " << G4endl;
2817d3e2 876 if (cutVector)
3c7cd15a 877 G4cout << " Global kinetic energy cuts are set." << G4endl;
878 G4cout << " Special cuts process is defined for: " << G4endl
2817d3e2 879 << " ";
880 for (G4int i=0; i<kAny; i++) {
881 G4String name;
882 physicsManager->GetG3ParticleWSPName(i, name);
883 if ((*isCutVector)[i]) G4cout << name << " ";
884 }
3c7cd15a 885 G4cout << G4endl;
2817d3e2 886 }
887 }
888}
889
890void TG4PhysicsList::ConstructSpecialFlags()
891{
892// Adds TG4SpecialFlags "process" that activates
893// the control process flags defined in TG4Limits.
894// ---
895
896 TG4PhysicsManager* physicsManager
897 = TG4PhysicsManager::Instance();
898
899 if (physicsManager->IsSpecialFlags())
900 {
3c7cd15a 901 G4cout << "IsSpecialFlags started" << G4endl;
2817d3e2 902 TG4boolVector* isFlagVector
903 = physicsManager->GetIsFlagVector();
904
905 theParticleIterator->reset();
906 while ((*theParticleIterator)())
907 {
908 G4ParticleDefinition* particle = theParticleIterator->value();
909 TG3ParticleWSP particleWSP
910 = physicsManager->GetG3ParticleWSP(particle);
911 //G4String name;
912 //GetG3ParticleWSPName(particleWSP, name);
913
914 // special process is set in case
915 // the special flag is set by TG4Limits
916 if ((particleWSP !=kNofParticlesWSP) &&
917 ((*isFlagVector)[particleWSP])) {
918 // check if process already exists
919 G4String processName = "specialFlag";
920 G4VProcess* process = FindProcess(processName);
921 if (!process) {
922 process = new TG4SpecialFlags(processName);
923 }
924 //particle->GetProcessManager()->AddProcess(process, 0, -1, 1);
925 particle->GetProcessManager()->AddDiscreteProcess(process);
926 }
927 }
928
929 if (verboseLevel>0) {
3c7cd15a 930 G4cout << "TG4PhysicsList::ConstructSpecialFlagss: " << G4endl;
931 G4cout << " Special flags process is defined for: " << G4endl
2817d3e2 932 << " ";
933 for (G4int i=0; i<kNofParticlesWSP; i++) {
934 G4String name;
935 physicsManager->GetG3ParticleWSPName(i, name);
936 if ((*isFlagVector)[i]) G4cout << name << " ";
937 }
3c7cd15a 938 G4cout << G4endl;
2817d3e2 939 }
940 }
941}
942
943void TG4PhysicsList::SetCuts()
944{
6eb14eb0 945// Sets the default cut value for all particle types
946// other then e-/e+.
947// The cut value for e-/e+ is high in oredr to supress
948// tracking of delta electrons.
2817d3e2 949// ---
950
6eb14eb0 951 // SetCutsWithDefault();
952 // "G4VUserPhysicsList::SetCutsWithDefault" method sets
953 // the default cut value for all particle types.
954
955 // default cut value
956 G4double cut = defaultCutValue;
957 G4double ecut = 10.*m;
368e370d 958 //G4double ecut = cut;
6eb14eb0 959
960#ifdef G4VERBOSE
961 if (verboseLevel >1){
962 G4cout << "G4VUserPhysicsList::SetCutsWithDefault:";
963 G4cout << "CutLength : " << cut/mm << " (mm)" << G4endl;
964 }
965#endif
966
967 // set cut values for gamma at first and for e- second and next for e+,
968 // because some processes for e+/e- need cut values for gamma
969 SetCutValue(cut, "gamma");
970 SetCutValue(ecut, "e-");
971 SetCutValue(ecut, "e+");
972
973 // set cut values for proton and anti_proton before all other hadrons
974 // because some processes for hadrons need cut values for proton/anti_proton
975 SetCutValue(cut, "proton");
976 SetCutValue(cut, "anti_proton");
977
978 SetCutValueForOthers(cut);
979
980 if (verboseLevel>1) {
981 DumpCutValuesTable();
982 }
2817d3e2 983}
984
985void TG4PhysicsList::ConstructAllBosons()
986{
987// Construct all bosons
988// ---
989
990 G4BosonConstructor pConstructor;
991 pConstructor.ConstructParticle();
992}
993
994void TG4PhysicsList::ConstructAllLeptons()
995{
996// Construct all leptons
997// ---
998
999 G4LeptonConstructor pConstructor;
1000 pConstructor.ConstructParticle();
1001}
1002
1003void TG4PhysicsList::ConstructAllMesons()
1004{
1005// Construct all mesons
1006// ---
1007
1008 G4MesonConstructor pConstructor;
1009 pConstructor.ConstructParticle();
1010}
1011
1012void TG4PhysicsList::ConstructAllBaryons()
1013{
1014// Construct all barions
1015// ---
1016
1017 G4BaryonConstructor pConstructor;
1018 pConstructor.ConstructParticle();
1019}
1020
1021void TG4PhysicsList::ConstructAllIons()
1022{
1023// Construct light ions
1024// ---
1025
1026 G4IonConstructor pConstructor;
1027 pConstructor.ConstructParticle();
1028}
1029
1030void TG4PhysicsList::ConstructAllShortLiveds()
1031{
1032// Construct resonaces and quarks
1033// ---
1034
1035 G4ShortLivedConstructor pConstructor;
1036 pConstructor.ConstructParticle();
1037}
1038
1039// private methods
1040
1041G4VProcess* TG4PhysicsList::FindProcess(G4String processName) const
1042{
1043// Finds G4VProcess with specified name.
1044// ---
1045
1046 G4ProcessTable* processTable = G4ProcessTable::GetProcessTable();
1047
1048 G4ProcessVector* processVector
1049 = processTable->FindProcesses(processName);
1050 G4VProcess* firstFoundProcess = 0;
1051 if (processVector->entries()>0) firstFoundProcess= (*processVector)[0];
1052
1053 processVector->clear();
1054 delete processVector;
1055
1056 return firstFoundProcess;
1057}
1058
1059void TG4PhysicsList::InActivateProcess(G4String processName,
1060 G4ParticleDefinition* particle)
1061{
1062// Activates the process specified by name for the specified
1063// particle.
1064// Only for tests - to be removed.
1065// ---
1066
1067 G4ProcessManager* processManager = particle->GetProcessManager();
1068 G4ProcessVector* processVector = processManager->GetProcessList();
1069 for (G4int i=0; i<processVector->entries(); i++) {
1070 if ((*processVector)[i]->GetProcessName() == processName) {
1071 processManager->SetProcessActivation((*processVector)[i], false);
1072 return;
1073 }
1074 }
1075
1076 G4String text = "TG4PhysicsList::InActivateProcess: ";
1077 text = text + processName + " is not set for ";
1078 text = text + particle->GetParticleName();
1079 TG4Globals::Exception(text);
1080}
1081
1082void TG4PhysicsList::InActivateEM()
1083{
1084// Inactivates specified electromagnetic processes.
1085// Only for tests - to be removed.
1086// !! This method must be called after all Construct methods.
1087// Uncomment the selected line(s) to inactivate desired processes.
1088// ---
1089
1090 theParticleIterator->reset();
1091 while ((*theParticleIterator)())
1092 {
1093 G4ParticleDefinition* particle = theParticleIterator->value();
1094 G4String name = particle->GetParticleName();
1095
1096 if (name == "gamma") {
1097 // gamma
1098 //InActivateProcess("phot", particle);
1099 //InActivateProcess("compt", particle);
1100 //InActivateProcess("conv", particle);
1101 }
1102 else if (name == "e-") {
1103 //electron
1104 InActivateProcess("msc", particle);
3c7cd15a 1105 G4cout << "msc inactivated." << G4endl;
2817d3e2 1106 //InActivateProcess("eIoni", particle);
3c7cd15a 1107 //G4cout << "eIoni inactivated." << G4endl;
2817d3e2 1108 InActivateProcess("eBrem", particle);
3c7cd15a 1109 G4cout << "eBrem inactivated." << G4endl;
2817d3e2 1110 }
1111 else if (name == "e+") {
1112 //positron
1113 //InActivateProcess("msc", particle);
1114 //InActivateProcess("eIoni", particle);
1115 //InActivateProcess("eBrem", particle);
1116 //InActivateProcess("annihil", particle);
1117 }
1118 else if (name == "mu+" || name == "mu-") {
1119 //muon
1120 //InActivateProcess("msc", particle);
1121 //InActivateProcess("MuIoni", particle);
1122 //InActivateProcess("MuBrem", particle);
1123 //InActivateProcess("MuPairProd", particle);
1124 }
1125 else if ((!particle->IsShortLived()) &&
1126 (particle->GetPDGCharge() != 0.0) &&
1127 (particle->GetParticleName() != "chargedgeantino"))
1128 {
1129 // all others charged particles except geantino
1130 //InActivateProcess("msc", particle);
1131 //InActivateProcess("hIoni", particle);
1132 }
1133 }
1134}
1135