Merge pull request #30883 from PFCal-dev/hgc-tpg-integration-200722

[HGCAL trigger] Updated trigger towers (+minor updates)

L1Trigger/L1THGCal/interface/HGCalProcessorBase.h

@@ -19,11 +19,14 @@ typedef HGCalProcessorBaseT<edm::Handle<l1t::HGCalTriggerCellBxCollection>,
     HGCalConcentratorProcessorBase;
 typedef HGCalProcessorBaseT<edm::Handle<l1t::HGCalTriggerCellBxCollection>, l1t::HGCalClusterBxCollection>
     HGCalBackendLayer1ProcessorBase;
-typedef HGCalProcessorBaseT<edm::Handle<l1t::HGCalClusterBxCollection>, l1t::HGCalMulticlusterBxCollection>
+typedef HGCalProcessorBaseT<edm::Handle<l1t::HGCalClusterBxCollection>,
+                            std::pair<l1t::HGCalMulticlusterBxCollection, l1t::HGCalClusterBxCollection> >
     HGCalBackendLayer2ProcessorBase;
-typedef HGCalProcessorBaseT<edm::Handle<l1t::HGCalTriggerCellBxCollection>, l1t::HGCalTowerMapBxCollection>
+typedef HGCalProcessorBaseT<edm::Handle<l1t::HGCalTriggerSumsBxCollection>, l1t::HGCalTowerMapBxCollection>
     HGCalTowerMapProcessorBase;
-typedef HGCalProcessorBaseT<edm::Handle<l1t::HGCalTowerMapBxCollection>, l1t::HGCalTowerBxCollection>
+typedef HGCalProcessorBaseT<
+    std::pair<edm::Handle<l1t::HGCalTowerMapBxCollection>, edm::Handle<l1t::HGCalClusterBxCollection> >,
+    l1t::HGCalTowerBxCollection>
     HGCalTowerProcessorBase;
 
 #include "FWCore/PluginManager/interface/PluginFactory.h"

L1Trigger/L1THGCal/interface/HGCalProcessorBaseT.h

@@ -18,6 +18,8 @@ class HGCalProcessorBaseT {
 
   void setGeometry(const HGCalTriggerGeometryBase* const geom) { geometry_ = geom; }
 
+  virtual void eventSetup(const edm::EventSetup& es){};
+
   virtual void run(const InputCollection& inputColl, OutputCollection& outColl, const edm::EventSetup& es) = 0;
 
 protected:

L1Trigger/L1THGCal/interface/HGCalTriggerTowerGeometryHelper.h

@@ -13,6 +13,8 @@
 #include "FWCore/ParameterSet/interface/ParameterSet.h"
 #include "DataFormats/L1THGCal/interface/HGCalTowerID.h"
 #include "L1Trigger/L1THGCal/interface/HGCalTriggerTools.h"
+#include "DataFormats/L1THGCal/interface/HGCalTriggerCell.h"
+#include "DataFormats/L1THGCal/interface/HGCalTriggerSums.h"
 
 #include <vector>
 #include <unordered_map>
@@ -32,7 +34,9 @@ class HGCalTriggerTowerGeometryHelper {
 
   const std::vector<l1t::HGCalTowerCoord>& getTowerCoordinates() const;
 
-  unsigned short getTriggerTowerFromTriggerCell(const unsigned tcId, const float& eta, const float& phi) const;
+  unsigned short getTriggerTowerFromEtaPhi(const float& eta, const float& phi) const;
+  unsigned short getTriggerTower(const l1t::HGCalTriggerCell&) const;
+  unsigned short getTriggerTower(const l1t::HGCalTriggerSums&) const;
 
 private:
   std::vector<l1t::HGCalTowerCoord> tower_coords_;

L1Trigger/L1THGCal/interface/backend/HGCalHistoClusteringImpl.h

@@ -32,17 +32,21 @@ class HGCalHistoClusteringImpl {
   void clusterizeHisto(const std::vector<edm::Ptr<l1t::HGCalCluster>>& clustersPtr,
                        const std::vector<std::pair<GlobalPoint, double>>& seedPositionsEnergy,
                        const HGCalTriggerGeometryBase& triggerGeometry,
-                       l1t::HGCalMulticlusterBxCollection& multiclusters) const;
+                       l1t::HGCalMulticlusterBxCollection& multiclusters,
+                       l1t::HGCalClusterBxCollection& rejected_clusters) const;
 
 private:
   enum ClusterAssociationStrategy { NearestNeighbour, EnergySplit };
 
   std::vector<l1t::HGCalMulticluster> clusterSeedMulticluster(
       const std::vector<edm::Ptr<l1t::HGCalCluster>>& clustersPtrs,
-      const std::vector<std::pair<GlobalPoint, double>>& seeds) const;
+      const std::vector<std::pair<GlobalPoint, double>>& seeds,
+      std::vector<l1t::HGCalCluster>& rejected_clusters) const;
 
   void finalizeClusters(std::vector<l1t::HGCalMulticluster>&,
+                        const std::vector<l1t::HGCalCluster>&,
                         l1t::HGCalMulticlusterBxCollection&,
+                        l1t::HGCalClusterBxCollection&,
                         const HGCalTriggerGeometryBase&) const;
 
   double dr_;

L1Trigger/L1THGCal/interface/backend/HGCalTowerMap2DImpl.h

@@ -5,6 +5,7 @@
 #include "FWCore/MessageLogger/interface/MessageLogger.h"
 #include "FWCore/Framework/interface/EventSetup.h"
 
+#include "DataFormats/L1THGCal/interface/HGCalTriggerSums.h"
 #include "DataFormats/L1THGCal/interface/HGCalTriggerCell.h"
 #include "DataFormats/L1THGCal/interface/HGCalTowerMap.h"
 #include "L1Trigger/L1THGCal/interface/HGCalTriggerTools.h"
@@ -16,8 +17,37 @@ class HGCalTowerMap2DImpl {
 
   void resetTowerMaps();
 
-  void buildTowerMap2D(const std::vector<edm::Ptr<l1t::HGCalTriggerCell>>& triggerCellsPtrs,
-                       l1t::HGCalTowerMapBxCollection& towermaps);
+  template <class T>
+  void buildTowerMap2D(const std::vector<edm::Ptr<T>>& ptrs, l1t::HGCalTowerMapBxCollection& towerMaps) {
+    std::unordered_map<int, l1t::HGCalTowerMap> towerMapsTmp = newTowerMaps();
+
+    for (const auto& ptr : ptrs) {
+      if (triggerTools_.isNose(ptr->detId()))
+        continue;
+      unsigned layer = triggerTools_.layerWithOffset(ptr->detId());
+      if (towerMapsTmp.find(layer) == towerMapsTmp.end()) {
+        throw cms::Exception("Out of range")
+            << "HGCalTowerMap2dImpl: Found trigger sum in layer " << layer << " for which there is no tower map\n";
+      }
+      // FIXME: should actually sum the energy not the Et...
+      double calibPt = ptr->pt();
+      if (useLayerWeights_)
+        calibPt = layerWeights_[layer] * ptr->mipPt();
+
+      double etEm = layer <= triggerTools_.lastLayerEE() ? calibPt : 0;
+      double etHad = layer > triggerTools_.lastLayerEE() ? calibPt : 0;
+
+      towerMapsTmp[layer].addEt(towerGeometryHelper_.getTriggerTower(*ptr), etEm, etHad);
+    }
+
+    /* store towerMaps in the persistent collection */
+    towerMaps.resize(0, towerMapsTmp.size());
+    int i = 0;
+    for (const auto& towerMap : towerMapsTmp) {
+      towerMaps.set(0, i, towerMap.second);
+      i++;
+    }
+  }
 
   void eventSetup(const edm::EventSetup& es) {
     triggerTools_.eventSetup(es);

L1Trigger/L1THGCal/plugins/HGCalBackendLayer2Producer.cc

@@ -16,6 +16,7 @@
 #include "L1Trigger/L1THGCal/interface/HGCalProcessorBase.h"
 
 #include <memory>
+#include <utility>
 
 class HGCalBackendLayer2Producer : public edm::stream::EDProducer<> {
 public:
@@ -46,6 +47,7 @@ HGCalBackendLayer2Producer::HGCalBackendLayer2Producer(const edm::ParameterSet&
       HGCalBackendLayer2Factory::get()->create(beProcessorName, beParamConfig)};
 
   produces<l1t::HGCalMulticlusterBxCollection>(backendProcess_->name());
+  produces<l1t::HGCalClusterBxCollection>(backendProcess_->name() + "Unclustered");
 }
 
 void HGCalBackendLayer2Producer::beginRun(const edm::Run& /*run*/, const edm::EventSetup& es) {
@@ -55,14 +57,16 @@ void HGCalBackendLayer2Producer::beginRun(const edm::Run& /*run*/, const edm::Ev
 
 void HGCalBackendLayer2Producer::produce(edm::Event& e, const edm::EventSetup& es) {
   // Output collections
-  auto be_multicluster_output = std::make_unique<l1t::HGCalMulticlusterBxCollection>();
+  std::pair<l1t::HGCalMulticlusterBxCollection, l1t::HGCalClusterBxCollection> be_output;
 
   // Input collections
   edm::Handle<l1t::HGCalClusterBxCollection> trigCluster2DBxColl;
 
   e.getByToken(input_clusters_, trigCluster2DBxColl);
 
-  backendProcess_->run(trigCluster2DBxColl, *be_multicluster_output, es);
+  backendProcess_->run(trigCluster2DBxColl, be_output, es);
 
-  e.put(std::move(be_multicluster_output), backendProcess_->name());
+  e.put(std::make_unique<l1t::HGCalMulticlusterBxCollection>(std::move(be_output.first)), backendProcess_->name());
+  e.put(std::make_unique<l1t::HGCalClusterBxCollection>(std::move(be_output.second)),
+        backendProcess_->name() + "Unclustered");
 }

L1Trigger/L1THGCal/plugins/HGCalTowerMapProducer.cc

@@ -25,7 +25,7 @@ class HGCalTowerMapProducer : public edm::stream::EDProducer<> {
 
 private:
   // inputs
-  edm::EDGetToken input_cell_;
+  edm::EDGetToken input_sums_;
   edm::ESHandle<HGCalTriggerGeometryBase> triggerGeometry_;
   edm::ESGetToken<HGCalTriggerGeometryBase, CaloGeometryRecord> triggerGeomToken_;
   std::unique_ptr<HGCalTowerMapProcessorBase> towersMapProcess_;
@@ -34,7 +34,7 @@ class HGCalTowerMapProducer : public edm::stream::EDProducer<> {
 DEFINE_FWK_MODULE(HGCalTowerMapProducer);
 
 HGCalTowerMapProducer::HGCalTowerMapProducer(const edm::ParameterSet& conf)
-    : input_cell_(consumes<l1t::HGCalTriggerCellBxCollection>(conf.getParameter<edm::InputTag>("InputTriggerCells"))),
+    : input_sums_(consumes<l1t::HGCalTriggerSumsBxCollection>(conf.getParameter<edm::InputTag>("InputTriggerSums"))),
       triggerGeomToken_(esConsumes<HGCalTriggerGeometryBase, CaloGeometryRecord, edm::Transition::BeginRun>()) {
   //setup TowerMap parameters
   const edm::ParameterSet& towerMapParamConfig = conf.getParameterSet("ProcessorParameters");
@@ -55,11 +55,11 @@ void HGCalTowerMapProducer::produce(edm::Event& e, const edm::EventSetup& es) {
   auto towersMap_output = std::make_unique<l1t::HGCalTowerMapBxCollection>();
 
   // Input collections
-  edm::Handle<l1t::HGCalTriggerCellBxCollection> trigCellBxColl;
+  edm::Handle<l1t::HGCalTriggerSumsBxCollection> trigSumBxColl;
 
-  e.getByToken(input_cell_, trigCellBxColl);
+  e.getByToken(input_sums_, trigSumBxColl);
 
-  towersMapProcess_->run(trigCellBxColl, *towersMap_output, es);
+  towersMapProcess_->run(trigSumBxColl, *towersMap_output, es);
 
   e.put(std::move(towersMap_output), towersMapProcess_->name());
 }

L1Trigger/L1THGCal/plugins/HGCalTowerProducer.cc

@@ -26,6 +26,7 @@ class HGCalTowerProducer : public edm::stream::EDProducer<> {
 private:
   // inputs
   edm::EDGetToken input_towers_map_;
+  edm::EDGetToken input_trigger_cells_;
   edm::ESHandle<HGCalTriggerGeometryBase> triggerGeometry_;
   edm::ESGetToken<HGCalTriggerGeometryBase, CaloGeometryRecord> triggerGeomToken_;
   std::unique_ptr<HGCalTowerProcessorBase> towersProcess_;
@@ -35,6 +36,8 @@ DEFINE_FWK_MODULE(HGCalTowerProducer);
 
 HGCalTowerProducer::HGCalTowerProducer(const edm::ParameterSet& conf)
     : input_towers_map_(consumes<l1t::HGCalTowerMapBxCollection>(conf.getParameter<edm::InputTag>("InputTowerMaps"))),
+      input_trigger_cells_(
+          consumes<l1t::HGCalClusterBxCollection>(conf.getParameter<edm::InputTag>("InputTriggerCells"))),
       triggerGeomToken_(esConsumes<HGCalTriggerGeometryBase, CaloGeometryRecord, edm::Transition::BeginRun>()) {
   //setup TowerMap parameters
   const edm::ParameterSet& towerParamConfig = conf.getParameterSet("ProcessorParameters");
@@ -45,6 +48,7 @@ HGCalTowerProducer::HGCalTowerProducer(const edm::ParameterSet& conf)
 }
 
 void HGCalTowerProducer::beginRun(const edm::Run& /*run*/, const edm::EventSetup& es) {
+  towersProcess_->eventSetup(es);
   triggerGeometry_ = es.getHandle(triggerGeomToken_);
   towersProcess_->setGeometry(triggerGeometry_.product());
 }
@@ -54,11 +58,14 @@ void HGCalTowerProducer::produce(edm::Event& e, const edm::EventSetup& es) {
   auto towers_output = std::make_unique<l1t::HGCalTowerBxCollection>();
 
   // Input collections
-  edm::Handle<l1t::HGCalTowerMapBxCollection> towersMapBxColl;
+  std::pair<edm::Handle<l1t::HGCalTowerMapBxCollection>, edm::Handle<l1t::HGCalClusterBxCollection> > inputsColl;
+  auto& towersMapBxColl = inputsColl.first;
+  auto& clustersBxColl = inputsColl.second;
 
   e.getByToken(input_towers_map_, towersMapBxColl);
+  e.getByToken(input_trigger_cells_, clustersBxColl);
 
-  towersProcess_->run(towersMapBxColl, *towers_output, es);
+  towersProcess_->run(inputsColl, *towers_output, es);
 
   e.put(std::move(towers_output), towersProcess_->name());
 }

L1Trigger/L1THGCal/plugins/backend/HGCalBackendLayer2Processor3DClustering.cc

@@ -10,6 +10,8 @@
 #include "L1Trigger/L1THGCal/interface/backend/HGCalHistoClusteringImpl.h"
 #include "L1Trigger/L1THGCal/interface/backend/HGCalTriggerClusterInterpreterBase.h"
 
+#include <utility>
+
 class HGCalBackendLayer2Processor3DClustering : public HGCalBackendLayer2ProcessorBase {
 public:
   HGCalBackendLayer2Processor3DClustering(const edm::ParameterSet& conf) : HGCalBackendLayer2ProcessorBase(conf) {
@@ -39,7 +41,7 @@ class HGCalBackendLayer2Processor3DClustering : public HGCalBackendLayer2Process
   }
 
   void run(const edm::Handle<l1t::HGCalClusterBxCollection>& collHandle,
-           l1t::HGCalMulticlusterBxCollection& collCluster3D,
+           std::pair<l1t::HGCalMulticlusterBxCollection, l1t::HGCalClusterBxCollection>& be_output,
            const edm::EventSetup& es) override {
     es.get<CaloGeometryRecord>().get("", triggerGeometry_);
     if (multiclustering_)
@@ -49,6 +51,9 @@ class HGCalBackendLayer2Processor3DClustering : public HGCalBackendLayer2Process
     if (multiclusteringHistoClustering_)
       multiclusteringHistoClustering_->eventSetup(es);
 
+    auto& collCluster3D = be_output.first;
+    auto& rejectedClusters = be_output.second;
+
     /* create a persistent vector of pointers to the trigger-cells */
     std::vector<edm::Ptr<l1t::HGCalCluster>> clustersPtrs;
     for (unsigned i = 0; i < collHandle->size(); ++i) {
@@ -70,7 +75,7 @@ class HGCalBackendLayer2Processor3DClustering : public HGCalBackendLayer2Process
       case HistoC3d:
         multiclusteringHistoSeeding_->findHistoSeeds(clustersPtrs, seedPositionsEnergy);
         multiclusteringHistoClustering_->clusterizeHisto(
-            clustersPtrs, seedPositionsEnergy, *triggerGeometry_, collCluster3D);
+            clustersPtrs, seedPositionsEnergy, *triggerGeometry_, collCluster3D, rejectedClusters);
         break;
       default:
         // Should not happen, clustering type checked in constructor

L1Trigger/L1THGCal/plugins/backend/HGCalTowerMapProcessor.cc

@@ -1,6 +1,6 @@
 #include "L1Trigger/L1THGCal/interface/HGCalProcessorBase.h"
 
-#include "DataFormats/L1THGCal/interface/HGCalTriggerCell.h"
+#include "DataFormats/L1THGCal/interface/HGCalTriggerSums.h"
 #include "DataFormats/L1THGCal/interface/HGCalTowerMap.h"
 #include "DataFormats/L1THGCal/interface/HGCalTower.h"
 
@@ -14,21 +14,21 @@ class HGCalTowerMapProcessor : public HGCalTowerMapProcessorBase {
     towermap2D_ = std::make_unique<HGCalTowerMap2DImpl>(conf.getParameterSet("towermap_parameters"));
   }
 
-  void run(const edm::Handle<l1t::HGCalTriggerCellBxCollection>& collHandle,
+  void run(const edm::Handle<l1t::HGCalTriggerSumsBxCollection>& collHandle,
            l1t::HGCalTowerMapBxCollection& collTowerMap,
            const edm::EventSetup& es) override {
     es.get<CaloGeometryRecord>().get("", triggerGeometry_);
     towermap2D_->eventSetup(es);
 
-    /* create a persistent vector of pointers to the trigger-cells */
-    std::vector<edm::Ptr<l1t::HGCalTriggerCell>> triggerCellsPtrs;
+    /* create a persistent vector of pointers to the trigger-sums */
+    std::vector<edm::Ptr<l1t::HGCalTriggerSums>> triggerSumsPtrs;
     for (unsigned i = 0; i < collHandle->size(); ++i) {
-      edm::Ptr<l1t::HGCalTriggerCell> ptr(collHandle, i);
-      triggerCellsPtrs.push_back(ptr);
+      edm::Ptr<l1t::HGCalTriggerSums> ptr(collHandle, i);
+      triggerSumsPtrs.push_back(ptr);
     }
 
     /* call to towerMap2D clustering */
-    towermap2D_->buildTowerMap2D(triggerCellsPtrs, collTowerMap);
+    towermap2D_->buildTowerMap2D(triggerSumsPtrs, collTowerMap);
   }
 
 private:

L1Trigger/L1THGCal/plugins/backend/HGCalTowerProcessor.cc

@@ -6,24 +6,52 @@
 
 #include "Geometry/Records/interface/CaloGeometryRecord.h"
 #include "L1Trigger/L1THGCal/interface/HGCalTriggerGeometryBase.h"
+#include "L1Trigger/L1THGCal/interface/backend/HGCalTowerMap2DImpl.h"
 #include "L1Trigger/L1THGCal/interface/backend/HGCalTowerMap3DImpl.h"
 
 class HGCalTowerProcessor : public HGCalTowerProcessorBase {
 public:
   HGCalTowerProcessor(const edm::ParameterSet& conf) : HGCalTowerProcessorBase(conf) {
+    towermap2D_ = std::make_unique<HGCalTowerMap2DImpl>(conf.getParameterSet("towermap_parameters"));
     towermap3D_ = std::make_unique<HGCalTowerMap3DImpl>();
   }
 
-  void run(const edm::Handle<l1t::HGCalTowerMapBxCollection>& collHandle,
+  void eventSetup(const edm::EventSetup& es) override { towermap2D_->eventSetup(es); }
+
+  void run(const std::pair<edm::Handle<l1t::HGCalTowerMapBxCollection>, edm::Handle<l1t::HGCalClusterBxCollection>>&
+               collHandle,
            l1t::HGCalTowerBxCollection& collTowers,
            const edm::EventSetup& es) override {
     es.get<CaloGeometryRecord>().get("", triggerGeometry_);
 
+    auto& towerMapCollHandle = collHandle.first;
+    auto& unclTCsCollHandle = collHandle.second;
+
     /* create a persistent vector of pointers to the towerMaps */
     std::vector<edm::Ptr<l1t::HGCalTowerMap>> towerMapsPtrs;
-    for (unsigned i = 0; i < collHandle->size(); ++i) {
-      edm::Ptr<l1t::HGCalTowerMap> ptr(collHandle, i);
-      towerMapsPtrs.push_back(ptr);
+    for (unsigned i = 0; i < towerMapCollHandle->size(); ++i) {
+      towerMapsPtrs.emplace_back(towerMapCollHandle, i);
+    }
+
+    /* create additional TowerMaps from the unclustered TCs */
+
+    // translate our HGCalClusters into HGCalTriggerCells
+    std::vector<edm::Ptr<l1t::HGCalTriggerCell>> trigCellVec;
+    for (unsigned i = 0; i < unclTCsCollHandle->size(); ++i) {
+      edm::Ptr<l1t::HGCalCluster> ptr(unclTCsCollHandle, i);
+      for (const auto& itTC : ptr->constituents()) {
+        trigCellVec.push_back(itTC.second);
+      }
+    }
+
+    // fill the TowerMaps with the HGCalTriggersCells
+    l1t::HGCalTowerMapBxCollection towerMapsFromUnclTCs;
+    towermap2D_->buildTowerMap2D(trigCellVec, towerMapsFromUnclTCs);
+
+    /* merge the two sets of TowerMaps */
+    unsigned int towerMapsPtrsSize = towerMapsPtrs.size();
+    for (unsigned int i = 0; i < towerMapsFromUnclTCs.size(); ++i) {
+      towerMapsPtrs.emplace_back(&(towerMapsFromUnclTCs[i]), i + towerMapsPtrsSize);
     }
 
     /* call to towerMap3D clustering */
@@ -34,6 +62,7 @@ class HGCalTowerProcessor : public HGCalTowerProcessorBase {
   edm::ESHandle<HGCalTriggerGeometryBase> triggerGeometry_;
 
   /* algorithms instances */
+  std::unique_ptr<HGCalTowerMap2DImpl> towermap2D_;
   std::unique_ptr<HGCalTowerMap3DImpl> towermap3D_;
 };
 

L1Trigger/L1THGCal/python/customTowers.py

@@ -1,6 +1,17 @@
 import FWCore.ParameterSet.Config as cms
 import math
 
+def custom_towers_unclustered_tc(process):
+    process.hgcalTowerProducer.InputTriggerCells = cms.InputTag('hgcalBackEndLayer2Producer:HGCalBackendLayer2Processor3DClusteringUnclustered')
+    process.hgcalTowerProducerHFNose.InputTriggerCells = cms.InputTag('hgcalBackEndLayer2ProducerHFNose:HGCalBackendLayer2Processor3DClusteringUnclustered')
+    return process
+
+
+def custom_towers_all_tc(process):
+    process.hgcalTowerProducer.InputTriggerCells = cms.InputTag('hgcalBackEndLayer1Producer:HGCalBackendLayer1Processor2DClustering')
+    process.hgcalTowerProducerHFNose.InputTriggerCells = cms.InputTag('hgcalBackEndLayer1ProducerHFNose:HGCalBackendLayer1Processor2DClustering')
+    return process
+
 
 def custom_towers_etaphi(process,
         minEta=1.479,