#include <G4VTwistedFaceted.hh>

Inheritance diagram for G4VTwistedFaceted:

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)

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

G4double	EstimateCubicVolume (G4int nStat, G4double epsilon) const

G4double	EstimateSurfaceArea (G4int nStat, G4double ell) const

Additional Inherited Members
Protected Attributes inherited from G4VSolid
G4double	kCarTolerance

Detailed Description

Definition at line 58 of file G4VTwistedFaceted.hh.

Constructor & Destructor Documentation

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 63 of file G4VTwistedFaceted.cc.

References python.hepunit::cm, python.hepunit::deg, FatalErrorInArgument, G4cout, G4endl, G4Exception(), G4GeometryTolerance::GetAngularTolerance(), G4GeometryTolerance::GetInstance(), G4VSolid::GetName(), G4VSolid::kCarTolerance, and python.hepunit::pi.

   : G4VSolid(pname), 
     fLowerEndcap(0), fUpperEndcap(0), fSide0(0),
     fSide90(0), fSide180(0), fSide270(0),
     fSurfaceArea(0.), fpPolyhedron(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 );
 }

G4VTwistedFaceted::~G4VTwistedFaceted ( )

virtual

Definition at line 207 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;
 }

G4VTwistedFaceted::G4VTwistedFaceted ( __void__ & a )

Definition at line 195 of file G4VTwistedFaceted.cc.

   : G4VSolid(a), 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.), fpPolyhedron(0)
 {
 }

G4VTwistedFaceted::G4VTwistedFaceted ( const G4VTwistedFaceted & rhs )

Definition at line 222 of file G4VTwistedFaceted.cc.

   : G4VSolid(rhs), 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),
     fpPolyhedron(0),
     fLastInside(rhs.fLastInside), fLastNormal(rhs.fLastNormal),
     fLastDistanceToIn(rhs.fLastDistanceToIn),
     fLastDistanceToOut(rhs.fLastDistanceToOut),
     fLastDistanceToInWithV(rhs.fLastDistanceToInWithV),
     fLastDistanceToOutWithV(rhs.fLastDistanceToOutWithV)
 {
   CreateSurfaces();
 }

Member Function Documentation

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

virtual

Implements G4VSolid.

Definition at line 291 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;
     } 
   
   
 }

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

virtual

Reimplemented from G4VSolid.

Definition at line 278 of file G4VTwistedFaceted.cc.

References FatalException, and G4Exception().

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

G4Polyhedron * G4VTwistedFaceted::CreatePolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1318 of file G4VTwistedFaceted.cc.

References HepPolyhedron::createPolyhedron(), G4VTwistSurface::GetFacets(), HepPolyhedron::GetNumberOfRotationSteps(), n, and python.hepunit::twopi.

Referenced by GetPolyhedron().

 {
   // 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;
 }

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

protected

Definition at line 476 of file G4VTwistedFaceted.cc.

References G4VSolid::DumpInfo(), FatalException, G4Exception(), and G4AffineTransform::TransformPoint().

Referenced by CalculateExtent().

 {
 
   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;
 }

void G4VTwistedFaceted::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

virtual

Implements G4VSolid.

Definition at line 1106 of file G4VTwistedFaceted.cc.

References G4VGraphicsScene::AddSolid().

 {
   scene.AddSolid (*this);
 }

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

virtual

Implements G4VSolid.

Definition at line 669 of file G4VTwistedFaceted.cc.

References G4VTwistSurface::DistanceToIn(), G4cout, G4endl, Inside(), kInside, kSurface, CLHEP::Hep3Vector::set(), SurfaceNormal(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

 {
 
    // 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;
 }

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

virtual

Implements G4VSolid.

Definition at line 768 of file G4VTwistedFaceted.cc.

References G4VTwistSurface::DistanceTo(), FatalException, G4Exception(), Inside(), kInside, kOutside, kSurface, CLHEP::Hep3Vector::set(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

 {
    // 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;
 }

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 858 of file G4VTwistedFaceted.cc.

References G4VTwistSurface::DistanceToOut(), G4VTwistSurface::GetNormal(), Inside(), G4VTwistSurface::IsValidNorm(), kOutside, kSurface, CLHEP::Hep3Vector::set(), SurfaceNormal(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

 {
    // 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;
 }

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

virtual

Implements G4VSolid.

Definition at line 963 of file G4VTwistedFaceted.cc.

References G4VTwistSurface::DistanceTo(), G4VSolid::DumpInfo(), FatalException, G4cout, G4endl, G4Exception(), Inside(), JustWarning, kInside, kOutside, kSurface, python.hepunit::mm, CLHEP::Hep3Vector::set(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

 {
    // 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;
 }

G4double G4VTwistedFaceted::GetAlpha ( ) const

inline

Definition at line 130 of file G4VTwistedFaceted.hh.

Referenced by G4TwistedTrap::GetTiltAngleAlpha().

130 { return fAlph ; }

G4double G4VTwistedFaceted::GetCubicVolume ( )

inlinevirtual

Reimplemented from G4VSolid.

Definition at line 312 of file G4VTwistedFaceted.hh.

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

G4double G4VTwistedFaceted::GetDx1 ( ) const

inline

Definition at line 121 of file G4VTwistedFaceted.hh.

Referenced by G4TwistedTrd::GetX1HalfLength(), G4TwistedTrap::GetX1HalfLength(), and G4TwistedBox::GetXHalfLength().

121 { return fDx1 ; }

G4double G4VTwistedFaceted::GetDx2 ( ) const

inline

Definition at line 122 of file G4VTwistedFaceted.hh.

Referenced by G4TwistedTrap::GetX2HalfLength().

122 { return fDx2 ; }

G4double G4VTwistedFaceted::GetDx3 ( ) const

inline

Definition at line 123 of file G4VTwistedFaceted.hh.

Referenced by G4TwistedTrd::GetX2HalfLength(), and G4TwistedTrap::GetX3HalfLength().

123 { return fDx3 ; }

G4double G4VTwistedFaceted::GetDx4 ( ) const

inline

Definition at line 124 of file G4VTwistedFaceted.hh.

Referenced by G4TwistedTrap::GetX4HalfLength().

124 { return fDx4 ; }

G4double G4VTwistedFaceted::GetDy1 ( ) const

inline

Definition at line 125 of file G4VTwistedFaceted.hh.

Referenced by G4TwistedTrd::GetY1HalfLength(), G4TwistedTrap::GetY1HalfLength(), and G4TwistedBox::GetYHalfLength().

125 { return fDy1 ; }

G4double G4VTwistedFaceted::GetDy2 ( ) const

inline

Definition at line 126 of file G4VTwistedFaceted.hh.

Referenced by G4TwistedTrd::GetY2HalfLength(), and G4TwistedTrap::GetY2HalfLength().

126 { return fDy2 ; }

G4double G4VTwistedFaceted::GetDz ( ) const

inline

Definition at line 127 of file G4VTwistedFaceted.hh.

Referenced by G4TwistedBox::GetZHalfLength(), G4TwistedTrd::GetZHalfLength(), and G4TwistedTrap::GetZHalfLength().

127 { return fDz ; }

G4GeometryType G4VTwistedFaceted::GetEntityType ( ) const

virtual

Implements G4VSolid.

Reimplemented in G4TwistedTrap, G4TwistedTrd, and G4TwistedBox.

Definition at line 1176 of file G4VTwistedFaceted.cc.

 {
   return G4String("G4VTwistedFaceted");
 }

G4VisExtent G4VTwistedFaceted::GetExtent ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1114 of file G4VTwistedFaceted.cc.

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

G4double G4VTwistedFaceted::GetPhi ( ) const

inline

Definition at line 128 of file G4VTwistedFaceted.hh.

Referenced by G4TwistedTrap::GetAzimuthalAnglePhi().

128 { return fPhi ; }

G4ThreeVector G4VTwistedFaceted::GetPointInSolid ( G4double z ) const

Definition at line 1202 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 ) ;
 }

G4ThreeVector G4VTwistedFaceted::GetPointOnSurface ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1221 of file G4VTwistedFaceted.cc.

References G4cout, G4endl, G4VTwistSurface::GetBoundaryMax(), G4VTwistSurface::GetBoundaryMin(), G4VTwistSurface::GetSurfaceArea(), G4INCL::DeJongSpin::shoot(), and G4VTwistSurface::SurfacePoint().

 {
 
   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
 
   }
 }

G4Polyhedron * G4VTwistedFaceted::GetPolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1185 of file G4VTwistedFaceted.cc.

References CreatePolyhedron(), HepPolyhedron::GetNumberOfRotationSteps(), and G4Polyhedron::GetNumberOfRotationStepsAtTimeOfCreation().

 {
   if (!fpPolyhedron ||
       fpPolyhedron->GetNumberOfRotationStepsAtTimeOfCreation() !=
       fpPolyhedron->GetNumberOfRotationSteps())
     {
       delete fpPolyhedron;
       fpPolyhedron = CreatePolyhedron();
     }
 
   return fpPolyhedron;
 }

G4double G4VTwistedFaceted::GetSurfaceArea ( )

inlinevirtual

Reimplemented from G4VSolid.

Definition at line 321 of file G4VTwistedFaceted.hh.

References G4VSolid::GetSurfaceArea().

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

G4double G4VTwistedFaceted::GetTheta ( ) const

inline

Definition at line 129 of file G4VTwistedFaceted.hh.

Referenced by G4TwistedTrap::GetPolarAngleTheta().

129 { return fTheta ; }

G4double G4VTwistedFaceted::GetTwistAngle ( ) const

inline

Definition at line 119 of file G4VTwistedFaceted.hh.

Referenced by G4TwistedBox::GetPhiTwist(), G4TwistedTrd::GetPhiTwist(), and G4TwistedTrap::GetPhiTwist().

119 { return fPhiTwist; }

G4double G4VTwistedFaceted::GetValueA ( G4double phi ) const

inline

Definition at line 329 of file G4VTwistedFaceted.hh.

Referenced by Xcoef().

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

G4double G4VTwistedFaceted::GetValueB ( G4double phi ) const

inline

Definition at line 341 of file G4VTwistedFaceted.hh.

Referenced by Inside(), and Xcoef().

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

G4double G4VTwistedFaceted::GetValueD ( G4double phi ) const

inline

Definition at line 335 of file G4VTwistedFaceted.hh.

Referenced by Xcoef().

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

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

virtual

Implements G4VSolid.

Definition at line 518 of file G4VTwistedFaceted.cc.

References G4cout, G4endl, GetValueB(), G4VSolid::kCarTolerance, kInside, kOutside, kSurface, CLHEP::Hep3Vector::set(), CLHEP::Hep3Vector::x(), Xcoef(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

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

 {
 
    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;
 
 }

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

Definition at line 244 of file G4VTwistedFaceted.cc.

References G4VSolid::operator=().

Referenced by G4TwistedBox::operator=(), G4TwistedTrd::operator=(), and G4TwistedTrap::operator=().

 {
    // 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;
    fpPolyhedron= 0;
    fLastInside= rhs.fLastInside; fLastNormal= rhs.fLastNormal;
    fLastDistanceToIn= rhs.fLastDistanceToIn;
    fLastDistanceToOut= rhs.fLastDistanceToOut;
    fLastDistanceToInWithV= rhs.fLastDistanceToInWithV;
    fLastDistanceToOutWithV= rhs.fLastDistanceToOutWithV;
  
    CreateSurfaces();
 
    return *this;
 }

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

virtual

Implements G4VSolid.

Reimplemented in G4TwistedTrap, G4TwistedTrd, and G4TwistedBox.

Definition at line 1069 of file G4VTwistedFaceted.cc.

References python.hepunit::cm, python.hepunit::degree, G4endl, and G4VSolid::GetName().

 {
   //
   // 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;
 }

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

virtual

Implements G4VSolid.

Definition at line 615 of file G4VTwistedFaceted.cc.

References G4VTwistSurface::DistanceTo(), G4VTwistSurface::GetNormal(), CLHEP::Hep3Vector::set(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by DistanceToIn(), and DistanceToOut().

 {
    //
    // 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;
 }

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

inline

Definition at line 347 of file G4VTwistedFaceted.hh.

References GetValueA(), GetValueB(), and GetValueD().

Referenced by Inside().

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

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

Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation