source: trunk/examples/advanced/gammaray_telescope/src/GammaRayTelHadronPhysics.cc@ 1313

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

update to geant4.9.3
File size: 16.6 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//
27// $Id: GammaRayTelHadronPhysics.cc,v 1.4 2006/06/29 15:56:45 gunter Exp $
28// GEANT4 tag $Name: geant4-09-03-cand-01 $
29//
30
31#include "GammaRayTelHadronPhysics.hh"
32#include "G4ShortLivedConstructor.hh"
33#include "globals.hh"
34#include "G4ios.hh"
35#include <iomanip>
36
37
38GammaRayTelHadronPhysics::GammaRayTelHadronPhysics(const G4String& name)
39 : G4VPhysicsConstructor(name)
40{
41
42
43}
44
45GammaRayTelHadronPhysics::~GammaRayTelHadronPhysics()
46{
47 delete theStringDecay;
48}
49
50
51#include "G4ProcessManager.hh"
52
53
54void GammaRayTelHadronPhysics::ConstructProcess()
55{
56
57 G4ProcessManager * pManager = 0;
58 /*
59 G4cout << "" << G4endl;
60 G4cout << "You are using the GammaRayTelHadronPhysics" << G4endl;
61 G4cout << " - Note that this hadronic physics list is not optimized for any particular usage" << G4endl;
62 G4cout << " - If you wish to have a starting point tailored for a particular area of work," << G4endl;
63 G4cout << " please use one of the available physics lists by use-case." << G4endl;
64 G4cout << "" << G4endl;
65 */
66
67 // Elastic Process
68 theElasticModel = new G4LElastic();
69 theElasticProcess.RegisterMe(theElasticModel);
70
71 // pi+ and pi-
72
73 theCascade = new G4GeneratorPrecompoundInterface();
74 thePreEquilib = new G4PreCompoundModel(&theHandler);
75 theCascade -> SetDeExcitation(thePreEquilib);
76
77 theStringModel = new G4QGSModel< G4QGSParticipants >;
78 theStringDecay = new G4ExcitedStringDecay(new G4QGSMFragmentation);
79 theStringModel -> SetFragmentationModel(theStringDecay);
80
81 theModel = new G4TheoFSGenerator();
82 theModel -> SetTransport(theCascade);
83 theModel -> SetHighEnergyGenerator(theStringModel);
84 theModel -> SetMinEnergy(15*GeV);
85 theModel -> SetMaxEnergy(100*TeV);
86
87 // PionPlus
88 G4ParticleDefinition* pion = G4PionPlus::PionPlusDefinition();
89 pManager = pion ->GetProcessManager();
90 // add process
91 pManager->AddDiscreteProcess(&theElasticProcess);
92
93 theLEPionPlusModel = new G4LEPionPlusInelastic();
94 thePionPlusInelastic.RegisterMe(theLEPionPlusModel);
95 thePionPlusInelastic.RegisterMe(theModel);
96 pManager->AddDiscreteProcess(&thePionPlusInelastic);
97
98 pManager->AddProcess(&thePionPlusIonisation, ordInActive,2, 2);
99
100 pManager->AddProcess(&thePionPlusMult);
101 pManager->SetProcessOrdering(&thePionPlusMult, idxAlongStep, 1);
102 pManager->SetProcessOrdering(&thePionPlusMult, idxPostStep, 1);
103
104 // PionMinus
105 G4ParticleDefinition* pionMinus = G4PionMinus::PionMinusDefinition();
106 pManager = pionMinus -> GetProcessManager();
107 // add process
108 pManager->AddDiscreteProcess(&theElasticProcess);
109
110 theLEPionMinusModel = new G4LEPionMinusInelastic();
111 thePionMinusInelastic.RegisterMe(theLEPionMinusModel);
112 thePionMinusInelastic.RegisterMe(theModel);
113 pManager->AddDiscreteProcess(&thePionMinusInelastic);
114
115 pManager->AddProcess(&thePionMinusIonisation, ordInActive,2, 2);
116
117 pManager->AddProcess(&thePionMinusMult);
118 pManager->SetProcessOrdering(&thePionMinusMult, idxAlongStep, 1);
119 pManager->SetProcessOrdering(&thePionMinusMult, idxPostStep, 1);
120
121 pManager->AddRestProcess(&thePionMinusAbsorption, ordDefault);
122
123 // KaonPlus
124 G4ParticleDefinition* kaonPlus = G4KaonPlus::KaonPlusDefinition();
125 pManager = kaonPlus->GetProcessManager();
126 // add process
127 pManager->AddDiscreteProcess(&theElasticProcess);
128
129 theLEKaonPlusModel = new G4LEKaonPlusInelastic();
130 theHEKaonPlusModel = new G4HEKaonPlusInelastic();
131 theKaonPlusInelastic.RegisterMe(theLEKaonPlusModel);
132 theKaonPlusInelastic.RegisterMe(theModel);
133 pManager->AddDiscreteProcess(&theKaonPlusInelastic);
134
135 pManager->AddProcess(&theKaonPlusIonisation, ordInActive,2, 2);
136
137 pManager->AddProcess(&theKaonPlusMult);
138 pManager->SetProcessOrdering(&theKaonPlusMult, idxAlongStep, 1);
139 pManager->SetProcessOrdering(&theKaonPlusMult, idxPostStep, 1);
140
141 // KaonMinus
142 G4ParticleDefinition* kaonMinus = G4KaonMinus::KaonMinusDefinition();
143 pManager = kaonMinus->GetProcessManager();
144 // add process
145 pManager->AddDiscreteProcess(&theElasticProcess);
146
147 theLEKaonMinusModel = new G4LEKaonMinusInelastic();
148 theHEKaonMinusModel = new G4HEKaonMinusInelastic();
149 theKaonMinusInelastic.RegisterMe(theLEKaonMinusModel);
150 theKaonMinusInelastic.RegisterMe(theHEKaonMinusModel);
151 pManager->AddDiscreteProcess(&theKaonMinusInelastic);
152
153 pManager->AddProcess(&theKaonMinusIonisation, ordInActive,2, 2);
154
155 pManager->AddProcess(&theKaonMinusMult);
156 pManager->SetProcessOrdering(&theKaonMinusMult, idxAlongStep, 1);
157 pManager->SetProcessOrdering(&theKaonMinusMult, idxPostStep, 1);
158
159 pManager->AddRestProcess(&theKaonMinusAbsorption, ordDefault);
160
161 // KaonZeroL
162 pManager = G4KaonZeroLong::KaonZeroLong()->GetProcessManager();
163 // add process
164 pManager->AddDiscreteProcess(&theElasticProcess);
165
166 theLEKaonZeroLModel = new G4LEKaonZeroLInelastic();
167 theHEKaonZeroLModel = new G4HEKaonZeroInelastic();
168 theKaonZeroLInelastic.RegisterMe(theLEKaonZeroLModel);
169 theKaonZeroLInelastic.RegisterMe(theHEKaonZeroLModel);
170 pManager->AddDiscreteProcess(&theKaonZeroLInelastic);
171
172 // KaonZeroS
173 pManager = G4KaonZeroShort::KaonZeroShort()->GetProcessManager();
174 // add process
175 pManager->AddDiscreteProcess(&theElasticProcess);
176
177 theLEKaonZeroSModel = new G4LEKaonZeroSInelastic();
178 theHEKaonZeroSModel = new G4HEKaonZeroInelastic();
179 theKaonZeroSInelastic.RegisterMe(theLEKaonZeroSModel);
180 theKaonZeroSInelastic.RegisterMe(theHEKaonZeroSModel);
181 pManager->AddDiscreteProcess(&theKaonZeroSInelastic);
182
183 // Proton
184 pManager = G4Proton::Proton()->GetProcessManager();
185 // add process
186 pManager->AddDiscreteProcess(&theElasticProcess);
187
188 theLEProtonModel = new G4LEProtonInelastic();
189 theHEProtonModel = new G4HEProtonInelastic();
190 theProtonInelastic.RegisterMe(theLEProtonModel);
191 theProtonInelastic.RegisterMe(theModel);
192 pManager->AddDiscreteProcess(&theProtonInelastic);
193
194 pManager->AddProcess(&theProtonIonisation, ordInActive,2, 2);
195
196 pManager->AddProcess(&theProtonMult);
197 pManager->SetProcessOrdering(&theProtonMult, idxAlongStep, 1);
198 pManager->SetProcessOrdering(&theProtonMult, idxPostStep, 1);
199
200 // anti-Proton
201 pManager = G4AntiProton::AntiProton()->GetProcessManager();
202 // add process
203 pManager->AddDiscreteProcess(&theElasticProcess);
204
205 theLEAntiProtonModel = new G4LEAntiProtonInelastic();
206 theHEAntiProtonModel = new G4HEAntiProtonInelastic();
207 theAntiProtonInelastic.RegisterMe(theLEAntiProtonModel);
208 theAntiProtonInelastic.RegisterMe(theHEAntiProtonModel);
209 pManager->AddDiscreteProcess(&theAntiProtonInelastic);
210
211 pManager->AddProcess(&theAntiProtonIonisation, ordInActive,2, 2);
212
213 pManager->AddProcess(&theAntiProtonMult);
214 pManager->SetProcessOrdering(&theAntiProtonMult, idxAlongStep, 1);
215 pManager->SetProcessOrdering(&theAntiProtonMult, idxPostStep, 1);
216
217 pManager->AddRestProcess(&theAntiProtonAnnihilation);
218
219 // Neutron
220 pManager = G4Neutron::Neutron()->GetProcessManager();
221 // add process
222 pManager->AddDiscreteProcess(&theElasticProcess);
223
224 theLENeutronModel = new G4LENeutronInelastic();
225 theHENeutronModel = new G4HENeutronInelastic();
226 theNeutronInelastic.RegisterMe(theLENeutronModel);
227 theNeutronInelastic.RegisterMe(theModel);
228 pManager->AddDiscreteProcess(&theNeutronInelastic);
229
230 theNeutronFissionModel = new G4LFission();
231 theNeutronFission.RegisterMe(theNeutronFissionModel);
232 pManager->AddDiscreteProcess(&theNeutronFission);
233
234 theNeutronCaptureModel = new G4LCapture();
235 theNeutronCapture.RegisterMe(theNeutronCaptureModel);
236 pManager->AddDiscreteProcess(&theNeutronCapture);
237
238 // AntiNeutron
239 pManager = G4AntiNeutron::AntiNeutron()->GetProcessManager();
240 // add process
241 pManager->AddDiscreteProcess(&theElasticProcess);
242
243 theLEAntiNeutronModel = new G4LEAntiNeutronInelastic();
244 theHEAntiNeutronModel = new G4HEAntiNeutronInelastic();
245 theAntiNeutronInelastic.RegisterMe(theLEAntiNeutronModel);
246 theAntiNeutronInelastic.RegisterMe(theHEAntiNeutronModel);
247 pManager->AddDiscreteProcess(&theAntiNeutronInelastic);
248
249 pManager->AddRestProcess(&theAntiNeutronAnnihilation);
250
251 // Lambda
252 pManager = G4Lambda::Lambda()->GetProcessManager();
253 // add process
254 pManager->AddDiscreteProcess(&theElasticProcess);
255
256 theLELambdaModel = new G4LELambdaInelastic();
257 theHELambdaModel = new G4HELambdaInelastic();
258 theLambdaInelastic.RegisterMe(theLELambdaModel);
259 theLambdaInelastic.RegisterMe(theHELambdaModel);
260 pManager->AddDiscreteProcess(&theLambdaInelastic);
261
262 // AntiLambda
263 pManager = G4AntiLambda::AntiLambda()->GetProcessManager();
264 // add process
265 pManager->AddDiscreteProcess(&theElasticProcess);
266
267 theLEAntiLambdaModel = new G4LEAntiLambdaInelastic();
268 theHEAntiLambdaModel = new G4HEAntiLambdaInelastic();
269 theAntiLambdaInelastic.RegisterMe(theLEAntiLambdaModel);
270 theAntiLambdaInelastic.RegisterMe(theHEAntiLambdaModel);
271 pManager->AddDiscreteProcess(&theAntiLambdaInelastic);
272
273 // SigmaMinus
274 pManager = G4SigmaMinus::SigmaMinus()->GetProcessManager();
275 // add process
276 pManager->AddDiscreteProcess(&theElasticProcess);
277
278 theLESigmaMinusModel = new G4LESigmaMinusInelastic();
279 theHESigmaMinusModel = new G4HESigmaMinusInelastic();
280 theSigmaMinusInelastic.RegisterMe(theLESigmaMinusModel);
281 theSigmaMinusInelastic.RegisterMe(theHESigmaMinusModel);
282 pManager->AddDiscreteProcess(&theSigmaMinusInelastic);
283
284 pManager->AddProcess(&theSigmaMinusIonisation, ordInActive,2, 2);
285
286 pManager->AddProcess(&theSigmaMinusMult);
287 pManager->SetProcessOrdering(&theSigmaMinusMult, idxAlongStep, 1);
288 pManager->SetProcessOrdering(&theSigmaMinusMult, idxPostStep, 1);
289
290 // anti-SigmaMinus
291 pManager = G4AntiSigmaMinus::AntiSigmaMinus()->GetProcessManager();
292 // add process
293 pManager->AddDiscreteProcess(&theElasticProcess);
294
295 theLEAntiSigmaMinusModel = new G4LEAntiSigmaMinusInelastic();
296 theHEAntiSigmaMinusModel = new G4HEAntiSigmaMinusInelastic();
297 theAntiSigmaMinusInelastic.RegisterMe(theLEAntiSigmaMinusModel);
298 theAntiSigmaMinusInelastic.RegisterMe(theHEAntiSigmaMinusModel);
299 pManager->AddDiscreteProcess(&theAntiSigmaMinusInelastic);
300
301 pManager->AddProcess(&theAntiSigmaMinusIonisation, ordInActive,2, 2);
302
303 pManager->AddProcess(&theAntiSigmaMinusMult);
304 pManager->SetProcessOrdering(&theAntiSigmaMinusMult, idxAlongStep, 1);
305 pManager->SetProcessOrdering(&theAntiSigmaMinusMult, idxPostStep, 1);
306
307 // SigmaPlus
308 pManager = G4SigmaPlus::SigmaPlus()->GetProcessManager();
309 // add process
310 pManager->AddDiscreteProcess(&theElasticProcess);
311
312 theLESigmaPlusModel = new G4LESigmaPlusInelastic();
313 theHESigmaPlusModel = new G4HESigmaPlusInelastic();
314 theSigmaPlusInelastic.RegisterMe(theLESigmaPlusModel);
315 theSigmaPlusInelastic.RegisterMe(theHESigmaPlusModel);
316 pManager->AddDiscreteProcess(&theSigmaPlusInelastic);
317
318 pManager->AddProcess(&theSigmaPlusIonisation, ordInActive,2, 2);
319
320 pManager->AddProcess(&theSigmaPlusMult);
321 pManager->SetProcessOrdering(&theSigmaPlusMult, idxAlongStep, 1);
322 pManager->SetProcessOrdering(&theSigmaPlusMult, idxPostStep, 1);
323
324 // anti-SigmaPlus
325 pManager = G4AntiSigmaPlus::AntiSigmaPlus()->GetProcessManager();
326 // add process
327 pManager->AddDiscreteProcess(&theElasticProcess);
328
329 theLEAntiSigmaPlusModel = new G4LEAntiSigmaPlusInelastic();
330 theHEAntiSigmaPlusModel = new G4HEAntiSigmaPlusInelastic();
331 theAntiSigmaPlusInelastic.RegisterMe(theLEAntiSigmaPlusModel);
332 theAntiSigmaPlusInelastic.RegisterMe(theHEAntiSigmaPlusModel);
333 pManager->AddDiscreteProcess(&theAntiSigmaPlusInelastic);
334
335 pManager->AddProcess(&theAntiSigmaPlusIonisation, ordInActive,2, 2);
336
337 pManager->AddProcess(&theAntiSigmaPlusMult);
338 pManager->SetProcessOrdering(&theAntiSigmaPlusMult, idxAlongStep, 1);
339 pManager->SetProcessOrdering(&theAntiSigmaPlusMult, idxPostStep, 1);
340
341 // XiMinus
342 pManager = G4XiMinus::XiMinus()->GetProcessManager();
343 // add process
344 pManager->AddDiscreteProcess(&theElasticProcess);
345
346 theLEXiMinusModel = new G4LEXiMinusInelastic();
347 theHEXiMinusModel = new G4HEXiMinusInelastic();
348 theXiMinusInelastic.RegisterMe(theLEXiMinusModel);
349 theXiMinusInelastic.RegisterMe(theHEXiMinusModel);
350 pManager->AddDiscreteProcess(&theXiMinusInelastic);
351
352 pManager->AddProcess(&theXiMinusIonisation, ordInActive,2, 2);
353
354 pManager->AddProcess(&theXiMinusMult);
355 pManager->SetProcessOrdering(&theXiMinusMult, idxAlongStep, 1);
356 pManager->SetProcessOrdering(&theXiMinusMult, idxPostStep, 1);
357
358 // anti-XiMinus
359 pManager = G4AntiXiMinus::AntiXiMinus()->GetProcessManager();
360 // add process
361 pManager->AddDiscreteProcess(&theElasticProcess);
362
363 theLEAntiXiMinusModel = new G4LEAntiXiMinusInelastic();
364 theHEAntiXiMinusModel = new G4HEAntiXiMinusInelastic();
365 theAntiXiMinusInelastic.RegisterMe(theLEAntiXiMinusModel);
366 theAntiXiMinusInelastic.RegisterMe(theHEAntiXiMinusModel);
367 pManager->AddDiscreteProcess(&theAntiXiMinusInelastic);
368
369 pManager->AddProcess(&theAntiXiMinusIonisation, ordInActive,2, 2);
370
371 pManager->AddProcess(&theAntiXiMinusMult);
372 pManager->SetProcessOrdering(&theAntiXiMinusMult, idxAlongStep, 1);
373 pManager->SetProcessOrdering(&theAntiXiMinusMult, idxPostStep, 1);
374
375 // XiZero
376 pManager = G4XiZero::XiZero()->GetProcessManager();
377 // add process
378 pManager->AddDiscreteProcess(&theElasticProcess);
379
380 theLEXiZeroModel = new G4LEXiZeroInelastic();
381 theHEXiZeroModel = new G4HEXiZeroInelastic();
382 theXiZeroInelastic.RegisterMe(theLEXiZeroModel);
383 theXiZeroInelastic.RegisterMe(theHEXiZeroModel);
384 pManager->AddDiscreteProcess(&theXiZeroInelastic);
385
386 // anti-XiZero
387 pManager = G4AntiXiZero::AntiXiZero()->GetProcessManager();
388 // add process
389 pManager->AddDiscreteProcess(&theElasticProcess);
390
391 theLEAntiXiZeroModel = new G4LEAntiXiZeroInelastic();
392 theHEAntiXiZeroModel = new G4HEAntiXiZeroInelastic();
393 theAntiXiZeroInelastic.RegisterMe(theLEAntiXiZeroModel);
394 theAntiXiZeroInelastic.RegisterMe(theHEAntiXiZeroModel);
395 pManager->AddDiscreteProcess(&theAntiXiZeroInelastic);
396
397 // OmegaMinus
398 pManager = G4OmegaMinus::OmegaMinus()->GetProcessManager();
399 // add process
400 pManager->AddDiscreteProcess(&theElasticProcess);
401
402 theLEOmegaMinusModel = new G4LEOmegaMinusInelastic();
403 theHEOmegaMinusModel = new G4HEOmegaMinusInelastic();
404 theOmegaMinusInelastic.RegisterMe(theLEOmegaMinusModel);
405 theOmegaMinusInelastic.RegisterMe(theHEOmegaMinusModel);
406 pManager->AddDiscreteProcess(&theOmegaMinusInelastic);
407
408 pManager->AddProcess(&theOmegaMinusIonisation, ordInActive,2, 2);
409
410 pManager->AddProcess(&theOmegaMinusMult);
411 pManager->SetProcessOrdering(&theOmegaMinusMult, idxAlongStep, 1);
412 pManager->SetProcessOrdering(&theOmegaMinusMult, idxPostStep, 1);
413
414 // anti-OmegaMinus
415 pManager = G4AntiOmegaMinus::AntiOmegaMinus()->GetProcessManager();
416 // add process
417 pManager->AddDiscreteProcess(&theElasticProcess);
418
419 theLEAntiOmegaMinusModel = new G4LEAntiOmegaMinusInelastic();
420 theHEAntiOmegaMinusModel = new G4HEAntiOmegaMinusInelastic();
421 theAntiOmegaMinusInelastic.RegisterMe(theLEAntiOmegaMinusModel);
422 theAntiOmegaMinusInelastic.RegisterMe(theHEAntiOmegaMinusModel);
423 pManager->AddDiscreteProcess(&theAntiOmegaMinusInelastic);
424
425 pManager->AddProcess(&theAntiOmegaMinusIonisation, ordInActive,2, 2);
426
427 pManager->AddProcess(&theAntiOmegaMinusMult);
428 pManager->SetProcessOrdering(&theAntiOmegaMinusMult, idxAlongStep, 1);
429 pManager->SetProcessOrdering(&theAntiOmegaMinusMult, idxPostStep, 1);
430
431}
Note: See TracBrowser for help on using the repository browser.