Merge pull request #32978 from swagata87/egmhlt_ph2_timing_113X

Seed TICL by L1 e/gamma + other timing considerations for e/gamma HLT

RecoEgamma/EgammaHLTProducers/plugins/HLTCaloObjInRegionsProducer.cc

@@ -331,3 +331,16 @@ DEFINE_FWK_MODULE(HLTEcalRecHitsInRegionsProducer);
 #include "DataFormats/EcalRecHit/interface/EcalUncalibratedRecHit.h"
 using HLTEcalUnCalibRecHitsInRegionsProducer = HLTCaloObjInRegionsProducer<EcalUncalibratedRecHit>;
 DEFINE_FWK_MODULE(HLTEcalUnCalibRecHitsInRegionsProducer);
+
+// HGCAL Digis
+#include "DataFormats/HGCDigi/interface/HGCDigiCollections.h"
+using HLTHGCalDigisInRegionsProducer = HLTCaloObjInRegionsProducer<HGCalDataFrame, HGCalDigiCollection>;
+DEFINE_FWK_MODULE(HLTHGCalDigisInRegionsProducer);
+
+// HGCAL RecHits
+#include "DataFormats/HGCRecHit/interface/HGCRecHit.h"
+using HLTHGCalRecHitsInRegionsProducer = HLTCaloObjInRegionsProducer<HGCRecHit>;
+DEFINE_FWK_MODULE(HLTHGCalRecHitsInRegionsProducer);
+#include "DataFormats/HGCRecHit/interface/HGCUncalibratedRecHit.h"
+using HLTHGCalUncalibratedRecHitsInRegionsProducer = HLTCaloObjInRegionsProducer<HGCUncalibratedRecHit>;
+DEFINE_FWK_MODULE(HLTHGCalUncalibratedRecHitsInRegionsProducer);

RecoEgamma/EgammaHLTProducers/plugins/L1TEGammaFilteredCollectionProducer.cc

@@ -0,0 +1,121 @@
+/*
+  Author: Swagata Mukherjee
+
+  Date: Feb 2021
+
+  At the time of writing this new module, it is intended to be used mainly for
+  phase-2. Before feeding in the L1 e/g collection to
+  HLTEcalRecHitInAllL1RegionsProducer, it can pass through this module which
+  will filter the collection based on hardware quality and pT.
+
+  The most generic L1 e/g phase-2 collections are:
+  TkEm, which is std::vector<l1t::TkEm>
+  &
+  StaEG, which is BXVector<l1t::EGamma>
+
+  Despite this technical difference, the objects are almost identical, for all
+  practical purposes. So any of these two collections could have been used.
+  Currently, BXVector<l1t::EGamma> is recognised by the next step
+  HLTEcalRecHitInAllL1RegionsProducer, while std::vector<l1t::TkEm> is not. So
+  using BXVector<l1t::EGamma> is straightforward. If for some reason one need to
+  use std::vector<l1t::TkEm>, changes in HLTEcalRecHitInAllL1RegionsProducer
+  would also be necesary.
+*/
+
+#include "DataFormats/L1TCorrelator/interface/TkEm.h"
+#include "FWCore/Framework/interface/ESHandle.h"
+#include "FWCore/Framework/interface/Event.h"
+#include "FWCore/Framework/interface/EventSetup.h"
+#include "FWCore/Framework/interface/EventSetupRecord.h"
+#include "FWCore/Framework/interface/Frameworkfwd.h"
+#include "FWCore/Framework/interface/MakerMacros.h"
+#include "FWCore/Framework/interface/global/EDProducer.h"
+#include "FWCore/MessageLogger/interface/MessageLogger.h"
+#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
+
+class L1TEGammaFilteredCollectionProducer : public edm::global::EDProducer<> {
+public:
+  explicit L1TEGammaFilteredCollectionProducer(const edm::ParameterSet&);
+  ~L1TEGammaFilteredCollectionProducer() override;
+  static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
+  void produce(edm::StreamID sid, edm::Event& iEvent, const edm::EventSetup& iSetup) const override;
+
+private:
+  edm::InputTag l1EgTag_;
+  edm::EDGetTokenT<BXVector<l1t::EGamma>> l1EgToken_;
+  int quality_;
+  bool qualIsMask_;
+  bool applyQual_;
+  int minBX_;
+  int maxBX_;
+  double minPt_;
+  std::vector<double> scalings_;  // pT scaling factors
+  double getOfflineEt(double et) const;
+};
+
+L1TEGammaFilteredCollectionProducer::L1TEGammaFilteredCollectionProducer(const edm::ParameterSet& iConfig)
+    : l1EgTag_(iConfig.getParameter<edm::InputTag>("inputTag")), l1EgToken_(consumes<BXVector<l1t::EGamma>>(l1EgTag_)) {
+  quality_ = iConfig.getParameter<int>("quality");
+  qualIsMask_ = iConfig.getParameter<bool>("qualIsMask");
+  applyQual_ = iConfig.getParameter<bool>("applyQual");
+  minBX_ = iConfig.getParameter<int>("minBX");
+  maxBX_ = iConfig.getParameter<int>("maxBX");
+  minPt_ = iConfig.getParameter<double>("minPt");
+  scalings_ = iConfig.getParameter<std::vector<double>>("scalings");
+
+  produces<BXVector<l1t::EGamma>>();
+}
+
+L1TEGammaFilteredCollectionProducer::~L1TEGammaFilteredCollectionProducer() = default;
+
+void L1TEGammaFilteredCollectionProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
+  edm::ParameterSetDescription desc;
+  desc.add<edm::InputTag>("inputTag", edm::InputTag("L1EGammaClusterEmuProducer"));
+  desc.add<int>("quality", 0x2);
+  desc.add<bool>("qualIsMask", true);
+  desc.add<bool>("applyQual", true);
+  desc.add<int>("minBX", -1);
+  desc.add<int>("maxBX", 1);
+  desc.add<double>("minPt", 5.0);
+  desc.add<std::vector<double>>("scalings", {2.6604, 1.06077, 0.0});
+  descriptions.add("L1TEGammaFilteredCollectionProducer", desc);
+}
+
+void L1TEGammaFilteredCollectionProducer::produce(edm::StreamID sid,
+                                                  edm::Event& iEvent,
+                                                  const edm::EventSetup& iSetup) const {
+  auto outEgs = std::make_unique<BXVector<l1t::EGamma>>();
+  auto l1Egs = iEvent.getHandle(l1EgToken_);
+
+  int startBX = std::max((*l1Egs).getFirstBX(), minBX_);
+  int endBX = std::min((*l1Egs).getLastBX(), maxBX_);
+
+  for (int bx = startBX; bx <= endBX; bx++) {
+    // Loop over all L1 e/gamma objects
+    for (BXVector<l1t::EGamma>::const_iterator iEg = (*l1Egs).begin(bx); iEg != (*l1Egs).end(bx); iEg++) {
+      double offlineEt = this->getOfflineEt((*iEg).pt());
+      bool passQuality(false);
+      if (applyQual_) {
+        if (qualIsMask_)
+          passQuality = ((*iEg).hwQual() & quality_);
+        else
+          passQuality = ((*iEg).hwQual() == quality_);
+      } else
+        passQuality = true;
+
+      // if quality is passed, put the object in filtered collection
+      if (passQuality && (offlineEt > minPt_)) {
+        outEgs->push_back(bx, *iEg);
+      }
+    }  // l1EG loop ends
+  }    // BX loop ends
+  iEvent.put(std::move(outEgs));
+}
+
+double L1TEGammaFilteredCollectionProducer::getOfflineEt(double et) const {
+  return (scalings_.at(0) + et * scalings_.at(1) + et * et * scalings_.at(2));
+}
+
+DEFINE_FWK_MODULE(L1TEGammaFilteredCollectionProducer);

RecoHGCal/TICL/plugins/BuildFile.xml

@@ -5,6 +5,8 @@
 <use name="FWCore/ParameterSet"/>
 <use name="FWCore/PluginManager"/>
 <use name="DataFormats/CaloRecHit"/>
+<use name="DataFormats/L1Trigger"/>
+<use name="DataFormats/Candidate"/>
 <use name="DataFormats/ParticleFlowCandidate"/>
 <use name="DataFormats/HGCalReco"/>
 <use name="FWCore/MessageLogger"/>

RecoHGCal/TICL/plugins/SeedingRegionAlgoBase.h

@@ -9,6 +9,7 @@
 #include <vector>
 #include "DataFormats/HGCalReco/interface/Common.h"
 #include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
 #include "DataFormats/HGCalReco/interface/TICLSeedingRegion.h"
 #include "FWCore/Framework/interface/ConsumesCollector.h"
 
@@ -30,6 +31,8 @@ namespace ticl {
                              const edm::EventSetup& es,
                              std::vector<TICLSeedingRegion>& result) = 0;
 
+    static void fillPSetDescription(edm::ParameterSetDescription& desc) { desc.add<int>("algo_verbosity", 0); }
+
     enum VerbosityLevel { None = 0, Basic, Advanced, Expert, Guru };
 
   protected:

RecoHGCal/TICL/plugins/SeedingRegionAlgoFactory.cc

@@ -0,0 +1,12 @@
+#include "FWCore/ParameterSet/interface/ValidatedPluginFactoryMacros.h"
+#include "FWCore/ParameterSet/interface/ValidatedPluginMacros.h"
+#include "SeedingRegionAlgoFactory.h"
+#include "SeedingRegionByTracks.h"
+#include "SeedingRegionGlobal.h"
+#include "SeedingRegionByL1.h"
+
+EDM_REGISTER_VALIDATED_PLUGINFACTORY(SeedingRegionAlgoFactory, "SeedingRegionAlgoFactory");
+
+DEFINE_EDM_VALIDATED_PLUGIN(SeedingRegionAlgoFactory, ticl::SeedingRegionByTracks, "SeedingRegionByTracks");
+DEFINE_EDM_VALIDATED_PLUGIN(SeedingRegionAlgoFactory, ticl::SeedingRegionGlobal, "SeedingRegionGlobal");
+DEFINE_EDM_VALIDATED_PLUGIN(SeedingRegionAlgoFactory, ticl::SeedingRegionByL1, "SeedingRegionByL1");

RecoHGCal/TICL/plugins/SeedingRegionAlgoFactory.h

@@ -0,0 +1,11 @@
+#ifndef RecoHGCAL_TICL_SeedingRegionAlgoFactory_h
+#define RecoHGCAL_TICL_SeedingRegionAlgoFactory_h
+
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/PluginManager/interface/PluginFactory.h"
+#include "SeedingRegionAlgoBase.h"
+
+using SeedingRegionAlgoFactory =
+    edmplugin::PluginFactory<ticl::SeedingRegionAlgoBase*(const edm::ParameterSet&, edm::ConsumesCollector&)>;
+
+#endif

RecoHGCal/TICL/plugins/SeedingRegionByL1.cc

@@ -0,0 +1,68 @@
+/*
+   Author: Swagata Mukherjee
+
+   Date: Feb 2021
+
+   TICL is currently seeded by tracks, or just globally.
+   Here, adding option to seed TICL by L1 e/gamma objects (L1 TkEm).
+   This is expected to be useful for CPU timing at the HLT.
+*/
+
+#include "SeedingRegionByL1.h"
+
+#include <algorithm>
+#include <set>
+#include <vector>
+
+#include "FWCore/MessageLogger/interface/MessageLogger.h"
+
+ticl::SeedingRegionByL1::SeedingRegionByL1(const edm::ParameterSet &conf, edm::ConsumesCollector &sumes)
+    : SeedingRegionAlgoBase(conf, sumes),
+      l1TkEmsToken_(sumes.consumes<std::vector<l1t::TkEm>>(conf.getParameter<edm::InputTag>("l1TkEmColl"))),
+      algoVerbosity_(conf.getParameter<int>("algo_verbosity")),
+      minPt_(conf.getParameter<double>("minPt")),
+      minAbsEta_(conf.getParameter<double>("minAbsEta")),
+      maxAbsEta_(conf.getParameter<double>("maxAbsEta")),
+      endcapScalings_(conf.getParameter<std::vector<double>>("endcapScalings")),
+      quality_(conf.getParameter<int>("quality")) {}
+
+void ticl::SeedingRegionByL1::makeRegions(const edm::Event &ev,
+                                          const edm::EventSetup &es,
+                                          std::vector<TICLSeedingRegion> &result) {
+  auto l1TrkEms = ev.getHandle(l1TkEmsToken_);
+  edm::ProductID l1tkemsId = l1TrkEms.id();
+
+  for (size_t indx = 0; indx < (*l1TrkEms).size(); indx++) {
+    const auto &l1TrkEm = (*l1TrkEms)[indx];
+    double offlinePt = this->tkEmOfflineEt(l1TrkEm.pt());
+    if ((offlinePt < minPt_) || (std::abs(l1TrkEm.eta()) < minAbsEta_) || (std::abs(l1TrkEm.eta()) > maxAbsEta_) ||
+        (l1TrkEm.EGRef()->hwQual() != quality_)) {
+      continue;
+    }
+
+    int iSide = int(l1TrkEm.eta() > 0);
+    result.emplace_back(GlobalPoint(l1TrkEm.p4().X(), l1TrkEm.p4().Y(), l1TrkEm.p4().Z()),
+                        GlobalVector(l1TrkEm.px(), l1TrkEm.py(), l1TrkEm.pz()),
+                        iSide,
+                        indx,
+                        l1tkemsId);
+  }
+
+  std::sort(result.begin(), result.end(), [](const TICLSeedingRegion &a, const TICLSeedingRegion &b) {
+    return a.directionAtOrigin.perp2() > b.directionAtOrigin.perp2();
+  });
+}
+
+double ticl::SeedingRegionByL1::tkEmOfflineEt(double et) const {
+  return (endcapScalings_.at(0) + et * endcapScalings_.at(1) + et * et * endcapScalings_.at(2));
+}
+
+void ticl::SeedingRegionByL1::fillPSetDescription(edm::ParameterSetDescription &desc) {
+  desc.add<edm::InputTag>("l1TkEmColl", edm::InputTag("L1TkPhotonsHGC", "EG"));
+  desc.add<double>("minPt", 10);
+  desc.add<double>("minAbsEta", 1.479);
+  desc.add<double>("maxAbsEta", 4.0);
+  desc.add<std::vector<double>>("endcapScalings", {3.17445, 1.13219, 0.0});
+  desc.add<int>("quality", 5);
+  SeedingRegionAlgoBase::fillPSetDescription(desc);
+}

RecoHGCal/TICL/plugins/SeedingRegionByL1.h

@@ -0,0 +1,42 @@
+// Author: Swagata Mukherjee
+
+#ifndef RecoHGCal_TICL_SeedingRegionByL1_h
+#define RecoHGCal_TICL_SeedingRegionByL1_h
+#include <memory>
+#include <string>
+
+#include "DataFormats/L1TCorrelator/interface/TkEm.h"
+#include "DataFormats/L1TCorrelator/interface/TkEmFwd.h"
+#include "FWCore/Framework/interface/ConsumesCollector.h"
+#include "FWCore/Framework/interface/ESHandle.h"
+#include "FWCore/Framework/interface/Event.h"
+#include "FWCore/Framework/interface/Frameworkfwd.h"
+#include "FWCore/Framework/interface/MakerMacros.h"
+#include "FWCore/MessageLogger/interface/MessageLogger.h"
+#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
+#include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
+#include "FWCore/Utilities/interface/ESGetToken.h"
+#include "RecoHGCal/TICL/plugins/SeedingRegionAlgoBase.h"
+
+namespace ticl {
+  class SeedingRegionByL1 final : public SeedingRegionAlgoBase {
+  public:
+    SeedingRegionByL1(const edm::ParameterSet& conf, edm::ConsumesCollector& sumes);
+
+    void initialize(const edm::EventSetup& es) override{};
+    void makeRegions(const edm::Event& ev, const edm::EventSetup& es, std::vector<TICLSeedingRegion>& result) override;
+    static void fillPSetDescription(edm::ParameterSetDescription& desc);
+
+  private:
+    edm::EDGetTokenT<std::vector<l1t::TkEm>> l1TkEmsToken_;
+    int algoVerbosity_ = 0;
+    double minPt_;                        // minimum pT of L1 TkEm objects
+    double minAbsEta_;                    // minimum |eta| of L1 TkEm objects
+    double maxAbsEta_;                    // maximum |eta| of L1 TkEm objects
+    std::vector<double> endcapScalings_;  // pT scaling factors for endcap
+    int quality_;                         // hwQual
+
+    double tkEmOfflineEt(double et) const;
+  };
+}  // namespace ticl
+#endif

RecoHGCal/TICL/plugins/SeedingRegionByTracks.cc

@@ -65,6 +65,15 @@ void SeedingRegionByTracks::makeRegions(const edm::Event &ev,
   });
 }
 
+void SeedingRegionByTracks::fillPSetDescription(edm::ParameterSetDescription &desc) {
+  desc.add<edm::InputTag>("tracks", edm::InputTag("generalTracks"));
+  desc.add<std::string>("cutTk",
+                        "1.48 < abs(eta) < 3.0 && pt > 1. && quality(\"highPurity\") && "
+                        "hitPattern().numberOfLostHits(\"MISSING_OUTER_HITS\") < 5");
+  desc.add<std::string>("propagator", "PropagatorWithMaterial");
+  SeedingRegionAlgoBase::fillPSetDescription(desc);
+}
+
 void SeedingRegionByTracks::buildFirstLayers() {
   float zVal = hgcons_->waferZ(1, true);
   std::pair<double, double> rMinMax = hgcons_->rangeR(zVal, true);

RecoHGCal/TICL/plugins/SeedingRegionByTracks.h

@@ -37,6 +37,8 @@ namespace ticl {
 
     void makeRegions(const edm::Event& ev, const edm::EventSetup& es, std::vector<TICLSeedingRegion>& result) override;
 
+    static void fillPSetDescription(edm::ParameterSetDescription& desc);
+
   private:
     void buildFirstLayers();
 

RecoHGCal/TICL/plugins/SeedingRegionGlobal.cc

@@ -26,3 +26,7 @@ void SeedingRegionGlobal::makeRegions(const edm::Event &ev,
     result.emplace_back(GlobalPoint(0., 0., 0.), GlobalVector(0., 0., 0.), i, -1, edm::ProductID());
   }
 }
+
+void SeedingRegionGlobal::fillPSetDescription(edm::ParameterSetDescription &desc) {
+  SeedingRegionAlgoBase::fillPSetDescription(desc);
+}

RecoHGCal/TICL/plugins/SeedingRegionGlobal.h

@@ -25,6 +25,8 @@ namespace ticl {
     void initialize(const edm::EventSetup& es) override{};
 
     void makeRegions(const edm::Event& ev, const edm::EventSetup& es, std::vector<TICLSeedingRegion>& result) override;
+
+    static void fillPSetDescription(edm::ParameterSetDescription& desc);
   };
 }  // namespace ticl
 #endif