SensitiveDetector.cc

Go to the documentation of this file.

#include "SimG4Core/SensitiveDetector/interface/SensitiveDetector.h"
 
#include "SimG4Core/Notification/interface/SimG4Exception.h"
#include "FWCore/Utilities/interface/isFinite.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
 
#include "G4SDManager.hh"
#include "G4Step.hh"
#include "G4Track.hh"
#include "G4StepPoint.hh"
#include "G4Transform3D.hh"
#include "G4LogicalVolumeStore.hh"
#include "G4TouchableHistory.hh"
#include "G4VUserTrackInformation.hh"
 
#include <sstream>
 
SensitiveDetector::SensitiveDetector(const std::string& iname, const SensitiveDetectorCatalog& clg, bool calo)
    : G4VSensitiveDetector(iname), m_isCalo(calo) {
  // for CMS hits
  m_namesOfSD.push_back(iname);
 
  // Geant4 hit collection
  collectionName.insert(iname);
 
  // register sensitive detector
  G4SDManager* SDman = G4SDManager::GetSDMpointer();
  SDman->AddNewDetector(this);
 
  const std::vector<std::string_view>& lvNames = clg.logicalNames(iname);
  std::stringstream ss;
  for (auto& lvname : lvNames) {
    this->AssignSD({lvname.data(), lvname.size()});
    ss << " " << lvname;
  }
  edm::LogVerbatim("SensitiveDetector") << " <" << iname << "> : Assigns SD to LVs " << ss.str();
}
 
SensitiveDetector::~SensitiveDetector() {}
 
void SensitiveDetector::Initialize(G4HCofThisEvent* eventHC) {}
 
void SensitiveDetector::EndOfEvent(G4HCofThisEvent* eventHC) {}
 
void SensitiveDetector::AssignSD(const std::string& vname) {
  G4LogicalVolumeStore* theStore = G4LogicalVolumeStore::GetInstance();
  for (auto& lv : *theStore) {
    if (vname == lv->GetName()) {
      lv->SetSensitiveDetector(this);
    }
  }
}
 
Local3DPoint SensitiveDetector::InitialStepPosition(const G4Step* step, coordinates cd) const {
  const G4StepPoint* preStepPoint = step->GetPreStepPoint();
  const G4ThreeVector& globalCoordinates = preStepPoint->GetPosition();
  if (cd == WorldCoordinates) {
    return ConvertToLocal3DPoint(globalCoordinates);
  }
  const G4TouchableHistory* theTouchable = static_cast<const G4TouchableHistory*>(preStepPoint->GetTouchable());
  const G4ThreeVector localCoordinates =
      theTouchable->GetHistory()->GetTopTransform().TransformPoint(globalCoordinates);
  return ConvertToLocal3DPoint(localCoordinates);
}
 
Local3DPoint SensitiveDetector::FinalStepPosition(const G4Step* step, coordinates cd) const {
  const G4StepPoint* postStepPoint = step->GetPostStepPoint();
  const G4ThreeVector& globalCoordinates = postStepPoint->GetPosition();
  if (cd == WorldCoordinates) {
    return ConvertToLocal3DPoint(globalCoordinates);
  }
  const G4StepPoint* preStepPoint = step->GetPreStepPoint();
  const G4ThreeVector localCoordinates =
      preStepPoint->GetTouchable()->GetHistory()->GetTopTransform().TransformPoint(globalCoordinates);
  return ConvertToLocal3DPoint(localCoordinates);
}
 
Local3DPoint SensitiveDetector::LocalPreStepPosition(const G4Step* step) const {
  const G4StepPoint* preStepPoint = step->GetPreStepPoint();
  G4ThreeVector localCoordinates =
      preStepPoint->GetTouchable()->GetHistory()->GetTopTransform().TransformPoint(preStepPoint->GetPosition());
  return ConvertToLocal3DPoint(localCoordinates);
}
 
Local3DPoint SensitiveDetector::LocalPostStepPosition(const G4Step* step) const {
  const G4ThreeVector& globalCoordinates = step->GetPostStepPoint()->GetPosition();
  G4ThreeVector localCoordinates =
      step->GetPreStepPoint()->GetTouchable()->GetHistory()->GetTopTransform().TransformPoint(globalCoordinates);
  return ConvertToLocal3DPoint(localCoordinates);
}
 
TrackInformation* SensitiveDetector::cmsTrackInformation(const G4Track* aTrack) {
  TrackInformation* info = (TrackInformation*)(aTrack->GetUserInformation());
  if (!info) {
    edm::LogWarning("SensitiveDetector") << " no TrackInformation available for trackID= " << aTrack->GetTrackID();
    throw SimG4Exception("SimG4CoreSensitiveDetector: cannot handle hits for " + GetName());
  }
  return info;
}
 
void SensitiveDetector::setNames(const std::vector<std::string>& hnames) {
  m_namesOfSD.clear();
  m_namesOfSD = hnames;
}
 
void SensitiveDetector::NaNTrap(const G4Step* aStep) const {
  const G4Track* CurrentTrk = aStep->GetTrack();
  const G4ThreeVector& CurrentPos = CurrentTrk->GetPosition();
  double xyz = CurrentPos.x() + CurrentPos.y() + CurrentPos.z();
  const G4ThreeVector& CurrentMom = CurrentTrk->GetMomentum();
  xyz += CurrentMom.x() + CurrentMom.y() + CurrentMom.z();
 
  if (edm::isNotFinite(xyz)) {
    const G4VPhysicalVolume* pCurrentVol = aStep->GetPreStepPoint()->GetPhysicalVolume();
    const G4String& NameOfVol = pCurrentVol->GetName();
    throw SimG4Exception("SimG4CoreSensitiveDetector: Corrupted Event - NaN detected in volume " + NameOfVol);
  }
}