G4Orb Class Reference

G4Orb represents a full sphere. More...

#include <G4Orb.hh>

Inheritance diagram for G4Orb:

Public Member Functions
	G4Orb (const G4String &pName, G4double pRmax)
	~G4Orb () override=default
G4double	GetRadius () const
G4double	GetRadialTolerance () const
void	SetRadius (G4double newRmax)
G4double	GetCubicVolume () override
G4double	GetSurfaceArea () override
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
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
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
	G4Orb (__void__ &)
	G4Orb (const G4Orb &rhs)=default
G4Orb &	operator= (const G4Orb &rhs)
Public Member Functions inherited from G4CSGSolid
	G4CSGSolid (const G4String &pName)
	~G4CSGSolid () 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
virtual G4bool	IsFaceted () 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

Protected Member Functions
void	Initialize ()
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

Additional Inherited Members
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

G4Orb represents a full sphere.

Definition at line 58 of file G4Orb.hh.

Constructor & Destructor Documentation

G4Orb() [1/3]

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

Constructs a full sphere, given a name and its radius.

Parameters

[in]	pName	The name of the solid.
[in]	pRmax	Outer radius.

Definition at line 58 of file G4Orb.cc.

  : G4CSGSolid(pName), fRmax(pRmax)
{
  Initialize();
}

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

~G4Orb()

G4Orb::~G4Orb ( )

overridedefault

Default destructor.

G4Orb() [2/3]

G4Orb::G4Orb

(

__void__ &

a

)

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

Definition at line 69 of file G4Orb.cc.

  : G4CSGSolid(a)
{
}

G4Orb() [3/3]

G4Orb::G4Orb ( const G4Orb & rhs )

default

Copy constructor and assignment operator.

Member Function Documentation

BoundingLimits()

void G4Orb::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 136 of file G4Orb.cc.

{
  G4double radius = GetRadius();
  pMin.set(-radius,-radius,-radius);
  pMax.set( radius, radius, radius);
 
  // 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("G4Orb::BoundingLimits()", "GeomMgt0001",
                JustWarning, message);
    DumpInfo();
  }
}

Referenced by CalculateExtent().

CalculateExtent()

G4bool G4Orb::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 161 of file G4Orb.cc.

{
  G4ThreeVector bmin, bmax;
  G4bool exist;
 
  // Get bounding box
  BoundingLimits(bmin,bmax);
 
  // Check bounding box
  G4BoundingEnvelope bbox(bmin,bmax);
#ifdef G4BBOX_EXTENT
  return bbox.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
#endif
  if (bbox.BoundingBoxVsVoxelLimits(pAxis,pVoxelLimit,pTransform,pMin,pMax))
  {
    return exist = pMin < pMax;
  }
 
  // Find bounding envelope and calculate extent
  //
  static const G4int NTHETA = 8;  // number of steps along Theta
  static const G4int NPHI   = 16; // number of steps along Phi
  static const G4double sinHalfTheta = std::sin(halfpi/NTHETA);
  static const G4double cosHalfTheta = std::cos(halfpi/NTHETA);
  static const G4double sinHalfPhi   = std::sin(pi/NPHI);
  static const G4double cosHalfPhi   = std::cos(pi/NPHI);
  static const G4double sinStepTheta = 2.*sinHalfTheta*cosHalfTheta;
  static const G4double cosStepTheta = 1. - 2.*sinHalfTheta*sinHalfTheta;
  static const G4double sinStepPhi   = 2.*sinHalfPhi*cosHalfPhi;
  static const G4double cosStepPhi   = 1. - 2.*sinHalfPhi*sinHalfPhi;
 
  G4double radius = GetRadius();
  G4double rtheta = radius/cosHalfTheta;
  G4double rphi   = rtheta/cosHalfPhi;
 
  // set reference circle
  G4TwoVector xy[NPHI];
  G4double sinCurPhi = sinHalfPhi;
  G4double cosCurPhi = cosHalfPhi;
  for (auto & k : xy)
  {
    k.set(cosCurPhi,sinCurPhi);
    G4double sinTmpPhi = sinCurPhi;
    sinCurPhi = sinCurPhi*cosStepPhi + cosCurPhi*sinStepPhi;
    cosCurPhi = cosCurPhi*cosStepPhi - sinTmpPhi*sinStepPhi;
  }
 
  // set bounding circles
  G4ThreeVectorList circles[NTHETA];
  for (auto & circle : circles) { circle.resize(NPHI); }
 
  G4double sinCurTheta = sinHalfTheta;
  G4double cosCurTheta = cosHalfTheta;
  for (auto & circle : circles)
  {
    G4double z = rtheta*cosCurTheta;
    G4double rho = rphi*sinCurTheta;
    for (G4int k=0; k<NPHI; ++k)
    {
      circle[k].set(rho*xy[k].x(),rho*xy[k].y(),z);
    }
    G4double sinTmpTheta = sinCurTheta;
    sinCurTheta = sinCurTheta*cosStepTheta + cosCurTheta*sinStepTheta;
    cosCurTheta = cosCurTheta*cosStepTheta - sinTmpTheta*sinStepTheta;
  }
 
  // set envelope and calculate extent
  std::vector<const G4ThreeVectorList *> polygons;
  polygons.resize(NTHETA);
  for (G4int i=0; i<NTHETA; ++i) { polygons[i] = &circles[i]; }
 
  G4BoundingEnvelope benv(bmin,bmax,polygons);
  exist = benv.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
  return exist;
}

Clone()

G4VSolid * G4Orb::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 401 of file G4Orb.cc.

{
  return new G4Orb(*this);
}

ComputeDimensions()

void G4Orb::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 125 of file G4Orb.cc.

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

CreatePolyhedron()

G4Polyhedron * G4Orb::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 484 of file G4Orb.cc.

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

DescribeYourselfTo()

void G4Orb::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

overridevirtual

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

Implements G4VSolid.

Definition at line 474 of file G4Orb.cc.

{
  scene.AddSolid (*this);
}

DistanceToIn() [1/2]

G4double G4Orb::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 310 of file G4Orb.cc.

{
  G4double dist = p.mag() - fRmax;
  return (dist > 0) ? dist : 0.;
}

DistanceToIn() [2/2]

G4double G4Orb::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 266 of file G4Orb.cc.

{
  // Check if point is on the surface and traveling away
  //
  G4double rr = p.mag2();
  G4double pv = p.dot(v);
  if (rr >= sqrRmaxMinusTol && pv >= 0) { return kInfinity; }
 
  // Find intersection
  //
  //    Sphere eqn: x^2 + y^2 + z^2 = R^2
  //
  //    => (px + t*vx)^2 + (py + t*vy)^2 + (pz + t*vz)^2 = R^2
  //    => r^2 + 2t(p.v) + t^2 = R^2
  //    => tmin = -(p.v) - Sqrt((p.v)^2 - (r^2 - R^2))
  //
  G4double D  = pv*pv - rr + fRmax*fRmax;
  if (D < 0) { return kInfinity; } // no intersection
 
  G4double sqrtD = std::sqrt(D);
  G4double dist = -pv - sqrtD;
 
  // Avoid rounding errors due to precision issues seen on 64 bits systems.
  // Split long distances and recompute
  //
  G4double Dmax = 32*fRmax;
  if (dist > Dmax)
  {
    dist  = dist - 1.e-8*dist - fRmax; // to stay outside after the move
    dist += DistanceToIn(p + dist*v, v);
    return (dist >= kInfinity) ? kInfinity : dist;
  }
 
  if (sqrtD*2 <= halfRmaxTol) { return kInfinity; } // touch
 
  return (dist < halfRmaxTol) ? 0. : dist;
}

Referenced by DistanceToIn().

DistanceToOut() [1/2]

G4double G4Orb::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 366 of file G4Orb.cc.

{
#ifdef G4CSGDEBUG
  if( Inside(p) == kOutside )
  {
    std::ostringstream message;
    G4int oldprc = message.precision(16);
    message << "Point p is outside (!?) of solid: " << GetName() << "\n";
    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("G4Trap::DistanceToOut(p)", "GeomSolids1002",
                JustWarning, message );
    DumpInfo();
  }
#endif
  G4double dist = fRmax - p.mag();
  return (dist > 0) ? dist : 0.;
}

DistanceToOut() [2/2]

G4double G4Orb::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 322 of file G4Orb.cc.

{
  // Check if point is on the surface and traveling away
  //
  G4double rr = p.mag2();
  G4double pv = p.dot(v);
  if (rr >= sqrRmaxMinusTol && pv > 0)
  {
    if (calcNorm)
    {
      *validNorm = true;
      *n = p*(1./std::sqrt(rr));
    }
    return 0.;
  }
 
  // Find intersection
  //
  //    Sphere eqn: x^2 + y^2 + z^2 = R^2
  //
  //    => (px + t*vx)^2 + (py + t*vy)^2 + (pz + t*vz)^2 = R^2
  //    => r^2 + 2t(p.v) + t^2 = R^2
  //    => tmax = -(p.v) + Sqrt((p.v)^2 - (r^2 - R^2))
  //
  G4double D  = pv*pv - rr + fRmax*fRmax;
  G4double tmax = (D <= 0) ? 0. : std::sqrt(D) - pv;
  if (tmax < halfRmaxTol) { tmax = 0.; }
  if (calcNorm)
  {
    *validNorm = true;
    G4ThreeVector ptmax = p + tmax*v;
    *n = ptmax*(1./ptmax.mag());
  }
  return tmax;
}

