G4VoxelNavigation Class Reference

G4VoxelNavigation is a concrete utility class for navigation in volumes containing only G4PVPlacement daughter volumes for which voxels have been constructed. More...

#include <G4VoxelNavigation.hh>

Inheritance diagram for G4VoxelNavigation:

Public Member Functions
	G4VoxelNavigation ()
	~G4VoxelNavigation () override
G4SmartVoxelNode *	VoxelLocate (G4SmartVoxelHeader *pHead, const G4ThreeVector &localPoint)
G4bool	LevelLocate (G4NavigationHistory &history, const G4VPhysicalVolume *blockedVol, const G4int blockedNum, const G4ThreeVector &globalPoint, const G4ThreeVector *globalDirection, const G4bool pLocatedOnEdge, G4ThreeVector &localPoint) override
G4double	ComputeStep (const G4ThreeVector &localPoint, const G4ThreeVector &localDirection, const G4double currentProposedStepLength, G4double &newSafety, G4NavigationHistory &history, G4bool &validExitNormal, G4ThreeVector &exitNormal, G4bool &exiting, G4bool &entering, G4VPhysicalVolume *(*pBlockedPhysical), G4int &blockedReplicaNo) override
G4double	ComputeSafety (const G4ThreeVector &localpoint, const G4NavigationHistory &history, const G4double pMaxLength=DBL_MAX) override
void	RelocateWithinVolume (G4VPhysicalVolume *motherPhysical, const G4ThreeVector &localPoint) override
G4int	GetVerboseLevel () const override
void	SetVerboseLevel (G4int level) override
void	EnableBestSafety (G4bool flag=false)
Public Member Functions inherited from G4VNavigation
virtual	~G4VNavigation ()=default
void	CheckMode (G4bool mode)

Protected Member Functions
G4double	ComputeVoxelSafety (const G4ThreeVector &localPoint) const
G4bool	LocateNextVoxel (const G4ThreeVector &localPoint, const G4ThreeVector &localDirection, const G4double currentStep)

Protected Attributes
G4BlockingList	fBList
G4int	fVoxelDepth = -1
std::vector< EAxis >	fVoxelAxisStack
std::vector< G4int >	fVoxelNoSlicesStack
std::vector< G4double >	fVoxelSliceWidthStack
std::vector< G4int >	fVoxelNodeNoStack
std::vector< G4SmartVoxelHeader * >	fVoxelHeaderStack
G4SmartVoxelNode *	fVoxelNode = nullptr
G4VoxelSafety *	fpVoxelSafety = nullptr
G4double	fHalfTolerance
G4bool	fBestSafety = false
G4NavigationLogger *	fLogger
Protected Attributes inherited from G4VNavigation
G4int	fVerbose = 0
G4bool	fCheck = false

Detailed Description

G4VoxelNavigation is a concrete utility class for navigation in volumes containing only G4PVPlacement daughter volumes for which voxels have been constructed.

Definition at line 69 of file G4VoxelNavigation.hh.

Constructor & Destructor Documentation

G4VoxelNavigation()

G4VoxelNavigation::G4VoxelNavigation

(

)

Constructor and Destructor.

Definition at line 45 of file G4VoxelNavigation.cc.

  : fVoxelAxisStack(kNavigatorVoxelStackMax,kXAxis),
    fVoxelNoSlicesStack(kNavigatorVoxelStackMax,0),
    fVoxelSliceWidthStack(kNavigatorVoxelStackMax,0.),
    fVoxelNodeNoStack(kNavigatorVoxelStackMax,0),
    fVoxelHeaderStack(kNavigatorVoxelStackMax,(G4SmartVoxelHeader*)nullptr)
{
  fLogger= new G4NavigationLogger("G4VoxelNavigation");
  fpVoxelSafety= new G4VoxelSafety();
  fHalfTolerance= 0.5*G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
 
#ifdef G4DEBUG_NAVIGATION
  SetVerboseLevel(5);   // Reports most about daughter volumes
#endif
}

~G4VoxelNavigation()

G4VoxelNavigation::~G4VoxelNavigation ( )

override

Definition at line 65 of file G4VoxelNavigation.cc.

{
  delete fpVoxelSafety;
  delete fLogger;
}

Member Function Documentation

ComputeSafety()

G4double G4VoxelNavigation::ComputeSafety ( const G4ThreeVector & localpoint, const G4NavigationHistory & history, const G4double pMaxLength = DBL_MAX )

overridevirtual

Calculates the isotropic distance to the nearest boundary from the specified point in the local coordinate system. The localpoint utilised must be within the current volume.

Parameters

[in]	localPoint	Local point.
[in]	history	Navigation history.
[in]	pMaxLength	Maximum step length beyond which volumes need not be checked.

Returns

Length from current point to closest surface.

Implements G4VNavigation.

Definition at line 647 of file G4VoxelNavigation.cc.

{
  G4VPhysicalVolume *motherPhysical, *samplePhysical;
  G4LogicalVolume *motherLogical;
  G4VSolid *motherSolid;
  G4double motherSafety, ourSafety;
  G4int sampleNo;
  G4SmartVoxelNode *curVoxelNode;
  G4long curNoVolumes, contentNo;
  G4double voxelSafety;
 
  motherPhysical = history.GetTopVolume();
  motherLogical = motherPhysical->GetLogicalVolume();
  motherSolid = motherLogical->GetSolid();
 
  if( fBestSafety )
  { 
    return fpVoxelSafety->ComputeSafety( localPoint,*motherPhysical,maxLength );
  }
 
  //
  // Compute mother safety
  //
 
  motherSafety = motherSolid->DistanceToOut(localPoint);
  ourSafety = motherSafety;                 // Working isotropic safety
 
  if( motherSafety == 0.0 )
  {
#ifdef G4DEBUG_NAVIGATION
    // Check that point is inside mother volume
    EInside  insideMother = motherSolid->Inside(localPoint);
 
    if( insideMother == kOutside )
    {
      G4ExceptionDescription message;
      message << "Safety method called for location outside current Volume." << G4endl
         << "Location for safety is Outside this volume. " << G4endl
         << "The approximate distance to the solid "
         << "(safety from outside) is: "
         << motherSolid->DistanceToIn( localPoint ) << G4endl;
      message << "  Problem occurred with physical volume: "
         << " Name: " << motherPhysical->GetName()
         << " Copy No: " << motherPhysical->GetCopyNo() << G4endl
         << "    Local Point = " << localPoint << G4endl;
      message << "  Description of solid: " << G4endl
            << *motherSolid << G4endl;
      G4Exception("G4VoxelNavigation::ComputeSafety()", "GeomNav0003",
                  JustWarning, message);
    }
 
    // Following check is NOT for an issue - it is only for information
    //  It is allowed that a solid gives approximate safety - even zero.
    //
    if( insideMother == kInside ) // && fVerbose )
    {
      G4ExceptionDescription messageIn;
      
      messageIn << " Point is Inside, but safety is Zero ."  << G4endl;
      messageIn << " Inexact safety for volume " << motherPhysical->GetName() << G4endl
             << "  Solid: Name= " << motherSolid->GetName()
             << "   Type= " << motherSolid->GetEntityType() << G4endl;
      messageIn << "  Local point= " << localPoint << G4endl;
      messageIn << "  Solid parameters: " << G4endl << *motherSolid << G4endl;
      G4Exception("G4VoxelNavigation::ComputeSafety()", "GeomNav0003",
                  JustWarning, messageIn);
    }
#endif
    // if( insideMother != kInside )
    return 0.0;
  }
   
#ifdef G4VERBOSE
  if( fCheck )
  {
    fLogger->ComputeSafetyLog (motherSolid,localPoint,motherSafety,true,1);
  }
#endif
  //
  // Compute daughter safeties
  //
  // Look only inside the current Voxel only (in the first version).
  //
  curVoxelNode = fVoxelNode;
  curNoVolumes = curVoxelNode->GetNoContained();
 
  for ( contentNo=curNoVolumes-1; contentNo>=0; contentNo-- )
  {
    sampleNo = curVoxelNode->GetVolume((G4int)contentNo);
    samplePhysical = motherLogical->GetDaughter(sampleNo);
 
    G4AffineTransform sampleTf(samplePhysical->GetRotation(),
                               samplePhysical->GetTranslation());
    sampleTf.Invert();
    const G4ThreeVector samplePoint = sampleTf.TransformPoint(localPoint);
    const G4VSolid* sampleSolid= samplePhysical->GetLogicalVolume()->GetSolid();
    G4double sampleSafety = sampleSolid->DistanceToIn(samplePoint);
    if ( sampleSafety<ourSafety )
    {
      ourSafety = sampleSafety;
    }
#ifdef G4VERBOSE
    if( fCheck )
    {
      fLogger->ComputeSafetyLog(sampleSolid, samplePoint,
                                sampleSafety, false, 0);
    }
#endif
  }
  voxelSafety = ComputeVoxelSafety(localPoint);
  if ( voxelSafety<ourSafety )
  {
    ourSafety = voxelSafety;
  }
  return ourSafety;
}

ComputeStep()

G4double G4VoxelNavigation::ComputeStep ( const G4ThreeVector & localPoint, const G4ThreeVector & localDirection, const G4double currentProposedStepLength, G4double & newSafety, G4NavigationHistory & history, G4bool & validExitNormal, G4ThreeVector & exitNormal, G4bool & exiting, G4bool & entering, G4VPhysicalVolume ** pBlockedPhysical, G4int & blockedReplicaNo )

overridevirtual

Computes the length of a step to the next boundary. Does not test against pBlockedPhysical. Identifies the next candidate volume (if a daughter of the current volume), and returns it in: pBlockedPhysical, blockedReplicaNo.

Parameters

[in]	localPoint	Local point.
[in]	localDirection	Local direction vector.
[in]	currentProposedStepLength	Current proposed step length.
[in,out]	newSafety	New safety.
[in,out]	history	Navigation history.
[in,out]	validExitNormal	Flag to indicate whether exit normal is valid or not.
[in,out]	exitNormal	Exit normal.
[in,out]	exiting	Flag to indicate whether exiting a volume.
[in,out]	entering	Flag to indicate whether entering a volume.
[in,out]	pBlockedPhysical	Blocked physical volume that should be ignored in queries.
[in,out]	blockedReplicaNo	Copy number for blocked replica volumes.

Returns

Length from current point to next boundary surface along localDirection.

Implements G4VNavigation.

Definition at line 89 of file G4VoxelNavigation.cc.

