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

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

update
File size: 16.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//
27// $Id: GammaRayTelHadronPhysics.cc,v 1.4 2006/06/29 15:56:45 gunter Exp $
28// GEANT4 tag $Name:  $
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.