GetCubicVolume()

G4double G4Orb::GetCubicVolume ( )

overridevirtual

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

Reimplemented from G4VSolid.

Definition at line 445 of file G4Orb.cc.

{
  if (fCubicVolume == 0)
  {
    G4AutoLock l(&orbMutex);
    fCubicVolume = 4*CLHEP::pi*fRmax*fRmax*fRmax/3.;
    l.unlock();
  }
  return fCubicVolume;
}

GetEntityType()

G4GeometryType G4Orb::GetEntityType ( ) const

overridevirtual

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

Implements G4VSolid.

Definition at line 392 of file G4Orb.cc.

{
  return {"G4Orb"};
}

GetExtent()

G4VisExtent G4Orb::GetExtent ( ) const

overridevirtual

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

Reimplemented from G4VSolid.

Definition at line 479 of file G4Orb.cc.

{
  return {-fRmax, fRmax, -fRmax, fRmax, -fRmax, fRmax};
}

GetPointOnSurface()

G4ThreeVector G4Orb::GetPointOnSurface ( ) const

overridevirtual

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

Reimplemented from G4VSolid.

Definition at line 428 of file G4Orb.cc.

{
  G4double u, v, b;
  do
  {
    u = 2.*G4QuickRand() - 1.;
    v = 2.*G4QuickRand() - 1.;
    b = sqr(u) + sqr(v);
  } while(b > 1.);
  G4double a = 2.*std::sqrt(1. - b);
  return { fRmax*a*u, fRmax*a*v, fRmax*(2.*b - 1.) };
}

GetRadialTolerance()

G4double G4Orb::GetRadialTolerance ( ) const

inline

GetRadius()

G4double G4Orb::GetRadius ( ) const

inline

Accessors and modifiers.

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

GetSurfaceArea()

G4double G4Orb::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 460 of file G4Orb.cc.

{
  if (fSurfaceArea == 0)
  {
    G4AutoLock l(&orbMutex);
    fSurfaceArea = 4*CLHEP::pi*fRmax*fRmax;
    l.unlock();
  }
  return fSurfaceArea;
}

Initialize()

void G4Orb::Initialize ( )

protected

Checks radius and initialises data members. Used in constructor.

Definition at line 102 of file G4Orb.cc.

{
  const G4double fEpsilon = 2.e-11;  // relative tolerance of fRmax
 
  // Check radius
  //
  if ( fRmax < 10*kCarTolerance )
  {
    G4Exception("G4Orb::Initialize()", "GeomSolids0002", FatalException,
                "Invalid radius < 10*kCarTolerance.");
  }
  halfRmaxTol = 0.5 * std::max(kCarTolerance, fEpsilon*fRmax);
  G4double rmaxPlusTol  = fRmax + halfRmaxTol;
  G4double rmaxMinusTol = fRmax - halfRmaxTol;
  sqrRmaxPlusTol = rmaxPlusTol*rmaxPlusTol;
  sqrRmaxMinusTol = rmaxMinusTol*rmaxMinusTol;
}

Referenced by G4Orb().

Inside()

EInside G4Orb::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 244 of file G4Orb.cc.

{
  G4double rr = p.mag2();
  if (rr > sqrRmaxPlusTol) { return kOutside; }
  return (rr > sqrRmaxMinusTol) ? kSurface : kInside;
}

Referenced by DistanceToOut().

operator=()

G4Orb & G4Orb::operator=

(

const G4Orb &

rhs

)

Definition at line 78 of file G4Orb.cc.

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

SetRadius()

void G4Orb::SetRadius ( G4double newRmax )

inline

StreamInfo()

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

overridevirtual

Streams the object contents to an output stream.

Reimplemented from G4CSGSolid.

Definition at line 410 of file G4Orb.cc.

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

SurfaceNormal()

G4ThreeVector G4Orb::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 255 of file G4Orb.cc.

{
  return (1/p.mag())*p;
}

---

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

• G4Orb.hh
• G4Orb.cc