Geant4  10.02.p03
G4EmPenelopePhysics Class Reference

#include <G4EmPenelopePhysics.hh>

Inheritance diagram for G4EmPenelopePhysics:
Collaboration diagram for G4EmPenelopePhysics:

Public Member Functions

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

Private Attributes

G4int verbose
 

Additional Inherited Members

- Static Public Member Functions inherited from G4VPhysicsConstructor
static const G4VPCManagerGetSubInstanceManager ()
 
- Protected Member Functions inherited from G4VPhysicsConstructor
G4bool RegisterProcess (G4VProcess *process, G4ParticleDefinition *particle)
 
G4ParticleTable::G4PTblDicIteratorGetParticleIterator () const
 
- Protected Attributes inherited from G4VPhysicsConstructor
G4int verboseLevel
 
G4String namePhysics
 
G4int typePhysics
 
G4ParticleTabletheParticleTable
 
G4int g4vpcInstanceID
 
- Static Protected Attributes inherited from G4VPhysicsConstructor
static G4RUN_DLL G4VPCManager subInstanceManager
 

Detailed Description

Definition at line 36 of file G4EmPenelopePhysics.hh.

Constructor & Destructor Documentation

◆ G4EmPenelopePhysics() [1/2]

G4EmPenelopePhysics::G4EmPenelopePhysics ( G4int  ver = 1)

Definition at line 133 of file G4EmPenelopePhysics.cc.

134  : G4VPhysicsConstructor("G4EmPenelopePhysics"), verbose(ver)
135 {
137  param->SetDefaults();
138  param->SetVerbose(verbose);
139  param->SetMinEnergy(100*eV);
140  param->SetMaxEnergy(10*TeV);
141  param->SetLowestElectronEnergy(100*eV);
142  param->SetNumberOfBinsPerDecade(20);
143  param->SetMscRangeFactor(0.02);
145  param->SetFluo(true);
146  param->SetPIXEElectronCrossSectionModel("Penelope");
148 }
void SetVerbose(G4int val)
void SetLowestElectronEnergy(G4double val)
void SetMscStepLimitType(G4MscStepLimitType val)
void SetPIXEElectronCrossSectionModel(const G4String &)
void SetMaxEnergy(G4double val)
void SetMscRangeFactor(G4double val)
void SetNumberOfBinsPerDecade(G4int val)
static const double eV
Definition: G4SIunits.hh:212
void SetMinEnergy(G4double val)
static G4EmParameters * Instance()
G4VPhysicsConstructor(const G4String &="")
static const double TeV
Definition: G4SIunits.hh:215
void SetFluo(G4bool val)
Here is the call graph for this function:

◆ G4EmPenelopePhysics() [2/2]

G4EmPenelopePhysics::G4EmPenelopePhysics ( G4int  ver,
const G4String name 
)

Definition at line 152 of file G4EmPenelopePhysics.cc.

153  : G4VPhysicsConstructor("G4EmPenelopePhysics"), verbose(ver)
154 {
156  param->SetDefaults();
157  param->SetVerbose(verbose);
158  param->SetMinEnergy(100*eV);
159  param->SetMaxEnergy(10*TeV);
160  param->SetLowestElectronEnergy(100*eV);
161  param->SetNumberOfBinsPerDecade(20);
162  param->SetMscRangeFactor(0.02);
164  param->SetFluo(true);
165  param->SetPIXEElectronCrossSectionModel("Penelope");
167 }
void SetVerbose(G4int val)
void SetLowestElectronEnergy(G4double val)
void SetMscStepLimitType(G4MscStepLimitType val)
void SetPIXEElectronCrossSectionModel(const G4String &)
void SetMaxEnergy(G4double val)
void SetMscRangeFactor(G4double val)
void SetNumberOfBinsPerDecade(G4int val)
static const double eV
Definition: G4SIunits.hh:212
void SetMinEnergy(G4double val)
static G4EmParameters * Instance()
G4VPhysicsConstructor(const G4String &="")
static const double TeV
Definition: G4SIunits.hh:215
void SetFluo(G4bool val)
Here is the call graph for this function:

◆ ~G4EmPenelopePhysics()

G4EmPenelopePhysics::~G4EmPenelopePhysics ( )
virtual

Definition at line 171 of file G4EmPenelopePhysics.cc.

172 {}

Member Function Documentation

◆ ConstructParticle()

void G4EmPenelopePhysics::ConstructParticle ( void  )
virtual

Implements G4VPhysicsConstructor.

Definition at line 176 of file G4EmPenelopePhysics.cc.

177 {
178  // gamma
179  G4Gamma::Gamma();
180 
181  // leptons
186 
187  // mesons
192 
193  // baryons
196 
197  // ions
200  G4He3::He3();
201  G4Alpha::Alpha();
203 
204  // dna
205  G4EmModelActivator mact;
206  mact.ConstructParticle();
207 }
static G4KaonPlus * KaonPlusDefinition()
Definition: G4KaonPlus.cc:108
static G4GenericIon * GenericIonDefinition()
Definition: G4GenericIon.cc:88
static G4MuonPlus * MuonPlus()
Definition: G4MuonPlus.cc:99
static G4KaonMinus * KaonMinusDefinition()
Definition: G4KaonMinus.cc:108
static G4AntiProton * AntiProton()
Definition: G4AntiProton.cc:93
static G4PionMinus * PionMinusDefinition()
Definition: G4PionMinus.cc:93
static G4Triton * Triton()
Definition: G4Triton.cc:95
static G4PionPlus * PionPlusDefinition()
Definition: G4PionPlus.cc:93
static G4Proton * Proton()
Definition: G4Proton.cc:93
static G4Gamma * Gamma()
Definition: G4Gamma.cc:86
static G4Deuteron * Deuteron()
Definition: G4Deuteron.cc:94
static G4Positron * Positron()
Definition: G4Positron.cc:94
static G4MuonMinus * MuonMinus()
Definition: G4MuonMinus.cc:100
static G4Electron * Electron()
Definition: G4Electron.cc:94
static G4Alpha * Alpha()
Definition: G4Alpha.cc:89
static G4He3 * He3()
Definition: G4He3.cc:94
Here is the call graph for this function:

◆ ConstructProcess()

void G4EmPenelopePhysics::ConstructProcess ( void  )
virtual

Implements G4VPhysicsConstructor.

Definition at line 211 of file G4EmPenelopePhysics.cc.

212 {
213  if(verbose > 1) {
214  G4cout << "### " << GetPhysicsName() << " Construct Processes " << G4endl;
215  }
217 
218  // muon & hadron bremsstrahlung and pair production
227 
228  // muon & hadron multiple scattering
230  mumsc->AddEmModel(0, new G4WentzelVIModel());
231  //G4MuMultipleScattering* pimsc = new G4MuMultipleScattering();
232  //pimsc->AddEmModel(0, new G4WentzelVIModel());
233  //G4MuMultipleScattering* kmsc = new G4MuMultipleScattering();
234  //kmsc->AddEmModel(0, new G4WentzelVIModel());
235  //G4MuMultipleScattering* pmsc = new G4MuMultipleScattering();
236  //pmsc->AddEmModel(0, new G4WentzelVIModel());
237  G4hMultipleScattering* hmsc = new G4hMultipleScattering("ionmsc");
238 
239  // high energy limit for e+- scattering models
240  G4double highEnergyLimit = 100*MeV;
241 
242  // nuclear stopping
243  G4NuclearStopping* pnuc = new G4NuclearStopping();
244 
245  // Add Penelope EM Processes
246  auto myParticleIterator=GetParticleIterator();
247  myParticleIterator->reset();
248 
249  while( (*myParticleIterator)() ){
250 
251  G4ParticleDefinition* particle = myParticleIterator->value();
252  G4String particleName = particle->GetParticleName();
253 
254  //Applicability range for Penelope models
255  //for higher energies, the Standard models are used
256  G4double PenelopeHighEnergyLimit = 1.0*GeV;
257 
258  if (particleName == "gamma") {
259 
260  //Photo-electric effect
261  G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
262  G4PenelopePhotoElectricModel* thePEPenelopeModel = new
264  thePEPenelopeModel->SetHighEnergyLimit(PenelopeHighEnergyLimit);
265  thePhotoElectricEffect->SetEmModel(thePEPenelopeModel, 1);
266  ph->RegisterProcess(thePhotoElectricEffect, particle);
267 
268  //Compton scattering
269  G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
270  G4PenelopeComptonModel* theComptonPenelopeModel =
272  theComptonPenelopeModel->SetHighEnergyLimit(PenelopeHighEnergyLimit);
273  theComptonScattering->SetEmModel(theComptonPenelopeModel, 1);
274  ph->RegisterProcess(theComptonScattering, particle);
275 
276  //Gamma conversion
277  G4GammaConversion* theGammaConversion = new G4GammaConversion();
278  G4PenelopeGammaConversionModel* theGCPenelopeModel =
280  theGammaConversion->SetEmModel(theGCPenelopeModel,1);
281  ph->RegisterProcess(theGammaConversion, particle);
282 
283  //Rayleigh scattering
284  G4RayleighScattering* theRayleigh = new G4RayleighScattering();
285  G4PenelopeRayleighModel* theRayleighPenelopeModel =
287  //theRayleighPenelopeModel->SetHighEnergyLimit(PenelopeHighEnergyLimit);
288  theRayleigh->SetEmModel(theRayleighPenelopeModel, 1);
289  ph->RegisterProcess(theRayleigh, particle);
290 
291  } else if (particleName == "e-") {
292 
293  // multiple scattering
295  G4UrbanMscModel* msc1 = new G4UrbanMscModel();
296  G4WentzelVIModel* msc2 = new G4WentzelVIModel();
297  msc1->SetHighEnergyLimit(highEnergyLimit);
298  msc2->SetLowEnergyLimit(highEnergyLimit);
299  msc->AddEmModel(0, msc1);
300  msc->AddEmModel(0, msc2);
301 
304  ss->SetEmModel(ssm, 1);
305  ss->SetMinKinEnergy(highEnergyLimit);
306  ssm->SetLowEnergyLimit(highEnergyLimit);
307  ssm->SetActivationLowEnergyLimit(highEnergyLimit);
308 
309  //Ionisation
310  G4eIonisation* eIoni = new G4eIonisation();
311  G4PenelopeIonisationModel* theIoniPenelope =
313  theIoniPenelope->SetHighEnergyLimit(PenelopeHighEnergyLimit);
314  eIoni->AddEmModel(0,theIoniPenelope,new G4UniversalFluctuation());
315  eIoni->SetStepFunction(0.2, 100*um); //
316 
317  //Bremsstrahlung
318  G4eBremsstrahlung* eBrem = new G4eBremsstrahlung();
319  G4PenelopeBremsstrahlungModel* theBremPenelope = new
320  G4PenelopeBremsstrahlungModel();
321  theBremPenelope->SetHighEnergyLimit(PenelopeHighEnergyLimit);
322  eBrem->AddEmModel(0,theBremPenelope);
323 
324  // register processes
325  ph->RegisterProcess(msc, particle);
326  ph->RegisterProcess(eIoni, particle);
327  ph->RegisterProcess(eBrem, particle);
328  ph->RegisterProcess(ss, particle);
329 
330  } else if (particleName == "e+") {
331 
332  // multiple scattering
334  G4UrbanMscModel* msc1 = new G4UrbanMscModel();
335  G4WentzelVIModel* msc2 = new G4WentzelVIModel();
336  msc1->SetHighEnergyLimit(highEnergyLimit);
337  msc2->SetLowEnergyLimit(highEnergyLimit);
338  msc->AddEmModel(0, msc1);
339  msc->AddEmModel(0, msc2);
340 
343  ss->SetEmModel(ssm, 1);
344  ss->SetMinKinEnergy(highEnergyLimit);
345  ssm->SetLowEnergyLimit(highEnergyLimit);
346  ssm->SetActivationLowEnergyLimit(highEnergyLimit);
347 
348  //Ionisation
349  G4eIonisation* eIoni = new G4eIonisation();
350  G4PenelopeIonisationModel* theIoniPenelope =
352  theIoniPenelope->SetHighEnergyLimit(PenelopeHighEnergyLimit);
353  eIoni->AddEmModel(0,theIoniPenelope,new G4UniversalFluctuation());
354  eIoni->SetStepFunction(0.2, 100*um); //
355 
356  //Bremsstrahlung
357  G4eBremsstrahlung* eBrem = new G4eBremsstrahlung();
358  G4PenelopeBremsstrahlungModel* theBremPenelope = new
359  G4PenelopeBremsstrahlungModel();
360  theBremPenelope->SetHighEnergyLimit(PenelopeHighEnergyLimit);
361  eBrem->AddEmModel(0,theBremPenelope);
362 
363  //Annihilation
365  G4PenelopeAnnihilationModel* theAnnPenelope = new
367  theAnnPenelope->SetHighEnergyLimit(PenelopeHighEnergyLimit);
368  eAnni->AddEmModel(0,theAnnPenelope);
369 
370  // register processes
371  ph->RegisterProcess(msc, particle);
372  ph->RegisterProcess(eIoni, particle);
373  ph->RegisterProcess(eBrem, particle);
374  ph->RegisterProcess(eAnni, particle);
375  ph->RegisterProcess(ss, particle);
376 
377  } else if (particleName == "mu+" ||
378  particleName == "mu-" ) {
379 
380  G4MuIonisation* muIoni = new G4MuIonisation();
381  muIoni->SetStepFunction(0.2, 50*um);
382 
383  ph->RegisterProcess(mumsc, particle);
384  ph->RegisterProcess(muIoni, particle);
385  ph->RegisterProcess(mub, particle);
386  ph->RegisterProcess(mup, particle);
387  ph->RegisterProcess(new G4CoulombScattering(), particle);
388 
389  } else if (particleName == "alpha" ||
390  particleName == "He3" ) {
391 
393  G4ionIonisation* ionIoni = new G4ionIonisation();
394  ionIoni->SetStepFunction(0.1, 10*um);
395 
396  ph->RegisterProcess(msc, particle);
397  ph->RegisterProcess(ionIoni, particle);
398  ph->RegisterProcess(pnuc, particle);
399 
400  } else if (particleName == "GenericIon") {
401 
402  G4ionIonisation* ionIoni = new G4ionIonisation();
403  ionIoni->SetEmModel(new G4IonParametrisedLossModel());
404  ionIoni->SetStepFunction(0.1, 1*um);
405 
406  ph->RegisterProcess(hmsc, particle);
407  ph->RegisterProcess(ionIoni, particle);
408  ph->RegisterProcess(pnuc, particle);
409 
410  } else if (particleName == "pi+" ||
411  particleName == "pi-" ) {
412 
414  G4hIonisation* hIoni = new G4hIonisation();
415  hIoni->SetStepFunction(0.2, 50*um);
416 
417  ph->RegisterProcess(pimsc, particle);
418  ph->RegisterProcess(hIoni, particle);
419  ph->RegisterProcess(pib, particle);
420  ph->RegisterProcess(pip, particle);
421 
422  } else if (particleName == "kaon+" ||
423  particleName == "kaon-" ) {
424 
426  G4hIonisation* hIoni = new G4hIonisation();
427  hIoni->SetStepFunction(0.2, 50*um);
428 
429  ph->RegisterProcess(kmsc, particle);
430  ph->RegisterProcess(hIoni, particle);
431  ph->RegisterProcess(kb, particle);
432  ph->RegisterProcess(kp, particle);
433 
434  } else if (particleName == "proton" ||
435  particleName == "anti_proton") {
436 
438  G4hIonisation* hIoni = new G4hIonisation();
439  hIoni->SetStepFunction(0.2, 50*um);
440 
441  ph->RegisterProcess(pmsc, particle);
442  ph->RegisterProcess(hIoni, particle);
443  ph->RegisterProcess(pb, particle);
444  ph->RegisterProcess(pp, particle);
445  ph->RegisterProcess(pnuc, particle);
446 
447  } else if (particleName == "B+" ||
448  particleName == "B-" ||
449  particleName == "D+" ||
450  particleName == "D-" ||
451  particleName == "Ds+" ||
452  particleName == "Ds-" ||
453  particleName == "anti_He3" ||
454  particleName == "anti_alpha" ||
455  particleName == "anti_deuteron" ||
456  particleName == "anti_lambda_c+" ||
457  particleName == "anti_omega-" ||
458  particleName == "anti_sigma_c+" ||
459  particleName == "anti_sigma_c++" ||
460  particleName == "anti_sigma+" ||
461  particleName == "anti_sigma-" ||
462  particleName == "anti_triton" ||
463  particleName == "anti_xi_c+" ||
464  particleName == "anti_xi-" ||
465  particleName == "deuteron" ||
466  particleName == "lambda_c+" ||
467  particleName == "omega-" ||
468  particleName == "sigma_c+" ||
469  particleName == "sigma_c++" ||
470  particleName == "sigma+" ||
471  particleName == "sigma-" ||
472  particleName == "tau+" ||
473  particleName == "tau-" ||
474  particleName == "triton" ||
475  particleName == "xi_c+" ||
476  particleName == "xi-" ) {
477 
478  ph->RegisterProcess(hmsc, particle);
479  ph->RegisterProcess(new G4hIonisation(), particle);
480  }
481  }
482 
483  // Nuclear stopping
484  pnuc->SetMaxKinEnergy(MeV);
485 
486  // Deexcitation
487  //
488  G4VAtomDeexcitation* deexcitation = new G4UAtomicDeexcitation();
490 
491  G4EmModelActivator mact;
492  mact.ConstructProcess();
493 }
static const double MeV
Definition: G4SIunits.hh:211
static G4LossTableManager * Instance()
void SetStepFunction(G4double v1, G4double v2)
void SetHighEnergyLimit(G4double)
Definition: G4VEmModel.hh:725
void SetEmModel(G4VEmModel *, G4int index=1)
const G4String & GetParticleName() const
const G4String & GetPhysicsName() const
G4GLOB_DLL std::ostream G4cout
G4bool RegisterProcess(G4VProcess *process, G4ParticleDefinition *particle)
static const double GeV
Definition: G4SIunits.hh:214
void AddEmModel(G4int, G4VEmModel *, G4VEmFluctuationModel *fluc=0, const G4Region *region=0)
void SetActivationLowEnergyLimit(G4double)
Definition: G4VEmModel.hh:746
void SetMaxKinEnergy(G4double e)
void AddEmModel(G4int, G4VEmModel *, const G4Region *region=0)
void AddEmModel(G4int order, G4VEmModel *, const G4Region *region=0)
static G4PhysicsListHelper * GetPhysicsListHelper()
void SetEmModel(G4VEmModel *, G4int index=1)
static const double um
Definition: G4SIunits.hh:112
#define G4endl
Definition: G4ios.hh:61
void SetMinKinEnergy(G4double e)
G4ParticleTable::G4PTblDicIterator * GetParticleIterator() const
double G4double
Definition: G4Types.hh:76
void SetLowEnergyLimit(G4double)
Definition: G4VEmModel.hh:732
void SetAtomDeexcitation(G4VAtomDeexcitation *)
Here is the call graph for this function:

Member Data Documentation

◆ verbose

G4int G4EmPenelopePhysics::verbose
private

Definition at line 51 of file G4EmPenelopePhysics.hh.


The documentation for this class was generated from the following files: