G4VSolid Class Reference

G4VSolid is an abstract base class for solids, physical shapes that can be tracked through. Each solid has a name, and the constructors and destructors automatically add and subtract them from the G4SolidStore, a singleton 'master' list of available solids. More...

#include <G4VSolid.hh>

Inheritance diagram for G4VSolid:

Public Member Functions
	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 void	BoundingLimits (G4ThreeVector &pMin, G4ThreeVector &pMax) const
virtual G4bool	CalculateExtent (const EAxis pAxis, const G4VoxelLimits &pVoxelLimit, const G4AffineTransform &pTransform, G4double &pMin, G4double &pMax) const =0
virtual EInside	Inside (const G4ThreeVector &p) const =0
virtual G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const =0
virtual G4double	DistanceToIn (const G4ThreeVector &p, const G4ThreeVector &v) const =0
virtual G4double	DistanceToIn (const G4ThreeVector &p) const =0
virtual G4double	DistanceToOut (const G4ThreeVector &p, const G4ThreeVector &v, const G4bool calcNorm=false, G4bool *validNorm=nullptr, G4ThreeVector *n=nullptr) const =0
virtual G4double	DistanceToOut (const G4ThreeVector &p) const =0
virtual void	ComputeDimensions (G4VPVParameterisation *p, const G4int n, const G4VPhysicalVolume *pRep)
virtual G4double	GetCubicVolume ()
virtual G4double	GetSurfaceArea ()
virtual G4GeometryType	GetEntityType () const =0
virtual G4ThreeVector	GetPointOnSurface () const
virtual G4int	GetNumOfConstituents () const
virtual G4bool	IsFaceted () const
virtual G4VSolid *	Clone () const
virtual std::ostream &	StreamInfo (std::ostream &os) const =0
void	DumpInfo () const
virtual void	DescribeYourselfTo (G4VGraphicsScene &scene) const =0
virtual G4VisExtent	GetExtent () const
virtual G4Polyhedron *	CreatePolyhedron () const
virtual G4Polyhedron *	GetPolyhedron () 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	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
G4double	kCarTolerance

Detailed Description

G4VSolid is an abstract base class for solids, physical shapes that can be tracked through. Each solid has a name, and the constructors and destructors automatically add and subtract them from the G4SolidStore, a singleton 'master' list of available solids.

Definition at line 79 of file G4VSolid.hh.

Constructor & Destructor Documentation

G4VSolid() [1/3]

G4VSolid::G4VSolid

(

const G4String &

name

)

Constructor for G4VSolid. Creates a new shape, with the supplied name. No provision is made for sharing a common name amongst multiple classes.

Parameters

[in]

name

The solid's name.

Definition at line 59 of file G4VSolid.cc.

  : fshapeName(name)
{
    kCarTolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
 
    // Register to store
    //
    G4SolidStore::GetInstance()->Register(this);
}

Referenced by G4MultiUnion::AddNode(), G4MultiUnion::AddNode(), G4Box::Clone(), G4Cons::Clone(), G4CutTubs::Clone(), G4DisplacedSolid::Clone(), G4Ellipsoid::Clone(), G4EllipticalCone::Clone(), G4EllipticalTube::Clone(), G4ExtrudedSolid::Clone(), G4GenericPolycone::Clone(), G4GenericTrap::Clone(), G4Hype::Clone(), G4IntersectionSolid::Clone(), G4MultiUnion::Clone(), G4Orb::Clone(), G4Para::Clone(), G4Paraboloid::Clone(), G4Polycone::Clone(), G4Polyhedra::Clone(), G4ReflectedSolid::Clone(), G4ScaledSolid::Clone(), G4Sphere::Clone(), G4SubtractionSolid::Clone(), G4TessellatedSolid::Clone(), G4Tet::Clone(), G4Torus::Clone(), G4Trap::Clone(), G4Trd::Clone(), G4Tubs::Clone(), G4TwistedBox::Clone(), G4TwistedTrap::Clone(), G4TwistedTrd::Clone(), G4TwistedTubs::Clone(), G4UnionSolid::Clone(), Clone(), G4MultiUnion::CreatePolyhedron(), DescribeYourselfTo(), G4MultiUnion::DistanceToIn(), G4MultiUnion::DistanceToInNoVoxels(), G4MultiUnion::DistanceToOut(), G4MultiUnion::DistanceToOutNoVoxels(), G4MultiUnion::DistanceToOutVoxels(), G4MultiUnion::Extent(), G4BooleanSolid::G4BooleanSolid(), G4BooleanSolid::G4BooleanSolid(), G4BooleanSolid::G4BooleanSolid(), G4BooleanSolid::G4BooleanSolid(), G4BooleanSolid::G4BooleanSolid(), G4CSGSolid::G4CSGSolid(), G4CSGSolid::G4CSGSolid(), G4CSGSolid::G4CSGSolid(), G4DisplacedSolid::G4DisplacedSolid(), G4DisplacedSolid::G4DisplacedSolid(), G4DisplacedSolid::G4DisplacedSolid(), G4DisplacedSolid::G4DisplacedSolid(), G4DisplacedSolid::G4DisplacedSolid(), G4Ellipsoid::G4Ellipsoid(), G4Ellipsoid::G4Ellipsoid(), G4Ellipsoid::G4Ellipsoid(), G4EllipticalCone::G4EllipticalCone(), G4EllipticalCone::G4EllipticalCone(), G4EllipticalCone::G4EllipticalCone(), G4EllipticalTube::G4EllipticalTube(), G4EllipticalTube::G4EllipticalTube(), G4EllipticalTube::G4EllipticalTube(), G4GenericTrap::G4GenericTrap(), G4GenericTrap::G4GenericTrap(), G4GenericTrap::G4GenericTrap(), G4Hype::G4Hype(), G4Hype::G4Hype(), G4Hype::G4Hype(), G4IntersectionSolid::G4IntersectionSolid(), G4IntersectionSolid::G4IntersectionSolid(), G4IntersectionSolid::G4IntersectionSolid(), G4IntersectionSolid::G4IntersectionSolid(), G4MultiUnion::G4MultiUnion(), G4MultiUnion::G4MultiUnion(), G4MultiUnion::G4MultiUnion(), G4MultiUnion::G4MultiUnion(), G4Paraboloid::G4Paraboloid(), G4Paraboloid::G4Paraboloid(), G4Paraboloid::G4Paraboloid(), G4ReflectedSolid::G4ReflectedSolid(), G4ReflectedSolid::G4ReflectedSolid(), G4ScaledSolid::G4ScaledSolid(), G4ScaledSolid::G4ScaledSolid(), G4ScaledSolid::G4ScaledSolid(), G4SubtractionSolid::G4SubtractionSolid(), G4SubtractionSolid::G4SubtractionSolid(), G4SubtractionSolid::G4SubtractionSolid(), G4SubtractionSolid::G4SubtractionSolid(), G4TessellatedSolid::G4TessellatedSolid(), G4TessellatedSolid::G4TessellatedSolid(), G4TessellatedSolid::G4TessellatedSolid(), G4TessellatedSolid::G4TessellatedSolid(), G4Tet::G4Tet(), G4Tet::G4Tet(), G4Tet::G4Tet(), G4TwistedTubs::G4TwistedTubs(), G4TwistedTubs::G4TwistedTubs(), G4TwistedTubs::G4TwistedTubs(), G4TwistedTubs::G4TwistedTubs(), G4TwistedTubs::G4TwistedTubs(), G4TwistedTubs::G4TwistedTubs(), G4UnionSolid::G4UnionSolid(), G4UnionSolid::G4UnionSolid(), G4UnionSolid::G4UnionSolid(), G4VCSGfaceted::G4VCSGfaceted(), G4VCSGfaceted::G4VCSGfaceted(), G4VCSGfaceted::G4VCSGfaceted(), G4VSolid(), G4VTwistedFaceted::G4VTwistedFaceted(), G4VTwistedFaceted::G4VTwistedFaceted(), G4VTwistedFaceted::G4VTwistedFaceted(), G4Trap::GetAlpha2(), G4DisplacedSolid::GetConstituentMovedSolid(), G4ReflectedSolid::GetConstituentMovedSolid(), G4BooleanSolid::GetConstituentSolid(), G4BooleanSolid::GetConstituentSolid(), GetConstituentSolid(), GetConstituentSolid(), G4GenericPolycone::GetCorner(), G4Torus::GetCosEndPhi(), GetEntityType(), G4BooleanSolid::GetListOfPrimitives(), G4Hype::GetOuterStereo(), G4MultiUnion::GetPointOnSurface(), G4Paraboloid::GetRadiusPlusZ(), G4MultiUnion::GetSolid(), G4ScaledSolid::GetUnscaledSolid(), G4MultiUnion::GetVoxels(), G4Box::GetZHalfLength(), G4ExtrudedSolid::GetZSections(), G4EllipticalCone::GetZTopCut(), operator=(), operator==(), G4MultiUnion::SetAccurateSafety(), G4BooleanSolid::SetAreaAccuracy(), G4BooleanSolid::SetCubVolEpsilon(), G4BooleanSolid::SetCubVolStatistics(), G4Cons::SetDeltaPhiAngle(), G4CutTubs::SetDeltaPhiAngle(), G4Tubs::SetDeltaPhiAngle(), G4Sphere::SetDeltaThetaAngle(), G4EllipticalTube::SetDz(), G4Polycone::SetOriginalParameters(), G4Polyhedra::SetOriginalParameters(), G4Orb::SetRadius(), G4Para::SetThetaAndPhi(), G4GenericTrap::SetVisSubdivisions(), G4Ellipsoid::SetZCuts(), G4Trd::SetZHalfLength(), G4BooleanSolid::StackPolyhedron(), G4MultiUnion::StreamInfo(), G4MultiUnion::SurfaceNormal(), G4MultiUnion::~G4MultiUnion(), and G4UnionSolid::~G4UnionSolid().

~G4VSolid()

