Example #1
0
    def process(self, event):
        self.readCollections(event.input)
        triggerBits = self.handles['TriggerBits'].product()
        allTriggerObjects = self.handles['TriggerObjects'].product()
        names = event.input.object().triggerNames(triggerBits)
        for ob in allTriggerObjects:
            ob.unpackPathNames(names)
        triggerObjects = [
            ob for ob in allTriggerObjects
            if False not in [sel(ob) for sel in self.trgObjSelectors]
        ]

        setattr(event, 'trgObjects_' + self.label, triggerObjects)

        if self.collToMatch:
            tcoll = getattr(event, self.collToMatch)
            doubleandselector = lambda lep, ob: False if False in [
                sel(lep, ob) for sel in self.collMatchSelectors
            ] else True
            pairs = matchObjectCollection3(
                tcoll,
                triggerObjects,
                deltaRMax=self.collMatchDRCut,
                filter=doubleandselector
            ) if self.match1To1 else matchObjectCollection(
                tcoll,
                triggerObjects,
                self.collMatchDRCut,
                filter=doubleandselector)
            for lep in tcoll:
                setattr(lep, 'matchedTrgObj' + self.label, pairs[lep])

        if self.verbose:
            print('Verbose debug for triggerMatchAnalyzer %s' % self.label)
            for ob in getattr(event, 'trgObjects_' + self.label):
                types = ", ".join([str(f) for f in ob.filterIds()])
                filters = ", ".join([str(f) for f in ob.filterLabels()])
                paths = ", ".join(
                    [("%s***" if f in set(ob.pathNames(True)) else "%s") % f
                     for f in ob.pathNames()]
                )  # asterisks indicate final paths fired by this object, see pat::TriggerObjectStandAlone class
                print(
                    'Trigger object: pt=%.2f, eta=%.2f, phi=%.2f, collection=%s, type_ids=%s, filters=%s, paths=%s'
                    % (ob.pt(), ob.eta(), ob.phi(), ob.collection(), types,
                       filters, paths))
            if self.collToMatch:
                for lep in tcoll:
                    mstring = 'None'
                    ob = getattr(lep, 'matchedTrgObj' + self.label)
                    if ob:
                        mstring = 'trigger obj with pt=%.2f, eta=%.2f, phi=%.2f, collection=%s' % (
                            ob.pt(), ob.eta(), ob.phi(), ob.collection())
                    print('Lepton pt=%.2f, eta=%.2f, phi=%.2f matched to %s' %
                          (lep.pt(), lep.eta(), lep.phi(), mstring))

        return True
Example #2
0
    def process(self, event):
        super(SimpleJetAnalyzer, self).readCollections(event.input)
        # creating Jet python objects wrapping the EDM jets
        # keeping only the first 2 leading jets
        event.jets = map(Jet, self.handles['jets'].product())[:2]
        event.jets = [ jet for jet in event.jets if jet.pt()>self.cfg_ana.ptmin]

        if self.cfg_comp.isMC:
            event.genjets =  map(GenJet, self.mchandles['genjets'].product())
            matches = matchObjectCollection(event.jets, event.genjets, 0.2)
            for jet in event.jets:
                jet.gen = matches[jet]
Example #3
0
    def process(self, event):
        super(SimpleJetAnalyzer, self).readCollections(event.input)
        # creating Jet python objects wrapping the EDM jets
        jets = map(Jet, self.handles['jets'].product())
        jets = [ jet for jet in jets if self.cfg_ana.filter_func(jet)]
        jets = jets[:self.cfg_ana.njets]

        if self.cfg_comp.isMC:
            genjets =  map(GenJet, self.mchandles['genjets'].product())
            matches = matchObjectCollection(jets, genjets, 0.2)
            for jet in jets:
                jet.gen = matches[jet]
            
        setattr(event, self.instance_label, jets)
        setattr(event, '_'.join([self.instance_label, 'gen']), genjets)
Example #4
0
    def process(self, event):
        self.readCollections( event.input )
        rho  = float(self.handles['rho'].product()[0])
        event.rho = rho

        ## Read jets, if necessary recalibrate and shift MET
        allJets = map(Jet, self.handles['jets'].product()) 

        event.deltaMetFromJEC = [0.,0.]
        if self.doJEC:
            #print "\nCalibrating jets %s for lumi %d, event %d" % (self.cfg_ana.jetCol, event.lumi, event.eventId)
            self.jetReCalibrator.correctAll(allJets, rho, delta=self.shiftJEC, metShift=event.deltaMetFromJEC)
        event.allJetsUsedForMET = allJets

        if self.cfg_comp.isMC:
            event.genJets = [ x for x in self.handles['genJet'].product() ]
            self.matchJets(event, allJets)
            if getattr(self.cfg_ana, 'smearJets', False):
                self.smearJets(event, allJets)
        
	##Sort Jets by pT 
        allJets.sort(key = lambda j : j.pt(), reverse = True)
        
	## Apply jet selection
        event.jets = []
        event.jetsFailId = []
        event.jetsAllNoID = []
        event.jetsIdOnly = []
        for jet in allJets:
            if self.testJetNoID( jet ): 
                event.jetsAllNoID.append(jet) 
                if self.testJetID (jet ):
                    
                    if(self.cfg_ana.doQG):
                        self.computeQGvars(jet)
                        jet.qgl = self.qglcalc.computeQGLikelihood(jet, rho)


                    event.jets.append(jet)
                    event.jetsIdOnly.append(jet)
                else:
                    event.jetsFailId.append(jet)
            elif self.testJetID (jet ):
                event.jetsIdOnly.append(jet)

        ## Clean Jets from leptons
        leptons = []
        if hasattr(event, 'selectedLeptons'):
            leptons = [ l for l in event.selectedLeptons if l.pt() > self.lepPtMin ]
        if self.cfg_ana.cleanJetsFromTaus and hasattr(event, 'selectedTaus'):
            leptons = leptons[:] + event.selectedTaus
        if self.cfg_ana.cleanJetsFromIsoTracks and hasattr(event, 'selectedIsoCleanTrack'):
            leptons = leptons[:] + event.selectedIsoCleanTrack
        event.cleanJetsAll, cleanLeptons = cleanJetsAndLeptons(event.jets, leptons, self.jetLepDR, self.jetLepArbitration)
        event.cleanJets    = [j for j in event.cleanJetsAll if abs(j.eta()) <  self.cfg_ana.jetEtaCentral ]
        event.cleanJetsFwd = [j for j in event.cleanJetsAll if abs(j.eta()) >= self.cfg_ana.jetEtaCentral ]
        event.discardedJets = [j for j in event.jets if j not in event.cleanJetsAll]
        if hasattr(event, 'selectedLeptons'):
            event.discardedLeptons = [ l for l in leptons if l not in cleanLeptons ]
            event.selectedLeptons  = [ l for l in event.selectedLeptons if l not in event.discardedLeptons ]

        ## Clean Jets from photons
        photons = []
        if hasattr(event, 'selectedPhotons'):
            if self.cfg_ana.cleanJetsFromFirstPhoton:
                photons = event.selectedPhotons[:1]
            else:
                photons = [ g for g in event.selectedPhotons ] 

        event.gamma_cleanJetsAll = cleanNearestJetOnly(event.cleanJetsAll, photons, self.jetGammaDR)
        event.gamma_cleanJets    = [j for j in event.gamma_cleanJetsAll if abs(j.eta()) <  self.cfg_ana.jetEtaCentral ]
        event.gamma_cleanJetsFwd = [j for j in event.gamma_cleanJetsAll if abs(j.eta()) >= self.cfg_ana.jetEtaCentral ]
        ###


        ## Associate jets to leptons
        leptons = event.inclusiveLeptons if hasattr(event, 'inclusiveLeptons') else event.selectedLeptons
        jlpairs = matchObjectCollection( leptons, allJets, self.jetLepDR**2)

        for jet in allJets:
            jet.leptons = [l for l in jlpairs if jlpairs[l] == jet ]

        for lep in leptons:
            jet = jlpairs[lep]
            if jet is None:
                lep.jet = lep
            else:
                lep.jet = jet
        ## Associate jets to taus 
        taus = getattr(event,'selectedTaus',[])
        jtaupairs = matchObjectCollection( taus, allJets, self.jetLepDR**2)

        for jet in allJets:
            jet.taus = [l for l in jtaupairs if jtaupairs[l] == jet ]
        for tau in taus:
            tau.jet = jtaupairs[tau]

        #MC stuff
        if self.cfg_comp.isMC:
            event.deltaMetFromJetSmearing = [0, 0]
            for j in event.cleanJetsAll:
                if hasattr(j, 'deltaMetFromJetSmearing'):
                    event.deltaMetFromJetSmearing[0] += j.deltaMetFromJetSmearing[0]
                    event.deltaMetFromJetSmearing[1] += j.deltaMetFromJetSmearing[1]
            event.cleanGenJets = cleanNearestJetOnly(event.genJets, leptons, self.jetLepDR)
            
            #event.nGenJets25 = 0
            #event.nGenJets25Cen = 0
            #event.nGenJets25Fwd = 0
            #for j in event.cleanGenJets:
            #    event.nGenJets25 += 1
            #    if abs(j.eta()) <= 2.4: event.nGenJets25Cen += 1
            #    else:                   event.nGenJets25Fwd += 1
                    
            self.jetFlavour(event)
        
    
        return True
Example #5
0
    def process(self, event):

        self.readCollections(event.input)
        miniaodjets = self.handles['jets'].product()

        allJets = []
        event.jets = []
        event.bJets = []
        event.cleanJets = []
        event.cleanBJets = []

        leptons = []
        if hasattr(event, 'selectedLeptons'):
            leptons = event.selectedLeptons
        if hasattr(self.cfg_ana, 'toClean'):
            leptons = getattr(event, self.cfg_ana.toClean)

        if hasattr(self.cfg_ana, 'leptonCollections'):
            for coll in self.cfg_ana.leptonCollections:
                leptons += self.handles[coll].product()

        genJets = None
        if self.cfg_comp.isMC:
            genJets = map(GenJet, self.mchandles['genJets'].product())

        allJets = [Jet(jet) for jet in miniaodjets]

        if self.recalibrateJets:
            self.jetReCalibrator.correctAll(allJets,
                                            event.rho,
                                            delta=0.,
                                            addCorr=True,
                                            addShifts=True)

        for jet in allJets:
            if genJets:
                # Use DeltaR = 0.25 matching like JetMET
                pairs = matchObjectCollection([jet], genJets, 0.25 * 0.25)
                if pairs[jet] is None:
                    pass
                else:
                    jet.matchedGenJet = pairs[jet]
            # Add JER correction for MC jets. Requires gen-jet matching.
            if self.cfg_comp.isMC and hasattr(
                    self.cfg_ana, 'jerCorr') and self.cfg_ana.jerCorr:
                self.jerCorrection(jet)
            # Add JES correction for MC jets.
            if self.cfg_comp.isMC and hasattr(self.cfg_ana, 'jesCorr'):
                self.jesCorrection(jet, self.cfg_ana.jesCorr)
            if self.testJet(jet):
                event.jets.append(jet)
            if self.testBJet(jet):
                event.bJets.append(jet)

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

        event.cleanJets, dummy = cleanObjectCollection(event.jets,
                                                       masks=leptons,
                                                       deltaRMin=0.5)
        event.cleanBJets, dummy = cleanObjectCollection(event.bJets,
                                                        masks=leptons,
                                                        deltaRMin=0.5)

        # Attach matched jets to selected + other leptons
        if hasattr(event, 'otherLeptons'):
            leptons += event.otherLeptons

        pairs = matchObjectCollection(leptons, allJets, 0.5 * 0.5)
        # associating a jet to each lepton
        for lepton in leptons:
            jet = pairs[lepton]
            if jet is None:
                lepton.jet = lepton
            else:
                lepton.jet = jet

        # associating a leg to each clean jet
        invpairs = matchObjectCollection(event.cleanJets, leptons, 99999.)
        for jet in event.cleanJets:
            leg = invpairs[jet]
            jet.leg = leg

        for jet in event.cleanJets:
            jet.matchGenParton = 999.0

        event.jets30 = [jet for jet in event.jets if jet.pt() > 30]
        event.cleanJets30 = [jet for jet in event.cleanJets if jet.pt() > 30]
        if len(event.jets30) >= 2:
            self.counters.counter('jets').inc('at least 2 good jets')
        if len(event.cleanJets30) >= 2:
            self.counters.counter('jets').inc('at least 2 clean jets')
        if len(event.cleanBJets) > 0:
            self.counters.counter('jets').inc('at least 1 b jet')
            if len(event.cleanBJets) > 1:
                self.counters.counter('jets').inc('at least 2 b jets')

        # save HTs
        event.HT_allJets = sum([jet.pt() for jet in allJets])
        event.HT_jets = sum([jet.pt() for jet in event.jets])
        event.HT_bJets = sum([jet.pt() for jet in event.bJets])
        event.HT_cleanJets = sum([jet.pt() for jet in event.cleanJets])
        event.HT_jets30 = sum([jet.pt() for jet in event.jets30])
        event.HT_cleanJets30 = sum([jet.pt() for jet in event.cleanJets30])

        return True
Example #6
0
    def process(self, event):
        self.readCollections(event.input)
        rho = float(self.handles['rho'].product()[0])
        self.rho = rho

        ## Read jets, if necessary recalibrate and shift MET
        if self.cfg_ana.copyJetsByValue:
            import ROOT
            allJets = map(
                lambda j: Jet(ROOT.pat.Jet(j)), self.handles['jets'].product(
                ))  #copy-by-value is safe if JetAnalyzer is ran more than once
        else:
            allJets = map(Jet, self.handles['jets'].product())

        self.deltaMetFromJEC = [0., 0.]
        #        print "before. rho",self.rho,self.cfg_ana.collectionPostFix,'allJets len ',len(allJets),'pt', [j.pt() for j in allJets]
        if self.doJEC:
            #            print "\nCalibrating jets %s for lumi %d, event %d" % (self.cfg_ana.jetCol, event.lumi, event.eventId)
            self.jetReCalibrator.correctAll(allJets,
                                            rho,
                                            delta=self.shiftJEC,
                                            metShift=self.deltaMetFromJEC)
        self.allJetsUsedForMET = allJets
        #        print "after. rho",self.rho,self.cfg_ana.collectionPostFix,'allJets len ',len(allJets),'pt', [j.pt() for j in allJets]

        if self.cfg_comp.isMC:
            self.genJets = [x for x in self.handles['genJet'].product()]
            self.matchJets(event, allJets)
            if getattr(self.cfg_ana, 'smearJets', False):
                self.smearJets(event, allJets)

##Sort Jets by pT
        allJets.sort(key=lambda j: j.pt(), reverse=True)
        ## Apply jet selection
        self.jets = []
        self.jetsFailId = []
        self.jetsAllNoID = []
        self.jetsIdOnly = []
        for jet in allJets:
            if self.testJetNoID(jet):
                self.jetsAllNoID.append(jet)
                if self.testJetID(jet):

                    if (self.cfg_ana.doQG):
                        self.computeQGvars(jet)
                        jet.qgl = self.qglcalc.computeQGLikelihood(jet, rho)

                    self.jets.append(jet)
                    self.jetsIdOnly.append(jet)
                else:
                    self.jetsFailId.append(jet)
            elif self.testJetID(jet):
                self.jetsIdOnly.append(jet)

        ## Clean Jets from leptons
        leptons = []
        if hasattr(event, 'selectedLeptons'):
            leptons = [
                l for l in event.selectedLeptons
                if l.pt() > self.lepPtMin and self.lepSelCut(l)
            ]
        if self.cfg_ana.cleanJetsFromTaus and hasattr(event, 'selectedTaus'):
            leptons = leptons[:] + event.selectedTaus
        if self.cfg_ana.cleanJetsFromIsoTracks and hasattr(
                event, 'selectedIsoCleanTrack'):
            leptons = leptons[:] + event.selectedIsoCleanTrack
        self.cleanJetsAll, cleanLeptons = cleanJetsAndLeptons(
            self.jets, leptons, self.jetLepDR, self.jetLepArbitration)
        self.cleanJets = [
            j for j in self.cleanJetsAll
            if abs(j.eta()) < self.cfg_ana.jetEtaCentral
        ]
        self.cleanJetsFwd = [
            j for j in self.cleanJetsAll
            if abs(j.eta()) >= self.cfg_ana.jetEtaCentral
        ]
        self.discardedJets = [
            j for j in self.jets if j not in self.cleanJetsAll
        ]
        if hasattr(event,
                   'selectedLeptons') and self.cfg_ana.cleanSelectedLeptons:
            event.discardedLeptons = [
                l for l in leptons if l not in cleanLeptons
            ]
            event.selectedLeptons = [
                l for l in event.selectedLeptons
                if l not in event.discardedLeptons
            ]

        ## Clean Jets from photons
        photons = []
        if hasattr(event, 'selectedPhotons'):
            if self.cfg_ana.cleanJetsFromFirstPhoton:
                photons = event.selectedPhotons[:1]
            else:
                photons = [g for g in event.selectedPhotons]

        self.gamma_cleanJetsAll = cleanNearestJetOnly(self.cleanJetsAll,
                                                      photons, self.jetGammaDR)
        self.gamma_cleanJets = [
            j for j in self.gamma_cleanJetsAll
            if abs(j.eta()) < self.cfg_ana.jetEtaCentral
        ]
        self.gamma_cleanJetsFwd = [
            j for j in self.gamma_cleanJetsAll
            if abs(j.eta()) >= self.cfg_ana.jetEtaCentral
        ]
        ###

        ## Associate jets to leptons
        leptons = event.inclusiveLeptons if hasattr(
            event, 'inclusiveLeptons') else event.selectedLeptons
        jlpairs = matchObjectCollection(leptons, allJets, self.jetLepDR**2)

        for jet in allJets:
            jet.leptons = [l for l in jlpairs if jlpairs[l] == jet]

        for lep in leptons:
            jet = jlpairs[lep]
            if jet is None:
                lep.jet = lep
            else:
                lep.jet = jet
        ## Associate jets to taus
        taus = getattr(event, 'selectedTaus', [])
        jtaupairs = matchObjectCollection(taus, allJets, self.jetLepDR**2)

        for jet in allJets:
            jet.taus = [l for l in jtaupairs if jtaupairs[l] == jet]
        for tau in taus:
            tau.jet = jtaupairs[tau]

        #MC stuff
        if self.cfg_comp.isMC:
            self.deltaMetFromJetSmearing = [0, 0]
            for j in self.cleanJetsAll:
                if hasattr(j, 'deltaMetFromJetSmearing'):
                    self.deltaMetFromJetSmearing[
                        0] += j.deltaMetFromJetSmearing[0]
                    self.deltaMetFromJetSmearing[
                        1] += j.deltaMetFromJetSmearing[1]
            self.cleanGenJets = cleanNearestJetOnly(self.genJets, leptons,
                                                    self.jetLepDR)

            if self.cfg_ana.cleanGenJetsFromPhoton:
                self.cleanGenJets = cleanNearestJetOnly(
                    self.cleanGenJets, photons, self.jetLepDR)

            #event.nGenJets25 = 0
            #event.nGenJets25Cen = 0
            #event.nGenJets25Fwd = 0
            #for j in event.cleanGenJets:
            #    event.nGenJets25 += 1
            #    if abs(j.eta()) <= 2.4: event.nGenJets25Cen += 1
            #    else:                   event.nGenJets25Fwd += 1

            self.jetFlavour(event)

        setattr(event, "rho" + self.cfg_ana.collectionPostFix, self.rho)
        setattr(event, "deltaMetFromJEC" + self.cfg_ana.collectionPostFix,
                self.deltaMetFromJEC)
        setattr(event,
                "deltaMetFromJetSmearing" + self.cfg_ana.collectionPostFix,
                self.deltaMetFromJetSmearing)
        setattr(event, "allJetsUsedForMET" + self.cfg_ana.collectionPostFix,
                self.allJetsUsedForMET)
        setattr(event, "genJets" + self.cfg_ana.collectionPostFix,
                self.genJets)
        setattr(event, "cleanGenJets" + self.cfg_ana.collectionPostFix,
                self.cleanGenJets)
        setattr(event, "jets" + self.cfg_ana.collectionPostFix, self.jets)
        setattr(event, "jetsFailId" + self.cfg_ana.collectionPostFix,
                self.jetsFailId)
        setattr(event, "jetsAllNoID" + self.cfg_ana.collectionPostFix,
                self.jetsAllNoID)
        setattr(event, "jetsIdOnly" + self.cfg_ana.collectionPostFix,
                self.jetsIdOnly)
        setattr(event, "cleanJetsAll" + self.cfg_ana.collectionPostFix,
                self.cleanJetsAll)
        setattr(event, "cleanJets" + self.cfg_ana.collectionPostFix,
                self.cleanJets)
        setattr(event, "cleanJetsFwd" + self.cfg_ana.collectionPostFix,
                self.cleanJetsFwd)
        setattr(event, "discardedJets" + self.cfg_ana.collectionPostFix,
                self.discardedJets)
        setattr(event, "gamma_cleanJetsAll" + self.cfg_ana.collectionPostFix,
                self.gamma_cleanJetsAll)
        setattr(event, "gamma_cleanJets" + self.cfg_ana.collectionPostFix,
                self.gamma_cleanJets)
        setattr(event, "gamma_cleanJetsFwd" + self.cfg_ana.collectionPostFix,
                self.gamma_cleanJetsFwd)
        setattr(event, "bqObjects" + self.cfg_ana.collectionPostFix,
                self.bqObjects)
        setattr(event, "cqObjects" + self.cfg_ana.collectionPostFix,
                self.cqObjects)
        setattr(event, "partons" + self.cfg_ana.collectionPostFix,
                self.partons)
        setattr(event, "heaviestQCDFlavour" + self.cfg_ana.collectionPostFix,
                self.heaviestQCDFlavour)

        return True
Example #7
0
    def process(self, event):
        self.readCollections( event.input )
        rho  = float(self.handles['rho'].product()[0])
        self.rho = rho

        ## Read jets, if necessary recalibrate and shift MET
        if self.cfg_ana.copyJetsByValue: 
          import ROOT
          allJets = map(lambda j:Jet(ROOT.pat.Jet(j)), self.handles['jets'].product()) #copy-by-value is safe if JetAnalyzer is ran more than once
        else: 
          allJets = map(Jet, self.handles['jets'].product()) 

        self.deltaMetFromJEC = [0.,0.]
#        print "before. rho",self.rho,self.cfg_ana.collectionPostFix,'allJets len ',len(allJets),'pt', [j.pt() for j in allJets]
        if self.doJEC:
#            print "\nCalibrating jets %s for lumi %d, event %d" % (self.cfg_ana.jetCol, event.lumi, event.eventId)
            self.jetReCalibrator.correctAll(allJets, rho, delta=self.shiftJEC, metShift=self.deltaMetFromJEC)
        self.allJetsUsedForMET = allJets
#        print "after. rho",self.rho,self.cfg_ana.collectionPostFix,'allJets len ',len(allJets),'pt', [j.pt() for j in allJets]

        if self.cfg_comp.isMC:
            self.genJets = [ x for x in self.handles['genJet'].product() ]
            self.matchJets(event, allJets)
            if getattr(self.cfg_ana, 'smearJets', False):
                self.smearJets(event, allJets)
        
	##Sort Jets by pT 
        allJets.sort(key = lambda j : j.pt(), reverse = True)
	## Apply jet selection
        self.jets = []
        self.jetsFailId = []
        self.jetsAllNoID = []
        self.jetsIdOnly = []
        for jet in allJets:
            if self.testJetNoID( jet ): 
                self.jetsAllNoID.append(jet) 
                if self.testJetID (jet ):
                    
                    if(self.cfg_ana.doQG):
                        self.computeQGvars(jet)
                        jet.qgl = self.qglcalc.computeQGLikelihood(jet, rho)


                    self.jets.append(jet)
                    self.jetsIdOnly.append(jet)
                else:
                    self.jetsFailId.append(jet)
            elif self.testJetID (jet ):
                self.jetsIdOnly.append(jet)

        ## Clean Jets from leptons
        leptons = []
        if hasattr(event, 'selectedLeptons'):
            leptons = [ l for l in event.selectedLeptons if l.pt() > self.lepPtMin and self.lepSelCut(l) ]
        if self.cfg_ana.cleanJetsFromTaus and hasattr(event, 'selectedTaus'):
            leptons = leptons[:] + event.selectedTaus
        if self.cfg_ana.cleanJetsFromIsoTracks and hasattr(event, 'selectedIsoCleanTrack'):
            leptons = leptons[:] + event.selectedIsoCleanTrack
        self.cleanJetsAll, cleanLeptons = cleanJetsAndLeptons(self.jets, leptons, self.jetLepDR, self.jetLepArbitration)
        self.cleanJets    = [j for j in self.cleanJetsAll if abs(j.eta()) <  self.cfg_ana.jetEtaCentral ]
        self.cleanJetsFwd = [j for j in self.cleanJetsAll if abs(j.eta()) >= self.cfg_ana.jetEtaCentral ]
        self.discardedJets = [j for j in self.jets if j not in self.cleanJetsAll]
        if hasattr(event, 'selectedLeptons') and self.cfg_ana.cleanSelectedLeptons:
            event.discardedLeptons = [ l for l in leptons if l not in cleanLeptons ]
            event.selectedLeptons  = [ l for l in event.selectedLeptons if l not in event.discardedLeptons ]

        ## Clean Jets from photons
        photons = []
        if hasattr(event, 'selectedPhotons'):
            if self.cfg_ana.cleanJetsFromFirstPhoton:
                photons = event.selectedPhotons[:1]
            else:
                photons = [ g for g in event.selectedPhotons ] 

        self.gamma_cleanJetsAll = cleanNearestJetOnly(self.cleanJetsAll, photons, self.jetGammaDR)
        self.gamma_cleanJets    = [j for j in self.gamma_cleanJetsAll if abs(j.eta()) <  self.cfg_ana.jetEtaCentral ]
        self.gamma_cleanJetsFwd = [j for j in self.gamma_cleanJetsAll if abs(j.eta()) >= self.cfg_ana.jetEtaCentral ]
        ###

        if self.cfg_ana.alwaysCleanPhotons:
            self.cleanJets = self.gamma_cleanJets
            self.cleanJetsAll = self.gamma_cleanJetsAll
            self.cleanJetsFwd = self.gamma_cleanJetsFwd

        ## Associate jets to leptons
        leptons = event.inclusiveLeptons if hasattr(event, 'inclusiveLeptons') else event.selectedLeptons
        jlpairs = matchObjectCollection( leptons, allJets, self.jetLepDR**2)

        for jet in allJets:
            jet.leptons = [l for l in jlpairs if jlpairs[l] == jet ]

        for lep in leptons:
            jet = jlpairs[lep]
            if jet is None:
                lep.jet = lep
            else:
                lep.jet = jet
        ## Associate jets to taus 
        taus = getattr(event,'selectedTaus',[])
        jtaupairs = matchObjectCollection( taus, allJets, self.jetLepDR**2)

        for jet in allJets:
            jet.taus = [l for l in jtaupairs if jtaupairs[l] == jet ]
        for tau in taus:
            tau.jet = jtaupairs[tau]

        #MC stuff
        if self.cfg_comp.isMC:
            self.deltaMetFromJetSmearing = [0, 0]
            for j in self.cleanJetsAll:
                if hasattr(j, 'deltaMetFromJetSmearing'):
                    self.deltaMetFromJetSmearing[0] += j.deltaMetFromJetSmearing[0]
                    self.deltaMetFromJetSmearing[1] += j.deltaMetFromJetSmearing[1]
            self.cleanGenJets = cleanNearestJetOnly(self.genJets, leptons, self.jetLepDR)
            
            if self.cfg_ana.cleanGenJetsFromPhoton:
                self.cleanGenJets = cleanNearestJetOnly(self.cleanGenJets, photons, self.jetLepDR)

            
            #event.nGenJets25 = 0
            #event.nGenJets25Cen = 0
            #event.nGenJets25Fwd = 0
            #for j in event.cleanGenJets:
            #    event.nGenJets25 += 1
            #    if abs(j.eta()) <= 2.4: event.nGenJets25Cen += 1
            #    else:                   event.nGenJets25Fwd += 1
                    
            self.jetFlavour(event)

        setattr(event,"rho"                    +self.cfg_ana.collectionPostFix, self.rho                    ) 
        setattr(event,"deltaMetFromJEC"        +self.cfg_ana.collectionPostFix, self.deltaMetFromJEC        ) 
        setattr(event,"allJetsUsedForMET"      +self.cfg_ana.collectionPostFix, self.allJetsUsedForMET      ) 
        setattr(event,"jets"                   +self.cfg_ana.collectionPostFix, self.jets                   ) 
        setattr(event,"jetsFailId"             +self.cfg_ana.collectionPostFix, self.jetsFailId             ) 
        setattr(event,"jetsAllNoID"            +self.cfg_ana.collectionPostFix, self.jetsAllNoID            ) 
        setattr(event,"jetsIdOnly"             +self.cfg_ana.collectionPostFix, self.jetsIdOnly             ) 
        setattr(event,"cleanJetsAll"           +self.cfg_ana.collectionPostFix, self.cleanJetsAll           ) 
        setattr(event,"cleanJets"              +self.cfg_ana.collectionPostFix, self.cleanJets              ) 
        setattr(event,"cleanJetsFwd"           +self.cfg_ana.collectionPostFix, self.cleanJetsFwd           ) 
        setattr(event,"discardedJets"          +self.cfg_ana.collectionPostFix, self.discardedJets          ) 
        setattr(event,"gamma_cleanJetsAll"     +self.cfg_ana.collectionPostFix, self.gamma_cleanJetsAll     ) 
        setattr(event,"gamma_cleanJets"        +self.cfg_ana.collectionPostFix, self.gamma_cleanJets        ) 
        setattr(event,"gamma_cleanJetsFwd"     +self.cfg_ana.collectionPostFix, self.gamma_cleanJetsFwd     ) 


	if self.cfg_comp.isMC:
            setattr(event,"cleanGenJets"           +self.cfg_ana.collectionPostFix, self.cleanGenJets           ) 
            setattr(event,"bqObjects"              +self.cfg_ana.collectionPostFix, self.bqObjects              ) 
            setattr(event,"cqObjects"              +self.cfg_ana.collectionPostFix, self.cqObjects              ) 
            setattr(event,"partons"                +self.cfg_ana.collectionPostFix, self.partons                ) 
            setattr(event,"heaviestQCDFlavour"     +self.cfg_ana.collectionPostFix, self.heaviestQCDFlavour     ) 
            setattr(event,"deltaMetFromJetSmearing"+self.cfg_ana.collectionPostFix, self.deltaMetFromJetSmearing) 
            setattr(event,"genJets"                +self.cfg_ana.collectionPostFix, self.genJets                ) 
 
        return True
Example #8
0
    def process(self, event):
        self.readCollections(event.input)
        rho = float(self.handles['rho'].product()[0])
        event.rho = rho

        ## Read jets, if necessary recalibrate and shift MET
        allJets = map(Jet, self.handles['jets'].product())

        event.deltaMetFromJEC = [0., 0.]
        if self.doJEC:
            #print "\nCalibrating jets %s for lumi %d, event %d" % (self.cfg_ana.jetCol, event.lumi, event.eventId)
            self.jetReCalibrator.correctAll(allJets,
                                            rho,
                                            delta=self.shiftJEC,
                                            metShift=event.deltaMetFromJEC)
        event.allJetsUsedForMET = allJets

        if self.cfg_comp.isMC:
            event.genJets = [x for x in self.handles['genJet'].product()]
            self.matchJets(event, allJets)
            if getattr(self.cfg_ana, 'smearJets', False):
                self.smearJets(event, allJets)

##Sort Jets by pT
        allJets.sort(key=lambda j: j.pt(), reverse=True)

        ## Apply jet selection
        event.jets = []
        event.jetsFailId = []
        event.jetsAllNoID = []
        event.jetsIdOnly = []
        for jet in allJets:
            if self.testJetNoID(jet):
                event.jetsAllNoID.append(jet)
                if self.testJetID(jet):

                    if (self.cfg_ana.doQG):
                        self.computeQGvars(jet)
                        jet.qgl = self.qglcalc.computeQGLikelihood(jet, rho)

                    event.jets.append(jet)
                    event.jetsIdOnly.append(jet)
                else:
                    event.jetsFailId.append(jet)
            elif self.testJetID(jet):
                event.jetsIdOnly.append(jet)

        ## Clean Jets from leptons
        leptons = []
        if hasattr(event, 'selectedLeptons'):
            leptons = [
                l for l in event.selectedLeptons if l.pt() > self.lepPtMin
            ]
        if self.cfg_ana.cleanJetsFromTaus and hasattr(event, 'selectedTaus'):
            leptons = leptons[:] + event.selectedTaus
        if self.cfg_ana.cleanJetsFromIsoTracks and hasattr(
                event, 'selectedIsoCleanTrack'):
            leptons = leptons[:] + event.selectedIsoCleanTrack
        event.cleanJetsAll, cleanLeptons = cleanJetsAndLeptons(
            event.jets, leptons, self.jetLepDR, self.jetLepArbitration)
        event.cleanJets = [
            j for j in event.cleanJetsAll
            if abs(j.eta()) < self.cfg_ana.jetEtaCentral
        ]
        event.cleanJetsFwd = [
            j for j in event.cleanJetsAll
            if abs(j.eta()) >= self.cfg_ana.jetEtaCentral
        ]
        event.discardedJets = [
            j for j in event.jets if j not in event.cleanJetsAll
        ]
        if hasattr(event, 'selectedLeptons'):
            event.discardedLeptons = [
                l for l in leptons if l not in cleanLeptons
            ]
            event.selectedLeptons = [
                l for l in event.selectedLeptons
                if l not in event.discardedLeptons
            ]

        ## Clean Jets from photons
        photons = []
        if hasattr(event, 'selectedPhotons'):
            if self.cfg_ana.cleanJetsFromFirstPhoton:
                photons = event.selectedPhotons[:1]
            else:
                photons = [g for g in event.selectedPhotons]

        event.gamma_cleanJetsAll = cleanNearestJetOnly(event.cleanJetsAll,
                                                       photons,
                                                       self.jetGammaDR)
        event.gamma_cleanJets = [
            j for j in event.gamma_cleanJetsAll
            if abs(j.eta()) < self.cfg_ana.jetEtaCentral
        ]
        event.gamma_cleanJetsFwd = [
            j for j in event.gamma_cleanJetsAll
            if abs(j.eta()) >= self.cfg_ana.jetEtaCentral
        ]
        ###

        ## Associate jets to leptons
        leptons = event.inclusiveLeptons if hasattr(
            event, 'inclusiveLeptons') else event.selectedLeptons
        jlpairs = matchObjectCollection(leptons, allJets, self.jetLepDR**2)

        for jet in allJets:
            jet.leptons = [l for l in jlpairs if jlpairs[l] == jet]

        for lep in leptons:
            jet = jlpairs[lep]
            if jet is None:
                lep.jet = lep
            else:
                lep.jet = jet
        ## Associate jets to taus
        taus = getattr(event, 'selectedTaus', [])
        jtaupairs = matchObjectCollection(taus, allJets, self.jetLepDR**2)

        for jet in allJets:
            jet.taus = [l for l in jtaupairs if jtaupairs[l] == jet]
        for tau in taus:
            tau.jet = jtaupairs[tau]

        #MC stuff
        if self.cfg_comp.isMC:
            event.deltaMetFromJetSmearing = [0, 0]
            for j in event.cleanJetsAll:
                if hasattr(j, 'deltaMetFromJetSmearing'):
                    event.deltaMetFromJetSmearing[
                        0] += j.deltaMetFromJetSmearing[0]
                    event.deltaMetFromJetSmearing[
                        1] += j.deltaMetFromJetSmearing[1]
            event.cleanGenJets = cleanNearestJetOnly(event.genJets, leptons,
                                                     self.jetLepDR)

            #event.nGenJets25 = 0
            #event.nGenJets25Cen = 0
            #event.nGenJets25Fwd = 0
            #for j in event.cleanGenJets:
            #    event.nGenJets25 += 1
            #    if abs(j.eta()) <= 2.4: event.nGenJets25Cen += 1
            #    else:                   event.nGenJets25Fwd += 1

            self.jetFlavour(event)

        return True
Example #9
0
    def process(self, event):

        self.readCollections(event.input)
        cmgJets = self.handles['jets'].product()

        allJets = []
        event.jets = []
        event.bJets = []
        event.cleanJets = []
        event.cleanBJets = []

        leg1 = event.diLepton.leg1()
        leg2 = event.diLepton.leg2()

        genJets = None
        if self.cfg_comp.isMC:
            genJets = map(GenJet, self.mchandles['genJets'].product())

        for cmgJet in cmgJets:
            jet = Jet(cmgJet)
            allJets.append(jet)
            if self.cfg_comp.isMC and hasattr(self.cfg_comp, 'jetScale'):
                scale = random.gauss(self.cfg_comp.jetScale,
                                     self.cfg_comp.jetSmear)
                jet.scaleEnergy(scale)

            if self.testJet(jet):
                event.jets.append(jet)
            if self.testBJet(jet):
                event.bJets.append(jet)
            if genJets:
                # Use DeltaR = 0.25 matching like JetMET
                pairs = matchObjectCollection([jet], genJets, 0.25 * 0.25)
                if pairs[jet] is None:
                    pass
                else:
                    jet.matchedGenJet = pairs[jet]

            #Add JER correction for MC jets. Requires gen-jet matching
            if self.cfg_comp.isMC and hasattr(
                    self.cfg_ana, 'jerCorr') and self.cfg_ana.jerCorr:
                self.jerCorrection(jet)

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

        event.cleanJets, dummy = cleanObjectCollection(event.jets,
                                                       masks=[leg1, leg2],
                                                       deltaRMin=0.5)

        event.cleanBJets, dummy = cleanObjectCollection(event.bJets,
                                                        masks=[leg1, leg2],
                                                        deltaRMin=0.5)

        pairs = matchObjectCollection([leg1, leg2], allJets, 0.5 * 0.5)

        # associating a jet to each leg
        leg1.jet = pairs[leg1]
        leg2.jet = pairs[leg2]
        if leg1.jet is None:  #COLIN: I don't understand the code below...
            leg1.jet = leg1
        if leg2.jet is None:
            leg2.jet = leg2

        # associating a leg to each clean jet
        invpairs = matchObjectCollection(event.cleanJets, [leg1, leg2], 99999.)
        for jet in event.cleanJets:
            leg = invpairs[jet]
            jet.leg = leg

        for jet in event.cleanJets:
            jet.matchGenParton = 999.0

        if self.cfg_comp.isMC and "BB" in self.cfg_comp.name:
            genParticles = self.mchandles['genParticles'].product()
            event.genParticles = map(GenParticle, genParticles)
            for gen in genParticles:
                if abs(gen.pdgId()) == 5 and gen.mother() and abs(
                        gen.mother().pdgId()) == 21:
                    for jet in event.cleanJets:
                        dR = deltaR2(jet.eta(), jet.phi(), gen.eta(),
                                     gen.phi())
                        if dR < jet.matchGenParton:
                            jet.matchGenParton = dR

        event.jets30 = [jet for jet in event.jets if jet.pt() > 30]
        event.cleanJets30 = [jet for jet in event.cleanJets if jet.pt() > 30]

        if len(event.jets30) >= 2:
            self.counters.counter('VBF').inc('at least 2 good jets')

        if len(event.cleanJets30) >= 2:
            self.counters.counter('VBF').inc('at least 2 clean jets')

        if len(event.cleanJets) < 2:
            return True

        event.vbf = VBF(event.cleanJets, event.diLepton, None,
                        self.cfg_ana.cjvPtCut)
        if event.vbf.mjj > self.cfg_ana.Mjj:
            self.counters.counter('VBF').inc(
                'M_jj > {cut:3.1f}'.format(cut=self.cfg_ana.Mjj))
        else:
            return True
        if abs(event.vbf.deta) > self.cfg_ana.deltaEta:
            self.counters.counter('VBF').inc(
                'delta Eta > {cut:3.1f}'.format(cut=self.cfg_ana.deltaEta))
        else:
            return True
        if len(event.vbf.centralJets) == 0:
            self.counters.counter('VBF').inc('no central jets')
        else:
            return True

        return True
Example #10
0
    def process(self, event):

        self.readCollections(event.input)
        miniaodjets = self.handles['jets'].product()

        allJets = []
        event.jets = []
        event.bJets = []
        event.cleanJets = []
        event.cleanBJets = []

        leptons = []
        if hasattr(event, 'selectedLeptons'):
            leptons = event.selectedLeptons

        genJets = None
        if self.cfg_comp.isMC:
            genJets = map(GenJet, self.mchandles['genJets'].product())

        for maodjet in miniaodjets:
            jet = Jet(maodjet)
            allJets.append(jet)
            if self.cfg_comp.isMC and hasattr(self.cfg_comp, 'jetScale'):
                scale = random.gauss(self.cfg_comp.jetScale,
                                     self.cfg_comp.jetSmear)
                jet.scaleEnergy(scale)
            if genJets:
                # Use DeltaR = 0.25 matching like JetMET
                pairs = matchObjectCollection([jet], genJets, 0.25 * 0.25)
                if pairs[jet] is None:
                    pass
                else:
                    jet.matchedGenJet = pairs[jet]
            # Add JER correction for MC jets. Requires gen-jet matching.
            if self.cfg_comp.isMC and hasattr(self.cfg_ana, 'jerCorr') and self.cfg_ana.jerCorr:
                self.jerCorrection(jet)
            # Add JES correction for MC jets.
            if self.cfg_comp.isMC and hasattr(self.cfg_ana, 'jesCorr'):
                self.jesCorrection(jet, self.cfg_ana.jesCorr)
            if self.testJet(jet):
                event.jets.append(jet)
            if self.testBJet(jet):
                event.bJets.append(jet)

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

        event.cleanJets, dummy = cleanObjectCollection(event.jets,
                                                       masks=leptons,
                                                       deltaRMin=0.5)
        event.cleanBJets, dummy = cleanObjectCollection(event.bJets,
                                                        masks=leptons,
                                                        deltaRMin=0.5)

        pairs = matchObjectCollection(leptons, allJets, 0.5 * 0.5)
        # associating a jet to each lepton
        for lepton in leptons:
            jet = pairs[lepton]
            if jet is None:
                lepton.jet = lepton
            else:
                lepton.jet = jet

        # associating a leg to each clean jet
        invpairs = matchObjectCollection(event.cleanJets, leptons, 99999.)
        for jet in event.cleanJets:
            leg = invpairs[jet]
            jet.leg = leg

        for jet in event.cleanJets:
            jet.matchGenParton = 999.0

        if self.cfg_comp.isMC and "BB" in self.cfg_comp.name:
            genParticles = self.mchandles['genParticles'].product()
            event.genParticles = map(GenParticle, genParticles)
            for gen in genParticles:
                if abs(gen.pdgId()) == 5 and gen.mother() and abs(gen.mother().pdgId()) == 21:
                    for jet in event.cleanJets:
                        dR = deltaR2(jet.eta(), jet.phi(), gen.eta(), gen.phi())
                        if dR < jet.matchGenParton:
                            jet.matchGenParton = dR

        event.jets30 = [jet for jet in event.jets if jet.pt() > 30]
        event.cleanJets30 = [jet for jet in event.cleanJets if jet.pt() > 30]
        if len(event.jets30) >= 2:
            self.counters.counter('jets').inc('at least 2 good jets')
        if len(event.cleanJets30) >= 2:
            self.counters.counter('jets').inc('at least 2 clean jets')
        if len(event.cleanBJets) > 0:
            self.counters.counter('jets').inc('at least 1 b jet')
            if len(event.cleanBJets) > 1:
                self.counters.counter('jets').inc('at least 2 b jets')
        return True
    def process(self, event):
        #get all the gen-jet
        event.gen_jet = map(lambda p: Particle.from_obj(p, 0), event.GenJet)
        event.gen_jet = filter(
            lambda x, conf=conf: x.p4().Pt() > conf["jets"]["pt"] and abs(x.p4().Eta()) < conf["jets"]["eta"],
            event.gen_jet
        )

        #match b-quarks to gen-jets by deltaR
        matches = matchObjectCollection(event.b_hadrons_sorted, event.gen_jet, 0.3)

        #find jets matched to b-quarks
        event.matched_b_jets = []
        for p in event.b_hadrons_sorted:
            if matches.has_key(p) and matches[p] != None:
                jet = matches[p]
                jet.source = p.source
                event.matched_b_jets += [jet]
                self.logger.debug("quark pt={0}, id={1} (from {2}) matched to jet pt={3}, id={4}".format(
                    p.p4().Pt(), p.pdg_id(), p.source, matches[p].p4().Pt(), matches[p].pdg_id())
                )
            else:
                self.logger.debug(
                    "b-quark with pt={0:.2f} not matched to gen-jet".format(p.p4().Pt())
                )

        #find jets matched to light quarks
        matches = matchObjectCollection(event.gen_q_w, event.gen_jet, 0.3)
        event.matched_q_jets = []
        for p in event.gen_q_w:
            if matches.has_key(p) and matches[p] != None:
                jet = matches[p]
                jet.source = p.source
                event.matched_q_jets += [jet]
                self.logger.debug("light quark pt={0}, id={1} matched to jet pt={2}, id={3}".format(
                    p.p4().Pt(), p.pdg_id(), matches[p].p4().Pt(), matches[p].pdg_id())
                )

        #find unmatched jets
        event.unmatched_jets = []
        for jet in event.gen_jet:
            if jet not in event.matched_b_jets and jet not in event.matched_q_jets:
                event.unmatched_jets += [jet]

        #count number of jets matched to quarks from certain origin
        match_count = {
            "t": 0,
            "h": 0,
            "w": 0,
            "other": 0,
        }
        for jet in event.matched_b_jets + event.matched_q_jets:
            match_count[jet.source] += 1
        event.match_count = match_count
        self.logger.info("process: matched_b_jets={0} matched_q_jets={0}".format(len(event.matched_b_jets), len(event.matched_q_jets)))

        #Creates a jet-level representation
        event.repr_matched_jets = EventRepresentation(
            b_quarks = event.matched_b_jets[:4],
            l_quarks = event.matched_q_jets[:2],
            leptons = event.gen_lep,
            invisible = event.gen_met,
        )


        event.repr_matched_jets_smeared = copy.deepcopy(event.repr_quarks)
        event.repr_matched_jets_smeared.smear_quarks()

        event.interpretations["gen_jet_matched_2w2h2t"] = event.repr_matched_jets.make_interpretation("2w2h2t", self.conf, "sl_2w2h2t")
        event.interpretations["gen_jet_matched_2w2h2t_smeared"] = event.repr_matched_jets_smeared.make_interpretation("2w2h2t", self.conf, "sl_2w2h2t")

        #event.interpretations["gen_b_q_jet_flavour"] = event.repr_matched_jets_flavour.make_interpretation("2w2h2t", self.conf, "sl_2w2h2t")
        return True
Example #12
0
    def process(self, event):
        self.readCollections(event.input)
        rho = float(self.handles['rho'].product()[0])
        self.rho = rho

        ## Read jets, if necessary recalibrate and shift MET
        if self.cfg_ana.copyJetsByValue:
            import ROOT
            #from ROOT.heppy import JetUtils
            allJets = map(
                lambda j: Jet(ROOT.heppy.JetUtils.copyJet(j)),
                self.handles['jets'].product(
                ))  #copy-by-value is safe if JetAnalyzer is ran more than once
        else:
            allJets = map(Jet, self.handles['jets'].product())

        #set dummy MC flavour for all jets in case we want to ntuplize discarded jets later
        for jet in allJets:
            jet.mcFlavour = 0

        self.deltaMetFromJEC = [0., 0.]
        self.type1METCorr = [0., 0., 0.]
        #        print "before. rho",self.rho,self.cfg_ana.collectionPostFix,'allJets len ',len(allJets),'pt', [j.pt() for j in allJets]
        if self.doJEC:
            if not self.recalibrateJets:  # check point that things won't change
                jetsBefore = [(j.pt(), j.eta(), j.phi(), j.rawFactor())
                              for j in allJets]
            self.jetReCalibrator.correctAll(allJets,
                                            rho,
                                            delta=self.shiftJEC,
                                            addCorr=True,
                                            addShifts=self.addJECShifts,
                                            metShift=self.deltaMetFromJEC,
                                            type1METCorr=self.type1METCorr)
            if not self.recalibrateJets:
                jetsAfter = [(j.pt(), j.eta(), j.phi(), j.rawFactor())
                             for j in allJets]
                if len(jetsBefore) != len(jetsAfter):
                    print "ERROR: I had to recompute jet corrections, and they rejected some of the jets:\nold = %s\n new = %s\n" % (
                        jetsBefore, jetsAfter)
                else:
                    for (told, tnew) in zip(jetsBefore, jetsAfter):
                        if (deltaR2(told[1], told[2], tnew[1],
                                    tnew[2])) > 0.0001:
                            print "ERROR: I had to recompute jet corrections, and one jet direction moved: old = %s, new = %s\n" % (
                                told, tnew)
                        elif abs(told[0] - tnew[0]) / (
                                told[0] + tnew[0]) > 0.5e-3 or abs(
                                    told[3] - tnew[3]) > 0.5e-3:
                            print "ERROR: I had to recompute jet corrections, and one jet pt or corr changed: old = %s, new = %s\n" % (
                                told, tnew)
        self.allJetsUsedForMET = allJets
        #        print "after. rho",self.rho,self.cfg_ana.collectionPostFix,'allJets len ',len(allJets),'pt', [j.pt() for j in allJets]

        if self.cfg_comp.isMC:
            self.genJets = [x for x in self.handles['genJet'].product()]
            if self.cfg_ana.do_mc_match:
                for igj, gj in enumerate(self.genJets):
                    gj.index = igj
#                self.matchJets(event, allJets)
                self.matchJets(
                    event, [j for j in allJets if j.pt() > self.cfg_ana.jetPt
                            ])  # To match only jets above chosen threshold
            if getattr(self.cfg_ana, 'smearJets', False):
                self.smearJets(event, allJets)

##Sort Jets by pT
        allJets.sort(key=lambda j: j.pt(), reverse=True)

        leptons = []
        if hasattr(event, 'selectedLeptons'):
            leptons = [
                l for l in event.selectedLeptons
                if l.pt() > self.lepPtMin and self.lepSelCut(l)
            ]
        if self.cfg_ana.cleanJetsFromTaus and hasattr(event, 'selectedTaus'):
            leptons = leptons[:] + event.selectedTaus
        if self.cfg_ana.cleanJetsFromIsoTracks and hasattr(
                event, 'selectedIsoCleanTrack'):
            leptons = leptons[:] + event.selectedIsoCleanTrack

## Apply jet selection
        self.jets = []
        self.jetsFailId = []
        self.jetsAllNoID = []
        self.jetsIdOnly = []
        for jet in allJets:
            #Check if lepton and jet have overlapping PF candidates
            leps_with_overlaps = []
            if getattr(self.cfg_ana, 'checkLeptonPFOverlap', True):
                for i in range(jet.numberOfSourceCandidatePtrs()):
                    p1 = jet.sourceCandidatePtr(i)  #Ptr<Candidate> p1
                    for lep in leptons:
                        for j in range(lep.numberOfSourceCandidatePtrs()):
                            p2 = lep.sourceCandidatePtr(j)
                            has_overlaps = p1.key() == p2.key() and p1.refCore(
                            ).id().productIndex() == p2.refCore().id(
                            ).productIndex() and p1.refCore().id(
                            ).processIndex() == p2.refCore().id().processIndex(
                            )
                            if has_overlaps:
                                leps_with_overlaps += [lep]
            if len(leps_with_overlaps) > 0:
                for lep in leps_with_overlaps:
                    lep.jetOverlap = jet
            if self.testJetNoID(jet):
                self.jetsAllNoID.append(jet)
                if (self.cfg_ana.doQG):
                    jet.qgl_calc = self.qglcalc.computeQGLikelihood
                    jet.qgl_rho = rho
                if self.testJetID(jet):
                    self.jets.append(jet)
                    self.jetsIdOnly.append(jet)
                else:
                    self.jetsFailId.append(jet)
            elif self.testJetID(jet):
                self.jetsIdOnly.append(jet)

        jetsEtaCut = [
            j for j in self.jets if abs(j.eta()) < self.cfg_ana.jetEta
        ]
        self.cleanJetsAll, cleanLeptons = cleanJetsAndLeptons(
            jetsEtaCut, leptons, self.jetLepDR, self.jetLepArbitration)

        self.cleanJets = [
            j for j in self.cleanJetsAll
            if abs(j.eta()) < self.cfg_ana.jetEtaCentral
        ]
        self.cleanJetsFwd = [
            j for j in self.cleanJetsAll
            if abs(j.eta()) >= self.cfg_ana.jetEtaCentral
        ]
        self.discardedJets = [
            j for j in self.jets if j not in self.cleanJetsAll
        ]
        if hasattr(event,
                   'selectedLeptons') and self.cfg_ana.cleanSelectedLeptons:
            event.discardedLeptons = [
                l for l in leptons if l not in cleanLeptons
            ]
            event.selectedLeptons = [
                l for l in event.selectedLeptons
                if l not in event.discardedLeptons
            ]
        for lep in leptons:
            if hasattr(lep, "jetOverlap"):
                if lep.jetOverlap in self.cleanJetsAll:
                    #print "overlap reco", lep.p4().pt(), lep.p4().eta(), lep.p4().phi(), lep.jetOverlap.p4().pt(), lep.jetOverlap.p4().eta(), lep.jetOverlap.p4().phi()
                    lep.jetOverlapIdx = self.cleanJetsAll.index(lep.jetOverlap)
                elif lep.jetOverlap in self.discardedJets:
                    #print "overlap discarded", lep.p4().pt(), lep.p4().eta(), lep.p4().phi(), lep.jetOverlap.p4().pt(), lep.jetOverlap.p4().eta(), lep.jetOverlap.p4().phi()
                    lep.jetOverlapIdx = 1000 + self.discardedJets.index(
                        lep.jetOverlap)

        ## First cleaning, then Jet Id
        self.noIdCleanJetsAll, cleanLeptons = cleanJetsAndLeptons(
            self.jetsAllNoID, leptons, self.jetLepDR, self.jetLepArbitration)
        self.noIdCleanJets = [
            j for j in self.noIdCleanJetsAll
            if abs(j.eta()) < self.cfg_ana.jetEtaCentral
        ]
        self.noIdCleanJetsFwd = [
            j for j in self.noIdCleanJetsAll
            if abs(j.eta()) >= self.cfg_ana.jetEtaCentral
        ]
        self.noIdDiscardedJets = [
            j for j in self.jetsAllNoID if j not in self.noIdCleanJetsAll
        ]

        ## Clean Jets from photons (first cleaning, then Jet Id)
        photons = []
        if hasattr(event, 'selectedPhotons'):
            if self.cfg_ana.cleanJetsFromFirstPhoton:
                photons = event.selectedPhotons[:1]
            else:
                photons = [g for g in event.selectedPhotons]

        self.gamma_cleanJetaAll = []
        self.gamma_noIdCleanJetsAll = []

        if self.cleanFromLepAndGammaSimultaneously:
            self.gamma_cleanJetsAll = cleanNearestJetOnly(
                jetsEtaCut, photons + leptons, self.jetGammaLepDR)
            self.gamma_noIdCleanJetsAll = cleanNearestJetOnly(
                self.jetsAllNoID, photons + leptons, self.jetGammaLepDR)
        else:
            self.gamma_cleanJetsAll = cleanNearestJetOnly(
                self.cleanJetsAll, photons, self.jetGammaDR)
            self.gamma_noIdCleanJetsAll = cleanNearestJetOnly(
                self.noIdCleanJetsAll, photons, self.jetGammaDR)

        self.gamma_cleanJets = [
            j for j in self.gamma_cleanJetsAll
            if abs(j.eta()) < self.cfg_ana.jetEtaCentral
        ]
        self.gamma_cleanJetsFwd = [
            j for j in self.gamma_cleanJetsAll
            if abs(j.eta()) >= self.cfg_ana.jetEtaCentral
        ]

        self.gamma_noIdCleanJets = [
            j for j in self.gamma_noIdCleanJetsAll
            if abs(j.eta()) < self.cfg_ana.jetEtaCentral
        ]
        self.gamma_noIdCleanJetsFwd = [
            j for j in self.gamma_noIdCleanJetsAll
            if abs(j.eta()) >= self.cfg_ana.jetEtaCentral
        ]
        ###

        if self.cfg_ana.alwaysCleanPhotons:
            self.cleanJets = self.gamma_cleanJets
            self.cleanJetsAll = self.gamma_cleanJetsAll
            self.cleanJetsFwd = self.gamma_cleanJetsFwd
            #
            self.noIdCleanJets = self.gamma_noIdCleanJets
            self.noIdCleanJetsAll = self.gamma_noIdCleanJetsAll
            self.noIdCleanJetsFwd = self.gamma_noIdCleanJetsFwd

        ## Jet Id, after jet/lepton cleaning
        self.cleanJetsFailIdAll = []
        for jet in self.noIdCleanJetsAll:
            if not self.testJetID(jet):
                self.cleanJetsFailIdAll.append(jet)

        self.cleanJetsFailId = [
            j for j in self.cleanJetsFailIdAll
            if abs(j.eta()) < self.cfg_ana.jetEtaCentral
        ]

        ## Jet Id, after jet/photon cleaning
        self.gamma_cleanJetsFailIdAll = []
        for jet in self.gamma_noIdCleanJetsAll:
            if not self.testJetID(jet):
                self.gamma_cleanJetsFailIdAll.append(jet)

        self.gamma_cleanJetsFailId = [
            j for j in self.gamma_cleanJetsFailIdAll
            if abs(j.eta()) < self.cfg_ana.jetEtaCentral
        ]

        ## Associate jets to leptons
        incleptons = event.inclusiveLeptons if hasattr(
            event, 'inclusiveLeptons') else event.selectedLeptons
        jlpairs = matchObjectCollection(incleptons, allJets, self.jetLepDR**2)

        for jet in allJets:
            jet.leptons = [l for l in jlpairs if jlpairs[l] == jet]
        for lep in incleptons:
            jet = jlpairs[lep]
            if jet is None:
                setattr(lep, "jet" + self.cfg_ana.collectionPostFix, lep)
            else:
                setattr(lep, "jet" + self.cfg_ana.collectionPostFix, jet)
        ## Associate jets to taus
        taus = getattr(event, 'selectedTaus', [])
        jtaupairs = matchObjectCollection(taus, allJets, self.jetLepDR**2)

        for jet in allJets:
            jet.taus = [l for l in jtaupairs if jtaupairs[l] == jet]
        for tau in taus:
            setattr(tau, "jet" + self.cfg_ana.collectionPostFix,
                    jtaupairs[tau])

        #MC stuff
        if self.cfg_comp.isMC:
            self.deltaMetFromJetSmearing = [0, 0]
            for j in self.cleanJetsAll:
                if hasattr(j, 'deltaMetFromJetSmearing'):
                    self.deltaMetFromJetSmearing[
                        0] += j.deltaMetFromJetSmearing[0]
                    self.deltaMetFromJetSmearing[
                        1] += j.deltaMetFromJetSmearing[1]

            self.cleanGenJets = cleanNearestJetOnly(self.genJets, leptons,
                                                    self.jetLepDR)

            if self.cfg_ana.cleanGenJetsFromPhoton:
                self.cleanGenJets = cleanNearestJetOnly(
                    self.cleanGenJets, photons, self.jetLepDR)

            if getattr(self.cfg_ana, 'attachNeutrinos', True) and hasattr(
                    self.cfg_ana, "genNuSelection"):
                jetNus = [
                    x for x in event.genParticles
                    if abs(x.pdgId()) in [12, 14, 16]
                    and self.cfg_ana.genNuSelection(x)
                ]
                pairs = matchObjectCollection(jetNus, self.genJets, 0.4**2)

                for (nu, genJet) in pairs.iteritems():
                    if genJet is not None:
                        if not hasattr(genJet, "nu"):
                            genJet.nu = nu.p4()
                        else:
                            genJet.nu += nu.p4()

            if self.cfg_ana.do_mc_match:
                self.jetFlavour(event)

        if hasattr(event, "jets" + self.cfg_ana.collectionPostFix):
            raise RuntimeError(
                "Event already contains a jet collection with the following postfix: "
                + self.cfg_ana.collectionPostFix)
        setattr(event, "rho" + self.cfg_ana.collectionPostFix, self.rho)
        setattr(event, "deltaMetFromJEC" + self.cfg_ana.collectionPostFix,
                self.deltaMetFromJEC)
        setattr(event, "type1METCorr" + self.cfg_ana.collectionPostFix,
                self.type1METCorr)
        setattr(event, "allJetsUsedForMET" + self.cfg_ana.collectionPostFix,
                self.allJetsUsedForMET)
        setattr(event, "jets" + self.cfg_ana.collectionPostFix, self.jets)
        setattr(event, "jetsFailId" + self.cfg_ana.collectionPostFix,
                self.jetsFailId)
        setattr(event, "jetsAllNoID" + self.cfg_ana.collectionPostFix,
                self.jetsAllNoID)
        setattr(event, "jetsIdOnly" + self.cfg_ana.collectionPostFix,
                self.jetsIdOnly)
        setattr(event, "cleanJetsAll" + self.cfg_ana.collectionPostFix,
                self.cleanJetsAll)
        setattr(event, "cleanJets" + self.cfg_ana.collectionPostFix,
                self.cleanJets)
        setattr(event, "cleanJetsFwd" + self.cfg_ana.collectionPostFix,
                self.cleanJetsFwd)
        setattr(event, "cleanJetsFailIdAll" + self.cfg_ana.collectionPostFix,
                self.cleanJetsFailIdAll)
        setattr(event, "cleanJetsFailId" + self.cfg_ana.collectionPostFix,
                self.cleanJetsFailId)
        setattr(event, "discardedJets" + self.cfg_ana.collectionPostFix,
                self.discardedJets)
        setattr(event, "gamma_cleanJetsAll" + self.cfg_ana.collectionPostFix,
                self.gamma_cleanJetsAll)
        setattr(event, "gamma_cleanJets" + self.cfg_ana.collectionPostFix,
                self.gamma_cleanJets)
        setattr(event, "gamma_cleanJetsFwd" + self.cfg_ana.collectionPostFix,
                self.gamma_cleanJetsFwd)
        setattr(event,
                "gamma_cleanJetsFailIdAll" + self.cfg_ana.collectionPostFix,
                self.gamma_cleanJetsFailIdAll)
        setattr(event,
                "gamma_cleanJetsFailId" + self.cfg_ana.collectionPostFix,
                self.gamma_cleanJetsFailId)

        if self.cfg_comp.isMC:
            setattr(event,
                    "deltaMetFromJetSmearing" + self.cfg_ana.collectionPostFix,
                    self.deltaMetFromJetSmearing)
            setattr(event, "cleanGenJets" + self.cfg_ana.collectionPostFix,
                    self.cleanGenJets)
            setattr(event, "genJets" + self.cfg_ana.collectionPostFix,
                    self.genJets)
            if self.cfg_ana.do_mc_match:
                setattr(event, "bqObjects" + self.cfg_ana.collectionPostFix,
                        self.bqObjects)
                setattr(event, "cqObjects" + self.cfg_ana.collectionPostFix,
                        self.cqObjects)
                setattr(event, "partons" + self.cfg_ana.collectionPostFix,
                        self.partons)
                setattr(event,
                        "heaviestQCDFlavour" + self.cfg_ana.collectionPostFix,
                        self.heaviestQCDFlavour)

        return True
Example #13
0
    def process(self, event):
        self.readCollections( event.input )
        triggerBits = self.handles['TriggerBits'].product()
        allTriggerObjects = self.handles['TriggerObjects'].product()
        names = event.input.object().triggerNames(triggerBits)
        for ob in allTriggerObjects: ob.unpackPathNames(names)
        triggerObjects = [ob for ob in allTriggerObjects if False not in [sel(ob) for sel in self.trgObjSelectors]]

        setattr(event,'trgObjects_'+self.label,triggerObjects)

        if self.collToMatch:
            tcoll = getattr(event,self.collToMatch)
            doubleandselector = lambda lep,ob: False if False in [sel(lep,ob) for sel in self.collMatchSelectors] else True
            pairs = matchObjectCollection3(tcoll,triggerObjects,deltaRMax=self.collMatchDRCut,filter=doubleandselector) if self.match1To1 else matchObjectCollection(tcoll,triggerObjects,self.collMatchDRCut,filter=doubleandselector)
            for lep in tcoll: setattr(lep,'matchedTrgObj'+self.label,pairs[lep])

        if self.verbose:
            print 'Verbose debug for triggerMatchAnalyzer %s'%self.label
            for ob in getattr(event,'trgObjects_'+self.label):
                types = ", ".join([str(f) for f in ob.filterIds()])
                filters = ", ".join([str(f) for f in ob.filterLabels()])
                paths = ", ".join([("%s***" if f in set(ob.pathNames(True)) else "%s")%f for f in ob.pathNames()]) # asterisks indicate final paths fired by this object, see pat::TriggerObjectStandAlone class
                print 'Trigger object: pt=%.2f, eta=%.2f, phi=%.2f, collection=%s, type_ids=%s, filters=%s, paths=%s'%(ob.pt(),ob.eta(),ob.phi(),ob.collection(),types,filters,paths)
            if self.collToMatch:
                for lep in tcoll:
                    mstring = 'None'
                    ob = getattr(lep,'matchedTrgObj'+self.label)
                    if ob: mstring = 'trigger obj with pt=%.2f, eta=%.2f, phi=%.2f, collection=%s'%(ob.pt(),ob.eta(),ob.phi(),ob.collection())
                    print 'Lepton pt=%.2f, eta=%.2f, phi=%.2f matched to %s'%(lep.pt(),lep.eta(),lep.phi(),mstring)

        return True
Example #14
0
    def process(self, event):
        self.readCollections( event.input )
        rho  = float(self.handles['rho'].product()[0])
        self.rho = rho

        ## Read jets, if necessary recalibrate and shift MET
        if self.cfg_ana.copyJetsByValue: 
            import ROOT
            #from ROOT.heppy import JetUtils
            allJets = map(lambda j:Jet(ROOT.heppy.JetUtils.copyJet(j)), self.handles['jets'].product())  #copy-by-value is safe if JetAnalyzer is ran more than once
        else: 
            allJets = map(Jet, self.handles['jets'].product()) 

        #set dummy MC flavour for all jets in case we want to ntuplize discarded jets later
        for jet in allJets:
            jet.mcFlavour = 0

        self.deltaMetFromJEC = [0.,0.]
        self.type1METCorr    = [0.,0.,0.]
#        print "before. rho",self.rho,self.cfg_ana.collectionPostFix,'allJets len ',len(allJets),'pt', [j.pt() for j in allJets]
        if self.doJEC:
            if not self.recalibrateJets:  # check point that things won't change
                jetsBefore = [ (j.pt(),j.eta(),j.phi(),j.rawFactor()) for j in allJets ]
            self.jetReCalibrator.correctAll(allJets, rho, delta=self.shiftJEC, 
                                                addCorr=True, addShifts=self.addJECShifts,
                                                metShift=self.deltaMetFromJEC, type1METCorr=self.type1METCorr )           
            if not self.recalibrateJets: 
                jetsAfter = [ (j.pt(),j.eta(),j.phi(),j.rawFactor()) for j in allJets ]
                if len(jetsBefore) != len(jetsAfter): 
                    print("ERROR: I had to recompute jet corrections, and they rejected some of the jets:\nold = %s\n new = %s\n" % (jetsBefore,jetsAfter))
                else:
                    for (told, tnew) in zip(jetsBefore,jetsAfter):
                        if (deltaR2(told[1],told[2],tnew[1],tnew[2])) > 0.0001:
                            print("ERROR: I had to recompute jet corrections, and one jet direction moved: old = %s, new = %s\n" % (told, tnew))
                        elif abs(told[0]-tnew[0])/(told[0]+tnew[0]) > 0.5e-3 or abs(told[3]-tnew[3]) > 0.5e-3:
                            print("ERROR: I had to recompute jet corrections, and one jet pt or corr changed: old = %s, new = %s\n" % (told, tnew))
        self.allJetsUsedForMET = allJets
#        print "after. rho",self.rho,self.cfg_ana.collectionPostFix,'allJets len ',len(allJets),'pt', [j.pt() for j in allJets]

        if self.cfg_comp.isMC:
            self.genJets = [ x for x in self.handles['genJet'].product() ]
            if self.cfg_ana.do_mc_match:
                for igj, gj in enumerate(self.genJets):
                    gj.index = igj
#                self.matchJets(event, allJets)
                self.matchJets(event, [ j for j in allJets if j.pt()>self.cfg_ana.jetPt ]) # To match only jets above chosen threshold
            if getattr(self.cfg_ana, 'smearJets', False):
                self.smearJets(event, allJets)




        ##Sort Jets by pT 
        allJets.sort(key = lambda j : j.pt(), reverse = True)

        leptons = []
        if hasattr(event, 'selectedLeptons'):
            leptons = [ l for l in event.selectedLeptons if l.pt() > self.lepPtMin and self.lepSelCut(l) ]
        if self.cfg_ana.cleanJetsFromTaus and hasattr(event, 'selectedTaus'):
            leptons = leptons[:] + event.selectedTaus
        if self.cfg_ana.cleanJetsFromIsoTracks and hasattr(event, 'selectedIsoCleanTrack'):
            leptons = leptons[:] + event.selectedIsoCleanTrack

        ## Apply jet selection
        self.jets = []
        self.jetsFailId = []
        self.jetsAllNoID = []
        self.jetsIdOnly = []
        for jet in allJets:
            #Check if lepton and jet have overlapping PF candidates 
            leps_with_overlaps = []
            if getattr(self.cfg_ana, 'checkLeptonPFOverlap', True):
                for i in range(jet.numberOfSourceCandidatePtrs()):
                    p1 = jet.sourceCandidatePtr(i) #Ptr<Candidate> p1
                    for lep in leptons:
                        for j in range(lep.numberOfSourceCandidatePtrs()):
                            p2 = lep.sourceCandidatePtr(j)
                            has_overlaps = p1.key() == p2.key() and p1.refCore().id().productIndex() == p2.refCore().id().productIndex() and p1.refCore().id().processIndex() == p2.refCore().id().processIndex()
                            if has_overlaps:
                                leps_with_overlaps += [lep]
            if len(leps_with_overlaps)>0:
                for lep in leps_with_overlaps:
                    lep.jetOverlap = jet
            if self.testJetNoID( jet ): 
                self.jetsAllNoID.append(jet) 
                if(self.cfg_ana.doQG):
                    jet.qgl_calc =  self.qglcalc.computeQGLikelihood
                    jet.qgl_rho =  rho
                if self.testJetID( jet ):
                    self.jets.append(jet)
                    self.jetsIdOnly.append(jet)
                else:
                    self.jetsFailId.append(jet)
            elif self.testJetID (jet ):
                self.jetsIdOnly.append(jet)

        jetsEtaCut = [j for j in self.jets if abs(j.eta()) <  self.cfg_ana.jetEta ]
        self.cleanJetsAll, cleanLeptons = cleanJetsAndLeptons(jetsEtaCut, leptons, self.jetLepDR, self.jetLepArbitration)

        self.cleanJets    = [j for j in self.cleanJetsAll if abs(j.eta()) <  self.cfg_ana.jetEtaCentral ]
        self.cleanJetsFwd = [j for j in self.cleanJetsAll if abs(j.eta()) >= self.cfg_ana.jetEtaCentral ]
        self.discardedJets = [j for j in self.jets if j not in self.cleanJetsAll]
        if hasattr(event, 'selectedLeptons') and self.cfg_ana.cleanSelectedLeptons:
            event.discardedLeptons = [ l for l in leptons if l not in cleanLeptons ]
            event.selectedLeptons  = [ l for l in event.selectedLeptons if l not in event.discardedLeptons ]
        for lep in leptons:
            if hasattr(lep, "jetOverlap"):
                if lep.jetOverlap in self.cleanJetsAll:
                    #print "overlap reco", lep.p4().pt(), lep.p4().eta(), lep.p4().phi(), lep.jetOverlap.p4().pt(), lep.jetOverlap.p4().eta(), lep.jetOverlap.p4().phi()
                    lep.jetOverlapIdx = self.cleanJetsAll.index(lep.jetOverlap)
                elif lep.jetOverlap in self.discardedJets:
                    #print "overlap discarded", lep.p4().pt(), lep.p4().eta(), lep.p4().phi(), lep.jetOverlap.p4().pt(), lep.jetOverlap.p4().eta(), lep.jetOverlap.p4().phi()
                    lep.jetOverlapIdx = 1000 + self.discardedJets.index(lep.jetOverlap)

        ## First cleaning, then Jet Id
        self.noIdCleanJetsAll, cleanLeptons = cleanJetsAndLeptons(self.jetsAllNoID, leptons, self.jetLepDR, self.jetLepArbitration)
        self.noIdCleanJets = [j for j in self.noIdCleanJetsAll if abs(j.eta()) <  self.cfg_ana.jetEtaCentral ]
        self.noIdCleanJetsFwd = [j for j in self.noIdCleanJetsAll if abs(j.eta()) >=  self.cfg_ana.jetEtaCentral ]
        self.noIdDiscardedJets = [j for j in self.jetsAllNoID if j not in self.noIdCleanJetsAll]

        ## Clean Jets from photons (first cleaning, then Jet Id)
        photons = []
        if hasattr(event, 'selectedPhotons'):
            if self.cfg_ana.cleanJetsFromFirstPhoton:
                photons = event.selectedPhotons[:1]
            else:
                photons = [ g for g in event.selectedPhotons ] 

        self.gamma_cleanJetaAll = []
        self.gamma_noIdCleanJetsAll = []

        if self.cleanFromLepAndGammaSimultaneously:
            self.gamma_cleanJetsAll = cleanNearestJetOnly(jetsEtaCut, photons+leptons, self.jetGammaLepDR)
            self.gamma_noIdCleanJetsAll = cleanNearestJetOnly(self.jetsAllNoID, photons+leptons, self.jetGammaLepDR)
        else:
            self.gamma_cleanJetsAll = cleanNearestJetOnly(self.cleanJetsAll, photons, self.jetGammaDR)
            self.gamma_noIdCleanJetsAll = cleanNearestJetOnly(self.noIdCleanJetsAll, photons, self.jetGammaDR)

        self.gamma_cleanJets    = [j for j in self.gamma_cleanJetsAll if abs(j.eta()) <  self.cfg_ana.jetEtaCentral ]
        self.gamma_cleanJetsFwd = [j for j in self.gamma_cleanJetsAll if abs(j.eta()) >= self.cfg_ana.jetEtaCentral ]

        self.gamma_noIdCleanJets    = [j for j in self.gamma_noIdCleanJetsAll if abs(j.eta()) <  self.cfg_ana.jetEtaCentral ]
        self.gamma_noIdCleanJetsFwd = [j for j in self.gamma_noIdCleanJetsAll if abs(j.eta()) >= self.cfg_ana.jetEtaCentral ]
        ###

        if self.cfg_ana.alwaysCleanPhotons:
            self.cleanJets = self.gamma_cleanJets
            self.cleanJetsAll = self.gamma_cleanJetsAll
            self.cleanJetsFwd = self.gamma_cleanJetsFwd
            #
            self.noIdCleanJets = self.gamma_noIdCleanJets
            self.noIdCleanJetsAll = self.gamma_noIdCleanJetsAll
            self.noIdCleanJetsFwd = self.gamma_noIdCleanJetsFwd

        ## Jet Id, after jet/lepton cleaning
        self.cleanJetsFailIdAll = []
        for jet in self.noIdCleanJetsAll:
            if not self.testJetID( jet ):
                self.cleanJetsFailIdAll.append(jet)

        self.cleanJetsFailId = [j for j in self.cleanJetsFailIdAll if abs(j.eta()) <  self.cfg_ana.jetEtaCentral ]

        ## Jet Id, after jet/photon cleaning
        self.gamma_cleanJetsFailIdAll = []
        for jet in self.gamma_noIdCleanJetsAll:
            if not self.testJetID( jet ):
                self.gamma_cleanJetsFailIdAll.append(jet)

        self.gamma_cleanJetsFailId = [j for j in self.gamma_cleanJetsFailIdAll if abs(j.eta()) <  self.cfg_ana.jetEtaCentral ]

        ## Associate jets to leptons
        incleptons = event.inclusiveLeptons if hasattr(event, 'inclusiveLeptons') else event.selectedLeptons
        jlpairs = matchObjectCollection(incleptons, allJets, self.jetLepDR**2)

        for jet in allJets:
            jet.leptons = [l for l in jlpairs if jlpairs[l] == jet ]
        for lep in incleptons:
            jet = jlpairs[lep]
            if jet is None:
                setattr(lep,"jet"+self.cfg_ana.collectionPostFix,lep)
            else:
                setattr(lep,"jet"+self.cfg_ana.collectionPostFix,jet)
        ## Associate jets to taus 
        taus = getattr(event,'selectedTaus',[])
        jtaupairs = matchObjectCollection( taus, allJets, self.jetLepDR**2)

        for jet in allJets:
            jet.taus = [l for l in jtaupairs if jtaupairs[l] == jet ]
        for tau in taus:
            setattr(tau,"jet"+self.cfg_ana.collectionPostFix,jtaupairs[tau])

        #MC stuff
        if self.cfg_comp.isMC:
            self.deltaMetFromJetSmearing = [0, 0]
            for j in self.cleanJetsAll:
                if hasattr(j, 'deltaMetFromJetSmearing'):
                    self.deltaMetFromJetSmearing[0] += j.deltaMetFromJetSmearing[0]
                    self.deltaMetFromJetSmearing[1] += j.deltaMetFromJetSmearing[1]

            self.cleanGenJets = cleanNearestJetOnly(self.genJets, leptons, self.jetLepDR)

            if self.cfg_ana.cleanGenJetsFromPhoton:
                self.cleanGenJets = cleanNearestJetOnly(self.cleanGenJets, photons, self.jetLepDR)

            if getattr(self.cfg_ana, 'attachNeutrinos', True) and hasattr(self.cfg_ana,"genNuSelection") :
                jetNus=[x for x in event.genParticles if abs(x.pdgId()) in [12,14,16] and self.cfg_ana.genNuSelection(x) ]
                pairs= matchObjectCollection (jetNus, self.genJets, 0.4**2)

                for (nu,genJet) in six.iteritems(pairs) :
                    if genJet is not None :
                        if not hasattr(genJet,"nu") :
                            genJet.nu=nu.p4()
                        else :
                            genJet.nu+=nu.p4()


            if self.cfg_ana.do_mc_match:
                self.jetFlavour(event)

        if hasattr(event,"jets"+self.cfg_ana.collectionPostFix): raise RuntimeError("Event already contains a jet collection with the following postfix: "+self.cfg_ana.collectionPostFix)
        setattr(event,"rho"                    +self.cfg_ana.collectionPostFix, self.rho                    ) 
        setattr(event,"deltaMetFromJEC"        +self.cfg_ana.collectionPostFix, self.deltaMetFromJEC        ) 
        setattr(event,"type1METCorr"           +self.cfg_ana.collectionPostFix, self.type1METCorr           ) 
        setattr(event,"allJetsUsedForMET"      +self.cfg_ana.collectionPostFix, self.allJetsUsedForMET      ) 
        setattr(event,"jets"                   +self.cfg_ana.collectionPostFix, self.jets                   ) 
        setattr(event,"jetsFailId"             +self.cfg_ana.collectionPostFix, self.jetsFailId             ) 
        setattr(event,"jetsAllNoID"            +self.cfg_ana.collectionPostFix, self.jetsAllNoID            ) 
        setattr(event,"jetsIdOnly"             +self.cfg_ana.collectionPostFix, self.jetsIdOnly             ) 
        setattr(event,"cleanJetsAll"           +self.cfg_ana.collectionPostFix, self.cleanJetsAll           ) 
        setattr(event,"cleanJets"              +self.cfg_ana.collectionPostFix, self.cleanJets              ) 
        setattr(event,"cleanJetsFwd"           +self.cfg_ana.collectionPostFix, self.cleanJetsFwd           ) 
        setattr(event,"cleanJetsFailIdAll"           +self.cfg_ana.collectionPostFix, self.cleanJetsFailIdAll           ) 
        setattr(event,"cleanJetsFailId"              +self.cfg_ana.collectionPostFix, self.cleanJetsFailId              ) 
        setattr(event,"discardedJets"          +self.cfg_ana.collectionPostFix, self.discardedJets          ) 
        setattr(event,"gamma_cleanJetsAll"     +self.cfg_ana.collectionPostFix, self.gamma_cleanJetsAll     ) 
        setattr(event,"gamma_cleanJets"        +self.cfg_ana.collectionPostFix, self.gamma_cleanJets        ) 
        setattr(event,"gamma_cleanJetsFwd"     +self.cfg_ana.collectionPostFix, self.gamma_cleanJetsFwd     ) 
        setattr(event,"gamma_cleanJetsFailIdAll"     +self.cfg_ana.collectionPostFix, self.gamma_cleanJetsFailIdAll     ) 
        setattr(event,"gamma_cleanJetsFailId"        +self.cfg_ana.collectionPostFix, self.gamma_cleanJetsFailId        ) 


        if self.cfg_comp.isMC:
            setattr(event,"deltaMetFromJetSmearing"+self.cfg_ana.collectionPostFix, self.deltaMetFromJetSmearing) 
            setattr(event,"cleanGenJets"           +self.cfg_ana.collectionPostFix, self.cleanGenJets           )
            setattr(event,"genJets"                +self.cfg_ana.collectionPostFix, self.genJets                )
            if self.cfg_ana.do_mc_match:
                setattr(event,"bqObjects"              +self.cfg_ana.collectionPostFix, self.bqObjects              )
                setattr(event,"cqObjects"              +self.cfg_ana.collectionPostFix, self.cqObjects              )
                setattr(event,"partons"                +self.cfg_ana.collectionPostFix, self.partons                )
                setattr(event,"heaviestQCDFlavour"     +self.cfg_ana.collectionPostFix, self.heaviestQCDFlavour     )


        return True
Example #15
0
    def process(self, event):

        self.counters.counter('jets').inc('all events')
        self.readCollections(event.input)
        miniaodjets = self.handles['jets'].product()

        allJets = []

        to_clean_against = []
        if hasattr(self.cfg_ana, 'toClean'):
            for collection in self.cfg_ana.toClean:
                to_clean_against += getattr(event, collection)

        genJets = None
        if self.cfg_comp.isMC:
            genJets = map(GenJet, self.mchandles['genJets'].product())

        allJets = [Jet(jet) for jet in miniaodjets]

        if self.recalibrateJets:
            self.jetReCalibrator.correctAll(allJets,
                                            event.rho,
                                            delta=0.,
                                            addCorr=True,
                                            addShifts=True)

        for jet in allJets:
            if genJets:
                # Use DeltaR = 0.25 matching like JetMET
                pairs = matchObjectCollection([jet], genJets, 0.25 * 0.25)
                if pairs[jet] is None:
                    pass
                else:
                    jet.matchedGenJet = pairs[jet]
            # Add JER correction for MC jets. Requires gen-jet matching.
            if self.cfg_comp.isMC and hasattr(
                    self.cfg_ana, 'jerCorr') and self.cfg_ana.jerCorr:
                self.jerCorrection(jet)
            # Add JES correction for MC jets.
            if self.cfg_comp.isMC and hasattr(self.cfg_ana, 'jesCorr'):
                self.jesCorrection(jet, self.cfg_ana.jesCorr)
            jet.btagMVA = jet.btag(
                'pfCombinedInclusiveSecondaryVertexV2BJetTags'
            )  #TODO switch to deepCSV
            jet.btagged = self.btagSF.isBTagged(
                pt=jet.pt(),
                eta=jet.eta(),
                csv=jet.btag("pfCombinedInclusiveSecondaryVertexV2BJetTags"),
                jetflavor=abs(jet.hadronFlavour()),
                is_data=not self.cfg_comp.isMC,
                csv_cut=
                0.800  #CSVM from https://twiki.cern.ch/twiki/bin/viewauth/CMS/BtagRecommendation80X
            )
            ## if self.testJet(jet):
            ## 	event.jets.append(jet)
            ## if self.testBJet(jet):
            ## 	event.bJets.append(jet)

        allJets = [
            jet for jet in allJets if bool(jet.jetID("POG_PFID_Loose"))
            if jet.pt() > 20. if abs(jet.eta()) < 2.4
        ]
        if len(allJets) < 2: return False
        self.counters.counter('jets').inc('at least 2 good jets')

        event.jets, dummy = cleanObjectCollection(allJets,
                                                  masks=to_clean_against,
                                                  deltaRMin=0.5)
        if len(event.jets) < 2: return False
        self.counters.counter('jets').inc('at least 2 clean jets')

        event.bJets = [jet for jet in event.jets if jet.btagged]
        if len(event.bJets) != 2: return False
        self.counters.counter('jets').inc('exactly 2 b jets')

        # save HTs
        event.HT_jets = sum([jet.pt() for jet in event.jets])
        event.HT_bJets = sum([jet.pt() for jet in event.bJets])

        return True
Example #16
0
    def scaleDiLep(self, diLep):

        if hasattr(diLep, 'daughter(0)') and \
           hasattr(diLep, 'daughter(1)'):
            taus = [diLep.daughter(0), diLep.daughter(1)]
        else:
            taus = [diLep.leg1(), diLep.leg2()]
        jets = [Jet(jet) for jet in self.handles['jets'].product()]
        pfmet = self.handles['pfMET'].product()[0]
        puppimet = self.handles['puppiMET'].product()[0]
        if hasattr(diLep, 'daughter(2)'):
            met = diLep.daughter(2)
        else:
            met = diLep.met()

        pairs = matchObjectCollection(taus, jets, 0.5 * 0.5)

        # associating a jet to each tau
        for tau in taus:
            jet = pairs[tau]
            if jet is None:
                pass
            else:
                tau.jet = jet

        tau_p4_scale = 1.

        for tau in taus:
            if tau.decayMode() in (0, 1, 10) and hasattr(tau, 'jet'):

                TauIsolationCalculator.tauIsoBreakdown(tau)

                self.variables['tau_pt'][0] = tau.pt()
                self.variables['tau_eta'][0] = tau.eta()
                self.variables['tau_mass'][0] = tau.mass()
                self.variables['tau_decayMode'][0] = tau.decayMode()

                self.variables['tau_charged_iso'][0] = tau.chargedPtSumIso
                self.variables['tau_gamma_iso'][0] = tau.gammaPtSumIso
                self.variables['tau_charged_sig'][0] = tau.chargedPtSumSignal
                self.variables['tau_gamma_sig'][0] = tau.gammaPtSumSignal

                self.variables['tau_jet_pt'][0] = tau.jet.pt()
                self.variables['tau_jet_mass'][0] = tau.jet.mass()
                self.variables['tau_jet_nConstituents'][
                    0] = tau.jet.nConstituents()
                self.variables['tau_jet_rawFactor'][0] = tau.jet.rawFactor()
                self.variables['tau_jet_chargedHadronEnergy'][
                    0] = tau.jet.chargedHadronEnergy()
                self.variables['tau_jet_neutralHadronEnergy'][
                    0] = tau.jet.neutralHadronEnergy()
                self.variables['tau_jet_neutralEmEnergy'][
                    0] = tau.jet.neutralEmEnergy()
                self.variables['tau_jet_chargedEmEnergy'][
                    0] = tau.jet.chargedEmEnergy()

                calibrated_tau_pt = self.reader.EvaluateRegression('BDTG')[0]
                tau_p4_scale = calibrated_tau_pt / tau.pt()

                pfmetP4 = pfmet.p4()
                puppimetP4 = puppimet.p4()
                metP4 = met.p4()

                # remove pre-calibrated tau from met computation
                pfmetP4 += tau.p4()
                puppimetP4 += tau.p4()
                metP4 += tau.p4()

                self.scaleP4(tau, tau_p4_scale)
                tau.ptScale = tau_p4_scale

                # include calibrated tau into the met computation
                pfmetP4 -= tau.p4()
                puppimetP4 -= tau.p4()
                metP4 -= tau.p4()

                pfmet.setP4(pfmetP4)
                puppimet.setP4(puppimetP4)
                met.setP4(metP4)

        return True
Example #17
0
    def process(self, event):

        self.readCollections(event.input)
        
        # create Heppy Jet objects
        allJets = map(Jet, self.handles['jets'].product())

        # create intially empty jet collections
        event.jets  = []
        event.bJets = []
        event.cleanJets   = OrderedDict()
        event.cleanJets30 = OrderedDict()
        event.cleanBJets  = OrderedDict()
        
        # selected leptons as defined in the analyzer prior to this
        leptons = getattr(event, 'selectedLeptons', [])

        genJets = None
        if self.cfg_comp.isMC:
            genJets = map(GenJet, self.mchandles['genJets'].product())
            
        # recalibrate jets
        if self.recalibrateJets:
            self.jetReCalibrator.correctAll(allJets, event.rho, delta=0., metShift=[0.,0.], addCorr=True, addShifts=True)

        # fill the various jet collections and
        # possibly correct jets (if configured to do so)
        for jet in allJets:
            if genJets:
                # Use DeltaR = 0.25 matching like JetMET
                pairs = matchObjectCollection([jet], genJets, 0.25 * 0.25)
                if pairs[jet] is None:
                    pass
                else:
                    jet.matchedGenJet = pairs[jet]
                    
            # Add JER/JES correction for MC jets. Requires gen-jet matching.
            # Add JES correction for MC jets.
            if self.cfg_comp.isMC and hasattr(self.cfg_ana, 'jerCorr') and self.cfg_ana.jerCorr: self.jerCorrection(jet)
            if self.cfg_comp.isMC and hasattr(self.cfg_ana, 'jesCorr')                         : self.jesCorrection(jet, self.cfg_ana.jesCorr)
            
            # preselect jets
            if self.testJet(jet) : event.jets.append(jet)
            
            # compute deepjet scores only once
            self._prepareDeepJet(jet, year=self.cfg_ana.year, wp=getattr(self.cfg_ana, 'btag_wp', 'medium'))

            # create collection of bjets
            if self.testBJet(jet, 
                             year=self.cfg_ana.year, 
                             wp=getattr(self.cfg_ana, 'btag_wp', 'medium'), 
                             final_state='tot'): 
                event.bJets.append(jet)

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

        for final_state in ['mmm', 'mem', 'eee', 'eem']:
            
            if final_state not in leptons.keys():
                continue

            # RM: found out that there's not a lot of final state dependency,
            #     so we'll use the inclusive measurement that has better stats
            # preselect jets, with the appropriate btag SF correction **final state dependent**!
            # event.bJets = []
            # for jet in event.jets:
            #     if self.testBJet(jet, 
            #                      year=self.cfg_ana.year, 
            #                      wp=getattr(self.cfg_ana, 'btag_wp', 'medium'), 
            #                      final_state=final_state): 
            #         event.bJets.append(jet)
                        
            # clean jets from selected leptons (per final state!)
            event.cleanJets [final_state], dummy = cleanObjectCollection(event.jets , masks=leptons[final_state], deltaRMin=0.5)
            event.cleanBJets[final_state], dummy = cleanObjectCollection(event.bJets, masks=leptons[final_state], deltaRMin=0.5)

            pairs = matchObjectCollection(leptons[final_state], allJets, 0.5 * 0.5)
            # associating a jet to each lepton
            for lepton in leptons[final_state]:
                jet = pairs[lepton]
                if jet is None:
                    lepton.jet = lepton
                else:
                    lepton.jet = jet

            # associating to each (clean) jet the lepton that's closest to it
            invpairs = matchObjectCollection(event.cleanJets[final_state], leptons[final_state], 99999.)
            for jet in event.cleanJets[final_state]:
                leg = invpairs[jet]
                jet.leg = leg

            for jet in event.cleanJets[final_state]:
                jet.matchGenParton = 999.0

            event.jets30                   = [jet for jet in event.jets                   if jet.pt() > 30]
            event.cleanJets30[final_state] = [jet for jet in event.cleanJets[final_state] if jet.pt() > 30]
                                    
        return True
Example #18
0
    def process(self, event):
        #get all the gen-jet
        event.gen_jet = map(lambda p: Particle.from_obj(p, 0), event.GenJet)
        event.gen_jet = filter(lambda x, conf=conf: x.p4().Pt() > conf["jets"][
            "pt"] and abs(x.p4().Eta()) < conf["jets"]["eta"],
                               event.gen_jet)

        #match b-quarks to gen-jets by deltaR
        matches = matchObjectCollection(event.b_hadrons_sorted, event.gen_jet,
                                        0.3)

        #find jets matched to b-quarks
        event.matched_b_jets = []
        for p in event.b_hadrons_sorted:
            if matches.has_key(p) and matches[p] != None:
                jet = matches[p]
                jet.source = p.source
                event.matched_b_jets += [jet]
                self.logger.debug(
                    "quark pt={0}, id={1} (from {2}) matched to jet pt={3}, id={4}"
                    .format(p.p4().Pt(), p.pdg_id(), p.source,
                            matches[p].p4().Pt(), matches[p].pdg_id()))
            else:
                self.logger.debug(
                    "b-quark with pt={0:.2f} not matched to gen-jet".format(
                        p.p4().Pt()))

        #find jets matched to light quarks
        matches = matchObjectCollection(event.gen_q_w, event.gen_jet, 0.3)
        event.matched_q_jets = []
        for p in event.gen_q_w:
            if matches.has_key(p) and matches[p] != None:
                jet = matches[p]
                jet.source = p.source
                event.matched_q_jets += [jet]
                self.logger.debug(
                    "light quark pt={0}, id={1} matched to jet pt={2}, id={3}".
                    format(p.p4().Pt(), p.pdg_id(), matches[p].p4().Pt(),
                           matches[p].pdg_id()))

        #find unmatched jets
        event.unmatched_jets = []
        for jet in event.gen_jet:
            if jet not in event.matched_b_jets and jet not in event.matched_q_jets:
                event.unmatched_jets += [jet]

        #count number of jets matched to quarks from certain origin
        match_count = {
            "t": 0,
            "h": 0,
            "w": 0,
            "other": 0,
        }
        for jet in event.matched_b_jets + event.matched_q_jets:
            match_count[jet.source] += 1
        event.match_count = match_count
        self.logger.info(
            "process: matched_b_jets={0} matched_q_jets={0}".format(
                len(event.matched_b_jets), len(event.matched_q_jets)))

        #Creates a jet-level representation
        event.repr_matched_jets = EventRepresentation(
            b_quarks=event.matched_b_jets[:4],
            l_quarks=event.matched_q_jets[:2],
            leptons=event.gen_lep,
            invisible=event.gen_met,
        )

        event.repr_matched_jets_smeared = copy.deepcopy(event.repr_quarks)
        event.repr_matched_jets_smeared.smear_quarks()

        event.interpretations[
            "gen_jet_matched_2w2h2t"] = event.repr_matched_jets.make_interpretation(
                "2w2h2t", self.conf, "sl_2w2h2t")
        event.interpretations[
            "gen_jet_matched_2w2h2t_smeared"] = event.repr_matched_jets_smeared.make_interpretation(
                "2w2h2t", self.conf, "sl_2w2h2t")

        #event.interpretations["gen_b_q_jet_flavour"] = event.repr_matched_jets_flavour.make_interpretation("2w2h2t", self.conf, "sl_2w2h2t")
        return True
Example #19
0
    def process(self, event):
        event.gen_b_h = map(lambda p: Particle.from_obj(p, 25),
                            event.GenBQuarkFromH)
        event.gen_b_t = map(lambda p: Particle.from_obj(p, 6),
                            event.GenBQuarkFromTop)
        event.gen_b_others = map(lambda p: Particle.from_obj(p, 0),
                                 event.GenStatus2bHad)
        event.gen_q_w = map(lambda p: Particle.from_obj(p, 24),
                            event.GenWZQuark)
        event.gen_lep = map(lambda p: Particle.from_obj(p, 6),
                            event.GenLepFromTop)
        event.gen_lep = filter(lambda x, conf=self.conf: x.p4().Pt() > conf[
            "leptons"]["pt"] and abs(x.p4().Eta()) < conf["leptons"]["eta"],
                               event.gen_lep)
        event.gen_nu = map(lambda p: Particle.from_obj(p, 6),
                           event.GenNuFromTop)
        event.gen_met = sum([p.p4() for p in event.gen_nu],
                            ROOT.TLorentzVector())
        self.logger.info(
            "process "
            "nGenBother={0} nGenBH={1} nGenBt={2} nGenLep={3}".format(
                len(event.gen_b_others), len(event.gen_b_h),
                len(event.gen_b_t), len(event.gen_lep)))
        event.interpretations = {}

        ###
        ### b-quarks
        ###
        for q in event.gen_b_h:
            q.source = "h"
        for q in event.gen_b_t:
            q.source = "t"
        for q in event.gen_q_w:
            q.source = "w"
        b_hadrons = event.gen_b_h + event.gen_b_t
        self.logger.debug("b from h: {0}".format(map(str, event.gen_b_h)))
        self.logger.debug("b from t: {0}".format(map(str, event.gen_b_t)))

        #Find b-hadrons in additional set that are not matched to existing higgs or top
        #derived b-hadrons
        additional_b_hadrons = []
        for bhad in event.gen_b_others:
            matches = matchObjectCollection(event.gen_b_others, b_hadrons, 0.3)
            if not matches.has_key(bhad) or matches[bhad] is None:
                self.logger.debug("no match for pt={0}, adding".format(
                    bhad.p4().Pt()))
                bhad.source = "other"
                b_hadrons += [bhad]
                additional_b_hadrons += [bhad]
        self.logger.debug("b from other: {0}".format(
            map(str, additional_b_hadrons)))

        event.gen_b_others_cleaned = additional_b_hadrons

        #Apply kinematic cuts and sort by pt
        event.b_hadrons_sorted = sorted(b_hadrons,
                                        key=lambda x: x.p4().Pt(),
                                        reverse=True)
        event.b_hadrons_sorted = filter(
            lambda x: x.p4().Pt() > self.conf["jets"]["pt"],
            event.b_hadrons_sorted)
        event.b_hadrons_sorted = filter(
            lambda x: abs(x.p4().Eta()) < self.conf["jets"]["eta"],
            event.b_hadrons_sorted)
        event.b_hadrons_sorted = event.b_hadrons_sorted

        #create a quark-level representation
        event.repr_quarks = EventRepresentation(
            b_quarks=event.b_hadrons_sorted[:4],
            l_quarks=event.gen_q_w[:2],
            leptons=event.gen_lep,
            invisible=event.gen_met,
        )

        event.repr_quarks_smeared = copy.deepcopy(event.repr_quarks)
        event.repr_quarks_smeared.smear_quarks()

        event.interpretations[
            "gen_quark_2w2h2t"] = event.repr_quarks.make_interpretation(
                "2w2h2t", self.conf, "sl_2w2h2t")
        event.interpretations[
            "gen_quark_2w2h2t_smeared"] = event.repr_quarks_smeared.make_interpretation(
                "2w2h2t", self.conf, "sl_2w2h2t")

        #create the 022 and 222 interpretations on the quark level
        #event.interpretations["gen_b_quark"] = event.repr_quarks.make_interpretation("0w2h2t", self.conf, "sl_0w2h2t")
        #event.interpretations["gen_b_q_quark"] = event.repr_quarks.make_interpretation("2w2h2t", self.conf, "sl_2w2h2t")
        return True
    def process(self, event):
        event.gen_b_h = map(lambda p: Particle.from_obj(p, 25), event.GenBQuarkFromH)
        event.gen_b_t = map(lambda p: Particle.from_obj(p, 6), event.GenBQuarkFromTop)
        event.gen_b_others = map(lambda p: Particle.from_obj(p, 0), event.GenStatus2bHad)
        event.gen_q_w = map(lambda p: Particle.from_obj(p, 24), event.GenWZQuark)
        event.gen_lep = map(lambda p: Particle.from_obj(p, 6), event.GenLepFromTop)
        event.gen_lep = filter(
            lambda x, conf=self.conf: x.p4().Pt() > conf["leptons"]["pt"] and abs(x.p4().Eta()) < conf["leptons"]["eta"],
            event.gen_lep
        )
        event.gen_nu = map(lambda p: Particle.from_obj(p, 6), event.GenNuFromTop)
        event.gen_met = sum([p.p4() for p in event.gen_nu], ROOT.TLorentzVector())
        self.logger.info("process "
            "nGenBother={0} nGenBH={1} nGenBt={2} nGenLep={3}".format(
                len(event.gen_b_others), len(event.gen_b_h), len(event.gen_b_t), len(event.gen_lep)
            )
        )
        event.interpretations = {}

        ###
        ### b-quarks
        ###
        for q in event.gen_b_h:
            q.source = "h"
        for q in event.gen_b_t:
            q.source = "t"
        for q in event.gen_q_w:
            q.source = "w"
        b_hadrons = event.gen_b_h + event.gen_b_t
        self.logger.debug("b from h: {0}".format(map(str, event.gen_b_h)))
        self.logger.debug("b from t: {0}".format(map(str, event.gen_b_t)))

        #Find b-hadrons in additional set that are not matched to existing higgs or top
        #derived b-hadrons
        additional_b_hadrons = []
        for bhad in event.gen_b_others:
            matches = matchObjectCollection(event.gen_b_others, b_hadrons, 0.3)
            if not matches.has_key(bhad) or matches[bhad] is None:
                self.logger.debug("no match for pt={0}, adding".format(bhad.p4().Pt()))
                bhad.source = "other"
                b_hadrons += [bhad]
                additional_b_hadrons += [bhad]
        self.logger.debug("b from other: {0}".format(map(str, additional_b_hadrons)))

        event.gen_b_others_cleaned = additional_b_hadrons

        #Apply kinematic cuts and sort by pt
        event.b_hadrons_sorted = sorted(b_hadrons, key=lambda x: x.p4().Pt(), reverse=True)
        event.b_hadrons_sorted = filter(lambda x: x.p4().Pt() > self.conf["jets"]["pt"], event.b_hadrons_sorted)
        event.b_hadrons_sorted = filter(lambda x: abs(x.p4().Eta()) < self.conf["jets"]["eta"], event.b_hadrons_sorted)
        event.b_hadrons_sorted = event.b_hadrons_sorted

        #create a quark-level representation
        event.repr_quarks = EventRepresentation(
            b_quarks = event.b_hadrons_sorted[:4],
            l_quarks = event.gen_q_w[:2],
            leptons = event.gen_lep,
            invisible = event.gen_met,
        )

        event.repr_quarks_smeared = copy.deepcopy(event.repr_quarks)
        event.repr_quarks_smeared.smear_quarks()


        event.interpretations["gen_quark_2w2h2t"] = event.repr_quarks.make_interpretation("2w2h2t", self.conf, "sl_2w2h2t")
        event.interpretations["gen_quark_2w2h2t_smeared"] = event.repr_quarks_smeared.make_interpretation("2w2h2t", self.conf, "sl_2w2h2t")

        #create the 022 and 222 interpretations on the quark level
        #event.interpretations["gen_b_quark"] = event.repr_quarks.make_interpretation("0w2h2t", self.conf, "sl_0w2h2t")
        #event.interpretations["gen_b_q_quark"] = event.repr_quarks.make_interpretation("2w2h2t", self.conf, "sl_2w2h2t")
        return True
Example #21
0
        print "   total pt from short neut.(K0S) , pt > 1: %7.2f" % sum(d.pt() for d in j.daus() if d.charge() == 0 and d.pdgId() in (310,) and d.pt() > 1)
        print "   total pt from other neutrals   , pt > 1: %7.2f" % sum(d.pt() for d in j.daus() if d.charge() == 0 and d.pdgId() not in (22,130,2112,-2112,310) and d.pt() > 1)
        print ""
        
        c_tomatch = [g for g in j.daus() if g.charge() != 0 and g.pt() > 1]
        n_tomatch = [g for g in j.daus() if g.charge() == 0 and g.pt() > 1]
        a_tomatch = c_tomatch + n_tomatch

        tk2tk = matchObjectCollection3(events_new[key]["tracks"], events_ref[key]["tracks"], 0.07, lambda d,g: d.charge() == g.charge() and abs(d.pt()-g.pt())/(d.pt()+g.pt()) < 0.2)
        pf2pf = matchObjectCollection3(events_new[key]["pf"], events_ref[key]["pf"], 0.07, lambda d,g: abs(d.pt()-g.pt())/(d.pt()+g.pt()) < 0.6)
        pfb2pfb = matchObjectCollection3(events_new[key]["pfblock"], events_ref[key]["pfblock"], 0.07, lambda d,g: abs(d.pt()-g.pt())/(d.pt()+g.pt()) < 0.6)
        gsf2gsf = matchObjectCollection3(events_new[key]["gsfE"], events_ref[key]["gsfE"], 0.07, lambda d,g: abs(d.pt()-g.pt())/(d.pt()+g.pt()) < 0.6)
        #calt2calt = matchObjectCollection3(events_new[key]["caloT"], events_ref[key]["caloT"], 0.1)
        pf2tk_ref = matchObjectCollection3(events_ref[key]["pf"], events_ref[key]["tracks"], 0.07, lambda d,g: d.charge() == g.charge() and abs(d.pt()-g.pt())/(d.pt()+g.pt()) < 0.6)
        pf2tk_new = matchObjectCollection3(events_new[key]["pf"], events_new[key]["tracks"], 0.07, lambda d,g: d.charge() == g.charge() and abs(d.pt()-g.pt())/(d.pt()+g.pt()) < 0.6)
        pfb2tk_ref = matchObjectCollection(events_ref[key]["pfblock"], events_ref[key]["tracks"], 0.07, lambda d,g: d.charge() == g.charge() and abs(d.pt()-g.pt())/(d.pt()+g.pt()) < 0.6)
        pf2pfb_ref = matchObjectCollection(events_ref[key]["pf"], events_ref[key]["pfblock"], 0.07, lambda d,g: d.charge() == g.charge() and abs(d.pt()-g.pt())/(d.pt()+g.pt()) < 0.6)
        pfb2tk_new = matchObjectCollection(events_new[key]["pfblock"], events_new[key]["tracks"], 0.07, lambda d,g: d.charge() == g.charge() and abs(d.pt()-g.pt())/(d.pt()+g.pt()) < 0.6)
        pf2pfb_new = matchObjectCollection(events_new[key]["pf"], events_new[key]["pfblock"], 0.07, lambda d,g: d.charge() == g.charge() and abs(d.pt()-g.pt())/(d.pt()+g.pt()) < 0.6)
        mu2mu = matchObjectCollection3(events_new[key]["mu"], events_ref[key]["mu"], 0.07, lambda d,g: d.charge() == g.charge() and abs(d.pt()-g.pt())/(d.pt()+g.pt()) < 0.2)
        mu2tk_ref = matchObjectCollection3(events_ref[key]["mu"], events_ref[key]["tracks"], 0.07, lambda d,g: d.charge() == g.charge() and abs(d.pt()-g.pt())/(d.pt()+g.pt()) < 0.2)
        mu2tk_new = matchObjectCollection3(events_new[key]["mu"], events_new[key]["tracks"], 0.07, lambda d,g: d.charge() == g.charge() and abs(d.pt()-g.pt())/(d.pt()+g.pt()) < 0.2)
        layers = [
                ('tk_ref', events_ref[key]["tracks"], []),
                ('tk_new', events_new[key]["tracks"], [tk2tk]), 
                ('ecal_ref', events_ref[key]["ecal"], []), 
                ('ecal_new', events_new[key]["ecal"], []),
                ('pfb_ref', events_ref[key]["pfblock"], [pfb2tk_ref]), 
                ('pfb_new', events_new[key]["pfblock"], [pfb2tk_new,pfb2pfb]), 
                ('pf_ref', events_ref[key]["pf"], [pf2tk_ref,pf2pfb_ref]), 
                ('pf_new', events_new[key]["pf"], [pf2tk_new,pf2pfb_new,pf2pf]),
Example #22
0
    def process(self, event):

        self.readCollections(event.input)
        miniaodjets = self.handles['jets'].product()

        allJets = []
        event.jets = []
        event.bJets = []
        event.cleanJets = []
        event.cleanBJets = []

        leptons = []
        if hasattr(event, 'selectedLeptons'):
            leptons = event.selectedLeptons

        genJets = None
        if self.cfg_comp.isMC:
            genJets = map(GenJet, self.mchandles['genJets'].product())

        for maodjet in miniaodjets:
            jet = Jet(maodjet)
            allJets.append(jet)
            if self.cfg_comp.isMC and hasattr(self.cfg_comp, 'jetScale'):
                scale = random.gauss(self.cfg_comp.jetScale,
                                     self.cfg_comp.jetSmear)
                jet.scaleEnergy(scale)
            if genJets:
                # Use DeltaR = 0.25 matching like JetMET
                pairs = matchObjectCollection([jet], genJets, 0.25 * 0.25)
                if pairs[jet] is None:
                    pass
                else:
                    jet.matchedGenJet = pairs[jet]
            #Add JER correction for MC jets. Requires gen-jet matching.
            if self.cfg_comp.isMC and hasattr(
                    self.cfg_ana, 'jerCorr') and self.cfg_ana.jerCorr:
                self.jerCorrection(jet)
            #Add JES correction for MC jets.
            if self.cfg_comp.isMC and hasattr(self.cfg_ana, 'jesCorr'):
                self.jesCorrection(jet, self.cfg_ana.jesCorr)
            if self.testJet(jet):
                event.jets.append(jet)
            if self.testBJet(jet):
                event.bJets.append(jet)

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

        event.cleanJets, dummy = cleanObjectCollection(event.jets,
                                                       masks=leptons,
                                                       deltaRMin=0.5)
        event.cleanBJets, dummy = cleanObjectCollection(event.bJets,
                                                        masks=leptons,
                                                        deltaRMin=0.5)

        pairs = matchObjectCollection(leptons, allJets, 0.5 * 0.5)
        # associating a jet to each lepton
        for lepton in leptons:
            jet = pairs[lepton]
            if jet is None:
                lepton.jet = lepton
            else:
                lepton.jet = jet

        # associating a leg to each clean jet
        invpairs = matchObjectCollection(event.cleanJets, leptons, 99999.)
        for jet in event.cleanJets:
            leg = invpairs[jet]
            jet.leg = leg

        for jet in event.cleanJets:
            jet.matchGenParton = 999.0

        if self.cfg_comp.isMC and "BB" in self.cfg_comp.name:
            genParticles = self.mchandles['genParticles'].product()
            event.genParticles = map(GenParticle, genParticles)
            for gen in genParticles:
                if abs(gen.pdgId()) == 5 and gen.mother() and abs(
                        gen.mother().pdgId()) == 21:
                    for jet in event.cleanJets:
                        dR = deltaR2(jet.eta(), jet.phi(), gen.eta(),
                                     gen.phi())
                        if dR < jet.matchGenParton:
                            jet.matchGenParton = dR

        event.jets30 = [jet for jet in event.jets if jet.pt() > 30]
        event.cleanJets30 = [jet for jet in event.cleanJets if jet.pt() > 30]
        if len(event.jets30) >= 2:
            self.counters.counter('jets').inc('at least 2 good jets')
        if len(event.cleanJets30) >= 2:
            self.counters.counter('jets').inc('at least 2 clean jets')
        if len(event.cleanBJets) > 0:
            self.counters.counter('jets').inc('at least 1 b jet')
            if len(event.cleanBJets) > 1:
                self.counters.counter('jets').inc('at least 2 b jets')
        return True
Example #23
0
    def process(self, event):
        '''
        '''

        self.readCollections(event.input)

        taus     = [Tau(tau) for tau in self.handles['taus'].product()]
        jets     = [Jet(jet) for jet in self.handles['jets'].product()]
        pfmet    = self.handles['pfMET'   ].product()[0]
        puppimet = self.handles['puppiMET'].product()[0]
        
        pairs = matchObjectCollection(taus, jets, 0.5 * 0.5)
        
#         import pdb ; pdb.set_trace()
        
        # associating a jet to each lepton
        for tau in taus:
            jet = pairs[tau]
            if jet is None:
                pass
            else:
                tau.jet = jet

        event.calibratedTaus = []
        
        for tau in taus:

            tau.associatedVertex = event.goodVertices[0]

            tau_p4_scale = 1.
            
            if tau.decayMode() in (0, 1, 10) and hasattr(tau, 'jet'):

                self.tauIsoBreakdown(tau)

                self.variables['tau_pt'                     ][0] = tau.pt()               
                self.variables['tau_eta'                    ][0] = tau.eta()              
                self.variables['tau_mass'                   ][0] = tau.mass()             
                self.variables['tau_decayMode'              ][0] = tau.decayMode()        

                self.variables['tau_charged_iso'            ][0] = tau.chargedPtSumIso    
                self.variables['tau_gamma_iso'              ][0] = tau.gammaPtSumIso      
                self.variables['tau_charged_sig'            ][0] = tau.chargedPtSumSignal 
                self.variables['tau_gamma_sig'              ][0] = tau.gammaPtSumSignal   

                self.variables['tau_jet_pt'                 ][0] = tau.jet.pt()           
                self.variables['tau_jet_mass'               ][0] = tau.jet.mass()         
                self.variables['tau_jet_nConstituents'      ][0] = tau.jet.nConstituents()
                self.variables['tau_jet_rawFactor'          ][0] = tau.jet.rawFactor()
                self.variables['tau_jet_chargedHadronEnergy'][0] = tau.jet.chargedHadronEnergy()      
                self.variables['tau_jet_neutralHadronEnergy'][0] = tau.jet.neutralHadronEnergy()      
                self.variables['tau_jet_neutralEmEnergy'    ][0] = tau.jet.neutralEmEnergy()    
                self.variables['tau_jet_chargedEmEnergy'    ][0] = tau.jet.chargedEmEnergy()          

                calibrated_tau_pt = self.reader.EvaluateRegression('BDTG')[0]
                tau_p4_scale = calibrated_tau_pt / tau.pt()

                pfmetP4    = pfmet   .p4()
                puppimetP4 = puppimet.p4()

                # remove pre-calibrated tau from met computation
                pfmetP4    += tau.p4()
                puppimetP4 += tau.p4()
                
                self.scaleP4(tau, tau_p4_scale)
                tau.ptScale = tau_p4_scale

                # include calibrated tau into the met computation
                pfmetP4    -= tau.p4()
                puppimetP4 -= tau.p4()
            
                pfmet   .setP4(pfmetP4   )
                puppimet.setP4(puppimetP4)
            
            event.calibratedTaus.append(tau)
        
        event.calibratedPfMet    = pfmet
        event.calibratedPuppiMet = puppimet

        return True
Example #24
0
    def process(self, event):
        self.readCollections(event.input)
        rho = float(self.handles['rho'].product()[0])
        self.rho = rho

        ## Read jets, if necessary recalibrate and shift MET
        if self.cfg_ana.copyJetsByValue:
            import ROOT
            allJets = map(
                lambda j: Jet(
                    ROOT.pat.Jet(
                        ROOT.edm.Ptr(ROOT.pat.Jet)
                        (ROOT.edm.ProductID(), j, 0))),
                self.handles['jets'].product(
                ))  #copy-by-value is safe if JetAnalyzer is ran more than once
        else:
            allJets = map(Jet, self.handles['jets'].product())

        self.deltaMetFromJEC = [0., 0.]
        self.type1METCorr = [0., 0., 0.]
        #        print "before. rho",self.rho,self.cfg_ana.collectionPostFix,'allJets len ',len(allJets),'pt', [j.pt() for j in allJets]
        if self.doJEC:
            if not self.recalibrateJets:  # check point that things won't change
                jetsBefore = [(j.pt(), j.eta(), j.phi(), j.rawFactor())
                              for j in allJets]
            self.jetReCalibrator.correctAll(allJets,
                                            rho,
                                            delta=self.shiftJEC,
                                            addCorr=True,
                                            addShifts=self.addJECShifts,
                                            metShift=self.deltaMetFromJEC,
                                            type1METCorr=self.type1METCorr)
            if not self.recalibrateJets:
                jetsAfter = [(j.pt(), j.eta(), j.phi(), j.rawFactor())
                             for j in allJets]
                if len(jetsBefore) != len(jetsAfter):
                    print "ERROR: I had to recompute jet corrections, and they rejected some of the jets:\nold = %s\n new = %s\n" % (
                        jetsBefore, jetsAfter)
                else:
                    for (told, tnew) in zip(jetsBefore, jetsAfter):
                        if (deltaR2(told[1], told[2], tnew[1],
                                    tnew[2])) > 0.0001:
                            print "ERROR: I had to recompute jet corrections, and one jet direction moved: old = %s, new = %s\n" % (
                                told, tnew)
                        elif abs(told[0] - tnew[0]) / (
                                told[0] + tnew[0]) > 0.5e-3 or abs(
                                    told[3] - tnew[3]) > 0.5e-3:
                            print "ERROR: I had to recompute jet corrections, and one jet pt or corr changed: old = %s, new = %s\n" % (
                                told, tnew)
        self.allJetsUsedForMET = allJets
        #        print "after. rho",self.rho,self.cfg_ana.collectionPostFix,'allJets len ',len(allJets),'pt', [j.pt() for j in allJets]

        if self.cfg_comp.isMC:
            self.genJets = [x for x in self.handles['genJet'].product()]
            if self.cfg_ana.do_mc_match:
                for igj, gj in enumerate(self.genJets):
                    gj.index = igj
                self.matchJets(event, allJets)
            if getattr(self.cfg_ana, 'smearJets', False):
                self.smearJets(event, allJets)

##Sort Jets by pT
        allJets.sort(key=lambda j: j.pt(), reverse=True)

        ## Apply jet selection
        self.jets = []
        self.jetsFailId = []
        self.jetsAllNoID = []
        self.jetsIdOnly = []
        for jet in allJets:
            if self.testJetNoID(jet):
                self.jetsAllNoID.append(jet)
                # temporary fix since the jetID it's not good for eta>3
                if self.testJetID(jet):
                    if (self.cfg_ana.doQG):
                        jet.qgl_calc = self.qglcalc.computeQGLikelihood
                        jet.qgl_rho = rho

                    self.jets.append(jet)
                    self.jetsIdOnly.append(jet)
                else:
                    self.jetsFailId.append(jet)
            elif self.testJetID(jet):
                self.jetsIdOnly.append(jet)

        ## Clean Jets from leptons
        leptons = []
        if hasattr(event, 'selectedLeptons'):
            leptons = [
                l for l in event.selectedLeptons
                if l.pt() > self.lepPtMin and self.lepSelCut(l)
            ]
        if self.cfg_ana.cleanJetsFromTaus and hasattr(event, 'selectedTaus'):
            leptons = leptons[:] + event.selectedTaus
        if self.cfg_ana.cleanJetsFromIsoTracks and hasattr(
                event, 'selectedIsoCleanTrack'):
            leptons = leptons[:] + event.selectedIsoCleanTrack

        jetsEtaCut = [
            j for j in self.jets if abs(j.eta()) < self.cfg_ana.jetEta
        ]
        self.cleanJetsAll, cleanLeptons = cleanJetsAndLeptons(
            jetsEtaCut, leptons, self.jetLepDR, self.jetLepArbitration)
        #self.cleanJetsAll, cleanLeptons = cleanJetsAndLeptons(self.jets, leptons, self.jetLepDR, self.jetLepArbitration) ##from central
        self.cleanJets = [
            j for j in self.cleanJetsAll
            if abs(j.eta()) < self.cfg_ana.jetEtaCentral
        ]
        self.cleanJetsFwd = [
            j for j in self.cleanJetsAll
            if abs(j.eta()) >= self.cfg_ana.jetEtaCentral
        ]
        self.discardedJets = [
            j for j in self.jets if j not in self.cleanJetsAll
        ]
        if hasattr(event,
                   'selectedLeptons') and self.cfg_ana.cleanSelectedLeptons:
            event.discardedLeptons = [
                l for l in leptons if l not in cleanLeptons
            ]
            event.selectedLeptons = [
                l for l in event.selectedLeptons
                if l not in event.discardedLeptons
            ]

        ## First cleaning, then Jet Id
        noIdJetsEtaCut = [
            j for j in self.jetsAllNoID if abs(j.eta()) < self.cfg_ana.jetEta
        ]
        self.noIdCleanJetsAll, cleanLeptons = cleanJetsAndLeptons(
            noIdJetsEtaCut, leptons, self.jetLepDR, self.jetLepArbitration)
        self.noIdCleanJets = [
            j for j in self.noIdCleanJetsAll
            if abs(j.eta()) < self.cfg_ana.jetEtaCentral
        ]
        self.noIdCleanJetsFwd = [
            j for j in self.noIdCleanJetsAll
            if abs(j.eta()) >= self.cfg_ana.jetEtaCentral
        ]
        self.noIdDiscardedJets = [
            j for j in self.jets if j not in self.noIdCleanJetsAll
        ]

        ## Clean Jets from photons (first cleaning, then Jet Id)
        photons = []
        if hasattr(event, 'selectedPhotons'):
            if self.cfg_ana.cleanJetsFromFirstPhoton:
                photons = event.selectedPhotons[:1]
            else:
                photons = [g for g in event.selectedPhotons]

        self.gamma_cleanJetsAll = cleanNearestJetOnly(self.cleanJetsAll,
                                                      photons, self.jetGammaDR)
        self.gamma_cleanJets = [
            j for j in self.gamma_cleanJetsAll
            if abs(j.eta()) < self.cfg_ana.jetEtaCentral
        ]
        self.gamma_cleanJetsFwd = [
            j for j in self.gamma_cleanJetsAll
            if abs(j.eta()) >= self.cfg_ana.jetEtaCentral
        ]
        self.gamma_noIdCleanJetsAll = cleanNearestJetOnly(
            self.noIdCleanJetsAll, photons, self.jetGammaDR)
        self.gamma_noIdCleanJets = [
            j for j in self.gamma_noIdCleanJetsAll
            if abs(j.eta()) < self.cfg_ana.jetEtaCentral
        ]
        self.gamma_noIdCleanJetsFwd = [
            j for j in self.gamma_noIdCleanJetsAll
            if abs(j.eta()) >= self.cfg_ana.jetEtaCentral
        ]
        ###

        if self.cfg_ana.alwaysCleanPhotons:
            self.cleanJets = self.gamma_cleanJets
            self.cleanJetsAll = self.gamma_cleanJetsAll
            self.cleanJetsFwd = self.gamma_cleanJetsFwd
            #
            self.noIdCleanJets = self.gamma_noIdCleanJets
            self.noIdCleanJetsAll = self.gamma_noIdCleanJetsAll
            self.noIdCleanJetsFwd = self.gamma_noIdCleanJetsFwd

        ## Jet Id, after jet/lepton cleaning
        self.cleanJetsFailIdAll = []
        for jet in self.noIdCleanJetsAll:
            if not self.testJetID(jet):
                self.cleanJetsFailIdAll.append(jet)

        self.cleanJetsFailId = [
            j for j in self.cleanJetsFailIdAll
            if abs(j.eta()) < self.cfg_ana.jetEtaCentral
        ]

        ## Jet Id, after jet/photon cleaning
        self.gamma_cleanJetsFailIdAll = []
        for jet in self.gamma_noIdCleanJetsAll:
            if not self.testJetID(jet):
                self.gamma_cleanJetsFailIdAll.append(jet)

        self.gamma_cleanJetsFailId = [
            j for j in self.gamma_cleanJetsFailIdAll
            if abs(j.eta()) < self.cfg_ana.jetEtaCentral
        ]

        ## Associate jets to leptons
        leptons = event.inclusiveLeptons if hasattr(
            event, 'inclusiveLeptons') else event.selectedLeptons
        jlpairs = matchObjectCollection(leptons, allJets, self.jetLepDR**2)

        for jet in allJets:
            jet.leptons = [l for l in jlpairs if jlpairs[l] == jet]

        for lep in leptons:
            jet = jlpairs[lep]
            if jet is None:
                setattr(lep, "jet" + self.cfg_ana.collectionPostFix, lep)
            else:
                setattr(lep, "jet" + self.cfg_ana.collectionPostFix, jet)
        ## Associate jets to taus
        taus = getattr(event, 'selectedTaus', [])
        jtaupairs = matchObjectCollection(taus, allJets, self.jetLepDR**2)

        for jet in allJets:
            jet.taus = [l for l in jtaupairs if jtaupairs[l] == jet]
        for tau in taus:
            setattr(tau, "jet" + self.cfg_ana.collectionPostFix,
                    jtaupairs[tau])

        #MC stuff
        if self.cfg_comp.isMC:
            self.deltaMetFromJetSmearing = [0, 0]
            for j in self.cleanJetsAll:
                if hasattr(j, 'deltaMetFromJetSmearing'):
                    self.deltaMetFromJetSmearing[
                        0] += j.deltaMetFromJetSmearing[0]
                    self.deltaMetFromJetSmearing[
                        1] += j.deltaMetFromJetSmearing[1]

            self.cleanGenJets = cleanNearestJetOnly(self.genJets, leptons,
                                                    self.jetLepDR)

            if self.cfg_ana.cleanGenJetsFromPhoton:
                self.cleanGenJets = cleanNearestJetOnly(
                    self.cleanGenJets, photons, self.jetLepDR)

            #event.nGenJets25 = 0
            #event.nGenJets25Cen = 0
            #event.nGenJets25Fwd = 0
            #for j in event.cleanGenJets:
            #    event.nGenJets25 += 1
            #    if abs(j.eta()) <= 2.4: event.nGenJets25Cen += 1
            #    else:                   event.nGenJets25Fwd += 1

            if self.cfg_ana.do_mc_match:
                self.jetFlavour(event)

        if hasattr(event, "jets" + self.cfg_ana.collectionPostFix):
            raise RuntimeError, "Event already contains a jet collection with the following postfix: " + self.cfg_ana.collectionPostFix
        setattr(event, "rho" + self.cfg_ana.collectionPostFix, self.rho)
        setattr(event, "deltaMetFromJEC" + self.cfg_ana.collectionPostFix,
                self.deltaMetFromJEC)
        setattr(event, "type1METCorr" + self.cfg_ana.collectionPostFix,
                self.type1METCorr)
        setattr(event, "allJetsUsedForMET" + self.cfg_ana.collectionPostFix,
                self.allJetsUsedForMET)
        setattr(event, "jets" + self.cfg_ana.collectionPostFix, self.jets)
        setattr(event, "jetsFailId" + self.cfg_ana.collectionPostFix,
                self.jetsFailId)
        setattr(event, "jetsAllNoID" + self.cfg_ana.collectionPostFix,
                self.jetsAllNoID)
        setattr(event, "jetsIdOnly" + self.cfg_ana.collectionPostFix,
                self.jetsIdOnly)
        setattr(event, "cleanJetsAll" + self.cfg_ana.collectionPostFix,
                self.cleanJetsAll)
        setattr(event, "cleanJets" + self.cfg_ana.collectionPostFix,
                self.cleanJets)
        setattr(event, "cleanJetsFwd" + self.cfg_ana.collectionPostFix,
                self.cleanJetsFwd)
        setattr(event, "cleanJetsFailIdAll" + self.cfg_ana.collectionPostFix,
                self.cleanJetsFailIdAll)
        setattr(event, "cleanJetsFailId" + self.cfg_ana.collectionPostFix,
                self.cleanJetsFailId)
        setattr(event, "discardedJets" + self.cfg_ana.collectionPostFix,
                self.discardedJets)
        setattr(event, "gamma_cleanJetsAll" + self.cfg_ana.collectionPostFix,
                self.gamma_cleanJetsAll)
        setattr(event, "gamma_cleanJets" + self.cfg_ana.collectionPostFix,
                self.gamma_cleanJets)
        setattr(event, "gamma_cleanJetsFwd" + self.cfg_ana.collectionPostFix,
                self.gamma_cleanJetsFwd)
        setattr(event,
                "gamma_cleanJetsFailIdAll" + self.cfg_ana.collectionPostFix,
                self.gamma_cleanJetsFailIdAll)
        setattr(event,
                "gamma_cleanJetsFailId" + self.cfg_ana.collectionPostFix,
                self.gamma_cleanJetsFailId)

        if self.cfg_comp.isMC:
            setattr(event,
                    "deltaMetFromJetSmearing" + self.cfg_ana.collectionPostFix,
                    self.deltaMetFromJetSmearing)
            setattr(event, "cleanGenJets" + self.cfg_ana.collectionPostFix,
                    self.cleanGenJets)
            setattr(event, "genJets" + self.cfg_ana.collectionPostFix,
                    self.genJets)
            if self.cfg_ana.do_mc_match:
                setattr(event, "bqObjects" + self.cfg_ana.collectionPostFix,
                        self.bqObjects)
                setattr(event, "cqObjects" + self.cfg_ana.collectionPostFix,
                        self.cqObjects)
                setattr(event, "partons" + self.cfg_ana.collectionPostFix,
                        self.partons)
                setattr(event,
                        "heaviestQCDFlavour" + self.cfg_ana.collectionPostFix,
                        self.heaviestQCDFlavour)

        return True
Example #25
0
    def process(self, event):
        self.readCollections(event.input)
        rho = float(self.handles['rho'].product()[0])
        rho_jer = float(self.handles['rho_jer'].product()[0])
        self.rho = rho

        ## Read jets, if necessary recalibrate and shift MET
        #self.jets_raw = map(Jet, self.handles['jets_raw'].product())
        if self.cfg_ana.copyJetsByValue:
            import ROOT
            allJets = map(
                lambda j: Jet(
                    ROOT.pat.Jet(
                        ROOT.edm.Ptr(ROOT.pat.Jet)
                        (ROOT.edm.ProductID(), j, 0))),
                self.handles['jets'].product(
                ))  #copy-by-value is safe if JetAnalyzer is ran more than once
        else:
            allJets = map(Jet, self.handles['jets'].product())
        self.jets_raw = copy.deepcopy(allJets)
        #set dummy MC flavour for all jets in case we want to ntuplize discarded jets later
        for jet in allJets:
            jet.mcFlavour = 0

        self.deltaMetFromJEC = [0., 0.]
        self.type1METCorr = [0., 0., 0.]
        self.type1METCorrUp = [0., 0., 0.]
        self.type1METCorrDown = [0., 0., 0.]
        self.sumRawJetsforT1 = [0., 0., 0.]

        #        print "before. rho",self.rho,self.cfg_ana.collectionPostFix,'allJets len ',len(allJets),'pt', [j.pt() for j in allJets]

        if self.doJEC:
            if not self.recalibrateJets:  # check point that things won't change
                jetsBefore = [(j.pt(), j.eta(), j.phi(), j.rawFactor())
                              for j in allJets]
            #print '[Debug] I am event = ', event.input.eventAuxiliary().id().event()

            self.jetReCalibrator.correctAll(
                allJets,
                rho,
                delta=self.shiftJEC,
                addCorr=True,
                addShifts=self.addJECShifts,
                metShift=self.deltaMetFromJEC,
                type1METCorr=self.type1METCorr,
                type1METCorrUp=self.type1METCorrUp,
                type1METCorrDown=self.type1METCorrDown,
                sumRawJetsforT1=self.sumRawJetsforT1)

            if not self.recalibrateJets:
                jetsAfter = [(j.pt(), j.eta(), j.phi(), j.rawFactor())
                             for j in allJets]
                if len(jetsBefore) != len(jetsAfter):
                    print "ERROR: I had to recompute jet corrections, and they rejected some of the jets:\nold = %s\n new = %s\n" % (
                        jetsBefore, jetsAfter)
                else:
                    for (told, tnew) in zip(jetsBefore, jetsAfter):
                        if (deltaR2(told[1], told[2], tnew[1],
                                    tnew[2])) > 0.0001:
                            print "ERROR: I had to recompute jet corrections, and one jet direction moved: old = %s, new = %s\n" % (
                                told, tnew)
                        elif abs(told[0] - tnew[0]) / (
                                told[0] + tnew[0]) > 0.5e-3 or abs(
                                    told[3] - tnew[3]) > 0.5e-3:
                            print "ERROR: I had to recompute jet corrections, and one jet pt or corr changed: old = %s, new = %s\n" % (
                                told, tnew)
        self.allJetsUsedForMET = allJets
        self.sumJetsInT1 = {
            "rawP4forT1":
            self.sumRawJetsforT1,
            "type1METCorr":
            self.type1METCorr,
            "corrP4forT1":
            [x + y for x, y in zip(self.sumRawJetsforT1, self.type1METCorr)]
        }

        #        print "after. rho",self.rho,self.cfg_ana.collectionPostFix,'allJets len ',len(allJets),'pt', [j.pt() for j in allJets]

        if self.cfg_comp.isMC:
            self.genJets = [x for x in self.handles['genJet'].product()]

        # ==> following matching example from PhysicsTools/Heppy/python/analyzers/examples/JetAnalyzer.py
        if self.cfg_comp.isMC:
            for jet in allJets:
                if self.smearJets:
                    jet.resolution = self.jetResolution.getResolution(
                        jet, rho_jer)
                    jet.jerfactor = self.jetResolution.getScaleFactor(jet)
                else:
                    jet.resolution = 1.0
                    jet.jerfactor = 1.0

                if self.genJets:
                    # Use DeltaR = 0.2 matching jet and genJet from
                    # https://github.com/blinkseb/JMEReferenceSample/blob/master/test/createReferenceSample.py
                    pairs = XZZmatchObjectCollection([jet], self.genJets,
                                                     0.2 * 0.2, 3)
                    if pairs[jet] is None:
                        pass
                    else:
                        jet.matchedGenJet = pairs[jet]
                else:
                    pass
                if self.debug:
                    print '[Debug] I am event = ', event.input.eventAuxiliary(
                    ).id().event()
                if self.smearJets:
                    self.jerCorrection(jet, rho_jer)

##Sort Jets by pT
        allJets.sort(key=lambda j: j.pt(), reverse=True)

        leptons = []
        if hasattr(event, 'selectedLeptons'):
            leptons = [
                l for l in event.selectedLeptons
                if l.pt() > self.lepPtMin and self.lepSelCut(l)
            ]
        if self.cfg_ana.cleanJetsFromTaus and hasattr(event, 'selectedTaus'):
            leptons = leptons[:] + event.selectedTaus
        if self.cfg_ana.cleanJetsFromIsoTracks and hasattr(
                event, 'selectedIsoCleanTrack'):
            leptons = leptons[:] + event.selectedIsoCleanTrack

        self.counters.counter('jets').inc('All Events')
        ## Apply jet selection
        self.jets = []
        self.jetsFailId = []
        self.jetsAllNoID = []
        self.jetsIdOnly = []
        for jet in allJets:
            #Check if lepton and jet have overlapping PF candidates
            leps_with_overlaps = []
            if getattr(self.cfg_ana, 'checkLeptonPFOverlap', True):
                for i in range(jet.numberOfSourceCandidatePtrs()):
                    p1 = jet.sourceCandidatePtr(i)  #Ptr<Candidate> p1
                    for lep in leptons:
                        for j in range(lep.numberOfSourceCandidatePtrs()):
                            p2 = lep.sourceCandidatePtr(j)
                            has_overlaps = p1.key() == p2.key() and p1.refCore(
                            ).id().productIndex() == p2.refCore().id(
                            ).productIndex() and p1.refCore().id(
                            ).processIndex() == p2.refCore().id().processIndex(
                            )
                            if has_overlaps:
                                leps_with_overlaps += [lep]
            if len(leps_with_overlaps) > 0:
                for lep in leps_with_overlaps:
                    lep.jetOverlap = jet
            if self.testJetNoID(jet):
                self.jetsAllNoID.append(jet)
                if (self.cfg_ana.doQG):
                    jet.qgl_calc = self.qglcalc.computeQGLikelihood
                    jet.qgl_rho = rho
                if self.testJetID(jet):
                    self.jets.append(jet)
                    self.jetsIdOnly.append(jet)
                else:
                    self.jetsFailId.append(jet)
            elif self.testJetID(jet):
                self.jetsIdOnly.append(jet)

        jetsEtaCut = [
            j for j in self.jets if abs(j.eta()) < self.cfg_ana.jetEta
        ]
        self.cleanJetsAll, cleanLeptons = cleanJetsAndLeptons(
            jetsEtaCut, leptons, self.jetLepDR, self.jetLepArbitration)

        self.cleanJets = [
            j for j in self.cleanJetsAll
            if abs(j.eta()) < self.cfg_ana.jetEtaCentral
        ]
        self.cleanJetsFwd = [
            j for j in self.cleanJetsAll
            if abs(j.eta()) >= self.cfg_ana.jetEtaCentral
        ]
        self.discardedJets = [
            j for j in self.jets if j not in self.cleanJetsAll
        ]
        if hasattr(event,
                   'selectedLeptons') and self.cfg_ana.cleanSelectedLeptons:
            event.discardedLeptons = [
                l for l in leptons if l not in cleanLeptons
            ]
            event.selectedLeptons = [
                l for l in event.selectedLeptons
                if l not in event.discardedLeptons
            ]
        for lep in leptons:
            if hasattr(lep, "jetOverlap"):
                if lep.jetOverlap in self.cleanJetsAll:
                    #print "overlap reco", lep.p4().pt(), lep.p4().eta(), lep.p4().phi(), lep.jetOverlap.p4().pt(), lep.jetOverlap.p4().eta(), lep.jetOverlap.p4().phi()
                    lep.jetOverlapIdx = self.cleanJetsAll.index(lep.jetOverlap)
                elif lep.jetOverlap in self.discardedJets:
                    #print "overlap discarded", lep.p4().pt(), lep.p4().eta(), lep.p4().phi(), lep.jetOverlap.p4().pt(), lep.jetOverlap.p4().eta(), lep.jetOverlap.p4().phi()
                    lep.jetOverlapIdx = 1000 + self.discardedJets.index(
                        lep.jetOverlap)

        ## First cleaning, then Jet Id
        self.noIdCleanJetsAll, cleanLeptons = cleanJetsAndLeptons(
            self.jetsAllNoID, leptons, self.jetLepDR, self.jetLepArbitration)
        self.noIdCleanJets = [
            j for j in self.noIdCleanJetsAll
            if abs(j.eta()) < self.cfg_ana.jetEtaCentral
        ]
        self.noIdCleanJetsFwd = [
            j for j in self.noIdCleanJetsAll
            if abs(j.eta()) >= self.cfg_ana.jetEtaCentral
        ]
        self.noIdDiscardedJets = [
            j for j in self.jetsAllNoID if j not in self.noIdCleanJetsAll
        ]

        ## Clean Jets from photons (first cleaning, then Jet Id)
        photons = []
        if hasattr(event, 'selectedPhotons'):
            if self.cfg_ana.cleanJetsFromFirstPhoton:
                photons = event.selectedPhotons[:1]
            else:
                photons = [g for g in event.selectedPhotons]

        self.gamma_cleanJetsAll = cleanNearestJetOnly(self.cleanJetsAll,
                                                      photons, self.jetGammaDR)
        self.gamma_cleanJets = [
            j for j in self.gamma_cleanJetsAll
            if abs(j.eta()) < self.cfg_ana.jetEtaCentral
        ]
        self.gamma_cleanJetsFwd = [
            j for j in self.gamma_cleanJetsAll
            if abs(j.eta()) >= self.cfg_ana.jetEtaCentral
        ]
        self.gamma_noIdCleanJetsAll = cleanNearestJetOnly(
            self.noIdCleanJetsAll, photons, self.jetGammaDR)
        self.gamma_noIdCleanJets = [
            j for j in self.gamma_noIdCleanJetsAll
            if abs(j.eta()) < self.cfg_ana.jetEtaCentral
        ]
        self.gamma_noIdCleanJetsFwd = [
            j for j in self.gamma_noIdCleanJetsAll
            if abs(j.eta()) >= self.cfg_ana.jetEtaCentral
        ]
        ###

        if self.cfg_ana.alwaysCleanPhotons:
            self.cleanJets = self.gamma_cleanJets
            self.cleanJetsAll = self.gamma_cleanJetsAll
            self.cleanJetsFwd = self.gamma_cleanJetsFwd
            #
            self.noIdCleanJets = self.gamma_noIdCleanJets
            self.noIdCleanJetsAll = self.gamma_noIdCleanJetsAll
            self.noIdCleanJetsFwd = self.gamma_noIdCleanJetsFwd

        ## Jet Id, after jet/lepton cleaning
        self.cleanJetsFailIdAll = []
        for jet in self.noIdCleanJetsAll:
            if not self.testJetID(jet):
                self.cleanJetsFailIdAll.append(jet)

        self.cleanJetsFailId = [
            j for j in self.cleanJetsFailIdAll
            if abs(j.eta()) < self.cfg_ana.jetEtaCentral
        ]

        ## Jet Id, after jet/photon cleaning
        self.gamma_cleanJetsFailIdAll = []
        for jet in self.gamma_noIdCleanJetsAll:
            if not self.testJetID(jet):
                self.gamma_cleanJetsFailIdAll.append(jet)

        self.gamma_cleanJetsFailId = [
            j for j in self.gamma_cleanJetsFailIdAll
            if abs(j.eta()) < self.cfg_ana.jetEtaCentral
        ]

        ## Associate jets to leptons
        incleptons = event.inclusiveLeptons if hasattr(
            event, 'inclusiveLeptons') else event.selectedLeptons
        jlpairs = matchObjectCollection(incleptons, allJets, self.jetLepDR**2)

        for jet in allJets:
            jet.leptons = [l for l in jlpairs if jlpairs[l] == jet]
        for lep in incleptons:
            jet = jlpairs[lep]
            if jet is None:
                setattr(lep, "jet" + self.cfg_ana.collectionPostFix, lep)
            else:
                setattr(lep, "jet" + self.cfg_ana.collectionPostFix, jet)
        ## Associate jets to taus
        taus = getattr(event, 'selectedTaus', [])
        jtaupairs = matchObjectCollection(taus, allJets, self.jetLepDR**2)

        for jet in allJets:
            jet.taus = [l for l in jtaupairs if jtaupairs[l] == jet]
        for tau in taus:
            setattr(tau, "jet" + self.cfg_ana.collectionPostFix,
                    jtaupairs[tau])

        #MC stuff
        if self.cfg_comp.isMC:
            self.deltaMetFromJetSmearing = [0, 0]
            for j in self.cleanJetsAll:
                if hasattr(j, 'deltaMetFromJetSmearing'):
                    self.deltaMetFromJetSmearing[
                        0] += j.deltaMetFromJetSmearing[0]
                    self.deltaMetFromJetSmearing[
                        1] += j.deltaMetFromJetSmearing[1]

            self.cleanGenJets = cleanNearestJetOnly(self.genJets, leptons,
                                                    self.jetLepDR)

            if self.cfg_ana.cleanGenJetsFromPhoton:
                self.cleanGenJets = cleanNearestJetOnly(
                    self.cleanGenJets, photons, self.jetLepDR)

            if getattr(self.cfg_ana, 'attachNeutrinos', True) and hasattr(
                    self.cfg_ana, "genNuSelection"):
                jetNus = [
                    x for x in event.genParticles
                    if abs(x.pdgId()) in [12, 14, 16]
                    and self.cfg_ana.genNuSelection(x)
                ]
                pairs = matchObjectCollection(jetNus, self.genJets, 0.4**2)

                for (nu, genJet) in pairs.iteritems():
                    if genJet is not None:
                        if not hasattr(genJet, "nu"):
                            genJet.nu = nu.p4()
                        else:
                            genJet.nu += nu.p4()

            if self.cfg_ana.do_mc_match:
                self.jetFlavour(event)

        if hasattr(event, "jets" + self.cfg_ana.collectionPostFix):
            raise RuntimeError, "Event already contains a jet collection with the following postfix: " + self.cfg_ana.collectionPostFix
        setattr(event, "rho" + self.cfg_ana.collectionPostFix, self.rho)
        setattr(event, "deltaMetFromJEC" + self.cfg_ana.collectionPostFix,
                self.deltaMetFromJEC)
        setattr(event, "type1METCorr" + self.cfg_ana.collectionPostFix,
                self.type1METCorr)
        setattr(event, "type1METCorrUp" + self.cfg_ana.collectionPostFix,
                self.type1METCorrUp)
        setattr(event, "type1METCorrDown" + self.cfg_ana.collectionPostFix,
                self.type1METCorrDown)
        setattr(event, "sumJetsInT1" + self.cfg_ana.collectionPostFix,
                self.sumJetsInT1)
        setattr(event, "allJetsUsedForMET" + self.cfg_ana.collectionPostFix,
                self.allJetsUsedForMET)
        setattr(event, "jets_raw" + self.cfg_ana.collectionPostFix,
                self.jets_raw)
        setattr(event, "jets" + self.cfg_ana.collectionPostFix, self.jets)
        setattr(event, "jetsFailId" + self.cfg_ana.collectionPostFix,
                self.jetsFailId)
        setattr(event, "jetsAllNoID" + self.cfg_ana.collectionPostFix,
                self.jetsAllNoID)
        setattr(event, "jetsIdOnly" + self.cfg_ana.collectionPostFix,
                self.jetsIdOnly)
        setattr(event, "cleanJetsAll" + self.cfg_ana.collectionPostFix,
                self.cleanJetsAll)
        setattr(event, "cleanJets" + self.cfg_ana.collectionPostFix,
                self.cleanJets)
        setattr(event, "cleanJetsFwd" + self.cfg_ana.collectionPostFix,
                self.cleanJetsFwd)
        setattr(event, "cleanJetsFailIdAll" + self.cfg_ana.collectionPostFix,
                self.cleanJetsFailIdAll)
        setattr(event, "cleanJetsFailId" + self.cfg_ana.collectionPostFix,
                self.cleanJetsFailId)
        setattr(event, "discardedJets" + self.cfg_ana.collectionPostFix,
                self.discardedJets)
        setattr(event, "gamma_cleanJetsAll" + self.cfg_ana.collectionPostFix,
                self.gamma_cleanJetsAll)
        setattr(event, "gamma_cleanJets" + self.cfg_ana.collectionPostFix,
                self.gamma_cleanJets)
        setattr(event, "gamma_cleanJetsFwd" + self.cfg_ana.collectionPostFix,
                self.gamma_cleanJetsFwd)
        setattr(event,
                "gamma_cleanJetsFailIdAll" + self.cfg_ana.collectionPostFix,
                self.gamma_cleanJetsFailIdAll)
        setattr(event,
                "gamma_cleanJetsFailId" + self.cfg_ana.collectionPostFix,
                self.gamma_cleanJetsFailId)

        if self.cfg_comp.isMC:
            setattr(event,
                    "deltaMetFromJetSmearing" + self.cfg_ana.collectionPostFix,
                    self.deltaMetFromJetSmearing)
            setattr(event, "cleanGenJets" + self.cfg_ana.collectionPostFix,
                    self.cleanGenJets)
            setattr(event, "genJets" + self.cfg_ana.collectionPostFix,
                    self.genJets)
            if self.cfg_ana.do_mc_match:
                setattr(event, "bqObjects" + self.cfg_ana.collectionPostFix,
                        self.bqObjects)
                setattr(event, "cqObjects" + self.cfg_ana.collectionPostFix,
                        self.cqObjects)
                setattr(event, "partons" + self.cfg_ana.collectionPostFix,
                        self.partons)
                setattr(event,
                        "heaviestQCDFlavour" + self.cfg_ana.collectionPostFix,
                        self.heaviestQCDFlavour)

        return True