#include <UPolyhedra.hh>

Inheritance diagram for UPolyhedra:

Public Member Functions
void	Init (double phiStart, double phiTotal, int numSide, int numZPlanes, const double zPlane[], const double rInner[], const double rOuter[])

	UPolyhedra (const std::string &name, double phiStart, double phiTotal, int numSide, int numZPlanes, const double zPlane[], const double rInner[], const double rOuter[])

	UPolyhedra (const std::string &name, double phiStart, double phiTotal, int numSide, int numRZ, const double r[], const double z[])

virtual	~UPolyhedra ()

void	GetParametersList (int, double *) const

void	ComputeBBox (UBBox *, bool)

VUSolid::EnumInside	Inside (const UVector3 &p) const

double	SafetyFromOutside (const UVector3 &aPoint, bool aAccurate=false) const

UGeometryType	GetEntityType () const

VUSolid *	Clone () const

UVector3	GetPointOnSurface () const

std::ostream &	StreamInfo (std::ostream &os) const

bool	Reset ()

int	GetNumSide () const

double	GetStartPhi () const

double	GetEndPhi () const

bool	IsOpen () const

bool	IsGeneric () const

int	GetNumRZCorner () const

UPolyhedraSideRZ	GetCorner (const int index) const

UPolyhedraHistorical *	GetOriginalParameters ()

void	SetOriginalParameters (UPolyhedraHistorical &pars)

double	DistanceToIn (const UVector3 &p, const UVector3 &v, double aPstep=UUtils::kInfinity) const

	UPolyhedra (const UPolyhedra &source)

UPolyhedra &	operator= (const UPolyhedra &source)

Public Member Functions inherited from UVCSGfaceted
	UVCSGfaceted (const std::string &name)

virtual	~UVCSGfaceted ()

	UVCSGfaceted (const UVCSGfaceted &source)

UVCSGfaceted &	operator= (const UVCSGfaceted &source)

VUSolid::EnumInside	InsideNoVoxels (const UVector3 &p) const

virtual bool	Normal (const UVector3 &p, UVector3 &n) const

double	DistanceToInNoVoxels (const UVector3 &p, const UVector3 &v) const

double	DistanceTo (const UVector3 &p, const bool outgoing) const

double	DistanceToOutNoVoxels (const UVector3 &p, const UVector3 &v, UVector3 &n, bool &aConvex) const

virtual double	DistanceToOut (const UVector3 &p, const UVector3 &v, UVector3 &n, bool &aConvex, double aPstep=UUtils::kInfinity) const

virtual double	SafetyFromInside (const UVector3 &aPoint, bool aAccurate=false) const

virtual double	SafetyFromInsideNoVoxels (const UVector3 &aPoint, bool aAccurate=false) const

int	GetCubVolStatistics () const

double	GetCubVolEpsilon () const

void	SetCubVolStatistics (int st)

void	SetCubVolEpsilon (double ep)

int	GetAreaStatistics () const

double	GetAreaAccuracy () const

void	SetAreaStatistics (int st)

void	SetAreaAccuracy (double ep)

virtual double	Capacity ()

virtual double	SurfaceArea ()

Public Member Functions inherited from VUSolid
	VUSolid ()

	VUSolid (const std::string &name)

virtual	~VUSolid ()

double	GetCarTolerance () const

double	GetRadTolerance () const

double	GetAngTolerance () const

void	SetCarTolerance (double eps)

void	SetRadTolerance (double eps)

void	SetAngTolerance (double eps)

virtual void	ExtentAxis (EAxisType aAxis, double &aMin, double &aMax) const

const std::string &	GetName () const

void	SetName (const std::string &aName)

virtual void	SamplePointsInside (int, UVector3 *) const

virtual void	SamplePointsOnSurface (int, UVector3 *) const

virtual void	SamplePointsOnEdge (int, UVector3 *) const

double	EstimateCubicVolume (int nStat, double epsilon) const

double	EstimateSurfaceArea (int nStat, double ell) const

Protected Member Functions
	UPolyhedra (const std::string &name)

void	SetOriginalParameters ()

void	Create (double phiStart, double phiTotal, int numSide, UReduciblePolygon *rz)

void	CopyStuff (const UPolyhedra &source)

void	DeleteStuff ()

UVector3	GetPointOnPlane (UVector3 p0, UVector3 p1, UVector3 p2, UVector3 p3) const

UVector3	GetPointOnTriangle (UVector3 p0, UVector3 p1, UVector3 p2) const

UVector3	GetPointOnSurfaceCorners () const

void	Extent (UVector3 &aMin, UVector3 &aMax) const

Protected Member Functions inherited from UVCSGfaceted
double	SafetyFromInsideSection (int index, const UVector3 &p, UBits &bits) const

int	GetSection (double z) const

UVector3	GetPointOnSurfaceGeneric () const

void	CopyStuff (const UVCSGfaceted &source)

void	DeleteStuff ()

void	FindCandidates (double z, std::vector< int > &candidates, bool sides=false)

void	InitVoxels (UReduciblePolygon &z, double radius)

Protected Attributes
int	fNumSides

double	fStartPhi

double	fEndPhi

bool	fPhiIsOpen

bool	fGenericPgon

int	fNumCorner

UPolyhedraSideRZ *	fCorners

UPolyhedraHistorical	fOriginalParameters

UEnclosingCylinder *	fEnclosingCylinder

Protected Attributes inherited from UVCSGfaceted
int	numFace

UVCSGface **	faces

double	fCubicVolume

double	fSurfaceArea

std::vector< double >	fZs

std::vector< std::vector< int > >	fCandidates

int	fMaxSection

UBox	fBox

double	fBoxShift

bool	fNoVoxels

Additional Inherited Members
Public Types inherited from VUSolid
enum	EnumInside { eInside =0, eSurface =1, eOutside =2 }

enum	EAxisType { eXaxis =0, eYaxis =1, eZaxis =2 }

Static Public Member Functions inherited from VUSolid
static double	Tolerance ()

Static Protected Attributes inherited from VUSolid
static double	fgTolerance = 1.0E-9

static double	frTolerance = 1.0E-9

static double	faTolerance = 1.0E-9

Detailed Description

Definition at line 64 of file UPolyhedra.hh.

Constructor & Destructor Documentation

UPolyhedra::UPolyhedra ( const std::string & name )

inlineprotected

Definition at line 68 of file UPolyhedra.hh.

Referenced by Clone().

68 : UVCSGfaceted(name) {}

name

const XML_Char * name

Definition: include/expat.h:151

UVCSGfaceted::UVCSGfaceted

UVCSGfaceted(const std::string &name)

Definition: UVCSGfaceted.cc:31

UPolyhedra::UPolyhedra	(	const std::string &	name,
		double	phiStart,
		double	phiTotal,
		int	numSide,
		int	numZPlanes,
		const double	zPlane[],
		const double	rInner[],
		const double	rOuter[]
	)

Definition at line 49 of file UPolyhedra.cc.

References Init().

   : UVCSGfaceted(name)
 {
   Init(phiStart, thePhiTotal, thefNumSide, numZPlanes, zPlane, rInner, rOuter);
 }

UPolyhedra::UPolyhedra	(	const std::string &	name,
		double	phiStart,
		double	phiTotal,
		int	numSide,
		int	numRZ,
		const double	r[],
		const double	z[]
	)

Definition at line 156 of file UPolyhedra.cc.

References Create(), and SetOriginalParameters().

   : UVCSGfaceted(name), fGenericPgon(true)
 {
   UReduciblePolygon* rz = new UReduciblePolygon(r, z, numRZ);
 
   Create(phiStart, phiTotal, thefNumSide, rz);
 
   // Set fOriginalParameters struct for consistency
   //
   SetOriginalParameters();
 
   delete rz;
 }

UPolyhedra::~UPolyhedra ( )

virtual

Definition at line 382 of file UPolyhedra.cc.

References fCorners, and fEnclosingCylinder.

 {
   delete [] fCorners;
 //  if (fOriginalParameters) delete fOriginalParameters;
 
   delete fEnclosingCylinder;
 }

UPolyhedra::UPolyhedra ( const UPolyhedra & source )

Definition at line 394 of file UPolyhedra.cc.

References CopyStuff().

   : UVCSGfaceted(source)
 {
   CopyStuff(source);
 }

Member Function Documentation

VUSolid * UPolyhedra::Clone ( ) const

virtual

Implements VUSolid.

Definition at line 541 of file UPolyhedra.cc.

References UPolyhedra().

 {
   return new UPolyhedra(*this);
 }

void UPolyhedra::ComputeBBox	(	UBBox *	,
		bool
	)

inlinevirtual

Implements VUSolid.

Definition at line 104 of file UPolyhedra.hh.

     {
       // Computes bounding box.
       std::cout << "ComputeBBox - Not implemented" << std::endl;
     }

void UPolyhedra::CopyStuff ( const UPolyhedra & source )

protected

Definition at line 424 of file UPolyhedra.cc.

References fCorners, fEnclosingCylinder, fEndPhi, fGenericPgon, fNumCorner, fNumSides, fOriginalParameters, fPhiIsOpen, and fStartPhi.

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

 {
   //
   // Simple stuff
   //
   fNumSides    = source.fNumSides;
   fStartPhi   = source.fStartPhi;
   fEndPhi     = source.fEndPhi;
   fPhiIsOpen  = source.fPhiIsOpen;
   fNumCorner  = source.fNumCorner;
   fGenericPgon = source.fGenericPgon;
 
   //
   // The corner array
   //
   fCorners = new UPolyhedraSideRZ[fNumCorner];
 
   UPolyhedraSideRZ*  corn = fCorners,
                      *sourceCorn = source.fCorners;
   do
   {
     *corn = *sourceCorn;
   }
   while (++sourceCorn, ++corn < fCorners + fNumCorner);
 
   fOriginalParameters = source.fOriginalParameters;
 
   //
   // Enclosing cylinder
   //
   fEnclosingCylinder = new UEnclosingCylinder(*source.fEnclosingCylinder);
 }

void UPolyhedra::Create	(	double	phiStart,
		double	phiTotal,
		int	numSide,
		UReduciblePolygon *	rz
	)

protected

Definition at line 183 of file UPolyhedra.cc.

Referenced by Init(), Reset(), and UPolyhedra().

 {
   //
   // Perform checks of rz values
   //
   if (rz->Amin() < 0.0)
   {
     std::ostringstream message;
     message << "Illegal input parameters - " << GetName() << std::endl
             << "        All R values must be >= 0 !";
     UUtils::Exception("UPolyhedra::Create()", "GeomSolids0002",
                       FatalErrorInArguments, 1, message.str().c_str());
   }
 
   double rzArea = rz->Area();
   if (rzArea < -VUSolid::Tolerance())
     rz->ReverseOrder();
 
   else if (rzArea < -VUSolid::Tolerance())
   {
     std::ostringstream message;
     message << "Illegal input parameters - " << GetName() << std::endl
             << "        R/Z Cross section is zero or near zero: " << rzArea;
     UUtils::Exception("UPolyhedra::Create()", "GeomSolids0002",
                       FatalErrorInArguments, 1, message.str().c_str());
   }
 
   if ((!rz->RemoveDuplicateVertices(VUSolid::Tolerance()))
       || (!rz->RemoveRedundantVertices(VUSolid::Tolerance())))
   {
     std::ostringstream message;
     message << "Illegal input parameters - " << GetName() << std::endl
             << "        Too few unique R/Z values !";
     UUtils::Exception("UPolyhedra::Create()", "GeomSolids0002",
                       FatalErrorInArguments, 1, message.str().c_str());
   }
 
   if (rz->CrossesItself(1 / UUtils::kInfinity))
   {
     std::ostringstream message;
     message << "Illegal input parameters - " << GetName() << std::endl
             << "        R/Z segments Cross !";
     UUtils::Exception("UPolyhedra::Create()", "GeomSolids0002",
                       FatalErrorInArguments, 1, message.str().c_str());
   }
 
   fNumCorner = rz->NumVertices();
 
   fStartPhi = phiStart;
   while (fStartPhi < 0) fStartPhi += 2 * UUtils::kPi;
   //
   // Phi opening? Account for some possible roundoff, and interpret
   // nonsense value as representing no phi opening
   //
   if ((phiTotal <= 0) || (phiTotal > 2 * UUtils::kPi * (1 - DBL_EPSILON)))
   {
     fPhiIsOpen = false;
     fEndPhi = phiStart + 2 * UUtils::kPi;
   }
   else
   {
     fPhiIsOpen = true;
 
     //
     // Convert phi into our convention
     //
     fEndPhi = phiStart + phiTotal;
     while (fEndPhi < fStartPhi) fEndPhi += 2 * UUtils::kPi;
   }
 
   //
   // Save number sides
   //
   fNumSides = thefNumSide;
 
   //
   // Allocate corner array.
   //
   fCorners = new UPolyhedraSideRZ[fNumCorner];
 
   //
   // Copy fCorners
   //
   UReduciblePolygonIterator iterRZ(rz);
 
   UPolyhedraSideRZ* next = fCorners;
   iterRZ.Begin();
   do
   {
     next->r = iterRZ.GetA();
     next->z = iterRZ.GetB();
   }
   while (++next, iterRZ.Next());
 
   //
   // Allocate face pointer array
   //
   numFace = fPhiIsOpen ? fNumCorner + 2 : fNumCorner;
   faces = new UVCSGface*[numFace];
 
   //
   // Construct side faces
   //
   // To do so properly, we need to keep track of four successive RZ
   // fCorners.
   //
   // But! Don't construct a face if both points are at zero radius!
 
   //
   UPolyhedraSideRZ* corner = fCorners,
                     *prev = fCorners + fNumCorner - 1,
                      *nextNext;
   UVCSGface**   face = faces;
   do
   {
     next = corner + 1;
     if (next >= fCorners + fNumCorner) next = fCorners;
     nextNext = next + 1;
     if (nextNext >= fCorners + fNumCorner) nextNext = fCorners;
 
     if (corner->r < 1 / UUtils::kInfinity && next->r < 1 / UUtils::kInfinity) continue;
     /*
         // We must decide here if we can dare declare one of our faces
         // as having a "valid" normal (i.e. allBehind = true). This
         // is never possible if the face faces "inward" in r *unless*
         // we have only one side
         //
         bool allBehind;
         if ((corner->z > next->z) && (fNumSides > 1))
         {
           allBehind = false;
         }
         else
         {
           //
           // Otherwise, it is only true if the line passing
           // through the two points of the segment do not
           // split the r/z Cross section
           //
           allBehind = !rz->BisectedBy( corner->r, corner->z,
                                        next->r, next->z, VUSolid::Tolerance() );
         }
     */
     *face++ = new UPolyhedraSide(prev, corner, next, nextNext,
                                  fNumSides, fStartPhi, fEndPhi - fStartPhi, fPhiIsOpen);
   }
   while (prev = corner, corner = next, corner > fCorners);
 
   if (fPhiIsOpen)
   {
     //
     // Construct phi open edges
     //
     *face++ = new UPolyPhiFace(rz, fStartPhi, phiTotal / fNumSides, fEndPhi);
     *face++ = new UPolyPhiFace(rz, fEndPhi,   phiTotal / fNumSides, fStartPhi);
   }
 
   //
   // We might have dropped a face or two: recalculate numFace
   //
   numFace = face - faces;
 
   //
   // Make fEnclosingCylinder
   //
 
   /*
   double mxy = rz->Amax();
   double alfa = UUtils::kPi / fNumSides;
 
   double r= rz->Amax();
 
   if (fNumSides != 0)
   {
     // mxy *= std::sqrt(2.0); // this is old and wrong, works only for n = 4
     double k = std::tan(alfa) * mxy;
     double l = mxy / std::cos(alfa);
     mxy = l;
     r = l;
   }
   mxy += fgTolerance;
   */
 
   fEnclosingCylinder =
     new UEnclosingCylinder(rz->Amax(), rz->Bmax(), rz->Bmin(), fPhiIsOpen, phiStart, phiTotal);
 
   InitVoxels(*rz, fEnclosingCylinder->radius);
 
   fNoVoxels = fMaxSection < 2; // minimally, sections with at least numbers 0,1,2 values required, this corresponds to fMaxSection == 2
 }

void UPolyhedra::DeleteStuff ( )

protected

double UPolyhedra::DistanceToIn	(	const UVector3 &	p,
		const UVector3 &	v,
		double	aPstep = `UUtils::kInfinity`
	)		const

virtual

Reimplemented from UVCSGfaceted.

Definition at line 935 of file UPolyhedra.cc.

References UVCSGfaceted::DistanceToIn(), fEnclosingCylinder, UVCSGfaceted::fNoVoxels, and UEnclosingCylinder::ShouldMiss().

 {
   //
   // Quick test
   //
   if (fNoVoxels && fEnclosingCylinder->ShouldMiss(p, v))
     return UUtils::kInfinity;
 
   //
   // Long answer
   //
   return UVCSGfaceted::DistanceToIn(p, v, aPstep);
 }

void UPolyhedra::Extent	(	UVector3 &	aMin,
		UVector3 &	aMax
	)		const

protectedvirtual

Implements VUSolid.

Definition at line 923 of file UPolyhedra.cc.

References UEnclosingCylinder::Extent(), and fEnclosingCylinder.

 {
   fEnclosingCylinder->Extent(aMin, aMax);
 }

UPolyhedraSideRZ UPolyhedra::GetCorner ( const int index ) const

inline

Referenced by G4UPolyhedra::GetCorner().

double UPolyhedra::GetEndPhi ( ) const

inline

Referenced by G4UPolyhedra::GetEndPhi().

UGeometryType UPolyhedra::GetEntityType ( ) const

virtual

Reimplemented from UVCSGfaceted.

Definition at line 532 of file UPolyhedra.cc.

 {
   return std::string("Polyhedra");
 }

int UPolyhedra::GetNumRZCorner ( ) const

inline

Referenced by G4UPolyhedra::GetNumRZCorner().

int UPolyhedra::GetNumSide ( ) const

inline

Referenced by G4UPolyhedra::GetNumSide().

UPolyhedraHistorical* UPolyhedra::GetOriginalParameters ( )

inline

Referenced by G4UPolyhedra::GetOriginalParameters(), and G4UPolyhedra::SetOriginalParameters().

void UPolyhedra::GetParametersList	(	int	,
		double *
	)		const

inlinevirtual

Implements VUSolid.

Definition at line 102 of file UPolyhedra.hh.

102 {}

UVector3 UPolyhedra::GetPointOnPlane	(	UVector3	p0,
		UVector3	p1,
		UVector3	p2,
		UVector3	p3
	)		const

protected

Definition at line 603 of file UPolyhedra.cc.

References UUtils::Random(), and test::v.

Referenced by GetPointOnSurface().

 {
   double lambda1, lambda2, chose, aOne, aTwo;
   UVector3 t, u, v, w, Area, normal;
   aOne = 1.;
   aTwo = 1.;
 
   t = p1 - p0;
   u = p2 - p1;
   v = p3 - p2;
   w = p0 - p3;
 
   chose = UUtils::Random(0., aOne + aTwo);
   if ((chose >= 0.) && (chose < aOne))
   {
     lambda1 = UUtils::Random(0., 1.);
     lambda2 = UUtils::Random(0., lambda1);
     return (p2 + lambda1 * v + lambda2 * w);
   }
 
   lambda1 = UUtils::Random(0., 1.);
   lambda2 = UUtils::Random(0., lambda1);
   return (p0 + lambda1 * t + lambda2 * u);
 }

UVector3 UPolyhedra::GetPointOnSurface ( ) const

virtual

Implements VUSolid.

Definition at line 652 of file UPolyhedra.cc.

References test::a, test::b, fEndPhi, fGenericPgon, fNumSides, UPolyhedraHistorical::fNumZPlanes, fOriginalParameters, fPhiIsOpen, fStartPhi, UPolyhedraHistorical::fZValues, GetPointOnPlane(), UVCSGfaceted::GetPointOnSurfaceGeneric(), UUtils::Random(), UPolyhedraHistorical::Rmax, UPolyhedraHistorical::Rmin, and UUtils::sqr().

 {
   if (!fGenericPgon)   // Polyhedra by faces
   {
     int j, numPlanes = fOriginalParameters.fNumZPlanes, Flag = 0;
     double chose, totArea = 0., Achose1, Achose2,
                   rad1, rad2, sinphi1, sinphi2, cosphi1, cosphi2;
     double a, b, l2, rang, totalPhi, ksi,
            area, aTop = 0., aBottom = 0., zVal = 0.;
 
     UVector3 p0, p1, p2, p3;
     std::vector<double> aVector1;
     std::vector<double> aVector2;
     std::vector<double> aVector3;
 
     totalPhi = (fPhiIsOpen) ? (fEndPhi - fStartPhi) : 2 * UUtils::kPi;
     ksi = totalPhi / fNumSides;
     double cosksi = std::cos(ksi / 2.);
 
     // Below we generate the areas relevant to our solid
     //
     for (j = 0; j < numPlanes - 1; j++)
     {
       a = fOriginalParameters.Rmax[j + 1];
       b = fOriginalParameters.Rmax[j];
       l2 = UUtils::sqr(fOriginalParameters.fZValues[j]
                        - fOriginalParameters.fZValues[j + 1]) + UUtils::sqr(b - a);
       area = std::sqrt(l2 - UUtils::sqr((a - b) * cosksi)) * (a + b) * cosksi;
       aVector1.push_back(area);
     }
 
     for (j = 0; j < numPlanes - 1; j++)
     {
       a = fOriginalParameters.Rmin[j + 1]; //*cosksi;
       b = fOriginalParameters.Rmin[j];//*cosksi;
       l2 = UUtils::sqr(fOriginalParameters.fZValues[j]
                        - fOriginalParameters.fZValues[j + 1]) + UUtils::sqr(b - a);
       area = std::sqrt(l2 - UUtils::sqr((a - b) * cosksi)) * (a + b) * cosksi;
       aVector2.push_back(area);
     }
 
     for (j = 0; j < numPlanes - 1; j++)
     {
       if (fPhiIsOpen == true)
       {
         aVector3.push_back(0.5 * (fOriginalParameters.Rmax[j]
                                   - fOriginalParameters.Rmin[j]
                                   + fOriginalParameters.Rmax[j + 1]
                                   - fOriginalParameters.Rmin[j + 1])
                            *std::fabs(fOriginalParameters.fZValues[j + 1]
                                       - fOriginalParameters.fZValues[j]));
       }
       else
       {
         aVector3.push_back(0.);
       }
     }
 
     for (j = 0; j < numPlanes - 1; j++)
     {
       totArea += fNumSides * (aVector1[j] + aVector2[j]) + 2.*aVector3[j];
     }
 
     // Must include top and bottom areas
     //
     if (fOriginalParameters.Rmax[numPlanes - 1] != 0.)
     {
       a = fOriginalParameters.Rmax[numPlanes - 1];
       b = fOriginalParameters.Rmin[numPlanes - 1];
       l2 = UUtils::sqr(a - b);
       aTop = std::sqrt(l2 - UUtils::sqr((a - b) * cosksi)) * (a + b) * cosksi;
     }
 
     if (fOriginalParameters.Rmax[0] != 0.)
     {
       a = fOriginalParameters.Rmax[0];
       b = fOriginalParameters.Rmin[0];
       l2 = UUtils::sqr(a - b);
       aBottom = std::sqrt(l2 - UUtils::sqr((a - b) * cosksi)) * (a + b) * cosksi;
     }
 
     Achose1 = 0.;
     Achose2 = fNumSides * (aVector1[0] + aVector2[0]) + 2.*aVector3[0];
 
     chose = UUtils::Random(0., totArea + aTop + aBottom);
     if ((chose >= 0.) && (chose < aTop + aBottom))
     {
       chose = UUtils::Random(fStartPhi, fStartPhi + totalPhi);
       rang = std::floor((chose - fStartPhi) / ksi - 0.01);
       if (rang < 0)
       {
         rang = 0;
       }
       rang = std::fabs(rang);
       sinphi1 = std::sin(fStartPhi + rang * ksi);
       sinphi2 = std::sin(fStartPhi + (rang + 1) * ksi);
       cosphi1 = std::cos(fStartPhi + rang * ksi);
       cosphi2 = std::cos(fStartPhi + (rang + 1) * ksi);
       chose = UUtils::Random(0., aTop + aBottom);
       if (chose >= 0. && chose < aTop)
       {
         rad1 = fOriginalParameters.Rmin[numPlanes - 1];
         rad2 = fOriginalParameters.Rmax[numPlanes - 1];
         zVal = fOriginalParameters.fZValues[numPlanes - 1];
       }
       else
       {
         rad1 = fOriginalParameters.Rmin[0];
         rad2 = fOriginalParameters.Rmax[0];
         zVal = fOriginalParameters.fZValues[0];
       }
       p0 = UVector3(rad1 * cosphi1, rad1 * sinphi1, zVal);
       p1 = UVector3(rad2 * cosphi1, rad2 * sinphi1, zVal);
       p2 = UVector3(rad2 * cosphi2, rad2 * sinphi2, zVal);
       p3 = UVector3(rad1 * cosphi2, rad1 * sinphi2, zVal);
       return GetPointOnPlane(p0, p1, p2, p3);
     }
     else
     {
       for (j = 0; j < numPlanes - 1; j++)
       {
         if (((chose >= Achose1) && (chose < Achose2)) || (j == numPlanes - 2))
         {
           Flag = j;
           break;
         }
         Achose1 += fNumSides * (aVector1[j] + aVector2[j]) + 2.*aVector3[j];
         Achose2 = Achose1 + fNumSides * (aVector1[j + 1] + aVector2[j + 1])
                   + 2.*aVector3[j + 1];
       }
     }
 
     // At this point we have chosen a subsection
     // between to adjacent plane cuts...
 
     j = Flag;
 
     totArea = fNumSides * (aVector1[j] + aVector2[j]) + 2.*aVector3[j];
     chose = UUtils::Random(0., totArea);
 
     if ((chose >= 0.) && (chose < fNumSides * aVector1[j]))
     {
       chose = UUtils::Random(fStartPhi, fStartPhi + totalPhi);
       rang = std::floor((chose - fStartPhi) / ksi - 0.01);
       if (rang < 0)
       {
         rang = 0;
       }
       rang = std::fabs(rang);
       rad1 = fOriginalParameters.Rmax[j];
       rad2 = fOriginalParameters.Rmax[j + 1];
       sinphi1 = std::sin(fStartPhi + rang * ksi);
       sinphi2 = std::sin(fStartPhi + (rang + 1) * ksi);
       cosphi1 = std::cos(fStartPhi + rang * ksi);
       cosphi2 = std::cos(fStartPhi + (rang + 1) * ksi);
       zVal = fOriginalParameters.fZValues[j];
 
       p0 = UVector3(rad1 * cosphi1, rad1 * sinphi1, zVal);
       p1 = UVector3(rad1 * cosphi2, rad1 * sinphi2, zVal);
 
       zVal = fOriginalParameters.fZValues[j + 1];
 
       p2 = UVector3(rad2 * cosphi2, rad2 * sinphi2, zVal);
       p3 = UVector3(rad2 * cosphi1, rad2 * sinphi1, zVal);
       return GetPointOnPlane(p0, p1, p2, p3);
     }
     else if ((chose >= fNumSides * aVector1[j])
              && (chose <= fNumSides * (aVector1[j] + aVector2[j])))
     {
       chose = UUtils::Random(fStartPhi, fStartPhi + totalPhi);
       rang = std::floor((chose - fStartPhi) / ksi - 0.01);
       if (rang < 0)
       {
         rang = 0;
       }
       rang = std::fabs(rang);
       rad1 = fOriginalParameters.Rmin[j];
       rad2 = fOriginalParameters.Rmin[j + 1];
       sinphi1 = std::sin(fStartPhi + rang * ksi);
       sinphi2 = std::sin(fStartPhi + (rang + 1) * ksi);
       cosphi1 = std::cos(fStartPhi + rang * ksi);
       cosphi2 = std::cos(fStartPhi + (rang + 1) * ksi);
       zVal = fOriginalParameters.fZValues[j];
 
       p0 = UVector3(rad1 * cosphi1, rad1 * sinphi1, zVal);
       p1 = UVector3(rad1 * cosphi2, rad1 * sinphi2, zVal);
 
       zVal = fOriginalParameters.fZValues[j + 1];
 
       p2 = UVector3(rad2 * cosphi2, rad2 * sinphi2, zVal);
       p3 = UVector3(rad2 * cosphi1, rad2 * sinphi1, zVal);
       return GetPointOnPlane(p0, p1, p2, p3);
     }
 
     chose = UUtils::Random(0., 2.2);
     if ((chose >= 0.) && (chose < 1.))
     {
       rang = fStartPhi;
     }
     else
     {
       rang = fEndPhi;
     }
 
     cosphi1 = std::cos(rang);
     rad1 = fOriginalParameters.Rmin[j];
     sinphi1 = std::sin(rang);
     rad2 = fOriginalParameters.Rmax[j];
 
     p0 = UVector3(rad1 * cosphi1, rad1 * sinphi1,
                   fOriginalParameters.fZValues[j]);
     p1 = UVector3(rad2 * cosphi1, rad2 * sinphi1,
                   fOriginalParameters.fZValues[j]);
 
     rad1 = fOriginalParameters.Rmax[j + 1];
     rad2 = fOriginalParameters.Rmin[j + 1];
 
     p2 = UVector3(rad1 * cosphi1, rad1 * sinphi1,
                   fOriginalParameters.fZValues[j + 1]);
     p3 = UVector3(rad2 * cosphi1, rad2 * sinphi1,
                   fOriginalParameters.fZValues[j + 1]);
     return GetPointOnPlane(p0, p1, p2, p3);
   }
   else  // Generic polyhedra
   {
     return GetPointOnSurfaceGeneric();
   }
 }

UVector3 UPolyhedra::GetPointOnSurfaceCorners ( ) const

protected

UVector3 UPolyhedra::GetPointOnTriangle	(	UVector3	p0,
		UVector3	p1,
		UVector3	p2
	)		const

protected

Definition at line 635 of file UPolyhedra.cc.

References UUtils::Random(), and test::v.

 {
   double lambda1, lambda2;
   UVector3 v = p3 - p1, w = p1 - p2;
 
   lambda1 = UUtils::Random(0., 1.);
   lambda2 = UUtils::Random(0., lambda1);
 
   return (p2 + lambda1 * w + lambda2 * v);
 }

double UPolyhedra::GetStartPhi ( ) const

inline

Referenced by G4UPolyhedra::GetStartPhi().

void UPolyhedra::Init	(	double	phiStart,
		double	phiTotal,
		int	numSide,
		int	numZPlanes,
		const double	zPlane[],
		const double	rInner[],
		const double	rOuter[]
	)

Definition at line 67 of file UPolyhedra.cc.

References Create(), DBL_EPSILON, UUtils::Exception(), FatalErrorInArguments, fGenericPgon, UPolyhedraHistorical::fNumSide, UPolyhedraHistorical::fNumZPlanes, UPolyhedraHistorical::fOpeningAngle, fOriginalParameters, UPolyhedraHistorical::fStartAngle, UPolyhedraHistorical::fZValues, VUSolid::GetName(), UPolyhedraHistorical::Rmax, UPolyhedraHistorical::Rmin, and UReduciblePolygon::ScaleA().

Referenced by UPolyhedra().

 {
   fGenericPgon = false;
 
   if (thefNumSide <= 0)
   {
     std::ostringstream message;
     message << "Solid must have at least one side - " << GetName() << std::endl
             << "        No sides specified !";
     UUtils::Exception("UPolyhedra::UPolyhedra()", "GeomSolids0002",
                       FatalErrorInArguments, 1, message.str().c_str());
   }
 
   //
   // Calculate conversion factor from G3 radius to U radius
   //
   double phiTotal = thePhiTotal;
   if ((phiTotal <= 0) || (phiTotal >= 2 * UUtils::kPi * (1 - DBL_EPSILON)))
   {
     phiTotal = 2 * UUtils::kPi;
   }
   double convertRad = std::cos(0.5 * phiTotal / thefNumSide);
 
   //
   // Some historical stuff
   //
 //  fOriginalParameters = new UPolyhedraHistorical;
 
   fOriginalParameters.fNumSide = thefNumSide;
   fOriginalParameters.fStartAngle = phiStart;
   fOriginalParameters.fOpeningAngle = phiTotal;
   fOriginalParameters.fNumZPlanes = numZPlanes;
   fOriginalParameters.fZValues.resize(numZPlanes);
   fOriginalParameters.Rmin.resize(numZPlanes);
   fOriginalParameters.Rmax.resize(numZPlanes);
 
   int i;
   for (i = 0; i < numZPlanes; i++)
   {
     if ((i < numZPlanes - 1) && (zPlane[i] == zPlane[i + 1]))
     {
       if ((rInner[i]   > rOuter[i + 1])
           || (rInner[i + 1] > rOuter[i]))
       {
 
         std::ostringstream message;
         message << "Cannot create a Polyhedra with no contiguous segments."
                 << std::endl
                 << "        Segments are not contiguous !" << std::endl
                 << "        rMin[" << i << "] = " << rInner[i]
                 << " -- rMax[" << i + 1 << "] = " << rOuter[i + 1] << std::endl
                 << "        rMin[" << i + 1 << "] = " << rInner[i + 1]
                 << " -- rMax[" << i << "] = " << rOuter[i];
         UUtils::Exception("UPolyhedra::UPolyhedra()", "GeomSolids0002",
                           FatalErrorInArguments, 1, message.str().c_str());
       }
     }
     fOriginalParameters.fZValues[i] = zPlane[i];
     fOriginalParameters.Rmin[i] = rInner[i] / convertRad;
     fOriginalParameters.Rmax[i] = rOuter[i] / convertRad;
   }
 
 
   //
   // Build RZ polygon using special PCON/PGON GEANT3 constructor
   //
   UReduciblePolygon* rz =
     new UReduciblePolygon(rInner, rOuter, zPlane, numZPlanes);
   rz->ScaleA(1 / convertRad);
 
   //
   // Do the real work
   //
   Create(phiStart, phiTotal, thefNumSide, rz);
 
   delete rz;
 }

VUSolid::EnumInside UPolyhedra::Inside ( const UVector3 & p ) const

virtual

Reimplemented from UVCSGfaceted.

Definition at line 506 of file UPolyhedra.cc.

References VUSolid::eOutside, fEnclosingCylinder, UVCSGfaceted::Inside(), and UEnclosingCylinder::MustBeOutside().

 {
   //
   // Quick test
   //
   if (fEnclosingCylinder->MustBeOutside(p)) return eOutside;
 
   //
   // Long answer
   //
   return UVCSGfaceted::Inside(p);
 }

bool UPolyhedra::IsGeneric ( ) const

inline

Referenced by G4UPolyhedra::IsGeneric().

bool UPolyhedra::IsOpen ( ) const

inline

Referenced by G4UPolyhedra::IsOpen().

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

Definition at line 404 of file UPolyhedra.cc.

References CopyStuff(), fCorners, fEnclosingCylinder, and UVCSGfaceted::operator=().

 {
   if (this == &source) return *this;
 
   UVCSGfaceted::operator=(source);
 
   delete [] fCorners;
 //  if (fOriginalParameters) delete fOriginalParameters;
 
   delete fEnclosingCylinder;
 
   CopyStuff(source);
 
   return *this;
 }

bool UPolyhedra::Reset ( )

Definition at line 464 of file UPolyhedra.cc.

References Create(), UVCSGfaceted::DeleteStuff(), UUtils::Exception(), fCorners, fEnclosingCylinder, fGenericPgon, UPolyhedraHistorical::fNumSide, UPolyhedraHistorical::fNumZPlanes, UPolyhedraHistorical::fOpeningAngle, fOriginalParameters, UPolyhedraHistorical::fStartAngle, UPolyhedraHistorical::fZValues, VUSolid::GetName(), UPolyhedraHistorical::Rmax, UPolyhedraHistorical::Rmin, and Warning.

Referenced by G4UPolyhedra::Reset().

 {
   if (fGenericPgon)
   {
     std::ostringstream message;
     message << "Solid " << GetName() << " built using generic construct."
             << std::endl << "Not applicable to the generic construct !";
     UUtils::Exception("UPolyhedra::Reset(,,)", "GeomSolids1001",
                       Warning, 1,  message.str().c_str());
     return 1;
   }
 
   //
   // Clear old setup
   //
   UVCSGfaceted::DeleteStuff();
   delete [] fCorners;
   delete fEnclosingCylinder;
 
   //
   // Rebuild polyhedra
   //
   UReduciblePolygon* rz =
     new UReduciblePolygon(&fOriginalParameters.Rmin[0],
                           &fOriginalParameters.Rmax[0],
                           &fOriginalParameters.fZValues[0],
                           fOriginalParameters.fNumZPlanes);
   Create(fOriginalParameters.fStartAngle,
          fOriginalParameters.fOpeningAngle,
          fOriginalParameters.fNumSide, rz);
   delete rz;
 
   return 0;
 }

double UPolyhedra::SafetyFromOutside	(	const UVector3 &	aPoint,
		bool	aAccurate = `false`
	)		const

virtual

Reimplemented from UVCSGfaceted.

Definition at line 523 of file UPolyhedra.cc.

References UVCSGfaceted::SafetyFromOutside().

 {
   return UVCSGfaceted::SafetyFromOutside(aPoint, aAccurate);
 }

void UPolyhedra::SetOriginalParameters ( UPolyhedraHistorical & pars )

inline

void UPolyhedra::SetOriginalParameters ( )

inlineprotected

Referenced by UPolyhedra().

std::ostream & UPolyhedra::StreamInfo ( std::ostream & os ) const

virtual

Reimplemented from UVCSGfaceted.

Definition at line 550 of file UPolyhedra.cc.

References fCorners, fEndPhi, fGenericPgon, fNumCorner, UPolyhedraHistorical::fNumZPlanes, fOriginalParameters, fStartPhi, UPolyhedraHistorical::fZValues, VUSolid::GetName(), UPolyhedraSideRZ::r, UPolyhedraHistorical::Rmax, UPolyhedraHistorical::Rmin, and UPolyhedraSideRZ::z.

 {
   int oldprc = os.precision(16);
   os << "-----------------------------------------------------------\n"
      << "    *** Dump for solid - " << GetName() << " ***\n"
      << "    ===================================================\n"
      << " Solid type: UPolyhedra\n"
      << " Parameters: \n"
      << "    starting phi angle : " << fStartPhi / (UUtils::kPi / 180.0) << " degrees \n"
      << "    ending phi angle   : " << fEndPhi / (UUtils::kPi / 180.0) << " degrees \n";
   int i = 0;
   if (!fGenericPgon)
   {
     int numPlanes = fOriginalParameters.fNumZPlanes;
     os << "    number of Z planes: " << numPlanes << "\n"
        << "              Z values: \n";
     for (i = 0; i < numPlanes; i++)
     {
       os << "              Z plane " << i << ": "
          << fOriginalParameters.fZValues[i] << "\n";
     }
     os << "              Tangent distances to inner surface (Rmin): \n";
     for (i = 0; i < numPlanes; i++)
     {
       os << "              Z plane " << i << ": "
          << fOriginalParameters.Rmin[i] << "\n";
     }
     os << "              Tangent distances to outer surface (Rmax): \n";
     for (i = 0; i < numPlanes; i++)
     {
       os << "              Z plane " << i << ": "
          << fOriginalParameters.Rmax[i] << "\n";
     }
   }
   os << "    number of RZ points: " << fNumCorner << "\n"
      << "              RZ values (fCorners): \n";
   for (i = 0; i < fNumCorner; i++)
   {
     os << "                         "
        << fCorners[i].r << ", " << fCorners[i].z << "\n";
   }
   os << "-----------------------------------------------------------\n";
   os.precision(oldprc);
 
   return os;
 }