Geant4  10.03.p03
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
G4PolyPhiFace Class Reference

#include <G4PolyPhiFace.hh>

Inheritance diagram for G4PolyPhiFace:
Collaboration diagram for G4PolyPhiFace:

Public Member Functions

 G4PolyPhiFace (const G4ReduciblePolygon *rz, G4double phi, G4double deltaPhi, G4double phiOther)
 
virtual ~G4PolyPhiFace ()
 
 G4PolyPhiFace (const G4PolyPhiFace &source)
 
G4PolyPhiFaceoperator= (const G4PolyPhiFace &source)
 
G4bool Intersect (const G4ThreeVector &p, const G4ThreeVector &v, G4bool outgoing, G4double surfTolerance, G4double &distance, G4double &distFromSurface, G4ThreeVector &normal, G4bool &allBehind)
 
G4double Distance (const G4ThreeVector &p, G4bool outgoing)
 
EInside Inside (const G4ThreeVector &p, G4double tolerance, G4double *bestDistance)
 
G4ThreeVector Normal (const G4ThreeVector &p, G4double *bestDistance)
 
G4double Extent (const G4ThreeVector axis)
 
void CalculateExtent (const EAxis axis, const G4VoxelLimits &voxelLimit, const G4AffineTransform &tranform, G4SolidExtentList &extentList)
 
G4VCSGfaceClone ()
 
G4double SurfaceArea ()
 
G4double SurfaceTriangle (G4ThreeVector p1, G4ThreeVector p2, G4ThreeVector p3, G4ThreeVector *p4)
 
G4ThreeVector GetPointOnFace ()
 
 G4PolyPhiFace (__void__ &)
 
void Diagnose (G4VSolid *solid)
 
- Public Member Functions inherited from G4VCSGface
 G4VCSGface ()
 
virtual ~G4VCSGface ()
 

Protected Member Functions

G4bool InsideEdgesExact (G4double r, G4double z, G4double normSign, const G4ThreeVector &p, const G4ThreeVector &v)
 
G4bool InsideEdges (G4double r, G4double z)
 
G4bool InsideEdges (G4double r, G4double z, G4double *distRZ2, G4PolyPhiFaceVertex **base3Dnorm=0, G4ThreeVector **head3Dnorm=0)
 
G4double ExactZOrder (G4double z, G4double qx, G4double qy, G4double qz, const G4ThreeVector &v, G4double normSign, const G4PolyPhiFaceVertex *vert) const
 
void CopyStuff (const G4PolyPhiFace &source)
 
G4double Area2 (G4TwoVector a, G4TwoVector b, G4TwoVector c)
 
G4bool Left (G4TwoVector a, G4TwoVector b, G4TwoVector c)
 
G4bool LeftOn (G4TwoVector a, G4TwoVector b, G4TwoVector c)
 
G4bool Collinear (G4TwoVector a, G4TwoVector b, G4TwoVector c)
 
G4bool IntersectProp (G4TwoVector a, G4TwoVector b, G4TwoVector c, G4TwoVector d)
 
G4bool Between (G4TwoVector a, G4TwoVector b, G4TwoVector c)
 
G4bool Intersect (G4TwoVector a, G4TwoVector b, G4TwoVector c, G4TwoVector d)
 
G4bool Diagonalie (G4PolyPhiFaceVertex *a, G4PolyPhiFaceVertex *b)
 
G4bool InCone (G4PolyPhiFaceVertex *a, G4PolyPhiFaceVertex *b)
 
G4bool Diagonal (G4PolyPhiFaceVertex *a, G4PolyPhiFaceVertex *b)
 
void EarInit ()
 
void Triangulate ()
 

Protected Attributes

G4int numEdges
 
G4PolyPhiFaceEdgeedges
 
G4PolyPhiFaceVertexcorners
 
G4ThreeVector normal
 
G4ThreeVector radial
 
G4ThreeVector surface
 
G4ThreeVector surface_point
 
G4double rMin
 
G4double rMax
 
G4double zMin
 
G4double zMax
 
G4bool allBehind
 
G4double kCarTolerance
 
G4double fSurfaceArea
 
G4PolyPhiFaceVertextriangles
 

Detailed Description

Definition at line 85 of file G4PolyPhiFace.hh.

Constructor & Destructor Documentation

G4PolyPhiFace::G4PolyPhiFace ( const G4ReduciblePolygon rz,
G4double  phi,
G4double  deltaPhi,
G4double  phiOther 
)

Definition at line 61 of file G4PolyPhiFace.cc.

65  : fSurfaceArea(0.), triangles(0)
66 {
68 
69  numEdges = rz->NumVertices();
70 
71  rMin = rz->Amin();
72  rMax = rz->Amax();
73  zMin = rz->Bmin();
74  zMax = rz->Bmax();
75 
76  //
77  // Is this the "starting" phi edge of the two?
78  //
79  G4bool start = (phiOther > phi);
80 
81  //
82  // Build radial vector
83  //
84  radial = G4ThreeVector( std::cos(phi), std::sin(phi), 0.0 );
85 
86  //
87  // Build normal
88  //
89  G4double zSign = start ? 1 : -1;
90  normal = G4ThreeVector( zSign*radial.y(), -zSign*radial.x(), 0 );
91 
92  //
93  // Is allBehind?
94  //
95  allBehind = (zSign*(std::cos(phiOther)*radial.y() - std::sin(phiOther)*radial.x()) < 0);
96 
97  //
98  // Adjacent edges
99  //
100  G4double midPhi = phi + (start ? +0.5 : -0.5)*deltaPhi;
101  G4double cosMid = std::cos(midPhi),
102  sinMid = std::sin(midPhi);
103 
104  //
105  // Allocate corners
106  //
108  //
109  // Fill them
110  //
111  G4ReduciblePolygonIterator iterRZ(rz);
112 
115 
116  iterRZ.Begin();
117  do // Loop checking, 13.08.2015, G.Cosmo
118  {
119  corn->r = iterRZ.GetA();
120  corn->z = iterRZ.GetB();
121  corn->x = corn->r*radial.x();
122  corn->y = corn->r*radial.y();
123 
124  // Add pointer on prev corner
125  //
126  if( corn == corners )
127  { corn->prev = corners+numEdges-1;}
128  else
129  { corn->prev = helper; }
130 
131  // Add pointer on next corner
132  //
133  if( corn < corners+numEdges-1 )
134  { corn->next = corn+1;}
135  else
136  { corn->next = corners; }
137 
138  helper = corn;
139  } while( ++corn, iterRZ.Next() );
140 
141  //
142  // Allocate edges
143  //
145 
146  //
147  // Fill them
148  //
149  G4double rFact = std::cos(0.5*deltaPhi);
150  G4double rFactNormalize = 1.0/std::sqrt(1.0+rFact*rFact);
151 
153  *here = corners;
154  G4PolyPhiFaceEdge *edge = edges;
155  do // Loop checking, 13.08.2015, G.Cosmo
156  {
157  G4ThreeVector sideNorm;
158 
159  edge->v0 = prev;
160  edge->v1 = here;
161 
162  G4double dr = here->r - prev->r,
163  dz = here->z - prev->z;
164 
165  edge->length = std::sqrt( dr*dr + dz*dz );
166 
167  edge->tr = dr/edge->length;
168  edge->tz = dz/edge->length;
169 
170  if ((here->r < DBL_MIN) && (prev->r < DBL_MIN))
171  {
172  //
173  // Sigh! Always exceptions!
174  // This edge runs at r==0, so its adjoing surface is not a
175  // PolyconeSide or PolyhedraSide, but the opposite PolyPhiFace.
176  //
177  G4double zSignOther = start ? -1 : 1;
178  sideNorm = G4ThreeVector( zSignOther*std::sin(phiOther),
179  -zSignOther*std::cos(phiOther), 0 );
180  }
181  else
182  {
183  sideNorm = G4ThreeVector( edge->tz*cosMid,
184  edge->tz*sinMid,
185  -edge->tr*rFact );
186  sideNorm *= rFactNormalize;
187  }
188  sideNorm += normal;
189 
190  edge->norm3D = sideNorm.unit();
191  } while( edge++, prev=here, ++here < corners+numEdges );
192 
193  //
194  // Go back and fill in corner "normals"
195  //
196  G4PolyPhiFaceEdge *prevEdge = edges+numEdges-1;
197  edge = edges;
198  do // Loop checking, 13.08.2015, G.Cosmo
199  {
200  //
201  // Calculate vertex 2D normals (on the phi surface)
202  //
203  G4double rPart = prevEdge->tr + edge->tr;
204  G4double zPart = prevEdge->tz + edge->tz;
205  G4double norm = std::sqrt( rPart*rPart + zPart*zPart );
206  G4double rNorm = +zPart/norm;
207  G4double zNorm = -rPart/norm;
208 
209  edge->v0->rNorm = rNorm;
210  edge->v0->zNorm = zNorm;
211 
212  //
213  // Calculate the 3D normals.
214  //
215  // Find the vector perpendicular to the z axis
216  // that defines the plane that contains the vertex normal
217  //
218  G4ThreeVector xyVector;
219 
220  if (edge->v0->r < DBL_MIN)
221  {
222  //
223  // This is a vertex at r==0, which is a special
224  // case. The normal we will construct lays in the
225  // plane at the center of the phi opening.
226  //
227  // We also know that rNorm < 0
228  //
229  G4double zSignOther = start ? -1 : 1;
230  G4ThreeVector normalOther( zSignOther*std::sin(phiOther),
231  -zSignOther*std::cos(phiOther), 0 );
232 
233  xyVector = - normal - normalOther;
234  }
235  else
236  {
237  //
238  // This is a vertex at r > 0. The plane
239  // is the average of the normal and the
240  // normal of the adjacent phi face
241  //
242  xyVector = G4ThreeVector( cosMid, sinMid, 0 );
243  if (rNorm < 0)
244  xyVector -= normal;
245  else
246  xyVector += normal;
247  }
248 
249  //
250  // Combine it with the r/z direction from the face
251  //
252  edge->v0->norm3D = rNorm*xyVector.unit() + G4ThreeVector( 0, 0, zNorm );
253  } while( prevEdge=edge, ++edge < edges+numEdges );
254 
255  //
256  // Build point on surface
257  //
258  G4double rAve = 0.5*(rMax-rMin),
259  zAve = 0.5*(zMax-zMin);
260  surface = G4ThreeVector( rAve*radial.x(), rAve*radial.y(), zAve );
261 }
G4double Amax() const
CLHEP::Hep3Vector G4ThreeVector
G4PolyPhiFaceVertex * v1
double x() const
G4double Amin() const
G4PolyPhiFaceVertex * v0
G4double GetSurfaceTolerance() const
G4ThreeVector norm3D
G4double kCarTolerance
G4int NumVertices() const
G4double Bmax() const
bool G4bool
Definition: G4Types.hh:79
G4PolyPhiFaceVertex * next
G4PolyPhiFaceVertex * prev
G4PolyPhiFaceVertex * corners
G4double fSurfaceArea
G4PolyPhiFaceVertex * triangles
Hep3Vector unit() const
double y() const
#define DBL_MIN
Definition: templates.hh:75
G4double Bmin() const
double G4double
Definition: G4Types.hh:76
G4ThreeVector norm3D
G4ThreeVector normal
G4ThreeVector surface
static G4GeometryTolerance * GetInstance()
G4ThreeVector radial
G4PolyPhiFaceEdge * edges

Here is the call graph for this function:

G4PolyPhiFace::~G4PolyPhiFace ( )
virtual

Definition at line 301 of file G4PolyPhiFace.cc.

302 {
303  delete [] edges;
304  delete [] corners;
305 }
G4PolyPhiFaceVertex * corners
G4PolyPhiFaceEdge * edges
G4PolyPhiFace::G4PolyPhiFace ( const G4PolyPhiFace source)

Definition at line 311 of file G4PolyPhiFace.cc.

312  : G4VCSGface()
313 {
314  CopyStuff( source );
315 }
void CopyStuff(const G4PolyPhiFace &source)

Here is the call graph for this function:

G4PolyPhiFace::G4PolyPhiFace ( __void__ &  )

Definition at line 291 of file G4PolyPhiFace.cc.

292  : numEdges(0), edges(0), corners(0), rMin(0.), rMax(0.), zMin(0.), zMax(0.),
293  allBehind(false), kCarTolerance(0.), fSurfaceArea(0.), triangles(0)
294 {
295 }
G4double kCarTolerance
G4PolyPhiFaceVertex * corners
G4double fSurfaceArea
G4PolyPhiFaceVertex * triangles
G4PolyPhiFaceEdge * edges

Member Function Documentation

G4double G4PolyPhiFace::Area2 ( G4TwoVector  a,
G4TwoVector  b,
G4TwoVector  c 
)
protected

Definition at line 960 of file G4PolyPhiFace.cc.

963 {
964  return ((b.x()-a.x())*(c.y()-a.y())-
965  (c.x()-a.x())*(b.y()-a.y()));
966 }
double y() const
double x() const

Here is the call graph for this function:

Here is the caller graph for this function:

G4bool G4PolyPhiFace::Between ( G4TwoVector  a,
G4TwoVector  b,
G4TwoVector  c 
)
protected

Definition at line 1018 of file G4PolyPhiFace.cc.

1019 {
1020  if( !Collinear(a,b,c) ) { return false; }
1021 
1022  if(a.x()!=b.x())
1023  {
1024  return ((a.x()<=c.x())&&(c.x()<=b.x()))||
1025  ((a.x()>=c.x())&&(c.x()>=b.x()));
1026  }
1027  else
1028  {
1029  return ((a.y()<=c.y())&&(c.y()<=b.y()))||
1030  ((a.y()>=c.y())&&(c.y()>=b.y()));
1031  }
1032 }
double y() const
double x() const
G4bool Collinear(G4TwoVector a, G4TwoVector b, G4TwoVector c)

Here is the call graph for this function:

Here is the caller graph for this function:

void G4PolyPhiFace::CalculateExtent ( const EAxis  axis,
const G4VoxelLimits voxelLimit,
const G4AffineTransform tranform,
G4SolidExtentList extentList 
)
virtual

Implements G4VCSGface.

Definition at line 628 of file G4PolyPhiFace.cc.

632 {
633  //
634  // Construct a (sometimes big) clippable polygon,
635  //
636  // Perform the necessary transformations while doing so
637  //
638  G4ClippablePolygon polygon;
639 
640  G4PolyPhiFaceVertex *corner = corners;
641  do // Loop checking, 13.08.2015, G.Cosmo
642  {
643  G4ThreeVector point( 0, 0, corner->z );
644  point += radial*corner->r;
645 
646  polygon.AddVertexInOrder( transform.TransformPoint( point ) );
647  } while( ++corner < corners + numEdges );
648 
649  //
650  // Clip away
651  //
652  if (polygon.PartialClip( voxelLimit, axis ))
653  {
654  //
655  // Add it to the list
656  //
657  polygon.SetNormal( transform.TransformAxis(normal) );
658  extentList.AddSurface( polygon );
659  }
660 }
void SetNormal(const G4ThreeVector &newNormal)
virtual G4bool PartialClip(const G4VoxelLimits &voxelLimit, const EAxis IgnoreMe)
virtual void AddVertexInOrder(const G4ThreeVector vertex)
void AddSurface(const G4ClippablePolygon &surface)
G4PolyPhiFaceVertex * corners
G4ThreeVector normal
G4ThreeVector radial

Here is the call graph for this function:

G4VCSGface* G4PolyPhiFace::Clone ( )
inlinevirtual

Implements G4VCSGface.

G4bool G4PolyPhiFace::Collinear ( G4TwoVector  a,
G4TwoVector  b,
G4TwoVector  c 
)
protected

Definition at line 991 of file G4PolyPhiFace.cc.

994 {
995  return Area2(a,b,c)==0;
996 }
G4double Area2(G4TwoVector a, G4TwoVector b, G4TwoVector c)

Here is the call graph for this function:

Here is the caller graph for this function:

void G4PolyPhiFace::CopyStuff ( const G4PolyPhiFace source)
protected

Definition at line 337 of file G4PolyPhiFace.cc.

338 {
339  //
340  // The simple stuff
341  //
342  numEdges = source.numEdges;
343  normal = source.normal;
344  radial = source.radial;
345  surface = source.surface;
346  rMin = source.rMin;
347  rMax = source.rMax;
348  zMin = source.zMin;
349  zMax = source.zMax;
350  allBehind = source.allBehind;
351  triangles = 0;
352 
353  kCarTolerance = source.kCarTolerance;
354  fSurfaceArea = source.fSurfaceArea;
355 
356  //
357  // Corner dynamic array
358  //
361  *sourceCorn = source.corners;
362  do // Loop checking, 13.08.2015, G.Cosmo
363  {
364  *corn = *sourceCorn;
365  } while( ++sourceCorn, ++corn < corners+numEdges );
366 
367  //
368  // Edge dynamic array
369  //
371 
373  *here = corners;
374  G4PolyPhiFaceEdge *edge = edges,
375  *sourceEdge = source.edges;
376  do // Loop checking, 13.08.2015, G.Cosmo
377  {
378  *edge = *sourceEdge;
379  edge->v0 = prev;
380  edge->v1 = here;
381  } while( ++sourceEdge, ++edge, prev=here, ++here < corners+numEdges );
382 }
G4PolyPhiFaceVertex * v1
G4PolyPhiFaceVertex * v0
G4double kCarTolerance
G4PolyPhiFaceVertex * corners
G4double fSurfaceArea
G4PolyPhiFaceVertex * triangles
G4ThreeVector normal
G4ThreeVector surface
G4ThreeVector radial
G4PolyPhiFaceEdge * edges

Here is the caller graph for this function:

void G4PolyPhiFace::Diagnose ( G4VSolid solid)

Definition at line 272 of file G4PolyPhiFace.cc.

273 {
274  G4PolyPhiFaceVertex *corner = corners;
275  do // Loop checking, 13.08.2015, G.Cosmo
276  {
277  G4ThreeVector test(corner->x, corner->y, corner->z);
278  test -= 1E-6*corner->norm3D;
279 
280  if (owner->Inside(test) != kInside)
281  G4Exception( "G4PolyPhiFace::Diagnose()", "GeomSolids0002",
282  FatalException, "Bad vertex normal found." );
283  } while( ++corner < corners+numEdges );
284 }
G4ThreeVector norm3D
G4PolyPhiFaceVertex * corners
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
program test
Definition: Main_HIJING.f:1

Here is the call graph for this function:

G4bool G4PolyPhiFace::Diagonal ( G4PolyPhiFaceVertex a,
G4PolyPhiFaceVertex b 
)
protected

Definition at line 1118 of file G4PolyPhiFace.cc.

1119 {
1120  return InCone(a,b) && InCone(b,a) && Diagonalie(a,b);
1121 }
G4bool Diagonalie(G4PolyPhiFaceVertex *a, G4PolyPhiFaceVertex *b)
G4bool InCone(G4PolyPhiFaceVertex *a, G4PolyPhiFaceVertex *b)

Here is the call graph for this function:

Here is the caller graph for this function:

G4bool G4PolyPhiFace::Diagonalie ( G4PolyPhiFaceVertex a,
G4PolyPhiFaceVertex b 
)
protected

Definition at line 1057 of file G4PolyPhiFace.cc.

1059 {
1060  G4PolyPhiFaceVertex *corner = triangles;
1061  G4PolyPhiFaceVertex *corner_next=triangles;
1062 
1063  // For each Edge (corner,corner_next)
1064  do // Loop checking, 13.08.2015, G.Cosmo
1065  {
1066  corner_next=corner->next;
1067 
1068  // Skip edges incident to a of b
1069  //
1070  if( (corner!=a)&&(corner_next!=a)
1071  &&(corner!=b)&&(corner_next!=b) )
1072  {
1073  G4TwoVector rz1,rz2,rz3,rz4;
1074  rz1 = G4TwoVector(a->r,a->z);
1075  rz2 = G4TwoVector(b->r,b->z);
1076  rz3 = G4TwoVector(corner->r,corner->z);
1077  rz4 = G4TwoVector(corner_next->r,corner_next->z);
1078  if( Intersect(rz1,rz2,rz3,rz4) ) { return false; }
1079  }
1080  corner=corner->next;
1081 
1082  } while( corner != triangles );
1083 
1084  return true;
1085 }
G4bool Intersect(const G4ThreeVector &p, const G4ThreeVector &v, G4bool outgoing, G4double surfTolerance, G4double &distance, G4double &distFromSurface, G4ThreeVector &normal, G4bool &allBehind)
G4PolyPhiFaceVertex * next
G4PolyPhiFaceVertex * triangles
CLHEP::Hep2Vector G4TwoVector
Definition: G4TwoVector.hh:42

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4PolyPhiFace::Distance ( const G4ThreeVector p,
G4bool  outgoing 
)
virtual

Implements G4VCSGface.

Definition at line 445 of file G4PolyPhiFace.cc.

446 {
447  G4double normSign = outgoing ? +1 : -1;
448  //
449  // Correct normal?
450  //
451  G4ThreeVector ps = p - surface;
452  G4double distPhi = -normSign*normal.dot(ps);
453 
454  if (distPhi < -0.5*kCarTolerance)
455  return kInfinity;
456  else if (distPhi < 0)
457  distPhi = 0.0;
458 
459  //
460  // Calculate projected point in r,z
461  //
462  G4double r = radial.dot(p);
463 
464  //
465  // Are we inside the face?
466  //
467  G4double distRZ2;
468 
469  if (InsideEdges( r, p.z(), &distRZ2, 0 ))
470  {
471  //
472  // Yup, answer is just distPhi
473  //
474  return distPhi;
475  }
476  else
477  {
478  //
479  // Nope. Penalize by distance out
480  //
481  return std::sqrt( distPhi*distPhi + distRZ2 );
482  }
483 }
static const G4double kInfinity
Definition: geomdefs.hh:42
double dot(const Hep3Vector &) const
G4double kCarTolerance
G4bool InsideEdges(G4double r, G4double z)
double z() const
double G4double
Definition: G4Types.hh:76
static constexpr double ps
Definition: G4SIunits.hh:172
G4ThreeVector normal
G4ThreeVector surface
G4ThreeVector radial

Here is the call graph for this function:

void G4PolyPhiFace::EarInit ( )
protected

Definition at line 1127 of file G4PolyPhiFace.cc.

1128 {
1129  G4PolyPhiFaceVertex *corner = triangles;
1130  G4PolyPhiFaceVertex *c_prev,*c_next;
1131 
1132  do // Loop checking, 13.08.2015, G.Cosmo
1133  {
1134  // We need to determine three consecutive vertices
1135  //
1136  c_next=corner->next;
1137  c_prev=corner->prev;
1138 
1139  // Calculation of ears
1140  //
1141  corner->ear=Diagonal(c_prev,c_next);
1142  corner=corner->next;
1143 
1144  } while( corner!=triangles );
1145 }
G4PolyPhiFaceVertex * next
G4PolyPhiFaceVertex * prev
G4PolyPhiFaceVertex * triangles
G4bool Diagonal(G4PolyPhiFaceVertex *a, G4PolyPhiFaceVertex *b)

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4PolyPhiFace::ExactZOrder ( G4double  z,
G4double  qx,
G4double  qy,
G4double  qz,
const G4ThreeVector v,
G4double  normSign,
const G4PolyPhiFaceVertex vert 
) const
inlineprotected

Here is the caller graph for this function:

G4double G4PolyPhiFace::Extent ( const G4ThreeVector  axis)
virtual

Implements G4VCSGface.

Definition at line 606 of file G4PolyPhiFace.cc.

607 {
609 
610  G4PolyPhiFaceVertex *corner = corners;
611  do // Loop checking, 13.08.2015, G.Cosmo
612  {
613  G4double here = axis.x()*corner->r*radial.x()
614  + axis.y()*corner->r*radial.y()
615  + axis.z()*corner->z;
616  if (here > max) max = here;
617  } while( ++corner < corners + numEdges );
618 
619  return max;
620 }
static const G4double kInfinity
Definition: geomdefs.hh:42
double x() const
double z() const
G4PolyPhiFaceVertex * corners
T max(const T t1, const T t2)
brief Return the largest of the two arguments
double y() const
double G4double
Definition: G4Types.hh:76
G4ThreeVector radial

Here is the call graph for this function:

G4ThreeVector G4PolyPhiFace::GetPointOnFace ( )
virtual

Implements G4VCSGface.

Definition at line 947 of file G4PolyPhiFace.cc.

948 {
949  Triangulate();
950  return surface_point;
951 }
G4ThreeVector surface_point

Here is the call graph for this function:

G4bool G4PolyPhiFace::InCone ( G4PolyPhiFaceVertex a,
G4PolyPhiFaceVertex b 
)
protected

Definition at line 1091 of file G4PolyPhiFace.cc.

1092 {
1093  // a0,a and a1 are consecutive vertices
1094  //
1095  G4PolyPhiFaceVertex *a0,*a1;
1096  a1=a->next;
1097  a0=a->prev;
1098 
1099  G4TwoVector arz,arz0,arz1,brz;
1100  arz=G4TwoVector(a->r,a->z);arz0=G4TwoVector(a0->r,a0->z);
1101  arz1=G4TwoVector(a1->r,a1->z);brz=G4TwoVector(b->r,b->z);
1102 
1103 
1104  if(LeftOn(arz,arz1,arz0)) // If a is convex vertex
1105  {
1106  return Left(arz,brz,arz0)&&Left(brz,arz,arz1);
1107  }
1108  else // Else a is reflex
1109  {
1110  return !( LeftOn(arz,brz,arz1)&&LeftOn(brz,arz,arz0));
1111  }
1112 }
const G4double a0
G4bool LeftOn(G4TwoVector a, G4TwoVector b, G4TwoVector c)
G4PolyPhiFaceVertex * next
G4PolyPhiFaceVertex * prev
CLHEP::Hep2Vector G4TwoVector
Definition: G4TwoVector.hh:42
G4bool Left(G4TwoVector a, G4TwoVector b, G4TwoVector c)

Here is the call graph for this function:

Here is the caller graph for this function:

EInside G4PolyPhiFace::Inside ( const G4ThreeVector p,
G4double  tolerance,
G4double bestDistance 
)
virtual

Implements G4VCSGface.

Definition at line 489 of file G4PolyPhiFace.cc.

492 {
493  //
494  // Get distance along phi, which if negative means the point
495  // is nominally inside the shape.
496  //
497  G4ThreeVector ps = p - surface;
498  G4double distPhi = normal.dot(ps);
499 
500  //
501  // Calculate projected point in r,z
502  //
503  G4double r = radial.dot(p);
504 
505  //
506  // Are we inside the face?
507  //
508  G4double distRZ2;
509  G4PolyPhiFaceVertex *base3Dnorm=0;
510  G4ThreeVector *head3Dnorm=0;
511 
512  if (InsideEdges( r, p.z(), &distRZ2, &base3Dnorm, &head3Dnorm ))
513  {
514  //
515  // Looks like we're inside. Distance is distance in phi.
516  //
517  *bestDistance = std::fabs(distPhi);
518 
519  //
520  // Use distPhi to decide fate
521  //
522  if (distPhi < -tolerance) return kInside;
523  if (distPhi < tolerance) return kSurface;
524  return kOutside;
525  }
526  else
527  {
528  //
529  // We're outside the extent of the face,
530  // so the distance is penalized by distance from edges in RZ
531  //
532  *bestDistance = std::sqrt( distPhi*distPhi + distRZ2 );
533 
534  //
535  // Use edge normal to decide fate
536  //
537  G4ThreeVector cc( base3Dnorm->r*radial.x(),
538  base3Dnorm->r*radial.y(),
539  base3Dnorm->z );
540  cc = p - cc;
541  G4double normDist = head3Dnorm->dot(cc);
542  if ( distRZ2 > tolerance*tolerance )
543  {
544  //
545  // We're far enough away that kSurface is not possible
546  //
547  return normDist < 0 ? kInside : kOutside;
548  }
549 
550  if (normDist < -tolerance) return kInside;
551  if (normDist < tolerance) return kSurface;
552  return kOutside;
553  }
554 }
double x() const
double dot(const Hep3Vector &) const
G4bool InsideEdges(G4double r, G4double z)
double z() const
double y() const
double G4double
Definition: G4Types.hh:76
static constexpr double ps
Definition: G4SIunits.hh:172
G4ThreeVector normal
G4ThreeVector surface
G4ThreeVector radial

Here is the call graph for this function:

G4bool G4PolyPhiFace::InsideEdges ( G4double  r,
G4double  z 
)
protected

Definition at line 816 of file G4PolyPhiFace.cc.

817 {
818  //
819  // Quick check of extent
820  //
821  if ( r < rMin || r > rMax ) return false;
822  if ( z < zMin || z > zMax ) return false;
823 
824  //
825  // More thorough check
826  //
827  G4double notUsed;
828 
829  return InsideEdges( r, z, &notUsed, 0 );
830 }
G4bool InsideEdges(G4double r, G4double z)
tuple z
Definition: test.py:28
double G4double
Definition: G4Types.hh:76

Here is the caller graph for this function:

G4bool G4PolyPhiFace::InsideEdges ( G4double  r,
G4double  z,
G4double distRZ2,
G4PolyPhiFaceVertex **  base3Dnorm = 0,
G4ThreeVector **  head3Dnorm = 0 
)
protected

Definition at line 838 of file G4PolyPhiFace.cc.

842 {
843  G4double bestDistance2 = kInfinity;
844  G4bool answer = 0;
845 
846  G4PolyPhiFaceEdge *edge = edges;
847  do // Loop checking, 13.08.2015, G.Cosmo
848  {
849  G4PolyPhiFaceVertex *testMe;
850  //
851  // Get distance perpendicular to the edge
852  //
853  G4double dr = (r-edge->v0->r), dz = (z-edge->v0->z);
854 
855  G4double distOut = dr*edge->tz - dz*edge->tr;
856  G4double distance2 = distOut*distOut;
857  if (distance2 > bestDistance2) continue; // No hope!
858 
859  //
860  // Check to see if normal intersects edge within the edge's boundary
861  //
862  G4double q = dr*edge->tr + dz*edge->tz;
863 
864  //
865  // If it doesn't, penalize distance2 appropriately
866  //
867  if (q < 0)
868  {
869  distance2 += q*q;
870  testMe = edge->v0;
871  }
872  else if (q > edge->length)
873  {
874  G4double s2 = q-edge->length;
875  distance2 += s2*s2;
876  testMe = edge->v1;
877  }
878  else
879  {
880  testMe = 0;
881  }
882 
883  //
884  // Closest edge so far?
885  //
886  if (distance2 < bestDistance2)
887  {
888  bestDistance2 = distance2;
889  if (testMe)
890  {
891  G4double distNorm = dr*testMe->rNorm + dz*testMe->zNorm;
892  answer = (distNorm <= 0);
893  if (base3Dnorm)
894  {
895  *base3Dnorm = testMe;
896  *head3Dnorm = &testMe->norm3D;
897  }
898  }
899  else
900  {
901  answer = (distOut <= 0);
902  if (base3Dnorm)
903  {
904  *base3Dnorm = edge->v0;
905  *head3Dnorm = &edge->norm3D;
906  }
907  }
908  }
909  } while( ++edge < edges + numEdges );
910 
911  *bestDist2 = bestDistance2;
912  return answer;
913 }
static const G4double kInfinity
Definition: geomdefs.hh:42
G4PolyPhiFaceVertex * v1
G4PolyPhiFaceVertex * v0
G4ThreeVector norm3D
bool G4bool
Definition: G4Types.hh:79
tuple z
Definition: test.py:28
double G4double
Definition: G4Types.hh:76
G4ThreeVector norm3D
G4PolyPhiFaceEdge * edges
G4bool G4PolyPhiFace::InsideEdgesExact ( G4double  r,
G4double  z,
G4double  normSign,
const G4ThreeVector p,
const G4ThreeVector v 
)
protected

Definition at line 683 of file G4PolyPhiFace.cc.

687 {
688  //
689  // Quick check of extent
690  //
691  if ( (r < rMin-kCarTolerance)
692  || (r > rMax+kCarTolerance) ) return false;
693 
694  if ( (z < zMin-kCarTolerance)
695  || (z > zMax+kCarTolerance) ) return false;
696 
697  //
698  // Exact check: loop over all vertices
699  //
700  G4double qx = p.x() + v.x(),
701  qy = p.y() + v.y(),
702  qz = p.z() + v.z();
703 
704  G4int answer = 0;
705  G4PolyPhiFaceVertex *corn = corners,
706  *prev = corners+numEdges-1;
707 
708  G4double cornZ, prevZ;
709 
710  prevZ = ExactZOrder( z, qx, qy, qz, v, normSign, prev );
711  do // Loop checking, 13.08.2015, G.Cosmo
712  {
713  //
714  // Get z order of this vertex, and compare to previous vertex
715  //
716  cornZ = ExactZOrder( z, qx, qy, qz, v, normSign, corn );
717 
718  if (cornZ < 0)
719  {
720  if (prevZ < 0) continue;
721  }
722  else if (cornZ > 0)
723  {
724  if (prevZ > 0) continue;
725  }
726  else
727  {
728  //
729  // By chance, we overlap exactly (within precision) with
730  // the current vertex. Continue if the same happened previously
731  // (e.g. the previous vertex had the same z value)
732  //
733  if (prevZ == 0) continue;
734 
735  //
736  // Otherwise, to decide what to do, we need to know what is
737  // coming up next. Specifically, we need to find the next vertex
738  // with a non-zero z order.
739  //
740  // One might worry about infinite loops, but the above conditional
741  // should prevent it
742  //
743  G4PolyPhiFaceVertex *next = corn;
744  G4double nextZ;
745  do // Loop checking, 13.08.2015, G.Cosmo
746  {
747  next++;
748  if (next == corners+numEdges) next = corners;
749 
750  nextZ = ExactZOrder( z, qx, qy, qz, v, normSign, next );
751  } while( nextZ == 0 );
752 
753  //
754  // If we won't be changing direction, go to the next vertex
755  //
756  if (nextZ*prevZ < 0) continue;
757  }
758 
759 
760  //
761  // We overlap in z with the side of the face that stretches from
762  // vertex "prev" to "corn". On which side (left or right) do
763  // we lay with respect to this segment?
764  //
765  G4ThreeVector qa( qx - prev->x, qy - prev->y, qz - prev->z ),
766  qb( qx - corn->x, qy - corn->y, qz - corn->z );
767 
768  G4double aboveOrBelow = normSign*qa.cross(qb).dot(v);
769 
770  if (aboveOrBelow > 0)
771  answer++;
772  else if (aboveOrBelow < 0)
773  answer--;
774  else
775  {
776  //
777  // A precisely zero answer here means we exactly
778  // intersect (within roundoff) the edge of the face.
779  // Return true in this case.
780  //
781  return true;
782  }
783  } while( prevZ = cornZ, prev=corn, ++corn < corners+numEdges );
784 
785  return answer!=0;
786 }
G4double ExactZOrder(G4double z, G4double qx, G4double qy, G4double qz, const G4ThreeVector &v, G4double normSign, const G4PolyPhiFaceVertex *vert) const
double x() const
G4double kCarTolerance
int G4int
Definition: G4Types.hh:78
double z() const
G4PolyPhiFaceVertex * corners
double y() const
tuple z
Definition: test.py:28
double G4double
Definition: G4Types.hh:76

Here is the call graph for this function:

Here is the caller graph for this function:

G4bool G4PolyPhiFace::Intersect ( const G4ThreeVector p,
const G4ThreeVector v,
G4bool  outgoing,
G4double  surfTolerance,
G4double distance,
G4double distFromSurface,
G4ThreeVector normal,
G4bool allBehind 
)
virtual

Implements G4VCSGface.

Definition at line 388 of file G4PolyPhiFace.cc.

396 {
397  G4double normSign = outgoing ? +1 : -1;
398 
399  //
400  // These don't change
401  //
402  isAllBehind = allBehind;
403  aNormal = normal;
404 
405  //
406  // Correct normal? Here we have straight sides, and can safely ignore
407  // intersections where the dot product with the normal is zero.
408  //
409  G4double dotProd = normSign*normal.dot(v);
410 
411  if (dotProd <= 0) return false;
412 
413  //
414  // Calculate distance to surface. If the side is too far
415  // behind the point, we must reject it.
416  //
417  G4ThreeVector ps = p - surface;
418  distFromSurface = -normSign*ps.dot(normal);
419 
420  if (distFromSurface < -surfTolerance) return false;
421 
422  //
423  // Calculate precise distance to intersection with the side
424  // (along the trajectory, not normal to the surface)
425  //
426  distance = distFromSurface/dotProd;
427 
428  //
429  // Calculate intersection point in r,z
430  //
431  G4ThreeVector ip = p + distance*v;
432 
433  G4double r = radial.dot(ip);
434 
435  //
436  // And is it inside the r/z extent?
437  //
438  return InsideEdgesExact( r, ip.z(), normSign, p, v );
439 }
G4bool InsideEdgesExact(G4double r, G4double z, G4double normSign, const G4ThreeVector &p, const G4ThreeVector &v)
double dot(const Hep3Vector &) const
const char * p
Definition: xmltok.h:285
double z() const
tuple v
Definition: test.py:18
double G4double
Definition: G4Types.hh:76
static constexpr double ps
Definition: G4SIunits.hh:172
G4ThreeVector normal
G4ThreeVector surface
G4ThreeVector radial

Here is the call graph for this function:

Here is the caller graph for this function:

G4bool G4PolyPhiFace::Intersect ( G4TwoVector  a,
G4TwoVector  b,
G4TwoVector  c,
G4TwoVector  d 
)
protected

Definition at line 1038 of file G4PolyPhiFace.cc.

1041 {
1042  if( IntersectProp(a,b,c,d) )
1043  { return true; }
1044  else if( Between(a,b,c)||
1045  Between(a,b,d)||
1046  Between(c,d,a)||
1047  Between(c,d,b) )
1048  { return true; }
1049  else
1050  { return false; }
1051 }
G4bool Between(G4TwoVector a, G4TwoVector b, G4TwoVector c)
G4bool IntersectProp(G4TwoVector a, G4TwoVector b, G4TwoVector c, G4TwoVector d)

Here is the call graph for this function:

G4bool G4PolyPhiFace::IntersectProp ( G4TwoVector  a,
G4TwoVector  b,
G4TwoVector  c,
G4TwoVector  d 
)
protected

Definition at line 1002 of file G4PolyPhiFace.cc.

1005 {
1006  if( Collinear(a,b,c) || Collinear(a,b,d)||
1007  Collinear(c,d,a) || Collinear(c,d,b) ) { return false; }
1008 
1009  G4bool Positive;
1010  Positive = !(Left(a,b,c))^!(Left(a,b,d));
1011  return Positive && (!Left(c,d,a)^!Left(c,d,b));
1012 }
bool G4bool
Definition: G4Types.hh:79
G4bool Collinear(G4TwoVector a, G4TwoVector b, G4TwoVector c)
G4bool Left(G4TwoVector a, G4TwoVector b, G4TwoVector c)

Here is the call graph for this function:

Here is the caller graph for this function:

G4bool G4PolyPhiFace::Left ( G4TwoVector  a,
G4TwoVector  b,
G4TwoVector  c 
)
protected

Definition at line 971 of file G4PolyPhiFace.cc.

974 {
975  return Area2(a,b,c)>0;
976 }
G4double Area2(G4TwoVector a, G4TwoVector b, G4TwoVector c)

Here is the call graph for this function:

Here is the caller graph for this function:

G4bool G4PolyPhiFace::LeftOn ( G4TwoVector  a,
G4TwoVector  b,
G4TwoVector  c 
)
protected

Definition at line 981 of file G4PolyPhiFace.cc.

984 {
985  return Area2(a,b,c)>=0;
986 }
G4double Area2(G4TwoVector a, G4TwoVector b, G4TwoVector c)

Here is the call graph for this function:

Here is the caller graph for this function:

G4ThreeVector G4PolyPhiFace::Normal ( const G4ThreeVector p,
G4double bestDistance 
)
virtual

Implements G4VCSGface.

Definition at line 563 of file G4PolyPhiFace.cc.

565 {
566  //
567  // Get distance along phi, which if negative means the point
568  // is nominally inside the shape.
569  //
570  G4double distPhi = normal.dot(p);
571 
572  //
573  // Calculate projected point in r,z
574  //
575  G4double r = radial.dot(p);
576 
577  //
578  // Are we inside the face?
579  //
580  G4double distRZ2;
581 
582  if (InsideEdges( r, p.z(), &distRZ2, 0 ))
583  {
584  //
585  // Yup, answer is just distPhi
586  //
587  *bestDistance = std::fabs(distPhi);
588  }
589  else
590  {
591  //
592  // Nope. Penalize by distance out
593  //
594  *bestDistance = std::sqrt( distPhi*distPhi + distRZ2 );
595  }
596 
597  return normal;
598 }
double dot(const Hep3Vector &) const
G4bool InsideEdges(G4double r, G4double z)
double z() const
double G4double
Definition: G4Types.hh:76
G4ThreeVector normal
G4ThreeVector radial

Here is the call graph for this function:

G4PolyPhiFace & G4PolyPhiFace::operator= ( const G4PolyPhiFace source)

Definition at line 321 of file G4PolyPhiFace.cc.

322 {
323  if (this == &source) { return *this; }
324 
325  delete [] edges;
326  delete [] corners;
327 
328  CopyStuff( source );
329 
330  return *this;
331 }
G4PolyPhiFaceVertex * corners
void CopyStuff(const G4PolyPhiFace &source)
G4PolyPhiFaceEdge * edges

Here is the call graph for this function:

G4double G4PolyPhiFace::SurfaceArea ( )
virtual

Implements G4VCSGface.

Definition at line 938 of file G4PolyPhiFace.cc.

939 {
940  if ( fSurfaceArea==0. ) { Triangulate(); }
941  return fSurfaceArea;
942 }
G4double fSurfaceArea

Here is the call graph for this function:

G4double G4PolyPhiFace::SurfaceTriangle ( G4ThreeVector  p1,
G4ThreeVector  p2,
G4ThreeVector  p3,
G4ThreeVector p4 
)

Definition at line 919 of file G4PolyPhiFace.cc.

923 {
924  G4ThreeVector v, w;
925 
926  v = p3 - p1;
927  w = p1 - p2;
928  G4double lambda1 = G4UniformRand();
929  G4double lambda2 = lambda1*G4UniformRand();
930 
931  *p4=p2 + lambda1*w + lambda2*v;
932  return 0.5*(v.cross(w)).mag();
933 }
#define G4UniformRand()
Definition: Randomize.hh:97
tuple v
Definition: test.py:18
double G4double
Definition: G4Types.hh:76

Here is the caller graph for this function:

void G4PolyPhiFace::Triangulate ( )
protected

Definition at line 1151 of file G4PolyPhiFace.cc.

1152 {
1153  // The copy of Polycone is made and this copy is reordered in order to
1154  // have a list of triangles. This list is used for GetPointOnFace().
1155 
1157  triangles = tri_help;
1158  G4PolyPhiFaceVertex *triang = triangles;
1159 
1160  std::vector<G4double> areas;
1161  std::vector<G4ThreeVector> points;
1162  G4double area=0.;
1163  G4PolyPhiFaceVertex *v0,*v1,*v2,*v3,*v4;
1164  v2=triangles;
1165 
1166  // Make copy for prev/next for triang=corners
1167  //
1168  G4PolyPhiFaceVertex *helper = corners;
1169  G4PolyPhiFaceVertex *helper2 = corners;
1170  do // Loop checking, 13.08.2015, G.Cosmo
1171  {
1172  triang->r = helper->r;
1173  triang->z = helper->z;
1174  triang->x = helper->x;
1175  triang->y= helper->y;
1176 
1177  // add pointer on prev corner
1178  //
1179  if( helper==corners )
1180  { triang->prev=triangles+numEdges-1; }
1181  else
1182  { triang->prev=helper2; }
1183 
1184  // add pointer on next corner
1185  //
1186  if( helper<corners+numEdges-1 )
1187  { triang->next=triang+1; }
1188  else
1189  { triang->next=triangles; }
1190  helper2=triang;
1191  helper=helper->next;
1192  triang=triang->next;
1193 
1194  } while( helper!=corners );
1195 
1196  EarInit();
1197 
1198  G4int n=numEdges;
1199  G4int i=0;
1200  G4ThreeVector p1,p2,p3,p4;
1201  const G4int max_n_loops=numEdges*10000; // protection against infinite loop
1202 
1203  // Each step of outer loop removes one ear
1204  //
1205  while(n>3) // Loop checking, 13.08.2015, G.Cosmo
1206  { // Inner loop searches for one ear
1207  v2=triangles;
1208  do // Loop checking, 13.08.2015, G.Cosmo
1209  {
1210  if(v2->ear) // Ear found. Fill variables
1211  {
1212  // (v1,v3) is diagonal
1213  //
1214  v3=v2->next; v4=v3->next;
1215  v1=v2->prev; v0=v1->prev;
1216 
1217  // Calculate areas and points
1218 
1219  p1=G4ThreeVector((v2)->x,(v2)->y,(v2)->z);
1220  p2=G4ThreeVector((v1)->x,(v1)->y,(v1)->z);
1221  p3=G4ThreeVector((v3)->x,(v3)->y,(v3)->z);
1222 
1223  G4double result1 = SurfaceTriangle(p1,p2,p3,&p4 );
1224  points.push_back(p4);
1225  areas.push_back(result1);
1226  area=area+result1;
1227 
1228  // Update earity of diagonal endpoints
1229  //
1230  v1->ear=Diagonal(v0,v3);
1231  v3->ear=Diagonal(v1,v4);
1232 
1233  // Cut off the ear v2
1234  // Has to be done for a copy and not for real PolyPhiFace
1235  //
1236  v1->next=v3;
1237  v3->prev=v1;
1238  triangles=v3; // In case the head was v2
1239  n--;
1240 
1241  break; // out of inner loop
1242  } // end if ear found
1243 
1244  v2=v2->next;
1245 
1246  } while( v2!=triangles );
1247 
1248  i++;
1249  if(i>=max_n_loops)
1250  {
1251  G4Exception( "G4PolyPhiFace::Triangulation()",
1252  "GeomSolids0003", FatalException,
1253  "Maximum number of steps is reached for triangulation!" );
1254  }
1255  } // end outer while loop
1256 
1257  if(v2->next)
1258  {
1259  // add last triangle
1260  //
1261  v2=v2->next;
1262  p1=G4ThreeVector((v2)->x,(v2)->y,(v2)->z);
1263  p2=G4ThreeVector((v2->next)->x,(v2->next)->y,(v2->next)->z);
1264  p3=G4ThreeVector((v2->prev)->x,(v2->prev)->y,(v2->prev)->z);
1265  G4double result1 = SurfaceTriangle(p1,p2,p3,&p4 );
1266  points.push_back(p4);
1267  areas.push_back(result1);
1268  area=area+result1;
1269  }
1270 
1271  // Surface Area is stored
1272  //
1273  fSurfaceArea = area;
1274 
1275  // Second Step: choose randomly one surface
1276  //
1277  G4double chose = area*G4UniformRand();
1278 
1279  // Third Step: Get a point on choosen surface
1280  //
1281  G4double Achose1, Achose2;
1282  Achose1=0; Achose2=0.;
1283  i=0;
1284  do // Loop checking, 13.08.2015, G.Cosmo
1285  {
1286  Achose2+=areas[i];
1287  if(chose>=Achose1 && chose<Achose2)
1288  {
1289  G4ThreeVector point;
1290  point=points[i] ;
1291  surface_point=point;
1292  break;
1293  }
1294  i++; Achose1=Achose2;
1295  } while( i<numEdges-2 );
1296 
1297  delete [] tri_help;
1298  tri_help = 0;
1299 }
G4ThreeVector surface_point
CLHEP::Hep3Vector G4ThreeVector
tuple x
Definition: test.py:50
int G4int
Definition: G4Types.hh:78
#define G4UniformRand()
Definition: Randomize.hh:97
G4double SurfaceTriangle(G4ThreeVector p1, G4ThreeVector p2, G4ThreeVector p3, G4ThreeVector *p4)
G4PolyPhiFaceVertex * next
G4PolyPhiFaceVertex * prev
const G4int n
G4PolyPhiFaceVertex * corners
G4double fSurfaceArea
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
G4PolyPhiFaceVertex * triangles
G4bool Diagonal(G4PolyPhiFaceVertex *a, G4PolyPhiFaceVertex *b)
tuple z
Definition: test.py:28
double G4double
Definition: G4Types.hh:76

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

G4bool G4PolyPhiFace::allBehind
protected

Definition at line 231 of file G4PolyPhiFace.hh.

G4PolyPhiFaceVertex* G4PolyPhiFace::corners
protected

Definition at line 223 of file G4PolyPhiFace.hh.

G4PolyPhiFaceEdge* G4PolyPhiFace::edges
protected

Definition at line 222 of file G4PolyPhiFace.hh.

G4double G4PolyPhiFace::fSurfaceArea
protected

Definition at line 234 of file G4PolyPhiFace.hh.

G4double G4PolyPhiFace::kCarTolerance
protected

Definition at line 233 of file G4PolyPhiFace.hh.

G4ThreeVector G4PolyPhiFace::normal
protected

Definition at line 224 of file G4PolyPhiFace.hh.

G4int G4PolyPhiFace::numEdges
protected

Definition at line 221 of file G4PolyPhiFace.hh.

G4ThreeVector G4PolyPhiFace::radial
protected

Definition at line 225 of file G4PolyPhiFace.hh.

G4double G4PolyPhiFace::rMax
protected

Definition at line 229 of file G4PolyPhiFace.hh.

G4double G4PolyPhiFace::rMin
protected

Definition at line 229 of file G4PolyPhiFace.hh.

G4ThreeVector G4PolyPhiFace::surface
protected

Definition at line 226 of file G4PolyPhiFace.hh.

G4ThreeVector G4PolyPhiFace::surface_point
protected

Definition at line 227 of file G4PolyPhiFace.hh.

G4PolyPhiFaceVertex* G4PolyPhiFace::triangles
protected

Definition at line 235 of file G4PolyPhiFace.hh.

G4double G4PolyPhiFace::zMax
protected

Definition at line 229 of file G4PolyPhiFace.hh.

G4double G4PolyPhiFace::zMin
protected

Definition at line 229 of file G4PolyPhiFace.hh.


The documentation for this class was generated from the following files: