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

#include <G4EmDNAPhysics_stationary.hh>

+ Inheritance diagram for G4EmDNAPhysics_stationary:

Public Member Functions

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

Constructor & Destructor Documentation

◆ G4EmDNAPhysics_stationary() [1/2]

G4EmDNAPhysics_stationary::G4EmDNAPhysics_stationary ( G4int  ver = 1)

Definition at line 86 of file G4EmDNAPhysics_stationary.cc.

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}
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() [2/2]

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

Definition at line 102 of file G4EmDNAPhysics_stationary.cc.

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}

◆ ~G4EmDNAPhysics_stationary()

G4EmDNAPhysics_stationary::~G4EmDNAPhysics_stationary ( )
virtual

Definition at line 117 of file G4EmDNAPhysics_stationary.cc.

118{}

Member Function Documentation

◆ ConstructParticle()

void G4EmDNAPhysics_stationary::ConstructParticle ( )
virtual

Implements G4VPhysicsConstructor.

Definition at line 122 of file G4EmDNAPhysics_stationary.cc.

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}
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::ConstructProcess ( )
virtual

Implements G4VPhysicsConstructor.

Definition at line 147 of file G4EmDNAPhysics_stationary.cc.

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}
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: