#include <G4EllipticalTube.hh>

Inheritance diagram for G4EllipticalTube:

Collaboration 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)

G4double	EstimateCubicVolume (G4int nStat, G4double epsilon) const

G4double	EstimateSurfaceArea (G4int nStat, G4double ell) const

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

Protected Attributes
G4double	dx

G4double	dy

G4double	dz

Protected Attributes inherited from G4VSolid
G4double	kCarTolerance

Private Member Functions
G4ThreeVector	ApproxSurfaceNormal (const G4ThreeVector &p) const

Private Attributes
G4double	halfTol

G4double	fCubicVolume

G4double	fSurfaceArea

G4bool	fRebuildPolyhedron

G4Polyhedron *	fpPolyhedron

Detailed Description

Definition at line 56 of file G4EllipticalTube.hh.

Constructor & Destructor Documentation

◆ G4EllipticalTube() [1/3]

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

Definition at line 66 of file G4EllipticalTube.cc.

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

Here is the caller graph for this function:

◆ ~G4EllipticalTube()

G4EllipticalTube::~G4EllipticalTube ( )

virtual

Definition at line 96 of file G4EllipticalTube.cc.

 {
   delete fpPolyhedron;  fpPolyhedron = 0;
 }

◆ G4EllipticalTube() [2/3]

G4EllipticalTube::G4EllipticalTube ( __void__ & a )

Definition at line 85 of file G4EllipticalTube.cc.

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

◆ G4EllipticalTube() [3/3]

G4EllipticalTube::G4EllipticalTube ( const G4EllipticalTube & rhs )

Definition at line 105 of file G4EllipticalTube.cc.

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

Member Function Documentation

◆ ApproxSurfaceNormal()

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

private

