G4RegularNavigation Class Reference

#include <G4RegularNavigation.hh>

Inheritance diagram for G4RegularNavigation:

Public Member Functions
	G4RegularNavigation ()
	~G4RegularNavigation () override
G4bool	LevelLocate (G4NavigationHistory &history, const G4VPhysicalVolume *blockedVol, const G4int blockedNum, const G4ThreeVector &globalPoint, const G4ThreeVector *globalDirection, const G4bool pLocatedOnEdge, G4ThreeVector &localPoint) final
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) final
G4double	ComputeStepSkippingEqualMaterials (G4ThreeVector &localPoint, const G4ThreeVector &globalDirection, const G4double currentProposedStepLength, G4double &newSafety, G4NavigationHistory &history, G4bool &validExitNormal, G4ThreeVector &exitNormal, G4bool &exiting, G4bool &entering, G4VPhysicalVolume *(*pBlockedPhysical), G4int &blockedReplicaNo, G4VPhysicalVolume *pCurrentPhysical)
G4double	ComputeSafety (const G4ThreeVector &localPoint, const G4NavigationHistory &history, const G4double pProposedMaxLength=DBL_MAX) final
void	SetNormalNavigation (G4NormalNavigation *fnormnav)
Public Member Functions inherited from G4VNavigation
virtual	~G4VNavigation ()=default
virtual void	RelocateWithinVolume (G4VPhysicalVolume *, const G4ThreeVector &)
virtual G4int	GetVerboseLevel () const
virtual void	SetVerboseLevel (G4int level)
void	CheckMode (G4bool mode)

Additional Inherited Members
Protected Attributes inherited from G4VNavigation
G4int	fVerbose = 0
G4bool	fCheck = false

Detailed Description

Definition at line 51 of file G4RegularNavigation.hh.

Constructor & Destructor Documentation

G4RegularNavigation()

G4RegularNavigation::G4RegularNavigation

(

)

Definition at line 42 of file G4RegularNavigation.cc.

{
  kCarTolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
  fMinStep = 101*kCarTolerance;
}

~G4RegularNavigation()

G4RegularNavigation::~G4RegularNavigation ( )

overridedefault

Member Function Documentation

ComputeSafety()

G4double G4RegularNavigation::ComputeSafety ( const G4ThreeVector & globalpoint, const G4NavigationHistory & history, const G4double pMaxLength = DBL_MAX )

finalvirtual

Compute the distance to the closest surface.

Parameters

[in]	globalPoint	Global 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 345 of file G4RegularNavigation.cc.

{
  // This method is never called because to be called the daughter has to be a
  // regular structure. This would only happen if the track is in the mother of
  // voxels volume. But the voxels fill completely their mother, so when a
  // track enters the mother it automatically enters a voxel. Only precision
  // problems would make this method to be called
 
  // Compute step in voxel
  //
  return fnormalNav->ComputeSafety(localPoint,
                                   history,
                                   pMaxLength );
}

ComputeStep()

G4double G4RegularNavigation::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 )

finalvirtual

Compute the length of a step to the next boundary. Do not test against pBlockedPhysical. Identify the next candidate volume (if a daughter of current volume), and return it in pBlockedPhysical, blockedReplicaNo.

Parameters

[in]	localPoint	Local point
[in]	localDirection	Pointer to local direction or null pointer.
[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]	entering	Flag to indicate whether we are entering a volume.
[in,out]	exiting	Flag to indicate whether we are exiting 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 54 of file G4RegularNavigation.cc.

{
  // This method is never called because to be called the daughter has to be
  // a regular structure. This would only happen if the track is in the mother
  // of voxels volume. But the voxels fill completely their mother, so when a
  // track enters the mother it automatically enters a voxel. Only precision
  // problems would make this method to be called
 
  G4ThreeVector globalPoint =
    history.GetTopTransform().InverseTransformPoint(localPoint);
  G4ThreeVector globalDirection =
         history.GetTopTransform().InverseTransformAxis(localDirection);
 
  G4ThreeVector localPoint2 = localPoint; // take away constantness
 
  LevelLocate( history, *pBlockedPhysical, blockedReplicaNo, 
               globalPoint, &globalDirection, true, localPoint2 );
 
 
  // Get in which voxel it is
  //
  G4VPhysicalVolume *motherPhysical, *daughterPhysical;
  G4LogicalVolume *motherLogical;
  motherPhysical = history.GetTopVolume();
  motherLogical = motherPhysical->GetLogicalVolume();
  daughterPhysical = motherLogical->GetDaughter(0);
 
  auto daughterParam =
       (G4PhantomParameterisation*)(daughterPhysical->GetParameterisation());
  G4int copyNo = daughterParam ->GetReplicaNo(localPoint,localDirection);
 
  G4ThreeVector voxelTranslation = daughterParam->GetTranslation( copyNo );
  G4ThreeVector daughterPoint = localPoint - voxelTranslation;
 
 
  // Compute step in voxel
  //
  return fnormalNav->ComputeStep(daughterPoint,
                                 localDirection,
                                 currentProposedStepLength,
                                 newSafety,
                                 history,
                                 validExitNormal,
                                 exitNormal,
                                 exiting,
                                 entering,
                                 pBlockedPhysical,
                                 blockedReplicaNo);
}

ComputeStepSkippingEqualMaterials()

G4double G4RegularNavigation::ComputeStepSkippingEqualMaterials	(	G4ThreeVector &	localPoint,
		const G4ThreeVector &	globalDirection,
		const G4double	currentProposedStepLength,
		G4double &	newSafety,
		G4NavigationHistory &	history,
		G4bool &	validExitNormal,
		G4ThreeVector &	exitNormal,
		G4bool &	exiting,
		G4bool &	entering,
		G4VPhysicalVolume **	pBlockedPhysical,
		G4int &	blockedReplicaNo,
		G4VPhysicalVolume *	pCurrentPhysical )

Definition at line 117 of file G4RegularNavigation.cc.

{
  G4RegularNavigationHelper::Instance()->ClearStepLengths();
 
  auto param =
    (G4PhantomParameterisation*)(pCurrentPhysical->GetParameterisation());
 
  if( !param->SkipEqualMaterials() )
  {
    return fnormalNav->ComputeStep(localPoint,
                                   localDirection,
                                   currentProposedStepLength,
                                   newSafety,
                                   history,
                                   validExitNormal,
                                   exitNormal,
                                   exiting,
                                   entering,
                                   pBlockedPhysical,
                                   blockedReplicaNo);
  }
 
 
  G4double ourStep = 0.;
 
  // To get replica No: transform local point to the reference system of the
  // param container volume
  //
  auto  ide = (G4int)history.GetDepth();
  G4ThreeVector containerPoint = history.GetTransform(ide)
                                 .InverseTransformPoint(localPoint);
 
  // Point in global frame
  //
  containerPoint = history.GetTransform(ide).InverseTransformPoint(localPoint);
 
  // Point in voxel parent volume frame
  //
  containerPoint = history.GetTransform(ide-1).TransformPoint(containerPoint);
 
  // Store previous voxel translation to move localPoint by the difference
  // with the new one
  //
  G4ThreeVector prevVoxelTranslation = containerPoint - localPoint;
 
  // Do not use the expression below: There are cases where the
  // fLastLocatedPointLocal does not give the correct answer
  // (particle reaching a wall and bounced back, particle travelling through
  // the wall that is deviated in an step, ...; these are pathological cases
  // that give wrong answers in G4PhantomParameterisation::GetReplicaNo()
  //
  // G4ThreeVector prevVoxelTranslation = param->GetTranslation( copyNo );
 
  G4int copyNo = param->GetReplicaNo(containerPoint,localDirection);
 
  G4Material* currentMate = param->ComputeMaterial( copyNo, nullptr, nullptr );
  G4VSolid* voxelBox = pCurrentPhysical->GetLogicalVolume()->GetSolid();
 
  G4VSolid* containerSolid = param->GetContainerSolid();
  G4Material* nextMate;
  G4bool bFirstStep = true;
  G4double newStep;
  G4double totalNewStep = 0.;
 
  // Loop while same material is found 
  //
  //
  fNumberZeroSteps = 0;
  for( G4int ii = 0; ii < fNoStepsAllowed+1; ++ii )
  {
    if( ii == fNoStepsAllowed ) {
      // Must kill this stuck track
      //
      G4ThreeVector pGlobalpoint = history.GetTransform(ide)
                                   .InverseTransformPoint(localPoint);
      std::ostringstream message;
      message << "G4RegularNavigation::ComputeStepSkippingEqualMaterials()"
        << "Stuck Track: potential geometry or navigation problem."
        << G4endl
        << "        Track stuck, moving for more than " 
        << ii << " steps" << G4endl
        << "- at point " << pGlobalpoint << G4endl
        << "        local direction: " << localDirection << G4endl;
      G4Exception("G4RegularNavigation::ComputeStepSkippingEqualMaterials()",
      "GeomRegNav1001",
      EventMustBeAborted,
      message);
    }
    newStep = voxelBox->DistanceToOut( localPoint, localDirection );
    fLastStepWasZero = (newStep<fMinStep);
    if( fLastStepWasZero )
    {
      ++fNumberZeroSteps;
#ifdef G4DEBUG_NAVIGATION
      if( fNumberZeroSteps > 1 )
      {
        G4ThreeVector pGlobalpoint = history.GetTransform(ide)
                                     .InverseTransformPoint(localPoint);
      std::ostringstream message;
      message.precision(16);
      message << "G4RegularNavigation::ComputeStepSkippingEqualMaterials(): another 'zero' step, # "
            << fNumberZeroSteps
            << ", at " << pGlobalpoint
            << ", nav-comp-step calls # " << ii
            << ", Step= " << newStep;
            G4Exception("G4RegularNavigation::ComputeStepSkippingEqualMaterials()",
                        "GeomRegNav1002", JustWarning, message,
                        "Potential overlap in geometry!");
      }
#endif
      if( fNumberZeroSteps > fActionThreshold_NoZeroSteps-1 )
      {
        // Act to recover this stuck track. Pushing it along direction
        //
        newStep = std::min(101*kCarTolerance*std::pow(10,fNumberZeroSteps-2),0.1);
#ifdef G4DEBUG_NAVIGATION
        G4ThreeVector pGlobalpoint = history.GetTransform(ide)
                                       .InverseTransformPoint(localPoint);
        std::ostringstream message;
        message.precision(16);
        message << "Track stuck or not moving." << G4endl
                      << "          Track stuck, not moving for " 
                      << fNumberZeroSteps << " steps" << G4endl
                      << "- at point " << pGlobalpoint
                      << " (local point " << localPoint << ")" << G4endl
                      << "        local direction: " << localDirection 
                      << "          Potential geometry or navigation problem !"
                      << G4endl
                      << "          Trying pushing it of " << newStep << " mm ...";
              G4Exception("G4RegularNavigation::ComputeStepSkippingEqualMaterials()",
                          "GeomRegNav1003", JustWarning, message,
                          "Potential overlap in geometry!");
#endif
      }
      if( fNumberZeroSteps > fAbandonThreshold_NoZeroSteps-1 )
      {
        // Must kill this stuck track
        //
        G4ThreeVector pGlobalpoint = history.GetTransform(ide)
                                          .InverseTransformPoint(localPoint);
        std::ostringstream message;
        message << "G4RegularNavigation::ComputeStepSkippingEqualMaterials()"
          << "Stuck Track: potential geometry or navigation problem."
          << G4endl
          << "        Track stuck, not moving for " 
          << fNumberZeroSteps << " steps" << G4endl
          << "- at point " << pGlobalpoint << G4endl  
          << "        local direction: " << localDirection << G4endl;
        G4Exception("G4RegularNavigation::ComputeStepSkippingEqualMaterials()",
              "GeomRegNav1004",
              EventMustBeAborted,
              message);
      }
    }
    else
    {
      // reset the zero step counter when a non-zero step was performed
      fNumberZeroSteps = 0;
    }
    if( (bFirstStep) && (newStep < currentProposedStepLength) )
    {
      exiting  = true;
    }
    bFirstStep = false;
 
    newStep += kCarTolerance;   // Avoid precision problems
    ourStep += newStep;
    totalNewStep += newStep;
 
    // Physical process is limiting the step, don't continue
    //
    if(std::fabs(totalNewStep-currentProposedStepLength) < kCarTolerance)
    { 
      return currentProposedStepLength;
    }
    if(totalNewStep > currentProposedStepLength) 
    { 
      G4RegularNavigationHelper::Instance()->
        AddStepLength(copyNo, newStep-totalNewStep+currentProposedStepLength);
      return currentProposedStepLength;
    }
    G4RegularNavigationHelper::Instance()->AddStepLength( copyNo, newStep );
 
    // Move container point until wall of voxel
    //
    containerPoint += newStep*localDirection;
    if( containerSolid->Inside( containerPoint ) != kInside )
    {
      break;
    }
 
    // Get copyNo and translation of new voxel
    //
    copyNo = param->GetReplicaNo(containerPoint, localDirection);
    G4ThreeVector voxelTranslation = param->GetTranslation( copyNo );
 
    // Move local point until wall of voxel and then put it in the new voxel
    // local coordinates
    //
    localPoint += newStep*localDirection;
    localPoint += prevVoxelTranslation - voxelTranslation;
 
    prevVoxelTranslation = voxelTranslation;
 
    // Check if material of next voxel is the same as that of the current voxel
    nextMate = param->ComputeMaterial( copyNo, nullptr, nullptr );
 
    if( currentMate != nextMate ) { break; }
  }
 
  return ourStep;
}

LevelLocate()

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

finalvirtual

Search 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 that should be ignored in queries.
[in,out]	blockedNum	Copy number for blocked replica volumes.
[in,out]	globalPoint	Global point
[in,out]	globalDirection	Pointer to global direction or null pointer.
[in,out]	localPoint	= global point in local system on entry, point in new system on exit.

Returns

Whether a containing volume has been found.

Implements G4VNavigation.

Definition at line 365 of file G4RegularNavigation.cc.

{
  G4VPhysicalVolume *motherPhysical, *pPhysical;
  G4PhantomParameterisation *pParam;
  G4LogicalVolume *motherLogical;
  G4ThreeVector localDir;
  G4int replicaNo;
  
  motherPhysical = history.GetTopVolume();
  motherLogical = motherPhysical->GetLogicalVolume();
  
  pPhysical = motherLogical->GetDaughter(0);
  pParam = (G4PhantomParameterisation*)(pPhysical->GetParameterisation());
  
  // Save parent history in touchable history
  // ... for use as parent t-h in ComputeMaterial method of param
  //
  G4TouchableHistory parentTouchable( history ); 
  
  // Get local direction
  //
  if( globalDirection != nullptr )
  {
    localDir = history.GetTopTransform().TransformAxis(*globalDirection);
  }
  else
  {
    localDir = G4ThreeVector(0.,0.,0.);
  }
 
  // Enter this daughter
  //
  replicaNo = pParam->GetReplicaNo( localPoint, localDir );
 
  if( replicaNo < 0 || replicaNo >= G4int(pParam->GetNoVoxels()) )
  {
    return false;
  }
 
  // Set the correct copy number in physical
  //
  pPhysical->SetCopyNo(replicaNo);
  pParam->ComputeTransformation(replicaNo,pPhysical);
 
  history.NewLevel(pPhysical, kParameterised, replicaNo );
  localPoint = history.GetTopTransform().TransformPoint(globalPoint);
 
  // Set the correct solid and material in Logical Volume
  //
  G4LogicalVolume *pLogical = pPhysical->GetLogicalVolume();
      
  pLogical->UpdateMaterial(pParam->ComputeMaterial(replicaNo,
                           pPhysical, &parentTouchable) );
  return true;
}

Referenced by ComputeStep().

SetNormalNavigation()

void G4RegularNavigation::SetNormalNavigation ( G4NormalNavigation * fnormnav )

inline

Definition at line 112 of file G4RegularNavigation.hh.

      { fnormalNav = fnormnav; }

---

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

• G4RegularNavigation.hh
• G4RegularNavigation.cc