G4VoxelLimits Class Reference

G4VoxelLimits represents limitation/restrictions of space, where restrictions are only made perpendicular to the Cartesian axes. More...

#include <G4VoxelLimits.hh>

Public Member Functions
	G4VoxelLimits ()=default
	~G4VoxelLimits ()=default
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

G4VoxelLimits represents limitation/restrictions of space, where restrictions are only made perpendicular to the Cartesian axes.

Definition at line 57 of file G4VoxelLimits.hh.

Constructor & Destructor Documentation

G4VoxelLimits()

G4VoxelLimits::G4VoxelLimits ( )

default

Default Constructor & Destructor. Constructor initialises to be unlimited. Volume unrestricted.

~G4VoxelLimits()

G4VoxelLimits::~G4VoxelLimits ( )

default

Member Function Documentation

AddLimit()

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

Restricts the volume to between specified min and max along the given axis. Cartesian axes only, pMin<=pMax.

Definition at line 40 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 G4BoundingEnvelope::CalculateExtent(), G4ReflectedSolid::CalculateExtent(), G4ClippablePolygon::ClipAlongOneAxis(), and G4VSolid::ClipPolygon().

ClipToLimits()

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

Clips the line segment pStart->pEnd to the volume described by the current limits. Returns true if the line remains after clipping, else false, and leaves the vectors in an undefined state.

Definition at line 76 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) != 0 )
  {
    // 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() ;
 
    while ( sCode != eCode )  // Loop checking, 06.08.2015, G.Cosmo
    {
      // Copy vectors to work variables x1-z1,x2-z2
      // Ensure x1-z1 lies outside volume, swapping vectors and outcodes
      // if necessary
 
      if ( sCode != 0 )
      {
        if ( (sCode & 0x01) != 0 )  // Clip against fxAxisMin
        {
          z1 += (fxAxisMin-x1)*(z2-z1)/(x2-x1);
          y1 += (fxAxisMin-x1)*(y2-y1)/(x2-x1);
          x1  = fxAxisMin;
        }
        else if ( (sCode & 0x02) != 0 ) // Clip against fxAxisMax
        {
          z1 += (fxAxisMax-x1)*(z2-z1)/(x2-x1);
          y1 += (fxAxisMax-x1)*(y2-y1)/(x2-x1);
          x1  = fxAxisMax ;
        }
        else if ( (sCode & 0x04) != 0 )  // Clip against fyAxisMin
        {
          x1 += (fyAxisMin-y1)*(x2-x1)/(y2-y1);
          z1 += (fyAxisMin-y1)*(z2-z1)/(y2-y1);
          y1  = fyAxisMin;
        }
        else if ( (sCode & 0x08) != 0 )  // Clip against fyAxisMax
        {
          x1 += (fyAxisMax-y1)*(x2-x1)/(y2-y1);
          z1 += (fyAxisMax-y1)*(z2-z1)/(y2-y1);
          y1  = fyAxisMax;
        }
        else if ( (sCode & 0x10) != 0 )  // Clip against fzAxisMin
        {
          x1 += (fzAxisMin-z1)*(x2-x1)/(z2-z1);
          y1 += (fzAxisMin-z1)*(y2-y1)/(z2-z1);
          z1  = fzAxisMin;
        }
        else if ( (sCode & 0x20) != 0 )  // Clip against fzAxisMax
        {
          x1 += (fzAxisMax-z1)*(x2-x1)/(z2-z1);
          y1 += (fzAxisMax-z1)*(y2-y1)/(z2-z1);
          z1  = fzAxisMax;
        }
      }
      if ( eCode != 0 )  // Clip 2nd end: repeat of 1st, but 1<>2
      {
        if ( (eCode & 0x01) != 0 )  // Clip against fxAxisMin
        {
          z2 += (fxAxisMin-x2)*(z1-z2)/(x1-x2);
          y2 += (fxAxisMin-x2)*(y1-y2)/(x1-x2);
          x2  = fxAxisMin;
        }
        else if ( (eCode & 0x02) != 0 )  // Clip against fxAxisMax
        {
          z2 += (fxAxisMax-x2)*(z1-z2)/(x1-x2);
          y2 += (fxAxisMax-x2)*(y1-y2)/(x1-x2);
          x2  = fxAxisMax;
        }
        else if ( (eCode & 0x04) != 0 )  // Clip against fyAxisMin
        {
          x2 += (fyAxisMin-y2)*(x1-x2)/(y1-y2);
          z2 += (fyAxisMin-y2)*(z1-z2)/(y1-y2);
          y2  = fyAxisMin;
        }
        else if ((eCode&0x08) != 0)  // Clip against fyAxisMax
        {
          x2 += (fyAxisMax-y2)*(x1-x2)/(y1-y2);
          z2 += (fyAxisMax-y2)*(z1-z2)/(y1-y2);
          y2  = fyAxisMax;
        }
        else if ( (eCode & 0x10) != 0 )  // Clip against fzAxisMin
        {
          x2 += (fzAxisMin-z2)*(x1-x2)/(z1-z2);
          y2 += (fzAxisMin-z2)*(y1-y2)/(z1-z2);
          z2  = fzAxisMin;
        }
        else if ( (eCode & 0x20) != 0 )  // Clip against fzAxisMax
        {
          x2 += (fzAxisMax-z2)*(x1-x2)/(z1-z2);
          y2 += (fzAxisMax-z2)*(y1-y2)/(z1-z2);
          z2  = fzAxisMax;
        }
      }
      pStart = G4ThreeVector(x1,y1,z1);
      pEnd   = G4ThreeVector(x2,y2,z2);
      sCode  = OutCode(pStart);
      eCode  = OutCode(pEnd);
    }
    remainsAfterClip = sCode == 0 && eCode == 0;
  }
  return remainsAfterClip;
}

GetMaxExtent()

G4double G4VoxelLimits::GetMaxExtent

(

const EAxis

pAxis

)

const

Accessors for the extent of the volume along the specified axis.

Referenced by G4BoundingEnvelope::CalculateExtent(), G4ExtrudedSolid::CalculateExtent(), G4GenericPolycone::CalculateExtent(), G4Polycone::CalculateExtent(), G4Polyhedra::CalculateExtent(), G4TessellatedSolid::CalculateExtent(), G4Torus::CalculateExtent(), G4ClippablePolygon::ClipAlongOneAxis(), and G4SolidExtentList::G4SolidExtentList().

GetMaxXExtent()

G4double G4VoxelLimits::GetMaxXExtent

(

)

const

Accessors for max extent

Referenced by G4BoundingEnvelope::BoundingBoxVsVoxelLimits(), G4BoundingEnvelope::CalculateExtent(), G4ReflectedSolid::CalculateExtent(), G4VSolid::ClipPolygon(), and operator<<().

GetMaxYExtent()

G4double G4VoxelLimits::GetMaxYExtent

(

)

const

Referenced by G4BoundingEnvelope::BoundingBoxVsVoxelLimits(), G4BoundingEnvelope::CalculateExtent(), G4ReflectedSolid::CalculateExtent(), G4VSolid::ClipPolygon(), and operator<<().

GetMaxZExtent()

G4double G4VoxelLimits::GetMaxZExtent

(

)

const

Referenced by G4BoundingEnvelope::BoundingBoxVsVoxelLimits(), G4BoundingEnvelope::CalculateExtent(), G4ReflectedSolid::CalculateExtent(), G4VSolid::ClipPolygon(), and operator<<().

GetMinExtent()

G4double G4VoxelLimits::GetMinExtent

(

const EAxis

pAxis

)

const

Referenced by G4BoundingEnvelope::CalculateExtent(), G4ExtrudedSolid::CalculateExtent(), G4GenericPolycone::CalculateExtent(), G4Polycone::CalculateExtent(), G4Polyhedra::CalculateExtent(), G4TessellatedSolid::CalculateExtent(), G4Torus::CalculateExtent(), G4ClippablePolygon::ClipAlongOneAxis(), and G4SolidExtentList::G4SolidExtentList().

GetMinXExtent()

G4double G4VoxelLimits::GetMinXExtent

(

)

const

Accessors for min extent

Referenced by G4BoundingEnvelope::BoundingBoxVsVoxelLimits(), G4BoundingEnvelope::CalculateExtent(), G4ReflectedSolid::CalculateExtent(), G4VSolid::ClipPolygon(), and operator<<().

GetMinYExtent()

G4double G4VoxelLimits::GetMinYExtent

(

)

const

Referenced by G4BoundingEnvelope::BoundingBoxVsVoxelLimits(), G4BoundingEnvelope::CalculateExtent(), G4ReflectedSolid::CalculateExtent(), G4VSolid::ClipPolygon(), and operator<<().

GetMinZExtent()

G4double G4VoxelLimits::GetMinZExtent

(

)

const

Referenced by G4BoundingEnvelope::BoundingBoxVsVoxelLimits(), G4BoundingEnvelope::CalculateExtent(), G4ReflectedSolid::CalculateExtent(), G4VSolid::ClipPolygon(), and operator<<().

Inside()

G4bool G4VoxelLimits::Inside

(

const G4ThreeVector &

pVec

)

const

Returns true if the specified vector is inside/on boundaries of limits.

IsLimited() [1/2]

G4bool G4VoxelLimits::IsLimited

(

)

const

Return true if limited along any axis.

Referenced by G4BoundingEnvelope::CalculateExtent(), G4ClippablePolygon::Clip(), G4ClippablePolygon::ClipAlongOneAxis(), G4VSolid::ClipPolygon(), G4SolidExtentList::G4SolidExtentList(), and G4ClippablePolygon::PartialClip().

IsLimited() [2/2]

G4bool G4VoxelLimits::IsLimited

(

const EAxis

pAxis

)

const

Return true if the specified axis is restricted/limited.

IsXLimited()

G4bool G4VoxelLimits::IsXLimited

(

)

const

Return true if the X/Y/Z axis is limited.

Referenced by G4VSolid::ClipPolygon(), operator<<(), and OutCode().

IsYLimited()

G4bool G4VoxelLimits::IsYLimited

(

)

const

Referenced by G4VSolid::ClipPolygon(), operator<<(), and OutCode().

IsZLimited()

G4bool G4VoxelLimits::IsZLimited

(

)

const

Referenced by G4VSolid::ClipPolygon(), operator<<(), and OutCode().

OutCode()

G4int G4VoxelLimits::OutCode

(

const G4ThreeVector &

pVec

)

const

Calculates the 'outcode' for the specified vector. Intended for use during clipping against the limits. The bits are set given the following conditions: 0 pVec.x()<fxAxisMin && IsXLimited() 1 pVec.x()>fxAxisMax && IsXLimited() 2 pVec.y()<fyAxisMin && IsYLimited() 3 pVec.y()>fyAxisMax && IsYLimited() 4 pVec.z()<fzAxisMin && IsZLimited() 5 pVec.z()>fzAxisMax && IsZLimited()

Definition at line 220 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:

• G4VoxelLimits.hh
• G4VoxelLimits.cc