Geant4 11.2.2
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
G4EmModelActivator.cc
Go to the documentation of this file.
1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26//
27//---------------------------------------------------------------------------
28//
29// ClassName: G4EmModelActivator
30//
31// Author: V.Ivanchenko 01.06.2015
32//
33// Organisation: G4AI
34// Contract: ESA contract 4000107387/12/NL/AT
35// Customer: ESA/ESTEC
36//
37// Modified:
38//
39//----------------------------------------------------------------------------
40//
41
42//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
43//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
44
45#include "G4EmModelActivator.hh"
46#include "G4EmParameters.hh"
47#include "G4ParticleDefinition.hh"
48#include "G4ParticleTable.hh"
49#include "G4RegionStore.hh"
50#include "G4Region.hh"
51#include "G4VEnergyLossProcess.hh"
52#include "G4VMscModel.hh"
53#include "G4LossTableManager.hh"
54#include "G4EmConfigurator.hh"
55#include "G4PAIModel.hh"
56#include "G4PAIPhotModel.hh"
57#include "G4Gamma.hh"
58#include "G4Electron.hh"
59#include "G4Positron.hh"
60#include "G4MuonPlus.hh"
61#include "G4MuonMinus.hh"
62#include "G4Proton.hh"
63#include "G4GenericIon.hh"
64#include "G4Alpha.hh"
65#include "G4ProcessManager.hh"
66#include "G4DummyModel.hh"
67#include "G4EmProcessSubType.hh"
68#include "G4PhysicsListHelper.hh"
69#include "G4EmParticleList.hh"
70#include "G4EmUtility.hh"
71
72#include "G4MicroElecElastic.hh"
73#include "G4MicroElecElasticModel.hh"
74
75#include "G4MicroElecInelastic.hh"
76#include "G4MicroElecInelasticModel.hh"
77
78#include "G4BraggModel.hh"
79#include "G4BraggIonModel.hh"
80#include "G4BetheBlochModel.hh"
81#include "G4UrbanMscModel.hh"
82#include "G4MollerBhabhaModel.hh"
83#include "G4IonFluctuations.hh"
84#include "G4UniversalFluctuation.hh"
85#include "G4LowECapture.hh"
86#include "G4hMultipleScattering.hh"
87#include "G4eCoulombScatteringModel.hh"
88#include "G4IonCoulombScatteringModel.hh"
89#include "G4ionIonisation.hh"
90#include "G4KleinNishinaModel.hh"
91
92#include "G4GammaGeneralProcess.hh"
93#include "G4CoulombScattering.hh"
94#include "G4eCoulombScatteringModel.hh"
95#include "G4WentzelVIModel.hh"
96#include "G4UniversalFluctuation.hh"
97#include "G4RayleighScattering.hh"
98#include "G4UrbanMscModel.hh"
99#include "G4GoudsmitSaundersonMscModel.hh"
100#include "G4LowEPComptonModel.hh"
101#include "G4BetheHeitler5DModel.hh"
102#include "G4LindhardSorensenIonModel.hh"
103
104#include "G4LivermorePhotoElectricModel.hh"
105#include "G4LivermoreComptonModel.hh"
106#include "G4LivermoreGammaConversionModel.hh"
107#include "G4LivermoreRayleighModel.hh"
108#include "G4LivermoreIonisationModel.hh"
109#include "G4LivermoreBremsstrahlungModel.hh"
110
111#include "G4PenelopePhotoElectricModel.hh"
112#include "G4PenelopeComptonModel.hh"
113#include "G4PenelopeGammaConversionModel.hh"
114#include "G4PenelopeRayleighModel.hh"
115#include "G4PenelopeIonisationModel.hh"
116#include "G4PenelopeBremsstrahlungModel.hh"
117#include "G4PenelopeAnnihilationModel.hh"
118
119#include "G4SystemOfUnits.hh"
120#include "G4Threading.hh"
121#include <vector>
122
123//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
124
125G4EmModelActivator::G4EmModelActivator(const G4String& emphys)
126 : baseName(emphys)
127{
128 theParameters = G4EmParameters::Instance();
129
130 const std::vector<G4String>& regnamesPAI = theParameters->RegionsPAI();
131 if(regnamesPAI.size() > 0)
132 {
133 ActivatePAI();
134 }
135 const std::vector<G4String>& regnamesME = theParameters->RegionsMicroElec();
136 if(regnamesME.size() > 0)
137 {
138 ActivateMicroElec();
139 }
140 const std::vector<G4String>& regnamesMSC = theParameters->RegionsPhysics();
141 if(regnamesMSC.size() > 0)
142 {
143 ActivateEmOptions();
144 }
145}
146
147//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
148
149void G4EmModelActivator::ActivateEmOptions()
150{
151 const std::vector<G4String>& regnamesPhys = theParameters->RegionsPhysics();
152 std::size_t nreg = regnamesPhys.size();
153 if(0 == nreg) { return; }
154 G4int verbose = theParameters->Verbose() - 1;
155 if(verbose > 0) {
156 G4cout << "### G4EmModelActivator::ActivateEmOptions for " << nreg << " regions"
157 << G4endl;
158 }
159 const std::vector<G4String>& typesPhys = theParameters->TypesPhysics();
160
161 // start configuration of models
162 const G4ParticleDefinition* elec = G4Electron::Electron();
163 const G4ParticleDefinition* posi = G4Positron::Positron();
164 const G4ParticleDefinition* phot = G4Gamma::Gamma();
165 const G4ParticleDefinition* prot = G4Proton::Proton();
166 G4LossTableManager* man = G4LossTableManager::Instance();
167 G4EmConfigurator* em_config = man->EmConfigurator();
168 G4VAtomDeexcitation* adeexc = man->AtomDeexcitation();
169 G4ParticleTable* table = G4ParticleTable::GetParticleTable();
170 G4VEmModel* mod = nullptr;
171 G4VEmProcess* proc = nullptr;
172
173 // high energy limit for low-energy e+- model of msc
174 G4double mscEnergyLimit = theParameters->MscEnergyLimit();
175
176 // high energy limit for Livermore and Penelope models
177 G4double highEnergyLimit = 1*GeV;
178
179 // general high energy limit
180 G4double highEnergy = theParameters->MaxKinEnergy();
181
182 for(std::size_t i=0; i<nreg; ++i) {
183 const G4String reg = regnamesPhys[i];
184 auto region = G4EmUtility::FindRegion(reg);
185 if(verbose > 0) {
186 G4cout << i << ". region <" << reg << ">; physics type <"
187 << typesPhys[i] << "> region ptr: " << region << G4endl;
188 }
189
190 if(baseName == typesPhys[i]) { continue; }
191
192 if("G4EmStandard" == typesPhys[i]) {
193 G4UrbanMscModel* msc = new G4UrbanMscModel();
194 AddStandardScattering(elec, em_config, msc, reg, mscEnergyLimit, highEnergy, typesPhys[i]);
195
196 msc = new G4UrbanMscModel();
197 AddStandardScattering(posi, em_config, msc, reg, mscEnergyLimit, highEnergy, typesPhys[i]);
198
199 } else if("G4EmStandard_opt1" == typesPhys[i] || "G4EmStandard_opt2" == typesPhys[i]) {
200 G4UrbanMscModel* msc = new G4UrbanMscModel();
201 AddStandardScattering(elec, em_config, msc, reg, mscEnergyLimit, highEnergy, typesPhys[i]);
202
203 msc = new G4UrbanMscModel();
204 AddStandardScattering(posi, em_config, msc, reg, mscEnergyLimit, highEnergy, typesPhys[i]);
205
206 } else if("G4EmStandard_opt3" == typesPhys[i]) {
207
208 G4DummyModel* dummy = new G4DummyModel();
209 G4UrbanMscModel* msc = new G4UrbanMscModel();
210 SetMscParameters(elec, msc, typesPhys[i]);
211 em_config->SetExtraEmModel("e-", "msc", msc, reg);
212 proc = FindOrAddProcess(elec, "CoulombScat");
213 proc->AddEmModel(-1, dummy, region);
214
215 msc = new G4UrbanMscModel();
216 SetMscParameters(posi, msc, typesPhys[i]);
217 em_config->SetExtraEmModel("e+", "msc", msc, reg);
218 proc = FindOrAddProcess(posi, "CoulombScat");
219 proc->AddEmModel(-1, dummy, region);
220
221 msc = new G4UrbanMscModel();
222 SetMscParameters(prot, msc, typesPhys[i]);
223 em_config->SetExtraEmModel("proton", "msc", msc, reg);
224 proc = FindOrAddProcess(prot, "CoulombScat");
225 proc->AddEmModel(-1, dummy, region);
226
227 theParameters->SetNumberOfBinsPerDecade(20);
228 if(G4Threading::IsMasterThread()) {
229 theParameters->SetDeexActiveRegion(reg, true, false, false);
230 }
231 theParameters->DefineRegParamForDeex(adeexc);
232 proc = FindOrAddProcess(phot, "Rayl");
233 proc->AddEmModel(-1, new G4LivermoreRayleighModel(), region);
234 proc = FindOrAddProcess(phot, "compt");
235 proc->AddEmModel(-1, new G4KleinNishinaModel(), region);
236
237 } else if("G4EmStandard_opt4" == typesPhys[i]) {
238 G4VMscModel* msc = new G4GoudsmitSaundersonMscModel();
239 AddStandardScattering(elec, em_config, msc, reg, mscEnergyLimit, highEnergy, typesPhys[i]);
240
241 msc = new G4GoudsmitSaundersonMscModel();
242 AddStandardScattering(posi, em_config, msc, reg, mscEnergyLimit, highEnergy, typesPhys[i]);
243
244 theParameters->SetNumberOfBinsPerDecade(20);
245 theParameters->SetUseMottCorrection(true);
246 if(G4Threading::IsMasterThread()) {
247 theParameters->SetDeexActiveRegion(reg, true, false, false);
248 }
249 theParameters->DefineRegParamForDeex(adeexc);
250
251 proc = FindOrAddProcess(phot, "Rayl");
252 proc->AddEmModel(-1, new G4LivermoreRayleighModel(), region);
253 proc = FindOrAddProcess(phot, "compt");
254 proc->AddEmModel(-1, new G4KleinNishinaModel(), region);
255 mod = new G4LowEPComptonModel();
256 mod->SetHighEnergyLimit(20*MeV);
257 proc->AddEmModel(-2, mod, region);
258 proc = FindOrAddProcess(phot, "conv");
259 proc->AddEmModel(-1, new G4BetheHeitler5DModel(), region);
260
261 } else if("G4EmStandardGS" == typesPhys[i]) {
262 G4GoudsmitSaundersonMscModel* msc = new G4GoudsmitSaundersonMscModel();
263 AddStandardScattering(elec, em_config, msc, reg, mscEnergyLimit, highEnergy, typesPhys[i]);
264
265 msc = new G4GoudsmitSaundersonMscModel();
266 AddStandardScattering(posi, em_config, msc, reg, mscEnergyLimit, highEnergy, typesPhys[i]);
267
268 } else if("G4EmStandardWVI" == typesPhys[i]) {
269 G4WentzelVIModel* msc = new G4WentzelVIModel();
270 AddStandardScattering(elec, em_config, msc, reg, mscEnergyLimit, highEnergy, typesPhys[i]);
271
272 msc = new G4WentzelVIModel();
273 AddStandardScattering(posi, em_config, msc, reg, mscEnergyLimit, highEnergy, typesPhys[i]);
274
275 theParameters->SetMscThetaLimit(0.15);
276
277 if(G4Threading::IsMasterThread()) {
278 theParameters->SetDeexActiveRegion(regnamesPhys[i], true, false, false);
279 }
280 theParameters->DefineRegParamForDeex(adeexc);
281
282 } else if("G4EmStandardSS" == typesPhys[i]) {
283 G4EmParticleList emList;
284 for(const auto& particleName : emList.EmChargedPartNames()) {
285 G4ParticleDefinition* particle = table->FindParticle(particleName);
286 if(nullptr != particle && 0.0 != particle->GetPDGCharge()) {
287 proc = FindOrAddProcess(particle, "CoulombScat");
288 if(nullptr != proc) {
289 proc->AddEmModel(-1, new G4DummyModel(), region);
290 }
291 auto pm = particle->GetProcessManager();
292 proc = new G4CoulombScattering("SingleCoulombScat", false);
293 pm->AddDiscreteProcess(proc);
294 proc->SetEmModel(new G4DummyModel());
295 G4VEmModel* scmod = nullptr;
296 if(particle->GetPDGMass() > CLHEP::GeV ||
297 particle->GetParticleType() == "nucleus") {
298 scmod = new G4IonCoulombScatteringModel();
299 } else {
300 scmod = new G4eCoulombScatteringModel(false);
301 }
302 scmod->SetPolarAngleLimit(0.0);
303 scmod->SetLocked(true);
304 proc->AddEmModel(-1, scmod, region);
305
306 // multiple scattering should be disabled
307 if(particleName == "mu+" || particleName == "mu-") {
308 em_config->SetExtraEmModel(particleName, "muMsc",
309 new G4DummyModel(), reg);
310 } else {
311 em_config->SetExtraEmModel(particleName, "msc",
312 new G4DummyModel(), reg);
313 }
314 }
315 }
316 if(G4Threading::IsMasterThread()) {
317 theParameters->SetDeexActiveRegion(regnamesPhys[i], true, true, true);
318 }
319 theParameters->DefineRegParamForDeex(adeexc);
320
321 } else if("G4EmLivermore" == typesPhys[i]) {
322
323 G4VMscModel* msc = new G4GoudsmitSaundersonMscModel();
324 AddStandardScattering(elec, em_config, msc, reg, mscEnergyLimit, highEnergy, typesPhys[i]);
325
326 msc = new G4GoudsmitSaundersonMscModel();
327 AddStandardScattering(posi, em_config, msc, reg, mscEnergyLimit, highEnergy, typesPhys[i]);
328
329 mod = new G4LivermorePhotoElectricModel();
330 em_config->SetExtraEmModel("gamma", "phot", mod, reg);
331 mod = new G4LivermoreComptonModel();
332 em_config->SetExtraEmModel("gamma", "compt", mod, reg);
333 mod = new G4LivermoreGammaConversionModel();
334 em_config->SetExtraEmModel("gamma", "conv", mod, reg);
335
336 FindOrAddProcess(phot, "Rayl");
337 mod = new G4LivermoreRayleighModel();
338 em_config->SetExtraEmModel("gamma", "Rayl", mod, reg);
339
340 mod = new G4LivermoreIonisationModel();
341 G4UniversalFluctuation* uf = new G4UniversalFluctuation();
342 em_config->SetExtraEmModel("e-", "eIoni", mod, reg, 0.0, 0.1*MeV, uf);
343 mod = new G4LivermoreBremsstrahlungModel();
344 em_config->SetExtraEmModel("e-", "eBrem", mod, reg, 0.0, highEnergyLimit);
345
346 theParameters->SetNumberOfBinsPerDecade(20);
347 theParameters->SetUseMottCorrection(true);
348 if(G4Threading::IsMasterThread()) {
349 theParameters->SetDeexActiveRegion(regnamesPhys[i], true, false, false);
350 }
351 theParameters->DefineRegParamForDeex(adeexc);
352
353 } else if("G4EmPenelope" == typesPhys[i]) {
354
355 G4VMscModel* msc = new G4GoudsmitSaundersonMscModel();
356 AddStandardScattering(elec, em_config, msc, reg, mscEnergyLimit, highEnergy, typesPhys[i]);
357
358 msc = new G4GoudsmitSaundersonMscModel();
359 AddStandardScattering(posi, em_config, msc, reg, mscEnergyLimit, highEnergy, typesPhys[i]);
360
361 mod = new G4PenelopePhotoElectricModel();
362 em_config->SetExtraEmModel("gamma", "phot", mod, reg);
363 mod = new G4PenelopeComptonModel();
364 em_config->SetExtraEmModel("gamma", "compt", mod, reg);
365 mod = new G4PenelopeGammaConversionModel();
366 em_config->SetExtraEmModel("gamma", "conv", mod, reg);
367
368 FindOrAddProcess(phot, "Rayl");
369 mod = new G4PenelopeRayleighModel();
370 em_config->SetExtraEmModel("gamma", "Rayl", mod, reg);
371
372 mod = new G4PenelopeIonisationModel();
373 G4UniversalFluctuation* uf = new G4UniversalFluctuation();
374 em_config->SetExtraEmModel("e-", "eIoni", mod, reg, 0.0, highEnergyLimit, uf);
375 mod = new G4PenelopeBremsstrahlungModel();
376 em_config->SetExtraEmModel("e-", "eBrem", mod, reg, 0.0, highEnergyLimit);
377
378 mod = new G4PenelopeIonisationModel();
379 uf = new G4UniversalFluctuation();
380 em_config->SetExtraEmModel("e+", "eIoni", mod, reg, 0.0, highEnergyLimit, uf);
381 mod = new G4PenelopeBremsstrahlungModel();
382 em_config->SetExtraEmModel("e+", "eBrem", mod, reg, 0.0, highEnergyLimit);
383 mod = new G4PenelopeAnnihilationModel();
384 em_config->SetExtraEmModel("e+", "annihil", mod, reg, 0.0, highEnergyLimit);
385
386 theParameters->SetNumberOfBinsPerDecade(20);
387 theParameters->SetUseMottCorrection(true);
388 if(G4Threading::IsMasterThread()) {
389 theParameters->SetDeexActiveRegion(regnamesPhys[i], true, false, false);
390 }
391 theParameters->DefineRegParamForDeex(adeexc);
392
393 } else {
394 if(verbose > 0 && G4Threading::IsMasterThread()) {
395 G4cout << "### G4EmModelActivator::ActivateEmOptions WARNING: \n"
396 << " EM Physics configuration name <" << typesPhys[i]
397 << "> is not known - ignored" << G4endl;
398 }
399 }
400 }
401}
402
403//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
404
405void G4EmModelActivator::ActivatePAI()
406{
407 const std::vector<G4String> regnamesPAI = theParameters->RegionsPAI();
408 std::size_t nreg = regnamesPAI.size();
409 if(0 == nreg) { return; }
410 G4int verbose = theParameters->Verbose() - 1;
411 if(verbose > 0) {
412 G4cout << "### G4EmModelActivator::ActivatePAI for " << nreg << " regions"
413 << G4endl;
414 }
415 const std::vector<G4String> particlesPAI = theParameters->ParticlesPAI();
416 const std::vector<G4String> typesPAI = theParameters->TypesPAI();
417
418 const std::vector<G4VEnergyLossProcess*>& v = G4LossTableManager::Instance()
419 ->GetEnergyLossProcessVector();
420
421 G4RegionStore* regionStore = G4RegionStore::GetInstance();
422
423 const G4ParticleDefinition* elec = G4Electron::Electron();
424 const G4ParticleDefinition* posi = G4Positron::Positron();
425 const G4ParticleDefinition* mupl = G4MuonPlus::MuonPlus();
426 const G4ParticleDefinition* mumi = G4MuonMinus::MuonMinus();
427 const G4ParticleDefinition* gion = G4GenericIon::GenericIon();
428
429 for(std::size_t i = 0; i < nreg; ++i) {
430 const G4ParticleDefinition* p = nullptr;
431 if(particlesPAI[i] != "all") {
432 p = G4ParticleTable::GetParticleTable()->FindParticle(particlesPAI[i]);
433 if(!p) {
434 G4cout << "### WARNING: ActivatePAI::FindParticle fails to find "
435 << particlesPAI[i] << G4endl;
436 continue;
437 }
438 }
439 const G4Region* r = regionStore->GetRegion(regnamesPAI[i], false);
440 if(!r) {
441 G4cout << "### WARNING: ActivatePAI::GetRegion fails to find "
442 << regnamesPAI[i] << G4endl;
443 continue;
444 }
445
446 G4String name = "hIoni";
447 if(p == elec || p == posi)
448 { name = "eIoni"; }
449 else if (p == mupl || p == mumi)
450 { name = "muIoni"; }
451 else if (p == gion)
452 { name = "ionIoni"; }
453
454 for(auto proc : v) {
455
456 if(!proc->IsIonisationProcess()) { continue; }
457
458 G4String namep = proc->GetProcessName();
459 if(p) {
460 if(name != namep) { continue; }
461 } else {
462 if(namep != "hIoni" && namep != "muIoni" &&
463 namep != "eIoni" && namep != "ionIoni")
464 { continue; }
465 }
466 G4double emin = 50*CLHEP::keV;
467 if(namep == "eIoni") emin = 110*CLHEP::eV;
468 else if(namep == "muIoni") emin = 5*CLHEP::keV;
469
470 G4VEmModel* em = nullptr;
471 G4VEmFluctuationModel* fm = nullptr;
472 if(typesPAI[i] == "PAIphoton" || typesPAI[i] == "pai_photon") {
473 G4PAIPhotModel* mod = new G4PAIPhotModel(p,"PAIPhotModel");
474 em = mod;
475 fm = mod;
476 } else {
477 G4PAIModel* mod = new G4PAIModel(p,"PAIModel");
478 em = mod;
479 fm = mod;
480 }
481 // first added the default model for world
482 // second added low energy model below PAI threshold in the region
483 // finally added PAI for the region
484 G4VEmModel* em0 = nullptr;
485 G4VEmFluctuationModel* fm0 = nullptr;
486 if(namep == "eIoni") {
487 fm0 = new G4UniversalFluctuation();
488 proc->SetEmModel(new G4MollerBhabhaModel());
489 proc->SetFluctModel(fm0);
490 em0 = new G4MollerBhabhaModel();
491 } else if(namep == "ionIoni") {
492 fm0 = new G4IonFluctuations();
493 proc->SetEmModel(new G4LindhardSorensenIonModel());
494 proc->SetFluctModel(fm0);
495 em0 = new G4LindhardSorensenIonModel();
496 } else {
497 fm0 = new G4UniversalFluctuation();
498 proc->SetEmModel(new G4BraggModel());
499 proc->SetEmModel(new G4BetheBlochModel());
500 proc->SetFluctModel(fm0);
501 em0 = new G4BraggModel();
502 }
503 em0->SetHighEnergyLimit(emin);
504 proc->AddEmModel(-1, em0, fm0, r);
505 em->SetLowEnergyLimit(emin);
506 proc->AddEmModel(-1, em, fm, r);
507 if(verbose > 0) {
508 G4cout << "### G4EmModelActivator: add <" << typesPAI[i]
509 << "> model for " << particlesPAI[i]
510 << " in the " << regnamesPAI[i]
511 << " Emin(keV)= " << emin/CLHEP::keV << G4endl;
512 }
513 }
514 }
515}
516
517//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
518
519void G4EmModelActivator::ActivateMicroElec()
520{
521 const std::vector<G4String> regnamesME = theParameters->RegionsMicroElec();
522 std::size_t nreg = regnamesME.size();
523 if(0 == nreg)
524 {
525 return;
526 }
527 G4int verbose = theParameters->Verbose() - 1;
528 if(verbose > 0)
529 {
530 G4cout << "### G4EmModelActivator::ActivateMicroElec for " << nreg
531 << " regions" << G4endl;
532 }
533 G4LossTableManager* man = G4LossTableManager::Instance();
534
535 const G4ParticleDefinition* elec = G4Electron::Electron();
536 const G4ParticleDefinition* prot = G4Proton::Proton();
537 const G4ParticleDefinition* gion = G4GenericIon::GenericIon();
538 G4ProcessManager* eman = elec->GetProcessManager();
539 G4ProcessManager* pman = prot->GetProcessManager();
540 G4ProcessManager* iman = gion->GetProcessManager();
541
542 G4bool emsc = HasMsc(eman);
543
544 // MicroElec elastic is not active in the world
545 G4MicroElecElastic* eElasProc =
546 new G4MicroElecElastic("e-G4MicroElecElastic");
547 eman->AddDiscreteProcess(eElasProc);
548
549 G4MicroElecInelastic* eInelProc =
550 new G4MicroElecInelastic("e-G4MicroElecInelastic");
551 eman->AddDiscreteProcess(eInelProc);
552
553 G4MicroElecInelastic* pInelProc =
554 new G4MicroElecInelastic("p_G4MicroElecInelastic");
555 pman->AddDiscreteProcess(pInelProc);
556
557 G4MicroElecInelastic* iInelProc =
558 new G4MicroElecInelastic("ion_G4MicroElecInelastic");
559 iman->AddDiscreteProcess(iInelProc);
560
561 // start configuration of models
562 G4EmConfigurator* em_config = man->EmConfigurator();
563 G4VEmModel* mod;
564
565 // limits for MicroElec applicability
566 G4double elowest = 16.7 * eV;
567 G4double elimel = 100 * MeV;
568 G4double elimin = 9 * MeV;
569 G4double pmin = 50 * keV;
570 G4double pmax = 99.9 * MeV;
571
572 G4LowECapture* ecap = new G4LowECapture(elowest);
573 eman->AddDiscreteProcess(ecap);
574
575 for(std::size_t i = 0; i < nreg; ++i)
576 {
577
578 G4String reg = regnamesME[i];
579 G4cout << "### MicroElec models are activated for G4Region " << reg
580 << G4endl
581 << " Energy limits for e- elastic: " << elowest/eV << " eV - "
582 << elimel/MeV << " MeV"
583 << G4endl
584 << " Energy limits for e- inelastic: " << elowest/eV << " eV - "
585 << elimin/MeV << " MeV"
586 << G4endl
587 << " Energy limits for hadrons/ions: " << pmin/MeV << " MeV - "
588 << pmax/MeV << " MeV"
589 << G4endl;
590
591 // e-
592 if(emsc)
593 {
594 G4UrbanMscModel* msc = new G4UrbanMscModel();
595 msc->SetActivationLowEnergyLimit(elimel);
596 em_config->SetExtraEmModel("e-", "msc", msc, reg);
597 }
598 else
599 {
600 mod = new G4DummyModel();
601 em_config->SetExtraEmModel("e-", "CoulombScat", mod, reg, 0.0, elimel);
602 }
603
604 mod = new G4MicroElecElasticModel();
605 em_config->SetExtraEmModel("e-",
606 "e-G4MicroElecElastic",
607 mod,
608 reg,
609 elowest,
610 elimin);
611
612 mod = new G4MollerBhabhaModel();
613 mod->SetActivationLowEnergyLimit(elimin);
614 em_config->SetExtraEmModel("e-",
615 "eIoni",
616 mod,
617 reg,
618 0.0,
619 10 * TeV,
620 new G4UniversalFluctuation());
621
622 mod = new G4MicroElecInelasticModel();
623 em_config->SetExtraEmModel("e-",
624 "e-G4MicroElecInelastic",
625 mod,
626 reg,
627 elowest,
628 elimin);
629
630 // proton
631 mod = new G4BraggModel();
632 mod->SetActivationHighEnergyLimit(pmin);
633 em_config->SetExtraEmModel("proton",
634 "hIoni",
635 mod,
636 reg,
637 0.0,
638 2 * MeV,
639 new G4UniversalFluctuation());
640
641 mod = new G4BetheBlochModel();
642 mod->SetActivationLowEnergyLimit(pmax);
643 em_config->SetExtraEmModel("proton",
644 "hIoni",
645 mod,
646 reg,
647 2 * MeV,
648 10 * TeV,
649 new G4UniversalFluctuation());
650
651 mod = new G4MicroElecInelasticModel();
652 em_config->SetExtraEmModel("proton",
653 "p_G4MicroElecInelastic",
654 mod,
655 reg,
656 pmin,
657 pmax);
658
659 // ions
660 mod = new G4BraggIonModel();
661 mod->SetActivationHighEnergyLimit(pmin);
662 em_config->SetExtraEmModel("GenericIon",
663 "ionIoni",
664 mod,
665 reg,
666 0.0,
667 2 * MeV,
668 new G4IonFluctuations());
669
670 mod = new G4BetheBlochModel();
671 mod->SetActivationLowEnergyLimit(pmax);
672 em_config->SetExtraEmModel("GenericIon",
673 "ionIoni",
674 mod,
675 reg,
676 2 * MeV,
677 10 * TeV,
678 new G4IonFluctuations());
679
680 mod = new G4MicroElecInelasticModel();
681 em_config->SetExtraEmModel("GenericIon",
682 "ion_G4MicroElecInelastic",
683 mod,
684 reg,
685 pmin,
686 pmax);
687 }
688}
689
690//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
691
692G4bool G4EmModelActivator::HasMsc(G4ProcessManager* pm) const
693{
694 G4bool res = false;
695 G4ProcessVector* pv = pm->GetProcessList();
696 G4int nproc = pm->GetProcessListLength();
697 for(G4int i = 0; i < nproc; ++i)
698 {
699 if(((*pv)[i])->GetProcessSubType() == fMultipleScattering)
700 {
701 res = true;
702 break;
703 }
704 }
705 return res;
706}
707
708//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
709
710void G4EmModelActivator::AddStandardScattering(const G4ParticleDefinition* part,
711 G4EmConfigurator* em_config,
712 G4VMscModel* mscmod,
713 const G4String& reg,
714 G4double e1, G4double e2,
715 const G4String& type)
716{
717 G4String pname = part->GetParticleName();
718
719 // low-energy msc model
720 SetMscParameters(part, mscmod, type);
721 em_config->SetExtraEmModel(pname, "msc", mscmod, reg, 0.0, e1);
722
723 // high energy msc model
724 G4WentzelVIModel* msc = new G4WentzelVIModel();
725 SetMscParameters(part, msc, type);
726 em_config->SetExtraEmModel(pname, "msc", msc, reg, e1, e2);
727
728 // high energy single scattering model
729 FindOrAddProcess(part, "CoulombScat");
730 G4eCoulombScatteringModel* mod = new G4eCoulombScatteringModel();
731 mod->SetActivationLowEnergyLimit(e1);
732 mod->SetLocked(true);
733 em_config->SetExtraEmModel(pname, "CoulombScat", mod, reg, 0.0, e2);
734}
735
736//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
737
738void G4EmModelActivator::SetMscParameters(const G4ParticleDefinition* part,
739 G4VMscModel* msc, const G4String& phys)
740{
741 if(part == G4Electron::Electron() || part == G4Positron::Positron()) {
742 if(phys == "G4EmStandard_opt1" || phys == "G4EmStandard_opt2") {
743 msc->SetRangeFactor(0.2);
744 msc->SetStepLimitType(fMinimal);
745 } else if(phys == "G4EmStandard_opt3") {
746 msc->SetStepLimitType(fUseDistanceToBoundary);
747 } else if(phys == "G4EmStandard_opt4" || phys == "G4EmLivermore" || phys == "G4EmPenelope") {
748 msc->SetRangeFactor(0.08);
749 msc->SetStepLimitType(fUseSafetyPlus);
750 msc->SetSkin(3);
751 } else if(phys == "G4EmStandardGS") {
752 msc->SetRangeFactor(0.06);
753 }
754 } else {
755 if(phys != "G4EmStandard" && phys != "G4EmStandard_opt1" && phys != "G4EmStandard_opt2") {
756 msc->SetLateralDisplasmentFlag(true);
757 }
758 }
759 msc->SetLocked(true);
760}
761
762//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
763
764G4VEmProcess*
765G4EmModelActivator::FindOrAddProcess(const G4ParticleDefinition* part,
766 const G4String& name)
767{
768 G4VEmProcess* proc = nullptr;
769 auto pm = part->GetProcessManager();
770 auto emproc = pm->GetProcessList();
771 G4int n = (G4int)emproc->size();
772 for(auto i=0; i<n; ++i) {
773 auto ptr = (*emproc)[i];
774 if(part->GetPDGEncoding() == 22 &&
775 ptr->GetProcessSubType() == fGammaGeneralProcess) {
776 proc = (static_cast<G4GammaGeneralProcess*>(ptr))->GetEmProcess(name);
777 } else if(ptr->GetProcessName() == name) {
778 proc = dynamic_cast<G4VEmProcess*>(ptr);
779 }
780 if(nullptr != proc) { return proc; }
781 }
782 if(name == "Rayl") {
783 G4RayleighScattering* rs = new G4RayleighScattering();
784 rs->SetEmModel(new G4DummyModel());
785 pm->AddDiscreteProcess(rs);
786 return rs;
787 }
788 return proc;
789}
790
791//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
fGammaGeneralProcess
@ fGammaGeneralProcess
Definition G4EmProcessSubType.hh:62
fMultipleScattering
@ fMultipleScattering
Definition G4EmProcessSubType.hh:55
fUseSafetyPlus
@ fUseSafetyPlus
Definition G4MscStepLimitType.hh:50
fUseDistanceToBoundary
@ fUseDistanceToBoundary
Definition G4MscStepLimitType.hh:51
G4double
double G4double
Definition G4Types.hh:83
G4bool
bool G4bool
Definition G4Types.hh:86
G4int
int G4int
Definition G4Types.hh:85
G4endl
#define G4endl
Definition G4ios.hh:67
G4cout
G4GLOB_DLL std::ostream G4cout
G4Electron::Electron
static G4Electron * Electron()
Definition G4Electron.cc:91
G4EmConfigurator::SetExtraEmModel
void SetExtraEmModel(const G4String &particleName, const G4String &processName, G4VEmModel *, const G4String &regionName="", G4double emin=0.0, G4double emax=DBL_MAX, G4VEmFluctuationModel *fm=nullptr)
Definition G4EmConfigurator.cc:77
G4EmModelActivator::G4EmModelActivator
G4EmModelActivator(const G4String &emphys="")
Definition G4EmModelActivator.cc:125
G4EmParameters::SetNumberOfBinsPerDecade
void SetNumberOfBinsPerDecade(G4int val)
Definition G4EmParameters.cc:961
G4EmParameters::Instance
static G4EmParameters * Instance()
Definition G4EmParameters.cc:70
G4EmParameters::TypesPhysics
const std::vector< G4String > & TypesPhysics() const
Definition G4EmParameters.cc:1203
G4EmParameters::SetMscThetaLimit
void SetMscThetaLimit(G4double val)
Definition G4EmParameters.cc:765
G4EmParameters::MscEnergyLimit
G4double MscEnergyLimit() const
Definition G4EmParameters.cc:796
G4EmParameters::RegionsPAI
const std::vector< G4String > & RegionsPAI() const
Definition G4EmParameters.cc:1154
G4EmParameters::SetDeexActiveRegion
void SetDeexActiveRegion(const G4String &region, G4bool fdeex, G4bool fauger, G4bool fpixe)
Definition G4EmParameters.cc:1215
G4EmParameters::Verbose
G4int Verbose() const
Definition G4EmParameters.cc:986
G4EmParameters::ParticlesPAI
const std::vector< G4String > & ParticlesPAI() const
Definition G4EmParameters.cc:1149
G4EmParameters::RegionsPhysics
const std::vector< G4String > & RegionsPhysics() const
Definition G4EmParameters.cc:1198
G4EmParameters::DefineRegParamForDeex
void DefineRegParamForDeex(G4VAtomDeexcitation *) const
Definition G4EmParameters.cc:1303
G4EmParameters::MaxKinEnergy
G4double MaxKinEnergy() const
Definition G4EmParameters.cc:596
G4EmParameters::SetUseMottCorrection
void SetUseMottCorrection(G4bool val)
Definition G4EmParameters.cc:364
G4EmParameters::RegionsMicroElec
const std::vector< G4String > & RegionsMicroElec() const
Definition G4EmParameters.cc:1170
G4EmParameters::TypesPAI
const std::vector< G4String > & TypesPAI() const
Definition G4EmParameters.cc:1159
G4EmParticleList::EmChargedPartNames
const std::vector< G4String > & EmChargedPartNames() const
Definition G4EmParticleList.cc:70
G4EmUtility::FindRegion
static const G4Region * FindRegion(const G4String &regionName, const G4int verbose=0)
Definition G4EmUtility.cc:47
G4Gamma::Gamma
static G4Gamma * Gamma()
Definition G4Gamma.cc:81
G4GenericIon::GenericIon
static G4GenericIon * GenericIon()
Definition G4GenericIon.cc:89
G4LossTableManager::Instance
static G4LossTableManager * Instance()
Definition G4LossTableManager.cc:87
G4LossTableManager::EmConfigurator
G4EmConfigurator * EmConfigurator()
Definition G4LossTableManager.cc:964
G4LossTableManager::GetEnergyLossProcessVector
const std::vector< G4VEnergyLossProcess * > & GetEnergyLossProcessVector()
Definition G4LossTableManager.cc:935
G4LossTableManager::AtomDeexcitation
G4VAtomDeexcitation * AtomDeexcitation()
Definition G4LossTableManager.hh:389
G4MuonMinus::MuonMinus
static G4MuonMinus * MuonMinus()
Definition G4MuonMinus.cc:99
G4MuonPlus::MuonPlus
static G4MuonPlus * MuonPlus()
Definition G4MuonPlus.cc:98
G4ParticleDefinition::GetProcessManager
G4ProcessManager * GetProcessManager() const
Definition G4ParticleDefinition.cc:218
G4ParticleDefinition::GetParticleType
const G4String & GetParticleType() const
Definition G4ParticleDefinition.hh:118
G4ParticleDefinition::GetParticleName
const G4String & GetParticleName() const
Definition G4ParticleDefinition.hh:96
G4ParticleTable::FindParticle
G4ParticleDefinition * FindParticle(G4int PDGEncoding)
Definition G4ParticleTable.cc:498
G4ParticleTable::GetParticleTable
static G4ParticleTable * GetParticleTable()
Definition G4ParticleTable.cc:82
G4Positron::Positron
static G4Positron * Positron()
Definition G4Positron.cc:90
G4ProcessManager::AddDiscreteProcess
G4int AddDiscreteProcess(G4VProcess *aProcess, G4int ord=ordDefault)
G4ProcessManager::GetProcessListLength
G4int GetProcessListLength() const
G4ProcessManager::GetProcessList
G4ProcessVector * GetProcessList() const
G4Proton::Proton
static G4Proton * Proton()
Definition G4Proton.cc:90
G4RegionStore::GetInstance
static G4RegionStore * GetInstance()
Definition G4RegionStore.cc:212
G4RegionStore::GetRegion
G4Region * GetRegion(const G4String &name, G4bool verbose=true) const
Definition G4RegionStore.cc:267
G4VEmModel::SetPolarAngleLimit
void SetPolarAngleLimit(G4double)
Definition G4VEmModel.hh:773
G4VEmModel::SetHighEnergyLimit
void SetHighEnergyLimit(G4double)
Definition G4VEmModel.hh:738
G4VEmModel::SetActivationLowEnergyLimit
void SetActivationLowEnergyLimit(G4double)
Definition G4VEmModel.hh:759
G4VEmModel::SetLowEnergyLimit
void SetLowEnergyLimit(G4double)
Definition G4VEmModel.hh:745
G4VEmModel::SetActivationHighEnergyLimit
void SetActivationHighEnergyLimit(G4double)
Definition G4VEmModel.hh:752
G4VEmModel::SetLocked
void SetLocked(G4bool)
Definition G4VEmModel.hh:848
G4VEmProcess::AddEmModel
void AddEmModel(G4int, G4VEmModel *, const G4Region *region=nullptr)
Definition G4VEmProcess.cc:125
G4VEmProcess::SetEmModel
void SetEmModel(G4VEmModel *, G4int index=0)
Definition G4VEmProcess.cc:136
G4VMscModel::SetSkin
void SetSkin(G4double)
Definition G4VMscModel.hh:229
G4VMscModel::SetRangeFactor
void SetRangeFactor(G4double)
Definition G4VMscModel.hh:236
G4VMscModel::SetLateralDisplasmentFlag
void SetLateralDisplasmentFlag(G4bool val)
Definition G4VMscModel.hh:222
G4VMscModel::SetStepLimitType
void SetStepLimitType(G4MscStepLimitType)
Definition G4VMscModel.hh:264
G4VProcess::GetProcessName
const G4String & GetProcessName() const
Definition G4VProcess.hh:386
G4InuclParticleNames::name
const char * name(G4int ptype)
Definition G4InuclParticleNames.hh:76
G4Threading::IsMasterThread
G4bool IsMasterThread()
Definition G4Threading.cc:124