G4VoxelLimits Class Reference

#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

Definition at line 52 of file G4VoxelLimits.hh.

Constructor & Destructor Documentation

G4VoxelLimits()

G4VoxelLimits::G4VoxelLimits ( )

default

~G4VoxelLimits()

G4VoxelLimits::~G4VoxelLimits ( )

default

Member Function Documentation

AddLimit()

void G4VoxelLimits::AddLimit	(	const EAxis	pAxis,
		const G4double	pMin,
		const G4double	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 G4ReflectedSolid::CalculateExtent(), G4BoundingEnvelope::CalculateExtent(), G4ClippablePolygon::ClipAlongOneAxis(), G4VSolid::ClipPolygon(), and G4SmartVoxelHeader::RefineNodes().

ClipToLimits()

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

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 )
  {
    // 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 )
      {
        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;
        }
      }
      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()

G4double G4VoxelLimits::GetMaxExtent

(

const EAxis

pAxis

)

const

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

GetMaxXExtent()

G4double G4VoxelLimits::GetMaxXExtent

(

)

const

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

GetMaxYExtent()

G4double G4VoxelLimits::GetMaxYExtent

(

)

const

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

GetMaxZExtent()

G4double G4VoxelLimits::GetMaxZExtent

(

)

const

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

GetMinExtent()

G4double G4VoxelLimits::GetMinExtent

(

const EAxis

pAxis

)

const

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

GetMinXExtent()

G4double G4VoxelLimits::GetMinXExtent

(

)

const

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

GetMinYExtent()

G4double G4VoxelLimits::GetMinYExtent

(

)

const

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

GetMinZExtent()

G4double G4VoxelLimits::GetMinZExtent

(

)

const

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

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(), G4BoundingEnvelope::CalculateExtent(), G4ClippablePolygon::Clip(), G4ClippablePolygon::ClipAlongOneAxis(), G4VSolid::ClipPolygon(), G4SolidExtentList::G4SolidExtentList(), and G4ClippablePolygon::PartialClip().

IsLimited() [2/2]

G4bool G4VoxelLimits::IsLimited

(

const EAxis

pAxis

)

const

IsXLimited()

G4bool G4VoxelLimits::IsXLimited

(

)

const

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

IsYLimited()

G4bool G4VoxelLimits::IsYLimited

(

)

const

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

IsZLimited()

G4bool G4VoxelLimits::IsZLimited

(

)

const

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

OutCode()

G4int G4VoxelLimits::OutCode

(

const G4ThreeVector &

pVec

)

const

Definition at line 221 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