Geant4 Cross Reference |
1 // 2 // ******************************************************************** 3 // * License and Disclaimer * 4 // * * 5 // * The Geant4 software is copyright of the Copyright Holders of * 6 // * the Geant4 Collaboration. It is provided under the terms and * 7 // * conditions of the Geant4 Software License, included in the file * 8 // * LICENSE and available at http://cern.ch/geant4/license . These * 9 // * include a list of copyright holders. * 10 // * * 11 // * Neither the authors of this software system, nor their employing * 12 // * institutes,nor the agencies providing financial support for this * 13 // * work make any representation or warranty, express or implied, * 14 // * regarding this software system or assume any liability for its * 15 // * use. Please see the license in the file LICENSE and URL above * 16 // * for the full disclaimer and the limitation of liability. * 17 // * * 18 // * This code implementation is the result of the scientific and * 19 // * technical work of the GEANT4 collaboration. * 20 // * By using, copying, modifying or distributing the software (or * 21 // * any work based on the software) you agree to acknowledge its * 22 // * use in resulting scientific publications, and indicate your * 23 // * acceptance of all terms of the Geant4 Software license. * 24 // ******************************************************************** 25 // 26 // G4RunMessenger implementation 27 // 28 // Original author: M.Asai, 1997 29 // -------------------------------------------------------------------- 30 31 #include "G4RunMessenger.hh" 32 33 #include "G4MTRunManager.hh" 34 #include "G4SubEvtRunManager.hh" 35 #include "G4ProductionCutsTable.hh" 36 #include "G4RunManager.hh" 37 #include "G4Tokenizer.hh" 38 #include "G4UIcmdWithABool.hh" 39 #include "G4UIcmdWithAString.hh" 40 #include "G4UIcmdWithAnInteger.hh" 41 #include "G4UIcmdWithoutParameter.hh" 42 #include "G4UIcommand.hh" 43 #include "G4UIdirectory.hh" 44 #include "G4UImanager.hh" 45 #include "G4UIparameter.hh" 46 #include "G4ios.hh" 47 #include "Randomize.hh" 48 49 #include <sstream> 50 51 G4RunMessenger::G4RunMessenger(G4RunManager* runMgr) : runManager(runMgr) 52 { 53 runDirectory = new G4UIdirectory("/run/"); 54 runDirectory->SetGuidance("Run control commands."); 55 56 initCmd = new G4UIcmdWithoutParameter("/run/initialize", this); 57 initCmd->SetGuidance("Initialize G4 kernel."); 58 initCmd->AvailableForStates(G4State_PreInit, G4State_Idle), 59 60 beamOnCmd = new G4UIcommand("/run/beamOn", this); 61 beamOnCmd->SetGuidance("Start a Run."); 62 beamOnCmd->SetGuidance("If G4 kernel is not initialized, it will be initialized."); 63 beamOnCmd->SetGuidance("Default number of events to be processed is 1."); 64 beamOnCmd->SetGuidance("The second and third arguments can be used for"); 65 beamOnCmd->SetGuidance("executing a macro file at the end of each event."); 66 beamOnCmd->SetGuidance("If the second argument, i.e. name of the macro"); 67 beamOnCmd->SetGuidance("file, is given but the third argument is not,"); 68 beamOnCmd->SetGuidance("the macro file will be executed for all of the"); 69 beamOnCmd->SetGuidance("event."); 70 beamOnCmd->SetGuidance("If the third argument (nSelect) is given, the"); 71 beamOnCmd->SetGuidance("macro file will be executed only for the first"); 72 beamOnCmd->SetGuidance("nSelect events."); 73 beamOnCmd->AvailableForStates(G4State_PreInit, G4State_Idle); 74 beamOnCmd->SetToBeBroadcasted(false); 75 auto p1 = new G4UIparameter("numberOfEvent", 'i', true); 76 p1->SetDefaultValue(1); 77 p1->SetParameterRange("numberOfEvent >= 0"); 78 beamOnCmd->SetParameter(p1); 79 auto p2 = new G4UIparameter("macroFile", 's', true); 80 p2->SetDefaultValue("***NULL***"); 81 beamOnCmd->SetParameter(p2); 82 auto p3 = new G4UIparameter("nSelect", 'i', true); 83 p3->SetDefaultValue(-1); 84 p3->SetParameterRange("nSelect>=-1"); 85 beamOnCmd->SetParameter(p3); 86 // beamOnCmd->SetToBeBroadcasted(false); 87 88 verboseCmd = new G4UIcmdWithAnInteger("/run/verbose", this); 89 verboseCmd->SetGuidance("Set the Verbose level of G4RunManager."); 90 verboseCmd->SetGuidance(" 0 : Silent (default)"); 91 verboseCmd->SetGuidance(" 1 : Display main topics"); 92 verboseCmd->SetGuidance(" 2 : Display main topics and run summary"); 93 verboseCmd->SetGuidance(" 3 : Display some additional information"); 94 verboseCmd->SetGuidance(" 4 : Display detailed information"); 95 verboseCmd->SetGuidance(" N.B. 3 or 4 may cause significant performance degradation"); 96 verboseCmd->SetParameterName("level", true); 97 verboseCmd->SetDefaultValue(0); 98 verboseCmd->SetRange("level >=0 && level <=4"); 99 100 printProgCmd = new G4UIcmdWithAnInteger("/run/printProgress", this); 101 printProgCmd->SetGuidance("Display begin_of_event information at given frequency."); 102 printProgCmd->SetGuidance("If it is set to zero, only the begin_of_run is shown."); 103 printProgCmd->SetGuidance("If it is set to -1, no print-out is shown."); 104 printProgCmd->SetParameterName("mod", true); 105 printProgCmd->SetDefaultValue(-1); 106 printProgCmd->SetRange("mod>=-1"); 107 108 nThreadsCmd = new G4UIcmdWithAnInteger("/run/numberOfThreads", this); 109 nThreadsCmd->SetGuidance("Set the number of threads to be used."); 110 nThreadsCmd->SetGuidance("This command works only in PreInit state."); 111 nThreadsCmd->SetGuidance("This command is valid only for multi-threaded mode."); 112 nThreadsCmd->SetGuidance("The command is ignored if it is issued in sequential mode."); 113 nThreadsCmd->SetParameterName("nThreads", true); 114 nThreadsCmd->SetDefaultValue(2); 115 nThreadsCmd->SetRange("nThreads >0"); 116 nThreadsCmd->SetToBeBroadcasted(false); 117 nThreadsCmd->AvailableForStates(G4State_PreInit); 118 119 maxThreadsCmd = new G4UIcmdWithoutParameter("/run/useMaximumLogicalCores", this); 120 maxThreadsCmd->SetGuidance( 121 "Set the number of threads to be the number of available logical cores."); 122 maxThreadsCmd->SetGuidance("This command works only in PreInit state."); 123 maxThreadsCmd->SetGuidance("This command is valid only for multi-threaded mode."); 124 maxThreadsCmd->SetGuidance("The command is ignored if it is issued in sequential mode."); 125 maxThreadsCmd->SetToBeBroadcasted(false); 126 maxThreadsCmd->AvailableForStates(G4State_PreInit); 127 128 pinAffinityCmd = new G4UIcmdWithAnInteger("/run/pinAffinity", this); 129 pinAffinityCmd->SetGuidance( 130 "Locks each thread to a specific logical core. Workers " 131 "are locked in round robin to logical cores."); 132 pinAffinityCmd->SetGuidance("This command is valid only for multi-threaded mode."); 133 pinAffinityCmd->SetGuidance("This command works only in PreInit state."); 134 pinAffinityCmd->SetGuidance("This command is ignored if it is issued in sequential mode."); 135 pinAffinityCmd->SetGuidance( 136 "If a value n>0 is provided it starts setting affinity " 137 "from the n-th CPU (note: counting from 1)."); 138 pinAffinityCmd->SetGuidance( 139 "E.g. /run/pinAffinity 3 locks first thread on " 140 "third logical CPU (number 2)."); 141 pinAffinityCmd->SetGuidance("If a value n<0 is provided never locks on n-th CPU."); 142 pinAffinityCmd->SetParameterName("pinAffinity", true); 143 pinAffinityCmd->SetDefaultValue(1); 144 pinAffinityCmd->SetToBeBroadcasted(false); 145 pinAffinityCmd->SetRange("pinAffinity > 0 || pinAffinity < 0"); 146 pinAffinityCmd->AvailableForStates(G4State_PreInit); 147 148 evModCmd = new G4UIcommand("/run/eventModulo", this); 149 evModCmd->SetGuidance("Set the event modulo for dispatching events to worker threads"); 150 evModCmd->SetGuidance("i.e. each worker thread is ordered to simulate N events and then"); 151 evModCmd->SetGuidance("comes back to G4MTRunManager for next set."); 152 evModCmd->SetGuidance("If it is set to zero (default value), N is roughly given by this."); 153 evModCmd->SetGuidance(" N = int( sqrt( number_of_events / number_of_threads ) )"); 154 evModCmd->SetGuidance("The value N may affect on the computing performance in particular"); 155 evModCmd->SetGuidance("if N is too small compared to the total number of events."); 156 evModCmd->SetGuidance("The second parameter seedOnce specifies how frequently each worker"); 157 evModCmd->SetGuidance("thread is seeded by the random number sequence centrally managed"); 158 evModCmd->SetGuidance("by the master G4MTRunManager."); 159 evModCmd->SetGuidance(" - If seedOnce is set to 0 (default), seeds that are centrally managed"); 160 evModCmd->SetGuidance(" by G4MTRunManager are set for every event of every worker thread."); 161 evModCmd->SetGuidance(" This option guarantees event reproducibility regardless of number"); 162 evModCmd->SetGuidance(" of threads."); 163 evModCmd->SetGuidance(" - If seedOnce is set to 1, seeds are set only once for the first"); 164 evModCmd->SetGuidance(" event of each run of each worker thread. Event reproducibility is"); 165 evModCmd->SetGuidance(" guaranteed only if the same number of worker threads are used."); 166 evModCmd->SetGuidance(" On the other hand, this option offers better computing performance"); 167 evModCmd->SetGuidance(" in particular for applications with relatively small primary"); 168 evModCmd->SetGuidance(" particle energy and large number of events."); 169 evModCmd->SetGuidance(" - If seedOnce is set to 2, seeds are set only for the first event of"); 170 evModCmd->SetGuidance(" group of N events. This option is reserved for the future use when"); 171 evModCmd->SetGuidance(" Geant4 allows number of threads to be dynamically changed during an"); 172 evModCmd->SetGuidance(" event loop."); 173 evModCmd->SetGuidance("This command is valid only for multi-threaded event-level parallel mode."); 174 evModCmd->SetGuidance("This command is ignored if it is issued in sequential mode or in"); 175 evModCmd->SetGuidance("sub-event parallel mode."); 176 auto emp1 = new G4UIparameter("N", 'i', true); 177 emp1->SetDefaultValue(0); 178 emp1->SetParameterRange("N >= 0"); 179 evModCmd->SetParameter(emp1); 180 auto emp2 = new G4UIparameter("seedOnce", 'i', true); 181 emp2->SetDefaultValue(0); 182 emp2->SetParameterRange("seedOnce >= 0 && seedOnce <=2"); 183 evModCmd->SetParameter(emp2); 184 evModCmd->SetToBeBroadcasted(false); 185 evModCmd->AvailableForStates(G4State_PreInit, G4State_Idle); 186 187 dumpRegCmd = new G4UIcmdWithAString("/run/dumpRegion", this); 188 dumpRegCmd->SetGuidance("Dump region information."); 189 dumpRegCmd->SetGuidance("In case name of a region is not given, all regions will be displayed."); 190 dumpRegCmd->SetParameterName("regionName", true); 191 dumpRegCmd->SetDefaultValue("**ALL**"); 192 dumpRegCmd->AvailableForStates(G4State_Idle); 193 194 dumpCoupleCmd = new G4UIcmdWithoutParameter("/run/dumpCouples", this); 195 dumpCoupleCmd->SetGuidance("Dump material-cuts-couple information."); 196 dumpCoupleCmd->SetGuidance("Note that material-cuts-couple information is updated"); 197 dumpCoupleCmd->SetGuidance("after BeamOn has started."); 198 dumpCoupleCmd->AvailableForStates(G4State_Idle); 199 200 optCmd = new G4UIcmdWithABool("/run/optimizeGeometry", this); 201 optCmd->SetGuidance("Set the optimization flag for geometry."); 202 optCmd->SetGuidance("If it is set to TRUE, G4GeometryManager will optimize"); 203 optCmd->SetGuidance("the geometry definitions."); 204 optCmd->SetGuidance("GEANT4 is initialized with this flag as TRUE."); 205 optCmd->SetParameterName("optimizeFlag", true); 206 optCmd->SetDefaultValue(true); 207 optCmd->AvailableForStates(G4State_PreInit, G4State_Idle); 208 209 brkBoECmd = new G4UIcmdWithABool("/run/breakAtBeginOfEvent", this); 210 brkBoECmd->SetGuidance("Set a break point at the beginning of every event."); 211 brkBoECmd->SetParameterName("flag", true); 212 brkBoECmd->SetDefaultValue(true); 213 214 brkEoECmd = new G4UIcmdWithABool("/run/breakAtEndOfEvent", this); 215 brkEoECmd->SetGuidance("Set a break point at the end of every event."); 216 brkEoECmd->SetParameterName("flag", true); 217 brkEoECmd->SetDefaultValue(true); 218 219 abortCmd = new G4UIcmdWithABool("/run/abort", this); 220 abortCmd->SetGuidance("Abort current run processing."); 221 abortCmd->SetGuidance( 222 "If softAbort is false (default), currently processing event " 223 "will be immediately aborted,"); 224 abortCmd->SetGuidance( 225 "while softAbort is true, abortion occurs after " 226 "processing the current event."); 227 abortCmd->AvailableForStates(G4State_GeomClosed, G4State_EventProc); 228 abortCmd->SetParameterName("softAbort", true); 229 abortCmd->SetDefaultValue(false); 230 231 abortEventCmd = new G4UIcmdWithoutParameter("/run/abortCurrentEvent", this); 232 abortEventCmd->SetGuidance("Abort currently processing event."); 233 abortEventCmd->AvailableForStates(G4State_EventProc); 234 235 geomCmd = new G4UIcmdWithoutParameter("/run/geometryModified", this); 236 geomCmd->SetGuidance("Force geometry to be closed (re-voxellized) again."); 237 geomCmd->SetGuidance("This command must be applied if geometry has been modified"); 238 geomCmd->SetGuidance(" after the first initialization (or BeamOn)."); 239 geomCmd->AvailableForStates(G4State_PreInit, G4State_Idle); 240 241 geomRebCmd = new G4UIcmdWithABool("/run/reinitializeGeometry", this); 242 geomRebCmd->SetGuidance("Force geometry to be rebuilt once again."); 243 geomRebCmd->SetGuidance("This command must be applied if the user needs his/her"); 244 geomRebCmd->SetGuidance(" detector construction to be reinvoked."); 245 geomRebCmd->SetGuidance("/run/geometryModified is automatically issued with this command."); 246 geomRebCmd->SetParameterName("destroyFirst", true); 247 geomRebCmd->SetDefaultValue(false); 248 geomRebCmd->AvailableForStates(G4State_PreInit, G4State_Idle); 249 250 physCmd = new G4UIcmdWithoutParameter("/run/physicsModified", this); 251 physCmd->SetGuidance("Force all physics tables recalculated again."); 252 physCmd->SetGuidance("This command must be applied"); 253 physCmd->SetGuidance(" if physics process has been modified after the"); 254 physCmd->SetGuidance(" first initialization (or BeamOn)."); 255 physCmd->AvailableForStates(G4State_PreInit, G4State_Idle); 256 257 constScoreCmd = new G4UIcmdWithoutParameter("/run/constructScoringWorlds", this); 258 constScoreCmd->SetGuidance("Construct scoring parallel world(s) if defined."); 259 constScoreCmd->SetGuidance( 260 "This command is not mandatory, but automatically " 261 "called when a run starts."); 262 constScoreCmd->SetGuidance( 263 "But the user may use this to visualize the scoring " 264 "world(s) before a run to start."); 265 constScoreCmd->AvailableForStates(G4State_Idle); 266 267 randomDirectory = new G4UIdirectory("/random/"); 268 randomDirectory->SetGuidance("Random number status control commands."); 269 270 seedCmd = new G4UIcmdWithAString("/random/setSeeds", this); 271 seedCmd->SetGuidance("Initialize the random number generator with integer seed stream."); 272 seedCmd->SetGuidance("Number of integers should be more than 1."); 273 seedCmd->SetGuidance( 274 "Actual number of integers to be used depends on the individual " 275 "random number engine."); 276 #ifdef G4MULTITHREADED 277 seedCmd->SetGuidance("This command sets the seeds for the master thread."); 278 #endif 279 seedCmd->SetParameterName("IntArray", false); 280 seedCmd->AvailableForStates(G4State_PreInit, G4State_Idle, G4State_GeomClosed); 281 seedCmd->SetToBeBroadcasted(false); 282 283 randDirCmd = new G4UIcmdWithAString("/random/setDirectoryName", this); 284 randDirCmd->SetGuidance("Define the directory name of the rndm status files."); 285 randDirCmd->SetGuidance("Directory will be created if it does not exist."); 286 randDirCmd->SetParameterName("fileName", true); 287 randDirCmd->SetDefaultValue("./"); 288 randDirCmd->AvailableForStates(G4State_PreInit, G4State_Idle, G4State_GeomClosed); 289 290 savingFlagCmd = new G4UIcmdWithABool("/random/setSavingFlag", this); 291 savingFlagCmd->SetGuidance("The randomNumberStatus will be saved at :"); 292 savingFlagCmd->SetGuidance( 293 "beginning of run (currentRun.rndm) and " 294 "beginning of event (currentEvent.rndm) "); 295 savingFlagCmd->SetParameterName("flag", true); 296 savingFlagCmd->SetDefaultValue(true); 297 298 saveThisRunCmd = new G4UIcmdWithoutParameter("/random/saveThisRun", this); 299 saveThisRunCmd->SetGuidance("copy currentRun.rndm to runXXX.rndm"); 300 saveThisRunCmd->AvailableForStates(G4State_Idle, G4State_GeomClosed, G4State_EventProc); 301 302 saveThisEventCmd = new G4UIcmdWithoutParameter("/random/saveThisEvent", this); 303 saveThisEventCmd->SetGuidance("copy currentEvent.rndm to runXXXevtYYY.rndm"); 304 saveThisEventCmd->AvailableForStates(G4State_EventProc); 305 306 restoreRandCmd = new G4UIcmdWithAString("/random/resetEngineFrom", this); 307 restoreRandCmd->SetGuidance("Reset the status of the rndm engine from a file."); 308 restoreRandCmd->SetGuidance("See CLHEP manual for detail."); 309 restoreRandCmd->SetGuidance("The engine status must be stored beforehand."); 310 restoreRandCmd->SetGuidance( 311 "Directory of the status file should be set by" 312 " /random/setDirectoryName."); 313 restoreRandCmd->SetParameterName("fileName", true); 314 restoreRandCmd->SetDefaultValue("currentRun.rndm"); 315 restoreRandCmd->AvailableForStates(G4State_PreInit, G4State_Idle, G4State_GeomClosed); 316 restoreRandCmd->SetToBeBroadcasted(false); 317 318 restoreRandCmdMT = new G4UIcmdWithABool("/random/resetEngineFromEachEvent", this); 319 restoreRandCmdMT->SetGuidance("Reset the status of the rndm engine from a file at each event."); 320 restoreRandCmdMT->SetGuidance("Note that the file must follow the following naming convention:"); 321 restoreRandCmdMT->SetGuidance( 322 "run{#1}evt{#2}.rndm ; where #1 is the run " 323 "number and #2 is the event number."); 324 restoreRandCmdMT->SetGuidance( 325 "For example to re-seed the first event of the first " 326 "run the file should be called run0evt0.rndm."); 327 restoreRandCmdMT->SetGuidance( 328 "If for a specific run/event the file is not found, " 329 "the standard re-seeding strategy is used."); 330 restoreRandCmdMT->SetGuidance( 331 "This command has meaning only in MT mode for " 332 "strong reproducibility studies."); 333 restoreRandCmdMT->SetGuidance( 334 "Directory of the status file should be set by" 335 " /random/setDirectoryName."); 336 restoreRandCmdMT->SetDefaultValue(false); 337 restoreRandCmdMT->AvailableForStates(G4State_PreInit, G4State_Idle, G4State_GeomClosed); 338 339 saveEachEventCmd = new G4UIcmdWithABool("/random/saveEachEventFlag", this); 340 saveEachEventCmd->SetGuidance("Save random number status at beginning of each event."); 341 saveEachEventCmd->SetGuidance("File name contains run and event numbers: runXXXevtYYY.rndm"); 342 saveEachEventCmd->SetParameterName("flag", true); 343 saveEachEventCmd->SetDefaultValue(true); 344 345 randEvtCmd = new G4UIcmdWithAnInteger("/run/storeRndmStatToEvent", this); 346 randEvtCmd->SetGuidance("Flag to store rndm status to G4Event object."); 347 randEvtCmd->SetGuidance(" flag = 0 : not store (default)"); 348 randEvtCmd->SetGuidance(" flag = 1 : status before primary particle generation is stored"); 349 randEvtCmd->SetGuidance( 350 " flag = 2 : status before event processing (after primary " 351 "particle generation) is stored"); 352 randEvtCmd->SetGuidance(" flag = 3 : both are stored"); 353 randEvtCmd->SetGuidance( 354 "Note: Some performance overhead may be seen by storing rndm " 355 "status, in particular"); 356 randEvtCmd->SetGuidance( 357 "for the case of simplest geometry and small number of tracks per event."); 358 randEvtCmd->SetParameterName("flag", true); 359 randEvtCmd->SetDefaultValue(0); 360 randEvtCmd->SetRange("flag>=0 && flag<=3"); 361 randEvtCmd->AvailableForStates(G4State_PreInit, G4State_Idle); 362 363 procUICmds = new G4UIcmdWithoutParameter("/run/workersProcessCmds", this); 364 procUICmds->SetToBeBroadcasted(false); 365 procUICmds->SetGuidance("Force workers to process current stack of UI commands."); 366 procUICmds->SetGuidance("This commands is meaningful only in MT mode."); 367 procUICmds->AvailableForStates(G4State_PreInit, G4State_Idle, G4State_GeomClosed); 368 369 trajMergeCmd = new G4UIcmdWithABool("/run/trajectoriesToBeMerged",this); 370 trajMergeCmd->SetGuidance("Merge trajectories created in sub-event parallel mode."); 371 trajMergeCmd->SetGuidance("In sub-event parallel mode, trajectories created in worker "); 372 trajMergeCmd->SetGuidance("threads are not merged to the event in the master thread by default "); 373 trajMergeCmd->SetGuidance("due to the performance overhead caused by copying them."); 374 trajMergeCmd->SetGuidance("This command enables the merging."); 375 trajMergeCmd->SetGuidance("/tracking/storeTrajectory command must be set to create trajectories."); 376 trajMergeCmd->SetGuidance("This command is valid only for sub-event parallel mode."); 377 trajMergeCmd->AvailableForStates(G4State_PreInit, G4State_Idle); 378 trajMergeCmd->SetParameterName("flag", true); 379 trajMergeCmd->SetDefaultValue(true); 380 trajMergeCmd->SetToBeBroadcasted(false); 381 } 382 383 // -------------------------------------------------------------------- 384 G4RunMessenger::~G4RunMessenger() 385 { 386 delete beamOnCmd; 387 delete verboseCmd; 388 delete printProgCmd; 389 delete nThreadsCmd; 390 delete maxThreadsCmd; 391 delete pinAffinityCmd; 392 delete evModCmd; 393 delete optCmd; 394 delete dumpRegCmd; 395 delete dumpCoupleCmd; 396 delete brkBoECmd; 397 delete brkEoECmd; 398 delete abortCmd; 399 delete abortEventCmd; 400 delete initCmd; 401 delete geomCmd; 402 delete geomRebCmd; 403 delete physCmd; 404 delete randEvtCmd; 405 delete constScoreCmd; 406 delete procUICmds; 407 delete trajMergeCmd; 408 409 delete seedCmd; 410 delete savingFlagCmd; 411 delete saveThisRunCmd; 412 delete saveThisEventCmd; 413 delete restoreRandCmd; 414 delete randomDirectory; 415 delete saveEachEventCmd; 416 417 delete randDirCmd; 418 delete runDirectory; 419 420 delete restoreRandCmdMT; 421 } 422 423 // -------------------------------------------------------------------- 424 void G4RunMessenger::SetNewValue(G4UIcommand* command, G4String newValue) 425 { 426 if (command == beamOnCmd) { 427 G4int nev; 428 G4int nst; 429 const auto nv = (const char*)newValue; 430 std::istringstream is(nv); 431 is >> nev >> macroFileName >> nst; 432 if (macroFileName == "***NULL***") { 433 runManager->BeamOn(nev); 434 } 435 else { 436 runManager->BeamOn(nev, macroFileName, nst); 437 } 438 } 439 else if (command == verboseCmd) { 440 runManager->SetVerboseLevel(verboseCmd->GetNewIntValue(newValue)); 441 } 442 else if (command == printProgCmd) { 443 runManager->SetPrintProgress(printProgCmd->GetNewIntValue(newValue)); 444 } 445 else if (command == nThreadsCmd) { 446 G4RunManager::RMType rmType = runManager->GetRunManagerType(); 447 if (rmType == G4RunManager::masterRM) { 448 static_cast<G4MTRunManager*>(runManager) 449 ->SetNumberOfThreads(nThreadsCmd->GetNewIntValue(newValue)); 450 } 451 else if (rmType == G4RunManager::sequentialRM) { 452 G4cout << "*** /run/numberOfThreads command is issued in sequential mode." 453 << "\nCommand is ignored." << G4endl; 454 } 455 else { 456 G4Exception("G4RunMessenger::ApplyNewCommand", "Run0901", FatalException, 457 "/run/numberOfThreads command is issued to local thread."); 458 } 459 } 460 else if (command == maxThreadsCmd) { 461 G4RunManager::RMType rmType = runManager->GetRunManagerType(); 462 if (rmType == G4RunManager::masterRM) { 463 static_cast<G4MTRunManager*>(runManager) 464 ->SetNumberOfThreads(G4Threading::G4GetNumberOfCores()); 465 } 466 else if (rmType == G4RunManager::sequentialRM) { 467 G4cout << "*** /run/useMaximumLogicalCores command is issued in " 468 "sequential mode." 469 << "\nCommand is ignored." << G4endl; 470 } 471 else { 472 G4Exception("G4RunMessenger::ApplyNewCommand", "Run0901", FatalException, 473 "/run/useMaximumLogicalCores command is issued to local thread."); 474 } 475 } 476 else if (command == pinAffinityCmd) { 477 G4RunManager::RMType rmType = runManager->GetRunManagerType(); 478 if (rmType == G4RunManager::masterRM) { 479 static_cast<G4MTRunManager*>(runManager) 480 ->SetPinAffinity(pinAffinityCmd->GetNewIntValue(newValue)); 481 } 482 else if (rmType == G4RunManager::sequentialRM) { 483 G4cout << "*** /run/pinAffinity command is issued in sequential mode." 484 << "\nCommand is ignored." << G4endl; 485 } 486 else { 487 G4Exception("G4RunMessenger::ApplyNewCommand", "Run0901", FatalException, 488 "/run/pinAffinity command is issued to local thread."); 489 } 490 } 491 else if (command == evModCmd) { 492 G4RunManager::RMType rmType = runManager->GetRunManagerType(); 493 if (rmType == G4RunManager::masterRM) { 494 G4int nevMod = 0; 495 G4int sOnce = 0; 496 const auto nv = (const char*)newValue; 497 std::istringstream is(nv); 498 is >> nevMod >> sOnce; 499 static_cast<G4MTRunManager*>(runManager)->SetEventModulo(nevMod); 500 G4MTRunManager::SetSeedOncePerCommunication(sOnce); 501 } 502 else if (rmType == G4RunManager::sequentialRM) { 503 G4cout << "*** /run/eventModulo command is issued in sequential mode." 504 << "\nCommand is ignored." << G4endl; 505 } 506 else if (rmType == G4RunManager::subEventMasterRM) { 507 G4cout << "*** /run/eventModulo command is issued in sub-event parallel mode." 508 << "\nCommand is ignored." << G4endl; 509 } 510 else { 511 G4Exception("G4RunMessenger::ApplyNewCommand", "Run0902", FatalException, 512 "/run/eventModulo command is issued to worker thread."); 513 } 514 } 515 else if (command == dumpRegCmd) { 516 if (newValue == "**ALL**") { 517 runManager->DumpRegion(); 518 } 519 else { 520 runManager->DumpRegion(newValue); 521 } 522 } 523 else if (command == dumpCoupleCmd) { 524 G4ProductionCutsTable::GetProductionCutsTable()->DumpCouples(); 525 } 526 else if (command == optCmd) { 527 runManager->SetGeometryToBeOptimized(optCmd->GetNewBoolValue(newValue)); 528 } 529 else if (command == brkBoECmd) { 530 G4UImanager::GetUIpointer()->SetPauseAtBeginOfEvent(brkBoECmd->GetNewBoolValue(newValue)); 531 } 532 else if (command == brkEoECmd) { 533 G4UImanager::GetUIpointer()->SetPauseAtEndOfEvent(brkEoECmd->GetNewBoolValue(newValue)); 534 } 535 else if (command == abortCmd) { 536 runManager->AbortRun(abortCmd->GetNewBoolValue(newValue)); 537 } 538 else if (command == abortEventCmd) { 539 runManager->AbortEvent(); 540 } 541 else if (command == initCmd) { 542 runManager->Initialize(); 543 } 544 else if (command == geomCmd) { 545 runManager->GeometryHasBeenModified(false); 546 } 547 else if (command == geomRebCmd) { 548 runManager->ReinitializeGeometry(geomRebCmd->GetNewBoolValue(newValue), false); 549 } 550 else if (command == physCmd) { 551 runManager->PhysicsHasBeenModified(); 552 } 553 else if (command == seedCmd) { 554 G4Tokenizer next(newValue); 555 G4int idx = 0; 556 G4long seeds[100]; 557 G4String vl; 558 while (!(vl = next()).empty()) { 559 seeds[idx] = StoL(vl); 560 ++idx; 561 } 562 if (idx < 2) { 563 G4cerr << "/random/setSeeds should have at least two values. " 564 "Command ignored." 565 << G4endl; 566 } 567 else { 568 seeds[idx] = 0; 569 G4Random::setTheSeeds(seeds); 570 } 571 } 572 else if (command == randDirCmd) { 573 runManager->SetRandomNumberStoreDir(newValue); 574 } 575 else if (command == savingFlagCmd) { 576 runManager->SetRandomNumberStore(savingFlagCmd->GetNewBoolValue(newValue)); 577 } 578 else if (command == saveThisRunCmd) { 579 runManager->rndmSaveThisRun(); 580 } 581 else if (command == saveThisEventCmd) { 582 runManager->rndmSaveThisEvent(); 583 } 584 else if (command == restoreRandCmd) { 585 runManager->RestoreRandomNumberStatus(newValue); 586 } 587 else if (command == randEvtCmd) { 588 runManager->StoreRandomNumberStatusToG4Event(randEvtCmd->GetNewIntValue(newValue)); 589 } 590 else if (command == saveEachEventCmd) { 591 runManager->SetRandomNumberStorePerEvent(saveEachEventCmd->GetNewBoolValue(newValue)); 592 } 593 else if (command == constScoreCmd) { 594 runManager->ConstructScoringWorlds(); 595 } 596 else if (command == restoreRandCmdMT) { 597 runManager->RestoreRndmEachEvent(restoreRandCmdMT->GetNewBoolValue(newValue)); 598 } 599 else if (command == procUICmds) { 600 G4RunManager::RMType rmType = runManager->GetRunManagerType(); 601 if (rmType == G4RunManager::masterRM) { 602 auto rm = dynamic_cast<G4MTRunManager*>(runManager); 603 if (rm != nullptr) { 604 rm->RequestWorkersProcessCommandsStack(); 605 } 606 else { 607 G4Exception("G4RunManager::ApplyNewCommand", "Run0128", FatalException, 608 "/run/workersProcessCmds command issued on a " 609 "non-G4MTRunManager class instance."); 610 } 611 } 612 else if (rmType == G4RunManager::sequentialRM) { 613 G4cout << "*** /run/workersProcessCmds command is issued in sequential mode." 614 << "\nCommand is ignored." << G4endl; 615 } 616 else { 617 G4Exception("G4RunMessenger::ApplyNewCommand", "Run0129", FatalException, 618 "/run/workersProcessCmds command is issued to local thread."); 619 } 620 } 621 else if (command == trajMergeCmd) { 622 G4RunManager::RMType rmType = runManager->GetRunManagerType(); 623 if (rmType == G4RunManager::subEventMasterRM) { 624 auto rm = dynamic_cast<G4SubEvtRunManager*>(runManager); 625 if (rm != nullptr) { 626 rm->TrajectoriesToBeMerged(trajMergeCmd->GetNewBoolValue(newValue)); 627 } 628 else { 629 G4ExceptionDescription ed; 630 ed << "/run/trajectoriesToBeMerged command is issued on a RunManager class " 631 << "instance that is not G4SubEvtRunManager."; 632 G4Exception("G4RunManager::ApplyNewCommand", "Run0129", FatalException, ed); 633 } 634 } 635 else { 636 G4cout << "*** /run/trajectoriesToBeMerged command is issued on a RunManager " 637 << "class instance that is not G4SubEvtRunManager." 638 << "\nCommand is ignored." << G4endl; 639 } 640 } 641 } 642 643 // -------------------------------------------------------------------- 644 G4String G4RunMessenger::GetCurrentValue(G4UIcommand* command) 645 { 646 G4String cv; 647 648 if (command == verboseCmd) { 649 cv = verboseCmd->ConvertToString(runManager->GetVerboseLevel()); 650 } 651 else if (command == printProgCmd) { 652 cv = printProgCmd->ConvertToString(runManager->GetPrintProgress()); 653 } 654 else if (command == randDirCmd) { 655 cv = runManager->GetRandomNumberStoreDir(); 656 } 657 else if (command == randEvtCmd) { 658 cv = randEvtCmd->ConvertToString(runManager->GetFlagRandomNumberStatusToG4Event()); 659 } 660 else if (command == nThreadsCmd) { 661 G4RunManager::RMType rmType = runManager->GetRunManagerType(); 662 if (rmType == G4RunManager::masterRM) { 663 cv = nThreadsCmd->ConvertToString( 664 static_cast<G4MTRunManager*>(runManager)->GetNumberOfThreads()); 665 } 666 else if (rmType == G4RunManager::sequentialRM) { 667 cv = "0"; 668 } 669 } 670 else if (command == evModCmd) { 671 G4RunManager::RMType rmType = runManager->GetRunManagerType(); 672 if (rmType == G4RunManager::masterRM) { 673 cv = evModCmd->ConvertToString(static_cast<G4MTRunManager*>(runManager)->GetEventModulo()) 674 + " " + evModCmd->ConvertToString(G4MTRunManager::SeedOncePerCommunication()); 675 } 676 else if (rmType == G4RunManager::sequentialRM) { 677 G4cout << "*** /run/eventModulo command is valid only in MT mode." << G4endl; 678 } 679 } 680 681 return cv; 682 } 683