#include <G4VTwistedFaceted.hh>

Inheritance diagram for G4VTwistedFaceted:

Collaboration diagram for G4VTwistedFaceted:

Classes
class	LastState

class	LastValue

class	LastValueWithDoubleVector

class	LastVector

Public Member Functions
	G4VTwistedFaceted (const G4String &pname, G4double PhiTwist, G4double pDz, G4double pTheta, G4double pPhi, G4double pDy1, G4double pDx1, G4double pDx2, G4double pDy2, G4double pDx3, G4double pDx4, G4double pAlph)

virtual	~G4VTwistedFaceted ()

virtual void	ComputeDimensions (G4VPVParameterisation , const G4int, const G4VPhysicalVolume )

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

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

virtual G4double	DistanceToIn (const G4ThreeVector &p) const

virtual G4double	DistanceToOut (const G4ThreeVector &p, const G4ThreeVector &v, const G4bool calcnorm=false, G4bool validnorm=0, G4ThreeVector n=0) const

virtual G4double	DistanceToOut (const G4ThreeVector &p) const

virtual EInside	Inside (const G4ThreeVector &p) const

virtual G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const

G4ThreeVector	GetPointOnSurface () const

G4ThreeVector	GetPointInSolid (G4double z) const

virtual G4double	GetCubicVolume ()

virtual G4double	GetSurfaceArea ()

virtual void	DescribeYourselfTo (G4VGraphicsScene &scene) const

virtual G4Polyhedron *	CreatePolyhedron () const

virtual G4Polyhedron *	GetPolyhedron () const

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

G4double	GetTwistAngle () const

G4double	GetDx1 () const

G4double	GetDx2 () const

G4double	GetDx3 () const

G4double	GetDx4 () const

G4double	GetDy1 () const

G4double	GetDy2 () const

G4double	GetDz () const

G4double	GetPhi () const

G4double	GetTheta () const

G4double	GetAlpha () const

G4double	Xcoef (G4double u, G4double phi, G4double ftg) const

G4double	GetValueA (G4double phi) const

G4double	GetValueB (G4double phi) const

G4double	GetValueD (G4double phi) const

virtual G4VisExtent	GetExtent () const

virtual G4GeometryType	GetEntityType () const

	G4VTwistedFaceted (__void__ &)

	G4VTwistedFaceted (const G4VTwistedFaceted &rhs)

G4VTwistedFaceted &	operator= (const G4VTwistedFaceted &rhs)

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

virtual	~G4VSolid ()

G4bool	operator== (const G4VSolid &s) const

G4String	GetName () const

void	SetName (const G4String &name)

G4double	GetTolerance () const

virtual G4VSolid *	Clone () 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

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

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

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

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

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

Protected Attributes
G4bool	fRebuildPolyhedron

G4Polyhedron *	fpPolyhedron

Protected Attributes inherited from G4VSolid
G4double	kCarTolerance

Private Member Functions
void	CreateSurfaces ()

Detailed Description

Definition at line 58 of file G4VTwistedFaceted.hh.

Constructor & Destructor Documentation

◆ G4VTwistedFaceted() [1/3]

G4VTwistedFaceted::G4VTwistedFaceted	(	const G4String &	pname,
		G4double	PhiTwist,
		G4double	pDz,
		G4double	pTheta,
		G4double	pPhi,
		G4double	pDy1,
		G4double	pDx1,
		G4double	pDx2,
		G4double	pDy2,
		G4double	pDx3,
		G4double	pDx4,
		G4double	pAlph
	)

Definition at line 70 of file G4VTwistedFaceted.cc.

   : G4VSolid(pname), fRebuildPolyhedron(false), fpPolyhedron(0),
     fLowerEndcap(0), fUpperEndcap(0), fSide0(0),
     fSide90(0), fSide180(0), fSide270(0),
     fSurfaceArea(0.)
 {
 
   G4double pDytmp ;
   G4double fDxUp ;
   G4double fDxDown ;
 
   fDx1 = pDx1 ;
   fDx2 = pDx2 ;
   fDx3 = pDx3 ;
   fDx4 = pDx4 ;
   fDy1 = pDy1 ;
   fDy2 = pDy2 ;
   fDz  = pDz  ;
 
   G4double kAngTolerance
     = G4GeometryTolerance::GetInstance()->GetAngularTolerance();
 
   // maximum values
   //
   fDxDown = ( fDx1 > fDx2 ? fDx1 : fDx2 ) ;
   fDxUp   = ( fDx3 > fDx4 ? fDx3 : fDx4 ) ;
   fDx     = ( fDxUp > fDxDown ? fDxUp : fDxDown ) ;
   fDy     = ( fDy1 > fDy2 ? fDy1 : fDy2 ) ;
   
   // planarity check
   //
   if ( fDx1 != fDx2 && fDx3 != fDx4 )
   {
     pDytmp = fDy1 * ( fDx3 - fDx4 ) / ( fDx1 - fDx2 ) ;
     if ( std::fabs(pDytmp - fDy2) > kCarTolerance )
     {
       std::ostringstream message;
       message << "Not planar surface in untwisted Trapezoid: "
               << GetName() << G4endl
               << "fDy2 is " << fDy2 << " but should be "
               << pDytmp << ".";
       G4Exception("G4VTwistedFaceted::G4VTwistedFaceted()", "GeomSolids0002",
                   FatalErrorInArgument, message);
     }
   }
 
 #ifdef G4TWISTDEBUG
   if ( fDx1 == fDx2 && fDx3 == fDx4 )
   { 
       G4cout << "Trapezoid is a box" << G4endl ;
   }
   
 #endif
 
   if ( (  fDx1 == fDx2 && fDx3 != fDx4 ) || ( fDx1 != fDx2 && fDx3 == fDx4 ) )
   {
     std::ostringstream message;
     message << "Not planar surface in untwisted Trapezoid: "
             << GetName() << G4endl
             << "One endcap is rectangular, the other is a trapezoid." << G4endl
             << "For planarity reasons they have to be rectangles or trapezoids "
             << "on both sides.";
     G4Exception("G4VTwistedFaceted::G4VTwistedFaceted()", "GeomSolids0002",
                 FatalErrorInArgument, message);
   }
 
   // twist angle
   //
   fPhiTwist = PhiTwist ;
 
   // tilt angle
   //
   fAlph = pAlph ; 
   fTAlph = std::tan(fAlph) ;
   
   fTheta = pTheta ;
   fPhi   = pPhi ;
 
   // dx in surface equation
   //
   fdeltaX = 2 * fDz * std::tan(fTheta) * std::cos(fPhi)  ;
 
   // dy in surface equation
   //
   fdeltaY = 2 * fDz * std::tan(fTheta) * std::sin(fPhi)  ;
 
   if  ( ! ( ( fDx1  > 2*kCarTolerance)
          && ( fDx2  > 2*kCarTolerance)
          && ( fDx3  > 2*kCarTolerance)
          && ( fDx4  > 2*kCarTolerance)
          && ( fDy1  > 2*kCarTolerance)
          && ( fDy2  > 2*kCarTolerance)
          && ( fDz   > 2*kCarTolerance) 
          && ( std::fabs(fPhiTwist) > 2*kAngTolerance )
          && ( std::fabs(fPhiTwist) < pi/2 )
          && ( std::fabs(fAlph) < pi/2 )
          && ( fTheta < pi/2 && fTheta >= 0 ) )
       )
   {
     std::ostringstream message;
     message << "Invalid dimensions. Too small, or twist angle too big: "
             << GetName() << G4endl
             << "fDx 1-4 = " << fDx1/cm << ", " << fDx2/cm << ", "
             << fDx3/cm << ", " << fDx4/cm << " cm" << G4endl 
             << "fDy 1-2 = " << fDy1/cm << ", " << fDy2/cm << ", "
             << " cm" << G4endl 
             << "fDz = " << fDz/cm << " cm" << G4endl 
             << " twistangle " << fPhiTwist/deg << " deg" << G4endl 
             << " phi,theta = " << fPhi/deg << ", "  << fTheta/deg << " deg";
     G4Exception("G4TwistedTrap::G4VTwistedFaceted()",
                 "GeomSolids0002", FatalErrorInArgument, message);
   }
   CreateSurfaces();
   fCubicVolume = 2 * fDz * ( ( fDx1 + fDx2 ) * fDy1 + ( fDx3 + fDx4 ) * fDy2 );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ~G4VTwistedFaceted()

G4VTwistedFaceted::~G4VTwistedFaceted ( )

virtual

Definition at line 216 of file G4VTwistedFaceted.cc.

 {
   if (fLowerEndcap) { delete fLowerEndcap ; }
   if (fUpperEndcap) { delete fUpperEndcap ; }
 
   if (fSide0)       { delete fSide0   ; }
   if (fSide90)      { delete fSide90  ; }
   if (fSide180)     { delete fSide180 ; }
   if (fSide270)     { delete fSide270 ; }
   if (fpPolyhedron) { delete fpPolyhedron; fpPolyhedron = 0; }
 }

◆ G4VTwistedFaceted() [2/3]

G4VTwistedFaceted::G4VTwistedFaceted ( __void__ & a )

Definition at line 202 of file G4VTwistedFaceted.cc.

   : G4VSolid(a), fRebuildPolyhedron(false), fpPolyhedron(0),
     fTheta(0.), fPhi(0.), fDy1(0.),
     fDx1(0.), fDx2(0.), fDy2(0.), fDx3(0.), fDx4(0.),
     fDz(0.), fDx(0.), fDy(0.), fAlph(0.),
     fTAlph(0.), fdeltaX(0.), fdeltaY(0.), fPhiTwist(0.),
     fLowerEndcap(0), fUpperEndcap(0), fSide0(0), fSide90(0), fSide180(0),
     fSide270(0), fCubicVolume(0.), fSurfaceArea(0.)
 {
 }

◆ G4VTwistedFaceted() [3/3]

G4VTwistedFaceted::G4VTwistedFaceted ( const G4VTwistedFaceted & rhs )

Definition at line 231 of file G4VTwistedFaceted.cc.

   : G4VSolid(rhs), fRebuildPolyhedron(false), fpPolyhedron(0),
     fTheta(rhs.fTheta), fPhi(rhs.fPhi),
     fDy1(rhs.fDy1), fDx1(rhs.fDx1), fDx2(rhs.fDx2), fDy2(rhs.fDy2),
     fDx3(rhs.fDx3), fDx4(rhs.fDx4), fDz(rhs.fDz), fDx(rhs.fDx), fDy(rhs.fDy),
     fAlph(rhs.fAlph), fTAlph(rhs.fTAlph), fdeltaX(rhs.fdeltaX),
     fdeltaY(rhs.fdeltaY), fPhiTwist(rhs.fPhiTwist), fLowerEndcap(0),
     fUpperEndcap(0), fSide0(0), fSide90(0), fSide180(0), fSide270(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)
 {
   CreateSurfaces();
 }

Here is the call graph for this function:

Member Function Documentation

◆ CalculateExtent()

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

virtual

Implements G4VSolid.

Definition at line 301 of file G4VTwistedFaceted.cc.

 {
   G4double maxRad = std::sqrt( fDx*fDx + fDy*fDy);
 
   if (!pTransform.IsRotated())
     {
       // Special case handling for unrotated boxes
       // Compute x/y/z mins and maxs respecting limits, with early returns
       // if outside limits. Then switch() on pAxis
       
       G4double xoffset,xMin,xMax;
       G4double yoffset,yMin,yMax;
       G4double zoffset,zMin,zMax;
 
       xoffset = pTransform.NetTranslation().x() ;
       xMin    = xoffset - maxRad ;
       xMax    = xoffset + maxRad ;
 
       if (pVoxelLimit.IsXLimited())
         {
           if ( xMin > pVoxelLimit.GetMaxXExtent()+kCarTolerance || 
                xMax < pVoxelLimit.GetMinXExtent()-kCarTolerance  ) return false;
           else
             {
               if (xMin < pVoxelLimit.GetMinXExtent())
                 {
                   xMin = pVoxelLimit.GetMinXExtent() ;
                 }
               if (xMax > pVoxelLimit.GetMaxXExtent())
                 {
                   xMax = pVoxelLimit.GetMaxXExtent() ;
                 }
             }
         }
       yoffset = pTransform.NetTranslation().y() ;
       yMin    = yoffset - maxRad ;
       yMax    = yoffset + maxRad ;
       
       if (pVoxelLimit.IsYLimited())
         {
           if ( yMin > pVoxelLimit.GetMaxYExtent()+kCarTolerance ||
                yMax < pVoxelLimit.GetMinYExtent()-kCarTolerance  ) return false;
           else
             {
               if (yMin < pVoxelLimit.GetMinYExtent())
                 {
                   yMin = pVoxelLimit.GetMinYExtent() ;
                 }
               if (yMax > pVoxelLimit.GetMaxYExtent())
                 {
                   yMax = pVoxelLimit.GetMaxYExtent() ;
                 }
             }
         }
       zoffset = pTransform.NetTranslation().z() ;
       zMin    = zoffset - fDz ;
       zMax    = zoffset + fDz ;
       
       if (pVoxelLimit.IsZLimited())
         {
           if ( zMin > pVoxelLimit.GetMaxZExtent()+kCarTolerance ||
                zMax < pVoxelLimit.GetMinZExtent()-kCarTolerance  ) return false;
           else
             {
               if (zMin < pVoxelLimit.GetMinZExtent())
                 {
                   zMin = pVoxelLimit.GetMinZExtent() ;
                 }
               if (zMax > pVoxelLimit.GetMaxZExtent())
                 {
                   zMax = pVoxelLimit.GetMaxZExtent() ;
                 }
             }
         }
       switch (pAxis)
         {
         case kXAxis:
           pMin = xMin ;
           pMax = xMax ;
           break ;
         case kYAxis:
           pMin=yMin;
           pMax=yMax;
           break;
         case kZAxis:
         pMin=zMin;
         pMax=zMax;
         break;
         default:
           break;
         }
       pMin -= kCarTolerance ;
       pMax += kCarTolerance ;
       
       return true;
   }
   else  // General rotated case - create and clip mesh to boundaries
     {
       G4bool existsAfterClip = false ;
       G4ThreeVectorList* vertices ;
 
       pMin = +kInfinity ;
       pMax = -kInfinity ;
     
     // Calculate rotated vertex coordinates
       
       vertices = CreateRotatedVertices(pTransform) ;
       ClipCrossSection(vertices,0,pVoxelLimit,pAxis,pMin,pMax) ;
       ClipCrossSection(vertices,4,pVoxelLimit,pAxis,pMin,pMax) ;
       ClipBetweenSections(vertices,0,pVoxelLimit,pAxis,pMin,pMax) ;
       
       if (pVoxelLimit.IsLimited(pAxis) == false) 
         {  
           if ( pMin != kInfinity || pMax != -kInfinity ) 
             {
               existsAfterClip = true ;
 
               // Add 2*tolerance to avoid precision troubles
 
               pMin           -= kCarTolerance;
               pMax           += kCarTolerance;
             }
         }      
       else
         {
           G4ThreeVector clipCentre(
             ( pVoxelLimit.GetMinXExtent()+pVoxelLimit.GetMaxXExtent())*0.5,
             ( pVoxelLimit.GetMinYExtent()+pVoxelLimit.GetMaxYExtent())*0.5,
             ( pVoxelLimit.GetMinZExtent()+pVoxelLimit.GetMaxZExtent())*0.5 );
           
       if ( pMin != kInfinity || pMax != -kInfinity )
         {
           existsAfterClip = true ;
           
           // Check to see if endpoints are in the solid
           
           clipCentre(pAxis) = pVoxelLimit.GetMinExtent(pAxis);
           
           if (Inside(pTransform.Inverse().TransformPoint(clipCentre))
               != kOutside)
             {
               pMin = pVoxelLimit.GetMinExtent(pAxis);
             }
           else
             {
               pMin -= kCarTolerance;
             }
           clipCentre(pAxis) = pVoxelLimit.GetMaxExtent(pAxis);
           
           if (Inside(pTransform.Inverse().TransformPoint(clipCentre))
               != kOutside)
             {
               pMax = pVoxelLimit.GetMaxExtent(pAxis);
             }
           else
             {
               pMax += kCarTolerance;
             }
         }
       
       // Check for case where completely enveloping clipping volume
       // If point inside then we are confident that the solid completely
       // envelopes the clipping volume. Hence set min/max extents according
       // to clipping volume extents along the specified axis.
       
       else if (Inside(pTransform.Inverse().TransformPoint(clipCentre))
                != kOutside)
         {
           existsAfterClip = true ;
           pMin            = pVoxelLimit.GetMinExtent(pAxis) ;
           pMax            = pVoxelLimit.GetMaxExtent(pAxis) ;
         }
         } 
       delete vertices;
       return existsAfterClip;
     } 
   
   
 }

Here is the call graph for this function:

◆ ComputeDimensions()

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

virtual

Reimplemented from G4VSolid.

Definition at line 288 of file G4VTwistedFaceted.cc.

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

Here is the call graph for this function:

◆ CreatePolyhedron()

G4Polyhedron * G4VTwistedFaceted::CreatePolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1335 of file G4VTwistedFaceted.cc.

 {
   // number of meshes
   const G4int k =
     G4int(G4Polyhedron::GetNumberOfRotationSteps() * fPhiTwist / twopi) + 2;
   const G4int n = k;
 
   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) ;
   fSide270->GetFacets(k,n,xyz,faces,2) ;
   fSide0->GetFacets(k,n,xyz,faces,3) ;
   fSide90->GetFacets(k,n,xyz,faces,4) ;
   fSide180->GetFacets(k,n,xyz,faces,5) ;
 
   ph->createPolyhedron(nnodes,nfaces,xyz,faces);
 
   return ph;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CreateRotatedVertices()

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

protected

Definition at line 486 of file G4VTwistedFaceted.cc.

 {
 
   G4ThreeVectorList* vertices = new G4ThreeVectorList();
 
   if (vertices)
   {
     vertices->reserve(8);
 
     G4double maxRad = std::sqrt( fDx*fDx + fDy*fDy);
 
     G4ThreeVector vertex0(-maxRad,-maxRad,-fDz) ;
     G4ThreeVector vertex1(maxRad,-maxRad,-fDz) ;
     G4ThreeVector vertex2(maxRad,maxRad,-fDz) ;
     G4ThreeVector vertex3(-maxRad,maxRad,-fDz) ;
     G4ThreeVector vertex4(-maxRad,-maxRad,fDz) ;
     G4ThreeVector vertex5(maxRad,-maxRad,fDz) ;
     G4ThreeVector vertex6(maxRad,maxRad,fDz) ;
     G4ThreeVector vertex7(-maxRad,maxRad,fDz) ;
 
     vertices->push_back(pTransform.TransformPoint(vertex0));
     vertices->push_back(pTransform.TransformPoint(vertex1));
     vertices->push_back(pTransform.TransformPoint(vertex2));
     vertices->push_back(pTransform.TransformPoint(vertex3));
     vertices->push_back(pTransform.TransformPoint(vertex4));
     vertices->push_back(pTransform.TransformPoint(vertex5));
     vertices->push_back(pTransform.TransformPoint(vertex6));
     vertices->push_back(pTransform.TransformPoint(vertex7));
   }
   else
   {
     DumpInfo();
     G4Exception("G4VTwistedFaceted::CreateRotatedVertices()",
                 "GeomSolids0003", FatalException,
                 "Error in allocation of vertices. Out of memory !");
   }
   return vertices;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CreateSurfaces()

void G4VTwistedFaceted::CreateSurfaces ( )

private

Definition at line 1140 of file G4VTwistedFaceted.cc.

 {
    
   // create 6 surfaces of TwistedTub.
 
   if ( fDx1 == fDx2 && fDx3 == fDx4 )    // special case : Box
   {
     fSide0   = new G4TwistBoxSide("0deg",   fPhiTwist, fDz, fTheta, fPhi,
                                         fDy1, fDx1, fDx1, fDy2, fDx3, fDx3, fAlph, 0.*deg);
     fSide180 = new G4TwistBoxSide("180deg", fPhiTwist, fDz, fTheta, fPhi+pi,
                                         fDy1, fDx1, fDx1, fDy2, fDx3, fDx3, fAlph, 180.*deg);
   }
   else   // default general case
   {
     fSide0   = new G4TwistTrapAlphaSide("0deg"   ,fPhiTwist, fDz, fTheta,
                       fPhi, fDy1, fDx1, fDx2, fDy2, fDx3, fDx4, fAlph, 0.*deg);
     fSide180 = new G4TwistTrapAlphaSide("180deg", fPhiTwist, fDz, fTheta,
                  fPhi+pi, fDy1, fDx2, fDx1, fDy2, fDx4, fDx3, fAlph, 180.*deg);
   }
 
   // create parallel sides
   //
   fSide90 = new G4TwistTrapParallelSide("90deg",  fPhiTwist, fDz, fTheta,
                       fPhi, fDy1, fDx1, fDx2, fDy2, fDx3, fDx4, fAlph, 0.*deg);
   fSide270 = new G4TwistTrapParallelSide("270deg", fPhiTwist, fDz, fTheta,
                  fPhi+pi, fDy1, fDx2, fDx1, fDy2, fDx4, fDx3, fAlph, 180.*deg);
 
   // create endcaps
   //
   fUpperEndcap = new G4TwistTrapFlatSide("UpperCap",fPhiTwist, fDx3, fDx4, fDy2,
                                     fDz, fAlph, fPhi, fTheta,  1 );
   fLowerEndcap = new G4TwistTrapFlatSide("LowerCap",fPhiTwist, fDx1, fDx2, fDy1,
                                     fDz, fAlph, fPhi, fTheta, -1 );
  
   // Set neighbour surfaces
   
   fSide0->SetNeighbours(  fSide270 , fLowerEndcap , fSide90  , fUpperEndcap );
   fSide90->SetNeighbours( fSide0   , fLowerEndcap , fSide180 , fUpperEndcap );
   fSide180->SetNeighbours(fSide90  , fLowerEndcap , fSide270 , fUpperEndcap );
   fSide270->SetNeighbours(fSide180 , fLowerEndcap , fSide0   , fUpperEndcap );
   fUpperEndcap->SetNeighbours( fSide180, fSide270 , fSide0 , fSide90  );
   fLowerEndcap->SetNeighbours( fSide180, fSide270 , fSide0 , fSide90  );
 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DescribeYourselfTo()

void G4VTwistedFaceted::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

virtual

Implements G4VSolid.

Definition at line 1119 of file G4VTwistedFaceted.cc.

 {
   scene.AddSolid (*this);
 }

Here is the call graph for this function:

◆ DistanceToIn() [1/2]

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

virtual

Implements G4VSolid.

Definition at line 679 of file G4VTwistedFaceted.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] = fSide0;
    surfaces[1] = fSide90 ;
    surfaces[2] = fSide180 ;
    surfaces[3] = fSide270 ;
    surfaces[4] = fLowerEndcap;
    surfaces[5] = fUpperEndcap;
    
    G4ThreeVector xx;
    G4ThreeVector bestxx;
    G4int i;
    for (i=0; i < 6 ; i++)
    {
 #ifdef G4TWISTDEBUG
       G4cout << G4endl << "surface " << i << ": " << G4endl << G4endl ;
 #endif
       G4double tmpdistance = surfaces[i]->DistanceToIn(p, v, xx);
 #ifdef G4TWISTDEBUG
       G4cout << "Solid DistanceToIn : distance = " << tmpdistance << G4endl ; 
       G4cout << "intersection point = " << xx << G4endl ;
 #endif 
       if (tmpdistance < distance)
       {
          distance = tmpdistance;
          bestxx = xx;
       }
    }
 
 #ifdef G4TWISTDEBUG
    G4cout << "best distance = " << distance << G4endl ;
 #endif
 
    *tmpdist = distance;
    // timer.Stop();
    return fLastDistanceToInWithV.value;
 }

Here is the call graph for this function:

◆ DistanceToIn() [2/2]

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

virtual

Implements G4VSolid.

Definition at line 778 of file G4VTwistedFaceted.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] = fSide0;
          surfaces[1] = fSide90 ;
          surfaces[2] = fSide180 ;
          surfaces[3] = fSide270 ;
          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 fLastDistanceToIn.value;
       }
 
       default :
       {
          G4Exception("G4VTwistedFaceted::DistanceToIn(p)", "GeomSolids0003",
                      FatalException, "Unknown point location!");
       }
    } // switch end
 
    return 0;
 }

Here is the call graph for this function:

◆ DistanceToOut() [1/2]

G4double G4VTwistedFaceted::DistanceToOut	(	const G4ThreeVector &	p,
		const G4ThreeVector &	v,
		const G4bool	calcnorm = `false`,
		G4bool *	validnorm = `0`,
		G4ThreeVector *	n = `0`
	)		const

virtual

Implements G4VSolid.

Definition at line 868 of file G4VTwistedFaceted.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.;
             // timer.Stop();
             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] = fSide0;
    surfaces[1] = fSide90 ;
    surfaces[2] = fSide180 ;
    surfaces[3] = fSide270 ;
    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;
    // timer.Stop();
    return fLastDistanceToOutWithV.value;
 }

Here is the call graph for this function:

◆ DistanceToOut() [2/2]

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

virtual

Implements G4VSolid.

Definition at line 976 of file G4VTwistedFaceted.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);
    G4double     retval = kInfinity;   
 
    switch (currentside)
    {
       case (kOutside) :
       {
 #ifdef G4SPECSDEBUG
         G4int oldprc = G4cout.precision(16) ;
         G4cout << G4endl ;
         DumpInfo();
         G4cout << "Position:"  << G4endl << G4endl ;
         G4cout << "p.x() = "   << p.x()/mm << " mm" << G4endl ;
         G4cout << "p.y() = "   << p.y()/mm << " mm" << G4endl ;
         G4cout << "p.z() = "   << p.z()/mm << " mm" << G4endl << G4endl ;
         G4cout.precision(oldprc) ;
         G4Exception("G4VTwistedFaceted::DistanceToOut(p)", "GeomSolids1002",
                     JustWarning, "Point p is outside !?" );
 #endif
         break;
       }
       case (kSurface) :
       {
         *tmpdist = 0.;
         retval = fLastDistanceToOut.value;
         break;
       }
       
       case (kInside) :
       {
         // Initialize
         //
         G4double      distance = kInfinity;
    
         // find intersections and choose nearest one
         //
         G4VTwistSurface *surfaces[6];
 
         surfaces[0] = fSide0;
         surfaces[1] = fSide90 ;
         surfaces[2] = fSide180 ;
         surfaces[3] = fSide270 ;
         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;
    
         retval = fLastDistanceToOut.value;
         break;
       }
       
       default :
       {
         G4Exception("G4VTwistedFaceted::DistanceToOut(p)", "GeomSolids0003",
                     FatalException, "Unknown point location!");
         break;
       }
    } // switch end
 
    return retval;
 }

Here is the call graph for this function:

◆ GetAlpha()

G4double G4VTwistedFaceted::GetAlpha ( ) const

inline

Definition at line 130 of file G4VTwistedFaceted.hh.

130 { return fAlph ; }

G4VTwistedFaceted::fAlph

G4double fAlph

Definition: G4VTwistedFaceted.hh:185

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetCubicVolume()

G4double G4VTwistedFaceted::GetCubicVolume ( )

inlinevirtual

Reimplemented from G4VSolid.

Definition at line 313 of file G4VTwistedFaceted.hh.

 {
   if(fCubicVolume != 0.) ;
   else   fCubicVolume = 2 * fDz
                       * ( ( fDx1 + fDx2 ) * fDy1 + ( fDx3 + fDx4 ) * fDy2  );
   return fCubicVolume;
 }

◆ GetDx1()

G4double G4VTwistedFaceted::GetDx1 ( ) const

inline

Definition at line 121 of file G4VTwistedFaceted.hh.

121 { return fDx1 ; }

G4VTwistedFaceted::fDx1

G4double fDx1

Definition: G4VTwistedFaceted.hh:173

Here is the caller graph for this function:

◆ GetDx2()

G4double G4VTwistedFaceted::GetDx2 ( ) const

inline

Definition at line 122 of file G4VTwistedFaceted.hh.

122 { return fDx2 ; }

G4VTwistedFaceted::fDx2

G4double fDx2

Definition: G4VTwistedFaceted.hh:174

Here is the caller graph for this function:

◆ GetDx3()

G4double G4VTwistedFaceted::GetDx3 ( ) const

inline

Definition at line 123 of file G4VTwistedFaceted.hh.

123 { return fDx3 ; }

G4VTwistedFaceted::fDx3

G4double fDx3

Definition: G4VTwistedFaceted.hh:177

Here is the caller graph for this function:

◆ GetDx4()

G4double G4VTwistedFaceted::GetDx4 ( ) const

inline

Definition at line 124 of file G4VTwistedFaceted.hh.

124 { return fDx4 ; }

G4VTwistedFaceted::fDx4

G4double fDx4

Definition: G4VTwistedFaceted.hh:178

Here is the caller graph for this function:

◆ GetDy1()

G4double G4VTwistedFaceted::GetDy1 ( ) const

inline

Definition at line 125 of file G4VTwistedFaceted.hh.

125 { return fDy1 ; }

G4VTwistedFaceted::fDy1

G4double fDy1

Definition: G4VTwistedFaceted.hh:172

Here is the caller graph for this function:

◆ GetDy2()

G4double G4VTwistedFaceted::GetDy2 ( ) const

inline

Definition at line 126 of file G4VTwistedFaceted.hh.

126 { return fDy2 ; }

G4VTwistedFaceted::fDy2

G4double fDy2

Definition: G4VTwistedFaceted.hh:176

Here is the caller graph for this function:

◆ GetDz()

G4double G4VTwistedFaceted::GetDz ( ) const

inline

Definition at line 127 of file G4VTwistedFaceted.hh.

127 { return fDz ; }

G4VTwistedFaceted::fDz

G4double fDz

Definition: G4VTwistedFaceted.hh:180

Here is the caller graph for this function:

◆ GetEntityType()

G4GeometryType G4VTwistedFaceted::GetEntityType ( ) const

virtual

Implements G4VSolid.

Reimplemented in G4TwistedTrap, G4TwistedTrd, and G4TwistedBox.

Definition at line 1189 of file G4VTwistedFaceted.cc.

 {
   return G4String("G4VTwistedFaceted");
 }

Here is the caller graph for this function:

◆ GetExtent()

G4VisExtent G4VTwistedFaceted::GetExtent ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1127 of file G4VTwistedFaceted.cc.

 {
   G4double maxRad = std::sqrt( fDx*fDx + fDy*fDy);
 
   return G4VisExtent(-maxRad, maxRad ,
                      -maxRad, maxRad ,
                      -fDz, fDz );
 }

Here is the caller graph for this function:

◆ GetPhi()

G4double G4VTwistedFaceted::GetPhi ( ) const

inline

Definition at line 128 of file G4VTwistedFaceted.hh.

128 { return fPhi ; }

G4VTwistedFaceted::fPhi

G4double fPhi

Definition: G4VTwistedFaceted.hh:170

Here is the caller graph for this function:

◆ GetPointInSolid()

G4ThreeVector G4VTwistedFaceted::GetPointInSolid ( G4double z ) const

Definition at line 1219 of file G4VTwistedFaceted.cc.

 {
 
 
   // this routine is only used for a test
   // can be deleted ...
 
   if ( z == fDz ) z -= 0.1*fDz ;
   if ( z == -fDz ) z += 0.1*fDz ;
 
   G4double phi = z/(2*fDz)*fPhiTwist ;
 
   return G4ThreeVector(fdeltaX * phi/fPhiTwist, fdeltaY * phi/fPhiTwist, z ) ;
 }

◆ GetPointOnSurface()

