#include <G4ParameterisedNavigation.hh>

Inheritance diagram for G4ParameterisedNavigation:

Public Member Functions
void	CheckMode (G4bool mode)

G4double	ComputeSafety (const G4ThreeVector &localPoint, const G4NavigationHistory &history, const G4double pProposedMaxLength=DBL_MAX)

G4double	ComputeStep (const G4ThreeVector &globalPoint, const G4ThreeVector &globalDirection, const G4double currentProposedStepLength, G4double &newSafety, G4NavigationHistory &history, G4bool &validExitNormal, G4ThreeVector &exitNormal, G4bool &exiting, G4bool &entering, G4VPhysicalVolume (pBlockedPhysical), G4int &blockedReplicaNo)

void	EnableBestSafety (G4bool flag=false)

	G4ParameterisedNavigation ()

G4int	GetVerboseLevel () const

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

G4SmartVoxelNode *	ParamVoxelLocate (G4SmartVoxelHeader *pHead, const G4ThreeVector &localPoint)

void	SetVerboseLevel (G4int level)

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

	~G4ParameterisedNavigation ()

Protected Member Functions
G4double	ComputeVoxelSafety (const G4ThreeVector &localPoint) const

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

G4SmartVoxelNode *	VoxelLocateLight (G4SmartVoxelHeader *pHead, const G4ThreeVector &localPoint) const

Protected Attributes
G4bool	fBestSafety = false

G4BlockingList	fBList

G4bool	fCheck = false

G4double	fHalfTolerance

G4NavigationLogger *	fLogger

G4VoxelSafety *	fpVoxelSafety = nullptr

std::vector< EAxis >	fVoxelAxisStack

G4int	fVoxelDepth = -1

std::vector< G4SmartVoxelHeader * >	fVoxelHeaderStack

G4SmartVoxelNode *	fVoxelNode = nullptr

std::vector< G4int >	fVoxelNodeNoStack

std::vector< G4int >	fVoxelNoSlicesStack

std::vector< G4double >	fVoxelSliceWidthStack

Private Member Functions
void	AlongComputeStepLog (const G4VSolid *sampleSolid, const G4ThreeVector &samplePoint, const G4ThreeVector &sampleDirection, const G4ThreeVector &localDirection, G4double sampleSafety, G4double sampleStep)

void	ComputeSafetyLog (const G4VSolid *solid, const G4ThreeVector &point, G4double safety, G4bool banner)

G4double	ComputeVoxelSafety (const G4ThreeVector &localPoint, const EAxis pAxis) const

G4VPhysicalVolume *	CreateVolumeWithParent (G4VPhysicalVolume *curPhysical, const G4NavigationHistory &hist)

G4VSolid *	IdentifyAndPlaceSolid (G4int num, G4VPhysicalVolume apparentPhys, G4VPVParameterisation curParam)

G4bool	LocateNextVoxel (const G4ThreeVector &localPoint, const G4ThreeVector &localDirection, const G4double currentStep, const EAxis pAxis)

void	PostComputeStepLog (const G4VSolid *motherSolid, const G4ThreeVector &localPoint, const G4ThreeVector &localDirection, G4double motherStep, G4double motherSafety)

void	PreComputeStepLog (const G4VPhysicalVolume *motherPhysical, G4double motherSafety, const G4ThreeVector &localPoint)

void	PrintDaughterLog (const G4VSolid *sampleSolid, const G4ThreeVector &samplePoint, G4double sampleSafety, G4double sampleStep)

Private Attributes
EAxis	fVoxelAxis = kUndefined

G4SmartVoxelHeader *	fVoxelHeader = nullptr

size_t	fVoxelNodeNo = 0

G4int	fVoxelNoSlices = 0

G4double	fVoxelSliceWidth = 0.0

Detailed Description

Definition at line 54 of file G4ParameterisedNavigation.hh.

Constructor & Destructor Documentation

◆ G4ParameterisedNavigation()

G4ParameterisedNavigation::G4ParameterisedNavigation ( )

Definition at line 56 of file G4ParameterisedNavigation.cc.

57{

58}

◆ ~G4ParameterisedNavigation()

G4ParameterisedNavigation::~G4ParameterisedNavigation ( )

Definition at line 64 of file G4ParameterisedNavigation.cc.

65{

66}

Member Function Documentation

◆ AlongComputeStepLog()

void G4VoxelNavigation::AlongComputeStepLog	(	const G4VSolid *	sampleSolid,
		const G4ThreeVector &	samplePoint,
		const G4ThreeVector &	sampleDirection,
		const G4ThreeVector &	localDirection,
		G4double	sampleSafety,
		G4double	sampleStep
	)

privateinherited

◆ CheckMode()

void G4VoxelNavigation::CheckMode ( G4bool mode )

inlineinherited

◆ ComputeSafety()

G4double G4ParameterisedNavigation::ComputeSafety	(	const G4ThreeVector &	localPoint,
		const G4NavigationHistory &	history,
		const G4double	pProposedMaxLength = `DBL_MAX`
	)

virtual

Reimplemented from G4VoxelNavigation.

Definition at line 396 of file G4ParameterisedNavigation.cc.

{
  G4VPhysicalVolume *motherPhysical, *samplePhysical;
  G4VPVParameterisation *sampleParam;
  G4LogicalVolume *motherLogical;
  G4VSolid *motherSolid, *sampleSolid;
  G4double motherSafety, ourSafety;
  G4int sampleNo, curVoxelNodeNo;
 
  G4SmartVoxelNode *curVoxelNode;
  G4int curNoVolumes, contentNo;
  G4double voxelSafety;
 
  // Replication data
  //
  EAxis axis;
  G4int nReplicas;
  G4double width, offset;
  G4bool consuming;
 
  motherPhysical = history.GetTopVolume();
  motherLogical = motherPhysical->GetLogicalVolume();
  motherSolid = motherLogical->GetSolid();
 
  //
  // Compute mother safety
  //
 
  motherSafety = motherSolid->DistanceToOut(localPoint);
  ourSafety = motherSafety;                     // Working isotropic safety
 
  //
  // Compute daughter safeties
  //
 
  // By definition, parameterised volumes exist as first
  // daughter of the mother volume
  //
  samplePhysical = motherLogical->GetDaughter(0);
  samplePhysical->GetReplicationData(axis, nReplicas,
                                     width, offset, consuming);
  sampleParam = samplePhysical->GetParameterisation();
 
  // Look inside the current Voxel only at the current point
  //
  if ( axis==kUndefined )      // 3D case: current voxel node is retrieved
  {                            //          from G4VoxelNavigation.
    curVoxelNode = fVoxelNode;
  }
  else                         // 1D case: current voxel node is computed here.
  {
    curVoxelNodeNo = G4int((localPoint(fVoxelAxis)
                           -fVoxelHeader->GetMinExtent()) / fVoxelSliceWidth );
    curVoxelNode = fVoxelHeader->GetSlice(curVoxelNodeNo)->GetNode();
    fVoxelNodeNo = curVoxelNodeNo;
    fVoxelNode = curVoxelNode;
  }
  curNoVolumes = curVoxelNode->GetNoContained();
 
  for ( contentNo=curNoVolumes-1; contentNo>=0; contentNo-- )
  {
    sampleNo = curVoxelNode->GetVolume(contentNo);
    
    // Call virtual methods, and copy information if needed
    //
    sampleSolid= IdentifyAndPlaceSolid( sampleNo,samplePhysical,sampleParam ); 
 
    G4AffineTransform sampleTf(samplePhysical->GetRotation(),
                               samplePhysical->GetTranslation());
    sampleTf.Invert();
    const G4ThreeVector samplePoint = sampleTf.TransformPoint(localPoint);
    G4double sampleSafety = sampleSolid->DistanceToIn(samplePoint);
    if ( sampleSafety<ourSafety )
    {
      ourSafety = sampleSafety;
    }
  }
 
  voxelSafety = ComputeVoxelSafety(localPoint,axis);
  if ( voxelSafety<ourSafety )
  {
    ourSafety=voxelSafety;
  }
 
  return ourSafety;
}

References ComputeVoxelSafety(), G4VSolid::DistanceToIn(), G4VSolid::DistanceToOut(), fVoxelAxis, fVoxelHeader, G4VoxelNavigation::fVoxelNode, fVoxelNodeNo, fVoxelSliceWidth, G4LogicalVolume::GetDaughter(), G4VPhysicalVolume::GetLogicalVolume(), G4SmartVoxelHeader::GetMinExtent(), G4SmartVoxelNode::GetNoContained(), G4SmartVoxelProxy::GetNode(), G4VPhysicalVolume::GetParameterisation(), G4VPhysicalVolume::GetReplicationData(), G4VPhysicalVolume::GetRotation(), G4SmartVoxelHeader::GetSlice(), G4LogicalVolume::GetSolid(), G4VPhysicalVolume::GetTranslation(), G4SmartVoxelNode::GetVolume(), g4zmq::history(), IdentifyAndPlaceSolid(), G4AffineTransform::Invert(), kUndefined, and G4AffineTransform::TransformPoint().

Referenced by G4Navigator::ComputeSafety(), G4ITNavigator1::ComputeSafety(), and G4ITNavigator2::ComputeSafety().

◆ ComputeSafetyLog()

void G4VoxelNavigation::ComputeSafetyLog	(	const G4VSolid *	solid,
		const G4ThreeVector &	point,
		G4double	safety,
		G4bool	banner
	)

privateinherited

◆ ComputeStep()

G4double G4ParameterisedNavigation::ComputeStep	(	const G4ThreeVector &	globalPoint,
		const G4ThreeVector &	globalDirection,
		const G4double	currentProposedStepLength,
		G4double &	newSafety,
		G4NavigationHistory &	history,
		G4bool &	validExitNormal,
		G4ThreeVector &	exitNormal,
		G4bool &	exiting,
		G4bool &	entering,
		G4VPhysicalVolume **	pBlockedPhysical,
		G4int &	blockedReplicaNo
	)

virtual

Reimplemented from G4VoxelNavigation.

Definition at line 72 of file G4ParameterisedNavigation.cc.

{
  G4VPhysicalVolume *motherPhysical, *samplePhysical;
  G4VPVParameterisation *sampleParam;
  G4LogicalVolume *motherLogical;
  G4VSolid *motherSolid, *sampleSolid;
  G4ThreeVector sampleDirection;
  G4double ourStep=currentProposedStepLength, ourSafety;
  G4double motherSafety, motherStep = DBL_MAX;
  G4bool motherValidExitNormal = false;
  G4ThreeVector motherExitNormal;
  
  G4int sampleNo;
 
  G4bool initialNode, noStep;
  G4SmartVoxelNode *curVoxelNode;
  G4int curNoVolumes, contentNo;
  G4double voxelSafety;
 
  // Replication data
  //
  EAxis axis;
  G4int nReplicas;
  G4double width, offset;
  G4bool consuming;
 
  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 )
  {
    if( motherSafety < 0.0 )
    {
      motherSolid->DumpInfo();
      std::ostringstream message;
      message << "Negative Safety In Voxel Navigation !" << G4endl
              << "        Current solid " << motherSolid->GetName()
              << " gave negative safety: " << motherSafety << G4endl
              << "        for the current (local) point " << localPoint;
      G4Exception("G4ParameterisedNavigation::ComputeStep()",
                  "GeomNav0003", FatalException, message); 
    }
    if( motherSolid->Inside(localPoint) == kOutside )
    { 
      std::ostringstream message;
      message << "Point is outside Current Volume !" << G4endl
              << "          Point " << localPoint
              << " is outside current volume " << motherPhysical->GetName()
              << G4endl;
      G4double estDistToSolid = motherSolid->DistanceToIn(localPoint); 
      G4cout << "          Estimated isotropic distance to solid (distToIn)= " 
             << estDistToSolid;
      if( estDistToSolid > 100.0 * motherSolid->GetTolerance() )
      {
        motherSolid->DumpInfo();
        G4Exception("G4ParameterisedNavigation::ComputeStep()",
                    "GeomNav0003", FatalException, message,
                    "Point is far outside Current Volume !"); 
      }
      else
      {
        G4Exception("G4ParameterisedNavigation::ComputeStep()",
                    "GeomNav1002", JustWarning, message,
                    "Point is a little outside Current Volume.");
      }
    }
 
    // Compute early:
    //  a) to check whether point is (wrongly) outside
    //               (signaled if step < 0 or step == kInfinity )
    //  b) to check value against answer of daughters!
    //
    motherStep = motherSolid->DistanceToOut(localPoint,
                                            localDirection,
                                            true,
                                           &motherValidExitNormal,
                                           &motherExitNormal);
  
    if( (motherStep >= kInfinity) || (motherStep < 0.0) )
    {
      // Error - indication of being outside solid !!
      //
      fLogger->ReportOutsideMother(localPoint, localDirection, motherPhysical);
 
      ourStep = motherStep = 0.0;
      exiting = true;
      entering = false;
    
      // If we are outside the solid does the normal make sense?
      validExitNormal = motherValidExitNormal;
      exitNormal = motherExitNormal;
    
      *pBlockedPhysical = nullptr; // or motherPhysical ?
      blockedReplicaNo = 0;  // or motherReplicaNumber ?
    
      newSafety = 0.0;
      return ourStep;
    }
  }
