| 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: G4VisCommands.cc,v 1.24 2009-03-09 12:42:00 allison Exp $
27 28
28 // /vis/set - John Allison 21st March 2012 29 // /vis/set - John Allison 21st March 2012
29 // Set quantities for use in appropriate futur 30 // Set quantities for use in appropriate future commands.
30 31
31 #include "G4VisCommandsSet.hh" 32 #include "G4VisCommandsSet.hh"
32 33
33 #include "G4UIcommand.hh" 34 #include "G4UIcommand.hh"
34 #include "G4UIcmdWithAnInteger.hh" 35 #include "G4UIcmdWithAnInteger.hh"
35 #include "G4UIcmdWithADouble.hh" 36 #include "G4UIcmdWithADouble.hh"
36 #include "G4UIcmdWithAString.hh" 37 #include "G4UIcmdWithAString.hh"
37 #include "G4UIcmdWithABool.hh" <<
38 #include "G4TouchablePropertiesScene.hh" <<
39 #include "G4TransportationManager.hh" <<
40 #include "G4BoundingExtentScene.hh" <<
41 <<
42 #include <sstream> 38 #include <sstream>
43 #include <utility> <<
44 <<
45 #define G4warn G4cout <<
46 39
47 ////////////// /vis/set/arrow3DLineSegmentsPer 40 ////////////// /vis/set/arrow3DLineSegmentsPerCircle ////////////////////////////////////
48 41
49 G4VisCommandSetArrow3DLineSegmentsPerCircle::G 42 G4VisCommandSetArrow3DLineSegmentsPerCircle::G4VisCommandSetArrow3DLineSegmentsPerCircle ()
50 { 43 {
51 G4bool omitable; 44 G4bool omitable;
52 fpCommand = new G4UIcmdWithAnInteger("/vis/s 45 fpCommand = new G4UIcmdWithAnInteger("/vis/set/arrow3DLineSegmentsPerCircle", this);
53 fpCommand->SetGuidance 46 fpCommand->SetGuidance
54 ("Defines number of line segments per circle 47 ("Defines number of line segments per circle for drawing 3D arrows"
55 " for future \"/vis/scene/add/\" commands." 48 " for future \"/vis/scene/add/\" commands.");
56 fpCommand->SetParameterName ("number", omita 49 fpCommand->SetParameterName ("number", omitable = true);
57 fpCommand->SetDefaultValue (6); 50 fpCommand->SetDefaultValue (6);
58 fpCommand->SetRange("number >= 3"); 51 fpCommand->SetRange("number >= 3");
59 } 52 }
60 53
61 G4VisCommandSetArrow3DLineSegmentsPerCircle::~ 54 G4VisCommandSetArrow3DLineSegmentsPerCircle::~G4VisCommandSetArrow3DLineSegmentsPerCircle ()
62 { 55 {
63 delete fpCommand; 56 delete fpCommand;
64 } 57 }
65 58
66 G4String G4VisCommandSetArrow3DLineSegmentsPer 59 G4String G4VisCommandSetArrow3DLineSegmentsPerCircle::GetCurrentValue (G4UIcommand*)
67 { 60 {
68 return G4String(); 61 return G4String();
69 } 62 }
70 63
71 void G4VisCommandSetArrow3DLineSegmentsPerCirc 64 void G4VisCommandSetArrow3DLineSegmentsPerCircle::SetNewValue (G4UIcommand*, G4String newValue)
72 { 65 {
73 G4VisManager::Verbosity verbosity = fpVisMan 66 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
74 67
75 fCurrentArrow3DLineSegmentsPerCircle = fpCom 68 fCurrentArrow3DLineSegmentsPerCircle = fpCommand->GetNewIntValue(newValue);
76 69
77 if (verbosity >= G4VisManager::confirmations 70 if (verbosity >= G4VisManager::confirmations) {
78 G4cout << 71 G4cout <<
79 "Number of line segments per circle for dr 72 "Number of line segments per circle for drawing 3D arrows for future"
80 "\n \"/vis/scene/add/\" commands has been 73 "\n \"/vis/scene/add/\" commands has been set to "
81 << fCurrentArrow3DLineSegmentsPerCircle 74 << fCurrentArrow3DLineSegmentsPerCircle
82 << G4endl; 75 << G4endl;
83 } 76 }
84 } 77 }
85 78
86 ////////////// /vis/set/colour /////////////// 79 ////////////// /vis/set/colour ////////////////////////////////////
87 80
88 G4VisCommandSetColour::G4VisCommandSetColour ( 81 G4VisCommandSetColour::G4VisCommandSetColour ()
89 { 82 {
90 G4bool omitable; 83 G4bool omitable;
91 fpCommand = new G4UIcommand("/vis/set/colour 84 fpCommand = new G4UIcommand("/vis/set/colour", this);
92 fpCommand->SetGuidance 85 fpCommand->SetGuidance
93 ("Defines colour and opacity for future \"/v << 86 ("Defines colour and opacity for future \"/vis/scene/add/\" commands.");
94 fpCommand->SetGuidance 87 fpCommand->SetGuidance
95 ("(Except \"/vis/scene/add/text\" commands - << 88 ("(Except \"/vis/scene/add/text\" commands - see \"/vis/set/textColour\".)");
96 fpCommand->SetGuidance(ConvertToColourGuidan 89 fpCommand->SetGuidance(ConvertToColourGuidance());
97 fpCommand->SetGuidance("Default: white and o 90 fpCommand->SetGuidance("Default: white and opaque.");
98 G4UIparameter* parameter; 91 G4UIparameter* parameter;
99 parameter = new G4UIparameter ("red", 's', o 92 parameter = new G4UIparameter ("red", 's', omitable = true);
100 parameter->SetGuidance 93 parameter->SetGuidance
101 ("Red component or a string, e.g., \"cyan\" << 94 ("Red component or a string, e.g., \"cyan\" (green and blue parameters are ignored).");
102 parameter->SetDefaultValue ("1."); 95 parameter->SetDefaultValue ("1.");
103 fpCommand->SetParameter (parameter); 96 fpCommand->SetParameter (parameter);
104 parameter = new G4UIparameter ("green", 'd', 97 parameter = new G4UIparameter ("green", 'd', omitable = true);
105 parameter->SetDefaultValue (1.); 98 parameter->SetDefaultValue (1.);
106 fpCommand->SetParameter (parameter); 99 fpCommand->SetParameter (parameter);
107 parameter = new G4UIparameter ("blue", 'd', 100 parameter = new G4UIparameter ("blue", 'd', omitable = true);
108 parameter->SetDefaultValue (1.); 101 parameter->SetDefaultValue (1.);
109 fpCommand->SetParameter (parameter); 102 fpCommand->SetParameter (parameter);
110 parameter = new G4UIparameter ("alpha", 'd', 103 parameter = new G4UIparameter ("alpha", 'd', omitable = true);
111 parameter->SetDefaultValue (1.); 104 parameter->SetDefaultValue (1.);
112 parameter->SetGuidance ("Opacity"); 105 parameter->SetGuidance ("Opacity");
113 fpCommand->SetParameter (parameter); 106 fpCommand->SetParameter (parameter);
114 } 107 }
115 108
116 G4VisCommandSetColour::~G4VisCommandSetColour 109 G4VisCommandSetColour::~G4VisCommandSetColour ()
117 { 110 {
118 delete fpCommand; 111 delete fpCommand;
119 } 112 }
120 113
121 G4String G4VisCommandSetColour::GetCurrentValu 114 G4String G4VisCommandSetColour::GetCurrentValue (G4UIcommand*)
122 { 115 {
123 return G4String(); 116 return G4String();
124 } 117 }
125 118
126 void G4VisCommandSetColour::SetNewValue (G4UIc 119 void G4VisCommandSetColour::SetNewValue (G4UIcommand*, G4String newValue)
127 { 120 {
128 G4VisManager::Verbosity verbosity = fpVisMan 121 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
129 122
130 G4String redOrString; 123 G4String redOrString;
131 G4double green, blue, opacity; 124 G4double green, blue, opacity;
132 std::istringstream iss(newValue); 125 std::istringstream iss(newValue);
133 iss >> redOrString >> green >> blue >> opaci 126 iss >> redOrString >> green >> blue >> opacity;
134 127
135 ConvertToColour(fCurrentColour, redOrString, 128 ConvertToColour(fCurrentColour, redOrString, green, blue, opacity);
136 129
137 if (verbosity >= G4VisManager::confirmations 130 if (verbosity >= G4VisManager::confirmations) {
138 G4cout << 131 G4cout <<
139 "Colour for future \"/vis/scene/add/\" com << 132 "Colour for future \"/vis/scene/add/\" commands has been set to "
140 << fCurrentColour << << 133 << fCurrentColour <<
141 ".\n(Except \"/vis/scene/add/text\" comman << 134 ".\n(Except \"/vis/scene/add/text\" commands - use \"/vis/set/textColour\".)"
142 << G4endl; << 135 << G4endl;
143 } <<
144 } <<
145 <<
146 ////////////// /vis/set/extentForField /////// <<
147 <<
148 G4VisCommandSetExtentForField::G4VisCommandSet <<
149 { <<
150 G4bool omitable; <<
151 fpCommand = new G4UIcommand("/vis/set/extent <<
152 fpCommand->SetGuidance <<
153 ("Sets an extent for future \"/vis/scene/add <<
154 fpCommand->SetGuidance <<
155 ("The default is a null extent, which is int <<
156 "\nextent of the whole scene."); <<
157 G4UIparameter* parameter; <<
158 parameter = new G4UIparameter ("xmin", 'd', <<
159 fpCommand->SetParameter (parameter); <<
160 parameter = new G4UIparameter ("xmax", 'd', <<
161 fpCommand->SetParameter (parameter); <<
162 parameter = new G4UIparameter ("ymin", 'd', <<
163 fpCommand->SetParameter (parameter); <<
164 parameter = new G4UIparameter ("ymax", 'd', <<
165 fpCommand->SetParameter (parameter); <<
166 parameter = new G4UIparameter ("zmin", 'd', <<
167 fpCommand->SetParameter (parameter); <<
168 parameter = new G4UIparameter ("zmax", 'd', <<
169 fpCommand->SetParameter (parameter); <<
170 parameter = new G4UIparameter ("unit", 's', <<
171 fpCommand->SetParameter (parameter); <<
172 } <<
173 <<
174 G4VisCommandSetExtentForField::~G4VisCommandSe <<
175 { <<
176 delete fpCommand; <<
177 } <<
178 <<
179 G4String G4VisCommandSetExtentForField::GetCur <<
180 { <<
181 return G4String(); <<
182 } <<
183 <<
184 void G4VisCommandSetExtentForField::SetNewValu <<
185 { <<
186 G4VisManager::Verbosity verbosity = fpVisMan <<
187 <<
188 G4double xmin, xmax, ymin, ymax, zmin, zmax; <<
189 G4String unitString; <<
190 std::istringstream iss(newValue); <<
191 iss >> xmin >> xmax >> ymin >> ymax >> zmin <<
192 G4double unit = G4UIcommand::ValueOf(unitStr <<
193 xmin *= unit; xmax *= unit; <<
194 ymin *= unit; ymax *= unit; <<
195 zmin *= unit; zmax *= unit; <<
196 <<
197 fCurrentExtentForField = G4VisExtent(xmin,xm <<
198 fCurrrentPVFindingsForField.clear(); <<
199 <<
200 if (verbosity >= G4VisManager::confirmations <<
201 G4cout << <<
202 "Extent for future \"/vis/scene/add/*Field <<
203 << fCurrentExtentForField <<
204 << "\nVolume for field has been cleared." <<
205 << G4endl; <<
206 } 136 }
207 } 137 }
208 138
209 ////////////// /vis/set/lineWidth //////////// 139 ////////////// /vis/set/lineWidth ////////////////////////////////////
210 140
211 G4VisCommandSetLineWidth::G4VisCommandSetLineW 141 G4VisCommandSetLineWidth::G4VisCommandSetLineWidth ()
212 { 142 {
213 G4bool omitable; 143 G4bool omitable;
214 fpCommand = new G4UIcmdWithADouble("/vis/set 144 fpCommand = new G4UIcmdWithADouble("/vis/set/lineWidth", this);
215 fpCommand->SetGuidance 145 fpCommand->SetGuidance
216 ("Defines line width for future \"/vis/scene << 146 ("Defines line width for future \"/vis/scene/add/\" commands.");
217 "\nSee \"/vis/viewer/set/lineWidth\" for mo <<
218 fpCommand->SetParameterName ("lineWidth", om 147 fpCommand->SetParameterName ("lineWidth", omitable = true);
219 fpCommand->SetDefaultValue (1.); 148 fpCommand->SetDefaultValue (1.);
220 fpCommand->SetRange("lineWidth >= 1."); 149 fpCommand->SetRange("lineWidth >= 1.");
221 } 150 }
222 151
223 G4VisCommandSetLineWidth::~G4VisCommandSetLine 152 G4VisCommandSetLineWidth::~G4VisCommandSetLineWidth ()
224 { 153 {
225 delete fpCommand; 154 delete fpCommand;
226 } 155 }
227 156
228 G4String G4VisCommandSetLineWidth::GetCurrentV 157 G4String G4VisCommandSetLineWidth::GetCurrentValue (G4UIcommand*)
229 { 158 {
230 return G4String(); 159 return G4String();
231 } 160 }
232 161
233 void G4VisCommandSetLineWidth::SetNewValue (G4 162 void G4VisCommandSetLineWidth::SetNewValue (G4UIcommand*, G4String newValue)
234 { 163 {
235 G4VisManager::Verbosity verbosity = fpVisMan 164 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
236 165
237 fCurrentLineWidth = fpCommand->GetNewDoubleV 166 fCurrentLineWidth = fpCommand->GetNewDoubleValue(newValue);
238 167
239 if (verbosity >= G4VisManager::warnings) { << 168 if (verbosity >= G4VisManager::confirmations) {
240 G4warn << << 169 G4cout <<
241 "Line width for *future* \"/vis/scene/add/ << 170 "Line width for future \"/vis/scene/add/\" commands has been set to "
242 << fCurrentLineWidth << << 171 << fCurrentLineWidth
243 "\nSee \"/vis/viewer/set/lineWidth\" for m << 172 << G4endl;
244 << G4endl; <<
245 } 173 }
246 } 174 }
247 175
248 ////////////// /vis/set/textColour /////////// 176 ////////////// /vis/set/textColour ////////////////////////////////////
249 177
250 G4VisCommandSetTextColour::G4VisCommandSetText 178 G4VisCommandSetTextColour::G4VisCommandSetTextColour ()
251 { 179 {
252 G4bool omitable; 180 G4bool omitable;
253 fpCommand = new G4UIcommand("/vis/set/textCo 181 fpCommand = new G4UIcommand("/vis/set/textColour", this);
254 fpCommand->SetGuidance 182 fpCommand->SetGuidance
255 ("Defines colour and opacity for future \" 183 ("Defines colour and opacity for future \"/vis/scene/add/text\" commands.");
256 fpCommand->SetGuidance(ConvertToColourGuidan 184 fpCommand->SetGuidance(ConvertToColourGuidance());
257 fpCommand->SetGuidance("Default: blue and op 185 fpCommand->SetGuidance("Default: blue and opaque.");
258 G4UIparameter* parameter; 186 G4UIparameter* parameter;
259 parameter = new G4UIparameter ("red", 's', o 187 parameter = new G4UIparameter ("red", 's', omitable = true);
260 parameter->SetGuidance 188 parameter->SetGuidance
261 ("Red component or a string, e.g., \"cyan\ 189 ("Red component or a string, e.g., \"cyan\" (green and blue parameters are ignored).");
262 parameter->SetDefaultValue ("0."); 190 parameter->SetDefaultValue ("0.");
263 fpCommand->SetParameter (parameter); 191 fpCommand->SetParameter (parameter);
264 parameter = new G4UIparameter ("green", 'd', 192 parameter = new G4UIparameter ("green", 'd', omitable = true);
265 parameter->SetDefaultValue (0.); 193 parameter->SetDefaultValue (0.);
266 fpCommand->SetParameter (parameter); 194 fpCommand->SetParameter (parameter);
267 parameter = new G4UIparameter ("blue", 'd', 195 parameter = new G4UIparameter ("blue", 'd', omitable = true);
268 parameter->SetDefaultValue (1.); 196 parameter->SetDefaultValue (1.);
269 fpCommand->SetParameter (parameter); 197 fpCommand->SetParameter (parameter);
270 parameter = new G4UIparameter ("alpha", 'd', 198 parameter = new G4UIparameter ("alpha", 'd', omitable = true);
271 parameter->SetDefaultValue (1.); 199 parameter->SetDefaultValue (1.);
272 parameter->SetGuidance ("Opacity"); 200 parameter->SetGuidance ("Opacity");
273 fpCommand->SetParameter (parameter); 201 fpCommand->SetParameter (parameter);
274 } 202 }
275 203
276 G4VisCommandSetTextColour::~G4VisCommandSetTex 204 G4VisCommandSetTextColour::~G4VisCommandSetTextColour ()
277 { 205 {
278 delete fpCommand; 206 delete fpCommand;
279 } 207 }
280 208
281 G4String G4VisCommandSetTextColour::GetCurrent 209 G4String G4VisCommandSetTextColour::GetCurrentValue (G4UIcommand*)
282 { 210 {
283 return G4String(); 211 return G4String();
284 } 212 }
285 213
286 void G4VisCommandSetTextColour::SetNewValue (G 214 void G4VisCommandSetTextColour::SetNewValue (G4UIcommand*, G4String newValue)
287 { 215 {
288 G4VisManager::Verbosity verbosity = fpVisMan 216 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
289 217
290 G4String redOrString; 218 G4String redOrString;
291 G4double green, blue, opacity; 219 G4double green, blue, opacity;
292 std::istringstream iss(newValue); 220 std::istringstream iss(newValue);
293 iss >> redOrString >> green >> blue >> opaci 221 iss >> redOrString >> green >> blue >> opacity;
294 222
295 ConvertToColour(fCurrentTextColour, redOrStr 223 ConvertToColour(fCurrentTextColour, redOrString, green, blue, opacity);
296 224
297 if (verbosity >= G4VisManager::confirmations 225 if (verbosity >= G4VisManager::confirmations) {
298 G4cout << 226 G4cout <<
299 "Colour for future \"/vis/scene/add/text 227 "Colour for future \"/vis/scene/add/text\" commands has been set to "
300 << fCurrentTextColour << '.' 228 << fCurrentTextColour << '.'
301 << G4endl; 229 << G4endl;
302 } 230 }
303 } 231 }
304 232
305 ////////////// /vis/set/textLayout /////////// 233 ////////////// /vis/set/textLayout ////////////////////////////////////
306 234
307 G4VisCommandSetTextLayout::G4VisCommandSetText 235 G4VisCommandSetTextLayout::G4VisCommandSetTextLayout ()
308 { 236 {
309 G4bool omitable; 237 G4bool omitable;
310 fpCommand = new G4UIcmdWithAString("/vis/set 238 fpCommand = new G4UIcmdWithAString("/vis/set/textLayout", this);
311 fpCommand->SetGuidance 239 fpCommand->SetGuidance
312 ("Defines layout future \"/vis/scene/add/t 240 ("Defines layout future \"/vis/scene/add/text\" commands.");
313 fpCommand->SetGuidance 241 fpCommand->SetGuidance
314 ("\"left\" (default) for left justificatio 242 ("\"left\" (default) for left justification to provided coordinate.");
315 fpCommand->SetGuidance 243 fpCommand->SetGuidance
316 ("\"centre\" or \"center\" for text center 244 ("\"centre\" or \"center\" for text centered on provided coordinate.");
317 fpCommand->SetGuidance 245 fpCommand->SetGuidance
318 ("\"right\" for right justification to pro 246 ("\"right\" for right justification to provided coordinate.");
319 fpCommand->SetGuidance("Default: left."); 247 fpCommand->SetGuidance("Default: left.");
320 fpCommand->SetParameterName("layout", omitab 248 fpCommand->SetParameterName("layout", omitable = true);
321 fpCommand->SetCandidates ("left centre cente 249 fpCommand->SetCandidates ("left centre center right");
322 fpCommand->SetDefaultValue ("left"); 250 fpCommand->SetDefaultValue ("left");
323 } 251 }
324 252
325 G4VisCommandSetTextLayout::~G4VisCommandSetTex 253 G4VisCommandSetTextLayout::~G4VisCommandSetTextLayout ()
326 { 254 {
327 delete fpCommand; 255 delete fpCommand;
328 } 256 }
329 257
330 G4String G4VisCommandSetTextLayout::GetCurrent 258 G4String G4VisCommandSetTextLayout::GetCurrentValue (G4UIcommand*)
331 { 259 {
332 return G4String(); 260 return G4String();
333 } 261 }
334 262
335 void G4VisCommandSetTextLayout::SetNewValue (G 263 void G4VisCommandSetTextLayout::SetNewValue (G4UIcommand*, G4String newValue)
336 { 264 {
337 G4Text::Layout layout = G4Text::left; 265 G4Text::Layout layout = G4Text::left;
338 if (newValue == "left") layout = G4Text::lef 266 if (newValue == "left") layout = G4Text::left;
339 else if (newValue == "centre" || newValue == 267 else if (newValue == "centre" || newValue == "center")
340 layout = G4Text::centre; 268 layout = G4Text::centre;
341 else if (newValue == "right") layout = G4Tex 269 else if (newValue == "right") layout = G4Text::right;
342 270
343 fCurrentTextLayout = layout; 271 fCurrentTextLayout = layout;
344 272
345 G4VisManager::Verbosity verbosity = fpVisMan 273 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
346 if (verbosity >= G4VisManager::confirmations 274 if (verbosity >= G4VisManager::confirmations) {
347 G4cout << "Text layout (for future \"text\ 275 G4cout << "Text layout (for future \"text\" commands) has been set to \""
348 << fCurrentTextLayout << "\"." 276 << fCurrentTextLayout << "\"."
349 << G4endl; 277 << G4endl;
350 } 278 }
351 } 279 }
352 280
353 ////////////// /vis/set/textSize ///////////// 281 ////////////// /vis/set/textSize ////////////////////////////////////
354 282
355 G4VisCommandSetTextSize::G4VisCommandSetTextSi 283 G4VisCommandSetTextSize::G4VisCommandSetTextSize ()
356 { 284 {
357 G4bool omitable; 285 G4bool omitable;
358 fpCommand = new G4UIcmdWithADouble("/vis/set 286 fpCommand = new G4UIcmdWithADouble("/vis/set/textSize", this);
359 fpCommand->SetGuidance 287 fpCommand->SetGuidance
360 ("Defines text size (pixels) for future \"/v 288 ("Defines text size (pixels) for future \"/vis/scene/add/\" commands.");
361 fpCommand->SetParameterName ("textSize", omi 289 fpCommand->SetParameterName ("textSize", omitable = true);
362 fpCommand->SetDefaultValue (12.); // pixels 290 fpCommand->SetDefaultValue (12.); // pixels
363 fpCommand->SetRange("textSize >= 8."); << 291 fpCommand->SetRange("textSize >= 1.");
364 } 292 }
365 293
366 G4VisCommandSetTextSize::~G4VisCommandSetTextS 294 G4VisCommandSetTextSize::~G4VisCommandSetTextSize ()
367 { 295 {
368 delete fpCommand; 296 delete fpCommand;
369 } 297 }
370 298
371 G4String G4VisCommandSetTextSize::GetCurrentVa 299 G4String G4VisCommandSetTextSize::GetCurrentValue (G4UIcommand*)
372 { 300 {
373 return G4String(); 301 return G4String();
374 } 302 }
375 303
376 void G4VisCommandSetTextSize::SetNewValue (G4U 304 void G4VisCommandSetTextSize::SetNewValue (G4UIcommand*, G4String newValue)
377 { 305 {
378 G4VisManager::Verbosity verbosity = fpVisMan 306 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
379 307
380 fCurrentTextSize = fpCommand->GetNewDoubleVa 308 fCurrentTextSize = fpCommand->GetNewDoubleValue(newValue);
381 309
382 if (verbosity >= G4VisManager::confirmations 310 if (verbosity >= G4VisManager::confirmations) {
383 G4cout << 311 G4cout <<
384 "Text size for future \"/vis/scene/add/\" 312 "Text size for future \"/vis/scene/add/\" commands has been set to "
385 << fCurrentTextSize 313 << fCurrentTextSize
386 << G4endl; 314 << G4endl;
387 } 315 }
388 } 316 }
389 317
390 ////////////// /vis/set/touchable //////////// 318 ////////////// /vis/set/touchable ////////////////////////////////////
391 319
392 G4VisCommandSetTouchable::G4VisCommandSetTouch 320 G4VisCommandSetTouchable::G4VisCommandSetTouchable ()
393 { 321 {
394 G4bool omitable; 322 G4bool omitable;
395 G4UIparameter* parameter; 323 G4UIparameter* parameter;
396 fpCommand = new G4UIcommand("/vis/set/toucha 324 fpCommand = new G4UIcommand("/vis/set/touchable", this);
397 fpCommand->SetGuidance 325 fpCommand->SetGuidance
398 ("Defines touchable for future \"/vis/toucha 326 ("Defines touchable for future \"/vis/touchable/set/\" commands.");
399 fpCommand->SetGuidance 327 fpCommand->SetGuidance
400 ("Please provide a list of space-separated p 328 ("Please provide a list of space-separated physical volume names and"
401 "\ncopy number pairs starting at the world 329 "\ncopy number pairs starting at the world volume, e.g:"
402 "\n /vis/set/touchable World 0 Envelope 0 330 "\n /vis/set/touchable World 0 Envelope 0 Shape1 0"
403 "\n(To get list of touchables, use \"/vis/d 331 "\n(To get list of touchables, use \"/vis/drawTree\")"
404 "\n(To save, use \"/vis/viewer/save\")"); 332 "\n(To save, use \"/vis/viewer/save\")");
405 parameter = new G4UIparameter ("list", 's', << 333 parameter = new G4UIparameter ("list", 's', omitable = false);
406 parameter->SetGuidance 334 parameter->SetGuidance
407 ("List of physical volume names and copy num 335 ("List of physical volume names and copy number pairs");
408 fpCommand->SetParameter (parameter); 336 fpCommand->SetParameter (parameter);
409 } 337 }
410 338
411 G4VisCommandSetTouchable::~G4VisCommandSetTouc 339 G4VisCommandSetTouchable::~G4VisCommandSetTouchable ()
412 { 340 {
413 delete fpCommand; 341 delete fpCommand;
414 } 342 }
415 343
416 G4String G4VisCommandSetTouchable::GetCurrentV 344 G4String G4VisCommandSetTouchable::GetCurrentValue (G4UIcommand*)
417 { 345 {
418 return G4String(); 346 return G4String();
419 } 347 }
420 348
421 void G4VisCommandSetTouchable::SetNewValue (G4 349 void G4VisCommandSetTouchable::SetNewValue (G4UIcommand*, G4String newValue)
422 { 350 {
423 G4VisManager::Verbosity verbosity = fpVisMan 351 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
424 <<
425 if (newValue.empty()) { <<
426 fCurrentTouchableProperties = G4PhysicalVo <<
427 if (verbosity >= G4VisManager::confirmatio <<
428 G4cout << <<
429 "Current touchable reset to: " << fCurre <<
430 << G4endl; <<
431 } <<
432 return; <<
433 } <<
434 352
435 G4ModelingParameters::PVNameCopyNoPath curre 353 G4ModelingParameters::PVNameCopyNoPath currentTouchablePath;
436 << 354
437 // Algorithm from Josuttis p.476. 355 // Algorithm from Josuttis p.476.
438 G4String::size_type iBegin, iEnd; 356 G4String::size_type iBegin, iEnd;
439 iBegin = newValue.find_first_not_of(' '); 357 iBegin = newValue.find_first_not_of(' ');
440 while (iBegin != G4String::npos) { 358 while (iBegin != G4String::npos) {
441 iEnd = newValue.find_first_of(' ',iBegin); 359 iEnd = newValue.find_first_of(' ',iBegin);
442 if (iEnd == G4String::npos) { 360 if (iEnd == G4String::npos) {
443 iEnd = newValue.length(); 361 iEnd = newValue.length();
444 } 362 }
445 const G4String& name(newValue.substr(iBegi << 363 G4String name(newValue.substr(iBegin,iEnd-iBegin));
446 iBegin = newValue.find_first_not_of(' ',iE 364 iBegin = newValue.find_first_not_of(' ',iEnd);
447 if (iBegin == G4String::npos) { 365 if (iBegin == G4String::npos) {
448 if (verbosity >= G4VisManager::warnings) 366 if (verbosity >= G4VisManager::warnings) {
449 G4warn << << 367 G4cout <<
450 "WARNING: G4VisCommandSetTouchable::Se 368 "WARNING: G4VisCommandSetTouchable::SetNewValue"
451 "\n A pair not found. (There should be an << 369 "\n A pair not found. (Did you have an even number of parameters?)"
452 "\n Command ignored." 370 "\n Command ignored."
453 << G4endl; 371 << G4endl;
454 return; 372 return;
455 } 373 }
456 } 374 }
457 iEnd = newValue.find_first_of(' ',iBegin); 375 iEnd = newValue.find_first_of(' ',iBegin);
458 if (iEnd == G4String::npos) { 376 if (iEnd == G4String::npos) {
459 iEnd = newValue.length(); 377 iEnd = newValue.length();
460 } 378 }
461 G4int copyNo; 379 G4int copyNo;
462 std::istringstream iss(newValue.substr(iBe 380 std::istringstream iss(newValue.substr(iBegin,iEnd-iBegin));
463 if (!(iss >> copyNo)) { 381 if (!(iss >> copyNo)) {
464 if (verbosity >= G4VisManager::warnings) 382 if (verbosity >= G4VisManager::warnings) {
465 G4warn << << 383 G4cout <<
466 "WARNING: G4VisCommandSetTouchable::Se 384 "WARNING: G4VisCommandSetTouchable::SetNewValue"
467 "\n Error reading copy number - it wa 385 "\n Error reading copy number - it was not numeric?"
468 "\n Command ignored." 386 "\n Command ignored."
469 << G4endl; 387 << G4endl;
470 return; 388 return;
471 } 389 }
472 } 390 }
473 currentTouchablePath.push_back 391 currentTouchablePath.push_back
474 (G4ModelingParameters::PVNameCopyNo(name,c 392 (G4ModelingParameters::PVNameCopyNo(name,copyNo));
475 iBegin = newValue.find_first_not_of(' ',iE 393 iBegin = newValue.find_first_not_of(' ',iEnd);
476 } 394 }
477 << 395
478 // Check validity << 396 fCurrentTouchablePath = currentTouchablePath;
479 G4bool successful = false; << 397
480 G4TransportationManager* transportationManag <<
481 G4TransportationManager::GetTransportationMa <<
482 size_t nWorlds = transportationManager->GetN <<
483 std::vector<G4VPhysicalVolume*>::iterator it <<
484 transportationManager->GetWorldsIterator(); <<
485 for (size_t i = 0; i < nWorlds; ++i, ++iterW <<
486 G4PhysicalVolumeModel pvModel (*iterWorld) <<
487 G4ModelingParameters mp; // Default - no <<
488 pvModel.SetModelingParameters (&mp); <<
489 G4TouchablePropertiesScene scene (&pvModel <<
490 pvModel.DescribeYourselfTo (scene); // In <<
491 if (scene.GetFoundTouchableProperties().fp <<
492 successful = true; <<
493 fCurrentTouchableProperties = scene.GetF <<
494 break; // Found, so no need to scan mor <<
495 } <<
496 } <<
497 <<
498 if (successful) { <<
499 if (verbosity >= G4VisManager::confirmatio <<
500 G4cout << <<
501 "Current touchable: " << fCurrentTouchab <<
502 << G4endl; <<
503 return; <<
504 } <<
505 } else { <<
506 if (verbosity >= G4VisManager::warnings) { <<
507 G4warn << <<
508 "WARNING: G4VisCommandSetTouchable::SetN <<
509 "\n Touchable not found." <<
510 << G4endl; <<
511 return; <<
512 } <<
513 } <<
514 } <<
515 <<
516 ////////////// /vis/set/volumeForField /////// <<
517 <<
518 G4VisCommandSetVolumeForField::G4VisCommandSet <<
519 { <<
520 G4bool omitable; <<
521 G4UIparameter* parameter; <<
522 fpCommand = new G4UIcommand("/vis/set/volume <<
523 fpCommand->SetGuidance <<
524 ("Sets a volume for \"/vis/scene/add/*Field\ <<
525 fpCommand->SetGuidance <<
526 ("Takes a volume name or a /regular expressi <<
527 "\n\"/vis/drawVolume\""); <<
528 parameter = new G4UIparameter ("physical-vol <<
529 fpCommand -> SetParameter (parameter); <<
530 parameter = new G4UIparameter ("copy-no", 'i <<
531 parameter -> SetGuidance ("If negative, matc <<
532 parameter -> SetDefaultValue (-1); <<
533 fpCommand -> SetParameter (parameter); <<
534 parameter = new G4UIparameter ("draw", 'b', <<
535 parameter -> SetGuidance ("If true, draw ext <<
536 parameter -> SetDefaultValue (false); <<
537 fpCommand -> SetParameter (parameter); <<
538 } <<
539 <<
540 G4VisCommandSetVolumeForField::~G4VisCommandSe <<
541 { <<
542 delete fpCommand; <<
543 } <<
544 <<
545 G4String G4VisCommandSetVolumeForField::GetCur <<
546 { <<
547 return G4String(); <<
548 } <<
549 <<
550 void G4VisCommandSetVolumeForField::SetNewValu <<
551 { <<
552 G4VisManager::Verbosity verbosity = fpVisMan <<
553 <<
554 G4String name, drawString; <<
555 G4int copyNo; <<
556 std::istringstream is (newValue); <<
557 is >> name >> copyNo >> drawString; <<
558 G4bool draw = G4UIcmdWithABool::ConvertToBoo <<
559 <<
560 G4TransportationManager* transportationManag <<
561 G4TransportationManager::GetTransportationMa <<
562 size_t nWorlds = transportationManager->GetN <<
563 std::vector<G4VPhysicalVolume*>::iterator it <<
564 transportationManager->GetWorldsIterator(); <<
565 fCurrrentPVFindingsForField.clear(); <<
566 G4BoundingExtentScene extentScene; <<
567 for (size_t i = 0; i < nWorlds; ++i, ++iterW <<
568 G4PhysicalVolumeModel searchModel (*iterWo <<
569 G4ModelingParameters mp; // Default - no <<
570 searchModel.SetModelingParameters (&mp); <<
571 // Find all instances at any position in t <<
572 G4PhysicalVolumesSearchScene searchScene ( <<
573 searchModel.DescribeYourselfTo (searchScen <<
574 for (const auto& findings: searchScene.Get <<
575 fCurrrentPVFindingsForField.push_back(fi <<
576 G4VisExtent extent = findings.fpFoundPV- <<
577 extent.Transform(findings.fFoundObjectTr <<
578 extentScene.AccrueBoundingExtent(extent) <<
579 } <<
580 } <<
581 <<
582 if (fCurrrentPVFindingsForField.empty()) { <<
583 if (verbosity >= G4VisManager::errors) { <<
584 G4warn << "ERROR: Volume \"" << name << <<
585 if (copyNo >= 0) { <<
586 G4warn << ", copy no. " << copyNo << " <<
587 } <<
588 G4warn << " not found." << G4endl; <<
589 } <<
590 return; <<
591 } <<
592 <<
593 fCurrentExtentForField = extentScene.GetExte <<
594 <<
595 if (draw) DrawExtent(fCurrentExtentForField) <<
596 <<
597 if (verbosity >= G4VisManager::confirmations 398 if (verbosity >= G4VisManager::confirmations) {
598 for (const auto& findings: fCurrrentPVFind << 399 G4cout << fCurrentTouchablePath
599 G4cout << 400 << G4endl;
600 << "\"" << findings.fpFoundPV->GetName() <<
601 << "\", copy no. " << findings.fFoundPVC <<
602 << ", found\nin searched volume \"" <<
603 << findings.fpSearchPV->GetName() <<
604 << "\" at depth " << findings.fFoundDept <<
605 << ",\nbase path: \"" << findings.fFound <<
606 << "\",\nand has been set as volume for <<
607 << G4endl; <<
608 } <<
609 } 401 }
610 } 402 }
>> 403
611 404