Heppy 7 4 4 patch4

PhysicsTools/Heppy/python/analyzers/core/AutoHandle.py

@@ -7,22 +7,24 @@ class AutoHandle( Handle, object ):
 
     handles = {}
 
-    def __init__(self, label, type, mayFail=False, fallbackLabel=None):
+    def __init__(self, label, type, mayFail=False, fallbackLabel=None, lazy=True):
         '''Note: label can be a tuple : (module_label, collection_label, process)'''
         self.label = label
         self.fallbackLabel = fallbackLabel
         self.type = type
         self.mayFail = mayFail
+        self.lazy = lazy
         Handle.__init__(self, self.type)
     def product(self):
-	if not self.isLoaded :
-		self.ReallyLoad(self.event)
-		self.isLoaded=True
-	return super(AutoHandle,self).product()
+        if not self.isLoaded :
+                self.ReallyLoad(self.event)
+                self.isLoaded=True
+        return super(AutoHandle,self).product()
 
     def Load(self, event):  #is actually a reset state
-	self.event=event
- 	self.isLoaded=False
+        self.event=event
+        self.isLoaded=False
+        if self.lazy==False: self.ReallyLoad(self.event)
 
     def ReallyLoad(self, event):
         '''Load self from a given event.

PhysicsTools/Heppy/python/analyzers/gen/GeneratorAnalyzer.py

@@ -45,6 +45,9 @@ class GeneratorAnalyzer( Analyzer ):
        event.genwzquarks and event.genbquarks, might have overlaps 
        event.genbquarksFromTop and event.genbquarksFromH are all contained in event.genbquarks
 
+       In addition to genParticles, if makeLHEweights is set to True, the list WeightsInfo objects of the LHE branch
+       is stored in event.LHE_weights
+
        """
 
     def __init__(self, cfg_ana, cfg_comp, looperName ):
@@ -54,10 +57,13 @@ def __init__(self, cfg_ana, cfg_comp, looperName ):
         self.makeAllGenParticles   = cfg_ana.makeAllGenParticles
         self.makeSplittedGenLists  = cfg_ana.makeSplittedGenLists
         self.allGenTaus            = cfg_ana.allGenTaus if self.makeSplittedGenLists else False
+	self.makeLHEweights  = cfg_ana.makeLHEweights
 
     def declareHandles(self):
         super(GeneratorAnalyzer, self).declareHandles()
         self.mchandles['genParticles'] = AutoHandle( 'prunedGenParticles', 'std::vector<reco::GenParticle>' )
+	if self.makeLHEweights:
+		self.mchandles['LHEweights'] = AutoHandle( 'source', 'LHEEventProduct', mayFail = True, lazy = False )
 
     def beginLoop(self,setup):
         super(GeneratorAnalyzer,self).beginLoop(setup)
@@ -239,6 +245,13 @@ def makeMCInfo(self, event):
                 if id <= 5 and any([abs(m.pdgId()) in {23,24} for m in realGenMothers(p)]):
                     event.genwzquarks.append(p)
 
+        #Add LHE weight info
+	event.LHE_weights = []
+	if self.makeLHEweights:
+	    if self.mchandles['LHEweights'].isValid():
+	    	for w in self.mchandles['LHEweights'].product().weights():
+	        	event.LHE_weights.append(w)
+
     def process(self, event):
         self.readCollections( event.input )
 
@@ -263,6 +276,8 @@ def process(self, event):
         # Make also the splitted lists
         makeSplittedGenLists = True,
         allGenTaus = False, 
+        # Save LHE weights in LHEEventProduct
+        makeLHEweights = True,
         # Print out debug information
         verbose = False,
     )

PhysicsTools/Heppy/python/analyzers/objects/JetAnalyzer.py

@@ -70,7 +70,8 @@ def __init__(self, cfg_ana, cfg_comp, looperName):
         self.lepSelCut = getattr(self.cfg_ana, 'lepSelCut', lambda lep : True)
         self.jetGammaDR =  getattr(self.cfg_ana, 'jetGammaDR', 0.4)
         if(self.cfg_ana.doQG):
-            self.qglcalc = QGLikelihoodCalculator("%s/src/PhysicsTools/Heppy/data/pdfQG_AK4chs_antib_13TeV_v1.root" % os.environ['CMSSW_BASE'])
+            qgdefname="{CMSSW_BASE}/src/PhysicsTools/Heppy/data/pdfQG_AK4chs_antib_13TeV_v1.root"
+            self.qglcalc = QGLikelihoodCalculator(getattr(self.cfg_ana,"QGpath",qgdefname).format(CMSSW_BASE= os.environ['CMSSW_BASE']))
         if not hasattr(self.cfg_ana ,"collectionPostFix"):self.cfg_ana.collectionPostFix=""
 
     def declareHandles(self):

PhysicsTools/Heppy/python/analyzers/objects/LeptonAnalyzer.py

@@ -335,6 +335,9 @@ def makeAllElectrons(self, event):
                  ele.tightIdResult = ele.electronID("POG_MVA_ID_Trig_full5x5")
             elif self.cfg_ana.ele_tightId=="Cuts_2012" :
                  ele.tightIdResult = -1 + 1*ele.electronID("POG_Cuts_ID_2012_Veto_full5x5") + 1*ele.electronID("POG_Cuts_ID_2012_Loose_full5x5") + 1*ele.electronID("POG_Cuts_ID_2012_Medium_full5x5") + 1*ele.electronID("POG_Cuts_ID_2012_Tight_full5x5")
+            elif self.cfg_ana.ele_tightId=="Cuts_PHYS14_25ns_v1_ConvVetoDxyDz" :
+                 ele.tightIdResult = -1 + 1*ele.electronID("POG_Cuts_ID_PHYS14_25ns_v1_ConvVetoDxyDz_Veto_full5x5") + 1*ele.electronID("POG_Cuts_ID_PHYS14_25ns_v1_ConvVetoDxyDz_Loose_full5x5") + 1*ele.electronID("POG_Cuts_ID_PHYS14_25ns_v1_ConvVetoDxyDz_Medium_full5x5") + 1*ele.electronID("POG_Cuts_ID_PHYS14_25ns_v1_ConvVetoDxyDz_Tight_full5x5")
+
             else :
                  try:
                      ele.tightIdResult = ele.electronID(self.cfg_ana.ele_tightId)
@@ -349,7 +352,10 @@ def attachMiniIsolation(self, mu):
         # -- version with increasing cone at low pT, gives slightly better performance for tight cuts and low pt leptons
         # mu.miniIsoR = 10.0/min(max(mu.pt(), 50),200) if mu.pt() > 20 else 4.0/min(max(mu.pt(),10),20) 
         what = "mu" if (abs(mu.pdgId()) == 13) else ("eleB" if mu.isEB() else "eleE")
-        mu.miniAbsIsoCharged = self.IsolationComputer.chargedAbsIso(mu.physObj, mu.miniIsoR, {"mu":0.0001,"eleB":0,"eleE":0.015}[what], 0.0);
+        if what == "mu":
+            mu.miniAbsIsoCharged = self.IsolationComputer.chargedAbsIso(mu.physObj, mu.miniIsoR, {"mu":0.0001,"eleB":0,"eleE":0.015}[what], 0.0);
+        else:
+            mu.miniAbsIsoCharged = self.IsolationComputer.chargedAbsIso(mu.physObj, mu.miniIsoR, {"mu":0.0001,"eleB":0,"eleE":0.015}[what], 0.0,self.IsolationComputer.selfVetoNone);
         if self.miniIsolationPUCorr == "weights":
             if what == "mu":
                 mu.miniAbsIsoNeutral = self.IsolationComputer.neutralAbsIsoWeighted(mu.physObj, mu.miniIsoR, 0.01, 0.5);
@@ -373,7 +379,7 @@ def attachMiniIsolation(self, mu):
                 if what == "mu":
                     mu.miniAbsIsoPU = self.IsolationComputer.puAbsIso(mu.physObj, mu.miniIsoR, 0.01, 0.5);
                 else:
-                    mu.miniAbsIsoPU = self.IsolationComputer.puAbsIso(mu.physObj, mu.miniIsoR, 0.015 if what == "eleE" else 0.0, 0.0);
+                    mu.miniAbsIsoPU = self.IsolationComputer.puAbsIso(mu.physObj, mu.miniIsoR, 0.015 if what == "eleE" else 0.0, 0.0,self.IsolationComputer.selfVetoNone);
                 mu.miniAbsIsoNeutral = max(0.0, mu.miniAbsIsoNeutral - 0.5*mu.miniAbsIsoPU)
             elif self.miniIsolationPUCorr != 'raw':
                 raise RuntimeError, "Unsupported miniIsolationCorr name '" + str(self.cfg_ana.miniIsolationCorr) +  "'! For now only 'rhoArea', 'deltaBeta', 'raw', 'weights' are supported (and 'weights' is not tested)."
@@ -473,6 +479,7 @@ def process(self, event):
     loose_muon_dxy    = 0.05,
     loose_muon_dz     = 0.2,
     loose_muon_relIso = 0.4,
+    # loose_muon_isoCut = lambda muon :muon.miniRelIso < 0.2 
     # inclusive very loose electron selection
     inclusive_electron_id  = "",
     inclusive_electron_pt  = 5,
@@ -487,6 +494,7 @@ def process(self, event):
     loose_electron_dxy    = 0.05,
     loose_electron_dz     = 0.2,
     loose_electron_relIso = 0.4,
+    # loose_electron_isoCut = lambda electron : electron.miniRelIso < 0.1
     loose_electron_lostHits = 1.0,
     # muon isolation correction method (can be "rhoArea" or "deltaBeta")
     mu_isoCorr = "rhoArea" ,

PhysicsTools/Heppy/python/analyzers/objects/TauAnalyzer.py

@@ -20,54 +20,53 @@ def declareHandles(self):
         super(TauAnalyzer, self).declareHandles()
         self.handles['taus'] = AutoHandle( ('slimmedTaus',''),'std::vector<pat::Tau>')
 
-
     def beginLoop(self, setup):
         super(TauAnalyzer,self).beginLoop(setup)
         self.counters.addCounter('events')
         count = self.counters.counter('events')
         count.register('all events')
         count.register('has >=1 tau at preselection')
         count.register('has >=1 selected taus')
-        count.register('has >=1 loose taus')
-        count.register('has >=1 inclusive taus')
+        count.register('has >=1 other taus')
 
     #------------------
     # MAKE LEPTON LISTS
     #------------------
     def makeTaus(self, event):
-        event.selectedTaus = []
-        event.looseTaus = []
         event.inclusiveTaus = []
+        event.selectedTaus = []
+        event.otherTaus = []
 
         #get all
         alltaus = map( Tau, self.handles['taus'].product() )
 
-        foundTau = False
+        #make inclusive taus
         for tau in alltaus:
             tau.associatedVertex = event.goodVertices[0] if len(event.goodVertices)>0 else event.vertices[0]
             tau.lepVeto = False
             tau.idDecayMode = tau.tauID("decayModeFinding")
             tau.idDecayModeNewDMs = tau.tauID("decayModeFindingNewDMs")
-            if hasattr(self.cfg_ana, 'decayModeID') and self.cfg_ana.decayModeID and not tau.tauID(self.cfg_ana.decayModeID):
+
+            if hasattr(self.cfg_ana, 'inclusive_decayModeID') and self.cfg_ana.inclusive_decayModeID and not tau.tauID(self.cfg_ana.inclusive_decayModeID):
                 continue
 
-            if self.cfg_ana.vetoLeptons:
+            tau.inclusive_lepVeto = False
+            if self.cfg_ana.inclusive_vetoLeptons:
                 for lep in event.selectedLeptons:
-                    if deltaR(lep.eta(), lep.phi(), tau.eta(), tau.phi()) < self.cfg_ana.leptonVetoDR:
-                        tau.lepVeto = True
-                if tau.lepVeto: continue
-            if self.cfg_ana.vetoLeptonsPOG:
-                if not tau.tauID(self.cfg_ana.tauAntiMuonID):
-                        tau.lepVeto = True
-                if not tau.tauID(self.cfg_ana.tauAntiElectronID):
-                        tau.lepVeto = True
-                if tau.lepVeto: continue
-
-            if tau.pt() < self.cfg_ana.ptMin: continue
-            if abs(tau.eta()) > self.cfg_ana.etaMax: continue
-            if abs(tau.dxy()) > self.cfg_ana.dxyMax or abs(tau.dz()) > self.cfg_ana.dzMax: continue
-
-            foundTau = True
+                    if deltaR(lep.eta(), lep.phi(), tau.eta(), tau.phi()) < self.cfg_ana.inclusive_leptonVetoDR:
+                        tau.inclusive_lepVeto = True
+                if tau.inclusive_lepVeto: continue
+            if self.cfg_ana.inclusive_vetoLeptonsPOG:
+                if not tau.tauID(self.cfg_ana.inclusive_tauAntiMuonID):
+                        tau.inclusive_lepVeto = True
+                if not tau.tauID(self.cfg_ana.inclusive_tauAntiElectronID):
+                        tau.inclusive_lepVeto = True
+                if tau.inclusive_lepVeto: continue
+
+            if tau.pt() < self.cfg_ana.inclusive_ptMin: continue
+            if abs(tau.eta()) > self.cfg_ana.inclusive_etaMax: continue
+            if abs(tau.dxy()) > self.cfg_ana.inclusive_dxyMax or abs(tau.dz()) > self.cfg_ana.inclusive_dzMax: continue
+
             def id3(tau,X):
                 """Create an integer equal to 1-2-3 for (loose,medium,tight)"""
                 return tau.tauID(X%"Loose") + tau.tauID(X%"Medium") + tau.tauID(X%"Tight")
@@ -86,28 +85,44 @@ def id6(tau,X):
             tau.idAntiMu = tau.tauID("againstMuonLoose") + tau.tauID("againstMuonTight")
             tau.idAntiE = id5(tau, "againstElectron%sMVA5")
             #print "Tau pt %5.1f: idMVA2 %d, idCI3hit %d, %s, %s" % (tau.pt(), tau.idMVA2, tau.idCI3hit, tau.tauID(self.cfg_ana.tauID), tau.tauID(self.cfg_ana.tauLooseID))
-            if tau.tauID(self.cfg_ana.tauID):
-                event.selectedTaus.append(tau)
-                event.inclusiveTaus.append(tau)
-            elif tau.tauID(self.cfg_ana.tauLooseID):
-                event.looseTaus.append(tau)
+
+            if tau.tauID(self.cfg_ana.inclusive_tauID):
                 event.inclusiveTaus.append(tau)
+
+        for tau in event.inclusiveTaus:
 
+            tau.loose_lepVeto = False
+            if self.cfg_ana.loose_vetoLeptons:
+                for lep in event.selectedLeptons:
+                    if deltaR(lep.eta(), lep.phi(), tau.eta(), tau.phi()) < self.cfg_ana.loose_leptonVetoDR:
+                        tau.loose_lepVeto = True
+            if self.cfg_ana.loose_vetoLeptonsPOG:
+                if not tau.tauID(self.cfg_ana.loose_tauAntiMuonID):
+                        tau.loose_lepVeto = True
+                if not tau.tauID(self.cfg_ana.loose_tauAntiElectronID):
+                        tau.loose_lepVeto = True
+
+            if tau.tauID(self.cfg_ana.loose_decayModeID) and \
+                      tau.pt() > self.cfg_ana.loose_ptMin and abs(tau.eta()) < self.cfg_ana.loose_etaMax and \
+                      abs(tau.dxy()) < self.cfg_ana.loose_dxyMax and abs(tau.dz()) < self.cfg_ana.loose_dzMax and \
+                      tau.tauID(self.cfg_ana.loose_tauID) and not tau.loose_lepVeto:
+                event.selectedTaus.append(tau)
+            else:
+                event.otherTaus.append(tau)
+
+        event.inclusiveTaus.sort(key = lambda l : l.pt(), reverse = True)        
         event.selectedTaus.sort(key = lambda l : l.pt(), reverse = True)
-        event.looseTaus.sort(key = lambda l : l.pt(), reverse = True)
+        event.otherTaus.sort(key = lambda l : l.pt(), reverse = True)
         self.counters.counter('events').inc('all events')
-        if foundTau: self.counters.counter('events').inc('has >=1 tau at preselection')
+        if len(event.inclusiveTaus): self.counters.counter('events').inc('has >=1 tau at preselection')
         if len(event.selectedTaus): self.counters.counter('events').inc('has >=1 selected taus')
-        if len(event.looseTaus): self.counters.counter('events').inc('has >=1 loose taus')
-        if len(event.inclusiveTaus): self.counters.counter('events').inc('has >=1 inclusive taus')
-
+        if len(event.otherTaus): self.counters.counter('events').inc('has >=1 other taus')
 
     def matchTaus(self, event):
         match = matchObjectCollection3(event.inclusiveTaus, event.gentaus, deltaRMax = 0.5)
         for lep in event.inclusiveTaus:
             gen = match[lep]
             lep.mcMatchId = 1 if gen else 0
-            lep.mcTau = gen
 
     def process(self, event):
         self.readCollections( event.input )
@@ -126,18 +141,31 @@ def process(self, event):
 # http://cmslxr.fnal.gov/lxr/source/PhysicsTools/PatAlgos/python/producersLayer1/tauProducer_cfi.py
 
 setattr(TauAnalyzer,"defaultConfig",cfg.Analyzer(
-    class_object=TauAnalyzer,
-    ptMin = 20,
-    etaMax = 9999,
-    dxyMax = 1000.,
-    dzMax = 0.2,
-    vetoLeptons = True,
-    leptonVetoDR = 0.4,
-    decayModeID = "decayModeFindingNewDMs", # ignored if not set or ""
-    tauID = "byLooseCombinedIsolationDeltaBetaCorr3Hits",
-    vetoLeptonsPOG = False, # If True, the following two IDs are required
-    tauAntiMuonID = "againstMuonLoose3",
-    tauAntiElectronID = "againstElectronLooseMVA5",
-    tauLooseID = "decayModeFinding",
+    class_object = TauAnalyzer,
+    # inclusive very loose hadronic tau selection
+    inclusive_ptMin = 18,
+    inclusive_etaMax = 9999,
+    inclusive_dxyMax = 1000.,
+    inclusive_dzMax = 0.4,
+    inclusive_vetoLeptons = False,
+    inclusive_leptonVetoDR = 0.4,
+    inclusive_decayModeID = "decayModeFindingNewDMs", # ignored if not set or ""
+    inclusive_tauID = "decayModeFindingNewDMs",
+    inclusive_vetoLeptonsPOG = False, # If True, the following two IDs are required
+    inclusive_tauAntiMuonID = "",
+    inclusive_tauAntiElectronID = "",
+    # loose hadronic tau selection
+    loose_ptMin = 18,
+    loose_etaMax = 9999,
+    loose_dxyMax = 1000.,
+    loose_dzMax = 0.2,
+    loose_vetoLeptons = True,
+    loose_leptonVetoDR = 0.4,
+    loose_decayModeID = "decayModeFindingNewDMs", # ignored if not set or ""
+    loose_tauID = "byLooseCombinedIsolationDeltaBetaCorr3Hits",
+    loose_vetoLeptonsPOG = False, # If True, the following two IDs are required
+    loose_tauAntiMuonID = "againstMuonLoose3",
+    loose_tauAntiElectronID = "againstElectronLooseMVA5",
+    loose_tauLooseID = "decayModeFindingNewDMs"
   )
 )