Revert "use a PSet to wrap the list of hits to use in RecHitMapProducer"

This reverts commit 0c8751e.

Author: brusale

RecoLocalCalo/HGCalRecProducers/plugins/RecHitMapProducer.cc

@@ -1,3 +1,4 @@
+// user include files
 #include <unordered_map>
 
 #include "FWCore/Framework/interface/Frameworkfwd.h"
@@ -9,7 +10,6 @@
 #include "FWCore/Framework/interface/MakerMacros.h"
 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
-#include "FWCore/ParameterSet/interface/ParameterSet.h"
 
 #include "DataFormats/HGCRecHit/interface/HGCRecHitCollections.h"
 #include "DataFormats/ParticleFlowReco/interface/PFRecHit.h"
@@ -19,88 +19,81 @@ class RecHitMapProducer : public edm::global::EDProducer<> {
 public:
   RecHitMapProducer(const edm::ParameterSet&);
   static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
+
   void produce(edm::StreamID, edm::Event&, const edm::EventSetup&) const override;
 
 private:
-  using DetIdRecHitMap = std::unordered_map<DetId, const unsigned int>;
-
-  std::unordered_map<std::string, edm::EDGetTokenT<HGCRecHitCollection>> hgcal_hits_tokens_;
-  std::unordered_map<std::string, edm::EDGetTokenT<reco::PFRecHitCollection>> barrel_hits_tokens_;
+  std::vector<edm::EDGetTokenT<HGCRecHitCollection>> hgcal_hits_token_;
+  std::vector<edm::EDGetTokenT<reco::PFRecHitCollection>> barrel_hits_token_;
 
   bool hgcalOnly_;
 };
 
 DEFINE_FWK_MODULE(RecHitMapProducer);
 
+using DetIdRecHitMap = std::unordered_map<DetId, const unsigned int>;
+
 RecHitMapProducer::RecHitMapProducer(const edm::ParameterSet& ps) : hgcalOnly_(ps.getParameter<bool>("hgcalOnly")) {
-  const edm::ParameterSet& hitPSet = ps.getParameter<edm::ParameterSet>("hits");
-  for (const auto& entry : hitPSet.getParameterNamesForType<edm::InputTag>()) {
-    edm::InputTag tag = hitPSet.getParameter<edm::InputTag>(entry);
+  std::vector<edm::InputTag> tags = ps.getParameter<std::vector<edm::InputTag>>("hits");
+  for (auto& tag : tags) {
     if (tag.label().find("HGCalRecHit") != std::string::npos) {
-      hgcal_hits_tokens_.emplace(entry, consumes<HGCRecHitCollection>(tag));
+      hgcal_hits_token_.push_back(consumes<HGCRecHitCollection>(tag));
     } else {
-      barrel_hits_tokens_.emplace(entry, consumes<reco::PFRecHitCollection>(tag));
+      barrel_hits_token_.push_back(consumes<reco::PFRecHitCollection>(tag));
     }
   }
 
   produces<DetIdRecHitMap>("hgcalRecHitMap");
-  if (!hgcalOnly_) {
+  if (!hgcalOnly_)
     produces<DetIdRecHitMap>("barrelRecHitMap");
-  }
 }
 
 void RecHitMapProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
-  edm::ParameterSetDescription hitDesc;
-  hitDesc.add<edm::InputTag>("HGCEE", edm::InputTag("HGCalRecHit", "HGCEERecHits"));
-  hitDesc.add<edm::InputTag>("HGCHEF", edm::InputTag("HGCalRecHit", "HGCHEFRecHits"));
-  hitDesc.add<edm::InputTag>("HGCHEB", edm::InputTag("HGCalRecHit", "HGCHEBRecHits"));
-  // Optionally allow barrel collections to be defined
-  hitDesc.addOptional<edm::InputTag>("ECAL", edm::InputTag("particleFlowRecHitECAL"));
-  hitDesc.addOptional<edm::InputTag>("HCAL", edm::InputTag("particleFlowRecHitHBHE"));
-
   edm::ParameterSetDescription desc;
-  desc.add<edm::ParameterSetDescription>("hits", hitDesc);
+  desc.add<std::vector<edm::InputTag>>("hits",
+                                       {edm::InputTag("HGCalRecHit", "HGCEERecHits"),
+                                        edm::InputTag("HGCalRecHit", "HGCHEFRecHits"),
+                                        edm::InputTag("HGCalRecHit", "HGCHEBRecHits")});
   desc.add<bool>("hgcalOnly", true);
   descriptions.add("recHitMapProducer", desc);
 }
 
-void RecHitMapProducer::produce(edm::StreamID, edm::Event& evt, const edm::EventSetup&) const {
+void RecHitMapProducer::produce(edm::StreamID, edm::Event& evt, const edm::EventSetup& es) const {
   auto hitMapHGCal = std::make_unique<DetIdRecHitMap>();
-  MultiVectorManager<HGCRecHit> rechitManager;
 
-  for (const auto& [name, token] : hgcal_hits_tokens_) {
-    const auto& handle = evt.getHandle(token);
-    if (handle.isValid()) {
-      rechitManager.addVector(*handle);
-    } else {
-      edm::LogWarning("RecHitMapProducer") << "HGCal collection \"" << name << "\" is invalid.";
-    }
+  // Retrieve collections
+  const auto& ee_hits = evt.getHandle(hgcal_hits_token_[0]);
+  const auto& fh_hits = evt.getHandle(hgcal_hits_token_[1]);
+  const auto& bh_hits = evt.getHandle(hgcal_hits_token_[2]);
+
+  // Check validity of all handles
+  if (!ee_hits.isValid() || !fh_hits.isValid() || !bh_hits.isValid()) {
+    edm::LogWarning("HGCalRecHitMapProducer") << "One or more hit collections are unavailable. Returning an empty map.";
+    evt.put(std::move(hitMapHGCal), "hgcalRecHitMap");
+    return;
   }
 
+  MultiVectorManager<HGCRecHit> rechitManager;
+  rechitManager.addVector(*ee_hits);
+  rechitManager.addVector(*fh_hits);
+  rechitManager.addVector(*bh_hits);
+
   for (unsigned int i = 0; i < rechitManager.size(); ++i) {
-    hitMapHGCal->emplace(rechitManager[i].detid(), i);
+    const auto recHitDetId = rechitManager[i].detid();
+    hitMapHGCal->emplace(recHitDetId, i);
   }
 
   evt.put(std::move(hitMapHGCal), "hgcalRecHitMap");
 
-  if (hgcalOnly_)
-    return;
-
-  auto hitMapBarrel = std::make_unique<DetIdRecHitMap>();
-  MultiVectorManager<reco::PFRecHit> barrelManager;
-
-  for (const auto& [name, token] : barrel_hits_tokens_) {
-    const auto& handle = evt.getHandle(token);
-    if (handle.isValid()) {
-      barrelManager.addVector(*handle);
-    } else {
-      edm::LogWarning("RecHitMapProducer") << "Barrel collection \"" << name << "\" is invalid.";
+  if (!hgcalOnly_) {
+    auto hitMapBarrel = std::make_unique<DetIdRecHitMap>();
+    MultiVectorManager<reco::PFRecHit> barrelRechitManager;
+    barrelRechitManager.addVector(evt.get(barrel_hits_token_[0]));
+    barrelRechitManager.addVector(evt.get(barrel_hits_token_[1]));
+    for (unsigned int i = 0; i < barrelRechitManager.size(); ++i) {
+      const auto recHitDetId = barrelRechitManager[i].detId();
+      hitMapBarrel->emplace(recHitDetId, i);
     }
+    evt.put(std::move(hitMapBarrel), "barrelRecHitMap");
   }
-
-  for (unsigned int i = 0; i < barrelManager.size(); ++i) {
-    hitMapBarrel->emplace(barrelManager[i].detId(), i);
-  }
-
-  evt.put(std::move(hitMapBarrel), "barrelRecHitMap");
 }

RecoLocalCalo/HGCalRecProducers/python/recHitMapProducer_cff.py

@@ -1,19 +1,14 @@
 import FWCore.ParameterSet.Config as cms
 
-from RecoLocalCalo.HGCalRecProducers.recHitMapProducer_cfi import recHitMapProducer as _recHitMapProducer
+from RecoLocalCalo.HGCalRecProducers.recHitMapProducer_cfi import recHitMapProducer as recHitMapProducer_
 
-recHitMapProducer = _recHitMapProducer.clone(
-    hits = dict(HGCEE  = ("HGCalRecHit", "HGCEERecHits"),
-                HGCHEF = ("HGCalRecHit", "HGCHEFRecHits"),
-                HGCHEB = ("HGCalRecHit", "HGCHEBRecHits"))
-)
+recHitMapProducer = recHitMapProducer_.clone()
+
+hits = ["HGCalRecHit:HGCEERecHits",
+        "HGCalRecHit:HGCHEFRecHits",
+        "HGCalRecHit:HGCHEBRecHits",
+        "particleFlowRecHitECAL",
+        "particleFlowRecHitHBHE"]
 
 from Configuration.ProcessModifiers.ticl_barrel_cff import ticl_barrel
-ticl_barrel.toModify(recHitMapProducer,
-                     hits = dict(HGCEE  = ("HGCalRecHit", "HGCEERecHits"),
-                                 HGCHEF = ("HGCalRecHit", "HGCHEFRecHits"),
-                                 HGCHEB = ("HGCalRecHit", "HGCHEBRecHits"),
-                                 ECAL   = "particleFlowRecHitECAL",
-                                 HBHE   = "particleFlowRecHitHBHE"),
-                     hgcalOnly = False
-                     )
+ticl_barrel.toModify(recHitMapProducer, hits = hits, hgcalOnly = cms.bool(False)) 

Validation/Configuration/python/hltHGCalSimValid_cff.py

@@ -11,12 +11,12 @@
 
 from Validation.HGCalValidation.HLT_TICLIterLabels_cff import hltTiclIterLabels as _hltTiclIterLabels
 
-from RecoLocalCalo.HGCalRecProducers.recHitMapProducer_cfi import recHitMapProducer as _recHitMapProducer
+from RecoLocalCalo.HGCalRecProducers.recHitMapProducer_cff import recHitMapProducer as _recHitMapProducer
+
+hits = ["hltHGCalRecHit:HGCEERecHits", "hltHGCalRecHit:HGCHEFRecHits", "hltHGCalRecHit:HGCHEBRecHits"]
 hltRecHitMapProducer = _recHitMapProducer.clone(
-    hits = dict(HGCEE  = ("hltHGCalRecHit", "HGCEERecHits"),
-                HGCHEF = ("hltHGCalRecHit", "HGCHEFRecHits"),
-                HGCHEB = ("hltHGCalRecHit", "HGCHEBRecHits")),
-    hgcalOnly = True,
+    hits = hits,
+    hgcalOnly = cms.bool(True),
 )
 
 hltLcAssocByEnergyScoreProducer = _lcAssocByEnergyScoreProducer.clone(