E/gamma HLT L1 Track Isolation Producer & TTTrack typedef: 11_3_X

DataFormats/L1TrackTrigger/interface/L1Track.h

@@ -0,0 +1,6 @@
+#include "DataFormats/L1TrackTrigger/interface/TTTrack.h"
+#include "DataFormats/L1TrackTrigger/interface/TTTypes.h"
+#include <vector>
+
+using L1Track = TTTrack<Ref_Phase2TrackerDigi_>;
+using L1TrackCollection = std::vector<L1Track>;

RecoEgamma/EgammaHLTProducers/plugins/EgammaHLTEleL1TrackIsolProducer.cc

@@ -0,0 +1,95 @@
+// Author: Sam Harper (RAL/CERN)
+// L1 track isolation producer for the HLT
+// A quick primer on how the E/gamma HLT works w.r.t to ID variables
+// 1. the supercluster is the primary object
+// 2. superclusters get id variables associated to them via association maps keyed
+//    to the supercluster
+// However here we also need to read in electron objects as we need to solve for which
+// GsfTrack associated to the supercluster to use for the isolation
+// The electron producer solves for this and assigns the electron the best GsfTrack
+// which we will use for the vz of the electron
+// One thing which Swagata Mukherjee pointed out is that we have to be careful of
+// is getting a bad GsfTrack with a bad vertex which  will give us a fake vz which then
+// leads to a perfectly isolated electron as that random vz is not a vertex
+
+#include "FWCore/Framework/interface/Frameworkfwd.h"
+#include "FWCore/Framework/interface/Event.h"
+#include "FWCore/Framework/interface/MakerMacros.h"
+#include "FWCore/Framework/interface/global/EDProducer.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
+#include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
+
+#include "DataFormats/EgammaCandidates/interface/Electron.h"
+#include "DataFormats/EgammaCandidates/interface/ElectronFwd.h"
+#include "DataFormats/RecoCandidate/interface/RecoEcalCandidate.h"
+#include "DataFormats/RecoCandidate/interface/RecoEcalCandidateFwd.h"
+#include "DataFormats/RecoCandidate/interface/RecoEcalCandidateIsolation.h"
+#include "DataFormats/TrackReco/interface/TrackFwd.h"
+#include "DataFormats/TrackReco/interface/Track.h"
+
+#include "RecoEgamma/EgammaIsolationAlgos/interface/EgammaL1TkIsolation.h"
+
+#include <memory>
+
+class EgammaHLTEleL1TrackIsolProducer : public edm::global::EDProducer<> {
+public:
+  explicit EgammaHLTEleL1TrackIsolProducer(const edm::ParameterSet&);
+  ~EgammaHLTEleL1TrackIsolProducer() override;
+  void produce(edm::StreamID sid, edm::Event&, const edm::EventSetup&) const override;
+  static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
+
+private:
+  const edm::EDGetTokenT<reco::RecoEcalCandidateCollection> ecalCandsToken_;
+  const edm::EDGetTokenT<reco::ElectronCollection> elesToken_;
+  const edm::EDGetTokenT<L1TrackCollection> l1TrksToken_;
+  EgammaL1TkIsolation isolAlgo_;
+};
+
+EgammaHLTEleL1TrackIsolProducer::EgammaHLTEleL1TrackIsolProducer(const edm::ParameterSet& config)
+    : ecalCandsToken_(consumes<reco::RecoEcalCandidateCollection>(config.getParameter<edm::InputTag>("ecalCands"))),
+      elesToken_(consumes<reco::ElectronCollection>(config.getParameter<edm::InputTag>("eles"))),
+      l1TrksToken_(consumes<L1TrackCollection>(config.getParameter<edm::InputTag>("l1Tracks"))),
+      isolAlgo_(config.getParameter<edm::ParameterSet>("isolCfg")) {
+  produces<reco::RecoEcalCandidateIsolationMap>();
+}
+
+EgammaHLTEleL1TrackIsolProducer::~EgammaHLTEleL1TrackIsolProducer() {}
+
+void EgammaHLTEleL1TrackIsolProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
+  edm::ParameterSetDescription desc;
+  desc.add<edm::InputTag>("ecalCands", edm::InputTag("hltEgammaCandidates"));
+  desc.add<edm::InputTag>("eles", edm::InputTag("hltEgammaGsfElectrons"));
+  desc.add<edm::InputTag>("l1Tracks", edm::InputTag("TTTracksFromTrackletEmulation", "Level1TTTracks"));
+  desc.add("isolCfg", EgammaL1TkIsolation::pSetDescript());
+  descriptions.add("hltEgammaHLTEleL1TrackIsolProducer", desc);
+}
+void EgammaHLTEleL1TrackIsolProducer::produce(edm::StreamID sid,
+                                              edm::Event& iEvent,
+                                              const edm::EventSetup& iSetup) const {
+  auto ecalCands = iEvent.getHandle(ecalCandsToken_);
+  auto eles = iEvent.getHandle(elesToken_);
+  auto l1Trks = iEvent.getHandle(l1TrksToken_);
+
+  auto recoEcalCandMap = std::make_unique<reco::RecoEcalCandidateIsolationMap>(ecalCands);
+
+  for (size_t candNr = 0; candNr < ecalCands->size(); candNr++) {
+    reco::RecoEcalCandidateRef recoEcalCandRef(ecalCands, candNr);
+    reco::ElectronRef eleRef;
+    for (size_t eleNr = 0; eleNr < eles->size(); eleNr++) {
+      if ((*eles)[eleNr].superCluster() == recoEcalCandRef->superCluster()) {
+        eleRef = reco::ElectronRef(eles, eleNr);
+        break;
+      }
+    }
+
+    float isol =
+        eleRef.isNonnull() ? isolAlgo_.calIsol(*eleRef->gsfTrack(), *l1Trks).second : std::numeric_limits<float>::max();
+
+    recoEcalCandMap->insert(recoEcalCandRef, isol);
+  }
+  iEvent.put(std::move(recoEcalCandMap));
+}
+
+#include "FWCore/Framework/interface/MakerMacros.h"
+DEFINE_FWK_MODULE(EgammaHLTEleL1TrackIsolProducer);

RecoEgamma/EgammaIsolationAlgos/interface/EgammaL1TkIsolation.h

@@ -0,0 +1,58 @@
+#ifndef RECOEGAMMA_EGAMMAISOLATIONALGOS_EGAMMAL1TKISOLATION_H
+#define RECOEGAMMA_EGAMMAISOLATIONALGOS_EGAMMAL1TKISOLATION_H
+
+#include "DataFormats/L1TrackTrigger/interface/L1Track.h"
+#include "DataFormats/TrackReco/interface/TrackBase.h"
+#include "DataFormats/TrackReco/interface/TrackFwd.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
+
+//author S. Harper (RAL/CERN)
+//based on the work of Swagata Mukherjee and Giulia Sorrentino
+
+class EgammaL1TkIsolation {
+public:
+private:
+  struct TrkCuts {
+    float minPt;
+    float minDR2;
+    float maxDR2;
+    float minDEta;
+    float maxDZ;
+    explicit TrkCuts(const edm::ParameterSet& para);
+    static edm::ParameterSetDescription pSetDescript();
+  };
+
+  TrkCuts barrelCuts_, endcapCuts_;
+
+public:
+  explicit EgammaL1TkIsolation(const edm::ParameterSet& para);
+  EgammaL1TkIsolation(const EgammaL1TkIsolation&) = default;
+  ~EgammaL1TkIsolation() = default;
+  EgammaL1TkIsolation& operator=(const EgammaL1TkIsolation&) = default;
+
+  static edm::ParameterSetDescription pSetDescript();
+
+  std::pair<int, double> calIsol(const reco::TrackBase& trk, const L1TrackCollection& l1Tks) const;
+
+  std::pair<int, double> calIsol(const double objEta,
+                                 const double objPhi,
+                                 const double objZ,
+                                 const L1TrackCollection& l1Tks) const;
+
+  //little helper function for the two calIsol functions for it to directly return the pt
+  template <typename... Args>
+  double calIsolPt(Args&&... args) const {
+    return calIsol(std::forward<Args>(args)...).second;
+  }
+
+private:
+  static bool passTrkSel(const L1Track& trk,
+                         const double trkPt,
+                         const TrkCuts& cuts,
+                         const double objEta,
+                         const double objPhi,
+                         const double objZ);
+};
+
+#endif

RecoEgamma/EgammaIsolationAlgos/src/EgammaL1TkIsolation.cc

@@ -0,0 +1,72 @@
+#include "RecoEgamma/EgammaIsolationAlgos/interface/EgammaL1TkIsolation.h"
+#include "DataFormats/TrackReco/interface/Track.h"
+#include "DataFormats/Math/interface/deltaR.h"
+
+EgammaL1TkIsolation::TrkCuts::TrkCuts(const edm::ParameterSet& para) {
+  minPt = para.getParameter<double>("minPt");
+  auto sq = [](double val) { return val * val; };
+  minDR2 = sq(para.getParameter<double>("minDR"));
+  maxDR2 = sq(para.getParameter<double>("maxDR"));
+  minDEta = para.getParameter<double>("minDEta");
+  maxDZ = para.getParameter<double>("maxDZ");
+}
+
+edm::ParameterSetDescription EgammaL1TkIsolation::TrkCuts::pSetDescript() {
+  edm::ParameterSetDescription desc;
+  desc.add<double>("minPt", 2.0);
+  desc.add<double>("maxDR", 0.3);
+  desc.add<double>("minDR", 0.01);
+  desc.add<double>("minDEta", 0.003);
+  desc.add<double>("maxDZ", 0.7);
+  return desc;
+}
+
+EgammaL1TkIsolation::EgammaL1TkIsolation(const edm::ParameterSet& para)
+    : barrelCuts_(para.getParameter<edm::ParameterSet>("barrelCuts")),
+      endcapCuts_(para.getParameter<edm::ParameterSet>("endcapCuts")) {}
+
+edm::ParameterSetDescription EgammaL1TkIsolation::pSetDescript() {
+  edm::ParameterSetDescription desc;
+  desc.add("barrelCuts", TrkCuts::pSetDescript());
+  desc.add("endcapCuts", TrkCuts::pSetDescript());
+  return desc;
+}
+
+std::pair<int, double> EgammaL1TkIsolation::calIsol(const reco::TrackBase& trk, const L1TrackCollection& tracks) const {
+  return calIsol(trk.eta(), trk.phi(), trk.vz(), tracks);
+}
+
+std::pair<int, double> EgammaL1TkIsolation::calIsol(const double objEta,
+                                                    const double objPhi,
+                                                    const double objZ,
+                                                    const L1TrackCollection& tracks) const {
+  double ptSum = 0.;
+  int nrTrks = 0;
+
+  const TrkCuts& cuts = std::abs(objEta) < 1.5 ? barrelCuts_ : endcapCuts_;
+
+  for (auto& trk : tracks) {
+    const float trkPt = trk.momentum().perp();
+    if (passTrkSel(trk, trkPt, cuts, objEta, objPhi, objZ)) {
+      ptSum += trkPt;
+      nrTrks++;
+    }
+  }
+  return {nrTrks, ptSum};
+}
+
+bool EgammaL1TkIsolation::passTrkSel(const L1Track& trk,
+                                     const double trkPt,
+                                     const TrkCuts& cuts,
+                                     const double objEta,
+                                     const double objPhi,
+                                     const double objZ) {
+  if (trkPt > cuts.minPt && std::abs(objZ - trk.z0()) < cuts.maxDZ) {
+    const float trkEta = trk.eta();
+    const float dEta = trkEta - objEta;
+    const float dR2 = reco::deltaR2(objEta, objPhi, trkEta, trk.phi());
+    return dR2 >= cuts.minDR2 && dR2 <= cuts.maxDR2 && std::abs(dEta) >= cuts.minDEta;
+  }
+
+  return false;
+}