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 9.4.p1)


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