GGSIntHitSD Class Reference

Sensitive detector class for integrated hits. More...

#include <GGSIntHitSD.h>

Inheritance diagram for GGSIntHitSD:

Collaboration diagram for GGSIntHitSD:

Public Member Functions
	GGSIntHitSD (G4String name)
	Constructor. More...
	~GGSIntHitSD ()
	Destructor.
void	Initialize (G4HCofThisEvent *hitCollection)
	Initializes the sensitive detector. More...
G4bool	ProcessHits (G4Step *aStep, G4TouchableHistory *ROHist)
	The hit processing method. More...
void	EndOfEvent (G4HCofThisEvent *hitCollection)
	Sets the hits collection, as required by specifications of mother class. More...
void	SetTimeBin (G4double time)
	Time bins setter. More...
const std::vector< G4double > &	GetTimeBins ()
	Time bins getter. More...
void	SetPartHitsStorage (bool store)
	Turn on or off the storage (i.e. persistency) of particle hits. More...
bool	GetPartHitsStorage ()
	Return current status of particle hits storage (i.e. persistence). More...
void	SetPosHitsStorage (bool store)
	Turn on or off the storage (i.e. persistence) of position hits. More...
bool	GetPosHitsStorage ()
	Return current status of particle hits storage (i.e. persistence). More...
void	SetIntHitThreshold (float minEnergy)
	Sets the minimum energy for integrated hits. More...
void	SetPartHitThreshold (float minEnergy)
	Sets the minimum energy for particle hits. More...
void	SetPosHitThreshold (float minEnergy)
	Sets the minimum energy for position hits. More...

Detailed Description

Sensitive detector class for integrated hits.

This sensitive detector takes care of summing up all energy releases inside the sensitive volume it manages, so that a single hit is produced for each single volume with non-zero energy release for each event.

Definition at line 28 of file GGSIntHitSD.h.

Constructor & Destructor Documentation

GGSIntHitSD::GGSIntHitSD

(

G4String

name

)

Constructor.

Parameters

name	The sensitive detector's name.

Definition at line 24 of file GGSIntHitSD.cpp.

                                      :
    G4VSensitiveDetector(name), _intHitCollection(NULL), _timeBins(0), _intHitClass("GGSIntHit"), _partHitClass(
        "GGSPartHit"), _posHitClass("GGSPosHit"), _storePartHits(false), _storePosHits(false), _intHitThreshold { 0. }, _partHitThreshold {
        0. }, _posHitThreshold { 0. }, _currPartHit { nullptr } {
  collectionName.insert(name);
  _messenger = new GGSIntHitSDMessenger(this);

  auto params = name.substr(name.find_first_of('.') + 1); // Remove volume name
  auto secondPointPos = params.find_first_of('.');
  if (secondPointPos != std::string::npos) {
    // Parameters have been specified so let's handle them
    params = params.substr(secondPointPos + 1); // Remove GGSIntHitSD
    if (params.size() > 0) {
      // Retrieve hit classes
      std::string intHitClassName, partHitClassName, posHitClassName;
      auto start = params.find_first_of('[');
      auto end = params.find_first_of(']');
      if (start < std::string::npos && end != std::string::npos) {
        intHitClassName = params.substr(start + 1, end - start - 1);
      }
      else {
        throw std::runtime_error(
            std::string("[GGSIntHitSD::GGSIntHitSD] Missing definition of custom integrated hit class in \"") + params
                + ("\""));
      }

      start = params.find_first_of('[', end + 1);
      end = params.find_first_of(']', start + 1);
      if (start != std::string::npos && end != std::string::npos) {
        partHitClassName = params.substr(start + 1, end - start - 1);
      }
      else {
        throw std::runtime_error(
            std::string("[GGSIntHitSD::GGSIntHitSD] Missing definition of custom particle hit class in \"") + params
                + ("\""));
      }

      start = params.find_first_of('[', end + 1);
      end = params.find_first_of(']', start + 1);
      if (start != std::string::npos && end != std::string::npos) {
        posHitClassName = params.substr(start + 1, end - start - 1);
      }
      else {
        throw std::runtime_error(
            std::string("[GGSIntHitSD::GGSIntHitSD] Missing definition of custom position hit class in \"") + params
                + ("\""));
      }

      if (intHitClassName.size() > 0) {
        auto &buildersList = GGSIntHitFactory::GetInstance().GetListOfRegisteredBuilders();
        if (std::find(buildersList.begin(), buildersList.end(), intHitClassName) == buildersList.end()) {
          throw std::runtime_error(
              std::string("[GGSIntHitSD::GGSIntHitSD] Integrated hit class \"") + intHitClassName + "\" not found.");
        }
        _intHitClass = intHitClassName;
      }
      if (partHitClassName.size() > 0) {
        auto &buildersList = GGSPartHitFactory::GetInstance().GetListOfRegisteredBuilders();
        if (std::find(buildersList.begin(), buildersList.end(), partHitClassName) == buildersList.end()) {
          throw std::runtime_error(
              std::string("[GGSIntHitSD::GGSIntHitSD] Particle hit class \"") + partHitClassName + "\" not found.");
        }
        _partHitClass = partHitClassName;
      }
      if (posHitClassName.size() > 0) {
        auto &buildersList = GGSPosHitFactory::GetInstance().GetListOfRegisteredBuilders();
        if (std::find(buildersList.begin(), buildersList.end(), posHitClassName) == buildersList.end()) {
          throw std::runtime_error(
              std::string("[GGSIntHitSD::GGSIntHitSD] Position hit class \"") + posHitClassName + "\" not found.");
        }
        _posHitClass = posHitClassName;
      }
    }
  }
}

Member Function Documentation

void GGSIntHitSD::EndOfEvent

(

G4HCofThisEvent *

hitCollection

)

Sets the hits collection, as required by specifications of mother class.

Parameters

hitCollection

The hits collection.

Definition at line 268 of file GGSIntHitSD.cpp.

                                                           {

  G4int IHID = G4SDManager::GetSDMpointer()->GetCollectionID(collectionName[0]);
  hitCollection->AddHitsCollection(IHID, _intHitCollection);

}

bool GGSIntHitSD::GetPartHitsStorage ( )

inline

Return current status of particle hits storage (i.e. persistence).

Returns

true if particle hits are going to be stored.

Definition at line 110 of file GGSIntHitSD.h.

                            {
    return _storePartHits;
  }

bool GGSIntHitSD::GetPosHitsStorage ( )

inline

Return current status of particle hits storage (i.e. persistence).

Returns

true if particle hits are going to be stored.

Definition at line 137 of file GGSIntHitSD.h.

                           {
    return _storePosHits;
  }

const std::vector<G4double>& GGSIntHitSD::GetTimeBins ( )

inline

Time bins getter.

First element is the end time of first bin (which always starts at t=0). Last element is the ending time of last bin but one, which corresponds to start time of last bin (last bin always ends at the end of event).

Returns

Vector of time bins.

Definition at line 83 of file GGSIntHitSD.h.

                                           {
    return _timeBins;
  }

void GGSIntHitSD::Initialize

(

G4HCofThisEvent *

hitCollection

)

Initializes the sensitive detector.

Parameters

hitCollection

Unused (needed by the interface).

Definition at line 108 of file GGSIntHitSD.cpp.

                                             {

  // The hits collection is added to G4HCofThisEvent in EndOfEvent.
  // It is automatically deleted at the end of the event so it must be recreated every time.
  // However, G4Allocator should provide fast memory allocation for this purpose.
  _intHitCollection = new GGSIntHitsCollection(SensitiveDetectorName, collectionName[0]);
}

G4bool GGSIntHitSD::ProcessHits	(	G4Step *	aStep,
		G4TouchableHistory *	ROHist
	)

The hit processing method.

For each physical sensitive volume, this method sums up the total energy release during this step to the total releases of previous steps.

Parameters

aStep	The current step
ROHist	Unused (needed by the interface).

Returns

true if energy deposit of current step is greater than 0.

Definition at line 118 of file GGSIntHitSD.cpp.

                                                                  {

  // The G4TouchableHistory argument of this method is non-null only if a readout geometry has been
  // defined. Since this feature is not supported, it is currently always null.
  // TODO: investigate the possibility to define a readout geometry

  if (aStep->GetTotalEnergyDeposit() == 0. && !_storePartHits)
    return false;

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

  // 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
  static boost::unordered_map<G4VPhysicalVolume*, int> multMap;

  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
        boost::unordered_map<G4VPhysicalVolume*, int>::iterator 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;

    }
  }

  /* *** Add step to integrated hit *** */
  GGSIntHit *intHit = nullptr;
  bool intFound = false;
  // Search for existing integrated hit for this volume
  for (int iHit = 0; iHit < _intHitCollection->entries(); iHit++) {
    intHit = (*(_intHitCollection))[iHit];
    if (physVol == intHit->GetVolume() && touchableID == intHit->GetID() && volPos == intHit->GetAbsTranslation()) {
      intFound = true;
      break;
    }
  }
  if (!intFound) {
    // If we reach this point, then this is a new hit
    intHit = GGSIntHitFactory::GetInstance().CreateObject(_intHitClass, _timeBins).release();
    if (!intHit) {
      throw std::runtime_error(
          std::string("[GGSIntHitSD::ProcessHits] Can't create integrated hit of class ").append(_intHitClass));
    }
    // Set global hit properties
    intHit->SetAbsTranslation(volPos);
    intHit->SetID(touchableID);
    intHit->SetVolume(physVol);
    intHit->SetPartHitsStorage(_storePartHits);
    intHit->SetPosHitsStorage(_storePosHits);
    // Insert the new integrated hit into the hit collection
    _intHitCollection->insert(intHit);
  }
  // Add the current step to the hit
  intHit->AddStep(*aStep);

  if (_storePartHits) {
    /* *** Add step to particle hit *** */
    // Create the particle hit if it does not exists, i.e. on first step inside the sensitive volume.
    // If a particle entered in the volume in previous step and immediately got stopped but not killed then IsFirstStepInVolume
    // for the current step will be true, so check also that kinetic energy is non-zero for pre-step
    if (aStep->IsFirstStepInVolume() && aStep->GetPreStepPoint()->GetKineticEnergy() != 0) {
      if (_currPartHit != nullptr) {
        // On first step there must be no current hit
        throw std::runtime_error("GGSIntHitSD::ProcessHit: existing particle hit on first step in sensitive volume");
      }
      _currPartHit = GGSPartHitFactory::GetInstance().CreateObject(_partHitClass).release();
      // Set global hit properties
      _currPartHit->SetPosHitsStorage(_storePosHits);
    }
    // Add the current step to the hit
    _currPartHit->AddStep(*aStep);

    // Check if this is the last step in the volume
    // Do not use aStep->IsLastStepInVolume(); see https://geant4-forum.web.cern.ch/t/last-step-in-a-volume/856
    if ((aStep->GetPostStepPoint()->GetStepStatus() == G4StepStatus::fGeomBoundary
        && aStep->GetTrack()->GetTrackStatus() != G4TrackStatus::fStopButAlive)
        || aStep->GetTrack()->GetTrackStatus() == G4TrackStatus::fStopAndKill
        || aStep->GetTrack()->GetTrackStatus() == G4TrackStatus::fKillTrackAndSecondaries) {
      if (_currPartHit->GetEnergyDeposit() > _partHitThreshold) {
        // Hit above threshold: insert it into the hit collection
        intHit->GetPartHits()->insert(_currPartHit);
      }
      else {
        // Hit below threshold: delete it
        delete _currPartHit;
      }
      // Do not point at the hit anymore (at this point, it's either stored in the collection or deleted)
      _currPartHit = nullptr;
    }

    if (_storePosHits && aStep->GetTotalEnergyDeposit() > _posHitThreshold) {
      /* *** Create position hit for current step *** */
      GGSPosHit *posHit = GGSPosHitFactory::GetInstance().CreateObject(_posHitClass).release();
      if (!posHit) {
        throw std::runtime_error(
            std::string("[GGSIntHitSD::ProcessHits] Can't create position hit of class ").append(_posHitClass));
      }
      // Insert the new position hit into the hit collection
      auto *partHit = (_currPartHit ? _currPartHit : (*(intHit->GetPartHits()))[intHit->GetPartHits()->GetSize() - 1]);
      partHit->GetPosHits()->insert(posHit);
      // Set members of the position hit
      posHit->SetStep(*aStep);
    }
  }

  return true;
}

void GGSIntHitSD::SetIntHitThreshold ( float  minEnergy )

inline

Sets the minimum energy for integrated hits.

Hits below this threshold will be removed from the hits array.

Parameters

minEnergy

The minimum energy for integrated hits.

Definition at line 147 of file GGSIntHitSD.h.

                                          {
    _intHitThreshold = minEnergy;
  }

void GGSIntHitSD::SetPartHitsStorage ( bool  store )

inline

Turn on or off the storage (i.e. persistency) of particle hits.

This method tells to the SD whether to activate the storage of particle hits or not. By default, storage is not activated.

Calling this method with "false" parameter will automatically disable position hits storage, i.e., it will call SetPartsHitStorage(false).

Parameters

store

if true, steps will be stored as position hits.

See Also

SetPosHitsStorage

GGSIntHit::SetPosHitsStorage

Definition at line 99 of file GGSIntHitSD.h.

                                      {
    _storePartHits = store;
    if (store == false) {
      SetPosHitsStorage(false);
    }
  }

void GGSIntHitSD::SetPartHitThreshold ( float  minEnergy )

inline

Sets the minimum energy for particle hits.

Hits below this threshold will be removed from the hits array.

Parameters

minEnergy

The minimum energy for particle hits.

Definition at line 157 of file GGSIntHitSD.h.

                                           {
    _partHitThreshold = minEnergy;
  }

void GGSIntHitSD::SetPosHitsStorage ( bool  store )

inline

Turn on or off the storage (i.e. persistence) of position hits.

This method tells to the SD whether to activate the storage of position hits or not. By default, storage is not activated.

Calling this method with "true" parameter will automatically enable particle hits storage, i.e., it will call SetPartHitsStorage(true).

Parameters

store

if true, steps will be stored as position hits.

See Also

SetPartHitsStorage

GGSIntHit::SetPosHitsStorage

Definition at line 126 of file GGSIntHitSD.h.

                                     {
    _storePosHits = store;
    if (store == true) {
      SetPartHitsStorage(true);
    }
  }

void GGSIntHitSD::SetPosHitThreshold ( float  minEnergy )

inline

Sets the minimum energy for position hits.

Hits below this threshold will be removed from the hits array.

Parameters

minEnergy

The minimum energy for position hits.

Definition at line 168 of file GGSIntHitSD.h.

                                          {
    _posHitThreshold = minEnergy;
  }

void GGSIntHitSD::SetTimeBin ( G4double  time )

inline

Time bins setter.

This method adds a division in the timeline, effectively adding a time bin.

Parameters

time	The time of first energy deposit.

Definition at line 70 of file GGSIntHitSD.h.

                                 {
    _timeBins.push_back(time);
    std::sort(_timeBins.begin(), _timeBins.end());
  }

---

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

• GGSIntHitSD.h
• GGSIntHitSD.cpp