Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/graphics_reps/include/HepPolyhedron.h

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 ]

Diff markup

Differences between /graphics_reps/include/HepPolyhedron.h (Version 11.3.0) and /graphics_reps/include/HepPolyhedron.h (Version 11.2)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25 //                                                 25 //
 26 // Class Description:                              26 // Class Description:
 27 // HepPolyhedron is an intermediate class betw     27 // HepPolyhedron is an intermediate class between description of a shape
 28 // and visualization systems. It is intended t     28 // and visualization systems. It is intended to provide some service like:
 29 //   - polygonization of shapes with trianguli     29 //   - polygonization of shapes with triangulization (quadrilaterization)
 30 //     of complex polygons;                        30 //     of complex polygons;
 31 //   - calculation of normals for faces and ve     31 //   - calculation of normals for faces and vertices;
 32 //   - finding result of boolean operation on      32 //   - finding result of boolean operation on polyhedra;
 33 //                                                 33 //
 34 // Public constructors:                            34 // Public constructors:
 35 //                                                 35 //
 36 //   HepPolyhedronBox (dx,dy,dz)                   36 //   HepPolyhedronBox (dx,dy,dz)
 37 //                                        - cr     37 //                                        - create polyhedron for Box;
 38 //   HepPolyhedronTrd1 (dx1,dx2,dy,dz)             38 //   HepPolyhedronTrd1 (dx1,dx2,dy,dz)
 39 //                                        - cr     39 //                                        - create polyhedron for Trd1;
 40 //   HepPolyhedronTrd2 (dx1,dx2,dy1,dy2,dz)        40 //   HepPolyhedronTrd2 (dx1,dx2,dy1,dy2,dz)
 41 //                                        - cr     41 //                                        - create polyhedron for Trd2;
 42 //   HepPolyhedronTrap (dz,theta,phi, h1,bl1,t     42 //   HepPolyhedronTrap (dz,theta,phi, h1,bl1,tl1,alp1, h2,bl2,tl2,alp2)
 43 //                                        - cr     43 //                                        - create polyhedron for Trap;
 44 //   HepPolyhedronPara (dx,dy,dz,alpha,theta,p     44 //   HepPolyhedronPara (dx,dy,dz,alpha,theta,phi)
 45 //                                        - cr     45 //                                        - create polyhedron for Para;
 46 //   HepPolyhedronTube (rmin,rmax,dz)              46 //   HepPolyhedronTube (rmin,rmax,dz)
 47 //                                        - cr     47 //                                        - create polyhedron for Tube;
 48 //   HepPolyhedronTubs (rmin,rmax,dz,phi1,dphi     48 //   HepPolyhedronTubs (rmin,rmax,dz,phi1,dphi)
 49 //                                        - cr     49 //                                        - create polyhedron for Tubs;
 50 //   HepPolyhedronCone (rmin1,rmax1,rmin2,rmax     50 //   HepPolyhedronCone (rmin1,rmax1,rmin2,rmax2,dz)
 51 //                                        - cr     51 //                                        - create polyhedron for Cone;
 52 //   HepPolyhedronCons (rmin1,rmax1,rmin2,rmax     52 //   HepPolyhedronCons (rmin1,rmax1,rmin2,rmax2,dz,phi1,dphi)
 53 //                                        - cr     53 //                                        - create polyhedron for Cons;
 54 //   HepPolyhedronPgon (phi,dphi,npdv,nz, z(*)     54 //   HepPolyhedronPgon (phi,dphi,npdv,nz, z(*),rmin(*),rmax(*))
 55 //                                        - cr     55 //                                        - create polyhedron for Pgon;
 56 //   HepPolyhedronPcon (phi,dphi,nz, z(*),rmin     56 //   HepPolyhedronPcon (phi,dphi,nz, z(*),rmin(*),rmax(*))
 57 //                                        - cr     57 //                                        - create polyhedron for Pcon;
 58 //   HepPolyhedronSphere (rmin,rmax,phi,dphi,t     58 //   HepPolyhedronSphere (rmin,rmax,phi,dphi,the,dthe)
 59 //                                        - cr     59 //                                        - create polyhedron for Sphere;
 60 //   HepPolyhedronTorus (rmin,rmax,rtor,phi,dp     60 //   HepPolyhedronTorus (rmin,rmax,rtor,phi,dphi)
 61 //                                        - cr     61 //                                        - create polyhedron for Torus;
 62 //   HepPolyhedronTet (p0[3],p1[3],p2[3],p3[3]     62 //   HepPolyhedronTet (p0[3],p1[3],p2[3],p3[3])
 63 //                                        - cr     63 //                                        - create polyhedron for Tet;
 64 //   HepPolyhedronEllipsoid (dx,dy,dz,zcut1,zc     64 //   HepPolyhedronEllipsoid (dx,dy,dz,zcut1,zcut2)
 65 //                                        - cr     65 //                                        - create polyhedron for Ellipsoid;
 66 //   HepPolyhedronEllipticalCone(dx,dy,z,zcut1     66 //   HepPolyhedronEllipticalCone(dx,dy,z,zcut1)
 67 //                                        - cr     67 //                                        - create polyhedron for Elliptical cone;
 68 //   HepPolyhedronParaboloid (r1,r2,dz,phi,dph     68 //   HepPolyhedronParaboloid (r1,r2,dz,phi,dphi)
 69 //                                        - cr     69 //                                        - create polyhedron for Paraboloid;
 70 //   HepPolyhedronHype (r1,r2,tan1,tan2,halfz)     70 //   HepPolyhedronHype (r1,r2,tan1,tan2,halfz)
 71 //                                        - cr     71 //                                        - create polyhedron for Hype;
 72 //   HepPolyhedronHyperbolicMirror (a,h,r)         72 //   HepPolyhedronHyperbolicMirror (a,h,r)
 73 //                                        - cr     73 //                                        - create polyhedron for Hyperbolic mirror;
 74 //   HepPolyhedronTetMesh (vector<p>)              74 //   HepPolyhedronTetMesh (vector<p>)
 75 //                                        - cr     75 //                                        - create polyhedron for tetrahedron mesh;
 76 //   HepPolyhedronBoxMesh (sx,sy,sz,vector<p>)     76 //   HepPolyhedronBoxMesh (sx,sy,sz,vector<p>)
 77 //                                        - cr     77 //                                        - create polyhedron for box mesh;
 78 // Public functions:                               78 // Public functions:
 79 //                                                 79 //
 80 //   GetNoVertices ()       - returns number o     80 //   GetNoVertices ()       - returns number of vertices;
 81 //   GetNoFacets ()         - returns number o     81 //   GetNoFacets ()         - returns number of faces;
 82 //   GetNextVertexIndex (index,edgeFlag) - get     82 //   GetNextVertexIndex (index,edgeFlag) - get vertex indices of the
 83 //                            quadrilaterals i     83 //                            quadrilaterals in order;
 84 //                            returns false wh     84 //                            returns false when finished each face;
 85 //   GetVertex (index)      - returns vertex b     85 //   GetVertex (index)      - returns vertex by index;
 86 //   GetNextVertex (vertex,edgeFlag) - get ver     86 //   GetNextVertex (vertex,edgeFlag) - get vertices with edge visibility
 87 //                            of the quadrilat     87 //                            of the quadrilaterals in order;
 88 //                            returns false wh     88 //                            returns false when finished each face;
 89 //   GetNextVertex (vertex,edgeFlag,normal) -      89 //   GetNextVertex (vertex,edgeFlag,normal) - get vertices with edge
 90 //                            visibility and n     90 //                            visibility and normal of the quadrilaterals
 91 //                            in order; return     91 //                            in order; returns false when finished each face;
 92 //   GetNextEdgeIndices (i1,i2,edgeFlag) - get     92 //   GetNextEdgeIndices (i1,i2,edgeFlag) - get indices of the next edge;
 93 //                            returns false fo     93 //                            returns false for the last edge;
 94 //   GetNextEdgeIndices (i1,i2,edgeFlag,iface1     94 //   GetNextEdgeIndices (i1,i2,edgeFlag,iface1,iface2) - get indices of
 95 //                            the next edge wi     95 //                            the next edge with indices of the faces
 96 //                            to which the edg     96 //                            to which the edge belongs;
 97 //                            returns false fo     97 //                            returns false for the last edge;
 98 //   GetNextEdge (p1,p2,edgeFlag) - get next e     98 //   GetNextEdge (p1,p2,edgeFlag) - get next edge;
 99 //                            returns false fo     99 //                            returns false for the last edge;
100 //   GetNextEdge (p1,p2,edgeFlag,iface1,iface2    100 //   GetNextEdge (p1,p2,edgeFlag,iface1,iface2) - get next edge with indices
101 //                            of the faces to     101 //                            of the faces to which the edge belongs;
102 //                            returns false fo    102 //                            returns false for the last edge;
103 //   GetFacet (index,n,nodes,edgeFlags=0,norma    103 //   GetFacet (index,n,nodes,edgeFlags=0,normals=0) - get face by index;
104 //   GetNextFacet (n,nodes,edgeFlags=0,normals    104 //   GetNextFacet (n,nodes,edgeFlags=0,normals=0) - get next face with normals
105 //                            at the nodes; re    105 //                            at the nodes; returns false for the last face;
106 //   GetNormal (index)      - get normal of fa    106 //   GetNormal (index)      - get normal of face given by index;
107 //   GetUnitNormal (index)  - get unit normal     107 //   GetUnitNormal (index)  - get unit normal of face given by index;
108 //   GetNextNormal (normal) - get normals of e    108 //   GetNextNormal (normal) - get normals of each face in order;
109 //                            returns false wh    109 //                            returns false when finished all faces;
110 //   GetNextUnitNormal (normal) - get normals     110 //   GetNextUnitNormal (normal) - get normals of unit length of each face
111 //                            in order; return    111 //                            in order; returns false when finished all faces;
112 //   GetSurfaceArea()       - get surface area    112 //   GetSurfaceArea()       - get surface area of the polyhedron;
113 //   GetVolume()            - get volume of th    113 //   GetVolume()            - get volume of the polyhedron;
114 //   GetNumberOfRotationSteps() - get number o    114 //   GetNumberOfRotationSteps() - get number of steps for whole circle;
115 //   SetVertex(index, v)    - set vertex;         115 //   SetVertex(index, v)    - set vertex;
116 //   SetFacet(index,iv1,iv2,iv3,iv4) - set fac    116 //   SetFacet(index,iv1,iv2,iv3,iv4) - set facet;
117 //   SetReferences()        - set references t    117 //   SetReferences()        - set references to neighbouring facets;
118 //   JoinCoplanarFacets(tolerance) - join copl    118 //   JoinCoplanarFacets(tolerance) - join coplanar facets where it is possible
119 //   InvertFacets()         - invert the order    119 //   InvertFacets()         - invert the order on nodes in facets;
120 //   SetNumberOfRotationSteps (n) - set number    120 //   SetNumberOfRotationSteps (n) - set number of steps for whole circle;
121 //   ResetNumberOfRotationSteps() - reset numb    121 //   ResetNumberOfRotationSteps() - reset number of steps for whole circle
122 //                            to default value    122 //                            to default value;
123 // History:                                       123 // History:
124 //                                                124 //
125 // 20.06.96 Evgeni Chernyaev <Evgueni.Tchernia    125 // 20.06.96 Evgeni Chernyaev <Evgueni.Tcherniaev@cern.ch> - initial version
126 //                                                126 //
127 // 23.07.96 John Allison                          127 // 23.07.96 John Allison
128 // - added GetNoVertices, GetNoFacets, GetNext    128 // - added GetNoVertices, GetNoFacets, GetNextVertex, GetNextNormal
129 //                                                129 //
130 // 30.09.96 E.Chernyaev                           130 // 30.09.96 E.Chernyaev
131 // - added GetNextVertexIndex, GetVertex by Ya    131 // - added GetNextVertexIndex, GetVertex by Yasuhide Sawada
132 // - added GetNextUnitNormal, GetNextEdgeIndic    132 // - added GetNextUnitNormal, GetNextEdgeIndices, GetNextEdge
133 // - improvements: angles now expected in radi    133 // - improvements: angles now expected in radians
134 //                 int -> G4int, double -> G4d    134 //                 int -> G4int, double -> G4double
135 // - G4ThreeVector replaced by either G4Point3    135 // - G4ThreeVector replaced by either G4Point3D or G4Normal3D
136 //                                                136 //
137 // 15.12.96 E.Chernyaev                           137 // 15.12.96 E.Chernyaev
138 // - private functions G4PolyhedronAlloc, G4Po    138 // - private functions G4PolyhedronAlloc, G4PolyhedronPrism renamed
139 //   to AllocateMemory and CreatePrism            139 //   to AllocateMemory and CreatePrism
140 // - added private functions GetNumberOfRotati    140 // - added private functions GetNumberOfRotationSteps, RotateEdge,
141 //   RotateAroundZ, SetReferences                 141 //   RotateAroundZ, SetReferences
142 // - rewritten G4PolyhedronCons;                  142 // - rewritten G4PolyhedronCons;
143 // - added G4PolyhedronPara, ...Trap, ...Pgon,    143 // - added G4PolyhedronPara, ...Trap, ...Pgon, ...Pcon, ...Sphere, ...Torus,
144 //   so full List of implemented shapes now lo    144 //   so full List of implemented shapes now looks like:
145 //   BOX, TRD1, TRD2, TRAP, TUBE, TUBS, CONE,     145 //   BOX, TRD1, TRD2, TRAP, TUBE, TUBS, CONE, CONS, PARA, PGON, PCON,
146 //   SPHERE, TORUS                                146 //   SPHERE, TORUS
147 //                                                147 //
148 // 01.06.97 E.Chernyaev                           148 // 01.06.97 E.Chernyaev
149 // - RotateAroundZ modified and SetSideFacets     149 // - RotateAroundZ modified and SetSideFacets added to allow Rmin=Rmax
150 //   in bodies of revolution                      150 //   in bodies of revolution
151 //                                                151 //
152 // 24.06.97 J.Allison                             152 // 24.06.97 J.Allison
153 // - added static private member fNumberOfRota    153 // - added static private member fNumberOfRotationSteps and static public
154 //   functions void SetNumberOfRotationSteps (    154 //   functions void SetNumberOfRotationSteps (G4int n) and
155 //   void ResetNumberOfRotationSteps ().  Modi    155 //   void ResetNumberOfRotationSteps ().  Modified
156 //   GetNumberOfRotationSteps() appropriately.    156 //   GetNumberOfRotationSteps() appropriately.  Made all three functions
157 //   inline (at end of this .hh file).            157 //   inline (at end of this .hh file).
158 //   Usage:                                       158 //   Usage:
159 //    G4Polyhedron::SetNumberOfRotationSteps      159 //    G4Polyhedron::SetNumberOfRotationSteps
160 //     (fpView -> GetViewParameters ().GetNoOf    160 //     (fpView -> GetViewParameters ().GetNoOfSides ());
161 //    pPolyhedron = solid.CreatePolyhedron ();    161 //    pPolyhedron = solid.CreatePolyhedron ();
162 //    G4Polyhedron::ResetNumberOfRotationSteps    162 //    G4Polyhedron::ResetNumberOfRotationSteps ();
163 //                                                163 //
164 // 19.03.00 E.Chernyaev                           164 // 19.03.00 E.Chernyaev
165 // - added boolean operations (add, subtract,     165 // - added boolean operations (add, subtract, intersect) on polyhedra;
166 //                                                166 //
167 // 25.05.01 E.Chernyaev                           167 // 25.05.01 E.Chernyaev
168 // - added GetSurfaceArea() and GetVolume();      168 // - added GetSurfaceArea() and GetVolume();
169 //                                                169 //
170 // 05.11.02 E.Chernyaev                           170 // 05.11.02 E.Chernyaev
171 // - added createTwistedTrap() and createPolyh    171 // - added createTwistedTrap() and createPolyhedron();
172 //                                                172 //
173 // 06.03.05 J.Allison                             173 // 06.03.05 J.Allison
174 // - added IsErrorBooleanProcess                  174 // - added IsErrorBooleanProcess
175 //                                                175 //
176 // 20.06.05 G.Cosmo                               176 // 20.06.05 G.Cosmo
177 // - added HepPolyhedronEllipsoid                 177 // - added HepPolyhedronEllipsoid
178 //                                                178 //
179 // 18.07.07 T.Nikitina                            179 // 18.07.07 T.Nikitina
180 // - added HepPolyhedronParaboloid;               180 // - added HepPolyhedronParaboloid;
181 //                                                181 //
182 // 21.10.09 J.Allison                             182 // 21.10.09 J.Allison
183 // - removed IsErrorBooleanProcess (now error     183 // - removed IsErrorBooleanProcess (now error is returned through argument)
184 //                                                184 //
185 // 22.02.20 E.Chernyaev                           185 // 22.02.20 E.Chernyaev
186 // - added HepPolyhedronTet, HepPolyhedronHybe    186 // - added HepPolyhedronTet, HepPolyhedronHyberbolicMirror
187 //                                                187 //
188 // 12.05.21 E.Chernyaev                           188 // 12.05.21 E.Chernyaev
189 // - added TriangulatePolygon(), RotateContour    189 // - added TriangulatePolygon(), RotateContourAroundZ()
190 // - added HepPolyhedronPgon, HepPolyhedronPco    190 // - added HepPolyhedronPgon, HepPolyhedronPcon given by rz-countour
191 //                                                191 //
192 // 26.03.22 E.Chernyaev                           192 // 26.03.22 E.Chernyaev
193 // - added HepPolyhedronTetMesh                   193 // - added HepPolyhedronTetMesh
194 //                                                194 //
195 // 04.04.22 E.Chernyaev                           195 // 04.04.22 E.Chernyaev
196 // - added JoinCoplanarFacets()                   196 // - added JoinCoplanarFacets()
197 //                                                197 //
198 // 07.04.22 E.Chernyaev                           198 // 07.04.22 E.Chernyaev
199 // - added HepPolyhedronBoxMesh                   199 // - added HepPolyhedronBoxMesh
200                                                   200 
201 #ifndef HEP_POLYHEDRON_HH                         201 #ifndef HEP_POLYHEDRON_HH
202 #define HEP_POLYHEDRON_HH                         202 #define HEP_POLYHEDRON_HH
203                                                   203 
204 #include <vector>                                 204 #include <vector>
205 #include "G4Types.hh"                             205 #include "G4Types.hh"
206 #include "G4TwoVector.hh"                         206 #include "G4TwoVector.hh"
207 #include "G4ThreeVector.hh"                       207 #include "G4ThreeVector.hh"
208 #include "G4Point3D.hh"                           208 #include "G4Point3D.hh"
209 #include "G4Normal3D.hh"                          209 #include "G4Normal3D.hh"
210 #include "G4Transform3D.hh"                       210 #include "G4Transform3D.hh"
211                                                   211 
212 #ifndef DEFAULT_NUMBER_OF_STEPS                   212 #ifndef DEFAULT_NUMBER_OF_STEPS
213 #define DEFAULT_NUMBER_OF_STEPS 24                213 #define DEFAULT_NUMBER_OF_STEPS 24
214 #endif                                            214 #endif
215                                                   215 
216 class G4Facet {                                   216 class G4Facet {
217   friend class HepPolyhedron;                     217   friend class HepPolyhedron;
218   friend std::ostream& operator<<(std::ostream    218   friend std::ostream& operator<<(std::ostream&, const G4Facet &facet);
219                                                   219 
220  private:                                         220  private:
221   struct G4Edge { G4int v,f; };                   221   struct G4Edge { G4int v,f; };
222   G4Edge edge[4];                                 222   G4Edge edge[4];
223                                                   223 
224  public:                                          224  public:
225   G4Facet(G4int v1=0, G4int f1=0, G4int v2=0,     225   G4Facet(G4int v1=0, G4int f1=0, G4int v2=0, G4int f2=0,
226           G4int v3=0, G4int f3=0, G4int v4=0,     226           G4int v3=0, G4int f3=0, G4int v4=0, G4int f4=0)
227   { edge[0].v=v1; edge[0].f=f1; edge[1].v=v2;     227   { edge[0].v=v1; edge[0].f=f1; edge[1].v=v2; edge[1].f=f2;
228     edge[2].v=v3; edge[2].f=f3; edge[3].v=v4;     228     edge[2].v=v3; edge[2].f=f3; edge[3].v=v4; edge[3].f=f4; }
229 };                                                229 };
230                                                   230 
231 class HepPolyhedron {                             231 class HepPolyhedron {
232   friend std::ostream& operator<<(std::ostream    232   friend std::ostream& operator<<(std::ostream&, const HepPolyhedron &ph);
233                                                   233 
234  protected:                                       234  protected:
235   static G4ThreadLocal G4int fNumberOfRotation    235   static G4ThreadLocal G4int fNumberOfRotationSteps;
236   G4int nvert, nface;                             236   G4int nvert, nface;
237   G4Point3D  *pV;                                 237   G4Point3D  *pV;
238   G4Facet    *pF;                                 238   G4Facet    *pF;
239                                                   239 
240   // Re-allocate memory for HepPolyhedron         240   // Re-allocate memory for HepPolyhedron
241   void AllocateMemory(G4int Nvert, G4int Nface    241   void AllocateMemory(G4int Nvert, G4int Nface);
242                                                   242 
243   // Find neighbouring facet                      243   // Find neighbouring facet
244   G4int FindNeighbour(G4int iFace, G4int iNode    244   G4int FindNeighbour(G4int iFace, G4int iNode, G4int iOrder) const;
245                                                   245 
246   // Find normal at node                          246   // Find normal at node
247   G4Normal3D FindNodeNormal(G4int iFace, G4int    247   G4Normal3D FindNodeNormal(G4int iFace, G4int iNode) const;
248                                                   248 
249   // Create HepPolyhedron for prism with quadr    249   // Create HepPolyhedron for prism with quadrilateral base
250   void CreatePrism();                             250   void CreatePrism();
251                                                   251 
252   // Generate facets by revolving an edge arou    252   // Generate facets by revolving an edge around Z-axis
253   void RotateEdge(G4int k1, G4int k2, G4double    253   void RotateEdge(G4int k1, G4int k2, G4double r1, G4double r2,
254                   G4int v1, G4int v2, G4int vE    254                   G4int v1, G4int v2, G4int vEdge,
255                   G4bool ifWholeCircle, G4int     255                   G4bool ifWholeCircle, G4int ns, G4int &kface);
256                                                   256 
257   // Set side facets for the case of incomplet    257   // Set side facets for the case of incomplete rotation
258   void SetSideFacets(G4int ii[4], G4int vv[4],    258   void SetSideFacets(G4int ii[4], G4int vv[4],
259                      G4int *kk, G4double *r,      259                      G4int *kk, G4double *r,
260                      G4double dphi, G4int ns,     260                      G4double dphi, G4int ns, G4int &kface);
261                                                   261 
262   // Create HepPolyhedron for body of revoluti    262   // Create HepPolyhedron for body of revolution around Z-axis
263   void RotateAroundZ(G4int nstep, G4double phi    263   void RotateAroundZ(G4int nstep, G4double phi, G4double dphi,
264                      G4int np1, G4int np2,        264                      G4int np1, G4int np2,
265                      const G4double *z, G4doub    265                      const G4double *z, G4double *r,
266                      G4int nodeVis, G4int edge    266                      G4int nodeVis, G4int edgeVis);
267                                                   267 
268   // Create HepPolyhedron for body of revoluti    268   // Create HepPolyhedron for body of revolution around Z-axis
269   void RotateContourAroundZ(G4int nstep, G4dou    269   void RotateContourAroundZ(G4int nstep, G4double phi, G4double dphi,
270                             const std::vector<    270                             const std::vector<G4TwoVector> &rz,
271                             G4int nodeVis, G4i    271                             G4int nodeVis, G4int edgeVis);
272                                                   272 
273   // Triangulate closed polygon (contour)         273   // Triangulate closed polygon (contour)
274   G4bool TriangulatePolygon(const std::vector<    274   G4bool TriangulatePolygon(const std::vector<G4TwoVector> &polygon,
275                             std::vector<G4int>    275                             std::vector<G4int> &result);
276                                                   276 
277   // Helper function for TriangulatePolygon()     277   // Helper function for TriangulatePolygon()
278   G4bool CheckSnip(const std::vector<G4TwoVect    278   G4bool CheckSnip(const std::vector<G4TwoVector> &contour,
279                    G4int a, G4int b, G4int c,     279                    G4int a, G4int b, G4int c,
280                    G4int n, const G4int* V);      280                    G4int n, const G4int* V);
281                                                   281 
282  public:                                          282  public:
283   // Default constructor                          283   // Default constructor
284   HepPolyhedron() : nvert(0), nface(0), pV(nul    284   HepPolyhedron() : nvert(0), nface(0), pV(nullptr), pF(nullptr) {}
285                                                   285 
286   // Constructor with allocation of memory        286   // Constructor with allocation of memory
287   HepPolyhedron(G4int Nvert, G4int Nface);        287   HepPolyhedron(G4int Nvert, G4int Nface);
288                                                   288 
289   // Copy constructor                             289   // Copy constructor
290   HepPolyhedron(const HepPolyhedron & from);      290   HepPolyhedron(const HepPolyhedron & from);
291                                                   291 
292   // Move constructor                             292   // Move constructor
293   HepPolyhedron(HepPolyhedron && from);           293   HepPolyhedron(HepPolyhedron && from);
294                                                   294 
295   // Destructor                                   295   // Destructor
296   virtual ~HepPolyhedron() { delete [] pV; del    296   virtual ~HepPolyhedron() { delete [] pV; delete [] pF; }
297                                                   297 
298   // Assignment                                   298   // Assignment
299   HepPolyhedron & operator=(const HepPolyhedro    299   HepPolyhedron & operator=(const HepPolyhedron & from);
300                                                   300 
301   // Move assignment                              301   // Move assignment
302   HepPolyhedron & operator=(HepPolyhedron && f    302   HepPolyhedron & operator=(HepPolyhedron && from);
303                                                   303 
304   // Get number of vertices                       304   // Get number of vertices
305   G4int GetNoVertices() const { return nvert;     305   G4int GetNoVertices() const { return nvert; }
306   G4int GetNoVerteces() const { return nvert;     306   G4int GetNoVerteces() const { return nvert; }  // Old spelling.
307                                                   307 
308   // Get number of facets                         308   // Get number of facets
309   G4int GetNoFacets() const { return nface; }     309   G4int GetNoFacets() const { return nface; }
310                                                   310 
311   // Transform the polyhedron                     311   // Transform the polyhedron
312   HepPolyhedron & Transform(const G4Transform3    312   HepPolyhedron & Transform(const G4Transform3D & t);
313                                                   313 
314   // Get next vertex index of the quadrilatera    314   // Get next vertex index of the quadrilateral
315   G4bool GetNextVertexIndex(G4int & index, G4i    315   G4bool GetNextVertexIndex(G4int & index, G4int & edgeFlag) const;
316                                                   316 
317   // Get vertex by index                          317   // Get vertex by index
318   G4Point3D GetVertex(G4int index) const;         318   G4Point3D GetVertex(G4int index) const;
319                                                   319 
320   // Get next vertex + edge visibility of the     320   // Get next vertex + edge visibility of the quadrilateral
321   G4bool GetNextVertex(G4Point3D & vertex, G4i    321   G4bool GetNextVertex(G4Point3D & vertex, G4int & edgeFlag) const;
322                                                   322 
323   // Get next vertex + edge visibility + norma    323   // Get next vertex + edge visibility + normal of the quadrilateral
324   G4bool GetNextVertex(G4Point3D & vertex, G4i    324   G4bool GetNextVertex(G4Point3D & vertex, G4int & edgeFlag,
325                        G4Normal3D & normal) co    325                        G4Normal3D & normal) const;
326                                                   326 
327   // Get indices of the next edge with indices    327   // Get indices of the next edge with indices of the faces
328   G4bool GetNextEdgeIndices(G4int & i1, G4int     328   G4bool GetNextEdgeIndices(G4int & i1, G4int & i2, G4int & edgeFlag,
329                             G4int & iface1, G4    329                             G4int & iface1, G4int & iface2) const;
330   G4bool GetNextEdgeIndeces(G4int & i1, G4int     330   G4bool GetNextEdgeIndeces(G4int & i1, G4int & i2, G4int & edgeFlag,
331                             G4int & iface1, G4    331                             G4int & iface1, G4int & iface2) const
332   {return GetNextEdgeIndices(i1,i2,edgeFlag,if    332   {return GetNextEdgeIndices(i1,i2,edgeFlag,iface1,iface2);}  // Old spelling
333                                                   333 
334   // Get indices of the next edge                 334   // Get indices of the next edge
335   G4bool GetNextEdgeIndices(G4int & i1, G4int     335   G4bool GetNextEdgeIndices(G4int & i1, G4int & i2, G4int & edgeFlag) const;
336   G4bool GetNextEdgeIndeces(G4int & i1, G4int     336   G4bool GetNextEdgeIndeces(G4int & i1, G4int & i2, G4int & edgeFlag) const
337   {return GetNextEdgeIndices(i1,i2,edgeFlag);}    337   {return GetNextEdgeIndices(i1,i2,edgeFlag);}  // Old spelling.
338                                                   338 
339   // Get next edge                                339   // Get next edge
340   G4bool GetNextEdge(G4Point3D &p1, G4Point3D     340   G4bool GetNextEdge(G4Point3D &p1, G4Point3D &p2, G4int &edgeFlag) const;
341                                                   341 
342   // Get next edge                                342   // Get next edge
343   G4bool GetNextEdge(G4Point3D &p1, G4Point3D     343   G4bool GetNextEdge(G4Point3D &p1, G4Point3D &p2, G4int &edgeFlag,
344                      G4int &iface1, G4int &ifa    344                      G4int &iface1, G4int &iface2) const;
345                                                   345 
346   // Get face by index                            346   // Get face by index
347   void GetFacet(G4int iFace, G4int &n, G4int *    347   void GetFacet(G4int iFace, G4int &n, G4int *iNodes,
348                 G4int *edgeFlags = nullptr, G4    348                 G4int *edgeFlags = nullptr, G4int *iFaces = nullptr) const;
349                                                   349 
350   // Get face by index                            350   // Get face by index
351   void GetFacet(G4int iFace, G4int &n, G4Point    351   void GetFacet(G4int iFace, G4int &n, G4Point3D *nodes,
352                 G4int *edgeFlags=nullptr, G4No    352                 G4int *edgeFlags=nullptr, G4Normal3D *normals=nullptr) const;
353                                                   353 
354   // Get next face with normals at the nodes      354   // Get next face with normals at the nodes
355   G4bool GetNextFacet(G4int &n, G4Point3D *nod    355   G4bool GetNextFacet(G4int &n, G4Point3D *nodes, G4int *edgeFlags=nullptr,
356                       G4Normal3D *normals=null    356                       G4Normal3D *normals=nullptr) const;
357                                                   357 
358   // Get normal of the face given by index        358   // Get normal of the face given by index
359   G4Normal3D GetNormal(G4int iFace) const;        359   G4Normal3D GetNormal(G4int iFace) const;
360                                                   360 
361   // Get unit normal of the face given by inde    361   // Get unit normal of the face given by index
362   G4Normal3D GetUnitNormal(G4int iFace) const;    362   G4Normal3D GetUnitNormal(G4int iFace) const;
363                                                   363 
364   // Get normal of the next face                  364   // Get normal of the next face
365   G4bool GetNextNormal(G4Normal3D &normal) con    365   G4bool GetNextNormal(G4Normal3D &normal) const;
366                                                   366 
367   // Get normal of unit length of the next fac    367   // Get normal of unit length of the next face
368   G4bool GetNextUnitNormal(G4Normal3D &normal)    368   G4bool GetNextUnitNormal(G4Normal3D &normal) const;
369                                                   369 
370   // Boolean operations                           370   // Boolean operations
371   HepPolyhedron add(const HepPolyhedron &p) co    371   HepPolyhedron add(const HepPolyhedron &p) const;
372   HepPolyhedron subtract(const HepPolyhedron &    372   HepPolyhedron subtract(const HepPolyhedron &p) const;
373   HepPolyhedron intersect(const HepPolyhedron     373   HepPolyhedron intersect(const HepPolyhedron &p) const;
374                                                   374 
375   // Get area of the surface of the polyhedron    375   // Get area of the surface of the polyhedron
376   G4double GetSurfaceArea() const;                376   G4double GetSurfaceArea() const;
377                                                   377 
378   // Get volume of the polyhedron                 378   // Get volume of the polyhedron
379   G4double GetVolume() const;                     379   G4double GetVolume() const;
380                                                   380 
381   // Get number of steps for whole circle         381   // Get number of steps for whole circle
382   static G4int GetNumberOfRotationSteps();        382   static G4int GetNumberOfRotationSteps();
383                                                   383 
384   // Set vertex (1 <= index <= Nvert)             384   // Set vertex (1 <= index <= Nvert)
385   void SetVertex(G4int index, const G4Point3D&    385   void SetVertex(G4int index, const G4Point3D& v);
386                                                   386 
387   // Set facet (1 <= index <= Nface)              387   // Set facet (1 <= index <= Nface)
388   void SetFacet(G4int index, G4int iv1, G4int     388   void SetFacet(G4int index, G4int iv1, G4int iv2, G4int iv3, G4int iv4 = 0);
389                                                   389 
390   // For each edge set reference to neighbouri    390   // For each edge set reference to neighbouring facet,
391   // call this after all vertices and facets h    391   // call this after all vertices and facets have been set
392   void SetReferences();                           392   void SetReferences();
393                                                   393 
394   // Join couples of triangular facets to quad    394   // Join couples of triangular facets to quadrangular facets
395   // where it is possible                         395   // where it is possible
396   void JoinCoplanarFacets(G4double tolerance);    396   void JoinCoplanarFacets(G4double tolerance);
397                                                   397 
398   // Invert the order on nodes in facets          398   // Invert the order on nodes in facets
399   void InvertFacets();                            399   void InvertFacets();
400                                                   400 
401   // Set number of steps for whole circle         401   // Set number of steps for whole circle
402   static void SetNumberOfRotationSteps(G4int n    402   static void SetNumberOfRotationSteps(G4int n);
403                                                   403 
404   // Reset number of steps for whole circle to    404   // Reset number of steps for whole circle to default value
405   static void ResetNumberOfRotationSteps();       405   static void ResetNumberOfRotationSteps();
406                                                   406 
407   /**                                             407   /**
408    * Creates polyhedron for twisted trapezoid.    408    * Creates polyhedron for twisted trapezoid.
409    * The trapezoid is given by two bases perpe    409    * The trapezoid is given by two bases perpendicular to the z-axis.
410    *                                              410    *
411    * @param  Dz  half length in z                 411    * @param  Dz  half length in z
412    * @param  xy1 1st base (at z = -Dz)            412    * @param  xy1 1st base (at z = -Dz)
413    * @param  xy2 2nd base (at z = +Dz)            413    * @param  xy2 2nd base (at z = +Dz)
414    * @return status of the operation - is non-    414    * @return status of the operation - is non-zero in case of problem
415    */                                             415    */
416   G4int createTwistedTrap(G4double Dz,            416   G4int createTwistedTrap(G4double Dz,
417                         const G4double xy1[][2    417                         const G4double xy1[][2], const G4double xy2[][2]);
418                                                   418 
419   /**                                             419   /**
420    * Creates user defined polyhedron.             420    * Creates user defined polyhedron.
421    * This function allows to the user to defin    421    * This function allows to the user to define arbitrary polyhedron.
422    * The faces of the polyhedron should be eit    422    * The faces of the polyhedron should be either triangles or planar
423    * quadrilateral. Nodes of a face are define    423    * quadrilateral. Nodes of a face are defined by indexes pointing to
424    * the elements in the xyz array. Numeration    424    * the elements in the xyz array. Numeration of the elements in the
425    * array starts from 1 (like in fortran). Th    425    * array starts from 1 (like in fortran). The indexes can be positive
426    * or negative. Negative sign means that the    426    * or negative. Negative sign means that the corresponding edge is
427    * invisible. The normal of the face should     427    * invisible. The normal of the face should be directed to exterior
428    * of the polyhedron.                           428    * of the polyhedron.
429    *                                              429    *
430    * @param  Nnodes number of nodes               430    * @param  Nnodes number of nodes
431    * @param  Nfaces number of faces               431    * @param  Nfaces number of faces
432    * @param  xyz    nodes                         432    * @param  xyz    nodes
433    * @param  faces  faces (quadrilaterals or t    433    * @param  faces  faces (quadrilaterals or triangles)
434    * @return status of the operation - is non-    434    * @return status of the operation - is non-zero in case of problem
435    */                                             435    */
436   G4int createPolyhedron(G4int Nnodes, G4int N    436   G4int createPolyhedron(G4int Nnodes, G4int Nfaces,
437                          const G4double xyz[][    437                          const G4double xyz[][3], const G4int faces[][4]);
438                                                   438 
439   /**                                             439   /**
440    * Calculate the unweighted mean of all the     440    * Calculate the unweighted mean of all the vertices in the polyhedron. Not to be
441    * confused with the polyhedron centre or ce    441    * confused with the polyhedron centre or centre of mass
442    * @return G4Point3D of the unweighted mean     442    * @return G4Point3D of the unweighted mean vertex position
443    */                                             443    */
444   G4Point3D vertexUnweightedMean() const;         444   G4Point3D vertexUnweightedMean() const;
445 };                                                445 };
446                                                   446 
447 class HepPolyhedronTrd2 : public HepPolyhedron    447 class HepPolyhedronTrd2 : public HepPolyhedron
448 {                                                 448 {
449  public:                                          449  public:
450   HepPolyhedronTrd2(G4double Dx1, G4double Dx2    450   HepPolyhedronTrd2(G4double Dx1, G4double Dx2,
451                     G4double Dy1, G4double Dy2    451                     G4double Dy1, G4double Dy2, G4double Dz);
452   ~HepPolyhedronTrd2() override;                  452   ~HepPolyhedronTrd2() override;
453 };                                                453 };
454                                                   454 
455 class HepPolyhedronTrd1 : public HepPolyhedron    455 class HepPolyhedronTrd1 : public HepPolyhedronTrd2
456 {                                                 456 {
457  public:                                          457  public:
458   HepPolyhedronTrd1(G4double Dx1, G4double Dx2    458   HepPolyhedronTrd1(G4double Dx1, G4double Dx2,
459                     G4double Dy, G4double Dz);    459                     G4double Dy, G4double Dz);
460   ~HepPolyhedronTrd1() override;                  460   ~HepPolyhedronTrd1() override;
461 };                                                461 };
462                                                   462 
463 class HepPolyhedronBox : public HepPolyhedronT    463 class HepPolyhedronBox : public HepPolyhedronTrd2
464 {                                                 464 {
465  public:                                          465  public:
466   HepPolyhedronBox(G4double Dx, G4double Dy, G    466   HepPolyhedronBox(G4double Dx, G4double Dy, G4double Dz);
467   ~HepPolyhedronBox() override;                   467   ~HepPolyhedronBox() override;
468 };                                                468 };
469                                                   469 
470 class HepPolyhedronTrap : public HepPolyhedron    470 class HepPolyhedronTrap : public HepPolyhedron
471 {                                                 471 {
472  public:                                          472  public:
473   HepPolyhedronTrap(G4double Dz, G4double Thet    473   HepPolyhedronTrap(G4double Dz, G4double Theta, G4double Phi,
474                     G4double Dy1,                 474                     G4double Dy1,
475                     G4double Dx1, G4double Dx2    475                     G4double Dx1, G4double Dx2, G4double Alp1,
476                     G4double Dy2,                 476                     G4double Dy2,
477                     G4double Dx3, G4double Dx4    477                     G4double Dx3, G4double Dx4, G4double Alp2);
478   ~HepPolyhedronTrap() override;                  478   ~HepPolyhedronTrap() override;
479 };                                                479 };
480                                                   480 
481 class HepPolyhedronPara : public HepPolyhedron    481 class HepPolyhedronPara : public HepPolyhedronTrap
482 {                                                 482 {
483  public:                                          483  public:
484   HepPolyhedronPara(G4double Dx, G4double Dy,     484   HepPolyhedronPara(G4double Dx, G4double Dy, G4double Dz,
485                     G4double Alpha, G4double T    485                     G4double Alpha, G4double Theta, G4double Phi);
486   ~HepPolyhedronPara() override;                  486   ~HepPolyhedronPara() override;
487 };                                                487 };
488                                                   488 
489 class HepPolyhedronParaboloid : public HepPoly    489 class HepPolyhedronParaboloid : public HepPolyhedron
490 {                                                 490 {
491  public:                                          491  public:
492   HepPolyhedronParaboloid(G4double r1,            492   HepPolyhedronParaboloid(G4double r1,
493                           G4double r2,            493                           G4double r2,
494                           G4double dz,            494                           G4double dz,
495                           G4double Phi1,          495                           G4double Phi1,
496                           G4double Dphi);         496                           G4double Dphi);
497   ~HepPolyhedronParaboloid() override;            497   ~HepPolyhedronParaboloid() override;
498 };                                                498 };
499                                                   499 
500 class HepPolyhedronHype : public HepPolyhedron    500 class HepPolyhedronHype : public HepPolyhedron
501 {                                                 501 {
502  public:                                          502  public:
503   HepPolyhedronHype(G4double r1,                  503   HepPolyhedronHype(G4double r1,
504                     G4double r2,                  504                     G4double r2,
505                     G4double tan1,                505                     G4double tan1,
506                     G4double tan2,                506                     G4double tan2,
507                     G4double halfZ);              507                     G4double halfZ);
508   ~HepPolyhedronHype() override;                  508   ~HepPolyhedronHype() override;
509 };                                                509 };
510                                                   510 
511 class HepPolyhedronCons : public HepPolyhedron    511 class HepPolyhedronCons : public HepPolyhedron
512 {                                                 512 {
513  public:                                          513  public:
514   HepPolyhedronCons(G4double Rmn1, G4double Rm    514   HepPolyhedronCons(G4double Rmn1, G4double Rmx1,
515                     G4double Rmn2, G4double Rm    515                     G4double Rmn2, G4double Rmx2, G4double Dz,
516                     G4double Phi1, G4double Dp    516                     G4double Phi1, G4double Dphi);
517   ~HepPolyhedronCons() override;                  517   ~HepPolyhedronCons() override;
518 };                                                518 };
519                                                   519 
520 class HepPolyhedronCone : public HepPolyhedron    520 class HepPolyhedronCone : public HepPolyhedronCons
521 {                                                 521 {
522  public:                                          522  public:
523   HepPolyhedronCone(G4double Rmn1, G4double Rm    523   HepPolyhedronCone(G4double Rmn1, G4double Rmx1,
524                     G4double Rmn2, G4double Rm    524                     G4double Rmn2, G4double Rmx2, G4double Dz);
525   ~HepPolyhedronCone() override;                  525   ~HepPolyhedronCone() override;
526 };                                                526 };
527                                                   527 
528 class HepPolyhedronTubs : public HepPolyhedron    528 class HepPolyhedronTubs : public HepPolyhedronCons
529 {                                                 529 {
530  public:                                          530  public:
531   HepPolyhedronTubs(G4double Rmin, G4double Rm    531   HepPolyhedronTubs(G4double Rmin, G4double Rmax, G4double Dz,
532                     G4double Phi1, G4double Dp    532                     G4double Phi1, G4double Dphi);
533   ~HepPolyhedronTubs() override;                  533   ~HepPolyhedronTubs() override;
534 };                                                534 };
535                                                   535 
536 class HepPolyhedronTube : public HepPolyhedron    536 class HepPolyhedronTube : public HepPolyhedronCons
537 {                                                 537 {
538  public:                                          538  public:
539   HepPolyhedronTube (G4double Rmin, G4double R    539   HepPolyhedronTube (G4double Rmin, G4double Rmax, G4double Dz);
540   ~HepPolyhedronTube() override;                  540   ~HepPolyhedronTube() override;
541 };                                                541 };
542                                                   542 
543 class HepPolyhedronPgon : public HepPolyhedron    543 class HepPolyhedronPgon : public HepPolyhedron
544 {                                                 544 {
545  public:                                          545  public:
546   HepPolyhedronPgon(G4double phi, G4double dph    546   HepPolyhedronPgon(G4double phi, G4double dphi, G4int npdv, G4int nz,
547                     const G4double *z,            547                     const G4double *z,
548                     const G4double *rmin,         548                     const G4double *rmin,
549                     const G4double *rmax);        549                     const G4double *rmax);
550   HepPolyhedronPgon(G4double phi, G4double dph    550   HepPolyhedronPgon(G4double phi, G4double dphi, G4int npdv,
551                     const std::vector<G4TwoVec    551                     const std::vector<G4TwoVector> &rz);
552   ~HepPolyhedronPgon() override;                  552   ~HepPolyhedronPgon() override;
553 };                                                553 };
554                                                   554 
555 class HepPolyhedronPcon : public HepPolyhedron    555 class HepPolyhedronPcon : public HepPolyhedronPgon
556 {                                                 556 {
557  public:                                          557  public:
558   HepPolyhedronPcon(G4double phi, G4double dph    558   HepPolyhedronPcon(G4double phi, G4double dphi, G4int nz,
559                     const G4double *z,            559                     const G4double *z,
560                     const G4double *rmin,         560                     const G4double *rmin,
561                     const G4double *rmax);        561                     const G4double *rmax);
562   HepPolyhedronPcon(G4double phi, G4double dph    562   HepPolyhedronPcon(G4double phi, G4double dphi,
563                     const std::vector<G4TwoVec    563                     const std::vector<G4TwoVector> &rz);
564   ~HepPolyhedronPcon() override;                  564   ~HepPolyhedronPcon() override;
565 };                                                565 };
566                                                   566 
567 class HepPolyhedronSphere : public HepPolyhedr    567 class HepPolyhedronSphere : public HepPolyhedron
568 {                                                 568 {
569  public:                                          569  public:
570   HepPolyhedronSphere(G4double rmin, G4double     570   HepPolyhedronSphere(G4double rmin, G4double rmax,
571                       G4double phi, G4double d    571                       G4double phi, G4double dphi,
572                       G4double the, G4double d    572                       G4double the, G4double dthe);
573   ~HepPolyhedronSphere() override;                573   ~HepPolyhedronSphere() override;
574 };                                                574 };
575                                                   575 
576 class HepPolyhedronTorus : public HepPolyhedro    576 class HepPolyhedronTorus : public HepPolyhedron
577 {                                                 577 {
578  public:                                          578  public:
579   HepPolyhedronTorus(G4double rmin, G4double r    579   HepPolyhedronTorus(G4double rmin, G4double rmax, G4double rtor,
580                      G4double phi, G4double dp    580                      G4double phi, G4double dphi);
581   ~HepPolyhedronTorus() override;                 581   ~HepPolyhedronTorus() override;
582 };                                                582 };
583                                                   583 
584 class HepPolyhedronTet : public HepPolyhedron     584 class HepPolyhedronTet : public HepPolyhedron
585 {                                                 585 {
586  public:                                          586  public:
587   HepPolyhedronTet(const G4double p0[3],          587   HepPolyhedronTet(const G4double p0[3],
588                    const G4double p1[3],          588                    const G4double p1[3],
589                    const G4double p2[3],          589                    const G4double p2[3],
590                    const G4double p3[3]);         590                    const G4double p3[3]);
591   ~HepPolyhedronTet() override;                   591   ~HepPolyhedronTet() override;
592 };                                                592 };
593                                                   593 
594 class HepPolyhedronEllipsoid : public HepPolyh    594 class HepPolyhedronEllipsoid : public HepPolyhedron
595 {                                                 595 {
596  public:                                          596  public:
597   HepPolyhedronEllipsoid(G4double dx, G4double    597   HepPolyhedronEllipsoid(G4double dx, G4double dy, G4double dz,
598                          G4double zcut1, G4dou    598                          G4double zcut1, G4double zcut2);
599   ~HepPolyhedronEllipsoid() override;             599   ~HepPolyhedronEllipsoid() override;
600 };                                                600 };
601                                                   601 
602 class HepPolyhedronEllipticalCone : public Hep    602 class HepPolyhedronEllipticalCone : public HepPolyhedron
603 {                                                 603 {
604  public:                                          604  public:
605   HepPolyhedronEllipticalCone(G4double dx, G4d    605   HepPolyhedronEllipticalCone(G4double dx, G4double dy, G4double z,
606                               G4double zcut1);    606                               G4double zcut1);
607   ~HepPolyhedronEllipticalCone() override;        607   ~HepPolyhedronEllipticalCone() override;
608 };                                                608 };
609                                                   609 
610 class HepPolyhedronHyperbolicMirror : public H    610 class HepPolyhedronHyperbolicMirror : public HepPolyhedron
611 {                                                 611 {
612  public:                                          612  public:
613   HepPolyhedronHyperbolicMirror(G4double a, G4    613   HepPolyhedronHyperbolicMirror(G4double a, G4double h, G4double r);
614   ~HepPolyhedronHyperbolicMirror() override;      614   ~HepPolyhedronHyperbolicMirror() override;
615 };                                                615 };
616                                                   616 
617 class HepPolyhedronTetMesh : public HepPolyhed    617 class HepPolyhedronTetMesh : public HepPolyhedron
618 {                                                 618 {
619  public:                                          619  public:
620   HepPolyhedronTetMesh(const std::vector<G4Thr    620   HepPolyhedronTetMesh(const std::vector<G4ThreeVector>& tetrahedra);
621   ~HepPolyhedronTetMesh() override;               621   ~HepPolyhedronTetMesh() override;
622 };                                                622 };
623                                                   623 
624 class HepPolyhedronBoxMesh : public HepPolyhed    624 class HepPolyhedronBoxMesh : public HepPolyhedron
625 {                                                 625 {
626  public:                                          626  public:
627   HepPolyhedronBoxMesh(G4double sizeX, G4doubl    627   HepPolyhedronBoxMesh(G4double sizeX, G4double sizeY, G4double sizeZ,
628                        const std::vector<G4Thr    628                        const std::vector<G4ThreeVector>& positions);
629   ~HepPolyhedronBoxMesh() override;               629   ~HepPolyhedronBoxMesh() override;
630 };                                                630 };
631                                                   631 
632 #endif /* HEP_POLYHEDRON_HH */                    632 #endif /* HEP_POLYHEDRON_HH */
633                                                   633