def __init__(self, cfg_ana, cfg_comp, looperName):
     super(ttHCoreEventAnalyzer, self).__init__(cfg_ana, cfg_comp,
                                                looperName)
     self.maxLeps = cfg_ana.maxLeps
     self.leptonMVA = LeptonMVA(
         "%s/src/CMGTools/TTHAnalysis/data/leptonMVA/%%s_BDTG.weights.xml" %
         os.environ['CMSSW_BASE'], self.cfg_comp.isMC)
Exemple #2
0
 def __init__(self, cfg_ana, cfg_comp, looperName):
     super(ttHCoreEventAnalyzer, self).__init__(cfg_ana, cfg_comp,
                                                looperName)
     self.maxLeps = cfg_ana.maxLeps
     self.mhtForBiasedDPhi = cfg_ana.mhtForBiasedDPhi
     self.jetForBiasedDPhi = cfg_ana.jetForBiasedDPhi
     self.leptonMVAKindTTH = getattr(self.cfg_ana, "leptonMVAKindTTH",
                                     "Susy")
     self.leptonMVAKindSusy = getattr(self.cfg_ana, "leptonMVAKindSusy",
                                      "Susy")
     self.leptonMVAPathTTH = getattr(
         self.cfg_ana, "leptonMVAPathTTH",
         "CMGTools/TTHAnalysis/data/leptonMVA/tth/%s_BDTG.weights.xml")
     if self.leptonMVAPathTTH[0] != "/":
         self.leptonMVAPathTTH = "%s/src/%s" % (os.environ['CMSSW_BASE'],
                                                self.leptonMVAPathTTH)
     self.leptonMVATTH = LeptonMVA(self.leptonMVAKindTTH,
                                   self.leptonMVAPathTTH,
                                   self.cfg_comp.isMC)
     self.leptonMVAPathSusy = getattr(
         self.cfg_ana, "leptonMVAPathSusy",
         "CMGTools/TTHAnalysis/data/leptonMVA/susy/%s_BDTG.weights.xml")
     if self.leptonMVAPathSusy[0] != "/":
         self.leptonMVAPathSusy = "%s/src/%s" % (os.environ['CMSSW_BASE'],
                                                 self.leptonMVAPathSusy)
     self.leptonMVASusy = LeptonMVA(self.leptonMVAKindSusy,
                                    self.leptonMVAPathSusy,
                                    self.cfg_comp.isMC)
     self.jetPt = cfg_ana.jetPt
 def __init__(self, cfg_ana, cfg_comp, looperName):
     super(ttHCoreEventAnalyzer, self).__init__(cfg_ana, cfg_comp,
                                                looperName)
     self.btagAlgo = getattr(cfg_ana, 'btagAlgo', 'CSVv2IVF')
     self.maxLeps = cfg_ana.maxLeps
     self.mhtForBiasedDPhi = cfg_ana.mhtForBiasedDPhi
     self.jetForBiasedDPhi = cfg_ana.jetForBiasedDPhi
     self.leptonMVAKindTTH = getattr(self.cfg_ana, "leptonMVAKindTTH",
                                     "training2017")
     self.leptonMVAPathTTH = getattr(
         self.cfg_ana, "leptonMVAPathTTH",
         "CMGTools/TTHAnalysis/data/leptonMVA/tth/%s_BDTG.weights.xml")
     if self.leptonMVAPathTTH[0] != "/":
         self.leptonMVAPathTTH = "%s/src/%s" % (os.environ['CMSSW_BASE'],
                                                self.leptonMVAPathTTH)
     self.leptonMVATTH = LeptonMVA(self.leptonMVAKindTTH,
                                   self.leptonMVAPathTTH,
                                   self.cfg_comp.isMC)
     self.leptonMVAKindSUSY = getattr(self.cfg_ana, "leptonMVAKindSUSY",
                                      "training2017")
     self.leptonMVAPathSUSY = getattr(
         self.cfg_ana, "leptonMVAPathSUSY",
         "CMGTools/TTHAnalysis/data/leptonMVA/susy/%s_BDTG.weights.xml")
     if self.leptonMVAPathSUSY[0] != "/":
         self.leptonMVAPathSUSY = "%s/src/%s" % (os.environ['CMSSW_BASE'],
                                                 self.leptonMVAPathSUSY)
     self.leptonMVASUSY = LeptonMVA(self.leptonMVAKindSUSY,
                                    self.leptonMVAPathSUSY,
                                    self.cfg_comp.isMC)
     self.doLeptonMVASoft = getattr(self.cfg_ana, "doLeptonMVASoft", False)
     if self.doLeptonMVASoft:
         self.leptonMVAKindSoftT2tt = getattr(self.cfg_ana,
                                              "leptonMVAKindSoftT2tt",
                                              "SoftJetLessNOBTAG")
         self.leptonMVAPathSoftT2tt = getattr(
             self.cfg_ana, "leptonMVAPathSoftT2tt",
             "CMGTools/TTHAnalysis/data/leptonMVA/jetless/SoftJetLessNOBTAGNOTAU_SIGT2tt_%s_BDTG.weights.xml"
         )
         if self.leptonMVAPathSoftT2tt[0] != "/":
             self.leptonMVAPathSoftT2tt = "%s/src/%s" % (
                 os.environ['CMSSW_BASE'], self.leptonMVAPathSoftT2tt)
         self.leptonMVASoftT2tt = LeptonMVA(self.leptonMVAKindSoftT2tt,
                                            self.leptonMVAPathSoftT2tt,
                                            self.cfg_comp.isMC)
         self.leptonMVAKindSoftEWK = getattr(self.cfg_ana,
                                             "leptonMVAKindSoftEWK",
                                             "SoftJetLessNOBTAG")
         self.leptonMVAPathSoftEWK = getattr(
             self.cfg_ana, "leptonMVAPathSoftEWK",
             "CMGTools/TTHAnalysis/data/leptonMVA/jetless/SoftJetLessNOBTAGNOTAU_SIGTChiNeu8090_%s_BDTG.weights.xml"
         )
         if self.leptonMVAPathSoftEWK[0] != "/":
             self.leptonMVAPathSoftEWK = "%s/src/%s" % (
                 os.environ['CMSSW_BASE'], self.leptonMVAPathSoftEWK)
         self.leptonMVASoftEWK = LeptonMVA(self.leptonMVAKindSoftEWK,
                                           self.leptonMVAPathSoftEWK,
                                           self.cfg_comp.isMC)
     self.jetPt = cfg_ana.jetPt
 def __init__(self, cfg_ana, cfg_comp, looperName ):
     super(ttHLepFRAnalyzer,self).__init__(cfg_ana,cfg_comp,looperName) 
     self.leptonMVA = LeptonMVA("%s/src/CMGTools/TTHAnalysis/data/leptonMVA/%%s_BDTG.weights.xml" % os.environ['CMSSW_BASE'], self.cfg_comp.isMC)
     self.triggerCheckers = []
     import ROOT
     for T in self.cfg_ana.triggers:
         trigVec = ROOT.vector(ROOT.string)()
         trigVec.push_back("HLT_%s_v*" % T)
         self.triggerCheckers.append( (T.replace("_eta2p1",""), TriggerBitChecker(trigVec)) )
