source: trunk/environments/g4py/examples/demos/water_phantom/g4lib/PhysicsListLHad.cc @ 1337

Last change on this file since 1337 was 1337, checked in by garnier, 14 years ago

tag geant4.9.4 beta 1 + modifs locales
File size: 15.3 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: PhysicsListLHad.cc,v 1.4 2010/06/04 05:43:47 kmura Exp $
27// ====================================================================
28//   PhysicsListLHad.cc
29//
30//   Light package of hadron physics
31// ====================================================================
32#include "PhysicsListLHad.hh"
33#include "G4ProcessManager.hh"
34#include "G4ParticleDefinition.hh"
35
36#include "G4hMultipleScattering.hh"
37#include "G4hIonisation.hh"
38
39// Hadronic Processes
40#include "G4HadronElasticProcess.hh"
41#include "G4HadronFissionProcess.hh"
42#include "G4HadronCaptureProcess.hh"
43#include "G4ProtonInelasticProcess.hh"
44#include "G4AntiProtonInelasticProcess.hh"
45#include "G4NeutronInelasticProcess.hh"
46#include "G4AntiNeutronInelasticProcess.hh"
47#include "G4PionPlusInelasticProcess.hh"
48#include "G4PionMinusInelasticProcess.hh"
49#include "G4KaonPlusInelasticProcess.hh"
50#include "G4KaonZeroSInelasticProcess.hh"
51#include "G4KaonZeroLInelasticProcess.hh"
52#include "G4KaonMinusInelasticProcess.hh"
53
54// Low energy models
55#include "G4LElastic.hh"
56#include "G4LFission.hh"
57#include "G4LCapture.hh"
58#include "G4LEProtonInelastic.hh"
59#include "G4LEAntiProtonInelastic.hh"
60#include "G4LENeutronInelastic.hh"
61#include "G4LEAntiNeutronInelastic.hh"
62#include "G4LEPionPlusInelastic.hh"
63#include "G4LEPionMinusInelastic.hh"
64#include "G4LEKaonPlusInelastic.hh"
65#include "G4LEKaonZeroSInelastic.hh"
66#include "G4LEKaonZeroLInelastic.hh"
67#include "G4LEKaonMinusInelastic.hh"
68
69// High-energy Models
70#include "G4HEProtonInelastic.hh"
71#include "G4HEAntiProtonInelastic.hh"
72#include "G4HEPionPlusInelastic.hh"
73#include "G4HEPionMinusInelastic.hh"
74#include "G4HEKaonPlusInelastic.hh"
75#include "G4HEKaonZeroInelastic.hh"
76#include "G4HEKaonZeroInelastic.hh"
77#include "G4HEKaonMinusInelastic.hh"
78
79// Stopping processes
80#include "G4AntiProtonAnnihilationAtRest.hh"
81
82// Binary Cascade
83#include "G4BinaryCascade.hh"
84#include "G4ProtonInelasticCrossSection.hh"
85
86// ====================================================================
87//
88// class description
89//
90// ====================================================================
91
92//////////////////////////////////
93PhysicsListLHad::PhysicsListLHad()
94  :  G4VPhysicsConstructor("LHad")
95//////////////////////////////////
96{
97}
98
99
100///////////////////////////////////
101PhysicsListLHad::~PhysicsListLHad()
102///////////////////////////////////
103{
104}
105
106
107/////////////////////////////////////////
108void PhysicsListLHad::ConstructParticle()
109/////////////////////////////////////////
110{
111}
112
113
114////////////////////////////////////////
115void PhysicsListLHad::ConstructProcess()
116////////////////////////////////////////
117{
118  G4ProcessManager* pManager;
119
120  // ---------------------------------------------------------------
121  // proton
122  // ---------------------------------------------------------------
123  pManager= G4Proton::Proton()-> GetProcessManager();
124
125  // elastic
126  G4HadronElasticProcess* thepElasticProcess = new G4HadronElasticProcess();
127  G4LElastic* thepElasticModel = new G4LElastic();
128  thepElasticProcess->RegisterMe(thepElasticModel);
129  pManager-> AddDiscreteProcess(thepElasticProcess);
130
131  // inelastic
132  G4ProtonInelasticProcess* theProtonInelasticProcess
133    = new G4ProtonInelasticProcess(); 
134
135  G4HEProtonInelastic* theProtonHEPModel = new G4HEProtonInelastic(); 
136
137  G4LEProtonInelastic* theProtonLEPModel = new G4LEProtonInelastic();
138  theProtonLEPModel->SetMinEnergy(2.8*GeV);
139   
140  G4BinaryCascade* theProtonBICModel = new G4BinaryCascade();
141  theProtonBICModel->SetMaxEnergy(3.2*GeV);
142
143  theProtonInelasticProcess-> RegisterMe(theProtonHEPModel);
144  theProtonInelasticProcess-> RegisterMe(theProtonLEPModel);
145  theProtonInelasticProcess-> RegisterMe(theProtonBICModel);
146
147  // add Xsection data of BIC
148  G4ProtonInelasticCrossSection* theProtonInelasticData
149    = new G4ProtonInelasticCrossSection();
150  theProtonInelasticProcess-> AddDataSet( theProtonInelasticData );
151
152  pManager-> AddDiscreteProcess(theProtonInelasticProcess);
153
154  // QED
155  G4VProcess* thepMultipleScattering = new G4hMultipleScattering();
156  G4VProcess* thepIonisation         = new G4hIonisation();
157
158  pManager-> AddProcess(thepIonisation);
159  pManager-> AddProcess(thepMultipleScattering);
160
161  pManager-> SetProcessOrdering(thepMultipleScattering, idxAlongStep, 1);
162  pManager-> SetProcessOrdering(thepIonisation,         idxAlongStep, 2);
163
164  pManager-> SetProcessOrdering(thepMultipleScattering, idxPostStep, 1);
165  pManager-> SetProcessOrdering(thepIonisation,         idxPostStep, 2);
166
167  // ---------------------------------------------------------------
168  // anti-proton
169  // ---------------------------------------------------------------
170  pManager= G4AntiProton::AntiProton()-> GetProcessManager();
171
172  // elastic
173  G4HadronElasticProcess* theapElasticProcess = new G4HadronElasticProcess();
174  G4LElastic* theapElasticModel = new G4LElastic();
175  theapElasticProcess-> RegisterMe(theapElasticModel);
176  pManager-> AddDiscreteProcess(theapElasticProcess);
177
178  // inelastic
179  G4AntiProtonInelasticProcess* theAntiProtonInelasticProcess
180    = new G4AntiProtonInelasticProcess(); 
181
182  G4LEAntiProtonInelastic* theAntiProtonLEPModel
183    = new G4LEAntiProtonInelastic();
184  G4HEAntiProtonInelastic* theAntiProtonHEPModel
185    = new G4HEAntiProtonInelastic();
186
187  theAntiProtonInelasticProcess-> RegisterMe(theAntiProtonLEPModel);
188  theAntiProtonInelasticProcess-> RegisterMe(theAntiProtonHEPModel);
189  pManager-> AddDiscreteProcess(theAntiProtonInelasticProcess);
190
191  G4AntiProtonAnnihilationAtRest* theAntiProtonAnnihilation
192    =  new G4AntiProtonAnnihilationAtRest();
193  pManager-> AddRestProcess(theAntiProtonAnnihilation);
194
195  // QED
196  G4VProcess* theapMultipleScattering = new G4hMultipleScattering();
197  G4VProcess* theapIonisation         = new G4hIonisation();
198
199  pManager-> AddProcess(theapIonisation);
200  pManager-> AddProcess(theapMultipleScattering);
201
202  pManager->SetProcessOrdering(theapMultipleScattering, idxAlongStep, 1);
203  pManager->SetProcessOrdering(theapIonisation,         idxAlongStep, 2);
204
205  pManager->SetProcessOrdering(theapMultipleScattering, idxPostStep, 1);
206  pManager->SetProcessOrdering(theapIonisation,         idxPostStep, 2);
207
208
209  // ---------------------------------------------------------------
210  // mesons...
211  // ---------------------------------------------------------------
212
213  // ---------------------------------------------------------------
214  // pi+
215  // ---------------------------------------------------------------
216  pManager= G4PionPlus::PionPlus()-> GetProcessManager();
217
218  // elastic
219  G4HadronElasticProcess* theppElasticProcess = new G4HadronElasticProcess();
220  G4LElastic* theppElasticModel = new G4LElastic();
221  theppElasticProcess-> RegisterMe(theppElasticModel);
222  pManager-> AddDiscreteProcess(theppElasticProcess);
223
224  // inelastic
225  G4PionPlusInelasticProcess* thePionPlusInelasticProcess
226    = new G4PionPlusInelasticProcess(); 
227
228  G4LEPionPlusInelastic* thePionPlusLEPModel = new G4LEPionPlusInelastic();
229  G4HEPionPlusInelastic* thePionPlusHEPModel = new G4HEPionPlusInelastic();
230  thePionPlusInelasticProcess->RegisterMe(thePionPlusLEPModel);
231  thePionPlusInelasticProcess->RegisterMe(thePionPlusHEPModel);
232  pManager-> AddDiscreteProcess(thePionPlusInelasticProcess);
233
234  // QED
235  G4VProcess* theppMultipleScattering = new G4hMultipleScattering();
236  G4VProcess* theppIonisation         = new G4hIonisation();
237
238  pManager-> AddProcess(theppIonisation);
239  pManager-> AddProcess(theppMultipleScattering);
240
241  pManager-> SetProcessOrdering(theppMultipleScattering, idxAlongStep, 1);
242  pManager-> SetProcessOrdering(theppIonisation,         idxAlongStep, 2);
243
244  pManager-> SetProcessOrdering(theppMultipleScattering, idxPostStep, 1);
245  pManager-> SetProcessOrdering(theppIonisation,         idxPostStep, 2);
246 
247  // ---------------------------------------------------------------
248  // pi-
249  // ---------------------------------------------------------------
250  pManager= G4PionMinus::PionMinus()-> GetProcessManager();
251
252  // elastic
253  G4HadronElasticProcess* thepmElasticProcess = new G4HadronElasticProcess();
254  G4LElastic* thepmElasticModel = new G4LElastic();
255  thepmElasticProcess->RegisterMe(thepmElasticModel);
256  pManager-> AddDiscreteProcess(thepmElasticProcess);
257
258  // inelastic
259  G4PionMinusInelasticProcess* thePionMinusInelasticProcess
260    = new G4PionMinusInelasticProcess(); 
261
262  G4LEPionMinusInelastic* thePionMinusLEPModel = new G4LEPionMinusInelastic();
263  G4HEPionMinusInelastic* thePionMinusHEPModel = new G4HEPionMinusInelastic();
264  thePionMinusInelasticProcess-> RegisterMe(thePionMinusLEPModel);
265  thePionMinusInelasticProcess-> RegisterMe(thePionMinusHEPModel);
266  pManager-> AddDiscreteProcess(thePionMinusInelasticProcess);
267
268  // QED
269  G4VProcess* thepmMultipleScattering = new G4hMultipleScattering();
270  G4VProcess* thepmIonisation         = new G4hIonisation();
271
272  pManager-> AddProcess(thepmIonisation);
273  pManager-> AddProcess(thepmMultipleScattering);
274
275  pManager-> SetProcessOrdering(thepmMultipleScattering, idxAlongStep, 1);
276  pManager-> SetProcessOrdering(thepmIonisation,         idxAlongStep, 2);
277
278  pManager-> SetProcessOrdering(thepmMultipleScattering, idxPostStep, 1);
279  pManager-> SetProcessOrdering(thepmIonisation,         idxPostStep, 2);
280
281  // ---------------------------------------------------------------
282  // K+
283  // ---------------------------------------------------------------
284  pManager= G4KaonPlus::KaonPlus()-> GetProcessManager();
285
286  // elastic
287  G4HadronElasticProcess* thekpElasticProcess = new G4HadronElasticProcess();
288  G4LElastic* thekpElasticModel = new G4LElastic();
289  thekpElasticProcess->RegisterMe(thekpElasticModel);
290  pManager->AddDiscreteProcess(thekpElasticProcess);
291
292  // inelastic
293  G4KaonPlusInelasticProcess* theKaonPlusInelasticProcess
294    = new G4KaonPlusInelasticProcess(); 
295
296  G4LEKaonPlusInelastic* theKaonPlusLEPModel = new G4LEKaonPlusInelastic();
297  G4HEKaonPlusInelastic* theKaonPlusHEPModel = new G4HEKaonPlusInelastic();
298  theKaonPlusInelasticProcess-> RegisterMe(theKaonPlusLEPModel);
299  theKaonPlusInelasticProcess-> RegisterMe(theKaonPlusHEPModel);
300  pManager-> AddDiscreteProcess(theKaonPlusInelasticProcess);
301
302  // QED
303  G4VProcess* thekpMultipleScattering = new G4hMultipleScattering();
304  G4VProcess* thekpIonisation         = new G4hIonisation();
305
306  pManager-> AddProcess(thekpIonisation);
307  pManager-> AddProcess(thekpMultipleScattering);
308
309  pManager-> SetProcessOrdering(thekpMultipleScattering, idxAlongStep, 1);
310  pManager-> SetProcessOrdering(thekpIonisation,         idxAlongStep, 2);
311
312  pManager-> SetProcessOrdering(thekpMultipleScattering, idxPostStep, 1);
313  pManager-> SetProcessOrdering(thekpIonisation,         idxPostStep, 2);
314
315  // ---------------------------------------------------------------
316  // K-
317  // ---------------------------------------------------------------
318  pManager= G4KaonMinus::KaonMinus()->GetProcessManager();
319
320  // elastic
321  G4HadronElasticProcess* thekmElasticProcess = new G4HadronElasticProcess();
322  G4LElastic* thekmElasticModel = new G4LElastic();
323  thekmElasticProcess->RegisterMe(thekmElasticModel);
324  pManager->AddDiscreteProcess(thekmElasticProcess);
325
326  // inelastic
327  G4KaonMinusInelasticProcess* theKaonMinusInelasticProcess
328    = new G4KaonMinusInelasticProcess(); 
329
330  G4LEKaonMinusInelastic* theKaonMinusLEPModel = new G4LEKaonMinusInelastic();
331  G4HEKaonMinusInelastic* theKaonMinusHEPModel = new G4HEKaonMinusInelastic();
332  theKaonMinusInelasticProcess->RegisterMe(theKaonMinusLEPModel);
333  theKaonMinusInelasticProcess->RegisterMe(theKaonMinusHEPModel);
334  pManager->AddDiscreteProcess(theKaonMinusInelasticProcess);
335
336  // QED
337  G4VProcess* thekmMultipleScattering = new G4hMultipleScattering();
338  G4VProcess* thekmIonisation         = new G4hIonisation();
339
340  pManager-> AddProcess(thekmIonisation);
341  pManager-> AddProcess(thekmMultipleScattering);
342
343  pManager->SetProcessOrdering(thekmMultipleScattering, idxAlongStep, 1);
344  pManager->SetProcessOrdering(thekmIonisation,         idxAlongStep, 2);
345
346  pManager->SetProcessOrdering(thekmMultipleScattering, idxPostStep, 1);
347  pManager->SetProcessOrdering(thekmIonisation,         idxPostStep, 2);
348
349  // ---------------------------------------------------------------
350  // K0L
351  // ---------------------------------------------------------------
352  pManager= G4KaonZeroLong::KaonZeroLong()-> GetProcessManager();
353
354  // elastic
355  G4HadronElasticProcess* thek0lElasticProcess = new G4HadronElasticProcess();
356  G4LElastic* thek0lElasticModel = new G4LElastic();
357  thek0lElasticProcess-> RegisterMe(thek0lElasticModel);
358  pManager-> AddDiscreteProcess(thek0lElasticProcess);
359
360  // inelastic
361  G4KaonZeroLInelasticProcess* theKaonZeroLInelasticProcess
362    = new G4KaonZeroLInelasticProcess(); 
363
364  G4LEKaonZeroLInelastic* theKaonZeroLLEPModel = new G4LEKaonZeroLInelastic();
365  G4HEKaonZeroInelastic* theKaonZerolHEPModel  = new G4HEKaonZeroInelastic();
366
367  theKaonZeroLInelasticProcess-> RegisterMe(theKaonZeroLLEPModel);
368  theKaonZeroLInelasticProcess-> RegisterMe(theKaonZerolHEPModel);
369
370  pManager-> AddDiscreteProcess(theKaonZeroLInelasticProcess);
371
372  // ---------------------------------------------------------------
373  // K0S
374  // ---------------------------------------------------------------
375  pManager= G4KaonZeroShort::KaonZeroShort()-> GetProcessManager();
376
377  // elastic
378  G4HadronElasticProcess* thek0sElasticProcess = new G4HadronElasticProcess();
379  G4LElastic* thek0sElasticModel = new G4LElastic();
380  thek0sElasticProcess-> RegisterMe(thek0sElasticModel);
381  pManager-> AddDiscreteProcess(thek0sElasticProcess);
382
383  // inelastic
384  G4KaonZeroSInelasticProcess* theKaonZeroSInelasticProcess
385    = new G4KaonZeroSInelasticProcess(); 
386
387  G4LEKaonZeroSInelastic* theKaonZeroSLEPModel = new G4LEKaonZeroSInelastic();
388  G4HEKaonZeroInelastic* theKaonZerosHEPModel  = new G4HEKaonZeroInelastic();
389
390  theKaonZeroSInelasticProcess-> RegisterMe(theKaonZeroSLEPModel);
391  theKaonZeroSInelasticProcess-> RegisterMe(theKaonZerosHEPModel);
392
393  pManager-> AddDiscreteProcess(theKaonZeroSInelasticProcess);
394
395}
396
Note: See TracBrowser for help on using the repository browser.