GGSUniqueTouchableIDComputer Class Reference

A class that computes unique IDs for each touchable. More...

#include <GGSUniqueTouchableIDComputer.h>

Inheritance diagram for GGSUniqueTouchableIDComputer:

Collaboration diagram for GGSUniqueTouchableIDComputer:

Public Member Functions
int	ComputeTouchableID (G4Step *aStep)
	Computes the touchable ID in a unique way. More...
Public Member Functions inherited from GGSTouchableIDComputer
virtual	~GGSTouchableIDComputer ()
	Destructor.

Detailed Description

A class that computes unique IDs for each touchable.

This class computes a unique ID for each touchable belonging to a given detector logical volume. It works only for a given volume hierarchy, i.e. for those touchables that are inside the same hierarchy of volumes up to the world volume. For example, a sensitive logical L might be placed as G4PVPlacement twice in the logical container L1 and three times in the logical container L2; L1 and L2 are then placed N1 and N2 times inside the world volume. In this case, the computed IDs will be unique among the physical volumes inside the various L1s, and the same for L2, but the IDs for volumes in L1 and in L2 might be the same.

To obtain unique IDs the various placements of the sensitive volume and all its mother volumes must have different copy numbers.

Definition at line 32 of file GGSUniqueTouchableIDComputer.h.

Member Function Documentation

int GGSUniqueTouchableIDComputer::ComputeTouchableID ( G4Step *  aStep )

virtual

Computes the touchable ID in a unique way.

The ID is computed starting from the replica number and taking into account the multiplicity of the touchable and of all its mother volumes. This requires all the volumes to have unique copy/replica number. For example, consider three sensitive volumes (copy no. 0, 1 and 2) in a container placed two times (copy no.* 0 and 1). Volume 0 in container 0 will have ID 0, volume 0 in container 1 will have ID 3 = copy n. + multiplicity * mother copy n. = 0 + 3*1.

Parameters

aStep

The current step.

Returns

the unique ID of the touchable where the current step is happening.

Implements GGSTouchableIDComputer.

Definition at line 14 of file GGSUniqueTouchableIDComputer.cpp.

                                                                  {

  G4TouchableHandle touchable = aStep->GetPreStepPoint()->GetTouchableHandle();
  G4ThreeVector volPos = touchable->GetTranslation(); // Absolute volume translation

  // Build the absolute touchable ID
  // Definition: the multiplicity of a physical volume is defined as the number of that volumes inside a given mother
  // logical volume. Definition: given a history, the multiplicity at depth i is the multiplicity of the volume in
  // history at depth i Definition: given a history, the copy number at depth i is the copy number of the volume in
  // history at depth i Being N_i and M_i the copy number and multiplicity at depth i, the absolute ID of the touchable
  // at history depth 0 is defined as:
  //   ID = N_0 + M_0*N_1 + M_0*M_1*N_2 + ...
  // At each step, the product M_0*M_1*N_2*... is stored in the variable totMult.

  int historyDepth = touchable->GetHistoryDepth();
  int totMult = 1;
  int touchableID = 0;
  // Map to store the multiplicity of each physical volume

  for (int iDepth = 0; iDepth < historyDepth; iDepth++) { // This loop will go up in history up to the daughter of the
                                                          // world volume (i.e. iDepth == historyDepth - 1)
    touchableID += totMult * touchable->GetCopyNumber(iDepth);
    // Compute total multiplicity for next step
    if (iDepth != historyDepth - 1) { // No need to compute the total multiplicity on last step
      int currVolMult = 0;
      if (!(touchable->GetVolume(iDepth)->IsReplicated())) {
        // See if the multiplicity for the current non-replicated volume has been computed before
        auto storedMult = _multMap.find(touchable->GetVolume(iDepth));
        if (storedMult == _multMap.end()) {
          // Compute the multiplicity for non-replicated volumes placed inside the current mother logical
          G4LogicalVolume *currLogVol = touchable->GetVolume(iDepth)->GetLogicalVolume();
          G4LogicalVolume *motherLogVol = touchable->GetVolume(iDepth)->GetMotherLogical();
          int nDaughters = motherLogVol->GetNoDaughters();
          for (int iDaughter = 0; iDaughter < nDaughters; iDaughter++) {
            if (motherLogVol->GetDaughter(iDaughter)->GetLogicalVolume() == currLogVol)
              currVolMult++;
          }
          // Store the computed multiplicity
          _multMap[touchable->GetVolume(iDepth)] = currVolMult;
        } else {
          // Use the stored multiplicity
          currVolMult = storedMult->second;
        }
      } else {
        // Use the multiplicity of the replicated volume
        EAxis axis;
        G4int nReplicas;
        G4double width, offset;
        G4bool consuming;
        touchable->GetVolume(iDepth)->GetReplicationData(axis, nReplicas, width, offset, consuming);
        currVolMult = nReplicas;
      }
      totMult *= currVolMult;
    }
  }

  return touchableID;
}

---

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

• GGSUniqueTouchableIDComputer.h
• GGSUniqueTouchableIDComputer.cpp