#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::G4VoxelLimits ( )

Definition at line 48 of file G4VoxelLimits.cc.

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

◆ ~G4VoxelLimits()

G4VoxelLimits::~G4VoxelLimits ( )

Definition at line 55 of file G4VoxelLimits.cc.

56{

57}

Member Function Documentation

◆ AddLimit()

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

Definition at line 65 of file G4VoxelLimits.cc.

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

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

◆ ClipToLimits()

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

Definition at line 102 of file G4VoxelLimits.cc.

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

Referenced by G4ClippablePolygon::ClipToSimpleLimits().

◆ GetMaxExtent()

◆ GetMaxXExtent()

◆ GetMaxYExtent()

◆ GetMaxZExtent()

◆ GetMinExtent()

◆ GetMinXExtent()

◆ GetMinYExtent()

◆ GetMinZExtent()

◆ Inside()

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

Referenced by G4ClippablePolygon::ClipToSimpleLimits().

◆ IsLimited() [1/2]

G4bool G4VoxelLimits::IsLimited ( ) const

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

◆ IsLimited() [2/2]

G4bool G4VoxelLimits::IsLimited ( const EAxis pAxis ) const

◆ IsXLimited()

◆ IsYLimited()

◆ IsZLimited()

◆ OutCode()

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

Definition at line 262 of file G4VoxelLimits.cc.

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

Referenced by ClipToLimits().

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

Public Member Functions