Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/geometry/solids/specific/src/G4TessellatedGeometryAlgorithms.cc

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/src/G4TessellatedGeometryAlgorithms.cc (Version 11.3.0) and /geometry/solids/specific/src/G4TessellatedGeometryAlgorithms.cc (Version 9.2.p3)


  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 and of QinetiQ Ltd,   *
 20 // * subject to DEFCON 705 IPR conditions.         20 // * subject to DEFCON 705 IPR conditions.                            *
 21 // * By using,  copying,  modifying or  distri     21 // * By using,  copying,  modifying or  distributing the software (or *
 22 // * any work based  on the software)  you  ag     22 // * any work based  on the software)  you  agree  to acknowledge its *
 23 // * use  in  resulting  scientific  publicati     23 // * use  in  resulting  scientific  publications,  and indicate your *
 24 // * acceptance of all terms of the Geant4 Sof     24 // * acceptance of all terms of the Geant4 Software license.          *
 25 // *******************************************     25 // ********************************************************************
 26 //                                                 26 //
 27 // G4TessellatedGeometryAlgorithms implementat <<  27 //
                                                   >>  28 // $Id: G4TessellatedGeometryAlgorithms.cc,v 1.6 2008/12/18 12:57:36 gunter Exp $
                                                   >>  29 // GEANT4 tag $Name: geant4-09-02-patch-03 $
                                                   >>  30 //
                                                   >>  31 // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
                                                   >>  32 //
                                                   >>  33 // MODULE:              G4TessellatedGeometryAlgorithms.cc
                                                   >>  34 //
                                                   >>  35 // Date:                07/08/2005
                                                   >>  36 // Author:              Rickard Holmberg & Pete Truscott
                                                   >>  37 // Organisation:        QinetiQ Ltd, UK (PT)
                                                   >>  38 // Customer:            ESA-ESTEC / TEC-EES
                                                   >>  39 // Contract:            
                                                   >>  40 //
                                                   >>  41 // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
                                                   >>  42 //
                                                   >>  43 // CHANGE HISTORY
                                                   >>  44 // --------------
 28 //                                                 45 //
 29 // 07 August 2007, P R Truscott, QinetiQ Ltd,      46 // 07 August 2007, P R Truscott, QinetiQ Ltd, UK - Created, with member
 30 //                 functions based on the work     47 //                 functions based on the work of Rickard Holmberg.
 31 // 12 October 2012, M Gayer, CERN, - Reviewed  <<  48 //
 32 // ------------------------------------------- <<  49 // 26 September 2007
                                                   >>  50 //                 P R Truscott, qinetiQ Ltd, UK
                                                   >>  51 //                 Updated to assign values of location array, not update
                                                   >>  52 //                 just the pointer.
                                                   >>  53 //
                                                   >>  54 ///////////////////////////////////////////////////////////////////////////////
 33                                                    55 
 34 #include "G4TessellatedGeometryAlgorithms.hh"      56 #include "G4TessellatedGeometryAlgorithms.hh"
                                                   >>  57 ///////////////////////////////////////////////////////////////////////////////
                                                   >>  58 //
                                                   >>  59 // Pointer to single instance of class.
                                                   >>  60 //
                                                   >>  61 G4TessellatedGeometryAlgorithms* G4TessellatedGeometryAlgorithms::fInstance = 0;
 35                                                    62 
 36 #include <cfloat>                              <<  63 ///////////////////////////////////////////////////////////////////////////////
                                                   >>  64 //
                                                   >>  65 // G4TessellatedGeometryAlgorithms
                                                   >>  66 //
                                                   >>  67 // Constructor doesn't need to do anything since this class just allows access
                                                   >>  68 // to the geometric algorithms contained in member functions.
                                                   >>  69 //
                                                   >>  70 G4TessellatedGeometryAlgorithms::G4TessellatedGeometryAlgorithms ()
                                                   >>  71 {
                                                   >>  72 }
                                                   >>  73 
                                                   >>  74 ///////////////////////////////////////////////////////////////////////////////
                                                   >>  75 //
                                                   >>  76 // GetInstance
                                                   >>  77 //
                                                   >>  78 // This is the access point for this singleton.
                                                   >>  79 //
                                                   >>  80 G4TessellatedGeometryAlgorithms* G4TessellatedGeometryAlgorithms::GetInstance()
                                                   >>  81 {
                                                   >>  82   static G4TessellatedGeometryAlgorithms worldStdGeom;
                                                   >>  83   if (!fInstance)
                                                   >>  84   {
                                                   >>  85     fInstance = &worldStdGeom;
                                                   >>  86   }
                                                   >>  87   return fInstance;
                                                   >>  88 }
 37                                                    89 
 38 //////////////////////////////////////////////     90 ///////////////////////////////////////////////////////////////////////////////
 39 //                                                 91 //
 40 // IntersectLineAndTriangle2D                      92 // IntersectLineAndTriangle2D
 41 //                                                 93 //
 42 // Determines whether there is an intersection     94 // Determines whether there is an intersection between a line defined
 43 // by r = p + s.v and a triangle defined by ve <<  95 // by r = p + s.v and a triangle defined by verticies P0, P0+E0 and P0+E1.
 44 //                                                 96 //
 45 // Here:                                           97 // Here:
 46 //        p = 2D vector                            98 //        p = 2D vector
 47 //        s = scaler on [0,infinity)               99 //        s = scaler on [0,infinity)
 48 //        v = 2D vector                           100 //        v = 2D vector
 49 //        p0, e0 and e1 are 2D vectors         << 101 //        P0, E0 and E1 are 2D vectors
 50 // Information about where the intersection oc    102 // Information about where the intersection occurs is returned in the
 51 // variable location.                             103 // variable location.
 52 //                                                104 //
 53 // This is based on the work of Rickard Holmbe    105 // This is based on the work of Rickard Holmberg.
 54 //                                                106 //
 55 G4bool G4TessellatedGeometryAlgorithms::Inters    107 G4bool G4TessellatedGeometryAlgorithms::IntersectLineAndTriangle2D (
 56   const G4TwoVector& p,  const G4TwoVector& v, << 108   const G4TwoVector p,  const G4TwoVector v,
 57   const G4TwoVector& p0, const G4TwoVector& e0 << 109   const G4TwoVector P0, const G4TwoVector E0, const G4TwoVector E1,
 58   G4TwoVector location[2])                        110   G4TwoVector location[2])
 59 {                                                 111 {
 60   G4TwoVector loc0[2];                            112   G4TwoVector loc0[2];
 61   G4int e0i = IntersectLineAndLineSegment2D (p << 113   G4int e0i = IntersectLineAndLineSegment2D (p,v,P0,E0,loc0);
 62   if (e0i == 2)                                   114   if (e0i == 2)
 63   {                                               115   {
 64     location[0] = loc0[0];                        116     location[0] = loc0[0];
 65     location[1] = loc0[1];                        117     location[1] = loc0[1];
 66     return true;                                  118     return true;
 67   }                                               119   }
 68                                                << 120   
 69   G4TwoVector loc1[2];                            121   G4TwoVector loc1[2];
 70   G4int e1i = IntersectLineAndLineSegment2D (p << 122   G4int e1i = IntersectLineAndLineSegment2D (p,v,P0,E1,loc1);
 71   if (e1i == 2)                                   123   if (e1i == 2)
 72   {                                               124   {
 73     location[0] = loc1[0];                        125     location[0] = loc1[0];
 74     location[1] = loc1[1];                        126     location[1] = loc1[1];
 75     return true;                                  127     return true;
 76   }                                               128   }
 77                                                << 129   
 78   if ((e0i == 1) && (e1i == 1))                   130   if ((e0i == 1) && (e1i == 1))
 79   {                                               131   {
 80     if ((loc0[0]-p).mag2() < (loc1[0]-p).mag2(    132     if ((loc0[0]-p).mag2() < (loc1[0]-p).mag2())
 81     {                                             133     {
 82       location[0] = loc0[0];                      134       location[0] = loc0[0];
 83       location[1] = loc1[0];                      135       location[1] = loc1[0];
 84     }                                             136     }
 85     else                                          137     else
 86     {                                             138     {
 87       location[0] = loc1[0];                      139       location[0] = loc1[0];
 88       location[1] = loc0[0];                      140       location[1] = loc0[0];
 89     }                                             141     }
 90     return true;                                  142     return true;
 91   }                                               143   }
 92                                                << 144   
 93   G4TwoVector p1 = p0 + e0;                    << 145   G4TwoVector P1 = P0 + E0;
 94   G4TwoVector DE = e1 - e0;                    << 146   G4TwoVector DE = E1 - E0;
 95   G4TwoVector loc2[2];                            147   G4TwoVector loc2[2];
 96   G4int e2i = IntersectLineAndLineSegment2D (p << 148   G4int e2i = IntersectLineAndLineSegment2D (p,v,P1,DE,loc2);
 97   if (e2i == 2)                                   149   if (e2i == 2)
 98   {                                               150   {
 99     location[0] = loc2[0];                        151     location[0] = loc2[0];
100     location[1] = loc2[1];                        152     location[1] = loc2[1];
101     return true;                                  153     return true;
102   }                                               154   }
103                                                   155 
104   if ((e0i == 0) && (e1i == 0) && (e2i == 0))  << 156   if ((e0i == 0) && (e1i == 0) && (e2i == 0)) { return false; }
105                                                   157 
106   if ((e0i == 1) && (e2i == 1))                   158   if ((e0i == 1) && (e2i == 1))
107   {                                               159   {
108     if ((loc0[0]-p).mag2() < (loc2[0]-p).mag2(    160     if ((loc0[0]-p).mag2() < (loc2[0]-p).mag2())
109     {                                             161     {
110       location[0] = loc0[0];                      162       location[0] = loc0[0];
111       location[1] = loc2[0];                      163       location[1] = loc2[0];
112     }                                             164     }
113     else                                          165     else
114     {                                             166     {
115       location[0] = loc2[0];                      167       location[0] = loc2[0];
116       location[1] = loc0[0];                      168       location[1] = loc0[0];
117     }                                             169     }
118     return true;                                  170     return true;
119   }                                               171   }
120                                                   172 
121   if ((e1i == 1) && (e2i == 1))                   173   if ((e1i == 1) && (e2i == 1))
122   {                                               174   {
123     if ((loc1[0]-p).mag2() < (loc2[0]-p).mag2(    175     if ((loc1[0]-p).mag2() < (loc2[0]-p).mag2())
124     {                                             176     {
125       location[0] = loc1[0];                      177       location[0] = loc1[0];
126       location[1] = loc2[0];                      178       location[1] = loc2[0];
127     }                                             179     }
128     else                                          180     else
129     {                                             181     {
130       location[0] = loc2[0];                      182       location[0] = loc2[0];
131       location[1] = loc1[0];                      183       location[1] = loc1[0];
132     }                                             184     }
133     return true;                                  185     return true;
134   }                                               186   }
135                                                   187 
136   return false;                                   188   return false;
137 }                                                 189 }
138                                                   190 
139 //////////////////////////////////////////////    191 ///////////////////////////////////////////////////////////////////////////////
140 //                                                192 //
141 // IntersectLineAndLineSegment2D                  193 // IntersectLineAndLineSegment2D
142 //                                                194 //
143 // Determines whether there is an intersection    195 // Determines whether there is an intersection between a line defined
144 // by r = p0 + s.d0 and a line-segment with en << 196 // by r = P0 + s.D0 and a line-segment with endpoints P1 and P1+D1.
145 // Here:                                          197 // Here:
146 //        p0 = 2D vector                       << 198 //        P0 = 2D vector
147 //        s  = scaler on [0,infinity)             199 //        s  = scaler on [0,infinity)
148 //        d0 = 2D vector                       << 200 //        D0 = 2D vector
149 //        p1 and d1 are 2D vectors             << 201 //        P1 and D1 are 2D vectors
150 //                                                202 //
151 // This function returns:                         203 // This function returns:
152 // 0 - if there is no intersection;               204 // 0 - if there is no intersection;
153 // 1 - if there is a unique intersection;         205 // 1 - if there is a unique intersection;
154 // 2 - if the line and line-segments overlap,     206 // 2 - if the line and line-segments overlap, and the intersection is a
155 //     segment itself.                            207 //     segment itself.
156 // Information about where the intersection oc    208 // Information about where the intersection occurs is returned in the
157 // as ??.                                         209 // as ??.
158 //                                                210 //
159 // This is based on the work of Rickard Holmbe    211 // This is based on the work of Rickard Holmberg as well as material published
160 // by Philip J Schneider and David H Eberly, "    212 // by Philip J Schneider and David H Eberly, "Geometric Tools for Computer
161 // Graphics," ISBN 1-55860-694-0, pp 244-245,     213 // Graphics," ISBN 1-55860-694-0, pp 244-245, 2003.
162 //                                                214 //
163 G4int G4TessellatedGeometryAlgorithms::Interse    215 G4int G4TessellatedGeometryAlgorithms::IntersectLineAndLineSegment2D (
164   const G4TwoVector& p0, const G4TwoVector& d0 << 216   const G4TwoVector P0, const G4TwoVector D0,
165   const G4TwoVector& p1, const G4TwoVector& d1 << 217   const G4TwoVector P1, const G4TwoVector D1,
                                                   >> 218   G4TwoVector location[2])
166 {                                                 219 {
167   G4TwoVector e     = p1 - p0;                 << 220   G4TwoVector E     = P1 - P0;
168   G4double kross    = cross(d0,d1);            << 221   G4double kross    = cross(D0,D1);
169   G4double sqrKross = kross * kross;              222   G4double sqrKross = kross * kross;
170   G4double sqrLen0  = d0.mag2();               << 223   G4double sqrLen0  = D0.mag2();
171   G4double sqrLen1  = d1.mag2();               << 224   G4double sqrLen1  = D1.mag2();
172   location[0]       = G4TwoVector(0.0,0.0);       225   location[0]       = G4TwoVector(0.0,0.0);
173   location[1]       = G4TwoVector(0.0,0.0);       226   location[1]       = G4TwoVector(0.0,0.0);
174                                                   227 
175   if (sqrKross > DBL_EPSILON * DBL_EPSILON * s    228   if (sqrKross > DBL_EPSILON * DBL_EPSILON * sqrLen0 * sqrLen1)
176   {                                               229   {
177     //                                         << 230 //
178     // The line and line segment are not paral << 231 //
179     // is in positive s where r=p0 + s*d0, and << 232 // The line and line segment are not parallel.  Determine if the intersection
180     //                                         << 233 // is in positive s where r = P0 + s*D0, and for 0<=t<=1 where r = p1 + t*D1.
181     G4double ss = cross(e,d1)/kross;           << 234 //
182     if (ss < 0)         return 0; // Intersect << 235     G4double s = cross(E,D1)/kross;
183     G4double t = cross(e,d0)/kross;            << 236     if (s < 0)          return 0; // Intersection does not occur for positive s.
184     if (t < 0 || t > 1) return 0; // Intersect << 237     G4double t = cross(E,D0)/kross;
185     //                                         << 238     if (t < 0 || t > 1) return 0; // Intersection does not occur on line-segment.
186     // Intersection of lines is a single point << 239 //
187     // defined by r=p0 + ss*d0, and the line s << 240 //
188     //                                         << 241 // Intersection of lines is a single point on the forward-propagating line
189     location[0] = p0 + ss*d0;                  << 242 // defined by r = P0 + s*D0, and the line segment defined by  r = p1 + t*D1.
                                                   >> 243 //
                                                   >> 244     location[0] = P0 + s*D0;
190     return 1;                                     245     return 1;
191   }                                               246   }
192   //                                           << 247 //
193   // Line and line segment are parallel. Deter << 248 //
194   //                                           << 249 // Line and line segment are parallel.  Determine whether they overlap or not.
195   G4double sqrLenE = e.mag2();                 << 250 //
196   kross            = cross(e,d0);              << 251   G4double sqrLenE = E.mag2();
                                                   >> 252   kross            = cross(E,D0);
197   sqrKross         = kross * kross;               253   sqrKross         = kross * kross;
198   if (sqrKross > DBL_EPSILON * DBL_EPSILON * s    254   if (sqrKross > DBL_EPSILON * DBL_EPSILON * sqrLen0 * sqrLenE)
199   {                                               255   {
200     return 0; //Lines are different.              256     return 0; //Lines are different.
201   }                                               257   }
202   //                                           << 258 //
203   // Lines are the same.  Test for overlap.    << 259 //
204   //                                           << 260 // Lines are the same.  Test for overlap.
205   G4double s0   = d0.dot(e)/sqrLen0;           << 261 //
206   G4double s1   = s0 + d0.dot(d1)/sqrLen0;     << 262   G4double s0   = D0.dot(E)/sqrLen0;
                                                   >> 263   G4double s1   = s0 + D0.dot(D1)/sqrLen0;
207   G4double smin = 0.0;                            264   G4double smin = 0.0;
208   G4double smax = 0.0;                            265   G4double smax = 0.0;
209                                                   266 
210   if (s0 < s1) {smin = s0; smax = s1;}            267   if (s0 < s1) {smin = s0; smax = s1;}
211   else         {smin = s1; smax = s0;}            268   else         {smin = s1; smax = s0;}
212                                                   269 
213   if (smax < 0.0) return 0;                       270   if (smax < 0.0) return 0;
214   else if (smin < 0.0)                            271   else if (smin < 0.0)
215   {                                               272   {
216     location[0] = p0;                          << 273     location[0] = P0;
217     location[1] = p0 + smax*d0;                << 274     location[1] = P0 + smax*D0;
218     return 2;                                     275     return 2;
219   }                                               276   }
220   else                                            277   else
221   {                                               278   {
222     location[0] = p0 + smin*d0;                << 279     location[0] = P0 + smin*D0;
223     location[1] = p0 + smax*d0;                << 280     location[1] = P0 + smax*D0;
224     return 2;                                     281     return 2;
225   }                                               282   }
226 }                                              << 
227                                                << 
228 ////////////////////////////////////////////// << 
229 //                                             << 
230 // CrossProduct                                << 
231 //                                             << 
232 // This is just a ficticious "cross-product" f << 
233 // "ficticious" because such an operation is n << 
234 // with 3D space.                              << 
235 //                                             << 
236 G4double G4TessellatedGeometryAlgorithms::cros << 
237                                                << 
238 {                                              << 
239   return v1.x()*v2.y() - v1.y()*v2.x();        << 
240 }                                                 283 }
241                                                   284