BDSIM
BDSIM is a Geant4 extension toolkit for simulation of particle transport in accelerator beamlines.
Loading...
Searching...
No Matches
BDSIMClass.cc
1/*
2Beam Delivery Simulation (BDSIM) Copyright (C) Royal Holloway,
3University of London 2001 - 2023.
4
5This file is part of BDSIM.
6
7BDSIM is free software: you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published
9by the Free Software Foundation version 3 of the License.
10
11BDSIM is distributed in the hope that it will be useful, but
12WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14GNU General Public License for more details.
15
16You should have received a copy of the GNU General Public License
17along with BDSIM. If not, see <http://www.gnu.org/licenses/>.
18*/
19#include "BDSIMClass.hh"
20
21#include "BDSExecOptions.hh" // executable command line options
22#include "BDSGlobalConstants.hh" // global parameters
23
24#include <algorithm>
25#include <csignal>
26#include <cstdlib>
27#include <cstdio>
28
29#include "G4EventManager.hh" // Geant4 includes
30#include "G4GenericBiasingPhysics.hh"
31#include "G4GeometryManager.hh"
32#include "G4GeometryTolerance.hh"
33#include "G4PhysicsListHelper.hh"
34#include "G4ParallelWorldPhysics.hh"
35#include "G4ParticleDefinition.hh"
36#include "G4SteppingManager.hh"
37#include "G4TrackingManager.hh"
38#include "G4Version.hh"
39#include "G4VModularPhysicsList.hh"
40
41#include "CLHEP/Units/SystemOfUnits.h"
42
43#include "BDSAcceleratorModel.hh"
44#include "BDSAperturePointsLoader.hh"
45#include "BDSBeamPipeFactory.hh"
46#include "BDSBunch.hh"
47#include "BDSBunchFactory.hh"
48#include "BDSCavityFactory.hh"
49#include "BDSColours.hh"
50#include "BDSComponentFactoryUser.hh"
51#include "BDSDebug.hh"
52#include "BDSDetectorConstruction.hh"
53#include "BDSEventAction.hh"
54#include "BDSException.hh"
55#include "BDSFieldFactory.hh"
56#include "BDSFieldLoader.hh"
57#include "BDSGeometryFactory.hh"
58#include "BDSGeometryFactorySQL.hh"
59#include "BDSGeometryWriter.hh"
60#include "BDSIonDefinition.hh"
61#include "BDSMaterials.hh"
62#include "BDSOutput.hh"
63#include "BDSOutputFactory.hh"
64#include "BDSParallelWorldUtilities.hh"
65#include "BDSParser.hh" // Parser
66#include "BDSParticleDefinition.hh"
67#include "BDSPhysicsUtilities.hh"
68#include "BDSPrimaryGeneratorAction.hh"
69#include "BDSRandom.hh" // for random number generator from CLHEP
70#include "BDSRunAction.hh"
71#include "BDSRunManager.hh"
72#include "BDSSamplerRegistry.hh"
73#include "BDSSDManager.hh"
74#include "BDSSteppingAction.hh"
75#include "BDSStackingAction.hh"
76#include "BDSTemporaryFiles.hh"
77#include "BDSTrackingAction.hh"
78#include "BDSUtilities.hh"
79#include "BDSVisManager.hh"
80#include "BDSWarning.hh"
81
83 ignoreSIGINT(false),
84 usualPrintOut(true),
85 initialised(false),
86 initialisationResult(1),
87 argcCache(0),
88 argvCache(nullptr),
89 parser(nullptr),
90 bdsOutput(nullptr),
91 bdsBunch(nullptr),
92 runManager(nullptr),
93 userComponentFactory(nullptr),
94 userPhysicsList(nullptr),
95 realWorld(nullptr)
96{;}
97
98BDSIM::BDSIM(int argc, char** argv, bool usualPrintOutIn):
99 ignoreSIGINT(false),
100 usualPrintOut(usualPrintOutIn),
101 initialised(false),
102 initialisationResult(1),
103 argcCache(argc),
104 argvCache(argv),
105 parser(nullptr),
106 bdsOutput(nullptr),
107 bdsBunch(nullptr),
108 runManager(nullptr),
109 userComponentFactory(nullptr),
110 userPhysicsList(nullptr),
111 realWorld(nullptr)
112{
114}
115
116int BDSIM::Initialise(int argc, char** argv, bool usualPrintOutIn)
117{
118 argcCache = argc;
119 argvCache = argv;
120 usualPrintOut = usualPrintOutIn;
123}
124
126{
128 const BDSExecOptions* execOptions = new BDSExecOptions(argcCache,argvCache);
129 if (usualPrintOut)
130 {execOptions->Print();}
131 ignoreSIGINT = execOptions->IgnoreSIGINT(); // different sig catching for cmake
132
133 execOptions->PrintCopyright();
134#ifdef BDSDEBUG
135 G4cout << __METHOD_NAME__ << "DEBUG mode is on." << G4endl;
136#endif
137
139 parser = BDSParser::Instance(execOptions->InputFileName());
141 parser->AmalgamateOptions(execOptions->Options());
142 parser->AmalgamateBeam(execOptions->Beam(), execOptions->Options().recreate);
145
148
150 delete execOptions;
151
156
158 BDSRandom::CreateRandomNumberGenerator(globals->RandomEngine());
159 BDSRandom::SetSeed(); // set the seed from options
160
162 bdsOutput = BDSOutputFactory::CreateOutput(globals->OutputFormat(),
163 globals->OutputFileName());
164
167 {
168 G4cerr << "No Geant4 environmental variables found - please source geant4.sh environment" << G4endl;
169 G4cout << "A common fault is the wrong Geant4 environment as compared to the one BDSIM was compiled with." << G4endl;
170 return 1;
171 }
172
176
179
181 auto parallelWorldsRequiringPhysics = BDS::ConstructAndRegisterParallelWorlds(realWorld,
183 realWorld->BuildPlacementFieldsWorld());
184 runManager->SetUserInitialization(realWorld);
185
188#ifdef BDSDEBUG
189 G4cout << __METHOD_NAME__ << "> Constructing physics processes" << G4endl;
190#endif
191 G4String physicsListName = parser->GetOptions().physicsList;
192
193#if G4VERSION_NUMBER > 1049
194 // from 10.5 onwards they have a looping particle killer that warnings and kills particles
195 // deemed to be looping that are <100 MeV. This is unrelated to the primary energy so troublesome.
196 // set to the 'low' limits here ~10keV. This must be done before any physics is created as the
197 // parameters are copied into the transportation physics process for each particle and it's very
198 // hard to sift through and fix afterwards
199 G4PhysicsListHelper::GetPhysicsListHelper()->UseLowLooperThresholds();
200#endif
201 // sampler physics process for parallel world tracking must be instantiated BEFORE
202 // regular physics.
203 // Note, we purposively don't create a parallel world process for the curvilinear
204 // world as we don't need the track information from it - unreliable that way. We
205 // query the geometry directly using our BDSAuxiliaryNavigator class.
206 auto parallelWorldPhysics = BDS::ConstructParallelWorldPhysics(parallelWorldsRequiringPhysics);
207 G4int physicsVerbosity = globals->PhysicsVerbosity();
208 G4VModularPhysicsList* physList;
209 if (userPhysicsList)
210 {
211 G4cout << "Using externally registered user defined physics list" << G4endl;
212 physList = userPhysicsList;
213 }
214 else
215 {physList = BDS::BuildPhysics(physicsListName, physicsVerbosity);}
216
217 // create geometry sampler and register importance sampling biasing. Has to be here
218 // before physicsList is "initialised" in run manager.
219 if (BDSGlobalConstants::Instance()->UseImportanceSampling())
220 {BDS::RegisterImportanceBiasing(parallelWorldsRequiringPhysics,physList);}
221
222 // Construction of the physics lists defines the necessary particles and therefore
223 // we can calculate the beam rigidity for the particle the beam is designed w.r.t. This
224 // must happen before the geometry is constructed (which is called by
225 // runManager->Initialize()).
226 BDSParticleDefinition* designParticle = nullptr;
227 BDSParticleDefinition* beamParticle = nullptr;
228 G4bool beamDifferentFromDesignParticle = false;
230 globals->FFact(),
231 designParticle,
232 beamParticle,
233 beamDifferentFromDesignParticle);
234 G4double minEK = globals->MinimumKineticEnergy();
235 if (beamParticle->KineticEnergy() < minEK && BDS::IsFinite(minEK))
236 {throw BDSException("option, minimumKineticEnergy is higher than kinetic energy of the beam - all primary particles wil be killed!");}
237 if (usualPrintOut)
238 {
239 G4cout << "Design particle properties: " << G4endl << *designParticle;
240 if (beamDifferentFromDesignParticle)
241 {G4cout << "Beam particle properties: " << G4endl << *beamParticle;}
242 }
243 // update rigidity where needed
244 realWorld->SetDesignParticle(designParticle);
246 BDSGeometryFactorySQL::SetDefaultRigidity(designParticle->BRho()); // used for sql field loading
247
248 // Muon splitting - optional - should be done *after* biasing to work with it - TBC it's before...
249 BDS::BuildMuonBiasing(physList);
250
251 BDS::RegisterSamplerPhysics(parallelWorldPhysics, physList);
252 auto biasPhysics = BDS::BuildAndAttachBiasWrapper(parser->GetBiasing());
253 if (biasPhysics)//could be nullptr and can't be passed to geant4 like this
254 {physList->RegisterPhysics(biasPhysics);}
255 runManager->SetUserInitialization(physList);
256
259 parser->GetBeam(),
260 globals->BeamlineTransform(),
261 globals->BeamlineS(),
262 globals->GeneratePrimariesOnly());
263 G4cout << "Bunch distribution: \"" << bdsBunch->Name() << "\"" << G4endl;
266 delete beamParticle;
270
274 if (globals->GeneratePrimariesOnly())
275 {
276 GeneratePrimariesOnly(globals);
277 return 0;
278 }
279
281 G4GeometryTolerance* theGeometryTolerance = G4GeometryTolerance::GetInstance();
282 if (usualPrintOut)
283 {
284 G4cout << __METHOD_NAME__ << "Geometry Tolerances: " << G4endl;
285 G4cout << __METHOD_NAME__ << std::setw(12) << "Surface: " << std::setw(7) << theGeometryTolerance->GetSurfaceTolerance() << " mm" << G4endl;
286 G4cout << __METHOD_NAME__ << std::setw(12) << "Angular: " << std::setw(7) << theGeometryTolerance->GetAngularTolerance() << " rad" << G4endl;
287 G4cout << __METHOD_NAME__ << std::setw(12) << "Radial: " << std::setw(7) << theGeometryTolerance->GetRadialTolerance() << " mm" << G4endl;
288 }
289
291 BDSEventAction* eventAction = new BDSEventAction(bdsOutput);
292 runManager->SetUserAction(eventAction);
293
294 BDSRunAction* runAction = new BDSRunAction(bdsOutput,
295 bdsBunch,
297 eventAction,
298 globals->StoreTrajectorySamplerID());
299 runManager->SetUserAction(runAction);
300
301 // Only add stepping action if it is actually used, so do check here (for performance reasons)
302 G4int verboseSteppingEventStart = globals->VerboseSteppingEventStart();
303 G4int verboseSteppingEventStop = BDS::VerboseEventStop(verboseSteppingEventStart,
304 globals->VerboseSteppingEventContinueFor());
305 if (globals->VerboseSteppingBDSIM())
306 {
307 runManager->SetUserAction(new BDSSteppingAction(true,
308 verboseSteppingEventStart,
309 verboseSteppingEventStop));
310 }
311
312 runManager->SetUserAction(new BDSTrackingAction(globals->Batch(),
313 globals->StoreTrajectory(),
314 globals->StoreTrajectoryOptions(),
315 eventAction,
316 verboseSteppingEventStart,
317 verboseSteppingEventStop,
318 globals->VerboseSteppingPrimaryOnly(),
319 globals->VerboseSteppingLevel()));
320
321 runManager->SetUserAction(new BDSStackingAction(globals));
322
323 auto primaryGeneratorAction = new BDSPrimaryGeneratorAction(bdsBunch, parser->GetBeam(), globals->Batch());
324 runManager->SetUserAction(primaryGeneratorAction);
325 BDSFieldFactory::SetPrimaryGeneratorAction(primaryGeneratorAction);
326
329
331 if (globals->UseImportanceSampling())
332 {BDS::AddIStore(parallelWorldsRequiringPhysics);}
333
336
337 if (usualPrintOut && globals->PhysicsVerbose())
338 {
341 }
342
346 runManager->SetVerboseLevel(std::min(globals->VerboseRunLevel(), globals->PhysicsVerbosity()));
347 G4EventManager::GetEventManager()->SetVerboseLevel(globals->VerboseEventLevel());
348 G4EventManager::GetEventManager()->GetTrackingManager()->SetVerboseLevel(globals->VerboseTrackingLevel());
349
351 G4bool bCloseGeometry = G4GeometryManager::GetInstance()->CloseGeometry();
352 if (!bCloseGeometry)
353 {
354 G4cerr << __METHOD_NAME__ << "error - geometry not closed." << G4endl;
355 return 1;
356 }
357
358 if (globals->ExportGeometry())
359 {
360 BDSGeometryWriter geometrywriter;
361 geometrywriter.ExportGeometry(globals->ExportType(),
362 globals->ExportFileName());
363 }
364
365 initialised = true;
366 return 0;
367}
368
369void BDSIM::BeamOn(int nGenerate)
370{
372 {return;} // a mode where we don't do anything
373
374 G4cout.precision(10);
376 struct sigaction act;
377 act.sa_handler = &BDS::HandleAborts;
378 sigemptyset(&act.sa_mask);
379 act.sa_flags = 0;
380 if (!ignoreSIGINT)
381 {sigaction(SIGINT, &act, nullptr);}
382 sigaction(SIGABRT, &act, nullptr);
383 sigaction(SIGTERM, &act, nullptr);
384 sigaction(SIGSEGV, &act, nullptr);
385
387 try
388 {
389 if (!BDSGlobalConstants::Instance()->Batch()) // Interactive mode
390 {
391 BDSVisManager visManager = BDSVisManager(BDSGlobalConstants::Instance()->VisMacroFileName(),
392 BDSGlobalConstants::Instance()->Geant4MacroFileName(),
393 realWorld);
394 visManager.StartSession(argcCache, argvCache);
395 }
396 else
397 {// batch mode
398 if (nGenerate < 0)
400 else
401 {runManager->BeamOn(nGenerate);}
402 }
403 }
404 catch (const BDSException& exception)
405 {
406 // don't do this for now in case it's dangerous and we try tracking with open geometry
407 //G4GeometryManager::GetInstance()->OpenGeometry();
408 throw exception;
409 }
410}
411
413{
415 G4GeometryManager::GetInstance()->OpenGeometry();
416
417#ifdef BDSDEBUG
418 G4cout << __METHOD_NAME__ << "deleting..." << G4endl;
419#endif
420 delete bdsOutput;
421
422 try
423 {
424 // order important here because of singletons relying on each other
425 delete BDSSDManager::Instance();
429 delete BDSAcceleratorModel::Instance();
431 delete BDSFieldFactory::Instance(); // this uses BDSGlobalConstants which uses BDSMaterials
433 delete BDSMaterials::Instance();
434
435 // instances not used in this file, but no other good location for deletion
436 if (initialisationResult < 2)
437 {
438 delete BDSColours::Instance();
442 }
443 }
444 catch (...)
445 {;} // ignore any exception as this is a destructor
446
447 delete runManager;
448 delete bdsBunch;
449 delete parser;
450
451 if (usualPrintOut)
452 {G4cout << __METHOD_NAME__ << "End of Run. Thank you for using BDSIM!" << G4endl;}
453}
454
455void BDSIM::RegisterUserComponent(const G4String& componentTypeName,
456 BDSComponentConstructor* componentConstructor)
457{
458 if (initialised)
459 {BDS::Warning(__METHOD_NAME__, "BDSIM kernel already initialised - this component will not be available");}
462
463 userComponentFactory->RegisterComponent(componentTypeName,
464 componentConstructor);
465}
466
468{
469 // output creation is duplicated below but with this if loop, we exit so ok.
471 const G4int nToGenerate = globals->NGenerate();
472 const G4int printModulo = globals->PrintModuloEvents();
473 bdsBunch->BeginOfRunAction(nToGenerate, globals->Batch());
474 auto flagsCache(G4cout.flags());
475 for (G4int i = 0; i < nToGenerate; i++)
476 {
477 if (i%printModulo == 0)
478 {G4cout << "\r Primary> " << std::fixed << i << " of " << nToGenerate << G4endl;}
480 // always pull particle definition in case it's updated
482 bdsOutput->FillEventPrimaryOnly(coords, pDef);
483 }
484 G4cout.flags(flagsCache); // restore cout flags
485 // Write options now the file is open
488
489 // Write beam
491 bdsOutput->FillBeam(bb);
492
494}
static BDSAperturePointsCache * Instance()
Access the singleton instance.
void ClearCachedFiles()
Delete all cached points from memory and clear the map of files loaded.
static BDSBeamPipeFactory * Instance()
Singleton accessor.
static BDSBunch * CreateBunch(const BDSParticleDefinition *beamParticle, const GMAD::Beam &beam, const G4Transform3D &beamlineTransform=G4Transform3D::Identity, G4double beamlineS=0, G4bool generatePrimariesOnlyIn=false)
factory method
virtual void BeginOfRunAction(G4int numberOfEvents, G4bool batchMode)
Definition: BDSBunch.cc:285
virtual G4bool ExpectChangingParticleType() const
A hint of whether we expect to require and extended particle set (ie pions, kaons,...
Definition: BDSBunch.hh:80
virtual const BDSParticleDefinition * ParticleDefinition() const
Access the beam particle definition.
Definition: BDSBunch.hh:96
G4String Name() const
Distribution name.
Definition: BDSBunch.hh:145
virtual BDSParticleCoordsFullGlobal GetNextParticleValid(G4int maxTries=100)
Definition: BDSBunch.cc:234
static BDSCavityFactory * Instance()
Singleton accessor.
static BDSColours * Instance()
singleton pattern
Definition: BDSColours.cc:33
Interface class the developer should derive to construct their element.
Factory for user specified accelerator components.
void RegisterComponent(const G4String &componentTypeName, BDSComponentConstructor *componentConstructor)
Register a constructor instance by a given name.
Class that constructs a Geant4 model of an accelerator.
void SetDesignParticle(const BDSParticleDefinition *defIn)
Set the design particle definition.
Process information at the event level.
General exception with possible name of object and message.
Definition: BDSException.hh:35
Executable option processing for BDSIM.
const GMAD::Options & Options() const
Accessor for options generated by command line parsing.
void Print() const
Print out the commands and their set values.
G4bool IgnoreSIGINT() const
Accessor.
const GMAD::Beam & Beam() const
Accessor for beam options generate by command line parsing.
void PrintCopyright() const
Print out the copyright information (no exit).
G4String InputFileName() const
Acessor for convenience for the one thing that's needed before the parser options.
static void SetDesignParticle(const BDSParticleDefinition *designParticleIn)
Update the internal cache of the rigidity.
static void SetPrimaryGeneratorAction(BDSPrimaryGeneratorAction *pgaIn)
Update the internal cache of the primary generator action.
static BDSFieldFactory * Instance()
Public accessor method for singleton pattern.
static BDSFieldLoader * Instance()
Singleton accessor.
static BDSGeometryFactory * Instance()
Singleton accessor.
A class for writing fully constructed geometry from BDSIM out to other formats.
void ExportGeometry(G4String geometryType, G4String geometryFileName)
A class that holds global options and constants.
static BDSGlobalConstants * Instance()
Access method.
BDS::TrajectoryOptions StoreTrajectoryOptions() const
options that require some implementation.
G4bool UseImportanceSampling() const
Is importance sampling being used.
BDSRunManager * runManager
Cache of main objects in BDSIM.
Definition: BDSIMClass.hh:105
BDSOutput * bdsOutput
Cache of main objects in BDSIM.
Definition: BDSIMClass.hh:103
void RegisterUserComponent(const G4String &componentTypeName, BDSComponentConstructor *componentConstructor)
Definition: BDSIMClass.cc:455
void BeamOn(int nGenerate=-1)
Definition: BDSIMClass.cc:369
BDSIM()
Definition: BDSIMClass.cc:82
int Initialise()
The main function where everything is constructed.
Definition: BDSIMClass.cc:125
~BDSIM()
The destructor opens the geometry in Geant4 and deletes everything.
Definition: BDSIMClass.cc:412
BDSComponentFactoryUser * userComponentFactory
Optional user registered component factory.
Definition: BDSIMClass.hh:106
BDSBunch * bdsBunch
Cache of main objects in BDSIM.
Definition: BDSIMClass.hh:104
bool ignoreSIGINT
For cmake testing.
Definition: BDSIMClass.hh:94
void GeneratePrimariesOnly(const BDSGlobalConstants *globals)
Definition: BDSIMClass.cc:467
BDSDetectorConstruction * realWorld
Cache of main objects in BDSIM.
Definition: BDSIMClass.hh:108
int initialisationResult
Possible to not finish initialisation but have completed ok - flag for this.
Definition: BDSIMClass.hh:97
G4VModularPhysicsList * userPhysicsList
Optional user registered physics list.
Definition: BDSIMClass.hh:107
int argcCache
Cache of argc.
Definition: BDSIMClass.hh:98
char ** argvCache
Cache of argv.
Definition: BDSIMClass.hh:99
bool usualPrintOut
Whether to allow the usual cout output.
Definition: BDSIMClass.hh:95
BDSParser * parser
Cache of main objects in BDSIM.
Definition: BDSIMClass.hh:102
bool initialised
Whether initialisation was completed safely.
Definition: BDSIMClass.hh:96
static BDSMaterials * Instance()
Singleton pattern access.
Definition: BDSMaterials.cc:39
void PrepareRequiredMaterials(G4bool verbose=false)
converts parser material list
static BDSOutput * CreateOutput(BDSOutputType format, const G4String &fileName, G4int fileNumberOffset=-1, G4int compressionLevel=-1)
factory method
virtual void NewFile()=0
Open a new file. This should call WriteHeader() in it.
void FillEventPrimaryOnly(const BDSParticleCoordsFullGlobal &coords, const BDSParticleDefinition *particle)
Definition: BDSOutput.cc:271
void FillBeam(const GMAD::BeamBase *beam)
Definition: BDSOutput.cc:208
void FillOptions(const GMAD::OptionsBase *options)
Definition: BDSOutput.cc:215
virtual void CloseFile()=0
void AmalgamateBeam(const GMAD::Beam &beamIn, bool recreate)
Amalgamate the input beam definition with the ones stored in teh parser.
Definition: BDSParser.cc:65
const GMAD::OptionsBase * GetOptionsBase() const
Return bare options base class.
Definition: BDSParser.hh:53
void CheckOptions()
Check options for consistency. This also checks the beam options.
Definition: BDSParser.cc:84
static BDSParser * Instance()
Access method.
Definition: BDSParser.cc:28
const GMAD::Beam & GetBeam() const
Return beam.
Definition: BDSParser.hh:56
const GMAD::Options & GetOptions() const
Return options.
Definition: BDSParser.hh:50
void AmalgamateOptions(const GMAD::Options &optionsIn)
Amalgamate the input options with the ones stored in the parser.
Definition: BDSParser.cc:76
const GMAD::BeamBase * GetBeamBase() const
Return bare beam base class.
Definition: BDSParser.hh:62
const GMAD::FastList< GMAD::PhysicsBiasing > & GetBiasing() const
Return biasing list.
Definition: BDSParser.hh:92
A set of particle coordinates in both local and global.
Wrapper for particle definition.
G4String Name() const
Accessor.
G4double KineticEnergy() const
Accessor.
G4double BRho() const
Accessor.
G4bool IsAnIon() const
Accessor.
Generates primary particle vertices using BDSBunch.
Control over the beginning and end of run actions.
Definition: BDSRunAction.hh:44
Wrapper from G4RunManager that provides more output.
virtual void Initialize()
virtual void BeamOn(G4int n_event, const char *macroFile=nullptr, G4int n_select=-1)
Altered BeamOn function to account for Placet synchronisation.
static BDSSamplerRegistry * Instance()
Accessor for registry.
BDSIM's Geant4 stacking action.
Provide extra output for Geant4 through a verbose stepping action.
static BDSTemporaryFiles * Instance()
Singleton accessor.
Action to decide whether or not to store trajectory information.
The BDS Visualisation Manager.
void StartSession(int argc, char **argv)
Start interactive mode.
Options for a beam distribution.
Definition: beamBase.h:35
Basic options class independent of Geant4.
Definition: optionsBase.h:36
std::string physicsList
list of physics processes
Definition: optionsBase.h:115
bool verbose
General verbosity.
Definition: optionsBase.h:64
bool recreate
Whether to recreate from a file or not.
Definition: optionsBase.h:94
std::vector< G4ParallelWorldPhysics * > ConstructParallelWorldPhysics(const std::vector< G4VUserParallelWorld * > &worlds)
Construct the parallel physics process for each sampler world.
void PrintDefinedParticles()
void RegisterSamplerPhysics(const std::vector< G4ParallelWorldPhysics * > &processes, G4VModularPhysicsList *physicsList)
Register each parallel physics process to the main physics list.
void RegisterImportanceBiasing(const std::vector< G4VUserParallelWorld * > &worlds, G4VModularPhysicsList *physicsList)
Create importance geometry sampler and register importance biasing with physics list.
std::vector< G4VUserParallelWorld * > ConstructAndRegisterParallelWorlds(G4VUserDetectorConstruction *massWorld, G4bool buildSamplerWorld, G4bool buildPlacementFieldsWorld)
void PrintPrimaryParticleProcesses(const G4String &primaryParticleName)
void BuildMuonBiasing(G4VModularPhysicsList *physicsList)
Build muon splitting biasing and wrap the various processes in the physics list.
G4bool Geant4EnvironmentIsSet()
Check if the geant4 environmental variables necessary for a run are set.
void ConstructExtendedParticleSet()
void HandleAborts(int signal_number)
void ConstructDesignAndBeamParticle(const GMAD::Beam &beamDefinition, G4double ffact, BDSParticleDefinition *&designParticle, BDSParticleDefinition *&beamParticle, G4bool &beamDifferentFromDesignParticle)
G4int VerboseEventStop(G4int verboseEventStart, G4int verboseEventContinueFor)
void AddIStore(const std::vector< G4VUserParallelWorld * > &worlds)
Get store, and prepare importance sampling for importance geometry sampler.
G4bool IsFinite(G4double value, G4double tolerance=std::numeric_limits< double >::epsilon())
G4VModularPhysicsList * BuildPhysics(const G4String &physicsList, G4int verbosity=1)