ECCE @ EIC Software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
G4EmDNAPhysics_stationary_option6.cc
Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file G4EmDNAPhysics_stationary_option6.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 #include "G4EmDNAPhysics_stationary_option6.hh"
27 
28 #include "G4SystemOfUnits.hh"
29 
30 #include "G4DNAGenericIonsManager.hh"
31 
32 // *** Processes and models for Geant4-DNA
33 
34 #include "G4DNAElastic.hh"
35 #include "G4DNAUeharaScreenedRutherfordElasticModel.hh"
36 #include "G4DNAIonElasticModel.hh"
37 
38 #include "G4DNAExcitation.hh"
39 #include "G4DNAAttachment.hh"
40 #include "G4DNAVibExcitation.hh"
41 #include "G4DNAIonisation.hh"
42 #include "G4DNAChargeDecrease.hh"
43 #include "G4DNAChargeIncrease.hh"
44 
45 #include "G4DNACPA100IonisationModel.hh"
46 #include "G4DNACPA100ExcitationModel.hh"
47 #include "G4DNACPA100ElasticModel.hh"
48 
49 // particles
50 
51 #include "G4Electron.hh"
52 #include "G4Proton.hh"
53 #include "G4GenericIon.hh"
54 
55 // Warning : the following is needed in order to use EM Physics builders
56 // e+
57 #include "G4Positron.hh"
58 #include "G4eMultipleScattering.hh"
59 #include "G4eIonisation.hh"
60 #include "G4eBremsstrahlung.hh"
61 #include "G4eplusAnnihilation.hh"
62 // gamma
63 #include "G4Gamma.hh"
64 #include "G4PhotoElectricEffect.hh"
65 #include "G4LivermorePhotoElectricModel.hh"
66 #include "G4ComptonScattering.hh"
67 #include "G4LivermoreComptonModel.hh"
68 #include "G4GammaConversion.hh"
69 #include "G4LivermoreGammaConversionModel.hh"
70 #include "G4RayleighScattering.hh"
71 #include "G4LivermoreRayleighModel.hh"
72 
73 #include "G4EmParameters.hh"
74 // end of warning
75 
76 #include "G4LossTableManager.hh"
77 #include "G4UAtomicDeexcitation.hh"
78 #include "G4PhysicsListHelper.hh"
79 #include "G4BuilderType.hh"
80 
81 // factory
82 #include "G4PhysicsConstructorFactory.hh"
83 //
84 G4_DECLARE_PHYSCONSTR_FACTORY(G4EmDNAPhysics_stationary_option6);
85 
86 
87 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
88 
89 G4EmDNAPhysics_stationary_option6::G4EmDNAPhysics_stationary_option6(G4int ver)
90  : G4VPhysicsConstructor("G4EmDNAPhysics_stationary_option6"), verbose(ver)
91 {
92  G4EmParameters* param = G4EmParameters::Instance();
93  param->SetDefaults();
94  param->SetFluo(true);
95  param->SetAuger(true);
96  param->SetAugerCascade(true);
97  param->SetDeexcitationIgnoreCut(true);
98  param->ActivateDNA();
99 
100  SetPhysicsType(bElectromagnetic);
101 }
102 
103 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
104 
105 G4EmDNAPhysics_stationary_option6::G4EmDNAPhysics_stationary_option6(G4int ver,
106 const G4String&)
107  : G4VPhysicsConstructor("G4EmDNAPhysics_stationary_option6"), verbose(ver)
108 {
109  G4EmParameters* param = G4EmParameters::Instance();
110  param->SetDefaults();
111  param->SetFluo(true);
112  param->SetAuger(true);
113  param->SetAugerCascade(true);
114  param->SetDeexcitationIgnoreCut(true);
115 
116  SetPhysicsType(bElectromagnetic);
117 }
118 
119 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
120 
121 G4EmDNAPhysics_stationary_option6::~G4EmDNAPhysics_stationary_option6()
122 {}
123 
124 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
125 
126 void G4EmDNAPhysics_stationary_option6::ConstructParticle()
127 {
128 // bosons
129  G4Gamma::Gamma();
130 
131 // leptons
132  G4Electron::Electron();
133  G4Positron::Positron();
134 
135 // baryons
136  G4Proton::Proton();
137 
138  G4GenericIon::GenericIonDefinition();
139 
140  G4DNAGenericIonsManager * genericIonsManager;
141  genericIonsManager=G4DNAGenericIonsManager::Instance();
142  genericIonsManager->GetIon("alpha++");
143  genericIonsManager->GetIon("alpha+");
144  genericIonsManager->GetIon("helium");
145  genericIonsManager->GetIon("hydrogen");
146 
147 }
148 
149 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
150 
151 void G4EmDNAPhysics_stationary_option6::ConstructProcess()
152 {
153  if(verbose > 1) {
154  G4cout << "### " << GetPhysicsName() << " Construct Processes " << G4endl;
155  }
156  G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
157 
158  auto myParticleIterator=GetParticleIterator();
159  myParticleIterator->reset();
160  while( (*myParticleIterator)() )
161  {
162  G4ParticleDefinition* particle = myParticleIterator->value();
163  G4String particleName = particle->GetParticleName();
164 
165  if (particleName == "e-") {
166 
167  // *** Elastic scattering (two alternative models available) ***
168 
169  G4DNAElastic* theDNAElasticProcess =
170  new G4DNAElastic("e-_G4DNAElastic");
171  theDNAElasticProcess->SetEmModel(new G4DNACPA100ElasticModel());
172  ((G4DNACPA100ElasticModel*)
173  (theDNAElasticProcess->EmModel()))->SelectStationary(true);
174  ph->RegisterProcess(theDNAElasticProcess, particle);
175 
176  // *** Excitation ***
177 
178  G4DNAExcitation* theDNAExcitationProcess =
179  new G4DNAExcitation("e-_G4DNAExcitation");
180  theDNAExcitationProcess->SetEmModel(new G4DNACPA100ExcitationModel());
181  ((G4DNACPA100ExcitationModel*)
182  (theDNAExcitationProcess->EmModel()))->SelectStationary(true);
183  ph->RegisterProcess(theDNAExcitationProcess, particle);
184 
185  // *** Ionisation ***
186 
187  G4DNAIonisation* theDNAIonisationProcess =
188  new G4DNAIonisation("e-_G4DNAIonisation");
189  theDNAIonisationProcess->SetEmModel(new G4DNACPA100IonisationModel());
190  ((G4DNACPA100IonisationModel*)
191  (theDNAIonisationProcess->EmModel()))->SelectStationary(true);
192  ph->RegisterProcess(theDNAIonisationProcess, particle);
193 
194  // *** Vibrational excitation ***
195 
196  G4DNAVibExcitation* theDNAVibExcitationProcess =
197  new G4DNAVibExcitation("e-_G4DNAVibExcitation");
198  theDNAVibExcitationProcess->SetEmModel(new G4DNASancheExcitationModel());
199  ((G4DNASancheExcitationModel*)
200  (theDNAVibExcitationProcess->EmModel()))->SelectStationary(true);
201  ph->RegisterProcess(theDNAVibExcitationProcess, particle);
202 
203  // *** Attachment ***
204 
205  G4DNAAttachment* theDNAAttachmentProcess =
206  new G4DNAAttachment("e-_G4DNAAttachment");
207  theDNAAttachmentProcess->SetEmModel(new G4DNAMeltonAttachmentModel());
208  ((G4DNAMeltonAttachmentModel*)
209  (theDNAAttachmentProcess->EmModel()))->SelectStationary(true);
210  ph->RegisterProcess(theDNAAttachmentProcess, particle);
211 
212  } else if ( particleName == "proton" ) {
213 
214  // *** Elastic ***
215 
216  G4DNAElastic* theDNAElasticProcess =
217  new G4DNAElastic("proton_G4DNAElastic");
218  theDNAElasticProcess->SetEmModel(new G4DNAIonElasticModel());
219  ((G4DNAIonElasticModel*)
220  (theDNAElasticProcess->EmModel()))->SelectStationary(true);
221  ph->RegisterProcess(theDNAElasticProcess, particle);
222 
223  // *** Excitation ***
224 
225  G4DNAExcitation* theDNAExcitationProcess =
226  new G4DNAExcitation("proton_G4DNAExcitation");
227 
228  theDNAExcitationProcess->SetEmModel(
229  new G4DNAMillerGreenExcitationModel());
230  theDNAExcitationProcess->SetEmModel(
231  new G4DNABornExcitationModel());
232 
233  ((G4DNAMillerGreenExcitationModel*)
234  (theDNAExcitationProcess->EmModel()))->SetLowEnergyLimit(10*eV);
235  ((G4DNAMillerGreenExcitationModel*)
236  (theDNAExcitationProcess->EmModel()))->SetHighEnergyLimit(500*keV);
237  ((G4DNAMillerGreenExcitationModel*)
238  (theDNAExcitationProcess->EmModel()))->SelectStationary(true);
239 
240  ((G4DNABornExcitationModel*)
241  (theDNAExcitationProcess->EmModel(1)))->SetLowEnergyLimit(500*keV);
242  ((G4DNABornExcitationModel*)
243  (theDNAExcitationProcess->EmModel(1)))->SetHighEnergyLimit(100*MeV);
244  ((G4DNABornExcitationModel*)
245  (theDNAExcitationProcess->EmModel(1)))->SelectStationary(true);
246 
247  ph->RegisterProcess(theDNAExcitationProcess, particle);
248 
249  // *** Ionisation ***
250 
251  G4DNAIonisation* theDNAIonisationProcess =
252  new G4DNAIonisation("proton_G4DNAIonisation");
253 
254  theDNAIonisationProcess->SetEmModel(
255  new G4DNARuddIonisationExtendedModel);
256  theDNAIonisationProcess->SetEmModel(
257  new G4DNABornIonisationModel);
258 
259  ((G4DNARuddIonisationExtendedModel*)
260  (theDNAIonisationProcess->EmModel()))->SetLowEnergyLimit(0*eV);
261  ((G4DNARuddIonisationExtendedModel*)
262  (theDNAIonisationProcess->EmModel()))->SetHighEnergyLimit(500*keV);
263  ((G4DNARuddIonisationExtendedModel*)
264  (theDNAIonisationProcess->EmModel()))->SelectStationary(true);
265 
266  ((G4DNABornIonisationModel*)
267  (theDNAIonisationProcess->EmModel(1)))->SetLowEnergyLimit(500*keV);
268  ((G4DNABornIonisationModel*)
269  (theDNAIonisationProcess->EmModel(1)))->SetHighEnergyLimit(100*MeV);
270  ((G4DNABornIonisationModel*)
271  (theDNAIonisationProcess->EmModel(1)))->SelectStationary(true);
272  //
273  ((G4DNABornIonisationModel*)
274  (theDNAIonisationProcess->EmModel(1)))->SelectFasterComputation(true);
275  //
276 
277  ph->RegisterProcess(theDNAIonisationProcess, particle);
278 
279  // *** Charge decrease ***
280 
281  G4DNAChargeDecrease* theDNAChargeDecreaseProcess =
282  new G4DNAChargeDecrease("proton_G4DNAChargeDecrease");
283  theDNAChargeDecreaseProcess->SetEmModel(
284  new G4DNADingfelderChargeDecreaseModel());
285  ((G4DNADingfelderChargeDecreaseModel*)
286  (theDNAChargeDecreaseProcess->EmModel()))->SelectStationary(true);
287  ph->RegisterProcess(theDNAChargeDecreaseProcess, particle);
288 
289  } else if ( particleName == "hydrogen" ) {
290 
291  // *** Elastic ***
292 
293  G4DNAElastic* theDNAElasticProcess =
294  new G4DNAElastic("hydrogen_G4DNAElastic");
295  theDNAElasticProcess->SetEmModel(
296  new G4DNAIonElasticModel());
297  ((G4DNAIonElasticModel*)
298  (theDNAElasticProcess->EmModel()))->SelectStationary(true);
299  ph->RegisterProcess(theDNAElasticProcess, particle);
300 
301  // *** Excitation ***
302 
303  G4DNAExcitation* theDNAExcitationProcess =
304  new G4DNAExcitation("hydrogen_G4DNAExcitation");
305  theDNAExcitationProcess->SetEmModel(
306  new G4DNAMillerGreenExcitationModel());
307  ((G4DNAMillerGreenExcitationModel*)
308  (theDNAExcitationProcess->EmModel()))->SelectStationary(true);
309  ph->RegisterProcess(theDNAExcitationProcess, particle);
310 
311  // *** Ionisation ***
312 
313  G4DNAIonisation* theDNAIonisationProcess =
314  new G4DNAIonisation("hydrogen_G4DNAIonisation");
315  theDNAIonisationProcess->SetEmModel(
316  new G4DNARuddIonisationExtendedModel());
317  ((G4DNARuddIonisationExtendedModel*)(
318  theDNAIonisationProcess->EmModel()))->SelectStationary(true);
319  ph->RegisterProcess(theDNAIonisationProcess, particle);
320 
321  // *** Charge increase ***
322 
323  G4DNAChargeIncrease* theDNAChargeIncreaseProcess =
324  new G4DNAChargeIncrease("hydrogen_G4DNAChargeIncrease");
325  theDNAChargeIncreaseProcess->SetEmModel(
326  new G4DNADingfelderChargeIncreaseModel());
327  ((G4DNADingfelderChargeIncreaseModel*)(
328  theDNAChargeIncreaseProcess->EmModel()))->SelectStationary(true);
329  ph->RegisterProcess(theDNAChargeIncreaseProcess, particle);
330 
331  } else if ( particleName == "alpha" ) {
332 
333  // *** Elastic ***
334 
335  G4DNAElastic* theDNAElasticProcess =
336  new G4DNAElastic("alpha_G4DNAElastic");
337  theDNAElasticProcess->SetEmModel(new G4DNAIonElasticModel());
338  ((G4DNAIonElasticModel*)
339  (theDNAElasticProcess->EmModel()))->SelectStationary(true);
340  ph->RegisterProcess(theDNAElasticProcess, particle);
341 
342  // *** Excitation ***
343 
344  G4DNAExcitation* theDNAExcitationProcess =
345  new G4DNAExcitation("alpha_G4DNAExcitation");
346  theDNAExcitationProcess->SetEmModel(
347  new G4DNAMillerGreenExcitationModel());
348  ((G4DNAMillerGreenExcitationModel*)
349  (theDNAExcitationProcess->EmModel()))->SelectStationary(true);
350  ph->RegisterProcess(theDNAExcitationProcess, particle);
351 
352  // *** Ionisation ***
353 
354  G4DNAIonisation* theDNAIonisationProcess =
355  new G4DNAIonisation("alpha_G4DNAIonisation");
356  theDNAIonisationProcess->SetEmModel(
357  new G4DNARuddIonisationExtendedModel());
358  ((G4DNARuddIonisationExtendedModel*)
359  (theDNAIonisationProcess->EmModel()))->SelectStationary(true);
360  ph->RegisterProcess(theDNAIonisationProcess, particle);
361 
362  // *** Charge decrease ***
363 
364  G4DNAChargeDecrease* theDNAChargeDecreaseProcess =
365  new G4DNAChargeDecrease("alpha_G4DNAChargeDecrease");
366  theDNAChargeDecreaseProcess->SetEmModel(
367  new G4DNADingfelderChargeDecreaseModel());
368  ((G4DNADingfelderChargeDecreaseModel*)
369  (theDNAChargeDecreaseProcess->EmModel()))->SelectStationary(true);
370  ph->RegisterProcess(theDNAChargeDecreaseProcess, particle);
371 
372  } else if ( particleName == "alpha+" ) {
373 
374  // *** Elastic ***
375 
376  G4DNAElastic* theDNAElasticProcess =
377  new G4DNAElastic("alpha+_G4DNAElastic");
378  theDNAElasticProcess->SetEmModel(
379  new G4DNAIonElasticModel());
380  ((G4DNAIonElasticModel*)
381  (theDNAElasticProcess->EmModel()))->SelectStationary(true);
382  ph->RegisterProcess(theDNAElasticProcess, particle);
383 
384  // *** Excitation ***
385 
386  G4DNAExcitation* theDNAExcitationProcess =
387  new G4DNAExcitation("alpha+_G4DNAExcitation");
388  theDNAExcitationProcess->SetEmModel(
389  new G4DNAMillerGreenExcitationModel());
390  ((G4DNAMillerGreenExcitationModel*)
391  (theDNAExcitationProcess->EmModel()))->SelectStationary(true);
392  ph->RegisterProcess(theDNAExcitationProcess, particle);
393 
394  // *** Ionisation ***
395 
396  G4DNAIonisation* theDNAIonisationProcess =
397  new G4DNAIonisation("alpha+_G4DNAIonisation");
398  theDNAIonisationProcess->SetEmModel(
399  new G4DNARuddIonisationExtendedModel());
400  ((G4DNARuddIonisationExtendedModel*)
401  (theDNAIonisationProcess->EmModel()))->SelectStationary(true);
402  ph->RegisterProcess(theDNAIonisationProcess, particle);
403 
404  // *** Charge decrease ***
405 
406  G4DNAChargeDecrease* theDNAChargeDecreaseProcess =
407  new G4DNAChargeDecrease("alpha+_G4DNAChargeDecrease");
408  theDNAChargeDecreaseProcess->SetEmModel(
409  new G4DNADingfelderChargeDecreaseModel());
410  ((G4DNADingfelderChargeDecreaseModel*)
411  (theDNAChargeDecreaseProcess->EmModel()))->SelectStationary(true);
412  ph->RegisterProcess(theDNAChargeDecreaseProcess, particle);
413 
414  // *** Charge increase ***
415 
416  G4DNAChargeIncrease* theDNAChargeIncreaseProcess =
417  new G4DNAChargeIncrease("alpha+_G4DNAChargeIncrease");
418  theDNAChargeIncreaseProcess->SetEmModel(
419  new G4DNADingfelderChargeIncreaseModel());
420  ((G4DNADingfelderChargeIncreaseModel*)
421  (theDNAChargeIncreaseProcess->EmModel()))->SelectStationary(true);
422  ph->RegisterProcess(theDNAChargeIncreaseProcess, particle);
423 
424  } else if ( particleName == "helium" ) {
425 
426  // *** Elastic ***
427 
428  G4DNAElastic* theDNAElasticProcess =
429  new G4DNAElastic("helium_G4DNAElastic");
430  theDNAElasticProcess->SetEmModel(new G4DNAIonElasticModel());
431  ((G4DNAIonElasticModel*)
432  (theDNAElasticProcess->EmModel()))->SelectStationary(true);
433  ph->RegisterProcess(theDNAElasticProcess, particle);
434 
435  // *** Excitation ***
436 
437  G4DNAExcitation* theDNAExcitationProcess =
438  new G4DNAExcitation("helium_G4DNAExcitation");
439  theDNAExcitationProcess->SetEmModel(
440  new G4DNAMillerGreenExcitationModel());
441  ((G4DNAMillerGreenExcitationModel*)
442  (theDNAExcitationProcess->EmModel()))->SelectStationary(true);
443  ph->RegisterProcess(theDNAExcitationProcess, particle);
444 
445  // *** Ionisation ***
446 
447  G4DNAIonisation* theDNAIonisationProcess =
448  new G4DNAIonisation("helium_G4DNAIonisation");
449  theDNAIonisationProcess->SetEmModel(
450  new G4DNARuddIonisationExtendedModel());
451  ((G4DNARuddIonisationExtendedModel*)
452  (theDNAIonisationProcess->EmModel()))->SelectStationary(true);
453  ph->RegisterProcess(theDNAIonisationProcess, particle);
454 
455  // *** Charge increase ***
456 
457  G4DNAChargeIncrease* theDNAChargeIncreaseProcess =
458  new G4DNAChargeIncrease("helium_G4DNAChargeIncrease");
459  theDNAChargeIncreaseProcess->SetEmModel(
460  new G4DNADingfelderChargeIncreaseModel());
461  ((G4DNADingfelderChargeIncreaseModel*)
462  (theDNAChargeIncreaseProcess->EmModel()))->SelectStationary(true);
463  ph->RegisterProcess(theDNAChargeIncreaseProcess, particle);
464 
465  } else if ( particleName == "GenericIon" ) {
466 
467  // *** Ionisation ***
468 
469  G4DNAIonisation* theDNAIonisationProcess =
470  new G4DNAIonisation("GenericIon_G4DNAIonisation");
471  theDNAIonisationProcess->SetEmModel(
472  new G4DNARuddIonisationExtendedModel());
473  ((G4DNARuddIonisationExtendedModel*)
474  (theDNAIonisationProcess->EmModel()))->SelectStationary(true);
475  ph->RegisterProcess(theDNAIonisationProcess, particle);
476 
477  }
478 
479  // Warning : the following particles and processes are needed by EM Physics
480  // builders
481  // They are taken from the default Livermore Physics list
482  // These particles are currently not handled by Geant4-DNA
483 
484  // e+
485 
486  else if (particleName == "e+") {
487 
488  // Identical to G4EmStandardPhysics_stationary
489 
490  G4eMultipleScattering* msc = new G4eMultipleScattering();
491  msc->SetStepLimitType(fUseDistanceToBoundary);
492  G4eIonisation* eIoni = new G4eIonisation();
493  eIoni->SetStepFunction(0.2, 100*um);
494 
495  ph->RegisterProcess(msc, particle);
496  ph->RegisterProcess(eIoni, particle);
497  ph->RegisterProcess(new G4eBremsstrahlung(), particle);
498  ph->RegisterProcess(new G4eplusAnnihilation(), particle);
499 
500  } else if (particleName == "gamma") {
501 
502  // photoelectric effect - Livermore model only
503  G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
504  thePhotoElectricEffect->SetEmModel(new G4LivermorePhotoElectricModel());
505  ph->RegisterProcess(thePhotoElectricEffect, particle);
506 
507  // Compton scattering - Livermore model only
508  G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
509  theComptonScattering->SetEmModel(new G4LivermoreComptonModel());
510  ph->RegisterProcess(theComptonScattering, particle);
511 
512  // gamma conversion - Livermore model below 80 GeV
513  G4GammaConversion* theGammaConversion = new G4GammaConversion();
514  theGammaConversion->SetEmModel(new G4LivermoreGammaConversionModel());
515  ph->RegisterProcess(theGammaConversion, particle);
516 
517  // default Rayleigh scattering is Livermore
518  G4RayleighScattering* theRayleigh = new G4RayleighScattering();
519  ph->RegisterProcess(theRayleigh, particle);
520  }
521 
522  // Warning : end of particles and processes are needed by EM Physics build.
523 
524  }
525 
526  // Deexcitation
527  //
528  G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
529  G4LossTableManager::Instance()->SetAtomDeexcitation(de);
530 }
531