#include <G4VoxelLimits.hh>

Public Member Functions
	G4VoxelLimits ()

	~G4VoxelLimits ()

void	AddLimit (const EAxis pAxis, const G4double pMin, const G4double pMax)

G4double	GetMaxXExtent () const

G4double	GetMaxYExtent () const

G4double	GetMaxZExtent () const

G4double	GetMinXExtent () const

G4double	GetMinYExtent () const

G4double	GetMinZExtent () const

G4double	GetMaxExtent (const EAxis pAxis) const

G4double	GetMinExtent (const EAxis pAxis) const

G4bool	IsXLimited () const

G4bool	IsYLimited () const

G4bool	IsZLimited () const

G4bool	IsLimited () const

G4bool	IsLimited (const EAxis pAxis) const

G4bool	ClipToLimits (G4ThreeVector &pStart, G4ThreeVector &pEnd) const

G4bool	Inside (const G4ThreeVector &pVec) const

G4int	OutCode (const G4ThreeVector &pVec) const

Detailed Description

Definition at line 62 of file G4VoxelLimits.hh.

Constructor & Destructor Documentation

G4VoxelLimits::G4VoxelLimits ( )

Definition at line 48 of file G4VoxelLimits.cc.

  : fxAxisMin(-kInfinity),fxAxisMax(kInfinity),
    fyAxisMin(-kInfinity),fyAxisMax(kInfinity),
    fzAxisMin(-kInfinity),fzAxisMax(kInfinity)
 {
 }

G4VoxelLimits::~G4VoxelLimits ( )

Definition at line 55 of file G4VoxelLimits.cc.

56 {

57 }

Member Function Documentation

void G4VoxelLimits::AddLimit	(	const EAxis	pAxis,
		const G4double	pMin,
		const G4double	pMax
	)

Definition at line 65 of file G4VoxelLimits.cc.

References assert, kXAxis, kYAxis, and kZAxis.

Referenced by G4ClippablePolygon::ClipAlongOneAxis(), G4VSolid::ClipPolygon(), and G4SmartVoxelHeader::RefineNodes().

 {
   if ( pAxis == kXAxis )
   {
     if ( pMin > fxAxisMin ) fxAxisMin = pMin ;    
     if ( pMax < fxAxisMax ) fxAxisMax = pMax ;    
   }
   else if ( pAxis == kYAxis )
   {
     if ( pMin > fyAxisMin ) fyAxisMin = pMin ;    
     if ( pMax < fyAxisMax ) fyAxisMax = pMax ;
   }
   else
   { 
     assert( pAxis == kZAxis ) ;
 
     if ( pMin > fzAxisMin ) fzAxisMin = pMin ;
     if ( pMax < fzAxisMax ) fzAxisMax = pMax ;
   }
 }

G4bool G4VoxelLimits::ClipToLimits	(	G4ThreeVector &	pStart,
		G4ThreeVector &	pEnd
	)		const

Definition at line 102 of file G4VoxelLimits.cc.

References OutCode(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by G4ClippablePolygon::ClipToSimpleLimits().

 {
   G4int sCode, eCode ;
   G4bool remainsAfterClip ;
     
   // Determine if line is trivially inside (both outcodes==0) or outside
   // (logical AND of outcodes !=0)
 
   sCode = OutCode(pStart) ;
   eCode = OutCode(pEnd)   ;
 
   if ( sCode & eCode )
   {
     // Trivially outside, no intersection with region
 
     remainsAfterClip = false;
   }
   else if ( sCode == 0 && eCode == 0 )
   {
     // Trivially inside, no intersections
 
     remainsAfterClip = true ;
   }
   else
   {
     // Line segment *may* cut volume boundaries
     // At most, one end point is inside
 
     G4double x1, y1, z1, x2, y2, z2 ;
 
     x1 = pStart.x() ;
     y1 = pStart.y() ;
     z1 = pStart.z() ;
 
     x2 = pEnd.x() ;
     y2 = pEnd.y() ;
     z2 = pEnd.z() ;
     /*
     if( std::abs(x1-x2) < kCarTolerance*kCarTolerance)
     {
       G4cout<<"x1 = "<<x1<<"\t"<<"x2 = "<<x2<<G4endl; 
     }   
     if( std::abs(y1-y2) < kCarTolerance*kCarTolerance)
     {
       G4cout<<"y1 = "<<y1<<"\t"<<"y2 = "<<y2<<G4endl; 
     }   
     if( std::abs(z1-z2) < kCarTolerance*kCarTolerance)
     {
       G4cout<<"z1 = "<<z1<<"\t"<<"z2 = "<<z2<<G4endl; 
     } 
     */  
     while ( sCode != eCode )
     {
       // Copy vectors to work variables x1-z1,x2-z2
       // Ensure x1-z1 lies outside volume, swapping vectors and outcodes
       // if necessary
 
       if ( sCode )
       {
         if ( sCode & 0x01 )  // Clip against fxAxisMin
         {
           z1 += (fxAxisMin-x1)*(z2-z1)/(x2-x1);
           y1 += (fxAxisMin-x1)*(y2-y1)/(x2-x1);
           x1  = fxAxisMin;
         }
         else if ( sCode & 0x02 ) // Clip against fxAxisMax
         {
           z1 += (fxAxisMax-x1)*(z2-z1)/(x2-x1);
           y1 += (fxAxisMax-x1)*(y2-y1)/(x2-x1);
           x1  = fxAxisMax ;
         }
         else if ( sCode & 0x04 )  // Clip against fyAxisMin
         {
           x1 += (fyAxisMin-y1)*(x2-x1)/(y2-y1);
           z1 += (fyAxisMin-y1)*(z2-z1)/(y2-y1);
           y1  = fyAxisMin;
         }
         else if ( sCode & 0x08 )  // Clip against fyAxisMax
         {
           x1 += (fyAxisMax-y1)*(x2-x1)/(y2-y1);
           z1 += (fyAxisMax-y1)*(z2-z1)/(y2-y1);
           y1  = fyAxisMax;
         }
         else if ( sCode & 0x10 )  // Clip against fzAxisMin
         {
           x1 += (fzAxisMin-z1)*(x2-x1)/(z2-z1);
           y1 += (fzAxisMin-z1)*(y2-y1)/(z2-z1);
           z1  = fzAxisMin;
         }
         else if ( sCode & 0x20 )  // Clip against fzAxisMax
         {
           x1 += (fzAxisMax-z1)*(x2-x1)/(z2-z1);
           y1 += (fzAxisMax-z1)*(y2-y1)/(z2-z1);
           z1  = fzAxisMax;
         }
       }
       if ( eCode )  // Clip 2nd end: repeat of 1st, but 1<>2
       {
         if ( eCode & 0x01 )  // Clip against fxAxisMin
         {
           z2 += (fxAxisMin-x2)*(z1-z2)/(x1-x2);
           y2 += (fxAxisMin-x2)*(y1-y2)/(x1-x2);
           x2  = fxAxisMin;
         }
         else if ( eCode & 0x02 )  // Clip against fxAxisMax
         {
           z2 += (fxAxisMax-x2)*(z1-z2)/(x1-x2);
           y2 += (fxAxisMax-x2)*(y1-y2)/(x1-x2);
           x2  = fxAxisMax;
         }
         else if ( eCode & 0x04 )  // Clip against fyAxisMin
         {
           x2 += (fyAxisMin-y2)*(x1-x2)/(y1-y2);
           z2 += (fyAxisMin-y2)*(z1-z2)/(y1-y2);
           y2  = fyAxisMin;
         }
         else if (eCode&0x08)  // Clip against fyAxisMax
         {
           x2 += (fyAxisMax-y2)*(x1-x2)/(y1-y2);
           z2 += (fyAxisMax-y2)*(z1-z2)/(y1-y2);
           y2  = fyAxisMax;
         }
         else if ( eCode & 0x10 )  // Clip against fzAxisMin
         {
           x2 += (fzAxisMin-z2)*(x1-x2)/(z1-z2);
           y2 += (fzAxisMin-z2)*(y1-y2)/(z1-z2);
           z2  = fzAxisMin;
         }
         else if ( eCode & 0x20 )  // Clip against fzAxisMax
         {
           x2 += (fzAxisMax-z2)*(x1-x2)/(z1-z2);
           y2 += (fzAxisMax-z2)*(y1-y2)/(z1-z2);
           z2  = fzAxisMax;
         }
       }
       //  G4endl; G4cout<<"x1 = "<<x1<<"\t"<<"x2 = "<<x2<<G4endl<<G4endl;
       pStart = G4ThreeVector(x1,y1,z1);
       pEnd   = G4ThreeVector(x2,y2,z2);
       sCode  = OutCode(pStart);
       eCode  = OutCode(pEnd);
     }
     if ( sCode == 0 && eCode == 0 ) remainsAfterClip = true;
     else                            remainsAfterClip = false;
   }
   return remainsAfterClip;
 }

G4bool G4VoxelLimits::Inside ( const G4ThreeVector & pVec ) const

Referenced by G4ClippablePolygon::ClipToSimpleLimits().

G4bool G4VoxelLimits::IsLimited ( ) const

Referenced by G4SmartVoxelHeader::BuildNodes(), G4SmartVoxelHeader::BuildVoxelsWithinLimits(), G4USolid::CalculateExtent(), G4ReflectedSolid::CalculateExtent(), G4Box::CalculateExtent(), G4VTwistedFaceted::CalculateExtent(), G4TessellatedSolid::CalculateExtent(), G4ClippablePolygon::Clip(), G4ClippablePolygon::ClipAlongOneAxis(), G4VSolid::ClipPolygon(), G4SolidExtentList::G4SolidExtentList(), and G4ClippablePolygon::PartialClip().

G4bool G4VoxelLimits::IsLimited ( const EAxis pAxis ) const

G4int G4VoxelLimits::OutCode ( const G4ThreeVector & pVec ) const

Definition at line 262 of file G4VoxelLimits.cc.

References IsXLimited(), IsYLimited(), IsZLimited(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by ClipToLimits().

 {
   G4int code = 0 ;                // The outcode
 
   if ( IsXLimited() )
   {
     if ( pVec.x() < fxAxisMin ) code |= 0x01 ;
     if ( pVec.x() > fxAxisMax ) code |= 0x02 ;
   }
   if ( IsYLimited() )
   {
     if ( pVec.y() < fyAxisMin ) code |= 0x04 ;
     if ( pVec.y() > fyAxisMax ) code |= 0x08 ;
   }
   if (IsZLimited())
   {
     if ( pVec.z() < fzAxisMin ) code |= 0x10 ;
     if ( pVec.z() > fzAxisMax ) code |= 0x20 ;
   }
   return code;
 }

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

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation