G4EllipticalTube Class Reference

#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 G4bool	CalculateExtent (const EAxis pAxis, const G4VoxelLimits &pVoxelLimit, const G4AffineTransform &pTransform, G4double &pMin, G4double &pMax) const =0
virtual EInside	Inside (const G4ThreeVector &p) const =0
virtual G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const =0
virtual G4double	DistanceToIn (const G4ThreeVector &p, const G4ThreeVector &v) const =0
virtual G4double	DistanceToIn (const G4ThreeVector &p) const =0
virtual G4double	DistanceToOut (const G4ThreeVector &p, const G4ThreeVector &v, const G4bool calcNorm=false, G4bool *validNorm=0, G4ThreeVector *n=0) const =0
virtual G4double	DistanceToOut (const G4ThreeVector &p) const =0
virtual void	ComputeDimensions (G4VPVParameterisation *p, const G4int n, const G4VPhysicalVolume *pRep)
virtual G4double	GetCubicVolume ()
virtual G4double	GetSurfaceArea ()
virtual G4GeometryType	GetEntityType () const =0
virtual G4ThreeVector	GetPointOnSurface () const
virtual G4VSolid *	Clone () const
virtual std::ostream &	StreamInfo (std::ostream &os) const =0
void	DumpInfo () const
virtual void	DescribeYourselfTo (G4VGraphicsScene &scene) const =0
virtual G4VisExtent	GetExtent () const
virtual G4Polyhedron *	CreatePolyhedron () const
virtual G4NURBS *	CreateNURBS () const
virtual G4Polyhedron *	GetPolyhedron () 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() [1/3]

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

Definition at line 60 of file G4EllipticalTube.cc.

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

~G4EllipticalTube()

G4EllipticalTube::~G4EllipticalTube ( )

virtual

Definition at line 86 of file G4EllipticalTube.cc.

{
  delete fpPolyhedron;
}

G4EllipticalTube() [2/3]

G4EllipticalTube::G4EllipticalTube

(

__void__ &

a

)

Definition at line 76 of file G4EllipticalTube.cc.

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

G4EllipticalTube() [3/3]

G4EllipticalTube::G4EllipticalTube

(

const G4EllipticalTube &

rhs

)

Definition at line 95 of file G4EllipticalTube.cc.

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

Member Function Documentation

CalculateExtent()

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

virtual

Implements G4VSolid.

Definition at line 130 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
  {
    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 );
}

CheckXY() [1/2]

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

inlineprotected

CheckXY() [2/2]

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

inlineprotected

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

Clone()

G4VSolid * G4EllipticalTube::Clone ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 858 of file G4EllipticalTube.cc.

{
  return new G4EllipticalTube(*this);
}

CreatePolyhedron()

G4Polyhedron * G4EllipticalTube::CreatePolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 961 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;
}

Referenced by GetPolyhedron().

DescribeYourselfTo()

void G4EllipticalTube::DescribeYourselfTo ( G4VGraphicsScene &  scene ) const

virtual

Implements G4VSolid.

Definition at line 993 of file G4EllipticalTube.cc.

{
  scene.AddSolid (*this);
}

DistanceToIn() [1/2]

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

virtual

Implements G4VSolid.

Definition at line 525 of file G4EllipticalTube.cc.

{
  static const G4double halfTol = 0.5*kCarTolerance;
  
  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;
}

DistanceToIn() [2/2]

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

virtual

Implements G4VSolid.

Definition at line 367 of file G4EllipticalTube.cc.

{
  static const G4double halfTol = 0.5*kCarTolerance;
    
  //
  // 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];
}

DistanceToOut() [1/2]

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

virtual

Implements G4VSolid.

Definition at line 729 of file G4EllipticalTube.cc.

{
  static const G4double halfTol = 0.5*kCarTolerance;
  
  //
  // 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;
}

DistanceToOut() [2/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 588 of file G4EllipticalTube.cc.

{
  static const G4double halfTol = 0.5*kCarTolerance;
  
  //
  // 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;
}

GetCubicVolume()

G4double G4EllipticalTube::GetCubicVolume ( )

virtual

Reimplemented from G4VSolid.

Definition at line 867 of file G4EllipticalTube.cc.

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

GetDx()

G4double G4EllipticalTube::GetDx ( ) const

inline

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

GetDy()

G4double G4EllipticalTube::GetDy ( ) const

inline

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

GetDz()

G4double G4EllipticalTube::GetDz ( ) const

inline

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

GetEntityType()

G4GeometryType G4EllipticalTube::GetEntityType ( ) const

virtual

Implements G4VSolid.

Definition at line 849 of file G4EllipticalTube.cc.

{
  return G4String("G4EllipticalTube");
}

GetExtent()

G4VisExtent G4EllipticalTube::GetExtent ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1002 of file G4EllipticalTube.cc.

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

GetPointOnSurface()

G4ThreeVector G4EllipticalTube::GetPointOnSurface ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 911 of file G4EllipticalTube.cc.

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

GetPolyhedron()

G4Polyhedron * G4EllipticalTube::GetPolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 977 of file G4EllipticalTube.cc.

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

GetSurfaceArea()

G4double G4EllipticalTube::GetSurfaceArea ( )

virtual

Reimplemented from G4VSolid.

Definition at line 877 of file G4EllipticalTube.cc.

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

Inside()

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

virtual

Implements G4VSolid.

Definition at line 250 of file G4EllipticalTube.cc.

{
  static const G4double halfTol = 0.5*kCarTolerance;
  
  //
  // 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;
}

IntersectXY()

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

protected

Definition at line 810 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;
}

Referenced by DistanceToIn(), and DistanceToOut().

operator=()

G4EllipticalTube & G4EllipticalTube::operator=

(

const G4EllipticalTube &

rhs

)

Definition at line 106 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;
   fCubicVolume = rhs.fCubicVolume; fSurfaceArea = rhs.fSurfaceArea;
   fpPolyhedron = 0;
 
   return *this;
}

SetDx()

void G4EllipticalTube::SetDx ( const G4double  newDx )

inline

SetDy()

void G4EllipticalTube::SetDy ( const G4double  newDy )

inline

SetDz()

void G4EllipticalTube::SetDz ( const G4double  newDz )

inline

StreamInfo()

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

virtual

Implements G4VSolid.

Definition at line 887 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;
}

SurfaceNormal()

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

virtual

Implements G4VSolid.

Definition at line 284 of file G4EllipticalTube.cc.

{
  //
  // SurfaceNormal for the point On the Surface, sum the normals on the Corners
  //
  static const G4double halfTol = 0.5*kCarTolerance;
 
  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;
}

Member Data Documentation

dx

G4double G4EllipticalTube::dx

protected

Definition at line 128 of file G4EllipticalTube.hh.

Referenced by CalculateExtent(), CreatePolyhedron(), DistanceToIn(), DistanceToOut(), G4EllipticalTube(), GetExtent(), GetPointOnSurface(), IntersectXY(), operator=(), StreamInfo(), and SurfaceNormal().

dy

G4double G4EllipticalTube::dy

protected

Definition at line 128 of file G4EllipticalTube.hh.

Referenced by CalculateExtent(), CreatePolyhedron(), DistanceToIn(), DistanceToOut(), G4EllipticalTube(), GetExtent(), GetPointOnSurface(), IntersectXY(), operator=(), StreamInfo(), and SurfaceNormal().

dz

G4double G4EllipticalTube::dz

protected

Definition at line 128 of file G4EllipticalTube.hh.

Referenced by CalculateExtent(), CreatePolyhedron(), DistanceToIn(), DistanceToOut(), G4EllipticalTube(), GetExtent(), GetPointOnSurface(), Inside(), operator=(), StreamInfo(), and SurfaceNormal().

---

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

• G4EllipticalTube.hh
• G4EllipticalTube.cc