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


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