#include <UPolyconeSide.hh>

Inheritance diagram for UPolyconeSide:

Public Member Functions
	UPolyconeSide (const UPolyconeSideRZ prevRZ, const UPolyconeSideRZ tail, const UPolyconeSideRZ head, const UPolyconeSideRZ nextRZ, double phiStart, double deltaPhi, bool phiIsOpen, bool isAllBehind=false)

virtual	~UPolyconeSide ()

	UPolyconeSide (const UPolyconeSide &source)

UPolyconeSide &	operator= (const UPolyconeSide &source)

bool	Distance (const UVector3 &p, const UVector3 &v, bool outgoing, double surfTolerance, double &distance, double &distFromSurface, UVector3 &normal, bool &isAllBehind)

double	Safety (const UVector3 &p, bool outgoing)

VUSolid::EnumInside	Inside (const UVector3 &p, double tolerance, double *bestDistance)

UVector3	Normal (const UVector3 &p, double *bestDistance)

double	Extent (const UVector3 axis)

UVCSGface *	Clone ()

double	SurfaceArea ()

UVector3	GetPointOnFace ()

	UPolyconeSide (__void__ &)

Public Member Functions inherited from UVCSGface
	UVCSGface ()

virtual	~UVCSGface ()

Protected Member Functions
double	DistanceAway (const UVector3 &p, bool opposite, double &distOutside2, double *rzNorm=0)

bool	PointOnCone (const UVector3 &hit, double normSign, const UVector3 &p, const UVector3 &v, UVector3 &normal)

void	CopyStuff (const UPolyconeSide &source)

double	GetPhi (const UVector3 &p)

Static Protected Member Functions
static void	FindLineIntersect (double x1, double y1, double tx1, double ty1, double x2, double y2, double tx2, double ty2, double &x, double &y)

Protected Attributes
double	r [2]

double	z [2]

double	startPhi

double	deltaPhi

bool	phiIsOpen

bool	allBehind

UIntersectingCone *	cone

double	rNorm

double	zNorm

double	rS

double	zS

double	length

double	prevRS

double	prevZS

double	nextRS

double	nextZS

double	rNormEdge [2]

double	zNormEdge [2]

int	ncorners

UVector3 *	corners

Detailed Description

Definition at line 56 of file UPolyconeSide.hh.

Constructor & Destructor Documentation

UPolyconeSide::UPolyconeSide	(	const UPolyconeSideRZ *	prevRZ,
		const UPolyconeSideRZ *	tail,
		const UPolyconeSideRZ *	head,
		const UPolyconeSideRZ *	nextRZ,
		double	phiStart,
		double	deltaPhi,
		bool	phiIsOpen,
		bool	isAllBehind = `false`
	)

Definition at line 31 of file UPolyconeSide.cc.

References allBehind, cone, corners, deltaPhi, length, ncorners, nextRS, nextZS, phiIsOpen, prevRS, prevZS, UPolyconeSideRZ::r, r, rNorm, rNormEdge, rS, startPhi, VUSolid::Tolerance(), UPolyconeSideRZ::z, z, zNorm, zNormEdge, and zS.

Referenced by Clone().

   : ncorners(0), corners(0)
 {
 
   tolerance = VUSolid::Tolerance();
 
   fSurfaceArea = 0.0;
 
   //
   // Record values
   //
   r[0] = tail->r;
   z[0] = tail->z;
   r[1] = head->r;
   z[1] = head->z;
 
   phiIsOpen = thePhiIsOpen;
   if (phiIsOpen)
   {
     deltaPhi = theDeltaPhi;
     startPhi = thePhiStart;
 
     //
     // Set phi values to our conventions
     //
     while (deltaPhi < 0.0) deltaPhi += 2 * UUtils::kPi;
     while (startPhi < 0.0) startPhi += 2 * UUtils::kPi;
 
     //
     // Calculate corner coordinates
     //
     ncorners = 4;
     corners = new UVector3[ncorners];
 
     corners[0] = UVector3(tail->r * std::cos(startPhi),
                           tail->r * std::sin(startPhi), tail->z);
     corners[1] = UVector3(head->r * std::cos(startPhi),
                           head->r * std::sin(startPhi), head->z);
     corners[2] = UVector3(tail->r * std::cos(startPhi + deltaPhi),
                           tail->r * std::sin(startPhi + deltaPhi), tail->z);
     corners[3] = UVector3(head->r * std::cos(startPhi + deltaPhi),
                           head->r * std::sin(startPhi + deltaPhi), head->z);
   }
   else
   {
     deltaPhi = 2 * UUtils::kPi;
     startPhi = 0.0;
   }
 
   allBehind = isAllBehind;
 
   //
   // Make our intersecting cone
   //
   cone = new UIntersectingCone(r, z);
 
   //
   // Calculate vectors in r,z space
   //
   rS = r[1] - r[0];
   zS = z[1] - z[0];
   length = std::sqrt(rS * rS + zS * zS);
   rS /= length;
   zS /= length;
 
   rNorm = +zS;
   zNorm = -rS;
 
   double lAdj;
 
   prevRS = r[0] - prevRZ->r;
   prevZS = z[0] - prevRZ->z;
   lAdj = std::sqrt(prevRS * prevRS + prevZS * prevZS);
   prevRS /= lAdj;
   prevZS /= lAdj;
 
   rNormEdge[0] = rNorm + prevZS;
   zNormEdge[0] = zNorm - prevRS;
   lAdj = std::sqrt(rNormEdge[0] * rNormEdge[0] + zNormEdge[0] * zNormEdge[0]);
   rNormEdge[0] /= lAdj;
   zNormEdge[0] /= lAdj;
 
   nextRS = nextRZ->r - r[1];
   nextZS = nextRZ->z - z[1];
   lAdj = std::sqrt(nextRS * nextRS + nextZS * nextZS);
   nextRS /= lAdj;
   nextZS /= lAdj;
 
   rNormEdge[1] = rNorm + nextZS;
   zNormEdge[1] = zNorm - nextRS;
   lAdj = std::sqrt(rNormEdge[1] * rNormEdge[1] + zNormEdge[1] * zNormEdge[1]);
   rNormEdge[1] /= lAdj;
   zNormEdge[1] /= lAdj;
 }

UPolyconeSide::~UPolyconeSide ( )

virtual

Definition at line 152 of file UPolyconeSide.cc.

References cone, corners, and phiIsOpen.

 {
   delete cone;
   if (phiIsOpen)
   {
     delete [] corners;
   }
 }

UPolyconeSide::UPolyconeSide ( const UPolyconeSide & source )

Definition at line 165 of file UPolyconeSide.cc.

References CopyStuff().

   : UVCSGface(), ncorners(0), corners(0)
 {
 
   CopyStuff(source);
 }

UPolyconeSide::UPolyconeSide ( __void__ & )

Definition at line 137 of file UPolyconeSide.cc.

References r, rNormEdge, z, and zNormEdge.

   : startPhi(0.), deltaPhi(0.), phiIsOpen(false), allBehind(false),
     cone(0), rNorm(0.), zNorm(0.), rS(0.), zS(0.), length(0.),
     prevRS(0.), prevZS(0.), nextRS(0.), nextZS(0.), ncorners(0), corners(0),
     tolerance(0.), fSurfaceArea(0.)
 {
   r[0] = r[1] = 0.;
   z[0] = z[1] = 0.;
   rNormEdge[0] = rNormEdge[1] = 0.;
   zNormEdge[0] = zNormEdge[1] = 0.;
 }

Member Function Documentation

UVCSGface* UPolyconeSide::Clone ( )

inlinevirtual

Implements UVCSGface.

Definition at line 92 of file UPolyconeSide.hh.

References UPolyconeSide().

     {
       return new UPolyconeSide(*this);
     }

void UPolyconeSide::CopyStuff ( const UPolyconeSide & source )

protected

Definition at line 198 of file UPolyconeSide.cc.

References allBehind, cone, corners, deltaPhi, length, ncorners, nextRS, nextZS, phiIsOpen, prevRS, prevZS, r, rNorm, rNormEdge, rS, startPhi, z, zNorm, zNormEdge, and zS.

Referenced by operator=(), and UPolyconeSide().

 {
   r[0]    = source.r[0];
   r[1]    = source.r[1];
   z[0]    = source.z[0];
   z[1]    = source.z[1];
 
   startPhi  = source.startPhi;
   deltaPhi  = source.deltaPhi;
   phiIsOpen = source.phiIsOpen;
   allBehind = source.allBehind;
 
   tolerance = source.tolerance;
   fSurfaceArea = source.fSurfaceArea;
 
   cone    = new UIntersectingCone(*source.cone);
 
   rNorm   = source.rNorm;
   zNorm   = source.zNorm;
   rS    = source.rS;
   zS    = source.zS;
   length    = source.length;
   prevRS    = source.prevRS;
   prevZS    = source.prevZS;
   nextRS    = source.nextRS;
   nextZS    = source.nextZS;
 
   rNormEdge[0]   = source.rNormEdge[0];
   rNormEdge[1]  = source.rNormEdge[1];
   zNormEdge[0]  = source.zNormEdge[0];
   zNormEdge[1]  = source.zNormEdge[1];
 
   if (phiIsOpen)
   {
     ncorners = 4;
     corners = new UVector3[ncorners];
 
     corners[0] = source.corners[0];
     corners[1] = source.corners[1];
     corners[2] = source.corners[2];
     corners[3] = source.corners[3];
   }
 }

bool UPolyconeSide::Distance	(	const UVector3 &	p,
		const UVector3 &	v,
		bool	outgoing,
		double	surfTolerance,
		double &	distance,
		double &	distFromSurface,
		UVector3 &	normal,
		bool &	isAllBehind
	)

virtual

Implements UVCSGface.

Definition at line 246 of file UPolyconeSide.cc.

References allBehind, cone, DBL_MIN, DistanceAway(), UIntersectingCone::LineHitsCone(), UVector3::Perp(), PointOnCone(), gammaraytel::pr, rNorm, test::v, UVector3::x, UVector3::y, and zNorm.

 {
   double s1, s2;
   double normSign = outgoing ? +1 : -1;
 
   isAllBehind = allBehind;
 
   //
   // Check for two possible intersections
   //
   int nside = cone->LineHitsCone(p, v, s1, s2);
   if (nside == 0) return false;
 
   //
   // Check the first side first, since it is (supposed to be) closest
   //
   UVector3 hit = p + s1 * v;
 
   if (PointOnCone(hit, normSign, p, v, normal))
   {
     //
     // Good intersection! What about the normal?
     //
     if (normSign * v.Dot(normal) > 0)
     {
       //
       // We have a valid intersection, but it could very easily
       // be behind the point. To decide if we tolerate this,
       // we have to see if the point p is on the surface near
       // the intersecting point.
       //
       // What does it mean exactly for the point p to be "near"
       // the intersection? It means that if we draw a line from
       // p to the hit, the line remains entirely within the
       // tolerance bounds of the cone. To test this, we can
       // ask if the normal is correct near p.
       //
       double pr = p.Perp();
       if (pr < DBL_MIN) pr = DBL_MIN;
       UVector3 pNormal(rNorm * p.x / pr, rNorm * p.y / pr, zNorm);
       if (normSign * v.Dot(pNormal) > 0)
       {
         //
         // p and intersection in same hemisphere
         //
         double distOutside2;
         distFromSurface = -normSign * DistanceAway(p, false, distOutside2);
         if (distOutside2 < surfTolerance * surfTolerance)
         {
           if (distFromSurface > -surfTolerance)
           {
             //
             // We are just inside or away from the
             // surface. Accept *any* value of distance.
             //
             distance = s1;
             return true;
           }
         }
       }
       else
         distFromSurface = s1;
 
       //
       // Accept positive distances
       //
       if (s1 > 0)
       {
         distance = s1;
         return true;
       }
     }
   }
 
   if (nside == 1) return false;
 
   //
   // Well, try the second hit
   //
   hit = p + s2 * v;
 
   if (PointOnCone(hit, normSign, p, v, normal))
   {
     //
     // Good intersection! What about the normal?
     //
     if (normSign * v.Dot(normal) > 0)
     {
       double pr = p.Perp();
       if (pr < DBL_MIN) pr = DBL_MIN;
       UVector3 pNormal(rNorm * p.x / pr, rNorm * p.y / pr, zNorm);
       if (normSign * v.Dot(pNormal) > 0)
       {
         double distOutside2;
         distFromSurface = -normSign * DistanceAway(p, false, distOutside2);
         if (distOutside2 < surfTolerance * surfTolerance)
         {
           if (distFromSurface > -surfTolerance)
           {
             distance = s2;
             return true;
           }
         }
       }
       else
         distFromSurface = s2;
 
       if (s2 > 0)
       {
         distance = s2;
         return true;
       }
     }
   }
 
   //
   // Better luck next time
   //
   return false;
 }

double UPolyconeSide::DistanceAway	(	const UVector3 &	p,
		bool	opposite,
		double &	distOutside2,
		double *	rzNorm = `0`
	)

protected

Definition at line 894 of file UPolyconeSide.cc.

References deltaPhi, GetPhi(), length, G4INCL::Math::max(), UVector3::Perp(), phiIsOpen, r, rNorm, rNormEdge, rS, UUtils::sqr(), startPhi, z, UVector3::z, zNorm, zNormEdge, and zS.

Referenced by Distance(), Inside(), Normal(), and Safety().

 {
   //
   // Convert our point to r and z
   //
   double rx = p.Perp(), zx = p.z;
 
   //
   // Change sign of r if opposite says we should
   //
   if (opposite) rx = -rx;
 
   //
   // Calculate return value
   //
   double deltaR = rx - r[0], deltaZ = zx - z[0];
   double answer = deltaR * rNorm + deltaZ * zNorm;
 
   //
   // Are we off the surface in r,z space?
   //
   double q = deltaR * rS + deltaZ * zS;
   if (q < 0)
   {
     distOutside2 = q * q;
     if (edgeRZnorm) *edgeRZnorm = deltaR * rNormEdge[0] + deltaZ * zNormEdge[0];
   }
   else if (q > length)
   {
     distOutside2 = UUtils::sqr(q - length);
     if (edgeRZnorm)
     {
       deltaR = rx - r[1];
       deltaZ = zx - z[1];
       *edgeRZnorm = deltaR * rNormEdge[1] + deltaZ * zNormEdge[1];
     }
   }
   else
   {
     distOutside2 = 0;
     if (edgeRZnorm) *edgeRZnorm = answer;
   }
 
   if (phiIsOpen)
   {
     //
     // Finally, check phi
     //
     double phi = GetPhi(p);
     while (phi < startPhi) phi += 2 * UUtils::kPi;
 
     if (phi > startPhi + deltaPhi)
     {
       //
       // Oops. Are we closer to the start phi or end phi?
       //
       double d1 = phi - startPhi - deltaPhi;
       while (phi > startPhi) phi -= 2 * UUtils::kPi;
       double d2 = startPhi - phi;
 
       if (d2 < d1) d1 = d2;
 
       //
       // Add result to our distance
       //
       double dist = d1 * rx;
 
       distOutside2 += dist * dist;
       if (edgeRZnorm)
       {
         *edgeRZnorm = std::max(std::fabs(*edgeRZnorm), std::fabs(dist));
       }
     }
   }
 
   return answer;
 }

double UPolyconeSide::Extent ( const UVector3 axis )

virtual

Implements UVCSGface.

Definition at line 480 of file UPolyconeSide.cc.

References test::a, test::b, test::c, cone, DBL_MIN, deltaPhi, UVector3::Dot(), GetPhi(), UVector3::Perp(), UVector3::Perp2(), phiIsOpen, r, startPhi, z, UVector3::z, UIntersectingCone::ZHi(), and UIntersectingCone::ZLo().

 {
   if (axis.Perp2() < DBL_MIN)
   {
     //
     // Special case
     //
     return axis.z < 0 ? -cone->ZLo() : cone->ZHi();
   }
 
   //
   // Is the axis pointing inside our phi gap?
   //
   if (phiIsOpen)
   {
     double phi = GetPhi(axis);
     while (phi < startPhi) phi += 2 * UUtils::kPi;
 
     if (phi > deltaPhi + startPhi)
     {
       //
       // Yeah, looks so. Make four three vectors defining the phi
       // opening
       //
       double cosP = std::cos(startPhi), sinP = std::sin(startPhi);
       UVector3 a(r[0]*cosP, r[0]*sinP, z[0]);
       UVector3 b(r[1]*cosP, r[1]*sinP, z[1]);
       cosP = std::cos(startPhi + deltaPhi);
       sinP = std::sin(startPhi + deltaPhi);
       UVector3 c(r[0]*cosP, r[0]*sinP, z[0]);
       UVector3 d(r[1]*cosP, r[1]*sinP, z[1]);
 
       double ad = axis.Dot(a),
              bd = axis.Dot(b),
              cd = axis.Dot(c),
              dd = axis.Dot(d);
 
       if (bd > ad) ad = bd;
       if (cd > ad) ad = cd;
       if (dd > ad) ad = dd;
 
       return ad;
     }
   }
 
   //
   // Check either end
   //
   double aPerp = axis.Perp();
 
   double a = aPerp * r[0] + axis.z * z[0];
   double b = aPerp * r[1] + axis.z * z[1];
 
   if (b > a) a = b;
 
   return a;
 }

void UPolyconeSide::FindLineIntersect	(	double	x1,
		double	y1,
		double	tx1,
		double	ty1,
		double	x2,
		double	y2,
		double	tx2,
		double	ty2,
		double &	x,
		double &	y
	)

staticprotected

Definition at line 1050 of file UPolyconeSide.cc.

 {
   //
   // The solution is a simple linear equation
   //
   double deter = tx1 * ty2 - tx2 * ty1;
 
   double s1 = ((x2 - x1) * ty2 - tx2 * (y2 - y1)) / deter;
   double s2 = ((x2 - x1) * ty1 - tx1 * (y2 - y1)) / deter;
 
   //
   // We want the answer to not depend on which order the
   // lines were specified. Take average.
   //
   x = 0.5 * (x1 + s1 * tx1 + x2 + s2 * tx2);
   y = 0.5 * (y1 + s1 * ty1 + y2 + s2 * ty2);
 }

double UPolyconeSide::GetPhi ( const UVector3 & p )

protected

Definition at line 867 of file UPolyconeSide.cc.

References UVector3::Phi().

Referenced by DistanceAway(), Extent(), and PointOnCone().

 {
   double val = 0.;
 
   val = p.Phi();
 
   return val;
 }

UVector3 UPolyconeSide::GetPointOnFace ( )

virtual

Implements UVCSGface.

Definition at line 1088 of file UPolyconeSide.cc.

References deltaPhi, r, UUtils::Random(), startPhi, test::x, and z.

 {
   double x, y, zz;
   double rr, phi, dz, dr;
   dr = r[1] - r[0];
   dz = z[1] - z[0];
   phi = startPhi + deltaPhi * UUtils::Random();
   rr = r[0] + dr * UUtils::Random();
 
   x = rr * std::cos(phi);
   y = rr * std::sin(phi);
 
   // PolyconeSide has a Ring Form
   //
   if (dz == 0.)
   {
     zz = z[0];
   }
   else
   {
     if (dr == 0.) // PolyconeSide has a Tube Form
     {
       zz = z[0] + dz * UUtils::Random();
     }
     else
     {
       zz = z[0] + (rr - r[0]) * dz / dr;
     }
   }
 
   return UVector3(x, y, zz);
 }

VUSolid::EnumInside UPolyconeSide::Inside	(	const UVector3 &	p,
		double	tolerance,
		double *	bestDistance
	)

virtual

Implements UVCSGface.

Definition at line 415 of file UPolyconeSide.cc.

References DistanceAway(), VUSolid::eInside, VUSolid::eOutside, and VUSolid::eSurface.

 {
   //
   // Check both sides
   //
   double distFrom[2], distOut2[2], dist2[2];
   double edgeRZnorm[2];
 
   distFrom[0] = DistanceAway(p, false, distOut2[0], edgeRZnorm);
   distFrom[1] = DistanceAway(p, true, distOut2[1], edgeRZnorm + 1);
 
   dist2[0] = distFrom[0] * distFrom[0] + distOut2[0];
   dist2[1] = distFrom[1] * distFrom[1] + distOut2[1];
 
   //
   // Who's closest?
   //
   int i = std::fabs(dist2[0]) < std::fabs(dist2[1]) ? 0 : 1;
 
   *bestDistance = std::sqrt(dist2[i]);   // could sqrt be removed?
 
   //
   // Okay then, inside or out?
   //
   if ((std::fabs(edgeRZnorm[i]) < atolerance)
       && (distOut2[i] < atolerance * atolerance))
     return VUSolid::eSurface;
   else if (edgeRZnorm[i] < 0)
     return VUSolid::eInside;
   else
     return VUSolid::eOutside;
 }

UVector3 UPolyconeSide::Normal	(	const UVector3 &	p,
		double *	bestDistance
	)

virtual

Implements UVCSGface.

Definition at line 454 of file UPolyconeSide.cc.

References DistanceAway(), UVector3::Perp(), rNorm, UVector3::Unit(), UVector3::x, UVector3::y, and zNorm.

 {
   if (p == UVector3(0., 0., 0.))
   {
     return p;
   }
 
   double dFrom, dOut2;
 
   dFrom = DistanceAway(p, false, dOut2);
 
   *bestDistance = std::sqrt(dFrom * dFrom + dOut2);
 
   double rds = p.Perp();
   if (rds != 0.)
   {
     return UVector3(rNorm * p.x / rds, rNorm * p.y / rds, zNorm);
   }
   return UVector3(0., 0., zNorm).Unit();
 }

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

Definition at line 176 of file UPolyconeSide.cc.

References cone, CopyStuff(), corners, and phiIsOpen.

 {
   if (this == &source)
   {
     return *this;
   }
 
   delete cone;
   if (phiIsOpen)
   {
     delete [] corners;
   }
 
   CopyStuff(source);
 
   return *this;
 }

bool UPolyconeSide::PointOnCone	(	const UVector3 &	hit,
		double	normSign,
		const UVector3 &	p,
		const UVector3 &	v,
		UVector3 &	normal
	)

protected

Definition at line 981 of file UPolyconeSide.cc.

References cone, corners, UVector3::Cross(), DBL_MIN, deltaPhi, UVector3::Dot(), GetPhi(), UIntersectingCone::HitOn(), UVector3::Perp(), phiIsOpen, rNorm, startPhi, VUSolid::Tolerance(), test::v, UVector3::x, UVector3::y, UVector3::z, and zNorm.

Referenced by Distance().

 {
   double rx = hit.Perp();
   //
   // Check radial/z extent, as appropriate
   //
   if (!cone->HitOn(rx, hit.z)) return false;
 
   if (phiIsOpen)
   {
     double phiTolerant = 2.0 * VUSolid::Tolerance() / (rx + VUSolid::Tolerance());
     //
     // Check phi segment. Here we have to be careful
     // to use the standard method consistent with
     // PolyPhiFace. See PolyPhiFace::InsideEdgesExact
     //
     double phi = GetPhi(hit);
     while (phi < startPhi - phiTolerant) phi += 2 * UUtils::kPi;
 
     if (phi > startPhi + deltaPhi + phiTolerant) return false;
 
     if (phi > startPhi + deltaPhi - phiTolerant)
     {
       //
       // Exact treatment
       //
       UVector3 qx = p + v;
       UVector3 qa = qx - corners[2],
                qb = qx - corners[3];
       UVector3 qacb = qa.Cross(qb);
 
       if (normSign * qacb.Dot(v) < 0) return false;
     }
     else if (phi < phiTolerant)
     {
       UVector3 qx = p + v;
       UVector3 qa = qx - corners[1],
                qb = qx - corners[0];
       UVector3 qacb = qa.Cross(qb);
 
       if (normSign * qacb.Dot(v) < 0) return false;
     }
   }
 
   //
   // We have a good hit! Calculate normal
   //
   if (rx < DBL_MIN)
     normal = UVector3(0, 0, zNorm < 0 ? -1 : 1);
   else
     normal = UVector3(rNorm * hit.x / rx, rNorm * hit.y / rx, zNorm);
   return true;
 }

double UPolyconeSide::Safety	(	const UVector3 &	p,
		bool	outgoing
	)

virtual

Implements UVCSGface.

Definition at line 375 of file UPolyconeSide.cc.

References DistanceAway(), and VUSolid::Tolerance().

 {
   double normSign = outgoing ? -1 : +1;
   double distFrom, distOut2;
 
   //
   // We have two tries for each hemisphere. Try the closest first.
   //
   distFrom = normSign * DistanceAway(p, false, distOut2);
   if (distFrom > -0.5 * VUSolid::Tolerance())
   {
     //
     // Good answer
     //
     if (distOut2 > 0)
       return std::sqrt(distFrom * distFrom + distOut2);
     else
       return std::fabs(distFrom);
   }
 
   //
   // Try second side.
   //
   distFrom = normSign * DistanceAway(p, true, distOut2);
   if (distFrom > -0.5 * VUSolid::Tolerance())
   {
 
     if (distOut2 > 0)
       return std::sqrt(distFrom * distFrom + distOut2);
     else
       return std::fabs(distFrom);
   }
 
   return UUtils::kInfinity;
 }

double UPolyconeSide::SurfaceArea ( )

virtual

Implements UVCSGface.

Definition at line 1075 of file UPolyconeSide.cc.

References deltaPhi, r, UUtils::sqr(), and z.

 {
   if (fSurfaceArea == 0)
   {
     fSurfaceArea = (r[0] + r[1]) * std::sqrt(UUtils::sqr(r[0] - r[1]) + UUtils::sqr(z[0] - z[1]));
     fSurfaceArea *= 0.5 * (deltaPhi);
   }
   return fSurfaceArea;
 }