source: trunk/source/processes/scoring/test/test1/src/A01HadronPhysics.cc @ 1199

Last change on this file since 1199 was 1199, checked in by garnier, 15 years ago

nvx fichiers dans CVS
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.2 2006/12/13 15:49:10 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.