Geant4  v4-10.4-release
 모두 클래스 네임스페이스들 파일들 함수 변수 타입정의 열거형 타입 열거형 멤버 Friends 매크로 그룹들 페이지들
G4VisCommandsGeometrySet.cc
이 파일의 문서화 페이지로 가기
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 // $Id: G4VisCommandsGeometrySet.cc 104123 2017-05-11 13:51:32Z gcosmo $
28 
29 // /vis/geometry commands - John Allison 31st January 2006
30 
32 
33 #include "G4UIcommand.hh"
34 #include "G4VisManager.hh"
35 #include "G4LogicalVolumeStore.hh"
36 #include "G4UImanager.hh"
37 
38 #include <sstream>
39 
41 (G4String requestedName,
42  const G4VVisCommandGeometrySetFunction& setFunction,
43  G4int requestedDepth)
44 {
45  G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
47  G4bool found = false;
48  for (size_t iLV = 0; iLV < pLVStore->size(); iLV++ ) {
49  G4LogicalVolume* pLV = (*pLVStore)[iLV];
50  const G4String& logVolName = pLV->GetName();
51  if (logVolName == requestedName) found = true;
52  if (requestedName == "all" || logVolName == requestedName) {
53  SetLVVisAtts(pLV, setFunction, 0, requestedDepth);
54  }
55  }
56  if (requestedName != "all" && !found) {
57  if (verbosity >= G4VisManager::errors) {
58  G4cerr << "ERROR: Logical volume \"" << requestedName
59  << "\" not found in logical volume store." << G4endl;
60  }
61  return;
62  }
63  if (fpVisManager->GetCurrentViewer()) {
64  G4UImanager::GetUIpointer()->ApplyCommand("/vis/scene/notifyHandlers");
65  }
66 }
67 
70  const G4VVisCommandGeometrySetFunction& setFunction,
71  G4int depth, G4int requestedDepth)
72 {
73  G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
74  const G4VisAttributes* oldVisAtts = pLV->GetVisAttributes();
75  fVisAttsMap.insert(std::make_pair(pLV,oldVisAtts)); // Store old vis atts.
76  G4VisAttributes* newVisAtts = new G4VisAttributes; // Memory leak!
77  if (oldVisAtts) {
78  *newVisAtts = *oldVisAtts;
79  }
80  setFunction(newVisAtts); // Sets whatever attribute determined by
81  // function object.
82  pLV->SetVisAttributes(newVisAtts);
83  if (verbosity >= G4VisManager::confirmations) {
84  G4cout << "\nLogical Volume \"" << pLV->GetName()
85  << "\": setting vis attributes:";
86  if (oldVisAtts) {
87  G4cout << "\nwas: " << *oldVisAtts;
88  } else {
89  G4cout << "\n(no old attributes)";
90  }
91  G4cout << "\nnow: " << *newVisAtts
92  << G4endl;
93  }
94  if (requestedDepth < 0 || depth < requestedDepth) {
95  G4int nDaughters = pLV->GetNoDaughters();
96  for (G4int i = 0; i < nDaughters; ++i) {
97  SetLVVisAtts(pLV->GetDaughter(i)->GetLogicalVolume(),
98  setFunction, ++depth, requestedDepth);
99  }
100  }
101 }
102 
104 
106 {
107  G4bool omitable;
108  fpCommand = new G4UIcommand("/vis/geometry/set/colour", this);
109  fpCommand->SetGuidance("Sets colour of logical volume(s).");
110  fpCommand->SetGuidance("\"all\" sets all logical volumes.");
112  ("Optionally propagates down hierarchy to given depth.");
113  G4UIparameter* parameter;
114  parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
115  parameter->SetDefaultValue("all");
116  fpCommand->SetParameter(parameter);
117  parameter = new G4UIparameter("depth", 'd', omitable = true);
118  parameter->SetDefaultValue(0);
119  parameter->SetGuidance
120  ("Depth of propagation (-1 means unlimited depth).");
121  fpCommand->SetParameter(parameter);
122  parameter = new G4UIparameter("red", 's', omitable = true);
123  parameter->SetDefaultValue("1.");
124  parameter->SetGuidance
125  ("Red component or a string, e.g., \"blue\", in which case succeeding colour components are ignored.");
126  fpCommand->SetParameter(parameter);
127  parameter = new G4UIparameter("green", 'd', omitable = true);
128  parameter->SetDefaultValue(1.);
129  fpCommand->SetParameter(parameter);
130  parameter = new G4UIparameter("blue", 'd', omitable = true);
131  parameter->SetDefaultValue(1.);
132  fpCommand->SetParameter(parameter);
133  parameter = new G4UIparameter("opacity", 'd', omitable = true);
134  parameter->SetDefaultValue(1.);
135  fpCommand->SetParameter(parameter);
136 }
137 
139 {
140  delete fpCommand;
141 }
142 
144 {
145  return "";
146 }
147 
149 (G4UIcommand*, G4String newValue)
150 {
151  G4String name, redOrString;
152  G4int requestedDepth;
153  G4double green, blue, opacity;
154  std::istringstream iss(newValue);
155  iss >> name >> requestedDepth >> redOrString >> green >> blue >> opacity;
156  G4Colour colour(1,1,1,1); // Default white and opaque.
157  ConvertToColour(colour, redOrString, green, blue, opacity);
158  G4VisCommandGeometrySetColourFunction setColour(colour);
159  Set(name, setColour, requestedDepth);
160 }
161 
163 
165 {
166  G4bool omitable;
167  fpCommand = new G4UIcommand("/vis/geometry/set/daughtersInvisible", this);
168  fpCommand->SetGuidance("Makes daughters of logical volume(s) invisible.");
169  fpCommand->SetGuidance("\"all\" sets all logical volumes.");
171  ("Optionally propagates down hierarchy to given depth.");
172  G4UIparameter* parameter;
173  parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
174  parameter->SetDefaultValue("all");
175  fpCommand->SetParameter(parameter);
176  parameter = new G4UIparameter("depth", 'd', omitable = true);
177  parameter->SetDefaultValue(0);
178  parameter->SetGuidance
179  ("Depth of propagation (-1 means unlimited depth).");
180  fpCommand->SetParameter(parameter);
181  parameter = new G4UIparameter("daughtersInvisible", 'b', omitable = true);
182  parameter->SetDefaultValue(true);
183  fpCommand->SetParameter(parameter);
184 }
185 
187 {
188  delete fpCommand;
189 }
190 
191 G4String
193 {
194  return "";
195 }
196 
198 (G4UIcommand*, G4String newValue)
199 {
200  G4String name;
201  G4int requestedDepth;
202  G4String daughtersInvisibleString;
203  std::istringstream iss(newValue);
204  iss >> name >> requestedDepth >> daughtersInvisibleString;
205  G4bool daughtersInvisible =
206  G4UIcommand::ConvertToBool(daughtersInvisibleString);
207 
208  if (requestedDepth !=0) {
209  requestedDepth = 0;
210  if (fpVisManager->GetVerbosity() >= G4VisManager::warnings) {
211  G4cout << "Recursive application suppressed for this attribute."
212  << G4endl;
213  }
214  }
215 
217  setDaughtersInvisible(daughtersInvisible);
218  Set(name, setDaughtersInvisible, requestedDepth);
219 
220  G4VViewer* pViewer = fpVisManager->GetCurrentViewer();
221  if (pViewer) {
222  const G4ViewParameters& viewParams = pViewer->GetViewParameters();
223  if (fpVisManager->GetVerbosity() >= G4VisManager::warnings) {
224  if (!viewParams.IsCulling()) {
225  G4cout <<
226  "Culling must be on - \"/vis/viewer/set/culling global true\" - to see effect."
227  << G4endl;
228  }
229  }
230  }
231 }
232 
234 
236 {
237  G4bool omitable;
238  fpCommand = new G4UIcommand("/vis/geometry/set/forceAuxEdgeVisible", this);
240  ("Forces auxiliary (soft) edges of logical volume(s) to be visible,"
241  "\nregardless of the view parameters.");
242  fpCommand->SetGuidance("\"all\" sets all logical volumes.");
244  ("Optionally propagates down hierarchy to given depth.");
245  G4UIparameter* parameter;
246  parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
247  parameter->SetDefaultValue("all");
248  fpCommand->SetParameter(parameter);
249  parameter = new G4UIparameter("depth", 'd', omitable = true);
250  parameter->SetDefaultValue(0);
251  parameter->SetGuidance
252  ("Depth of propagation (-1 means unlimited depth).");
253  fpCommand->SetParameter(parameter);
254  parameter = new G4UIparameter("forceAuxEdgeVisible", 'b', omitable = true);
255  parameter->SetDefaultValue(true);
256  fpCommand->SetParameter(parameter);
257 }
258 
260 {
261  delete fpCommand;
262 }
263 
264 G4String
266 {
267  return "";
268 }
269 
271 (G4UIcommand*, G4String newValue)
272 {
273  G4String name;
274  G4int requestedDepth;
275  G4String forceAuxEdgeVisibleString;
276  std::istringstream iss(newValue);
277  iss >> name >> requestedDepth >> forceAuxEdgeVisibleString;
278  G4bool forceAuxEdgeVisible =
279  G4UIcommand::ConvertToBool(forceAuxEdgeVisibleString);;
280 
282  setForceAuxEdgeVisible(forceAuxEdgeVisible);
283  Set(name, setForceAuxEdgeVisible, requestedDepth);
284 }
285 
287 
289 {
290  G4bool omitable;
291  fpCommand = new G4UIcommand("/vis/geometry/set/forceLineSegmentsPerCircle", this);
293  ("Forces number of line segments per circle, the precision with which a"
294  "\ncurved line or surface is represented by a polygon or polyhedron,"
295  "\nregardless of the view parameters.");
296  fpCommand->SetGuidance("\"all\" sets all logical volumes.");
298  ("Optionally propagates down hierarchy to given depth.");
299  G4UIparameter* parameter;
300  parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
301  parameter->SetDefaultValue("all");
302  fpCommand->SetParameter(parameter);
303  parameter = new G4UIparameter("depth", 'd', omitable = true);
304  parameter->SetDefaultValue(0);
305  parameter->SetGuidance
306  ("Depth of propagation (-1 means unlimited depth).");
307  fpCommand->SetParameter(parameter);
308  parameter = new G4UIparameter("lineSegmentsPerCircle", 'd', omitable = true);
309  parameter->SetGuidance
310  ("<= 0 means not forced, i.e., under control of viewer.");
311  parameter->SetDefaultValue(0);
312  fpCommand->SetParameter(parameter);
313 }
314 
316 {
317  delete fpCommand;
318 }
319 
320 G4String
322 {
323  return "";
324 }
325 
327 (G4UIcommand*, G4String newValue)
328 {
329  G4String name;
330  G4int requestedDepth;
331  G4int lineSegmentsPerCircle;
332  std::istringstream iss(newValue);
333  iss >> name >> requestedDepth >> lineSegmentsPerCircle;
334 
335  G4VisCommandGeometrySetForceLineSegmentsPerCircleFunction setForceLineSegmentsPerCircle(lineSegmentsPerCircle);
336  Set(name, setForceLineSegmentsPerCircle, requestedDepth);
337 }
338 
340 
342 {
343  G4bool omitable;
344  fpCommand = new G4UIcommand("/vis/geometry/set/forceSolid", this);
346  ("Forces logical volume(s) always to be drawn solid (surface drawing),"
347  "\nregardless of the view parameters.");
348  fpCommand->SetGuidance("\"all\" sets all logical volumes.");
350  ("Optionally propagates down hierarchy to given depth.");
351  G4UIparameter* parameter;
352  parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
353  parameter->SetDefaultValue("all");
354  fpCommand->SetParameter(parameter);
355  parameter = new G4UIparameter("depth", 'd', omitable = true);
356  parameter->SetDefaultValue(0);
357  parameter->SetGuidance
358  ("Depth of propagation (-1 means unlimited depth).");
359  fpCommand->SetParameter(parameter);
360  parameter = new G4UIparameter("forceSolid", 'b', omitable = true);
361  parameter->SetDefaultValue(true);
362  fpCommand->SetParameter(parameter);
363 }
364 
366 {
367  delete fpCommand;
368 }
369 
370 G4String
372 {
373  return "";
374 }
375 
377 (G4UIcommand*, G4String newValue)
378 {
379  G4String name;
380  G4int requestedDepth;
381  G4String forceSolidString;
382  std::istringstream iss(newValue);
383  iss >> name >> requestedDepth >> forceSolidString;
384  G4bool forceSolid = G4UIcommand::ConvertToBool(forceSolidString);
385 
386  G4VisCommandGeometrySetForceSolidFunction setForceSolid(forceSolid);
387  Set(name, setForceSolid, requestedDepth);
388 }
389 
391 
393 {
394  G4bool omitable;
395  fpCommand = new G4UIcommand("/vis/geometry/set/forceWireframe", this);
397  ("Forces logical volume(s) always to be drawn as wireframe,"
398  "\nregardless of the view parameters.");
399  fpCommand->SetGuidance("\"all\" sets all logical volumes.");
401  ("Optionally propagates down hierarchy to given depth.");
402  G4UIparameter* parameter;
403  parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
404  parameter->SetDefaultValue("all");
405  fpCommand->SetParameter(parameter);
406  parameter = new G4UIparameter("depth", 'd', omitable = true);
407  parameter->SetDefaultValue(0);
408  parameter->SetGuidance
409  ("Depth of propagation (-1 means unlimited depth).");
410  fpCommand->SetParameter(parameter);
411  parameter = new G4UIparameter("forceWireframe", 'b', omitable = true);
412  parameter->SetDefaultValue(true);
413  fpCommand->SetParameter(parameter);
414 }
415 
417 {
418  delete fpCommand;
419 }
420 
421 G4String
423 {
424  return "";
425 }
426 
428 (G4UIcommand*, G4String newValue)
429 {
430  G4String name;
431  G4int requestedDepth;
432  G4String forceWireframeString;
433  std::istringstream iss(newValue);
434  iss >> name >> requestedDepth >> forceWireframeString;
435  G4bool forceWireframe = G4UIcommand::ConvertToBool(forceWireframeString);
436 
438  setForceWireframe(forceWireframe);
439  Set(name, setForceWireframe, requestedDepth);
440 }
441 
443 
445 {
446  G4bool omitable;
447  fpCommand = new G4UIcommand("/vis/geometry/set/lineStyle", this);
448  fpCommand->SetGuidance("Sets line style of logical volume(s) drawing.");
449  fpCommand->SetGuidance("\"all\" sets all logical volumes.");
451  ("Optionally propagates down hierarchy to given depth.");
452  G4UIparameter* parameter;
453  parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
454  parameter->SetDefaultValue("all");
455  fpCommand->SetParameter(parameter);
456  parameter = new G4UIparameter("depth", 'd', omitable = true);
457  parameter->SetDefaultValue(0);
458  parameter->SetGuidance
459  ("Depth of propagation (-1 means unlimited depth).");
460  fpCommand->SetParameter(parameter);
461  parameter = new G4UIparameter("lineStyle", 's', omitable = true);
462  parameter->SetParameterCandidates("unbroken dashed dotted");
463  parameter->SetDefaultValue("unbroken");
464  fpCommand->SetParameter(parameter);
465 }
466 
468 {
469  delete fpCommand;
470 }
471 
472 G4String
474 {
475  return "";
476 }
477 
479 (G4UIcommand*, G4String newValue)
480 {
481  G4String name, lineStyleString;
482  G4int requestedDepth;
483  std::istringstream iss(newValue);
484  iss >> name >> requestedDepth >> lineStyleString;
486  if (lineStyleString == "unbroken") lineStyle = G4VisAttributes::unbroken;
487  if (lineStyleString == "dashed") lineStyle = G4VisAttributes::dashed;
488  if (lineStyleString == "dotted") lineStyle = G4VisAttributes::dotted;
489 
490  G4VisCommandGeometrySetLineStyleFunction setLineStyle(lineStyle);
491  Set(name, setLineStyle, requestedDepth);
492 }
493 
495 
497 {
498  G4bool omitable;
499  fpCommand = new G4UIcommand("/vis/geometry/set/lineWidth", this);
500  fpCommand->SetGuidance("Sets line width of logical volume(s) drawing.");
501  fpCommand->SetGuidance("\"all\" sets all logical volumes.");
503  ("Optionally propagates down hierarchy to given depth.");
504  G4UIparameter* parameter;
505  parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
506  parameter->SetDefaultValue("all");
507  fpCommand->SetParameter(parameter);
508  parameter = new G4UIparameter("depth", 'd', omitable = true);
509  parameter->SetDefaultValue(0);
510  parameter->SetGuidance
511  ("Depth of propagation (-1 means unlimited depth).");
512  fpCommand->SetParameter(parameter);
513  parameter = new G4UIparameter("lineWidth", 'd', omitable = true);
514  parameter->SetDefaultValue(1.);
515  fpCommand->SetParameter(parameter);
516 }
517 
519 {
520  delete fpCommand;
521 }
522 
523 G4String
525 {
526  return "";
527 }
528 
530 (G4UIcommand*, G4String newValue)
531 {
532  G4String name;
533  G4int requestedDepth;
534  G4double lineWidth;
535  std::istringstream iss(newValue);
536  iss >> name >> requestedDepth >> lineWidth;
537 
538  G4VisCommandGeometrySetLineWidthFunction setLineWidth(lineWidth);
539  Set(name, setLineWidth, requestedDepth);
540 }
541 
543 
545 {
546  G4bool omitable;
547  fpCommand = new G4UIcommand("/vis/geometry/set/visibility", this);
548  fpCommand->SetGuidance("Sets visibility of logical volume(s).");
549  fpCommand->SetGuidance("\"all\" sets all logical volumes.");
551  ("Optionally propagates down hierarchy to given depth.");
552  G4UIparameter* parameter;
553  parameter = new G4UIparameter ("logical-volume-name", 's', omitable = true);
554  parameter->SetDefaultValue("all");
555  fpCommand->SetParameter(parameter);
556  parameter = new G4UIparameter("depth", 'd', omitable = true);
557  parameter->SetDefaultValue(0);
558  parameter->SetGuidance
559  ("Depth of propagation (-1 means unlimited depth).");
560  fpCommand->SetParameter(parameter);
561  parameter = new G4UIparameter("visibility", 'b', omitable = true);
562  parameter->SetDefaultValue(true);
563  fpCommand->SetParameter(parameter);
564 }
565 
567 {
568  delete fpCommand;
569 }
570 
572 {
573  return "";
574 }
575 
577 (G4UIcommand*, G4String newValue)
578 {
579  G4String name;
580  G4int requestedDepth;
581  G4String visibilityString;
582  std::istringstream iss(newValue);
583  iss >> name >> requestedDepth >> visibilityString;
584  G4bool visibility = G4UIcommand::ConvertToBool(visibilityString);
585 
586  G4VisCommandGeometrySetVisibilityFunction setVisibility(visibility);
587  Set(name, setVisibility, requestedDepth);
588 
589  G4VViewer* pViewer = fpVisManager->GetCurrentViewer();
590  if (pViewer) {
591  const G4ViewParameters& viewParams = pViewer->GetViewParameters();
592  if (fpVisManager->GetVerbosity() >= G4VisManager::warnings) {
593  if (!viewParams.IsCulling() ||
594  !viewParams.IsCullingInvisible()) {
595  G4cout <<
596  "Culling must be on - \"/vis/viewer/set/culling global true\" and"
597  "\n \"/vis/viewer/set/culling invisible true\" - to see effect."
598  << G4endl;
599  }
600  }
601  }
602 }
603 
605 (G4LogicalVolume* pLV, G4int requestedDepth,G4bool visibility)
606 {
607  if (!pLV) return;
608  G4VisCommandGeometrySetVisibilityFunction setVisibility(visibility);
609  SetLVVisAtts(pLV, setVisibility, 0, requestedDepth);
610 
611  G4VViewer* pViewer = fpVisManager->GetCurrentViewer();
612  if (pViewer) {
613  G4UImanager::GetUIpointer()->ApplyCommand("/vis/scene/notifyHandlers");
614  const G4ViewParameters& viewParams = pViewer->GetViewParameters();
615  if (fpVisManager->GetVerbosity() >= G4VisManager::warnings) {
616  if (!viewParams.IsCulling() ||
617  !viewParams.IsCullingInvisible()) {
618  G4cout <<
619  "Culling must be on - \"/vis/viewer/set/culling global true\" and"
620  "\n \"/vis/viewer/set/culling invisible true\" - to see effect."
621  << G4endl;
622  }
623  }
624  }
625 }
void SetGuidance(const char *aGuidance)
Definition: G4UIcommand.hh:161
const XML_Char * name
Definition: expat.h:151
G4LogicalVolume * GetLogicalVolume() const
void SetNewValue(G4UIcommand *command, G4String newValue)
G4int ApplyCommand(const char *aCommand)
Definition: G4UImanager.cc:466
#define G4endl
Definition: G4ios.hh:61
G4String GetCurrentValue(G4UIcommand *command)
G4int GetNoDaughters() const
static G4bool ConvertToBool(const char *st)
Definition: G4UIcommand.cc:439
const G4ViewParameters & GetViewParameters() const
void SetNewValueOnLV(G4LogicalVolume *pLV, G4int, G4bool)
Definition: test07.cc:36
void SetNewValue(G4UIcommand *command, G4String newValue)
void SetGuidance(const char *theGuidance)
void SetNewValue(G4UIcommand *command, G4String newValue)
static G4UImanager * GetUIpointer()
Definition: G4UImanager.cc:73
void SetNewValue(G4UIcommand *command, G4String newValue)
G4bool IsCulling() const
G4String GetCurrentValue(G4UIcommand *command)
void SetParameter(G4UIparameter *const newParameter)
Definition: G4UIcommand.hh:152
void SetDefaultValue(const char *theDefaultValue)
double G4double
Definition: G4Types.hh:76
bool G4bool
Definition: G4Types.hh:79
G4String GetCurrentValue(G4UIcommand *command)
void SetNewValue(G4UIcommand *command, G4String newValue)
const G4VisAttributes * GetVisAttributes() const
G4bool IsCullingInvisible() const
void SetVisAttributes(const G4VisAttributes *pVA)
G4String GetCurrentValue(G4UIcommand *command)
G4GLOB_DLL std::ostream G4cerr
void SetNewValue(G4UIcommand *command, G4String newValue)
void Set(G4String logVolName, const G4VVisCommandGeometrySetFunction &, G4int requestedDepth)
int G4int
Definition: G4Types.hh:78
void SetNewValue(G4UIcommand *command, G4String newValue)
void SetLVVisAtts(G4LogicalVolume *, const G4VVisCommandGeometrySetFunction &, G4int depth, G4int requestedDepth)
G4GLOB_DLL std::ostream G4cout
G4String GetCurrentValue(G4UIcommand *command)
void SetNewValue(G4UIcommand *command, G4String newValue)
void Set(G4int Elements, T *To, T Value)
Definition: G4ArrayOps.hh:51
void SetParameterCandidates(const char *theString)
G4String GetCurrentValue(G4UIcommand *command)
static G4LogicalVolumeStore * GetInstance()
G4VPhysicalVolume * GetDaughter(const G4int i) const
const G4String & GetName() const
void SetNewValue(G4UIcommand *command, G4String newValue)