| Geant4 Cross Reference |
1 // 1
2 // *******************************************
3 // * License and Disclaimer
4 // *
5 // * The Geant4 software is copyright of th
6 // * the Geant4 Collaboration. It is provided
7 // * conditions of the Geant4 Software License
8 // * LICENSE and available at http://cern.ch/
9 // * include a list of copyright holders.
10 // *
11 // * Neither the authors of this software syst
12 // * institutes,nor the agencies providing fin
13 // * work make any representation or warran
14 // * regarding this software system or assum
15 // * use. Please see the license in the file
16 // * for the full disclaimer and the limitatio
17 // *
18 // * This code implementation is the result
19 // * technical work of the GEANT4 collaboratio
20 // * By using, copying, modifying or distri
21 // * any work based on the software) you ag
22 // * use in resulting scientific publicati
23 // * acceptance of all terms of the Geant4 Sof
24 // *******************************************
25 //
26 /// \file HadronicGenerator.cc
27 /// \brief Implementation of the HadronicGener
28 //
29 //--------------------------------------------
30 // Class: HadronicGenerator
31 // Author: Alberto Ribon (CERN EP/SFT)
32 // Date: May 2020
33 //--------------------------------------------
34
35 //....oooOO0OOooo........oooOO0OOooo........oo
36 //....oooOO0OOooo........oooOO0OOooo........oo
37
38 #include "HadronicGenerator.hh"
39
40 #include "G4AblaInterface.hh"
41 #include "G4Alpha.hh"
42 #include "G4AntiAlpha.hh"
43 #include "G4AntiBMesonZero.hh"
44 #include "G4AntiBsMesonZero.hh"
45 #include "G4AntiDMesonZero.hh"
46 #include "G4AntiDeuteron.hh"
47 #include "G4AntiDoubleHyperDoubleNeutron.hh"
48 #include "G4AntiDoubleHyperH4.hh"
49 #include "G4AntiHe3.hh"
50 #include "G4AntiHyperAlpha.hh"
51 #include "G4AntiHyperH4.hh"
52 #include "G4AntiHyperHe5.hh"
53 #include "G4AntiHyperTriton.hh"
54 #include "G4AntiLambda.hh"
55 #include "G4AntiLambdab.hh"
56 #include "G4AntiLambdacPlus.hh"
57 #include "G4AntiNeutron.hh"
58 #include "G4AntiOmegaMinus.hh"
59 #include "G4AntiOmegabMinus.hh"
60 #include "G4AntiOmegacZero.hh"
61 #include "G4AntiProton.hh"
62 #include "G4AntiSigmaMinus.hh"
63 #include "G4AntiSigmaPlus.hh"
64 #include "G4AntiSigmaZero.hh"
65 #include "G4AntiTriton.hh"
66 #include "G4AntiXiMinus.hh"
67 #include "G4AntiXiZero.hh"
68 #include "G4AntiXibMinus.hh"
69 #include "G4AntiXibZero.hh"
70 #include "G4AntiXicPlus.hh"
71 #include "G4AntiXicZero.hh"
72 #include "G4BGGNucleonInelasticXS.hh"
73 #include "G4BGGPionInelasticXS.hh"
74 #include "G4BMesonMinus.hh"
75 #include "G4BMesonPlus.hh"
76 #include "G4BMesonZero.hh"
77 #include "G4BcMesonMinus.hh"
78 #include "G4BcMesonPlus.hh"
79 #include "G4BinaryCascade.hh"
80 #include "G4BinaryLightIonReaction.hh"
81 #include "G4Box.hh"
82 #include "G4BsMesonZero.hh"
83 #include "G4CascadeInterface.hh"
84 #include "G4ChipsHyperonInelasticXS.hh"
85 #include "G4ComponentAntiNuclNuclearXS.hh"
86 #include "G4ComponentGGHadronNucleusXsc.hh"
87 #include "G4ComponentGGNuclNuclXsc.hh"
88 #include "G4CrossSectionInelastic.hh"
89 #include "G4DMesonMinus.hh"
90 #include "G4DMesonPlus.hh"
91 #include "G4DMesonZero.hh"
92 #include "G4DecayPhysics.hh"
93 #include "G4Deuteron.hh"
94 #include "G4DoubleHyperDoubleNeutron.hh"
95 #include "G4DoubleHyperH4.hh"
96 #include "G4DsMesonMinus.hh"
97 #include "G4DsMesonPlus.hh"
98 #include "G4DynamicParticle.hh"
99 #include "G4ExcitationHandler.hh"
100 #include "G4ExcitedStringDecay.hh"
101 #include "G4FTFModel.hh"
102 #include "G4GeneratorPrecompoundInterface.hh"
103 #include "G4GenericIon.hh"
104 #include "G4HadronInelasticProcess.hh"
105 #include "G4HadronicParameters.hh"
106 #include "G4He3.hh"
107 #include "G4HyperAlpha.hh"
108 #include "G4HyperH4.hh"
109 #include "G4HyperHe5.hh"
110 #include "G4HyperTriton.hh"
111 #include "G4INCLXXInterface.hh"
112 #include "G4IonTable.hh"
113 #include "G4KaonMinus.hh"
114 #include "G4KaonPlus.hh"
115 #include "G4KaonZeroLong.hh"
116 #include "G4KaonZeroShort.hh"
117 #include "G4Lambda.hh"
118 #include "G4Lambdab.hh"
119 #include "G4LambdacPlus.hh"
120 #include "G4LundStringFragmentation.hh"
121 #include "G4Material.hh"
122 #include "G4Neutron.hh"
123 #include "G4NeutronInelasticXS.hh"
124 #include "G4OmegaMinus.hh"
125 #include "G4OmegabMinus.hh"
126 #include "G4OmegacZero.hh"
127 #include "G4PVPlacement.hh"
128 #include "G4ParticleTable.hh"
129 #include "G4PhysicalConstants.hh"
130 #include "G4PionMinus.hh"
131 #include "G4PionPlus.hh"
132 #include "G4PreCompoundModel.hh"
133 #include "G4ProcessManager.hh"
134 #include "G4Proton.hh"
135 #include "G4QGSMFragmentation.hh"
136 #include "G4QGSModel.hh"
137 #include "G4QGSParticipants.hh"
138 #include "G4QuasiElasticChannel.hh"
139 #include "G4SigmaMinus.hh"
140 #include "G4SigmaPlus.hh"
141 #include "G4SigmaZero.hh"
142 #include "G4StateManager.hh"
143 #include "G4Step.hh"
144 #include "G4SystemOfUnits.hh"
145 #include "G4TheoFSGenerator.hh"
146 #include "G4TouchableHistory.hh"
147 #include "G4TransportationManager.hh"
148 #include "G4Triton.hh"
149 #include "G4UnitsTable.hh"
150 #include "G4VCrossSectionDataSet.hh"
151 #include "G4VParticleChange.hh"
152 #include "G4XiMinus.hh"
153 #include "G4XiZero.hh"
154 #include "G4XibMinus.hh"
155 #include "G4XibZero.hh"
156 #include "G4XicPlus.hh"
157 #include "G4XicZero.hh"
158 #include "G4ios.hh"
159 #include "globals.hh"
160
161 #include <iomanip>
162
163 //....oooOO0OOooo........oooOO0OOooo........oo
164
165 HadronicGenerator::HadronicGenerator(const G4S
166 : fPhysicsCase(physicsCase),
167 fPhysicsCaseIsSupported(false),
168 fLastHadronicProcess(nullptr),
169 fPartTable(nullptr)
170 {
171 // The constructor set-ups all the particles
172 // hadronic inelastic processes.
173 // This should be done only once for each ap
174 // In the case of a multi-threaded applicati
175 // the constructor should be invoked for eac
176 // i.e. one instance of the class should be
177 // The particles and processes that are crea
178 // will then be used by the method GenerateI
179 // Notes:
180 // - Neither the hadronic models nor the cro
181 // by the method GenerateInteraction, but
182 // hadronic processes and used by Geant4 t
183 // - Although the class generates only final
184 // inelastic hadron-nuclear cross sections
185 // the target nucleus from the target mate
186
187 // Definition of particles
188 G4GenericIon* gion = G4GenericIon::Definitio
189 gion->SetProcessManager(new G4ProcessManager
190 G4DecayPhysics* decays = new G4DecayPhysics;
191 decays->ConstructParticle();
192 fPartTable = G4ParticleTable::GetParticleTab
193 fPartTable->SetReadiness();
194 G4IonTable* ions = fPartTable->GetIonTable()
195 ions->CreateAllIon();
196 ions->CreateAllIsomer();
197
198 // Build BERT model
199 G4CascadeInterface* theBERTmodel = new G4Cas
200
201 // Build BIC model
202 G4BinaryCascade* theBICmodel = new G4BinaryC
203 G4PreCompoundModel* thePreEquilib = new G4Pr
204 theBICmodel->SetDeExcitation(thePreEquilib);
205
206 // Build BinaryLightIon model
207 G4PreCompoundModel* thePreEquilibBis = new G
208 G4BinaryLightIonReaction* theIonBICmodel = n
209
210 // Build the INCL model
211 G4INCLXXInterface* theINCLmodel = new G4INCL
212 const G4bool useAblaDeExcitation = false; /
213 /
214 if (theINCLmodel && useAblaDeExcitation) {
215 G4AblaInterface* theAblaInterface = new G4
216 theINCLmodel->SetDeExcitation(theAblaInter
217 }
218
219 // Build the FTFP model (FTF/Preco) : 4 inst
220 // (Notice that these kinetic energy interva
221 // for all types of hadron and ion projectil
222 // Model instance without energy constraint.
223 // (Used for the case of FTFP model, and for
224 G4TheoFSGenerator* theFTFPmodel = new G4Theo
225 theFTFPmodel->SetMaxEnergy(G4HadronicParamet
226 G4GeneratorPrecompoundInterface* theCascade
227 theCascade->SetDeExcitation(thePreEquilib);
228 theFTFPmodel->SetTransport(theCascade);
229 G4LundStringFragmentation* theLundFragmentat
230 G4ExcitedStringDecay* theStringDecay = new G
231 G4FTFModel* theStringModel = new G4FTFModel;
232 theStringModel->SetFragmentationModel(theStr
233
234 // If the following line is set, then the sq
235 // randomly from a flat distribution in the
236 //***LOOKHERE*** CHOOSE IMPACT PARAMETER MIN
237 // theStringModel->SetBminBmax( 0.0, 2.0*fer
238
239 theFTFPmodel->SetHighEnergyGenerator(theStri
240 // Model instance with constraint to be abov
241 // (Used for ions in all physics lists, and,
242 // also for pions, kaons, nucleons and hyper
243 G4TheoFSGenerator* theFTFPmodel_aboveThresho
244 theFTFPmodel_aboveThreshold->SetMaxEnergy(G4
245 theFTFPmodel_aboveThreshold->SetTransport(th
246 theFTFPmodel_aboveThreshold->SetHighEnergyGe
247 // Model instance with constraint to be with
248 // (Used in the case of QGS-based physics li
249 G4TheoFSGenerator* theFTFPmodel_constrained
250 theFTFPmodel_constrained->SetMaxEnergy(G4Had
251 theFTFPmodel_constrained->SetTransport(theCa
252 theFTFPmodel_constrained->SetHighEnergyGener
253 // Model instance to be used down to zero ki
254 // - in the case of QGS-based physics lists
255 // (Used for anti-baryons, anti-hyperons, an
256 G4TheoFSGenerator* theFTFPmodel_belowThresho
257 theFTFPmodel_belowThreshold->SetMaxEnergy(G4
258 theFTFPmodel_belowThreshold->SetTransport(th
259 theFTFPmodel_belowThreshold->SetHighEnergyGe
260
261 // Build the QGSP model (QGS/Preco)
262 G4TheoFSGenerator* theQGSPmodel = new G4Theo
263 theQGSPmodel->SetMaxEnergy(G4HadronicParamet
264 theQGSPmodel->SetTransport(theCascade);
265 G4QGSMFragmentation* theQgsmFragmentation =
266 G4ExcitedStringDecay* theQgsmStringDecay = n
267 G4VPartonStringModel* theQgsmStringModel = n
268 theQgsmStringModel->SetFragmentationModel(th
269 theQGSPmodel->SetHighEnergyGenerator(theQgsm
270 G4QuasiElasticChannel* theQuasiElastic = new
271 theQGSPmodel->SetQuasiElasticChannel(theQuas
272
273 // For the case of "physics-list proxies", s
274 // Note: the transition energy between hadro
275 // type of hadrons, and version of Gea
276 // energy transition for all types of
277 // moreover, for "FTFP_INCLXX" we use
278 // between FTFP and INCL than in the r
279 if (fPhysicsCase == "FTFP_BERT_ATL" || fPhys
280 || fPhysicsCase == "FTFP_INCLXX" || fPhy
281 {
282 const G4double ftfpMinE = G4HadronicParame
283 const G4double bertMaxE = G4HadronicParame
284 const G4double ftfpMinE_ATL = 9.0 * CLHEP:
285 const G4double bertMaxE_ATL = 12.0 * CLHEP
286 const G4double ftfpMaxE = G4HadronicParame
287 const G4double qgspMinE = G4HadronicParame
288 theFTFPmodel->SetMinEnergy(0.0);
289 theFTFPmodel_belowThreshold->SetMinEnergy(
290 if (fPhysicsCase == "FTFP_BERT_ATL") {
291 theBERTmodel->SetMaxEnergy(bertMaxE_ATL)
292 theIonBICmodel->SetMaxEnergy(bertMaxE_AT
293 theFTFPmodel_aboveThreshold->SetMinEnerg
294 theFTFPmodel_constrained->SetMinEnergy(f
295 }
296 else {
297 theBERTmodel->SetMaxEnergy(bertMaxE);
298 theIonBICmodel->SetMaxEnergy(bertMaxE);
299 theFTFPmodel_aboveThreshold->SetMinEnerg
300 theFTFPmodel_constrained->SetMinEnergy(f
301 }
302 if (fPhysicsCase == "FTFP_INCLXX") {
303 theINCLmodel->SetMaxEnergy(bertMaxE);
304 }
305 if (fPhysicsCase == "QGSP_BERT" || fPhysic
306 theFTFPmodel_constrained->SetMaxEnergy(f
307 theFTFPmodel_belowThreshold->SetMaxEnerg
308 theQGSPmodel->SetMinEnergy(qgspMinE);
309 theBICmodel->SetMaxEnergy(bertMaxE);
310 }
311 }
312
313 // Cross sections (needed by Geant4 to sampl
314 G4VCrossSectionDataSet* thePionMinusXSdata =
315 thePionMinusXSdata->BuildPhysicsTable(*(G4Pi
316 G4VCrossSectionDataSet* thePionPlusXSdata =
317 thePionPlusXSdata->BuildPhysicsTable(*(G4Pio
318 G4VCrossSectionDataSet* theKaonXSdata =
319 new G4CrossSectionInelastic(new G4Componen
320 theKaonXSdata->BuildPhysicsTable(*(G4KaonMin
321 theKaonXSdata->BuildPhysicsTable(*(G4KaonPlu
322 theKaonXSdata->BuildPhysicsTable(*(G4KaonZer
323 theKaonXSdata->BuildPhysicsTable(*(G4KaonZer
324 G4VCrossSectionDataSet* theProtonXSdata = ne
325 theProtonXSdata->BuildPhysicsTable(*(G4Proto
326 G4VCrossSectionDataSet* theNeutronXSdata = n
327 theNeutronXSdata->BuildPhysicsTable(*(G4Neut
328 // For hyperon and anti-hyperons we can use
329 // Glauber-Gribov cross sections
330 // G4VCrossSectionDataSet* theHyperonsXSdata
331 G4VCrossSectionDataSet* theHyperonsXSdata =
332 new G4CrossSectionInelastic(new G4Componen
333 G4VCrossSectionDataSet* theAntibaryonsXSdata
334 new G4CrossSectionInelastic(new G4Componen
335 G4VCrossSectionDataSet* theNuclNuclXSdata =
336 new G4CrossSectionInelastic(new G4Componen
337
338 // Set up inelastic processes : store them i
339 // for convenie
340 typedef std::pair<G4ParticleDefinition*, G4H
341 G4HadronicProcess* thePionMinusInelasticProc
342 new G4HadronInelasticProcess("pi-Inelastic
343 fProcessMap.insert(ProcessPair(G4PionMinus::
344 G4HadronicProcess* thePionPlusInelasticProce
345 new G4HadronInelasticProcess("pi+Inelastic
346 fProcessMap.insert(ProcessPair(G4PionPlus::D
347 G4HadronicProcess* theKaonMinusInelasticProc
348 new G4HadronInelasticProcess("kaon-Inelast
349 fProcessMap.insert(ProcessPair(G4KaonMinus::
350 G4HadronicProcess* theKaonPlusInelasticProce
351 new G4HadronInelasticProcess("kaon+Inelast
352 fProcessMap.insert(ProcessPair(G4KaonPlus::D
353 G4HadronicProcess* theKaonZeroLInelasticProc
354 new G4HadronInelasticProcess("kaon0LInelas
355 fProcessMap.insert(ProcessPair(G4KaonZeroLon
356 G4HadronicProcess* theKaonZeroSInelasticProc
357 new G4HadronInelasticProcess("kaon0SInelas
358 fProcessMap.insert(ProcessPair(G4KaonZeroSho
359 G4HadronicProcess* theProtonInelasticProcess
360 new G4HadronInelasticProcess("protonInelas
361 fProcessMap.insert(ProcessPair(G4Proton::Def
362 G4HadronicProcess* theNeutronInelasticProces
363 new G4HadronInelasticProcess("neutronInela
364 fProcessMap.insert(ProcessPair(G4Neutron::De
365 G4HadronicProcess* theDeuteronInelasticProce
366 new G4HadronInelasticProcess("dInelastic",
367 fProcessMap.insert(ProcessPair(G4Deuteron::D
368 G4HadronicProcess* theTritonInelasticProcess
369 new G4HadronInelasticProcess("tInelastic",
370 fProcessMap.insert(ProcessPair(G4Triton::Def
371 G4HadronicProcess* theHe3InelasticProcess =
372 new G4HadronInelasticProcess("he3Inelastic
373 fProcessMap.insert(ProcessPair(G4He3::Defini
374 G4HadronicProcess* theAlphaInelasticProcess
375 new G4HadronInelasticProcess("alphaInelast
376 fProcessMap.insert(ProcessPair(G4Alpha::Defi
377 G4HadronicProcess* theIonInelasticProcess =
378 new G4HadronInelasticProcess("ionInelastic
379 fProcessMap.insert(ProcessPair(G4GenericIon:
380 G4HadronicProcess* theLambdaInelasticProcess
381 new G4HadronInelasticProcess("lambdaInelas
382 fProcessMap.insert(ProcessPair(G4Lambda::Def
383 G4HadronicProcess* theSigmaMinusInelasticPro
384 new G4HadronInelasticProcess("sigma-Inelas
385 fProcessMap.insert(ProcessPair(G4SigmaMinus:
386 G4HadronicProcess* theSigmaPlusInelasticProc
387 new G4HadronInelasticProcess("sigma+Inelas
388 fProcessMap.insert(ProcessPair(G4SigmaPlus::
389 G4HadronicProcess* theXiMinusInelasticProces
390 new G4HadronInelasticProcess("xi-Inelastic
391 fProcessMap.insert(ProcessPair(G4XiMinus::De
392 G4HadronicProcess* theXiZeroInelasticProcess
393 new G4HadronInelasticProcess("xi0Inelastic
394 fProcessMap.insert(ProcessPair(G4XiZero::Def
395 G4HadronicProcess* theOmegaMinusInelasticPro
396 new G4HadronInelasticProcess("omega-Inelas
397 fProcessMap.insert(ProcessPair(G4OmegaMinus:
398 G4HadronicProcess* theAntiProtonInelasticPro
399 new G4HadronInelasticProcess("anti_protonI
400 fProcessMap.insert(ProcessPair(G4AntiProton:
401 G4HadronicProcess* theAntiNeutronInelasticPr
402 new G4HadronInelasticProcess("anti_neutron
403 fProcessMap.insert(ProcessPair(G4AntiNeutron
404 G4HadronicProcess* theAntiDeuteronInelasticP
405 new G4HadronInelasticProcess("anti_deutero
406 fProcessMap.insert(ProcessPair(G4AntiDeutero
407 G4HadronicProcess* theAntiTritonInelasticPro
408 new G4HadronInelasticProcess("anti_tritonI
409 fProcessMap.insert(ProcessPair(G4AntiTriton:
410 G4HadronicProcess* theAntiHe3InelasticProces
411 new G4HadronInelasticProcess("anti_He3Inel
412 fProcessMap.insert(ProcessPair(G4AntiHe3::De
413 G4HadronicProcess* theAntiAlphaInelasticProc
414 new G4HadronInelasticProcess("anti_alphaIn
415 fProcessMap.insert(ProcessPair(G4AntiAlpha::
416 G4HadronicProcess* theAntiLambdaInelasticPro
417 new G4HadronInelasticProcess("anti-lambdaI
418 fProcessMap.insert(ProcessPair(G4AntiLambda:
419 G4HadronicProcess* theAntiSigmaMinusInelasti
420 new G4HadronInelasticProcess("anti_sigma-I
421 fProcessMap.insert(
422 ProcessPair(G4AntiSigmaMinus::Definition()
423 G4HadronicProcess* theAntiSigmaPlusInelastic
424 new G4HadronInelasticProcess("anti_sigma+I
425 fProcessMap.insert(ProcessPair(G4AntiSigmaPl
426 G4HadronicProcess* theAntiXiMinusInelasticPr
427 new G4HadronInelasticProcess("anti_xi-Inel
428 fProcessMap.insert(ProcessPair(G4AntiXiMinus
429 G4HadronicProcess* theAntiXiZeroInelasticPro
430 new G4HadronInelasticProcess("anti_xi0Inel
431 fProcessMap.insert(ProcessPair(G4AntiXiZero:
432 G4HadronicProcess* theAntiOmegaMinusInelasti
433 new G4HadronInelasticProcess("anti_omega-I
434 fProcessMap.insert(
435 ProcessPair(G4AntiOmegaMinus::Definition()
436
437 G4HadronicProcess* theDPlusInelasticProcess
438 new G4HadronInelasticProcess("D+Inelastic"
439 fProcessMap.insert(ProcessPair(G4DMesonPlus:
440 G4HadronicProcess* theDMinusInelasticProcess
441 new G4HadronInelasticProcess("D-Inelastic"
442 fProcessMap.insert(ProcessPair(G4DMesonMinus
443 G4HadronicProcess* theDZeroInelasticProcess
444 new G4HadronInelasticProcess("D0Inelastic"
445 fProcessMap.insert(ProcessPair(G4DMesonZero:
446 G4HadronicProcess* theAntiDZeroInelasticProc
447 new G4HadronInelasticProcess("anti_D0Inela
448 fProcessMap.insert(ProcessPair(G4AntiDMesonZ
449 G4HadronicProcess* theDsPlusInelasticProcess
450 new G4HadronInelasticProcess("Ds+Inelastic
451 fProcessMap.insert(ProcessPair(G4DsMesonPlus
452 G4HadronicProcess* theDsMinusInelasticProces
453 new G4HadronInelasticProcess("Ds-Inelastic
454 fProcessMap.insert(ProcessPair(G4DsMesonMinu
455 G4HadronicProcess* theBPlusInelasticProcess
456 new G4HadronInelasticProcess("B+Inelastic"
457 fProcessMap.insert(ProcessPair(G4BMesonPlus:
458 G4HadronicProcess* theBMinusInelasticProcess
459 new G4HadronInelasticProcess("B-Inelastic"
460 fProcessMap.insert(ProcessPair(G4BMesonMinus
461 G4HadronicProcess* theBZeroInelasticProcess
462 new G4HadronInelasticProcess("B0Inelastic"
463 fProcessMap.insert(ProcessPair(G4BMesonZero:
464 G4HadronicProcess* theAntiBZeroInelasticProc
465 new G4HadronInelasticProcess("anti_B0Inela
466 fProcessMap.insert(ProcessPair(G4AntiBMesonZ
467 G4HadronicProcess* theBsZeroInelasticProcess
468 new G4HadronInelasticProcess("Bs0Inelastic
469 fProcessMap.insert(ProcessPair(G4BsMesonZero
470 G4HadronicProcess* theAntiBsZeroInelasticPro
471 new G4HadronInelasticProcess("anti_Bs0Inel
472 fProcessMap.insert(ProcessPair(G4AntiBsMeson
473 G4HadronicProcess* theBcPlusInelasticProcess
474 new G4HadronInelasticProcess("Bc+Inelastic
475 fProcessMap.insert(ProcessPair(G4BcMesonPlus
476 G4HadronicProcess* theBcMinusInelasticProces
477 new G4HadronInelasticProcess("Bc-Inelastic
478 fProcessMap.insert(ProcessPair(G4BcMesonMinu
479 G4HadronicProcess* theLambdacPlusInelasticPr
480 new G4HadronInelasticProcess("lambda_c+Ine
481 fProcessMap.insert(ProcessPair(G4LambdacPlus
482 G4HadronicProcess* theAntiLambdacPlusInelast
483 new G4HadronInelasticProcess("anti_lambda_
484 fProcessMap.insert(
485 ProcessPair(G4AntiLambdacPlus::Definition(
486 G4HadronicProcess* theXicPlusInelasticProces
487 new G4HadronInelasticProcess("xi_c+Inelast
488 fProcessMap.insert(ProcessPair(G4XicPlus::De
489 G4HadronicProcess* theAntiXicPlusInelasticPr
490 new G4HadronInelasticProcess("anti_xi_c+In
491 fProcessMap.insert(ProcessPair(G4AntiXicPlus
492 G4HadronicProcess* theXicZeroInelasticProces
493 new G4HadronInelasticProcess("xi_c0Inelast
494 fProcessMap.insert(ProcessPair(G4XicZero::De
495 G4HadronicProcess* theAntiXicZeroInelasticPr
496 new G4HadronInelasticProcess("anti_xi_c0In
497 fProcessMap.insert(ProcessPair(G4AntiXicZero
498 G4HadronicProcess* theOmegacZeroInelasticPro
499 new G4HadronInelasticProcess("omega_c0Inel
500 fProcessMap.insert(ProcessPair(G4OmegacZero:
501 G4HadronicProcess* theAntiOmegacZeroInelasti
502 new G4HadronInelasticProcess("anti_omega_c
503 fProcessMap.insert(
504 ProcessPair(G4AntiOmegacZero::Definition()
505 G4HadronicProcess* theLambdabInelasticProces
506 new G4HadronInelasticProcess("lambda_bInel
507 fProcessMap.insert(ProcessPair(G4Lambdab::De
508 G4HadronicProcess* theAntiLambdabInelasticPr
509 new G4HadronInelasticProcess("anti_lambda_
510 fProcessMap.insert(ProcessPair(G4AntiLambdab
511 G4HadronicProcess* theXibZeroInelasticProces
512 new G4HadronInelasticProcess("xi_b0Inelast
513 fProcessMap.insert(ProcessPair(G4XibZero::De
514 G4HadronicProcess* theAntiXibZeroInelasticPr
515 new G4HadronInelasticProcess("anti_xi_b0In
516 fProcessMap.insert(ProcessPair(G4AntiXibZero
517 G4HadronicProcess* theXibMinusInelasticProce
518 new G4HadronInelasticProcess("xi_b-Inelast
519 fProcessMap.insert(ProcessPair(G4XibMinus::D
520 G4HadronicProcess* theAntiXibMinusInelasticP
521 new G4HadronInelasticProcess("anti_xi_b-In
522 fProcessMap.insert(ProcessPair(G4AntiXibMinu
523 G4HadronicProcess* theOmegabMinusInelasticPr
524 new G4HadronInelasticProcess("omega_b-Inel
525 fProcessMap.insert(ProcessPair(G4OmegabMinus
526 G4HadronicProcess* theAntiOmegabMinusInelast
527 new G4HadronInelasticProcess("anti_omega_b
528 fProcessMap.insert(
529 ProcessPair(G4AntiOmegabMinus::Definition(
530
531 G4HadronicProcess* theHyperTritonInelasticPr
532 new G4HadronInelasticProcess("hypertritonI
533 fProcessMap.insert(ProcessPair(G4HyperTriton
534 G4HadronicProcess* theAntiHyperTritonInelast
535 new G4HadronInelasticProcess("anti_hypertr
536 fProcessMap.insert(
537 ProcessPair(G4AntiHyperTriton::Definition(
538 G4HadronicProcess* theHyperAlphaInelasticPro
539 new G4HadronInelasticProcess("hyperalphaIn
540 fProcessMap.insert(ProcessPair(G4HyperAlpha:
541 G4HadronicProcess* theAntiHyperAlphaInelasti
542 new G4HadronInelasticProcess("anti_hyperal
543 fProcessMap.insert(
544 ProcessPair(G4AntiHyperAlpha::Definition()
545 G4HadronicProcess* theHyperH4InelasticProces
546 new G4HadronInelasticProcess("hyperH4Inela
547 fProcessMap.insert(ProcessPair(G4HyperH4::De
548 G4HadronicProcess* theAntiHyperH4InelasticPr
549 new G4HadronInelasticProcess("anti_hyperH4
550 fProcessMap.insert(ProcessPair(G4AntiHyperH4
551 G4HadronicProcess* theDoubleHyperH4Inelastic
552 new G4HadronInelasticProcess("doublehyperH
553 fProcessMap.insert(ProcessPair(G4DoubleHyper
554 G4HadronicProcess* theAntiDoubleHyperH4Inela
555 new G4HadronInelasticProcess("anti_doubleh
556 fProcessMap.insert(
557 ProcessPair(G4AntiDoubleHyperH4::Definitio
558 G4HadronicProcess* theDoubleHyperDoubleNeutr
559 "doublehyperdoubleneutronInelastic", G4Dou
560 fProcessMap.insert(ProcessPair(G4DoubleHyper
561 theDoubleHype
562 G4HadronicProcess* theAntiDoubleHyperDoubleN
563 "anti_doublehyperdoubleneutronInelastic",
564 fProcessMap.insert(ProcessPair(G4AntiDoubleH
565 theAntiDouble
566 G4HadronicProcess* theHyperHe5InelasticProce
567 new G4HadronInelasticProcess("hyperHe5Inel
568 fProcessMap.insert(ProcessPair(G4HyperHe5::D
569 G4HadronicProcess* theAntiHyperHe5InelasticP
570 new G4HadronInelasticProcess("anti_hyperHe
571 fProcessMap.insert(ProcessPair(G4AntiHyperHe
572
573 // Add the cross sections to the correspondi
574 thePionMinusInelasticProcess->AddDataSet(the
575 thePionPlusInelasticProcess->AddDataSet(theP
576 theKaonMinusInelasticProcess->AddDataSet(the
577 theKaonPlusInelasticProcess->AddDataSet(theK
578 theKaonZeroLInelasticProcess->AddDataSet(the
579 theKaonZeroSInelasticProcess->AddDataSet(the
580 theProtonInelasticProcess->AddDataSet(thePro
581 theNeutronInelasticProcess->AddDataSet(theNe
582 theDeuteronInelasticProcess->AddDataSet(theN
583 theTritonInelasticProcess->AddDataSet(theNuc
584 theHe3InelasticProcess->AddDataSet(theNuclNu
585 theAlphaInelasticProcess->AddDataSet(theNucl
586 theIonInelasticProcess->AddDataSet(theNuclNu
587 theLambdaInelasticProcess->AddDataSet(theHyp
588 theSigmaMinusInelasticProcess->AddDataSet(th
589 theSigmaPlusInelasticProcess->AddDataSet(the
590 theXiMinusInelasticProcess->AddDataSet(theHy
591 theXiZeroInelasticProcess->AddDataSet(theHyp
592 theOmegaMinusInelasticProcess->AddDataSet(th
593 theAntiProtonInelasticProcess->AddDataSet(th
594 theAntiNeutronInelasticProcess->AddDataSet(t
595 theAntiDeuteronInelasticProcess->AddDataSet(
596 theAntiTritonInelasticProcess->AddDataSet(th
597 theAntiHe3InelasticProcess->AddDataSet(theAn
598 theAntiAlphaInelasticProcess->AddDataSet(the
599 theAntiLambdaInelasticProcess->AddDataSet(th
600 theAntiSigmaMinusInelasticProcess->AddDataSe
601 theAntiSigmaPlusInelasticProcess->AddDataSet
602 theAntiXiMinusInelasticProcess->AddDataSet(t
603 theAntiXiZeroInelasticProcess->AddDataSet(th
604 theAntiOmegaMinusInelasticProcess->AddDataSe
605
606 theDPlusInelasticProcess->AddDataSet(theHype
607 theDMinusInelasticProcess->AddDataSet(theHyp
608 theDZeroInelasticProcess->AddDataSet(theHype
609 theAntiDZeroInelasticProcess->AddDataSet(the
610 theDsPlusInelasticProcess->AddDataSet(theHyp
611 theDsMinusInelasticProcess->AddDataSet(theHy
612 theBPlusInelasticProcess->AddDataSet(theHype
613 theBMinusInelasticProcess->AddDataSet(theHyp
614 theBZeroInelasticProcess->AddDataSet(theHype
615 theAntiBZeroInelasticProcess->AddDataSet(the
616 theBsZeroInelasticProcess->AddDataSet(theHyp
617 theAntiBsZeroInelasticProcess->AddDataSet(th
618 theBcPlusInelasticProcess->AddDataSet(theHyp
619 theBcMinusInelasticProcess->AddDataSet(theHy
620 theLambdacPlusInelasticProcess->AddDataSet(t
621 theAntiLambdacPlusInelasticProcess->AddDataS
622 theXicPlusInelasticProcess->AddDataSet(theHy
623 theAntiXicPlusInelasticProcess->AddDataSet(t
624 theXicZeroInelasticProcess->AddDataSet(theHy
625 theAntiXicZeroInelasticProcess->AddDataSet(t
626 theOmegacZeroInelasticProcess->AddDataSet(th
627 theAntiOmegacZeroInelasticProcess->AddDataSe
628 theLambdabInelasticProcess->AddDataSet(theHy
629 theAntiLambdabInelasticProcess->AddDataSet(t
630 theXibZeroInelasticProcess->AddDataSet(theHy
631 theAntiXibZeroInelasticProcess->AddDataSet(t
632 theXibMinusInelasticProcess->AddDataSet(theH
633 theAntiXibMinusInelasticProcess->AddDataSet(
634 theOmegabMinusInelasticProcess->AddDataSet(t
635 theAntiOmegabMinusInelasticProcess->AddDataS
636
637 theHyperTritonInelasticProcess->AddDataSet(t
638 theAntiHyperTritonInelasticProcess->AddDataS
639 theHyperAlphaInelasticProcess->AddDataSet(th
640 theAntiHyperAlphaInelasticProcess->AddDataSe
641 theHyperH4InelasticProcess->AddDataSet(theNu
642 theAntiHyperH4InelasticProcess->AddDataSet(t
643 theDoubleHyperH4InelasticProcess->AddDataSet
644 theAntiDoubleHyperH4InelasticProcess->AddDat
645 theDoubleHyperDoubleNeutronInelasticProcess-
646 theAntiDoubleHyperDoubleNeutronInelasticProc
647 theHyperHe5InelasticProcess->AddDataSet(theN
648 theAntiHyperHe5InelasticProcess->AddDataSet(
649
650 // Register the proper hadronic model(s) to
651 // Note: hadronic models ("BERT", "BIC", "Io
652 // used for the hadrons and energies t
653 // (exception for INCL, which in recen
654 // more hadron types and higher energ
655 // For "physics-list proxies" ("FTFP_B
656 // "QGSP_BIC", "FTFP_INCLXX"), all had
657 // by combining different hadronic mod
658 // to the corresponding physics lists.
659 if (fPhysicsCase == "BIC" || fPhysicsCase ==
660 // The BIC model is applicable to nucleons
661 // whereas in the physics list QGSP_BIC it
662 fPhysicsCaseIsSupported = true;
663 theProtonInelasticProcess->RegisterMe(theB
664 theNeutronInelasticProcess->RegisterMe(the
665 if (fPhysicsCase == "BIC") {
666 thePionMinusInelasticProcess->RegisterMe
667 thePionPlusInelasticProcess->RegisterMe(
668 }
669 else {
670 thePionMinusInelasticProcess->RegisterMe
671 thePionPlusInelasticProcess->RegisterMe(
672 }
673 }
674 else if (fPhysicsCase == "INCL" || fPhysicsC
675 // We consider here for simplicity only nu
676 // (although recent versions of INCL can h
677 fPhysicsCaseIsSupported = true;
678 thePionMinusInelasticProcess->RegisterMe(t
679 thePionPlusInelasticProcess->RegisterMe(th
680 theProtonInelasticProcess->RegisterMe(theI
681 theNeutronInelasticProcess->RegisterMe(the
682 }
683 if (fPhysicsCase == "IonBIC" || fPhysicsCase
684 || fPhysicsCase == "FTFP_INCLXX" || fPhy
685 {
686 // The Binary Light Ion model is used for
687 fPhysicsCaseIsSupported = true;
688 theDeuteronInelasticProcess->RegisterMe(th
689 theTritonInelasticProcess->RegisterMe(theI
690 theHe3InelasticProcess->RegisterMe(theIonB
691 theAlphaInelasticProcess->RegisterMe(theIo
692 theIonInelasticProcess->RegisterMe(theIonB
693 }
694 if (fPhysicsCase == "QGSP" || fPhysicsCase =
695 fPhysicsCaseIsSupported = true;
696 thePionMinusInelasticProcess->RegisterMe(t
697 thePionPlusInelasticProcess->RegisterMe(th
698 theKaonMinusInelasticProcess->RegisterMe(t
699 theKaonPlusInelasticProcess->RegisterMe(th
700 theKaonZeroLInelasticProcess->RegisterMe(t
701 theKaonZeroSInelasticProcess->RegisterMe(t
702 theProtonInelasticProcess->RegisterMe(theQ
703 theNeutronInelasticProcess->RegisterMe(the
704 theLambdaInelasticProcess->RegisterMe(theQ
705 theSigmaMinusInelasticProcess->RegisterMe(
706 theSigmaPlusInelasticProcess->RegisterMe(t
707 theXiMinusInelasticProcess->RegisterMe(the
708 theXiZeroInelasticProcess->RegisterMe(theQ
709 theOmegaMinusInelasticProcess->RegisterMe(
710 theAntiProtonInelasticProcess->RegisterMe(
711 theAntiNeutronInelasticProcess->RegisterMe
712 theAntiLambdaInelasticProcess->RegisterMe(
713 theAntiSigmaMinusInelasticProcess->Registe
714 theAntiSigmaPlusInelasticProcess->Register
715 theAntiXiMinusInelasticProcess->RegisterMe
716 theAntiXiZeroInelasticProcess->RegisterMe(
717 theAntiOmegaMinusInelasticProcess->Registe
718 theDPlusInelasticProcess->RegisterMe(theQG
719 theDMinusInelasticProcess->RegisterMe(theQ
720 theDZeroInelasticProcess->RegisterMe(theQG
721 theAntiDZeroInelasticProcess->RegisterMe(t
722 theDsPlusInelasticProcess->RegisterMe(theQ
723 theDsMinusInelasticProcess->RegisterMe(the
724 theBPlusInelasticProcess->RegisterMe(theQG
725 theBMinusInelasticProcess->RegisterMe(theQ
726 theBZeroInelasticProcess->RegisterMe(theQG
727 theAntiBZeroInelasticProcess->RegisterMe(t
728 theBsZeroInelasticProcess->RegisterMe(theQ
729 theAntiBsZeroInelasticProcess->RegisterMe(
730 theBcPlusInelasticProcess->RegisterMe(theQ
731 theBcMinusInelasticProcess->RegisterMe(the
732 theLambdacPlusInelasticProcess->RegisterMe
733 theAntiLambdacPlusInelasticProcess->Regist
734 theXicPlusInelasticProcess->RegisterMe(the
735 theAntiXicPlusInelasticProcess->RegisterMe
736 theXicZeroInelasticProcess->RegisterMe(the
737 theAntiXicZeroInelasticProcess->RegisterMe
738 theOmegacZeroInelasticProcess->RegisterMe(
739 theAntiOmegacZeroInelasticProcess->Registe
740 theLambdabInelasticProcess->RegisterMe(the
741 theAntiLambdabInelasticProcess->RegisterMe
742 theXibZeroInelasticProcess->RegisterMe(the
743 theAntiXibZeroInelasticProcess->RegisterMe
744 theXibMinusInelasticProcess->RegisterMe(th
745 theAntiXibMinusInelasticProcess->RegisterM
746 theOmegabMinusInelasticProcess->RegisterMe
747 theAntiOmegabMinusInelasticProcess->Regist
748 }
749 if (fPhysicsCase == "BERT" || fPhysicsCase =
750 || fPhysicsCase == "QGSP_BERT")
751 {
752 // The BERT model is used for pions and nu
753 fPhysicsCaseIsSupported = true;
754 thePionMinusInelasticProcess->RegisterMe(t
755 thePionPlusInelasticProcess->RegisterMe(th
756 theProtonInelasticProcess->RegisterMe(theB
757 theNeutronInelasticProcess->RegisterMe(the
758 }
759 if (fPhysicsCase == "BERT" || fPhysicsCase =
760 || fPhysicsCase == "FTFP_INCLXX" || fPhy
761 {
762 // The BERT model is used for kaons and hy
763 fPhysicsCaseIsSupported = true;
764 theKaonMinusInelasticProcess->RegisterMe(t
765 theKaonPlusInelasticProcess->RegisterMe(th
766 theKaonZeroLInelasticProcess->RegisterMe(t
767 theKaonZeroSInelasticProcess->RegisterMe(t
768 theLambdaInelasticProcess->RegisterMe(theB
769 theSigmaMinusInelasticProcess->RegisterMe(
770 theSigmaPlusInelasticProcess->RegisterMe(t
771 theXiMinusInelasticProcess->RegisterMe(the
772 theXiZeroInelasticProcess->RegisterMe(theB
773 theOmegaMinusInelasticProcess->RegisterMe(
774 }
775 if (fPhysicsCase == "FTFP" || fPhysicsCase =
776 || fPhysicsCase == "FTFP_INCLXX" || fPhy
777 {
778 // The FTFP model is applied for all hadro
779 // whether it is consider as a stand-alone
780 fPhysicsCaseIsSupported = true;
781 theAntiDeuteronInelasticProcess->RegisterM
782 theAntiTritonInelasticProcess->RegisterMe(
783 theAntiHe3InelasticProcess->RegisterMe(the
784 theAntiAlphaInelasticProcess->RegisterMe(t
785 G4TheoFSGenerator* theFTFPmodelToBeUsed =
786 if (fPhysicsCase == "FTFP") {
787 theFTFPmodelToBeUsed = theFTFPmodel;
788 }
789 else if (fPhysicsCase == "QGSP_BERT" || fP
790 theFTFPmodelToBeUsed = theFTFPmodel_cons
791 }
792 thePionMinusInelasticProcess->RegisterMe(t
793 thePionPlusInelasticProcess->RegisterMe(th
794 theKaonMinusInelasticProcess->RegisterMe(t
795 theKaonPlusInelasticProcess->RegisterMe(th
796 theKaonZeroLInelasticProcess->RegisterMe(t
797 theKaonZeroSInelasticProcess->RegisterMe(t
798 theProtonInelasticProcess->RegisterMe(theF
799 theAntiProtonInelasticProcess->RegisterMe(
800 theNeutronInelasticProcess->RegisterMe(the
801 theAntiNeutronInelasticProcess->RegisterMe
802 theLambdaInelasticProcess->RegisterMe(theF
803 theAntiLambdaInelasticProcess->RegisterMe(
804 theSigmaMinusInelasticProcess->RegisterMe(
805 theAntiSigmaMinusInelasticProcess->Registe
806 theSigmaPlusInelasticProcess->RegisterMe(t
807 theAntiSigmaPlusInelasticProcess->Register
808 theXiMinusInelasticProcess->RegisterMe(the
809 theAntiXiMinusInelasticProcess->RegisterMe
810 theXiZeroInelasticProcess->RegisterMe(theF
811 theAntiXiZeroInelasticProcess->RegisterMe(
812 theOmegaMinusInelasticProcess->RegisterMe(
813 theAntiOmegaMinusInelasticProcess->Registe
814 theDPlusInelasticProcess->RegisterMe(theFT
815 theDMinusInelasticProcess->RegisterMe(theF
816 theDZeroInelasticProcess->RegisterMe(theFT
817 theAntiDZeroInelasticProcess->RegisterMe(t
818 theDsPlusInelasticProcess->RegisterMe(theF
819 theDsMinusInelasticProcess->RegisterMe(the
820 theBPlusInelasticProcess->RegisterMe(theFT
821 theBMinusInelasticProcess->RegisterMe(theF
822 theBZeroInelasticProcess->RegisterMe(theFT
823 theAntiBZeroInelasticProcess->RegisterMe(t
824 theBsZeroInelasticProcess->RegisterMe(theF
825 theAntiBsZeroInelasticProcess->RegisterMe(
826 theBcPlusInelasticProcess->RegisterMe(theF
827 theBcMinusInelasticProcess->RegisterMe(the
828 theLambdacPlusInelasticProcess->RegisterMe
829 theAntiLambdacPlusInelasticProcess->Regist
830 theXicPlusInelasticProcess->RegisterMe(the
831 theAntiXicPlusInelasticProcess->RegisterMe
832 theXicZeroInelasticProcess->RegisterMe(the
833 theAntiXicZeroInelasticProcess->RegisterMe
834 theOmegacZeroInelasticProcess->RegisterMe(
835 theAntiOmegacZeroInelasticProcess->Registe
836 theLambdabInelasticProcess->RegisterMe(the
837 theAntiLambdabInelasticProcess->RegisterMe
838 theXibZeroInelasticProcess->RegisterMe(the
839 theAntiXibZeroInelasticProcess->RegisterMe
840 theXibMinusInelasticProcess->RegisterMe(th
841 theAntiXibMinusInelasticProcess->RegisterM
842 theOmegabMinusInelasticProcess->RegisterMe
843 theAntiOmegabMinusInelasticProcess->Regist
844 theFTFPmodelToBeUsed = theFTFPmodel_aboveT
845 if (fPhysicsCase == "FTFP") theFTFPmodelTo
846 theDeuteronInelasticProcess->RegisterMe(th
847 theTritonInelasticProcess->RegisterMe(theF
848 theHe3InelasticProcess->RegisterMe(theFTFP
849 theAlphaInelasticProcess->RegisterMe(theFT
850 theIonInelasticProcess->RegisterMe(theFTFP
851 }
852
853 if (G4HadronicParameters::Instance()->Enable
854 // Only FTFP and INCL can handle the nucle
855 // of light hypernuclei, and only FTFP is
856 // the nuclear interactions of light anti-
857 if (fPhysicsCase == "FTFP_BERT" || fPhysic
858 fPhysicsCaseIsSupported = true;
859 if (fPhysicsCase == "FTFP_INCLXX") {
860 theHyperTritonInelasticProcess->Regist
861 theHyperAlphaInelasticProcess->Registe
862 theHyperH4InelasticProcess->RegisterMe
863 theDoubleHyperH4InelasticProcess->Regi
864 theDoubleHyperDoubleNeutronInelasticPr
865 theHyperHe5InelasticProcess->RegisterM
866 }
867 else {
868 theHyperTritonInelasticProcess->Regist
869 theHyperAlphaInelasticProcess->Registe
870 theHyperH4InelasticProcess->RegisterMe
871 theDoubleHyperH4InelasticProcess->Regi
872 theDoubleHyperDoubleNeutronInelasticPr
873 theHyperHe5InelasticProcess->RegisterM
874 }
875 theAntiHyperTritonInelasticProcess->Regi
876 theAntiHyperAlphaInelasticProcess->Regis
877 theAntiHyperH4InelasticProcess->Register
878 theAntiDoubleHyperH4InelasticProcess->Re
879 theAntiDoubleHyperDoubleNeutronInelastic
880 theAntiHyperHe5InelasticProcess->Registe
881 }
882 if (fPhysicsCase == "FTFP_INCLXX" || fPhys
883 fPhysicsCaseIsSupported = true;
884 theHyperTritonInelasticProcess->Register
885 theHyperAlphaInelasticProcess->RegisterM
886 theHyperH4InelasticProcess->RegisterMe(t
887 theDoubleHyperH4InelasticProcess->Regist
888 theDoubleHyperDoubleNeutronInelasticProc
889 theHyperHe5InelasticProcess->RegisterMe(
890 }
891 }
892
893 if (!fPhysicsCaseIsSupported) {
894 G4cerr << "ERROR: Not supported final-stat
895 << G4endl << "\t Re-try by choosing
896 << "\t - Hadronic models : BERT, BI
897 << "\t - \"Physics-list proxies\" :
898
899 << G4endl;
900 }
901 }
902
903 //....oooOO0OOooo........oooOO0OOooo........oo
904
905 HadronicGenerator::~HadronicGenerator()
906 {
907 fPartTable->DeleteAllParticles();
908 }
909
910 //....oooOO0OOooo........oooOO0OOooo........oo
911
912 G4bool HadronicGenerator::IsApplicable(const G
913 const G
914 {
915 G4ParticleDefinition* projectileDefinition =
916 return IsApplicable(projectileDefinition, pr
917 }
918
919 //....oooOO0OOooo........oooOO0OOooo........oo
920
921 G4bool HadronicGenerator::IsApplicable(G4Parti
922 const G
923 {
924 if (projectileDefinition == nullptr) return
925 G4bool isApplicable = true;
926 // No restrictions for "physics list proxies
927 // For the individual models, instead, we ne
928 if (fPhysicsCase == "BERT") {
929 // We consider BERT model below 15 GeV
930 if (((projectileDefinition != G4PionMinus:
931 && (projectileDefinition != G4PionPlu
932 && (projectileDefinition != G4Proton:
933 && (projectileDefinition != G4Neutron
934 && (projectileDefinition != G4Lambda:
935 && (projectileDefinition != G4SigmaMi
936 && (projectileDefinition != G4SigmaPl
937 && (projectileDefinition != G4XiMinus
938 && (projectileDefinition != G4XiZero:
939 && (projectileDefinition != G4OmegaMi
940 || (projectileEnergy > 15.0 * CLHEP::G
941 {
942 isApplicable = false;
943 }
944 }
945 else if (fPhysicsCase == "QGSP") {
946 // We consider QGSP above 2 GeV and not fo
947 if (projectileEnergy < 2.0 * CLHEP::GeV ||
948 || projectileDefinition == G4Triton::D
949 || projectileDefinition == G4He3::Defi
950 || projectileDefinition == G4Alpha::De
951 || projectileDefinition == G4GenericIo
952 || projectileDefinition == G4AntiDeute
953 || projectileDefinition == G4AntiTrito
954 || projectileDefinition == G4AntiHe3::
955 || projectileDefinition == G4AntiAlpha
956 {
957 isApplicable = false;
958 }
959 }
960 else if (fPhysicsCase == "BIC" || fPhysicsCa
961 // We consider BIC and INCL models only fo
962 // (although in recent versions INCL is ca
963 // and up to higher energies)
964 if (((projectileDefinition != G4PionMinus:
965 && (projectileDefinition != G4PionPlu
966 && (projectileDefinition != G4Proton:
967 && (projectileDefinition != G4Neutron
968 || (projectileEnergy > 10.0 * CLHEP::G
969 {
970 isApplicable = false;
971 }
972 }
973 else if (fPhysicsCase == "IonBIC") {
974 // We consider IonBIC models only for deut
975 // with energies below 10 GeV / nucleon
976 if (!((projectileDefinition == G4Deuteron:
977 && projectileEnergy < 2 * 10.0 * CL
978 || (projectileDefinition == G4Triton
979 && projectileEnergy < 3 * 10.0 *
980 || (projectileDefinition == G4He3::D
981 && projectileEnergy < 3 * 10.0 *
982 || (projectileDefinition == G4Alpha:
983 && projectileEnergy < 4 * 10.0 *
984 {
985 isApplicable = false;
986 }
987 }
988 return isApplicable;
989 }
990
991 //....oooOO0OOooo........oooOO0OOooo........oo
992
993 G4VParticleChange* HadronicGenerator::Generate
994
995
996
997 {
998 G4ParticleDefinition* projectileDefinition =
999 return GenerateInteraction(projectileDefinit
1000 targetMaterial);
1001 }
1002
1003 //....oooOO0OOooo........oooOO0OOooo........o
1004
1005 G4VParticleChange* HadronicGenerator::Generat
1006 G4ParticleDefinition* projectileDefinition,
1007 const G4ThreeVector& projectileDirection, G
1008 {
1009 // This is the most important method of the
1010 // the method performs the specified hadron
1011 // (by invoking the "PostStepDoIt" method o
1012 // and returns the final state, i.e. the se
1013 // It is a relatively short method because
1014 // possible hadronic processes - with their
1015 // and cross sections (the latter is needed
1016 // the target material) - was already done
1017 G4VParticleChange* aChange = nullptr;
1018
1019 if (projectileDefinition == nullptr) {
1020 G4cerr << "ERROR: projectileDefinition is
1021 return aChange;
1022 }
1023
1024 // Debugging print-out
1025 // G4cout << "\t" << projectileDefinition->
1026 // << "\t" << projectileEnergy/CLHEP:
1027 // << " GeV \t" << projectileDirectio
1028 // << "\t" << ( targetMaterial ? targ
1029 if (!IsApplicable(projectileDefinition, pro
1030 // G4cout << " -> NOT applicable !" ; //<
1031 return aChange;
1032 }
1033 // G4cout << G4endl;
1034
1035 // Check Geant4 state (not strictly needed)
1036 // if ( ! G4StateManager::GetStateManager()
1037 // G4cerr << "ERROR: No possible to set G4
1038 // return aChange;
1039 //}
1040
1041 // Geometry definition (not strictly needed
1042 // const G4double dimX = 1.0*mm;
1043 // const G4double dimY = 1.0*mm;
1044 // const G4double dimZ = 1.0*mm;
1045 // G4Box* sFrame = new G4Box( "Box", dimX,
1046 // G4LogicalVolume* lFrame = new G4LogicalV
1047 // G4PVPlacement* pFrame = new G4PVPlacemen
1048 // G4TransportationManager::GetTransportati
1049
1050 // Projectile track & step
1051 G4DynamicParticle dParticle(projectileDefin
1052 const G4double aTime = 0.0;
1053 const G4ThreeVector aPosition = G4ThreeVect
1054 G4Track* gTrack = new G4Track(&dParticle, a
1055 G4TouchableHandle fpTouchable(new G4Touchab
1056 gTrack->SetTouchableHandle(fpTouchable); /
1057 G4Step* step = new G4Step;
1058 step->SetTrack(gTrack);
1059 gTrack->SetStep(step);
1060 G4StepPoint* aPoint = new G4StepPoint;
1061 aPoint->SetPosition(aPosition);
1062 aPoint->SetMaterial(targetMaterial);
1063 step->SetPreStepPoint(aPoint);
1064 dParticle.SetKineticEnergy(projectileEnergy
1065 gTrack->SetStep(step);
1066 gTrack->SetKineticEnergy(projectileEnergy);
1067
1068 // Change Geant4 state: from "PreInit" to "
1069 // if ( ! G4StateManager::GetStateManager()
1070 // G4cerr << "ERROR: No possible to set G4
1071 // return aChange;
1072 //}
1073
1074 // Finally, the hadronic interaction: hadro
1075 // need to be treated slightly differently
1076 G4HadronicProcess* theProcess = nullptr;
1077 G4ParticleDefinition* theProjectileDef = nu
1078 if (projectileDefinition->IsGeneralIon()) {
1079 theProjectileDef = G4GenericIon::Definiti
1080 }
1081 else {
1082 theProjectileDef = projectileDefinition;
1083 }
1084 auto mapIndex = fProcessMap.find(theProject
1085 if (mapIndex != fProcessMap.end()) theProce
1086 if (theProcess != nullptr) {
1087 aChange = theProcess->PostStepDoIt(*gTrac
1088 //***************************************
1089 }
1090 else {
1091 G4cerr << "ERROR: theProcess is nullptr !
1092 }
1093 fLastHadronicProcess = theProcess;
1094 // delete pFrame;
1095 // delete lFrame;
1096 // delete sFrame;
1097
1098 return aChange;
1099 }
1100
1101 //....oooOO0OOooo........oooOO0OOooo........o
1102
1103 G4double HadronicGenerator::GetImpactParamete
1104 {
1105 G4double impactParameter = -999.0 * fermi;
1106 G4HadronicProcess* hadProcess = GetHadronic
1107 G4HadronicInteraction* hadInteraction = Get
1108 G4HadronicInteraction* wantedHadInteraction
1109 const_cast<G4HadronicProcess*>(hadProcess
1110 if (hadInteraction != nullptr && hadInterac
1111 // FTFP has handled the inelastic hadroni
1112 G4TheoFSGenerator* theoFSGenerator = dyna
1113 if (theoFSGenerator != nullptr) {
1114 const G4FTFModel* ftfModel =
1115 dynamic_cast<const G4FTFModel*>(theoF
1116 if (ftfModel != nullptr) {
1117 // ftfModel points to the G4FTFModel
1118 // inelastic hadronic interaction.
1119 impactParameter = ftfModel->GetImpact
1120 // G4cout << "\t impactParameter = "
1121 }
1122 }
1123 }
1124 return impactParameter;
1125 }
1126
1127 //....oooOO0OOooo........oooOO0OOooo........o
1128
1129 G4int HadronicGenerator::GetNumberOfProjectil
1130 {
1131 G4double numProjectileSpectatorNucleons = -
1132 G4HadronicProcess* hadProcess = GetHadronic
1133 G4HadronicInteraction* hadInteraction = Get
1134 G4HadronicInteraction* wantedHadInteraction
1135 const_cast<G4HadronicProcess*>(hadProcess
1136 if (hadInteraction != nullptr && hadInterac
1137 G4TheoFSGenerator* theoFSGenerator = dyna
1138 if (theoFSGenerator != nullptr) {
1139 const G4FTFModel* ftfModel =
1140 dynamic_cast<const G4FTFModel*>(theoF
1141 if (ftfModel != nullptr) {
1142 numProjectileSpectatorNucleons = ftfM
1143 // G4cout << "\t numProjectileSpectat
1144 // << G4endl;
1145 }
1146 }
1147 }
1148 return numProjectileSpectatorNucleons;
1149 }
1150
1151 //....oooOO0OOooo........oooOO0OOooo........o
1152
1153 G4int HadronicGenerator::GetNumberOfTargetSpe
1154 {
1155 G4double numTargetSpectatorNucleons = -999;
1156 G4HadronicProcess* hadProcess = GetHadronic
1157 G4HadronicInteraction* hadInteraction = Get
1158 G4HadronicInteraction* wantedHadInteraction
1159 const_cast<G4HadronicProcess*>(hadProcess
1160 if (hadInteraction != nullptr && hadInterac
1161 G4TheoFSGenerator* theoFSGenerator = dyna
1162 if (theoFSGenerator != nullptr) {
1163 const G4FTFModel* ftfModel =
1164 dynamic_cast<const G4FTFModel*>(theoF
1165 if (ftfModel != nullptr) {
1166 numTargetSpectatorNucleons = ftfModel
1167 // G4cout << "\t numTargetSpectatorNu
1168 }
1169 }
1170 }
1171 return numTargetSpectatorNucleons;
1172 }
1173
1174 //....oooOO0OOooo........oooOO0OOooo........o
1175
1176 G4int HadronicGenerator::GetNumberOfNNcollisi
1177 {
1178 G4double numNNcollisions = -999;
1179 G4HadronicProcess* hadProcess = GetHadronic
1180 G4HadronicInteraction* hadInteraction = Get
1181 G4HadronicInteraction* wantedHadInteraction
1182 const_cast<G4HadronicProcess*>(hadProcess
1183 if (hadInteraction != nullptr && hadInterac
1184 G4TheoFSGenerator* theoFSGenerator = dyna
1185 if (theoFSGenerator != nullptr) {
1186 const G4FTFModel* ftfModel =
1187 dynamic_cast<const G4FTFModel*>(theoF
1188 if (ftfModel != nullptr) {
1189 numNNcollisions = ftfModel->GetNumber
1190 // G4cout << "\t numNNcollisions = "
1191 }
1192 }
1193 }
1194 return numNNcollisions;
1195 }
1196
1197 //....oooOO0OOooo........oooOO0OOooo........o
1198