File indexing completed on 2022-01-26 04:12:34
0001 from __future__ import print_function
0002 import FWCore.ParameterSet.Config as cms
0003
0004 from PhysicsTools.PatAlgos.tools.ConfigToolBase import *
0005 import PhysicsTools.PatAlgos.tools.helpers as configtools
0006 from PhysicsTools.PatAlgos.tools.helpers import getPatAlgosToolsTask, addToProcessAndTask
0007 from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection
0008 import CommonTools.CandAlgos.candPtrProjector_cfi as _mod
0009 from PhysicsTools.PatUtils.tools.pfforTrkMET_cff import *
0010 import JetMETCorrections.Type1MET.BadPFCandidateJetsEEnoiseProducer_cfi as _modbad
0011 import JetMETCorrections.Type1MET.UnclusteredBlobProducer_cfi as _modunc
0012
0013 def isValidInputTag(input):
0014 input_str = input
0015 if isinstance(input, cms.InputTag):
0016 input_str = input.value()
0017 if input is None or input_str == '""':
0018 return False
0019 else:
0020 return True
0021
0022
0023 class RunMETCorrectionsAndUncertainties(ConfigToolBase):
0024
0025 _label='RunMETCorrectionsAndUncertainties'
0026 _defaultParameters=dicttypes.SortedKeysDict()
0027
0028 def __init__(self):
0029 ConfigToolBase.__init__(self)
0030 self.addParameter(self._defaultParameters, 'metType', "PF",
0031 "Type of considered MET (only PF and Puppi supported so far)", Type=str)
0032 self.addParameter(self._defaultParameters, 'correctionLevel', [""],
0033 "level of correction : available corrections for pfMet are T0, T1, T2, Txy and Smear; irrelevant entry for MVAMet)",
0034 allowedValues=["T0","T1","T2","Txy","Smear",""])
0035 self.addParameter(self._defaultParameters, 'computeUncertainties', True,
0036 "enable/disable the uncertainty computation", Type=bool)
0037 self.addParameter(self._defaultParameters, 'produceIntermediateCorrections', False,
0038 "enable/disable the production of all correction schemes (only for the most common)", Type=bool)
0039 self.addParameter(self._defaultParameters, 'electronCollection', cms.InputTag('selectedPatElectrons'),
0040 "Input electron collection", Type=cms.InputTag, acceptNoneValue=True)
0041
0042 self.addParameter(self._defaultParameters, 'photonCollection', cms.InputTag('selectedPatPhotons'),
0043 "Input photon collection", Type=cms.InputTag, acceptNoneValue=True)
0044 self.addParameter(self._defaultParameters, 'muonCollection', cms.InputTag('selectedPatMuons'),
0045 "Input muon collection", Type=cms.InputTag, acceptNoneValue=True)
0046 self.addParameter(self._defaultParameters, 'tauCollection', cms.InputTag('selectedPatTaus'),
0047 "Input tau collection", Type=cms.InputTag, acceptNoneValue=True)
0048 self.addParameter(self._defaultParameters, 'jetCollectionUnskimmed', cms.InputTag('patJets'),
0049 "Input unskimmed jet collection for T1 MET computation", Type=cms.InputTag, acceptNoneValue=True)
0050 self.addParameter(self._defaultParameters, 'pfCandCollection', cms.InputTag('particleFlow'),
0051 "pf Candidate collection", Type=cms.InputTag, acceptNoneValue=True)
0052 self.addParameter(self._defaultParameters, 'autoJetCleaning', 'LepClean',
0053 "Enable the jet cleaning for the uncertainty computation: Full for tau/photons/jet cleaning, Partial for jet cleaning, LepClean for jet cleaning with muon and electrons only, None or Manual for no cleaning", Type=str)
0054 self.addParameter(self._defaultParameters, 'jetFlavor', 'AK4PFchs',
0055 "Use AK4PF/AK4PFchs for PFJets,AK4Calo for CaloJets", Type=str)
0056 self.addParameter(self._defaultParameters, 'jetCorrectionType', 'L1L2L3-L1',
0057 "Use L1L2L3-L1 for the standard L1 removal / L1L2L3-RC for the random-cone correction", Type=str)
0058
0059 self.addParameter(self._defaultParameters, 'jetCorLabelUpToL3', "ak4PFCHSL1FastL2L3Corrector", "Use ak4PFL1FastL2L3Corrector (ak4PFCHSL1FastL2L3Corrector) for PFJets with (without) charged hadron subtraction, ak4CaloL1FastL2L3Corrector for CaloJets", Type=str)
0060 self.addParameter(self._defaultParameters, 'jetCorLabelL3Res', "ak4PFCHSL1FastL2L3ResidualCorrector", "Use ak4PFL1FastL2L3ResidualCorrector (ak4PFCHSL1FastL2L3ResidualCorrector) for PFJets with (without) charged hadron subtraction, ak4CaloL1FastL2L3ResidualCorrector for CaloJets", Type=str)
0061
0062
0063 self.addParameter(self._defaultParameters, 'jecUncertaintyFile', '',
0064 "Extra JES uncertainty file", Type=str)
0065 self.addParameter(self._defaultParameters, 'jecUncertaintyTag', None,
0066 "JES uncertainty Tag", acceptNoneValue=True)
0067
0068 self.addParameter(self._defaultParameters, 'mvaMetLeptons',["Electrons","Muons"],
0069 "Leptons to be used for recoil computation in the MVA MET, available values are: Electrons, Muons, Taus, Photons", allowedValues=["Electrons","Muons","Taus","Photons",""])
0070
0071 self.addParameter(self._defaultParameters, 'addToPatDefaultSequence', False,
0072 "Flag to enable/disable that metUncertaintySequence is inserted into patDefaultSequence", Type=bool)
0073 self.addParameter(self._defaultParameters, 'manualJetConfig', False,
0074 "Enable jet configuration options", Type=bool)
0075 self.addParameter(self._defaultParameters, 'jetSelection', 'pt>15 && abs(eta)<9.9',
0076 "Advanced jet kinematic selection", Type=str)
0077 self.addParameter(self._defaultParameters, 'recoMetFromPFCs', False,
0078 "Recompute the MET from scratch using the pfCandidate collection", Type=bool)
0079 self.addParameter(self._defaultParameters, 'reapplyJEC', True,
0080 "Flag to enable/disable JEC update", Type=bool)
0081 self.addParameter(self._defaultParameters, 'reclusterJets', False,
0082 "Flag to enable/disable the jet reclustering", Type=bool)
0083 self.addParameter(self._defaultParameters, 'computeMETSignificance', True,
0084 "Flag to enable/disable the MET significance computation", Type=bool)
0085 self.addParameter(self._defaultParameters, 'CHS', False,
0086 "Flag to enable/disable the CHS jets", Type=bool)
0087 self.addParameter(self._defaultParameters, 'runOnData', False,
0088 "Switch for data/MC processing", Type=bool)
0089 self.addParameter(self._defaultParameters, 'onMiniAOD', False,
0090 "Switch on miniAOD configuration", Type=bool)
0091 self.addParameter(self._defaultParameters, 'postfix', '',
0092 "Technical parameter to identify the resulting sequence and its modules (allows multiple calls in a job)", Type=str)
0093 self.addParameter(self._defaultParameters,'fixEE2017', False,
0094 "Exclude jets and PF candidates with EE noise characteristics (fix for 2017 run)", Type=bool)
0095 self.addParameter(self._defaultParameters,'fixEE2017Params', {'userawPt': True, 'ptThreshold': 50.0, 'minEtaThreshold': 2.65, 'maxEtaThreshold': 3.139},
0096 "Parameters dict for fixEE2017: userawPt, ptThreshold, minEtaThreshold, maxEtaThreshold", Type=dict)
0097 self.addParameter(self._defaultParameters, 'extractDeepMETs', False,
0098 "Extract DeepMETs from miniAOD, instead of recomputing them.", Type=bool)
0099
0100
0101 self.addParameter(self._defaultParameters, 'Puppi', False,
0102 "Puppi algorithm (private)", Type=bool)
0103
0104
0105
0106 self._parameters = copy.deepcopy(self._defaultParameters)
0107 self._comment = ""
0108
0109 def getDefaultParameters(self):
0110 return self._defaultParameters
0111
0112
0113 def __call__(self, process,
0114 metType =None,
0115 correctionLevel =None,
0116 computeUncertainties =None,
0117 produceIntermediateCorrections = None,
0118 electronCollection =None,
0119 photonCollection =None,
0120 muonCollection =None,
0121 tauCollection =None,
0122 jetCollectionUnskimmed =None,
0123 pfCandCollection =None,
0124 autoJetCleaning =None,
0125 jetFlavor =None,
0126 jetCorr =None,
0127 jetCorLabelUpToL3 =None,
0128 jetCorLabelL3Res =None,
0129 jecUncertaintyFile =None,
0130 jecUncertaintyTag =None,
0131 mvaMetLeptons =None,
0132 addToPatDefaultSequence =None,
0133 manualJetConfig =None,
0134 jetSelection =None,
0135 recoMetFromPFCs =None,
0136 reapplyJEC =None,
0137 reclusterJets =None,
0138 computeMETSignificance =None,
0139 CHS =None,
0140 runOnData =None,
0141 onMiniAOD =None,
0142 fixEE2017 =None,
0143 fixEE2017Params =None,
0144 extractDeepMETs =None,
0145 postfix =None):
0146 electronCollection = self.initializeInputTag(electronCollection, 'electronCollection')
0147 photonCollection = self.initializeInputTag(photonCollection, 'photonCollection')
0148 muonCollection = self.initializeInputTag(muonCollection, 'muonCollection')
0149 tauCollection = self.initializeInputTag(tauCollection, 'tauCollection')
0150 jetCollectionUnskimmed = self.initializeInputTag(jetCollectionUnskimmed, 'jetCollectionUnskimmed')
0151 pfCandCollection = self.initializeInputTag(pfCandCollection, 'pfCandCollection')
0152 if metType is None :
0153 metType = self._defaultParameters['metType'].value
0154 if correctionLevel is None :
0155 correctionLevel = self._defaultParameters['correctionLevel'].value
0156 if computeUncertainties is None :
0157 computeUncertainties = self._defaultParameters['computeUncertainties'].value
0158 if produceIntermediateCorrections is None :
0159 produceIntermediateCorrections = self._defaultParameters['produceIntermediateCorrections'].value
0160 if electronCollection is None :
0161 electronCollection = self._defaultParameters['electronCollection'].value
0162 if photonCollection is None :
0163 photonCollection = self._defaultParameters['photonCollection'].value
0164 if muonCollection is None :
0165 muonCollection = self._defaultParameters['muonCollection'].value
0166 if tauCollection is None :
0167 tauCollection = self._defaultParameters['tauCollection'].value
0168 if jetCollectionUnskimmed is None :
0169 jetCollectionUnskimmed = self._defaultParameters['jetCollectionUnskimmed'].value
0170 if pfCandCollection is None :
0171 pfCandCollection = self._defaultParameters['pfCandCollection'].value
0172 if autoJetCleaning is None :
0173 autoJetCleaning = self._defaultParameters['autoJetCleaning'].value
0174 if jetFlavor is None :
0175 jetFlavor = self._defaultParameters['jetFlavor'].value
0176 if jetCorr is None :
0177 jetCorr = self._defaultParameters['jetCorrectionType'].value
0178 if jetCorLabelUpToL3 is None:
0179 jetCorLabelUpToL3 = self._defaultParameters['jetCorLabelUpToL3'].value
0180 if jetCorLabelL3Res is None:
0181 jetCorLabelL3Res = self._defaultParameters['jetCorLabelL3Res'].value
0182 if jecUncertaintyFile is None:
0183 jecUncertaintyFile = self._defaultParameters['jecUncertaintyFile'].value
0184 if jecUncertaintyTag is None:
0185 jecUncertaintyTag = self._defaultParameters['jecUncertaintyTag'].value
0186
0187 if mvaMetLeptons is None:
0188 mvaMetLeptons = self._defaultParameters['mvaMetLeptons'].value
0189
0190 if addToPatDefaultSequence is None :
0191 addToPatDefaultSequence = self._defaultParameters['addToPatDefaultSequence'].value
0192 if manualJetConfig is None :
0193 manualJetConfig = self._defaultParameters['manualJetConfig'].value
0194 if jetSelection is None :
0195 jetSelection = self._defaultParameters['jetSelection'].value
0196 recoMetFromPFCsIsNone = (recoMetFromPFCs is None)
0197 if recoMetFromPFCs is None :
0198 recoMetFromPFCs = self._defaultParameters['recoMetFromPFCs'].value
0199 if reapplyJEC is None :
0200 reapplyJEC = self._defaultParameters['reapplyJEC'].value
0201 reclusterJetsIsNone = (reclusterJets is None)
0202 if reclusterJets is None :
0203 reclusterJets = self._defaultParameters['reclusterJets'].value
0204 if computeMETSignificance is None :
0205 computeMETSignificance = self._defaultParameters['computeMETSignificance'].value
0206 if CHS is None :
0207 CHS = self._defaultParameters['CHS'].value
0208 if runOnData is None :
0209 runOnData = self._defaultParameters['runOnData'].value
0210 if onMiniAOD is None :
0211 onMiniAOD = self._defaultParameters['onMiniAOD'].value
0212 if postfix is None :
0213 postfix = self._defaultParameters['postfix'].value
0214 if fixEE2017 is None :
0215 fixEE2017 = self._defaultParameters['fixEE2017'].value
0216 if fixEE2017Params is None :
0217 fixEE2017Params = self._defaultParameters['fixEE2017Params'].value
0218 if extractDeepMETs is None :
0219 extractDeepMETs = self._defaultParameters['extractDeepMETs'].value
0220
0221 self.setParameter('metType',metType),
0222 self.setParameter('correctionLevel',correctionLevel),
0223 self.setParameter('computeUncertainties',computeUncertainties),
0224 self.setParameter('produceIntermediateCorrections',produceIntermediateCorrections),
0225 self.setParameter('electronCollection',electronCollection),
0226 self.setParameter('photonCollection',photonCollection),
0227 self.setParameter('muonCollection',muonCollection),
0228 self.setParameter('tauCollection',tauCollection),
0229 self.setParameter('jetCollectionUnskimmed',jetCollectionUnskimmed),
0230 self.setParameter('pfCandCollection',pfCandCollection),
0231
0232 self.setParameter('autoJetCleaning',autoJetCleaning),
0233 self.setParameter('jetFlavor',jetFlavor),
0234
0235
0236 self.setParameter('jecUncertaintyFile',jecUncertaintyFile),
0237 self.setParameter('jecUncertaintyTag',jecUncertaintyTag),
0238
0239 self.setParameter('mvaMetLeptons',mvaMetLeptons),
0240
0241 self.setParameter('addToPatDefaultSequence',addToPatDefaultSequence),
0242 self.setParameter('jetSelection',jetSelection),
0243 self.setParameter('recoMetFromPFCs',recoMetFromPFCs),
0244 self.setParameter('reclusterJets',reclusterJets),
0245 self.setParameter('computeMETSignificance',computeMETSignificance),
0246 self.setParameter('reapplyJEC',reapplyJEC),
0247 self.setParameter('CHS',CHS),
0248 self.setParameter('runOnData',runOnData),
0249 self.setParameter('onMiniAOD',onMiniAOD),
0250 self.setParameter('postfix',postfix),
0251 self.setParameter('fixEE2017',fixEE2017),
0252 self.setParameter('fixEE2017Params',fixEE2017Params),
0253 self.setParameter('extractDeepMETs',extractDeepMETs),
0254
0255
0256 if metType == "MVA" or metType == "Puppi":
0257 self.setParameter('CHS',False),
0258
0259
0260 self.setParameter('Puppi',self._defaultParameters['Puppi'].value)
0261 if metType == "Puppi":
0262 self.setParameter('metType',"PF")
0263 self.setParameter('Puppi',True)
0264
0265
0266 if manualJetConfig:
0267 self.setParameter('CHS',CHS)
0268 self.setParameter('jetCorLabelUpToL3',jetCorLabelUpToL3)
0269 self.setParameter('jetCorLabelL3Res',jetCorLabelL3Res)
0270 self.setParameter('reclusterJets',reclusterJets)
0271 else:
0272
0273 self.jetConfiguration()
0274
0275
0276
0277 if fixEE2017:
0278 if recoMetFromPFCsIsNone: self.setParameter('recoMetFromPFCs',True)
0279 if reclusterJetsIsNone: self.setParameter('reclusterJets',False)
0280
0281
0282 if recoMetFromPFCs and reclusterJetsIsNone and not fixEE2017:
0283 self.setParameter('reclusterJets',True)
0284
0285 self.apply(process)
0286
0287
0288 def toolCode(self, process):
0289 metType = self._parameters['metType'].value
0290 correctionLevel = self._parameters['correctionLevel'].value
0291 computeUncertainties = self._parameters['computeUncertainties'].value
0292 produceIntermediateCorrections = self._parameters['produceIntermediateCorrections'].value
0293 electronCollection = self._parameters['electronCollection'].value
0294 photonCollection = self._parameters['photonCollection'].value
0295 muonCollection = self._parameters['muonCollection'].value
0296 tauCollection = self._parameters['tauCollection'].value
0297 jetCollectionUnskimmed = self._parameters['jetCollectionUnskimmed'].value
0298 pfCandCollection = self._parameters['pfCandCollection'].value
0299 autoJetCleaning = self._parameters['autoJetCleaning'].value
0300 jetFlavor = self._parameters['jetFlavor'].value
0301 jetCorLabelUpToL3 = self._parameters['jetCorLabelUpToL3'].value
0302 jetCorLabelL3Res = self._parameters['jetCorLabelL3Res'].value
0303 jecUncertaintyFile = self._parameters['jecUncertaintyFile'].value
0304 jecUncertaintyTag = self._parameters['jecUncertaintyTag'].value
0305
0306 mvaMetLeptons = self._parameters['mvaMetLeptons'].value
0307 addToPatDefaultSequence = self._parameters['addToPatDefaultSequence'].value
0308 jetSelection = self._parameters['jetSelection'].value
0309 recoMetFromPFCs = self._parameters['recoMetFromPFCs'].value
0310 reapplyJEC = self._parameters['reapplyJEC'].value
0311 reclusterJets = self._parameters['reclusterJets'].value
0312 computeMETSignificance = self._parameters['computeMETSignificance'].value
0313 onMiniAOD = self._parameters['onMiniAOD'].value
0314 postfix = self._parameters['postfix'].value
0315 fixEE2017 = self._parameters['fixEE2017'].value
0316 fixEE2017Params = self._parameters['fixEE2017Params'].value
0317 extractDeepMETs = self._parameters['extractDeepMETs'].value
0318
0319
0320 jetUncInfos = { "jCorrPayload":jetFlavor, "jCorLabelUpToL3":jetCorLabelUpToL3,
0321 "jCorLabelL3Res":jetCorLabelL3Res, "jecUncFile":jecUncertaintyFile,
0322 "jecUncTag":"Uncertainty" }
0323
0324 if (jecUncertaintyFile!="" and jecUncertaintyTag==None):
0325 jetUncInfos[ "jecUncTag" ] = ""
0326 elif(jecUncertaintyTag!=None):
0327 jetUncInfos[ "jecUncTag" ] = jecUncertaintyTag
0328
0329 patMetModuleSequence = cms.Sequence()
0330
0331
0332 if fixEE2017:
0333 pfCandCollection, jetCollectionUnskimmed = self.runFixEE2017(process,
0334 fixEE2017Params,
0335 jetCollectionUnskimmed,
0336 pfCandCollection,
0337 [electronCollection,muonCollection,tauCollection,photonCollection],
0338 patMetModuleSequence,
0339 postfix,
0340 )
0341
0342
0343 if recoMetFromPFCs:
0344 self.recomputeRawMetFromPfcs(process,
0345 pfCandCollection,
0346 onMiniAOD,
0347 patMetModuleSequence,
0348 postfix)
0349
0350 elif onMiniAOD:
0351 self.extractMET(process, "raw", patMetModuleSequence, postfix)
0352
0353
0354
0355 if reclusterJets:
0356 jetCollectionUnskimmed = self.ak4JetReclustering(process, pfCandCollection,
0357 patMetModuleSequence, postfix)
0358
0359
0360 if onMiniAOD:
0361 if not reclusterJets and reapplyJEC:
0362 jetCollectionUnskimmed = self.updateJECs(process, jetCollectionUnskimmed, patMetModuleSequence, postfix)
0363
0364
0365
0366
0367 jetCollection = self.getJetCollectionForCorsAndUncs(process,
0368 jetCollectionUnskimmed,
0369 jetSelection,
0370 autoJetCleaning,
0371 patMetModuleSequence,
0372 postfix)
0373
0374
0375 if onMiniAOD:
0376 self.miniAODConfigurationPre(process, patMetModuleSequence, pfCandCollection, postfix)
0377 else:
0378 from PhysicsTools.PatUtils.pfeGammaToCandidate_cfi import pfeGammaToCandidate
0379 task = getPatAlgosToolsTask(process)
0380 addToProcessAndTask("pfeGammaToCandidate", pfeGammaToCandidate.clone(
0381 electrons = copy.copy(electronCollection),
0382 photons = copy.copy(photonCollection)),
0383 process, task)
0384 if hasattr(process,"patElectrons") and process.patElectrons.electronSource == cms.InputTag("reducedEgamma","reducedGedGsfElectrons"):
0385 process.pfeGammaToCandidate.electron2pf = "reducedEgamma:reducedGsfElectronPfCandMap"
0386 if hasattr(process,"patPhotons") and process.patPhotons.photonSource == cms.InputTag("reducedEgamma","reducedGedPhotons"):
0387 process.pfeGammaToCandidate.photon2pf = "reducedEgamma:reducedPhotonPfCandMap"
0388
0389
0390 self.produceMET(process, metType,patMetModuleSequence, postfix)
0391
0392
0393
0394
0395 if onMiniAOD:
0396 self.miniAODConfiguration(process,
0397 pfCandCollection,
0398 jetCollection,
0399 patMetModuleSequence,
0400 postfix
0401 )
0402
0403
0404 patMetCorrectionSequence, metModName = self.getCorrectedMET(process, metType, correctionLevel,
0405 produceIntermediateCorrections,
0406 jetCollection,
0407 patMetModuleSequence, postfix )
0408
0409
0410
0411
0412 if "T1" in metModName:
0413 getattr(process,"patPFMetT1T2Corr"+postfix).src = jetCollection
0414 getattr(process,"patPFMetT2Corr"+postfix).src = jetCollection
0415
0416 if self._parameters["Puppi"].value:
0417 getattr(process,"patPFMetT1T2Corr"+postfix).offsetCorrLabel = cms.InputTag("")
0418 getattr(process,"patPFMetT2Corr"+postfix).offsetCorrLabel = cms.InputTag("")
0419 if "Smear" in metModName:
0420 getattr(process,"patSmearedJets"+postfix).src = jetCollection
0421 if self._parameters["Puppi"].value:
0422 getattr(process,"patPFMetT1T2SmearCorr"+postfix).offsetCorrLabel = cms.InputTag("")
0423
0424
0425
0426 patMetUncertaintySequence = cms.Sequence()
0427 tmpUncSequence =cms.Sequence()
0428 if not hasattr(process, "patMetUncertaintySequence"+postfix):
0429 if self._parameters["Puppi"].value:
0430 patMetUncertaintySequence=cms.Sequence(getattr(process, "ak4PFPuppiL1FastL2L3CorrectorChain")+getattr(process, "ak4PFPuppiL1FastL2L3ResidualCorrectorChain"))
0431 else:
0432 patMetUncertaintySequence=cms.Sequence(getattr(process, "ak4PFCHSL1FastL2L3CorrectorChain")+getattr(process, "ak4PFCHSL1FastL2L3ResidualCorrectorChain"))
0433 patShiftedModuleSequence = cms.Sequence()
0434 if computeUncertainties:
0435 tmpUncSequence,patShiftedModuleSequence = self.getMETUncertainties(process, metType, metModName,
0436 electronCollection,
0437 photonCollection,
0438 muonCollection,
0439 tauCollection,
0440 pfCandCollection,
0441 jetCollection,
0442 jetUncInfos,
0443 postfix)
0444
0445 if not hasattr(process, "patMetCorrectionSequence"+postfix):
0446 setattr(process, "patMetCorrectionSequence"+postfix, patMetCorrectionSequence)
0447 if not hasattr(process, "patMetUncertaintySequence"+postfix):
0448 patMetUncertaintySequence += tmpUncSequence
0449 setattr(process, "patMetUncertaintySequence"+postfix, patMetUncertaintySequence)
0450 else:
0451 if not len(configtools.listModules(tmpUncSequence))==0:
0452 setattr(process, metModName+"patMetUncertaintySequence"+postfix , tmpUncSequence)
0453 tmpSeq = getattr(process, "patMetUncertaintySequence"+postfix)
0454 tmpSeq += getattr(process, metModName+"patMetUncertaintySequence"+postfix)
0455
0456 if not hasattr(process, "patShiftedModuleSequence"+postfix):
0457 setattr(process, "patShiftedModuleSequence"+postfix, patShiftedModuleSequence)
0458 else:
0459 if not len(configtools.listModules(patShiftedModuleSequence))==0:
0460 setattr(process, metModName+"patShiftedModuleSequence"+postfix , patShiftedModuleSequence)
0461 tmpSeq = getattr(process, "patShiftedModuleSequence"+postfix)
0462 tmpSeq += getattr(process, metModName+"patShiftedModuleSequence"+postfix)
0463
0464 if not hasattr(process, "patMetModuleSequence"+postfix):
0465 setattr(process, "patMetModuleSequence"+postfix, patMetModuleSequence)
0466
0467
0468 fullPatMetSequence = cms.Sequence()
0469 fullPatMetSequence += getattr(process, "patMetModuleSequence"+postfix)
0470 fullPatMetSequence += getattr(process, "patMetCorrectionSequence"+postfix)
0471 fullPatMetSequence += getattr(process, "patMetUncertaintySequence"+postfix)
0472 fullPatMetSequence += getattr(process, "patShiftedModuleSequence"+postfix)
0473
0474
0475 if hasattr(process, "patCaloMet"):
0476 fullPatMetSequence +=getattr(process, "patCaloMet")
0477
0478 if hasattr(process, "deepMETsResolutionTune"):
0479 fullPatMetSequence +=getattr(process, "deepMETsResolutionTune")
0480 if hasattr(process, "deepMETsResponseTune"):
0481 fullPatMetSequence += getattr(process, "deepMETsResponseTune")
0482 if hasattr(process, "slimmedMETs"+postfix):
0483 fullPatMetSequence +=getattr(process, "slimmedMETs"+postfix)
0484
0485 setattr(process,"fullPatMetSequence"+postfix,fullPatMetSequence)
0486
0487
0488 configtools.removeIfInSequence(process, "selectedPatJetsForMetT1T2Corr", "patPFMetT1T2CorrSequence", postfix )
0489
0490
0491 self.miniAODConfigurationPost(process, postfix)
0492
0493
0494 if addToPatDefaultSequence:
0495 if not hasattr(process, "patDefaultSequence"):
0496 raise ValueError("PAT default sequence is not defined !!")
0497 process.patDefaultSequence += getattr(process, "fullPatMetSequence"+postfix)
0498
0499
0500 def produceMET(self, process, metType, metModuleSequence, postfix):
0501
0502 task = getPatAlgosToolsTask(process)
0503
0504 if metType == "PF" and not hasattr(process, 'pat'+metType+'Met'):
0505 process.load("PhysicsTools.PatUtils.patPFMETCorrections_cff")
0506 task.add(process.producePatPFMETCorrectionsTask)
0507 task.add(process.patPFMetT2SmearCorrTask)
0508 task.add(process.patPFMetTxyCorrTask)
0509 task.add(process.jetCorrectorsTask)
0510
0511 _myPatMet = 'pat'+metType+'Met'+postfix
0512 if postfix != "" and metType == "PF" and not hasattr(process, _myPatMet):
0513 noClonesTmp = [ "particleFlowDisplacedVertex", "pfCandidateToVertexAssociation" ]
0514 configtools.cloneProcessingSnippet(process, getattr(process,"producePatPFMETCorrections"), postfix, noClones = noClonesTmp, addToTask = True)
0515 addToProcessAndTask(_myPatMet, getattr(process,'patPFMet').clone(), process, task)
0516 getattr(process, _myPatMet).metSource = cms.InputTag("pfMet"+postfix)
0517 getattr(process, _myPatMet).srcPFCands = copy.copy(self.getvalue("pfCandCollection"))
0518 if self.getvalue("Puppi"):
0519 getattr(process, _myPatMet).srcWeights = "puppiNoLep"
0520 if metType == "PF":
0521 getattr(process, _myPatMet).srcLeptons = \
0522 cms.VInputTag(copy.copy(self.getvalue("electronCollection")) if self.getvalue("onMiniAOD") else
0523 cms.InputTag("pfeGammaToCandidate","electrons"),
0524 copy.copy(self.getvalue("muonCollection")),
0525 copy.copy(self.getvalue("photonCollection")) if self.getvalue("onMiniAOD") else
0526 cms.InputTag("pfeGammaToCandidate","photons"))
0527
0528 if self.getvalue("runOnData"):
0529 getattr(process, _myPatMet).addGenMET = False
0530
0531
0532
0533 if metType == "MVA":
0534
0535 mvaMetProducer = self.createMVAMETModule(process)
0536 addToProcessAndTask('pfMVAMet'+postfix, mvaMetProducer, process, task)
0537 addToProcessAndTask(_myPatMet,
0538 getattr(process,'patPFMet' ).clone(metSource = cms.InputTag('pfMVAMet')),
0539 process, task)
0540
0541 metModuleSequence += getattr(process, _myPatMet )
0542
0543
0544 def getCorrectedMET(self, process, metType, correctionLevel,produceIntermediateCorrections,
0545 jetCollection, metModuleSequence, postfix ):
0546
0547
0548 patMetCorrectionSequence = cms.Sequence()
0549 metModName = "pat"+metType+"Met"+postfix
0550
0551 if metType == "MVA":
0552 return patMetCorrectionSequence, metModName
0553
0554 corNames = {
0555 "T0":"T0pc",
0556 "T1":"T1",
0557 "T2":"T2",
0558 "Txy":"Txy",
0559 "Smear":"Smear",
0560 }
0561
0562
0563
0564 for cor in correctionLevel:
0565 if cor not in corNames.keys():
0566 if cor != "":
0567 print("ERROR : ",cor," is not a proper MET correction name! aborting the MET correction production")
0568 return patMetCorrectionSequence, metModName
0569
0570 corModNames = {
0571 "T0": "patPFMetT0CorrSequence"+postfix,
0572 "T1": "patPFMetT1T2CorrSequence"+postfix,
0573 "T2": "patPFMetT2CorrSequence"+postfix,
0574 "Txy": "patPFMetTxyCorrSequence"+postfix,
0575 "Smear": "patPFMetSmearCorrSequence"+postfix,
0576 "T2Smear": "patPFMetT2SmearCorrSequence"+postfix
0577 }
0578
0579 if postfix != "":
0580 noClonesTmp = [ "particleFlowDisplacedVertex", "pfCandidateToVertexAssociation" ]
0581 if not hasattr(process, "patPFMetT0CorrSequence"+postfix):
0582 configtools.cloneProcessingSnippet(process, getattr(process,"patPFMetT0CorrSequence"), postfix, noClones = noClonesTmp, addToTask = True)
0583 if not hasattr(process, "patPFMetT1T2CorrSequence"+postfix):
0584 configtools.cloneProcessingSnippet(process, getattr(process,"patPFMetT1T2CorrSequence"), postfix, addToTask = True)
0585 if not hasattr(process, "patPFMetT2CorrSequence"+postfix):
0586 configtools.cloneProcessingSnippet(process, getattr(process,"patPFMetT2CorrSequence"), postfix, addToTask = True)
0587 if not hasattr(process, "patPFMetTxyCorrSequence"+postfix):
0588 configtools.cloneProcessingSnippet(process, getattr(process,"patPFMetTxyCorrSequence"), postfix, addToTask = True)
0589 if not hasattr(process, "patPFMetSmearCorrSequence"+postfix):
0590 configtools.cloneProcessingSnippet(process, getattr(process,"patPFMetSmearCorrSequence"), postfix, addToTask = True)
0591 if not hasattr(process, "patPFMetT2SmearCorrSequence"+postfix):
0592 configtools.cloneProcessingSnippet(process, getattr(process,"patPFMetT2SmearCorrSequence"), postfix, addToTask = True)
0593
0594 corModules = {}
0595 for mod in corModNames.keys():
0596 corModules[mod] = getattr(process, corModNames[mod] )
0597
0598 corTags = {
0599
0600
0601
0602
0603
0604
0605 "T0":['patPFMetT0Corr'+postfix,''],
0606 "T1":['patPFMetT1T2Corr'+postfix, 'type1'],
0607 "T2":['patPFMetT2Corr'+postfix, 'type2'],
0608 "Txy": ['patPFMetTxyCorr'+postfix,''],
0609 "Smear":['patPFMetT1T2SmearCorr'+postfix, 'type1'],
0610 "T2Smear":['patPFMetT2SmearCorr'+postfix, 'type2']
0611 }
0612
0613 corScheme=""
0614 corrections = []
0615 correctionSequence = []
0616 for cor in correctionLevel:
0617 corScheme += corNames[cor]
0618 corrections.append(cms.InputTag(corTags[cor][0],corTags[cor][1]))
0619 correctionSequence.append(corModules[cor])
0620
0621
0622 if "T2" in correctionLevel and "Smear" in correctionLevel:
0623 corrections.append(cms.InputTag(corTags["T2Smear"][0],corTags["T2Smear"][1]))
0624 correctionSequence.append(corModules["T2Smear"])
0625
0626
0627 if "T1" in correctionLevel and "Smear" in correctionLevel:
0628 corrections.remove(cms.InputTag(corTags["T1"][0],corTags["T1"][1]))
0629
0630
0631 if "Txy" in correctionLevel:
0632 self.tuneTxyParameters(process, corScheme, postfix)
0633 getattr(process, "patPFMetTxyCorr"+postfix).srcPFlow = self._parameters["pfCandCollection"].value
0634 if self.getvalue("Puppi"):
0635 getattr(process, "patPFMetTxyCorr"+postfix).srcWeights = "puppiNoLep"
0636
0637
0638
0639 if "T1" in correctionLevel:
0640 _myPatMet = "pat"+metType+"Met"+postfix
0641 getattr(process, _myPatMet).computeMETSignificance = cms.bool(self.getvalue("computeMETSignificance"))
0642 getattr(process, _myPatMet).srcPFCands = copy.copy(self.getvalue("pfCandCollection"))
0643 getattr(process, _myPatMet).srcLeptons = \
0644 cms.VInputTag(copy.copy(self.getvalue("electronCollection")) if self.getvalue("onMiniAOD") else
0645 cms.InputTag("pfeGammaToCandidate","electrons"),
0646 copy.copy(self.getvalue("muonCollection")),
0647 copy.copy(self.getvalue("photonCollection")) if self.getvalue("onMiniAOD") else
0648 cms.InputTag("pfeGammaToCandidate","photons"))
0649 if postfix=="NoHF":
0650 getattr(process, _myPatMet).computeMETSignificance = cms.bool(False)
0651 if self.getvalue("runOnData"):
0652 from RecoMET.METProducers.METSignificanceParams_cfi import METSignificanceParams_Data
0653 getattr(process, _myPatMet).parameters = METSignificanceParams_Data
0654 if self.getvalue("Puppi"):
0655 getattr(process, _myPatMet).srcWeights = "puppiNoLep"
0656 getattr(process, _myPatMet).srcJets = cms.InputTag('cleanedPatJets'+postfix)
0657 getattr(process, _myPatMet).srcJetSF = 'AK4PFPuppi'
0658 getattr(process, _myPatMet).srcJetResPt = 'AK4PFPuppi_pt'
0659 getattr(process, _myPatMet).srcJetResPhi = 'AK4PFPuppi_phi'
0660
0661
0662 if not self._parameters["onMiniAOD"].value and not postfix=="NoHF":
0663 _myPatMet = "patMETs"+postfix
0664 getattr(process, _myPatMet).computeMETSignificance = cms.bool(self.getvalue("computeMETSignificance"))
0665 getattr(process, _myPatMet).srcPFCands=copy.copy(self.getvalue("pfCandCollection"))
0666 getattr(process, _myPatMet).srcLeptons = \
0667 cms.VInputTag(copy.copy(self.getvalue("electronCollection")) if self.getvalue("onMiniAOD") else
0668 cms.InputTag("pfeGammaToCandidate","electrons"),
0669 copy.copy(self.getvalue("muonCollection")),
0670 copy.copy(self.getvalue("photonCollection")) if self.getvalue("onMiniAOD") else
0671 cms.InputTag("pfeGammaToCandidate","photons"))
0672 if self.getvalue("Puppi"):
0673 getattr(process, _myPatMet).srcWeights = "puppiNoLep"
0674
0675 if hasattr(process, "patCaloMet"):
0676 getattr(process, "patCaloMet").computeMETSignificance = cms.bool(False)
0677
0678 task = getPatAlgosToolsTask(process)
0679
0680
0681 if "T1" in correctionLevel and not self._parameters["CHS"].value:
0682 addToProcessAndTask("corrPfMetType1"+postfix, getattr(process, "corrPfMetType1" ).clone(), process, task)
0683 getattr(process, "corrPfMetType1"+postfix).src = cms.InputTag("ak4PFJets"+postfix)
0684 getattr(process, "corrPfMetType1"+postfix).jetCorrLabel = cms.InputTag("ak4PFL1FastL2L3Corrector")
0685 getattr(process, "corrPfMetType1"+postfix).jetCorrLabelRes = cms.InputTag("ak4PFL1FastL2L3ResidualCorrector")
0686 getattr(process, "corrPfMetType1"+postfix).offsetCorrLabel = cms.InputTag("ak4PFL1FastjetCorrector")
0687 getattr(process, "basicJetsForMet"+postfix).offsetCorrLabel = cms.InputTag("ak4PFL1FastjetCorrector")
0688
0689 if "T1" in correctionLevel and self._parameters["Puppi"].value:
0690 addToProcessAndTask("corrPfMetType1"+postfix, getattr(process, "corrPfMetType1" ).clone(), process, task)
0691 getattr(process, "corrPfMetType1"+postfix).src = cms.InputTag("ak4PFJets"+postfix)
0692 getattr(process, "corrPfMetType1"+postfix).jetCorrLabel = cms.InputTag("ak4PFPuppiL1FastL2L3Corrector")
0693 getattr(process, "corrPfMetType1"+postfix).jetCorrLabelRes = cms.InputTag("ak4PFPuppiL1FastL2L3ResidualCorrector")
0694 getattr(process, "corrPfMetType1"+postfix).offsetCorrLabel = cms.InputTag("ak4PFPuppiL1FastjetCorrector")
0695 getattr(process, "basicJetsForMet"+postfix).offsetCorrLabel = cms.InputTag("L1FastJet")
0696
0697 if "T1" in correctionLevel and self._parameters["CHS"].value and self._parameters["reclusterJets"].value:
0698 getattr(process, "corrPfMetType1"+postfix).src = cms.InputTag("ak4PFJetsCHS"+postfix)
0699
0700
0701 metModName = "pat"+metType+"Met"+corScheme+postfix
0702
0703 sequenceName=""
0704 corMetProducer=None
0705 if metType == "PF":
0706 corMetProducer = cms.EDProducer("CorrectedPATMETProducer",
0707 src = cms.InputTag('pat'+metType+'Met' + postfix),
0708 srcCorrections = cms.VInputTag(corrections)
0709 )
0710 sequenceName="patMetCorrectionSequence"
0711
0712
0713
0714
0715
0716
0717
0718 addToProcessAndTask(metModName, corMetProducer, process, task)
0719
0720
0721 if not hasattr(process, sequenceName+postfix):
0722
0723 for corModule in correctionSequence:
0724 patMetCorrectionSequence += corModule
0725
0726 setattr(process, sequenceName+postfix, patMetCorrectionSequence)
0727
0728 else:
0729 patMetCorrectionSequence = getattr(process, "patMetCorrectionSequence"+postfix)
0730
0731
0732 for cor in corModNames.keys():
0733 if not configtools.contains(patMetCorrectionSequence, corTags[cor][0]) and cor in correctionLevel:
0734 patMetCorrectionSequence += corModules[cor]
0735
0736
0737 patMetCorrectionSequence += getattr(process, metModName)
0738
0739
0740
0741 if produceIntermediateCorrections:
0742 interMets = self.addIntermediateMETs(process, metType, correctionLevel, corScheme, corTags,corNames, postfix)
0743 for met in interMets.keys():
0744 addToProcessAndTask(met, interMets[met], process, task)
0745 patMetCorrectionSequence += getattr(process, met)
0746
0747 return patMetCorrectionSequence, metModName
0748
0749
0750
0751 def addIntermediateMETs(self, process, metType, correctionLevel, corScheme, corTags, corNames, postfix):
0752 interMets = {}
0753
0754
0755 if len(correctionLevel) == 1:
0756 return interMets
0757
0758
0759 nCor=len(correctionLevel)+1
0760 ids = [0]*nCor
0761 for i in range(nCor**nCor):
0762 tmp=i
0763 exists=False
0764 corName=""
0765 corrections = []
0766 for j in range(nCor):
0767 ids[j] = tmp%nCor
0768 tmp = tmp//nCor
0769
0770 if j != 0 and ids[j-1] < ids[j]:
0771 exists=True
0772 for k in range(0,j):
0773 if ids[k] == ids[j] and ids[k]!=0:
0774 exists=True
0775
0776 if exists or sum(ids[j] for j in range(nCor))==0:
0777 continue
0778
0779 for cor in range(nCor):
0780 cid = ids[nCor-cor-1]
0781 cKey = correctionLevel[cid-1]
0782 if cid ==0:
0783 continue
0784 else :
0785 corName += corNames[cKey]
0786 corrections.append( cms.InputTag(corTags[ cKey ][0], corTags[ cKey ][1]) )
0787
0788 if corName == corScheme:
0789 continue
0790
0791 corName='pat'+metType+'Met' + corName + postfix
0792 if configtools.contains(getattr(process,"patMetCorrectionSequence"+postfix), corName ) and hasattr(process, corName):
0793 continue
0794
0795 interMets[corName] = cms.EDProducer("CorrectedPATMETProducer",
0796 src = cms.InputTag('pat'+metType+'Met' + postfix),
0797 srcCorrections = cms.VInputTag(corrections)
0798 )
0799
0800
0801 return interMets
0802
0803
0804
0805 def getMETUncertainties(self, process, metType, metModName, electronCollection,
0806 photonCollection, muonCollection, tauCollection,
0807 pfCandCollection, jetCollection, jetUncInfos,
0808 postfix):
0809
0810
0811
0812 metUncSequence = cms.Sequence()
0813 shiftedModuleSequence = cms.Sequence()
0814
0815 task = getPatAlgosToolsTask(process)
0816
0817
0818
0819
0820 if not isValidInputTag(jetCollection):
0821 print("INFO : jet collection %s does not exists, no energy resolution shifting will be performed in MET uncertainty tools" % jetCollection)
0822 else:
0823 preId=""
0824 if "Smear" in metModName:
0825 preId="Smeared"
0826
0827 metJERUncModules = self.getVariations(process, metModName, "Jet",preId, jetCollection, "Res", metUncSequence, postfix=postfix )
0828
0829 for mod in metJERUncModules.keys():
0830 addToProcessAndTask(mod, metJERUncModules[mod], process, task)
0831 shiftedModuleSequence += getattr(process, mod)
0832
0833
0834
0835
0836 if not hasattr(process, "pfCandsForUnclusteredUnc"+postfix):
0837
0838
0839 pfCandsNoJets = _mod.candPtrProjector.clone(
0840 src = pfCandCollection,
0841 veto = jetCollection,
0842 )
0843 addToProcessAndTask("pfCandsNoJets"+postfix, pfCandsNoJets, process, task)
0844 metUncSequence += getattr(process, "pfCandsNoJets"+postfix)
0845
0846
0847 pfCandsNoJetsNoEle = _mod.candPtrProjector.clone(
0848 src = "pfCandsNoJets"+postfix,
0849 veto = electronCollection,
0850 )
0851 if not self.getvalue("onMiniAOD"):
0852 pfCandsNoJetsNoEle.veto = "pfeGammaToCandidate:electrons"
0853 addToProcessAndTask("pfCandsNoJetsNoEle"+postfix, pfCandsNoJetsNoEle, process, task)
0854 metUncSequence += getattr(process, "pfCandsNoJetsNoEle"+postfix)
0855
0856
0857 pfCandsNoJetsNoEleNoMu = _mod.candPtrProjector.clone(
0858 src = "pfCandsNoJetsNoEle"+postfix,
0859 veto = muonCollection,
0860 )
0861 addToProcessAndTask("pfCandsNoJetsNoEleNoMu"+postfix, pfCandsNoJetsNoEleNoMu, process, task)
0862 metUncSequence += getattr(process, "pfCandsNoJetsNoEleNoMu"+postfix)
0863
0864
0865 pfCandsNoJetsNoEleNoMuNoTau = _mod.candPtrProjector.clone(
0866 src = "pfCandsNoJetsNoEleNoMu"+postfix,
0867 veto = tauCollection,
0868 )
0869 addToProcessAndTask("pfCandsNoJetsNoEleNoMuNoTau"+postfix, pfCandsNoJetsNoEleNoMuNoTau, process, task)
0870 metUncSequence += getattr(process, "pfCandsNoJetsNoEleNoMuNoTau"+postfix)
0871
0872
0873 pfCandsForUnclusteredUnc = _mod.candPtrProjector.clone(
0874 src = "pfCandsNoJetsNoEleNoMuNoTau"+postfix,
0875 veto = photonCollection,
0876 )
0877 if not self.getvalue("onMiniAOD"):
0878 pfCandsForUnclusteredUnc.veto = "pfeGammaToCandidate:photons"
0879 addToProcessAndTask("pfCandsForUnclusteredUnc"+postfix, pfCandsForUnclusteredUnc, process, task)
0880 metUncSequence += getattr(process, "pfCandsForUnclusteredUnc"+postfix)
0881
0882
0883
0884
0885
0886
0887
0888
0889
0890
0891 pfElectrons = cms.EDFilter("CandPtrSelector",
0892 src = electronCollection,
0893 cut = cms.string("pt > 5 && isPF && gsfTrack.isAvailable() && gsfTrack.hitPattern().numberOfLostHits(\'MISSING_INNER_HITS\') < 2")
0894 )
0895 addToProcessAndTask("pfElectrons"+postfix, pfElectrons, process, task)
0896 metUncSequence += getattr(process, "pfElectrons"+postfix)
0897
0898
0899
0900 pfTaus = cms.EDFilter("PATTauRefSelector",
0901 src = tauCollection,
0902 cut = cms.string('pt > 18.0 & abs(eta) < 2.6 & tauID("decayModeFinding") > 0.5 & isPFTau')
0903 )
0904 addToProcessAndTask("pfTaus"+postfix, pfTaus, process, task)
0905 metUncSequence += getattr(process, "pfTaus"+postfix)
0906
0907
0908
0909 pfMuons = cms.EDFilter("CandPtrSelector",
0910 src = muonCollection,
0911 cut = cms.string("pt > 5.0 && isPFMuon && abs(eta) < 2.4")
0912 )
0913 addToProcessAndTask("pfMuons"+postfix, pfMuons, process, task)
0914 metUncSequence += getattr(process, "pfMuons"+postfix)
0915
0916
0917
0918 pfPhotons = cms.EDFilter("CandPtrSelector",
0919 src = pfCandCollection if self._parameters["Puppi"].value or not self._parameters["onMiniAOD"].value else cms.InputTag("pfCHS"),
0920 cut = cms.string("abs(pdgId) = 22")
0921 )
0922 addToProcessAndTask("pfPhotons"+postfix, pfPhotons, process, task)
0923 metUncSequence += getattr(process, "pfPhotons"+postfix)
0924
0925
0926
0927 electronCollection = cms.InputTag("pfElectrons"+postfix)
0928 muonCollection = cms.InputTag("pfMuons"+postfix)
0929 tauCollection = cms.InputTag("pfTaus"+postfix)
0930 photonCollection = cms.InputTag("pfPhotons"+postfix)
0931
0932
0933 objectCollections = { "Jet":jetCollection,
0934 "Electron":electronCollection,
0935 "Photon":photonCollection,
0936 "Muon":muonCollection,
0937 "Unclustered":cms.InputTag("pfCandsForUnclusteredUnc"+postfix),
0938 "Tau":tauCollection,
0939 }
0940
0941 for obj in objectCollections.keys():
0942 if not isValidInputTag(objectCollections[obj]):
0943 print("INFO : %s collection %s does not exists, no energy scale shifting will be performed in MET uncertainty tools" %(obj, objectCollections[obj]))
0944 else:
0945 metObjUncModules = self.getVariations(process, metModName, obj,"", objectCollections[obj], "En", metUncSequence, jetUncInfos, postfix )
0946
0947
0948 for mod in metObjUncModules.keys():
0949 addToProcessAndTask(mod, metObjUncModules[mod], process, task)
0950 shiftedModuleSequence += getattr(process, mod)
0951
0952
0953 return metUncSequence, shiftedModuleSequence
0954
0955
0956 def createEnergyScaleShiftedUpModule(self, process,identifier, objectCollection,
0957 varyByNsigmas, jetUncInfos=None, postfix=""):
0958
0959 shiftedModuleUp = None
0960
0961 if identifier == "Electron":
0962 shiftedModuleUp = cms.EDProducer("ShiftedParticleProducer",
0963 src = objectCollection,
0964 uncertainty = cms.string('((abs(y)<1.479)?(0.006+0*x):(0.015+0*x))'),
0965 shiftBy = cms.double(+1.*varyByNsigmas),
0966 srcWeights = cms.InputTag("")
0967 )
0968
0969 if identifier == "Photon":
0970 shiftedModuleUp = cms.EDProducer("ShiftedParticleProducer",
0971 src = objectCollection,
0972 uncertainty = cms.string('((abs(y)<1.479)?(0.01+0*x):(0.025+0*x))'),
0973 shiftBy = cms.double(+1.*varyByNsigmas),
0974 srcWeights = cms.InputTag("")
0975 )
0976
0977 if identifier == "Muon":
0978 shiftedModuleUp = cms.EDProducer("ShiftedParticleProducer",
0979 src = objectCollection,
0980 uncertainty = cms.string('((x<100)?(0.002+0*y):(0.05+0*y))'),
0981 shiftBy = cms.double(+1.*varyByNsigmas),
0982 srcWeights = cms.InputTag("")
0983 )
0984
0985 if identifier == "Tau":
0986 shiftedModuleUp = cms.EDProducer("ShiftedParticleProducer",
0987 src = objectCollection,
0988 uncertainty = cms.string('0.03+0*x*y'),
0989 shiftBy = cms.double(+1.*varyByNsigmas),
0990 srcWeights = cms.InputTag("")
0991 )
0992
0993 if identifier == "Unclustered":
0994 shiftedModuleUp = cms.EDProducer("ShiftedParticleProducer",
0995 src = objectCollection,
0996 binning = cms.VPSet(
0997
0998 cms.PSet(
0999 binSelection = cms.string('charge!=0'),
1000 binUncertainty = cms.string('sqrt(pow(0.00009*x,2)+pow(0.0085/sqrt(sin(2*atan(exp(-y)))),2))')
1001 ),
1002
1003 cms.PSet(
1004 binSelection = cms.string('pdgId==130'),
1005 energyDependency = cms.bool(True),
1006 binUncertainty = cms.string('((abs(y)<1.3)?(min(0.25,sqrt(0.64/x+0.0025))):(min(0.30,sqrt(1.0/x+0.0016))))')
1007 ),
1008
1009 cms.PSet(
1010 binSelection = cms.string('pdgId==22'),
1011 energyDependency = cms.bool(True),
1012 binUncertainty = cms.string('sqrt(0.0009/x+0.000001)+0*y')
1013 ),
1014
1015 cms.PSet(
1016 binSelection = cms.string('pdgId==1 || pdgId==2'),
1017 energyDependency = cms.bool(True),
1018 binUncertainty = cms.string('sqrt(1./x+0.0025)+0*y')
1019 ),
1020 ),
1021 shiftBy = cms.double(+1.*varyByNsigmas),
1022 srcWeights = cms.InputTag("")
1023 )
1024
1025 if identifier == "Jet":
1026 moduleType="ShiftedPATJetProducer"
1027
1028
1029
1030
1031 if jetUncInfos["jecUncFile"] == "":
1032 shiftedModuleUp = cms.EDProducer(moduleType,
1033 src = objectCollection,
1034 jetCorrUncertaintyTag = cms.string(jetUncInfos["jecUncTag"] ),
1035 addResidualJES = cms.bool(True),
1036 jetCorrLabelUpToL3 = cms.InputTag(jetUncInfos["jCorLabelUpToL3"] ),
1037 jetCorrLabelUpToL3Res = cms.InputTag(jetUncInfos["jCorLabelL3Res"] ),
1038 jetCorrPayloadName = cms.string(jetUncInfos["jCorrPayload"] ),
1039 shiftBy = cms.double(+1.*varyByNsigmas),
1040 )
1041 else:
1042 shiftedModuleUp = cms.EDProducer(moduleType,
1043 src = objectCollection,
1044 jetCorrInputFileName = cms.FileInPath(jetUncInfos["jecUncFile"] ),
1045 jetCorrUncertaintyTag = cms.string(jetUncInfos["jecUncTag"] ),
1046 addResidualJES = cms.bool(True),
1047 jetCorrLabelUpToL3 = cms.InputTag(jetUncInfos["jCorLabelUpToL3"] ),
1048 jetCorrLabelUpToL3Res = cms.InputTag(jetUncInfos["jCorLabelL3Res"] ),
1049 jetCorrPayloadName = cms.string(jetUncInfos["jCorrPayload"] ),
1050 shiftBy = cms.double(+1.*varyByNsigmas),
1051 )
1052
1053
1054 return shiftedModuleUp
1055
1056
1057
1058
1059
1060
1061 def removePostfix(self, name, postfix):
1062
1063 if postfix=="":
1064 return name
1065
1066 baseName = name
1067 if baseName[-len(postfix):] == postfix:
1068 baseName = baseName[0:-len(postfix)]
1069 else:
1070 raise Exception("Tried to remove postfix %s from %s, but it wasn't there" % (postfix, baseName))
1071
1072 return baseName
1073
1074
1075 def tuneTxyParameters(self, process, corScheme, postfix):
1076 import PhysicsTools.PatUtils.patPFMETCorrections_cff as metCors
1077 xyTags = {
1078 "Txy_50ns":metCors.patMultPhiCorrParams_Txy_50ns,
1079 "T1Txy_50ns":metCors.patMultPhiCorrParams_T1Txy_50ns,
1080 "T0pcTxy_50ns":metCors.patMultPhiCorrParams_T0pcTxy_50ns,
1081 "T0pcT1Txy_50ns":metCors.patMultPhiCorrParams_T0pcT1Txy_50ns,
1082 "T1T2Txy_50ns":metCors.patMultPhiCorrParams_T1T2Txy_50ns,
1083 "T0pcT1T2Txy_50ns":metCors.patMultPhiCorrParams_T0pcT1T2Txy_50ns,
1084 "T1SmearTxy_50ns":metCors.patMultPhiCorrParams_T1SmearTxy_50ns,
1085 "T1T2SmearTxy_50ns":metCors.patMultPhiCorrParams_T1T2SmearTxy_50ns,
1086 "T0pcT1SmearTxy_50ns":metCors.patMultPhiCorrParams_T0pcT1SmearTxy_50ns,
1087 "T0pcT1T2SmearTxy_50ns":metCors.patMultPhiCorrParams_T0pcT1T2SmearTxy_50ns,
1088
1089 "Txy_25ns":metCors.patMultPhiCorrParams_Txy_25ns,
1090 "T1Txy_25ns":metCors.patMultPhiCorrParams_T1Txy_25ns,
1091 "T0pcTxy_25ns":metCors.patMultPhiCorrParams_T0pcTxy_25ns,
1092 "T0pcT1Txy_25ns":metCors.patMultPhiCorrParams_T0pcT1Txy_25ns,
1093 "T1T2Txy_25ns":metCors.patMultPhiCorrParams_T1T2Txy_25ns,
1094 "T0pcT1T2Txy_25ns":metCors.patMultPhiCorrParams_T0pcT1T2Txy_25ns,
1095 "T1SmearTxy_25ns":metCors.patMultPhiCorrParams_T1SmearTxy_25ns,
1096 "T1T2SmearTxy_25ns":metCors.patMultPhiCorrParams_T1T2SmearTxy_25ns,
1097 "T0pcT1SmearTxy_25ns":metCors.patMultPhiCorrParams_T0pcT1SmearTxy_25ns,
1098 "T0pcT1T2SmearTxy_25ns":metCors.patMultPhiCorrParams_T0pcT1T2SmearTxy_25ns
1099 }
1100
1101 getattr(process, "patPFMetTxyCorr"+postfix).parameters = xyTags[corScheme+"_25ns"]
1102
1103
1104
1105 def getVariations(self, process, metModName, identifier,preId, objectCollection, varType,
1106 metUncSequence, jetUncInfos=None, postfix="" ):
1107
1108
1109 varyByNsigmas=1
1110
1111
1112 baseName = self.removePostfix(metModName, postfix)
1113
1114
1115 shiftedMetProducers = {preId+identifier+varType+'Up':None, preId+identifier+varType+'Down':None}
1116
1117
1118 shiftedCollModules = {'Up':None, 'Down':None}
1119
1120 if identifier=="Jet" and varType=="Res":
1121 smear=False
1122 if "Smear" in metModName:
1123 smear=True
1124 else:
1125 smear=True
1126 varyByNsigmas=101
1127
1128 shiftedCollModules['Up'] = self.createShiftedJetResModule(process, smear, objectCollection, +1.*varyByNsigmas,
1129 "Up", postfix)
1130 shiftedCollModules['Down'] = self.createShiftedJetResModule(process, smear, objectCollection, -1.*varyByNsigmas,
1131 "Down", postfix)
1132 else:
1133 shiftedCollModules['Up'] = self.createEnergyScaleShiftedUpModule(process, identifier, objectCollection, varyByNsigmas, jetUncInfos, postfix)
1134 shiftedCollModules['Down'] = shiftedCollModules['Up'].clone( shiftBy = cms.double(-1.*varyByNsigmas) )
1135
1136 if identifier=="Jet" and varType=="Res":
1137 smear=False
1138 if "Smear" in metModName:
1139 objectCollection=cms.InputTag("selectedPatJetsForMetT1T2SmearCorr"+postfix)
1140
1141
1142
1143
1144 if identifier=="Jet" and varType=="Res" and self._parameters["runOnData"].value:
1145 shiftedMetProducers = self.copyCentralMETProducer(process, shiftedCollModules, identifier, metModName, varType, postfix)
1146 else:
1147 shiftedMetProducers = self.createShiftedModules(process, shiftedCollModules, identifier, preId, objectCollection,
1148 metModName, varType, metUncSequence, postfix)
1149
1150 return shiftedMetProducers
1151
1152
1153
1154 def copyCentralMETProducer(self, process, shiftedCollModules, identifier, metModName, varType, postfix):
1155
1156
1157 shiftedMetProducers = {}
1158 baseName = self.removePostfix(metModName, postfix)
1159 for mod in shiftedCollModules.keys():
1160 modName = baseName+identifier+varType+mod+postfix
1161 shiftedMETModule = getattr(process, metModName).clone()
1162 shiftedMetProducers[ modName ] = shiftedMETModule
1163
1164 return shiftedMetProducers
1165
1166
1167
1168 def createShiftedJetResModule(self, process, smear, objectCollection, varyByNsigmas, varDir, postfix ):
1169
1170 smearedJetModule = self.createSmearedJetModule(process, objectCollection, smear, varyByNsigmas, varDir, postfix)
1171
1172 return smearedJetModule
1173
1174
1175
1176 def createShiftedModules(self, process, shiftedCollModules, identifier, preId, objectCollection,
1177 metModName, varType, metUncSequence, postfix):
1178
1179 shiftedMetProducers = {}
1180
1181 task = getPatAlgosToolsTask(process)
1182
1183
1184 baseName = self.removePostfix(metModName, postfix)
1185
1186
1187 for mod in shiftedCollModules.keys():
1188 modName = "shiftedPat"+preId+identifier+varType+mod+postfix
1189
1190
1191
1192 if (identifier=="Photon" or identifier=="Unclustered") and self.getvalue("Puppi"):
1193 shiftedCollModules[mod].srcWeights = "puppiNoLep"
1194 if not hasattr(process, modName):
1195 addToProcessAndTask(modName, shiftedCollModules[mod], process, task)
1196 metUncSequence += getattr(process, modName)
1197
1198
1199 modName = "shiftedPat"+preId+identifier+varType+mod+postfix
1200
1201
1202 if "PF" in metModName:
1203
1204 shiftedMETCorrModule = self.createShiftedMETModule(process, objectCollection, modName)
1205 if (identifier=="Photon" or identifier=="Unclustered") and self.getvalue("Puppi"):
1206 shiftedMETCorrModule.srcWeights = "puppiNoLep"
1207 modMETShiftName = "shiftedPatMETCorr"+preId+identifier+varType+mod+postfix
1208 if not hasattr(process, modMETShiftName):
1209 addToProcessAndTask(modMETShiftName, shiftedMETCorrModule, process, task)
1210 metUncSequence += getattr(process, modMETShiftName)
1211
1212
1213 modName = baseName+identifier+varType+mod+postfix
1214 shiftedMETModule = getattr(process, metModName).clone(
1215 src = cms.InputTag( metModName ),
1216 srcCorrections = cms.VInputTag( cms.InputTag(modMETShiftName) )
1217 )
1218 shiftedMetProducers[ modName ] = shiftedMETModule
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252 return shiftedMetProducers
1253
1254
1255
1256 def createShiftedMETModule(self, process, originCollection, shiftedCollection):
1257
1258 shiftedModule = cms.EDProducer("ShiftedParticleMETcorrInputProducer",
1259 srcOriginal = originCollection,
1260 srcShifted = cms.InputTag(shiftedCollection),
1261 srcWeights = cms.InputTag("")
1262 )
1263
1264 return shiftedModule
1265
1266
1267 def createMVAMETModule(self, process, identifier="", shiftedCollection="", isShifted=False, postfix="" ):
1268
1269 task = getPatAlgosToolsTask(process)
1270
1271 if not hasattr(process, "pfMVAMEt"):
1272 process.load("RecoMET.METPUSubtraction.mvaPFMET_cff")
1273
1274
1275 electronCollection = self._parameters["electronCollection"].value
1276 muonCollection = self._parameters["electronCollection"].value
1277 photonCollection = self._parameters["photonCollection"].value
1278 tauCollection = self._parameters["tauCollection"].value
1279 pfCandCollection = self._parameters["pfCandCollection"].value
1280 corJetCollection = cms.InputTag("calibratedAK4PFJetsForPFMVAMEt"+postfix)
1281 uncorJetCollection = cms.InputTag("ak4PFJets")
1282
1283
1284 if isShifted:
1285 if identifier == "Electron":
1286 electronCollection = cms.InputTag(shiftedCollection)
1287 if identifier == "Muon":
1288 muonCollection = cms.InputTag(shiftedCollection)
1289 if identifier == "Tau":
1290 tauCollection = cms.InputTag(shiftedCollection)
1291 if identifier == "Photon":
1292 photonCollection = cms.InputTag(shiftedCollection)
1293 if identifier == "Unclustered":
1294 pfCandCollection = cms.InputTag(shiftedCollection)
1295 if identifier == "Jet":
1296 corJetCollection = cms.InputTag(shiftedCollection)
1297 uncorJetCollection = cms.InputTag("uncorrected"+shiftedCollection)
1298
1299
1300
1301 mvaMetLeptons = self._parameters["mvaMetLeptons"].value
1302 leptons = cms.VInputTag([])
1303 if "Electrons" in mvaMetLeptons and isValidInputTag(electronCollection):
1304 leptons.append = electronCollection
1305 if "Muons" in mvaMetLeptons and isValidInputTag(muonCollection):
1306 leptons.append = muonCollection
1307 if "Photons" in mvaMetLeptons and isValidInputTag(photonCollection):
1308 leptons.append = photonCollection
1309 if "Taus" in mvaMetLeptons and isValidInputTag(tauCollection):
1310 leptons.append = tauCollection
1311
1312
1313 mvaMetProducer=getattr(process, "pfMVAMEt").clone(
1314 srcCorrJets = corJetCollection,
1315 srcUncorrJets = uncorJetCollection,
1316 srcPFCandidates = pfCandCollection,
1317 srcLeptons = leptons,
1318 )
1319
1320 return mvaMetProducer
1321
1322
1323 def getUnclusteredVariationsForMVAMET(self, process, var, val, metUncSequence, postfix ):
1324
1325 if not hasattr(process, "pfCandsNotInJetsForMetCorr"):
1326 process.load("JetMETCorrections.Type1MET.correctionTerms.PfMetType1Type2_cff")
1327
1328
1329
1330 unclCandModule = cms.EDProducer("ShiftedPFCandidateProducer",
1331 src = cms.InputTag('pfCandsNotInJetsForMetCorr'),
1332 shiftBy = cms.double(val),
1333 uncertainty = cms.double(0.10)
1334 )
1335 setattr(process, "pfCandsNotInJetsUnclusteredEn"+var+postfix, unclCandModule)
1336 metUncSequence += getattr(process, "pfCandsNotInJetsUnclusteredEn"+var+postfix)
1337
1338
1339
1340
1341 pfCandCollection = self._parameters["pfCandCollection"].value
1342
1343
1344 pfCandsNotInJets = _mod.candPtrProjector.clone(
1345 src = pfCandCollection,
1346 veto = "ak4PFJets"
1347 )
1348 setattr(process, "pfCandsNotInJetsUnclusteredEn"+var+postfix, pfCandsNotInJets)
1349 metUncSequence += getattr(process,"pfCandsNotInJetsUnclusteredEn"+var+postfix)
1350
1351 fullShiftedModule = self.createShiftedObjectModuleForMVAMET(pfCandCollection, cms.InputTag("pfCandsNotInJetsUnclusteredEn"+var+postfix), 0.01 )
1352 setattr(process, "pfCandidatesEn"+var+postfix, fullShiftedModule)
1353 metUncSequence += getattr(process, "pfCandidatesEn"+var+postfix)
1354
1355
1356 shiftedMETModule = self.createMVAMETModule(process, "Unclustered", "pfCandidatesEn"+var+postfix, True)
1357 return shiftedMETModule
1358
1359
1360 def createShiftedObjectModuleForMVAMET(self, origCollection, shiftedCollection, dr=0.5):
1361 fullShiftedModule = cms.EDProducer("ShiftedPFCandidateProducerByMatchedObject",
1362 srcPFCandidates = origCollection,
1363 srcUnshiftedObjects = origCollection,
1364 dRmatch_PFCandidate = cms.double(dr),
1365 srcShiftedObjects = shiftedCollection
1366 )
1367 return fullShiftedModule
1368
1369
1370 def createSmearedJetModule(self, process, jetCollection, smear, varyByNsigmas, varDir, postfix):
1371
1372 smearedJetModule = None
1373
1374 modName = "pat"
1375 selJetModName= "selectedPatJetsForMetT1T2"
1376 if smear:
1377 modName += "SmearedJets"
1378 selJetModName += "SmearCorr"
1379 else:
1380 modName += "Jets"
1381
1382
1383 if varDir != "":
1384 modName += "Res"+varDir
1385 selJetModName += "Res"+varDir
1386
1387 modName += postfix
1388 selJetModName += postfix
1389
1390 genJetsCollection=cms.InputTag('ak4GenJetsNoNu')
1391 if self._parameters["onMiniAOD"].value:
1392 genJetsCollection=cms.InputTag("slimmedGenJets")
1393
1394 if self._parameters["Puppi"].value:
1395 getattr(process, "patSmearedJets"+postfix).algo = 'AK4PFPuppi'
1396 getattr(process, "patSmearedJets"+postfix).algopt = 'AK4PFPuppi_pt'
1397
1398 if "PF" == self._parameters["metType"].value:
1399 smearedJetModule = getattr(process, "patSmearedJets"+postfix).clone(
1400 src = jetCollection,
1401 enabled = cms.bool(smear),
1402 variation = cms.int32( int(varyByNsigmas) ),
1403 genJets = genJetsCollection,
1404 )
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429 return smearedJetModule
1430
1431
1432
1433 def labelsInSequence(process, sequenceLabel, postfix=""):
1434 result = [ m.label()[:-len(postfix)] for m in listModules( getattr(process,sequenceLabel+postfix))]
1435 result.extend([ m.label()[:-len(postfix)] for m in listSequences( getattr(process,sequenceLabel+postfix))] )
1436 if postfix == "":
1437 result = [ m.label() for m in listModules( getattr(process,sequenceLabel+postfix))]
1438 result.extend([ m.label() for m in listSequences( getattr(process,sequenceLabel+postfix))] )
1439 return result
1440
1441 def initializeInputTag(self, input, default):
1442 retVal = None
1443 if input is None:
1444 retVal = self._defaultParameters[default].value
1445 elif isinstance(input, str):
1446 retVal = cms.InputTag(input)
1447 else:
1448 retVal = input
1449 return retVal
1450
1451
1452 def recomputeRawMetFromPfcs(self, process, pfCandCollection, onMiniAOD, patMetModuleSequence, postfix):
1453
1454 task = getPatAlgosToolsTask(process)
1455
1456
1457 if not hasattr(process, "pfMet"+postfix) and self._parameters["metType"].value == "PF":
1458
1459
1460 from RecoMET.METProducers.pfMet_cfi import pfMet
1461 addToProcessAndTask("pfMet"+postfix, pfMet.clone(), process, task)
1462 getattr(process, "pfMet"+postfix).src = pfCandCollection
1463 getattr(process, "pfMet"+postfix).calculateSignificance = False
1464 if self.getvalue("Puppi"):
1465 getattr(process, "pfMet"+postfix).applyWeight = True
1466 getattr(process, "pfMet"+postfix).srcWeights = "puppiNoLep"
1467 patMetModuleSequence += getattr(process, "pfMet"+postfix)
1468
1469
1470 if not hasattr(process, "patMETs"+postfix) and self._parameters["metType"].value == "PF":
1471 process.load("PhysicsTools.PatAlgos.producersLayer1.metProducer_cff")
1472 task.add(process.makePatMETsTask)
1473 configtools.cloneProcessingSnippet(process, getattr(process,"patMETCorrections"), postfix, addToTask = True)
1474
1475
1476 if not onMiniAOD:
1477
1478 getattr(process, "pfMetT1"+postfix).src = cms.InputTag("pfMet"+postfix)
1479 patMetModuleSequence += getattr(process, "pfMetT1"+postfix)
1480 _myPatMet = 'patMETs'+postfix
1481 addToProcessAndTask(_myPatMet, getattr(process,'patMETs' ).clone(), process, task)
1482 getattr(process, _myPatMet).metSource = cms.InputTag("pfMetT1"+postfix)
1483 getattr(process, _myPatMet).computeMETSignificance = cms.bool(self.getvalue("computeMETSignificance"))
1484 getattr(process, _myPatMet).srcLeptons = \
1485 cms.VInputTag(copy.copy(self.getvalue("electronCollection")) if self.getvalue("onMiniAOD") else
1486 cms.InputTag("pfeGammaToCandidate","electrons"),
1487 copy.copy(self.getvalue("muonCollection")),
1488 copy.copy(self.getvalue("photonCollection")) if self.getvalue("onMiniAOD") else
1489 cms.InputTag("pfeGammaToCandidate","photons"))
1490 if postfix=="NoHF":
1491 getattr(process, _myPatMet).computeMETSignificance = cms.bool(False)
1492
1493 if self.getvalue("Puppi"):
1494 getattr(process, _myPatMet).srcWeights = "puppiNoLep"
1495 getattr(process, _myPatMet).srcJets = cms.InputTag('cleanedPatJets'+postfix)
1496 getattr(process, _myPatMet).srcJetSF = cms.string('AK4PFPuppi')
1497 getattr(process, _myPatMet).srcJetResPt = cms.string('AK4PFPuppi_pt')
1498 getattr(process, _myPatMet).srcJetResPhi = cms.string('AK4PFPuppi_phi')
1499
1500
1501 def extractMET(self, process, correctionLevel, patMetModuleSequence, postfix):
1502
1503 task = getPatAlgosToolsTask(process)
1504
1505 pfMet = cms.EDProducer("RecoMETExtractor",
1506 metSource= cms.InputTag("slimmedMETs" if not self._parameters["Puppi"].value else "slimmedMETsPuppi",processName=cms.InputTag.skipCurrentProcess()),
1507 correctionLevel = cms.string(correctionLevel)
1508 )
1509 if(correctionLevel=="raw"):
1510 addToProcessAndTask("pfMet"+postfix, pfMet, process, task)
1511 patMetModuleSequence += getattr(process, "pfMet"+postfix)
1512 else:
1513 addToProcessAndTask("met"+correctionLevel+postfix, pfMet, process, task)
1514 patMetModuleSequence += getattr(process, "met"+correctionLevel+postfix)
1515
1516 if not hasattr(process, "genMetExtractor"+postfix) and not self._parameters["runOnData"].value:
1517 genMetExtractor = cms.EDProducer("GenMETExtractor",
1518 metSource= cms.InputTag("slimmedMETs",processName=cms.InputTag.skipCurrentProcess())
1519 )
1520 addToProcessAndTask("genMetExtractor"+postfix, genMetExtractor, process, task)
1521 patMetModuleSequence += getattr(process, "genMetExtractor"+postfix)
1522
1523
1524 def updateJECs(self,process,jetCollection, patMetModuleSequence, postfix):
1525 from PhysicsTools.PatAlgos.producersLayer1.jetUpdater_cff import updatedPatJetCorrFactors
1526
1527 patJetCorrFactorsReapplyJEC = updatedPatJetCorrFactors.clone(
1528 src = jetCollection if not self._parameters["Puppi"].value else cms.InputTag("slimmedJetsPuppi"),
1529 levels = ['L1FastJet',
1530 'L2Relative',
1531 'L3Absolute'],
1532 payload = 'AK4PFchs' if not self._parameters["Puppi"].value else 'AK4PFPuppi' )
1533
1534 if self._parameters["runOnData"].value:
1535 patJetCorrFactorsReapplyJEC.levels.append("L2L3Residual")
1536
1537 from PhysicsTools.PatAlgos.producersLayer1.jetUpdater_cff import updatedPatJets
1538 patJetsReapplyJEC = updatedPatJets.clone(
1539 jetSource = jetCollection if not self._parameters["Puppi"].value else cms.InputTag("slimmedJetsPuppi"),
1540 jetCorrFactorsSource = cms.VInputTag(cms.InputTag("patJetCorrFactorsReapplyJEC"+postfix))
1541 )
1542
1543 task = getPatAlgosToolsTask(process)
1544 addToProcessAndTask("patJetCorrFactorsReapplyJEC"+postfix, patJetCorrFactorsReapplyJEC, process, task)
1545 addToProcessAndTask("patJetsReapplyJEC"+postfix, patJetsReapplyJEC.clone(), process, task)
1546
1547 patMetModuleSequence += getattr(process,"patJetCorrFactorsReapplyJEC"+postfix)
1548 patMetModuleSequence += getattr(process,"patJetsReapplyJEC"+postfix)
1549
1550 return cms.InputTag("patJetsReapplyJEC"+postfix)
1551
1552
1553 def getJetCollectionForCorsAndUncs(self, process, jetCollectionUnskimmed,
1554 jetSelection, autoJetCleaning,patMetModuleSequence, postfix):
1555
1556 task = getPatAlgosToolsTask(process)
1557
1558 basicJetsForMet = cms.EDProducer("PATJetCleanerForType1MET",
1559 src = jetCollectionUnskimmed,
1560 jetCorrEtaMax = cms.double(9.9),
1561 jetCorrLabel = cms.InputTag("L3Absolute"),
1562 jetCorrLabelRes = cms.InputTag("L2L3Residual"),
1563 offsetCorrLabel = cms.InputTag("L1FastJet"),
1564 skipEM = cms.bool(True),
1565 skipEMfractionThreshold = cms.double(0.9),
1566 skipMuonSelection = cms.string('isGlobalMuon | isStandAloneMuon'),
1567 skipMuons = cms.bool(True),
1568 type1JetPtThreshold = cms.double(15.0)
1569 )
1570 addToProcessAndTask("basicJetsForMet"+postfix, basicJetsForMet, process, task)
1571 patMetModuleSequence += getattr(process, "basicJetsForMet"+postfix)
1572
1573 from PhysicsTools.PatAlgos.selectionLayer1.jetSelector_cfi import selectedPatJets
1574 jetSelector = selectedPatJets.clone(
1575 src = cms.InputTag("basicJetsForMet"+postfix),
1576 cut = cms.string(jetSelection)
1577 )
1578 addToProcessAndTask("jetSelectorForMet"+postfix, jetSelector, process, task)
1579 patMetModuleSequence += getattr(process, "jetSelectorForMet"+postfix)
1580
1581 jetCollection = self.jetCleaning(process, "jetSelectorForMet"+postfix, autoJetCleaning, patMetModuleSequence, postfix)
1582
1583 return jetCollection
1584
1585
1586 def ak4JetReclustering(self,process, pfCandCollection, patMetModuleSequence, postfix):
1587
1588 task = getPatAlgosToolsTask(process)
1589
1590 chs = self._parameters["CHS"].value
1591 jetColName="ak4PFJets"
1592 CHSname=""
1593 pfCandColl=pfCandCollection
1594 if chs:
1595 CHSname="chs"
1596 jetColName="ak4PFJetsCHS"
1597 if self._parameters["onMiniAOD"].value:
1598 pfCandColl = cms.InputTag("pfCHS")
1599 else:
1600 addToProcessAndTask("tmpPFCandCollPtr"+postfix,
1601 cms.EDProducer("PFCandidateFwdPtrProducer",
1602 src = pfCandCollection ),
1603 process, task)
1604 process.load("CommonTools.ParticleFlow.pfNoPileUpJME_cff")
1605 task.add(process.pfNoPileUpJMETask)
1606 configtools.cloneProcessingSnippet(process, getattr(process,"pfNoPileUpJMESequence"), postfix, addToTask = True )
1607 getattr(process, "pfPileUpJME"+postfix).PFCandidates = "tmpPFCandCollPtr"+postfix
1608 getattr(process, "pfNoPileUpJME"+postfix).bottomCollection = "tmpPFCandCollPtr"+postfix
1609 pfCandColl = "pfNoPileUpJME"+postfix
1610 patMetModuleSequence += getattr(process, "tmpPFCandCollPtr"+postfix)
1611 patMetModuleSequence += getattr(process, "pfNoPileUpJME"+postfix)
1612
1613 jetColName+=postfix
1614 if not hasattr(process, jetColName):
1615
1616
1617 from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets
1618
1619 addToProcessAndTask(jetColName, ak4PFJets.clone(), process, task)
1620 getattr(process, jetColName).src = pfCandColl
1621 getattr(process, jetColName).doAreaFastjet = True
1622
1623
1624 if self._parameters["Puppi"].value:
1625 getattr(process, jetColName).srcWeights = cms.InputTag("puppi")
1626 getattr(process, jetColName).applyWeight = True
1627
1628 patMetModuleSequence += getattr(process, jetColName)
1629
1630 corLevels=['L1FastJet', 'L2Relative', 'L3Absolute']
1631 if self._parameters["runOnData"].value:
1632 corLevels.append("L2L3Residual")
1633
1634 switchJetCollection(process,
1635 jetSource = cms.InputTag(jetColName),
1636 jetCorrections = ('AK4PF'+CHSname, corLevels , ''),
1637 postfix=postfix
1638 )
1639
1640 getattr(process,"patJets"+postfix).addGenJetMatch = False
1641 getattr(process,"patJets"+postfix).addGenPartonMatch = False
1642 getattr(process,"patJets"+postfix).addPartonJetMatch = False
1643 getattr(process,"patJets"+postfix).embedGenPartonMatch = False
1644 getattr(process,"patJets"+postfix).embedGenJetMatch = False
1645 if self._parameters['onMiniAOD'].value:
1646 del getattr(process,"patJets"+postfix).JetFlavourInfoSource
1647 del getattr(process,"patJets"+postfix).JetPartonMapSource
1648 del getattr(process,"patJets"+postfix).genPartonMatch
1649 del getattr(process,"patJets"+postfix).genJetMatch
1650 getattr(process,"patJets"+postfix).getJetMCFlavour = False
1651
1652 getattr(process,"patJetCorrFactors"+postfix).src=cms.InputTag(jetColName)
1653 getattr(process,"patJetCorrFactors"+postfix).primaryVertices= cms.InputTag("offlineSlimmedPrimaryVertices")
1654 if self._parameters["Puppi"].value:
1655 getattr(process,"patJetCorrFactors"+postfix).payload=cms.string('AK4PFPuppi')
1656 patMetModuleSequence += getattr(process, "patJetCorrFactors"+postfix)
1657 patMetModuleSequence += getattr(process, "patJets"+postfix)
1658
1659 return cms.InputTag("patJets"+postfix)
1660
1661
1662
1663 def miniAODConfigurationPre(self, process, patMetModuleSequence, pfCandCollection, postfix):
1664
1665
1666 self.extractMET(process,"rawCalo",patMetModuleSequence,postfix)
1667 caloMetName="metrawCalo" if hasattr(process,"metrawCalo") else "metrawCalo"+postfix
1668 from PhysicsTools.PatAlgos.tools.metTools import addMETCollection
1669 addMETCollection(process,
1670 labelName = "patCaloMet",
1671 metSource = caloMetName
1672 )
1673 getattr(process,"patCaloMet").addGenMET = False
1674
1675
1676 if self._parameters["extractDeepMETs"].value:
1677 self.extractMET(process, "rawDeepResponseTune", patMetModuleSequence, postfix)
1678 deepMetResponseTuneName = "metrawDeepResponseTune" if hasattr(process, "metrawDeepResponseTune") else "metrawDeepResponseTune"+postfix
1679 addMETCollection(process,
1680 labelName = "deepMETsResponseTune",
1681 metSource = deepMetResponseTuneName
1682 )
1683 getattr(process, "deepMETsResponseTune").addGenMET = False
1684 getattr(process, "deepMETsResponseTune").computeMETSignificance = cms.bool(False)
1685
1686 self.extractMET(process, "rawDeepResolutionTune", patMetModuleSequence, postfix)
1687 deepMetResolutionTuneName = "metrawDeepResolutionTune" if hasattr(process, "metrawDeepResolutionTune") else "metrawDeepResolutionTune"+postfix
1688 addMETCollection(process,
1689 labelName = "deepMETsResolutionTune",
1690 metSource = deepMetResolutionTuneName
1691 )
1692 getattr(process, "deepMETsResolutionTune").addGenMET = False
1693 getattr(process, "deepMETsResolutionTune").computeMETSignificance = cms.bool(False)
1694
1695
1696 task = getPatAlgosToolsTask(process)
1697
1698 from CommonTools.ParticleFlow.pfCHS_cff import pfCHS
1699 addToProcessAndTask("pfCHS", pfCHS.clone(), process, task)
1700 from RecoMET.METProducers.pfMet_cfi import pfMet
1701 pfMetCHS = pfMet.clone(src = "pfCHS")
1702 addToProcessAndTask("pfMetCHS", pfMetCHS, process, task)
1703
1704 addMETCollection(process,
1705 labelName = "patCHSMet",
1706 metSource = "pfMetCHS"
1707 )
1708
1709 process.patCHSMet.computeMETSignificant = cms.bool(False)
1710 process.patCHSMet.addGenMET = cms.bool(False)
1711
1712 patMetModuleSequence += getattr(process, "pfCHS")
1713 patMetModuleSequence += getattr(process, "pfMetCHS")
1714 patMetModuleSequence += getattr(process, "patCHSMet")
1715
1716 pfTrk = chargedPackedCandsForTkMet.clone()
1717 addToProcessAndTask("pfTrk", pfTrk, process, task)
1718 pfMetTrk = pfMet.clone(src = 'pfTrk')
1719 addToProcessAndTask("pfMetTrk", pfMetTrk, process, task)
1720
1721 addMETCollection(process,
1722 labelName = "patTrkMet",
1723 metSource = "pfMetTrk"
1724 )
1725
1726 process.patTrkMet.computeMETSignificant = cms.bool(False)
1727 process.patTrkMet.addGenMET = cms.bool(False)
1728
1729 patMetModuleSequence += getattr(process, "pfTrk")
1730 patMetModuleSequence += getattr(process, "pfMetTrk")
1731 patMetModuleSequence += getattr(process, "patTrkMet")
1732
1733
1734 def miniAODConfigurationPost(self, process, postfix):
1735
1736 if self._parameters["metType"].value == "PF":
1737 if hasattr(process, "patPFMetTxyCorr"+postfix):
1738 getattr(process, "patPFMetTxyCorr"+postfix).vertexCollection = cms.InputTag("offlineSlimmedPrimaryVertices")
1739
1740 if self._parameters['computeUncertainties'].value and not self._parameters["runOnData"]:
1741 getattr(process, "shiftedPatJetResDown"+postfix).genJets = cms.InputTag("slimmedGenJets")
1742 getattr(process, "shiftedPatJetResUp"+postfix).genJets = cms.InputTag("slimmedGenJets")
1743
1744
1745 def miniAODConfiguration(self, process, pfCandCollection, jetCollection,
1746 patMetModuleSequence, postfix ):
1747 if self._parameters["metType"].value == "PF":
1748 if "T1" in self._parameters['correctionLevel'].value:
1749 getattr(process, "patPFMet"+postfix).srcJets = jetCollection
1750 getattr(process, "patPFMet"+postfix).addGenMET = False
1751 if not self._parameters["runOnData"].value:
1752 getattr(process, "patPFMet"+postfix).addGenMET = True
1753 getattr(process, "patPFMet"+postfix).genMETSource = cms.InputTag("genMetExtractor"+postfix)
1754
1755
1756 if "Smear" in self._parameters['correctionLevel'].value:
1757 getattr(process, "patSmearedJets"+postfix).genJets = cms.InputTag("slimmedGenJets")
1758
1759 if not hasattr(process, "slimmedMETs"+postfix) and self._parameters["metType"].value == "PF":
1760
1761 task = getPatAlgosToolsTask(process)
1762
1763 from PhysicsTools.PatAlgos.slimming.slimmedMETs_cfi import slimmedMETs
1764 addToProcessAndTask("slimmedMETs"+postfix, slimmedMETs.clone(), process, task)
1765 getattr(process,"slimmedMETs"+postfix).src = cms.InputTag("patPFMetT1"+postfix)
1766 getattr(process,"slimmedMETs"+postfix).rawVariation = cms.InputTag("patPFMet"+postfix)
1767 getattr(process,"slimmedMETs"+postfix).t1Uncertainties = cms.InputTag("patPFMetT1%s"+postfix)
1768 getattr(process,"slimmedMETs"+postfix).t01Variation = cms.InputTag("patPFMetT0pcT1"+postfix)
1769 getattr(process,"slimmedMETs"+postfix).t1SmearedVarsAndUncs = cms.InputTag("patPFMetT1Smear%s"+postfix)
1770
1771 getattr(process,"slimmedMETs"+postfix).tXYUncForRaw = cms.InputTag("patPFMetTxy"+postfix)
1772 getattr(process,"slimmedMETs"+postfix).tXYUncForT1 = cms.InputTag("patPFMetT1Txy"+postfix)
1773 getattr(process,"slimmedMETs"+postfix).tXYUncForT01 = cms.InputTag("patPFMetT0pcT1Txy"+postfix)
1774 getattr(process,"slimmedMETs"+postfix).tXYUncForT1Smear = cms.InputTag("patPFMetT1SmearTxy"+postfix)
1775 getattr(process,"slimmedMETs"+postfix).tXYUncForT01Smear = cms.InputTag("patPFMetT0pcT1SmearTxy"+postfix)
1776
1777 getattr(process,"slimmedMETs"+postfix).runningOnMiniAOD = True
1778 getattr(process,"slimmedMETs"+postfix).t01Variation = cms.InputTag("slimmedMETs" if not self._parameters["Puppi"].value else "slimmedMETsPuppi",processName=cms.InputTag.skipCurrentProcess())
1779
1780 if hasattr(process, "deepMETsResolutionTune") and hasattr(process, "deepMETsResponseTune"):
1781
1782
1783 getattr(process,"slimmedMETs"+postfix).addDeepMETs = True
1784
1785
1786
1787 del getattr(process,"slimmedMETs"+postfix).tXYUncForRaw
1788 del getattr(process,"slimmedMETs"+postfix).tXYUncForT01
1789 del getattr(process,"slimmedMETs"+postfix).tXYUncForT1Smear
1790 del getattr(process,"slimmedMETs"+postfix).tXYUncForT01Smear
1791
1792
1793
1794 def jetConfiguration(self):
1795
1796 jetFlavor = self._parameters["jetFlavor"].value
1797 jetCorr = self._parameters["jetCorrectionType"].value
1798
1799 jetCorLabelUpToL3Name="ak4PF"
1800 jetCorLabelL3ResName="ak4PF"
1801
1802
1803 if "chs" in jetFlavor:
1804 self.setParameter("CHS",True)
1805 jetCorLabelUpToL3Name += "CHS"
1806 jetCorLabelL3ResName += "CHS"
1807 elif "Puppi" in jetFlavor:
1808 self.setParameter("CHS",False)
1809 jetCorLabelUpToL3Name += "Puppi"
1810 jetCorLabelL3ResName += "Puppi"
1811
1812 else:
1813 self.setParameter("CHS",False)
1814
1815
1816 if jetCorr == "L1L2L3-L1":
1817 jetCorLabelUpToL3Name += "L1FastL2L3Corrector"
1818 jetCorLabelL3ResName += "L1FastL2L3ResidualCorrector"
1819 elif jetCorr == "L1L2L3-RC":
1820 jetCorLabelUpToL3Name += "L1FastL2L3Corrector"
1821 jetCorLabelL3ResName += "L1FastL2L3ResidualCorrector"
1822
1823 self.setParameter("jetCorLabelUpToL3",jetCorLabelUpToL3Name )
1824 self.setParameter("jetCorLabelL3Res",jetCorLabelL3ResName )
1825
1826
1827 def jetCleaning(self, process, jetCollectionName, autoJetCleaning, jetProductionSequence, postfix ):
1828
1829 if autoJetCleaning == "None" or autoJetCleaning == "Manual" :
1830 return cms.InputTag(jetCollectionName)
1831
1832
1833 electronCollection = self._parameters["electronCollection"].value
1834 muonCollection = self._parameters["muonCollection"].value
1835 photonCollection = self._parameters["photonCollection"].value
1836 tauCollection = self._parameters["tauCollection"].value
1837
1838 task = getPatAlgosToolsTask(process)
1839
1840 if autoJetCleaning == "Full" :
1841 if isValidInputTag(tauCollection):
1842 process.load("PhysicsTools.PatAlgos.cleaningLayer1.tauCleaner_cfi")
1843 task.add(process.cleanPatTaus)
1844 cleanPatTauProducer = getattr(process, "cleanPatTaus").clone(
1845 src = tauCollection
1846 )
1847 cleanPatTauProducer.checkOverlaps.electrons.src = electronCollection
1848 cleanPatTauProducer.checkOverlaps.muons.src = muonCollection
1849 addToProcessAndTask("cleanedPatTaus"+postfix, cleanPatTauProducer, process, task)
1850 jetProductionSequence += getattr(process, "cleanedPatTaus"+postfix)
1851 tauCollection = cms.InputTag("cleanedPatTaus"+postfix)
1852
1853 if isValidInputTag(photonCollection):
1854 process.load("PhysicsTools.PatAlgos.cleaningLayer1.photonCleaner_cfi")
1855 task.add(process.cleanPatPhotons)
1856 cleanPatPhotonProducer = getattr(process, "cleanPatPhotons").clone(
1857 src = photonCollection
1858 )
1859 cleanPatPhotonProducer.checkOverlaps.electrons.src = electronCollection
1860 addToProcessAndTask("cleanedPatPhotons"+postfix, cleanPatPhotonProducer, process, task)
1861 jetProductionSequence += getattr(process, "cleanedPatPhotons"+postfix)
1862 photonCollection = cms.InputTag("cleanedPatPhotons"+postfix)
1863
1864
1865 have_cleanPatJets = hasattr(process, "cleanPatJets")
1866 process.load("PhysicsTools.PatAlgos.cleaningLayer1.jetCleaner_cfi")
1867 cleanPatJetProducer = getattr(process, "cleanPatJets").clone(
1868 src = cms.InputTag(jetCollectionName)
1869 )
1870
1871 if not have_cleanPatJets:
1872 del process.cleanPatJets
1873 cleanPatJetProducer.checkOverlaps.muons.src = muonCollection
1874 cleanPatJetProducer.checkOverlaps.electrons.src = electronCollection
1875 if isValidInputTag(photonCollection) and autoJetCleaning != "LepClean":
1876 cleanPatJetProducer.checkOverlaps.photons.src = photonCollection
1877 else:
1878 del cleanPatJetProducer.checkOverlaps.photons
1879
1880 if isValidInputTag(tauCollection) and autoJetCleaning != "LepClean":
1881 cleanPatJetProducer.checkOverlaps.taus.src = tauCollection
1882 else:
1883 del cleanPatJetProducer.checkOverlaps.taus
1884
1885
1886 del cleanPatJetProducer.checkOverlaps.tkIsoElectrons
1887
1888 addToProcessAndTask("cleanedPatJets"+postfix, cleanPatJetProducer, process, task)
1889 jetProductionSequence += getattr(process, "cleanedPatJets"+postfix)
1890 return cms.InputTag("cleanedPatJets"+postfix)
1891
1892
1893 def runFixEE2017(self,process,params,jets,cands,goodcolls,patMetModuleSequence,postfix):
1894
1895 task = getPatAlgosToolsTask(process)
1896
1897 pfCandidateJetsWithEEnoise = _modbad.BadPFCandidateJetsEEnoiseProducer.clone(
1898 jetsrc = jets,
1899 userawPt = params["userawPt"],
1900 ptThreshold = params["ptThreshold"],
1901 minEtaThreshold = params["minEtaThreshold"],
1902 maxEtaThreshold = params["maxEtaThreshold"],
1903 )
1904 addToProcessAndTask("pfCandidateJetsWithEEnoise"+postfix, pfCandidateJetsWithEEnoise, process, task)
1905 patMetModuleSequence += getattr(process,"pfCandidateJetsWithEEnoise"+postfix)
1906 pfcandidateClustered = cms.EDProducer("CandViewMerger",
1907 src = cms.VInputTag(goodcolls+[jets])
1908 )
1909 addToProcessAndTask("pfcandidateClustered"+postfix, pfcandidateClustered, process, task)
1910 patMetModuleSequence += getattr(process,"pfcandidateClustered"+postfix)
1911 pfcandidateForUnclusteredUnc = _mod.candPtrProjector.clone(
1912 src = cands,
1913 veto = "pfcandidateClustered"+postfix,
1914 )
1915 addToProcessAndTask("pfcandidateForUnclusteredUnc"+postfix, pfcandidateForUnclusteredUnc, process, task)
1916 patMetModuleSequence += getattr(process,"pfcandidateForUnclusteredUnc"+postfix)
1917 badUnclustered = cms.EDFilter("CandPtrSelector",
1918 src = cms.InputTag("pfcandidateForUnclusteredUnc"+postfix),
1919 cut = cms.string("abs(eta) > "+str(params["minEtaThreshold"])+" && abs(eta) < "+str(params["maxEtaThreshold"])),
1920 )
1921 addToProcessAndTask("badUnclustered"+postfix, badUnclustered, process, task)
1922 patMetModuleSequence += getattr(process,"badUnclustered"+postfix)
1923 blobUnclustered = _modunc.UnclusteredBlobProducer.clone(
1924 candsrc = "badUnclustered"+postfix,
1925 )
1926 addToProcessAndTask("blobUnclustered"+postfix, blobUnclustered, process, task)
1927 patMetModuleSequence += getattr(process,"blobUnclustered"+postfix)
1928 superbad = cms.EDProducer("CandViewMerger",
1929 src = cms.VInputTag(
1930 cms.InputTag("blobUnclustered"+postfix),
1931 cms.InputTag("pfCandidateJetsWithEEnoise"+postfix,"bad"),
1932 )
1933 )
1934 addToProcessAndTask("superbad"+postfix, superbad, process, task)
1935 patMetModuleSequence += getattr(process,"superbad"+postfix)
1936 pfCandidatesGoodEE2017 = _mod.candPtrProjector.clone(
1937 src = cands,
1938 veto = "superbad"+postfix,
1939 )
1940 addToProcessAndTask("pfCandidatesGoodEE2017"+postfix, pfCandidatesGoodEE2017, process, task)
1941 patMetModuleSequence += getattr(process,"pfCandidatesGoodEE2017"+postfix)
1942
1943 return (cms.InputTag("pfCandidatesGoodEE2017"+postfix), cms.InputTag("pfCandidateJetsWithEEnoise"+postfix,"good"))
1944
1945
1946 runMETCorrectionsAndUncertainties = RunMETCorrectionsAndUncertainties()
1947
1948
1949
1950
1951
1952 def runMetCorAndUncForMiniAODProduction(process, metType="PF",
1953 jetCollUnskimmed="patJets",
1954 photonColl="selectedPatPhotons",
1955 electronColl="selectedPatElectrons",
1956 muonColl="selectedPatMuons",
1957 tauColl="selectedPatTaus",
1958 pfCandColl = "particleFlow",
1959 jetCleaning="LepClean",
1960 jetSelection="pt>15 && abs(eta)<9.9",
1961 jecUnFile="",
1962 jetFlavor="AK4PFchs",
1963 recoMetFromPFCs=False,
1964 postfix=""):
1965
1966 runMETCorrectionsAndUncertainties = RunMETCorrectionsAndUncertainties()
1967
1968
1969 runMETCorrectionsAndUncertainties(process, metType=metType,
1970 correctionLevel=["T0","T1","T2","Smear","Txy"],
1971 computeUncertainties=False,
1972 produceIntermediateCorrections=True,
1973 addToPatDefaultSequence=False,
1974 jetCollectionUnskimmed=jetCollUnskimmed,
1975 photonCollection=photonColl,
1976 electronCollection=electronColl,
1977 muonCollection=muonColl,
1978 tauCollection=tauColl,
1979 pfCandCollection =pfCandColl,
1980 autoJetCleaning=jetCleaning,
1981 jecUncertaintyFile=jecUnFile,
1982 jetSelection=jetSelection,
1983 jetFlavor=jetFlavor,
1984 recoMetFromPFCs=recoMetFromPFCs,
1985 postfix=postfix
1986 )
1987
1988
1989 runMETCorrectionsAndUncertainties(process, metType=metType,
1990 correctionLevel=["T1"],
1991 computeUncertainties=True,
1992 produceIntermediateCorrections=False,
1993 addToPatDefaultSequence=False,
1994 jetCollectionUnskimmed=jetCollUnskimmed,
1995 photonCollection=photonColl,
1996 electronCollection=electronColl,
1997 muonCollection=muonColl,
1998 tauCollection=tauColl,
1999 pfCandCollection =pfCandColl,
2000 autoJetCleaning=jetCleaning,
2001 jecUncertaintyFile=jecUnFile,
2002 jetSelection=jetSelection,
2003 jetFlavor=jetFlavor,
2004 recoMetFromPFCs=recoMetFromPFCs,
2005 postfix=postfix
2006 )
2007
2008
2009 runMETCorrectionsAndUncertainties(process, metType=metType,
2010 correctionLevel=["T1","Smear"],
2011 computeUncertainties=True,
2012 produceIntermediateCorrections=False,
2013 addToPatDefaultSequence=False,
2014 jetCollectionUnskimmed=jetCollUnskimmed,
2015 photonCollection=photonColl,
2016 electronCollection=electronColl,
2017 muonCollection=muonColl,
2018 tauCollection=tauColl,
2019 pfCandCollection =pfCandColl,
2020 autoJetCleaning=jetCleaning,
2021 jecUncertaintyFile=jecUnFile,
2022 jetSelection=jetSelection,
2023 jetFlavor=jetFlavor,
2024 recoMetFromPFCs=recoMetFromPFCs,
2025 postfix=postfix,
2026 )
2027
2028
2029
2030
2031
2032 def runMetCorAndUncFromMiniAOD(process, metType="PF",
2033 jetCollUnskimmed="slimmedJets",
2034 photonColl="slimmedPhotons",
2035 electronColl="slimmedElectrons",
2036 muonColl="slimmedMuons",
2037 tauColl="slimmedTaus",
2038 pfCandColl = "packedPFCandidates",
2039 jetFlavor="AK4PFchs",
2040 jetCleaning="LepClean",
2041 isData=False,
2042 manualJetConfig=False,
2043 reclusterJets=None,
2044 jetSelection="pt>15 && abs(eta)<9.9",
2045 recoMetFromPFCs=None,
2046 jetCorLabelL3="ak4PFCHSL1FastL2L3Corrector",
2047 jetCorLabelRes="ak4PFCHSL1FastL2L3ResidualCorrector",
2048
2049 CHS=False,
2050 reapplyJEC=True,
2051 jecUncFile="",
2052 computeMETSignificance=True,
2053 fixEE2017=False,
2054 fixEE2017Params=None,
2055 extractDeepMETs=False,
2056 postfix=""):
2057
2058 runMETCorrectionsAndUncertainties = RunMETCorrectionsAndUncertainties()
2059
2060
2061 runMETCorrectionsAndUncertainties(process, metType=metType,
2062 correctionLevel=["T1"],
2063 computeUncertainties=True,
2064 produceIntermediateCorrections=False,
2065 addToPatDefaultSequence=False,
2066 jetCollectionUnskimmed=jetCollUnskimmed,
2067 electronCollection=electronColl,
2068 muonCollection=muonColl,
2069 tauCollection=tauColl,
2070 photonCollection=photonColl,
2071 pfCandCollection =pfCandColl,
2072 runOnData=isData,
2073 onMiniAOD=True,
2074 reapplyJEC=reapplyJEC,
2075 reclusterJets=reclusterJets,
2076 jetSelection=jetSelection,
2077 recoMetFromPFCs=recoMetFromPFCs,
2078 autoJetCleaning=jetCleaning,
2079 manualJetConfig=manualJetConfig,
2080 jetFlavor=jetFlavor,
2081 jetCorLabelUpToL3=jetCorLabelL3,
2082 jetCorLabelL3Res=jetCorLabelRes,
2083 jecUncertaintyFile=jecUncFile,
2084 computeMETSignificance=computeMETSignificance,
2085 CHS=CHS,
2086 postfix=postfix,
2087 fixEE2017=fixEE2017,
2088 fixEE2017Params=fixEE2017Params,
2089 extractDeepMETs=extractDeepMETs,
2090 )
2091
2092
2093 runMETCorrectionsAndUncertainties(process, metType=metType,
2094 correctionLevel=["T1","Txy"],
2095 computeUncertainties=False,
2096 produceIntermediateCorrections=True,
2097 addToPatDefaultSequence=False,
2098 jetCollectionUnskimmed=jetCollUnskimmed,
2099 electronCollection=electronColl,
2100 muonCollection=muonColl,
2101 tauCollection=tauColl,
2102 photonCollection=photonColl,
2103 pfCandCollection =pfCandColl,
2104 runOnData=isData,
2105 onMiniAOD=True,
2106 reapplyJEC=reapplyJEC,
2107 reclusterJets=reclusterJets,
2108 jetSelection=jetSelection,
2109 recoMetFromPFCs=recoMetFromPFCs,
2110 autoJetCleaning=jetCleaning,
2111 manualJetConfig=manualJetConfig,
2112 jetFlavor=jetFlavor,
2113 jetCorLabelUpToL3=jetCorLabelL3,
2114 jetCorLabelL3Res=jetCorLabelRes,
2115 jecUncertaintyFile=jecUncFile,
2116 computeMETSignificance=computeMETSignificance,
2117 CHS=CHS,
2118 postfix=postfix,
2119 fixEE2017=fixEE2017,
2120 fixEE2017Params=fixEE2017Params,
2121 extractDeepMETs=extractDeepMETs,
2122 )
2123
2124 runMETCorrectionsAndUncertainties(process, metType=metType,
2125 correctionLevel=["T1","Smear"],
2126 computeUncertainties=True,
2127 produceIntermediateCorrections=False,
2128 addToPatDefaultSequence=False,
2129 jetCollectionUnskimmed=jetCollUnskimmed,
2130 electronCollection=electronColl,
2131 muonCollection=muonColl,
2132 tauCollection=tauColl,
2133 photonCollection=photonColl,
2134 pfCandCollection =pfCandColl,
2135 runOnData=isData,
2136 onMiniAOD=True,
2137 reapplyJEC=reapplyJEC,
2138 reclusterJets=reclusterJets,
2139 jetSelection=jetSelection,
2140 recoMetFromPFCs=recoMetFromPFCs,
2141 autoJetCleaning=jetCleaning,
2142 manualJetConfig=manualJetConfig,
2143 jetFlavor=jetFlavor,
2144 jetCorLabelUpToL3=jetCorLabelL3,
2145 jetCorLabelL3Res=jetCorLabelRes,
2146 jecUncertaintyFile=jecUncFile,
2147 computeMETSignificance=computeMETSignificance,
2148 CHS=CHS,
2149 postfix=postfix,
2150 fixEE2017=fixEE2017,
2151 fixEE2017Params=fixEE2017Params,
2152 extractDeepMETs=extractDeepMETs,
2153 )