Geant4  10.03.p01
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Public Member Functions | List of all members
G4RunMessenger Class Reference

#include <G4RunMessenger.hh>

Inheritance diagram for G4RunMessenger:
Inheritance graph
[legend]
Collaboration diagram for G4RunMessenger:
Collaboration graph
[legend]

Public Member Functions

 G4RunMessenger (G4RunManager *runMgr)
 
 ~G4RunMessenger ()
 
void SetNewValue (G4UIcommand *command, G4String newValues)
 
G4String GetCurrentValue (G4UIcommand *command)
 
- Public Member Functions inherited from G4UImessenger
 G4UImessenger ()
 
 G4UImessenger (const G4String &path, const G4String &dsc, G4bool commandsToBeBroadcasted=true)
 
virtual ~G4UImessenger ()
 
G4bool operator== (const G4UImessenger &messenger) const
 
G4bool CommandsShouldBeInMaster () const
 

Additional Inherited Members

- Protected Member Functions inherited from G4UImessenger
G4String ItoS (G4int i)
 
G4String DtoS (G4double a)
 
G4String BtoS (G4bool b)
 
G4int StoI (G4String s)
 
G4double StoD (G4String s)
 
G4bool StoB (G4String s)
 
void AddUIcommand (G4UIcommand *newCommand)
 
void CreateDirectory (const G4String &path, const G4String &dsc, G4bool commandsToBeBroadcasted=true)
 
template<typename T >
T * CreateCommand (const G4String &cname, const G4String &dsc)
 
- Protected Attributes inherited from G4UImessenger
G4UIdirectory * baseDir
 
G4String baseDirName
 
G4bool commandsShouldBeInMaster
 

Detailed Description

Definition at line 69 of file G4RunMessenger.hh.

Constructor & Destructor Documentation

G4RunMessenger::G4RunMessenger ( G4RunManager *  runMgr)

Definition at line 48 of file G4RunMessenger.cc.

49 :runManager(runMgr)
50 {
51  runDirectory = new G4UIdirectory("/run/");
52  runDirectory->SetGuidance("Run control commands.");
53 
54  initCmd = new G4UIcmdWithoutParameter("/run/initialize",this);
55  initCmd->SetGuidance("Initialize G4 kernel.");
56  initCmd->AvailableForStates(G4State_PreInit,G4State_Idle),
57 
58  beamOnCmd = new G4UIcommand("/run/beamOn",this);
59  beamOnCmd->SetGuidance("Start a Run.");
60  beamOnCmd->SetGuidance("If G4 kernel is not initialized, it will be initialized.");
61  beamOnCmd->SetGuidance("Default number of events to be processed is 1.");
62  beamOnCmd->SetGuidance("The second and third arguments can be used for");
63  beamOnCmd->SetGuidance("executing a macro file at the end of each event.");
64  beamOnCmd->SetGuidance("If the second argument, i.e. name of the macro");
65  beamOnCmd->SetGuidance("file, is given but the third argument is not,");
66  beamOnCmd->SetGuidance("the macro file will be executed for all of the");
67  beamOnCmd->SetGuidance("event.");
68  beamOnCmd->SetGuidance("If the third argument (nSelect) is given, the");
69  beamOnCmd->SetGuidance("macro file will be executed only for the first");
70  beamOnCmd->SetGuidance("nSelect events.");
71  beamOnCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
72  beamOnCmd->SetToBeBroadcasted(false);
73  G4UIparameter* p1 = new G4UIparameter("numberOfEvent",'i',true);
74  p1->SetDefaultValue(1);
75  p1->SetParameterRange("numberOfEvent >= 0");
76  beamOnCmd->SetParameter(p1);
77  G4UIparameter* p2 = new G4UIparameter("macroFile",'s',true);
78  p2->SetDefaultValue("***NULL***");
79  beamOnCmd->SetParameter(p2);
80  G4UIparameter* p3 = new G4UIparameter("nSelect",'i',true);
81  p3->SetDefaultValue(-1);
82  p3->SetParameterRange("nSelect>=-1");
83  beamOnCmd->SetParameter(p3);
84  //beamOnCmd->SetToBeBroadcasted(false);
85 
86  verboseCmd = new G4UIcmdWithAnInteger("/run/verbose",this);
87  verboseCmd->SetGuidance("Set the Verbose level of G4RunManager.");
88  verboseCmd->SetGuidance(" 0 : Silent (default)");
89  verboseCmd->SetGuidance(" 1 : Display main topics");
90  verboseCmd->SetGuidance(" 2 : Display main topics and run summary");
91  verboseCmd->SetParameterName("level",true);
92  verboseCmd->SetDefaultValue(0);
93  verboseCmd->SetRange("level >=0 && level <=2");
94 
95  printProgCmd = new G4UIcmdWithAnInteger("/run/printProgress",this);
96  printProgCmd->SetGuidance("Display begin_of_event information at given frequency.");
97  printProgCmd->SetGuidance("If it is set to zero, only the begin_of_run is shown.");
98  printProgCmd->SetGuidance("If it is set to -1, no print-out is shown.");
99  printProgCmd->SetParameterName("mod",true);
100  printProgCmd->SetDefaultValue(-1);
101  printProgCmd->SetRange("mod>=-1");
102 
103  nThreadsCmd = new G4UIcmdWithAnInteger("/run/numberOfThreads",this);
104  nThreadsCmd->SetGuidance("Set the number of threads to be used.");
105  nThreadsCmd->SetGuidance("This command works only in PreInit state.");
106  nThreadsCmd->SetGuidance("This command is valid only for multi-threaded mode.");
107  nThreadsCmd->SetGuidance("The command is ignored if it is issued in sequential mode.");
108  nThreadsCmd->SetParameterName("nThreads",true);
109  nThreadsCmd->SetDefaultValue(2);
110  nThreadsCmd->SetRange("nThreads >0");
111  nThreadsCmd->SetToBeBroadcasted(false);
112  nThreadsCmd->AvailableForStates(G4State_PreInit);
113 
114  maxThreadsCmd = new G4UIcmdWithoutParameter("/run/useMaximumLogicalCores",this);
115  maxThreadsCmd->SetGuidance("Set the number of threads to be the number of available logical cores.");
116  maxThreadsCmd->SetGuidance("This command works only in PreInit state.");
117  maxThreadsCmd->SetGuidance("This command is valid only for multi-threaded mode.");
118  maxThreadsCmd->SetGuidance("The command is ignored if it is issued in sequential mode.");
119  maxThreadsCmd->SetToBeBroadcasted(false);
120  maxThreadsCmd->AvailableForStates(G4State_PreInit);
121 
122  pinAffinityCmd = new G4UIcmdWithAnInteger("/run/pinAffinity",this);
123  pinAffinityCmd->SetGuidance("Locks each thread to a specific logical core. Workers are locked in round robin to logical cores.");
124  pinAffinityCmd->SetGuidance("This command is valid only for multi-threaded mode.");
125  pinAffinityCmd->SetGuidance("This command works only in PreInit state.");
126  pinAffinityCmd->SetGuidance("This command is ignored if it is issued in sequential mode.");
127  pinAffinityCmd->SetGuidance("If a value n>0 is provided it starts setting affinity from the n-th CPU (note: counting from 1).");
128  pinAffinityCmd->SetGuidance("E.g. /run/pinAffinity 3 locks first thread on third logical CPU (number 2).");
129  pinAffinityCmd->SetGuidance("If a value n<0 is provided never locks on n-th CPU.");
130  pinAffinityCmd->SetParameterName("pinAffinity",true);
131  pinAffinityCmd->SetDefaultValue(1);
132  pinAffinityCmd->SetToBeBroadcasted(false);
133  pinAffinityCmd->SetRange("pinAffinity > 0 || pinAffinity < 0");
134  pinAffinityCmd->AvailableForStates(G4State_PreInit);
135 
136  evModCmd = new G4UIcommand("/run/eventModulo",this);
137  evModCmd->SetGuidance("Set the event modulo for dispatching events to worker threads");
138  evModCmd->SetGuidance("i.e. each worker thread is ordered to simulate N events and then");
139  evModCmd->SetGuidance("comes back to G4MTRunManager for next set.");
140  evModCmd->SetGuidance("If it is set to zero (default value), N is roughly given by this.");
141  evModCmd->SetGuidance(" N = int( sqrt( number_of_events / number_of_threads ) )");
142  evModCmd->SetGuidance("The value N may affect on the computing performance in particular");
143  evModCmd->SetGuidance("if N is too small compared to the total number of events.");
144  evModCmd->SetGuidance("The second parameter seedOnce specifies how frequently each worker");
145  evModCmd->SetGuidance("thread is seeded by the random number sequence contrally managed");
146  evModCmd->SetGuidance("by the master G4MTRunManager.");
147  evModCmd->SetGuidance(" - If seedOnce is set to 0 (default), seeds that are centrally managed");
148  evModCmd->SetGuidance(" by G4MTRunManager are set for every event of every worker thread.");
149  evModCmd->SetGuidance(" This option guarantees event reproducability regardless of number");
150  evModCmd->SetGuidance(" of threads.");
151  evModCmd->SetGuidance(" - If seedOnce is set to 1, seeds are set only once for the first");
152  evModCmd->SetGuidance(" event of each run of each worker thread. Event reproducability is");
153  evModCmd->SetGuidance(" guaranteed only if the same number of worker threads are used.");
154  evModCmd->SetGuidance(" On the other hand, this option offers better computing performance");
155  evModCmd->SetGuidance(" in particular for applications with relatively small primary");
156  evModCmd->SetGuidance(" particle energy and large number of events.");
157  evModCmd->SetGuidance(" - If seedOnce is set to 2, seeds are set only for the first event of");
158  evModCmd->SetGuidance(" group of N events. This option is reserved for the future use when");
159  evModCmd->SetGuidance(" Geant4 allows number of threads to be dynatically changed during an");
160  evModCmd->SetGuidance(" event loop.");
161  evModCmd->SetGuidance("This command is valid only for multi-threaded mode.");
162  evModCmd->SetGuidance("This command is ignored if it is issued in sequential mode.");
163  G4UIparameter* emp1 = new G4UIparameter("N",'i',true);
164  emp1->SetDefaultValue(0);
165  emp1->SetParameterRange("N >= 0");
166  evModCmd->SetParameter(emp1);
167  G4UIparameter* emp2 = new G4UIparameter("seedOnce",'i',true);
168  emp2->SetDefaultValue(0);
169  emp2->SetParameterRange("seedOnce >= 0 && seedOnce <=2");
170  evModCmd->SetParameter(emp2);
171  evModCmd->SetToBeBroadcasted(false);
172  evModCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
173 
174  dumpRegCmd = new G4UIcmdWithAString("/run/dumpRegion",this);
175  dumpRegCmd->SetGuidance("Dump region information.");
176  dumpRegCmd->SetGuidance("In case name of a region is not given, all regions will be displayed.");
177  dumpRegCmd->SetParameterName("regionName", true);
178  dumpRegCmd->SetDefaultValue("**ALL**");
179  dumpRegCmd->AvailableForStates(G4State_Idle);
180 
181  dumpCoupleCmd = new G4UIcmdWithoutParameter("/run/dumpCouples",this);
182  dumpCoupleCmd->SetGuidance("Dump material-cuts-couple information.");
183  dumpCoupleCmd->SetGuidance("Note that material-cuts-couple information is updated");
184  dumpCoupleCmd->SetGuidance("after BeamOn has started.");
185  dumpCoupleCmd->AvailableForStates(G4State_Idle);
186 
187  optCmd = new G4UIcmdWithABool("/run/optimizeGeometry",this);
188  optCmd->SetGuidance("Set the optimization flag for geometry.");
189  optCmd->SetGuidance("If it is set to TRUE, G4GeometryManager will optimize");
190  optCmd->SetGuidance("the geometry definitions.");
191  optCmd->SetGuidance("GEANT4 is initialized with this flag as TRUE.");
192  optCmd->SetParameterName("optimizeFlag",true);
193  optCmd->SetDefaultValue(true);
194  optCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
195 
196  brkBoECmd = new G4UIcmdWithABool("/run/breakAtBeginOfEvent",this);
197  brkBoECmd->SetGuidance("Set a break point at the begining of every event.");
198  brkBoECmd->SetParameterName("flag",true);
199  brkBoECmd->SetDefaultValue(true);
200 
201  brkEoECmd = new G4UIcmdWithABool("/run/breakAtEndOfEvent",this);
202  brkEoECmd->SetGuidance("Set a break point at the end of every event.");
203  brkEoECmd->SetParameterName("flag",true);
204  brkEoECmd->SetDefaultValue(true);
205 
206  abortCmd = new G4UIcmdWithABool("/run/abort",this);
207  abortCmd->SetGuidance("Abort current run processing.");
208  abortCmd->SetGuidance("If softAbort is false (default), currently processing event will be immediately aborted,");
209  abortCmd->SetGuidance("while softAbort is true, abortion occurs after processing the current event.");
210  abortCmd->AvailableForStates(G4State_GeomClosed,G4State_EventProc);
211  abortCmd->SetParameterName("softAbort",true);
212  abortCmd->SetDefaultValue(false);
213 
214  abortEventCmd = new G4UIcmdWithoutParameter("/run/abortCurrentEvent",this);
215  abortEventCmd->SetGuidance("Abort currently processing event.");
216  abortEventCmd->AvailableForStates(G4State_EventProc);
217 
218  geomCmd = new G4UIcmdWithoutParameter("/run/geometryModified",this);
219  geomCmd->SetGuidance("Force geometry to be closed (re-voxellized) again.");
220  geomCmd->SetGuidance("This command must be applied if geometry has been modified");
221  geomCmd->SetGuidance(" after the first initialization (or BeamOn).");
222  geomCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
223 
224  geomRebCmd = new G4UIcmdWithABool("/run/reinitializeGeometry",this);
225  geomRebCmd->SetGuidance("Force geometry to be rebuilt once again.");
226  geomRebCmd->SetGuidance("This command must be applied if the user needs his/her");
227  geomRebCmd->SetGuidance(" detector construction to be reinvoked.");
228  geomRebCmd->SetGuidance("/run/geometryModified is automatically issued with this command.");
229  geomRebCmd->SetParameterName("destroyFirst",true);
230  geomRebCmd->SetDefaultValue(false);
231  geomRebCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
232 
233  physCmd = new G4UIcmdWithoutParameter("/run/physicsModified",this);
234  physCmd->SetGuidance("Force all physics tables recalculated again.");
235  physCmd->SetGuidance("This command must be applied");
236  physCmd->SetGuidance(" if physics process has been modified after the");
237  physCmd->SetGuidance(" first initialization (or BeamOn).");
238  physCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
239 
240  constScoreCmd = new G4UIcmdWithoutParameter("/run/constructScoringWorlds",this);
241  constScoreCmd->SetGuidance("Constrct scoring parallel world(s) if defined.");
242  constScoreCmd->SetGuidance("This command is not mandatory, but automatically called when a run starts.");
243  constScoreCmd->SetGuidance("But the user may use this to visualize the scoring world(s) before a run to start.");
244  constScoreCmd->AvailableForStates(G4State_Idle);
245 
246  materialScanner = new G4MaterialScanner();
247 
248  randomDirectory = new G4UIdirectory("/random/");
249  randomDirectory->SetGuidance("Random number status control commands.");
250 
251  seedCmd = new G4UIcmdWithAString("/random/setSeeds",this);
252  seedCmd->SetGuidance("Initialize the random number generator with integer seed stream.");
253  seedCmd->SetGuidance("Number of integers should be more than 1.");
254  seedCmd->SetGuidance("Actual number of integers to be used depends on the individual random number engine.");
255 #ifdef G4MULTITHREADED
256  seedCmd->SetGuidance("This command sets the seeds for the master thread.");
257 #endif
258  seedCmd->SetParameterName("IntArray",false);
259  seedCmd->AvailableForStates(G4State_PreInit,G4State_Idle,G4State_GeomClosed);
260  seedCmd->SetToBeBroadcasted(false);
261 
262  randDirCmd = new G4UIcmdWithAString("/random/setDirectoryName",this);
263  randDirCmd->SetGuidance("Define the directory name of the rndm status files.");
264  randDirCmd->SetGuidance("Directory will be created if it does not exist.");
265  randDirCmd->SetParameterName("fileName",true);
266  randDirCmd->SetDefaultValue("./");
267  randDirCmd->AvailableForStates(G4State_PreInit,G4State_Idle,G4State_GeomClosed);
268 
269  savingFlagCmd = new G4UIcmdWithABool("/random/setSavingFlag",this);
270  savingFlagCmd->SetGuidance("The randomNumberStatus will be saved at :");
271  savingFlagCmd->SetGuidance("begining of run (currentRun.rndm) and "
272  "begining of event (currentEvent.rndm) ");
273  savingFlagCmd->SetParameterName("flag",true);
274  savingFlagCmd->SetDefaultValue(true);
275 
276  saveThisRunCmd = new G4UIcmdWithoutParameter("/random/saveThisRun",this);
277  saveThisRunCmd->SetGuidance("copy currentRun.rndm to runXXX.rndm");
278  saveThisRunCmd->AvailableForStates(G4State_Idle,G4State_GeomClosed,G4State_EventProc);
279 
280  saveThisEventCmd = new G4UIcmdWithoutParameter("/random/saveThisEvent",this);
281  saveThisEventCmd->SetGuidance("copy currentEvent.rndm to runXXXevtYYY.rndm");
282  saveThisEventCmd->AvailableForStates(G4State_EventProc);
283 
284  restoreRandCmd = new G4UIcmdWithAString("/random/resetEngineFrom",this);
285  restoreRandCmd->SetGuidance("Reset the status of the rndm engine from a file.");
286  restoreRandCmd->SetGuidance("See CLHEP manual for detail.");
287  restoreRandCmd->SetGuidance("The engine status must be stored beforehand.");
288  restoreRandCmd->SetGuidance("Directory of the status file should be set by"
289  " /random/setDirectoryName.");
290  restoreRandCmd->SetParameterName("fileName",true);
291  restoreRandCmd->SetDefaultValue("currentRun.rndm");
292  restoreRandCmd->AvailableForStates(G4State_PreInit,G4State_Idle,G4State_GeomClosed);
293  restoreRandCmd->SetToBeBroadcasted(false);
294 
295  restoreRandCmdMT = new G4UIcmdWithABool("/random/resetEngineFromEachEvent",this);
296  restoreRandCmdMT->SetGuidance("Reset the status of the rndm engine from a file at each event.");
297  restoreRandCmdMT->SetGuidance("Note that the file must follow the following naming convention:");
298  restoreRandCmdMT->SetGuidance("run{#1}evt{#2}.rndm ; where #1 is the run number and #2 is the event number.");
299  restoreRandCmdMT->SetGuidance("For example to re-seed the first event of the first run the file should be called run0evt0.rndm.");
300  restoreRandCmdMT->SetGuidance("If for a specific run/event the file is not found, the standard re-seeding strategy is used.");
301  restoreRandCmdMT->SetGuidance("This command has meaning only in MT mode for strong reproducibility studies.");
302  restoreRandCmdMT->SetGuidance("Directory of the status file should be set by"
303  " /random/setDirectoryName.");
304  restoreRandCmdMT->SetDefaultValue(false);
305  restoreRandCmdMT->AvailableForStates(G4State_PreInit,G4State_Idle,G4State_GeomClosed);
306 
307 
308  saveEachEventCmd = new G4UIcmdWithABool("/random/saveEachEventFlag",this);
309  saveEachEventCmd->SetGuidance("Save random number status at beginning of each event.");
310  saveEachEventCmd->SetGuidance("File name contains run and event numbers: runXXXevtYYY.rndm");
311  saveEachEventCmd->SetParameterName("flag",true);
312  saveEachEventCmd->SetDefaultValue(true);
313 
314  randEvtCmd = new G4UIcmdWithAnInteger("/run/storeRndmStatToEvent",this);
315  randEvtCmd->SetGuidance("Flag to store rndm status to G4Event object.");
316  randEvtCmd->SetGuidance(" flag = 0 : not store (default)");
317  randEvtCmd->SetGuidance(" flag = 1 : status before primary particle generation is stored");
318  randEvtCmd->SetGuidance(" flag = 2 : status before event processing (after primary particle generation) is stored");
319  randEvtCmd->SetGuidance(" flag = 3 : both are stored");
320  randEvtCmd->SetGuidance("Note: Some performance overhead may be seen by storing rndm status, in particular");
321  randEvtCmd->SetGuidance("for the case of simplest geometry and small number of tracks per event.");
322  randEvtCmd->SetParameterName("flag",true);
323  randEvtCmd->SetDefaultValue(0);
324  randEvtCmd->SetRange("flag>=0 && flag<3");
325  randEvtCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
326 
327  procUICmds = new G4UIcmdWithoutParameter("/run/workersProcessCmds",this);
328  procUICmds->SetToBeBroadcasted(false);
329  procUICmds->SetGuidance("Force workers to process current stack of UI commands.");
330  procUICmds->SetGuidance("This commands is meaningful only in MT mode.");
331  procUICmds->AvailableForStates(G4State_PreInit,G4State_Idle,G4State_GeomClosed);
332 
333 }
G4UIcmdWithAString::SetParameterName
void SetParameterName(const char *theName, G4bool omittable, G4bool currentAsDefault=false)
Definition: G4UIcmdWithAString.cc:42
G4UIcommand::SetParameter
void SetParameter(G4UIparameter *const newParameter)
Definition: G4UIcommand.hh:152
G4UIcmdWithAnInteger::SetParameterName
void SetParameterName(const char *theName, G4bool omittable, G4bool currentAsDefault=false)
Definition: G4UIcmdWithAnInteger.cc:47
G4UIparameter::SetParameterRange
void SetParameterRange(const char *theRange)
Definition: G4UIparameter.hh:95
G4UIcommand::SetToBeBroadcasted
void SetToBeBroadcasted(G4bool val)
Definition: G4UIcommand.hh:184
G4UIparameter::SetDefaultValue
void SetDefaultValue(const char *theDefaultValue)
Definition: G4UIparameter.hh:83
G4State_EventProc
Definition: G4ApplicationState.hh:86
G4UIcmdWithABool::SetDefaultValue
void SetDefaultValue(G4bool defVal)
Definition: G4UIcmdWithABool.cc:55
G4UIcmdWithABool::SetParameterName
void SetParameterName(const char *theName, G4bool omittable, G4bool currentAsDefault=false)
Definition: G4UIcmdWithABool.cc:47
G4UIcommand::SetRange
void SetRange(const char *rs)
Definition: G4UIcommand.hh:125
G4UIcommand::SetGuidance
void SetGuidance(const char *aGuidance)
Definition: G4UIcommand.hh:161
G4State_GeomClosed
Definition: G4ApplicationState.hh:85
G4UIcommand::AvailableForStates
void AvailableForStates(G4ApplicationState s1)
Definition: G4UIcommand.cc:240
G4UIcmdWithAString::SetDefaultValue
void SetDefaultValue(const char *defVal)
Definition: G4UIcmdWithAString.cc:57
G4State_Idle
Definition: G4ApplicationState.hh:85
G4UIcmdWithAnInteger::SetDefaultValue
void SetDefaultValue(G4int defVal)
Definition: G4UIcmdWithAnInteger.cc:55
G4State_PreInit
Definition: G4ApplicationState.hh:85

Here is the call graph for this function:

G4RunMessenger::~G4RunMessenger ( )

Definition at line 335 of file G4RunMessenger.cc.

336 {
337  delete materialScanner;
338  delete beamOnCmd;
339  delete verboseCmd;
340  delete printProgCmd;
341  delete nThreadsCmd;
342  delete maxThreadsCmd;
343  delete pinAffinityCmd;
344  delete evModCmd;
345  delete optCmd;
346  delete dumpRegCmd;
347  delete dumpCoupleCmd;
348  delete brkBoECmd;
349  delete brkEoECmd;
350  delete abortCmd;
351  delete abortEventCmd;
352  delete initCmd;
353  delete geomCmd;
354  delete geomRebCmd;
355  delete physCmd;
356  delete randEvtCmd;
357  delete constScoreCmd;
358  delete procUICmds;
359 
360  delete seedCmd;
361  delete savingFlagCmd;
362  delete saveThisRunCmd;
363  delete saveThisEventCmd;
364  delete restoreRandCmd;
365  delete randomDirectory;
366  delete saveEachEventCmd;
367 
368  delete randDirCmd;
369  delete runDirectory;
370 
371  delete restoreRandCmdMT;
372 }

Member Function Documentation

G4String G4RunMessenger::GetCurrentValue ( G4UIcommand *  command)
virtual

