Geant4 10.7.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
Public Member Functions | List of all members
G4EmDNAPhysics_stationary_option4 Class Reference

#include <G4EmDNAPhysics_stationary_option4.hh>

+ Inheritance diagram for G4EmDNAPhysics_stationary_option4:

Public Member Functions

 G4EmDNAPhysics_stationary_option4 (G4int ver=1)
 
 G4EmDNAPhysics_stationary_option4 (G4int ver, const G4String &name)
 
virtual ~G4EmDNAPhysics_stationary_option4 ()
 
virtual void ConstructParticle ()
 
virtual void ConstructProcess ()
 
- Public Member Functions inherited from G4VPhysicsConstructor
 G4VPhysicsConstructor (const G4String &="")
 
 G4VPhysicsConstructor (const G4String &name, G4int physics_type)
 
virtual ~G4VPhysicsConstructor ()
 
virtual void ConstructParticle ()=0
 
virtual void ConstructProcess ()=0
 
void SetPhysicsName (const G4String &="")
 
const G4String & GetPhysicsName () const
 
void SetPhysicsType (G4int)
 
G4int GetPhysicsType () const
 
void SetVerboseLevel (G4int value)
 
G4int GetVerboseLevel () const
 
G4int GetInstanceID () const
 
virtual void TerminateWorker ()
 

Additional Inherited Members

- Static Public Member Functions inherited from G4VPhysicsConstructor
static const G4VPCManager & GetSubInstanceManager ()
 
- Protected Types inherited from G4VPhysicsConstructor
using PhysicsBuilder_V = G4VPCData::PhysicsBuilders_V
 
- Protected Member Functions inherited from G4VPhysicsConstructor
G4bool RegisterProcess (G4VProcess *process, G4ParticleDefinition *particle)
 
G4ParticleTable::G4PTblDicIterator * GetParticleIterator () const
 
PhysicsBuilder_V GetBuilders () const
 
void AddBuilder (G4PhysicsBuilderInterface *bld)
 
- Protected Attributes inherited from G4VPhysicsConstructor
G4int verboseLevel
 
G4String namePhysics
 
G4int typePhysics
 
G4ParticleTable * theParticleTable
 
G4int g4vpcInstanceID
 
- Static Protected Attributes inherited from G4VPhysicsConstructor
static G4RUN_DLL G4VPCManager subInstanceManager
 

Detailed Description

Definition at line 34 of file G4EmDNAPhysics_stationary_option4.hh.

Constructor & Destructor Documentation

◆ G4EmDNAPhysics_stationary_option4() [1/2]

G4EmDNAPhysics_stationary_option4::G4EmDNAPhysics_stationary_option4 ( G4int  ver = 1)

Definition at line 88 of file G4EmDNAPhysics_stationary_option4.cc.

89 : G4VPhysicsConstructor("G4EmDNAPhysics_stationary_option4"), verbose(ver)
90{
91 G4EmParameters* param = G4EmParameters::Instance();
92 param->SetDefaults();
93 param->SetFluo(true);
94 param->SetAuger(true);
95 param->SetAugerCascade(true);
96 param->SetDeexcitationIgnoreCut(true);
97 param->ActivateDNA();
98
99 SetPhysicsType(bElectromagnetic);
100}
bElectromagnetic
@ bElectromagnetic
Definition: G4BuilderType.hh:47
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

◆ G4EmDNAPhysics_stationary_option4() [2/2]

G4EmDNAPhysics_stationary_option4::G4EmDNAPhysics_stationary_option4 ( G4int  ver,
const G4String &  name 
)

Definition at line 104 of file G4EmDNAPhysics_stationary_option4.cc.

106 : G4VPhysicsConstructor("G4EmDNAPhysics_stationary_option4"), verbose(ver)
107{
108 G4EmParameters* param = G4EmParameters::Instance();
109 param->SetDefaults();
110 param->SetFluo(true);
111 param->SetAuger(true);
112 param->SetAugerCascade(true);
113 param->SetDeexcitationIgnoreCut(true);
114
115 SetPhysicsType(bElectromagnetic);
116}

◆ ~G4EmDNAPhysics_stationary_option4()

G4EmDNAPhysics_stationary_option4::~G4EmDNAPhysics_stationary_option4 ( )
virtual

Definition at line 120 of file G4EmDNAPhysics_stationary_option4.cc.

121{}

Member Function Documentation

◆ ConstructParticle()

void G4EmDNAPhysics_stationary_option4::ConstructParticle ( )
virtual

Implements G4VPhysicsConstructor.

Definition at line 125 of file G4EmDNAPhysics_stationary_option4.cc.

126{
127// bosons
128 G4Gamma::Gamma();
129
130// leptons
131 G4Electron::Electron();
132 G4Positron::Positron();
133
134// baryons
135 G4Proton::Proton();
136
137 G4GenericIon::GenericIonDefinition();
138
139 G4DNAGenericIonsManager * genericIonsManager;
140 genericIonsManager=G4DNAGenericIonsManager::Instance();
141 genericIonsManager->GetIon("alpha++");
142 genericIonsManager->GetIon("alpha+");
143 genericIonsManager->GetIon("helium");
144 genericIonsManager->GetIon("hydrogen");
145
146}
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
G4Gamma::Gamma
static G4Gamma * Gamma()
Definition: G4Gamma.cc:85
G4GenericIon::GenericIonDefinition
static G4GenericIon * GenericIonDefinition()
Definition: G4GenericIon.cc:87
G4Positron::Positron
static G4Positron * Positron()
Definition: G4Positron.cc:93
G4Proton::Proton
static G4Proton * Proton()
Definition: G4Proton.cc:92

◆ ConstructProcess()

void G4EmDNAPhysics_stationary_option4::ConstructProcess ( )
virtual

Implements G4VPhysicsConstructor.

Definition at line 150 of file G4EmDNAPhysics_stationary_option4.cc.

151{
152 if(verbose > 1) {
153 G4cout << "### " << GetPhysicsName() << " Construct Processes " << G4endl;
154 }
155 G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
156
157 auto myParticleIterator=GetParticleIterator();
158 myParticleIterator->reset();
159 while( (*myParticleIterator)() )
160 {
161 G4ParticleDefinition* particle = myParticleIterator->value();
162 G4String particleName = particle->GetParticleName();
163
164 if (particleName == "e-") {
165
166 // *** Elastic scattering (two alternative models available) ***
167
168 G4DNAElastic* theDNAElasticProcess =
169 new G4DNAElastic("e-_G4DNAElastic");
170 theDNAElasticProcess->SetEmModel(
171 new G4DNAUeharaScreenedRutherfordElasticModel());
172 ph->RegisterProcess(theDNAElasticProcess, particle);
173
174 // *** Excitation ***
175
176 G4DNAExcitation* theDNAExcitationProcess =
177 new G4DNAExcitation("e-_G4DNAExcitation");
178 theDNAExcitationProcess->SetEmModel(
179 new G4DNAEmfietzoglouExcitationModel());
180 ((G4DNAEmfietzoglouExcitationModel*)
181 (theDNAExcitationProcess->EmModel()))->SelectStationary(true);
182 ph->RegisterProcess(theDNAExcitationProcess, particle);
183
184 // *** Ionisation ***
185
186 G4DNAIonisation* theDNAIonisationProcess =
187 new G4DNAIonisation("e-_G4DNAIonisation");
188 theDNAIonisationProcess->SetEmModel(
189 new G4DNAEmfietzoglouIonisationModel());
190 ((G4DNAEmfietzoglouIonisationModel*)
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(
199 new G4DNASancheExcitationModel());
200 ((G4DNASancheExcitationModel*)
201 (theDNAVibExcitationProcess->EmModel()))->SelectStationary(true);
202 ph->RegisterProcess(theDNAVibExcitationProcess, particle);
203
204 // *** Attachment ***
205
206 G4DNAAttachment* theDNAAttachmentProcess =
207 new G4DNAAttachment("e-_G4DNAAttachment");
208 theDNAAttachmentProcess->SetEmModel(
209 new G4DNAMeltonAttachmentModel());
210 ((G4DNAMeltonAttachmentModel*)
211 (theDNAAttachmentProcess->EmModel()))->SelectStationary(true);
212 ph->RegisterProcess(theDNAAttachmentProcess, particle);
213
214 } else if ( particleName == "proton" ) {
215
216 // *** Elastic ***
217
218 G4DNAElastic* theDNAElasticProcess =
219 new G4DNAElastic("proton_G4DNAElastic");
220 theDNAElasticProcess->SetEmModel(
221 new G4DNAIonElasticModel());
222 ((G4DNAIonElasticModel*)
223 (theDNAElasticProcess->EmModel()))->SelectStationary(true);
224 ph->RegisterProcess(theDNAElasticProcess, particle);
225
226 // *** Excitation ***
227
228 G4DNAExcitation* theDNAExcitationProcess =
229 new G4DNAExcitation("proton_G4DNAExcitation");
230
231 theDNAExcitationProcess->SetEmModel(
232 new G4DNAMillerGreenExcitationModel());
233 theDNAExcitationProcess->SetEmModel(
234 new G4DNABornExcitationModel());
235
236 ((G4DNAMillerGreenExcitationModel*)
237 (theDNAExcitationProcess->EmModel()))->SetLowEnergyLimit(10*eV);
238 ((G4DNAMillerGreenExcitationModel*)
239 (theDNAExcitationProcess->EmModel()))->SetHighEnergyLimit(500*keV);
240 ((G4DNAMillerGreenExcitationModel*)
241 (theDNAExcitationProcess->EmModel()))->SelectStationary(true);
242
243 ((G4DNABornExcitationModel*)
244 (theDNAExcitationProcess->EmModel(1)))->SetLowEnergyLimit(500*keV);
245 ((G4DNABornExcitationModel*)
246 (theDNAExcitationProcess->EmModel(1)))->SetHighEnergyLimit(100*MeV);
247 ((G4DNABornExcitationModel*)
248 (theDNAExcitationProcess->EmModel(1)))->SelectStationary(true);
249
250 ph->RegisterProcess(theDNAExcitationProcess, particle);
251
252 // *** Ionisation ***
253
254 G4DNAIonisation* theDNAIonisationProcess =
255 new G4DNAIonisation("proton_G4DNAIonisation");
256
257 theDNAIonisationProcess->SetEmModel(
258 new G4DNARuddIonisationExtendedModel);
259 theDNAIonisationProcess->SetEmModel(
260 new G4DNABornIonisationModel);
261
262 ((G4DNARuddIonisationExtendedModel*)
263 (theDNAIonisationProcess->EmModel()))->SetLowEnergyLimit(0*eV);
264 ((G4DNARuddIonisationExtendedModel*)
265 (theDNAIonisationProcess->EmModel()))->SetHighEnergyLimit(500*keV);
266 ((G4DNARuddIonisationExtendedModel*)
267 (theDNAIonisationProcess->EmModel()))->SelectStationary(true);
268
269 ((G4DNABornIonisationModel*)
270 (theDNAIonisationProcess->EmModel(1)))->SetLowEnergyLimit(500*keV);
271 ((G4DNABornIonisationModel*)
272 (theDNAIonisationProcess->EmModel(1)))->SetHighEnergyLimit(100*MeV);
273 ((G4DNABornIonisationModel*)
274 (theDNAIonisationProcess->EmModel(1)))->SelectStationary(true);
275 //
276 ((G4DNABornIonisationModel*)
277 (theDNAIonisationProcess->EmModel(1)))->SelectFasterComputation(true);
278 //
279
280 ph->RegisterProcess(theDNAIonisationProcess, particle);
281
282 // *** Charge decrease ***
283
284 G4DNAChargeDecrease* theDNAChargeDecreaseProcess =
285 new G4DNAChargeDecrease("proton_G4DNAChargeDecrease");
286 theDNAChargeDecreaseProcess->SetEmModel(
287 new G4DNADingfelderChargeDecreaseModel());
288 ((G4DNADingfelderChargeDecreaseModel*)
289 (theDNAChargeDecreaseProcess->EmModel()))->SelectStationary(true);
290 ph->RegisterProcess(theDNAChargeDecreaseProcess, particle);
291
292 } else if ( particleName == "hydrogen" ) {
293
294 // *** Elastic ***
295
296 G4DNAElastic* theDNAElasticProcess =
297 new G4DNAElastic("hydrogen_G4DNAElastic");
298 theDNAElasticProcess->SetEmModel(
299 new G4DNAIonElasticModel());
300 ((G4DNAIonElasticModel*)
301 (theDNAElasticProcess->EmModel()))->SelectStationary(true);
302 ph->RegisterProcess(theDNAElasticProcess, particle);
303
304 // *** Excitation ***
305
306 G4DNAExcitation* theDNAExcitationProcess =
307 new G4DNAExcitation("hydrogen_G4DNAExcitation");
308 theDNAExcitationProcess->SetEmModel(
309 new G4DNAMillerGreenExcitationModel());
310 ((G4DNAMillerGreenExcitationModel*)
311 (theDNAExcitationProcess->EmModel()))->SelectStationary(true);
312 ph->RegisterProcess(theDNAExcitationProcess, particle);
313
314 // *** Ionisation ***
315
316 G4DNAIonisation* theDNAIonisationProcess =
317 new G4DNAIonisation("hydrogen_G4DNAIonisation");
318 theDNAIonisationProcess->SetEmModel(
319 new G4DNARuddIonisationExtendedModel());
320 ((G4DNARuddIonisationExtendedModel*)
321 (theDNAIonisationProcess->EmModel()))->SelectStationary(true);
322 ph->RegisterProcess(theDNAIonisationProcess, particle);
323
324 // *** Charge increase ***
325
326 G4DNAChargeIncrease* theDNAChargeIncreaseProcess =
327 new G4DNAChargeIncrease("hydrogen_G4DNAChargeIncrease");
328 theDNAChargeIncreaseProcess->SetEmModel(
329 new G4DNADingfelderChargeIncreaseModel());
330 ((G4DNADingfelderChargeIncreaseModel*)
331 (theDNAChargeIncreaseProcess->EmModel()))->SelectStationary(true);
332 ph->RegisterProcess(theDNAChargeIncreaseProcess, particle);
333
334 } else if ( particleName == "alpha" ) {
335
336 // *** Elastic ***
337
338 G4DNAElastic* theDNAElasticProcess =
339 new G4DNAElastic("alpha_G4DNAElastic");
340 theDNAElasticProcess->SetEmModel(
341 new G4DNAIonElasticModel());
342 ((G4DNAIonElasticModel*)
343 (theDNAElasticProcess->EmModel()))->SelectStationary(true);
344 ph->RegisterProcess(theDNAElasticProcess, particle);
345
346 // *** Excitation ***
347
348 G4DNAExcitation* theDNAExcitationProcess =
349 new G4DNAExcitation("alpha_G4DNAExcitation");
350 theDNAExcitationProcess->SetEmModel(
351 new G4DNAMillerGreenExcitationModel());
352 ((G4DNAMillerGreenExcitationModel*)
353 (theDNAExcitationProcess->EmModel()))->SelectStationary(true);
354 ph->RegisterProcess(theDNAExcitationProcess, particle);
355
356 // *** Ionisation ***
357
358 G4DNAIonisation* theDNAIonisationProcess =
359 new G4DNAIonisation("alpha_G4DNAIonisation");
360 theDNAIonisationProcess->SetEmModel(
361 new G4DNARuddIonisationExtendedModel());
362 ((G4DNARuddIonisationExtendedModel*)
363 (theDNAIonisationProcess->EmModel()))->SelectStationary(true);
364 ph->RegisterProcess(theDNAIonisationProcess, particle);
365
366 // *** Charge decrease ***
367
368 G4DNAChargeDecrease* theDNAChargeDecreaseProcess =
369 new G4DNAChargeDecrease("alpha_G4DNAChargeDecrease");
370 theDNAChargeDecreaseProcess->SetEmModel(
371 new G4DNADingfelderChargeDecreaseModel());
372 ((G4DNADingfelderChargeDecreaseModel*)
373 (theDNAChargeDecreaseProcess->EmModel()))->SelectStationary(true);
374 ph->RegisterProcess(theDNAChargeDecreaseProcess, particle);
375
376 } else if ( particleName == "alpha+" ) {
377
378 // *** Elastic ***
379
380 G4DNAElastic* theDNAElasticProcess =
381 new G4DNAElastic("alpha+_G4DNAElastic");
382 theDNAElasticProcess->SetEmModel(
383 new G4DNAIonElasticModel());
384 ((G4DNAIonElasticModel*)
385 (theDNAElasticProcess->EmModel()))->SelectStationary(true);
386 ph->RegisterProcess(theDNAElasticProcess, particle);
387
388 // *** Excitation ***
389
390 G4DNAExcitation* theDNAExcitationProcess =
391 new G4DNAExcitation("alpha+_G4DNAExcitation");
392 theDNAExcitationProcess->SetEmModel(
393 new G4DNAMillerGreenExcitationModel());
394 ((G4DNAMillerGreenExcitationModel*)
395 (theDNAExcitationProcess->EmModel()))->SelectStationary(true);
396 ph->RegisterProcess(theDNAExcitationProcess, particle);
397
398 // *** Ionisation ***
399
400 G4DNAIonisation* theDNAIonisationProcess =
401 new G4DNAIonisation("alpha+_G4DNAIonisation");
402 theDNAIonisationProcess->SetEmModel(
403 new G4DNARuddIonisationExtendedModel());
404 ((G4DNARuddIonisationExtendedModel*)
405 (theDNAIonisationProcess->EmModel()))->SelectStationary(true);
406 ph->RegisterProcess(theDNAIonisationProcess, particle);
407
408 // *** Charge decrease ***
409
410 G4DNAChargeDecrease* theDNAChargeDecreaseProcess =
411 new G4DNAChargeDecrease("alpha+_G4DNAChargeDecrease");
412 theDNAChargeDecreaseProcess->SetEmModel(
413 new G4DNADingfelderChargeDecreaseModel());
414 ((G4DNADingfelderChargeDecreaseModel*)
415 (theDNAChargeDecreaseProcess->EmModel()))->SelectStationary(true);
416 ph->RegisterProcess(theDNAChargeDecreaseProcess, particle);
417
418 // *** Charge increase ***
419
420 G4DNAChargeIncrease* theDNAChargeIncreaseProcess =
421 new G4DNAChargeIncrease("alpha+_G4DNAChargeIncrease");
422 theDNAChargeIncreaseProcess->SetEmModel(
423 new G4DNADingfelderChargeIncreaseModel());
424 ((G4DNADingfelderChargeIncreaseModel*)
425 (theDNAChargeIncreaseProcess->EmModel()))->SelectStationary(true);
426 ph->RegisterProcess(theDNAChargeIncreaseProcess, particle);
427
428 } else if ( particleName == "helium" ) {
429
430 // *** Elastic ***
431
432 G4DNAElastic* theDNAElasticProcess =
433 new G4DNAElastic("helium_G4DNAElastic");
434 theDNAElasticProcess->SetEmModel(
435 new G4DNAIonElasticModel());
436 ((G4DNAIonElasticModel*)
437 (theDNAElasticProcess->EmModel()))->SelectStationary(true);
438 ph->RegisterProcess(theDNAElasticProcess, particle);
439
440 // *** Excitation ***
441
442 G4DNAExcitation* theDNAExcitationProcess =
443 new G4DNAExcitation("helium_G4DNAExcitation");
444 theDNAExcitationProcess->SetEmModel(
445 new G4DNAMillerGreenExcitationModel());
446 ((G4DNAMillerGreenExcitationModel*)
447 (theDNAExcitationProcess->EmModel()))->SelectStationary(true);
448 ph->RegisterProcess(theDNAExcitationProcess, particle);
449
450 // *** Ionisation ***
451
452 G4DNAIonisation* theDNAIonisationProcess =
453 new G4DNAIonisation("helium_G4DNAIonisation");
454 theDNAIonisationProcess->SetEmModel(
455 new G4DNARuddIonisationExtendedModel());
456 ((G4DNARuddIonisationExtendedModel*)
457 (theDNAIonisationProcess->EmModel()))->SelectStationary(true);
458 ph->RegisterProcess(theDNAIonisationProcess, particle);
459
460 // *** Charge increase ***
461
462 G4DNAChargeIncrease* theDNAChargeIncreaseProcess =
463 new G4DNAChargeIncrease("helium_G4DNAChargeIncrease");
464 theDNAChargeIncreaseProcess->SetEmModel(
465 new G4DNADingfelderChargeIncreaseModel());
466 ((G4DNADingfelderChargeIncreaseModel*)
467 (theDNAChargeIncreaseProcess->EmModel()))->SelectStationary(true);
468 ph->RegisterProcess(theDNAChargeIncreaseProcess, particle);
469
470 } else if ( particleName == "GenericIon" ) {
471
472 // *** Ionisation ***
473
474 G4DNAIonisation* theDNAIonisationProcess =
475 new G4DNAIonisation("GenericIon_G4DNAIonisation");
476 theDNAIonisationProcess->SetEmModel(
477 new G4DNARuddIonisationExtendedModel());
478 ((G4DNARuddIonisationExtendedModel*)
479 (theDNAIonisationProcess->EmModel()))->SelectStationary(true);
480 ph->RegisterProcess(theDNAIonisationProcess, particle);
481
482 }
483
484 // Warning : the following particles and processes are needed by EM Physics
485 // builders
486 // They are taken from the default Livermore Physics list
487 // These particles are currently not handled by Geant4-DNA
488
489 // e+
490
491 else if (particleName == "e+") {
492
493 // Identical to G4EmStandardPhysics_stationary
494
495 G4eMultipleScattering* msc = new G4eMultipleScattering();
496 msc->SetStepLimitType(fUseDistanceToBoundary);
497 G4eIonisation* eIoni = new G4eIonisation();
498 eIoni->SetStepFunction(0.2, 100*um);
499
500 ph->RegisterProcess(msc, particle);
501 ph->RegisterProcess(eIoni, particle);
502 ph->RegisterProcess(new G4eBremsstrahlung(), particle);
503 ph->RegisterProcess(new G4eplusAnnihilation(), particle);
504
505 } else if (particleName == "gamma") {
506
507 // photoelectric effect - Livermore model only
508 G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
509 thePhotoElectricEffect->SetEmModel(new G4LivermorePhotoElectricModel());
510 ph->RegisterProcess(thePhotoElectricEffect, particle);
511
512 // Compton scattering - Livermore model only
513 G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
514 theComptonScattering->SetEmModel(new G4LivermoreComptonModel());
515 ph->RegisterProcess(theComptonScattering, particle);
516
517 // gamma conversion - Livermore model below 80 GeV
518 G4GammaConversion* theGammaConversion = new G4GammaConversion();
519 theGammaConversion->SetEmModel(new G4LivermoreGammaConversionModel());
520 ph->RegisterProcess(theGammaConversion, particle);
521
522 // default Rayleigh scattering is Livermore
523 G4RayleighScattering* theRayleigh = new G4RayleighScattering();
524 ph->RegisterProcess(theRayleigh, particle);
525 }
526
527 // Warning : end of particles and processes are needed by EM Physics build.
528
529 }
530
531 // Deexcitation
532 //
533 G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
534 G4LossTableManager::Instance()->SetAtomDeexcitation(de);
535}
G4DNABornExcitationModel
G4DNABornExcitationModel1 G4DNABornExcitationModel
Definition: G4DNABornExcitationModel.hh:40
G4DNABornIonisationModel
#define G4DNABornIonisationModel
Definition: G4DNABornIonisationModel.hh:40
fUseDistanceToBoundary
@ fUseDistanceToBoundary
Definition: G4MscStepLimitType.hh:51
G4endl
#define G4endl
Definition: G4ios.hh:57
G4cout
G4GLOB_DLL std::ostream G4cout
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
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
The documentation for this class was generated from the following files: