| 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 biasing/B03/src/B03PhysicsList.cc <<
27 /// \brief Implementation of the B03PhysicsLis <<
28 // <<
29 // 26 //
>> 27 // $Id: B03PhysicsList.cc,v 1.5 2006/06/29 16:35:21 gunter Exp $
>> 28 // GEANT4 tag $Name: geant4-08-01-patch-01 $
30 // 29 //
31 30
>> 31 #include "globals.hh"
>> 32 #include <iomanip>
>> 33
32 #include "B03PhysicsList.hh" 34 #include "B03PhysicsList.hh"
33 35
34 #include "G4BaryonConstructor.hh" <<
35 #include "G4BosonConstructor.hh" <<
36 #include "G4HadronicParameters.hh" <<
37 #include "G4IonConstructor.hh" <<
38 #include "G4LeptonConstructor.hh" <<
39 #include "G4Material.hh" <<
40 #include "G4MaterialTable.hh" <<
41 #include "G4MesonConstructor.hh" <<
42 #include "G4ParticleDefinition.hh" 36 #include "G4ParticleDefinition.hh"
43 #include "G4ParticleTable.hh" <<
44 #include "G4ParticleTypes.hh" <<
45 #include "G4ParticleWithCuts.hh" 37 #include "G4ParticleWithCuts.hh"
46 #include "G4ProcessManager.hh" 38 #include "G4ProcessManager.hh"
47 #include "G4ProcessVector.hh" 39 #include "G4ProcessVector.hh"
>> 40 #include "G4ParticleTypes.hh"
>> 41 #include "G4ParticleTable.hh"
>> 42 #include "G4BosonConstructor.hh"
>> 43 #include "G4LeptonConstructor.hh"
>> 44 #include "G4MesonConstructor.hh"
>> 45 #include "G4BaryonConstructor.hh"
>> 46 #include "G4IonConstructor.hh"
48 #include "G4ShortLivedConstructor.hh" 47 #include "G4ShortLivedConstructor.hh"
49 #include "G4SystemOfUnits.hh" << 48 #include "G4Material.hh"
50 #include "globals.hh" << 49 #include "G4MaterialTable.hh"
51 <<
52 #include <iomanip> <<
53 <<
54 //....oooOO0OOooo........oooOO0OOooo........oo <<
55 50
56 B03PhysicsList::B03PhysicsList(G4String parall << 51 B03PhysicsList::B03PhysicsList() : G4VUserPhysicsList()
57 : G4VUserPhysicsList(), fBiasWorldName(paral <<
58 { 52 {
59 fParaWorldName.clear(); <<
60 SetVerboseLevel(1); 53 SetVerboseLevel(1);
61 } 54 }
62 55
63 //....oooOO0OOooo........oooOO0OOooo........oo <<
64 <<
65 B03PhysicsList::~B03PhysicsList() 56 B03PhysicsList::~B03PhysicsList()
66 { 57 {
67 fParaWorldName.clear(); <<
68 } 58 }
69 59
70 //....oooOO0OOooo........oooOO0OOooo........oo <<
71 <<
72 void B03PhysicsList::ConstructParticle() 60 void B03PhysicsList::ConstructParticle()
73 { 61 {
74 // In this method, static member functions s 62 // In this method, static member functions should be called
75 // for all particles which you want to use. 63 // for all particles which you want to use.
76 // This ensures that objects of these partic 64 // This ensures that objects of these particle types will be
77 // created in the program. << 65 // created in the program.
78 66
79 ConstructAllBosons(); 67 ConstructAllBosons();
80 ConstructAllLeptons(); 68 ConstructAllLeptons();
81 ConstructAllMesons(); 69 ConstructAllMesons();
82 ConstructAllBaryons(); 70 ConstructAllBaryons();
83 ConstructAllIons(); 71 ConstructAllIons();
84 ConstructAllShortLiveds(); 72 ConstructAllShortLiveds();
85 } 73 }
86 74
87 //....oooOO0OOooo........oooOO0OOooo........oo <<
88 <<
89 void B03PhysicsList::ConstructAllBosons() 75 void B03PhysicsList::ConstructAllBosons()
90 { 76 {
91 // Construct all bosons 77 // Construct all bosons
92 G4BosonConstructor pConstructor; 78 G4BosonConstructor pConstructor;
93 pConstructor.ConstructParticle(); 79 pConstructor.ConstructParticle();
94 } 80 }
95 81
96 //....oooOO0OOooo........oooOO0OOooo........oo <<
97 <<
98 void B03PhysicsList::ConstructAllLeptons() 82 void B03PhysicsList::ConstructAllLeptons()
99 { 83 {
100 // Construct all leptons 84 // Construct all leptons
101 G4LeptonConstructor pConstructor; 85 G4LeptonConstructor pConstructor;
102 pConstructor.ConstructParticle(); 86 pConstructor.ConstructParticle();
103 } 87 }
104 88
105 //....oooOO0OOooo........oooOO0OOooo........oo <<
106 <<
107 void B03PhysicsList::ConstructAllMesons() 89 void B03PhysicsList::ConstructAllMesons()
108 { 90 {
109 // Construct all mesons 91 // Construct all mesons
110 G4MesonConstructor pConstructor; 92 G4MesonConstructor pConstructor;
111 pConstructor.ConstructParticle(); 93 pConstructor.ConstructParticle();
112 } 94 }
113 95
114 //....oooOO0OOooo........oooOO0OOooo........oo <<
115 <<
116 void B03PhysicsList::ConstructAllBaryons() 96 void B03PhysicsList::ConstructAllBaryons()
117 { 97 {
118 // Construct all barions 98 // Construct all barions
119 G4BaryonConstructor pConstructor; 99 G4BaryonConstructor pConstructor;
120 pConstructor.ConstructParticle(); 100 pConstructor.ConstructParticle();
121 } 101 }
122 102
123 //....oooOO0OOooo........oooOO0OOooo........oo <<
124 <<
125 void B03PhysicsList::ConstructAllIons() 103 void B03PhysicsList::ConstructAllIons()
126 { 104 {
127 // Construct light ions 105 // Construct light ions
128 G4IonConstructor pConstructor; 106 G4IonConstructor pConstructor;
129 pConstructor.ConstructParticle(); << 107 pConstructor.ConstructParticle();
130 } 108 }
131 109
132 //....oooOO0OOooo........oooOO0OOooo........oo <<
133 <<
134 void B03PhysicsList::ConstructAllShortLiveds() 110 void B03PhysicsList::ConstructAllShortLiveds()
135 { 111 {
136 // Construct resonaces and quarks 112 // Construct resonaces and quarks
137 G4ShortLivedConstructor pConstructor; 113 G4ShortLivedConstructor pConstructor;
138 pConstructor.ConstructParticle(); << 114 pConstructor.ConstructParticle();
139 } 115 }
140 116
141 //....oooOO0OOooo........oooOO0OOooo........oo <<
142 <<
143 void B03PhysicsList::ConstructProcess() 117 void B03PhysicsList::ConstructProcess()
144 { 118 {
145 AddTransportation(); 119 AddTransportation();
146 AddScoringProcess(); <<
147 AddBiasingProcess(); <<
148 ConstructEM(); 120 ConstructEM();
149 ConstructLeptHad(); 121 ConstructLeptHad();
150 ConstructHad(); 122 ConstructHad();
151 ConstructGeneral(); 123 ConstructGeneral();
152 } 124 }
153 125
154 //....oooOO0OOooo........oooOO0OOooo........oo <<
155 <<
156 #include "G4ComptonScattering.hh" 126 #include "G4ComptonScattering.hh"
157 #include "G4GammaConversion.hh" 127 #include "G4GammaConversion.hh"
158 #include "G4MuBremsstrahlung.hh" <<
159 #include "G4MuIonisation.hh" <<
160 #include "G4MuMultipleScattering.hh" <<
161 #include "G4MuPairProduction.hh" <<
162 #include "G4PhotoElectricEffect.hh" 128 #include "G4PhotoElectricEffect.hh"
163 #include "G4eBremsstrahlung.hh" << 129
>> 130 #include "G4MultipleScattering.hh"
>> 131
164 #include "G4eIonisation.hh" 132 #include "G4eIonisation.hh"
165 #include "G4eMultipleScattering.hh" << 133 #include "G4eBremsstrahlung.hh"
166 #include "G4eplusAnnihilation.hh" 134 #include "G4eplusAnnihilation.hh"
>> 135
>> 136 #include "G4MuIonisation.hh"
>> 137 #include "G4MuBremsstrahlung.hh"
>> 138 #include "G4MuPairProduction.hh"
>> 139
167 #include "G4hIonisation.hh" 140 #include "G4hIonisation.hh"
168 #include "G4hMultipleScattering.hh" <<
169 141
170 void B03PhysicsList::ConstructEM() 142 void B03PhysicsList::ConstructEM()
171 { 143 {
172 auto particleIterator = GetParticleIterator( << 144 theParticleIterator->reset();
173 particleIterator->reset(); << 145 while( (*theParticleIterator)() ){
174 while ((*particleIterator)()) { << 146 G4ParticleDefinition* particle = theParticleIterator->value();
175 G4ParticleDefinition* particle = particleI <<
176 G4ProcessManager* pmanager = particle->Get 147 G4ProcessManager* pmanager = particle->GetProcessManager();
177 G4String particleName = particle->GetParti 148 G4String particleName = particle->GetParticleName();
178 << 149
179 if (particleName == "gamma") { 150 if (particleName == "gamma") {
180 // gamma << 151 // gamma
181 // Construct processes for gamma 152 // Construct processes for gamma
182 pmanager->AddDiscreteProcess(new G4Gamma 153 pmanager->AddDiscreteProcess(new G4GammaConversion());
183 pmanager->AddDiscreteProcess(new G4Compt << 154 pmanager->AddDiscreteProcess(new G4ComptonScattering());
184 pmanager->AddDiscreteProcess(new G4Photo 155 pmanager->AddDiscreteProcess(new G4PhotoElectricEffect());
185 } << 156
186 else if (particleName == "e-") { << 157 } else if (particleName == "e-") {
187 // electron << 158 //electron
188 // Construct processes for electron << 159 // Construct processes for electron
189 pmanager->AddProcess(new G4eMultipleScat << 160 pmanager->AddProcess(new G4MultipleScattering(),-1,1,1);
190 pmanager->AddProcess(new G4eIonisation() << 161 pmanager->AddProcess(new G4eIonisation(),-1,2,2);
191 pmanager->AddProcess(new G4eBremsstrahlu << 162 pmanager->AddProcess(new G4eBremsstrahlung(),-1,-1,3);
192 } << 163
193 else if (particleName == "e+") { << 164 } else if (particleName == "e+") {
194 // positron << 165 //positron
195 // Construct processes for positron << 166 // Construct processes for positron
196 pmanager->AddProcess(new G4eMultipleScat << 167 pmanager->AddProcess(new G4MultipleScattering(),-1,1,1);
197 << 168
198 pmanager->AddProcess(new G4eIonisation() << 169 pmanager->AddProcess(new G4eIonisation(),-1,2,2);
199 pmanager->AddProcess(new G4eBremsstrahlu << 170 pmanager->AddProcess(new G4eBremsstrahlung(),-1,-1,3);
200 pmanager->AddProcess(new G4eplusAnnihila << 171 pmanager->AddProcess(new G4eplusAnnihilation(),0,-1,4);
201 } << 172
202 else if (particleName == "mu+" || particle << 173 } else if( particleName == "mu+" ||
203 // muon << 174 particleName == "mu-" ) {
204 // Construct processes for muon+ << 175 //muon
205 pmanager->AddProcess(new G4MuMultipleSca << 176 // Construct processes for muon+
206 pmanager->AddProcess(new G4MuIonisation( << 177 pmanager->AddProcess(new G4MultipleScattering(),-1,1,1);
207 pmanager->AddProcess(new G4MuBremsstrahl << 178 pmanager->AddProcess(new G4MuIonisation(),-1,2,2);
208 pmanager->AddProcess(new G4MuPairProduct << 179 pmanager->AddProcess(new G4MuBremsstrahlung(),-1,-1,3);
209 } << 180 pmanager->AddProcess(new G4MuPairProduction(),-1,-1,4);
210 else if (particleName == "GenericIon") { << 181
211 pmanager->AddProcess(new G4hMultipleScat << 182 } else if( particleName == "GenericIon" ) {
212 pmanager->AddProcess(new G4hIonisation() << 183 pmanager->AddProcess(new G4MultipleScattering(),-1,1,1);
213 } << 184 pmanager->AddProcess(new G4hIonisation(),-1,2,2);
214 else { << 185 } else {
215 if ((particle->GetPDGCharge() != 0.0) && << 186 if ((particle->GetPDGCharge() != 0.0) &&
216 && (!particle->IsShortLived())) << 187 (particle->GetParticleName() != "chargedgeantino")&&
217 { << 188 (!particle->IsShortLived()) ) {
218 // all others charged particles except << 189 // all others charged particles except geantino
219 pmanager->AddProcess(new G4hMultipleSc << 190 pmanager->AddProcess(new G4MultipleScattering(),-1,1,1);
220 pmanager->AddProcess(new G4hIonisation << 191 pmanager->AddProcess(new G4hIonisation(),-1,2,2);
221 } << 192 }
222 } 193 }
223 } 194 }
224 } 195 }
225 196
226 //....oooOO0OOooo........oooOO0OOooo........oo <<
227 <<
228 // Hadron Processes 197 // Hadron Processes
229 198
230 #include "G4HadronElasticProcess.hh" 199 #include "G4HadronElasticProcess.hh"
231 #include "G4HadronInelasticProcess.hh" << 200 #include "G4HadronFissionProcess.hh"
232 #include "G4NeutronCaptureProcess.hh" << 201 #include "G4HadronCaptureProcess.hh"
233 #include "G4NeutronFissionProcess.hh" << 202
>> 203 #include "G4PionPlusInelasticProcess.hh"
>> 204 #include "G4PionMinusInelasticProcess.hh"
>> 205 #include "G4KaonPlusInelasticProcess.hh"
>> 206 #include "G4KaonZeroSInelasticProcess.hh"
>> 207 #include "G4KaonZeroLInelasticProcess.hh"
>> 208 #include "G4KaonMinusInelasticProcess.hh"
>> 209 #include "G4ProtonInelasticProcess.hh"
>> 210 #include "G4AntiProtonInelasticProcess.hh"
>> 211 #include "G4NeutronInelasticProcess.hh"
>> 212 #include "G4AntiNeutronInelasticProcess.hh"
>> 213 #include "G4LambdaInelasticProcess.hh"
>> 214 #include "G4AntiLambdaInelasticProcess.hh"
>> 215 #include "G4SigmaPlusInelasticProcess.hh"
>> 216 #include "G4SigmaMinusInelasticProcess.hh"
>> 217 #include "G4AntiSigmaPlusInelasticProcess.hh"
>> 218 #include "G4AntiSigmaMinusInelasticProcess.hh"
>> 219 #include "G4XiZeroInelasticProcess.hh"
>> 220 #include "G4XiMinusInelasticProcess.hh"
>> 221 #include "G4AntiXiZeroInelasticProcess.hh"
>> 222 #include "G4AntiXiMinusInelasticProcess.hh"
>> 223 #include "G4DeuteronInelasticProcess.hh"
>> 224 #include "G4TritonInelasticProcess.hh"
>> 225 #include "G4AlphaInelasticProcess.hh"
>> 226 #include "G4OmegaMinusInelasticProcess.hh"
>> 227 #include "G4AntiOmegaMinusInelasticProcess.hh"
234 228
235 // Low-energy Models 229 // Low-energy Models
236 230
237 #include "G4HadronElastic.hh" << 231 #include "G4LElastic.hh"
238 #include "G4LFission.hh" 232 #include "G4LFission.hh"
239 #include "G4NeutronRadCapture.hh" << 233 #include "G4LCapture.hh"
>> 234
>> 235 #include "G4LEPionPlusInelastic.hh"
>> 236 #include "G4LEPionMinusInelastic.hh"
>> 237 #include "G4LEKaonPlusInelastic.hh"
>> 238 #include "G4LEKaonZeroSInelastic.hh"
>> 239 #include "G4LEKaonZeroLInelastic.hh"
>> 240 #include "G4LEKaonMinusInelastic.hh"
>> 241 #include "G4LEProtonInelastic.hh"
>> 242 #include "G4LEAntiProtonInelastic.hh"
>> 243 #include "G4LENeutronInelastic.hh"
>> 244 #include "G4LEAntiNeutronInelastic.hh"
>> 245 #include "G4LELambdaInelastic.hh"
>> 246 #include "G4LEAntiLambdaInelastic.hh"
>> 247 #include "G4LESigmaPlusInelastic.hh"
>> 248 #include "G4LESigmaMinusInelastic.hh"
>> 249 #include "G4LEAntiSigmaPlusInelastic.hh"
>> 250 #include "G4LEAntiSigmaMinusInelastic.hh"
>> 251 #include "G4LEXiZeroInelastic.hh"
>> 252 #include "G4LEXiMinusInelastic.hh"
>> 253 #include "G4LEAntiXiZeroInelastic.hh"
>> 254 #include "G4LEAntiXiMinusInelastic.hh"
>> 255 #include "G4LEDeuteronInelastic.hh"
>> 256 #include "G4LETritonInelastic.hh"
>> 257 #include "G4LEAlphaInelastic.hh"
>> 258 #include "G4LEOmegaMinusInelastic.hh"
>> 259 #include "G4LEAntiOmegaMinusInelastic.hh"
240 260
241 // -- generator models 261 // -- generator models
242 #include "G4BinaryLightIonReaction.hh" << 262 #include "G4TheoFSGenerator.hh"
243 #include "G4CascadeInterface.hh" <<
244 #include "G4CompetitiveFission.hh" <<
245 #include "G4ExcitationHandler.hh" 263 #include "G4ExcitationHandler.hh"
246 #include "G4ExcitedStringDecay.hh" << 264 #include "G4Evaporation.hh"
247 #include "G4FTFModel.hh" << 265 #include "G4CompetitiveFission.hh"
248 #include "G4Fancy3DNucleus.hh" << 266 #include "G4FermiBreakUp.hh"
>> 267 #include "G4StatMF.hh"
249 #include "G4GeneratorPrecompoundInterface.hh" 268 #include "G4GeneratorPrecompoundInterface.hh"
250 #include "G4LundStringFragmentation.hh" << 269 #include "G4Fancy3DNucleus.hh"
>> 270 #include "G4LEProtonInelastic.hh"
>> 271 #include "G4StringModel.hh"
251 #include "G4PreCompoundModel.hh" 272 #include "G4PreCompoundModel.hh"
>> 273 #include "G4FTFModel.hh"
252 #include "G4QGSMFragmentation.hh" 274 #include "G4QGSMFragmentation.hh"
253 #include "G4QMDReaction.hh" << 275 #include "G4ExcitedStringDecay.hh"
254 #include "G4StringModel.hh" <<
255 #include "G4TheoFSGenerator.hh" <<
256 <<
257 // Cross sections <<
258 #include "G4ComponentGGHadronNucleusXsc.hh" <<
259 #include "G4ComponentGGNuclNuclXsc.hh" <<
260 #include "G4CrossSectionElastic.hh" <<
261 #include "G4CrossSectionInelastic.hh" <<
262 #include "G4NeutronInelasticXS.hh" <<
263 276
264 // 277 //
265 // ConstructHad() 278 // ConstructHad()
266 // 279 //
267 // Makes discrete physics processes for the ha << 280 // Makes discrete physics processes for the hadrons, at present limited
>> 281 // to those particles with GHEISHA interactions (INTRC > 0).
268 // The processes are: Elastic scattering, Inel 282 // The processes are: Elastic scattering, Inelastic scattering,
269 // Fission (for neutron only), and Capture (ne 283 // Fission (for neutron only), and Capture (neutron).
270 // 284 //
>> 285 // F.W.Jones 06-JUL-1998
>> 286 //
271 287
272 void B03PhysicsList::ConstructHad() 288 void B03PhysicsList::ConstructHad()
273 { 289 {
274 // this will be the model class for high ene << 290 // this will be the model class for high energies
275 G4TheoFSGenerator* theTheoModel = new G4Theo << 291 G4TheoFSGenerator * theTheoModel = new G4TheoFSGenerator;
276 G4TheoFSGenerator* antiBHighEnergyModel = ne << 292
277 << 293 // all models for treatment of thermal nucleus
278 // Evaporation logic << 294 G4Evaporation * theEvaporation = new G4Evaporation;
279 G4ExcitationHandler* theHandler = new G4Exci << 295 G4FermiBreakUp * theFermiBreakUp = new G4FermiBreakUp;
280 theHandler->SetMinEForMultiFrag(3 * MeV); << 296 G4StatMF * theMF = new G4StatMF;
281 << 297
282 // Pre equilibrium stage << 298 // Evaporation logic
283 G4PreCompoundModel* thePreEquilib = new G4Pr << 299 G4ExcitationHandler * theHandler = new G4ExcitationHandler;
284 << 300 theHandler->SetEvaporation(theEvaporation);
285 // a no-cascade generator-precompound intera << 301 theHandler->SetFermiModel(theFermiBreakUp);
286 G4GeneratorPrecompoundInterface* theCascade << 302 theHandler->SetMultiFragmentation(theMF);
287 theCascade->SetDeExcitation(thePreEquilib); << 303 theHandler->SetMaxAandZForFermiBreakUp(12, 6);
288 << 304 theHandler->SetMinEForMultiFrag(3*MeV);
289 // Bertini cascade << 305
290 G4CascadeInterface* bertini = new G4CascadeI << 306 // Pre equilibrium stage
291 bertini->SetMaxEnergy(22 * MeV); << 307 G4PreCompoundModel * thePreEquilib = new G4PreCompoundModel(theHandler);
292 << 308
293 // here come the high energy parts << 309
294 G4VPartonStringModel* theStringModel; << 310 // a no-cascade generator-precompound interaface
295 theStringModel = new G4FTFModel; << 311 G4GeneratorPrecompoundInterface * theCascade = new G4GeneratorPrecompoundInterface;
296 theTheoModel->SetTransport(theCascade); << 312 theCascade->SetDeExcitation(thePreEquilib);
297 theTheoModel->SetHighEnergyGenerator(theStri << 313
298 theTheoModel->SetMinEnergy(19 * GeV); << 314 // here come the high energy parts
299 theTheoModel->SetMaxEnergy(G4HadronicParamet << 315 // the string model; still not quite according to design - Explicite use of the forseen interfaces
300 << 316 // will be tested and documented in this program by beta-02 at latest.
301 G4VLongitudinalStringDecay* theFragmentation << 317 G4VPartonStringModel * theStringModel;
302 G4ExcitedStringDecay* theStringDecay = new G << 318 theStringModel = new G4FTFModel;
303 theStringModel->SetFragmentationModel(theStr << 319 theTheoModel->SetTransport(theCascade);
304 << 320 theTheoModel->SetHighEnergyGenerator(theStringModel);
305 // high energy model for anti-baryons << 321 theTheoModel->SetMinEnergy(19*GeV);
306 antiBHighEnergyModel = new G4TheoFSGenerator << 322 theTheoModel->SetMaxEnergy(100*TeV);
307 G4FTFModel* antiBStringModel = new G4FTFMode << 323
308 G4ExcitedStringDecay* stringDecay = new G4Ex << 324 G4VLongitudinalStringDecay * theFragmentation = new G4QGSMFragmentation;
309 antiBStringModel->SetFragmentationModel(stri << 325 G4ExcitedStringDecay * theStringDecay = new G4ExcitedStringDecay(theFragmentation);
310 << 326 theStringModel->SetFragmentationModel(theStringDecay);
311 G4GeneratorPrecompoundInterface* antiBCascad << 327
312 G4PreCompoundModel* preEquilib = new G4PreCo << 328 // done with the generator model (most of the above is also available as default)
313 antiBCascade->SetDeExcitation(preEquilib); << 329 G4HadronElasticProcess* theElasticProcess =
314 << 330 new G4HadronElasticProcess;
315 antiBHighEnergyModel->SetTransport(antiBCasc << 331 G4LElastic* theElasticModel = new G4LElastic;
316 antiBHighEnergyModel->SetHighEnergyGenerator << 332 theElasticProcess->RegisterMe(theElasticModel);
317 antiBHighEnergyModel->SetMinEnergy(0.0); << 333 G4HadronElasticProcess* theElasticProcess1 =
318 antiBHighEnergyModel->SetMaxEnergy(20 * TeV) << 334 new G4HadronElasticProcess;
319 << 335 theParticleIterator->reset();
320 // Light ion models << 336 while ((*theParticleIterator)()) {
321 G4BinaryLightIonReaction* binaryCascade = ne << 337 G4ParticleDefinition* particle = theParticleIterator->value();
322 binaryCascade->SetMinEnergy(0.0); << 338 G4ProcessManager* pmanager = particle->GetProcessManager();
323 binaryCascade->SetMaxEnergy(110 * MeV); << 339 G4String particleName = particle->GetParticleName();
324 << 340
325 G4QMDReaction* qmd = new G4QMDReaction; << 341 if (particleName == "pi+") {
326 qmd->SetMinEnergy(100 * MeV); << 342 pmanager->AddDiscreteProcess(theElasticProcess);
327 qmd->SetMaxEnergy(10 * GeV); << 343 G4PionPlusInelasticProcess* theInelasticProcess =
328 << 344 new G4PionPlusInelasticProcess("inelastic");
329 G4VCrossSectionDataSet* ionXS = new G4CrossS << 345 G4LEPionPlusInelastic* theInelasticModel =
330 << 346 new G4LEPionPlusInelastic;
331 G4ComponentGGHadronNucleusXsc* ggHNXsec = ne << 347 theInelasticProcess->RegisterMe(theInelasticModel);
332 G4VCrossSectionDataSet* theGGHNEl = new G4Cr << 348 theInelasticProcess->RegisterMe(theTheoModel);
333 G4VCrossSectionDataSet* theGGHNInel = new G4 << 349 pmanager->AddDiscreteProcess(theInelasticProcess);
334 << 350 }
335 // Elastic process << 351 else if (particleName == "pi-") {
336 G4HadronElasticProcess* theElasticProcess = << 352 pmanager->AddDiscreteProcess(theElasticProcess);
337 theElasticProcess->AddDataSet(theGGHNEl); << 353 G4PionMinusInelasticProcess* theInelasticProcess =
338 G4HadronElastic* theElasticModel = new G4Had << 354 new G4PionMinusInelasticProcess("inelastic");
339 theElasticProcess->RegisterMe(theElasticMode << 355 G4LEPionMinusInelastic* theInelasticModel =
340 << 356 new G4LEPionMinusInelastic;
341 auto particleIterator = GetParticleIterator( << 357 theInelasticProcess->RegisterMe(theInelasticModel);
342 particleIterator->reset(); << 358 theInelasticProcess->RegisterMe(theTheoModel);
343 while ((*particleIterator)()) { << 359 pmanager->AddDiscreteProcess(theInelasticProcess);
344 G4ParticleDefinition* particle = particleI << 360 }
345 G4ProcessManager* pmanager = particle->Get << 361 else if (particleName == "kaon+") {
346 G4String particleName = particle->GetParti << 362 pmanager->AddDiscreteProcess(theElasticProcess);
347 << 363 G4KaonPlusInelasticProcess* theInelasticProcess =
348 if (particleName == "pi+") { << 364 new G4KaonPlusInelasticProcess("inelastic");
349 pmanager->AddDiscreteProcess(theElasticP << 365 G4LEKaonPlusInelastic* theInelasticModel = new G4LEKaonPlusInelastic;
350 G4HadronInelasticProcess* theInelasticPr << 366 theInelasticProcess->RegisterMe(theInelasticModel);
351 new G4HadronInelasticProcess("inelasti << 367 theInelasticProcess->RegisterMe(theTheoModel);
352 theInelasticProcess->AddDataSet(theGGHNI << 368 pmanager->AddDiscreteProcess(theInelasticProcess);
353 theInelasticProcess->RegisterMe(bertini) << 369 }
354 theInelasticProcess->RegisterMe(theTheoM << 370 else if (particleName == "kaon0S") {
355 pmanager->AddDiscreteProcess(theInelasti << 371 pmanager->AddDiscreteProcess(theElasticProcess);
356 } << 372 G4KaonZeroSInelasticProcess* theInelasticProcess =
357 else if (particleName == "pi-") { << 373 new G4KaonZeroSInelasticProcess("inelastic");
358 pmanager->AddDiscreteProcess(theElasticP << 374 G4LEKaonZeroSInelastic* theInelasticModel =
359 G4HadronInelasticProcess* theInelasticPr << 375 new G4LEKaonZeroSInelastic;
360 new G4HadronInelasticProcess("inelasti << 376 theInelasticProcess->RegisterMe(theInelasticModel);
361 theInelasticProcess->AddDataSet(theGGHNI << 377 theInelasticProcess->RegisterMe(theTheoModel);
362 theInelasticProcess->RegisterMe(bertini) << 378 pmanager->AddDiscreteProcess(theInelasticProcess);
363 theInelasticProcess->RegisterMe(theTheoM << 379 }
364 pmanager->AddDiscreteProcess(theInelasti << 380 else if (particleName == "kaon0L") {
365 } << 381 pmanager->AddDiscreteProcess(theElasticProcess);
366 else if (particleName == "kaon+") { << 382 G4KaonZeroLInelasticProcess* theInelasticProcess =
367 pmanager->AddDiscreteProcess(theElasticP << 383 new G4KaonZeroLInelasticProcess("inelastic");
368 G4HadronInelasticProcess* theInelasticPr << 384 G4LEKaonZeroLInelastic* theInelasticModel =
369 new G4HadronInelasticProcess("inelasti << 385 new G4LEKaonZeroLInelastic;
370 theInelasticProcess->AddDataSet(theGGHNI << 386 theInelasticProcess->RegisterMe(theInelasticModel);
371 theInelasticProcess->RegisterMe(bertini) << 387 theInelasticProcess->RegisterMe(theTheoModel);
372 theInelasticProcess->RegisterMe(theTheoM << 388 pmanager->AddDiscreteProcess(theInelasticProcess);
373 pmanager->AddDiscreteProcess(theInelasti << 389 }
374 } << 390 else if (particleName == "kaon-") {
375 else if (particleName == "kaon0S") { << 391 pmanager->AddDiscreteProcess(theElasticProcess);
376 pmanager->AddDiscreteProcess(theElasticP << 392 G4KaonMinusInelasticProcess* theInelasticProcess =
377 G4HadronInelasticProcess* theInelasticPr << 393 new G4KaonMinusInelasticProcess("inelastic");
378 new G4HadronInelasticProcess("inelasti << 394 G4LEKaonMinusInelastic* theInelasticModel =
379 theInelasticProcess->AddDataSet(theGGHNI << 395 new G4LEKaonMinusInelastic;
380 theInelasticProcess->RegisterMe(bertini) << 396 theInelasticProcess->RegisterMe(theInelasticModel);
381 theInelasticProcess->RegisterMe(theTheoM << 397 theInelasticProcess->RegisterMe(theTheoModel);
382 pmanager->AddDiscreteProcess(theInelasti << 398 pmanager->AddDiscreteProcess(theInelasticProcess);
383 } << 399 }
384 else if (particleName == "kaon0L") { << 400 else if (particleName == "proton") {
385 pmanager->AddDiscreteProcess(theElasticP << 401 pmanager->AddDiscreteProcess(theElasticProcess);
386 G4HadronInelasticProcess* theInelasticPr << 402 G4ProtonInelasticProcess* theInelasticProcess =
387 new G4HadronInelasticProcess("inelasti << 403 new G4ProtonInelasticProcess("inelastic");
388 theInelasticProcess->AddDataSet(theGGHNI << 404 G4LEProtonInelastic* theInelasticModel = new G4LEProtonInelastic;
389 theInelasticProcess->RegisterMe(bertini) << 405 theInelasticProcess->RegisterMe(theInelasticModel);
390 theInelasticProcess->RegisterMe(theTheoM << 406 theInelasticProcess->RegisterMe(theTheoModel);
391 pmanager->AddDiscreteProcess(theInelasti << 407 pmanager->AddDiscreteProcess(theInelasticProcess);
392 } << 408 }
393 else if (particleName == "kaon-") { << 409 else if (particleName == "anti_proton") {
394 pmanager->AddDiscreteProcess(theElasticP << 410 pmanager->AddDiscreteProcess(theElasticProcess);
395 G4HadronInelasticProcess* theInelasticPr << 411 G4AntiProtonInelasticProcess* theInelasticProcess =
396 new G4HadronInelasticProcess("inelasti << 412 new G4AntiProtonInelasticProcess("inelastic");
397 theInelasticProcess->AddDataSet(theGGHNI << 413 G4LEAntiProtonInelastic* theInelasticModel =
398 theInelasticProcess->RegisterMe(bertini) << 414 new G4LEAntiProtonInelastic;
399 theInelasticProcess->RegisterMe(theTheoM << 415 theInelasticProcess->RegisterMe(theInelasticModel);
400 pmanager->AddDiscreteProcess(theInelasti << 416 theInelasticProcess->RegisterMe(theTheoModel);
401 } << 417 pmanager->AddDiscreteProcess(theInelasticProcess);
402 else if (particleName == "proton") { << 418 }
403 pmanager->AddDiscreteProcess(theElasticP << 419 else if (particleName == "neutron") {
404 G4HadronInelasticProcess* theInelasticPr << 420
405 new G4HadronInelasticProcess("inelasti << 421 // elastic scattering
406 theInelasticProcess->AddDataSet(theGGHNI << 422 G4LElastic* theElasticModel1 = new G4LElastic;
407 theInelasticProcess->RegisterMe(bertini) << 423 theElasticProcess1->RegisterMe(theElasticModel1);
408 theInelasticProcess->RegisterMe(theTheoM << 424 pmanager->AddDiscreteProcess(theElasticProcess1);
409 pmanager->AddDiscreteProcess(theInelasti << 425 // inelastic scattering
410 } << 426 G4NeutronInelasticProcess* theInelasticProcess =
411 else if (particleName == "anti_proton") { << 427 new G4NeutronInelasticProcess("inelastic");
412 pmanager->AddDiscreteProcess(theElasticP << 428 G4LENeutronInelastic* theInelasticModel = new G4LENeutronInelastic;
413 G4HadronInelasticProcess* theInelasticPr << 429 theInelasticProcess->RegisterMe(theInelasticModel);
414 new G4HadronInelasticProcess("inelasti << 430 theInelasticProcess->RegisterMe(theTheoModel);
415 theInelasticProcess->AddDataSet(theGGHNI << 431 pmanager->AddDiscreteProcess(theInelasticProcess);
416 theInelasticProcess->RegisterMe(antiBHig << 432 // fission
417 pmanager->AddDiscreteProcess(theInelasti << 433 G4HadronFissionProcess* theFissionProcess =
418 } << 434 new G4HadronFissionProcess;
419 else if (particleName == "neutron") { << 435 G4LFission* theFissionModel = new G4LFission;
420 // elastic scattering << 436 theFissionProcess->RegisterMe(theFissionModel);
421 pmanager->AddDiscreteProcess(theElasticP << 437 pmanager->AddDiscreteProcess(theFissionProcess);
422 << 438 // capture
423 // inelastic scattering << 439 G4HadronCaptureProcess* theCaptureProcess =
424 G4HadronInelasticProcess* theInelasticPr << 440 new G4HadronCaptureProcess;
425 new G4HadronInelasticProcess("inelasti << 441 G4LCapture* theCaptureModel = new G4LCapture;
426 theInelasticProcess->AddDataSet(new G4Ne << 442 theCaptureProcess->RegisterMe(theCaptureModel);
427 theInelasticProcess->RegisterMe(bertini) << 443 pmanager->AddDiscreteProcess(theCaptureProcess);
428 theInelasticProcess->RegisterMe(theTheoM << 444 }
429 pmanager->AddDiscreteProcess(theInelasti << 445 else if (particleName == "anti_neutron") {
430 << 446 pmanager->AddDiscreteProcess(theElasticProcess);
431 // fission << 447 G4AntiNeutronInelasticProcess* theInelasticProcess =
432 G4NeutronFissionProcess* theFissionProce << 448 new G4AntiNeutronInelasticProcess("inelastic");
433 G4LFission* theFissionModel = new G4LFis << 449 G4LEAntiNeutronInelastic* theInelasticModel =
434 theFissionProcess->RegisterMe(theFission << 450 new G4LEAntiNeutronInelastic;
435 pmanager->AddDiscreteProcess(theFissionP << 451 theInelasticProcess->RegisterMe(theInelasticModel);
436 << 452 theInelasticProcess->RegisterMe(theTheoModel);
437 // capture << 453 pmanager->AddDiscreteProcess(theInelasticProcess);
438 G4NeutronCaptureProcess* theCaptureProce << 454 }
439 G4NeutronRadCapture* theCaptureModel = n << 455 else if (particleName == "lambda") {
440 theCaptureProcess->RegisterMe(theCapture << 456 pmanager->AddDiscreteProcess(theElasticProcess);
441 pmanager->AddDiscreteProcess(theCaptureP << 457 G4LambdaInelasticProcess* theInelasticProcess =
442 } << 458 new G4LambdaInelasticProcess("inelastic");
443 else if (particleName == "anti_neutron") { << 459 G4LELambdaInelastic* theInelasticModel = new G4LELambdaInelastic;
444 pmanager->AddDiscreteProcess(theElasticP << 460 theInelasticProcess->RegisterMe(theInelasticModel);
445 G4HadronInelasticProcess* theInelasticPr << 461 theInelasticProcess->RegisterMe(theTheoModel);
446 new G4HadronInelasticProcess("inelasti << 462 pmanager->AddDiscreteProcess(theInelasticProcess);
447 theInelasticProcess->AddDataSet(theGGHNI << 463 }
448 theInelasticProcess->RegisterMe(antiBHig << 464 else if (particleName == "anti_lambda") {
449 pmanager->AddDiscreteProcess(theInelasti << 465 pmanager->AddDiscreteProcess(theElasticProcess);
450 } << 466 G4AntiLambdaInelasticProcess* theInelasticProcess =
451 else if (particleName == "lambda") { << 467 new G4AntiLambdaInelasticProcess("inelastic");
452 pmanager->AddDiscreteProcess(theElasticP << 468 G4LEAntiLambdaInelastic* theInelasticModel =
453 G4HadronInelasticProcess* theInelasticPr << 469 new G4LEAntiLambdaInelastic;
454 new G4HadronInelasticProcess("inelasti << 470 theInelasticProcess->RegisterMe(theInelasticModel);
455 theInelasticProcess->AddDataSet(theGGHNI << 471 theInelasticProcess->RegisterMe(theTheoModel);
456 theInelasticProcess->RegisterMe(bertini) << 472 pmanager->AddDiscreteProcess(theInelasticProcess);
457 theInelasticProcess->RegisterMe(theTheoM << 473 }
458 pmanager->AddDiscreteProcess(theInelasti << 474 else if (particleName == "sigma+") {
459 } << 475 pmanager->AddDiscreteProcess(theElasticProcess);
460 else if (particleName == "anti_lambda") { << 476 G4SigmaPlusInelasticProcess* theInelasticProcess =
461 pmanager->AddDiscreteProcess(theElasticP << 477 new G4SigmaPlusInelasticProcess("inelastic");
462 G4HadronInelasticProcess* theInelasticPr << 478 G4LESigmaPlusInelastic* theInelasticModel =
463 new G4HadronInelasticProcess("inelasti << 479 new G4LESigmaPlusInelastic;
464 theInelasticProcess->AddDataSet(theGGHNI << 480 theInelasticProcess->RegisterMe(theInelasticModel);
465 theInelasticProcess->RegisterMe(antiBHig << 481 theInelasticProcess->RegisterMe(theTheoModel);
466 pmanager->AddDiscreteProcess(theInelasti << 482 pmanager->AddDiscreteProcess(theInelasticProcess);
467 } << 483 }
468 else if (particleName == "sigma+") { << 484 else if (particleName == "sigma-") {
469 pmanager->AddDiscreteProcess(theElasticP << 485 pmanager->AddDiscreteProcess(theElasticProcess);
470 G4HadronInelasticProcess* theInelasticPr << 486 G4SigmaMinusInelasticProcess* theInelasticProcess =
471 new G4HadronInelasticProcess("inelasti << 487 new G4SigmaMinusInelasticProcess("inelastic");
472 theInelasticProcess->AddDataSet(theGGHNI << 488 G4LESigmaMinusInelastic* theInelasticModel =
473 theInelasticProcess->RegisterMe(bertini) << 489 new G4LESigmaMinusInelastic;
474 theInelasticProcess->RegisterMe(theTheoM << 490 theInelasticProcess->RegisterMe(theInelasticModel);
475 pmanager->AddDiscreteProcess(theInelasti << 491 theInelasticProcess->RegisterMe(theTheoModel);
476 } << 492 pmanager->AddDiscreteProcess(theInelasticProcess);
477 else if (particleName == "sigma-") { << 493 }
478 pmanager->AddDiscreteProcess(theElasticP << 494 else if (particleName == "anti_sigma+") {
479 G4HadronInelasticProcess* theInelasticPr << 495 pmanager->AddDiscreteProcess(theElasticProcess);
480 new G4HadronInelasticProcess("inelasti << 496 G4AntiSigmaPlusInelasticProcess* theInelasticProcess =
481 theInelasticProcess->AddDataSet(theGGHNI << 497 new G4AntiSigmaPlusInelasticProcess("inelastic");
482 theInelasticProcess->RegisterMe(bertini) << 498 G4LEAntiSigmaPlusInelastic* theInelasticModel =
483 theInelasticProcess->RegisterMe(theTheoM << 499 new G4LEAntiSigmaPlusInelastic;
484 pmanager->AddDiscreteProcess(theInelasti << 500 theInelasticProcess->RegisterMe(theInelasticModel);
485 } << 501 theInelasticProcess->RegisterMe(theTheoModel);
486 else if (particleName == "anti_sigma+") { << 502 pmanager->AddDiscreteProcess(theInelasticProcess);
487 pmanager->AddDiscreteProcess(theElasticP << 503 }
488 G4HadronInelasticProcess* theInelasticPr << 504 else if (particleName == "anti_sigma-") {
489 new G4HadronInelasticProcess("inelasti << 505 pmanager->AddDiscreteProcess(theElasticProcess);
490 theInelasticProcess->AddDataSet(theGGHNI << 506 G4AntiSigmaMinusInelasticProcess* theInelasticProcess =
491 theInelasticProcess->RegisterMe(antiBHig << 507 new G4AntiSigmaMinusInelasticProcess("inelastic");
492 pmanager->AddDiscreteProcess(theInelasti << 508 G4LEAntiSigmaMinusInelastic* theInelasticModel =
493 } << 509 new G4LEAntiSigmaMinusInelastic;
494 else if (particleName == "anti_sigma-") { << 510 theInelasticProcess->RegisterMe(theInelasticModel);
495 pmanager->AddDiscreteProcess(theElasticP << 511 theInelasticProcess->RegisterMe(theTheoModel);
496 G4HadronInelasticProcess* theInelasticPr << 512 pmanager->AddDiscreteProcess(theInelasticProcess);
497 new G4HadronInelasticProcess("inelasti << 513 }
498 theInelasticProcess->AddDataSet(theGGHNI << 514 else if (particleName == "xi0") {
499 theInelasticProcess->RegisterMe(antiBHig << 515 pmanager->AddDiscreteProcess(theElasticProcess);
500 pmanager->AddDiscreteProcess(theInelasti << 516 G4XiZeroInelasticProcess* theInelasticProcess =
501 } << 517 new G4XiZeroInelasticProcess("inelastic");
502 else if (particleName == "xi0") { << 518 G4LEXiZeroInelastic* theInelasticModel =
503 pmanager->AddDiscreteProcess(theElasticP << 519 new G4LEXiZeroInelastic;
504 G4HadronInelasticProcess* theInelasticPr << 520 theInelasticProcess->RegisterMe(theInelasticModel);
505 new G4HadronInelasticProcess("inelasti << 521 theInelasticProcess->RegisterMe(theTheoModel);
506 theInelasticProcess->AddDataSet(theGGHNI << 522 pmanager->AddDiscreteProcess(theInelasticProcess);
507 theInelasticProcess->RegisterMe(bertini) << 523 }
508 theInelasticProcess->RegisterMe(theTheoM << 524 else if (particleName == "xi-") {
509 pmanager->AddDiscreteProcess(theInelasti << 525 pmanager->AddDiscreteProcess(theElasticProcess);
510 } << 526 G4XiMinusInelasticProcess* theInelasticProcess =
511 else if (particleName == "xi-") { << 527 new G4XiMinusInelasticProcess("inelastic");
512 pmanager->AddDiscreteProcess(theElasticP << 528 G4LEXiMinusInelastic* theInelasticModel =
513 G4HadronInelasticProcess* theInelasticPr << 529 new G4LEXiMinusInelastic;
514 new G4HadronInelasticProcess("inelasti << 530 theInelasticProcess->RegisterMe(theInelasticModel);
515 theInelasticProcess->AddDataSet(theGGHNI << 531 theInelasticProcess->RegisterMe(theTheoModel);
516 theInelasticProcess->RegisterMe(bertini) << 532 pmanager->AddDiscreteProcess(theInelasticProcess);
517 theInelasticProcess->RegisterMe(theTheoM << 533 }
518 pmanager->AddDiscreteProcess(theInelasti << 534 else if (particleName == "anti_xi0") {
519 } << 535 pmanager->AddDiscreteProcess(theElasticProcess);
520 else if (particleName == "anti_xi0") { << 536 G4AntiXiZeroInelasticProcess* theInelasticProcess =
521 pmanager->AddDiscreteProcess(theElasticP << 537 new G4AntiXiZeroInelasticProcess("inelastic");
522 G4HadronInelasticProcess* theInelasticPr << 538 G4LEAntiXiZeroInelastic* theInelasticModel =
523 new G4HadronInelasticProcess("inelasti << 539 new G4LEAntiXiZeroInelastic;
524 theInelasticProcess->AddDataSet(theGGHNI << 540 theInelasticProcess->RegisterMe(theInelasticModel);
525 theInelasticProcess->RegisterMe(antiBHig << 541 theInelasticProcess->RegisterMe(theTheoModel);
526 pmanager->AddDiscreteProcess(theInelasti << 542 pmanager->AddDiscreteProcess(theInelasticProcess);
527 } << 543 }
528 else if (particleName == "anti_xi-") { << 544 else if (particleName == "anti_xi-") {
529 pmanager->AddDiscreteProcess(theElasticP << 545 pmanager->AddDiscreteProcess(theElasticProcess);
530 G4HadronInelasticProcess* theInelasticPr << 546 G4AntiXiMinusInelasticProcess* theInelasticProcess =
531 new G4HadronInelasticProcess("inelasti << 547 new G4AntiXiMinusInelasticProcess("inelastic");
532 theInelasticProcess->AddDataSet(theGGHNI << 548 G4LEAntiXiMinusInelastic* theInelasticModel =
533 theInelasticProcess->RegisterMe(antiBHig << 549 new G4LEAntiXiMinusInelastic;
534 pmanager->AddDiscreteProcess(theInelasti << 550 theInelasticProcess->RegisterMe(theInelasticModel);
535 } << 551 theInelasticProcess->RegisterMe(theTheoModel);
536 else if (particleName == "deuteron") { << 552 pmanager->AddDiscreteProcess(theInelasticProcess);
537 pmanager->AddDiscreteProcess(theElasticP << 553 }
538 G4HadronInelasticProcess* theInelasticPr << 554 else if (particleName == "deuteron") {
539 new G4HadronInelasticProcess("inelasti << 555 pmanager->AddDiscreteProcess(theElasticProcess);
540 theInelasticProcess->RegisterMe(binaryCa << 556 G4DeuteronInelasticProcess* theInelasticProcess =
541 theInelasticProcess->RegisterMe(qmd); << 557 new G4DeuteronInelasticProcess("inelastic");
542 theInelasticProcess->AddDataSet(ionXS); << 558 G4LEDeuteronInelastic* theInelasticModel =
543 pmanager->AddDiscreteProcess(theInelasti << 559 new G4LEDeuteronInelastic;
544 } << 560 theInelasticProcess->RegisterMe(theInelasticModel);
545 else if (particleName == "triton") { << 561 theInelasticProcess->RegisterMe(theTheoModel);
546 pmanager->AddDiscreteProcess(theElasticP << 562 pmanager->AddDiscreteProcess(theInelasticProcess);
547 G4HadronInelasticProcess* theInelasticPr << 563 }
548 new G4HadronInelasticProcess("inelasti << 564 else if (particleName == "triton") {
549 theInelasticProcess->RegisterMe(binaryCa << 565 pmanager->AddDiscreteProcess(theElasticProcess);
550 theInelasticProcess->RegisterMe(qmd); << 566 G4TritonInelasticProcess* theInelasticProcess =
551 theInelasticProcess->AddDataSet(ionXS); << 567 new G4TritonInelasticProcess("inelastic");
552 pmanager->AddDiscreteProcess(theInelasti << 568 G4LETritonInelastic* theInelasticModel =
553 } << 569 new G4LETritonInelastic;
554 else if (particleName == "alpha") { << 570 theInelasticProcess->RegisterMe(theInelasticModel);
555 pmanager->AddDiscreteProcess(theElasticP << 571 theInelasticProcess->RegisterMe(theTheoModel);
556 G4HadronInelasticProcess* theInelasticPr << 572 pmanager->AddDiscreteProcess(theInelasticProcess);
557 new G4HadronInelasticProcess("inelasti << 573 }
558 theInelasticProcess->RegisterMe(binaryCa << 574 else if (particleName == "alpha") {
559 theInelasticProcess->RegisterMe(qmd); << 575 pmanager->AddDiscreteProcess(theElasticProcess);
560 theInelasticProcess->AddDataSet(ionXS); << 576 G4AlphaInelasticProcess* theInelasticProcess =
561 pmanager->AddDiscreteProcess(theInelasti << 577 new G4AlphaInelasticProcess("inelastic");
562 } << 578 G4LEAlphaInelastic* theInelasticModel =
563 else if (particleName == "omega-") { << 579 new G4LEAlphaInelastic;
564 pmanager->AddDiscreteProcess(theElasticP << 580 theInelasticProcess->RegisterMe(theInelasticModel);
565 G4HadronInelasticProcess* theInelasticPr << 581 theInelasticProcess->RegisterMe(theTheoModel);
566 new G4HadronInelasticProcess("inelasti << 582 pmanager->AddDiscreteProcess(theInelasticProcess);
567 theInelasticProcess->AddDataSet(theGGHNI << 583 }
568 theInelasticProcess->RegisterMe(bertini) << 584 else if (particleName == "omega-") {
569 theInelasticProcess->RegisterMe(theTheoM << 585 pmanager->AddDiscreteProcess(theElasticProcess);
570 pmanager->AddDiscreteProcess(theInelasti << 586 G4OmegaMinusInelasticProcess* theInelasticProcess =
571 } << 587 new G4OmegaMinusInelasticProcess("inelastic");
572 else if (particleName == "anti_omega-") { << 588 G4LEOmegaMinusInelastic* theInelasticModel =
573 pmanager->AddDiscreteProcess(theElasticP << 589 new G4LEOmegaMinusInelastic;
574 G4HadronInelasticProcess* theInelasticPr << 590 theInelasticProcess->RegisterMe(theInelasticModel);
575 new G4HadronInelasticProcess("inelasti << 591 theInelasticProcess->RegisterMe(theTheoModel);
576 theInelasticProcess->AddDataSet(theGGHNI << 592 pmanager->AddDiscreteProcess(theInelasticProcess);
577 theInelasticProcess->RegisterMe(antiBHig << 593 }
578 pmanager->AddDiscreteProcess(theInelasti << 594 else if (particleName == "anti_omega-") {
579 } << 595 pmanager->AddDiscreteProcess(theElasticProcess);
580 } << 596 G4AntiOmegaMinusInelasticProcess* theInelasticProcess =
>> 597 new G4AntiOmegaMinusInelasticProcess("inelastic");
>> 598 G4LEAntiOmegaMinusInelastic* theInelasticModel =
>> 599 new G4LEAntiOmegaMinusInelastic;
>> 600 theInelasticProcess->RegisterMe(theInelasticModel);
>> 601 theInelasticProcess->RegisterMe(theTheoModel);
>> 602 pmanager->AddDiscreteProcess(theInelasticProcess);
>> 603 }
>> 604 }
581 } 605 }
582 606
583 //....oooOO0OOooo........oooOO0OOooo........oo <<
584 <<
585 void B03PhysicsList::ConstructLeptHad() 607 void B03PhysicsList::ConstructLeptHad()
586 { << 608 {;}
587 ; <<
588 } <<
589 <<
590 //....oooOO0OOooo........oooOO0OOooo........oo <<
591 609
592 #include "G4Decay.hh" 610 #include "G4Decay.hh"
593 void B03PhysicsList::ConstructGeneral() 611 void B03PhysicsList::ConstructGeneral()
594 { 612 {
595 G4Decay* theDecayProcess = new G4Decay(); 613 G4Decay* theDecayProcess = new G4Decay();
596 auto particleIterator = GetParticleIterator( << 614 theParticleIterator->reset();
597 particleIterator->reset(); << 615 while( (*theParticleIterator)() ){
598 while ((*particleIterator)()) { << 616 G4ParticleDefinition* particle = theParticleIterator->value();
599 G4ParticleDefinition* particle = particleI <<
600 G4ProcessManager* pmanager = particle->Get 617 G4ProcessManager* pmanager = particle->GetProcessManager();
601 if (theDecayProcess->IsApplicable(*particl << 618 if (theDecayProcess->IsApplicable(*particle)) {
602 pmanager->AddProcess(theDecayProcess); << 619 pmanager ->AddProcess(theDecayProcess);
603 pmanager->SetProcessOrdering(theDecayPro << 620 pmanager ->SetProcessOrdering(theDecayProcess, idxPostStep);
604 pmanager->SetProcessOrdering(theDecayPro << 621 pmanager ->SetProcessOrdering(theDecayProcess, idxAtRest);
605 } 622 }
606 } 623 }
607 } 624 }
608 625
609 //....oooOO0OOooo........oooOO0OOooo........oo <<
610 <<
611 void B03PhysicsList::SetCuts() 626 void B03PhysicsList::SetCuts()
612 { 627 {
613 if (verboseLevel > 0) { << 628 if (verboseLevel >0)
>> 629 {
614 G4cout << "B03PhysicsList::SetCuts:"; 630 G4cout << "B03PhysicsList::SetCuts:";
615 G4cout << "CutLength : " << defaultCutValu << 631 G4cout << "CutLength : " << defaultCutValue/mm << " (mm)" << G4endl;
616 } << 632 }
617 // "G4VUserPhysicsList::SetCutsWithDefault << 633 // "G4VUserPhysicsList::SetCutsWithDefault" method sets
618 // the default cut value for all particle << 634 // the default cut value for all particle types
619 SetCutsWithDefault(); << 635 SetCutsWithDefault();
620 } <<
621 <<
622 //....oooOO0OOooo........oooOO0OOooo........oo <<
623 <<
624 #include "G4ParallelWorldProcess.hh" <<
625 void B03PhysicsList::AddScoringProcess() <<
626 { <<
627 G4int npw = fParaWorldName.size(); <<
628 for (G4int i = 0; i < npw; i++) { <<
629 G4String procName = "ParaWorldProc_" + fPa <<
630 G4ParallelWorldProcess* theParallelWorldPr <<
631 theParallelWorldProcess->SetParallelWorld( <<
632 <<
633 auto particleIterator = GetParticleIterato <<
634 particleIterator->reset(); <<
635 while ((*particleIterator)()) { <<
636 G4ParticleDefinition* particle = particl <<
637 G4ProcessManager* pmanager = particle->G <<
638 pmanager->AddProcess(theParallelWorldPro <<
639 if (theParallelWorldProcess->IsAtRestReq <<
640 pmanager->SetProcessOrdering(theParall <<
641 } <<
642 pmanager->SetProcessOrderingToSecond(the <<
643 pmanager->SetProcessOrdering(theParallel <<
644 } <<
645 } <<
646 } <<
647 <<
648 //....oooOO0OOooo........oooOO0OOooo........oo <<
649 <<
650 #include "G4IStore.hh" <<
651 #include "G4ImportanceProcess.hh" <<
652 void B03PhysicsList::AddBiasingProcess() <<
653 { <<
654 G4cout << " Preparing Importance Sampling wi <<
655 <<
656 G4IStore* iStore = G4IStore::GetInstance(fBi <<
657 G4GeometrySampler fGeomSampler(fBiasWorldNam <<
658 fGeomSampler.SetParallel(true); // parallel <<
659 // fGeomSampler.SetWorld(iStore->GetParallel <<
660 // fGeomSampler->PrepareImportanceSampling( <<
661 // GetInstance( <<
662 static G4bool first = true; <<
663 if (first) { <<
664 fGeomSampler.PrepareImportanceSampling(iSt <<
665 <<
666 fGeomSampler.Configure(); <<
667 G4cout << " GeomSampler Configured!!! " << <<
668 first = false; <<
669 } <<
670 <<
671 #ifdef G4MULTITHREADED <<
672 if (!G4Threading::IsMasterThread()) fGeomSam <<
673 #else <<
674 G4cout << " Running in singlethreaded mode!! <<
675 #endif <<
676 } 636 }
677 <<
678 //....oooOO0OOooo........oooOO0OOooo........oo <<
679 637