def toolCode(self, process):
electronCollection = self._parameters['electronCollection'].value
photonCollection = self._parameters['photonCollection'].value
muonCollection = self._parameters['muonCollection'].value
tauCollection = self._parameters['tauCollection'].value
jetCollection = self._parameters['jetCollection'].value
jetCorrLabel = self._parameters['jetCorrLabel'].value
dRjetCleaning = self._parameters['dRjetCleaning'].value
doSmearJets = self._parameters['doSmearJets'].value
jetSmearFileName = self._parameters['jetSmearFileName'].value
jetSmearHistogram = self._parameters['jetSmearHistogram'].value
jetCorrPayloadName = self._parameters['jetCorrPayloadName'].value
jetCorrLabelUpToL3 = self._parameters['jetCorrLabelUpToL3'].value
jetCorrLabelUpToL3Res = self._parameters['jetCorrLabelUpToL3Res'].value
jecUncertaintyFile = self._parameters['jecUncertaintyFile'].value
jecUncertaintyTag = self._parameters['jecUncertaintyTag'].value
varyByNsigmas = self._parameters['varyByNsigmas'].value
addToPatDefaultSequence = self._parameters['addToPatDefaultSequence'].value
outputModule = self._parameters['outputModule'].value
postfix = self._parameters['postfix'].value
if not hasattr(process, "jetUncertaintySequence" + postfix):
jetUncertaintySequence = cms.Sequence()
setattr(process, "jetUncertaintySequence" + postfix, jetUncertaintySequence)
jetUncertaintySequence = getattr(process, "jetUncertaintySequence" + postfix)
collectionsToKeep = []
# produce collection of jets not overlapping with reconstructed
# electrons/photons, muons and tau-jet candidates
lastJetCollection, cleanedJetCollection = \
self._addCleanedJets(process, jetCollection,
electronCollection, photonCollection, muonCollection, tauCollection,
jetUncertaintySequence, postfix)
# smear jet energies to account for difference in jet resolutions between MC and Data
# (cf. JME-10-014 PAS)
jetCollectionResUp = None
jetCollectionResDown = None
if doSmearJets:
lastJetCollection = \
self._addSmearedJets(process, cleanedJetCollection, [ "smeared", jetCollection.value() ],
jetSmearFileName, jetSmearHistogram, varyByNsigmas,
uncertaintySequence = jetUncertaintySequence, postfix = postfix)
jetCollectionResUp = \
self._addSmearedJets(process, cleanedJetCollection, [ "smeared", jetCollection.value(), "ResUp" ],
jetSmearFileName, jetSmearHistogram, varyByNsigmas, -1.,
uncertaintySequence = jetUncertaintySequence, postfix = postfix)
collectionsToKeep.append(jetCollectionResUp)
jetCollectionResDown = \
self._addSmearedJets(process, cleanedJetCollection, [ "smeared", jetCollection.value(), "ResDown" ],
jetSmearFileName, jetSmearHistogram, varyByNsigmas, +1.,
uncertaintySequence = jetUncertaintySequence, postfix = postfix)
collectionsToKeep.append(jetCollectionResDown)
collectionsToKeep.append(lastJetCollection)
#--------------------------------------------------------------------------------------------
# produce collection of electrons/photons, muons, tau-jet candidates and jets
# shifted up/down in energy by their respective energy uncertainties
#--------------------------------------------------------------------------------------------
shiftedParticleSequence, shiftedParticleCollections, addCollectionsToKeep = \
self._addShiftedParticleCollections(process,
None,
None,
None,
None,
jetCollection, cleanedJetCollection, lastJetCollection,
jetCollectionResUp, jetCollectionResDown,
jetCorrLabelUpToL3, jetCorrLabelUpToL3Res,
jecUncertaintyFile, jecUncertaintyTag,
varyByNsigmas,
postfix)
setattr(process, "shiftedParticlesForJetUncertainties" + postfix, shiftedParticleSequence)
jetUncertaintySequence += getattr(process, "shiftedParticlesForJetUncertainties" + postfix)
collectionsToKeep.extend(addCollectionsToKeep)
# insert metUncertaintySequence into patDefaultSequence
if addToPatDefaultSequence:
if not hasattr(process, "patDefaultSequence"):
raise ValueError("PAT default sequence is not defined !!")
process.patDefaultSequence += jetUncertaintySequence
# add shifted + unshifted collections pf pat::Electrons/Photons,
# Muons, Taus, Jets and MET to PAT-tuple event content
if outputModule is not None and hasattr(process, outputModule):
getattr(process, outputModule).outputCommands = _addEventContent(
getattr(process, outputModule).outputCommands,
[ 'keep *_%s_*_%s' % (collectionToKeep, process.name_()) for collectionToKeep in collectionsToKeep ])
def toolCode(self, process):
electronCollection = self._parameters['electronCollection'].value
photonCollection = self._parameters['photonCollection'].value
muonCollection = self._parameters['muonCollection'].value
tauCollection = self._parameters['tauCollection'].value
jetCollection = self._parameters['jetCollection'].value
jetCorrLabel = self._parameters['jetCorrLabel'].value
doSmearJets = self._parameters['doSmearJets'].value
jetSmearFileName = self._parameters['jetSmearFileName'].value
jetSmearHistogram = self._parameters['jetSmearHistogram'].value
pfCandCollection = self._parameters['pfCandCollection'].value
jetCorrPayloadName = self._parameters['jetCorrPayloadName'].value
jetCorrLabelUpToL3 = self._parameters['jetCorrLabelUpToL3'].value
jetCorrLabelUpToL3Res = self._parameters['jetCorrLabelUpToL3Res'].value
jecUncertaintyFile = self._parameters['jecUncertaintyFile'].value
jecUncertaintyTag = self._parameters['jecUncertaintyTag'].value
varyByNsigmas = self._parameters['varyByNsigmas'].value
addToPatDefaultSequence = self._parameters[
'addToPatDefaultSequence'].value
outputModule = self._parameters['outputModule'].value
postfix = self._parameters['postfix'].value
if not hasattr(process, "pfMVAMEtUncertaintySequence" + postfix):
metUncertaintySequence = cms.Sequence()
setattr(process, "pfMVAMEtUncertaintySequence" + postfix,
metUncertaintySequence)
metUncertaintySequence = getattr(
process, "pfMVAMEtUncertaintySequence" + postfix)
collectionsToKeep = []
lastJetCollection = jetCollection.value()
# smear jet energies to account for difference in jet resolutions between MC and Data
# (cf. JME-10-014 PAS)
jetCollectionResUp = None
jetCollectionResDown = None
if doSmearJets:
lastJetCollection = \
self._addSmearedJets(process, lastJetCollection, [ "smeared", jetCollection.value(), "ForPFMEtByMVA" ],
jetSmearFileName, jetSmearHistogram, varyByNsigmas,
uncertaintySequence = metUncertaintySequence, postfix = postfix)
jetCollectionResUp = \
self._addSmearedJets(process, lastJetCollection, [ "smeared", jetCollection.value(), "ForPFMEtByMVAResUp" ],
jetSmearFileName, jetSmearHistogram, varyByNsigmas, -1.,
uncertaintySequence = metUncertaintySequence, postfix = postfix)
collectionsToKeep.append(jetCollectionResUp)
jetCollectionResDown = \
self._addSmearedJets(process, lastJetCollection, [ "smeared", jetCollection.value(), "ForPFMEtByMVAResDown" ],
jetSmearFileName, jetSmearHistogram, varyByNsigmas, +1.,
uncertaintySequence = metUncertaintySequence, postfix = postfix)
collectionsToKeep.append(jetCollectionResDown)
collectionsToKeep.append(lastJetCollection)
#--------------------------------------------------------------------------------------------
# produce collection of electrons/photons, muons, tau-jet candidates and jets
# shifted up/down in energy by their respective energy uncertainties
#--------------------------------------------------------------------------------------------
shiftedParticleSequence, shiftedParticleCollections, addCollectionsToKeep = \
self._addShiftedParticleCollections(process,
electronCollection,
photonCollection,
muonCollection,
tauCollection,
jetCollection, None, lastJetCollection,
jetCollectionResUp, jetCollectionResDown,
jetCorrLabelUpToL3, jetCorrLabelUpToL3Res,
jecUncertaintyFile, jecUncertaintyTag,
varyByNsigmas,
"ForPFMEtByMVA" + postfix)
setattr(process,
"shiftedParticlesForPFMEtByMVAUncertainties" + postfix,
shiftedParticleSequence)
metUncertaintySequence += getattr(
process, "shiftedParticlesForPFMEtByMVAUncertainties" + postfix)
collectionsToKeep.extend(addCollectionsToKeep)
#--------------------------------------------------------------------------------------------
# propagate shifted particle energies to MVA MET
#--------------------------------------------------------------------------------------------
self._addPFMEtByMVA(process, metUncertaintySequence,
shiftedParticleCollections, pfCandCollection,
collectionsToKeep, doSmearJets, jecUncertaintyFile,
jecUncertaintyTag, varyByNsigmas, postfix)
# insert metUncertaintySequence into patDefaultSequence
if addToPatDefaultSequence:
if not hasattr(process, "patDefaultSequence"):
raise ValueError("PAT default sequence is not defined !!")
process.patDefaultSequence += metUncertaintySequence
# add shifted + unshifted collections pf pat::Electrons/Photons,
# Muons, Taus, Jets and MET to PAT-tuple event content
if outputModule is not None and hasattr(process, outputModule):
getattr(process, outputModule).outputCommands = _addEventContent(
getattr(process, outputModule).outputCommands, [
'keep *_%s_*_%s' % (collectionToKeep, process.name_())
for collectionToKeep in collectionsToKeep
])
def toolCode(self, process):
electronCollection = self._parameters['electronCollection'].value
photonCollection = self._parameters['photonCollection'].value
muonCollection = self._parameters['muonCollection'].value
tauCollection = self._parameters['tauCollection'].value
jetCollection = self._parameters['jetCollection'].value
jetCollectionUnskimmed = self._parameters['jetCollectionUnskimmed'].value
jetCorrLabel = self._parameters['jetCorrLabel'].value
dRjetCleaning = self._parameters['dRjetCleaning'].value
doSmearJets = self._parameters['doSmearJets'].value
makeType1corrPFMEt = self._parameters['makeType1corrPFMEt'].value
makeType1p2corrPFMEt = self._parameters['makeType1p2corrPFMEt'].value
doApplyType0corr = self._parameters['doApplyType0corr'].value
sysShiftCorrParameter = self._parameters['sysShiftCorrParameter'].value
doApplySysShiftCorr = self._parameters['doApplySysShiftCorr'].value
jetSmearFileName = self._parameters['jetSmearFileName'].value
jetSmearHistogram = self._parameters['jetSmearHistogram'].value
pfCandCollection = self._parameters['pfCandCollection'].value
doApplyUnclEnergyCalibration = self._parameters['doApplyUnclEnergyCalibration'].value
jetCorrPayloadName = self._parameters['jetCorrPayloadName'].value
jetCorrLabelUpToL3 = self._parameters['jetCorrLabelUpToL3'].value
jetCorrLabelUpToL3Res = self._parameters['jetCorrLabelUpToL3Res'].value
jecUncertaintyFile = self._parameters['jecUncertaintyFile'].value
jecUncertaintyTag = self._parameters['jecUncertaintyTag'].value
varyByNsigmas = self._parameters['varyByNsigmas'].value
addToPatDefaultSequence = self._parameters['addToPatDefaultSequence'].value
outputModule = self._parameters['outputModule'].value
postfix = self._parameters['postfix'].value
if not hasattr(process, "pfType1MEtUncertaintySequence" + postfix):
metUncertaintySequence = cms.Sequence()
setattr(process, "pfType1MEtUncertaintySequence" + postfix, metUncertaintySequence)
metUncertaintySequence = getattr(process, "pfType1MEtUncertaintySequence" + postfix)
collectionsToKeep = []
if isValidInputTag(jetCollection):
# produce collection of jets not overlapping with reconstructed
# electrons/photons, muons and tau-jet candidates
lastJetCollection, cleanedJetCollection = \
self._addCleanedJets(process, jetCollection,
electronCollection, photonCollection, muonCollection, tauCollection,
metUncertaintySequence, postfix)
# smear jet energies to account for difference in jet resolutions between MC and Data
# (cf. JME-10-014 PAS)
if doSmearJets:
lastJetCollection = \
addSmearedJets(process, cleanedJetCollection,
[ "smeared", jetCollection.value() ],
jetSmearFileName, jetSmearHistogram, jetResolutions,
varyByNsigmas, None, metUncertaintySequence, postfix)
collectionsToKeep.append( lastJetCollection )
#for default w/o smearing
collectionsToKeep.append( lastJetCollection )
#--------------------------------------------------------------------------------------------
# produce collection of electrons/photons, muons, tau-jet candidates and jets
# shifted up/down in energy by their respective energy uncertainties
#--------------------------------------------------------------------------------------------
shiftedParticleSequence, shiftedParticleCollections, addCollectionsToKeep = \
self._addShiftedParticleCollections(process,
electronCollection.value() if isValidInputTag(electronCollection) else "",
photonCollection.value() if isValidInputTag(photonCollection) else "",
muonCollection.value() if isValidInputTag(muonCollection) else "",
tauCollection.value() if isValidInputTag(tauCollection) else "",
jetCollection.value() if isValidInputTag(jetCollection) else "",
cleanedJetCollection,
lastJetCollection, doSmearJets,
jetCorrLabelUpToL3, jetCorrLabelUpToL3Res,
jecUncertaintyFile, jecUncertaintyTag,
jetSmearFileName, jetSmearHistogram,
varyByNsigmas, postfix)
setattr(process, "shiftedParticlesForType1PFMEtUncertainties" + postfix, shiftedParticleSequence)
metUncertaintySequence += getattr(process, "shiftedParticlesForType1PFMEtUncertainties" + postfix)
collectionsToKeep.extend(addCollectionsToKeep)
#--------------------------------------------------------------------------------------------
# propagate shifted particle energies to Type 1 and Type 1 + 2 corrected PFMET
#--------------------------------------------------------------------------------------------
self._addCorrPFMEt(process, metUncertaintySequence,
shiftedParticleCollections, pfCandCollection, jetCollectionUnskimmed,
doApplyUnclEnergyCalibration,
collectionsToKeep,
doSmearJets,
makeType1corrPFMEt,
makeType1p2corrPFMEt,
doApplyType0corr,
sysShiftCorrParameter,
doApplySysShiftCorr,
jetCorrLabel,
varyByNsigmas,
postfix)
# insert metUncertaintySequence into patDefaultSequence
if addToPatDefaultSequence:
if not hasattr(process, "patDefaultSequence"):
raise ValueError("PAT default sequence is not defined !!")
process.patDefaultSequence += metUncertaintySequence
# add shifted + unshifted collections pf pat::Electrons/Photons,
# Muons, Taus, Jets and MET to PAT-tuple event content
if outputModule is not None and hasattr(process, outputModule):
getattr(process, outputModule).outputCommands = _addEventContent(
getattr(process, outputModule).outputCommands,
[ 'keep *_%s_*_%s' % (collectionToKeep, process.name_()) for collectionToKeep in collectionsToKeep ])
def toolCode(self, process):
electronCollection = self._parameters['electronCollection'].value
photonCollection = self._parameters['photonCollection'].value
muonCollection = self._parameters['muonCollection'].value
tauCollection = self._parameters['tauCollection'].value
jetCollection = self._parameters['jetCollection'].value
jetCorrLabel = self._parameters['jetCorrLabel'].value
dRjetCleaning = self._parameters['dRjetCleaning'].value
caloTowerCollection = self._parameters['caloTowerCollection'].value
jetCorrPayloadName = self._parameters['jetCorrPayloadName'].value
jetCorrLabelUpToL3 = self._parameters['jetCorrLabelUpToL3'].value
jetCorrLabelUpToL3Res = self._parameters['jetCorrLabelUpToL3Res'].value
jecUncertaintyFile = self._parameters['jecUncertaintyFile'].value
jecUncertaintyTag = self._parameters['jecUncertaintyTag'].value
varyByNsigmas = self._parameters['varyByNsigmas'].value
type1JetPtThreshold = self._parameters['type1JetPtThreshold'].value
addToPatDefaultSequence = self._parameters['addToPatDefaultSequence'].value
outputModule = self._parameters['outputModule'].value
postfix = self._parameters['postfix'].value
if not hasattr(process, "caloType1MEtUncertaintySequence" + postfix):
metUncertaintySequence = cms.Sequence()
setattr(process, "caloType1MEtUncertaintySequence" + postfix, metUncertaintySequence)
metUncertaintySequence = getattr(process, "caloType1MEtUncertaintySequence" + postfix)
collectionsToKeep = []
# produce collection of jets not overlapping with reconstructed
# electrons/photons, muons and tau-jet candidates
lastJetCollection, cleanedJetCollection = \
self._addCleanedJets(process, jetCollection,
electronCollection, photonCollection, muonCollection, tauCollection,
metUncertaintySequence, postfix)
moduleJetsNotOverlappingWithLeptonsPtGtType1Threshold = cms.EDFilter("PATJetSelector",
src = cms.InputTag(lastJetCollection),
cut = cms.string('pt > %f' % type1JetPtThreshold)
)
moduleJetsNotOverlappingWithLeptonsPtGtType1ThresholdName = "%sNotOverlappingWithLeptonsPtGtType1ThresholdForJetMEtUncertainty" % jetCollection.value()
setattr(process, moduleJetsNotOverlappingWithLeptonsPtGtType1ThresholdName, moduleJetsNotOverlappingWithLeptonsPtGtType1Threshold)
metUncertaintySequence += moduleJetsNotOverlappingWithLeptonsPtGtType1Threshold
lastJetCollection = moduleJetsNotOverlappingWithLeptonsPtGtType1ThresholdName
collectionsToKeep.append(lastJetCollection)
#--------------------------------------------------------------------------------------------
# produce collection of electrons/photons, muons, tau-jet candidates and jets
# shifted up/down in energy by their respective energy uncertainties
#--------------------------------------------------------------------------------------------
shiftedParticleSequence, shiftedParticleCollections, addCollectionsToKeep = \
self._addShiftedParticleCollections(process,
electronCollection,
photonCollection,
muonCollection,
tauCollection,
jetCollection, cleanedJetCollection, lastJetCollection,
None, None,
jetCorrLabelUpToL3, jetCorrLabelUpToL3Res,
jecUncertaintyFile, jecUncertaintyTag,
varyByNsigmas,
postfix)
setattr(process, "shiftedParticlesForType1CaloMEtUncertainties" + postfix, shiftedParticleSequence)
metUncertaintySequence += getattr(process, "shiftedParticlesForType1CaloMEtUncertainties" + postfix)
collectionsToKeep.extend(addCollectionsToKeep)
#--------------------------------------------------------------------------------------------
# propagate shifted particle energies to Type 1 and Type 1 + 2 corrected PFMET
#--------------------------------------------------------------------------------------------
self._addCorrCaloMEt(process, metUncertaintySequence,
shiftedParticleCollections, caloTowerCollection,
collectionsToKeep,
jetCorrLabelUpToL3, jetCorrLabelUpToL3Res,
jecUncertaintyFile, jecUncertaintyTag,
varyByNsigmas,
type1JetPtThreshold,
postfix)
# insert metUncertaintySequence into patDefaultSequence
if addToPatDefaultSequence:
if not hasattr(process, "patDefaultSequence"):
raise ValueError("PAT default sequence is not defined !!")
process.patDefaultSequence += metUncertaintySequence
# add shifted + unshifted collections pf pat::Electrons/Photons,
# Muons, Taus, Jets and MET to PAT-tuple event content
if outputModule is not None and hasattr(process, outputModule):
getattr(process, outputModule).outputCommands = _addEventContent(
getattr(process, outputModule).outputCommands,
[ 'keep *_%s_*_%s' % (collectionToKeep, process.name_()) for collectionToKeep in collectionsToKeep ])
def toolCode(self, process):
electronCollection = self._parameters['electronCollection'].value
photonCollection = self._parameters['photonCollection'].value
muonCollection = self._parameters['muonCollection'].value
tauCollection = self._parameters['tauCollection'].value
jetCollection = self._parameters['jetCollection'].value
jetCorrLabel = self._parameters['jetCorrLabel'].value
dRjetCleaning = self._parameters['dRjetCleaning'].value
doSmearJets = self._parameters['doSmearJets'].value
makeType1corrPFMEt = self._parameters['makeType1corrPFMEt'].value
makeType1p2corrPFMEt = self._parameters['makeType1p2corrPFMEt'].value
doApplyType0corr = self._parameters['doApplyType0corr'].value
sysShiftCorrParameter = self._parameters['sysShiftCorrParameter'].value
doApplySysShiftCorr = self._parameters['doApplySysShiftCorr'].value
jetSmearFileName = self._parameters['jetSmearFileName'].value
jetSmearHistogram = self._parameters['jetSmearHistogram'].value
pfCandCollection = self._parameters['pfCandCollection'].value
doApplyUnclEnergyCalibration = self._parameters['doApplyUnclEnergyCalibration'].value
jetCorrPayloadName = self._parameters['jetCorrPayloadName'].value
jetCorrLabelUpToL3 = self._parameters['jetCorrLabelUpToL3'].value
jetCorrLabelUpToL3Res = self._parameters['jetCorrLabelUpToL3Res'].value
jecUncertaintyFile = self._parameters['jecUncertaintyFile'].value
jecUncertaintyTag = self._parameters['jecUncertaintyTag'].value
varyByNsigmas = self._parameters['varyByNsigmas'].value
addToPatDefaultSequence = self._parameters['addToPatDefaultSequence'].value
outputModule = self._parameters['outputModule'].value
postfix = self._parameters['postfix'].value
if not hasattr(process, "pfType1MEtUncertaintySequence" + postfix):
metUncertaintySequence = cms.Sequence()
setattr(process, "pfType1MEtUncertaintySequence" + postfix, metUncertaintySequence)
metUncertaintySequence = getattr(process, "pfType1MEtUncertaintySequence" + postfix)
collectionsToKeep = []
if isValidInputTag(jetCollection):
# produce collection of jets not overlapping with reconstructed
# electrons/photons, muons and tau-jet candidates
lastJetCollection, cleanedJetCollection = \
self._addCleanedJets(process, jetCollection,
electronCollection, photonCollection, muonCollection, tauCollection,
metUncertaintySequence, postfix)
# smear jet energies to account for difference in jet resolutions between MC and Data
# (cf. JME-10-014 PAS)
if doSmearJets:
lastJetCollection = \
addSmearedJets(process, cleanedJetCollection,
[ "smeared", jetCollection.value() ],
jetSmearFileName, jetSmearHistogram, jetResolutions,
varyByNsigmas, None, metUncertaintySequence, postfix)
collectionsToKeep.append( lastJetCollection )
#for default w/o smearing
collectionsToKeep.append( lastJetCollection )
#--------------------------------------------------------------------------------------------
# produce collection of electrons/photons, muons, tau-jet candidates and jets
# shifted up/down in energy by their respective energy uncertainties
#--------------------------------------------------------------------------------------------
shiftedParticleSequence, shiftedParticleCollections, addCollectionsToKeep = \
self._addShiftedParticleCollections(process,
electronCollection.value() if isValidInputTag(electronCollection) else "",
photonCollection.value() if isValidInputTag(photonCollection) else "",
muonCollection.value() if isValidInputTag(muonCollection) else "",
tauCollection.value() if isValidInputTag(tauCollection) else "",
jetCollection.value() if isValidInputTag(jetCollection) else "",
cleanedJetCollection,
lastJetCollection, doSmearJets,
jetCorrLabelUpToL3, jetCorrLabelUpToL3Res,
jecUncertaintyFile, jecUncertaintyTag,
jetSmearFileName, jetSmearHistogram,
varyByNsigmas, postfix)
setattr(process, "shiftedParticlesForType1PFMEtUncertainties" + postfix, shiftedParticleSequence)
metUncertaintySequence += getattr(process, "shiftedParticlesForType1PFMEtUncertainties" + postfix)
collectionsToKeep.extend(addCollectionsToKeep)
#--------------------------------------------------------------------------------------------
# propagate shifted particle energies to Type 1 and Type 1 + 2 corrected PFMET
#--------------------------------------------------------------------------------------------
self._addCorrPFMEt(process, metUncertaintySequence,
shiftedParticleCollections, pfCandCollection, doApplyUnclEnergyCalibration,
collectionsToKeep,
doSmearJets,
makeType1corrPFMEt,
makeType1p2corrPFMEt,
doApplyType0corr,
sysShiftCorrParameter,
doApplySysShiftCorr,
jetCorrLabel,
varyByNsigmas,
postfix)
# insert metUncertaintySequence into patDefaultSequence
if addToPatDefaultSequence:
if not hasattr(process, "patDefaultSequence"):
raise ValueError("PAT default sequence is not defined !!")
process.patDefaultSequence += metUncertaintySequence
# add shifted + unshifted collections pf pat::Electrons/Photons,
# Muons, Taus, Jets and MET to PAT-tuple event content
if outputModule is not None and hasattr(process, outputModule):
getattr(process, outputModule).outputCommands = _addEventContent(
getattr(process, outputModule).outputCommands,
[ 'keep *_%s_*_%s' % (collectionToKeep, process.name_()) for collectionToKeep in collectionsToKeep ])
def toolCode(self, process):
electronCollection = self._parameters['electronCollection'].value
photonCollection = self._parameters['photonCollection'].value
muonCollection = self._parameters['muonCollection'].value
tauCollection = self._parameters['tauCollection'].value
jetCollection = self._parameters['jetCollection'].value
jetCorrLabel = self._parameters['jetCorrLabel'].value
dRjetCleaning = self._parameters['dRjetCleaning'].value
doSmearJets = self._parameters['doSmearJets'].value
jetSmearFileName = self._parameters['jetSmearFileName'].value
jetSmearHistogram = self._parameters['jetSmearHistogram'].value
pfCandCollection = self._parameters['pfCandCollection'].value
jetCorrPayloadName = self._parameters['jetCorrPayloadName'].value
varyByNsigmas = self._parameters['varyByNsigmas'].value
addToPatDefaultSequence = self._parameters['addToPatDefaultSequence'].value
outputModule = self._parameters['outputModule'].value
process.metUncertaintySequence = cms.Sequence()
collectionsToKeep = []
# produce collection of jets not overlapping with reconstructed
# electrons/photons, muons and tau-jet candidates
jetsNotOverlappingWithLeptonsForMEtUncertainty = cms.EDProducer("PATJetCleaner",
src = jetCollection,
preselection = cms.string(''),
checkOverlaps = cms.PSet(),
finalCut = cms.string('')
)
numOverlapCollections = 0
for collection in [
[ 'electrons', electronCollection ],
[ 'photons', photonCollection ],
[ 'muons', muonCollection ],
[ 'taus', tauCollection ] ]:
if self._isValidInputTag(collection[1]):
setattr(jetsNotOverlappingWithLeptonsForMEtUncertainty.checkOverlaps, collection[0], cms.PSet(
src = collection[1],
algorithm = cms.string("byDeltaR"),
preselection = cms.string(""),
deltaR = cms.double(0.5),
checkRecoComponents = cms.bool(False),
pairCut = cms.string(""),
requireNoOverlaps = cms.bool(True),
))
numOverlapCollections = numOverlapCollections + 1
lastJetCollection = jetCollection.value()
if numOverlapCollections >= 1:
lastJetCollection = \
self._addModuleToSequence(process, jetsNotOverlappingWithLeptonsForMEtUncertainty,
[ jetCollection.value(), "NotOverlappingWithLeptonsForMEtUncertainty" ],
process.metUncertaintySequence)
cleanedJetCollection = lastJetCollection
# smear jet energies to account for difference in jet resolutions between MC and Data
# (cf. JME-10-014 PAS)
jetCollectionResUp = None
jetCollectionResDown = None
if doSmearJets:
lastJetCollection = \
self._addSmearedJets(process, cleanedJetCollection, [ "smeared", jetCollection.value() ],
jetSmearFileName, jetSmearHistogram, varyByNsigmas)
jetCollectionResUp = \
self._addSmearedJets(process, cleanedJetCollection, [ "smeared", jetCollection.value(), "ResUp" ],
jetSmearFileName, jetSmearHistogram, varyByNsigmas,
-1.)
collectionsToKeep.append(jetCollectionResUp)
jetCollectionResDown = \
self._addSmearedJets(process, cleanedJetCollection, [ "smeared", jetCollection.value(), "ResDown" ],
jetSmearFileName, jetSmearHistogram, varyByNsigmas,
+1.)
collectionsToKeep.append(jetCollectionResDown)
collectionsToKeep.append(lastJetCollection)
#--------------------------------------------------------------------------------------------
# produce collection of jets shifted up/down in energy
#--------------------------------------------------------------------------------------------
# in case of "raw" (uncorrected) MET,
# add residual jet energy corrections in quadrature to jet energy uncertainties:
# cf. https://twiki.cern.ch/twiki/bin/view/CMS/MissingETUncertaintyPrescription
jetsEnUpForRawMEt = cms.EDProducer("ShiftedPATJetProducer",
src = cms.InputTag(lastJetCollection),
#jetCorrPayloadName = cms.string(jetCorrPayloadName),
#jetCorrUncertaintyTag = cms.string('Uncertainty'),
jetCorrInputFileName = cms.FileInPath('PhysicsTools/PatUtils/data/JEC11_V12_AK5PF_UncertaintySources.txt'),
jetCorrUncertaintyTag = cms.string("SubTotalDataMC"),
addResidualJES = cms.bool(True),
jetCorrLabelUpToL3 = cms.string("ak5PFL1FastL2L3"),
jetCorrLabelUpToL3Res = cms.string("ak5PFL1FastL2L3Residual"),
shiftBy = cms.double(+1.*varyByNsigmas)
)
jetCollectionEnUpForRawMEt = \
self._addModuleToSequence(process, jetsEnUpForRawMEt,
[ "shifted", jetCollection.value(), "EnUpForRawMEt" ],
process.metUncertaintySequence)
collectionsToKeep.append(jetCollectionEnUpForRawMEt)
jetsEnDownForRawMEt = jetsEnUpForRawMEt.clone(
shiftBy = cms.double(-1.*varyByNsigmas)
)
jetCollectionEnDownForRawMEt = \
self._addModuleToSequence(process, jetsEnDownForRawMEt,
[ "shifted", jetCollection.value(), "EnDownForRawMEt" ],
process.metUncertaintySequence)
collectionsToKeep.append(jetCollectionEnDownForRawMEt)
jetsEnUpForCorrMEt = jetsEnUpForRawMEt.clone(
addResidualJES = cms.bool(False)
)
jetCollectionEnUpForCorrMEt = \
self._addModuleToSequence(process, jetsEnUpForCorrMEt,
[ "shifted", jetCollection.value(), "EnUpForCorrMEt" ],
process.metUncertaintySequence)
collectionsToKeep.append(jetCollectionEnUpForCorrMEt)
jetsEnDownForCorrMEt = jetsEnUpForCorrMEt.clone(
shiftBy = cms.double(-1.*varyByNsigmas)
)
jetCollectionEnDownForCorrMEt = \
self._addModuleToSequence(process, jetsEnDownForCorrMEt,
[ "shifted", jetCollection.value(), "EnDownForCorrMEt" ],
process.metUncertaintySequence)
collectionsToKeep.append(jetCollectionEnDownForCorrMEt)
#--------------------------------------------------------------------------------------------
# produce collection of electrons shifted up/down in energy
#--------------------------------------------------------------------------------------------
electronCollectionEnUp = None
electronCollectionEnDown = None
if self._isValidInputTag(electronCollection):
electronsEnUp = cms.EDProducer("ShiftedPATElectronProducer",
src = electronCollection,
binning = cms.VPSet(
cms.PSet(
binSelection = cms.string('isEB'),
binUncertainty = cms.double(0.006)
),
cms.PSet(
binSelection = cms.string('!isEB'),
binUncertainty = cms.double(0.015)
),
),
shiftBy = cms.double(+1.*varyByNsigmas)
)
electronCollectionEnUp = \
self._addModuleToSequence(process, electronsEnUp,
[ "shifted", electronCollection.value(), "EnUp" ],
process.metUncertaintySequence)
collectionsToKeep.append(electronCollectionEnUp)
electronsEnDown = electronsEnUp.clone(
shiftBy = cms.double(-1.*varyByNsigmas)
)
electronCollectionEnDown = \
self._addModuleToSequence(process, electronsEnDown,
[ "shifted", electronCollection.value(), "EnDown" ],
process.metUncertaintySequence)
collectionsToKeep.append(electronCollectionEnDown)
#--------------------------------------------------------------------------------------------
# produce collection of (high Pt) photon candidates shifted up/down in energy
#--------------------------------------------------------------------------------------------
photonCollectionEnUp = None
photonCollectionEnDown = None
if self._isValidInputTag(photonCollection):
photonsEnUp = cms.EDProducer("ShiftedPATPhotonProducer",
src = photonCollection,
binning = cms.VPSet(
cms.PSet(
binSelection = cms.string('isEB = true'),
binUncertainty = cms.double(0.01)
),
cms.PSet(
binSelection = cms.string('isEB = false'),
binUncertainty = cms.double(0.025)
),
),
shiftBy = cms.double(+1.*varyByNsigmas)
)
photonCollectionEnUp = \
self._addModuleToSequence(process, photonsEnUp,
[ "shifted", photonCollection.value(), "EnUp" ],
process.metUncertaintySequence)
collectionsToKeep.append(photonCollectionEnUp)
photonsEnDown = photonsEnUp.clone(
shiftBy = cms.double(-1.*varyByNsigmas)
)
photonCollectionEnDown = \
self._addModuleToSequence(process, photonsEnDown,
[ "shifted", photonCollection.value(), "EnDown" ],
process.metUncertaintySequence)
collectionsToKeep.append(photonCollectionEnDown)
#--------------------------------------------------------------------------------------------
# produce collection of muons shifted up/down in energy/momentum
#--------------------------------------------------------------------------------------------
muonCollectionEnUp = None
muonCollectionEnDown = None
if self._isValidInputTag(muonCollection):
muonsEnUp = cms.EDProducer("ShiftedPATMuonProducer",
src = muonCollection,
uncertainty = cms.double(0.01),
shiftBy = cms.double(+1.*varyByNsigmas)
)
muonCollectionEnUp = \
self._addModuleToSequence(process, muonsEnUp,
[ "shifted", muonCollection.value(), "EnUp" ],
process.metUncertaintySequence)
collectionsToKeep.append(muonCollectionEnUp)
muonsEnDown = muonsEnUp.clone(
shiftBy = cms.double(-1.*varyByNsigmas)
)
muonCollectionEnDown = \
self._addModuleToSequence(process, muonsEnDown,
[ "shifted", muonCollection.value(), "EnDown" ],
process.metUncertaintySequence)
collectionsToKeep.append(muonCollectionEnDown)
#--------------------------------------------------------------------------------------------
# produce collection of tau-jets shifted up/down in energy
#--------------------------------------------------------------------------------------------
tauCollectionEnUp = None
tauCollectionEnDown = None
if self._isValidInputTag(tauCollection):
tausEnUp = cms.EDProducer("ShiftedPATTauProducer",
src = tauCollection,
uncertainty = cms.double(0.03),
shiftBy = cms.double(+1.*varyByNsigmas)
)
tauCollectionEnUp = \
self._addModuleToSequence(process, tausEnUp,
[ "shifted", tauCollection.value(), "EnUp" ],
process.metUncertaintySequence)
collectionsToKeep.append(tauCollectionEnUp)
tausEnDown = tausEnUp.clone(
shiftBy = cms.double(-1.*varyByNsigmas)
)
tauCollectionEnDown = \
self._addModuleToSequence(process, tausEnDown,
[ "shifted", tauCollection.value(), "EnDown" ],
process.metUncertaintySequence)
collectionsToKeep.append(tauCollectionEnDown)
#--------------------------------------------------------------------------------------------
# propagate shifted jet energies to MET
#--------------------------------------------------------------------------------------------
# add "nominal" (unshifted) pat::MET collections
if not hasattr(process, 'producePatPFMETCorrections'):
process.load("PhysicsTools.PatUtils.patPFMETCorrections_cff")
process.pfCandsNotInJet.bottomCollection = pfCandCollection
process.selectedPatJetsForMETtype1p2Corr.src = lastJetCollection
process.selectedPatJetsForMETtype2Corr.src = lastJetCollection
process.metUncertaintySequence += process.producePatPFMETCorrections
collectionsToKeep.extend([
'patPFMet',
'patType1CorrectedPFMet',
'patType1p2CorrectedPFMet'])
# split jet collections into |jetEta| < 4.7 and |jetEta| > 4.7 parts
#
# NOTE: splitting of pat::Jets collections needs to be done
# in order to work around problem with CMSSW_4_2_x JEC factors at high eta,
# reported in
# https://hypernews.cern.ch/HyperNews/CMS/get/jes/270.html
# https://hypernews.cern.ch/HyperNews/CMS/get/JetMET/1259/1.html )
#
process.selectedPatJetsForMETtype1p2CorrEnUp = getattr(process, jetCollectionEnUpForCorrMEt).clone(
src = cms.InputTag('selectedPatJetsForMETtype1p2Corr')
)
process.metUncertaintySequence += process.selectedPatJetsForMETtype1p2CorrEnUp
process.selectedPatJetsForMETtype2CorrEnUp = getattr(process, jetCollectionEnUpForCorrMEt).clone(
src = cms.InputTag('selectedPatJetsForMETtype2Corr')
)
process.metUncertaintySequence += process.selectedPatJetsForMETtype2CorrEnUp
process.selectedPatJetsForMETtype1p2CorrEnDown = getattr(process, jetCollectionEnDownForCorrMEt).clone(
src = cms.InputTag('selectedPatJetsForMETtype1p2Corr')
)
process.metUncertaintySequence += process.selectedPatJetsForMETtype1p2CorrEnDown
process.selectedPatJetsForMETtype2CorrEnDown = getattr(process, jetCollectionEnDownForCorrMEt).clone(
src = cms.InputTag('selectedPatJetsForMETtype2Corr')
)
process.metUncertaintySequence += process.selectedPatJetsForMETtype2CorrEnDown
if doSmearJets:
process.selectedPatJetsForMETtype1p2CorrResUp = getattr(process, jetCollectionResUp).clone(
src = cms.InputTag('selectedPatJetsForMETtype1p2Corr')
)
process.metUncertaintySequence += process.selectedPatJetsForMETtype1p2CorrResUp
process.selectedPatJetsForMETtype2CorrResUp = getattr(process, jetCollectionResUp).clone(
src = cms.InputTag('selectedPatJetsForMETtype2Corr')
)
process.metUncertaintySequence += process.selectedPatJetsForMETtype2CorrResUp
process.selectedPatJetsForMETtype1p2CorrResDown = getattr(process, jetCollectionResDown).clone(
src = cms.InputTag('selectedPatJetsForMETtype1p2Corr')
)
process.metUncertaintySequence += process.selectedPatJetsForMETtype1p2CorrResDown
process.selectedPatJetsForMETtype2CorrResDown = getattr(process, jetCollectionResDown).clone(
src = cms.InputTag('selectedPatJetsForMETtype2Corr')
)
process.metUncertaintySequence += process.selectedPatJetsForMETtype2CorrResDown
if doSmearJets:
# apply MET smearing to "raw" (uncorrected) MET
process.smearedPatPFMetSequence = cms.Sequence()
process.patPFMetForMEtUncertainty = process.patPFMet.clone()
process.smearedPatPFMetSequence += process.patPFMetForMEtUncertainty
process.patPFMETcorrJetSmearing = cms.EDProducer("ShiftedParticleMETcorrInputProducer",
srcOriginal = cms.InputTag(cleanedJetCollection),
srcShifted = cms.InputTag(lastJetCollection)
)
process.smearedPatPFMetSequence += process.patPFMETcorrJetSmearing
process.producePatPFMETCorrections.replace(process.patPFMet, process.smearedPatPFMetSequence)
process.patPFMet = process.patType1CorrectedPFMet.clone(
src = cms.InputTag('patPFMetForMEtUncertainty'),
srcType1Corrections = cms.VInputTag(
cms.InputTag('patPFMETcorrJetSmearing')
)
)
process.smearedPatPFMetSequence += process.patPFMet
process.metUncertaintySequence += process.smearedPatPFMetSequence
# propagate shifts in jet energy to "raw" (uncorrected) and Type 1 corrected MET
metCollectionsUp_DownForRawMEt = \
self._propagateMEtUncertainties(
process, lastJetCollection, "Jet", "En", jetCollectionEnUpForRawMEt, jetCollectionEnDownForRawMEt,
process.patPFMet, process.metUncertaintySequence)
collectionsToKeep.extend(metCollectionsUp_DownForRawMEt)
metCollectionsUp_DownForCorrMEt = \
self._propagateMEtUncertainties(
process, lastJetCollection, "Jet", "En", jetCollectionEnUpForCorrMEt, jetCollectionEnDownForCorrMEt,
process.patType1CorrectedPFMet, process.metUncertaintySequence)
collectionsToKeep.extend(metCollectionsUp_DownForCorrMEt)
# propagate shifts in jet energy to Type 1 + 2 corrected MET
process.patPFJetMETtype1p2CorrEnUp = process.patPFJetMETtype1p2Corr.clone(
src = cms.InputTag(process.selectedPatJetsForMETtype1p2CorrEnUp.label()),
jetCorrLabel = cms.string(jetCorrLabel)
)
process.metUncertaintySequence += process.patPFJetMETtype1p2CorrEnUp
process.patPFJetMETtype2CorrEnUp = process.patPFJetMETtype2Corr.clone(
src = cms.InputTag('selectedPatJetsForMETtype2CorrEnUp')
)
process.metUncertaintySequence += process.patPFJetMETtype2CorrEnUp
process.patPFJetMETtype1p2CorrEnDown = process.patPFJetMETtype1p2CorrEnUp.clone(
src = cms.InputTag(process.selectedPatJetsForMETtype1p2CorrEnDown.label())
)
process.metUncertaintySequence += process.patPFJetMETtype1p2CorrEnDown
process.patPFJetMETtype2CorrEnDown = process.patPFJetMETtype2Corr.clone(
src = cms.InputTag('selectedPatJetsForMETtype2CorrEnDown')
)
process.metUncertaintySequence += process.patPFJetMETtype2CorrEnDown
process.patType1p2CorrectedPFMetJetEnUp = process.patType1p2CorrectedPFMet.clone(
srcType1Corrections = cms.VInputTag(
cms.InputTag('patPFJetMETtype1p2CorrEnUp', 'type1')
),
srcUnclEnergySums = cms.VInputTag(
cms.InputTag('patPFJetMETtype1p2CorrEnUp', 'type2' ),
cms.InputTag('patPFJetMETtype2CorrEnUp', 'type2' ),
cms.InputTag('patPFJetMETtype1p2CorrEnUp', 'offset'),
cms.InputTag('pfCandMETcorr')
)
)
process.metUncertaintySequence += process.patType1p2CorrectedPFMetJetEnUp
collectionsToKeep.append('patType1p2CorrectedPFMetJetEnUp')
process.patType1p2CorrectedPFMetJetEnDown = process.patType1p2CorrectedPFMetJetEnUp.clone(
srcType1Corrections = cms.VInputTag(
cms.InputTag('patPFJetMETtype1p2CorrEnDown', 'type1')
),
srcUnclEnergySums = cms.VInputTag(
cms.InputTag('patPFJetMETtype1p2CorrEnDown', 'type2' ),
cms.InputTag('patPFJetMETtype2CorrEnDown', 'type2' ),
cms.InputTag('patPFJetMETtype1p2CorrEnDown', 'offset'),
cms.InputTag('pfCandMETcorr')
)
)
process.metUncertaintySequence += process.patType1p2CorrectedPFMetJetEnDown
collectionsToKeep.append('patType1p2CorrectedPFMetJetEnDown')
if doSmearJets:
# propagate shifts in jet resolution to "raw" (uncorrected) MET and Type 1 corrected MET
for metProducer in [ process.patPFMet,
process.patType1CorrectedPFMet ]:
metCollectionsUp_Down = \
self._propagateMEtUncertainties(
process, lastJetCollection, "Jet", "Res", jetCollectionResUp, jetCollectionResDown,
metProducer, process.metUncertaintySequence)
collectionsToKeep.extend(metCollectionsUp_Down)
# propagate shifts in jet resolution to Type 1 + 2 corrected MET
process.patPFJetMETtype1p2CorrResUp = process.patPFJetMETtype1p2Corr.clone(
src = cms.InputTag(process.selectedPatJetsForMETtype1p2CorrResUp.label()),
jetCorrLabel = cms.string(jetCorrLabel)
)
process.metUncertaintySequence += process.patPFJetMETtype1p2CorrResUp
process.patPFJetMETtype2CorrResUp = process.patPFJetMETtype2Corr.clone(
src = cms.InputTag('selectedPatJetsForMETtype2CorrResUp')
)
process.metUncertaintySequence += process.patPFJetMETtype2CorrResUp
process.patPFJetMETtype1p2CorrResDown = process.patPFJetMETtype1p2CorrResUp.clone(
src = cms.InputTag(process.selectedPatJetsForMETtype1p2CorrResDown.label())
)
process.metUncertaintySequence += process.patPFJetMETtype1p2CorrResDown
process.patPFJetMETtype2CorrResDown = process.patPFJetMETtype2Corr.clone(
src = cms.InputTag('selectedPatJetsForMETtype2CorrResDown')
)
process.metUncertaintySequence += process.patPFJetMETtype2CorrResDown
process.patType1p2CorrectedPFMetJetResUp = process.patType1p2CorrectedPFMet.clone(
srcType1Corrections = cms.VInputTag(
cms.InputTag('patPFJetMETtype1p2CorrResUp', 'type1')
),
srcUnclEnergySums = cms.VInputTag(
cms.InputTag('patPFJetMETtype1p2CorrResUp', 'type2' ),
cms.InputTag('patPFJetMETtype2CorrResUp', 'type2' ),
cms.InputTag('patPFJetMETtype1p2CorrResUp', 'offset'),
cms.InputTag('pfCandMETcorr')
)
)
process.metUncertaintySequence += process.patType1p2CorrectedPFMetJetResUp
collectionsToKeep.append('patType1p2CorrectedPFMetJetResUp')
process.patType1p2CorrectedPFMetJetResDown = process.patType1p2CorrectedPFMetJetResUp.clone(
srcType1Corrections = cms.VInputTag(
cms.InputTag('patPFJetMETtype1p2CorrResDown', 'type1')
),
srcUnclEnergySums = cms.VInputTag(
cms.InputTag('patPFJetMETtype1p2CorrResDown', 'type2' ),
cms.InputTag('patPFJetMETtype2CorrResDown', 'type2' ),
cms.InputTag('patPFJetMETtype1p2CorrResDown', 'offset'),
cms.InputTag('pfCandMETcorr')
)
)
process.metUncertaintySequence += process.patType1p2CorrectedPFMetJetResDown
collectionsToKeep.append('patType1p2CorrectedPFMetJetResDown')
#--------------------------------------------------------------------------------------------
# shift "unclustered energy" (PFJets of Pt < 10 GeV plus PFCandidates not within jets)
# and propagate effect of shift to (Type 1 as well as Type 1 + 2 corrected) MET
#--------------------------------------------------------------------------------------------
unclEnMETcorrections = [
[ 'pfCandMETcorr', [ '' ] ],
[ 'patPFJetMETtype1p2Corr', [ 'type2', 'offset' ] ],
[ 'patPFJetMETtype2Corr', [ 'type2' ] ],
]
unclEnMETcorrectionsUp = []
unclEnMETcorrectionsDown = []
for srcUnclEnMETcorr in unclEnMETcorrections:
moduleUnclEnMETcorrUp = cms.EDProducer("ShiftedMETcorrInputProducer",
src = cms.VInputTag(
[ cms.InputTag(srcUnclEnMETcorr[0], instanceLabel) for instanceLabel in srcUnclEnMETcorr[1] ]
),
uncertainty = cms.double(0.10),
shiftBy = cms.double(+1.*varyByNsigmas)
)
moduleUnclEnMETcorrUpName = "%sUnclusteredEnUp" % srcUnclEnMETcorr[0]
setattr(process, moduleUnclEnMETcorrUpName, moduleUnclEnMETcorrUp)
process.metUncertaintySequence += moduleUnclEnMETcorrUp
unclEnMETcorrectionsUp.extend([ cms.InputTag(moduleUnclEnMETcorrUpName, instanceLabel)
for instanceLabel in srcUnclEnMETcorr[1] ] )
moduleUnclEnMETcorrDown = moduleUnclEnMETcorrUp.clone(
shiftBy = cms.double(-1.*varyByNsigmas)
)
moduleUnclEnMETcorrDownName = "%sUnclusteredEnDown" % srcUnclEnMETcorr[0]
setattr(process, moduleUnclEnMETcorrDownName, moduleUnclEnMETcorrDown)
process.metUncertaintySequence += moduleUnclEnMETcorrDown
unclEnMETcorrectionsDown.extend([ cms.InputTag(moduleUnclEnMETcorrDownName, instanceLabel)
for instanceLabel in srcUnclEnMETcorr[1] ] )
# propagate shifts in jet energy/resolution to "raw" (uncorrected) MET
process.patPFMetUnclusteredEnUp = process.patType1CorrectedPFMet.clone(
src = cms.InputTag('patPFMet'),
srcType1Corrections = cms.VInputTag(unclEnMETcorrectionsUp)
)
process.metUncertaintySequence += process.patPFMetUnclusteredEnUp
collectionsToKeep.append('patPFMetUnclusteredEnUp')
process.patPFMetUnclusteredEnDown = process.patPFMetUnclusteredEnUp.clone(
srcType1Corrections = cms.VInputTag(unclEnMETcorrectionsDown)
)
process.metUncertaintySequence += process.patPFMetUnclusteredEnDown
collectionsToKeep.append('patPFMetUnclusteredEnDown')
# propagate shifts in jet energy/resolution to Type 1 corrected MET
process.patType1CorrectedPFMetUnclusteredEnUp = process.patType1CorrectedPFMet.clone(
src = cms.InputTag('patType1CorrectedPFMet'),
srcType1Corrections = cms.VInputTag(unclEnMETcorrectionsUp)
)
process.metUncertaintySequence += process.patType1CorrectedPFMetUnclusteredEnUp
collectionsToKeep.append('patType1CorrectedPFMetUnclusteredEnUp')
process.patType1CorrectedPFMetUnclusteredEnDown = process.patType1CorrectedPFMetUnclusteredEnUp.clone(
srcType1Corrections = cms.VInputTag(unclEnMETcorrectionsDown)
)
process.metUncertaintySequence += process.patType1CorrectedPFMetUnclusteredEnDown
collectionsToKeep.append('patType1CorrectedPFMetUnclusteredEnDown')
# propagate shifts in jet energy/resolution to Type 1 + 2 corrected MET
process.patType1p2CorrectedPFMetUnclusteredEnUp = process.patType1p2CorrectedPFMet.clone(
srcUnclEnergySums = cms.VInputTag(
cms.InputTag('patPFJetMETtype1p2Corr', 'type2' ),
cms.InputTag('patPFJetMETtype1p2CorrUnclusteredEnUp', 'type2' ),
cms.InputTag('patPFJetMETtype2Corr', 'type2' ),
cms.InputTag('patPFJetMETtype2CorrUnclusteredEnUp', 'type2' ),
cms.InputTag('patPFJetMETtype1p2Corr', 'offset'),
cms.InputTag('patPFJetMETtype1p2CorrUnclusteredEnUp', 'offset'),
cms.InputTag('pfCandMETcorr'),
cms.InputTag('pfCandMETcorrUnclusteredEnUp')
)
)
process.metUncertaintySequence += process.patType1p2CorrectedPFMetUnclusteredEnUp
collectionsToKeep.append('patType1p2CorrectedPFMetUnclusteredEnUp')
process.patType1p2CorrectedPFMetUnclusteredEnDown = process.patType1p2CorrectedPFMetUnclusteredEnUp.clone(
srcUnclEnergySums = cms.VInputTag(
cms.InputTag('patPFJetMETtype1p2Corr', 'type2' ),
cms.InputTag('patPFJetMETtype1p2CorrUnclusteredEnDown', 'type2' ),
cms.InputTag('patPFJetMETtype2Corr', 'type2' ),
cms.InputTag('patPFJetMETtype2CorrUnclusteredEnDown', 'type2' ),
cms.InputTag('patPFJetMETtype1p2Corr', 'offset'),
cms.InputTag('patPFJetMETtype1p2CorrUnclusteredEnDown', 'offset'),
cms.InputTag('pfCandMETcorr'),
cms.InputTag('pfCandMETcorrUnclusteredEnDown')
)
)
process.metUncertaintySequence += process.patType1p2CorrectedPFMetUnclusteredEnDown
collectionsToKeep.append('patType1p2CorrectedPFMetUnclusteredEnDown')
#--------------------------------------------------------------------------------------------
# propagate shifted electron/photon, muon and tau-jet energies to MET
#--------------------------------------------------------------------------------------------
for metProducer in [ process.patPFMet,
process.patType1CorrectedPFMet,
process.patType1p2CorrectedPFMet ]:
if self._isValidInputTag(electronCollection):
metCollectionsUp_Down = \
self._propagateMEtUncertainties(
process, electronCollection.value(), "Electron", "En", electronCollectionEnUp, electronCollectionEnDown,
metProducer, process.metUncertaintySequence)
collectionsToKeep.extend(metCollectionsUp_Down)
if self._isValidInputTag(photonCollection):
metCollectionsUp_Down = \
self._propagateMEtUncertainties(
process, photonCollection.value(), "Photon", "En", photonCollectionEnUp, photonCollectionEnDown,
metProducer, process.metUncertaintySequence)
collectionsToKeep.extend(metCollectionsUp_Down)
if self._isValidInputTag(muonCollection):
metCollectionsUp_Down = \
self._propagateMEtUncertainties(
process, muonCollection.value(), "Muon", "En", muonCollectionEnUp, muonCollectionEnDown,
metProducer, process.metUncertaintySequence)
collectionsToKeep.extend(metCollectionsUp_Down)
if self._isValidInputTag(tauCollection):
metCollectionsUp_Down = \
self._propagateMEtUncertainties(
process, tauCollection.value(), "Tau", "En", tauCollectionEnUp, tauCollectionEnDown,
metProducer, process.metUncertaintySequence)
collectionsToKeep.extend(metCollectionsUp_Down)
# insert metUncertaintySequence into patDefaultSequence
if addToPatDefaultSequence:
if not hasattr(process, "patDefaultSequence"):
raise ValueError("PAT default sequence is not defined !!")
process.patDefaultSequence += process.metUncertaintySequence
# add shifted + unshifted collections pf pat::Electrons/Photons,
# Muons, Taus, Jets and MET to PAT-tuple event content
if outputModule is not None and hasattr(process, outputModule):
getattr(process, outputModule).outputCommands = _addEventContent(
getattr(process, outputModule).outputCommands,
[ 'keep *_%s_*_%s' % (collectionToKeep, process.name_()) for collectionToKeep in collectionsToKeep ])
def toolCode(self, process):
electronCollection = self._parameters['electronCollection'].value
photonCollection = self._parameters['photonCollection'].value
muonCollection = self._parameters['muonCollection'].value
tauCollection = self._parameters['tauCollection'].value
jetCollection = self._parameters['jetCollection'].value
jetCorrLabel = self._parameters['jetCorrLabel'].value
doApplyChargedHadronSubtraction = self._parameters[
'doApplyChargedHadronSubtraction'].value
chsLabel = None
if doApplyChargedHadronSubtraction:
chsLabel = "chs"
else:
chsLabel = ""
doSmearJets = self._parameters['doSmearJets'].value
jetSmearFileName = self._parameters['jetSmearFileName'].value
jetSmearHistogram = self._parameters['jetSmearHistogram'].value
pfCandCollection = self._parameters['pfCandCollection'].value
doApplyUnclEnergyCalibration = self._parameters[
'doApplyUnclEnergyCalibration'].value
sfNoPUjetOffsetEnCorr = self._parameters['sfNoPUjetOffsetEnCorr'].value
jetCorrPayloadName = self._parameters['jetCorrPayloadName'].value
jetCorrLabelUpToL3 = self._parameters['jetCorrLabelUpToL3'].value
jetCorrLabelUpToL3Res = self._parameters['jetCorrLabelUpToL3Res'].value
jecUncertaintyFile = self._parameters['jecUncertaintyFile'].value
jecUncertaintyTag = self._parameters['jecUncertaintyTag'].value
varyByNsigmas = self._parameters['varyByNsigmas'].value
addToPatDefaultSequence = self._parameters[
'addToPatDefaultSequence'].value
outputModule = self._parameters['outputModule'].value
postfix = self._parameters['postfix'].value
if not hasattr(
process, "pf%sNoPUMEtUncertaintySequence%s" %
(chsLabel, postfix)):
metUncertaintySequence = cms.Sequence()
setattr(process,
"pf%sNoPUMEtUncertaintySequence%s" % (chsLabel, postfix),
metUncertaintySequence)
metUncertaintySequence = getattr(
process, "pf%sNoPUMEtUncertaintySequence%s" % (chsLabel, postfix))
collectionsToKeep = []
lastJetCollection = jetCollection.value()
# smear jet energies to account for difference in jet resolutions between MC and Data
# (cf. JME-10-014 PAS)
if isValidInputTag(jetCollection):
if doSmearJets:
lastJetCollection = \
addSmearedJets(process, lastJetCollection, [ "smeared", jetCollection.value(), "ForPFNoPU%sMEt" % chsLabel ],
jetSmearFileName, jetSmearHistogram, jetResolutions, varyByNsigmas, None,
sequence = metUncertaintySequence, postfix = postfix)
collectionsToKeep.append(lastJetCollection)
#--------------------------------------------------------------------------------------------
# produce collection of electrons/photons, muons, tau-jet candidates and jets
# shifted up/down in energy by their respective energy uncertainties
#--------------------------------------------------------------------------------------------
shiftedParticleSequence, shiftedParticleCollections, addCollectionsToKeep = \
self._addShiftedParticleCollections(process,
electronCollection.value(),
photonCollection.value(),
muonCollection.value(),
tauCollection.value(),
jetCollection.value(), lastJetCollection, lastJetCollection,
doSmearJets,
jetCorrLabelUpToL3, jetCorrLabelUpToL3Res,
jecUncertaintyFile, jecUncertaintyTag,
jetSmearFileName, jetSmearHistogram,
varyByNsigmas,
"ForPFNoPU%sMEt%s" % (chsLabel, postfix))
setattr(
process, "shiftedParticlesForPFNoPU%sMEtUncertainties%s" %
(chsLabel, postfix), shiftedParticleSequence)
metUncertaintySequence += getattr(
process, "shiftedParticlesForPFNoPU%sMEtUncertainties%s" %
(chsLabel, postfix))
collectionsToKeep.extend(addCollectionsToKeep)
#--------------------------------------------------------------------------------------------
# propagate shifted particle energies to No-PU MET
#--------------------------------------------------------------------------------------------
self._addPFNoPUMEt(process, metUncertaintySequence,
shiftedParticleCollections, pfCandCollection,
doApplyUnclEnergyCalibration, sfNoPUjetOffsetEnCorr,
collectionsToKeep, doApplyChargedHadronSubtraction,
doSmearJets, jecUncertaintyFile, jecUncertaintyTag,
varyByNsigmas, postfix)
# insert metUncertaintySequence into patDefaultSequence
if addToPatDefaultSequence:
if not hasattr(process, "patDefaultSequence"):
raise ValueError("PAT default sequence is not defined !!")
process.patDefaultSequence += metUncertaintySequence
# add shifted + unshifted collections pf pat::Electrons/Photons,
# Muons, Taus, Jets and MET to PAT-tuple event content
if outputModule is not None and hasattr(process, outputModule):
getattr(process, outputModule).outputCommands = _addEventContent(
getattr(process, outputModule).outputCommands, [
'keep *_%s_*_%s' % (collectionToKeep, process.name_())
for collectionToKeep in collectionsToKeep
])
def toolCode(self, process):
electronCollection = self._parameters['electronCollection'].value
photonCollection = self._parameters['photonCollection'].value
muonCollection = self._parameters['muonCollection'].value
tauCollection = self._parameters['tauCollection'].value
jetCollection = self._parameters['jetCollection'].value
jetCorrLabel = self._parameters['jetCorrLabel'].value
doApplyChargedHadronSubtraction = self._parameters['doApplyChargedHadronSubtraction'].value
chsLabel = None
if doApplyChargedHadronSubtraction:
chsLabel = "chs"
else:
chsLabel = ""
doSmearJets = self._parameters['doSmearJets'].value
jetSmearFileName = self._parameters['jetSmearFileName'].value
jetSmearHistogram = self._parameters['jetSmearHistogram'].value
pfCandCollection = self._parameters['pfCandCollection'].value
jetCorrPayloadName = self._parameters['jetCorrPayloadName'].value
jetCorrLabelUpToL3 = self._parameters['jetCorrLabelUpToL3'].value
jetCorrLabelUpToL3Res = self._parameters['jetCorrLabelUpToL3Res'].value
jecUncertaintyFile = self._parameters['jecUncertaintyFile'].value
jecUncertaintyTag = self._parameters['jecUncertaintyTag'].value
varyByNsigmas = self._parameters['varyByNsigmas'].value
addToPatDefaultSequence = self._parameters['addToPatDefaultSequence'].value
outputModule = self._parameters['outputModule'].value
postfix = self._parameters['postfix'].value
if not hasattr(process, "pf%sNoPileUpMEtUncertaintySequence%s" % (chsLabel, postfix)):
metUncertaintySequence = cms.Sequence()
setattr(process, "pf%sNoPileUpMEtUncertaintySequence%s" % (chsLabel, postfix), metUncertaintySequence)
metUncertaintySequence = getattr(process, "pf%sNoPileUpMEtUncertaintySequence%s" % (chsLabel, postfix))
collectionsToKeep = []
lastJetCollection = jetCollection.value()
# smear jet energies to account for difference in jet resolutions between MC and Data
# (cf. JME-10-014 PAS)
jetCollectionResUp = None
jetCollectionResDown = None
if doSmearJets:
lastJetCollection = \
self._addSmearedJets(process, lastJetCollection, [ "smeared", jetCollection.value(), "ForNoPileUpPF%sMEt" % chsLabel ],
jetSmearFileName, jetSmearHistogram, varyByNsigmas,
uncertaintySequence = metUncertaintySequence, postfix = postfix)
jetCollectionResUp = \
self._addSmearedJets(process, lastJetCollection, [ "smeared", jetCollection.value(), "ForNoPileUpPF%sMEtResUp" % chsLabel ],
jetSmearFileName, jetSmearHistogram, varyByNsigmas, -1.,
uncertaintySequence = metUncertaintySequence, postfix = postfix)
collectionsToKeep.append(jetCollectionResUp)
jetCollectionResDown = \
self._addSmearedJets(process, lastJetCollection, [ "smeared", jetCollection.value(), "ForNoPileUpPF%sMEtResDown" % chsLabel ],
jetSmearFileName, jetSmearHistogram, varyByNsigmas, +1.,
uncertaintySequence = metUncertaintySequence, postfix = postfix)
collectionsToKeep.append(jetCollectionResDown)
collectionsToKeep.append(lastJetCollection)
#--------------------------------------------------------------------------------------------
# produce collection of electrons/photons, muons, tau-jet candidates and jets
# shifted up/down in energy by their respective energy uncertainties
#--------------------------------------------------------------------------------------------
shiftedParticleSequence, shiftedParticleCollections, addCollectionsToKeep = \
self._addShiftedParticleCollections(process,
electronCollection,
photonCollection,
muonCollection,
tauCollection,
jetCollection, None, lastJetCollection,
jetCollectionResUp, jetCollectionResDown,
jetCorrLabelUpToL3, jetCorrLabelUpToL3Res,
jecUncertaintyFile, jecUncertaintyTag,
varyByNsigmas,
"ForNoPileUpPF%sMEt%s" % (chsLabel, postfix))
setattr(process, "shiftedParticlesForNoPileUpPF%sMEtUncertainties%s" % (chsLabel, postfix), shiftedParticleSequence)
metUncertaintySequence += getattr(process, "shiftedParticlesForNoPileUpPF%sMEtUncertainties%s" % (chsLabel, postfix))
collectionsToKeep.extend(addCollectionsToKeep)
#--------------------------------------------------------------------------------------------
# propagate shifted particle energies to No-PU MET
#--------------------------------------------------------------------------------------------
self._addNoPileUpPFMEt(process, metUncertaintySequence,
shiftedParticleCollections, pfCandCollection,
collectionsToKeep,
doApplyChargedHadronSubtraction,
doSmearJets,
jecUncertaintyFile, jecUncertaintyTag,
varyByNsigmas,
postfix)
# insert metUncertaintySequence into patDefaultSequence
if addToPatDefaultSequence:
if not hasattr(process, "patDefaultSequence"):
raise ValueError("PAT default sequence is not defined !!")
process.patDefaultSequence += metUncertaintySequence
# add shifted + unshifted collections pf pat::Electrons/Photons,
# Muons, Taus, Jets and MET to PAT-tuple event content
if outputModule is not None and hasattr(process, outputModule):
getattr(process, outputModule).outputCommands = _addEventContent(
getattr(process, outputModule).outputCommands,
[ 'keep *_%s_*_%s' % (collectionToKeep, process.name_()) for collectionToKeep in collectionsToKeep ])
def toolCode(self, process):
electronCollection = self._parameters['electronCollection'].value
photonCollection = self._parameters['photonCollection'].value
muonCollection = self._parameters['muonCollection'].value
tauCollection = self._parameters['tauCollection'].value
jetCollection = self._parameters['jetCollection'].value
jetCorrLabel = self._parameters['jetCorrLabel'].value
dRjetCleaning = self._parameters['dRjetCleaning'].value
caloTowerCollection = self._parameters['caloTowerCollection'].value
jetCorrPayloadName = self._parameters['jetCorrPayloadName'].value
jetCorrLabelUpToL3 = self._parameters['jetCorrLabelUpToL3'].value
jetCorrLabelUpToL3Res = self._parameters['jetCorrLabelUpToL3Res'].value
jecUncertaintyFile = self._parameters['jecUncertaintyFile'].value
jecUncertaintyTag = self._parameters['jecUncertaintyTag'].value
varyByNsigmas = self._parameters['varyByNsigmas'].value
type1JetPtThreshold = self._parameters['type1JetPtThreshold'].value
addToPatDefaultSequence = self._parameters[
'addToPatDefaultSequence'].value
outputModule = self._parameters['outputModule'].value
postfix = self._parameters['postfix'].value
if not hasattr(process, "caloType1MEtUncertaintySequence" + postfix):
metUncertaintySequence = cms.Sequence()
setattr(process, "caloType1MEtUncertaintySequence" + postfix,
metUncertaintySequence)
metUncertaintySequence = getattr(
process, "caloType1MEtUncertaintySequence" + postfix)
collectionsToKeep = []
# produce collection of jets not overlapping with reconstructed
# electrons/photons, muons and tau-jet candidates
lastJetCollection, cleanedJetCollection = \
self._addCleanedJets(process, jetCollection,
electronCollection, photonCollection, muonCollection, tauCollection,
metUncertaintySequence, postfix)
moduleJetsNotOverlappingWithLeptonsPtGtType1Threshold = cms.EDFilter(
"PATJetSelector",
src=cms.InputTag(lastJetCollection),
cut=cms.string('pt > %f' % type1JetPtThreshold))
moduleJetsNotOverlappingWithLeptonsPtGtType1ThresholdName = "%sNotOverlappingWithLeptonsPtGtType1ThresholdForJetMEtUncertainty" % jetCollection.value(
)
setattr(process,
moduleJetsNotOverlappingWithLeptonsPtGtType1ThresholdName,
moduleJetsNotOverlappingWithLeptonsPtGtType1Threshold)
metUncertaintySequence += moduleJetsNotOverlappingWithLeptonsPtGtType1Threshold
lastJetCollection = moduleJetsNotOverlappingWithLeptonsPtGtType1ThresholdName
collectionsToKeep.append(lastJetCollection)
#--------------------------------------------------------------------------------------------
# produce collection of electrons/photons, muons, tau-jet candidates and jets
# shifted up/down in energy by their respective energy uncertainties
#--------------------------------------------------------------------------------------------
shiftedParticleSequence, shiftedParticleCollections, addCollectionsToKeep = \
self._addShiftedParticleCollections(process,
electronCollection,
photonCollection,
muonCollection,
tauCollection,
jetCollection, cleanedJetCollection, lastJetCollection,
None, None,
jetCorrLabelUpToL3, jetCorrLabelUpToL3Res,
jecUncertaintyFile, jecUncertaintyTag,
varyByNsigmas,
postfix)
setattr(process,
"shiftedParticlesForType1CaloMEtUncertainties" + postfix,
shiftedParticleSequence)
metUncertaintySequence += getattr(
process, "shiftedParticlesForType1CaloMEtUncertainties" + postfix)
collectionsToKeep.extend(addCollectionsToKeep)
#--------------------------------------------------------------------------------------------
# propagate shifted particle energies to Type 1 and Type 1 + 2 corrected PFMET
#--------------------------------------------------------------------------------------------
self._addCorrCaloMEt(process, metUncertaintySequence,
shiftedParticleCollections, caloTowerCollection,
collectionsToKeep, jetCorrLabelUpToL3,
jetCorrLabelUpToL3Res, jecUncertaintyFile,
jecUncertaintyTag, varyByNsigmas,
type1JetPtThreshold, postfix)
# insert metUncertaintySequence into patDefaultSequence
if addToPatDefaultSequence:
if not hasattr(process, "patDefaultSequence"):
raise ValueError("PAT default sequence is not defined !!")
process.patDefaultSequence += metUncertaintySequence
# add shifted + unshifted collections pf pat::Electrons/Photons,
# Muons, Taus, Jets and MET to PAT-tuple event content
if outputModule is not None and hasattr(process, outputModule):
getattr(process, outputModule).outputCommands = _addEventContent(
getattr(process, outputModule).outputCommands, [
'keep *_%s_*_%s' % (collectionToKeep, process.name_())
for collectionToKeep in collectionsToKeep
])
