#include <G4RegularNavigation.hh>

Public Member Functions
	G4RegularNavigation ()

	~G4RegularNavigation ()

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

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)

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)

void	SetVerboseLevel (G4int level)

void	CheckMode (G4bool mode)

void	SetNormalNavigation (G4NormalNavigation *fnormnav)

Detailed Description

Definition at line 54 of file G4RegularNavigation.hh.

Constructor & Destructor Documentation

G4RegularNavigation::G4RegularNavigation ( )

Definition at line 46 of file G4RegularNavigation.cc.

   : fverbose(false), fcheck(false), fnormalNav(0)
 {
   kCarTolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
 }

Here is the call graph for this function:

G4RegularNavigation::~G4RegularNavigation ( )

Definition at line 54 of file G4RegularNavigation.cc.

55 {

56 }

Member Function Documentation

void G4RegularNavigation::CheckMode ( G4bool mode )

inline

Definition at line 118 of file G4RegularNavigation.hh.

118 { fcheck = mode; }

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 61 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().Inverse().TransformPoint(localPoint);
   G4ThreeVector globalDirection =
          history.GetTopTransform().Inverse().TransformAxis(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);
 
   G4PhantomParameterisation * 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);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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 123 of file G4RegularNavigation.cc.

 {
   G4RegularNavigationHelper::Instance()->ClearStepLengths();
 
   G4PhantomParameterisation *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
   //
   G4int ide = history.GetDepth();
   G4ThreeVector containerPoint = history.GetTransform(ide).Inverse().TransformPoint(localPoint);
 
   // Point in global frame
   //
   containerPoint = history.GetTransform(ide).Inverse().TransformPoint(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, 0, 0 );
   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 
   //
   for( ;; )
   {
     newStep = voxelBox->DistanceToOut( localPoint, localDirection );
 
     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;
     }
     else
     {
       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 );
 
     //    G4cout << " copyNo " << copyNo << " = " << pCurrentPhysical->GetCopyNo() << G4endl;
     // 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, 0, 0 );
 
     if( currentMate != nextMate ) { break; }
   }
 
   return ourStep;
 }

Here is the call graph for this function:

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

Definition at line 286 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 )
   {
     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->GetNoVoxel()) )
   {
     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;
 }