TimingSD.h

Go to the documentation of this file.

#ifndef Forward_TimingSD_h
#define Forward_TimingSD_h
//
// Base sensitive class for timing detectors and sensors
//
// Created 17 June 2018 V.Ivantchenko
//
 
#include "SimG4Core/Notification/interface/Observer.h"
#include "SimG4Core/SensitiveDetector/interface/SensitiveTkDetector.h"
 
#include "SimG4Core/Notification/interface/BeginOfEvent.h"
 
#include "SimG4CMS/Forward/interface/BscG4Hit.h"
#include "SimG4CMS/Forward/interface/BscG4HitCollection.h"
 
#include <string>
 
class G4Step;
class G4StepPoint;
class G4Track;
class G4VPhysicalVolume;
class TrackingSlaveSD;
class SimTrackManager;
class G4ProcessTypeEnumerator;
 
//-------------------------------------------------------------------
 
class TimingSD : public SensitiveTkDetector, public Observer<const BeginOfEvent*> {
public:
  TimingSD(const std::string&,
           const edm::EventSetup&,
           const SensitiveDetectorCatalog&,
           const edm::ParameterSet&,
           const SimTrackManager*);
 
  ~TimingSD() override;
 
  bool ProcessHits(G4Step*, G4TouchableHistory*) override;
 
  void Initialize(G4HCofThisEvent* HCE) override;
  void EndOfEvent(G4HCofThisEvent* eventHC) override;
  void PrintAll() override;
 
  void fillHits(edm::PSimHitContainer&, const std::string&) override;
  void clearHits() override;
 
protected:
  void update(const BeginOfEvent*) override;
 
  // define time slices
  void setTimeFactor(double);
 
  // define MC truth thresholds
  void setCuts(double eCut, double historyCut);
 
  // by default accumulate hit for the same detector
  // and time slice, use primary information for fastest
  // Geant4 particle, check if for this detector new
  // hit can be merged with the existing one
  virtual bool checkHit(const G4Step*, BscG4Hit*);
 
  void setToLocal(const G4StepPoint* stepPoint, const G4ThreeVector& globalPoint, G4ThreeVector& localPoint);
 
  // accessors
  const G4ThreeVector& getLocalEntryPoint() const { return hitPointLocal; };
  const G4ThreeVector& getGlobalEntryPoint() const { return hitPoint; };
 
private:
  void getStepInfo(const G4Step*);
  bool hitExists(const G4Step*);
  void createNewHit(const G4Step*);
  void updateHit();
  void storeHit(BscG4Hit*);
 
  TrackingSlaveSD* slave;
  G4ProcessTypeEnumerator* theEnumerator;
 
  const SimTrackManager* theManager;
  BscG4HitCollection* theHC;
 
  BscG4Hit* currentHit;
  const G4Track* theTrack;
  const G4StepPoint* preStepPoint;
  const G4StepPoint* postStepPoint;
 
  uint32_t unitID, previousUnitID;
 
  int primID;
  int hcID;
  int tsID;
  int primaryID;
  int tSliceID;
 
  G4ThreeVector hitPoint;
  G4ThreeVector hitPointExit;
  G4ThreeVector hitPointLocal;
  G4ThreeVector hitPointLocalExit;
 
  double tSlice;
  double timeFactor;
 
  double energyCut;         // MeV
  double energyHistoryCut;  // MeV
 
  double incidentEnergy;  // MeV
  float tof;              // ns
  float edeposit;
  float edepositEM, edepositHAD;
};
 
#endif