def UpdatePuppiTuneV13(process): # # Adapt for re-running PUPPI # print( "customizePuppiTune_cff::UpdatePuppiTuneV13: Recomputing PUPPI with Tune v13, slimmedJetsPuppi and slimmedMETsPuppi" ) from PhysicsTools.PatAlgos.tools.helpers import getPatAlgosToolsTask, addToProcessAndTask task = getPatAlgosToolsTask(process) from PhysicsTools.PatAlgos.slimming.puppiForMET_cff import makePuppiesFromMiniAOD makePuppiesFromMiniAOD(process, True) process.puppi.useExistingWeights = False process.puppiNoLep.useExistingWeights = False from PhysicsTools.PatUtils.tools.runMETCorrectionsAndUncertainties import runMetCorAndUncFromMiniAOD runMetCorAndUncFromMiniAOD(process, isData=False, metType="Puppi", postfix="Puppi", jetFlavor="AK4PFPuppi", recoMetFromPFCs=True) from PhysicsTools.PatAlgos.patPuppiJetSpecificProducer_cfi import patPuppiJetSpecificProducer addToProcessAndTask( 'patPuppiJetSpecificProducer', patPuppiJetSpecificProducer.clone(src=cms.InputTag("patJetsPuppi")), process, task) from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection updateJetCollection( process, labelName='PuppiJetSpecific', jetSource=cms.InputTag('patJetsPuppi'), ) process.updatedPatJetsPuppiJetSpecific.userData.userFloats.src = [ 'patPuppiJetSpecificProducer:puppiMultiplicity', 'patPuppiJetSpecificProducer:neutralPuppiMultiplicity', 'patPuppiJetSpecificProducer:neutralHadronPuppiMultiplicity', 'patPuppiJetSpecificProducer:photonPuppiMultiplicity', 'patPuppiJetSpecificProducer:HFHadronPuppiMultiplicity', 'patPuppiJetSpecificProducer:HFEMPuppiMultiplicity' ] addToProcessAndTask('slimmedJetsPuppi', process.updatedPatJetsPuppiJetSpecific.clone(), process, task) del process.updatedPatJetsPuppiJetSpecific process.puppiSequence = cms.Sequence(process.puppiMETSequence + process.fullPatMetSequencePuppi + process.patPuppiJetSpecificProducer + process.slimmedJetsPuppi) # # Adapt for PUPPI tune V13 # process.puppi.UseFromPVLooseTight = False process.puppi.UseDeltaZCut = False process.puppi.PtMaxCharged = 20. process.puppi.EtaMaxCharged = 2.5 process.puppi.PtMaxNeutralsStartSlope = 20. process.puppiNoLep.UseFromPVLooseTight = False process.puppiNoLep.UseDeltaZCut = False process.puppiNoLep.PtMaxCharged = 20. process.puppiNoLep.EtaMaxCharged = 2.5 process.puppiNoLep.PtMaxNeutralsStartSlope = 20.
def nanoAOD_customizeCommon(process): makePuppiesFromMiniAOD(process,True) process.puppiNoLep.useExistingWeights = True process.puppi.useExistingWeights = True run2_nanoAOD_106Xv1.toModify(process.puppiNoLep, useExistingWeights = False) run2_nanoAOD_106Xv1.toModify(process.puppi, useExistingWeights = False) process = nanoAOD_activateVID(process) nanoAOD_addDeepInfo_switch = cms.PSet( nanoAOD_addDeepBTag_switch = cms.untracked.bool(False), nanoAOD_addDeepFlavourTag_switch = cms.untracked.bool(False), ) run2_miniAOD_80XLegacy.toModify(nanoAOD_addDeepInfo_switch, nanoAOD_addDeepBTag_switch = cms.untracked.bool(True)) for modifier in run2_miniAOD_80XLegacy, run2_nanoAOD_94X2016, run2_nanoAOD_94XMiniAODv1, run2_nanoAOD_94XMiniAODv2: modifier.toModify(nanoAOD_addDeepInfo_switch, nanoAOD_addDeepFlavourTag_switch = cms.untracked.bool(True)) process = nanoAOD_addDeepInfo(process, addDeepBTag=nanoAOD_addDeepInfo_switch.nanoAOD_addDeepBTag_switch, addDeepFlavour=nanoAOD_addDeepInfo_switch.nanoAOD_addDeepFlavourTag_switch) nanoAOD_addDeepInfoAK8_switch = cms.PSet( nanoAOD_addDeepBTag_switch = cms.untracked.bool(False), nanoAOD_addDeepBoostedJet_switch = cms.untracked.bool(False), nanoAOD_addDeepDoubleX_switch = cms.untracked.bool(False), nanoAOD_addDeepDoubleXV2_switch = cms.untracked.bool(False), nanoAOD_addParticleNet_switch = cms.untracked.bool(False), jecPayload = cms.untracked.string('AK8PFPuppi') ) # deepAK8 should not run on 80X, that contains ak8PFJetsCHS jets run2_miniAOD_80XLegacy.toModify(nanoAOD_addDeepInfoAK8_switch, nanoAOD_addDeepBTag_switch = True, jecPayload = 'AK8PFchs') # for 94X and 102X samples: needs to run DeepAK8, DeepDoubleX and ParticleNet (run2_nanoAOD_94X2016 | run2_nanoAOD_94XMiniAODv1 | run2_nanoAOD_94XMiniAODv2 | run2_nanoAOD_102Xv1).toModify( nanoAOD_addDeepInfoAK8_switch, nanoAOD_addDeepBoostedJet_switch = True, nanoAOD_addDeepDoubleX_switch = True, nanoAOD_addDeepDoubleXV2_switch = True, nanoAOD_addParticleNet_switch = True, ) # for 106Xv1: only needs to run ParticleNet and DDXV2; DeepAK8, DeepDoubleX are already in MiniAOD run2_nanoAOD_106Xv1.toModify( nanoAOD_addDeepInfoAK8_switch, nanoAOD_addDeepDoubleXV2_switch = True, nanoAOD_addParticleNet_switch = True, ) process = nanoAOD_addDeepInfoAK8(process, addDeepBTag=nanoAOD_addDeepInfoAK8_switch.nanoAOD_addDeepBTag_switch, addDeepBoostedJet=nanoAOD_addDeepInfoAK8_switch.nanoAOD_addDeepBoostedJet_switch, addDeepDoubleX=nanoAOD_addDeepInfoAK8_switch.nanoAOD_addDeepDoubleX_switch, addDeepDoubleXV2=nanoAOD_addDeepInfoAK8_switch.nanoAOD_addDeepDoubleXV2_switch, addParticleNet=nanoAOD_addDeepInfoAK8_switch.nanoAOD_addParticleNet_switch, jecPayload=nanoAOD_addDeepInfoAK8_switch.jecPayload) (run2_nanoAOD_94XMiniAODv1 | run2_nanoAOD_94X2016 | run2_nanoAOD_94XMiniAODv2 | run2_nanoAOD_102Xv1 | run2_nanoAOD_106Xv1).toModify(process, lambda p : nanoAOD_addTauIds(p)) return process
runMetCorAndUncFromMiniAOD(process, isData=runOnData, ) if not useHFCandidates: runMetCorAndUncFromMiniAOD(process, isData=runOnData, pfCandColl=cms.InputTag("noHFCands"), reclusterJets=True, #needed for NoHF recoMetFromPFCs=True, #needed for NoHF postfix="NoHF" ) if redoPuppi: from PhysicsTools.PatAlgos.slimming.puppiForMET_cff import makePuppiesFromMiniAOD makePuppiesFromMiniAOD( process ); runMetCorAndUncFromMiniAOD(process, isData=runOnData, metType="Puppi", pfCandColl=cms.InputTag("puppiForMET"), recoMetFromPFCs=True, reclusterJets=True, jetFlavor="AK4PFPuppi", postfix="Puppi" ) process.MINIAODSIMoutput = cms.OutputModule("PoolOutputModule", compressionLevel = cms.untracked.int32(4), compressionAlgorithm = cms.untracked.string('LZMA'),
correctionFile=egmidconf.photonSmearingData[egmSmearingType]) egmCorrectionSequence = cms.Sequence(process.correctedElectrons + process.correctedPhotons + process.selectedElectrons + process.slimmedElectrons + process.slimmedPhotons) ### PUPPI # 80X does not contain the latest & greatest PuppiPhoton; need to rerun for all config from PhysicsTools.PatAlgos.slimming.puppiForMET_cff import makePuppiesFromMiniAOD # Creates process.puppiMETSequence which includes 'puppi' and 'puppiForMET' (= EDProducer('PuppiPhoton')) # *UGLY* also runs switchOnVIDPhotonIdProducer and sets up photon id Spring16_V2p2 internally # which loads photonIDValueMapProducer and egmPhotonIDs makePuppiesFromMiniAOD(process, createScheduledSequence=True) # Just renaming puppiSequence = process.puppiMETSequence ### PUPPI JET from PandaProd.Producer.utils.makeJets_cff import makeJets puppiJetSequence = makeJets(process, options.isData, 'AK4PFPuppi', 'puppi', 'Puppi') ### PUPPI MET from PhysicsTools.PatUtils.tools.runMETCorrectionsAndUncertainties import runMetCorAndUncFromMiniAOD # Creates process.fullPatMetSequencePuppi
def nanoAOD_recalibrateMETs(process,isData): # add DeepMETs nanoAOD_DeepMET_switch = cms.PSet( nanoAOD_addDeepMET_switch = cms.untracked.bool(True), # decide if DeeMET should be included in Nano nanoAOD_produceDeepMET_switch = cms.untracked.bool(False), # decide if DeepMET should be computed on the fly ResponseTune_Graph = cms.untracked.string('RecoMET/METPUSubtraction/data/deepmet/deepmet_resp_v1_2018.pb') ) for modifier in run2_miniAOD_80XLegacy, run2_nanoAOD_94X2016, run2_nanoAOD_94XMiniAODv1, run2_nanoAOD_94XMiniAODv2, run2_nanoAOD_102Xv1, run2_nanoAOD_106Xv1: # compute DeepMETs in these eras (before 111X) modifier.toModify(nanoAOD_DeepMET_switch, nanoAOD_produceDeepMET_switch = cms.untracked.bool(True)) for modifier in run2_miniAOD_80XLegacy, run2_nanoAOD_94X2016: modifier.toModify(nanoAOD_DeepMET_switch, ResponseTune_Graph=cms.untracked.string("RecoMET/METPUSubtraction/data/deepmet/deepmet_resp_v1_2016.pb")) if nanoAOD_DeepMET_switch.nanoAOD_addDeepMET_switch: process = nanoAOD_addDeepMET(process, addDeepMETProducer=nanoAOD_DeepMET_switch.nanoAOD_produceDeepMET_switch, ResponseTune_Graph=nanoAOD_DeepMET_switch.ResponseTune_Graph) # if included in Nano, and not computed in the fly, then it should be extracted from minAOD extractDeepMETs = nanoAOD_DeepMET_switch.nanoAOD_addDeepMET_switch and not nanoAOD_DeepMET_switch.nanoAOD_produceDeepMET_switch runMetCorAndUncFromMiniAOD(process,isData=isData, extractDeepMETs=extractDeepMETs) process.nanoSequenceCommon.insert(2,cms.Sequence(process.fullPatMetSequence)) from PhysicsTools.PatAlgos.slimming.puppiForMET_cff import makePuppiesFromMiniAOD makePuppiesFromMiniAOD(process,True) process.puppiNoLep.useExistingWeights = True process.puppi.useExistingWeights = True run2_nanoAOD_106Xv1.toModify(process.puppiNoLep, useExistingWeights = False) run2_nanoAOD_106Xv1.toModify(process.puppi, useExistingWeights = False) print("will make Puppies on top of MINIAOD") # makePuppiesFromMiniAOD(process,True) # call this before in the global customizer otherwise it would reset photon IDs in VID nanoAOD_PuppiV15_switch = cms.PSet( recoMetFromPFCs = cms.untracked.bool(False), reclusterJets = cms.untracked.bool(False), ) run2_nanoAOD_106Xv1.toModify(nanoAOD_PuppiV15_switch,recoMetFromPFCs=True,reclusterJets=True) if nanoAOD_PuppiV15_switch.reclusterJets: from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets from PhysicsTools.PatAlgos.tools.helpers import getPatAlgosToolsTask, addToProcessAndTask task = getPatAlgosToolsTask(process) addToProcessAndTask('ak4PuppiJets', ak4PFJets.clone (src = 'puppi', doAreaFastjet = True, jetPtMin = 10.), process, task) from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection addJetCollection(process, labelName = 'Puppi', jetSource = cms.InputTag('ak4PuppiJets'), algo = 'AK', rParam=0.4, genJetCollection=cms.InputTag('slimmedGenJets'), jetCorrections = ('AK4PFPuppi', ['L1FastJet', 'L2Relative', 'L3Absolute','L2L3Residual'], 'None'), pfCandidates = cms.InputTag('packedPFCandidates'), pvSource = cms.InputTag('offlineSlimmedPrimaryVertices'), svSource = cms.InputTag('slimmedSecondaryVertices'), muSource =cms.InputTag( 'slimmedMuons'), elSource = cms.InputTag('slimmedElectrons'), genParticles= cms.InputTag('prunedGenParticles'), getJetMCFlavour= False ) process.patJetsPuppi.addGenPartonMatch = cms.bool(False) process.patJetsPuppi.addGenJetMatch = cms.bool(False) print("nanoAOD_PuppiV15_switch.reclusterJets is true") runMetCorAndUncFromMiniAOD(process,isData=isData,metType="Puppi",postfix="Puppi",jetFlavor="AK4PFPuppi", recoMetFromPFCs=bool(nanoAOD_PuppiV15_switch.recoMetFromPFCs), reclusterJets=bool(nanoAOD_PuppiV15_switch.reclusterJets)) process.nanoSequenceCommon.insert(2,cms.Sequence(process.puppiMETSequence+process.fullPatMetSequencePuppi)) return process
### ReRun JEC + Pileup Jet ID =========================================================================== #PFMET from PhysicsTools.PatUtils.tools.runMETCorrectionsAndUncertainties import runMetCorAndUncFromMiniAOD # If you only want to re-correct and get the proper uncertainties runMetCorAndUncFromMiniAOD(process, isData=runOnData) """# If you would like to re-cluster and get the proper uncertainties runMetCorAndUncFromMiniAOD(process, isData=runOnData, pfCandColl=cms.InputTag("packedPFCandidates"), recoMetFromPFCs=True, )""" #PuppiMET from PhysicsTools.PatAlgos.slimming.puppiForMET_cff import makePuppiesFromMiniAOD makePuppiesFromMiniAOD(process, True) # If you only want to re-correct and get the proper uncertainties """runMetCorAndUncFromMiniAOD(process, isData=runOnData, metType="Puppi", postfix="Puppi" )""" # If you only want to re-cluster and get the proper uncertainties runMetCorAndUncFromMiniAOD(process, isData=runOnData, metType="Puppi", pfCandColl=cms.InputTag("puppiForMET"), recoMetFromPFCs=True, jetFlavor="AK4PFPuppi",
isData=runOnData, ) if not useHFCandidates: runMetCorAndUncFromMiniAOD(process, isData=runOnData, pfCandColl=cms.InputTag("noHFCands"), reclusterJets=True, #needed for NoHF recoMetFromPFCs=True, #needed for NoHF postfix="NoHF" ) if redoPuppi: from PhysicsTools.PatAlgos.slimming.puppiForMET_cff import makePuppiesFromMiniAOD makePuppiesFromMiniAOD( process ); runMetCorAndUncFromMiniAOD(process, isData=runOnData, pfCandColl=cms.InputTag("puppiForMET"), reclusterJets=False, recoMetFromPFCs=False, postfix="Puppi" ) ### ------------------------------------------------------------------- ### the lines below remove the L2L3 residual corrections when processing data ### ------------------------------------------------------------------- if not applyResiduals: process.patPFMetT1T2Corr.jetCorrLabelRes = cms.InputTag("L3Absolute") process.patPFMetT1T2SmearCorr.jetCorrLabelRes = cms.InputTag("L3Absolute")
from PhysicsTools.PatUtils.tools.runMETCorrectionsAndUncertainties import runMetCorAndUncFromMiniAOD runMetCorAndUncFromMiniAOD(process, isData=isData, ) print "-> Updating the met collection to run on to 'slimmedMETs with nero' with the new jec in the GT for Type1" process.nero.mets=cms.InputTag('slimmedMETs','','nero') ## TO DO this is production specific, when testing on relval it works with RECO, maybe we should leave it empty ##if not options.isData: ## process.nero.metFilterToken=cms.InputTag("TriggerResults","","PAT") ############ RUN Puppi MET CLUSTERING ########################## from PhysicsTools.PatAlgos.slimming.puppiForMET_cff import makePuppiesFromMiniAOD makePuppiesFromMiniAOD( process, True ); runMetCorAndUncFromMiniAOD(process, isData=options.isData, metType="Puppi", pfCandColl=cms.InputTag("puppiForMET"), recoMetFromPFCs=True, jetFlavor="AK4PFPuppi", postfix="Puppi" ) #-----------------------ELECTRON ID------------------------------- from NeroProducer.Nero.egammavid_cfi import * initEGammaVID(process,options) ############### end of met conf avoid overwriting
def metCorrector(process, jetCollection, metCollection, isMC, payloadName, applyL2L3Residuals, addMETSystematics, useOfficialMETSystematics): ## propagation on missing energy + full systematics if "Puppi" in metCollection or "PUPPI" in metCollection: postfix = "Puppi" else: postfix = "" #### run the right recipe for puppi candidates for MET (as well taking last for jets) if postfix == "Puppi" and not hasattr(process, "puppi") and not hasattr( process, "puppiForMET"): from PhysicsTools.PatAlgos.slimming.puppiForMET_cff import makePuppiesFromMiniAOD makePuppiesFromMiniAOD(process, False) process.puppi.useExistingWeights = cms.bool(False) process.puppiNoLep.useExistingWeights = cms.bool(False) ###################### if useOfficialMETSystematics and addMETSystematics: ## use the official jet-MET tool ## re-run for standard met if postfix == "Puppi": if isMC: runMetCorAndUncFromMiniAOD( process, isData=False, pfCandColl=cms.InputTag("puppiForMET"), recoMetFromPFCs=True, metType=postfix, postfix=postfix, jetFlavor="AK4PFPuppi") else: runMetCorAndUncFromMiniAOD( process, isData=True, pfCandColl=cms.InputTag("puppiForMET"), recoMetFromPFCs=True, metType=postfix, postfix=postfix, jetFlavor="AK4PFPuppi") if applyL2L3Residuals == False and not isMC: process.patPFMetT1T2CorrPuppi.jetCorrLabelRes = cms.InputTag( "L3Absolute") process.patPFMetT1T2SmearCorrPuppi.jetCorrLabelRes = cms.InputTag( "L3Absolute") process.patPFMetT2CorrPuppi.jetCorrLabelRes = cms.InputTag( "L3Absolute") process.patPFMetT2SmearCorrPuppi.jetCorrLabelRes = cms.InputTag( "L3Absolute") process.shiftedPatJetEnDownPuppi.jetCorrLabelUpToL3Res = cms.InputTag( "ak4PFCHSL1FastL2L3Corrector") process.shiftedPatJetEnUpPuppi.jetCorrLabelUpToL3Res = cms.InputTag( "ak4PFCHSL1FastL2L3Corrector") else: if isMC: runMetCorAndUncFromMiniAOD(process, isData=False) else: runMetCorAndUncFromMiniAOD(process, isData=True) if applyL2L3Residuals == False and not isMC: process.patPFMetT1T2Corr.jetCorrLabelRes = cms.InputTag( "L3Absolute") process.patPFMetT1T2SmearCorr.jetCorrLabelRes = cms.InputTag( "L3Absolute") process.patPFMetT2Corr.jetCorrLabelRes = cms.InputTag( "L3Absolute") process.patPFMetT2SmearCorr.jetCorrLabelRes = cms.InputTag( "L3Absolute") process.shiftedPatJetEnDown.jetCorrLabelUpToL3Res = cms.InputTag( "ak4PFCHSL1FastL2L3Corrector") process.shiftedPatJetEnUp.jetCorrLabelUpToL3Res = cms.InputTag( "ak4PFCHSL1FastL2L3Corrector") else: ## extract genMet if not hasattr(process, "genMetExtractor") and isMC: setattr( process, "genMetExtractor", cms.EDProducer("GenMETExtractor", metSource=cms.InputTag(metCollection, "", "@skipCurrentProcess"))) ## redo raw PF met for both collections if not hasattr(process, "pfMet" + postfix): setattr( process, "pfMet" + postfix, pfMet.clone(src=cms.InputTag("packedPFCandidates"), alias=cms.string('pfMet' + postfix))) if postfix == "Puppi": getattr(process, "pfMet" + postfix).src = cms.InputTag('puppiForMET') ## re-cast PFMets into PAT objects addMETCollection(process, labelName='patPFMet' + postfix, metSource='pfMet' + postfix) if isMC: getattr(process, "patPFMet" + postfix).addGenMET = cms.bool(True) getattr(process, "patPFMet" + postfix).genMETSource = cms.InputTag("genMetExtractor") else: getattr(process, "patPFMet" + postfix).addGenMET = cms.bool(False) ## derive type-I corrector object setattr( process, "patPFMetT1Corr" + postfix, patPFMetT1T2Corr.clone( src=cms.InputTag(jetCollection), type1JetPtThreshold=cms.double(15.0), )) ## no L1 correction for Puppi if postfix == "Puppi": getattr(process, "patPFMetT1Corr" + postfix).offsetCorrLabel = cms.InputTag( "") ## info embedded in the jet object ## apply type-I corrections setattr( process, "patPFMetT1" + postfix, cms.EDProducer("CorrectedPATMETProducer", src=cms.InputTag("patPFMet" + postfix), srcCorrections=cms.VInputTag( cms.InputTag("patPFMetT1Corr" + postfix, "type1")))) ## re-compute all MET systematics if addMETSystematics: setattr( process, "metSysProducer" + postfix, cms.EDProducer( "METSystematicsProducer", inputMET=cms.InputTag("patPFMetT1" + postfix), rho=cms.InputTag("fixedGridRhoFastjetAll"), pfCandidate=cms.InputTag("packedPFCandidates"), ## skip candidates storeSmearedShiftedCollections=cms.bool(True), skipMuon=cms.bool(False), skipElectron=cms.bool(False), skipTau=cms.bool(False), skipPhoton=cms.bool(False), skipJet=cms.bool(False), ## muons muon=cms.PSet( src=cms.InputTag("slimmedMuons"), useExternalUncertainty=cms.bool(True), binning=cms.VPSet( cms.PSet(binSelection=cms.string("pt < 100"), uncertainty=cms.double(0.002)), cms.PSet(binSelection=cms.string("pt >= 100"), uncertainty=cms.double(0.05)))), ## electrons electron=cms.PSet( src=cms.InputTag("slimmedElectrons"), useExternalUncertainty=cms.bool(True), binning=cms.VPSet( cms.PSet(binSelection=cms.string("isEB"), uncertainty=cms.double(0.006)), cms.PSet(binSelection=cms.string("!isEB"), uncertainty=cms.double(0.015)))), ## electrons photon=cms.PSet( src=cms.InputTag("slimmedPhotons"), useExternalUncertainty=cms.bool(True), binning=cms.VPSet( cms.PSet(binSelection=cms.string('isEB'), uncertainty=cms.double(0.01)), cms.PSet(binSelection=cms.string('!isEB'), uncertainty=cms.double(0.025)))), ## taus tau=cms.PSet( src=cms.InputTag("slimmedTaus"), useExternalUncertainty=cms.bool(True), binning=cms.VPSet( cms.PSet(binSelection=cms.string( "abs(eta) < 2.5 && pt > 18. && tauID(\'decayModeFindingNewDMs\')> 0.5" ), uncertainty=cms.double(0.03)), )), jet=cms.PSet( ## input collection src=cms.InputTag(jetCollection), selection=cms.string( 'pt > 15 && abs(eta) < 9.9 && (chargedEmEnergyFraction+neutralEmEnergyFraction) < 0.9' ), ## information for jet energy correction payloadName=cms.string(payloadName), useExternalJECUncertainty=cms.bool(False), JECUncFile=cms.FileInPath( "AnalysisCode/MonoXAnalysis/data/JEC/Fall15_25nsV2_DATA_Uncertainty_" + payloadName + ".txt"), #https://twiki.cern.ch/twiki/bin/view/CMS/JetResolution JERFile=cms.FileInPath( "AnalysisCode/MonoXAnalysis/data/JER/Fall15_25nsV2_DATA_PtResolution_" + payloadName + ".txt"), JERSFFile=cms.FileInPath( "AnalysisCode/MonoXAnalysis/data/JER/Fall15_25nsV2_DATA_SF_" + payloadName + ".txt"), jetCorrLabel=cms.InputTag("L3Absolute"), jetCorrLabelRes=cms.InputTag("L2L3Residual"), useExternalJERSF=cms.bool(False), useExternalJER=cms.bool(False)), ## unclustered component unclustered=cms.PSet( useExternalUncertainty=cms.bool(True), binning=cms.VPSet( cms.PSet( binSelection=cms.string("charge!=0"), binUncertainty=cms.string( "sqrt(pow(0.00009*pt,2)+pow(0.0085/sqrt(sin(2*atan(exp(eta)))),2))" )), cms.PSet( binSelection=cms.string("pdgId==130"), binUncertainty=cms.string( "((abs(eta)<1.3)?(max(0.25,sqrt(pow(0.8/sqrt(energy), 2)+0.05*0.05))):(max(0.30,sqrt(pow(1.0/sqrt(energy),2)+0.04*0.04))))" )), cms.PSet( binSelection=cms.string("pdgId==22"), binUncertainty=cms.string( "sqrt(pow(0.00009*energy,2)+pow(0.0085/sqrt(sin(2*atan(exp(eta)))),2))" )), cms.PSet( binSelection=cms.string( 'pdgId==1 || pdgId==2'), binUncertainty=cms.string( 'sqrt(pow(1/sqrt(energy),2)+0.05*0.05)+0*eta' ), )), ))) if isMC: getattr( process, "metSysProducer" + postfix ).jet.JECUncFile = cms.FileInPath( "AnalysisCode/MonoXAnalysis/data/JEC/Fall15_25nsV2_MC_Uncertainty_" + payloadName + ".txt") getattr( process, "metSysProducer" + postfix ).jet.JERFile = cms.FileInPath( "AnalysisCode/MonoXAnalysis/data/JER/Fall15_25nsV2_MC_PtResolution_" + payloadName + ".txt") ### add xy corrections if not hasattr(process, "patPFMetTxyCorr" + postfix): setattr( process, "patPFMetTxyCorr" + postfix, pfMEtMultShiftCorr.clone( srcPFlow=cms.InputTag('packedPFCandidates'), vertexCollection=cms.InputTag( 'offlineSlimmedPrimaryVertices'))) setattr( process, 'patPFMetT1Txy' + postfix, cms.EDProducer( "CorrectedPATMETProducer", src=cms.InputTag("patPFMet" + postfix), srcCorrections=cms.VInputTag( cms.InputTag("patPFMetT1Corr" + postfix, "type1"), cms.InputTag("patPFMetTxyCorr" + postfix)))) ## final slimmed MET setattr( process, metCollection, cms.EDProducer( "PATMETSlimmer", caloMET=cms.InputTag("patPFMet" + postfix), rawVariation=cms.InputTag("patPFMet" + postfix), runningOnMiniAOD=cms.bool(True), src=cms.InputTag("patPFMetT1" + postfix), t01Variation=cms.InputTag(metCollection, "", "@skipCurrentProcess"), t1Uncertainties=cms.InputTag("metSysProducer" + postfix, "patPFMetT1" + postfix + "%s"), tXYUncForRaw=cms.InputTag(metCollection, "", "@skipCurrentProcess"), tXYUncForT1=cms.InputTag('patPFMetT1Txy' + postfix), t1SmearedVarsAndUncs=cms.InputTag( "metSysProducer" + postfix, "patPFMetT1" + postfix + "Smear%s"))) else: setattr( process, metCollection, cms.EDProducer( "PATMETSlimmer", caloMET=cms.InputTag("patPFMet" + postfix), rawVariation=cms.InputTag("patPFMet" + postfix), runningOnMiniAOD=cms.bool(True), src=cms.InputTag("patPFMetT1" + postfix), t01Variation=cms.InputTag(metCollection, "", "@skipCurrentProcess"), tXYUncForRaw=cms.InputTag(metCollection, "", "@skipCurrentProcess"), tXYUncForT1=cms.InputTag(metCollection, "", "@skipCurrentProcess"), t1Uncertainties=cms.InputTag(metCollection, "", "@skipCurrentProcess"), t1SmearedVarsAndUncs=cms.InputTag(metCollection, "", "@skipCurrentProcess")))
def JetSubstructure(process, isMC, coneSize=0.8, algo="AK", pileupMethod="chs", selection="pt > 175 && abs(eta) < 2.5", addPruning=True, addPrunedSubjets=True, addSoftDrop=True, addSoftDropSubjets=True, addTrimming=False, addTrimmedSubjets=False, addFiltering=False, addFilteredSubjets=False, addNsubjettiness=True, addEnergyCorrelation=True, addQJets=False, addQGLikelihood=True): print "############################" print "add substructure information" print "isMC = ", isMC print "coneSize = ", coneSize print "algo = ", algo print "pileupMethod = ", pileupMethod print "selection = ", selection print "addPruning = ", addPruning print "addPrunedSubjets = ", addPrunedSubjets print "addSoftDrop = ", addSoftDrop print "addSoftDropSubjets = ", addSoftDropSubjets print "addTrimming = ", addTrimming print "addTrimmedSubjets = ", addTrimmedSubjets print "addFiltering = ", addFiltering print "addFilteredSubjets = ", addFilteredSubjets print "addNsubjettiness = ", addNsubjettiness print "addEnergyCorrelation = ", addEnergyCorrelation print "addQJets = ", addQJets print "addQGLikelihood = ", addQGLikelihood print "############################" ## build jet algo name for jet clustering coneSizeStr = str(coneSize).replace("0", "").replace(".", "") jetAlgo = algo + coneSizeStr if algo == "AK": ALGO = "AntiKt" elif algo == "CA": ALGO = "CambridgeAachen" if isMC: ## run gen jet clustering from genParticles if not hasattr(process, "genParticlesForJetsNoNu"): setattr( process, 'genParticlesForJetsNoNu', cms.EDFilter( "CandPtrSelector", src=cms.InputTag("packedGenParticles"), cut=cms.string( "abs(pdgId) != 12 && abs(pdgId) != 14 && abs(pdgId) != 16 && abs(pdgId) != 1000022 && abs(pdgId) != 1000012 &&" + "abs(pdgId) != 1000014 && abs(pdgId) != 1000016 && abs(pdgId) != 2000012 && abs(pdgId) != 2000014 &&" + "abs(pdgId) != 2000016 && abs(pdgId) != 1000039 && abs(pdgId) != 5100039 && abs(pdgId) != 4000012 &&" + "abs(pdgId) != 4000014 && abs(pdgId) != 4000016 && abs(pdgId) != 9900012 && abs(pdgId) != 9900014 &&" + "abs(pdgId) != 9900016 && abs(pdgId) != 39 && abs(pdgId) != 9100012" ))) ## skip all the possible invisible particles if not hasattr(process, "genJets" + jetAlgo): setattr( process, "genJets" + jetAlgo, ak4GenJets.clone(src='genParticlesForJetsNoNu', rParam=coneSize, jetAlgorithm=ALGO, jetPtMin=cms.double(50.)) ) ## fix a lower reasonable threshold give the jet response ## filter only hadronically decaying W/Z and Higgs at generator level if not hasattr(process, "genBosons"): setattr( process, "genBosons", cms.EDFilter( "CandPtrSelector", src=cms.InputTag("prunedGenParticles"), cut=cms.string( "(abs(pdgId) == 23 || abs(pdgId) == 24 || abs(pdgId) == 25) &&" + "numberOfDaughters > 1 && abs(daughter(0).pdgId) <= 5 && abs(daughter(1).pdgId) <= 5" ))) ## b-tag discriminators to be considered bTagDiscriminators = [ #'pfCombinedInclusiveSecondaryVertexV2BJetTags', ## don't run b-tagging on the whole large cone jet 'pfBoostedDoubleSecondaryVertexAK8BJetTags' ## new tag for Boosted double b-tagging ] ## jet energy corrections already loaded in JECLevels if pileupMethod != "chs" and pileupMethod != "Puppi" and pileupMethod != "": sys.exit( "Invalid pileupMethod setup --> only recognized options are 'chs' and 'Puppi'" ) ## JEC JECLevel = copy.deepcopy(process.JECLevels.labels) payloadName = "" payloadNameSubJet = "" jetCollection = "" pfCand = "" ## in case of CHS select particles and re-cluster jets if pileupMethod == "chs": ## obtain chs candidates if not hasattr(process, "chs"): setattr( process, 'chs', cms.EDFilter('CandPtrSelector', src=cms.InputTag("packedPFCandidates"), cut=cms.string('fromPV'))) ## cluster basic jets given rParameter and algorithm if not hasattr(process, jetAlgo + 'PFJets' + pileupMethod.upper()): setattr( process, jetAlgo + 'PFJets' + pileupMethod.upper(), ak4PFJetsCHS.clone(src=cms.InputTag('chs'), doAreaFastjet=True, rParam=coneSize, jetAlgorithm=ALGO)) payloadName = jetAlgo + 'PF' + pileupMethod payloadNameSubjet = 'AK4PF' + pileupMethod jetCollection = jetAlgo + 'PFJets' + pileupMethod.upper() pfCand = "chs" ## for puppi jets elif pileupMethod == "Puppi": ### re-run optimal puppi weights if not hasattr(process, "puppi"): from PhysicsTools.PatAlgos.slimming.puppiForMET_cff import makePuppiesFromMiniAOD makePuppiesFromMiniAOD(process, False) process.puppi.useExistingWeights = cms.bool(False) process.puppiNoLep.useExistingWeights = cms.bool(False) ## cluster puppi jets given rParameter and algorithm if not hasattr(process, jetAlgo + 'PFJets' + pileupMethod): setattr( process, jetAlgo + 'PFJets' + pileupMethod, ak4PFJetsPuppi.clone(src=cms.InputTag('puppi'), doAreaFastjet=True, rParam=coneSize, jetAlgorithm=ALGO)) payloadName = jetAlgo + 'PF' + pileupMethod payloadNameSubjet = 'AK4PF' + pileupMethod jetCollection = jetAlgo + 'PFJets' + pileupMethod pfCand = "puppi" ## standard PF jets elif pileupMethod == "": ## no pileup mitigation if not hasattr(process, jetAlgo + 'PFJets'): setattr( process, jetAlgo + 'PFJets', ak4PFJetsPuppi.clone(src=cms.InputTag('packedPFCandidates'), doAreaFastjet=True, rParam=coneSize, jetAlgorithm=ALGO)) payloadName = jetAlgo + 'PF' payloadNameSubjet = 'AK4PF' jetCollection = jetAlgo + 'PFJets' pfCand = "packedPFCandidates" ## apply selection and produce a restricted set of consituents only for jets passig the selection if not hasattr(process, jetCollection + "Reduced"): setattr( process, jetCollection + "Reduced", cms.EDFilter("MiniAODJetConstituentSelector", src=cms.InputTag(jetCollection), cut=cms.string("pt > 100 && abs(eta) < 2.5"))) ## build pat-jets from this skimmed collection: example if not hasattr(process, "patJets" + jetCollection): addJetCollection( process, labelName=jetCollection, jetSource=cms.InputTag(jetCollection + "Reduced"), algo=algo, rParam=coneSize, pfCandidates=cms.InputTag(pfCand), jetCorrections=(payloadName, JECLevel, 'None'), svSource=cms.InputTag('slimmedSecondaryVertices'), genJetCollection=cms.InputTag("genJets" + jetAlgo), pvSource=cms.InputTag('offlineSlimmedPrimaryVertices'), btagDiscriminators=bTagDiscriminators, getJetMCFlavour=isMC, genParticles=cms.InputTag("prunedGenParticles"), ) ### special jec set for pruned/sof-drop mass correction --> to be taken from the EDAnalyzer if hasattr(process, "patJetCorrFactors" + jetCollection): if isMC: setattr( process, "patJetCorrFactors" + jetCollection + "v2", getattr( process, "patJetCorrFactors" + jetCollection).clone( levels=cms.vstring('L2Relative', 'L3Absolute'))) else: setattr( process, "patJetCorrFactors" + jetCollection + "v2", getattr(process, "patJetCorrFactors" + jetCollection).clone(levels=cms.vstring( 'L2Relative', 'L3Absolute', 'L2L3Residual'))) getattr(process, "patJets" + jetCollection).jetCorrFactorsSource = cms.VInputTag( cms.InputTag("patJetCorrFactors" + jetCollection), cms.InputTag("patJetCorrFactors" + jetCollection + "v2")) if hasattr(process, "selectedPatJets" + jetCollection): getattr(process, "selectedPatJets" + jetCollection).cut = cms.string(selection) ## match reco-jets with hadronically decaying genBosons (W,Z,H) if isMC: if not hasattr(process, jetCollection + 'GenBosonMatched'): setattr( process, jetCollection + 'GenBosonMatched', cms.EDProducer( "RecoJetCandDeltaRValueMapProducer", ## basic reco::jet ungroomed src=cms.InputTag(jetCollection + "Reduced"), ## mathched groomed pat jet matched=cms.InputTag('genBosons'), distMax=cms.double(coneSize), values=cms.vstring("pt", "eta", "phi", "mass"), valueLabels=cms.vstring("pt", "eta", "phi", "mass"))) getattr(process, 'patJets' + jetCollection).userData.userFloats.src += [ jetCollection + 'GenBosonMatched:pt' ] getattr(process, 'patJets' + jetCollection).userData.userFloats.src += [ jetCollection + 'GenBosonMatched:eta' ] getattr(process, 'patJets' + jetCollection).userData.userFloats.src += [ jetCollection + 'GenBosonMatched:phi' ] getattr(process, 'patJets' + jetCollection).userData.userFloats.src += [ jetCollection + 'GenBosonMatched:mass' ] ## add QGLikelihood on fat jet if addQGLikelihood: if not hasattr(process, jetCollection + "QGL"): setattr( process, jetCollection + "QGL", QGTagger.clone(srcJets=cms.InputTag(jetCollection + "Reduced"), jetsLabel=cms.string('QGL_AK4PFchs'), srcVertexCollection=cms.InputTag( 'offlineSlimmedPrimaryVertices'))) getattr(process, 'patJets' + jetCollection).userData.userFloats.src += [ jetCollection + 'QGL:qgLikelihood' ] ## addNsubjettiness if addNsubjettiness: if not hasattr(process, 'Njettiness' + jetCollection): setattr( process, 'Njettiness' + jetCollection, Njettiness.clone(src=cms.InputTag(jetCollection + "Reduced"), cone=cms.double(coneSize))) getattr(process, 'patJets' + jetCollection).userData.userFloats.src += [ 'Njettiness' + jetCollection + ':tau1', 'Njettiness' + jetCollection + ':tau2', 'Njettiness' + jetCollection + ':tau3', 'Njettiness' + jetCollection + ':tau4' ] ## on gen jets if isMC: if not hasattr(process, "NjettinessGenJets" + jetAlgo): setattr( process, "NjettinessGenJets" + jetAlgo, Njettiness.clone(src=cms.InputTag("genJets" + jetAlgo), cone=cms.double(coneSize))) ## pattify gen jets --> temp if not hasattr(process, 'patGenJets' + jetAlgo): setattr( process, 'patGenJets' + jetAlgo, patJets.clone( jetSource=cms.InputTag("genJets" + jetAlgo), addJetCorrFactors=cms.bool(False), addBTagInfo=cms.bool(False), addDiscriminators=cms.bool(False), discriminatorSources=cms.VInputTag('None'), addAssociatedTracks=cms.bool(False), addJetCharge=cms.bool(False), addGenPartonMatch=cms.bool(False), embedGenPartonMatch=cms.bool(False), addGenJetMatch=cms.bool(False), embedGenJetMatch=cms.bool(False), getJetMCFlavour=cms.bool(False), addJetFlavourInfo=cms.bool(False))) getattr(process, 'patGenJets' + jetAlgo).userData.userFloats.src += [ "NjettinessGenJets" + jetAlgo + ':tau1' ] getattr(process, 'patGenJets' + jetAlgo).userData.userFloats.src += [ "NjettinessGenJets" + jetAlgo + ':tau2' ] getattr(process, 'patGenJets' + jetAlgo).userData.userFloats.src += [ "NjettinessGenJets" + jetAlgo + ':tau3' ] getattr(process, 'patGenJets' + jetAlgo).userData.userFloats.src += [ "NjettinessGenJets" + jetAlgo + ':tau4' ] if not hasattr(process, jetCollection + 'GenNjettinessMatched'): setattr( process, jetCollection + 'GenNjettinessMatched', cms.EDProducer( "RecoPATJetDeltaRValueMapProducer", ## basic reco::jet ungroomed src=cms.InputTag(jetCollection + "Reduced"), ## mathched groomed pat jet matched=cms.InputTag('patGenJets' + jetAlgo), distMax=cms.double(coneSize), values=cms.vstring( "userFloat('NjettinessGenJets" + jetAlgo + ":tau1')", "userFloat('NjettinessGenJets" + jetAlgo + ":tau2')", "userFloat('NjettinessGenJets" + jetAlgo + ":tau3')", "userFloat('NjettinessGenJets" + jetAlgo + ":tau4')"), valueLabels=cms.vstring("tau1", "tau2", "tau3", "tau4"))) getattr(process, 'patJets' + jetCollection).userData.userFloats.src += [ jetCollection + 'GenNjettinessMatched:tau1', jetCollection + 'GenNjettinessMatched:tau2', jetCollection + 'GenNjettinessMatched:tau3', jetCollection + 'GenNjettinessMatched:tau4' ] ## add ECF if addEnergyCorrelation: if not hasattr(process, 'ecf' + jetCollection): setattr( process, 'ecf' + jetCollection, ECF.clone(src=cms.InputTag(jetCollection + "Reduced"), Njets=cms.vuint32(1, 2, 3))) getattr(process, 'patJets' + jetCollection).userData.userFloats.src += [ 'ecf' + jetCollection + ':ecf1' ] getattr(process, 'patJets' + jetCollection).userData.userFloats.src += [ 'ecf' + jetCollection + ':ecf2' ] getattr(process, 'patJets' + jetCollection).userData.userFloats.src += [ 'ecf' + jetCollection + ':ecf3' ] ## add QJets if addQJets: if not hasattr(process, "qjets" + jetCollection): setattr( process, "qjets" + jetCollection, QJetsAdder.clone(src=cms.InputTag(jetCollection + "Reduced"), jeRad=cms.double(coneSize), jetAlgo=cms.string(algo))) setattr(process, 'patJets' + jetCollection).userData.userFloats.src += [ "qjets" + jetCollection + ":QjetsVolatility" ] ### start with substructure: Pruning (run it on both reco and gen jets): Tags = [] Labels = [] JECLevelTemp = copy.deepcopy(JECLevel) if 'L1FastJet' in JECLevelTemp: JECLevelTemp.remove( 'L1FastJet') ## in any case groomers are removing already pileup if addPruning: runGroomedMethod(process, isMC=isMC, jetCollection=jetCollection, coneSize=coneSize, algo=algo, payloadName=payloadName, payloadNameSubjet=payloadNameSubjet, JECLevel=JECLevelTemp, pfCand=pfCand, btagDiscriminators=bTagDiscriminators, addSubJets=addPrunedSubjets, addQGLikelihood=addQGLikelihood, isPruning=True, isSoftDrop=False, isTrimming=False, isFiltering=False) if addPrunedSubjets: Tags += ['patJets' + jetCollection + 'PrunedPacked'] Labels += ['Pruned'] if addSoftDrop: runGroomedMethod(process, isMC=isMC, jetCollection=jetCollection, coneSize=coneSize, algo=algo, payloadName=payloadName, payloadNameSubjet=payloadNameSubjet, JECLevel=JECLevelTemp, pfCand=pfCand, btagDiscriminators=bTagDiscriminators, addSubJets=addSoftDropSubjets, addQGLikelihood=addQGLikelihood, isPruning=False, isSoftDrop=True, isTrimming=False, isFiltering=False) if addSoftDropSubjets: Tags += ['patJets' + jetCollection + 'SoftDropPacked'] Labels += ['SoftDrop'] if addTrimming: runGroomedMethod(process, isMC=isMC, jetCollection=jetCollection, coneSize=coneSize, algo=algo, payloadName=payloadName, payloadNameSubjet=payloadNameSubjet, JECLevel=JECLevelTemp, pfCand=pfCand, btagDiscriminators=bTagDiscriminators, addSubJets=addTrimmedSubjets, addQGLikelihood=addQGLikelihood, isPruning=False, isSoftDrop=False, isTrimming=True, isFiltering=False) if addTrimmedSubjets: Tags += ['patJets' + jetCollection + 'TrimmedPacked'] Labels += ['Trimmed'] if addFiltering: runGroomedMethod(process, isMC=isMC, jetCollection=jetCollection, coneSize=coneSize, algo=algo, payloadName=payloadName, payloadNameSubjet=payloadNameSubjet, JECLevel=JECLevelTemp, pfCand=pfCand, btagDiscriminators=bTagDiscriminators, addSubJets=addFilteredSubjets, addQGLikelihood=addQGLikelihood, isPruning=False, isSoftDrop=False, isTrimming=False, isFiltering=True) if addFilteredSubjets: Tags += ['patJets' + jetCollection + 'FilteredPacked'] Labels += ['Filtered'] ## finally fix the pat fat jet collection if not hasattr(process, "packedPatJets" + jetCollection): setattr( process, "packedPatJets" + jetCollection, cms.EDProducer("JetSubstructurePacker", jetSrc=cms.InputTag("selectedPatJets" + jetCollection), distMax=cms.double(coneSize), fixDaughters=cms.bool(False), algoTags=cms.VInputTag(), algoLabels=cms.vstring())) getattr(process, "packedPatJets" + jetCollection).algoTags = Tags getattr(process, "packedPatJets" + jetCollection).algoLabels = Labels return "packedPatJets" + jetCollection
process.jets = cms.Task() process.jets.add(process.MergeAK15FatjetsAndSubjets) process.jets.add(process.AK15PFPuppiComplete) process.jets.add(process.MergeAK8FatjetsAndSubjets) process.jets.add(process.AK8PFPuppiComplete) ###################################################### ####################### MET stuff ############################# from PhysicsTools.PatUtils.tools.runMETCorrectionsAndUncertainties import ( runMetCorAndUncFromMiniAOD, ) from PhysicsTools.PatAlgos.slimming.puppiForMET_cff import makePuppiesFromMiniAOD makePuppiesFromMiniAOD(process, False) runMetCorAndUncFromMiniAOD( process, isData=options.isData, fixEE2017=True if "2017" in options.dataEra else False, fixEE2017Params={ "userawPt": True, "ptThreshold": 50.0, "minEtaThreshold": 2.65, "maxEtaThreshold": 3.139, }, ) runMetCorAndUncFromMiniAOD( process,