Geant4 9.6.0
Toolkit for the simulation of the passage of particles through matter
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
Public Member Functions | List of all members
G4EmPenelopePhysics Class Reference

#include <G4EmPenelopePhysics.hh>

+ Inheritance 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 ()
 
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
 

Additional Inherited Members

- Protected Member Functions inherited from G4VPhysicsConstructor
G4bool RegisterProcess (G4VProcess *process, G4ParticleDefinition *particle)
 
- Protected Attributes inherited from G4VPhysicsConstructor
G4int verboseLevel
 
G4String namePhysics
 
G4int typePhysics
 
G4ParticleTable * theParticleTable
 
G4ParticleTable::G4PTblDicIterator * theParticleIterator
 
G4PhysicsListHelper * thePLHelper
 

Detailed Description

Definition at line 36 of file G4EmPenelopePhysics.hh.

Constructor & Destructor Documentation

◆ G4EmPenelopePhysics() [1/2]

G4EmPenelopePhysics::G4EmPenelopePhysics ( G4int  ver = 1)

Definition at line 134 of file G4EmPenelopePhysics.cc.

135 : G4VPhysicsConstructor("G4EmPenelopePhysics"), verbose(ver)
136{
137 G4LossTableManager::Instance();
138 SetPhysicsType(bElectromagnetic);
139}
bElectromagnetic
@ bElectromagnetic
Definition: G4BuilderType.hh:48
G4LossTableManager::Instance
static G4LossTableManager * Instance()
Definition: G4LossTableManager.cc:107

◆ G4EmPenelopePhysics() [2/2]

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

Definition at line 143 of file G4EmPenelopePhysics.cc.

144 : G4VPhysicsConstructor("G4EmPenelopePhysics"), verbose(ver)
145{
146 G4LossTableManager::Instance();
147 SetPhysicsType(bElectromagnetic);
148}

◆ ~G4EmPenelopePhysics()

G4EmPenelopePhysics::~G4EmPenelopePhysics ( )
virtual

Definition at line 152 of file G4EmPenelopePhysics.cc.

153{}

Member Function Documentation

◆ ConstructParticle()

void G4EmPenelopePhysics::ConstructParticle ( )
virtual

Implements G4VPhysicsConstructor.

Definition at line 157 of file G4EmPenelopePhysics.cc.

158{
159// gamma
160 G4Gamma::Gamma();
161
162// leptons
163 G4Electron::Electron();
164 G4Positron::Positron();
165 G4MuonPlus::MuonPlus();
166 G4MuonMinus::MuonMinus();
167
168// mesons
169 G4PionPlus::PionPlusDefinition();
170 G4PionMinus::PionMinusDefinition();
171 G4KaonPlus::KaonPlusDefinition();
172 G4KaonMinus::KaonMinusDefinition();
173
174// baryons
175 G4Proton::Proton();
176 G4AntiProton::AntiProton();
177
178// ions
179 G4Deuteron::Deuteron();
180 G4Triton::Triton();
181 G4He3::He3();
182 G4Alpha::Alpha();
183 G4GenericIon::GenericIonDefinition();
184}
G4Alpha::Alpha
static G4Alpha * Alpha()
Definition: G4Alpha.cc:89
G4AntiProton::AntiProton
static G4AntiProton * AntiProton()
Definition: G4AntiProton.cc:93
G4Deuteron::Deuteron
static G4Deuteron * Deuteron()
Definition: G4Deuteron.cc:94
G4Electron::Electron
static G4Electron * Electron()
Definition: G4Electron.cc:94
G4Gamma::Gamma
static G4Gamma * Gamma()
Definition: G4Gamma.cc:86
G4GenericIon::GenericIonDefinition
static G4GenericIon * GenericIonDefinition()
Definition: G4GenericIon.cc:87
G4He3::He3
static G4He3 * He3()
Definition: G4He3.cc:94
G4KaonMinus::KaonMinusDefinition
static G4KaonMinus * KaonMinusDefinition()
Definition: G4KaonMinus.cc:108
G4KaonPlus::KaonPlusDefinition
static G4KaonPlus * KaonPlusDefinition()
Definition: G4KaonPlus.cc:108
G4MuonMinus::MuonMinus
static G4MuonMinus * MuonMinus()
Definition: G4MuonMinus.cc:100
G4MuonPlus::MuonPlus
static G4MuonPlus * MuonPlus()
Definition: G4MuonPlus.cc:99
G4PionMinus::PionMinusDefinition
static G4PionMinus * PionMinusDefinition()
Definition: G4PionMinus.cc:93
G4PionPlus::PionPlusDefinition
static G4PionPlus * PionPlusDefinition()
Definition: G4PionPlus.cc:93
G4Positron::Positron
static G4Positron * Positron()
Definition: G4Positron.cc:94
G4Proton::Proton
static G4Proton * Proton()
Definition: G4Proton.cc:93
G4Triton::Triton
static G4Triton * Triton()
Definition: G4Triton.cc:95

◆ ConstructProcess()

void G4EmPenelopePhysics::ConstructProcess ( )
virtual

Implements G4VPhysicsConstructor.

Definition at line 188 of file G4EmPenelopePhysics.cc.

189{
190 G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
191
192 // muon & hadron bremsstrahlung and pair production
193 G4MuBremsstrahlung* mub = new G4MuBremsstrahlung();
194 G4MuPairProduction* mup = new G4MuPairProduction();
195 G4hBremsstrahlung* pib = new G4hBremsstrahlung();
196 G4hPairProduction* pip = new G4hPairProduction();
197 G4hBremsstrahlung* kb = new G4hBremsstrahlung();
198 G4hPairProduction* kp = new G4hPairProduction();
199 G4hBremsstrahlung* pb = new G4hBremsstrahlung();
200 G4hPairProduction* pp = new G4hPairProduction();
201
202 // muon & hadron multiple scattering
203 G4MuMultipleScattering* mumsc = new G4MuMultipleScattering();
204 mumsc->AddEmModel(0, new G4WentzelVIModel());
205 G4MuMultipleScattering* pimsc = new G4MuMultipleScattering();
206 pimsc->AddEmModel(0, new G4WentzelVIModel());
207 G4MuMultipleScattering* kmsc = new G4MuMultipleScattering();
208 kmsc->AddEmModel(0, new G4WentzelVIModel());
209 G4MuMultipleScattering* pmsc = new G4MuMultipleScattering();
210 pmsc->AddEmModel(0, new G4WentzelVIModel());
211 G4hMultipleScattering* hmsc = new G4hMultipleScattering("ionmsc");
212
213 // high energy limit for e+- scattering models
214 G4double highEnergyLimit = 100*MeV;
215
216 // nuclear stopping
217 G4NuclearStopping* ionnuc = new G4NuclearStopping();
218 G4NuclearStopping* pnuc = new G4NuclearStopping();
219
220 // Add Penelope EM Processes
221 theParticleIterator->reset();
222
223 while( (*theParticleIterator)() ){
224
225 G4ParticleDefinition* particle = theParticleIterator->value();
226 G4String particleName = particle->GetParticleName();
227
228 if(verbose > 1)
229 G4cout << "### " << GetPhysicsName() << " instantiates for "
230 << particleName << G4endl;
231
232 //Applicability range for Penelope models
233 //for higher energies, the Standard models are used
234 G4double PenelopeHighEnergyLimit = 1.0*GeV;
235
236 if (particleName == "gamma") {
237
238 //Photo-electric effect
239 G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
240 G4PenelopePhotoElectricModel* thePEPenelopeModel = new
241 G4PenelopePhotoElectricModel();
242 thePEPenelopeModel->SetHighEnergyLimit(PenelopeHighEnergyLimit);
243 thePhotoElectricEffect->SetEmModel(thePEPenelopeModel, 1);
244 ph->RegisterProcess(thePhotoElectricEffect, particle);
245
246 //Compton scattering
247 G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
248 G4PenelopeComptonModel* theComptonPenelopeModel =
249 new G4PenelopeComptonModel();
250 theComptonPenelopeModel->SetHighEnergyLimit(PenelopeHighEnergyLimit);
251 theComptonScattering->SetEmModel(theComptonPenelopeModel, 1);
252 ph->RegisterProcess(theComptonScattering, particle);
253
254 //Gamma conversion
255 G4GammaConversion* theGammaConversion = new G4GammaConversion();
256 G4PenelopeGammaConversionModel* theGCPenelopeModel =
257 new G4PenelopeGammaConversionModel();
258 theGammaConversion->SetEmModel(theGCPenelopeModel,1);
259 ph->RegisterProcess(theGammaConversion, particle);
260
261 //Rayleigh scattering
262 G4RayleighScattering* theRayleigh = new G4RayleighScattering();
263 G4PenelopeRayleighModel* theRayleighPenelopeModel =
264 new G4PenelopeRayleighModel();
265 //theRayleighPenelopeModel->SetHighEnergyLimit(PenelopeHighEnergyLimit);
266 theRayleigh->SetEmModel(theRayleighPenelopeModel, 1);
267 ph->RegisterProcess(theRayleigh, particle);
268
269 } else if (particleName == "e-") {
270
271 // multiple scattering
272 G4eMultipleScattering* msc = new G4eMultipleScattering;
273 msc->SetStepLimitType(fUseDistanceToBoundary);
274 G4UrbanMscModel95* msc1 = new G4UrbanMscModel95();
275 G4WentzelVIModel* msc2 = new G4WentzelVIModel();
276 msc1->SetHighEnergyLimit(highEnergyLimit);
277 msc2->SetLowEnergyLimit(highEnergyLimit);
278 msc->AddEmModel(0, msc1);
279 msc->AddEmModel(0, msc2);
280
281 G4eCoulombScatteringModel* ssm = new G4eCoulombScatteringModel();
282 G4CoulombScattering* ss = new G4CoulombScattering();
283 ss->SetEmModel(ssm, 1);
284 ss->SetMinKinEnergy(highEnergyLimit);
285 ssm->SetLowEnergyLimit(highEnergyLimit);
286 ssm->SetActivationLowEnergyLimit(highEnergyLimit);
287 ph->RegisterProcess(msc, particle);
288 ph->RegisterProcess(ss, particle);
289
290 //Ionisation
291 G4eIonisation* eIoni = new G4eIonisation();
292 G4PenelopeIonisationModel* theIoniPenelope =
293 new G4PenelopeIonisationModel();
294 theIoniPenelope->SetHighEnergyLimit(PenelopeHighEnergyLimit);
295 eIoni->AddEmModel(0,theIoniPenelope,new G4UniversalFluctuation());
296 eIoni->SetStepFunction(0.2, 100*um); //
297 ph->RegisterProcess(eIoni, particle);
298
299 //Bremsstrahlung
300 G4eBremsstrahlung* eBrem = new G4eBremsstrahlung();
301 G4PenelopeBremsstrahlungModel* theBremPenelope = new
302 G4PenelopeBremsstrahlungModel();
303 theBremPenelope->SetHighEnergyLimit(PenelopeHighEnergyLimit);
304 eBrem->AddEmModel(0,theBremPenelope);
305 ph->RegisterProcess(eBrem, particle);
306
307 } else if (particleName == "e+") {
308
309 // multiple scattering
310 G4eMultipleScattering* msc = new G4eMultipleScattering;
311 msc->SetStepLimitType(fUseDistanceToBoundary);
312 G4UrbanMscModel95* msc1 = new G4UrbanMscModel95();
313 G4WentzelVIModel* msc2 = new G4WentzelVIModel();
314 msc1->SetHighEnergyLimit(highEnergyLimit);
315 msc2->SetLowEnergyLimit(highEnergyLimit);
316 msc->AddEmModel(0, msc1);
317 msc->AddEmModel(0, msc2);
318
319 G4eCoulombScatteringModel* ssm = new G4eCoulombScatteringModel();
320 G4CoulombScattering* ss = new G4CoulombScattering();
321 ss->SetEmModel(ssm, 1);
322 ss->SetMinKinEnergy(highEnergyLimit);
323 ssm->SetLowEnergyLimit(highEnergyLimit);
324 ssm->SetActivationLowEnergyLimit(highEnergyLimit);
325 ph->RegisterProcess(msc, particle);
326 ph->RegisterProcess(ss, particle);
327
328 //Ionisation
329 G4eIonisation* eIoni = new G4eIonisation();
330 G4PenelopeIonisationModel* theIoniPenelope =
331 new G4PenelopeIonisationModel();
332 theIoniPenelope->SetHighEnergyLimit(PenelopeHighEnergyLimit);
333 eIoni->AddEmModel(0,theIoniPenelope,new G4UniversalFluctuation());
334 eIoni->SetStepFunction(0.2, 100*um); //
335 ph->RegisterProcess(eIoni, particle);
336
337 //Bremsstrahlung
338 G4eBremsstrahlung* eBrem = new G4eBremsstrahlung();
339 G4PenelopeBremsstrahlungModel* theBremPenelope = new
340 G4PenelopeBremsstrahlungModel();
341 theBremPenelope->SetHighEnergyLimit(PenelopeHighEnergyLimit);
342 eBrem->AddEmModel(0,theBremPenelope);
343 ph->RegisterProcess(eBrem, particle);
344
345 //Annihilation
346 G4eplusAnnihilation* eAnni = new G4eplusAnnihilation();
347 G4PenelopeAnnihilationModel* theAnnPenelope = new
348 G4PenelopeAnnihilationModel();
349 theAnnPenelope->SetHighEnergyLimit(PenelopeHighEnergyLimit);
350 eAnni->AddEmModel(0,theAnnPenelope);
351 ph->RegisterProcess(eAnni, particle);
352
353 } else if (particleName == "mu+" ||
354 particleName == "mu-" ) {
355
356 // Identical to G4EmStandardPhysics_option3
357
358 G4MuIonisation* muIoni = new G4MuIonisation();
359 muIoni->SetStepFunction(0.2, 50*um);
360
361 ph->RegisterProcess(mumsc, particle);
362 ph->RegisterProcess(muIoni, particle);
363 ph->RegisterProcess(mub, particle);
364 ph->RegisterProcess(mup, particle);
365 ph->RegisterProcess(new G4CoulombScattering(), particle);
366
367 } else if (particleName == "alpha" ||
368 particleName == "He3" ) {
369
370 // Identical to G4EmStandardPhysics_option3
371
372 G4hMultipleScattering* msc = new G4hMultipleScattering();
373 G4ionIonisation* ionIoni = new G4ionIonisation();
374 ionIoni->SetStepFunction(0.1, 10*um);
375
376 ph->RegisterProcess(msc, particle);
377 ph->RegisterProcess(ionIoni, particle);
378 ph->RegisterProcess(ionnuc, particle);
379
380 } else if (particleName == "GenericIon") {
381
382 // Identical to G4EmStandardPhysics_option3
383
384 G4ionIonisation* ionIoni = new G4ionIonisation();
385 ionIoni->SetEmModel(new G4IonParametrisedLossModel());
386 ionIoni->SetStepFunction(0.1, 1*um);
387
388 ph->RegisterProcess(hmsc, particle);
389 ph->RegisterProcess(ionIoni, particle);
390 ph->RegisterProcess(ionnuc, particle);
391
392 } else if (particleName == "pi+" ||
393 particleName == "pi-" ) {
394
395 G4hIonisation* hIoni = new G4hIonisation();
396 hIoni->SetStepFunction(0.2, 50*um);
397
398 ph->RegisterProcess(pimsc, particle);
399 ph->RegisterProcess(hIoni, particle);
400 ph->RegisterProcess(pib, particle);
401 ph->RegisterProcess(pip, particle);
402
403 } else if (particleName == "kaon+" ||
404 particleName == "kaon-" ) {
405
406 G4hIonisation* hIoni = new G4hIonisation();
407 hIoni->SetStepFunction(0.2, 50*um);
408
409 ph->RegisterProcess(kmsc, particle);
410 ph->RegisterProcess(hIoni, particle);
411 ph->RegisterProcess(kb, particle);
412 ph->RegisterProcess(kp, particle);
413
414 } else if (particleName == "proton" ||
415 particleName == "anti_proton") {
416
417 G4hIonisation* hIoni = new G4hIonisation();
418 hIoni->SetStepFunction(0.2, 50*um);
419
420 ph->RegisterProcess(pmsc, particle);
421 ph->RegisterProcess(hIoni, particle);
422 ph->RegisterProcess(pb, particle);
423 ph->RegisterProcess(pp, particle);
424 ph->RegisterProcess(pnuc, particle);
425
426 } else if (particleName == "B+" ||
427 particleName == "B-" ||
428 particleName == "D+" ||
429 particleName == "D-" ||
430 particleName == "Ds+" ||
431 particleName == "Ds-" ||
432 particleName == "anti_He3" ||
433 particleName == "anti_alpha" ||
434 particleName == "anti_deuteron" ||
435 particleName == "anti_lambda_c+" ||
436 particleName == "anti_omega-" ||
437 particleName == "anti_sigma_c+" ||
438 particleName == "anti_sigma_c++" ||
439 particleName == "anti_sigma+" ||
440 particleName == "anti_sigma-" ||
441 particleName == "anti_triton" ||
442 particleName == "anti_xi_c+" ||
443 particleName == "anti_xi-" ||
444 particleName == "deuteron" ||
445 particleName == "lambda_c+" ||
446 particleName == "omega-" ||
447 particleName == "sigma_c+" ||
448 particleName == "sigma_c++" ||
449 particleName == "sigma+" ||
450 particleName == "sigma-" ||
451 particleName == "tau+" ||
452 particleName == "tau-" ||
453 particleName == "triton" ||
454 particleName == "xi_c+" ||
455 particleName == "xi-" ) {
456
457 // Identical to G4EmStandardPhysics_option3
458
459 ph->RegisterProcess(hmsc, particle);
460 ph->RegisterProcess(new G4hIonisation(), particle);
461 ph->RegisterProcess(pnuc, particle);
462 }
463 }
464
465 // Em options
466 //
467 G4EmProcessOptions opt;
468 opt.SetVerbose(verbose);
469
470 // Multiple Coulomb scattering
471 //
472 //opt.SetMscStepLimitation(fUseDistanceToBoundary);
473 //opt.SetMscRangeFactor(0.02);
474
475 // Physics tables
476 //
477
478 opt.SetMinEnergy(100*eV);
479 opt.SetMaxEnergy(10*TeV);
480 opt.SetDEDXBinning(220);
481 opt.SetLambdaBinning(220);
482
483 // Nuclear stopping
484 pnuc->SetMaxKinEnergy(MeV);
485
486 //opt.SetSplineFlag(true);
487 opt.SetPolarAngleLimit(CLHEP::pi);
488
489 // Ionization
490 //
491 //opt.SetSubCutoff(true);
492
493
494 // Deexcitation
495 //
496 G4VAtomDeexcitation* deexcitation = new G4UAtomicDeexcitation();
497 G4LossTableManager::Instance()->SetAtomDeexcitation(deexcitation);
498 deexcitation->SetFluo(true);
499}
fUseDistanceToBoundary
@ fUseDistanceToBoundary
Definition: G4MscStepLimitType.hh:51
G4double
double G4double
Definition: G4Types.hh:64
G4endl
#define G4endl
Definition: G4ios.hh:52
G4cout
G4DLLIMPORT std::ostream G4cout
G4EmProcessOptions::SetMaxEnergy
void SetMaxEnergy(G4double val)
Definition: G4EmProcessOptions.cc:115
G4EmProcessOptions::SetDEDXBinning
void SetDEDXBinning(G4int val)
Definition: G4EmProcessOptions.cc:136
G4EmProcessOptions::SetLambdaBinning
void SetLambdaBinning(G4int val)
Definition: G4EmProcessOptions.cc:150
G4EmProcessOptions::SetPolarAngleLimit
void SetPolarAngleLimit(G4double val)
Definition: G4EmProcessOptions.cc:364
G4EmProcessOptions::SetVerbose
void SetVerbose(G4int val, const G4String &name="all")
Definition: G4EmProcessOptions.cc:191
G4EmProcessOptions::SetMinEnergy
void SetMinEnergy(G4double val)
Definition: G4EmProcessOptions.cc:108
G4LossTableManager::SetAtomDeexcitation
void SetAtomDeexcitation(G4VAtomDeexcitation *)
Definition: G4LossTableManager.cc:1120
G4ParticleDefinition::GetParticleName
const G4String & GetParticleName() const
Definition: G4ParticleDefinition.hh:115
G4PhysicsListHelper::RegisterProcess
G4bool RegisterProcess(G4VProcess *process, G4ParticleDefinition *particle)
Definition: G4PhysicsListHelper.cc:408
G4PhysicsListHelper::GetPhysicsListHelper
static G4PhysicsListHelper * GetPhysicsListHelper()
Definition: G4PhysicsListHelper.cc:89
G4VEmModel::SetHighEnergyLimit
void SetHighEnergyLimit(G4double)
Definition: G4VEmModel.hh:585
G4VEmModel::SetActivationLowEnergyLimit
void SetActivationLowEnergyLimit(G4double)
Definition: G4VEmModel.hh:606
G4VEmModel::SetLowEnergyLimit
void SetLowEnergyLimit(G4double)
Definition: G4VEmModel.hh:592
G4VEmProcess::AddEmModel
void AddEmModel(G4int, G4VEmModel *, const G4Region *region=0)
Definition: G4VEmProcess.cc:182
G4VEmProcess::SetMinKinEnergy
void SetMinKinEnergy(G4double e)
Definition: G4VEmProcess.cc:1091
G4VEmProcess::SetEmModel
void SetEmModel(G4VEmModel *, G4int index=1)
Definition: G4VEmProcess.cc:221
G4VEmProcess::SetMaxKinEnergy
void SetMaxKinEnergy(G4double e)
Definition: G4VEmProcess.cc:1100
G4VEnergyLossProcess::SetEmModel
void SetEmModel(G4VEmModel *, G4int index=1)
Definition: G4VEnergyLossProcess.cc:349
G4VEnergyLossProcess::AddEmModel
void AddEmModel(G4int, G4VEmModel *, G4VEmFluctuationModel *fluc=0, const G4Region *region=0)
Definition: G4VEnergyLossProcess.cc:331
G4VEnergyLossProcess::SetStepFunction
void SetStepFunction(G4double v1, G4double v2)
Definition: G4VEnergyLossProcess.hh:966
G4VMultipleScattering::AddEmModel
void AddEmModel(G4int order, G4VEmModel *, const G4Region *region=0)
Definition: G4VMultipleScattering.cc:137
G4VMultipleScattering::SetStepLimitType
void SetStepLimitType(G4MscStepLimitType val)
Definition: G4VMultipleScattering.hh:394
G4VPhysicsConstructor::GetPhysicsName
const G4String & GetPhysicsName() const
Definition: G4VPhysicsConstructor.hh:136
G4VPhysicsConstructor::theParticleIterator
G4ParticleTable::G4PTblDicIterator * theParticleIterator
Definition: G4VPhysicsConstructor.hh:113
The documentation for this class was generated from the following files: