#include <G4SolidExtentList.hh>

Public Member Functions
	G4SolidExtentList ()

	G4SolidExtentList (const EAxis targetAxis, const G4VoxelLimits &voxelLimits)

	~G4SolidExtentList ()

void	AddSurface (const G4ClippablePolygon &surface)

G4bool	GetExtent (G4double &min, G4double &max) const

Protected Attributes
EAxis	axis

G4bool	limited

G4double	minLimit

G4double	maxLimit

G4ClippablePolygon	minSurface

G4ClippablePolygon	maxSurface

G4ClippablePolygon	minAbove

G4ClippablePolygon	maxBelow

Detailed Description

Definition at line 54 of file G4SolidExtentList.hh.

Constructor & Destructor Documentation

G4SolidExtentList::G4SolidExtentList ( )

Definition at line 48 of file G4SolidExtentList.cc.

References axis, INT_MAX, kZAxis, limited, maxLimit, and minLimit.

 {
   axis = kZAxis;
   limited = false;
   minLimit = -INT_MAX/2;
   maxLimit =  INT_MAX/2;
 }

G4SolidExtentList::G4SolidExtentList	(	const EAxis	targetAxis,
		const G4VoxelLimits &	voxelLimits
	)

Definition at line 60 of file G4SolidExtentList.cc.

References axis, G4VoxelLimits::GetMaxExtent(), G4VoxelLimits::GetMinExtent(), INT_MAX, G4VoxelLimits::IsLimited(), limited, maxLimit, and minLimit.

 {
   axis = targetAxis;
   
   limited = voxelLimits.IsLimited( axis );
   if (limited)
   {
     minLimit = voxelLimits.GetMinExtent( axis );
     maxLimit = voxelLimits.GetMaxExtent( axis );
   }
   else
   {
     minLimit = -INT_MAX/2;
     maxLimit =  INT_MAX/2;
   }
 }

G4SolidExtentList::~G4SolidExtentList ( )

Definition at line 82 of file G4SolidExtentList.cc.

83 {

84 }

Member Function Documentation

void G4SolidExtentList::AddSurface ( const G4ClippablePolygon & surface )

Definition at line 91 of file G4SolidExtentList.cc.

References axis, G4ClippablePolygon::BehindOf(), G4ClippablePolygon::GetExtent(), G4ClippablePolygon::InFrontOf(), G4INCL::Math::max(), maxBelow, maxLimit, maxSurface, G4INCL::Math::min(), minAbove, minLimit, and minSurface.

Referenced by G4Hype::AddPolyToExtent(), G4EllipticalTube::CalculateExtent(), G4Hype::CalculateExtent(), G4EllipticalCone::CalculateExtent(), G4PolyPhiFace::CalculateExtent(), G4PolyconeSide::CalculateExtent(), and G4PolyhedraSide::CalculateExtent().

 {
   //
   // Keep track of four surfaces
   //
   G4double min, max;
   
   surface.GetExtent( axis, min, max );
   
   if (min > maxLimit)
   {
     //
     // Nearest surface beyond maximum limit
     //
     if (surface.InFrontOf(minAbove,axis)) minAbove = surface;
   }
   else if (max < minLimit)
   {
     //
     // Nearest surface below minimum limit
     //
     if (surface.BehindOf(maxBelow,axis)) maxBelow = surface;
   }
   else
   {
     //
     // Max and min surfaces inside
     //
     if (surface.BehindOf(maxSurface,axis)) maxSurface = surface;
     if (surface.InFrontOf(minSurface,axis)) minSurface = surface;
   }
 }

G4bool G4SolidExtentList::GetExtent	(	G4double &	min,
		G4double &	max
	)		const

Definition at line 131 of file G4SolidExtentList.cc.

References axis, G4ClippablePolygon::Empty(), G4ClippablePolygon::GetExtent(), G4GeometryTolerance::GetInstance(), G4ClippablePolygon::GetNormal(), G4GeometryTolerance::GetSurfaceTolerance(), maxLimit, maxSurface, minAbove, minLimit, and minSurface.

Referenced by G4VCSGfaceted::CalculateExtent(), G4EllipticalTube::CalculateExtent(), G4Hype::CalculateExtent(), G4TwistedTubs::CalculateExtent(), and G4EllipticalCone::CalculateExtent().

 {
   G4double kCarTolerance = G4GeometryTolerance::GetInstance()
                            ->GetSurfaceTolerance();
   //
   // Did we have any surfaces within the limits?
   //
   if (minSurface.Empty())
   {
     //
     // Nothing! Do we have anything above?
     //
     if (minAbove.Empty()) return false;
     
     //
     // Yup. Is it facing inwards?
     //
     if (minAbove.GetNormal().operator()(axis) < 0) return false;
     
     //
     // No. We must be entirely within the solid
     //
     max = maxLimit + kCarTolerance;
     min = minLimit - kCarTolerance;
     return true;
   }
   
   //
   // Check max surface
   //
   if (maxSurface.GetNormal().operator()(axis) < 0)
   {
     //
     // Inward facing: max limit must be embedded within solid
     //
     max = maxLimit + kCarTolerance;
   }
   else
   {
     G4double sMin, sMax;
     maxSurface.GetExtent( axis, sMin, sMax );
     max = ( (sMax > maxLimit) ? maxLimit : sMax ) + kCarTolerance;
   }
   
   //
   // Check min surface
   //
   if (minSurface.GetNormal().operator()(axis) > 0)
   {
     //
     // Inward facing: max limit must be embedded within solid
     //
     min = minLimit - kCarTolerance;
   }
   else
   {
     G4double sMin, sMax;
     minSurface.GetExtent( axis, sMin, sMax );
     min = ( (sMin < minLimit) ? minLimit : sMin ) - kCarTolerance;
   }
   
   return true;
 }