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