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

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

update
File size: 30.5 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: 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.