ECCE @ EIC Software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
G4HadronPhysicsINCLXX.cc
Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file G4HadronPhysicsINCLXX.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 // ClassName: G4HadronPhysicsINCLXX
30 //
31 // Author: 2011 P. Kaitaniemi
32 //
33 // Modified:
34 // 22.05.2014 D. Mancusi: Extend INCL++ to 20 GeV
35 // 19.03.2013 A.Ribon: Replace LEP with FTFP and BERT
36 // 08.03.2013 D. Mancusi: Fix a problem with overlapping model ranges
37 // 01.03.2013 D. Mancusi: Rename to G4HadronPhysicsINCLXX and introduce
38 // parameters for FTFP and NeutronHP
39 // 31.10.2012 A.Ribon: Use G4MiscBuilder
40 // 23.03.2012 D. Mancusi: Extended INCL++ to incident heavy ions up to 16O
41 // 27.11.2011 P.Kaitaniemi: Created physics list for INCL++ using QGSP_INCL_ABLA as a template
42 //
43 //----------------------------------------------------------------------------
44 //
45 #include <iomanip>
46 
47 #include "G4HadronPhysicsINCLXX.hh"
48 
49 #include "globals.hh"
50 #include "G4ios.hh"
51 #include "G4SystemOfUnits.hh"
52 #include "G4ParticleDefinition.hh"
53 #include "G4ParticleTable.hh"
54 
55 #include "G4MesonConstructor.hh"
56 #include "G4BaryonConstructor.hh"
58 #include "G4IonConstructor.hh"
59 
60 #include "G4PionBuilder.hh"
61 #include "G4KaonBuilder.hh"
62 #include "G4QGSPPionBuilder.hh"
63 #include "G4FTFPPionBuilder.hh"
64 #include "G4QGSPKaonBuilder.hh"
65 #include "G4FTFPKaonBuilder.hh"
66 #include "G4INCLXXPionBuilder.hh"
67 #include "G4BertiniKaonBuilder.hh"
68 
69 #include "G4ProtonBuilder.hh"
70 #include "G4QGSPProtonBuilder.hh"
71 #include "G4FTFPProtonBuilder.hh"
72 #include "G4INCLXXProtonBuilder.hh"
73 
74 #include "G4NeutronBuilder.hh"
75 #include "G4QGSPNeutronBuilder.hh"
76 #include "G4FTFPNeutronBuilder.hh"
78 #include "G4NeutronPHPBuilder.hh"
79 
80 #include "G4HyperonFTFPBuilder.hh"
81 #include "G4AntiBarionBuilder.hh"
83 
85 #include "G4NeutronRadCapture.hh"
86 #include "G4NeutronCaptureXS.hh"
87 #include "G4NeutronInelasticXS.hh"
89 #include "G4LFission.hh"
90 
92 
93 #include "G4PhysListUtil.hh"
94 #include "G4ProcessManager.hh"
95 
96 #include "G4HadronicParameters.hh"
97 
98 // factory
100 //
102 
103 //Constant for configuration
104 namespace {
105  const G4bool quasiElasticFTF= false; // Use built-in quasi-elastic (not add-on)
106  const G4bool quasiElasticQGS= true; // For QGS, it must use it.
107 }
108 
110  : G4HadronPhysicsINCLXX("hInelastic INCLXX")
111 {
112 }
113 
114 G4HadronPhysicsINCLXX::G4HadronPhysicsINCLXX(const G4String& name, const G4bool quasiElastic, const G4bool neutronHP, const G4bool ftfp)
115  : G4VPhysicsConstructor(name)
116  , QuasiElastic(quasiElastic)
117  , withNeutronHP(neutronHP)
118  , withFTFP(ftfp)
119 {
120 }
121 
123 {
124  Neutron();
125  Proton();
126  Pion();
127  Kaon();
128  Others();
129 }
130 
131 
133 {
134  //General schema:
135  // 1) Create a builder
136  // 2) Call AddBuilder
137  // 3) Configure the builder, possibly with sub-builders
138  // 4) Call builder->Build()
139  auto neu = new G4NeutronBuilder( withNeutronHP );
140  AddBuilder(neu);
141  G4PhysicsBuilderInterface* string = nullptr;
142  if(withFTFP) {
143  string = new G4FTFPNeutronBuilder(quasiElasticFTF);
144  } else {
145  string = new G4QGSPNeutronBuilder(quasiElasticQGS);
146  }
147  string->SetMinEnergy(15.*GeV);
148  AddBuilder(string);
149  neu->RegisterMe(string);
150 
151  auto inclxxn = new G4INCLXXNeutronBuilder;
152  inclxxn->SetMaxEnergy(20.*GeV);
153  AddBuilder(inclxxn);
154  neu->RegisterMe(inclxxn);
155 
156  if(withNeutronHP) {
157  inclxxn->UsePreCompound(false);
158  inclxxn->SetMinEnergy(19.9*MeV);
159  auto hpn = new G4NeutronPHPBuilder;
160  AddBuilder(hpn);
161  neu->RegisterMe(hpn);
162  } else {
163  inclxxn->UsePreCompound(true);
164  inclxxn->SetMinPreCompoundEnergy(0.0*MeV);
165  inclxxn->SetMaxPreCompoundEnergy(2.0*MeV);
166  inclxxn->SetMinEnergy(1.0*MeV);
167  }
168 
169  neu->Build();
170 }
171 
173 {
174  auto pro =new G4ProtonBuilder;
175  AddBuilder(pro);
176  G4PhysicsBuilderInterface* string = nullptr;
177  if(withFTFP) {
178  string = new G4FTFPProtonBuilder(quasiElasticFTF);
179  } else {
180  string = new G4QGSPProtonBuilder(quasiElasticQGS);
181  }
182  string->SetMinEnergy(15.*GeV);
183  AddBuilder(string);
184  pro->RegisterMe(string);
185 
186  auto inclxxp = new G4INCLXXProtonBuilder;
187  AddBuilder(inclxxp);
188  inclxxp->SetMinEnergy(1.0*MeV);
189  inclxxp->SetMaxEnergy(20.0*GeV);
190  pro->RegisterMe(inclxxp);
191  pro->Build();
192 }
193 
195 {
196  auto pi = new G4PionBuilder;
197  AddBuilder(pi);
198  G4PhysicsBuilderInterface* string = nullptr;
199  if(withFTFP) {
200  string = new G4FTFPPionBuilder(quasiElasticFTF);
201  } else {
202  string = new G4QGSPPionBuilder(quasiElasticQGS);
203  }
204  string->SetMinEnergy(15.*GeV);
205  AddBuilder(string);
206  pi->RegisterMe(string);
207 
208  auto inclxx = new G4INCLXXPionBuilder;
209  inclxx->SetMinEnergy(0.0*GeV);
210  inclxx->SetMaxEnergy(20.*GeV);
211  AddBuilder(inclxx);
212  pi->RegisterMe(inclxx);
213 
214  pi->Build();
215 }
216 
218 {
219  auto k = new G4KaonBuilder;
220  AddBuilder(k);
221  G4PhysicsBuilderInterface* string = nullptr;
222  if(withFTFP) {
223  string = new G4FTFPKaonBuilder(quasiElasticFTF);
224  } else {
225  string = new G4QGSPKaonBuilder(quasiElasticQGS);
226  }
227  string->SetMinEnergy(14.*GeV);
228  AddBuilder(string);
229  k->RegisterMe(string);
230 
231  auto bert = new G4BertiniKaonBuilder;
232  bert->SetMinEnergy(0.0*GeV);
233  bert->SetMaxEnergy(15.0*GeV);
234  AddBuilder(bert);
235  k->RegisterMe(bert);
236 
237  k->Build();
238 }
239 
241 {
242  auto hyp = new G4HyperonFTFPBuilder;
243  AddBuilder(hyp);
244  hyp->Build();
245 
246  auto abar = new G4AntiBarionBuilder;
247  AddBuilder(abar);
248  auto ftfpabar = new G4FTFPAntiBarionBuilder(quasiElasticFTF);
249  AddBuilder(ftfpabar);
250  abar->RegisterMe(ftfpabar);
251  abar->Build();
252 }
253 
255 {}
256 
258 {
259  G4MesonConstructor pMesonConstructor;
260  pMesonConstructor.ConstructParticle();
261 
262  G4BaryonConstructor pBaryonConstructor;
263  pBaryonConstructor.ConstructParticle();
264 
265  G4ShortLivedConstructor pShortLivedConstructor;
266  pShortLivedConstructor.ConstructParticle();
267 
268  G4IonConstructor pIonConstructor;
269  pIonConstructor.ConstructParticle();
270 }
271 
273 {
274  CreateModels();
276 }
277 
279 {
280  // --- Neutrons ---
283  if (capture) {
284  G4NeutronRadCapture* theNeutronRadCapture = new G4NeutronRadCapture();
285  capture->RegisterMe(theNeutronRadCapture);
286  if ( withNeutronHP ) {
287  capture->AddDataSet( new G4ParticleHPCaptureData );
288  theNeutronRadCapture->SetMinEnergy( 19.9*MeV );
289  }
290  }
292  if (fission && withNeutronHP) {
293  G4LFission* theNeutronLEPFission = new G4LFission();
294  theNeutronLEPFission->SetMinEnergy( 19.9*MeV );
295  theNeutronLEPFission->SetMaxEnergy( G4HadronicParameters::Instance()->GetMaxEnergy() );
296  fission->RegisterMe( theNeutronLEPFission );
297  }
298 }