{
  G4VPhysicalVolume *motherPhysical, *samplePhysical, *blockedExitedVol=nullptr;
  G4LogicalVolume *motherLogical;
  G4VSolid *motherSolid;
  G4ThreeVector sampleDirection;
  G4double ourStep=currentProposedStepLength, ourSafety;
  G4double motherSafety, motherStep = DBL_MAX;
  G4int localNoDaughters, sampleNo;
 
  G4bool initialNode, noStep;
  G4SmartVoxelNode *curVoxelNode;
  G4long curNoVolumes, contentNo;
  G4double voxelSafety;
 
  motherPhysical = history.GetTopVolume();
  motherLogical = motherPhysical->GetLogicalVolume();
  motherSolid = motherLogical->GetSolid();
 
  //
  // Compute mother safety
  //
 
  motherSafety = motherSolid->DistanceToOut(localPoint);
  ourSafety = motherSafety;                 // Working isotropic safety
  
#ifdef G4VERBOSE
  if ( fCheck )
  {
    fLogger->PreComputeStepLog (motherPhysical, motherSafety, localPoint);
  }
#endif
 
  //
  // Compute daughter safeties & intersections
  //
 
  // Exiting normal optimisation
  //
  if ( exiting && validExitNormal )
  {
    if ( localDirection.dot(exitNormal)>=kMinExitingNormalCosine )
    {
      // Block exited daughter volume
      //
      blockedExitedVol = *pBlockedPhysical;
      ourSafety = 0;
    }
  }
  exiting = false;
  entering = false;
 
  // For extra checking,  get the distance to Mother early !!
  G4bool motherValidExitNormal = false;
  G4ThreeVector motherExitNormal(0.0, 0.0, 0.0);
 
#ifdef G4VERBOSE
  if ( fCheck )
  {
    // Compute early -- a) for validity
    //                  b) to check against answer of daughters!
    motherStep = motherSolid->DistanceToOut(localPoint,
                                            localDirection,
                                            true,
                                           &motherValidExitNormal,
                                           &motherExitNormal);
  }
#endif
 
  localNoDaughters = (G4int)motherLogical->GetNoDaughters();
 
  fBList.Enlarge(localNoDaughters);
  fBList.Reset();
 
  initialNode = true;
  noStep = true;
 
  while (noStep)
  {
    curVoxelNode = fVoxelNode;
    curNoVolumes = curVoxelNode->GetNoContained();
    for (contentNo=curNoVolumes-1; contentNo>=0; contentNo--)
    {
      sampleNo = curVoxelNode->GetVolume((G4int)contentNo);
      if ( !fBList.IsBlocked(sampleNo) )
      {
        fBList.BlockVolume(sampleNo);
        samplePhysical = motherLogical->GetDaughter(sampleNo);
        if ( samplePhysical!=blockedExitedVol )
        {
          G4AffineTransform sampleTf(samplePhysical->GetRotation(),
                                     samplePhysical->GetTranslation());
          sampleTf.Invert();
          const G4ThreeVector samplePoint =
                     sampleTf.TransformPoint(localPoint);
          const G4VSolid *sampleSolid     =
                     samplePhysical->GetLogicalVolume()->GetSolid();
          const G4double sampleSafety     =
                     sampleSolid->DistanceToIn(samplePoint);
 
          if ( sampleSafety<ourSafety )
          {
            ourSafety = sampleSafety;
          }
          if ( sampleSafety<=ourStep )
          {
            sampleDirection = sampleTf.TransformAxis(localDirection);
            G4double sampleStep =
                     sampleSolid->DistanceToIn(samplePoint, sampleDirection);
#ifdef G4VERBOSE
            if( fCheck )
            {
              fLogger->PrintDaughterLog(sampleSolid, samplePoint,
                                        sampleSafety, true,
                                        sampleDirection, sampleStep);
            }
#endif
            if ( sampleStep<=ourStep )
            {
              ourStep = sampleStep;
              entering = true;
              exiting = false;
              *pBlockedPhysical = samplePhysical;
              blockedReplicaNo = -1;
#ifdef G4VERBOSE
              // Check to see that the resulting point is indeed in/on volume.
              // This could be done only for successful candidate.
              if ( fCheck )
              {
                fLogger->AlongComputeStepLog (sampleSolid, samplePoint,
                  sampleDirection, localDirection, sampleSafety, sampleStep);
              }
#endif
            }
#ifdef G4VERBOSE
            if ( fCheck && ( sampleStep < kInfinity )
                        && ( sampleStep >= motherStep ) )            
            {               
               // The intersection point with the daughter is after the exit
               // point from the mother volume.  Double check this !!
               fLogger->CheckDaughterEntryPoint(sampleSolid,
                                                samplePoint, sampleDirection,
                                                motherSolid,
                                                localPoint, localDirection,
                                                motherStep, sampleStep);
            }
#endif
          }            
#ifdef G4VERBOSE
          else // ie if sampleSafety > outStep 
          {
            if( fCheck )
            {
              fLogger->PrintDaughterLog(sampleSolid, samplePoint,
                                        sampleSafety, false,
                                        G4ThreeVector(0.,0.,0.), -1.0 );
            }
          }
#endif                         
        }
      }
    }
    if (initialNode)
    {
      initialNode = false;
      voxelSafety = ComputeVoxelSafety(localPoint);
      if ( voxelSafety<ourSafety )
      {
        ourSafety = voxelSafety;
      }
      if ( currentProposedStepLength<ourSafety )
      {
        // Guaranteed physics limited
        //      
        noStep = false;
        entering = false;
        exiting = false;
        *pBlockedPhysical = nullptr;
        ourStep = kInfinity;
      }
      else
      {
        //
        // Compute mother intersection if required
        //
        if ( motherSafety<=ourStep )
        {
          // In case of check mode this is a duplicate call -- acceptable
          motherStep = motherSolid->DistanceToOut(localPoint, localDirection,
                              true, &motherValidExitNormal, &motherExitNormal);
#ifdef G4VERBOSE
          if ( fCheck )
          {
            fLogger->PostComputeStepLog(motherSolid, localPoint, localDirection,
                                        motherStep, motherSafety);
            if( motherValidExitNormal )
            {
              fLogger->CheckAndReportBadNormal(motherExitNormal,
                                               localPoint, localDirection, 
                                               motherStep, motherSolid,
                                        "From motherSolid::DistanceToOut" );
            }
          }
#endif
          if( (motherStep >= kInfinity) || (motherStep < 0.0) )
          {
#ifdef G4VERBOSE
            if( fCheck ) // Error - indication of being outside solid !!
            {
              fLogger->ReportOutsideMother(localPoint, localDirection,
                                           motherPhysical);
            }
#endif
            motherStep = 0.0;
            ourStep = 0.0;
            exiting = true;
            entering = false;
 
            // validExitNormal= motherValidExitNormal;
            // exitNormal= motherExitNormal;
            // Useful only if the point is very close to surface
            // => but it would need to be rotated to grand-mother ref frame !
            validExitNormal= false;
 
            *pBlockedPhysical = nullptr; // or motherPhysical ?
            blockedReplicaNo = 0;  // or motherReplicaNumber ?
    
            newSafety = 0.0;
            return ourStep;
          }          
          
          if ( motherStep<=ourStep )
          {
            ourStep = motherStep;
            exiting = true;
            entering = false;
 
            // Exit normal: Natural location to set these;confirmed short step
            //
            validExitNormal = motherValidExitNormal;
            exitNormal = motherExitNormal;
 
            if ( validExitNormal )
            {
              const G4RotationMatrix *rot = motherPhysical->GetRotation();
              if (rot != nullptr)
              {
                exitNormal *= rot->inverse();
#ifdef G4VERBOSE
                if( fCheck )
                {
                  fLogger->CheckAndReportBadNormal(exitNormal,        // rotated
                                                   motherExitNormal,  // original 
                                                   *rot,
                                                   "From RotationMatrix" );
                }
#endif
              }
            }
          }
          else
          {
            validExitNormal = false;
          }
        }
      }
      newSafety = ourSafety;
    }
    if (noStep)
    {
      noStep = LocateNextVoxel(localPoint, localDirection, ourStep);
    }
  }  // end -while (noStep)- loop
 
  return ourStep;
}

Referenced by G4Navigator::ComputeStep().

ComputeVoxelSafety()

G4double G4VoxelNavigation::ComputeVoxelSafety ( const G4ThreeVector & localPoint ) const

protected

Computes safety from specified point to voxel boundaries using already located point.

Parameters

[in]

localPoint

Local point.

Returns

Safety length from current point to voxel boundary.

Definition at line 386 of file G4VoxelNavigation.cc.

{
  G4SmartVoxelHeader *curHeader;
  G4double voxelSafety, curNodeWidth;
  G4double curNodeOffset, minCurCommonDelta, maxCurCommonDelta;
  G4int minCurNodeNoDelta, maxCurNodeNoDelta;
  G4int localVoxelDepth, curNodeNo;
  EAxis curHeaderAxis;
 
  localVoxelDepth = fVoxelDepth;
 
  curHeader = fVoxelHeaderStack[localVoxelDepth];
  curHeaderAxis = fVoxelAxisStack[localVoxelDepth];
  curNodeNo = fVoxelNodeNoStack[localVoxelDepth];
  curNodeWidth = fVoxelSliceWidthStack[localVoxelDepth];
  
  // Compute linear intersection distance to boundaries of max/min
  // to collected nodes at current level
  //
  curNodeOffset = curNodeNo*curNodeWidth;
  maxCurNodeNoDelta = fVoxelNode->GetMaxEquivalentSliceNo()-curNodeNo;
  minCurNodeNoDelta = curNodeNo-fVoxelNode->GetMinEquivalentSliceNo();
  minCurCommonDelta = localPoint(curHeaderAxis)
                      - curHeader->GetMinExtent() - curNodeOffset;
  maxCurCommonDelta = curNodeWidth-minCurCommonDelta;
 
  if ( minCurNodeNoDelta<maxCurNodeNoDelta )
  {
    voxelSafety = minCurNodeNoDelta*curNodeWidth;
    voxelSafety += minCurCommonDelta;
  }
  else if (maxCurNodeNoDelta < minCurNodeNoDelta)
  {
    voxelSafety = maxCurNodeNoDelta*curNodeWidth;
    voxelSafety += maxCurCommonDelta;
  }
  else    // (maxCurNodeNoDelta == minCurNodeNoDelta)
  {
    voxelSafety = minCurNodeNoDelta*curNodeWidth;
    voxelSafety += std::min(minCurCommonDelta,maxCurCommonDelta);
  }
 
  // Compute isotropic safety to boundaries of previous levels
  // [NOT to collected boundaries]
 
  // Loop checking, 07.10.2016, JA
  while ( (localVoxelDepth>0) && (voxelSafety>0) )
  {
    localVoxelDepth--;
    curHeader = fVoxelHeaderStack[localVoxelDepth];
    curHeaderAxis = fVoxelAxisStack[localVoxelDepth];
    curNodeNo = fVoxelNodeNoStack[localVoxelDepth];
    curNodeWidth = fVoxelSliceWidthStack[localVoxelDepth];
    curNodeOffset = curNodeNo*curNodeWidth;
    minCurCommonDelta = localPoint(curHeaderAxis)
                        - curHeader->GetMinExtent() - curNodeOffset;
    maxCurCommonDelta = curNodeWidth-minCurCommonDelta;
    
    if ( minCurCommonDelta<voxelSafety )
    {
      voxelSafety = minCurCommonDelta;
    }
    if ( maxCurCommonDelta<voxelSafety )
    {
      voxelSafety = maxCurCommonDelta;
    }
  }
  if ( voxelSafety<0 )
  {
    voxelSafety = 0;
  }
 
  return voxelSafety;
}

Referenced by ComputeSafety(), and ComputeStep().

EnableBestSafety()

void G4VoxelNavigation::EnableBestSafety ( G4bool flag = false )

inline

Enables best-possible evaluation of isotropic safety.

GetVerboseLevel()

G4int G4VoxelNavigation::GetVerboseLevel ( ) const

inlineoverridevirtual

Verbosity control.

Note

If level>0 && G4VERBOSE, printout can occur.

Reimplemented from G4VNavigation.

LevelLocate()

G4bool G4VoxelNavigation::LevelLocate ( G4NavigationHistory & history, const G4VPhysicalVolume * blockedVol, const G4int blockedNum, const G4ThreeVector & globalPoint, const G4ThreeVector * globalDirection, const G4bool pLocatedOnEdge, G4ThreeVector & localPoint )

inlineoverridevirtual

Searches positioned volumes in mother at current top level of history for volume containing globalPoint. Do not test against blockedVol. If a containing volume is found, push it onto navigation history state.

Parameters

[in,out]	history	Navigation history.
[in,out]	blockedVol	Blocked volume to be ignored in queries.
[in,out]	blockedNum	Copy number for blocked replica volumes.
[in,out]	globalPoint	Point in global coordinates system.
[in,out]	globalDirection	Pointer to global direction or null.
[in]	pLocatedOnEdge	Flag specifying if point is located on edge.
[in,out]	localPoint	Point in local coordinates system.

Returns

Whether a containing volume has been found.

Implements G4VNavigation.

Referenced by G4Navigator::LocateGlobalPointAndSetup().

LocateNextVoxel()

G4bool G4VoxelNavigation::LocateNextVoxel ( const G4ThreeVector & localPoint, const G4ThreeVector & localDirection, const G4double currentStep )

protected

Finds the next voxel from the current voxel and point in the specified direction.

Parameters

[in]	localPoint	Local point.
[in]	localDirection	Direction along which compute the distance.
[in]	currentStep	Current step size.

Returns

false if all voxels considered [current Step ends inside same voxel or leaves all voxels] true otherwise [the information on the next voxel is saved].

Definition at line 475 of file G4VoxelNavigation.cc.

{
  G4SmartVoxelHeader *workHeader=nullptr, *newHeader=nullptr;
  G4SmartVoxelProxy *newProxy=nullptr;
  G4SmartVoxelNode *newVoxelNode=nullptr;
  G4ThreeVector targetPoint, voxelPoint;
  G4double workNodeWidth, workMinExtent, workCoord;
  G4double minVal, maxVal, newDistance=0.;
  G4double newHeaderMin, newHeaderNodeWidth;
  G4int depth=0, newDepth=0, workNodeNo=0, newNodeNo=0, newHeaderNoSlices=0;
  EAxis workHeaderAxis, newHeaderAxis;
  G4bool isNewVoxel = false;
  
  G4double currentDistance = currentStep;
 
  // Determine if end of Step within current voxel
  //
  for (depth=0; depth<fVoxelDepth; ++depth)
  {
    targetPoint = localPoint+localDirection*currentDistance;
    newDistance = currentDistance;
    workHeader = fVoxelHeaderStack[depth];
    workHeaderAxis = fVoxelAxisStack[depth];
    workNodeNo = fVoxelNodeNoStack[depth];
    workNodeWidth = fVoxelSliceWidthStack[depth];
    workMinExtent = workHeader->GetMinExtent();
    workCoord = targetPoint(workHeaderAxis);
    minVal = workMinExtent+workNodeNo*workNodeWidth;
 
    if ( minVal<=workCoord+fHalfTolerance )
    {
      maxVal = minVal+workNodeWidth;
      if ( maxVal<=workCoord-fHalfTolerance )
      {
        // Must consider next voxel
        //
        newNodeNo = workNodeNo+1;
        newHeader = workHeader;
        newDistance = (maxVal-localPoint(workHeaderAxis))
                    / localDirection(workHeaderAxis);
        isNewVoxel = true;
        newDepth = depth;
      }
    }
    else
    {
      newNodeNo = workNodeNo-1;
      newHeader = workHeader;
      newDistance = (minVal-localPoint(workHeaderAxis))
                  / localDirection(workHeaderAxis);
      isNewVoxel = true;
      newDepth = depth;
    }
    currentDistance = newDistance;
  }
  targetPoint = localPoint+localDirection*currentDistance;
 
  // Check if end of Step within collected boundaries of current voxel
  //
  depth = fVoxelDepth;
  {
    workHeader = fVoxelHeaderStack[depth];
    workHeaderAxis = fVoxelAxisStack[depth];
    workNodeNo = fVoxelNodeNoStack[depth];
    workNodeWidth = fVoxelSliceWidthStack[depth];
    workMinExtent = workHeader->GetMinExtent();
    workCoord = targetPoint(workHeaderAxis);
    minVal = workMinExtent+fVoxelNode->GetMinEquivalentSliceNo()*workNodeWidth;
 
    if ( minVal<=workCoord+fHalfTolerance )
    {
      maxVal = workMinExtent+(fVoxelNode->GetMaxEquivalentSliceNo()+1)
                            *workNodeWidth;
      if ( maxVal<=workCoord-fHalfTolerance )
      {
        newNodeNo = fVoxelNode->GetMaxEquivalentSliceNo()+1;
        newHeader = workHeader;
        newDistance = (maxVal-localPoint(workHeaderAxis))
                    / localDirection(workHeaderAxis);
        isNewVoxel = true;
        newDepth = depth;
      }
    }
    else
    {
      newNodeNo = fVoxelNode->GetMinEquivalentSliceNo()-1;
      newHeader = workHeader;
      newDistance = (minVal-localPoint(workHeaderAxis))
                  / localDirection(workHeaderAxis);
      isNewVoxel = true;
      newDepth = depth;
    }
    currentDistance = newDistance;
  }
  if (isNewVoxel)
  {
    // Compute new voxel & adjust voxel stack
    //
    // newNodeNo=Candidate node no at 
    // newDepth =refinement depth of crossed voxel boundary
    // newHeader=Header for crossed voxel
    // newDistance=distance to crossed voxel boundary (along the track)
    //
    if ( (newNodeNo<0) || (newNodeNo>=G4int(newHeader->GetNoSlices())))
    {
      // Leaving mother volume
      //
      isNewVoxel = false;
    }
    else
    {
      // Compute intersection point on the least refined
      // voxel boundary that is hit
      //
      voxelPoint = localPoint+localDirection*newDistance;
      fVoxelNodeNoStack[newDepth] = newNodeNo;
      fVoxelDepth = newDepth;
      newVoxelNode = nullptr;
      while ( newVoxelNode == nullptr )
      {
        newProxy = newHeader->GetSlice(newNodeNo);
        if (newProxy->IsNode())
        {
          newVoxelNode = newProxy->GetNode();
        }
        else
        {
          ++fVoxelDepth;
          newHeader = newProxy->GetHeader();
          newHeaderAxis = newHeader->GetAxis();
          newHeaderNoSlices = (G4int)newHeader->GetNoSlices();
          newHeaderMin = newHeader->GetMinExtent();
          newHeaderNodeWidth = (newHeader->GetMaxExtent()-newHeaderMin)
                             / newHeaderNoSlices;
          newNodeNo = G4int( (voxelPoint(newHeaderAxis)-newHeaderMin)
                             / newHeaderNodeWidth );
          // Rounding protection
          //
          if ( newNodeNo<0 )
          {
            newNodeNo=0;
          }
          else if ( newNodeNo>=newHeaderNoSlices )
          {
            newNodeNo = newHeaderNoSlices-1;
          }
          // Stack info for stepping
          //
          fVoxelAxisStack[fVoxelDepth] = newHeaderAxis;
          fVoxelNoSlicesStack[fVoxelDepth] = newHeaderNoSlices;
          fVoxelSliceWidthStack[fVoxelDepth] = newHeaderNodeWidth;
          fVoxelNodeNoStack[fVoxelDepth] = newNodeNo;
          fVoxelHeaderStack[fVoxelDepth] = newHeader;
        }
      }
      fVoxelNode = newVoxelNode;
    }
  }
  return isNewVoxel;        
}

Referenced by ComputeStep().

RelocateWithinVolume()

void G4VoxelNavigation::RelocateWithinVolume ( G4VPhysicalVolume * motherPhysical, const G4ThreeVector & localPoint )

overridevirtual

Updates internal navigation state to take into account that location has been moved, but remains within the motherPhysical volume.

Parameters

[in]	motherPhysical	Current physical volume.
[in]	localPoint	Local point.

Reimplemented from G4VNavigation.

Definition at line 770 of file G4VoxelNavigation.cc.

{
  auto motherLogical = motherPhysical->GetLogicalVolume();
 
  // assert(motherLogical != nullptr);
 
  if ( auto pVoxelHeader = motherLogical->GetVoxelHeader() )
  {
    VoxelLocate( pVoxelHeader, localPoint );
  }
}

Referenced by G4Navigator::LocateGlobalPointWithinVolume().

SetVerboseLevel()

void G4VoxelNavigation::SetVerboseLevel ( G4int level )

overridevirtual

Sets current verbosity level.

Reimplemented from G4VNavigation.

Definition at line 787 of file G4VoxelNavigation.cc.

{
  if( fLogger != nullptr ) { fLogger->SetVerboseLevel(level); }
  if( fpVoxelSafety != nullptr) { fpVoxelSafety->SetVerboseLevel(level); }
}

Referenced by G4VoxelNavigation().

VoxelLocate()

G4SmartVoxelNode * G4VoxelNavigation::VoxelLocate ( G4SmartVoxelHeader * pHead, const G4ThreeVector & localPoint )

inline

Locates voxel node based on given point.

Parameters

[in]	pHead	Pointer to header of nodes to look through.
[in]	localPoint	Local point

Returns

Pointer to the node where the given point is located.

Referenced by RelocateWithinVolume().

Member Data Documentation

fBestSafety

G4bool G4VoxelNavigation::fBestSafety = false

protected

Flag for best safety.

Definition at line 268 of file G4VoxelNavigation.hh.

Referenced by ComputeSafety().

fBList

G4BlockingList G4VoxelNavigation::fBList

protected

Blocked volumes.

Definition at line 229 of file G4VoxelNavigation.hh.

Referenced by G4ParameterisedNavigation::ComputeStep(), and ComputeStep().

fHalfTolerance

G4double G4VoxelNavigation::fHalfTolerance

protected

Surface tolerance.

Definition at line 265 of file G4VoxelNavigation.hh.

Referenced by G4VoxelNavigation(), and LocateNextVoxel().

fLogger

G4NavigationLogger* G4VoxelNavigation::fLogger

protected

Verbosity logger.

Definition at line 271 of file G4VoxelNavigation.hh.

Referenced by ComputeSafety(), G4ParameterisedNavigation::ComputeStep(), ComputeStep(), G4VoxelNavigation(), SetVerboseLevel(), and ~G4VoxelNavigation().

fpVoxelSafety

G4VoxelSafety* G4VoxelNavigation::fpVoxelSafety = nullptr

protected

Helper object for Voxel Safety.

Definition at line 262 of file G4VoxelNavigation.hh.

Referenced by ComputeSafety(), G4VoxelNavigation(), SetVerboseLevel(), and ~G4VoxelNavigation().

fVoxelAxisStack

std::vector<EAxis> G4VoxelNavigation::fVoxelAxisStack

protected

Voxel axes.

Definition at line 241 of file G4VoxelNavigation.hh.

Referenced by ComputeVoxelSafety(), G4VoxelNavigation(), and LocateNextVoxel().

fVoxelDepth

G4int G4VoxelNavigation::fVoxelDepth = -1

protected

Voxels depth.

Note

fVoxelDepth==0+ => fVoxelAxisStack(0+) contains axes of voxel fVoxelDepth==-1 -> not in voxel.

Definition at line 238 of file G4VoxelNavigation.hh.

Referenced by ComputeVoxelSafety(), and LocateNextVoxel().

fVoxelHeaderStack

std::vector<G4SmartVoxelHeader*> G4VoxelNavigation::fVoxelHeaderStack

protected

Voxel headers at each level.

Definition at line 253 of file G4VoxelNavigation.hh.

Referenced by ComputeVoxelSafety(), G4VoxelNavigation(), and LocateNextVoxel().

fVoxelNode

G4SmartVoxelNode* G4VoxelNavigation::fVoxelNode = nullptr

protected

Node containing last located point.

Definition at line 256 of file G4VoxelNavigation.hh.

Referenced by G4ParameterisedNavigation::ComputeSafety(), ComputeSafety(), G4ParameterisedNavigation::ComputeStep(), ComputeStep(), ComputeVoxelSafety(), and LocateNextVoxel().

fVoxelNodeNoStack

std::vector<G4int> G4VoxelNavigation::fVoxelNodeNoStack

protected

Node no point is inside at each level.

Definition at line 250 of file G4VoxelNavigation.hh.

Referenced by ComputeVoxelSafety(), G4VoxelNavigation(), and LocateNextVoxel().

fVoxelNoSlicesStack

std::vector<G4int> G4VoxelNavigation::fVoxelNoSlicesStack

protected

No slices per voxel at each level.

Definition at line 244 of file G4VoxelNavigation.hh.

Referenced by G4VoxelNavigation(), and LocateNextVoxel().

fVoxelSliceWidthStack

std::vector<G4double> G4VoxelNavigation::fVoxelSliceWidthStack

protected

Width of voxels at each level.

Definition at line 247 of file G4VoxelNavigation.hh.

Referenced by ComputeVoxelSafety(), G4VoxelNavigation(), and LocateNextVoxel().

---

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

• G4VoxelNavigation.hh
• G4VoxelNavigation.cc