Geant4 10.7.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
G4VisCommandsGeometrySet.cc
Go to the documentation of this file.
1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26//
27
28// /vis/geometry commands - John Allison 31st January 2006
29
31
32#include "G4UIcommand.hh"
33#include "G4VisManager.hh"
35#include "G4UImanager.hh"
36
37#include <sstream>
38
40(G4String requestedName,
41 const G4VVisCommandGeometrySetFunction& setFunction,
42 G4int requestedDepth)
43{
46 G4bool found = false;
47 for (size_t iLV = 0; iLV < pLVStore->size(); iLV++ ) {
48 G4LogicalVolume* pLV = (*pLVStore)[iLV];
49 const G4String& logVolName = pLV->GetName();
50 if (logVolName == requestedName) found = true;
51 if (requestedName == "all" || logVolName == requestedName) {
52 SetLVVisAtts(pLV, setFunction, 0, requestedDepth);
53 }
54 }
55 if (requestedName != "all" && !found) {
56 if (verbosity >= G4VisManager::errors) {
57 G4cerr << "ERROR: Logical volume \"" << requestedName
58 << "\" not found in logical volume store." << G4endl;
59 }
60 return;
61 }
63 G4UImanager::GetUIpointer()->ApplyCommand("/vis/scene/notifyHandlers");
64 }
65}
66
68(G4LogicalVolume* pLV,
69 const G4VVisCommandGeometrySetFunction& setFunction,
70 G4int depth, G4int requestedDepth)
71{
73 const G4VisAttributes* oldVisAtts = pLV->GetVisAttributes();
74 fVisAttsMap.insert(std::make_pair(pLV,oldVisAtts)); // Store old vis atts.
75 G4VisAttributes* newVisAtts = new G4VisAttributes; // Memory leak!
76 if (oldVisAtts) {
77 *newVisAtts = *oldVisAtts;
78 }
79 setFunction(newVisAtts); // Sets whatever attribute determined by
80 // function object.
81 pLV->SetVisAttributes(newVisAtts);
82 if (verbosity >= G4VisManager::confirmations) {
83 G4cout << "\nLogical Volume \"" << pLV->GetName()
84 << "\": setting vis attributes:";
85 if (oldVisAtts) {
86 G4cout << "\nwas: " << *oldVisAtts;
87 } else {
88 G4cout << "\n(no old attributes)";
89 }
90 G4cout << "\nnow: " << *newVisAtts
91 << G4endl;
92 }
93 if (requestedDepth < 0 || depth < requestedDepth) {
94 G4int nDaughters = pLV->GetNoDaughters();
95 for (G4int i = 0; i < nDaughters; ++i) {
97 setFunction, ++depth, requestedDepth);
98 }
99 }
100}
101
102////////////// /vis/geometry/set/colour ///////////////////////////////////////
103
105{
106 G4bool omitable;
107 fpCommand = new G4UIcommand("/vis/geometry/set/colour", this);
108 fpCommand->SetGuidance("Sets colour of logical volume(s).");
109 fpCommand->SetGuidance("\"all\" sets all logical volumes.");
110 fpCommand->SetGuidance
111 ("Optionally propagates down hierarchy to given depth.");
112 G4UIparameter* parameter;
113 parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
114 parameter->SetDefaultValue("all");
115 fpCommand->SetParameter(parameter);
116 parameter = new G4UIparameter("depth", 'd', omitable = true);
117 parameter->SetDefaultValue(0);
118 parameter->SetGuidance
119 ("Depth of propagation (-1 means unlimited depth).");
120 fpCommand->SetParameter(parameter);
121 parameter = new G4UIparameter("red", 's', omitable = true);
122 parameter->SetDefaultValue("1.");
123 parameter->SetGuidance
124 ("Red component or a string, e.g., \"blue\", in which case succeeding colour components are ignored.");
125 fpCommand->SetParameter(parameter);
126 parameter = new G4UIparameter("green", 'd', omitable = true);
127 parameter->SetDefaultValue(1.);
128 fpCommand->SetParameter(parameter);
129 parameter = new G4UIparameter("blue", 'd', omitable = true);
130 parameter->SetDefaultValue(1.);
131 fpCommand->SetParameter(parameter);
132 parameter = new G4UIparameter("opacity", 'd', omitable = true);
133 parameter->SetDefaultValue(1.);
134 fpCommand->SetParameter(parameter);
135}
136
138{
139 delete fpCommand;
140}
141
143{
144 return "";
145}
146
148(G4UIcommand*, G4String newValue)
149{
150 G4String name, redOrString;
151 G4int requestedDepth;
152 G4double green, blue, opacity;
153 std::istringstream iss(newValue);
154 iss >> name >> requestedDepth >> redOrString >> green >> blue >> opacity;
155 G4Colour colour(1,1,1,1); // Default white and opaque.
156 ConvertToColour(colour, redOrString, green, blue, opacity);
158 Set(name, setColour, requestedDepth);
159}
160
161////////////// /vis/geometry/set/daughtersInvisible //////////////////////
162
164{
165 G4bool omitable;
166 fpCommand = new G4UIcommand("/vis/geometry/set/daughtersInvisible", this);
167 fpCommand->SetGuidance("Makes daughters of logical volume(s) invisible.");
168 fpCommand->SetGuidance("\"all\" sets all logical volumes.");
169 fpCommand->SetGuidance
170 ("Optionally propagates down hierarchy to given depth.");
171 G4UIparameter* parameter;
172 parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
173 parameter->SetDefaultValue("all");
174 fpCommand->SetParameter(parameter);
175 parameter = new G4UIparameter("depth", 'd', omitable = true);
176 parameter->SetDefaultValue(0);
177 parameter->SetGuidance
178 ("Depth of propagation (-1 means unlimited depth).");
179 fpCommand->SetParameter(parameter);
180 parameter = new G4UIparameter("daughtersInvisible", 'b', omitable = true);
181 parameter->SetDefaultValue(true);
182 fpCommand->SetParameter(parameter);
183}
184
186{
187 delete fpCommand;
188}
189
192{
193 return "";
194}
195
197(G4UIcommand*, G4String newValue)
198{
199 G4String name;
200 G4int requestedDepth;
201 G4String daughtersInvisibleString;
202 std::istringstream iss(newValue);
203 iss >> name >> requestedDepth >> daughtersInvisibleString;
204 G4bool daughtersInvisible =
205 G4UIcommand::ConvertToBool(daughtersInvisibleString);
206
207 if (requestedDepth !=0) {
208 requestedDepth = 0;
210 G4cout << "Recursive application suppressed for this attribute."
211 << G4endl;
212 }
213 }
214
216 setDaughtersInvisible(daughtersInvisible);
217 Set(name, setDaughtersInvisible, requestedDepth);
218
220 if (pViewer) {
221 const G4ViewParameters& viewParams = pViewer->GetViewParameters();
223 if (!viewParams.IsCulling()) {
224 G4cout <<
225 "Culling must be on - \"/vis/viewer/set/culling global true\" - to see effect."
226 << G4endl;
227 }
228 }
229 }
230}
231
232////////////// /vis/geometry/set/forceAuxEdgeVisible /////////////////////////
233
235{
236 G4bool omitable;
237 fpCommand = new G4UIcommand("/vis/geometry/set/forceAuxEdgeVisible", this);
238 fpCommand->SetGuidance
239 ("Forces auxiliary (soft) edges of logical volume(s) to be visible,"
240 "\nregardless of the view parameters.");
241 fpCommand->SetGuidance("\"all\" sets all logical volumes.");
242 fpCommand->SetGuidance
243 ("Optionally propagates down hierarchy to given depth.");
244 G4UIparameter* parameter;
245 parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
246 parameter->SetDefaultValue("all");
247 fpCommand->SetParameter(parameter);
248 parameter = new G4UIparameter("depth", 'd', omitable = true);
249 parameter->SetDefaultValue(0);
250 parameter->SetGuidance
251 ("Depth of propagation (-1 means unlimited depth).");
252 fpCommand->SetParameter(parameter);
253 parameter = new G4UIparameter("forceAuxEdgeVisible", 'b', omitable = true);
254 parameter->SetDefaultValue(true);
255 fpCommand->SetParameter(parameter);
256}
257
259{
260 delete fpCommand;
261}
262
265{
266 return "";
267}
268
270(G4UIcommand*, G4String newValue)
271{
272 G4String name;
273 G4int requestedDepth;
274 G4String forceAuxEdgeVisibleString;
275 std::istringstream iss(newValue);
276 iss >> name >> requestedDepth >> forceAuxEdgeVisibleString;
277 G4bool forceAuxEdgeVisible =
278 G4UIcommand::ConvertToBool(forceAuxEdgeVisibleString);;
279
281 setForceAuxEdgeVisible(forceAuxEdgeVisible);
282 Set(name, setForceAuxEdgeVisible, requestedDepth);
283}
284
285////////////// /vis/geometry/set/forceCloud /////////////////////////
286
288{
289 G4bool omitable;
290 fpCommand = new G4UIcommand("/vis/geometry/set/forceCloud", this);
291 fpCommand->SetGuidance
292 ("Forces logical volume(s) always to be drawn as a cloud of points,"
293 "\nregardless of the view parameters.");
294 fpCommand->SetGuidance("\"all\" sets all logical volumes.");
295 fpCommand->SetGuidance
296 ("Optionally propagates down hierarchy to given depth.");
297 G4UIparameter* parameter;
298 parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
299 parameter->SetDefaultValue("all");
300 fpCommand->SetParameter(parameter);
301 parameter = new G4UIparameter("depth", 'd', omitable = true);
302 parameter->SetDefaultValue(0);
303 parameter->SetGuidance
304 ("Depth of propagation (-1 means unlimited depth).");
305 fpCommand->SetParameter(parameter);
306 parameter = new G4UIparameter("forceCloud", 'b', omitable = true);
307 parameter->SetDefaultValue(true);
308 fpCommand->SetParameter(parameter);
309 parameter = new G4UIparameter("nPoints", 'd', omitable = true);
310 parameter->SetGuidance
311 ("<= 0 means under control of viewer.");
312 parameter->SetDefaultValue(0);
313 fpCommand->SetParameter(parameter);
314}
315
317{
318 delete fpCommand;
319}
320
323{
324 return "";
325}
326
328(G4UIcommand*, G4String newValue)
329{
330 G4String name, forceCloudString;
331 G4int requestedDepth, nPoints;
332 std::istringstream iss(newValue);
333 iss >> name >> requestedDepth >> forceCloudString >> nPoints;
334 G4bool forceCloud = G4UIcommand::ConvertToBool(forceCloudString);;
335
336 G4VisCommandGeometrySetForceCloudFunction setForceCloud(forceCloud,nPoints);
337 Set(name, setForceCloud, requestedDepth);
338}
339
340////////////// /vis/geometry/set/forceLineSegmentsPerCircle /////////////////////////
341
343{
344 G4bool omitable;
345 fpCommand = new G4UIcommand("/vis/geometry/set/forceLineSegmentsPerCircle", this);
346 fpCommand->SetGuidance
347 ("Forces number of line segments per circle, the precision with which a"
348 "\ncurved line or surface is represented by a polygon or polyhedron,"
349 "\nregardless of the view parameters.");
350 fpCommand->SetGuidance("\"all\" sets all logical volumes.");
351 fpCommand->SetGuidance
352 ("Optionally propagates down hierarchy to given depth.");
353 G4UIparameter* parameter;
354 parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
355 parameter->SetDefaultValue("all");
356 fpCommand->SetParameter(parameter);
357 parameter = new G4UIparameter("depth", 'd', omitable = true);
358 parameter->SetDefaultValue(0);
359 parameter->SetGuidance
360 ("Depth of propagation (-1 means unlimited depth).");
361 fpCommand->SetParameter(parameter);
362 parameter = new G4UIparameter("lineSegmentsPerCircle", 'd', omitable = true);
363 parameter->SetGuidance
364 ("<= 0 means not forced, i.e., under control of viewer.");
365 parameter->SetDefaultValue(0);
366 fpCommand->SetParameter(parameter);
367}
368
370{
371 delete fpCommand;
372}
373
376{
377 return "";
378}
379
381(G4UIcommand*, G4String newValue)
382{
383 G4String name;
384 G4int requestedDepth;
385 G4int lineSegmentsPerCircle;
386 std::istringstream iss(newValue);
387 iss >> name >> requestedDepth >> lineSegmentsPerCircle;
388
390 setForceLineSegmentsPerCircle(lineSegmentsPerCircle);
391 Set(name, setForceLineSegmentsPerCircle, requestedDepth);
392}
393
394////////////// /vis/geometry/set/forceSolid /////////////////////////
395
397{
398 G4bool omitable;
399 fpCommand = new G4UIcommand("/vis/geometry/set/forceSolid", this);
400 fpCommand->SetGuidance
401 ("Forces logical volume(s) always to be drawn solid (surface drawing),"
402 "\nregardless of the view parameters.");
403 fpCommand->SetGuidance("\"all\" sets all logical volumes.");
404 fpCommand->SetGuidance
405 ("Optionally propagates down hierarchy to given depth.");
406 G4UIparameter* parameter;
407 parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
408 parameter->SetDefaultValue("all");
409 fpCommand->SetParameter(parameter);
410 parameter = new G4UIparameter("depth", 'd', omitable = true);
411 parameter->SetDefaultValue(0);
412 parameter->SetGuidance
413 ("Depth of propagation (-1 means unlimited depth).");
414 fpCommand->SetParameter(parameter);
415 parameter = new G4UIparameter("force", 'b', omitable = true);
416 parameter->SetDefaultValue(true);
417 fpCommand->SetParameter(parameter);
418}
419
421{
422 delete fpCommand;
423}
424
427{
428 return "";
429}
430
432(G4UIcommand*, G4String newValue)
433{
434 G4String name;
435 G4int requestedDepth;
436 G4String forceString;
437 std::istringstream iss(newValue);
438 iss >> name >> requestedDepth >> forceString;
439 G4bool force = G4UIcommand::ConvertToBool(forceString);
440
442 Set(name, setForceSolid, requestedDepth);
443}
444
445////////////// /vis/geometry/set/forceWireframe /////////////////////////
446
448{
449 G4bool omitable;
450 fpCommand = new G4UIcommand("/vis/geometry/set/forceWireframe", this);
451 fpCommand->SetGuidance
452 ("Forces logical volume(s) always to be drawn as wireframe,"
453 "\nregardless of the view parameters.");
454 fpCommand->SetGuidance("\"all\" sets all logical volumes.");
455 fpCommand->SetGuidance
456 ("Optionally propagates down hierarchy to given depth.");
457 G4UIparameter* parameter;
458 parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
459 parameter->SetDefaultValue("all");
460 fpCommand->SetParameter(parameter);
461 parameter = new G4UIparameter("depth", 'd', omitable = true);
462 parameter->SetDefaultValue(0);
463 parameter->SetGuidance
464 ("Depth of propagation (-1 means unlimited depth).");
465 fpCommand->SetParameter(parameter);
466 parameter = new G4UIparameter("forceWireframe", 'b', omitable = true);
467 parameter->SetDefaultValue(true);
468 fpCommand->SetParameter(parameter);
469}
470
472{
473 delete fpCommand;
474}
475
478{
479 return "";
480}
481
483(G4UIcommand*, G4String newValue)
484{
485 G4String name;
486 G4int requestedDepth;
487 G4String forceWireframeString;
488 std::istringstream iss(newValue);
489 iss >> name >> requestedDepth >> forceWireframeString;
490 G4bool forceWireframe = G4UIcommand::ConvertToBool(forceWireframeString);
491
493 setForceWireframe(forceWireframe);
494 Set(name, setForceWireframe, requestedDepth);
495}
496
497////////////// /vis/geometry/set/lineStyle /////////////////////////////////
498
500{
501 G4bool omitable;
502 fpCommand = new G4UIcommand("/vis/geometry/set/lineStyle", this);
503 fpCommand->SetGuidance("Sets line style of logical volume(s) drawing.");
504 fpCommand->SetGuidance("\"all\" sets all logical volumes.");
505 fpCommand->SetGuidance
506 ("Optionally propagates down hierarchy to given depth.");
507 G4UIparameter* parameter;
508 parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
509 parameter->SetDefaultValue("all");
510 fpCommand->SetParameter(parameter);
511 parameter = new G4UIparameter("depth", 'd', omitable = true);
512 parameter->SetDefaultValue(0);
513 parameter->SetGuidance
514 ("Depth of propagation (-1 means unlimited depth).");
515 fpCommand->SetParameter(parameter);
516 parameter = new G4UIparameter("lineStyle", 's', omitable = true);
517 parameter->SetParameterCandidates("unbroken dashed dotted");
518 parameter->SetDefaultValue("unbroken");
519 fpCommand->SetParameter(parameter);
520}
521
523{
524 delete fpCommand;
525}
526
529{
530 return "";
531}
532
534(G4UIcommand*, G4String newValue)
535{
536 G4String name, lineStyleString;
537 G4int requestedDepth;
538 std::istringstream iss(newValue);
539 iss >> name >> requestedDepth >> lineStyleString;
541 if (lineStyleString == "unbroken") lineStyle = G4VisAttributes::unbroken;
542 if (lineStyleString == "dashed") lineStyle = G4VisAttributes::dashed;
543 if (lineStyleString == "dotted") lineStyle = G4VisAttributes::dotted;
544
545 G4VisCommandGeometrySetLineStyleFunction setLineStyle(lineStyle);
546 Set(name, setLineStyle, requestedDepth);
547}
548
549////////////// /vis/geometry/set/lineWidth /////////////////////////////////
550
552{
553 G4bool omitable;
554 fpCommand = new G4UIcommand("/vis/geometry/set/lineWidth", this);
555 fpCommand->SetGuidance("Sets line width of logical volume(s) drawing.");
556 fpCommand->SetGuidance("\"all\" sets all logical volumes.");
557 fpCommand->SetGuidance
558 ("Optionally propagates down hierarchy to given depth.");
559 G4UIparameter* parameter;
560 parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
561 parameter->SetDefaultValue("all");
562 fpCommand->SetParameter(parameter);
563 parameter = new G4UIparameter("depth", 'd', omitable = true);
564 parameter->SetDefaultValue(0);
565 parameter->SetGuidance
566 ("Depth of propagation (-1 means unlimited depth).");
567 fpCommand->SetParameter(parameter);
568 parameter = new G4UIparameter("lineWidth", 'd', omitable = true);
569 parameter->SetDefaultValue(1.);
570 fpCommand->SetParameter(parameter);
571}
572
574{
575 delete fpCommand;
576}
577
580{
581 return "";
582}
583
585(G4UIcommand*, G4String newValue)
586{
587 G4String name;
588 G4int requestedDepth;
589 G4double lineWidth;
590 std::istringstream iss(newValue);
591 iss >> name >> requestedDepth >> lineWidth;
592
593 G4VisCommandGeometrySetLineWidthFunction setLineWidth(lineWidth);
594 Set(name, setLineWidth, requestedDepth);
595}
596
597////////////// /vis/geometry/set/visibility ///////////////////////////////////////
598
600{
601 G4bool omitable;
602 fpCommand = new G4UIcommand("/vis/geometry/set/visibility", this);
603 fpCommand->SetGuidance("Sets visibility of logical volume(s).");
604 fpCommand->SetGuidance("\"all\" sets all logical volumes.");
605 fpCommand->SetGuidance
606 ("Optionally propagates down hierarchy to given depth.");
607 G4UIparameter* parameter;
608 parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
609 parameter->SetDefaultValue("all");
610 fpCommand->SetParameter(parameter);
611 parameter = new G4UIparameter("depth", 'd', omitable = true);
612 parameter->SetDefaultValue(0);
613 parameter->SetGuidance
614 ("Depth of propagation (-1 means unlimited depth).");
615 fpCommand->SetParameter(parameter);
616 parameter = new G4UIparameter("visibility", 'b', omitable = true);
617 parameter->SetDefaultValue(true);
618 fpCommand->SetParameter(parameter);
619}
620
622{
623 delete fpCommand;
624}
625
627{
628 return "";
629}
630
632(G4UIcommand*, G4String newValue)
633{
634 G4String name;
635 G4int requestedDepth;
636 G4String visibilityString;
637 std::istringstream iss(newValue);
638 iss >> name >> requestedDepth >> visibilityString;
639 G4bool visibility = G4UIcommand::ConvertToBool(visibilityString);
640
641 G4VisCommandGeometrySetVisibilityFunction setVisibility(visibility);
642 Set(name, setVisibility, requestedDepth);
643
645 if (pViewer) {
646 const G4ViewParameters& viewParams = pViewer->GetViewParameters();
648 if (!viewParams.IsCulling() ||
649 !viewParams.IsCullingInvisible()) {
650 G4cout <<
651 "Culling must be on - \"/vis/viewer/set/culling global true\" and"
652 "\n \"/vis/viewer/set/culling invisible true\" - to see effect."
653 << G4endl;
654 }
655 }
656 }
657}
658
660(G4LogicalVolume* pLV, G4int requestedDepth,G4bool visibility)
661{
662 if (!pLV) return;
663 G4VisCommandGeometrySetVisibilityFunction setVisibility(visibility);
664 SetLVVisAtts(pLV, setVisibility, 0, requestedDepth);
665
667 if (pViewer) {
668 G4UImanager::GetUIpointer()->ApplyCommand("/vis/scene/notifyHandlers");
669 const G4ViewParameters& viewParams = pViewer->GetViewParameters();
671 if (!viewParams.IsCulling() ||
672 !viewParams.IsCullingInvisible()) {
673 G4cout <<
674 "Culling must be on - \"/vis/viewer/set/culling global true\" and"
675 "\n \"/vis/viewer/set/culling invisible true\" - to see effect."
676 << G4endl;
677 }
678 }
679 }
680}
double G4double
Definition: G4Types.hh:83
bool G4bool
Definition: G4Types.hh:86
int G4int
Definition: G4Types.hh:85
G4GLOB_DLL std::ostream G4cerr
#define G4endl
Definition: G4ios.hh:57
G4GLOB_DLL std::ostream G4cout
static G4LogicalVolumeStore * GetInstance()
const G4VisAttributes * GetVisAttributes() const
size_t GetNoDaughters() const
G4VPhysicalVolume * GetDaughter(const G4int i) const
void SetVisAttributes(const G4VisAttributes *pVA)
const G4String & GetName() const
void SetParameter(G4UIparameter *const newParameter)
Definition: G4UIcommand.hh:146
void SetGuidance(const char *aGuidance)
Definition: G4UIcommand.hh:156
static G4bool ConvertToBool(const char *st)
Definition: G4UIcommand.cc:530
G4int ApplyCommand(const char *aCommand)
Definition: G4UImanager.cc:485
static G4UImanager * GetUIpointer()
Definition: G4UImanager.cc:77
void SetDefaultValue(const char *theDefaultValue)
void SetGuidance(const char *theGuidance)
void SetParameterCandidates(const char *theString)
G4LogicalVolume * GetLogicalVolume() const
const G4ViewParameters & GetViewParameters() const
void SetLVVisAtts(G4LogicalVolume *, const G4VVisCommandGeometrySetFunction &, G4int depth, G4int requestedDepth)
void Set(G4String logVolName, const G4VVisCommandGeometrySetFunction &, G4int requestedDepth)
static std::map< G4LogicalVolume *, const G4VisAttributes * > fVisAttsMap
void ConvertToColour(G4Colour &colour, const G4String &redOrString, G4double green, G4double blue, G4double opacity)
static G4VisManager * fpVisManager
G4bool IsCulling() const
G4bool IsCullingInvisible() const
void SetNewValue(G4UIcommand *command, G4String newValue)
G4String GetCurrentValue(G4UIcommand *command)
void SetNewValue(G4UIcommand *command, G4String newValue)
void SetNewValue(G4UIcommand *command, G4String newValue)
G4String GetCurrentValue(G4UIcommand *command)
void SetNewValue(G4UIcommand *command, G4String newValue)
void SetNewValue(G4UIcommand *command, G4String newValue)
G4String GetCurrentValue(G4UIcommand *command)
void SetNewValue(G4UIcommand *command, G4String newValue)
void SetNewValue(G4UIcommand *command, G4String newValue)
G4String GetCurrentValue(G4UIcommand *command)
G4String GetCurrentValue(G4UIcommand *command)
void SetNewValue(G4UIcommand *command, G4String newValue)
G4String GetCurrentValue(G4UIcommand *command)
void SetNewValue(G4UIcommand *command, G4String newValue)
G4String GetCurrentValue(G4UIcommand *command)
void SetNewValue(G4UIcommand *command, G4String newValue)
void SetNewValueOnLV(G4LogicalVolume *pLV, G4int, G4bool)
G4VViewer * GetCurrentViewer() const
static Verbosity GetVerbosity()