diff --git a/Configuration/Applications/python/ConfigBuilder.py b/Configuration/Applications/python/ConfigBuilder.py index 5fbd200704d0f..e25dd9dc66057 100644 --- a/Configuration/Applications/python/ConfigBuilder.py +++ b/Configuration/Applications/python/ConfigBuilder.py @@ -1098,7 +1098,7 @@ def define_Configs(self): self.VALIDATIONDefaultSeq='' self.ENDJOBDefaultSeq='endOfProcess' self.REPACKDefaultSeq='DigiToRawRepack' - self.PATDefaultSeq='miniAOD' + self.PATDefaultSeq='patTask' self.PATGENDefaultSeq='miniGEN' #TODO: Check based of file input self.NANODefaultSeq='nanoSequence' @@ -1118,7 +1118,6 @@ def define_Configs(self): if self._options.isMC==True: self.RAW2DIGIDefaultCFF="Configuration/StandardSequences/RawToDigi_cff" self.RECODefaultCFF="Configuration/StandardSequences/Reconstruction_cff" - self.PATDefaultCFF="Configuration/StandardSequences/PATMC_cff" self.PATGENDefaultCFF="Configuration/StandardSequences/PATGEN_cff" self.DQMOFFLINEDefaultCFF="DQMOffline/Configuration/DQMOfflineMC_cff" self.ALCADefaultCFF="Configuration/StandardSequences/AlCaRecoStreamsMC_cff" @@ -1745,12 +1744,6 @@ def prepare_RAW2DIGI(self, stepSpec = "RawToDigi"): self.scheduleSequence(_raw2digiSeq,'raw2digi_step') return - def prepare_PATFILTER(self, stepSpec = None): - self.loadAndRemember("PhysicsTools/PatAlgos/slimming/metFilterPaths_cff") - from PhysicsTools.PatAlgos.slimming.metFilterPaths_cff import allMetFilterPaths - for filt in allMetFilterPaths: - self.schedule.append(getattr(self.process,'Flag_'+filt)) - def prepare_L1HwVal(self, stepSpec = 'L1HwVal'): ''' Enrich the schedule with L1 HW validation ''' self.loadDefaultOrSpecifiedCFF(stepSpec,self.L1HwValDefaultCFF) @@ -1822,18 +1815,20 @@ def prepare_RECOBEFMIX(self, stepSpec = "reconstruction"): self.scheduleSequence(_recobefmixSeq,'reconstruction_befmix_step') return - def prepare_PAT(self, stepSpec = "miniAOD"): + def prepare_PAT(self, stepSpec = "patTask"): ''' Enrich the schedule with PAT ''' - self.prepare_PATFILTER(self) - self.loadDefaultOrSpecifiedCFF(stepSpec,self.PATDefaultCFF) - self.labelsToAssociate.append('patTask') + _,pat_sequence,pat_cff = self.loadDefaultOrSpecifiedCFF(stepSpec,self.PATDefaultCFF) + ## handle the noise filters as Flag_* path that were loaded + for existing_path,path_ in self.process.paths_().items(): + if existing_path.startswith('Flag_'): + print(f'scheduling {existing_path} as part of PAT configuration') + self.schedule.append( path_ ) + + self.labelsToAssociate.append(pat_sequence) if self._options.isData: - self._options.customisation_file_unsch.insert(0,"PhysicsTools/PatAlgos/slimming/miniAOD_tools.miniAOD_customizeAllData") + self._options.customisation_file_unsch.insert(0,f"{pat_cff}.miniAOD_customizeAllData") else: - if self._options.fast: - self._options.customisation_file_unsch.insert(0,"PhysicsTools/PatAlgos/slimming/miniAOD_tools.miniAOD_customizeAllMCFastSim") - else: - self._options.customisation_file_unsch.insert(0,"PhysicsTools/PatAlgos/slimming/miniAOD_tools.miniAOD_customizeAllMC") + self._options.customisation_file_unsch.insert(0,f"{pat_cff}.miniAOD_customizeAllMC") if self._options.hltProcess: self._customise_coms.append( f'process.patTrigger.processName = "{self._options.hltProcess}"') diff --git a/Configuration/ProcessModifiers/python/run2_miniAOD_miniAODUL_cff.py b/Configuration/ProcessModifiers/python/run2_miniAOD_miniAODUL_cff.py new file mode 100644 index 0000000000000..2830b81edf5cc --- /dev/null +++ b/Configuration/ProcessModifiers/python/run2_miniAOD_miniAODUL_cff.py @@ -0,0 +1,6 @@ +import FWCore.ParameterSet.Config as cms + +# This modifier is for common settings to run miniAOD on top of +# ultra-legacy (during LS2) Run-2 MINIAOD + +run2_miniAOD_miniAODUL = cms.Modifier() diff --git a/Configuration/ProcessModifiers/python/run3_miniAOD_miniAODpre142X_cff.py b/Configuration/ProcessModifiers/python/run3_miniAOD_miniAODpre142X_cff.py new file mode 100644 index 0000000000000..c069e482dbab0 --- /dev/null +++ b/Configuration/ProcessModifiers/python/run3_miniAOD_miniAODpre142X_cff.py @@ -0,0 +1,6 @@ +import FWCore.ParameterSet.Config as cms + +# This modifier is for common settings to run miniAOD on top of +# Run-3 MINIAOD produced prior to 14.2 release + +run3_miniAOD_miniAODpre142X = cms.Modifier() diff --git a/Configuration/PyReleaseValidation/python/relval_nano.py b/Configuration/PyReleaseValidation/python/relval_nano.py index c328a97f4cd43..4a77aa9f11379 100644 --- a/Configuration/PyReleaseValidation/python/relval_nano.py +++ b/Configuration/PyReleaseValidation/python/relval_nano.py @@ -79,23 +79,60 @@ def next(self, index: int = None) -> None: '--customise': '"Configuration/DataProcessing/Utils.addMonitoring"' }]) _HARVEST_mc = merge([_HARVEST_nano, {'--mc': ''}]) +## the validation sequence VALIDATION:@miniAODValidation will not function on M2M, because it requires AOD-bound collections TBF +## the dqm sequence DQM:@miniAODDQM will not function on M2M, because it requires AOD-bound collections TBF +#_MINI_from_MINI = {'-s': 'PAT:Configuration/StandardSequences/REMINI_cff.patAlgosToolsTask,DQM:@miniAODDQM', +# '--process': 'M2M'} +_MINI_from_MINI = {'-s': 'PAT:Configuration/StandardSequences/REMINI_cff.patAlgosToolsTask', + '--eventcontent' : 'MINIAODSIM', + '--datatier' : 'MINIAODSIM', + '--process': 'M2M'} +_MINI_from_MINI_data = merge([{'--data': '', + '--eventcontent' : 'MINIAOD', + '--datatier' : 'MINIAOD'}, + _MINI_from_MINI]) steps['HRV_NANO_mc'] = _HARVEST_mc +steps['HRV3_NANO_mc'] = merge([{'--filein':'file:step3_inDQM.root'}, + _HARVEST_mc]) steps['HRV_NANO_data'] = _HARVEST_data +steps['HRV3_NANO_data'] = merge([{'--filein':'file:step3_inDQM.root'}, + _HARVEST_data]) ################################################################ # 10.6 INPUT and workflows +steps['TTbarAOD10.6_UL16APV'] = {'INPUT': InputInfo( + location='STD', dataSet='/TTJets_SingleLeptFromT_TuneCP5_13TeV-madgraphMLM-pythia8/RunIISummer20UL16RECOAPV-106X_mcRun2_asymptotic_preVFP_v8-v2/AODSIM')} +steps['MINI_mc10.6ul16APV'] = merge([{'--procModifiers':'run2_miniAOD_UL'}, steps['REMINIAOD_mc2016UL_preVFP']]) +steps['M2M_mc10.6ul16APV'] = merge([_MINI_from_MINI, {'--procModifiers':'run2_miniAOD_miniAODUL'} ,steps['MINI_mc10.6ul16APV']]) +steps['TTbarMINIAOD10.6_UL16APVv2'] = {'INPUT': InputInfo( + location='STD', dataSet='/TTJets_SingleLeptFromT_TuneCP5_13TeV-madgraphMLM-pythia8/RunIISummer20UL16MiniAODAPVv2-106X_mcRun2_asymptotic_preVFP_v11-v2/MINIAODSIM')} +steps['NANO_mc10.6ul16APVv2'] = merge([{'--era': 'Run2_2016_HIPM,run2_nanoAOD_106Xv2', + '--conditions': 'auto:run2_mc'}, + _NANO_mc]) +steps['TTbarAOD10.6_UL16'] = {'INPUT': InputInfo( + location='STD', dataSet='/TTJets_SingleLeptFromT_TuneCP5_13TeV-madgraphMLM-pythia8/RunIISummer20UL16RECO-106X_mcRun2_asymptotic_v13-v2/AODSIM')} +steps['MINI_mc10.6ul16'] = merge([{'--procModifiers':'run2_miniAOD_UL'}, steps['REMINIAOD_mc2016UL_postVFP']]) +steps['M2M_mc10.6ul16'] = merge([_MINI_from_MINI, {'--procModifiers':'run2_miniAOD_miniAODUL'} ,steps['MINI_mc10.6ul16']]) steps['TTbarMINIAOD10.6_UL16v2'] = {'INPUT': InputInfo( location='STD', dataSet='/TTJets_SingleLeptFromT_TuneCP5_13TeV-madgraphMLM-pythia8/RunIISummer20UL16MiniAODv2-106X_mcRun2_asymptotic_v17-v2/MINIAODSIM')} steps['NANO_mc10.6ul16v2'] = merge([{'--era': 'Run2_2016,run2_nanoAOD_106Xv2', '--conditions': 'auto:run2_mc'}, _NANO_mc]) # 2017 looking Monte-Carlo: two versions in 10.6 +steps['TTbarAOD10.6_UL17'] = {'INPUT': InputInfo( + location='STD', dataSet='/TTJets_SingleLeptFromT_TuneCP5_13TeV-madgraphMLM-pythia8/RunIISummer20UL17RECO-106X_mc2017_realistic_v6-v2/AODSIM')} +steps['MINI_mc10.6ul17'] = merge([{'--procModifiers':'run2_miniAOD_UL'}, steps['REMINIAOD_mc2017UL']]) +steps['M2M_mc10.6ul17'] = merge([_MINI_from_MINI, {'--procModifiers':'run2_miniAOD_miniAODUL'} ,steps['MINI_mc10.6ul17']]) steps['TTbarMINIAOD10.6_UL17v2'] = {'INPUT': InputInfo( location='STD', dataSet='/TTJets_SingleLeptFromT_TuneCP5_13TeV-madgraphMLM-pythia8/RunIISummer20UL17MiniAODv2-106X_mc2017_realistic_v9-v2/MINIAODSIM')} steps['NANO_mc10.6ul17v2'] = merge([{'--era': 'Run2_2017,run2_nanoAOD_106Xv2', '--conditions': 'auto:phase1_2017_realistic'}, _NANO_mc]) +steps['TTbarAOD10.6_UL18'] = {'INPUT': InputInfo( + location='STD', dataSet='/TTJets_SingleLeptFromT_TuneCP5_13TeV-madgraphMLM-pythia8/RunIISummer20UL18RECO-106X_upgrade2018_realistic_v11_L1v1-v2/AODSIM')} +steps['MINI_mc10.6ul18'] = merge([{'--procModifiers':'run2_miniAOD_UL'}, steps['REMINIAOD_mc2018UL']]) +steps['M2M_mc10.6ul18'] = merge([_MINI_from_MINI, {'--procModifiers':'run2_miniAOD_miniAODUL'} ,steps['MINI_mc10.6ul18']]) steps['TTbarMINIAOD10.6_UL18v2'] = {'INPUT': InputInfo( location='STD', dataSet='/TTJets_SingleLeptFromT_TuneCP5_13TeV-madgraphMLM-pythia8/RunIISummer20UL18MiniAODv2-106X_upgrade2018_realistic_v16_L1v1-v2/MINIAODSIM')} steps['NANO_mc10.6ul18v2'] = merge([{'--era': 'Run2_2018,run2_nanoAOD_106Xv2', @@ -105,12 +142,14 @@ def next(self, index: int = None) -> None: # HIPM_UL2016_MiniAODv2 campaign is CMSSW_10_6_25 steps['MuonEG2016MINIAOD10.6v2'] = {'INPUT': InputInfo(location='STD', ls=run2_lumis, dataSet='/MuonEG/Run2016E-HIPM_UL2016_MiniAODv2-v2/MINIAOD')} +steps['M2M_data10.6ul16'] = merge([_MINI_from_MINI_data, {'--procModifiers':'run2_miniAOD_miniAODUL'}, steps['REMINIAOD_data2016UL']]) steps['NANO_data10.6ul16v2'] = merge([{'--era': 'Run2_2016_HIPM,run2_nanoAOD_106Xv2', '--conditions': 'auto:run2_data'}, _NANO_data]) # UL2017_MiniAODv2 campaign is CMSSW_10_6_20 steps['MuonEG2017MINIAOD10.6v2'] = {'INPUT': InputInfo(location='STD', ls=run2_lumis, dataSet='/MuonEG/Run2017F-UL2017_MiniAODv2-v1/MINIAOD')} +steps['M2M_data10.6ul17'] = merge([_MINI_from_MINI_data, {'--procModifiers':'run2_miniAOD_miniAODUL'}, steps['REMINIAOD_data2017UL']]) steps['NANO_data10.6ul17v2'] = merge([{'--era': 'Run2_2017,run2_nanoAOD_106Xv2', '--conditions': 'auto:run2_data'}, _NANO_data]) @@ -118,12 +157,14 @@ def next(self, index: int = None) -> None: # UL2018_MiniAODv2 campaign is CMSSW_10_6_20 steps['MuonEG2018MINIAOD10.6v2'] = {'INPUT': InputInfo(location='STD', ls=run2_lumis, dataSet='/MuonEG/Run2018D-UL2018_MiniAODv2-v1/MINIAOD')} +steps['M2M_data10.6ul18'] = merge([_MINI_from_MINI_data, {'--procModifiers':'run2_miniAOD_miniAODUL'}, steps['REMINIAOD_data2018UL']]) steps['NANO_data10.6ul18v2'] = merge([{'--era': 'Run2_2018,run2_nanoAOD_106Xv2', '--conditions': 'auto:run2_data'}, _NANO_data]) ################################################################ # Run2UL re-MINI/NANO +## below: nano steps in current release, using MINI redone with the current release, either from AOD or MINIAOD steps['NANO_mc_UL16APVreMINI'] = merge([{'--era': 'Run2_2016_HIPM', '--conditions': 'auto:run2_mc_pre_vfp'}, _NANO_mc]) @@ -171,10 +212,21 @@ def next(self, index: int = None) -> None: # 13.0 workflows steps['TTbarMINIAOD13.0'] = {'INPUT': InputInfo( location='STD', dataSet='/TTtoLNu2Q_TuneCP5_13p6TeV_powheg-pythia8/Run3Summer23MiniAODv4-130X_mcRun3_2023_realistic_v14-v2/MINIAODSIM')} - +steps['M2M_mc13.0s23'] = merge([{'--era': 'Run3', '--conditions': 'auto:phase1_2023_realistic', '--procModifier': 'run3_miniAOD_miniAODpre142X'}, + steps['M2M_mc10.6ul18']]) steps['NANO_mc13.0'] = merge([{'--era': 'Run3,run3_nanoAOD_pre142X', '--conditions': 'auto:phase1_2023_realistic'}, _NANO_mc]) - +## below: nano steps in current release, using MINI redone with the current release, either from AOD or MINIAOD +steps['NANO_mc_S23reMINI'] = merge([{'--era': 'Run3', '--conditions': 'auto:phase1_2023_realistic'}, + _NANO_mc]) +#steps['NANO_mc_S22reMINI'] = merge([{'--era': 'Run3', '--conditions': 'auto:phase1_2023_realistic'},## fig GT +# _NANO_mc]) +#steps['NANO_mc_S22EEreMINI'] = merge([{'--era': 'Run3', '--conditions': 'auto:phase1_2023_realistic'},## fig GT +# _NANO_mc]) +#steps['NANO_mc_S23reMINI'] = merge([{'--era': 'Run3_2023', '--conditions': 'auto:phase1_2023_realistic'},## fit GT +# _NANO_mc]) +#steps['NANO_mc_S23BPixreMINI'] = merge([{'--era': 'Run3_2023', '--conditions': 'auto:phase1_2023_realistic'},## fix GT +# _NANO_mc]) # 13.0 workflows -- data steps['MuonEG2023MINIAOD13.0'] = {'INPUT': InputInfo(location='STD', ls={368489: [[46, 546]]}, @@ -186,9 +238,11 @@ def next(self, index: int = None) -> None: steps['ScoutingPFMonitor_Run2023D_RAW_130X'] = {'INPUT': InputInfo( dataSet='/ScoutingPFMonitor/Run2023D-v1/RAW', label='2023D', events=100000, location='STD', ls=Run2023D)} +steps['M2M_data13.0'] = merge([_MINI_from_MINI_data, {'--era': 'Run3', '--conditions': 'auto:run3_data', '--procModifier': 'run3_miniAOD_miniAODpre142X'}]) steps['NANO_data13.0'] = merge([{'--era': 'Run3_2023,run3_nanoAOD_pre142X', '--conditions': 'auto:run3_data'}, _NANO_data]) - +steps['NANO_data_23reMINI'] = merge([{'--era': 'Run3_2023', '--conditions': 'auto:run3_data'}, + _NANO_data]) steps['NANO_data13.0_prompt'] = merge([{'-s': 'NANO:@Prompt,DQM:@nanoAODDQM', '-n': '1000'}, steps['NANO_data13.0']]) @@ -428,6 +482,7 @@ def next(self, index: int = None) -> None: ######## 2500.0xxx ######## # Run2, 10_6_X MiniAOD input (current recommendation for 2016--2018) workflows[_wfn()] = ['NANOmc106Xul16v2', ['TTbarMINIAOD10.6_UL16v2', 'NANO_mc10.6ul16v2', 'HRV_NANO_mc']] +workflows[_wfn()] = ['NANOmc106Xul16APVv2', ['TTbarMINIAOD10.6_UL16APVv2', 'NANO_mc10.6ul16APVv2', 'HRV_NANO_mc']] workflows[_wfn()] = ['NANOmc106Xul17v2', ['TTbarMINIAOD10.6_UL17v2', 'NANO_mc10.6ul17v2', 'HRV_NANO_mc']] workflows[_wfn()] = ['NANOmc106Xul18v2', ['TTbarMINIAOD10.6_UL18v2', 'NANO_mc10.6ul18v2', 'HRV_NANO_mc']] @@ -438,16 +493,27 @@ def next(self, index: int = None) -> None: # Run2, 10_6_X AOD, reMINI+reNANO _wfn.subnext() -workflows[_wfn()] = ['NANOmcUL16APVreMINI', ['TTbar_13_reminiaod2016UL_preVFP_INPUT', 'REMINIAOD_mc2016UL_preVFP', 'NANO_mc_UL16APVreMINI', 'HRV_NANO_mc']] # noqa -workflows[_wfn()] = ['NANOmcUL16reMINI', ['TTbar_13_reminiaod2016UL_postVFP_INPUT', 'REMINIAOD_mc2016UL_postVFP', 'NANO_mc_UL16reMINI', 'HRV_NANO_mc']] # noqa -workflows[_wfn()] = ['NANOmcUL17reMINI', ['TTbar_13_reminiaod2017UL_INPUT', 'REMINIAOD_mc2017UL', 'NANO_mc_UL17reMINI', 'HRV_NANO_mc']] # noqa -workflows[_wfn()] = ['NANOmcUL18reMINI', ['TTbar_13_reminiaod2018UL_INPUT', 'REMINIAOD_mc2018UL', 'NANO_mc_UL18reMINI', 'HRV_NANO_mc']] # noqa +workflows[_wfn()] = ['NANOmcUL16APVreMINI', ['TTbarAOD10.6_UL16APV', 'MINI_mc10.6ul16APV', 'NANO_mc_UL16APVreMINI', 'HRV3_NANO_mc']] +workflows[_wfn()] = ['NANOmcUL16reMINI', ['TTbarAOD10.6_UL16', 'MINI_mc10.6ul16', 'NANO_mc_UL16reMINI', 'HRV3_NANO_mc']] +workflows[_wfn()] = ['NANOmcUL17reMINI', ['TTbarAOD10.6_UL17', 'MINI_mc10.6ul17', 'NANO_mc_UL17reMINI', 'HRV3_NANO_mc']] +workflows[_wfn()] = ['NANOmcUL18reMINI', ['TTbarAOD10.6_UL18', 'MINI_mc10.6ul18', 'NANO_mc_UL18reMINI', 'HRV3_NANO_mc']] + +_wfn.subnext() +workflows[_wfn()] = ['NANOdataUL16APVreMINI', ['RunJetHT2016E_reminiaodUL', 'REMINIAOD_data2016UL_HIPM', 'NANO_data_UL16APVreMINI', 'HRV3_NANO_data']] # noqa +workflows[_wfn()] = ['NANOdataUL16reMINI', ['RunJetHT2016H_reminiaodUL', 'REMINIAOD_data2016UL', 'NANO_data_UL16reMINI', 'HRV3_NANO_data']] # noqa +workflows[_wfn()] = ['NANOdataUL17reMINI', ['RunJetHT2017F_reminiaodUL', 'REMINIAOD_data2017UL', 'NANO_data_UL17reMINI', 'HRV3_NANO_data']] # noqa +workflows[_wfn()] = ['NANOdataUL18reMINI', ['RunJetHT2018D_reminiaodUL', 'REMINIAOD_data2018UL', 'NANO_data_UL18reMINI', 'HRV3_NANO_data']] # noqa _wfn.subnext() -workflows[_wfn()] = ['NANOdataUL16APVreMINI', ['RunJetHT2016E_reminiaodUL', 'REMINIAOD_data2016UL_HIPM', 'NANO_data_UL16APVreMINI', 'HRV_NANO_data']] # noqa -workflows[_wfn()] = ['NANOdataUL16reMINI', ['RunJetHT2016H_reminiaodUL', 'REMINIAOD_data2016UL', 'NANO_data_UL16reMINI', 'HRV_NANO_data']] # noqa -workflows[_wfn()] = ['NANOdataUL17reMINI', ['RunJetHT2017F_reminiaodUL', 'REMINIAOD_data2017UL', 'NANO_data_UL17reMINI', 'HRV_NANO_data']] # noqa -workflows[_wfn()] = ['NANOdataUL18reMINI', ['RunJetHT2018D_reminiaodUL', 'REMINIAOD_data2018UL', 'NANO_data_UL18reMINI', 'HRV_NANO_data']] # noqa +workflows[_wfn()] = ['NANOmcUL16APVMini2Mini', ['TTbarMINIAOD10.6_UL16APVv2', 'M2M_mc10.6ul16APV', 'NANO_mc_UL16APVreMINI', 'HRV3_NANO_mc']] +workflows[_wfn()] = ['NANOmcUL16Mini2Mini', ['TTbarMINIAOD10.6_UL16v2', 'M2M_mc10.6ul16', 'NANO_mc_UL16reMINI', 'HRV3_NANO_mc']] +workflows[_wfn()] = ['NANOmcUL17Mini2Mini', ['TTbarMINIAOD10.6_UL17v2', 'M2M_mc10.6ul17', 'NANO_mc_UL17reMINI', 'HRV3_NANO_mc']] +workflows[_wfn()] = ['NANOmcUL18Mini2Mini', ['TTbarMINIAOD10.6_UL18v2', 'M2M_mc10.6ul18', 'NANO_mc_UL18reMINI', 'HRV3_NANO_mc']] + +_wfn.subnext() +workflows[_wfn()] = ['NANOdataUL16Mini2Mini', ['MuonEG2016MINIAOD10.6v2', 'M2M_data10.6ul16', 'NANO_data_UL16reMINI', 'HRV3_NANO_data']] +workflows[_wfn()] = ['NANOdataUL17Mini2Mini', ['MuonEG2017MINIAOD10.6v2', 'M2M_data10.6ul17', 'NANO_data_UL17reMINI', 'HRV3_NANO_data']] +workflows[_wfn()] = ['NANOdataUL18Mini2Mini', ['MuonEG2018MINIAOD10.6v2', 'M2M_data10.6ul18', 'NANO_data_UL18reMINI', 'HRV3_NANO_data']] _wfn.next(1) ######## 2500.1xxx ######## @@ -457,6 +523,12 @@ def next(self, index: int = None) -> None: _wfn.subnext() workflows[_wfn()] = ['NANOdata130Xrun3', ['MuonEG2023MINIAOD13.0', 'NANO_data13.0', 'HRV_NANO_data']] +_wfn.subnext() +workflows[_wfn()] = ['NANOmc23Mini2Mini', ['TTbarMINIAOD13.0', 'M2M_mc13.0s23', 'NANO_mc_S23reMINI', 'HRV3_NANO_mc']] + +_wfn.subnext() +workflows[_wfn()] = ['NANOdata23Mini2Mini', ['MuonEG2023MINIAOD13.0', 'M2M_data13.0', 'NANO_data_23reMINI', 'HRV3_NANO_data']] + # POG/PAG custom NANOs, MC _wfn.subnext() @@ -520,11 +592,11 @@ def next(self, index: int = None) -> None: # MINIv6+NANOv15, MC _wfn.subnext() -workflows[_wfn()] = ['NANOmc2024reMINI', ['TTbar_13p6_Summer24_AOD_140X', 'REMINIAOD_mc2024', 'NANO_mc_Summer24_reMINI', 'HRV_NANO_mc']] # noqa +workflows[_wfn()] = ['NANOmc2024reMINI', ['TTbar_13p6_Summer24_AOD_140X', 'REMINIAOD_mc2024', 'NANO_mc_Summer24_reMINI', 'HRV3_NANO_mc']] # noqa # MINIv6+NANOv15, data _wfn.subnext() -workflows[_wfn()] = ['NANOdata2024reMINI', ['JetMET1_Run2024H_AOD_140X', 'REMINIAOD_data2024', 'NANO_data_2024_reMINI', 'HRV_NANO_data']] # noqa +workflows[_wfn()] = ['NANOdata2024reMINI', ['JetMET1_Run2024H_AOD_140X', 'REMINIAOD_data2024', 'NANO_data_2024_reMINI', 'HRV3_NANO_data']] # noqa _wfn.next(3) ######## 2500.3xxx ######## diff --git a/Configuration/StandardSequences/python/PATMC_cff.py b/Configuration/StandardSequences/python/PATMC_cff.py deleted file mode 100644 index 7927523f55a75..0000000000000 --- a/Configuration/StandardSequences/python/PATMC_cff.py +++ /dev/null @@ -1,15 +0,0 @@ -import FWCore.ParameterSet.Config as cms - -from PhysicsTools.PatAlgos.producersLayer1.patCandidates_cff import * -from PhysicsTools.PatAlgos.selectionLayer1.selectedPatCandidates_cff import * -from PhysicsTools.PatAlgos.slimming.slimming_cff import * -from RecoLuminosity.LumiProducer.bunchSpacingProducer_cfi import * - -patTask = cms.Task( - patCandidatesTask, - selectedPatCandidatesTask, - slimmingTask, - bunchSpacingProducer -) - -miniAOD=cms.Sequence() diff --git a/Configuration/StandardSequences/python/PAT_cff.py b/Configuration/StandardSequences/python/PAT_cff.py index 7927523f55a75..5d0fe3f406e17 100644 --- a/Configuration/StandardSequences/python/PAT_cff.py +++ b/Configuration/StandardSequences/python/PAT_cff.py @@ -12,4 +12,8 @@ bunchSpacingProducer ) -miniAOD=cms.Sequence() +from PhysicsTools.PatAlgos.slimming.miniAOD_tools import miniAOD_customizeAllData +from PhysicsTools.PatAlgos.slimming.miniAOD_tools import miniAOD_customizeAllMC + +## include cms.Path defined from event filters +from PhysicsTools.PatAlgos.slimming.metFilterPaths_cff import * diff --git a/Configuration/StandardSequences/python/REMINI_cff.py b/Configuration/StandardSequences/python/REMINI_cff.py new file mode 100644 index 0000000000000..6f0a979dc67d9 --- /dev/null +++ b/Configuration/StandardSequences/python/REMINI_cff.py @@ -0,0 +1,7 @@ +import FWCore.ParameterSet.Config as cms + +patAlgosToolsTask = cms.Task() + +from PhysicsTools.PatAlgos.slimming.miniAODFromMiniAOD_tools import miniAODFromMiniAOD_customizeAllData as miniAOD_customizeAllData +from PhysicsTools.PatAlgos.slimming.miniAODFromMiniAOD_tools import miniAODFromMiniAOD_customizeAllMC as miniAOD_customizeAllMC + diff --git a/DQMOffline/JetMET/python/jetMETDQMOfflineSource_cff.py b/DQMOffline/JetMET/python/jetMETDQMOfflineSource_cff.py index d92b4a5e59a4f..d8fcb47ab0fd3 100644 --- a/DQMOffline/JetMET/python/jetMETDQMOfflineSource_cff.py +++ b/DQMOffline/JetMET/python/jetMETDQMOfflineSource_cff.py @@ -9,12 +9,21 @@ from RecoJets.JetProducers.QGTagger_cfi import * from RecoMET.METFilters.metFilters_cff import* -HcalStripHaloFilterDQM=HcalStripHaloFilter.clone(taggingMode = True) -CSCTightHaloFilterDQM=CSCTightHaloFilter.clone(taggingMode = True) -CSCTightHalo2015FilterDQM=CSCTightHalo2015Filter.clone(taggingMode = True) -eeBadScFilterDQM=eeBadScFilter.clone(taggingMode = True) -EcalDeadCellTriggerPrimitiveFilterDQM=EcalDeadCellTriggerPrimitiveFilter.clone(taggingMode = True) -EcalDeadCellBoundaryEnergyFilterDQM=EcalDeadCellBoundaryEnergyFilter.clone(taggingMode = True) + +## interferes with fastSim sequence that replaced these modules by an HLTBool module +## is it sufficient to have them scheduled with cms.ignore, and not need for tagging mode? +def clone_in_tagging_mode( m ): + if hasattr( m , 'taggingMode'): + return m.clone(taggingMode = True) + else: + return m.clone() + +HcalStripHaloFilterDQM = clone_in_tagging_mode( HcalStripHaloFilter ) +CSCTightHaloFilterDQM = clone_in_tagging_mode( CSCTightHaloFilter ) +CSCTightHalo2015FilterDQM = clone_in_tagging_mode( CSCTightHalo2015Filter ) +eeBadScFilterDQM = clone_in_tagging_mode( eeBadScFilter ) +EcalDeadCellTriggerPrimitiveFilterDQM = clone_in_tagging_mode( EcalDeadCellTriggerPrimitiveFilter ) +EcalDeadCellBoundaryEnergyFilterDQM = clone_in_tagging_mode( EcalDeadCellBoundaryEnergyFilter ) pileupJetIdCalculatorDQM=pileupJetIdCalculator.clone( jets = "ak4PFJets", diff --git a/DataFormats/PatCandidates/interface/Electron.h b/DataFormats/PatCandidates/interface/Electron.h index 860a470c142cf..177fa0bd7fc13 100644 --- a/DataFormats/PatCandidates/interface/Electron.h +++ b/DataFormats/PatCandidates/interface/Electron.h @@ -47,6 +47,7 @@ namespace reco { // Class definition namespace pat { class PATElectronSlimmer; + class PATElectronCandidatesRekeyer; class Electron : public Lepton { public: @@ -269,6 +270,7 @@ namespace pat { } friend class PATElectronSlimmer; + friend class PATElectronCandidatesRekeyer; protected: /// init impact parameter defaults (for use in a constructor) diff --git a/DataFormats/PatCandidates/interface/Muon.h b/DataFormats/PatCandidates/interface/Muon.h index 144985c46534e..a9054c8927350 100644 --- a/DataFormats/PatCandidates/interface/Muon.h +++ b/DataFormats/PatCandidates/interface/Muon.h @@ -47,6 +47,7 @@ namespace reco { namespace pat { class PATMuonSlimmer; + class PATMuonCandidatesRekeyer; class Muon : public Lepton { public: @@ -272,6 +273,7 @@ namespace pat { friend std::ostream& reco::operator<<(std::ostream& out, const pat::Muon& obj); friend class PATMuonSlimmer; + friend class PATMuonCandidatesRekeyer; float pfEcalEnergy() const { return pfEcalEnergy_; } void setPfEcalEnergy(float pfEcalEnergy) { pfEcalEnergy_ = pfEcalEnergy; } diff --git a/DataFormats/PatCandidates/interface/Photon.h b/DataFormats/PatCandidates/interface/Photon.h index 4f661bf68c632..4ce2d99821825 100644 --- a/DataFormats/PatCandidates/interface/Photon.h +++ b/DataFormats/PatCandidates/interface/Photon.h @@ -42,6 +42,7 @@ namespace reco { // Class definition namespace pat { class PATPhotonSlimmer; + class PATPhotonCandidatesRekeyer; class Photon : public PATObject { public: @@ -328,6 +329,7 @@ namespace pat { reco::CandidatePtr sourceCandidatePtr(size_type i) const override; friend class PATPhotonSlimmer; + friend class PATPhotonCandidatesRekeyer; protected: // ---- for content embedding ---- diff --git a/PhysicsTools/PatAlgos/plugins/PATElectronCandidatesRekeyer.cc b/PhysicsTools/PatAlgos/plugins/PATElectronCandidatesRekeyer.cc new file mode 100644 index 0000000000000..975615a429b9b --- /dev/null +++ b/PhysicsTools/PatAlgos/plugins/PATElectronCandidatesRekeyer.cc @@ -0,0 +1,75 @@ +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" +#include "FWCore/Utilities/interface/InputTag.h" +#include "DataFormats/Common/interface/View.h" + +#include "DataFormats/PatCandidates/interface/Electron.h" +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" + +#include "DataFormats/Candidate/interface/CandidateFwd.h" + +namespace pat { + class PATElectronCandidatesRekeyer : public edm::stream::EDProducer<> { + public: + explicit PATElectronCandidatesRekeyer(const edm::ParameterSet &iConfig); + ~PATElectronCandidatesRekeyer() override; + + void produce(edm::Event &, const edm::EventSetup &) override; + + private: + // configurables + edm::EDGetTokenT> src_; + edm::EDGetTokenT pcNewCandViewToken_; + edm::EDGetTokenT pcNewToken_; + }; + +} // namespace pat + +using namespace pat; + +PATElectronCandidatesRekeyer::PATElectronCandidatesRekeyer(const edm::ParameterSet &iConfig) + : + + src_(consumes>(iConfig.getParameter("src"))), + pcNewCandViewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))), + pcNewToken_( + consumes(iConfig.getParameter("packedPFCandidatesNew"))) { + produces>(); +} + +PATElectronCandidatesRekeyer::~PATElectronCandidatesRekeyer() {} + +void PATElectronCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup const &) { + edm::Handle> src; + iEvent.getByToken(src_, src); + + edm::Handle pcNewCandViewHandle; + iEvent.getByToken(pcNewCandViewToken_, pcNewCandViewHandle); + + edm::Handle pcNewHandle; + iEvent.getByToken(pcNewToken_, pcNewHandle); + + auto outPtrP = std::make_unique>(); + outPtrP->reserve(src->size()); + + for (const auto &obj : *src) { + // copy original pat object and append to vector + outPtrP->emplace_back(obj); + + std::vector keys; + for (const edm::Ref &ref : outPtrP->back().associatedPackedPFCandidates()) { + keys.push_back(ref.key()); + }; + outPtrP->back().setAssociatedPackedPFCandidates( + edm::RefProd(pcNewHandle), keys.begin(), keys.end()); + outPtrP->back().refToOrig_ = + (keys.size() == 1) ? outPtrP->back().sourceCandidatePtr(0) : reco::CandidatePtr(pcNewHandle.id()); + } + iEvent.put(std::move(outPtrP)); +} + +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(PATElectronCandidatesRekeyer); diff --git a/PhysicsTools/PatAlgos/plugins/PATJetCandidatesRekeyer.cc b/PhysicsTools/PatAlgos/plugins/PATJetCandidatesRekeyer.cc new file mode 100644 index 0000000000000..7f15584816700 --- /dev/null +++ b/PhysicsTools/PatAlgos/plugins/PATJetCandidatesRekeyer.cc @@ -0,0 +1,105 @@ +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" +#include "FWCore/Utilities/interface/InputTag.h" +#include "DataFormats/Common/interface/View.h" + +#include "DataFormats/PatCandidates/interface/Jet.h" +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" + +#include "DataFormats/Candidate/interface/CandidateFwd.h" + +namespace pat { + class PATJetCandidatesRekeyer : public edm::stream::EDProducer<> { + public: + explicit PATJetCandidatesRekeyer(const edm::ParameterSet &iConfig); + ~PATJetCandidatesRekeyer() override; + + void produce(edm::Event &, const edm::EventSetup &) override; + + private: + // configurables + edm::EDGetTokenT> src_; + edm::EDGetTokenT pcNewCandViewToken_; + edm::EDGetTokenT pcNewToken_; + // std::string subjetLabel_; + }; +} // namespace pat + +using namespace pat; + +PATJetCandidatesRekeyer::PATJetCandidatesRekeyer(const edm::ParameterSet &iConfig) + : src_(consumes>(iConfig.getParameter("src"))), + pcNewCandViewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))), + pcNewToken_( + consumes(iConfig.getParameter("packedPFCandidatesNew"))) { + produces>(); + produces>("tagInfos"); +} + +PATJetCandidatesRekeyer::~PATJetCandidatesRekeyer() {} + +void PATJetCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup const &) { + edm::Handle> src; + iEvent.getByToken(src_, src); + + edm::Handle pcNewCandViewHandle; + iEvent.getByToken(pcNewCandViewToken_, pcNewCandViewHandle); + + edm::Handle pcNewHandle; + iEvent.getByToken(pcNewToken_, pcNewHandle); + + edm::RefProd> h_tagInfosOut = + iEvent.getRefBeforePut>("tagInfos"); + auto tagInfosOut = std::make_unique>(); + + auto outPtrP = std::make_unique>(); + outPtrP->reserve(src->size()); + + // + // + // + for (const auto &jet : *src) { + for (const auto &info : jet.tagInfosFwdPtr()) { + tagInfosOut->push_back(*info); + } + } + + edm::OrphanHandle> oh_tagInfosOut = iEvent.put(std::move(tagInfosOut), "tagInfos"); + + // + // + // + unsigned int tagInfoIndex = 0; + + for (const auto &obj : *src) { + // copy original pat object and append to vector + outPtrP->emplace_back(obj); + + reco::CompositePtrCandidate::daughters old = outPtrP->back().daughterPtrVector(); + outPtrP->back().clearDaughters(); + for (const auto &dauItr : old) { + outPtrP->back().addDaughter(edm::Ptr(pcNewHandle, dauItr.key())); + } + + // Copy the tag infos + for (TagInfoFwdPtrCollection::const_iterator iinfoBegin = outPtrP->back().tagInfosFwdPtr().begin(), + iinfoEnd = outPtrP->back().tagInfosFwdPtr().end(), + iinfo = iinfoBegin; + iinfo != iinfoEnd; + ++iinfo) { + // Update the "forward" bit of the FwdPtr to point at the new collection. + // ptr to "this" info in the global list + edm::Ptr outPtr(oh_tagInfosOut, tagInfoIndex); + outPtrP->back().updateFwdTagInfoFwdPtr(iinfo - iinfoBegin, outPtr); + ++tagInfoIndex; + } + } + + iEvent.put(std::move(outPtrP)); +} + +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(PATJetCandidatesRekeyer); diff --git a/PhysicsTools/PatAlgos/plugins/PATMuonCandidatesRekeyer.cc b/PhysicsTools/PatAlgos/plugins/PATMuonCandidatesRekeyer.cc new file mode 100644 index 0000000000000..618819d397416 --- /dev/null +++ b/PhysicsTools/PatAlgos/plugins/PATMuonCandidatesRekeyer.cc @@ -0,0 +1,77 @@ +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" +#include "FWCore/Utilities/interface/InputTag.h" +#include "DataFormats/Common/interface/View.h" + +#include "DataFormats/PatCandidates/interface/Muon.h" +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" + +#include "DataFormats/Candidate/interface/CandidateFwd.h" + +namespace pat { + class PATMuonCandidatesRekeyer : public edm::stream::EDProducer<> { + public: + explicit PATMuonCandidatesRekeyer(const edm::ParameterSet &iConfig); + ~PATMuonCandidatesRekeyer() override; + + void produce(edm::Event &, const edm::EventSetup &) override; + + private: + // configurables + edm::EDGetTokenT> src_; + edm::EDGetTokenT pcNewCandViewToken_; + edm::EDGetTokenT pcNewToken_; + }; + +} // namespace pat + +using namespace pat; + +PATMuonCandidatesRekeyer::PATMuonCandidatesRekeyer(const edm::ParameterSet &iConfig) + : src_(consumes>(iConfig.getParameter("src"))), + pcNewCandViewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))), + pcNewToken_( + consumes(iConfig.getParameter("packedPFCandidatesNew"))) { + produces>(); +} + +PATMuonCandidatesRekeyer::~PATMuonCandidatesRekeyer() {} + +void PATMuonCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup const &) { + edm::Handle> src; + iEvent.getByToken(src_, src); + + edm::Handle pcNewCandViewHandle; + iEvent.getByToken(pcNewCandViewToken_, pcNewCandViewHandle); + + edm::Handle pcNewHandle; + iEvent.getByToken(pcNewToken_, pcNewHandle); + + auto outPtrP = std::make_unique>(); + outPtrP->reserve(src->size()); + + for (const auto &obj : *src) { + // copy original pat object and append to vector + outPtrP->emplace_back(obj); + + // + std::vector keys; + for (size_t ic = 0; ic < outPtrP->back().numberOfSourceCandidatePtrs(); ++ic) { + const reco::CandidatePtr &candPtr = outPtrP->back().sourceCandidatePtr(ic); + if (candPtr.isNonnull()) { + keys.push_back(candPtr.key()); + } + } + if (keys.size() == 1) { + outPtrP->back().refToOrig_ = reco::CandidatePtr(pcNewCandViewHandle, keys[0]); + } + } + + iEvent.put(std::move(outPtrP)); +} + +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(PATMuonCandidatesRekeyer); diff --git a/PhysicsTools/PatAlgos/plugins/PATObjectPuppiIsolationUpdater.cc b/PhysicsTools/PatAlgos/plugins/PATObjectPuppiIsolationUpdater.cc new file mode 100644 index 0000000000000..3358cd8bfc2ca --- /dev/null +++ b/PhysicsTools/PatAlgos/plugins/PATObjectPuppiIsolationUpdater.cc @@ -0,0 +1,119 @@ +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" +#include "FWCore/Utilities/interface/InputTag.h" +#include "DataFormats/Common/interface/View.h" + +#include "DataFormats/PatCandidates/interface/Electron.h" +#include "DataFormats/PatCandidates/interface/Photon.h" +#include "DataFormats/PatCandidates/interface/Muon.h" + +#include "DataFormats/Candidate/interface/CandidateFwd.h" + +namespace pat { + template + class PATObjectPuppiIsolationUpdater : public edm::stream::EDProducer<> { + public: + explicit PATObjectPuppiIsolationUpdater(const edm::ParameterSet &iConfig); + ~PATObjectPuppiIsolationUpdater() override; + + void produce(edm::Event &, const edm::EventSetup &) override; + + private: + // configurables + edm::EDGetTokenT> src_; + //PUPPI isolation tokens + edm::EDGetTokenT> PUPPIIsolation_charged_hadrons_; + edm::EDGetTokenT> PUPPIIsolation_neutral_hadrons_; + edm::EDGetTokenT> PUPPIIsolation_photons_; + //PUPPINoLeptons isolation tokens + edm::EDGetTokenT> PUPPINoLeptonsIsolation_charged_hadrons_; + edm::EDGetTokenT> PUPPINoLeptonsIsolation_neutral_hadrons_; + edm::EDGetTokenT> PUPPINoLeptonsIsolation_photons_; + }; +} // namespace pat + +using namespace pat; + +template +PATObjectPuppiIsolationUpdater::PATObjectPuppiIsolationUpdater(const edm::ParameterSet &iConfig) + : src_(consumes>(iConfig.getParameter("src"))) { + PUPPIIsolation_charged_hadrons_ = + consumes>(iConfig.getParameter("puppiIsolationChargedHadrons")); + PUPPIIsolation_neutral_hadrons_ = + consumes>(iConfig.getParameter("puppiIsolationNeutralHadrons")); + PUPPIIsolation_photons_ = + consumes>(iConfig.getParameter("puppiIsolationPhotons")); + if constexpr (std::is_same::value || std::is_same::value) { + PUPPINoLeptonsIsolation_charged_hadrons_ = + consumes>(iConfig.getParameter("puppiNoLeptonsIsolationChargedHadrons")); + PUPPINoLeptonsIsolation_neutral_hadrons_ = + consumes>(iConfig.getParameter("puppiNoLeptonsIsolationNeutralHadrons")); + PUPPINoLeptonsIsolation_photons_ = + consumes>(iConfig.getParameter("puppiNoLeptonsIsolationPhotons")); + } + produces>(); +} + +template +PATObjectPuppiIsolationUpdater::~PATObjectPuppiIsolationUpdater() {} + +template +void PATObjectPuppiIsolationUpdater::produce(edm::Event &iEvent, edm::EventSetup const &) { + edm::Handle> src; + iEvent.getByToken(src_, src); + + //value maps for puppi isolation + edm::Handle> PUPPIIsolation_charged_hadrons; + edm::Handle> PUPPIIsolation_neutral_hadrons; + edm::Handle> PUPPIIsolation_photons; + //value maps for puppiNoLeptons isolation + edm::Handle> PUPPINoLeptonsIsolation_charged_hadrons; + edm::Handle> PUPPINoLeptonsIsolation_neutral_hadrons; + edm::Handle> PUPPINoLeptonsIsolation_photons; + + //puppi + iEvent.getByToken(PUPPIIsolation_charged_hadrons_, PUPPIIsolation_charged_hadrons); + iEvent.getByToken(PUPPIIsolation_neutral_hadrons_, PUPPIIsolation_neutral_hadrons); + iEvent.getByToken(PUPPIIsolation_photons_, PUPPIIsolation_photons); + //puppiNoLeptons + + if constexpr (std::is_same::value || std::is_same::value) { + iEvent.getByToken(PUPPINoLeptonsIsolation_charged_hadrons_, PUPPINoLeptonsIsolation_charged_hadrons); + iEvent.getByToken(PUPPINoLeptonsIsolation_neutral_hadrons_, PUPPINoLeptonsIsolation_neutral_hadrons); + iEvent.getByToken(PUPPINoLeptonsIsolation_photons_, PUPPINoLeptonsIsolation_photons); + } + + auto outPtrP = std::make_unique>(); + outPtrP->reserve(src->size()); + + for (size_t i = 0; i < src->size(); ++i) { + // copy original pat object and append to vector + outPtrP->emplace_back((*src)[i]); + + edm::Ptr objPtr(src, i); + + outPtrP->back().setIsolationPUPPI((*PUPPIIsolation_charged_hadrons)[objPtr], + (*PUPPIIsolation_neutral_hadrons)[objPtr], + (*PUPPIIsolation_photons)[objPtr]); + + if constexpr (std::is_same::value || std::is_same::value) { + outPtrP->back().setIsolationPUPPINoLeptons((*PUPPINoLeptonsIsolation_charged_hadrons)[objPtr], + (*PUPPINoLeptonsIsolation_neutral_hadrons)[objPtr], + (*PUPPINoLeptonsIsolation_photons)[objPtr]); + } + } + iEvent.put(std::move(outPtrP)); +} + +typedef PATObjectPuppiIsolationUpdater PATElectronPuppiIsolationUpdater; +typedef PATObjectPuppiIsolationUpdater PATPhotonPuppiIsolationUpdater; +typedef PATObjectPuppiIsolationUpdater PATMuonPuppiIsolationUpdater; + +#include "FWCore/Framework/interface/MakerMacros.h" + +DEFINE_FWK_MODULE(PATElectronPuppiIsolationUpdater); +DEFINE_FWK_MODULE(PATPhotonPuppiIsolationUpdater); +DEFINE_FWK_MODULE(PATMuonPuppiIsolationUpdater); diff --git a/PhysicsTools/PatAlgos/plugins/PATPackedCandidateUpdater.cc b/PhysicsTools/PatAlgos/plugins/PATPackedCandidateUpdater.cc new file mode 100644 index 0000000000000..a81ca166b133f --- /dev/null +++ b/PhysicsTools/PatAlgos/plugins/PATPackedCandidateUpdater.cc @@ -0,0 +1,68 @@ +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" + +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" +#include "DataFormats/Common/interface/ValueMap.h" + +namespace pat { + class PATPackedCandidateUpdater : public edm::stream::EDProducer<> { + public: + explicit PATPackedCandidateUpdater(const edm::ParameterSet&); + ~PATPackedCandidateUpdater() override {} + + void produce(edm::Event&, const edm::EventSetup&) override; + + private: + edm::EDGetTokenT> candsToken_; + + bool updatePuppiWeights_; + edm::EDGetTokenT> puppiWeightToken_; + edm::EDGetTokenT> puppiWeightNoLepToken_; + }; +} // namespace pat + +using namespace pat; + +PATPackedCandidateUpdater::PATPackedCandidateUpdater(const edm::ParameterSet& iConfig) + : candsToken_(consumes>(iConfig.getParameter("src"))), + updatePuppiWeights_(iConfig.getParameter("updatePuppiWeights")), + puppiWeightToken_(consumes>(iConfig.getParameter("puppiWeight"))), + puppiWeightNoLepToken_(consumes>(iConfig.getParameter("puppiWeightNoLep"))) { + produces>(); +} + +void PATPackedCandidateUpdater::produce(edm::Event& iEvent, const edm::EventSetup&) { + edm::Handle> cands; + iEvent.getByToken(candsToken_, cands); + + edm::Handle> puppiWeight; + edm::Handle> puppiWeightNoLep; + if (updatePuppiWeights_) { + iEvent.getByToken(puppiWeightToken_, puppiWeight); + iEvent.getByToken(puppiWeightNoLepToken_, puppiWeightNoLep); + } + + auto outPtrP = std::make_unique>(); + outPtrP->reserve(cands->size()); + + for (size_t ic = 0; ic < cands->size(); ++ic) { + // copy original pat::PackedCandidate and append to vector + outPtrP->emplace_back((*cands)[ic]); + + // Retrieve puppi weights from edm::ValueMap + pat::PackedCandidateRef pkref(cands, ic); + + if (updatePuppiWeights_) { + float puppiWeightVal = (*puppiWeight)[pkref]; + float puppiWeightNoLepVal = (*puppiWeightNoLep)[pkref]; + outPtrP->back().setPuppiWeight(puppiWeightVal, puppiWeightNoLepVal); + } + } + + iEvent.put(std::move(outPtrP)); +} + +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(PATPackedCandidateUpdater); diff --git a/PhysicsTools/PatAlgos/plugins/PATPhotonCandidatesRekeyer.cc b/PhysicsTools/PatAlgos/plugins/PATPhotonCandidatesRekeyer.cc new file mode 100644 index 0000000000000..9ff9da5d8d96e --- /dev/null +++ b/PhysicsTools/PatAlgos/plugins/PATPhotonCandidatesRekeyer.cc @@ -0,0 +1,76 @@ +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" +#include "FWCore/Utilities/interface/InputTag.h" +#include "DataFormats/Common/interface/View.h" + +#include "DataFormats/PatCandidates/interface/Photon.h" +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" + +#include "DataFormats/Candidate/interface/CandidateFwd.h" + +namespace pat { + class PATPhotonCandidatesRekeyer : public edm::stream::EDProducer<> { + public: + explicit PATPhotonCandidatesRekeyer(const edm::ParameterSet &iConfig); + ~PATPhotonCandidatesRekeyer() override; + + void produce(edm::Event &, const edm::EventSetup &) override; + + private: + // configurables + edm::EDGetTokenT> src_; + edm::EDGetTokenT pcNewCandViewToken_; + edm::EDGetTokenT pcNewToken_; + }; + +} // namespace pat + +using namespace pat; + +PATPhotonCandidatesRekeyer::PATPhotonCandidatesRekeyer(const edm::ParameterSet &iConfig) + : src_(consumes>(iConfig.getParameter("src"))), + pcNewCandViewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))), + pcNewToken_( + consumes(iConfig.getParameter("packedPFCandidatesNew"))) { + produces>(); +} + +PATPhotonCandidatesRekeyer::~PATPhotonCandidatesRekeyer() {} + +void PATPhotonCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup const &) { + edm::Handle> src; + iEvent.getByToken(src_, src); + + edm::Handle pcNewCandViewHandle; + iEvent.getByToken(pcNewCandViewToken_, pcNewCandViewHandle); + + edm::Handle pcNewHandle; + iEvent.getByToken(pcNewToken_, pcNewHandle); + + auto outPtrP = std::make_unique>(); + outPtrP->reserve(src->size()); + + for (const auto &obj : *src) { + // copy original pat object and append to vector + outPtrP->emplace_back(obj); + + std::vector keys; + for (const edm::Ref &ref : outPtrP->back().associatedPackedPFCandidates()) { + keys.push_back(ref.key()); + }; + outPtrP->back().setAssociatedPackedPFCandidates( + edm::RefProd(pcNewHandle), keys.begin(), keys.end()); + if (keys.size() == 1) { + outPtrP->back().refToOrig_ = outPtrP->back().sourceCandidatePtr(0); + } else { + outPtrP->back().refToOrig_ = reco::CandidatePtr(pcNewHandle.id()); + } + } + iEvent.put(std::move(outPtrP)); +} + +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(PATPhotonCandidatesRekeyer); diff --git a/PhysicsTools/PatAlgos/plugins/PATTauCandidatesRekeyer.cc b/PhysicsTools/PatAlgos/plugins/PATTauCandidatesRekeyer.cc new file mode 100644 index 0000000000000..4e24987bf7efb --- /dev/null +++ b/PhysicsTools/PatAlgos/plugins/PATTauCandidatesRekeyer.cc @@ -0,0 +1,101 @@ +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" +#include "FWCore/Utilities/interface/InputTag.h" +#include "DataFormats/Common/interface/View.h" + +#include "DataFormats/PatCandidates/interface/Tau.h" +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" + +#include "DataFormats/Candidate/interface/CandidateFwd.h" + +namespace pat { + class PATTauCandidatesRekeyer : public edm::stream::EDProducer<> { + public: + explicit PATTauCandidatesRekeyer(const edm::ParameterSet &iConfig); + ~PATTauCandidatesRekeyer() override; + + void produce(edm::Event &, const edm::EventSetup &) override; + + private: + // configurables + edm::EDGetTokenT> src_; + edm::EDGetTokenT pcNewCandViewToken_; + edm::EDGetTokenT pcNewToken_; + }; + +} // namespace pat + +using namespace pat; + +PATTauCandidatesRekeyer::PATTauCandidatesRekeyer(const edm::ParameterSet &iConfig) + : src_(consumes>(iConfig.getParameter("src"))), + pcNewCandViewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))), + pcNewToken_( + consumes(iConfig.getParameter("packedPFCandidatesNew"))) { + produces>(); +} + +PATTauCandidatesRekeyer::~PATTauCandidatesRekeyer() {} + +void PATTauCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup const &) { + edm::Handle> src; + iEvent.getByToken(src_, src); + + edm::Handle pcNewCandViewHandle; + iEvent.getByToken(pcNewCandViewToken_, pcNewCandViewHandle); + + edm::Handle pcNewHandle; + iEvent.getByToken(pcNewToken_, pcNewHandle); + + auto outPtrP = std::make_unique>(); + outPtrP->reserve(src->size()); + + for (const auto &obj : *src) { + // copy original pat object and append to vector + outPtrP->emplace_back(obj); + + reco::CandidatePtrVector signalChHPtrs; + for (const reco::CandidatePtr &p : outPtrP->back().signalChargedHadrCands()) { + signalChHPtrs.push_back(edm::Ptr(pcNewHandle, p.key())); + } + outPtrP->back().setSignalChargedHadrCands(signalChHPtrs); + + reco::CandidatePtrVector signalNHPtrs; + for (const reco::CandidatePtr &p : outPtrP->back().signalNeutrHadrCands()) { + signalNHPtrs.push_back(edm::Ptr(pcNewHandle, p.key())); + } + outPtrP->back().setSignalNeutralHadrCands(signalNHPtrs); + + reco::CandidatePtrVector signalGammaPtrs; + for (const reco::CandidatePtr &p : outPtrP->back().signalGammaCands()) { + signalGammaPtrs.push_back(edm::Ptr(pcNewHandle, p.key())); + } + outPtrP->back().setSignalGammaCands(signalGammaPtrs); + + reco::CandidatePtrVector isolationChHPtrs; + for (const reco::CandidatePtr &p : outPtrP->back().isolationChargedHadrCands()) { + isolationChHPtrs.push_back(edm::Ptr(pcNewHandle, p.key())); + } + outPtrP->back().setIsolationChargedHadrCands(isolationChHPtrs); + + reco::CandidatePtrVector isolationNHPtrs; + + for (const reco::CandidatePtr &p : outPtrP->back().isolationNeutrHadrCands()) { + isolationNHPtrs.push_back(edm::Ptr(pcNewHandle, p.key())); + } + outPtrP->back().setIsolationNeutralHadrCands(isolationNHPtrs); + + reco::CandidatePtrVector isolationGammaPtrs; + for (const reco::CandidatePtr &p : outPtrP->back().isolationGammaCands()) { + isolationGammaPtrs.push_back(edm::Ptr(pcNewHandle, p.key())); + } + outPtrP->back().setIsolationGammaCands(isolationGammaPtrs); + } + iEvent.put(std::move(outPtrP)); +} + +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(PATTauCandidatesRekeyer); diff --git a/PhysicsTools/PatAlgos/plugins/VertexCompositeCandidateDaughtersRekeyer.cc b/PhysicsTools/PatAlgos/plugins/VertexCompositeCandidateDaughtersRekeyer.cc new file mode 100644 index 0000000000000..ae06de789e168 --- /dev/null +++ b/PhysicsTools/PatAlgos/plugins/VertexCompositeCandidateDaughtersRekeyer.cc @@ -0,0 +1,79 @@ +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" +#include "FWCore/Utilities/interface/InputTag.h" +#include "DataFormats/Common/interface/View.h" + +#include "DataFormats/Candidate/interface/VertexCompositePtrCandidate.h" +#include "DataFormats/Candidate/interface/VertexCompositeCandidate.h" +#include "DataFormats/Candidate/interface/VertexCompositeCandidateFwd.h" +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" + +#include "DataFormats/Candidate/interface/CandidateFwd.h" + +namespace pat { + class VertexCompositeCandidateDaughtersRekeyer : public edm::stream::EDProducer<> { + public: + explicit VertexCompositeCandidateDaughtersRekeyer(const edm::ParameterSet &iConfig); + ~VertexCompositeCandidateDaughtersRekeyer() override; + + void produce(edm::Event &, const edm::EventSetup &) override; + + private: + // configurables + edm::EDGetTokenT src_; + edm::EDGetTokenT pcOriToken_; + edm::EDGetTokenT pcNewToken_; + }; + +} // namespace pat + +using namespace pat; + +VertexCompositeCandidateDaughtersRekeyer::VertexCompositeCandidateDaughtersRekeyer(const edm::ParameterSet &iConfig) + : src_(consumes(iConfig.getParameter("src"))), + pcOriToken_( + consumes(iConfig.getParameter("packedPFCandidatesOri"))), + pcNewToken_( + consumes(iConfig.getParameter("packedPFCandidatesNew"))) { + produces(); +} + +VertexCompositeCandidateDaughtersRekeyer::~VertexCompositeCandidateDaughtersRekeyer() {} + +void VertexCompositeCandidateDaughtersRekeyer::produce(edm::Event &iEvent, edm::EventSetup const &) { + edm::Handle src; + iEvent.getByToken(src_, src); + + edm::Handle pcOriHandle; + iEvent.getByToken(pcOriToken_, pcOriHandle); + + edm::Handle pcNewHandle; + iEvent.getByToken(pcNewToken_, pcNewHandle); + + auto outPtrP = std::make_unique(); + outPtrP->reserve(src->size()); + + for (const auto &obj : *src) { + // copy original object and append to vector + outPtrP->emplace_back(obj); + + std::vector daughters = outPtrP->back().daughterPtrVector(); + outPtrP->back().clearDaughters(); + + for (const reco::CandidatePtr &dau : daughters) { + // + // We check if this CandidatePtr points to a candidate in the original packedPFCandidates collection + // This is needed because the CandidatePtr can point to a candidate in lostTracks collection + // + outPtrP->back().addDaughter((dau.id() == pcOriHandle.id()) ? edm::Ptr(pcNewHandle, dau.key()) + : dau); + } + } + iEvent.put(std::move(outPtrP)); +} + +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(VertexCompositeCandidateDaughtersRekeyer); diff --git a/PhysicsTools/PatAlgos/python/slimming/isolatedTracks_cfi.py b/PhysicsTools/PatAlgos/python/slimming/isolatedTracks_cfi.py index 11d9c9b6ba500..79aad38a83734 100644 --- a/PhysicsTools/PatAlgos/python/slimming/isolatedTracks_cfi.py +++ b/PhysicsTools/PatAlgos/python/slimming/isolatedTracks_cfi.py @@ -76,7 +76,5 @@ from Configuration.ProcessModifiers.pp_on_AA_cff import pp_on_AA pp_on_AA.toModify(isolatedTracks, useHighPurity = True) -def miniAOD_customizeIsolatedTracksFastSim(process): - """Switch off dE/dx hit info on fast sim, as it's not available""" - process.isolatedTracks.saveDeDxHitInfo = False - return process +from Configuration.Eras.Modifier_fastSim_cff import fastSim +fastSim.toModify(isolatedTracks, saveDeDxHitInfo = False) diff --git a/PhysicsTools/PatAlgos/python/slimming/metFilterPaths_cff.py b/PhysicsTools/PatAlgos/python/slimming/metFilterPaths_cff.py index 12a44d34a4f97..177a21b731b78 100644 --- a/PhysicsTools/PatAlgos/python/slimming/metFilterPaths_cff.py +++ b/PhysicsTools/PatAlgos/python/slimming/metFilterPaths_cff.py @@ -44,19 +44,23 @@ Flag_trkPOG_logErrorTooManyClusters = cms.Path(~logErrorTooManyClusters) #add your new path here!! -allMetFilterPaths=['HBHENoiseFilter','HBHENoiseIsoFilter','CSCTightHaloFilter','CSCTightHaloTrkMuUnvetoFilter','CSCTightHalo2015Filter','globalTightHalo2016Filter','globalSuperTightHalo2016Filter','HcalStripHaloFilter','hcalLaserEventFilter','EcalDeadCellTriggerPrimitiveFilter','EcalDeadCellBoundaryEnergyFilter','ecalBadCalibFilter','goodVertices','eeBadScFilter', - 'ecalLaserCorrFilter','trkPOGFilters','chargedHadronTrackResolutionFilter','muonBadTrackFilter', - 'BadChargedCandidateFilter','BadPFMuonFilter', 'BadPFMuonDzFilter', 'hfNoisyHitsFilter', 'BadChargedCandidateSummer16Filter','BadPFMuonSummer16Filter', - 'trkPOG_manystripclus53X','trkPOG_toomanystripclus53X','trkPOG_logErrorTooManyClusters'] +#allMetFilterPaths=['HBHENoiseFilter','HBHENoiseIsoFilter','CSCTightHaloFilter','CSCTightHaloTrkMuUnvetoFilter','CSCTightHalo2015Filter','globalTightHalo2016Filter','globalSuperTightHalo2016Filter','HcalStripHaloFilter','hcalLaserEventFilter','EcalDeadCellTriggerPrimitiveFilter','EcalDeadCellBoundaryEnergyFilter','ecalBadCalibFilter','goodVertices','eeBadScFilter', +# 'ecalLaserCorrFilter','trkPOGFilters','chargedHadronTrackResolutionFilter','muonBadTrackFilter', +# 'BadChargedCandidateFilter','BadPFMuonFilter', 'BadPFMuonDzFilter', 'hfNoisyHitsFilter', 'BadChargedCandidateSummer16Filter','BadPFMuonSummer16Filter', +# 'trkPOG_manystripclus53X','trkPOG_toomanystripclus53X','trkPOG_logErrorTooManyClusters'] - -def miniAOD_customizeMETFiltersFastSim(process): - """Replace some MET filters that don't work in FastSim with trivial bools""" - for X in 'CSCTightHaloFilter', 'CSCTightHaloTrkMuUnvetoFilter','CSCTightHalo2015Filter','globalTightHalo2016Filter','globalSuperTightHalo2016Filter','HcalStripHaloFilter': - process.globalReplace(X, cms.EDFilter("HLTBool", result=cms.bool(True))) - for X in 'manystripclus53X', 'toomanystripclus53X', 'logErrorTooManyClusters': - process.globalReplace(X, cms.EDFilter("HLTBool", result=cms.bool(False))) - return process +"""Replace some MET filters that don't work in FastSim with trivial bools""" +_fake_bool = cms.EDFilter("HLTBool", result=cms.bool(True)) +from Configuration.Eras.Modifier_fastSim_cff import fastSim +fastSim.toReplaceWith( CSCTightHaloFilter, _fake_bool.clone( result = True)) +fastSim.toReplaceWith( CSCTightHaloTrkMuUnvetoFilter, _fake_bool.clone( result = True)) +fastSim.toReplaceWith( CSCTightHalo2015Filter, _fake_bool.clone( result = True)) +fastSim.toReplaceWith( globalTightHalo2016Filter, _fake_bool.clone( result = True)) +fastSim.toReplaceWith( globalSuperTightHalo2016Filter, _fake_bool.clone( result = True)) +fastSim.toReplaceWith( HcalStripHaloFilter, _fake_bool.clone( result = True)) +fastSim.toReplaceWith( manystripclus53X, _fake_bool.clone( result = False)) +fastSim.toReplaceWith( toomanystripclus53X, _fake_bool.clone( result = False)) +fastSim.toReplaceWith( logErrorTooManyClusters, _fake_bool.clone( result = False)) from Configuration.Eras.Modifier_phase2_common_cff import phase2_common phase2_common.toReplaceWith( Flag_trkPOG_manystripclus53X, cms.Path() ) diff --git a/PhysicsTools/PatAlgos/python/slimming/miniAODFromMiniAOD_tools.py b/PhysicsTools/PatAlgos/python/slimming/miniAODFromMiniAOD_tools.py new file mode 100644 index 0000000000000..e31901239dfd4 --- /dev/null +++ b/PhysicsTools/PatAlgos/python/slimming/miniAODFromMiniAOD_tools.py @@ -0,0 +1,330 @@ +import FWCore.ParameterSet.Config as cms +from PhysicsTools.PatAlgos.tools.helpers import getPatAlgosToolsTask, addToProcessAndTask + +def miniAODFromMiniAOD_customizeCommon(process): + + task = getPatAlgosToolsTask(process) + + ########################################################################### + # Set puppi producers to use the original packedPFCandidate collection + ########################################################################### + process.packedpuppi.candName = 'packedPFCandidates::@skipCurrentProcess' + process.packedpuppiNoLep.candName = 'packedPFCandidates::@skipCurrentProcess' + + ########################################################################### + # Update packedPFCandidates with the recomputed puppi weights + ########################################################################### + addToProcessAndTask("packedPFCandidates", cms.EDProducer("PATPackedCandidateUpdater", + src = cms.InputTag("packedPFCandidates", processName=cms.InputTag.skipCurrentProcess()), + updatePuppiWeights = cms.bool(True), + puppiWeight = cms.InputTag("packedpuppi"), + puppiWeightNoLep = cms.InputTag("packedpuppiNoLep"), + ), + process, task + ) + + ########################################################################### + # Recompute Puppi Isolation for muons, electrons and photons + ########################################################################### + from RecoMuon.MuonIsolation.muonIsolationPUPPI_cff import muonIsolationMiniAODPUPPI as _muonIsolationMiniAODPUPPI + from RecoMuon.MuonIsolation.muonIsolationPUPPI_cff import muonIsolationMiniAODPUPPINoLeptons as _muonIsolationMiniAODPUPPINoLeptons + + addToProcessAndTask('muonPUPPIIsolation', _muonIsolationMiniAODPUPPI.clone( + srcToIsolate = cms.InputTag('slimmedMuons', processName=cms.InputTag.skipCurrentProcess()), + srcForIsolationCone = cms.InputTag('packedPFCandidates', processName=cms.InputTag.skipCurrentProcess()), + puppiValueMap = cms.InputTag('packedpuppi'), + ), + process, task + ) + + addToProcessAndTask('muonPUPPINoLeptonsIsolation', _muonIsolationMiniAODPUPPINoLeptons.clone( + srcToIsolate = cms.InputTag('slimmedMuons', processName=cms.InputTag.skipCurrentProcess()), + srcForIsolationCone = cms.InputTag('packedPFCandidates', processName=cms.InputTag.skipCurrentProcess()), + puppiValueMap = cms.InputTag('packedpuppiNoLep'), + ), + process, task + ) + + addToProcessAndTask('slimmedMuonsUpdatedPuppiIsolation', cms.EDProducer('PATMuonPuppiIsolationUpdater', + src = cms.InputTag('slimmedMuons', processName=cms.InputTag.skipCurrentProcess()), + puppiIsolationChargedHadrons = cms.InputTag("muonPUPPIIsolation","h+-DR040-ThresholdVeto000-ConeVeto000"), + puppiIsolationNeutralHadrons = cms.InputTag("muonPUPPIIsolation","h0-DR040-ThresholdVeto000-ConeVeto001"), + puppiIsolationPhotons = cms.InputTag("muonPUPPIIsolation","gamma-DR040-ThresholdVeto000-ConeVeto001"), + puppiNoLeptonsIsolationChargedHadrons = cms.InputTag("muonPUPPINoLeptonsIsolation","h+-DR040-ThresholdVeto000-ConeVeto000"), + puppiNoLeptonsIsolationNeutralHadrons = cms.InputTag("muonPUPPINoLeptonsIsolation","h0-DR040-ThresholdVeto000-ConeVeto001"), + puppiNoLeptonsIsolationPhotons = cms.InputTag("muonPUPPINoLeptonsIsolation","gamma-DR040-ThresholdVeto000-ConeVeto001"), + ), + process, task + ) + + from RecoEgamma.EgammaIsolationAlgos.egmPhotonIsolationPUPPI_cff import egmPhotonIsolationMiniAODPUPPI as _egmPhotonPUPPIIsolationForPhotons + from RecoEgamma.EgammaIsolationAlgos.egmElectronIsolationPUPPI_cff import egmElectronIsolationMiniAODPUPPI as _egmElectronIsolationMiniAODPUPPI + from RecoEgamma.EgammaIsolationAlgos.egmElectronIsolationPUPPI_cff import egmElectronIsolationMiniAODPUPPINoLeptons as _egmElectronIsolationMiniAODPUPPINoLeptons + + addToProcessAndTask('egmPhotonPUPPIIsolation', _egmPhotonPUPPIIsolationForPhotons.clone( + srcToIsolate = cms.InputTag('slimmedPhotons', processName=cms.InputTag.skipCurrentProcess()), + srcForIsolationCone = cms.InputTag("packedPFCandidates", processName=cms.InputTag.skipCurrentProcess()), + puppiValueMap = cms.InputTag('packedpuppi'), + ), + process, task + ) + + addToProcessAndTask('egmElectronPUPPIIsolation', _egmElectronIsolationMiniAODPUPPI.clone( + srcToIsolate = cms.InputTag('slimmedElectrons', processName=cms.InputTag.skipCurrentProcess()), + srcForIsolationCone = cms.InputTag("packedPFCandidates", processName=cms.InputTag.skipCurrentProcess()), + puppiValueMap = cms.InputTag('packedpuppi'), + ), + process, task + ) + + addToProcessAndTask('egmElectronPUPPINoLeptonsIsolation', _egmElectronIsolationMiniAODPUPPI.clone( + srcToIsolate = cms.InputTag('slimmedElectrons', processName=cms.InputTag.skipCurrentProcess()), + srcForIsolationCone = cms.InputTag("packedPFCandidates", processName=cms.InputTag.skipCurrentProcess()), + puppiValueMap = cms.InputTag('packedpuppiNoLep'), + ), + process, task + ) + + addToProcessAndTask('slimmedPhotonsUpdatedPuppiIsolation', cms.EDProducer('PATPhotonPuppiIsolationUpdater', + src = cms.InputTag('slimmedPhotons', processName=cms.InputTag.skipCurrentProcess()), + puppiIsolationChargedHadrons = cms.InputTag("egmPhotonPUPPIIsolation","h+-DR030-"), + puppiIsolationNeutralHadrons = cms.InputTag("egmPhotonPUPPIIsolation","h0-DR030-"), + puppiIsolationPhotons = cms.InputTag("egmPhotonPUPPIIsolation","gamma-DR030-"), + ), + process, task + ) + + addToProcessAndTask('slimmedElectronsUpdatedPuppiIsolation', cms.EDProducer('PATElectronPuppiIsolationUpdater', + src = cms.InputTag('slimmedElectrons', processName=cms.InputTag.skipCurrentProcess()), + puppiIsolationChargedHadrons = cms.InputTag("egmElectronPUPPIIsolation","h+-DR030-BarVeto000-EndVeto001"), + puppiIsolationNeutralHadrons = cms.InputTag("egmElectronPUPPIIsolation","h0-DR030-BarVeto000-EndVeto000"), + puppiIsolationPhotons = cms.InputTag("egmElectronPUPPIIsolation","gamma-DR030-BarVeto000-EndVeto008"), + puppiNoLeptonsIsolationChargedHadrons = cms.InputTag("egmElectronPUPPINoLeptonsIsolation","h+-DR030-BarVeto000-EndVeto001"), + puppiNoLeptonsIsolationNeutralHadrons = cms.InputTag("egmElectronPUPPINoLeptonsIsolation","h0-DR030-BarVeto000-EndVeto000"), + puppiNoLeptonsIsolationPhotons = cms.InputTag("egmElectronPUPPINoLeptonsIsolation","gamma-DR030-BarVeto000-EndVeto008"), + ), + process, task + ) + + ########################################################################### + # Rekey jet constituents + ########################################################################### + addToProcessAndTask("slimmedJets", cms.EDProducer("PATJetCandidatesRekeyer", + src = cms.InputTag("slimmedJets", processName=cms.InputTag.skipCurrentProcess()), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates",processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + addToProcessAndTask("slimmedJetsPuppiPreRekey", process.slimmedJetsPuppi.clone(), process, task) + del process.slimmedJetsPuppi + + addToProcessAndTask("slimmedJetsPuppi", cms.EDProducer("PATJetCandidatesRekeyer", + src = cms.InputTag("slimmedJetsPuppiPreRekey"), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates",processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + addToProcessAndTask("slimmedJetsAK8PreRekey", process.slimmedJetsAK8.clone(), process, task) + del process.slimmedJetsAK8 + + addToProcessAndTask("slimmedJetsAK8", cms.EDProducer("PATJetCandidatesRekeyer", + src = cms.InputTag("slimmedJetsAK8PreRekey"), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates",processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + addToProcessAndTask("selectedUpdatedPatJetsAK8PFPuppiSoftDropSubjetsSlimmedDeepFlavourPreRekey", + process.selectedUpdatedPatJetsAK8PFPuppiSoftDropSubjetsSlimmedDeepFlavour.clone(), + process, + task + ) + del process.selectedUpdatedPatJetsAK8PFPuppiSoftDropSubjetsSlimmedDeepFlavour + + addToProcessAndTask("selectedUpdatedPatJetsAK8PFPuppiSoftDropSubjetsSlimmedDeepFlavour", cms.EDProducer("PATJetCandidatesRekeyer", + src = cms.InputTag("selectedUpdatedPatJetsAK8PFPuppiSoftDropSubjetsSlimmedDeepFlavourPreRekey"), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates",processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + ########################################################################### + # Rekey tau constituents + ########################################################################### + from Configuration.ProcessModifiers.run2_miniAOD_miniAODUL_cff import run2_miniAOD_miniAODUL + from Configuration.ProcessModifiers.run3_miniAOD_miniAODpre142X_cff import run3_miniAOD_miniAODpre142X + import RecoTauTag.RecoTau.tools.runTauIdMVA as tauIdConfig + taus_to_use = 'slimmedTaus::@skipCurrentProcess' + idsToRun_for_taus = cms.PSet(idsToAdd=cms.vstring()) + run2_miniAOD_miniAODUL.toModify( + idsToRun_for_taus, idsToAdd=["deepTau2018v2p5"]) + if idsToRun_for_taus.idsToAdd: + if not hasattr(process,'tauTask'): process.tauTask = cms.Task() + taus_from_mini = taus_to_use + taus_to_use = 'slimmedTausUpdated' + tauIdEmbedder = tauIdConfig.TauIDEmbedder(process, debug=False, + originalTauName=taus_from_mini, + updatedTauName=taus_to_use, + postfix="M2M", + toKeep=idsToRun_for_taus.idsToAdd) + tauIdEmbedder.runTauID() + task.add(process.rerunMvaIsolationTaskM2M, getattr(process, taus_to_use)) + + addToProcessAndTask("slimmedTaus", cms.EDProducer("PATTauCandidatesRekeyer", + src = cms.InputTag(taus_to_use), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates",processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + boosted_taus_to_use = 'slimmedTausBoosted::@skipCurrentProcess' + idsToRun_for_boosted_taus = cms.PSet(idsToAdd=cms.vstring()) + run2_miniAOD_miniAODUL.toModify( + idsToRun_for_boosted_taus, idsToAdd=["mvaIso", "mvaIsoNewDM", "mvaIsoDR0p3", "againstEle", "boostedDeepTauRunIIv2p0"]) + run3_miniAOD_miniAODpre142X.toModify( + idsToRun_for_boosted_taus, idsToAdd=["boostedDeepTauRunIIv2p0"]) + if idsToRun_for_boosted_taus.idsToAdd: + if not hasattr(process,'tauTask'): process.tauTask = cms.Task() + boosted_taus_from_mini = boosted_taus_to_use + boosted_taus_to_use = 'slimmedTausBoostedUpdated' + tauIdEmbedder = tauIdConfig.TauIDEmbedder(process, debug=False, + originalTauName=boosted_taus_from_mini, + updatedTauName=boosted_taus_to_use, + postfix="BoostedM2M", + toKeep=idsToRun_for_boosted_taus.idsToAdd) + tauIdEmbedder.runTauID() + task.add(process.rerunMvaIsolationTaskBoostedM2M, getattr(process, boosted_taus_to_use)) + + addToProcessAndTask("slimmedTausBoosted", cms.EDProducer("PATTauCandidatesRekeyer", + src = cms.InputTag(boosted_taus_to_use), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates",processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + ########################################################################### + # Rekey candidates in electrons, photons and muons + ########################################################################### + addToProcessAndTask("slimmedElectrons", cms.EDProducer("PATElectronCandidatesRekeyer", + src = cms.InputTag("slimmedElectronsUpdatedPuppiIsolation"), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates", processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + addToProcessAndTask("slimmedLowPtElectrons", cms.EDProducer("PATElectronCandidatesRekeyer", + src = cms.InputTag("slimmedLowPtElectrons", processName=cms.InputTag.skipCurrentProcess()), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates", processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + addToProcessAndTask("slimmedPhotons", cms.EDProducer("PATPhotonCandidatesRekeyer", + src = cms.InputTag("slimmedPhotonsUpdatedPuppiIsolation"), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates", processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + + addToProcessAndTask("slimmedMuons", cms.EDProducer("PATMuonCandidatesRekeyer", + src = cms.InputTag("slimmedMuonsUpdatedPuppiIsolation"), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates", processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + addToProcessAndTask("slimmedDisplacedMuons", cms.EDProducer("PATMuonCandidatesRekeyer", + src = cms.InputTag("slimmedDisplacedMuons", processName=cms.InputTag.skipCurrentProcess()), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates", processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + ########################################################################### + # Rekey daughters of secondary vertices + ########################################################################### + addToProcessAndTask("slimmedKshortVertices", cms.EDProducer("VertexCompositeCandidateDaughtersRekeyer", + src = cms.InputTag("slimmedKshortVertices", processName=cms.InputTag.skipCurrentProcess()), + packedPFCandidatesOri = cms.InputTag("packedPFCandidates", processName=cms.InputTag.skipCurrentProcess()), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates", processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + addToProcessAndTask("slimmedLambdaVertices", cms.EDProducer("VertexCompositeCandidateDaughtersRekeyer", + src = cms.InputTag("slimmedLambdaVertices", processName=cms.InputTag.skipCurrentProcess()), + packedPFCandidatesOri = cms.InputTag("packedPFCandidates", processName=cms.InputTag.skipCurrentProcess()), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates", processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + addToProcessAndTask("slimmedSecondaryVertices", cms.EDProducer("VertexCompositeCandidateDaughtersRekeyer", + src = cms.InputTag("slimmedSecondaryVertices", processName=cms.InputTag.skipCurrentProcess()), + packedPFCandidatesOri = cms.InputTag("packedPFCandidates", processName=cms.InputTag.skipCurrentProcess()), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates", processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + + _modified_run2_task = task.copyAndExclude([getattr(process,thisone) for thisone in ['slimmedDisplacedMuons']]) + from PhysicsTools.PatAlgos.patRefitVertexProducer_cfi import patRefitVertexProducer + process.offlineSlimmedPrimaryVerticesWithBS = patRefitVertexProducer.clone( + srcVertices = "offlineSlimmedPrimaryVertices", + ) + + _modified_run2_task.add( process.offlineSlimmedPrimaryVerticesWithBS ) + run2_miniAOD_miniAODUL.toReplaceWith( + task, _modified_run2_task) + + mini_output = None + for out_name in process.outputModules_().keys(): + if out_name.startswith('MINIAOD'): + mini_output = getattr(process, out_name) + break + if mini_output: + for new_collection_to_keep in ['packedPFCandidates', + 'slimmedJets', + 'slimmedJetsPuppi', + 'slimmedJetsAK8', + 'slimmedJetsAK8PFPuppiSoftDropPacked_SubJets', + 'slimmedMETsPuppi', + 'slimmedTaus', + 'slimmedTausBoosted', + 'slimmedElectrons', + 'slimmedMuons', + 'slimmedPhotons', + 'slimmedLowPtElectrons', + 'slimmedKshortVertices', + 'slimmedLambdaVertices', + 'slimmedSecondaryVertices']: + new_collection_to_keep += '_*' if not '_' in new_collection_to_keep else '' + mini_output.outputCommands += [ + f'drop *_{new_collection_to_keep}_*', + f'keep *_{new_collection_to_keep}_{process.name_()}'] + + return process + +def miniAODFromMiniAOD_customizeData(process): + from PhysicsTools.PatAlgos.tools.puppiJetMETReclusteringFromMiniAOD_cff import puppiJetMETReclusterFromMiniAOD_Data + process = puppiJetMETReclusterFromMiniAOD_Data(process) + return process + +def miniAODFromMiniAOD_customizeMC(process): + from PhysicsTools.PatAlgos.tools.puppiJetMETReclusteringFromMiniAOD_cff import puppiJetMETReclusterFromMiniAOD_MC + process = puppiJetMETReclusterFromMiniAOD_MC(process) + return process + +def miniAODFromMiniAOD_customizeAllData(process): + process = miniAODFromMiniAOD_customizeData(process) + process = miniAODFromMiniAOD_customizeCommon(process) + return process + +def miniAODFromMiniAOD_customizeAllMC(process): + process = miniAODFromMiniAOD_customizeMC(process) + process = miniAODFromMiniAOD_customizeCommon(process) + return process diff --git a/PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py b/PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py index f2bb6cb2316ce..bd50695a3e77d 100644 --- a/PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py +++ b/PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py @@ -655,6 +655,17 @@ def miniAOD_customizeMC(process): pp_on_AA.toModify(process, removeJECsForMC) pp_on_AA.toReplaceWith(task,task.copyAndExclude([process.slimmedGenJetsFlavourInfos])) + from Configuration.Eras.Modifier_fastSim_cff import fastSim + if hasattr(process, 'patMuons'): + fastSim.toModify(process.patMuons, addTriggerMatching = False) + if hasattr(process, 'patJets'): + fastSim.toModify(process.patJets, addTagInfos = cms.bool(False) ) + if hasattr(process, 'slimmedJetsNoDeepFlavour'): + fastSim.toModify(process.slimmedJetsNoDeepFlavour, dropTagInfos = cms.string('1') ) + if hasattr(process, 'updatedPatJetsSlimmedDeepFlavour'): + fastSim.toModify(process.updatedPatJetsSlimmedDeepFlavour, addTagInfos = cms.bool(False) ) + if hasattr(process, "updatedPatJetsTransientCorrectedSlimmedDeepFlavour"): + fastSim.toModify(process.updatedPatJetsTransientCorrectedSlimmedDeepFlavour, addTagInfos = cms.bool(False) ) def miniAOD_customizeOutput(out): from PhysicsTools.PatAlgos.slimming.MicroEventContent_cff import MiniAODOverrideBranchesSplitLevel @@ -704,20 +715,3 @@ def miniAOD_customizeAllMC(process): miniAOD_customizeCommon(process) miniAOD_customizeMC(process) return process - -def miniAOD_customizeAllMCFastSim(process): - miniAOD_customizeCommon(process) - miniAOD_customizeMC(process) - from PhysicsTools.PatAlgos.slimming.metFilterPaths_cff import miniAOD_customizeMETFiltersFastSim - process = miniAOD_customizeMETFiltersFastSim(process) - from PhysicsTools.PatAlgos.slimming.isolatedTracks_cfi import miniAOD_customizeIsolatedTracksFastSim - process = miniAOD_customizeIsolatedTracksFastSim(process) - process.patMuons.addTriggerMatching = False - # Disable pixelClusterTagInfos in FastSim (no siPixelCluster available) - from Configuration.Eras.Modifier_fastSim_cff import fastSim - fastSim.toModify(process.patJets, addTagInfos = cms.bool(False) ) - fastSim.toModify(process.slimmedJetsNoDeepFlavour, dropTagInfos = cms.string('1') ) - fastSim.toModify(process.updatedPatJetsSlimmedDeepFlavour, addTagInfos = cms.bool(False) ) - fastSim.toModify(process.updatedPatJetsTransientCorrectedSlimmedDeepFlavour, addTagInfos = cms.bool(False) ) - - return process diff --git a/PhysicsTools/PatAlgos/python/tools/jetTools.py b/PhysicsTools/PatAlgos/python/tools/jetTools.py index 9ae1075dc9cba..a38c70840397a 100644 --- a/PhysicsTools/PatAlgos/python/tools/jetTools.py +++ b/PhysicsTools/PatAlgos/python/tools/jetTools.py @@ -408,7 +408,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou # Setup the PUPPI ValueMap that will consumed by the TagInfo producers. puppi_value_map = "puppi" - if pfCandidates.value() == 'packedPFCandidates': + if 'packedPFCandidates' in pfCandidates.value(): puppi_value_map = setupPuppiForPackedPF(process)[0] acceptedTagInfos = list() @@ -651,7 +651,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou # use right input tags when running with RECO PF candidates, which actually # depends of whether jets use "particleFlow" - if pfCandidates.value() == 'packedPFCandidates': + if 'packedPFCandidates' in pfCandidates.value(): vertex_associator = cms.InputTag("") else: vertex_associator = cms.InputTag("primaryVertexAssociation","original") @@ -680,7 +680,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou svUsed, flip, max_sip3dsig_for_flip = svSource, False, -1. # use right input tags when running with RECO PF candidates, which actually # depends of whether jets use "particleFlow" - if pfCandidates.value() == 'packedPFCandidates': + if 'packedPFCandidates' in pfCandidates.value(): vertex_associator = cms.InputTag("") else: vertex_associator = cms.InputTag("primaryVertexAssociation","original") @@ -710,7 +710,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou flip = False # use right input tags when running with RECO PF candidates, which actually # depends of whether jets use "particleFlow" - if pfCandidates.value() == 'packedPFCandidates': + if 'packedPFCandidates' in pfCandidates.value(): vertex_associator = cms.InputTag("") else: vertex_associator = cms.InputTag("primaryVertexAssociation","original") @@ -739,7 +739,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou flip = False # use right input tags when running with RECO PF candidates, which actually # depends of whether jets use "particleFlow" - if pfCandidates.value() == 'packedPFCandidates': + if 'packedPFCandidates' in pfCandidates.value(): puppi_value_map = setupPuppiForPackedPF(process)[0] vertex_associator = cms.InputTag("") else: @@ -786,7 +786,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou process, task) if btagInfo == 'pfDeepBoostedJetTagInfos': - if pfCandidates.value() == 'packedPFCandidates': + if 'packedPFCandidates' in pfCandidates.value(): # case 1: running over jets whose daughters are PackedCandidates (only via updateJetCollection for now) if 'updated' not in jetSource.value().lower(): raise ValueError("Invalid jet collection: %s. pfDeepBoostedJetTagInfos only supports running via updateJetCollection." % jetSource.value()) @@ -811,7 +811,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou process, task) if btagInfo == 'pfParticleNetTagInfos' or btagInfo == 'pfGlobalParticleTransformerAK8TagInfos': - if pfCandidates.value() == 'packedPFCandidates': + if 'packedPFCandidates' in pfCandidates.value(): # case 1: running over jets whose daughters are PackedCandidates (only via updateJetCollection for now) vertex_associator = "" elif pfCandidates.value() == 'particleFlow': @@ -841,7 +841,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou secondary_vertices = svSource flip_ip_sign = False sip3dSigMax = -1 - if pfCandidates.value() == 'packedPFCandidates': + if 'packedPFCandidates' in pfCandidates.value(): # case 1: running over jets whose daughters are PackedCandidates (only via updateJetCollection for now) vertex_associator = "" elif pfCandidates.value() == 'particleFlow': @@ -877,7 +877,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou svUsed, flip_ip_sign, max_sip3dsig_for_flip = cms.InputTag(btagPrefix+'inclusiveCandidateNegativeSecondaryVertices'+labelName+postfix), True, 10. else: svUsed, flip_ip_sign, max_sip3dsig_for_flip = svSource, False, -1. - if pfCandidates.value() != 'packedPFCandidates': + if 'packedPFCandidates' not in pfCandidates.value(): raise ValueError("Invalid pfCandidates collection: %s." % pfCandidates.value()) addToProcessAndTask(btagPrefix+btagInfo+labelName+postfix, pfParticleNetFromMiniAODAK4PuppiCentralTagInfos.clone( @@ -893,7 +893,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou acceptedTagInfos.append(btagInfo) elif btagInfo == 'pfParticleNetFromMiniAODAK4PuppiForwardTagInfos': # ParticleNetFromMiniAOD cannot be run on RECO inputs, so need a workaround - if pfCandidates.value() != 'packedPFCandidates': + if 'packedPFCandidates' not in pfCandidates.value(): raise ValueError("Invalid pfCandidates collection: %s." % pfCandidates.value()) addToProcessAndTask(btagPrefix+btagInfo+labelName+postfix, pfParticleNetFromMiniAODAK4PuppiForwardTagInfos.clone( @@ -911,7 +911,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou svUsed, flip_ip_sign, max_sip3dsig_for_flip = cms.InputTag(btagPrefix+'inclusiveCandidateNegativeSecondaryVertices'+labelName+postfix), True, 10. else: svUsed, flip_ip_sign, max_sip3dsig_for_flip = svSource, False, -1. - if pfCandidates.value() != 'packedPFCandidates': + if 'packedPFCandidates' not in pfCandidates.value(): raise ValueError("Invalid pfCandidates collection: %s." % pfCandidates.value()) addToProcessAndTask(btagPrefix+btagInfo+labelName+postfix, pfParticleNetFromMiniAODAK4CHSCentralTagInfos.clone( @@ -927,7 +927,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou acceptedTagInfos.append(btagInfo) elif btagInfo == 'pfParticleNetFromMiniAODAK4CHSForwardTagInfos': # ParticleNetFromMiniAOD cannot be run on RECO inputs, so need a workaround - if pfCandidates.value() != 'packedPFCandidates': + if 'packedPFCandidates' not in pfCandidates.value(): raise ValueError("Invalid pfCandidates collection: %s." % pfCandidates.value()) addToProcessAndTask(btagPrefix+btagInfo+labelName+postfix, pfParticleNetFromMiniAODAK4CHSForwardTagInfos.clone( @@ -941,7 +941,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou acceptedTagInfos.append(btagInfo) elif btagInfo == 'pfParticleNetFromMiniAODAK8TagInfos': # ParticleNetFromMiniAOD cannot be run on RECO inputs, so need a workaround - if pfCandidates.value() != 'packedPFCandidates': + if 'packedPFCandidates' not in pfCandidates.value(): raise ValueError("Invalid pfCandidates collection: %s." % pfCandidates.value()) addToProcessAndTask(btagPrefix+btagInfo+labelName+postfix, pfParticleNetFromMiniAODAK8TagInfos.clone( diff --git a/PhysicsTools/PatAlgos/python/tools/puppiJetMETReclusteringTools.py b/PhysicsTools/PatAlgos/python/tools/puppiJetMETReclusteringTools.py index fa04c124df112..71e13f349d319 100644 --- a/PhysicsTools/PatAlgos/python/tools/puppiJetMETReclusteringTools.py +++ b/PhysicsTools/PatAlgos/python/tools/puppiJetMETReclusteringTools.py @@ -8,7 +8,7 @@ def puppiAK4METReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDi task = getPatAlgosToolsTask(process) - pfLabel = "packedPFCandidates" + pfInputTag = cms.InputTag("packedPFCandidates", processName=cms.InputTag.skipCurrentProcess()) pvLabel = "offlineSlimmedPrimaryVertices" svLabel = "slimmedSecondaryVertices" muLabel = "slimmedMuons" @@ -37,7 +37,7 @@ def puppiAK4METReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDi # process.load("RecoJets.JetProducers.ak4PFJets_cfi") task.add(process.ak4PFJetsPuppi) - process.ak4PFJetsPuppi.src = pfLabel + process.ak4PFJetsPuppi.src = pfInputTag process.ak4PFJetsPuppi.srcWeights = puppiLabel from RecoJets.JetAssociationProducers.j2tParametersVX_cfi import j2tParametersVX @@ -62,7 +62,7 @@ def puppiAK4METReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDi jetSource = cms.InputTag("ak4PFJetsPuppi"), algo = "ak", rParam = 0.4, - pfCandidates = cms.InputTag(pfLabel), + pfCandidates = pfInputTag, pvSource = cms.InputTag(pvLabel), svSource = cms.InputTag(svLabel), muSource = cms.InputTag(muLabel), @@ -96,7 +96,7 @@ def puppiAK4METReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDi from PhysicsTools.PatAlgos.slimming.slimmedJets_cfi import slimmedJets addToProcessAndTask('slimmedJetsPuppiNoDeepTags', slimmedJets.clone( src = "selectedPatJetsPuppi", - packedPFCandidates = pfLabel, + packedPFCandidates = pfInputTag, dropDaughters = "0", rekeyDaughters = "0", ), @@ -108,7 +108,7 @@ def puppiAK4METReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDi jetSource = cms.InputTag("slimmedJetsPuppiNoDeepTags"), # updateJetCollection defaults to MiniAOD inputs but # here it is made explicit (as in training or MINIAOD redoing) - pfCandidates = cms.InputTag(pfLabel), + pfCandidates = pfInputTag, pvSource = cms.InputTag(pvLabel), svSource = cms.InputTag(svLabel), muSource = cms.InputTag(muLabel), @@ -131,6 +131,7 @@ def puppiAK4METReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDi runMetCorAndUncFromMiniAOD(process, isData=not(runOnMC), jetCollUnskimmed="slimmedJetsPuppi", + pfCandColl=pfInputTag, metType="Puppi", postfix="Puppi", jetFlavor="AK4PFPuppi", @@ -155,7 +156,7 @@ def puppiAK8ReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDiscr task = getPatAlgosToolsTask(process) - pfLabel = "packedPFCandidates" + pfInputTag = cms.InputTag("packedPFCandidates", processName=cms.InputTag.skipCurrentProcess()) pvLabel = "offlineSlimmedPrimaryVertices" svLabel = "slimmedSecondaryVertices" muLabel = "slimmedMuons" @@ -188,7 +189,7 @@ def puppiAK8ReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDiscr task.add(process.ak8PFJetsPuppiSoftDrop) # AK8 jet constituents for softdrop - process.ak8PFJetsPuppi.src = pfLabel + process.ak8PFJetsPuppi.src = pfInputTag process.ak8PFJetsPuppi.srcWeights = puppiLabel # AK8 jet constituents for softdrop @@ -223,7 +224,7 @@ def puppiAK8ReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDiscr jetSource = cms.InputTag("ak8PFJetsPuppi"), algo = "ak", rParam = 0.8, - pfCandidates = cms.InputTag(pfLabel), + pfCandidates = pfInputTag, pvSource = cms.InputTag(pvLabel), svSource = cms.InputTag(svLabel), muSource = cms.InputTag(muLabel), @@ -269,7 +270,7 @@ def puppiAK8ReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDiscr labelName = "AK8PFPuppiSoftDrop", jetSource = cms.InputTag("ak8PFJetsPuppiSoftDrop"), btagDiscriminators = ["None"], - pfCandidates = cms.InputTag(pfLabel), + pfCandidates = pfInputTag, pvSource = cms.InputTag(pvLabel), svSource = cms.InputTag(svLabel), muSource = cms.InputTag(muLabel), @@ -291,7 +292,7 @@ def puppiAK8ReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDiscr rParam = 0.8, # needed for subjet flavor clustering explicitJTA = True, # needed for subjet b tagging svClustering = True, # needed for subjet b tagging - pfCandidates = cms.InputTag(pfLabel), + pfCandidates = pfInputTag, pvSource = cms.InputTag(pvLabel), svSource = cms.InputTag(svLabel), muSource = cms.InputTag(muLabel), @@ -381,7 +382,7 @@ def puppiAK8ReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDiscr addToProcessAndTask("slimmedJetsAK8PFPuppiSoftDropSubjetsNoDeepTags", cms.EDProducer("PATJetSlimmer", src = cms.InputTag("selectedPatJetsAK8PFPuppiSoftDropSubjets"), - packedPFCandidates = cms.InputTag(pfLabel), + packedPFCandidates = pfInputTag, dropJetVars = cms.string("1"), dropDaughters = cms.string("0"), rekeyDaughters = cms.string("0"), @@ -402,7 +403,7 @@ def puppiAK8ReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDiscr jetSource = cms.InputTag("slimmedJetsAK8PFPuppiSoftDropSubjetsNoDeepTags"), # updateJetCollection defaults to MiniAOD inputs but # here it is made explicit (as in training or MINIAOD redoing) - pfCandidates = cms.InputTag(pfLabel), + pfCandidates = pfInputTag, pvSource = cms.InputTag(pvLabel), svSource = cms.InputTag(svLabel), muSource = cms.InputTag(muLabel), @@ -430,7 +431,7 @@ def puppiAK8ReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDiscr 'SoftDropPuppi' ), fixDaughters = cms.bool(False), - packedPFCandidates = cms.InputTag(pfLabel), + packedPFCandidates = pfInputTag, ), process, task ) @@ -455,7 +456,7 @@ def puppiAK8ReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDiscr jetSource = cms.InputTag("slimmedJetsAK8NoDeepTags"), # updateJetCollection defaults to MiniAOD inputs but # here it is made explicit (as in training or MINIAOD redoing) - pfCandidates = cms.InputTag(pfLabel), + pfCandidates = pfInputTag, pvSource = cms.InputTag(pvLabel), svSource = cms.InputTag(svLabel), muSource = cms.InputTag(muLabel),