Example #1
0
    def process (self, iEvent, event) :
        #read all the handles defined beforehand
        self.readCollections (iEvent)
        
        jetEtaCut = 4.5 
        
        # get the vertexes
        event.vertices = self.handles['vertices'].product ()
#        self.h_nvtx.Fill (len (event.vertices))
        
        # get the jets in the jets variable
        jets = self.handles['jets'].product ()
        # filter jets with some selections
        event.jets = [ jet for jet in jets if ( abs(jet.eta()) < jetEtaCut and jet.pt()>self.cfg_ana.ptCut and self.isPFLoose(jet) ) ]
        
        # get status 2 leptons
        if 'genParticlesPruned' in self.mchandles:
            event.genLeptons = [ lep for lep in self.mchandles['genParticlesPruned'].product() if lep.status() == 2 and (abs(lep.pdgId()) == 11 or abs(lep.pdgId()) == 13 or abs(lep.pdgId()) == 15) ]  
        else:
            event.genLeptons = [ lep for lep in self.mchandles['genParticles'].product() if lep.status() == 3 and (abs(lep.pdgId()) == 11 or abs(lep.pdgId()) == 13 or abs(lep.pdgId()) == 15) ]  
# @ Pasquale: why level 3 and not level 2?
#        event.selGenLeptons = [GenParticle (lep) for lep in event.genLeptons if (lep.pt ()>self.cfg_ana.ptCut and abs (lep.eta ()) < jetEtaCut)]
        
        # get genJets
        event.genJets = map (GenJet, self.mchandles['genJets'].product ())
        # filter genjets as for reco jets
        event.selGenJets = [GenJet (jet) for jet in event.genJets if (jet.pt ()>self.cfg_ana.genPtCut)]
        
        #FIXME why are there cases in which there's 4 or 6 leptons?
        if len (event.genLeptons) != 2 :
            return
        # in case I want to filter out taus
        # 11, 13, 15 : e, u, T
#        event.genOneLepton = [GenParticle (part) for part in event.genLeptons if abs (part.pdgId ()) == 15]
        # remove leptons from jets if closer than 0.2
        event.cleanJets = cleanObjectCollection (event.jets, event.genLeptons, 0.2)
        event.matchingCleanJets = matchObjectCollection2 (event.cleanJets, event.selGenJets, 0.25)
        # assign to each jet its gen match (easy life :))
        for jet in event.cleanJets :
            jet.gen = event.matchingCleanJets[ jet ]

        
        event.matchedCleanJets = [jet for jet in event.matchingCleanJets if jet.gen != None]
        for jet in event.matchedCleanJets:
            self.myntuple.Fill (jet.gen.pt (), jet.pt (), jet.gen.eta (), jet.eta (), jet.gen.phi (), jet.phi (), len (event.vertices))
    def process(self, iEvent, event):
        # read all the handles defined beforehand
        self.readCollections(iEvent)

        jetEtaCut = 4.5

        # get the vertexes
        event.vertices = self.handles["vertices"].product()
        self.h_nvtx.Fill(len(event.vertices))
        event.vertexBin = int(len(event.vertices))

        # get the jets in the jets variable
        jets = self.handles["jets"].product()
        # filter jets with some selections
        event.jets = [
            jet
            for jet in jets
            if (abs(jet.eta()) < jetEtaCut and jet.pt() > self.cfg_ana.ptCut and self.isPFLoose(jet))
        ]
        self.jetHistos.fillEvent(event.jets)

        # get status 2 leptons
        if "genParticlesPruned" in self.mchandles:
            event.genLeptons = [
                lep
                for lep in self.mchandles["genParticlesPruned"].product()
                if lep.status() == 3 and (abs(lep.pdgId()) == 11 or abs(lep.pdgId()) == 13 or abs(lep.pdgId()) == 15)
            ]
        else:
            event.genLeptons = [
                lep
                for lep in self.mchandles["genParticles"].product()
                if lep.status() == 3 and (abs(lep.pdgId()) == 11 or abs(lep.pdgId()) == 13 or abs(lep.pdgId()) == 15)
            ]
        # @ Pasquale: why level 3 and not level 2?
        #        event.selGenLeptons = [GenParticle (lep) for lep in event.genLeptons if (lep.pt ()>self.cfg_ana.ptCut and abs (lep.eta ()) < jetEtaCut)]

        # get genJets
        event.genJets = map(GenJet, self.mchandles["genJets"].product())
        # filter genjets as for reco jets
        event.myGenJets = [GenJet(jet) for jet in event.genJets if (jet.pt() > self.cfg_ana.genPtCut)]
        event.selGenJets = cleanObjectCollection(event.myGenJets, event.genLeptons, 0.2)
        # event.selGenJets = event.genJets
        for jet in event.selGenJets:
            self.h_genjetspt.Fill(jet.pt())
            self.h_genjetspt2.Fill(jet.pt())
            if abs(jet.eta()) < 1.4:
                self.h_genjetspt_barrel.Fill(jet.pt())
            elif 1.6 < abs(jet.eta()) < 2.5:
                self.h_genjetspt_endtk.Fill(jet.pt())
            elif 2.6 < abs(jet.eta()) < 2.9:
                self.h_genjetspt_endNOtk.Fill(jet.pt())
            elif 3.1 < abs(jet.eta()):
                self.h_genjetspt_fwd.Fill(jet.pt())

        event.noNegJets = [jet for jet in event.jets if (jet.jecFactor(0) > 0)]

        # first stats plots
        # print 'genLeptons : ' + repr (len (event.genLeptons)) + ' | genJets : ' + repr (len (event.genJets)) + ' | recoJets : ' + repr (len (event.jets))
        self.jetHistos.fillStats(len(event.selGenJets), len(event.noNegJets))

        # FIXME why are there cases in which there's 4 or 6 leptons?
        if len(event.genLeptons) > 2:
            return
        # in case I want to filter out taus
        # 11, 13, 15 : e, u, T
        #        event.genOneLepton = [GenParticle (part) for part in event.genLeptons if abs (part.pdgId ()) == 15]
        # remove leptons from jets if closer than 0.2
        event.cleanJets = cleanObjectCollection(event.noNegJets, event.genLeptons, 0.2)
        self.cleanJetHistos.fillEvent(event.cleanJets)
        for jet in event.cleanJets:
            if abs(jet.eta()) < 1.4:
                self.cleanJetHistos_barrel.fillJet(jet)
            elif 1.6 < abs(jet.eta()) < 2.5:
                self.cleanJetHistos_endtk.fillJet(jet)
            elif 2.6 < abs(jet.eta()) < 2.9:
                self.cleanJetHistos_endNOtk.fillJet(jet)
            elif 3.1 < abs(jet.eta()):
                self.cleanJetHistos_fwd.fillJet(jet)

        #        print len (jets),len (event.jets), len (event.noNegJets), len (event.cleanJets), len (event.genLeptons),"-->",(len (event.noNegJets) - len (event.cleanJets) - len (event.genLeptons))

        event.matchingCleanJets = matchObjectCollection2(event.cleanJets, event.selGenJets, 0.25)
        # assign to each jet its gen match (easy life :))
        for jet in event.cleanJets:
            jet.gen = event.matchingCleanJets[jet]
        # FIXME next step might be to put this in the matching and remove the boolean flags

        self.cleanJetHistos.fillEvent(event.cleanJets)

        event.matchedCleanJets = [jet for jet in event.matchingCleanJets if jet.gen != None]
        event.cleanGluJets = []
        event.cleanQuarkJets = []
        for jet in event.matchedCleanJets:
            flav = abs(jet.partonFlavour())
            if flav == 21:
                event.cleanGluJets.append(jet)
            elif flav > 0 and flav <= 3:
                event.cleanQuarkJets.append(jet)

        event.LPtmatchedCleanJets = [jet for jet in event.matchingCleanJets if jet.gen != None and jet.pt() <= 30]
        event.HPtmatchedCleanJets = [jet for jet in event.matchingCleanJets if jet.gen != None and jet.pt() > 30]

        self.matchedCleanJetHistos.fillEvent(event.matchedCleanJets)
        self.LPtmatchedCleanJetHistos.fillEvent(event.LPtmatchedCleanJets)
        self.HPtmatchedCleanJetHistos.fillEvent(event.HPtmatchedCleanJets)

        event.unmatchedCleanJets = [jet for jet in event.matchingCleanJets if jet.gen == None]
        event.LPtunmatchedCleanJets = [jet for jet in event.matchingCleanJets if jet.gen == None and jet.pt() <= 30]
        event.HPtunmatchedCleanJets = [jet for jet in event.matchingCleanJets if jet.gen == None and jet.pt() > 30]

        self.unmatchedCleanJetHistos.fillEvent(event.unmatchedCleanJets)
        self.LPtUnmatchedCleanJetHistos.fillEvent(event.LPtunmatchedCleanJets)
        self.HPtUnmatchedCleanJetHistos.fillEvent(event.HPtunmatchedCleanJets)

        self.matchedCleanJetHistosComponents.fillEvent(event.matchedCleanJets)

        self.unmatchedCleanJetHistosComponents.fillEvent(event.unmatchedCleanJets)

        self.matchedCleanJetHistosResolution.fillEvent(event.matchedCleanJets, len(event.vertices))

        for jet in event.matchedCleanJets:
            if abs(jet.gen.eta()) < 1.4:
                self.matchedCleanJetHistosResolution_barrel.fillJet(jet, len(event.vertices))
                self.matchedCleanJetHistos_barrel.fillJet(jet)
            elif 1.6 < abs(jet.gen.eta()) < 2.5:
                self.matchedCleanJetHistosResolution_endtk.fillJet(jet, len(event.vertices))
                self.matchedCleanJetHistos_endtk.fillJet(jet)
            elif 2.6 < abs(jet.gen.eta()) < 2.9:
                self.matchedCleanJetHistosResolution_endNOtk.fillJet(jet, len(event.vertices))
                self.matchedCleanJetHistos_endNOtk.fillJet(jet)
            elif 3.1 < abs(jet.gen.eta()):
                self.matchedCleanJetHistosResolution_fwd.fillJet(jet, len(event.vertices))
                self.matchedCleanJetHistos_fwd.fillJet(jet)

        # PG debugging for tails
        #         for jet in event.matchedCleanJets :
        #             minDelta = 10
        #             secondClosest = jet
        #             for recojet in event.cleanJets :
        #                 if recojet == jet :
        #                     continue
        #                 dr2 = deltaR2( jet.gen.eta (), jet.gen.phi (), recojet.eta (), recojet.phi ())
        #                 if dr2 < minDelta :
        #                     minDelta = dr2
        #                     secondClosest = recojet
        #             if len(event.vertices) < 10 or abs (jet.gen.eta ()) < 1.6: continue
        #             self.h_secondClosestVsPtratio.Fill (jet.pt () / jet.gen.pt (), math.sqrt (minDelta))
        #             #if (jet.pt () / jet.gen.pt () < 0.2) :
        #                 #print '------------'
        #                 #print jet.pt (), jet.eta (), jet.phi ()
        #                 #print jet.gen.pt (), jet.gen.eta (), jet.gen.phi ()
        #                 #print 'second reco closest to gen at distance', minDelta

        #         aveDeltaR = 0
        #         num = 0
        #         for recojet1 in event.cleanJets :
        #             minDelta = 10
        #             closest = recojet1
        #             for recojet2 in event.cleanJets :
        #                 if recojet1 == recojet2 : continue
        #                     dr2 = deltaR2( recojet1.eta (), recojet1.phi (), recojet2.eta (), recojet2.phi ())
        #                     if dr2 < minDelta :
        #                         minDelta = dr2
        #                         closest = recojet2
        #             if minDelta == 10 continue ;
        #             aveDeltaR = aveDeltaR + math.sqrt (minDelta)
        #             num = num + 1
        #         if num > 0 :
        #             aveDeltaR = aveDeltaR / num
        #            self.h_avedistanceVSNvtx.Fill (len(event.vertices), aveDeltaR)

        # AB: fill eta-dependent responses (in bins of gen pt)
        for jet in event.matchedCleanJets:
            if abs(jet.gen.pt()) < 20.0:
                self.matchedCleanJetHistosResolution_PtL.fillJet(jet, len(event.vertices))
                self.matchedCleanJetHistos_PtL.fillJet(jet)
            elif 20.0 < abs(jet.gen.pt()) < 40.0:
                self.matchedCleanJetHistosResolution_PtM.fillJet(jet, len(event.vertices))
                self.matchedCleanJetHistos_PtM.fillJet(jet)
            elif 40.0 < abs(jet.gen.pt()) < 80.0:
                self.matchedCleanJetHistosResolution_PtH.fillJet(jet, len(event.vertices))
                self.matchedCleanJetHistos_PtH.fillJet(jet)
            elif 80.0 < abs(jet.gen.pt()):
                self.matchedCleanJetHistosResolution_PtV.fillJet(jet, len(event.vertices))
                self.matchedCleanJetHistos_PtV.fillJet(jet)

        if self.doJetIdHisto:
            self.gluCleanHistosId.fillEvent(event.cleanGluJets, event.vertices)
            self.quarkCleanHistosId.fillEvent(event.cleanQuarkJets, event.vertices)
            ### self.matchedCleanHistosId.fillEvent(event.matchedCleanJets,event.vertices)
            self.reweiMatchedCleanHistosId.fillEvent(event.matchedCleanJets, event.vertices)
            self.unmatchedCleanHistosId.fillEvent(event.unmatchedCleanJets, event.vertices)
Example #3
0
    def process(self, iEvent, event):
        #read all the handles defined beforehand
        self.readCollections(iEvent)
        #        print '-------'

        jetEtaCut = 4.5

        event.vertices = self.handles['vertices'].product()
        self.h_NVTXnum.Fill(len(event.vertices))

        YeCHSjets = self.handles['YeCHSjets'].product()
        event.YeCHSjets = [
            jet for jet in YeCHSjets
            if (abs(jet.eta()) < jetEtaCut and jet.pt() > self.cfg_ana.ptCut
                and self.isPFLoose(jet))
        ]
        NoCHSjets = self.handles['NoCHSjets'].product()
        event.NoCHSjets = [
            jet for jet in NoCHSjets
            if (abs(jet.eta()) < jetEtaCut and jet.pt() > self.cfg_ana.ptCut
                and self.isPFLoose(jet))
        ]

        # get status 2 leptons
        if 'genParticlesPruned' in self.mchandles:
            event.genLeptons = [
                lep for lep in self.mchandles['genParticlesPruned'].product()
                if lep.status() == 2 and (abs(lep.pdgId()) == 11 or abs(
                    lep.pdgId()) == 13 or abs(lep.pdgId()) == 15)
            ]
        else:
            event.genLeptons = [
                lep for lep in self.mchandles['genParticles'].product()
                if lep.status() == 3 and (abs(lep.pdgId()) == 11 or abs(
                    lep.pdgId()) == 13 or abs(lep.pdgId()) == 15)
            ]

        event.NoCHSgenJets = map(GenJet,
                                 self.mchandles['NoCHSgenJets'].product())
        event.myNoCHSGenJets = [
            GenJet(jet) for jet in event.NoCHSgenJets
            if (jet.pt() > self.cfg_ana.genPtCut)
        ]
        event.selNoCHSGenJets = cleanObjectCollection(event.myNoCHSGenJets,
                                                      event.genLeptons, 0.2)
        event.YeCHSgenJets = map(GenJet,
                                 self.mchandles['YeCHSgenJets'].product())
        event.myYeCHSGenJets = [
            GenJet(jet) for jet in event.YeCHSgenJets
            if (jet.pt() > self.cfg_ana.genPtCut)
        ]
        event.selYeCHSGenJets = cleanObjectCollection(event.myYeCHSGenJets,
                                                      event.genLeptons, 0.2)

        self.h_NoCHS_genjetsnum.Fill(len(event.selNoCHSGenJets))

        if len(event.genLeptons) > 2:
            return

        for jet in event.selNoCHSGenJets:
            self.h_NoCHS_genjetspt.Fill(jet.pt())
            self.h_NoCHS_genjetseta.Fill(jet.eta())
        for jet in event.selYeCHSGenJets:
            self.h_YeCHS_genjetspt.Fill(jet.pt())
            self.h_YeCHS_genjetseta.Fill(jet.eta())

        event.cleanYeCHSJets = cleanObjectCollection(event.YeCHSjets,
                                                     event.genLeptons, 0.2)
        event.cleanNoCHSJets = cleanObjectCollection(event.NoCHSjets,
                                                     event.genLeptons, 0.2)
        for jet in event.cleanYeCHSJets:
            self.h_YeCHS_recjetspt.Fill(jet.pt())
            self.h_YeCHS_recjetseta.Fill(jet.eta())
#            if (abs(jet.pt () > 20) and len(event.vertices) > 10):
#                self.h_YeCHS_correction.Fill (jet.eta (), 1. / jet.jecFactor(0)) ;
#                print 'Ev', event.iEv, 'YeCHS ', round (jet.eta (), 2), round (jet.phi (), 2), round (jet.pt () * jet.jecFactor(0), 2)#, round (jet.component (1).fraction (), 2)

        for jet in event.cleanNoCHSJets:
            self.h_NoCHS_recjetspt.Fill(jet.pt())
            self.h_NoCHS_recjetseta.Fill(jet.eta())
#            if (abs(jet.pt () > 20) and len(event.vertices) > 10):
#                self.h_NoCHS_correction.Fill (jet.eta (), 1. / jet.jecFactor(0)) ;
#                print 'Ev', event.iEv, 'NoCHS ', round (jet.eta (), 2), round (jet.phi (), 2), round (jet.pt () * jet.jecFactor(0), 2)#, round (jet.component (1).fraction (), 2)

#PG removing negative correction jets
        event.noNegCleanYeCHSJets = [
            jet for jet in event.cleanYeCHSJets if (jet.jecFactor(0) > 0)
        ]
        event.noNegCleanNoCHSJets = [
            jet for jet in event.cleanNoCHSJets if (jet.jecFactor(0) > 0)
        ]

        #PG matching between CHS and non CHS
        event.YeNoCHSmatch = matchObjectCollection2(event.noNegCleanYeCHSJets,
                                                    event.noNegCleanNoCHSJets,
                                                    0.1)
        for yejet, nojet in event.YeNoCHSmatch.iteritems():
            if nojet == None:
                continue
            self.YeNoCHSRatio_eta.Fill(
                yejet.eta(),
                yejet.pt() * yejet.jecFactor(0) /
                (nojet.pt() * nojet.jecFactor(0)))
            self.h_NoCHS_correction.Fill(nojet.eta(), 1. / nojet.jecFactor(0))
            self.h_YeCHS_correction.Fill(yejet.eta(), 1. / yejet.jecFactor(0))

            if len(event.vertices) > 8 and len(event.vertices) <= 10:
                self.YeNoCHSRatio_eta_PUcut.Fill(
                    yejet.eta(),
                    yejet.pt() * yejet.jecFactor(0) /
                    (nojet.pt() * nojet.jecFactor(0)))
                self.h_NoCHS_correction_PUcut.Fill(nojet.eta(),
                                                   1. / nojet.jecFactor(0))
                self.h_YeCHS_correction_PUcut.Fill(yejet.eta(),
                                                   1. / yejet.jecFactor(0))

            if nojet.pt() < 40 or nojet.pt() > 60:
                continue
            self.YeNoCHSRatio_eta_ptcut.Fill(
                yejet.eta(),
                yejet.pt() * yejet.jecFactor(0) /
                (nojet.pt() * nojet.jecFactor(0)))
            self.h_NoCHS_correction_ptcut.Fill(nojet.eta(),
                                               1. / nojet.jecFactor(0))
            self.h_YeCHS_correction_ptcut.Fill(yejet.eta(),
                                               1. / yejet.jecFactor(0))

            if len(event.vertices) < 8 or len(event.vertices) > 10:
                continue
            self.YeNoCHSRatio_eta_ptcut_PUcut.Fill(
                yejet.eta(),
                yejet.pt() * yejet.jecFactor(0) /
                (nojet.pt() * nojet.jecFactor(0)))
            self.h_NoCHS_correction_ptcut_PUcut.Fill(nojet.eta(),
                                                     1. / nojet.jecFactor(0))
            self.h_YeCHS_correction_ptcut_PUcut.Fill(yejet.eta(),
                                                     1. / yejet.jecFactor(0))

#            if yejet.pt () * yejet.jecFactor(0) < 10:
#                continue ;
#            if abs (yejet.eta ()) < 3:
#                continue ;
#            print round (yejet.eta (), 2), '\t', round (yejet.pt () * yejet.jecFactor(0), 2),  '\t',round (nojet.pt () * nojet.jecFactor(0), 2),  '\t',round (yejet.pt () * yejet.jecFactor(0) / (nojet.pt () * nojet.jecFactor(0)), 2)
#            print round (yejet.eta (), 2), '\t', round (yejet.pt (), 2),  '\t',round (nojet.pt (), 2),  '\t',round (yejet.pt () * yejet.jecFactor(0) / (nojet.pt () * nojet.jecFactor(0)), 2)

        event.matchingCleanYeCHSJets = matchObjectCollection2(
            event.cleanYeCHSJets, event.selYeCHSGenJets, 0.25)
        for jet in event.cleanYeCHSJets:
            jet.gen = event.matchingCleanYeCHSJets[jet]
        event.matchedCleanYeCHSJets = [
            jet for jet in event.matchingCleanYeCHSJets if jet.gen != None
        ]

        for jet in event.matchedCleanYeCHSJets:
            self.h_YeCHS_recjetspt_match.Fill(jet.pt())
            self.h_YeCHS_recjetseta_match.Fill(jet.eta())
            self.h_YeCHS_genjetspt_match.Fill(jet.gen.pt())
            self.h_YeCHS_genjetseta_match.Fill(jet.gen.eta())

        event.matchingCleanNoCHSJets = matchObjectCollection2(
            event.cleanNoCHSJets, event.selNoCHSGenJets, 0.25)
        for jet in event.cleanNoCHSJets:
            jet.gen = event.matchingCleanNoCHSJets[jet]
        event.matchedCleanNoCHSJets = [
            jet for jet in event.matchingCleanNoCHSJets if jet.gen != None
        ]

        for jet in event.matchedCleanNoCHSJets:
            self.h_NoCHS_recjetspt_match.Fill(jet.pt())
            self.h_NoCHS_recjetseta_match.Fill(jet.eta())
            self.h_NoCHS_genjetspt_match.Fill(jet.gen.pt())
            self.h_NoCHS_genjetseta_match.Fill(jet.gen.eta())

        if len(event.vertices) != 10:
            return
        for jet in event.matchedCleanNoCHSJets:
            if (jet.gen.pt() < 20 or jet.gen.pt() > 30
                    or abs(jet.gen.eta()) > 1.4):
                continue
            self.h_NoCHS_response.Fill(
                (jet.pt() - jet.gen.pt()) / jet.gen.pt())
        for jet in event.matchedCleanYeCHSJets:
            if (jet.gen.pt() < 20 or jet.gen.pt() > 30
                    or abs(jet.gen.eta()) > 1.4):
                continue
            self.h_YeCHS_response.Fill(
                (jet.pt() - jet.gen.pt()) / jet.gen.pt())
    def process(self, iEvent, event):
        #read all the handles defined beforehand
        self.readCollections(iEvent)

        jetEtaCut = 4.5

        # get the vertexes
        event.vertices = self.handles['vertices'].product()
        #        self.h_nvtx.Fill (len (event.vertices))

        # get the jets in the jets variable
        jets = self.handles['jets'].product()
        # filter jets with some selections
        event.jets = [
            jet for jet in jets
            if (abs(jet.eta()) < jetEtaCut and jet.pt() > self.cfg_ana.ptCut
                and self.isPFLoose(jet))
        ]

        # get status 2 leptons
        if 'genParticlesPruned' in self.mchandles:
            event.genLeptons = [
                lep for lep in self.mchandles['genParticlesPruned'].product()
                if lep.status() == 2 and (abs(lep.pdgId()) == 11 or abs(
                    lep.pdgId()) == 13 or abs(lep.pdgId()) == 15)
            ]
        else:
            event.genLeptons = [
                lep for lep in self.mchandles['genParticles'].product()
                if lep.status() == 3 and (abs(lep.pdgId()) == 11 or abs(
                    lep.pdgId()) == 13 or abs(lep.pdgId()) == 15)
            ]
# @ Pasquale: why level 3 and not level 2?
#        event.selGenLeptons = [GenParticle (lep) for lep in event.genLeptons if (lep.pt ()>self.cfg_ana.ptCut and abs (lep.eta ()) < jetEtaCut)]

# get genJets
        event.genJets = map(GenJet, self.mchandles['genJets'].product())
        # filter genjets as for reco jets
        event.selGenJets = [
            GenJet(jet) for jet in event.genJets
            if (jet.pt() > self.cfg_ana.genPtCut)
        ]

        #FIXME why are there cases in which there's 4 or 6 leptons?
        if len(event.genLeptons) != 2:
            return
        # in case I want to filter out taus
        # 11, 13, 15 : e, u, T
#        event.genOneLepton = [GenParticle (part) for part in event.genLeptons if abs (part.pdgId ()) == 15]
# remove leptons from jets if closer than 0.2
        event.cleanJets = cleanObjectCollection(event.jets, event.genLeptons,
                                                0.2)
        event.matchingCleanJets = matchObjectCollection2(
            event.cleanJets, event.selGenJets, 0.25)
        # assign to each jet its gen match (easy life :))
        for jet in event.cleanJets:
            jet.gen = event.matchingCleanJets[jet]

        event.matchedCleanJets = [
            jet for jet in event.matchingCleanJets if jet.gen != None
        ]
        for jet in event.matchedCleanJets:
            self.myntuple.Fill(jet.gen.pt(), jet.pt(), jet.gen.eta(),
                               jet.eta(), jet.gen.phi(), jet.phi(),
                               len(event.vertices))
Example #5
0
    def process (self, iEvent, event) :
        #read all the handles defined beforehand
        self.readCollections (iEvent)
#        print '-------'
        
        jetEtaCut = 4.5 
        
        event.vertices = self.handles['vertices'].product ()
        self.h_NVTXnum.Fill (len (event.vertices))
        
        YeCHSjets = self.handles['YeCHSjets'].product ()
        event.YeCHSjets = [ jet for jet in YeCHSjets if ( abs(jet.eta()) < jetEtaCut and jet.pt()>self.cfg_ana.ptCut and self.isPFLoose(jet) ) ]
        NoCHSjets = self.handles['NoCHSjets'].product ()
        event.NoCHSjets = [ jet for jet in NoCHSjets if ( abs(jet.eta()) < jetEtaCut and jet.pt()>self.cfg_ana.ptCut and self.isPFLoose(jet) ) ]
        
        # get status 2 leptons
        if 'genParticlesPruned' in self.mchandles:
            event.genLeptons = [ lep for lep in self.mchandles['genParticlesPruned'].product() if lep.status() == 2 and (abs(lep.pdgId()) == 11 or abs(lep.pdgId()) == 13 or abs(lep.pdgId()) == 15) ]  
        else:
            event.genLeptons = [ lep for lep in self.mchandles['genParticles'].product() if lep.status() == 3 and (abs(lep.pdgId()) == 11 or abs(lep.pdgId()) == 13 or abs(lep.pdgId()) == 15) ]  
        
        event.NoCHSgenJets = map (GenJet, self.mchandles['NoCHSgenJets'].product ())
        event.myNoCHSGenJets = [GenJet (jet) for jet in event.NoCHSgenJets if (jet.pt ()>self.cfg_ana.genPtCut)]
        event.selNoCHSGenJets = cleanObjectCollection (event.myNoCHSGenJets, event.genLeptons, 0.2)
        event.YeCHSgenJets = map (GenJet, self.mchandles['YeCHSgenJets'].product ())
        event.myYeCHSGenJets = [GenJet (jet) for jet in event.YeCHSgenJets if (jet.pt ()>self.cfg_ana.genPtCut)]
        event.selYeCHSGenJets = cleanObjectCollection (event.myYeCHSGenJets, event.genLeptons, 0.2)
        
        self.h_NoCHS_genjetsnum.Fill (len (event.selNoCHSGenJets)) 
        
        if len (event.genLeptons) > 2 :
            return
     
        for jet in event.selNoCHSGenJets:
            self.h_NoCHS_genjetspt.Fill (jet.pt ()) ;
            self.h_NoCHS_genjetseta.Fill (jet.eta ()) ;
        for jet in event.selYeCHSGenJets:
            self.h_YeCHS_genjetspt.Fill (jet.pt ()) ;
            self.h_YeCHS_genjetseta.Fill (jet.eta ()) ;

        event.cleanYeCHSJets = cleanObjectCollection (event.YeCHSjets, event.genLeptons, 0.2)
        event.cleanNoCHSJets = cleanObjectCollection (event.NoCHSjets, event.genLeptons, 0.2)
        for jet in event.cleanYeCHSJets :
            self.h_YeCHS_recjetspt       .Fill (jet.pt ()) ;
            self.h_YeCHS_recjetseta      .Fill (jet.eta ()) ; 
#            if (abs(jet.pt () > 20) and len(event.vertices) > 10):
#                self.h_YeCHS_correction.Fill (jet.eta (), 1. / jet.jecFactor(0)) ;
#                print 'Ev', event.iEv, 'YeCHS ', round (jet.eta (), 2), round (jet.phi (), 2), round (jet.pt () * jet.jecFactor(0), 2)#, round (jet.component (1).fraction (), 2)
                
        for jet in event.cleanNoCHSJets:
            self.h_NoCHS_recjetspt       .Fill (jet.pt ()) ;
            self.h_NoCHS_recjetseta      .Fill (jet.eta ()) ; 
#            if (abs(jet.pt () > 20) and len(event.vertices) > 10):
#                self.h_NoCHS_correction.Fill (jet.eta (), 1. / jet.jecFactor(0)) ;
#                print 'Ev', event.iEv, 'NoCHS ', round (jet.eta (), 2), round (jet.phi (), 2), round (jet.pt () * jet.jecFactor(0), 2)#, round (jet.component (1).fraction (), 2)
                
        #PG removing negative correction jets
        event.noNegCleanYeCHSJets = [ jet for jet in event.cleanYeCHSJets if (jet.jecFactor(0) > 0) ]
        event.noNegCleanNoCHSJets = [ jet for jet in event.cleanNoCHSJets if (jet.jecFactor(0) > 0) ]
        
        #PG matching between CHS and non CHS
        event.YeNoCHSmatch = matchObjectCollection2 (event.noNegCleanYeCHSJets, event.noNegCleanNoCHSJets, 0.1)
        for yejet, nojet in event.YeNoCHSmatch.iteritems():
            if nojet == None: 
                continue
            self.YeNoCHSRatio_eta.Fill (yejet.eta (), yejet.pt () * yejet.jecFactor(0) / (nojet.pt () * nojet.jecFactor(0)))
            self.h_NoCHS_correction.Fill (nojet.eta (), 1. / nojet.jecFactor(0))
            self.h_YeCHS_correction.Fill (yejet.eta (), 1. / yejet.jecFactor(0))

            if len (event.vertices) > 8 and len (event.vertices) <= 10:
                self.YeNoCHSRatio_eta_PUcut.Fill (yejet.eta (), yejet.pt () * yejet.jecFactor(0) / (nojet.pt () * nojet.jecFactor(0)))
                self.h_NoCHS_correction_PUcut.Fill (nojet.eta (), 1. / nojet.jecFactor(0))
                self.h_YeCHS_correction_PUcut.Fill (yejet.eta (), 1. / yejet.jecFactor(0))
            
            if nojet.pt () < 40 or nojet.pt () > 60:
                continue
            self.YeNoCHSRatio_eta_ptcut.Fill (yejet.eta (), yejet.pt () * yejet.jecFactor(0) / (nojet.pt () * nojet.jecFactor(0)))
            self.h_NoCHS_correction_ptcut.Fill (nojet.eta (), 1. / nojet.jecFactor(0))
            self.h_YeCHS_correction_ptcut.Fill (yejet.eta (), 1. / yejet.jecFactor(0))

            if len (event.vertices) < 8 or len (event.vertices) > 10:
                continue
            self.YeNoCHSRatio_eta_ptcut_PUcut.Fill (yejet.eta (), yejet.pt () * yejet.jecFactor(0) / (nojet.pt () * nojet.jecFactor(0)))
            self.h_NoCHS_correction_ptcut_PUcut.Fill (nojet.eta (), 1. / nojet.jecFactor(0))
            self.h_YeCHS_correction_ptcut_PUcut.Fill (yejet.eta (), 1. / yejet.jecFactor(0))



#            if yejet.pt () * yejet.jecFactor(0) < 10: 
#                continue ;
#            if abs (yejet.eta ()) < 3:
#                continue ;
#            print round (yejet.eta (), 2), '\t', round (yejet.pt () * yejet.jecFactor(0), 2),  '\t',round (nojet.pt () * nojet.jecFactor(0), 2),  '\t',round (yejet.pt () * yejet.jecFactor(0) / (nojet.pt () * nojet.jecFactor(0)), 2)
#            print round (yejet.eta (), 2), '\t', round (yejet.pt (), 2),  '\t',round (nojet.pt (), 2),  '\t',round (yejet.pt () * yejet.jecFactor(0) / (nojet.pt () * nojet.jecFactor(0)), 2)
        
        event.matchingCleanYeCHSJets = matchObjectCollection2 (event.cleanYeCHSJets, event.selYeCHSGenJets, 0.25)
        for jet in event.cleanYeCHSJets :
            jet.gen = event.matchingCleanYeCHSJets[ jet ]
        event.matchedCleanYeCHSJets = [jet for jet in event.matchingCleanYeCHSJets if jet.gen != None]

        for jet in event.matchedCleanYeCHSJets:
            self.h_YeCHS_recjetspt_match .Fill (jet.pt ()) ; 
            self.h_YeCHS_recjetseta_match.Fill (jet.eta ()) ;
            self.h_YeCHS_genjetspt_match .Fill (jet.gen.pt ()) ;
            self.h_YeCHS_genjetseta_match.Fill (jet.gen.eta ()) ;

        event.matchingCleanNoCHSJets = matchObjectCollection2 (event.cleanNoCHSJets, event.selNoCHSGenJets, 0.25)
        for jet in event.cleanNoCHSJets :
            jet.gen = event.matchingCleanNoCHSJets[ jet ]
        event.matchedCleanNoCHSJets = [jet for jet in event.matchingCleanNoCHSJets if jet.gen != None]
        
        for jet in event.matchedCleanNoCHSJets:
            self.h_NoCHS_recjetspt_match .Fill (jet.pt ()) ; 
            self.h_NoCHS_recjetseta_match.Fill (jet.eta ()) ;
            self.h_NoCHS_genjetspt_match .Fill (jet.gen.pt ()) ;
            self.h_NoCHS_genjetseta_match.Fill (jet.gen.eta ()) ;
        
        if len (event.vertices) != 10 :
            return ;
        for jet in event.matchedCleanNoCHSJets:
            if (jet.gen.pt () < 20 or jet.gen.pt () > 30 or abs (jet.gen.eta ()) > 1.4) : continue ; 
            self.h_NoCHS_response.Fill ((jet.pt () - jet.gen.pt ()) / jet.gen.pt ()) ;
        for jet in event.matchedCleanYeCHSJets:
            if (jet.gen.pt () < 20 or jet.gen.pt () > 30 or abs (jet.gen.eta ()) > 1.4) : continue ; 
            self.h_YeCHS_response.Fill ((jet.pt () - jet.gen.pt ()) / jet.gen.pt ()) ;
Example #6
0
    def process (self, iEvent, event) :
        #read all the handles defined beforehand
        self.readCollections (iEvent)
        
        jetEtaCut = 4.5 
        
        # get the vertexes
        event.vertices = self.handles['vertices'].product ()
        self.h_nvtx.Fill (len (event.vertices))
        event.vertexBin = int (len (event.vertices))
        
        # get the jets in the jets variable
        jets = self.handles['jets'].product ()
        # filter jets with some selections
        event.jets = [ jet for jet in jets if ( abs(jet.eta()) < jetEtaCut and jet.pt()>self.cfg_ana.ptCut and self.isPFLoose(jet) ) ]
        self.jetHistos.fillEvent (event.jets)
        
        # get status 2 leptons
        if 'genParticlesPruned' in self.mchandles:
            event.genLeptons = [ lep for lep in self.mchandles['genParticlesPruned'].product() if lep.status() == 3 and (abs(lep.pdgId()) == 11 or abs(lep.pdgId()) == 13 or abs(lep.pdgId()) == 15) ]
        else:
            event.genLeptons = [ lep for lep in self.mchandles['genParticles'].product() if lep.status() == 3 and (abs(lep.pdgId()) == 11 or abs(lep.pdgId()) == 13 or abs(lep.pdgId()) == 15) ]  
# @ Pasquale: why level 3 and not level 2?
#        event.selGenLeptons = [GenParticle (lep) for lep in event.genLeptons if (lep.pt ()>self.cfg_ana.ptCut and abs (lep.eta ()) < jetEtaCut)]
        
        # get genJets
        event.genJets = map (GenJet, self.mchandles['genJets'].product ())
        # filter genjets as for reco jets
        event.myGenJets = [GenJet (jet) for jet in event.genJets if (jet.pt ()>self.cfg_ana.genPtCut)]
        event.selGenJets = cleanObjectCollection (event.myGenJets, event.genLeptons, 0.2)
        # event.selGenJets = event.genJets
        for jet in event.selGenJets : 
            self.h_genjetspt.Fill (jet.pt ())
        
        event.noNegJets = [ jet for jet in event.jets if (jet.jecFactor(0) > 0) ]
#        event.noNegJets = [ jet for jet in event.jets]
        
        # first stats plots
        # print 'genLeptons : ' + repr (len (event.genLeptons)) + ' | genJets : ' + repr (len (event.genJets)) + ' | recoJets : ' + repr (len (event.jets))
        self.jetHistos.fillStats (len (event.selGenJets), len (event.noNegJets))
        
        #FIXME why are there cases in which there's 4 or 6 leptons?
        if len (event.genLeptons) > 2 :
            return
        # in case I want to filter out taus
        # 11, 13, 15 : e, u, T
#        event.genOneLepton = [GenParticle (part) for part in event.genLeptons if abs (part.pdgId ()) == 15]
        # remove leptons from jets if closer than 0.2
        event.cleanJets = cleanObjectCollection (event.noNegJets, event.genLeptons, 0.2)
#        event.cleanJets = event.noNegJets
        self.cleanJetHistos.fillEvent (event.cleanJets)
        
#        print len (jets),len (event.jets), len (event.noNegJets), len (event.cleanJets), len (event.genLeptons),"-->",(len (event.noNegJets) - len (event.cleanJets) - len (event.genLeptons))

        event.matchingCleanJets = matchObjectCollection2 (event.cleanJets, event.selGenJets, 0.25)
        # assign to each jet its gen match (easy life :))
        for jet in event.cleanJets :
            jet.gen = event.matchingCleanJets[ jet ]
        # FIXME next step might be to put this in the matching and remove the boolean flags

        event.matchedCleanJets = [jet for jet in event.matchingCleanJets if jet.gen != None]
        event.cleanGluJets = []
        event.cleanQuarkJets = []
        for jet in event.matchedCleanJets:
            flav = abs(jet.partonFlavour()) 
            if flav == 21:
                event.cleanGluJets.append(jet)
            elif flav > 0 and flav <= 3:
                event.cleanQuarkJets.append(jet)

        event.LPtmatchedCleanJets = [jet for jet in event.matchingCleanJets if jet.gen != None and jet.pt () <= 30]
        event.HPtmatchedCleanJets = [jet for jet in event.matchingCleanJets if jet.gen != None and jet.pt () > 30]

        self.matchedCleanJetHistos.fillEvent (event.matchedCleanJets)
        self.LPtmatchedCleanJetHistos.fillEvent (event.LPtmatchedCleanJets)
        self.HPtmatchedCleanJetHistos.fillEvent (event.HPtmatchedCleanJets)

        event.unmatchedCleanJets = [jet for jet in event.matchingCleanJets if jet.gen == None]
        event.LPtunmatchedCleanJets = [jet for jet in event.matchingCleanJets if jet.gen == None and jet.pt () <= 30]
        event.HPtunmatchedCleanJets = [jet for jet in event.matchingCleanJets if jet.gen == None and jet.pt () > 30]
        
        self.unmatchedCleanJetHistos.fillEvent (event.unmatchedCleanJets)
        self.LPtUnmatchedCleanJetHistos.fillEvent (event.LPtunmatchedCleanJets)
        self.HPtUnmatchedCleanJetHistos.fillEvent (event.HPtunmatchedCleanJets)
        
        self.matchedCleanJetHistosComponents.fillEvent (event.matchedCleanJets)
        
        self.unmatchedCleanJetHistosComponents.fillEvent (event.unmatchedCleanJets)
        
        self.matchedCleanJetHistosResolution.fillEvent (event.matchedCleanJets, len (event.vertices))
        
        for jet in event.matchedCleanJets :
            if abs (jet.gen.eta ()) < 1.4 :
                self.matchedCleanJetHistosResolution_barrel.fillJet (jet, len (event.vertices))
                self.matchedCleanJetHistos_barrel.fillJet (jet)
            elif 1.6 < abs (jet.gen.eta ()) < 2.5 :    
                self.matchedCleanJetHistosResolution_endtk.fillJet (jet, len (event.vertices))
                self.matchedCleanJetHistos_endtk.fillJet (jet)
            elif 2.6 < abs (jet.gen.eta ()) < 2.9 :    
                self.matchedCleanJetHistosResolution_endNOtk.fillJet (jet, len (event.vertices))
                self.matchedCleanJetHistos_endNOtk.fillJet (jet)
            elif 3.1 < abs (jet.gen.eta ()) :    
                self.matchedCleanJetHistosResolution_fwd.fillJet (jet, len (event.vertices))
                self.matchedCleanJetHistos_fwd.fillJet (jet)

        ##PG debugging for tails
        #for jet in event.matchedCleanJets :
            #deltaRR = deltaR( jet.eta (), jet.phi (), jet.gen.eta (), jet.gen.phi ())
            #self.h_matchDR.Fill (deltaRR)
            #self.h_relPtVSmatchDR.Fill (deltaRR, jet.pt () / jet.gen.pt ())
            #if abs (jet.gen.eta ()) > 2.5 and abs (jet.gen.eta ()) < 3 :
                #self.h_relPtVSchFrac.Fill (jet.chargedHadronEnergyFraction (), jet.pt () / jet.gen.pt ())

            #if jet.gen.pt () > 20 and jet.gen.pt () < 40 :
                #self.h_PTRatioVSgenEta.Fill (jet.gen.eta (), jet.pt () / jet.gen.pt ())
            #if abs (jet.gen.eta ()) > 1.6 :
                #self.h_PTRatioVSgenPt.Fill (jet.gen.pt (), jet.pt () / jet.gen.pt ())

            #minDelta = 10
            #secondClosest = jet
            #for recojet in event.cleanJets :
                #if recojet == jet : continue
                #dr2 = deltaR2( jet.gen.eta (), jet.gen.phi (), recojet.eta (), recojet.phi ())
                #if dr2 < minDelta :
                    #minDelta = dr2
                    #secondClosest = recojet 
            ##if len(event.vertices) < 10 or abs (jet.gen.eta ()) < 1.6: continue
            #self.h_secondClosestVsPtratio.Fill (jet.pt () / jet.gen.pt (), math.sqrt (minDelta))
            #if jet.pt () / jet.gen.pt () < 0.2 and jet.gen.pt () > 20 and abs (jet.gen.eta ()) < 3 and abs (jet.gen.eta ()) > 2.5 :
                #print '============',len(event.genLeptons)
                #print jet.pt (), jet.eta (), jet.phi (), jet.jecFactor (0)
                #print jet.gen.pt (), jet.gen.eta (), jet.gen.phi ()
                #print '------------ leptons:'
                #for lept in event.genLeptons :
                    #print lept.pt (), lept.eta (), lept.phi ()
                #print '------------'
                #for recojet in event.cleanJets :
                    #print "RECO",recojet.pt (), recojet.eta (), recojet.phi (), recojet.jecFactor (0)
                #for genjet in event.selGenJets :
                    #print "GEN ",genjet.pt (), genjet.eta (), genjet.phi ()

        #aveDeltaR = 0
        #num = 0
        #for recojet1 in event.cleanJets :
            #minDelta = 10
            #closest = recojet1
            #for recojet2 in event.cleanJets :
                #if recojet1 == recojet2 : continue
                #dr2 = deltaR2( recojet1.eta (), recojet1.phi (), recojet2.eta (), recojet2.phi ())
                #if dr2 < minDelta :
                    #minDelta = dr2
                    #closest = recojet2
            #if minDelta == 10 : continue
            #aveDeltaR = aveDeltaR + math.sqrt (minDelta)
            #num = num + 1
        #if num > 0 :
            #aveDeltaR = aveDeltaR / num
            #self.h_avedistanceVSNvtx.Fill (len(event.vertices), aveDeltaR)


        if self.doJetIdHisto:
            self.gluCleanHistosId.fillEvent(event.cleanGluJets,event.vertices)
            self.quarkCleanHistosId.fillEvent(event.cleanQuarkJets,event.vertices)
            ### self.matchedCleanHistosId.fillEvent(event.matchedCleanJets,event.vertices)
            self.reweiMatchedCleanHistosId.fillEvent(event.matchedCleanJets,event.vertices)
            self.unmatchedCleanHistosId.fillEvent(event.unmatchedCleanJets,event.vertices)