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