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