source: trunk/examples/extended/analysis/A01/src/A01HadronPhysics.cc@ 1230

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

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