G4RegularNavigation Class Reference

#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.

{
}

Member Function Documentation

void G4RegularNavigation::CheckMode ( G4bool  mode )

inline

Definition at line 118 of file G4RegularNavigation.hh.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4RegularNavigation::SetNormalNavigation ( G4NormalNavigation *  fnormnav )

inline

Definition at line 119 of file G4RegularNavigation.hh.

      { fnormalNav = fnormnav; }

Here is the caller graph for this function:

void G4RegularNavigation::SetVerboseLevel ( G4int  level )

inline

Definition at line 117 of file G4RegularNavigation.hh.

{ fverbose = level; }

---

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

• source/geant4.10.03.p02/source/geometry/navigation/include/G4RegularNavigation.hh
• source/geant4.10.03.p02/source/geometry/navigation/src/G4RegularNavigation.cc