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

#include <G4EmBuilder.hh>

Static Public Member Functions

static void ConstructBasicEmPhysics (G4hMultipleScattering *hmsc, const std::vector< G4int > &listHadrons)
 
static void ConstructLightHadrons (G4ParticleDefinition *part1, G4ParticleDefinition *part2, G4bool isHEP, G4bool isProton, G4bool isWVI)
 
static void ConstructLightHadronsSS (G4ParticleDefinition *part1, G4ParticleDefinition *part2, G4bool isHEP)
 
static void ConstructIonEmPhysics (G4hMultipleScattering *hmsc, G4NuclearStopping *nucStopping)
 
static void ConstructIonEmPhysicsSS ()
 
static void ConstructCharged (G4hMultipleScattering *hmsc, G4NuclearStopping *nucStopping, G4bool isWVI=true)
 
static void ConstructChargedSS (G4hMultipleScattering *hmsc)
 
static void ConstructMinimalEmSet ()
 
static void PrepareEMPhysics ()
 
static void ConstructElectronMscProcess (G4VMscModel *msc1, G4VMscModel *msc2, G4ParticleDefinition *particle)
 
static void ConstructElectronSSProcess (G4VEmModel *ss, G4ParticleDefinition *particle)
 

Detailed Description

Definition at line 46 of file G4EmBuilder.hh.

Member Function Documentation

◆ ConstructBasicEmPhysics()

void G4EmBuilder::ConstructBasicEmPhysics ( G4hMultipleScattering * hmsc,
const std::vector< G4int > & listHadrons )
static

Definition at line 104 of file G4EmBuilder.cc.

106{
107 G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
108 G4ParticleTable* table = G4ParticleTable::GetParticleTable();
109
110 for( auto & pdg : partList ) {
111 auto part = table->FindParticle( pdg );
112 if ( part == nullptr || part->GetPDGCharge() == 0.0 ) { continue; }
113 ph->RegisterProcess(hmsc, part);
114 ph->RegisterProcess(new G4hIonisation(), part);
115 }
116}
G4ParticleTable::FindParticle
G4ParticleDefinition * FindParticle(G4int PDGEncoding)
Definition G4ParticleTable.cc:498
G4ParticleTable::GetParticleTable
static G4ParticleTable * GetParticleTable()
Definition G4ParticleTable.cc:82
G4PhysicsListHelper::RegisterProcess
G4bool RegisterProcess(G4VProcess *process, G4ParticleDefinition *particle)
Definition G4PhysicsListHelper.cc:354
G4PhysicsListHelper::GetPhysicsListHelper
static G4PhysicsListHelper * GetPhysicsListHelper()
Definition G4PhysicsListHelper.cc:83

Referenced by ConstructCharged(), ConstructChargedSS(), and G4EmDNABuilder::ConstructStandardEmPhysics().

◆ ConstructCharged()

void G4EmBuilder::ConstructCharged ( G4hMultipleScattering * hmsc,
G4NuclearStopping * nucStopping,
G4bool isWVI = true )
static

Definition at line 232 of file G4EmBuilder.cc.

235{
236 G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
237 G4EmParameters* param = G4EmParameters::Instance();
238 G4HadronicParameters* hpar = G4HadronicParameters::Instance();
239 G4bool isHEP = ( param->MaxKinEnergy() > hpar->EnergyThresholdForHeavyHadrons() );
240
241 // muon multiple and single scattering
242 G4MuMultipleScattering* mumsc = new G4MuMultipleScattering();
243 if(isWVI) { mumsc->SetEmModel(new G4WentzelVIModel()); }
244 G4CoulombScattering* muss = ( isWVI ) ? new G4CoulombScattering() : nullptr;
245
246 // Add standard EM Processes
247 // mu+-
248 G4ParticleDefinition* part = G4MuonPlus::MuonPlus();
249 ph->RegisterProcess(mumsc, part);
250 ph->RegisterProcess(new G4MuIonisation(), part);
251
252 // muon bremsstrahlung and pair production
253 G4MuBremsstrahlung* mub = ( isHEP ) ? new G4MuBremsstrahlung() : nullptr;
254 G4MuPairProduction* mup = ( isHEP ) ? new G4MuPairProduction() : nullptr;
255
256 if( isHEP ) {
257 ph->RegisterProcess(mub, part);
258 ph->RegisterProcess(mup, part);
259 }
260 if( isWVI ) { ph->RegisterProcess(muss, part); }
261
262 part = G4MuonMinus::MuonMinus();
263 ph->RegisterProcess(mumsc, part);
264 ph->RegisterProcess(new G4MuIonisation(), part);
265 if( isHEP ) {
266 ph->RegisterProcess(mub, part);
267 ph->RegisterProcess(mup, part);
268 }
269 if( isWVI ) { ph->RegisterProcess(muss, part); }
270
271 // pi+-
272 ConstructLightHadrons(G4PionPlus::PionPlus(), G4PionMinus::PionMinus(), isHEP, false, isWVI);
273
274 // K+-
275 ConstructLightHadrons(G4KaonPlus::KaonPlus(), G4KaonMinus::KaonMinus(), isHEP, false, isWVI);
276
277 // p, pbar
278 ConstructLightHadrons(G4Proton::Proton(), G4AntiProton::AntiProton(), isHEP, true, isWVI);
279 if( nucStopping != nullptr ) {
280 ph->RegisterProcess(nucStopping, G4Proton::Proton());
281 }
282
283 // ions
284 ConstructIonEmPhysics(hmsc, nucStopping);
285
286 // hyperons and anti particles
287 if( isHEP ) {
288 ConstructBasicEmPhysics(hmsc, G4HadParticles::GetHeavyChargedParticles());
289
290 // b- and c- charged particles
291 if( hpar->EnableBCParticles() ) {
292 ConstructBasicEmPhysics(hmsc, G4HadParticles::GetBCChargedHadrons());
293 }
294 // light hyper-nuclei
295 if( hpar->EnableHyperNuclei() ) {
296 ConstructBasicEmPhysics(hmsc, G4HadParticles::GetChargedHyperNuclei());
297 }
298 }
299}
G4bool
bool G4bool
Definition G4Types.hh:86
G4AntiProton::AntiProton
static G4AntiProton * AntiProton()
Definition G4AntiProton.cc:90
G4EmBuilder::ConstructLightHadrons
static void ConstructLightHadrons(G4ParticleDefinition *part1, G4ParticleDefinition *part2, G4bool isHEP, G4bool isProton, G4bool isWVI)
Definition G4EmBuilder.cc:167
G4EmBuilder::ConstructIonEmPhysics
static void ConstructIonEmPhysics(G4hMultipleScattering *hmsc, G4NuclearStopping *nucStopping)
Definition G4EmBuilder.cc:118
G4EmBuilder::ConstructBasicEmPhysics
static void ConstructBasicEmPhysics(G4hMultipleScattering *hmsc, const std::vector< G4int > &listHadrons)
Definition G4EmBuilder.cc:104
G4EmParameters::Instance
static G4EmParameters * Instance()
Definition G4EmParameters.cc:70
G4EmParameters::MaxKinEnergy
G4double MaxKinEnergy() const
Definition G4EmParameters.cc:596
G4HadParticles::GetBCChargedHadrons
static const std::vector< G4int > & GetBCChargedHadrons()
Definition G4HadParticles.cc:175
G4HadParticles::GetHeavyChargedParticles
static const std::vector< G4int > & GetHeavyChargedParticles()
Definition G4HadParticles.cc:170
G4HadParticles::GetChargedHyperNuclei
static const std::vector< G4int > & GetChargedHyperNuclei()
Definition G4HadParticles.cc:180
G4HadronicParameters::Instance
static G4HadronicParameters * Instance()
Definition G4HadronicParameters.cc:54
G4HadronicParameters::EnergyThresholdForHeavyHadrons
G4double EnergyThresholdForHeavyHadrons() const
Definition G4HadronicParameters.hh:250
G4KaonMinus::KaonMinus
static G4KaonMinus * KaonMinus()
Definition G4KaonMinus.cc:110
G4KaonPlus::KaonPlus
static G4KaonPlus * KaonPlus()
Definition G4KaonPlus.cc:110
G4MuonMinus::MuonMinus
static G4MuonMinus * MuonMinus()
Definition G4MuonMinus.cc:99
G4MuonPlus::MuonPlus
static G4MuonPlus * MuonPlus()
Definition G4MuonPlus.cc:98
G4PionMinus::PionMinus
static G4PionMinus * PionMinus()
Definition G4PionMinus.cc:93
G4PionPlus::PionPlus
static G4PionPlus * PionPlus()
Definition G4PionPlus.cc:93
G4Proton::Proton
static G4Proton * Proton()
Definition G4Proton.cc:90
G4VMultipleScattering::SetEmModel
void SetEmModel(G4VMscModel *, G4int idx=0)
Definition G4VMultipleScattering.cc:129

Referenced by G4EmLivermorePhysics::ConstructProcess(), G4EmLowEPPhysics::ConstructProcess(), G4EmPenelopePhysics::ConstructProcess(), G4EmStandardPhysics::ConstructProcess(), G4EmStandardPhysics_option1::ConstructProcess(), G4EmStandardPhysics_option2::ConstructProcess(), G4EmStandardPhysics_option3::ConstructProcess(), G4EmStandardPhysics_option4::ConstructProcess(), G4EmStandardPhysicsGS::ConstructProcess(), and G4EmStandardPhysicsWVI::ConstructProcess().

◆ ConstructChargedSS()

void G4EmBuilder::ConstructChargedSS ( G4hMultipleScattering * hmsc)
static

Definition at line 301 of file G4EmBuilder.cc.

302{
303 G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
304 G4EmParameters* param = G4EmParameters::Instance();
305 G4HadronicParameters* hpar = G4HadronicParameters::Instance();
306 G4bool isHEP = ( param->MaxKinEnergy() > hpar->EnergyThresholdForHeavyHadrons() );
307
308 // muon multiple and single scattering
309 G4CoulombScattering* muss = new G4CoulombScattering(false);
310
311 // Add standard EM Processes
312 // mu+-
313 G4ParticleDefinition* part = G4MuonPlus::MuonPlus();
314 ph->RegisterProcess(new G4MuIonisation(), part);
315
316 // muon bremsstrahlung and pair production
317 G4MuBremsstrahlung* mub = ( isHEP ) ? new G4MuBremsstrahlung() : nullptr;
318 G4MuPairProduction* mup = ( isHEP ) ? new G4MuPairProduction() : nullptr;
319
320 if( isHEP ) {
321 ph->RegisterProcess(mub, part);
322 ph->RegisterProcess(mup, part);
323 }
324 ph->RegisterProcess(muss, part);
325
326 part = G4MuonMinus::MuonMinus();
327 ph->RegisterProcess(new G4MuIonisation(), part);
328 if( isHEP ) {
329 ph->RegisterProcess(mub, part);
330 ph->RegisterProcess(mup, part);
331 }
332 ph->RegisterProcess(muss, part);
333
334 // pi+-
335 ConstructLightHadronsSS(G4PionPlus::PionPlus(), G4PionMinus::PionMinus(), isHEP);
336
337 // K+-
338 ConstructLightHadronsSS(G4KaonPlus::KaonPlus(), G4KaonMinus::KaonMinus(), isHEP);
339
340 // p, pbar
341 ConstructLightHadronsSS(G4Proton::Proton(), G4AntiProton::AntiProton(), isHEP);
342 // ions
343 ConstructIonEmPhysicsSS();
344
345 // hyperons and anti particles
346 if( isHEP ) {
347 ConstructBasicEmPhysics(hmsc, G4HadParticles::GetHeavyChargedParticles());
348
349 // b- and c- charged particles
350 if( hpar->EnableBCParticles() ) {
351 ConstructBasicEmPhysics(hmsc, G4HadParticles::GetBCChargedHadrons());
352 }
353 // light hyper-nuclei
354 if( hpar->EnableHyperNuclei() ) {
355 ConstructBasicEmPhysics(hmsc, G4HadParticles::GetChargedHyperNuclei());
356 }
357 }
358}
G4EmBuilder::ConstructIonEmPhysicsSS
static void ConstructIonEmPhysicsSS()
Definition G4EmBuilder.cc:146
G4EmBuilder::ConstructLightHadronsSS
static void ConstructLightHadronsSS(G4ParticleDefinition *part1, G4ParticleDefinition *part2, G4bool isHEP)
Definition G4EmBuilder.cc:206

Referenced by G4EmStandardPhysicsSS::ConstructProcess().

◆ ConstructElectronMscProcess()

void G4EmBuilder::ConstructElectronMscProcess ( G4VMscModel * msc1,
G4VMscModel * msc2,
G4ParticleDefinition * particle )
static

Definition at line 409 of file G4EmBuilder.cc.

411{
412 G4TransportationWithMscType type =
413 G4EmParameters::Instance()->TransportationWithMsc();
414 G4ProcessManager* procManager = particle->GetProcessManager();
415 auto plist = procManager->GetProcessList();
416 G4int ptype = (0 < plist->size()) ? (*plist)[0]->GetProcessSubType() : 0;
417 if(type != G4TransportationWithMscType::fDisabled && ptype == TRANSPORTATION) {
418 // Remove default G4Transportation and replace with G4TransportationWithMsc.
419 procManager->RemoveProcess(0);
420 G4TransportationWithMsc* transportWithMsc = new G4TransportationWithMsc(
421 G4TransportationWithMsc::ScatteringType::MultipleScattering);
422 if(type == G4TransportationWithMscType::fMultipleSteps) {
423 transportWithMsc->SetMultipleSteps(true);
424 }
425 transportWithMsc->AddMscModel(msc1);
426 if(msc2 != nullptr) {
427 transportWithMsc->AddMscModel(msc2);
428 }
429 procManager->AddProcess(transportWithMsc, -1, 0, 0);
430 } else {
431 // Register as a separate process.
432 G4eMultipleScattering* msc = new G4eMultipleScattering;
433 msc->SetEmModel(msc1);
434 if(msc2 != nullptr) {
435 msc->SetEmModel(msc2);
436 }
437 G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
438 ph->RegisterProcess(msc, particle);
439 }
440}
G4TransportationWithMscType
G4TransportationWithMscType
Definition G4EmParameters.hh:73
G4int
int G4int
Definition G4Types.hh:85
G4EmParameters::TransportationWithMsc
G4TransportationWithMscType TransportationWithMsc() const
Definition G4EmParameters.cc:1019
G4ParticleDefinition::GetProcessManager
G4ProcessManager * GetProcessManager() const
Definition G4ParticleDefinition.cc:218
G4ProcessManager::GetProcessList
G4ProcessVector * GetProcessList() const
G4ProcessManager::RemoveProcess
G4VProcess * RemoveProcess(G4VProcess *aProcess)
Definition G4ProcessManager.cc:594
G4ProcessManager::AddProcess
G4int AddProcess(G4VProcess *aProcess, G4int ordAtRestDoIt=ordInActive, G4int ordAlongSteptDoIt=ordInActive, G4int ordPostStepDoIt=ordInActive)
Definition G4ProcessManager.cc:405
G4TransportationWithMsc::AddMscModel
void AddMscModel(G4VMscModel *mscModel, G4int order=0, const G4Region *region=nullptr)
Definition G4TransportationWithMsc.cc:108

Referenced by G4EmLivermorePhysics::ConstructProcess(), G4EmPenelopePhysics::ConstructProcess(), G4EmStandardPhysics::ConstructProcess(), G4EmStandardPhysics_option1::ConstructProcess(), G4EmStandardPhysics_option2::ConstructProcess(), G4EmStandardPhysics_option3::ConstructProcess(), and G4EmStandardPhysics_option4::ConstructProcess().

◆ ConstructElectronSSProcess()

void G4EmBuilder::ConstructElectronSSProcess ( G4VEmModel * ss,
G4ParticleDefinition * particle )
static

Definition at line 442 of file G4EmBuilder.cc.

443{
444 G4TransportationWithMscType type = G4EmParameters::Instance()->TransportationWithMsc();
445 G4ProcessManager* procManager = particle->GetProcessManager();
446 auto plist = procManager->GetProcessList();
447 G4int ptype = (0 < plist->size()) ? (*plist)[0]->GetProcessSubType() : 0;
448 if (type != G4TransportationWithMscType::fDisabled && ptype == TRANSPORTATION) {
449 // Remove default G4Transportation and replace with G4TransportationWithMsc.
450 procManager->RemoveProcess(0);
451 G4TransportationWithMsc* transportWithMsc =
452 new G4TransportationWithMsc(G4TransportationWithMsc::ScatteringType::SingleScattering);
453 if (type == G4TransportationWithMscType::fMultipleSteps) {
454 transportWithMsc->SetMultipleSteps(true);
455 }
456 transportWithMsc->AddSSModel(ss);
457 procManager->AddProcess(transportWithMsc, -1, 0, 0);
458 }
459 else {
460 // Register as a separate process.
461 G4CoulombScattering* ssProc = new G4CoulombScattering(false);
462 ssProc->SetEmModel(ss);
463 G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
464 ph->RegisterProcess(ssProc, particle);
465 }
466}
G4TransportationWithMsc::AddSSModel
void AddSSModel(G4VEmModel *model, G4int order=0, const G4Region *region=nullptr)
Definition G4TransportationWithMsc.cc:122
G4VEmProcess::SetEmModel
void SetEmModel(G4VEmModel *, G4int index=0)
Definition G4VEmProcess.cc:136

Referenced by G4EmStandardPhysicsSS::ConstructProcess().

◆ ConstructIonEmPhysics()

void G4EmBuilder::ConstructIonEmPhysics ( G4hMultipleScattering * hmsc,
G4NuclearStopping * nucStopping )
static

Definition at line 118 of file G4EmBuilder.cc.

120{
121 G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
122
123 G4ParticleDefinition* part = G4Deuteron::Deuteron();
124 ph->RegisterProcess(hmsc, part);
125 ph->RegisterProcess(new G4hIonisation(), part);
126
127 part = G4Triton::Triton();
128 ph->RegisterProcess(hmsc, part);
129 ph->RegisterProcess(new G4hIonisation(), part);
130
131 part = G4Alpha::Alpha();
132 ph->RegisterProcess(new G4hMultipleScattering(), part);
133 ph->RegisterProcess(new G4ionIonisation(), part);
134 if( nucStopping != nullptr ) {
135 ph->RegisterProcess(nucStopping, part);
136 }
137
138 part = G4He3::He3();
139 ph->RegisterProcess(new G4hMultipleScattering(), part);
140 ph->RegisterProcess(new G4ionIonisation(), part);
141 if( nucStopping != nullptr ) {
142 ph->RegisterProcess(nucStopping, part);
143 }
144}
G4Alpha::Alpha
static G4Alpha * Alpha()
Definition G4Alpha.cc:83
G4Deuteron::Deuteron
static G4Deuteron * Deuteron()
Definition G4Deuteron.cc:90
G4He3::He3
static G4He3 * He3()
Definition G4He3.cc:90
G4Triton::Triton
static G4Triton * Triton()
Definition G4Triton.cc:90

Referenced by ConstructCharged().

◆ ConstructIonEmPhysicsSS()

void G4EmBuilder::ConstructIonEmPhysicsSS ( )
static

Definition at line 146 of file G4EmBuilder.cc.

147{
148 G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
149
150 G4ParticleDefinition* part = G4Deuteron::Deuteron();
151 ph->RegisterProcess(new G4hIonisation(), part);
152 ph->RegisterProcess(new G4CoulombScattering(false), part);
153
154 part = G4Triton::Triton();
155 ph->RegisterProcess(new G4hIonisation(), part);
156 ph->RegisterProcess(new G4CoulombScattering(false), part);
157
158 part = G4Alpha::Alpha();
159 ph->RegisterProcess(new G4ionIonisation(), part);
160 ph->RegisterProcess(new G4CoulombScattering(false), part);
161
162 part = G4He3::He3();
163 ph->RegisterProcess(new G4ionIonisation(), part);
164 ph->RegisterProcess(new G4CoulombScattering(false), part);
165}

Referenced by ConstructChargedSS().

◆ ConstructLightHadrons()

void G4EmBuilder::ConstructLightHadrons ( G4ParticleDefinition * part1,
G4ParticleDefinition * part2,
G4bool isHEP,
G4bool isProton,
G4bool isWVI )
static

Definition at line 167 of file G4EmBuilder.cc.

171{
172 G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
173
174 G4hMultipleScattering* msc = new G4hMultipleScattering();
175 if(isWVI) { msc->SetEmModel(new G4WentzelVIModel()); }
176 G4CoulombScattering* ss = ( isWVI ) ? new G4CoulombScattering() : nullptr;
177
178 ph->RegisterProcess(msc, part1);
179 ph->RegisterProcess(new G4hIonisation(), part1);
180
181 G4hBremsstrahlung* brem = ( isHEP ) ? new G4hBremsstrahlung() : nullptr;
182 G4hPairProduction* pair = ( isHEP ) ? new G4hPairProduction() : nullptr;
183
184 if( isHEP ) {
185 ph->RegisterProcess(brem, part1);
186 ph->RegisterProcess(pair, part1);
187 }
188 if( isWVI ) { ph->RegisterProcess(ss, part1); }
189
190 if( isProton ) {
191 msc = new G4hMultipleScattering();
192 if(isWVI) {
193 msc->SetEmModel(new G4WentzelVIModel());
194 ss = new G4CoulombScattering();
195 }
196 }
197 ph->RegisterProcess(msc, part2);
198 ph->RegisterProcess(new G4hIonisation(), part2);
199 if( isHEP ) {
200 ph->RegisterProcess(brem, part2);
201 ph->RegisterProcess(pair, part2);
202 }
203 if( isWVI ) { ph->RegisterProcess(ss, part2); }
204}

Referenced by ConstructCharged().

◆ ConstructLightHadronsSS()

void G4EmBuilder::ConstructLightHadronsSS ( G4ParticleDefinition * part1,
G4ParticleDefinition * part2,
G4bool isHEP )
static

Definition at line 206 of file G4EmBuilder.cc.

209{
210 G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
211
212 ph->RegisterProcess(new G4hIonisation(), part1);
213
214 G4hBremsstrahlung* brem = ( isHEP ) ? new G4hBremsstrahlung() : nullptr;
215 G4hPairProduction* pair = ( isHEP ) ? new G4hPairProduction() : nullptr;
216
217 if( isHEP ) {
218 ph->RegisterProcess(brem, part1);
219 ph->RegisterProcess(pair, part1);
220 }
221 auto ss = new G4CoulombScattering(false);
222 ph->RegisterProcess(ss, part1);
223
224 ph->RegisterProcess(new G4hIonisation(), part2);
225 if( isHEP ) {
226 ph->RegisterProcess(brem, part2);
227 ph->RegisterProcess(pair, part2);
228 }
229 ph->RegisterProcess(new G4CoulombScattering(false), part2);
230}

Referenced by ConstructChargedSS().

◆ ConstructMinimalEmSet()

void G4EmBuilder::ConstructMinimalEmSet ( )
static

Definition at line 360 of file G4EmBuilder.cc.

