G4Hype Class Reference

G4Hype is a tube with hyperbolic profile; it describes an hyperbolic volume with curved sides parallel to the Z axis. The solid has a specified half-length along the Z axis, about which it is centered, and a given minimum and maximum radii. More...

#include <G4Hype.hh>

Inheritance diagram for G4Hype:

Public Member Functions
	G4Hype (const G4String &pName, G4double newInnerRadius, G4double newOuterRadius, G4double newInnerStereo, G4double newOuterStereo, G4double newHalfLenZ)
	~G4Hype () override
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)
void	ComputeDimensions (G4VPVParameterisation *p, const G4int n, const G4VPhysicalVolume *pRep) override
void	BoundingLimits (G4ThreeVector &pMin, G4ThreeVector &pMax) const override
G4bool	CalculateExtent (const EAxis pAxis, const G4VoxelLimits &pVoxelLimit, const G4AffineTransform &pTransform, G4double &pMin, G4double &pMax) const override
EInside	Inside (const G4ThreeVector &p) const override
G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const override
G4double	DistanceToIn (const G4ThreeVector &p, const G4ThreeVector &v) const override
G4double	DistanceToIn (const G4ThreeVector &p) const override
G4double	DistanceToOut (const G4ThreeVector &p, const G4ThreeVector &v, const G4bool calcNorm=false, G4bool *validNorm=nullptr, G4ThreeVector *n=nullptr) const override
G4double	DistanceToOut (const G4ThreeVector &p) const override
G4GeometryType	GetEntityType () const override
G4VSolid *	Clone () const override
std::ostream &	StreamInfo (std::ostream &os) const override
G4double	GetCubicVolume () override
G4double	GetSurfaceArea () override
G4ThreeVector	GetPointOnSurface () const override
void	DescribeYourselfTo (G4VGraphicsScene &scene) const override
G4VisExtent	GetExtent () const override
G4Polyhedron *	CreatePolyhedron () const override
G4Polyhedron *	GetPolyhedron () const override
	G4Hype (__void__ &)
	G4Hype (const G4Hype &rhs)
G4Hype &	operator= (const G4Hype &rhs)
Public Member Functions inherited from G4VSolid
	G4VSolid (const G4String &name)
virtual	~G4VSolid ()
	G4VSolid (const G4VSolid &rhs)
G4VSolid &	operator= (const G4VSolid &rhs)
G4bool	operator== (const G4VSolid &s) const
G4String	GetName () const
void	SetName (const G4String &name)
G4double	GetTolerance () const
virtual G4int	GetNumOfConstituents () const
virtual G4bool	IsFaceted () 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__ &)
G4double	EstimateCubicVolume (G4int nStat, G4double epsilon) const
G4double	EstimateSurfaceArea (G4int nStat, G4double epsilon) const

Additional Inherited Members
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 inherited from G4VSolid
G4double	kCarTolerance

Detailed Description

G4Hype is a tube with hyperbolic profile; it describes an hyperbolic volume with curved sides parallel to the Z axis. The solid has a specified half-length along the Z axis, about which it is centered, and a given minimum and maximum radii.

Definition at line 71 of file G4Hype.hh.

Constructor & Destructor Documentation

G4Hype() [1/3]

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

Constructs a hyperbolic tube, given its parameters.

Parameters

[in]	pName	The solid name.
[in]	newInnerRadius	Inner radius.
[in]	newOuterRadius	Outer radius.
[in]	newInnerStereo	Inner stereo angle in radians.
[in]	newOuterStereo	Outer stereo angle in radians.
[in]	newHalfLenZ	Half length in Z.

Definition at line 61 of file G4Hype.cc.

  : G4VSolid(pName)
{
  fHalfTol = 0.5*kCarTolerance;
 
  // Check z-len
  //
  if (newHalfLenZ <= 0)
  {
    std::ostringstream message;
    message << "Invalid Z half-length in solid: " << GetName() << " !"
            << "\nZ half-length: " << newHalfLenZ/mm << " mm";
    G4Exception("G4Hype::G4Hype()", "GeomSolids0002",
                FatalErrorInArgument, message);
  }
  halfLenZ = newHalfLenZ;
 
  // Check radii
  //
  if (newInnerRadius < 0 || newOuterRadius < 0 || newInnerRadius >= newOuterRadius)
  {
    std::ostringstream message;
    message << "Invalid radii in solid: " << GetName() << " !"
            << "\nInner radius: " << newInnerRadius/mm << " mm"
            << "\nOuter radius: " << newOuterRadius/mm << " mm";
    G4Exception("G4Hype::G4Hype()", "GeomSolids0002",
                FatalErrorInArgument, message);
  }
 
  innerRadius = newInnerRadius;
  outerRadius = newOuterRadius;
 
  innerRadius2 = innerRadius*innerRadius;
  outerRadius2 = outerRadius*outerRadius;
 
  SetInnerStereo(newInnerStereo);
  SetOuterStereo(newOuterStereo);
 
  // Check end radii
  //
  if (endInnerRadius > endOuterRadius)
  {
    std::ostringstream message;
    message << "Inconsistent stereo angles in solid: " << GetName() << " !"
            << "\nEnd inner radius: " << endInnerRadius/mm << " mm"
            << "\nEnd outer radius: " << endOuterRadius/mm << " mm";
    G4Exception("G4Hype::G4Hype()", "GeomSolids0002",
                FatalErrorInArgument, message);
  }
}

Referenced by Clone(), G4Hype(), GetOuterStereo(), and operator=().

~G4Hype()

G4Hype::~G4Hype ( )

override

Destructor.

Definition at line 130 of file G4Hype.cc.

{
  delete fpPolyhedron; fpPolyhedron = nullptr;
}

G4Hype() [2/3]

G4Hype::G4Hype

(

__void__ &

a

)

Fake default constructor for usage restricted to direct object persistency for clients requiring preallocation of memory for persistifiable objects.

Definition at line 120 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.), fHalfTol(0.)
{
}

G4Hype() [3/3]

G4Hype::G4Hype

(

const G4Hype &

rhs

)

Copy constructor and assignment operator.

Definition at line 137 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),
    fInnerSurfaceArea(rhs.fInnerSurfaceArea), fOuterSurfaceArea(rhs.fOuterSurfaceArea),
    fHalfTol(rhs.fHalfTol)
{
}

Member Function Documentation

BoundingLimits()

void G4Hype::BoundingLimits ( G4ThreeVector & pMin, G4ThreeVector & pMax ) const

overridevirtual

Computes the bounding limits of the solid.

Parameters

[out]	pMin	The minimum bounding limit point.
[out]	pMax	The maximum bounding limit point.

Reimplemented from G4VSolid.

Definition at line 275 of file G4Hype.cc.

{
  pMin.set(-endOuterRadius,-endOuterRadius,-halfLenZ);
  pMax.set( endOuterRadius, endOuterRadius, halfLenZ);
 
  // Check correctness of the bounding box
  //
  if (pMin.x() >= pMax.x() || pMin.y() >= pMax.y() || pMin.z() >= pMax.z())
  {
    std::ostringstream message;
    message << "Bad bounding box (min >= max) for solid: " << GetName() << " !"
            << "\npMin = " << pMin
            << "\npMax = " << pMax;
    G4Exception("G4Hype::BoundingLimits()", "GeomMgt0001",
                JustWarning, message);
    DumpInfo();
  }
}

Referenced by CalculateExtent().

CalculateExtent()

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

overridevirtual

Calculates the minimum and maximum extent of the solid, when under the specified transform, and within the specified limits.

Parameters

[in]	pAxis	The axis along which compute the extent.
[in]	pVoxelLimit	The limiting space dictated by voxels.
[in]	pTransform	The internal transformation applied to the solid.
[out]	pMin	The minimum extent value.
[out]	pMax	The maximum extent value.

Returns

True if the solid is intersected by the extent region.

Implements G4VSolid.

Definition at line 296 of file G4Hype.cc.

{
  G4ThreeVector bmin, bmax;
 
  // Get bounding box
  BoundingLimits(bmin,bmax);
 
  // Find extent
  G4BoundingEnvelope bbox(bmin,bmax);
  return bbox.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
}

Clone()

G4VSolid * G4Hype::Clone ( ) const

overridevirtual

Makes a clone of the object for use in multi-treading.

Returns

A pointer to the new cloned allocated solid.

Reimplemented from G4VSolid.

Definition at line 1176 of file G4Hype.cc.

{
  return new G4Hype(*this);
}

ComputeDimensions()

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

overridevirtual

Dispatch method for parameterisation replication mechanism and dimension computation.

Reimplemented from G4VSolid.

Definition at line 266 of file G4Hype.cc.

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

CreatePolyhedron()

G4Polyhedron * G4Hype::CreatePolyhedron ( ) const

overridevirtual

Creates a Polyhedron used for Visualisation. It is the caller's responsibility to delete it. A null pointer means "not created".

Reimplemented from G4VSolid.

Definition at line 1290 of file G4Hype.cc.

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

Referenced by GetPolyhedron().

DescribeYourselfTo()

void G4Hype::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

overridevirtual

Methods for creating graphical representations (i.e. for visualisation).

Implements G4VSolid.

Definition at line 1272 of file G4Hype.cc.

{
  scene.AddSolid (*this);
}

DistanceToIn() [1/2]

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

overridevirtual

Calculates the distance to the nearest surface of a shape from an outside point. The distance can be an underestimate.

Parameters

[in]

p

The point at offset p.

Returns

The safety distance to enter the shape.

Implements G4VSolid.

Definition at line 704 of file G4Hype.cc.

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

DistanceToIn() [2/2]

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

overridevirtual

Returns the distance along the normalised vector 'v' to the shape, from the point at offset 'p'. If there is no intersection, returns kInfinity. The first intersection resulting from 'leaving' a surface/volume is discarded. Hence, it is tolerant of points on the surface of the shape.

Parameters

[in]	p	The point at offset p.
[in]	v	The normalised direction vector.

Returns

The distance to enter the shape.

Implements G4VSolid.

Definition at line 401 of file G4Hype.cc.

{
  //
  // 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;
        }
        
        //
        // 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
    //
    for( G4int 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)
  //
  for( G4int 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;
}

DistanceToOut() [1/2]

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

overridevirtual

Calculates the distance to the nearest surface of a shape from an inside point 'p'. The distance can be an underestimate.

Parameters

[in]

p

The point at offset p.

Returns

The safety distance to exit the shape.

Implements G4VSolid.

Definition at line 958 of file G4Hype.cc.

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

DistanceToOut() [2/2]

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

overridevirtual

Returns the distance along the normalised vector 'v' to the shape, from a point at an offset 'p' inside or on the surface of the shape. Intersections with surfaces, when the point is less than Tolerance/2 from a surface must be ignored.

Parameters

[in]	p	The point at offset p.
[in]	v	The normalised direction vector.
[in]	calcNorm	Flag to indicate if to calculate the normal or not.
[out]	validNorm	Flag set to true if the solid lies entirely behind or on the exiting surface. It is set false if the solid does not lie entirely behind or on the exiting surface. 'calcNorm' must be true, otherwise it is unused.
[out]	n	The exiting outwards normal vector (undefined Magnitude). 'calcNorm' must be true, otherwise it is unused.

Returns

The distance to exit the shape.

Implements G4VSolid.

Definition at line 785 of file G4Hype.cc.

{
  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.
    //
    for( G4int 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
      //
      for( G4int 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;
}

GetCubicVolume()

G4double G4Hype::GetCubicVolume ( )

overridevirtual

Returning an estimation of the solid volume (capacity) and surface area, in internal units.

Reimplemented from G4VSolid.

Definition at line 1245 of file G4Hype.cc.

{
  if (fCubicVolume == 0)
  {
    G4AutoLock l(&hypeMutex);
    fCubicVolume =
      twopi*halfLenZ*(2.*(outerRadius2 - innerRadius2) + endOuterRadius2 - endInnerRadius2)/3.;
    l.unlock();
  }
  return fCubicVolume;
}

GetEntityType()

G4GeometryType G4Hype::GetEntityType ( ) const

overridevirtual

Returns the type ID, "G4Hype" of the solid.

Implements G4VSolid.

Definition at line 1169 of file G4Hype.cc.

{
  return {"G4Hype"};
}

GetExtent()

G4VisExtent G4Hype::GetExtent ( ) const

overridevirtual

Provides extent (bounding box) as possible hint to the graphics view.

Reimplemented from G4VSolid.

Definition at line 1279 of file G4Hype.cc.

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

GetInnerRadius()

G4double G4Hype::GetInnerRadius ( ) const

inline

Accessors.

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

GetInnerStereo()

G4double G4Hype::GetInnerStereo ( ) const

inline

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

GetOuterRadius()

G4double G4Hype::GetOuterRadius ( ) const

inline

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

GetOuterStereo()

G4double G4Hype::GetOuterStereo ( ) const

inline

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

GetPointOnSurface()

G4ThreeVector G4Hype::GetPointOnSurface ( ) const

overridevirtual

Returns a random point located and uniformly distributed on the surface of the solid.

Reimplemented from G4VSolid.

Definition at line 1204 of file G4Hype.cc.

{
  G4double sbases = twopi*(endOuterRadius2 - endInnerRadius2);
  G4double stotal = fInnerSurfaceArea + fOuterSurfaceArea + sbases;
  G4double select = stotal*G4QuickRand();
 
  G4double h = halfLenZ;
  G4double phi = twopi*G4QuickRand();
  G4double cosphi = std::cos(phi);
  G4double sinphi = std::sin(phi);
  if (select < sbases)
  {
    // circular bases
    G4double u = G4QuickRand();
    G4double rho = std::sqrt(u*endOuterRadius2 + (1. - u)*endInnerRadius2);
    G4double z = (select < 0.5*sbases) ? -h : h;
    return { rho*cosphi, rho*sinphi, z };
  }
  
  // lateral surfaces (rejection sampling)
  G4double hh = h*h;
  G4double rr = (select < stotal - fInnerSurfaceArea) ? outerRadius2 : innerRadius2;
  G4double endrr = (select < stotal - fInnerSurfaceArea) ? endOuterRadius2 : endInnerRadius2;
  G4double delrr = endrr - rr;
  // max surface element: std::sqrt(aa*hh + (RR - aa)*(RR - aa + hh)*1.0)
  G4double ss_max = rr*hh + delrr*(delrr + hh);
  G4double u = 0.;
  for (auto i = 0; i < 10000; ++i)
  {
    u = 2.*G4QuickRand() - 1.;
    // surface element: std::sqrt(aa*hh + (RR - aa)*(RR - aa + hh)*uu)
    G4double ss = rr*hh + delrr*(delrr + hh)*u*u;
    if (ss_max*sqr(G4QuickRand()) <= ss) { break; }
  }
  G4double z = h*u;
  G4double rho = std::sqrt(rr + delrr*u*u);
  return { rho*cosphi, rho*sinphi, z };
}

GetPolyhedron()

G4Polyhedron * G4Hype::GetPolyhedron ( ) const

overridevirtual

Smart access function - creates on request and stores for future access. A null pointer means "not available".

Reimplemented from G4VSolid.

Definition at line 1298 of file G4Hype.cc.

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

GetSurfaceArea()

G4double G4Hype::GetSurfaceArea ( )

overridevirtual

Returns an estimation of the solid surface area in internal units. This method may be overloaded by derived classes to compute the exact geometrical quantity for solids where this is possible, or anyway to cache the computed value. Note: the computed value is NOT cached.

Reimplemented from G4VSolid.

Definition at line 1259 of file G4Hype.cc.

{
  if (fSurfaceArea == 0)
  {
    G4AutoLock l(&hypeMutex);
    fSurfaceArea = fInnerSurfaceArea + fOuterSurfaceArea + twopi*(endOuterRadius2 - endInnerRadius2);
    l.unlock();
  }
  return fSurfaceArea;
}

GetZHalfLength()

G4double G4Hype::GetZHalfLength ( ) const

inline

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

Inside()

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

overridevirtual

Concrete implementations of the expected query interfaces for solids, as defined in the base class G4VSolid.

Implements G4VSolid.

Definition at line 313 of file G4Hype.cc.

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

operator=()

G4Hype & G4Hype::operator=

(

const G4Hype &

rhs

)

Definition at line 154 of file G4Hype.cc.

{
   // 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;
   fInnerSurfaceArea = rhs.fInnerSurfaceArea; fOuterSurfaceArea = rhs.fOuterSurfaceArea;
   fHalfTol = rhs.fHalfTol;
   fRebuildPolyhedron = false;
   delete fpPolyhedron; fpPolyhedron = nullptr;
 
   return *this;
}

SetInnerRadius()

void G4Hype::SetInnerRadius

(

G4double

newIRad

)

Modifiers.

Definition at line 185 of file G4Hype.cc.

{
  innerRadius = newIRad;
  innerRadius2 = newIRad*newIRad;
  endInnerRadius2 = HypeInnerRadius2(halfLenZ);
  endInnerRadius = std::sqrt(endInnerRadius2);
  fCubicVolume = 0.;
  fSurfaceArea = 0.;
  fInnerSurfaceArea =
    G4GeomTools::HyperboloidSurfaceArea(twopi, innerRadius, tanInnerStereo, -halfLenZ, halfLenZ);
  fRebuildPolyhedron = true;
}

SetInnerStereo()

void G4Hype::SetInnerStereo

(

G4double

newISte

)

Definition at line 233 of file G4Hype.cc.

{
  innerStereo = std::abs(newISte);
  tanInnerStereo = std::tan(innerStereo);
  tanInnerStereo2 = tanInnerStereo*tanInnerStereo;
  endInnerRadius2 = HypeInnerRadius2(halfLenZ);
  endInnerRadius = std::sqrt(endInnerRadius2);
  fCubicVolume = 0.;
  fSurfaceArea = 0.;
  fInnerSurfaceArea =
    G4GeomTools::HyperboloidSurfaceArea(twopi, innerRadius, tanInnerStereo, -halfLenZ, halfLenZ);
  fRebuildPolyhedron = true;
}

Referenced by G4Hype().

SetOuterRadius()

void G4Hype::SetOuterRadius

(

G4double

newORad

)

Definition at line 200 of file G4Hype.cc.

{
  outerRadius = newORad;
  outerRadius2 = newORad*newORad;
  endOuterRadius2 = HypeOuterRadius2(halfLenZ);
  endOuterRadius = std::sqrt(endOuterRadius2);
  fCubicVolume = 0.;
  fSurfaceArea = 0.;
  fOuterSurfaceArea =
    G4GeomTools::HyperboloidSurfaceArea(twopi, outerRadius, tanOuterStereo, -halfLenZ, halfLenZ);
  fRebuildPolyhedron = true;
}

SetOuterStereo()

void G4Hype::SetOuterStereo

(

G4double

newOSte

)

Definition at line 249 of file G4Hype.cc.

{
  outerStereo = std::abs(newOSte);
  tanOuterStereo = std::tan(outerStereo);
  tanOuterStereo2 = tanOuterStereo*tanOuterStereo;
  endOuterRadius2 = HypeOuterRadius2(halfLenZ);
  endOuterRadius = std::sqrt(endOuterRadius2);
  fCubicVolume = 0.;
  fSurfaceArea = 0.;
  fOuterSurfaceArea =
    G4GeomTools::HyperboloidSurfaceArea(twopi, outerRadius, tanOuterStereo, -halfLenZ, halfLenZ);
  fRebuildPolyhedron = true;
}

Referenced by G4Hype().

SetZHalfLength()

void G4Hype::SetZHalfLength

(

G4double

newHLZ

)

Definition at line 215 of file G4Hype.cc.

{
  halfLenZ = newHLZ;
  endInnerRadius2 = HypeInnerRadius2(halfLenZ);
  endInnerRadius = std::sqrt(endInnerRadius2);
  endOuterRadius2 = HypeOuterRadius2(halfLenZ);
  endOuterRadius = std::sqrt(endOuterRadius2);
  fCubicVolume = 0.;
  fSurfaceArea = 0.;
  fInnerSurfaceArea =
    G4GeomTools::HyperboloidSurfaceArea(twopi, innerRadius, tanInnerStereo, -halfLenZ, halfLenZ);
  fOuterSurfaceArea =
    G4GeomTools::HyperboloidSurfaceArea(twopi, outerRadius, tanOuterStereo, -halfLenZ, halfLenZ);
  fRebuildPolyhedron = true;
}

StreamInfo()

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

overridevirtual

Streams the object contents to an output stream.

Implements G4VSolid.

Definition at line 1183 of file G4Hype.cc.

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

SurfaceNormal()

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

overridevirtual

Returns the outwards pointing unit normal of the shape for the surface closest to the point at offset 'p'.

Parameters

[in]

p

The point at offset p.

Returns

The outwards pointing unit normal.

Implements G4VSolid.

Definition at line 354 of file G4Hype.cc.

{
  //
  // 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 { 0.0, 0.0, (G4double)(p.z() < 0 ? -1.0 : 1.0) };
  }
 
  //
  // Outer surface wins
  //
  return G4ThreeVector( p.x(), p.y(), -p.z()*tanOuterStereo2 ).unit();
}

---

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

• G4Hype.hh
• G4Hype.cc