SensitiveDetector.h

#ifndef SIMCORE_SENSITIVEDETECTOR_H_
#define SIMCORE_SENSITIVEDETECTOR_H_
 
#include "Framework/Configure/Parameters.h"
#include "Framework/RunHeader.h"
#include "SimCore/ConditionsInterface.h"
#include "SimCore/Factory.h"
#include "SimCore/G4User/TrackingAction.h"
#include "SimCore/TrackMap.h"
 
//------------//
//   Geant4   //
//------------//
#include "G4VSensitiveDetector.hh"
 
namespace simcore {
 
class SensitiveDetector : public G4VSensitiveDetector {
 public:
  SensitiveDetector(const std::string& name, simcore::ConditionsInterface& ci,
                    const framework::config::Parameters& parameters);
 
  using Factory =
      ::simcore::Factory<SensitiveDetector, SensitiveDetector*,
                         const std::string&, simcore::ConditionsInterface&,
                         const framework::config::Parameters&>;
 
  virtual ~SensitiveDetector() = default;
 
  virtual bool isSensDet(G4LogicalVolume* lv) const = 0;
 
  virtual G4bool ProcessHits(G4Step* step,
                             G4TouchableHistory* hist) override = 0;
 
  virtual void saveHits(framework::Event& event) = 0;
 
  virtual void EndOfEvent(G4HCofThisEvent*) override {}
 
  virtual void OnFinishedEvent() = 0;
 
  // virtual void RecordConfig(ldmx::RunHeader& header) const = 0;
 
 protected:
  template <class T>
  const T& getCondition(const std::string& condition_name) {
    return conditions_interface_.getCondition<T>(condition_name);
  }
 
  bool isGeantino(const G4Step* step) const;
 
  const TrackMap& getTrackMap() const {
    return simcore::g4user::TrackingAction::get()->getTrackMap();
  }
 
 private:
  simcore::ConditionsInterface& conditions_interface_;
 
};  // SensitiveDetector
}  // namespace simcore
 
#define DECLARE_SENSITIVEDETECTOR(CLASS)                                  \
  namespace {                                                             \
  auto v = ::simcore::SensitiveDetector::Factory::get().declare<CLASS>(); \
  }
 
#endif  // SIMCORE_SENSITIVEDETECTOR_H_