361{
362 // instantiate singletones for physics
363 G4PhysListUtil::InitialiseParameters();
364 // pseudo-particles
365 G4Geantino::GeantinoDefinition();
366 G4ChargedGeantino::ChargedGeantinoDefinition();
367 G4NeutrinoMu::NeutrinoMu();
368 G4AntiNeutrinoMu::AntiNeutrinoMu();
369 G4NeutrinoE::NeutrinoE();
370 G4AntiNeutrinoE::AntiNeutrinoE();
371 // gamma
372 G4Gamma::Gamma();
373 // leptons
374 G4Electron::Electron();
375 G4Positron::Positron();
376 G4MuonPlus::MuonPlus();
377 G4MuonMinus::MuonMinus();
378 // mesons
379 G4PionPlus::PionPlus();
380 G4PionMinus::PionMinus();
381 G4PionZero::PionZero();
382 G4KaonPlus::KaonPlus();
383 G4KaonMinus::KaonMinus();
384 // barions
385 G4Proton::Proton();
386 G4AntiProton::AntiProton();
387 G4Neutron::Neutron();
388 G4AntiNeutron::AntiNeutron();
389 G4Lambda::Lambda();
390 G4AntiLambda::AntiLambda();
391 // ions
392 G4Deuteron::Deuteron();
393 G4Triton::Triton();
394 G4He3::He3();
395 G4Alpha::Alpha();
396 G4GenericIon::GenericIon();
397}
G4AntiLambda::AntiLambda
static G4AntiLambda * AntiLambda()
Definition G4AntiLambda.cc:105
G4AntiNeutrinoE::AntiNeutrinoE
static G4AntiNeutrinoE * AntiNeutrinoE()
Definition G4AntiNeutrinoE.cc:81
G4AntiNeutrinoMu::AntiNeutrinoMu
static G4AntiNeutrinoMu * AntiNeutrinoMu()
Definition G4AntiNeutrinoMu.cc:82
G4AntiNeutron::AntiNeutron
static G4AntiNeutron * AntiNeutron()
Definition G4AntiNeutron.cc:98
G4ChargedGeantino::ChargedGeantinoDefinition
static G4ChargedGeantino * ChargedGeantinoDefinition()
Definition G4ChargedGeantino.cc:76
G4Electron::Electron
static G4Electron * Electron()
Definition G4Electron.cc:91
G4Gamma::Gamma
static G4Gamma * Gamma()
Definition G4Gamma.cc:81
G4Geantino::GeantinoDefinition
static G4Geantino * GeantinoDefinition()
Definition G4Geantino.cc:76
G4GenericIon::GenericIon
static G4GenericIon * GenericIon()
Definition G4GenericIon.cc:89
G4Lambda::Lambda
static G4Lambda * Lambda()
Definition G4Lambda.cc:105
G4NeutrinoE::NeutrinoE
static G4NeutrinoE * NeutrinoE()
Definition G4NeutrinoE.cc:82
G4NeutrinoMu::NeutrinoMu
static G4NeutrinoMu * NeutrinoMu()
Definition G4NeutrinoMu.cc:82
G4Neutron::Neutron
static G4Neutron * Neutron()
Definition G4Neutron.cc:101
G4PhysListUtil::InitialiseParameters
static void InitialiseParameters()
Definition G4PhysListUtil.cc:51
G4PionZero::PionZero
static G4PionZero * PionZero()
Definition G4PionZero.cc:102
G4Positron::Positron
static G4Positron * Positron()
Definition G4Positron.cc:90

Referenced by G4EmDNABuilder::ConstructDNAParticles(), G4EmLivermorePhysics::ConstructParticle(), G4EmLowEPPhysics::ConstructParticle(), G4EmPenelopePhysics::ConstructParticle(), G4EmStandardPhysics::ConstructParticle(), G4EmStandardPhysics_option1::ConstructParticle(), G4EmStandardPhysics_option2::ConstructParticle(), G4EmStandardPhysics_option3::ConstructParticle(), G4EmStandardPhysics_option4::ConstructParticle(), G4EmStandardPhysicsGS::ConstructParticle(), G4EmStandardPhysicsSS::ConstructParticle(), G4EmStandardPhysicsWVI::ConstructParticle(), and G4SpinDecayPhysics::ConstructParticle().

◆ PrepareEMPhysics()

void G4EmBuilder::PrepareEMPhysics ( )
static

Definition at line 399 of file G4EmBuilder.cc.

400{
401 G4LossTableManager* man = G4LossTableManager::Instance();
402 G4VAtomDeexcitation* ad = man->AtomDeexcitation();
403 if(nullptr == ad) {
404 ad = new G4UAtomicDeexcitation();
405 man->SetAtomDeexcitation(ad);
406 }
407}
G4LossTableManager::SetAtomDeexcitation
void SetAtomDeexcitation(G4VAtomDeexcitation *)
Definition G4LossTableManager.cc:1004
G4LossTableManager::Instance
static G4LossTableManager * Instance()
Definition G4LossTableManager.cc:87
G4LossTableManager::AtomDeexcitation
G4VAtomDeexcitation * AtomDeexcitation()
Definition G4LossTableManager.hh:389

Referenced by G4EmLivermorePhysics::ConstructProcess(), G4EmLowEPPhysics::ConstructProcess(), G4EmPenelopePhysics::ConstructProcess(), G4EmStandardPhysics::ConstructProcess(), G4EmStandardPhysics_option1::ConstructProcess(), G4EmStandardPhysics_option2::ConstructProcess(), G4EmStandardPhysics_option3::ConstructProcess(), G4EmStandardPhysics_option4::ConstructProcess(), G4EmStandardPhysicsGS::ConstructProcess(), G4EmStandardPhysicsSS::ConstructProcess(), G4EmStandardPhysicsWVI::ConstructProcess(), and G4EmDNABuilder::ConstructStandardEmPhysics().

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