#include <G4Orb.hh>

Inheritance diagram for G4Orb:

Public Member Functions
	G4Orb (const G4String &pName, G4double pRmax)

virtual	~G4Orb ()

G4double	GetRadius () const

void	SetRadius (G4double newRmax)

G4double	GetCubicVolume ()

G4double	GetSurfaceArea ()

void	ComputeDimensions (G4VPVParameterisation p, const G4int n, const G4VPhysicalVolume pRep)

G4bool	CalculateExtent (const EAxis pAxis, const G4VoxelLimits &pVoxelLimit, const G4AffineTransform &pTransform, G4double &pmin, G4double &pmax) const

EInside	Inside (const G4ThreeVector &p) const

G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const

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

G4double	DistanceToIn (const G4ThreeVector &p) const

G4double	DistanceToOut (const G4ThreeVector &p, const G4ThreeVector &v, const G4bool calcNorm=G4bool(false), G4bool validNorm=0, G4ThreeVector n=0) const

G4double	DistanceToOut (const G4ThreeVector &p) const

G4GeometryType	GetEntityType () const

G4ThreeVector	GetPointOnSurface () const

G4VSolid *	Clone () const

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

void	DescribeYourselfTo (G4VGraphicsScene &scene) const

G4Polyhedron *	CreatePolyhedron () const

	G4Orb (__void__ &)

	G4Orb (const G4Orb &rhs)

G4Orb &	operator= (const G4Orb &rhs)

Public Member Functions inherited from G4CSGSolid
	G4CSGSolid (const G4String &pName)

virtual	~G4CSGSolid ()

virtual G4Polyhedron *	GetPolyhedron () const

	G4CSGSolid (__void__ &)

	G4CSGSolid (const G4CSGSolid &rhs)

G4CSGSolid &	operator= (const G4CSGSolid &rhs)

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

virtual	~G4VSolid ()

G4bool	operator== (const G4VSolid &s) const

G4String	GetName () const

void	SetName (const G4String &name)

G4double	GetTolerance () const

void	DumpInfo () const

virtual G4VisExtent	GetExtent () 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 Types
enum	ESide { kNull, kRMax }

enum	ENorm { kNRMax }

Additional Inherited Members
Protected Member Functions inherited from G4CSGSolid
G4double	GetRadiusInRing (G4double rmin, G4double rmax) 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

Protected Attributes inherited from G4CSGSolid
G4double	fCubicVolume

G4double	fSurfaceArea

G4Polyhedron *	fpPolyhedron

Protected Attributes inherited from G4VSolid
G4double	kCarTolerance

Detailed Description

Definition at line 60 of file G4Orb.hh.

Member Enumeration Documentation

enum G4Orb::ENorm

protected

Enumerator
kNRMax

Definition at line 139 of file G4Orb.hh.

139 {kNRMax};

G4Orb::kNRMax

Definition: G4Orb.hh:139

enum G4Orb::ESide

protected

Enumerator
kNull
kRMax

Definition at line 135 of file G4Orb.hh.

135 {kNull,kRMax};

G4Orb::kNull

Definition: G4Orb.hh:135

G4Orb::kRMax

Definition: G4Orb.hh:135

Constructor & Destructor Documentation

G4Orb::G4Orb	(	const G4String &	pName,
		G4double	pRmax
	)

Definition at line 73 of file G4Orb.cc.

References FatalException, G4Exception(), G4GeometryTolerance::GetInstance(), G4GeometryTolerance::GetRadialTolerance(), G4VSolid::kCarTolerance, and G4INCL::Math::max().

Referenced by Clone().

 : G4CSGSolid(pName), fRmax(pRmax)
 {
 
   const G4double fEpsilon = 2.e-11;  // relative tolerance of fRmax
 
   G4double kRadTolerance
     = G4GeometryTolerance::GetInstance()->GetRadialTolerance();
 
   // Check radius
   //
   if ( pRmax < 10*kCarTolerance )
   {
     G4Exception("G4Orb::G4Orb()", "GeomSolids0002", FatalException,
                 "Invalid radius > 10*kCarTolerance.");
   }
   fRmaxTolerance =  std::max( kRadTolerance, fEpsilon*fRmax);
 
 }

G4Orb::~G4Orb ( )

virtual

Definition at line 107 of file G4Orb.cc.

108 {

109 }

G4Orb::G4Orb ( __void__ & a )

Definition at line 98 of file G4Orb.cc.

   : G4CSGSolid(a), fRmax(0.), fRmaxTolerance(0.)
 {
 }

G4Orb::G4Orb ( const G4Orb & rhs )

Definition at line 115 of file G4Orb.cc.

   : G4CSGSolid(rhs), fRmax(rhs.fRmax), fRmaxTolerance(rhs.fRmaxTolerance)
 {
 }

Member Function Documentation

G4bool G4Orb::CalculateExtent	(	const EAxis	pAxis,
		const G4VoxelLimits &	pVoxelLimit,
		const G4AffineTransform &	pTransform,
		G4double &	pmin,
		G4double &	pmax
	)		const

virtual

Implements G4VSolid.

Definition at line 158 of file G4Orb.cc.

References G4VoxelLimits::GetMaxXExtent(), G4VoxelLimits::GetMaxYExtent(), G4VoxelLimits::GetMaxZExtent(), G4VoxelLimits::GetMinXExtent(), G4VoxelLimits::GetMinYExtent(), G4VoxelLimits::GetMinZExtent(), G4VoxelLimits::IsXLimited(), G4VoxelLimits::IsYLimited(), G4VoxelLimits::IsZLimited(), G4VSolid::kCarTolerance, kXAxis, kYAxis, kZAxis, G4AffineTransform::NetTranslation(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

 {
     // Compute x/y/z mins and maxs for bounding box respecting limits,
     // with early returns if outside limits. Then switch() on pAxis,
     // and compute exact x and y limit for x/y case
       
     G4double xoffset,xMin,xMax;
     G4double yoffset,yMin,yMax;
     G4double zoffset,zMin,zMax;
 
     G4double diff1,diff2,delta,maxDiff,newMin,newMax;
     G4double xoff1,xoff2,yoff1,yoff2;
 
     xoffset=pTransform.NetTranslation().x();
     xMin=xoffset-fRmax;
     xMax=xoffset+fRmax;
 
     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-fRmax;
     yMax=yoffset+fRmax;
 
     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-fRmax;
     zMax=zoffset+fRmax;
 
     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();
         }
       }
     }
 
     // Known to cut sphere
 
     switch (pAxis)
     {
       case kXAxis:
         yoff1=yoffset-yMin;
         yoff2=yMax-yoffset;
 
         if ( yoff1 >= 0 && yoff2 >= 0 )
         {
           // Y limits cross max/min x => no change
           //
           pMin=xMin;
           pMax=xMax;
         }
         else
         {
           // Y limits don't cross max/min x => compute max delta x,
           // hence new mins/maxs
           //
           delta=fRmax*fRmax-yoff1*yoff1;
           diff1=(delta>0.) ? std::sqrt(delta) : 0.;
           delta=fRmax*fRmax-yoff2*yoff2;
           diff2=(delta>0.) ? std::sqrt(delta) : 0.;
           maxDiff=(diff1>diff2) ? diff1:diff2;
           newMin=xoffset-maxDiff;
           newMax=xoffset+maxDiff;
           pMin=(newMin<xMin) ? xMin : newMin;
           pMax=(newMax>xMax) ? xMax : newMax;
         }
         break;
       case kYAxis:
         xoff1=xoffset-xMin;
         xoff2=xMax-xoffset;
         if (xoff1>=0&&xoff2>=0)
         {
           // X limits cross max/min y => no change
           //
           pMin=yMin;
           pMax=yMax;
         }
         else
         {
           // X limits don't cross max/min y => compute max delta y,
           // hence new mins/maxs
           //
           delta=fRmax*fRmax-xoff1*xoff1;
           diff1=(delta>0.) ? std::sqrt(delta) : 0.;
           delta=fRmax*fRmax-xoff2*xoff2;
           diff2=(delta>0.) ? std::sqrt(delta) : 0.;
           maxDiff=(diff1>diff2) ? diff1:diff2;
           newMin=yoffset-maxDiff;
           newMax=yoffset+maxDiff;
           pMin=(newMin<yMin) ? yMin : newMin;
           pMax=(newMax>yMax) ? yMax : newMax;
         }
         break;
       case kZAxis:
         pMin=zMin;
         pMax=zMax;
         break;
       default:
         break;
     }
     pMin -= fRmaxTolerance;
     pMax += fRmaxTolerance;
 
     return true;  
   
 }

G4VSolid * G4Orb::Clone ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 665 of file G4Orb.cc.

References G4Orb().

 {
   return new G4Orb(*this);
 }

void G4Orb::ComputeDimensions	(	G4VPVParameterisation *	p,
		const G4int	n,
		const G4VPhysicalVolume *	pRep
	)

virtual

Reimplemented from G4VSolid.

Definition at line 147 of file G4Orb.cc.

References G4VPVParameterisation::ComputeDimensions().

 {
   p->ComputeDimensions(*this,n,pRep);
 }

G4Polyhedron * G4Orb::CreatePolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 719 of file G4Orb.cc.

References python.hepunit::pi.

 {
   return new G4PolyhedronSphere (0., fRmax, 0., 2*pi, 0., pi);
 }

void G4Orb::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

virtual

Implements G4VSolid.

Definition at line 714 of file G4Orb.cc.

References G4VGraphicsScene::AddSolid().

 {
   scene.AddSolid (*this);
 }

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

virtual

Implements G4VSolid.

Definition at line 383 of file G4Orb.cc.

References test::c, G4Exception(), JustWarning, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

 {
   G4double snxt = kInfinity;      // snxt = default return value
 
   G4double radius, pDotV3d; // , tolORMax2, tolIRMax2;
   G4double c, d2, sd = kInfinity;
 
   const G4double dRmax = 100.*fRmax;
 
   // General Precalcs
 
   radius  = std::sqrt(p.x()*p.x() + p.y()*p.y() + p.z()*p.z());
   pDotV3d = p.x()*v.x() + p.y()*v.y() + p.z()*v.z();
 
   // Radial Precalcs
 
   // tolORMax2 = (fRmax+fRmaxTolerance*0.5)*(fRmax+fRmaxTolerance*0.5);
   // tolIRMax2 = (fRmax-fRmaxTolerance*0.5)*(fRmax-fRmaxTolerance*0.5);
 
   // Outer spherical shell intersection
   // - Only if outside tolerant fRmax
   // - Check for if inside and outer G4Orb heading through solid (-> 0)
   // - No intersect -> no intersection with G4Orb
   //
   // Shell eqn: x^2+y^2+z^2 = RSPH^2
   //
   // => (px+svx)^2+(py+svy)^2+(pz+svz)^2=R^2
   //
   // => (px^2+py^2+pz^2) +2sd(pxvx+pyvy+pzvz)+sd^2(vx^2+vy^2+vz^2)=R^2
   // =>      rad2        +2sd(pDotV3d)      +sd^2                =R^2
   //
   // => sd=-pDotV3d+-std::sqrt(pDotV3d^2-(rad2-R^2))
 
   c = (radius - fRmax)*(radius + fRmax);
 
   if( radius > fRmax-fRmaxTolerance*0.5 ) // not inside in terms of Inside(p)
   {
     if ( c > fRmaxTolerance*fRmax )
     {
       // If outside tolerant boundary of outer G4Orb in terms of c
       // [ should be std::sqrt(rad2) - fRmax > fRmaxTolerance*0.5 ]
 
       d2 = pDotV3d*pDotV3d - c;
 
       if ( d2 >= 0 )
       {
         sd = -pDotV3d - std::sqrt(d2);
         if ( sd >= 0 )
         {
           if ( sd > dRmax ) // Avoid rounding errors due to precision issues seen on
           {                 // 64 bits systems. Split long distances and recompute
             G4double fTerm = sd - std::fmod(sd,dRmax);
             sd = fTerm + DistanceToIn(p+fTerm*v,v);
           } 
           return snxt = sd;
         }
       }
       else    // No intersection with G4Orb
       {
         return snxt = kInfinity;
       }
     }
     else // not outside in terms of c
     {
       if ( c > -fRmaxTolerance*fRmax )  // on surface  
       {
         d2 = pDotV3d*pDotV3d - c;             
         if ( (d2 < fRmaxTolerance*fRmax) || (pDotV3d >= 0) )
         {
           return snxt = kInfinity;
         }
         else
         {
           return snxt = 0.;
         }
       }
     }
   }
 #ifdef G4CSGDEBUG
   else // inside ???
   {
       G4Exception("G4Orb::DistanceToIn(p,v)", "GeomSolids1002",
                   JustWarning, "Point p is inside !?");
   }
 #endif
 
   return snxt;
 }

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

virtual

Implements G4VSolid.

Definition at line 479 of file G4Orb.cc.

References CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

 {
   G4double safe = 0.0,
            radius  = std::sqrt(p.x()*p.x()+p.y()*p.y()+p.z()*p.z());
   safe = radius - fRmax;
   if( safe < 0 ) { safe = 0.; }
   return safe;
 }

G4double G4Orb::DistanceToOut	(	const G4ThreeVector &	p,
		const G4ThreeVector &	v,
		const G4bool	calcNorm = `G4bool(false)`,
		G4bool *	validNorm = `0`,
		G4ThreeVector *	n = `0`
	)		const

virtual

Implements G4VSolid.

Definition at line 493 of file G4Orb.cc.

References test::c, G4VSolid::DumpInfo(), G4cout, G4endl, G4Exception(), JustWarning, kNull, kRMax, python.hepunit::mm, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

 {
   G4double snxt = kInfinity;     // ??? snxt is default return value
   ESide    side = kNull;
   
   G4double rad2,pDotV3d; 
   G4double xi,yi,zi;      // Intersection point
   G4double c,d2;
                  
   rad2    = p.x()*p.x() + p.y()*p.y() + p.z()*p.z();
   pDotV3d = p.x()*v.x() + p.y()*v.y() + p.z()*v.z();
     
   // Radial Intersection from G4Orb::DistanceToIn
   //
   // Outer spherical shell intersection
   // - Only if outside tolerant fRmax
   // - Check for if inside and outer G4Orb heading through solid (-> 0)
   // - No intersect -> no intersection with G4Orb
   //
   // Shell eqn: x^2+y^2+z^2=RSPH^2
   //
   // => (px+svx)^2+(py+svy)^2+(pz+svz)^2=R^2
   //
   // => (px^2+py^2+pz^2) +2s(pxvx+pyvy+pzvz)+s^2(vx^2+vy^2+vz^2)=R^2
   // =>      rad2        +2s(pDotV3d)       +s^2                =R^2
   //
   // => s=-pDotV3d+-std::sqrt(pDotV3d^2-(rad2-R^2))
   
   const G4double  Rmax_plus = fRmax + fRmaxTolerance*0.5;
   G4double radius = std::sqrt(rad2);
 
   if ( radius <= Rmax_plus )
   {
     c = (radius - fRmax)*(radius + fRmax);
 
     if ( c < fRmaxTolerance*fRmax ) 
     {
       // Within tolerant Outer radius 
       // 
       // The test is
       //     radius  - fRmax < 0.5*fRmaxTolerance
       // =>  radius  < fRmax + 0.5*kRadTol
       // =>  rad2 < (fRmax + 0.5*kRadTol)^2
       // =>  rad2 < fRmax^2 + 2.*0.5*fRmax*kRadTol + 0.25*kRadTol*kRadTol
       // =>  rad2 - fRmax^2    <~    fRmax*kRadTol 
 
       d2 = pDotV3d*pDotV3d - c;
 
       if( ( c > -fRmaxTolerance*fRmax) &&         // on tolerant surface
           ( ( pDotV3d >= 0 )   || ( d2 < 0 )) )   // leaving outside from Rmax 
                                                   // not re-entering
       {
         if(calcNorm)
         {
           *validNorm = true;
           *n         = G4ThreeVector(p.x()/fRmax,p.y()/fRmax,p.z()/fRmax);
         }
         return snxt = 0;
       }
       else 
       {
         snxt = -pDotV3d + std::sqrt(d2);    // second root since inside Rmax
         side = kRMax; 
       }
     }
   }
   else // p is outside ???
   {
     G4cout << G4endl;
     DumpInfo();
     std::ostringstream message;
     G4int oldprc = message.precision(16);
     message << "Logic error: snxt = kInfinity ???" << G4endl
             << "Position:"  << G4endl << G4endl
             << "p.x() = "   << p.x()/mm << " mm" << G4endl
             << "p.y() = "   << p.y()/mm << " mm" << G4endl
             << "p.z() = "   << p.z()/mm << " mm" << G4endl << G4endl
             << "Rp = "<< std::sqrt( p.x()*p.x()+p.y()*p.y()+p.z()*p.z() )/mm
             << " mm" << G4endl << G4endl
             << "Direction:" << G4endl << G4endl
             << "v.x() = "   << v.x() << G4endl
             << "v.y() = "   << v.y() << G4endl
             << "v.z() = "   << v.z() << G4endl << G4endl
             << "Proposed distance :" << G4endl << G4endl
             << "snxt = "    << snxt/mm << " mm" << G4endl;
     message.precision(oldprc);
     G4Exception("G4Orb::DistanceToOut(p,v,..)", "GeomSolids1002",
                 JustWarning, message);
   }
   if (calcNorm)    // Output switch operator
   {
     switch( side )
     {
       case kRMax:
         xi=p.x()+snxt*v.x();
         yi=p.y()+snxt*v.y();
         zi=p.z()+snxt*v.z();
         *n=G4ThreeVector(xi/fRmax,yi/fRmax,zi/fRmax);
         *validNorm=true;
         break;
       default:
         G4cout << G4endl;
         DumpInfo();
         std::ostringstream message;
         G4int oldprc = message.precision(16);
         message << "Undefined side for valid surface normal to solid."
                 << G4endl
                 << "Position:"  << G4endl << G4endl
                 << "p.x() = "   << p.x()/mm << " mm" << G4endl
                 << "p.y() = "   << p.y()/mm << " mm" << G4endl
                 << "p.z() = "   << p.z()/mm << " mm" << G4endl << G4endl
                 << "Direction:" << G4endl << G4endl
                 << "v.x() = "   << v.x() << G4endl
                 << "v.y() = "   << v.y() << G4endl
                 << "v.z() = "   << v.z() << G4endl << G4endl
                 << "Proposed distance :" << G4endl << G4endl
                 << "snxt = "    << snxt/mm << " mm" << G4endl;
         message.precision(oldprc);
         G4Exception("G4Orb::DistanceToOut(p,v,..)","GeomSolids1002",
                     JustWarning, message);
         break;
     }
   }
   return snxt;
 }

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

virtual

Implements G4VSolid.

Definition at line 627 of file G4Orb.cc.

References G4VSolid::DumpInfo(), G4cout, G4endl, G4Exception(), Inside(), JustWarning, kOutside, python.hepunit::mm, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

 {
   G4double safe=0.0,radius = std::sqrt(p.x()*p.x()+p.y()*p.y()+p.z()*p.z());
 
 #ifdef G4CSGDEBUG
   if( Inside(p) == kOutside )
   {
      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("G4Orb::DistanceToOut(p)", "GeomSolids1002",
                  JustWarning, "Point p is outside !?" );
   }
 #endif
 
   safe = fRmax - radius;
   if ( safe < 0. ) safe = 0.;
   return safe;
 }

G4double G4Orb::GetCubicVolume ( )

inlinevirtual

Reimplemented from G4VSolid.

G4GeometryType G4Orb::GetEntityType ( ) const

virtual

Implements G4VSolid.

Definition at line 656 of file G4Orb.cc.

 {
   return G4String("G4Orb");
 }

G4ThreeVector G4Orb::GetPointOnSurface ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 694 of file G4Orb.cc.

References python.hepunit::pi, G4INCL::DeJongSpin::shoot(), and sqr().

 {
   //  generate a random number from zero to 2pi...
   //
   G4double phi      = RandFlat::shoot(0.,2.*pi);
   G4double cosphi   = std::cos(phi);
   G4double sinphi   = std::sin(phi);
 
   // generate a random point uniform in area
   G4double costheta = RandFlat::shoot(-1.,1.);
   G4double sintheta = std::sqrt(1.-sqr(costheta));
   
   return G4ThreeVector (fRmax*sintheta*cosphi,
                         fRmax*sintheta*sinphi, fRmax*costheta); 
 }

G4double G4Orb::GetRadius ( ) const

inline

Referenced by export_G4Orb(), G4tgbGeometryDumper::GetSolidParams(), G4GDMLWriteParamvol::Orb_dimensionsWrite(), and G4GDMLWriteSolids::OrbWrite().

G4double G4Orb::GetSurfaceArea ( )

inlinevirtual

Reimplemented from G4VSolid.

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

virtual

Implements G4VSolid.

Definition at line 321 of file G4Orb.cc.

References kInside, kOutside, kSurface, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by DistanceToOut().

 {
   G4double rad2,tolRMax;
   EInside in;
 
 
   rad2 = p.x()*p.x()+p.y()*p.y()+p.z()*p.z();
 
   G4double radius = std::sqrt(rad2);
 
   // G4double radius = std::sqrt(rad2);
   // Check radial surface
   // sets `in'
   
   tolRMax = fRmax - fRmaxTolerance*0.5;
     
   if ( radius <= tolRMax )  { in = kInside; }
   else
   {
     tolRMax = fRmax + fRmaxTolerance*0.5;       
     if ( radius <= tolRMax )  { in = kSurface; }
     else                   { in = kOutside; }
   }
   return in;
 }

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

Definition at line 124 of file G4Orb.cc.

References G4CSGSolid::operator=().

 {
    // Check assignment to self
    //
    if (this == &rhs)  { return *this; }
 
    // Copy base class data
    //
    G4CSGSolid::operator=(rhs);
 
    // Copy data
    //
    fRmax = rhs.fRmax;
    fRmaxTolerance = rhs.fRmaxTolerance;
 
    return *this;
 }

void G4Orb::SetRadius ( G4double newRmax )

inline

Referenced by export_G4Orb().

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

virtual

Reimplemented from G4CSGSolid.

Definition at line 674 of file G4Orb.cc.

References G4VSolid::GetName(), and python.hepunit::mm.

 {
   G4int oldprc = os.precision(16);
   os << "-----------------------------------------------------------\n"
      << "    *** Dump for solid - " << GetName() << " ***\n"
      << "    ===================================================\n"
      << " Solid type: G4Orb\n"
      << " Parameters: \n"
 
      << "    outer radius: " << fRmax/mm << " mm \n"
      << "-----------------------------------------------------------\n";
   os.precision(oldprc);
 
   return os;
 }

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

virtual

Implements G4VSolid.

Definition at line 353 of file G4Orb.cc.

References G4VSolid::DumpInfo(), G4Exception(), JustWarning, kNRMax, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

 {
   ENorm side = kNRMax;
   G4ThreeVector norm;
   G4double radius = std::sqrt(p.x()*p.x()+p.y()*p.y()+p.z()*p.z());
 
   switch (side)
   {
     case kNRMax: 
       norm = G4ThreeVector(p.x()/radius,p.y()/radius,p.z()/radius);
       break;
    default:        // Should never reach this case ...
       DumpInfo();
       G4Exception("G4Orb::SurfaceNormal()", "GeomSolids1002", JustWarning,
                   "Undefined side for valid surface normal to solid.");
       break;    
   } 
 
   return norm;
 }

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

Public Member Functions

Protected Types

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation