G4VoxelLimits Class Reference

#include <G4VoxelLimits.hh>

Collaboration diagram for G4VoxelLimits:

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

Private Attributes
G4double	fxAxisMin
G4double	fxAxisMax
G4double	fyAxisMin
G4double	fyAxisMax
G4double	fzAxisMin
G4double	fzAxisMax

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.

{
}

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

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

GetMaxExtent()

G4double G4VoxelLimits::GetMaxExtent

(

const EAxis

pAxis

)

const

Here is the caller graph for this function:

GetMaxXExtent()

G4double G4VoxelLimits::GetMaxXExtent

(

)

const

Here is the caller graph for this function:

GetMaxYExtent()

G4double G4VoxelLimits::GetMaxYExtent

(

)

const

Here is the caller graph for this function:

GetMaxZExtent()

G4double G4VoxelLimits::GetMaxZExtent

(

)

const

Here is the caller graph for this function:

GetMinExtent()

G4double G4VoxelLimits::GetMinExtent

(

const EAxis

pAxis

)

const

Here is the caller graph for this function:

GetMinXExtent()

G4double G4VoxelLimits::GetMinXExtent

(

)

const

Here is the caller graph for this function:

GetMinYExtent()

G4double G4VoxelLimits::GetMinYExtent

(

)

const

Here is the caller graph for this function:

GetMinZExtent()

G4double G4VoxelLimits::GetMinZExtent

(

)

const

Here is the caller graph for this function:

Inside()

G4bool G4VoxelLimits::Inside

(

const G4ThreeVector &

pVec

)

const

Here is the caller graph for this function:

IsLimited() [1/2]

G4bool G4VoxelLimits::IsLimited

(

)

const

Here is the caller graph for this function:

IsLimited() [2/2]

G4bool G4VoxelLimits::IsLimited

(

const EAxis

pAxis

)

const

IsXLimited()

G4bool G4VoxelLimits::IsXLimited

(

)

const

Here is the caller graph for this function:

IsYLimited()

G4bool G4VoxelLimits::IsYLimited

(

)

const

Here is the caller graph for this function:

IsZLimited()

G4bool G4VoxelLimits::IsZLimited

(

)

const

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

fxAxisMax

G4double G4VoxelLimits::fxAxisMax

private

Definition at line 128 of file G4VoxelLimits.hh.

fxAxisMin

G4double G4VoxelLimits::fxAxisMin

private

Definition at line 128 of file G4VoxelLimits.hh.

fyAxisMax

G4double G4VoxelLimits::fyAxisMax

private

Definition at line 129 of file G4VoxelLimits.hh.

fyAxisMin

G4double G4VoxelLimits::fyAxisMin

private

Definition at line 129 of file G4VoxelLimits.hh.

fzAxisMax

G4double G4VoxelLimits::fzAxisMax

private

Definition at line 130 of file G4VoxelLimits.hh.

fzAxisMin

G4double G4VoxelLimits::fzAxisMin

private

Definition at line 130 of file G4VoxelLimits.hh.

---

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

• G4VoxelLimits.hh
• G4VoxelLimits.cc