source: trunk/examples/extended/runAndEvent/RE02/src/RE02HadronPhysics.cc@ 1036

Last change on this file since 1036 was 807, checked in by garnier, 17 years ago

update
File size: 30.5 KB
RevLine 
[807]1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26// $Id: RE02HadronPhysics.cc,v 1.2 2006/06/29 17:45:18 gunter Exp $
27// --------------------------------------------------------------
28//
29// 09-Oct-2003 Hadron Physics List with Parameterization Model by T. Koi
30// 12-Oct-2003 Bug Fixed (KaonMinus) by T. Koi
31// 16-Nov-2005 Binary Cascade for Protons. by T. Aso
32// Proton : BinaryCascade < 6 GeV, 4 GeV < LE Model,
33// Neutron: BinaryCascade < 6 GeV, 4 GeV < LE Model,
34//
35
36#include "RE02HadronPhysics.hh"
37
38#include "globals.hh"
39#include "G4ios.hh"
40#include <iomanip>
41
42
43RE02HadronPhysics::RE02HadronPhysics(const G4String& name)
44 : G4VPhysicsConstructor(name)
45{
46}
47
48RE02HadronPhysics::~RE02HadronPhysics()
49{
50}
51
52#include "G4ParticleDefinition.hh"
53#include "G4ParticleTable.hh"
54
55#include "G4ProcessManager.hh"
56
57void RE02HadronPhysics::ConstructProcess()
58{
59 G4ProcessManager * pManager = 0;
60
61 // Pi+ Physics
62 pManager = G4PionPlus::PionPlus()->GetProcessManager();
63
64 // add processes
65 G4HadronElasticProcess* theppElasticProcess
66 = new G4HadronElasticProcess();
67 G4LElastic* theppElasticModel = new G4LElastic();
68 theppElasticProcess->RegisterMe(theppElasticModel);
69 pManager->AddDiscreteProcess(theppElasticProcess);
70
71 G4PionPlusInelasticProcess* thePionPlusInelasticProcess
72 = new G4PionPlusInelasticProcess();
73
74 G4LEPionPlusInelastic* thePionPlusLEPModel = new G4LEPionPlusInelastic();
75 G4HEPionPlusInelastic* thePionPlusHEPModel = new G4HEPionPlusInelastic();
76 thePionPlusInelasticProcess->RegisterMe(thePionPlusLEPModel);
77 thePionPlusInelasticProcess->RegisterMe(thePionPlusHEPModel);
78 pManager->AddDiscreteProcess(thePionPlusInelasticProcess);
79
80 G4VProcess* theppMultipleScattering = new G4MultipleScattering();
81 G4VProcess* theppIonisation = new G4hIonisation();
82 //
83 pManager->AddProcess(theppIonisation);
84 pManager->AddProcess(theppMultipleScattering);
85 //
86 // set ordering for AlongStepDoIt
87 pManager->SetProcessOrdering(theppMultipleScattering, idxAlongStep,1);
88 pManager->SetProcessOrdering(theppIonisation, idxAlongStep,2);
89 //
90 // set ordering for PostStepDoIt
91 pManager->SetProcessOrdering(theppMultipleScattering, idxPostStep,1);
92 pManager->SetProcessOrdering(theppIonisation, idxPostStep,2);
93
94
95 // Pi- Physics
96 pManager = G4PionMinus::PionMinus()->GetProcessManager();
97
98 G4HadronElasticProcess* thepmElasticProcess
99 = new G4HadronElasticProcess();
100 G4LElastic* thepmElasticModel = new G4LElastic();
101 thepmElasticProcess->RegisterMe(thepmElasticModel);
102 pManager->AddDiscreteProcess(thepmElasticProcess);
103
104 G4PionMinusInelasticProcess* thePionMinusInelasticProcess
105 = new G4PionMinusInelasticProcess();
106
107 G4LEPionMinusInelastic* thePionMinusLEPModel = new G4LEPionMinusInelastic();
108 G4HEPionMinusInelastic* thePionMinusHEPModel = new G4HEPionMinusInelastic();
109 thePionMinusInelasticProcess->RegisterMe(thePionMinusLEPModel);
110 thePionMinusInelasticProcess->RegisterMe(thePionMinusHEPModel);
111 pManager->AddDiscreteProcess(thePionMinusInelasticProcess);
112
113 G4VProcess* thepmMultipleScattering = new G4MultipleScattering();
114 G4VProcess* thepmIonisation = new G4hIonisation();
115 //
116 // add processes
117 pManager->AddProcess(thepmIonisation);
118 pManager->AddProcess(thepmMultipleScattering);
119 //
120 // set ordering for AlongStepDoIt
121 pManager->SetProcessOrdering(thepmMultipleScattering, idxAlongStep,1);
122 pManager->SetProcessOrdering(thepmIonisation, idxAlongStep,2);
123 //
124 // set ordering for PostStepDoIt
125 pManager->SetProcessOrdering(thepmMultipleScattering, idxPostStep,1);
126 pManager->SetProcessOrdering(thepmIonisation, idxPostStep,2);
127
128
129 // K+ Physics
130 pManager = G4KaonPlus::KaonPlus()->GetProcessManager();
131
132 G4HadronElasticProcess* thekpElasticProcess
133 = new G4HadronElasticProcess();
134 G4LElastic* thekpElasticModel = new G4LElastic();
135 thekpElasticProcess->RegisterMe(thekpElasticModel);
136 pManager->AddDiscreteProcess(thekpElasticProcess);
137
138 G4KaonPlusInelasticProcess* theKaonPlusInelasticProcess
139 = new G4KaonPlusInelasticProcess();
140
141 G4LEKaonPlusInelastic* theKaonPlusLEPModel = new G4LEKaonPlusInelastic();
142 G4HEKaonPlusInelastic* theKaonPlusHEPModel = new G4HEKaonPlusInelastic();
143 theKaonPlusInelasticProcess->RegisterMe(theKaonPlusLEPModel);
144 theKaonPlusInelasticProcess->RegisterMe(theKaonPlusHEPModel);
145 pManager->AddDiscreteProcess(theKaonPlusInelasticProcess);
146
147 G4VProcess* thekpMultipleScattering = new G4MultipleScattering();
148 G4VProcess* thekpIonisation = new G4hIonisation();
149 //
150 // add processes
151 pManager->AddProcess(thekpIonisation);
152 pManager->AddProcess(thekpMultipleScattering);
153 //
154 // set ordering for AlongStepDoIt
155 pManager->SetProcessOrdering(thekpMultipleScattering, idxAlongStep,1);
156 pManager->SetProcessOrdering(thekpIonisation, idxAlongStep,2);
157 //
158 // set ordering for PostStepDoIt
159 pManager->SetProcessOrdering(thekpMultipleScattering, idxPostStep,1);
160 pManager->SetProcessOrdering(thekpIonisation, idxPostStep,2);
161
162
163 // K- Physics
164 pManager = G4KaonMinus::KaonMinus()->GetProcessManager();
165
166 // add processes
167 G4HadronElasticProcess* thekmElasticProcess
168 = new G4HadronElasticProcess();
169 G4LElastic* thekmElasticModel = new G4LElastic();
170 thekmElasticProcess->RegisterMe(thekmElasticModel);
171 pManager->AddDiscreteProcess(thekmElasticProcess);
172
173 G4KaonMinusInelasticProcess* theKaonMinusInelasticProcess
174 = new G4KaonMinusInelasticProcess();
175
176 G4LEKaonMinusInelastic* theKaonMinusLEPModel = new G4LEKaonMinusInelastic();
177 G4HEKaonMinusInelastic* theKaonMinusHEPModel = new G4HEKaonMinusInelastic();
178 theKaonMinusInelasticProcess->RegisterMe(theKaonMinusLEPModel);
179 theKaonMinusInelasticProcess->RegisterMe(theKaonMinusHEPModel);
180 pManager->AddDiscreteProcess(theKaonMinusInelasticProcess);
181
182 G4VProcess* thekmMultipleScattering = new G4MultipleScattering();
183 G4VProcess* thekmIonisation = new G4hIonisation();
184
185 pManager->AddProcess(thekmIonisation);
186 pManager->AddProcess(thekmMultipleScattering);
187
188 // set ordering for AlongStepDoIt
189 pManager->SetProcessOrdering(thekmMultipleScattering, idxAlongStep,1);
190 pManager->SetProcessOrdering(thekmIonisation, idxAlongStep,2);
191 //
192 // set ordering for PostStepDoIt
193 pManager->SetProcessOrdering(thekmMultipleScattering, idxPostStep,1);
194 pManager->SetProcessOrdering(thekmIonisation, idxPostStep,2);
195
196
197 // Kaon0L Phsics
198 pManager = G4KaonZeroLong::KaonZeroLong()->GetProcessManager();
199
200 G4HadronElasticProcess* thek0lElasticProcess
201 = new G4HadronElasticProcess();
202 G4LElastic* thek0lElasticModel = new G4LElastic();
203 thek0lElasticProcess->RegisterMe(thek0lElasticModel);
204 pManager->AddDiscreteProcess(thek0lElasticProcess);
205
206 G4KaonZeroLInelasticProcess* theKaonZeroLInelasticProcess
207 = new G4KaonZeroLInelasticProcess();
208
209 G4LEKaonZeroLInelastic* theKaonZeroLLEPModel = new G4LEKaonZeroLInelastic();
210 G4HEKaonZeroInelastic* theKaonZerolHEPModel = new G4HEKaonZeroInelastic();
211 theKaonZeroLInelasticProcess->RegisterMe(theKaonZeroLLEPModel);
212 theKaonZeroLInelasticProcess->RegisterMe(theKaonZerolHEPModel);
213 pManager->AddDiscreteProcess(theKaonZeroLInelasticProcess);
214
215
216 // Kaon0S Phsics
217 pManager = G4KaonZeroShort::KaonZeroShort()->GetProcessManager();
218
219 G4HadronElasticProcess* thek0sElasticProcess
220 = new G4HadronElasticProcess();
221 G4LElastic* thek0sElasticModel = new G4LElastic();
222 thek0sElasticProcess->RegisterMe(thek0sElasticModel);
223 pManager->AddDiscreteProcess(thek0sElasticProcess);
224
225 G4KaonZeroSInelasticProcess* theKaonZeroSInelasticProcess
226 = new G4KaonZeroSInelasticProcess();
227
228 G4LEKaonZeroSInelastic* theKaonZeroSLEPModel = new G4LEKaonZeroSInelastic();
229 G4HEKaonZeroInelastic* theKaonZerosHEPModel = new G4HEKaonZeroInelastic();
230 theKaonZeroSInelasticProcess->RegisterMe(theKaonZeroSLEPModel);
231 theKaonZeroSInelasticProcess->RegisterMe(theKaonZerosHEPModel);
232 pManager->AddDiscreteProcess(theKaonZeroSInelasticProcess);
233
234
235 // Proton Physics
236 pManager = G4Proton::Proton()->GetProcessManager();
237
238 // add process
239 G4HadronElasticProcess* thepElasticProcess
240 = new G4HadronElasticProcess();
241 G4LElastic* thepElasticModel = new G4LElastic();
242 thepElasticProcess->RegisterMe(thepElasticModel);
243 pManager->AddDiscreteProcess(thepElasticProcess);
244
245 G4ProtonInelasticProcess* theProtonInelasticProcess
246 = new G4ProtonInelasticProcess();
247
248 G4BinaryCascade* theProtonBCModel = new G4BinaryCascade();
249 theProtonBCModel->SetMaxEnergy(6.*GeV);
250 G4LEProtonInelastic* theProtonLEPModel = new G4LEProtonInelastic();
251 theProtonLEPModel->SetMinEnergy(4.*GeV);
252 G4HEProtonInelastic* theProtonHEPModel = new G4HEProtonInelastic();
253 theProtonInelasticProcess->RegisterMe(theProtonBCModel);
254 theProtonInelasticProcess->RegisterMe(theProtonLEPModel);
255 theProtonInelasticProcess->RegisterMe(theProtonHEPModel);
256 pManager->AddDiscreteProcess(theProtonInelasticProcess);
257
258 G4VProcess* thepMultipleScattering = new G4MultipleScattering();
259 G4VProcess* thepIonisation = new G4hIonisation();
260
261 pManager->AddProcess(thepIonisation);
262 pManager->AddProcess(thepMultipleScattering);
263
264 // set ordering for AlongStepDoIt
265 pManager->SetProcessOrdering(thepMultipleScattering, idxAlongStep,1);
266 pManager->SetProcessOrdering(thepIonisation, idxAlongStep,2);
267 //
268 // set ordering for PostStepDoIt
269 pManager->SetProcessOrdering(thepMultipleScattering, idxPostStep,1);
270 pManager->SetProcessOrdering(thepIonisation, idxPostStep,2);
271
272
273 // anti-proton Physics
274 pManager = G4AntiProton::AntiProton()->GetProcessManager();
275
276 // add process
277 G4HadronElasticProcess* theapElasticProcess
278 = new G4HadronElasticProcess();
279 G4LElastic* theapElasticModel = new G4LElastic();
280 theapElasticProcess->RegisterMe(theapElasticModel);
281 pManager->AddDiscreteProcess(theapElasticProcess);
282
283 G4AntiProtonInelasticProcess* theAntiProtonInelasticProcess
284 = new G4AntiProtonInelasticProcess();
285
286 G4LEAntiProtonInelastic* theAntiProtonLEPModel = new G4LEAntiProtonInelastic();
287 G4HEAntiProtonInelastic* theAntiProtonHEPModel = new G4HEAntiProtonInelastic();
288 theAntiProtonInelasticProcess->RegisterMe(theAntiProtonLEPModel);
289 theAntiProtonInelasticProcess->RegisterMe(theAntiProtonHEPModel);
290 pManager->AddDiscreteProcess(theAntiProtonInelasticProcess);
291
292 G4AntiProtonAnnihilationAtRest* theAntiProtonAnnihilation
293 = new G4AntiProtonAnnihilationAtRest();
294 pManager->AddRestProcess(theAntiProtonAnnihilation);
295
296 G4VProcess* theapMultipleScattering = new G4MultipleScattering();
297 G4VProcess* theapIonisation = new G4hIonisation();
298
299 pManager->AddProcess(theapIonisation);
300 pManager->AddProcess(theapMultipleScattering);
301
302 // set ordering for AlongStepDoIt
303 pManager->SetProcessOrdering(theapMultipleScattering, idxAlongStep,1);
304 pManager->SetProcessOrdering(theapIonisation, idxAlongStep,2);
305 //
306 // set ordering for PostStepDoIt
307 pManager->SetProcessOrdering(theapMultipleScattering, idxPostStep,1);
308 pManager->SetProcessOrdering(theapIonisation, idxPostStep,2);
309
310
311 // neutron Physics
312 pManager = G4Neutron::Neutron()->GetProcessManager();
313
314 // add process
315 G4HadronElasticProcess* thenElasticProcess
316 = new G4HadronElasticProcess();
317 G4LElastic* thenElasticModel = new G4LElastic();
318 thenElasticProcess->RegisterMe(thenElasticModel);
319 pManager->AddDiscreteProcess(thenElasticProcess);
320
321 G4NeutronInelasticProcess* theNeutronInelasticProcess
322 = new G4NeutronInelasticProcess();
323
324 G4BinaryCascade* theNeutronBCModel = new G4BinaryCascade();
325 theNeutronBCModel->SetMaxEnergy(6.*GeV);
326 G4LENeutronInelastic* theNeutronLEPModel = new G4LENeutronInelastic();
327 theNeutronLEPModel->SetMinEnergy(4.*GeV);
328 G4HENeutronInelastic* theNeutronHEPModel = new G4HENeutronInelastic();
329 theNeutronInelasticProcess->RegisterMe(theNeutronBCModel);
330 theNeutronInelasticProcess->RegisterMe(theNeutronLEPModel);
331 theNeutronInelasticProcess->RegisterMe(theNeutronHEPModel);
332 pManager->AddDiscreteProcess(theNeutronInelasticProcess);
333
334 G4HadronFissionProcess* thenFission
335 = new G4HadronFissionProcess();
336 G4LFission* thenFissionModel = new G4LFission();
337 thenFission->RegisterMe(thenFissionModel);
338 pManager->AddDiscreteProcess(thenFission);
339
340
341 G4HadronCaptureProcess* thenCapture
342 = new G4HadronCaptureProcess();
343 G4LCapture* thenCaptureModel = new G4LCapture();
344 thenCapture->RegisterMe(thenCaptureModel);
345 pManager->AddDiscreteProcess(thenCapture);
346
347
348 // anti-neutron Physics
349 pManager = G4AntiNeutron::AntiNeutron()->GetProcessManager();
350
351 // add process
352 G4HadronElasticProcess* theanElasticProcess
353 = new G4HadronElasticProcess();
354 G4LElastic* theanElasticModel = new G4LElastic();
355 theanElasticProcess->RegisterMe(theanElasticModel);
356 pManager->AddDiscreteProcess(theanElasticProcess);
357
358 G4AntiNeutronInelasticProcess* theAntiNeutronInelasticProcess
359 = new G4AntiNeutronInelasticProcess();
360
361 G4LEAntiNeutronInelastic* theAntiNeutronLEPModel = new G4LEAntiNeutronInelastic();
362 G4HEAntiNeutronInelastic* theAntiNeutronHEPModel = new G4HEAntiNeutronInelastic();
363 theAntiNeutronInelasticProcess->RegisterMe(theAntiNeutronLEPModel);
364 theAntiNeutronInelasticProcess->RegisterMe(theAntiNeutronHEPModel);
365 pManager->AddDiscreteProcess(theAntiNeutronInelasticProcess);
366
367 G4AntiNeutronAnnihilationAtRest* theAntiNeutronAnnihilation
368 = new G4AntiNeutronAnnihilationAtRest();
369 pManager->AddRestProcess(theAntiNeutronAnnihilation);
370
371
372 // Lambda Physics
373 pManager = G4Lambda::Lambda()->GetProcessManager();
374
375 // add process
376 G4HadronElasticProcess* thel0ElasticProcess
377 = new G4HadronElasticProcess();
378 G4LElastic* thel0ElasticModel = new G4LElastic();
379 thel0ElasticProcess->RegisterMe(thel0ElasticModel);
380 pManager->AddDiscreteProcess(thel0ElasticProcess);
381
382 G4LambdaInelasticProcess* theLambdaInelasticProcess
383 = new G4LambdaInelasticProcess();
384
385 G4LELambdaInelastic* theLambdaLEPModel = new G4LELambdaInelastic();
386 G4HELambdaInelastic* theLambdaHEPModel = new G4HELambdaInelastic();
387 theLambdaInelasticProcess->RegisterMe(theLambdaLEPModel);
388 theLambdaInelasticProcess->RegisterMe(theLambdaHEPModel);
389 pManager->AddDiscreteProcess(theLambdaInelasticProcess);
390
391
392 // Anti-Labda Physics
393 pManager = G4AntiLambda::AntiLambda()->GetProcessManager();
394
395 // add process
396 G4HadronElasticProcess* theal0ElasticProcess
397 = new G4HadronElasticProcess();
398 G4LElastic* theal0ElasticModel = new G4LElastic();
399 theal0ElasticProcess->RegisterMe(theal0ElasticModel);
400 pManager->AddDiscreteProcess(theal0ElasticProcess);
401
402 G4AntiLambdaInelasticProcess* theAntiLambdaInelasticProcess
403 = new G4AntiLambdaInelasticProcess();
404
405 G4LEAntiLambdaInelastic* theAntiLambdaLEPModel = new G4LEAntiLambdaInelastic();
406 G4HEAntiLambdaInelastic* theAntiLambdaHEPModel = new G4HEAntiLambdaInelastic();
407 theAntiLambdaInelasticProcess->RegisterMe(theAntiLambdaLEPModel);
408 theAntiLambdaInelasticProcess->RegisterMe(theAntiLambdaHEPModel);
409 pManager->AddDiscreteProcess(theAntiLambdaInelasticProcess);
410
411
412 // Sigma+ Physics
413 pManager = G4SigmaPlus::SigmaPlus()->GetProcessManager();
414
415 // add process
416 G4HadronElasticProcess* thespElasticProcess
417 = new G4HadronElasticProcess();
418 G4LElastic* thespElasticModel = new G4LElastic();
419 thespElasticProcess->RegisterMe(thespElasticModel);
420 pManager->AddDiscreteProcess(thespElasticProcess);
421
422 G4SigmaPlusInelasticProcess* theSigmaPlusInelasticProcess
423 = new G4SigmaPlusInelasticProcess();
424
425 G4LESigmaPlusInelastic* theSigmaPlusLEPModel = new G4LESigmaPlusInelastic();
426 G4HESigmaPlusInelastic* theSigmaPlusHEPModel = new G4HESigmaPlusInelastic();
427 theSigmaPlusInelasticProcess->RegisterMe(theSigmaPlusLEPModel);
428 theSigmaPlusInelasticProcess->RegisterMe(theSigmaPlusHEPModel);
429 pManager->AddDiscreteProcess(theSigmaPlusInelasticProcess);
430
431 G4VProcess* thespMultipleScattering = new G4MultipleScattering();
432 G4VProcess* thespIonisation = new G4hIonisation();
433
434 pManager->AddProcess(thespIonisation);
435 pManager->AddProcess(thespMultipleScattering);
436
437 // set ordering for AlongStepDoIt
438 pManager->SetProcessOrdering(thespMultipleScattering, idxAlongStep,1);
439 pManager->SetProcessOrdering(thespIonisation, idxAlongStep,2);
440 //
441 // set ordering for PostStepDoIt
442 pManager->SetProcessOrdering(thespMultipleScattering, idxPostStep,1);
443 pManager->SetProcessOrdering(thespIonisation, idxPostStep,2);
444
445
446 // anti-Sigma+ Physics
447 pManager = G4AntiSigmaPlus::AntiSigmaPlus()->GetProcessManager();
448
449 // add process
450 G4HadronElasticProcess* theaspElasticProcess
451 = new G4HadronElasticProcess();
452 G4LElastic* theaspElasticModel = new G4LElastic();
453 theaspElasticProcess->RegisterMe(theaspElasticModel);
454 pManager->AddDiscreteProcess(theaspElasticProcess);
455
456 G4AntiSigmaPlusInelasticProcess* theAntiSigmaPlusInelasticProcess
457 = new G4AntiSigmaPlusInelasticProcess();
458
459 G4LEAntiSigmaPlusInelastic* theAntiSigmaPlusLEPModel = new G4LEAntiSigmaPlusInelastic();
460 G4HEAntiSigmaPlusInelastic* theAntiSigmaPlusHEPModel = new G4HEAntiSigmaPlusInelastic();
461 theAntiSigmaPlusInelasticProcess->RegisterMe(theAntiSigmaPlusLEPModel);
462 theAntiSigmaPlusInelasticProcess->RegisterMe(theAntiSigmaPlusHEPModel);
463 pManager->AddDiscreteProcess(theAntiSigmaPlusInelasticProcess);
464
465 G4VProcess* theaspMultipleScattering = new G4MultipleScattering();
466 G4VProcess* theaspIonisation = new G4hIonisation();
467
468 pManager->AddProcess(theaspIonisation);
469 pManager->AddProcess(theaspMultipleScattering);
470
471 // set ordering for AlongStepDoIt
472 pManager->SetProcessOrdering(theaspMultipleScattering, idxAlongStep,1);
473 pManager->SetProcessOrdering(theaspIonisation, idxAlongStep,2);
474 //
475 // set ordering for PostStepDoIt
476 pManager->SetProcessOrdering(theaspMultipleScattering, idxPostStep,1);
477 pManager->SetProcessOrdering(theaspIonisation, idxPostStep,2);
478
479
480 // Sigma- Physics
481 pManager = G4SigmaMinus::SigmaMinus()->GetProcessManager();
482
483 // add process
484 G4HadronElasticProcess* thesmElasticProcess
485 = new G4HadronElasticProcess();
486 G4LElastic* thesmElasticModel = new G4LElastic();
487 thesmElasticProcess->RegisterMe(thesmElasticModel);
488 pManager->AddDiscreteProcess(thesmElasticProcess);
489
490 G4SigmaMinusInelasticProcess* theSigmaMinusInelasticProcess
491 = new G4SigmaMinusInelasticProcess();
492
493 G4LESigmaMinusInelastic* theSigmaMinusLEPModel = new G4LESigmaMinusInelastic();
494 G4HESigmaMinusInelastic* theSigmaMinusHEPModel = new G4HESigmaMinusInelastic();
495 theSigmaMinusInelasticProcess->RegisterMe(theSigmaMinusLEPModel);
496 theSigmaMinusInelasticProcess->RegisterMe(theSigmaMinusHEPModel);
497 pManager->AddDiscreteProcess(theSigmaMinusInelasticProcess);
498
499 G4VProcess* thesmMultipleScattering = new G4MultipleScattering();
500 G4VProcess* thesmIonisation = new G4hIonisation();
501
502 pManager->AddProcess(thesmIonisation);
503 pManager->AddProcess(thesmMultipleScattering);
504
505 // set ordering for AlongStepDoIt
506 pManager->SetProcessOrdering(thesmMultipleScattering, idxAlongStep,1);
507 pManager->SetProcessOrdering(thesmIonisation, idxAlongStep,2);
508 //
509 // set ordering for PostStepDoIt
510 pManager->SetProcessOrdering(thesmMultipleScattering, idxPostStep,1);
511 pManager->SetProcessOrdering(thesmIonisation, idxPostStep,2);
512
513
514 // anti-Sigma- Physics
515 pManager = G4AntiSigmaMinus::AntiSigmaMinus()->GetProcessManager();
516
517 // add process
518 G4HadronElasticProcess* theasmElasticProcess
519 = new G4HadronElasticProcess();
520 G4LElastic* theasmElasticModel = new G4LElastic();
521 theasmElasticProcess->RegisterMe(theasmElasticModel);
522 pManager->AddDiscreteProcess(theasmElasticProcess);
523
524 G4AntiSigmaMinusInelasticProcess* theAntiSigmaMinusInelasticProcess
525 = new G4AntiSigmaMinusInelasticProcess();
526
527 G4LEAntiSigmaMinusInelastic* theAntiSigmaMinusLEPModel = new G4LEAntiSigmaMinusInelastic();
528 G4HEAntiSigmaMinusInelastic* theAntiSigmaMinusHEPModel = new G4HEAntiSigmaMinusInelastic();
529 theAntiSigmaMinusInelasticProcess->RegisterMe(theAntiSigmaMinusLEPModel);
530 theAntiSigmaMinusInelasticProcess->RegisterMe(theAntiSigmaMinusHEPModel);
531 pManager->AddDiscreteProcess(theAntiSigmaMinusInelasticProcess);
532
533 G4VProcess* theasmMultipleScattering = new G4MultipleScattering();
534 G4VProcess* theasmIonisation = new G4hIonisation();
535
536 pManager->AddProcess(theasmIonisation);
537 pManager->AddProcess(theasmMultipleScattering);
538
539 // set ordering for AlongStepDoIt
540 pManager->SetProcessOrdering(theasmMultipleScattering, idxAlongStep,1);
541 pManager->SetProcessOrdering(theasmIonisation, idxAlongStep,2);
542 //
543 // set ordering for PostStepDoIt
544 pManager->SetProcessOrdering(theasmMultipleScattering, idxPostStep,1);
545 pManager->SetProcessOrdering(theasmIonisation, idxPostStep,2);
546
547
548 // Xi0 Physics
549 pManager = G4XiZero::XiZero()->GetProcessManager();
550
551 // add process
552 G4HadronElasticProcess* thex0ElasticProcess
553 = new G4HadronElasticProcess();
554 G4LElastic* thex0ElasticModel = new G4LElastic();
555 thex0ElasticProcess->RegisterMe(thex0ElasticModel);
556 pManager->AddDiscreteProcess(thex0ElasticProcess);
557
558 G4XiZeroInelasticProcess* theXiZeroInelasticProcess
559 = new G4XiZeroInelasticProcess();
560
561 G4LEXiZeroInelastic* theXiZeroLEPModel = new G4LEXiZeroInelastic();
562 G4HEXiZeroInelastic* theXiZeroHEPModel = new G4HEXiZeroInelastic();
563 theXiZeroInelasticProcess->RegisterMe(theXiZeroLEPModel);
564 theXiZeroInelasticProcess->RegisterMe(theXiZeroHEPModel);
565 pManager->AddDiscreteProcess(theXiZeroInelasticProcess);
566
567
568 // Anti-Xi0 Physics
569 pManager = G4AntiXiZero::AntiXiZero()->GetProcessManager();
570
571 // add process
572 G4HadronElasticProcess* theax0ElasticProcess
573 = new G4HadronElasticProcess();
574 G4LElastic* theax0ElasticModel = new G4LElastic();
575 theax0ElasticProcess->RegisterMe(theax0ElasticModel);
576 pManager->AddDiscreteProcess(theax0ElasticProcess);
577
578 G4AntiXiZeroInelasticProcess* theAntiXiZeroInelasticProcess
579 = new G4AntiXiZeroInelasticProcess();
580
581 G4LEAntiXiZeroInelastic* theAntiXiZeroLEPModel = new G4LEAntiXiZeroInelastic();
582 G4HEAntiXiZeroInelastic* theAntiXiZeroHEPModel = new G4HEAntiXiZeroInelastic();
583 theAntiXiZeroInelasticProcess->RegisterMe(theAntiXiZeroLEPModel);
584 theAntiXiZeroInelasticProcess->RegisterMe(theAntiXiZeroHEPModel);
585 pManager->AddDiscreteProcess(theAntiXiZeroInelasticProcess);
586
587
588 // Xi- Physics
589 pManager = G4XiMinus::XiMinus()->GetProcessManager();
590
591 // add process
592 G4HadronElasticProcess* thexmElasticProcess
593 = new G4HadronElasticProcess();
594 G4LElastic* thexmElasticModel = new G4LElastic();
595 thexmElasticProcess->RegisterMe(thexmElasticModel);
596 pManager->AddDiscreteProcess(thexmElasticProcess);
597
598 G4XiMinusInelasticProcess* theXiMinusInelasticProcess
599 = new G4XiMinusInelasticProcess();
600
601 G4LEXiMinusInelastic* theXiMinusLEPModel = new G4LEXiMinusInelastic();
602 G4HEXiMinusInelastic* theXiMinusHEPModel = new G4HEXiMinusInelastic();
603 theXiMinusInelasticProcess->RegisterMe(theXiMinusLEPModel);
604 theXiMinusInelasticProcess->RegisterMe(theXiMinusHEPModel);
605 pManager->AddDiscreteProcess(theXiMinusInelasticProcess);
606
607 G4VProcess* thexmMultipleScattering = new G4MultipleScattering();
608 G4VProcess* thexmIonisation = new G4hIonisation();
609
610 pManager->AddProcess(thexmIonisation);
611 pManager->AddProcess(thexmMultipleScattering);
612
613 // set ordering for AlongStepDoIt
614 pManager->SetProcessOrdering(thexmMultipleScattering, idxAlongStep,1);
615 pManager->SetProcessOrdering(thexmIonisation, idxAlongStep,2);
616 //
617 // set ordering for PostStepDoIt
618 pManager->SetProcessOrdering(thexmMultipleScattering, idxPostStep,1);
619 pManager->SetProcessOrdering(thexmIonisation, idxPostStep,2);
620
621
622 // anti-Xi- Physics
623 pManager = G4AntiXiMinus::AntiXiMinus()->GetProcessManager();
624
625 // add process
626 G4HadronElasticProcess* theaxmElasticProcess
627 = new G4HadronElasticProcess();
628 G4LElastic* theaxmElasticModel = new G4LElastic();
629 theaxmElasticProcess->RegisterMe(theaxmElasticModel);
630 pManager->AddDiscreteProcess(theaxmElasticProcess);
631
632 G4AntiXiMinusInelasticProcess* theAntiXiMinusInelasticProcess
633 = new G4AntiXiMinusInelasticProcess();
634
635 G4LEAntiXiMinusInelastic* theAntiXiMinusLEPModel = new G4LEAntiXiMinusInelastic();
636 G4HEAntiXiMinusInelastic* theAntiXiMinusHEPModel = new G4HEAntiXiMinusInelastic();
637 theAntiXiMinusInelasticProcess->RegisterMe(theAntiXiMinusLEPModel);
638 theAntiXiMinusInelasticProcess->RegisterMe(theAntiXiMinusHEPModel);
639 pManager->AddDiscreteProcess(theAntiXiMinusInelasticProcess);
640
641 G4VProcess* theaxmMultipleScattering = new G4MultipleScattering();
642 G4VProcess* theaxmIonisation = new G4hIonisation();
643
644 pManager->AddProcess(theaxmIonisation);
645 pManager->AddProcess(theaxmMultipleScattering);
646
647 // set ordering for AlongStepDoIt
648 pManager->SetProcessOrdering(theaxmMultipleScattering, idxAlongStep,1);
649 pManager->SetProcessOrdering(theaxmIonisation, idxAlongStep,2);
650 //
651 // set ordering for PostStepDoIt
652 pManager->SetProcessOrdering(theaxmMultipleScattering, idxPostStep,1);
653 pManager->SetProcessOrdering(theaxmIonisation, idxPostStep,2);
654
655
656 // Omega- Physics
657 pManager = G4OmegaMinus::OmegaMinus()->GetProcessManager();
658
659 // add process
660 G4HadronElasticProcess* theomElasticProcess
661 = new G4HadronElasticProcess();
662 G4LElastic* theomElasticModel = new G4LElastic();
663 theomElasticProcess->RegisterMe(theomElasticModel);
664 pManager->AddDiscreteProcess(theomElasticProcess);
665
666 G4OmegaMinusInelasticProcess* theOmegaMinusInelasticProcess
667 = new G4OmegaMinusInelasticProcess();
668
669 G4LEOmegaMinusInelastic* theOmegaMinusLEPModel = new G4LEOmegaMinusInelastic();
670 G4HEOmegaMinusInelastic* theOmegaMinusHEPModel = new G4HEOmegaMinusInelastic();
671 theOmegaMinusInelasticProcess->RegisterMe(theOmegaMinusLEPModel);
672 theOmegaMinusInelasticProcess->RegisterMe(theOmegaMinusHEPModel);
673 pManager->AddDiscreteProcess(theOmegaMinusInelasticProcess);
674
675 G4VProcess* theomMultipleScattering = new G4MultipleScattering();
676 G4VProcess* theomIonisation = new G4hIonisation();
677
678 pManager->AddProcess(theomIonisation);
679 pManager->AddProcess(theomMultipleScattering);
680
681 // set ordering for AlongStepDoIt
682 pManager->SetProcessOrdering(theomMultipleScattering, idxAlongStep,1);
683 pManager->SetProcessOrdering(theomIonisation, idxAlongStep,2);
684 //
685 // set ordering for PostStepDoIt
686 pManager->SetProcessOrdering(theomMultipleScattering, idxPostStep,1);
687 pManager->SetProcessOrdering(theomIonisation, idxPostStep,2);
688
689
690 // anti-Omega- Physics
691 pManager = G4AntiOmegaMinus::AntiOmegaMinus()->GetProcessManager();
692
693 // add process
694 G4HadronElasticProcess* theaomElasticProcess
695 = new G4HadronElasticProcess();
696 G4LElastic* theaomElasticModel = new G4LElastic();
697 theaomElasticProcess->RegisterMe(theaomElasticModel);
698 pManager->AddDiscreteProcess(theaomElasticProcess);
699
700 G4AntiOmegaMinusInelasticProcess* theAntiOmegaMinusInelasticProcess
701 = new G4AntiOmegaMinusInelasticProcess();
702
703 G4LEAntiOmegaMinusInelastic* theAntiOmegaMinusLEPModel = new G4LEAntiOmegaMinusInelastic();
704 G4HEAntiOmegaMinusInelastic* theAntiOmegaMinusHEPModel = new G4HEAntiOmegaMinusInelastic();
705 theAntiOmegaMinusInelasticProcess->RegisterMe(theAntiOmegaMinusLEPModel);
706 theAntiOmegaMinusInelasticProcess->RegisterMe(theAntiOmegaMinusHEPModel);
707 pManager->AddDiscreteProcess(theAntiOmegaMinusInelasticProcess);
708
709 G4VProcess* theaomMultipleScattering = new G4MultipleScattering();
710 G4VProcess* theaomIonisation = new G4hIonisation();
711
712 pManager->AddProcess(theaomIonisation);
713 pManager->AddProcess(theaomMultipleScattering);
714
715 // set ordering for AlongStepDoIt
716 pManager->SetProcessOrdering(theaomMultipleScattering, idxAlongStep,1);
717 pManager->SetProcessOrdering(theaomIonisation, idxAlongStep,2);
718 //
719 // set ordering for PostStepDoIt
720 pManager->SetProcessOrdering(theaomMultipleScattering, idxPostStep,1);
721 pManager->SetProcessOrdering(theaomIonisation, idxPostStep,2);
722
723}
Note: See TracBrowser for help on using the repository browser.