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

#include <G4EmStandardPhysics_option4.hh>

+ Inheritance diagram for G4EmStandardPhysics_option4:

Public Member Functions

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

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 53 of file G4EmStandardPhysics_option4.hh.

Constructor & Destructor Documentation

◆ G4EmStandardPhysics_option4() [1/2]

G4EmStandardPhysics_option4::G4EmStandardPhysics_option4 ( G4int  ver = 1)

Definition at line 122 of file G4EmStandardPhysics_option4.cc.

123 : G4VPhysicsConstructor("G4EmStandard_opt4"), verbose(ver)
124{
125 G4LossTableManager::Instance();
126 SetPhysicsType(bElectromagnetic);
127}
bElectromagnetic
@ bElectromagnetic
Definition: G4BuilderType.hh:48
G4LossTableManager::Instance
static G4LossTableManager * Instance()
Definition: G4LossTableManager.cc:107

◆ G4EmStandardPhysics_option4() [2/2]

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

Definition at line 131 of file G4EmStandardPhysics_option4.cc.

132 : G4VPhysicsConstructor("G4EmStandard_opt3"), verbose(ver)
133{
134 G4LossTableManager::Instance();
135 SetPhysicsType(bElectromagnetic);
136}

◆ ~G4EmStandardPhysics_option4()

G4EmStandardPhysics_option4::~G4EmStandardPhysics_option4 ( )
virtual

Definition at line 140 of file G4EmStandardPhysics_option4.cc.

141{}

Member Function Documentation

◆ ConstructParticle()

void G4EmStandardPhysics_option4::ConstructParticle ( )
virtual

Implements G4VPhysicsConstructor.

Definition at line 145 of file G4EmStandardPhysics_option4.cc.

146{
147// gamma
148 G4Gamma::Gamma();
149
150// leptons
151 G4Electron::Electron();
152 G4Positron::Positron();
153 G4MuonPlus::MuonPlus();
154 G4MuonMinus::MuonMinus();
155
156// mesons
157 G4PionPlus::PionPlusDefinition();
158 G4PionMinus::PionMinusDefinition();
159 G4KaonPlus::KaonPlusDefinition();
160 G4KaonMinus::KaonMinusDefinition();
161
162// barions
163 G4Proton::Proton();
164 G4AntiProton::AntiProton();
165
166// ions
167 G4Deuteron::Deuteron();
168 G4Triton::Triton();
169 G4He3::He3();
170 G4Alpha::Alpha();
171 G4GenericIon::GenericIonDefinition();
172}
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 G4EmStandardPhysics_option4::ConstructProcess ( )
virtual

Implements G4VPhysicsConstructor.

Definition at line 176 of file G4EmStandardPhysics_option4.cc.

177{
178 G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
179
180 // muon & hadron bremsstrahlung and pair production
181 G4MuBremsstrahlung* mub = new G4MuBremsstrahlung();
182 G4MuPairProduction* mup = new G4MuPairProduction();
183 G4hBremsstrahlung* pib = new G4hBremsstrahlung();
184 G4hPairProduction* pip = new G4hPairProduction();
185 G4hBremsstrahlung* kb = new G4hBremsstrahlung();
186 G4hPairProduction* kp = new G4hPairProduction();
187 G4hBremsstrahlung* pb = new G4hBremsstrahlung();
188 G4hPairProduction* pp = new G4hPairProduction();
189
190 // muon & hadron multiple scattering
191 G4MuMultipleScattering* mumsc = new G4MuMultipleScattering();
192 mumsc->AddEmModel(0, new G4WentzelVIModel());
193 G4hMultipleScattering* pimsc = new G4hMultipleScattering();
194 pimsc->AddEmModel(0, new G4WentzelVIModel());
195 G4hMultipleScattering* kmsc = new G4hMultipleScattering();
196 kmsc->AddEmModel(0, new G4WentzelVIModel());
197 G4hMultipleScattering* pmsc = new G4hMultipleScattering();
198 pmsc->AddEmModel(0, new G4WentzelVIModel());
199 G4hMultipleScattering* hmsc = new G4hMultipleScattering("ionmsc");
200
201 // high energy limit for e+- scattering models
202 G4double highEnergyLimit = 100*MeV;
203
204 // nuclear stopping
205 G4NuclearStopping* ionnuc = new G4NuclearStopping();
206 G4NuclearStopping* pnuc = new G4NuclearStopping();
207
208 // Add standard EM Processes
209 theParticleIterator->reset();
210 while( (*theParticleIterator)() ){
211 G4ParticleDefinition* particle = theParticleIterator->value();
212 G4String particleName = particle->GetParticleName();
213 if(verbose > 1)
214 G4cout << "### " << GetPhysicsName() << " instantiates for "
215 << particleName << G4endl;
216
217 if (particleName == "gamma") {
218
219 // Compton scattering
220 G4ComptonScattering* cs = new G4ComptonScattering;
221 cs->SetEmModel(new G4KleinNishinaModel(),1);
222 G4VEmModel* theLowEPComptonModel = new G4LowEPComptonModel();
223 theLowEPComptonModel->SetHighEnergyLimit(20*MeV);
224 cs->AddEmModel(0, theLowEPComptonModel);
225 ph->RegisterProcess(cs, particle);
226
227 // Photoelectric
228 G4PhotoElectricEffect* pe = new G4PhotoElectricEffect();
229 G4VEmModel* theLivermorePEModel = new G4LivermorePhotoElectricModel();
230 theLivermorePEModel->SetHighEnergyLimit(10*GeV);
231 pe->SetEmModel(theLivermorePEModel,1);
232 ph->RegisterProcess(pe, particle);
233
234 // Gamma conversion
235 G4GammaConversion* gc = new G4GammaConversion();
236 G4VEmModel* thePenelopeGCModel = new G4PenelopeGammaConversionModel();
237 thePenelopeGCModel->SetHighEnergyLimit(1*GeV);
238 gc->SetEmModel(thePenelopeGCModel,1);
239 ph->RegisterProcess(gc, particle);
240
241 // Rayleigh scattering
242 ph->RegisterProcess(new G4RayleighScattering(), particle);
243
244 } else if (particleName == "e-") {
245
246 // multiple scattering
247 G4eMultipleScattering* msc = new G4eMultipleScattering;
248 msc->SetStepLimitType(fUseDistanceToBoundary);
249 G4UrbanMscModel95* msc1 = new G4UrbanMscModel95();
250 G4WentzelVIModel* msc2 = new G4WentzelVIModel();
251 msc1->SetHighEnergyLimit(highEnergyLimit);
252 msc2->SetLowEnergyLimit(highEnergyLimit);
253 msc->AddEmModel(0, msc1);
254 msc->AddEmModel(0, msc2);
255
256 G4eCoulombScatteringModel* ssm = new G4eCoulombScatteringModel();
257 G4CoulombScattering* ss = new G4CoulombScattering();
258 ss->SetEmModel(ssm, 1);
259 ss->SetMinKinEnergy(highEnergyLimit);
260 ssm->SetLowEnergyLimit(highEnergyLimit);
261 ssm->SetActivationLowEnergyLimit(highEnergyLimit);
262
263 // ionisation
264 G4eIonisation* eIoni = new G4eIonisation();
265 eIoni->SetStepFunction(0.2, 100*um);
266 G4VEmModel* theIoniPenelope = new G4PenelopeIonisationModel();
267 theIoniPenelope->SetHighEnergyLimit(0.1*MeV);
268 eIoni->AddEmModel(0, theIoniPenelope, new G4UniversalFluctuation());
269
270 // bremsstrahlung
271 G4eBremsstrahlung* eBrem = new G4eBremsstrahlung();
272
273 ph->RegisterProcess(msc, particle);
274 ph->RegisterProcess(eIoni, particle);
275 ph->RegisterProcess(eBrem, particle);
276 ph->RegisterProcess(ss, particle);
277
278 } else if (particleName == "e+") {
279
280 // multiple scattering
281 G4eMultipleScattering* msc = new G4eMultipleScattering;
282 msc->SetStepLimitType(fUseDistanceToBoundary);
283 G4UrbanMscModel95* msc1 = new G4UrbanMscModel95();
284 G4WentzelVIModel* msc2 = new G4WentzelVIModel();
285 msc1->SetHighEnergyLimit(highEnergyLimit);
286 msc2->SetLowEnergyLimit(highEnergyLimit);
287 msc->AddEmModel(0, msc1);
288 msc->AddEmModel(0, msc2);
289
290 G4eCoulombScatteringModel* ssm = new G4eCoulombScatteringModel();
291 G4CoulombScattering* ss = new G4CoulombScattering();
292 ss->SetEmModel(ssm, 1);
293 ss->SetMinKinEnergy(highEnergyLimit);
294 ssm->SetLowEnergyLimit(highEnergyLimit);
295 ssm->SetActivationLowEnergyLimit(highEnergyLimit);
296
297 // ionisation
298 G4eIonisation* eIoni = new G4eIonisation();
299 eIoni->SetStepFunction(0.2, 100*um);
300 G4VEmModel* theIoniPenelope = new G4PenelopeIonisationModel();
301 theIoniPenelope->SetHighEnergyLimit(0.1*MeV);
302 eIoni->AddEmModel(0, theIoniPenelope, new G4UniversalFluctuation());
303
304 // bremsstrahlung
305 G4eBremsstrahlung* eBrem = new G4eBremsstrahlung();
306
307 ph->RegisterProcess(msc, particle);
308 ph->RegisterProcess(eIoni, particle);
309 ph->RegisterProcess(eBrem, particle);
310 ph->RegisterProcess(ss, particle);
311
312 // annihilation at rest and in flight
313 ph->RegisterProcess(new G4eplusAnnihilation(), particle);
314
315 } else if (particleName == "mu+" ||
316 particleName == "mu-" ) {
317
318 G4MuIonisation* muIoni = new G4MuIonisation();
319 muIoni->SetStepFunction(0.2, 50*um);
320
321 ph->RegisterProcess(mumsc, particle);
322 ph->RegisterProcess(muIoni, particle);
323 ph->RegisterProcess(mub, particle);
324 ph->RegisterProcess(mup, particle);
325 ph->RegisterProcess(new G4CoulombScattering(), particle);
326
327 } else if (particleName == "alpha" ||
328 particleName == "He3") {
329
330 G4hMultipleScattering* msc = new G4hMultipleScattering();
331 G4ionIonisation* ionIoni = new G4ionIonisation();
332 ionIoni->SetStepFunction(0.1, 10*um);
333
334 ph->RegisterProcess(msc, particle);
335 ph->RegisterProcess(ionIoni, particle);
336 ph->RegisterProcess(ionnuc, particle);
337
338 } else if (particleName == "GenericIon") {
339
340 G4ionIonisation* ionIoni = new G4ionIonisation();
341 ionIoni->SetEmModel(new G4IonParametrisedLossModel());
342 ionIoni->SetStepFunction(0.1, 1*um);
343
344 ph->RegisterProcess(hmsc, particle);
345 ph->RegisterProcess(ionIoni, particle);
346 ph->RegisterProcess(ionnuc, particle);
347
348 } else if (particleName == "pi+" ||
349 particleName == "pi-" ) {
350
351 //G4hMultipleScattering* pimsc = new G4hMultipleScattering();
352 G4hIonisation* hIoni = new G4hIonisation();
353 hIoni->SetStepFunction(0.2, 50*um);
354
355 ph->RegisterProcess(pimsc, particle);
356 ph->RegisterProcess(hIoni, particle);
357 ph->RegisterProcess(pib, particle);
358 ph->RegisterProcess(pip, particle);
359
360 } else if (particleName == "kaon+" ||
361 particleName == "kaon-" ) {
362
363 //G4hMultipleScattering* kmsc = new G4hMultipleScattering();
364 G4hIonisation* hIoni = new G4hIonisation();
365 hIoni->SetStepFunction(0.2, 50*um);
366
367 ph->RegisterProcess(kmsc, particle);
368 ph->RegisterProcess(hIoni, particle);
369 ph->RegisterProcess(kb, particle);
370 ph->RegisterProcess(kp, particle);
371
372 } else if (particleName == "proton" ||
373 particleName == "anti_proton") {
374
375 //G4hMultipleScattering* pmsc = new G4hMultipleScattering();
376 G4hIonisation* hIoni = new G4hIonisation();
377 hIoni->SetStepFunction(0.2, 50*um);
378
379 ph->RegisterProcess(pmsc, particle);
380 ph->RegisterProcess(hIoni, particle);
381 ph->RegisterProcess(pb, particle);
382 ph->RegisterProcess(pp, particle);
383 ph->RegisterProcess(pnuc, particle);
384
385 } else if (particleName == "B+" ||
386 particleName == "B-" ||
387 particleName == "D+" ||
388 particleName == "D-" ||
389 particleName == "Ds+" ||
390 particleName == "Ds-" ||
391 particleName == "anti_He3" ||
392 particleName == "anti_alpha" ||
393 particleName == "anti_deuteron" ||
394 particleName == "anti_lambda_c+" ||
395 particleName == "anti_omega-" ||
396 particleName == "anti_sigma_c+" ||
397 particleName == "anti_sigma_c++" ||
398 particleName == "anti_sigma+" ||
399 particleName == "anti_sigma-" ||
400 particleName == "anti_triton" ||
401 particleName == "anti_xi_c+" ||
402 particleName == "anti_xi-" ||
403 particleName == "deuteron" ||
404 particleName == "lambda_c+" ||
405 particleName == "omega-" ||
406 particleName == "sigma_c+" ||
407 particleName == "sigma_c++" ||
408 particleName == "sigma+" ||
409 particleName == "sigma-" ||
410 particleName == "tau+" ||
411 particleName == "tau-" ||
412 particleName == "triton" ||
413 particleName == "xi_c+" ||
414 particleName == "xi-" ) {
415
416 ph->RegisterProcess(hmsc, particle);
417 ph->RegisterProcess(new G4hIonisation(), particle);
418 ph->RegisterProcess(pnuc, particle);
419 }
420 }
421
422 // Em options
423 //
424 G4EmProcessOptions opt;
425 opt.SetVerbose(verbose);
426
427 // Multiple Coulomb scattering
428 //
429 opt.SetPolarAngleLimit(CLHEP::pi);
430
431 // Physics tables
432 //
433 opt.SetMinEnergy(10*eV);
434 opt.SetMaxEnergy(10*TeV);
435 opt.SetDEDXBinning(240);
436 opt.SetLambdaBinning(240);
437
438 // Nuclear stopping
439 pnuc->SetMaxKinEnergy(MeV);
440
441 // Ionization
442 //
443 //opt.SetSubCutoff(true);
444
445 // Deexcitation
446 G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
447 G4LossTableManager::Instance()->SetAtomDeexcitation(de);
448 de->SetFluo(true);
449}
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: