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