#include <G4Box.hh>

Inheritance diagram for G4Box:

Collaboration 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)

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

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)

G4double	EstimateCubicVolume (G4int nStat, G4double epsilon) const

G4double	EstimateSurfaceArea (G4int nStat, G4double ell) const

Protected Types
enum	ESide { kUndefined, kPX, kMX, kPY, kMY, kPZ, kMZ }

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

Protected Attributes inherited from G4CSGSolid
G4double	fCubicVolume

G4double	fSurfaceArea

G4bool	fRebuildPolyhedron

G4Polyhedron *	fpPolyhedron

Protected Attributes inherited from G4VSolid
G4double	kCarTolerance

Detailed Description

Definition at line 64 of file G4Box.hh.

Member Enumeration Documentation

enum G4Box::ESide

protected

Enumerator
kUndefined
kPX
kMX
kPY
kMY
kPZ
kMZ

Definition at line 135 of file G4Box.hh.

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

G4Box::kMX

Definition: G4Box.hh:135

G4Box::kMY

Definition: G4Box.hh:135

G4Box::kPZ

Definition: G4Box.hh:135

G4Box::kPX

Definition: G4Box.hh:135

G4Box::kUndefined

Definition: G4Box.hh:135

G4Box::kPY

Definition: G4Box.hh:135

G4Box::kMZ

Definition: G4Box.hh:135

Constructor & Destructor Documentation

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

Definition at line 63 of file G4Box.cc.

   : 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);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4Box::~G4Box ( )

virtual

Definition at line 95 of file G4Box.cc.

96 {

97 }

G4Box::G4Box ( __void__ & a )

Definition at line 86 of file G4Box.cc.

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

G4Box::G4Box ( const G4Box & rhs )

Definition at line 103 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 233 of file G4Box.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:

G4VSolid * G4Box::Clone ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 864 of file G4Box.cc.

 {
   return new G4Box(*this);
 }

Here is the call graph for this function:

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

virtual

Reimplemented from G4VSolid.

Definition at line 199 of file G4Box.cc.

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

Here is the call graph for this function:

G4Polyhedron * G4Box::CreatePolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 883 of file G4Box.cc.

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

Here is the caller graph for this function:

void G4Box::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

virtual

Implements G4VSolid.

Definition at line 873 of file G4Box.cc.

 {
   scene.AddSolid (*this);
 }

Here is the call graph for this function:

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

virtual

Implements G4VSolid.

Definition at line 436 of file G4Box.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

virtual

Implements G4VSolid.

Definition at line 550 of file G4Box.cc.

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

Here is the call graph for this function:

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 573 of file G4Box.cc.

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

Here is the call graph for this function:

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

virtual

Implements G4VSolid.

Definition at line 748 of file G4Box.cc.

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

Here is the call graph for this function:

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

virtual

Reimplemented from G4VSolid.

Definition at line 210 of file G4Box.cc.

 {
   pMin.set(-fDx,-fDy,-fDz);
   pMax.set( fDx, fDy, fDz);
 
   // Check correctness of the bounding box
   //
   if (pMin.x() >= pMax.x() || pMin.y() >= pMax.y() || pMin.z() >= pMax.z())
   {
     std::ostringstream message;
     message << "Bad bounding box (min >= max) for solid: " 
             << GetName() << " !"
             << "\npMin = " << pMin
             << "\npMax = " << pMax;
     G4Exception("G4Box::Extent()", "GeomMgt0001", JustWarning, message);
     DumpInfo();
   }
 } 

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4Box::GetCubicVolume ( )

inlinevirtual

Reimplemented from G4VSolid.

G4GeometryType G4Box::GetEntityType ( ) const

virtual

Implements G4VSolid.

Definition at line 792 of file G4Box.cc.

 {
   return G4String("G4Box");
 }

G4VisExtent G4Box::GetExtent ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 878 of file G4Box.cc.

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

G4ThreeVector G4Box::GetPointOnSurface ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 825 of file G4Box.cc.

 {
   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

Here is the caller graph for this function:

G4double G4Box::GetYHalfLength ( ) const

inline

Here is the caller graph for this function:

G4double G4Box::GetZHalfLength ( ) const

inline

Here is the caller graph for this function:

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

virtual

Implements G4VSolid.

Definition at line 252 of file G4Box.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 112 of file G4Box.cc.

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

Here is the call graph for this function:

void G4Box::SetXHalfLength ( G4double dx )

Definition at line 134 of file G4Box.cc.

 {
   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.;
   fRebuildPolyhedron = true;
 } 

Here is the call graph for this function:

Here is the caller graph for this function:

void G4Box::SetYHalfLength ( G4double dy )

Definition at line 154 of file G4Box.cc.

 {
   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.;
   fRebuildPolyhedron = true;
 } 

Here is the call graph for this function:

Here is the caller graph for this function:

void G4Box::SetZHalfLength ( G4double dz )

Definition at line 174 of file G4Box.cc.

 {
   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.;
   fRebuildPolyhedron = true;
 } 

Here is the call graph for this function:

Here is the caller graph for this function:

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

virtual

Reimplemented from G4CSGSolid.

Definition at line 801 of file G4Box.cc.

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

Here is the call graph for this function:

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

virtual

Implements G4VSolid.

Definition at line 285 of file G4Box.cc.

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

Here is the call graph for this function:

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

source/geant4.10.03.p03/source/geometry/solids/CSG/include/G4Box.hh
source/geant4.10.03.p03/source/geometry/solids/CSG/src/G4Box.cc

Public Member Functions

Protected Types

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation