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.5)


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