G4Box Class Reference

G4Box is a cuboid of given half lengths dx,dy,dz. The Box is centred on the origin with sides parallel to the x/y/z axes. More...

#include <G4Box.hh>

Inheritance diagram for G4Box:

Public Member Functions
	G4Box (const G4String &pName, G4double pX, G4double pY, G4double pZ)
	~G4Box () override=default
void	ComputeDimensions (G4VPVParameterisation *p, const G4int n, const G4VPhysicalVolume *pRep) override
void	BoundingLimits (G4ThreeVector &pMin, G4ThreeVector &pMax) const override
G4bool	CalculateExtent (const EAxis pAxis, const G4VoxelLimits &pVoxelLimit, const G4AffineTransform &pTransform, G4double &pMin, G4double &pMax) const override
G4double	GetXHalfLength () const
G4double	GetYHalfLength () const
G4double	GetZHalfLength () const
void	SetXHalfLength (G4double dx)
void	SetYHalfLength (G4double dy)
void	SetZHalfLength (G4double dz)
G4double	GetCubicVolume () override
G4double	GetSurfaceArea () override
EInside	Inside (const G4ThreeVector &p) const override
G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const override
G4double	DistanceToIn (const G4ThreeVector &p, const G4ThreeVector &v) const override
G4double	DistanceToIn (const G4ThreeVector &p) const override
G4double	DistanceToOut (const G4ThreeVector &p, const G4ThreeVector &v, const G4bool calcNorm=false, G4bool *validNorm=nullptr, G4ThreeVector *n=nullptr) const override
G4double	DistanceToOut (const G4ThreeVector &p) const override
G4GeometryType	GetEntityType () const override
G4ThreeVector	GetPointOnSurface () const override
G4bool	IsFaceted () const override
G4VSolid *	Clone () const override
std::ostream &	StreamInfo (std::ostream &os) const override
void	DescribeYourselfTo (G4VGraphicsScene &scene) const override
G4VisExtent	GetExtent () const override
G4Polyhedron *	CreatePolyhedron () const override
	G4Box (__void__ &)
	G4Box (const G4Box &rhs)=default
G4Box &	operator= (const G4Box &rhs)
Public Member Functions inherited from G4CSGSolid
	G4CSGSolid (const G4String &pName)
	~G4CSGSolid () override
std::ostream &	StreamInfo (std::ostream &os) const override
G4Polyhedron *	GetPolyhedron () const override
	G4CSGSolid (__void__ &)
	G4CSGSolid (const G4CSGSolid &rhs)
G4CSGSolid &	operator= (const G4CSGSolid &rhs)
Public Member Functions inherited from G4VSolid
	G4VSolid (const G4String &name)
virtual	~G4VSolid ()
	G4VSolid (const G4VSolid &rhs)
G4VSolid &	operator= (const G4VSolid &rhs)
G4bool	operator== (const G4VSolid &s) const
G4String	GetName () const
void	SetName (const G4String &name)
G4double	GetTolerance () const
virtual G4int	GetNumOfConstituents () 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__ &)
G4double	EstimateCubicVolume (G4int nStat, G4double epsilon) const
G4double	EstimateSurfaceArea (G4int nStat, G4double epsilon) const

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 = 0.0
G4double	fSurfaceArea = 0.0
G4bool	fRebuildPolyhedron = false
G4Polyhedron *	fpPolyhedron = nullptr
Protected Attributes inherited from G4VSolid
G4double	kCarTolerance

Detailed Description

G4Box is a cuboid of given half lengths dx,dy,dz. The Box is centred on the origin with sides parallel to the x/y/z axes.

Definition at line 57 of file G4Box.hh.

Constructor & Destructor Documentation

G4Box() [1/3]

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

Constructs a box with name, and half lengths pX, pY, pZ.

Parameters

[in]	pName	The name of the solid.
[in]	pX	Half length in X.
[in]	pY	Half length in Y.
[in]	pZ	Half length in Z.

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

Referenced by Clone(), G4Box(), and operator=().

~G4Box()

G4Box::~G4Box ( )

overridedefault

Default destructor.

G4Box() [2/3]

G4Box::G4Box

(

__void__ &

a

)

Fake default constructor for usage restricted to direct object persistency for clients requiring preallocation of memory for persistifiable objects.

Definition at line 81 of file G4Box.cc.

  : G4CSGSolid(a)
{
}

G4Box() [3/3]

G4Box::G4Box ( const G4Box & rhs )

default

Copy constructor and assignment operator.

Member Function Documentation

BoundingLimits()

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

overridevirtual

Computes the bounding limits of the solid.

Parameters

[out]	pMin	The minimum bounding limit point.
[out]	pMax	The maximum bounding limit point.

Reimplemented from G4VSolid.

Definition at line 196 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::BoundingLimits()", "GeomMgt0001", JustWarning, message);
    DumpInfo();
  }
}

Referenced by CalculateExtent().

CalculateExtent()

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

overridevirtual

Calculates the minimum and maximum extent of the solid, when under the specified transform, and within the specified limits.

Parameters

[in]	pAxis	The axis along which compute the extent.
[in]	pVoxelLimit	The limiting space dictated by voxels.
[in]	pTransform	The internal transformation applied to the solid.
[out]	pMin	The minimum extent value.
[out]	pMax	The maximum extent value.

Returns

True if the solid is intersected by the extent region.

Implements G4VSolid.

Definition at line 219 of file G4Box.cc.

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

Clone()

G4VSolid * G4Box::Clone ( ) const

overridevirtual

Makes a clone of the object for use in multi-treading.

Returns

A pointer to the new cloned allocated solid.

Reimplemented from G4VSolid.

Definition at line 563 of file G4Box.cc.

{
  return new G4Box(*this);
}

ComputeDimensions()

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

overridevirtual

Dispatch method for parameterisation replication mechanism and dimension computation.

Reimplemented from G4VSolid.

Definition at line 185 of file G4Box.cc.

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

CreatePolyhedron()

G4Polyhedron * G4Box::CreatePolyhedron ( ) const

overridevirtual

Creates a Polyhedron used for Visualisation. It is the caller's responsibility to delete it. A null pointer means "not created".

Reimplemented from G4VSolid.

Definition at line 582 of file G4Box.cc.

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

Referenced by G4GMocrenFileSceneHandler::AddSolid().

DescribeYourselfTo()

void G4Box::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

overridevirtual

Methods for creating graphical representations (i.e. for visualisation).

Implements G4VSolid.

Definition at line 572 of file G4Box.cc.

{
  scene.AddSolid (*this);
}

DistanceToIn() [1/2]

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

overridevirtual

Calculates the distance to the nearest surface of a shape from an outside point. The distance can be an underestimate.

Parameters

[in]

p

The point at offset p.

Returns

The safety distance to enter the shape.

Implements G4VSolid.

Definition at line 357 of file G4Box.cc.

{
  G4double dist = std::max(std::max(
                  std::abs(p.x())-fDx,
                  std::abs(p.y())-fDy),
                  std::abs(p.z())-fDz);
  return (dist > 0) ? dist : 0.;
}

DistanceToIn() [2/2]

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

overridevirtual

Returns the distance along the normalised vector 'v' to the shape, from the point at offset 'p'. If there is no intersection, returns kInfinity. The first intersection resulting from 'leaving' a surface/volume is discarded. Hence, it is tolerant of points on the surface of the shape.

Parameters

[in]	p	The point at offset p.
[in]	v	The normalised direction vector.

Returns

The distance to enter the shape.

Implements G4VSolid.

Definition at line 319 of file G4Box.cc.

{
  // Check if point is on the surface and traveling away
  //
  if ((std::abs(p.x())-fDx) >= -delta && p.x()*v.x() >= 0) { return kInfinity; }
  if ((std::abs(p.y())-fDy) >= -delta && p.y()*v.y() >= 0) { return kInfinity; }
  if ((std::abs(p.z())-fDz) >= -delta && p.z()*v.z() >= 0) { return kInfinity; }
 
  // Find intersection
  //
  G4double invx = (v.x() == 0) ? DBL_MAX : -1./v.x();
  G4double dx = std::copysign(fDx,invx);
  G4double txmin = (p.x() - dx)*invx;
  G4double txmax = (p.x() + dx)*invx;
 
  G4double invy = (v.y() == 0) ? DBL_MAX : -1./v.y();
  G4double dy = std::copysign(fDy,invy);
  G4double tymin = std::max(txmin,(p.y() - dy)*invy);
  G4double tymax = std::min(txmax,(p.y() + dy)*invy);
 
  G4double invz = (v.z() == 0) ? DBL_MAX : -1./v.z();
  G4double dz = std::copysign(fDz,invz);
  G4double tmin = std::max(tymin,(p.z() - dz)*invz);
  G4double tmax = std::min(tymax,(p.z() + dz)*invz);
 
  if (tmax <= tmin + delta) { return kInfinity; } // touch or no hit
 
  return (tmin < delta) ? 0. : tmin;
}

DistanceToOut() [1/2]

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

overridevirtual

Calculates the distance to the nearest surface of a shape from an inside point 'p'. The distance can be an underestimate.

Parameters

[in]

p

The point at offset p.

Returns

The safety distance to exit the shape.

Implements G4VSolid.

Definition at line 433 of file G4Box.cc.

{
#ifdef G4CSGDEBUG
  if( Inside(p) == kOutside )
  {
    std::ostringstream message;
    G4int oldprc = message.precision(16);
    message << "Point p is outside (!?) of solid: " << GetName() << G4endl;
    message << "Position:\n";
    message << "   p.x() = " << p.x()/mm << " mm\n";
    message << "   p.y() = " << p.y()/mm << " mm\n";
    message << "   p.z() = " << p.z()/mm << " mm";
    G4cout.precision(oldprc);
    G4Exception("G4Box::DistanceToOut(p)", "GeomSolids1002",
                JustWarning, message );
    DumpInfo();
  }
#endif
  G4double dist = std::min(std::min(
                  fDx-std::abs(p.x()),
                  fDy-std::abs(p.y())),
                  fDz-std::abs(p.z()));
  return (dist > 0) ? dist : 0.;
}

DistanceToOut() [2/2]

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

overridevirtual

Returns the distance along the normalised vector 'v' to the shape, from a point at an offset 'p' inside or on the surface of the shape. Intersections with surfaces, when the point is less than Tolerance/2 from a surface must be ignored.

Parameters

[in]	p	The point at offset p.
[in]	v	The normalised direction vector.
[in]	calcNorm	Flag to indicate if to calculate the normal or not.
[out]	validNorm	Flag set to true if the solid lies entirely behind or on the exiting surface. It is set false if the solid does not lie entirely behind or on the exiting surface. 'calcNorm' must be true, otherwise it is unused.
[out]	n	The exiting outwards normal vector (undefined Magnitude). 'calcNorm' must be true, otherwise it is unused.

Returns

The distance to exit the shape.

Implements G4VSolid.

Definition at line 372 of file G4Box.cc.

{
  G4double px = p.x(), vx = v.x();
  G4double py = p.y(), vy = v.y();
  G4double pz = p.z(), vz = v.z();
 
  if (!calcNorm) // calculation of normal is not needed
  {
    if ((std::abs(px) - fDx) >= -delta && px*vx > 0) { return 0.; }
    if ((std::abs(py) - fDy) >= -delta && py*vy > 0) { return 0.; }
    if ((std::abs(pz) - fDz) >= -delta && pz*vz > 0) { return 0.; }
    G4double tx = (vx == 0) ? DBL_MAX : (std::copysign(fDx,vx) - px)/vx;
    G4double ty = (vy == 0) ? DBL_MAX : (std::copysign(fDy,vy) - py)/vy;
    G4double tz = (vz == 0) ? DBL_MAX : (std::copysign(fDz,vz) - pz)/vz;
    G4double tmax = std::min(std::min(tx,ty),tz);
    return tmax;
  }
 
  *validNorm = true;
  // Check if point is on the surface and traveling away
  if ((std::abs(px) - fDx) >= -delta && px*vx > 0)
  {
    n->set(std::copysign(1.,px), 0., 0.);
    return 0.;
  }
  if ((std::abs(py) - fDy) >= -delta && py*vy > 0)
  {
    n->set(0., std::copysign(1.,py), 0.);
    return 0.;
  }
  if ((std::abs(pz) - fDz) >= -delta && pz*vz > 0)
  {
    n->set(0., 0., std::copysign(1.,pz));
    return 0.;
  }
 
  // Find intersection
  G4double tx = (vx == 0) ? DBL_MAX : (std::copysign(fDx,vx) - px)/vx;
  G4double ty = (vy == 0) ? DBL_MAX : (std::copysign(fDy,vy) - py)/vy;
  G4double tz = (vz == 0) ? DBL_MAX : (std::copysign(fDz,vz) - pz)/vz;
  G4double tmax = std::min(std::min(tx, ty), tz);
 
  // Find normal
  G4bool pickZ = (tmax == tz);
  G4bool pickX = (!pickZ) && (tmax == tx);
  G4bool pickY = (!pickZ) && (!pickX);
  G4double nz = std::copysign((G4double)pickZ, vz);
  G4double nx = std::copysign((G4double)pickX, vx);
  G4double ny = std::copysign((G4double)pickY, vy);
  n->set(nx, ny, nz);
  return tmax;
}

