Particle Flow cluster validation in ECAL

DataFormats/ParticleFlowReco/src/classes_def_2.xml

@@ -69,7 +69,7 @@
 
   <class name="std::vector<reco::PFRecHit>"/>
   <class name="edm::Wrapper<std::vector<reco::PFRecHit> >"/>
-  <class name="edm::RefProd<vector<reco::PFRecHit> >"/>
+  <class name="edm::RefProd<std::vector<reco::PFRecHit> >"/>
   <class name="edm::Ref< std::vector<reco::PFRecHit>, reco::PFRecHit, edm::refhelper::FindUsingAdvance<std::vector<reco::PFRecHit>,reco::PFRecHit>  >"/>
   <class name="edm::RefVector<std::vector<reco::PFRecHit>,reco::PFRecHit,edm::refhelper::FindUsingAdvance<std::vector<reco::PFRecHit>,reco::PFRecHit> >"/>
   <class name="edm::Wrapper<std::vector<edm::RefProd<std::vector<reco::PFRecHit> > > >"/>
@@ -223,9 +223,9 @@
   <class name="edm::RefVector<std::vector<reco::GsfPFRecTrack>,reco::GsfPFRecTrack,edm::refhelper::FindUsingAdvance<std::vector<reco::GsfPFRecTrack>,reco::GsfPFRecTrack> >"/>
   <class name="std::vector<edm::Ref<std::vector<reco::GsfPFRecTrack>,reco::GsfPFRecTrack,edm::refhelper::FindUsingAdvance<std::vector<reco::GsfPFRecTrack>,reco::GsfPFRecTrack> > >"/>
 
+  <class name="edm::refhelper::FindUsingAdvance<std::vector<reco::PFCluster>,reco::PFCluster>"/>
   <class name="edm::Ref<std::vector<reco::PFCluster>,reco::PFCluster,edm::refhelper::FindUsingAdvance<std::vector<reco::PFCluster>,reco::PFCluster> >"/>
 
-
   <class name="pftools::ParticleFiltrationDecision" ClassVersion="11">
    <version ClassVersion="11" checksum="1016852148"/>
    <version ClassVersion="10" checksum="2525480962"/>

HLTriggerOffline/Common/python/HLTValidationHarvest_cff.py

@@ -18,11 +18,13 @@
 from Validation.HGCalValidation.HLTHGCalPostProcessor_cff import *
 from Validation.HLTrigger.HLTGenValidationHarvesting_cff import *
 from Validation.HGCalValidation.BarrelPostProcessor_cff import *
+from Validation.RecoParticleFlow.hltPFPostProcessor_cfi import hltPFClusterPostProcessor
 
 hltpostvalidation = cms.Sequence( 
     postProcessorHLTtrackingSequence
     +postProcessorHLTvertexing
     +postProcessorHLTvertexingReconstructableSim
+    +hltPFClusterPostProcessor
     +HLTMuonPostVal
     +HLTTauPostVal
     +EgammaPostVal

HLTriggerOffline/Common/python/HLTValidation_cff.py

@@ -21,6 +21,8 @@
 # Gen-level Validation
 from Validation.HLTrigger.HLTGenValidation_cff import *
 from Validation.Configuration.globalValidation_cff import *
+# PF
+from Validation.RecoParticleFlow.hltPFValidation_cfi import *
 
 # HGCAL Rechit Calibration
 from Validation.HGCalValidation.hgcalHitCalibrationDefault_cfi import hgcalHitCalibrationDefault as _hgcalHitCalibrationDefault
@@ -31,7 +33,12 @@
     recHitsBH = ("hltHGCalRecHit", "HGCHEBRecHits", "HLT"),
     hgcalMultiClusters = "None",
     electrons = "None",
-    photons = "None"
+    photons = "None",
+    caloParticles = cms.InputTag("mix", "MergedCaloTruth")
+)
+from Configuration.ProcessModifiers.premix_stage2_cff import premix_stage2
+premix_stage2.toModify(hgcalHitCalibrationHLT,
+    caloParticles = cms.InputTag("mixData", "MergedCaloTruth")
 )
 
 # HGCAL validation
@@ -56,6 +63,7 @@
     +ExoticaValidationProdSeq
     +hltMultiTrackValidationGsfTracks
     +hltJetPreValidSeq
+    +hltRecHitMapProducer
     )
 from Configuration.Eras.Modifier_phase1Pixel_cff import phase1Pixel
 
@@ -98,14 +106,15 @@
     +SMPValidationSequence
     +hltbtagValidationSequence #too noisy for now
     +hltHCALdigisAnalyzer+hltHCALRecoAnalyzer+hltHCALNoiseRates # HCAL
+    +PFValSeq
 )
 
 # Exclude everything except Muon and JetMET for now. Add HGCAL Hit Calibration
 _hltvalidationWithMC_Phase2 = hltvalidationWithMC.copyAndExclude([#HLTMuonVal,
   HLTTauVal,
   egammaValidationSequence,
   heavyFlavorValidationSequence,
-  #HLTJetMETValSeq,
+  HLTJetMETValSeq,
   HLTSusyExoValSeq,
   HiggsValidationSequence,
   ExoticaValidationSequence,
@@ -116,8 +125,9 @@
   hltHCALRecoAnalyzer,
   hltHCALNoiseRates])
 _hltvalidationWithMC_Phase2.insert(-1, hgcalHitCalibrationHLT)
-_hltvalidationWithMC_Phase2.insert(-1, hltHgcalValidator)
-_hltvalidationWithMC_Phase2.insert(-1, hltGENValidation)
+_hltvalidationWithMC_Phase2.insert(-1, hltHgcalValSeq)
+_hltvalidationWithMC_Phase2.insert(-1, hltGENValidation) # must go before HLTJetMETValSeq
+_hltvalidationWithMC_Phase2.insert(-1, HLTJetMETValSeq)
 phase2_common.toReplaceWith(hltvalidationWithMC, _hltvalidationWithMC_Phase2)
 
 hltvalidationWithData = cms.Sequence(

RecoLocalCalo/HGCalRecAlgos/src/RecHitTools.cc

@@ -113,7 +113,8 @@ void RecHitTools::setGeometry(const CaloGeometry& geom) {
     bhFirstLayer_ = bhOffset_ + (geomBH->topology().dddConstants()).firstLayer();
     bhLastLayer_ = bhOffset_ + (geomBH->topology().dddConstants()).lastLayer(true);
     bhMaxIphi_ = geomBH->topology().dddConstants().maxCells(true);
-  } else {
+  } else if (static_cast<const HGCalGeometry*>(
+                 geom_->getSubdetectorGeometry(DetId::Forward, ForwardSubdetector::HGCEE))) {
     geometryType_ = 0;
     geomEE =
         static_cast<const HGCalGeometry*>(geom_->getSubdetectorGeometry(DetId::Forward, ForwardSubdetector::HGCEE));
@@ -526,11 +527,13 @@ bool RecHitTools::isScintillatorFine(const DetId& id) const {
     return false;
   }
 }
+
 bool RecHitTools::isBarrel(const DetId& id) const {
   return (id.det() == DetId::Ecal && id.subdetId() == EcalBarrel) ||
          (id.det() == DetId::Hcal && id.subdetId() == HcalBarrel) ||
          (id.det() == DetId::Hcal && id.subdetId() == HcalOuter);
 }
+
 bool RecHitTools::isOnlySilicon(const unsigned int layer) const {
   // HFnose TODO
   bool isonlysilicon = (layer % bhLastLayer_) < bhOffset_;

RecoLocalCalo/HGCalRecProducers/plugins/RecHitMapProducer.cc

@@ -13,6 +13,7 @@
 
 #include "DataFormats/HGCRecHit/interface/HGCRecHitCollections.h"
 #include "DataFormats/ParticleFlowReco/interface/PFRecHit.h"
+#include "DataFormats/ParticleFlowReco/interface/PFRecHitFwd.h"
 #include "DataFormats/Common/interface/RefProdVector.h"
 #include "DataFormats/Common/interface/MultiSpan.h"
 
@@ -24,33 +25,35 @@ class RecHitMapProducer : public edm::global::EDProducer<> {
   void produce(edm::StreamID, edm::Event&, const edm::EventSetup&) const override;
 
 private:
+  std::vector<edm::InputTag> hgcal_hits_tag_;
+  std::vector<edm::InputTag> pf_hits_tag_;
   std::vector<edm::EDGetTokenT<HGCRecHitCollection>> hgcal_hits_token_;
-  std::vector<edm::EDGetTokenT<reco::PFRecHitCollection>> barrel_hits_token_;
+  std::vector<edm::EDGetTokenT<reco::PFRecHitCollection>> pf_hits_token_;
 
-  bool hgcalOnly_;
+  bool doHgcalHits_;
+  bool doPFHits_;
 };
 
 DEFINE_FWK_MODULE(RecHitMapProducer);
 
 using DetIdRecHitMap = std::unordered_map<DetId, const unsigned int>;
 
-RecHitMapProducer::RecHitMapProducer(const edm::ParameterSet& ps) : hgcalOnly_(ps.getParameter<bool>("hgcalOnly")) {
+RecHitMapProducer::RecHitMapProducer(const edm::ParameterSet& ps)
+    : doHgcalHits_(ps.getParameter<bool>("doHgcalHits")), doPFHits_(ps.getParameter<bool>("doPFHits")) {
   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_tag_.push_back(tag);
       hgcal_hits_token_.push_back(consumes<HGCRecHitCollection>(tag));
     } else {
-      barrel_hits_token_.push_back(consumes<reco::PFRecHitCollection>(tag));
+      pf_hits_tag_.push_back(tag);
+      pf_hits_token_.push_back(consumes<reco::PFRecHitCollection>(tag));
     }
   }
-
   produces<edm::RefProdVector<HGCRecHitCollection>>("RefProdVectorHGCRecHitCollection");
   produces<DetIdRecHitMap>("hgcalRecHitMap");
-
-  if (!hgcalOnly_) {
-    produces<edm::RefProdVector<reco::PFRecHitCollection>>("RefProdVectorPFRecHitCollection");
-    produces<DetIdRecHitMap>("barrelRecHitMap");
-  }
+  produces<edm::RefProdVector<reco::PFRecHitCollection>>("RefProdVectorPFRecHitCollection");
+  produces<DetIdRecHitMap>("pfRecHitMap");
 }
 
 void RecHitMapProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
@@ -59,69 +62,85 @@ void RecHitMapProducer::fillDescriptions(edm::ConfigurationDescriptions& descrip
                                        {edm::InputTag("HGCalRecHit", "HGCEERecHits"),
                                         edm::InputTag("HGCalRecHit", "HGCHEFRecHits"),
                                         edm::InputTag("HGCalRecHit", "HGCHEBRecHits")});
-  desc.add<bool>("hgcalOnly", true);
+  desc.add<bool>("doHgcalHits", true);
+  desc.add<bool>("doPFHits", false);
   descriptions.add("recHitMapProducer", desc);
 }
 
 void RecHitMapProducer::produce(edm::StreamID, edm::Event& evt, const edm::EventSetup& es) const {
-  auto hitMapHGCal = std::make_unique<DetIdRecHitMap>();
-
-  // Retrieve collections
-  assert(hgcal_hits_token_.size() == 3);
-  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 HGCal hit collections are unavailable. Returning an "
-                                                 "empty map and an empty RefProdVectorHGCRecHitCollection";
-    evt.put(std::make_unique<edm::RefProdVector<HGCRecHitCollection>>(), "RefProdVectorHGCRecHitCollection");
-    evt.put(std::move(hitMapHGCal), "hgcalRecHitMap");
-  } else {
-    // Fix order by storing a edm::RefProdVector<HGCRecHitCollection>
-    auto mcHGCRecHit = std::make_unique<edm::RefProdVector<HGCRecHitCollection>>();
-    mcHGCRecHit->push_back(edm::RefProd<HGCRecHitCollection>(ee_hits));
-    mcHGCRecHit->push_back(edm::RefProd<HGCRecHitCollection>(fh_hits));
-    mcHGCRecHit->push_back(edm::RefProd<HGCRecHitCollection>(bh_hits));
-
-    edm::MultiSpan<HGCRecHit> rechitSpan(*mcHGCRecHit);
-    for (unsigned int i = 0; i < rechitSpan.size(); ++i) {
-      const auto recHitDetId = rechitSpan[i].detid();
-      hitMapHGCal->emplace(recHitDetId, i);
+  if (doHgcalHits_) {
+    auto hitMapHGCal = std::make_unique<DetIdRecHitMap>();
+
+    // Retrieve collections
+    assert(hgcal_hits_token_.size() == 3);
+    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 of the following HGCal hit collections are unavailable: ";
+      for (auto& tag : hgcal_hits_tag_) {
+        edm::LogWarning("HGCalRecHitMapProducer") << " - " << tag;
+      }
+      edm::LogWarning("HGCalRecHitMapProducer")
+          << "Returning an empty map and an empty RefProdVectorHGCRecHitCollection";
+      evt.put(std::make_unique<edm::RefProdVector<HGCRecHitCollection>>(), "RefProdVectorHGCRecHitCollection");
+      evt.put(std::move(hitMapHGCal), "hgcalRecHitMap");
+    } else {
+      // Fix order by storing a edm::RefProdVector<HGCRecHitCollection>
+      auto mcHGCRecHit = std::make_unique<edm::RefProdVector<HGCRecHitCollection>>();
+      mcHGCRecHit->push_back(edm::RefProd<HGCRecHitCollection>(ee_hits));
+      mcHGCRecHit->push_back(edm::RefProd<HGCRecHitCollection>(fh_hits));
+      mcHGCRecHit->push_back(edm::RefProd<HGCRecHitCollection>(bh_hits));
+
+      edm::MultiSpan<HGCRecHit> rechitSpan(*mcHGCRecHit);
+      for (unsigned int i = 0; i < rechitSpan.size(); ++i) {
+        const auto recHitDetId = rechitSpan[i].detid();
+        hitMapHGCal->emplace(recHitDetId, i);
+      }
+
+      evt.put(std::move(mcHGCRecHit), "RefProdVectorHGCRecHitCollection");
+      evt.put(std::move(hitMapHGCal), "hgcalRecHitMap");
     }
-
-    evt.put(std::move(mcHGCRecHit), "RefProdVectorHGCRecHitCollection");
-    evt.put(std::move(hitMapHGCal), "hgcalRecHitMap");
-  }
-
-  if (hgcalOnly_) {
-    return;
+  } else {
+    evt.put(std::make_unique<edm::RefProdVector<HGCRecHitCollection>>(), "RefProdVectorHGCRecHitCollection");
+    evt.put(std::make_unique<DetIdRecHitMap>(), "hgcalRecHitMap");
   }
 
-  auto hitMapBarrel = std::make_unique<DetIdRecHitMap>();
-
-  assert(barrel_hits_token_.size() == 2);
-  const auto& ecal_hits = evt.getHandle(barrel_hits_token_[0]);
-  const auto& hbhe_hits = evt.getHandle(barrel_hits_token_[1]);
-
-  if (!ecal_hits.isValid() || !hbhe_hits.isValid()) {
-    edm::LogWarning("HGCalRecHitMapProducer") << "One or more barrel hit collections are unavailable. Returning an "
-                                                 "empty map and an empty RefProdVectorPFRecHitCollection";
-    evt.put(std::make_unique<edm::RefProdVector<reco::PFRecHitCollection>>(), "RefProdVectorPFRecHitCollection");
-    evt.put(std::move(hitMapBarrel), "barrelRecHitMap");
-  } else {
-    auto mcPFRecHit = std::make_unique<edm::RefProdVector<reco::PFRecHitCollection>>();
-    mcPFRecHit->push_back(edm::RefProd<reco::PFRecHitCollection>(ecal_hits));
-    mcPFRecHit->push_back(edm::RefProd<reco::PFRecHitCollection>(hbhe_hits));
-
-    edm::MultiSpan<reco::PFRecHit> barrelRechitSpan(*mcPFRecHit);
-    for (unsigned int i = 0; i < barrelRechitSpan.size(); ++i) {
-      const auto recHitDetId = barrelRechitSpan[i].detId();
-      hitMapBarrel->emplace(recHitDetId, i);
+  if (doPFHits_) {
+    auto hitMapPF = std::make_unique<DetIdRecHitMap>();
+
+    assert(pf_hits_token_.size() == 2);
+    const auto& ecal_hits = evt.getHandle(pf_hits_token_[0]);
+    const auto& hbhe_hits = evt.getHandle(pf_hits_token_[1]);
+
+    if (!ecal_hits.isValid() || !hbhe_hits.isValid()) {
+      edm::LogWarning("HGCalRecHitMapProducer") << "One or more of the following PF hit collections are unavailable: ";
+      for (auto& tag : pf_hits_tag_) {
+        edm::LogWarning("HGCalRecHitMapProducer") << " - " << tag;
+      }
+      edm::LogWarning("HGCalRecHitMapProducer") << "Returning an empty map.";
+      evt.put(std::make_unique<edm::RefProdVector<reco::PFRecHitCollection>>(), "RefProdVectorPFRecHitCollection");
+      evt.put(std::move(hitMapPF), "pfRecHitMap");
+    } else {
+      // Fix order by storing a edm::RefProdVector<PFRecHitCollection>
+      auto mcPFRecHit = std::make_unique<edm::RefProdVector<reco::PFRecHitCollection>>();
+      mcPFRecHit->push_back(edm::RefProd<reco::PFRecHitCollection>(ecal_hits));
+      mcPFRecHit->push_back(edm::RefProd<reco::PFRecHitCollection>(hbhe_hits));
+
+      edm::MultiSpan<reco::PFRecHit> pfRechitSpan(*mcPFRecHit);
+      for (unsigned int i = 0; i < pfRechitSpan.size(); ++i) {
+        const auto recHitDetId = pfRechitSpan[i].detId();
+        hitMapPF->emplace(recHitDetId, i);
+      }
+
+      evt.put(std::move(mcPFRecHit), "RefProdVectorPFRecHitCollection");
+      evt.put(std::move(hitMapPF), "pfRecHitMap");
     }
-
-    evt.put(std::move(mcPFRecHit), "RefProdVectorPFRecHitCollection");
-    evt.put(std::move(hitMapBarrel), "barrelRecHitMap");
+  } else {
+    evt.put(std::make_unique<edm::RefProdVector<reco::PFRecHitCollection>>(), "RefProdVectorPFRecHitCollection");
+    evt.put(std::make_unique<DetIdRecHitMap>(), "pfRecHitMap");
   }
 }

RecoLocalCalo/HGCalRecProducers/python/recHitMapProducer_cff.py

@@ -11,4 +11,4 @@
         "particleFlowRecHitHBHE"]
 
 from Configuration.ProcessModifiers.ticl_barrel_cff import ticl_barrel
-ticl_barrel.toModify(recHitMapProducer, hits = hits, hgcalOnly = False)
+ticl_barrel.toModify(recHitMapProducer, hits = hits, doHgcalHits = True, doPFHits = True)

SimCalorimetry/Configuration/python/SimCalorimetry_EventContent_cff.py

@@ -45,6 +45,10 @@
 run2_common.toModify( SimCalorimetryFEVTDEBUG.outputCommands, func=lambda outputCommands: outputCommands.append('keep *_simHcalUnsuppressedDigis_*_*') )
 run2_common.toModify( SimCalorimetryRAW.outputCommands, func=lambda outputCommands: outputCommands.append('keep *_simHcalUnsuppressedDigis_*_*') )
 
+from Configuration.Eras.Modifier_run3_common_cff import run3_common
+run3_common.toModify( SimCalorimetryFEVTDEBUG.outputCommands, func=lambda outputCommands: outputCommands.append('keep *_mix_MergedCaloTruth_*') )
+run3_common.toModify( SimCalorimetryRAW.outputCommands, func=lambda outputCommands: outputCommands.append('keep *_mix_MergedCaloTruth_*') )
+
 from Configuration.Eras.Modifier_run3_ecal_devel_cff import run3_ecal_devel
 run3_ecal_devel.toModify(SimCalorimetryFEVTDEBUG.outputCommands, func=lambda outputCommands: outputCommands.append('keep *_mix_EBTimeDigi_*') )
 run3_ecal_devel.toModify(SimCalorimetryRAW.outputCommands, func=lambda outputCommands: outputCommands.append('keep *_mix_EBTimeDigi_*') )