SensitiveDetector.h

#ifndef SIMCORE_SENSITIVEDETECTOR_H_
#define SIMCORE_SENSITIVEDETECTOR_H_
 
#include "Framework/Configure/Parameters.h"
#include "Framework/Factory.h"
#include "Framework/Logger.h"
#include "Framework/RunHeader.h"
#include "SimCore/ConditionsInterface.h"
#include "SimCore/G4User/TrackMap.h"
#include "SimCore/G4User/TrackingAction.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);
 
  DECLARE_FACTORY_WITH_WAREHOUSE(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();
  }
 
  enableLogging("SensitiveDetector");
 
 private:
  simcore::ConditionsInterface& conditions_interface_;
 
};  // SensitiveDetector
}  // namespace simcore
 
#define DECLARE_SENSITIVEDETECTOR(CLASS) \
  FACTORY_REGISTRATION(simcore::SensitiveDetector, CLASS)
 
#endif  // SIMCORE_SENSITIVEDETECTOR_H_