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