Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/visualization/management/src/G4VisCommandsViewerSet.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

  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/viewer/set commands - John Allison  16th May 2000
 29 
 30 #include "G4VisCommandsViewerSet.hh"
 31 
 32 #include "G4UIcommand.hh"
 33 #include "G4UIcmdWithoutParameter.hh"
 34 #include "G4UIcmdWithAString.hh"
 35 #include "G4UIcmdWithABool.hh"
 36 #include "G4UIcmdWithAnInteger.hh"
 37 #include "G4UIcmdWithADouble.hh"
 38 #include "G4UIcmdWith3VectorAndUnit.hh"
 39 #include "G4UnitsTable.hh"
 40 #include "G4VisManager.hh"
 41 #include "G4Polyhedron.hh"
 42 #include "G4SystemOfUnits.hh"
 43 
 44 #include <sstream>
 45 #include <iomanip>
 46 #include <utility>
 47 
 48 #define G4warn G4cout
 49 
 50 G4VisCommandsViewerSet::G4VisCommandsViewerSet ():
 51 fLightsVector    (G4ThreeVector(1.,1.,1.)),
 52 fUpVector        (G4ThreeVector(0.,1.,0.)),
 53 fViewpointVector (G4ThreeVector(0.,0.,1.))
 54 {
 55   G4bool omitable;
 56   G4UIparameter* parameter;
 57 
 58   fpCommandAll = new G4UIcmdWithAString ("/vis/viewer/set/all",this);
 59   fpCommandAll->SetGuidance
 60   ("Copies view parameters.");
 61   fpCommandAll->SetGuidance
 62   ("Copies ALL view parameters (except the autoRefresh status) from"
 63    "\nfrom-viewer to current viewer. You may need \"/vis/viewer/rebuild\".");
 64   fpCommandAll->SetGuidance
 65   ("Note: to copy only the camera-specific parameters use"
 66    "\n\"/vis/viewer/copyfrom\".");
 67   fpCommandAll->SetParameterName ("from-viewer-name",omitable = false);
 68 
 69   fpCommandAutoRefresh = new G4UIcmdWithABool
 70   ("/vis/viewer/set/autoRefresh",this);
 71   fpCommandAutoRefresh->SetGuidance("Sets auto-refresh.");
 72   fpCommandAutoRefresh->SetGuidance
 73   ("If true, view is automatically refreshed after a change of"
 74    "\nview parameters.");
 75   fpCommandAutoRefresh->SetParameterName("auto-refresh",omitable = true);
 76   fpCommandAutoRefresh->SetDefaultValue(true);
 77 
 78   fpCommandAuxEdge = new G4UIcmdWithABool
 79   ("/vis/viewer/set/auxiliaryEdge",this);
 80   fpCommandAuxEdge->SetGuidance("Sets visibility of auxiliary edges");
 81   fpCommandAuxEdge->SetGuidance
 82   ("Auxiliary edges, i.e., those that are part of a curved surface,"
 83    "\nsometimes called soft edges, become visible/invisible.");
 84   fpCommandAuxEdge->SetParameterName("edge",omitable = true);
 85   fpCommandAuxEdge->SetDefaultValue(true);
 86 
 87   fpCommandBackground = new G4UIcommand
 88   ("/vis/viewer/set/background",this);
 89   fpCommandBackground->SetGuidance
 90   ("Set background colour and transparency (default black and opaque).");
 91   fpCommandBackground->SetGuidance(ConvertToColourGuidance());
 92   parameter = new G4UIparameter("red_or_string", 's', omitable = true);
 93   parameter -> SetDefaultValue ("0.");
 94   fpCommandBackground -> SetParameter (parameter);
 95   parameter = new G4UIparameter("green", 'd', omitable = true);
 96   parameter -> SetDefaultValue (0.);
 97   fpCommandBackground -> SetParameter (parameter);
 98   parameter = new G4UIparameter ("blue", 'd', omitable = true);
 99   parameter -> SetDefaultValue (0.);
100   fpCommandBackground -> SetParameter (parameter);
101   parameter = new G4UIparameter ("opacity", 'd', omitable = true);
102   parameter -> SetDefaultValue (1.);
103   fpCommandBackground -> SetParameter (parameter);
104 
105   fpCommandCulling = new G4UIcommand("/vis/viewer/set/culling",this);
106   fpCommandCulling->SetGuidance ("Set culling options.");
107   fpCommandCulling->SetGuidance
108   ("\"global\": enables/disables all other culling options.");
109   fpCommandCulling->SetGuidance
110   ("\"coveredDaughters\": culls, i.e., eliminates, volumes that would not"
111    "\nbe seen because covered by ancestor volumes in surface drawing mode,"
112    "\nand then only if the ancestors are visible and opaque, and then only"
113    "\nif no sections or cutaways are in operation.  Intended solely to"
114    "\nimprove the speed of rendering visible volumes.");
115   fpCommandCulling->SetGuidance
116   ("\"invisible\": culls objects with the invisible attribute set.");
117   fpCommandCulling->SetGuidance
118   ("\"density\": culls volumes with density lower than threshold.  Useful"
119    "\nfor eliminating \"container volumes\" with no physical correspondence,"
120    "\nwhose material is usually air.  If this is selected, provide threshold"
121    "\ndensity and unit (e.g., g/cm3, mg/cm3 or kg/m3)."
122    );
123   parameter = new G4UIparameter("culling-option",'s',omitable = false);
124   parameter->SetParameterCandidates
125   ("global coveredDaughters invisible density");
126   fpCommandCulling->SetParameter(parameter);
127   parameter = new G4UIparameter("action",'b',omitable = true);
128   parameter->SetDefaultValue(1);
129   fpCommandCulling->SetParameter(parameter);
130   parameter = new G4UIparameter("density-threshold",'d',omitable = true);
131   parameter->SetDefaultValue("0.01");
132   fpCommandCulling->SetParameter(parameter);
133   parameter = new G4UIparameter("unit",'s',omitable = true);
134   // parameter->SetParameterCandidates ("g/cm3 mg/cm3 kg/m3");
135   // Instead of the above, SetNewValue accepts *any* density unit.
136   parameter->SetDefaultValue("g/cm3");
137   fpCommandCulling->SetParameter(parameter);
138 
139   fpCommandCutawayMode =
140   new G4UIcmdWithAString ("/vis/viewer/set/cutawayMode", this);
141   fpCommandCutawayMode->SetGuidance
142   ("Sets cutaway mode - add (union) or multiply (intersection).");
143   fpCommandCutawayMode->SetParameterName ("cutaway-mode",omitable = false);
144   fpCommandCutawayMode->SetCandidates ("add union multiply intersection");
145   fpCommandCutawayMode->SetDefaultValue("union");
146 
147   fpCommandDefaultColour = new G4UIcommand
148   ("/vis/viewer/set/defaultColour",this);
149   fpCommandDefaultColour->SetGuidance
150   ("Set defaultColour colour and transparency (default white and opaque).");
151   fpCommandDefaultColour->SetGuidance(ConvertToColourGuidance());
152   parameter = new G4UIparameter("red_or_string", 's', omitable = true);
153   parameter -> SetDefaultValue ("1.");
154   fpCommandDefaultColour -> SetParameter (parameter);
155   parameter = new G4UIparameter("green", 'd', omitable = true);
156   parameter -> SetDefaultValue (1.);
157   fpCommandDefaultColour -> SetParameter (parameter);
158   parameter = new G4UIparameter ("blue", 'd', omitable = true);
159   parameter -> SetDefaultValue (1.);
160   fpCommandDefaultColour -> SetParameter (parameter);
161   parameter = new G4UIparameter ("opacity", 'd', omitable = true);
162   parameter -> SetDefaultValue (1.);
163   fpCommandDefaultColour -> SetParameter (parameter);
164 
165   fpCommandDefaultTextColour = new G4UIcommand
166   ("/vis/viewer/set/defaultTextColour",this);
167   fpCommandDefaultTextColour->SetGuidance
168   ("Set defaultTextColour colour and transparency (default blue and opaque).");
169   fpCommandDefaultTextColour->SetGuidance(ConvertToColourGuidance());
170   parameter = new G4UIparameter("red_or_string", 's', omitable = true);
171   parameter -> SetDefaultValue ("0.");
172   fpCommandDefaultTextColour -> SetParameter (parameter);
173   parameter = new G4UIparameter("green", 'd', omitable = true);
174   parameter -> SetDefaultValue (0.);
175   fpCommandDefaultTextColour -> SetParameter (parameter);
176   parameter = new G4UIparameter ("blue", 'd', omitable = true);
177   parameter -> SetDefaultValue (1.);
178   fpCommandDefaultTextColour -> SetParameter (parameter);
179   parameter = new G4UIparameter ("opacity", 'd', omitable = true);
180   parameter -> SetDefaultValue (1.);
181   fpCommandDefaultTextColour -> SetParameter (parameter);
182 
183   fpCommandEdge = new G4UIcmdWithABool("/vis/viewer/set/edge",this);
184   fpCommandEdge->SetGuidance
185   ("Edges become visible/invisible in surface mode.");
186   fpCommandEdge->SetParameterName("edge",omitable = true);
187   fpCommandEdge->SetDefaultValue(true);
188 
189   fpCommandExplodeFactor = new G4UIcommand
190   ("/vis/viewer/set/explodeFactor", this);
191   fpCommandExplodeFactor->SetGuidance
192   ("Moves top-level drawn volumes by this factor from this centre.");
193   parameter = new G4UIparameter("explodeFactor", 'd', omitable=true);
194   parameter->SetParameterRange("explodeFactor>=1.");
195   parameter->SetDefaultValue(1.);
196   fpCommandExplodeFactor->SetParameter(parameter);
197   parameter = new G4UIparameter("x",'d',omitable = true);
198   parameter->SetDefaultValue  (0);
199   parameter->SetGuidance      ("Coordinate of explode centre.");
200   fpCommandExplodeFactor->SetParameter(parameter);
201   parameter = new G4UIparameter("y",'d',omitable = true);
202   parameter->SetDefaultValue  (0);
203   parameter->SetGuidance      ("Coordinate of explode centre.");
204   fpCommandExplodeFactor->SetParameter(parameter);
205   parameter = new G4UIparameter("z",'d',omitable = true);
206   parameter->SetDefaultValue  (0);
207   parameter->SetGuidance      ("Coordinate of explode centre.");
208   fpCommandExplodeFactor->SetParameter(parameter);
209   parameter = new G4UIparameter("unit",'s',omitable = true);
210   parameter->SetDefaultValue  ("m");
211   parameter->SetGuidance      ("Unit of explode centre.");
212   fpCommandExplodeFactor->SetParameter(parameter);
213 
214   fpCommandGlobalLineWidthScale = new G4UIcmdWithADouble
215   ("/vis/viewer/set/globalLineWidthScale", this);
216   fpCommandGlobalLineWidthScale->SetGuidance
217   ("Multiplies line widths by this factor.");
218   fpCommandGlobalLineWidthScale->
219   SetParameterName("scale-factor", omitable=true);
220   fpCommandGlobalLineWidthScale->SetDefaultValue(1.);
221 
222   fpCommandGlobalMarkerScale = new G4UIcmdWithADouble
223   ("/vis/viewer/set/globalMarkerScale", this);
224   fpCommandGlobalMarkerScale->SetGuidance
225   ("Multiplies marker sizes by this factor.");
226   fpCommandGlobalMarkerScale->
227   SetParameterName("scale-factor", omitable=true);
228   fpCommandGlobalMarkerScale->SetDefaultValue(1.);
229 
230   fpCommandHiddenEdge =
231   new G4UIcmdWithABool("/vis/viewer/set/hiddenEdge",this);
232   fpCommandHiddenEdge->SetGuidance
233   ("Edges become hidden/seen in wireframe or surface mode.");
234   fpCommandHiddenEdge->SetParameterName("hidden-edge",omitable = true);
235   fpCommandHiddenEdge->SetDefaultValue(true);
236 
237   fpCommandHiddenMarker =
238   new G4UIcmdWithABool("/vis/viewer/set/hiddenMarker",this);
239   fpCommandHiddenMarker->SetGuidance
240   ("If true, closer objects hide markers. Otherwise, markers always show.");
241   fpCommandHiddenMarker->SetParameterName("hidden-marker",omitable = true);
242   fpCommandHiddenMarker->SetDefaultValue(true);
243 
244   fpCommandLightsMove = new G4UIcmdWithAString
245   ("/vis/viewer/set/lightsMove",this);
246   fpCommandLightsMove->SetGuidance
247   ("Lights move with camera or with object");
248   fpCommandLightsMove->SetParameterName("lightsMove",omitable = false);
249   fpCommandLightsMove->SetCandidates
250   ("cam camera with-camera obj object with-object");
251 
252   fpCommandLightsThetaPhi = new G4UIcommand
253   ("/vis/viewer/set/lightsThetaPhi", this);
254   fpCommandLightsThetaPhi->SetGuidance
255   ("Set direction from target to lights.");
256   parameter = new G4UIparameter("theta", 'd', omitable = true);
257   parameter -> SetDefaultValue(60.);
258   fpCommandLightsThetaPhi -> SetParameter (parameter);
259   parameter = new G4UIparameter("phi", 'd', omitable = true);
260   parameter -> SetDefaultValue(45.);
261   fpCommandLightsThetaPhi -> SetParameter (parameter);
262   parameter = new G4UIparameter ("unit", 's', omitable = true);
263   parameter -> SetDefaultValue ("deg");
264   fpCommandLightsThetaPhi -> SetParameter (parameter);
265 
266   fpCommandLightsVector = new G4UIcommand
267   ("/vis/viewer/set/lightsVector", this);
268   fpCommandLightsVector->SetGuidance
269   ("Set direction from target to lights.");
270   parameter = new G4UIparameter("x", 'd', omitable = true);
271   parameter -> SetDefaultValue (1);
272   fpCommandLightsVector -> SetParameter (parameter);
273   parameter = new G4UIparameter("y", 'd', omitable = true);
274   parameter -> SetDefaultValue (1);
275   fpCommandLightsVector -> SetParameter (parameter);
276   parameter = new G4UIparameter ("z", 'd', omitable = true);
277   parameter -> SetDefaultValue (1);
278   fpCommandLightsVector -> SetParameter (parameter);
279 
280   fpCommandLineSegments = new G4UIcmdWithAnInteger
281   ("/vis/viewer/set/lineSegmentsPerCircle",this);
282   fpCommandLineSegments->SetGuidance
283   ("Set number of sides per circle for polygon/polyhedron drawing.");
284   fpCommandLineSegments->SetGuidance
285   ("Refers to graphical representation of objects with curved lines/surfaces.");
286   fpCommandLineSegments->SetParameterName("line-segments",omitable = true);
287   fpCommandLineSegments->SetDefaultValue(24);
288 
289   fpCommandLineWidth = new G4UIcmdWithoutParameter
290   ("/vis/viewer/set/lineWidth",this);
291   fpCommandLineWidth->SetGuidance
292   ("Use \"/vis/viewer/set/globalLineWidthScale\" instead."
293    "\nFor trajectories use \"/vis/modeling/trajectories/*/default/setLineWidth\"."
294    "\nFor volumes use \"/vis/geometry/set/lineWidth\".");
295 
296   fpCommandNumberOfCloudPoints = new G4UIcmdWithAnInteger
297   ("/vis/viewer/set/numberOfCloudPoints",this);
298   fpCommandNumberOfCloudPoints->SetGuidance
299   ("Set number of points to be used for cloud representation of volumes.");
300   fpCommandNumberOfCloudPoints->SetParameterName("points",omitable = true);
301   fpCommandNumberOfCloudPoints->SetDefaultValue(10000);
302 
303   fpCommandPicking = new G4UIcmdWithABool
304   ("/vis/viewer/set/picking",this);
305   fpCommandPicking->SetGuidance("Sets picking, if available.");
306   fpCommandPicking->SetGuidance
307   ("If true, view is set up for picking, if available.");
308   fpCommandPicking->SetGuidance
309   ("You may need to issue \"/vis/viewer/update\".");
310   fpCommandPicking->SetGuidance
311   ("For required actions, watch for instructions for viewer.");
312   fpCommandPicking->SetParameterName("picking",omitable = true);
313   fpCommandPicking->SetDefaultValue(true);
314 
315   fpCommandProjection = new G4UIcommand("/vis/viewer/set/projection",this);
316   fpCommandProjection->SetGuidance
317   ("Set projection style - o[rthogonal] or p[erspective]."
318    "\nIf p[erspective], also set field half angle.");
319   parameter = new G4UIparameter("projection",'s',omitable = true);
320   parameter->SetParameterCandidates("o orthogonal p perspective");
321   parameter->SetDefaultValue("orthogonal");
322   fpCommandProjection->SetParameter(parameter);
323   parameter = new G4UIparameter("field-half-angle",'d',omitable = true);
324   parameter->SetDefaultValue(30.);
325   //parameter->SetCurrentAsDefault(true);
326   fpCommandProjection->SetParameter(parameter);
327   parameter = new G4UIparameter("unit",'s',omitable = true);
328   parameter->SetDefaultValue("deg");
329   //parameter->SetCurrentAsDefault(true);
330   fpCommandProjection->SetParameter(parameter);
331 
332   fpCommandRotationStyle = new G4UIcmdWithAString
333   ("/vis/viewer/set/rotationStyle",this);
334   fpCommandRotationStyle->SetGuidance
335   ("Set style of rotation - constrainUpDirection or freeRotation.");
336   fpCommandRotationStyle->SetGuidance
337   ("constrainUpDirection: conventional HEP view.");
338   fpCommandRotationStyle->SetGuidance
339   ("freeRotation: Google-like rotation, using mouse-grab.");
340   fpCommandRotationStyle->SetParameterName ("style",omitable = false);
341   fpCommandRotationStyle->SetCandidates("constrainUpDirection freeRotation");
342 
343   fpCommandSectionPlane = new G4UIcommand("/vis/viewer/set/sectionPlane",this);
344   fpCommandSectionPlane -> SetGuidance
345   ("Set plane for drawing section (DCUT).");
346   fpCommandSectionPlane -> SetGuidance
347   ("E.g., for a y-z plane at x = 1 cm:"
348    "\n\"/vis/viewer/set/sectionPlane on 1 0 0 cm 1 0 0\"."
349    "\nTo turn off: /vis/viewer/set/sectionPlane off");
350   parameter  =  new G4UIparameter("Selector",'c',true);
351   parameter  -> SetDefaultValue  ("on");
352   fpCommandSectionPlane->SetParameter(parameter);
353   parameter  =  new G4UIparameter("x",'d',omitable = true);
354   parameter  -> SetDefaultValue  (0);
355   parameter  -> SetGuidance      ("Coordinate of point on the plane.");
356   fpCommandSectionPlane->SetParameter(parameter);
357   parameter  =  new G4UIparameter("y",'d',omitable = true);
358   parameter  -> SetDefaultValue  (0);
359   parameter  -> SetGuidance      ("Coordinate of point on the plane.");
360   fpCommandSectionPlane->SetParameter(parameter);
361   parameter  =  new G4UIparameter("z",'d',omitable = true);
362   parameter  -> SetDefaultValue  (0);
363   parameter  -> SetGuidance      ("Coordinate of point on the plane.");
364   fpCommandSectionPlane->SetParameter(parameter);
365   parameter  =  new G4UIparameter("unit",'s',omitable = true);
366   parameter  -> SetDefaultValue  ("m");
367   parameter  -> SetGuidance      ("Unit of point on the plane.");
368   fpCommandSectionPlane->SetParameter(parameter);
369   parameter  =  new G4UIparameter("nx",'d',omitable = true);
370   parameter  -> SetDefaultValue  (1);
371   parameter  -> SetGuidance      ("Component of plane normal.");
372   fpCommandSectionPlane->SetParameter(parameter);
373   parameter  =  new G4UIparameter("ny",'d',omitable = true);
374   parameter  -> SetDefaultValue  (0);
375   parameter  -> SetGuidance      ("Component of plane normal.");
376   fpCommandSectionPlane->SetParameter(parameter);
377   parameter  =  new G4UIparameter("nz",'d',omitable = true);
378   parameter  -> SetDefaultValue  (0);
379   parameter  -> SetGuidance      ("Component of plane normal.");
380   fpCommandSectionPlane->SetParameter(parameter);
381 
382   fpCommandSpecialMeshRendering = new G4UIcmdWithABool
383   ("/vis/viewer/set/specialMeshRendering",this);
384   fpCommandSpecialMeshRendering -> SetGuidance
385   ("Request special rendering of volumes (meshes) that use G4VParameterisation.");
386   fpCommandSpecialMeshRendering->SetParameterName("render",omitable = true);
387   fpCommandSpecialMeshRendering->SetDefaultValue(true);
388 
389   fpCommandSpecialMeshRenderingOption = new G4UIcmdWithAString
390   ("/vis/viewer/set/specialMeshRenderingOption",this);
391   fpCommandSpecialMeshRenderingOption->SetGuidance
392   ("Set special mesh rendering option - \"default\", \"dots\" or \"surfaces\".");
393   fpCommandSpecialMeshRenderingOption->SetParameterName ("option",omitable = true);
394   fpCommandSpecialMeshRenderingOption->SetCandidates("default dots surfaces");
395   fpCommandSpecialMeshRenderingOption->SetDefaultValue("default");
396 
397   fpCommandSpecialMeshVolumes = new G4UIcommand
398   ("/vis/viewer/set/specialMeshVolumes",this);
399   fpCommandSpecialMeshVolumes -> SetGuidance
400   ("Specify the volumes for special rendering. No arguments resets the list"
401    "\nand is interpreted to mean \"all found meshes\".");
402   fpCommandSpecialMeshVolumes->SetGuidance
403   ("Please provide a list of space-separated physical volume names and copy"
404    "\nnumber pairs. Negative copy number means \"all volumes of that name\".");
405   parameter = new G4UIparameter("volumes",'s',omitable = true);
406   parameter->SetGuidance
407   ("List of physical volume names and copy number pairs");
408   fpCommandSpecialMeshVolumes->SetParameter(parameter);
409 
410   fpCommandStyle = new G4UIcmdWithAString ("/vis/viewer/set/style",this);
411   fpCommandStyle->SetGuidance
412   ("Set style of drawing - w[ireframe] or s[urface] or c[loud].");
413   fpCommandStyle->SetGuidance
414   ("(Hidden line drawing is controlled by \"/vis/viewer/set/hiddenEdge\".)");
415   fpCommandStyle->SetParameterName ("style",omitable = false);
416   fpCommandStyle->SetCandidates("w wireframe s surface c cloud");
417 
418   fpCommandTargetPoint = new G4UIcmdWith3VectorAndUnit
419   ("/vis/viewer/set/targetPoint", this);
420   fpCommandTargetPoint->SetGuidance
421   ("Set target point.");
422   fpCommandTargetPoint->SetGuidance
423   ("This sets the \"Current Target Point\" relative to the \"Standard");
424   fpCommandTargetPoint->SetGuidance
425   ("Target Point\" so that the actual target point is as requested.");
426   fpCommandTargetPoint->SetGuidance
427   ("(See G4ViewParameters.hh for an explanation of target points.)");
428   fpCommandTargetPoint->SetParameterName("x", "y", "z", omitable = false);
429   fpCommandTargetPoint->SetUnitCategory("Length");
430 
431   fpCommandUpThetaPhi = new G4UIcommand
432   ("/vis/viewer/set/upThetaPhi", this);
433   fpCommandUpThetaPhi -> SetGuidance ("Set up vector.");
434   fpCommandUpThetaPhi -> SetGuidance
435   ("Viewer will attempt always to show this direction upwards.");
436   parameter = new G4UIparameter("theta", 'd', omitable = true);
437   parameter -> SetDefaultValue (90.);
438   fpCommandUpThetaPhi -> SetParameter (parameter);
439   parameter = new G4UIparameter("phi", 'd', omitable = true);
440   parameter -> SetDefaultValue (90.);
441   fpCommandUpThetaPhi -> SetParameter (parameter);
442   parameter = new G4UIparameter ("unit", 's', omitable = true);
443   parameter -> SetDefaultValue ("deg");
444   fpCommandUpThetaPhi -> SetParameter (parameter);
445 
446   fpCommandUpVector = new G4UIcommand
447   ("/vis/viewer/set/upVector", this);
448   fpCommandUpVector -> SetGuidance ("Set up vector.");
449   fpCommandUpVector -> SetGuidance
450   ("Viewer will attempt always to show this direction upwards.");
451   parameter = new G4UIparameter("x", 'd', omitable = true);
452   parameter -> SetDefaultValue (0.);
453   fpCommandUpVector -> SetParameter (parameter);
454   parameter = new G4UIparameter("y", 'd', omitable = true);
455   parameter -> SetDefaultValue (1.);
456   fpCommandUpVector -> SetParameter (parameter);
457   parameter = new G4UIparameter ("z", 'd', omitable = true);
458   parameter -> SetDefaultValue (0.);
459   fpCommandUpVector -> SetParameter (parameter);
460 
461   fpCommandViewpointThetaPhi = new G4UIcommand
462   ("/vis/viewer/set/viewpointThetaPhi", this);
463   fpCommandViewpointThetaPhi -> SetGuidance
464   ("Set direction from target to camera.");
465   fpCommandViewpointThetaPhi -> SetGuidance
466   ("Also changes lightpoint direction if lights are set to move with camera.");
467   parameter = new G4UIparameter("theta", 'd', omitable = true);
468   parameter -> SetDefaultValue (60.);
469   fpCommandViewpointThetaPhi -> SetParameter (parameter);
470   parameter = new G4UIparameter("phi", 'd', omitable = true);
471   parameter -> SetDefaultValue (45.);
472   fpCommandViewpointThetaPhi -> SetParameter (parameter);
473   parameter = new G4UIparameter ("unit", 's', omitable = true);
474   parameter -> SetDefaultValue ("deg");
475   fpCommandViewpointThetaPhi -> SetParameter (parameter);
476 
477   fpCommandViewpointVector = new G4UIcommand
478   ("/vis/viewer/set/viewpointVector", this);
479   fpCommandViewpointVector -> SetGuidance
480   ("Set direction from target to camera.");
481   fpCommandViewpointVector -> SetGuidance
482   ("Also changes lightpoint direction if lights are set to move with camera.");
483   parameter = new G4UIparameter("x", 'd', omitable = true);
484   parameter -> SetDefaultValue (1.);
485   fpCommandViewpointVector -> SetParameter (parameter);
486   parameter = new G4UIparameter("y", 'd', omitable = true);
487   parameter -> SetDefaultValue (1.);
488   fpCommandViewpointVector -> SetParameter (parameter);
489   parameter = new G4UIparameter ("z", 'd', omitable = true);
490   parameter -> SetDefaultValue (1.);
491   fpCommandViewpointVector -> SetParameter (parameter);
492 
493   fpTimeWindowDirectory = new G4UIdirectory ("/vis/viewer/set/timeWindow/");
494   fpTimeWindowDirectory -> SetGuidance ("Set time window parameters of current viewer.");
495   G4String timeWindowGuidance =
496   "For these commands use"
497   "\n  /vis/scene/add/trajectories rich"
498   "\n  /vis/modeling/trajectories/drawByCharge-0/default/setTimeSliceInterval 0.01 ns"
499   "\nthen typically"
500   "\n  /vis/viewer/set/timeWindow/displayLightFront true 0 0 -50 cm -0.5 ns"
501   "\n  /vis/viewer/set/timeWindow/displayHeadTime true"
502   "\n  /vis/viewer/set/timeWindow/fadeFactor 1"
503   "\n  /run/beamOn # or several until you get a good event or events"
504   "\n  /vis/viewer/set/timeWindow/startTime 0 ns 1 ns"
505   "\n  /vis/viewer/save"
506   "\n  /vis/viewer/set/timeWindow/startTime 1 ns 1 ns"
507   "\nthen zoom, pan etc to a view of interest and"
508   "\n  /vis/viewer/save"
509   "\nthen repeat with next start time, another view and a save, then try"
510   "\n  /vis/viewer/interpolate";
511 
512   fpCommandTimeWindowDisplayHeadTime =
513   new G4UIcommand("/vis/viewer/set/timeWindow/displayHeadTime", this);
514   fpCommandTimeWindowDisplayHeadTime->SetGuidance
515   ("Display head time of range in 2D text.");
516   fpCommandTimeWindowDisplayHeadTime->SetGuidance(timeWindowGuidance);
517   parameter = new G4UIparameter ("displayHeadTime", 'b', omitable = false);
518   parameter->SetDefaultValue(false);
519   fpCommandTimeWindowDisplayHeadTime->SetParameter(parameter);
520   parameter = new G4UIparameter ("screenX", 'd', omitable = true);
521   parameter->SetGuidance("-1 < screenX < 1");
522   parameter->SetParameterRange("screenX >= -1. && screenX <= 1.");
523   parameter->SetDefaultValue(-0.9);
524   fpCommandTimeWindowDisplayHeadTime->SetParameter(parameter);
525   parameter = new G4UIparameter ("screenY", 'd', omitable = true);
526   parameter->SetGuidance("-1 < screenY < 1");
527   parameter->SetParameterRange("screenY >= -1. && screenY <= 1.");
528   parameter->SetDefaultValue(-0.9);
529   fpCommandTimeWindowDisplayHeadTime->SetParameter(parameter);
530   parameter = new G4UIparameter ("screenSize", 'd', omitable = true);
531   parameter->SetDefaultValue(24.);
532   fpCommandTimeWindowDisplayHeadTime->SetParameter(parameter);
533   parameter = new G4UIparameter ("red", 'd', omitable = true);
534   parameter->SetParameterRange("red >= 0. && red <= 1.");
535   parameter->SetDefaultValue(0.);
536   fpCommandTimeWindowDisplayHeadTime->SetParameter(parameter);
537   parameter = new G4UIparameter ("green", 'd', omitable = true);
538   parameter->SetParameterRange("green >= 0. && green <= 1.");
539   parameter->SetDefaultValue(1.);
540   fpCommandTimeWindowDisplayHeadTime->SetParameter(parameter);
541   parameter = new G4UIparameter ("blue", 'd', omitable = true);
542   parameter->SetParameterRange("blue >= 0. && blue <= 1.");
543   parameter->SetDefaultValue(1.);
544   fpCommandTimeWindowDisplayHeadTime->SetParameter(parameter);
545 
546   fpCommandTimeWindowDisplayLightFront =
547   new G4UIcommand("/vis/viewer/set/timeWindow/displayLightFront", this);
548   fpCommandTimeWindowDisplayLightFront->SetGuidance
549   ("Display the light front at head time.");
550   fpCommandTimeWindowDisplayLightFront->SetGuidance
551   ("Tip: The trajectories can appear of jump ahead of the light front"
552    "\nbecause their time range overlaps the viewer's time range.  To"
553    "\naverage out this discrete time effect, advance the light front by"
554    "\nhalf the trajectories interval. E.g., if the trajectory time slice"
555    "\ninterval is 0.01 ns:"
556    "\n  /vis/viewer/set/timeWindow/displayLightFront true -90 0 0 mm -0.005 ns"
557    "\nTo prevent them beating the light front at all:"
558    "\n  /vis/viewer/set/timeWindow/displayLightFront true -90 0 0 mm -0.01 ns");
559   fpCommandTimeWindowDisplayLightFront->SetGuidance(timeWindowGuidance);
560   parameter = new G4UIparameter ("displayLightFront", 'b', omitable = true);
561   parameter->SetDefaultValue(true);
562   fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
563   parameter = new G4UIparameter ("originX", 'd', omitable = true);
564   parameter->SetDefaultValue(0.);
565   fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
566   parameter = new G4UIparameter ("originY", 'd', omitable = true);
567   parameter->SetDefaultValue(0.);
568   fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
569   parameter = new G4UIparameter ("originZ", 'd', omitable = true);
570   parameter->SetDefaultValue(0.);
571   fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
572   parameter = new G4UIparameter ("space_unit", 's', omitable = true);
573   parameter->SetDefaultValue("m");
574   fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
575   parameter = new G4UIparameter ("originT", 'd', omitable = true);
576   parameter->SetDefaultValue(0.);
577   fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
578   parameter = new G4UIparameter ("time_unit", 's', omitable = true);
579   parameter->SetDefaultValue("s");
580   fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
581   parameter = new G4UIparameter ("red", 'd', omitable = true);
582   parameter->SetParameterRange("red >= 0. && red <= 1.");
583   parameter->SetDefaultValue(0.);
584   fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
585   parameter = new G4UIparameter ("green", 'd', omitable = true);
586   parameter->SetParameterRange("green >= 0. && green <= 1.");
587   parameter->SetDefaultValue(1.);
588   fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
589   parameter = new G4UIparameter ("blue", 'd', omitable = true);
590   parameter->SetParameterRange("blue >= 0. && blue <= 1.");
591   parameter->SetDefaultValue(0.);
592   fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
593 
594   fpCommandTimeWindowEndTime =
595   new G4UIcommand("/vis/viewer/set/timeWindow/endTime", this);
596   fpCommandTimeWindowEndTime->SetGuidance("Set end and range of track time.");
597   fpCommandTimeWindowEndTime->SetGuidance(timeWindowGuidance);
598   parameter = new G4UIparameter ("end-time", 'd', omitable = false);
599   parameter->SetDefaultValue(G4VisAttributes::fVeryLongTime);
600   fpCommandTimeWindowEndTime->SetParameter(parameter);
601   parameter = new G4UIparameter ("end-time-unit", 's', omitable = false);
602   parameter->SetDefaultValue("ns");
603   fpCommandTimeWindowEndTime->SetParameter(parameter);
604   parameter = new G4UIparameter ("time-range", 'd', omitable = true);
605   parameter->SetDefaultValue(-1.);
606   fpCommandTimeWindowEndTime->SetParameter(parameter);
607   parameter = new G4UIparameter ("time-range-unit", 's', omitable = true);
608   parameter->SetDefaultValue("ns");
609   fpCommandTimeWindowEndTime->SetParameter(parameter);
610 
611   fpCommandTimeWindowFadeFactor =
612   new G4UIcmdWithADouble("/vis/viewer/set/timeWindow/fadeFactor", this);
613   fpCommandTimeWindowFadeFactor->SetGuidance
614   ("0: no fade; 1: maximum fade with time window.");
615   fpCommandTimeWindowFadeFactor->SetGuidance(timeWindowGuidance);
616   fpCommandTimeWindowFadeFactor->SetParameterName("fade_factor", omitable = false);
617   fpCommandTimeWindowFadeFactor->SetRange("fade_factor>=0.&&fade_factor<=1.");
618   fpCommandTimeWindowFadeFactor->SetDefaultValue(0.);
619 
620   fpCommandTimeWindowStartTime =
621   new G4UIcommand("/vis/viewer/set/timeWindow/startTime", this);
622   fpCommandTimeWindowStartTime->SetGuidance("Set start and range of track time.");
623   fpCommandTimeWindowStartTime->SetGuidance(timeWindowGuidance);
624   parameter = new G4UIparameter ("start-time", 'd', omitable = false);
625   parameter->SetDefaultValue(-G4VisAttributes::fVeryLongTime);
626   fpCommandTimeWindowStartTime->SetParameter(parameter);
627   parameter = new G4UIparameter ("start-time-unit", 's', omitable = false);
628   parameter->SetDefaultValue("ns");
629   fpCommandTimeWindowStartTime->SetParameter(parameter);
630   parameter = new G4UIparameter ("time-range", 'd', omitable = true);
631   parameter->SetDefaultValue(-1.);
632   fpCommandTimeWindowStartTime->SetParameter(parameter);
633   parameter = new G4UIparameter ("time-range-unit", 's', omitable = true);
634   parameter->SetDefaultValue("ns");
635   fpCommandTimeWindowStartTime->SetParameter(parameter);
636 }
637 
638 G4VisCommandsViewerSet::~G4VisCommandsViewerSet() {
639   delete fpCommandTimeWindowStartTime;
640   delete fpCommandTimeWindowFadeFactor;
641   delete fpCommandTimeWindowEndTime;
642   delete fpCommandTimeWindowDisplayLightFront;
643   delete fpCommandTimeWindowDisplayHeadTime;
644   delete fpTimeWindowDirectory;
645   delete fpCommandViewpointVector;
646   delete fpCommandViewpointThetaPhi;
647   delete fpCommandUpVector;
648   delete fpCommandUpThetaPhi;
649   delete fpCommandTargetPoint;
650   delete fpCommandStyle;
651   delete fpCommandSpecialMeshVolumes;
652   delete fpCommandSpecialMeshRenderingOption;
653   delete fpCommandSpecialMeshRendering;
654   delete fpCommandSectionPlane;
655   delete fpCommandRotationStyle;
656   delete fpCommandProjection;
657   delete fpCommandPicking;
658   delete fpCommandNumberOfCloudPoints;
659   delete fpCommandLineWidth;
660   delete fpCommandLineSegments;
661   delete fpCommandLightsVector;
662   delete fpCommandLightsThetaPhi;
663   delete fpCommandLightsMove;
664   delete fpCommandHiddenMarker;
665   delete fpCommandHiddenEdge;
666   delete fpCommandGlobalMarkerScale;
667   delete fpCommandGlobalLineWidthScale;
668   delete fpCommandExplodeFactor;
669   delete fpCommandEdge;
670   delete fpCommandDefaultTextColour;
671   delete fpCommandDefaultColour;
672   delete fpCommandCutawayMode;
673   delete fpCommandCulling;
674   delete fpCommandBackground;
675   delete fpCommandAuxEdge;
676   delete fpCommandAutoRefresh;
677   delete fpCommandAll;
678 }
679 
680 G4String G4VisCommandsViewerSet::GetCurrentValue(G4UIcommand*) {
681   return "";
682 }
683 
684 void G4VisCommandsViewerSet::SetNewValue
685 (G4UIcommand* command,G4String newValue) {
686 
687   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
688 
689   G4VViewer* currentViewer = fpVisManager->GetCurrentViewer();
690   if (!currentViewer) {
691     if (verbosity >= G4VisManager::errors) {
692       G4warn <<
693       "ERROR: G4VisCommandsViewerSet::SetNewValue: no current viewer."
694       << G4endl;
695     }
696     return;
697   }
698 
699   G4ViewParameters vp = currentViewer->GetViewParameters();
700 
701   if (command == fpCommandAll) {
702     G4VViewer* fromViewer = fpVisManager->GetViewer(newValue);
703     if (!fromViewer) {
704       if (verbosity >= G4VisManager::errors) {
705         G4warn <<
706         "ERROR: G4VisCommandsViewerSet::SetNewValue: all:"
707         "\n  unrecognised from-viewer."
708         << G4endl;
709       }
710       return;
711     }
712     if (fromViewer == currentViewer) {
713       if (verbosity >= G4VisManager::warnings) {
714         G4warn <<
715         "WARNING: G4VisCommandsViewerSet::SetNewValue: all:"
716         "\n  from-viewer and current viewer are identical."
717         << G4endl;
718       }
719       return;
720     }
721     // Copy view parameters except for autoRefresh and background...
722     auto keepAutoRefresh = vp.IsAutoRefresh();
723     auto keepBackground  = vp.GetBackgroundColour();
724     vp = fromViewer->GetViewParameters();
725     vp.SetAutoRefresh(keepAutoRefresh);
726     vp.SetBackgroundColour(keepBackground);
727     // Concatenate any private vis attributes modifiers...
728     const std::vector<G4ModelingParameters::VisAttributesModifier>*
729     privateVAMs = fromViewer->GetPrivateVisAttributesModifiers();
730     if (privateVAMs) {
731       std::vector<G4ModelingParameters::VisAttributesModifier>::const_iterator i;
732       for (i = privateVAMs->begin(); i != privateVAMs->end(); ++i) {
733         vp.AddVisAttributesModifier(*i);
734       }
735     }
736     if (verbosity >= G4VisManager::confirmations) {
737       G4cout << "View parameters of viewer \"" << currentViewer->GetName()
738       << "\"\n  set to those of viewer \"" << fromViewer->GetName()
739       << "\"."
740       << G4endl;
741     }
742     if (verbosity >= G4VisManager::warnings) {
743       G4warn << "You may need \"/vis/viewer/rebuild\"."
744       << G4endl;
745     }
746   }
747 
748   else if (command == fpCommandAutoRefresh) {
749     G4bool autoRefresh = G4UIcommand::ConvertToBool(newValue);
750     const G4ViewParameters& defaultVP =
751     currentViewer->GetDefaultViewParameters();
752     if (autoRefresh && !defaultVP.IsAutoRefresh()) {
753       if (verbosity >= G4VisManager::warnings) {
754         G4warn
755         << "WARNING: "
756         << currentViewer->GetName() << " is NOT auto-refesh by default"
757         << "\n  so cannot be set to auto-refresh."
758         << G4endl;
759       }
760       return;
761     }
762     vp.SetAutoRefresh(autoRefresh);
763     if (verbosity >= G4VisManager::confirmations) {
764       G4cout << "Views will ";
765       if (!vp.IsAutoRefresh()) G4cout << "not ";
766       G4cout << "be automatically refreshed after a change of view parameters."
767       << G4endl;
768     }
769     if (!vp.IsAutoRefresh()) {
770       currentViewer->SetViewParameters(vp);
771       return;  // Avoid a refresh if auto-refresh has been set to off...
772     }  // ...otherwise take normal action.
773   }
774 
775   else if (command == fpCommandAuxEdge) {
776     vp.SetAuxEdgeVisible(G4UIcommand::ConvertToBool(newValue));
777     if (verbosity >= G4VisManager::confirmations) {
778       G4cout << "Auxiliary edges will ";
779       if (!vp.IsAuxEdgeVisible()) G4cout << "not ";
780       G4cout << "be visible." << G4endl;
781     }
782   }
783 
784   else if (command == fpCommandBackground) {
785     G4String redOrString;
786     G4double green, blue, opacity;
787     std::istringstream iss(newValue);
788     iss >> redOrString >> green >> blue >> opacity;
789     G4Colour colour(0.,0.,0.);  // Default black and opaque.
790     ConvertToColour(colour, redOrString, green, blue, opacity);
791     vp.SetBackgroundColour(colour);
792     if (verbosity >= G4VisManager::confirmations) {
793       G4cout << "Background colour "
794       << vp.GetBackgroundColour()
795       << " requested."
796       << G4endl;
797     }
798   }
799 
800   else if (command == fpCommandCulling) {
801     G4String cullingOption, stringFlag, unit;
802     G4double density;
803     std::istringstream is (newValue);
804     is >> cullingOption >> stringFlag >> density >> unit;
805     G4bool boolFlag = G4UIcommand::ConvertToBool(stringFlag);
806     if (cullingOption == "global") {
807       vp.SetCulling(boolFlag);
808       if (verbosity >= G4VisManager::confirmations) {
809         G4cout <<
810         "G4VisCommandsViewerSet::SetNewValue: culling: global culling flag"
811         " set to " << G4UIcommand::ConvertToString(boolFlag) <<
812         ".\n  Does not change specific culling flags."
813         << G4endl;
814       }
815     }
816     else if (cullingOption == "coveredDaughters") {
817       vp.SetCullingCovered(boolFlag);
818       if (verbosity >= G4VisManager::confirmations) {
819         G4cout <<
820         "G4VisCommandsViewerSet::SetNewValue: culling: culling covered"
821         "\n  daughters flag set to "
822         << G4UIcommand::ConvertToString(boolFlag) <<
823         ".  Daughters covered by opaque mothers"
824         "\n  will be culled, i.e., not drawn, if this flag is true."
825         "\n  Note: this is only effective in surface drawing style,"
826         "\n  and then only if the volumes are visible and opaque, and then"
827         "\n  only if no sections or cutaways are in operation."
828         << G4endl;
829       }
830     }
831     else if (cullingOption == "invisible") {
832       vp.SetCullingInvisible(boolFlag);
833       if (verbosity >= G4VisManager::confirmations) {
834         G4cout <<
835         "G4VisCommandsViewerSet::SetNewValue: culling: culling invisible"
836         "\n  flag set to "
837         << boolFlag << G4UIcommand::ConvertToString(boolFlag) <<
838         ".  Volumes marked invisible will be culled,"
839         "\n  i.e., not drawn, if this flag is true."
840         << G4endl;
841       }
842     }
843     else if (cullingOption == "density") {
844       const G4String where =
845       "G4VisCommandsViewerSet::SetNewValue: culling: culling by density";
846       if (boolFlag) {
847         G4double valueOfUnit;
848         // "Volumic Mass" is Michel's phrase for "Density"
849         if (ProvideValueOfUnit(where,unit,"Volumic Mass",valueOfUnit)) {
850           // Successful outcome of unit search
851           vp.SetDensityCulling(boolFlag);
852           density *= valueOfUnit;
853           vp.SetVisibleDensity(density);
854         } else {
855           // Unsuccessful outcome of unit search. Flag and density unchanged.
856           density = vp.GetVisibleDensity();
857         }
858       } else {  // Reset flag but density unchanged.
859         vp.SetDensityCulling(boolFlag);
860       }
861       if (verbosity >= G4VisManager::confirmations) {
862         G4cout
863         << where
864         << "\n  flag set to "
865         << std::boolalpha << vp.IsDensityCulling()
866         << ".  Volumes with density less than "
867         << G4BestUnit(density,"Volumic Mass")
868         << "\n  will be culled, i.e., not drawn, if this flag is true."
869         << G4endl;
870       }
871     }
872     else {
873       if (verbosity >= G4VisManager::errors) {
874         G4warn <<
875         "ERROR: G4VisCommandsViewerSet::SetNewValue: culling:"
876         "\n  option not recognised."
877         << G4endl;
878       }
879     }
880   }
881 
882   else if (command == fpCommandCutawayMode) {
883     if (newValue == "add" || newValue == "union")
884       vp.SetCutawayMode(G4ViewParameters::cutawayUnion);
885     if (newValue == "multiply" || newValue == "intersection")
886       vp.SetCutawayMode(G4ViewParameters::cutawayIntersection);
887 
888     if (verbosity >= G4VisManager::confirmations) {
889       G4cout << "Cutaway mode set to ";
890       if (vp.GetCutawayMode() == G4ViewParameters::cutawayUnion)
891         G4cout << "cutawayUnion";
892       if (vp.GetCutawayMode() == G4ViewParameters::cutawayIntersection)
893         G4cout << "cutawayIntersection";
894       G4cout << G4endl;
895     }
896   }
897 
898   else if (command == fpCommandDefaultColour) {
899     G4String redOrString;
900     G4double green, blue, opacity;
901     std::istringstream iss(newValue);
902     iss >> redOrString >> green >> blue >> opacity;
903     G4Colour colour(1.,1.,1.);  // Default white and opaque.
904     ConvertToColour(colour, redOrString, green, blue, opacity);
905     G4VisAttributes va = vp.GetDefaultVisAttributes();
906     va.SetColour(colour);
907     vp.SetDefaultVisAttributes(va);
908     if (verbosity >= G4VisManager::confirmations) {
909       G4cout << "Default colour "
910       << vp.GetDefaultVisAttributes()->GetColour()
911       << " requested."
912       << G4endl;
913     }
914   }
915 
916   else if (command == fpCommandDefaultTextColour) {
917     G4String redOrString;
918     G4double green, blue, opacity;
919     std::istringstream iss(newValue);
920     iss >> redOrString >> green >> blue >> opacity;
921     G4Colour colour(1.,1.,1.);  // Default white and opaque.
922     ConvertToColour(colour, redOrString, green, blue, opacity);
923     G4VisAttributes va = vp.GetDefaultTextVisAttributes();
924     va.SetColour(colour);
925     vp.SetDefaultTextVisAttributes(va);
926     if (verbosity >= G4VisManager::confirmations) {
927       G4cout << "Default colour "
928       << vp.GetDefaultTextVisAttributes()->GetColour()
929       << " requested."
930       << G4endl;
931     }
932   }
933 
934   else if (command == fpCommandEdge) {
935     G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle();
936     if (G4UIcommand::ConvertToBool(newValue)) {  // true
937       switch (existingStyle) {
938         case G4ViewParameters::wireframe:
939           break;
940         case G4ViewParameters::hlr:
941           break;
942         case G4ViewParameters::hsr:
943           vp.SetDrawingStyle(G4ViewParameters::hlhsr);
944           break;
945         case G4ViewParameters::hlhsr:
946           break;
947         case G4ViewParameters::cloud:
948           break;
949       }
950     }
951     else {  // false
952       switch (existingStyle) {
953         case G4ViewParameters::wireframe:
954           break;
955         case G4ViewParameters::hlr:
956           break;
957         case G4ViewParameters::hsr:
958           break;
959         case G4ViewParameters::hlhsr:
960           vp.SetDrawingStyle(G4ViewParameters::hsr);
961           break;
962         case G4ViewParameters::cloud:
963           break;
964       }
965     }
966     if (verbosity >= G4VisManager::confirmations) {
967       G4cout << "Drawing style of viewer \"" << currentViewer->GetName()
968       << "\" set to " << vp.GetDrawingStyle()
969       << G4endl;
970     }
971   }
972 
973   else if (command == fpCommandExplodeFactor) {
974     G4double explodeFactor, x, y, z;
975     G4String unitString;
976     std::istringstream is (newValue);
977     is >> explodeFactor >> x >> y >> z >> unitString;
978     G4double unit = G4UIcommand::ValueOf(unitString);
979     vp.SetExplodeFactor(explodeFactor);
980     vp.SetExplodeCentre(G4Point3D(x * unit, y * unit, z * unit));
981     if (verbosity >= G4VisManager::confirmations) {
982       G4cout << "Explode factor changed to " << vp.GetExplodeFactor()
983       << " from centre " << vp.GetExplodeCentre()
984       << G4endl;
985     }
986   }
987 
988   else if (command == fpCommandGlobalLineWidthScale) {
989     G4double globalLineWidthScale
990     = fpCommandGlobalLineWidthScale->GetNewDoubleValue(newValue);
991     vp.SetGlobalLineWidthScale(globalLineWidthScale);
992     if (verbosity >= G4VisManager::confirmations) {
993       G4cout << "Global Line Width Scale changed to "
994       << vp.GetGlobalLineWidthScale() << G4endl;
995     }
996   }
997 
998   else if (command == fpCommandGlobalMarkerScale) {
999     G4double globalMarkerScale
1000     = fpCommandGlobalMarkerScale->GetNewDoubleValue(newValue);
1001     vp.SetGlobalMarkerScale(globalMarkerScale);
1002     if (verbosity >= G4VisManager::confirmations) {
1003       G4cout << "Global Marker Scale changed to "
1004       << vp.GetGlobalMarkerScale() << G4endl;
1005     }
1006   }
1007 
1008   else if (command == fpCommandHiddenEdge) {
1009     G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle();
1010     if (G4UIcommand::ConvertToBool(newValue)) {
1011       switch (existingStyle) {
1012         case G4ViewParameters::wireframe:
1013           vp.SetDrawingStyle(G4ViewParameters::hlr);
1014           break;
1015         case G4ViewParameters::hlr:
1016           break;
1017         case G4ViewParameters::hsr:
1018           vp.SetDrawingStyle(G4ViewParameters::hlhsr);
1019           break;
1020         case G4ViewParameters::hlhsr:
1021           break;
1022         case G4ViewParameters::cloud:
1023           break;
1024       }
1025     }
1026     else {
1027       switch (existingStyle) {
1028         case G4ViewParameters::wireframe:
1029           break;
1030         case G4ViewParameters::hlr:
1031           vp.SetDrawingStyle(G4ViewParameters::wireframe);
1032           break;
1033         case G4ViewParameters::hsr:
1034           break;
1035         case G4ViewParameters::hlhsr:
1036           vp.SetDrawingStyle(G4ViewParameters::hsr);
1037           break;
1038         case G4ViewParameters::cloud:
1039           break;
1040       }
1041     }
1042     if (verbosity >= G4VisManager::confirmations) {
1043       G4cout << "Drawing style of viewer \"" << currentViewer->GetName()
1044       << "\" set to " << vp.GetDrawingStyle()
1045       << G4endl;
1046     }
1047   }
1048 
1049   else if (command == fpCommandHiddenMarker) {
1050     G4bool hidden = G4UIcommand::ConvertToBool(newValue);
1051     if (hidden) vp.SetMarkerHidden();
1052     else vp.SetMarkerNotHidden();
1053     if (verbosity >= G4VisManager::confirmations) {
1054       G4cout << "Markers will ";
1055       if (vp.IsMarkerNotHidden()) G4cout << "not ";
1056       G4cout << "be hidden under solid objects." << G4endl;
1057     }
1058   }
1059 
1060   else if (command == fpCommandLightsMove) {
1061     if (newValue.find("cam") != G4String::npos)
1062       vp.SetLightsMoveWithCamera(true);
1063     else if(newValue.find("obj") != G4String::npos)
1064       vp.SetLightsMoveWithCamera(false);
1065     else {
1066       if (verbosity >= G4VisManager::errors) {
1067         G4warn << "ERROR: \"" << newValue << "\" not recognised."
1068         "  Looking for \"cam\" or \"obj\" in string." << G4endl;
1069       }
1070     }
1071     if (verbosity >= G4VisManager::confirmations) {
1072       G4cout << "Lights move with ";
1073       if (vp.GetLightsMoveWithCamera())
1074         G4cout << "camera (object appears to rotate).";
1075       else G4cout << "object (the viewer appears to be moving).";
1076       G4cout << G4endl;
1077     }
1078   }
1079 
1080   else if (command == fpCommandLightsThetaPhi) {
1081     G4double theta, phi;
1082     if (ConvertToDoublePair(newValue, theta, phi)) {
1083       G4double x = std::sin (theta) * std::cos (phi);
1084       G4double y = std::sin (theta) * std::sin (phi);
1085       G4double z = std::cos (theta);
1086       fLightsVector = G4ThreeVector (x, y, z);
1087       vp.SetLightpointDirection(fLightsVector);
1088       if (verbosity >= G4VisManager::confirmations) {
1089         G4cout << "Lights direction set to "
1090         << vp.GetLightpointDirection() << G4endl;
1091       }
1092     }
1093   }
1094 
1095   else if (command == fpCommandLightsVector) {
1096     fLightsVector = G4UIcommand::ConvertTo3Vector(newValue);
1097     vp.SetLightpointDirection(fLightsVector);
1098     if (verbosity >= G4VisManager::confirmations) {
1099       G4cout << "Lights direction set to "
1100       << vp.GetLightpointDirection() << G4endl;
1101     }
1102   }
1103 
1104   else if (command == fpCommandLineWidth) {
1105     if (verbosity >= G4VisManager::errors) {
1106       // A do-nothing command
1107       G4warn << command->GetGuidanceLine(0) << G4endl;
1108     }
1109   }
1110 
1111   else if (command == fpCommandLineSegments) {
1112     G4int nSides = G4UIcommand::ConvertToInt(newValue);
1113     nSides = vp.SetNoOfSides(nSides);
1114     if (verbosity >= G4VisManager::confirmations) {
1115       G4cout <<
1116       "Number of line segments per circle in polygon approximation is "
1117       << nSides << G4endl;
1118     }
1119   }
1120 
1121   else if (command == fpCommandNumberOfCloudPoints) {
1122     G4int nPoints = G4UIcommand::ConvertToInt(newValue);
1123     nPoints = vp.SetNumberOfCloudPoints(nPoints);
1124     if (verbosity >= G4VisManager::confirmations) {
1125       G4cout <<
1126       "Number of points to be used in cloud representation of volumes is "
1127       << nPoints << G4endl;
1128     }
1129   }
1130 
1131   else if (command == fpCommandPicking) {
1132     vp.SetPicking(G4UIcommand::ConvertToBool(newValue));
1133     if (verbosity >= G4VisManager::confirmations) {
1134       G4cout << "Picking ";
1135       if (vp.IsPicking()) G4cout << "requested.";
1136       else G4cout << "inhibited.";
1137       G4cout << G4endl;
1138     }
1139     if (verbosity >= G4VisManager::warnings) {
1140       G4warn << "You may need to issue \"/vis/viewer/update\"."
1141       << G4endl;
1142     }
1143   }
1144 
1145   else if (command == fpCommandProjection) {
1146     G4double fieldHalfAngle;
1147     const size_t iPos0 = 0;
1148     if (newValue[iPos0] == 'o') {  // "orthogonal"
1149       fieldHalfAngle = 0.;
1150     }
1151     else if (newValue[iPos0] == 'p') {  // "perspective"
1152       G4String dummy;
1153       G4String unit;
1154       std::istringstream is (newValue);
1155       is >> dummy >> fieldHalfAngle >> unit;
1156       fieldHalfAngle *= G4UIcommand::ValueOf(unit);
1157       if (fieldHalfAngle > 89.5 * deg || fieldHalfAngle <= 0.0) {
1158         if (verbosity >= G4VisManager::errors) {
1159           G4warn <<
1160           "ERROR: Field half angle should be 0 < angle <= 89.5 degrees.";
1161           G4warn << G4endl;
1162         }
1163         return;
1164       }
1165     }
1166     else {
1167       if (verbosity >= G4VisManager::errors) {
1168         G4warn << "ERROR: \"" << newValue << "\" not recognised."
1169         "  Looking for 'o' or 'p' first character." << G4endl;
1170       }
1171       return;
1172     }
1173     vp.SetFieldHalfAngle(fieldHalfAngle);
1174     if (verbosity >= G4VisManager::confirmations) {
1175       G4cout << "Projection style of viewer \"" << currentViewer->GetName()
1176       << "\" set to ";
1177       if (fieldHalfAngle == 0.) {
1178         G4cout << "orthogonal.";
1179       }
1180       else {
1181         G4cout << "perspective\n  with half angle " << fieldHalfAngle / deg
1182         << " degrees.";
1183       }
1184       G4cout << G4endl;
1185     }
1186   }
1187 
1188   else if (command == fpCommandRotationStyle) {
1189     G4ViewParameters::RotationStyle style;
1190     if (newValue == "constrainUpDirection")
1191       style = G4ViewParameters::constrainUpDirection;
1192     else if (newValue == "freeRotation")
1193       style = G4ViewParameters::freeRotation;
1194     else {
1195       if (verbosity >= G4VisManager::errors) {
1196   G4warn << "ERROR: \"" << newValue << "\" not recognised." << G4endl;
1197       }
1198       return;
1199     }
1200     vp.SetRotationStyle(style);
1201     if (verbosity >= G4VisManager::confirmations) {
1202       G4cout << "Rotation style of viewer \"" << currentViewer->GetName()
1203       << "\" set to " << vp.GetRotationStyle()
1204       << G4endl;
1205     }
1206   }
1207 
1208   else if (command == fpCommandSectionPlane) {
1209     G4String choice, unit;
1210     G4double x, y, z, nx, ny, nz, F = 1.;
1211     std::istringstream is (newValue);
1212     is >> choice >> x >> y >> z >> unit >> nx >> ny >> nz;
1213     G4int iSelector = -1;
1214     if (G4StrUtil::icompare(choice, "off") == 0 ||
1215         !G4UIcommand::ConvertToBool(choice)) iSelector = 0;
1216     if (G4StrUtil::icompare(choice, "on") == 0 ||
1217         G4UIcommand::ConvertToBool(choice)) iSelector = 1;
1218     if (iSelector < 0) {
1219       if (verbosity >= G4VisManager::errors) {
1220         G4warn << "Choice not recognised (on/true or off/false)." << G4endl;
1221       }
1222       goto write_result;
1223     }
1224     // iSelector can only be 0 or 1
1225     switch (iSelector) {
1226       case 0:
1227         vp.UnsetSectionPlane();
1228         break;
1229       case 1:
1230         F = G4UIcommand::ValueOf(unit);
1231         x *= F; y *= F; z *= F;
1232         if (nx == 0. && ny == 0. && nz == 0.) {
1233           if (verbosity >= G4VisManager::errors) {
1234             G4warn << "Null normal." << G4endl;
1235           }
1236           break;;
1237         }
1238         // Make sure normal is normalised
1239         const G4Normal3D& normal = G4Normal3D(nx,ny,nz).unit();
1240         vp.SetSectionPlane(G4Plane3D(normal, G4Point3D(x,y,z)));
1241         vp.SetViewpointDirection(normal);
1242         break;
1243     }
1244   write_result:
1245     if (verbosity >= G4VisManager::confirmations) {
1246       G4cout << "Section drawing is: ";
1247       if (vp.IsSection ()) G4cout << "on";
1248       else                 G4cout << "off";
1249       G4cout << ".\nSection plane is now: "
1250       << vp.GetSectionPlane ();
1251       G4cout << G4endl;
1252     }
1253   }
1254 
1255   else if (command == fpCommandSpecialMeshRendering) {
1256     vp.SetSpecialMeshRendering(G4UIcommand::ConvertToBool(newValue));
1257     if (verbosity >= G4VisManager::confirmations) {
1258       G4cout << "Special mesh rendering";
1259       if (vp.IsSpecialMeshRendering()) {
1260         G4cout << " requested. Current option is \""
1261         << vp.GetSpecialMeshRenderingOption() << "\" for ";
1262         if (vp.GetSpecialMeshVolumes().empty()) {
1263           G4cout << "any mesh.";
1264         } else{
1265           G4cout << "selected volumes:";
1266           for (const auto& pvNameCopyNo: vp.GetSpecialMeshVolumes()) {
1267             G4cout << "\n  " << pvNameCopyNo.GetName();
1268             if (pvNameCopyNo.GetCopyNo() >= 0) G4cout << ':' << pvNameCopyNo.GetCopyNo();
1269           }
1270         }
1271       }
1272       else G4cout << ": off.";
1273       G4cout << G4endl;
1274     }
1275   }
1276 
1277   else if (command == fpCommandSpecialMeshRenderingOption) {
1278     G4ViewParameters::SMROption option = G4ViewParameters::meshAsDefault;
1279     if (newValue == "dots") {
1280       option = G4ViewParameters::meshAsDots;
1281     }
1282     else if(newValue == "surfaces") {
1283       option = G4ViewParameters::meshAsSurfaces;
1284     }
1285     vp.SetSpecialMeshRenderingOption(option);
1286     if (verbosity >= G4VisManager::confirmations) {
1287       G4cout << "Special mesh rendering option set to \""
1288       << vp.GetSpecialMeshRenderingOption() << "\"."
1289       << G4endl;
1290     }
1291   }
1292 
1293   else if (command == fpCommandSpecialMeshVolumes) {
1294     std::vector<G4ModelingParameters::PVNameCopyNo> requestedMeshes;
1295     if (newValue.empty()) {
1296       vp.SetSpecialMeshVolumes(requestedMeshes);  // Empty list
1297     } else {
1298       // Algorithm from Josuttis p.476.
1299       G4String::size_type iBegin, iEnd;
1300       iBegin = newValue.find_first_not_of(' ');
1301       while (iBegin != G4String::npos) {
1302   iEnd = newValue.find_first_of(' ',iBegin);
1303   if (iEnd == G4String::npos) {
1304     iEnd = newValue.length();
1305   }
1306   const G4String& name(newValue.substr(iBegin,iEnd-iBegin));
1307   iBegin = newValue.find_first_not_of(' ',iEnd);
1308   if (iBegin == G4String::npos) {
1309     if (verbosity >= G4VisManager::warnings) {
1310       G4warn <<
1311       "WARNING: G4VisCommandsViewerSet::SetNewValue: /vis/viewer/set/specialMeshVolumes"
1312       "\n  A pair not found.  (There should be an even number of parameters.)"
1313       "\n  Command ignored."
1314       << G4endl;
1315       return;
1316     }
1317   }
1318   iEnd = newValue.find_first_of(' ',iBegin);
1319   if (iEnd == G4String::npos) {
1320     iEnd = newValue.length();
1321   }
1322   G4int copyNo;
1323   std::istringstream iss(newValue.substr(iBegin,iEnd-iBegin));
1324   if (!(iss >> copyNo)) {
1325     if (verbosity >= G4VisManager::warnings) {
1326       G4warn <<
1327       "WARNING: G4VisCommandsViewerSet::SetNewValue: /vis/viewer/set/specialMeshVolumes"
1328       "\n  Error reading copy number - it was not numeric?"
1329       "\n  Command ignored."
1330       << G4endl;
1331       return;
1332     }
1333   }
1334   requestedMeshes.push_back(G4ModelingParameters::PVNameCopyNo(name,copyNo));
1335   iBegin = newValue.find_first_not_of(' ',iEnd);
1336       }
1337       vp.SetSpecialMeshVolumes(requestedMeshes);
1338     }
1339     if (verbosity >= G4VisManager::confirmations) {
1340       if (vp.GetSpecialMeshVolumes().empty()) {
1341   G4cout <<
1342   "Special mesh list empty, which means \"all meshes\"."
1343   << G4endl;
1344       } else {
1345   G4cout << "Selected special mesh volumes are:";
1346   for (const auto& pvNameCopyNo: vp.GetSpecialMeshVolumes()) {
1347     G4cout << "\n  " << pvNameCopyNo.GetName();
1348     if (pvNameCopyNo.GetCopyNo() >= 0) G4cout << ':' << pvNameCopyNo.GetCopyNo();
1349   }
1350   G4cout << G4endl;
1351       }
1352     }
1353   }
1354 
1355   else if (command == fpCommandStyle) {
1356     G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle();
1357     const size_t iPos0 = 0;
1358     if (newValue[iPos0] == 'w') {  // "wireframe"
1359       switch (existingStyle) {
1360         case G4ViewParameters::wireframe:
1361           break;
1362         case G4ViewParameters::hlr:
1363           break;
1364         case G4ViewParameters::hsr:
1365           vp.SetDrawingStyle(G4ViewParameters::wireframe);
1366           break;
1367         case G4ViewParameters::hlhsr:
1368           vp.SetDrawingStyle(G4ViewParameters::hlr);
1369           break;
1370         case G4ViewParameters::cloud:
1371           vp.SetDrawingStyle(G4ViewParameters::wireframe);
1372           break;
1373       }
1374     }
1375     else if (newValue[iPos0] == 's') {  // "surface"
1376       switch (existingStyle) {
1377         case G4ViewParameters::wireframe:
1378           vp.SetDrawingStyle(G4ViewParameters::hsr);
1379           break;
1380         case G4ViewParameters::hlr:
1381           vp.SetDrawingStyle(G4ViewParameters::hlhsr);
1382           break;
1383         case G4ViewParameters::hsr:
1384           break;
1385         case G4ViewParameters::hlhsr:
1386           break;
1387         case G4ViewParameters::cloud:
1388           vp.SetDrawingStyle(G4ViewParameters::hsr);
1389           break;
1390      }
1391     }
1392     else if (newValue[iPos0] == 'c') {  // "cloud"
1393       switch (existingStyle) {
1394         case G4ViewParameters::wireframe:
1395           vp.SetDrawingStyle(G4ViewParameters::cloud);
1396           break;
1397         case G4ViewParameters::hlr:
1398           vp.SetDrawingStyle(G4ViewParameters::cloud);
1399           break;
1400         case G4ViewParameters::hsr:
1401           vp.SetDrawingStyle(G4ViewParameters::cloud);
1402           break;
1403         case G4ViewParameters::hlhsr:
1404           vp.SetDrawingStyle(G4ViewParameters::cloud);
1405           break;
1406         case G4ViewParameters::cloud:
1407           break;
1408       }
1409     }
1410     else {
1411       if (verbosity >= G4VisManager::errors) {
1412         G4warn << "ERROR: \"" << newValue << "\" not recognised."
1413         "  Looking for 'w' or 's' or 'c' first character." << G4endl;
1414       }
1415       return;
1416     }
1417     if (verbosity >= G4VisManager::confirmations) {
1418       G4cout << "Drawing style of viewer \"" << currentViewer->GetName()
1419       << "\" set to " << vp.GetDrawingStyle()
1420       << G4endl;
1421     }
1422   }
1423 
1424   else if (command == fpCommandTargetPoint) {
1425     G4ThreeVector targetPoint =
1426     fpCommandTargetPoint->GetNew3VectorValue(newValue);
1427     const G4Point3D& standardTargetPoint =
1428     currentViewer->GetSceneHandler()->GetScene()->GetStandardTargetPoint();
1429     vp.SetCurrentTargetPoint(targetPoint - standardTargetPoint);
1430     if (verbosity >= G4VisManager::confirmations) {
1431       G4cout << "Target point set to "
1432       << fpCommandTargetPoint->ConvertToStringWithBestUnit
1433       (targetPoint)
1434       << "\n\"Current Target Point\" set to  "
1435       << fpCommandTargetPoint->ConvertToStringWithBestUnit
1436       (vp.GetCurrentTargetPoint())
1437       << "\n\"Standard Target Point\" is "
1438       << fpCommandTargetPoint->ConvertToStringWithBestUnit
1439       (standardTargetPoint)
1440       << G4endl;
1441     }
1442   }
1443 
1444   else if (command == fpCommandUpThetaPhi) {
1445     G4double theta, phi;
1446     if (ConvertToDoublePair(newValue, theta, phi)) {
1447       G4double x = std::sin (theta) * std::cos (phi);
1448       G4double y = std::sin (theta) * std::sin (phi);
1449       G4double z = std::cos (theta);
1450       fUpVector = G4ThreeVector (x, y, z);
1451       vp.SetUpVector(fUpVector);
1452       if (verbosity >= G4VisManager::confirmations) {
1453         G4cout << "Up direction set to " << vp.GetUpVector() << G4endl;
1454       }
1455     }
1456   }
1457 
1458   else if (command == fpCommandUpVector) {
1459     fUpVector = G4UIcommand::ConvertTo3Vector(newValue).unit();
1460     vp.SetUpVector(fUpVector);
1461     if (verbosity >= G4VisManager::confirmations) {
1462       G4cout << "Up direction set to " << vp.GetUpVector() << G4endl;
1463     }
1464   }
1465 
1466   else if (command == fpCommandViewpointThetaPhi) {
1467     G4double theta, phi;
1468     if (ConvertToDoublePair(newValue, theta, phi)) {
1469       G4double x = std::sin (theta) * std::cos (phi);
1470       G4double y = std::sin (theta) * std::sin (phi);
1471       G4double z = std::cos (theta);
1472       fViewpointVector = G4ThreeVector (x, y, z);
1473       vp.SetViewAndLights(fViewpointVector);
1474       if (verbosity >= G4VisManager::confirmations) {
1475         G4cout << "Viewpoint direction set to "
1476         << vp.GetViewpointDirection() << G4endl;
1477         if (vp.GetLightsMoveWithCamera ()) {
1478           G4cout << "Lightpoint direction set to "
1479           << vp.GetActualLightpointDirection () << G4endl;
1480         }
1481       }
1482     }
1483   }
1484 
1485   else if (command == fpCommandViewpointVector) {
1486     G4ThreeVector viewpointVector = G4UIcommand::ConvertTo3Vector(newValue);
1487     if (viewpointVector.mag2() <= 0.) {
1488       if (verbosity >= G4VisManager::errors) {
1489         G4warn << "ERROR: Null viewpoint vector. No action taken." << G4endl;
1490       }
1491     } else {
1492       fViewpointVector = viewpointVector.unit();
1493       vp.SetViewAndLights(fViewpointVector);
1494       if (verbosity >= G4VisManager::confirmations) {
1495         G4cout << "Viewpoint direction set to "
1496         << vp.GetViewpointDirection() << G4endl;
1497         if (vp.GetLightsMoveWithCamera ()) {
1498           G4cout << "Lightpoint direction set to "
1499           << vp.GetActualLightpointDirection () << G4endl;
1500         }
1501       }
1502     }
1503   }
1504 
1505   else if (command == fpCommandTimeWindowDisplayHeadTime)
1506   {
1507     G4String display;
1508     G4double screenX, screenY, screenSize, red, green, blue;
1509     std::istringstream iss(newValue);
1510     iss >> display >> screenX >> screenY
1511     >> screenSize >> red >> green >> blue;
1512     vp.SetDisplayHeadTime(command->ConvertToBool(display));
1513     vp.SetDisplayHeadTimeX(screenX);
1514     vp.SetDisplayHeadTimeY(screenY);
1515     vp.SetDisplayHeadTimeSize(screenSize);
1516     vp.SetDisplayHeadTimeRed(red);
1517     vp.SetDisplayHeadTimeGreen(green);
1518     vp.SetDisplayHeadTimeBlue(blue);
1519     if (verbosity >= G4VisManager::confirmations) {
1520       G4cout << "Display head time flag set: "
1521       << vp
1522       << G4endl;
1523     }
1524   }
1525 
1526   else if (command == fpCommandTimeWindowDisplayLightFront)
1527   {
1528     G4String display, originX, originY, originZ, unitS, originT, unitT;
1529     G4double red, green, blue;
1530     std::istringstream iss(newValue);
1531     iss >> display
1532     >> originX >> originY >> originZ >> unitS
1533     >> originT >> unitT
1534     >> red >> green >> blue;
1535     vp.SetDisplayLightFront(command->ConvertToBool(display));
1536     vp.SetDisplayLightFrontX
1537     (command->ConvertToDimensionedDouble(G4String(originX + ' ' + unitS)));
1538     vp.SetDisplayLightFrontY
1539     (command->ConvertToDimensionedDouble(G4String(originY + ' ' + unitS)));
1540     vp.SetDisplayLightFrontZ
1541     (command->ConvertToDimensionedDouble(G4String(originZ + ' ' + unitS)));
1542     vp.SetDisplayLightFrontT
1543     (command->ConvertToDimensionedDouble(G4String(originT + ' ' + unitT)));
1544     vp.SetDisplayLightFrontRed(red);
1545     vp.SetDisplayLightFrontGreen(green);
1546     vp.SetDisplayLightFrontBlue(blue);
1547     if (verbosity >= G4VisManager::confirmations) {
1548       G4cout << "Display light front flag set: "
1549       << vp
1550       << G4endl;
1551     }
1552   }
1553 
1554   else if (command == fpCommandTimeWindowEndTime)
1555   {
1556     G4String end_time_string, end_time_unit,
1557     time_range_string, time_range_unit;
1558     std::istringstream iss(newValue);
1559     iss >> end_time_string >> end_time_unit
1560     >> time_range_string >> time_range_unit;
1561     vp.SetEndTime
1562     (command->ConvertToDimensionedDouble
1563      (G4String(end_time_string + ' ' + end_time_unit)));
1564     G4double timeRange = command->ConvertToDimensionedDouble
1565     (G4String(time_range_string + ' ' + time_range_unit));
1566     if (timeRange > 0.) {
1567       vp.SetStartTime
1568       (vp.GetEndTime() - timeRange);
1569     }
1570     if (verbosity >= G4VisManager::confirmations) {
1571       G4cout
1572       << "Time window start time: " << vp.GetStartTime()/ns << " ns"
1573       << ", time window end time: " << vp.GetEndTime()/ns << " ns";
1574       if (timeRange > 0.) {
1575         G4cout << "\n  (time range: " << timeRange/ns << " ns)";
1576       }
1577       G4cout << G4endl;
1578     }
1579   }
1580 
1581   else if (command == fpCommandTimeWindowFadeFactor) {
1582     vp.SetFadeFactor(command->ConvertToDouble(newValue));
1583     if (verbosity >= G4VisManager::confirmations) {
1584       G4cout << "Time window fade factor changed to " << vp.GetFadeFactor()
1585       << G4endl;
1586     }
1587   }
1588 
1589   else if (command == fpCommandTimeWindowStartTime)
1590   {
1591     G4String start_time_string, start_time_unit,
1592     time_range_string, time_range_unit;
1593     std::istringstream iss(newValue);
1594     iss >> start_time_string >> start_time_unit
1595     >> time_range_string >> time_range_unit;
1596     vp.SetStartTime
1597     (command->ConvertToDimensionedDouble
1598      (G4String(start_time_string + ' ' + start_time_unit)));
1599     G4double timeRange = command->ConvertToDimensionedDouble
1600     (G4String(time_range_string + ' ' + time_range_unit));
1601     if (timeRange > 0.) {
1602       vp.SetEndTime
1603       (vp.GetStartTime() + timeRange);
1604     }
1605     if (verbosity >= G4VisManager::confirmations) {
1606       G4cout
1607       << "Time window start time: " << vp.GetStartTime()/ns << " ns"
1608       << ", time window end time: " << vp.GetEndTime()/ns << " ns";
1609       if (timeRange > 0.) {
1610         G4cout << "\n  (time range: " << timeRange/ns << " ns)";
1611       }
1612       G4cout << G4endl;
1613     }
1614   }
1615 
1616   else {
1617     if (verbosity >= G4VisManager::errors) {
1618       G4warn <<
1619       "ERROR: G4VisCommandsViewerSet::SetNewValue: unrecognised command."
1620       << G4endl;
1621     }
1622     return;
1623   }
1624 
1625   SetViewParameters(currentViewer,vp);
1626 }
1627