| 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 // 26 //
27 27
28 // /vis/ top level commands - John Allison 5t 28 // /vis/ top level commands - John Allison 5th February 2001
29 29
30 #include "G4VisCommands.hh" 30 #include "G4VisCommands.hh"
31 31
32 #include "G4VisManager.hh" 32 #include "G4VisManager.hh"
33 #include "G4UImanager.hh" 33 #include "G4UImanager.hh"
34 #include "G4UIcmdWithABool.hh" 34 #include "G4UIcmdWithABool.hh"
35 #include "G4UIcmdWithAString.hh" 35 #include "G4UIcmdWithAString.hh"
36 #include "G4UIcmdWithoutParameter.hh" 36 #include "G4UIcmdWithoutParameter.hh"
37 #include "G4RunManager.hh" 37 #include "G4RunManager.hh"
38 #include "G4RunManagerFactory.hh" << 38 #ifdef G4MULTITHREADED
>> 39 #include "G4MTRunManager.hh"
>> 40 #endif
39 #include "G4Run.hh" 41 #include "G4Run.hh"
40 #include "G4UIsession.hh" 42 #include "G4UIsession.hh"
41 #include "G4Trajectory.hh" 43 #include "G4Trajectory.hh"
42 #include "G4TrajectoryPoint.hh" 44 #include "G4TrajectoryPoint.hh"
43 #include "G4RichTrajectory.hh" 45 #include "G4RichTrajectory.hh"
44 #include "G4RichTrajectoryPoint.hh" 46 #include "G4RichTrajectoryPoint.hh"
45 #include "G4SmoothTrajectory.hh" 47 #include "G4SmoothTrajectory.hh"
46 #include "G4SmoothTrajectoryPoint.hh" 48 #include "G4SmoothTrajectoryPoint.hh"
47 #include "G4PhysicalVolumeModel.hh" 49 #include "G4PhysicalVolumeModel.hh"
48 #include "G4AttDef.hh" 50 #include "G4AttDef.hh"
49 51
50 #define G4warn G4cout <<
51 <<
52 ////////////// /vis/abortReviewKeptEvents //// 52 ////////////// /vis/abortReviewKeptEvents /////////////////////////////
53 53
54 G4VisCommandAbortReviewKeptEvents::G4VisComman 54 G4VisCommandAbortReviewKeptEvents::G4VisCommandAbortReviewKeptEvents () {
55 G4bool omitable; 55 G4bool omitable;
56 56
57 fpCommand = new G4UIcmdWithABool("/vis/abort 57 fpCommand = new G4UIcmdWithABool("/vis/abortReviewKeptEvents", this);
58 fpCommand -> SetGuidance("Abort review of ke 58 fpCommand -> SetGuidance("Abort review of kept events.");
59 fpCommand -> SetParameterName("abort", omita 59 fpCommand -> SetParameterName("abort", omitable=true);
60 fpCommand -> SetDefaultValue(true); 60 fpCommand -> SetDefaultValue(true);
61 } 61 }
62 62
63 G4VisCommandAbortReviewKeptEvents::~G4VisComma 63 G4VisCommandAbortReviewKeptEvents::~G4VisCommandAbortReviewKeptEvents () {
64 delete fpCommand; 64 delete fpCommand;
65 } 65 }
66 66
67 G4String G4VisCommandAbortReviewKeptEvents::Ge 67 G4String G4VisCommandAbortReviewKeptEvents::GetCurrentValue (G4UIcommand*) {
68 return G4String(); 68 return G4String();
69 } 69 }
70 70
71 void G4VisCommandAbortReviewKeptEvents::SetNew 71 void G4VisCommandAbortReviewKeptEvents::SetNewValue (G4UIcommand*,
72 72 G4String newValue) {
73 fpVisManager->SetAbortReviewKeptEvents(G4UIc 73 fpVisManager->SetAbortReviewKeptEvents(G4UIcommand::ConvertToBool(newValue));
74 G4warn << "Type \"continue\" to complete the << 74 G4cout << "Type \"continue\" to complete the abort." << G4endl;
75 } <<
76 <<
77 ////////////// /vis/abortReviewPlots ///////// <<
78 <<
79 G4VisCommandAbortReviewPlots::G4VisCommandAbor <<
80 G4bool omitable; <<
81 <<
82 fpCommand = new G4UIcmdWithABool("/vis/abort <<
83 fpCommand -> SetGuidance("Abort review of pl <<
84 fpCommand -> SetParameterName("abort", omita <<
85 fpCommand -> SetDefaultValue(true); <<
86 } <<
87 <<
88 G4VisCommandAbortReviewPlots::~G4VisCommandAbo <<
89 delete fpCommand; <<
90 } <<
91 <<
92 G4String G4VisCommandAbortReviewPlots::GetCurr <<
93 return G4String(); <<
94 } <<
95 <<
96 void G4VisCommandAbortReviewPlots::SetNewValue <<
97 <<
98 fpVisManager->SetAbortReviewPlots(G4UIcomman <<
99 G4warn << "Type \"continue\" to complete the <<
100 } 75 }
101 76
102 ////////////// /vis/drawOnlyToBeKeptEvents /// 77 ////////////// /vis/drawOnlyToBeKeptEvents /////////////////////////////
103 78
104 G4VisCommandDrawOnlyToBeKeptEvents::G4VisComma 79 G4VisCommandDrawOnlyToBeKeptEvents::G4VisCommandDrawOnlyToBeKeptEvents ()
105 { 80 {
106 G4bool omitable; 81 G4bool omitable;
107 82
108 fpCommand = new G4UIcmdWithABool("/vis/drawO 83 fpCommand = new G4UIcmdWithABool("/vis/drawOnlyToBeKeptEvents", this);
109 fpCommand -> SetGuidance 84 fpCommand -> SetGuidance
110 ("DURING A RUN draw only those events that h 85 ("DURING A RUN draw only those events that have been \"to be kept\" by the user"
111 "\nwith G4EventManager::GetEventManager()-> 86 "\nwith G4EventManager::GetEventManager()->KeepTheCurrentEvent() or"
112 "\nwith \"/event/keepCurrentEvent\"."); 87 "\nwith \"/event/keepCurrentEvent\".");
113 fpCommand -> SetGuidance( 88 fpCommand -> SetGuidance(
114 "To draw selected events the user should set 89 "To draw selected events the user should set this flag, then in a user action:"
115 "\n if ( some criterion ) {" 90 "\n if ( some criterion ) {"
116 "\n G4EventManager::GetEventManager()->Ke 91 "\n G4EventManager::GetEventManager()->KeepTheCurrentEvent();"
117 "\n }"); 92 "\n }");
118 fpCommand -> SetParameterName("draw", omitab 93 fpCommand -> SetParameterName("draw", omitable=true);
119 fpCommand -> SetDefaultValue(true); 94 fpCommand -> SetDefaultValue(true);
120 } 95 }
121 96
122 G4VisCommandDrawOnlyToBeKeptEvents::~G4VisComm 97 G4VisCommandDrawOnlyToBeKeptEvents::~G4VisCommandDrawOnlyToBeKeptEvents () {
123 delete fpCommand; 98 delete fpCommand;
124 } 99 }
125 100
126 G4String G4VisCommandDrawOnlyToBeKeptEvents::G 101 G4String G4VisCommandDrawOnlyToBeKeptEvents::GetCurrentValue (G4UIcommand*) {
127 return G4String(); 102 return G4String();
128 } 103 }
129 104
130 void G4VisCommandDrawOnlyToBeKeptEvents::SetNe 105 void G4VisCommandDrawOnlyToBeKeptEvents::SetNewValue (G4UIcommand*,
131 106 G4String newValue) {
132 fpVisManager->SetDrawEventOnlyIfToBeKept(G4U 107 fpVisManager->SetDrawEventOnlyIfToBeKept(G4UIcommand::ConvertToBool(newValue));
133 G4VisManager::Verbosity verbosity = fpVisMan 108 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
134 if (verbosity < G4VisManager::warnings) { 109 if (verbosity < G4VisManager::warnings) {
135 if (fpVisManager->GetDrawEventOnlyIfToBeKe 110 if (fpVisManager->GetDrawEventOnlyIfToBeKept()) {
136 G4warn << "Only events that have been ke << 111 G4cout << "Only events that have been kept will be drawn." << G4endl;
137 } else { 112 } else {
138 G4warn << "All events will be drawn." << << 113 G4cout << "All events will be drawn." << G4endl;
139 } 114 }
140 } 115 }
141 } 116 }
142 117
143 ////////////// /vis/enable /////////////////// 118 ////////////// /vis/enable ///////////////////////////////////////
144 119
145 G4VisCommandEnable::G4VisCommandEnable () { 120 G4VisCommandEnable::G4VisCommandEnable () {
146 G4bool omitable; 121 G4bool omitable;
147 122
148 fpCommand = new G4UIcmdWithABool("/vis/enabl 123 fpCommand = new G4UIcmdWithABool("/vis/enable", this);
149 fpCommand -> SetGuidance("Enables/disables v 124 fpCommand -> SetGuidance("Enables/disables visualization system.");
150 fpCommand -> SetParameterName("enabled", omi 125 fpCommand -> SetParameterName("enabled", omitable=true);
151 fpCommand -> SetDefaultValue(true); 126 fpCommand -> SetDefaultValue(true);
152 127
153 fpCommand1 = new G4UIcmdWithoutParameter("/v 128 fpCommand1 = new G4UIcmdWithoutParameter("/vis/disable", this);
154 fpCommand1 -> SetGuidance("Disables visualiz 129 fpCommand1 -> SetGuidance("Disables visualization system.");
155 } 130 }
156 131
157 G4VisCommandEnable::~G4VisCommandEnable () { 132 G4VisCommandEnable::~G4VisCommandEnable () {
158 delete fpCommand; 133 delete fpCommand;
159 delete fpCommand1; 134 delete fpCommand1;
160 } 135 }
161 136
162 G4String G4VisCommandEnable::GetCurrentValue ( 137 G4String G4VisCommandEnable::GetCurrentValue (G4UIcommand*) {
163 return G4String(); 138 return G4String();
164 } 139 }
165 140
166 void G4VisCommandEnable::SetNewValue (G4UIcomm 141 void G4VisCommandEnable::SetNewValue (G4UIcommand* command,
167 G4String newValue) { 142 G4String newValue) {
168 if (command == fpCommand) { 143 if (command == fpCommand) {
169 G4bool enable = G4UIcommand::ConvertToBool 144 G4bool enable = G4UIcommand::ConvertToBool(newValue);
170 if (enable) fpVisManager->Enable(); // Pr 145 if (enable) fpVisManager->Enable(); // Printing is in vis manager.
171 else fpVisManager->Disable(); // Pr 146 else fpVisManager->Disable(); // Printing is in vis manager.
172 } else fpVisManager->Disable(); // Pr 147 } else fpVisManager->Disable(); // Printing is in vis manager.
173 // Note: Printing is in vis manager. 148 // Note: Printing is in vis manager.
174 } 149 }
175 150
176 ////////////// /vis/initialize /////////////// 151 ////////////// /vis/initialize ///////////////////////////////////////
177 152
178 G4VisCommandInitialize::G4VisCommandInitialize 153 G4VisCommandInitialize::G4VisCommandInitialize ()
179 { 154 {
180 fpCommand = new G4UIcmdWithoutParameter("/vi 155 fpCommand = new G4UIcmdWithoutParameter("/vis/initialize", this);
181 fpCommand -> SetGuidance("Initialise visuali 156 fpCommand -> SetGuidance("Initialise visualisation manager.");
182 } 157 }
183 158
184 G4VisCommandInitialize::~G4VisCommandInitializ 159 G4VisCommandInitialize::~G4VisCommandInitialize () {
185 delete fpCommand; 160 delete fpCommand;
186 } 161 }
187 162
188 void G4VisCommandInitialize::SetNewValue (G4UI 163 void G4VisCommandInitialize::SetNewValue (G4UIcommand*,
189 G4String) { 164 G4String) {
190 fpVisManager->Initialize(); 165 fpVisManager->Initialize();
191 } 166 }
192 167
193 ////////////// /vis/list ///////////////////// 168 ////////////// /vis/list ///////////////////////////////////////
194 169
195 G4VisCommandList::G4VisCommandList () 170 G4VisCommandList::G4VisCommandList ()
196 { 171 {
197 G4bool omitable; 172 G4bool omitable;
198 173
199 fpCommand = new G4UIcmdWithAString("/vis/lis 174 fpCommand = new G4UIcmdWithAString("/vis/list", this);
200 fpCommand -> SetGuidance("Lists visualizatio 175 fpCommand -> SetGuidance("Lists visualization parameters.");
201 fpCommand -> SetParameterName("verbosity", o 176 fpCommand -> SetParameterName("verbosity", omitable=true);
202 fpCommand -> SetDefaultValue("warnings"); 177 fpCommand -> SetDefaultValue("warnings");
203 } 178 }
204 179
205 G4VisCommandList::~G4VisCommandList () 180 G4VisCommandList::~G4VisCommandList ()
206 { 181 {
207 delete fpCommand; 182 delete fpCommand;
208 } 183 }
209 184
210 G4String G4VisCommandList::GetCurrentValue (G4 185 G4String G4VisCommandList::GetCurrentValue (G4UIcommand*)
211 { 186 {
212 return ""; 187 return "";
213 } 188 }
214 189
215 void G4VisCommandList::SetNewValue (G4UIcomman 190 void G4VisCommandList::SetNewValue (G4UIcommand*, G4String newValue)
216 { 191 {
217 G4VisManager::Verbosity verbosity = fpVisMan << 192 G4String& verbosityString = newValue;
>> 193 G4VisManager::Verbosity verbosity =
>> 194 fpVisManager->GetVerbosityValue(verbosityString);
218 195
219 G4VisManager::PrintAvailableVerbosity(G4cout <<
220 G4cout << G4endl; <<
221 fpVisManager->PrintAvailableGraphicsSystems( 196 fpVisManager->PrintAvailableGraphicsSystems(verbosity);
222 G4cout << G4endl; 197 G4cout << G4endl;
223 fpVisManager->PrintAvailableModels(verbosity 198 fpVisManager->PrintAvailableModels(verbosity);
224 G4cout << G4endl; 199 G4cout << G4endl;
225 fpVisManager->PrintAvailableUserVisActions(v 200 fpVisManager->PrintAvailableUserVisActions(verbosity);
226 G4cout << G4endl; 201 G4cout << G4endl;
227 fpVisManager->PrintAvailableColours(verbosit 202 fpVisManager->PrintAvailableColours(verbosity);
228 G4cout << G4endl; 203 G4cout << G4endl;
229 G4UImanager* UImanager = G4UImanager::GetUIp 204 G4UImanager* UImanager = G4UImanager::GetUIpointer();
230 UImanager->ApplyCommand("/vis/scene/list ! " 205 UImanager->ApplyCommand("/vis/scene/list ! " + newValue);
231 G4cout << G4endl; <<
232 UImanager->ApplyCommand("/vis/viewer/list ! 206 UImanager->ApplyCommand("/vis/viewer/list ! " + newValue);
233 207
234 G4cout << 208 G4cout <<
235 "\nAttributes available for modeling and fil 209 "\nAttributes available for modeling and filtering with"
236 "\n \"/vis/modeling/trajectories/create/dra 210 "\n \"/vis/modeling/trajectories/create/drawByAttribute\" and"
237 "\n \"/vis/filtering/trajectories/create/at 211 "\n \"/vis/filtering/trajectories/create/attributeFilter\" commands"
238 "\nand by picking:" 212 "\nand by picking:"
239 << G4endl; 213 << G4endl;
240 G4cout 214 G4cout
241 << *G4TrajectoriesModel().GetAttDefs(); 215 << *G4TrajectoriesModel().GetAttDefs();
242 G4cout 216 G4cout
243 << *G4RichTrajectory().GetAttDefs() 217 << *G4RichTrajectory().GetAttDefs()
244 << *G4RichTrajectoryPoint().GetAttDefs(); 218 << *G4RichTrajectoryPoint().GetAttDefs();
245 G4cout 219 G4cout
246 << *G4SmoothTrajectory().GetAttDefs() 220 << *G4SmoothTrajectory().GetAttDefs()
247 << *G4SmoothTrajectoryPoint().GetAttDefs(); 221 << *G4SmoothTrajectoryPoint().GetAttDefs();
248 G4cout 222 G4cout
249 << *G4Trajectory().GetAttDefs() 223 << *G4Trajectory().GetAttDefs()
250 << *G4TrajectoryPoint().GetAttDefs(); 224 << *G4TrajectoryPoint().GetAttDefs();
251 225
252 G4cout << 226 G4cout <<
253 "\nGeometry attributes available for touchab 227 "\nGeometry attributes available for touchables by picking:\n";
254 G4cout 228 G4cout
255 << *G4PhysicalVolumeModel().GetAttDefs(); 229 << *G4PhysicalVolumeModel().GetAttDefs();
256 230
257 if (verbosity < G4VisManager::parameters) 231 if (verbosity < G4VisManager::parameters)
258 G4cout << 232 G4cout <<
259 "\nTo get more information, \"/vis/list all\ 233 "\nTo get more information, \"/vis/list all\" or use individual commands"
260 "\n such as (use \"ls\" or \"help\"):" 234 "\n such as (use \"ls\" or \"help\"):"
261 "\n /vis/scene/list all all" 235 "\n /vis/scene/list all all"
262 "\n /vis/viewer/list all all" 236 "\n /vis/viewer/list all all"
263 "\n /vis/modeling/trajectories/list" 237 "\n /vis/modeling/trajectories/list"
264 "\n /vis/filtering/trajectories/list" 238 "\n /vis/filtering/trajectories/list"
265 << G4endl; 239 << G4endl;
266 } 240 }
267 241
268 ////////////// /vis/reviewKeptEvents ///////// 242 ////////////// /vis/reviewKeptEvents ///////////////////////////////////////
269 243
270 G4VisCommandReviewKeptEvents::G4VisCommandRevi 244 G4VisCommandReviewKeptEvents::G4VisCommandReviewKeptEvents ()
271 { 245 {
272 G4bool omitable; 246 G4bool omitable;
273 247
274 fpCommand = new G4UIcmdWithAString("/vis/rev 248 fpCommand = new G4UIcmdWithAString("/vis/reviewKeptEvents", this);
275 fpCommand -> SetGuidance("Review kept events 249 fpCommand -> SetGuidance("Review kept events.");
276 fpCommand -> SetGuidance 250 fpCommand -> SetGuidance
277 ("If a macro file is specified, it is exec 251 ("If a macro file is specified, it is executed for each event.");
278 fpCommand -> SetGuidance( 252 fpCommand -> SetGuidance(
279 "If a macro file is not specified, each even 253 "If a macro file is not specified, each event is drawn to the current"
280 "\nviewer. After each event, the session is 254 "\nviewer. After each event, the session is paused. The user may issue"
281 "\nany allowed command. Then enter \"cont[i 255 "\nany allowed command. Then enter \"cont[inue]\" to continue to the next"
282 "\nevent." 256 "\nevent."
283 "\nUseful commands might be:" 257 "\nUseful commands might be:"
284 "\n \"/vis/viewer/...\" to change the view 258 "\n \"/vis/viewer/...\" to change the view (zoom, set/viewpoint,...)."
285 "\n \"/vis/ogl/export\" to get hard copy." << 259 "\n \"/vis/oglx/printEPS\" to get hard copy."
286 "\n \"/vis/open\" to get alternative viewer 260 "\n \"/vis/open\" to get alternative viewer."
287 "\n \"/vis/abortReviewKeptEvents\", then \" 261 "\n \"/vis/abortReviewKeptEvents\", then \"cont[inue]\", to abort.");
288 fpCommand -> SetParameterName("macro-file-na 262 fpCommand -> SetParameterName("macro-file-name", omitable=true);
289 fpCommand -> SetDefaultValue(""); 263 fpCommand -> SetDefaultValue("");
290 } 264 }
291 265
292 G4VisCommandReviewKeptEvents::~G4VisCommandRev 266 G4VisCommandReviewKeptEvents::~G4VisCommandReviewKeptEvents ()
293 { 267 {
294 delete fpCommand; 268 delete fpCommand;
295 } 269 }
296 270
297 G4String G4VisCommandReviewKeptEvents::GetCurr 271 G4String G4VisCommandReviewKeptEvents::GetCurrentValue (G4UIcommand*)
298 { 272 {
299 return ""; 273 return "";
300 } 274 }
301 275
302 void G4VisCommandReviewKeptEvents::SetNewValue 276 void G4VisCommandReviewKeptEvents::SetNewValue (G4UIcommand*, G4String newValue)
303 { 277 {
304 if (fpVisManager->GetReviewingKeptEvents()) 278 if (fpVisManager->GetReviewingKeptEvents()) {
305 G4warn << << 279 G4cout <<
306 "\"/vis/reviewKeptEvents\" not allowed w 280 "\"/vis/reviewKeptEvents\" not allowed within an already started review."
307 "\n No action taken." 281 "\n No action taken."
308 << G4endl; 282 << G4endl;
309 return; 283 return;
310 } 284 }
311 285
312 G4String& macroFileName = newValue; 286 G4String& macroFileName = newValue;
313 G4VisManager::Verbosity verbosity = fpVisMan 287 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
314 288
315 G4RunManager* runManager = G4RunManagerFacto << 289 G4RunManager* runManager = G4RunManager::GetRunManager();
316 const G4Run* run = runManager ? runM << 290 #ifdef G4MULTITHREADED
317 const std::vector<const G4Event*>* events = << 291 if(G4Threading::IsMultithreadedApplication())
318 run ? run->GetEventVector() : nullptr; << 292 { runManager = G4MTRunManager::GetMasterRunManager(); }
319 size_t nKeptEvents = events ? events->size() << 293 #endif
>> 294 const G4Run* run = runManager? runManager->GetCurrentRun(): 0;
>> 295 const std::vector<const G4Event*>* events = run? run->GetEventVector(): 0;
>> 296 size_t nKeptEvents = events? events->size(): 0;
320 297
321 if (!nKeptEvents) { 298 if (!nKeptEvents) {
322 if (verbosity >= G4VisManager::errors) { 299 if (verbosity >= G4VisManager::errors) {
323 G4warn << << 300 G4cerr <<
324 "ERROR: G4VisCommandReviewKeptEvents::SetNew 301 "ERROR: G4VisCommandReviewKeptEvents::SetNewValue: No kept events,"
325 "\n or kept events not accessible." 302 "\n or kept events not accessible."
326 << G4endl; 303 << G4endl;
327 } 304 }
328 return; 305 return;
329 } 306 }
330 307
331 G4VViewer* viewer = fpVisManager->GetCurrent 308 G4VViewer* viewer = fpVisManager->GetCurrentViewer();
332 if (!viewer) { 309 if (!viewer) {
333 if (verbosity >= G4VisManager::errors) { 310 if (verbosity >= G4VisManager::errors) {
334 G4warn << << 311 G4cerr <<
335 "ERROR: No current viewer - \"/vis/viewer/li 312 "ERROR: No current viewer - \"/vis/viewer/list\" to see possibilities."
336 << G4endl; 313 << G4endl;
337 } 314 }
338 return; 315 return;
339 } 316 }
340 317
341 G4Scene* pScene = fpVisManager->GetCurrentSc 318 G4Scene* pScene = fpVisManager->GetCurrentScene();
342 if (!pScene) { 319 if (!pScene) {
343 if (verbosity >= G4VisManager::errors) { 320 if (verbosity >= G4VisManager::errors) {
344 G4warn << "ERROR: No current scene. Ple << 321 G4cerr << "ERROR: No current scene. Please create one." << G4endl;
345 } 322 }
346 return; 323 return;
347 } 324 }
348 325
349 G4UImanager* UImanager = G4UImanager::GetUIp 326 G4UImanager* UImanager = G4UImanager::GetUIpointer();
350 G4int keepControlVerbose = UImanager->GetVer << 327 G4int keepVerbose = UImanager->GetVerboseLevel();
351 G4int newVerbose(0); 328 G4int newVerbose(0);
352 if (keepControlVerbose >= 2 || verbosity >= << 329 if (keepVerbose >= 2 || verbosity >= G4VisManager::confirmations)
353 newVerbose = 2; 330 newVerbose = 2;
354 UImanager->SetVerboseLevel(newVerbose); 331 UImanager->SetVerboseLevel(newVerbose);
355 332
356 G4VVisManager* keepConcreteInstance = fpVisM 333 G4VVisManager* keepConcreteInstance = fpVisManager->GetConcreteInstance();
357 fpVisManager->Enable(); 334 fpVisManager->Enable();
358 335
359 // Start on clean view 336 // Start on clean view
360 UImanager->ApplyCommand("/vis/viewer/rebuild 337 UImanager->ApplyCommand("/vis/viewer/rebuild");
361 338
362 // Event by event refreshing... 339 // Event by event refreshing...
363 fpVisManager->SetReviewingKeptEvents(true); 340 fpVisManager->SetReviewingKeptEvents(true);
364 G4bool currentRefreshAtEndOfEvent = pScene-> 341 G4bool currentRefreshAtEndOfEvent = pScene->GetRefreshAtEndOfEvent();
365 pScene->SetRefreshAtEndOfEvent(true); 342 pScene->SetRefreshAtEndOfEvent(true);
366 if (macroFileName.empty()) { 343 if (macroFileName.empty()) {
367 344
368 // Draw to viewer and pause session... 345 // Draw to viewer and pause session...
369 G4UIsession* session = UImanager->GetSessi 346 G4UIsession* session = UImanager->GetSession();
370 for (size_t i = 0; i < nKeptEvents; ++i) { 347 for (size_t i = 0; i < nKeptEvents; ++i) {
371 const G4Event* event = (*events)[i]; 348 const G4Event* event = (*events)[i];
372 if (verbosity >= G4VisManager::warnings) 349 if (verbosity >= G4VisManager::warnings) {
373 G4warn << "Drawing event : " << event->GetEv << 350 G4cout << "Drawing event : " << event->GetEventID() <<
374 ". At EndOfEvent, enter any command, then 351 ". At EndOfEvent, enter any command, then \"cont[inue]\"..."
375 << G4endl; 352 << G4endl;
376 static G4bool first = true; 353 static G4bool first = true;
377 if (first) { 354 if (first) {
378 first = false; 355 first = false;
379 G4warn << << 356 G4cout <<
380 " Useful commands might be:" 357 " Useful commands might be:"
381 "\n \"/vis/scene/add/trajectories\" if no 358 "\n \"/vis/scene/add/trajectories\" if not already added."
382 "\n \"/vis/viewer/...\" to change the vie 359 "\n \"/vis/viewer/...\" to change the view (zoom, set/viewpoint,...)."
383 "\n \"/vis/ogl/export\" to get hard copy. << 360 "\n \"/vis/oglx/printEPS\" to get hard copy."
384 "\n \"/vis/open\" to get alternative view 361 "\n \"/vis/open\" to get alternative viewer."
385 "\n \"/vis/abortReviewKeptEvents\", then 362 "\n \"/vis/abortReviewKeptEvents\", then \"cont[inue]\", to abort."
386 << G4endl; 363 << G4endl;
387 } 364 }
388 } 365 }
389 fpVisManager->SetRequestedEvent(event); 366 fpVisManager->SetRequestedEvent(event);
390 UImanager->ApplyCommand("/vis/viewer/reb 367 UImanager->ApplyCommand("/vis/viewer/rebuild");
391 /* The above command forces a rebuild of 368 /* The above command forces a rebuild of the scene, including
392 the detector. This is fine for "immediate" 369 the detector. This is fine for "immediate" viewers - a
393 refresh requires a rebuild anyway. But for 370 refresh requires a rebuild anyway. But for "stored mode"
394 viewers, you could, in principle, avoid a r 371 viewers, you could, in principle, avoid a rebuild of the
395 detector with something like the following: 372 detector with something like the following:
396 sceneHandler->ClearTransientStore(); 373 sceneHandler->ClearTransientStore();
397 viewer->DrawView(); 374 viewer->DrawView();
398 sceneHandler->DrawEvent(event); 375 sceneHandler->DrawEvent(event);
399 but this causes mayhem for "immediate 376 but this causes mayhem for "immediate" viewers because
400 ClearTransientStore issues a DrawView 377 ClearTransientStore issues a DrawView and some curious sort
401 of recursion takes place. For "store 378 of recursion takes place. For "stored" viewers, the event
402 gets drawn but not the eventID, so so 379 gets drawn but not the eventID, so something odd is happening
403 there too. This needs further invest 380 there too. This needs further investigation - enhanced
404 features or a complete re-think. 381 features or a complete re-think.
405 */ 382 */
406 UImanager->ApplyCommand("/vis/viewer/flu 383 UImanager->ApplyCommand("/vis/viewer/flush");
407 session->PauseSessionStart("EndOfEvent") 384 session->PauseSessionStart("EndOfEvent");
408 fpVisManager->SetRequestedEvent(0); 385 fpVisManager->SetRequestedEvent(0);
409 if (fpVisManager->GetAbortReviewKeptEven 386 if (fpVisManager->GetAbortReviewKeptEvents()) break;
410 } 387 }
411 fpVisManager->SetAbortReviewKeptEvents(fal 388 fpVisManager->SetAbortReviewKeptEvents(false);
412 389
413 } else { 390 } else {
414 391
415 // Execute macro file... 392 // Execute macro file...
416 for (size_t i = 0; i < nKeptEvents; ++i) { 393 for (size_t i = 0; i < nKeptEvents; ++i) {
417 const G4Event* event = (*events)[i]; 394 const G4Event* event = (*events)[i];
418 if (verbosity >= G4VisManager::warnings) 395 if (verbosity >= G4VisManager::warnings) {
419 G4warn << "Drawing event : " << event->GetEv << 396 G4cout << "Drawing event : " << event->GetEventID()
420 << " with macro file \"" << macroFile 397 << " with macro file \"" << macroFileName << G4endl;
421 } 398 }
422 fpVisManager->SetRequestedEvent(event); 399 fpVisManager->SetRequestedEvent(event);
423 UImanager->ApplyCommand("/control/execut 400 UImanager->ApplyCommand("/control/execute " + macroFileName);
424 fpVisManager->SetRequestedEvent(0); 401 fpVisManager->SetRequestedEvent(0);
425 } 402 }
426 } 403 }
427 pScene->SetRefreshAtEndOfEvent(currentRefres 404 pScene->SetRefreshAtEndOfEvent(currentRefreshAtEndOfEvent);
428 fpVisManager->SetReviewingKeptEvents(false); 405 fpVisManager->SetReviewingKeptEvents(false);
429 406
430 if (keepConcreteInstance) fpVisManager->Enab 407 if (keepConcreteInstance) fpVisManager->Enable();
431 else fpVisManager->Disable(); 408 else fpVisManager->Disable();
432 UImanager->SetVerboseLevel(keepControlVerbos << 409 UImanager->SetVerboseLevel(keepVerbose);
433 } <<
434 <<
435 ////////////// /vis/reviewPlots ////////////// <<
436 <<
437 G4VisCommandReviewPlots::G4VisCommandReviewPlo <<
438 { <<
439 fpCommand = new G4UIcmdWithoutParameter("/vi <<
440 fpCommand -> SetGuidance("Review plots."); <<
441 fpCommand -> SetGuidance <<
442 ("Each plot is drawn, one by one, to the cur <<
443 "\nplot the session is paused. The user ma <<
444 "\nThen enter \"cont[inue]\" to continue to <<
445 "\nUseful commands might be:" <<
446 "\n \"/vis/tsg/export\" to get hard copy." <<
447 "\n \"/vis/abortReviewPlots\", then \"cont <<
448 } <<
449 <<
450 G4VisCommandReviewPlots::~G4VisCommandReviewPl <<
451 { <<
452 delete fpCommand; <<
453 } <<
454 <<
455 G4String G4VisCommandReviewPlots::GetCurrentVa <<
456 { <<
457 return ""; <<
458 } <<
459 <<
460 #include <tools/histo/h1d> <<
461 #include <tools/histo/h2d> <<
462 <<
463 namespace { <<
464 template <typename HT> // tools::histo::h1d <<
465 G4bool ReviewPlots(const G4String& plotType) <<
466 auto visManager = G4VisManager::GetInstanc <<
467 auto ui = G4UImanager::GetUIpointer(); <<
468 auto session = ui->GetSession(); <<
469 G4bool aborting = false; <<
470 auto keepControlVerbose = ui->GetVerboseLe <<
471 ui->SetVerboseLevel(0); <<
472 auto status = ui->ApplyCommand("/analysis/ <<
473 ui->SetVerboseLevel(keepControlVerbose); <<
474 if(status==G4UIcommandStatus::fCommandSucc <<
475 G4String hexString = ui->GetCurrentValue <<
476 if(hexString.size()) { <<
477 void* ptr; <<
478 std::istringstream is(hexString); <<
479 is >> ptr; <<
480 auto _v = (const std::vector<HT*>*)ptr <<
481 auto _n = _v->size(); <<
482 for (size_t i = 0; i < _n; ++i) { <<
483 // Draw then pause session... <<
484 std::ostringstream oss; <<
485 oss << "/vis/plot " << plotType << ' <<
486 ui->ApplyCommand(oss.str()); <<
487 session->PauseSessionStart("EndOfEve <<
488 if (visManager->GetAbortReviewPlots( <<
489 aborting = true; <<
490 break; <<
491 } <<
492 } <<
493 } <<
494 } <<
495 return aborting; <<
496 } <<
497 } <<
498 <<
499 void G4VisCommandReviewPlots::SetNewValue (G4U <<
500 { <<
501 if (fpVisManager->GetReviewingPlots()) { <<
502 G4warn << <<
503 "\"/vis/reviewPlots\" not allowed within a <<
504 "\n No action taken." <<
505 << G4endl; <<
506 return; <<
507 } <<
508 <<
509 auto verbosity = fpVisManager->GetVerbosity( <<
510 <<
511 auto currentViewer = fpVisManager->GetCurren <<
512 if (!currentViewer) { <<
513 if (verbosity >= G4VisManager::errors) { <<
514 G4warn << <<
515 "ERROR: No current viewer - \"/vis/viewe <<
516 << G4endl; <<
517 } <<
518 return; <<
519 } <<
520 <<
521 if (currentViewer->GetName().find("TOOLSSG") <<
522 G4warn << <<
523 "WARNING: Current viewer not able to draw <<
524 "\n Try \"/vis/open TSG\", then \"/vis/re <<
525 << G4endl; <<
526 return; <<
527 } <<
528 <<
529 G4Scene* pScene = fpVisManager->GetCurrentSc <<
530 if (!pScene) { <<
531 if (verbosity >= G4VisManager::errors) { <<
532 G4warn << "ERROR: No current scene. Ple <<
533 } <<
534 return; <<
535 } <<
536 <<
537 auto ui = G4UImanager::GetUIpointer(); <<
538 <<
539 auto keepControlVerbose = ui->GetVerboseLeve <<
540 ui->SetVerboseLevel(0); <<
541 auto keepVisVerbose = fpVisManager->GetVerbo <<
542 fpVisManager->SetVerboseLevel(G4VisManager:: <<
543 auto keepEnable = fpVisManager->IsEnabled(); <<
544 fpVisManager->Enable(); <<
545 fpVisManager->SetReviewingPlots(true); <<
546 <<
547 if (ReviewPlots<tools::histo::h1d>("h1")) go <<
548 if (ReviewPlots<tools::histo::h2d>("h2")) go <<
549 <<
550 finish: <<
551 fpVisManager->SetReviewingPlots(false); <<
552 if (!keepEnable) fpVisManager->Disable(); <<
553 fpVisManager->SetVerboseLevel(keepVisVerbose <<
554 ui->SetVerboseLevel(keepControlVerbose); <<
555 } 410 }
556 411
557 ////////////// /vis/verbose ////////////////// 412 ////////////// /vis/verbose ///////////////////////////////////////
558 413
559 G4VisCommandVerbose::G4VisCommandVerbose () { 414 G4VisCommandVerbose::G4VisCommandVerbose () {
560 G4bool omitable; 415 G4bool omitable;
561 416
562 fpCommand = new G4UIcmdWithAString("/vis/ver 417 fpCommand = new G4UIcmdWithAString("/vis/verbose", this);
563 for (size_t i = 0; i < G4VisManager::Verbosi 418 for (size_t i = 0; i < G4VisManager::VerbosityGuidanceStrings.size(); ++i) {
564 fpCommand -> SetGuidance(G4VisManager::Ver 419 fpCommand -> SetGuidance(G4VisManager::VerbosityGuidanceStrings[i]);
565 } 420 }
566 fpCommand -> SetParameterName("verbosity", o 421 fpCommand -> SetParameterName("verbosity", omitable=true);
567 fpCommand -> SetDefaultValue(""); << 422 fpCommand -> SetDefaultValue("warnings");
568 } 423 }
569 424
570 G4VisCommandVerbose::~G4VisCommandVerbose () { 425 G4VisCommandVerbose::~G4VisCommandVerbose () {
571 delete fpCommand; 426 delete fpCommand;
572 } 427 }
573 428
574 G4String G4VisCommandVerbose::GetCurrentValue 429 G4String G4VisCommandVerbose::GetCurrentValue (G4UIcommand*) {
575 return G4String(); 430 return G4String();
576 } 431 }
577 432
578 void G4VisCommandVerbose::SetNewValue (G4UIcom 433 void G4VisCommandVerbose::SetNewValue (G4UIcommand*,
579 G4String newValue) { 434 G4String newValue) {
580 G4VisManager::Verbosity verbosity = 435 G4VisManager::Verbosity verbosity =
581 fpVisManager->GetVerbosityValue(newValue); 436 fpVisManager->GetVerbosityValue(newValue);
582 fpVisManager->SetVerboseLevel(verbosity); 437 fpVisManager->SetVerboseLevel(verbosity);
583 // Always prints whatever the verbosity... 438 // Always prints whatever the verbosity...
584 G4cout << "Visualization verbosity is now " << 439 G4cout << "Visualization verbosity changed to "
585 << G4VisManager::VerbosityString(verbosity) 440 << G4VisManager::VerbosityString(verbosity) << G4endl;
586 } 441 }
587 442