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