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