| Geant4 Cross Reference |
1 // 1
2 // *******************************************
3 // * License and Disclaimer
4 // *
5 // * The Geant4 software is copyright of th
6 // * the Geant4 Collaboration. It is provided
7 // * conditions of the Geant4 Software License
8 // * LICENSE and available at http://cern.ch/
9 // * include a list of copyright holders.
10 // *
11 // * Neither the authors of this software syst
12 // * institutes,nor the agencies providing fin
13 // * work make any representation or warran
14 // * regarding this software system or assum
15 // * use. Please see the license in the file
16 // * for the full disclaimer and the limitatio
17 // *
18 // * This code implementation is the result
19 // * technical work of the GEANT4 collaboratio
20 // * By using, copying, modifying or distri
21 // * any work based on the software) you ag
22 // * use in resulting scientific publicati
23 // * acceptance of all terms of the Geant4 Sof
24 // *******************************************
25 //
26 //
27
28 // /vis/set - John Allison 21st March 2012
29 // Set quantities for use in appropriate futur
30
31 #include "G4VisCommandsSet.hh"
32
33 #include "G4UIcommand.hh"
34 #include "G4UIcmdWithAnInteger.hh"
35 #include "G4UIcmdWithADouble.hh"
36 #include "G4UIcmdWithAString.hh"
37 #include "G4UIcmdWithABool.hh"
38 #include "G4TouchablePropertiesScene.hh"
39 #include "G4TransportationManager.hh"
40 #include "G4BoundingExtentScene.hh"
41
42 #include <sstream>
43 #include <utility>
44
45 #define G4warn G4cout
46
47 ////////////// /vis/set/arrow3DLineSegmentsPer
48
49 G4VisCommandSetArrow3DLineSegmentsPerCircle::G
50 {
51 G4bool omitable;
52 fpCommand = new G4UIcmdWithAnInteger("/vis/s
53 fpCommand->SetGuidance
54 ("Defines number of line segments per circle
55 " for future \"/vis/scene/add/\" commands."
56 fpCommand->SetParameterName ("number", omita
57 fpCommand->SetDefaultValue (6);
58 fpCommand->SetRange("number >= 3");
59 }
60
61 G4VisCommandSetArrow3DLineSegmentsPerCircle::~
62 {
63 delete fpCommand;
64 }
65
66 G4String G4VisCommandSetArrow3DLineSegmentsPer
67 {
68 return G4String();
69 }
70
71 void G4VisCommandSetArrow3DLineSegmentsPerCirc
72 {
73 G4VisManager::Verbosity verbosity = fpVisMan
74
75 fCurrentArrow3DLineSegmentsPerCircle = fpCom
76
77 if (verbosity >= G4VisManager::confirmations
78 G4cout <<
79 "Number of line segments per circle for dr
80 "\n \"/vis/scene/add/\" commands has been
81 << fCurrentArrow3DLineSegmentsPerCircle
82 << G4endl;
83 }
84 }
85
86 ////////////// /vis/set/colour ///////////////
87
88 G4VisCommandSetColour::G4VisCommandSetColour (
89 {
90 G4bool omitable;
91 fpCommand = new G4UIcommand("/vis/set/colour
92 fpCommand->SetGuidance
93 ("Defines colour and opacity for future \"/v
94 fpCommand->SetGuidance
95 ("(Except \"/vis/scene/add/text\" commands -
96 fpCommand->SetGuidance(ConvertToColourGuidan
97 fpCommand->SetGuidance("Default: white and o
98 G4UIparameter* parameter;
99 parameter = new G4UIparameter ("red", 's', o
100 parameter->SetGuidance
101 ("Red component or a string, e.g., \"cyan\"
102 parameter->SetDefaultValue ("1.");
103 fpCommand->SetParameter (parameter);
104 parameter = new G4UIparameter ("green", 'd',
105 parameter->SetDefaultValue (1.);
106 fpCommand->SetParameter (parameter);
107 parameter = new G4UIparameter ("blue", 'd',
108 parameter->SetDefaultValue (1.);
109 fpCommand->SetParameter (parameter);
110 parameter = new G4UIparameter ("alpha", 'd',
111 parameter->SetDefaultValue (1.);
112 parameter->SetGuidance ("Opacity");
113 fpCommand->SetParameter (parameter);
114 }
115
116 G4VisCommandSetColour::~G4VisCommandSetColour
117 {
118 delete fpCommand;
119 }
120
121 G4String G4VisCommandSetColour::GetCurrentValu
122 {
123 return G4String();
124 }
125
126 void G4VisCommandSetColour::SetNewValue (G4UIc
127 {
128 G4VisManager::Verbosity verbosity = fpVisMan
129
130 G4String redOrString;
131 G4double green, blue, opacity;
132 std::istringstream iss(newValue);
133 iss >> redOrString >> green >> blue >> opaci
134
135 ConvertToColour(fCurrentColour, redOrString,
136
137 if (verbosity >= G4VisManager::confirmations
138 G4cout <<
139 "Colour for future \"/vis/scene/add/\" com
140 << fCurrentColour <<
141 ".\n(Except \"/vis/scene/add/text\" comman
142 << 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 }
207 }
208
209 ////////////// /vis/set/lineWidth ////////////
210
211 G4VisCommandSetLineWidth::G4VisCommandSetLineW
212 {
213 G4bool omitable;
214 fpCommand = new G4UIcmdWithADouble("/vis/set
215 fpCommand->SetGuidance
216 ("Defines line width for future \"/vis/scene
217 "\nSee \"/vis/viewer/set/lineWidth\" for mo
218 fpCommand->SetParameterName ("lineWidth", om
219 fpCommand->SetDefaultValue (1.);
220 fpCommand->SetRange("lineWidth >= 1.");
221 }
222
223 G4VisCommandSetLineWidth::~G4VisCommandSetLine
224 {
225 delete fpCommand;
226 }
227
228 G4String G4VisCommandSetLineWidth::GetCurrentV
229 {
230 return G4String();
231 }
232
233 void G4VisCommandSetLineWidth::SetNewValue (G4
234 {
235 G4VisManager::Verbosity verbosity = fpVisMan
236
237 fCurrentLineWidth = fpCommand->GetNewDoubleV
238
239 if (verbosity >= G4VisManager::warnings) {
240 G4warn <<
241 "Line width for *future* \"/vis/scene/add/
242 << fCurrentLineWidth <<
243 "\nSee \"/vis/viewer/set/lineWidth\" for m
244 << G4endl;
245 }
246 }
247
248 ////////////// /vis/set/textColour ///////////
249
250 G4VisCommandSetTextColour::G4VisCommandSetText
251 {
252 G4bool omitable;
253 fpCommand = new G4UIcommand("/vis/set/textCo
254 fpCommand->SetGuidance
255 ("Defines colour and opacity for future \"
256 fpCommand->SetGuidance(ConvertToColourGuidan
257 fpCommand->SetGuidance("Default: blue and op
258 G4UIparameter* parameter;
259 parameter = new G4UIparameter ("red", 's', o
260 parameter->SetGuidance
261 ("Red component or a string, e.g., \"cyan\
262 parameter->SetDefaultValue ("0.");
263 fpCommand->SetParameter (parameter);
264 parameter = new G4UIparameter ("green", 'd',
265 parameter->SetDefaultValue (0.);
266 fpCommand->SetParameter (parameter);
267 parameter = new G4UIparameter ("blue", 'd',
268 parameter->SetDefaultValue (1.);
269 fpCommand->SetParameter (parameter);
270 parameter = new G4UIparameter ("alpha", 'd',
271 parameter->SetDefaultValue (1.);
272 parameter->SetGuidance ("Opacity");
273 fpCommand->SetParameter (parameter);
274 }
275
276 G4VisCommandSetTextColour::~G4VisCommandSetTex
277 {
278 delete fpCommand;
279 }
280
281 G4String G4VisCommandSetTextColour::GetCurrent
282 {
283 return G4String();
284 }
285
286 void G4VisCommandSetTextColour::SetNewValue (G
287 {
288 G4VisManager::Verbosity verbosity = fpVisMan
289
290 G4String redOrString;
291 G4double green, blue, opacity;
292 std::istringstream iss(newValue);
293 iss >> redOrString >> green >> blue >> opaci
294
295 ConvertToColour(fCurrentTextColour, redOrStr
296
297 if (verbosity >= G4VisManager::confirmations
298 G4cout <<
299 "Colour for future \"/vis/scene/add/text
300 << fCurrentTextColour << '.'
301 << G4endl;
302 }
303 }
304
305 ////////////// /vis/set/textLayout ///////////
306
307 G4VisCommandSetTextLayout::G4VisCommandSetText
308 {
309 G4bool omitable;
310 fpCommand = new G4UIcmdWithAString("/vis/set
311 fpCommand->SetGuidance
312 ("Defines layout future \"/vis/scene/add/t
313 fpCommand->SetGuidance
314 ("\"left\" (default) for left justificatio
315 fpCommand->SetGuidance
316 ("\"centre\" or \"center\" for text center
317 fpCommand->SetGuidance
318 ("\"right\" for right justification to pro
319 fpCommand->SetGuidance("Default: left.");
320 fpCommand->SetParameterName("layout", omitab
321 fpCommand->SetCandidates ("left centre cente
322 fpCommand->SetDefaultValue ("left");
323 }
324
325 G4VisCommandSetTextLayout::~G4VisCommandSetTex
326 {
327 delete fpCommand;
328 }
329
330 G4String G4VisCommandSetTextLayout::GetCurrent
331 {
332 return G4String();
333 }
334
335 void G4VisCommandSetTextLayout::SetNewValue (G
336 {
337 G4Text::Layout layout = G4Text::left;
338 if (newValue == "left") layout = G4Text::lef
339 else if (newValue == "centre" || newValue ==
340 layout = G4Text::centre;
341 else if (newValue == "right") layout = G4Tex
342
343 fCurrentTextLayout = layout;
344
345 G4VisManager::Verbosity verbosity = fpVisMan
346 if (verbosity >= G4VisManager::confirmations
347 G4cout << "Text layout (for future \"text\
348 << fCurrentTextLayout << "\"."
349 << G4endl;
350 }
351 }
352
353 ////////////// /vis/set/textSize /////////////
354
355 G4VisCommandSetTextSize::G4VisCommandSetTextSi
356 {
357 G4bool omitable;
358 fpCommand = new G4UIcmdWithADouble("/vis/set
359 fpCommand->SetGuidance
360 ("Defines text size (pixels) for future \"/v
361 fpCommand->SetParameterName ("textSize", omi
362 fpCommand->SetDefaultValue (12.); // pixels
363 fpCommand->SetRange("textSize >= 8.");
364 }
365
366 G4VisCommandSetTextSize::~G4VisCommandSetTextS
367 {
368 delete fpCommand;
369 }
370
371 G4String G4VisCommandSetTextSize::GetCurrentVa
372 {
373 return G4String();
374 }
375
376 void G4VisCommandSetTextSize::SetNewValue (G4U
377 {
378 G4VisManager::Verbosity verbosity = fpVisMan
379
380 fCurrentTextSize = fpCommand->GetNewDoubleVa
381
382 if (verbosity >= G4VisManager::confirmations
383 G4cout <<
384 "Text size for future \"/vis/scene/add/\"
385 << fCurrentTextSize
386 << G4endl;
387 }
388 }
389
390 ////////////// /vis/set/touchable ////////////
391
392 G4VisCommandSetTouchable::G4VisCommandSetTouch
393 {
394 G4bool omitable;
395 G4UIparameter* parameter;
396 fpCommand = new G4UIcommand("/vis/set/toucha
397 fpCommand->SetGuidance
398 ("Defines touchable for future \"/vis/toucha
399 fpCommand->SetGuidance
400 ("Please provide a list of space-separated p
401 "\ncopy number pairs starting at the world
402 "\n /vis/set/touchable World 0 Envelope 0
403 "\n(To get list of touchables, use \"/vis/d
404 "\n(To save, use \"/vis/viewer/save\")");
405 parameter = new G4UIparameter ("list", 's',
406 parameter->SetGuidance
407 ("List of physical volume names and copy num
408 fpCommand->SetParameter (parameter);
409 }
410
411 G4VisCommandSetTouchable::~G4VisCommandSetTouc
412 {
413 delete fpCommand;
414 }
415
416 G4String G4VisCommandSetTouchable::GetCurrentV
417 {
418 return G4String();
419 }
420
421 void G4VisCommandSetTouchable::SetNewValue (G4
422 {
423 G4VisManager::Verbosity verbosity = fpVisMan
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
435 G4ModelingParameters::PVNameCopyNoPath curre
436
437 // Algorithm from Josuttis p.476.
438 G4String::size_type iBegin, iEnd;
439 iBegin = newValue.find_first_not_of(' ');
440 while (iBegin != G4String::npos) {
441 iEnd = newValue.find_first_of(' ',iBegin);
442 if (iEnd == G4String::npos) {
443 iEnd = newValue.length();
444 }
445 const G4String& name(newValue.substr(iBegi
446 iBegin = newValue.find_first_not_of(' ',iE
447 if (iBegin == G4String::npos) {
448 if (verbosity >= G4VisManager::warnings)
449 G4warn <<
450 "WARNING: G4VisCommandSetTouchable::Se
451 "\n A pair not found. (There should be an
452 "\n Command ignored."
453 << G4endl;
454 return;
455 }
456 }
457 iEnd = newValue.find_first_of(' ',iBegin);
458 if (iEnd == G4String::npos) {
459 iEnd = newValue.length();
460 }
461 G4int copyNo;
462 std::istringstream iss(newValue.substr(iBe
463 if (!(iss >> copyNo)) {
464 if (verbosity >= G4VisManager::warnings)
465 G4warn <<
466 "WARNING: G4VisCommandSetTouchable::Se
467 "\n Error reading copy number - it wa
468 "\n Command ignored."
469 << G4endl;
470 return;
471 }
472 }
473 currentTouchablePath.push_back
474 (G4ModelingParameters::PVNameCopyNo(name,c
475 iBegin = newValue.find_first_not_of(' ',iE
476 }
477
478 // Check validity
479 G4bool successful = false;
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
598 for (const auto& findings: fCurrrentPVFind
599 G4cout
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 }
610 }
611