Reimplemented from G4UImessenger.

Definition at line 557 of file G4RunMessenger.cc.

558 {
559  G4String cv;
560 
561  if( command==verboseCmd )
562  { cv = verboseCmd->ConvertToString(runManager->GetVerboseLevel()); }
563  else if( command == printProgCmd )
564  { cv = printProgCmd->ConvertToString(runManager->GetPrintProgress()); }
565  else if( command==randDirCmd )
566  { cv = runManager->GetRandomNumberStoreDir(); }
567  else if( command==randEvtCmd )
568  { cv = randEvtCmd->ConvertToString(runManager->GetFlagRandomNumberStatusToG4Event()); }
569  else if( command==nThreadsCmd )
570  {
571  G4RunManager::RMType rmType = runManager->GetRunManagerType();
572  if( rmType==G4RunManager::masterRM )
573  {
574  cv = nThreadsCmd->ConvertToString(
575  static_cast<G4MTRunManager*>(runManager)->GetNumberOfThreads());
576  }
577  else if ( rmType==G4RunManager::sequentialRM )
578  {
579  cv = "0";
580  }
581  }
582  else if( command==evModCmd)
583  {
584  G4RunManager::RMType rmType = runManager->GetRunManagerType();
585  if( rmType==G4RunManager::masterRM )
586  {
587  cv = evModCmd->ConvertToString(
588  static_cast<G4MTRunManager*>(runManager)->GetEventModulo() )
589  + " " + evModCmd->ConvertToString(G4MTRunManager::SeedOncePerCommunication());
590  }
591  else if ( rmType==G4RunManager::sequentialRM )
592  { G4cout<<"*** /run/eventModulo command is valid only in MT mode."<<G4endl; }
593  }
594 
595  return cv;
596 }
G4RunManager::GetVerboseLevel
G4int GetVerboseLevel() const
Definition: G4RunManager.hh:500
G4RunManager::GetPrintProgress
G4int GetPrintProgress()
Definition: G4RunManager.hh:502
G4RunManager::GetRandomNumberStoreDir
const G4String & GetRandomNumberStoreDir() const
Definition: G4RunManager.hh:435
G4UIcommand::ConvertToString
static G4String ConvertToString(G4bool boolVal)
Definition: G4UIcommand.cc:372
G4RunManager::GetFlagRandomNumberStatusToG4Event
G4int GetFlagRandomNumberStatusToG4Event() const
Definition: G4RunManager.hh:407
G4cout
G4GLOB_DLL std::ostream G4cout
G4RunManager::GetRunManagerType
RMType GetRunManagerType() const
Definition: G4RunManager.hh:570
G4MTRunManager::SeedOncePerCommunication
static G4int SeedOncePerCommunication()
Definition: G4MTRunManager.hh:256
G4endl
#define G4endl
Definition: G4ios.hh:61

