G4EllipticalCone Class Reference

G4EllipticalCone is a full cone with elliptical base which can be cut in Z. The height in Z corresponds to where the elliptical cone hits the Z-axis if it had no Z cut. More...

#include <G4EllipticalCone.hh>

Inheritance diagram for G4EllipticalCone:

Public Member Functions
	G4EllipticalCone (const G4String &pName, G4double pxSemiAxis, G4double pySemiAxis, G4double zMax, G4double pzTopCut)
	~G4EllipticalCone () override
G4double	GetSemiAxisMin () const
G4double	GetSemiAxisMax () const
G4double	GetSemiAxisX () const
G4double	GetSemiAxisY () const
G4double	GetZMax () const
G4double	GetZTopCut () const
void	SetSemiAxis (G4double x, G4double y, G4double z)
void	SetZCut (G4double newzTopCut)
G4double	GetCubicVolume () override
G4double	GetSurfaceArea () 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
G4ThreeVector	GetPointOnSurface () const override
std::ostream &	StreamInfo (std::ostream &os) const override
G4Polyhedron *	GetPolyhedron () const override
void	DescribeYourselfTo (G4VGraphicsScene &scene) const override
G4VisExtent	GetExtent () const override
G4Polyhedron *	CreatePolyhedron () const override
	G4EllipticalCone (__void__ &)
	G4EllipticalCone (const G4EllipticalCone &rhs)
G4EllipticalCone &	operator= (const G4EllipticalCone &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 void	ComputeDimensions (G4VPVParameterisation *p, const G4int n, const G4VPhysicalVolume *pRep)
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

Protected Attributes
G4bool	fRebuildPolyhedron = false
G4Polyhedron *	fpPolyhedron = nullptr
Protected Attributes inherited from G4VSolid
G4double	kCarTolerance

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

Detailed Description

G4EllipticalCone is a full cone with elliptical base which can be cut in Z. The height in Z corresponds to where the elliptical cone hits the Z-axis if it had no Z cut.

Definition at line 92 of file G4EllipticalCone.hh.

Constructor & Destructor Documentation

G4EllipticalCone() [1/3]

G4EllipticalCone::G4EllipticalCone	(	const G4String &	pName,
		G4double	pxSemiAxis,
		G4double	pySemiAxis,
		G4double	zMax,
		G4double	pzTopCut )

Constructs an elliptical cone, with cut in Z.

Parameters

[in]	name	The solid name.
[in]	pxSemiAxis	Scalar value, defining the scaling along X-axis.
[in]	pySemiAxis	Scalar value, defining the scaling along Y-axis.
[in]	zMax	The Z-coordinate at the apex.
[in]	pzTopCut	Upper cut plane level.

Definition at line 65 of file G4EllipticalCone.cc.

  : G4VSolid(pName), zTopCut(0.)
{
  halfCarTol = 0.5*kCarTolerance;
 
  // Check Semi-Axis & Z-cut
  //
  if ( (pxSemiAxis <= 0.) || (pySemiAxis <= 0.) || (pzMax <= 0.) )
  {
     std::ostringstream message;
     message << "Invalid semi-axis or height for solid: " << GetName()
             << "\n   X semi-axis, Y semi-axis, height = "
             << pxSemiAxis << ", " << pySemiAxis << ", " << pzMax;
     G4Exception("G4EllipticalCone::G4EllipticalCone()", "GeomSolids0002",
                 FatalErrorInArgument, message);
   }
 
  if ( pzTopCut <= 0 )
  {
     std::ostringstream message;
     message << "Invalid z-coordinate for cutting plane for solid: " << GetName()
             << "\n   Z top cut = " << pzTopCut;
     G4Exception("G4EllipticalCone::G4EllipticalCone()", "GeomSolids0002",
                 FatalErrorInArgument, message);
  }
 
  SetSemiAxis( pxSemiAxis, pySemiAxis, pzMax );
  SetZCut(pzTopCut);
  GetSurfaceArea();
}

Referenced by Clone(), G4EllipticalCone(), GetZTopCut(), and operator=().

~G4EllipticalCone()

G4EllipticalCone::~G4EllipticalCone ( )

override

Destructor.

Definition at line 116 of file G4EllipticalCone.cc.

{
  delete fpPolyhedron; fpPolyhedron = nullptr;
}

G4EllipticalCone() [2/3]

G4EllipticalCone::G4EllipticalCone

(

__void__ &

a

)

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

Definition at line 105 of file G4EllipticalCone.cc.

  : G4VSolid(a), halfCarTol(0.),
    xSemiAxis(0.), ySemiAxis(0.), zheight(0.), zTopCut(0.),
    cosAxisMin(0.), invXX(0.), invYY(0.)
{
}

G4EllipticalCone() [3/3]

G4EllipticalCone::G4EllipticalCone

(

const G4EllipticalCone &

rhs

)

Copy constructor and assignment operator.

Definition at line 125 of file G4EllipticalCone.cc.

  : G4VSolid(rhs), halfCarTol(rhs.halfCarTol),
    fCubicVolume(rhs.fCubicVolume), fSurfaceArea(rhs.fSurfaceArea),
    fMinZBaseArea(rhs.fMinZBaseArea), fMaxZBaseArea(rhs.fMaxZBaseArea),
    xSemiAxis(rhs.xSemiAxis), ySemiAxis(rhs.ySemiAxis),
    zheight(rhs.zheight), zTopCut(rhs.zTopCut),
    cosAxisMin(rhs.cosAxisMin), invXX(rhs.invXX), invYY(rhs.invYY)
{
}

Member Function Documentation

BoundingLimits()

void G4EllipticalCone::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 203 of file G4EllipticalCone.cc.

{
  G4double zcut   = GetZTopCut();
  G4double height = GetZMax();
  G4double xmax   = GetSemiAxisX()*(height+zcut);
  G4double ymax   = GetSemiAxisY()*(height+zcut);
  pMin.set(-xmax,-ymax,-zcut);
  pMax.set( xmax, ymax, zcut);
 
  // 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("G4EllipticalCone::BoundingLimits()", "GeomMgt0001",
                JustWarning, message);
    DumpInfo();
  }
}

Referenced by CalculateExtent(), and GetExtent().

CalculateExtent()

G4bool G4EllipticalCone::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 233 of file G4EllipticalCone.cc.

{
  G4ThreeVector bmin,bmax;
  G4bool exist;
 
  // Check bounding box (bbox)
  //
  BoundingLimits(bmin,bmax);
  G4BoundingEnvelope bbox(bmin,bmax);
#ifdef G4BBOX_EXTENT
  return bbox.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
#endif
  if (bbox.BoundingBoxVsVoxelLimits(pAxis,pVoxelLimit,pTransform,pMin,pMax))
  {
    return exist = pMin < pMax;
  }
 
  // Set bounding envelope (benv) and calculate extent
  //
  static const G4int NSTEPS = 48; // number of steps for whole circle
  static const G4double ang = twopi/NSTEPS;
  static const G4double sinHalf = std::sin(0.5*ang);
  static const G4double cosHalf = std::cos(0.5*ang);
  static const G4double sinStep = 2.*sinHalf*cosHalf;
  static const G4double cosStep = 1. - 2.*sinHalf*sinHalf;
  G4double zcut   = bmax.z();
  G4double height = GetZMax();
  G4double sxmin  = GetSemiAxisX()*(height-zcut)/cosHalf;
  G4double symin  = GetSemiAxisY()*(height-zcut)/cosHalf;
  G4double sxmax  = bmax.x()/cosHalf;
  G4double symax  = bmax.y()/cosHalf;
 
  G4double sinCur = sinHalf;
  G4double cosCur = cosHalf;
  G4ThreeVectorList baseA(NSTEPS),baseB(NSTEPS);
  for (G4int k=0; k<NSTEPS; ++k)
  {
    baseA[k].set(sxmax*cosCur,symax*sinCur,-zcut);
    baseB[k].set(sxmin*cosCur,symin*sinCur, zcut);
 
    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;
}

Clone()

G4VSolid * G4EllipticalCone::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 836 of file G4EllipticalCone.cc.

{
  return new G4EllipticalCone(*this);
}

CreatePolyhedron()

G4Polyhedron * G4EllipticalCone::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 963 of file G4EllipticalCone.cc.

{
  return new G4PolyhedronEllipticalCone(xSemiAxis, ySemiAxis, zheight, zTopCut);
}

Referenced by GetPolyhedron().

DescribeYourselfTo()

void G4EllipticalCone::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

overridevirtual

A "double dispatch" function which identifies the solid to the graphics scene for visualization.

Implements G4VSolid.

Definition at line 949 of file G4EllipticalCone.cc.

{
  scene.AddSolid(*this);
}

DistanceToIn() [1/2]

G4double G4EllipticalCone::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 622 of file G4EllipticalCone.cc.

{
  G4double hp = std::sqrt(p.x()*p.x()*invXX + p.y()*p.y()*invYY) + p.z();
  G4double ds = (hp - zheight)*cosAxisMin;
  G4double dz = std::abs(p.z()) - zTopCut;
  G4double dist = std::max(ds,dz);
  return (dist > 0) ? dist : 0.;
}

DistanceToIn() [2/2]

G4double G4EllipticalCone::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 382 of file G4EllipticalCone.cc.

{
  G4double distMin = kInfinity;
 
  // code from EllipticalTube
 
  G4double sigz = p.z()+zTopCut;
 
  //
  // Check z = -dz planer surface
  //
 
  if (sigz < halfCarTol)
  {
    //
    // 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 ( sqr(p.x()/( xSemiAxis - halfCarTol ))
         + sqr(p.y()/( ySemiAxis - halfCarTol )) <= sqr( zheight + zTopCut ) )
      {
        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 ( sqr(xi/xSemiAxis) + sqr(yi/ySemiAxis) <= sqr( zheight + zTopCut ) )
      {
        //
        // Yup. Return q, unless we are on the surface
        //
        return (sigz < -halfCarTol) ? q : 0;
      }
      if (xi/(xSemiAxis*xSemiAxis)*v.x() + yi/(ySemiAxis*ySemiAxis)*v.y() >= 0)
      {
        //
        // Else, if we are traveling outwards, we know
        // we must miss
        //
        //        return kInfinity;
      }
    }
  }
 
  //
  // Check z = +dz planer surface
  //
  sigz = p.z() - zTopCut;
 
  if (sigz > -halfCarTol)
  {
    if (v.z() >= 0)
    {
      if (sigz > 0) { return kInfinity; }
 
      if ( sqr(p.x()/( xSemiAxis - halfCarTol ))
         + sqr(p.y()/( ySemiAxis - halfCarTol )) <= sqr( zheight-zTopCut ) )
      {
        return kInfinity;
      }
    }
    else
    {
      G4double q = -sigz/v.z();
 
      G4double xi = p.x() + q*v.x(),
               yi = p.y() + q*v.y();
 
      if ( sqr(xi/xSemiAxis) + sqr(yi/ySemiAxis) <= sqr( zheight - zTopCut ) )
      {
        return (sigz > -halfCarTol) ? q : 0;
      }
      if (xi/(xSemiAxis*xSemiAxis)*v.x() + yi/(ySemiAxis*ySemiAxis)*v.y() >= 0)
      {
        // return kInfinity;
      }
    }
  }
 
#if 0
 
  // check to see if Z plane is relevant
  //
  if (p.z() < -zTopCut - halfCarTol)
  {
    if (v.z() <= 0.0) { return distMin; }
 
    G4double lambda = (-zTopCut - p.z())/v.z();
 
    if ( sqr((lambda*v.x()+p.x())/xSemiAxis) +
         sqr((lambda*v.y()+p.y())/ySemiAxis) <=
         sqr(zTopCut + zheight + halfCarTol) )
    {
      return distMin = std::fabs(lambda);
    }
  }
 
  if (p.z() > zTopCut + halfCarTol)
  {
    if (v.z() >= 0.0) { return distMin; }
 
    G4double lambda  = (zTopCut - p.z()) / v.z();
 
    if ( sqr((lambda*v.x() + p.x())/xSemiAxis) +
         sqr((lambda*v.y() + p.y())/ySemiAxis) <=
         sqr(zheight - zTopCut + halfCarTol) )
    {
      return distMin = std::fabs(lambda);
    }
  }
 
  if (p.z() > zTopCut - halfCarTol
   && p.z() < zTopCut + halfCarTol )
  {
    if (v.z() > 0.) { return kInfinity; }
 
    return distMin = 0.;
  }
 
  if (p.z() < -zTopCut + halfCarTol
   && p.z() > -zTopCut - halfCarTol)
  {
    if (v.z() < 0.) { return distMin = kInfinity; }
 
    return distMin = 0.;
  }
 
#endif
 
  // if we are here then it either intersects or grazes the curved surface
  // or it does not intersect at all
  //
  G4double A = sqr(v.x()/xSemiAxis) + sqr(v.y()/ySemiAxis) - sqr(v.z());
  G4double B = 2*(v.x()*p.x()/sqr(xSemiAxis) +
                  v.y()*p.y()/sqr(ySemiAxis) + v.z()*(zheight-p.z()));
  G4double C = sqr(p.x()/xSemiAxis) + sqr(p.y()/ySemiAxis) -
               sqr(zheight - p.z());
 
  G4double discr = B*B - 4.*A*C;
 
  // if the discriminant is negative it never hits the curved object
  //
  if ( discr < -halfCarTol ) { return distMin; }
 
  // case below is when it hits or grazes the surface
  //
  if ( (discr >= -halfCarTol ) && (discr < halfCarTol ) )
  {
    return distMin = std::fabs(-B/(2.*A));
  }
 
  G4double plus  = (-B+std::sqrt(discr))/(2.*A);
  G4double minus = (-B-std::sqrt(discr))/(2.*A);
 
  // Special case::Point on Surface, Check norm.dot(v)
 
  if ( ( std::fabs(plus) < halfCarTol )||( std::fabs(minus) < halfCarTol ) )
  {
    G4ThreeVector truenorm(p.x()/(xSemiAxis*xSemiAxis),
                           p.y()/(ySemiAxis*ySemiAxis),
                           -( p.z() - zheight ));
    if ( truenorm*v >= 0)  //  going outside the solid from surface
    {
      return kInfinity;
    }
    return 0;
  }
 
  // G4double lambda = std::fabs(plus) < std::fabs(minus) ? plus : minus;
  G4double lambda = 0;
 
  if ( minus > halfCarTol && minus < distMin )
  {
    lambda = minus ;
    // check normal vector   n * v < 0
    G4ThreeVector pin = p + lambda*v;
    if(std::fabs(pin.z())< zTopCut + halfCarTol)
    {
      G4ThreeVector truenorm(pin.x()/(xSemiAxis*xSemiAxis),
                             pin.y()/(ySemiAxis*ySemiAxis),
                             - ( pin.z() - zheight ));
      if ( truenorm*v < 0)
      {   // yes, going inside the solid
        distMin = lambda;
      }
    }
  }
  if ( plus > halfCarTol  && plus < distMin )
  {
    lambda = plus ;
    // check normal vector   n * v < 0
    G4ThreeVector pin = p + lambda*v;
    if(std::fabs(pin.z()) < zTopCut + halfCarTol)
    {
      G4ThreeVector truenorm(pin.x()/(xSemiAxis*xSemiAxis),
                             pin.y()/(ySemiAxis*ySemiAxis),
                             - ( pin.z() - zheight ) );
      if ( truenorm*v < 0)
      {   // yes, going inside the solid
        distMin = lambda;
      }
    }
  }
  if (distMin < halfCarTol) { distMin=0.; }
  return distMin ;
}

DistanceToOut() [1/2]

G4double G4EllipticalCone::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 798 of file G4EllipticalCone.cc.

{
#ifdef G4SPECSDEBUG
  if( Inside(p) == kOutside )
  {
     std::ostringstream message;
     G4long oldprc = message.precision(16);
     message << "Point p is outside (!?) of solid: " << GetName() << "\n"
             << "Position:\n"
             << "   p.x() = "  << p.x()/mm << " mm\n"
             << "   p.y() = "  << p.y()/mm << " mm\n"
             << "   p.z() = "  << p.z()/mm << " mm";
     message.precision(oldprc) ;
     G4Exception("G4Ellipsoid::DistanceToOut(p)", "GeomSolids1002",
                 JustWarning, message);
     DumpInfo();
  }
#endif
  G4double hp = std::sqrt(p.x()*p.x()*invXX + p.y()*p.y()*invYY) + p.z();
  G4double ds = (zheight - hp)*cosAxisMin;
  G4double dz = zTopCut - std::abs(p.z());
  G4double dist = std::min(ds,dz);
  return (dist > 0) ? dist : 0.;
}

DistanceToOut() [2/2]

G4double G4EllipticalCone::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 636 of file G4EllipticalCone.cc.

{
  G4double distMin, lambda;
  enum surface_e {kPlaneSurf, kCurvedSurf, kNoSurf} surface;
 
  distMin = kInfinity;
  surface = kNoSurf;
 
  if (v.z() < 0.0)
  {
    lambda = (-p.z() - zTopCut)/v.z();
 
    if ( (sqr((p.x() + lambda*v.x())/xSemiAxis) +
          sqr((p.y() + lambda*v.y())/ySemiAxis)) <
          sqr(zheight + zTopCut + halfCarTol) )
    {
      distMin = std::fabs(lambda);
 
      if (!calcNorm) { return distMin; }
    }
    distMin = std::fabs(lambda);
    surface = kPlaneSurf;
  }
 
  if (v.z() > 0.0)
  {
    lambda = (zTopCut - p.z()) / v.z();
 
    if ( (sqr((p.x() + lambda*v.x())/xSemiAxis)
        + sqr((p.y() + lambda*v.y())/ySemiAxis) )
       < (sqr(zheight - zTopCut + halfCarTol)) )
    {
      distMin = std::fabs(lambda);
      if (!calcNorm) { return distMin; }
    }
    distMin = std::fabs(lambda);
    surface = kPlaneSurf;
  }
 
  // if we are here then it either intersects or grazes the
  // curved surface...
  //
  G4double A = sqr(v.x()/xSemiAxis) + sqr(v.y()/ySemiAxis) - sqr(v.z());
  G4double B = 2.*(v.x()*p.x()/sqr(xSemiAxis) +
                   v.y()*p.y()/sqr(ySemiAxis) + v.z()*(zheight-p.z()));
  G4double C = sqr(p.x()/xSemiAxis) + sqr(p.y()/ySemiAxis)
             - sqr(zheight - p.z());
 
  G4double discr = B*B - 4.*A*C;
 
  if ( discr >= - halfCarTol && discr < halfCarTol )
  {
    if(!calcNorm) { return distMin = std::fabs(-B/(2.*A)); }
  }
 
  else if ( discr > halfCarTol )
  {
    G4double plus  = (-B+std::sqrt(discr))/(2.*A);
    G4double minus = (-B-std::sqrt(discr))/(2.*A);
 
    if ( plus > halfCarTol && minus > halfCarTol )
    {
      // take the shorter distance
      //
      lambda   = std::fabs(plus) < std::fabs(minus) ? plus : minus;
    }
    else
    {
      // at least one solution is close to zero or negative
      // so, take small positive solution or zero
      //
      lambda   = plus > -halfCarTol ? plus : 0;
    }
 
    if ( std::fabs(lambda) < distMin )
    {
      if( std::fabs(lambda) > halfCarTol)
      {
        distMin  = std::fabs(lambda);
        surface  = kCurvedSurf;
      }
      else  // Point is On the Surface, Check Normal
      {
        G4ThreeVector truenorm(p.x()/(xSemiAxis*xSemiAxis),
                               p.y()/(ySemiAxis*ySemiAxis),
                               -( p.z() - zheight ));
        if( truenorm.dot(v) > 0 )
        {
          distMin  = 0.0;
          surface  = kCurvedSurf;
        }
      }
    }
  }
 
  // set normal if requested
  //
  if (calcNorm)
  {
    if (surface == kNoSurf)
    {
      *validNorm = false;
    }
    else
    {
      *validNorm = true;
      switch (surface)
      {
        case kPlaneSurf:
        {
          *n = G4ThreeVector(0.,0.,(v.z() > 0.0 ? 1. : -1.));
        }
        break;
 
        case kCurvedSurf:
        {
          G4ThreeVector pexit = p + distMin*v;
          G4ThreeVector truenorm( pexit.x()/(xSemiAxis*xSemiAxis),
                                  pexit.y()/(ySemiAxis*ySemiAxis),
                                  -( pexit.z() - zheight ) );
          truenorm /= truenorm.mag();
          *n= truenorm;
        }
        break;
 
        default:            // Should never reach this case ...
          DumpInfo();
          std::ostringstream message;
          G4long oldprc = message.precision(16);
          message << "Undefined side for valid surface normal to solid."
                  << 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
                  << "   v.x() = "   << v.x() << G4endl
                  << "   v.y() = "   << v.y() << G4endl
                  << "   v.z() = "   << v.z() << G4endl
                  << "Proposed distance :" << G4endl
                  << "   distMin = "    << distMin/mm << " mm";
          message.precision(oldprc);
          G4Exception("G4EllipticalCone::DistanceToOut(p,v,..)",
                      "GeomSolids1002", JustWarning, message);
          break;
      }
    }
  }
 
  if (distMin < halfCarTol) { distMin=0; }
 
  return distMin;
}

GetCubicVolume()

G4double G4EllipticalCone::GetCubicVolume ( )

overridevirtual

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

Reimplemented from G4VSolid.

Definition at line 907 of file G4EllipticalCone.cc.

{
  if (fCubicVolume == 0)
  {
    G4AutoLock l(&elconeMutex);
    G4double x0 = xSemiAxis*zheight; // x semi axis at z=0
    G4double y0 = ySemiAxis*zheight; // y semi axis at z=0
    G4double v0 = CLHEP::pi*x0*y0*zheight/3.;
    G4double kmin = (zTopCut >= zheight ) ? 0. : (zheight - zTopCut)/zheight;
    G4double kmax = (zTopCut >= zheight ) ? 2. : (zheight + zTopCut)/zheight;
    fCubicVolume = (kmax - kmin)*(kmax*kmax + kmax*kmin + kmin*kmin)*v0;
    l.unlock();
  }
  return fCubicVolume;
}

GetEntityType()

G4GeometryType G4EllipticalCone::GetEntityType ( ) const

overridevirtual

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

Implements G4VSolid.

Definition at line 827 of file G4EllipticalCone.cc.

{
  return {"G4EllipticalCone"};
}

GetExtent()

G4VisExtent G4EllipticalCone::GetExtent ( ) const

overridevirtual

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

Reimplemented from G4VSolid.

Definition at line 954 of file G4EllipticalCone.cc.

{
  // Define the sides of the box into which the solid instance would fit.
  //
  G4ThreeVector pmin,pmax;
  BoundingLimits(pmin,pmax);
  return { pmin.x(), pmax.x(), pmin.y(), pmax.y(), pmin.z(), pmax.z() };
}

GetPointOnSurface()

G4ThreeVector G4EllipticalCone::GetPointOnSurface ( ) const

overridevirtual

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

Reimplemented from G4VSolid.

Definition at line 868 of file G4EllipticalCone.cc.

{
  G4double phi = twopi*G4QuickRand();
  G4double cosphi = std::cos(phi);
  G4double sinphi = std::sin(phi);
  G4double select = fSurfaceArea*G4QuickRand();
  if (select < fMinZBaseArea + fMaxZBaseArea)
  {
    // elliptical bases
    G4double z = (select < fMinZBaseArea) ? -zTopCut : zTopCut;
    G4double a = xSemiAxis*(zheight - z);
    G4double b = ySemiAxis*(zheight - z);
    G4double rho = std::sqrt(G4QuickRand());
    return { a*rho*cosphi, b*rho*sinphi, z };
  }
  
  // lateral surface (rejection sampling)
  G4double ucut = zTopCut/zheight;
  G4double a = xSemiAxis;
  G4double b = ySemiAxis;
  G4double h = zheight;
  G4double aa = a*a;
  G4double bb = b*b;
  G4double aabb = aa*bb + bb*cosphi*cosphi + aa*sinphi*sinphi;
  G4double ss_max = 4.*ucut*ucut*(std::max(aa, bb) + aa*bb);
  G4double u;
  for (auto i = 0; i < 10000; ++i)
  {
    u = ucut*(2.*G4QuickRand() - 1.);
    G4double ss = (1. - u)*(1. - u)*aabb;
    if (ss_max*sqr(G4QuickRand()) <= ss) { break; }
  }
  return { a*h*(1. - u)*cosphi, b*h*(1 - u)*sinphi, h*u };
}

GetPolyhedron()

G4Polyhedron * G4EllipticalCone::GetPolyhedron ( ) const

overridevirtual

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

Reimplemented from G4VSolid.

Definition at line 968 of file G4EllipticalCone.cc.

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

GetSemiAxisMax()

G4double G4EllipticalCone::GetSemiAxisMax ( ) const

inline

GetSemiAxisMin()

G4double G4EllipticalCone::GetSemiAxisMin ( ) const

inline

Accessors.

GetSemiAxisX()

G4double G4EllipticalCone::GetSemiAxisX ( ) const

inline

Referenced by BoundingLimits(), CalculateExtent(), G4GDMLWriteSolids::ElconeWrite(), and G4tgbGeometryDumper::GetSolidParams().

GetSemiAxisY()

G4double G4EllipticalCone::GetSemiAxisY ( ) const

inline

Referenced by BoundingLimits(), CalculateExtent(), G4GDMLWriteSolids::ElconeWrite(), and G4tgbGeometryDumper::GetSolidParams().

GetSurfaceArea()

G4double G4EllipticalCone::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 927 of file G4EllipticalCone.cc.

{
  if (fSurfaceArea == 0)
  {
    G4AutoLock l(&elconeMutex);
    G4double x0 = xSemiAxis*zheight; // x semi axis at z=0
    G4double y0 = ySemiAxis*zheight; // y semi axis at z=0
    G4double s0 = G4GeomTools::EllipticConeLateralArea(x0,y0,zheight);
    G4double kmin = (zTopCut >= zheight ) ? 0. : (zheight - zTopCut)/zheight;
    G4double kmax = (zTopCut >= zheight ) ? 2. : (zheight + zTopCut)/zheight;
    fMinZBaseArea =  pi*x0*y0*kmax*kmax;
    fMaxZBaseArea =  pi*x0*y0*kmin*kmin;
    fSurfaceArea = (kmax - kmin)*(kmax + kmin)*s0 + fMinZBaseArea + fMaxZBaseArea;
    l.unlock();
  }
  return fSurfaceArea;
}

Referenced by G4EllipticalCone(), SetSemiAxis(), and SetZCut().

GetZMax()

G4double G4EllipticalCone::GetZMax ( ) const

inline

Referenced by BoundingLimits(), CalculateExtent(), G4GDMLWriteSolids::ElconeWrite(), and G4tgbGeometryDumper::GetSolidParams().

GetZTopCut()

G4double G4EllipticalCone::GetZTopCut ( ) const

inline

Referenced by BoundingLimits(), G4GDMLWriteSolids::ElconeWrite(), and G4tgbGeometryDumper::GetSolidParams().

Inside()

EInside G4EllipticalCone::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 293 of file G4EllipticalCone.cc.

{
  G4double hp = std::sqrt(p.x()*p.x()*invXX + p.y()*p.y()*invYY) + p.z();
  G4double ds = (hp - zheight)*cosAxisMin;
  G4double dz = std::abs(p.z()) - zTopCut;
  G4double dist = std::max(ds,dz);
 
  if (dist > halfCarTol) { return kOutside; }
  return (dist > -halfCarTol) ? kSurface : kInside;
}

Referenced by DistanceToOut().

operator=()

G4EllipticalCone & G4EllipticalCone::operator=

(

const G4EllipticalCone &

rhs

)

Definition at line 139 of file G4EllipticalCone.cc.

{
   // Check assignment to self
   //
   if (this == &rhs)  { return *this; }
 
   // Copy base class data
   //
   G4VSolid::operator=(rhs);
 
   // Copy data
   //
   halfCarTol = rhs.halfCarTol;
   fCubicVolume = rhs.fCubicVolume; fSurfaceArea = rhs.fSurfaceArea;
   fMinZBaseArea = rhs.fMinZBaseArea; fMaxZBaseArea = rhs.fMaxZBaseArea;
   xSemiAxis = rhs.xSemiAxis; ySemiAxis = rhs.ySemiAxis;
   zheight = rhs.zheight; zTopCut = rhs.zTopCut;
   cosAxisMin = rhs.cosAxisMin; invXX = rhs.invXX; invYY = rhs.invYY;
 
   fRebuildPolyhedron = false;
   delete fpPolyhedron; fpPolyhedron = nullptr;
 
   return *this;
}

SetSemiAxis()

void G4EllipticalCone::SetSemiAxis	(	G4double	x,
		G4double	y,
		G4double	z )

Modifiers.

Definition at line 168 of file G4EllipticalCone.cc.

{
  xSemiAxis = newxSemiAxis;
  ySemiAxis = newySemiAxis;
  zheight   = newzMax;
  if (zTopCut > zheight) { zTopCut = zheight; }
  G4double axmin = std::min(xSemiAxis, ySemiAxis);
  cosAxisMin = axmin/std::sqrt(1. + axmin*axmin);
  invXX = 1./(xSemiAxis*xSemiAxis);
  invYY = 1./(ySemiAxis*ySemiAxis);
  fCubicVolume = 0.0;
  fSurfaceArea = 0.0;
  GetSurfaceArea();
  fRebuildPolyhedron = true;
}

Referenced by G4EllipticalCone().

SetZCut()

void G4EllipticalCone::SetZCut

(

G4double

newzTopCut

)

Definition at line 190 of file G4EllipticalCone.cc.

{
  zTopCut = std::min(newzTopCut, zheight);
  fCubicVolume = 0.0;
  fSurfaceArea = 0.0;
  GetSurfaceArea();
  fRebuildPolyhedron = true;
}

Referenced by G4EllipticalCone().

StreamInfo()

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

overridevirtual

Streams the object contents to an output stream.

Implements G4VSolid.

Definition at line 845 of file G4EllipticalCone.cc.

{
  G4long oldprc = os.precision(16);
  os << "-----------------------------------------------------------\n"
     << "    *** Dump for solid - " << GetName() << " ***\n"
     << "    ===================================================\n"
     << " Solid type: G4EllipticalCone\n"
     << " Parameters: \n"
 
     << "    semi-axis x: " << xSemiAxis/mm << " mm \n"
     << "    semi-axis y: " << ySemiAxis/mm << " mm \n"
     << "    height    z: " << zheight/mm << " mm \n"
     << "    half length in  z: " << zTopCut/mm << " mm \n"
     << "-----------------------------------------------------------\n";
  os.precision(oldprc);
 
  return os;
}

SurfaceNormal()

G4ThreeVector G4EllipticalCone::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 308 of file G4EllipticalCone.cc.

{
  G4ThreeVector norm(0,0,0);
  G4int nsurf = 0;  // number of surfaces where p is placed
 
  G4double hp = std::sqrt(p.x()*p.x()*invXX + p.y()*p.y()*invYY) + p.z();
  G4double ds = (hp - zheight)*cosAxisMin;
  if (std::abs(ds) <= halfCarTol)
  {
    norm = G4ThreeVector(p.x()*invXX, p.y()*invYY, hp - p.z());
    G4double mag = norm.mag();
    if (mag == 0) { return {0,0,1}; } // apex
    norm *= (1/mag);
    ++nsurf;
  }
  G4double dz = std::abs(p.z()) - zTopCut;
  if (std::abs(dz) <= halfCarTol)
  {
    norm += G4ThreeVector(0., 0.,(p.z() < 0) ? -1. : 1.);
    ++nsurf;
  }
 
  if (nsurf == 1)
  {
    return norm;
  }
  if (nsurf >  1)
  {
    return norm.unit(); // elliptic edge
  }
 
  // Point is not on the surface
  //
#ifdef G4CSGDEBUG
  std::ostringstream message;
  G4long oldprc = message.precision(16);
  message << "Point p is not on surface (!?) of solid: "
          << GetName() << G4endl;
  message << "Position:\n";
  message << "   p.x() = " << p.x()/mm << " mm\n";
  message << "   p.y() = " << p.y()/mm << " mm\n";
  message << "   p.z() = " << p.z()/mm << " mm";
  G4cout.precision(oldprc);
  G4Exception("G4EllipticalCone::SurfaceNormal(p)", "GeomSolids1002",
              JustWarning, message );
  DumpInfo();
#endif
  return ApproxSurfaceNormal(p);
}

Member Data Documentation

fpPolyhedron

G4Polyhedron* G4EllipticalCone::fpPolyhedron = nullptr

mutableprotected

Definition at line 222 of file G4EllipticalCone.hh.

Referenced by GetPolyhedron(), operator=(), and ~G4EllipticalCone().

fRebuildPolyhedron

G4bool G4EllipticalCone::fRebuildPolyhedron = false

mutableprotected

Definition at line 221 of file G4EllipticalCone.hh.

Referenced by GetPolyhedron(), operator=(), SetSemiAxis(), and SetZCut().

---

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

• G4EllipticalCone.hh
• G4EllipticalCone.cc