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_option2 Class Reference

#include <G4EmDNAPhysics_stationary_option2.hh>

+ Inheritance diagram for G4EmDNAPhysics_stationary_option2:

Public Member Functions

 G4EmDNAPhysics_stationary_option2 (G4int ver=1)
 
 G4EmDNAPhysics_stationary_option2 (G4int ver, const G4String &name)
 
virtual ~G4EmDNAPhysics_stationary_option2 ()
 
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_option2.hh.

Constructor & Destructor Documentation

◆ G4EmDNAPhysics_stationary_option2() [1/2]

G4EmDNAPhysics_stationary_option2::G4EmDNAPhysics_stationary_option2 ( G4int  ver = 1)

Definition at line 86 of file G4EmDNAPhysics_stationary_option2.cc.

87 : G4VPhysicsConstructor("G4EmDNAPhysics_stationary_option2"), 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}
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_option2() [2/2]

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

Definition at line 102 of file G4EmDNAPhysics_stationary_option2.cc.

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

◆ ~G4EmDNAPhysics_stationary_option2()

G4EmDNAPhysics_stationary_option2::~G4EmDNAPhysics_stationary_option2 ( )
virtual

Definition at line 118 of file G4EmDNAPhysics_stationary_option2.cc.

119{}

Member Function Documentation

◆ ConstructParticle()

void G4EmDNAPhysics_stationary_option2::ConstructParticle ( )
virtual

Implements G4VPhysicsConstructor.

Definition at line 123 of file G4EmDNAPhysics_stationary_option2.cc.

124{
125// bosons
126 G4Gamma::Gamma();
127
128// leptons
129 G4Electron::Electron();
130 G4Positron::Positron();
131
132// baryons
133 G4Proton::Proton();
134
135 G4GenericIon::GenericIonDefinition();
136
137 G4DNAGenericIonsManager * genericIonsManager;
138 genericIonsManager=G4DNAGenericIonsManager::Instance();
139 genericIonsManager->GetIon("alpha++");
140 genericIonsManager->GetIon("alpha+");
141 genericIonsManager->GetIon("helium");
142 genericIonsManager->GetIon("hydrogen");
143
144}
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_option2::ConstructProcess ( )
virtual

Implements G4VPhysicsConstructor.

Definition at line 148 of file G4EmDNAPhysics_stationary_option2.cc.

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