| 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 // 26 //
27 // ------------------------------------------- 27 // --------------------------------------------------------------
28 // GEANT 4 - Underground Dark Matter Detecto 28 // GEANT 4 - Underground Dark Matter Detector Advanced Example
29 // 29 //
30 // For information related to this code c 30 // For information related to this code contact: Alex Howard
31 // e-mail: alexander.howard@cern.ch 31 // e-mail: alexander.howard@cern.ch
32 // ------------------------------------------- 32 // --------------------------------------------------------------
33 // Comments 33 // Comments
34 // 34 //
35 // Underground Advanced 35 // Underground Advanced
36 // by A. Howard and H. Araujo 36 // by A. Howard and H. Araujo
37 // (27th November 2001) 37 // (27th November 2001)
38 // 38 //
39 // PhysicsList program 39 // PhysicsList program
40 // 40 //
41 // Modified: 41 // Modified:
42 // 42 //
43 // 14-02-03 Fix bugs in msc and hIon instancia 43 // 14-02-03 Fix bugs in msc and hIon instanciation + cut per region
44 // 44 //
45 // 05-02-05 AH - changes to G4Decay - added is 45 // 05-02-05 AH - changes to G4Decay - added is not short lived protection
46 // and redefined particles to allow n 46 // and redefined particles to allow non-static creation
47 // i.e. changed construction to G4Mes 47 // i.e. changed construction to G4MesonConstructor, G4BaryonConstructor
48 // 48 //
49 // 23-10-09 LP - migrated EM physics from the 49 // 23-10-09 LP - migrated EM physics from the LowEnergy processes (not supported) to
50 // the new G4Livermore model implemen 50 // the new G4Livermore model implementation. Results unchanged.
51 // 51 //
52 // ------------------------------------------- 52 // --------------------------------------------------------------
53 53
54 #include <iomanip> 54 #include <iomanip>
55 55
56 #include "DMXPhysicsList.hh" 56 #include "DMXPhysicsList.hh"
57 57
58 #include "globals.hh" 58 #include "globals.hh"
59 #include "G4SystemOfUnits.hh" 59 #include "G4SystemOfUnits.hh"
60 #include "G4ProcessManager.hh" 60 #include "G4ProcessManager.hh"
61 #include "G4ProcessVector.hh" 61 #include "G4ProcessVector.hh"
62 62
63 #include "G4ParticleDefinition.hh" 63 #include "G4ParticleDefinition.hh"
64 #include "G4ParticleWithCuts.hh" 64 #include "G4ParticleWithCuts.hh"
65 #include "G4ParticleTypes.hh" 65 #include "G4ParticleTypes.hh"
66 #include "G4ParticleTable.hh" 66 #include "G4ParticleTable.hh"
67 67
68 #include "G4ios.hh" 68 #include "G4ios.hh"
69 #include "G4UserLimits.hh" 69 #include "G4UserLimits.hh"
70 70
71 #include "G4MesonConstructor.hh" <<
72 #include "G4BaryonConstructor.hh" <<
73 #include "G4IonConstructor.hh" <<
74 #include "G4ShortLivedConstructor.hh" <<
75 <<
76 #include "DMXMaxTimeCuts.hh" <<
77 #include "DMXMinEkineCuts.hh" <<
78 #include "G4StepLimiter.hh" <<
79 <<
80 // gamma <<
81 #include "G4PhotoElectricEffect.hh" <<
82 #include "G4LivermorePhotoElectricModel.hh" <<
83 <<
84 #include "G4ComptonScattering.hh" <<
85 #include "G4LivermoreComptonModel.hh" <<
86 <<
87 #include "G4GammaConversion.hh" <<
88 #include "G4BetheHeitler5DModel.hh" <<
89 <<
90 #include "G4RayleighScattering.hh" <<
91 #include "G4LivermoreRayleighModel.hh" <<
92 <<
93 // e- <<
94 #include "G4eMultipleScattering.hh" <<
95 <<
96 #include "G4eIonisation.hh" <<
97 #include "G4LivermoreIonisationModel.hh" <<
98 <<
99 #include "G4eBremsstrahlung.hh" <<
100 #include "G4UniversalFluctuation.hh" <<
101 <<
102 // e+ <<
103 #include "G4eIonisation.hh" <<
104 #include "G4eBremsstrahlung.hh" <<
105 #include "G4eplusAnnihilation.hh" <<
106 <<
107 // alpha and GenericIon and deuterons, triton, <<
108 //muon: <<
109 #include "G4MuIonisation.hh" <<
110 #include "G4MuBremsstrahlung.hh" <<
111 #include "G4MuPairProduction.hh" <<
112 #include "G4MuMultipleScattering.hh" <<
113 #include "G4MuonMinusCapture.hh" <<
114 <<
115 //OTHERS: <<
116 #include "G4hIonisation.hh" <<
117 #include "G4hMultipleScattering.hh" <<
118 #include "G4hBremsstrahlung.hh" <<
119 #include "G4ionIonisation.hh" <<
120 #include "G4IonParametrisedLossModel.hh" <<
121 #include "G4NuclearStopping.hh" <<
122 <<
123 //em process options to allow msc step-limitat <<
124 #include "G4EmParameters.hh" <<
125 #include "G4VAtomDeexcitation.hh" <<
126 #include "G4UAtomicDeexcitation.hh" <<
127 #include "G4LossTableManager.hh" <<
128 <<
129 #include "G4Scintillation.hh" <<
130 #include "G4OpAbsorption.hh" <<
131 #include "G4OpBoundaryProcess.hh" <<
132 #include "G4OpticalParameters.hh" <<
133 <<
134 // Elastic processes: <<
135 #include "G4HadronElasticProcess.hh" <<
136 #include "G4ChipsElasticModel.hh" <<
137 #include "G4ElasticHadrNucleusHE.hh" <<
138 <<
139 // Inelastic processes: <<
140 #include "G4HadronInelasticProcess.hh" <<
141 <<
142 // High energy FTFP model and Bertini cascade <<
143 #include "G4FTFModel.hh" <<
144 #include "G4LundStringFragmentation.hh" <<
145 #include "G4ExcitedStringDecay.hh" <<
146 #include "G4PreCompoundModel.hh" <<
147 #include "G4GeneratorPrecompoundInterface.hh" <<
148 #include "G4TheoFSGenerator.hh" <<
149 #include "G4CascadeInterface.hh" <<
150 <<
151 // Cross sections <<
152 #include "G4VCrossSectionDataSet.hh" <<
153 #include "G4CrossSectionDataSetRegistry.hh" <<
154 <<
155 #include "G4CrossSectionElastic.hh" <<
156 #include "G4CrossSectionInelastic.hh" <<
157 #include "G4BGGPionElasticXS.hh" <<
158 #include "G4BGGPionInelasticXS.hh" <<
159 #include "G4AntiNuclElastic.hh" <<
160 <<
161 #include "G4CrossSectionInelastic.hh" <<
162 #include "G4BGGNucleonInelasticXS.hh" <<
163 #include "G4BGGNucleonElasticXS.hh" <<
164 #include "G4NeutronInelasticXS.hh" <<
165 #include "G4NeutronElasticXS.hh" <<
166 #include "G4ComponentAntiNuclNuclearXS.hh" <<
167 #include "G4ComponentGGNuclNuclXsc.hh" <<
168 #include "G4ComponentGGHadronNucleusXsc.hh" <<
169 <<
170 #include "G4HadronElastic.hh" <<
171 #include "G4NeutronCaptureProcess.hh" <<
172 <<
173 // Neutron high-precision models: <20 MeV <<
174 #include "G4ParticleHPElastic.hh" <<
175 #include "G4ParticleHPElasticData.hh" <<
176 #include "G4ParticleHPCapture.hh" <<
177 #include "G4ParticleHPCaptureData.hh" <<
178 #include "G4ParticleHPInelastic.hh" <<
179 #include "G4ParticleHPInelasticData.hh" <<
180 <<
181 // Stopping processes <<
182 #include "G4HadronStoppingProcess.hh" <<
183 #include "G4HadronicAbsorptionBertini.hh" <<
184 #include "G4HadronicAbsorptionFritiof.hh" <<
185 <<
186 #include "G4HadronicParameters.hh" <<
187 <<
188 #include "G4Decay.hh" <<
189 #include "G4RadioactiveDecay.hh" <<
190 #include "G4PhysicsListHelper.hh" <<
191 #include "G4NuclideTable.hh" <<
192 #include "G4NuclearLevelData.hh" <<
193 <<
194 // Constructor /////////////////////////////// 71 // Constructor /////////////////////////////////////////////////////////////
195 DMXPhysicsList::DMXPhysicsList() : G4VUserPhys 72 DMXPhysicsList::DMXPhysicsList() : G4VUserPhysicsList()
196 { 73 {
197 74
198 defaultCutValue = 1.0*micrometer; // 75 defaultCutValue = 1.0*micrometer; //
199 cutForGamma = defaultCutValue; 76 cutForGamma = defaultCutValue;
200 cutForElectron = 1.0*nanometer; 77 cutForElectron = 1.0*nanometer;
201 cutForPositron = defaultCutValue; 78 cutForPositron = defaultCutValue;
202 79
203 VerboseLevel = 1; 80 VerboseLevel = 1;
204 OpVerbLevel = 0; 81 OpVerbLevel = 0;
205 82
206 //set a finer grid of the physic tables in o <<
207 //former LowEnergy models have 200 bins up t <<
208 G4EmParameters* param = G4EmParameters::Inst <<
209 param->SetMaxEnergy(100*GeV); <<
210 param->SetNumberOfBinsPerDecade(20); <<
211 param->SetMscStepLimitType(fMinimal); <<
212 param->SetFluo(true); <<
213 param->SetPixe(true); <<
214 param->SetAuger(true); <<
215 <<
216 G4EmParameters::Instance()->AddPhysics("Worl <<
217 G4DeexPrecoParameters* deex = G4NuclearLevel <<
218 deex->SetStoreICLevelData(true); <<
219 deex->SetMaxLifeTime(G4NuclideTable::GetInst <<
220 /std::log(2.)); <<
221 SetVerboseLevel(VerboseLevel); 83 SetVerboseLevel(VerboseLevel);
222 } 84 }
223 85
>> 86
224 // Destructor //////////////////////////////// 87 // Destructor //////////////////////////////////////////////////////////////
225 DMXPhysicsList::~DMXPhysicsList() 88 DMXPhysicsList::~DMXPhysicsList()
226 {;} 89 {;}
227 90
>> 91
228 // Construct Particles /////////////////////// 92 // Construct Particles /////////////////////////////////////////////////////
229 void DMXPhysicsList::ConstructParticle() 93 void DMXPhysicsList::ConstructParticle()
230 { 94 {
>> 95
231 // In this method, static member functions s 96 // In this method, static member functions should be called
232 // for all particles which you want to use. 97 // for all particles which you want to use.
233 // This ensures that objects of these partic 98 // This ensures that objects of these particle types will be
234 // created in the program. 99 // created in the program.
235 100
236 ConstructMyBosons(); 101 ConstructMyBosons();
237 ConstructMyLeptons(); 102 ConstructMyLeptons();
238 ConstructMyHadrons(); 103 ConstructMyHadrons();
239 ConstructMyShortLiveds(); 104 ConstructMyShortLiveds();
>> 105
240 } 106 }
241 107
>> 108
242 // construct Bosons:////////////////////////// 109 // construct Bosons://///////////////////////////////////////////////////
243 void DMXPhysicsList::ConstructMyBosons() 110 void DMXPhysicsList::ConstructMyBosons()
244 { 111 {
245 // pseudo-particles 112 // pseudo-particles
246 G4Geantino::GeantinoDefinition(); 113 G4Geantino::GeantinoDefinition();
247 G4ChargedGeantino::ChargedGeantinoDefinition 114 G4ChargedGeantino::ChargedGeantinoDefinition();
248 115
249 // gamma 116 // gamma
250 G4Gamma::GammaDefinition(); 117 G4Gamma::GammaDefinition();
251 118
252 //OpticalPhotons 119 //OpticalPhotons
253 G4OpticalPhoton::OpticalPhotonDefinition(); 120 G4OpticalPhoton::OpticalPhotonDefinition();
254 121
255 } 122 }
256 123
>> 124
257 // construct Leptons:///////////////////////// 125 // construct Leptons://///////////////////////////////////////////////////
258 void DMXPhysicsList::ConstructMyLeptons() 126 void DMXPhysicsList::ConstructMyLeptons()
259 { 127 {
260 // leptons 128 // leptons
261 G4Electron::ElectronDefinition(); 129 G4Electron::ElectronDefinition();
262 G4Positron::PositronDefinition(); 130 G4Positron::PositronDefinition();
263 G4MuonPlus::MuonPlusDefinition(); 131 G4MuonPlus::MuonPlusDefinition();
264 G4MuonMinus::MuonMinusDefinition(); 132 G4MuonMinus::MuonMinusDefinition();
265 133
266 G4NeutrinoE::NeutrinoEDefinition(); 134 G4NeutrinoE::NeutrinoEDefinition();
267 G4AntiNeutrinoE::AntiNeutrinoEDefinition(); 135 G4AntiNeutrinoE::AntiNeutrinoEDefinition();
268 G4NeutrinoMu::NeutrinoMuDefinition(); 136 G4NeutrinoMu::NeutrinoMuDefinition();
269 G4AntiNeutrinoMu::AntiNeutrinoMuDefinition() 137 G4AntiNeutrinoMu::AntiNeutrinoMuDefinition();
270 } 138 }
271 139
>> 140
>> 141 #include "G4MesonConstructor.hh"
>> 142 #include "G4BaryonConstructor.hh"
>> 143 #include "G4IonConstructor.hh"
>> 144
272 // construct Hadrons:///////////////////////// 145 // construct Hadrons://///////////////////////////////////////////////////
273 void DMXPhysicsList::ConstructMyHadrons() 146 void DMXPhysicsList::ConstructMyHadrons()
274 { 147 {
275 // mesons 148 // mesons
276 G4MesonConstructor mConstructor; 149 G4MesonConstructor mConstructor;
277 mConstructor.ConstructParticle(); 150 mConstructor.ConstructParticle();
278 151
279 // baryons 152 // baryons
280 G4BaryonConstructor bConstructor; 153 G4BaryonConstructor bConstructor;
281 bConstructor.ConstructParticle(); 154 bConstructor.ConstructParticle();
282 155
283 // ions 156 // ions
284 G4IonConstructor iConstructor; 157 G4IonConstructor iConstructor;
285 iConstructor.ConstructParticle(); 158 iConstructor.ConstructParticle();
>> 159
286 } 160 }
287 161
>> 162 #include "G4ShortLivedConstructor.hh"
>> 163
288 // construct Shortliveds:///////////////////// 164 // construct Shortliveds://///////////////////////////////////////////////////
289 void DMXPhysicsList::ConstructMyShortLiveds() 165 void DMXPhysicsList::ConstructMyShortLiveds()
290 { 166 {
291 G4ShortLivedConstructor slConstructor; 167 G4ShortLivedConstructor slConstructor;
292 slConstructor.ConstructParticle(); 168 slConstructor.ConstructParticle();
293 } 169 }
294 170
>> 171
>> 172
>> 173
295 // Construct Processes /////////////////////// 174 // Construct Processes //////////////////////////////////////////////////////
296 void DMXPhysicsList::ConstructProcess() 175 void DMXPhysicsList::ConstructProcess()
297 { 176 {
>> 177
298 AddTransportation(); 178 AddTransportation();
299 179
300 ConstructEM(); 180 ConstructEM();
301 181
302 ConstructOp(); 182 ConstructOp();
303 183
304 ConstructHad(); 184 ConstructHad();
305 185
306 ConstructGeneral(); 186 ConstructGeneral();
>> 187
307 } 188 }
308 189
>> 190
309 // Transportation //////////////////////////// 191 // Transportation ///////////////////////////////////////////////////////////
>> 192 #include "DMXMaxTimeCuts.hh"
>> 193 #include "DMXMinEkineCuts.hh"
>> 194 #include "G4StepLimiter.hh"
>> 195
310 void DMXPhysicsList::AddTransportation() { 196 void DMXPhysicsList::AddTransportation() {
311 197
312 G4VUserPhysicsList::AddTransportation(); 198 G4VUserPhysicsList::AddTransportation();
313 199
314 auto particleIterator=GetParticleIterator(); 200 auto particleIterator=GetParticleIterator();
315 particleIterator->reset(); 201 particleIterator->reset();
316 while( (*particleIterator)() ){ 202 while( (*particleIterator)() ){
317 G4ParticleDefinition* particle = particleI 203 G4ParticleDefinition* particle = particleIterator->value();
318 G4ProcessManager* pmanager = particle->Get 204 G4ProcessManager* pmanager = particle->GetProcessManager();
319 G4String particleName = particle->GetParti 205 G4String particleName = particle->GetParticleName();
320 // time cuts for ONLY neutrons: 206 // time cuts for ONLY neutrons:
321 if(particleName == "neutron") 207 if(particleName == "neutron")
322 pmanager->AddDiscreteProcess(new DMXMaxT 208 pmanager->AddDiscreteProcess(new DMXMaxTimeCuts());
323 // Energy cuts to kill charged (embedded i 209 // Energy cuts to kill charged (embedded in method) particles:
324 pmanager->AddDiscreteProcess(new DMXMinEki 210 pmanager->AddDiscreteProcess(new DMXMinEkineCuts());
325 211
326 // Step limit applied to all particles: 212 // Step limit applied to all particles:
327 pmanager->AddDiscreteProcess(new G4StepLim << 213 pmanager->AddProcess(new G4StepLimiter, -1,-1,1);
>> 214
328 } 215 }
329 } 216 }
330 217
>> 218
331 // Electromagnetic Processes ///////////////// 219 // Electromagnetic Processes ////////////////////////////////////////////////
332 // all charged particles 220 // all charged particles
>> 221
>> 222 // gamma
>> 223 #include "G4PhotoElectricEffect.hh"
>> 224 #include "G4LivermorePhotoElectricModel.hh"
>> 225
>> 226 #include "G4ComptonScattering.hh"
>> 227 #include "G4LivermoreComptonModel.hh"
>> 228
>> 229 #include "G4GammaConversion.hh"
>> 230 #include "G4LivermoreGammaConversionModel.hh"
>> 231
>> 232 #include "G4RayleighScattering.hh"
>> 233 #include "G4LivermoreRayleighModel.hh"
>> 234
>> 235
>> 236 // e-
>> 237 #include "G4eMultipleScattering.hh"
>> 238
>> 239 #include "G4eIonisation.hh"
>> 240 #include "G4LivermoreIonisationModel.hh"
>> 241
>> 242 #include "G4eBremsstrahlung.hh"
>> 243 #include "G4LivermoreBremsstrahlungModel.hh"
>> 244
>> 245
>> 246 // e+
>> 247 #include "G4eIonisation.hh"
>> 248 #include "G4eBremsstrahlung.hh"
>> 249 #include "G4eplusAnnihilation.hh"
>> 250
>> 251
>> 252 // alpha and GenericIon and deuterons, triton, He3:
>> 253
>> 254 //muon:
>> 255 #include "G4MuIonisation.hh"
>> 256 #include "G4MuBremsstrahlung.hh"
>> 257 #include "G4MuPairProduction.hh"
>> 258 #include "G4MuonMinusCapture.hh"
>> 259
>> 260 //OTHERS:
>> 261 #include "G4hIonisation.hh"
>> 262 #include "G4hMultipleScattering.hh"
>> 263 #include "G4hBremsstrahlung.hh"
>> 264 #include "G4ionIonisation.hh"
>> 265 #include "G4IonParametrisedLossModel.hh"
>> 266
>> 267 //em process options to allow msc step-limitation to be switched off
>> 268 #include "G4EmParameters.hh"
>> 269 #include "G4VAtomDeexcitation.hh"
>> 270 #include "G4UAtomicDeexcitation.hh"
>> 271 #include "G4LossTableManager.hh"
>> 272
333 void DMXPhysicsList::ConstructEM() { 273 void DMXPhysicsList::ConstructEM() {
334 274
>> 275 //set a finer grid of the physic tables in order to improve precision
>> 276 //former LowEnergy models have 200 bins up to 100 GeV
>> 277 G4EmParameters* param = G4EmParameters::Instance();
>> 278 param->SetMaxEnergy(100*GeV);
>> 279 param->SetNumberOfBinsPerDecade(20);
>> 280 param->SetMscStepLimitType(fMinimal);
>> 281 param->SetFluo(true);
>> 282 param->SetPixe(true);
>> 283 param->SetAuger(true);
335 G4LossTableManager* man = G4LossTableManager 284 G4LossTableManager* man = G4LossTableManager::Instance();
336 man->SetAtomDeexcitation(new G4UAtomicDeexci << 285 G4VAtomDeexcitation* ad = man->AtomDeexcitation();
>> 286 if(!ad) {
>> 287 man->SetAtomDeexcitation(new G4UAtomicDeexcitation());
>> 288 }
337 289
338 G4EmParameters* em_params = G4EmParameters:: <<
339 <<
340 auto particleIterator=GetParticleIterator(); 290 auto particleIterator=GetParticleIterator();
341 particleIterator->reset(); 291 particleIterator->reset();
342 while( (*particleIterator)() ){ 292 while( (*particleIterator)() ){
343 G4ParticleDefinition* particle = particleI 293 G4ParticleDefinition* particle = particleIterator->value();
344 G4ProcessManager* pmanager = particle->Get 294 G4ProcessManager* pmanager = particle->GetProcessManager();
345 G4String particleName = particle->GetParti 295 G4String particleName = particle->GetParticleName();
346 G4String particleType = particle->GetParti 296 G4String particleType = particle->GetParticleType();
347 G4double charge = particle->GetPDGCharge() 297 G4double charge = particle->GetPDGCharge();
348 298
349 if (particleName == "gamma") 299 if (particleName == "gamma")
350 { 300 {
351 //gamma 301 //gamma
352 G4RayleighScattering* theRayleigh = new G4Ra 302 G4RayleighScattering* theRayleigh = new G4RayleighScattering();
353 pmanager->AddDiscreteProcess(theRayleigh); 303 pmanager->AddDiscreteProcess(theRayleigh);
354 304
355 G4PhotoElectricEffect* thePhotoElectricEffec 305 G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
356 thePhotoElectricEffect->SetEmModel(new G4Liv 306 thePhotoElectricEffect->SetEmModel(new G4LivermorePhotoElectricModel());
357 pmanager->AddDiscreteProcess(thePhotoElectri 307 pmanager->AddDiscreteProcess(thePhotoElectricEffect);
358 308
359 G4ComptonScattering* theComptonScattering = 309 G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
360 theComptonScattering->SetEmModel(new G4Liver 310 theComptonScattering->SetEmModel(new G4LivermoreComptonModel());
361 pmanager->AddDiscreteProcess(theComptonScatt 311 pmanager->AddDiscreteProcess(theComptonScattering);
362 312
363 G4GammaConversion* theGammaConversion = new 313 G4GammaConversion* theGammaConversion = new G4GammaConversion();
364 theGammaConversion->SetEmModel(new G4BetheHe << 314 theGammaConversion->SetEmModel(new G4LivermoreGammaConversionModel());
365 pmanager->AddDiscreteProcess(theGammaConvers 315 pmanager->AddDiscreteProcess(theGammaConversion);
366 316
367 } 317 }
368 else if (particleName == "e-") 318 else if (particleName == "e-")
369 { 319 {
370 //electron 320 //electron
371 // process ordering: AddProcess(name, at res 321 // process ordering: AddProcess(name, at rest, along step, post step)
372 // Multiple scattering 322 // Multiple scattering
373 G4eMultipleScattering* msc = new G4eMultiple 323 G4eMultipleScattering* msc = new G4eMultipleScattering();
374 em_params->SetMscStepLimitType(fUseDistanceT << 324 msc->SetStepLimitType(fUseDistanceToBoundary);
375 pmanager->AddProcess(msc,-1, 1, -1); 325 pmanager->AddProcess(msc,-1, 1, -1);
376 326
377 // Ionisation 327 // Ionisation
378 G4eIonisation* eIonisation = new G4eIonisati 328 G4eIonisation* eIonisation = new G4eIonisation();
379 G4VEmModel* theIoniLiv = new G4Livermo << 329 eIonisation->SetEmModel(new G4LivermoreIonisationModel());
380 theIoniLiv->SetHighEnergyLimit(0.1*MeV << 330 eIonisation->SetStepFunction(0.2, 100*um); //improved precision in tracking
381 eIonisation->AddEmModel(0, theIoniLiv, << 331 pmanager->AddProcess(eIonisation,-1, 2, 2);
382 em_params->SetStepFunction(0.2, 100*um); //i <<
383 pmanager->AddProcess(eIonisation,-1, 2, 1); <<
384 332
385 // Bremsstrahlung 333 // Bremsstrahlung
386 G4eBremsstrahlung* eBremsstrahlung = new G4e 334 G4eBremsstrahlung* eBremsstrahlung = new G4eBremsstrahlung();
387 pmanager->AddProcess(eBremsstrahlung, -1,-3, << 335 eBremsstrahlung->SetEmModel(new G4LivermoreBremsstrahlungModel());
>> 336 pmanager->AddProcess(eBremsstrahlung, -1,-3, 3);
388 } 337 }
389 else if (particleName == "e+") 338 else if (particleName == "e+")
390 { 339 {
391 //positron 340 //positron
392 G4eMultipleScattering* msc = new G4eMultiple 341 G4eMultipleScattering* msc = new G4eMultipleScattering();
393 msc->SetStepLimitType(fUseDistanceToBoundary 342 msc->SetStepLimitType(fUseDistanceToBoundary);
394 pmanager->AddProcess(msc,-1, 1, -1); << 343 pmanager->AddProcess(msc,-1, 1, 1);
395 344
396 // Ionisation 345 // Ionisation
397 G4eIonisation* eIonisation = new G4eIonisati 346 G4eIonisation* eIonisation = new G4eIonisation();
398 // eIonisation->SetStepFunction(0.2, 100*um) << 347 eIonisation->SetStepFunction(0.2, 100*um); //
399 pmanager->AddProcess(eIonisation, << 348 pmanager->AddProcess(eIonisation, -1, 2, 2);
400 349
401 //Bremsstrahlung (use default, no low-energy 350 //Bremsstrahlung (use default, no low-energy available)
402 pmanager->AddProcess(new G4eBremsstrahlung() << 351 pmanager->AddProcess(new G4eBremsstrahlung(), -1,-1, 3);
403 352
404 //Annihilation 353 //Annihilation
405 pmanager->AddProcess(new G4eplusAnnihilation << 354 pmanager->AddProcess(new G4eplusAnnihilation(),0,-1, 4);
406 } 355 }
407 else if( particleName == "mu+" || 356 else if( particleName == "mu+" ||
408 particleName == "mu-" ) 357 particleName == "mu-" )
409 { 358 {
410 //muon 359 //muon
411 pmanager->AddProcess(new G4MuMultipleScatter << 360 pmanager->AddProcess(new G4eMultipleScattering, -1, 1, 1);
412 pmanager->AddProcess(new G4MuIonisation(), << 361 pmanager->AddProcess(new G4MuIonisation(), -1, 2, 2);
413 pmanager->AddProcess(new G4MuBremsstrahlung( << 362 pmanager->AddProcess(new G4MuBremsstrahlung(), -1,-1, 3);
414 pmanager->AddProcess(new G4MuPairProduction( << 363 pmanager->AddProcess(new G4MuPairProduction(), -1,-1, 4);
415 if( particleName == "mu-" ) 364 if( particleName == "mu-" )
416 pmanager->AddProcess(new G4MuonMinusCaptur 365 pmanager->AddProcess(new G4MuonMinusCapture(), 0,-1,-1);
417 } 366 }
418 else if (particleName == "proton" || 367 else if (particleName == "proton" ||
419 particleName == "pi+" || 368 particleName == "pi+" ||
420 particleName == "pi-") 369 particleName == "pi-")
421 { 370 {
422 //multiple scattering 371 //multiple scattering
423 pmanager->AddProcess(new G4hMultipleScatteri << 372 pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
424 373
425 //ionisation 374 //ionisation
426 G4hIonisation* hIonisation = new G4hIonisati 375 G4hIonisation* hIonisation = new G4hIonisation();
427 em_params->SetStepFunctionMuHad(0.2, 50*um); << 376 hIonisation->SetStepFunction(0.2, 50*um);
428 pmanager->AddProcess(hIonisation, << 377 pmanager->AddProcess(hIonisation, -1, 2, 2);
429 378
430 //bremmstrahlung 379 //bremmstrahlung
431 pmanager->AddProcess(new G4hBremsstrahlung, << 380 pmanager->AddProcess(new G4hBremsstrahlung, -1,-3, 3);
432 } 381 }
433 else if(particleName == "alpha" || 382 else if(particleName == "alpha" ||
434 particleName == "deuteron" || 383 particleName == "deuteron" ||
435 particleName == "triton" || 384 particleName == "triton" ||
436 particleName == "He3") 385 particleName == "He3")
437 { 386 {
438 //multiple scattering 387 //multiple scattering
439 pmanager->AddProcess(new G4hMultipleScatteri << 388 pmanager->AddProcess(new G4hMultipleScattering,-1,1,1);
440 389
441 //ionisation 390 //ionisation
442 G4ionIonisation* ionIoni = new G4ionIonisati 391 G4ionIonisation* ionIoni = new G4ionIonisation();
443 em_params->SetStepFunctionLightIons(0.1, 1*C << 392 ionIoni->SetStepFunction(0.1, 20*um);
444 pmanager->AddProcess(ionIoni, << 393 pmanager->AddProcess(ionIoni, -1, 2, 2);
445 pmanager->AddProcess(new G4NuclearStopping() <<
446 } 394 }
447 else if (particleName == "GenericIon") 395 else if (particleName == "GenericIon")
448 { 396 {
449 // OBJECT may be dynamically created as eith 397 // OBJECT may be dynamically created as either a GenericIon or nucleus
450 // G4Nucleus exists and therefore has partic 398 // G4Nucleus exists and therefore has particle type nucleus
451 // genericIon: 399 // genericIon:
452 400
453 //multiple scattering 401 //multiple scattering
454 pmanager->AddProcess(new G4hMultipleScatteri << 402 pmanager->AddProcess(new G4hMultipleScattering,-1,1,1);
455 403
456 //ionisation 404 //ionisation
457 G4ionIonisation* ionIoni = new G4ionIonisati 405 G4ionIonisation* ionIoni = new G4ionIonisation();
458 em_params->SetStepFunctionIons(0.1, 1*CLHEP: << 406 ionIoni->SetEmModel(new G4IonParametrisedLossModel());
459 pmanager->AddProcess(ionIoni, << 407 ionIoni->SetStepFunction(0.1, 20*um);
460 pmanager->AddProcess(new G4NuclearStopping() << 408 pmanager->AddProcess(ionIoni, -1, 2, 2);
461 } 409 }
462 410
463 else if ((!particle->IsShortLived()) && 411 else if ((!particle->IsShortLived()) &&
464 (charge != 0.0) && 412 (charge != 0.0) &&
465 (particle->GetParticleName() != "charge 413 (particle->GetParticleName() != "chargedgeantino"))
466 { 414 {
467 //all others charged particles except geanti 415 //all others charged particles except geantino
468 G4hMultipleScattering* aMultipleScatte 416 G4hMultipleScattering* aMultipleScattering = new G4hMultipleScattering();
469 G4hIonisation* ahadronIon = new G4hIon 417 G4hIonisation* ahadronIon = new G4hIonisation();
470 418
471 //multiple scattering 419 //multiple scattering
472 pmanager->AddProcess(aMultipleScattering,-1, << 420 pmanager->AddProcess(aMultipleScattering,-1,1,1);
473 421
474 //ionisation 422 //ionisation
475 pmanager->AddProcess(ahadronIon, -1,2, << 423 pmanager->AddProcess(ahadronIon, -1,2,2);
476 } 424 }
>> 425
477 } 426 }
478 } 427 }
479 428
>> 429
480 // Optical Processes ///////////////////////// 430 // Optical Processes ////////////////////////////////////////////////////////
>> 431 #include "G4Scintillation.hh"
>> 432 #include "G4OpAbsorption.hh"
>> 433 //#include "G4OpRayleigh.hh"
>> 434 #include "G4OpBoundaryProcess.hh"
>> 435
481 void DMXPhysicsList::ConstructOp() 436 void DMXPhysicsList::ConstructOp()
482 { 437 {
483 G4OpticalParameters* opParams = G4OpticalPar << 438 // default scintillation process
484 G4Scintillation* theScintProcessDef = new G4 439 G4Scintillation* theScintProcessDef = new G4Scintillation("Scintillation");
485 opParams->SetScintTrackSecondariesFirst(true << 440 // theScintProcessDef->DumpPhysicsTable();
486 opParams->SetScintByParticleType(true); << 441 theScintProcessDef->SetTrackSecondariesFirst(true);
>> 442 theScintProcessDef->SetScintillationYieldFactor(1.0); //
>> 443 theScintProcessDef->SetScintillationExcitationRatio(0.0); //
>> 444 theScintProcessDef->SetVerboseLevel(OpVerbLevel);
>> 445
>> 446 // scintillation process for alpha:
>> 447 G4Scintillation* theScintProcessAlpha = new G4Scintillation("Scintillation");
>> 448 // theScintProcessNuc->DumpPhysicsTable();
>> 449 theScintProcessAlpha->SetTrackSecondariesFirst(true);
>> 450 theScintProcessAlpha->SetScintillationYieldFactor(1.1);
>> 451 theScintProcessAlpha->SetScintillationExcitationRatio(1.0);
>> 452 theScintProcessAlpha->SetVerboseLevel(OpVerbLevel);
>> 453
>> 454 // scintillation process for heavy nuclei
>> 455 G4Scintillation* theScintProcessNuc = new G4Scintillation("Scintillation");
>> 456 // theScintProcessNuc->DumpPhysicsTable();
>> 457 theScintProcessNuc->SetTrackSecondariesFirst(true);
>> 458 theScintProcessNuc->SetScintillationYieldFactor(0.2);
>> 459 theScintProcessNuc->SetScintillationExcitationRatio(1.0);
>> 460 theScintProcessNuc->SetVerboseLevel(OpVerbLevel);
487 461
488 // optical processes 462 // optical processes
489 G4OpAbsorption* theAbsorptionProcess = new G 463 G4OpAbsorption* theAbsorptionProcess = new G4OpAbsorption();
>> 464 // G4OpRayleigh* theRayleighScatteringProcess = new G4OpRayleigh();
490 G4OpBoundaryProcess* theBoundaryProcess = ne 465 G4OpBoundaryProcess* theBoundaryProcess = new G4OpBoundaryProcess();
>> 466 // theAbsorptionProcess->DumpPhysicsTable();
>> 467 // theRayleighScatteringProcess->DumpPhysicsTable();
>> 468 theAbsorptionProcess->SetVerboseLevel(OpVerbLevel);
>> 469 // theRayleighScatteringProcess->SetVerboseLevel(OpVerbLevel);
>> 470 theBoundaryProcess->SetVerboseLevel(OpVerbLevel);
491 471
492 auto particleIterator=GetParticleIterator(); 472 auto particleIterator=GetParticleIterator();
493 particleIterator->reset(); 473 particleIterator->reset();
494 while( (*particleIterator)() ) 474 while( (*particleIterator)() )
495 { 475 {
496 G4ParticleDefinition* particle = particl 476 G4ParticleDefinition* particle = particleIterator->value();
497 G4ProcessManager* pmanager = particle->G 477 G4ProcessManager* pmanager = particle->GetProcessManager();
498 G4String particleName = particle->GetPar 478 G4String particleName = particle->GetParticleName();
499 if (theScintProcessDef->IsApplicable(*pa 479 if (theScintProcessDef->IsApplicable(*particle)) {
500 pmanager->AddProcess(theScintProcessDe << 480 // if(particle->GetPDGMass() > 5.0*GeV)
501 pmanager->SetProcessOrderingToLast(the << 481 if(particle->GetParticleName() == "GenericIon") {
502 pmanager->SetProcessOrderingToLast(the << 482 pmanager->AddProcess(theScintProcessNuc); // AtRestDiscrete
>> 483 pmanager->SetProcessOrderingToLast(theScintProcessNuc,idxAtRest);
>> 484 pmanager->SetProcessOrderingToLast(theScintProcessNuc,idxPostStep);
>> 485 }
>> 486 else if(particle->GetParticleName() == "alpha") {
>> 487 pmanager->AddProcess(theScintProcessAlpha);
>> 488 pmanager->SetProcessOrderingToLast(theScintProcessAlpha,idxAtRest);
>> 489 pmanager->SetProcessOrderingToLast(theScintProcessAlpha,idxPostStep);
>> 490 }
>> 491 else {
>> 492 pmanager->AddProcess(theScintProcessDef);
>> 493 pmanager->SetProcessOrderingToLast(theScintProcessDef,idxAtRest);
>> 494 pmanager->SetProcessOrderingToLast(theScintProcessDef,idxPostStep);
>> 495 }
503 } 496 }
504 497
505 if (particleName == "opticalphoton") { 498 if (particleName == "opticalphoton") {
506 pmanager->AddDiscreteProcess(theAbsorptionPr 499 pmanager->AddDiscreteProcess(theAbsorptionProcess);
>> 500 // pmanager->AddDiscreteProcess(theRayleighScatteringProcess);
507 pmanager->AddDiscreteProcess(theBoundaryProc 501 pmanager->AddDiscreteProcess(theBoundaryProcess);
508 } 502 }
509 } 503 }
510 } 504 }
511 505
>> 506
512 // Hadronic processes //////////////////////// 507 // Hadronic processes ////////////////////////////////////////////////////////
513 508
>> 509 // Elastic processes:
>> 510 #include "G4HadronElasticProcess.hh"
>> 511 #include "G4ChipsElasticModel.hh"
>> 512 #include "G4ElasticHadrNucleusHE.hh"
>> 513
>> 514 // Inelastic processes:
>> 515 #include "G4PionPlusInelasticProcess.hh"
>> 516 #include "G4PionMinusInelasticProcess.hh"
>> 517 #include "G4KaonPlusInelasticProcess.hh"
>> 518 #include "G4KaonZeroSInelasticProcess.hh"
>> 519 #include "G4KaonZeroLInelasticProcess.hh"
>> 520 #include "G4KaonMinusInelasticProcess.hh"
>> 521 #include "G4ProtonInelasticProcess.hh"
>> 522 #include "G4AntiProtonInelasticProcess.hh"
>> 523 #include "G4NeutronInelasticProcess.hh"
>> 524 #include "G4AntiNeutronInelasticProcess.hh"
>> 525 #include "G4DeuteronInelasticProcess.hh"
>> 526 #include "G4TritonInelasticProcess.hh"
>> 527 #include "G4AlphaInelasticProcess.hh"
>> 528
>> 529 // High energy FTFP model and Bertini cascade
>> 530 #include "G4FTFModel.hh"
>> 531 #include "G4LundStringFragmentation.hh"
>> 532 #include "G4ExcitedStringDecay.hh"
>> 533 #include "G4PreCompoundModel.hh"
>> 534 #include "G4GeneratorPrecompoundInterface.hh"
>> 535 #include "G4TheoFSGenerator.hh"
>> 536 #include "G4CascadeInterface.hh"
>> 537
>> 538 // Cross sections
>> 539 #include "G4VCrossSectionDataSet.hh"
>> 540 #include "G4CrossSectionDataSetRegistry.hh"
>> 541
>> 542 #include "G4CrossSectionElastic.hh"
>> 543 #include "G4BGGPionElasticXS.hh"
>> 544 #include "G4AntiNuclElastic.hh"
>> 545
>> 546 #include "G4CrossSectionInelastic.hh"
>> 547 #include "G4PiNuclearCrossSection.hh"
>> 548 #include "G4CrossSectionPairGG.hh"
>> 549 #include "G4BGGNucleonInelasticXS.hh"
>> 550 #include "G4ComponentAntiNuclNuclearXS.hh"
>> 551 #include "G4ComponentGGNuclNuclXsc.hh"
>> 552
>> 553 #include "G4HadronElastic.hh"
>> 554 #include "G4HadronCaptureProcess.hh"
>> 555
>> 556 // Neutron high-precision models: <20 MeV
>> 557 #include "G4ParticleHPElastic.hh"
>> 558 #include "G4ParticleHPElasticData.hh"
>> 559 #include "G4ParticleHPCapture.hh"
>> 560 #include "G4ParticleHPCaptureData.hh"
>> 561 #include "G4ParticleHPInelastic.hh"
>> 562 #include "G4ParticleHPInelasticData.hh"
>> 563
>> 564 // Stopping processes
>> 565 #include "G4PiMinusAbsorptionBertini.hh"
>> 566 #include "G4KaonMinusAbsorptionBertini.hh"
>> 567 #include "G4AntiProtonAbsorptionFritiof.hh"
>> 568
>> 569
>> 570
514 void DMXPhysicsList::ConstructHad() 571 void DMXPhysicsList::ConstructHad()
515 { 572 {
516 //Elastic models 573 //Elastic models
>> 574 const G4double elastic_elimitPi = 1.0*GeV;
>> 575
517 G4HadronElastic* elastic_lhep0 = new G4Hadro 576 G4HadronElastic* elastic_lhep0 = new G4HadronElastic();
>> 577 G4HadronElastic* elastic_lhep1 = new G4HadronElastic();
>> 578 elastic_lhep1->SetMaxEnergy( elastic_elimitPi );
518 G4ChipsElasticModel* elastic_chip = new G4Ch 579 G4ChipsElasticModel* elastic_chip = new G4ChipsElasticModel();
519 G4ElasticHadrNucleusHE* elastic_he = new G4E 580 G4ElasticHadrNucleusHE* elastic_he = new G4ElasticHadrNucleusHE();
>> 581 elastic_he->SetMinEnergy( elastic_elimitPi );
>> 582
520 583
521 // Inelastic scattering 584 // Inelastic scattering
522 const G4double theFTFMin0 = 0.0*GeV; 585 const G4double theFTFMin0 = 0.0*GeV;
523 const G4double theFTFMin1 = 3.0*GeV; << 586 const G4double theFTFMin1 = 4.0*GeV;
524 const G4double theFTFMax = G4HadronicParamet << 587 const G4double theFTFMax = 100.0*TeV;
525 const G4double theBERTMin0 = 0.0*GeV; 588 const G4double theBERTMin0 = 0.0*GeV;
526 const G4double theBERTMin1 = 19.0*MeV; 589 const G4double theBERTMin1 = 19.0*MeV;
527 const G4double theBERTMax = 6.0*GeV; << 590 const G4double theBERTMax = 5.0*GeV;
528 const G4double theHPMin = 0.0*GeV; 591 const G4double theHPMin = 0.0*GeV;
529 const G4double theHPMax = 20.0*MeV; 592 const G4double theHPMax = 20.0*MeV;
530 593
531 G4FTFModel * theStringModel = new G4FTFModel 594 G4FTFModel * theStringModel = new G4FTFModel;
532 G4ExcitedStringDecay * theStringDecay = new 595 G4ExcitedStringDecay * theStringDecay = new G4ExcitedStringDecay( new G4LundStringFragmentation );
533 theStringModel->SetFragmentationModel( theSt 596 theStringModel->SetFragmentationModel( theStringDecay );
534 G4PreCompoundModel * thePreEquilib = new G4P 597 G4PreCompoundModel * thePreEquilib = new G4PreCompoundModel( new G4ExcitationHandler );
535 G4GeneratorPrecompoundInterface * theCascade 598 G4GeneratorPrecompoundInterface * theCascade = new G4GeneratorPrecompoundInterface( thePreEquilib );
536 599
537 G4TheoFSGenerator * theFTFModel0 = new G4The 600 G4TheoFSGenerator * theFTFModel0 = new G4TheoFSGenerator( "FTFP" );
538 theFTFModel0->SetHighEnergyGenerator( theStr 601 theFTFModel0->SetHighEnergyGenerator( theStringModel );
539 theFTFModel0->SetTransport( theCascade ); 602 theFTFModel0->SetTransport( theCascade );
540 theFTFModel0->SetMinEnergy( theFTFMin0 ); 603 theFTFModel0->SetMinEnergy( theFTFMin0 );
541 theFTFModel0->SetMaxEnergy( theFTFMax ); 604 theFTFModel0->SetMaxEnergy( theFTFMax );
542 605
543 G4TheoFSGenerator * theFTFModel1 = new G4The 606 G4TheoFSGenerator * theFTFModel1 = new G4TheoFSGenerator( "FTFP" );
544 theFTFModel1->SetHighEnergyGenerator( theStr 607 theFTFModel1->SetHighEnergyGenerator( theStringModel );
545 theFTFModel1->SetTransport( theCascade ); 608 theFTFModel1->SetTransport( theCascade );
546 theFTFModel1->SetMinEnergy( theFTFMin1 ); 609 theFTFModel1->SetMinEnergy( theFTFMin1 );
547 theFTFModel1->SetMaxEnergy( theFTFMax ); 610 theFTFModel1->SetMaxEnergy( theFTFMax );
548 611
549 G4CascadeInterface * theBERTModel0 = new G4C 612 G4CascadeInterface * theBERTModel0 = new G4CascadeInterface;
550 theBERTModel0->SetMinEnergy( theBERTMin0 ); 613 theBERTModel0->SetMinEnergy( theBERTMin0 );
551 theBERTModel0->SetMaxEnergy( theBERTMax ); 614 theBERTModel0->SetMaxEnergy( theBERTMax );
552 615
553 G4CascadeInterface * theBERTModel1 = new G4C 616 G4CascadeInterface * theBERTModel1 = new G4CascadeInterface;
554 theBERTModel1->SetMinEnergy( theBERTMin1 ); 617 theBERTModel1->SetMinEnergy( theBERTMin1 );
555 theBERTModel1->SetMaxEnergy( theBERTMax ); 618 theBERTModel1->SetMaxEnergy( theBERTMax );
556 619
>> 620 G4VCrossSectionDataSet * thePiData = new G4CrossSectionPairGG( new G4PiNuclearCrossSection, 91*GeV );
557 G4VCrossSectionDataSet * theAntiNucleonData 621 G4VCrossSectionDataSet * theAntiNucleonData = new G4CrossSectionInelastic( new G4ComponentAntiNuclNuclearXS );
558 G4ComponentGGNuclNuclXsc * ggNuclNuclXsec = 622 G4ComponentGGNuclNuclXsc * ggNuclNuclXsec = new G4ComponentGGNuclNuclXsc();
559 G4VCrossSectionDataSet * theGGNuclNuclData = 623 G4VCrossSectionDataSet * theGGNuclNuclData = new G4CrossSectionInelastic(ggNuclNuclXsec);
560 G4VCrossSectionDataSet * theGGNNEl = new G4C <<
561 G4ComponentGGHadronNucleusXsc * ggHNXsec = n <<
562 G4VCrossSectionDataSet * theGGHNEl = new G4C <<
563 G4VCrossSectionDataSet * theGGHNInel = new G <<
564 624
565 auto particleIterator=GetParticleIterator(); 625 auto particleIterator=GetParticleIterator();
566 particleIterator->reset(); 626 particleIterator->reset();
567 while ((*particleIterator)()) 627 while ((*particleIterator)())
568 { 628 {
569 G4ParticleDefinition* particle = particl 629 G4ParticleDefinition* particle = particleIterator->value();
570 G4ProcessManager* pmanager = particle->G 630 G4ProcessManager* pmanager = particle->GetProcessManager();
571 G4String particleName = particle->GetPar 631 G4String particleName = particle->GetParticleName();
572 632
573 if (particleName == "pi+") 633 if (particleName == "pi+")
574 { 634 {
575 // Elastic scattering 635 // Elastic scattering
576 G4HadronElasticProcess* theElasticPr 636 G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
577 theElasticProcess->AddDataSet( new G 637 theElasticProcess->AddDataSet( new G4BGGPionElasticXS( particle ) );
>> 638 theElasticProcess->RegisterMe( elastic_lhep1 );
578 theElasticProcess->RegisterMe( elast 639 theElasticProcess->RegisterMe( elastic_he );
579 pmanager->AddDiscreteProcess( theElasticPr 640 pmanager->AddDiscreteProcess( theElasticProcess );
580 //Inelastic scattering 641 //Inelastic scattering
581 G4HadronInelasticProcess* theInelasticProc << 642 G4PionPlusInelasticProcess* theInelasticProcess =
582 new G4HadronInelasticProcess( "inelastic << 643 new G4PionPlusInelasticProcess("inelastic");
583 theInelasticProcess->AddDataSet( new G4BGG << 644 theInelasticProcess->AddDataSet( thePiData );
584 theInelasticProcess->RegisterMe( theFTFMod 645 theInelasticProcess->RegisterMe( theFTFModel1 );
585 theInelasticProcess->RegisterMe( the 646 theInelasticProcess->RegisterMe( theBERTModel0 );
586 pmanager->AddDiscreteProcess( theInelastic 647 pmanager->AddDiscreteProcess( theInelasticProcess );
587 } 648 }
588 649
589 else if (particleName == "pi-") 650 else if (particleName == "pi-")
590 { 651 {
591 // Elastic scattering 652 // Elastic scattering
592 G4HadronElasticProcess* theElasticPr 653 G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
593 theElasticProcess->AddDataSet( new G 654 theElasticProcess->AddDataSet( new G4BGGPionElasticXS( particle ) );
>> 655 theElasticProcess->RegisterMe( elastic_lhep1 );
594 theElasticProcess->RegisterMe( elast 656 theElasticProcess->RegisterMe( elastic_he );
595 pmanager->AddDiscreteProcess( theElasticPr 657 pmanager->AddDiscreteProcess( theElasticProcess );
596 //Inelastic scattering 658 //Inelastic scattering
597 G4HadronInelasticProcess* theInelasticProc << 659 G4PionMinusInelasticProcess* theInelasticProcess =
598 new G4HadronInelasticProcess( "inelastic << 660 new G4PionMinusInelasticProcess("inelastic");
599 theInelasticProcess->AddDataSet( new G4BGG << 661 theInelasticProcess->AddDataSet( thePiData );
600 theInelasticProcess->RegisterMe( theFTFMod 662 theInelasticProcess->RegisterMe( theFTFModel1 );
601 theInelasticProcess->RegisterMe( the 663 theInelasticProcess->RegisterMe( theBERTModel0 );
602 pmanager->AddDiscreteProcess( theInelastic 664 pmanager->AddDiscreteProcess( theInelasticProcess );
603 //Absorption 665 //Absorption
604 pmanager->AddRestProcess(new G4HadronicAbs << 666 pmanager->AddRestProcess(new G4PiMinusAbsorptionBertini, ordDefault);
605 } 667 }
>> 668
606 else if (particleName == "kaon+") 669 else if (particleName == "kaon+")
607 { 670 {
608 // Elastic scattering 671 // Elastic scattering
609 G4HadronElasticProcess* theElasticPr 672 G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
610 theElasticProcess->AddDataSet( theGGHNEl ) <<
611 theElasticProcess->RegisterMe( elast 673 theElasticProcess->RegisterMe( elastic_lhep0 );
612 pmanager->AddDiscreteProcess( theElasticPr 674 pmanager->AddDiscreteProcess( theElasticProcess );
613 // Inelastic scattering 675 // Inelastic scattering
614 G4HadronInelasticProcess* theInelasticProc << 676 G4KaonPlusInelasticProcess* theInelasticProcess =
615 new G4HadronInelasticProcess( "inelastic << 677 new G4KaonPlusInelasticProcess("inelastic");
616 theInelasticProcess->AddDataSet( theGGHNIn << 678 theInelasticProcess->AddDataSet( G4CrossSectionDataSetRegistry::Instance()->
>> 679 GetCrossSectionDataSet(G4ChipsKaonPlusInelasticXS::Default_Name()));
617 theInelasticProcess->RegisterMe( theFTFMod 680 theInelasticProcess->RegisterMe( theFTFModel1 );
618 theInelasticProcess->RegisterMe( the 681 theInelasticProcess->RegisterMe( theBERTModel0 );
619 pmanager->AddDiscreteProcess( theInelastic 682 pmanager->AddDiscreteProcess( theInelasticProcess );
620 } << 683 }
>> 684
621 else if (particleName == "kaon0S") 685 else if (particleName == "kaon0S")
622 { 686 {
623 // Elastic scattering 687 // Elastic scattering
624 G4HadronElasticProcess* theElasticPr 688 G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
625 theElasticProcess->AddDataSet( theGGHNEl ) <<
626 theElasticProcess->RegisterMe( elast 689 theElasticProcess->RegisterMe( elastic_lhep0 );
627 pmanager->AddDiscreteProcess( theElasticPr 690 pmanager->AddDiscreteProcess( theElasticProcess );
628 // Inelastic scattering 691 // Inelastic scattering
629 G4HadronInelasticProcess* theInelasticProc << 692 G4KaonZeroSInelasticProcess* theInelasticProcess =
630 new G4HadronInelasticProcess( "inelastic << 693 new G4KaonZeroSInelasticProcess("inelastic");
631 theInelasticProcess->AddDataSet( theGGHNIn << 694 theInelasticProcess->AddDataSet( G4CrossSectionDataSetRegistry::Instance()->
>> 695 GetCrossSectionDataSet(G4ChipsKaonZeroInelasticXS::Default_Name()));
632 theInelasticProcess->RegisterMe( theFTFMod 696 theInelasticProcess->RegisterMe( theFTFModel1 );
633 theInelasticProcess->RegisterMe( the 697 theInelasticProcess->RegisterMe( theBERTModel0 );
634 pmanager->AddDiscreteProcess( theInelastic 698 pmanager->AddDiscreteProcess( theInelasticProcess );
635 } 699 }
636 700
637 else if (particleName == "kaon0L") 701 else if (particleName == "kaon0L")
638 { 702 {
639 // Elastic scattering 703 // Elastic scattering
640 G4HadronElasticProcess* theElasticPr 704 G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
641 theElasticProcess->AddDataSet( theGGHNEl ) <<
642 theElasticProcess->RegisterMe( elast 705 theElasticProcess->RegisterMe( elastic_lhep0 );
643 pmanager->AddDiscreteProcess( theElasticPr 706 pmanager->AddDiscreteProcess( theElasticProcess );
644 // Inelastic scattering 707 // Inelastic scattering
645 G4HadronInelasticProcess* theInelasticProc << 708 G4KaonZeroLInelasticProcess* theInelasticProcess =
646 new G4HadronInelasticProcess( "inelastic << 709 new G4KaonZeroLInelasticProcess("inelastic");
647 theInelasticProcess->AddDataSet( theGGHNIn << 710 theInelasticProcess->AddDataSet( G4CrossSectionDataSetRegistry::Instance()->
>> 711 GetCrossSectionDataSet(G4ChipsKaonZeroInelasticXS::Default_Name()));
648 theInelasticProcess->RegisterMe( theFTFMod 712 theInelasticProcess->RegisterMe( theFTFModel1 );
649 theInelasticProcess->RegisterMe( the 713 theInelasticProcess->RegisterMe( theBERTModel0 );
650 pmanager->AddDiscreteProcess( theInelastic 714 pmanager->AddDiscreteProcess( theInelasticProcess );
651 } 715 }
652 716
653 else if (particleName == "kaon-") 717 else if (particleName == "kaon-")
654 { 718 {
655 // Elastic scattering 719 // Elastic scattering
656 G4HadronElasticProcess* theElasticPr 720 G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
657 theElasticProcess->AddDataSet( theGGHNEl ) <<
658 theElasticProcess->RegisterMe( elast 721 theElasticProcess->RegisterMe( elastic_lhep0 );
659 pmanager->AddDiscreteProcess( theElasticPr 722 pmanager->AddDiscreteProcess( theElasticProcess );
660 // Inelastic scattering 723 // Inelastic scattering
661 G4HadronInelasticProcess* theInelasticProc << 724 G4KaonMinusInelasticProcess* theInelasticProcess =
662 new G4HadronInelasticProcess( "inelastic << 725 new G4KaonMinusInelasticProcess("inelastic");
663 theInelasticProcess->AddDataSet( the << 726 theInelasticProcess->AddDataSet( G4CrossSectionDataSetRegistry::Instance()->
>> 727 GetCrossSectionDataSet(G4ChipsKaonMinusInelasticXS::Default_Name()));
664 theInelasticProcess->RegisterMe( theFTFMod 728 theInelasticProcess->RegisterMe( theFTFModel1 );
665 theInelasticProcess->RegisterMe( the 729 theInelasticProcess->RegisterMe( theBERTModel0 );
666 pmanager->AddDiscreteProcess( theInelastic 730 pmanager->AddDiscreteProcess( theInelasticProcess );
667 pmanager->AddRestProcess(new G4HadronicAbs << 731 pmanager->AddRestProcess(new G4KaonMinusAbsorptionBertini, ordDefault);
668 } 732 }
669 733
670 else if (particleName == "proton") 734 else if (particleName == "proton")
671 { 735 {
672 // Elastic scattering 736 // Elastic scattering
673 G4HadronElasticProcess* theElasticPr 737 G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
674 theElasticProcess->AddDataSet( new G << 738 theElasticProcess->AddDataSet(G4CrossSectionDataSetRegistry::Instance()->
>> 739 GetCrossSectionDataSet(G4ChipsProtonElasticXS::Default_Name()));
675 theElasticProcess->RegisterMe( elast 740 theElasticProcess->RegisterMe( elastic_chip );
676 pmanager->AddDiscreteProcess( theElasticPr 741 pmanager->AddDiscreteProcess( theElasticProcess );
677 // Inelastic scattering 742 // Inelastic scattering
678 G4HadronInelasticProcess* theInelasticProc << 743 G4ProtonInelasticProcess* theInelasticProcess =
679 new G4HadronInelasticProcess( "inelastic << 744 new G4ProtonInelasticProcess("inelastic");
680 theInelasticProcess->AddDataSet( new G4BGG 745 theInelasticProcess->AddDataSet( new G4BGGNucleonInelasticXS( G4Proton::Proton() ) );
681 theInelasticProcess->RegisterMe( theFTFMod 746 theInelasticProcess->RegisterMe( theFTFModel1 );
682 theInelasticProcess->RegisterMe( the 747 theInelasticProcess->RegisterMe( theBERTModel0 );
683 pmanager->AddDiscreteProcess( theInelastic 748 pmanager->AddDiscreteProcess( theInelasticProcess );
684 } 749 }
685 else if (particleName == "anti_proton") 750 else if (particleName == "anti_proton")
686 { 751 {
687 // Elastic scattering 752 // Elastic scattering
688 const G4double elastic_elimitAntiNuc 753 const G4double elastic_elimitAntiNuc = 100.0*MeV;
689 G4AntiNuclElastic* elastic_anuc = ne 754 G4AntiNuclElastic* elastic_anuc = new G4AntiNuclElastic();
690 elastic_anuc->SetMinEnergy( elastic_ 755 elastic_anuc->SetMinEnergy( elastic_elimitAntiNuc );
691 G4CrossSectionElastic* elastic_anucx 756 G4CrossSectionElastic* elastic_anucxs = new G4CrossSectionElastic( elastic_anuc->GetComponentCrossSection() );
692 G4HadronElastic* elastic_lhep2 = new 757 G4HadronElastic* elastic_lhep2 = new G4HadronElastic();
693 elastic_lhep2->SetMaxEnergy( elastic 758 elastic_lhep2->SetMaxEnergy( elastic_elimitAntiNuc );
694 G4HadronElasticProcess* theElasticPr 759 G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
695 theElasticProcess->AddDataSet( elast 760 theElasticProcess->AddDataSet( elastic_anucxs );
696 theElasticProcess->RegisterMe( elast 761 theElasticProcess->RegisterMe( elastic_lhep2 );
697 theElasticProcess->RegisterMe( elast 762 theElasticProcess->RegisterMe( elastic_anuc );
698 pmanager->AddDiscreteProcess( theElasticPr 763 pmanager->AddDiscreteProcess( theElasticProcess );
699 // Inelastic scattering 764 // Inelastic scattering
700 G4HadronInelasticProcess* theInelasticProc << 765 G4AntiProtonInelasticProcess* theInelasticProcess =
701 new G4HadronInelasticProcess( "inelastic << 766 new G4AntiProtonInelasticProcess("inelastic");
702 theInelasticProcess->AddDataSet( theAntiNu 767 theInelasticProcess->AddDataSet( theAntiNucleonData );
703 theInelasticProcess->RegisterMe( theFTFMod 768 theInelasticProcess->RegisterMe( theFTFModel0 );
704 pmanager->AddDiscreteProcess( theInelastic 769 pmanager->AddDiscreteProcess( theInelasticProcess );
705 // Absorption 770 // Absorption
706 pmanager->AddRestProcess(new G4HadronicAbs << 771 pmanager->AddRestProcess(new G4AntiProtonAbsorptionFritiof, ordDefault);
707 } 772 }
>> 773
708 else if (particleName == "neutron") { 774 else if (particleName == "neutron") {
709 // elastic scattering 775 // elastic scattering
710 G4HadronElasticProcess* theElasticProcess = 776 G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
711 theElasticProcess->AddDataSet(new G4Ne << 777 theElasticProcess->AddDataSet(G4CrossSectionDataSetRegistry::Instance()->GetCrossSectionDataSet(G4ChipsNeutronElasticXS::Default_Name()));
712 G4HadronElastic* elastic_neutronChipsM 778 G4HadronElastic* elastic_neutronChipsModel = new G4ChipsElasticModel();
713 elastic_neutronChipsModel->SetMinEnergy( 19. 779 elastic_neutronChipsModel->SetMinEnergy( 19.0*MeV );
714 theElasticProcess->RegisterMe( elastic 780 theElasticProcess->RegisterMe( elastic_neutronChipsModel );
715 G4ParticleHPElastic * theElasticNeutronHP = 781 G4ParticleHPElastic * theElasticNeutronHP = new G4ParticleHPElastic;
716 theElasticNeutronHP->SetMinEnergy( the 782 theElasticNeutronHP->SetMinEnergy( theHPMin );
717 theElasticNeutronHP->SetMaxEnergy( the 783 theElasticNeutronHP->SetMaxEnergy( theHPMax );
718 theElasticProcess->RegisterMe( theElasticNeu 784 theElasticProcess->RegisterMe( theElasticNeutronHP );
719 theElasticProcess->AddDataSet( new G4Particl 785 theElasticProcess->AddDataSet( new G4ParticleHPElasticData );
720 pmanager->AddDiscreteProcess( theElasticProc 786 pmanager->AddDiscreteProcess( theElasticProcess );
721 // inelastic scattering 787 // inelastic scattering
722 G4HadronInelasticProcess* theInelasticProces << 788 G4NeutronInelasticProcess* theInelasticProcess =
723 new G4HadronInelasticProcess( "inelastic", << 789 new G4NeutronInelasticProcess("inelastic");
724 theInelasticProcess->AddDataSet( new G4Neutr << 790 theInelasticProcess->AddDataSet( new G4BGGNucleonInelasticXS( G4Neutron::Neutron() ) );
725 theInelasticProcess->RegisterMe( theFTFModel 791 theInelasticProcess->RegisterMe( theFTFModel1 );
726 theInelasticProcess->RegisterMe( theBE 792 theInelasticProcess->RegisterMe( theBERTModel1 );
727 G4ParticleHPInelastic * theNeutronInelasticH 793 G4ParticleHPInelastic * theNeutronInelasticHPModel = new G4ParticleHPInelastic;
728 theNeutronInelasticHPModel->SetMinEner 794 theNeutronInelasticHPModel->SetMinEnergy( theHPMin );
729 theNeutronInelasticHPModel->SetMaxEner 795 theNeutronInelasticHPModel->SetMaxEnergy( theHPMax );
730 theInelasticProcess->RegisterMe( theNeutronI 796 theInelasticProcess->RegisterMe( theNeutronInelasticHPModel );
731 theInelasticProcess->AddDataSet( new G4Parti 797 theInelasticProcess->AddDataSet( new G4ParticleHPInelasticData );
732 pmanager->AddDiscreteProcess(theInelasticPro 798 pmanager->AddDiscreteProcess(theInelasticProcess);
733 // capture 799 // capture
734 G4NeutronCaptureProcess* theCaptureProcess = << 800 G4HadronCaptureProcess* theCaptureProcess =
735 new G4NeutronCaptureProcess; << 801 new G4HadronCaptureProcess;
736 G4ParticleHPCapture * theLENeutronCaptureMod 802 G4ParticleHPCapture * theLENeutronCaptureModel = new G4ParticleHPCapture;
737 theLENeutronCaptureModel->SetMinEnergy(theHP 803 theLENeutronCaptureModel->SetMinEnergy(theHPMin);
738 theLENeutronCaptureModel->SetMaxEnergy(theHP 804 theLENeutronCaptureModel->SetMaxEnergy(theHPMax);
739 theCaptureProcess->RegisterMe(theLENeutronCa 805 theCaptureProcess->RegisterMe(theLENeutronCaptureModel);
740 theCaptureProcess->AddDataSet( new G4Particl 806 theCaptureProcess->AddDataSet( new G4ParticleHPCaptureData);
741 pmanager->AddDiscreteProcess(theCaptureProce 807 pmanager->AddDiscreteProcess(theCaptureProcess);
>> 808
742 } 809 }
743 else if (particleName == "anti_neutron") 810 else if (particleName == "anti_neutron")
744 { 811 {
745 // Elastic scattering 812 // Elastic scattering
746 G4HadronElasticProcess* theElasticPr 813 G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
747 theElasticProcess->AddDataSet( theGGHNEl ) <<
748 theElasticProcess->RegisterMe( elast 814 theElasticProcess->RegisterMe( elastic_lhep0 );
749 pmanager->AddDiscreteProcess( theElasticPr 815 pmanager->AddDiscreteProcess( theElasticProcess );
750 // Inelastic scattering (include ann 816 // Inelastic scattering (include annihilation on-fly)
751 G4HadronInelasticProcess* theInelasticProc << 817 G4AntiNeutronInelasticProcess* theInelasticProcess =
752 new G4HadronInelasticProcess( "inelastic << 818 new G4AntiNeutronInelasticProcess("inelastic");
753 theInelasticProcess->AddDataSet( theAntiNu 819 theInelasticProcess->AddDataSet( theAntiNucleonData );
754 theInelasticProcess->RegisterMe( theFTFMod 820 theInelasticProcess->RegisterMe( theFTFModel0 );
755 pmanager->AddDiscreteProcess( theInelastic 821 pmanager->AddDiscreteProcess( theInelasticProcess );
756 } 822 }
>> 823
757 else if (particleName == "deuteron") 824 else if (particleName == "deuteron")
758 { 825 {
759 // Elastic scattering 826 // Elastic scattering
760 G4HadronElasticProcess* theElasticPr 827 G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
761 theElasticProcess->AddDataSet( theGGNNEl ) <<
762 theElasticProcess->RegisterMe( elast 828 theElasticProcess->RegisterMe( elastic_lhep0 );
763 pmanager->AddDiscreteProcess( theElasticPr 829 pmanager->AddDiscreteProcess( theElasticProcess );
764 // Inelastic scattering 830 // Inelastic scattering
765 G4HadronInelasticProcess* theInelasticProc << 831 G4DeuteronInelasticProcess* theInelasticProcess =
766 new G4HadronInelasticProcess( "inelastic << 832 new G4DeuteronInelasticProcess("inelastic");
767 theInelasticProcess->AddDataSet( theGGNucl 833 theInelasticProcess->AddDataSet( theGGNuclNuclData );
768 theInelasticProcess->RegisterMe( theFTFMod 834 theInelasticProcess->RegisterMe( theFTFModel1 );
769 theInelasticProcess->RegisterMe( the 835 theInelasticProcess->RegisterMe( theBERTModel0 );
770 pmanager->AddDiscreteProcess( theInelastic 836 pmanager->AddDiscreteProcess( theInelasticProcess );
771 } 837 }
>> 838
772 else if (particleName == "triton") 839 else if (particleName == "triton")
773 { 840 {
774 // Elastic scattering 841 // Elastic scattering
775 G4HadronElasticProcess* theElasticPr 842 G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
776 theElasticProcess->AddDataSet( theGGNNEl ) <<
777 theElasticProcess->RegisterMe( elast 843 theElasticProcess->RegisterMe( elastic_lhep0 );
778 pmanager->AddDiscreteProcess( theElasticPr 844 pmanager->AddDiscreteProcess( theElasticProcess );
779 // Inelastic scattering 845 // Inelastic scattering
780 G4HadronInelasticProcess* theInelasticProc << 846 G4TritonInelasticProcess* theInelasticProcess =
781 new G4HadronInelasticProcess( "inelastic << 847 new G4TritonInelasticProcess("inelastic");
782 theInelasticProcess->AddDataSet( theGGNucl 848 theInelasticProcess->AddDataSet( theGGNuclNuclData );
783 theInelasticProcess->RegisterMe( theFTFMod 849 theInelasticProcess->RegisterMe( theFTFModel1 );
784 theInelasticProcess->RegisterMe( the 850 theInelasticProcess->RegisterMe( theBERTModel0 );
785 pmanager->AddDiscreteProcess( theInelastic 851 pmanager->AddDiscreteProcess( theInelasticProcess );
786 } 852 }
787 else if (particleName == "alpha") 853 else if (particleName == "alpha")
788 { 854 {
789 // Elastic scattering 855 // Elastic scattering
790 G4HadronElasticProcess* theElasticPr 856 G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
791 theElasticProcess->AddDataSet( theGGNNEl ) <<
792 theElasticProcess->RegisterMe( elast 857 theElasticProcess->RegisterMe( elastic_lhep0 );
793 pmanager->AddDiscreteProcess( theElasticPr 858 pmanager->AddDiscreteProcess( theElasticProcess );
794 // Inelastic scattering 859 // Inelastic scattering
795 G4HadronInelasticProcess* theInelasticProc << 860 G4AlphaInelasticProcess* theInelasticProcess =
796 new G4HadronInelasticProcess( "inelastic << 861 new G4AlphaInelasticProcess("inelastic");
797 theInelasticProcess->AddDataSet( the 862 theInelasticProcess->AddDataSet( theGGNuclNuclData );
798 theInelasticProcess->RegisterMe( theFTFMod 863 theInelasticProcess->RegisterMe( theFTFModel1 );
799 theInelasticProcess->RegisterMe( the 864 theInelasticProcess->RegisterMe( theBERTModel0 );
800 pmanager->AddDiscreteProcess( theInelastic 865 pmanager->AddDiscreteProcess( theInelasticProcess );
801 } 866 }
>> 867
802 } 868 }
803 } 869 }
804 870
>> 871
805 // Decays //////////////////////////////////// 872 // Decays ///////////////////////////////////////////////////////////////////
>> 873 #include "G4Decay.hh"
>> 874 #include "G4RadioactiveDecay.hh"
>> 875 #include "G4IonTable.hh"
>> 876 #include "G4Ions.hh"
>> 877
806 void DMXPhysicsList::ConstructGeneral() { 878 void DMXPhysicsList::ConstructGeneral() {
807 879
808 // Add Decay Process 880 // Add Decay Process
809 G4Decay* theDecayProcess = new G4Decay(); 881 G4Decay* theDecayProcess = new G4Decay();
810 auto particleIterator=GetParticleIterator(); 882 auto particleIterator=GetParticleIterator();
811 particleIterator->reset(); 883 particleIterator->reset();
812 while( (*particleIterator)() ) 884 while( (*particleIterator)() )
813 { 885 {
814 G4ParticleDefinition* particle = particl 886 G4ParticleDefinition* particle = particleIterator->value();
815 G4ProcessManager* pmanager = particle->G 887 G4ProcessManager* pmanager = particle->GetProcessManager();
816 888
817 if (theDecayProcess->IsApplicable(*parti 889 if (theDecayProcess->IsApplicable(*particle) && !particle->IsShortLived())
818 { 890 {
819 pmanager ->AddProcess(theDecayProcess); 891 pmanager ->AddProcess(theDecayProcess);
820 // set ordering for PostStepDoIt and AtRes 892 // set ordering for PostStepDoIt and AtRestDoIt
821 pmanager ->SetProcessOrdering(theDecayProc 893 pmanager ->SetProcessOrdering(theDecayProcess, idxPostStep);
822 pmanager ->SetProcessOrdering(theDecayProc 894 pmanager ->SetProcessOrdering(theDecayProcess, idxAtRest);
823 } 895 }
824 } 896 }
825 897
826 // Declare radioactive decay to the GenericI 898 // Declare radioactive decay to the GenericIon in the IonTable.
827 G4LossTableManager* man = G4LossTableManager << 899 const G4IonTable *theIonTable =
828 G4VAtomDeexcitation* ad = man->AtomDeexcitat << 900 G4ParticleTable::GetParticleTable()->GetIonTable();
829 if(!ad) { << 901 G4RadioactiveDecay *theRadioactiveDecay = new G4RadioactiveDecay();
830 G4EmParameters::Instance()->SetAugerCascad <<
831 ad = new G4UAtomicDeexcitation(); <<
832 man->SetAtomDeexcitation(ad); <<
833 ad->InitialiseAtomicDeexcitation(); <<
834 } <<
835 902
836 G4PhysicsListHelper::GetPhysicsListHelper()- << 903 for (G4int i=0; i<theIonTable->Entries(); i++)
837 RegisterProcess(new G4RadioactiveDecay(), << 904 {
>> 905 G4String particleName = theIonTable->GetParticle(i)->GetParticleName();
>> 906 G4String particleType = theIonTable->GetParticle(i)->GetParticleType();
>> 907
>> 908 if (particleName == "GenericIon")
>> 909 {
>> 910 G4ProcessManager* pmanager =
>> 911 theIonTable->GetParticle(i)->GetProcessManager();
>> 912 pmanager->SetVerboseLevel(VerboseLevel);
>> 913 pmanager ->AddProcess(theRadioactiveDecay);
>> 914 pmanager ->SetProcessOrdering(theRadioactiveDecay, idxPostStep);
>> 915 pmanager ->SetProcessOrdering(theRadioactiveDecay, idxAtRest);
>> 916 }
>> 917 }
838 } 918 }
839 919
840 // Cuts ////////////////////////////////////// 920 // Cuts /////////////////////////////////////////////////////////////////////
841 void DMXPhysicsList::SetCuts() 921 void DMXPhysicsList::SetCuts()
842 { 922 {
843 923
844 if (verboseLevel >1) 924 if (verboseLevel >1)
845 G4cout << "DMXPhysicsList::SetCuts:"; 925 G4cout << "DMXPhysicsList::SetCuts:";
846 926
847 if (verboseLevel>0){ 927 if (verboseLevel>0){
848 G4cout << "DMXPhysicsList::SetCuts:"; 928 G4cout << "DMXPhysicsList::SetCuts:";
849 G4cout << "CutLength : " 929 G4cout << "CutLength : "
850 << G4BestUnit(defaultCutValue,"Length") < 930 << G4BestUnit(defaultCutValue,"Length") << G4endl;
851 } 931 }
852 932
853 //special for low energy physics 933 //special for low energy physics
854 G4double lowlimit=250*eV; 934 G4double lowlimit=250*eV;
855 G4ProductionCutsTable::GetProductionCutsTabl 935 G4ProductionCutsTable::GetProductionCutsTable()->SetEnergyRange(lowlimit,100.*GeV);
856 936
857 // set cut values for gamma at first and for 937 // set cut values for gamma at first and for e- second and next for e+,
858 // because some processes for e+/e- need cut 938 // because some processes for e+/e- need cut values for gamma
859 SetCutValue(cutForGamma, "gamma"); 939 SetCutValue(cutForGamma, "gamma");
860 SetCutValue(cutForElectron, "e-"); 940 SetCutValue(cutForElectron, "e-");
861 SetCutValue(cutForPositron, "e+"); 941 SetCutValue(cutForPositron, "e+");
862 942
863 if (verboseLevel>0) DumpCutValuesTable(); 943 if (verboseLevel>0) DumpCutValuesTable();
864 } 944 }
865 945
866 946