#include <G4TwistedTubs.hh>

Inheritance diagram for G4TwistedTubs:

Collaboration diagram for G4TwistedTubs:

Classes
class	LastState

class	LastValue

class	LastValueWithDoubleVector

class	LastVector

Public Member Functions
	G4TwistedTubs (const G4String &pname, G4double twistedangle, G4double endinnerrad, G4double endouterrad, G4double halfzlen, G4double dphi)

	G4TwistedTubs (const G4String &pname, G4double twistedangle, G4double endinnerrad, G4double endouterrad, G4double halfzlen, G4int nseg, G4double totphi)

	G4TwistedTubs (const G4String &pname, G4double twistedangle, G4double innerrad, G4double outerrad, G4double negativeEndz, G4double positiveEndz, G4double dphi)

	G4TwistedTubs (const G4String &pname, G4double twistedangle, G4double innerrad, G4double outerrad, G4double negativeEndz, G4double positiveEndz, G4int nseg, G4double totphi)

virtual	~G4TwistedTubs ()

void	ComputeDimensions (G4VPVParameterisation , const G4int, const G4VPhysicalVolume )

G4bool	CalculateExtent (const EAxis paxis, const G4VoxelLimits &pvoxellimit, const G4AffineTransform &ptransform, G4double &pmin, G4double &pmax) 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

EInside	Inside (const G4ThreeVector &p) const

G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const

void	DescribeYourselfTo (G4VGraphicsScene &scene) const

G4Polyhedron *	CreatePolyhedron () const

G4Polyhedron *	GetPolyhedron () const

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

G4double	GetDPhi () const

G4double	GetPhiTwist () const

G4double	GetInnerRadius () const

G4double	GetOuterRadius () const

G4double	GetInnerStereo () const

G4double	GetOuterStereo () const

G4double	GetZHalfLength () const

G4double	GetKappa () const

G4double	GetTanInnerStereo () const

G4double	GetTanInnerStereo2 () const

G4double	GetTanOuterStereo () const

G4double	GetTanOuterStereo2 () const

G4double	GetEndZ (G4int i) const

G4double	GetEndPhi (G4int i) const

G4double	GetEndInnerRadius (G4int i) const

G4double	GetEndOuterRadius (G4int i) const

G4double	GetEndInnerRadius () const

G4double	GetEndOuterRadius () const

G4VisExtent	GetExtent () const

G4GeometryType	GetEntityType () const

G4VSolid *	Clone () const

G4double	GetCubicVolume ()

G4double	GetSurfaceArea ()

G4ThreeVector	GetPointOnSurface () const

	G4TwistedTubs (__void__ &)

	G4TwistedTubs (const G4TwistedTubs &rhs)

G4TwistedTubs &	operator= (const G4TwistedTubs &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

void	DumpInfo () const

virtual const G4VSolid *	GetConstituentSolid (G4int no) const

virtual G4VSolid *	GetConstituentSolid (G4int no)

virtual const G4DisplacedSolid *	GetDisplacedSolidPtr () const

virtual G4DisplacedSolid *	GetDisplacedSolidPtr ()

	G4VSolid (__void__ &)

	G4VSolid (const G4VSolid &rhs)

G4VSolid &	operator= (const G4VSolid &rhs)

G4double	EstimateCubicVolume (G4int nStat, G4double epsilon) const

G4double	EstimateSurfaceArea (G4int nStat, G4double ell) const

Private Member Functions
void	SetFields (G4double phitwist, G4double innerrad, G4double outerrad, G4double negativeEndz, G4double positiveEndz)

void	CreateSurfaces ()

Static Private Member Functions
static void	AddPolyToExtent (const G4ThreeVector &v0, const G4ThreeVector &v1, const G4ThreeVector &w1, const G4ThreeVector &w0, const G4VoxelLimits &voxellimit, const EAxis axis, G4SolidExtentList &extentlist)

Private Attributes
G4double	fPhiTwist

G4double	fInnerRadius

G4double	fOuterRadius

G4double	fEndZ [2]

G4double	fDPhi

G4double	fZHalfLength

G4double	fInnerStereo

G4double	fOuterStereo

G4double	fTanInnerStereo

G4double	fTanOuterStereo

G4double	fKappa

G4double	fEndInnerRadius [2]

G4double	fEndOuterRadius [2]

G4double	fEndPhi [2]

G4double	fInnerRadius2

G4double	fOuterRadius2

G4double	fTanInnerStereo2

G4double	fTanOuterStereo2

G4double	fEndZ2 [2]

G4VTwistSurface *	fLowerEndcap

G4VTwistSurface *	fUpperEndcap

G4VTwistSurface *	fLatterTwisted

G4VTwistSurface *	fFormerTwisted

G4VTwistSurface *	fInnerHype

G4VTwistSurface *	fOuterHype

G4double	fCubicVolume

G4double	fSurfaceArea

G4bool	fRebuildPolyhedron

G4Polyhedron *	fpPolyhedron

LastState	fLastInside

LastVector	fLastNormal

LastValue	fLastDistanceToIn

LastValue	fLastDistanceToOut

LastValueWithDoubleVector	fLastDistanceToInWithV

LastValueWithDoubleVector	fLastDistanceToOutWithV

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

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

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

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

Protected Attributes inherited from G4VSolid
G4double	kCarTolerance

Detailed Description

Definition at line 65 of file G4TwistedTubs.hh.

Constructor & Destructor Documentation

◆ G4TwistedTubs() [1/6]

G4TwistedTubs::G4TwistedTubs	(	const G4String &	pname,
		G4double	twistedangle,
		G4double	endinnerrad,
		G4double	endouterrad,
		G4double	halfzlen,
		G4double	dphi
	)

Definition at line 72 of file G4TwistedTubs.cc.

    : G4VSolid(pname), fDPhi(dphi), 
      fLowerEndcap(0), fUpperEndcap(0), fLatterTwisted(0),
      fFormerTwisted(0), fInnerHype(0), fOuterHype(0),
      fCubicVolume(0.), fSurfaceArea(0.),
      fRebuildPolyhedron(false), fpPolyhedron(0)
 {
    if (endinnerrad < DBL_MIN)
    {
       G4Exception("G4TwistedTubs::G4TwistedTubs()", "GeomSolids0002",
                   FatalErrorInArgument, "Invalid end-inner-radius!");
    }
             
    G4double sinhalftwist = std::sin(0.5 * twistedangle);
 
    G4double endinnerradX = endinnerrad * sinhalftwist;
    G4double innerrad     = std::sqrt( endinnerrad * endinnerrad
                                  - endinnerradX * endinnerradX );
 
    G4double endouterradX = endouterrad * sinhalftwist;
    G4double outerrad     = std::sqrt( endouterrad * endouterrad
                                  - endouterradX * endouterradX );
    
    // temporary treatment!!
    SetFields(twistedangle, innerrad, outerrad, -halfzlen, halfzlen);
    CreateSurfaces();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ G4TwistedTubs() [2/6]

G4TwistedTubs::G4TwistedTubs	(	const G4String &	pname,
		G4double	twistedangle,
		G4double	endinnerrad,
		G4double	endouterrad,
		G4double	halfzlen,
		G4int	nseg,
		G4double	totphi
	)

Definition at line 105 of file G4TwistedTubs.cc.

    : G4VSolid(pname),
      fLowerEndcap(0), fUpperEndcap(0), fLatterTwisted(0),
      fFormerTwisted(0), fInnerHype(0), fOuterHype(0),
      fCubicVolume(0.), fSurfaceArea(0.),
      fRebuildPolyhedron(false), fpPolyhedron(0)
 {
 
    if (!nseg)
    {
       std::ostringstream message;
       message << "Invalid number of segments." << G4endl
               << "        nseg = " << nseg;
       G4Exception("G4TwistedTubs::G4TwistedTubs()", "GeomSolids0002",
                   FatalErrorInArgument, message);
    }
    if (totphi == DBL_MIN || endinnerrad < DBL_MIN)
    {
       G4Exception("G4TwistedTubs::G4TwistedTubs()", "GeomSolids0002",
                 FatalErrorInArgument, "Invalid total-phi or end-inner-radius!");
    }
          
    G4double sinhalftwist = std::sin(0.5 * twistedangle);
 
    G4double endinnerradX = endinnerrad * sinhalftwist;
    G4double innerrad     = std::sqrt( endinnerrad * endinnerrad
                                  - endinnerradX * endinnerradX );
 
    G4double endouterradX = endouterrad * sinhalftwist;
    G4double outerrad     = std::sqrt( endouterrad * endouterrad
                                  - endouterradX * endouterradX );
    
    // temporary treatment!!
    fDPhi = totphi / nseg;
    SetFields(twistedangle, innerrad, outerrad, -halfzlen, halfzlen);
    CreateSurfaces();
 }

Here is the call graph for this function:

◆ G4TwistedTubs() [3/6]

G4TwistedTubs::G4TwistedTubs	(	const G4String &	pname,
		G4double	twistedangle,
		G4double	innerrad,
		G4double	outerrad,
		G4double	negativeEndz,
		G4double	positiveEndz,
		G4double	dphi
	)

Definition at line 149 of file G4TwistedTubs.cc.

    : G4VSolid(pname), fDPhi(dphi),
      fLowerEndcap(0), fUpperEndcap(0), fLatterTwisted(0),
      fFormerTwisted(0), fInnerHype(0), fOuterHype(0),
      fCubicVolume(0.), fSurfaceArea(0.),
      fRebuildPolyhedron(false), fpPolyhedron(0)
 {
    if (innerrad < DBL_MIN)
    {
       G4Exception("G4TwistedTubs::G4TwistedTubs()", "GeomSolids0002",
                   FatalErrorInArgument, "Invalid end-inner-radius!");
    }
                  
    SetFields(twistedangle, innerrad, outerrad, negativeEndz, positiveEndz);
    CreateSurfaces();
 }

Here is the call graph for this function:

◆ G4TwistedTubs() [4/6]

G4TwistedTubs::G4TwistedTubs	(	const G4String &	pname,
		G4double	twistedangle,
		G4double	innerrad,
		G4double	outerrad,
		G4double	negativeEndz,
		G4double	positiveEndz,
		G4int	nseg,
		G4double	totphi
	)

Definition at line 172 of file G4TwistedTubs.cc.

    : G4VSolid(pname),
      fLowerEndcap(0), fUpperEndcap(0), fLatterTwisted(0),
      fFormerTwisted(0), fInnerHype(0), fOuterHype(0),
      fCubicVolume(0.), fSurfaceArea(0.),
      fRebuildPolyhedron(false), fpPolyhedron(0)
 {
    if (!nseg)
    {
       std::ostringstream message;
       message << "Invalid number of segments." << G4endl
               << "        nseg = " << nseg;
       G4Exception("G4TwistedTubs::G4TwistedTubs()", "GeomSolids0002",
                   FatalErrorInArgument, message);
    }
    if (totphi == DBL_MIN || innerrad < DBL_MIN)
    {
       G4Exception("G4TwistedTubs::G4TwistedTubs()", "GeomSolids0002",
                 FatalErrorInArgument, "Invalid total-phi or end-inner-radius!");
    }
             
    fDPhi = totphi / nseg;
    SetFields(twistedangle, innerrad, outerrad, negativeEndz, positiveEndz);
    CreateSurfaces();
 }

Here is the call graph for this function:

◆ ~G4TwistedTubs()

G4TwistedTubs::~G4TwistedTubs ( )

virtual

Definition at line 222 of file G4TwistedTubs.cc.

 {
    if (fLowerEndcap)   { delete fLowerEndcap;   }
    if (fUpperEndcap)   { delete fUpperEndcap;   }
    if (fLatterTwisted) { delete fLatterTwisted; }
    if (fFormerTwisted) { delete fFormerTwisted; }
    if (fInnerHype)     { delete fInnerHype;     }
    if (fOuterHype)     { delete fOuterHype;     }
    if (fpPolyhedron)   { delete fpPolyhedron; fpPolyhedron = 0; }
 }

◆ G4TwistedTubs() [5/6]

G4TwistedTubs::G4TwistedTubs ( __void__ & a )

Definition at line 208 of file G4TwistedTubs.cc.

   : G4VSolid(a), fPhiTwist(0.), fInnerRadius(0.), fOuterRadius(0.), fDPhi(0.),
     fZHalfLength(0.), fInnerStereo(0.), fOuterStereo(0.), fTanInnerStereo(0.),
     fTanOuterStereo(0.), fKappa(0.), fInnerRadius2(0.), fOuterRadius2(0.),
     fTanInnerStereo2(0.), fTanOuterStereo2(0.), fLowerEndcap(0), fUpperEndcap(0),
     fLatterTwisted(0), fFormerTwisted(0), fInnerHype(0), fOuterHype(0),
     fCubicVolume(0.), fSurfaceArea(0.),
     fRebuildPolyhedron(false), fpPolyhedron(0)
 {
 }

◆ G4TwistedTubs() [6/6]

G4TwistedTubs::G4TwistedTubs ( const G4TwistedTubs & rhs )

Definition at line 236 of file G4TwistedTubs.cc.

   : G4VSolid(rhs), fPhiTwist(rhs.fPhiTwist),
     fInnerRadius(rhs.fInnerRadius), fOuterRadius(rhs.fOuterRadius),
     fDPhi(rhs.fDPhi), fZHalfLength(rhs.fZHalfLength),
     fInnerStereo(rhs.fInnerStereo), fOuterStereo(rhs.fOuterStereo),
     fTanInnerStereo(rhs.fTanInnerStereo), fTanOuterStereo(rhs.fTanOuterStereo),
     fKappa(rhs.fKappa), fInnerRadius2(rhs.fInnerRadius2), 
     fOuterRadius2(rhs.fOuterRadius2), fTanInnerStereo2(rhs.fTanInnerStereo2),
     fTanOuterStereo2(rhs.fTanOuterStereo2),
     fLowerEndcap(0), fUpperEndcap(0), fLatterTwisted(0), fFormerTwisted(0),
     fInnerHype(0), fOuterHype(0),
     fCubicVolume(rhs.fCubicVolume), fSurfaceArea(rhs.fSurfaceArea),
     fRebuildPolyhedron(false), fpPolyhedron(0),
     fLastInside(rhs.fLastInside), fLastNormal(rhs.fLastNormal),
     fLastDistanceToIn(rhs.fLastDistanceToIn),
     fLastDistanceToOut(rhs.fLastDistanceToOut),
     fLastDistanceToInWithV(rhs.fLastDistanceToInWithV),
     fLastDistanceToOutWithV(rhs.fLastDistanceToOutWithV)
 {
   for (size_t i=0; i<2; ++i)
   {
     fEndZ[i] = rhs.fEndZ[i];
     fEndInnerRadius[i] = rhs.fEndInnerRadius[i];
     fEndOuterRadius[i] = rhs.fEndOuterRadius[i];
     fEndPhi[i] = rhs.fEndPhi[i];
     fEndZ2[i] = rhs.fEndZ2[i];
   }
   CreateSurfaces();
 }

Here is the call graph for this function:

Member Function Documentation

◆ AddPolyToExtent()

void G4TwistedTubs::AddPolyToExtent	(	const G4ThreeVector &	v0,
		const G4ThreeVector &	v1,
		const G4ThreeVector &	w1,
		const G4ThreeVector &	w0,
		const G4VoxelLimits &	voxellimit,
		const EAxis	axis,
		G4SolidExtentList &	extentlist
	)

staticprivate

Definition at line 544 of file G4TwistedTubs.cc.

 {
     // Utility function for CalculateExtent
     //
     G4ClippablePolygon phiPoly;
 
     phiPoly.AddVertexInOrder( v0 );
     phiPoly.AddVertexInOrder( v1 );
     phiPoly.AddVertexInOrder( w1 );
     phiPoly.AddVertexInOrder( w0 );
 
     if (phiPoly.PartialClip( voxelLimit, axis ))
     {
         phiPoly.SetNormal( (v1-v0).cross(w0-v0).unit() );
         extentList.AddSurface( phiPoly );
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CalculateExtent()

G4bool G4TwistedTubs::CalculateExtent	(	const EAxis	paxis,
		const G4VoxelLimits &	pvoxellimit,
		const G4AffineTransform &	ptransform,
		G4double &	pmin,
		G4double &	pmax
	)		const

virtual

Implements G4VSolid.

Definition at line 331 of file G4TwistedTubs.cc.

 {
 
   G4SolidExtentList  extentList( axis, voxelLimit );
   G4double maxEndOuterRad = (fEndOuterRadius[0] > fEndOuterRadius[1] ?
                              fEndOuterRadius[0] : fEndOuterRadius[1]);
   G4double maxEndInnerRad = (fEndInnerRadius[0] > fEndInnerRadius[1] ?
                              fEndInnerRadius[0] : fEndInnerRadius[1]);
   G4double maxphi         = (std::fabs(fEndPhi[0]) > std::fabs(fEndPhi[1]) ?
                              std::fabs(fEndPhi[0]) : std::fabs(fEndPhi[1]));
    
   //
   // Choose phi size of our segment(s) based on constants as
   // defined in meshdefs.hh
   //
   // G4int numPhi = kMaxMeshSections;
   G4double sigPhi = 2*maxphi + fDPhi;
   G4double rFudge = 1.0/std::cos(0.5*sigPhi);
   G4double fudgeEndOuterRad = rFudge * maxEndOuterRad;
   
   //
   // We work around in phi building polygons along the way.
   // As a reasonable compromise between accuracy and
   // complexity (=cpu time), the following facets are chosen:
   //
   //   1. If fOuterRadius/maxEndOuterRad > 0.95, approximate
   //      the outer surface as a cylinder, and use one
   //      rectangular polygon (0-1) to build its mesh.
   //
   //      Otherwise, use two trapazoidal polygons that 
   //      meet at z = 0 (0-4-1)
   //
   //   2. If there is no inner surface, then use one
   //      polygon for each entire endcap.  (0) and (1)
   //
   //      Otherwise, use a trapazoidal polygon for each
   //      phi segment of each endcap.    (0-2) and (1-3)
   //
   //   3. For the inner surface, if fInnerRadius/maxEndInnerRad > 0.95,
   //      approximate the inner surface as a cylinder of
   //      radius fInnerRadius and use one rectangular polygon
   //      to build each phi segment of its mesh.   (2-3)
   //
   //      Otherwise, use one rectangular polygon centered
   //      at z = 0 (5-6) and two connecting trapazoidal polygons
   //      for each phi segment (2-5) and (3-6).
   //
 
   G4bool splitOuter = (fOuterRadius/maxEndOuterRad < 0.95);
   G4bool splitInner = (fInnerRadius/maxEndInnerRad < 0.95);
   
   //
   // Vertex assignments (v and w arrays)
   // [0] and [1] are mandatory
   // the rest are optional
   //
   //     +                     -
   //      [0]------[4]------[1]      <--- outer radius
   //       |                 |       
   //       |                 |       
   //      [2]---[5]---[6]---[3]      <--- inner radius
   //
 
   G4ClippablePolygon endPoly1, endPoly2;
   
   G4double phimax   = maxphi + 0.5*fDPhi;
   if ( phimax > pi/2)  { phimax = pi-phimax; }
   G4double phimin   = - phimax;
 
   G4ThreeVector v0, v1, v2, v3, v4, v5, v6;   // -ve phi verticies for polygon
   G4ThreeVector w0, w1, w2, w3, w4, w5, w6;   // +ve phi verticies for polygon
 
   //
   // decide verticies of -ve phi boundary
   //
   
   G4double cosPhi = std::cos(phimin);
   G4double sinPhi = std::sin(phimin);
  
   // Outer hyperbolic surface  
 
   v0 = transform.TransformPoint( 
        G4ThreeVector(fudgeEndOuterRad*cosPhi, fudgeEndOuterRad*sinPhi, 
                      + fZHalfLength));
   v1 = transform.TransformPoint( 
        G4ThreeVector(fudgeEndOuterRad*cosPhi, fudgeEndOuterRad*sinPhi, 
                      - fZHalfLength));
   if (splitOuter)
   {
      v4 = transform.TransformPoint(
           G4ThreeVector(fudgeEndOuterRad*cosPhi, fudgeEndOuterRad*sinPhi, 0));
   }
   
   // Inner hyperbolic surface  
 
   G4double zInnerSplit = 0.;
   if (splitInner)
   {
      v2 = transform.TransformPoint( 
           G4ThreeVector(maxEndInnerRad*cosPhi, maxEndInnerRad*sinPhi, 
                         + fZHalfLength));
      v3 = transform.TransformPoint( 
           G4ThreeVector(maxEndInnerRad*cosPhi, maxEndInnerRad*sinPhi, 
                         - fZHalfLength));
       
      // Find intersection of tangential line of inner
      // surface at z = fZHalfLength and line r=fInnerRadius.
      G4double dr = fZHalfLength * fTanInnerStereo2;
      G4double dz = maxEndInnerRad;
      zInnerSplit = fZHalfLength + (fInnerRadius - maxEndInnerRad) * dz / dr;
 
      // Build associated vertices
      v5 = transform.TransformPoint( 
           G4ThreeVector(fInnerRadius*cosPhi, fInnerRadius*sinPhi, 
                         + zInnerSplit));
      v6 = transform.TransformPoint( 
           G4ThreeVector(fInnerRadius*cosPhi, fInnerRadius*sinPhi, 
                         - zInnerSplit));
   }
   else
   {
      v2 = transform.TransformPoint(
           G4ThreeVector(fInnerRadius*cosPhi, fInnerRadius*sinPhi, 
                         + fZHalfLength));
      v3 = transform.TransformPoint(
           G4ThreeVector(fInnerRadius*cosPhi, fInnerRadius*sinPhi, 
                         - fZHalfLength));
   }
 
   //
   // decide vertices of +ve phi boundary
   // 
 
   cosPhi = std::cos(phimax);
   sinPhi = std::sin(phimax);
    
   // Outer hyperbolic surface  
   
   w0 = transform.TransformPoint(
        G4ThreeVector(fudgeEndOuterRad*cosPhi, fudgeEndOuterRad*sinPhi,
                      + fZHalfLength));
   w1 = transform.TransformPoint(
        G4ThreeVector(fudgeEndOuterRad*cosPhi, fudgeEndOuterRad*sinPhi,
                      - fZHalfLength));
   if (splitOuter)
   {
      G4double r = rFudge*fOuterRadius;
      
      w4 = transform.TransformPoint(G4ThreeVector( r*cosPhi, r*sinPhi, 0 ));
       
      AddPolyToExtent( v0, v4, w4, w0, voxelLimit, axis, extentList );
      AddPolyToExtent( v4, v1, w1, w4, voxelLimit, axis, extentList );
   }
   else
   {
      AddPolyToExtent( v0, v1, w1, w0, voxelLimit, axis, extentList );
   }
   
   // Inner hyperbolic surface
   
   if (splitInner)
   {
      w2 = transform.TransformPoint(
           G4ThreeVector(maxEndInnerRad*cosPhi, maxEndInnerRad*sinPhi, 
                         + fZHalfLength));
      w3 = transform.TransformPoint(
           G4ThreeVector(maxEndInnerRad*cosPhi, maxEndInnerRad*sinPhi, 
                         - fZHalfLength));
           
      w5 = transform.TransformPoint(
           G4ThreeVector(fInnerRadius*cosPhi, fInnerRadius*sinPhi,
                         + zInnerSplit));
      w6 = transform.TransformPoint(
           G4ThreeVector(fInnerRadius*cosPhi, fInnerRadius*sinPhi,
                         - zInnerSplit));
                                    
      AddPolyToExtent( v3, v6, w6, w3, voxelLimit, axis, extentList );
      AddPolyToExtent( v6, v5, w5, w6, voxelLimit, axis, extentList );
      AddPolyToExtent( v5, v2, w2, w5, voxelLimit, axis, extentList );
      
   }
   else
   {
      w2 = transform.TransformPoint(
           G4ThreeVector(fInnerRadius*cosPhi, fInnerRadius*sinPhi,
                         + fZHalfLength));
      w3 = transform.TransformPoint(
           G4ThreeVector(fInnerRadius*cosPhi, fInnerRadius*sinPhi,
                         - fZHalfLength));
 
      AddPolyToExtent( v3, v2, w2, w3, voxelLimit, axis, extentList );
   }
 
   //
   // Endplate segments
   //
   AddPolyToExtent( v1, v3, w3, w1, voxelLimit, axis, extentList );
   AddPolyToExtent( v2, v0, w0, w2, voxelLimit, axis, extentList );
   
   //
   // Return min/max value
   //
   return extentList.GetExtent( min, max );
 }

Here is the call graph for this function:

◆ Clone()

G4VSolid * G4TwistedTubs::Clone ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1222 of file G4TwistedTubs.cc.

 {
   return new G4TwistedTubs(*this);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputeDimensions()

void G4TwistedTubs::ComputeDimensions	(	G4VPVParameterisation *	,
		const G4int	,
		const G4VPhysicalVolume *
	)

virtual

Reimplemented from G4VSolid.

Definition at line 318 of file G4TwistedTubs.cc.

 {
   G4Exception("G4TwistedTubs::ComputeDimensions()",
               "GeomSolids0001", FatalException,
               "G4TwistedTubs does not support Parameterisation.");
 }

Here is the call graph for this function:

◆ CreatePolyhedron()

G4Polyhedron * G4TwistedTubs::CreatePolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1098 of file G4TwistedTubs.cc.

 {
   // number of meshes
   //
   G4double dA = std::max(fDPhi,fPhiTwist);
   const G4int k =
     G4int(G4Polyhedron::GetNumberOfRotationSteps() * dA / twopi) + 2;
   const G4int n =
     G4int(G4Polyhedron::GetNumberOfRotationSteps() * fPhiTwist / twopi) + 2;
 
   const G4int nnodes = 4*(k-1)*(n-2) + 2*k*k ;
   const G4int nfaces = 4*(k-1)*(n-1) + 2*(k-1)*(k-1) ;
 
   G4Polyhedron *ph=new G4Polyhedron;
   typedef G4double G4double3[3];
   typedef G4int G4int4[4];
   G4double3* xyz = new G4double3[nnodes];  // number of nodes 
   G4int4*  faces = new G4int4[nfaces] ;    // number of faces
   fLowerEndcap->GetFacets(k,k,xyz,faces,0) ;
   fUpperEndcap->GetFacets(k,k,xyz,faces,1) ;
   fInnerHype->GetFacets(k,n,xyz,faces,2) ;
   fFormerTwisted->GetFacets(k,n,xyz,faces,3) ;
   fOuterHype->GetFacets(k,n,xyz,faces,4) ;
   fLatterTwisted->GetFacets(k,n,xyz,faces,5) ;
 
   ph->createPolyhedron(nnodes,nfaces,xyz,faces);
 
   delete[] xyz;
   delete[] faces;
 
   return ph;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CreateSurfaces()

void G4TwistedTubs::CreateSurfaces ( )

private

Definition at line 1153 of file G4TwistedTubs.cc.

 {
    // create 6 surfaces of TwistedTub
 
    G4ThreeVector x0(0, 0, fEndZ[0]);
    G4ThreeVector n (0, 0, -1);
 
    fLowerEndcap = new G4TwistTubsFlatSide("LowerEndcap",
                                     fEndInnerRadius, fEndOuterRadius,
                                     fDPhi, fEndPhi, fEndZ, -1) ;
 
    fUpperEndcap = new G4TwistTubsFlatSide("UpperEndcap",  
                                     fEndInnerRadius, fEndOuterRadius,
                                     fDPhi, fEndPhi, fEndZ, 1) ;
 
    G4RotationMatrix    rotHalfDPhi;
    rotHalfDPhi.rotateZ(0.5*fDPhi);
 
    fLatterTwisted = new G4TwistTubsSide("LatterTwisted",
                                          fEndInnerRadius, fEndOuterRadius,
                                          fDPhi, fEndPhi, fEndZ, 
                                          fInnerRadius, fOuterRadius, fKappa,
                                          1 ) ; 
    fFormerTwisted = new G4TwistTubsSide("FormerTwisted", 
                                          fEndInnerRadius, fEndOuterRadius,
                                          fDPhi, fEndPhi, fEndZ, 
                                          fInnerRadius, fOuterRadius, fKappa,
                                          -1 ) ; 
 
    fInnerHype = new G4TwistTubsHypeSide("InnerHype",
                                         fEndInnerRadius, fEndOuterRadius,
                                         fDPhi, fEndPhi, fEndZ, 
                                         fInnerRadius, fOuterRadius,fKappa,
                                         fTanInnerStereo, fTanOuterStereo, -1) ;
    fOuterHype = new G4TwistTubsHypeSide("OuterHype", 
                                         fEndInnerRadius, fEndOuterRadius,
                                         fDPhi, fEndPhi, fEndZ, 
                                         fInnerRadius, fOuterRadius,fKappa,
                                         fTanInnerStereo, fTanOuterStereo, 1) ;
 
 
    // set neighbour surfaces
    //
    fLowerEndcap->SetNeighbours(fInnerHype, fLatterTwisted,
                                fOuterHype, fFormerTwisted);
    fUpperEndcap->SetNeighbours(fInnerHype, fLatterTwisted,
                                fOuterHype, fFormerTwisted);
    fLatterTwisted->SetNeighbours(fInnerHype, fLowerEndcap,
                                  fOuterHype, fUpperEndcap);
    fFormerTwisted->SetNeighbours(fInnerHype, fLowerEndcap,
                                  fOuterHype, fUpperEndcap);
    fInnerHype->SetNeighbours(fLatterTwisted, fLowerEndcap,
                              fFormerTwisted, fUpperEndcap);
    fOuterHype->SetNeighbours(fLatterTwisted, fLowerEndcap,
                              fFormerTwisted, fUpperEndcap);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DescribeYourselfTo()

void G4TwistedTubs::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

virtual

Implements G4VSolid.

Definition at line 1077 of file G4TwistedTubs.cc.

 {
   scene.AddSolid (*this);
 }

Here is the call graph for this function:

◆ DistanceToIn() [1/2]

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

virtual

Implements G4VSolid.

Definition at line 679 of file G4TwistedTubs.cc.

 {
 
    // DistanceToIn (p, v):
    // Calculate distance to surface of shape from `outside' 
    // along with the v, allowing for tolerance.
    // The function returns kInfinity if no intersection or
    // just grazing within tolerance.
 
    //
    // checking last value
    //
    
    G4ThreeVector *tmpp;
    G4ThreeVector *tmpv;
    G4double      *tmpdist;
    if ((fLastDistanceToInWithV.p == p) && (fLastDistanceToInWithV.vec == v))
    {
      return fLastDistanceToIn.value;
    }
    else
    {
       tmpp    = const_cast<G4ThreeVector*>(&(fLastDistanceToInWithV.p));
       tmpv    = const_cast<G4ThreeVector*>(&(fLastDistanceToInWithV.vec));
       tmpdist = const_cast<G4double*>(&(fLastDistanceToInWithV.value));
       tmpp->set(p.x(), p.y(), p.z());
       tmpv->set(v.x(), v.y(), v.z());
    }
 
    //
    // Calculate DistanceToIn(p,v)
    //
    
    EInside currentside = Inside(p);
 
    if (currentside == kInside)
    {
    }
    else
    {
      if (currentside == kSurface)
      {
        // particle is just on a boundary.
        // If the particle is entering to the volume, return 0.
        //
        G4ThreeVector normal = SurfaceNormal(p);
        if (normal*v < 0)
        {
          *tmpdist = 0;
          return fLastDistanceToInWithV.value;
        } 
      }
    }
       
    // now, we can take smallest positive distance.
    
    // Initialize
    //
    G4double      distance = kInfinity;   
 
    // find intersections and choose nearest one.
    //
    G4VTwistSurface *surfaces[6];
    surfaces[0] = fLowerEndcap;
    surfaces[1] = fUpperEndcap;
    surfaces[2] = fLatterTwisted;
    surfaces[3] = fFormerTwisted;
    surfaces[4] = fInnerHype;
    surfaces[5] = fOuterHype;
    
    G4ThreeVector xx;
    G4ThreeVector bestxx;
    G4int i;
    for (i=0; i< 6; i++)
    {
       G4double tmpdistance = surfaces[i]->DistanceToIn(p, v, xx);
       if (tmpdistance < distance)
       {
          distance = tmpdistance;
          bestxx = xx;
       }
    }
    *tmpdist = distance;
 
    return fLastDistanceToInWithV.value;
 }

Here is the call graph for this function:

◆ DistanceToIn() [2/2]

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

virtual

Implements G4VSolid.

Definition at line 770 of file G4TwistedTubs.cc.

 {
    // DistanceToIn(p):
    // Calculate distance to surface of shape from `outside',
    // allowing for tolerance
    
    //
    // checking last value
    //
    
    G4ThreeVector *tmpp;
    G4double      *tmpdist;
    if (fLastDistanceToIn.p == p)
    {
      return fLastDistanceToIn.value;
    }
    else
    {
       tmpp    = const_cast<G4ThreeVector*>(&(fLastDistanceToIn.p));
       tmpdist = const_cast<G4double*>(&(fLastDistanceToIn.value));
       tmpp->set(p.x(), p.y(), p.z());
    }
 
    //
    // Calculate DistanceToIn(p) 
    //
    
    EInside currentside = Inside(p);
 
    switch (currentside)
    {
       case (kInside) :
       {}
       case (kSurface) :
       {
          *tmpdist = 0.;
          return fLastDistanceToIn.value;
       }
       case (kOutside) :
       {
          // Initialize
          G4double      distance = kInfinity;   
 
          // find intersections and choose nearest one.
          G4VTwistSurface *surfaces[6];
          surfaces[0] = fLowerEndcap;
          surfaces[1] = fUpperEndcap;
          surfaces[2] = fLatterTwisted;
          surfaces[3] = fFormerTwisted;
          surfaces[4] = fInnerHype;
          surfaces[5] = fOuterHype;
 
          G4int i;
          G4ThreeVector xx;
          G4ThreeVector bestxx;
          for (i=0; i< 6; i++)
          {
             G4double tmpdistance = surfaces[i]->DistanceTo(p, xx);
             if (tmpdistance < distance)
             {
                distance = tmpdistance;
                bestxx = xx;
             }
          }
          *tmpdist = distance;
          return fLastDistanceToIn.value;
       }
       default :
       {
          G4Exception("G4TwistedTubs::DistanceToIn(p)", "GeomSolids0003",
                      FatalException, "Unknown point location!");
       }
    } // switch end
 
    return kInfinity;
 }

Here is the call graph for this function:

◆ DistanceToOut() [1/2]

G4double G4TwistedTubs::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 850 of file G4TwistedTubs.cc.

 {
    // DistanceToOut (p, v):
    // Calculate distance to surface of shape from `inside'
    // along with the v, allowing for tolerance.
    // The function returns kInfinity if no intersection or
    // just grazing within tolerance.
 
    //
    // checking last value
    //
    
    G4ThreeVector *tmpp;
    G4ThreeVector *tmpv;
    G4double      *tmpdist;
    if ((fLastDistanceToOutWithV.p == p) && (fLastDistanceToOutWithV.vec == v) )
    {
      return fLastDistanceToOutWithV.value;
    }
    else
    {
       tmpp    = const_cast<G4ThreeVector*>(&(fLastDistanceToOutWithV.p));
       tmpv    = const_cast<G4ThreeVector*>(&(fLastDistanceToOutWithV.vec));
       tmpdist = const_cast<G4double*>(&(fLastDistanceToOutWithV.value));
       tmpp->set(p.x(), p.y(), p.z());
       tmpv->set(v.x(), v.y(), v.z());
    }
 
    //
    // Calculate DistanceToOut(p,v)
    //
    
    EInside currentside = Inside(p);
 
    if (currentside == kOutside)
    {
    }
    else
    {
      if (currentside == kSurface)
      {
        // particle is just on a boundary.
        // If the particle is exiting from the volume, return 0.
        //
        G4ThreeVector normal = SurfaceNormal(p);
        G4VTwistSurface *blockedsurface = fLastNormal.surface[0];
        if (normal*v > 0)
        {
          if (calcNorm)
          {
            *norm = (blockedsurface->GetNormal(p, true));
            *validNorm = blockedsurface->IsValidNorm();
          }
          *tmpdist = 0.;
          return fLastDistanceToOutWithV.value;
        }
      }
    }
       
    // now, we can take smallest positive distance.
    
    // Initialize
    //
    G4double      distance = kInfinity;
        
    // find intersections and choose nearest one.
    //
    G4VTwistSurface *surfaces[6];
    surfaces[0] = fLatterTwisted;
    surfaces[1] = fFormerTwisted;
    surfaces[2] = fInnerHype;
    surfaces[3] = fOuterHype;
    surfaces[4] = fLowerEndcap;
    surfaces[5] = fUpperEndcap;
    
    G4int i;
    G4int besti = -1;
    G4ThreeVector xx;
    G4ThreeVector bestxx;
    for (i=0; i< 6; i++)
    {
       G4double tmpdistance = surfaces[i]->DistanceToOut(p, v, xx);
       if (tmpdistance < distance)
       {
          distance = tmpdistance;
          bestxx = xx; 
          besti = i;
       }
    }
 
    if (calcNorm)
    {
       if (besti != -1)
       {
          *norm = (surfaces[besti]->GetNormal(p, true));
          *validNorm = surfaces[besti]->IsValidNorm();
       }
    }
 
    *tmpdist = distance;
 
    return fLastDistanceToOutWithV.value;
 }

Here is the call graph for this function:

◆ DistanceToOut() [2/2]

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

virtual

Implements G4VSolid.

Definition at line 962 of file G4TwistedTubs.cc.

 {
    // DistanceToOut(p):
    // Calculate distance to surface of shape from `inside', 
    // allowing for tolerance
 
    //
    // checking last value
    //
    
    G4ThreeVector *tmpp;
    G4double      *tmpdist;
    if (fLastDistanceToOut.p == p)
    {
       return fLastDistanceToOut.value;
    }
    else
    {
       tmpp    = const_cast<G4ThreeVector*>(&(fLastDistanceToOut.p));
       tmpdist = const_cast<G4double*>(&(fLastDistanceToOut.value));
       tmpp->set(p.x(), p.y(), p.z());
    }
    
    //
    // Calculate DistanceToOut(p)
    //
    
    EInside currentside = Inside(p);
 
    switch (currentside)
    {
       case (kOutside) :
       {
       }
       case (kSurface) :
       {
         *tmpdist = 0.;
          return fLastDistanceToOut.value;
       }
       case (kInside) :
       {
          // Initialize
          G4double      distance = kInfinity;
    
          // find intersections and choose nearest one.
          G4VTwistSurface *surfaces[6];
          surfaces[0] = fLatterTwisted;
          surfaces[1] = fFormerTwisted;
          surfaces[2] = fInnerHype;
          surfaces[3] = fOuterHype;
          surfaces[4] = fLowerEndcap;
          surfaces[5] = fUpperEndcap;
 
          G4int i;
          G4ThreeVector xx;
          G4ThreeVector bestxx;
          for (i=0; i< 6; i++)
          {
             G4double tmpdistance = surfaces[i]->DistanceTo(p, xx);
             if (tmpdistance < distance)
             {
                distance = tmpdistance;
                bestxx = xx;
             }
          }
          *tmpdist = distance;
    
          return fLastDistanceToOut.value;
       }
       default :
       {
          G4Exception("G4TwistedTubs::DistanceToOut(p)", "GeomSolids0003",
                      FatalException, "Unknown point location!");
       }
    } // switch end
 
    return 0;
 }

Here is the call graph for this function:

◆ GetCubicVolume()

G4double G4TwistedTubs::GetCubicVolume ( )

virtual

Reimplemented from G4VSolid.

Definition at line 1230 of file G4TwistedTubs.cc.

 {
   if(fCubicVolume != 0.) {;}
   else   { fCubicVolume = fDPhi*fZHalfLength*(fOuterRadius*fOuterRadius
                                              -fInnerRadius*fInnerRadius); }
   return fCubicVolume;
 }

Here is the caller graph for this function:

◆ GetDPhi()

G4double G4TwistedTubs::GetDPhi ( ) const

inline

Definition at line 138 of file G4TwistedTubs.hh.

138 { return fDPhi ; }

G4TwistedTubs::fDPhi

G4double fDPhi

Definition: G4TwistedTubs.hh:214

Here is the caller graph for this function:

◆ GetEndInnerRadius() [1/2]

G4double G4TwistedTubs::GetEndInnerRadius ( G4int i ) const

inline

Definition at line 154 of file G4TwistedTubs.hh.

155 { return fEndInnerRadius[i]; }

G4TwistedTubs::fEndInnerRadius

G4double fEndInnerRadius[2]

Definition: G4TwistedTubs.hh:222

◆ GetEndInnerRadius() [2/2]

G4double G4TwistedTubs::GetEndInnerRadius ( ) const

inline

Definition at line 158 of file G4TwistedTubs.hh.

159 { return (fEndInnerRadius[0] > fEndInnerRadius[1] ?

160 fEndInnerRadius[0] : fEndInnerRadius[1]); }

G4TwistedTubs::fEndInnerRadius

G4double fEndInnerRadius[2]

Definition: G4TwistedTubs.hh:222

Here is the caller graph for this function:

◆ GetEndOuterRadius() [1/2]

G4double G4TwistedTubs::GetEndOuterRadius ( G4int i ) const

inline

Definition at line 156 of file G4TwistedTubs.hh.

157 { return fEndOuterRadius[i]; }

G4TwistedTubs::fEndOuterRadius

G4double fEndOuterRadius[2]

Definition: G4TwistedTubs.hh:223

◆ GetEndOuterRadius() [2/2]

G4double G4TwistedTubs::GetEndOuterRadius ( ) const

inline

Definition at line 161 of file G4TwistedTubs.hh.

162 { return (fEndOuterRadius[0] > fEndOuterRadius[1] ?

163 fEndOuterRadius[0] : fEndOuterRadius[1]); }

G4TwistedTubs::fEndOuterRadius

G4double fEndOuterRadius[2]

Definition: G4TwistedTubs.hh:223

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetEndPhi()

G4double G4TwistedTubs::GetEndPhi ( G4int i ) const

inline

Definition at line 153 of file G4TwistedTubs.hh.

153 { return fEndPhi[i]; }

G4TwistedTubs::fEndPhi

G4double fEndPhi[2]

Definition: G4TwistedTubs.hh:224

Here is the caller graph for this function:

◆ GetEndZ()

G4double G4TwistedTubs::GetEndZ ( G4int i ) const

inline

Definition at line 152 of file G4TwistedTubs.hh.

152 { return fEndZ[i] ; }

G4TwistedTubs::fEndZ

G4double fEndZ[2]

Definition: G4TwistedTubs.hh:213

Here is the caller graph for this function:

◆ GetEntityType()

G4GeometryType G4TwistedTubs::GetEntityType ( ) const

virtual

Implements G4VSolid.

Definition at line 1214 of file G4TwistedTubs.cc.

 {
   return G4String("G4TwistedTubs");
 }

Here is the caller graph for this function:

◆ GetExtent()

G4VisExtent G4TwistedTubs::GetExtent ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1085 of file G4TwistedTubs.cc.

 {
   // Define the sides of the box into which the G4Tubs instance would fit.
 
   G4double maxEndOuterRad = (fEndOuterRadius[0] > fEndOuterRadius[1] ? 0 : 1);
   return G4VisExtent( -maxEndOuterRad, maxEndOuterRad, 
                       -maxEndOuterRad, maxEndOuterRad, 
                       -fZHalfLength, fZHalfLength );
 }

Here is the caller graph for this function:

◆ GetInnerRadius()

G4double G4TwistedTubs::GetInnerRadius ( ) const

inline

Definition at line 140 of file G4TwistedTubs.hh.

140 { return fInnerRadius; }

G4TwistedTubs::fInnerRadius

G4double fInnerRadius

Definition: G4TwistedTubs.hh:211

Here is the caller graph for this function:

◆ GetInnerStereo()

G4double G4TwistedTubs::GetInnerStereo ( ) const

inline

Definition at line 142 of file G4TwistedTubs.hh.

142 { return fInnerStereo; }

G4TwistedTubs::fInnerStereo

G4double fInnerStereo

Definition: G4TwistedTubs.hh:217

Here is the caller graph for this function:

◆ GetKappa()

G4double G4TwistedTubs::GetKappa ( ) const

inline

Definition at line 145 of file G4TwistedTubs.hh.

145 { return fKappa ; }

G4TwistedTubs::fKappa

G4double fKappa

Definition: G4TwistedTubs.hh:221

Here is the caller graph for this function:

◆ GetOuterRadius()

G4double G4TwistedTubs::GetOuterRadius ( ) const

inline

Definition at line 141 of file G4TwistedTubs.hh.

141 { return fOuterRadius; }

G4TwistedTubs::fOuterRadius

G4double fOuterRadius

Definition: G4TwistedTubs.hh:212

Here is the caller graph for this function:

◆ GetOuterStereo()

G4double G4TwistedTubs::GetOuterStereo ( ) const

inline

Definition at line 143 of file G4TwistedTubs.hh.

143 { return fOuterStereo; }

G4TwistedTubs::fOuterStereo

G4double fOuterStereo

Definition: G4TwistedTubs.hh:218

Here is the caller graph for this function:

◆ GetPhiTwist()

G4double G4TwistedTubs::GetPhiTwist ( ) const

inline

Definition at line 139 of file G4TwistedTubs.hh.

139 { return fPhiTwist ; }

G4TwistedTubs::fPhiTwist

G4double fPhiTwist

Definition: G4TwistedTubs.hh:210

Here is the caller graph for this function:

◆ GetPointOnSurface()

G4ThreeVector G4TwistedTubs::GetPointOnSurface ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1251 of file G4TwistedTubs.cc.

 {
 
   G4double  z = G4RandFlat::shoot(fEndZ[0],fEndZ[1]);
   G4double phi , phimin, phimax ;
   G4double x   , xmin,   xmax ;
   G4double r   , rmin,   rmax ;
 
   G4double a1 = fOuterHype->GetSurfaceArea() ;
   G4double a2 = fInnerHype->GetSurfaceArea() ;
   G4double a3 = fLatterTwisted->GetSurfaceArea() ;
   G4double a4 = fFormerTwisted->GetSurfaceArea() ;
   G4double a5 = fLowerEndcap->GetSurfaceArea()  ;
   G4double a6 = fUpperEndcap->GetSurfaceArea() ;
 
   G4double chose = G4RandFlat::shoot(0.,a1 + a2 + a3 + a4 + a5 + a6) ;
 
   if(chose < a1)
   {
 
     phimin = fOuterHype->GetBoundaryMin(z) ;
     phimax = fOuterHype->GetBoundaryMax(z) ;
     phi = G4RandFlat::shoot(phimin,phimax) ;
 
     return fOuterHype->SurfacePoint(phi,z,true) ;
 
   }
   else if ( (chose >= a1) && (chose < a1 + a2 ) )
   {
 
     phimin = fInnerHype->GetBoundaryMin(z) ;
     phimax = fInnerHype->GetBoundaryMax(z) ;
     phi = G4RandFlat::shoot(phimin,phimax) ;
 
     return fInnerHype->SurfacePoint(phi,z,true) ;
 
   }
   else if ( (chose >= a1 + a2 ) && (chose < a1 + a2 + a3 ) ) 
   {
 
     xmin = fLatterTwisted->GetBoundaryMin(z) ; 
     xmax = fLatterTwisted->GetBoundaryMax(z) ;
     x = G4RandFlat::shoot(xmin,xmax) ;
     
     return fLatterTwisted->SurfacePoint(x,z,true) ;
 
   }
   else if ( (chose >= a1 + a2 + a3  ) && (chose < a1 + a2 + a3 + a4  ) )
   {
 
     xmin = fFormerTwisted->GetBoundaryMin(z) ; 
     xmax = fFormerTwisted->GetBoundaryMax(z) ;
     x = G4RandFlat::shoot(xmin,xmax) ;
 
     return fFormerTwisted->SurfacePoint(x,z,true) ;
    }
   else if( (chose >= a1 + a2 + a3 + a4  )&&(chose < a1 + a2 + a3 + a4 + a5 ) )
   {
     rmin = GetEndInnerRadius(0) ;
     rmax = GetEndOuterRadius(0) ;
     r = std::sqrt(G4RandFlat::shoot()*(sqr(rmax)-sqr(rmin))+sqr(rmin));
 
     phimin = fLowerEndcap->GetBoundaryMin(r) ; 
     phimax = fLowerEndcap->GetBoundaryMax(r) ;
     phi    = G4RandFlat::shoot(phimin,phimax) ;
 
     return fLowerEndcap->SurfacePoint(phi,r,true) ;
   }
   else
   {
     rmin = GetEndInnerRadius(1) ;
     rmax = GetEndOuterRadius(1) ;
     r = rmin + (rmax-rmin)*std::sqrt(G4RandFlat::shoot());
 
     phimin = fUpperEndcap->GetBoundaryMin(r) ; 
     phimax = fUpperEndcap->GetBoundaryMax(r) ;
     phi    = G4RandFlat::shoot(phimin,phimax) ;
 
     return fUpperEndcap->SurfacePoint(phi,r,true) ;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetPolyhedron()

G4Polyhedron * G4TwistedTubs::GetPolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1134 of file G4TwistedTubs.cc.

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

Here is the call graph for this function:

◆ GetSurfaceArea()

G4double G4TwistedTubs::GetSurfaceArea ( )

virtual

Reimplemented from G4VSolid.

Definition at line 1241 of file G4TwistedTubs.cc.

 {
   if(fSurfaceArea != 0.) {;}
   else   { fSurfaceArea = G4VSolid::GetSurfaceArea(); }
   return fSurfaceArea;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetTanInnerStereo()

G4double G4TwistedTubs::GetTanInnerStereo ( ) const

inline

Definition at line 147 of file G4TwistedTubs.hh.

147 { return fTanInnerStereo ; }

G4TwistedTubs::fTanInnerStereo

G4double fTanInnerStereo

Definition: G4TwistedTubs.hh:219

Here is the caller graph for this function:

◆ GetTanInnerStereo2()

G4double G4TwistedTubs::GetTanInnerStereo2 ( ) const

inline

Definition at line 148 of file G4TwistedTubs.hh.

148 { return fTanInnerStereo2 ; }

G4TwistedTubs::fTanInnerStereo2

G4double fTanInnerStereo2

Definition: G4TwistedTubs.hh:228

Here is the caller graph for this function:

◆ GetTanOuterStereo()

G4double G4TwistedTubs::GetTanOuterStereo ( ) const

inline

Definition at line 149 of file G4TwistedTubs.hh.

149 { return fTanOuterStereo ; }

G4TwistedTubs::fTanOuterStereo

G4double fTanOuterStereo

Definition: G4TwistedTubs.hh:220

Here is the caller graph for this function:

◆ GetTanOuterStereo2()

G4double G4TwistedTubs::GetTanOuterStereo2 ( ) const

inline

Definition at line 150 of file G4TwistedTubs.hh.

150 { return fTanOuterStereo2 ; }

G4TwistedTubs::fTanOuterStereo2

G4double fTanOuterStereo2

Definition: G4TwistedTubs.hh:229

Here is the caller graph for this function:

◆ GetZHalfLength()

G4double G4TwistedTubs::GetZHalfLength ( ) const

inline

Definition at line 144 of file G4TwistedTubs.hh.

144 { return fZHalfLength; }

G4TwistedTubs::fZHalfLength

G4double fZHalfLength

Definition: G4TwistedTubs.hh:215

Here is the caller graph for this function:

◆ Inside()

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

virtual

Implements G4VSolid.

Definition at line 572 of file G4TwistedTubs.cc.

 {
 
    const G4double halftol
      = 0.5 * G4GeometryTolerance::GetInstance()->GetRadialTolerance();
    // static G4int timerid = -1;
    // G4Timer timer(timerid, "G4TwistedTubs", "Inside");
    // timer.Start();
 
    G4ThreeVector *tmpp;
    EInside       *tmpinside;
    if (fLastInside.p == p)
    {
      return fLastInside.inside;
    }
    else
    {
       tmpp      = const_cast<G4ThreeVector*>(&(fLastInside.p));
       tmpinside = const_cast<EInside*>(&(fLastInside.inside));
       tmpp->set(p.x(), p.y(), p.z());
    }
    
    EInside  outerhypearea = ((G4TwistTubsHypeSide *)fOuterHype)->Inside(p);
    G4double innerhyperho  = ((G4TwistTubsHypeSide *)fInnerHype)->GetRhoAtPZ(p);
    G4double distanceToOut = p.getRho() - innerhyperho; // +ve: inside
 
    if ((outerhypearea == kOutside) || (distanceToOut < -halftol))
    {
       *tmpinside = kOutside;
    }
    else if (outerhypearea == kSurface)
    {
       *tmpinside = kSurface;
    }
    else
    {
       if (distanceToOut <= halftol)
       {
          *tmpinside = kSurface;
       }
       else
       {
          *tmpinside = kInside;
       }
    }
 
    return fLastInside.inside;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator=()

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

Definition at line 270 of file G4TwistedTubs.cc.

 {
    // Check assignment to self
    //
    if (this == &rhs)  { return *this; }
 
    // Copy base class data
    //
    G4VSolid::operator=(rhs);
 
    // Copy data
    //
    fPhiTwist= rhs.fPhiTwist;
    fInnerRadius= rhs.fInnerRadius; fOuterRadius= rhs.fOuterRadius;
    fDPhi= rhs.fDPhi; fZHalfLength= rhs.fZHalfLength;
    fInnerStereo= rhs.fInnerStereo; fOuterStereo= rhs.fOuterStereo;
    fTanInnerStereo= rhs.fTanInnerStereo; fTanOuterStereo= rhs.fTanOuterStereo;
    fKappa= rhs.fKappa; fInnerRadius2= rhs.fInnerRadius2; 
    fOuterRadius2= rhs.fOuterRadius2; fTanInnerStereo2= rhs.fTanInnerStereo2;
    fTanOuterStereo2= rhs.fTanOuterStereo2;
    fLowerEndcap= fUpperEndcap= fLatterTwisted= fFormerTwisted= 0;
    fInnerHype= fOuterHype= 0;
    fCubicVolume= rhs.fCubicVolume; fSurfaceArea= rhs.fSurfaceArea;
    fLastInside= rhs.fLastInside; fLastNormal= rhs.fLastNormal;
    fLastDistanceToIn= rhs.fLastDistanceToIn;
    fLastDistanceToOut= rhs.fLastDistanceToOut;
    fLastDistanceToInWithV= rhs.fLastDistanceToInWithV;
    fLastDistanceToOutWithV= rhs.fLastDistanceToOutWithV;
  
    for (size_t i=0; i<2; ++i)
    {
      fEndZ[i] = rhs.fEndZ[i];
      fEndInnerRadius[i] = rhs.fEndInnerRadius[i];
      fEndOuterRadius[i] = rhs.fEndOuterRadius[i];
      fEndPhi[i] = rhs.fEndPhi[i];
      fEndZ2[i] = rhs.fEndZ2[i];
    }
  
    CreateSurfaces();
    fRebuildPolyhedron = false;
    delete fpPolyhedron; fpPolyhedron = 0;
 
    return *this;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetFields()

void G4TwistedTubs::SetFields	(	G4double	phitwist,
		G4double	innerrad,
		G4double	outerrad,
		G4double	negativeEndz,
		G4double	positiveEndz
	)

inlineprivate

Definition at line 359 of file G4TwistedTubs.hh.

 {
    fCubicVolume  = 0.;
    fPhiTwist     = phitwist;
    fEndZ[0]      = negativeEndz;
    fEndZ[1]      = positiveEndz;
    fEndZ2[0]     = fEndZ[0] * fEndZ[0];
    fEndZ2[1]     = fEndZ[1] * fEndZ[1];
    fInnerRadius  = innerrad;
    fOuterRadius  = outerrad;
    fInnerRadius2 = fInnerRadius * fInnerRadius;
    fOuterRadius2 = fOuterRadius * fOuterRadius;
    
    if (std::fabs(fEndZ[0]) >= std::fabs(fEndZ[1])) {
       fZHalfLength = std::fabs(fEndZ[0]);
    } else {
       fZHalfLength = std::fabs(fEndZ[1]);
    }
 
    G4double parity         = (fPhiTwist > 0 ? 1 : -1); 
    G4double tanHalfTwist   = std::tan(0.5 * fPhiTwist);
    G4double innerNumerator = std::fabs(fInnerRadius * tanHalfTwist) * parity;
    G4double outerNumerator = std::fabs(fOuterRadius * tanHalfTwist) * parity;
 
    fTanInnerStereo    = innerNumerator / fZHalfLength; 
    fTanOuterStereo    = outerNumerator / fZHalfLength; 
    fTanInnerStereo2   = fTanInnerStereo * fTanInnerStereo;
    fTanOuterStereo2   = fTanOuterStereo * fTanOuterStereo;
    fInnerStereo       = std::atan2(innerNumerator,  fZHalfLength); 
    fOuterStereo       = std::atan2(outerNumerator,  fZHalfLength); 
    fEndInnerRadius[0] = std::sqrt(fInnerRadius2 + fEndZ2[0] * fTanInnerStereo2);
    fEndInnerRadius[1] = std::sqrt(fInnerRadius2 + fEndZ2[1] * fTanInnerStereo2);
    fEndOuterRadius[0] = std::sqrt(fOuterRadius2 + fEndZ2[0] * fTanOuterStereo2);
    fEndOuterRadius[1] = std::sqrt(fOuterRadius2 + fEndZ2[1] * fTanOuterStereo2);
 
    fKappa          = tanHalfTwist / fZHalfLength;
    fEndPhi[0]      = std::atan2(fEndZ[0] * tanHalfTwist, fZHalfLength);
    fEndPhi[1]      = std::atan2(fEndZ[1] * tanHalfTwist, fZHalfLength);
 
 #ifdef G4TWISTDEBUG
    G4cout << "/********* G4TwistedTubs::SetFields() Field Parameters ***************** " << G4endl;
    G4cout << "/*   fPhiTwist                  : " << fPhiTwist << G4endl;
    G4cout << "/*   fEndZ(0, 1)                : " << fEndZ[0] << " , " << fEndZ[1] << G4endl; 
    G4cout << "/*   fEndPhi(0, 1)              : " << fEndPhi[0] << " , " << fEndPhi[1] << G4endl; 
    G4cout << "/*   fInnerRadius, fOuterRadius : " << fInnerRadius << " , " << fOuterRadius << G4endl; 
    G4cout << "/*   fEndInnerRadius(0, 1)      : " << fEndInnerRadius[0] << " , " 
           << fEndInnerRadius[1] << G4endl; 
    G4cout << "/*   fEndOuterRadius(0, 1)      : " << fEndOuterRadius[0] << " , " 
           << fEndOuterRadius[1] << G4endl; 
    G4cout << "/*   fInnerStereo, fOuterStereo : " << fInnerStereo << " , " << fOuterStereo << G4endl; 
    G4cout << "/*   tanHalfTwist, fKappa       : " << tanHalfTwist << " , " << fKappa << G4endl; 
    G4cout << "/*********************************************************************** " << G4endl;
 #endif
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ StreamInfo()

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

virtual

Implements G4VSolid.

Definition at line 1044 of file G4TwistedTubs.cc.

 {
   //
   // Stream object contents to an output stream
   //
   G4int oldprc = os.precision(16);
   os << "-----------------------------------------------------------\n"
      << "    *** Dump for solid - " << GetName() << " ***\n"
      << "    ===================================================\n"
      << " Solid type: G4TwistedTubs\n"
      << " Parameters: \n"
      << "    -ve end Z              : " << fEndZ[0]/mm << " mm \n"
      << "    +ve end Z              : " << fEndZ[1]/mm << " mm \n"
      << "    inner end radius(-ve z): " << fEndInnerRadius[0]/mm << " mm \n"
      << "    inner end radius(+ve z): " << fEndInnerRadius[1]/mm << " mm \n"
      << "    outer end radius(-ve z): " << fEndOuterRadius[0]/mm << " mm \n"
      << "    outer end radius(+ve z): " << fEndOuterRadius[1]/mm << " mm \n"
      << "    inner radius (z=0)     : " << fInnerRadius/mm << " mm \n"
      << "    outer radius (z=0)     : " << fOuterRadius/mm << " mm \n"
      << "    twisted angle          : " << fPhiTwist/degree << " degrees \n"
      << "    inner stereo angle     : " << fInnerStereo/degree << " degrees \n"
      << "    outer stereo angle     : " << fOuterStereo/degree << " degrees \n"
      << "    phi-width of a piece   : " << fDPhi/degree << " degrees \n"
      << "-----------------------------------------------------------\n";
   os.precision(oldprc);
 
   return os;
 }

Here is the call graph for this function:

◆ SurfaceNormal()

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

virtual

Implements G4VSolid.

Definition at line 624 of file G4TwistedTubs.cc.

 {
    //
    // return the normal unit vector to the Hyperbolical Surface at a point 
    // p on (or nearly on) the surface
    //
    // Which of the three or four surfaces are we closest to?
    //
 
    if (fLastNormal.p == p)
    {
       return fLastNormal.vec;
    }    
    G4ThreeVector *tmpp          =
      const_cast<G4ThreeVector*>(&(fLastNormal.p));
    G4ThreeVector *tmpnormal     =
      const_cast<G4ThreeVector*>(&(fLastNormal.vec));
    G4VTwistSurface **tmpsurface =
      const_cast<G4VTwistSurface**>(fLastNormal.surface);
    tmpp->set(p.x(), p.y(), p.z());
 
    G4double      distance = kInfinity;
 
    G4VTwistSurface *surfaces[6];
    surfaces[0] = fLatterTwisted;
    surfaces[1] = fFormerTwisted;
    surfaces[2] = fInnerHype;
    surfaces[3] = fOuterHype;
    surfaces[4] = fLowerEndcap;
    surfaces[5] = fUpperEndcap;
 
    G4ThreeVector xx;
    G4ThreeVector bestxx;
    G4int i;
    G4int besti = -1;
    for (i=0; i< 6; i++)
    {
       G4double tmpdistance = surfaces[i]->DistanceTo(p, xx);
       if (tmpdistance < distance)
       {
          distance = tmpdistance;
          bestxx = xx;
          besti = i; 
       }
    }
 
    tmpsurface[0] = surfaces[besti];
    *tmpnormal = tmpsurface[0]->GetNormal(bestxx, true);
    
    return fLastNormal.vec;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ fCubicVolume

G4double G4TwistedTubs::fCubicVolume

private

Definition at line 239 of file G4TwistedTubs.hh.

◆ fDPhi

G4double G4TwistedTubs::fDPhi

private

Definition at line 214 of file G4TwistedTubs.hh.

◆ fEndInnerRadius

G4double G4TwistedTubs::fEndInnerRadius[2]

private

Definition at line 222 of file G4TwistedTubs.hh.

◆ fEndOuterRadius

G4double G4TwistedTubs::fEndOuterRadius[2]

private

Definition at line 223 of file G4TwistedTubs.hh.

◆ fEndPhi

G4double G4TwistedTubs::fEndPhi[2]

private

Definition at line 224 of file G4TwistedTubs.hh.

◆ fEndZ

G4double G4TwistedTubs::fEndZ[2]

private

Definition at line 213 of file G4TwistedTubs.hh.

◆ fEndZ2

G4double G4TwistedTubs::fEndZ2[2]

private

Definition at line 230 of file G4TwistedTubs.hh.

◆ fFormerTwisted

G4VTwistSurface* G4TwistedTubs::fFormerTwisted

private

Definition at line 235 of file G4TwistedTubs.hh.

◆ fInnerHype

G4VTwistSurface* G4TwistedTubs::fInnerHype

private

Definition at line 236 of file G4TwistedTubs.hh.

◆ fInnerRadius

G4double G4TwistedTubs::fInnerRadius

private

Definition at line 211 of file G4TwistedTubs.hh.

◆ fInnerRadius2

G4double G4TwistedTubs::fInnerRadius2

private

Definition at line 226 of file G4TwistedTubs.hh.

◆ fInnerStereo

G4double G4TwistedTubs::fInnerStereo

private

Definition at line 217 of file G4TwistedTubs.hh.

◆ fKappa

G4double G4TwistedTubs::fKappa

private

Definition at line 221 of file G4TwistedTubs.hh.

◆ fLastDistanceToIn

LastValue G4TwistedTubs::fLastDistanceToIn

private

Definition at line 345 of file G4TwistedTubs.hh.

◆ fLastDistanceToInWithV

LastValueWithDoubleVector G4TwistedTubs::fLastDistanceToInWithV

private

Definition at line 347 of file G4TwistedTubs.hh.

◆ fLastDistanceToOut

LastValue G4TwistedTubs::fLastDistanceToOut

private

Definition at line 346 of file G4TwistedTubs.hh.

◆ fLastDistanceToOutWithV

LastValueWithDoubleVector G4TwistedTubs::fLastDistanceToOutWithV

private

Definition at line 348 of file G4TwistedTubs.hh.

◆ fLastInside

LastState G4TwistedTubs::fLastInside

private

Definition at line 343 of file G4TwistedTubs.hh.

◆ fLastNormal

LastVector G4TwistedTubs::fLastNormal

private

Definition at line 344 of file G4TwistedTubs.hh.

◆ fLatterTwisted

G4VTwistSurface* G4TwistedTubs::fLatterTwisted

private

Definition at line 234 of file G4TwistedTubs.hh.

◆ fLowerEndcap

G4VTwistSurface* G4TwistedTubs::fLowerEndcap

private

Definition at line 232 of file G4TwistedTubs.hh.

◆ fOuterHype

G4VTwistSurface* G4TwistedTubs::fOuterHype

private

Definition at line 237 of file G4TwistedTubs.hh.

◆ fOuterRadius

G4double G4TwistedTubs::fOuterRadius

private

Definition at line 212 of file G4TwistedTubs.hh.

◆ fOuterRadius2

G4double G4TwistedTubs::fOuterRadius2

private

Definition at line 227 of file G4TwistedTubs.hh.

◆ fOuterStereo

G4double G4TwistedTubs::fOuterStereo

private

Definition at line 218 of file G4TwistedTubs.hh.

◆ fPhiTwist

G4double G4TwistedTubs::fPhiTwist

private

Definition at line 210 of file G4TwistedTubs.hh.

◆ fpPolyhedron

G4Polyhedron* G4TwistedTubs::fpPolyhedron

mutableprivate

Definition at line 243 of file G4TwistedTubs.hh.

◆ fRebuildPolyhedron

G4bool G4TwistedTubs::fRebuildPolyhedron

mutableprivate

Definition at line 242 of file G4TwistedTubs.hh.

◆ fSurfaceArea

G4double G4TwistedTubs::fSurfaceArea

private

Definition at line 240 of file G4TwistedTubs.hh.

◆ fTanInnerStereo

G4double G4TwistedTubs::fTanInnerStereo

private

Definition at line 219 of file G4TwistedTubs.hh.

◆ fTanInnerStereo2

G4double G4TwistedTubs::fTanInnerStereo2

private

Definition at line 228 of file G4TwistedTubs.hh.

◆ fTanOuterStereo

G4double G4TwistedTubs::fTanOuterStereo

private

Definition at line 220 of file G4TwistedTubs.hh.

◆ fTanOuterStereo2

G4double G4TwistedTubs::fTanOuterStereo2

private

Definition at line 229 of file G4TwistedTubs.hh.

◆ fUpperEndcap

G4VTwistSurface* G4TwistedTubs::fUpperEndcap

private

Definition at line 233 of file G4TwistedTubs.hh.

◆ fZHalfLength

G4double G4TwistedTubs::fZHalfLength

private

Definition at line 215 of file G4TwistedTubs.hh.

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

Classes

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4TwistedTubs() [1/6]

◆ G4TwistedTubs() [2/6]

◆ G4TwistedTubs() [3/6]

◆ G4TwistedTubs() [4/6]

◆ ~G4TwistedTubs()

◆ G4TwistedTubs() [5/6]

◆ G4TwistedTubs() [6/6]

Member Function Documentation

◆ AddPolyToExtent()

◆ CalculateExtent()

◆ Clone()

◆ ComputeDimensions()

◆ CreatePolyhedron()

◆ CreateSurfaces()

◆ DescribeYourselfTo()

◆ DistanceToIn() [1/2]

◆ DistanceToIn() [2/2]

◆ DistanceToOut() [1/2]

◆ DistanceToOut() [2/2]

◆ GetCubicVolume()

◆ GetDPhi()

◆ GetEndInnerRadius() [1/2]

◆ GetEndInnerRadius() [2/2]

◆ GetEndOuterRadius() [1/2]

◆ GetEndOuterRadius() [2/2]

◆ GetEndPhi()

◆ GetEndZ()

◆ GetEntityType()

◆ GetExtent()

◆ GetInnerRadius()

◆ GetInnerStereo()

◆ GetKappa()

◆ GetOuterRadius()

◆ GetOuterStereo()

◆ GetPhiTwist()

◆ GetPointOnSurface()

◆ GetPolyhedron()

◆ GetSurfaceArea()

◆ GetTanInnerStereo()

◆ GetTanInnerStereo2()

◆ GetTanOuterStereo()

◆ GetTanOuterStereo2()

◆ GetZHalfLength()

◆ Inside()

◆ operator=()

◆ SetFields()

◆ StreamInfo()

◆ SurfaceNormal()

Member Data Documentation

◆ fCubicVolume

◆ fDPhi

◆ fEndInnerRadius

◆ fEndOuterRadius

◆ fEndPhi

◆ fEndZ

◆ fEndZ2

◆ fFormerTwisted

◆ fInnerHype

◆ fInnerRadius

◆ fInnerRadius2

◆ fInnerStereo

◆ fKappa

◆ fLastDistanceToIn

◆ fLastDistanceToInWithV

◆ fLastDistanceToOut

◆ fLastDistanceToOutWithV

◆ fLastInside

◆ fLastNormal

◆ fLatterTwisted

◆ fLowerEndcap

◆ fOuterHype

◆ fOuterRadius