G4EllipticalTube Class Reference

#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 ()
void	Extent (G4ThreeVector &pMin, G4ThreeVector &pMax) const
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

Detailed Description

Definition at line 56 of file G4EllipticalTube.hh.

Constructor & Destructor Documentation

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

Definition at line 67 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 ( )

virtual

Definition at line 97 of file G4EllipticalTube.cc.

{
  delete fpPolyhedron;  fpPolyhedron = 0;
}

G4EllipticalTube::G4EllipticalTube

(

__void__ &

a

)

Definition at line 86 of file G4EllipticalTube.cc.

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

G4EllipticalTube::G4EllipticalTube

(

const G4EllipticalTube &

rhs

)

Definition at line 106 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

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

virtual

Implements G4VSolid.

Definition at line 154 of file G4EllipticalTube.cc.

{
  G4ThreeVector bmin, bmax;
  G4bool exist;

  // Check bounding box (bbox)
  //
  Extent(bmin,bmax);
  G4BoundingEnvelope bbox(bmin,bmax);
#ifdef G4BBOX_EXTENT
  if (true) return bbox.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
#endif
  if (bbox.BoundingBoxVsVoxelLimits(pAxis,pVoxelLimit,pTransform,pMin,pMax))
  {
    return exist = (pMin < pMax) ? true : false;
  }

  // Set bounding envelope (benv) and calculate extent
  //
  const G4int NSTEPS = 48; // number of steps for whole circle
  G4double ang = twopi/NSTEPS;

  G4double sinHalf = std::sin(0.5*ang);
  G4double cosHalf = std::cos(0.5*ang);
  G4double sinStep = 2.*sinHalf*cosHalf;
  G4double cosStep = 1. - 2.*sinHalf*sinHalf;
  G4double sx = dx/cosHalf;
  G4double sy = dy/cosHalf;

  G4double sinCur = sinHalf;
  G4double cosCur = cosHalf;
  G4ThreeVectorList baseA(NSTEPS),baseB(NSTEPS);
  for (G4int k=0; k<NSTEPS; ++k)
  {
    baseA[k].set(sx*cosCur,sy*sinCur,-dz);
    baseB[k].set(sx*cosCur,sy*sinCur, dz);

    G4double sinTmp = sinCur;
    sinCur = sinCur*cosStep + cosCur*sinStep;
    cosCur = cosCur*cosStep - sinTmp*sinStep;
  }

  std::vector<const G4ThreeVectorList *> polygons(2);
  polygons[0] = &baseA;
  polygons[1] = &baseB;
  G4BoundingEnvelope benv(bmin,bmax,polygons);
  exist = benv.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
  return exist;
}

Here is the call graph for this function:

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

inlineprotected

Here is the caller graph for this function:

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

inlineprotected

G4VSolid * G4EllipticalTube::Clone ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 811 of file G4EllipticalTube.cc.

{
  return new G4EllipticalTube(*this);
}

Here is the call graph for this function:

G4Polyhedron * G4EllipticalTube::CreatePolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 914 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:

void G4EllipticalTube::DescribeYourselfTo ( G4VGraphicsScene &  scene ) const

virtual

Implements G4VSolid.

Definition at line 950 of file G4EllipticalTube.cc.

{
  scene.AddSolid (*this);
}

Here is the call graph for this function:

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

virtual

Implements G4VSolid.

Definition at line 328 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:

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

virtual

Implements G4VSolid.

Definition at line 484 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:

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 545 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:

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

virtual

Implements G4VSolid.

Definition at line 684 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:

void G4EllipticalTube::Extent ( G4ThreeVector &  pMin, G4ThreeVector &  pMax  ) const

virtual

Reimplemented from G4VSolid.

Definition at line 142 of file G4EllipticalTube.cc.

{
  pMin.set(-dx,-dy,-dz);
  pMax.set( dx, dy, dz);
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4EllipticalTube::GetCubicVolume ( )

virtual

Reimplemented from G4VSolid.

Definition at line 820 of file G4EllipticalTube.cc.

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

Here is the call graph for this function:

G4double G4EllipticalTube::GetDx ( ) const

inline

Here is the caller graph for this function:

G4double G4EllipticalTube::GetDy ( ) const

inline

Here is the caller graph for this function:

G4double G4EllipticalTube::GetDz ( ) const

inline

Here is the caller graph for this function:

G4GeometryType G4EllipticalTube::GetEntityType ( ) const

virtual

Implements G4VSolid.

Definition at line 802 of file G4EllipticalTube.cc.

{
  return G4String("G4EllipticalTube");
}

G4VisExtent G4EllipticalTube::GetExtent ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 959 of file G4EllipticalTube.cc.

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

G4ThreeVector G4EllipticalTube::GetPointOnSurface ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 864 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:

G4Polyhedron * G4EllipticalTube::GetPolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 930 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:

G4double G4EllipticalTube::GetSurfaceArea ( )

virtual

Reimplemented from G4VSolid.

Definition at line 830 of file G4EllipticalTube.cc.

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

Here is the call graph for this function:

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

virtual

Implements G4VSolid.

Definition at line 214 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:

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

protected

Definition at line 763 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:

G4EllipticalTube & G4EllipticalTube::operator=

(

const G4EllipticalTube &

rhs

)

Definition at line 117 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:

void G4EllipticalTube::SetDx ( const G4double  newDx )

inline

void G4EllipticalTube::SetDy ( const G4double  newDy )

inline

void G4EllipticalTube::SetDz ( const G4double  newDz )

inline

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

virtual

Implements G4VSolid.

Definition at line 840 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:

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

virtual

Implements G4VSolid.

Definition at line 246 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

G4double G4EllipticalTube::dx

protected

Definition at line 131 of file G4EllipticalTube.hh.

G4double G4EllipticalTube::dy

protected

Definition at line 131 of file G4EllipticalTube.hh.

G4double G4EllipticalTube::dz

protected

Definition at line 131 of file G4EllipticalTube.hh.

---

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

• geant4.10.03.p01/source/geometry/solids/specific/include/G4EllipticalTube.hh
• geant4.10.03.p01/source/geometry/solids/specific/src/G4EllipticalTube.cc