G4VSolid::~G4VSolid ( )

virtual

Default Destructor.

Definition at line 99 of file G4VSolid.cc.

{
    G4SolidStore::GetInstance()->DeRegister(this);
}

G4VSolid() [2/3]

G4VSolid::G4VSolid

(

const G4VSolid &

rhs

)

Copy constructor and assignment operator.

Definition at line 73 of file G4VSolid.cc.

  : kCarTolerance(rhs.kCarTolerance), fshapeName(rhs.fshapeName)
{
    // Register to store
    //
    G4SolidStore::GetInstance()->Register(this);
}

G4VSolid() [3/3]

G4VSolid::G4VSolid

(

__void__ &

)

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

Definition at line 86 of file G4VSolid.cc.

  : fshapeName("")
{
    // Register to store
    //
    G4SolidStore::GetInstance()->Register(this);
}

Member Function Documentation

BoundingLimits()

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

virtual

Computes the bounding limits of the solid.

Parameters

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

Reimplemented in G4Box, G4Cons, G4CutTubs, G4DisplacedSolid, G4Ellipsoid, G4EllipticalCone, G4EllipticalTube, G4ExtrudedSolid, G4GenericPolycone, G4GenericTrap, G4Hype, G4IntersectionSolid, G4MultiUnion, G4Orb, G4Para, G4Paraboloid, G4Polycone, G4Polyhedra, G4ReflectedSolid, G4ScaledSolid, G4Sphere, G4SubtractionSolid, G4TessellatedSolid, G4Tet, G4Torus, G4Trap, G4Trd, G4Tubs, G4TwistedTubs, G4UnionSolid, and G4VTwistedFaceted.

Definition at line 691 of file G4VSolid.cc.

{
  std::ostringstream message;
  message << "Not implemented for solid: "
          << GetEntityType() << " !"
          << "\nReturning infinite boundinx box.";
  G4Exception("G4VSolid::BoundingLimits()", "GeomMgt1001",
              JustWarning, message);
 
  pMin.set(-kInfinity,-kInfinity,-kInfinity);
  pMax.set( kInfinity, kInfinity, kInfinity);
}

Referenced by G4PVPlacement::CheckOverlaps(), EstimateSurfaceArea(), G4MultiUnion::Extent(), and G4VChannelingFastSimCrystalData::SetBendingAngle().

CalculateClippedPolygonExtent()

void G4VSolid::CalculateClippedPolygonExtent ( G4ThreeVectorList & pPolygon, const G4VoxelLimits & pVoxelLimit, const EAxis pAxis, G4double & pMin, G4double & pMax ) const

protected

Calculates the maximum and minimum extents of the convex polygon 'pPolygon' along the axis 'pAxis', within the limits 'pVoxelLimit'. If the minimum is less than 'pMin', 'pMin' is set to the new minimum. If the maximum is greater than 'pMax', 'pMax' is set to the new maximum. Modifications to 'pPolygon' are made - it is left in an undefined state.

Parameters

[in,out]	pPolygon	The points defining the convex polygon.
[in]	pVoxelLimit	The limiting space dictated by voxels.
[in]	pAxis	The axis along which compute the extent.
[out]	pMin	The minimum extent value.
[out]	pMax	The maximum extent value.

Definition at line 515 of file G4VSolid.cc.

{
  G4int noLeft,i;
  G4double component;
 
  ClipPolygon(pPolygon,pVoxelLimit,pAxis);
  noLeft = (G4int)pPolygon.size();
 
  if ( noLeft != 0 )
  {
    for (i=0; i<noLeft; ++i)
    {
      component = pPolygon[i].operator()(pAxis);
 
      if (component < pMin)
      {
        pMin = component;
      }
      if (component > pMax)
      {
        pMax = component;
      }
    }
  }
}

Referenced by ClipBetweenSections(), and ClipCrossSection().

CalculateExtent()

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

pure virtual

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.

Implemented in G4Box, G4Cons, G4CutTubs, G4DisplacedSolid, G4Ellipsoid, G4EllipticalCone, G4EllipticalTube, G4ExtrudedSolid, G4GenericPolycone, G4GenericTrap, G4Hype, G4IntersectionSolid, G4MultiUnion, G4Orb, G4Para, G4Paraboloid, G4Polycone, G4Polyhedra, G4ReflectedSolid, G4ScaledSolid, G4Sphere, G4SubtractionSolid, G4TessellatedSolid, G4Tet, G4Torus, G4Trap, G4Trd, G4Tubs, G4TwistedTubs, G4UnionSolid, G4VCSGfaceted, and G4VTwistedFaceted.

Referenced by EstimateCubicVolume(), GetExtent(), and G4ITNavigator2::GetRandomInCurrentVolume().

ClipBetweenSections()

void G4VSolid::ClipBetweenSections ( G4ThreeVectorList * pVertices, const G4int pSectionIndex, const G4VoxelLimits & pVoxelLimit, const EAxis pAxis, G4double & pMin, G4double & pMax ) const

protected

Calculates the maximum and minimum extents of the polygons joining the CrossSections at pSectionIndex->pSectionIndex+3 and pSectionIndex+4->pSectionIndex7 in the list 'pVertices', within the boundaries of the voxel limits 'pVoxelLimit'. If the minimum is less than 'pMin', 'pMin' is set to the new minimum. If the maximum is greater than 'pMax', 'pMax' is set to the new maximum. No modifications are made to 'pVertices'.

Parameters

[in]	pVertices	The vertices list defining the convex polygon.
[in]	pSectionIndex	The starting index for vertices.
[in]	pVoxelLimit	The limiting space dictated by voxels.
[in]	pAxis	The axis along which compute the extent.
[out]	pMin	The minimum extent value.
[out]	pMax	The maximum extent value.

Definition at line 470 of file G4VSolid.cc.

{
  G4ThreeVectorList polygon;
  polygon.reserve(4);
  polygon.push_back((*pVertices)[pSectionIndex]);
  polygon.push_back((*pVertices)[pSectionIndex+4]);
  polygon.push_back((*pVertices)[pSectionIndex+5]);
  polygon.push_back((*pVertices)[pSectionIndex+1]);
  CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
  polygon.clear();
 
  polygon.push_back((*pVertices)[pSectionIndex+1]);
  polygon.push_back((*pVertices)[pSectionIndex+5]);
  polygon.push_back((*pVertices)[pSectionIndex+6]);
  polygon.push_back((*pVertices)[pSectionIndex+2]);
  CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
  polygon.clear();
 
  polygon.push_back((*pVertices)[pSectionIndex+2]);
  polygon.push_back((*pVertices)[pSectionIndex+6]);
  polygon.push_back((*pVertices)[pSectionIndex+7]);
  polygon.push_back((*pVertices)[pSectionIndex+3]);
  CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
  polygon.clear();
 
  polygon.push_back((*pVertices)[pSectionIndex+3]);
  polygon.push_back((*pVertices)[pSectionIndex+7]);
  polygon.push_back((*pVertices)[pSectionIndex+4]);
  polygon.push_back((*pVertices)[pSectionIndex]);
  CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
  return;
}

ClipCrossSection()

void G4VSolid::ClipCrossSection ( G4ThreeVectorList * pVertices, const G4int pSectionIndex, const G4VoxelLimits & pVoxelLimit, const EAxis pAxis, G4double & pMin, G4double & pMax ) const

protected

Calculates the maximum and minimum extents of the polygon described by the vertices: pSectionIndex->pSectionIndex+1-> pSectionIndex+2->pSectionIndex+3->pSectionIndex in the list 'pVertices'. If the minimum is less than 'pMin', 'pMin' is set to the new minimum. If the maximum is greater than 'pMax', 'pMax' is set to the new maximum. No modifications are made to 'pVertices'.

Parameters

[in]	pVertices	The vertices list defining the convex polygon.
[in]	pSectionIndex	The starting index for vertices.
[in]	pVoxelLimit	The limiting space dictated by voxels.
[in]	pAxis	The axis along which compute the extent.
[out]	pMin	The minimum extent value.
[out]	pMax	The maximum extent value.

Definition at line 440 of file G4VSolid.cc.

{
 
  G4ThreeVectorList polygon;
  polygon.reserve(4);
  polygon.push_back((*pVertices)[pSectionIndex]);
  polygon.push_back((*pVertices)[pSectionIndex+1]);
  polygon.push_back((*pVertices)[pSectionIndex+2]);
  polygon.push_back((*pVertices)[pSectionIndex+3]);
  CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
  return;
}

ClipPolygon()

void G4VSolid::ClipPolygon ( G4ThreeVectorList & pPolygon, const G4VoxelLimits & pVoxelLimit, const EAxis pAxis ) const

protected

Clips the specified convex polygon to the given limits, where the polygon is described by the vertices at (0),(1),...,(n),(0) in 'pPolygon'. If the polygon is completely clipped away, the polygon is cleared.

Parameters

[in,out]	pPolygon	pPolygon The points defining the convex polygon.
[in]	pVoxelLimit	The limiting space dictated by voxels.
[in]	pAxis	The axis along which apply the clipping.

Definition at line 565 of file G4VSolid.cc.

