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