20#include "BDSException.hh"
21#include "BDSGlobalConstants.hh"
22#include "BDSIonDefinition.hh"
23#include "BDSModularPhysicsList.hh"
24#include "BDSParticleDefinition.hh"
25#include "BDSPhysicalConstants.hh"
26#include "BDSPhysicsAnnihiToMuMu.hh"
27#include "BDSPhysicsCherenkov.hh"
28#include "BDSPhysicsCutsAndLimits.hh"
29#include "BDSPhysicsEMDissociation.hh"
30#include "BDSPhysicsGammaToMuMu.hh"
31#include "BDSPhysicsLaserWire.hh"
32#include "BDSPhysicsMuon.hh"
33#include "BDSPhysicsSynchRad.hh"
34#include "BDSPhysicsUtilities.hh"
35#include "BDSUtilities.hh"
37#include "parser/fastlist.h"
38#include "parser/physicsbiasing.h"
42#include "G4GenericBiasingPhysics.hh"
43#include "G4ParticleTable.hh"
44#include "G4ProcessManager.hh"
45#include "G4ProcessVector.hh"
47#include "G4Version.hh"
50#include "G4ChargeExchangePhysics.hh"
51#include "G4DecayPhysics.hh"
52#include "G4EmExtraPhysics.hh"
53#include "G4EmLivermorePhysics.hh"
54#include "G4EmLivermorePolarizedPhysics.hh"
55#include "G4EmLowEPPhysics.hh"
56#include "G4EmPenelopePhysics.hh"
57#include "G4EmStandardPhysics.hh"
58#include "G4EmStandardPhysicsSS.hh"
59#include "G4EmStandardPhysicsWVI.hh"
60#include "G4EmStandardPhysics_option1.hh"
61#include "G4EmStandardPhysics_option2.hh"
62#include "G4EmStandardPhysics_option3.hh"
63#include "G4EmStandardPhysics_option4.hh"
64#include "G4HadronDElasticPhysics.hh"
65#include "G4HadronElasticPhysics.hh"
66#include "G4HadronElasticPhysicsHP.hh"
67#include "G4HadronElasticPhysicsLEND.hh"
68#include "G4HadronElasticPhysicsXS.hh"
69#include "G4HadronHElasticPhysics.hh"
70#include "G4HadronPhysicsFTFP_BERT.hh"
71#include "G4HadronPhysicsFTFP_BERT_HP.hh"
72#include "G4HadronPhysicsQGSP_BERT.hh"
73#include "G4HadronPhysicsQGSP_BERT_HP.hh"
74#include "G4HadronPhysicsQGSP_BIC.hh"
75#include "G4HadronPhysicsQGSP_BIC_HP.hh"
76#include "G4HadronPhysicsShielding.hh"
77#include "G4IonBinaryCascadePhysics.hh"
78#include "G4IonElasticPhysics.hh"
79#include "G4IonINCLXXPhysics.hh"
80#include "G4IonPhysics.hh"
81#include "G4IonQMDPhysics.hh"
82#include "G4NeutronTrackingCut.hh"
83#include "G4OpticalPhysics.hh"
84#include "G4RadioactiveDecayPhysics.hh"
85#include "G4StoppingPhysics.hh"
86#include "G4SynchrotronRadiation.hh"
89#if G4VERSION_NUMBER > 1009
90#include "G4HadronElasticPhysicsPHP.hh"
93#if G4VERSION_NUMBER > 1019
94#include "G4EmStandardPhysicsGS.hh"
97#if G4VERSION_NUMBER > 1020
98#include "G4SpinDecayPhysics.hh"
101#if G4VERSION_NUMBER > 1022
102#include "G4IonPhysicsPHP.hh"
105#if G4VERSION_NUMBER > 1029
106#include "G4MuonicAtomDecayPhysics.hh"
109#if G4VERSION_NUMBER > 1039
110#include "BDSPhysicsChannelling.hh"
111#include "BDSPhysicsRadioactivation.hh"
112#include "G4EmDNAPhysics.hh"
113#include "G4EmDNAPhysics_option1.hh"
114#include "G4EmDNAPhysics_option2.hh"
115#include "G4EmDNAPhysics_option3.hh"
116#include "G4EmDNAPhysics_option4.hh"
117#include "G4EmDNAPhysics_option5.hh"
118#include "G4EmDNAPhysics_option6.hh"
119#include "G4EmDNAPhysics_option7.hh"
120#include "G4HadronPhysicsShieldingLEND.hh"
123#if G4VERSION_NUMBER < 1070
124#include "G4OpticalProcessIndex.hh"
126#include "G4OpticalParameters.hh"
130#include "G4AntiNeutrinoE.hh"
131#include "G4AntiNeutron.hh"
132#include "G4AntiProton.hh"
133#include "G4BaryonConstructor.hh"
134#include "G4Electron.hh"
136#include "G4IonConstructor.hh"
137#include "G4LeptonConstructor.hh"
138#include "G4MesonConstructor.hh"
139#include "G4NeutrinoE.hh"
140#include "G4Neutron.hh"
141#include "G4Positron.hh"
142#include "G4Proton.hh"
143#include "G4ShortLivedConstructor.hh"
155BDSModularPhysicsList::BDSModularPhysicsList(
const G4String& physicsList):
157 opticalPhysics(nullptr),
210#if G4VERSION_NUMBER > 1019
213#if G4VERSION_NUMBER > 1020
216#if G4VERSION_NUMBER > 1022
219#if G4VERSION_NUMBER > 1029
222#if G4VERSION_NUMBER > 1039
237 aliasToOriginal[
"cerenkov"] =
"cherenkov";
238 aliasToOriginal[
"cutsandlimits"] =
"cuts_and_limits";
239 aliasToOriginal[
"em_low"] =
"em_penelope";
240 aliasToOriginal[
"hadronic"] =
"ftfp_bert";
241 aliasToOriginal[
"hadronic_hp"] =
"ftfp_bert_hp";
242 aliasToOriginal[
"ionbinary"] =
"ion_binary";
243 aliasToOriginal[
"ioninclxx"] =
"ion_inclxx";
244 aliasToOriginal[
"ionphp"] =
"ion_php";
245 aliasToOriginal[
"spindecay"] =
"decay_spin";
246 aliasToOriginal[
"synchrad"] =
"synch_rad";
247#if G4VERSION_NUMBER > 1039
248 aliasToOriginal[
"channeling"] =
"channelling";
252 for (
const auto& constructor : physicsConstructors)
254 physicsLists.emplace_back(constructor.first);
255 physicsActivated[constructor.first] =
false;
260 for (
const auto& kv : physicsConstructors)
261 {incompatible.insert(std::make_pair(kv.first, std::vector<G4String>()));}
262 incompatible[
"annihi_to_mumu"] = {
"em_extra"};
263 incompatible[
"em"] = {
"em_ss",
"em_wvi",
"em_1",
"em_2",
"em_3",
"em_4"};
264 incompatible[
"em_ss"] = {
"em",
"em_wvi",
"em_1",
"em_2",
"em_3",
"em_4"};
265 incompatible[
"em_wvi"] = {
"em",
"em_ss",
"em_1",
"em_2",
"em_3",
"em_4"};
266 incompatible[
"em_1"] = {
"em",
"em_ss",
"em_wvi",
"em_2",
"em_3",
"em_4"};
267 incompatible[
"em_2"] = {
"em",
"em_ss",
"em_wvi",
"em_1",
"em_3",
"em_4"};
268 incompatible[
"em_3"] = {
"em",
"em_ss",
"em_wvi",
"em_1",
"em_2",
"em_4"};
269 incompatible[
"em_4"] = {
"em",
"em_ss",
"em_wvi",
"em_1",
"em_2",
"em_3"};
270 incompatible[
"em_livermore"] = {
"em_livermore_polarised"};
271 incompatible[
"ftfp_bert"] = {
"ftfp_bert_hp",
"qgsp_bert",
"qgsp_bert_hp",
"qgsp_bic",
"qgsp_bic_hp"};
272 incompatible[
"ftfp_bert_hp"] = {
"ftfp_bert",
"qgsp_bert",
"qgsp_bert_hp",
"qgsp_bic",
"qgsp_bic_hp"};
273 incompatible[
"gamma_to_mumu"] = {
"em_extra"};
274 incompatible[
"hadronic_elastic"] = {
"hadronic_elastic_d",
"hadronic_elastic_h",
"hadronic_elastic_hp",
"hadronic_elastic_lend",
"hadronic_elastic_xs"};
275 incompatible[
"hadronic_elastic_d"] = {
"hadronic_elastic",
"hadronic_elastic_h",
"hadronic_elastic_hp",
"hadronic_elastic_lend",
"hadronic_elastic_xs"};
276 incompatible[
"hadronic_elastic_h"] = {
"hadronic_elastic",
"hadronic_elastic_d",
"hadronic_elastic_hp",
"hadronic_elastic_lend",
"hadronic_elastic_xs"};
277 incompatible[
"hadronic_elastic_hp"] = {
"hadronic_elastic",
"hadronic_elastic_d",
"hadronic_elastic_h",
"hadronic_elastic_lend",
"hadronic_elastic_xs"};
278 incompatible[
"hadronic_elastic_lend"] = {
"hadronic_elastic",
"hadronic_elastic_d",
"hadronic_elastic_h",
"hadronic_elastic_hp",
"hadronic_elastic_xs"};
279 incompatible[
"hadronic_elastic_xs"] = {
"hadronic_elastic",
"hadronic_elastic_d",
"hadronic_elastic_h",
"hadronic_elastic_hp",
"hadronic_elastic_lend"};
280 incompatible[
"ion_elastic"] = {
"ion_elastic_qmd"};
281 incompatible[
"qgsp_bert"] = {
"ftfp_bert",
"ftfp_bert_hp",
"qgsp_bert_hp",
"qgsp_bic",
"qgsp_bic_hp"};
282 incompatible[
"qgsp_bert_hp"] = {
"ftfp_bert",
"ftfp_bert_hp",
"qgsp_bert",
"qgsp_bic",
"qgsp_bic_hp"};
283 incompatible[
"qgsp_bic"] = {
"ftfp_bert",
"ftfp_bert_hp",
"qgsp_bert",
"qgsp_bert_hp",
"qgsp_bic_hp"};
284 incompatible[
"qgsp_bic_hp"] = {
"ftfp_bert",
"ftfp_bert_hp",
"qgsp_bert",
"qgsp_bert_hp",
"qgsp_bic"};
286#if G4VERSION_NUMBER > 1019
287 for (
const auto& name : {
"em",
"em_ss",
"em_wvi",
"em_1",
"em_2",
"em_3",
"em_4"})
288 {incompatible[name].push_back(
"em_gs");}
289 incompatible[
"em_gs"] = {
"em",
"em_ss",
"em_wvi",
"em_1",
"em_2",
"em_3",
"em_4"};
291#if G4VERSION_NUMBER > 1020
292 incompatible[
"decay"].push_back(
"decay_spin");
293 incompatible[
"decay_spin"] = {
"decay"};
295#if G4VERSION_NUMBER > 1039
296 incompatible[
"shielding"].push_back(
"shielding_lend");
297 incompatible[
"shielding_lend"] = {
"shielding"};
300 ParsePhysicsList(physicsList);
304 for (
auto physics : constructors)
305 {RegisterPhysics(physics);}
310 if (globals->Verbose())
315BDSModularPhysicsList::~BDSModularPhysicsList()
321 G4VModularPhysicsList::ConstructParticle();
326 G4VModularPhysicsList::ConstructProcess();
327 DumpCutValuesTable(100);
334 G4String result = (physics.second ?
"active" :
"inactive");
335 G4cout << std::setw(27) << (
"\"" + physics.first +
"\": ") << result << G4endl;
342 G4cout << __METHOD_NAME__ <<
"Physics list string: \"" << physListName <<
"\"" << G4endl;
346 std::stringstream ss(physListName);
347 std::istream_iterator<std::string> begin(ss);
348 std::istream_iterator<std::string> end;
349 std::vector<std::string> physicsListNamesS(begin, end);
352 std::vector<G4String> physicsListNames;
353 for (
const auto& physicsListName : physicsListNamesS)
355 G4String name = G4String(physicsListName);
363 G4cout << __METHOD_NAME__ <<
"alias \"" << name <<
"\" forwarding to \""
364 << result->second <<
"\"" << G4endl;
365 name = result->second;
367 physicsListNames.push_back(name);
371 if (std::find(physicsListNames.begin(), physicsListNames.end(),
"em") != physicsListNames.end())
374 for (
const auto& name : physicsListNames)
379 G4cout << __METHOD_NAME__ <<
"Constructing \"" << result->first <<
"\" physics list" << G4endl;
381 auto mem = result->second;
386 G4cout <<
"\"" << name <<
"\" is not a valid physics list. Available ones are: " << G4endl;
388 {G4cout <<
"\"" << listName <<
"\"" << G4endl;}
389 throw BDSException(__METHOD_NAME__,
"Invalid physics list.");
399 G4LeptonConstructor::ConstructParticle();
404 G4ShortLivedConstructor::ConstructParticle();
409 G4MesonConstructor::ConstructParticle();
414 G4BaryonConstructor::ConstructParticle();
420 G4GenericIon::GenericIonDefinition();
421 G4IonConstructor::ConstructParticle();
432 G4long maxPhotonsPerStep =
globals->MaximumPhotonsPerStep();
433#if G4VERSION_NUMBER < 1079
435 opticalPhysics->Configure(G4OpticalProcessIndex::kCerenkov,
true);
436 opticalPhysics->Configure(G4OpticalProcessIndex::kScintillation,
true);
437 opticalPhysics->Configure(G4OpticalProcessIndex::kAbsorption,
globals->TurnOnOpticalAbsorption());
438 opticalPhysics->Configure(G4OpticalProcessIndex::kRayleigh,
globals->TurnOnRayleighScattering());
439 opticalPhysics->Configure(G4OpticalProcessIndex::kMieHG,
globals->TurnOnMieScattering());
440 opticalPhysics->Configure(G4OpticalProcessIndex::kBoundary,
globals->TurnOnOpticalSurface());
441 opticalPhysics->Configure(G4OpticalProcessIndex::kWLS,
true);
442 opticalPhysics->SetScintillationYieldFactor(
globals->ScintYieldFactor());
443 if (maxPhotonsPerStep >= 0)
444 {opticalPhysics->SetMaxNumPhotonsPerStep(maxPhotonsPerStep);}
446 G4OpticalParameters* opticalParameters = G4OpticalParameters::Instance();
447 opticalParameters->SetProcessActivation(G4OpticalProcessName(G4OpticalProcessIndex::kCerenkov),
true);
448 opticalParameters->SetProcessActivation(G4OpticalProcessName(G4OpticalProcessIndex::kScintillation),
true);
449 opticalParameters->SetProcessActivation(G4OpticalProcessName(G4OpticalProcessIndex::kAbsorption),
globals->TurnOnOpticalAbsorption());
450 opticalParameters->SetProcessActivation(G4OpticalProcessName(G4OpticalProcessIndex::kRayleigh),
globals->TurnOnRayleighScattering());
451 opticalParameters->SetProcessActivation(G4OpticalProcessName(G4OpticalProcessIndex::kMieHG),
globals->TurnOnMieScattering());
452 opticalParameters->SetProcessActivation(G4OpticalProcessName(G4OpticalProcessIndex::kBoundary),
globals->TurnOnOpticalSurface());
453 opticalParameters->SetProcessActivation(G4OpticalProcessName(G4OpticalProcessIndex::kWLS),
true);
454 if (maxPhotonsPerStep >= 0)
455 {opticalParameters->SetCerenkovMaxPhotonsPerStep((G4int)maxPhotonsPerStep);}
462 const std::vector<G4String>& forbidden =
incompatible.at(singlePhysicsIn);
464 for (
const auto& key : forbidden)
468 G4cerr << __METHOD_NAME__ <<
"Incompatible physics list \"" << singlePhysicsIn
469 <<
"\" being used with already used \"" << key <<
"\"" << G4endl;
470 G4cout <<
"\"" << singlePhysicsIn <<
"\" cannot be used with the following:" << G4endl;
471 for (
const auto& v : forbidden)
472 {G4cout <<
"\"" << v <<
"\"" << G4endl;}
473 throw BDSException(__METHOD_NAME__,
"Incompatible physics list.");
501 constructors.push_back(
new G4ChargeExchangePhysics());
531 constructors.push_back(
new G4DecayPhysics());
540 constructors.push_back(
new G4RadioactiveDecayPhysics());
550 constructors.push_back(
new G4EmStandardPhysics());
568 auto constructor =
new G4EmExtraPhysics();
569#if G4VERSION_NUMBER > 1019
571 constructor->MuonNuclear(useMuonNuclear);
572 G4cout << __METHOD_NAME__ <<
"G4EmExtraPhysics> muon nuclear processes : " << BDS::BoolToString(useMuonNuclear) << G4endl;
574#if G4VERSION_NUMBER > 1029
576 constructor->GammaToMuMu(useGammaToMuMu);
577 G4cout << __METHOD_NAME__ <<
"G4EmExtraPhysics> gamma to mu mu : " << BDS::BoolToString(useGammaToMuMu) << G4endl;
579 constructor->PositronToMuMu(usePositronToMuMu);
580 G4cout << __METHOD_NAME__ <<
"G4EmExtraPhysics> e+ to mu mu : " << BDS::BoolToString(usePositronToMuMu) << G4endl;
582 constructor->PositronToHadrons(usePositronToHadrons);
583 G4cout << __METHOD_NAME__ <<
"G4EmExtraPhysics> e+ to hadrons : " << BDS::BoolToString(usePositronToHadrons) << G4endl;
585#if G4VERSION_NUMBER > 1039
587 if (useLENDGammaNuclear)
590 constructor->LENDGammaNuclear(
true);
591 G4cout << __METHOD_NAME__ <<
"G4EmExtraPhysics> LEND gamma nuclear : " << BDS::BoolToString(useMuonNuclear) << G4endl;
594 constructor->ElectroNuclear(useElectroNuclear);
596 constructors.push_back(constructor);
606 constructors.push_back(
new G4EmLivermorePhysics());
616 constructors.push_back(
new G4EmLivermorePolarizedPhysics());
626 constructors.push_back(
new G4EmLowEPPhysics());
636 constructors.push_back(
new G4EmPenelopePhysics());
646 constructors.push_back(
new G4EmStandardPhysicsSS());
656 constructors.push_back(
new G4EmStandardPhysicsWVI());
666 constructors.push_back(
new G4EmStandardPhysics_option1());
676 constructors.push_back(
new G4EmStandardPhysics_option2());
686 constructors.push_back(
new G4EmStandardPhysics_option3());
696 constructors.push_back(
new G4EmStandardPhysics_option4());
707 constructors.push_back(
new G4HadronPhysicsFTFP_BERT());
718 constructors.push_back(
new G4HadronPhysicsFTFP_BERT_HP());
737 constructors.push_back(
new G4HadronElasticPhysics());
747 constructors.push_back(
new G4HadronDElasticPhysics());
757 constructors.push_back(
new G4HadronHElasticPhysics());
767 constructors.push_back(
new G4HadronElasticPhysicsHP());
778 constructors.push_back(
new G4HadronElasticPhysicsLEND());
788 constructors.push_back(
new G4HadronElasticPhysicsXS());
803 constructors.push_back(
new G4IonPhysics());
819 constructors.push_back(
new G4IonBinaryCascadePhysics());
835 constructors.push_back(
new G4IonElasticPhysics());
851 constructors.push_back(
new G4IonQMDPhysics());
881 constructors.push_back(
new G4IonINCLXXPhysics());
908 auto ntc =
new G4NeutronTrackingCut();
911 G4cout << __METHOD_NAME__ <<
"Neutron time limit: " << timeLimit / CLHEP::s <<
" s" << G4endl;
912 G4cout << __METHOD_NAME__ <<
"Neutron kinetic energy limit: " << eKinLimit / CLHEP::MeV << G4endl;
913 ntc->SetTimeLimit(timeLimit);
914 ntc->SetKineticEnergyLimit(eKinLimit);
915 constructors.push_back(ntc);
924 opticalPhysics =
new G4OpticalPhysics();
925 constructors.push_back(opticalPhysics);
935 constructors.push_back(
new G4HadronPhysicsQGSP_BERT());
945 constructors.push_back(
new G4HadronPhysicsQGSP_BERT_HP());
955 constructors.push_back(
new G4HadronPhysicsQGSP_BIC());
965 constructors.push_back(
new G4HadronPhysicsQGSP_BIC_HP());
972#if G4VERSION_NUMBER > 1059
977 constructors.push_back(
new G4HadronPhysicsShielding());
988 constructors.push_back(
new G4StoppingPhysics());
1003#if G4VERSION_NUMBER > 1019
1009 constructors.push_back(
new G4EmStandardPhysicsGS());
1015#if G4VERSION_NUMBER > 1020
1020 constructors.push_back(
new G4SpinDecayPhysics());
1026#if G4VERSION_NUMBER > 1022
1038 constructors.push_back(
new G4IonPhysicsPHP());
1044#if G4VERSION_NUMBER > 1029
1048#if G4VERSION_NUMBER > 1059
1053 constructors.push_back(
new G4MuonicAtomDecayPhysics());
1059#if G4VERSION_NUMBER > 1039
1068 {constructors.push_back(
new G4EmDNAPhysics_option1());}
1070 {constructors.push_back(
new G4EmDNAPhysics_option2());}
1072 {constructors.push_back(
new G4EmDNAPhysics_option3());}
1074 {constructors.push_back(
new G4EmDNAPhysics_option4());}
1076 {constructors.push_back(
new G4EmDNAPhysics_option5());}
1078 {constructors.push_back(
new G4EmDNAPhysics_option6());}
1080 {constructors.push_back(
new G4EmDNAPhysics_option7());}
1083 {constructors.push_back(
new G4EmDNAPhysics());}
1093 G4GenericBiasingPhysics* biasingPhysics =
new G4GenericBiasingPhysics();
1094 biasingPhysics->PhysicsBiasAllCharged();
1095 RegisterPhysics(biasingPhysics);
1115 constructors.push_back(
new G4HadronPhysicsShieldingLEND());
General exception with possible name of object and message.
static BDSGlobalConstants * Instance()
Access method.
void ConstructAllShortLived()
Construct resonances and quarks - sometimes required explicitly.
void ShieldingLEND()
Physics constructor loader.
void Em1()
Physics constructor loader.
void EmLivermorePolarised()
Physics constructor loader.
void Optical()
Physics constructor loader.
void HadronicElasticHP()
Physics constructor loader.
void Em2()
Physics constructor loader.
void IonBinary()
Physics constructor loader.
void ConstructAllIons()
Construct ions.
void HadronicElasticXS()
Physics constructor loader.
void IonINCLXX()
Physics constructor loader.
void ParsePhysicsList(const G4String &physListName)
Interpret the string of physics lists given from the user through the parser.
void Em3()
Physics constructor loader.
void Stopping()
Physics constructor loader.
virtual void ConstructParticle()
void LaserWire()
Physics constructor loader.
void EmLowEP()
Physics constructor loader.
void EmWVI()
Physics constructor loader.
BDSGlobalConstants * globals
Keep a local reference to global constants to avoid getting it all the time.
G4bool usingIons
Flag telling whether ions are being used either in physics list or in beam particle.
void CheckIncompatiblePhysics(const G4String &singlePhysicsIn) const
void Ion()
Physics constructor loader.
void Cherenkov()
Physics constructor loader.
void ChargeExchange()
Physics constructor loader.
std::map< G4String, std::vector< G4String > > incompatible
Map of incompatible physics lists by our name for each individual list.
void DecayMuonicAtom()
Physics constructor loader.
void DecayRadioactive()
Physics constructor loader.
void DNA()
Physics constructor loader.
void HadronicElasticH()
Physics constructor loader.
G4String temporaryName
Temporary string used to pass name to constructor functions.
void IonEMDissociation()
Physics constructor loader.
std::map< G4String, G4bool > physicsActivated
void Em4()
Physics constructor loader.
void EmExtra()
Physics constructor loader.
void HadronicElasticLEND()
Physics constructor loader.
void Radioactivation()
Physics constructor loader.
void QGSPBICHP()
Physics constructor loader.
void IonElastic()
Physics constructor loader.
void Muon()
Physics constructor loader.
void NeutronTrackingCut()
Physics constructor loader.
void ConstructAllBaryons()
Construct baryons.
void QGSPBERTHP()
Physics constructor loader.
void IonPHP()
Physics constructor loader.
void Decay()
Physics constructor loader.
void EmSS()
Physics constructor loader.
void FTFPBERT()
Physics constructor loader.
void AnnihiToMuMu()
Physics constructor loader.
void QGSPBIC()
Physics constructor loader.
void GammaToMuMu()
Physics constructor loader.
void CutsAndLimits()
Physics constructor loader.
void Em()
Physics constructor loader.
void EmPenelope()
Physics constructor loader.
void HadronicElastic()
Physics constructor loader.
G4bool emWillBeUsed
Flag as to whether em will be used - avoids duplicate processes being registered.
void HadronicElasticD()
Physics constructor loader.
void DecaySpin()
Physics constructor loader.
void FTFPBERTHP()
Physics constructor loader.
void EmLivermore()
Physics constructor loader.
void ConstructAllLeptons()
void IonElasticQMD()
Physics constructor loader.
virtual void ConstructProcess()
std::map< std::string, Constructor > physicsConstructors
A map of physics list names to their constructors.
std::vector< G4String > physicsLists
void Channelling()
Physics constructor loader.
void QGSPBERT()
Physics constructor loader.
void Shielding()
Physics constructor loader.
void EmGS()
Physics constructor loader.
void ConstructAllMesons()
Construct mesons.
void Print()
Print out which physics lists are activated.
std::map< G4String, G4String > aliasToOriginal
Map of possible aliases for a given physics list.
void SynchRad()
Physics constructor loader.
High energy muon processes.
Channelling physics process.
Cherenkov physics process constructor.
Physics processes required for user tracking limits.
Electromagnetic dissociation for high energy ions.
High energy muon processes.
Constructor for BDSLaserCompton process.
High energy muon processes.
Radioactivation processes.
A physics constructor that only constructs Synchrotron Radiation.
G4bool StrContains(const G4String &str, const G4String &test)
Utility function to simplify lots of syntax changes for pedantic g4 changes.
G4String LowerCase(const G4String &str)
Utility function to simplify lots of syntax changes for pedantic g4 changes.
void CheckHighPrecisionDataExists(const G4String &physicsListName)
void CheckLowEnergyNeutronDataExists(const G4String &phhysicsListName)
void ConstructMinimumParticleSet()