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,