{
  G4ThreeVectorList outputPolygon;
 
  if ( pVoxelLimit.IsLimited() )
  {
    if (pVoxelLimit.IsXLimited() ) // && pAxis != kXAxis)
    {
      G4VoxelLimits simpleLimit1;
      simpleLimit1.AddLimit(kXAxis,pVoxelLimit.GetMinXExtent(),kInfinity);
      ClipPolygonToSimpleLimits(pPolygon,outputPolygon,simpleLimit1);
 
      pPolygon.clear();
 
      if ( outputPolygon.empty() ) {  return; }
 
      G4VoxelLimits simpleLimit2;
      simpleLimit2.AddLimit(kXAxis,-kInfinity,pVoxelLimit.GetMaxXExtent());
      ClipPolygonToSimpleLimits(outputPolygon,pPolygon,simpleLimit2);
 
      if ( pPolygon.empty() ) { return; }
      outputPolygon.clear();
    }
    if ( pVoxelLimit.IsYLimited() ) // && pAxis != kYAxis)
    {
      G4VoxelLimits simpleLimit1;
      simpleLimit1.AddLimit(kYAxis,pVoxelLimit.GetMinYExtent(),kInfinity);
      ClipPolygonToSimpleLimits(pPolygon,outputPolygon,simpleLimit1);
 
      // Must always clear pPolygon - for clip to simpleLimit2 and in case of
      // early exit
 
      pPolygon.clear();
 
      if ( outputPolygon.empty() ) { return; }
 
      G4VoxelLimits simpleLimit2;
      simpleLimit2.AddLimit(kYAxis,-kInfinity,pVoxelLimit.GetMaxYExtent());
      ClipPolygonToSimpleLimits(outputPolygon,pPolygon,simpleLimit2);
 
      if ( pPolygon.empty() ) { return; }
      outputPolygon.clear();
    }
    if ( pVoxelLimit.IsZLimited() ) // && pAxis != kZAxis)
    {
      G4VoxelLimits simpleLimit1;
      simpleLimit1.AddLimit(kZAxis,pVoxelLimit.GetMinZExtent(),kInfinity);
      ClipPolygonToSimpleLimits(pPolygon,outputPolygon,simpleLimit1);
 
      // Must always clear pPolygon - for clip to simpleLimit2 and in case of
      // early exit
 
      pPolygon.clear();
 
      if ( outputPolygon.empty() ) {  return; }
 
      G4VoxelLimits simpleLimit2;
      simpleLimit2.AddLimit(kZAxis,-kInfinity,pVoxelLimit.GetMaxZExtent());
      ClipPolygonToSimpleLimits(outputPolygon,pPolygon,simpleLimit2);
 
      // Return after final clip - no cleanup
    }
  }
}

Referenced by CalculateClippedPolygonExtent().

Clone()

G4VSolid * G4VSolid::Clone ( ) const

virtual

Returns a pointer of a dynamically allocated copy of the solid. Returns a null pointer with warning in case the concrete solid does not implement this method. The caller has responsibility for ownership.

Reimplemented in G4Box, G4Cons, G4CutTubs, G4DisplacedSolid, G4Ellipsoid, G4EllipticalCone, G4EllipticalTube, G4ExtrudedSolid, G4GenericPolycone, G4GenericTrap, G4Hype, G4IntersectionSolid, G4MultiUnion, G4Orb, G4Para, G4Paraboloid, G4Polycone, G4Polyhedra, G4ReflectedSolid, G4ScaledSolid, G4Sphere, G4SubtractionSolid, G4TessellatedSolid, G4Tet, G4Torus, G4Trap, G4Trd, G4Tubs, G4TwistedBox, G4TwistedTrap, G4TwistedTrd, G4TwistedTubs, and G4UnionSolid.

Definition at line 417 of file G4VSolid.cc.

{
  std::ostringstream message;
  message << "Clone() method not implemented for type: "
          << GetEntityType() << "!" << G4endl
          << "Returning NULL pointer!";
  G4Exception("G4VSolid::Clone()", "GeomMgt1001", JustWarning, message);
  return nullptr;
}

Referenced by G4GeometryWorkspace::CloneReplicaSolid().

ComputeDimensions()

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

virtual

Dispatch method for parameterisation replication mechanism and dimension computation. Throws exception if ComputeDimensions() is called from an illegal derived class.

Reimplemented in G4Box, G4Cons, G4DisplacedSolid, G4Ellipsoid, G4Hype, G4IntersectionSolid, G4Orb, G4Para, G4Polycone, G4Polyhedra, G4ReflectedSolid, G4ScaledSolid, G4Sphere, G4SubtractionSolid, G4Tet, G4Torus, G4Trap, G4Trd, G4Tubs, G4TwistedTubs, G4UnionSolid, and G4VTwistedFaceted.

Definition at line 136 of file G4VSolid.cc.

{
    std::ostringstream message;
    message << "Illegal call to G4VSolid::ComputeDimensions()" << G4endl
            << "Method not overloaded by derived class !";
    G4Exception("G4VSolid::ComputeDimensions()", "GeomMgt0003",
                FatalException, message);
}

Referenced by G4PVParameterised::CheckOverlaps(), G4VPrimitiveScorer::ComputeSolid(), G4LogicalVolumeModel::DescribeYourselfTo(), G4VFieldModel::DescribeYourselfTo(), G4LogicalVolume::GetMass(), G4ITNavigator1::GetMotherToDaughterTransform(), G4ITNavigator2::GetMotherToDaughterTransform(), G4Navigator::GetMotherToDaughterTransform(), G4ITNavigator1::LocateGlobalPointAndSetup(), G4ITNavigator2::LocateGlobalPointAndSetup(), G4Navigator::LocateGlobalPointAndSetup(), G4PSFlatSurfaceCurrent::ProcessHits(), G4PSFlatSurfaceFlux::ProcessHits(), G4PSSphereSurfaceFlux::ProcessHits(), G4PSVolumeFlux::ProcessHits(), G4ITNavigator1::SetupHierarchy(), G4ITNavigator2::SetupHierarchy(), and G4Navigator::SetupHierarchy().

CreatePolyhedron()

G4Polyhedron * G4VSolid::CreatePolyhedron ( ) const

virtual

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

Reimplemented in G4Box, G4Cons, G4CutTubs, G4DisplacedSolid, G4Ellipsoid, G4EllipticalCone, G4EllipticalTube, G4GenericPolycone, G4GenericTrap, G4Hype, G4IntersectionSolid, G4MultiUnion, G4Orb, G4Para, G4Paraboloid, G4Polycone, G4Polyhedra, G4ReflectedSolid, G4ScaledSolid, G4Sphere, G4SubtractionSolid, G4TessellatedSolid, G4Tet, G4Torus, G4Trap, G4Trd, G4Tubs, G4TwistedTubs, G4UnionSolid, G4VCSGfaceted, and G4VTwistedFaceted.

Definition at line 726 of file G4VSolid.cc.

{
  return nullptr;
}

Referenced by G4BooleanSolid::GetPolyhedron(), and G4CSGSolid::GetPolyhedron().

DescribeYourselfTo()

virtual void G4VSolid::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

pure virtual

A "double dispatch" function which identifies the solid to the graphics scene for visualization.

Implemented in G4Box, G4Cons, G4CutTubs, G4DisplacedSolid, G4Ellipsoid, G4EllipticalCone, G4EllipticalTube, G4GenericTrap, G4Hype, G4IntersectionSolid, G4MultiUnion, G4Orb, G4Para, G4Paraboloid, G4ReflectedSolid, G4ScaledSolid, G4Sphere, G4SubtractionSolid, G4TessellatedSolid, G4Tet, G4Torus, G4Trap, G4Trd, G4Tubs, G4TwistedTubs, G4UnionSolid, G4VCSGfaceted, and G4VTwistedFaceted.

Referenced by G4VisManager::Draw().

DistanceToIn() [1/2]

virtual G4double G4VSolid::DistanceToIn ( const G4ThreeVector & p ) const

pure virtual

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.

Implemented in G4Box, G4Cons, G4CutTubs, G4DisplacedSolid, G4Ellipsoid, G4EllipticalCone, G4EllipticalTube, G4ExtrudedSolid, G4GenericPolycone, G4GenericTrap, G4Hype, G4IntersectionSolid, G4MultiUnion, G4Orb, G4Para, G4Paraboloid, G4Polycone, G4Polyhedra, G4ReflectedSolid, G4ScaledSolid, G4Sphere, G4SubtractionSolid, G4TessellatedSolid, G4Tet, G4Torus, G4Trap, G4Trd, G4Tubs, G4TwistedTubs, G4UnionSolid, G4VCSGfaceted, and G4VTwistedFaceted.

DistanceToIn() [2/2]

virtual G4double G4VSolid::DistanceToIn ( const G4ThreeVector & p, const G4ThreeVector & v ) const

pure virtual

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.

Implemented in G4Box, G4Cons, G4CutTubs, G4DisplacedSolid, G4Ellipsoid, G4EllipticalCone, G4EllipticalTube, G4ExtrudedSolid, G4GenericPolycone, G4GenericTrap, G4Hype, G4IntersectionSolid, G4MultiUnion, G4Orb, G4Para, G4Paraboloid, G4Polycone, G4Polyhedra, G4ReflectedSolid, G4ScaledSolid, G4Sphere, G4SubtractionSolid, G4TessellatedSolid, G4Tet, G4Torus, G4Trap, G4Trd, G4Tubs, G4TwistedTubs, G4UnionSolid, G4VCSGfaceted, and G4VTwistedFaceted.

Referenced by G4NavigationLogger::AlongComputeStepLog(), G4NavigationLogger::CheckDaughterEntryPoint(), G4PVParameterised::CheckOverlaps(), G4PVPlacement::CheckOverlaps(), G4NormalNavigation::ComputeSafety(), G4ParameterisedNavigation::ComputeSafety(), G4ReplicaNavigation::ComputeSafety(), G4VoxelNavigation::ComputeSafety(), G4VoxelSafety::ComputeSafety(), G4NormalNavigation::ComputeStep(), G4ParameterisedNavigation::ComputeStep(), G4ReplicaNavigation::ComputeStep(), G4VoxelNavigation::ComputeStep(), G4MultiUnion::DistanceToIn(), G4MultiUnion::DistanceToInNoVoxels(), EstimateSurfaceArea(), G4ITNavigator1::GetLocalExitNormal(), G4ITNavigator2::GetLocalExitNormal(), G4Navigator::GetLocalExitNormal(), G4VIntersectionLocator::LocateGlobalPointWithinVolumeAndCheck(), G4NavigationLogger::PreComputeStepLog(), G4ITNavigator2::RecheckDistanceToCurrentBoundary(), G4NavigationLogger::ReportOutsideMother(), G4NavigationLogger::ReportVolumeAndIntersection(), G4VoxelSafety::SafetyForVoxelNode(), and G4MultiUnion::SurfaceNormal().

DistanceToOut() [1/2]

virtual G4double G4VSolid::DistanceToOut ( const G4ThreeVector & p ) const

pure virtual

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.

Implemented in G4Box, G4Cons, G4CutTubs, G4DisplacedSolid, G4Ellipsoid, G4EllipticalCone, G4EllipticalTube, G4ExtrudedSolid, G4GenericTrap, G4Hype, G4IntersectionSolid, G4MultiUnion, G4Orb, G4Para, G4Paraboloid, G4ReflectedSolid, G4ScaledSolid, G4Sphere, G4SubtractionSolid, G4TessellatedSolid, G4Tet, G4Torus, G4Trap, G4Trd, G4Tubs, G4TwistedTubs, G4UnionSolid, G4VCSGfaceted, and G4VTwistedFaceted.

DistanceToOut() [2/2]

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

pure virtual

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.

Implemented in G4Box, G4Cons, G4CutTubs, G4DisplacedSolid, G4Ellipsoid, G4EllipticalCone, G4EllipticalTube, G4ExtrudedSolid, G4GenericTrap, G4Hype, G4IntersectionSolid, G4MultiUnion, G4Orb, G4Para, G4Paraboloid, G4ReflectedSolid, G4ScaledSolid, G4Sphere, G4SubtractionSolid, G4TessellatedSolid, G4Tet, G4Torus, G4Trap, G4Trd, G4Tubs, G4TwistedTubs, G4UnionSolid, G4VCSGfaceted, and G4VTwistedFaceted.

Referenced by G4NavigationLogger::AlongComputeStepLog(), G4NavigationLogger::CheckDaughterEntryPoint(), G4PVParameterised::CheckOverlaps(), G4PVPlacement::CheckOverlaps(), G4NormalNavigation::ComputeSafety(), G4ParameterisedNavigation::ComputeSafety(), G4ReplicaNavigation::ComputeSafety(), G4VoxelNavigation::ComputeSafety(), G4VoxelSafety::ComputeSafety(), G4NormalNavigation::ComputeStep(), G4ParameterisedNavigation::ComputeStep(), G4ReplicaNavigation::ComputeStep(), G4VoxelNavigation::ComputeStep(), G4RegularNavigation::ComputeStepSkippingEqualMaterials(), G4MultiUnion::DistanceToOut(), G4MultiUnion::DistanceToOutNoVoxels(), G4MultiUnion::DistanceToOutVoxels(), EstimateSurfaceArea(), G4ITNavigator1::GetLocalExitNormal(), G4ITNavigator2::GetLocalExitNormal(), G4Navigator::GetLocalExitNormal(), G4BOptnForceCommonTruncatedExp::Initialize(), G4FastTrack::OnTheBoundaryButExiting(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4MuNeutrinoNucleusProcess::PostStepDoIt(), G4NeutrinoElectronProcess::PostStepDoIt(), G4TauNeutrinoNucleusProcess::PostStepDoIt(), G4ITNavigator2::RecheckDistanceToCurrentBoundary(), G4NavigationLogger::ReportOutsideMother(), G4NavigationLogger::ReportVolumeAndIntersection(), and G4MultiUnion::SurfaceNormal().

DumpInfo()

void G4VSolid::DumpInfo ( ) const

inline

Dumps contents of the solid to the standard output.

Referenced by G4CutTubs::ApproxSurfaceNormal(), G4Tubs::ApproxSurfaceNormal(), G4Box::BoundingLimits(), G4Cons::BoundingLimits(), G4CutTubs::BoundingLimits(), G4DisplacedSolid::BoundingLimits(), G4EllipticalCone::BoundingLimits(), G4ExtrudedSolid::BoundingLimits(), G4GenericPolycone::BoundingLimits(), G4Hype::BoundingLimits(), G4IntersectionSolid::BoundingLimits(), G4Orb::BoundingLimits(), G4Para::BoundingLimits(), G4Paraboloid::BoundingLimits(), G4Polycone::BoundingLimits(), G4Polyhedra::BoundingLimits(), G4ReflectedSolid::BoundingLimits(), G4ScaledSolid::BoundingLimits(), G4Sphere::BoundingLimits(), G4SubtractionSolid::BoundingLimits(), G4TessellatedSolid::BoundingLimits(), G4Torus::BoundingLimits(), G4Trap::BoundingLimits(), G4Trd::BoundingLimits(), G4Tubs::BoundingLimits(), G4TwistedTubs::BoundingLimits(), G4UnionSolid::BoundingLimits(), G4DisplacedSolid::ComputeDimensions(), G4IntersectionSolid::ComputeDimensions(), G4ParameterisationBoxX::ComputeDimensions(), G4ParameterisationBoxY::ComputeDimensions(), G4ParameterisationBoxZ::ComputeDimensions(), G4ParameterisationConsPhi::ComputeDimensions(), G4ParameterisationConsRho::ComputeDimensions(), G4ParameterisationConsZ::ComputeDimensions(), G4ParameterisationParaX::ComputeDimensions(), G4ParameterisationParaY::ComputeDimensions(), G4ParameterisationParaZ::ComputeDimensions(), G4ParameterisationPolyconePhi::ComputeDimensions(), G4ParameterisationPolyconeRho::ComputeDimensions(), G4ParameterisationPolyconeZ::ComputeDimensions(), G4ParameterisationPolyhedraPhi::ComputeDimensions(), G4ParameterisationPolyhedraRho::ComputeDimensions(), G4ParameterisationPolyhedraZ::ComputeDimensions(), G4ParameterisationTrdX::ComputeDimensions(), G4ParameterisationTrdX::ComputeDimensions(), G4ParameterisationTrdY::ComputeDimensions(), G4ParameterisationTrdY::ComputeDimensions(), G4ParameterisationTrdZ::ComputeDimensions(), G4ParameterisationTubsPhi::ComputeDimensions(), G4ParameterisationTubsRho::ComputeDimensions(), G4ParameterisationTubsZ::ComputeDimensions(), G4ReflectedSolid::ComputeDimensions(), G4ScaledSolid::ComputeDimensions(), G4SubtractionSolid::ComputeDimensions(), G4UnionSolid::ComputeDimensions(), G4ParameterisedNavigation::ComputeStep(), G4ReplicaNavigation::ComputeStep(), G4DisplacedSolid::CreatePolyhedron(), G4ScaledSolid::CreatePolyhedron(), G4SubtractionSolid::DistanceToIn(), G4Box::DistanceToOut(), G4Cons::DistanceToOut(), G4Cons::DistanceToOut(), G4CutTubs::DistanceToOut(), G4Ellipsoid::DistanceToOut(), G4EllipticalCone::DistanceToOut(), G4EllipticalCone::DistanceToOut(), G4EllipticalTube::DistanceToOut(), G4EllipticalTube::DistanceToOut(), G4Orb::DistanceToOut(), G4Para::DistanceToOut(), G4Paraboloid::DistanceToOut(), G4Sphere::DistanceToOut(), G4Sphere::DistanceToOut(), G4Torus::DistanceToOut(), G4Torus::DistanceToOut(), G4Trap::DistanceToOut(), G4Trd::DistanceToOut(), G4Tubs::DistanceToOut(), G4Tubs::DistanceToOut(), G4VTwistedFaceted::DistanceToOut(), G4Polycone::G4Polycone(), G4Polyhedra::G4Polyhedra(), G4BooleanSolid::GetConstituentSolid(), G4BooleanSolid::GetConstituentSolid(), G4NavigationLogger::PostComputeStepLog(), G4Box::SurfaceNormal(), G4Ellipsoid::SurfaceNormal(), G4EllipticalCone::SurfaceNormal(), G4EllipticalTube::SurfaceNormal(), G4ExtrudedSolid::SurfaceNormal(), G4Para::SurfaceNormal(), G4Tet::SurfaceNormal(), G4Trap::SurfaceNormal(), and G4Trd::SurfaceNormal().

EstimateCubicVolume()

G4double G4VSolid::EstimateCubicVolume	(	G4int	nStat,
		G4double	epsilon ) const

Calculates the cubic volume only based on the Inside() method. The accuracy is limited by the second argument 'epsilon' or the statistics expressed by 'nStat'.

Parameters

[in]	nStat	The number of points to generate for the calculation.
[in]	epsilon	The accuracy value.

Definition at line 229 of file G4VSolid.cc.

{
  G4int iInside=0;
  G4double px, py, pz, volume, halfepsilon;
  G4double minX=0., maxX=0., minY=0., maxY=0., minZ=0., maxZ=0.;
  G4ThreeVector p;
  EInside in;
 
  // values needed for CalculateExtent signature
  G4VoxelLimits limit; // unlimited
  G4AffineTransform origin;
 
  // min max extents of pSolid along X,Y,Z
  CalculateExtent(kXAxis,limit,origin,minX,maxX);
  CalculateExtent(kYAxis,limit,origin,minY,maxY);
  CalculateExtent(kZAxis,limit,origin,minZ,maxZ);
 
  // limits
  if(nStat < 100) { nStat   = 100; }
  if(epsilon > 0.01) { epsilon = 0.01; }
  halfepsilon = 0.5*epsilon;
 
  G4QuickRand(1234567890); // set seed
  for(auto i = 0; i < nStat; ++i )
  {
    px = minX-halfepsilon+(maxX-minX+epsilon)*G4QuickRand();
    py = minY-halfepsilon+(maxY-minY+epsilon)*G4QuickRand();
    pz = minZ-halfepsilon+(maxZ-minZ+epsilon)*G4QuickRand();
    p  = G4ThreeVector(px,py,pz);
    in = Inside(p);
    if(in != kOutside) { ++iInside; }
  }
  volume = (maxX-minX+epsilon)*(maxY-minY+epsilon)
         * (maxZ-minZ+epsilon)*iInside/nStat;
  return volume;
}

Referenced by G4BooleanSolid::GetCubicVolume(), G4MultiUnion::GetCubicVolume(), G4VCSGfaceted::GetCubicVolume(), and GetCubicVolume().

EstimateSurfaceArea()

G4double G4VSolid::EstimateSurfaceArea	(	G4int	nStat,
		G4double	epsilon ) const

Calculates the surface area only based on the Inside() method. The accuracy is limited by the second argument 'epsilon' or the statistics expressed by 'nStat'.

Parameters

[in]	nStat	The number of points to generate for the calculation.
[in]	epsilon	The accuracy value.

Definition at line 290 of file G4VSolid.cc.

{
  static const G4double s2 = 1./std::sqrt(2.);
  static const G4double s3 = 1./std::sqrt(3.);
  static const G4ThreeVector directions[64] =
  {
    G4ThreeVector(  0,  0,  0), G4ThreeVector( -1,  0,  0), // (  ,  ,  ) ( -,  ,  )
    G4ThreeVector(  1,  0,  0), G4ThreeVector( -1,  0,  0), // ( +,  ,  ) (-+,  ,  )
    G4ThreeVector(  0, -1,  0), G4ThreeVector(-s2,-s2,  0), // (  , -,  ) ( -, -,  )
    G4ThreeVector( s2, -s2, 0), G4ThreeVector(  0, -1,  0), // ( +, -,  ) (-+, -,  )
 
    G4ThreeVector(  0,  1,  0), G4ThreeVector( -s2, s2, 0), // (  , +,  ) ( -, +,  )
    G4ThreeVector( s2, s2,  0), G4ThreeVector(  0,  1,  0), // ( +, +,  ) (-+, +,  )
    G4ThreeVector(  0, -1,  0), G4ThreeVector( -1,  0,  0), // (  ,-+,  ) ( -,-+,  )
    G4ThreeVector(  1,  0,  0), G4ThreeVector( -1,  0,  0), // ( +,-+,  ) (-+,-+,  )
 
    G4ThreeVector(  0,  0, -1), G4ThreeVector(-s2,  0,-s2), // (  ,  , -) ( -,  , -)
    G4ThreeVector( s2,  0,-s2), G4ThreeVector(  0,  0, -1), // ( +,  , -) (-+,  , -)
    G4ThreeVector(  0,-s2,-s2), G4ThreeVector(-s3,-s3,-s3), // (  , -, -) ( -, -, -)
    G4ThreeVector( s3,-s3,-s3), G4ThreeVector(  0,-s2,-s2), // ( +, -, -) (-+, -, -)
 
    G4ThreeVector(  0, s2,-s2), G4ThreeVector(-s3, s3,-s3), // (  , +, -) ( -, +, -)
    G4ThreeVector( s3, s3,-s3), G4ThreeVector(  0, s2,-s2), // ( +, +, -) (-+, +, -)
    G4ThreeVector(  0,  0, -1), G4ThreeVector(-s2,  0,-s2), // (  ,-+, -) ( -,-+, -)
    G4ThreeVector( s2,  0,-s2), G4ThreeVector(  0,  0, -1), // ( +,-+, -) (-+,-+, -)
 
    G4ThreeVector(  0,  0,  1), G4ThreeVector(-s2,  0, s2), // (  ,  , +) ( -,  , +)
    G4ThreeVector( s2,  0, s2), G4ThreeVector(  0,  0,  1), // ( +,  , +) (-+,  , +)
    G4ThreeVector(  0,-s2, s2), G4ThreeVector(-s3,-s3, s3), // (  , -, +) ( -, -, +)
    G4ThreeVector( s3,-s3, s3), G4ThreeVector(  0,-s2, s2), // ( +, -, +) (-+, -, +)
 
    G4ThreeVector(  0, s2, s2), G4ThreeVector(-s3, s3, s3), // (  , +, +) ( -, +, +)
    G4ThreeVector( s3, s3, s3), G4ThreeVector(  0, s2, s2), // ( +, +, +) (-+, +, +)
    G4ThreeVector(  0,  0,  1), G4ThreeVector(-s2,  0, s2), // (  ,-+, +) ( -,-+, +)
    G4ThreeVector( s2,  0, s2), G4ThreeVector(  0,  0,  1), // ( +,-+, +) (-+,-+, +)
 
    G4ThreeVector(  0,  0, -1), G4ThreeVector( -1,  0,  0), // (  ,  ,-+) ( -,  ,-+)
    G4ThreeVector(  1,  0,  0), G4ThreeVector( -1,  0,  0), // ( +,  ,-+) (-+,  ,-+)
    G4ThreeVector(  0, -1,  0), G4ThreeVector(-s2,-s2,  0), // (  , -,-+) ( -, -,-+)
    G4ThreeVector( s2, -s2, 0), G4ThreeVector(  0, -1,  0), // ( +, -,-+) (-+, -,-+)
 
    G4ThreeVector(  0,  1,  0), G4ThreeVector( -s2, s2, 0), // (  , +,-+) ( -, +,-+)
    G4ThreeVector( s2, s2,  0), G4ThreeVector(  0,  1,  0), // ( +, +,-+) (-+, +,-+)
    G4ThreeVector(  0, -1,  0), G4ThreeVector( -1,  0,  0), // (  ,-+,-+) ( -,-+,-+)
    G4ThreeVector(  1,  0,  0), G4ThreeVector( -1,  0,  0), // ( +,-+,-+) (-+,-+,-+)
  };
 
  G4ThreeVector bmin, bmax;
  BoundingLimits(bmin, bmax);
 
  G4double dX = bmax.x() - bmin.x();
  G4double dY = bmax.y() - bmin.y();
  G4double dZ = bmax.z() - bmin.z();
 
  // Define statistics and shell thickness
  //
  G4int npoints = (nstat < 1000) ? 1000 : nstat;
  G4double coeff = 0.5 / std::cbrt(G4double(npoints));
  G4double eps = (ell > 0) ? ell : coeff * std::min(std::min(dX, dY), dZ);
  G4double del = 1.8 * eps; // shold be more than sqrt(3.)
 
  G4double minX = bmin.x() - eps;
  G4double minY = bmin.y() - eps;
  G4double minZ = bmin.z() - eps;
 
  G4double dd = 2. * eps;
  dX += dd;
  dY += dd;
  dZ += dd;
 
  // Calculate surface area
  //
  G4QuickRand(1234567890); // set seed
  G4int icount = 0;
  for(auto i = 0; i < npoints; ++i)
  {
    G4double px = minX + dX*G4QuickRand();
    G4double py = minY + dY*G4QuickRand();
    G4double pz = minZ + dZ*G4QuickRand();
    G4ThreeVector p  = G4ThreeVector(px, py, pz);
    EInside in = Inside(p);
    G4double dist = 0;
    if (in == kInside)
    {
      if (DistanceToOut(p) >= eps) { continue; }
      G4int icase = 0;
      if (Inside(G4ThreeVector(px-del, py, pz)) != kInside) { icase += 1; }
      if (Inside(G4ThreeVector(px+del, py, pz)) != kInside) { icase += 2; }
      if (Inside(G4ThreeVector(px, py-del, pz)) != kInside) { icase += 4; }
      if (Inside(G4ThreeVector(px, py+del, pz)) != kInside) { icase += 8; }
      if (Inside(G4ThreeVector(px, py, pz-del)) != kInside) { icase += 16; }
      if (Inside(G4ThreeVector(px, py, pz+del)) != kInside) { icase += 32; }
      if (icase == 0) { continue; }
      G4ThreeVector v = directions[icase];
      dist = DistanceToOut(p, v);
      G4ThreeVector n = SurfaceNormal(p + v*dist);
      dist *= v.dot(n);
    }
    else if (in == kOutside)
    {
      if (DistanceToIn(p) >= eps) { continue; }
      G4int icase = 0;
      if (Inside(G4ThreeVector(px-del, py, pz)) != kOutside) { icase += 1; }
      if (Inside(G4ThreeVector(px+del, py, pz)) != kOutside) { icase += 2; }
      if (Inside(G4ThreeVector(px, py-del, pz)) != kOutside) { icase += 4; }
      if (Inside(G4ThreeVector(px, py+del, pz)) != kOutside) { icase += 8; }
      if (Inside(G4ThreeVector(px, py, pz-del)) != kOutside) { icase += 16; }
      if (Inside(G4ThreeVector(px, py, pz+del)) != kOutside) { icase += 32; }
      if (icase == 0) { continue; }
      G4ThreeVector v = directions[icase];
      dist = DistanceToIn(p, v);
      if (dist == kInfinity) { continue; }
      G4ThreeVector n = SurfaceNormal(p + v*dist);
      dist *= -(v.dot(n));
    }
    if (dist < eps) { ++icount; }
  }
  return dX*dY*dZ*icount/npoints/dd;
}

Referenced by G4BooleanSolid::GetSurfaceArea(), G4MultiUnion::GetSurfaceArea(), G4VCSGfaceted::GetSurfaceArea(), and GetSurfaceArea().

GetConstituentSolid() [1/2]

G4VSolid * G4VSolid::GetConstituentSolid ( G4int no )

virtual

Reimplemented in G4BooleanSolid.

Definition at line 190 of file G4VSolid.cc.

{
  return nullptr;
}

GetConstituentSolid() [2/2]

const G4VSolid * G4VSolid::GetConstituentSolid ( G4int no ) const

virtual

If the solid is made up from a Boolean operation of two solids, it returns the number 'no' solid. If the solid is not a "Boolean", it returns a null pointer.

Reimplemented in G4BooleanSolid.

Definition at line 185 of file G4VSolid.cc.

{
  return nullptr;
}

Referenced by G4BooleanSolid::StackPolyhedron().

GetCubicVolume()

G4double G4VSolid::GetCubicVolume ( )

virtual

Returns an estimation of the solid volume 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 in G4BooleanSolid, G4Box, G4Cons, G4CutTubs, G4DisplacedSolid, G4Ellipsoid, G4EllipticalCone, G4EllipticalTube, G4GenericPolycone, G4GenericTrap, G4Hype, G4MultiUnion, G4Orb, G4Para, G4Paraboloid, G4Polycone, G4Polyhedra, G4ReflectedSolid, G4ScaledSolid, G4Sphere, G4SubtractionSolid, G4TessellatedSolid, G4Tet, G4Torus, G4Trap, G4Trd, G4Tubs, G4TwistedBox, G4TwistedTrd, G4TwistedTubs, G4UnionSolid, G4VCSGfaceted, and G4VTwistedFaceted.

Definition at line 214 of file G4VSolid.cc.

{
  G4int cubVolStatistics = 1000000;
  G4double cubVolEpsilon = 0.001;
  return EstimateCubicVolume(cubVolStatistics, cubVolEpsilon);
}

Referenced by G4PSCellFlux::ComputeVolume(), G4PSDoseDeposit::ComputeVolume(), G4PSPassageCellFlux::ComputeVolume(), and G4LogicalVolume::GetMass().

GetDisplacedSolidPtr() [1/2]

G4DisplacedSolid * G4VSolid::GetDisplacedSolidPtr ( )

virtual

Reimplemented in G4DisplacedSolid.

Definition at line 200 of file G4VSolid.cc.

{
  return nullptr;
}

GetDisplacedSolidPtr() [2/2]

const G4DisplacedSolid * G4VSolid::GetDisplacedSolidPtr ( ) const

virtual

If the solid is a "G4DisplacedSolid", it returns a self pointer else it returns a null pointer.

Reimplemented in G4DisplacedSolid.

Definition at line 195 of file G4VSolid.cc.

{
  return nullptr;
}

GetEntityType()

virtual G4GeometryType G4VSolid::GetEntityType ( ) const

pure virtual

Provides identification of the class of an object (required for persistency).

Implemented in G4BooleanSolid, G4Box, G4Cons, G4CutTubs, G4DisplacedSolid, G4Ellipsoid, G4EllipticalCone, G4EllipticalTube, G4ExtrudedSolid, G4GenericPolycone, G4GenericTrap, G4Hype, G4IntersectionSolid, G4MultiUnion, G4Orb, G4Para, G4Paraboloid, G4Polycone, G4Polyhedra, G4ReflectedSolid, G4ScaledSolid, G4Sphere, G4SubtractionSolid, G4TessellatedSolid, G4Tet, G4Torus, G4Trap, G4Trd, G4Tubs, G4TwistedBox, G4TwistedTrap, G4TwistedTrd, G4TwistedTubs, G4UnionSolid, G4VCSGfaceted, and G4VTwistedFaceted.

Referenced by G4GMocrenFileSceneHandler::AddPrimitive(), G4GDMLWriteSolids::AddSolid(), BoundingLimits(), G4tgbVolume::BuildSolidForDivision(), G4PVPlacement::CheckOverlaps(), Clone(), G4GeometryWorkspace::CloneReplicaSolid(), G4VoxelNavigation::ComputeSafety(), G4NavigationLogger::ComputeSafetyLog(), G4VDivisionParameterisation::ComputeSolid(), G4PhysicalVolumeModel::CreateCurrentAttValues(), G4tgbGeometryDumper::DumpPVParameterised(), G4tgbGeometryDumper::DumpSolid(), G4tgbVolume::FindOrConstructG4Solid(), G4DisplacedSolid::G4DisplacedSolid(), G4DisplacedSolid::G4DisplacedSolid(), G4DisplacedSolid::G4DisplacedSolid(), G4VParameterisationBox::G4VParameterisationBox(), G4VParameterisationCons::G4VParameterisationCons(), G4VParameterisationPara::G4VParameterisationPara(), G4VParameterisationPolycone::G4VParameterisationPolycone(), G4VParameterisationPolyhedra::G4VParameterisationPolyhedra(), G4VParameterisationTrd::G4VParameterisationTrd(), G4VParameterisationTubs::G4VParameterisationTubs(), G4Navigator::GetGlobalExitNormal(), G4BooleanSolid::GetListOfPrimitives(), G4ITNavigator1::GetLocalExitNormal(), G4ITNavigator2::GetLocalExitNormal(), G4Navigator::GetLocalExitNormal(), GetPointOnSurface(), G4tgbGeometryDumper::GetSolidParams(), G4NavigationLogger::PostComputeStepLog(), G4NavigationLogger::PreComputeStepLog(), G4NavigationLogger::PrintDaughterLog(), G4NavigationLogger::ReportOutsideMother(), G4ASCIITreeSceneHandler::RequestPrimitives(), G4VoxelSafety::SafetyForVoxelHeader(), G4BooleanSolid::SetCubVolEpsilon(), G4BooleanSolid::SetCubVolStatistics(), G4BooleanSolid::StackPolyhedron(), G4CSGSolid::StreamInfo(), G4GeomTestVolume::TestOverlapInTree(), and G4PhysicalVolumeModel::VisitGeometryAndGetVisReps().

GetExtent()

G4VisExtent G4VSolid::GetExtent ( ) const

virtual

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

Reimplemented in G4Box, G4Ellipsoid, G4EllipticalCone, G4EllipticalTube, G4GenericTrap, G4Hype, G4Orb, G4Sphere, G4TessellatedSolid, G4Tet, G4TwistedTubs, G4VCSGfaceted, and G4VTwistedFaceted.

Definition at line 708 of file G4VSolid.cc.

{
  G4VisExtent extent;
  G4VoxelLimits voxelLimits;  // Defaults to "infinite" limits.
  G4AffineTransform affineTransform;
  G4double vmin, vmax;
  CalculateExtent(kXAxis,voxelLimits,affineTransform,vmin,vmax);
  extent.SetXmin (vmin);
  extent.SetXmax (vmax);
  CalculateExtent(kYAxis,voxelLimits,affineTransform,vmin,vmax);
  extent.SetYmin (vmin);
  extent.SetYmax (vmax);
  CalculateExtent(kZAxis,voxelLimits,affineTransform,vmin,vmax);
  extent.SetZmin (vmin);
  extent.SetZmax (vmax);
  return extent;
}

Referenced by G4tgbVolume::BuildSolidForDivision(), G4PhysicalVolumeModel::CreateCurrentAttValues(), and G4VisCommandsTouchable::SetNewValue().

GetName()

G4String G4VSolid::GetName ( ) const

inline

Getter/setter for the shape's name.

Referenced by G4GMocrenFileSceneHandler::AddPrimitive(), G4GDMLWriteSolids::AddSolid(), G4GMocrenFileSceneHandler::AddSolid(), G4GMocrenFileSceneHandler::AddSolid(), G4VtkSceneHandler::AddSolid(), G4NavigationLogger::AlongComputeStepLog(), G4GDMLWriteSolids::BooleanWrite(), G4Box::BoundingLimits(), G4Cons::BoundingLimits(), G4CutTubs::BoundingLimits(), G4DisplacedSolid::BoundingLimits(), G4EllipticalCone::BoundingLimits(), G4ExtrudedSolid::BoundingLimits(), G4GenericPolycone::BoundingLimits(), G4Hype::BoundingLimits(), G4IntersectionSolid::BoundingLimits(), G4Orb::BoundingLimits(), G4Para::BoundingLimits(), G4Paraboloid::BoundingLimits(), G4Polycone::BoundingLimits(), G4Polyhedra::BoundingLimits(), G4ReflectedSolid::BoundingLimits(), G4ScaledSolid::BoundingLimits(), G4Sphere::BoundingLimits(), G4SubtractionSolid::BoundingLimits(), G4TessellatedSolid::BoundingLimits(), G4Torus::BoundingLimits(), G4Trap::BoundingLimits(), G4Trd::BoundingLimits(), G4Tubs::BoundingLimits(), G4TwistedTubs::BoundingLimits(), G4UnionSolid::BoundingLimits(), G4GDMLWriteSolids::BoxWrite(), G4ExtrudedSolid::CalculateExtent(), G4GenericPolycone::CalculateExtent(), G4Polycone::CalculateExtent(), G4Polyhedra::CalculateExtent(), G4NavigationLogger::CheckDaughterEntryPoint(), G4VoxelNavigation::ComputeSafety(), G4VoxelSafety::ComputeSafety(), G4NavigationLogger::ComputeSafetyLog(), G4ParameterisedNavigation::ComputeStep(), G4ReplicaNavigation::ComputeStep(), G4GDMLWriteSolids::ConeWrite(), G4PhysicalVolumeModel::CreateCurrentAttValues(), G4ReflectedSolid::CreatePolyhedron(), G4GDMLWriteSolids::CutTubeWrite(), G4SolidStore::DeRegister(), G4Paraboloid::DistanceToIn(), G4TessellatedSolid::DistanceToIn(), G4Box::DistanceToOut(), G4Ellipsoid::DistanceToOut(), G4EllipticalCone::DistanceToOut(), G4EllipticalTube::DistanceToOut(), G4EllipticalTube::DistanceToOut(), G4Orb::DistanceToOut(), G4Para::DistanceToOut(), G4TessellatedSolid::DistanceToOut(), G4Trap::DistanceToOut(), G4Trd::DistanceToOut(), G4tgbGeometryDumper::DumpMultiUnionVolume(), G4tgbGeometryDumper::DumpScaledVolume(), G4tgbGeometryDumper::DumpSolid(), G4GDMLWriteSolids::ElconeWrite(), G4GDMLWriteSolids::EllipsoidWrite(), G4GDMLWriteSolids::EltubeWrite(), G4Box::G4Box(), G4Cons::G4Cons(), G4CutTubs::G4CutTubs(), G4EllipticalCone::G4EllipticalCone(), G4Hype::G4Hype(), G4Para::G4Para(), G4Paraboloid::G4Paraboloid(), G4Polycone::G4Polycone(), G4Polyhedra::G4Polyhedra(), G4Polyhedra::G4Polyhedra(), G4Sphere::G4Sphere(), G4Tet::G4Tet(), G4Trap::G4Trap(), G4Tubs::G4Tubs(), G4VTwistedFaceted::G4VTwistedFaceted(), G4GDMLWriteSolids::GenericPolyconeWrite(), G4GDMLWriteSolids::GenTrapWrite(), G4Navigator::GetGlobalExitNormal(), G4ITNavigator1::GetLocalExitNormal(), G4ITNavigator2::GetLocalExitNormal(), G4Navigator::GetLocalExitNormal(), G4BooleanSolid::GetPointOnSurface(), G4GDMLWriteSolids::HypeWrite(), G4ITNavigator1::LocateGlobalPointAndSetup(), G4ITNavigator2::LocateGlobalPointAndSetup(), G4Navigator::LocateGlobalPointAndSetup(), G4Trap::MakePlanes(), G4GDMLWriteSolids::MultiUnionWrite(), G4GDMLWriteSolids::OrbWrite(), G4GDMLWriteSolids::ParaboloidWrite(), G4GDMLWriteParamvol::ParametersWrite(), G4GDMLWriteSolids::ParaWrite(), G4GDMLWriteSolids::PolyconeWrite(), G4GDMLWriteSolids::PolyhedraWrite(), G4NavigationLogger::PostComputeStepLog(), G4NavigationLogger::PreComputeStepLog(), G4NavigationLogger::PrintDaughterLog(), G4PseudoScene::ProcessVolume(), G4SolidStore::Register(), G4tgbVolumeMgr::RegisterMe(), G4NavigationLogger::ReportOutsideMother(), G4ASCIITreeSceneHandler::RequestPrimitives(), G4VSceneHandler::RequestPrimitives(), G4GenericPolycone::Reset(), G4Polyhedra::Reset(), G4VoxelSafety::SafetyForVoxelNode(), G4GDMLWriteSolids::ScaledWrite(), G4Torus::SetAllParameters(), G4Tet::SetBoundingLimits(), G4TessellatedSolid::SetSolidClosed(), G4Tet::SetVertices(), G4Box::SetXHalfLength(), G4Box::SetYHalfLength(), G4Box::SetZHalfLength(), G4GDMLWriteSolids::SphereWrite(), G4BooleanSolid::StackPolyhedron(), G4BooleanSolid::StreamInfo(), G4Box::StreamInfo(), G4Cons::StreamInfo(), G4CSGSolid::StreamInfo(), G4CutTubs::StreamInfo(), G4DisplacedSolid::StreamInfo(), G4Ellipsoid::StreamInfo(), G4EllipticalCone::StreamInfo(), G4EllipticalTube::StreamInfo(), G4ExtrudedSolid::StreamInfo(), G4GenericPolycone::StreamInfo(), G4GenericTrap::StreamInfo(), G4Hype::StreamInfo(), G4MultiUnion::StreamInfo(), G4Orb::StreamInfo(), G4Para::StreamInfo(), G4Paraboloid::StreamInfo(), G4Polycone::StreamInfo(), G4Polyhedra::StreamInfo(), G4ReflectedSolid::StreamInfo(), G4ScaledSolid::StreamInfo(), G4Sphere::StreamInfo(), G4TessellatedSolid::StreamInfo(), G4Tet::StreamInfo(), G4Torus::StreamInfo(), G4Trap::StreamInfo(), G4Trd::StreamInfo(), G4Tubs::StreamInfo(), G4TwistedBox::StreamInfo(), G4TwistedTrap::StreamInfo(), G4TwistedTrd::StreamInfo(), G4TwistedTubs::StreamInfo(), G4VCSGfaceted::StreamInfo(), G4VTwistedFaceted::StreamInfo(), G4GDMLRead::StripNames(), SubstractSolids(), G4Box::SurfaceNormal(), G4Ellipsoid::SurfaceNormal(), G4EllipticalCone::SurfaceNormal(), G4EllipticalTube::SurfaceNormal(), G4ExtrudedSolid::SurfaceNormal(), G4Para::SurfaceNormal(), G4Tet::SurfaceNormal(), G4Trap::SurfaceNormal(), G4Trd::SurfaceNormal(), G4UnionSolid::SurfaceNormal(), G4GDMLWriteSolids::TessellatedWrite(), G4GDMLWriteSolids::TetWrite(), G4GDMLWriteSolids::TorusWrite(), G4GDMLWriteSolids::TrapWrite(), G4GDMLWriteStructure::TraverseVolumeTree(), G4GDMLWriteSolids::TrdWrite(), G4GDMLWriteSolids::TubeWrite(), G4GDMLWriteSolids::TwistedboxWrite(), G4GDMLWriteSolids::TwistedtrapWrite(), G4GDMLWriteSolids::TwistedtrdWrite(), G4GDMLWriteSolids::TwistedtubsWrite(), G4PhysicalVolumeModel::VisitGeometryAndGetVisReps(), and G4GDMLWriteSolids::XtruWrite().

GetNumOfConstituents()

G4int G4VSolid::GetNumOfConstituents ( ) const

virtual

Returns the number of constituents used for construction of the solid. For non-Boolean solids the return value is one.

Reimplemented in G4BooleanSolid, G4DisplacedSolid, G4MultiUnion, G4ReflectedSolid, and G4ScaledSolid.

Definition at line 167 of file G4VSolid.cc.

{
  return 1;
}

Referenced by G4MultiUnion::GetNumOfConstituents().

GetPointOnSurface()

G4ThreeVector G4VSolid::GetPointOnSurface ( ) const

virtual

Returns a random point located on the surface of the solid. Points returned are not necessarily uniformly distributed.

Reimplemented in G4BooleanSolid, G4Box, G4Cons, G4CutTubs, G4DisplacedSolid, G4Ellipsoid, G4EllipticalCone, G4EllipticalTube, G4GenericPolycone, G4GenericTrap, G4Hype, G4MultiUnion, G4Orb, G4Para, G4Paraboloid, G4Polycone, G4Polyhedra, G4ReflectedSolid, G4ScaledSolid, G4Sphere, G4TessellatedSolid, G4Tet, G4Torus, G4Trap, G4Trd, G4Tubs, G4TwistedTubs, and G4VTwistedFaceted.

Definition at line 151 of file G4VSolid.cc.

{
    std::ostringstream message;
    message << "Not implemented for solid: "
            << GetEntityType() << " !" << G4endl
            << "Returning origin.";
    G4Exception("G4VSolid::GetPointOnSurface()", "GeomMgt1001",
                JustWarning, message);
    return {0,0,0};
}

Referenced by G4PVParameterised::CheckOverlaps(), G4PVPlacement::CheckOverlaps(), G4LogicalVolumeModel::DescribeYourselfTo(), G4MultiUnion::GetPointOnSurface(), and G4VSceneHandler::RequestPrimitives().

GetPolyhedron()

G4Polyhedron * G4VSolid::GetPolyhedron ( ) const

virtual

Smart access function - creates on request and stores for future access. A null pointer means "not available".

Reimplemented in G4BooleanSolid, G4CSGSolid, G4DisplacedSolid, G4Ellipsoid, G4EllipticalCone, G4EllipticalTube, G4GenericTrap, G4Hype, G4MultiUnion, G4Paraboloid, G4ReflectedSolid, G4ScaledSolid, G4TessellatedSolid, G4Tet, G4TwistedTubs, G4VCSGfaceted, and G4VTwistedFaceted.

Definition at line 731 of file G4VSolid.cc.

{
  return nullptr;
}

Referenced by G4ASCIITreeSceneHandler::RequestPrimitives(), G4VSceneHandler::RequestPrimitives(), G4VisCommandsTouchable::SetNewValue(), G4BooleanSolid::StackPolyhedron(), and G4VSceneHandler::StandardSpecialMeshRendering().

GetSurfaceArea()

G4double G4VSolid::GetSurfaceArea ( )

virtual

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 in G4BooleanSolid, G4Box, G4Cons, G4CutTubs, G4DisplacedSolid, G4Ellipsoid, G4EllipticalCone, G4EllipticalTube, G4GenericPolycone, G4GenericTrap, G4Hype, G4MultiUnion, G4Orb, G4Para, G4Paraboloid, G4Polycone, G4Polyhedra, G4ReflectedSolid, G4ScaledSolid, G4Sphere, G4TessellatedSolid, G4Tet, G4Torus, G4Trap, G4Trd, G4Tubs, G4TwistedBox, G4TwistedTrd, G4TwistedTubs, G4VCSGfaceted, and G4VTwistedFaceted.

Definition at line 275 of file G4VSolid.cc.

{
  G4int stat = 1000000;
  G4double ell = -1.;
  return EstimateSurfaceArea(stat,ell);
}

Referenced by G4AdjointCrossSurfChecker::AddanExtSurfaceOfAvolume(), G4ScaledSolid::GetSurfaceArea(), and G4PSVolumeFlux::ProcessHits().

GetTolerance()

G4double G4VSolid::GetTolerance ( ) const

inline

Returns the cached geometrical tolerance.

Referenced by G4NavigationLogger::CheckDaughterEntryPoint(), G4ParameterisedNavigation::ComputeStep(), G4NavigationLogger::PreComputeStepLog(), G4NavigationLogger::ReportOutsideMother(), and G4NavigationLogger::ReportVolumeAndIntersection().

Inside()

virtual EInside G4VSolid::Inside ( const G4ThreeVector & p ) const

pure virtual

Returns the characterisation of a point at offset 'p' respect to the shape.

Parameters

[in]

p

The point at offset p.

Returns

kOutside if the point is outside the shapes boundaries plus Tolerance/2; kSurface if the point is less than Tolerance/2 from a surface; kInside otherwise.

Implemented in G4Box, G4Cons, G4CutTubs, G4DisplacedSolid, G4Ellipsoid, G4EllipticalCone, G4EllipticalTube, G4ExtrudedSolid, G4GenericPolycone, G4GenericTrap, G4Hype, G4IntersectionSolid, G4MultiUnion, G4Orb, G4Para, G4Paraboloid, G4Polycone, G4Polyhedra, G4ReflectedSolid, G4ScaledSolid, G4Sphere, G4SubtractionSolid, G4TessellatedSolid, G4Tet, G4Torus, G4Trap, G4Trd, G4Tubs, G4TwistedTubs, G4UnionSolid, G4VCSGfaceted, and G4VTwistedFaceted.

Referenced by G4NavigationLogger::AlongComputeStepLog(), G4ReplicaNavigation::BackLocate(), G4NavigationLogger::CheckDaughterEntryPoint(), G4PVParameterised::CheckOverlaps(), G4PVPlacement::CheckOverlaps(), G4VoxelNavigation::ComputeSafety(), G4VoxelSafety::ComputeSafety(), G4ParameterisedNavigation::ComputeStep(), G4ReplicaNavigation::ComputeStep(), G4RegularNavigation::ComputeStepSkippingEqualMaterials(), G4TheRayTracer::CreateBitMap(), G4DNAMolecularDissociation::DecayIt(), G4LogicalVolumeModel::DescribeYourselfTo(), G4VFieldModel::DescribeYourselfTo(), G4PolyPhiFace::Diagnose(), G4MultiUnion::DistanceToOut(), G4MultiUnion::DistanceToOutNoVoxels(), G4MultiUnion::DistanceToOutVoxels(), EstimateCubicVolume(), EstimateSurfaceArea(), G4ITNavigator1::GetLocalExitNormal(), G4ITNavigator2::GetLocalExitNormal(), G4Navigator::GetLocalExitNormal(), G4XrayReflection::GetMeanFreePath(), G4BooleanSolid::GetPointOnSurface(), G4ITNavigator2::GetRandomInCurrentVolume(), G4VExternalNavigation::Inside(), G4ITNavigator2::InsideCurrentVolume(), G4ITNavigator1::LocateGlobalPointAndSetup(), G4ITNavigator2::LocateGlobalPointAndSetup(), G4Navigator::LocateGlobalPointAndSetup(), G4VIntersectionLocator::LocateGlobalPointWithinVolumeAndCheck(), G4NavigationLogger::PreComputeStepLog(), G4ITNavigator2::RecheckDistanceToCurrentBoundary(), G4NavigationLogger::ReportOutsideMother(), G4NavigationLogger::ReportVolumeAndIntersection(), and G4MultiUnion::SurfaceNormal().

IsFaceted()

G4bool G4VSolid::IsFaceted ( ) const

virtual

Returns true if the solid has only planar faces, false otherwise.

Reimplemented in G4BooleanSolid, G4Box, G4DisplacedSolid, G4ExtrudedSolid, G4GenericTrap, G4MultiUnion, G4Para, G4Polyhedra, G4ReflectedSolid, G4ScaledSolid, G4TessellatedSolid, G4Tet, G4Trap, and G4Trd.

Definition at line 176 of file G4VSolid.cc.

{
  return false;
}

Referenced by G4MultiUnion::IsFaceted().

operator=()

G4VSolid & G4VSolid::operator=

(

const G4VSolid &

rhs

)

Definition at line 108 of file G4VSolid.cc.

{
   // Check assignment to self
   //
   if (this == &rhs)  { return *this; }
 
   // Copy data
   //
   kCarTolerance = rhs.kCarTolerance;
   fshapeName = rhs.fshapeName;
 
   return *this;
}

Referenced by G4BooleanSolid::operator=(), G4CSGSolid::operator=(), G4DisplacedSolid::operator=(), G4Ellipsoid::operator=(), G4EllipticalCone::operator=(), G4EllipticalTube::operator=(), G4GenericTrap::operator=(), G4Hype::operator=(), G4MultiUnion::operator=(), G4Paraboloid::operator=(), G4ReflectedSolid::operator=(), G4ScaledSolid::operator=(), G4TessellatedSolid::operator=(), G4Tet::operator=(), G4TwistedTubs::operator=(), G4VCSGfaceted::operator=(), and G4VTwistedFaceted::operator=().

operator==()

G4bool G4VSolid::operator== ( const G4VSolid & s ) const

inline

Equality operator. Returns true only if addresses are the same.

SetName()

void G4VSolid::SetName

(

const G4String &

name

)

Definition at line 126 of file G4VSolid.cc.

{
  fshapeName = name;
  G4SolidStore::GetInstance()->SetMapValid(false);
}

Referenced by G4MultiUnion::G4MultiUnion(), and G4GDMLRead::StripNames().

StreamInfo()

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

pure virtual

Dumps contents of the solid to a stream.

Implemented in G4BooleanSolid, G4Box, G4Cons, G4CSGSolid, G4CutTubs, G4DisplacedSolid, G4Ellipsoid, G4EllipticalCone, G4EllipticalTube, G4ExtrudedSolid, G4GenericPolycone, G4GenericTrap, G4Hype, G4MultiUnion, G4Orb, G4Para, G4Paraboloid, G4Polycone, G4Polyhedra, G4ReflectedSolid, G4ScaledSolid, G4Sphere, G4TessellatedSolid, G4Tet, G4Torus, G4Trap, G4Trd, G4Tubs, G4TwistedBox, G4TwistedTrap, G4TwistedTrd, G4TwistedTubs, G4VCSGfaceted, and G4VTwistedFaceted.

Referenced by operator<<(), and G4MultiUnion::StreamInfo().

SurfaceNormal()

virtual G4ThreeVector G4VSolid::SurfaceNormal ( const G4ThreeVector & p ) const

pure virtual

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.

Implemented in G4Box, G4Cons, G4CutTubs, G4DisplacedSolid, G4Ellipsoid, G4EllipticalCone, G4EllipticalTube, G4ExtrudedSolid, G4GenericTrap, G4Hype, G4IntersectionSolid, G4MultiUnion, G4Orb, G4Para, G4Paraboloid, G4ReflectedSolid, G4ScaledSolid, G4Sphere, G4SubtractionSolid, G4TessellatedSolid, G4Tet, G4Torus, G4Trap, G4Trd, G4Tubs, G4TwistedTubs, G4UnionSolid, G4VCSGfaceted, and G4VTwistedFaceted.

Referenced by G4PVPlacement::CheckOverlaps(), G4ITNavigator1::ComputeStep(), G4ITNavigator2::ComputeStep(), G4Navigator::ComputeStep(), G4ReplicaNavigation::ComputeStep(), EstimateSurfaceArea(), G4ITNavigator1::GetLocalExitNormal(), G4ITNavigator2::GetLocalExitNormal(), G4Navigator::GetLocalExitNormal(), G4ITNavigator1::LocateGlobalPointAndSetup(), G4ITNavigator2::LocateGlobalPointAndSetup(), G4Navigator::LocateGlobalPointAndSetup(), G4PSVolumeFlux::ProcessHits(), G4NavigationLogger::ReportVolumeAndIntersection(), and G4MultiUnion::SurfaceNormal().

Member Data Documentation

kCarTolerance

G4double G4VSolid::kCarTolerance

protected

Cached geometrical tolerance.

Definition at line 418 of file G4VSolid.hh.

Referenced by G4TessellatedSolid::AddFacet(), G4Polycone::CalculateExtent(), G4Polyhedra::CalculateExtent(), G4Tet::CheckDegeneracy(), G4CutTubs::CreatePolyhedron(), G4VCSGfaceted::DistanceTo(), G4Ellipsoid::DistanceToIn(), G4Hype::DistanceToIn(), G4Hype::DistanceToIn(), G4Paraboloid::DistanceToIn(), G4Sphere::DistanceToIn(), G4VCSGfaceted::DistanceToIn(), G4Cons::DistanceToOut(), G4CutTubs::DistanceToOut(), G4Hype::DistanceToOut(), G4Hype::DistanceToOut(), G4Paraboloid::DistanceToOut(), G4Paraboloid::DistanceToOut(), G4Sphere::DistanceToOut(), G4Torus::DistanceToOut(), G4Tubs::DistanceToOut(), G4VCSGfaceted::DistanceToOut(), G4Box::G4Box(), G4Cons::G4Cons(), G4CutTubs::G4CutTubs(), G4EllipticalCone::G4EllipticalCone(), G4ExtrudedSolid::G4ExtrudedSolid(), G4ExtrudedSolid::G4ExtrudedSolid(), G4GenericTrap::G4GenericTrap(), G4Hype::G4Hype(), G4Para::G4Para(), G4Para::G4Para(), G4Para::G4Para(), G4Sphere::G4Sphere(), G4Tet::G4Tet(), G4Trap::G4Trap(), G4Trap::G4Trap(), G4Trap::G4Trap(), G4Trap::G4Trap(), G4Trap::G4Trap(), G4Trap::G4Trap(), G4Trap::G4Trap(), G4Trd::G4Trd(), G4Trd::G4Trd(), G4Tubs::G4Tubs(), G4UnionSolid::G4UnionSolid(), G4VSolid(), G4VSolid(), G4VTwistedFaceted::G4VTwistedFaceted(), G4GenericPolycone::GetPointOnSurface(), G4Polycone::GetPointOnSurface(), G4TwistedTrd::GetSurfaceArea(), G4Orb::Initialize(), G4Hype::Inside(), G4Paraboloid::Inside(), G4SubtractionSolid::Inside(), G4VCSGfaceted::Inside(), G4VTwistedFaceted::Inside(), G4CutTubs::IsCrossingCutPlanes(), G4Trap::MakePlane(), operator=(), G4TessellatedSolid::SafetyFromInside(), G4TessellatedSolid::SafetyFromOutside(), G4Torus::SetAllParameters(), G4Box::SetXHalfLength(), G4Box::SetYHalfLength(), G4Box::SetZHalfLength(), G4Paraboloid::SurfaceNormal(), and G4Torus::SurfaceNormal().

---

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

• G4VSolid.hh
• G4VSolid.cc