G4ThreeVector G4VTwistedFaceted::GetPointOnSurface ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1238 of file G4VTwistedFaceted.cc.

 {
 
   G4double  phi = G4RandFlat::shoot(-fPhiTwist/2.,fPhiTwist/2.);
   G4double u , umin, umax ;  //  variable for twisted surfaces
   G4double y  ;              //  variable for flat surface (top and bottom)
 
   // Compute the areas. Attention: Only correct for trapezoids
   // where the twisting is done along the z-axis. In the general case
   // the computed surface area is more difficult. However this simplification
   // does not affect the tracking through the solid. 
  
   G4double a1   = fSide0->GetSurfaceArea();
   G4double a2   = fSide90->GetSurfaceArea();
   G4double a3   = fSide180->GetSurfaceArea() ;
   G4double a4   = fSide270->GetSurfaceArea() ;
   G4double a5   = fLowerEndcap->GetSurfaceArea() ;
   G4double a6   = fUpperEndcap->GetSurfaceArea() ;
 
 #ifdef G4TWISTDEBUG
   G4cout << "Surface 0   deg = " << a1 << G4endl ;
   G4cout << "Surface 90  deg = " << a2 << G4endl ;
   G4cout << "Surface 180 deg = " << a3 << G4endl ;
   G4cout << "Surface 270 deg = " << a4 << G4endl ;
   G4cout << "Surface Lower   = " << a5 << G4endl ;
   G4cout << "Surface Upper   = " << a6 << G4endl ;
 #endif 
 
   G4double chose = G4RandFlat::shoot(0.,a1 + a2 + a3 + a4 + a5 + a6) ;
 
   if(chose < a1)
   {
 
     umin = fSide0->GetBoundaryMin(phi) ;
     umax = fSide0->GetBoundaryMax(phi) ;
     u = G4RandFlat::shoot(umin,umax) ;
 
     return  fSide0->SurfacePoint(phi, u, true) ;   // point on 0deg surface
   }
 
   else if( (chose >= a1) && (chose < a1 + a2 ) )
   {
 
     umin = fSide90->GetBoundaryMin(phi) ;
     umax = fSide90->GetBoundaryMax(phi) ;
     
     u = G4RandFlat::shoot(umin,umax) ;
 
     return fSide90->SurfacePoint(phi, u, true);   // point on 90deg surface
   }
 
   else if( (chose >= a1 + a2 ) && (chose < a1 + a2 + a3 ) )
   {
 
     umin = fSide180->GetBoundaryMin(phi) ;
     umax = fSide180->GetBoundaryMax(phi) ;
     u = G4RandFlat::shoot(umin,umax) ;
 
      return fSide180->SurfacePoint(phi, u, true); // point on 180 deg surface
   }
 
   else if( (chose >= a1 + a2 + a3  ) && (chose < a1 + a2 + a3 + a4  ) )
   {
 
     umin = fSide270->GetBoundaryMin(phi) ;
     umax = fSide270->GetBoundaryMax(phi) ;
     u = G4RandFlat::shoot(umin,umax) ;
 
     return fSide270->SurfacePoint(phi, u, true); // point on 270 deg surface
   }
 
   else if( (chose >= a1 + a2 + a3 + a4  ) && (chose < a1 + a2 + a3 + a4 + a5 ) )
   {
 
     y = G4RandFlat::shoot(-fDy1,fDy1) ;
     umin = fLowerEndcap->GetBoundaryMin(y) ;
     umax = fLowerEndcap->GetBoundaryMax(y) ;
     u = G4RandFlat::shoot(umin,umax) ;
 
     return fLowerEndcap->SurfacePoint(u,y,true); // point on lower endcap
   }
   else {
 
     y = G4RandFlat::shoot(-fDy2,fDy2) ;
     umin = fUpperEndcap->GetBoundaryMin(y) ;
     umax = fUpperEndcap->GetBoundaryMax(y) ;
     u = G4RandFlat::shoot(umin,umax) ;
 
     return fUpperEndcap->SurfacePoint(u,y,true) ; // point on upper endcap
 
   }
 }

Here is the call graph for this function:

◆ GetPolyhedron()

G4Polyhedron * G4VTwistedFaceted::GetPolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1198 of file G4VTwistedFaceted.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:

Here is the caller graph for this function:

◆ GetSurfaceArea()

G4double G4VTwistedFaceted::GetSurfaceArea ( )

inlinevirtual

Reimplemented from G4VSolid.

Definition at line 322 of file G4VTwistedFaceted.hh.

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

Here is the call graph for this function:

◆ GetTheta()

G4double G4VTwistedFaceted::GetTheta ( ) const

inline

Definition at line 129 of file G4VTwistedFaceted.hh.

129 { return fTheta ; }

G4VTwistedFaceted::fTheta

G4double fTheta

Definition: G4VTwistedFaceted.hh:169

Here is the caller graph for this function:

◆ GetTwistAngle()

G4double G4VTwistedFaceted::GetTwistAngle ( ) const

inline

Definition at line 119 of file G4VTwistedFaceted.hh.

119 { return fPhiTwist; }

G4VTwistedFaceted::fPhiTwist

G4double fPhiTwist

Definition: G4VTwistedFaceted.hh:191

Here is the caller graph for this function:

◆ GetValueA()

G4double G4VTwistedFaceted::GetValueA ( G4double phi ) const

inline

Definition at line 330 of file G4VTwistedFaceted.hh.

 {
   return ( fDx4 + fDx2  + ( fDx4 - fDx2 ) * ( 2 * phi ) / fPhiTwist  ) ;
 }

Here is the caller graph for this function:

◆ GetValueB()

G4double G4VTwistedFaceted::GetValueB ( G4double phi ) const

inline

Definition at line 342 of file G4VTwistedFaceted.hh.

 {
   return ( fDy2 + fDy1  + ( fDy2 - fDy1 ) * ( 2 * phi ) / fPhiTwist ) ;
 }

Here is the caller graph for this function:

◆ GetValueD()

G4double G4VTwistedFaceted::GetValueD ( G4double phi ) const

inline

Definition at line 336 of file G4VTwistedFaceted.hh.

 {
   return ( fDx3 + fDx1  + ( fDx3 - fDx1 ) * ( 2 * phi ) / fPhiTwist  ) ;
 } 

Here is the caller graph for this function:

◆ Inside()

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

virtual

Implements G4VSolid.

Definition at line 528 of file G4VTwistedFaceted.cc.

 {
 
    G4ThreeVector *tmpp;
    EInside       *tmpin;
    if (fLastInside.p == p) {
      return fLastInside.inside;
    } else {
       tmpp      = const_cast<G4ThreeVector*>(&(fLastInside.p));
       tmpin     = const_cast<EInside*>(&(fLastInside.inside));
       tmpp->set(p.x(), p.y(), p.z());
    }
 
    *tmpin = kOutside ;
 
    G4double phi = p.z()/(2*fDz) * fPhiTwist ;  // rotate the point to z=0
    G4double cphi = std::cos(-phi) ;
    G4double sphi = std::sin(-phi) ;
 
    G4double px  = p.x() + fdeltaX * ( -phi/fPhiTwist) ;  // shift
    G4double py  = p.y() + fdeltaY * ( -phi/fPhiTwist) ;
    G4double pz  = p.z() ;
 
    G4double posx = px * cphi - py * sphi   ;  // rotation
    G4double posy = px * sphi + py * cphi   ;
    G4double posz = pz  ;
 
    G4double xMin = Xcoef(posy,phi,fTAlph) - 2*Xcoef(posy,phi,0.) ; 
    G4double xMax = Xcoef(posy,phi,fTAlph) ;  
 
    G4double yMax = GetValueB(phi)/2. ;  // b(phi)/2 is limit
    G4double yMin = -yMax ;
 
 #ifdef G4TWISTDEBUG
 
    G4cout << "inside called: p = " << p << G4endl ; 
    G4cout << "fDx1 = " << fDx1 << G4endl ;
    G4cout << "fDx2 = " << fDx2 << G4endl ;
    G4cout << "fDx3 = " << fDx3 << G4endl ;
    G4cout << "fDx4 = " << fDx4 << G4endl ;
 
    G4cout << "fDy1 = " << fDy1 << G4endl ;
    G4cout << "fDy2 = " << fDy2 << G4endl ;
 
    G4cout << "fDz  = " << fDz  << G4endl ;
 
    G4cout << "Tilt angle alpha = " << fAlph << G4endl ;
    G4cout << "phi,theta = " << fPhi << " , " << fTheta << G4endl ;
 
    G4cout << "Twist angle = " << fPhiTwist << G4endl ;
 
    G4cout << "posx = " << posx << G4endl ;
    G4cout << "posy = " << posy << G4endl ;
    G4cout << "xMin = " << xMin << G4endl ;
    G4cout << "xMax = " << xMax << G4endl ;
    G4cout << "yMin = " << yMin << G4endl ;
    G4cout << "yMax = " << yMax << G4endl ;
 
 #endif 
 
 
   if ( posx <= xMax - kCarTolerance*0.5
     && posx >= xMin + kCarTolerance*0.5 )
   {
     if ( posy <= yMax - kCarTolerance*0.5
       && posy >= yMin + kCarTolerance*0.5 )
     {
       if      (std::fabs(posz) <= fDz - kCarTolerance*0.5 ) *tmpin = kInside ;
       else if (std::fabs(posz) <= fDz + kCarTolerance*0.5 ) *tmpin = kSurface ;
     }
     else if ( posy <= yMax + kCarTolerance*0.5
            && posy >= yMin - kCarTolerance*0.5 )
     {
       if (std::fabs(posz) <= fDz + kCarTolerance*0.5 ) *tmpin = kSurface ;
     }
   }
   else if ( posx <= xMax + kCarTolerance*0.5
          && posx >= xMin - kCarTolerance*0.5 )
   {
     if ( posy <= yMax + kCarTolerance*0.5
       && posy >= yMin - kCarTolerance*0.5 )
     {
       if (std::fabs(posz) <= fDz + kCarTolerance*0.5) *tmpin = kSurface ;
     }
   }
 
 #ifdef G4TWISTDEBUG
   G4cout << "inside = " << fLastInside.inside << G4endl ;
 #endif
 
   return fLastInside.inside;
 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator=()

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

Definition at line 253 of file G4VTwistedFaceted.cc.

 {
    // Check assignment to self
    //
    if (this == &rhs)  { return *this; }
 
    // Copy base class data
    //
    G4VSolid::operator=(rhs);
 
    // Copy data
    //
    fTheta = rhs.fTheta; fPhi = rhs.fPhi;
    fDy1= rhs.fDy1; fDx1= rhs.fDx1; fDx2= rhs.fDx2; fDy2= rhs.fDy2;
    fDx3= rhs.fDx3; fDx4= rhs.fDx4; fDz= rhs.fDz; fDx= rhs.fDx; fDy= rhs.fDy;
    fAlph= rhs.fAlph; fTAlph= rhs.fTAlph; fdeltaX= rhs.fdeltaX;
    fdeltaY= rhs.fdeltaY; fPhiTwist= rhs.fPhiTwist; fLowerEndcap= 0;
    fUpperEndcap= 0; fSide0= 0; fSide90= 0; fSide180= 0; fSide270= 0;
    fCubicVolume= rhs.fCubicVolume; fSurfaceArea= rhs.fSurfaceArea;
    fRebuildPolyhedron = false;
    delete fpPolyhedron; fpPolyhedron= 0;
    fLastInside= rhs.fLastInside; fLastNormal= rhs.fLastNormal;
    fLastDistanceToIn= rhs.fLastDistanceToIn;
    fLastDistanceToOut= rhs.fLastDistanceToOut;
    fLastDistanceToInWithV= rhs.fLastDistanceToInWithV;
    fLastDistanceToOutWithV= rhs.fLastDistanceToOutWithV;
  
    CreateSurfaces();
 
    return *this;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ StreamInfo()

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

virtual

Implements G4VSolid.

Reimplemented in G4TwistedTrap, G4TwistedTrd, and G4TwistedBox.

Definition at line 1082 of file G4VTwistedFaceted.cc.

 {
   //
   // Stream object contents to an output stream
   //
   G4int oldprc = os.precision(16);
   os << "-----------------------------------------------------------\n"
      << "    *** Dump for solid - " << GetName() << " ***\n"
      << "    ===================================================\n"
      << " Solid type: G4VTwistedFaceted\n"
      << " Parameters: \n"
      << "  polar angle theta = "   <<  fTheta/degree      << " deg" << G4endl
      << "  azimuthal angle phi = "  << fPhi/degree        << " deg" << G4endl  
      << "  tilt angle  alpha = "   << fAlph/degree        << " deg" << G4endl  
      << "  TWIST angle = "         << fPhiTwist/degree    << " deg" << G4endl  
      << "  Half length along y (lower endcap) = "         << fDy1/cm << " cm"
      << G4endl 
      << "  Half length along x (lower endcap, bottom) = " << fDx1/cm << " cm"
      << G4endl 
      << "  Half length along x (lower endcap, top) = "    << fDx2/cm << " cm"
      << G4endl 
      << "  Half length along y (upper endcap) = "         << fDy2/cm << " cm"
      << G4endl 
      << "  Half length along x (upper endcap, bottom) = " << fDx3/cm << " cm"
      << G4endl 
      << "  Half length along x (upper endcap, top) = "    << fDx4/cm << " cm"
      << G4endl 
      << "-----------------------------------------------------------\n";
   os.precision(oldprc);
 
   return os;
 }

Here is the call graph for this function:

◆ SurfaceNormal()

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

virtual

Implements G4VSolid.

Definition at line 625 of file G4VTwistedFaceted.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] = fSide0 ;
    surfaces[1] = fSide90 ;
    surfaces[2] = fSide180 ;
    surfaces[3] = fSide270 ;
    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:

◆ Xcoef()

G4double G4VTwistedFaceted::Xcoef	(	G4double	u,
		G4double	phi,
		G4double	ftg
	)		const

inline

Definition at line 348 of file G4VTwistedFaceted.hh.

 {
   return GetValueA(phi)/2. + (GetValueD(phi)-GetValueA(phi))/4. 
     - u*( ( GetValueD(phi)-GetValueA(phi) ) / ( 2 * GetValueB(phi) ) - ftg );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ fAlph

G4double G4VTwistedFaceted::fAlph

private

Definition at line 185 of file G4VTwistedFaceted.hh.

◆ fCubicVolume

G4double G4VTwistedFaceted::fCubicVolume

private

Definition at line 201 of file G4VTwistedFaceted.hh.

◆ fdeltaX

G4double G4VTwistedFaceted::fdeltaX

private

Definition at line 188 of file G4VTwistedFaceted.hh.

◆ fdeltaY

G4double G4VTwistedFaceted::fdeltaY

private

Definition at line 189 of file G4VTwistedFaceted.hh.

◆ fDx

G4double G4VTwistedFaceted::fDx

private

Definition at line 182 of file G4VTwistedFaceted.hh.

◆ fDx1

G4double G4VTwistedFaceted::fDx1

private

Definition at line 173 of file G4VTwistedFaceted.hh.

◆ fDx2

G4double G4VTwistedFaceted::fDx2

private

Definition at line 174 of file G4VTwistedFaceted.hh.

◆ fDx3

G4double G4VTwistedFaceted::fDx3

private

Definition at line 177 of file G4VTwistedFaceted.hh.

◆ fDx4

G4double G4VTwistedFaceted::fDx4

private

Definition at line 178 of file G4VTwistedFaceted.hh.

◆ fDy

G4double G4VTwistedFaceted::fDy

private

Definition at line 183 of file G4VTwistedFaceted.hh.

◆ fDy1

G4double G4VTwistedFaceted::fDy1

private

Definition at line 172 of file G4VTwistedFaceted.hh.

◆ fDy2

G4double G4VTwistedFaceted::fDy2

private

Definition at line 176 of file G4VTwistedFaceted.hh.

◆ fDz

G4double G4VTwistedFaceted::fDz

private

Definition at line 180 of file G4VTwistedFaceted.hh.

◆ fLastDistanceToIn

LastValue G4VTwistedFaceted::fLastDistanceToIn

private

Definition at line 303 of file G4VTwistedFaceted.hh.

◆ fLastDistanceToInWithV

LastValueWithDoubleVector G4VTwistedFaceted::fLastDistanceToInWithV

private

Definition at line 305 of file G4VTwistedFaceted.hh.

◆ fLastDistanceToOut

LastValue G4VTwistedFaceted::fLastDistanceToOut

private

Definition at line 304 of file G4VTwistedFaceted.hh.

◆ fLastDistanceToOutWithV

LastValueWithDoubleVector G4VTwistedFaceted::fLastDistanceToOutWithV

private

Definition at line 306 of file G4VTwistedFaceted.hh.

◆ fLastInside

LastState G4VTwistedFaceted::fLastInside

private

Definition at line 301 of file G4VTwistedFaceted.hh.

◆ fLastNormal

LastVector G4VTwistedFaceted::fLastNormal

private

Definition at line 302 of file G4VTwistedFaceted.hh.

◆ fLowerEndcap

G4VTwistSurface* G4VTwistedFaceted::fLowerEndcap

private

Definition at line 193 of file G4VTwistedFaceted.hh.

◆ fPhi

G4double G4VTwistedFaceted::fPhi

private

Definition at line 170 of file G4VTwistedFaceted.hh.

◆ fPhiTwist

G4double G4VTwistedFaceted::fPhiTwist

private

Definition at line 191 of file G4VTwistedFaceted.hh.

◆ fpPolyhedron

G4Polyhedron* G4VTwistedFaceted::fpPolyhedron

mutableprotected

Definition at line 161 of file G4VTwistedFaceted.hh.

◆ fRebuildPolyhedron

G4bool G4VTwistedFaceted::fRebuildPolyhedron

mutableprotected

Definition at line 160 of file G4VTwistedFaceted.hh.

◆ fSide0

G4VTwistSurface* G4VTwistedFaceted::fSide0

private

Definition at line 196 of file G4VTwistedFaceted.hh.

◆ fSide180

G4VTwistSurface* G4VTwistedFaceted::fSide180

private

Definition at line 198 of file G4VTwistedFaceted.hh.

◆ fSide270

G4VTwistSurface* G4VTwistedFaceted::fSide270

private

Definition at line 199 of file G4VTwistedFaceted.hh.

◆ fSide90

G4VTwistSurface* G4VTwistedFaceted::fSide90

private

Definition at line 197 of file G4VTwistedFaceted.hh.

◆ fSurfaceArea

G4double G4VTwistedFaceted::fSurfaceArea

private

Definition at line 202 of file G4VTwistedFaceted.hh.

◆ fTAlph

G4double G4VTwistedFaceted::fTAlph

private

Definition at line 186 of file G4VTwistedFaceted.hh.

◆ fTheta

G4double G4VTwistedFaceted::fTheta

private

Definition at line 169 of file G4VTwistedFaceted.hh.

◆ fUpperEndcap

G4VTwistSurface* G4VTwistedFaceted::fUpperEndcap

private

Definition at line 194 of file G4VTwistedFaceted.hh.

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

Private Attributes
G4double	fTheta

G4double	fPhi

G4double	fDy1

G4double	fDx1

G4double	fDx2

G4double	fDy2

G4double	fDx3

G4double	fDx4

G4double	fDz

G4double	fDx

G4double	fDy

G4double	fAlph

G4double	fTAlph

G4double	fdeltaX

G4double	fdeltaY

G4double	fPhiTwist

G4VTwistSurface *	fLowerEndcap

G4VTwistSurface *	fUpperEndcap

G4VTwistSurface *	fSide0

G4VTwistSurface *	fSide90

G4VTwistSurface *	fSide180

G4VTwistSurface *	fSide270

G4double	fCubicVolume

G4double	fSurfaceArea

LastState	fLastInside

LastVector	fLastNormal

LastValue	fLastDistanceToIn

LastValue	fLastDistanceToOut

LastValueWithDoubleVector	fLastDistanceToInWithV

LastValueWithDoubleVector	fLastDistanceToOutWithV

Classes

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4VTwistedFaceted() [1/3]

◆ ~G4VTwistedFaceted()

◆ G4VTwistedFaceted() [2/3]

◆ G4VTwistedFaceted() [3/3]

Member Function Documentation

◆ CalculateExtent()

◆ ComputeDimensions()

◆ CreatePolyhedron()

◆ CreateRotatedVertices()

◆ CreateSurfaces()

◆ DescribeYourselfTo()

◆ DistanceToIn() [1/2]

◆ DistanceToIn() [2/2]

◆ DistanceToOut() [1/2]

◆ DistanceToOut() [2/2]

◆ GetAlpha()

◆ GetCubicVolume()

◆ GetDx1()

◆ GetDx2()

◆ GetDx3()

◆ GetDx4()

◆ GetDy1()

◆ GetDy2()

◆ GetDz()

◆ GetEntityType()

◆ GetExtent()

◆ GetPhi()

◆ GetPointInSolid()

◆ GetPointOnSurface()

◆ GetPolyhedron()

◆ GetSurfaceArea()

◆ GetTheta()

◆ GetTwistAngle()

◆ GetValueA()

◆ GetValueB()

◆ GetValueD()

◆ Inside()

◆ operator=()

◆ StreamInfo()

◆ SurfaceNormal()

◆ Xcoef()

Member Data Documentation

◆ fAlph

◆ fCubicVolume

◆ fdeltaX

◆ fdeltaY

◆ fDx

◆ fDx1

◆ fDx2

◆ fDx3

◆ fDx4

◆ fDy

◆ fDy1

◆ fDy2

◆ fDz

◆ fLastDistanceToIn

◆ fLastDistanceToInWithV

◆ fLastDistanceToOut

◆ fLastDistanceToOutWithV

◆ fLastInside

◆ fLastNormal

◆ fLowerEndcap

◆ fPhi

◆ fPhiTwist

◆ fpPolyhedron

◆ fRebuildPolyhedron

◆ fSide0

◆ fSide180

◆ fSide270

◆ fSide90

◆ fSurfaceArea

◆ fTAlph