Import Geant4 11.1.0 source tree

source/graphics_reps/include/G4AttCheck.hh

@@ -61,7 +61,7 @@ public: // With description
   (const std::vector<G4AttValue>* values,
    const std::map<G4String,G4AttDef>* definitions);
 
-  ~G4AttCheck();
+  ~G4AttCheck() = default;
 
   const std::vector<G4AttValue>* GetAttValues() const {
     return fpValues;

source/graphics_reps/include/G4AttDef.hh

@@ -77,8 +77,8 @@
       m_typeKey(typeKey)
     {};
 
-    G4AttDef(){};
-    virtual ~G4AttDef(){};
+    G4AttDef()= default;
+    virtual ~G4AttDef()= default;
     
     const G4String& GetName()const{return m_name;};
     const G4String& GetDesc()const{return m_desc;};

source/graphics_reps/include/G4AttHolder.hh

@@ -53,8 +53,10 @@ class G4AttHolder {
 
 public:
 
-  G4AttHolder() {}
+  G4AttHolder() = default;
   ~G4AttHolder();  // Note: G4AttValues are deleted here.
+  G4AttHolder(const G4AttHolder&) = delete;  // Copy construction not allowed.
+  G4AttHolder& operator=(const G4AttHolder&) = delete;  // Assignment not allowed.
 
   const std::vector<const std::vector<G4AttValue>*>& GetAttValues() const
   {return fValues;}
@@ -69,8 +71,6 @@ public:
   // life.
 
 private:
-  G4AttHolder(const G4AttHolder&);  // Copy construction not allowed.
-  G4AttHolder& operator=(const G4AttHolder&);  // Assignment not allowed.
   std::vector<const std::vector<G4AttValue>*> fValues;
   std::vector<const std::map<G4String,G4AttDef>*> fDefs;
 };

source/graphics_reps/include/G4AttUtils.hh

@@ -61,7 +61,8 @@ namespace G4AttUtils {
   G4bool ExtractAttDef(const T& object, const G4String& name, G4AttDef& def) 
   {
     const std::map<G4String, G4AttDef>* attDefs = object.GetAttDefs();
-
+    
+    // NOLINTNEXTLINE(modernize-use-auto): Explicitly want a const_iterator despite attDefs being const
     std::map<G4String, G4AttDef>::const_iterator iter = attDefs->find(name);
     if (iter == attDefs->end()) return false;    
     
@@ -76,9 +77,9 @@ namespace G4AttUtils {
   {
     std::vector<G4AttValue>* attValues = object.CreateAttValues();
     
-    std::vector<G4AttValue>::iterator iter = std::find_if(attValues->begin(), attValues->end(), 
+    auto iter = std::find_if(attValues->cbegin(), attValues->cend(), 
                                                           HasName<G4AttValue>(name));
-    if (iter == attValues->end()) return false;
+    if (iter == attValues->cend()) return false;
     
     attVal = *iter;
     

source/graphics_reps/include/G4AttValue.hh

@@ -57,7 +57,7 @@
                const G4String& showLabel): 
       m_name(name),m_value(value),
       m_showLabel(showLabel){};
-    G4AttValue(){};
+    G4AttValue()= default;
     
     const G4String& GetName()const{return m_name;};
     const G4String& GetValue()const{return m_value;};

source/graphics_reps/include/G4Circle.hh

@@ -46,7 +46,7 @@ public: // With description
   G4Circle ();
   G4Circle (const G4VMarker&);
   G4Circle (const G4Point3D& position);
-  virtual ~G4Circle ();
+  ~G4Circle () override;
 
  };
 

source/graphics_reps/include/G4Color.hh

@@ -38,6 +38,6 @@
 
 #include "G4Colour.hh"
 
-typedef G4Colour G4Color;
+using G4Color = G4Colour;
 
 #endif

source/graphics_reps/include/G4DimensionedDouble.hh

@@ -33,6 +33,6 @@
 
 #include "G4DimensionedType.hh"
 
-typedef G4DimensionedType<G4double> G4DimensionedDouble;
+using G4DimensionedDouble = G4DimensionedType<G4double>;
 
 #endif

source/graphics_reps/include/G4DimensionedThreeVector.hh

@@ -33,6 +33,6 @@
 
 #include "G4DimensionedType.hh"
 
-typedef G4DimensionedType<G4ThreeVector> G4DimensionedThreeVector;
+using G4DimensionedThreeVector = G4DimensionedType<G4ThreeVector>;
 
 #endif

source/graphics_reps/include/G4DimensionedType.hh

@@ -103,7 +103,7 @@ G4DimensionedType<T, ConversionErrorPolicy>::G4DimensionedType(const T& value, c
 }
 
 template <typename T, typename ConversionErrorPolicy>
-G4DimensionedType<T, ConversionErrorPolicy>::~G4DimensionedType() {}
+G4DimensionedType<T, ConversionErrorPolicy>::~G4DimensionedType() = default;
 
 template <typename T, typename ConversionErrorPolicy>
 T

source/graphics_reps/include/G4PlacedPolyhedron.hh

@@ -69,6 +69,6 @@ private:
 
 };
 
-typedef std::vector<G4PlacedPolyhedron> G4PlacedPolyhedronList;
+using G4PlacedPolyhedronList = std::vector<G4PlacedPolyhedron>;
 
 #endif /* G4PLACEDPOLYHEDRON_HH */

source/graphics_reps/include/G4Plotter.hh

@@ -76,8 +76,8 @@ public:
   const std::vector<Region_h2>& GetRegionH2s() const {return fRegion_h2s;}
 
 private:
-  unsigned int fColumns;
-  unsigned int fRows;
+  unsigned int fColumns{1};
+  unsigned int fRows{1};
   std::vector<G4String> fStyles;
   std::vector<RegionStyle> fRegionStyles;
   std::vector<RegionParameter> fRegionParameters;

source/graphics_reps/include/G4Point3DList.hh

@@ -45,7 +45,7 @@ class G4Point3DList: public std::vector<G4Point3D> {
   
 public:
 
-  typedef std::vector<G4Point3D>::iterator iterator;
+  using iterator = std::vector<G4Point3D>::iterator;
 
   virtual ~G4Point3DList();
 

source/graphics_reps/include/G4Polyhedron.hh

@@ -147,7 +147,7 @@ public:
   G4Polyhedron & operator=(G4Polyhedron && from) = default;
 
   // Destructor
-  virtual ~G4Polyhedron ();
+  ~G4Polyhedron () override;
 
   G4int GetNumberOfRotationStepsAtTimeOfCreation() const {
     return fNumberOfRotationStepsAtTimeOfCreation;
@@ -159,14 +159,14 @@ private:
 class G4PolyhedronBox: public G4Polyhedron {
 public:
   G4PolyhedronBox (G4double dx, G4double dy, G4double dz);
-  virtual ~G4PolyhedronBox ();
+  ~G4PolyhedronBox () override;
 };
 
 class G4PolyhedronCone: public G4Polyhedron {
 public:
   G4PolyhedronCone (G4double Rmn1, G4double Rmx1,
                     G4double Rmn2, G4double Rmx2, G4double Dz);
-  virtual ~G4PolyhedronCone ();
+  ~G4PolyhedronCone () override;
 };
 
 class G4PolyhedronCons: public G4Polyhedron {
@@ -174,14 +174,14 @@ public:
   G4PolyhedronCons (G4double Rmn1, G4double Rmx1,
                     G4double Rmn2, G4double Rmx2, G4double Dz,
                     G4double Phi1, G4double Dphi);
-  virtual ~G4PolyhedronCons ();
+  ~G4PolyhedronCons () override;
 };
 
 class G4PolyhedronPara: public G4Polyhedron {
 public:
   G4PolyhedronPara (G4double Dx, G4double Dy, G4double Dz,
                     G4double Alpha, G4double Theta, G4double Phi);
-  virtual ~G4PolyhedronPara ();
+  ~G4PolyhedronPara () override;
 };
 
 class G4PolyhedronPcon: public G4Polyhedron {
@@ -192,7 +192,7 @@ public:
                     const G4double *rmax);
   G4PolyhedronPcon (G4double phi, G4double dphi,
                     const std::vector<G4TwoVector> &rz);
-  virtual ~G4PolyhedronPcon ();
+  ~G4PolyhedronPcon () override;
 };
 
 class G4PolyhedronPgon: public G4Polyhedron {
@@ -204,7 +204,7 @@ public:
   G4PolyhedronPgon (G4double phi, G4double dphi, G4int npdv,
                     const std::vector<G4TwoVector> &rz);
 
-  virtual ~G4PolyhedronPgon ();
+  ~G4PolyhedronPgon () override;
 };
 
 class G4PolyhedronSphere: public G4Polyhedron {
@@ -212,7 +212,7 @@ public:
   G4PolyhedronSphere (G4double rmin, G4double rmax,
                       G4double phi, G4double dphi,
                       G4double the, G4double dthe);
-  virtual ~G4PolyhedronSphere ();
+  ~G4PolyhedronSphere () override;
 };
 
 class G4PolyhedronTet: public G4Polyhedron {
@@ -221,14 +221,14 @@ public:
                    const G4double p1[3],
                    const G4double p2[3],
                    const G4double p3[3]);
-  virtual ~G4PolyhedronTet ();
+  ~G4PolyhedronTet () override;
 };
 
 class G4PolyhedronTorus: public G4Polyhedron {
 public:
   G4PolyhedronTorus (G4double rmin, G4double rmax, G4double rtor,
                     G4double phi, G4double dphi);
-  virtual ~G4PolyhedronTorus ();
+  ~G4PolyhedronTorus () override;
 };
 
 class G4PolyhedronTrap: public G4Polyhedron {
@@ -238,74 +238,74 @@ public:
                     G4double Dx1, G4double Dx2, G4double Alp1,
                     G4double Dy2,
                     G4double Dx3, G4double Dx4, G4double Alp2);
-  virtual ~G4PolyhedronTrap ();
+  ~G4PolyhedronTrap () override;
 };
 
 class G4PolyhedronTrd1: public G4Polyhedron {
 public:
   G4PolyhedronTrd1 (G4double Dx1, G4double Dx2,
                     G4double Dy, G4double Dz);
-  virtual ~G4PolyhedronTrd1 ();
+  ~G4PolyhedronTrd1 () override;
 };
 
 class G4PolyhedronTrd2: public G4Polyhedron {
 public:
   G4PolyhedronTrd2 (G4double Dx1, G4double Dx2,
                     G4double Dy1, G4double Dy2, G4double Dz);
-  virtual ~G4PolyhedronTrd2 ();
+  ~G4PolyhedronTrd2 () override;
 };
 
 class G4PolyhedronTube: public G4Polyhedron {
 public:
   G4PolyhedronTube (G4double Rmin, G4double Rmax, G4double Dz);
-  virtual ~G4PolyhedronTube ();
+  ~G4PolyhedronTube () override;
 };
 
 class G4PolyhedronTubs: public G4Polyhedron {
 public:
   G4PolyhedronTubs (G4double Rmin, G4double Rmax, G4double Dz,
                     G4double Phi1, G4double Dphi);
-  virtual ~G4PolyhedronTubs ();
+  ~G4PolyhedronTubs () override;
 };
 
 class G4PolyhedronParaboloid: public G4Polyhedron {
  public:
   G4PolyhedronParaboloid(G4double r1, G4double r2, G4double dz,
                          G4double sPhi, G4double dPhi);
-  virtual ~G4PolyhedronParaboloid ();
+  ~G4PolyhedronParaboloid () override;
 };
 
 class G4PolyhedronHype: public G4Polyhedron {
  public:
   G4PolyhedronHype(G4double r1, G4double r2, G4double tan1,
                    G4double tan2, G4double halfZ);
-  virtual ~G4PolyhedronHype ();
+  ~G4PolyhedronHype () override;
 };
 
 class G4PolyhedronEllipsoid : public G4Polyhedron {
  public:
   G4PolyhedronEllipsoid(G4double dx, G4double dy, G4double dz,
                         G4double zcut1, G4double zcut2);
-  virtual ~G4PolyhedronEllipsoid ();
+  ~G4PolyhedronEllipsoid () override;
 };
 
 class G4PolyhedronEllipticalCone : public G4Polyhedron {
  public:
   G4PolyhedronEllipticalCone(G4double dx, G4double dy, G4double z,
                              G4double zcut1);
-  virtual ~G4PolyhedronEllipticalCone ();
+  ~G4PolyhedronEllipticalCone () override;
 };
 
 class G4PolyhedronHyperbolicMirror : public G4Polyhedron {
  public:
   G4PolyhedronHyperbolicMirror(G4double a, G4double h, G4double r);
-  virtual ~G4PolyhedronHyperbolicMirror ();
+  ~G4PolyhedronHyperbolicMirror () override;
 };
 
 class G4PolyhedronTetMesh : public G4Polyhedron {
  public:
   G4PolyhedronTetMesh(const std::vector<G4ThreeVector>& tetrahedra);
-  virtual ~G4PolyhedronTetMesh ();
+  ~G4PolyhedronTetMesh () override;
 };
 
 class G4PolyhedronBoxMesh : public G4Polyhedron {
@@ -313,7 +313,7 @@ class G4PolyhedronBoxMesh : public G4Polyhedron {
   G4PolyhedronBoxMesh(G4double sizeX, G4double sizeY, G4double sizeZ,
                       const std::vector<G4ThreeVector>& positions);
 
-  virtual ~G4PolyhedronBoxMesh ();
+  ~G4PolyhedronBoxMesh () override;
 };
 
 std::ostream& operator<<(std::ostream& os, const G4Polyhedron&);

source/graphics_reps/include/G4PolyhedronArbitrary.hh

@@ -76,8 +76,12 @@ class G4PolyhedronArbitrary : public G4Polyhedron
 {
   public:
     G4PolyhedronArbitrary (const G4int nVertices, const G4int nFacets);
-    virtual ~G4PolyhedronArbitrary ();
-    
+    ~G4PolyhedronArbitrary () override;
+    // Private copy constructor and assignment operator added to satisfy
+    // Coverity - JA 11/11/11.
+    G4PolyhedronArbitrary(const G4PolyhedronArbitrary&) = delete;
+    G4PolyhedronArbitrary& operator= (const G4PolyhedronArbitrary&) = delete;    
+
     void AddVertex (const G4ThreeVector& v);
     void AddFacet (const G4int iv1, const G4int iv2, const G4int iv3,
       const G4int iv4=0);
@@ -92,11 +96,6 @@ class G4PolyhedronArbitrary : public G4Polyhedron
     G4int nVertexCount;
     G4int nFacetCount;
 
-  private:
-    // Private copy constructor and assignment operator added to satisfy
-    // Coverity - JA 11/11/11.
-    G4PolyhedronArbitrary(const G4PolyhedronArbitrary&);
-    G4PolyhedronArbitrary& operator= (const G4PolyhedronArbitrary&);
 };
 #endif
 ///////////////////////////////////////////////////////////////////////////////

source/graphics_reps/include/G4Polyline.hh

@@ -49,10 +49,10 @@ class G4Polyline: public G4Visible, public G4Point3DList {
 
 public: // With description
 
-  typedef G4Point3DList::iterator iterator;
+  using iterator = G4Point3DList::iterator;
 
   G4Polyline ();
-  virtual ~G4Polyline ();
+  ~G4Polyline () override;
   G4Polyline& transform (const G4Transform3D&);
 };
 

source/graphics_reps/include/G4Polymarker.hh

@@ -47,7 +47,7 @@ public: // With description
   enum MarkerType {dots, circles, squares};
   G4Polymarker ();
   G4Polymarker (const G4VMarker&);
-  virtual ~G4Polymarker ();
+  ~G4Polymarker () override;
   MarkerType GetMarkerType () const;
   void SetMarkerType (MarkerType);
 private:

source/graphics_reps/include/G4Square.hh

@@ -46,7 +46,7 @@ public: // With description
   G4Square ();
   G4Square (const G4VMarker&);
   G4Square (const G4Point3D& position);
-  ~G4Square ();
+  ~G4Square () override;
 
 };
 

source/graphics_reps/include/G4Square.icc

@@ -28,7 +28,7 @@
 // 
 // John Allison  17/11/96.
 
-inline G4Square::G4Square () {}
+inline G4Square::G4Square () = default;
 
 inline G4Square::G4Square (const G4Point3D& pos):
 G4VMarker (pos) {}

source/graphics_reps/include/G4Text.hh

@@ -79,7 +79,7 @@ public: // With description
   G4Text (const G4VMarker&);
   G4Text (const G4Text&) = default;
   G4Text (G4Text&&) = default;
-  virtual ~G4Text ();
+  ~G4Text () override;
   G4Text& operator= (const G4Text&) = default;
   G4Text& operator= (G4Text&&) = default;
 

source/graphics_reps/include/G4TypeKey.hh

@@ -38,16 +38,16 @@ class G4TypeKey {
 
 public:
 
-  typedef unsigned long Key;
+  using Key = unsigned long;
 
   // Constructor
-  G4TypeKey():fMyKey(0) {}
+  G4TypeKey() = default;
 
   // Destructor
-  virtual ~G4TypeKey() {}
+  virtual ~G4TypeKey() = default;
 
   G4bool IsValid() {
-    return (0 == fMyKey ? false : true);
+    return (0 != fMyKey);
   }
   
   // Operators
@@ -64,13 +64,13 @@ public:
 protected:
 
   Key NextKey() const {
-    static G4ThreadLocal Key *npKey = 0 ;
-    if (!npKey) { npKey = new Key; *npKey = 0; }
+    static G4ThreadLocal Key *npKey = nullptr ;
+    if (npKey == nullptr) { npKey = new Key; *npKey = 0; }
     Key &nKey = *npKey;
     return ++nKey;
   }
 
-  Key fMyKey;
+  Key fMyKey{0};
 
 };
 

source/graphics_reps/include/G4TypeKeyT.hh

@@ -39,13 +39,13 @@ class G4TypeKeyT : public G4TypeKey {
 public:
   
   G4TypeKeyT() {
-    static G4ThreadLocal Key *pkey = 0 ;
-    if (!pkey) { pkey = new Key; *pkey = NextKey(); }
+    static G4ThreadLocal Key *pkey = nullptr ;
+    if (pkey == nullptr) { pkey = new Key; *pkey = NextKey(); }
     Key &key = *pkey;
     fMyKey = key;
   }
 
-  virtual ~G4TypeKeyT() {}
+  ~G4TypeKeyT() override = default;
 
 };
 

source/graphics_reps/include/G4VMarker.hh

@@ -105,7 +105,7 @@ public: // With description
 
   //////////////////////////////////////////////////////
   // Destructor...
-  virtual ~G4VMarker ();
+  ~G4VMarker () override;
 
   //////////////////////////////////////////////////////
   // Assignment...

source/graphics_reps/include/G4VVisManager.hh

@@ -169,6 +169,10 @@ public: // With description
   virtual void Draw (const G4VSolid&, const G4VisAttributes&,
     const G4Transform3D& objectTransformation = G4Transform3D()) = 0;
 
+  virtual void DrawGeometry
+  (G4VPhysicalVolume*, const G4Transform3D& t = G4Transform3D());
+  // Draws a geometry tree starting at the specified physical volume.
+
   //////////////////////////////////////////////////////////////////////
   // Optional methods that you may use to bracket a series of Draw
   // messages that have identical objectTransformation to improve

source/graphics_reps/include/G4VisAttributes.hh

@@ -79,8 +79,8 @@ public: // With description
   G4VisAttributes (G4bool visibility);
   G4VisAttributes (const G4Colour& colour);
   G4VisAttributes (G4bool visibility, const G4Colour& colour);
-  G4VisAttributes (const G4VisAttributes&);
-  ~G4VisAttributes ();
+  G4VisAttributes (const G4VisAttributes&) = default;
+  ~G4VisAttributes () = default;
   G4VisAttributes& operator= (const G4VisAttributes&);
 
   static const G4VisAttributes& GetInvisible();

source/graphics_reps/include/HepPolyhedron.h

@@ -281,7 +281,7 @@ class HepPolyhedron {
 
  public:
   // Default constructor
-  HepPolyhedron() : nvert(0), nface(0), pV(0), pF(0) {}
+  HepPolyhedron() : nvert(0), nface(0), pV(nullptr), pF(nullptr) {}
 
   // Constructor with allocation of memory
   HepPolyhedron(G4int Nvert, G4int Nface);
@@ -345,15 +345,15 @@ class HepPolyhedron {
 
   // Get face by index
   void GetFacet(G4int iFace, G4int &n, G4int *iNodes,
-                G4int *edgeFlags = 0, G4int *iFaces = 0) const;
+                G4int *edgeFlags = nullptr, G4int *iFaces = nullptr) const;
 
   // Get face by index
   void GetFacet(G4int iFace, G4int &n, G4Point3D *nodes,
-                G4int *edgeFlags=0, G4Normal3D *normals=0) const;
+                G4int *edgeFlags=nullptr, G4Normal3D *normals=nullptr) const;
 
   // Get next face with normals at the nodes
-  G4bool GetNextFacet(G4int &n, G4Point3D *nodes, G4int *edgeFlags=0,
-                      G4Normal3D *normals=0) const;
+  G4bool GetNextFacet(G4int &n, G4Point3D *nodes, G4int *edgeFlags=nullptr,
+                      G4Normal3D *normals=nullptr) const;
 
   // Get normal of the face given by index
   G4Normal3D GetNormal(G4int iFace) const;
@@ -442,7 +442,7 @@ class HepPolyhedronTrd2 : public HepPolyhedron
  public:
   HepPolyhedronTrd2(G4double Dx1, G4double Dx2,
                     G4double Dy1, G4double Dy2, G4double Dz);
-  virtual ~HepPolyhedronTrd2();
+  ~HepPolyhedronTrd2() override;
 };
 
 class HepPolyhedronTrd1 : public HepPolyhedronTrd2
@@ -450,14 +450,14 @@ class HepPolyhedronTrd1 : public HepPolyhedronTrd2
  public:
   HepPolyhedronTrd1(G4double Dx1, G4double Dx2,
                     G4double Dy, G4double Dz);
-  virtual ~HepPolyhedronTrd1();
+  ~HepPolyhedronTrd1() override;
 };
 
 class HepPolyhedronBox : public HepPolyhedronTrd2
 {
  public:
   HepPolyhedronBox(G4double Dx, G4double Dy, G4double Dz);
-  virtual ~HepPolyhedronBox();
+  ~HepPolyhedronBox() override;
 };
 
 class HepPolyhedronTrap : public HepPolyhedron
@@ -468,7 +468,7 @@ class HepPolyhedronTrap : public HepPolyhedron
                     G4double Dx1, G4double Dx2, G4double Alp1,
                     G4double Dy2,
                     G4double Dx3, G4double Dx4, G4double Alp2);
-  virtual ~HepPolyhedronTrap();
+  ~HepPolyhedronTrap() override;
 };
 
 class HepPolyhedronPara : public HepPolyhedronTrap
@@ -476,7 +476,7 @@ class HepPolyhedronPara : public HepPolyhedronTrap
  public:
   HepPolyhedronPara(G4double Dx, G4double Dy, G4double Dz,
                     G4double Alpha, G4double Theta, G4double Phi);
-  virtual ~HepPolyhedronPara();
+  ~HepPolyhedronPara() override;
 };
 
 class HepPolyhedronParaboloid : public HepPolyhedron
@@ -487,7 +487,7 @@ class HepPolyhedronParaboloid : public HepPolyhedron
                           G4double dz,
                           G4double Phi1,
                           G4double Dphi);
-  virtual ~HepPolyhedronParaboloid();
+  ~HepPolyhedronParaboloid() override;
 };
 
 class HepPolyhedronHype : public HepPolyhedron
@@ -498,7 +498,7 @@ class HepPolyhedronHype : public HepPolyhedron
                     G4double tan1,
                     G4double tan2,
                     G4double halfZ);
-  virtual ~HepPolyhedronHype();
+  ~HepPolyhedronHype() override;
 };
 
 class HepPolyhedronCons : public HepPolyhedron
@@ -507,7 +507,7 @@ class HepPolyhedronCons : public HepPolyhedron
   HepPolyhedronCons(G4double Rmn1, G4double Rmx1,
                     G4double Rmn2, G4double Rmx2, G4double Dz,
                     G4double Phi1, G4double Dphi);
-  virtual ~HepPolyhedronCons();
+  ~HepPolyhedronCons() override;
 };
 
 class HepPolyhedronCone : public HepPolyhedronCons
@@ -515,7 +515,7 @@ class HepPolyhedronCone : public HepPolyhedronCons
  public:
   HepPolyhedronCone(G4double Rmn1, G4double Rmx1,
                     G4double Rmn2, G4double Rmx2, G4double Dz);
-  virtual ~HepPolyhedronCone();
+  ~HepPolyhedronCone() override;
 };
 
 class HepPolyhedronTubs : public HepPolyhedronCons
@@ -523,14 +523,14 @@ class HepPolyhedronTubs : public HepPolyhedronCons
  public:
   HepPolyhedronTubs(G4double Rmin, G4double Rmax, G4double Dz,
                     G4double Phi1, G4double Dphi);
-  virtual ~HepPolyhedronTubs();
+  ~HepPolyhedronTubs() override;
 };
 
 class HepPolyhedronTube : public HepPolyhedronCons
 {
  public:
   HepPolyhedronTube (G4double Rmin, G4double Rmax, G4double Dz);
-  virtual ~HepPolyhedronTube();
+  ~HepPolyhedronTube() override;
 };
 
 class HepPolyhedronPgon : public HepPolyhedron
@@ -542,7 +542,7 @@ class HepPolyhedronPgon : public HepPolyhedron
                     const G4double *rmax);
   HepPolyhedronPgon(G4double phi, G4double dphi, G4int npdv,
                     const std::vector<G4TwoVector> &rz);
-  virtual ~HepPolyhedronPgon();
+  ~HepPolyhedronPgon() override;
 };
 
 class HepPolyhedronPcon : public HepPolyhedronPgon
@@ -554,7 +554,7 @@ class HepPolyhedronPcon : public HepPolyhedronPgon
                     const G4double *rmax);
   HepPolyhedronPcon(G4double phi, G4double dphi,
                     const std::vector<G4TwoVector> &rz);
-  virtual ~HepPolyhedronPcon();
+  ~HepPolyhedronPcon() override;
 };
 
 class HepPolyhedronSphere : public HepPolyhedron
@@ -563,7 +563,7 @@ class HepPolyhedronSphere : public HepPolyhedron
   HepPolyhedronSphere(G4double rmin, G4double rmax,
                       G4double phi, G4double dphi,
                       G4double the, G4double dthe);
-  virtual ~HepPolyhedronSphere();
+  ~HepPolyhedronSphere() override;
 };
 
 class HepPolyhedronTorus : public HepPolyhedron
@@ -571,7 +571,7 @@ class HepPolyhedronTorus : public HepPolyhedron
  public:
   HepPolyhedronTorus(G4double rmin, G4double rmax, G4double rtor,
                      G4double phi, G4double dphi);
-  virtual ~HepPolyhedronTorus();
+  ~HepPolyhedronTorus() override;
 };
 
 class HepPolyhedronTet : public HepPolyhedron
@@ -581,7 +581,7 @@ class HepPolyhedronTet : public HepPolyhedron
                    const G4double p1[3],
                    const G4double p2[3],
                    const G4double p3[3]);
-  virtual ~HepPolyhedronTet();
+  ~HepPolyhedronTet() override;
 };
 
 class HepPolyhedronEllipsoid : public HepPolyhedron
@@ -589,7 +589,7 @@ class HepPolyhedronEllipsoid : public HepPolyhedron
  public:
   HepPolyhedronEllipsoid(G4double dx, G4double dy, G4double dz,
                          G4double zcut1, G4double zcut2);
-  virtual ~HepPolyhedronEllipsoid();
+  ~HepPolyhedronEllipsoid() override;
 };
 
 class HepPolyhedronEllipticalCone : public HepPolyhedron
@@ -597,21 +597,21 @@ class HepPolyhedronEllipticalCone : public HepPolyhedron
  public:
   HepPolyhedronEllipticalCone(G4double dx, G4double dy, G4double z,
                               G4double zcut1);
-  virtual ~HepPolyhedronEllipticalCone();
+  ~HepPolyhedronEllipticalCone() override;
 };
 
 class HepPolyhedronHyperbolicMirror : public HepPolyhedron
 {
  public:
   HepPolyhedronHyperbolicMirror(G4double a, G4double h, G4double r);
-  virtual ~HepPolyhedronHyperbolicMirror();
+  ~HepPolyhedronHyperbolicMirror() override;
 };
 
 class HepPolyhedronTetMesh : public HepPolyhedron
 {
  public:
   HepPolyhedronTetMesh(const std::vector<G4ThreeVector>& tetrahedra);
-  virtual ~HepPolyhedronTetMesh();
+  ~HepPolyhedronTetMesh() override;
 };
 
 class HepPolyhedronBoxMesh : public HepPolyhedron
@@ -619,7 +619,7 @@ class HepPolyhedronBoxMesh : public HepPolyhedron
  public:
   HepPolyhedronBoxMesh(G4double sizeX, G4double sizeY, G4double sizeZ,
                        const std::vector<G4ThreeVector>& positions);
-  virtual ~HepPolyhedronBoxMesh();
+  ~HepPolyhedronBoxMesh() override;
 };
 
 #endif /* HEP_POLYHEDRON_HH */

source/graphics_reps/include/HepPolyhedronProcessor.h

@@ -39,7 +39,7 @@ public:
     ,SUBTRACTION = 2
   };
 private:
-  typedef std::pair<Operation,HepPolyhedron> op_t;
+  using op_t = std::pair<Operation, HepPolyhedron>;
 public:
   HepPolyhedronProcessor();
   virtual ~HepPolyhedronProcessor();