G4PolyPhiFace Class Reference

G4PolyPhiFace is a face that bounds a polycone or polyhedra when it has a phi opening. Specifically, it is a face that lies on a plane that passes through the Z axis, having boundaries that are straight lines of arbitrary length and direction, but with corners aways on the same side of the Z axis. More...

#include <G4PolyPhiFace.hh>

Inheritance diagram for G4PolyPhiFace:

Public Member Functions
	G4PolyPhiFace (const G4ReduciblePolygon *rz, G4double phi, G4double deltaPhi, G4double phiOther)
	~G4PolyPhiFace () override
	G4PolyPhiFace (const G4PolyPhiFace &source)
G4PolyPhiFace &	operator= (const G4PolyPhiFace &source)
G4bool	Intersect (const G4ThreeVector &p, const G4ThreeVector &v, G4bool outgoing, G4double surfTolerance, G4double &distance, G4double &distFromSurface, G4ThreeVector &normal, G4bool &allBehind) 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
	G4PolyPhiFace (__void__ &)
void	Diagnose (G4VSolid *solid)
Public Member Functions inherited from G4VCSGface
	G4VCSGface ()=default
virtual	~G4VCSGface ()=default

Detailed Description

G4PolyPhiFace is a face that bounds a polycone or polyhedra when it has a phi opening. Specifically, it is a face that lies on a plane that passes through the Z axis, having boundaries that are straight lines of arbitrary length and direction, but with corners aways on the same side of the Z axis.

Definition at line 83 of file G4PolyPhiFace.hh.

Constructor & Destructor Documentation

G4PolyPhiFace() [1/3]

G4PolyPhiFace::G4PolyPhiFace	(	const G4ReduciblePolygon *	rz,
		G4double	phi,
		G4double	deltaPhi,
		G4double	phiOther )

Constructor where points r,z should be supplied in clockwise order in r,z. For example: [1]------—[2] ^ R | | | | | +--> z [0]------—[3]

Parameters

[in]	rz	Pointer to previous r,Z section.
[in]	phi	Initial Phi starting angle.
[in]	deltaPhi	Total Phi angle.
[in]	phiOther	Phi angle of next section.

Definition at line 51 of file G4PolyPhiFace.cc.

{
  kCarTolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
 
  numEdges = rz->NumVertices();
 
  rMin = rz->Amin();
  rMax = rz->Amax();
  zMin = rz->Bmin();
  zMax = rz->Bmax();
 
  //
  // Is this the "starting" phi edge of the two?
  //
  G4bool start = (phiOther > phi);
  
  //
  // Build radial vector
  //
  radial = G4ThreeVector( std::cos(phi), std::sin(phi), 0.0 );
  
  //
  // Build normal
  //
  G4double zSign = start ? 1 : -1;
  normal = G4ThreeVector( zSign*radial.y(), -zSign*radial.x(), 0 );
  
  //
  // Is allBehind?
  //
  allBehind = (zSign*(std::cos(phiOther)*radial.y() - std::sin(phiOther)*radial.x()) < 0);
  
  //
  // Adjacent edges
  //
  G4double midPhi = phi + (start ? +0.5 : -0.5)*deltaPhi;
  G4double cosMid = std::cos(midPhi), 
                 sinMid = std::sin(midPhi);
  //
  // Allocate corners
  //
  const std::size_t maxEdges = numEdges>0 ? numEdges : 1;
  corners = new G4PolyPhiFaceVertex[maxEdges];
  //
  // Fill them
  //
  G4ReduciblePolygonIterator iterRZ(rz);
  
  G4PolyPhiFaceVertex* corn   = corners;
  G4PolyPhiFaceVertex* helper = corners;
 
  iterRZ.Begin();
  do    // Loop checking, 13.08.2015, G.Cosmo
  {
    corn->r = iterRZ.GetA();
    corn->z = iterRZ.GetB();
    corn->x = corn->r*radial.x();
    corn->y = corn->r*radial.y();
 
    // Add pointer on prev corner
    //
    if( corn == corners )
      { corn->prev = corners+maxEdges-1;}
    else
      { corn->prev = helper; }
 
    // Add pointer on next corner
    //
    if( corn < corners+maxEdges-1 )
      { corn->next = corn+1;}
    else
      { corn->next = corners; }
 
    helper = corn;
  } while( ++corn, iterRZ.Next() );
 
  //
  // Allocate edges
  //
  edges = new G4PolyPhiFaceEdge[maxEdges];
 
  //
  // Fill them
  //
  G4double rFact = std::cos(0.5*deltaPhi);
  G4double rFactNormalize = 1.0/std::sqrt(1.0+rFact*rFact);
 
  G4PolyPhiFaceVertex* prev = corners+maxEdges-1,
                     * here = corners;
  G4PolyPhiFaceEdge*   edge = edges;
  do    // Loop checking, 13.08.2015, G.Cosmo
  {
    G4ThreeVector sideNorm;
    
    edge->v0 = prev;
    edge->v1 = here;
 
    G4double dr = here->r - prev->r,
             dz = here->z - prev->z;
                         
    edge->length = std::sqrt( dr*dr + dz*dz );
 
    edge->tr = dr/edge->length;
    edge->tz = dz/edge->length;
    
    if ((here->r < DBL_MIN) && (prev->r < DBL_MIN))
    {
      //
      // Sigh! Always exceptions!
      // This edge runs at r==0, so its adjoing surface is not a
      // PolyconeSide or PolyhedraSide, but the opposite PolyPhiFace.
      //
      G4double zSignOther = start ? -1 : 1;
      sideNorm = G4ThreeVector(  zSignOther*std::sin(phiOther), 
                                -zSignOther*std::cos(phiOther), 0 );
    }
    else
    {
      sideNorm = G4ThreeVector( edge->tz*cosMid,
                                edge->tz*sinMid,
                               -edge->tr*rFact );
      sideNorm *= rFactNormalize;
    }
    sideNorm += normal;
    
    edge->norm3D = sideNorm.unit();
  } while( edge++, prev=here, ++here < corners+maxEdges );
 
  //
  // Go back and fill in corner "normals"
  //
  G4PolyPhiFaceEdge* prevEdge = edges+maxEdges-1;
  edge = edges;
  do    // Loop checking, 13.08.2015, G.Cosmo
  {
    //
    // Calculate vertex 2D normals (on the phi surface)
    //
    G4double rPart = prevEdge->tr + edge->tr;
    G4double zPart = prevEdge->tz + edge->tz;
    G4double norm = std::sqrt( rPart*rPart + zPart*zPart );
    G4double rNorm = +zPart/norm;
    G4double zNorm = -rPart/norm;
    
    edge->v0->rNorm = rNorm;
    edge->v0->zNorm = zNorm;
    
    //
    // Calculate the 3D normals.
    //
    // Find the vector perpendicular to the z axis
    // that defines the plane that contains the vertex normal
    //
    G4ThreeVector xyVector;
    
    if (edge->v0->r < DBL_MIN)
    {
      //
      // This is a vertex at r==0, which is a special
      // case. The normal we will construct lays in the
      // plane at the center of the phi opening.
      //
      // We also know that rNorm < 0
      //
      G4double zSignOther = start ? -1 : 1;
      G4ThreeVector normalOther(  zSignOther*std::sin(phiOther), 
                                 -zSignOther*std::cos(phiOther), 0 );
                
      xyVector = - normal - normalOther;
    }
    else
    {
      //
      // This is a vertex at r > 0. The plane
      // is the average of the normal and the
      // normal of the adjacent phi face
      //
      xyVector = G4ThreeVector( cosMid, sinMid, 0 );
      if (rNorm < 0)
      {
        xyVector -= normal;
      }
      else
      {
        xyVector += normal;
      }
    }
    
    //
    // Combine it with the r/z direction from the face
    //
    edge->v0->norm3D = rNorm*xyVector.unit() + G4ThreeVector( 0, 0, zNorm );
  } while(  prevEdge=edge, ++edge < edges+maxEdges );
  
  //
  // Build point on surface
  //
  G4double rAve = 0.5*(rMax-rMin),
           zAve = 0.5*(zMax-zMin);
  surface = G4ThreeVector( rAve*radial.x(), rAve*radial.y(), zAve );
}

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

~G4PolyPhiFace()

G4PolyPhiFace::~G4PolyPhiFace ( )

override

Destructor. Removes edges and corners.

Definition at line 291 of file G4PolyPhiFace.cc.

{
  delete [] edges;
  delete [] corners;
}

G4PolyPhiFace() [2/3]

G4PolyPhiFace::G4PolyPhiFace

(

const G4PolyPhiFace &

source

)

Copy constructor and assignment operator.

Definition at line 301 of file G4PolyPhiFace.cc.

{
  CopyStuff( source );
}

G4PolyPhiFace() [3/3]

G4PolyPhiFace::G4PolyPhiFace

(

__void__ &

)

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

Definition at line 282 of file G4PolyPhiFace.cc.

  :  rMin(0.), rMax(0.), zMin(0.), zMax(0.), kCarTolerance(0.)
{
}

Member Function Documentation

CalculateExtent()

void G4PolyPhiFace::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 607 of file G4PolyPhiFace.cc.

{
  //
  // Construct a (sometimes big) clippable polygon, 
  //
  // Perform the necessary transformations while doing so
  //
  G4ClippablePolygon polygon;
  
  G4PolyPhiFaceVertex* corner = corners;
  do    // Loop checking, 13.08.2015, G.Cosmo
  {
    G4ThreeVector point( 0, 0, corner->z );
    point += radial*corner->r;
    
    polygon.AddVertexInOrder( transform.TransformPoint( point ) );
  } while( ++corner < corners + numEdges );
  
  //
  // Clip away
  //
  if (polygon.PartialClip( voxelLimit, axis ))
  {
    //
    // Add it to the list
    //
    polygon.SetNormal( transform.TransformAxis(normal) );
    extentList.AddSurface( polygon );
  }
}

Clone()

G4VCSGface * G4PolyPhiFace::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.

Diagnose()

void G4PolyPhiFace::Diagnose

(

G4VSolid *

solid

)

Throws an exception if something is found inconsistent with the solid. For debugging purposes only.

Definition at line 263 of file G4PolyPhiFace.cc.

{
  G4PolyPhiFaceVertex* corner = corners;
  do    // Loop checking, 13.08.2015, G.Cosmo
  {
    G4ThreeVector test(corner->x, corner->y, corner->z);
    test -= 1E-6*corner->norm3D;
    
    if (owner->Inside(test) != kInside)
    { 
      G4Exception( "G4PolyPhiFace::Diagnose()", "GeomSolids0002",
                   FatalException, "Bad vertex normal found." );
    }
  } while( ++corner < corners+numEdges );
}

Distance()

G4double G4PolyPhiFace::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 432 of file G4PolyPhiFace.cc.

{
  G4double normSign = outgoing ? +1 : -1;
  //
  // Correct normal? 
  //
  G4ThreeVector ps = p - surface;
  G4double distPhi = -normSign*normal.dot(ps);
  
  if (distPhi < -0.5*kCarTolerance)
  { 
    return kInfinity;
  }
  if (distPhi < 0)
  {
    distPhi = 0.0;
  }
  
  //
  // Calculate projected point in r,z
  //
  G4double r = radial.dot(p);
  
  //
  // Are we inside the face?
  //
  G4double distRZ2;
  
  if (InsideEdges( r, p.z(), &distRZ2, nullptr ))
  {
    //
    // Yup, answer is just distPhi
    //
    return distPhi;
  }
  
  //
  // Nope. Penalize by distance out
  //
  return std::sqrt( distPhi*distPhi + distRZ2 );
}

Extent()

G4double G4PolyPhiFace::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 587 of file G4PolyPhiFace.cc.

{
  G4double max = -kInfinity;
  
  G4PolyPhiFaceVertex* corner = corners;
  do    // Loop checking, 13.08.2015, G.Cosmo
  {
    G4double here = axis.x()*corner->r*radial.x()
            + axis.y()*corner->r*radial.y()
            + axis.z()*corner->z;
    if (here > max) { max = here; }
  } while( ++corner < corners + numEdges );
  
  return max;
}  

Inside()

EInside G4PolyPhiFace::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 476 of file G4PolyPhiFace.cc.

{
  //
  // Get distance along phi, which if negative means the point
  // is nominally inside the shape.
  //
  G4ThreeVector ps = p - surface;
  G4double distPhi = normal.dot(ps);
  
  //
  // Calculate projected point in r,z
  //
  G4double r = radial.dot(p);
  
  //
  // Are we inside the face?
  //
  G4double distRZ2;
  G4PolyPhiFaceVertex* base3Dnorm = nullptr;
  G4ThreeVector*       head3Dnorm = nullptr;
  
  if (InsideEdges( r, p.z(), &distRZ2, &base3Dnorm, &head3Dnorm ))
  {
    //
    // Looks like we're inside. Distance is distance in phi.
    //
    *bestDistance = std::fabs(distPhi);
    
    //
    // Use distPhi to decide fate
    //
    if (distPhi < -tolerance) { return kInside; }
    if (distPhi <  tolerance) { return kSurface; }
    return kOutside;
  }
  
  //
  // We're outside the extent of the face,
  // so the distance is penalized by distance from edges in RZ
  //
  *bestDistance = std::sqrt( distPhi*distPhi + distRZ2 );
    
  //
  // Use edge normal to decide fate
  //
  G4ThreeVector cc( base3Dnorm->r*radial.x(),
                    base3Dnorm->r*radial.y(),
                    base3Dnorm->z );
  cc = p - cc;
  G4double normDist = head3Dnorm->dot(cc);
  if ( distRZ2 > tolerance*tolerance )
  {
    //
    // We're far enough away that kSurface is not possible
    //
    return normDist < 0 ? kInside : kOutside;
  }
    
  if (normDist < -tolerance) { return kInside; }
  if (normDist <  tolerance) { return kSurface; }
  return kOutside;
}  

Intersect()

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

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 377 of file G4PolyPhiFace.cc.

{
  G4double normSign = outgoing ? +1 : -1;
  
  //
  // These don't change
  //
  isAllBehind = allBehind;
  aNormal = normal;
 
  //
  // Correct normal? Here we have straight sides, and can safely ignore
  // intersections where the dot product with the normal is zero.
  //
  G4double dotProd = normSign*normal.dot(v);
  
  if (dotProd <= 0) { return false; }
 
  //
  // Calculate distance to surface. If the side is too far
  // behind the point, we must reject it.
  //
  G4ThreeVector ps = p - surface;
  distFromSurface = -normSign*ps.dot(normal);
    
  if (distFromSurface < -surfTolerance) { return false; }
 
  //
  // Calculate precise distance to intersection with the side
  // (along the trajectory, not normal to the surface)
  //
  distance = distFromSurface/dotProd;
 
  //
  // Calculate intersection point in r,z
  //
  G4ThreeVector ip = p + distance*v;
  
  G4double r = radial.dot(ip);
  
  //
  // And is it inside the r/z extent?
  //
  return InsideEdgesExact( r, ip.z(), normSign, p, v );
}

Normal()

G4ThreeVector G4PolyPhiFace::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 546 of file G4PolyPhiFace.cc.

{
  //
  // Get distance along phi, which if negative means the point
  // is nominally inside the shape.
  //
  G4double distPhi = normal.dot(p);
 
  //
  // Calculate projected point in r,z
  //
  G4double r = radial.dot(p);
  
  //
  // Are we inside the face?
  //
  G4double distRZ2;
  
  if (InsideEdges( r, p.z(), &distRZ2, nullptr ))
  {
    //
    // Yup, answer is just distPhi
    //
    *bestDistance = std::fabs(distPhi);
  }
  else
  {
    //
    // Nope. Penalize by distance out
    //
    *bestDistance = std::sqrt( distPhi*distPhi + distRZ2 );
  }
  
  return normal;
}

operator=()

G4PolyPhiFace & G4PolyPhiFace::operator=

(

const G4PolyPhiFace &

source

)

Definition at line 310 of file G4PolyPhiFace.cc.

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

SurfaceArea()

G4double G4PolyPhiFace::SurfaceArea ( )

overridevirtual

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

Implements G4VCSGface.

Definition at line 906 of file G4PolyPhiFace.cc.

{
  if ( fSurfaceArea==0. ) { Triangulate(); }
  return fSurfaceArea;
}

---

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

• G4PolyPhiFace.hh
• G4PolyPhiFace.cc