G4PolyconeSide Class Reference

G4PolyconeSide is a utility class implementing a face that represents one conical side of a polycone. More...

#include <G4PolyconeSide.hh>

Inheritance diagram for G4PolyconeSide:

Public Member Functions
	G4PolyconeSide (const G4PolyconeSideRZ *prevRZ, const G4PolyconeSideRZ *tail, const G4PolyconeSideRZ *head, const G4PolyconeSideRZ *nextRZ, G4double phiStart, G4double deltaPhi, G4bool phiIsOpen, G4bool isAllBehind=false)
	~G4PolyconeSide () override
	G4PolyconeSide (const G4PolyconeSide &source)
G4PolyconeSide &	operator= (const G4PolyconeSide &source)
G4bool	Intersect (const G4ThreeVector &p, const G4ThreeVector &v, G4bool outgoing, G4double surfTolerance, G4double &distance, G4double &distFromSurface, G4ThreeVector &normal, G4bool &isAllBehind) override
G4double	Distance (const G4ThreeVector &p, G4bool outgoing) override
EInside	Inside (const G4ThreeVector &p, G4double tolerance, G4double *bestDistance) override
G4ThreeVector	Normal (const G4ThreeVector &p, G4double *bestDistance) override
G4double	Extent (const G4ThreeVector axis) override
void	CalculateExtent (const EAxis axis, const G4VoxelLimits &voxelLimit, const G4AffineTransform &tranform, G4SolidExtentList &extentList) override
G4VCSGface *	Clone () override
G4double	SurfaceArea () override
G4ThreeVector	GetPointOnFace () override
	G4PolyconeSide (__void__ &)
G4int	GetInstanceID () const
Public Member Functions inherited from G4VCSGface
	G4VCSGface ()=default
virtual	~G4VCSGface ()=default

Static Public Member Functions
static const G4PlSideManager &	GetSubInstanceManager ()

Detailed Description

G4PolyconeSide is a utility class implementing a face that represents one conical side of a polycone.

Definition at line 90 of file G4PolyconeSide.hh.

Constructor & Destructor Documentation

G4PolyconeSide() [1/3]

G4PolyconeSide::G4PolyconeSide	(	const G4PolyconeSideRZ *	prevRZ,
		const G4PolyconeSideRZ *	tail,
		const G4PolyconeSideRZ *	head,
		const G4PolyconeSideRZ *	nextRZ,
		G4double	phiStart,
		G4double	deltaPhi,
		G4bool	phiIsOpen,
		G4bool	isAllBehind = false )

Constructor for the conical side of a polycone.

Parameters

[in]	prevRZ	Pointer to previous r,Z section.
[in]	tail	Pointer to r,Z tail of section.
[in]	head	Pointer to r,Z head of section.
[in]	nextRZ	Pointer to next r,Z section.
[in]	phiStart	Initial Phi starting angle.
[in]	deltaPhi	Total Phi angle.
[in]	phiIsOpen	Flag indicating if it is a Phi section.
[in]	isAllBehind	Indicating if entire surface is behind normal.

Definition at line 67 of file G4PolyconeSide.cc.

{
  instanceID = subInstanceManager.CreateSubInstance();
 
  kCarTolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
  G4MT_pcphix = 0.0; G4MT_pcphiy = 0.0; G4MT_pcphiz = 0.0; G4MT_pcphik = 0.0;
 
  //
  // Record values
  //
  r[0] = tail->r; z[0] = tail->z;
  r[1] = head->r; z[1] = head->z;
  
  phiIsOpen = thePhiIsOpen;
  if (phiIsOpen)
  {
    deltaPhi = theDeltaPhi;
    startPhi = thePhiStart;
 
    //
    // Set phi values to our conventions
    //
    while (deltaPhi < 0.0)    // Loop checking, 13.08.2015, G.Cosmo
    {
      deltaPhi += twopi;
    }
    while (startPhi < 0.0)    // Loop checking, 13.08.2015, G.Cosmo
    {
      startPhi += twopi;
    }
    
    //
    // Calculate corner coordinates
    //
    ncorners = 4;
    corners = new G4ThreeVector[ncorners];
    
    corners[0] = G4ThreeVector( tail->r*std::cos(startPhi),
                                tail->r*std::sin(startPhi), tail->z );
    corners[1] = G4ThreeVector( head->r*std::cos(startPhi),
                                head->r*std::sin(startPhi), head->z );
    corners[2] = G4ThreeVector( tail->r*std::cos(startPhi+deltaPhi),
                                tail->r*std::sin(startPhi+deltaPhi), tail->z );
    corners[3] = G4ThreeVector( head->r*std::cos(startPhi+deltaPhi),
                                head->r*std::sin(startPhi+deltaPhi), head->z );
  }
  else
  {
    deltaPhi = twopi;
    startPhi = 0.0;
  }
  
  allBehind = isAllBehind;
    
  //
  // Make our intersecting cone
  //
  cone = new G4IntersectingCone( r, z );
  
  //
  // Calculate vectors in r,z space
  //
  rS = r[1]-r[0]; zS = z[1]-z[0];
  length = std::sqrt( rS*rS + zS*zS);
  rS /= length; zS /= length;
  
  rNorm = +zS;
  zNorm = -rS;
  
  G4double lAdj;
  
  prevRS = r[0]-prevRZ->r;
  prevZS = z[0]-prevRZ->z;
  lAdj = std::sqrt( prevRS*prevRS + prevZS*prevZS );
  prevRS /= lAdj;
  prevZS /= lAdj;
 
  rNormEdge[0] = rNorm + prevZS;
  zNormEdge[0] = zNorm - prevRS;
  lAdj = std::sqrt( rNormEdge[0]*rNormEdge[0] + zNormEdge[0]*zNormEdge[0] );
  rNormEdge[0] /= lAdj;
  zNormEdge[0] /= lAdj;
 
  nextRS = nextRZ->r-r[1];
  nextZS = nextRZ->z-z[1];
  lAdj = std::sqrt( nextRS*nextRS + nextZS*nextZS );
  nextRS /= lAdj;
  nextZS /= lAdj;
 
  rNormEdge[1] = rNorm + nextZS;
  zNormEdge[1] = zNorm - nextRS;
  lAdj = std::sqrt( rNormEdge[1]*rNormEdge[1] + zNormEdge[1]*zNormEdge[1] );
  rNormEdge[1] /= lAdj;
  zNormEdge[1] /= lAdj;
}

Referenced by Clone(), G4PolyconeSide(), and operator=().

~G4PolyconeSide()

G4PolyconeSide::~G4PolyconeSide ( )

override

Destructor.

Definition at line 187 of file G4PolyconeSide.cc.

{
  delete cone;
  if (phiIsOpen) { delete [] corners; }
}

G4PolyconeSide() [2/3]

G4PolyconeSide::G4PolyconeSide

(

const G4PolyconeSide &

source

)

Copy constructor and assignment operator.

Definition at line 195 of file G4PolyconeSide.cc.

{
  instanceID = subInstanceManager.CreateSubInstance();
 
  CopyStuff( source );
}

G4PolyconeSide() [3/3]

G4PolyconeSide::G4PolyconeSide

(

__void__ &

)

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

Definition at line 173 of file G4PolyconeSide.cc.

  : startPhi(0.), deltaPhi(0.),
    rNorm(0.), zNorm(0.), rS(0.), zS(0.), length(0.),
    prevRS(0.), prevZS(0.), nextRS(0.), nextZS(0.),
    kCarTolerance(0.), instanceID(0)
{
  r[0] = r[1] = 0.;
  z[0] = z[1] = 0.;
  rNormEdge[0]= rNormEdge[1] = 0.;
  zNormEdge[0]= zNormEdge[1] = 0.;
}

Member Function Documentation

CalculateExtent()

void G4PolyconeSide::CalculateExtent ( const EAxis axis, const G4VoxelLimits & voxelLimit, const G4AffineTransform & tranform, G4SolidExtentList & extentList )

overridevirtual

Calculates the extent of the face for the voxel navigator.

Parameters

[in]	axis	The axis in which to check the shapes 3D extent against.
[in]	voxelLimit	Limits along x, y, and/or z axes.
[in]	tranform	A coordinate transformation on which to apply to the shape before testing.
[out]	extentList	The list of (voxel) extents along the axis.

Implements G4VCSGface.

Definition at line 549 of file G4PolyconeSide.cc.

{
  G4ClippablePolygon polygon;
  
  //
  // Here we will approximate (ala G4Cons) and divide our conical section
  // into segments, like G4Polyhedra. When doing so, the radius
  // is extented far enough such that the segments always lie
  // just outside the surface of the conical section we are
  // approximating.
  //
  
  //
  // Choose phi size of our segment(s) based on constants as
  // defined in meshdefs.hh
  //
  G4int numPhi = (G4int)(deltaPhi/kMeshAngleDefault) + 1;
  if (numPhi < kMinMeshSections)
  { 
    numPhi = kMinMeshSections;
  }
  else if (numPhi > kMaxMeshSections)
  {
    numPhi = kMaxMeshSections;
  }
    
  G4double sigPhi = deltaPhi/numPhi;
  
  //
  // Determine radius factor to keep segments outside
  //
  G4double rFudge = 1.0/std::cos(0.5*sigPhi);
  
  //
  // Decide which radius to use on each end of the side,
  // and whether a transition mesh is required
  //
  // {r0,z0}  - Beginning of this side
  // {r1,z1}  - Ending of this side
  // {r2,z0}  - Beginning of transition piece connecting previous
  //            side (and ends at beginning of this side)
  //
  // So, order is 2 --> 0 --> 1.
  //                    -------
  //
  // r2 < 0 indicates that no transition piece is required
  //
  G4double r0, r1, r2, z0, z1;
  
  r2 = -1;  // By default: no transition piece
  
  if (rNorm < -DBL_MIN)
  {
    //
    // This side faces *inward*, and so our mesh has
    // the same radius
    //
    r1 = r[1];
    z1 = z[1];
    z0 = z[0];
    r0 = r[0];
    
    r2 = -1;
    
    if (prevZS > DBL_MIN)
    {
      //
      // The previous side is facing outwards
      //
      if ( prevRS*zS - prevZS*rS > 0 )
      {
        //
        // Transition was convex: build transition piece
        //
        if (r[0] > DBL_MIN) { r2 = r[0]*rFudge; }
      }
      else
      {
        //
        // Transition was concave: short this side
        //
        FindLineIntersect( z0, r0, zS, rS,
                           z0, r0*rFudge, prevZS, prevRS*rFudge, z0, r0 );
      }
    }
    
    if ( nextZS > DBL_MIN && (rS*nextZS - zS*nextRS < 0) )
    {
      //
      // The next side is facing outwards, forming a 
      // concave transition: short this side
      //
      FindLineIntersect( z1, r1, zS, rS,
                         z1, r1*rFudge, nextZS, nextRS*rFudge, z1, r1 );
    }
  }
  else if (rNorm > DBL_MIN)
  {
    //
    // This side faces *outward* and is given a boost to
    // it radius
    //
    r0 = r[0]*rFudge;
    z0 = z[0];
    r1 = r[1]*rFudge;
    z1 = z[1];
    
    if (prevZS < -DBL_MIN)
    {
      //
      // The previous side is facing inwards
      //
      if ( prevRS*zS - prevZS*rS > 0 )
      {
        //
        // Transition was convex: build transition piece
        //
        if (r[0] > DBL_MIN) { r2 = r[0]; }
      }
      else
      {
        //
        // Transition was concave: short this side
        //
        FindLineIntersect( z0, r0, zS, rS*rFudge,
                           z0, r[0], prevZS, prevRS, z0, r0 );
      }
    }
    
    if ( nextZS < -DBL_MIN && (rS*nextZS - zS*nextRS < 0) )
    {
      //
      // The next side is facing inwards, forming a 
      // concave transition: short this side
      //
      FindLineIntersect( z1, r1, zS, rS*rFudge,
                         z1, r[1], nextZS, nextRS, z1, r1 );
    }
  }
  else
  {
    //
    // This side is perpendicular to the z axis (is a disk)
    //
    // Whether or not r0 needs a rFudge factor depends
    // on the normal of the previous edge. Similar with r1
    // and the next edge. No transition piece is required.
    //
    r0 = r[0];
    r1 = r[1];
    z0 = z[0];
    z1 = z[1];
    
    if (prevZS > DBL_MIN) { r0 *= rFudge; }
    if (nextZS > DBL_MIN) { r1 *= rFudge; }
  }
  
  //
  // Loop
  //
  G4double phi = startPhi, 
           cosPhi = std::cos(phi), 
           sinPhi = std::sin(phi);
  
  G4ThreeVector v0( r0*cosPhi, r0*sinPhi, z0 ),
                    v1( r1*cosPhi, r1*sinPhi, z1 ),
  v2, w0, w1, w2;
  transform.ApplyPointTransform( v0 );
  transform.ApplyPointTransform( v1 );
  
  if (r2 >= 0)
  {
    v2 = G4ThreeVector( r2*cosPhi, r2*sinPhi, z0 );
    transform.ApplyPointTransform( v2 );
  }
 
  do    // Loop checking, 13.08.2015, G.Cosmo
  {
    phi += sigPhi;
    if (numPhi == 1) { phi = startPhi+deltaPhi; } // Try to avoid roundoff
    cosPhi = std::cos(phi), 
    sinPhi = std::sin(phi);
    
    w0 = G4ThreeVector( r0*cosPhi, r0*sinPhi, z0 );
    w1 = G4ThreeVector( r1*cosPhi, r1*sinPhi, z1 );
    transform.ApplyPointTransform( w0 );
    transform.ApplyPointTransform( w1 );
    
    G4ThreeVector deltaV = r0 > r1 ? w0-v0 : w1-v1;
    
    //
    // Build polygon, taking special care to keep the vertices
    // in order
    //
    polygon.ClearAllVertices();
 
    polygon.AddVertexInOrder( v0 );
    polygon.AddVertexInOrder( v1 );
    polygon.AddVertexInOrder( w1 );
    polygon.AddVertexInOrder( w0 );
 
    //
    // Get extent
    //
    if (polygon.PartialClip( voxelLimit, axis ))
    {
      //
      // Get dot product of normal with target axis
      //
      polygon.SetNormal( deltaV.cross(v1-v0).unit() );
      
      extentList.AddSurface( polygon );
    }
    
    if (r2 >= 0)
    {
      //
      // Repeat, for transition piece
      //
      w2 = G4ThreeVector( r2*cosPhi, r2*sinPhi, z0 );
      transform.ApplyPointTransform( w2 );
 
      polygon.ClearAllVertices();
 
      polygon.AddVertexInOrder( v2 );
      polygon.AddVertexInOrder( v0 );
      polygon.AddVertexInOrder( w0 );
      polygon.AddVertexInOrder( w2 );
 
      if (polygon.PartialClip( voxelLimit, axis ))
      {
        polygon.SetNormal( deltaV.cross(v0-v2).unit() );
        
        extentList.AddSurface( polygon );
      }
      
      v2 = w2;
    }
    
    //
    // Next vertex
    //    
    v0 = w0;
    v1 = w1;
  } while( --numPhi > 0 );
  
  //
  // We are almost done. But, it is important that we leave no
  // gaps in the surface of our solid. By using rFudge, however,
  // we've done exactly that, if we have a phi segment. 
  // Add two additional faces if necessary
  //
  if (phiIsOpen && rNorm > DBL_MIN)
  {    
    cosPhi = std::cos(startPhi);
    sinPhi = std::sin(startPhi);
 
    G4ThreeVector a0( r[0]*cosPhi, r[0]*sinPhi, z[0] ),
                  a1( r[1]*cosPhi, r[1]*sinPhi, z[1] ),
                  b0( r0*cosPhi, r0*sinPhi, z[0] ),
                  b1( r1*cosPhi, r1*sinPhi, z[1] );
  
    transform.ApplyPointTransform( a0 );
    transform.ApplyPointTransform( a1 );
    transform.ApplyPointTransform( b0 );
    transform.ApplyPointTransform( b1 );
 
    polygon.ClearAllVertices();
 
    polygon.AddVertexInOrder( a0 );
    polygon.AddVertexInOrder( a1 );
    polygon.AddVertexInOrder( b0 );
    polygon.AddVertexInOrder( b1 );
    
    if (polygon.PartialClip( voxelLimit , axis))
    {
      G4ThreeVector normal( sinPhi, -cosPhi, 0 );
      polygon.SetNormal( transform.TransformAxis( normal ) );
        
      extentList.AddSurface( polygon );
    }
    
    cosPhi = std::cos(startPhi+deltaPhi);
    sinPhi = std::sin(startPhi+deltaPhi);
    
    a0 = G4ThreeVector( r[0]*cosPhi, r[0]*sinPhi, z[0] ),
    a1 = G4ThreeVector( r[1]*cosPhi, r[1]*sinPhi, z[1] ),
    b0 = G4ThreeVector( r0*cosPhi, r0*sinPhi, z[0] ),
    b1 = G4ThreeVector( r1*cosPhi, r1*sinPhi, z[1] );
    transform.ApplyPointTransform( a0 );
    transform.ApplyPointTransform( a1 );
    transform.ApplyPointTransform( b0 );
    transform.ApplyPointTransform( b1 );
 
    polygon.ClearAllVertices();
 
    polygon.AddVertexInOrder( a0 );
    polygon.AddVertexInOrder( a1 );
    polygon.AddVertexInOrder( b0 );
    polygon.AddVertexInOrder( b1 );
    
    if (polygon.PartialClip( voxelLimit, axis ))
    {
      G4ThreeVector normal( -sinPhi, cosPhi, 0 );
      polygon.SetNormal( transform.TransformAxis( normal ) );
        
      extentList.AddSurface( polygon );
    }
  }
    
  return;
}

Clone()

G4VCSGface * G4PolyconeSide::Clone ( )

inlineoverridevirtual

Method invoked by the copy constructor or the assignment operator. Its purpose is to return a pointer to a duplicate copy of the face.

Implements G4VCSGface.

Definition at line 200 of file G4PolyconeSide.hh.

{ return new G4PolyconeSide( *this ); }

Distance()

G4double G4PolyconeSide::Distance ( const G4ThreeVector & p, G4bool outgoing )

overridevirtual

Determines the distance of a point from either the inside or outside surfaces of the face.

Parameters

[in]	p	Position.
[in]	outgoing	Flag, true, to consider only inside surfaces or false, to consider only outside surfaces.

Returns

The distance to the closest surface satisfying requirements or kInfinity if no such surface exists.

Implements G4VCSGface.

Definition at line 399 of file G4PolyconeSide.cc.

{
  G4double normSign = outgoing ? -1 : +1;
  G4double distFrom, distOut2;
  
  //
  // We have two tries for each hemisphere. Try the closest first.
  //
  distFrom = normSign*DistanceAway( p, false, distOut2 );
  if (distFrom > -0.5*kCarTolerance )
  {
    //
    // Good answer
    //
    if (distOut2 > 0)
    { 
      return std::sqrt( distFrom*distFrom + distOut2 );
    }
    return std::fabs(distFrom);
  }
  
  //
  // Try second side. 
  //
  distFrom = normSign*DistanceAway( p,  true, distOut2 );
  if (distFrom > -0.5*kCarTolerance)
  {
    if (distOut2 > 0)
    { 
      return std::sqrt( distFrom*distFrom + distOut2 );
    }
    return std::fabs(distFrom);
  }
  
  return kInfinity;
}

Extent()

G4double G4PolyconeSide::Extent ( const G4ThreeVector axis )

overridevirtual

Returns the face extent along the axis.

Parameters

[in]

axis

Unit vector defining the direction.

Returns

The largest point along the given axis of the face's extent.

Implements G4VCSGface.

Definition at line 485 of file G4PolyconeSide.cc.

{
  if (axis.perp2() < DBL_MIN)
  {
    //
    // Special case
    //
    return axis.z() < 0 ? -cone->ZLo() : cone->ZHi();
  }
 
  //
  // Is the axis pointing inside our phi gap?
  //
  if (phiIsOpen)
  {
    G4double phi = GetPhi(axis);
    while( phi < startPhi )    // Loop checking, 13.08.2015, G.Cosmo
    {
      phi += twopi;
    }
    
    if (phi > deltaPhi+startPhi)
    {
      //
      // Yeah, looks so. Make four three vectors defining the phi
      // opening
      //
      G4double cosP = std::cos(startPhi), sinP = std::sin(startPhi);
      G4ThreeVector a( r[0]*cosP, r[0]*sinP, z[0] );
      G4ThreeVector b( r[1]*cosP, r[1]*sinP, z[1] );
      cosP = std::cos(startPhi+deltaPhi); sinP = std::sin(startPhi+deltaPhi);
      G4ThreeVector c( r[0]*cosP, r[0]*sinP, z[0] );
      G4ThreeVector d( r[1]*cosP, r[1]*sinP, z[1] );
      
      G4double ad = axis.dot(a),
               bd = axis.dot(b),
               cd = axis.dot(c),
               dd = axis.dot(d);
      
      if (bd > ad) { ad = bd; }
      if (cd > ad) { ad = cd; }
      if (dd > ad) { ad = dd; }
      
      return ad;
    }
  }
 
  //
  // Check either end
  //
  G4double aPerp = axis.perp();
  
  G4double a = aPerp*r[0] + axis.z()*z[0];
  G4double b = aPerp*r[1] + axis.z()*z[1];
  
  if (b > a) { a = b; }
  
  return a;
}

GetInstanceID()

G4int G4PolyconeSide::GetInstanceID ( ) const

inline

Returns the instance ID.

Definition at line 222 of file G4PolyconeSide.hh.

{ return instanceID; }

GetPointOnFace()

G4ThreeVector G4PolyconeSide::GetPointOnFace ( )

overridevirtual

Returns a random point located and uniformly distributed on the face.

Implements G4VCSGface.

Definition at line 1205 of file G4PolyconeSide.cc.

{
  G4double x,y,zz;
  G4double rr,phi,dz,dr;
  dr=r[1]-r[0];dz=z[1]-z[0];
  phi=startPhi+deltaPhi*G4QuickRand();
  rr=r[0]+dr*G4QuickRand();
 
  x=rr*std::cos(phi);
  y=rr*std::sin(phi);
 
  // PolyconeSide has a Ring Form
  //
  if (dz==0.)
  {
    zz=z[0];
  }
  else
  {
    if(dr==0.)  // PolyconeSide has a Tube Form
    {
      zz = z[0]+dz*G4QuickRand();
    }
    else
    {
      zz = z[0]+(rr-r[0])*dz/dr;
    }
  }
 
  return {x,y,zz};
}

GetSubInstanceManager()

const G4PlSideManager & G4PolyconeSide::GetSubInstanceManager ( )

static

Returns the private data instance manager.

Definition at line 57 of file G4PolyconeSide.cc.

{
  return subInstanceManager;
}

Referenced by G4SolidsWorkspace::G4SolidsWorkspace().

Inside()

EInside G4PolyconeSide::Inside ( const G4ThreeVector & p, G4double tolerance, G4double * bestDistance )

overridevirtual

Determines whether a point is inside, outside, or on the surface of the face.

Parameters

[in]	p	Position.
[in]	tolerance	Tolerance defining the bounds of the "kSurface", nominally equal to kCarTolerance/2.
[out]	bestDistance	Distance to the closest surface (in or out).

Returns

kInside if the point is closest to the inside surface; kOutside if the point is closest to the outside surface; kSurface if the point is withing tolerance of the surface.

Implements G4VCSGface.

Definition at line 438 of file G4PolyconeSide.cc.

{
  G4double distFrom, distOut2, dist2;
  G4double edgeRZnorm;
     
  distFrom =  DistanceAway( p, distOut2, &edgeRZnorm );
  dist2 = distFrom*distFrom + distOut2;
 
  *bestDistance = std::sqrt( dist2);
  
  // Okay then, inside or out?
  //
  if ( (std::fabs(edgeRZnorm) < tolerance)
    && (distOut2< tolerance*tolerance) )
  {
    return kSurface;
  }
  if (edgeRZnorm < 0)
  {
    return kInside;
  }
  
  return kOutside;
}

Intersect()

G4bool G4PolyconeSide::Intersect ( const G4ThreeVector & p, const G4ThreeVector & v, G4bool outgoing, G4double surfTolerance, G4double & distance, G4double & distFromSurface, G4ThreeVector & normal, G4bool & isAllBehind )

overridevirtual

Determines the distance along a line to the face.

Parameters

[in]	p	Position.
[in]	v	Direction (assumed to be a unit vector).
[in]	outgoing	Flag true, to consider only inside surfaces; false, to consider only outside surfaces.
[in]	surfTolerance	Minimum distance from the surface.
[out]	distance	Distance to intersection.
[out]	distFromSurface	Distance from surface (along surface normal), < 0 if the point is in front of the surface.
[out]	normal	Normal of surface at intersection point.
[out]	allBehind	Flag, true, if entire surface is behind normal.

Returns

true if there is an intersection, false otherwise.

Implements G4VCSGface.

Definition at line 264 of file G4PolyconeSide.cc.

{
  G4double s1=0., s2=0.;
  G4double normSign = outgoing ? +1 : -1;
  
  isAllBehind = allBehind;
 
  //
  // Check for two possible intersections
  //
  G4int nside = cone->LineHitsCone( p, v, &s1, &s2 );
  if (nside == 0) { return false; }
    
  //
  // Check the first side first, since it is (supposed to be) closest
  //
  G4ThreeVector hit = p + s1*v;
  
  if (PointOnCone( hit, normSign, p, v, normal ))
  {
    //
    // Good intersection! What about the normal? 
    //
    if (normSign*v.dot(normal) > 0)
    {
      //
      // We have a valid intersection, but it could very easily
      // be behind the point. To decide if we tolerate this,
      // we have to see if the point p is on the surface near
      // the intersecting point.
      //
      // What does it mean exactly for the point p to be "near"
      // the intersection? It means that if we draw a line from
      // p to the hit, the line remains entirely within the
      // tolerance bounds of the cone. To test this, we can
      // ask if the normal is correct near p.
      //
      G4double pr = p.perp();
      if (pr < DBL_MIN) { pr = DBL_MIN; }
      G4ThreeVector pNormal( rNorm*p.x()/pr, rNorm*p.y()/pr, zNorm );
      if (normSign*v.dot(pNormal) > 0)
      {
        //
        // p and intersection in same hemisphere
        //
        G4double distOutside2;
        distFromSurface = -normSign*DistanceAway( p, false, distOutside2 );
        if (distOutside2 < surfTolerance*surfTolerance)
        {
          if (distFromSurface > -surfTolerance)
          {
            //
            // We are just inside or away from the
            // surface. Accept *any* value of distance.
            //
            distance = s1;
            return true;
          }
        }
      }
      else
      { 
        distFromSurface = s1;
      }
      
      //
      // Accept positive distances
      //
      if (s1 > 0)
      {
        distance = s1;
        return true;
      }
    }
  }  
  
  if (nside==1) { return false;
}
  
  //
  // Well, try the second hit
  //  
  hit = p + s2*v;
  
  if (PointOnCone( hit, normSign, p, v, normal ))
  {
    //
    // Good intersection! What about the normal? 
    //
    if (normSign*v.dot(normal) > 0)
    {
      G4double pr = p.perp();
      if (pr < DBL_MIN) { pr = DBL_MIN; }
      G4ThreeVector pNormal( rNorm*p.x()/pr, rNorm*p.y()/pr, zNorm );
      if (normSign*v.dot(pNormal) > 0)
      {
        G4double distOutside2;
        distFromSurface = -normSign*DistanceAway( p, false, distOutside2 );
        if (distOutside2 < surfTolerance*surfTolerance)
        {
          if (distFromSurface > -surfTolerance)
          {
            distance = s2;
            return true;
          }
        }
      }
      else
      { 
        distFromSurface = s2;
      }
      
      if (s2 > 0)
      {
        distance = s2;
        return true;
      }
    }
  }  
 
  //
  // Better luck next time
  //
  return false;
}

Normal()

G4ThreeVector G4PolyconeSide::Normal ( const G4ThreeVector & p, G4double * bestDistance )

overridevirtual

Returns the normal of surface closest to the point.

Parameters

[in]	p	Position.
[out]	bestDistance	Distance to the closest surface (in or out).

Returns

The normal of the surface nearest the point.

Implements G4VCSGface.

Definition at line 467 of file G4PolyconeSide.cc.

{
  if (p == G4ThreeVector(0.,0.,0.)) { return p; }
 
  G4double dFrom, dOut2;
  
  dFrom = DistanceAway( p, false, dOut2 );
  
  *bestDistance = std::sqrt( dFrom*dFrom + dOut2 );
  
  G4double rds = p.perp();
  if (rds!=0.) { return {rNorm*p.x()/rds,rNorm*p.y()/rds,zNorm}; }
  return G4ThreeVector( 0.,0., zNorm ).unit();
}

operator=()

G4PolyconeSide & G4PolyconeSide::operator=

(

const G4PolyconeSide &

source

)

Definition at line 204 of file G4PolyconeSide.cc.

{
  if (this == &source) { return *this; }
 
  delete cone;
  if (phiIsOpen) { delete [] corners; }
  
  CopyStuff( source );
  
  return *this;
}

SurfaceArea()

G4double G4PolyconeSide::SurfaceArea ( )

overridevirtual

Returning an estimation of the face surface area, in internal units.

Implements G4VCSGface.

Definition at line 1193 of file G4PolyconeSide.cc.

{ 
  if(fSurfaceArea==0.)
  {
    fSurfaceArea = (r[0]+r[1])* std::sqrt(sqr(r[0]-r[1])+sqr(z[0]-z[1]));
    fSurfaceArea *= 0.5*(deltaPhi);
  }  
  return fSurfaceArea;
}

---

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

• G4PolyconeSide.hh
• G4PolyconeSide.cc