TrackingRecoDQM.h

#pragma once
 
#include "Framework/Configure/Parameters.h"
#include "Framework/Event.h"
#include "Framework/EventProcessor.h"
#include "SimCore/Event/SimTrackerHit.h"
#include "Tracking/Event/Measurement.h"
#include "Tracking/Event/Track.h"
#include "Tracking/Event/TruthTrack.h"
 
namespace tracking::dqm {
 
enum PIDBins {
  kminus = -4,
  antiproton,
  piminus,
  positron,
  electron,
  piplus,
  proton,
  kplus
};
 
class TrackingRecoDQM : public framework::Analyzer {
 public:
  TrackingRecoDQM(const std::string& name, framework::Process& process)
      : framework::Analyzer(name, process){};
 
  ~TrackingRecoDQM() = default;
 
  void analyze(const framework::Event& event) override;
 
  void TrackMonitoring(const std::vector<ldmx::Track>& tracks,
                       const std::vector<ldmx::Measurement>& measurements,
                       const std::string title, const bool& doDetail,
                       const bool& doTruth);
 
  void EfficiencyPlots(const std::vector<ldmx::Track>& tracks,
                       const std::vector<ldmx::Measurement>& measurements,
                       const std::string& title);
 
  void TrackStateMonitoring(const ldmx::Tracks& tracks,
                            ldmx::TrackStateType ts_type,
                            const std::string& ts_title);
  void configure(framework::config::Parameters& parameters) override;
 
  void onProcessEnd() override;
 
  void sortTracks(const std::vector<ldmx::Track>& tracks,
                  std::vector<ldmx::Track>& uniqueTracks,
                  std::vector<ldmx::Track>& duplicateTracks,
                  std::vector<ldmx::Track>& fakeTracks);
 
 private:
  std::string trackCollection_{"TruthTracks"};
  std::string truthCollection_{"TaggerTruthTracks"};
  std::string measurementCollection_{"DigiTaggerSimHits"};
  std::string sp_pass_name_{""};
 
  std::string title_{"tagger_trk_"};
  double trackProb_cut_{0.5};
  std::string subdetector_{"Tagger"};
  bool doTruthComparison{false};
  bool debug_{false};
  std::vector<std::string> trackStates_;
 
  // Truth Track collection
  std::shared_ptr<ldmx::Tracks> truthTrackCollection_{nullptr};
 
  // Ecal scoring plane hits
  std::shared_ptr<std::vector<ldmx::SimTrackerHit>> ecal_scoring_hits_{nullptr};
 
  // Target  scoring plane hits
  std::shared_ptr<std::vector<ldmx::SimTrackerHit>> target_scoring_hits_{
      nullptr};
 
  // If I have truth information, sort the tracks vector according to their
  // trackID and truthProb
  // real tracks (truth_prob > cut), unique
  std::vector<ldmx::Track> uniqueTracks_;
  // real tracks (truth_prob > cut), duplicated
  std::vector<ldmx::Track> duplicateTracks_;
  // fake tracks (truth_prob < cut)
  std::vector<ldmx::Track> fakeTracks_;
 
  // PID mapping
  std::map<int, int> pidmap;
};
class TrackingRecoDQM : public framework::Analyzer {…};
}  // namespace tracking::dqm