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