ECCE @ EIC Software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
GammaRayTelHadronPhysics.cc
Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file GammaRayTelHadronPhysics.cc
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 //
28 
29 #include <iomanip>
30 
31 #include "GammaRayTelHadronPhysics.hh"
32 #include "globals.hh"
33 #include "G4ios.hh"
34 #include "G4SystemOfUnits.hh"
35 #include "G4ShortLivedConstructor.hh"
36 #include "G4HadronicParameters.hh"
37 
38 
39 GammaRayTelHadronPhysics::GammaRayTelHadronPhysics(const G4String& name)
40  : G4VPhysicsConstructor(name)
41 {;}
42 
43 GammaRayTelHadronPhysics::~GammaRayTelHadronPhysics()
44 {
45  delete theStringDecay;
46 }
47 
48 
49 #include "G4ProcessManager.hh"
50 
51 
52 void GammaRayTelHadronPhysics::ConstructProcess()
53 {
54 
55  G4ProcessManager * pManager = 0;
56  /*
57  G4cout << "" << G4endl;
58  G4cout << "You are using the GammaRayTelHadronPhysics" << G4endl;
59  G4cout << " - Note that this hadronic physics list is not optimized for any particular usage" << G4endl;
60  G4cout << " - If you wish to have a starting point tailored for a particular area of work," << G4endl;
61  G4cout << " please use one of the available physics lists by use-case." << G4endl;
62  G4cout << "" << G4endl;
63  */
64 
65  // Elastic Process
66  theElasticModel = new G4HadronElastic();
67  theElasticProcess.RegisterMe(theElasticModel);
68 
69  const G4double theBERTMin = 0.0*GeV;
70  const G4double theBERTMax = 5.0*GeV;
71  const G4double theFTFMin = 4.0*GeV;
72  const G4double theFTFMax = G4HadronicParameters::Instance()->GetMaxEnergy();
73 
74  theStringModel = new G4FTFModel;
75  theStringDecay = new G4ExcitedStringDecay( new G4LundStringFragmentation );
76  theStringModel->SetFragmentationModel( theStringDecay );
77  thePreEquilib = new G4PreCompoundModel( new G4ExcitationHandler );
78  theCascade = new G4GeneratorPrecompoundInterface( thePreEquilib );
79 
80  theModel = new G4TheoFSGenerator( "FTFP" );
81  theModel->SetHighEnergyGenerator( theStringModel );
82  theModel->SetTransport( theCascade );
83  theModel->SetMinEnergy( theFTFMin );
84  theModel->SetMaxEnergy( theFTFMax );
85 
86  G4TheoFSGenerator* theModelDownToZero = new G4TheoFSGenerator( "FTFP" );
87  theModelDownToZero->SetHighEnergyGenerator( theStringModel );
88  theModelDownToZero->SetTransport( theCascade );
89  theModelDownToZero->SetMinEnergy(0*eV);
90  theModelDownToZero->SetMaxEnergy(theFTFMax );
91 
92  G4CascadeInterface * theBERTModel = new G4CascadeInterface;
93  theBERTModel->SetMinEnergy( theBERTMin );
94  theBERTModel->SetMaxEnergy( theBERTMax );
95 
96  // pi+ and pi-
97 
98  G4VCrossSectionDataSet * thePiData = new G4CrossSectionPairGG( new G4PiNuclearCrossSection, 91*GeV );
99  G4VCrossSectionDataSet * theAntiNucleonData = new G4CrossSectionInelastic( new G4ComponentAntiNuclNuclearXS );
100 
101 
102  // PionPlus
103  G4ParticleDefinition* pion = G4PionPlus::PionPlusDefinition();
104  pManager = pion ->GetProcessManager();
105  // add process
106  pManager->AddDiscreteProcess(&theElasticProcess);
107  thePionPlusInelastic.AddDataSet(thePiData);
108  thePionPlusInelastic.RegisterMe(theBERTModel);
109  thePionPlusInelastic.RegisterMe(theModel);
110  pManager->AddDiscreteProcess(&thePionPlusInelastic);
111 
112  pManager->AddProcess(&thePionPlusIonisation, ordInActive,2, 2);
113 
114  pManager->AddProcess(&thePionPlusMult);
115  pManager->SetProcessOrdering(&thePionPlusMult, idxAlongStep, 1);
116  pManager->SetProcessOrdering(&thePionPlusMult, idxPostStep, 1);
117 
118  // PionMinus
119  G4ParticleDefinition* pionMinus = G4PionMinus::PionMinusDefinition();
120  pManager = pionMinus -> GetProcessManager();
121  // add process
122  pManager->AddDiscreteProcess(&theElasticProcess);
123  thePionMinusInelastic.AddDataSet(thePiData);
124  thePionMinusInelastic.RegisterMe(theBERTModel);
125  thePionMinusInelastic.RegisterMe(theModel);
126  pManager->AddDiscreteProcess(&thePionMinusInelastic);
127 
128  pManager->AddProcess(&thePionMinusIonisation, ordInActive,2, 2);
129 
130  pManager->AddProcess(&thePionMinusMult);
131  pManager->SetProcessOrdering(&thePionMinusMult, idxAlongStep, 1);
132  pManager->SetProcessOrdering(&thePionMinusMult, idxPostStep, 1);
133 
134  pManager->AddRestProcess(&thePionMinusAbsorption, ordDefault);
135 
136  // KaonPlus
137  G4ParticleDefinition* kaonPlus = G4KaonPlus::KaonPlusDefinition();
138  pManager = kaonPlus->GetProcessManager();
139  // add process
140  pManager->AddDiscreteProcess(&theElasticProcess);
141  theKaonPlusInelastic.AddDataSet( G4CrossSectionDataSetRegistry::Instance()->
142  GetCrossSectionDataSet(G4ChipsKaonPlusInelasticXS::Default_Name()));
143  theKaonPlusInelastic.RegisterMe(theBERTModel);
144  theKaonPlusInelastic.RegisterMe(theModel);
145  pManager->AddDiscreteProcess(&theKaonPlusInelastic);
146 
147  pManager->AddProcess(&theKaonPlusIonisation, ordInActive,2, 2);
148 
149  pManager->AddProcess(&theKaonPlusMult);
150  pManager->SetProcessOrdering(&theKaonPlusMult, idxAlongStep, 1);
151  pManager->SetProcessOrdering(&theKaonPlusMult, idxPostStep, 1);
152 
153  // KaonMinus
154  G4ParticleDefinition* kaonMinus = G4KaonMinus::KaonMinusDefinition();
155  pManager = kaonMinus->GetProcessManager();
156  // add process
157  pManager->AddDiscreteProcess(&theElasticProcess);
158  theKaonMinusInelastic.AddDataSet( G4CrossSectionDataSetRegistry::Instance()->
159  GetCrossSectionDataSet(G4ChipsKaonMinusInelasticXS::Default_Name()));
160  theKaonMinusInelastic.RegisterMe(theBERTModel);
161  theKaonMinusInelastic.RegisterMe(theModel);
162  pManager->AddDiscreteProcess(&theKaonMinusInelastic);
163 
164  pManager->AddProcess(&theKaonMinusIonisation, ordInActive,2, 2);
165 
166  pManager->AddProcess(&theKaonMinusMult);
167  pManager->SetProcessOrdering(&theKaonMinusMult, idxAlongStep, 1);
168  pManager->SetProcessOrdering(&theKaonMinusMult, idxPostStep, 1);
169 
170  pManager->AddRestProcess(&theKaonMinusAbsorption, ordDefault);
171 
172  // KaonZeroL
173  pManager = G4KaonZeroLong::KaonZeroLong()->GetProcessManager();
174  // add process
175  pManager->AddDiscreteProcess(&theElasticProcess);
176  theKaonZeroLInelastic.AddDataSet( G4CrossSectionDataSetRegistry::Instance()
177  ->GetCrossSectionDataSet(G4ChipsKaonZeroInelasticXS::Default_Name()));
178  theKaonZeroLInelastic.RegisterMe(theBERTModel);
179  theKaonZeroLInelastic.RegisterMe(theModel);
180  pManager->AddDiscreteProcess(&theKaonZeroLInelastic);
181 
182  // KaonZeroS
183  pManager = G4KaonZeroShort::KaonZeroShort()->GetProcessManager();
184  // add process
185  pManager->AddDiscreteProcess(&theElasticProcess);
186  theKaonZeroSInelastic.AddDataSet( G4CrossSectionDataSetRegistry::Instance()
187  ->GetCrossSectionDataSet(G4ChipsKaonZeroInelasticXS::Default_Name()));
188  theKaonZeroSInelastic.RegisterMe(theBERTModel);
189  theKaonZeroSInelastic.RegisterMe(theModel);
190  pManager->AddDiscreteProcess(&theKaonZeroSInelastic);
191 
192  // Proton
193  pManager = G4Proton::Proton()->GetProcessManager();
194  // add process
195  pManager->AddDiscreteProcess(&theElasticProcess);
196  theProtonInelastic.AddDataSet(new G4BGGNucleonInelasticXS( G4Proton::Proton() ) );
197  theProtonInelastic.RegisterMe(theBERTModel);
198  theProtonInelastic.RegisterMe(theModel);
199  pManager->AddDiscreteProcess(&theProtonInelastic);
200 
201  pManager->AddProcess(&theProtonIonisation, ordInActive,2, 2);
202 
203  pManager->AddProcess(&theProtonMult);
204  pManager->SetProcessOrdering(&theProtonMult, idxAlongStep, 1);
205  pManager->SetProcessOrdering(&theProtonMult, idxPostStep, 1);
206 
207  // anti-Proton
208  pManager = G4AntiProton::AntiProton()->GetProcessManager();
209  // add process
210  pManager->AddDiscreteProcess(&theElasticProcess);
211  theAntiProtonInelastic.AddDataSet( theAntiNucleonData );
212  theAntiProtonInelastic.RegisterMe(theModelDownToZero);
213  pManager->AddDiscreteProcess(&theAntiProtonInelastic);
214 
215  pManager->AddProcess(&theAntiProtonIonisation, ordInActive,2, 2);
216 
217  pManager->AddProcess(&theAntiProtonMult);
218  pManager->SetProcessOrdering(&theAntiProtonMult, idxAlongStep, 1);
219  pManager->SetProcessOrdering(&theAntiProtonMult, idxPostStep, 1);
220 
221  pManager->AddRestProcess(&theAntiProtonAnnihilation);
222 
223  // Neutron
224  pManager = G4Neutron::Neutron()->GetProcessManager();
225  // add process
226  pManager->AddDiscreteProcess(&theElasticProcess);
227  theNeutronInelastic.AddDataSet( new G4BGGNucleonInelasticXS( G4Neutron::Neutron() ));
228  theNeutronInelastic.RegisterMe(theBERTModel);
229  theNeutronInelastic.RegisterMe(theModel);
230  pManager->AddDiscreteProcess(&theNeutronInelastic);
231 
232  theNeutronFissionModel = new G4LFission();
233  theNeutronFission.RegisterMe(theNeutronFissionModel);
234  pManager->AddDiscreteProcess(&theNeutronFission);
235 
236  theNeutronCapture = new G4HadronCaptureProcess();
237  theNeutronCapture->AddDataSet(new G4NeutronCaptureXS());
238  pManager->AddDiscreteProcess(theNeutronCapture);
239 
240  // AntiNeutron
241  pManager = G4AntiNeutron::AntiNeutron()->GetProcessManager();
242  // add process
243  pManager->AddDiscreteProcess(&theElasticProcess);
244  theAntiNeutronInelastic.AddDataSet( theAntiNucleonData );
245  theAntiNeutronInelastic.RegisterMe(theModelDownToZero);
246  pManager->AddDiscreteProcess(&theAntiNeutronInelastic);
247 
248 }