def __init__(self, cfg_ana, cfg_comp, looperName): super(JetAnalyzer, self).__init__(cfg_ana, cfg_comp, looperName) self.btagSF = BTagSF(0, wp='medium') self.recalibrateJets = self.cfg_ana.recalibrateJets if hasattr( cfg_ana, 'recalibrateJets') else False mcGT = cfg_ana.mcGT if hasattr( cfg_ana, 'mcGT') else "76X_mcRun2_asymptotic_RunIIFall15DR76_v1" dataGT = cfg_ana.dataGT if hasattr( cfg_ana, 'dataGT') else "76X_dataRun2_16Dec2015_v0" if self.recalibrateJets: doResidual = getattr(cfg_ana, 'applyL2L3Residual', 'Data') if doResidual == "MC": doResidual = self.cfg_comp.isMC elif doResidual == "Data": doResidual = not self.cfg_comp.isMC elif doResidual not in [True, False]: raise RuntimeError, "If specified, applyL2L3Residual must be any of { True, False, 'MC', 'Data'(default)}" GT = getattr(cfg_comp, 'jecGT', mcGT if self.cfg_comp.isMC else dataGT) # instantiate the jet re-calibrator self.jetReCalibrator = JetReCalibrator( GT, 'AK4PFchs', doResidual, jecPath="%s/src/CMGTools/RootTools/data/jec" % os.environ['CMSSW_BASE'])
def __init__(self, cfg_ana, cfg_comp, looperName): super(JetAnalyzer, self).__init__(cfg_ana, cfg_comp, looperName) mcGT = cfg_ana.mcGT if hasattr(cfg_ana, 'mcGT') else "PHYS14_25_V2" dataGT = cfg_ana.dataGT if hasattr(cfg_ana, 'dataGT') else "GR_70_V2_AN1" self.shiftJEC = self.cfg_ana.shiftJEC if hasattr( self.cfg_ana, 'shiftJEC') else 0 self.recalibrateJets = self.cfg_ana.recalibrateJets if self.recalibrateJets == "MC": self.recalibrateJets = self.cfg_comp.isMC elif self.recalibrateJets == "Data": self.recalibrateJets = not self.cfg_comp.isMC elif self.recalibrateJets not in [True, False]: raise RuntimeError, "recalibrateJets must be any of { True, False, 'MC', 'Data' }, while it is %r " % self.recalibrateJets self.doJEC = self.recalibrateJets or (self.shiftJEC != 0) if self.doJEC: if self.cfg_comp.isMC: self.jetReCalibrator = JetReCalibrator(mcGT, "AK4PFchs", False, cfg_ana.jecPath) else: self.jetReCalibrator = JetReCalibrator(dataGT, "AK4PFchs", True, cfg_ana.jecPath) self.doPuId = getattr(self.cfg_ana, 'doPuId', True) self.jetLepDR = getattr(self.cfg_ana, 'jetLepDR', 0.4) self.jetLepArbitration = getattr(self.cfg_ana, 'jetLepArbitration', lambda jet, lepton: lepton) self.lepPtMin = getattr(self.cfg_ana, 'minLepPt', -1) self.jetGammaDR = getattr(self.cfg_ana, 'jetGammaDR', 0.4) if (self.cfg_ana.doQG): self.qglcalc = QGLikelihoodCalculator( "/afs/cern.ch/user/t/tomc/public/qgTagger/QGLikelihoodDBFiles/QGL_v1a/pdfQG_AK4chs_antib_13TeV_v1.root" )
def __init__(self, cfg_ana, cfg_comp, looperName): super(AdditionalBoost,self).__init__(cfg_ana, cfg_comp, looperName) # Get the config parameters skip_ca15 = cfg_ana.skip_ca15 if hasattr(cfg_ana,'skip_ca15') else False GT = cfg_ana.GT if hasattr(cfg_ana,'GT') else "Summer15_25nsV6_DATA" jecPath = cfg_ana.jecPath if hasattr(cfg_ana,'jecPath') else "." isMC = cfg_ana.isMC if hasattr(cfg_ana,'isMC') else False self.skip_ca15 = skip_ca15 # Prepare re-calibrator recalibrationType = "AK8PFchs" # Following instructions from: # https://twiki.cern.ch/twiki/bin/viewauth/CMS/JetWtagging # L2L3 if isMC: doResidual = False # L2L3 Residual else: doResidual = True self.jetReCalibrator = JetReCalibrator(GT, recalibrationType, doResidual, jecPath, skipLevel1=True)
def __init__(self, cfg_ana, cfg_comp, looperName): super(JetAnalyzer, self).__init__(cfg_ana, cfg_comp, looperName) self.btagSF = BTagSF(0, wp='medium') self.recalibrateJets = getattr(cfg_ana, 'recalibrateJets', False) mcGT = getattr(cfg_ana, 'mcGT', 'Spring16_25nsV6_MC') dataGT = getattr(cfg_ana, 'dataGT', 'Spring16_25nsV6_DATA') if self.recalibrateJets: doResidual = getattr(cfg_ana, 'applyL2L3Residual', 'Data') if doResidual == "MC": doResidual = self.cfg_comp.isMC elif doResidual == "Data": doResidual = not self.cfg_comp.isMC elif doResidual not in [True, False]: raise RuntimeError, "If specified, applyL2L3Residual must be any of { True, False, 'MC', 'Data'(default)}" GT = getattr(cfg_comp, 'jecGT', mcGT if self.cfg_comp.isMC else dataGT) # instantiate the jet re-calibrator self.jetReCalibrator = JetReCalibrator( GT, 'AK4PFchs', doResidual, jecPath="%s/src/CMGTools/RootTools/data/jec" % os.environ['CMSSW_BASE'])
def __init__(self, cfg_ana, cfg_comp, looperName): super(JetAnalyzer,self).__init__(cfg_ana, cfg_comp, looperName) mcGT = cfg_ana.mcGT if hasattr(cfg_ana,'mcGT') else "PHYS14_25_V2" dataGT = cfg_ana.dataGT if hasattr(cfg_ana,'dataGT') else "GR_70_V2_AN1" self.shiftJEC = self.cfg_ana.shiftJEC if hasattr(self.cfg_ana, 'shiftJEC') else 0 self.recalibrateJets = self.cfg_ana.recalibrateJets self.addJECShifts = self.cfg_ana.addJECShifts if self.recalibrateJets == "MC" : self.recalibrateJets = self.cfg_comp.isMC elif self.recalibrateJets == "Data": self.recalibrateJets = not self.cfg_comp.isMC elif self.recalibrateJets not in [True,False]: raise RuntimeError, "recalibrateJets must be any of { True, False, 'MC', 'Data' }, while it is %r " % self.recalibrateJets self.doJEC = self.recalibrateJets or (self.shiftJEC != 0) or self.addJECShifts if self.doJEC: doResidual = getattr(cfg_ana, 'applyL2L3Residual', 'Data') if doResidual == "MC": doResidual = self.cfg_comp.isMC elif doResidual == "Data": doResidual = not self.cfg_comp.isMC elif doResidual not in [True,False]: raise RuntimeError, "If specified, applyL2L3Residual must be any of { True, False, 'MC', 'Data'(default)}" if self.cfg_comp.isMC: self.jetReCalibrator = JetReCalibrator(mcGT,self.cfg_ana.recalibrationType, doResidual, cfg_ana.jecPath, calculateSeparateCorrections=getattr(cfg_ana,"calculateSeparateCorrections",False)) else: self.jetReCalibrator = JetReCalibrator(dataGT,self.cfg_ana.recalibrationType, doResidual, cfg_ana.jecPath, calculateSeparateCorrections=getattr(cfg_ana,"calculateSeparateCorrections",False)) self.doPuId = getattr(self.cfg_ana, 'doPuId', True) self.jetLepDR = getattr(self.cfg_ana, 'jetLepDR', 0.4) self.jetLepArbitration = getattr(self.cfg_ana, 'jetLepArbitration', lambda jet,lepton: lepton) self.lepPtMin = getattr(self.cfg_ana, 'minLepPt', -1) self.lepSelCut = getattr(self.cfg_ana, 'lepSelCut', lambda lep : True) self.jetGammaDR = getattr(self.cfg_ana, 'jetGammaDR', 0.4) if(self.cfg_ana.doQG): qgdefname="{CMSSW_BASE}/src/PhysicsTools/Heppy/data/pdfQG_AK4chs_antib_13TeV_v1.root" self.qglcalc = QGLikelihoodCalculator(getattr(self.cfg_ana,"QGpath",qgdefname).format(CMSSW_BASE= os.environ['CMSSW_BASE'])) if not hasattr(self.cfg_ana ,"collectionPostFix"):self.cfg_ana.collectionPostFix=""
def __init__(self, cfg_ana, cfg_comp, looperName): super(JetAnalyzer, self).__init__(cfg_ana, cfg_comp, looperName) mcGT = cfg_ana.mcGT if hasattr(cfg_ana, 'mcGT') else "PHYS14_25_V2" dataGT = cfg_ana.dataGT if hasattr(cfg_ana, 'dataGT') else "GR_70_V2_AN1" self.shiftJEC = self.cfg_ana.shiftJEC if hasattr( self.cfg_ana, 'shiftJEC') else 0 self.recalibrateJets = self.cfg_ana.recalibrateJets if self.recalibrateJets == "MC": self.recalibrateJets = self.cfg_comp.isMC elif self.recalibrateJets == "Data": self.recalibrateJets = not self.cfg_comp.isMC elif self.recalibrateJets not in [True, False]: raise RuntimeError, "recalibrateJets must be any of { True, False, 'MC', 'Data' }, while it is %r " % self.recalibrateJets self.doJEC = self.recalibrateJets or (self.shiftJEC != 0) if self.doJEC: if self.cfg_comp.isMC: self.jetReCalibrator = JetReCalibrator(mcGT, "AK4PFchs", False, cfg_ana.jecPath) else: self.jetReCalibrator = JetReCalibrator(dataGT, "AK4PFchs", True, cfg_ana.jecPath) self.doPuId = self.cfg_ana.doPuId if hasattr(self.cfg_ana, 'doPuId') else True self.jetLepDR = self.cfg_ana.jetLepDR if hasattr( self.cfg_ana, 'jetLepDR') else 0.5 self.lepPtMin = self.cfg_ana.minLepPt if hasattr( self.cfg_ana, 'minLepPt') else -1 self.jetGammaDR = self.cfg_ana.jetGammaDR if hasattr( self.cfg_ana, 'jetGammaDR') else 0.4 if (self.cfg_ana.doQG): self.qglcalc = QGLikelihoodCalculator( "/afs/cern.ch/user/t/tomc/public/QG_pdfs_13TeV_2014-10-12/pdfQG_AK4chs_antib_NoQC_13TeV.root" )
class JetAnalyzer(Analyzer): def beginLoop(self, setup): super(JetAnalyzer, self).beginLoop(setup) if self.cfg_ana.do_jec: global_tag = self.cfg_ana.gt_mc if not self.cfg_comp.isMC: global_tag = self.cfg_comp.dataGT do_residual = not self.cfg_comp.isMC from PhysicsTools.Heppy.physicsutils.JetReCalibrator import JetReCalibrator self.jet_calibrator = JetReCalibrator( global_tag, 'AK4PFchs', do_residual, jecPath=os.path.expandvars( "${CMSSW_BASE}/src/CMGTools/RootTools/data/jec"), calculateType1METCorrection=True) self.counters.addCounter('JetAnalyzer') count = self.counters.counter('JetAnalyzer') count.register('all events') count.register('at least 2 good jets') count.register('at least 2 clean jets') def declareHandles(self): super(JetAnalyzer, self).declareHandles() self.handles['jets'] = AutoHandle(self.cfg_ana.jets, 'std::vector<pat::Jet>') def process(self, event): self.readCollections(event.input) jets = self.handles['jets'].product() output_jets = [] if self.cfg_ana.year == '2016': for jet in jets: hjet = Jet(jet) output_jets.append(hjet) else: for jet in jets: hjet = Jet(jet) if not hasattr(self.cfg_ana, 'selection'): continue elif self.cfg_ana.selection(hjet): output_jets.append(hjet) if self.cfg_ana.do_jec: event.metShift = [0., 0.] event.type1METCorr = [0., 0., 0.] self.jet_calibrator.correctAll(output_jets, event.rho, delta=0., addCorr=True, addShifts=True, metShift=event.metShift, type1METCorr=event.type1METCorr) setattr(event, self.cfg_ana.output, output_jets)
def __init__(self, cfg_ana, cfg_comp, looperName): super(JetAnalyzer,self).__init__(cfg_ana, cfg_comp, looperName) mcGT = cfg_ana.mcGT if hasattr(cfg_ana,'mcGT') else "PHYS14_25_V2" dataGT = cfg_ana.dataGT if hasattr(cfg_ana,'dataGT') else "GR_70_V2_AN1" self.shiftJEC = self.cfg_ana.shiftJEC if hasattr(self.cfg_ana, 'shiftJEC') else 0 self.recalibrateJets = self.cfg_ana.recalibrateJets self.addJECShifts = self.cfg_ana.addJECShifts if hasattr(self.cfg_ana, 'addJECShifts') else 0 if self.recalibrateJets == "MC" : self.recalibrateJets = self.cfg_comp.isMC elif self.recalibrateJets == "Data": self.recalibrateJets = not self.cfg_comp.isMC elif self.recalibrateJets not in [True,False]: raise RuntimeError("recalibrateJets must be any of { True, False, 'MC', 'Data' }, while it is %r " % self.recalibrateJets) calculateSeparateCorrections = getattr(cfg_ana,"calculateSeparateCorrections", False); calculateType1METCorrection = getattr(cfg_ana,"calculateType1METCorrection", False); self.doJEC = self.recalibrateJets or (self.shiftJEC != 0) or self.addJECShifts or calculateSeparateCorrections or calculateType1METCorrection if self.doJEC: doResidual = getattr(cfg_ana, 'applyL2L3Residual', 'Data') if doResidual == "MC": doResidual = self.cfg_comp.isMC elif doResidual == "Data": doResidual = not self.cfg_comp.isMC elif doResidual not in [True,False]: raise RuntimeError("If specified, applyL2L3Residual must be any of { True, False, 'MC', 'Data'(default)}") GT = getattr(cfg_comp, 'jecGT', mcGT if self.cfg_comp.isMC else dataGT) # Now take care of the optional arguments kwargs = { 'calculateSeparateCorrections':calculateSeparateCorrections, 'calculateType1METCorrection' :calculateType1METCorrection, } if kwargs['calculateType1METCorrection']: kwargs['type1METParams'] = cfg_ana.type1METParams # instantiate the jet re-calibrator self.jetReCalibrator = JetReCalibrator(GT, cfg_ana.recalibrationType, doResidual, cfg_ana.jecPath, **kwargs) self.doPuId = getattr(self.cfg_ana, 'doPuId', True) self.jetLepDR = getattr(self.cfg_ana, 'jetLepDR', 0.4) self.jetLepArbitration = getattr(self.cfg_ana, 'jetLepArbitration', lambda jet,lepton: lepton) self.lepPtMin = getattr(self.cfg_ana, 'minLepPt', -1) self.lepSelCut = getattr(self.cfg_ana, 'lepSelCut', lambda lep : True) self.jetGammaDR = getattr(self.cfg_ana, 'jetGammaDR', 0.4) self.jetGammaLepDR = getattr(self.cfg_ana, 'jetGammaLepDR', 0.4) self.cleanFromLepAndGammaSimultaneously = getattr(self.cfg_ana, 'cleanFromLepAndGammaSimultaneously', False) if self.cleanFromLepAndGammaSimultaneously: if hasattr(self.cfg_ana, 'jetGammaLepDR'): self.jetGammaLepDR = self.jetGammaLepDR elif (self.jetGammaDR == self.jetLepDR): self.jetGammaLepDR = self.jetGammaDR else: raise RuntimeError("DR for simultaneous cleaning of jets from leptons and photons is not defined, and dR(gamma, jet)!=dR(lep, jet)") if(self.cfg_ana.doQG): qgdefname="{CMSSW_BASE}/src/PhysicsTools/Heppy/data/pdfQG_AK4chs_13TeV_v2b.root" self.qglcalc = QGLikelihoodCalculator(getattr(self.cfg_ana,"QGpath",qgdefname).format(CMSSW_BASE= os.environ['CMSSW_BASE'])) if not hasattr(self.cfg_ana ,"collectionPostFix"):self.cfg_ana.collectionPostFix=""
def __init__(self, cfg_ana, cfg_comp, looperName): super(JetAnalyzer,self).__init__(cfg_ana, cfg_comp, looperName) mcGT = cfg_ana.mcGT if hasattr(cfg_ana,'mcGT') else "START53_V27" dataGT = cfg_ana.dataGT if hasattr(cfg_ana,'dataGT') else "FT_53_V21_AN5" self.shiftJEC = self.cfg_ana.shiftJEC if hasattr(self.cfg_ana, 'shiftJEC') else 0 self.doJEC = self.cfg_ana.recalibrateJets or (self.shiftJEC != 0) if self.doJEC: if self.cfg_comp.isMC: self.jetReCalibrator = JetReCalibrator(mcGT,"AK5PF", False,cfg_ana.jecPath) self.jetReCalibratorCHS = JetReCalibrator(mcGT,"AK5PFchs", False,cfg_ana.jecPath) else: self.jetReCalibrator = JetReCalibrator(dataGT,"AK5PF", True,cfg_ana.jecPath) self.jetReCalibratorCHS = JetReCalibrator(dataGT,"AK5PFchs", True,cfg_ana.jecPath) self.doPuId = self.cfg_ana.doPuId if hasattr(self.cfg_ana, 'doPuId') else True self.jetLepDR = self.cfg_ana.jetLepDR if hasattr(self.cfg_ana, 'jetLepDR') else 0.5 self.lepPtMin = self.cfg_ana.minLepPt if hasattr(self.cfg_ana, 'minLepPt') else -1 self.jetGammaDR = self.cfg_ana.jetGammaDR if hasattr(self.cfg_ana, 'jetGammaDR') else 0.4 self.gammaPtMin = self.cfg_ana.minGammaPt if hasattr(self.cfg_ana, 'minGammaPt') else -1 self.gammaEtaCentral = self.cfg_ana.gammaEtaCentral if hasattr(self.cfg_ana, 'gammaEtaCentral') else 0
def beginLoop(self, setup): super(JetAnalyzer, self).beginLoop(setup) if self.cfg_ana.do_jec: global_tag = self.cfg_ana.gt_mc if not self.cfg_comp.isMC: global_tag = self.cfg_comp.dataGT do_residual = not self.cfg_comp.isMC from PhysicsTools.Heppy.physicsutils.JetReCalibrator import JetReCalibrator self.jet_calibrator = JetReCalibrator( global_tag, 'AK4PFchs', do_residual, jecPath=os.path.expandvars( "${CMSSW_BASE}/src/CMGTools/RootTools/data/jec"), calculateType1METCorrection=True) self.counters.addCounter('JetAnalyzer') count = self.counters.counter('JetAnalyzer') count.register('all events') count.register('at least 2 good jets') count.register('at least 2 clean jets')
def __init__(self, cfg_ana, cfg_comp, looperName): super(JetAnalyzer, self).__init__(cfg_ana, cfg_comp, looperName) mcGT = cfg_ana.mcGT if hasattr(cfg_ana, 'mcGT') else "PHYS14_25_V2" dataGT = cfg_ana.dataGT if hasattr(cfg_ana, 'dataGT') else "GR_70_V2_AN1" self.shiftJEC = self.cfg_ana.shiftJEC if hasattr( self.cfg_ana, 'shiftJEC') else 0 self.recalibrateJets = self.cfg_ana.recalibrateJets if self.recalibrateJets == "MC": self.recalibrateJets = self.cfg_comp.isMC elif self.recalibrateJets == "Data": self.recalibrateJets = not self.cfg_comp.isMC elif self.recalibrateJets not in [True, False]: raise RuntimeError( "recalibrateJets must be any of { True, False, 'MC', 'Data' }, while it is %r " % self.recalibrateJets) self.doJEC = self.recalibrateJets or (self.shiftJEC != 0) if self.doJEC: if self.cfg_comp.isMC: self.jetReCalibrator = JetReCalibrator( mcGT, self.cfg_ana.recalibrationType, False, cfg_ana.jecPath) else: self.jetReCalibrator = JetReCalibrator( dataGT, self.cfg_ana.recalibrationType, True, cfg_ana.jecPath) self.doPuId = getattr(self.cfg_ana, 'doPuId', True) self.jetLepDR = getattr(self.cfg_ana, 'jetLepDR', 0.4) self.jetLepArbitration = getattr(self.cfg_ana, 'jetLepArbitration', lambda jet, lepton: lepton) self.lepPtMin = getattr(self.cfg_ana, 'minLepPt', -1) self.lepSelCut = getattr(self.cfg_ana, 'lepSelCut', lambda lep: True) self.jetGammaDR = getattr(self.cfg_ana, 'jetGammaDR', 0.4) if (self.cfg_ana.doQG): self.qglcalc = QGLikelihoodCalculator( "%s/src/PhysicsTools/Heppy/data/pdfQG_AK4chs_antib_13TeV_v1.root" % os.environ['CMSSW_BASE']) if not hasattr(self.cfg_ana, "collectionPostFix"): self.cfg_ana.collectionPostFix = ""
def __init__(self, cfg_ana, cfg_comp, looperName): super(JetAnalyzer,self).__init__(cfg_ana, cfg_comp, looperName) mcGT = cfg_ana.mcGT if hasattr(cfg_ana,'mcGT') else "PHYS14_25_V2" dataGT = cfg_ana.dataGT if hasattr(cfg_ana,'dataGT') else "GR_70_V2_AN1" self.shiftJEC = self.cfg_ana.shiftJEC if hasattr(self.cfg_ana, 'shiftJEC') else 0 self.recalibrateJets = self.cfg_ana.recalibrateJets if self.recalibrateJets == "MC" : self.recalibrateJets = self.cfg_comp.isMC elif self.recalibrateJets == "Data": self.recalibrateJets = not self.cfg_comp.isMC elif self.recalibrateJets not in [True,False]: raise RuntimeError, "recalibrateJets must be any of { True, False, 'MC', 'Data' }, while it is %r " % self.recalibrateJets self.doJEC = self.recalibrateJets or (self.shiftJEC != 0) if self.doJEC: if self.cfg_comp.isMC: self.jetReCalibrator = JetReCalibrator(mcGT,"AK4PFchs", False,cfg_ana.jecPath) else: self.jetReCalibrator = JetReCalibrator(dataGT,"AK4PFchs", True,cfg_ana.jecPath) self.doPuId = getattr(self.cfg_ana, 'doPuId', True) self.jetLepDR = getattr(self.cfg_ana, 'jetLepDR', 0.4) self.jetLepArbitration = getattr(self.cfg_ana, 'jetLepArbitration', lambda jet,lepton: lepton) self.lepPtMin = getattr(self.cfg_ana, 'minLepPt', -1) self.jetGammaDR = getattr(self.cfg_ana, 'jetGammaDR', 0.4) if(self.cfg_ana.doQG): self.qglcalc = QGLikelihoodCalculator("/afs/cern.ch/user/t/tomc/public/qgTagger/QGLikelihoodDBFiles/QGL_v1a/pdfQG_AK4chs_antib_13TeV_v1.root")
def __init__(self, cfg_ana, cfg_comp, looperName): super(monoXPuppiJetAnalyzer, self).__init__(cfg_ana, cfg_comp, looperName) mcGT = cfg_ana.mcGT if hasattr(cfg_ana, 'mcGT') else "PHYS14_25_V2" dataGT = cfg_ana.dataGT if hasattr(cfg_ana, 'dataGT') else "GR_70_V2_AN1" self.shiftJEC = self.cfg_ana.shiftJEC if hasattr( self.cfg_ana, 'shiftJEC') else 0 self.recalibrateJets = self.cfg_ana.recalibrateJets self.addJECShifts = self.cfg_ana.addJECShifts if hasattr( self.cfg_ana, 'addJECShifts') else 0 if self.recalibrateJets == "MC": self.recalibrateJets = self.cfg_comp.isMC elif self.recalibrateJets == "Data": self.recalibrateJets = not self.cfg_comp.isMC elif self.recalibrateJets not in [True, False]: raise RuntimeError, "recalibrateJets must be any of { True, False, 'MC', 'Data' }, while it is %r " % self.recalibrateJets self.doJEC = self.recalibrateJets or (self.shiftJEC != 0) or self.addJECShifts if self.doJEC: doResidual = getattr(cfg_ana, 'applyL2L3Residual', 'Data') if doResidual == "MC": doResidual = self.cfg_comp.isMC elif doResidual == "Data": doResidual = not self.cfg_comp.isMC elif doResidual not in [True, False]: raise RuntimeError, "If specified, applyL2L3Residual must be any of { True, False, 'MC', 'Data'(default)}" GT = getattr(cfg_comp, 'jecGT', mcGT if self.cfg_comp.isMC else dataGT) # instantiate the jet re-calibrator self.jetReCalibrator = JetReCalibrator(GT, cfg_ana.recalibrationType, doResidual, cfg_ana.jecPath) self.jetLepDR = self.cfg_ana.jetLepDR if hasattr( self.cfg_ana, 'jetLepDR') else 0.5 self.lepPtMin = self.cfg_ana.minLepPt if hasattr( self.cfg_ana, 'minLepPt') else -1
def __init__(self, cfg_ana, cfg_comp, looperName): super(EventInterpretationBase,self).__init__(cfg_ana, cfg_comp, looperName) self.selectFat = self.cfg_ana.selectFat self.selectPairLNu = self.cfg_ana.selectPairLNu self.selectPairLL = self.cfg_ana.selectPairLL self.selectPairJJ = self.cfg_ana.selectPairJJ self.selectPairJJNuNu = self.cfg_ana.selectPairJJNuNu self.isMC =cfg_comp.isMC if hasattr(cfg_ana,'matchDR'): self.matchDR = cfg_ana.matchDR else: self.matchDR = 0.2 mcGT = cfg_ana.mcGT if hasattr(cfg_ana,'mcGT') else "PHYS14_25_V2" dataGT = cfg_ana.dataGT if hasattr(cfg_ana,'dataGT') else "GR_70_V2_AN1" self.shiftJEC = self.cfg_ana.shiftJEC if hasattr(self.cfg_ana, 'shiftJEC') else 0 self.recalibrateJets = self.cfg_ana.recalibrateJets if self.recalibrateJets == "MC" : self.recalibrateJets = self.cfg_comp.isMC elif self.recalibrateJets == "Data": self.recalibrateJets = not self.cfg_comp.isMC elif self.recalibrateJets not in [True,False]: raise RuntimeError, "recalibrateJets must be any of { True, False, 'MC', 'Data' }, while it is %r " % self.recalibrateJets self.doJEC = self.recalibrateJets or (self.shiftJEC != 0) if self.doJEC: if self.cfg_comp.isMC: if hasattr(self.cfg_comp,'globalTag'): self.jetReCalibrator = JetReCalibrator(self.cfg_comp.globalTag,self.cfg_ana.recalibrationType, False,cfg_ana.jecPath) self.jetReCalibratorFAT = JetReCalibrator(self.cfg_comp.globalTag,self.cfg_ana.recalibrationTypeFAT, False,cfg_ana.jecPath) else: self.jetReCalibrator = JetReCalibrator(mcGT,self.cfg_ana.recalibrationType, False,cfg_ana.jecPath) self.jetReCalibratorFAT = JetReCalibrator(mcGT,self.cfg_ana.recalibrationTypeFAT, False,cfg_ana.jecPath) else: if hasattr(self.cfg_comp,'globalTag'): self.jetReCalibrator = JetReCalibrator(self.cfg_comp.globalTag,self.cfg_ana.recalibrationType, True,cfg_ana.jecPath) self.jetReCalibratorFAT = JetReCalibrator(self.cfg_comp.globalTag,self.cfg_ana.recalibrationTypeFAT, True,cfg_ana.jecPath) else: self.jetReCalibrator = JetReCalibrator(dataGT,self.cfg_ana.recalibrationType, True,cfg_ana.jecPath) self.jetReCalibratorFAT = JetReCalibrator(dataGT,self.cfg_ana.recalibrationTypeFAT, True,cfg_ana.jecPath) self.attachBTag = cfg_ana.attachBTag if self.attachBTag: self.btagDiscriminator = cfg_ana.btagDiscriminator if hasattr(cfg_ana,'doSkim'): self.doSkim = cfg_ana.doSkim else: self.doSkim=False
def __init__(self, cfg_ana, cfg_comp, looperName): super(JetAnalyzer,self).__init__(cfg_ana, cfg_comp, looperName) mcGT = cfg_ana.mcGT if hasattr(cfg_ana,'mcGT') else "PHYS14_25_V2" dataGT = cfg_ana.dataGT if hasattr(cfg_ana,'dataGT') else "GR_70_V2_AN1" self.shiftJEC = self.cfg_ana.shiftJEC if hasattr(self.cfg_ana, 'shiftJEC') else 0 self.recalibrateJets = self.cfg_ana.recalibrateJets if self.recalibrateJets == "MC" : self.recalibrateJets = self.cfg_comp.isMC elif self.recalibrateJets == "Data": self.recalibrateJets = not self.cfg_comp.isMC elif self.recalibrateJets not in [True,False]: raise RuntimeError, "recalibrateJets must be any of { True, False, 'MC', 'Data' }, while it is %r " % self.recalibrateJets self.doJEC = self.recalibrateJets or (self.shiftJEC != 0) if self.doJEC: if self.cfg_comp.isMC: self.jetReCalibrator = JetReCalibrator(mcGT,self.cfg_ana.recalibrationType, False,cfg_ana.jecPath) else: self.jetReCalibrator = JetReCalibrator(dataGT,self.cfg_ana.recalibrationType, True,cfg_ana.jecPath) self.doPuId = getattr(self.cfg_ana, 'doPuId', True) self.jetLepDR = getattr(self.cfg_ana, 'jetLepDR', 0.4) self.jetLepArbitration = getattr(self.cfg_ana, 'jetLepArbitration', lambda jet,lepton: lepton) self.lepPtMin = getattr(self.cfg_ana, 'minLepPt', -1) self.lepSelCut = getattr(self.cfg_ana, 'lepSelCut', lambda lep : True) self.jetGammaDR = getattr(self.cfg_ana, 'jetGammaDR', 0.4) if(self.cfg_ana.doQG): self.qglcalc = QGLikelihoodCalculator("%s/src/PhysicsTools/Heppy/data/pdfQG_AK4chs_antib_13TeV_v1.root" % os.environ['CMSSW_BASE']) if not hasattr(self.cfg_ana ,"collectionPostFix"):self.cfg_ana.collectionPostFix=""
def __init__(self, cfg_ana, cfg_comp, looperName): super(JetAnalyzer,self).__init__(cfg_ana, cfg_comp, looperName) mcGT = cfg_ana.mcGT if hasattr(cfg_ana,'mcGT') else "PHYS14_25_V2" dataGT = cfg_ana.dataGT if hasattr(cfg_ana,'dataGT') else "GR_70_V2_AN1" self.shiftJEC = self.cfg_ana.shiftJEC if hasattr(self.cfg_ana, 'shiftJEC') else 0 self.recalibrateJets = self.cfg_ana.recalibrateJets self.addJECShifts = self.cfg_ana.addJECShifts if hasattr(self.cfg_ana, 'addJECShifts') else 0 if self.recalibrateJets == "MC" : self.recalibrateJets = self.cfg_comp.isMC elif self.recalibrateJets == "Data": self.recalibrateJets = not self.cfg_comp.isMC elif self.recalibrateJets not in [True,False]: raise RuntimeError("recalibrateJets must be any of { True, False, 'MC', 'Data' }, while it is %r " % self.recalibrateJets) calculateSeparateCorrections = getattr(cfg_ana,"calculateSeparateCorrections", False); calculateType1METCorrection = getattr(cfg_ana,"calculateType1METCorrection", False); self.doJEC = self.recalibrateJets or (self.shiftJEC != 0) or self.addJECShifts or calculateSeparateCorrections or calculateType1METCorrection if self.doJEC: doResidual = getattr(cfg_ana, 'applyL2L3Residual', 'Data') if doResidual == "MC": doResidual = self.cfg_comp.isMC elif doResidual == "Data": doResidual = not self.cfg_comp.isMC elif doResidual not in [True,False]: raise RuntimeError("If specified, applyL2L3Residual must be any of { True, False, 'MC', 'Data'(default)}") GT = getattr(cfg_comp, 'jecGT', mcGT if self.cfg_comp.isMC else dataGT) # Now take care of the optional arguments kwargs = { 'calculateSeparateCorrections':calculateSeparateCorrections, 'calculateType1METCorrection' :calculateType1METCorrection, } if kwargs['calculateType1METCorrection']: kwargs['type1METParams'] = cfg_ana.type1METParams # instantiate the jet re-calibrator self.jetReCalibrator = JetReCalibrator(GT, cfg_ana.recalibrationType, doResidual, cfg_ana.jecPath, **kwargs) self.doPuId = getattr(self.cfg_ana, 'doPuId', True) self.jetLepDR = getattr(self.cfg_ana, 'jetLepDR', 0.4) self.jetLepArbitration = getattr(self.cfg_ana, 'jetLepArbitration', lambda jet,lepton: lepton) self.lepPtMin = getattr(self.cfg_ana, 'minLepPt', -1) self.lepSelCut = getattr(self.cfg_ana, 'lepSelCut', lambda lep : True) self.jetGammaDR = getattr(self.cfg_ana, 'jetGammaDR', 0.4) self.jetGammaLepDR = getattr(self.cfg_ana, 'jetGammaLepDR', 0.4) self.cleanFromLepAndGammaSimultaneously = getattr(self.cfg_ana, 'cleanFromLepAndGammaSimultaneously', False) if self.cleanFromLepAndGammaSimultaneously: if hasattr(self.cfg_ana, 'jetGammaLepDR'): self.jetGammaLepDR = self.jetGammaLepDR elif (self.jetGammaDR == self.jetLepDR): self.jetGammaLepDR = self.jetGammaDR else: raise RuntimeError("DR for simultaneous cleaning of jets from leptons and photons is not defined, and dR(gamma, jet)!=dR(lep, jet)") if(self.cfg_ana.doQG): qgdefname="{CMSSW_BASE}/src/PhysicsTools/Heppy/data/pdfQG_AK4chs_13TeV_v2b.root" self.qglcalc = QGLikelihoodCalculator(getattr(self.cfg_ana,"QGpath",qgdefname).format(CMSSW_BASE= os.environ['CMSSW_BASE'])) if not hasattr(self.cfg_ana ,"collectionPostFix"):self.cfg_ana.collectionPostFix=""
class JetAnalyzer( Analyzer ): """Taken from RootTools.JetAnalyzer, simplified, modified, added corrections """ def __init__(self, cfg_ana, cfg_comp, looperName): super(JetAnalyzer,self).__init__(cfg_ana, cfg_comp, looperName) mcGT = cfg_ana.mcGT if hasattr(cfg_ana,'mcGT') else "PHYS14_25_V2" dataGT = cfg_ana.dataGT if hasattr(cfg_ana,'dataGT') else "GR_70_V2_AN1" self.shiftJEC = self.cfg_ana.shiftJEC if hasattr(self.cfg_ana, 'shiftJEC') else 0 self.recalibrateJets = self.cfg_ana.recalibrateJets self.addJECShifts = self.cfg_ana.addJECShifts if hasattr(self.cfg_ana, 'addJECShifts') else 0 if self.recalibrateJets == "MC" : self.recalibrateJets = self.cfg_comp.isMC elif self.recalibrateJets == "Data": self.recalibrateJets = not self.cfg_comp.isMC elif self.recalibrateJets not in [True,False]: raise RuntimeError("recalibrateJets must be any of { True, False, 'MC', 'Data' }, while it is %r " % self.recalibrateJets) calculateSeparateCorrections = getattr(cfg_ana,"calculateSeparateCorrections", False); calculateType1METCorrection = getattr(cfg_ana,"calculateType1METCorrection", False); self.doJEC = self.recalibrateJets or (self.shiftJEC != 0) or self.addJECShifts or calculateSeparateCorrections or calculateType1METCorrection if self.doJEC: doResidual = getattr(cfg_ana, 'applyL2L3Residual', 'Data') if doResidual == "MC": doResidual = self.cfg_comp.isMC elif doResidual == "Data": doResidual = not self.cfg_comp.isMC elif doResidual not in [True,False]: raise RuntimeError("If specified, applyL2L3Residual must be any of { True, False, 'MC', 'Data'(default)}") GT = getattr(cfg_comp, 'jecGT', mcGT if self.cfg_comp.isMC else dataGT) # Now take care of the optional arguments kwargs = { 'calculateSeparateCorrections':calculateSeparateCorrections, 'calculateType1METCorrection' :calculateType1METCorrection, } if kwargs['calculateType1METCorrection']: kwargs['type1METParams'] = cfg_ana.type1METParams # instantiate the jet re-calibrator self.jetReCalibrator = JetReCalibrator(GT, cfg_ana.recalibrationType, doResidual, cfg_ana.jecPath, **kwargs) self.doPuId = getattr(self.cfg_ana, 'doPuId', True) self.jetLepDR = getattr(self.cfg_ana, 'jetLepDR', 0.4) self.jetLepArbitration = getattr(self.cfg_ana, 'jetLepArbitration', lambda jet,lepton: lepton) self.lepPtMin = getattr(self.cfg_ana, 'minLepPt', -1) self.lepSelCut = getattr(self.cfg_ana, 'lepSelCut', lambda lep : True) self.jetGammaDR = getattr(self.cfg_ana, 'jetGammaDR', 0.4) self.jetGammaLepDR = getattr(self.cfg_ana, 'jetGammaLepDR', 0.4) self.cleanFromLepAndGammaSimultaneously = getattr(self.cfg_ana, 'cleanFromLepAndGammaSimultaneously', False) if self.cleanFromLepAndGammaSimultaneously: if hasattr(self.cfg_ana, 'jetGammaLepDR'): self.jetGammaLepDR = self.jetGammaLepDR elif (self.jetGammaDR == self.jetLepDR): self.jetGammaLepDR = self.jetGammaDR else: raise RuntimeError("DR for simultaneous cleaning of jets from leptons and photons is not defined, and dR(gamma, jet)!=dR(lep, jet)") if(self.cfg_ana.doQG): qgdefname="{CMSSW_BASE}/src/PhysicsTools/Heppy/data/pdfQG_AK4chs_13TeV_v2b.root" self.qglcalc = QGLikelihoodCalculator(getattr(self.cfg_ana,"QGpath",qgdefname).format(CMSSW_BASE= os.environ['CMSSW_BASE'])) if not hasattr(self.cfg_ana ,"collectionPostFix"):self.cfg_ana.collectionPostFix="" def declareHandles(self): super(JetAnalyzer, self).declareHandles() self.handles['jets'] = AutoHandle( self.cfg_ana.jetCol, 'std::vector<pat::Jet>' ) self.handles['genJet'] = AutoHandle( self.cfg_ana.genJetCol, 'vector<reco::GenJet>' ) self.shiftJER = self.cfg_ana.shiftJER if hasattr(self.cfg_ana, 'shiftJER') else 0 self.addJERShifts = self.cfg_ana.addJERShifts if hasattr(self.cfg_ana, 'addJERShifts') else 0 self.handles['rho'] = AutoHandle( self.cfg_ana.rho, 'double' ) def beginLoop(self, setup): super(JetAnalyzer,self).beginLoop(setup) 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 def testJetID(self, jet): jet.puJetIdPassed = jet.puJetId() jet.pfJetIdPassed = jet.jetID('POG_PFID_Loose') if self.cfg_ana.relaxJetId: return True else: return jet.pfJetIdPassed and (jet.puJetIdPassed or not(self.doPuId)) def testJetNoID( self, jet ): # 2 is loose pile-up jet id return jet.pt() > self.cfg_ana.jetPt and \ abs( jet.eta() ) < self.cfg_ana.jetEta; def jetFlavour(self,event): def isFlavour(x,f): id = abs(x.pdgId()) if id > 999: return (id/1000)%10 == f if id > 99: return (id/100)%10 == f return id % 100 == f self.bqObjects = [ p for p in event.genParticles if (p.status() == 2 and isFlavour(p,5)) ] self.cqObjects = [ p for p in event.genParticles if (p.status() == 2 and isFlavour(p,4)) ] self.partons = [ p for p in event.genParticles if ((p.status() == 23 or p.status() == 3) and abs(p.pdgId())>0 and (abs(p.pdgId()) in [1,2,3,4,5,21]) ) ] match = matchObjectCollection2(self.cleanJetsAll, self.partons, deltaRMax = 0.3) for jet in self.cleanJetsAll: parton = match[jet] jet.partonId = (parton.pdgId() if parton != None else 0) jet.partonMotherId = (parton.mother(0).pdgId() if parton != None and parton.numberOfMothers()>0 else 0) for jet in self.jets: (bmatch, dr) = bestMatch(jet, self.bqObjects) if dr < 0.4: jet.mcFlavour = 5 else: (cmatch, dr) = bestMatch(jet, self.cqObjects) if dr < 0.4: jet.mcFlavour = 4 else: jet.mcFlavour = 0 self.heaviestQCDFlavour = 5 if len(self.bqObjects) else (4 if len(self.cqObjects) else 1); def matchJets(self, event, jets): match = matchObjectCollection2(jets, event.genbquarks + event.genwzquarks, deltaRMax = 0.3) for jet in jets: gen = match[jet] jet.mcParton = gen jet.mcMatchId = (gen.sourceId if gen != None else 0) jet.mcMatchFlav = (abs(gen.pdgId()) if gen != None else 0) match = matchObjectCollection2(jets, self.genJets, deltaRMax = 0.3) for jet in jets: jet.mcJet = match[jet] def smearJets(self, event, jets): # https://twiki.cern.ch/twiki/bin/viewauth/CMS/TWikiTopRefSyst#Jet_energy_resolution for jet in jets: gen = jet.mcJet if gen != None: genpt, jetpt, aeta = gen.pt(), jet.pt(), abs(jet.eta()) # from https://twiki.cern.ch/twiki/bin/view/CMS/JetResolution #8 TeV tables factor = shiftJERfactor(self.shiftJER, aeta) ptscale = max(0.0, (jetpt + (factor-1)*(jetpt-genpt))/jetpt) #print "get with pt %.1f (gen pt %.1f, ptscale = %.3f)" % (jetpt,genpt,ptscale) jet.deltaMetFromJetSmearing = [ -(ptscale-1)*jet.rawFactor()*jet.px(), -(ptscale-1)*jet.rawFactor()*jet.py() ] if ptscale != 0: jet.setP4(jet.p4()*ptscale) # leave the uncorrected unchanged for sync jet.setRawFactor(jet.rawFactor()/ptscale) #else: print "jet with pt %.1d, eta %.2f is unmatched" % (jet.pt(), jet.eta()) if (self.shiftJER==0) and (self.addJERShifts): setattr(jet, "corrJER", ptscale ) factorJERUp= shiftJERfactor(1, aeta) ptscaleJERUp = max(0.0, (jetpt + (factorJERUp-1)*(jetpt-genpt))/jetpt) setattr(jet, "corrJERUp", ptscaleJERUp) factorJERDown= shiftJERfactor(-1, aeta) ptscaleJERDown = max(0.0, (jetpt + (factorJERDown-1)*(jetpt-genpt))/jetpt) setattr(jet, "corrJERDown", ptscaleJERDown)
def __init__(self, cfg_ana, cfg_comp, looperName): super(EventInterpretationBase, self).__init__(cfg_ana, cfg_comp, looperName) self.selectFat = self.cfg_ana.selectFat self.selectPairLNu = self.cfg_ana.selectPairLNu self.selectPairLL = self.cfg_ana.selectPairLL self.selectPairJJ = self.cfg_ana.selectPairJJ self.selectPairJJNuNu = self.cfg_ana.selectPairJJNuNu self.isMC = cfg_comp.isMC if hasattr(cfg_ana, 'matchDR'): self.matchDR = cfg_ana.matchDR else: self.matchDR = 0.2 mcGT = cfg_ana.mcGT if hasattr(cfg_ana, 'mcGT') else "PHYS14_25_V2" dataGT = cfg_ana.dataGT if hasattr(cfg_ana, 'dataGT') else "GR_70_V2_AN1" self.shiftJEC = self.cfg_ana.shiftJEC if hasattr( self.cfg_ana, 'shiftJEC') else 0 self.recalibrateJets = self.cfg_ana.recalibrateJets if self.recalibrateJets == "MC": self.recalibrateJets = self.cfg_comp.isMC elif self.recalibrateJets == "Data": self.recalibrateJets = not self.cfg_comp.isMC elif self.recalibrateJets not in [True, False]: raise RuntimeError, "recalibrateJets must be any of { True, False, 'MC', 'Data' }, while it is %r " % self.recalibrateJets self.doJEC = self.recalibrateJets or (self.shiftJEC != 0) if self.doJEC: if self.cfg_comp.isMC: if hasattr(self.cfg_comp, 'globalTag'): self.jetReCalibrator = JetReCalibrator( self.cfg_comp.globalTag, self.cfg_ana.recalibrationType, False, cfg_ana.jecPath) self.jetReCalibratorFAT = JetReCalibrator( self.cfg_comp.globalTag, self.cfg_ana.recalibrationTypeFAT, False, cfg_ana.jecPath) else: self.jetReCalibrator = JetReCalibrator( mcGT, self.cfg_ana.recalibrationType, False, cfg_ana.jecPath) self.jetReCalibratorFAT = JetReCalibrator( mcGT, self.cfg_ana.recalibrationTypeFAT, False, cfg_ana.jecPath, 3, True) else: if hasattr(self.cfg_comp, 'globalTag'): self.jetReCalibrator = JetReCalibrator( self.cfg_comp.globalTag, self.cfg_ana.recalibrationType, True, cfg_ana.jecPath) self.jetReCalibratorFAT = JetReCalibrator( self.cfg_comp.globalTag, self.cfg_ana.recalibrationTypeFAT, True, cfg_ana.jecPath) else: self.jetReCalibrator = JetReCalibrator( dataGT, self.cfg_ana.recalibrationType, True, cfg_ana.jecPath) self.jetReCalibratorFAT = JetReCalibrator( dataGT, self.cfg_ana.recalibrationTypeFAT, True, cfg_ana.jecPath) self.attachBTag = cfg_ana.attachBTag if self.attachBTag: self.btagDiscriminator = cfg_ana.btagDiscriminator if hasattr(cfg_ana, 'doSkim'): self.doSkim = cfg_ana.doSkim else: self.doSkim = False
class EventInterpretationBase(Analyzer): def __init__(self, cfg_ana, cfg_comp, looperName): super(EventInterpretationBase, self).__init__(cfg_ana, cfg_comp, looperName) self.selectFat = self.cfg_ana.selectFat self.selectPairLNu = self.cfg_ana.selectPairLNu self.selectPairLL = self.cfg_ana.selectPairLL self.selectPairJJ = self.cfg_ana.selectPairJJ self.selectPairJJNuNu = self.cfg_ana.selectPairJJNuNu self.isMC = cfg_comp.isMC if hasattr(cfg_ana, 'matchDR'): self.matchDR = cfg_ana.matchDR else: self.matchDR = 0.2 mcGT = cfg_ana.mcGT if hasattr(cfg_ana, 'mcGT') else "PHYS14_25_V2" dataGT = cfg_ana.dataGT if hasattr(cfg_ana, 'dataGT') else "GR_70_V2_AN1" self.shiftJEC = self.cfg_ana.shiftJEC if hasattr( self.cfg_ana, 'shiftJEC') else 0 self.recalibrateJets = self.cfg_ana.recalibrateJets if self.recalibrateJets == "MC": self.recalibrateJets = self.cfg_comp.isMC elif self.recalibrateJets == "Data": self.recalibrateJets = not self.cfg_comp.isMC elif self.recalibrateJets not in [True, False]: raise RuntimeError, "recalibrateJets must be any of { True, False, 'MC', 'Data' }, while it is %r " % self.recalibrateJets self.doJEC = self.recalibrateJets or (self.shiftJEC != 0) if self.doJEC: if self.cfg_comp.isMC: if hasattr(self.cfg_comp, 'globalTag'): self.jetReCalibrator = JetReCalibrator( self.cfg_comp.globalTag, self.cfg_ana.recalibrationType, False, cfg_ana.jecPath) self.jetReCalibratorFAT = JetReCalibrator( self.cfg_comp.globalTag, self.cfg_ana.recalibrationTypeFAT, False, cfg_ana.jecPath) else: self.jetReCalibrator = JetReCalibrator( mcGT, self.cfg_ana.recalibrationType, False, cfg_ana.jecPath) self.jetReCalibratorFAT = JetReCalibrator( mcGT, self.cfg_ana.recalibrationTypeFAT, False, cfg_ana.jecPath, 3, True) else: if hasattr(self.cfg_comp, 'globalTag'): self.jetReCalibrator = JetReCalibrator( self.cfg_comp.globalTag, self.cfg_ana.recalibrationType, True, cfg_ana.jecPath) self.jetReCalibratorFAT = JetReCalibrator( self.cfg_comp.globalTag, self.cfg_ana.recalibrationTypeFAT, True, cfg_ana.jecPath) else: self.jetReCalibrator = JetReCalibrator( dataGT, self.cfg_ana.recalibrationType, True, cfg_ana.jecPath) self.jetReCalibratorFAT = JetReCalibrator( dataGT, self.cfg_ana.recalibrationTypeFAT, True, cfg_ana.jecPath) self.attachBTag = cfg_ana.attachBTag if self.attachBTag: self.btagDiscriminator = cfg_ana.btagDiscriminator if hasattr(cfg_ana, 'doSkim'): self.doSkim = cfg_ana.doSkim else: self.doSkim = False def declareHandles(self): super(EventInterpretationBase, self).declareHandles() self.handles['packed'] = AutoHandle( 'packedPFCandidates', 'std::vector<pat::PackedCandidate>') self.handles['rho'] = AutoHandle(self.cfg_ana.rho, 'double') if self.attachBTag or self.doSkim: self.handles['jets'] = AutoHandle(self.cfg_ana.standardJets, 'std::vector<pat::Jet>') self.handles['fatjets'] = AutoHandle(self.cfg_ana.fatJets, 'std::vector<pat::Jet>') self.handles['subjets'] = AutoHandle( (self.cfg_ana.subJets, 'SubJets'), 'std::vector<pat::Jet>') def removeLeptonFootPrint(self, leptons, cands): toRemove = [] cList = list(cands) for lepton in leptons: for p in range(0, lepton.numberOfSourceCandidatePtrs()): index = lepton.sourceCandidatePtr(p).key() if not cands[index] in toRemove: toRemove.append(cands[index]) for r in toRemove: cList.remove(r) return cList def matchSubJets(self, jets, genquarks): for j in jets: for s in j.subjets_SD + j.subjets: s.mcquark = None s.matched = 0 for g in genquarks: if deltaR(s.eta(), s.phi(), g.eta(), g.phi()) < self.matchDR: s.matched = 1 s.mcquark = g break def skim(self, leptons, met): cleanedJets = [] for jet in self.handles['fatjets'].product(): overlap = False for lepton in leptons: if deltaR(jet.eta(), jet.phi(), lepton.eta(), lepton.phi()) < 0.8: overlap = True break if not overlap: cleanedJets.append(jet) nJets = len(cleanedJets) nLeptons = len(leptons) if (nLeptons > 0 and nJets > 0) or nJets > 1 or (nJets > 0 and met.pt() > 300): return True return False def puppiWeight(self, cands): skimmedCollection = [] for p in cands: p.setP4(p.p4() * p.puppiWeight()) if p.pt() > 0: skimmedCollection.append(p) return skimmedCollection def makeFatJets(self, cands): toolboxFat = PyJetToolbox(cands) toolboxFat.setInterface(True, self.cfg_ana.ktPowerFat, self.cfg_ana.rFat) toolboxFat.setMassDrop(self.cfg_ana.massdrop) toolboxFat.setSubjets(True, 'inc', self.cfg_ana.subjets) toolboxFat.setPruning(self.cfg_ana.prunning) toolboxFat.setNtau(True) if hasattr(self.cfg_ana, 'softdrop_beta'): toolboxFat.setSoftDrop(self.cfg_ana.softdrop, self.cfg_ana.softdrop_beta, self.cfg_ana.softdrop_zeta) else: toolboxFat.setSoftDrop(self.cfg_ana.softdrop) # Lets cluster !! Fat jets first fatJets = toolboxFat.inclusiveJets(200.0, True) filtered = filter(self.selectFat, fatJets) ##Apply JECS in original,SoftDrop and pruned: if self.jetReCalibratorFAT is not None: prunedJets = [] for j in fatJets: prunedJets.append(j) prunedJets.append(j.softDropJet) prunedJets.append(j.prunedJet) #do not apply L1 corrections:rho=0.0 self.jetReCalibratorFAT.correctAll(prunedJets, 0.0, self.shiftJEC, True, False, [0., 0.], [0., 0., 0.]) # self.jetReCalibratorFAT.correctAll(originalJets, self.rho, self.shiftJEC,True,False,[0.,0.],[0.,0.,0.]) for p in prunedJets: p.setRawFactor(1.0 / p.corr) standardFatJets = self.handles['fatjets'].product() if self.attachBTag: for fat in filtered: for standardFat in standardFatJets: fat.btag = standardFat.bDiscriminator( self.btagDiscriminator) for j in fat.subjets_SD + fat.subjets: for standard in self.handles['subjets'].product(): if deltaR(j.eta(), j.phi(), standard.eta(), standard.phi()) < 0.1: j.btag = standard.bDiscriminator( self.btagDiscriminator) break return filtered def makeSatelliteJets(self, cands): toolbox = PyJetToolbox(cands) toolbox.setInterface(True, self.cfg_ana.ktPower, self.cfg_ana.r) toolbox.setMassDrop(False) toolbox.setSubjets(False, 'inc', 2) toolbox.setPruning(False) toolbox.setNtau(False) toolbox.setSoftDrop(False) unfiltered = toolbox.inclusiveJets(30.0, False) if self.attachBTag: for j in unfiltered: for standard in self.handles['jets'].product(): if deltaR(j.eta(), j.phi(), standard.eta(), standard.phi()) < 0.1: j.btag = standard.bDiscriminator( self.btagDiscriminator) break if self.jetReCalibrator is not None: self.jetReCalibrator.correctAll(unfiltered, self.rho, self.shiftJEC, True, False, [0., 0.], [0., 0., 0.]) for p in unfiltered: p.setRawFactor(1.0 / p.corr) filtered = filter(lambda x: x.pt() > 30, unfiltered) return filtered else: return unfiltered def removeJetFootPrint(self, jets, cands): toRemove = [] for j in jets: toRemove.extend(j.constituents) out = list(set(cands) - set(toRemove)) return out def topology(self, obj): #first clean nicely the jets from leptons and subjets objToClean = [] if abs(obj['pair'].leg1.pdgId()) == 23: objToClean.extend([obj['pair'].leg1.leg1, obj['pair'].leg1.leg2]) # print 'Z->ll', obj['pair'].leg1.leg1.pt(),obj['pair'].leg1.leg1.eta(),obj['pair'].leg1.leg1.phi(),obj['pair'].leg1.leg2.pt(),obj['pair'].leg1.leg2.eta(),obj['pair'].leg1.leg2.phi() if abs(obj['pair'].leg1.pdgId()) == 24: objToClean.extend([obj['pair'].leg1.leg1]) # print 'W->lnu', obj['pair'].leg1.leg1.pt(),obj['pair'].leg1.leg1.eta(),obj['pair'].leg1.leg1.phi() if abs(obj['pair'].leg1.pdgId()) == 1: objToClean.extend(obj['pair'].leg1.subjets) if abs(obj['pair'].leg2.pdgId()) == 23: objToClean.extend([obj['pair'].leg2.leg1, obj['pair'].leg2.leg2]) if abs(obj['pair'].leg2.pdgId()) == 24: objToClean.extend([obj['pair'].leg2.leg1]) if abs(obj['pair'].leg2.pdgId()) == 1: objToClean.extend(obj['pair'].leg2.subjets) # print 'jet', obj['pair'].leg2.pt(),obj['pair'].leg2.eta(),obj['pair'].leg2.phi() newJets = [] for j in obj['satelliteJets']: keep = True for c in objToClean: dr = deltaR(j.eta(), j.phi(), c.eta(), c.phi()) # print 'dr=',dr if dr < 0.4: keep = False break if keep: # print 'filtered satellite jet',j.pt(),j.eta(),j.phi() newJets.append(j) obj['satelliteJets'] = newJets if len(obj['satelliteJets']) < 2: obj['vbfDEta'] = -1.0 obj['vbfMJJ'] = -1.0 else: j1 = obj['satelliteJets'][0] j2 = obj['satelliteJets'][1] obj['vbfDEta'] = abs(j1.eta() - j2.eta()) obj['vbfMJJ'] = (j1.p4() + j2.p4()).M() NL = 0 NM = 0 NT = 0 bestBTag = None minDR = 1000.0 for s in obj['satelliteJets']: btag = s.bTag() if btag > 0.423: NL = NL + 1 DR = deltaR(obj['pair'].eta(), obj['pair'].phi(), s.eta(), s.phi()) if DR < minDR: bestBTag = s minDR = DR if btag > 0.814: NM = NM + 1 if btag > 0.941: NT = NT + 1 obj['nLooseBTags'] = NL obj['nMediumBTags'] = NM obj['nTightBTags'] = NT if bestBTag == None: obj['topMass'] = -1 else: obj['topMass'] = (bestBTag.p4() + s.p4()).mass() def beginLoop(self, setup): super(EventInterpretationBase, self).beginLoop(setup) def process(self, event): self.readCollections(event.input) rho = float(self.handles['rho'].product()[0]) self.rho = rho
class JetAnalyzer(Analyzer): """Taken from RootTools.JetAnalyzer, simplified, modified, added corrections """ def __init__(self, cfg_ana, cfg_comp, looperName): super(JetAnalyzer, self).__init__(cfg_ana, cfg_comp, looperName) mcGT = cfg_ana.mcGT if hasattr(cfg_ana, 'mcGT') else "PHYS14_25_V2" dataGT = cfg_ana.dataGT if hasattr(cfg_ana, 'dataGT') else "GR_70_V2_AN1" self.shiftJEC = self.cfg_ana.shiftJEC if hasattr( self.cfg_ana, 'shiftJEC') else 0 self.recalibrateJets = self.cfg_ana.recalibrateJets if self.recalibrateJets == "MC": self.recalibrateJets = self.cfg_comp.isMC elif self.recalibrateJets == "Data": self.recalibrateJets = not self.cfg_comp.isMC elif self.recalibrateJets not in [True, False]: raise RuntimeError, "recalibrateJets must be any of { True, False, 'MC', 'Data' }, while it is %r " % self.recalibrateJets self.doJEC = self.recalibrateJets or (self.shiftJEC != 0) if self.doJEC: if self.cfg_comp.isMC: self.jetReCalibrator = JetReCalibrator(mcGT, "AK4PFchs", False, cfg_ana.jecPath) else: self.jetReCalibrator = JetReCalibrator(dataGT, "AK4PFchs", True, cfg_ana.jecPath) self.doPuId = self.cfg_ana.doPuId if hasattr(self.cfg_ana, 'doPuId') else True self.jetLepDR = self.cfg_ana.jetLepDR if hasattr( self.cfg_ana, 'jetLepDR') else 0.5 self.lepPtMin = self.cfg_ana.minLepPt if hasattr( self.cfg_ana, 'minLepPt') else -1 self.jetGammaDR = self.cfg_ana.jetGammaDR if hasattr( self.cfg_ana, 'jetGammaDR') else 0.4 if (self.cfg_ana.doQG): self.qglcalc = QGLikelihoodCalculator( "/afs/cern.ch/user/t/tomc/public/QG_pdfs_13TeV_2014-10-12/pdfQG_AK4chs_antib_NoQC_13TeV.root" ) def declareHandles(self): super(JetAnalyzer, self).declareHandles() self.handles['jets'] = AutoHandle(self.cfg_ana.jetCol, 'std::vector<pat::Jet>') self.handles['genJet'] = AutoHandle('slimmedGenJets', 'vector<reco::GenJet>') self.shiftJER = self.cfg_ana.shiftJER if hasattr( self.cfg_ana, 'shiftJER') else 0 self.handles['rho'] = AutoHandle(('fixedGridRhoFastjetAll', '', ''), 'double') def beginLoop(self, setup): super(JetAnalyzer, self).beginLoop(setup) 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) ## 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 = cleanNearestJetOnly(event.jets, leptons, self.jetLepDR) 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 ] ## Clean Jets from photons photons = [] if hasattr(event, 'selectedPhotons'): 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 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, event.selectedLeptons, 0.5) #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 def testJetID(self, jet): jet.puJetIdPassed = jet.puJetId() jet.pfJetIdPassed = jet.jetID('POG_PFID_Loose') if self.cfg_ana.relaxJetId: return True else: return jet.pfJetIdPassed and (jet.puJetIdPassed or not (self.doPuId)) def testJetNoID(self, jet): # 2 is loose pile-up jet id return jet.pt() > self.cfg_ana.jetPt and \ abs( jet.eta() ) < self.cfg_ana.jetEta def computeQGvars(self, jet): jet.mult = 0 sum_weight = 0. sum_pt = 0. sum_deta = 0. sum_dphi = 0. sum_deta2 = 0. sum_detadphi = 0. sum_dphi2 = 0. for ii in range(0, jet.numberOfDaughters()): part = jet.daughter(ii) usePart = True if part.charge() == 0: # neutral particles if part.pt() > 1.: jet.mult += 1 else: # charged particles jet.mult += 1 if part.trackHighPurity() == False: usePart = False if part.fromPV() <= 1: usePart = False if usePart: deta = part.eta() - jet.eta() dphi = deltaPhi(part.phi(), jet.phi()) partPt = part.pt() weight = partPt * partPt sum_weight += weight sum_pt += partPt sum_deta += deta * weight sum_dphi += dphi * weight sum_deta2 += deta * deta * weight sum_detadphi += deta * dphi * weight sum_dphi2 += dphi * dphi * weight a = 0. b = 0. c = 0. if sum_weight > 0: jet.ptd = math.sqrt(sum_weight) / sum_pt ave_deta = sum_deta / sum_weight ave_dphi = sum_dphi / sum_weight ave_deta2 = sum_deta2 / sum_weight ave_dphi2 = sum_dphi2 / sum_weight a = ave_deta2 - ave_deta * ave_deta b = ave_dphi2 - ave_dphi * ave_dphi c = -(sum_detadphi / sum_weight - ave_deta * ave_dphi) else: jet.ptd = 0. delta = math.sqrt(math.fabs((a - b) * (a - b) + 4. * c * c)) if a + b - delta > 0: jet.axis2 = -math.log(math.sqrt(0.5 * (a + b - delta))) else: jet.axis2 = -1. def jetFlavour(self, event): def isFlavour(x, f): id = abs(x.pdgId()) if id > 999: return (id / 1000) % 10 == f if id > 99: return (id / 100) % 10 == f return id % 100 == f event.bqObjects = [ p for p in event.genParticles if (p.status() == 2 and isFlavour(p, 5)) ] event.cqObjects = [ p for p in event.genParticles if (p.status() == 2 and isFlavour(p, 4)) ] event.partons = [ p for p in event.genParticles if ((p.status() == 23 or p.status() == 3) and abs(p.pdgId()) > 0 and (abs(p.pdgId()) in [1, 2, 3, 4, 5, 21])) ] match = matchObjectCollection2(event.cleanJetsAll, event.partons, deltaRMax=0.3) for jet in event.cleanJetsAll: parton = match[jet] jet.partonId = (parton.pdgId() if parton != None else 0) jet.partonMotherId = (parton.mother(0).pdgId() if parton != None and parton.numberOfMothers() > 0 else 0) for jet in event.jets: (bmatch, dr) = bestMatch(jet, event.bqObjects) if dr < 0.4: jet.mcFlavour = 5 else: (cmatch, dr) = bestMatch(jet, event.cqObjects) if dr < 0.4: jet.mcFlavour = 4 else: jet.mcFlavour = 0 event.heaviestQCDFlavour = 5 if len( event.bqObjects) else (4 if len(event.cqObjects) else 1) def matchJets(self, event, jets): match = matchObjectCollection2(jets, event.genbquarks + event.genwzquarks, deltaRMax=0.3) for jet in jets: gen = match[jet] jet.mcParton = gen jet.mcMatchId = (gen.sourceId if gen != None else 0) jet.mcMatchFlav = (abs(gen.pdgId()) if gen != None else 0) match = matchObjectCollection2(jets, event.genJets, deltaRMax=0.3) for jet in jets: jet.mcJet = match[jet] def smearJets(self, event, jets): # https://twiki.cern.ch/twiki/bin/viewauth/CMS/TWikiTopRefSyst#Jet_energy_resolution for jet in jets: gen = jet.mcJet if gen != None: genpt, jetpt, aeta = gen.pt(), jet.pt(), abs(jet.eta()) # from https://twiki.cern.ch/twiki/bin/view/CMS/JetResolution factor = 1.052 + self.shiftJER * math.hypot(0.012, 0.062) if aeta > 2.3: factor = 1.288 + self.shiftJER * math.hypot(0.127, 0.154) elif aeta > 1.7: factor = 1.134 + self.shiftJER * math.hypot(0.035, 0.066) elif aeta > 1.1: factor = 1.096 + self.shiftJER * math.hypot(0.017, 0.063) elif aeta > 0.5: factor = 1.057 + self.shiftJER * math.hypot(0.012, 0.056) ptscale = max(0.0, (jetpt + (factor - 1) * (jetpt - genpt)) / jetpt) #print "get with pt %.1f (gen pt %.1f, ptscale = %.3f)" % (jetpt,genpt,ptscale) jet.deltaMetFromJetSmearing = [ -(ptscale - 1) * jet.rawFactor() * jet.px(), -(ptscale - 1) * jet.rawFactor() * jet.py() ] if ptscale != 0: jet.setP4(jet.p4() * ptscale) # leave the uncorrected unchanged for sync jet._rawFactorMultiplier *= (1.0 / ptscale) if ptscale != 0 else 1
class JetAnalyzer( Analyzer ): """Taken from RootTools.JetAnalyzer, simplified, modified, added corrections """ def __init__(self, cfg_ana, cfg_comp, looperName): super(JetAnalyzer,self).__init__(cfg_ana, cfg_comp, looperName) mcGT = cfg_ana.mcGT if hasattr(cfg_ana,'mcGT') else "PHYS14_25_V2" dataGT = cfg_ana.dataGT if hasattr(cfg_ana,'dataGT') else "GR_70_V2_AN1" self.shiftJEC = self.cfg_ana.shiftJEC if hasattr(self.cfg_ana, 'shiftJEC') else 0 self.recalibrateJets = self.cfg_ana.recalibrateJets if self.recalibrateJets == "MC" : self.recalibrateJets = self.cfg_comp.isMC elif self.recalibrateJets == "Data": self.recalibrateJets = not self.cfg_comp.isMC elif self.recalibrateJets not in [True,False]: raise RuntimeError, "recalibrateJets must be any of { True, False, 'MC', 'Data' }, while it is %r " % self.recalibrateJets self.doJEC = self.recalibrateJets or (self.shiftJEC != 0) if self.doJEC: if self.cfg_comp.isMC: self.jetReCalibrator = JetReCalibrator(mcGT,"AK4PFchs", False,cfg_ana.jecPath) else: self.jetReCalibrator = JetReCalibrator(dataGT,"AK4PFchs", True,cfg_ana.jecPath) self.doPuId = getattr(self.cfg_ana, 'doPuId', True) self.jetLepDR = getattr(self.cfg_ana, 'jetLepDR', 0.4) self.jetLepArbitration = getattr(self.cfg_ana, 'jetLepArbitration', lambda jet,lepton: lepton) self.lepPtMin = getattr(self.cfg_ana, 'minLepPt', -1) self.jetGammaDR = getattr(self.cfg_ana, 'jetGammaDR', 0.4) if(self.cfg_ana.doQG): self.qglcalc = QGLikelihoodCalculator("/afs/cern.ch/user/t/tomc/public/qgTagger/QGLikelihoodDBFiles/QGL_v1a/pdfQG_AK4chs_antib_13TeV_v1.root") def declareHandles(self): super(JetAnalyzer, self).declareHandles() self.handles['jets'] = AutoHandle( self.cfg_ana.jetCol, 'std::vector<pat::Jet>' ) self.handles['genJet'] = AutoHandle( 'slimmedGenJets', 'vector<reco::GenJet>' ) self.shiftJER = self.cfg_ana.shiftJER if hasattr(self.cfg_ana, 'shiftJER') else 0 self.handles['rho'] = AutoHandle( ('fixedGridRhoFastjetAll','',''), 'double' ) def beginLoop(self, setup): super(JetAnalyzer,self).beginLoop(setup) 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 def testJetID(self, jet): jet.puJetIdPassed = jet.puJetId() jet.pfJetIdPassed = jet.jetID('POG_PFID_Loose') if self.cfg_ana.relaxJetId: return True else: return jet.pfJetIdPassed and (jet.puJetIdPassed or not(self.doPuId)) def testJetNoID( self, jet ): # 2 is loose pile-up jet id return jet.pt() > self.cfg_ana.jetPt and \ abs( jet.eta() ) < self.cfg_ana.jetEta; def computeQGvars(self, jet): jet.mult = 0 sum_weight = 0. sum_pt = 0. sum_deta = 0. sum_dphi = 0. sum_deta2 = 0. sum_detadphi = 0. sum_dphi2 = 0. for ii in range(0, jet.numberOfDaughters()) : part = jet.daughter(ii) if part.charge() == 0 : # neutral particles if part.pt() < 1.: continue else : # charged particles if part.trackHighPurity()==False: continue if part.fromPV()<=1: continue jet.mult += 1 deta = part.eta() - jet.eta() dphi = deltaPhi(part.phi(), jet.phi()) partPt = part.pt() weight = partPt*partPt sum_weight += weight sum_pt += partPt sum_deta += deta*weight sum_dphi += dphi*weight sum_deta2 += deta*deta*weight sum_detadphi += deta*dphi*weight sum_dphi2 += dphi*dphi*weight a = 0. b = 0. c = 0. if sum_weight > 0 : jet.ptd = math.sqrt(sum_weight)/sum_pt ave_deta = sum_deta/sum_weight ave_dphi = sum_dphi/sum_weight ave_deta2 = sum_deta2/sum_weight ave_dphi2 = sum_dphi2/sum_weight a = ave_deta2 - ave_deta*ave_deta b = ave_dphi2 - ave_dphi*ave_dphi c = -(sum_detadphi/sum_weight - ave_deta*ave_dphi) else: jet.ptd = 0. delta = math.sqrt(math.fabs((a-b)*(a-b)+4.*c*c)) if a+b-delta > 0: jet.axis2 = -math.log(math.sqrt(0.5*(a+b-delta))) else: jet.axis2 = -1. def jetFlavour(self,event): def isFlavour(x,f): id = abs(x.pdgId()) if id > 999: return (id/1000)%10 == f if id > 99: return (id/100)%10 == f return id % 100 == f event.bqObjects = [ p for p in event.genParticles if (p.status() == 2 and isFlavour(p,5)) ] event.cqObjects = [ p for p in event.genParticles if (p.status() == 2 and isFlavour(p,4)) ] event.partons = [ p for p in event.genParticles if ((p.status() == 23 or p.status() == 3) and abs(p.pdgId())>0 and (abs(p.pdgId()) in [1,2,3,4,5,21]) ) ] match = matchObjectCollection2(event.cleanJetsAll, event.partons, deltaRMax = 0.3) for jet in event.cleanJetsAll: parton = match[jet] jet.partonId = (parton.pdgId() if parton != None else 0) jet.partonMotherId = (parton.mother(0).pdgId() if parton != None and parton.numberOfMothers()>0 else 0) for jet in event.jets: (bmatch, dr) = bestMatch(jet, event.bqObjects) if dr < 0.4: jet.mcFlavour = 5 else: (cmatch, dr) = bestMatch(jet, event.cqObjects) if dr < 0.4: jet.mcFlavour = 4 else: jet.mcFlavour = 0 event.heaviestQCDFlavour = 5 if len(event.bqObjects) else (4 if len(event.cqObjects) else 1); def matchJets(self, event, jets): match = matchObjectCollection2(jets, event.genbquarks + event.genwzquarks, deltaRMax = 0.3) for jet in jets: gen = match[jet] jet.mcParton = gen jet.mcMatchId = (gen.sourceId if gen != None else 0) jet.mcMatchFlav = (abs(gen.pdgId()) if gen != None else 0) match = matchObjectCollection2(jets, event.genJets, deltaRMax = 0.3) for jet in jets: jet.mcJet = match[jet] def smearJets(self, event, jets): # https://twiki.cern.ch/twiki/bin/viewauth/CMS/TWikiTopRefSyst#Jet_energy_resolution for jet in jets: gen = jet.mcJet if gen != None: genpt, jetpt, aeta = gen.pt(), jet.pt(), abs(jet.eta()) # from https://twiki.cern.ch/twiki/bin/view/CMS/JetResolution factor = 1.052 + self.shiftJER*math.hypot(0.012,0.062); if aeta > 2.3: factor = 1.288 + self.shiftJER*math.hypot(0.127,0.154) elif aeta > 1.7: factor = 1.134 + self.shiftJER*math.hypot(0.035,0.066) elif aeta > 1.1: factor = 1.096 + self.shiftJER*math.hypot(0.017,0.063) elif aeta > 0.5: factor = 1.057 + self.shiftJER*math.hypot(0.012,0.056) ptscale = max(0.0, (jetpt + (factor-1)*(jetpt-genpt))/jetpt) #print "get with pt %.1f (gen pt %.1f, ptscale = %.3f)" % (jetpt,genpt,ptscale) jet.deltaMetFromJetSmearing = [ -(ptscale-1)*jet.rawFactor()*jet.px(), -(ptscale-1)*jet.rawFactor()*jet.py() ] if ptscale != 0: jet.setP4(jet.p4()*ptscale) # leave the uncorrected unchanged for sync jet._rawFactorMultiplier *= (1.0/ptscale) if ptscale != 0 else 1
class JetAnalyzer(Analyzer): """Taken from RootTools.JetAnalyzer, simplified, modified, added corrections """ def __init__(self, cfg_ana, cfg_comp, looperName): super(JetAnalyzer, self).__init__(cfg_ana, cfg_comp, looperName) mcGT = cfg_ana.mcGT if hasattr(cfg_ana, 'mcGT') else "PHYS14_25_V2" dataGT = cfg_ana.dataGT if hasattr(cfg_ana, 'dataGT') else "GR_70_V2_AN1" self.shiftJEC = self.cfg_ana.shiftJEC if hasattr( self.cfg_ana, 'shiftJEC') else 0 self.recalibrateJets = self.cfg_ana.recalibrateJets if self.recalibrateJets == "MC": self.recalibrateJets = self.cfg_comp.isMC elif self.recalibrateJets == "Data": self.recalibrateJets = not self.cfg_comp.isMC elif self.recalibrateJets not in [True, False]: raise RuntimeError, "recalibrateJets must be any of { True, False, 'MC', 'Data' }, while it is %r " % self.recalibrateJets self.doJEC = self.recalibrateJets or (self.shiftJEC != 0) if self.doJEC: if self.cfg_comp.isMC: self.jetReCalibrator = JetReCalibrator( mcGT, self.cfg_ana.recalibrationType, False, cfg_ana.jecPath) else: self.jetReCalibrator = JetReCalibrator( dataGT, self.cfg_ana.recalibrationType, True, cfg_ana.jecPath) self.doPuId = getattr(self.cfg_ana, 'doPuId', True) self.jetLepDR = getattr(self.cfg_ana, 'jetLepDR', 0.4) self.jetLepArbitration = getattr(self.cfg_ana, 'jetLepArbitration', lambda jet, lepton: lepton) self.lepPtMin = getattr(self.cfg_ana, 'minLepPt', -1) self.lepSelCut = getattr(self.cfg_ana, 'lepSelCut', lambda lep: True) self.jetGammaDR = getattr(self.cfg_ana, 'jetGammaDR', 0.4) if (self.cfg_ana.doQG): self.qglcalc = QGLikelihoodCalculator( "%s/src/PhysicsTools/Heppy/data/pdfQG_AK4chs_antib_13TeV_v1.root" % os.environ['CMSSW_BASE']) if not hasattr(self.cfg_ana, "collectionPostFix"): self.cfg_ana.collectionPostFix = "" def declareHandles(self): super(JetAnalyzer, self).declareHandles() self.handles['jets'] = AutoHandle(self.cfg_ana.jetCol, 'std::vector<pat::Jet>') self.handles['genJet'] = AutoHandle(self.cfg_ana.genJetCol, 'vector<reco::GenJet>') self.shiftJER = self.cfg_ana.shiftJER if hasattr( self.cfg_ana, 'shiftJER') else 0 self.handles['rho'] = AutoHandle(self.cfg_ana.rho, 'double') def beginLoop(self, setup): super(JetAnalyzer, self).beginLoop(setup) 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 def testJetID(self, jet): jet.puJetIdPassed = jet.puJetId() jet.pfJetIdPassed = jet.jetID('POG_PFID_Loose') if self.cfg_ana.relaxJetId: return True else: return jet.pfJetIdPassed and (jet.puJetIdPassed or not (self.doPuId)) def testJetNoID(self, jet): # 2 is loose pile-up jet id return jet.pt() > self.cfg_ana.jetPt and \ abs( jet.eta() ) < self.cfg_ana.jetEta def computeQGvars(self, jet): jet.mult = 0 sum_weight = 0. sum_pt = 0. sum_deta = 0. sum_dphi = 0. sum_deta2 = 0. sum_detadphi = 0. sum_dphi2 = 0. for ii in range(0, jet.numberOfDaughters()): part = jet.daughter(ii) if part.charge() == 0: # neutral particles if part.pt() < 1.: continue else: # charged particles if part.trackHighPurity() == False: continue if part.fromPV() <= 1: continue jet.mult += 1 deta = part.eta() - jet.eta() dphi = deltaPhi(part.phi(), jet.phi()) partPt = part.pt() weight = partPt * partPt sum_weight += weight sum_pt += partPt sum_deta += deta * weight sum_dphi += dphi * weight sum_deta2 += deta * deta * weight sum_detadphi += deta * dphi * weight sum_dphi2 += dphi * dphi * weight a = 0. b = 0. c = 0. if sum_weight > 0: jet.ptd = math.sqrt(sum_weight) / sum_pt ave_deta = sum_deta / sum_weight ave_dphi = sum_dphi / sum_weight ave_deta2 = sum_deta2 / sum_weight ave_dphi2 = sum_dphi2 / sum_weight a = ave_deta2 - ave_deta * ave_deta b = ave_dphi2 - ave_dphi * ave_dphi c = -(sum_detadphi / sum_weight - ave_deta * ave_dphi) else: jet.ptd = 0. delta = math.sqrt(math.fabs((a - b) * (a - b) + 4. * c * c)) if a + b - delta > 0: jet.axis2 = -math.log(math.sqrt(0.5 * (a + b - delta))) else: jet.axis2 = -1. def jetFlavour(self, event): def isFlavour(x, f): id = abs(x.pdgId()) if id > 999: return (id / 1000) % 10 == f if id > 99: return (id / 100) % 10 == f return id % 100 == f self.bqObjects = [ p for p in event.genParticles if (p.status() == 2 and isFlavour(p, 5)) ] self.cqObjects = [ p for p in event.genParticles if (p.status() == 2 and isFlavour(p, 4)) ] self.partons = [ p for p in event.genParticles if ((p.status() == 23 or p.status() == 3) and abs(p.pdgId()) > 0 and (abs(p.pdgId()) in [1, 2, 3, 4, 5, 21])) ] match = matchObjectCollection2(self.cleanJetsAll, self.partons, deltaRMax=0.3) for jet in self.cleanJetsAll: parton = match[jet] jet.partonId = (parton.pdgId() if parton != None else 0) jet.partonMotherId = (parton.mother(0).pdgId() if parton != None and parton.numberOfMothers() > 0 else 0) for jet in self.jets: (bmatch, dr) = bestMatch(jet, self.bqObjects) if dr < 0.4: jet.mcFlavour = 5 else: (cmatch, dr) = bestMatch(jet, self.cqObjects) if dr < 0.4: jet.mcFlavour = 4 else: jet.mcFlavour = 0 self.heaviestQCDFlavour = 5 if len( self.bqObjects) else (4 if len(self.cqObjects) else 1) def matchJets(self, event, jets): match = matchObjectCollection2(jets, event.genbquarks + event.genwzquarks, deltaRMax=0.3) for jet in jets: gen = match[jet] jet.mcParton = gen jet.mcMatchId = (gen.sourceId if gen != None else 0) jet.mcMatchFlav = (abs(gen.pdgId()) if gen != None else 0) match = matchObjectCollection2(jets, self.genJets, deltaRMax=0.3) for jet in jets: jet.mcJet = match[jet] def smearJets(self, event, jets): # https://twiki.cern.ch/twiki/bin/viewauth/CMS/TWikiTopRefSyst#Jet_energy_resolution for jet in jets: gen = jet.mcJet if gen != None: genpt, jetpt, aeta = gen.pt(), jet.pt(), abs(jet.eta()) # from https://twiki.cern.ch/twiki/bin/view/CMS/JetResolution factor = 1.052 + self.shiftJER * math.hypot(0.012, 0.062) if aeta > 2.3: factor = 1.288 + self.shiftJER * math.hypot(0.127, 0.154) elif aeta > 1.7: factor = 1.134 + self.shiftJER * math.hypot(0.035, 0.066) elif aeta > 1.1: factor = 1.096 + self.shiftJER * math.hypot(0.017, 0.063) elif aeta > 0.5: factor = 1.057 + self.shiftJER * math.hypot(0.012, 0.056) ptscale = max(0.0, (jetpt + (factor - 1) * (jetpt - genpt)) / jetpt) #print "get with pt %.1f (gen pt %.1f, ptscale = %.3f)" % (jetpt,genpt,ptscale) jet.deltaMetFromJetSmearing = [ -(ptscale - 1) * jet.rawFactor() * jet.px(), -(ptscale - 1) * jet.rawFactor() * jet.py() ] if ptscale != 0: jet.setP4(jet.p4() * ptscale) # leave the uncorrected unchanged for sync jet._rawFactorMultiplier *= (1.0 / ptscale) if ptscale != 0 else 1
class monoXPuppiJetAnalyzer(Analyzer): """Taken from RootTools.JetAnalyzer, simplified, modified, added corrections """ @staticmethod def puppiCorrector(pJet): #self, pJet): correctionFilePath = "%s/src/CMGTools//MonoXAnalysis/cfg/puppiCorr.root" % os.environ[ 'CMSSW_BASE'] #print "---- Correction file for PUPPI: ",correctionFilePath correctionFile = TFile.Open(correctionFilePath) puppisd_corrGEN = correctionFile.Get("puppiJECcorr_gen") puppisd_corrRECO_cen = correctionFile.Get("puppiJECcorr_reco_0eta1v3") puppisd_corrRECO_for = correctionFile.Get( "puppiJECcorr_reco_1v3eta2v5") genCorr = 1. recoCorr = 1. totalWeight = 1. genCorr = puppisd_corrGEN.Eval(pJet.pt()) if (math.fabs(pJet.eta()) <= 1.3): recoCorr = puppisd_corrRECO_cen.Eval(pJet.pt()) else: if (math.fabs(pJet.eta()) > 1.3): recoCorr = puppisd_corrRECO_for.Eval(pJet.pt()) totalWeight = genCorr * recoCorr pJet_massCorr = totalWeight * pJet.mass() return pJet_massCorr def __init__(self, cfg_ana, cfg_comp, looperName): super(monoXPuppiJetAnalyzer, self).__init__(cfg_ana, cfg_comp, looperName) mcGT = cfg_ana.mcGT if hasattr(cfg_ana, 'mcGT') else "PHYS14_25_V2" dataGT = cfg_ana.dataGT if hasattr(cfg_ana, 'dataGT') else "GR_70_V2_AN1" self.shiftJEC = self.cfg_ana.shiftJEC if hasattr( self.cfg_ana, 'shiftJEC') else 0 self.recalibrateJets = self.cfg_ana.recalibrateJets self.addJECShifts = self.cfg_ana.addJECShifts if hasattr( self.cfg_ana, 'addJECShifts') else 0 if self.recalibrateJets == "MC": self.recalibrateJets = self.cfg_comp.isMC elif self.recalibrateJets == "Data": self.recalibrateJets = not self.cfg_comp.isMC elif self.recalibrateJets not in [True, False]: raise RuntimeError, "recalibrateJets must be any of { True, False, 'MC', 'Data' }, while it is %r " % self.recalibrateJets self.doJEC = self.recalibrateJets or (self.shiftJEC != 0) or self.addJECShifts if self.doJEC: doResidual = getattr(cfg_ana, 'applyL2L3Residual', 'Data') if doResidual == "MC": doResidual = self.cfg_comp.isMC elif doResidual == "Data": doResidual = not self.cfg_comp.isMC elif doResidual not in [True, False]: raise RuntimeError, "If specified, applyL2L3Residual must be any of { True, False, 'MC', 'Data'(default)}" GT = getattr(cfg_comp, 'jecGT', mcGT if self.cfg_comp.isMC else dataGT) # instantiate the jet re-calibrator self.jetReCalibrator = JetReCalibrator(GT, cfg_ana.recalibrationType, doResidual, cfg_ana.jecPath) self.jetLepDR = self.cfg_ana.jetLepDR if hasattr( self.cfg_ana, 'jetLepDR') else 0.5 self.lepPtMin = self.cfg_ana.minLepPt if hasattr( self.cfg_ana, 'minLepPt') else -1 def declareHandles(self): super(monoXPuppiJetAnalyzer, self).declareHandles() self.handles['jets'] = AutoHandle(self.cfg_ana.jetCol, 'std::vector<pat::Jet>') self.handles['rho'] = AutoHandle(self.cfg_ana.rho, 'double') def beginLoop(self, setup): super(monoXPuppiJetAnalyzer, self).beginLoop(setup) 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 allJets = map(Jet, self.handles['jets'].product()) self.deltaMetFromJEC = [0., 0.] self.type1METCorr = [0., 0., 0.] 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) ## Apply jet selection event.puppiJets = [] event.puppiJetsNoID = [] event.puppiAK08Jets = [] firstJet = True #global jetPuppiAk08 for jet in allJets: if self.testJetNoID(jet): event.puppiJetsNoID.append(jet) if self.testJetID(jet): # if firstJet: # jetPuppiAk08 = jet # print "FIRST JET!!!" # firstJet = False # else: # print "SECOND JET" # jetPuppiAk08+=jet jet.puppiMassCorrected = self.puppiCorrector(jet) event.puppiJets.append(jet) #jetPuppiAk08.puppiMassCorrected = self.puppiCorrector(jetPuppiAk08) #event.puppiAK08Jets.append(jetPuppiAk08) ## 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.puppijet = lep.jet else: lep.puppijet = jet def testJetID(self, jet): #jet.puJetIdPassed = jet.puJetId() jet.pfJetIdPassed = jet.jetID('POG_PFID_Loose') if self.cfg_ana.relaxJetId: return True else: return jet.pfJetIdPassed #return jet.pfJetIdPassed and (jet.puJetIdPassed or not(self.doPuId)) def testJetNoID(self, jet): return jet.pt() > self.cfg_ana.jetPt and \ abs( jet.eta() ) < self.cfg_ana.jetEta
class AdditionalBoost( Analyzer ): def __init__(self, cfg_ana, cfg_comp, looperName): super(AdditionalBoost,self).__init__(cfg_ana, cfg_comp, looperName) # Get the config parameters skip_ca15 = cfg_ana.skip_ca15 if hasattr(cfg_ana,'skip_ca15') else False GT = cfg_ana.GT if hasattr(cfg_ana,'GT') else "Summer15_25nsV6_DATA" jecPath = cfg_ana.jecPath if hasattr(cfg_ana,'jecPath') else "." isMC = cfg_ana.isMC if hasattr(cfg_ana,'isMC') else False self.skip_ca15 = skip_ca15 # Prepare re-calibrator recalibrationType = "AK8PFchs" # Following instructions from: # https://twiki.cern.ch/twiki/bin/viewauth/CMS/JetWtagging # L2L3 if isMC: doResidual = False # L2L3 Residual else: doResidual = True self.jetReCalibrator = JetReCalibrator(GT, recalibrationType, doResidual, jecPath, skipLevel1=True) def declareHandles(self): super(AdditionalBoost, self).declareHandles() self.handles['rho'] = AutoHandle( ('fixedGridRhoFastjetAll',""), 'double' ) self.handles['ak08'] = AutoHandle( ("slimmedJetsAK8",""), "std::vector<pat::Jet>") self.handles['ak08pruned'] = AutoHandle( ("ak08PFPrunedJetsCHS","","EX"), "std::vector<reco::BasicJet>") self.handles['ak08prunedsubjets'] = AutoHandle( ("ak08PFPrunedJetsCHS","SubJets","EX"), "std::vector<reco::PFJet>") self.handles['ak08softdropsubjets'] = AutoHandle( ("slimmedJetsAK8PFCHSSoftDropPacked","SubJets"), "std::vector<pat::Jet>") self.handles['ak08bbtag'] = AutoHandle( ("slimmedJetsAK8pfBoostedDoubleSecondaryVertexBJetTags","","EX"), "edm::AssociationVector<edm::RefToBaseProd<reco::Jet>,vector<float>,edm::RefToBase<reco::Jet>,unsigned int,edm::helper::AssociationIdenticalKeyReference>") self.handles['ak08prunedsubjetbtag'] = AutoHandle( ("ak08PFPrunedJetsCHSpfCombinedInclusiveSecondaryVertexV2BJetTags","","EX"), "edm::AssociationVector<edm::RefToBaseProd<reco::Jet>,vector<float>,edm::RefToBase<reco::Jet>,unsigned int,edm::helper::AssociationIdenticalKeyReference>") self.handles['ak08ipTagInfos'] = AutoHandle( ("slimmedJetsAK8ImpactParameterTagInfos","","EX"), "vector<reco::IPTagInfo<vector<edm::Ptr<reco::Candidate> >,reco::JetTagInfo> >") self.handles['ak08svTagInfos'] = AutoHandle( ("slimmedJetsAK8pfInclusiveSecondaryVertexFinderTagInfos", "","EX"), "vector<reco::TemplatedSecondaryVertexTagInfo<reco::IPTagInfo<vector<edm::Ptr<reco::Candidate> >,reco::JetTagInfo>,reco::VertexCompositePtrCandidate> >") self.handles['ak08muonTagInfos'] = AutoHandle( ("slimmedJetsAK8softPFMuonsTagInfos", "","EX"), "vector<reco::TemplatedSoftLeptonTagInfo<edm::Ptr<reco::Candidate> > >") self.handles['ak08elecTagInfos'] = AutoHandle( ("slimmedJetsAK8softPFElectronsTagInfos", "","EX"), "vector<reco::TemplatedSoftLeptonTagInfo<edm::Ptr<reco::Candidate> > >") if not self.skip_ca15: self.handles['ca15ipTagInfos'] = AutoHandle( ("ca15PFJetsCHSImpactParameterTagInfos","","EX"), "vector<reco::IPTagInfo<vector<edm::Ptr<reco::Candidate> >,reco::JetTagInfo> >") self.handles['ca15svTagInfos'] = AutoHandle( ("ca15PFJetsCHSpfInclusiveSecondaryVertexFinderTagInfos", "","EX"), "vector<reco::TemplatedSecondaryVertexTagInfo<reco::IPTagInfo<vector<edm::Ptr<reco::Candidate> >,reco::JetTagInfo>,reco::VertexCompositePtrCandidate> >") self.handles['ca15muonTagInfos'] = AutoHandle( ("ca15PFJetsCHSsoftPFMuonsTagInfos", "","EX"), "vector<reco::TemplatedSoftLeptonTagInfo<edm::Ptr<reco::Candidate> > >") self.handles['ca15elecTagInfos'] = AutoHandle( ("ca15PFJetsCHSsoftPFElectronsTagInfos", "","EX"), "vector<reco::TemplatedSoftLeptonTagInfo<edm::Ptr<reco::Candidate> > >") self.handles['ca15ungroomed'] = AutoHandle( ("ca15PFJetsCHS","","EX"), "std::vector<reco::PFJet>") self.handles['ca15trimmed'] = AutoHandle( ("ca15PFTrimmedJetsCHS","","EX"), "std::vector<reco::PFJet>") self.handles['ca15softdrop'] = AutoHandle( ("ca15PFSoftdropJetsCHS","","EX"), "std::vector<reco::PFJet>") self.handles['ca15softdropz2b1'] = AutoHandle( ("ca15PFSoftdropZ2B1JetsCHS","","EX"), "std::vector<reco::PFJet>") self.handles['ca15pruned'] = AutoHandle( ("ca15PFPrunedJetsCHS","","EX"), "std::vector<reco::BasicJet>") self.handles['ca15prunedsubjets'] = AutoHandle( ("ca15PFPrunedJetsCHS","SubJets","EX"), "std::vector<reco::PFJet>") self.handles['ca15tau1'] = AutoHandle( ("ca15PFJetsCHSNSubjettiness","tau1","EX"), "edm::ValueMap<float>") self.handles['ca15tau2'] = AutoHandle( ("ca15PFJetsCHSNSubjettiness","tau2","EX"), "edm::ValueMap<float>") self.handles['ca15tau3'] = AutoHandle( ("ca15PFJetsCHSNSubjettiness","tau3","EX"), "edm::ValueMap<float>") self.handles['ca15softdropz2b1tau1'] = AutoHandle( ("ca15PFSoftdropZ2B1JetsCHSNSubjettiness","tau1","EX"), "edm::ValueMap<float>") self.handles['ca15softdropz2b1tau2'] = AutoHandle( ("ca15PFSoftdropZ2B1JetsCHSNSubjettiness","tau2","EX"), "edm::ValueMap<float>") self.handles['ca15softdropz2b1tau3'] = AutoHandle( ("ca15PFSoftdropZ2B1JetsCHSNSubjettiness","tau3","EX"), "edm::ValueMap<float>") self.handles['httCandJets'] = AutoHandle( ("looseOptRHTT","","EX"), "std::vector<reco::BasicJet>") self.handles['httCandInfos'] = AutoHandle( ("looseOptRHTT","","EX"), "vector<reco::HTTTopJetTagInfo>") self.handles['httSubjetBtags'] = AutoHandle( ("looseOptRHTTpfCombinedInclusiveSecondaryVertexV2BJetTags","","EX"), "edm::AssociationVector<edm::RefToBaseProd<reco::Jet>,vector<float>,edm::RefToBase<reco::Jet>,unsigned int,edm::helper::AssociationIdenticalKeyReference>") self.handles['ca15bbtag'] = AutoHandle( ("ca15PFJetsCHSpfBoostedDoubleSecondaryVertexBJetTags","","EX"), "edm::AssociationVector<edm::RefToBaseProd<reco::Jet>,vector<float>,edm::RefToBase<reco::Jet>,unsigned int,edm::helper::AssociationIdenticalKeyReference>") self.handles['ca15prunedsubjetbtag'] = AutoHandle( ("ca15PFPrunedJetsCHSpfCombinedInclusiveSecondaryVertexV2BJetTags","","EX"), "edm::AssociationVector<edm::RefToBaseProd<reco::Jet>,vector<float>,edm::RefToBase<reco::Jet>,unsigned int,edm::helper::AssociationIdenticalKeyReference>") self.regressionsAK08={} print 'Initialize regression AK08' regressionAK08 = JetRegressionAK08('regAK08.weights.xml', 'Jet0RegressionAK08') #/afs/cern.ch/user/d/degrutto/scratch3/VHbbRun2/CMSSW_7_4_15/src/run2_boostedZH_161115/weights/TMVARegression_BDTG.weights.xml', 'Jet0RegressionAK08') self.regressionsAK08[0] = regressionAK08 def process(self, event): run = event.input.eventAuxiliary().id().run() lumi = event.input.eventAuxiliary().id().luminosityBlock() eventId = event.input.eventAuxiliary().id().event() self.readCollections( event.input ) # Will need who for jet calibration later rho = self.handles["rho"].product()[0] ######## # AK8 Jets from MiniAOD + Subjet btags ######## setattr(event, "ak08", map(PhysicsObject, self.handles["ak08"].product())) setattr(event, "ak0softdropsubjets", map(PhysicsObject, self.handles["ak08softdropsubjets"].product())) # bb-tag Output newtags = self.handles['ak08bbtag'].product() # Loop over jets for ij, jet in enumerate(getattr(event, "ak08")): # Fill bb-tag for i in xrange(len(newtags)) : if jet.physObj == newtags.key(i).get(): jet.bbtag = newtags.value(i) # bb-tag Inputs muonTagInfos = self.handles['ak08muonTagInfos'].product()[ij] elecTagInfos = self.handles['ak08elecTagInfos'].product()[ij] ipTagInfo = self.handles['ak08ipTagInfos'].product()[ij] svTagInfo = self.handles['ak08svTagInfos'].product()[ij] calcBBTagVariables(jet, muonTagInfos, elecTagInfos, ipTagInfo, svTagInfo, njettiness_08, maxSVDeltaRToJet = 0.7,) # end of loop over jets ######## # Ungroomed Fatjets + NSubjettiness + Hbb Tagging ######## for prefix in ["ca15"]: if self.skip_ca15 and ("ca15" in prefix): continue # N-Subjettiness tau1 = self.handles[prefix+'tau1'].product() tau2 = self.handles[prefix+'tau2'].product() tau3 = self.handles[prefix+'tau3'].product() # bb-tag Output newtags = self.handles[prefix+'bbtag'].product() # Four Vector setattr(event, prefix+"ungroomed", map(PhysicsObject, self.handles[prefix+'ungroomed'].product())) # Loop over jets for ij, jet in enumerate(getattr(event, prefix+"ungroomed")): # Fill N-Subjettiness jet.tau1 = tau1.get(ij) jet.tau2 = tau2.get(ij) jet.tau3 = tau3.get(ij) # Fill bb-tag for i in xrange(len(newtags)) : if jet.physObj == newtags.key(i).get(): jet.bbtag = newtags.value(i) # bb-tag Inputs muonTagInfos = self.handles['ca15muonTagInfos'].product()[ij] elecTagInfos = self.handles['ca15elecTagInfos'].product()[ij] ipTagInfo = self.handles['ca15ipTagInfos'].product()[ij] svTagInfo = self.handles['ca15svTagInfos'].product()[ij] calcBBTagVariables(jet, muonTagInfos, elecTagInfos, ipTagInfo, svTagInfo, njettiness_15, maxSVDeltaRToJet = 1.3) # end of loop over jets ######## # Softdrop Fatjets + NSubjettiness ######## for fj_name in ["ca15softdropz2b1"]: if self.skip_ca15 and ("ca15" in fj_name): continue # Set the four-vector setattr(event, fj_name, map(PhysicsObject, self.handles[fj_name].product())) # N-Subjettiness tau1 = self.handles[fj_name+'tau1'].product() tau2 = self.handles[fj_name+'tau2'].product() tau3 = self.handles[fj_name+'tau3'].product() # Loop over jets for ij, jet in enumerate(getattr(event, fj_name)): # Fill N-Subjettiness jet.tau1 = tau1.get(ij) jet.tau2 = tau2.get(ij) jet.tau3 = tau3.get(ij) # end of loop over jets ######## # Groomed Uncalibrated Fatjets ######## for fj_name in ['ak08pruned', 'ca15trimmed', 'ca15softdrop', 'ca15pruned']: if self.skip_ca15 and ("ca15" in fj_name): continue setattr(event, fj_name, map(PhysicsObject, self.handles[fj_name].product())) ######## # Groomed Fatjets to calibrate ######## pruned_cal_jets = [] for groomed_fj in self.handles['ak08pruned'].product(): # We need the closest ungroomed fatjet to get the JEC: # - Make a list of pairs: deltaR(ungroomed fj, groomed fj) for all ungroomed fatjets # - Sort by deltaR # - And take the minimum if len(getattr(event, "ak08")): closest_ung_fj_and_dr = sorted( [(ung_fj, deltaR2(ung_fj, groomed_fj)) for ung_fj in getattr(event, "ak08")], key=lambda x:x[1])[0] else: print "WARNING: No ungroomed fatjets found in event with groomed fatjet. Skipping" continue # Use the jet cone size for matching minimal_dr_groomed_ungroomed = 0.8 if closest_ung_fj_and_dr[1] > minimal_dr_groomed_ungroomed: print "WARNING: No ungroomed fatjet found close to groomed fatjet. Skipping" continue ungroomed_jet = Jet(closest_ung_fj_and_dr[0]) c = self.jetReCalibrator.getCorrection(ungroomed_jet, rho) # Need to do a deep-copy. Otherwise the original jet will be modified cal_groomed_fj = PhysicsObject(groomed_fj).__copy__() cal_groomed_fj.scaleEnergy(c) pruned_cal_jets.append(cal_groomed_fj) setattr(event, 'ak08prunedcal', pruned_cal_jets) ######## # AK08 Regression ####### self.regressionsAK08[0].evaluateRegressionAK08(event) ######## # Subjets ######## for fj_name in ['ak08pruned','ca15pruned']: if self.skip_ca15 and ("ca15" in fj_name): continue setattr(event, fj_name + "subjets", map(PhysicsObject, self.handles[fj_name+"subjets"].product())) newtags = self.handles[fj_name+'subjetbtag'].product() for i in xrange(0,len(newtags)) : for j in getattr(event, fj_name+"subjets"): if j.physObj == newtags.key(i).get(): j.btag = newtags.value(i) ######## # HEPTopTagger ######## if not self.skip_ca15: candJets = self.handles['httCandJets'].product() candInfos = self.handles['httCandInfos'].product() event.httCandidates = map(PhysicsObject, candJets) sjbtags = self.handles['httSubjetBtags'].product() for i in xrange(0, len(candJets)): event.httCandidates[i].fRec = candInfos[i].properties().fRec event.httCandidates[i].Ropt = candInfos[i].properties().Ropt event.httCandidates[i].RoptCalc = candInfos[i].properties().RoptCalc event.httCandidates[i].ptForRoptCalc = candInfos[i].properties().ptForRoptCalc # HTT return the subjet-pair closest to the W-mass as W-subjets # Could be improved by b-tagging if we run into a problem [sj_w1, sj_w2, sj_nonw] = [con.__deref__() for con in candJets[i].getJetConstituents() if not con.isNull()] event.httCandidates[i].sjW1pt = sj_w1.pt() event.httCandidates[i].sjW1eta = sj_w1.eta() event.httCandidates[i].sjW1phi = sj_w1.phi() event.httCandidates[i].sjW1mass = sj_w1.mass() # Get the correct b-tag for ib in xrange(0, len(sjbtags)) : if sj_w1 == sjbtags.key(ib).get(): event.httCandidates[i].sjW1btag = sjbtags.value(ib) event.httCandidates[i].sjW2pt = sj_w2.pt() event.httCandidates[i].sjW2eta = sj_w2.eta() event.httCandidates[i].sjW2phi = sj_w2.phi() event.httCandidates[i].sjW2mass = sj_w2.mass() # Get the correct b-tag for ib in xrange(0, len(sjbtags)) : if sj_w2 == sjbtags.key(ib).get(): event.httCandidates[i].sjW2btag = sjbtags.value(ib) event.httCandidates[i].sjNonWpt = sj_nonw.pt() event.httCandidates[i].sjNonWeta = sj_nonw.eta() event.httCandidates[i].sjNonWphi = sj_nonw.phi() event.httCandidates[i].sjNonWmass = sj_nonw.mass() # Get the correct b-tag for ib in xrange(0, len(sjbtags)) : if sj_nonw == sjbtags.key(ib).get(): event.httCandidates[i].sjNonWbtag = sjbtags.value(ib) return True
class monoXFatJetAnalyzer(Analyzer): """Taken from RootTools.JetAnalyzer, simplified, modified, added corrections """ def __init__(self, cfg_ana, cfg_comp, looperName): super(monoXFatJetAnalyzer, self).__init__(cfg_ana, cfg_comp, looperName) mcGT = cfg_ana.mcGT if hasattr(cfg_ana, 'mcGT') else "PHYS14_25_V2" dataGT = cfg_ana.dataGT if hasattr(cfg_ana, 'dataGT') else "GR_70_V2_AN1" self.shiftJEC = self.cfg_ana.shiftJEC if hasattr( self.cfg_ana, 'shiftJEC') else 0 self.recalibrateJets = self.cfg_ana.recalibrateJets self.addJECShifts = self.cfg_ana.addJECShifts if hasattr( self.cfg_ana, 'addJECShifts') else 0 if self.recalibrateJets == "MC": self.recalibrateJets = self.cfg_comp.isMC elif self.recalibrateJets == "Data": self.recalibrateJets = not self.cfg_comp.isMC elif self.recalibrateJets not in [True, False]: raise RuntimeError, "recalibrateJets must be any of { True, False, 'MC', 'Data' }, while it is %r " % self.recalibrateJets self.doJEC = self.recalibrateJets or (self.shiftJEC != 0) or self.addJECShifts if self.doJEC: doResidual = getattr(cfg_ana, 'applyL2L3Residual', 'Data') if doResidual == "MC": doResidual = self.cfg_comp.isMC elif doResidual == "Data": doResidual = not self.cfg_comp.isMC elif doResidual not in [True, False]: raise RuntimeError, "If specified, applyL2L3Residual must be any of { True, False, 'MC', 'Data'(default)}" GT = getattr(cfg_comp, 'jecGT', mcGT if self.cfg_comp.isMC else dataGT) # instantiate the jet re-calibrator self.jetReCalibrator = JetReCalibrator(GT, cfg_ana.recalibrationType, doResidual, cfg_ana.jecPath) self.jetLepDR = self.cfg_ana.jetLepDR if hasattr( self.cfg_ana, 'jetLepDR') else 0.5 self.lepPtMin = self.cfg_ana.minLepPt if hasattr( self.cfg_ana, 'minLepPt') else -1 def declareHandles(self): super(monoXFatJetAnalyzer, self).declareHandles() self.handles['jets'] = AutoHandle(self.cfg_ana.jetCol, 'std::vector<pat::Jet>') self.handles['rho'] = AutoHandle(self.cfg_ana.rho, 'double') def beginLoop(self, setup): super(monoXFatJetAnalyzer, self).beginLoop(setup) 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 allJets = map(Jet, self.handles['jets'].product()) self.deltaMetFromJEC = [0., 0.] self.type1METCorr = [0., 0., 0.] 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) ## Apply jet selection event.fatJets = [] event.fatJetsNoID = [] for jet in allJets: if self.testJetNoID(jet): event.fatJetsNoID.append(jet) if self.testJetID(jet): event.fatJets.append(jet) ## 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.fatjet = lep.jet else: lep.fatjet = jet def testJetID(self, jet): #jet.puJetIdPassed = jet.puJetId() jet.pfJetIdPassed = jet.jetID('POG_PFID_Loose') if self.cfg_ana.relaxJetId: return True else: return jet.pfJetIdPassed #return jet.pfJetIdPassed and (jet.puJetIdPassed or not(self.doPuId)) def testJetNoID(self, jet): return jet.pt() > self.cfg_ana.jetPt and \ abs( jet.eta() ) < self.cfg_ana.jetEta
class JetAnalyzer( Analyzer ): """Taken from RootTools.JetAnalyzer, simplified, modified, added corrections """ def __init__(self, cfg_ana, cfg_comp, looperName): super(JetAnalyzer,self).__init__(cfg_ana, cfg_comp, looperName) mcGT = cfg_ana.mcGT if hasattr(cfg_ana,'mcGT') else "PHYS14_25_V2" dataGT = cfg_ana.dataGT if hasattr(cfg_ana,'dataGT') else "GR_70_V2_AN1" self.shiftJEC = self.cfg_ana.shiftJEC if hasattr(self.cfg_ana, 'shiftJEC') else 0 self.recalibrateJets = self.cfg_ana.recalibrateJets self.addJECShifts = self.cfg_ana.addJECShifts if self.recalibrateJets == "MC" : self.recalibrateJets = self.cfg_comp.isMC elif self.recalibrateJets == "Data": self.recalibrateJets = not self.cfg_comp.isMC elif self.recalibrateJets not in [True,False]: raise RuntimeError, "recalibrateJets must be any of { True, False, 'MC', 'Data' }, while it is %r " % self.recalibrateJets self.doJEC = self.recalibrateJets or (self.shiftJEC != 0) or self.addJECShifts if self.doJEC: doResidual = getattr(cfg_ana, 'applyL2L3Residual', 'Data') if doResidual == "MC": doResidual = self.cfg_comp.isMC elif doResidual == "Data": doResidual = not self.cfg_comp.isMC elif doResidual not in [True,False]: raise RuntimeError, "If specified, applyL2L3Residual must be any of { True, False, 'MC', 'Data'(default)}" if self.cfg_comp.isMC: self.jetReCalibrator = JetReCalibrator(mcGT,self.cfg_ana.recalibrationType, doResidual, cfg_ana.jecPath, calculateSeparateCorrections=getattr(cfg_ana,"calculateSeparateCorrections",False)) else: self.jetReCalibrator = JetReCalibrator(dataGT,self.cfg_ana.recalibrationType, doResidual, cfg_ana.jecPath, calculateSeparateCorrections=getattr(cfg_ana,"calculateSeparateCorrections",False)) self.doPuId = getattr(self.cfg_ana, 'doPuId', True) self.jetLepDR = getattr(self.cfg_ana, 'jetLepDR', 0.4) self.jetLepArbitration = getattr(self.cfg_ana, 'jetLepArbitration', lambda jet,lepton: lepton) self.lepPtMin = getattr(self.cfg_ana, 'minLepPt', -1) self.lepSelCut = getattr(self.cfg_ana, 'lepSelCut', lambda lep : True) self.jetGammaDR = getattr(self.cfg_ana, 'jetGammaDR', 0.4) if(self.cfg_ana.doQG): qgdefname="{CMSSW_BASE}/src/PhysicsTools/Heppy/data/pdfQG_AK4chs_antib_13TeV_v1.root" self.qglcalc = QGLikelihoodCalculator(getattr(self.cfg_ana,"QGpath",qgdefname).format(CMSSW_BASE= os.environ['CMSSW_BASE'])) if not hasattr(self.cfg_ana ,"collectionPostFix"):self.cfg_ana.collectionPostFix="" def declareHandles(self): super(JetAnalyzer, self).declareHandles() self.handles['jets'] = AutoHandle( self.cfg_ana.jetCol, 'std::vector<pat::Jet>' ) self.handles['genJet'] = AutoHandle( self.cfg_ana.genJetCol, 'vector<reco::GenJet>' ) self.shiftJER = self.cfg_ana.shiftJER if hasattr(self.cfg_ana, 'shiftJER') else 0 self.handles['rho'] = AutoHandle( self.cfg_ana.rho, 'double' ) def beginLoop(self, setup): super(JetAnalyzer,self).beginLoop(setup) 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.] # 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) if self.addJECShifts: for delta, shift in [(1.0, "JECUp"), (0.0, ""), (-1.0, "JECDown")]: for j1 in allJets: corr = self.jetReCalibrator.getCorrection(j1, rho, delta, self.deltaMetFromJEC) setattr(j1, "corr"+shift, corr) 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: 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 abs(jet.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) else: self.jets.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 ] ## 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: 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,"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,"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 def testJetID(self, jet): jet.puJetIdPassed = jet.puJetId() jet.pfJetIdPassed = jet.jetID('POG_PFID_Loose') if self.cfg_ana.relaxJetId: return True else: return jet.pfJetIdPassed and (jet.puJetIdPassed or not(self.doPuId)) def testJetNoID( self, jet ): # 2 is loose pile-up jet id return jet.pt() > self.cfg_ana.jetPt and \ abs( jet.eta() ) < self.cfg_ana.jetEta; def jetFlavour(self,event): def isFlavour(x,f): id = abs(x.pdgId()) if id > 999: return (id/1000)%10 == f if id > 99: return (id/100)%10 == f return id % 100 == f self.bqObjects = [ p for p in event.genParticles if (p.status() == 2 and isFlavour(p,5)) ] self.cqObjects = [ p for p in event.genParticles if (p.status() == 2 and isFlavour(p,4)) ] self.partons = [ p for p in event.genParticles if ((p.status() == 23 or p.status() == 3) and abs(p.pdgId())>0 and (abs(p.pdgId()) in [1,2,3,4,5,21]) ) ] match = matchObjectCollection2(self.cleanJetsAll, self.partons, deltaRMax = 0.3) for jet in self.cleanJetsAll: parton = match[jet] jet.partonId = (parton.pdgId() if parton != None else 0) jet.partonMotherId = (parton.mother(0).pdgId() if parton != None and parton.numberOfMothers()>0 else 0) for jet in self.jets: (bmatch, dr) = bestMatch(jet, self.bqObjects) if dr < 0.4: jet.mcFlavour = 5 else: (cmatch, dr) = bestMatch(jet, self.cqObjects) if dr < 0.4: jet.mcFlavour = 4 else: jet.mcFlavour = 0 self.heaviestQCDFlavour = 5 if len(self.bqObjects) else (4 if len(self.cqObjects) else 1); def matchJets(self, event, jets): match = matchObjectCollection2(jets, event.genbquarks + event.genwzquarks, deltaRMax = 0.3) for jet in jets: gen = match[jet] jet.mcParton = gen jet.mcMatchId = (gen.sourceId if gen != None else 0) jet.mcMatchFlav = (abs(gen.pdgId()) if gen != None else 0) match = matchObjectCollection2(jets, self.genJets, deltaRMax = 0.3) for jet in jets: jet.mcJet = match[jet] def smearJets(self, event, jets): # https://twiki.cern.ch/twiki/bin/viewauth/CMS/TWikiTopRefSyst#Jet_energy_resolution for jet in jets: gen = jet.mcJet if gen != None: genpt, jetpt, aeta = gen.pt(), jet.pt(), abs(jet.eta()) # from https://twiki.cern.ch/twiki/bin/view/CMS/JetResolution factor = 1.052 + self.shiftJER*math.hypot(0.012,0.062); if aeta > 2.3: factor = 1.288 + self.shiftJER*math.hypot(0.127,0.154) elif aeta > 1.7: factor = 1.134 + self.shiftJER*math.hypot(0.035,0.066) elif aeta > 1.1: factor = 1.096 + self.shiftJER*math.hypot(0.017,0.063) elif aeta > 0.5: factor = 1.057 + self.shiftJER*math.hypot(0.012,0.056) ptscale = max(0.0, (jetpt + (factor-1)*(jetpt-genpt))/jetpt) #print "get with pt %.1f (gen pt %.1f, ptscale = %.3f)" % (jetpt,genpt,ptscale) jet.deltaMetFromJetSmearing = [ -(ptscale-1)*jet.rawFactor()*jet.px(), -(ptscale-1)*jet.rawFactor()*jet.py() ] if ptscale != 0: jet.setP4(jet.p4()*ptscale) # leave the uncorrected unchanged for sync jet._rawFactorMultiplier *= (1.0/ptscale) if ptscale != 0 else 1
class JetAnalyzer(Analyzer): """Analyze jets. Copied from heppy examples and edit to not rely on heppy examples. This analyzer filters the jets that do not correspond to the leptons stored in event.selectedLeptons, and puts in the event: - jets: all jets passing the pt and eta cuts - cleanJets: the collection of jets away from the leptons - cleanBJets: the jets passing testBJet, and away from the leptons Example configuration: jetAna = cfg.Analyzer( 'JetAnalyzer', jetCol = 'slimmedJets' # cmg jet input collection # pt threshold jetPt = 30, # eta range definition jetEta = 5.0, # seed for the btag scale factor btagSFseed = 0xdeadbeef, # if True, the PF and PU jet ID are not applied, and the jets get flagged relaxJetId = False, relaxPuJetId = False, ) """ def __init__(self, cfg_ana, cfg_comp, looperName): super(JetAnalyzer, self).__init__(cfg_ana, cfg_comp, looperName) self.btagSF = BTagSF(seed=getattr(self.cfg_ana, 'btagSFseed', 0), mc_eff_file=getattr(self.cfg_ana, 'mc_eff_file'), sf_file=getattr(self.cfg_ana, 'sf_file'), wp=getattr(self.cfg_ana, 'btag_wp', 'medium'), ) self.recalibrateJets = getattr(cfg_ana, 'recalibrateJets', False) mcGT = getattr(cfg_ana, 'mcGT', 'Spring16_25nsV6_MC') dataGT = getattr(cfg_ana, 'dataGT', 'Spring16_25nsV6_DATA') if self.recalibrateJets: doResidual = getattr(cfg_ana, 'applyL2L3Residual', 'Data') if doResidual == "MC": doResidual = self.cfg_comp.isMC elif doResidual == "Data": doResidual = not self.cfg_comp.isMC elif doResidual not in [True, False]: raise RuntimeError, "If specified, applyL2L3Residual must be any of { True, False, 'MC', 'Data'(default)}" GT = getattr(cfg_comp, 'jecGT', mcGT if self.cfg_comp.isMC else dataGT) # instantiate the jet re-calibrator self.jetReCalibrator = JetReCalibrator(GT, 'AK4PFchs', doResidual, jecPath="%s/src/CMGTools/RootTools/data/jec" % os.environ['CMSSW_BASE']) def declareHandles(self): super(JetAnalyzer, self).declareHandles() # self.handles['jets'] = AutoHandle(self.cfg_ana.jetCol, 'std::vector<pat::Jet>') # try to use recomputed jets, but if it fails, resort to normal slimmedJets in miniAODs self.handles['jets'] = AutoHandle(self.cfg_ana.jetCol, 'std::vector<pat::Jet>', mayFail=True, fallbackLabel='slimmedJets', lazy=False) if self.cfg_comp.isMC: self.mchandles['genParticles'] = AutoHandle('packedGenParticles', 'std::vector<pat::PackedGenParticle>') self.mchandles['genJets' ] = AutoHandle('slimmedGenJets' , 'std::vector<reco::GenJet>' ) def beginLoop(self, setup): super(JetAnalyzer, self).beginLoop(setup) self.counters.addCounter('jets') count = self.counters.counter('jets') count.register('all events') 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 def jerCorrection(self, jet): ''' Adds JER correction according to first method at https://twiki.cern.ch/twiki/bin/view/CMS/JetResolution Requires some attention when genJet matching fails. ''' if not hasattr(jet, 'matchedGenJet'): return #import pdb; pdb.set_trace() corrections = [0.052, 0.057, 0.096, 0.134, 0.288] maxEtas = [0.5, 1.1, 1.7, 2.3, 5.0] eta = abs(jet.eta()) for i, maxEta in enumerate(maxEtas): if eta < maxEta: pt = jet.pt() deltaPt = (pt - jet.matchedGenJet.pt()) * corrections[i] totalScale = (pt + deltaPt) / pt if totalScale < 0.: totalScale = 0. jet.scaleEnergy(totalScale) break def jesCorrection(self, jet, scale=0.): ''' Adds JES correction in number of sigmas (scale) ''' # Do nothing if nothing to change if scale == 0.: return unc = jet.uncOnFourVectorScale() totalScale = 1. + scale * unc if totalScale < 0.: totalScale = 0. jet.scaleEnergy(totalScale) def testJetID(self, jet): jet.puJetIdPassed = jet.puJetId() jet.pfJetIdPassed = jet.jetID("POG_PFID_Tight") puJetId = self.cfg_ana.relaxPuJetId or jet.puJetIdPassed pfJetId = self.cfg_ana.relaxJetId or jet.pfJetIdPassed return puJetId and pfJetId def testJet(self, jet): pt = jet.pt() if hasattr(self.cfg_ana, 'ptUncTolerance') and self.cfg_ana.ptUncTolerance: pt = max(pt, pt * jet.corrJECUp/jet.corr, pt * jet.corrJECDown/jet.corr) return pt > self.cfg_ana.jetPt and \ abs( jet.eta() ) < self.cfg_ana.jetEta and \ self.testJetID(jet) def _prepareDeepJet(self, jet, year, wp): jet.deepflavour_prob_b = jet.btag('pfDeepFlavourJetTags:probb') jet.deepflavour_prob_bb = jet.btag('pfDeepFlavourJetTags:probbb') jet.deepflavour_prob_lepb = jet.btag('pfDeepFlavourJetTags:problepb') jet.deepflavour_score = jet.deepflavour_prob_b + \ jet.deepflavour_prob_bb + \ jet.deepflavour_prob_lepb jet.pass_deepflavour = jet.deepflavour_score >= deepflavour_wp[year][wp] def testBJet(self, jet, year, wp, final_state): ''' Test DeepFlavour including scale factors ''' # Use the following once we start applying data-MC scale factors: jet.btagFlag = self.btagSF.isBTagged( pt = jet.pt(), eta = jet.eta(), deepjet = jet.deepflavour_score, jetflavor = abs(jet.partonFlavour()), is_data = not self.cfg_comp.isMC, deepjet_cut = deepflavour_wp[year][wp], final_state = final_state, ) return self.testJet(jet) and \ abs(jet.eta()) < 2.4 and \ jet.btagFlag and \ self.testJetID(jet)
class JetAnalyzer(Analyzer): """Analyze jets. Copied from heppy examples and edit to not rely on heppy examples. This analyzer filters the jets that do not correspond to the leptons stored in event.selectedLeptons, and puts in the event: - jets: all jets passing the pt and eta cuts - cleanJets: the collection of jets away from the leptons - cleanBJets: the jets passing testBJet, and away from the leptons Example configuration: jetAna = cfg.Analyzer( 'JetAnalyzer', jetCol = 'slimmedJets' # cmg jet input collection # pt threshold jetPt = 30, # eta range definition jetEta = 5.0, # seed for the btag scale factor btagSFseed = 0xdeadbeef, # if True, the PF and PU jet ID are not applied, and the jets get flagged relaxJetId = False, relaxPuJetId = False, ) """ def __init__(self, cfg_ana, cfg_comp, looperName): super(JetAnalyzer, self).__init__(cfg_ana, cfg_comp, looperName) self.btagSF = BTagSF(0, wp='medium') self.recalibrateJets = getattr(cfg_ana, 'recalibrateJets', False) mcGT = getattr(cfg_ana, 'mcGT', 'Spring16_25nsV6_MC') dataGT = getattr(cfg_ana, 'dataGT', 'Spring16_25nsV6_DATA') if self.recalibrateJets: doResidual = getattr(cfg_ana, 'applyL2L3Residual', 'Data') if doResidual == "MC": doResidual = self.cfg_comp.isMC elif doResidual == "Data": doResidual = not self.cfg_comp.isMC elif doResidual not in [True, False]: raise RuntimeError, "If specified, applyL2L3Residual must be any of { True, False, 'MC', 'Data'(default)}" GT = getattr(cfg_comp, 'jecGT', mcGT if self.cfg_comp.isMC else dataGT) # instantiate the jet re-calibrator self.jetReCalibrator = JetReCalibrator( GT, 'AK4PFchs', doResidual, jecPath="%s/src/CMGTools/RootTools/data/jec" % os.environ['CMSSW_BASE']) def declareHandles(self): super(JetAnalyzer, self).declareHandles() self.handles['jets'] = AutoHandle(self.cfg_ana.jetCol, 'std::vector<pat::Jet>') if hasattr(self.cfg_ana, 'leptonCollections'): for coll, cms_type in self.cfg_ana.leptonCollections.items(): self.handles[coll] = AutoHandle(coll, cms_type) if self.cfg_comp.isMC: self.mchandles['genParticles'] = AutoHandle( 'packedGenParticles', 'std::vector<pat::PackedGenParticle>') self.mchandles['genJets'] = AutoHandle( 'slimmedGenJets', 'std::vector<reco::GenJet>') def beginLoop(self, setup): super(JetAnalyzer, self).beginLoop(setup) self.counters.addCounter('jets') count = self.counters.counter('jets') count.register('all events') count.register('at least 2 good jets') count.register('at least 2 clean jets') count.register('at least 1 b jet') count.register('at least 2 b jets') 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 def jerCorrection(self, jet): ''' Adds JER correction according to first method at https://twiki.cern.ch/twiki/bin/view/CMS/JetResolution Requires some attention when genJet matching fails. ''' if not hasattr(jet, 'matchedGenJet'): return #import pdb; pdb.set_trace() corrections = [0.052, 0.057, 0.096, 0.134, 0.288] maxEtas = [0.5, 1.1, 1.7, 2.3, 5.0] eta = abs(jet.eta()) for i, maxEta in enumerate(maxEtas): if eta < maxEta: pt = jet.pt() deltaPt = (pt - jet.matchedGenJet.pt()) * corrections[i] totalScale = (pt + deltaPt) / pt if totalScale < 0.: totalScale = 0. jet.scaleEnergy(totalScale) break def jesCorrection(self, jet, scale=0.): ''' Adds JES correction in number of sigmas (scale) ''' # Do nothing if nothing to change if scale == 0.: return unc = jet.uncOnFourVectorScale() totalScale = 1. + scale * unc if totalScale < 0.: totalScale = 0. jet.scaleEnergy(totalScale) def testJetID(self, jet): jet.puJetIdPassed = jet.puJetId() jet.pfJetIdPassed = jet.jetID("POG_PFID_Loose") puJetId = self.cfg_ana.relaxPuJetId or jet.puJetIdPassed pfJetId = self.cfg_ana.relaxJetId or jet.pfJetIdPassed return puJetId and pfJetId def testJet(self, jet): pt = jet.pt() if hasattr(self.cfg_ana, 'ptUncTolerance') and self.cfg_ana.ptUncTolerance: pt = max(pt, pt * jet.corrJECUp / jet.corr, pt * jet.corrJECDown / jet.corr) return pt > self.cfg_ana.jetPt and \ abs( jet.eta() ) < self.cfg_ana.jetEta and \ self.testJetID(jet) def testBJet(self, jet, csv_cut=0.8): # medium csv working point # https://twiki.cern.ch/twiki/bin/viewauth/CMS/BtagRecommendation74X jet.btagMVA = jet.btag('pfCombinedInclusiveSecondaryVertexV2BJetTags') # jet.btagFlag = jet.btagMVA > csv_cut # Use the following once we start applying data-MC scale factors: jet.btagFlag = self.btagSF.isBTagged( pt=jet.pt(), eta=jet.eta(), csv=jet.btag("pfCombinedInclusiveSecondaryVertexV2BJetTags"), jetflavor=abs(jet.partonFlavour()), is_data=not self.cfg_comp.isMC, csv_cut=csv_cut) return self.testJet(jet) and \ abs(jet.eta()) < 2.4 and \ jet.btagFlag and \ self.testJetID(jet)
class EventInterpretationBase( Analyzer ): def __init__(self, cfg_ana, cfg_comp, looperName): super(EventInterpretationBase,self).__init__(cfg_ana, cfg_comp, looperName) self.selectFat = self.cfg_ana.selectFat self.selectPairLNu = self.cfg_ana.selectPairLNu self.selectPairLL = self.cfg_ana.selectPairLL self.selectPairJJ = self.cfg_ana.selectPairJJ self.selectPairJJNuNu = self.cfg_ana.selectPairJJNuNu self.isMC =cfg_comp.isMC if hasattr(cfg_ana,'matchDR'): self.matchDR = cfg_ana.matchDR else: self.matchDR = 0.2 mcGT = cfg_ana.mcGT if hasattr(cfg_ana,'mcGT') else "PHYS14_25_V2" dataGT = cfg_ana.dataGT if hasattr(cfg_ana,'dataGT') else "GR_70_V2_AN1" self.shiftJEC = self.cfg_ana.shiftJEC if hasattr(self.cfg_ana, 'shiftJEC') else 0 self.recalibrateJets = self.cfg_ana.recalibrateJets if self.recalibrateJets == "MC" : self.recalibrateJets = self.cfg_comp.isMC elif self.recalibrateJets == "Data": self.recalibrateJets = not self.cfg_comp.isMC elif self.recalibrateJets not in [True,False]: raise RuntimeError, "recalibrateJets must be any of { True, False, 'MC', 'Data' }, while it is %r " % self.recalibrateJets self.doJEC = self.recalibrateJets or (self.shiftJEC != 0) if self.doJEC: if self.cfg_comp.isMC: if hasattr(self.cfg_comp,'globalTag'): self.jetReCalibrator = JetReCalibrator(self.cfg_comp.globalTag,self.cfg_ana.recalibrationType, False,cfg_ana.jecPath) self.jetReCalibratorFAT = JetReCalibrator(self.cfg_comp.globalTag,self.cfg_ana.recalibrationTypeFAT, False,cfg_ana.jecPath) else: self.jetReCalibrator = JetReCalibrator(mcGT,self.cfg_ana.recalibrationType, False,cfg_ana.jecPath) self.jetReCalibratorFAT = JetReCalibrator(mcGT,self.cfg_ana.recalibrationTypeFAT, False,cfg_ana.jecPath) else: if hasattr(self.cfg_comp,'globalTag'): self.jetReCalibrator = JetReCalibrator(self.cfg_comp.globalTag,self.cfg_ana.recalibrationType, True,cfg_ana.jecPath) self.jetReCalibratorFAT = JetReCalibrator(self.cfg_comp.globalTag,self.cfg_ana.recalibrationTypeFAT, True,cfg_ana.jecPath) else: self.jetReCalibrator = JetReCalibrator(dataGT,self.cfg_ana.recalibrationType, True,cfg_ana.jecPath) self.jetReCalibratorFAT = JetReCalibrator(dataGT,self.cfg_ana.recalibrationTypeFAT, True,cfg_ana.jecPath) self.attachBTag = cfg_ana.attachBTag if self.attachBTag: self.btagDiscriminator = cfg_ana.btagDiscriminator if hasattr(cfg_ana,'doSkim'): self.doSkim = cfg_ana.doSkim else: self.doSkim=False def declareHandles(self): super(EventInterpretationBase, self).declareHandles() self.handles['packed'] = AutoHandle( 'packedPFCandidates', 'std::vector<pat::PackedCandidate>' ) self.handles['rho'] = AutoHandle( self.cfg_ana.rho, 'double' ) if self.attachBTag or self.doSkim: self.handles['jets'] = AutoHandle( self.cfg_ana.standardJets, 'std::vector<pat::Jet>' ) self.handles['fatjets'] = AutoHandle( self.cfg_ana.fatJets, 'std::vector<pat::Jet>' ) self.handles['subjets'] = AutoHandle( (self.cfg_ana.subJets,'SubJets'), 'std::vector<pat::Jet>' ) def removeLeptonFootPrint(self,leptons,cands): toRemove=[] cList=list(cands) for lepton in leptons: for p in range(0,lepton.numberOfSourceCandidatePtrs()): index = lepton.sourceCandidatePtr(p).key() if not cands[index] in toRemove: toRemove.append(cands[index]) for r in toRemove: cList.remove(r) return cList def matchSubJets(self,jets,genquarks): for j in jets: for s in j.subjets_SD+j.subjets: s.mcquark = None s.matched=0 for g in genquarks: if deltaR(s.eta(),s.phi(),g.eta(),g.phi())<self.matchDR: s.matched=1 s.mcquark = g break; def skim(self,leptons,met): cleanedJets = [] for jet in self.handles['fatjets'].product(): overlap=False for lepton in leptons: if deltaR(jet.eta(),jet.phi(),lepton.eta(),lepton.phi())<0.8: overlap=True break; if not overlap: cleanedJets.append(jet) nJets = len(cleanedJets) nLeptons = len(leptons) if (nLeptons>0 and nJets>0) or nJets>1 or (nJets>0 and met.pt()>300): return True return False def makeFatJets(self,cands): toolboxFat = PyJetToolbox(cands) toolboxFat.setInterface(True,self.cfg_ana.ktPowerFat,self.cfg_ana.rFat) toolboxFat.setMassDrop(self.cfg_ana.massdrop) toolboxFat.setSubjets(True,'inc',self.cfg_ana.subjets) toolboxFat.setPruning(self.cfg_ana.prunning) toolboxFat.setNtau(True) if hasattr(self.cfg_ana,'softdrop_beta'): toolboxFat.setSoftDrop(self.cfg_ana.softdrop,self.cfg_ana.softdrop_beta,self.cfg_ana.softdrop_zeta) else: toolboxFat.setSoftDrop(self.cfg_ana.softdrop) # Lets cluster !! Fat jets first fatJets=toolboxFat.inclusiveJets(200.0,True) filtered = filter(self.selectFat,fatJets) ##Apply JECS in SoftDrop and Pruned: if self.jetReCalibratorFAT is not None: prunedJets=[] for j in fatJets: prunedJets.append(j.softDropJet) prunedJets.append(j.prunedJet) self.jetReCalibratorFAT.correctAll(prunedJets, self.rho, self.shiftJEC,True,False,[0.,0.],[0.,0.,0.]) for p in prunedJets: p.setRawFactor(1.0/p.corr) standardFatJets = self.handles['fatjets'].product() if self.attachBTag: for fat in filtered: for standardFat in standardFatJets: fat.btag = standardFat.bDiscriminator(self.btagDiscriminator) for j in fat.subjets_SD+fat.subjets: for standard in self.handles['subjets'].product(): if deltaR(j.eta(),j.phi(),standard.eta(),standard.phi())<0.1: j.btag = standard.bDiscriminator(self.btagDiscriminator) break return filtered def makeSatelliteJets(self,cands): toolbox = PyJetToolbox(cands) toolbox.setInterface(True,self.cfg_ana.ktPower,self.cfg_ana.r) toolbox.setMassDrop(False) toolbox.setSubjets(False,'inc',2) toolbox.setPruning(False) toolbox.setNtau(False) toolbox.setSoftDrop(False) unfiltered = toolbox.inclusiveJets(30.0,False) if self.attachBTag: for j in unfiltered: for standard in self.handles['jets'].product(): if deltaR(j.eta(),j.phi(),standard.eta(),standard.phi())<0.1: j.btag = standard.bDiscriminator(self.btagDiscriminator) break if self.jetReCalibrator is not None: self.jetReCalibrator.correctAll(unfiltered, self.rho, self.shiftJEC,True,False,[0.,0.],[0.,0.,0.]) for p in unfiltered: p.setRawFactor(1.0/p.corr) filtered=filter(lambda x: x.pt()>30, unfiltered) return filtered else: return unfiltered def removeJetFootPrint(self,jets,cands): toRemove=[] for j in jets: toRemove.extend(j.constituents) out=list(set(cands)-set(toRemove)) return out def topology(self,obj): #first clean nicely the jets from leptons and subjets objToClean=[] if abs(obj['pair'].leg1.pdgId())==23: objToClean.extend([obj['pair'].leg1.leg1,obj['pair'].leg1.leg2]) # print 'Z->ll', obj['pair'].leg1.leg1.pt(),obj['pair'].leg1.leg1.eta(),obj['pair'].leg1.leg1.phi(),obj['pair'].leg1.leg2.pt(),obj['pair'].leg1.leg2.eta(),obj['pair'].leg1.leg2.phi() if abs(obj['pair'].leg1.pdgId())==24: objToClean.extend([obj['pair'].leg1.leg1]) # print 'W->lnu', obj['pair'].leg1.leg1.pt(),obj['pair'].leg1.leg1.eta(),obj['pair'].leg1.leg1.phi() if abs(obj['pair'].leg1.pdgId())==1: objToClean.extend(obj['pair'].leg1.subjets) if abs(obj['pair'].leg2.pdgId())==23: objToClean.extend([obj['pair'].leg2.leg1,obj['pair'].leg2.leg2]) if abs(obj['pair'].leg2.pdgId())==24: objToClean.extend([obj['pair'].leg2.leg1]) if abs(obj['pair'].leg2.pdgId())==1: objToClean.extend(obj['pair'].leg2.subjets) # print 'jet', obj['pair'].leg2.pt(),obj['pair'].leg2.eta(),obj['pair'].leg2.phi() newJets=[] for j in obj['satelliteJets']: keep=True for c in objToClean: dr=deltaR(j.eta(),j.phi(),c.eta(),c.phi()) # print 'dr=',dr if dr<0.4: keep=False break if keep: # print 'filtered satellite jet',j.pt(),j.eta(),j.phi() newJets.append(j) obj['satelliteJets']=newJets if len(obj['satelliteJets'])<2: obj['vbfDEta'] = -1.0 obj['vbfMJJ'] = -1.0 else: j1 = obj['satelliteJets'][0] j2 = obj['satelliteJets'][1] obj['vbfDEta'] = abs(j1.eta()-j2.eta()) obj['vbfMJJ'] = (j1.p4()+j2.p4()).M() NL = 0 NM = 0 NT = 0 bestBTag=None minDR=1000.0 for s in obj['satelliteJets']: btag = s.bTag() if btag>0.423: NL=NL+1 DR=deltaR(obj['pair'].eta(),obj['pair'].phi(),s.eta(),s.phi()) if DR<minDR: bestBTag=s minDR=DR if btag>0.814: NM=NM+1 if btag>0.941: NT=NT+1 obj['nLooseBTags'] = NL obj['nMediumBTags'] = NM obj['nTightBTags'] = NT if bestBTag==None: obj['topMass'] = -1 else: obj['topMass'] = (bestBTag.p4()+s.p4()).mass() def beginLoop(self, setup): super(EventInterpretationBase,self).beginLoop(setup) def process(self, event): self.readCollections( event.input ) rho = float(self.handles['rho'].product()[0]) self.rho = rho
class AdditionalBoost( Analyzer ): def __init__(self, cfg_ana, cfg_comp, looperName): super(AdditionalBoost,self).__init__(cfg_ana, cfg_comp, looperName) # Get the config parameters skip_ca15 = cfg_ana.skip_ca15 if hasattr(cfg_ana,'skip_ca15') else False GT = cfg_ana.GT if hasattr(cfg_ana,'GT') else "Summer15_25nsV6_DATA" jecPath = cfg_ana.jecPath if hasattr(cfg_ana,'jecPath') else "." isMC = cfg_ana.isMC if hasattr(cfg_ana,'isMC') else False self.skip_ca15 = skip_ca15 # Prepare re-calibrator recalibrationTypeAK8 = "AK8PFchs" recalibrationTypeAK4 = "AK4PFchs" # Following instructions from: # https://twiki.cern.ch/twiki/bin/viewauth/CMS/JetWtagging # L2L3 if isMC: doResidual = False # L2L3 Residual else: doResidual = True self.jetReCalibratorAK8L2L3 = JetReCalibrator(GT, recalibrationTypeAK8, doResidual, jecPath, skipLevel1=True) self.jetReCalibratorAK8L1L2L3 = JetReCalibrator(GT, recalibrationTypeAK8, doResidual, jecPath, skipLevel1=False) self.jetReCalibratorAK4 = JetReCalibrator(GT, recalibrationTypeAK4, doResidual, jecPath, skipLevel1=False) def declareHandles(self): super(AdditionalBoost, self).declareHandles() self.handles['rho'] = AutoHandle( ('fixedGridRhoFastjetAll',""), 'double' ) self.handles['ak08'] = AutoHandle( ("slimmedJetsAK8",""), "std::vector<pat::Jet>") self.handles['ak08softdropsubjets'] = AutoHandle( ("slimmedJetsAK8PFCHSSoftDropPacked","SubJets"), "std::vector<pat::Jet>") self.handles['ak08bbtag'] = AutoHandle( ("slimmedJetsAK8pfBoostedDoubleSecondaryVertexBJetTags","","EX"), "edm::AssociationVector<edm::RefToBaseProd<reco::Jet>,vector<float>,edm::RefToBase<reco::Jet>,unsigned int,edm::helper::AssociationIdenticalKeyReference>") self.handles['ak08ipTagInfos'] = AutoHandle( ("slimmedJetsAK8ImpactParameterTagInfos","","EX"), "vector<reco::IPTagInfo<vector<edm::Ptr<reco::Candidate> >,reco::JetTagInfo> >") self.handles['ak08svTagInfos'] = AutoHandle( ("slimmedJetsAK8pfInclusiveSecondaryVertexFinderTagInfos", "","EX"), "vector<reco::TemplatedSecondaryVertexTagInfo<reco::IPTagInfo<vector<edm::Ptr<reco::Candidate> >,reco::JetTagInfo>,reco::VertexCompositePtrCandidate> >") self.handles['ak08muonTagInfos'] = AutoHandle( ("slimmedJetsAK8softPFMuonsTagInfos", "","EX"), "vector<reco::TemplatedSoftLeptonTagInfo<edm::Ptr<reco::Candidate> > >") self.handles['ak08elecTagInfos'] = AutoHandle( ("slimmedJetsAK8softPFElectronsTagInfos", "","EX"), "vector<reco::TemplatedSoftLeptonTagInfo<edm::Ptr<reco::Candidate> > >") if not self.skip_ca15: self.handles['ca15ipTagInfos'] = AutoHandle( ("ca15PFJetsCHSImpactParameterTagInfos","","EX"), "vector<reco::IPTagInfo<vector<edm::Ptr<reco::Candidate> >,reco::JetTagInfo> >") self.handles['ca15svTagInfos'] = AutoHandle( ("ca15PFJetsCHSpfInclusiveSecondaryVertexFinderTagInfos", "","EX"), "vector<reco::TemplatedSecondaryVertexTagInfo<reco::IPTagInfo<vector<edm::Ptr<reco::Candidate> >,reco::JetTagInfo>,reco::VertexCompositePtrCandidate> >") self.handles['ca15muonTagInfos'] = AutoHandle( ("ca15PFJetsCHSsoftPFMuonsTagInfos", "","EX"), "vector<reco::TemplatedSoftLeptonTagInfo<edm::Ptr<reco::Candidate> > >") self.handles['ca15elecTagInfos'] = AutoHandle( ("ca15PFJetsCHSsoftPFElectronsTagInfos", "","EX"), "vector<reco::TemplatedSoftLeptonTagInfo<edm::Ptr<reco::Candidate> > >") self.handles['ca15ungroomed'] = AutoHandle( ("ca15PFJetsCHS","","EX"), "std::vector<reco::PFJet>") self.handles['ca15trimmed'] = AutoHandle( ("ca15PFTrimmedJetsCHS","","EX"), "std::vector<reco::PFJet>") self.handles['ca15softdrop'] = AutoHandle( ("ca15PFSoftdropJetsCHS","","EX"), "std::vector<reco::PFJet>") self.handles['ca15softdropz2b1'] = AutoHandle( ("ca15PFSoftdropZ2B1JetsCHS","","EX"), "std::vector<reco::PFJet>") self.handles['ca15pruned'] = AutoHandle( ("ca15PFPrunedJetsCHS","","EX"), "std::vector<reco::BasicJet>") self.handles['ca15prunedsubjets'] = AutoHandle( ("ca15PFPrunedJetsCHS","SubJets","EX"), "std::vector<reco::PFJet>") self.handles['ca15tau1'] = AutoHandle( ("ca15PFJetsCHSNSubjettiness","tau1","EX"), "edm::ValueMap<float>") self.handles['ca15tau2'] = AutoHandle( ("ca15PFJetsCHSNSubjettiness","tau2","EX"), "edm::ValueMap<float>") self.handles['ca15tau3'] = AutoHandle( ("ca15PFJetsCHSNSubjettiness","tau3","EX"), "edm::ValueMap<float>") self.handles['ca15softdropz2b1tau1'] = AutoHandle( ("ca15PFSoftdropZ2B1JetsCHSNSubjettiness","tau1","EX"), "edm::ValueMap<float>") self.handles['ca15softdropz2b1tau2'] = AutoHandle( ("ca15PFSoftdropZ2B1JetsCHSNSubjettiness","tau2","EX"), "edm::ValueMap<float>") self.handles['ca15softdropz2b1tau3'] = AutoHandle( ("ca15PFSoftdropZ2B1JetsCHSNSubjettiness","tau3","EX"), "edm::ValueMap<float>") self.handles['httCandJets'] = AutoHandle( ("looseOptRHTT","","EX"), "std::vector<reco::BasicJet>") self.handles['httCandInfos'] = AutoHandle( ("looseOptRHTT","","EX"), "vector<reco::HTTTopJetTagInfo>") self.handles['httSubjetBtags'] = AutoHandle( ("looseOptRHTTpfCombinedInclusiveSecondaryVertexV2BJetTags","","EX"), "edm::AssociationVector<edm::RefToBaseProd<reco::Jet>,vector<float>,edm::RefToBase<reco::Jet>,unsigned int,edm::helper::AssociationIdenticalKeyReference>") self.handles['ca15bbtag'] = AutoHandle( ("ca15PFJetsCHSpfBoostedDoubleSecondaryVertexBJetTags","","EX"), "edm::AssociationVector<edm::RefToBaseProd<reco::Jet>,vector<float>,edm::RefToBase<reco::Jet>,unsigned int,edm::helper::AssociationIdenticalKeyReference>") self.handles['ca15prunedsubjetbtag'] = AutoHandle( ("ca15PFPrunedJetsCHSpfCombinedInclusiveSecondaryVertexV2BJetTags","","EX"), "edm::AssociationVector<edm::RefToBaseProd<reco::Jet>,vector<float>,edm::RefToBase<reco::Jet>,unsigned int,edm::helper::AssociationIdenticalKeyReference>") def process(self, event): run = event.input.eventAuxiliary().id().run() lumi = event.input.eventAuxiliary().id().luminosityBlock() eventId = event.input.eventAuxiliary().id().event() self.readCollections( event.input ) # Will need who for jet calibration later rho = self.handles["rho"].product()[0] ######## # Softdrop Fatjets + NSubjettiness ######## for fj_name in ["ca15softdropz2b1"]: if self.skip_ca15 and ("ca15" in fj_name): continue # Set the four-vector setattr(event, fj_name, map(PhysicsObject, self.handles[fj_name].product())) # N-Subjettiness tau1 = self.handles[fj_name+'tau1'].product() tau2 = self.handles[fj_name+'tau2'].product() tau3 = self.handles[fj_name+'tau3'].product() # Loop over jets for ij, jet in enumerate(getattr(event, fj_name)): # Fill N-Subjettiness jet.tau1 = tau1.get(ij) jet.tau2 = tau2.get(ij) jet.tau3 = tau3.get(ij) # end of loop over jets ######## # Groomed Uncalibrated Fatjets ######## for fj_name in ['ca15trimmed', 'ca15softdrop', 'ca15pruned']: setattr(event, fj_name, map(PhysicsObject, self.handles[fj_name].product())) # # ######## # # Groomed Fatjets to calibrate # ######## # # pruned_cal_jets = [] # # for groomed_fj in self.handles['ak08pruned'].product(): # # # We need the closest ungroomed fatjet to get the JEC: # # - Make a list of pairs: deltaR(ungroomed fj, groomed fj) for all ungroomed fatjets # # - Sort by deltaR # # - And take the minimum # # if len(getattr(event, "ak08")): # closest_ung_fj_and_dr = sorted( # [(ung_fj, deltaR2(ung_fj, groomed_fj)) for ung_fj in getattr(event, "ak08")], # key=lambda x:x[1])[0] # else: # print "WARNING: No ungroomed fatjets found in event with groomed fatjet. Skipping" # continue # # # Use the jet cone size for matching # minimal_dr_groomed_ungroomed = 0.8 # if closest_ung_fj_and_dr[1] > minimal_dr_groomed_ungroomed: # print "WARNING: No ungroomed fatjet found close to groomed fatjet. Skipping" # continue # # ungroomed_jet = Jet(closest_ung_fj_and_dr[0]) # # c = self.jetReCalibratorAK8L2L3.getCorrection(ungroomed_jet, rho) # # # # Need to do a deep-copy. Otherwise the original jet will be modified # cal_groomed_fj = PhysicsObject(groomed_fj).__copy__() # cal_groomed_fj.scaleEnergy(c) # # pruned_cal_jets.append(cal_groomed_fj) # # setattr(event, 'ak08prunedcal', pruned_cal_jets) # ######## # Subjets ######## for fj_name in ['ca15pruned']: if self.skip_ca15 and ("ca15" in fj_name): continue setattr(event, fj_name + "subjets", map(PhysicsObject, self.handles[fj_name+"subjets"].product())) newtags = self.handles[fj_name+'subjetbtag'].product() for i in xrange(0,len(newtags)) : for j in getattr(event, fj_name+"subjets"): if j.physObj == newtags.key(i).get(): j.btag = newtags.value(i) ######## # HEPTopTagger ######## if not self.skip_ca15: candJets = self.handles['httCandJets'].product() candInfos = self.handles['httCandInfos'].product() event.httCandidates = map(PhysicsObject, candJets) sjbtags = self.handles['httSubjetBtags'].product() for i in xrange(0, len(candJets)): event.httCandidates[i].fRec = candInfos[i].properties().fRec event.httCandidates[i].Ropt = candInfos[i].properties().Ropt event.httCandidates[i].RoptCalc = candInfos[i].properties().RoptCalc event.httCandidates[i].ptForRoptCalc = candInfos[i].properties().ptForRoptCalc # HTT return the subjet-pair closest to the W-mass as W-subjets # Could be improved by b-tagging if we run into a problem [sj_w1, sj_w2, sj_nonw] = [con.__deref__() for con in candJets[i].getJetConstituents() if not con.isNull()] # Calibrate the subjets: W1 sj_w1_uncal = Jet(sj_w1) c = self.jetReCalibratorAK4.getCorrection(sj_w1_uncal, rho, isHttSubjet=True) sj_w1_cal = PhysicsObject(sj_w1).__copy__() sj_w1_cal.scaleEnergy(c) # Calibrate the subjets: W2 sj_w2_uncal = Jet(sj_w2) c = self.jetReCalibratorAK4.getCorrection(sj_w2_uncal, rho, isHttSubjet=True) sj_w2_cal = PhysicsObject(sj_w2).__copy__() sj_w2_cal.scaleEnergy(c) # Calibrate the subjets: NonW sj_nonw_uncal = Jet(sj_nonw) c = self.jetReCalibratorAK4.getCorrection(sj_nonw_uncal, rho, isHttSubjet=True) sj_nonw_cal = PhysicsObject(sj_nonw).__copy__() sj_nonw_cal.scaleEnergy(c) # Make TLVs so we can add them and get the top quark # candidate tlv_sj_w1_cal = ROOT.TLorentzVector() tlv_sj_w2_cal = ROOT.TLorentzVector() tlv_sj_nonw_cal = ROOT.TLorentzVector() tlv_sj_w1_cal.SetPtEtaPhiM(sj_w1_cal.pt(), sj_w1_cal.eta(), sj_w1_cal.phi(), sj_w1_cal.mass()) tlv_sj_w2_cal.SetPtEtaPhiM(sj_w2_cal.pt(), sj_w2_cal.eta(), sj_w2_cal.phi(), sj_w2_cal.mass()) tlv_sj_nonw_cal.SetPtEtaPhiM(sj_nonw_cal.pt(), sj_nonw_cal.eta(), sj_nonw_cal.phi(), sj_nonw_cal.mass()) tlv_top_cal = tlv_sj_w1_cal + tlv_sj_w2_cal + tlv_sj_nonw_cal # Store calibrated top candidate variables event.httCandidates[i].ptcal = tlv_top_cal.Pt() event.httCandidates[i].etacal = tlv_top_cal.Eta() event.httCandidates[i].phical = tlv_top_cal.Phi() event.httCandidates[i].masscal = tlv_top_cal.M() # Store SJ W1 Variables event.httCandidates[i].sjW1ptcal = sj_w1_cal.pt() event.httCandidates[i].sjW1masscal = sj_w1_cal.mass() event.httCandidates[i].sjW1pt = sj_w1.pt() event.httCandidates[i].sjW1eta = sj_w1.eta() event.httCandidates[i].sjW1phi = sj_w1.phi() event.httCandidates[i].sjW1mass = sj_w1.mass() # Get the correct b-tag for ib in xrange(0, len(sjbtags)) : if sj_w1 == sjbtags.key(ib).get(): event.httCandidates[i].sjW1btag = sjbtags.value(ib) # Store SJ W2 Variables event.httCandidates[i].sjW2ptcal = sj_w2_cal.pt() event.httCandidates[i].sjW2masscal = sj_w2_cal.mass() event.httCandidates[i].sjW2pt = sj_w2.pt() event.httCandidates[i].sjW2eta = sj_w2.eta() event.httCandidates[i].sjW2phi = sj_w2.phi() event.httCandidates[i].sjW2mass = sj_w2.mass() # Get the correct b-tag for ib in xrange(0, len(sjbtags)) : if sj_w2 == sjbtags.key(ib).get(): event.httCandidates[i].sjW2btag = sjbtags.value(ib) # Store SJ Non W Variables event.httCandidates[i].sjNonWptcal = sj_nonw_cal.pt() event.httCandidates[i].sjNonWmasscal = sj_nonw_cal.mass() event.httCandidates[i].sjNonWpt = sj_nonw.pt() event.httCandidates[i].sjNonWeta = sj_nonw.eta() event.httCandidates[i].sjNonWphi = sj_nonw.phi() event.httCandidates[i].sjNonWmass = sj_nonw.mass() # Get the correct b-tag for ib in xrange(0, len(sjbtags)) : if sj_nonw == sjbtags.key(ib).get(): event.httCandidates[i].sjNonWbtag = sjbtags.value(ib) ######## # AK8 Jets from MiniAOD + Subjet btags ######## setattr(event, "ak08", map(PhysicsObject, self.handles["ak08"].product())) setattr(event, "ak08softdropsubjets", map(PhysicsObject, self.handles["ak08softdropsubjets"].product())) do_calc_bb = False # Calc BB tag # -- if there is a HTT candidate and at least one lepton if len(event.selectedLeptons): for cand in event.httCandidates: if cand.fRec < 0.2 and cand.mass() > 100 and cand.mass() < 200: do_calc_bb = True # -- or if there are at least two fatjets with pT > 250 GeV and the scalar sum of the jet pTs is > 600 fj_pt250 = [j for j in event.ak08 if j.pt() > 250] if len(fj_pt250) >= 2 and sum([j.pt() for j in fj_pt250]) > 600: do_calc_bb = True # bb-tag Output newtags = self.handles['ak08bbtag'].product() # Loop over jets for ij, jet in enumerate(getattr(event, "ak08")): # Fill bb-tag for i in xrange(len(newtags)) : if jet.physObj == newtags.key(i).get(): jet.bbtag = newtags.value(i) corr = self.jetReCalibratorAK8L2L3.getCorrection(Jet(jet),rho) jet.mprunedcorr= jet.userFloat("ak8PFJetsCHSPrunedMass")*corr jet.JEC_L2L3 = corr jet.JEC_L1L2L3 = self.jetReCalibratorAK8L1L2L3.getCorrection(Jet(jet),rho) # bb-tag Inputs muonTagInfos = self.handles['ak08muonTagInfos'].product()[ij] elecTagInfos = self.handles['ak08elecTagInfos'].product()[ij] ipTagInfo = self.handles['ak08ipTagInfos'].product()[ij] svTagInfo = self.handles['ak08svTagInfos'].product()[ij] orig_jet = self.handles["ak08"].product()[ij] if do_calc_bb: calcBBTagVariables(jet, orig_jet, muonTagInfos, elecTagInfos, ipTagInfo, svTagInfo, njettiness_08, maxSVDeltaRToJet = 0.7,) else: calcBBTagVariables_dummy(jet) # end of loop over jets ######## # Ungroomed Fatjets + NSubjettiness + Hbb Tagging ######## for prefix in ["ca15"]: if self.skip_ca15 and ("ca15" in prefix): continue # N-Subjettiness tau1 = self.handles[prefix+'tau1'].product() tau2 = self.handles[prefix+'tau2'].product() tau3 = self.handles[prefix+'tau3'].product() # bb-tag Output newtags = self.handles[prefix+'bbtag'].product() # Four Vector setattr(event, prefix+"ungroomed", map(PhysicsObject, self.handles[prefix+'ungroomed'].product())) # Loop over jets for ij, jet in enumerate(getattr(event, prefix+"ungroomed")): # Fill N-Subjettiness jet.tau1 = tau1.get(ij) jet.tau2 = tau2.get(ij) jet.tau3 = tau3.get(ij) # Fill bb-tag for i in xrange(len(newtags)) : if jet.physObj == newtags.key(i).get(): jet.bbtag = newtags.value(i) # bb-tag Inputs muonTagInfos = self.handles['ca15muonTagInfos'].product()[ij] elecTagInfos = self.handles['ca15elecTagInfos'].product()[ij] ipTagInfo = self.handles['ca15ipTagInfos'].product()[ij] svTagInfo = self.handles['ca15svTagInfos'].product()[ij] orig_jet = self.handles[prefix+'ungroomed'].product()[ij] if do_calc_bb: calcBBTagVariables(jet, orig_jet, muonTagInfos, elecTagInfos, ipTagInfo, svTagInfo, njettiness_15, maxSVDeltaRToJet = 1.3) else: calcBBTagVariables_dummy(jet) # end of loop over jets return True
class JetAnalyzer(Analyzer): """Taken from RootTools.JetAnalyzer, simplified, modified, added corrections """ def __init__(self, cfg_ana, cfg_comp, looperName): super(JetAnalyzer, self).__init__(cfg_ana, cfg_comp, looperName) mcGT = cfg_ana.mcGT if hasattr(cfg_ana, 'mcGT') else "PHYS14_25_V2" dataGT = cfg_ana.dataGT if hasattr(cfg_ana, 'dataGT') else "GR_70_V2_AN1" self.shiftJEC = self.cfg_ana.shiftJEC if hasattr( self.cfg_ana, 'shiftJEC') else 0 self.recalibrateJets = self.cfg_ana.recalibrateJets self.addJECShifts = self.cfg_ana.addJECShifts if hasattr( self.cfg_ana, 'addJECShifts') else 0 if self.recalibrateJets == "MC": self.recalibrateJets = self.cfg_comp.isMC elif self.recalibrateJets == "Data": self.recalibrateJets = not self.cfg_comp.isMC elif self.recalibrateJets not in [True, False]: raise RuntimeError, "recalibrateJets must be any of { True, False, 'MC', 'Data' }, while it is %r " % self.recalibrateJets calculateSeparateCorrections = getattr(cfg_ana, "calculateSeparateCorrections", False) calculateType1METCorrection = getattr(cfg_ana, "calculateType1METCorrection", False) self.doJEC = self.recalibrateJets or ( self.shiftJEC != 0 ) or self.addJECShifts or calculateSeparateCorrections or calculateType1METCorrection if self.doJEC: doResidual = getattr(cfg_ana, 'applyL2L3Residual', 'Data') if doResidual == "MC": doResidual = self.cfg_comp.isMC elif doResidual == "Data": doResidual = not self.cfg_comp.isMC elif doResidual not in [True, False]: raise RuntimeError, "If specified, applyL2L3Residual must be any of { True, False, 'MC', 'Data'(default)}" GT = getattr(cfg_comp, 'jecGT', mcGT if self.cfg_comp.isMC else dataGT) # Now take care of the optional arguments kwargs = { 'calculateSeparateCorrections': calculateSeparateCorrections, 'calculateType1METCorrection': calculateType1METCorrection, } if kwargs['calculateType1METCorrection']: kwargs['type1METParams'] = cfg_ana.type1METParams # instantiate the jet re-calibrator self.jetReCalibrator = JetReCalibrator(GT, cfg_ana.recalibrationType, doResidual, cfg_ana.jecPath, **kwargs) self.doPuId = getattr(self.cfg_ana, 'doPuId', True) self.jetLepDR = getattr(self.cfg_ana, 'jetLepDR', 0.4) self.jetLepArbitration = getattr(self.cfg_ana, 'jetLepArbitration', lambda jet, lepton: lepton) self.lepPtMin = getattr(self.cfg_ana, 'minLepPt', -1) self.lepSelCut = getattr(self.cfg_ana, 'lepSelCut', lambda lep: True) self.jetGammaDR = getattr(self.cfg_ana, 'jetGammaDR', 0.4) self.jetGammaLepDR = getattr(self.cfg_ana, 'jetGammaLepDR', 0.4) self.cleanFromLepAndGammaSimultaneously = getattr( self.cfg_ana, 'cleanFromLepAndGammaSimultaneously', False) if self.cleanFromLepAndGammaSimultaneously: if hasattr(self.cfg_ana, 'jetGammaLepDR'): self.jetGammaLepDR = self.jetGammaLepDR elif (self.jetGammaDR == self.jetLepDR): self.jetGammaLepDR = self.jetGammaDR else: raise RuntimeError, "DR for simultaneous cleaning of jets from leptons and photons is not defined, and dR(gamma, jet)!=dR(lep, jet)" if (self.cfg_ana.doQG): qgdefname = "{CMSSW_BASE}/src/PhysicsTools/Heppy/data/pdfQG_AK4chs_13TeV_v2b.root" self.qglcalc = QGLikelihoodCalculator( getattr(self.cfg_ana, "QGpath", qgdefname).format(CMSSW_BASE=os.environ['CMSSW_BASE'])) if not hasattr(self.cfg_ana, "collectionPostFix"): self.cfg_ana.collectionPostFix = "" def declareHandles(self): super(JetAnalyzer, self).declareHandles() self.handles['jets'] = AutoHandle(self.cfg_ana.jetCol, 'std::vector<pat::Jet>') self.handles['genJet'] = AutoHandle(self.cfg_ana.genJetCol, 'vector<reco::GenJet>') self.shiftJER = self.cfg_ana.shiftJER if hasattr( self.cfg_ana, 'shiftJER') else 0 self.addJERShifts = self.cfg_ana.addJERShifts if hasattr( self.cfg_ana, 'addJERShifts') else 0 self.handles['rho'] = AutoHandle(self.cfg_ana.rho, 'double') def beginLoop(self, setup): super(JetAnalyzer, self).beginLoop(setup) 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 def testJetID(self, jet): jet.puJetIdPassed = jet.puJetId() jet.pfJetIdPassed = jet.jetID('POG_PFID_Loose') if self.cfg_ana.relaxJetId: return True else: return jet.pfJetIdPassed and (jet.puJetIdPassed or not (self.doPuId)) def testJetNoID(self, jet): # 2 is loose pile-up jet id return jet.pt() > self.cfg_ana.jetPt and \ abs( jet.eta() ) < self.cfg_ana.jetEta def jetFlavour(self, event): def isFlavour(x, f): id = abs(x.pdgId()) if id > 999: return (id / 1000) % 10 == f if id > 99: return (id / 100) % 10 == f return id % 100 == f self.bqObjects = [ p for p in event.genParticles if (p.status() == 2 and isFlavour(p, 5)) ] self.cqObjects = [ p for p in event.genParticles if (p.status() == 2 and isFlavour(p, 4)) ] self.partons = [ p for p in event.genParticles if ((p.status() == 23 or p.status() == 3) and abs(p.pdgId()) > 0 and (abs(p.pdgId()) in [1, 2, 3, 4, 5, 21])) ] match = matchObjectCollection2(self.cleanJetsAll, self.partons, deltaRMax=0.3) for jet in self.cleanJetsAll: parton = match[jet] jet.partonId = (parton.pdgId() if parton != None else 0) jet.partonMotherId = (parton.mother(0).pdgId() if parton != None and parton.numberOfMothers() > 0 else 0) for jet in self.jets: (bmatch, dr) = bestMatch(jet, self.bqObjects) if dr < 0.4: jet.mcFlavour = 5 else: (cmatch, dr) = bestMatch(jet, self.cqObjects) if dr < 0.4: jet.mcFlavour = 4 else: jet.mcFlavour = 0 self.heaviestQCDFlavour = 5 if len( self.bqObjects) else (4 if len(self.cqObjects) else 1) def matchJets(self, event, jets): match = matchObjectCollection2(jets, event.genbquarks + event.genwzquarks, deltaRMax=0.3) for jet in jets: gen = match[jet] jet.mcParton = gen jet.mcMatchId = (gen.sourceId if gen != None else 0) jet.mcMatchFlav = (abs(gen.pdgId()) if gen != None else 0) match = matchObjectCollection2(jets, self.genJets, deltaRMax=0.3) for jet in jets: jet.mcJet = match[jet] def smearJets(self, event, jets): # https://twiki.cern.ch/twiki/bin/viewauth/CMS/TWikiTopRefSyst#Jet_energy_resolution for jet in jets: gen = jet.mcJet if gen != None: genpt, jetpt, aeta = gen.pt(), jet.pt(), abs(jet.eta()) # from https://twiki.cern.ch/twiki/bin/view/CMS/JetResolution #8 TeV tables factor = shiftJERfactor(self.shiftJER, aeta) ptscale = max(0.0, (jetpt + (factor - 1) * (jetpt - genpt)) / jetpt) #print "get with pt %.1f (gen pt %.1f, ptscale = %.3f)" % (jetpt,genpt,ptscale) jet.deltaMetFromJetSmearing = [ -(ptscale - 1) * jet.rawFactor() * jet.px(), -(ptscale - 1) * jet.rawFactor() * jet.py() ] if ptscale != 0: jet.setP4(jet.p4() * ptscale) # leave the uncorrected unchanged for sync jet.setRawFactor(jet.rawFactor() / ptscale) #else: print "jet with pt %.1d, eta %.2f is unmatched" % (jet.pt(), jet.eta()) if (self.shiftJER == 0) and (self.addJERShifts): setattr(jet, "corrJER", ptscale) factorJERUp = shiftJERfactor(1, aeta) ptscaleJERUp = max(0.0, (jetpt + (factorJERUp - 1) * (jetpt - genpt)) / jetpt) setattr(jet, "corrJERUp", ptscaleJERUp) factorJERDown = shiftJERfactor(-1, aeta) ptscaleJERDown = max(0.0, (jetpt + (factorJERDown - 1) * (jetpt - genpt)) / jetpt) setattr(jet, "corrJERDown", ptscaleJERDown)
class JetSelector(Analyzer): """Analyze jets. Copied from heppy examples and edit to not rely on heppy examples. This analyzer filters the jets that do not correspond to the leptons stored in event.selectedLeptons, and puts in the event: - jets: all jets passing the pt and eta cuts - cleanJets: the collection of jets away from the leptons - cleanBJets: the jets passing testBJet, and away from the leptons Example configuration: jetAna = cfg.Analyzer( 'JetSelector', jetCol = 'slimmedJets' # cmg jet input collection # pt threshold jetPt = 30, # eta range definition jetEta = 5.0, # seed for the btag scale factor btagSFseed = 0xdeadbeef, # if True, the PF and PU jet ID are not applied, and the jets get flagged relaxJetId = False, relaxPuJetId = False, ) """ def __init__(self, cfg_ana, cfg_comp, looperName): super(JetSelector, self).__init__(cfg_ana, cfg_comp, looperName) self.btagSF = BTagSF(0, wp='medium') self.recalibrateJets = getattr(cfg_ana, 'recalibrateJets', False) mcGT = getattr(cfg_ana, 'mcGT', 'Spring16_25nsV6_MC') dataGT = getattr(cfg_ana, 'dataGT', 'Spring16_25nsV6_DATA') if self.recalibrateJets: doResidual = getattr(cfg_ana, 'applyL2L3Residual', 'Data') if doResidual == "MC": doResidual = self.cfg_comp.isMC elif doResidual == "Data": doResidual = not self.cfg_comp.isMC elif doResidual not in [True, False]: raise RuntimeError, "If specified, applyL2L3Residual must be any of { True, False, 'MC', 'Data'(default)}" GT = getattr(cfg_comp, 'jecGT', mcGT if self.cfg_comp.isMC else dataGT) # instantiate the jet re-calibrator self.jetReCalibrator = JetReCalibrator( GT, 'AK4PFchs', doResidual, jecPath="%s/src/CMGTools/RootTools/data/jec" % os.environ['CMSSW_BASE']) def declareHandles(self): super(JetSelector, self).declareHandles() self.handles['jets'] = AutoHandle(self.cfg_ana.jetCol, 'std::vector<pat::Jet>') if self.cfg_comp.isMC: self.mchandles['genParticles'] = AutoHandle( 'packedGenParticles', 'std::vector<pat::PackedGenParticle>') self.mchandles['genJets'] = AutoHandle( 'slimmedGenJets', 'std::vector<reco::GenJet>') def beginLoop(self, setup): super(JetSelector, self).beginLoop(setup) self.counters.addCounter('jets') count = self.counters.counter('jets') count.register('all events') count.register('at least 2 good jets') count.register('at least 2 clean jets') count.register('exactly 2 b jets') 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 def jerCorrection(self, jet): ''' Adds JER correction according to first method at https://twiki.cern.ch/twiki/bin/view/CMS/JetResolution Requires some attention when genJet matching fails. ''' if not hasattr(jet, 'matchedGenJet'): return #import pdb; pdb.set_trace() corrections = [0.052, 0.057, 0.096, 0.134, 0.288] maxEtas = [0.5, 1.1, 1.7, 2.3, 5.0] eta = abs(jet.eta()) for i, maxEta in enumerate(maxEtas): if eta < maxEta: pt = jet.pt() deltaPt = (pt - jet.matchedGenJet.pt()) * corrections[i] totalScale = (pt + deltaPt) / pt if totalScale < 0.: totalScale = 0. jet.scaleEnergy(totalScale) break def jesCorrection(self, jet, scale=0.): ''' Adds JES correction in number of sigmas (scale) ''' # Do nothing if nothing to change if scale == 0.: return unc = jet.uncOnFourVectorScale() totalScale = 1. + scale * unc if totalScale < 0.: totalScale = 0. jet.scaleEnergy(totalScale)