#endif
 
  initialNode = true;
  noStep = true;
 
  // By definition, the parameterised volume is the first
  // (and only) daughter of the mother volume
  //
  samplePhysical = motherLogical->GetDaughter(0);
  samplePhysical->GetReplicationData(axis,nReplicas,width,offset,consuming);
  fBList.Enlarge(nReplicas);
  fBList.Reset();
 
  // Exiting normal optimisation
  //
  if (exiting && (*pBlockedPhysical==samplePhysical) && validExitNormal)
  {
    if (localDirection.dot(exitNormal)>=kMinExitingNormalCosine)
    {
      // Block exited daughter replica; Must be on boundary => zero safety
      //
      fBList.BlockVolume(blockedReplicaNo);
      ourSafety = 0;
    }
  }
  exiting = false;
  entering = false;
 
  sampleParam = samplePhysical->GetParameterisation();
 
  // Loop over voxels & compute daughter safeties & intersections
 
  do
  {
    curVoxelNode = fVoxelNode;
    curNoVolumes = curVoxelNode->GetNoContained();
 
    for ( contentNo=curNoVolumes-1; contentNo>=0; contentNo-- )
    {
      sampleNo = curVoxelNode->GetVolume(contentNo);
      if ( !fBList.IsBlocked(sampleNo) )
      {
        fBList.BlockVolume(sampleNo);
 
        // Call virtual methods, and copy information if needed
        //
        sampleSolid = IdentifyAndPlaceSolid( sampleNo, samplePhysical,
                                             sampleParam ); 
 
        G4AffineTransform sampleTf(samplePhysical->GetRotation(),
                                   samplePhysical->GetTranslation());
        sampleTf.Invert();
        const G4ThreeVector samplePoint = sampleTf.TransformPoint(localPoint);
        const G4double sampleSafety = sampleSolid->DistanceToIn(samplePoint);
        if ( sampleSafety<ourSafety )
        {
          ourSafety = sampleSafety;
        }
        if ( sampleSafety<=ourStep )
        {
          sampleDirection = sampleTf.TransformAxis(localDirection);
          G4double sampleStep =
                   sampleSolid->DistanceToIn(samplePoint, sampleDirection);
          if ( sampleStep<=ourStep )
          {
            ourStep = sampleStep;
            entering = true;
            exiting = false;
            *pBlockedPhysical = samplePhysical;
            blockedReplicaNo = sampleNo;
#ifdef G4VERBOSE
              // Check to see that the resulting point is indeed in/on volume.
              // This check could eventually be made only for successful
              // candidate.
 
              if ( ( fCheck ) && ( sampleStep < kInfinity ) )
              {
                G4ThreeVector intersectionPoint;
                intersectionPoint = samplePoint + sampleStep * sampleDirection;
                EInside insideIntPt = sampleSolid->Inside(intersectionPoint); 
                if( insideIntPt != kSurface )
                {
                  G4int oldcoutPrec = G4cout.precision(16); 
                  std::ostringstream message;
                  message << "Navigator gets conflicting response from Solid."
                          << G4endl
                          << "          Inaccurate solid DistanceToIn"
                          << " for solid " << sampleSolid->GetName() << G4endl
                          << "          Solid gave DistanceToIn = "
                          << sampleStep << " yet returns " ;
                  if( insideIntPt == kInside )
                    message << "-kInside-"; 
                  else if( insideIntPt == kOutside )
                    message << "-kOutside-";
                  else
                    message << "-kSurface-"; 
                  message << " for this point !" << G4endl
                          << "          Point = " << intersectionPoint
                          << G4endl;
                  if ( insideIntPt != kInside )
                    message << "        DistanceToIn(p) = " 
                            << sampleSolid->DistanceToIn(intersectionPoint);
                  if ( insideIntPt != kOutside ) 
                    message << "        DistanceToOut(p) = " 
                            << sampleSolid->DistanceToOut(intersectionPoint);
                  G4Exception("G4ParameterisedNavigation::ComputeStep()", 
                              "GeomNav1002", JustWarning, message);
                  G4cout.precision(oldcoutPrec);
                }
              }
#endif
          }
        }
      }
    }
 
    if ( initialNode )
    {
      initialNode = false;
      voxelSafety = ComputeVoxelSafety(localPoint,axis);
      if ( voxelSafety<ourSafety )
      {
        ourSafety = voxelSafety;
      }
      if ( currentProposedStepLength<ourSafety )
      {
        // Guaranteed physics limited
        //      
        noStep = false;
        entering = false;
        exiting = false;
        *pBlockedPhysical = nullptr;
        ourStep = kInfinity;
      }
      else
      {
        // Consider intersection with mother solid
        //
        if ( motherSafety<=ourStep )
        {
          if ( !fCheck )           
          {
            motherStep = motherSolid->DistanceToOut(localPoint,
                                                   localDirection,
                                                   true,
                                                   &motherValidExitNormal,
                                                   &motherExitNormal);
          }
 
          if( ( motherStep < 0.0 ) || ( motherStep >= kInfinity) )
          {
#ifdef G4VERBOSE
            fLogger->ReportOutsideMother(localPoint, localDirection,
                                         motherPhysical);
#endif
            ourStep = motherStep = 0.0;
            // Rely on the code below to set the remaining state, i.e.
            // exiting, entering,  exitNormal & validExitNormal,
            // pBlockedPhysical etc.
          }
#ifdef G4VERBOSE
          if( motherValidExitNormal && ( fCheck || (motherStep<=ourStep)) )
          {
            fLogger->CheckAndReportBadNormal(motherExitNormal,
                                             localPoint, localDirection,
                                             motherStep, motherSolid,
                                             "From motherSolid::DistanceToOut");
          }
#endif
          if ( motherStep<=ourStep )
          {
            ourStep = motherStep;
            exiting = true;
            entering = false;
            if ( validExitNormal )
            {
              const G4RotationMatrix* rot = motherPhysical->GetRotation();
              if (rot)
              {
                exitNormal *= rot->inverse();
              }
            }
          }
          else
          {
            validExitNormal = false;
          }
        }
      }
      newSafety = ourSafety;
    }
    if (noStep)
    {
      noStep = LocateNextVoxel(localPoint, localDirection, ourStep, axis);
    }
  } while (noStep);
 
  return ourStep;
}

References G4BlockingList::BlockVolume(), G4NavigationLogger::CheckAndReportBadNormal(), ComputeVoxelSafety(), DBL_MAX, G4VSolid::DistanceToIn(), G4VSolid::DistanceToOut(), CLHEP::Hep3Vector::dot(), G4VSolid::DumpInfo(), G4BlockingList::Enlarge(), FatalException, G4VoxelNavigation::fBList, G4VoxelNavigation::fCheck, G4VoxelNavigation::fLogger, G4VoxelNavigation::fVoxelNode, G4cout, G4endl, G4Exception(), G4LogicalVolume::GetDaughter(), G4VPhysicalVolume::GetLogicalVolume(), G4VPhysicalVolume::GetName(), G4VSolid::GetName(), G4SmartVoxelNode::GetNoContained(), G4VPhysicalVolume::GetParameterisation(), G4VPhysicalVolume::GetReplicationData(), G4VPhysicalVolume::GetRotation(), G4LogicalVolume::GetSolid(), G4VSolid::GetTolerance(), G4VPhysicalVolume::GetTranslation(), G4SmartVoxelNode::GetVolume(), g4zmq::history(), IdentifyAndPlaceSolid(), G4VSolid::Inside(), CLHEP::HepRotation::inverse(), G4AffineTransform::Invert(), G4BlockingList::IsBlocked(), JustWarning, kInfinity, kInside, kMinExitingNormalCosine, kOutside, kSurface, LocateNextVoxel(), G4NavigationLogger::ReportOutsideMother(), G4BlockingList::Reset(), G4AffineTransform::TransformAxis(), and G4AffineTransform::TransformPoint().

Referenced by G4Navigator::ComputeStep(), G4ITNavigator1::ComputeStep(), and G4ITNavigator2::ComputeStep().

◆ ComputeVoxelSafety() [1/2]

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

protectedinherited

Definition at line 383 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;
}

References G4VoxelNavigation::fVoxelAxisStack, G4VoxelNavigation::fVoxelDepth, G4VoxelNavigation::fVoxelHeaderStack, G4VoxelNavigation::fVoxelNode, G4VoxelNavigation::fVoxelNodeNoStack, G4VoxelNavigation::fVoxelSliceWidthStack, G4SmartVoxelNode::GetMaxEquivalentSliceNo(), G4SmartVoxelNode::GetMinEquivalentSliceNo(), G4SmartVoxelHeader::GetMinExtent(), and G4INCL::Math::min().

Referenced by G4VoxelNavigation::ComputeSafety(), G4VoxelNavigation::ComputeStep(), and ComputeVoxelSafety().

◆ ComputeVoxelSafety() [2/2]

G4double G4ParameterisedNavigation::ComputeVoxelSafety	(	const G4ThreeVector &	localPoint,
		const EAxis	pAxis
	)		const

private

Definition at line 492 of file G4ParameterisedNavigation.cc.

{
  // If no best axis is specified, adopt default
  // strategy as for placements
  //  
  if ( pAxis==kUndefined )
  {
    return G4VoxelNavigation::ComputeVoxelSafety(localPoint);
  }
 
  G4double voxelSafety, plusVoxelSafety, minusVoxelSafety;
  G4double curNodeOffset, minCurCommonDelta, maxCurCommonDelta;
  G4int minCurNodeNoDelta, maxCurNodeNoDelta;
  
  // Compute linear intersection distance to boundaries of max/min
  // to collected nodes at current level
  //
  curNodeOffset = fVoxelNodeNo*fVoxelSliceWidth;
  minCurCommonDelta = localPoint(fVoxelAxis)
                    - fVoxelHeader->GetMinExtent()-curNodeOffset;
  maxCurNodeNoDelta = fVoxelNode->GetMaxEquivalentSliceNo()-fVoxelNodeNo;
  minCurNodeNoDelta = fVoxelNodeNo-fVoxelNode->GetMinEquivalentSliceNo();
  maxCurCommonDelta = fVoxelSliceWidth-minCurCommonDelta;
  plusVoxelSafety   = minCurNodeNoDelta*fVoxelSliceWidth+minCurCommonDelta;
  minusVoxelSafety  = maxCurNodeNoDelta*fVoxelSliceWidth+maxCurCommonDelta;
  voxelSafety = std::min(plusVoxelSafety,minusVoxelSafety);
 
  if ( voxelSafety<0 )
  {
    voxelSafety = 0;
  }
 
  return voxelSafety;
}

References G4VoxelNavigation::ComputeVoxelSafety(), fVoxelAxis, fVoxelHeader, G4VoxelNavigation::fVoxelNode, fVoxelNodeNo, fVoxelSliceWidth, G4SmartVoxelNode::GetMaxEquivalentSliceNo(), G4SmartVoxelNode::GetMinEquivalentSliceNo(), G4SmartVoxelHeader::GetMinExtent(), kUndefined, and G4INCL::Math::min().

Referenced by ComputeSafety(), and ComputeStep().

◆ CreateVolumeWithParent()

G4VPhysicalVolume * G4ParameterisedNavigation::CreateVolumeWithParent	(	G4VPhysicalVolume *	curPhysical,
		const G4NavigationHistory &	hist
	)

private

◆ EnableBestSafety()

void G4VoxelNavigation::EnableBestSafety ( G4bool flag = false )

inlineinherited

◆ GetVerboseLevel()

G4int G4VoxelNavigation::GetVerboseLevel ( ) const

inlineinherited

◆ IdentifyAndPlaceSolid()

G4VSolid * G4ParameterisedNavigation::IdentifyAndPlaceSolid	(	G4int	num,
		G4VPhysicalVolume *	apparentPhys,
		G4VPVParameterisation *	curParam
	)

inlineprivate

Referenced by ComputeSafety(), ComputeStep(), and LevelLocate().

◆ LevelLocate()

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

virtual

Reimplemented from G4VoxelNavigation.

Definition at line 602 of file G4ParameterisedNavigation.cc.

{
  G4SmartVoxelHeader *motherVoxelHeader;
  G4SmartVoxelNode *motherVoxelNode;
  G4VPhysicalVolume *motherPhysical, *pPhysical;
  G4VPVParameterisation *pParam;
  G4LogicalVolume *motherLogical;
  G4VSolid *pSolid;
  G4ThreeVector samplePoint;
  G4int voxelNoDaughters, replicaNo;
  
  motherPhysical = history.GetTopVolume();
  motherLogical = motherPhysical->GetLogicalVolume();
  motherVoxelHeader = motherLogical->GetVoxelHeader();
 
  // Find the voxel containing the point
  //
  motherVoxelNode = ParamVoxelLocate(motherVoxelHeader,localPoint);
  
  voxelNoDaughters = motherVoxelNode->GetNoContained();
  if ( voxelNoDaughters==0 )  { return false; }
  
  pPhysical = motherLogical->GetDaughter(0);
  pParam = pPhysical->GetParameterisation();
 
  // Save parent history in touchable history
  //   ... for use as parent t-h in ComputeMaterial method of param
  //
  G4TouchableHistory parentTouchable( history ); 
 
  // Search replicated daughter volume
  //
  for ( auto sampleNo=voxelNoDaughters-1; sampleNo>=0; sampleNo-- )
  {
    replicaNo = motherVoxelNode->GetVolume(sampleNo);
    if ( (replicaNo!=blockedNum) || (pPhysical!=blockedVol) )
    {
      // Obtain solid (as it can vary) and obtain its parameters
      //
      pSolid = IdentifyAndPlaceSolid( replicaNo, pPhysical, pParam ); 
 
      // Setup history
      //
      history.NewLevel(pPhysical, kParameterised, replicaNo);
      samplePoint = history.GetTopTransform().TransformPoint(globalPoint);
      if ( !G4AuxiliaryNavServices::CheckPointOnSurface( pSolid, samplePoint,
            globalDirection, history.GetTopTransform(), pLocatedOnEdge) )
      {
        history.BackLevel();
      }
      else
      { 
        // Enter this daughter
        //
        localPoint = samplePoint;
        
        // Set the correct copy number in physical
        //
        pPhysical->SetCopyNo(replicaNo);
        
        // Set the correct solid and material in Logical Volume
        //
        G4LogicalVolume *pLogical = pPhysical->GetLogicalVolume();
        pLogical->SetSolid(pSolid);
        pLogical->UpdateMaterial(pParam->ComputeMaterial(replicaNo,
                                 pPhysical, &parentTouchable)  );
        return true;
      }
    }
  }
  return false;
}

References G4AuxiliaryNavServices::CheckPointOnSurface(), G4VPVParameterisation::ComputeMaterial(), G4LogicalVolume::GetDaughter(), G4VPhysicalVolume::GetLogicalVolume(), G4SmartVoxelNode::GetNoContained(), G4VPhysicalVolume::GetParameterisation(), G4SmartVoxelNode::GetVolume(), G4LogicalVolume::GetVoxelHeader(), g4zmq::history(), IdentifyAndPlaceSolid(), kParameterised, ParamVoxelLocate(), G4VPhysicalVolume::SetCopyNo(), G4LogicalVolume::SetSolid(), and G4LogicalVolume::UpdateMaterial().

Referenced by G4ITNavigator1::LocateGlobalPointAndSetup(), G4ITNavigator2::LocateGlobalPointAndSetup(), and G4Navigator::LocateGlobalPointAndSetup().

◆ LocateNextVoxel() [1/2]

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

protectedinherited

Definition at line 472 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 = 0;
      while ( !newVoxelNode )
      {
        newProxy = newHeader->GetSlice(newNodeNo);
        if (newProxy->IsNode())
        {
          newVoxelNode = newProxy->GetNode();
        }
        else
        {
          ++fVoxelDepth;
          newHeader = newProxy->GetHeader();
          newHeaderAxis = newHeader->GetAxis();
          newHeaderNoSlices = 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 G4VoxelNavigation::ComputeStep(), and LocateNextVoxel().

◆ LocateNextVoxel() [2/2]

G4bool G4ParameterisedNavigation::LocateNextVoxel	(	const G4ThreeVector &	localPoint,
		const G4ThreeVector &	localDirection,
		const G4double	currentStep,
		const EAxis	pAxis
	)

private

Definition at line 540 of file G4ParameterisedNavigation.cc.

{
  // If no best axis is specified, adopt default
  // location strategy as for placements
  //  
  if ( pAxis==kUndefined )
  {
    return G4VoxelNavigation::LocateNextVoxel(localPoint,
                                              localDirection,
                                              currentStep);
  }
 
  G4bool isNewVoxel;
  G4int newNodeNo;
  G4double minVal, maxVal, curMinExtent, curCoord;
 
  curMinExtent = fVoxelHeader->GetMinExtent();
  curCoord = localPoint(fVoxelAxis)+currentStep*localDirection(fVoxelAxis);
  minVal = curMinExtent+fVoxelNode->GetMinEquivalentSliceNo()*fVoxelSliceWidth;
  isNewVoxel = false;
 
  if ( minVal<=curCoord )
  {
    maxVal = curMinExtent
           + (fVoxelNode->GetMaxEquivalentSliceNo()+1)*fVoxelSliceWidth;
    if ( maxVal<curCoord )
    {
      newNodeNo = fVoxelNode->GetMaxEquivalentSliceNo()+1;
      if ( newNodeNo<G4int(fVoxelHeader->GetNoSlices()) )
      {
        fVoxelNodeNo = newNodeNo;
        fVoxelNode = fVoxelHeader->GetSlice(newNodeNo)->GetNode();
        isNewVoxel = true;
      }
    }
  }
  else
  {
    newNodeNo = fVoxelNode->GetMinEquivalentSliceNo()-1;
 
    // Must locate from newNodeNo no and down to setup stack and fVoxelNode
    // Repeat or earlier code...
    //
    if ( newNodeNo>=0 )
    {
      fVoxelNodeNo = newNodeNo;
      fVoxelNode = fVoxelHeader->GetSlice(newNodeNo)->GetNode();
      isNewVoxel = true;
    }
  }
  return isNewVoxel;
}

References fVoxelAxis, fVoxelHeader, G4VoxelNavigation::fVoxelNode, fVoxelNodeNo, fVoxelSliceWidth, G4SmartVoxelNode::GetMaxEquivalentSliceNo(), G4SmartVoxelNode::GetMinEquivalentSliceNo(), G4SmartVoxelHeader::GetMinExtent(), G4SmartVoxelProxy::GetNode(), G4SmartVoxelHeader::GetNoSlices(), G4SmartVoxelHeader::GetSlice(), kUndefined, and G4VoxelNavigation::LocateNextVoxel().

Referenced by ComputeStep().

◆ ParamVoxelLocate()

G4SmartVoxelNode * G4ParameterisedNavigation::ParamVoxelLocate	(	G4SmartVoxelHeader *	pHead,
		const G4ThreeVector &	localPoint
	)

inline

Referenced by LevelLocate(), G4Navigator::LocateGlobalPointWithinVolume(), G4ITNavigator1::LocateGlobalPointWithinVolume(), and G4ITNavigator2::LocateGlobalPointWithinVolume().

◆ PostComputeStepLog()

void G4VoxelNavigation::PostComputeStepLog	(	const G4VSolid *	motherSolid,
		const G4ThreeVector &	localPoint,
		const G4ThreeVector &	localDirection,
		G4double	motherStep,
		G4double	motherSafety
	)

privateinherited

◆ PreComputeStepLog()

void G4VoxelNavigation::PreComputeStepLog	(	const G4VPhysicalVolume *	motherPhysical,
		G4double	motherSafety,
		const G4ThreeVector &	localPoint
	)

privateinherited

◆ PrintDaughterLog()

void G4VoxelNavigation::PrintDaughterLog	(	const G4VSolid *	sampleSolid,
		const G4ThreeVector &	samplePoint,
		G4double	sampleSafety,
		G4double	sampleStep
	)

inlineprivateinherited

◆ SetVerboseLevel()

void G4VoxelNavigation::SetVerboseLevel ( G4int level )

inherited

Definition at line 767 of file G4VoxelNavigation.cc.

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

References G4VoxelNavigation::fLogger, G4VoxelNavigation::fpVoxelSafety, G4NavigationLogger::SetVerboseLevel(), and G4VoxelSafety::SetVerboseLevel().

Referenced by G4VoxelNavigation::G4VoxelNavigation().

◆ VoxelLocate()

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

inherited

Referenced by G4Navigator::LocateGlobalPointWithinVolume(), G4ITNavigator1::LocateGlobalPointWithinVolume(), and G4ITNavigator2::LocateGlobalPointWithinVolume().

◆ VoxelLocateLight()

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

protectedinherited

Field Documentation

◆ fBestSafety

G4bool G4VoxelNavigation::fBestSafety = false

protectedinherited

Definition at line 186 of file G4VoxelNavigation.hh.

Referenced by G4VoxelNavigation::ComputeSafety().

◆ fBList

G4BlockingList G4VoxelNavigation::fBList

protectedinherited

Definition at line 146 of file G4VoxelNavigation.hh.

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

◆ fCheck

G4bool G4VoxelNavigation::fCheck = false

protectedinherited

Definition at line 185 of file G4VoxelNavigation.hh.

Referenced by G4VoxelNavigation::ComputeSafety(), ComputeStep(), and G4VoxelNavigation::ComputeStep().

◆ fHalfTolerance

G4double G4VoxelNavigation::fHalfTolerance

protectedinherited

Definition at line 182 of file G4VoxelNavigation.hh.

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

◆ fLogger

G4NavigationLogger* G4VoxelNavigation::fLogger

protectedinherited

Definition at line 188 of file G4VoxelNavigation.hh.

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

◆ fpVoxelSafety

G4VoxelSafety* G4VoxelNavigation::fpVoxelSafety = nullptr

protectedinherited

Definition at line 179 of file G4VoxelNavigation.hh.

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

◆ fVoxelAxis

EAxis G4ParameterisedNavigation::fVoxelAxis = kUndefined

private

Definition at line 114 of file G4ParameterisedNavigation.hh.

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

◆ fVoxelAxisStack

std::vector<EAxis> G4VoxelNavigation::fVoxelAxisStack

protectedinherited

Definition at line 157 of file G4VoxelNavigation.hh.

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

◆ fVoxelDepth

G4int G4VoxelNavigation::fVoxelDepth = -1

protectedinherited

Definition at line 153 of file G4VoxelNavigation.hh.

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

◆ fVoxelHeader

G4SmartVoxelHeader* G4ParameterisedNavigation::fVoxelHeader = nullptr

private

Definition at line 118 of file G4ParameterisedNavigation.hh.

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

◆ fVoxelHeaderStack

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

protectedinherited

Definition at line 169 of file G4VoxelNavigation.hh.

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

◆ fVoxelNode

G4SmartVoxelNode* G4VoxelNavigation::fVoxelNode = nullptr

protectedinherited

Definition at line 172 of file G4VoxelNavigation.hh.

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

◆ fVoxelNodeNo

size_t G4ParameterisedNavigation::fVoxelNodeNo = 0

private

Definition at line 117 of file G4ParameterisedNavigation.hh.

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

◆ fVoxelNodeNoStack

std::vector<G4int> G4VoxelNavigation::fVoxelNodeNoStack

protectedinherited

Definition at line 166 of file G4VoxelNavigation.hh.

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

◆ fVoxelNoSlices

G4int G4ParameterisedNavigation::fVoxelNoSlices = 0

private

Definition at line 115 of file G4ParameterisedNavigation.hh.

◆ fVoxelNoSlicesStack

std::vector<G4int> G4VoxelNavigation::fVoxelNoSlicesStack

protectedinherited

Definition at line 160 of file G4VoxelNavigation.hh.

Referenced by G4VoxelNavigation::LocateNextVoxel().

◆ fVoxelSliceWidth

G4double G4ParameterisedNavigation::fVoxelSliceWidth = 0.0

private

Definition at line 116 of file G4ParameterisedNavigation.hh.

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

◆ fVoxelSliceWidthStack

std::vector<G4double> G4VoxelNavigation::fVoxelSliceWidthStack

protectedinherited

Definition at line 163 of file G4VoxelNavigation.hh.

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

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

source/geometry/navigation/include/G4ParameterisedNavigation.hh
source/geometry/navigation/src/G4ParameterisedNavigation.cc

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4ParameterisedNavigation()

◆ ~G4ParameterisedNavigation()

Member Function Documentation

◆ AlongComputeStepLog()

◆ CheckMode()

◆ ComputeSafety()

◆ ComputeSafetyLog()

◆ ComputeStep()

◆ ComputeVoxelSafety() [1/2]

◆ ComputeVoxelSafety() [2/2]

◆ CreateVolumeWithParent()

◆ EnableBestSafety()

◆ GetVerboseLevel()

◆ IdentifyAndPlaceSolid()

◆ LevelLocate()

◆ LocateNextVoxel() [1/2]

◆ LocateNextVoxel() [2/2]

◆ ParamVoxelLocate()

◆ PostComputeStepLog()

◆ PreComputeStepLog()

◆ PrintDaughterLog()

◆ SetVerboseLevel()

◆ VoxelLocate()

◆ VoxelLocateLight()

Field Documentation

◆ fBestSafety

◆ fBList

◆ fCheck

◆ fHalfTolerance

◆ fLogger

◆ fpVoxelSafety

◆ fVoxelAxis

◆ fVoxelAxisStack

◆ fVoxelDepth

◆ fVoxelHeader

◆ fVoxelHeaderStack

◆ fVoxelNode

◆ fVoxelNodeNo

◆ fVoxelNodeNoStack

◆ fVoxelNoSlices

◆ fVoxelNoSlicesStack

◆ fVoxelSliceWidth

◆ fVoxelSliceWidthStack