class ttHLepStudyTreeProducer( ttHLepTreeProducerNew ):
    def __init__(self, cfg_ana, cfg_comp, looperName ):
        super(ttHLepStudyTreeProducer,self).__init__(cfg_ana,cfg_comp,looperName) 

        self.leptonMVA = LeptonMVA("%s/src/CMGTools/TTHAnalysis/data/leptonMVA/%%s_BDTG.weights.xml" % os.environ['CMSSW_BASE'], self.cfg_comp.isMC)

        self.globalVariables = [ 
            NTupleVariable("nVert",  lambda ev: len(ev.goodVertices), int, help="Number of good vertices"),
        ]
        self.globalObjects = {
            "lep"  : NTupleObject("Lep",   leptonTypeFull, help="Probe lepton"),
        }
        self.collections = {}

        ## Now book the variables
        self.initDone = True
        self.declareVariables()

    def declareHandles(self):
        super(ttHLepStudyTreeProducer, self).declareHandles()

    def beginLoop(self):
        super(ttHLepStudyTreeProducer,self).beginLoop()
        self.counters.addCounter('leptons')
        count = self.counters.counter('leptons')
        count.register('electron')
        count.register('prompt electron')
        count.register('non-prompt electron')
        count.register('unmatched electron')
        count.register('muon')
        count.register('prompt muon')
        count.register('non-prompt muon')
        count.register('unmatched muon')

    def process(self, iEvent, event):
        self.readCollections( iEvent )
        for lep in event.inclusiveLeptons:
            ## compute lepton MVA
            self.leptonMVA.addMVA(lep)
            ## increment counters
            name = "muon" if abs(lep.pdgId()) == 13 else "electron"
            self.counters.counter('leptons').inc(name)
            if lep.mcMatchId > 0:     self.counters.counter('leptons').inc('prompt '+name)
            elif lep.mcMatchAny != 0: self.counters.counter('leptons').inc('non-prompt '+name)
            else:                     self.counters.counter('leptons').inc('unmatched '+name)
            event.lep = lep
            self.fillTree(iEvent, event)
         
        return True
    def __init__(self, cfg_ana, cfg_comp, looperName ):
        super(ttHLepStudyTreeProducer,self).__init__(cfg_ana,cfg_comp,looperName) 

        self.leptonMVA = LeptonMVA("%s/src/CMGTools/TTHAnalysis/data/leptonMVA/%%s_BDTG.weights.xml" % os.environ['CMSSW_BASE'], self.cfg_comp.isMC)

        self.globalVariables = [ 
            NTupleVariable("nVert",  lambda ev: len(ev.goodVertices), int, help="Number of good vertices"),
        ]
        self.globalObjects = {
            "lep"  : NTupleObject("Lep",   leptonTypeFull, help="Probe lepton"),
        }
        self.collections = {}

        ## Now book the variables
        self.initDone = True
        self.declareVariables()
Exemple #7
0
class ttHLepEventAnalyzer(Analyzer):
    def __init__(self, cfg_ana, cfg_comp, looperName):
        super(ttHLepEventAnalyzer, self).__init__(cfg_ana, cfg_comp,
                                                  looperName)
        self.maxLeps = cfg_ana.maxLeps

        self.leptonMVA = LeptonMVA(
            "%s/src/CMGTools/TTHAnalysis/data/leptonMVA/%%s_BDTG.weights.xml" %
            os.environ['CMSSW_BASE'], self.cfg_comp.isMC)

    def declareHandles(self):
        super(ttHLepEventAnalyzer, self).declareHandles()
        self.handles['met'] = AutoHandle('cmgPFMET',
                                         'std::vector<cmg::BaseMET>')
        self.handles['nopumet'] = AutoHandle('nopuMet',
                                             'std::vector<reco::PFMET>')
        self.handles['metSignificance'] = AutoHandle('pfMetSignificance',
                                                     'cmg::METSignificance')

    def beginLoop(self):
        super(ttHLepEventAnalyzer, self).beginLoop()

    def makeZs(self, event, maxLeps):
        event.bestZ1 = [0., -1, -1]
        event.bestZ1sfss = [0., -1, -1]
        event.bestZ2 = [0., -1, -1, 0.]
        nlep = len(event.selectedLeptons)
        for i, l1 in enumerate(event.selectedLeptons):
            for j in range(i + 1, nlep):
                if j >= maxLeps: break
                l2 = event.selectedLeptons[j]
                if l1.pdgId() == -l2.pdgId():
                    zmass = (l1.p4() + l2.p4()).M()
                    if event.bestZ1[0] == 0 or abs(zmass - 91.188) < abs(
                            event.bestZ1[0] - 91.188):
                        event.bestZ1 = [zmass, i, j]
                if l1.pdgId() == l2.pdgId():
                    zmass = (l1.p4() + l2.p4()).M()
                    if event.bestZ1sfss[0] == 0 or abs(zmass - 91.188) < abs(
                            event.bestZ1sfss[0] - 91.188):
                        event.bestZ1sfss = [zmass, i, j]
        if event.bestZ1[0] != 0 and nlep > 3:
            for i, l1 in enumerate(event.selectedLeptons):
                if i == event.bestZ1[1]: continue
                for j in range(i + 1, nlep):
                    if j >= maxLeps: break
                    if j == event.bestZ1[2]: continue
                    l2 = event.selectedLeptons[j]
                    if l1.pdgId() == -l2.pdgId():
                        if l1.pt() + l2.pt() > event.bestZ2[0]:
                            event.bestZ2 = [
                                l1.pt() + l2.pt(), i, j,
                                (l1.p4() + l2.p4()).M()
                            ]

    def makeMlls(self, event, maxLeps):
        mllsfos = self.mllValues(event,
                                 lambda l1, l2: l1.pdgId() == -l2.pdgId(),
                                 maxLeps)
        mllafos = self.mllValues(event,
                                 lambda l1, l2: l1.charge() == -l2.charge(),
                                 maxLeps)
        mllafss = self.mllValues(event,
                                 lambda l1, l2: l1.charge() == l2.charge(),
                                 maxLeps)
        mllafas = self.mllValues(event, lambda l1, l2: True, maxLeps)
        event.minMllSFOS = min(mllsfos)
        event.minMllAFOS = min(mllafos)
        event.minMllAFSS = min(mllafss)
        event.minMllAFAS = min(mllafas)
        event.maxMllAFOS = max(mllafos)
        event.maxMllAFSS = max(mllafss)
        drllafos = self.drllValues(event,
                                   lambda l1, l2: l1.charge() == -l2.charge(),
                                   maxLeps)
        drllafss = self.drllValues(event,
                                   lambda l1, l2: l1.charge() == l2.charge(),
                                   maxLeps)
        event.minDrllAFSS = min(drllafss)
        event.minDrllAFOS = min(drllafos)
        event.maxDrllAFOS = max(drllafos)
        event.maxDrllAFSS = max(drllafss)
        ptllafos = self.ptllValues(event,
                                   lambda l1, l2: l1.charge() == -l2.charge(),
                                   maxLeps)
        ptllafss = self.ptllValues(event,
                                   lambda l1, l2: l1.charge() == l2.charge(),
                                   maxLeps)
        event.minPtllAFSS = min(ptllafss)
        event.minPtllAFOS = min(ptllafos)
        event.maxPtllAFOS = max(ptllafos)
        event.maxPtllAFSS = max(ptllafss)
        leps = event.selectedLeptons
        nlep = len(leps)
        event.m2l = (leps[0].p4() + leps[1].p4()).M() if nlep >= 2 else 0
        event.pt2l = (leps[0].p4() + leps[1].p4()).Pt() if nlep >= 2 else 0
        event.q3l = sum([l.charge() for l in leps[:2]]) if nlep >= 3 else 0
        event.ht3l = sum([l.pt() for l in leps[:2]]) if nlep >= 3 else 0
        event.pt3l = (leps[0].p4() + leps[1].p4() +
                      leps[2].p4()).Pt() if nlep >= 3 else 0
        event.m3l = (leps[0].p4() + leps[1].p4() +
                     leps[2].p4()).M() if nlep >= 3 else 0
        event.q4l = sum([l.charge() for l in leps[:3]]) if nlep >= 4 else 0
        event.ht4l = sum([l.pt() for l in leps[:3]]) if nlep >= 4 else 0
        event.pt4l = (leps[0].p4() + leps[1].p4() + leps[2].p4() +
                      leps[3].p4()).Pt() if nlep >= 4 else 0
        event.m4l = (leps[0].p4() + leps[1].p4() + leps[2].p4() +
                     leps[3].p4()).M() if nlep >= 4 else 0

    def mllValues(self, event, pairSelection, maxLeps):
        return self.llValues(event, lambda l1, l2: (l1.p4() + l2.p4()).M(),
                             pairSelection, maxLeps)

    def drllValues(self, event, pairSelection, maxLeps):
        return self.llValues(
            event,
            lambda l1, l2: deltaR(l1.eta(), l1.phi(), l2.eta(), l2.phi()),
            pairSelection, maxLeps)

    def ptllValues(self, event, pairSelection, maxLeps):
        return self.llValues(event, lambda l1, l2: (l1.p4() + l2.p4()).Pt(),
                             pairSelection, maxLeps)

    def llValues(self, event, function, pairSelection, maxLeps):
        pairs = []
        nlep = len(event.selectedLeptons)
        for i, l1 in enumerate(event.selectedLeptons):
            for j in range(i + 1, nlep):
                if j >= maxLeps: break
                l2 = event.selectedLeptons[j]
                if pairSelection(l1, l2):
                    pairs.append(function(l1, l2))
        if pairs == []: pairs.append(-1)
        return pairs

    def makeLepBJetDeltaR(self, event):
        for l in event.selectedLeptons + event.looseLeptons:
            match, dr = bestMatch(l, event.bjetsLoose)
            l.drBJet = dr

        for l in event.selectedLeptons:
            (px, py, pz) = (l.px(), l.py(), l.pz())
            (jx, jy, jz) = (l.jet.px(), l.jet.py(), l.jet.pz())
            cross = (px * jy - py * jx, py * jz - pz * jy, pz * jx - px * jz)
            l.ptRelJet = sqrt(sum([v * v for v in cross])) / l.jet.p()

    def jetProjectedMET(self, met, jets, oneSided=True):
        import math
        projfactor = 1.0
        for j in jets:
            dphi = abs(deltaPhi(j.phi(), met.phi()))
            proj = sin(dphi)
            if oneSided and dphi > 0.5 * math.pi:
                continue
            if projfactor > proj: projfactor = proj
        return met.pt() * projfactor

    def makeMETs(self, event):
        event.met = self.handles['met'].product()[0]
        event.metNoPU = self.handles['nopumet'].product()[0]
        if hasattr(event, 'deltaMetFromJetSmearing'):
            import ROOT
            px, py = event.met.px() + event.deltaMetFromJetSmearing[
                0], event.met.py() + event.deltaMetFromJetSmearing[1]
            event.met.setP4(
                ROOT.reco.Particle.LorentzVector(px, py, 0, hypot(px, py)))
            px, py = event.metNoPU.px() + event.deltaMetFromJetSmearing[
                0], event.metNoPU.py() + event.deltaMetFromJetSmearing[1]
            event.metNoPU.setP4(
                ROOT.reco.Particle.LorentzVector(px, py, 0, hypot(px, py)))
        metMatrix = self.handles['metSignificance'].product().significance()
        metMatrix.Invert()
        import array
        metVector = TVectorD(
            2, array.array('d',
                           [event.met.px(), event.met.py()]))
        event.metSignificance = metMatrix.Similarity(metVector)
        event.projMetAll1S = self.jetProjectedMET(event.met, event.jets, True)
        event.projMetAll2S = self.jetProjectedMET(event.met, event.jets, False)
        event.projMetJets1S = self.jetProjectedMET(event.met, event.cleanJets,
                                                   True)
        event.projMetJets2S = self.jetProjectedMET(event.met, event.cleanJets,
                                                   False)
        #print "MET value:  ", event.met.pt()
        #print "MET sumET:  ", event.met.sumEt()
        #print "MET signif: ", event.metSignificance
        #print "PrMETAll 1S:", event.projMetAll1S
        #print "PrMETAll 2S:", event.projMetAll2S
        #print "PrMETJet 1S:", event.projMetJets1S
        #print "PrMETJet 2S:", event.projMetJets2S

    def makeHadTopDecays(self, event):
        event.lightJets = [
            j for j in event.cleanJets if not j.getSelection("cuts_csv_medium")
        ]
        event.minMWjj = 999
        event.minMWjjPt = 0
        event.bestMWjj = 0
        event.bestMWjjPt = 0
        event.bestMTopHad = 0
        event.bestMTopHadPt = 0
        for i1, j1 in enumerate(event.lightJets):
            for i2 in xrange(i1 + 1, len(event.lightJets)):
                j2 = event.lightJets[i2]
                jjp4 = j1.p4() + j2.p4()
                mjj = jjp4.M()
                if mjj > 30 and mjj < event.minMWjj:
                    event.minMWjj = mjj
                    event.minMWjjPt = jjp4.Pt()
                if abs(mjj - 80.4) < abs(event.bestMWjj - 80.4):
                    event.bestMWjj = mjj
                    event.bestMWjjPt = jjp4.Pt()
                    for bj in event.bjetsLoose:
                        if deltaR(bj.eta(), bj.phi(), j1.eta(),
                                  j1.phi()) < 0.1 or deltaR(
                                      bj.eta(), bj.phi(), j2.eta(),
                                      j2.phi()) < 0.1:
                            continue
                        tp4 = jjp4 + bj.p4()
                        mtop = tp4.M()
                        if abs(mtop - 172) < abs(event.bestMTopHad - 172):
                            event.bestMTopHad = mtop
                            event.bestMTopHadPt = tp4.Pt()

    def process(self, iEvent, event):
        self.readCollections(iEvent)

        if hasattr(self.cfg_ana, 'minJets25'):
            n25 = len([j for j in event.cleanJets if j.pt() > 25])
            if n25 < self.cfg_ana.minJets25:
                return False

        eventNumber = iEvent.eventAuxiliary().id().event()

        event.bjetsLoose = [
            j for j in event.cleanJets if j.getSelection("cuts_csv_loose")
        ]
        event.bjetsMedium = [
            j for j in event.cleanJets if j.getSelection("cuts_csv_medium")
        ]

        objects25 = [j for j in event.cleanJets if j.pt() > 25
                     ] + event.selectedLeptons
        objects30 = [j for j in event.cleanJets if j.pt() > 30
                     ] + event.selectedLeptons
        event.htJet25 = sum([x.pt() for x in objects25])
        event.mhtJet25 = hypot(sum([x.px() for x in objects25]),
                               sum([x.py() for x in objects25]))
        event.htJet30 = sum([x.pt() for x in objects30])
        event.mhtJet30 = hypot(sum([x.px() for x in objects30]),
                               sum([x.py() for x in objects30]))
        ## same but with all eta range
        objects25a = [j for j in event.cleanJetsAll if j.pt() > 25
                      ] + event.selectedLeptons
        objects30a = [j for j in event.cleanJetsAll if j.pt() > 30
                      ] + event.selectedLeptons
        event.htJet25a = sum([x.pt() for x in objects25a])
        event.mhtJet25a = hypot(sum([x.px() for x in objects25a]),
                                sum([x.py() for x in objects25a]))
        event.htJet30a = sum([x.pt() for x in objects30a])
        event.mhtJet30a = hypot(sum([x.px() for x in objects30a]),
                                sum([x.py() for x in objects30a]))

        self.makeMETs(event)
        self.makeZs(event, self.maxLeps)
        self.makeMlls(event, self.maxLeps)

        self.makeHadTopDecays(event)
        for lep in event.selectedLeptons:
            self.leptonMVA.addMVA(lep)

        if self.cfg_ana.verbose:
            print 'Event ', eventNumber
            print 'Selected leptons: ', len(event.selectedLeptons)
            print "\n".join(["\t%s" % p for p in event.selectedLeptons])
            print 'Selected clean jets   : ', len(event.cleanJets)
            print "\n".join(["\t%s" % p for p in event.cleanJets])
            print 'Selected loose  b-jets: ', len(event.bjetsLoose)
            print 'Selected medium b-jets: ', len(event.bjetsMedium)
            print 'Best Z1, if any: mass = %6.1f ' % event.bestZ1[0]
            print 'Best Z2, if any: mass = %6.1f ' % event.bestZ2[3]
            print 'Min m(ll) values: SF/OS = %5.1f, AF/OS = %5.1f, AF/AS = %5.1f' % (
                event.minMllSFOS, event.minMllAFOS, event.minMllAFAS)

        return True
Exemple #8
0
class ttHLepFRAnalyzer(TreeAnalyzerNumpy):
    def __init__(self, cfg_ana, cfg_comp, looperName):
        super(ttHLepFRAnalyzer, self).__init__(cfg_ana, cfg_comp, looperName)
        self.leptonMVA = LeptonMVA(
            "%s/src/CMGTools/TTHAnalysis/data/leptonMVA/%%s_BDTG.weights.xml" %
            os.environ['CMSSW_BASE'], self.cfg_comp.isMC)

    def declareHandles(self):
        super(ttHLepFRAnalyzer, self).declareHandles()
        self.handles['met'] = AutoHandle('cmgPFMET',
                                         'std::vector<cmg::BaseMET>')
        self.handles['nopumet'] = AutoHandle('nopuMet',
                                             'std::vector<reco::PFMET>')

    def declareVariables(self):
        tr = self.tree

        isMC = self.cfg_comp.isMC

        tr = self.tree
        var(tr, 'run', int)
        var(tr, 'lumi', int)
        var(tr, 'evt', int)
        var(tr, 'nVert', int)

        bookLepton(tr, "Probe", isMC)

        var(tr, 'tagType', int)

        bookLepton(tr, "TagLepton", isMC)
        bookJet(tr, "TagJet", isMC)
        #bookParticle(tr,"TagPhoton", isMC)

        for I in (5, 8, 12, 17, 24, 40):
            var(tr, "Trig_Probe_Mu%d" % I, int)
            var(tr, "Trig_Tag_Mu%d" % I, int)
        var(tr, "Trig_Probe_RelIso1p0Mu5", int)
        var(tr, "Trig_Tag_RelIso1p0Mu5", int)
        var(tr, "Trig_Probe_1ElT", int)
        var(tr, "Trig_Probe_1ElL", int)
        var(tr, "Trig_Pair_2Mu", int)
        var(tr, "Trig_Pair_MuEG", int)

        var(tr, 'dphi_tp')
        var(tr, 'dr_tp')
        var(tr, 'mll')
        var(tr, 'mtw_probe')
        var(tr, 'mtw_tag')
        var(tr, 'mtwNoPU_probe')
        var(tr, 'mtwNoPU_tag')
        var(tr, 'met')
        var(tr, 'metPhi')
        var(tr, 'metNoPU')
        var(tr, 'metPhiNoPU')

    def beginLoop(self):
        super(ttHLepFRAnalyzer, self).beginLoop()
        self.counters.addCounter('pairs')
        count = self.counters.counter('pairs')
        count.register('all events')
        count.register('one lepton')
        count.register('loose jet')
        count.register('high pt jet')
        count.register('bjet tag')
        count.register('mu tag')

    def process(self, iEvent, event):
        self.readCollections(iEvent)
        event.met = self.handles['met'].product()[0]
        event.metNoPU = self.handles['nopumet'].product()[0]

        tr = self.tree
        fill(tr, 'run', event.run)
        fill(tr, 'lumi', event.lumi)
        fill(tr, 'evt', event.eventId)
        fill(tr, 'nVert', len(event.goodVertices))

        fill(tr, 'met', event.met.pt())
        fill(tr, 'metPhi', event.met.phi())
        fill(tr, 'metNoPU', event.metNoPU.pt())
        fill(tr, 'metPhiNoPU', event.metNoPU.phi())

        self.counters.counter('pairs').inc('all events')

        # di-lepton veto: simple, for now
        if len(event.selectedLeptons) > 1:
            return False
        self.counters.counter('pairs').inc('one lepton')

        def mtw(x1, x2):
            return sqrt(2 * x1.pt() * x2.pt() * (1 - cos(x1.phi() - x2.phi())))

        def passTrigg(lep, triggers):
            for t in triggers:
                if lep.sourcePtr().triggerObjectMatchesByPath(
                        'HLT_%s_v*' % t, 1, 0).size() > 0:
                    return True
            return False

        def passFilter(lep, filters):
            for t in filters:
                if lep.sourcePtr().triggerObjectMatchesByFilter(t).size() > 0:
                    return True
            return False

        def passSingleMu(lep):
            return passTrigg(
                lep,
                "Mu12 Mu24_eta2p1 Mu30_eta2p1 Mu40 Mu40_eta2p1 Mu17 Mu8".split(
                ))

        def passSingleIsoMu(lep):
            return passTrigg(lep, "IsoMu24 IsoMu24_eta2p1".split())

        def passSingleElL(lep):
            return passTrigg(
                lep, "Ele17_CaloIdL_CaloIsoVL Ele8_CaloIdL_CaloIsoVL".split())

        def passSingleElT(lep):
            return passTrigg(
                lep,
                "Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL"
                .split())

        def passDoubleMu(lep1, lep2):
            mu17_1 = passFilter(
                lep1,
                'hltL3fL1DoubleMu10MuOpenL1f0L2f10L3Filtered17 hltL3fL1DoubleMu10MuOpenOR3p5L1f0L2f10L3Filtered17'
                .split())
            mu17_2 = passFilter(
                lep2,
                'hltL3fL1DoubleMu10MuOpenL1f0L2f10L3Filtered17 hltL3fL1DoubleMu10MuOpenOR3p5L1f0L2f10L3Filtered17'
                .split())
            mu8_1 = passFilter(
                lep1,
                'hltL3pfL1DoubleMu10MuOpenL1f0L2pf0L3PreFiltered8 hltL3pfL1DoubleMu10MuOpenOR3p5L1f0L2pf0L3PreFiltered8'
                .split())
            mu8_2 = passFilter(
                lep2,
                'hltL3pfL1DoubleMu10MuOpenL1f0L2pf0L3PreFiltered8 hltL3pfL1DoubleMu10MuOpenOR3p5L1f0L2pf0L3PreFiltered8'
                .split())
            mu8tk_1 = passFilter(lep1, ['hltDiMuonGlbFiltered17TrkFiltered8'])
            mu8tk_2 = passFilter(lep2, ['hltDiMuonGlbFiltered17TrkFiltered8'])
            if lep1.sourcePtr().triggerObjectMatchesByPath(
                    'HLT_Mu17_Mu8_v*', 1, 0).size() and (
                        mu17_1 + mu17_2 >= 1) and (mu8_1 + mu8_2 >= 2):
                return True
            if lep2.sourcePtr().triggerObjectMatchesByPath(
                    'HLT_Mu17_Mu8_v*', 1, 0).size() and (
                        mu17_1 + mu17_2 >= 1) and (mu8_1 + mu8_2 >= 2):
                return True
            if lep1.sourcePtr().triggerObjectMatchesByPath(
                    'HLT_Mu17_TkMu8_v*', 1, 0).size() and (
                        (mu17_1 and mu8tk_2) or (mu17_2 and mu8tk_1)):
                return True
            if lep2.sourcePtr().triggerObjectMatchesByPath(
                    'HLT_Mu17_TkMu8_v*', 1, 0).size() and (
                        (mu17_1 and mu8tk_2) or (mu17_2 and mu8tk_1)):
                return True
            return False

        def passMuEG(mu, el):
            if (mu.sourcePtr().triggerObjectMatchesByFilter(
                    "hltL1Mu12EG7L3MuFiltered17"
            ).size() > 0 and el.sourcePtr().triggerObjectMatchesByFilter(
                    "hltMu17Ele8CaloIdTCaloIsoVLTrkIdVLTrkIsoVLTrackIsoFilter"
            ).size()):
                return True
            if (mu.sourcePtr().triggerObjectMatchesByFilter(
                    "hltL1sL1Mu3p5EG12ORL1MuOpenEG12L3Filtered8"
            ).size() > 0 and el.sourcePtr().triggerObjectMatchesByFilter(
                    "hltMu8Ele17CaloIdTCaloIsoVLTrkIdVLTrkIsoVLTrackIsoFilter"
            ).size()):
                return True
            return False

        for lep in event.selectedLeptons:
            self.leptonMVA.addMVA(lep)

        # now fill probes
        for lep in event.selectedLeptons:
            fillLepton(tr, "Probe", lep)
            fill(tr, 'mtw_probe', mtw(lep, event.met))
            fill(tr, 'mtwNoPU_probe', mtw(lep, event.metNoPU))
            fill(tr, 'Trig_Probe_Mu5', passTrigg(lep, ['Mu5']))
            fill(tr, 'Trig_Probe_Mu8', passTrigg(lep, ['Mu8']))
            fill(tr, 'Trig_Probe_Mu12', passTrigg(lep, ['Mu12']))
            fill(tr, 'Trig_Probe_Mu17', passTrigg(lep, ['Mu17']))
            fill(tr, 'Trig_Probe_Mu24', passTrigg(lep, ['Mu24_eta2p1']))
            fill(tr, 'Trig_Probe_Mu40', passTrigg(lep, ['Mu40_eta2p1']))
            fill(tr, 'Trig_Probe_RelIso1p0Mu5',
                 passTrigg(lep, ['RelIso1p0Mu5']))
            fill(tr, 'Trig_Probe_1ElL', passSingleElL(lep))
            fill(tr, 'Trig_Probe_1ElT', passSingleElT(lep))
            # first search for a jet tag
            fill(tr, 'tagType', 1)  # jet
            for jet in event.cleanJets:
                dr = deltaR(jet.eta(), jet.phi(), lep.eta(), lep.phi())
                dphi = deltaPhi(jet.phi(), lep.phi())
                if (dr < 0.8): continue
                self.counters.counter('pairs').inc('loose jet')
                if jet.pt() < self.cfg_ana.tagJetSel['minPt']: continue
                self.counters.counter('pairs').inc('high pt jet')
                if jet.btag('combinedSecondaryVertexBJetTags'
                            ) < self.cfg_ana.tagJetSel['minBTag']:
                    continue
                self.counters.counter('pairs').inc('bjet tag')
                fillJet(tr, "TagJet", jet)
                fill(tr, 'dr_tp', dr)
                fill(tr, 'dphi_tp', dphi)
                tr.tree.Fill()
                break
            # then search for a lepton tag
            fill(tr, 'tagType', 13)  # muon
            for tag in event.looseLeptons:
                if abs(tag.pdgId()) != 13: continue
                if tag.pt() < 10: continue
                if tag.sourcePtr().userFloat("isPFMuon") < 0.5: continue
                if tag.sip3D() < self.cfg_ana.tagLeptonSel['minSip3D']:
                    continue
                if tag.relIso() < self.cfg_ana.tagLeptonSel['minRelIso']:
                    continue
                dr = deltaR(tag.eta(), tag.phi(), lep.eta(), lep.phi())
                dphi = deltaPhi(tag.phi(), lep.phi())
                if (dr < 0.8): continue
                fillLepton(tr, "TagLepton", tag)
                fill(tr, 'mtw_tag', mtw(tag, event.met))
                fill(tr, 'mtwNoPU_tag', mtw(tag, event.metNoPU))
                fill(tr, 'dr_tp', dr)
                fill(tr, 'dphi_tp', dphi)
                fill(tr, 'mll', (tag.p4() + lep.p4()).M())
                fill(tr, 'Trig_Tag_RelIso1p0Mu5',
                     passTrigg(tag, ['RelIso1p0Mu5']))
                fill(tr, 'Trig_Tag_Mu5', passTrigg(tag, ['Mu5']))
                fill(tr, 'Trig_Tag_Mu8', passTrigg(tag, ['Mu8']))
                fill(tr, 'Trig_Tag_Mu12', passTrigg(tag, ['Mu12']))
                fill(tr, 'Trig_Tag_Mu17', passTrigg(tag, ['Mu17']))
                fill(tr, 'Trig_Tag_Mu24', passTrigg(tag, ['Mu24_eta2p1']))
                fill(tr, 'Trig_Tag_Mu40', passTrigg(tag, ['Mu40_eta2p1']))
                fill(tr, 'Trig_Pair_2Mu',
                     abs(lep.pdgId()) == 13 and passDoubleMu(tag, lep))
                fill(tr, 'Trig_Pair_MuEG',
                     abs(lep.pdgId()) == 11 and passMuEG(tag, lep))
                self.counters.counter('pairs').inc('mu tag')
                tr.tree.Fill()
                break

        return True
Exemple #9
0
    def __init__(self, cfg_ana, cfg_comp, looperName ):
        super(ttHLepEventAnalyzer,self).__init__(cfg_ana,cfg_comp,looperName)
        self.maxLeps = cfg_ana.maxLeps

        self.leptonMVA = LeptonMVA("%s/src/CMGTools/TTHAnalysis/data/leptonMVA/%%s_BDTG.weights.xml" % os.environ['CMSSW_BASE'], self.cfg_comp.isMC)
Exemple #10
0
class ttHLepEventAnalyzer( Analyzer ):
    def __init__(self, cfg_ana, cfg_comp, looperName ):
        super(ttHLepEventAnalyzer,self).__init__(cfg_ana,cfg_comp,looperName)
        self.maxLeps = cfg_ana.maxLeps

        self.leptonMVA = LeptonMVA("%s/src/CMGTools/TTHAnalysis/data/leptonMVA/%%s_BDTG.weights.xml" % os.environ['CMSSW_BASE'], self.cfg_comp.isMC)
    def declareHandles(self):
        super(ttHLepEventAnalyzer, self).declareHandles()
        self.handles['met'] = AutoHandle( 'cmgPFMET', 'std::vector<cmg::BaseMET>' )
        self.handles['nopumet'] = AutoHandle( 'nopuMet', 'std::vector<reco::PFMET>' )
        self.handles['metSignificance'] = AutoHandle( 'pfMetSignificance', 'cmg::METSignificance' )

    def beginLoop(self):
        super(ttHLepEventAnalyzer,self).beginLoop()
        self.counters.addCounter('events')
        count = self.counters.counter('events')
        count.register('all events')
        count.register('accepted events')

    def makeZs(self, event, maxLeps):
        event.bestZ1 = [ 0., -1,-1 ]
        event.bestZ1sfss = [ 0., -1,-1 ]
        event.bestZ2 = [ 0., -1,-1, 0. ]
        nlep = len(event.selectedLeptons)
        for i,l1 in enumerate(event.selectedLeptons):
            for j in range(i+1,nlep):
                if j >= maxLeps: break
                l2 = event.selectedLeptons[j]    
                if l1.pdgId() == -l2.pdgId():
                    zmass = (l1.p4() + l2.p4()).M()
                    if event.bestZ1[0] == 0 or abs(zmass - 91.188) < abs(event.bestZ1[0] - 91.188):
                        event.bestZ1 = [ zmass, i, j ]
                if l1.pdgId() == l2.pdgId():
                    zmass = (l1.p4() + l2.p4()).M()
                    if event.bestZ1sfss[0] == 0 or abs(zmass - 91.188) < abs(event.bestZ1sfss[0] - 91.188):
                        event.bestZ1sfss = [ zmass, i, j ]
        if event.bestZ1[0] != 0 and nlep > 3:
            for i,l1 in enumerate(event.selectedLeptons):
                if i == event.bestZ1[1]: continue
                for j in range(i+1,nlep):
                    if j >= maxLeps: break
                    if j == event.bestZ1[2]: continue
                    l2 = event.selectedLeptons[j]    
                    if l1.pdgId() == -l2.pdgId():
                        if l1.pt() + l2.pt() > event.bestZ2[0]:
                            event.bestZ2 = [ l1.pt() + l2.pt(), i, j, (l1.p4() + l2.p4()).M() ]

    def makeMlls(self, event, maxLeps):
        mllsfos = self.mllValues(event,  lambda l1,l2 : l1.pdgId()  == -l2.pdgId(),  maxLeps)
        mllafos = self.mllValues(event,  lambda l1,l2 : l1.charge() == -l2.charge(),  maxLeps)
        mllafss = self.mllValues(event,  lambda l1,l2 : l1.charge() ==  l2.charge(),  maxLeps)
        mllafas = self.mllValues(event,  lambda l1,l2 : True, maxLeps)
        event.minMllSFOS = min(mllsfos)
        event.minMllAFOS = min(mllafos)
        event.minMllAFSS = min(mllafss)
        event.minMllAFAS = min(mllafas)
        event.maxMllSFOS = max(mllsfos)
        event.maxMllAFAS = max(mllafas)
        event.maxMllAFOS = max(mllafos)
        event.maxMllAFSS = max(mllafss)
        drllafos = self.drllValues(event,  lambda l1,l2 : l1.charge() == -l2.charge(),  maxLeps)
        drllafss = self.drllValues(event,  lambda l1,l2 : l1.charge() ==  l2.charge(),  maxLeps)
        event.minDrllAFSS = min(drllafss)
        event.minDrllAFOS = min(drllafos)
        event.maxDrllAFOS = max(drllafos)
        event.maxDrllAFSS = max(drllafss)
        ptllafos = self.ptllValues(event,  lambda l1,l2 : l1.charge() == -l2.charge(),  maxLeps)
        ptllafss = self.ptllValues(event,  lambda l1,l2 : l1.charge() ==  l2.charge(),  maxLeps)
        event.minPtllAFSS = min(ptllafss)
        event.minPtllAFOS = min(ptllafos)
        event.maxPtllAFOS = max(ptllafos)
        event.maxPtllAFSS = max(ptllafss)
        leps = event.selectedLeptons; nlep = len(leps)
        event.m2l = (leps[0].p4() + leps[1].p4()).M() if nlep >= 2 else 0
        event.pt2l = (leps[0].p4() + leps[1].p4()).Pt() if nlep >= 2 else 0
        event.q3l = sum([l.charge() for l in leps[:2]]) if nlep >= 3 else 0
        event.ht3l = sum([l.pt() for l in leps[:2]]) if nlep >= 3 else 0
        event.pt3l = (leps[0].p4() + leps[1].p4() + leps[2].p4()).Pt() if nlep >= 3 else 0
        event.m3l = (leps[0].p4() + leps[1].p4() + leps[2].p4()).M() if nlep >= 3 else 0
        event.q4l = sum([l.charge() for l in leps[:3]])  if nlep >= 4 else 0
        event.ht4l = sum([l.pt() for l in leps[:3]]) if nlep >= 4 else 0
        event.pt4l = (leps[0].p4() + leps[1].p4() + leps[2].p4() + leps[3].p4()).Pt() if nlep >= 4 else 0
        event.m4l = (leps[0].p4() + leps[1].p4() + leps[2].p4() + leps[3].p4()).M() if nlep >= 4 else 0
        event.vtx2l = twoTrackChi2(leps[0],leps[1]) if nlep >= 2 else (-1,-1)

    def mllValues(self, event, pairSelection, maxLeps):
        return self.llValues(event, lambda l1,l2: (l1.p4() + l2.p4()).M(), pairSelection, maxLeps)

    def drllValues(self, event, pairSelection, maxLeps):
        return self.llValues(event, lambda l1,l2: deltaR(l1.eta(), l1.phi(), l2.eta(), l2.phi()), pairSelection, maxLeps)

    def ptllValues(self, event, pairSelection, maxLeps):
        return self.llValues(event, lambda l1,l2: (l1.p4() + l2.p4()).Pt(), pairSelection, maxLeps)

    def llValues(self, event, function, pairSelection, maxLeps):
        pairs = []
        nlep = len(event.selectedLeptons)
        for i,l1 in enumerate(event.selectedLeptons):
            for j in range(i+1,nlep):
                if j >= maxLeps: break
                l2 = event.selectedLeptons[j]    
                if pairSelection(l1,l2):
                    pairs.append( function(l1, l2) )
        if pairs == []: pairs.append(-1)
        return pairs
    
    def makeLepBJetDeltaR(self, event):
        for l in event.selectedLeptons + event.looseLeptons:
            match, dr = bestMatch(l, event.bjetsLoose)
            l.drBJet = dr

        for l in event.selectedLeptons:
            (px,py,pz) = (l.px(),l.py(),l.pz())
            (jx,jy,jz) = (l.jet.px(),l.jet.py(),l.jet.pz())
            cross = (px*jy-py*jx, py*jz-pz*jy, pz*jx-px*jz)
            l.ptRelJet = sqrt(sum([v*v for v in cross]))/l.jet.p()

    def jetProjectedMET(self, met, jets, oneSided=True):
        import math
        projfactor = 1.0
        for j in jets:
            dphi = abs(deltaPhi(j.phi(), met.phi()))
            proj = sin(dphi)
            if oneSided and dphi > 0.5*math.pi:
                continue
            if projfactor > proj: projfactor = proj
        return met.pt()*projfactor

    def makeMETs(self, event):
        event.met = self.handles['met'].product()[0]
        event.metNoPU = self.handles['nopumet'].product()[0]
        if hasattr(event, 'deltaMetFromJetSmearing'):
            import ROOT
            px,py = event.met.px()+event.deltaMetFromJetSmearing[0], event.met.py()+event.deltaMetFromJetSmearing[1]
            event.met.setP4(ROOT.reco.Particle.LorentzVector(px,py, 0, hypot(px,py)))
            px,py = event.metNoPU.px()+event.deltaMetFromJetSmearing[0], event.metNoPU.py()+event.deltaMetFromJetSmearing[1]
            event.metNoPU.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.met.px()+event.deltaMetFromJEC[0], event.met.py()+event.deltaMetFromJEC[1]
            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)))

        metMatrix = self.handles['metSignificance'].product().significance()
        metMatrix.Invert();
        import array
        metVector = TVectorD(2,array.array('d',[event.met.px(), event.met.py()]))
        event.metSignificance = metMatrix.Similarity(metVector) 
        event.projMetAll1S  = self.jetProjectedMET(event.met, event.jets,True)
        event.projMetAll2S  = self.jetProjectedMET(event.met, event.jets,False)
        event.projMetJets1S = self.jetProjectedMET(event.met, event.cleanJets,True)
        event.projMetJets2S = self.jetProjectedMET(event.met, event.cleanJets,False)
        #print "MET value:  ", event.met.pt()
        #print "MET sumET:  ", event.met.sumEt()
        #print "MET signif: ", event.metSignificance
        #print "PrMETAll 1S:", event.projMetAll1S 
        #print "PrMETAll 2S:", event.projMetAll2S 
        #print "PrMETJet 1S:", event.projMetJets1S 
        #print "PrMETJet 2S:", event.projMetJets2S

    def makeHadTopDecays(self, event):
        event.lightJets = [ j for j in event.cleanJets if not j.btagWP("CSVM") ]
        event.minMWjj   = 999
        event.minMWjjPt = 0
        event.bestMWjj   = 0
        event.bestMWjjPt = 0
        event.bestMTopHad   = 0
        event.bestMTopHadPt = 0
        for i1,j1 in enumerate(event.lightJets):
            for i2 in xrange(i1+1,len(event.lightJets)):
                j2 = event.lightJets[i2]
                jjp4 = j1.p4() + j2.p4()
                mjj  = jjp4.M()
                if mjj > 30 and mjj < event.minMWjj:
                    event.minMWjj = mjj
                    event.minMWjjPt = jjp4.Pt()
                if abs(mjj-80.4) < abs(event.bestMWjj-80.4):
                    event.bestMWjj = mjj
                    event.bestMWjjPt = jjp4.Pt()
                    for bj in event.bjetsLoose:
                        if deltaR(bj.eta(),bj.phi(),j1.eta(),j1.phi()) < 0.1 or deltaR(bj.eta(),bj.phi(),j2.eta(),j2.phi()) < 0.1: continue
                        tp4 = jjp4 + bj.p4()
                        mtop = tp4.M()
                        if abs(mtop-172) < abs(event.bestMTopHad - 172):
                            event.bestMTopHad = mtop
                            event.bestMTopHadPt = tp4.Pt()

    def process(self, iEvent, event):
        self.readCollections( iEvent )
        self.counters.counter('events').inc('all events')

        if hasattr(self.cfg_ana, 'minJets25'):
            n25 = len([ j for j in event.cleanJets if j.pt() > 25 ])
            if n25 < self.cfg_ana.minJets25: 
                return False

        eventNumber = iEvent.eventAuxiliary().id().event()

        event.bjetsLoose  = [ j for j in event.cleanJets if j.btagWP("CSVL") ]
        event.bjetsMedium = [ j for j in event.cleanJets if j.btagWP("CSVM") ]

        objects25 = [ j for j in event.cleanJets if j.pt() > 25 ] + event.selectedLeptons
        objects30 = [ j for j in event.cleanJets if j.pt() > 30 ] + event.selectedLeptons
        objects40j = [ j for j in event.cleanJets if j.pt() > 40 ] 
        objects40  = [ j for j in event.cleanJets if j.pt() > 40 ] + event.selectedLeptons
        event.htJet25 = sum([x.pt() for x in objects25])
        event.mhtJet25 = hypot(sum([x.px() for x in objects25]), sum([x.py() for x in objects25]))
        event.htJet30 = sum([x.pt() for x in objects30])
        event.mhtJet30 = hypot(sum([x.px() for x in objects30]), sum([x.py() for x in objects30]))
        event.htJet40 = sum([x.pt() for x in objects40])
        event.htJet40j = sum([x.pt() for x in objects40j])
        event.mhtJet40 = hypot(sum([x.px() for x in objects40]), sum([x.py() for x in objects40]))
        ## same but with all eta range
        objects25a = [ j for j in event.cleanJetsAll if j.pt() > 25 ] + event.selectedLeptons
        objects30a = [ j for j in event.cleanJetsAll if j.pt() > 30 ] + event.selectedLeptons
        event.htJet25a = sum([x.pt() for x in objects25a])
        event.mhtJet25a = hypot(sum([x.px() for x in objects25a]), sum([x.py() for x in objects25a]))
        event.htJet30a = sum([x.pt() for x in objects30a])
        event.mhtJet30a = hypot(sum([x.px() for x in objects30a]), sum([x.py() for x in objects30a]))

        self.makeMETs(event);
        self.makeZs(event, self.maxLeps)
        self.makeMlls(event, self.maxLeps)

        self.makeHadTopDecays(event)
        for lep in event.selectedLeptons:
            self.leptonMVA.addMVA(lep)
        for lep in event.inclusiveLeptons:
            if lep not in event.selectedLeptons:
                self.leptonMVA.addMVA(lep)

        if self.cfg_ana.verbose:
            print 'Event ',eventNumber
            print 'Selected leptons: ',len(event.selectedLeptons)
            print "\n".join(["\t%s" % p for p in event.selectedLeptons])
            print 'Selected clean jets   : ',len(event.cleanJets)
            print "\n".join(["\t%s" % p for p in event.cleanJets])
            print 'Selected loose  b-jets: ',len(event.bjetsLoose)
            print 'Selected medium b-jets: ',len(event.bjetsMedium)
            print 'Best Z1, if any: mass = %6.1f ' % event.bestZ1[0]
            print 'Best Z2, if any: mass = %6.1f ' % event.bestZ2[3]
            print 'Min m(ll) values: SF/OS = %5.1f, AF/OS = %5.1f, AF/AS = %5.1f' % (event.minMllSFOS, event.minMllAFOS, event.minMllAFAS)

        self.counters.counter('events').inc('accepted events')
        return True
class ttHCoreEventAnalyzer(Analyzer):
    def __init__(self, cfg_ana, cfg_comp, looperName):
        super(ttHCoreEventAnalyzer, self).__init__(cfg_ana, cfg_comp,
                                                   looperName)
        self.maxLeps = cfg_ana.maxLeps
        self.leptonMVA = LeptonMVA(
            "%s/src/CMGTools/TTHAnalysis/data/leptonMVA/%%s_BDTG.weights.xml" %
            os.environ['CMSSW_BASE'], self.cfg_comp.isMC)

    def declareHandles(self):
        super(ttHCoreEventAnalyzer, self).declareHandles()
        self.handles['met'] = AutoHandle('cmgPFMET',
                                         'std::vector<cmg::BaseMET>')
        self.handles['nopumet'] = AutoHandle('nopuMet',
                                             'std::vector<reco::PFMET>')
        self.handles['metSignificance'] = AutoHandle('pfMetSignificance',
                                                     'cmg::METSignificance')
        self.handles['rho'] = AutoHandle(('kt6PFJets', 'rho', ''), 'double')

    def beginLoop(self):
        super(ttHCoreEventAnalyzer, self).beginLoop()
        self.counters.addCounter('events')
        count = self.counters.counter('events')
        count.register('all events')

    def makeZs(self, event, maxLeps):
        event.bestZ1 = [0., -1, -1]
        event.bestZ1sfss = [0., -1, -1]
        event.bestZ2 = [0., -1, -1, 0.]
        nlep = len(event.selectedLeptons)
        for i, l1 in enumerate(event.selectedLeptons):
            for j in range(i + 1, nlep):
                if j >= maxLeps: break
                l2 = event.selectedLeptons[j]
                if l1.pdgId() == -l2.pdgId():
                    zmass = (l1.p4() + l2.p4()).M()
                    if event.bestZ1[0] == 0 or abs(zmass - 91.188) < abs(
                            event.bestZ1[0] - 91.188):
                        event.bestZ1 = [zmass, i, j]
                if l1.pdgId() == l2.pdgId():
                    zmass = (l1.p4() + l2.p4()).M()
                    if event.bestZ1sfss[0] == 0 or abs(zmass - 91.188) < abs(
                            event.bestZ1sfss[0] - 91.188):
                        event.bestZ1sfss = [zmass, i, j]
        if event.bestZ1[0] != 0 and nlep > 3:
            for i, l1 in enumerate(event.selectedLeptons):
                if i == event.bestZ1[1]: continue
                for j in range(i + 1, nlep):
                    if j >= maxLeps: break
                    if j == event.bestZ1[2]: continue
                    l2 = event.selectedLeptons[j]
                    if l1.pdgId() == -l2.pdgId():
                        if l1.pt() + l2.pt() > event.bestZ2[0]:
                            event.bestZ2 = [
                                l1.pt() + l2.pt(), i, j,
                                (l1.p4() + l2.p4()).M()
                            ]

    def makeMlls(self, event, maxLeps):
        mllsfos = self.mllValues(event,
                                 lambda l1, l2: l1.pdgId() == -l2.pdgId(),
                                 maxLeps)
        mllafos = self.mllValues(event,
                                 lambda l1, l2: l1.charge() == -l2.charge(),
                                 maxLeps)
        mllafss = self.mllValues(event,
                                 lambda l1, l2: l1.charge() == l2.charge(),
                                 maxLeps)
        mllafas = self.mllValues(event, lambda l1, l2: True, maxLeps)
        event.minMllSFOS = min(mllsfos)
        event.minMllAFOS = min(mllafos)
        event.minMllAFSS = min(mllafss)
        event.minMllAFAS = min(mllafas)
        event.maxMllSFOS = max(mllsfos)
        event.maxMllAFAS = max(mllafas)
        event.maxMllAFOS = max(mllafos)
        event.maxMllAFSS = max(mllafss)
        drllafos = self.drllValues(event,
                                   lambda l1, l2: l1.charge() == -l2.charge(),
                                   maxLeps)
        drllafss = self.drllValues(event,
                                   lambda l1, l2: l1.charge() == l2.charge(),
                                   maxLeps)
        event.minDrllAFSS = min(drllafss)
        event.minDrllAFOS = min(drllafos)
        event.maxDrllAFOS = max(drllafos)
        event.maxDrllAFSS = max(drllafss)
        ptllafos = self.ptllValues(event,
                                   lambda l1, l2: l1.charge() == -l2.charge(),
                                   maxLeps)
        ptllafss = self.ptllValues(event,
                                   lambda l1, l2: l1.charge() == l2.charge(),
                                   maxLeps)
        event.minPtllAFSS = min(ptllafss)
        event.minPtllAFOS = min(ptllafos)
        event.maxPtllAFOS = max(ptllafos)
        event.maxPtllAFSS = max(ptllafss)
        leps = event.selectedLeptons
        nlep = len(leps)
        event.m2l = (leps[0].p4() + leps[1].p4()).M() if nlep >= 2 else 0
        event.pt2l = (leps[0].p4() + leps[1].p4()).Pt() if nlep >= 2 else 0
        event.q3l = sum([l.charge() for l in leps[:2]]) if nlep >= 3 else 0
        event.ht3l = sum([l.pt() for l in leps[:2]]) if nlep >= 3 else 0
        event.pt3l = (leps[0].p4() + leps[1].p4() +
                      leps[2].p4()).Pt() if nlep >= 3 else 0
        event.m3l = (leps[0].p4() + leps[1].p4() +
                     leps[2].p4()).M() if nlep >= 3 else 0
        event.q4l = sum([l.charge() for l in leps[:3]]) if nlep >= 4 else 0
        event.ht4l = sum([l.pt() for l in leps[:3]]) if nlep >= 4 else 0
        event.pt4l = (leps[0].p4() + leps[1].p4() + leps[2].p4() +
                      leps[3].p4()).Pt() if nlep >= 4 else 0
        event.m4l = (leps[0].p4() + leps[1].p4() + leps[2].p4() +
                     leps[3].p4()).M() if nlep >= 4 else 0
        event.vtx2l = twoTrackChi2(leps[0], leps[1]) if nlep >= 2 else (-1, -1)

    def mllValues(self, event, pairSelection, maxLeps):
        return self.llValues(event, lambda l1, l2: (l1.p4() + l2.p4()).M(),
                             pairSelection, maxLeps)

    def drllValues(self, event, pairSelection, maxLeps):
        return self.llValues(
            event,
            lambda l1, l2: deltaR(l1.eta(), l1.phi(), l2.eta(), l2.phi()),
            pairSelection, maxLeps)

    def ptllValues(self, event, pairSelection, maxLeps):
        return self.llValues(event, lambda l1, l2: (l1.p4() + l2.p4()).Pt(),
                             pairSelection, maxLeps)

    def llValues(self, event, function, pairSelection, maxLeps):
        pairs = []
        nlep = len(event.selectedLeptons)
        for i, l1 in enumerate(event.selectedLeptons):
            for j in range(i + 1, nlep):
                if j >= maxLeps: break
                l2 = event.selectedLeptons[j]
                if pairSelection(l1, l2):
                    pairs.append(function(l1, l2))
        if pairs == []: pairs.append(-1)
        return pairs

    def makeLepPtRel(self, event):
        for l in event.selectedLeptons:
            (px, py, pz) = (l.px(), l.py(), l.pz())
            (jx, jy, jz) = (l.jet.px(), l.jet.py(), l.jet.pz())
            cross = (px * jy - py * jx, py * jz - pz * jy, pz * jx - px * jz)
            l.ptRelJet = sqrt(sum([v * v for v in cross])) / l.jet.p()

    def makeMETs(self, event):
        event.met = self.handles['met'].product()[0]
        event.metNoPU = self.handles['nopumet'].product()[0]
        if hasattr(event, 'deltaMetFromJetSmearing'):
            import ROOT
            px, py = event.met.px() + event.deltaMetFromJetSmearing[
                0], event.met.py() + event.deltaMetFromJetSmearing[1]
            event.met.setP4(
                ROOT.reco.Particle.LorentzVector(px, py, 0, hypot(px, py)))
            px, py = event.metNoPU.px() + event.deltaMetFromJetSmearing[
                0], event.metNoPU.py() + event.deltaMetFromJetSmearing[1]
            event.metNoPU.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.met.px() + event.deltaMetFromJEC[0], event.met.py(
            ) + event.deltaMetFromJEC[1]
            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)))

        metMatrix = self.handles['metSignificance'].product().significance()
        metMatrix.Invert()
        import array
        metVector = TVectorD(
            2, array.array('d',
                           [event.met.px(), event.met.py()]))
        event.metSignificance = metMatrix.Similarity(metVector)

    def process(self, iEvent, event):
        self.readCollections(iEvent)
        self.counters.counter('events').inc('all events')

        event.rho = self.handles['rho'].product()[0]
        event.bjetsLoose = [j for j in event.cleanJets if j.btagWP("CSVL")]
        event.bjetsMedium = [j for j in event.cleanJets if j.btagWP("CSVM")]

        import ROOT

        objects25 = [j for j in event.cleanJets if j.pt() > 25
                     ] + event.selectedLeptons
        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]
        objects40jc = [
            j for j in event.cleanJets if j.pt() > 40 and abs(j.eta()) < 2.5
        ]

        event.htJet25 = sum([x.pt() for x in objects25])
        event.mhtJet25vec = ROOT.reco.Particle.LorentzVector(
            -1. * (sum([x.px() for x in objects25])),
            -1. * (sum([x.py() for x in objects25])), 0, 0)
        event.mhtPhiJet25 = event.mhtJet25vec.phi()
        event.mhtJet25 = event.mhtJet25vec.pt()

        event.htJet30 = sum([x.pt() for x in objects30])
        event.mhtJet30vec = ROOT.reco.Particle.LorentzVector(
            -1. * (sum([x.px() for x in objects30])),
            -1. * (sum([x.py() for x in objects30])), 0, 0)
        event.mhtJet30 = event.mhtJet30vec.pt()
        event.mhtPhiJet30 = event.mhtJet30vec.phi()

        event.htJet40 = sum([x.pt() for x in objects40])
        event.mhtJet40vec = ROOT.reco.Particle.LorentzVector(
            -1. * (sum([x.px() for x in objects40])),
            -1. * (sum([x.py() for x in objects40])), 0, 0)
        event.mhtJet40 = event.mhtJet40vec.pt()
        event.mhtPhiJet40 = event.mhtJet40vec.phi()

        event.htJet40j = sum([x.pt() for x in objects40j])
        event.mhtJet40jvec = ROOT.reco.Particle.LorentzVector(
            -1. * (sum([x.px() for x in objects40j])),
            -1. * (sum([x.py() for x in objects40j])), 0, 0)
        event.mhtJet40j = event.mhtJet40jvec.pt()
        event.mhtPhiJet40j = event.mhtJet40jvec.phi()

        event.htJet40jc = sum([x.pt() for x in objects40jc])
        event.mhtJet40jcvec = ROOT.reco.Particle.LorentzVector(
            -1. * (sum([x.px() for x in objects40jc])),
            -1. * (sum([x.py() for x in objects40jc])), 0, 0)
        event.mhtJet40jc = event.mhtJet40jcvec.pt()
        event.mhtPhiJet40jc = event.mhtJet40jcvec.phi()

        ## same but with all eta range
        objects25a = [j for j in event.cleanJetsAll if j.pt() > 25
                      ] + event.selectedLeptons
        objects30a = [j for j in event.cleanJetsAll if j.pt() > 30
                      ] + event.selectedLeptons
        objects40a = [j for j in event.cleanJetsAll if j.pt() > 40
                      ] + event.selectedLeptons
        objects40ja = [j for j in event.cleanJetsAll if j.pt() > 40]

        event.htJet25a = sum([x.pt() for x in objects25a])
        event.mhtJet25veca = ROOT.reco.Particle.LorentzVector(
            -1. * (sum([x.px() for x in objects25a])),
            -1. * (sum([x.py() for x in objects25a])), 0, 0)
        event.mhtPhiJet25a = event.mhtJet25veca.phi()
        event.mhtJet25a = event.mhtJet25veca.pt()

        event.htJet30a = sum([x.pt() for x in objects30a])
        event.mhtJet30veca = ROOT.reco.Particle.LorentzVector(
            -1. * (sum([x.px() for x in objects30a])),
            -1. * (sum([x.py() for x in objects30a])), 0, 0)
        event.mhtJet30a = event.mhtJet30veca.pt()
        event.mhtPhiJet30a = event.mhtJet30veca.phi()

        event.htJet40a = sum([x.pt() for x in objects40a])
        event.mhtJet40veca = ROOT.reco.Particle.LorentzVector(
            -1. * (sum([x.px() for x in objects40a])),
            -1. * (sum([x.py() for x in objects40a])), 0, 0)
        event.mhtJet40a = event.mhtJet40veca.pt()
        event.mhtPhiJet40a = event.mhtJet40veca.phi()

        event.htJet40ja = sum([x.pt() for x in objects40ja])
        event.mhtJet40jveca = ROOT.reco.Particle.LorentzVector(
            -1. * (sum([x.px() for x in objects40ja])),
            -1. * (sum([x.py() for x in objects40ja])), 0, 0)
        event.mhtJet40ja = event.mhtJet40jveca.pt()
        event.mhtPhiJet40ja = event.mhtJet40jveca.phi()

        self.makeMETs(event)
        self.makeZs(event, self.maxLeps)
        self.makeMlls(event, self.maxLeps)
        self.makeLepPtRel(event)

        # look for minimal deltaPhi between MET and four leading jets with pt>40 and eta<2.4
        event.deltaPhiMin = 999.
        for n, j in enumerate(objects40jc):
            if n > 3: break
            thisDeltaPhi = abs(deltaPhi(j.phi(), event.met.phi()))
            if thisDeltaPhi < event.deltaPhiMin:
                event.deltaPhiMin = thisDeltaPhi

        for lep in event.selectedLeptons:
            self.leptonMVA.addMVA(lep)
        for lep in event.inclusiveLeptons:
            if lep not in event.selectedLeptons:
                self.leptonMVA.addMVA(lep)

        # absolute value of the vectorial difference between met and mht
        diffMetMht_vec = ROOT.reco.Particle.LorentzVector(
            event.mhtJet40jcvec.px() - event.met.px(),
            event.mhtJet40jcvec.py() - event.met.py(), 0, 0)
        event.diffMetMht = sqrt(diffMetMht_vec.px() * diffMetMht_vec.px() +
                                diffMetMht_vec.py() * diffMetMht_vec.py())

        return True