| 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 28
29 //....oooOO0OOooo........oooOO0OOooo........oo 29 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
30 30
31 #include "PhysicsList.hh" 31 #include "PhysicsList.hh"
32 #include "G4SystemOfUnits.hh" 32 #include "G4SystemOfUnits.hh"
33 33
34 // Geant4-MicroElec MODELS <<
35 <<
36 #include "G4MicroElecElastic.hh" <<
37 #include "G4MicroElecElasticModel.hh" <<
38 <<
39 #include "G4MicroElecInelastic.hh" <<
40 #include "G4MicroElecInelasticModel.hh" <<
41 // <<
42 <<
43 #include "G4LossTableManager.hh" <<
44 #include "G4EmConfigurator.hh" <<
45 #include "G4VEmModel.hh" <<
46 #include "G4DummyModel.hh" <<
47 #include "G4eIonisation.hh" <<
48 #include "G4hIonisation.hh" <<
49 #include "G4ionIonisation.hh" <<
50 #include "G4eMultipleScattering.hh" <<
51 #include "G4hMultipleScattering.hh" <<
52 #include "G4BraggModel.hh" <<
53 #include "G4BraggIonModel.hh" <<
54 #include "G4BetheBlochModel.hh" <<
55 #include "G4UrbanMscModel.hh" <<
56 #include "G4MollerBhabhaModel.hh" <<
57 #include "G4IonFluctuations.hh" <<
58 #include "G4UniversalFluctuation.hh" <<
59 <<
60 #include "G4ElectronCapture.hh" <<
61 <<
62 #include "G4UAtomicDeexcitation.hh" <<
63 <<
64 //....oooOO0OOooo........oooOO0OOooo........oo 34 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
65 35
66 PhysicsList::PhysicsList(): G4VUserPhysicsLis 36 PhysicsList::PhysicsList(): G4VUserPhysicsList()
67 { 37 {
68 defaultCutValue = 1*micrometer; 38 defaultCutValue = 1*micrometer;
69 cutForGamma = defaultCutValue; 39 cutForGamma = defaultCutValue;
70 cutForElectron = defaultCutValue; 40 cutForElectron = defaultCutValue;
71 cutForPositron = defaultCutValue; 41 cutForPositron = defaultCutValue;
72 cutForProton = defaultCutValue; 42 cutForProton = defaultCutValue;
73 43
74 SetVerboseLevel(1); 44 SetVerboseLevel(1);
75 } 45 }
76 46
77 //....oooOO0OOooo........oooOO0OOooo........oo 47 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
78 48
79 PhysicsList::~PhysicsList() 49 PhysicsList::~PhysicsList()
80 {} 50 {}
81 51
82 //....oooOO0OOooo........oooOO0OOooo........oo 52 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
83 53
84 void PhysicsList::ConstructParticle() 54 void PhysicsList::ConstructParticle()
85 { 55 {
86 ConstructBosons(); 56 ConstructBosons();
87 ConstructLeptons(); 57 ConstructLeptons();
88 ConstructBarions(); 58 ConstructBarions();
89 } 59 }
90 60
91 //....oooOO0OOooo........oooOO0OOooo........oo 61 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
92 62
93 void PhysicsList::ConstructBosons() 63 void PhysicsList::ConstructBosons()
94 { 64 {
95 // gamma 65 // gamma
96 G4Gamma::GammaDefinition(); 66 G4Gamma::GammaDefinition();
97 } 67 }
98 //....oooOO0OOooo........oooOO0OOooo........o 68 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
99 69
100 void PhysicsList::ConstructLeptons() 70 void PhysicsList::ConstructLeptons()
101 { 71 {
102 // leptons 72 // leptons
103 G4Electron::ElectronDefinition(); 73 G4Electron::ElectronDefinition();
104 G4Positron::PositronDefinition(); 74 G4Positron::PositronDefinition();
105 } 75 }
106 76
107 //....oooOO0OOooo........oooOO0OOooo........oo 77 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
108 78
109 void PhysicsList::ConstructBarions() 79 void PhysicsList::ConstructBarions()
110 { 80 {
111 // baryons 81 // baryons
112 G4Proton::ProtonDefinition(); 82 G4Proton::ProtonDefinition();
113 G4GenericIon::GenericIonDefinition(); 83 G4GenericIon::GenericIonDefinition();
114 } 84 }
115 85
116 //....oooOO0OOooo........oooOO0OOooo........oo 86 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
117 87
118 void PhysicsList::ConstructProcess() 88 void PhysicsList::ConstructProcess()
119 { 89 {
120 AddTransportation(); 90 AddTransportation();
121 ConstructEM(); 91 ConstructEM();
122 ConstructGeneral(); 92 ConstructGeneral();
123 } 93 }
124 94
125 //....oooOO0OOooo........oooOO0OOooo........oo 95 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
126 96
>> 97 // Geant4-MicroElec MODELS
>> 98
>> 99 #include "G4MicroElecElastic.hh"
>> 100 #include "G4MicroElecElasticModel.hh"
>> 101
>> 102 #include "G4MicroElecInelastic.hh"
>> 103 #include "G4MicroElecInelasticModel.hh"
>> 104 //
>> 105
>> 106 #include "G4LossTableManager.hh"
>> 107 #include "G4EmConfigurator.hh"
>> 108 #include "G4VEmModel.hh"
>> 109 #include "G4DummyModel.hh"
>> 110 #include "G4eIonisation.hh"
>> 111 #include "G4hIonisation.hh"
>> 112 #include "G4ionIonisation.hh"
>> 113 #include "G4eMultipleScattering.hh"
>> 114 #include "G4hMultipleScattering.hh"
>> 115 #include "G4BraggModel.hh"
>> 116 #include "G4BraggIonModel.hh"
>> 117 #include "G4BetheBlochModel.hh"
>> 118 #include "G4UrbanMscModel.hh"
>> 119 #include "G4MollerBhabhaModel.hh"
>> 120 #include "G4IonFluctuations.hh"
>> 121 #include "G4UniversalFluctuation.hh"
>> 122
>> 123 #include "G4ElectronCapture.hh"
>> 124
>> 125 #include "G4UAtomicDeexcitation.hh"
>> 126
>> 127 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
>> 128
127 void PhysicsList::ConstructEM() 129 void PhysicsList::ConstructEM()
128 { 130 {
129 131
130 auto particleIterator=GetParticleIterator(); 132 auto particleIterator=GetParticleIterator();
131 particleIterator->reset(); 133 particleIterator->reset();
132 134
133 while( (*particleIterator)() ) 135 while( (*particleIterator)() )
134 { 136 {
135 137
136 G4ParticleDefinition* particle = particleI 138 G4ParticleDefinition* particle = particleIterator->value();
137 G4ProcessManager* pmanager = particle->Get 139 G4ProcessManager* pmanager = particle->GetProcessManager();
138 G4String particleName = particle->GetParti 140 G4String particleName = particle->GetParticleName();
139 141
140 // ********************************* 142 // *********************************
141 // 1) Processes for the World region 143 // 1) Processes for the World region
142 // ********************************* 144 // *********************************
143 145
144 if (particleName == "e-") { 146 if (particleName == "e-") {
145 147
146 // STANDARD msc is active in the world 148 // STANDARD msc is active in the world
147 G4eMultipleScattering* msc = new G4eMult 149 G4eMultipleScattering* msc = new G4eMultipleScattering();
148 msc->AddEmModel(1, new G4UrbanMscModel() 150 msc->AddEmModel(1, new G4UrbanMscModel());
149 pmanager->AddProcess(msc, -1, 1, -1); 151 pmanager->AddProcess(msc, -1, 1, -1);
150 152
151 // STANDARD ionisation is active in the 153 // STANDARD ionisation is active in the world
152 G4eIonisation* eion = new G4eIonisation( 154 G4eIonisation* eion = new G4eIonisation();
153 pmanager->AddProcess(eion, -1, 2, 2); 155 pmanager->AddProcess(eion, -1, 2, 2);
154 156
155 // MicroElec elastic is not active in th 157 // MicroElec elastic is not active in the world
156 G4MicroElecElastic* theMicroElecElasticP 158 G4MicroElecElastic* theMicroElecElasticProcess = new G4MicroElecElastic("e-_G4MicroElecElastic");
157 theMicroElecElasticProcess->SetEmModel(n << 159 theMicroElecElasticProcess->SetEmModel(new G4DummyModel(),1);
158 pmanager->AddDiscreteProcess(theMicroEle 160 pmanager->AddDiscreteProcess(theMicroElecElasticProcess);
159 161
160 // MicroElec ionisation is not active in 162 // MicroElec ionisation is not active in the world
161 G4MicroElecInelastic* microelecioni = ne 163 G4MicroElecInelastic* microelecioni = new G4MicroElecInelastic("e-_G4MicroElecInelastic");
162 microelecioni->SetEmModel(new G4DummyMod << 164 microelecioni->SetEmModel(new G4DummyModel(),1);
163 pmanager->AddDiscreteProcess(microelecio 165 pmanager->AddDiscreteProcess(microelecioni);
164 166
165 // THE FOLLOWING PROCESS WILL KILL ALL E 167 // THE FOLLOWING PROCESS WILL KILL ALL ELECTRONS BELOW A SELECTED ENERY THRESHOLD
166 // Capture of low-energy e- 168 // Capture of low-energy e-
167 G4ElectronCapture* ecap = new G4Electron 169 G4ElectronCapture* ecap = new G4ElectronCapture("Target", 16.7*eV);
168 pmanager->AddDiscreteProcess(ecap); 170 pmanager->AddDiscreteProcess(ecap);
169 171
170 } else if ( particleName == "proton" ) { 172 } else if ( particleName == "proton" ) {
171 173
172 // STANDARD msc is active in the world 174 // STANDARD msc is active in the world
173 G4hMultipleScattering* msc = new G4hMult 175 G4hMultipleScattering* msc = new G4hMultipleScattering();
174 msc->AddEmModel(1, new G4UrbanMscModel() 176 msc->AddEmModel(1, new G4UrbanMscModel());
175 pmanager->AddProcess(msc, -1, 1, -1); 177 pmanager->AddProcess(msc, -1, 1, -1);
176 178
177 // STANDARD ionisation is active in the 179 // STANDARD ionisation is active in the world
178 G4hIonisation* hion = new G4hIonisation( 180 G4hIonisation* hion = new G4hIonisation();
179 pmanager->AddProcess(hion, -1, 2, 2); 181 pmanager->AddProcess(hion, -1, 2, 2);
180 182
181 // MicroElec ionisation is not active in 183 // MicroElec ionisation is not active in the world
182 G4MicroElecInelastic* microelecioni = ne 184 G4MicroElecInelastic* microelecioni = new G4MicroElecInelastic("p_G4MicroElecInelastic");
183 microelecioni->SetEmModel(new G4DummyMod << 185 microelecioni->SetEmModel(new G4DummyModel(),1);
184 microelecioni->SetEmModel(new G4DummyMod << 186 microelecioni->SetEmModel(new G4DummyModel(),2);
185 pmanager->AddDiscreteProcess(microelecio 187 pmanager->AddDiscreteProcess(microelecioni);
186 188
187 } else if (particleName == "GenericIon") { 189 } else if (particleName == "GenericIon") {
188 190
189 // STANDARD msc is active in the world 191 // STANDARD msc is active in the world
190 G4hMultipleScattering* msc = new G4hMult 192 G4hMultipleScattering* msc = new G4hMultipleScattering();
191 msc->AddEmModel(1, new G4UrbanMscModel() 193 msc->AddEmModel(1, new G4UrbanMscModel());
192 pmanager->AddProcess(new G4hMultipleScat 194 pmanager->AddProcess(new G4hMultipleScattering, -1, 1, -1);
193 195
194 // STANDARD ionisation is active in the 196 // STANDARD ionisation is active in the world
195 G4ionIonisation* hion = new G4ionIonisat 197 G4ionIonisation* hion = new G4ionIonisation();
196 pmanager->AddProcess(hion, -1, 2, 2); 198 pmanager->AddProcess(hion, -1, 2, 2);
197 199
198 // MicroElec ionisation is not active in 200 // MicroElec ionisation is not active in the world
199 G4MicroElecInelastic* microelecioni = ne 201 G4MicroElecInelastic* microelecioni = new G4MicroElecInelastic("ion_G4MicroElecInelastic");
200 microelecioni->SetEmModel(new G4DummyMod << 202 microelecioni->SetEmModel(new G4DummyModel(),1);
201 microelecioni->SetEmModel(new G4DummyMod << 203 microelecioni->SetEmModel(new G4DummyModel(),2);
202 pmanager->AddDiscreteProcess(microelecio 204 pmanager->AddDiscreteProcess(microelecioni);
203 } 205 }
204 } 206 }
205 207
206 // ************************************** 208 // **************************************
207 // 2) Define processes for Target region 209 // 2) Define processes for Target region
208 // ************************************** 210 // **************************************
209 211
210 // STANDARD EM processes should be inactivat 212 // STANDARD EM processes should be inactivated when corresponding MicroElec processes are used
211 // - STANDARD EM e- processes are inactivate 213 // - STANDARD EM e- processes are inactivated below 100 MeV
212 // - STANDARD EM proton & ion processes are 214 // - STANDARD EM proton & ion processes are inactivated below standEnergyLimit
213 // 215 //
214 G4EmConfigurator* em_config = G4LossTableMan 216 G4EmConfigurator* em_config = G4LossTableManager::Instance()->EmConfigurator();
215 217
216 G4VEmModel* mod; 218 G4VEmModel* mod;
217 // *** e- 219 // *** e-
218 220
219 // ---> STANDARD EM processes are inactivate 221 // ---> STANDARD EM processes are inactivated below 100 MeV
220 222
221 G4UrbanMscModel* msc = new G4UrbanMscModel( 223 G4UrbanMscModel* msc = new G4UrbanMscModel();
222 msc->SetActivationLowEnergyLimit(100*MeV); 224 msc->SetActivationLowEnergyLimit(100*MeV);
223 em_config->SetExtraEmModel("e-","msc",msc,"T 225 em_config->SetExtraEmModel("e-","msc",msc,"Target");
224 226
225 mod = new G4MollerBhabhaModel(); 227 mod = new G4MollerBhabhaModel();
226 mod->SetActivationLowEnergyLimit(100*MeV); 228 mod->SetActivationLowEnergyLimit(100*MeV);
227 em_config->SetExtraEmModel("e-","eIoni",mod, 229 em_config->SetExtraEmModel("e-","eIoni",mod,"Target",0.0,10*TeV, new G4UniversalFluctuation());
228 230
229 // ---> MicroElec processes activated 231 // ---> MicroElec processes activated
230 232
231 mod = new G4MicroElecElasticModel(); 233 mod = new G4MicroElecElasticModel();
232 em_config->SetExtraEmModel("e-","e-_G4MicroE 234 em_config->SetExtraEmModel("e-","e-_G4MicroElecElastic",mod,"Target",0.0,100*MeV);
233 235
234 mod = new G4MicroElecInelasticModel(); 236 mod = new G4MicroElecInelasticModel();
235 em_config->SetExtraEmModel("e-","e-_G4MicroE 237 em_config->SetExtraEmModel("e-","e-_G4MicroElecInelastic",mod,"Target",16.7*eV,100*MeV);
236 238
237 // *** proton 239 // *** proton
238 240
239 // ---> STANDARD EM processes inactivated be 241 // ---> STANDARD EM processes inactivated below standEnergyLimit
240 242
241 // STANDARD msc is still active 243 // STANDARD msc is still active
242 // Inactivate following STANDARD processes 244 // Inactivate following STANDARD processes
243 245
244 mod = new G4BraggModel(); 246 mod = new G4BraggModel();
245 mod->SetActivationHighEnergyLimit(50*keV); 247 mod->SetActivationHighEnergyLimit(50*keV);
246 em_config->SetExtraEmModel("proton","hIoni", 248 em_config->SetExtraEmModel("proton","hIoni",mod,"Target",0.0,2*MeV, new G4IonFluctuations());
247 249
248 mod = new G4BetheBlochModel(); 250 mod = new G4BetheBlochModel();
249 mod->SetActivationLowEnergyLimit(10*GeV); 251 mod->SetActivationLowEnergyLimit(10*GeV);
250 em_config->SetExtraEmModel("proton","hIoni", 252 em_config->SetExtraEmModel("proton","hIoni",mod,"Target",2*MeV,10*TeV, new G4IonFluctuations());
251 253
252 // ---> MicroElec processes activated 254 // ---> MicroElec processes activated
253 mod = new G4MicroElecInelasticModel(); 255 mod = new G4MicroElecInelasticModel();
254 mod->SetActivationLowEnergyLimit(50*keV); 256 mod->SetActivationLowEnergyLimit(50*keV);
255 em_config->SetExtraEmModel("proton","p_G4Mic 257 em_config->SetExtraEmModel("proton","p_G4MicroElecInelastic",mod,"Target",0.0,10*GeV);
256 em_config->SetExtraEmModel("proton","p_G4Mic 258 em_config->SetExtraEmModel("proton","p_G4MicroElecInelastic",new G4DummyModel,
257 "Target",10*GeV,10*TeV); 259 "Target",10*GeV,10*TeV);
258 260
259 // *** ion 261 // *** ion
260 262
261 // ---> STANDARD EM processes inactivated be 263 // ---> STANDARD EM processes inactivated below standEnergyLimit
262 264
263 // STANDARD msc is still active 265 // STANDARD msc is still active
264 // Inactivate following STANDARD processes 266 // Inactivate following STANDARD processes
265 267
266 mod = new G4BraggIonModel(); 268 mod = new G4BraggIonModel();
267 mod->SetActivationHighEnergyLimit(50*keV); 269 mod->SetActivationHighEnergyLimit(50*keV);
268 em_config->SetExtraEmModel("GenericIon","ion 270 em_config->SetExtraEmModel("GenericIon","ionIoni",mod,"Target",0.0,2*MeV, new G4IonFluctuations());
269 271
270 mod = new G4BetheBlochModel(); 272 mod = new G4BetheBlochModel();
271 mod->SetActivationLowEnergyLimit(10*GeV); 273 mod->SetActivationLowEnergyLimit(10*GeV);
272 em_config->SetExtraEmModel("GenericIon","ion 274 em_config->SetExtraEmModel("GenericIon","ionIoni",mod,"Target",2*MeV,10*TeV, new G4IonFluctuations());
273 275
274 // ---> MicroElec processes activated 276 // ---> MicroElec processes activated
275 mod = new G4MicroElecInelasticModel(); 277 mod = new G4MicroElecInelasticModel();
276 mod->SetActivationLowEnergyLimit(50*keV); 278 mod->SetActivationLowEnergyLimit(50*keV);
277 em_config->SetExtraEmModel("GenericIon","ion 279 em_config->SetExtraEmModel("GenericIon","ion_G4MicroElecInelastic",mod,
278 "Target",0.0,10*GeV); 280 "Target",0.0,10*GeV);
279 em_config->SetExtraEmModel("GenericIon","ion 281 em_config->SetExtraEmModel("GenericIon","ion_G4MicroElecInelastic",new G4DummyModel,
280 "Target",10*GeV,10*TeV); 282 "Target",10*GeV,10*TeV);
281 283
282 // Deexcitation 284 // Deexcitation
283 // 285 //
284 G4VAtomDeexcitation* de = new G4UAtomicDeexc 286 G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
285 G4LossTableManager::Instance()->SetAtomDeexc 287 G4LossTableManager::Instance()->SetAtomDeexcitation(de);
286 de->SetFluo(true); 288 de->SetFluo(true);
287 de->SetAuger(true); 289 de->SetAuger(true);
288 de->SetPIXE(true); 290 de->SetPIXE(true);
289 de->InitialiseForNewRun(); 291 de->InitialiseForNewRun();
290 292
291 293
292 } 294 }
293 295
294 //....oooOO0OOooo........oooOO0OOooo........oo 296 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
295 297
296 void PhysicsList::ConstructGeneral() 298 void PhysicsList::ConstructGeneral()
297 { } 299 { }
298 300
299 //....oooOO0OOooo........oooOO0OOooo........oo 301 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
300 302
301 void PhysicsList::SetCuts() 303 void PhysicsList::SetCuts()
302 { 304 {
303 if (verboseLevel >0) 305 if (verboseLevel >0)
304 { 306 {
305 G4cout << "PhysicsList::SetCuts:"; 307 G4cout << "PhysicsList::SetCuts:";
306 G4cout << "CutLength : " << G4BestUnit(def 308 G4cout << "CutLength : " << G4BestUnit(defaultCutValue,"Length") << G4endl;
307 } 309 }
308 310
309 // set cut values for gamma at first and for 311 // set cut values for gamma at first and for e- second and next for e+,
310 // because some processes for e+/e- need cut 312 // because some processes for e+/e- need cut values for gamma
311 SetCutValue(cutForGamma, "gamma"); 313 SetCutValue(cutForGamma, "gamma");
312 SetCutValue(cutForElectron, "e-"); 314 SetCutValue(cutForElectron, "e-");
313 SetCutValue(cutForPositron, "e+"); 315 SetCutValue(cutForPositron, "e+");
314 SetCutValue(cutForProton, "proton"); 316 SetCutValue(cutForProton, "proton");
315 317
316 if (verboseLevel>0) { DumpCutValuesTable(); 318 if (verboseLevel>0) { DumpCutValuesTable(); }
317 } 319 }
318 320