| Geant4 Cross Reference |
1 // 1
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 //
26 // Class Description:
27 // HepPolyhedron is an intermediate class betw
28 // and visualization systems. It is intended t
29 // - polygonization of shapes with trianguli
30 // of complex polygons;
31 // - calculation of normals for faces and ve
32 // - finding result of boolean operation on
33 //
34 // Public constructors:
35 //
36 // HepPolyhedronBox (dx,dy,dz)
37 // - cr
38 // HepPolyhedronTrd1 (dx1,dx2,dy,dz)
39 // - cr
40 // HepPolyhedronTrd2 (dx1,dx2,dy1,dy2,dz)
41 // - cr
42 // HepPolyhedronTrap (dz,theta,phi, h1,bl1,t
43 // - cr
44 // HepPolyhedronPara (dx,dy,dz,alpha,theta,p
45 // - cr
46 // HepPolyhedronTube (rmin,rmax,dz)
47 // - cr
48 // HepPolyhedronTubs (rmin,rmax,dz,phi1,dphi
49 // - cr
50 // HepPolyhedronCone (rmin1,rmax1,rmin2,rmax
51 // - cr
52 // HepPolyhedronCons (rmin1,rmax1,rmin2,rmax
53 // - cr
54 // HepPolyhedronPgon (phi,dphi,npdv,nz, z(*)
55 // - cr
56 // HepPolyhedronPcon (phi,dphi,nz, z(*),rmin
57 // - cr
58 // HepPolyhedronSphere (rmin,rmax,phi,dphi,t
59 // - cr
60 // HepPolyhedronTorus (rmin,rmax,rtor,phi,dp
61 // - cr
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:
79 //
80 // GetNoVertices () - returns number o
81 // GetNoFacets () - returns number o
82 // GetNextVertexIndex (index,edgeFlag) - get
83 // quadrilaterals i
84 // returns false wh
85 // GetVertex (index) - returns vertex b
86 // GetNextVertex (vertex,edgeFlag) - get ver
87 // of the quadrilat
88 // returns false wh
89 // GetNextVertex (vertex,edgeFlag,normal) -
90 // visibility and n
91 // in order; return
92 // GetNextEdgeIndices (i1,i2,edgeFlag) - get
93 // returns false fo
94 // GetNextEdgeIndices (i1,i2,edgeFlag,iface1
95 // the next edge wi
96 // to which the edg
97 // returns false fo
98 // GetNextEdge (p1,p2,edgeFlag) - get next e
99 // returns false fo
100 // GetNextEdge (p1,p2,edgeFlag,iface1,iface2
101 // of the faces to
102 // returns false fo
103 // GetFacet (index,n,nodes,edgeFlags=0,norma
104 // GetNextFacet (n,nodes,edgeFlags=0,normals
105 // at the nodes; re
106 // GetNormal (index) - get normal of fa
107 // GetUnitNormal (index) - get unit normal
108 // GetNextNormal (normal) - get normals of e
109 // returns false wh
110 // GetNextUnitNormal (normal) - get normals
111 // in order; return
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
121 // ResetNumberOfRotationSteps() - reset numb
122 // to default value
123 // History:
124 //
125 // 20.06.96 Evgeni Chernyaev <Evgueni.Tchernia
126 //
127 // 23.07.96 John Allison
128 // - added GetNoVertices, GetNoFacets, GetNext
129 //
130 // 30.09.96 E.Chernyaev
131 // - added GetNextVertexIndex, GetVertex by Ya
132 // - added GetNextUnitNormal, GetNextEdgeIndic
133 // - improvements: angles now expected in radi
134 // int -> G4int, double -> G4d
135 // - G4ThreeVector replaced by either G4Point3
136 //
137 // 15.12.96 E.Chernyaev
138 // - private functions G4PolyhedronAlloc, G4Po
139 // to AllocateMemory and CreatePrism
140 // - added private functions GetNumberOfRotati
141 // RotateAroundZ, SetReferences
142 // - rewritten G4PolyhedronCons;
143 // - added G4PolyhedronPara, ...Trap, ...Pgon,
144 // so full List of implemented shapes now lo
145 // BOX, TRD1, TRD2, TRAP, TUBE, TUBS, CONE,
146 // SPHERE, TORUS
147 //
148 // 01.06.97 E.Chernyaev
149 // - RotateAroundZ modified and SetSideFacets
150 // in bodies of revolution
151 //
152 // 24.06.97 J.Allison
153 // - added static private member fNumberOfRota
154 // functions void SetNumberOfRotationSteps (
155 // void ResetNumberOfRotationSteps (). Modi
156 // GetNumberOfRotationSteps() appropriately.
157 // inline (at end of this .hh file).
158 // Usage:
159 // G4Polyhedron::SetNumberOfRotationSteps
160 // (fpView -> GetViewParameters ().GetNoOf
161 // pPolyhedron = solid.CreatePolyhedron ();
162 // G4Polyhedron::ResetNumberOfRotationSteps
163 //
164 // 19.03.00 E.Chernyaev
165 // - added boolean operations (add, subtract,
166 //
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
201 #ifndef HEP_POLYHEDRON_HH
202 #define HEP_POLYHEDRON_HH
203
204 #include <vector>
205 #include "G4Types.hh"
206 #include "G4TwoVector.hh"
207 #include "G4ThreeVector.hh"
208 #include "G4Point3D.hh"
209 #include "G4Normal3D.hh"
210 #include "G4Transform3D.hh"
211
212 #ifndef DEFAULT_NUMBER_OF_STEPS
213 #define DEFAULT_NUMBER_OF_STEPS 24
214 #endif
215
216 class G4Facet {
217 friend class HepPolyhedron;
218 friend std::ostream& operator<<(std::ostream
219
220 private:
221 struct G4Edge { G4int v,f; };
222 G4Edge edge[4];
223
224 public:
225 G4Facet(G4int v1=0, G4int f1=0, G4int v2=0,
226 G4int v3=0, G4int f3=0, G4int v4=0,
227 { edge[0].v=v1; edge[0].f=f1; edge[1].v=v2;
228 edge[2].v=v3; edge[2].f=f3; edge[3].v=v4;
229 };
230
231 class HepPolyhedron {
232 friend std::ostream& operator<<(std::ostream
233
234 protected:
235 static G4ThreadLocal G4int fNumberOfRotation
236 G4int nvert, nface;
237 G4Point3D *pV;
238 G4Facet *pF;
239
240 // Re-allocate memory for HepPolyhedron
241 void AllocateMemory(G4int Nvert, G4int Nface
242
243 // Find neighbouring facet
244 G4int FindNeighbour(G4int iFace, G4int iNode
245
246 // Find normal at node
247 G4Normal3D FindNodeNormal(G4int iFace, G4int
248
249 // Create HepPolyhedron for prism with quadr
250 void CreatePrism();
251
252 // Generate facets by revolving an edge arou
253 void RotateEdge(G4int k1, G4int k2, G4double
254 G4int v1, G4int v2, G4int vE
255 G4bool ifWholeCircle, G4int
256
257 // Set side facets for the case of incomplet
258 void SetSideFacets(G4int ii[4], G4int vv[4],
259 G4int *kk, G4double *r,
260 G4double dphi, G4int ns,
261
262 // Create HepPolyhedron for body of revoluti
263 void RotateAroundZ(G4int nstep, G4double phi
264 G4int np1, G4int np2,
265 const G4double *z, G4doub
266 G4int nodeVis, G4int edge
267
268 // Create HepPolyhedron for body of revoluti
269 void RotateContourAroundZ(G4int nstep, G4dou
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
282 public:
283 // Default constructor
284 HepPolyhedron() : nvert(0), nface(0), pV(nul
285
286 // Constructor with allocation of memory
287 HepPolyhedron(G4int Nvert, G4int Nface);
288
289 // Copy constructor
290 HepPolyhedron(const HepPolyhedron & from);
291
292 // Move constructor
293 HepPolyhedron(HepPolyhedron && from);
294
295 // Destructor
296 virtual ~HepPolyhedron() { delete [] pV; del
297
298 // Assignment
299 HepPolyhedron & operator=(const HepPolyhedro
300
301 // Move assignment
302 HepPolyhedron & operator=(HepPolyhedron && f
303
304 // Get number of vertices
305 G4int GetNoVertices() const { return nvert;
306 G4int GetNoVerteces() const { return nvert;
307
308 // Get number of facets
309 G4int GetNoFacets() const { return nface; }
310
311 // Transform the polyhedron
312 HepPolyhedron & Transform(const G4Transform3
313
314 // Get next vertex index of the quadrilatera
315 G4bool GetNextVertexIndex(G4int & index, G4i
316
317 // Get vertex by index
318 G4Point3D GetVertex(G4int index) const;
319
320 // Get next vertex + edge visibility of the
321 G4bool GetNextVertex(G4Point3D & vertex, G4i
322
323 // Get next vertex + edge visibility + norma
324 G4bool GetNextVertex(G4Point3D & vertex, G4i
325 G4Normal3D & normal) co
326
327 // Get indices of the next edge with indices
328 G4bool GetNextEdgeIndices(G4int & i1, G4int
329 G4int & iface1, G4
330 G4bool GetNextEdgeIndeces(G4int & i1, G4int
331 G4int & iface1, G4
332 {return GetNextEdgeIndices(i1,i2,edgeFlag,if
333
334 // Get indices of the next edge
335 G4bool GetNextEdgeIndices(G4int & i1, G4int
336 G4bool GetNextEdgeIndeces(G4int & i1, G4int
337 {return GetNextEdgeIndices(i1,i2,edgeFlag);}
338
339 // Get next edge
340 G4bool GetNextEdge(G4Point3D &p1, G4Point3D
341
342 // Get next edge
343 G4bool GetNextEdge(G4Point3D &p1, G4Point3D
344 G4int &iface1, G4int &ifa
345
346 // Get face by index
347 void GetFacet(G4int iFace, G4int &n, G4int *
348 G4int *edgeFlags = nullptr, G4
349
350 // Get face by index
351 void GetFacet(G4int iFace, G4int &n, G4Point
352 G4int *edgeFlags=nullptr, G4No
353
354 // Get next face with normals at the nodes
355 G4bool GetNextFacet(G4int &n, G4Point3D *nod
356 G4Normal3D *normals=null
357
358 // Get normal of the face given by index
359 G4Normal3D GetNormal(G4int iFace) const;
360
361 // Get unit normal of the face given by inde
362 G4Normal3D GetUnitNormal(G4int iFace) const;
363
364 // Get normal of the next face
365 G4bool GetNextNormal(G4Normal3D &normal) con
366
367 // Get normal of unit length of the next fac
368 G4bool GetNextUnitNormal(G4Normal3D &normal)
369
370 // Boolean operations
371 HepPolyhedron add(const HepPolyhedron &p) co
372 HepPolyhedron subtract(const HepPolyhedron &
373 HepPolyhedron intersect(const HepPolyhedron
374
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
402 static void SetNumberOfRotationSteps(G4int n
403
404 // Reset number of steps for whole circle to
405 static void ResetNumberOfRotationSteps();
406
407 /**
408 * Creates polyhedron for twisted trapezoid.
409 * The trapezoid is given by two bases perpe
410 *
411 * @param Dz half length in z
412 * @param xy1 1st base (at z = -Dz)
413 * @param xy2 2nd base (at z = +Dz)
414 * @return status of the operation - is non-
415 */
416 G4int createTwistedTrap(G4double Dz,
417 const G4double xy1[][2
418
419 /**
420 * Creates user defined polyhedron.
421 * This function allows to the user to defin
422 * The faces of the polyhedron should be eit
423 * quadrilateral. Nodes of a face are define
424 * the elements in the xyz array. Numeration
425 * array starts from 1 (like in fortran). Th
426 * or negative. Negative sign means that the
427 * invisible. The normal of the face should
428 * of the polyhedron.
429 *
430 * @param Nnodes number of nodes
431 * @param Nfaces number of faces
432 * @param xyz nodes
433 * @param faces faces (quadrilaterals or t
434 * @return status of the operation - is non-
435 */
436 G4int createPolyhedron(G4int Nnodes, G4int N
437 const G4double xyz[][
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 };
446
447 class HepPolyhedronTrd2 : public HepPolyhedron
448 {
449 public:
450 HepPolyhedronTrd2(G4double Dx1, G4double Dx2
451 G4double Dy1, G4double Dy2
452 ~HepPolyhedronTrd2() override;
453 };
454
455 class HepPolyhedronTrd1 : public HepPolyhedron
456 {
457 public:
458 HepPolyhedronTrd1(G4double Dx1, G4double Dx2
459 G4double Dy, G4double Dz);
460 ~HepPolyhedronTrd1() override;
461 };
462
463 class HepPolyhedronBox : public HepPolyhedronT
464 {
465 public:
466 HepPolyhedronBox(G4double Dx, G4double Dy, G
467 ~HepPolyhedronBox() override;
468 };
469
470 class HepPolyhedronTrap : public HepPolyhedron
471 {
472 public:
473 HepPolyhedronTrap(G4double Dz, G4double Thet
474 G4double Dy1,
475 G4double Dx1, G4double Dx2
476 G4double Dy2,
477 G4double Dx3, G4double Dx4
478 ~HepPolyhedronTrap() override;
479 };
480
481 class HepPolyhedronPara : public HepPolyhedron
482 {
483 public:
484 HepPolyhedronPara(G4double Dx, G4double Dy,
485 G4double Alpha, G4double T
486 ~HepPolyhedronPara() override;
487 };
488
489 class HepPolyhedronParaboloid : public HepPoly
490 {
491 public:
492 HepPolyhedronParaboloid(G4double r1,
493 G4double r2,
494 G4double dz,
495 G4double Phi1,
496 G4double Dphi);
497 ~HepPolyhedronParaboloid() override;
498 };
499
500 class HepPolyhedronHype : public HepPolyhedron
501 {
502 public:
503 HepPolyhedronHype(G4double r1,
504 G4double r2,
505 G4double tan1,
506 G4double tan2,
507 G4double halfZ);
508 ~HepPolyhedronHype() override;
509 };
510
511 class HepPolyhedronCons : public HepPolyhedron
512 {
513 public:
514 HepPolyhedronCons(G4double Rmn1, G4double Rm
515 G4double Rmn2, G4double Rm
516 G4double Phi1, G4double Dp
517 ~HepPolyhedronCons() override;
518 };
519
520 class HepPolyhedronCone : public HepPolyhedron
521 {
522 public:
523 HepPolyhedronCone(G4double Rmn1, G4double Rm
524 G4double Rmn2, G4double Rm
525 ~HepPolyhedronCone() override;
526 };
527
528 class HepPolyhedronTubs : public HepPolyhedron
529 {
530 public:
531 HepPolyhedronTubs(G4double Rmin, G4double Rm
532 G4double Phi1, G4double Dp
533 ~HepPolyhedronTubs() override;
534 };
535
536 class HepPolyhedronTube : public HepPolyhedron
537 {
538 public:
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 };
631
632 #endif /* HEP_POLYHEDRON_HH */
633