#include <G4CutTubs.hh>

Inheritance diagram for G4CutTubs:

Collaboration diagram for G4CutTubs:

Public Member Functions
	G4CutTubs (const G4String &pName, G4double pRMin, G4double pRMax, G4double pDz, G4double pSPhi, G4double pDPhi, G4ThreeVector pLowNorm, G4ThreeVector pHighNorm)

	~G4CutTubs ()

G4ThreeVector	GetLowNorm () const

G4ThreeVector	GetHighNorm () const

G4double	GetCubicVolume ()

G4double	GetSurfaceArea ()

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

EInside	Inside (const G4ThreeVector &p) const

G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const

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

G4double	DistanceToIn (const G4ThreeVector &p) const

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

G4double	DistanceToOut (const G4ThreeVector &p) const

G4GeometryType	GetEntityType () const

G4ThreeVector	GetPointOnSurface () const

G4VSolid *	Clone () const

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

void	DescribeYourselfTo (G4VGraphicsScene &scene) const

G4Polyhedron *	CreatePolyhedron () const

	G4CutTubs (__void__ &)

	G4CutTubs (const G4CutTubs &rhs)

G4CutTubs &	operator= (const G4CutTubs &rhs)

Public Member Functions inherited from G4OTubs
	G4OTubs (const G4String &pName, G4double pRMin, G4double pRMax, G4double pDz, G4double pSPhi, G4double pDPhi)

virtual	~G4OTubs ()

G4double	GetInnerRadius () const

G4double	GetOuterRadius () const

G4double	GetZHalfLength () const

G4double	GetStartPhiAngle () const

G4double	GetDeltaPhiAngle () const

void	SetInnerRadius (G4double newRMin)

void	SetOuterRadius (G4double newRMax)

void	SetZHalfLength (G4double newDz)

void	SetStartPhiAngle (G4double newSPhi, G4bool trig=true)

void	SetDeltaPhiAngle (G4double newDPhi)

G4double	GetCubicVolume ()

G4double	GetSurfaceArea ()

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

EInside	Inside (const G4ThreeVector &p) const

G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const

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

G4double	DistanceToIn (const G4ThreeVector &p) const

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

G4double	DistanceToOut (const G4ThreeVector &p) const

G4GeometryType	GetEntityType () const

G4ThreeVector	GetPointOnSurface () const

G4VSolid *	Clone () const

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

void	DescribeYourselfTo (G4VGraphicsScene &scene) const

G4Polyhedron *	CreatePolyhedron () const

	G4OTubs (__void__ &)

	G4OTubs (const G4OTubs &rhs)

G4OTubs &	operator= (const G4OTubs &rhs)

G4double	GetRMin () const

G4double	GetRMax () const

G4double	GetDz () const

G4double	GetSPhi () const

G4double	GetDPhi () const

Public Member Functions inherited from G4CSGSolid
	G4CSGSolid (const G4String &pName)

virtual	~G4CSGSolid ()

virtual G4Polyhedron *	GetPolyhedron () const

	G4CSGSolid (__void__ &)

	G4CSGSolid (const G4CSGSolid &rhs)

G4CSGSolid &	operator= (const G4CSGSolid &rhs)

Public Member Functions inherited from G4VSolid
	G4VSolid (const G4String &name)

virtual	~G4VSolid ()

G4bool	operator== (const G4VSolid &s) const

G4String	GetName () const

void	SetName (const G4String &name)

G4double	GetTolerance () const

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

void	DumpInfo () const

virtual G4VisExtent	GetExtent () const

virtual const G4VSolid *	GetConstituentSolid (G4int no) const

virtual G4VSolid *	GetConstituentSolid (G4int no)

virtual const G4DisplacedSolid *	GetDisplacedSolidPtr () const

virtual G4DisplacedSolid *	GetDisplacedSolidPtr ()

	G4VSolid (__void__ &)

	G4VSolid (const G4VSolid &rhs)

G4VSolid &	operator= (const G4VSolid &rhs)

G4double	EstimateCubicVolume (G4int nStat, G4double epsilon) const

G4double	EstimateSurfaceArea (G4int nStat, G4double ell) const

Protected Member Functions
G4ThreeVectorList *	CreateRotatedVertices (const G4AffineTransform &pTransform) const

G4ThreeVector	ApproxSurfaceNormal (const G4ThreeVector &p) const

G4bool	IsCrossingCutPlanes () const

G4double	GetCutZ (const G4ThreeVector &p) const

void	GetMaxMinZ (G4double &zmin, G4double &zmax) const

Protected Member Functions inherited from G4OTubs
G4ThreeVectorList *	CreateRotatedVertices (const G4AffineTransform &pTransform) const

void	Initialize ()

void	CheckSPhiAngle (G4double sPhi)

void	CheckDPhiAngle (G4double dPhi)

void	CheckPhiAngles (G4double sPhi, G4double dPhi)

void	InitializeTrigonometry ()

Protected Member Functions inherited from G4CSGSolid
G4double	GetRadiusInRing (G4double rmin, G4double rmax) const

Protected Member Functions inherited from G4VSolid
void	CalculateClippedPolygonExtent (G4ThreeVectorList &pPolygon, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const

void	ClipCrossSection (G4ThreeVectorList *pVertices, const G4int pSectionIndex, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const

void	ClipBetweenSections (G4ThreeVectorList *pVertices, const G4int pSectionIndex, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const

void	ClipPolygon (G4ThreeVectorList &pPolygon, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis) const

Private Attributes
G4ThreeVector	fLowNorm

G4ThreeVector	fHighNorm

G4bool	fPhiFullCutTube

G4double	halfCarTolerance

G4double	halfRadTolerance

G4double	halfAngTolerance

Additional Inherited Members
Protected Types inherited from G4OTubs
enum	ESide { kNull, kRMin, kRMax, kSPhi, kEPhi, kPZ, kMZ }

enum	ENorm { kNRMin, kNRMax, kNSPhi, kNEPhi, kNZ }

Protected Attributes inherited from G4OTubs
G4double	kRadTolerance

G4double	kAngTolerance

G4double	fRMin

G4double	fRMax

G4double	fDz

G4double	fSPhi

G4double	fDPhi

G4double	sinCPhi

G4double	cosCPhi

G4double	cosHDPhiOT

G4double	cosHDPhiIT

G4double	sinSPhi

G4double	cosSPhi

G4double	sinEPhi

G4double	cosEPhi

G4bool	fPhiFullTube

G4double	halfCarTolerance

G4double	halfRadTolerance

G4double	halfAngTolerance

Protected Attributes inherited from G4CSGSolid
G4double	fCubicVolume

G4double	fSurfaceArea

G4bool	fRebuildPolyhedron

G4Polyhedron *	fpPolyhedron

Protected Attributes inherited from G4VSolid
G4double	kCarTolerance

Detailed Description

Definition at line 51 of file G4CutTubs.hh.

Constructor & Destructor Documentation

◆ G4CutTubs() [1/3]

G4CutTubs::G4CutTubs	(	const G4String &	pName,
		G4double	pRMin,
		G4double	pRMax,
		G4double	pDz,
		G4double	pSPhi,
		G4double	pDPhi,
		G4ThreeVector	pLowNorm,
		G4ThreeVector	pHighNorm
	)

Definition at line 61 of file G4CutTubs.cc.

   : G4OTubs(pName, pRMin, pRMax, pDz, pSPhi, pDPhi),
     fPhiFullCutTube(true)
 {
   kRadTolerance = G4GeometryTolerance::GetInstance()->GetRadialTolerance();
   kAngTolerance = G4GeometryTolerance::GetInstance()->GetAngularTolerance();
 
   halfCarTolerance = kCarTolerance*0.5;
   halfRadTolerance = kRadTolerance*0.5;
   halfAngTolerance = kAngTolerance*0.5;
 
   // Check on Cutted Planes Normals
   // If there is NO CUT, propose to use G4Tubs instead
   //
   if(pDPhi<twopi)  { fPhiFullCutTube=false; }
  
   if ( ( !pLowNorm.x()) && ( !pLowNorm.y())
     && ( !pHighNorm.x()) && (!pHighNorm.y()) )
   {
     std::ostringstream message;
     message << "Inexisting Low/High Normal to Z plane or Parallel to Z."
             << G4endl
             << "Normals to Z plane are (" << pLowNorm <<" and "
             << pHighNorm << ") in solid: " << GetName();
     G4Exception("G4CutTubs::G4CutTubs()", "GeomSolids1001",
                 JustWarning, message, "Should use G4Tubs!");
   }
 
   // If Normal is (0,0,0),means parallel to R, give it value of (0,0,+/-1)
   // 
   if (pLowNorm.mag2() == 0.)  { pLowNorm.setZ(-1.); }
   if (pHighNorm.mag2()== 0.)  { pHighNorm.setZ(1.); }
 
   // Given Normals to Cut Planes have to be an unit vectors. 
   // Normalize if it is needed.
   //
   if (pLowNorm.mag2() != 1.)  { pLowNorm  = pLowNorm.unit();  }
   if (pHighNorm.mag2()!= 1.)  { pHighNorm = pHighNorm.unit(); }
 
   // Normals to cutted planes have to point outside Solid
   //
   if( (pLowNorm.mag2() != 0.) && (pHighNorm.mag2()!= 0. ) )
   {
     if( ( pLowNorm.z()>= 0. ) || ( pHighNorm.z() <= 0.))
     {
       std::ostringstream message;
       message << "Invalid Low or High Normal to Z plane; "
                  "has to point outside Solid." << G4endl
               << "Invalid Norm to Z plane (" << pLowNorm << " or  "
               << pHighNorm << ") in solid: " << GetName();
       G4Exception("G4CutTubs::G4CutTubs()", "GeomSolids0002",
                   FatalException, message);
     }
   }
   fLowNorm  = pLowNorm;
   fHighNorm = pHighNorm;
 
   // Check Intersection of cut planes. They MUST NOT Intersect
   //
   // This check has been disabled as too strict.
   // See problem report #1887
   //
   // if(IsCrossingCutPlanes())
   // {
   //   std::ostringstream message;
   //   message << "Invalid Low or High Normal to Z plane; "
   //           << "Crossing Cutted Planes." << G4endl
   //           << "Invalid Norm to Z plane (" << pLowNorm << " and "
   //           << pHighNorm << ") in solid: " << GetName();
   //   G4Exception("G4CutTubs::G4CutTubs()", "GeomSolids0002",
   //               FatalException, message);
   // }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ~G4CutTubs()

G4CutTubs::~G4CutTubs ( )

Definition at line 155 of file G4CutTubs.cc.

156 {

157 }

◆ G4CutTubs() [2/3]

G4CutTubs::G4CutTubs ( __void__ & a )

Definition at line 144 of file G4CutTubs.cc.

   : G4OTubs(a), fLowNorm(G4ThreeVector()),
     fHighNorm(G4ThreeVector()), fPhiFullCutTube(false),
     halfCarTolerance(0.), halfRadTolerance(0.), halfAngTolerance(0.)
 {
 }

◆ G4CutTubs() [3/3]

G4CutTubs::G4CutTubs ( const G4CutTubs & rhs )

Definition at line 163 of file G4CutTubs.cc.

   : G4OTubs(rhs), fLowNorm(rhs.fLowNorm), fHighNorm(rhs.fHighNorm),
     fPhiFullCutTube(rhs.fPhiFullCutTube),
     halfCarTolerance(rhs.halfCarTolerance),
     halfRadTolerance(rhs.halfRadTolerance),
     halfAngTolerance(rhs.halfAngTolerance)
 {
 }

Member Function Documentation

◆ ApproxSurfaceNormal()

G4ThreeVector G4CutTubs::ApproxSurfaceNormal ( const G4ThreeVector & p ) const

protectedvirtual

Reimplemented from G4OTubs.

Definition at line 624 of file G4CutTubs.cc.

 {
   ENorm side ;
   G4ThreeVector norm ;
   G4double rho, phi ;
   G4double distZLow,distZHigh,distZ;
   G4double distRMin, distRMax, distSPhi, distEPhi, distMin ;
   G4ThreeVector vZ=G4ThreeVector(0,0,fDz);
 
   rho = std::sqrt(p.x()*p.x() + p.y()*p.y()) ;
 
   distRMin = std::fabs(rho - fRMin) ;
   distRMax = std::fabs(rho - fRMax) ;
 
   //dist to Low Cut
   //
   distZLow =std::fabs((p+vZ).dot(fLowNorm));
 
   //dist to High Cut
   //
   distZHigh = std::fabs((p-vZ).dot(fHighNorm));
   distZ=std::min(distZLow,distZHigh);
 
   if (distRMin < distRMax) // First minimum
   {
     if ( distZ < distRMin )
     {
        distMin = distZ ;
        side    = kNZ ;
     }
     else
     {
       distMin = distRMin ;
       side    = kNRMin   ;
     }
   }
   else
   {
     if ( distZ < distRMax )
     {
       distMin = distZ ;
       side    = kNZ   ;
     }
     else
     {
       distMin = distRMax ;
       side    = kNRMax   ;
     }
   }   
   if (!fPhiFullCutTube  &&  rho ) // Protected against (0,0,z) 
   {
     phi = std::atan2(p.y(),p.x()) ;
 
     if ( phi < 0 )  { phi += twopi; }
 
     if ( fSPhi < 0 )
     {
       distSPhi = std::fabs(phi - (fSPhi + twopi))*rho ;
     }
     else
     {
       distSPhi = std::fabs(phi - fSPhi)*rho ;
     }
     distEPhi = std::fabs(phi - fSPhi - fDPhi)*rho ;
                                       
     if (distSPhi < distEPhi) // Find new minimum
     {
       if ( distSPhi < distMin )
       {
         side = kNSPhi ;
       }
     }
     else
     {
       if ( distEPhi < distMin )
       {
         side = kNEPhi ;
       }
     }
   }    
   switch ( side )
   {
     case kNRMin : // Inner radius
     {                      
       norm = G4ThreeVector(-p.x()/rho, -p.y()/rho, 0) ;
       break ;
     }
     case kNRMax : // Outer radius
     {                  
       norm = G4ThreeVector(p.x()/rho, p.y()/rho, 0) ;
       break ;
     }
     case kNZ :    // + or - dz
     {                              
       if ( distZHigh > distZLow )  { norm = fHighNorm ; }
       else                         { norm = fLowNorm; }
       break ;
     }
     case kNSPhi:
     {
       norm = G4ThreeVector(std::sin(fSPhi), -std::cos(fSPhi), 0) ;
       break ;
     }
     case kNEPhi:
     {
       norm = G4ThreeVector(-std::sin(fSPhi+fDPhi), std::cos(fSPhi+fDPhi), 0) ;
       break;
     }
     default:      // Should never reach this case ...
     {
       DumpInfo();
       G4Exception("G4CutTubs::ApproxSurfaceNormal()",
                   "GeomSolids1002", JustWarning,
                   "Undefined side for valid surface normal to solid.");
       break ;
     }    
   }                
   return norm;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CalculateExtent()

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

virtual

Implements G4VSolid.

Definition at line 201 of file G4CutTubs.cc.

 {
   if ( (!pTransform.IsRotated()) && (fDPhi == twopi) && (fRMin == 0) )
   {
     // Special case handling for unrotated solid tubes
     // Compute x/y/z mins and maxs fro bounding box respecting limits,
     // with early returns if outside limits. Then switch() on pAxis,
     // and compute exact x and y limit for x/y case
       
     G4double xoffset, xMin, xMax;
     G4double yoffset, yMin, yMax;
     G4double zoffset, zMin, zMax;
 
     G4double diff1, diff2, maxDiff, newMin, newMax;
     G4double xoff1, xoff2, yoff1, yoff2, delta;
 
     xoffset = pTransform.NetTranslation().x();
     xMin = xoffset - fRMax;
     xMax = xoffset + fRMax;
 
     if (pVoxelLimit.IsXLimited())
     {
       if ( (xMin > pVoxelLimit.GetMaxXExtent())
         || (xMax < pVoxelLimit.GetMinXExtent()) )
       {
         return false;
       }
       else
       {
         if (xMin < pVoxelLimit.GetMinXExtent())
         {
           xMin = pVoxelLimit.GetMinXExtent();
         }
         if (xMax > pVoxelLimit.GetMaxXExtent())
         {
           xMax = pVoxelLimit.GetMaxXExtent();
         }
       }
     }
     yoffset = pTransform.NetTranslation().y();
     yMin    = yoffset - fRMax;
     yMax    = yoffset + fRMax;
 
     if ( pVoxelLimit.IsYLimited() )
     {
       if ( (yMin > pVoxelLimit.GetMaxYExtent())
         || (yMax < pVoxelLimit.GetMinYExtent()) )
       {
         return false;
       }
       else
       {
         if (yMin < pVoxelLimit.GetMinYExtent())
         {
           yMin = pVoxelLimit.GetMinYExtent();
         }
         if (yMax > pVoxelLimit.GetMaxYExtent())
         {
           yMax=pVoxelLimit.GetMaxYExtent();
         }
       }
     }
     zoffset = pTransform.NetTranslation().z();
     GetMaxMinZ(zMin,zMax);
     zMin    += zoffset;
     zMax    += zoffset;
 
     if ( pVoxelLimit.IsZLimited() )
     {
       if ( (zMin > pVoxelLimit.GetMaxZExtent())
         || (zMax < pVoxelLimit.GetMinZExtent()) )
       {
         return false;
       }
       else
       {
         if (zMin < pVoxelLimit.GetMinZExtent())
         {
           zMin = pVoxelLimit.GetMinZExtent();
         }
         if (zMax > pVoxelLimit.GetMaxZExtent())
         {
           zMax = pVoxelLimit.GetMaxZExtent();
         }
       }
     }
     switch ( pAxis )  // Known to cut cylinder
     {
       case kXAxis :
       {
         yoff1 = yoffset - yMin;
         yoff2 = yMax    - yoffset;
 
         if ( (yoff1 >= 0) && (yoff2 >= 0) ) // Y limits cross max/min x
         {                                   // => no change
           pMin = xMin;
           pMax = xMax;
         }
         else
         {
           // Y limits don't cross max/min x => compute max delta x,
           // hence new mins/maxs
 
           delta   = fRMax*fRMax - yoff1*yoff1;
           diff1   = (delta>0.) ? std::sqrt(delta) : 0.;
           delta   = fRMax*fRMax - yoff2*yoff2;
           diff2   = (delta>0.) ? std::sqrt(delta) : 0.;
           maxDiff = (diff1 > diff2) ? diff1:diff2;
           newMin  = xoffset - maxDiff;
           newMax  = xoffset + maxDiff;
           pMin    = (newMin < xMin) ? xMin : newMin;
           pMax    = (newMax > xMax) ? xMax : newMax;
         }    
         break;
       }
       case kYAxis :
       {
         xoff1 = xoffset - xMin;
         xoff2 = xMax - xoffset;
 
         if ( (xoff1 >= 0) && (xoff2 >= 0) ) // X limits cross max/min y
         {                                   // => no change
           pMin = yMin;
           pMax = yMax;
         }
         else
         {
           // X limits don't cross max/min y => compute max delta y,
           // hence new mins/maxs
 
           delta   = fRMax*fRMax - xoff1*xoff1;
           diff1   = (delta>0.) ? std::sqrt(delta) : 0.;
           delta   = fRMax*fRMax - xoff2*xoff2;
           diff2   = (delta>0.) ? std::sqrt(delta) : 0.;
           maxDiff = (diff1 > diff2) ? diff1 : diff2;
           newMin  = yoffset - maxDiff;
           newMax  = yoffset + maxDiff;
           pMin    = (newMin < yMin) ? yMin : newMin;
           pMax    = (newMax > yMax) ? yMax : newMax;
         }
         break;
       }
       case kZAxis:
       {
         pMin = zMin;
         pMax = zMax;
         break;
       }
       default:
         break;
     }
     pMin -= kCarTolerance;
     pMax += kCarTolerance;
     return true;
   }
   else // Calculate rotated vertex coordinates
   {
     G4int i, noEntries, noBetweenSections4;
     G4bool existsAfterClip = false;
     G4ThreeVectorList* vertices = CreateRotatedVertices(pTransform);
 
     pMin =  kInfinity;
     pMax = -kInfinity;
 
     noEntries = vertices->size();
     noBetweenSections4 = noEntries - 4;
     
     for ( i = 0 ; i < noEntries ; i += 4 )
     {
       ClipCrossSection(vertices, i, pVoxelLimit, pAxis, pMin, pMax);
     }
     for ( i = 0 ; i < noBetweenSections4 ; i += 4 )
     {
       ClipBetweenSections(vertices, i, pVoxelLimit, pAxis, pMin, pMax);
     }
     if ( (pMin != kInfinity) || (pMax != -kInfinity) )
     {
       existsAfterClip = true;
       pMin -= kCarTolerance; // Add 2*tolerance to avoid precision troubles
       pMax += kCarTolerance;
     }
     else
     {
       // Check for case where completely enveloping clipping volume
       // If point inside then we are confident that the solid completely
       // envelopes the clipping volume. Hence set min/max extents according
       // to clipping volume extents along the specified axis.
 
       G4ThreeVector clipCentre(
              (pVoxelLimit.GetMinXExtent()+pVoxelLimit.GetMaxXExtent())*0.5,
              (pVoxelLimit.GetMinYExtent()+pVoxelLimit.GetMaxYExtent())*0.5,
              (pVoxelLimit.GetMinZExtent()+pVoxelLimit.GetMaxZExtent())*0.5 );
         
       if ( Inside(pTransform.Inverse().TransformPoint(clipCentre)) != kOutside )
       {
         existsAfterClip = true;
         pMin            = pVoxelLimit.GetMinExtent(pAxis);
         pMax            = pVoxelLimit.GetMaxExtent(pAxis);
       }
     }
     delete vertices;
     return existsAfterClip;
   }
 }

Here is the call graph for this function:

◆ Clone()

G4VSolid * G4CutTubs::Clone ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1858 of file G4CutTubs.cc.

 {
   return new G4CutTubs(*this);
 }

Here is the call graph for this function:

◆ CreatePolyhedron()

G4Polyhedron * G4CutTubs::CreatePolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1971 of file G4CutTubs.cc.

 {
   typedef G4double G4double3[3];
   typedef G4int G4int4[4];
 
   G4Polyhedron *ph  = new G4Polyhedron;
   G4Polyhedron *ph1 = G4OTubs::CreatePolyhedron();
   G4int nn=ph1->GetNoVertices();
   G4int nf=ph1->GetNoFacets();
   G4double3* xyz = new G4double3[nn];  // number of nodes 
   G4int4*  faces = new G4int4[nf] ;    // number of faces
 
   for(G4int i=0;i<nn;i++)
   {
     xyz[i][0]=ph1->GetVertex(i+1).x();
     xyz[i][1]=ph1->GetVertex(i+1).y();
     G4double tmpZ=ph1->GetVertex(i+1).z();
     if(tmpZ>=fDz-kCarTolerance)
     {
       xyz[i][2]=GetCutZ(G4ThreeVector(xyz[i][0],xyz[i][1],fDz));
     }
     else if(tmpZ<=-fDz+kCarTolerance)
     {
       xyz[i][2]=GetCutZ(G4ThreeVector(xyz[i][0],xyz[i][1],-fDz));
     }
     else
     {
       xyz[i][2]=tmpZ;
     }
   }
   G4int iNodes[4];
   G4int *iEdge=0;
   G4int n;
   for(G4int i=0;i<nf;i++)
   {
     ph1->GetFacet(i+1,n,iNodes,iEdge);
     for(G4int k=0;k<n;k++)
     {
       faces[i][k]=iNodes[k];
     }
     for(G4int k=n;k<4;k++)
     {
       faces[i][k]=0;
     }
   }
   ph->createPolyhedron(nn,nf,xyz,faces);
 
   delete [] xyz;
   delete [] faces;
   delete ph1;
 
   return ph;
 }

Here is the call graph for this function:

◆ CreateRotatedVertices()

G4ThreeVectorList * G4CutTubs::CreateRotatedVertices ( const G4AffineTransform & pTransform ) const

protected

Definition at line 1763 of file G4CutTubs.cc.

 {
   G4ThreeVectorList* vertices ;
   G4ThreeVector vertex0, vertex1, vertex2, vertex3 ;
   G4double meshAngle, meshRMax, crossAngle,
            cosCrossAngle, sinCrossAngle, sAngle;
   G4double rMaxX, rMaxY, rMinX, rMinY, meshRMin ;
   G4int crossSection, noCrossSections;
 
   // Compute no of cross-sections necessary to mesh tube
   //
   noCrossSections = G4int(fDPhi/kMeshAngleDefault) + 1 ;
 
   if ( noCrossSections < kMinMeshSections )
   {
     noCrossSections = kMinMeshSections ;
   }
   else if (noCrossSections>kMaxMeshSections)
   {
     noCrossSections = kMaxMeshSections ;
   }
   // noCrossSections = 4 ;
 
   meshAngle = fDPhi/(noCrossSections - 1) ;
   // meshAngle = fDPhi/(noCrossSections) ;
 
   meshRMax  = (fRMax+100*kCarTolerance)/std::cos(meshAngle*0.5) ;
   meshRMin = fRMin - 100*kCarTolerance ; 
  
   // If complete in phi, set start angle such that mesh will be at fRMax
   // on the x axis. Will give better extent calculations when not rotated.
 
   if (fPhiFullCutTube && (fSPhi == 0) )  { sAngle = -meshAngle*0.5 ; }
   else                                { sAngle =  fSPhi ; }
     
   vertices = new G4ThreeVectorList();
     
   if ( vertices )
   {
     vertices->reserve(noCrossSections*4);
     for (crossSection = 0 ; crossSection < noCrossSections ; crossSection++ )
     {
       // Compute coordinates of cross section at section crossSection
 
       crossAngle    = sAngle + crossSection*meshAngle ;
       cosCrossAngle = std::cos(crossAngle) ;
       sinCrossAngle = std::sin(crossAngle) ;
 
       rMaxX = meshRMax*cosCrossAngle ;
       rMaxY = meshRMax*sinCrossAngle ;
 
       if(meshRMin <= 0.0)
       {
         rMinX = 0.0 ;
         rMinY = 0.0 ;
       }
       else
       {
         rMinX = meshRMin*cosCrossAngle ;
         rMinY = meshRMin*sinCrossAngle ;
       }
       vertex0 = G4ThreeVector(rMinX,rMinY,GetCutZ(G4ThreeVector(rMinX,rMinY,-fDz))) ;
       vertex1 = G4ThreeVector(rMaxX,rMaxY,GetCutZ(G4ThreeVector(rMaxX,rMaxY,-fDz))) ;
       vertex2 = G4ThreeVector(rMaxX,rMaxY,GetCutZ(G4ThreeVector(rMaxX,rMaxY,+fDz))) ;
       vertex3 = G4ThreeVector(rMinX,rMinY,GetCutZ(G4ThreeVector(rMinX,rMinY,+fDz))) ;
 
       vertices->push_back(pTransform.TransformPoint(vertex0)) ;
       vertices->push_back(pTransform.TransformPoint(vertex1)) ;
       vertices->push_back(pTransform.TransformPoint(vertex2)) ;
       vertices->push_back(pTransform.TransformPoint(vertex3)) ;
     }
   }
   else
   {
     DumpInfo();
     G4Exception("G4CutTubs::CreateRotatedVertices()",
                 "GeomSolids0003", FatalException,
                 "Error in allocation of vertices. Out of memory !");
   }
   return vertices ;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DescribeYourselfTo()

void G4CutTubs::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

virtual

Implements G4VSolid.

Definition at line 1966 of file G4CutTubs.cc.

 {
   scene.AddSolid (*this) ;
 }

Here is the call graph for this function:

◆ DistanceToIn() [1/2]

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

virtual

Implements G4VSolid.

Definition at line 766 of file G4CutTubs.cc.

 {
   G4double snxt = kInfinity ;      // snxt = default return value
   G4double tolORMin2, tolIRMax2 ;  // 'generous' radii squared
   G4double tolORMax2, tolIRMin2;
   const G4double dRmax = 100.*fRMax;
   G4ThreeVector vZ=G4ThreeVector(0,0,fDz);
   
   // Intersection point variables
   //
   G4double Dist, sd=0, xi, yi, zi, rho2, inum, iden, cosPsi, Comp,calf ;
   G4double t1, t2, t3, b, c, d ;     // Quadratic solver variables 
   G4double distZLow,distZHigh;
   // Calculate tolerant rmin and rmax
 
   if (fRMin > kRadTolerance)
   {
     tolORMin2 = (fRMin - halfRadTolerance)*(fRMin - halfRadTolerance) ;
     tolIRMin2 = (fRMin + halfRadTolerance)*(fRMin + halfRadTolerance) ;
   }
   else
   {
     tolORMin2 = 0.0 ;
     tolIRMin2 = 0.0 ;
   }
   tolORMax2 = (fRMax + halfRadTolerance)*(fRMax + halfRadTolerance) ;
   tolIRMax2 = (fRMax - halfRadTolerance)*(fRMax - halfRadTolerance) ;
 
   // Intersection with ZCut surfaces
 
   // dist to Low Cut
   //
   distZLow =(p+vZ).dot(fLowNorm);
 
   // dist to High Cut
   //
   distZHigh = (p-vZ).dot(fHighNorm);
 
   if ( distZLow >= -halfCarTolerance )
   {
     calf = v.dot(fLowNorm);
     if (calf<0)
     {
       sd = -distZLow/calf;
       if(sd < 0.0)  { sd = 0.0; }
 
       xi   = p.x() + sd*v.x() ;                // Intersection coords
       yi   = p.y() + sd*v.y() ;
       rho2 = xi*xi + yi*yi ;
 
       // Check validity of intersection
 
       if ((tolIRMin2 <= rho2) && (rho2 <= tolIRMax2))
       {
         if (!fPhiFullCutTube && rho2)
         {
           // Psi = angle made with central (average) phi of shape
           //
           inum   = xi*cosCPhi + yi*sinCPhi ;
           iden   = std::sqrt(rho2) ;
           cosPsi = inum/iden ;
           if (cosPsi >= cosHDPhiIT)  { return sd ; }
         }
         else
         {
           return sd ;
         }
       }
     }
     else
     {
       if ( sd<halfCarTolerance )
       {
         if(calf>=0) { sd=kInfinity; }
         return sd ;  // On/outside extent, and heading away
       }              // -> cannot intersect
     }
   }
 
   if(distZHigh >= -halfCarTolerance )
   {
     calf = v.dot(fHighNorm);
     if (calf<0)
     {
       sd = -distZHigh/calf;
 
       if(sd < 0.0)  { sd = 0.0; }
 
       xi   = p.x() + sd*v.x() ;                // Intersection coords
       yi   = p.y() + sd*v.y() ;
       rho2 = xi*xi + yi*yi ;
 
       // Check validity of intersection
 
       if ((tolIRMin2 <= rho2) && (rho2 <= tolIRMax2))
       {
         if (!fPhiFullCutTube && rho2)
         {
           // Psi = angle made with central (average) phi of shape
           //
           inum   = xi*cosCPhi + yi*sinCPhi ;
           iden   = std::sqrt(rho2) ;
           cosPsi = inum/iden ;
           if (cosPsi >= cosHDPhiIT)  { return sd ; }
         }
         else
         {
           return sd ;
         }
       }
     }
     else
     {
       if ( sd<halfCarTolerance )
       { 
         if(calf>=0) { sd=kInfinity; }
         return sd ;  // On/outside extent, and heading away
       }              // -> cannot intersect
     }
   }
 
   // -> Can not intersect z surfaces
   //
   // Intersection with rmax (possible return) and rmin (must also check phi)
   //
   // Intersection point (xi,yi,zi) on line x=p.x+t*v.x etc.
   //
   // Intersects with x^2+y^2=R^2
   //
   // Hence (v.x^2+v.y^2)t^2+ 2t(p.x*v.x+p.y*v.y)+p.x^2+p.y^2-R^2=0
   //            t1                t2                t3
 
   t1 = 1.0 - v.z()*v.z() ;
   t2 = p.x()*v.x() + p.y()*v.y() ;
   t3 = p.x()*p.x() + p.y()*p.y() ;
   if ( t1 > 0 )        // Check not || to z axis
   {
     b = t2/t1 ;
     c = t3 - fRMax*fRMax ;
     
     if ((t3 >= tolORMax2) && (t2<0))   // This also handles the tangent case
     {
       // Try outer cylinder intersection, c=(t3-fRMax*fRMax)/t1;
 
       c /= t1 ;
       d = b*b - c ;
 
       if (d >= 0)  // If real root
       {
         sd = c/(-b+std::sqrt(d));
         if (sd >= 0)  // If 'forwards'
         {
           if ( sd>dRmax ) // Avoid rounding errors due to precision issues on
           {               // 64 bits systems. Split long distances and recompute
             G4double fTerm = sd-std::fmod(sd,dRmax);
             sd = fTerm + DistanceToIn(p+fTerm*v,v);
           } 
           // Check z intersection
           //
           zi = p.z() + sd*v.z() ;
           xi = p.x() + sd*v.x() ;
           yi = p.y() + sd*v.y() ;
           if ((-xi*fLowNorm.x()-yi*fLowNorm.y()
                -(zi+fDz)*fLowNorm.z())>-halfCarTolerance)
           {
             if ((-xi*fHighNorm.x()-yi*fHighNorm.y()
                  +(fDz-zi)*fHighNorm.z())>-halfCarTolerance)
             {
               // Z ok. Check phi intersection if reqd
               //
               if (fPhiFullCutTube)
               {
                 return sd ;
               }
               else
               {
                 xi     = p.x() + sd*v.x() ;
                 yi     = p.y() + sd*v.y() ;
                 cosPsi = (xi*cosCPhi + yi*sinCPhi)/fRMax ;
                 if (cosPsi >= cosHDPhiIT)  { return sd ; }
               }
             }  //  end if std::fabs(zi)
           }
         }    //  end if (sd>=0)
       }      //  end if (d>=0)
     }        //  end if (r>=fRMax)
     else 
     {
       // Inside outer radius :
       // check not inside, and heading through tubs (-> 0 to in)
       if ((t3 > tolIRMin2) && (t2 < 0)
        && (std::fabs(p.z()) <= std::fabs(GetCutZ(p))-halfCarTolerance ))
       {
         // Inside both radii, delta r -ve, inside z extent
 
         if (!fPhiFullCutTube)
         {
           inum   = p.x()*cosCPhi + p.y()*sinCPhi ;
           iden   = std::sqrt(t3) ;
           cosPsi = inum/iden ;
           if (cosPsi >= cosHDPhiIT)
           {
             // In the old version, the small negative tangent for the point
             // on surface was not taken in account, and returning 0.0 ...
             // New version: check the tangent for the point on surface and 
             // if no intersection, return kInfinity, if intersection instead
             // return sd.
             //
             c = t3-fRMax*fRMax; 
             if ( c<=0.0 )
             {
               return 0.0;
             }
             else
             {
               c = c/t1 ;
               d = b*b-c;
               if ( d>=0.0 )
               {
                 snxt = c/(-b+std::sqrt(d)); // using safe solution
                                             // for quadratic equation 
                 if ( snxt < halfCarTolerance ) { snxt=0; }
                 return snxt ;
               }      
               else
               {
                 return kInfinity;
               }
             }
           } 
         }
         else
         {   
           // In the old version, the small negative tangent for the point
           // on surface was not taken in account, and returning 0.0 ...
           // New version: check the tangent for the point on surface and 
           // if no intersection, return kInfinity, if intersection instead
           // return sd.
           //
           c = t3 - fRMax*fRMax; 
           if ( c<=0.0 )
           {
             return 0.0;
           }
           else
           {
             c = c/t1 ;
             d = b*b-c;
             if ( d>=0.0 )
             {
               snxt= c/(-b+std::sqrt(d)); // using safe solution
                                          // for quadratic equation 
               if ( snxt < halfCarTolerance ) { snxt=0; }
               return snxt ;
             }      
             else
             {
               return kInfinity;
             }
           }
         } // end if   (!fPhiFullCutTube)
       }   // end if   (t3>tolIRMin2)
     }     // end if   (Inside Outer Radius) 
       
     if ( fRMin )    // Try inner cylinder intersection
     {
       c = (t3 - fRMin*fRMin)/t1 ;
       d = b*b - c ;
       if ( d >= 0.0 )  // If real root
       {
         // Always want 2nd root - we are outside and know rmax Hit was bad
         // - If on surface of rmin also need farthest root
         
         sd =( b > 0. )? c/(-b - std::sqrt(d)) : (-b + std::sqrt(d));
         if (sd >= -10*halfCarTolerance)  // check forwards
         {
           // Check z intersection
           //
           if (sd < 0.0)  { sd = 0.0; }
           if (sd>dRmax) // Avoid rounding errors due to precision issues seen
           {             // 64 bits systems. Split long distances and recompute
             G4double fTerm = sd-std::fmod(sd,dRmax);
             sd = fTerm + DistanceToIn(p+fTerm*v,v);
           } 
           zi = p.z() + sd*v.z() ;
           xi = p.x() + sd*v.x() ;
           yi = p.y() + sd*v.y() ;
           if ((-xi*fLowNorm.x()-yi*fLowNorm.y()
                -(zi+fDz)*fLowNorm.z())>-halfCarTolerance)
           {
             if ((-xi*fHighNorm.x()-yi*fHighNorm.y()
                  +(fDz-zi)*fHighNorm.z())>-halfCarTolerance)
             {
               // Z ok. Check phi
               //
               if ( fPhiFullCutTube )
               {
                 return sd ; 
               }
               else
               {
                 cosPsi = (xi*cosCPhi + yi*sinCPhi)/fRMin ;
                 if (cosPsi >= cosHDPhiIT)
                 {
                   // Good inner radius isect
                   // - but earlier phi isect still possible
                   //
                   snxt = sd ;
                 }
               }
             }      //    end if std::fabs(zi)
           }
         }          //    end if (sd>=0)
       }            //    end if (d>=0)
     }              //    end if (fRMin)
   }
 
   // Phi segment intersection
   //
   // o Tolerant of points inside phi planes by up to kCarTolerance*0.5
   //
   // o NOTE: Large duplication of code between sphi & ephi checks
   //         -> only diffs: sphi -> ephi, Comp -> -Comp and half-plane
   //            intersection check <=0 -> >=0
   //         -> use some form of loop Construct ?
   //
   if ( !fPhiFullCutTube )
   {
     // First phi surface (Starting phi)
     //
     Comp = v.x()*sinSPhi - v.y()*cosSPhi ;
                 
     if ( Comp < 0 )  // Component in outwards normal dirn
     {
       Dist = (p.y()*cosSPhi - p.x()*sinSPhi) ;
 
       if ( Dist < halfCarTolerance )
       {
         sd = Dist/Comp ;
 
         if (sd < snxt)
         {
           if ( sd < 0 )  { sd = 0.0; }
           zi = p.z() + sd*v.z() ;
           xi = p.x() + sd*v.x() ;
           yi = p.y() + sd*v.y() ;
           if ((-xi*fLowNorm.x()-yi*fLowNorm.y()
                -(zi+fDz)*fLowNorm.z())>-halfCarTolerance)
           {
             if ((-xi*fHighNorm.x()-yi*fHighNorm.y()
                  +(fDz-zi)*fHighNorm.z())>-halfCarTolerance) 
             {
               rho2 = xi*xi + yi*yi ;
               if ( ( (rho2 >= tolIRMin2) && (rho2 <= tolIRMax2) )
                 || ( (rho2 >  tolORMin2) && (rho2 <  tolIRMin2)
                   && ( v.y()*cosSPhi - v.x()*sinSPhi >  0 )
                   && ( v.x()*cosSPhi + v.y()*sinSPhi >= 0 )     )
                 || ( (rho2 > tolIRMax2) && (rho2 < tolORMax2)
                   && (v.y()*cosSPhi - v.x()*sinSPhi > 0)
                   && (v.x()*cosSPhi + v.y()*sinSPhi < 0) )    )
               {
                 // z and r intersections good
                 // - check intersecting with correct half-plane
                 //
                 if ((yi*cosCPhi-xi*sinCPhi) <= halfCarTolerance) { snxt = sd; }
               }
             }   //two Z conditions
           }
         }
       }    
     }
       
     // Second phi surface (Ending phi)
     //
     Comp = -(v.x()*sinEPhi - v.y()*cosEPhi) ;
         
     if (Comp < 0 )  // Component in outwards normal dirn
     {
       Dist = -(p.y()*cosEPhi - p.x()*sinEPhi) ;
 
       if ( Dist < halfCarTolerance )
       {
         sd = Dist/Comp ;
 
         if (sd < snxt)
         {
           if ( sd < 0 )  { sd = 0; }
           zi = p.z() + sd*v.z() ;
           xi = p.x() + sd*v.x() ;
           yi = p.y() + sd*v.y() ;
           if ((-xi*fLowNorm.x()-yi*fLowNorm.y()
                -(zi+fDz)*fLowNorm.z())>-halfCarTolerance)
           {
             if ((-xi*fHighNorm.x()-yi*fHighNorm.y()
                  +(fDz-zi)*fHighNorm.z())>-halfCarTolerance)
             {
               xi   = p.x() + sd*v.x() ;
               yi   = p.y() + sd*v.y() ;
               rho2 = xi*xi + yi*yi ;
               if ( ( (rho2 >= tolIRMin2) && (rho2 <= tolIRMax2) )
                   || ( (rho2 > tolORMin2)  && (rho2 < tolIRMin2)
                     && (v.x()*sinEPhi - v.y()*cosEPhi >  0)
                     && (v.x()*cosEPhi + v.y()*sinEPhi >= 0) )
                   || ( (rho2 > tolIRMax2) && (rho2 < tolORMax2)
                     && (v.x()*sinEPhi - v.y()*cosEPhi > 0)
                     && (v.x()*cosEPhi + v.y()*sinEPhi < 0) ) )
               {
                 // z and r intersections good
                 // - check intersecting with correct half-plane
                 //
                 if ( (yi*cosCPhi-xi*sinCPhi) >= -halfCarTolerance )
                 {
                   snxt = sd;
                 }
               }    //?? >=-halfCarTolerance
             }
           }  // two Z conditions
         }
       }
     }         //  Comp < 0
   }           //  !fPhiFullTube 
   if ( snxt<halfCarTolerance )  { snxt=0; }
 
   return snxt ;
 }

Here is the call graph for this function:

◆ DistanceToIn() [2/2]

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

virtual

Implements G4VSolid.

Definition at line 1219 of file G4CutTubs.cc.

 {
   G4double safRMin,safRMax,safZLow,safZHigh,safePhi,safe,rho,cosPsi;
   G4ThreeVector vZ=G4ThreeVector(0,0,fDz);
 
   // Distance to R
   //
   rho = std::sqrt(p.x()*p.x() + p.y()*p.y()) ;
 
   safRMin = fRMin- rho ;
   safRMax = rho - fRMax ;
 
   // Distances to ZCut(Low/High)
 
   // Dist to Low Cut
   //
   safZLow = (p+vZ).dot(fLowNorm);
 
   // Dist to High Cut
   //
   safZHigh = (p-vZ).dot(fHighNorm);
 
   safe = std::max(safZLow,safZHigh);
 
   if ( safRMin > safe ) { safe = safRMin; }
   if ( safRMax> safe )  { safe = safRMax; }
 
   // Distance to Phi
   //
   if ( (!fPhiFullCutTube) && (rho) )
    {
      // Psi=angle from central phi to point
      //
      cosPsi = (p.x()*cosCPhi + p.y()*sinCPhi)/rho ;
      
      if ( cosPsi < std::cos(fDPhi*0.5) )
      {
        // Point lies outside phi range
  
        if ( (p.y()*cosCPhi - p.x()*sinCPhi) <= 0 )
        {
          safePhi = std::fabs(p.x()*sinSPhi - p.y()*cosSPhi) ;
        }
        else
        {
          safePhi = std::fabs(p.x()*sinEPhi - p.y()*cosEPhi) ;
        }
        if ( safePhi > safe )  { safe = safePhi; }
      }
    }
    if ( safe < 0 )  { safe = 0; }
 
    return safe ;
 }

Here is the call graph for this function:

◆ DistanceToOut() [1/2]

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

virtual

Implements G4VSolid.

Definition at line 1279 of file G4CutTubs.cc.

 {  
   ESide side=kNull , sider=kNull, sidephi=kNull ;
   G4double snxt=kInfinity, srd=kInfinity,sz=kInfinity, sphi=kInfinity ;
   G4double deltaR, t1, t2, t3, b, c, d2, roMin2 ;
   G4double distZLow,distZHigh,calfH,calfL;
   G4ThreeVector vZ=G4ThreeVector(0,0,fDz);
  
   // Vars for phi intersection:
   //
   G4double pDistS, compS, pDistE, compE, sphi2, xi, yi, vphi, roi2 ;
  
   // Z plane intersection
   // Distances to ZCut(Low/High)
 
   // dist to Low Cut
   //
   distZLow =(p+vZ).dot(fLowNorm);
 
   // dist to High Cut
   //
   distZHigh = (p-vZ).dot(fHighNorm);
 
   calfH = v.dot(fHighNorm);
   calfL = v.dot(fLowNorm);
 
   if (calfH > 0 )
   {
     if ( distZHigh < halfCarTolerance )
     {
       snxt = -distZHigh/calfH ;
       side = kPZ ;
     }
     else
     {
       if (calcNorm)
       {
         *n         = G4ThreeVector(0,0,1) ;
         *validNorm = true ;
       }
       return snxt = 0 ;
     }
  }
   if ( calfL>0)
   {
    
     if ( distZLow < halfCarTolerance )
     {
       sz = -distZLow/calfL ;
       if(sz<snxt){
       snxt=sz;
       side = kMZ ;
       }
       
     }
     else
     {
       if (calcNorm)
       {
         *n         = G4ThreeVector(0,0,-1) ;
         *validNorm = true ;
       }
       return snxt = 0.0 ;
     }
   }
   if((calfH<=0)&&(calfL<=0))
   {
     snxt = kInfinity ;    // Travel perpendicular to z axis
     side = kNull;
   }
   // Radial Intersections
   //
   // Find intersection with cylinders at rmax/rmin
   // Intersection point (xi,yi,zi) on line x=p.x+t*v.x etc.
   //
   // Intersects with x^2+y^2=R^2
   //
   // Hence (v.x^2+v.y^2)t^2+ 2t(p.x*v.x+p.y*v.y)+p.x^2+p.y^2-R^2=0
   //
   //            t1                t2                    t3
 
   t1   = 1.0 - v.z()*v.z() ;      // since v normalised
   t2   = p.x()*v.x() + p.y()*v.y() ;
   t3   = p.x()*p.x() + p.y()*p.y() ;
 
   if ( snxt > 10*(fDz+fRMax) )  { roi2 = 2*fRMax*fRMax; }
   else  { roi2 = snxt*snxt*t1 + 2*snxt*t2 + t3; }        // radius^2 on +-fDz
 
   if ( t1 > 0 ) // Check not parallel
   {
     // Calculate srd, r exit distance
      
     if ( (t2 >= 0.0) && (roi2 > fRMax*(fRMax + kRadTolerance)) )
     {
       // Delta r not negative => leaving via rmax
 
       deltaR = t3 - fRMax*fRMax ;
 
       // NOTE: Should use rho-fRMax<-kRadTolerance*0.5
       // - avoid sqrt for efficiency
 
       if ( deltaR < -kRadTolerance*fRMax )
       {
         b     = t2/t1 ;
         c     = deltaR/t1 ;
         d2    = b*b-c;
         if( d2 >= 0 ) { srd = c/( -b - std::sqrt(d2)); }
         else          { srd = 0.; }
         sider = kRMax ;
       }
       else
       {
         // On tolerant boundary & heading outwards (or perpendicular to)
         // outer radial surface -> leaving immediately
 
         if ( calcNorm ) 
         {
           *n         = G4ThreeVector(p.x()/fRMax,p.y()/fRMax,0) ;
           *validNorm = true ;
         }
         return snxt = 0 ; // Leaving by rmax immediately
       }
     }             
     else if ( t2 < 0. ) // i.e.  t2 < 0; Possible rmin intersection
     {
       roMin2 = t3 - t2*t2/t1 ; // min ro2 of the plane of movement 
 
       if ( fRMin && (roMin2 < fRMin*(fRMin - kRadTolerance)) )
       {
         deltaR = t3 - fRMin*fRMin ;
         b      = t2/t1 ;
         c      = deltaR/t1 ;
         d2     = b*b - c ;
 
         if ( d2 >= 0 )   // Leaving via rmin
         {
           // NOTE: SHould use rho-rmin>kRadTolerance*0.5
           // - avoid sqrt for efficiency
 
           if (deltaR > kRadTolerance*fRMin)
           {
             srd = c/(-b+std::sqrt(d2)); 
             sider = kRMin ;
           }
           else
           {
             if ( calcNorm ) { *validNorm = false; }  // Concave side
             return snxt = 0.0;
           }
         }
         else    // No rmin intersect -> must be rmax intersect
         {
           deltaR = t3 - fRMax*fRMax ;
           c     = deltaR/t1 ;
           d2    = b*b-c;
           if( d2 >=0. )
           {
             srd    = -b + std::sqrt(d2) ;
             sider  = kRMax ;
           }
           else // Case: On the border+t2<kRadTolerance
                //       (v is perpendicular to the surface)
           {
             if (calcNorm)
             {
               *n = G4ThreeVector(p.x()/fRMax,p.y()/fRMax,0) ;
               *validNorm = true ;
             }
             return snxt = 0.0;
           }
         }
       }
       else if ( roi2 > fRMax*(fRMax + kRadTolerance) )
            // No rmin intersect -> must be rmax intersect
       {
         deltaR = t3 - fRMax*fRMax ;
         b      = t2/t1 ;
         c      = deltaR/t1;
         d2     = b*b-c;
         if( d2 >= 0 )
         {
           srd    = -b + std::sqrt(d2) ;
           sider  = kRMax ;
         }
         else // Case: On the border+t2<kRadTolerance
              //       (v is perpendicular to the surface)
         {
           if (calcNorm)
           {
             *n = G4ThreeVector(p.x()/fRMax,p.y()/fRMax,0) ;
             *validNorm = true ;
           }
           return snxt = 0.0;
         }
       }
     }
     // Phi Intersection
 
     if ( !fPhiFullCutTube )
     {
       // add angle calculation with correction 
       // of the difference in domain of atan2 and Sphi
       //
       vphi = std::atan2(v.y(),v.x()) ;
      
       if ( vphi < fSPhi - halfAngTolerance  )             { vphi += twopi; }
       else if ( vphi > fSPhi + fDPhi + halfAngTolerance ) { vphi -= twopi; }
 
 
       if ( p.x() || p.y() )  // Check if on z axis (rho not needed later)
       {
         // pDist -ve when inside
 
         pDistS = p.x()*sinSPhi - p.y()*cosSPhi ;
         pDistE = -p.x()*sinEPhi + p.y()*cosEPhi ;
 
         // Comp -ve when in direction of outwards normal
 
         compS   = -sinSPhi*v.x() + cosSPhi*v.y() ;
         compE   =  sinEPhi*v.x() - cosEPhi*v.y() ;
        
         sidephi = kNull;
         
         if( ( (fDPhi <= pi) && ( (pDistS <= halfCarTolerance)
                               && (pDistE <= halfCarTolerance) ) )
          || ( (fDPhi >  pi) && !((pDistS >  halfCarTolerance)
                               && (pDistE >  halfCarTolerance) ) )  )
         {
           // Inside both phi *full* planes
           
           if ( compS < 0 )
           {
             sphi = pDistS/compS ;
             
             if (sphi >= -halfCarTolerance)
             {
               xi = p.x() + sphi*v.x() ;
               yi = p.y() + sphi*v.y() ;
               
               // Check intersecting with correct half-plane
               // (if not -> no intersect)
               //
               if( (std::fabs(xi)<=kCarTolerance)
                && (std::fabs(yi)<=kCarTolerance) )
               {
                 sidephi = kSPhi;
                 if (((fSPhi-halfAngTolerance)<=vphi)
                    &&((fSPhi+fDPhi+halfAngTolerance)>=vphi))
                 {
                   sphi = kInfinity;
                 }
               }
               else if ( yi*cosCPhi-xi*sinCPhi >=0 )
               {
                 sphi = kInfinity ;
               }
               else
               {
                 sidephi = kSPhi ;
                 if ( pDistS > -halfCarTolerance )
                 {
                   sphi = 0.0 ; // Leave by sphi immediately
                 }    
               }       
             }
             else
             {
               sphi = kInfinity ;
             }
           }
           else
           {
             sphi = kInfinity ;
           }
 
           if ( compE < 0 )
           {
             sphi2 = pDistE/compE ;
             
             // Only check further if < starting phi intersection
             //
             if ( (sphi2 > -halfCarTolerance) && (sphi2 < sphi) )
             {
               xi = p.x() + sphi2*v.x() ;
               yi = p.y() + sphi2*v.y() ;
               
               if ((std::fabs(xi)<=kCarTolerance)&&(std::fabs(yi)<=kCarTolerance))
               {
                 // Leaving via ending phi
                 //
                 if( !((fSPhi-halfAngTolerance <= vphi)
                      &&(fSPhi+fDPhi+halfAngTolerance >= vphi)) )
                 {
                   sidephi = kEPhi ;
                   if ( pDistE <= -halfCarTolerance )  { sphi = sphi2 ; }
                   else                                { sphi = 0.0 ;   }
                 }
               } 
               else    // Check intersecting with correct half-plane 
 
               if ( (yi*cosCPhi-xi*sinCPhi) >= 0)
               {
                 // Leaving via ending phi
                 //
                 sidephi = kEPhi ;
                 if ( pDistE <= -halfCarTolerance ) { sphi = sphi2 ; }
                 else                               { sphi = 0.0 ;   }
               }
             }
           }
         }
         else
         {
           sphi = kInfinity ;
         }
       }
       else
       {
         // On z axis + travel not || to z axis -> if phi of vector direction
         // within phi of shape, Step limited by rmax, else Step =0
                
         if ( (fSPhi - halfAngTolerance <= vphi)
            && (vphi <= fSPhi + fDPhi + halfAngTolerance ) )
         {
           sphi = kInfinity ;
         }
         else
         {
           sidephi = kSPhi ; // arbitrary 
           sphi    = 0.0 ;
         }
       }
       if (sphi < snxt)  // Order intersecttions
       {
         snxt = sphi ;
         side = sidephi ;
       }
     }
     if (srd < snxt)  // Order intersections
     {
       snxt = srd ;
       side = sider ;
     }
   }
   if (calcNorm)
   {
     switch(side)
     {
       case kRMax:
         // Note: returned vector not normalised
         // (divide by fRMax for unit vector)
         //
         xi = p.x() + snxt*v.x() ;
         yi = p.y() + snxt*v.y() ;
         *n = G4ThreeVector(xi/fRMax,yi/fRMax,0) ;
         *validNorm = true ;
         break ;
 
       case kRMin:
         *validNorm = false ;  // Rmin is inconvex
         break ;
 
       case kSPhi:
         if ( fDPhi <= pi )
         {
           *n         = G4ThreeVector(sinSPhi,-cosSPhi,0) ;
           *validNorm = true ;
         }
         else
         {
           *validNorm = false ;
         }
         break ;
 
       case kEPhi:
         if (fDPhi <= pi)
         {
           *n = G4ThreeVector(-sinEPhi,cosEPhi,0) ;
           *validNorm = true ;
         }
         else
         {
           *validNorm = false ;
         }
         break ;
 
       case kPZ:
         *n         = fHighNorm ;
         *validNorm = true ;
         break ;
 
       case kMZ:
         *n         = fLowNorm ;
         *validNorm = true ;
         break ;
 
       default:
         G4cout << G4endl ;
         DumpInfo();
         std::ostringstream message;
         G4int oldprc = message.precision(16);
         message << "Undefined side for valid surface normal to solid."
                 << G4endl
                 << "Position:"  << G4endl << G4endl
                 << "p.x() = "   << p.x()/mm << " mm" << G4endl
                 << "p.y() = "   << p.y()/mm << " mm" << G4endl
                 << "p.z() = "   << p.z()/mm << " mm" << G4endl << G4endl
                 << "Direction:" << G4endl << G4endl
                 << "v.x() = "   << v.x() << G4endl
                 << "v.y() = "   << v.y() << G4endl
                 << "v.z() = "   << v.z() << G4endl << G4endl
                 << "Proposed distance :" << G4endl << G4endl
                 << "snxt = "    << snxt/mm << " mm" << G4endl ;
         message.precision(oldprc) ;
         G4Exception("G4CutTubs::DistanceToOut(p,v,..)", "GeomSolids1002",
                     JustWarning, message);
         break ;
     }
   }
   if ( snxt<halfCarTolerance )  { snxt=0 ; }
   return snxt ;
 }

Here is the call graph for this function:

◆ DistanceToOut() [2/2]

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

virtual

Implements G4VSolid.

Definition at line 1710 of file G4CutTubs.cc.

 {
   G4double safRMin,safRMax,safZLow,safZHigh,safePhi,safe,rho;
   G4ThreeVector vZ=G4ThreeVector(0,0,fDz);
 
   rho = std::sqrt(p.x()*p.x() + p.y()*p.y()) ;  // Distance to R
 
   safRMin =  rho - fRMin ;
   safRMax =  fRMax - rho ;
 
   // Distances to ZCut(Low/High)
 
   // Dist to Low Cut
   //
   safZLow = std::fabs((p+vZ).dot(fLowNorm));
 
   // Dist to High Cut
   //
   safZHigh = std::fabs((p-vZ).dot(fHighNorm));
   safe = std::min(safZLow,safZHigh);
 
   if ( safRMin < safe ) { safe = safRMin; }
   if ( safRMax< safe )  { safe = safRMax; }
 
   // Check if phi divided, Calc distances closest phi plane
   //
   if ( !fPhiFullCutTube )
   {
     if ( p.y()*cosCPhi-p.x()*sinCPhi <= 0 )
     {
       safePhi = -(p.x()*sinSPhi - p.y()*cosSPhi) ;
     }
     else
     {
       safePhi = (p.x()*sinEPhi - p.y()*cosEPhi) ;
     }
     if (safePhi < safe)  { safe = safePhi ; }
   }
   if ( safe < 0 )  { safe = 0; }
 
   return safe ;
 }

Here is the call graph for this function:

◆ GetCubicVolume()

G4double G4CutTubs::GetCubicVolume ( )

inlinevirtual

Reimplemented from G4VSolid.

◆ GetCutZ()

G4double G4CutTubs::GetCutZ ( const G4ThreeVector & p ) const

protected

Definition at line 2054 of file G4CutTubs.cc.

 {
   G4double newz = p.z();  // p.z() should be either +fDz or -fDz
   if (p.z()<0)
   {
     if(fLowNorm.z()!=0.)
     {
        newz = -fDz-(p.x()*fLowNorm.x()+p.y()*fLowNorm.y())/fLowNorm.z();
     }
   }
   else
   {
     if(fHighNorm.z()!=0.)
     {
        newz = fDz-(p.x()*fHighNorm.x()+p.y()*fHighNorm.y())/fHighNorm.z();
     }
   }
   return newz;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetEntityType()

G4GeometryType G4CutTubs::GetEntityType ( ) const

virtual

Implements G4VSolid.

Definition at line 1849 of file G4CutTubs.cc.

 {
   return G4String("G4CutTubs");
 }

◆ GetHighNorm()

G4ThreeVector G4CutTubs::GetHighNorm ( ) const

inline

Here is the caller graph for this function:

◆ GetLowNorm()

G4ThreeVector G4CutTubs::GetLowNorm ( ) const

inline

Here is the caller graph for this function:

◆ GetMaxMinZ()

void G4CutTubs::GetMaxMinZ	(	G4double &	zmin,
		G4double &	zmax
	)		const

protected

Definition at line 2078 of file G4CutTubs.cc.

 {
   G4double phiLow = std::atan2(fLowNorm.y(),fLowNorm.x());
   G4double phiHigh= std::atan2(fHighNorm.y(),fHighNorm.x());
 
   G4double xc=0, yc=0,z1;
   G4double z[8];
   G4bool in_range_low = false;
   G4bool in_range_hi = false;
  
   G4int i;
   for (i=0; i<2; i++)
   {
     if (phiLow<0)  { phiLow+=twopi; }
     G4double ddp = phiLow-fSPhi;
     if (ddp<0)  { ddp += twopi; }
     if (ddp <= fDPhi)
     {
       xc = fRMin*std::cos(phiLow);
       yc = fRMin*std::sin(phiLow);
       z1 = GetCutZ(G4ThreeVector(xc, yc, -fDz));
       xc = fRMax*std::cos(phiLow);
       yc = fRMax*std::sin(phiLow);
       z1 = std::min(z1, GetCutZ(G4ThreeVector(xc, yc, -fDz)));
       if (in_range_low)  { zmin = std::min(zmin, z1); }
       else               { zmin = z1; }
       in_range_low = true;
     }
     phiLow += pi;
     if (phiLow>twopi)  { phiLow-=twopi; }
   }
   for (i=0; i<2; i++)
   {
     if (phiHigh<0)  { phiHigh+=twopi; }
     G4double ddp = phiHigh-fSPhi;
     if (ddp<0)  { ddp += twopi; }
     if (ddp <= fDPhi)
     {
       xc = fRMin*std::cos(phiHigh);
       yc = fRMin*std::sin(phiHigh);
       z1 = GetCutZ(G4ThreeVector(xc, yc, fDz));
       xc = fRMax*std::cos(phiHigh);
       yc = fRMax*std::sin(phiHigh);
       z1 = std::min(z1, GetCutZ(G4ThreeVector(xc, yc, fDz)));
       if (in_range_hi)  { zmax = std::min(zmax, z1); }
       else              { zmax = z1; }
       in_range_hi = true;
     }
     phiHigh += pi;
     if (phiHigh>twopi)  { phiHigh-=twopi; }
   }
 
   xc = fRMin*std::cos(fSPhi);
   yc = fRMin*std::sin(fSPhi);
   z[0] = GetCutZ(G4ThreeVector(xc, yc, -fDz));
   z[4] = GetCutZ(G4ThreeVector(xc, yc, fDz));
  
   xc = fRMin*std::cos(fSPhi+fDPhi);
   yc = fRMin*std::sin(fSPhi+fDPhi);
   z[1] = GetCutZ(G4ThreeVector(xc, yc, -fDz));
   z[5] = GetCutZ(G4ThreeVector(xc, yc, fDz));
  
   xc = fRMax*std::cos(fSPhi);
   yc = fRMax*std::sin(fSPhi);
   z[2] = GetCutZ(G4ThreeVector(xc, yc, -fDz));
   z[6] = GetCutZ(G4ThreeVector(xc, yc, fDz));
  
   xc = fRMax*std::cos(fSPhi+fDPhi);
   yc = fRMax*std::sin(fSPhi+fDPhi);
   z[3] = GetCutZ(G4ThreeVector(xc, yc, -fDz));
   z[7] = GetCutZ(G4ThreeVector(xc, yc, fDz));
  
   // Find min/max
 
   z1=z[0];
   for (i = 1; i < 4; i++)
   {
     if(z[i] < z[i-1])z1=z[i];
   }
     
   if (in_range_low)
   {
     zmin = std::min(zmin, z1);
   }
   else
   {
     zmin = z1;
   }
   z1=z[4];
   for (i = 1; i < 4; i++)
   {
     if(z[4+i] > z[4+i-1])  { z1=z[4+i]; }
   }
 
   if (in_range_hi)  { zmax = std::max(zmax, z1); }
   else              { zmax = z1; }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetPointOnSurface()

G4ThreeVector G4CutTubs::GetPointOnSurface ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1892 of file G4CutTubs.cc.

 {
   G4double xRand, yRand, zRand, phi, cosphi, sinphi, chose,
            aOne, aTwo, aThr, aFou;
   G4double rRand;
  
   aOne = 2.*fDz*fDPhi*fRMax;
   aTwo = 2.*fDz*fDPhi*fRMin;
   aThr = 0.5*fDPhi*(fRMax*fRMax-fRMin*fRMin);
   aFou = 2.*fDz*(fRMax-fRMin);
 
   phi    = G4RandFlat::shoot(fSPhi, fSPhi+fDPhi);
   cosphi = std::cos(phi);
   sinphi = std::sin(phi);
 
   rRand  = GetRadiusInRing(fRMin,fRMax);
   
   if( (fSPhi == 0) && (fDPhi == twopi) ) { aFou = 0; }
   
   chose  = G4RandFlat::shoot(0.,aOne+aTwo+2.*aThr+2.*aFou);
 
   if( (chose >=0) && (chose < aOne) )
   {
     xRand = fRMax*cosphi;
     yRand = fRMax*sinphi;
     zRand = G4RandFlat::shoot(GetCutZ(G4ThreeVector(xRand,yRand,-fDz)),
                               GetCutZ(G4ThreeVector(xRand,yRand,fDz)));
     return G4ThreeVector  (xRand, yRand, zRand);
   }
   else if( (chose >= aOne) && (chose < aOne + aTwo) )
   {
     xRand = fRMin*cosphi;
     yRand = fRMin*sinphi;
     zRand = G4RandFlat::shoot(GetCutZ(G4ThreeVector(xRand,yRand,-fDz)),
                               GetCutZ(G4ThreeVector(xRand,yRand,fDz)));
     return G4ThreeVector  (xRand, yRand, zRand);
   }
   else if( (chose >= aOne + aTwo) && (chose < aOne + aTwo + aThr) )
   {
     xRand = rRand*cosphi;
     yRand = rRand*sinphi;
     zRand = GetCutZ(G4ThreeVector(xRand,yRand,fDz));
     return G4ThreeVector  (xRand, yRand, zRand);
   }
   else if( (chose >= aOne + aTwo + aThr) && (chose < aOne + aTwo + 2.*aThr) )
   {
     xRand = rRand*cosphi;
     yRand = rRand*sinphi;
     zRand = GetCutZ(G4ThreeVector(xRand,yRand,-fDz));
     return G4ThreeVector  (xRand, yRand, zRand);
   }
   else if( (chose >= aOne + aTwo + 2.*aThr)
         && (chose < aOne + aTwo + 2.*aThr + aFou) )
   {
     xRand = rRand*std::cos(fSPhi);
     yRand = rRand*std::sin(fSPhi);
     zRand = G4RandFlat::shoot(GetCutZ(G4ThreeVector(xRand,yRand,-fDz)),
                               GetCutZ(G4ThreeVector(xRand,yRand,fDz)));
     return G4ThreeVector  (xRand, yRand, zRand);
   }
   else
   {
     xRand = rRand*std::cos(fSPhi+fDPhi);
     yRand = rRand*std::sin(fSPhi+fDPhi);
     zRand = G4RandFlat::shoot(GetCutZ(G4ThreeVector(xRand,yRand,-fDz)),
                               GetCutZ(G4ThreeVector(xRand,yRand,fDz)));
     return G4ThreeVector  (xRand, yRand, zRand);
   }
 }

Here is the call graph for this function:

◆ GetSurfaceArea()

G4double G4CutTubs::GetSurfaceArea ( )

inlinevirtual

Reimplemented from G4VSolid.

◆ Inside()

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

virtual

Implements G4VSolid.

Definition at line 414 of file G4CutTubs.cc.

 {
   G4double zinLow,zinHigh,r2,pPhi=0.;
   G4double tolRMin,tolRMax;
   G4ThreeVector vZ=G4ThreeVector(0,0,fDz);
   EInside in = kInside;
 
   // Check if point is contained in the cut plane in -/+ Z
 
   // Check the lower cut plane
   //
   zinLow =(p+vZ).dot(fLowNorm);
   if (zinLow>halfCarTolerance)  { return kOutside; }
 
   // Check the higher cut plane
   //
   zinHigh = (p-vZ).dot(fHighNorm);
   if (zinHigh>halfCarTolerance)  { return kOutside; }
 
   // Check radius
   //
   r2 = p.x()*p.x() + p.y()*p.y() ;
 
   // First check 'generous' boundaries R+tolerance
   //
   tolRMin = fRMin - halfRadTolerance ;
   tolRMax = fRMax + halfRadTolerance ;
   if ( tolRMin < 0 )  { tolRMin = 0; }
     
   if ( ((r2 < tolRMin*tolRMin) || (r2 > tolRMax*tolRMax))
      && (r2 >=halfRadTolerance*halfRadTolerance) )  { return kOutside; }
    
   // Check Phi
   //
   if(!fPhiFullCutTube)
   {
     // Try outer tolerant phi boundaries only
 
     if ( (tolRMin==0) && (std::fabs(p.x())<=halfCarTolerance)
                       && (std::fabs(p.y())<=halfCarTolerance) )
     {
       return kSurface;
     }
  
     pPhi = std::atan2(p.y(),p.x()) ;
 
     if ( pPhi < -halfAngTolerance)  { pPhi += twopi; } // 0<=pPhi<2pi
     if ( fSPhi >= 0 )
     {
       if ( (std::fabs(pPhi) < halfAngTolerance)
         && (std::fabs(fSPhi + fDPhi - twopi) < halfAngTolerance) )
       { 
         pPhi += twopi ; // 0 <= pPhi < 2pi
       }
       if ( (pPhi <= fSPhi - halfAngTolerance)
         || (pPhi >= fSPhi + fDPhi + halfAngTolerance) )
       {
         in = kOutside ;
       }
       else if ( (pPhi <= fSPhi + halfAngTolerance)
              || (pPhi >= fSPhi + fDPhi - halfAngTolerance) )
       {
         in=kSurface;
       }
     }
     else  // fSPhi < 0
     {
       if ( (pPhi <= fSPhi + twopi - halfAngTolerance)
         && (pPhi >= fSPhi + fDPhi + halfAngTolerance) )
       {
         in = kOutside;
       }
       else
       {
         in = kSurface ;
       }
     }
   }
 
   // Check on the Surface for Z
   //
   if ((zinLow>=-halfCarTolerance)
    || (zinHigh>=-halfCarTolerance))
   {
     in=kSurface;
   }
 
   // Check on the Surface for R
   //
   if (fRMin) { tolRMin = fRMin + halfRadTolerance ; }
   else       { tolRMin = 0 ; }
   tolRMax = fRMax - halfRadTolerance ;  
   if ( ((r2 <= tolRMin*tolRMin) || (r2 >= tolRMax*tolRMax))&&
         (r2 >=halfRadTolerance*halfRadTolerance) )
   {
     return kSurface;
   }
 
   return in;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsCrossingCutPlanes()

G4bool G4CutTubs::IsCrossingCutPlanes ( ) const

protected

Definition at line 2031 of file G4CutTubs.cc.

 {
   G4double zXLow1,zXLow2,zYLow1,zYLow2;
   G4double zXHigh1,zXHigh2,zYHigh1,zYHigh2;
 
   zXLow1  = GetCutZ(G4ThreeVector(-fRMax,     0,-fDz));
   zXLow2  = GetCutZ(G4ThreeVector( fRMax,     0,-fDz));
   zYLow1  = GetCutZ(G4ThreeVector(     0,-fRMax,-fDz));
   zYLow2  = GetCutZ(G4ThreeVector(     0, fRMax,-fDz));
   zXHigh1 = GetCutZ(G4ThreeVector(-fRMax,     0, fDz));
   zXHigh2 = GetCutZ(G4ThreeVector( fRMax,     0, fDz));
   zYHigh1 = GetCutZ(G4ThreeVector(     0,-fRMax, fDz));
   zYHigh2 = GetCutZ(G4ThreeVector(     0, fRMax, fDz));
   if ( (zXLow1>zXHigh1) ||(zXLow2>zXHigh2)
     || (zYLow1>zYHigh1) ||(zYLow2>zYHigh2))  { return true; }
 
   return false;
 }

Here is the call graph for this function:

◆ operator=()

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

Definition at line 176 of file G4CutTubs.cc.

 {
    // Check assignment to self
    //
    if (this == &rhs)  { return *this; }
 
    // Copy base class data
    //
    G4OTubs::operator=(rhs);
 
    // Copy data
    //
    fLowNorm = rhs.fLowNorm; fHighNorm = rhs.fHighNorm;
    fPhiFullCutTube = rhs.fPhiFullCutTube;
    halfCarTolerance = rhs.halfCarTolerance;
    halfRadTolerance = rhs.halfRadTolerance;
    halfAngTolerance = rhs.halfAngTolerance;
 
    return *this;
 }

Here is the call graph for this function:

◆ StreamInfo()

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

virtual

Reimplemented from G4CSGSolid.

Definition at line 1867 of file G4CutTubs.cc.

 {
   G4int oldprc = os.precision(16);
   os << "-----------------------------------------------------------\n"
      << "    *** Dump for solid - " << GetName() << " ***\n"
      << "    ===================================================\n"
      << " Solid type: G4CutTubs\n"
      << " Parameters: \n"
      << "    inner radius : " << fRMin/mm << " mm \n"
      << "    outer radius : " << fRMax/mm << " mm \n"
      << "    half length Z: " << fDz/mm << " mm \n"
      << "    starting phi : " << fSPhi/degree << " degrees \n"
      << "    delta phi    : " << fDPhi/degree << " degrees \n"
      << "    low Norm     : " << fLowNorm     << "  \n" 
      << "    high Norm    : "  <<fHighNorm    << "  \n"
      << "-----------------------------------------------------------\n";
   os.precision(oldprc);
 
   return os;
 }

Here is the call graph for this function:

◆ SurfaceNormal()

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

virtual

Implements G4VSolid.

Definition at line 521 of file G4CutTubs.cc.

 {
   G4int noSurfaces = 0;
   G4double rho, pPhi;
   G4double distZLow,distZHigh, distRMin, distRMax;
   G4double distSPhi = kInfinity, distEPhi = kInfinity;
   G4ThreeVector vZ=G4ThreeVector(0,0,fDz);
 
   G4ThreeVector norm, sumnorm(0.,0.,0.);
   G4ThreeVector nZ = G4ThreeVector(0, 0, 1.0);
   G4ThreeVector nR, nPs, nPe;
 
   rho = std::sqrt(p.x()*p.x() + p.y()*p.y());
 
   distRMin = std::fabs(rho - fRMin);
   distRMax = std::fabs(rho - fRMax);
 
   // dist to Low Cut
   //
   distZLow =std::fabs((p+vZ).dot(fLowNorm));
  
   // dist to High Cut
   //
   distZHigh = std::fabs((p-vZ).dot(fHighNorm));
 
   if (!fPhiFullCutTube)    // Protected against (0,0,z) 
   {
     if ( rho > halfCarTolerance )
     {
       pPhi = std::atan2(p.y(),p.x());
     
       if(pPhi  < fSPhi- halfCarTolerance)           { pPhi += twopi; }
       else if(pPhi > fSPhi+fDPhi+ halfCarTolerance) { pPhi -= twopi; }
 
       distSPhi = std::fabs(pPhi - fSPhi);       
       distEPhi = std::fabs(pPhi - fSPhi - fDPhi); 
     }
     else if( !fRMin )
     {
       distSPhi = 0.; 
       distEPhi = 0.; 
     }
     nPs = G4ThreeVector(std::sin(fSPhi),-std::cos(fSPhi),0);
     nPe = G4ThreeVector(-std::sin(fSPhi+fDPhi),std::cos(fSPhi+fDPhi),0);
   }
   if ( rho > halfCarTolerance ) { nR = G4ThreeVector(p.x()/rho,p.y()/rho,0); }
 
   if( distRMax <= halfCarTolerance ) 
   {
     noSurfaces ++;
     sumnorm += nR;
   }
   if( fRMin && (distRMin <= halfCarTolerance) )
   {
     noSurfaces ++;
     sumnorm -= nR;
   }
   if( fDPhi < twopi )   
   {
     if (distSPhi <= halfAngTolerance)  
     {
       noSurfaces ++;
       sumnorm += nPs;
     }
     if (distEPhi <= halfAngTolerance)  
     {
       noSurfaces ++;
       sumnorm += nPe;
     }
   }
   if (distZLow <= halfCarTolerance)  
   {
     noSurfaces ++;
     sumnorm += fLowNorm;
   }
   if (distZHigh <= halfCarTolerance)  
   {
     noSurfaces ++;
     sumnorm += fHighNorm;
   }
   if ( noSurfaces == 0 )
   {
 #ifdef G4CSGDEBUG
     G4Exception("G4CutTubs::SurfaceNormal(p)", "GeomSolids1002",
                 JustWarning, "Point p is not on surface !?" );
     G4int oldprc = G4cout.precision(20);
     G4cout<< "G4CutTubs::SN ( "<<p.x()<<", "<<p.y()<<", "<<p.z()<<" ); "
           << G4endl << G4endl;
     G4cout.precision(oldprc) ;
 #endif 
      norm = ApproxSurfaceNormal(p);
   }
   else if ( noSurfaces == 1 )  { norm = sumnorm; }
   else                         { norm = sumnorm.unit(); }
 
   return norm;
 }

Here is the call graph for this function:

Member Data Documentation

◆ fHighNorm

G4ThreeVector G4CutTubs::fHighNorm

private

Definition at line 147 of file G4CutTubs.hh.

◆ fLowNorm

G4ThreeVector G4CutTubs::fLowNorm

private

Definition at line 147 of file G4CutTubs.hh.

◆ fPhiFullCutTube

G4bool G4CutTubs::fPhiFullCutTube

private

Definition at line 151 of file G4CutTubs.hh.

◆ halfAngTolerance

G4double G4CutTubs::halfAngTolerance

private

Definition at line 155 of file G4CutTubs.hh.

◆ halfCarTolerance

G4double G4CutTubs::halfCarTolerance

private

Definition at line 155 of file G4CutTubs.hh.

◆ halfRadTolerance

G4double G4CutTubs::halfRadTolerance

private

Definition at line 155 of file G4CutTubs.hh.

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

Public Member Functions

Protected Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4CutTubs() [1/3]

◆ ~G4CutTubs()

◆ G4CutTubs() [2/3]

◆ G4CutTubs() [3/3]

Member Function Documentation

◆ ApproxSurfaceNormal()

◆ CalculateExtent()

◆ Clone()

◆ CreatePolyhedron()

◆ CreateRotatedVertices()

◆ DescribeYourselfTo()

◆ DistanceToIn() [1/2]

◆ DistanceToIn() [2/2]

◆ DistanceToOut() [1/2]

◆ DistanceToOut() [2/2]

◆ GetCubicVolume()

◆ GetCutZ()

◆ GetEntityType()

◆ GetHighNorm()

◆ GetLowNorm()

◆ GetMaxMinZ()

◆ GetPointOnSurface()

◆ GetSurfaceArea()

◆ Inside()

◆ IsCrossingCutPlanes()

◆ operator=()

◆ StreamInfo()

◆ SurfaceNormal()

Member Data Documentation

◆ fHighNorm

◆ fLowNorm

◆ fPhiFullCutTube

◆ halfAngTolerance

◆ halfCarTolerance

◆ halfRadTolerance