Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/geometry/solids/specific/include/G4PolyPhiFace.hh

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 /geometry/solids/specific/include/G4PolyPhiFace.hh (Version 11.3.0) and /geometry/solids/specific/include/G4PolyPhiFace.hh (Version 8.3.p1)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25 //                                                 25 //
                                                   >>  26 //
                                                   >>  27 // $Id: G4PolyPhiFace.hh,v 1.9 2006/06/29 18:47:08 gunter Exp $
                                                   >>  28 // GEANT4 tag $Name: geant4-08-03-patch-01 $
                                                   >>  29 //
                                                   >>  30 // 
                                                   >>  31 // --------------------------------------------------------------------
                                                   >>  32 // GEANT 4 class header file
                                                   >>  33 //
                                                   >>  34 //
 26 // G4PolyPhiFace                                   35 // G4PolyPhiFace
 27 //                                                 36 //
 28 // Class description:                              37 // Class description:
 29 //                                                 38 //
 30 //   Definition of a face that bounds a polyco     39 //   Definition of a face that bounds a polycone or polyhedra when
 31 //   it has a phi opening:                         40 //   it has a phi opening:
 32 //                                                 41 //
 33 //   G4PolyPhiFace( const G4ReduciblePolygon*  <<  42 //   G4PolyPhiFace( const G4ReduciblePolygon *rz,
 34 //                        G4double phi,            43 //                        G4double phi,
 35 //                        G4double deltaPhi,       44 //                        G4double deltaPhi,
 36 //                        G4double phiOther )      45 //                        G4double phiOther )
 37 //                                                 46 //
 38 //   Specifically: a face that lies on a plane     47 //   Specifically: a face that lies on a plane that passes through
 39 //   the z axis. It has boundaries that are st     48 //   the z axis. It has boundaries that are straight lines of arbitrary
 40 //   length and direction, but with corners aw     49 //   length and direction, but with corners aways on the same side of
 41 //   the z axis.                                   50 //   the z axis.
 42                                                    51 
 43 // Author: David C. Williams (davidw@scipp.ucs <<  52 // Author: 
                                                   >>  53 //   David C. Williams (davidw@scipp.ucsc.edu)
 44 // -------------------------------------------     54 // --------------------------------------------------------------------
 45 #ifndef G4POLYPHIFACE_HH                       <<  55 
 46 #define G4POLYPHIFACE_HH 1                     <<  56 #ifndef G4PolyPhiFace_hh
                                                   >>  57 #define G4PolyPhiFace_hh
 47                                                    58 
 48 #include "G4VCSGface.hh"                           59 #include "G4VCSGface.hh"
 49 #include "G4TwoVector.hh"                      << 
 50                                                    60 
 51 class G4ReduciblePolygon;                          61 class G4ReduciblePolygon;
 52                                                    62 
 53 struct G4PolyPhiFaceVertex                         63 struct G4PolyPhiFaceVertex
 54 {                                                  64 {
 55   G4double x, y, r, z;   // position               65   G4double x, y, r, z;   // position
 56   G4double rNorm,                                  66   G4double rNorm, 
 57            zNorm;        // r/z normal             67            zNorm;        // r/z normal
 58   G4ThreeVector norm3D;  // 3D normal              68   G4ThreeVector norm3D;  // 3D normal
 59                                                << 
 60   // Needed for Triangulation Algorithm        << 
 61   //                                           << 
 62   G4bool ear;                                  << 
 63   G4PolyPhiFaceVertex *next,*prev;             << 
 64 };                                                 69 };
 65                                                    70 
 66 struct G4PolyPhiFaceEdge                           71 struct G4PolyPhiFaceEdge
 67 {                                                  72 {
 68   G4PolyPhiFaceEdge() = default;               <<  73   G4PolyPhiFaceEdge(): v0(0), v1(0) {}
 69   G4PolyPhiFaceVertex  *v0{nullptr}, *v1{nullp <<  74   G4PolyPhiFaceVertex  *v0, *v1;  // Corners
 70   G4double tr{.0}, tz{0.},        // Unit vect <<  75   G4double tr, tz,                // Unit vector along edge
 71            length{0.};            // Length of <<  76            length;                // Length of edge
 72   G4ThreeVector norm3D;           // 3D edge n     77   G4ThreeVector norm3D;           // 3D edge normal vector
 73 };                                                 78 };
 74                                                    79 
 75 class G4PolyPhiFace : public G4VCSGface            80 class G4PolyPhiFace : public G4VCSGface
 76 {                                                  81 {
 77                                                    82 
 78   public:                                      <<  83   public:  // with description
 79                                                    84 
 80     G4PolyPhiFace( const G4ReduciblePolygon* r <<  85     G4PolyPhiFace( const G4ReduciblePolygon *rz,
 81                          G4double phi, G4doubl     86                          G4double phi, G4double deltaPhi, G4double phiOther );
 82       // Constructor.                              87       // Constructor.
 83       // Points r,z should be supplied in cloc     88       // Points r,z should be supplied in clockwise order in r,z.
 84       // For example:                              89       // For example:
 85       //                [1]---------[2]            90       //                [1]---------[2]         ^ R
 86       //                 |           |             91       //                 |           |          |
 87       //                 |           |             92       //                 |           |          +--> z
 88       //                [0]---------[3]            93       //                [0]---------[3]
 89                                                    94 
 90     ~G4PolyPhiFace() override;                 <<  95     virtual ~G4PolyPhiFace();
 91       // Destructor. Removes edges and corners     96       // Destructor. Removes edges and corners.
 92                                                    97 
 93     G4PolyPhiFace( const G4PolyPhiFace &source     98     G4PolyPhiFace( const G4PolyPhiFace &source );
 94     G4PolyPhiFace& operator=( const G4PolyPhiF     99     G4PolyPhiFace& operator=( const G4PolyPhiFace &source );
 95       // Copy constructor and assgnment operat    100       // Copy constructor and assgnment operator.
 96                                                   101 
 97     G4bool Intersect( const G4ThreeVector& p,  << 102     G4bool Intersect( const G4ThreeVector &p, const G4ThreeVector &v,
 98                             G4bool outgoing, G    103                             G4bool outgoing, G4double surfTolerance,
 99                             G4double& distance << 104                             G4double &distance, G4double &distFromSurface,
100                             G4ThreeVector& nor << 105                             G4ThreeVector &normal, G4bool &allBehind );
101                                                   106 
102     G4double Distance( const G4ThreeVector& p, << 107     G4double Distance( const G4ThreeVector &p, G4bool outgoing );
103                                                   108   
104     EInside Inside( const G4ThreeVector& p, G4 << 109     EInside Inside( const G4ThreeVector &p, G4double tolerance, 
105                           G4double* bestDistan << 110                           G4double *bestDistance );
106                                                   111     
107     G4ThreeVector Normal( const G4ThreeVector& << 112     G4ThreeVector Normal( const G4ThreeVector &p, G4double *bestDistance );
108                                 G4double* best << 
109                                                   113 
110     G4double Extent( const G4ThreeVector axis  << 114     G4double Extent( const G4ThreeVector axis );
111                                                   115   
112     void CalculateExtent( const EAxis axis,       116     void CalculateExtent( const EAxis axis, 
113                           const G4VoxelLimits     117                           const G4VoxelLimits &voxelLimit,
114                           const G4AffineTransf << 118                           const G4AffineTransform &tranform,
115                                 G4SolidExtentL << 119                                 G4SolidExtentList &extentList );
116                                                   120 
117     inline G4VCSGface* Clone() override;       << 121     inline G4VCSGface *Clone();
118       // Allocates on the heap a clone of this    122       // Allocates on the heap a clone of this face.
119                                                   123 
120     G4double SurfaceArea() override;           << 124   public:  // without description
121     G4double SurfaceTriangle( const G4ThreeVec << 
122                               const G4ThreeVec << 
123     G4ThreeVector GetPointOnFace() override;   << 
124       // Auxiliary methods for determination o << 
125                                                   125 
126     G4PolyPhiFace(__void__&);                     126     G4PolyPhiFace(__void__&);
127       // Fake default constructor for usage re    127       // Fake default constructor for usage restricted to direct object
128       // persistency for clients requiring pre    128       // persistency for clients requiring preallocation of memory for
129       // persistifiable objects.                  129       // persistifiable objects.
130                                                   130 
131     void Diagnose( G4VSolid* solid );          << 131     void Diagnose( G4VSolid *solid );
132       // Throw an exception if something is fo    132       // Throw an exception if something is found inconsistent with
133       // the solid. For debugging purposes onl    133       // the solid. For debugging purposes only
134                                                   134 
135   protected:                                      135   protected:
136                                                   136 
137     G4bool InsideEdgesExact( G4double r, G4dou    137     G4bool InsideEdgesExact( G4double r, G4double z, G4double normSign,
138                              const G4ThreeVect << 138                              const G4ThreeVector &p, const G4ThreeVector &v );
139       // Decide if the point in r,z is inside     139       // Decide if the point in r,z is inside the edges of our face,
140       // **but** do so consistently with other    140       // **but** do so consistently with other faces.
141                                                   141 
142     G4bool InsideEdges( G4double r, G4double z    142     G4bool InsideEdges( G4double r, G4double z );
143     G4bool InsideEdges( G4double r, G4double z << 143     G4bool InsideEdges( G4double r, G4double z, G4double *distRZ2,
144                         G4PolyPhiFaceVertex**  << 144                         G4PolyPhiFaceVertex **base3Dnorm=0,
145                         G4ThreeVector** head3D << 145                         G4ThreeVector **head3Dnorm=0 );
146       // Decide if the point in r,z is inside     146       // Decide if the point in r,z is inside the edges of our face.
147                                                   147 
148     inline G4double ExactZOrder( G4double z,      148     inline G4double ExactZOrder( G4double z, 
149                                  G4double qx,     149                                  G4double qx, G4double qy, G4double qz, 
150                            const G4ThreeVector << 150                            const G4ThreeVector &v, 
151                                  G4double norm    151                                  G4double normSign,
152                            const G4PolyPhiFace << 152                            const G4PolyPhiFaceVertex *vert ) const;
153       // Decide precisely whether a trajectory    153       // Decide precisely whether a trajectory passes to the left, right,
154       // or exactly passes through the z posit    154       // or exactly passes through the z position of a vertex point in face.
155                                                   155 
156     void CopyStuff( const G4PolyPhiFace& sourc << 156     void CopyStuff( const G4PolyPhiFace &source );
157                                                << 
158     // Functions used for Triangulation in Cas << 
159     // The triangulation is used for GetPointO << 
160                                                << 
161     G4double Area2( const G4TwoVector& a, cons << 
162       // Calculation of 2*Area of Triangle wit << 
163                                                << 
164     G4bool Left( const G4TwoVector& a, const G << 
165     G4bool LeftOn( const G4TwoVector& a, const << 
166     G4bool Collinear( const G4TwoVector& a, co << 
167       // Boolean functions for sign of Surface << 
168                                                << 
169     G4bool IntersectProp( const G4TwoVector& a << 
170                           const G4TwoVector& c << 
171       // Boolean function for finding proper i << 
172       // line segments (a,b) and (c,d).        << 
173                                                << 
174     G4bool Between( const G4TwoVector& a, cons << 
175       // Boolean function for determining if p << 
176       // where the three points (a,b,c) are on << 
177                                                << 
178     G4bool Intersect( const G4TwoVector& a, co << 
179                       const G4TwoVector& c, co << 
180       // Boolean function for finding proper i << 
181       // of two line segments (a,b) and (c,d). << 
182                                                << 
183     G4bool Diagonalie( G4PolyPhiFaceVertex* a, << 
184       // Boolean Diagonalie help to determine  << 
185       // of segment (a,b) is convex or reflex. << 
186                                                << 
187     G4bool InCone( G4PolyPhiFaceVertex *a, G4P << 
188       // Boolean function for determining if b << 
189       // where a is the center of the cone.    << 
190                                                << 
191     G4bool Diagonal( G4PolyPhiFaceVertex* a, G << 
192       // Boolean function for determining if D << 
193       // inside Polycone or PolyHedra.         << 
194                                                << 
195     void EarInit();                            << 
196       // Initialisation for Triangulisation by << 
197       // For details see "Computational Geomet << 
198                                                << 
199     void Triangulate();                        << 
200       // Triangularisation by ear tips for Pol << 
201       // For details see "Computational Geomet << 
202       // NOTE: a copy of the shape is made and << 
203       //       order to have a list of triangl << 
204       //       method GetPointOnFace().        << 
205                                                   157 
206   protected:                                      158   protected:
207                                                   159 
208     G4int numEdges = 0;  // Number of edges    << 160     G4int      numEdges;            // Number of edges
209     G4PolyPhiFaceEdge* edges = nullptr;        << 161     G4PolyPhiFaceEdge   *edges;     // The edges of the face
210     G4PolyPhiFaceVertex* corners = nullptr;    << 162     G4PolyPhiFaceVertex *corners;   // And the corners
211     G4ThreeVector normal;        // Normal uni << 163     G4ThreeVector    normal;        // Normal unit vector
212     G4ThreeVector radial;        // Unit vecto << 164     G4ThreeVector    radial;        // Unit vector along radial direction
213     G4ThreeVector surface;       // Point on s << 165     G4ThreeVector    surface;       // Point on surface
214     G4ThreeVector surface_point; // Auxiliary  << 166     G4double   rMin, rMax, // Extent in r
215                                  // method Get << 167                zMin, zMax; // Extent in z
216     G4double rMin, rMax, // Extent in r        << 168     G4bool      allBehind; // True if the polycone/polyhedra
217              zMin, zMax; // Extent in z        << 169                            // is behind the place of this face
218     G4bool allBehind = false; // True if the p << 
219                               // is behind the << 
220     G4double kCarTolerance;      // Surface th << 
221     G4double fSurfaceArea = 0.0; // Surface Ar << 
222     G4PolyPhiFaceVertex* triangles = nullptr;  << 
223       // Auxiliary pointer to 'corners' used f << 
224       // Copy structure, changing the structur << 
225 };                                                170 };
226                                                   171 
227 #include "G4PolyPhiFace.icc"                      172 #include "G4PolyPhiFace.icc"
228                                                   173 
229 #endif                                            174 #endif
230                                                   175