#include <G4VTwistedFaceted.hh>

Inheritance diagram for G4VTwistedFaceted:

Collaboration 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 void	Extent (G4ThreeVector &pMin, G4ThreeVector &pMax) const

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 Attributes
G4bool	fRebuildPolyhedron

G4Polyhedron *	fpPolyhedron

Protected Attributes inherited from G4VSolid
G4double	kCarTolerance

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

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

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

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

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 71 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:

G4VTwistedFaceted::~G4VTwistedFaceted ( )

virtual

Definition at line 218 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::G4VTwistedFaceted ( __void__ & a )

Definition at line 203 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::G4VTwistedFaceted ( const G4VTwistedFaceted & rhs )

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

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

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

Here is the call graph for this function:

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

virtual

Reimplemented from G4VSolid.

Definition at line 292 of file G4VTwistedFaceted.cc.

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

Here is the call graph for this function:

G4Polyhedron * G4VTwistedFaceted::CreatePolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1151 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:

void G4VTwistedFaceted::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

virtual

Implements G4VSolid.

Definition at line 934 of file G4VTwistedFaceted.cc.

 {
   scene.AddSolid (*this);
 }

Here is the call graph for this function:

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

virtual

Implements G4VSolid.

Definition at line 491 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:

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

virtual

Implements G4VSolid.

Definition at line 593 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:

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 683 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:

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

virtual

Implements G4VSolid.

Definition at line 791 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:

void G4VTwistedFaceted::Extent	(	G4ThreeVector &	pMin,
		G4ThreeVector &	pMax
	)		const

virtual

Reimplemented from G4VSolid.

Definition at line 305 of file G4VTwistedFaceted.cc.

 {
   G4double maxRad = std::sqrt(fDx*fDx + fDy*fDy);
   pMin.set(-maxRad,-maxRad,-fDz);
   pMax.set( maxRad, maxRad, fDz);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4VTwistedFaceted::GetAlpha ( ) const

inline

Definition at line 132 of file G4VTwistedFaceted.hh.

132 { return fAlph ; }

Here is the caller graph for this function:

G4double G4VTwistedFaceted::GetCubicVolume ( )

inlinevirtual

Reimplemented from G4VSolid.

Definition at line 310 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 123 of file G4VTwistedFaceted.hh.

123 { return fDx1 ; }

Here is the caller graph for this function:

G4double G4VTwistedFaceted::GetDx2 ( ) const

inline

Definition at line 124 of file G4VTwistedFaceted.hh.

124 { return fDx2 ; }

Here is the caller graph for this function:

G4double G4VTwistedFaceted::GetDx3 ( ) const

inline

Definition at line 125 of file G4VTwistedFaceted.hh.

125 { return fDx3 ; }

Here is the caller graph for this function:

G4double G4VTwistedFaceted::GetDx4 ( ) const

inline

Definition at line 126 of file G4VTwistedFaceted.hh.

126 { return fDx4 ; }

Here is the caller graph for this function:

G4double G4VTwistedFaceted::GetDy1 ( ) const

inline

Definition at line 127 of file G4VTwistedFaceted.hh.

127 { return fDy1 ; }

Here is the caller graph for this function:

G4double G4VTwistedFaceted::GetDy2 ( ) const

inline

Definition at line 128 of file G4VTwistedFaceted.hh.

128 { return fDy2 ; }

Here is the caller graph for this function:

G4double G4VTwistedFaceted::GetDz ( ) const

inline

Definition at line 129 of file G4VTwistedFaceted.hh.

129 { return fDz ; }

Here is the caller graph for this function:

G4GeometryType G4VTwistedFaceted::GetEntityType ( ) const

virtual

Implements G4VSolid.

Reimplemented in G4TwistedTrap, G4TwistedTrd, and G4TwistedBox.

Definition at line 1005 of file G4VTwistedFaceted.cc.

 {
   return G4String("G4VTwistedFaceted");
 }

G4VisExtent G4VTwistedFaceted::GetExtent ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 943 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 130 of file G4VTwistedFaceted.hh.

130 { return fPhi ; }

Here is the caller graph for this function:

G4ThreeVector G4VTwistedFaceted::GetPointInSolid ( G4double z ) const

Definition at line 1035 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 1054 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:

G4Polyhedron * G4VTwistedFaceted::GetPolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1014 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:

G4double G4VTwistedFaceted::GetSurfaceArea ( )

inlinevirtual

Reimplemented from G4VSolid.

Definition at line 319 of file G4VTwistedFaceted.hh.

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

Here is the call graph for this function:

G4double G4VTwistedFaceted::GetTheta ( ) const

inline

Definition at line 131 of file G4VTwistedFaceted.hh.

131 { return fTheta ; }

Here is the caller graph for this function:

G4double G4VTwistedFaceted::GetTwistAngle ( ) const

inline

Definition at line 121 of file G4VTwistedFaceted.hh.

121 { return fPhiTwist; }

Here is the caller graph for this function:

G4double G4VTwistedFaceted::GetValueA ( G4double phi ) const

inline

Definition at line 327 of file G4VTwistedFaceted.hh.

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

Here is the caller graph for this function:

G4double G4VTwistedFaceted::GetValueB ( G4double phi ) const

inline

Definition at line 339 of file G4VTwistedFaceted.hh.

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

Here is the caller graph for this function:

G4double G4VTwistedFaceted::GetValueD ( G4double phi ) const

inline

Definition at line 333 of file G4VTwistedFaceted.hh.

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

Here is the caller graph for this function:

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

virtual

Implements G4VSolid.

Definition at line 338 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:

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

Definition at line 256 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:

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

virtual

Implements G4VSolid.

Reimplemented in G4TwistedTrap, G4TwistedTrd, and G4TwistedBox.

Definition at line 897 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:

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

virtual

Implements G4VSolid.

Definition at line 436 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:

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

inline

Definition at line 345 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

G4Polyhedron* G4VTwistedFaceted::fpPolyhedron

mutableprotected

Definition at line 158 of file G4VTwistedFaceted.hh.

G4bool G4VTwistedFaceted::fRebuildPolyhedron

mutableprotected

Definition at line 157 of file G4VTwistedFaceted.hh.

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

geant4.10.03.p01/source/geometry/solids/specific/include/G4VTwistedFaceted.hh
geant4.10.03.p01/source/geometry/solids/specific/src/G4VTwistedFaceted.cc

Public Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation