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