| 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 // $Id: G4VisCommandsCompound.cc 98766 2016-08-09 14:17:17Z gcosmo $
27 28
28 // Compound /vis/ commands - John Allison 15t 29 // Compound /vis/ commands - John Allison 15th May 2000
29 30
30 #include "G4VisCommandsCompound.hh" 31 #include "G4VisCommandsCompound.hh"
31 32
32 #include "G4VisManager.hh" 33 #include "G4VisManager.hh"
33 #include "G4UImanager.hh" 34 #include "G4UImanager.hh"
34 #include "G4UIcommandTree.hh" <<
35 #include "G4UIcmdWithAString.hh" 35 #include "G4UIcmdWithAString.hh"
36 36
37 #include <sstream> 37 #include <sstream>
38 #include <set> 38 #include <set>
39 39
40 #define G4warn G4cout <<
41 <<
42 ////////////// /vis/drawTree ///////////////// 40 ////////////// /vis/drawTree ///////////////////////////////////////
43 41
44 G4VisCommandDrawTree::G4VisCommandDrawTree() { 42 G4VisCommandDrawTree::G4VisCommandDrawTree() {
45 G4bool omitable; 43 G4bool omitable;
46 fpCommand = new G4UIcommand("/vis/drawTree", 44 fpCommand = new G4UIcommand("/vis/drawTree", this);
47 fpCommand->SetGuidance 45 fpCommand->SetGuidance
48 ("Produces a representation of the geometr << 46 ("(DTREE) Creates a scene consisting of this physical volume and"
49 "\nguidance is given on running the comma << 47 "\n produces a representation of the geometry hieracrhy.");
50 "\nfor \"/vis/ASCIITree/verbose\"."); << 48 fpCommand->SetGuidance("The scene becomes current.");
51 fpCommand->SetGuidance("The pre-existing sce <<
52 G4UIparameter* parameter; 49 G4UIparameter* parameter;
53 parameter = new G4UIparameter("physical-volu 50 parameter = new G4UIparameter("physical-volume-name", 's', omitable = true);
54 parameter -> SetDefaultValue("world"); 51 parameter -> SetDefaultValue("world");
55 fpCommand -> SetParameter (parameter); 52 fpCommand -> SetParameter (parameter);
56 parameter = new G4UIparameter("system", 's', 53 parameter = new G4UIparameter("system", 's', omitable = true);
57 parameter -> SetDefaultValue("ATree"); 54 parameter -> SetDefaultValue("ATree");
58 fpCommand -> SetParameter (parameter); 55 fpCommand -> SetParameter (parameter);
59 } 56 }
60 57
61 G4VisCommandDrawTree::~G4VisCommandDrawTree() 58 G4VisCommandDrawTree::~G4VisCommandDrawTree() {
62 delete fpCommand; 59 delete fpCommand;
63 } 60 }
64 61
65 void G4VisCommandDrawTree::SetNewValue(G4UIcom 62 void G4VisCommandDrawTree::SetNewValue(G4UIcommand*, G4String newValue) {
66 63
67 G4String pvname, system; 64 G4String pvname, system;
68 std::istringstream is(newValue); 65 std::istringstream is(newValue);
69 is >> pvname >> system; 66 is >> pvname >> system;
70 67
71 // Note: The second parameter, "system", is 68 // Note: The second parameter, "system", is intended to allow the user
72 // a choice of dedicated tree printing/displ 69 // a choice of dedicated tree printing/displaying systems but at present
73 // the only such dedicated system is ASCIITr 70 // the only such dedicated system is ASCIITree. It doesn't make sense to
74 // specify OGLSX, for example. So to avoid 71 // specify OGLSX, for example. So to avoid confusion we restrict this
75 // feature to systems that have "Tree" in th 72 // feature to systems that have "Tree" in the name or nickname.
76 73
77 // Of course, some other systems, such as OG 74 // Of course, some other systems, such as OGLSQt, have a tree browser
78 // built-in. The HepRApp offline browser al 75 // built-in. The HepRApp offline browser also has a tree browser
79 // built in. 76 // built in.
80 77
81 if (!G4StrUtil::contains(system, "Tree")) { << 78 if (!system.contains("Tree")) {
82 system = "ATree"; 79 system = "ATree";
83 } 80 }
84 81
85 G4VGraphicsSystem* keepSystem = fpVisManager 82 G4VGraphicsSystem* keepSystem = fpVisManager->GetCurrentGraphicsSystem();
86 G4Scene* keepScene = fpVisManager->GetCurren 83 G4Scene* keepScene = fpVisManager->GetCurrentScene();
87 G4VSceneHandler* keepSceneHandler = fpVisMan 84 G4VSceneHandler* keepSceneHandler = fpVisManager->GetCurrentSceneHandler();
88 G4VViewer* keepViewer = fpVisManager->GetCur 85 G4VViewer* keepViewer = fpVisManager->GetCurrentViewer();
89 G4VisManager::Verbosity keepVisVerbosity = f <<
90 G4bool keepAbleness = fpVisManager->GetConcr <<
91 86
92 G4UImanager* UImanager = G4UImanager::GetUIp 87 G4UImanager* UImanager = G4UImanager::GetUIpointer();
93 G4int keepUIVerbose = UImanager->GetVerboseL << 88 G4int keepVerbose = UImanager->GetVerboseLevel();
94 G4int newVerbose(0); 89 G4int newVerbose(0);
95 if (keepUIVerbose >= 2 || << 90 if (keepVerbose >= 2 ||
96 fpVisManager->GetVerbosity() >= G4VisMan 91 fpVisManager->GetVerbosity() >= G4VisManager::confirmations)
97 newVerbose = 2; 92 newVerbose = 2;
98 UImanager->SetVerboseLevel(newVerbose); 93 UImanager->SetVerboseLevel(newVerbose);
99 << 94 UImanager->ApplyCommand(G4String("/vis/open " + system));
100 auto errorCode = UImanager->ApplyCommand(G4S << 95 if (fErrorCode == 0) {
101 if (errorCode == 0) { <<
102 if (!keepAbleness) { // Enable temporaril <<
103 fpVisManager->SetVerboseLevel("Quiet"); <<
104 UImanager->ApplyCommand("/vis/enable"); <<
105 fpVisManager->SetVerboseLevel(keepVisVer <<
106 } <<
107 UImanager->ApplyCommand("/vis/viewer/reset <<
108 UImanager->ApplyCommand(G4String("/vis/dra 96 UImanager->ApplyCommand(G4String("/vis/drawVolume " + pvname));
109 UImanager->ApplyCommand("/vis/viewer/flush 97 UImanager->ApplyCommand("/vis/viewer/flush");
110 if (!keepAbleness) { // Disable again <<
111 fpVisManager->SetVerboseLevel("Quiet"); <<
112 UImanager->ApplyCommand("/vis/disable"); <<
113 fpVisManager->SetVerboseLevel(keepVisVer <<
114 } <<
115 if (keepViewer) { 98 if (keepViewer) {
116 if (fpVisManager->GetVerbosity() >= G4Vi 99 if (fpVisManager->GetVerbosity() >= G4VisManager::warnings) {
117 G4warn << "Reverting to " << keepViewe << 100 G4cout << "Reverting to " << keepViewer->GetName() << G4endl;
118 } 101 }
119 fpVisManager->SetCurrentGraphicsSystem(k 102 fpVisManager->SetCurrentGraphicsSystem(keepSystem);
120 fpVisManager->SetCurrentScene(keepScene) 103 fpVisManager->SetCurrentScene(keepScene);
121 fpVisManager->SetCurrentSceneHandler(kee 104 fpVisManager->SetCurrentSceneHandler(keepSceneHandler);
122 fpVisManager->SetCurrentViewer(keepViewe 105 fpVisManager->SetCurrentViewer(keepViewer);
123 } 106 }
124 } 107 }
125 UImanager->SetVerboseLevel(keepUIVerbose); << 108 UImanager->SetVerboseLevel(keepVerbose);
126 } 109 }
127 110
128 ////////////// /vis/drawView ///////////////// 111 ////////////// /vis/drawView ///////////////////////////////////////
129 112
130 G4VisCommandDrawView::G4VisCommandDrawView() { 113 G4VisCommandDrawView::G4VisCommandDrawView() {
131 G4bool omitable; 114 G4bool omitable;
132 fpCommand = new G4UIcommand("/vis/drawView", 115 fpCommand = new G4UIcommand("/vis/drawView", this);
133 fpCommand->SetGuidance 116 fpCommand->SetGuidance
134 ("Draw view from this angle, etc."); 117 ("Draw view from this angle, etc.");
135 G4UIparameter* parameter; 118 G4UIparameter* parameter;
136 parameter = new G4UIparameter("theta-degrees 119 parameter = new G4UIparameter("theta-degrees", 'd', omitable = true);
137 parameter -> SetDefaultValue(0.); 120 parameter -> SetDefaultValue(0.);
138 fpCommand -> SetParameter (parameter); 121 fpCommand -> SetParameter (parameter);
139 parameter = new G4UIparameter("phi-degrees", 122 parameter = new G4UIparameter("phi-degrees", 'd', omitable = true);
140 parameter -> SetDefaultValue(0.); 123 parameter -> SetDefaultValue(0.);
141 fpCommand -> SetParameter (parameter); 124 fpCommand -> SetParameter (parameter);
142 parameter = new G4UIparameter("pan-right", ' 125 parameter = new G4UIparameter("pan-right", 'd', omitable = true);
143 parameter -> SetDefaultValue(0.); 126 parameter -> SetDefaultValue(0.);
144 fpCommand -> SetParameter (parameter); 127 fpCommand -> SetParameter (parameter);
145 parameter = new G4UIparameter("pan-up", 'd', 128 parameter = new G4UIparameter("pan-up", 'd', omitable = true);
146 parameter -> SetDefaultValue(0.); 129 parameter -> SetDefaultValue(0.);
147 fpCommand -> SetParameter (parameter); 130 fpCommand -> SetParameter (parameter);
148 parameter = new G4UIparameter("pan-unit", 's 131 parameter = new G4UIparameter("pan-unit", 's', omitable = true);
149 parameter -> SetDefaultValue("cm"); 132 parameter -> SetDefaultValue("cm");
150 fpCommand -> SetParameter (parameter); 133 fpCommand -> SetParameter (parameter);
151 parameter = new G4UIparameter("zoom-factor", 134 parameter = new G4UIparameter("zoom-factor", 'd', omitable = true);
152 parameter -> SetDefaultValue(1.); 135 parameter -> SetDefaultValue(1.);
153 fpCommand -> SetParameter (parameter); 136 fpCommand -> SetParameter (parameter);
154 parameter = new G4UIparameter("dolly", 'd', 137 parameter = new G4UIparameter("dolly", 'd', omitable = true);
155 parameter -> SetDefaultValue(0.); 138 parameter -> SetDefaultValue(0.);
156 fpCommand -> SetParameter (parameter); 139 fpCommand -> SetParameter (parameter);
157 parameter = new G4UIparameter("dolly-unit", 140 parameter = new G4UIparameter("dolly-unit", 's', omitable = true);
158 parameter -> SetDefaultValue("cm"); 141 parameter -> SetDefaultValue("cm");
159 fpCommand -> SetParameter (parameter); 142 fpCommand -> SetParameter (parameter);
160 } 143 }
161 144
162 G4VisCommandDrawView::~G4VisCommandDrawView() 145 G4VisCommandDrawView::~G4VisCommandDrawView() {
163 delete fpCommand; 146 delete fpCommand;
164 } 147 }
165 148
166 void G4VisCommandDrawView::SetNewValue(G4UIcom 149 void G4VisCommandDrawView::SetNewValue(G4UIcommand*, G4String newValue) {
167 150
168 G4VisManager::Verbosity verbosity = fpVisMan 151 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
169 152
170 G4VViewer* currentViewer = fpVisManager->Get 153 G4VViewer* currentViewer = fpVisManager->GetCurrentViewer();
171 if (!currentViewer) { 154 if (!currentViewer) {
172 if (verbosity >= G4VisManager::warnings) { 155 if (verbosity >= G4VisManager::warnings) {
173 G4warn << << 156 G4cout <<
174 "WARNING: G4VisCommandsDrawView::SetNewValue 157 "WARNING: G4VisCommandsDrawView::SetNewValue: no current viewer."
175 << G4endl; 158 << G4endl;
176 } 159 }
177 return; 160 return;
178 } 161 }
179 162
180 G4String thetaDeg; 163 G4String thetaDeg;
181 G4String phiDeg; 164 G4String phiDeg;
182 G4String panRight; 165 G4String panRight;
183 G4String panUp; 166 G4String panUp;
184 G4String panUnit; 167 G4String panUnit;
185 G4String zoomFactor; 168 G4String zoomFactor;
186 G4String dolly; 169 G4String dolly;
187 G4String dollyUnit; 170 G4String dollyUnit;
188 std::istringstream is(newValue); 171 std::istringstream is(newValue);
189 is >> thetaDeg >> phiDeg >> panRight >> panU 172 is >> thetaDeg >> phiDeg >> panRight >> panUp >> panUnit
190 >> zoomFactor >> dolly >> dollyUnit; 173 >> zoomFactor >> dolly >> dollyUnit;
191 174
192 G4UImanager* UImanager = G4UImanager::GetUIp 175 G4UImanager* UImanager = G4UImanager::GetUIpointer();
>> 176 G4int keepVerbose = UImanager->GetVerboseLevel();
>> 177 G4int newVerbose(0);
>> 178 if (keepVerbose >= 2 ||
>> 179 fpVisManager->GetVerbosity() >= G4VisManager::confirmations)
>> 180 newVerbose = 2;
>> 181 UImanager->SetVerboseLevel(newVerbose);
193 G4ViewParameters vp = currentViewer->GetView 182 G4ViewParameters vp = currentViewer->GetViewParameters();
194 G4bool keepAutoRefresh = vp.IsAutoRefresh(); 183 G4bool keepAutoRefresh = vp.IsAutoRefresh();
195 vp.SetAutoRefresh(false); 184 vp.SetAutoRefresh(false);
196 currentViewer->SetViewParameters(vp); 185 currentViewer->SetViewParameters(vp);
197 UImanager->ApplyCommand( 186 UImanager->ApplyCommand(
198 G4String("/vis/viewer/set/viewpointThetaPh 187 G4String("/vis/viewer/set/viewpointThetaPhi " + thetaDeg + " " + phiDeg + " deg"));
199 UImanager->ApplyCommand( 188 UImanager->ApplyCommand(
200 G4String("/vis/viewer/panTo " + panRight + 189 G4String("/vis/viewer/panTo " + panRight + " " + panUp + " " + panUnit));
201 UImanager->ApplyCommand( 190 UImanager->ApplyCommand(
202 G4String("/vis/viewer/zoomTo " + zoomFacto 191 G4String("/vis/viewer/zoomTo " + zoomFactor));
203 vp = currentViewer->GetViewParameters(); 192 vp = currentViewer->GetViewParameters();
204 vp.SetAutoRefresh(keepAutoRefresh); 193 vp.SetAutoRefresh(keepAutoRefresh);
205 currentViewer->SetViewParameters(vp); 194 currentViewer->SetViewParameters(vp);
206 UImanager->ApplyCommand( 195 UImanager->ApplyCommand(
207 G4String("/vis/viewer/dollyTo " + dolly + 196 G4String("/vis/viewer/dollyTo " + dolly + " " + dollyUnit));
208 } << 197 UImanager->SetVerboseLevel(keepVerbose);
209 <<
210 ////////////// /vis/drawLogicalVolume //////// <<
211 <<
212 G4VisCommandDrawLogicalVolume::G4VisCommandDra <<
213 fpCommand = new G4UIcommand("/vis/drawLogica <<
214 fpCommand->SetGuidance <<
215 ("Draws logical volume with additional compo <<
216 fpCommand->SetGuidance <<
217 ("Synonymous with \"/vis/specify\"."); <<
218 fpCommand->SetGuidance <<
219 ("Creates a scene consisting of this logical <<
220 "\n current viewer to draw it. The scene b <<
221 const G4UIcommandTree* tree = G4UImanager::G <<
222 const G4UIcommand* addLogVolCmd = tree->Find <<
223 // Pick up guidance from /vis/scene/add/logi <<
224 CopyGuidanceFrom(addLogVolCmd,fpCommand); <<
225 // Pick up parameters from /vis/scene/add/lo <<
226 CopyParametersFrom(addLogVolCmd,fpCommand); <<
227 } <<
228 <<
229 G4VisCommandDrawLogicalVolume::~G4VisCommandDr <<
230 delete fpCommand; <<
231 } <<
232 <<
233 void G4VisCommandDrawLogicalVolume::SetNewValu <<
234 G4VisManager::Verbosity verbosity = fpVisMan <<
235 G4UImanager* UImanager = G4UImanager::GetUIp <<
236 G4VViewer* currentViewer = fpVisManager->Get <<
237 const G4ViewParameters& currentViewParams = <<
238 G4bool keepAutoRefresh = currentViewParams.I <<
239 if (keepAutoRefresh) UImanager->ApplyCommand <<
240 UImanager->ApplyCommand("/vis/scene/create") <<
241 UImanager->ApplyCommand(G4String("/vis/scene <<
242 UImanager->ApplyCommand("/vis/sceneHandler/a <<
243 G4ViewParameters::DrawingStyle keepDrawingSt <<
244 if(keepDrawingStyle != G4ViewParameters::wir <<
245 UImanager->ApplyCommand("/vis/viewer/set/s <<
246 G4bool keepMarkerNotHidden = currentViewPara <<
247 if (!keepMarkerNotHidden) UImanager->ApplyCo <<
248 if (keepAutoRefresh) UImanager->ApplyCommand <<
249 if (verbosity >= G4VisManager::warnings) { <<
250 if (keepDrawingStyle != currentViewParams. <<
251 G4warn <<
252 << "Drawing style changed to wireframe. <<
253 G4String style, edge; <<
254 switch (keepDrawingStyle) { <<
255 case G4ViewParameters::wireframe: <<
256 style = "wireframe"; edge = "false"; <<
257 case G4ViewParameters::hlr: <<
258 style = "wireframe"; edge = "true"; <<
259 case G4ViewParameters::hsr: <<
260 style = "surface"; edge = "false"; b <<
261 case G4ViewParameters::hlhsr: <<
262 style = "surface"; edge = "true"; br <<
263 case G4ViewParameters::cloud: <<
264 style = "cloud"; edge = ""; break; <<
265 } <<
266 G4warn << "\n /vis/viewer/set/style " + <<
267 if (!edge.empty()) G4warn << "\n /vis/v <<
268 G4warn << G4endl; <<
269 } <<
270 if (keepMarkerNotHidden != currentViewPara <<
271 G4warn <<
272 << "Markers changed to \"not hidden\". T <<
273 << "\n /vis/viewer/set/hiddenmarker tru <<
274 << G4endl; <<
275 } <<
276 } <<
277 static G4bool warned = false; <<
278 if (verbosity >= G4VisManager::confirmations <<
279 G4cout << <<
280 "NOTE: For systems which are not \"auto-re <<
281 "\n issue \"/vis/viewer/refresh\" or \"/v <<
282 << G4endl; <<
283 warned = true; <<
284 } <<
285 } 198 }
286 199
287 ////////////// /vis/drawVolume /////////////// 200 ////////////// /vis/drawVolume ///////////////////////////////////////
288 201
289 G4VisCommandDrawVolume::G4VisCommandDrawVolume 202 G4VisCommandDrawVolume::G4VisCommandDrawVolume() {
290 fpCommand = new G4UIcommand("/vis/drawVolume << 203 G4bool omitable;
>> 204 fpCommand = new G4UIcmdWithAString("/vis/drawVolume", this);
291 fpCommand->SetGuidance 205 fpCommand->SetGuidance
292 ("Creates a scene containing this physical v << 206 ("Creates a scene containing this physical volume and asks the"
293 "\ncurrent viewer to draw it. The scene be << 207 "\ncurrent viewer to draw it. The scene becomes current.");
294 const G4UIcommandTree* tree = G4UImanager::G << 208 fpCommand -> SetGuidance
295 const G4UIcommand* addVolCmd = tree->FindPat << 209 ("If physical-volume-name is \"world\" (the default), the main geometry"
296 // Pick up guidance from /vis/scene/add/volu << 210 "\ntree (material world) is drawn. If \"worlds\", all worlds - material"
297 CopyGuidanceFrom(addVolCmd,fpCommand); << 211 "\nworld and parallel worlds, if any - are drawn. Otherwise a search of"
298 // Pick up parameters from /vis/scene/add/vo << 212 "\nall worlds is made, taking the first matching occurence only. To see"
299 CopyParametersFrom(addVolCmd,fpCommand); << 213 "\na representation of the geometry hierarchy of the worlds, try"
>> 214 "\n\"/vis/drawTree worlds\" or one of the driver/browser combinations"
>> 215 "\nthat have the required functionality, e.g., HepRepFile/HepRApp.");
>> 216 fpCommand->SetParameterName("physical-volume-name", omitable = true);
>> 217 fpCommand->SetDefaultValue("world");
300 } 218 }
301 219
302 G4VisCommandDrawVolume::~G4VisCommandDrawVolum 220 G4VisCommandDrawVolume::~G4VisCommandDrawVolume() {
303 delete fpCommand; 221 delete fpCommand;
304 } 222 }
305 223
306 void G4VisCommandDrawVolume::SetNewValue(G4UIc 224 void G4VisCommandDrawVolume::SetNewValue(G4UIcommand*, G4String newValue) {
307 G4VisManager::Verbosity verbosity = fpVisMan 225 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
308 G4UImanager* UImanager = G4UImanager::GetUIp 226 G4UImanager* UImanager = G4UImanager::GetUIpointer();
>> 227 G4int keepVerbose = UImanager->GetVerboseLevel();
>> 228 G4int newVerbose(0);
>> 229 if (keepVerbose >= 2 || verbosity >= G4VisManager::confirmations)
>> 230 newVerbose = 2;
>> 231 UImanager->SetVerboseLevel(newVerbose);
309 UImanager->ApplyCommand("/vis/scene/create") 232 UImanager->ApplyCommand("/vis/scene/create");
310 UImanager->ApplyCommand(G4String("/vis/scene 233 UImanager->ApplyCommand(G4String("/vis/scene/add/volume " + newValue));
311 UImanager->ApplyCommand("/vis/sceneHandler/a 234 UImanager->ApplyCommand("/vis/sceneHandler/attach");
>> 235 UImanager->SetVerboseLevel(keepVerbose);
312 static G4bool warned = false; 236 static G4bool warned = false;
313 if (verbosity >= G4VisManager::confirmations 237 if (verbosity >= G4VisManager::confirmations && !warned) {
314 G4cout << 238 G4cout <<
315 "NOTE: For systems which are not \"auto- 239 "NOTE: For systems which are not \"auto-refresh\" you will need to"
316 "\n issue \"/vis/viewer/refresh\" or \" 240 "\n issue \"/vis/viewer/refresh\" or \"/vis/viewer/flush\"."
317 << G4endl; 241 << G4endl;
318 warned = true; 242 warned = true;
319 } 243 }
320 } 244 }
321 245
322 ////////////// /vis/open ///////////////////// 246 ////////////// /vis/open ///////////////////////////////////////
323 247
324 G4VisCommandOpen::G4VisCommandOpen() { 248 G4VisCommandOpen::G4VisCommandOpen() {
325 G4bool omitable; 249 G4bool omitable;
326 fpCommand = new G4UIcommand("/vis/open", thi 250 fpCommand = new G4UIcommand("/vis/open", this);
327 fpCommand->SetGuidance 251 fpCommand->SetGuidance
328 ("Creates a scene handler and viewer ready << 252 ("Creates a scene handler ready for drawing.");
329 fpCommand->SetGuidance 253 fpCommand->SetGuidance
330 ("The scene handler and viewer names are a << 254 ("The scene handler becomes current (the name is auto-generated).");
331 // Pick up guidance from /vis/viewer/create <<
332 const G4UIcommandTree* tree = G4UImanager::G <<
333 const G4UIcommand* viewerCreateCmd = tree->F <<
334 CopyGuidanceFrom(viewerCreateCmd,fpCommand,2 <<
335 G4UIparameter* parameter; 255 G4UIparameter* parameter;
336 parameter = new G4UIparameter("graphics-syst << 256 parameter = new G4UIparameter("graphics-system-name", 's', omitable = false);
337 parameter->SetCurrentAsDefault(true); <<
338 fpCommand->SetParameter(parameter); 257 fpCommand->SetParameter(parameter);
339 parameter = new G4UIparameter("window-size-h 258 parameter = new G4UIparameter("window-size-hint", 's', omitable = true);
340 parameter->SetGuidance 259 parameter->SetGuidance
341 ("integer (pixels) for square window place 260 ("integer (pixels) for square window placed by window manager or"
342 " X-Windows-type geometry string, e.g. 60 261 " X-Windows-type geometry string, e.g. 600x600-100+100");
343 parameter->SetCurrentAsDefault(true); << 262 parameter->SetDefaultValue("600");
344 fpCommand->SetParameter(parameter); 263 fpCommand->SetParameter(parameter);
345 } 264 }
346 265
347 G4VisCommandOpen::~G4VisCommandOpen() { 266 G4VisCommandOpen::~G4VisCommandOpen() {
348 delete fpCommand; 267 delete fpCommand;
349 } 268 }
350 269
351 G4String G4VisCommandOpen::GetCurrentValue(G4U << 270 void G4VisCommandOpen::SetNewValue (G4UIcommand*, G4String newValue) {
352 { <<
353 G4String graphicsSystemName, windowSizeHint; <<
354 auto graphicsSystem = fpVisManager->GetCurre <<
355 if (graphicsSystem) { <<
356 // Take name and hint from latest graphics <<
357 graphicsSystemName = graphicsSystem->GetNa <<
358 auto viewer = fpVisManager->GetCurrentView <<
359 if (viewer) { <<
360 windowSizeHint = viewer->GetViewParamete <<
361 } <<
362 else { // Viewer not yet created? <<
363 windowSizeHint = fpVisManager->GetDefaul <<
364 } <<
365 } <<
366 else { // No graphics system yet - must be <<
367 graphicsSystemName = fpVisManager->GetDefa <<
368 windowSizeHint = fpVisManager->GetDefaultX <<
369 } <<
370 return graphicsSystemName + ' ' + windowSize <<
371 } <<
372 <<
373 void G4VisCommandOpen::SetNewValue (G4UIcomman <<
374 { <<
375 G4String systemName, windowSizeHint; 271 G4String systemName, windowSizeHint;
376 std::istringstream is(newValue); 272 std::istringstream is(newValue);
377 is >> systemName >> windowSizeHint; 273 is >> systemName >> windowSizeHint;
378 G4UImanager* UImanager = G4UImanager::GetUIp 274 G4UImanager* UImanager = G4UImanager::GetUIpointer();
379 << 275 G4int keepVerbose = UImanager->GetVerboseLevel();
380 auto errorCode = UImanager->ApplyCommand(G4S << 276 G4int newVerbose(0);
381 if (errorCode) { << 277 if (keepVerbose >= 2 ||
382 G4warn << "sub-command \"/vis/sceneHandler << 278 fpVisManager->GetVerbosity() >= G4VisManager::confirmations)
383 goto finish; << 279 newVerbose = 2;
384 } << 280 UImanager->SetVerboseLevel(newVerbose);
385 << 281 fErrorCode = UImanager->ApplyCommand(G4String("/vis/sceneHandler/create " + systemName));
386 errorCode = UImanager->ApplyCommand(G4String << 282 if (fErrorCode == 0) {
387 if (errorCode) { << 283 UImanager->ApplyCommand(G4String("/vis/viewer/create ! ! " + windowSizeHint));
388 G4warn << "sub-command \"/vis/viewer/creat << 284 } else {
389 goto finish; << 285 // Use set to get alphabetical order
390 } << 286 std::set<G4String> candidates;
391 << 287 for (const auto gs: fpVisManager -> GetAvailableGraphicsSystems()) {
392 finish: << 288 // Just list nicknames, but exclude FALLBACK nicknames
393 if (errorCode) { << 289 for (const auto& nickname: gs->GetNicknames()) {
394 fpVisManager->PrintAvailableGraphicsSystem << 290 if (!nickname.contains("FALLBACK")) {
395 if (errorCode != JustWarning) { << 291 candidates.insert(nickname);
396 G4ExceptionDescription ed; << 292 }
397 ed << "Invoked command has failed - see << 293 }
398 command->CommandFailed(errorCode,ed); <<
399 } 294 }
>> 295 G4cerr << "Candidates are:";
>> 296 for (const auto& candidate: candidates) {
>> 297 G4cerr << ' ' << candidate;
>> 298 }
>> 299 G4cerr << G4endl;
400 } 300 }
401 } << 301 UImanager->SetVerboseLevel(keepVerbose);
402 <<
403 ////////////// /vis/plot ///////////////////// <<
404 <<
405 G4VisCommandPlot::G4VisCommandPlot () <<
406 { <<
407 G4bool omitable; <<
408 G4UIparameter* parameter; <<
409 <<
410 fpCommand = new G4UIcommand("/vis/plot", thi <<
411 fpCommand -> SetGuidance("Draws plots."); <<
412 parameter = new G4UIparameter ("type", 's', <<
413 parameter -> SetParameterCandidates("h1 h2") <<
414 fpCommand -> SetParameter (parameter); <<
415 parameter = new G4UIparameter ("id", 'i', om <<
416 fpCommand -> SetParameter (parameter); <<
417 #ifdef TOOLS_USE_FREETYPE <<
418 parameter = new G4UIparameter ("style", 's', <<
419 parameter -> SetParameterCandidates("none RO <<
420 parameter -> SetDefaultValue("ROOT_default") <<
421 fpCommand -> SetParameter (parameter); <<
422 #endif <<
423 } <<
424 <<
425 G4VisCommandPlot::~G4VisCommandPlot () <<
426 { <<
427 delete fpCommand; <<
428 } <<
429 <<
430 G4String G4VisCommandPlot::GetCurrentValue (G4 <<
431 { <<
432 return ""; <<
433 } <<
434 <<
435 void G4VisCommandPlot::SetNewValue (G4UIcomman <<
436 { <<
437 auto currentViewer = fpVisManager->GetCurren <<
438 if (currentViewer->GetName().find("TOOLSSG") <<
439 G4warn << <<
440 "WARNING: Current viewer not able to draw <<
441 "\n Try \"/vis/open TSG\", then \"/vis/pl <<
442 << G4endl; <<
443 return; <<
444 } <<
445 <<
446 std::istringstream is (newValue); <<
447 G4String type, id; <<
448 is >> type >> id; <<
449 #ifdef TOOLS_USE_FREETYPE <<
450 G4String style; <<
451 is >> style; <<
452 #endif <<
453 <<
454 auto keepEnable = fpVisManager->IsEnabled(); <<
455 <<
456 auto ui = G4UImanager::GetUIpointer(); <<
457 ui->ApplyCommand("/vis/enable"); <<
458 ui->ApplyCommand("/vis/viewer/resetCameraPar <<
459 ui->ApplyCommand("/vis/scene/create"); <<
460 ui->ApplyCommand("/vis/scene/endOfEventActio <<
461 static G4int plotterID = 0; <<
462 std::ostringstream ossPlotter; <<
463 ossPlotter << "plotter-" << plotterID++; <<
464 const G4String& plotterName = ossPlotter.str <<
465 ui->ApplyCommand("/vis/plotter/create " + pl <<
466 ui->ApplyCommand("/vis/scene/add/plotter " + <<
467 ui->ApplyCommand("/vis/plotter/add/" + type <<
468 #ifdef TOOLS_USE_FREETYPE <<
469 if (style != "none") { <<
470 ui->ApplyCommand("/vis/plotter/addStyle " <<
471 } <<
472 #endif <<
473 ui->ApplyCommand("/vis/sceneHandler/attach") <<
474 <<
475 if (!keepEnable) { <<
476 fpVisManager->Disable(); <<
477 G4warn << <<
478 "WARNING: drawing was enabled for plotting <<
479 << G4endl; <<
480 } <<
481 } 302 }
482 303
483 ////////////// /vis/specify ////////////////// 304 ////////////// /vis/specify ///////////////////////////////////////
484 305
485 G4VisCommandSpecify::G4VisCommandSpecify() { 306 G4VisCommandSpecify::G4VisCommandSpecify() {
486 G4bool omitable; 307 G4bool omitable;
487 fpCommand = new G4UIcommand("/vis/specify", 308 fpCommand = new G4UIcommand("/vis/specify", this);
488 fpCommand->SetGuidance 309 fpCommand->SetGuidance
489 ("Draws logical volume with Boolean compon 310 ("Draws logical volume with Boolean components, voxels and readout geometry.");
490 fpCommand->SetGuidance 311 fpCommand->SetGuidance
491 ("Synonymous with \"/vis/drawLogicalVolume <<
492 fpCommand->SetGuidance <<
493 ("Creates a scene consisting of this logic 312 ("Creates a scene consisting of this logical volume and asks the"
494 "\n current viewer to draw it to the spe 313 "\n current viewer to draw it to the specified depth of descent"
495 "\n showing boolean components (if any), 314 "\n showing boolean components (if any), voxels (if any),"
496 "\n readout geometry (if any), local axe << 315 "\n readout geometry (if any) and local axes, under control of the"
497 "\n under control of the appropriate fla << 316 "\n appropriate flag.");
498 fpCommand->SetGuidance 317 fpCommand->SetGuidance
499 ("Note: voxels are not constructed until sta 318 ("Note: voxels are not constructed until start of run - /run/beamOn."
500 "\n (For voxels without a run, \"/run/beam 319 "\n (For voxels without a run, \"/run/beamOn 0\".)");
501 fpCommand->SetGuidance("The scene becomes cu 320 fpCommand->SetGuidance("The scene becomes current.");
502 G4UIparameter* parameter; 321 G4UIparameter* parameter;
503 parameter = new G4UIparameter("logical-volum 322 parameter = new G4UIparameter("logical-volume-name", 's', omitable = false);
504 fpCommand->SetParameter(parameter); 323 fpCommand->SetParameter(parameter);
505 parameter = new G4UIparameter("depth-of-desc 324 parameter = new G4UIparameter("depth-of-descent", 'i', omitable = true);
506 parameter->SetDefaultValue(1); 325 parameter->SetDefaultValue(1);
507 fpCommand->SetParameter(parameter); 326 fpCommand->SetParameter(parameter);
508 parameter = new G4UIparameter("booleans-flag 327 parameter = new G4UIparameter("booleans-flag", 'b', omitable = true);
509 parameter->SetDefaultValue(true); 328 parameter->SetDefaultValue(true);
510 fpCommand->SetParameter(parameter); 329 fpCommand->SetParameter(parameter);
511 parameter = new G4UIparameter("voxels-flag", 330 parameter = new G4UIparameter("voxels-flag", 'b', omitable = true);
512 parameter->SetDefaultValue(true); 331 parameter->SetDefaultValue(true);
513 fpCommand->SetParameter(parameter); 332 fpCommand->SetParameter(parameter);
514 parameter = new G4UIparameter("readout-flag" 333 parameter = new G4UIparameter("readout-flag", 'b', omitable = true);
515 parameter->SetDefaultValue(true); 334 parameter->SetDefaultValue(true);
516 fpCommand->SetParameter(parameter); 335 fpCommand->SetParameter(parameter);
517 parameter = new G4UIparameter("axes-flag", ' 336 parameter = new G4UIparameter("axes-flag", 'b', omitable = true);
518 parameter->SetDefaultValue(true); 337 parameter->SetDefaultValue(true);
519 parameter -> SetGuidance ("Set \"false\" to 338 parameter -> SetGuidance ("Set \"false\" to suppress axes.");
520 fpCommand->SetParameter(parameter); 339 fpCommand->SetParameter(parameter);
521 parameter = new G4UIparameter("check-overlap <<
522 parameter->SetDefaultValue(true); <<
523 parameter -> SetGuidance ("Set \"false\" to <<
524 fpCommand->SetParameter(parameter); <<
525 } 340 }
526 341
527 G4VisCommandSpecify::~G4VisCommandSpecify() { 342 G4VisCommandSpecify::~G4VisCommandSpecify() {
528 delete fpCommand; 343 delete fpCommand;
529 } 344 }
530 345
531 void G4VisCommandSpecify::SetNewValue(G4UIcomm 346 void G4VisCommandSpecify::SetNewValue(G4UIcommand*, G4String newValue) {
532 G4VisManager::Verbosity verbosity = fpVisMan 347 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
533 G4UImanager* UImanager = G4UImanager::GetUIp 348 G4UImanager* UImanager = G4UImanager::GetUIpointer();
>> 349 G4int keepVerbose = UImanager->GetVerboseLevel();
>> 350 G4int newVerbose(0);
>> 351 if (keepVerbose >= 2 || verbosity >= G4VisManager::confirmations)
>> 352 newVerbose = 2;
>> 353 UImanager->SetVerboseLevel(newVerbose);
534 // UImanager->ApplyCommand(G4String("/geomet 354 // UImanager->ApplyCommand(G4String("/geometry/print " + newValue));
535 UImanager->ApplyCommand("/vis/scene/create") 355 UImanager->ApplyCommand("/vis/scene/create");
536 UImanager->ApplyCommand(G4String("/vis/scene 356 UImanager->ApplyCommand(G4String("/vis/scene/add/logicalVolume " + newValue));
537 UImanager->ApplyCommand("/vis/sceneHandler/a 357 UImanager->ApplyCommand("/vis/sceneHandler/attach");
>> 358 UImanager->SetVerboseLevel(keepVerbose);
538 static G4bool warned = false; 359 static G4bool warned = false;
539 if (verbosity >= G4VisManager::confirmations 360 if (verbosity >= G4VisManager::confirmations && !warned) {
540 G4cout << 361 G4cout <<
541 "NOTE: For systems which are not \"auto- 362 "NOTE: For systems which are not \"auto-refresh\" you will need to"
542 "\n issue \"/vis/viewer/refresh\" or \" 363 "\n issue \"/vis/viewer/refresh\" or \"/vis/viewer/flush\"."
543 << G4endl; 364 << G4endl;
544 warned = true; 365 warned = true;
545 } 366 }
546 } 367 }
547 368