#include <G4Box.hh>

Inheritance diagram for G4Box:

Public Member Functions
	G4Box (const G4String &pName, G4double pX, G4double pY, G4double pZ)

virtual	~G4Box ()

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

G4double	GetXHalfLength () const

G4double	GetYHalfLength () const

G4double	GetZHalfLength () const

void	SetXHalfLength (G4double dx)

void	SetYHalfLength (G4double dy)

void	SetZHalfLength (G4double dz)

G4double	GetCubicVolume ()

G4double	GetSurfaceArea ()

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=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

G4VisExtent	GetExtent () const

G4Polyhedron *	CreatePolyhedron () const

	G4Box (__void__ &)

	G4Box (const G4Box &rhs)

G4Box &	operator= (const G4Box &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 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 { kUndefined, kPX, kMX, kPY, kMY, kPZ, kMZ }

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

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

Additional Inherited Members
Protected Attributes inherited from G4CSGSolid
G4double	fCubicVolume

G4double	fSurfaceArea

G4Polyhedron *	fpPolyhedron

Protected Attributes inherited from G4VSolid
G4double	kCarTolerance

Detailed Description

Definition at line 63 of file G4Box.hh.

Member Enumeration Documentation

enum G4Box::ESide

protected

Enumerator
kUndefined
kPX
kMX
kPY
kMY
kPZ
kMZ

Definition at line 139 of file G4Box.hh.

139 {kUndefined,kPX,kMX,kPY,kMY,kPZ,kMZ};

G4Box::kMX

Definition: G4Box.hh:139

G4Box::kMY

Definition: G4Box.hh:139

G4Box::kPZ

Definition: G4Box.hh:139

G4Box::kPX

Definition: G4Box.hh:139

G4Box::kUndefined

Definition: G4Box.hh:139

G4Box::kPY

Definition: G4Box.hh:139

G4Box::kMZ

Definition: G4Box.hh:139

Constructor & Destructor Documentation

G4Box::G4Box	(	const G4String &	pName,
		G4double	pX,
		G4double	pY,
		G4double	pZ
	)

Definition at line 61 of file G4Box.cc.

References FatalException, G4endl, G4Exception(), G4VSolid::GetName(), and G4VSolid::kCarTolerance.

Referenced by Clone().

   : G4CSGSolid(pName), fDx(pX), fDy(pY), fDz(pZ)
 {
   delta = 0.5*kCarTolerance;
   if ( (pX < 2*kCarTolerance)
     || (pY < 2*kCarTolerance)
     || (pZ < 2*kCarTolerance) )  // limit to thickness of surfaces
   {
     std::ostringstream message;
     message << "Dimensions too small for Solid: " << GetName() << "!" << G4endl
             << "     hX, hY, hZ = " << pX << ", " << pY << ", " << pZ;
     G4Exception("G4Box::G4Box()", "GeomSolids0002", FatalException, message);
   }
 }

G4Box::~G4Box ( )

virtual

Definition at line 93 of file G4Box.cc.

94 {

95 }

G4Box::G4Box ( __void__ & a )

Definition at line 84 of file G4Box.cc.

   : G4CSGSolid(a), fDx(0.), fDy(0.), fDz(0.), delta(0.)
 {
 }

G4Box::G4Box ( const G4Box & rhs )

Definition at line 101 of file G4Box.cc.

   : G4CSGSolid(rhs), fDx(rhs.fDx), fDy(rhs.fDy), fDz(rhs.fDz), delta(rhs.delta)
 {
 }

Member Function Documentation

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

virtual

Implements G4VSolid.

Definition at line 208 of file G4Box.cc.

 {
   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 - fDx ;
     xMax    = xoffset + fDx ;
 
     if (pVoxelLimit.IsXLimited())
     {
       if ((xMin > pVoxelLimit.GetMaxXExtent()+kCarTolerance) || 
           (xMax < pVoxelLimit.GetMinXExtent()-kCarTolerance)) { return false ; }
       else
       {
         xMin = std::max(xMin, pVoxelLimit.GetMinXExtent());
         xMax = std::min(xMax, pVoxelLimit.GetMaxXExtent());
       }
     }
     yoffset = pTransform.NetTranslation().y() ;
     yMin    = yoffset - fDy ;
     yMax    = yoffset + fDy ;
 
     if (pVoxelLimit.IsYLimited())
     {
       if ((yMin > pVoxelLimit.GetMaxYExtent()+kCarTolerance) ||
           (yMax < pVoxelLimit.GetMinYExtent()-kCarTolerance)) { return false ; }
       else
       {
         yMin = std::max(yMin, pVoxelLimit.GetMinYExtent());
         yMax = std::min(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
       {
         zMin = std::max(zMin, pVoxelLimit.GetMinZExtent());
         zMax = std::min(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;
   } 
 } 

G4VSolid * G4Box::Clone ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1029 of file G4Box.cc.

References G4Box().

 {
   return new G4Box(*this);
 }

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

virtual

Reimplemented from G4VSolid.

Definition at line 197 of file G4Box.cc.

References G4VPVParameterisation::ComputeDimensions().

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

G4Polyhedron * G4Box::CreatePolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1048 of file G4Box.cc.

Referenced by G4GMocrenFileSceneHandler::AddSolid().

 {
   return new G4PolyhedronBox (fDx, fDy, fDz);
 }

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

protected

Definition at line 918 of file G4Box.cc.

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

Referenced by CalculateExtent().

 {
   G4ThreeVectorList* vertices = new G4ThreeVectorList();
 
   if (vertices)
   {
     vertices->reserve(8);
     G4ThreeVector vertex0(-fDx,-fDy,-fDz) ;
     G4ThreeVector vertex1(fDx,-fDy,-fDz) ;
     G4ThreeVector vertex2(fDx,fDy,-fDz) ;
     G4ThreeVector vertex3(-fDx,fDy,-fDz) ;
     G4ThreeVector vertex4(-fDx,-fDy,fDz) ;
     G4ThreeVector vertex5(fDx,-fDy,fDz) ;
     G4ThreeVector vertex6(fDx,fDy,fDz) ;
     G4ThreeVector vertex7(-fDx,fDy,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("G4Box::CreateRotatedVertices()",
                 "GeomSolids0003", FatalException,
                 "Error in allocation of vertices. Out of memory !");
   }
   return vertices;
 }

void G4Box::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

virtual

Implements G4VSolid.

Definition at line 1038 of file G4Box.cc.

References G4VGraphicsScene::AddSolid().

 {
   scene.AddSolid (*this);
 }

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

virtual

Implements G4VSolid.

Definition at line 556 of file G4Box.cc.

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

Referenced by G4SurfaceVoxelizer::DistanceToFirst().

 {
   G4double safx, safy, safz ;
   G4double smin=0.0, sminy, sminz ; // , sminx ;
   G4double smax=kInfinity, smaxy, smaxz ; // , smaxx ;  // they always > 0
   G4double stmp ;
   G4double sOut=kInfinity, sOuty=kInfinity, sOutz=kInfinity ;
 
   safx = std::fabs(p.x()) - fDx ;     // minimum distance to x surface of shape
   safy = std::fabs(p.y()) - fDy ;
   safz = std::fabs(p.z()) - fDz ;
 
   // Will we intersect?
   // If safx/y/z is >-tol/2 the point is outside/on the box's x/y/z extent.
   // If both p.x/y/z and v.x/y/z repectively are both positive/negative,
   // travel is in a direction away from the shape.
 
   if (    ((p.x()*v.x() >= 0.0) && (safx > -delta)) 
        || ((p.y()*v.y() >= 0.0) && (safy > -delta))
        || ((p.z()*v.z() >= 0.0) && (safz > -delta))   ) 
   {
     return kInfinity ;  // travel away or parallel within tolerance
   }
 
   // Compute min / max distances for x/y/z travel:
   // X Planes
 
   if ( v.x() )  // != 0
   {
     stmp = 1.0/std::fabs(v.x()) ;
 
     if (safx >= 0.0)
     {
       smin = safx*stmp ;
       smax = (fDx+std::fabs(p.x()))*stmp ;
     }
     else
     {
       if (v.x() < 0)  { sOut = (fDx + p.x())*stmp ; }
       else            { sOut = (fDx - p.x())*stmp ; }
     }
   }
 
   // Y Planes
 
   if ( v.y() )  // != 0
   {
     stmp = 1.0/std::fabs(v.y()) ;
 
     if (safy >= 0.0)
     {
       sminy = safy*stmp ;
       smaxy = (fDy+std::fabs(p.y()))*stmp ;
 
       if (sminy > smin) { smin=sminy ; }
       if (smaxy < smax) { smax=smaxy ; }
 
       if (smin >= (smax-delta))
       {
         return kInfinity ;  // touch XY corner
       }
     }
     else
     {
       if (v.y() < 0)  { sOuty = (fDy + p.y())*stmp ; }
       else            { sOuty = (fDy - p.y())*stmp ; }
       if( sOuty < sOut ) { sOut = sOuty ; }
     }     
   }
 
   // Z planes
 
   if ( v.z() )  // != 0
   {
     stmp = 1.0/std::fabs(v.z()) ;
 
     if ( safz >= 0.0 )
     {
       sminz = safz*stmp ;
       smaxz = (fDz+std::fabs(p.z()))*stmp ;
 
       if (sminz > smin) { smin = sminz ; }
       if (smaxz < smax) { smax = smaxz ; }
 
       if (smin >= (smax-delta))
       { 
         return kInfinity ;    // touch ZX or ZY corners
       }
     }
     else
     {
       if (v.z() < 0)  { sOutz = (fDz + p.z())*stmp ; }
       else            { sOutz = (fDz - p.z())*stmp ; }
       if( sOutz < sOut ) { sOut = sOutz ; }
     }
   }
 
   if (sOut <= (smin + delta)) // travel over edge
   {
     return kInfinity ;
   }
   if (smin < delta)  { smin = 0.0 ; }
 
   return smin ;
 }

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

virtual

Implements G4VSolid.

Definition at line 670 of file G4Box.cc.

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

 {
   G4double safex, safey, safez, safe = 0.0 ;
 
   safex = std::fabs(p.x()) - fDx ;
   safey = std::fabs(p.y()) - fDy ;
   safez = std::fabs(p.z()) - fDz ;
 
   if (safex > safe) { safe = safex ; }
   if (safey > safe) { safe = safey ; }
   if (safez > safe) { safe = safez ; }
 
   return safe ;
 }

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

virtual

Implements G4VSolid.

Definition at line 693 of file G4Box.cc.

References G4VSolid::DumpInfo(), G4cout, G4endl, G4Exception(), JustWarning, kMX, kMY, kMZ, kPX, kPY, kPZ, kUndefined, python.hepunit::mm, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

 {
   ESide side = kUndefined ;
   G4double pdist,stmp,snxt=kInfinity;
 
   if (calcNorm) { *validNorm = true ; }  // All normals are valid
 
   if (v.x() > 0)   // X planes
   {
     pdist = fDx - p.x() ;
 
     if (pdist > delta)
     {
       snxt = pdist/v.x() ;
       side = kPX ;
     }
     else
     {
       if (calcNorm) { *n   = G4ThreeVector(1,0,0) ; }
       return        snxt = 0 ;
     }
   }
   else if (v.x() < 0)
   {
     pdist = fDx + p.x() ;
 
     if (pdist > delta)
     {
       snxt = -pdist/v.x() ;
       side = kMX ;
     }
     else
     {
       if (calcNorm) { *n   = G4ThreeVector(-1,0,0) ; }
       return        snxt = 0 ;
     }
   }
 
   if (v.y() > 0)   // Y planes
   {
     pdist = fDy-p.y();
 
     if (pdist > delta)
     {
       stmp = pdist/v.y();
 
       if (stmp < snxt)
       {
         snxt = stmp;
         side = kPY;
       }
     }
     else
     {
       if (calcNorm) { *n   = G4ThreeVector(0,1,0) ; }
       return        snxt = 0 ;
     }
   }
   else if (v.y() < 0)
   {
     pdist = fDy + p.y() ;
 
     if (pdist > delta)
     {
       stmp = -pdist/v.y();
 
       if ( stmp < snxt )
       {
         snxt = stmp;
         side = kMY;
       }
     }
     else
     {
       if (calcNorm) { *n   = G4ThreeVector(0,-1,0) ; }
       return        snxt = 0 ;
     }
   }
 
   if (v.z() > 0)        // Z planes
   {
     pdist = fDz-p.z();
 
     if ( pdist > delta )
     {
       stmp = pdist/v.z();
 
       if ( stmp < snxt )
       {
         snxt = stmp;
         side = kPZ;
       }
     }
     else
     {
       if (calcNorm) { *n   = G4ThreeVector(0,0,1) ; } 
       return        snxt = 0 ;
     }
   }
   else if (v.z() < 0)
   {
     pdist = fDz + p.z();
 
     if ( pdist > delta )
     {
       stmp = -pdist/v.z();
 
       if ( stmp < snxt )
       {
         snxt = stmp;
         side = kMZ;
       }
     }
     else
     {
       if (calcNorm) { *n   = G4ThreeVector(0,0,-1) ; }
       return        snxt = 0 ;
     }
   }
 
   if (calcNorm)
   {      
     switch (side)
     {
       case kPX:
         *n=G4ThreeVector(1,0,0);
         break;
       case kMX:
         *n=G4ThreeVector(-1,0,0);
         break;
       case kPY:
         *n=G4ThreeVector(0,1,0);
         break;
       case kMY:
         *n=G4ThreeVector(0,-1,0);
         break;
       case kPZ:
         *n=G4ThreeVector(0,0,1);
         break;
       case kMZ:
         *n=G4ThreeVector(0,0,-1);
         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("G4Box::DistanceToOut(p,v,..)", "GeomSolids1002",
                     JustWarning, message);
         break;
     }
   }
   return snxt;
 }

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

virtual

Implements G4VSolid.

Definition at line 868 of file G4Box.cc.

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

 {
   G4double safx1,safx2,safy1,safy2,safz1,safz2,safe=0.0;
 
 #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("G4Box::DistanceToOut(p)", "GeomSolids1002",
                  JustWarning, "Point p is outside !?" );
   }
 #endif
 
   safx1 = fDx - p.x() ;
   safx2 = fDx + p.x() ;
   safy1 = fDy - p.y() ;
   safy2 = fDy + p.y() ;
   safz1 = fDz - p.z() ;
   safz2 = fDz + p.z() ;  
   
   // shortest Dist to any boundary now MIN(safx1,safx2,safy1..)
 
   if (safx2 < safx1) { safe = safx2; }
   else               { safe = safx1; }
   if (safy1 < safe)  { safe = safy1; }
   if (safy2 < safe)  { safe = safy2; }
   if (safz1 < safe)  { safe = safz1; }
   if (safz2 < safe)  { safe = safz2; }
 
   if (safe < 0) { safe = 0 ; }
   return safe ;  
 }

G4double G4Box::GetCubicVolume ( )

inlinevirtual

Reimplemented from G4VSolid.

G4GeometryType G4Box::GetEntityType ( ) const

virtual

Implements G4VSolid.

Definition at line 957 of file G4Box.cc.

 {
   return G4String("G4Box");
 }

G4VisExtent G4Box::GetExtent ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1043 of file G4Box.cc.

 {
   return G4VisExtent (-fDx, fDx, -fDy, fDy, -fDz, fDz);
 }

G4ThreeVector G4Box::GetPointOnSurface ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 990 of file G4Box.cc.

References G4UniformRand.

 {
   G4double px, py, pz, select, sumS;
   G4double Sxy = fDx*fDy, Sxz = fDx*fDz, Syz = fDy*fDz;
 
   sumS   = Sxy + Sxz + Syz;
   select = sumS*G4UniformRand();
  
   if( select < Sxy )
   {
     px = -fDx +2*fDx*G4UniformRand();
     py = -fDy +2*fDy*G4UniformRand();
 
     if(G4UniformRand() > 0.5) { pz =  fDz; }
     else                      { pz = -fDz; }
   }
   else if ( ( select - Sxy ) < Sxz ) 
   {
     px = -fDx +2*fDx*G4UniformRand();
     pz = -fDz +2*fDz*G4UniformRand();
 
     if(G4UniformRand() > 0.5) { py =  fDy; }
     else                      { py = -fDy; }
   }
   else  
   {
     py = -fDy +2*fDy*G4UniformRand();
     pz = -fDz +2*fDz*G4UniformRand();
 
     if(G4UniformRand() > 0.5) { px =  fDx; }
     else                      { px = -fDx; }
   } 
   return G4ThreeVector(px,py,pz);
 }

G4double G4Box::GetSurfaceArea ( )

inlinevirtual

Reimplemented from G4VSolid.

G4double G4Box::GetXHalfLength ( ) const

inline

G4double G4Box::GetYHalfLength ( ) const

inline

Referenced by G4XXXFileSceneHandler::AddSolid(), G4XXXStoredSceneHandler::AddSolid(), G4HepRepFileSceneHandler::AddSolid(), G4HepRepSceneHandler::AddSolid(), G4XXXSGSceneHandler::AddSolid(), G4GMocrenFileSceneHandler::AddSolid(), G4GDMLWriteParamvol::Box_dimensionsWrite(), G4GDMLWriteSolids::BoxWrite(), G4ParameterisationBoxX::ComputeDimensions(), G4ParameterisationBoxZ::ComputeDimensions(), G4ParameterisationBoxY::ComputeTransformation(), export_G4Box(), G4ParameterisationBoxY::G4ParameterisationBoxY(), G4ParameterisationBoxY::GetMaxParameter(), G4tgbGeometryDumper::GetSolidParams(), G4PSFlatSurfaceCurrent::ProcessHits(), G4PSFlatSurfaceFlux::ProcessHits(), and G4STRead::Read().

G4double G4Box::GetZHalfLength ( ) const

inline

Referenced by G4XXXFileSceneHandler::AddSolid(), G4XXXStoredSceneHandler::AddSolid(), G4HepRepFileSceneHandler::AddSolid(), G4HepRepSceneHandler::AddSolid(), G4XXXSGSceneHandler::AddSolid(), G4GMocrenFileSceneHandler::AddSolid(), G4GDMLWriteParamvol::Box_dimensionsWrite(), G4GDMLWriteSolids::BoxWrite(), G4tgbVolume::BuildSolidForDivision(), G4ParameterisationBoxX::ComputeDimensions(), G4ParameterisationBoxY::ComputeDimensions(), G4ParameterisationBoxZ::ComputeTransformation(), export_G4Box(), G4ParameterisationBoxZ::G4ParameterisationBoxZ(), B2PrimaryGeneratorAction::GeneratePrimaries(), B4PrimaryGeneratorAction::GeneratePrimaries(), B1PrimaryGeneratorAction::GeneratePrimaries(), G4ParameterisationBoxZ::GetMaxParameter(), G4tgbGeometryDumper::GetSolidParams(), G4PSFlatSurfaceCurrent::IsSelectedSurface(), G4PSFlatSurfaceFlux::IsSelectedSurface(), and G4STRead::Read().

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

virtual

Implements G4VSolid.

Definition at line 372 of file G4Box.cc.

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

Referenced by CalculateExtent(), and DistanceToOut().

 {
   EInside in = kOutside ;
   G4ThreeVector q(std::fabs(p.x()), std::fabs(p.y()), std::fabs(p.z()));
 
   if ( q.x() <= (fDx - delta) )
   {
     if (q.y() <= (fDy - delta) )
     {
       if      ( q.z() <= (fDz - delta) ) { in = kInside ;  }
       else if ( q.z() <= (fDz + delta) ) { in = kSurface ; }
     }
     else if ( q.y() <= (fDy + delta) )
     {
       if ( q.z() <= (fDz + delta) ) { in = kSurface ; }
     }
   }
   else if ( q.x() <= (fDx + delta) )
   {
     if ( q.y() <= (fDy + delta) )
     {
       if ( q.z() <= (fDz + delta) ) { in = kSurface ; }
     }
   }
   return in ;
 }

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

Definition at line 110 of file G4Box.cc.

References G4CSGSolid::operator=().

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

void G4Box::SetXHalfLength ( G4double dx )

Definition at line 132 of file G4Box.cc.

References FatalException, G4CSGSolid::fCubicVolume, G4CSGSolid::fpPolyhedron, G4CSGSolid::fSurfaceArea, G4endl, G4Exception(), G4VSolid::GetName(), and G4VSolid::kCarTolerance.

 {
   if(dx > 2*kCarTolerance)  // limit to thickness of surfaces
   {
     fDx = dx;
   }
   else
   {
     std::ostringstream message;
     message << "Dimension X too small for solid: " << GetName() << "!"
             << G4endl
             << "       hX = " << dx;
     G4Exception("G4Box::SetXHalfLength()", "GeomSolids0002",
                 FatalException, message);
   }
   fCubicVolume= 0.;
   fSurfaceArea= 0.;
   fpPolyhedron = 0;
 } 

void G4Box::SetYHalfLength ( G4double dy )

Definition at line 152 of file G4Box.cc.

References FatalException, G4CSGSolid::fCubicVolume, G4CSGSolid::fpPolyhedron, G4CSGSolid::fSurfaceArea, G4endl, G4Exception(), G4VSolid::GetName(), and G4VSolid::kCarTolerance.

 {
   if(dy > 2*kCarTolerance)  // limit to thickness of surfaces
   {
     fDy = dy;
   }
   else
   {
     std::ostringstream message;
     message << "Dimension Y too small for solid: " << GetName() << "!"
             << G4endl
             << "       hY = " << dy;
     G4Exception("G4Box::SetYHalfLength()", "GeomSolids0002",
                 FatalException, message);
   }
   fCubicVolume= 0.;
   fSurfaceArea= 0.;
   fpPolyhedron = 0;
 } 

void G4Box::SetZHalfLength ( G4double dz )

Definition at line 172 of file G4Box.cc.

References FatalException, G4CSGSolid::fCubicVolume, G4CSGSolid::fpPolyhedron, G4CSGSolid::fSurfaceArea, G4endl, G4Exception(), G4VSolid::GetName(), and G4VSolid::kCarTolerance.

 {
   if(dz > 2*kCarTolerance)  // limit to thickness of surfaces
   {
     fDz = dz;
   }
   else
   {
     std::ostringstream message;
     message << "Dimension Z too small for solid: " << GetName() << "!"
             << G4endl
             << "       hZ = " << dz;
     G4Exception("G4Box::SetZHalfLength()", "GeomSolids0002",
                 FatalException, message);
   }
   fCubicVolume= 0.;
   fSurfaceArea= 0.;
   fpPolyhedron = 0;
 } 

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

virtual

Reimplemented from G4CSGSolid.

Definition at line 966 of file G4Box.cc.

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

 {
   G4int oldprc = os.precision(16);
   os << "-----------------------------------------------------------\n"
      << "    *** Dump for solid - " << GetName() << " ***\n"
      << "    ===================================================\n"
      << " Solid type: G4Box\n"
      << " Parameters: \n"
      << "    half length X: " << fDx/mm << " mm \n"
      << "    half length Y: " << fDy/mm << " mm \n"
      << "    half length Z: " << fDz/mm << " mm \n"
      << "-----------------------------------------------------------\n";
   os.precision(oldprc);
 
   return os;
 }

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

virtual

Implements G4VSolid.

Definition at line 405 of file G4Box.cc.

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

 {
   G4double distx, disty, distz ;
   G4ThreeVector norm(0.,0.,0.);
 
   // Calculate distances as if in 1st octant
 
   distx = std::fabs(std::fabs(p.x()) - fDx) ;
   disty = std::fabs(std::fabs(p.y()) - fDy) ;
   distz = std::fabs(std::fabs(p.z()) - fDz) ;
 
   // New code for particle on surface including edges and corners with specific
   // normals
 
   const G4ThreeVector nX  = G4ThreeVector( 1.0, 0,0  );
   const G4ThreeVector nmX = G4ThreeVector(-1.0, 0,0  );
   const G4ThreeVector nY  = G4ThreeVector( 0, 1.0,0  );
   const G4ThreeVector nmY = G4ThreeVector( 0,-1.0,0  );
   const G4ThreeVector nZ  = G4ThreeVector( 0, 0,  1.0);
   const G4ThreeVector nmZ = G4ThreeVector( 0, 0,- 1.0);
 
   G4ThreeVector normX(0.,0.,0.), normY(0.,0.,0.), normZ(0.,0.,0.);
   G4ThreeVector sumnorm(0., 0., 0.);
   G4int noSurfaces=0; 
 
   if (distx <= delta)         // on X/mX surface and around
   {
     noSurfaces ++; 
     if ( p.x() >= 0. )  { normX= nX ; }       // on +X surface : (1,0,0)
     else                { normX= nmX; }       //                 (-1,0,0)
     sumnorm= normX; 
   }
 
   if (disty <= delta)    // on one of the +Y or -Y surfaces
   {
     noSurfaces ++; 
     if ( p.y() >= 0. )  { normY= nY;  }       // on +Y surface
     else                { normY= nmY; }
     sumnorm += normY; 
   }
 
   if (distz <= delta)    // on one of the +Z or -Z surfaces
   {
     noSurfaces ++; 
     if ( p.z() >= 0. )  { normZ= nZ;  }       // on +Z surface
     else                { normZ= nmZ; }
     sumnorm += normZ;
   }
 
   static const G4double invSqrt2 = 1.0 / std::sqrt(2.0); 
   static const G4double invSqrt3 = 1.0 / std::sqrt(3.0); 
 
   if( noSurfaces > 0 )
   { 
     if( noSurfaces == 1 )
     { 
       norm= sumnorm; 
     }
     else
     {
       // norm = sumnorm . unit(); 
       if( noSurfaces == 2 )
       { 
         // 2 surfaces -> on edge 
         norm = invSqrt2 * sumnorm; 
       }
       else
       { 
         // 3 surfaces (on corner)
         norm = invSqrt3 * sumnorm; 
       }
     }
   }
   else
   {
 #ifdef G4CSGDEBUG
      G4Exception("G4Box::SurfaceNormal(p)", "Notification", JustWarning, 
                  "Point p is not on surface !?" );
 #endif 
      norm = ApproxSurfaceNormal(p);
   }
   
   return norm;
 }

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

Public Member Functions

Protected Types

Protected Member Functions

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation