Import Geant4 10.6.0.beta source tree

2019-06-28 11:59:04 +02:00
parent 28a70706e0
commit d0f911957d
1056 changed files with 95168 additions and 78160 deletions
@@ -56,6 +56,7 @@ class G4VPhysicalVolume;
 class G4Material;
 class G4Event;
 class G4AttHolder;
+class G4DisplacedSolid;

 class G4VSceneHandler: public G4VGraphicsScene {

@@ -156,7 +157,7 @@ public: // With description
  // }

  virtual void BeginPrimitives
-  (const G4Transform3D& objectTransformation);
+  (const G4Transform3D& objectTransformation = G4Transform3D());
  // IMPORTANT: invoke this from your polymorphic versions, e.g.:
  // void MyXXXSceneHandler::BeginPrimitives
  // (const G4Transform3D& objectTransformation) {
@@ -172,7 +173,7 @@ public: // With description
  // }

  virtual void BeginPrimitives2D
-  (const G4Transform3D& objectTransformation);
+  (const G4Transform3D& objectTransformation = G4Transform3D());
  // The x,y coordinates of the primitives passed to AddPrimitive are
  // intrepreted as screen coordinates, -1 < x,y < 1.  The
  // z-coordinate is ignored.
@@ -249,6 +250,11 @@ public: // With description
  // has forced through the vis attributes, thereby over-riding the
  // current view parameter.

+  G4int GetNumberOfCloudPoints (const G4VisAttributes*) const;
+  // Returns no of cloud points from current view parameters, unless the user
+  // has forced through the vis attributes, thereby over-riding the
+  // current view parameter.
+
  G4bool GetAuxEdgeVisible (const G4VisAttributes*);
  // Returns auxiliary edge visibility from current view parameters,
  // unless the user has forced through the vis attributes, thereby
@@ -315,8 +321,8 @@ protected:
  //////////////////////////////////////////////////////////////
  // Other internal routines...

-  virtual G4VSolid* CreateSectionSolid ();
-  virtual G4VSolid* CreateCutawaySolid ();
+  virtual G4DisplacedSolid* CreateSectionSolid ();
+  virtual G4DisplacedSolid* CreateCutawaySolid ();
  // Generic clipping using the BooleanProcessor in graphics_reps is
  // implemented in this class.  Subclasses that implement their own
  // clipping should provide an override that returns zero.
@@ -38,28 +38,49 @@
 #include "G4VisAttributes.hh"
 #include "G4VMarker.hh"
 #include "G4ModelingParameters.hh"
+#include "G4PhysicalVolumesSearchScene.hh"
 #include <vector>

 class G4UIcommand;
 class G4UIcmdWithAString;

-class G4VVisCommand: public G4UImessenger {
+class G4VVisCommand: public G4UImessenger
+{
 public:
+  
  // Uses compiler defaults for copy constructor and assignment.
  G4VVisCommand ();
  virtual ~G4VVisCommand ();
-  static void SetVisManager (G4VisManager*);
-  static const G4Colour& GetCurrentColour() {return fCurrentColour;}
-  //static G4VMarker::FillStyle GetCurrentFillStyle() {return fCurrentFillStyle;}
-  //static G4VMarker::SizeType  GetCurrentSizeType() {return fCurrentSizeType;}
-  static G4double GetCurrentLineWidth() {return fCurrentLineWidth;}
-  //static G4VisAttributes::LineStyle GetCurrentLineStyle() {return fCurrentLineStyle;}
-  static const G4Colour& GetCurrentTextColour() {return fCurrentTextColour;}
-  static G4Text::Layout GetCurrentTextLayout() {return fCurrentTextLayout;}
-  static G4double GetCurrentTextSize() {return fCurrentTextSize;}
+
+  static void SetVisManager (G4VisManager* pVisManager)
+  {fpVisManager = pVisManager;}
+
+  static const G4Colour& GetCurrentTextColour()
+  {return fCurrentTextColour;}

 protected:

+  // Utility functions
+
+  void SetViewParameters(G4VViewer* viewer, const G4ViewParameters& viewParams);
+
+  void RefreshIfRequired(G4VViewer* viewer);
+
+  void InterpolateViews
+  (G4VViewer* currentViewer,
+   std::vector<G4ViewParameters> viewVector,
+   const G4int nInterpolationPoints = 50,
+   const G4int waitTimePerPointmilliseconds = 20,
+   const G4String exportString = "");
+
+  void InterpolateToNewView
+  (G4VViewer* currentViewer,
+   const G4ViewParameters& oldVP,
+   const G4ViewParameters& newVP,
+   const G4int nInterpolationPoints = 50,
+   const G4int waitTimePerPointmilliseconds = 20,
+   const G4String exportString = "");
+
  // Conversion routines augmenting those in G4UIcommand.

  static G4String ConvertToString(G4double x, G4double y,
@@ -93,13 +114,24 @@ protected:
   G4double& value);
  // Return false if there's a problem

-  // Other utilities.
+  // Other utilities
+
  void CheckSceneAndNotifyHandlers (G4Scene* = nullptr);

-  // Data members.
+  void G4VisCommandsSceneAddUnsuccessful(G4VisManager::Verbosity verbosity);
+
+  void CopyGuidanceFrom
+  (const G4UIcommand* fromCmd, G4UIcommand* toCmd, G4int startLine = 0);
+
+  void CopyParametersFrom
+  (const G4UIcommand* fromCmd, G4UIcommand* toCmd);
+
+  void DrawExtent(const G4VisExtent&);
+
+  // Data members
+
  static G4VisManager* fpVisManager;

-  // Error management
  static G4int fErrorCode;

  // Current quantities for use in appropriate commands
@@ -113,8 +145,8 @@ protected:
  static G4Text::Layout             fCurrentTextLayout;
  static G4double                   fCurrentTextSize;
  static G4PhysicalVolumeModel::TouchableProperties fCurrentTouchableProperties;
+  static G4VisExtent                fCurrentExtentForField;
+  static std::vector<G4PhysicalVolumesSearchScene::Findings> fCurrrentPVFindingsForField;
 };

-#include "G4VVisCommand.icc"
-
 #endif
@@ -1,33 +0,0 @@
-//
-// ********************************************************************
-// * License and Disclaimer                                           *
-// *                                                                  *
-// * The  Geant4 software  is  copyright of the Copyright Holders  of *
-// * the Geant4 Collaboration.  It is provided  under  the terms  and *
-// * conditions of the Geant4 Software License,  included in the file *
-// * LICENSE and available at  http://cern.ch/geant4/license .  These *
-// * include a list of copyright holders.                             *
-// *                                                                  *
-// * Neither the authors of this software system, nor their employing *
-// * institutes,nor the agencies providing financial support for this *
-// * work  make  any representation or  warranty, express or implied, *
-// * regarding  this  software system or assume any liability for its *
-// * use.  Please see the license in the file  LICENSE  and URL above *
-// * for the full disclaimer and the limitation of liability.         *
-// *                                                                  *
-// * This  code  implementation is the result of  the  scientific and *
-// * technical work of the GEANT4 collaboration.                      *
-// * By using,  copying,  modifying or  distributing the software (or *
-// * any work based  on the software)  you  agree  to acknowledge its *
-// * use  in  resulting  scientific  publications,  and indicate your *
-// * acceptance of all terms of the Geant4 Software license.          *
-// ********************************************************************
-//
-//
-
-// Base class for visualization commands - John Allison  9th August 1998
-// It is really a messenger - we have one command per messenger.
-
-inline void G4VVisCommand::SetVisManager (G4VisManager* pVisManager) {
-  fpVisManager = pVisManager;
-}
@@ -37,11 +37,11 @@
 // In GEANT4 visualization, we have the concept of a "Standard
 // View".  This is the view when the complete set of objects being
 // viewed is comfortably in view from any viewpoint.  It is defined by
-// the "Bounding Sphere" of "visible" objects when initially
+// the "Bounding Extent" of "visible" objects when initially
 // registered in the scene, and by the View Parameters.
 //
 // There is also the "Standard Target Point", which is the centre of
-// the Bounding Sphere (note that this belongs to the scene and is
+// the Bounding Extent (note that this belongs to the scene and is
 // stored in the G4Scene object).  The "Current Target Point", defined
 // relative to the Standard Target Point, is changed by the
 // "dolly" and "zoom" commands, and can be reset to the Standard
@@ -50,7 +50,7 @@
 // Also, the "Standard Camera Position" is the "Standard Camera
 // Distance" along the Viewpoint Direction vector from the Standard
 // Target Point.  The Standard Camera Distance is the radius of the
-// Bounding Sphere divided by fFieldHalfAngle.  It is not stored
+// Bounding Extent divided by fFieldHalfAngle.  It is not stored
 // explicitly because of the singularity at fFieldHalfAngle = 0,
 // which implies parallel projection.
 //
@@ -62,7 +62,8 @@
 // conceptually possible, but which might give some problems when
 // setting up the view matrix - see, for example, G4OpenGLView::SetView ().
 //
-// All viewers are expected to keep the "Up Vector" vertical.
+// All viewers are expected to keep the "Up Vector" vertical unless
+// RotationStyle is freeRotation.
 //
 // Finally, the view is magnified by the "Zoom Factor" which is
 // reset to 1 by the "/vis/viewer/reset" command.
@@ -94,7 +95,8 @@ public: // With description
    wireframe,  // Draw edges    - no hidden line removal.
    hlr,        // Draw edges    - hidden lines removed.
    hsr,        // Draw surfaces - hidden surfaces removed.
-    hlhsr       // Draw surfaces and edges - hidden removed.
+    hlhsr,      // Draw surfaces and edges - hidden removed.
+    cloud       // Draw volume as a cloud of dots.
  };

  enum CutawayMode {
@@ -122,6 +124,7 @@ public: // With description

  // Get and Is functions.
        DrawingStyle     GetDrawingStyle         () const;
+        G4int            GetNumberOfCloudPoints  () const;
        G4bool           IsAuxEdgeVisible        () const;
        G4bool           IsCulling               () const;
        G4bool           IsCullingInvisible      () const;
@@ -200,7 +203,7 @@ public: // With description
        G4double         GetDisplayLightFrontBlue () const;

  // Here Follow functions to evaluate useful quantities as a
-  // function of the radius of the Bounding Sphere of the object being
+  // function of the radius of the Bounding Extent of the object being
  // viewed.  Call them in the order given - for efficiency, later
  // functions depend on the results of earlier ones (Store the
  // results of earlier functions in your own temporary variables -
@@ -213,6 +216,7 @@ public: // With description

  // Set, Add, Multiply, Increment, Unset and Clear functions.
  void SetDrawingStyle         (G4ViewParameters::DrawingStyle style);
+  G4int SetNumberOfCloudPoints (G4int);  // Returns number actually set.
  void SetAuxEdgeVisible       (G4bool);
  void SetCulling              (G4bool);
  void SetCullingInvisible     (G4bool);
@@ -230,7 +234,7 @@ public: // With description
  void SetExplodeFactor        (G4double explodeFactor);
  void UnsetExplodeFactor      ();
  void SetExplodeCentre        (const G4Point3D& explodeCentre);
-  G4int SetNoOfSides           (G4int nSides);  // Returns actual number set.
+  G4int SetNoOfSides           (G4int nSides);  // Returns number actually set.
  void SetViewpointDirection   (const G4Vector3D& viewpointDirection);
  // Calls the following to get lightpoint direction right too.
  void SetViewAndLights        (const G4Vector3D& viewpointDirection);
@@ -321,6 +325,8 @@ private:
  G4int ReadInteger(char *string, char **NextString);

  DrawingStyle fDrawingStyle;    // Drawing style.
+  G4int        fNumberOfCloudPoints; // For drawing in cloud style.
+                                     // <= 0 means use viewer default.
  G4bool       fAuxEdgeVisible;  // Auxiliary edge visibility.
  G4bool       fCulling;         // Culling requested.
  G4bool       fCullInvisible;   // Cull (don't Draw) invisible objects.
@@ -291,6 +291,10 @@ inline G4double G4ViewParameters::GetDisplayLightFrontBlue () const {
  return fDisplayLightFrontBlue;
 }

+inline G4int G4ViewParameters::GetNumberOfCloudPoints () const {
+  return fNumberOfCloudPoints;
+}
+
 inline void
 G4ViewParameters::SetDrawingStyle (G4ViewParameters::DrawingStyle style) {
  fDrawingStyle = style;
@@ -74,13 +74,13 @@ class G4VisCommandGeometrySetForceAuxEdgeVisibleFunction:
 public:
  virtual ~G4VisCommandGeometrySetForceAuxEdgeVisibleFunction() {}
  G4VisCommandGeometrySetForceAuxEdgeVisibleFunction
-  (G4bool forceAuxEdgeVisible):
-    fForceAuxEdgeVisible(forceAuxEdgeVisible) {}
+  (G4bool force):
+    fForce(force) {}
  void operator()
    (G4VisAttributes* visAtts) const
-  {visAtts->SetForceAuxEdgeVisible(fForceAuxEdgeVisible);}
+  {visAtts->SetForceAuxEdgeVisible(fForce);}
 private:
-  G4bool fForceAuxEdgeVisible;
+  G4bool fForce;
 };

 class G4VisCommandGeometrySetForceLineSegmentsPerCircleFunction:
@@ -102,13 +102,13 @@ class G4VisCommandGeometrySetForceSolidFunction:
 public:
  virtual ~G4VisCommandGeometrySetForceSolidFunction() {}
  G4VisCommandGeometrySetForceSolidFunction
-  (G4bool forceSolid):
-    fForceSolid(forceSolid) {}
+  (G4bool force):
+    fForce(force) {}
  void operator()
    (G4VisAttributes* visAtts) const
-  {visAtts->SetForceSolid(fForceSolid);}
+  {visAtts->SetForceSolid(fForce);}
 private:
-  G4bool fForceSolid;
+  G4bool fForce;
 };

 class G4VisCommandGeometrySetForceWireframeFunction:
@@ -116,13 +116,13 @@ class G4VisCommandGeometrySetForceWireframeFunction:
 public:
  virtual ~G4VisCommandGeometrySetForceWireframeFunction() {}
  G4VisCommandGeometrySetForceWireframeFunction
-  (G4bool forceWireframe):
-    fForceWireframe(forceWireframe) {}
+  (G4bool force):
+    fForce(force) {}
  void operator()
    (G4VisAttributes* visAtts) const
-  {visAtts->SetForceWireframe(fForceWireframe);}
+  {visAtts->SetForceWireframe(fForce);}
 private:
-  G4bool fForceWireframe;
+  G4bool fForce;
 };

 class G4VisCommandGeometrySetLineStyleFunction:
@@ -137,4 +137,16 @@ private:
  G4UIcmdWithAString* fpCommand;
 };

+class G4VisCommandSceneShowExtents: public G4VVisCommandScene {
+public:
+  G4VisCommandSceneShowExtents ();
+  virtual ~G4VisCommandSceneShowExtents ();
+  G4String GetCurrentValue (G4UIcommand* command);
+  void SetNewValue (G4UIcommand* command, G4String newValue);
+private:
+  G4VisCommandSceneShowExtents (const G4VisCommandSceneShowExtents&);
+  G4VisCommandSceneShowExtents& operator = (const G4VisCommandSceneShowExtents&);
+  G4UIcmdWithoutParameter* fpCommand;
+};
+
 #endif
@@ -26,6 +26,7 @@
 //

 // /vis/scene commands - John Allison  9th August 1998
+// Michael Kelsey  31 Jan 2019 -- Add new command for electric field

 #ifndef G4VISCOMMANDSSCENEADD_HH
 #define G4VISCOMMANDSSCENEADD_HH
@@ -169,6 +170,18 @@ private:
  G4UIcommand* fpCommand;
 };

+class G4VisCommandSceneAddElectricField: public G4VVisCommandScene {
+public:
+  G4VisCommandSceneAddElectricField ();
+  virtual ~G4VisCommandSceneAddElectricField ();
+  G4String GetCurrentValue (G4UIcommand* command);
+  void SetNewValue (G4UIcommand* command, G4String newValue);
+private:
+  G4VisCommandSceneAddElectricField (const G4VisCommandSceneAddElectricField&);
+  G4VisCommandSceneAddElectricField& operator = (const G4VisCommandSceneAddElectricField&);
+  G4UIcommand* fpCommand;
+};
+
 class G4VisCommandSceneAddFrame: public G4VVisCommandScene {
 public:
  G4VisCommandSceneAddFrame ();
@@ -62,6 +62,18 @@ private:
  G4UIcommand* fpCommand;
 };

