| Geant4 Cross Reference |
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 // 11.11.2022 A.Ribon: Extended to light hypernuclei and anti-hypernuclei projectiles
35 // 07.05.2020 A.Ribon: Use eventually QGSP for hyperons (and anti-hyperons)
36 // at high energies
37 // 05.05.2020 A.Ribon: Use eventually QGSP for antibaryons at high energies
38 // 22.05.2014 D. Mancusi: Extend INCL++ to 20 GeV
39 // 19.03.2013 A.Ribon: Replace LEP with FTFP and BERT
40 // 08.03.2013 D. Mancusi: Fix a problem with overlapping model ranges
41 // 01.03.2013 D. Mancusi: Rename to G4HadronPhysicsINCLXX and introduce
42 // parameters for FTFP and NeutronHP
43 // 31.10.2012 A.Ribon: Use G4MiscBuilder
44 // 23.03.2012 D. Mancusi: Extended INCL++ to incident heavy ions up to 16O
45 // 27.11.2011 P.Kaitaniemi: Created physics list for INCL++ using QGSP_INCL_ABLA as a template
46 //
47 //----------------------------------------------------------------------------
48 //
49 #include <iomanip>
50
51 #include "G4HadronPhysicsINCLXX.hh"
52
53 #include "globals.hh"
54 #include "G4ios.hh"
55 #include "G4SystemOfUnits.hh"
56 #include "G4ParticleDefinition.hh"
57 #include "G4ParticleTable.hh"
58
59 #include "G4PionBuilder.hh"
60 #include "G4KaonBuilder.hh"
61 #include "G4QGSPPionBuilder.hh"
62 #include "G4FTFPPionBuilder.hh"
63 #include "G4QGSPKaonBuilder.hh"
64 #include "G4FTFPKaonBuilder.hh"
65 #include "G4INCLXXPionBuilder.hh"
66 #include "G4BertiniKaonBuilder.hh"
67
68 #include "G4ProtonBuilder.hh"
69 #include "G4QGSPProtonBuilder.hh"
70 #include "G4FTFPProtonBuilder.hh"
71 #include "G4INCLXXProtonBuilder.hh"
72
73 #include "G4NeutronBuilder.hh"
74 #include "G4QGSPNeutronBuilder.hh"
75 #include "G4FTFPNeutronBuilder.hh"
76 #include "G4INCLXXNeutronBuilder.hh"
77 #include "G4NeutronPHPBuilder.hh"
78
79 #include "G4NeutronRadCapture.hh"
80 #include "G4NeutronCaptureXS.hh"
81 #include "G4NeutronInelasticXS.hh"
82 #include "G4ParticleHPCaptureData.hh"
83 #include "G4LFission.hh"
84
85 #include "G4PhysListUtil.hh"
86 #include "G4HadParticles.hh"
87 #include "G4HadronicParameters.hh"
88 #include "G4HadronicBuilder.hh"
89
90 // factory
91 #include "G4PhysicsConstructorFactory.hh"
92 //
93 G4_DECLARE_PHYSCONSTR_FACTORY(G4HadronPhysicsINCLXX);
94
95 G4HadronPhysicsINCLXX::G4HadronPhysicsINCLXX(G4int verb)
96 : G4HadronPhysicsINCLXX("hInelastic INCLXX")
97 {
98 G4HadronicParameters::Instance()->SetVerboseLevel(verb);
99 }
100
101 G4HadronPhysicsINCLXX::G4HadronPhysicsINCLXX(const G4String& name, const G4bool quasiElastic, const G4bool neutronHP, const G4bool ftfp)
102 : G4HadronPhysicsFTFP_BERT(name, quasiElastic),
103 withNeutronHP(neutronHP),
104 withFTFP(ftfp)
105 {
106 QuasiElastic = withFTFP ? false : true;
107 minBERT_neutron = withNeutronHP ? 19.9*MeV : 0.0;
108 }
109
110 void G4HadronPhysicsINCLXX::Neutron()
111 {
112 G4HadronicParameters* param = G4HadronicParameters::Instance();
113 G4bool useFactorXS = param->ApplyFactorXS();
114 //General schema:
115 // 1) Create a builder
116 // 2) Call AddBuilder
117 // 3) Configure the builder, possibly with sub-builders
118 // 4) Call builder->Build()
119 auto neu = new G4NeutronBuilder( withNeutronHP );
120 AddBuilder(neu);
121 G4PhysicsBuilderInterface* string = nullptr;
122 if(withFTFP) {
123 string = new G4FTFPNeutronBuilder(QuasiElastic);
124 } else {
125 string = new G4QGSPNeutronBuilder(QuasiElastic);
126 }
127 string->SetMinEnergy(15.*GeV);
128 AddBuilder(string);
129 neu->RegisterMe(string);
130
131 auto inclxxn = new G4INCLXXNeutronBuilder;
132 inclxxn->SetMaxEnergy(20.*GeV);
133 AddBuilder(inclxxn);
134 neu->RegisterMe(inclxxn);
135
136 if(withNeutronHP) {
137 inclxxn->UsePreCompound(false);
138 inclxxn->SetMinEnergy(minBERT_neutron);
139 auto hpn = new G4NeutronPHPBuilder;
140 AddBuilder(hpn);
141 neu->RegisterMe(hpn);
142 } else {
143 inclxxn->UsePreCompound(true);
144 inclxxn->SetMinPreCompoundEnergy(0.0*MeV);
145 inclxxn->SetMaxPreCompoundEnergy(2.0*MeV);
146 inclxxn->SetMinEnergy(1.0*MeV);
147 }
148
149 neu->Build();
150
151 const G4ParticleDefinition* neutron = G4Neutron::Neutron();
152 G4HadronicProcess* inel = G4PhysListUtil::FindInelasticProcess(neutron);
153 if(nullptr != inel) {
154 if( useFactorXS ) inel->MultiplyCrossSectionBy( param->XSFactorNucleonInelastic() );
155 }
156 G4HadronicProcess* capture = G4PhysListUtil::FindCaptureProcess(neutron);
157 if (nullptr != capture) {
158 G4NeutronRadCapture* theNeutronRadCapture = new G4NeutronRadCapture();
159 theNeutronRadCapture->SetMinEnergy( minBERT_neutron );
160 capture->RegisterMe( theNeutronRadCapture );
161 }
162 G4HadronicProcess* fission = G4PhysListUtil::FindFissionProcess(neutron);
163 if (nullptr != fission) {
164 G4LFission* theNeutronLEPFission = new G4LFission();
165 theNeutronLEPFission->SetMinEnergy( minBERT_neutron );
166 theNeutronLEPFission->SetMaxEnergy( G4HadronicParameters::Instance()->GetMaxEnergy() );
167 fission->RegisterMe( theNeutronLEPFission );
168 }
169 }
170
171 void G4HadronPhysicsINCLXX::Proton()
172 {
173 G4HadronicParameters* param = G4HadronicParameters::Instance();
174 G4bool useFactorXS = param->ApplyFactorXS();
175
176 auto pro =new G4ProtonBuilder;
177 AddBuilder(pro);
178 G4PhysicsBuilderInterface* string = nullptr;
179 if(withFTFP) {
180 string = new G4FTFPProtonBuilder(QuasiElastic);
181 } else {
182 string = new G4QGSPProtonBuilder(QuasiElastic);
183 }
184 string->SetMinEnergy(15.*GeV);
185 AddBuilder(string);
186 pro->RegisterMe(string);
187
188 auto inclxxp = new G4INCLXXProtonBuilder;
189 AddBuilder(inclxxp);
190 inclxxp->SetMinEnergy(1.0*MeV);
191 inclxxp->SetMaxEnergy(20.0*GeV);
192 pro->RegisterMe(inclxxp);
193 pro->Build();
194
195 const G4ParticleDefinition* proton = G4Proton::Proton();
196 G4HadronicProcess* inel = G4PhysListUtil::FindInelasticProcess(proton);
197 if(nullptr != inel) {
198 if( useFactorXS ) inel->MultiplyCrossSectionBy( param->XSFactorNucleonInelastic() );
199 }
200 }
201
202 void G4HadronPhysicsINCLXX::Pion()
203 {
204 G4HadronicParameters* param = G4HadronicParameters::Instance();
205 G4bool useFactorXS = param->ApplyFactorXS();
206
207 auto pi = new G4PionBuilder;
208 AddBuilder(pi);
209 G4PhysicsBuilderInterface* string = nullptr;
210 if(withFTFP) {
211 string = new G4FTFPPionBuilder(QuasiElastic);
212 } else {
213 string = new G4QGSPPionBuilder(QuasiElastic);
214 }
215 string->SetMinEnergy(15.*GeV);
216 AddBuilder(string);
217 pi->RegisterMe(string);
218
219 auto inclxx = new G4INCLXXPionBuilder;
220 inclxx->SetMinEnergy(0.0*GeV);
221 inclxx->SetMaxEnergy(20.*GeV);
222 AddBuilder(inclxx);
223 pi->RegisterMe(inclxx);
224
225 pi->Build();
226
227 if( useFactorXS ) {
228 const G4ParticleDefinition* pion = G4PionPlus::PionPlus();
229 G4HadronicProcess* inel = G4PhysListUtil::FindInelasticProcess(pion);
230 if(nullptr != inel) {
231 inel->MultiplyCrossSectionBy( param->XSFactorPionInelastic() );
232 }
233 pion = G4PionMinus::PionMinus();
234 inel = G4PhysListUtil::FindInelasticProcess(pion);
235 if(nullptr != inel) {
236 inel->MultiplyCrossSectionBy( param->XSFactorPionInelastic() );
237 }
238 }
239 }
240
241 void G4HadronPhysicsINCLXX::Kaon()
242 {
243 G4HadronicParameters* param = G4HadronicParameters::Instance();
244 G4bool useFactorXS = param->ApplyFactorXS();
245
246 auto k = new G4KaonBuilder;
247 AddBuilder(k);
248 G4PhysicsBuilderInterface* string = nullptr;
249 if(withFTFP) {
250 string = new G4FTFPKaonBuilder(QuasiElastic);
251 } else {
252 string = new G4QGSPKaonBuilder(QuasiElastic);
253 }
254 string->SetMinEnergy(14.*GeV);
255 AddBuilder(string);
256 k->RegisterMe(string);
257
258 auto bert = new G4BertiniKaonBuilder;
259 bert->SetMinEnergy(0.0*GeV);
260 bert->SetMaxEnergy(15.0*GeV);
261 AddBuilder(bert);
262 k->RegisterMe(bert);
263
264 k->Build();
265
266 if( useFactorXS ) {
267 G4ParticleTable* table = G4ParticleTable::GetParticleTable();
268 for( auto & pdg : G4HadParticles::GetKaons() ) {
269 auto part = table->FindParticle( pdg );
270 if ( part == nullptr ) { continue; }
271 G4HadronicProcess* inel = G4PhysListUtil::FindInelasticProcess(part);
272 if(nullptr != inel) {
273 inel->MultiplyCrossSectionBy( param->XSFactorHadronInelastic() );
274 }
275 }
276 }
277 }
278
279 void G4HadronPhysicsINCLXX::Others()
280 {
281 G4HadronicParameters* param = G4HadronicParameters::Instance();
282
283 // high energy particles
284 if( param->GetMaxEnergy() > param->EnergyThresholdForHeavyHadrons() ) {
285
286 // anti light ions
287 G4HadronicBuilder::BuildAntiLightIonsINCLXX();
288
289 if ( param->EnableHyperNuclei() ) {
290 // INCLXX is currently capable of handling light hypernuclei projectiles,
291 // but not light anti-hypernuclei projectiles, therefore FTFP must be used
292 // for the latter.
293 // Note that the QGSP string model cannot currently handle nuclear projectiles
294 // of any kind, so only the FTFP string model can be used together with INCLXX
295 // for the simulation of nuclear interactions light hypernuclei.
296 G4HadronicBuilder::BuildHyperAntiNucleiFTFP_BERT();
297 G4HadronicBuilder::BuildHyperNucleiFTFP_INCLXX();
298 }
299
300 if(withFTFP) {
301 // hyperons
302 G4HadronicBuilder::BuildHyperonsFTFP_BERT();
303
304 // b-, c- baryons and mesons
305 if( param->EnableBCParticles() ) {
306 G4HadronicBuilder::BuildBCHadronsFTFP_BERT();
307 }
308 } else {
309 // hyperons
310 G4HadronicBuilder::BuildHyperonsQGSP_FTFP_BERT(true);
311
312 // b-, c- baryons and mesons
313 if( param->EnableBCParticles() ) {
314 G4HadronicBuilder::BuildBCHadronsQGSP_FTFP_BERT(true);
315 }
316 }
317 }
318 }
319
320 G4HadronPhysicsINCLXX::~G4HadronPhysicsINCLXX()
321 {}
322
323 void G4HadronPhysicsINCLXX::ConstructProcess()
324 {
325 if(G4Threading::IsMasterThread() &&
326 G4HadronicParameters::Instance()->GetVerboseLevel() > 0) {
327 DumpBanner();
328 }
329 CreateModels();
330 }
331
332