#include <G4Hype.hh>

Inheritance diagram for G4Hype:

Public Member Functions
	G4Hype (const G4String &pName, G4double newInnerRadius, G4double newOuterRadius, G4double newInnerStereo, G4double newOuterStereo, G4double newHalfLenZ)

virtual	~G4Hype ()

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

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

G4double	GetInnerRadius () const

G4double	GetOuterRadius () const

G4double	GetZHalfLength () const

G4double	GetInnerStereo () const

G4double	GetOuterStereo () const

void	SetInnerRadius (G4double newIRad)

void	SetOuterRadius (G4double newORad)

void	SetZHalfLength (G4double newHLZ)

void	SetInnerStereo (G4double newISte)

void	SetOuterStereo (G4double newOSte)

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=G4bool(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

void	DescribeYourselfTo (G4VGraphicsScene &scene) const

G4VisExtent	GetExtent () const

G4Polyhedron *	CreatePolyhedron () const

G4Polyhedron *	GetPolyhedron () const

	G4Hype (__void__ &)

	G4Hype (const G4Hype &rhs)

G4Hype &	operator= (const G4Hype &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

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 Types
enum	ESide { outerFace, innerFace, leftCap, rightCap }

Protected Member Functions
G4bool	InnerSurfaceExists () const

G4double	HypeInnerRadius2 (G4double zVal) const

G4double	HypeOuterRadius2 (G4double zVal) 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

Static Protected Member Functions
static G4double	ApproxDistOutside (G4double pr, G4double pz, G4double r0, G4double tanPhi)

static G4double	ApproxDistInside (G4double pr, G4double pz, G4double r0, G4double tan2Phi)

static G4int	IntersectHype (const G4ThreeVector &p, const G4ThreeVector &v, G4double r2, G4double tan2Phi, G4double s[2])

static void	AddPolyToExtent (const G4ThreeVector &v0, const G4ThreeVector &v1, const G4ThreeVector &w1, const G4ThreeVector &w0, const G4VoxelLimits &voxelLimit, const EAxis axis, G4SolidExtentList &extentList)

Protected Attributes
G4double	innerRadius

G4double	outerRadius

G4double	halfLenZ

G4double	innerStereo

G4double	outerStereo

G4double	tanInnerStereo

G4double	tanOuterStereo

G4double	tanInnerStereo2

G4double	tanOuterStereo2

G4double	innerRadius2

G4double	outerRadius2

G4double	endInnerRadius2

G4double	endOuterRadius2

G4double	endInnerRadius

G4double	endOuterRadius

Protected Attributes inherited from G4VSolid
G4double	kCarTolerance

Detailed Description

Definition at line 66 of file G4Hype.hh.

Member Enumeration Documentation

enum G4Hype::ESide

protected

Enumerator
outerFace
innerFace
leftCap
rightCap

Definition at line 188 of file G4Hype.hh.

188 {outerFace,innerFace,leftCap, rightCap};

G4Hype::innerFace

Definition: G4Hype.hh:188

G4Hype::outerFace

Definition: G4Hype.hh:188

G4Hype::rightCap

Definition: G4Hype.hh:188

G4Hype::leftCap

Definition: G4Hype.hh:188

Constructor & Destructor Documentation

G4Hype::G4Hype	(	const G4String &	pName,
		G4double	newInnerRadius,
		G4double	newOuterRadius,
		G4double	newInnerStereo,
		G4double	newOuterStereo,
		G4double	newHalfLenZ
	)

Definition at line 68 of file G4Hype.cc.

References FatalErrorInArgument, G4endl, G4Exception(), G4VSolid::GetName(), halfLenZ, innerRadius, innerRadius2, G4VSolid::kCarTolerance, python.hepunit::mm, outerRadius, outerRadius2, SetInnerStereo(), and SetOuterStereo().

Referenced by Clone().

   : G4VSolid(pName), fCubicVolume(0.), fSurfaceArea(0.), fpPolyhedron(0)
 {
   fHalfTol = 0.5*kCarTolerance;
 
   // Check z-len
   //
   if (newHalfLenZ<=0)
   {
     std::ostringstream message;
     message << "Invalid Z half-length - " << GetName() << G4endl
             << "        Invalid Z half-length: "
             << newHalfLenZ/mm << " mm";
     G4Exception("G4Hype::G4Hype()", "GeomSolids0002",
                 FatalErrorInArgument, message);
   }
   halfLenZ=newHalfLenZ;   
 
   // Check radii
   //
   if (newInnerRadius<0 || newOuterRadius<0)
   {
     std::ostringstream message;
     message << "Invalid radii - " << GetName() << G4endl
             << "        Invalid radii !  Inner radius: "
             << newInnerRadius/mm << " mm" << G4endl
             << "                         Outer radius: "
             << newOuterRadius/mm << " mm";
     G4Exception("G4Hype::G4Hype()", "GeomSolids0002",
                 FatalErrorInArgument, message);
   }
   if (newInnerRadius >= newOuterRadius)
   {
     std::ostringstream message;
     message << "Outer > inner radius - " << GetName() << G4endl
             << "        Invalid radii !  Inner radius: "
             << newInnerRadius/mm << " mm" << G4endl
             << "                         Outer radius: "
             << newOuterRadius/mm << " mm";
     G4Exception("G4Hype::G4Hype()", "GeomSolids0002",
                 FatalErrorInArgument, message);
   }
 
   innerRadius=newInnerRadius;
   outerRadius=newOuterRadius;
 
   innerRadius2=innerRadius*innerRadius;
   outerRadius2=outerRadius*outerRadius;
     
   SetInnerStereo( newInnerStereo );
   SetOuterStereo( newOuterStereo );
 }

G4Hype::~G4Hype ( )

virtual

Definition at line 144 of file G4Hype.cc.

 {
   delete fpPolyhedron;
 }

G4Hype::G4Hype ( __void__ & a )

Definition at line 131 of file G4Hype.cc.

   : G4VSolid(a), innerRadius(0.), outerRadius(0.), halfLenZ(0.), innerStereo(0.),
     outerStereo(0.), tanInnerStereo(0.), tanOuterStereo(0.), tanInnerStereo2(0.),
     tanOuterStereo2(0.), innerRadius2(0.), outerRadius2(0.), endInnerRadius2(0.),
     endOuterRadius2(0.), endInnerRadius(0.), endOuterRadius(0.),
     fCubicVolume(0.), fSurfaceArea(0.), fHalfTol(0.), fpPolyhedron(0)
 {
 }

G4Hype::G4Hype ( const G4Hype & rhs )

Definition at line 153 of file G4Hype.cc.

   : G4VSolid(rhs), innerRadius(rhs.innerRadius),
     outerRadius(rhs.outerRadius), halfLenZ(rhs.halfLenZ),
     innerStereo(rhs.innerStereo), outerStereo(rhs.outerStereo),
     tanInnerStereo(rhs.tanInnerStereo), tanOuterStereo(rhs.tanOuterStereo),
     tanInnerStereo2(rhs.tanInnerStereo2), tanOuterStereo2(rhs.tanOuterStereo2),
     innerRadius2(rhs.innerRadius2), outerRadius2(rhs.outerRadius2),
     endInnerRadius2(rhs.endInnerRadius2), endOuterRadius2(rhs.endOuterRadius2),
     endInnerRadius(rhs.endInnerRadius), endOuterRadius(rhs.endOuterRadius),
     fCubicVolume(rhs.fCubicVolume), fSurfaceArea(rhs.fSurfaceArea),
     fHalfTol(rhs.fHalfTol), fpPolyhedron(0)
 {
 }

Member Function Documentation

void G4Hype::AddPolyToExtent	(	const G4ThreeVector &	v0,
		const G4ThreeVector &	v1,
		const G4ThreeVector &	w1,
		const G4ThreeVector &	w0,
		const G4VoxelLimits &	voxelLimit,
		const EAxis	axis,
		G4SolidExtentList &	extentList
	)

staticprotected

Definition at line 477 of file G4Hype.cc.

References G4SolidExtentList::AddSurface(), G4ClippablePolygon::AddVertexInOrder(), G4ClippablePolygon::PartialClip(), and G4ClippablePolygon::SetNormal().

Referenced by CalculateExtent().

 {
   G4ClippablePolygon phiPoly;
 
   phiPoly.AddVertexInOrder( v0 );
   phiPoly.AddVertexInOrder( v1 );
   phiPoly.AddVertexInOrder( w1 );
   phiPoly.AddVertexInOrder( w0 );
 
   if (phiPoly.PartialClip( voxelLimit, axis ))
   {
     phiPoly.SetNormal( (v1-v0).cross(w0-v0).unit() );
     extentList.AddSurface( phiPoly );
   }
 }

G4double G4Hype::ApproxDistInside	(	G4double	pr,
		G4double	pz,
		G4double	r0,
		G4double	tan2Phi
	)

staticprotected

Definition at line 1328 of file G4Hype.cc.

References DBL_MIN, and gammaraytel::pr.

Referenced by DistanceToIn(), and DistanceToOut().

 {
   if (tan2Phi < DBL_MIN) return r0 - pr;
 
   //
   // Corresponding position and normal on hyperbolic
   //
   G4double rh = std::sqrt( r0*r0 + pz*pz*tan2Phi );
   
   G4double dr = -rh;
   G4double dz = pz*tan2Phi;
   G4double len = std::sqrt(dr*dr + dz*dz);
   
   //
   // Answer
   //
   return std::fabs((pr-rh)*dr)/len;
 }

G4double G4Hype::ApproxDistOutside	(	G4double	pr,
		G4double	pz,
		G4double	r0,
		G4double	tanPhi
	)

staticprotected

Definition at line 1270 of file G4Hype.cc.

References DBL_MIN.

Referenced by DistanceToIn(), and DistanceToOut().

 {
   if (tanPhi < DBL_MIN) return pr-r0;
 
   G4double tan2Phi = tanPhi*tanPhi;
 
   //
   // First point
   //
   G4double z1 = pz;
   G4double r1 = std::sqrt( r0*r0 + z1*z1*tan2Phi );
   
   //
   // Second point
   //
   G4double z2 = (pr*tanPhi + pz)/(1 + tan2Phi);
   G4double r2 = std::sqrt( r0*r0 + z2*z2*tan2Phi );
   
   //
   // Line between them
   //
   G4double dr = r2-r1;
   G4double dz = z2-z1;
   
   G4double len = std::sqrt(dr*dr + dz*dz);
   if (len < DBL_MIN)
   {
     //
     // The two points are the same?? I guess we
     // must have really bracketed the normal
     //
     dr = pr-r1;
     dz = pz-z1;
     return std::sqrt( dr*dr + dz*dz );
   }
   
   //
   // Distance
   //
   return std::fabs((pr-r1)*dz - (pz-z1)*dr)/len;
 }

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

virtual

Implements G4VSolid.

Definition at line 213 of file G4Hype.cc.

References AddPolyToExtent(), G4SolidExtentList::AddSurface(), G4ClippablePolygon::AddVertexInOrder(), G4AffineTransform::ApplyPointTransform(), endInnerRadius, endOuterRadius, G4SolidExtentList::GetExtent(), halfLenZ, innerRadius, InnerSurfaceExists(), kMaxMeshSections, outerRadius, G4ClippablePolygon::PartialClip(), G4ClippablePolygon::SetNormal(), tanInnerStereo2, G4AffineTransform::TransformAxis(), G4AffineTransform::TransformPoint(), and python.hepunit::twopi.

 {
   G4SolidExtentList  extentList( axis, voxelLimit );
   
   //
   // Choose phi size of our segment(s) based on constants as
   // defined in meshdefs.hh
   //
   G4int numPhi = kMaxMeshSections;
   G4double sigPhi = twopi/numPhi;
   G4double rFudge = 1.0/std::cos(0.5*sigPhi);
   
   //
   // We work around in phi building polygons along the way.
   // As a reasonable compromise between accuracy and
   // complexity (=cpu time), the following facets are chosen:
   //
   //   1. If outerRadius/endOuterRadius > 0.95, approximate
   //      the outer surface as a cylinder, and use one
   //      rectangular polygon (0-1) to build its mesh.
   //
   //      Otherwise, use two trapazoidal polygons that 
   //      meet at z = 0 (0-4-1)
   //
   //   2. If there is no inner surface, then use one
   //      polygon for each entire endcap.  (0) and (1)
   //
   //      Otherwise, use a trapazoidal polygon for each
   //      phi segment of each endcap.    (0-2) and (1-3)
   //
   //   3. For the inner surface, if innerRadius/endInnerRadius > 0.95,
   //      approximate the inner surface as a cylinder of
   //      radius innerRadius and use one rectangular polygon
   //      to build each phi segment of its mesh.   (2-3)
   //
   //      Otherwise, use one rectangular polygon centered
   //      at z = 0 (5-6) and two connecting trapazoidal polygons
   //      for each phi segment (2-5) and (3-6).
   //
   
   G4bool splitOuter = (outerRadius/endOuterRadius < 0.95);
   G4bool splitInner = 0;
   if (InnerSurfaceExists())
   {
     splitInner = (innerRadius/endInnerRadius < 0.95);
   }
   
   //
   // Vertex assignments (v and w arrays)
   // [0] and [1] are mandatory
   // the rest are optional
   //
   //     +                     -
   //      [0]------[4]------[1]      <--- outer radius
   //       |                 |       
   //       |                 |       
   //      [2]---[5]---[6]---[3]      <--- inner radius
   //
 
 
   G4ClippablePolygon endPoly1, endPoly2;
   
   G4double phi = 0, 
      cosPhi = std::cos(phi),
      sinPhi = std::sin(phi);
   G4ThreeVector v0( rFudge*endOuterRadius*cosPhi,
                     rFudge*endOuterRadius*sinPhi,
                     +halfLenZ ),
                 v1( rFudge*endOuterRadius*cosPhi,
                     rFudge*endOuterRadius*sinPhi,
                     -halfLenZ ),
                 v2, v3, v4, v5, v6,
                 w0, w1, w2, w3, w4, w5, w6;
   transform.ApplyPointTransform( v0 );
   transform.ApplyPointTransform( v1 );
   
   G4double zInnerSplit=0.;
   if (InnerSurfaceExists())
   {
     if (splitInner)
     {
       v2 = transform.TransformPoint( 
         G4ThreeVector( endInnerRadius*cosPhi,
                        endInnerRadius*sinPhi, +halfLenZ ) );
       v3 = transform.TransformPoint( 
         G4ThreeVector( endInnerRadius*cosPhi,
                        endInnerRadius*sinPhi, -halfLenZ ) );
       //
       // Find intersection of line normal to inner
       // surface at z = halfLenZ and line r=innerRadius
       //
       G4double rn = halfLenZ*tanInnerStereo2;
       G4double zn = endInnerRadius;
 
       zInnerSplit = halfLenZ + (innerRadius - endInnerRadius)*zn/rn;
 
       //
       // Build associated vertices
       //      
       v5 = transform.TransformPoint( 
         G4ThreeVector( innerRadius*cosPhi,
                        innerRadius*sinPhi, +zInnerSplit ) );
       v6 = transform.TransformPoint( 
         G4ThreeVector( innerRadius*cosPhi,
                        innerRadius*sinPhi, -zInnerSplit ) );
     }
     else
     {
       v2 = transform.TransformPoint( 
         G4ThreeVector( innerRadius*cosPhi,
                        innerRadius*sinPhi, +halfLenZ ) );
       v3 = transform.TransformPoint( 
         G4ThreeVector( innerRadius*cosPhi,
                        innerRadius*sinPhi, -halfLenZ ) );
     }
   }
   
   if (splitOuter)
   {
     v4 = transform.TransformPoint( 
       G4ThreeVector( rFudge*outerRadius*cosPhi,
                      rFudge*outerRadius*sinPhi, 0 ) );
   }
   
   //
   // Loop over phi segments
   //
   do
   {
     phi += sigPhi;
     if (numPhi == 1) phi = 0;  // Try to avoid roundoff
           cosPhi = std::cos(phi), 
     sinPhi = std::sin(phi);
     
     G4double r(rFudge*endOuterRadius);
     w0 = G4ThreeVector( r*cosPhi, r*sinPhi, +halfLenZ );
     w1 = G4ThreeVector( r*cosPhi, r*sinPhi, -halfLenZ );
     transform.ApplyPointTransform( w0 );
     transform.ApplyPointTransform( w1 );
   
     //
     // Outer hyperbolic surface
     //
     if (splitOuter)
     {
       r = rFudge*outerRadius;
       w4 = G4ThreeVector( r*cosPhi, r*sinPhi, 0 );
       transform.ApplyPointTransform( w4 );
       
       AddPolyToExtent( v0, v4, w4, w0, voxelLimit, axis, extentList );
       AddPolyToExtent( v4, v1, w1, w4, voxelLimit, axis, extentList );
     }
     else
     {
       AddPolyToExtent( v0, v1, w1, w0, voxelLimit, axis, extentList );
     }
   
     if (InnerSurfaceExists())
     {
       //
       // Inner hyperbolic surface
       //
       if (splitInner)
       {
         w2 = G4ThreeVector( endInnerRadius*cosPhi,
                             endInnerRadius*sinPhi, +halfLenZ );
         w3 = G4ThreeVector( endInnerRadius*cosPhi,
                             endInnerRadius*sinPhi, -halfLenZ );
         transform.ApplyPointTransform( w2 );
         transform.ApplyPointTransform( w3 );
 
         w5 = G4ThreeVector( innerRadius*cosPhi,
                             innerRadius*sinPhi, +zInnerSplit );
         w6 = G4ThreeVector( innerRadius*cosPhi,
                             innerRadius*sinPhi, -zInnerSplit );
         transform.ApplyPointTransform( w5 );
         transform.ApplyPointTransform( w6 );
         AddPolyToExtent( v3, v6, w6, w3, voxelLimit, axis, extentList );
         AddPolyToExtent( v6, v5, w5, w6, voxelLimit, axis, extentList );
         AddPolyToExtent( v5, v2, w2, w5, voxelLimit, axis, extentList );
       }
       else
       {
         w2 = G4ThreeVector( innerRadius*cosPhi,
                             innerRadius*sinPhi, +halfLenZ );
         w3 = G4ThreeVector( innerRadius*cosPhi,
                             innerRadius*sinPhi, -halfLenZ );
         transform.ApplyPointTransform( w2 );
         transform.ApplyPointTransform( w3 );
 
         AddPolyToExtent( v3, v2, w2, w3, voxelLimit, axis, extentList );
       }
 
       //
       // Endplate segments
       //
       AddPolyToExtent( v1, v3, w3, w1, voxelLimit, axis, extentList );
       AddPolyToExtent( v2, v0, w0, w2, voxelLimit, axis, extentList );
     }
     else
     {
       //
       // Continue building endplate polygons
       //
       endPoly1.AddVertexInOrder( v0 );
       endPoly2.AddVertexInOrder( v1 );
     }
 
     //
     // Next phi segments
     //    
     v0 = w0;
     v1 = w1;
     if (InnerSurfaceExists())
     {
       v2 = w2;
       v3 = w3;
       if (splitInner)
       {
         v5 = w5;
         v6 = w6;
       }
     }
     if (splitOuter) v4 = w4;
     
   } while( --numPhi > 0 );
   
   
   //
   // Don't forget about the endplate polygons, if
   // we use them
   //
   if (!InnerSurfaceExists())
   {
     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 );
 }

G4VSolid * G4Hype::Clone ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1361 of file G4Hype.cc.

References G4Hype().

 {
   return new G4Hype(*this);
 }

void G4Hype::ComputeDimensions	(	G4VPVParameterisation *	p,
		const G4int	n,
		const G4VPhysicalVolume *	pRep
	)

virtual

Reimplemented from G4VSolid.

Definition at line 202 of file G4Hype.cc.

References G4VPVParameterisation::ComputeDimensions().

 {
   p->ComputeDimensions(*this,n,pRep);
 }

G4Polyhedron * G4Hype::CreatePolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1541 of file G4Hype.cc.

References halfLenZ, innerRadius, outerRadius, tanInnerStereo2, and tanOuterStereo2.

Referenced by GetPolyhedron().

 {
    return new G4PolyhedronHype(innerRadius, outerRadius,
                                tanInnerStereo2, tanOuterStereo2, halfLenZ);
 }

void G4Hype::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

virtual

Implements G4VSolid.

Definition at line 1519 of file G4Hype.cc.

References G4VGraphicsScene::AddSolid().

 {
   scene.AddSolid (*this);
 }

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

virtual

Implements G4VSolid.

Definition at line 593 of file G4Hype.cc.

References DBL_EPSILON, DBL_MIN, endInnerRadius, endInnerRadius2, endOuterRadius, endOuterRadius2, halfLenZ, HypeInnerRadius2(), HypeOuterRadius2(), innerRadius2, innerStereo, InnerSurfaceExists(), IntersectHype(), G4VSolid::kCarTolerance, n, outerRadius2, tanInnerStereo2, tanOuterStereo2, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

 {
   //
   // Quick test. Beware! This assumes v is a unit vector!
   //
   if (std::fabs(p.x()*v.y() - p.y()*v.x()) > endOuterRadius+kCarTolerance)
     return kInfinity;
   
   //
   // Take advantage of z symmetry, and reflect throught the
   // z=0 plane so that pz is always positive
   //
   G4double pz(p.z()), vz(v.z());
   if (pz < 0)
   {
     pz = -pz;
     vz = -vz;
   }
 
   //
   // We must be very careful if we don't want to
   // create subtle leaks at the edges where the
   // hyperbolic surfaces connect to the endplate.
   // The only reliable way to do so is to make sure
   // that the decision as to when a track passes
   // over the edge of one surface is exactly the
   // same decision as to when a track passes into the
   // other surface. By "exact", we don't mean algebraicly
   // exact, but we mean the same machine instructions
   // should be used.
   //
   G4bool couldMissOuter(true),
          couldMissInner(true),
          cantMissInnerCylinder(false);
   
   //
   // Check endplate intersection
   //
   G4double sigz = pz-halfLenZ;
   
   if (sigz > -fHalfTol)    // equivalent to: if (pz > halfLenZ - fHalfTol)
   {
     //
     // We start in front of the endplate (within roundoff)
     // Correct direction to intersect endplate?
     //
     if (vz >= 0)
     {
       //
       // Nope. As long as we are far enough away, we
       // can't intersect anything
       //
       if (sigz > 0) return kInfinity;
       
       //
       // Otherwise, we may still hit a hyperbolic surface
       // if the point is on the hyperbolic surface (within tolerance)
       //
       G4double pr2 = p.x()*p.x() + p.y()*p.y();
       if (pr2 > endOuterRadius2 + kCarTolerance*endOuterRadius)
         return kInfinity;
       
       if (InnerSurfaceExists())
       {
         if (pr2 < endInnerRadius2 - kCarTolerance*endInnerRadius)
           return kInfinity;
         if ( (pr2 < endOuterRadius2 - kCarTolerance*endOuterRadius)
           && (pr2 > endInnerRadius2 + kCarTolerance*endInnerRadius) )
           return kInfinity;
       }
       else
       {
         if (pr2 < endOuterRadius2 - kCarTolerance*endOuterRadius)
           return kInfinity;
       }
     }
     else
     {
       //
       // Where do we intersect at z = halfLenZ?
       //
       G4double q = -sigz/vz;
       G4double xi = p.x() + q*v.x(),
                yi = p.y() + q*v.y();
          
       //
       // Is this on the endplate? If so, return s, unless
       // we are on the tolerant surface, in which case return 0
       //
       G4double pr2 = xi*xi + yi*yi;
       if (pr2 <= endOuterRadius2)
       {
         if (InnerSurfaceExists())
         {
           if (pr2 >= endInnerRadius2) return (sigz < fHalfTol) ? 0 : q;
           //
           // This test is sufficient to ensure that the
           // trajectory cannot miss the inner hyperbolic surface
           // for z > 0, if the normal is correct.
           //
           G4double dot1 = (xi*v.x() + yi*v.y())*endInnerRadius/std::sqrt(pr2);
           couldMissInner = (dot1 - halfLenZ*tanInnerStereo2*vz <= 0);
           
           if (pr2 > endInnerRadius2*(1 - 2*DBL_EPSILON) )
           {
             //
             // There is a potential leak if the inner
             // surface is a cylinder
             //
             if ( (innerStereo < DBL_MIN)
               && ((std::fabs(v.x()) > DBL_MIN) || (std::fabs(v.y()) > DBL_MIN)) )
               cantMissInnerCylinder = true;
           }
         }
         else
         {
           return (sigz < fHalfTol) ? 0 : q;
         }
       }
       else
       {
         G4double dotR( xi*v.x() + yi*v.y() );
         if (dotR >= 0)
         {
           //
           // Otherwise, if we are traveling outwards, we know
           // we must miss the hyperbolic surfaces also, so
           // we need not bother checking
           //
           return kInfinity;
         }
         else
         {
           //
           // This test is sufficient to ensure that the
           // trajectory cannot miss the outer hyperbolic surface
           // for z > 0, if the normal is correct.
           //
           G4double dot1 = dotR*endOuterRadius/std::sqrt(pr2);
           couldMissOuter = (dot1 - halfLenZ*tanOuterStereo2*vz>= 0);
         }
       }
     }
   }
     
   //
   // Check intersection with outer hyperbolic surface, save
   // distance to valid intersection into "best".
   //    
   G4double best = kInfinity;
   
   G4double q[2];
   G4int n = IntersectHype( p, v, outerRadius2, tanOuterStereo2, q );
   
   if (n > 0)
   {
     //
     // Potential intersection: is p on this surface?
     //
     if (pz < halfLenZ+fHalfTol)
     {
       G4double dr2 = p.x()*p.x() + p.y()*p.y() - HypeOuterRadius2(pz);
       if (std::fabs(dr2) < kCarTolerance*endOuterRadius)
       {
         //
         // Sure, but make sure we're traveling inwards at
         // this point
         //
         if (p.x()*v.x() + p.y()*v.y() - pz*tanOuterStereo2*vz < 0)
           return 0;
       }
     }
     
     //
     // We are now certain that p is not on the tolerant surface.
     // Accept only position distance q
     //
     G4int i;
     for( i=0; i<n; i++ )
     {
       if (q[i] >= 0)
       {
         //
         // Check to make sure this intersection point is
         // on the surface, but only do so if we haven't
         // checked the endplate intersection already
         //
         G4double zi = pz + q[i]*vz;
         
         if (zi < -halfLenZ) continue;
         if (zi > +halfLenZ && couldMissOuter) continue;
         
         //
         // Check normal
         //
         G4double xi = p.x() + q[i]*v.x(),
            yi = p.y() + q[i]*v.y();
            
         if (xi*v.x() + yi*v.y() - zi*tanOuterStereo2*vz > 0) continue;
 
         best = q[i];
         break;
       }
     }
   }
   
   if (!InnerSurfaceExists()) return best;    
   
   //
   // Check intersection with inner hyperbolic surface
   //
   n = IntersectHype( p, v, innerRadius2, tanInnerStereo2, q );  
   if (n == 0)
   {
     if (cantMissInnerCylinder) return (sigz < fHalfTol) ? 0 : -sigz/vz;
         
     return best;
   }
   
   //
   // P on this surface?
   //
   if (pz < halfLenZ+fHalfTol)
   {
     G4double dr2 = p.x()*p.x() + p.y()*p.y() - HypeInnerRadius2(pz);
     if (std::fabs(dr2) < kCarTolerance*endInnerRadius)
     {
       //
       // Sure, but make sure we're traveling outwards at
       // this point
       //
       if (p.x()*v.x() + p.y()*v.y() - pz*tanInnerStereo2*vz > 0) return 0;
     }
   }
   
   //
   // No, so only positive q is valid. Search for a valid intersection
   // that is closer than the outer intersection (if it exists)
   //
   G4int i;
   for( i=0; i<n; i++ )
   {
     if (q[i] > best) break;
     if (q[i] >= 0)
     {
       //
       // Check to make sure this intersection point is
       // on the surface, but only do so if we haven't
       // checked the endplate intersection already
       //
       G4double zi = pz + q[i]*vz;
 
       if (zi < -halfLenZ) continue;
       if (zi > +halfLenZ && couldMissInner) continue;
 
       //
       // Check normal
       //
       G4double xi = p.x() + q[i]*v.x(),
          yi = p.y() + q[i]*v.y();
 
       if (xi*v.x() + yi*v.y() - zi*tanOuterStereo2*vz < 0) continue;
 
       best = q[i];
       break;
     }
   }
     
   //
   // Done
   //
   return best;
 }

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

virtual

Implements G4VSolid.

Definition at line 888 of file G4Hype.cc.

References ApproxDistInside(), ApproxDistOutside(), endInnerRadius, endOuterRadius, halfLenZ, HypeInnerRadius2(), innerRadius, InnerSurfaceExists(), G4VSolid::kCarTolerance, outerRadius, tanInnerStereo2, tanOuterStereo, tanOuterStereo2, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

 {
   G4double absZ(std::fabs(p.z()));
   
   //
   // Check region
   //
   G4double r2 = p.x()*p.x() + p.y()*p.y();
   G4double r = std::sqrt(r2);
   
   G4double sigz = absZ - halfLenZ;
   
   if (r < endOuterRadius)
   {
     if (sigz > -fHalfTol)
     {
       if (InnerSurfaceExists())
       {
         if (r > endInnerRadius) 
           return sigz < fHalfTol ? 0 : sigz;  // Region 1
         
         G4double dr = endInnerRadius - r;
         if (sigz > dr*tanInnerStereo2)
         {
           //
           // In region 5
           //
           G4double answer = std::sqrt( dr*dr + sigz*sigz );
           return answer < fHalfTol ? 0 : answer;
         }
       }
       else
       {
         //
         // In region 1 (no inner surface)
         //
         return sigz < fHalfTol ? 0 : sigz;
       }
     }
   }
   else
   {
     G4double dr = r - endOuterRadius;
     if (sigz > -dr*tanOuterStereo2)
     {
       //
       // In region 2
       //
       G4double answer = std::sqrt( dr*dr + sigz*sigz );
       return answer < fHalfTol ? 0 : answer;
     }
   }
   
   if (InnerSurfaceExists())
   {
     if (r2 < HypeInnerRadius2(absZ)+kCarTolerance*endInnerRadius)
     {
        //
       // In region 4
       //
       G4double answer = ApproxDistInside( r,absZ,innerRadius,tanInnerStereo2 );
       return answer < fHalfTol ? 0 : answer;
     }
   }
   
   //
   // We are left by elimination with region 3
   //
   G4double answer = ApproxDistOutside( r, absZ, outerRadius, tanOuterStereo );
   return answer < fHalfTol ? 0 : answer;
 }

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

virtual

Implements G4VSolid.

Definition at line 969 of file G4Hype.cc.

References DBL_MIN, CLHEP::Hep3Vector::dot(), endInnerRadius, endOuterRadius, halfLenZ, HypeInnerRadius2(), HypeOuterRadius2(), innerRadius2, InnerSurfaceExists(), IntersectHype(), G4VSolid::kCarTolerance, n, outerRadius2, tanInnerStereo2, tanOuterStereo2, CLHEP::Hep3Vector::unit(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

 {
   static const G4ThreeVector normEnd1(0.0,0.0,+1.0);
   static const G4ThreeVector normEnd2(0.0,0.0,-1.0);
   
   //
   // Keep track of closest surface
   //
   G4double sBest;        // distance to
   const G4ThreeVector *nBest;    // normal vector
   G4bool vBest;        // whether "valid"
 
   //
   // Check endplate, taking advantage of symmetry.
   // Note that the endcap is the only surface which
   // has a "valid" normal, i.e. is a surface of which
   // the entire solid is behind.
   //
   G4double pz(p.z()), vz(v.z());
   if (vz < 0)
   {
     pz = -pz;
     vz = -vz;
     nBest = &normEnd2;
   }
   else
     nBest = &normEnd1;
 
   //
   // Possible intercept. Are we on the surface?
   //
   if (pz > halfLenZ-fHalfTol)
   {
     if (calcNorm) { *norm = *nBest; *validNorm = true; }
     return 0;
   }
 
   //
   // Nope. Get distance. Beware of zero vz.
   //
   sBest = (vz > DBL_MIN) ? (halfLenZ - pz)/vz : kInfinity;
   vBest = true;
   
   //
   // Check outer surface
   //
   G4double r2 = p.x()*p.x() + p.y()*p.y();
   
   G4double q[2];
   G4int n = IntersectHype( p, v, outerRadius2, tanOuterStereo2, q );
   
   G4ThreeVector norm1, norm2;
 
   if (n > 0)
   {
     //
     // We hit somewhere. Are we on the surface?
     //  
     G4double dr2 = r2 - HypeOuterRadius2(pz);
     if (std::fabs(dr2) < endOuterRadius*kCarTolerance)
     {
       G4ThreeVector normHere( p.x(), p.y(), -p.z()*tanOuterStereo2 );
       //
       // Sure. But are we going the right way?
       //
       if (normHere.dot(v) > 0)
       {
         if (calcNorm) { *norm = normHere.unit(); *validNorm = false; }
         return 0;
       }
     }
     
     //
     // Nope. Check closest positive intercept.
     //
     G4int i;
     for( i=0; i<n; i++ )
     {
       if (q[i] > sBest) break;
       if (q[i] > 0)
       {
         //
         // Make sure normal is correct (that this
         // solution is an outgoing solution)
         //
         G4ThreeVector pk(p+q[i]*v);
         norm1 = G4ThreeVector( pk.x(), pk.y(), -pk.z()*tanOuterStereo2 );
         if (norm1.dot(v) > 0)
         {
           sBest = q[i];
           nBest = &norm1;
           vBest = false;
           break;
         }
       }
     }
   }
   
   if (InnerSurfaceExists())
   {
     //
     // Check inner surface
     //
     n = IntersectHype( p, v, innerRadius2, tanInnerStereo2, q );
     if (n > 0)
     {
       //
       // On surface?
       //
       G4double dr2 = r2 - HypeInnerRadius2(pz);
       if (std::fabs(dr2) < endInnerRadius*kCarTolerance)
       {
         G4ThreeVector normHere( -p.x(), -p.y(), p.z()*tanInnerStereo2 );
         if (normHere.dot(v) > 0)
         {
           if (calcNorm)
           {
             *norm = normHere.unit();
             *validNorm = false;
           }
           return 0;
         }
       }
       
       //
       // Check closest positive
       //
       G4int i;
       for( i=0; i<n; i++ )
       {
         if (q[i] > sBest) break;
         if (q[i] > 0)
         {
           G4ThreeVector pk(p+q[i]*v);
           norm2 = G4ThreeVector( -pk.x(), -pk.y(), pk.z()*tanInnerStereo2 );
           if (norm2.dot(v) > 0)
           {
             sBest = q[i];
             nBest = &norm2;
             vBest = false;
             break;
           }
         }
       }
     }
   }
   
   //
   // Done!
   //
   if (calcNorm)
   {
     *validNorm = vBest;
     
     if (nBest == &norm1 || nBest == &norm2) 
       *norm = nBest->unit();
     else
       *norm = *nBest;
   }
   
   return sBest;
 }

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

virtual

Implements G4VSolid.

Definition at line 1140 of file G4Hype.cc.

References ApproxDistInside(), ApproxDistOutside(), halfLenZ, innerRadius, InnerSurfaceExists(), G4VSolid::kCarTolerance, outerRadius, CLHEP::Hep3Vector::perp(), tanInnerStereo, tanOuterStereo2, and CLHEP::Hep3Vector::z().

 {
   //
   // Try each surface and remember the closest
   //
   G4double absZ(std::fabs(p.z()));
   G4double r(p.perp());
   
   G4double sBest = halfLenZ - absZ;
   
   G4double tryOuter = ApproxDistInside( r, absZ, outerRadius, tanOuterStereo2 );
   if (tryOuter < sBest)
     sBest = tryOuter;
   
   if (InnerSurfaceExists())
   {
     G4double tryInner = ApproxDistOutside( r,absZ,innerRadius,tanInnerStereo );
     if (tryInner < sBest) sBest = tryInner;
   }
   
   return sBest < 0.5*kCarTolerance ? 0 : sBest;
 }

G4double G4Hype::GetCubicVolume ( )

virtual

Reimplemented from G4VSolid.

Definition at line 1370 of file G4Hype.cc.

References G4VSolid::GetCubicVolume().

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

G4GeometryType G4Hype::GetEntityType ( ) const

virtual

Implements G4VSolid.

Definition at line 1352 of file G4Hype.cc.

 {
   return G4String("G4Hype");
 }

G4VisExtent G4Hype::GetExtent ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1528 of file G4Hype.cc.

References endOuterRadius, and halfLenZ.

 {
   // Define the sides of the box into which the G4Tubs instance would fit.
   //
   return G4VisExtent( -endOuterRadius, endOuterRadius, 
                       -endOuterRadius, endOuterRadius, 
                       -halfLenZ, halfLenZ );
 }

G4double G4Hype::GetInnerRadius ( ) const

inline

Referenced by export_G4Hype(), G4tgbGeometryDumper::GetSolidParams(), G4GDMLWriteParamvol::Hype_dimensionsWrite(), and G4GDMLWriteSolids::HypeWrite().

G4double G4Hype::GetInnerStereo ( ) const

inline

Referenced by export_G4Hype(), G4tgbGeometryDumper::GetSolidParams(), G4GDMLWriteParamvol::Hype_dimensionsWrite(), and G4GDMLWriteSolids::HypeWrite().

G4double G4Hype::GetOuterRadius ( ) const

inline

Referenced by export_G4Hype(), G4tgbGeometryDumper::GetSolidParams(), G4GDMLWriteParamvol::Hype_dimensionsWrite(), and G4GDMLWriteSolids::HypeWrite().

G4double G4Hype::GetOuterStereo ( ) const

inline

Referenced by export_G4Hype(), G4tgbGeometryDumper::GetSolidParams(), G4GDMLWriteParamvol::Hype_dimensionsWrite(), and G4GDMLWriteSolids::HypeWrite().

G4ThreeVector G4Hype::GetPointOnSurface ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1416 of file G4Hype.cc.

References halfLenZ, innerRadius, innerRadius2, innerStereo, outerRadius, outerRadius2, outerStereo, python.hepunit::pi, G4INCL::DeJongSpin::shoot(), sqr(), tanInnerStereo, tanInnerStereo2, tanOuterStereo, and tanOuterStereo2.

 {
   G4double xRand, yRand, zRand, r2 , aOne, aTwo, aThree, chose, sinhu;
   G4double phi, cosphi, sinphi, rBar2Out, rBar2In, alpha, t, rOut, rIn2, rOut2;
 
   // we use the formula of the area of a surface of revolution to compute 
   // the areas, using the equation of the hyperbola:
   // x^2 + y^2 = (z*tanphi)^2 + r^2
 
   rBar2Out = outerRadius2;
   alpha = 2.*pi*rBar2Out*std::cos(outerStereo)/tanOuterStereo;
   t     = halfLenZ*tanOuterStereo/(outerRadius*std::cos(outerStereo));
   t     = std::log(t+std::sqrt(sqr(t)+1));
   aOne  = std::fabs(2.*alpha*(std::sinh(2.*t)/4.+t/2.));
 
 
   rBar2In = innerRadius2;
   alpha = 2.*pi*rBar2In*std::cos(innerStereo)/tanInnerStereo;
   t     = halfLenZ*tanInnerStereo/(innerRadius*std::cos(innerStereo));
   t     = std::log(t+std::sqrt(sqr(t)+1));
   aTwo  = std::fabs(2.*alpha*(std::sinh(2.*t)/4.+t/2.));
 
   aThree = pi*((outerRadius2+sqr(halfLenZ*tanOuterStereo)
               -(innerRadius2+sqr(halfLenZ*tanInnerStereo))));
   
   if(outerStereo == 0.) {aOne = std::fabs(2.*pi*outerRadius*2.*halfLenZ);}
   if(innerStereo == 0.) {aTwo = std::fabs(2.*pi*innerRadius*2.*halfLenZ);}
   
   phi = RandFlat::shoot(0.,2.*pi);
   cosphi = std::cos(phi);
   sinphi = std::sin(phi);
   sinhu = RandFlat::shoot(-1.*halfLenZ*tanOuterStereo/outerRadius,
                           halfLenZ*tanOuterStereo/outerRadius);
 
   chose = RandFlat::shoot(0.,aOne+aTwo+2.*aThree);
   if(chose>=0. && chose < aOne)
   {
     if(outerStereo != 0.)
     {
       zRand = outerRadius*sinhu/tanOuterStereo;
       xRand = std::sqrt(sqr(sinhu)+1)*outerRadius*cosphi;
       yRand = std::sqrt(sqr(sinhu)+1)*outerRadius*sinphi;
       return G4ThreeVector (xRand, yRand, zRand);
     }
     else
     {
       return G4ThreeVector(outerRadius*cosphi,outerRadius*sinphi,
                            RandFlat::shoot(-halfLenZ,halfLenZ));
     }
   }
   else if(chose>=aOne && chose<aOne+aTwo)
   {
     if(innerStereo != 0.)
     {
       sinhu = RandFlat::shoot(-1.*halfLenZ*tanInnerStereo/innerRadius,
                               halfLenZ*tanInnerStereo/innerRadius);
       zRand = innerRadius*sinhu/tanInnerStereo;
       xRand = std::sqrt(sqr(sinhu)+1)*innerRadius*cosphi;
       yRand = std::sqrt(sqr(sinhu)+1)*innerRadius*sinphi;
       return G4ThreeVector (xRand, yRand, zRand);
     }
     else 
     {
       return G4ThreeVector(innerRadius*cosphi,innerRadius*sinphi,
                            RandFlat::shoot(-1.*halfLenZ,halfLenZ));
     }
   }
   else if(chose>=aOne+aTwo && chose<aOne+aTwo+aThree)
   {
     rIn2  = innerRadius2+tanInnerStereo2*halfLenZ*halfLenZ;
     rOut2 = outerRadius2+tanOuterStereo2*halfLenZ*halfLenZ;
     rOut  = std::sqrt(rOut2) ;
  
     do {
       xRand = RandFlat::shoot(-rOut,rOut) ;
       yRand = RandFlat::shoot(-rOut,rOut) ;
       r2 = xRand*xRand + yRand*yRand ;
     } while ( ! ( r2 >= rIn2 && r2 <= rOut2 ) ) ;
 
     zRand = halfLenZ;
     return G4ThreeVector (xRand, yRand, zRand);
   }
   else
   {
     rIn2  = innerRadius2+tanInnerStereo2*halfLenZ*halfLenZ;
     rOut2 = outerRadius2+tanOuterStereo2*halfLenZ*halfLenZ;
     rOut  = std::sqrt(rOut2) ;
  
     do {
       xRand = RandFlat::shoot(-rOut,rOut) ;
       yRand = RandFlat::shoot(-rOut,rOut) ;
       r2 = xRand*xRand + yRand*yRand ;
     } while ( ! ( r2 >= rIn2 && r2 <= rOut2 ) ) ;
 
     zRand = -1.*halfLenZ;
     return G4ThreeVector (xRand, yRand, zRand);
   }
 }

G4Polyhedron * G4Hype::GetPolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1551 of file G4Hype.cc.

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

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

G4double G4Hype::GetSurfaceArea ( )

virtual

Reimplemented from G4VSolid.

Definition at line 1381 of file G4Hype.cc.

References G4VSolid::GetSurfaceArea().

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

G4double G4Hype::GetZHalfLength ( ) const

inline

Referenced by export_G4Hype(), G4tgbGeometryDumper::GetSolidParams(), G4GDMLWriteParamvol::Hype_dimensionsWrite(), and G4GDMLWriteSolids::HypeWrite().

G4double G4Hype::HypeInnerRadius2 ( G4double zVal ) const

inlineprotected

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

G4double G4Hype::HypeOuterRadius2 ( G4double zVal ) const

inlineprotected

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

G4bool G4Hype::InnerSurfaceExists ( ) const

inlineprotected

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

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

virtual

Implements G4VSolid.

Definition at line 503 of file G4Hype.cc.

References endInnerRadius, endOuterRadius, halfLenZ, HypeInnerRadius2(), HypeOuterRadius2(), InnerSurfaceExists(), G4VSolid::kCarTolerance, kInside, kOutside, kSurface, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

 {
   //
   // Check z extents: are we outside?
   //
   const G4double absZ(std::fabs(p.z()));
   if (absZ > halfLenZ + fHalfTol) return kOutside;
   
   //
   // Check outer radius
   //
   const G4double oRad2(HypeOuterRadius2(absZ));
   const G4double xR2( p.x()*p.x()+p.y()*p.y() );
   
   if (xR2 > oRad2 + kCarTolerance*endOuterRadius) return kOutside;
   
   if (xR2 > oRad2 - kCarTolerance*endOuterRadius) return kSurface;
   
   if (InnerSurfaceExists())
   {
     //
     // Check inner radius
     //
     const G4double iRad2(HypeInnerRadius2(absZ));
     
     if (xR2 < iRad2 - kCarTolerance*endInnerRadius) return kOutside;
     
     if (xR2 < iRad2 + kCarTolerance*endInnerRadius) return kSurface;
   }
   
   //
   // We are inside in radius, now check endplate surface
   //
   if (absZ > halfLenZ - fHalfTol) return kSurface;
   
   return kInside;
 }

G4int G4Hype::IntersectHype	(	const G4ThreeVector &	p,
		const G4ThreeVector &	v,
		G4double	r2,
		G4double	tan2Phi,
		G4double	s[2]
	)

staticprotected

Definition at line 1203 of file G4Hype.cc.

References test::a, test::b, test::c, DBL_MIN, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), CLHEP::Hep3Vector::z(), and G4InuclParticleNames::z0.

Referenced by DistanceToIn(), and DistanceToOut().

 {
   G4double x0 = p.x(), y0 = p.y(), z0 = p.z();
   G4double tx = v.x(), ty = v.y(), tz = v.z();
 
   G4double a = tx*tx + ty*ty - tz*tz*tan2Phi;
   G4double b = 2*( x0*tx + y0*ty - z0*tz*tan2Phi );
   G4double c = x0*x0 + y0*y0 - r2 - z0*z0*tan2Phi;
   
   if (std::fabs(a) < DBL_MIN)
   {
     //
     // The trajectory is parallel to the asympotic limit of
     // the surface: single solution
     //
     if (std::fabs(b) < DBL_MIN) return 0;  // Unless we travel through exact center
     
     ss[0] = c/b;
     return 1;
   }
     
   
   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;
 }

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

Definition at line 171 of file G4Hype.cc.

References endInnerRadius, endInnerRadius2, endOuterRadius, endOuterRadius2, halfLenZ, innerRadius, innerRadius2, innerStereo, G4VSolid::operator=(), outerRadius, outerRadius2, outerStereo, tanInnerStereo, tanInnerStereo2, tanOuterStereo, and tanOuterStereo2.

 {
    // Check assignment to self
    //
    if (this == &rhs)  { return *this; }
 
    // Copy base class data
    //
    G4VSolid::operator=(rhs);
 
    // Copy data
    //
    innerRadius = rhs.innerRadius; outerRadius = rhs.outerRadius;
    halfLenZ = rhs.halfLenZ;
    innerStereo = rhs.innerStereo; outerStereo = rhs.outerStereo;
    tanInnerStereo = rhs.tanInnerStereo; tanOuterStereo = rhs.tanOuterStereo;
    tanInnerStereo2 = rhs.tanInnerStereo2; tanOuterStereo2 = rhs.tanOuterStereo2;
    innerRadius2 = rhs.innerRadius2; outerRadius2 = rhs.outerRadius2;
    endInnerRadius2 = rhs.endInnerRadius2; endOuterRadius2 = rhs.endOuterRadius2;
    endInnerRadius = rhs.endInnerRadius; endOuterRadius = rhs.endOuterRadius;
    fCubicVolume = rhs.fCubicVolume; fSurfaceArea = rhs.fSurfaceArea;
    fHalfTol = rhs.fHalfTol; fpPolyhedron = 0; 
 
    return *this;
 }

void G4Hype::SetInnerRadius ( G4double newIRad )

inline

Referenced by export_G4Hype().

void G4Hype::SetInnerStereo ( G4double newISte )

inline

Referenced by export_G4Hype(), and G4Hype().

void G4Hype::SetOuterRadius ( G4double newORad )

inline

Referenced by export_G4Hype().

void G4Hype::SetOuterStereo ( G4double newOSte )

inline

Referenced by export_G4Hype(), and G4Hype().

void G4Hype::SetZHalfLength ( G4double newHLZ )

inline

Referenced by export_G4Hype().

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

virtual

Implements G4VSolid.

Definition at line 1392 of file G4Hype.cc.

References python.hepunit::degree, G4VSolid::GetName(), halfLenZ, innerRadius, innerStereo, python.hepunit::mm, outerRadius, and outerStereo.

 {
   G4int oldprc = os.precision(16);
   os << "-----------------------------------------------------------\n"
      << "    *** Dump for solid - " << GetName() << " ***\n"
      << "    ===================================================\n"
      << " Solid type: G4Hype\n"
      << " Parameters: \n"
      << "    half length Z: " << halfLenZ/mm << " mm \n"
      << "    inner radius : " << innerRadius/mm << " mm \n"
      << "    outer radius : " << outerRadius/mm << " mm \n"
      << "    inner stereo angle : " << innerStereo/degree << " degrees \n"
      << "    outer stereo angle : " << outerStereo/degree << " degrees \n"
      << "-----------------------------------------------------------\n";
   os.precision(oldprc);
 
   return os;
 }

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

virtual

Implements G4VSolid.

Definition at line 547 of file G4Hype.cc.

References halfLenZ, HypeInnerRadius2(), HypeOuterRadius2(), InnerSurfaceExists(), tanInnerStereo2, tanOuterStereo2, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

 {
   //
   // Which of the three or four surfaces are we closest to?
   //
   const G4double absZ(std::fabs(p.z()));
   const G4double distZ(absZ - halfLenZ);
   const G4double dist2Z(distZ*distZ);
   
   const G4double xR2( p.x()*p.x()+p.y()*p.y() );
   const G4double dist2Outer( std::fabs(xR2 - HypeOuterRadius2(absZ)) );
   
   if (InnerSurfaceExists())
   {
     //
     // Has inner surface: is this closest?
     //
     const G4double dist2Inner( std::fabs(xR2 - HypeInnerRadius2(absZ)) );
     if (dist2Inner < dist2Z && dist2Inner < dist2Outer)
       return G4ThreeVector( -p.x(), -p.y(), p.z()*tanInnerStereo2 ).unit();
   }
 
   //
   // Do the "endcaps" win?
   //
   if (dist2Z < dist2Outer) 
     return G4ThreeVector( 0.0, 0.0, p.z() < 0 ? -1.0 : 1.0 );
     
     
   //
   // Outer surface wins
   //
   return G4ThreeVector( p.x(), p.y(), -p.z()*tanOuterStereo2 ).unit();
 }