GetCubicVolume()

G4double G4Box::GetCubicVolume ( )

overridevirtual

Returning an estimation of the solid volume (capacity) and surface area, in internal units.

Reimplemented from G4VSolid.

Definition at line 533 of file G4Box.cc.

{
  if (fCubicVolume == 0)
  {
    G4AutoLock l(&boxMutex);
    fCubicVolume = 8*fDx*fDy*fDz;
    l.unlock();
  }
  return fCubicVolume;
}

GetEntityType()

G4GeometryType G4Box::GetEntityType ( ) const

overridevirtual

Returns the type ID, "G4Box" of the solid.

Implements G4VSolid.

Definition at line 462 of file G4Box.cc.

{
  return {"G4Box"};
}

GetExtent()

G4VisExtent G4Box::GetExtent ( ) const

overridevirtual

Provides extent (bounding box) as possible hint to the graphics view.

Reimplemented from G4VSolid.

Definition at line 577 of file G4Box.cc.

{
  return { -fDx, fDx, -fDy, fDy, -fDz, fDz };
}

GetPointOnSurface()

G4ThreeVector G4Box::GetPointOnSurface ( ) const

overridevirtual

Returns a random point located and uniformly distributed on the surface of the solid.

Reimplemented from G4VSolid.

Definition at line 500 of file G4Box.cc.

{
  G4double sxy = fDx*fDy, sxz = fDx*fDz, syz = fDy*fDz;
  G4double select = (sxy + sxz + syz)*G4QuickRand();
  G4double u = 2.*G4QuickRand() - 1.;
  G4double v = 2.*G4QuickRand() - 1.;
 
  G4double x, y, z;
  if (select < sxy)
  {
    x = u*fDx;
    y = v*fDy;
    z = (select < 0.5*sxy) ? -fDz : fDz;
  }
  else if (select < sxy + sxz)
  {
    x = u*fDx;
    y = (select < sxy + 0.5*sxz) ? -fDy : fDy;
    z = v*fDz;
  }
  else
  {
    x = (select < sxy + sxz + 0.5*syz) ? -fDx : fDx;
    y = u*fDy;
    z = v*fDz;
  }
  return { x, y, z };
}

GetSurfaceArea()

G4double G4Box::GetSurfaceArea ( )

overridevirtual

Returns an estimation of the solid surface area in internal units. This method may be overloaded by derived classes to compute the exact geometrical quantity for solids where this is possible, or anyway to cache the computed value. Note: the computed value is NOT cached.

Reimplemented from G4VSolid.

Definition at line 548 of file G4Box.cc.

{
  if (fSurfaceArea == 0)
  {
    G4AutoLock l(&boxMutex);
    fSurfaceArea = 8*(fDx*fDy+fDx*fDz+fDy*fDz);
    l.unlock();
  }
  return fSurfaceArea;
}

GetXHalfLength()

G4double G4Box::GetXHalfLength ( ) const

inline

Accessors and modifiers.

Referenced by G4GMocrenFileSceneHandler::AddSolid(), G4GDMLWriteParamvol::Box_dimensionsWrite(), G4GDMLWriteSolids::BoxWrite(), G4tgbVolume::BuildSolidForDivision(), and G4tgbGeometryDumper::GetSolidParams().

GetYHalfLength()

G4double G4Box::GetYHalfLength ( ) const

inline

Referenced by G4GMocrenFileSceneHandler::AddSolid(), G4GDMLWriteParamvol::Box_dimensionsWrite(), G4GDMLWriteSolids::BoxWrite(), and G4tgbGeometryDumper::GetSolidParams().

GetZHalfLength()

G4double G4Box::GetZHalfLength ( ) const

inline

Referenced by G4GMocrenFileSceneHandler::AddSolid(), G4GDMLWriteParamvol::Box_dimensionsWrite(), G4GDMLWriteSolids::BoxWrite(), G4tgbVolume::BuildSolidForDivision(), G4tgbGeometryDumper::GetSolidParams(), G4PSFlatSurfaceCurrent::IsSelectedSurface(), and G4PSFlatSurfaceFlux::IsSelectedSurface().

Inside()

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

overridevirtual

Concrete implementations of the expected query interfaces for solids, as defined in the base class G4VSolid.

Implements G4VSolid.

Definition at line 238 of file G4Box.cc.

{
  G4double dist = std::max(std::max(
                  std::abs(p.x())-fDx,
                  std::abs(p.y())-fDy),
                  std::abs(p.z())-fDz);
  return (dist > delta) ? kOutside :
    ((dist > -delta) ? kSurface : kInside);
}

Referenced by DistanceToOut().

IsFaceted()

G4bool G4Box::IsFaceted ( ) const

overridevirtual

Returns true as the solid has only planar faces.

Reimplemented from G4VSolid.

Definition at line 471 of file G4Box.cc.

{
  return true;
}

operator=()

G4Box & G4Box::operator=

(

const G4Box &

rhs

)

Definition at line 90 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;
}

SetXHalfLength()

void G4Box::SetXHalfLength

(

G4double

dx

)

Definition at line 114 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;
}

Referenced by G4ParameterisationBoxX::ComputeDimensions(), G4ParameterisationBoxY::ComputeDimensions(), and G4ParameterisationBoxZ::ComputeDimensions().

SetYHalfLength()

void G4Box::SetYHalfLength

(

G4double

dy

)

Definition at line 138 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() << "!\n"
            << "       hY = " << dy;
    G4Exception("G4Box::SetYHalfLength()", "GeomSolids0002",
                FatalException, message);
  }
  fCubicVolume = 0.;
  fSurfaceArea = 0.;
  fRebuildPolyhedron = true;
}

Referenced by G4ParameterisationBoxX::ComputeDimensions(), G4ParameterisationBoxY::ComputeDimensions(), and G4ParameterisationBoxZ::ComputeDimensions().

SetZHalfLength()

void G4Box::SetZHalfLength

(

G4double

dz

)

Definition at line 161 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() << "!\n"
            << "       hZ = " << dz;
    G4Exception("G4Box::SetZHalfLength()", "GeomSolids0002",
                FatalException, message);
  }
  fCubicVolume = 0.;
  fSurfaceArea = 0.;
  fRebuildPolyhedron = true;
}

Referenced by G4ParameterisationBoxX::ComputeDimensions(), G4ParameterisationBoxY::ComputeDimensions(), and G4ParameterisationBoxZ::ComputeDimensions().

StreamInfo()

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

overridevirtual

Streams the object contents to an output stream.

Implements G4VSolid.

Definition at line 480 of file G4Box.cc.

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

SurfaceNormal()

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

overridevirtual

Returns the outwards pointing unit normal of the shape for the surface closest to the point at offset 'p'.

Parameters

[in]

p

The point at offset p.

Returns

The outwards pointing unit normal.

Implements G4VSolid.

Definition at line 252 of file G4Box.cc.

{
  G4double px = p.x(), py = p.y(), pz = p.z();
  G4ThreeVector norm(0.,0.,0.);
  if (std::abs(std::abs(px)-fDx) <= delta) { norm.setX(std::copysign(1.,px)); }
  if (std::abs(std::abs(py)-fDy) <= delta) { norm.setY(std::copysign(1.,py)); }
  if (std::abs(std::abs(pz)-fDz) <= delta) { norm.setZ(std::copysign(1.,pz)); }
 
  G4double nside = norm.mag2(); // number of sides = magnitude squared
  if (nside == 1)
  {
    return norm;
  }
  if (nside > 1)
  {
    return norm.unit(); // edge or corner
  }
 
  // Point is not on the surface
  //
#ifdef G4CSGDEBUG
  std::ostringstream message;
  G4int oldprc = message.precision(16);
  message << "Point p is not on surface (!?) of solid: "
          << GetName() << G4endl;
  message << "Position:\n";
  message << "   p.x() = " << p.x()/mm << " mm\n";
  message << "   p.y() = " << p.y()/mm << " mm\n";
  message << "   p.z() = " << p.z()/mm << " mm";
  G4cout.precision(oldprc);
  G4Exception("G4Box::SurfaceNormal(p)", "GeomSolids1002",
              JustWarning, message );
  DumpInfo();
#endif
 
  return ApproxSurfaceNormal(p);
}

---

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

• G4Box.hh
• G4Box.cc