Here is the call graph for this function:

void G4RunMessenger::SetNewValue ( G4UIcommand *  command,
G4String  newValues 
)
virtual

Reimplemented from G4UImessenger.

Definition at line 374 of file G4RunMessenger.cc.

375 {
376  if( command==beamOnCmd )
377  {
378  G4int nev;
379  G4int nst;
380  const char* nv = (const char*)newValue;
381  std::istringstream is(nv);
382  is >> nev >> macroFileName >> nst;
383  if(macroFileName=="***NULL***")
384  { runManager->BeamOn(nev); }
385  else
386  { runManager->BeamOn(nev,macroFileName,nst); }
387  }
388  else if( command==verboseCmd )
389  { runManager->SetVerboseLevel(verboseCmd->GetNewIntValue(newValue)); }
390  else if( command == printProgCmd )
391  { runManager->SetPrintProgress(printProgCmd->GetNewIntValue(newValue)); }
392  else if( command==nThreadsCmd )
393  {
394  G4RunManager::RMType rmType = runManager->GetRunManagerType();
395  if( rmType==G4RunManager::masterRM )
396  {
397  static_cast<G4MTRunManager*>(runManager)->SetNumberOfThreads(
398  nThreadsCmd->GetNewIntValue(newValue));
399  }
400  else if ( rmType==G4RunManager::sequentialRM )
401  {
402  G4cout<<"*** /run/numberOfThreads command is issued in sequential mode."
403  <<"\nCommand is ignored."<<G4endl;
404  }
405  else
406  {
407  G4Exception("G4RunMessenger::ApplyNewCommand","Run0901",FatalException,
408  "/run/numberOfThreads command is issued to local thread.");
409  }
410  }
411  else if( command==maxThreadsCmd)
412  {
413  G4RunManager::RMType rmType = runManager->GetRunManagerType();
414  if( rmType==G4RunManager::masterRM )
415  {
416  static_cast<G4MTRunManager*>(runManager)->SetNumberOfThreads(
417  G4Threading::G4GetNumberOfCores() );
418  }
419  else if ( rmType==G4RunManager::sequentialRM )
420  {
421  G4cout<<"*** /run/useMaximumLogicalCores command is issued in sequential mode."
422  <<"\nCommand is ignored."<<G4endl;
423  }
424  else
425  {
426  G4Exception("G4RunMessenger::ApplyNewCommand","Run0901",FatalException,
427  "/run/useMaximumLogicalCores command is issued to local thread.");
428  }
429  }
430  else if ( command == pinAffinityCmd )
431  {
432  G4RunManager::RMType rmType = runManager->GetRunManagerType();
433  if( rmType==G4RunManager::masterRM )
434  {
435  static_cast<G4MTRunManager*>(runManager)->SetPinAffinity(
436  pinAffinityCmd->GetNewIntValue(newValue) );
437  }
438  else if ( rmType==G4RunManager::sequentialRM )
439  {
440  G4cout<<"*** /run/pinAffinity command is issued in sequential mode."
441  <<"\nCommand is ignored."<<G4endl;
442  }
443  else
444  {
445  G4Exception("G4RunMessenger::ApplyNewCommand","Run0901",FatalException,
446  "/run/pinAffinity command is issued to local thread.");
447  }
448 
449  }
450  else if( command==evModCmd)
451  {
452  G4RunManager::RMType rmType = runManager->GetRunManagerType();
453  if( rmType==G4RunManager::masterRM )
454  {
455  G4int nevMod = 0;
456  G4int sOnce = 0;
457  const char* nv = (const char*)newValue;
458  std::istringstream is(nv);
459  is >> nevMod >> sOnce;
460  static_cast<G4MTRunManager*>(runManager)->SetEventModulo(nevMod);
461  G4MTRunManager::SetSeedOncePerCommunication(sOnce);
462  }
463  else if ( rmType==G4RunManager::sequentialRM )
464  {
465  G4cout<<"*** /run/eventModulo command is issued in sequential mode."
466  <<"\nCommand is ignored."<<G4endl;
467  }
468  else
469  {
470  G4Exception("G4RunMessenger::ApplyNewCommand","Run0902",FatalException,
471  "/run/eventModulo command is issued to local thread.");
472  }
473  }
474  else if( command==dumpRegCmd )
475  {
476  if(newValue=="**ALL**")
477  { runManager->DumpRegion(); }
478  else
479  { runManager->DumpRegion(newValue); }
480  }
481  else if( command==dumpCoupleCmd)
482  {
483  G4ProductionCutsTable::GetProductionCutsTable()->DumpCouples();
484  }
485  else if( command==optCmd )
486  { runManager->SetGeometryToBeOptimized(optCmd->GetNewBoolValue(newValue)); }
487  else if( command==brkBoECmd )
488  { G4UImanager::GetUIpointer()->SetPauseAtBeginOfEvent(brkBoECmd->GetNewBoolValue(newValue)); }
489  else if( command==brkEoECmd )
490  { G4UImanager::GetUIpointer()->SetPauseAtEndOfEvent(brkEoECmd->GetNewBoolValue(newValue)); }
491  else if( command==abortCmd )
492  { runManager->AbortRun(abortCmd->GetNewBoolValue(newValue)); }
493  else if( command==abortEventCmd )
494  { runManager->AbortEvent(); }
495  else if( command==initCmd )
496  { runManager->Initialize(); }
497  else if( command==geomCmd )
498  { runManager->GeometryHasBeenModified(false); }
499  else if( command==geomRebCmd )
500  { runManager->ReinitializeGeometry(geomRebCmd->GetNewBoolValue(newValue),false); }
501  else if( command==physCmd )
502  { runManager->PhysicsHasBeenModified(); }
503  else if( command==seedCmd )
504  {
505  G4Tokenizer next(newValue);
506  G4int idx=0;
507  long seeds[100];
508  G4String vl;
509  while(!(vl=next()).isNull())
510  { seeds[idx] = (long)(StoI(vl)); idx++; }
511  if(idx<2)
512  { G4cerr << "/random/setSeeds should have at least two integers. Command ignored." << G4endl; }
513  else
514  {
515  seeds[idx] = 0;
516  G4Random::setTheSeeds(seeds);
517  }
518  }
519  else if( command==randDirCmd )
520  { runManager->SetRandomNumberStoreDir(newValue); }
521  else if( command==savingFlagCmd )
522  { runManager->SetRandomNumberStore(savingFlagCmd->GetNewBoolValue(newValue)); }
523  else if( command==saveThisRunCmd )
524  { runManager->rndmSaveThisRun(); }
525  else if( command==saveThisEventCmd )
526  { runManager->rndmSaveThisEvent(); }
527  else if( command==restoreRandCmd )
528  { runManager->RestoreRandomNumberStatus(newValue); }
529  else if( command==randEvtCmd )
530  { runManager->StoreRandomNumberStatusToG4Event(randEvtCmd->GetNewIntValue(newValue)); }
531  else if( command==saveEachEventCmd)
532  { runManager->SetRandomNumberStorePerEvent(saveEachEventCmd->GetNewBoolValue(newValue)); }
533  else if( command==constScoreCmd )
534  { runManager->ConstructScoringWorlds(); }
535  else if( command==restoreRandCmdMT)
536  { runManager->RestoreRndmEachEvent(restoreRandCmdMT->GetNewBoolValue(newValue)); }
537  else if ( command==procUICmds)
538  {
539  G4RunManager::RMType rmType = runManager->GetRunManagerType();
540  if( rmType==G4RunManager::masterRM ) {
541  auto rm = dynamic_cast<G4MTRunManager*>(runManager);
542  if ( rm != nullptr ) {
543  rm->RequestWorkersProcessCommandsStack();
544  }
545  else { G4Exception("G4RunManager::ApplyNewCommand","Run0128",FatalException,"/run/workersProcessCmds command issued on a non-G4MTRunManager class instance."); }
546  } else if ( rmType==G4RunManager::sequentialRM ) {
547  G4cout<<"*** /run/workersProcessCmds command is issued in sequential mode."
548  <<"\nCommand is ignored."<<G4endl;
549  } else {
550  G4Exception("G4RunMessenger::ApplyNewCommand","Run0129",FatalException,
551  "/run/workersProcessCmds command is issued to local thread.");
552  }
553  }
554 
555 }
G4RunManager::GeometryHasBeenModified
void GeometryHasBeenModified(G4bool prop=true)
Definition: G4RunManager.cc:909
G4RunManager::AbortRun
virtual void AbortRun(G4bool softAbort=false)
Definition: G4RunManager.cc:617
G4RunManager::SetVerboseLevel
void SetVerboseLevel(G4int vl)
Definition: G4RunManager.hh:497
G4UIcmdWithAnInteger::GetNewIntValue
static G4int GetNewIntValue(const char *paramString)
Definition: G4UIcmdWithAnInteger.cc:41
G4RunManager::SetPrintProgress
void SetPrintProgress(G4int i)
Definition: G4RunManager.hh:504
G4RunManager::SetGeometryToBeOptimized
void SetGeometryToBeOptimized(G4bool vl)
Definition: G4RunManager.hh:507
G4RunManager::SetRandomNumberStorePerEvent
void SetRandomNumberStorePerEvent(G4bool flag)
Definition: G4RunManager.hh:447
G4RunManager::BeamOn
virtual void BeamOn(G4int n_event, const char *macroFile=0, G4int n_select=-1)
Definition: G4RunManager.cc:262
G4RunManager::SetRandomNumberStore
void SetRandomNumberStore(G4bool flag)
Definition: G4RunManager.hh:411
G4int
int G4int
Definition: G4Types.hh:78
G4UIcmdWithABool::GetNewBoolValue
static G4bool GetNewBoolValue(const char *paramString)
Definition: G4UIcmdWithABool.cc:41
G4UImanager::GetUIpointer
static G4UImanager * GetUIpointer()
Definition: G4UImanager.cc:59
G4RunManager::RestoreRandomNumberStatus
virtual void RestoreRandomNumberStatus(const G4String &fileN)
Definition: G4RunManager.cc:702
G4RunManager::rndmSaveThisRun
virtual void rndmSaveThisRun()
Definition: G4RunManager.cc:659
G4cout
G4GLOB_DLL std::ostream G4cout
G4RunManager::StoreRandomNumberStatusToG4Event
void StoreRandomNumberStatusToG4Event(G4int vl)
Definition: G4RunManager.hh:398
G4RunManager::PhysicsHasBeenModified
void PhysicsHasBeenModified()
Definition: G4RunManager.hh:471
G4RunManager::GetRunManagerType
RMType GetRunManagerType() const
Definition: G4RunManager.hh:570
G4RunManager::ConstructScoringWorlds
virtual void ConstructScoringWorlds()
Definition: G4RunManager.cc:739
G4Threading::G4GetNumberOfCores
G4int G4GetNumberOfCores()
Definition: G4Threading.cc:143
G4RunManager::rndmSaveThisEvent
virtual void rndmSaveThisEvent()
Definition: G4RunManager.cc:681
G4MTRunManager::RequestWorkersProcessCommandsStack
virtual void RequestWorkersProcessCommandsStack()
Definition: G4MTRunManager.cc:607
G4RunManager::ReinitializeGeometry
void ReinitializeGeometry(G4bool destroyFirst=false, G4bool prop=true)
Definition: G4RunManager.cc:923
G4UImessenger::StoI
G4int StoI(G4String s)
Definition: G4UImessenger.cc:89
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
G4ProductionCutsTable::GetProductionCutsTable
static G4ProductionCutsTable * GetProductionCutsTable()
Definition: G4ProductionCutsTable.cc:63
G4UImanager::SetPauseAtEndOfEvent
void SetPauseAtEndOfEvent(G4bool vl)
Definition: G4UImanager.hh:196
G4RunManager::RestoreRndmEachEvent
virtual void RestoreRndmEachEvent(G4bool)
Definition: G4RunManager.hh:596
FatalException
Definition: G4ExceptionSeverity.hh:60
G4UImanager::SetPauseAtBeginOfEvent
void SetPauseAtBeginOfEvent(G4bool vl)
Definition: G4UImanager.hh:192
G4RunManager::Initialize
virtual void Initialize()
Definition: G4RunManager.cc:554
G4endl
#define G4endl
Definition: G4ios.hh:61
G4RunManager::AbortEvent
virtual void AbortEvent()
Definition: G4RunManager.cc:637
G4RunManager::SetRandomNumberStoreDir
void SetRandomNumberStoreDir(const G4String &dir)
Definition: G4RunManager.hh:415
G4MTRunManager::SetSeedOncePerCommunication
static void SetSeedOncePerCommunication(G4int val)
Definition: G4MTRunManager.hh:257
G4RunManager::DumpRegion
void DumpRegion(const G4String &rname) const
Definition: G4RunManager.cc:716
G4cerr
G4GLOB_DLL std::ostream G4cerr

Here is the call graph for this function:

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