Geant4 User's Guide For Application Developers Geometry

Navigation through the geometry at tracking time is implemented by the class G4Navigator. The navigator is used to locate points in the geometry and compute distances to geometry boundaries. At tracking time, the navigator is intended to be the only point of interaction with tracking.
Internally, the G4Navigator has several private helper/utility classes:

• G4NavigationHistory - stores the compounded transformations, replication/parameterisation information, and volume pointers at each level of the hierarchy to the current location. The volume types at each level are also stored - whether normal (placement), replicated or parameterised.
• G4NormalNavigation - provides location & distance computation functions for geometries containing 'placement' volumes, with no voxels.
• G4VoxelNavigation - provides location and distance computation functions for geometries containing 'placement' physical volumes with voxels. Internally a stack of voxel information is maintained. Private functions allow for isotropic distance computation to voxel boundaries and for computation of the 'next voxel' in a specified direction.
• G4ParameterisedNavigation - provides location and distance computation functions for geometries containing parameterised volumes with voxels. Voxel information is maintained similarly to G4VoxelNavigation, but computation can also be simpler by adopting voxels to be one level deep only (unrefined, or 1D optimisation)
• G4ReplicaNavigation - provides location and distance computation functions for replicated volumes.

The main functions required for tracking in the geometry are described below. Additional functions are provided to return the net transformation of volumes and for the creation of touchables. None of the functions implicitly requires that the geometry be described hierarchically.

• SetWorldVolume()
  Sets the first volume in the hierarchy. It must be unrotated and untranslated from the origin.
• LocateGlobalPointAndSetup()
  Locates the volume containing the specified global point. This involves a traverse of the hierarchy, requiring the computation of compound transformations, testing replicated and parameterised volumes (etc). To improve efficiency this search may be performed relative to the last, and this is the recommended way of calling the function. A 'relative' search may be used for the first call of the function which will result in the search defaulting to a search from the root node of the hierarchy. Searches may also be performed using a G4TouchableHistory.
• LocateGlobalPointAndUpdateTouchableHandle()
  First, search the geometrical hierarchy like the above method LocateGlobalPointAndSetup(). Then use the volume found and its navigation history to update the touchable.
• ComputeStep()
  Computes the distance to the next boundary intersected along the specified unit direction from a specified point. The point must be have been located prior to calling ComputeStep().
  When calling ComputeStep(), a proposed physics step is passed. If it can be determined that the first intersection lies at or beyond that distance then kInfinity is returned. In any case, if the returned step is greater than the physics step, the physics step must be taken.
• SetGeometricallyLimitedStep()
  Informs the navigator that the last computed step was taken in its entirety. This enables entering/exiting optimisation, and should be called prior to calling LocateGlobalPointAndSetup().
• CreateTouchableHistory()
  Creates a G4TouchableHistory object, for which the caller has deletion responsibility. The 'touchable' volume is the volume returned by the last Locate operation. The object includes a copy of the current NavigationHistory, enabling the efficient relocation of points in/close to the current volume in the hierarchy.

• The volume contains normal (placement) daughters (or none)
• The volume contains a single parameterised volume object, representing many volumes
• The volume is a replica and contains normal (placement) daughters

More than one navigator objects can be created inside an application; these navigators can act independently for different purposes. The main navigator which is activated automatically at the startup of a simulation program is the navigator used for the tracking and attached the world volume of the main tracking (or mass) geometry.
The navigator for tracking can be retrieved at any state of the application by messagging the G4TransportationManager:

     G4Navigator* tracking_navigator =
       G4TransportationManager::GetInstance()->GetNavigatorForTracking();

Using the 'step' to retrieve geometrical information

During the tracking run, geometrical information can be retrieved through the touchable handle associated to the current step. For example, to identify the exact copy-number of a specific physical volume in the mass geometry, one should do the following:

      // Given the pointer to the step object ...
      //
      G4Step* aStep = ..;

      // ... retrieve the 'pre-step' point
      //
      G4StepPoint* preStepPoint = aStep->GetPreStepPoint();

      // ... retrieve a touchable handle and access to the information
      //
      G4TouchableHandle theTouchable = preStepPoint->GetTouchableHandle();
      G4int copyNo = theTouchable->GetCopyNumber();
      G4int motherCopyNo = theTouchable->GetCopyNumber(1);

      G4ThreeVector worldPosition = preStepPoint->GetPosition();
      G4ThreeVector localPosition = theTouchable->GetHistory()->
                    GetTopTransform().TransformPoint(worldPosition);

Using an alternative navigator to locate points

In order to know (when in the idle state of the application) in which physical volume a given point is located in the detector geometry, it is necessary to create an alternative navigator object first and assign it to the world volume:

     G4Navigator* aNavigator = new G4Navigator();
     aNavigator->SetWorldVolume(worldVolumePointer);

     aNavigator->LocateGlobalPointAndSetup(myPoint);
     G4TouchableHistoryHandle aTouchable =
       aNavigator->CreateTouchableHistoryHandle();

     // Do whatever you need with it ...
     // ... convert point in local coordinates (local to the current volume)
     //
     G4ThreeVector localPosition = aTouchable->GetHistory()->
                   GetTopTransform().TransformPoint(myPoint);

     // ... convert back to global coordinates system
     G4ThreeVector globalPosition = aTouchable->GetHistory()->
                   GetTopTransform().Inverse().TransformPoint(localPosition);

Since release 8.2 of Geant4, it is possible to define geometry trees which are parallel to the tracking geometry and having them assigned to navigator objects that transparently communicate in sync with the normal tracking geometry.

Parallel geometries can be defined for several uses (fast shower parameterisation, geometrical biasing, particle scoring, readout geometries, etc ...) and can overlap with the mass geometry defined for the tracking. The parallel transportation will be activated only after the registration of the parallel geometry in the detector description setup; see Section 4.7 for how to define a parallel geometry and register it to the run-manager.
The G4TransportationManager provides all the utilities to verify, retrieve and activate the navigators associated to the various parallel geometries defined.

When running in verbose mode (i.e. the default, G4VERBOSE set while installing the Geant4 kernel libraries), the navigator provides a few commands to control its behavior. It is possible to select different verbosity levels (up to 5), with the command:

     geometry/navigator/verbose [verbose_level]

     geometry/navigator/check_mode [true/false]