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