RecHit map and CaloParticle-LayerCluster associator

RecoLocalCalo/HGCalRecProducers/plugins/HGCalRecHitMapProducer.cc

@@ -0,0 +1,71 @@
+#define __RecoLocalCalo_HGCRecProducers_HGCalRecHitMapProducer_H__
+
+// user include files
+#include <map>
+
+#include "FWCore/Framework/interface/Frameworkfwd.h"
+#include "FWCore/Framework/interface/global/EDProducer.h"
+#include "FWCore/MessageLogger/interface/MessageLogger.h"
+
+#include "FWCore/Framework/interface/Event.h"
+#include "FWCore/Framework/interface/ESHandle.h"
+#include "FWCore/Framework/interface/MakerMacros.h"
+#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
+#include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
+
+#include "DataFormats/HGCRecHit/interface/HGCRecHitCollections.h"
+
+class HGCalRecHitMapProducer : public edm::global::EDProducer<> {
+public:
+  HGCalRecHitMapProducer(const edm::ParameterSet&);
+  ~HGCalRecHitMapProducer() override {}
+  static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
+
+  void produce(edm::StreamID, edm::Event&, const edm::EventSetup&) const override;
+
+private:
+  edm::EDGetTokenT<HGCRecHitCollection> hits_ee_token;
+  edm::EDGetTokenT<HGCRecHitCollection> hits_fh_token;
+  edm::EDGetTokenT<HGCRecHitCollection> hits_bh_token;
+};
+
+DEFINE_FWK_MODULE(HGCalRecHitMapProducer);
+
+HGCalRecHitMapProducer::HGCalRecHitMapProducer(const edm::ParameterSet& ps) {
+  hits_ee_token = consumes<HGCRecHitCollection>(ps.getParameter<edm::InputTag>("HGCEEInput"));
+  hits_fh_token = consumes<HGCRecHitCollection>(ps.getParameter<edm::InputTag>("HGCFHInput"));
+  hits_bh_token = consumes<HGCRecHitCollection>(ps.getParameter<edm::InputTag>("HGCBHInput"));
+  produces<std::map<DetId, const HGCRecHit*>>();
+}
+
+void HGCalRecHitMapProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
+  edm::ParameterSetDescription desc;
+
+  desc.add<edm::InputTag>("HGCEEInput", edm::InputTag("HGCalRecHit", "HGCEERecHits"));
+  desc.add<edm::InputTag>("HGCFHInput", edm::InputTag("HGCalRecHit", "HGCHEFRecHits"));
+  desc.add<edm::InputTag>("HGCBHInput", edm::InputTag("HGCalRecHit", "HGCHEBRecHits"));
+  descriptions.add("hgcalRecHitMapProducer", desc);
+}
+
+void HGCalRecHitMapProducer::produce(edm::StreamID, edm::Event& evt, const edm::EventSetup& es) const {
+  std::unique_ptr<std::map<DetId, const HGCRecHit*>> hitMap(new std::map<DetId, const HGCRecHit*>);
+  edm::Handle<HGCRecHitCollection> ee_hits;
+  edm::Handle<HGCRecHitCollection> fh_hits;
+  edm::Handle<HGCRecHitCollection> bh_hits;
+
+  evt.getByToken(hits_ee_token, ee_hits);
+  evt.getByToken(hits_fh_token, fh_hits);
+  evt.getByToken(hits_bh_token, bh_hits);
+  for (const auto& hit : *ee_hits.product()) {
+    hitMap->emplace(hit.detid(), &hit);
+  }
+
+  for (const auto& hit : *fh_hits.product()) {
+    hitMap->emplace(hit.detid(), &hit);
+  }
+
+  for (const auto& hit : *bh_hits.product()) {
+    hitMap->emplace(hit.detid(), &hit);
+  }
+  evt.put(std::move(hitMap));
+}

RecoLocalCalo/HGCalRecProducers/src/classes.h

@@ -0,0 +1,4 @@
+#include "DataFormats/Common/interface/Wrapper.h"
+
+// Add includes for your classes here
+#include "DataFormats/HGCRecHit/interface/HGCRecHitCollections.h"

RecoLocalCalo/HGCalRecProducers/src/classes_def.xml

@@ -0,0 +1,5 @@
+<lcgdict>
+  <class name="std::map<DetId,const HGCRecHit*>" persistent="false"/>
+  <class name="edm::Wrapper<std::map<DetId,const HGCRecHit*>>" persistent="false"/>
+  <class name="std::pair<const DetId,const HGCRecHit*>" />
+</lcgdict>

SimCalorimetry/HGCalAssociatorProducers/plugins/BuildFile.xml

@@ -0,0 +1,7 @@
+<use name="FWCore/Framework"/>
+<use name="FWCore/PluginManager"/>
+<use name="FWCore/ParameterSet"/>
+<use name="SimDataFormats/Associations"/>
+<use name="RecoLocalCalo/HGCalRecAlgos"/>
+<flags EDM_PLUGIN="1"/>
+

SimCalorimetry/HGCalAssociatorProducers/plugins/LayerClusterAssociatorByEnergyScoreImpl.h

@@ -0,0 +1,68 @@
+// Original Author: Marco Rovere
+
+#include <vector>
+#include <map>
+#include <unordered_map>
+#include <memory>  // shared_ptr
+
+#include "DataFormats/ForwardDetId/interface/HGCalDetId.h"
+#include "DataFormats/HGCRecHit/interface/HGCRecHit.h"
+#include "SimDataFormats/Associations/interface/LayerClusterToCaloParticleAssociator.h"
+#include "RecoLocalCalo/HGCalRecAlgos/interface/RecHitTools.h"
+
+namespace edm {
+  class EDProductGetter;
+}
+
+namespace hgcal {
+  struct detIdInfoInCluster {
+    bool operator==(const detIdInfoInCluster &o) const { return clusterId == o.clusterId; };
+    long unsigned int clusterId;
+    float fraction;
+    detIdInfoInCluster(long unsigned int cId, float fr) {
+      clusterId = cId;
+      fraction = fr;
+    }
+  };
+
+  struct detIdInfoInMultiCluster {
+    bool operator==(const detIdInfoInMultiCluster &o) const { return multiclusterId == o.multiclusterId; };
+    unsigned int multiclusterId;
+    long unsigned int clusterId;
+    float fraction;
+  };
+
+  struct caloParticleOnLayer {
+    unsigned int caloParticleId;
+    float energy = 0;
+    std::vector<std::pair<DetId, float>> hits_and_fractions;
+    std::unordered_map<int, std::pair<float, float>> layerClusterIdToEnergyAndScore;
+  };
+
+  typedef std::vector<std::vector<std::pair<unsigned int, float>>> layerClusterToCaloParticle;
+  typedef std::vector<std::vector<hgcal::caloParticleOnLayer>> caloParticleToLayerCluster;
+  typedef std::tuple<layerClusterToCaloParticle, caloParticleToLayerCluster> association;
+}  // namespace hgcal
+
+class LayerClusterAssociatorByEnergyScoreImpl : public hgcal::LayerClusterToCaloParticleAssociatorBaseImpl {
+public:
+  explicit LayerClusterAssociatorByEnergyScoreImpl(edm::EDProductGetter const &,
+                                                   bool,
+                                                   std::shared_ptr<hgcal::RecHitTools>,
+                                                   const std::map<DetId, const HGCRecHit *> *&);
+
+  hgcal::RecoToSimCollection associateRecoToSim(const edm::Handle<reco::CaloClusterCollection> &cCH,
+                                                const edm::Handle<CaloParticleCollection> &cPCH) const override;
+
+  hgcal::SimToRecoCollection associateSimToReco(const edm::Handle<reco::CaloClusterCollection> &cCH,
+                                                const edm::Handle<CaloParticleCollection> &cPCH) const override;
+
+private:
+  const bool hardScatterOnly_;
+  std::shared_ptr<hgcal::RecHitTools> recHitTools_;
+  const std::map<DetId, const HGCRecHit *> *hitMap_;
+  unsigned layers_;
+  edm::EDProductGetter const *productGetter_;
+  hgcal::association makeConnections(const edm::Handle<reco::CaloClusterCollection> &cCH,
+                                     const edm::Handle<CaloParticleCollection> &cPCH) const;
+};

SimCalorimetry/HGCalAssociatorProducers/plugins/LayerClusterAssociatorByEnergyScoreProducer.cc

@@ -0,0 +1,66 @@
+// Original author: Marco Rovere
+
+// user include files
+#include "FWCore/Framework/interface/Frameworkfwd.h"
+#include "FWCore/Framework/interface/global/EDProducer.h"
+
+#include "FWCore/Framework/interface/Event.h"
+#include "FWCore/Framework/interface/MakerMacros.h"
+
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/Utilities/interface/EDGetToken.h"
+
+#include "SimDataFormats/Associations/interface/LayerClusterToCaloParticleAssociator.h"
+#include "LayerClusterAssociatorByEnergyScoreImpl.h"
+
+class LayerClusterAssociatorByEnergyScoreProducer : public edm::global::EDProducer<> {
+public:
+  explicit LayerClusterAssociatorByEnergyScoreProducer(const edm::ParameterSet &);
+  ~LayerClusterAssociatorByEnergyScoreProducer() override;
+
+  static void fillDescriptions(edm::ConfigurationDescriptions &descriptions);
+
+private:
+  void produce(edm::StreamID, edm::Event &, const edm::EventSetup &) const override;
+  edm::EDGetTokenT<std::map<DetId, const HGCRecHit *>> hitMapToken_;
+  const bool hardScatterOnly_;
+  std::shared_ptr<hgcal::RecHitTools> rhtools_;
+};
+
+LayerClusterAssociatorByEnergyScoreProducer::LayerClusterAssociatorByEnergyScoreProducer(const edm::ParameterSet &ps)
+    : hitMapToken_(consumes<std::map<DetId, const HGCRecHit *>>(ps.getParameter<edm::InputTag>("hitMapTag"))),
+      hardScatterOnly_(ps.getParameter<bool>("hardScatterOnly")) {
+  rhtools_.reset(new hgcal::RecHitTools());
+
+  // Register the product
+  produces<hgcal::LayerClusterToCaloParticleAssociator>();
+}
+
+LayerClusterAssociatorByEnergyScoreProducer::~LayerClusterAssociatorByEnergyScoreProducer() {}
+
+void LayerClusterAssociatorByEnergyScoreProducer::produce(edm::StreamID,
+                                                          edm::Event &iEvent,
+                                                          const edm::EventSetup &es) const {
+  rhtools_->getEventSetup(es);
+  edm::Handle<std::map<DetId, const HGCRecHit *>> hitMapHandle;
+  iEvent.getByToken(hitMapToken_, hitMapHandle);
+  const std::map<DetId, const HGCRecHit *> *hitMap = &*hitMapHandle;
+
+  std::unique_ptr<hgcal::LayerClusterToCaloParticleAssociatorBaseImpl> impl(
+      std::make_unique<LayerClusterAssociatorByEnergyScoreImpl>(
+          iEvent.productGetter(), hardScatterOnly_, rhtools_, hitMap));
+  std::unique_ptr<hgcal::LayerClusterToCaloParticleAssociator> toPut(
+      std::make_unique<hgcal::LayerClusterToCaloParticleAssociator>(std::move(impl)));
+  iEvent.put(std::move(toPut));
+}
+
+void LayerClusterAssociatorByEnergyScoreProducer::fillDescriptions(edm::ConfigurationDescriptions &cfg) {
+  edm::ParameterSetDescription desc;
+  desc.add<edm::InputTag>("hitMapTag", edm::InputTag("HGCRecHitMapProducer"));
+  desc.add<bool>("hardScatterOnly", true);
+
+  cfg.add("layerClusterAssociatorByEnergyScore", desc);
+}
+
+//define this as a plug-in
+DEFINE_FWK_MODULE(LayerClusterAssociatorByEnergyScoreProducer);

SimCalorimetry/HGCalSimProducers/python/hgcHitAssociation_cfi.py

@@ -0,0 +1,3 @@
+from SimCalorimetry.HGCalAssociatorProducers.layerClusterAssociatorByEnergyScore_cfi import layerClusterAssociatorByEnergyScore as LCAssocByEnergyScoreProducer
+
+from RecoLocalCalo.HGCalRecProducers.hgcalRecHitMapProducer_cfi import hgcalRecHitMapProducer as HGCRecHitMapProducer

SimDataFormats/Associations/BuildFile.xml

@@ -1,5 +1,7 @@
 <use name="DataFormats/Common"/>
 <use name="DataFormats/RecoCandidate"/>
+<use name="DataFormats/CaloRecHit"/>
+<use name="SimDataFormats/CaloAnalysis"/>
 <use name="clhep"/>
 <export>
   <lib name="1"/>

SimDataFormats/Associations/interface/LayerClusterToCaloParticleAssociator.h

@@ -0,0 +1,48 @@
+#ifndef SimDataFormats_Associations_LayerClusterToCaloParticleAssociator_h
+#define SimDataFormats_Associations_LayerClusterToCaloParticleAssociator_h
+// Original Author:  Marco Rovere
+
+// system include files
+#include <memory>
+
+// user include files
+
+#include "SimDataFormats/Associations/interface/LayerClusterToCaloParticleAssociatorBaseImpl.h"
+
+// forward declarations
+
+namespace hgcal {
+
+  class LayerClusterToCaloParticleAssociator {
+  public:
+    LayerClusterToCaloParticleAssociator(std::unique_ptr<hgcal::LayerClusterToCaloParticleAssociatorBaseImpl>);
+    LayerClusterToCaloParticleAssociator() = default;
+    LayerClusterToCaloParticleAssociator(LayerClusterToCaloParticleAssociator &&) = default;
+    LayerClusterToCaloParticleAssociator &operator=(LayerClusterToCaloParticleAssociator &&) = default;
+    ~LayerClusterToCaloParticleAssociator() = default;
+
+    // ---------- const member functions ---------------------
+    /// Associate a LayerCluster to CaloParticles
+    hgcal::RecoToSimCollection associateRecoToSim(const edm::Handle<reco::CaloClusterCollection> &cCCH,
+                                                  const edm::Handle<CaloParticleCollection> &cPCH) const {
+      return m_impl->associateRecoToSim(cCCH, cPCH);
+    };
+
+    /// Associate a CaloParticle to LayerClusters
+    hgcal::SimToRecoCollection associateSimToReco(const edm::Handle<reco::CaloClusterCollection> &cCCH,
+                                                  const edm::Handle<CaloParticleCollection> &cPCH) const {
+      return m_impl->associateSimToReco(cCCH, cPCH);
+    }
+
+  private:
+    LayerClusterToCaloParticleAssociator(const LayerClusterToCaloParticleAssociator &) = delete;  // stop default
+
+    const LayerClusterToCaloParticleAssociator &operator=(const LayerClusterToCaloParticleAssociator &) =
+        delete;  // stop default
+
+    // ---------- member data --------------------------------
+    std::unique_ptr<LayerClusterToCaloParticleAssociatorBaseImpl> m_impl;
+  };
+}  // namespace hgcal
+
+#endif

SimDataFormats/Associations/interface/LayerClusterToCaloParticleAssociatorBaseImpl.h

@@ -0,0 +1,45 @@
+#ifndef SimDataFormats_Associations_LayerClusterToCaloParticleAssociatorBaseImpl_h
+#define SimDataFormats_Associations_LayerClusterToCaloParticleAssociatorBaseImpl_h
+
+/** \class LayerClusterToCaloParticleAssociatorBaseImpl
+ *
+ * Base class for LayerClusterToCaloParticleAssociators.  Methods take as input
+ * the handle of LayerClusters and the CaloParticle collections and return an
+ * AssociationMap (oneToManyWithQuality)
+ *
+ *  \author Marco Rovere
+ */
+
+#include "DataFormats/Common/interface/Handle.h"
+#include "DataFormats/Common/interface/AssociationMap.h"
+#include "DataFormats/CaloRecHit/interface/CaloClusterFwd.h"
+
+#include "SimDataFormats/CaloAnalysis/interface/CaloParticleFwd.h"
+
+namespace hgcal {
+
+  typedef edm::AssociationMap<
+      edm::OneToManyWithQualityGeneric<CaloParticleCollection, reco::CaloClusterCollection, std::pair<float, float>>>
+      SimToRecoCollection;
+  typedef edm::AssociationMap<
+      edm::OneToManyWithQualityGeneric<reco::CaloClusterCollection, CaloParticleCollection, float>>
+      RecoToSimCollection;
+
+  class LayerClusterToCaloParticleAssociatorBaseImpl {
+  public:
+    /// Constructor
+    LayerClusterToCaloParticleAssociatorBaseImpl();
+    /// Destructor
+    virtual ~LayerClusterToCaloParticleAssociatorBaseImpl();
+
+    /// Associate a LayerCluster to CaloParticles
+    virtual hgcal::RecoToSimCollection associateRecoToSim(const edm::Handle<reco::CaloClusterCollection> &cCH,
+                                                          const edm::Handle<CaloParticleCollection> &cPCH) const;
+
+    /// Associate a CaloParticle to LayerClusters
+    virtual hgcal::SimToRecoCollection associateSimToReco(const edm::Handle<reco::CaloClusterCollection> &cCH,
+                                                          const edm::Handle<CaloParticleCollection> &cPCH) const;
+  };
+}  // namespace hgcal
+
+#endif

SimDataFormats/Associations/src/LayerClusterToCaloParticleAssociator.cc

@@ -0,0 +1,7 @@
+// Original Author: Marco Rovere
+
+#include "SimDataFormats/Associations/interface/LayerClusterToCaloParticleAssociator.h"
+
+hgcal::LayerClusterToCaloParticleAssociator::LayerClusterToCaloParticleAssociator(
+    std::unique_ptr<hgcal::LayerClusterToCaloParticleAssociatorBaseImpl> ptr)
+    : m_impl(std::move(ptr)) {}

SimDataFormats/Associations/src/LayerClusterToCaloParticleAssociatorBaseImpl.cc

@@ -0,0 +1,19 @@
+// Original Author: Marco Rovere
+
+#include "SimDataFormats/Associations/interface/LayerClusterToCaloParticleAssociatorBaseImpl.h"
+
+namespace hgcal {
+  LayerClusterToCaloParticleAssociatorBaseImpl::LayerClusterToCaloParticleAssociatorBaseImpl(){};
+  LayerClusterToCaloParticleAssociatorBaseImpl::~LayerClusterToCaloParticleAssociatorBaseImpl(){};
+
+  hgcal::RecoToSimCollection LayerClusterToCaloParticleAssociatorBaseImpl::associateRecoToSim(
+      const edm::Handle<reco::CaloClusterCollection> &cCCH, const edm::Handle<CaloParticleCollection> &cPCH) const {
+    return hgcal::RecoToSimCollection();
+  }
+
+  hgcal::SimToRecoCollection LayerClusterToCaloParticleAssociatorBaseImpl::associateSimToReco(
+      const edm::Handle<reco::CaloClusterCollection> &cCCH, const edm::Handle<CaloParticleCollection> &cPCH) const {
+    return hgcal::SimToRecoCollection();
+  }
+
+}  // namespace hgcal

SimDataFormats/Associations/src/classes.h

@@ -6,6 +6,7 @@
 #include "SimDataFormats/Associations/interface/TrackToTrackingParticleAssociator.h"
 #include "SimDataFormats/Associations/interface/VertexAssociation.h"
 #include "SimDataFormats/Associations/interface/VertexToTrackingVertexAssociator.h"
+#include "SimDataFormats/Associations/interface/LayerClusterToCaloParticleAssociator.h"
 
 namespace SimDataFormats_Associations {
   struct SimDataFormats_Associations {
@@ -16,6 +17,8 @@ namespace SimDataFormats_Associations {
 
     edm::Wrapper<reco::VertexToTrackingVertexAssociator> dummy4;
 
+    edm::Wrapper<hgcal::LayerClusterToCaloParticleAssociator> dummy5;
+
     reco::VertexSimToRecoCollection vstrc;
     reco::VertexSimToRecoCollection::const_iterator vstrci;
     edm::Wrapper<reco::VertexSimToRecoCollection> wvstrc;

SimDataFormats/Associations/src/classes_def.xml

@@ -9,6 +9,9 @@
   <class name="reco::VertexToTrackingVertexAssociator" persistent="false"/>
   <class name="edm::Wrapper<reco::VertexToTrackingVertexAssociator>" persistent="false"/>
 
+  <class name="hgcal::LayerClusterToCaloParticleAssociator" persistent="false"/>
+  <class name="edm::Wrapper<hgcal::LayerClusterToCaloParticleAssociator>" persistent="false"/>
+
   <class name="reco::VertexSimToRecoCollection" >
     <field name="transientMap_" transient="true"/>
   </class>

Validation/Configuration/python/autoValidation.py

@@ -13,7 +13,7 @@
                    'miniAODValidation' : ['prevalidationMiniAOD','validationMiniAOD','validationHarvestingMiniAOD'],
                    'standardValidation' : ['prevalidation','validation','validationHarvesting'],
                    'standardValidationNoHLT' : ['prevalidationNoHLT','validationNoHLT','validationHarvestingNoHLT'],
-                   'HGCalValidation' : ['', 'globalValidationHGCal', 'hgcalValidatorPostProcessor'],
+                   'HGCalValidation' : ['globalPrevalidationHGCal', 'globalValidationHGCal', 'hgcalValidatorPostProcessor'],
                    'MTDValidation' : ['', 'globalValidationMTD', 'mtdValidationPostProcessor'],
                    'OuterTrackerValidation' : ['', 'globalValidationOuterTracker', 'postValidationOuterTracker'],
                    'ecalValidation_phase2' : ['', 'validationECALPhase2', ''],