Geant4 9.6.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
G4EmStandardPhysics_option4.cc
Go to the documentation of this file.
1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26// $Id$
27//
28//---------------------------------------------------------------------------
29//
30// ClassName: G4EmStandardPhysics_option4
31//
32// Author: V.Ivanchenko 28.09.2012 from Option3 physics constructor
33//
34// Modified:
35//
36//----------------------------------------------------------------------------
37//
38
39#include "G4EmStandardPhysics_option4.hh"
40
41#include "G4SystemOfUnits.hh"
42#include "G4ParticleDefinition.hh"
43#include "G4LossTableManager.hh"
44#include "G4EmProcessOptions.hh"
45
46#include "G4ComptonScattering.hh"
47#include "G4GammaConversion.hh"
48#include "G4PhotoElectricEffect.hh"
49#include "G4RayleighScattering.hh"
50#include "G4PEEffectFluoModel.hh"
51#include "G4KleinNishinaModel.hh"
52#include "G4LowEPComptonModel.hh"
53#include "G4PenelopeGammaConversionModel.hh"
54#include "G4LivermorePhotoElectricModel.hh"
55
56#include "G4eMultipleScattering.hh"
57#include "G4MuMultipleScattering.hh"
58#include "G4hMultipleScattering.hh"
59#include "G4MscStepLimitType.hh"
60#include "G4UrbanMscModel93.hh"
61#include "G4UrbanMscModel95.hh"
62#include "G4UrbanMscModel96.hh"
63#include "G4DummyModel.hh"
64#include "G4WentzelVIModel.hh"
65#include "G4CoulombScattering.hh"
66#include "G4eCoulombScatteringModel.hh"
67
68#include "G4eIonisation.hh"
69#include "G4eBremsstrahlung.hh"
70#include "G4Generator2BS.hh"
71#include "G4Generator2BN.hh"
72#include "G4SeltzerBergerModel.hh"
73#include "G4PenelopeIonisationModel.hh"
74#include "G4UniversalFluctuation.hh"
75
76#include "G4eplusAnnihilation.hh"
77#include "G4UAtomicDeexcitation.hh"
78
79#include "G4MuIonisation.hh"
80#include "G4MuBremsstrahlung.hh"
81#include "G4MuPairProduction.hh"
82#include "G4hBremsstrahlung.hh"
83#include "G4hPairProduction.hh"
84
85#include "G4MuBremsstrahlungModel.hh"
86#include "G4MuPairProductionModel.hh"
87#include "G4hBremsstrahlungModel.hh"
88#include "G4hPairProductionModel.hh"
89
90#include "G4hIonisation.hh"
91#include "G4ionIonisation.hh"
92#include "G4IonParametrisedLossModel.hh"
93#include "G4NuclearStopping.hh"
94
95#include "G4Gamma.hh"
96#include "G4Electron.hh"
97#include "G4Positron.hh"
98#include "G4MuonPlus.hh"
99#include "G4MuonMinus.hh"
100#include "G4PionPlus.hh"
101#include "G4PionMinus.hh"
102#include "G4KaonPlus.hh"
103#include "G4KaonMinus.hh"
104#include "G4Proton.hh"
105#include "G4AntiProton.hh"
106#include "G4Deuteron.hh"
107#include "G4Triton.hh"
108#include "G4He3.hh"
109#include "G4Alpha.hh"
110#include "G4GenericIon.hh"
111
112#include "G4PhysicsListHelper.hh"
113#include "G4BuilderType.hh"
114
115// factory
116#include "G4PhysicsConstructorFactory.hh"
117//
118G4_DECLARE_PHYSCONSTR_FACTORY(G4EmStandardPhysics_option4);
119
120//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
121
122G4EmStandardPhysics_option4::G4EmStandardPhysics_option4(G4int ver)
123 : G4VPhysicsConstructor("G4EmStandard_opt4"), verbose(ver)
124{
125 G4LossTableManager::Instance();
126 SetPhysicsType(bElectromagnetic);
127}
128
129//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
130
131G4EmStandardPhysics_option4::G4EmStandardPhysics_option4(G4int ver, const G4String&)
132 : G4VPhysicsConstructor("G4EmStandard_opt3"), verbose(ver)
133{
134 G4LossTableManager::Instance();
135 SetPhysicsType(bElectromagnetic);
136}
137
138//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
139
140G4EmStandardPhysics_option4::~G4EmStandardPhysics_option4()
141{}
142
143//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
144
145void G4EmStandardPhysics_option4::ConstructParticle()
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}
173
174//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
175
176void G4EmStandardPhysics_option4::ConstructProcess()
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}
450
451//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
bElectromagnetic
@ bElectromagnetic
Definition: G4BuilderType.hh:48
G4EmStandardPhysics_option4.hh
fUseDistanceToBoundary
@ fUseDistanceToBoundary
Definition: G4MscStepLimitType.hh:51
G4_DECLARE_PHYSCONSTR_FACTORY
#define G4_DECLARE_PHYSCONSTR_FACTORY(physics_constructor)
Definition: G4PhysicsConstructorFactory.hh:60
G4double
double G4double
Definition: G4Types.hh:64
G4int
int G4int
Definition: G4Types.hh:66
G4endl
#define G4endl
Definition: G4ios.hh:52
G4cout
G4DLLIMPORT std::ostream G4cout
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
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
G4EmStandardPhysics_option4
Definition: G4EmStandardPhysics_option4.hh:54
G4EmStandardPhysics_option4::ConstructProcess
virtual void ConstructProcess()
Definition: G4EmStandardPhysics_option4.cc:176
G4EmStandardPhysics_option4::ConstructParticle
virtual void ConstructParticle()
Definition: G4EmStandardPhysics_option4.cc:145
G4EmStandardPhysics_option4::G4EmStandardPhysics_option4
G4EmStandardPhysics_option4(G4int ver=1)
Definition: G4EmStandardPhysics_option4.cc:122
G4EmStandardPhysics_option4::~G4EmStandardPhysics_option4
virtual ~G4EmStandardPhysics_option4()
Definition: G4EmStandardPhysics_option4.cc:140
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
G4LossTableManager::SetAtomDeexcitation
void SetAtomDeexcitation(G4VAtomDeexcitation *)
Definition: G4LossTableManager.cc:1120
G4LossTableManager::Instance
static G4LossTableManager * Instance()
Definition: G4LossTableManager.cc:107
G4MuonMinus::MuonMinus
static G4MuonMinus * MuonMinus()
Definition: G4MuonMinus.cc:100
G4MuonPlus::MuonPlus
static G4MuonPlus * MuonPlus()
Definition: G4MuonPlus.cc:99
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
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
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