G4TwistedTubs Class Reference

G4TwistedTubs is a sector of a twisted hollow cylinder. A twisted cylinder which is placed along with Z axis and is separated into phi-segments should become a hyperboloid, and its each segmented piece should be tilted with a stereo angle. More...

#include <G4TwistedTubs.hh>

Inheritance diagram for G4TwistedTubs:

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)
	~G4TwistedTubs () override
void	ComputeDimensions (G4VPVParameterisation *, const G4int, const G4VPhysicalVolume *) override
void	BoundingLimits (G4ThreeVector &pMin, G4ThreeVector &pMax) const override
G4bool	CalculateExtent (const EAxis pAxis, const G4VoxelLimits &pVoxelLimit, const G4AffineTransform &pTransform, G4double &pMin, G4double &pMax) const override
G4double	DistanceToIn (const G4ThreeVector &p, const G4ThreeVector &v) const override
G4double	DistanceToIn (const G4ThreeVector &p) const override
G4double	DistanceToOut (const G4ThreeVector &p, const G4ThreeVector &v, const G4bool calcnorm=false, G4bool *validnorm=nullptr, G4ThreeVector *n=nullptr) const override
G4double	DistanceToOut (const G4ThreeVector &p) const override
EInside	Inside (const G4ThreeVector &p) const override
G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const override
void	DescribeYourselfTo (G4VGraphicsScene &scene) const override
G4Polyhedron *	CreatePolyhedron () const override
G4Polyhedron *	GetPolyhedron () const override
G4VisExtent	GetExtent () const override
std::ostream &	StreamInfo (std::ostream &os) const override
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
G4GeometryType	GetEntityType () const override
G4VSolid *	Clone () const override
G4double	GetCubicVolume () override
G4double	GetSurfaceArea () override
G4ThreeVector	GetPointOnSurface () const override
	G4TwistedTubs (__void__ &)
	G4TwistedTubs (const G4TwistedTubs &rhs)
G4TwistedTubs &	operator= (const G4TwistedTubs &rhs)
Public Member Functions inherited from G4VSolid
	G4VSolid (const G4String &name)
virtual	~G4VSolid ()
	G4VSolid (const G4VSolid &rhs)
G4VSolid &	operator= (const G4VSolid &rhs)
G4bool	operator== (const G4VSolid &s) const
G4String	GetName () const
void	SetName (const G4String &name)
G4double	GetTolerance () const
virtual G4int	GetNumOfConstituents () const
virtual G4bool	IsFaceted () const
void	DumpInfo () const
virtual const G4VSolid *	GetConstituentSolid (G4int no) const
virtual G4VSolid *	GetConstituentSolid (G4int no)
virtual const G4DisplacedSolid *	GetDisplacedSolidPtr () const
virtual G4DisplacedSolid *	GetDisplacedSolidPtr ()
	G4VSolid (__void__ &)
G4double	EstimateCubicVolume (G4int nStat, G4double epsilon) const
G4double	EstimateSurfaceArea (G4int nStat, G4double epsilon) const

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

G4TwistedTubs is a sector of a twisted hollow cylinder. A twisted cylinder which is placed along with Z axis and is separated into phi-segments should become a hyperboloid, and its each segmented piece should be tilted with a stereo angle.

Definition at line 62 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 )

Constructs a twisted tube, given radii and twist angle.

Parameters

[in]	pName	The solid name.
[in]	twistedangle	The twisted angle.
[in]	endinnerrad	Inner radius at endcap.
[in]	endouterrad	Outer radius at endcap.
[in]	halfzlen	Half Z length.
[in]	dphi	Phi angle of a segment.

Definition at line 62 of file G4TwistedTubs.cc.

   : G4VSolid(pname), fDPhi(dphi), 
     fLowerEndcap(nullptr), fUpperEndcap(nullptr), fLatterTwisted(nullptr),
     fFormerTwisted(nullptr), fInnerHype(nullptr), fOuterHype(nullptr)
{
   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();
}

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

G4TwistedTubs() [2/6]

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

Constructs a twisted tube, given radii, twist angle and number of segments.

Parameters

