ECCE @ EIC Software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
G4EmLivermorePhysics.cc
Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file G4EmLivermorePhysics.cc
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 #include "G4EmLivermorePhysics.hh"
28 #include "G4ParticleDefinition.hh"
29 #include "G4SystemOfUnits.hh"
30 #include "G4ParticleTable.hh"
31 
32 // *** Processes and models
33 
34 // gamma
35 #include "G4PhotoElectricEffect.hh"
36 #include "G4LivermorePhotoElectricModel.hh"
37 
38 #include "G4ComptonScattering.hh"
39 #include "G4LivermoreComptonModel.hh"
40 
41 #include "G4GammaConversion.hh"
42 #include "G4LivermoreGammaConversionModel.hh"
43 
44 #include "G4RayleighScattering.hh"
45 #include "G4LivermoreRayleighModel.hh"
46 
47 #include "G4PEEffectFluoModel.hh"
48 #include "G4KleinNishinaModel.hh"
49 
50 // e+-
51 #include "G4eMultipleScattering.hh"
52 #include "G4UniversalFluctuation.hh"
53 
54 #include "G4eIonisation.hh"
55 #include "G4LivermoreIonisationModel.hh"
56 
57 #include "G4eBremsstrahlung.hh"
58 #include "G4LivermoreBremsstrahlungModel.hh"
59 #include "G4Generator2BS.hh"
60 #include "G4SeltzerBergerModel.hh"
61 #include "G4BetheHeitler5DModel.hh"
62 
63 // e+
64 #include "G4eplusAnnihilation.hh"
65 
66 // mu+-
67 #include "G4MuMultipleScattering.hh"
68 #include "G4MuIonisation.hh"
69 #include "G4MuBremsstrahlung.hh"
70 #include "G4MuPairProduction.hh"
71 
72 #include "G4MuBremsstrahlungModel.hh"
73 #include "G4MuPairProductionModel.hh"
74 #include "G4hBremsstrahlungModel.hh"
75 #include "G4hPairProductionModel.hh"
76 
77 // hadrons
78 #include "G4hMultipleScattering.hh"
79 #include "G4MscStepLimitType.hh"
80 
81 #include "G4hBremsstrahlung.hh"
82 #include "G4hPairProduction.hh"
83 #include "G4ePairProduction.hh"
84 
85 #include "G4hIonisation.hh"
86 #include "G4ionIonisation.hh"
87 #include "G4alphaIonisation.hh"
88 #include "G4IonParametrisedLossModel.hh"
89 #include "G4NuclearStopping.hh"
90 
91 // msc models
92 #include "G4UrbanMscModel.hh"
93 #include "G4WentzelVIModel.hh"
94 #include "G4GoudsmitSaundersonMscModel.hh"
95 #include "G4CoulombScattering.hh"
96 #include "G4eCoulombScatteringModel.hh"
97 
98 // interfaces
99 #include "G4LossTableManager.hh"
100 #include "G4UAtomicDeexcitation.hh"
101 #include "G4EmParameters.hh"
102 
103 // particles
104 
105 #include "G4Gamma.hh"
106 #include "G4Electron.hh"
107 #include "G4Positron.hh"
108 #include "G4MuonPlus.hh"
109 #include "G4MuonMinus.hh"
110 #include "G4PionPlus.hh"
111 #include "G4PionMinus.hh"
112 #include "G4KaonPlus.hh"
113 #include "G4KaonMinus.hh"
114 #include "G4Proton.hh"
115 #include "G4AntiProton.hh"
116 #include "G4Deuteron.hh"
117 #include "G4Triton.hh"
118 #include "G4He3.hh"
119 #include "G4Alpha.hh"
120 #include "G4GenericIon.hh"
121 
122 //
123 #include "G4PhysicsListHelper.hh"
124 #include "G4BuilderType.hh"
125 #include "G4EmModelActivator.hh"
126 
127 // factory
128 #include "G4PhysicsConstructorFactory.hh"
129 //
130 G4_DECLARE_PHYSCONSTR_FACTORY(G4EmLivermorePhysics);
131 
132 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
133 
134 G4EmLivermorePhysics::G4EmLivermorePhysics(G4int ver, const G4String&)
135  : G4VPhysicsConstructor("G4EmLivermore"), verbose(ver)
136 {
137  G4EmParameters* param = G4EmParameters::Instance();
138  param->SetDefaults();
139  param->SetVerbose(verbose);
140  param->SetMinEnergy(100*eV);
141  param->SetLowestElectronEnergy(100*eV);
142  param->SetNumberOfBinsPerDecade(20);
143  param->ActivateAngularGeneratorForIonisation(true);
144  param->SetStepFunction(0.2, 10*um);
145  param->SetStepFunctionMuHad(0.2, 50*um);
146  param->SetUseMottCorrection(true);
147  param->SetMscStepLimitType(fUseSafetyPlus);
148  param->SetMscSkin(3);
149  param->SetMscRangeFactor(0.08);
150  param->SetMuHadLateralDisplacement(true);
151  param->SetFluo(true);
152  param->SetMaxNIELEnergy(1*MeV);
153  SetPhysicsType(bElectromagnetic);
154 }
155 
156 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
157 
158 G4EmLivermorePhysics::~G4EmLivermorePhysics()
159 {}
160 
161 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
162 
163 void G4EmLivermorePhysics::ConstructParticle()
164 {
165  // gamma
166  G4Gamma::Gamma();
167 
168  // leptons
169  G4Electron::Electron();
170  G4Positron::Positron();
171  G4MuonPlus::MuonPlus();
172  G4MuonMinus::MuonMinus();
173 
174  // mesons
175  G4PionPlus::PionPlusDefinition();
176  G4PionMinus::PionMinusDefinition();
177  G4KaonPlus::KaonPlusDefinition();
178  G4KaonMinus::KaonMinusDefinition();
179 
180  // baryons
181  G4Proton::Proton();
182  G4AntiProton::AntiProton();
183 
184  // ions
185  G4Deuteron::Deuteron();
186  G4Triton::Triton();
187  G4He3::He3();
188  G4Alpha::Alpha();
189  G4GenericIon::GenericIonDefinition();
190 }
191 
192 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
193 
194 void G4EmLivermorePhysics::ConstructProcess()
195 {
196  if(verbose > 1) {
197  G4cout << "### " << GetPhysicsName() << " Construct Processes " << G4endl;
198  }
199  G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
200  G4LossTableManager* man = G4LossTableManager::Instance();
201 
202  // muon & hadron bremsstrahlung and pair production
203  G4MuBremsstrahlung* mub = new G4MuBremsstrahlung();
204  G4MuPairProduction* mup = new G4MuPairProduction();
205  G4hBremsstrahlung* pib = new G4hBremsstrahlung();
206  G4hPairProduction* pip = new G4hPairProduction();
207  G4hBremsstrahlung* kb = new G4hBremsstrahlung();
208  G4hPairProduction* kp = new G4hPairProduction();
209  G4hBremsstrahlung* pb = new G4hBremsstrahlung();
210  G4hPairProduction* pp = new G4hPairProduction();
211  G4ePairProduction* ee = new G4ePairProduction();
212 
213  // muon & hadron multiple scattering
214  G4MuMultipleScattering* mumsc = new G4MuMultipleScattering();
215  mumsc->SetEmModel(new G4WentzelVIModel());
216  G4CoulombScattering* muss = new G4CoulombScattering();
217 
218  G4hMultipleScattering* pimsc = new G4hMultipleScattering();
219  pimsc->SetEmModel(new G4WentzelVIModel());
220  G4CoulombScattering* piss = new G4CoulombScattering();
221 
222  G4hMultipleScattering* kmsc = new G4hMultipleScattering();
223  kmsc->SetEmModel(new G4WentzelVIModel());
224  G4CoulombScattering* kss = new G4CoulombScattering();
225 
226  G4hMultipleScattering* hmsc = new G4hMultipleScattering("ionmsc");
227 
228  // high energy limit for e+- scattering models
229  G4double highEnergyLimit= G4EmParameters::Instance()->MscEnergyLimit();
230  G4double livEnergyLimit = 1*GeV;
231 
232  // nuclear stopping
233  G4double nielEnergyLimit = G4EmParameters::Instance()->MaxNIELEnergy();
234  G4NuclearStopping* pnuc = new G4NuclearStopping();
235  pnuc->SetMaxKinEnergy(nielEnergyLimit);
236 
237  // Add Livermore EM Processes
238  G4ParticleTable* table = G4ParticleTable::GetParticleTable();
239  for(const auto& particleName : partList.PartNames()) {
240  G4ParticleDefinition* particle = table->FindParticle(particleName);
241  if (!particle) { continue; }
242  if (particleName == "gamma") {
243 
244  // photoelectric effect - Livermore model only
245  G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
246  thePhotoElectricEffect->SetEmModel(new G4LivermorePhotoElectricModel());
247 
248  // Compton scattering - Livermore model only
249  G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
250  theComptonScattering->SetEmModel(new G4KleinNishinaModel());
251  G4VEmModel* comptLiv = new G4LivermoreComptonModel();
252  comptLiv->SetHighEnergyLimit(livEnergyLimit);
253  theComptonScattering->AddEmModel(0, comptLiv);
254 
255  // gamma conversion
256  G4GammaConversion* theGammaConversion = new G4GammaConversion();
257  G4VEmModel* convLiv = new G4BetheHeitler5DModel();
258  theGammaConversion->SetEmModel(convLiv);
259 
260  // default Rayleigh scattering is Livermore
261  G4RayleighScattering* theRayleigh = new G4RayleighScattering();
262 
263  ph->RegisterProcess(thePhotoElectricEffect, particle);
264  ph->RegisterProcess(theComptonScattering, particle);
265  ph->RegisterProcess(theGammaConversion, particle);
266  ph->RegisterProcess(theRayleigh, particle);
267 
268  } else if (particleName == "e-") {
269 
270  // multiple and single scattering
271  G4eMultipleScattering* msc = new G4eMultipleScattering;
272  G4GoudsmitSaundersonMscModel* msc1 = new G4GoudsmitSaundersonMscModel();
273  G4WentzelVIModel* msc2 = new G4WentzelVIModel();
274  msc1->SetHighEnergyLimit(highEnergyLimit);
275  msc2->SetLowEnergyLimit(highEnergyLimit);
276  msc->SetEmModel(msc1);
277  msc->SetEmModel(msc2);
278 
279  G4eCoulombScatteringModel* ssm = new G4eCoulombScatteringModel();
280  G4CoulombScattering* ss = new G4CoulombScattering();
281  ss->SetEmModel(ssm);
282  ss->SetMinKinEnergy(highEnergyLimit);
283  ssm->SetLowEnergyLimit(highEnergyLimit);
284  ssm->SetActivationLowEnergyLimit(highEnergyLimit);
285 
286  // Ionisation - Livermore should be used only for low energies
287  G4eIonisation* eioni = new G4eIonisation();
288  G4VEmModel* theIoniLiv = new G4LivermoreIonisationModel();
289  theIoniLiv->SetHighEnergyLimit(0.1*MeV);
290  eioni->AddEmModel(0, theIoniLiv, new G4UniversalFluctuation() );
291 
292  // Bremsstrahlung
293  G4eBremsstrahlung* brem = new G4eBremsstrahlung();
294  G4SeltzerBergerModel* br1 = new G4SeltzerBergerModel();
295  G4eBremsstrahlungRelModel* br2 = new G4eBremsstrahlungRelModel();
296  br1->SetAngularDistribution(new G4Generator2BS());
297  br2->SetAngularDistribution(new G4Generator2BS());
298  brem->SetEmModel(br1);
299  brem->SetEmModel(br2);
300  br1->SetHighEnergyLimit(GeV);
301 
302  // register processes
303  ph->RegisterProcess(msc, particle);
304  ph->RegisterProcess(eioni, particle);
305  ph->RegisterProcess(brem, particle);
306  ph->RegisterProcess(ee, particle);
307  ph->RegisterProcess(ss, particle);
308 
309  } else if (particleName == "e+") {
310 
311  // multiple and single scattering
312  G4eMultipleScattering* msc = new G4eMultipleScattering;
313  G4GoudsmitSaundersonMscModel* msc1 = new G4GoudsmitSaundersonMscModel();
314  G4WentzelVIModel* msc2 = new G4WentzelVIModel();
315  msc1->SetHighEnergyLimit(highEnergyLimit);
316  msc2->SetLowEnergyLimit(highEnergyLimit);
317  msc->SetEmModel(msc1);
318  msc->SetEmModel(msc2);
319 
320  G4eCoulombScatteringModel* ssm = new G4eCoulombScatteringModel();
321  G4CoulombScattering* ss = new G4CoulombScattering();
322  ss->SetEmModel(ssm);
323  ss->SetMinKinEnergy(highEnergyLimit);
324  ssm->SetLowEnergyLimit(highEnergyLimit);
325  ssm->SetActivationLowEnergyLimit(highEnergyLimit);
326 
327  // ionisation
328  G4eIonisation* eIoni = new G4eIonisation();
329 
330  // Bremsstrahlung from standard
331  G4eBremsstrahlung* brem = new G4eBremsstrahlung();
332  G4SeltzerBergerModel* br1 = new G4SeltzerBergerModel();
333  G4eBremsstrahlungRelModel* br2 = new G4eBremsstrahlungRelModel();
334  br1->SetAngularDistribution(new G4Generator2BS());
335  br2->SetAngularDistribution(new G4Generator2BS());
336  brem->SetEmModel(br1);
337  brem->SetEmModel(br2);
338  br1->SetHighEnergyLimit(GeV);
339 
340  // register processes
341  ph->RegisterProcess(msc, particle);
342  ph->RegisterProcess(eIoni, particle);
343  ph->RegisterProcess(brem, particle);
344  ph->RegisterProcess(ee, particle);
345  ph->RegisterProcess(new G4eplusAnnihilation(), particle);
346  ph->RegisterProcess(ss, particle);
347 
348  } else if (particleName == "mu+" ||
349  particleName == "mu-" ) {
350 
351  G4MuIonisation* muIoni = new G4MuIonisation();
352 
353  ph->RegisterProcess(mumsc, particle);
354  ph->RegisterProcess(muIoni, particle);
355  ph->RegisterProcess(mub, particle);
356  ph->RegisterProcess(mup, particle);
357  ph->RegisterProcess(muss, particle);
358 
359  } else if (particleName == "alpha" ||
360  particleName == "He3" ) {
361 
362  G4hMultipleScattering* msc = new G4hMultipleScattering();
363  G4ionIonisation* ionIoni = new G4ionIonisation();
364 
365  ph->RegisterProcess(msc, particle);
366  ph->RegisterProcess(ionIoni, particle);
367  ph->RegisterProcess(pnuc, particle);
368 
369  } else if (particleName == "GenericIon") {
370 
371  G4ionIonisation* ionIoni = new G4ionIonisation();
372  ionIoni->SetEmModel(new G4IonParametrisedLossModel());
373  ionIoni->SetStepFunction(0.1, 1*um);
374 
375  ph->RegisterProcess(hmsc, particle);
376  ph->RegisterProcess(ionIoni, particle);
377  ph->RegisterProcess(pnuc, particle);
378 
379  } else if (particleName == "pi+" ||
380  particleName == "pi-" ) {
381 
382  G4hIonisation* hIoni = new G4hIonisation();
383 
384  ph->RegisterProcess(pimsc, particle);
385  ph->RegisterProcess(hIoni, particle);
386  ph->RegisterProcess(pib, particle);
387  ph->RegisterProcess(pip, particle);
388  ph->RegisterProcess(piss, particle);
389 
390  } else if (particleName == "kaon+" ||
391  particleName == "kaon-" ) {
392 
393  G4hIonisation* hIoni = new G4hIonisation();
394 
395  ph->RegisterProcess(kmsc, particle);
396  ph->RegisterProcess(hIoni, particle);
397  ph->RegisterProcess(kb, particle);
398  ph->RegisterProcess(kp, particle);
399  ph->RegisterProcess(kss, particle);
400 
401  } else if (particleName == "proton" ||
402  particleName == "anti_proton") {
403 
404  G4hMultipleScattering* pmsc = new G4hMultipleScattering();
405  pmsc->SetEmModel(new G4WentzelVIModel());
406  G4hIonisation* hIoni = new G4hIonisation();
407 
408  ph->RegisterProcess(pmsc, particle);
409  ph->RegisterProcess(hIoni, particle);
410  ph->RegisterProcess(pb, particle);
411  ph->RegisterProcess(pp, particle);
412  ph->RegisterProcess(new G4CoulombScattering(), particle);
413 
414  } else if (particleName == "B+" ||
415  particleName == "B-" ||
416  particleName == "D+" ||
417  particleName == "D-" ||
418  particleName == "Ds+" ||
419  particleName == "Ds-" ||
420  particleName == "anti_He3" ||
421  particleName == "anti_alpha" ||
422  particleName == "anti_deuteron" ||
423  particleName == "anti_lambda_c+" ||
424  particleName == "anti_omega-" ||
425  particleName == "anti_sigma_c+" ||
426  particleName == "anti_sigma_c++" ||
427  particleName == "anti_sigma+" ||
428  particleName == "anti_sigma-" ||
429  particleName == "anti_triton" ||
430  particleName == "anti_xi_c+" ||
431  particleName == "anti_xi-" ||
432  particleName == "deuteron" ||
433  particleName == "lambda_c+" ||
434  particleName == "omega-" ||
435  particleName == "sigma_c+" ||
436  particleName == "sigma_c++" ||
437  particleName == "sigma+" ||
438  particleName == "sigma-" ||
439  particleName == "tau+" ||
440  particleName == "tau-" ||
441  particleName == "triton" ||
442  particleName == "xi_c+" ||
443  particleName == "xi-" ) {
444 
445  ph->RegisterProcess(hmsc, particle);
446  ph->RegisterProcess(new G4hIonisation(), particle);
447  ph->RegisterProcess(pnuc, particle);
448  }
449  }
450 
451  // Nuclear stopping
452  pnuc->SetMaxKinEnergy(MeV);
453 
454  // Deexcitation
455  //
456  G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
457  man->SetAtomDeexcitation(de);
458 
459  G4EmModelActivator mact(GetPhysicsName());
460 }
461 
462 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......