Updating E/gamma supercluster/ecal candidate filtering tools to allow future jetcore seeding by e/gamma

CommonTools/CandAlgos/plugins/CandMergerCleanOthersByDR.cc

@@ -0,0 +1,120 @@
+//****************************************************************
+//
+// A simple class to combine two candidate collections into a single
+// collection of ptrs to the candidates
+// note: it is a std::vector as the candidates are from different 
+// collections
+//
+// collection 1 is added fully while collection 2 is deltaR cross
+// cleaned against collection 2
+//
+// usecase: getting a unified list of e/gammas + jets for jet core 
+//          regional tracking
+//
+//****************************************************************
+
+
+#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/StreamID.h"
+
+#include "DataFormats/Candidate/interface/Candidate.h"
+#include "DataFormats/Common/interface/View.h"
+#include "DataFormats/Common/interface/Ptr.h"
+#include "DataFormats/Math/interface/deltaR.h"
+
+class CandMergerCleanOthersByDR : public edm::global::EDProducer<> {
+public:
+  explicit CandMergerCleanOthersByDR(const edm::ParameterSet&);
+  ~CandMergerCleanOthersByDR(){}
+
+  static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
+
+private:
+  void produce(edm::StreamID, edm::Event&, const edm::EventSetup&)const override;
+
+private:  
+  const edm::EDGetTokenT<edm::View<reco::Candidate> > coll1Token_;
+  const edm::EDGetTokenT<edm::View<reco::Candidate> > coll2Token_;
+  const float maxDR2ToClean_;
+
+};
+
+
+namespace {
+  double pow2(double val){return val*val;}
+}
+
+CandMergerCleanOthersByDR::CandMergerCleanOthersByDR(const edm::ParameterSet& iConfig) :
+  coll1Token_(consumes<edm::View<reco::Candidate>>(iConfig.getParameter<edm::InputTag>("coll1"))),
+  coll2Token_(consumes<edm::View<reco::Candidate>>(iConfig.getParameter<edm::InputTag>("coll2"))),
+  maxDR2ToClean_(pow2(iConfig.getParameter<double>("maxDRToClean")))
+{
+  produces<std::vector<edm::Ptr<reco::Candidate> > >();
+}
+
+namespace {
+  template<typename T> edm::Handle<T> getHandle(const edm::Event& iEvent,
+						const edm::EDGetTokenT<T>& token)
+  {
+    edm::Handle<T> handle;
+    iEvent.getByToken(token,handle);
+    return handle;
+  }
+
+  bool hasDRMatch(const reco::Candidate& cand,const std::vector<std::pair<float,float> >& etaPhisToMatch,const float maxDR2)
+  {
+    const float candEta = cand.eta();
+    const float candPhi = cand.phi();
+    for(const auto& etaPhi : etaPhisToMatch){
+      if(reco::deltaR2(candEta,candPhi,etaPhi.first,etaPhi.second)<=maxDR2){
+	return true;
+      }
+    }
+    return false;
+  }
+}
+
+// ------------ method called to produce the data  ------------
+void
+CandMergerCleanOthersByDR::produce(edm::StreamID streamID, edm::Event& iEvent, const edm::EventSetup& iSetup)const
+{
+  auto outColl = std::make_unique<std::vector<edm::Ptr<reco::Candidate> > >();
+
+  auto coll1Handle = getHandle(iEvent,coll1Token_); 
+  auto coll2Handle = getHandle(iEvent,coll2Token_); 
+
+  std::vector<std::pair<float,float> > coll1EtaPhis;
+  for(size_t objNr=0;objNr<coll1Handle->size();objNr++){
+    edm::Ptr<reco::Candidate> objPtr(coll1Handle,objNr);
+    coll1EtaPhis.push_back({objPtr->eta(),objPtr->phi()}); //just to speed up the DR match
+    outColl->push_back(objPtr);
+  }
+  for(size_t objNr=0;objNr<coll2Handle->size();objNr++){
+    edm::Ptr<reco::Candidate> objPtr(coll2Handle,objNr);
+    if(!hasDRMatch(*objPtr,coll1EtaPhis,maxDR2ToClean_)){
+      outColl->push_back(objPtr);
+    }
+  }
+
+  iEvent.put(std::move(outColl));
+}
+
+// ------------ method fills 'descriptions' with the allowed parameters for the module  ------------
+void
+CandMergerCleanOthersByDR::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
+
+  edm::ParameterSetDescription desc;
+  desc.add<edm::InputTag>("coll1", edm::InputTag("egammasForCoreTracking"));
+  desc.add<edm::InputTag>("coll2", edm::InputTag("jetsForCoreTracking"));
+  desc.add<double>("maxDRToClean", 0.05);
+  descriptions.add("candMergerCleanOthersByDR", desc);
+}
+
+//define this as a plug-in
+DEFINE_FWK_MODULE(CandMergerCleanOthersByDR);

RecoEgamma/EgammaHLTProducers/interface/EgammaHLTFilteredObjProducer.h

@@ -0,0 +1,177 @@
+#ifndef RECOEGAMMA_EGAMMAHLTPRODUCERS_EGAMMAHLTFILTEREDOBJPRODUCER_H
+#define RECOEGAMMA_EGAMMAHLTPRODUCERS_EGAMMAHLTFILTEREDOBJPRODUCER_H
+
+
+#include "FWCore/Framework/interface/Frameworkfwd.h"
+#include "FWCore/Framework/interface/stream/EDProducer.h"
+#include "FWCore/Framework/interface/Event.h"
+#include "FWCore/Framework/interface/MakerMacros.h"
+#include "FWCore/Framework/interface/ESHandle.h"
+#include "FWCore/Framework/interface/ConsumesCollector.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h" 
+#include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
+#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
+
+#include "DataFormats/RecoCandidate/interface/RecoEcalCandidate.h"
+#include "DataFormats/RecoCandidate/interface/RecoEcalCandidateFwd.h"
+#include "DataFormats/RecoCandidate/interface/RecoEcalCandidateIsolation.h"
+
+#include "HLTrigger/HLTcore/interface/defaultModuleLabel.h"
+
+namespace {
+  template<typename T> edm::Handle<T> getHandle(const edm::Event& event,const edm::EDGetTokenT<T>& token)
+  {
+    edm::Handle<T> handle;
+    event.getByToken(token,handle);
+    return handle;
+  }
+
+}
+
+template <typename OutCollType>
+class EgammaHLTFilteredObjProducer : public edm::stream::EDProducer<>{
+public:  
+  class SelectionCut {
+  public:
+    SelectionCut(const edm::ParameterSet& pset,edm::ConsumesCollector && iC):
+      ebCut_(pset.getParameter<edm::ParameterSet>("barrelCut")),
+      eeCut_(pset.getParameter<edm::ParameterSet>("endcapCut")),
+      varToken_(iC.consumes<reco::RecoEcalCandidateIsolationMap>(pset.getParameter<edm::InputTag>("var")))
+    {}
+
+    ~SelectionCut()=default;
+
+    bool operator()(const reco::RecoEcalCandidateRef& cand)const{
+      CutValues cut = std::abs(cand->eta())<1.479 ? ebCut_ : eeCut_;
+      return cut(*cand,getVar(cand));
+    }
+
+    float getVar(const reco::RecoEcalCandidateRef& cand)const{ 
+      auto res = varHandle_->find(cand);
+      if(res!=varHandle_->end()) return res->val;
+      else{
+	//FIX ME: add some provenance info to this
+	throw cms::Exception("LogicError") <<" candidate not found in collection ";
+      }
+    }
+
+    void getHandles(const edm::Event& event){
+      event.getByToken(varToken_,varHandle_);
+    }
+  private:
+    struct CutValues {
+      float cut;
+      float cutOverE;
+      float cutOverE2;
+      bool useEt;
+      std::function<bool(float,float)> compFunc;
+
+      CutValues(const edm::ParameterSet& pset):
+	cut(pset.getParameter<double>("cut")),
+	cutOverE(pset.getParameter<double>("cutOverE")),
+	cutOverE2(pset.getParameter<double>("cutOverE2")),
+	useEt(pset.getParameter<bool>("useEt")),
+	compFunc(std::less<float>()) {}
+
+      bool operator()(const reco::RecoEcalCandidate& cand,float value)const{
+	if(compFunc(value,cut)) return true;
+	else{
+	  float energyInv = useEt ? 1./cand.et() : 1./cand.energy();
+	  return  compFunc(value*energyInv,cutOverE) || 
+	    compFunc(value*energyInv*energyInv,cutOverE2);
+	}
+      }
+    };
+
+    CutValues ebCut_;
+    CutValues eeCut_;
+    edm::EDGetTokenT<reco::RecoEcalCandidateIsolationMap> varToken_;
+    edm::Handle<reco::RecoEcalCandidateIsolationMap> varHandle_;
+  };
+
+  explicit EgammaHLTFilteredObjProducer(const edm::ParameterSet& pset);
+  ~EgammaHLTFilteredObjProducer() override =default;
+  static void fillDescriptions(edm::ConfigurationDescriptions & descriptions);
+
+  void produce(edm::Event&, const edm::EventSetup&) override;    
+
+private:
+  //different collection types may need to specialise this function
+  //eg if you wanted superclusters it would output.push_back(cand->superCluster())
+  static void addObj(const reco::RecoEcalCandidateRef& cand,OutCollType& output){
+    output.push_back(cand);
+  }
+
+  edm::EDGetTokenT<reco::RecoEcalCandidateCollection> candsToken_;
+  std::vector<SelectionCut> cuts_;
+};
+
+
+template<typename OutCollType>
+EgammaHLTFilteredObjProducer<OutCollType>::
+EgammaHLTFilteredObjProducer(const edm::ParameterSet& pset):
+  candsToken_(consumes<reco::RecoEcalCandidateCollection>(pset.getParameter<edm::InputTag>("cands")))
+{
+  const auto& cutPsets = pset.getParameter<std::vector<edm::ParameterSet> >("cuts");
+  for(auto& cutPset : cutPsets){
+    cuts_.push_back(SelectionCut(cutPset,consumesCollector()));
+  }
+
+  produces<OutCollType>();
+
+}
+
+template<typename OutCollType>
+void EgammaHLTFilteredObjProducer<OutCollType>::
+fillDescriptions(edm::ConfigurationDescriptions & descriptions)
+{
+  edm::ParameterSetDescription desc;
+  desc.add<edm::InputTag>("cands",edm::InputTag("hltEgammaCandidates"));
+
+  edm::ParameterSetDescription cutsDesc;
+  edm::ParameterSetDescription regionCutsDesc;
+  regionCutsDesc.add<double>("cut",-1);
+  regionCutsDesc.add<double>("cutOverE",-1);
+  regionCutsDesc.add<double>("cutOverE2",-1);
+  regionCutsDesc.add<bool>("useEt",false);
+  edm::ParameterSet cutDefaults;
+  cutDefaults.addParameter<double>("cutOverE",0.2);
+  cutDefaults.addParameter<double>("useEt",false);
+
+  cutsDesc.add<edm::ParameterSetDescription>("barrelCut",regionCutsDesc);
+  cutsDesc.add<edm::ParameterSetDescription>("endcapCut",regionCutsDesc);
+  cutsDesc.add<edm::InputTag>("var",edm::InputTag("hltEgammaHoverE"));
+
+  edm::ParameterSet defaults;
+  defaults.addParameter<edm::InputTag>("var",edm::InputTag("hltEgammaHoverE"));
+  defaults.addParameter<edm::ParameterSet>("barrelCut",cutDefaults);
+  defaults.addParameter<edm::ParameterSet>("endcapCut",cutDefaults);
+  desc.addVPSet("cuts",cutsDesc,std::vector<edm::ParameterSet>{defaults});
+  descriptions.add(defaultModuleLabel<EgammaHLTFilteredObjProducer<OutCollType>>(),desc);
+}
+
+template<typename OutCollType>
+void EgammaHLTFilteredObjProducer<OutCollType>::
+produce(edm::Event& iEvent, const edm::EventSetup& iSetup) 
+{
+  for(auto& cut : cuts_) cut.getHandles(iEvent);
+  auto candsHandle = getHandle(iEvent,candsToken_);
+
+  auto output = std::make_unique<OutCollType>();
+
+  for(size_t candNr=0;candNr<candsHandle->size();candNr++){
+    reco::RecoEcalCandidateRef candRef(candsHandle,candNr);
+    bool passAllCuts=true;
+    for(const auto& cut: cuts_){
+      if(!cut(candRef)){
+	passAllCuts=false;
+	break;
+      }
+    }
+    if(passAllCuts) addObj(candRef,*output);
+  }
+
+  iEvent.put(std::move(output));
+}
+
+#endif

RecoEgamma/EgammaHLTProducers/src/EgammaHLTFilteredEcalCandProducer.cc

@@ -0,0 +1,26 @@
+
+#include "RecoEgamma/EgammaHLTProducers/interface/EgammaHLTFilteredObjProducer.h"
+#include "DataFormats/Common/interface/Ptr.h"
+#include "DataFormats/Common/interface/RefToPtr.h"
+
+template<>
+void EgammaHLTFilteredObjProducer<reco::RecoEcalCandidateCollection>::
+addObj(const reco::RecoEcalCandidateRef& cand, reco::RecoEcalCandidateCollection& output)
+{
+  output.push_back(*cand);
+}
+
+using EgammaHLTFilteredEcalCandProducer=EgammaHLTFilteredObjProducer<reco::RecoEcalCandidateCollection>;
+DEFINE_FWK_MODULE(EgammaHLTFilteredEcalCandProducer);
+
+
+template<>
+void EgammaHLTFilteredObjProducer<std::vector<edm::Ptr<reco::Candidate> > >::
+addObj(const reco::RecoEcalCandidateRef& cand, std::vector<edm::Ptr<reco::Candidate> >& output)
+{
+  output.push_back(edm::refToPtr(cand));
+}
+
+using EgammaHLTFilteredEcalCandPtrProducer=EgammaHLTFilteredObjProducer<std::vector<edm::Ptr<reco::Candidate> > >;
+DEFINE_FWK_MODULE(EgammaHLTFilteredEcalCandPtrProducer);
+