diff --git a/CMGTools/RootTools/python/statistics/Tree.py b/CMGTools/RootTools/python/statistics/Tree.py index 0fb6a118c5462..86d783e0f97f3 100644 --- a/CMGTools/RootTools/python/statistics/Tree.py +++ b/CMGTools/RootTools/python/statistics/Tree.py @@ -19,6 +19,7 @@ def shortType(self, type): if ltype.startswith('int'): return 'I' elif ltype.startswith('float'): return 'F' elif ltype.startswith('double'): return 'D' + elif ltype.startswith('bool'): return 'O' else: return None def addVar(self, type, name): @@ -29,7 +30,6 @@ def book(self): for var,type in self.vars.iteritems(): structcode.append('{type} {var};'.format(type=type, var=var)) structcode.append('};') - print structcode gROOT.ProcessLine( ' '.join(structcode) ) from ROOT import struct_name self.s = struct_name() diff --git a/CMGTools/TTHAnalysis/python/analyzers/susyCore_modules_cff.py b/CMGTools/TTHAnalysis/python/analyzers/susyCore_modules_cff.py index b7b67d1700aaa..04cfe8ea74cc2 100644 --- a/CMGTools/TTHAnalysis/python/analyzers/susyCore_modules_cff.py +++ b/CMGTools/TTHAnalysis/python/analyzers/susyCore_modules_cff.py @@ -198,6 +198,7 @@ ttHMetAna = cfg.Analyzer( 'ttHMetEventAnalyzer', doTkMet = False, + doMetNoMu = False, candidates='packedPFCandidates', candidatesTypes='std::vector', dzMax = 0.1, diff --git a/CMGTools/TTHAnalysis/python/analyzers/treeProducerSusyAlphaT.py b/CMGTools/TTHAnalysis/python/analyzers/treeProducerSusyAlphaT.py index 5bc0c8e8cb480..ed84b7efe95ea 100644 --- a/CMGTools/TTHAnalysis/python/analyzers/treeProducerSusyAlphaT.py +++ b/CMGTools/TTHAnalysis/python/analyzers/treeProducerSusyAlphaT.py @@ -3,7 +3,7 @@ class treeProducerSusyAlphaT( treeProducerSusyCore ): #----------------------------------- - # TREE PRODUCER FOR SUSY MULTILEPTONS + # TREE PRODUCER FOR SUSY ALPHAT #----------------------------------- def __init__(self, cfg_ana, cfg_comp, looperName): super(treeProducerSusyAlphaT,self).__init__(cfg_ana, cfg_comp, looperName) @@ -14,60 +14,43 @@ def __init__(self, cfg_ana, cfg_comp, looperName): #NTupleVariable("crossSection", lambda ev : ev.crossSection, help="process cross section in pb"), + #Gen level + NTupleVariable("genBin", lambda ev : ev.genBin, help="Generator level binning quantity"), + NTupleVariable("genQScale", lambda ev : ev.genQScale, help="Generator level binning quantity, QScale"), # Energy sums #---------------------------------------- - NTupleVariable("ht", lambda ev : ev.htJet40j, help="H_{T} computed from only jets (with |eta|<2.5, pt > 40 GeV)"), + NTupleVariable("ht", lambda ev : ev.htJet50j, help="H_{T} computed from only jets (with |eta|<3, pt > 50 GeV)"), NTupleVariable("deltaPhiMin", lambda ev : ev.deltaPhiMin_had, help="minimal deltaPhi between the MET and the four leading jets with pt>40 and eta<2.4"), NTupleVariable("diffMetMht", lambda ev : ev.diffMetMht_had, help="abs( vec(mht) - vec(met) )"), - NTupleVariable("mht_pt", lambda ev : ev.mhtJet40j, help="H_{T}^{miss} computed from only jets (with |eta|<2.5, pt > 40 GeV)"), - NTupleVariable("mht_phi", lambda ev : ev.mhtPhiJet40j, help="H_{T}^{miss} #phi computed from onlyy jets (with |eta|<2.5, pt > 40 GeV)"), + NTupleVariable("mht_pt", lambda ev : ev.mhtJet50j, help="H_{T}^{miss} computed from only jets (with |eta|<3.0, pt > 50 GeV)"), + NTupleVariable("mht_phi", lambda ev : ev.mhtPhiJet50j, help="H_{T}^{miss} #phi computed from onlyy jets (with |eta|<3.0, pt > 50 GeV)"), ##-------------------------------------------------- + NTupleVariable("biasedDPhi", lambda ev : ev.biasedDPhi, help="biased delta phi"), # Physics object multplicities #---------------------------------------- - NTupleVariable("nMuons10", lambda ev: sum([l.pt() > 10 and abs(l.pdgId()) == 13 for l in ev.selectedLeptons]), int, help="Number of muons with pt > 10"), - NTupleVariable("nElectrons10", lambda ev: sum([l.pt() > 10 and abs(l.pdgId()) == 11 for l in ev.selectedLeptons]), int, help="Number of electrons with pt > 10"), + NTupleVariable("nMuons10", lambda ev: sum([l.pt() > 10 and abs(l.pdgId()) == 13 for l in ev.selectedLeptons]), int, help="Number of muons with at least pt > 10"), + NTupleVariable("nElectrons10", lambda ev: sum([l.pt() > 10 and abs(l.pdgId()) == 11 for l in ev.selectedLeptons]), int, help="Number of electrons with at least pt > 10"), NTupleVariable("nTaus20", lambda ev: sum([l.pt() > 20 for l in ev.selectedTaus]), int, help="Number of taus with pt > 20"), - NTupleVariable("nGammas20", lambda ev: sum([l.pt() > 20 for l in ev.selectedPhotons]), int, help="Number of photons with pt > 20"), - NTupleVariable("nBJet40", lambda ev: sum([j.btagWP("CSVM") for j in ev.cleanJets if j.pt() > 40]), int, help="Number of jets with pt > 40 passing CSV medium"), + NTupleVariable("nGammas25", lambda ev: sum([l.pt() > 25 for l in ev.selectedPhotons]), int, help="Number of photons with at least pt > 25"), + NTupleVariable("nBJet50", lambda ev: sum([j.btagWP("CSVM") for j in ev.cleanJets if j.pt() > 50]), int, help="Number of jets with pt > 50 passing CSV medium"), # AlphaT variables #---------------------------------------- - - # NEED TO ADD: - # - M_{T} - # - metcorrected for photon, muon - # - mht/metcorrected - - # NTupleVariable("nJet50", lambda ev: len(ev.cleanJets), int, help="Number of jets with pt > 50, |eta|<3"), - # NTupleVariable("nJetFwd50", lambda ev: len(ev.cleanJetsFwd), int, help="Number of jets with pt > 50, 3<|eta|<5"), - # NTupleVariable("nBJetMedium50", lambda ev: len(ev.bjetsMedium), int, help="Number of jets with pt > 50, |eta|<3 passing CSV medium"), - # NTupleVariable("htJet50", lambda ev: ev.htJet50, help="H_{T} computed from jets (with |eta|<3, pt > 50 GeV)"), - # NTupleVariable("mhtJet50", lambda ev: ev.mhtJet50, help="H_{T}^{miss} computed from jets (with |eta|<3, pt > 50 GeV)"), - # NTupleVariable("mht50OverMet", lambda ev: ev.mht50OverMet,help="H_{T}^{miss}/E_{T}^{miss} computed from jets (with |eta|<3, pt > 50 GeV)"), - NTupleVariable("alphaT", lambda ev: ev.alphaT, help="AlphaT computed using jets with pt > 50, |eta|<3"), - # # NTupleVariable("mT", lambda ev: ev.mT, help="M_{T} computed from lepton and type-1 corrected PFMET"), - # NTupleVariable("mZ1", lambda ev: ev.bestZ1[0], help="Best m(ll) SF/OS"), - # NTupleVariable("pt2l", lambda ev: ev.pt2l, help="p_{T}(ll)"), - # NTupleVariable("m2l", lambda ev: ev.m2l, help="m(ll)"), + # control sample variables ##-------------------------------------------------- - # NTupleVariable("mtw", lambda ev: ev.mtw, int, help="mt(l,met)"), - # NTupleVariable("mtwTau", lambda ev: ev.mtwTau, int, help="mt(tau,met)"), - # NTupleVariable("IsoTrack_mtw", lambda ev: ev.mtwIsoTrack, int, help="mt(isoTrack,met)"), - ##-------------------------------------------------- - # NTupleVariable("minMWjj", lambda ev: ev.minMWjj, int, help="minMWjj"), - # NTupleVariable("minMWjjPt", lambda ev: ev.minMWjjPt, int, help="minMWjjPt"), - # NTupleVariable("bestMWjj", lambda ev: ev.bestMWjj, int, help="bestMWjj"), - # NTupleVariable("bestMWjjPt", lambda ev: ev.bestMWjjPt, int, help="bestMWjjPt"), - # NTupleVariable("bestMTopHad", lambda ev: ev.bestMTopHad, int, help="bestMTopHad"), - # NTupleVariable("bestMTopHadPt", lambda ev: ev.bestMTopHadPt, int, help="bestMTopHadPt"), + NTupleVariable("mtw", lambda ev: ev.mtw, help="mt(l,met)"), + NTupleVariable("mtwTau", lambda ev: ev.mtwTau, help="mt(tau,met)"), + NTupleVariable("IsoTrack_mtw", lambda ev: ev.mtwIsoTrack, help="mt(isoTrack,met)"), + NTupleVariable("mll", lambda ev: ev.mll, help="Invariant mass of the two lead leptons"), + ##-------------------------------------------------- ] @@ -75,6 +58,8 @@ def __init__(self, cfg_ana, cfg_comp, looperName): # put more here # "pseudoJet1" : NTupleObject("pseudoJet1", fourVectorType, help="pseudoJet1 for hemishphere"), # "pseudoJet2" : NTupleObject("pseudoJet2", fourVectorType, help="pseudoJet2 for hemishphere"), + "biasedDPhiJet" : NTupleObject("biasedDPhiJet", fourVectorType, help="jet closest to missing energy vector"), + "metNoMu": NTupleObject("metNoMu",fourVectorType, help="met computed with muom momentum substracted"), }) self.collections.update({ # put more here @@ -83,7 +68,17 @@ def __init__(self, cfg_ana, cfg_comp, looperName): "cleanJetsAll" : NTupleCollection("jet", jetTypeSusy, 100, help="all jets (w/ x-cleaning, w/ ID applied w/o PUID applied pt > 50 |eta| < 3) , sorted by pt", filter=lambda l : l.pt()>50 ), "selectedPhotons" : NTupleCollection("gamma", photonTypeSusy, 50, help="photons with pt > 25 and loose cut based ID"), "selectedIsoTrack" : NTupleCollection("isoTrack", isoTrackType, 50, help="isoTrack, sorted by pt"), + + #Gen collections "genParticles" : NTupleCollection("genPart", genParticleWithMotherId, 200, help="all pruned genparticles"), + "genJets" : NTupleCollection("genJet", genParticleType, 10, help="Generated jets (not cleaned)"), + + # add stuff for testing + "selectedMuons" : NTupleCollection("muon", leptonTypeSusy, 50, help="Muons for testing"), + + # dR jet lep for each lepton + # not putting in for now, maybe in future + #"minDeltaRLepJet" : NTupleCollection("minDeltaRLepJet", double, 50, help="Min deltaR between a lepton and all the jets"), }) ## Book the variables, but only if we're called explicitly and not through a base class diff --git a/CMGTools/TTHAnalysis/python/analyzers/ttHAlphaTControlAnalyzer.py b/CMGTools/TTHAnalysis/python/analyzers/ttHAlphaTControlAnalyzer.py new file mode 100644 index 0000000000000..b14de83a7f1d9 --- /dev/null +++ b/CMGTools/TTHAnalysis/python/analyzers/ttHAlphaTControlAnalyzer.py @@ -0,0 +1,123 @@ +import operator +import itertools +import copy +from math import * + +#from ROOT import TLorentzVector, TVectorD + +from CMGTools.RootTools.fwlite.Analyzer import Analyzer +from CMGTools.RootTools.fwlite.Event import Event +from CMGTools.RootTools.statistics.Counter import Counter, Counters +from CMGTools.RootTools.fwlite.AutoHandle import AutoHandle +# from CMGTools.RootTools.physicsobjects.Lepton import Lepton +# from CMGTools.RootTools.physicsobjects.Photon import Photon +# from CMGTools.RootTools.physicsobjects.Electron import Electron +# from CMGTools.RootTools.physicsobjects.Muon import Muon +# from CMGTools.RootTools.physicsobjects.Tau import Tau +from CMGTools.RootTools.physicsobjects.Jet import Jet + +from CMGTools.RootTools.utils.DeltaR import deltaR + +import os + +# Function to calculate the transverse mass +def mtw(x1,x2): + return sqrt(2*x1.pt()*x2.pt()*(1-cos(x1.phi()-x2.phi()))) + +class ttHAlphaTControlAnalyzer( Analyzer ): + def __init__(self, cfg_ana, cfg_comp, looperName ): + super(ttHAlphaTControlAnalyzer,self).__init__(cfg_ana,cfg_comp,looperName) + + def declareHandles(self): + super(ttHAlphaTControlAnalyzer, self).declareHandles() + #genJets + self.handles['genJets'] = AutoHandle( 'slimmedGenJets','std::vector') + + def beginLoop(self): + super(ttHAlphaTControlAnalyzer,self).beginLoop() + self.counters.addCounter('pairs') + count = self.counters.counter('pairs') + count.register('all events') + + + # Calculate MT_W (stolen from the MT2 code) + # Modularize this later? + def makeMT(self, event): + # print '==> INSIDE THE PRINT MT' + # print 'MET=',event.met.pt() + + if len(event.selectedLeptons)>0: + for lepton in event.selectedLeptons: + event.mtw = mtw(lepton, event.met) + + if len(event.selectedTaus)>0: + for myTau in event.selectedTaus: + event.mtwTau = mtw(myTau, event.met) + foundTau = True + + if len(event.selectedIsoTrack)>0: + for myTrack in event.selectedIsoTrack: + event.mtwIsoTrack = mtw(myTrack, event.met) + + return + + # Calculate the invariant mass from two lead leptons + def makeMll(self, event): + + if len(event.selectedLeptons)>=2: + event.mll = (event.selectedLeptons[0].p4()+event.selectedLeptons[1].p4()).M() + + return + + # Calculate the DeltaR between the lepton and the closest jet + def makeDeltaRLepJet(self, event): + + event.minDeltaRLepJet = [] + + for lepton in event.selectedLeptons: + + minDeltaR = 999 + + for jet in event.cleanJets: + minDeltaR=min(deltaR(lepton.eta(),lepton.phi(),jet.eta(),jet.phi()), minDeltaR) + + # Fill event with the min deltaR for each lepton + event.minDeltaRLepJet.append(minDeltaR) + + return + + # Calculate the DeltaR between the photon and the closest jet + def makeDeltaRPhoJet(self, event): + + event.minDeltaRPhoJet = [] + + for photon in event.selectedPhotons: + + minDeltaR = 999 + + for jet in event.cleanJets: + minDeltaR=min(deltaR(photon.eta(),photon.phi(),jet.eta(),jet.phi()), minDeltaR) + + # Fill event with the min deltaR for each photon + event.minDeltaRPhoJet.append(minDeltaR) + + return + + def process(self, iEvent, event): + self.readCollections( iEvent ) + + #W variables + event.mtw = -999 + event.mtwTau = -999 + event.mtwIsoTrack = -999 + self.makeMT(event) + + #Z variables + event.mll = -999 + self.makeMll(event) + + #Delta R variables + self.makeDeltaRLepJet(event) + self.makeDeltaRPhoJet(event) + + return True diff --git a/CMGTools/TTHAnalysis/python/analyzers/ttHAlphaTControlSkimmer.py b/CMGTools/TTHAnalysis/python/analyzers/ttHAlphaTControlSkimmer.py new file mode 100644 index 0000000000000..d9c18fa4d3d44 --- /dev/null +++ b/CMGTools/TTHAnalysis/python/analyzers/ttHAlphaTControlSkimmer.py @@ -0,0 +1,54 @@ + +from CMGTools.RootTools.fwlite.Analyzer import Analyzer +from CMGTools.RootTools.fwlite.Event import Event +from CMGTools.RootTools.statistics.Counter import Counter, Counters +from CMGTools.RootTools.fwlite.AutoHandle import AutoHandle + +class ttHAlphaTControlSkimmer( Analyzer ): + def __init__(self, cfg_ana, cfg_comp, looperName ): + super(ttHAlphaTControlSkimmer,self).__init__(cfg_ana,cfg_comp,looperName) + + def declareHandles(self): + super(ttHAlphaTControlSkimmer, self).declareHandles() + + def beginLoop(self): + super(ttHAlphaTControlSkimmer,self).beginLoop() + self.counters.addCounter('events') + count = self.counters.counter('events') + count.register('all events') + count.register('pass mtw cuts') + count.register('pass mll cuts') + count.register('pass lepton deltaR cuts') + count.register('pass photon deltaR cuts') + count.register('accepted events') + + + def process(self, iEvent, event): + self.readCollections( iEvent ) + self.counters.counter('events').inc('all events') + + #Perform W mass MTW cut + if event.mtw < self.cfg_ana.mtwCut[0] or event.mtw > self.cfg_ana.mtwCut[1]: + return False + self.counters.counter('events').inc('pass mtw cuts') + + #Perform Z mass MLL cut + if event.mll < self.cfg_ana.mllCut[0] or event.mll > self.cfg_ana.mllCut[1]: + return False + self.counters.counter('events').inc('pass mll cuts') + + #Perform deltaR cuts + for dR in event.minDeltaRLepJet: + if dR < self.cfg_ana.lepDeltaRCut: + return False + self.counters.counter('events').inc('pass lepton deltaR cuts') + + for dR in event.minDeltaRPhoJet: + if dR < self.cfg_ana.photonDeltaRCut: + return False + self.counters.counter('events').inc('pass photon deltaR cuts') + + #If everything passed return true + self.counters.counter('events').inc('accepted events') + return True + diff --git a/CMGTools/TTHAnalysis/python/analyzers/ttHAlphaTSkimmer.py b/CMGTools/TTHAnalysis/python/analyzers/ttHAlphaTSkimmer.py new file mode 100644 index 0000000000000..f43b31f4cfea5 --- /dev/null +++ b/CMGTools/TTHAnalysis/python/analyzers/ttHAlphaTSkimmer.py @@ -0,0 +1,58 @@ + +from CMGTools.RootTools.fwlite.Analyzer import Analyzer +from CMGTools.RootTools.fwlite.Event import Event +from CMGTools.RootTools.statistics.Counter import Counter, Counters +from CMGTools.RootTools.fwlite.AutoHandle import AutoHandle + +class ttHAlphaTSkimmer( Analyzer ): + def __init__(self, cfg_ana, cfg_comp, looperName ): + super(ttHAlphaTSkimmer,self).__init__(cfg_ana,cfg_comp,looperName) + + def declareHandles(self): + super(ttHAlphaTSkimmer, self).declareHandles() + + def beginLoop(self): + super(ttHAlphaTSkimmer,self).beginLoop() + self.counters.addCounter('events') + count = self.counters.counter('events') + count.register('all events') + count.register('pass forwardJetVeto') + count.register('pass MHT/MET cut') + count.register('pass alphaTCuts') + count.register('accepted events') + + + def process(self, iEvent, event): + self.readCollections( iEvent ) + self.counters.counter('events').inc('all events') + + #Veto forward jets that have passed the jet requirement + if self.cfg_ana.forwardJetVeto and len(event.cleanJetsFwd) > 0: + return False + self.counters.counter('events').inc('pass forwardJetVeto') + + #Veto events that don't pass the MHT/MET cut + if getattr(event, self.cfg_ana.mhtDivMetCut[0])/getattr(event, self.cfg_ana.mhtDivMetCut[1]).pt() > self.cfg_ana.mhtDivMetCut[2]: + return False + self.counters.counter('events').inc('pass MHT/MET cut') + + #Check if the event passes the alphaT cut + + if self.cfg_ana.invertAlphaT: #This is for the multijet enriched control region + + for aTCut in self.cfg_ana.alphaTCuts: + if event.alphaT < aTCut[0] and event.htJet50j >= aTCut[1] and event.htJet50j < aTCut[2]: + self.counters.counter('events').inc('pass alphaTCuts') + self.counters.counter('events').inc('accepted events') + return True + + else: + + for aTCut in self.cfg_ana.alphaTCuts: + if event.alphaT > aTCut[0] and event.htJet50j >= aTCut[1] and event.htJet50j < aTCut[2]: + self.counters.counter('events').inc('pass alphaTCuts') + self.counters.counter('events').inc('accepted events') + return True + + #If none of the alphaT cuts are passed, veto the event + return False diff --git a/CMGTools/TTHAnalysis/python/analyzers/ttHAlphaTVarAnalyzer.py b/CMGTools/TTHAnalysis/python/analyzers/ttHAlphaTVarAnalyzer.py index 527855f492c0d..367c5e6050f81 100644 --- a/CMGTools/TTHAnalysis/python/analyzers/ttHAlphaTVarAnalyzer.py +++ b/CMGTools/TTHAnalysis/python/analyzers/ttHAlphaTVarAnalyzer.py @@ -5,6 +5,7 @@ #from ROOT import TLorentzVector, TVectorD +from CMGTools.RootTools.utils.DeltaR import deltaR, deltaPhi from CMGTools.RootTools.fwlite.Analyzer import Analyzer from CMGTools.RootTools.fwlite.Event import Event from CMGTools.RootTools.statistics.Counter import Counter, Counters @@ -16,7 +17,7 @@ # from CMGTools.RootTools.physicsobjects.Tau import Tau from CMGTools.RootTools.physicsobjects.Jet import Jet -from CMGTools.RootTools.utils.DeltaR import * +#from CMGTools.RootTools.utils.DeltaR import * import ROOT from ROOT import AlphaT @@ -50,8 +51,8 @@ def makeAlphaT(self, event): px = ROOT.std.vector('double')() py = ROOT.std.vector('double')() et = ROOT.std.vector('double')() - - for jet in event.cleanJets: +#Make alphaT from lead 10 jets + for jet in event.cleanJets[:10]: px.push_back(jet.px()) py.push_back(jet.py()) et.push_back(jet.et()) @@ -62,7 +63,6 @@ def makeAlphaT(self, event): return - def process(self, iEvent, event): self.readCollections( iEvent ) diff --git a/CMGTools/TTHAnalysis/python/analyzers/ttHCoreEventAnalyzer.py b/CMGTools/TTHAnalysis/python/analyzers/ttHCoreEventAnalyzer.py index ea25f2cd1d494..74d0c6b0c54ed 100644 --- a/CMGTools/TTHAnalysis/python/analyzers/ttHCoreEventAnalyzer.py +++ b/CMGTools/TTHAnalysis/python/analyzers/ttHCoreEventAnalyzer.py @@ -148,6 +148,30 @@ def makeLepPtRel(self, event): # event.met.setP4(ROOT.reco.Particle.LorentzVector(px,py, 0, hypot(px,py))) # px,py = event.metNoPU.px()+event.deltaMetFromJEC[0], event.metNoPU.py()+event.deltaMetFromJEC[1] # event.metNoPU.setP4(ROOT.reco.Particle.LorentzVector(px,py, 0, hypot(px,py))) + + #Function to make the biased Dphi + def makeBiasedDPhi(self, event): + + if len(event.cleanJets) == 0: + event.biasedDPhi = 0 + return + mhtPx = event.mhtJet50jvec.px() + mhtPy = event.mhtJet50jvec.py() + + biasedDPhi = 10; + for jet in event.cleanJets: + newPhi = atan2(mhtPy+jet.py(),mhtPx+jet.px()) + biasedDPhiTemp = abs(deltaPhi(newPhi,jet.phi())) + if biasedDPhiTemp < biasedDPhi: + biasedDPhi = biasedDPhiTemp + biasedDPhiJet = jet + pass + + event.biasedDPhi = biasedDPhi + event.biasedDPhiJet = biasedDPhiJet + + return + def process(self, iEvent, event): self.readCollections( iEvent ) @@ -166,6 +190,7 @@ def process(self, iEvent, event): objects30 = [ j for j in event.cleanJets if j.pt() > 30 ] + event.selectedLeptons objects40 = [ j for j in event.cleanJets if j.pt() > 40 ] + event.selectedLeptons objects40j = [ j for j in event.cleanJets if j.pt() > 40 ] + objects50j = [ j for j in event.cleanJets if j.pt() > 50 ] objects40j10l = [ j for j in event.cleanJets if j.pt() > 40 ] + [ l for l in event.selectedLeptons if l.pt() > 10 ] event.htJet25 = sum([x.pt() for x in objects25]) @@ -188,6 +213,11 @@ def process(self, iEvent, event): event.mhtJet40j = event.mhtJet40jvec.pt() event.mhtPhiJet40j = event.mhtJet40jvec.phi() + event.htJet50j = sum([x.pt() for x in objects50j]) + event.mhtJet50jvec = ROOT.reco.Particle.LorentzVector(-1.*(sum([x.px() for x in objects50j])) , -1.*(sum([x.py() for x in objects50j])), 0, 0 ) + event.mhtJet50j = event.mhtJet50jvec.pt() + event.mhtPhiJet50j = event.mhtJet50jvec.phi() + event.htJet40j10l = sum([x.pt() for x in objects40j10l]) event.mhtJet40j10lvec = ROOT.reco.Particle.LorentzVector(-1.*(sum([x.px() for x in objects40j10l])) , -1.*(sum([x.py() for x in objects40j10l])), 0, 0 ) event.mhtJet40j10l = event.mhtJet40j10lvec.pt() @@ -289,4 +319,9 @@ def process(self, iEvent, event): diffMetMht_vec = ROOT.reco.Particle.LorentzVector(event.mhtJet40j10lvec.px()-event.met.px(), event.mhtJet40j10lvec.py()-event.met.py(), 0, 0 ) event.diffMetMht = sqrt( diffMetMht_vec.px()*diffMetMht_vec.px() + diffMetMht_vec.py()*diffMetMht_vec.py() ) ### + + #Make Biased DPhi + event.biasedDPhi = -999 + self.makeBiasedDPhi(event) + return True diff --git a/CMGTools/TTHAnalysis/python/analyzers/ttHGenLevelAnalyzer.py b/CMGTools/TTHAnalysis/python/analyzers/ttHGenLevelAnalyzer.py index 89fb55d08a4c4..dd20382ed5028 100644 --- a/CMGTools/TTHAnalysis/python/analyzers/ttHGenLevelAnalyzer.py +++ b/CMGTools/TTHAnalysis/python/analyzers/ttHGenLevelAnalyzer.py @@ -58,8 +58,8 @@ def declareHandles(self): #mc information self.mchandles['genParticles'] = AutoHandle( 'prunedGenParticles', 'std::vector' ) - if self.doPDFWeights: - self.mchandles['pdfstuff'] = AutoHandle( 'generator', 'GenEventInfoProduct' ) + #if self.doPDFWeights: + self.mchandles['pdfstuff'] = AutoHandle( 'generator', 'GenEventInfoProduct' ) def beginLoop(self): super(ttHGenLevelAnalyzer,self).beginLoop() @@ -247,6 +247,14 @@ def makePDFWeights(self, event): event.pdfWeights[pdf] = [w for w in ws] #print "Produced %d weights for %s: %s" % (len(ws),pdf,event.pdfWeights[pdf]) + def addGenBinning(self,event): + if self.mchandles['pdfstuff'].product().hasBinningValues(): + event.genBin = self.mchandles['pdfstuff'].product().binningValues()[0] + else: + event.genBin = -999 + + event.genQScale = self.mchandles['pdfstuff'].product().qScale() + def process(self, iEvent, event): self.readCollections( iEvent ) @@ -262,6 +270,8 @@ def process(self, iEvent, event): # do MC level analysis self.makeMCInfo(event) + self.addGenBinning(event) + # if MC and filtering on the Higgs decay mode, # them do filter events if self.cfg_ana.filterHiggsDecays: diff --git a/CMGTools/TTHAnalysis/python/analyzers/ttHIsoTrackSkimmer.py b/CMGTools/TTHAnalysis/python/analyzers/ttHIsoTrackSkimmer.py new file mode 100644 index 0000000000000..89047ac03b521 --- /dev/null +++ b/CMGTools/TTHAnalysis/python/analyzers/ttHIsoTrackSkimmer.py @@ -0,0 +1,71 @@ +import os +import logging + +from CMGTools.RootTools.fwlite.Analyzer import Analyzer +from CMGTools.RootTools.fwlite.Event import Event +from CMGTools.RootTools.statistics.Counter import Counter, Counters +from CMGTools.RootTools.fwlite.AutoHandle import AutoHandle +from CMGTools.RootTools.utils.DeltaR import deltaR + +class ttHIsoTrackSkimmer( Analyzer ): + def __init__(self, cfg_ana, cfg_comp, looperName ): + #Rather than using the inherited init do own so can choose directory + #name + + super(ttHIsoTrackSkimmer,self).__init__(cfg_ana,cfg_comp,looperName) + + self.ptCuts = cfg_ana.ptCuts if hasattr(cfg_ana, 'ptCuts') else [] + self.ptCuts += 10*[-1.] + + self.idCut = cfg_ana.idCut if hasattr(cfg_ana, 'idCut') else "True" + self.idFunc = eval("lambda object : "+self.idCut); + + def declareHandles(self): + super(ttHIsoTrackSkimmer, self).declareHandles() + + def beginLoop(self): + super(ttHIsoTrackSkimmer,self).beginLoop() + self.counters.addCounter('events') + count = self.counters.counter('events') + count.register('all events') + count.register('too many objects') + count.register('too few objects') + count.register('accepted events') + + + + def process(self, iEvent, event): + self.readCollections( iEvent ) + self.counters.counter('events').inc('all events') + + + objects = [] + selectedObjects = getattr(event, self.cfg_ana.objects) + for obj, ptCut in zip(selectedObjects, self.ptCuts): + allowTrack = False + for i in range (0,len(event.selectedMuons)) : + if (i == self.cfg_ana.allowedMuon): break + if(deltaR(event.selectedMuons[i].eta(), event.selectedMuons[i].phi(), obj.eta(), obj.phi()) < 0.01) : allowTrack=True + + for i in range (0,len(event.selectedElectrons)) : + if (i == self.cfg_ana.allowedElectron): break + if(deltaR(event.selectedElectrons[i].eta(), event.selectedElectrons[i].phi(), obj.eta(), obj.phi()) < 0.01) : allowTrack=True + + if not self.idFunc(obj): + continue + if obj.pt() > ptCut and not allowTrack: + objects.append(obj) + + + ret = False + if len(objects) >= self.cfg_ana.minObjects: + ret = True + else: + self.counters.counter('events').inc('too few objects') + + if len(objects) > self.cfg_ana.maxObjects: + self.counters.counter('events').inc('too many objects') + ret = False + + if ret: self.counters.counter('events').inc('accepted events') + return ret diff --git a/CMGTools/TTHAnalysis/python/analyzers/ttHMetEventAnalyzer.py b/CMGTools/TTHAnalysis/python/analyzers/ttHMetEventAnalyzer.py index 8274775097ab8..6a720c7c0f446 100644 --- a/CMGTools/TTHAnalysis/python/analyzers/ttHMetEventAnalyzer.py +++ b/CMGTools/TTHAnalysis/python/analyzers/ttHMetEventAnalyzer.py @@ -73,6 +73,31 @@ def makeMETs(self, event): px,py = event.metNoPU.px()+event.deltaMetFromJEC[0], event.metNoPU.py()+event.deltaMetFromJEC[1] event.metNoPU.setP4(ROOT.reco.Particle.LorentzVector(px,py, 0, hypot(px,py))) + def makeMETNoMu(self, event): + event.metNoMu = copy.deepcopy(self.handles['met'].product()[0]) + event.metNoMuNoPU = copy.deepcopy(self.handles['nopumet'].product()[0]) + + mupx = 0 + mupy = 0 + #sum muon momentum + for mu in event.selectedMuons: + mupx += mu.px() + mupy += mu.py() + + #subtract muon momentum and construct met + if hasattr(event, 'deltaMetFromJetSmearing'): + import ROOT + px,py = event.metNoMu.px()+event.deltaMetFromJetSmearing[0]-mupx, event.metNoMu.py()+event.deltaMetFromJetSmearing[1]-mupy + event.metNoMu.setP4(ROOT.reco.Particle.LorentzVector(px,py, 0, hypot(px,py))) + px,py = event.metNoMuNoPU.px()+event.deltaMetFromJetSmearing[0]-mupx, event.metNoMuNoPU.py()+event.deltaMetFromJetSmearing[1]-mupy + event.metNoMuNoPU.setP4(ROOT.reco.Particle.LorentzVector(px,py, 0, hypot(px,py))) + if hasattr(event, 'deltaMetFromJEC') and event.deltaMetFromJEC[0] != 0 and event.deltaMetFromJEC[1] != 0: + import ROOT + px,py = event.metNoMu.px()+event.deltaMetFromJEC[0]-mupx, event.metNoMu.py()+event.deltaMetFromJEC[1]-mupy + event.met.setP4(ROOT.reco.Particle.LorentzVector(px,py, 0, hypot(px,py))) + px,py = event.metNoMuNoPU.px()+event.deltaMetFromJEC[0]-mupx, event.metNoMuNoPU.py()+event.deltaMetFromJEC[1]-mupy + event.metNoMuNoPU.setP4(ROOT.reco.Particle.LorentzVector(px,py, 0, hypot(px,py))) + def process(self, iEvent, event): self.readCollections( iEvent ) @@ -84,4 +109,7 @@ def process(self, iEvent, event): if self.cfg_ana.doTkMet: self.makeTkMETs(event); + if self.cfg_ana.doMetNoMu: + self.makeMETNoMu(event) + return True diff --git a/CMGTools/TTHAnalysis/python/analyzers/ttHObjectSkimmer.py b/CMGTools/TTHAnalysis/python/analyzers/ttHObjectSkimmer.py new file mode 100644 index 0000000000000..802b17eab74c9 --- /dev/null +++ b/CMGTools/TTHAnalysis/python/analyzers/ttHObjectSkimmer.py @@ -0,0 +1,77 @@ +import os +import logging + +from CMGTools.RootTools.fwlite.Analyzer import Analyzer +from CMGTools.RootTools.fwlite.Event import Event +from CMGTools.RootTools.statistics.Counter import Counter, Counters +from CMGTools.RootTools.fwlite.AutoHandle import AutoHandle + +class ttHObjectSkimmer( Analyzer ): + def __init__(self, cfg_ana, cfg_comp, looperName ): + #Rather than using the inherited init do own so can choose directory + #name + + #super(ttHObjectSkimmer,self).__init__(cfg_ana,cfg_comp,looperName) + + self.name = cfg_ana.name + self.verbose = cfg_ana.verbose + self.cfg_ana = cfg_ana + self.cfg_comp = cfg_comp + self.looperName = looperName + if hasattr(cfg_ana, 'skimmerName'): + self.dirName = os.path.join(self.looperName, cfg_ana.skimmerName) + else: + self.dirName = os.path.join(self.looperName, self.name) + + os.mkdir( self.dirName ) + + # this is the main logger corresponding to the looper. + # each analyzer could also declare its own logger + self.mainLogger = logging.getLogger( looperName ) + self.beginLoopCalled = False + + + self.ptCuts = cfg_ana.ptCuts if hasattr(cfg_ana, 'ptCuts') else [] + self.ptCuts += 10*[-1.] + + self.idCut = cfg_ana.idCut if hasattr(cfg_ana, 'idCut') else "True" + self.idFunc = eval("lambda object : "+self.idCut); + + def declareHandles(self): + super(ttHObjectSkimmer, self).declareHandles() + + def beginLoop(self): + super(ttHObjectSkimmer,self).beginLoop() + self.counters.addCounter('events') + count = self.counters.counter('events') + count.register('all events') + count.register('too many objects') + count.register('too few objects') + count.register('accepted events') + + + def process(self, iEvent, event): + self.readCollections( iEvent ) + self.counters.counter('events').inc('all events') + + + objects = [] + selectedObjects = getattr(event, self.cfg_ana.objects) + for obj, ptCut in zip(selectedObjects, self.ptCuts): + if not self.idFunc(obj): + continue + if obj.pt() > ptCut: + objects.append(obj) + + ret = False + if len(objects) >= self.cfg_ana.minObjects: + ret = True + else: + self.counters.counter('events').inc('too few objects') + + if len(objects) > self.cfg_ana.maxObjects: + self.counters.counter('events').inc('too many objects') + ret = False + + if ret: self.counters.counter('events').inc('accepted events') + return ret