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 ])