Geant4 11.1.1
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)
 

Detailed Description

Definition at line 45 of file G4EmBuilder.hh.

Member Function Documentation

◆ ConstructBasicEmPhysics()

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

Definition at line 105 of file G4EmBuilder.cc.

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

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:92
G4EmBuilder::ConstructLightHadrons
static void ConstructLightHadrons(G4ParticleDefinition *part1, G4ParticleDefinition *part2, G4bool isHEP, G4bool isProton, G4bool isWVI)
Definition: G4EmBuilder.cc:168
G4EmBuilder::ConstructIonEmPhysics
static void ConstructIonEmPhysics(G4hMultipleScattering *hmsc, G4NuclearStopping *nucStopping)
Definition: G4EmBuilder.cc:119
G4EmBuilder::ConstructBasicEmPhysics
static void ConstructBasicEmPhysics(G4hMultipleScattering *hmsc, const std::vector< G4int > &listHadrons)
Definition: G4EmBuilder.cc:105
G4EmParameters::Instance
static G4EmParameters * Instance()
Definition: G4EmParameters.cc:70
G4EmParameters::MaxKinEnergy
G4double MaxKinEnergy() const
Definition: G4EmParameters.cc:593
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::EnableHyperNuclei
G4bool EnableHyperNuclei() const
Definition: G4HadronicParameters.hh:237
G4HadronicParameters::EnableBCParticles
G4bool EnableBCParticles() const
Definition: G4HadronicParameters.hh:233
G4HadronicParameters::EnergyThresholdForHeavyHadrons
G4double EnergyThresholdForHeavyHadrons() const
Definition: G4HadronicParameters.hh:197
G4KaonMinus::KaonMinus
static G4KaonMinus * KaonMinus()
Definition: G4KaonMinus.cc:112
G4KaonPlus::KaonPlus
static G4KaonPlus * KaonPlus()
Definition: G4KaonPlus.cc:112
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:97
G4PionPlus::PionPlus
static G4PionPlus * PionPlus()
Definition: G4PionPlus.cc:97
G4Proton::Proton
static G4Proton * Proton()
Definition: G4Proton.cc:92
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();
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:147
G4EmBuilder::ConstructLightHadronsSS
static void ConstructLightHadronsSS(G4ParticleDefinition *part1, G4ParticleDefinition *part2, G4bool isHEP)
Definition: G4EmBuilder.cc:207

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:1005
G4ParticleDefinition::GetProcessManager
G4ProcessManager * GetProcessManager() const
Definition: G4ParticleDefinition.cc:238
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:95

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

◆ ConstructIonEmPhysics()

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

Definition at line 119 of file G4EmBuilder.cc.

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

Referenced by ConstructCharged().

◆ ConstructIonEmPhysicsSS()

void G4EmBuilder::ConstructIonEmPhysicsSS ( )
static

Definition at line 147 of file G4EmBuilder.cc.

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

Referenced by ConstructChargedSS().

◆ ConstructLightHadrons()

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

Definition at line 168 of file G4EmBuilder.cc.

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

Referenced by ConstructCharged().

◆ ConstructLightHadronsSS()

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

Definition at line 207 of file G4EmBuilder.cc.

210{
211 G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
212
213 ph->RegisterProcess(new G4hIonisation(), part1);
214
215 G4hBremsstrahlung* brem = ( isHEP ) ? new G4hBremsstrahlung() : nullptr;
216 G4hPairProduction* pair = ( isHEP ) ? new G4hPairProduction() : nullptr;
217
218 if( isHEP ) {
219 ph->RegisterProcess(brem, part1);
220 ph->RegisterProcess(pair, part1);
221 }
222 ph->RegisterProcess(new G4CoulombScattering(), 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(), 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:107
G4AntiNeutrinoE::AntiNeutrinoE
static G4AntiNeutrinoE * AntiNeutrinoE()
Definition: G4AntiNeutrinoE.cc:84
G4AntiNeutrinoMu::AntiNeutrinoMu
static G4AntiNeutrinoMu * AntiNeutrinoMu()
Definition: G4AntiNeutrinoMu.cc:84
G4AntiNeutron::AntiNeutron
static G4AntiNeutron * AntiNeutron()
Definition: G4AntiNeutron.cc:101
G4ChargedGeantino::ChargedGeantinoDefinition
static G4ChargedGeantino * ChargedGeantinoDefinition()
Definition: G4ChargedGeantino.cc:81
G4Electron::Electron
static G4Electron * Electron()
Definition: G4Electron.cc:93
G4Gamma::Gamma
static G4Gamma * Gamma()
Definition: G4Gamma.cc:85
G4Geantino::GeantinoDefinition
static G4Geantino * GeantinoDefinition()
Definition: G4Geantino.cc:81
G4GenericIon::GenericIon
static G4GenericIon * GenericIon()
Definition: G4GenericIon.cc:92
G4Lambda::Lambda
static G4Lambda * Lambda()
Definition: G4Lambda.cc:107
G4NeutrinoE::NeutrinoE
static G4NeutrinoE * NeutrinoE()
Definition: G4NeutrinoE.cc:84
G4NeutrinoMu::NeutrinoMu
static G4NeutrinoMu * NeutrinoMu()
Definition: G4NeutrinoMu.cc:84
G4Neutron::Neutron
static G4Neutron * Neutron()
Definition: G4Neutron.cc:103
G4PhysListUtil::InitialiseParameters
static void InitialiseParameters()
Definition: G4PhysListUtil.cc:51
G4PionZero::PionZero
static G4PionZero * PionZero()
Definition: G4PionZero.cc:107
G4Positron::Positron
static G4Positron * Positron()
Definition: G4Positron.cc:93

Referenced by G4EmDNABuilder::ConstructDNAParticles(), G4SpinDecayPhysics::ConstructParticle(), G4EmLivermorePhysics::ConstructParticle(), G4EmLowEPPhysics::ConstructParticle(), G4EmPenelopePhysics::ConstructParticle(), G4EmStandardPhysics::ConstructParticle(), G4EmStandardPhysics_option1::ConstructParticle(), G4EmStandardPhysics_option2::ConstructParticle(), G4EmStandardPhysics_option3::ConstructParticle(), G4EmStandardPhysics_option4::ConstructParticle(), G4EmStandardPhysicsGS::ConstructParticle(), G4EmStandardPhysicsSS::ConstructParticle(), and G4EmStandardPhysicsWVI::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:1034
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: