#include <G4EllipticalTube.hh>

Inheritance diagram for G4EllipticalTube:

Public Member Functions
	G4EllipticalTube (const G4String &name, G4double theDx, G4double theDy, G4double theDz)

virtual	~G4EllipticalTube ()

G4bool	CalculateExtent (const EAxis pAxis, const G4VoxelLimits &pVoxelLimit, const G4AffineTransform &pTransform, G4double &pmin, G4double &pmax) const

EInside	Inside (const G4ThreeVector &p) const

G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const

G4double	DistanceToIn (const G4ThreeVector &p, const G4ThreeVector &v) const

G4double	DistanceToIn (const G4ThreeVector &p) const

G4double	DistanceToOut (const G4ThreeVector &p, const G4ThreeVector &v, const G4bool calcNorm=false, G4bool validNorm=0, G4ThreeVector n=0) const

G4double	DistanceToOut (const G4ThreeVector &p) const

G4GeometryType	GetEntityType () const

G4VSolid *	Clone () const

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

G4double	GetCubicVolume ()

G4double	GetSurfaceArea ()

G4ThreeVector	GetPointOnSurface () const

G4Polyhedron *	CreatePolyhedron () const

G4Polyhedron *	GetPolyhedron () const

void	DescribeYourselfTo (G4VGraphicsScene &scene) const

G4VisExtent	GetExtent () const

G4double	GetDx () const

G4double	GetDy () const

G4double	GetDz () const

void	SetDx (const G4double newDx)

void	SetDy (const G4double newDy)

void	SetDz (const G4double newDz)

	G4EllipticalTube (__void__ &)

	G4EllipticalTube (const G4EllipticalTube &rhs)

G4EllipticalTube &	operator= (const G4EllipticalTube &rhs)

Public Member Functions inherited from G4VSolid
	G4VSolid (const G4String &name)

virtual	~G4VSolid ()

G4bool	operator== (const G4VSolid &s) const

G4String	GetName () const

void	SetName (const G4String &name)

G4double	GetTolerance () const

virtual void	ComputeDimensions (G4VPVParameterisation p, const G4int n, const G4VPhysicalVolume pRep)

void	DumpInfo () const

virtual const G4VSolid *	GetConstituentSolid (G4int no) const

virtual G4VSolid *	GetConstituentSolid (G4int no)

virtual const G4DisplacedSolid *	GetDisplacedSolidPtr () const

virtual G4DisplacedSolid *	GetDisplacedSolidPtr ()

	G4VSolid (__void__ &)

	G4VSolid (const G4VSolid &rhs)

G4VSolid &	operator= (const G4VSolid &rhs)

Protected Member Functions
G4double	CheckXY (const G4double x, const G4double y, const G4double toler) const

G4double	CheckXY (const G4double x, const G4double y) const

G4int	IntersectXY (const G4ThreeVector &p, const G4ThreeVector &v, G4double s[2]) const

Protected Member Functions inherited from G4VSolid
void	CalculateClippedPolygonExtent (G4ThreeVectorList &pPolygon, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const

void	ClipCrossSection (G4ThreeVectorList *pVertices, const G4int pSectionIndex, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const

void	ClipBetweenSections (G4ThreeVectorList *pVertices, const G4int pSectionIndex, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const

void	ClipPolygon (G4ThreeVectorList &pPolygon, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis) const

G4double	EstimateCubicVolume (G4int nStat, G4double epsilon) const

G4double	EstimateSurfaceArea (G4int nStat, G4double ell) const

Protected Attributes
G4double	dx

G4double	dy

G4double	dz

Protected Attributes inherited from G4VSolid
G4double	kCarTolerance

Detailed Description

Definition at line 55 of file G4EllipticalTube.hh.

Constructor & Destructor Documentation

G4EllipticalTube::G4EllipticalTube	(	const G4String &	name,
		G4double	theDx,
		G4double	theDy,
		G4double	theDz
	)

Definition at line 60 of file G4EllipticalTube.cc.

References dx, dy, dz, and G4VSolid::kCarTolerance.

Referenced by Clone().

   : G4VSolid( name ), fCubicVolume(0.), fSurfaceArea(0.), fpPolyhedron(0)
 {
   halfTol = 0.5*kCarTolerance;
 
   dx = theDx;
   dy = theDy;
   dz = theDz;
 }

G4EllipticalTube::~G4EllipticalTube ( )

virtual

Definition at line 88 of file G4EllipticalTube.cc.

 {
   delete fpPolyhedron;
 }

G4EllipticalTube::G4EllipticalTube ( __void__ & a )

Definition at line 78 of file G4EllipticalTube.cc.

   : G4VSolid(a), dx(0.), dy(0.), dz(0.), halfTol(0.),
     fCubicVolume(0.), fSurfaceArea(0.), fpPolyhedron(0)
 {
 }

G4EllipticalTube::G4EllipticalTube ( const G4EllipticalTube & rhs )

Definition at line 97 of file G4EllipticalTube.cc.

   : G4VSolid(rhs), dx(rhs.dx), dy(rhs.dy), dz(rhs.dz), halfTol(rhs.halfTol),
     fCubicVolume(rhs.fCubicVolume), fSurfaceArea(rhs.fSurfaceArea),
     fpPolyhedron(0)
 {
 }

Member Function Documentation

G4bool G4EllipticalTube::CalculateExtent	(	const EAxis	pAxis,
		const G4VoxelLimits &	pVoxelLimit,
		const G4AffineTransform &	pTransform,
		G4double &	pmin,
		G4double &	pmax
	)		const

virtual

Implements G4VSolid.

Definition at line 133 of file G4EllipticalTube.cc.

References G4SolidExtentList::AddSurface(), G4ClippablePolygon::AddVertexInOrder(), G4AffineTransform::ApplyPointTransform(), G4ClippablePolygon::ClearAllVertices(), dx, dy, dz, G4SolidExtentList::GetExtent(), kMaxMeshSections, G4ClippablePolygon::PartialClip(), G4ClippablePolygon::SetNormal(), G4AffineTransform::TransformAxis(), and python.hepunit::twopi.

 {
   G4SolidExtentList  extentList( axis, voxelLimit );
   
   //
   // We are going to divide up our elliptical face into small
   // pieces
   //
   
   //
   // Choose phi size of our segment(s) based on constants as
   // defined in meshdefs.hh
   //
   G4int numPhi = kMaxMeshSections;
   G4double sigPhi = twopi/numPhi;
   
   //
   // We have to be careful to keep our segments completely outside
   // of the elliptical surface. To do so we imagine we have
   // a simple (unit radius) circular cross section (as in G4Tubs) 
   // and then "stretch" the dimensions as necessary to fit the ellipse.
   //
   G4double rFudge = 1.0/std::cos(0.5*sigPhi);
   G4double dxFudge = dx*rFudge,
            dyFudge = dy*rFudge;
   
   //
   // As we work around the elliptical surface, we build
   // a "phi" segment on the way, and keep track of two
   // additional polygons for the two ends.
   //
   G4ClippablePolygon endPoly1, endPoly2, phiPoly;
   
   G4double phi = 0, 
            cosPhi = std::cos(phi),
            sinPhi = std::sin(phi);
   G4ThreeVector v0( dxFudge*cosPhi, dyFudge*sinPhi, +dz ),
                 v1( dxFudge*cosPhi, dyFudge*sinPhi, -dz ),
                 w0, w1;
   transform.ApplyPointTransform( v0 );
   transform.ApplyPointTransform( v1 );
   do
   {
     phi += sigPhi;
     if (numPhi == 1) phi = 0;  // Try to avoid roundoff
     cosPhi = std::cos(phi), 
     sinPhi = std::sin(phi);
     
     w0 = G4ThreeVector( dxFudge*cosPhi, dyFudge*sinPhi, +dz );
     w1 = G4ThreeVector( dxFudge*cosPhi, dyFudge*sinPhi, -dz );
     transform.ApplyPointTransform( w0 );
     transform.ApplyPointTransform( w1 );
     
     //
     // Add a point to our z ends
     //
     endPoly1.AddVertexInOrder( v0 );
     endPoly2.AddVertexInOrder( v1 );
     
     //
     // Build phi polygon
     //
     phiPoly.ClearAllVertices();
     
     phiPoly.AddVertexInOrder( v0 );
     phiPoly.AddVertexInOrder( v1 );
     phiPoly.AddVertexInOrder( w1 );
     phiPoly.AddVertexInOrder( w0 );
     
     if (phiPoly.PartialClip( voxelLimit, axis ))
     {
       //
       // Get unit normal
       //
       phiPoly.SetNormal( (v1-v0).cross(w0-v0).unit() );
       
       extentList.AddSurface( phiPoly );
     }
 
     //
     // Next vertex
     //    
     v0 = w0;
     v1 = w1;
   } while( --numPhi > 0 );
 
   //
   // Process the end pieces
   //
   if (endPoly1.PartialClip( voxelLimit, axis ))
   {
     static const G4ThreeVector normal(0,0,+1);
     endPoly1.SetNormal( transform.TransformAxis(normal) );
     extentList.AddSurface( endPoly1 );
   }
   
   if (endPoly2.PartialClip( voxelLimit, axis ))
   {
     static const G4ThreeVector normal(0,0,-1);
     endPoly2.SetNormal( transform.TransformAxis(normal) );
     extentList.AddSurface( endPoly2 );
   }
   
   //
   // Return min/max value
   //
   return extentList.GetExtent( min, max );
 }

G4double G4EllipticalTube::CheckXY	(	const G4double	x,
		const G4double	y,
		const G4double	toler
	)		const

inlineprotected

Referenced by DistanceToIn(), DistanceToOut(), Inside(), and SurfaceNormal().

G4double G4EllipticalTube::CheckXY	(	const G4double	x,
		const G4double	y
	)		const

inlineprotected

G4VSolid * G4EllipticalTube::Clone ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 850 of file G4EllipticalTube.cc.

References G4EllipticalTube().

 {
   return new G4EllipticalTube(*this);
 }

G4Polyhedron * G4EllipticalTube::CreatePolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 953 of file G4EllipticalTube.cc.

References dx, dz, and HepPolyhedron::Transform().

Referenced by GetPolyhedron().

 {
   // create cylinder with radius=1...
   //
   G4Polyhedron* eTube = new G4PolyhedronTube(0.,1.,dz);
 
   // apply non-uniform scaling...
   //
   eTube->Transform(G4Scale3D(dx,dy,1.));
   return  eTube;
 }

void G4EllipticalTube::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

virtual

Implements G4VSolid.

Definition at line 985 of file G4EllipticalTube.cc.

References G4VGraphicsScene::AddSolid().

 {
   scene.AddSolid (*this);
 }

G4double G4EllipticalTube::DistanceToIn	(	const G4ThreeVector &	p,
		const G4ThreeVector &	v
	)		const

virtual

Implements G4VSolid.

Definition at line 367 of file G4EllipticalTube.cc.

References CheckXY(), dx, dz, IntersectXY(), n, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

 {
   //
   // Check z = -dz planer surface
   //
   G4double sigz = p.z()+dz;
 
   if (sigz < halfTol)
   {
     //
     // We are "behind" the shape in z, and so can
     // potentially hit the rear face. Correct direction?
     //
     if (v.z() <= 0)
     {
       //
       // As long as we are far enough away, we know we
       // can't intersect
       //
       if (sigz < 0) return kInfinity;
       
       //
       // Otherwise, we don't intersect unless we are
       // on the surface of the ellipse
       //
       if (CheckXY(p.x(),p.y(),-halfTol) <= 1.0) return kInfinity;
     }
     else
     {
       //
       // How far?
       //
       G4double q = -sigz/v.z();
       
       //
       // Where does that place us?
       //
       G4double xi = p.x() + q*v.x(),
                yi = p.y() + q*v.y();
       
       //
       // Is this on the surface (within ellipse)?
       //
       if (CheckXY(xi,yi) <= 1.0)
       {
         //
         // Yup. Return q, unless we are on the surface
         //
         return (sigz < -halfTol) ? q : 0;
       }
       else if (xi*dy*dy*v.x() + yi*dx*dx*v.y() >= 0)
       {
         //
         // Else, if we are traveling outwards, we know
         // we must miss
         //
         return kInfinity;
       }
     }
   }
 
   //
   // Check z = +dz planer surface
   //
   sigz = p.z() - dz;
   
   if (sigz > -halfTol)
   {
     if (v.z() >= 0)
     {
       if (sigz > 0) return kInfinity;
       if (CheckXY(p.x(),p.y(),-halfTol) <= 1.0) return kInfinity;
     }
     else {
       G4double q = -sigz/v.z();
 
       G4double xi = p.x() + q*v.x(),
                yi = p.y() + q*v.y();
       
       if (CheckXY(xi,yi) <= 1.0)
       {
         return (sigz > -halfTol) ? q : 0;
       }
       else if (xi*dy*dy*v.x() + yi*dx*dx*v.y() >= 0)
       {
         return kInfinity;
       }
     }
   }
   
   //
   // Check intersection with the elliptical tube
   //
   G4double q[2];
   G4int n = IntersectXY( p, v, q );
   
   if (n==0) return kInfinity;
   
   //
   // Is the original point on the surface?
   //
   if (std::fabs(p.z()) < dz+halfTol) {
     if (CheckXY( p.x(), p.y(), halfTol ) < 1.0)
     {
       //
       // Well, yes, but are we traveling inwards at this point?
       //
       if (p.x()*dy*dy*v.x() + p.y()*dx*dx*v.y() < 0) return 0;
     }
   }
   
   //
   // We are now certain that point p is not on the surface of 
   // the solid (and thus std::fabs(q[0]) > halfTol). 
   // Return kInfinity if the intersection is "behind" the point.
   //
   if (q[0] < 0) return kInfinity;
   
   //
   // Check to see if we intersect the tube within
   // dz, but only when we know it might miss
   //
   G4double zi = p.z() + q[0]*v.z();
 
   if (v.z() < 0)
   {
     if (zi < -dz) return kInfinity;
   }
   else if (v.z() > 0)
   {
     if (zi > +dz) return kInfinity;
   }
 
   return q[0];
 }

G4double G4EllipticalTube::DistanceToIn ( const G4ThreeVector & p ) const

virtual

Implements G4VSolid.

Definition at line 523 of file G4EllipticalTube.cc.

References CheckXY(), DBL_MIN, dx, dy, dz, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

 {  
   if (CheckXY( p.x(), p.y(), +halfTol ) < 1.0)
   {
     //
     // We are inside or on the surface of the
     // elliptical cross section in x/y. Check z
     //
     if (p.z() < -dz-halfTol) 
       return -p.z()-dz;
     else if (p.z() > dz+halfTol)
       return p.z()-dz;
     else
       return 0;    // On any surface here (or inside)
   }
   
   //
   // Find point on ellipse
   //
   G4double qnorm = CheckXY( p.x(), p.y() );
   if (qnorm < DBL_MIN) return 0;  // This should never happen
   
   G4double q = 1.0/std::sqrt(qnorm);
   
   G4double xe = q*p.x(), ye = q*p.y();
      
   //
   // Get tangent to ellipse
   //
   G4double tx = -ye*dx*dx, ty = +xe*dy*dy;
   G4double tnorm = std::sqrt( tx*tx + ty*ty );
   
   //
   // Calculate distance
   //
   G4double distR = ( (p.x()-xe)*ty - (p.y()-ye)*tx )/tnorm;
   
   //
   // Add the result in quadrature if we are, in addition,
   // outside the z bounds of the shape
   //
   // We could save some time by returning the maximum rather
   // than the quadrature sum
   //
   if (p.z() < -dz) 
     return std::sqrt( (p.z()+dz)*(p.z()+dz) + distR*distR );
   else if (p.z() > dz)
     return std::sqrt( (p.z()-dz)*(p.z()-dz) + distR*distR );
 
   return distR;
 }

G4double G4EllipticalTube::DistanceToOut	(	const G4ThreeVector &	p,
		const G4ThreeVector &	v,
		const G4bool	calcNorm = `false`,
		G4bool *	validNorm = `0`,
		G4ThreeVector *	n = `0`
	)		const

virtual

Implements G4VSolid.

Definition at line 584 of file G4EllipticalTube.cc.

References CheckXY(), G4VSolid::DumpInfo(), dx, dy, dz, G4endl, G4Exception(), IntersectXY(), JustWarning, python.hepunit::mm, n, test::v, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

 {
   //
   // Our normal is always valid
   //
   if (calcNorm)  { *validNorm = true; }
   
   G4double sBest = kInfinity;
   G4ThreeVector nBest(0,0,0);
   
   //
   // Might we intersect the -dz surface?
   //
   if (v.z() < 0)
   {
     static const G4ThreeVector normHere(0.0,0.0,-1.0);
     //
     // Yup. What distance?
     //
     sBest = -(p.z()+dz)/v.z();
     
     //
     // Are we on the surface? If so, return zero
     //
     if (p.z() < -dz+halfTol)
     {
       if (calcNorm)  { *norm = normHere; }
       return 0;
     }
     else
     {
       nBest = normHere;
     }
   }
   
   //
   // How about the +dz surface?
   //
   if (v.z() > 0)
   {
     static const G4ThreeVector normHere(0.0,0.0,+1.0);
     //
     // Yup. What distance?
     //
     G4double q = (dz-p.z())/v.z();
     
     //
     // Are we on the surface? If so, return zero
     //
     if (p.z() > +dz-halfTol)
     {
       if (calcNorm)  { *norm = normHere; }
       return 0;
     }
     
     //
     // Best so far?
     //
     if (q < sBest) { sBest = q; nBest = normHere; }
   }
   
   //
   // Check furthest intersection with ellipse 
   //
   G4double q[2];
   G4int n = IntersectXY( p, v, q );
 
   if (n == 0)
   {
     if (sBest == kInfinity)
     {
       DumpInfo();
       std::ostringstream message;
       G4int oldprc = message.precision(16) ;
       message << "Point p is outside !?" << G4endl
               << "Position:"  << G4endl
               << "   p.x() = "   << p.x()/mm << " mm" << G4endl
               << "   p.y() = "   << p.y()/mm << " mm" << G4endl
               << "   p.z() = "   << p.z()/mm << " mm" << G4endl
               << "Direction:" << G4endl << G4endl
               << "   v.x() = "   << v.x() << G4endl
               << "   v.y() = "   << v.y() << G4endl
               << "   v.z() = "   << v.z() << G4endl
               << "Proposed distance :" << G4endl
               << "   snxt = "    << sBest/mm << " mm";
       message.precision(oldprc) ;
       G4Exception( "G4EllipticalTube::DistanceToOut(p,v,...)",
                    "GeomSolids1002", JustWarning, message);
     }
     if (calcNorm)  { *norm = nBest; }
     return sBest;
   }
   else if (q[n-1] > sBest)
   {
     if (calcNorm)  { *norm = nBest; }
     return sBest;
   }  
   sBest = q[n-1];
       
   //
   // Intersection with ellipse. Get normal at intersection point.
   //
   if (calcNorm)
   {
     G4ThreeVector ip = p + sBest*v;
     *norm = G4ThreeVector( ip.x()*dy*dy, ip.y()*dx*dx, 0.0 ).unit();
   }
   
   //
   // Do we start on the surface?
   //
   if (CheckXY( p.x(), p.y(), -halfTol ) > 1.0)
   {
     //
     // Well, yes, but are we traveling outwards at this point?
     //
     if (p.x()*dy*dy*v.x() + p.y()*dx*dx*v.y() > 0) return 0;
   }
   
   return sBest;
 }

G4double G4EllipticalTube::DistanceToOut ( const G4ThreeVector & p ) const

virtual

Implements G4VSolid.

Definition at line 723 of file G4EllipticalTube.cc.

References DBL_MIN, dx, dy, dz, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

 {
   //
   // We need to calculate the distances to all surfaces,
   // and then return the smallest
   //
   // Check -dz and +dz surface
   //
   G4double sBest = dz - std::fabs(p.z());
   if (sBest < halfTol) return 0;
   
   //
   // Check elliptical surface: find intersection of
   // line through p and parallel to x axis
   //
   G4double radical = 1.0 - p.y()*p.y()/dy/dy;
   if (radical < +DBL_MIN) return 0;
   
   G4double xi = dx*std::sqrt( radical );
   if (p.x() < 0) xi = -xi;
   
   //
   // Do the same with y axis
   //
   radical = 1.0 - p.x()*p.x()/dx/dx;
   if (radical < +DBL_MIN) return 0;
   
   G4double yi = dy*std::sqrt( radical );
   if (p.y() < 0) yi = -yi;
   
   //
   // Get distance from p to the line connecting
   // these two points
   //
   G4double xdi = p.x() - xi,
      ydi = yi - p.y();
 
   G4double normi = std::sqrt( xdi*xdi + ydi*ydi );
   if (normi < halfTol) return 0;
   xdi /= normi;
   ydi /= normi;
   
   G4double q = 0.5*(xdi*(p.y()-yi) - ydi*(p.x()-xi));
   if (xi*yi < 0) q = -q;
   
   if (q < sBest) sBest = q;
   
   //
   // Return best answer
   //
   return sBest < halfTol ? 0 : sBest;
 }

G4double G4EllipticalTube::GetCubicVolume ( )

virtual

Reimplemented from G4VSolid.

Definition at line 859 of file G4EllipticalTube.cc.

References G4VSolid::GetCubicVolume().

 {
   if(fCubicVolume != 0.) {;}
     else { fCubicVolume = G4VSolid::GetCubicVolume(); }
   return fCubicVolume;
 }

G4double G4EllipticalTube::GetDx ( ) const

inline

Referenced by G4GDMLWriteSolids::EltubeWrite(), export_G4EllipticalTube(), and G4tgbGeometryDumper::GetSolidParams().

G4double G4EllipticalTube::GetDy ( ) const

inline

Referenced by G4GDMLWriteSolids::EltubeWrite(), export_G4EllipticalTube(), and G4tgbGeometryDumper::GetSolidParams().

G4double G4EllipticalTube::GetDz ( ) const

inline

Referenced by G4GDMLWriteSolids::EltubeWrite(), export_G4EllipticalTube(), and G4tgbGeometryDumper::GetSolidParams().

G4GeometryType G4EllipticalTube::GetEntityType ( ) const

virtual

Implements G4VSolid.

Definition at line 841 of file G4EllipticalTube.cc.

 {
   return G4String("G4EllipticalTube");
 }

G4VisExtent G4EllipticalTube::GetExtent ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 994 of file G4EllipticalTube.cc.

References dx, and dz.

 {
   return G4VisExtent( -dx, dx, -dy, dy, -dz, dz );
 }

G4ThreeVector G4EllipticalTube::GetPointOnSurface ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 903 of file G4EllipticalTube.cc.

References dx, dy, dz, python.hepunit::pi, G4INCL::DeJongSpin::shoot(), and sqr().

 {
   G4double xRand, yRand, zRand, phi, cosphi, sinphi, zArea, cArea,p, chose;
 
   phi    = RandFlat::shoot(0., 2.*pi);
   cosphi = std::cos(phi);
   sinphi = std::sin(phi);
   
   // the ellipse perimeter from: "http://mathworld.wolfram.com/Ellipse.html"
   //   m = (dx - dy)/(dx + dy);
   //   k = 1.+1./4.*m*m+1./64.*sqr(m)*sqr(m)+1./256.*sqr(m)*sqr(m)*sqr(m);
   //   p = pi*(a+b)*k;
 
   // perimeter below from "http://www.efunda.com/math/areas/EllipseGen.cfm"
 
   p = 2.*pi*std::sqrt(0.5*(dx*dx+dy*dy));
 
   cArea = 2.*dz*p;
   zArea = pi*dx*dy;
 
   xRand = dx*cosphi;
   yRand = dy*sinphi;
   zRand = RandFlat::shoot(dz, -1.*dz);
     
   chose = RandFlat::shoot(0.,2.*zArea+cArea);
   
   if( (chose>=0) && (chose < cArea) )
   {
     return G4ThreeVector (xRand,yRand,zRand);
   }
   else if( (chose >= cArea) && (chose < cArea + zArea) )
   {
     xRand = RandFlat::shoot(-1.*dx,dx);
     yRand = std::sqrt(1.-sqr(xRand/dx));
     yRand = RandFlat::shoot(-1.*yRand, yRand);
     return G4ThreeVector (xRand,yRand,dz); 
   }
   else
   { 
     xRand = RandFlat::shoot(-1.*dx,dx);
     yRand = std::sqrt(1.-sqr(xRand/dx));
     yRand = RandFlat::shoot(-1.*yRand, yRand);
     return G4ThreeVector (xRand,yRand,-1.*dz);
   }
 }

G4Polyhedron * G4EllipticalTube::GetPolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 969 of file G4EllipticalTube.cc.

References CreatePolyhedron(), HepPolyhedron::GetNumberOfRotationSteps(), and G4Polyhedron::GetNumberOfRotationStepsAtTimeOfCreation().

 {
   if (!fpPolyhedron ||
       fpPolyhedron->GetNumberOfRotationStepsAtTimeOfCreation() !=
       fpPolyhedron->GetNumberOfRotationSteps())
     {
       delete fpPolyhedron;
       fpPolyhedron = CreatePolyhedron();
     }
   return fpPolyhedron;
 }

G4double G4EllipticalTube::GetSurfaceArea ( )

virtual

Reimplemented from G4VSolid.

Definition at line 869 of file G4EllipticalTube.cc.

References G4VSolid::GetSurfaceArea().

 {
   if(fSurfaceArea != 0.) {;}
   else   { fSurfaceArea = G4VSolid::GetSurfaceArea(); }
   return fSurfaceArea;
 }

EInside G4EllipticalTube::Inside ( const G4ThreeVector & p ) const

virtual

Implements G4VSolid.

Definition at line 253 of file G4EllipticalTube.cc.

References CheckXY(), dz, kInside, kOutside, kSurface, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

 {
   //
   // Check z extents: are we outside?
   //
   G4double absZ = std::fabs(p.z());
   if (absZ > dz+halfTol) return kOutside;
   
   //
   // Check x,y: are we outside?
   //
   // G4double x = p.x(), y = p.y();
   
   if (CheckXY(p.x(), p.y(), +halfTol) > 1.0) return kOutside;
   
   //
   // We are either inside or on the surface: recheck z extents
   //
   if (absZ > dz-halfTol) return kSurface;
   
   //
   // Recheck x,y
   //
   if (CheckXY(p.x(), p.y(), -halfTol) > 1.0) return kSurface;
   
   return kInside;
 }

G4int G4EllipticalTube::IntersectXY	(	const G4ThreeVector &	p,
		const G4ThreeVector &	v,
		G4double	s[2]
	)		const

protected

Definition at line 802 of file G4EllipticalTube.cc.

References test::a, test::b, test::c, DBL_MIN, dx, dy, CLHEP::Hep3Vector::x(), and CLHEP::Hep3Vector::y().

Referenced by DistanceToIn(), and DistanceToOut().

 {
   G4double px = p.x(), py = p.y();
   G4double vx = v.x(), vy = v.y();
   
   G4double a = (vx/dx)*(vx/dx) + (vy/dy)*(vy/dy);
   G4double b = 2.0*( px*vx/dx/dx + py*vy/dy/dy );
   G4double c = (px/dx)*(px/dx) + (py/dy)*(py/dy) - 1.0;
   
   if (a < DBL_MIN) return 0;      // Trajectory parallel to z axis
   
   G4double radical = b*b - 4*a*c;
   
   if (radical < -DBL_MIN) return 0;    // No solution
   
   if (radical < DBL_MIN)
   {
     //
     // Grazes surface
     //
     ss[0] = -b/a/2.0;
     return 1;
   }
   
   radical = std::sqrt(radical);
   
   G4double q = -0.5*( b + (b < 0 ? -radical : +radical) );
   G4double sa = q/a;
   G4double sb = c/q;    
   if (sa < sb) { ss[0] = sa; ss[1] = sb; } else { ss[0] = sb; ss[1] = sa; }
   return 2;
 }

G4EllipticalTube & G4EllipticalTube::operator= ( const G4EllipticalTube & rhs )

Definition at line 108 of file G4EllipticalTube.cc.

References dx, dy, dz, and G4VSolid::operator=().

 {
    // Check assignment to self
    //
    if (this == &rhs)  { return *this; }
 
    // Copy base class data
    //
    G4VSolid::operator=(rhs);
 
    // Copy data
    //
    dx = rhs.dx; dy = rhs.dy; dz = rhs.dz;
    halfTol = rhs.halfTol;
    fCubicVolume = rhs.fCubicVolume; fSurfaceArea = rhs.fSurfaceArea;
    fpPolyhedron = 0;
 
    return *this;
 }

void G4EllipticalTube::SetDx ( const G4double newDx )

inline

Referenced by export_G4EllipticalTube().

void G4EllipticalTube::SetDy ( const G4double newDy )

inline

Referenced by export_G4EllipticalTube().

void G4EllipticalTube::SetDz ( const G4double newDz )

inline

Referenced by export_G4EllipticalTube().

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

virtual

Implements G4VSolid.

Definition at line 879 of file G4EllipticalTube.cc.

References dx, dz, G4VSolid::GetName(), and python.hepunit::mm.

 {
   G4int oldprc = os.precision(16);
   os << "-----------------------------------------------------------\n"
      << "    *** Dump for solid - " << GetName() << " ***\n"
      << "    ===================================================\n"
      << " Solid type: G4EllipticalTube\n"
      << " Parameters: \n"
      << "    length Z: " << dz/mm << " mm \n"
      << "    surface equation in X and Y: \n"
      << "       (X / " << dx << ")^2 + (Y / " << dy << ")^2 = 1 \n"
      << "-----------------------------------------------------------\n";
   os.precision(oldprc);
 
   return os;
 }

G4ThreeVector G4EllipticalTube::SurfaceNormal ( const G4ThreeVector & p ) const

virtual

Implements G4VSolid.

Definition at line 285 of file G4EllipticalTube.cc.

References CheckXY(), dx, dy, dz, G4Exception(), JustWarning, CLHEP::Hep3Vector::unit(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

 {
   //
   // SurfaceNormal for the point On the Surface, sum the normals on the Corners
   //
 
   G4int noSurfaces=0;
   G4ThreeVector norm, sumnorm(0.,0.,0.);
 
   G4double distZ = std::fabs(std::fabs(p.z()) - dz);
   
   G4double distR1 = CheckXY( p.x(), p.y(),+ halfTol );
   G4double distR2 = CheckXY( p.x(), p.y(),- halfTol );
  
   if (  (distZ  < halfTol ) && ( distR1 <= 1 ) )
   {
     noSurfaces++;
     sumnorm=G4ThreeVector( 0.0, 0.0, p.z() < 0 ? -1.0 : 1.0 );
   }
   if( (distR1 <= 1 ) && ( distR2 >= 1 ) )
   {
     noSurfaces++;
     norm= G4ThreeVector( p.x()*dy*dy, p.y()*dx*dx, 0.0 ).unit();
     sumnorm+=norm;
   }
   if ( noSurfaces == 0 )
   {
 #ifdef G4SPECSDEBUG
     G4Exception("G4EllipticalTube::SurfaceNormal(p)", "GeomSolids1002",
                 JustWarning, "Point p is not on surface !?" );
 #endif 
     norm = ApproxSurfaceNormal(p);
   }
   else if ( noSurfaces == 1 )  { norm = sumnorm; }
   else                         { norm = sumnorm.unit(); }
  
   return norm;
 }