Definition at line 338 of file G4EllipticalTube.cc.

 {
   //
   // Which of the three surfaces are we closest to (approximatively)?
   //
   G4double distZ = std::fabs(p.z()) - dz;
   
   G4double rxy = CheckXY( p.x(), p.y() );
   G4double distR2 = (rxy < DBL_MIN) ? DBL_MAX : 1.0/rxy;
 
   //
   // Closer to z?
   //
   if (distZ*distZ < distR2)
   {
     return G4ThreeVector( 0.0, 0.0, p.z() < 0 ? -1.0 : 1.0 );
   }
 
   //
   // Closer to x/y
   //
   return G4ThreeVector( p.x()*dy*dy, p.y()*dx*dx, 0.0 ).unit();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CalculateExtent()

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

virtual

Implements G4VSolid.

Definition at line 142 of file G4EllipticalTube.cc.

 {
   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    // Loop checking, 13.08.2015, G.Cosmo
   {
     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 );
 }

Here is the call graph for this function:

◆ CheckXY() [1/2]

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

inlineprotected

Here is the caller graph for this function:

◆ CheckXY() [2/2]

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

inlineprotected

◆ Clone()

G4VSolid * G4EllipticalTube::Clone ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 859 of file G4EllipticalTube.cc.

 {
   return new G4EllipticalTube(*this);
 }

Here is the call graph for this function:

◆ CreatePolyhedron()

G4Polyhedron * G4EllipticalTube::CreatePolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 962 of file G4EllipticalTube.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DescribeYourselfTo()

void G4EllipticalTube::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

virtual

Implements G4VSolid.

Definition at line 998 of file G4EllipticalTube.cc.

 {
   scene.AddSolid (*this);
 }

Here is the call graph for this function:

◆ DistanceToIn() [1/2]

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

virtual

Implements G4VSolid.

Definition at line 376 of file G4EllipticalTube.cc.

 {
   //
   // 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];
 }

Here is the call graph for this function:

◆ DistanceToIn() [2/2]

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

virtual

Implements G4VSolid.

Definition at line 532 of file G4EllipticalTube.cc.

 {  
   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;
 }

Here is the call graph for this function:

◆ DistanceToOut() [1/2]

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 593 of file G4EllipticalTube.cc.

 {
   //
   // 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;
 }

Here is the call graph for this function:

◆ DistanceToOut() [2/2]

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

virtual

Implements G4VSolid.

Definition at line 732 of file G4EllipticalTube.cc.

 {
   //
   // 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;
 }

Here is the call graph for this function:

◆ GetCubicVolume()

G4double G4EllipticalTube::GetCubicVolume ( )

virtual

Reimplemented from G4VSolid.

Definition at line 868 of file G4EllipticalTube.cc.

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

Here is the call graph for this function:

◆ GetDx()

G4double G4EllipticalTube::GetDx ( ) const

inline

Here is the caller graph for this function:

◆ GetDy()

G4double G4EllipticalTube::GetDy ( ) const

inline

Here is the caller graph for this function:

◆ GetDz()

G4double G4EllipticalTube::GetDz ( ) const

inline

Here is the caller graph for this function:

◆ GetEntityType()

G4GeometryType G4EllipticalTube::GetEntityType ( ) const

virtual

Implements G4VSolid.

Definition at line 850 of file G4EllipticalTube.cc.

 {
   return G4String("G4EllipticalTube");
 }

◆ GetExtent()

G4VisExtent G4EllipticalTube::GetExtent ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1007 of file G4EllipticalTube.cc.

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

◆ GetPointOnSurface()

G4ThreeVector G4EllipticalTube::GetPointOnSurface ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 912 of file G4EllipticalTube.cc.

 {
   G4double xRand, yRand, zRand, phi, cosphi, sinphi, zArea, cArea,p, chose;
 
   phi    = G4RandFlat::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 = G4RandFlat::shoot(dz, -1.*dz);
     
   chose = G4RandFlat::shoot(0.,2.*zArea+cArea);
   
   if( (chose>=0) && (chose < cArea) )
   {
     return G4ThreeVector (xRand,yRand,zRand);
   }
   else if( (chose >= cArea) && (chose < cArea + zArea) )
   {
     xRand = G4RandFlat::shoot(-1.*dx,dx);
     yRand = std::sqrt(1.-sqr(xRand/dx));
     yRand = G4RandFlat::shoot(-1.*yRand, yRand);
     return G4ThreeVector (xRand,yRand,dz); 
   }
   else
   { 
     xRand = G4RandFlat::shoot(-1.*dx,dx);
     yRand = std::sqrt(1.-sqr(xRand/dx));
     yRand = G4RandFlat::shoot(-1.*yRand, yRand);
     return G4ThreeVector (xRand,yRand,-1.*dz);
   }
 }

Here is the call graph for this function:

◆ GetPolyhedron()

G4Polyhedron * G4EllipticalTube::GetPolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 978 of file G4EllipticalTube.cc.

 {
   if (!fpPolyhedron ||
       fRebuildPolyhedron ||
       fpPolyhedron->GetNumberOfRotationStepsAtTimeOfCreation() !=
       fpPolyhedron->GetNumberOfRotationSteps())
     {
       G4AutoLock l(&polyhedronMutex);
       delete fpPolyhedron;
       fpPolyhedron = CreatePolyhedron();
       fRebuildPolyhedron = false;
       l.unlock();
     }
   return fpPolyhedron;
 }

Here is the call graph for this function:

◆ GetSurfaceArea()

G4double G4EllipticalTube::GetSurfaceArea ( )

virtual

Reimplemented from G4VSolid.

Definition at line 878 of file G4EllipticalTube.cc.

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

Here is the call graph for this function:

◆ Inside()

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

virtual

Implements G4VSolid.

Definition at line 262 of file G4EllipticalTube.cc.

 {
   //
   // 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;
 }

Here is the call graph for this function:

◆ IntersectXY()

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

protected

Definition at line 811 of file G4EllipticalTube.cc.

 {
   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;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator=()

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

Definition at line 116 of file G4EllipticalTube.cc.

 {
    // 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;
    fRebuildPolyhedron = false;
    delete fpPolyhedron; fpPolyhedron = 0;
 
    return *this;
 }

Here is the call graph for this function:

◆ SetDx()

void G4EllipticalTube::SetDx ( const G4double newDx )

inline

Here is the caller graph for this function:

◆ SetDy()

void G4EllipticalTube::SetDy ( const G4double newDy )

inline

Here is the caller graph for this function:

◆ SetDz()

void G4EllipticalTube::SetDz ( const G4double newDz )

inline

Here is the caller graph for this function:

◆ StreamInfo()

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

virtual

Implements G4VSolid.

Definition at line 888 of file G4EllipticalTube.cc.

 {
   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;
 }

Here is the call graph for this function:

◆ SurfaceNormal()

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

virtual

Implements G4VSolid.

Definition at line 294 of file G4EllipticalTube.cc.

 {
   //
   // 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;
 }

Here is the call graph for this function:

Member Data Documentation

◆ dx

G4double G4EllipticalTube::dx

protected

Definition at line 129 of file G4EllipticalTube.hh.

◆ dy

G4double G4EllipticalTube::dy

protected

Definition at line 129 of file G4EllipticalTube.hh.

◆ dz

G4double G4EllipticalTube::dz

protected

Definition at line 129 of file G4EllipticalTube.hh.

◆ fCubicVolume

G4double G4EllipticalTube::fCubicVolume

private

Definition at line 149 of file G4EllipticalTube.hh.

◆ fpPolyhedron

G4Polyhedron* G4EllipticalTube::fpPolyhedron

mutableprivate

Definition at line 152 of file G4EllipticalTube.hh.

◆ fRebuildPolyhedron

G4bool G4EllipticalTube::fRebuildPolyhedron

mutableprivate

Definition at line 151 of file G4EllipticalTube.hh.

◆ fSurfaceArea

G4double G4EllipticalTube::fSurfaceArea

private

Definition at line 150 of file G4EllipticalTube.hh.

◆ halfTol

G4double G4EllipticalTube::halfTol

private

Definition at line 147 of file G4EllipticalTube.hh.

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

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4EllipticalTube() [1/3]

◆ ~G4EllipticalTube()

◆ G4EllipticalTube() [2/3]

◆ G4EllipticalTube() [3/3]

Member Function Documentation

◆ ApproxSurfaceNormal()

◆ CalculateExtent()

◆ CheckXY() [1/2]

◆ CheckXY() [2/2]

◆ Clone()

◆ CreatePolyhedron()

◆ DescribeYourselfTo()

◆ DistanceToIn() [1/2]

◆ DistanceToIn() [2/2]

◆ DistanceToOut() [1/2]

◆ DistanceToOut() [2/2]

◆ GetCubicVolume()

◆ GetDx()

◆ GetDy()

◆ GetDz()

◆ GetEntityType()

◆ GetExtent()

◆ GetPointOnSurface()

◆ GetPolyhedron()

◆ GetSurfaceArea()

◆ Inside()

◆ IntersectXY()

◆ operator=()

◆ SetDx()

◆ SetDy()

◆ SetDz()

◆ StreamInfo()

◆ SurfaceNormal()

Member Data Documentation

◆ dx

◆ dy

◆ dz

◆ fCubicVolume

◆ fpPolyhedron

◆ fRebuildPolyhedron

◆ fSurfaceArea

◆ halfTol