#include <UBox.hh>

Inheritance diagram for UBox:

Public Member Functions
	UBox ()

	UBox (const std::string &name, double dx, double dy, double dz)

virtual	~UBox ()

	UBox (const UBox &rhs)

UBox &	operator= (const UBox &rhs)

void	Set (double dx, double dy, double dz)

void	Set (const UVector3 &vec)

double	GetXHalfLength () const

double	GetYHalfLength () const

double	GetZHalfLength () const

void	SetXHalfLength (double dx)

void	SetYHalfLength (double dy)

void	SetZHalfLength (double dz)

EnumInside	Inside (const UVector3 &aPoint) const

double	SafetyFromInside (const UVector3 &aPoint, bool aAccurate=false) const

double	SafetyFromOutside (const UVector3 &aPoint, bool aAccurate=false) const

double	DistanceToIn (const UVector3 &aPoint, const UVector3 &aDirection, double aPstep=UUtils::kInfinity) const

double	DistanceToOut (const UVector3 &aPoint, const UVector3 &aDirection, UVector3 &aNormalVector, bool &aConvex, double aPstep=UUtils::kInfinity) const

bool	Normal (const UVector3 &aPoint, UVector3 &aNormal) const

void	Extent (UVector3 &aMin, UVector3 &aMax) const

double	Capacity ()

double	SurfaceArea ()

VUSolid *	Clone () const

UGeometryType	GetEntityType () const

void	ComputeBBox (UBBox *, bool)

void	GetParametersList (int, double *aArray) const

UVector3	GetPointOnSurface () const

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

Public Member Functions inherited from VUSolid
	VUSolid ()

	VUSolid (const std::string &name)

virtual	~VUSolid ()

double	GetCarTolerance () const

double	GetRadTolerance () const

double	GetAngTolerance () const

void	SetCarTolerance (double eps)

void	SetRadTolerance (double eps)

void	SetAngTolerance (double eps)

virtual void	ExtentAxis (EAxisType aAxis, double &aMin, double &aMax) const

const std::string &	GetName () const

void	SetName (const std::string &aName)

virtual void	SamplePointsInside (int, UVector3 *) const

virtual void	SamplePointsOnSurface (int, UVector3 *) const

virtual void	SamplePointsOnEdge (int, UVector3 *) const

double	EstimateCubicVolume (int nStat, double epsilon) const

double	EstimateSurfaceArea (int nStat, double ell) const

Additional Inherited Members
Public Types inherited from VUSolid
enum	EnumInside { eInside =0, eSurface =1, eOutside =2 }

enum	EAxisType { eXaxis =0, eYaxis =1, eZaxis =2 }

Static Public Member Functions inherited from VUSolid
static double	Tolerance ()

Static Protected Attributes inherited from VUSolid
static double	fgTolerance = 1.0E-9

static double	frTolerance = 1.0E-9

static double	faTolerance = 1.0E-9

Detailed Description

Definition at line 33 of file UBox.hh.

Constructor & Destructor Documentation

UBox::UBox ( )

inline

Definition at line 37 of file UBox.hh.

Referenced by Clone().

37 : VUSolid(), fDx(0), fDy(0), fDz(0),fCubicVolume(0.), fSurfaceArea(0.) {}

VUSolid::VUSolid

VUSolid()

Definition: VUSolid.cc:18

UBox::UBox	(	const std::string &	name,
		double	dx,
		double	dy,
		double	dz
	)

Definition at line 23 of file UBox.cc.

References UUtils::Exception(), FatalErrorInArguments, VUSolid::fgTolerance, and VUSolid::GetName().

   : VUSolid(name),
     fDx(dx),
     fDy(dy),
     fDz(dz), fCubicVolume(0.), fSurfaceArea(0.)
 {
   // Named constructor
 
   if ((dx < 2 * VUSolid::fgTolerance)
       || (dy < 2 * VUSolid::fgTolerance)
       || (dz < 2 * VUSolid::fgTolerance))  // limit to thickness of surfaces
   {
     //std::ostringstream message;
     std::ostringstream message;
     message << "Dimensions too small for Solid: " << GetName() << "!" << std::endl
             << "     dx, dy, dz = " << dx << ", " << dy << ", " << dz;
     UUtils::Exception("UBox::UBox()", "UGeomSolids", FatalErrorInArguments, 1, message.str().c_str());
   }
 }

UBox::~UBox ( )

virtual

Definition at line 57 of file UBox.cc.

 {
 
 }

UBox::UBox ( const UBox & rhs )

Definition at line 63 of file UBox.cc.

   : VUSolid(rhs), fDx(rhs.fDx), fDy(rhs.fDy), fDz(rhs.fDz),
     fCubicVolume(rhs.fCubicVolume), fSurfaceArea(rhs.fSurfaceArea)
 {
 }

Member Function Documentation

double UBox::Capacity ( )

inlinevirtual

Implements VUSolid.

Definition at line 126 of file UBox.hh.

 {
   if (fCubicVolume != 0.)
   {
     ;
   }
   else
   {
     fCubicVolume = 8 * fDx * fDy * fDz;
   }
   return fCubicVolume;
 }

VUSolid * UBox::Clone ( ) const

virtual

Implements VUSolid.

Definition at line 553 of file UBox.cc.

References UBox().

 {
    return new UBox(*this);
 }

void UBox::ComputeBBox	(	UBBox *	,
		bool
	)

inlinevirtual

Implements VUSolid.

Definition at line 88 of file UBox.hh.

88 {}

double UBox::DistanceToIn	(	const UVector3 &	aPoint,
		const UVector3 &	aDirection,
		double	aPstep = `UUtils::kInfinity`
	)		const

virtual

Implements VUSolid.

Definition at line 117 of file UBox.cc.

References VUSolid::fgTolerance, UVector3::x, UVector3::y, and UVector3::z.

Referenced by UVoxelizer::DistanceToFirst(), UVCSGfaceted::DistanceToIn(), and UPolycone::DistanceToIn().

 {
   // Computes distance from a point presumably outside the solid to the solid
   // surface. Ignores first surface if the point is actually inside. Early return
   // infinity in case the safety to any surface is found greater than the proposed
   // step aPstep.
   // The normal vector to the crossed surface is filled only in case the box is
   // crossed, otherwise aNormal.IsNull() is true.
 
   // Compute safety to the closest surface on each axis.
   // Early exits if safety bigger than proposed step.
   static const double delta = VUSolid::fgTolerance;
   //   aNormal.SetNull();
   double safx = std::abs(aPoint.x) - fDx;
   double safy = std::abs(aPoint.y) - fDy;
   double safz = std::abs(aPoint.z) - fDz;
   if ((safx > aPstep) || (safy > aPstep) || (safz > aPstep))
     return UUtils::kInfinity;
   // Check numerical outside.
   bool outside = (safx > 0) || (safy > 0) || (safz > 0);
   if (!outside)
   {
     // If point close to this surface, check against the normal
     if (safx > -delta)
     {
       //         aNormal.x = UUtils::Sign(1.0, aPoint.x);
       return (aPoint.x * aDirection.x > 0) ? UUtils::kInfinity : 0.0;
     }
     if (safy > -delta)
     {
       //         aNormal.y = UUtils::Sign(1.0, aPoint.y);
       return (aPoint.y * aDirection.y > 0) ? UUtils::kInfinity : 0.0;
     }
     if (safz > -delta)
     {
       //         aNormal.z = UUtils::Sign(1.0, aPoint.z);
       return (aPoint.z * aDirection.z > 0) ? UUtils::kInfinity : 0.0;
     }
     // Point actually "deep" inside, return zero distance, normal un-defined
     return 0.0;
   }
   // The point is really outside. Only axis with positive safety to be
   // considered. Early exit on each axis if point and direction components
   // have the same .sign.
   double dist = 0.0;
   double coordinate = 0.0;
   if (safx > 0)
   {
     if (aPoint.x * aDirection.x >= 0) return UUtils::kInfinity;
     dist = safx / std::abs(aDirection.x);
     coordinate = aPoint.y + dist * aDirection.y;
     if (std::abs(coordinate) < fDy)
     {
       coordinate = aPoint.z + dist * aDirection.z;
       if (std::abs(coordinate) < fDz)
       {
         //            aNormal.x = UUtils::Sign(1.0, aPoint.x);
         if (dist < 0.5 * delta) dist = 0.;
         return dist;
       }
     }
   }
   if (safy > 0)
   {
     if (aPoint.y * aDirection.y >= 0) return UUtils::kInfinity;
     dist = safy / std::abs(aDirection.y);
     coordinate = aPoint.x + dist * aDirection.x;
     if (std::abs(coordinate) < fDx)
     {
       coordinate = aPoint.z + dist * aDirection.z;
       if (std::abs(coordinate) < fDz)
       {
         //            aNormal.y = UUtils::Sign(1.0, aPoint.y);
         if (dist < 0.5 * delta) dist = 0.;
         return dist;
       }
     }
   }
   if (safz > 0)
   {
     if (aPoint.z * aDirection.z >= 0) return UUtils::kInfinity;
     dist = safz / std::abs(aDirection.z);
     coordinate = aPoint.x + dist * aDirection.x;
     if (std::abs(coordinate) < fDx)
     {
       coordinate = aPoint.y + dist * aDirection.y;
       if (std::abs(coordinate) < fDy)
       {
         //            aNormal.z = UUtils::Sign(1.0, aPoint.z);
         if (dist < 0.5 * delta) dist = 0.;
         return dist;
       }
     }
   }
   return UUtils::kInfinity;
 }

double UBox::DistanceToOut	(	const UVector3 &	aPoint,
		const UVector3 &	aDirection,
		UVector3 &	aNormalVector,
		bool &	aConvex,
		double	aPstep = `UUtils::kInfinity`
	)		const

virtual

Implements VUSolid.

Definition at line 218 of file UBox.cc.

References VUSolid::fgTolerance, UVector3::Set(), UUtils::Sign(), UVector3::x, UVector3::y, and UVector3::z.

 {
   // Computes distance from a point presumably intside the solid to the solid
   // surface. Ignores first surface along each axis systematically (for points
   // inside or outside. Early returns zero in case the second surface is behind
   // the starting point.
   // o The proposed step is ignored.
   // o The normal vector to the crossed surface is always filled.
   double smin = UUtils::kInfinity;
   double snxt, signDir;
   convex = true;  //   Box is convex (even if the starting point is outside)
   // Check always the "away" surface along direction on axis. This responds
   // corectly even for points outside the solid (no need for tolerance check)
   if (aDirection.x != 0.0)
     { 
     signDir = UUtils::Sign(1.0, aDirection.x);
     aNormal.Set(signDir, 0., 0.);
     snxt = (-aPoint.x + signDir * fDx) / aDirection.x;
     if (snxt <= 0) return 0.0;   // point outside moving outwards
     smin = snxt;
   }
 
   if (aDirection.y != 0.0)
     { 
     signDir = UUtils::Sign(1.0, aDirection.y);
     snxt = (-aPoint.y + signDir * fDy) / aDirection.y;
     if (snxt <= 0)
     {
       aNormal.Set(0., signDir, 0.);
       return 0.0; // point outside moving outwards
     }
     if (snxt < smin)
     {
       smin = snxt;
       aNormal.Set(0., signDir, 0.);
     }
   }
 
   if (aDirection.z != 0.0)
     { 
     signDir = UUtils::Sign(1.0, aDirection.z);
     snxt = (-aPoint.z + signDir * fDz) / aDirection.z;
     if (snxt <= 0)
     {
       aNormal.Set(0., 0., signDir);
       return 0.0; // point outside moving outwards
     }
     if (snxt < smin)
     {
       smin = snxt;
       aNormal.Set(0., 0., signDir);
      }
   }
   if (smin < 0.5 * VUSolid::fgTolerance) smin = 0.;
   return smin;
 }

void UBox::Extent	(	UVector3 &	aMin,
		UVector3 &	aMax
	)		const

virtual

Implements VUSolid.

Definition at line 400 of file UBox.cc.

References UVector3::x, UVector3::y, and UVector3::z.

 {
   // Returns the full 3D cartesian extent of the solid.
   aMin.x = -fDx;
   aMax.x = fDx;
   aMin.y = -fDy;
   aMax.y = fDy;
   aMin.z = -fDz;
   aMax.z = fDz;
 }

UGeometryType UBox::GetEntityType ( ) const

virtual

Implements VUSolid.

Definition at line 548 of file UBox.cc.

 {
    return "Box";
 }

void UBox::GetParametersList	(	int	,
		double *	aArray
	)		const

inlinevirtual

Implements VUSolid.

Definition at line 91 of file UBox.hh.

References GetXHalfLength(), GetYHalfLength(), and GetZHalfLength().

     {
       aArray[0] = GetXHalfLength();
       aArray[1] = GetYHalfLength();
       aArray[2] = GetZHalfLength();
     }

UVector3 UBox::GetPointOnSurface ( ) const

virtual

Implements VUSolid.

Definition at line 418 of file UBox.cc.

References UUtils::Random().

 {
   double px, py, pz, select, sumS;
   double Sxy = fDx * fDy, Sxz = fDx * fDz, Syz = fDy * fDz;
 
   sumS   = Sxy + Sxz + Syz;
   select = sumS * UUtils::Random();
 
   if (select < Sxy)
   {
     px = -fDx + 2 * fDx * UUtils::Random();
     py = -fDy + 2 * fDy * UUtils::Random();
 
     if (UUtils::Random() > 0.5)
     {
       pz = fDz;
     }
     else
     {
       pz = -fDz;
     }
   }
   else if ((select - Sxy) < Sxz)
   {
     px = -fDx + 2 * fDx * UUtils::Random();
     pz = -fDz + 2 * fDz * UUtils::Random();
 
     if (UUtils::Random() > 0.5)
     {
       py = fDy;
     }
     else
     {
       py = -fDy;
     }
   }
   else
   {
     py = -fDy + 2 * fDy * UUtils::Random();
     pz = -fDz + 2 * fDz * UUtils::Random();
 
     if (UUtils::Random() > 0.5)
     {
       px = fDx;
     }
     else
     {
       px = -fDx;
     }
   }
   return UVector3(px, py, pz);
 }

double UBox::GetXHalfLength ( ) const

inline

Definition at line 113 of file UBox.hh.

Referenced by GetParametersList(), and G4UBox::GetXHalfLength().

 {
   return fDx;
 }

double UBox::GetYHalfLength ( ) const

inline

Definition at line 117 of file UBox.hh.

Referenced by GetParametersList(), and G4UBox::GetYHalfLength().

 {
   return fDy;
 }

double UBox::GetZHalfLength ( ) const

inline

Definition at line 121 of file UBox.hh.

Referenced by UPolycone::DistanceToIn(), GetParametersList(), G4UBox::GetZHalfLength(), UVCSGfaceted::InitVoxels(), and UPolycone::Inside().

 {
   return fDz;
 }

VUSolid::EnumInside UBox::Inside ( const UVector3 & aPoint ) const

virtual

Implements VUSolid.

Definition at line 97 of file UBox.cc.

References VUSolid::eInside, VUSolid::eOutside, VUSolid::eSurface, VUSolid::fgTolerance, UVector3::x, UVector3::y, and UVector3::z.

Referenced by UPolycone::Inside().

 {
   // Classify point location with respect to solid:
   //  o eInside       - inside the solid
   //  o eSurface      - close to surface within tolerance
   //  o eOutside      - outside the solid
   static const double delta = VUSolid::fgTolerance;
   // Early returns on outside condition on any axis. Check Z first for faster
   // exclusion in  phi symmetric geometries.
   double ddz = std::abs(aPoint.z) - fDz;
   if (ddz > delta) return eOutside;
   double ddx = std::abs(aPoint.x) - fDx;
   if (ddx > delta) return eOutside;
   double ddy = std::abs(aPoint.y) - fDy;
   if (ddy > delta) return eOutside;
   if (ddx > - delta || ddy > -delta || ddz > -delta) return eSurface;
   return eInside;
 }

bool UBox::Normal	(	const UVector3 &	aPoint,
		UVector3 &	aNormal
	)		const

virtual

Implements VUSolid.

Definition at line 331 of file UBox.cc.

References VUSolid::fgTolerance, UVector3::Set(), UUtils::Sign(), UVector3::x, UVector3::y, and UVector3::z.

 {
   // Computes the normal on a surface and returns it as a unit vector
   //   In case a point is further than tolerance_normal from a surface, set validNormal=false
   //   Must return a valid vector. (even if the point is not on the surface.)
   //
   //   On an edge or corner, provide an average normal of all facets within tolerance
   // NOTE: the tolerance value used in here is not yet the global surface
   //     tolerance - we will have to revise this value - TODO
   static const double delta = 100.*VUSolid::fgTolerance;
   static const double kInvSqrt2 = 1. / std::sqrt(2.);
   static const double kInvSqrt3 = 1. / std::sqrt(3.);
   aNormal.Set(0.);
   UVector3 crt_normal, min_normal;
   int nsurf = 0;
   double safx = std::abs(std::abs(aPoint.x) - fDx);
   double safmin = safx;
   crt_normal.Set(UUtils::Sign(1., aPoint.x), 0., 0.);
   min_normal = crt_normal;
   if (safx < delta)
   {
     nsurf++;
     aNormal += crt_normal;
   }
   double safy = std::abs(std::abs(aPoint.y) - fDy);
   crt_normal.Set(0., UUtils::Sign(1., aPoint.y), 0.);
   if (safy < delta)
   {
     nsurf++;
     aNormal += crt_normal;
   }
   if (safy < safmin)
   {
     min_normal = crt_normal;
     safmin = safy;
   }
   double safz = std::abs(std::abs(aPoint.z) - fDz);
   crt_normal.Set(0., 0., UUtils::Sign(1., aPoint.z));
   if (safz < delta)
   {
     nsurf++;
     aNormal += crt_normal;
   }
   if (safz < safmin)
   {
     min_normal = crt_normal;
     safmin = safz;
   }
 
   bool valid = true;
   switch (nsurf)
   {
     case 0:
       aNormal = min_normal;
       valid = false;
       break;
     case 1:
       break;
     case 2:
       aNormal *= kInvSqrt2;
       break;
     case 3:
       aNormal *= kInvSqrt3;
   };
   return valid;
 }

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

Definition at line 72 of file UBox.cc.

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

double UBox::SafetyFromInside	(	const UVector3 &	aPoint,
		bool	aAccurate = `false`
	)		const

virtual

Implements VUSolid.

Definition at line 279 of file UBox.cc.

References G4INCL::Math::max(), UVector3::x, UVector3::y, and UVector3::z.

 {
   // Estimates the isotropic safety from a point inside the current solid to any
   // of its surfaces. The algorithm may be accurate or should provide a fast
   // underestimate.
   double safe, safy, safz;
   safe = fDx - std::abs(aPoint.x);
   safy = fDy - std::abs(aPoint.y);
   if (safy < safe) safe = safy;
   safz = fDz - std::abs(aPoint.z);
   if (safz < safe) safe = safz;
   return std::max(0.0, safe);
 }

double UBox::SafetyFromOutside	(	const UVector3 &	aPoint,
		bool	aAccurate = `false`
	)		const

virtual

Implements VUSolid.

Definition at line 295 of file UBox.cc.

References UVector3::x, UVector3::y, and UVector3::z.

Referenced by UVCSGfaceted::SafetyFromOutside().

 {
   // Estimates the isotropic safety from a point outside the current solid to any
   // of its surfaces. The algorithm may be accurate or should provide a fast
   // underestimate.
   double safe, safx, safy, safz;
   safe = safx = -fDx + std::abs(aPoint.x);
   safy = -fDy + std::abs(aPoint.y);
   if (safy > safe) safe = safy;
   safz = -fDz + std::abs(aPoint.z);
   if (safz > safe) safe = safz;
   if (safe < 0.0) return 0.0; // point is inside
   if (!aAccurate) return safe;
   double safsq = 0.0;
   int count = 0;
   if (safx > 0)
   {
     safsq += safx * safx;
     count++;
   }
   if (safy > 0)
   {
     safsq += safy * safy;
     count++;
   }
   if (safz > 0)
   {
     safsq += safz * safz;
     count++;
   }
   if (count == 1) return safe;
   return std::sqrt(safsq);
 }

void UBox::Set	(	double	dx,
		double	dy,
		double	dz
	)

Definition at line 43 of file UBox.cc.

Referenced by UPolycone::Init(), and UVCSGfaceted::InitVoxels().

 {
   fDx = dx;
   fDy = dy;
   fDz = dz;
 }

void UBox::Set ( const UVector3 & vec )

Definition at line 50 of file UBox.cc.

References UVector3::x, UVector3::y, and UVector3::z.

 {
   fDx = vec.x;
   fDy = vec.y;
   fDz = vec.z;
 }

void UBox::SetXHalfLength ( double dx )

Definition at line 488 of file UBox.cc.

References UUtils::Exception(), FatalErrorInArguments, VUSolid::fgTolerance, and VUSolid::GetName().

Referenced by G4UBox::SetXHalfLength().

 {
   if (dx > 2 * VUSolid::fgTolerance) // limit to thickness of surfaces
   {
     fDx = dx;
   }
   else
   {
     std::ostringstream message;
     message << "Dimension X too small for solid: " << GetName() << "!"
             << std::endl
             << "       hX = " << dx;
     UUtils::Exception("UBox::SetXHalfLength()", "GeomSolids0002",
                       FatalErrorInArguments, 1, message.str().c_str());
   }
   fCubicVolume = 0.;
   fSurfaceArea = 0.;
 
 }

void UBox::SetYHalfLength ( double dy )

Definition at line 508 of file UBox.cc.

References UUtils::Exception(), FatalErrorInArguments, VUSolid::fgTolerance, and VUSolid::GetName().

Referenced by G4UBox::SetYHalfLength().

 {
   if (dy > 2 * VUSolid::fgTolerance) // limit to thickness of surfaces
   {
     fDy = dy;
   }
   else
   {
     std::ostringstream message;
     message << "Dimension Y too small for solid: " << GetName() << "!"
             << std::endl
             << "       hY = " << dy;
     UUtils::Exception("UBox::SetYHalfLength()", "GeomSolids0002",
                       FatalErrorInArguments, 1, message.str().c_str());
   }
   fCubicVolume = 0.;
   fSurfaceArea = 0.;
 
 }

void UBox::SetZHalfLength ( double dz )

Definition at line 528 of file UBox.cc.

References UUtils::Exception(), FatalErrorInArguments, VUSolid::fgTolerance, and VUSolid::GetName().

Referenced by G4UBox::SetZHalfLength().

 {
   if (dz > 2 * VUSolid::fgTolerance) // limit to thickness of surfaces
   {
     fDz = dz;
   }
   else
   {
     std::ostringstream message;
     message << "Dimension Z too small for solid: " << GetName() << "!"
             << std::endl
             << "       hZ = " << dz;
     UUtils::Exception("G4Box::SetZHalfLength()", "GeomSolids0002",
                       FatalErrorInArguments, 1, message.str().c_str());
   }
   fCubicVolume = 0.;
   fSurfaceArea = 0.;
 
 }

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

virtual

Implements VUSolid.

Definition at line 471 of file UBox.cc.

References VUSolid::GetName().

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

double UBox::SurfaceArea ( )

inlinevirtual

Implements VUSolid.

Definition at line 139 of file UBox.hh.

 {
   if (fSurfaceArea != 0.)
   {
     ;
   }
   else
   {
     fSurfaceArea = 8 * (fDx * fDy + fDx * fDz + fDy * fDz);
   }
   return fSurfaceArea;
 }

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

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation