trying to match L1 objects

plugins/MiniAODL1Stage2CandProducer.cc

@@ -0,0 +1,14 @@
+#include "MiniAODL1Stage2CandProducer.h"
+
+#include "DataFormats/PatCandidates/interface/Electron.h"
+#include "DataFormats/PatCandidates/interface/Photon.h"
+
+typedef MiniAODL1Stage2CandProducer<pat::Electron> PatElectronL1Stage2CandProducer;
+DEFINE_FWK_MODULE(PatElectronL1Stage2CandProducer);
+
+typedef MiniAODL1Stage2CandProducer<reco::GsfElectron> GsfElectronL1Stage2CandProducer;
+DEFINE_FWK_MODULE(GsfElectronL1Stage2CandProducer);
+
+//typedef MiniAODL1CandProducer<pat::Photon> PatPhotonL1CandProducer;
+//DEFINE_FWK_MODULE(PatPhotonL1CandProducer);
+

plugins/MiniAODL1Stage2CandProducer.h

@@ -0,0 +1,136 @@
+#ifndef _MINIADOL1STAGE2CANDPRODUCER_H_
+#define _MINIADOL1STAGE2CANDPRODUCER_H_
+
+#include "FWCore/Framework/interface/Frameworkfwd.h"
+#include "FWCore/Framework/interface/Event.h"
+#include "FWCore/Framework/interface/MakerMacros.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/Framework/interface/EDProducer.h"
+
+//#include "DataFormats/L1Trigger/interface/L1EmParticle.h"                                                                                                          
+//#include "DataFormats/L1Trigger/interface/L1EmParticleFwd.h"                                                                                                       
+#include "DataFormats/L1Trigger/interface/EGamma.h" //for stage 2 L1                                                                                                 
+#include <DataFormats/Math/interface/deltaR.h>
+
+#include "FWCore/MessageLogger/interface/MessageLogger.h"
+
+#include <string>
+#include <vector>
+
+template <class T>
+class MiniAODL1Stage2CandProducer : public edm::EDProducer {
+
+  typedef std::vector<T> TCollection;
+  typedef edm::Ref<TCollection> TRef;
+  typedef edm::RefVector<TCollection> TRefVector;
+
+ public:
+  MiniAODL1Stage2CandProducer(const edm::ParameterSet&);
+  ~MiniAODL1Stage2CandProducer();
+
+  bool l1OfflineMatching(const std::vector<l1t::EGamma>& triggerObjects,
+                         math::XYZTLorentzVector refP4, float dRmin, float dRminEE, int& index);
+ private:
+  /// compare two l1Extra in et                                                                                                                                      
+  struct ComparePt {
+    bool operator()( const l1t::EGamma& t1, const l1t::EGamma& t2 ) const {
+      return t1.et() > t2.et();
+    }
+  };
+  ComparePt ptComparator;
+
+  virtual void produce(edm::Event&, const edm::EventSetup&) override;
+
+  edm::EDGetTokenT<TRefVector> inputs_;
+  edm::EDGetTokenT<l1t::EGammaBxCollection> l1ObjectsToken_;
+  float minET_;
+  float dRMatch_;
+  float dRMatchEE_;
+
+};
+
+template <class T>
+MiniAODL1Stage2CandProducer<T>::MiniAODL1Stage2CandProducer(const edm::ParameterSet& iConfig ) :
+
+
+  inputs_(consumes<TRefVector>(iConfig.getParameter<edm::InputTag>("inputs"))),
+  l1ObjectsToken_(consumes<l1t::EGammaBxCollection> ( iConfig.getParameter<edm::InputTag>("objects"))),
+  minET_(iConfig.getParameter<double>("minET")),
+  dRMatch_(iConfig.getParameter<double>("dRmatch"))
+{
+   std::cout << "!!!!!!!!!!!!!!!!!!!!" << std::endl;
+  if(iConfig.exists("dRmatchEE"))
+    dRMatchEE_ = (iConfig.getParameter<double>("dRmatchEE"));
+  else
+    dRMatchEE_ = dRMatch_; //for backwards compatibility
+
+  produces<TRefVector>();
+}
+
+template <class T>
+MiniAODL1Stage2CandProducer<T>::~MiniAODL1Stage2CandProducer()
+{}
+
+template <class T>
+void MiniAODL1Stage2CandProducer<T>::produce(edm::Event &iEvent, const edm::EventSetup &eventSetup) {
+
+  cout <<"1" <<endl;
+  edm::Handle<l1t::EGammaBxCollection> l1ObjectsH;
+  edm::Handle<TRefVector> inputs;
+
+  iEvent.getByToken(l1ObjectsToken_, l1ObjectsH);
+  iEvent.getByToken(inputs_, inputs);
+  cout <<"2" <<endl;
+   //Merge L1 objects and sort by et                                                                                                                                  
+  std::vector<l1t::EGamma> mergedL1;
+  for(auto it=l1ObjectsH->begin(0); it!=l1ObjectsH->end(0); it++){
+    mergedL1.push_back(*it);
+    // std::cout << "L1: "  << endl;
+  }
+  cout <<"3" <<endl;
+  std::sort(mergedL1.begin(), mergedL1.end(), ptComparator);
+
+  // Create the output collection                                                                                                                                    
+  // std::auto_ptr<TRefVector> outColRef(new TRefVector);
+  std::unique_ptr<TRefVector> outColRef(new TRefVector);
+  cout <<"4" <<endl;
+  for (size_t i=0; i<inputs->size(); i++) {
+    TRef ref = (*inputs)[i];
+    int index = -1;
+
+    if (l1OfflineMatching(mergedL1, ref->p4(), dRMatch_, dRMatchEE_, index)) {
+      outColRef->push_back(ref);
+    }
+  }
+  cout <<"5" <<endl;
+  //iEvent.put(outColRef);
+  iEvent.put(std::move(outColRef));
+}
+
+template <class T>
+bool MiniAODL1Stage2CandProducer<T>::l1OfflineMatching(const std::vector<l1t::EGamma>& l1Objects,
+						       math::XYZTLorentzVector refP4, float dRmin, float dRminEE, int& index) {
+
+  cout <<"a" <<endl;
+  index = 0;
+  //for (auto it=l1Objects.begin(0); it != l1Objects.end(0); it++) { //bx 0 only considered 
+  for (auto it=l1Objects.begin(); it != l1Objects.end(); it++) {
+    if (it->et() < minET_)
+      continue;
+     cout <<"b" <<endl;
+    float dR = deltaR(refP4, it->p4());
+    if(fabs(refP4.eta()) < 1.5)
+      if (dR < dRmin)
+	return true;
+    if(dR < dRminEE) //allow for looser requirements in EE (not needed for stage2)
+      return true;
+    index++;
+  }
+
+  return false;
+  cout <<"c" <<endl;
+}
+
+
+#endif
+

plugins/MiniAODStage2L1CandProducer.cc

@@ -0,0 +1,11 @@
+#include "MiniAODL1CandProducer.h"
+
+#include "DataFormats/PatCandidates/interface/Electron.h"
+#include "DataFormats/PatCandidates/interface/Photon.h"
+
+typedef MiniAODL1CandProducer<pat::Electron> PatElectronL1CandProducer;
+DEFINE_FWK_MODULE(PatElectronL1CandProducer);
+
+typedef MiniAODL1CandProducer<pat::Photon> PatPhotonL1CandProducer;
+DEFINE_FWK_MODULE(PatPhotonL1CandProducer);
+

python/egmGoodParticlesDef_cff.py

@@ -77,6 +77,12 @@ def setGoodParticlesMiniAOD(process, options):
                                          src = cms.InputTag( options['ELECTRON_COLL'] ),
                                          cut = cms.string(   options['ELECTRON_CUTS'] ),
                                          )
+
+
+    process.goodElectronsL1 = cms.EDFilter("PATElectronRefSelector",
+                                         src = cms.InputTag( options['ELECTRON_COLL'] ),
+                                         cut = cms.string(   options['ELECTRON_CUTS'] ),
+                                         )
 
     ####################  Photon collection
     process.goodPhotons   =  cms.EDFilter("PATPhotonRefSelector",
@@ -154,6 +160,13 @@ def setGoodParticlesAOD(process, options):
                                          cut = cms.string(options['ELECTRON_CUTS'])
                                          )
 
+
+    process.goodElectronsL1 = cms.EDFilter("GsfElectronRefSelector",
+                                         src = cms.InputTag( options['ELECTRON_COLL'] ),
+                                         cut = cms.string(   options['ELECTRON_CUTS'] ),
+                                         )
+
+
     ####################  Photon collection
     ### dummy in AOD (use miniAOD for photons)
     process.goodPhotons    =  cms.EDFilter("PhotonRefSelector",

python/egmTreesSetup_cff.py

@@ -37,18 +37,47 @@ def setTagsProbes(process, options):
                                     )
 
     ##################### PROBE ELECTRONs ###########################
+    # process.probeEle             = process.tagEle.clone()
+    # process.probeEle.filterNames = cms.vstring(options['TnPHLTProbeFilters'])
+    # process.probeEle.inputs      = cms.InputTag("goodElectrons")
+
+
+
+
+    ######added by me
+    ################# PROBE Matched to L1 #######################
+
+    process.goodElectronProbesL1 = cms.EDProducer("PatElectronL1Stage2CandProducer",
+    #process.goodElectronProbesL1 = cms.EDProducer("GsfElectronL1Stage2CandProducer",
+                                                inputs = cms.InputTag("goodElectrons"),
+                                                #isoObjects = cms.InputTag("l1extraParticles:Isolated"),
+                                                #nonIsoObjects = cms.InputTag("l1extraParticles:NonIsolated"),
+                                                #objects = cms.InputTag("hltCaloStage2Digis:EGamma"),
+                                                objects = cms.InputTag("caloStage2Digis:EGamma"),
+                                                minET = cms.double(23), #lead eff only
+                                                #minET = cms.double(14), #sublead eff only
+                                                #minET = cms.double(0.), #test on how L1 efficiency with the whole big OR changes vs time
+                                                dRmatch = cms.double(0.2), #defined to match L1 online matching to hlt (0.261)
+                                                dRmatchEE = cms.double(0.2), #defined to match L1 online matching to hlt (should probably be tightened for stage2)
+                                                isolatedOnly = cms.bool(False)
+    )
+
+
     process.probeEle             = process.tagEle.clone()
     process.probeEle.filterNames = cms.vstring(options['TnPHLTProbeFilters'])
-    process.probeEle.inputs      = cms.InputTag("goodElectrons")  
+    process.probeEle.inputs      = cms.InputTag("goodElectronProbesL1")  
 
+
     ################# PROBE ELECTRONs passHLT #######################
+
+
     process.probeElePassHLT              = process.tagEle.clone()
     process.probeElePassHLT.inputs       = cms.InputTag("probeEle")  
     process.probeElePassHLT.isAND        = cms.bool(False)
 
     for flag, filterNames in options['HLTFILTERSTOMEASURE'].iteritems():
-      setattr(process, flag, process.probeElePassHLT.clone(filterNames=filterNames))
-
+        setattr(process, flag, process.probeElePassHLT.clone(filterNames=filterNames))
+        
     ###################### PROBE PHOTONs ############################
     process.probePho  = cms.EDProducer( gamHLTProducer,
                                         filterNames = options['TnPHLTProbeFilters'],
@@ -159,7 +188,7 @@ def setSequences(process, options):
     process.hlt_sequence = cms.Sequence( process.hltFilter )
 
     process.tag_sequence = cms.Sequence(
-        process.goodElectrons             +
+        process.goodElectrons            +
         process.tagEleCutBasedTight       +
         process.tagEle 
         )

scripts/crab/tnpCrabSubmitAOD.py

@@ -6,10 +6,10 @@
 
 doEleTree = 'doEleID=False'
 doPhoTree = 'doPhoID=False'
-doHLTTree = 'doTrigger=False'
+doHLTTree = 'doTrigger=True'
 doRECO    = 'doRECO=True'
 
-mainOutputDir = '/store/group/phys_egamma/tnp/80X/RecoSF/%s' % submitVersion
+#mainOutputDir = '/store/group/phys_egamma/tnp/80X/RecoSF/%s' % submitVersion
 
 config.General.transferLogs = False