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