[in]	pName	The solid name.
[in]	twistedangle	The twisted angle.
[in]	endinnerrad	Inner radius at endcap.
[in]	endouterrad	Outer radius at endcap.
[in]	halfzlen	Half Z length.
[in]	nseg	Number of segments in Phi.
[in]	totphi	Total angle of all segments.

Definition at line 93 of file G4TwistedTubs.cc.

   : G4VSolid(pname),
     fLowerEndcap(nullptr), fUpperEndcap(nullptr), fLatterTwisted(nullptr),
     fFormerTwisted(nullptr), fInnerHype(nullptr), fOuterHype(nullptr)
{
 
   if (nseg == 0)
   {
      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();
}

G4TwistedTubs() [3/6]

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

Constructs a twisted tube, given radii, twist angle and EndZ values.

Parameters

[in]	pName	The solid name.
[in]	twistedangle	The twisted angle.
[in]	innerrad	Inner radius at z=0.
[in]	outerrad	Outer radius at z=0.
[in]	negativeEndz	-ve Z endplate.
[in]	positiveEndz	+ve Z endplate.
[in]	dphi	Phi angle of a segment.

Definition at line 135 of file G4TwistedTubs.cc.

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

G4TwistedTubs() [4/6]

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

Constructs a twisted tube, given radii, twist angle, EndZ values and number of segments.

Parameters

[in]	pName	The solid name.
[in]	twistedangle	The twisted angle.
[in]	innerrad	Inner radius at z=0.
[in]	outerrad	Outer radius at z=0.
[in]	negativeEndz	-ve Z endplate.
[in]	positiveEndz	+ve Z endplate.
[in]	nseg	Number of segments in Phi.
[in]	totphi	Total angle of all segments.

Definition at line 156 of file G4TwistedTubs.cc.

   : G4VSolid(pname),
     fLowerEndcap(nullptr), fUpperEndcap(nullptr), fLatterTwisted(nullptr),
     fFormerTwisted(nullptr), fInnerHype(nullptr), fOuterHype(nullptr)
{
   if (nseg == 0)
   {
      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();
}

~G4TwistedTubs()

G4TwistedTubs::~G4TwistedTubs ( )

override

Destructor.

Definition at line 201 of file G4TwistedTubs.cc.

{
   delete fLowerEndcap;   
   delete fUpperEndcap;   
   delete fLatterTwisted; 
   delete fFormerTwisted; 
   delete fInnerHype;     
   delete fOuterHype;     
   delete fpPolyhedron; fpPolyhedron = nullptr;
}

G4TwistedTubs() [5/6]

G4TwistedTubs::G4TwistedTubs

(

__void__ &

a

)

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

Definition at line 190 of file G4TwistedTubs.cc.

  : G4VSolid(a),
    fLowerEndcap(nullptr), fUpperEndcap(nullptr),
    fLatterTwisted(nullptr), fFormerTwisted(nullptr),
    fInnerHype(nullptr), fOuterHype(nullptr)
{
}

G4TwistedTubs() [6/6]

G4TwistedTubs::G4TwistedTubs

(

const G4TwistedTubs &

rhs

)

Copy constructor and assignment operator.

Definition at line 215 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(nullptr), fUpperEndcap(nullptr), fLatterTwisted(nullptr), fFormerTwisted(nullptr),
    fInnerHype(nullptr), fOuterHype(nullptr),
    fCubicVolume(rhs.fCubicVolume), fSurfaceArea(rhs.fSurfaceArea)
{
  for (auto 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();
}

Member Function Documentation

BoundingLimits()

void G4TwistedTubs::BoundingLimits ( G4ThreeVector & pMin, G4ThreeVector & pMax ) const

overridevirtual

Computes the bounding limits of the solid.

Parameters

[out]	pMin	The minimum bounding limit point.
[out]	pMax	The maximum bounding limit point.

Reimplemented from G4VSolid.

Definition at line 298 of file G4TwistedTubs.cc.

{
  // Find bounding tube
  G4double rmin = GetInnerRadius();
  G4double rmax = GetEndOuterRadius();
 
  G4double zmin = std::min(GetEndZ(0), GetEndZ(1));
  G4double zmax = std::max(GetEndZ(0), GetEndZ(1));
 
  G4double dphi = 0.5*GetDPhi();
  G4double sphi = std::min(GetEndPhi(0), GetEndPhi(1)) - dphi;
  G4double ephi = std::max(GetEndPhi(0), GetEndPhi(1)) + dphi;
  G4double totalphi = ephi - sphi;
 
  // Find bounding box
  if (dphi <= 0 || totalphi >= CLHEP::twopi)
  {
    pMin.set(-rmax,-rmax, zmin);
    pMax.set( rmax, rmax, zmax);
  }
  else
  {
    G4TwoVector vmin,vmax;
    G4GeomTools::DiskExtent(rmin, rmax, sphi, totalphi, vmin, vmax);
    pMin.set(vmin.x(), vmin.y(), zmin);
    pMax.set(vmax.x(), vmax.y(), zmax);
  }
 
  // Check correctness of the bounding box
  //
  if (pMin.x() >= pMax.x() || pMin.y() >= pMax.y() || pMin.z() >= pMax.z())
  {
    std::ostringstream message;
    message << "Bad bounding box (min >= max) for solid: "
            << GetName() << " !"
            << "\npMin = " << pMin
            << "\npMax = " << pMax;
    G4Exception("G4TwistedTubs::BoundingLimits()", "GeomMgt0001",
                JustWarning, message);
    DumpInfo();
  }
}

Referenced by CalculateExtent(), and GetExtent().

CalculateExtent()

G4bool G4TwistedTubs::CalculateExtent ( const EAxis pAxis, const G4VoxelLimits & pVoxelLimit, const G4AffineTransform & pTransform, G4double & pMin, G4double & pMax ) const

overridevirtual

Calculates the minimum and maximum extent of the solid, when under the specified transform, and within the specified limits.

Parameters

[in]	pAxis	The axis along which compute the extent.
[in]	pVoxelLimit	The limiting space dictated by voxels.
[in]	pTransform	The internal transformation applied to the solid.
[out]	pMin	The minimum extent value.
[out]	pMax	The maximum extent value.

Returns

True if the solid is intersected by the extent region.

Implements G4VSolid.

Definition at line 346 of file G4TwistedTubs.cc.

{
  G4ThreeVector bmin, bmax;
 
  // Get bounding box
  BoundingLimits(bmin,bmax);
 
  // Find extent
  G4BoundingEnvelope bbox(bmin,bmax);
  return bbox.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
}

Clone()

G4VSolid * G4TwistedTubs::Clone ( ) const

overridevirtual

Makes a clone of the object for use in multi-treading.

Returns

A pointer to the new cloned allocated solid.

Reimplemented from G4VSolid.

Definition at line 899 of file G4TwistedTubs.cc.

{
  return new G4TwistedTubs(*this);
}

ComputeDimensions()

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

overridevirtual

Thows a fatal exception. Parameterisations are not allowed on this shape.

Reimplemented from G4VSolid.

Definition at line 286 of file G4TwistedTubs.cc.

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

CreatePolyhedron()

G4Polyhedron * G4TwistedTubs::CreatePolyhedron ( ) const

overridevirtual

Creates a Polyhedron used for Visualisation. It is the caller's responsibility to delete it. A null pointer means "not created".

Reimplemented from G4VSolid.

Definition at line 774 of file G4TwistedTubs.cc.

{
  // number of meshes
  //
  G4double absPhiTwist = std::abs(fPhiTwist);
  G4double dA = std::max(fDPhi,absPhiTwist);
  const G4int k =
    G4int(G4Polyhedron::GetNumberOfRotationSteps() * dA / twopi) + 2;
  const G4int n =
    G4int(G4Polyhedron::GetNumberOfRotationSteps() * absPhiTwist / 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) ;
 
  auto ph = new G4Polyhedron;
  typedef G4double G4double3[3];
  typedef G4int G4int4[4];
  auto xyz = new G4double3[nnodes];  // number of nodes 
  auto 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;
}

Referenced by GetPolyhedron().

DescribeYourselfTo()

void G4TwistedTubs::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

overridevirtual

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

Implements G4VSolid.

Definition at line 752 of file G4TwistedTubs.cc.

{
  scene.AddSolid (*this);
}

DistanceToIn() [1/2]

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

overridevirtual

Calculates the distance to the nearest surface of a shape from an outside point. The distance can be an underestimate.

Parameters

[in]

p

The point at offset p.

Returns

The safety distance to enter the shape.

Implements G4VSolid.

Definition at line 512 of file G4TwistedTubs.cc.

{
   // DistanceToIn(p):
   // Calculate distance to surface of shape from `outside',
   // allowing for tolerance
 
   //
   // Calculate DistanceToIn(p) 
   //
   
   EInside currentside = Inside(p);
 
   switch (currentside)
   {
      case (kInside) :
      {}
      case (kSurface) :
      {
         return 0;
      }
      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;
 
         G4ThreeVector xx;
         G4ThreeVector bestxx;
         for (const auto & surface : surfaces)
         {
            G4double tmpdistance = surface->DistanceTo(p, xx);
            if (tmpdistance < distance)
            {
               distance = tmpdistance;
               bestxx = xx;
            }
         }
         return distance;
      }
      default :
      {
         G4Exception("G4TwistedTubs::DistanceToIn(p)", "GeomSolids0003",
                     FatalException, "Unknown point location!");
      }
   } // switch end
 
   return kInfinity;
}

DistanceToIn() [2/2]

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

overridevirtual

Concrete implementations of the expected query interfaces for solids, as defined in the base class G4VSolid.

Implements G4VSolid.

Definition at line 445 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.
 
   //
   // 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)
       {
         return 0;
       } 
     }
   }
      
   // 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;
   for (const auto & surface : surfaces)
   {
      G4double tmpdistance = surface->DistanceToIn(p, v, xx);
      if (tmpdistance < distance)
      {
         distance = tmpdistance;
         bestxx = xx;
      }
   }
   return distance;
}

DistanceToOut() [1/2]

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

overridevirtual

Calculates the distance to the nearest surface of a shape from an inside point 'p'. The distance can be an underestimate.

Parameters

[in]

p

The point at offset p.

Returns

The safety distance to exit the shape.

Implements G4VSolid.

Definition at line 658 of file G4TwistedTubs.cc.

{
   // DistanceToOut(p):
   // Calculate distance to surface of shape from `inside', 
   // allowing for tolerance
 
   //
   // Calculate DistanceToOut(p)
   //
   
   EInside currentside = Inside(p);
 
   switch (currentside)
   {
      case (kOutside) :
      {
      }
      case (kSurface) :
      {
         return 0;
      }
      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;
 
         G4ThreeVector xx;
         G4ThreeVector bestxx;
         for (const auto & surface : surfaces)
         {
            G4double tmpdistance = surface->DistanceTo(p, xx);
            if (tmpdistance < distance)
            {
               distance = tmpdistance;
               bestxx = xx;
            }
         }
         return distance;
      }
      default :
      {
         G4Exception("G4TwistedTubs::DistanceToOut(p)", "GeomSolids0003",
                     FatalException, "Unknown point location!");
      }
   } // switch end
 
   return 0.;
}

DistanceToOut() [2/2]

G4double G4TwistedTubs::DistanceToOut ( const G4ThreeVector & p, const G4ThreeVector & v, const G4bool calcNorm = false, G4bool * validNorm = nullptr, G4ThreeVector * n = nullptr ) const

overridevirtual

Returns the distance along the normalised vector 'v' to the shape, from a point at an offset 'p' inside or on the surface of the shape. Intersections with surfaces, when the point is less than Tolerance/2 from a surface must be ignored.

Parameters

[in]	p	The point at offset p.
[in]	v	The normalised direction vector.
[in]	calcNorm	Flag to indicate if to calculate the normal or not.
[out]	validNorm	Flag set to true if the solid lies entirely behind or on the exiting surface. It is set false if the solid does not lie entirely behind or on the exiting surface. 'calcNorm' must be true, otherwise it is unused.
[out]	n	The exiting outwards normal vector (undefined Magnitude). 'calcNorm' must be true, otherwise it is unused.

Returns

The distance to exit the shape.

Implements G4VSolid.

Definition at line 572 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.
 
   //
   // 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);
       if (normal*v > 0)
       {
         if (calcNorm)
         {
           *norm = normal;
           *validNorm = true;
         }
         return 0;
       }
     }
   }
      
   // 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 besti = -1;
   G4ThreeVector xx;
   G4ThreeVector bestxx;
   for (auto 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();
      }
   }
 
   return distance;
}

GetCubicVolume()

G4double G4TwistedTubs::GetCubicVolume ( )

overridevirtual

Returning an estimation of the solid volume (capacity) and surface area, in internal units. Caches the computed value once computed the first time.

Reimplemented from G4VSolid.

Definition at line 955 of file G4TwistedTubs.cc.

{
  if (fCubicVolume == 0)
  {
    G4AutoLock l(&twtubsMutex);
    G4double DPhi  = GetDPhi();
    G4double Z0    = GetEndZ(0);
    G4double Z1    = GetEndZ(1);
    G4double Ain   = GetInnerRadius();
    G4double Aout  = GetOuterRadius();
    G4double R0in  = GetEndInnerRadius(0);
    G4double R1in  = GetEndInnerRadius(1);
    G4double R0out = GetEndOuterRadius(0);
    G4double R1out = GetEndOuterRadius(1);
 
    // V_hyperboloid = pi*h*(2*a*a + R*R)/3
    fCubicVolume = (2.*(Z1 - Z0)*(Aout + Ain)*(Aout - Ain)
                    + Z1*(R1out + R1in)*(R1out - R1in)
                    - Z0*(R0out + R0in)*(R0out - R0in))*DPhi/6.;
    l.unlock();
  }
  return fCubicVolume;
}

GetDPhi()

G4double G4TwistedTubs::GetDPhi ( ) const

inline

Accessors.

Definition at line 206 of file G4TwistedTubs.hh.

{ return fDPhi       ; }

Referenced by BoundingLimits(), GetCubicVolume(), G4tgbGeometryDumper::GetSolidParams(), GetSurfaceArea(), and G4GDMLWriteSolids::TwistedtubsWrite().

GetEndInnerRadius() [1/2]

G4double G4TwistedTubs::GetEndInnerRadius ( ) const

inline

Definition at line 226 of file G4TwistedTubs.hh.

                    { return (fEndInnerRadius[0] > fEndInnerRadius[1] ?
                      fEndInnerRadius[0] : fEndInnerRadius[1]); }

Referenced by GetCubicVolume(), GetPointOnSurface(), and GetSurfaceArea().

GetEndInnerRadius() [2/2]

G4double G4TwistedTubs::GetEndInnerRadius ( G4int i ) const

inline

Definition at line 222 of file G4TwistedTubs.hh.

                    { return fEndInnerRadius[i]; }

GetEndOuterRadius() [1/2]

G4double G4TwistedTubs::GetEndOuterRadius ( ) const

inline

Definition at line 229 of file G4TwistedTubs.hh.

                    { return (fEndOuterRadius[0] > fEndOuterRadius[1] ?
                      fEndOuterRadius[0] : fEndOuterRadius[1]); }

Referenced by BoundingLimits(), GetCubicVolume(), GetPointOnSurface(), and GetSurfaceArea().

GetEndOuterRadius() [2/2]

G4double G4TwistedTubs::GetEndOuterRadius ( G4int i ) const

inline

Definition at line 224 of file G4TwistedTubs.hh.

                    { return fEndOuterRadius[i]; }

GetEndPhi()

G4double G4TwistedTubs::GetEndPhi ( G4int i ) const

inline

Definition at line 221 of file G4TwistedTubs.hh.

{ return fEndPhi[i]; }

Referenced by BoundingLimits().

GetEndZ()

G4double G4TwistedTubs::GetEndZ ( G4int i ) const

inline

Definition at line 220 of file G4TwistedTubs.hh.

{ return fEndZ[i]  ; }

Referenced by BoundingLimits(), GetCubicVolume(), GetSurfaceArea(), and G4GDMLWriteSolids::TwistedtubsWrite().

GetEntityType()

G4GeometryType G4TwistedTubs::GetEntityType ( ) const

overridevirtual

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

Implements G4VSolid.

Definition at line 891 of file G4TwistedTubs.cc.

{
  return {"G4TwistedTubs"};
}

GetExtent()

G4VisExtent G4TwistedTubs::GetExtent ( ) const

overridevirtual

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

Reimplemented from G4VSolid.

Definition at line 760 of file G4TwistedTubs.cc.

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

GetInnerRadius()

G4double G4TwistedTubs::GetInnerRadius ( ) const

inline

Definition at line 208 of file G4TwistedTubs.hh.

{ return fInnerRadius; }

Referenced by BoundingLimits(), GetCubicVolume(), G4tgbGeometryDumper::GetSolidParams(), GetSurfaceArea(), and G4GDMLWriteSolids::TwistedtubsWrite().

GetInnerStereo()

G4double G4TwistedTubs::GetInnerStereo ( ) const

inline

Definition at line 210 of file G4TwistedTubs.hh.

{ return fInnerStereo; }

GetKappa()

G4double G4TwistedTubs::GetKappa ( ) const

inline

Definition at line 213 of file G4TwistedTubs.hh.

{ return fKappa      ; }

GetOuterRadius()

G4double G4TwistedTubs::GetOuterRadius ( ) const

inline

Definition at line 209 of file G4TwistedTubs.hh.

{ return fOuterRadius; }

Referenced by GetCubicVolume(), G4tgbGeometryDumper::GetSolidParams(), GetSurfaceArea(), and G4GDMLWriteSolids::TwistedtubsWrite().

GetOuterStereo()

G4double G4TwistedTubs::GetOuterStereo ( ) const

inline

Definition at line 211 of file G4TwistedTubs.hh.

{ return fOuterStereo; }

GetPhiTwist()

G4double G4TwistedTubs::GetPhiTwist ( ) const

inline

Definition at line 207 of file G4TwistedTubs.hh.

{ return fPhiTwist   ; }

Referenced by G4tgbGeometryDumper::GetSolidParams(), and G4GDMLWriteSolids::TwistedtubsWrite().

GetPointOnSurface()

G4ThreeVector G4TwistedTubs::GetPointOnSurface ( ) const

overridevirtual

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

Reimplemented from G4VSolid.

Definition at line 1027 of file G4TwistedTubs.cc.

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

GetPolyhedron()

G4Polyhedron * G4TwistedTubs::GetPolyhedron ( ) const

overridevirtual

Smart access function - creates on request and stores for future access. A null pointer means "not available".

Reimplemented from G4VSolid.

Definition at line 811 of file G4TwistedTubs.cc.

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

GetSurfaceArea()

G4double G4TwistedTubs::GetSurfaceArea ( )

overridevirtual

Returns an estimation of the solid surface area in internal units. This method may be overloaded by derived classes to compute the exact geometrical quantity for solids where this is possible, or anyway to cache the computed value. Note: the computed value is NOT cached.

Reimplemented from G4VSolid.

Definition at line 982 of file G4TwistedTubs.cc.

{
  if (fSurfaceArea == 0)
  {
    G4AutoLock l(&twtubsMutex);
    G4double dphi = GetDPhi();
    G4double Ainn = GetInnerRadius();
    G4double Aout = GetOuterRadius();
    G4double Rinn0 = GetEndInnerRadius(0);
    G4double Rout0 = GetEndOuterRadius(0);
    G4double Rinn1 = GetEndInnerRadius(1);
    G4double Rout1 = GetEndOuterRadius(1);
    G4double z0 = GetEndZ(0);
    G4double z1 = GetEndZ(1);
 
    G4double base0 = 0.5*dphi*(Rout0*Rout0 - Rinn0*Rinn0); // lower base
    G4double inner0 = GetLateralArea(Ainn, Rinn0, z0); // lower inner surface
    G4double outer0 = GetLateralArea(Aout, Rout0, z0); // lower outer surface
    G4double cut0 =                                    // lower phi cut
      GetPhiCutArea(Aout, Rout0, z0) - GetPhiCutArea(Ainn, Rinn0, z0);
 
    G4double base1 = base0;
    G4double inner1 = inner0;
    G4double outer1 = outer0;
    G4double cut1 = cut0;
    if (std::abs(z0) != std::abs(z1))
    {
      base1 = 0.5*dphi*(Rout1*Rout1 - Rinn1*Rinn1); // upper base
      inner1 = GetLateralArea(Ainn, Rinn1, z1); // upper inner surface
      outer1 = GetLateralArea(Aout, Rout1, z1); // upper outer surface
      cut1 =                                    // upper phi cut
      GetPhiCutArea(Aout, Rout1, z1) - GetPhiCutArea(Ainn, Rinn1, z1);
    }
    fSurfaceArea = base0 + base1 +
      ((z0*z1 < 0) ?
      (inner0 + inner1 + outer0 + outer1 + 2.*(cut0 + cut1)) :
      std::abs(inner0 - inner1 + outer0 - outer1 + 2.*(cut0 - cut1)));
    l.unlock();
  }
  return fSurfaceArea;
}

GetTanInnerStereo()

G4double G4TwistedTubs::GetTanInnerStereo ( ) const

inline

Definition at line 215 of file G4TwistedTubs.hh.

{ return fTanInnerStereo  ; }

GetTanInnerStereo2()

G4double G4TwistedTubs::GetTanInnerStereo2 ( ) const

inline

Definition at line 216 of file G4TwistedTubs.hh.

{ return fTanInnerStereo2 ; }

GetTanOuterStereo()

G4double G4TwistedTubs::GetTanOuterStereo ( ) const

inline

Definition at line 217 of file G4TwistedTubs.hh.

{ return fTanOuterStereo  ; }

GetTanOuterStereo2()

G4double G4TwistedTubs::GetTanOuterStereo2 ( ) const

inline

Definition at line 218 of file G4TwistedTubs.hh.

{ return fTanOuterStereo2 ; }

GetZHalfLength()

G4double G4TwistedTubs::GetZHalfLength ( ) const

inline

Definition at line 212 of file G4TwistedTubs.hh.

{ return fZHalfLength; }

Referenced by G4tgbGeometryDumper::GetSolidParams().

Inside()

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

overridevirtual

Returns the characterisation of a point at offset 'p' respect to the shape.

Parameters

[in]

p

The point at offset p.

Returns

kOutside if the point is outside the shapes boundaries plus Tolerance/2; kSurface if the point is less than Tolerance/2 from a surface; kInside otherwise.

Implements G4VSolid.

Definition at line 365 of file G4TwistedTubs.cc.

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

Referenced by DistanceToIn(), DistanceToIn(), DistanceToOut(), and DistanceToOut().

operator=()

G4TwistedTubs & G4TwistedTubs::operator=

(

const G4TwistedTubs &

rhs

)

Definition at line 243 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= nullptr;
   fInnerHype= fOuterHype= nullptr;
   fCubicVolume= rhs.fCubicVolume; fSurfaceArea= rhs.fSurfaceArea;
 
   for (auto 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 = nullptr;
 
   return *this;
}

StreamInfo()

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

overridevirtual

Streams the object contents to an output stream.

Implements G4VSolid.

Definition at line 719 of file G4TwistedTubs.cc.

{
  //
  // Stream object contents to an output stream
  //
  G4long 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;
}

SurfaceNormal()

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

overridevirtual

Returns the outwards pointing unit normal of the shape for the surface closest to the point at offset 'p'.

Parameters

[in]

p

The point at offset p.

Returns

The outwards pointing unit normal.

Implements G4VSolid.

Definition at line 405 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?
   //
 
 
   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 besti = -1;
   for (auto i=0; i<6; ++i)
   {
      G4double tmpdistance = surfaces[i]->DistanceTo(p, xx);
      if (tmpdistance < distance)
      {
         distance = tmpdistance;
         bestxx = xx;
         besti = i; 
      }
   }
 
  return surfaces[besti]->GetNormal(bestxx, true);
}

Referenced by DistanceToIn(), and DistanceToOut().

---

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

• G4TwistedTubs.hh
• G4TwistedTubs.cc