+class G4VisCommandSetExtentForField: public G4VVisCommand {
+public:
+  G4VisCommandSetExtentForField ();
+  virtual ~G4VisCommandSetExtentForField ();
+  G4String GetCurrentValue (G4UIcommand* command);
+  void SetNewValue (G4UIcommand* command, G4String newValue);
+private:
+  G4VisCommandSetExtentForField (const G4VisCommandSetExtentForField&);
+  G4VisCommandSetExtentForField& operator = (const G4VisCommandSetExtentForField&);
+  G4UIcommand* fpCommand;
+};
+
 class G4VisCommandSetLineWidth: public G4VVisCommand {
 public:
  G4VisCommandSetLineWidth ();
@@ -122,4 +134,16 @@ private:
  G4UIcommand* fpCommand;
 };

+class G4VisCommandSetVolumeForField: public G4VVisCommand {
+public:
+  G4VisCommandSetVolumeForField ();
+  virtual ~G4VisCommandSetVolumeForField ();
+  G4String GetCurrentValue (G4UIcommand* command);
+  void SetNewValue (G4UIcommand* command, G4String newValue);
+private:
+  G4VisCommandSetVolumeForField (const G4VisCommandSetVolumeForField&);
+  G4VisCommandSetVolumeForField& operator = (const G4VisCommandSetVolumeForField&);
+  G4UIcommand* fpCommand;
+};
+
 #endif
@@ -34,6 +34,7 @@

 class G4UIcmdWithAString;
 class G4UIcmdWithoutParameter;
+class G4UIcmdWithABool;

 class G4VisCommandsTouchable: public G4VVisCommand {
 public:
@@ -44,8 +45,14 @@ public:
 private:
  G4VisCommandsTouchable (const G4VisCommandsTouchable&);
  G4VisCommandsTouchable& operator = (const G4VisCommandsTouchable&);
+  G4UIcmdWithoutParameter* fpCommandCentreOn;
+  G4UIcmdWithoutParameter* fpCommandCentreAndZoomInOn;
+  G4UIcmdWithoutParameter* fpCommandDraw;
  G4UIcmdWithoutParameter* fpCommandDump;
-  G4UIcmdWithAString*      fpCommandFindPath;
+  G4UIcmdWithABool*        fpCommandExtentForField;
+  G4UIcommand*             fpCommandFindPath;
+  G4UIcmdWithABool*        fpCommandShowExtent;
+  G4UIcmdWithABool*        fpCommandVolumeForField;
 };

 #endif
@@ -38,7 +38,7 @@ class G4UIcmdWithADouble;
 class G4UIcmdWithAnInteger;
 class G4UIcmdWithAString;

-class G4VisCommandsTouchableSet: public G4VVisCommandViewer {
+class G4VisCommandsTouchableSet: public G4VVisCommand {
 public:
  G4VisCommandsTouchableSet ();
  virtual ~G4VisCommandsTouchableSet ();
@@ -51,10 +51,12 @@ private:
  G4UIcmdWithABool*     fpCommandSetDaughtersInvisible;
  G4UIcmdWithABool*     fpCommandSetForceAuxEdgeVisible;
  G4UIcmdWithAnInteger* fpCommandSetLineSegmentsPerCircle;
+  G4UIcmdWithABool*     fpCommandSetForceCloud;
  G4UIcmdWithABool*     fpCommandSetForceSolid;
  G4UIcmdWithABool*     fpCommandSetForceWireframe;
  G4UIcmdWithAString*   fpCommandSetLineStyle;
  G4UIcmdWithADouble*   fpCommandSetLineWidth;
+  G4UIcmdWithAnInteger* fpCommandSetNumberOfCloudPoints;
  G4UIcmdWithABool*     fpCommandSetVisibility;
 };

@@ -41,19 +41,7 @@ class G4UIcmdWithADouble;
 class G4UIcmdWithADoubleAndUnit;
 class G4UIcmdWith3Vector;

-class G4VVisCommandViewer: public G4VVisCommand {
-public:
-  G4VVisCommandViewer ();
-  virtual ~G4VVisCommandViewer ();
-protected:
-  void SetViewParameters(G4VViewer*, const G4ViewParameters&);
-  void RefreshIfRequired(G4VViewer*);
-private:
-  G4VVisCommandViewer (const G4VVisCommandViewer&);
-  G4VVisCommandViewer& operator = (const G4VVisCommandViewer&);
-};
-
-class G4VisCommandViewerAddCutawayPlane: public G4VVisCommandViewer {
+class G4VisCommandViewerAddCutawayPlane: public G4VVisCommand {
 public:
  G4VisCommandViewerAddCutawayPlane ();
  virtual ~G4VisCommandViewerAddCutawayPlane ();
@@ -65,7 +53,20 @@ private:
  G4UIcommand* fpCommand;
 };

-class G4VisCommandViewerChangeCutawayPlane: public G4VVisCommandViewer {
+class G4VisCommandViewerCentreOn: public G4VVisCommand {
+public:
+  G4VisCommandViewerCentreOn ();
+  virtual ~G4VisCommandViewerCentreOn ();
+  G4String GetCurrentValue (G4UIcommand* command);
+  void SetNewValue (G4UIcommand* command, G4String newValue);
+private:
+  G4VisCommandViewerCentreOn (const G4VisCommandViewerCentreOn&);
+  G4VisCommandViewerCentreOn& operator = (const G4VisCommandViewerCentreOn&);
+  G4UIcommand* fpCommandCentreOn;
+  G4UIcommand* fpCommandCentreAndZoomInOn;
+};
+
+class G4VisCommandViewerChangeCutawayPlane: public G4VVisCommand {
 public:
  G4VisCommandViewerChangeCutawayPlane ();
  virtual ~G4VisCommandViewerChangeCutawayPlane ();
@@ -77,7 +78,7 @@ private:
  G4UIcommand* fpCommand;
 };

-class G4VisCommandViewerClear: public G4VVisCommandViewer {
+class G4VisCommandViewerClear: public G4VVisCommand {
 public:
  G4VisCommandViewerClear ();
  virtual ~G4VisCommandViewerClear ();
@@ -89,7 +90,7 @@ private:
  G4UIcmdWithAString* fpCommand;
 };

-class G4VisCommandViewerClearCutawayPlanes: public G4VVisCommandViewer {
+class G4VisCommandViewerClearCutawayPlanes: public G4VVisCommand {
 public:
  G4VisCommandViewerClearCutawayPlanes ();
  virtual ~G4VisCommandViewerClearCutawayPlanes ();
@@ -101,7 +102,7 @@ private:
  G4UIcmdWithoutParameter* fpCommand;
 };

-class G4VisCommandViewerClearTransients: public G4VVisCommandViewer {
+class G4VisCommandViewerClearTransients: public G4VVisCommand {
 public:
  G4VisCommandViewerClearTransients ();
  virtual ~G4VisCommandViewerClearTransients ();
@@ -114,7 +115,7 @@ private:
  G4UIcmdWithAString* fpCommand;
 };

-class G4VisCommandViewerClearVisAttributesModifiers: public G4VVisCommandViewer {
+class G4VisCommandViewerClearVisAttributesModifiers: public G4VVisCommand {
 public:
  G4VisCommandViewerClearVisAttributesModifiers ();
  virtual ~G4VisCommandViewerClearVisAttributesModifiers ();
@@ -126,7 +127,7 @@ private:
  G4UIcmdWithoutParameter* fpCommand;
 };

-class G4VisCommandViewerClone: public G4VVisCommandViewer {
+class G4VisCommandViewerClone: public G4VVisCommand {
 public:
  G4VisCommandViewerClone ();
  virtual ~G4VisCommandViewerClone ();
@@ -139,7 +140,7 @@ private:
  G4UIcommand* fpCommand;
 };

-class G4VisCommandViewerColourByDensity: public G4VVisCommandViewer {
+class G4VisCommandViewerColourByDensity: public G4VVisCommand {
 public:
  G4VisCommandViewerColourByDensity ();
  virtual ~G4VisCommandViewerColourByDensity ();
@@ -151,7 +152,7 @@ private:
  G4UIcommand* fpCommand;
 };

-class G4VisCommandViewerCopyViewFrom: public G4VVisCommandViewer {
+class G4VisCommandViewerCopyViewFrom: public G4VVisCommand {
 public:
  G4VisCommandViewerCopyViewFrom ();
  virtual ~G4VisCommandViewerCopyViewFrom ();
@@ -164,7 +165,7 @@ private:
  G4UIcmdWithAString* fpCommand;
 };

-class G4VisCommandViewerCreate: public G4VVisCommandViewer {
+class G4VisCommandViewerCreate: public G4VVisCommand {
 public:
  G4VisCommandViewerCreate ();
  virtual ~G4VisCommandViewerCreate ();
@@ -178,7 +179,7 @@ private:
  G4int fId;
 };

-class G4VisCommandViewerDolly: public G4VVisCommandViewer {
+class G4VisCommandViewerDolly: public G4VVisCommand {
 public:
  G4VisCommandViewerDolly ();
  virtual ~G4VisCommandViewerDolly ();
@@ -193,7 +194,7 @@ private:
  G4double fDollyTo;
 };

-class G4VisCommandViewerFlush: public G4VVisCommandViewer {
+class G4VisCommandViewerFlush: public G4VVisCommand {
 public:
  G4VisCommandViewerFlush ();
  virtual ~G4VisCommandViewerFlush ();
@@ -205,7 +206,7 @@ private:
  G4UIcmdWithAString* fpCommand;
 };

-class G4VisCommandViewerInterpolate: public G4VVisCommandViewer {
+class G4VisCommandViewerInterpolate: public G4VVisCommand {
 public:
  G4VisCommandViewerInterpolate ();
  virtual ~G4VisCommandViewerInterpolate ();
@@ -217,7 +218,7 @@ private:
  G4UIcommand* fpCommand;
 };

-class G4VisCommandViewerList: public G4VVisCommandViewer {
+class G4VisCommandViewerList: public G4VVisCommand {
 public:
  G4VisCommandViewerList ();
  virtual ~G4VisCommandViewerList ();
@@ -229,7 +230,7 @@ private:
  G4UIcommand* fpCommand;
 };

-class G4VisCommandViewerPan: public G4VVisCommandViewer {
+class G4VisCommandViewerPan: public G4VVisCommand {
 public:
  G4VisCommandViewerPan ();
  virtual ~G4VisCommandViewerPan ();
@@ -244,7 +245,7 @@ private:
  G4double fPanToRight, fPanToUp;
 };

-class G4VisCommandViewerReset: public G4VVisCommandViewer {
+class G4VisCommandViewerReset: public G4VVisCommand {
 public:
  G4VisCommandViewerReset ();
  virtual ~G4VisCommandViewerReset ();
@@ -256,7 +257,7 @@ private:
  G4UIcmdWithAString* fpCommand;
 };

-class G4VisCommandViewerRefresh: public G4VVisCommandViewer {
+class G4VisCommandViewerRefresh: public G4VVisCommand {
 public:
  G4VisCommandViewerRefresh ();
  virtual ~G4VisCommandViewerRefresh ();
@@ -268,7 +269,7 @@ private:
  G4UIcmdWithAString* fpCommand;
 };

-class G4VisCommandViewerRebuild: public G4VVisCommandViewer {
+class G4VisCommandViewerRebuild: public G4VVisCommand {
 public:
  G4VisCommandViewerRebuild ();
  virtual ~G4VisCommandViewerRebuild ();
@@ -280,7 +281,7 @@ private:
  G4UIcmdWithAString* fpCommand;
 };

-class G4VisCommandViewerSave: public G4VVisCommandViewer {
+class G4VisCommandViewerSave: public G4VVisCommand {
 public:
  G4VisCommandViewerSave ();
  virtual ~G4VisCommandViewerSave ();
@@ -292,7 +293,7 @@ private:
  G4UIcmdWithAString* fpCommand;
 };

-class G4VisCommandViewerScale: public G4VVisCommandViewer {
+class G4VisCommandViewerScale: public G4VVisCommand {
 public:
  G4VisCommandViewerScale ();
  virtual ~G4VisCommandViewerScale ();
@@ -307,7 +308,7 @@ private:
  G4Vector3D fScaleTo;
 };

-class G4VisCommandViewerSelect: public G4VVisCommandViewer {
+class G4VisCommandViewerSelect: public G4VVisCommand {
 public:
  G4VisCommandViewerSelect ();
  virtual ~G4VisCommandViewerSelect ();
@@ -319,7 +320,7 @@ private:
  G4UIcmdWithAString* fpCommand;
 };

-class G4VisCommandViewerUpdate: public G4VVisCommandViewer {
+class G4VisCommandViewerUpdate: public G4VVisCommand {
 public:
  G4VisCommandViewerUpdate ();
  virtual ~G4VisCommandViewerUpdate ();
@@ -331,7 +332,7 @@ private:
  G4UIcmdWithAString* fpCommand;
 };

-class G4VisCommandViewerZoom: public G4VVisCommandViewer {
+class G4VisCommandViewerZoom: public G4VVisCommand {
 public:
  G4VisCommandViewerZoom ();
  virtual ~G4VisCommandViewerZoom ();
@@ -42,7 +42,7 @@ class G4UIcmdWithAnInteger;
 class G4UIcmdWithADouble;
 class G4UIcmdWith3VectorAndUnit;

-class G4VisCommandsViewerSet: public G4VVisCommandViewer {
+class G4VisCommandsViewerSet: public G4VVisCommand {
 public:
  G4VisCommandsViewerSet ();
  virtual ~G4VisCommandsViewerSet ();
@@ -65,11 +65,12 @@ private:
  G4UIcmdWithADouble*   fpCommandGlobalLineWidthScale;
  G4UIcmdWithABool*     fpCommandHiddenEdge;
  G4UIcmdWithABool*     fpCommandHiddenMarker;
-  G4UIcmdWithAnInteger* fpCommandLineSegments;
  G4UIcmdWithAString*   fpCommandLightsMove;
  G4UIcommand*          fpCommandLightsThetaPhi;
  G4UIcommand*          fpCommandLightsVector;
  G4ThreeVector         fLightsVector;
+  G4UIcmdWithAnInteger* fpCommandLineSegments;
+  G4UIcmdWithAnInteger* fpCommandNumberOfCloudPoints;
  G4UIcmdWithABool*     fpCommandPicking;
  G4UIcommand*          fpCommandProjection;
  G4UIcmdWithAString*   fpCommandRotationStyle;