def nanoAOD_addDeepInfoAK8(process,addDeepBTag,addDeepBoostedJet,jecPayload):
_btagDiscriminators=[]
if addDeepBTag:
print("Updating process to run DeepCSV btag to AK8 jets")
_btagDiscriminators += ['pfDeepCSVJetTags:probb','pfDeepCSVJetTags:probbb']
if addDeepBoostedJet:
print("Updating process to run DeepBoostedJet on datasets before 103X")
from RecoBTag.MXNet.pfDeepBoostedJet_cff import _pfDeepBoostedJetTagsAll as pfDeepBoostedJetTagsAll
_btagDiscriminators += pfDeepBoostedJetTagsAll
if len(_btagDiscriminators)==0: return process
print("Will recalculate the following discriminators on AK8 jets: "+", ".join(_btagDiscriminators))
updateJetCollection(
process,
jetSource = cms.InputTag('slimmedJetsAK8'),
pvSource = cms.InputTag('offlineSlimmedPrimaryVertices'),
svSource = cms.InputTag('slimmedSecondaryVertices'),
rParam = 0.8,
jetCorrections = (jecPayload.value(), cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute', 'L2L3Residual']), 'None'),
btagDiscriminators = _btagDiscriminators,
postfix='AK8WithDeepInfo',
printWarning = False
)
process.looseJetIdAK8.src = "selectedUpdatedPatJetsAK8WithDeepInfo"
process.tightJetIdAK8.src = "selectedUpdatedPatJetsAK8WithDeepInfo"
process.tightJetIdLepVetoAK8.src = "selectedUpdatedPatJetsAK8WithDeepInfo"
process.slimmedJetsAK8WithUserData.src = "selectedUpdatedPatJetsAK8WithDeepInfo"
return process
def reproduceJEC(process):
'''
For instructions and more details see:
https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookJetEnergyCorrections#CorrPatJets
https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookMiniAOD2016#Jets
https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookJetAnalysis
'''
print "=== Customisation: reproducing jet collections with latest JEC"
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
updateJetCollection(
process,
# jetSource = cms.InputTag('slimmedJets'),
jetSource = cms.InputTag('cleanedPatJets'),
labelName = 'UpdatedJEC',
jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None') # Do not forget 'L2L3Residual' on data!
)
# PUPPI jets
updateJetCollection(
process,
jetSource = cms.InputTag('slimmedJetsPuppi'),
labelName = 'UpdatedJECPuppi',
jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None') # Do not
)
# Add to customisations sequence
process.CustomisationsSequence += process.patJetCorrFactorsUpdatedJEC
process.CustomisationsSequence += process.updatedPatJetsUpdatedJEC
process.CustomisationsSequence += process.patJetCorrFactorsUpdatedJECPuppi
process.CustomisationsSequence += process.updatedPatJetsUpdatedJECPuppi
def nanoAOD_addDeepInfo(process,addDeepBTag,addDeepFlavour):
_btagDiscriminators=[]
if addDeepBTag:
print("Updating process to run DeepCSV btag")
_btagDiscriminators += ['pfDeepCSVJetTags:probb','pfDeepCSVJetTags:probbb','pfDeepCSVJetTags:probc']
if addDeepFlavour:
print("Updating process to run DeepFlavour btag")
_btagDiscriminators += ['pfDeepFlavourJetTags:probb','pfDeepFlavourJetTags:probbb','pfDeepFlavourJetTags:problepb']
if len(_btagDiscriminators)==0: return process
print("Will recalculate the following discriminators: "+", ".join(_btagDiscriminators))
updateJetCollection(
process,
jetSource = cms.InputTag('slimmedJets'),
jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute','L2L3Residual']), 'None'),
btagDiscriminators = _btagDiscriminators,
postfix = 'WithDeepInfo',
)
process.load("Configuration.StandardSequences.MagneticField_cff")
process.looseJetId.src="selectedUpdatedPatJetsWithDeepInfo"
process.tightJetId.src="selectedUpdatedPatJetsWithDeepInfo"
process.tightJetIdLepVeto.src="selectedUpdatedPatJetsWithDeepInfo"
process.bJetVars.src="selectedUpdatedPatJetsWithDeepInfo"
process.slimmedJetsWithUserData.src="selectedUpdatedPatJetsWithDeepInfo"
process.qgtagger80x.srcJets="selectedUpdatedPatJetsWithDeepInfo"
if addDeepFlavour:
process.pfDeepFlavourJetTagsWithDeepInfo.graph_path = 'RecoBTag/Combined/data/DeepFlavourV03_10X_training/constant_graph.pb'
process.pfDeepFlavourJetTagsWithDeepInfo.lp_names = ["cpf_input_batchnorm/keras_learning_phase"]
return process
def reproduceJEC(process):
print "=== Customisation: reproducing jet collections with latest JEC"
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
updateJetCollection(
process,
# jetSource = cms.InputTag('slimmedJets'),
jetSource = cms.InputTag('cleanedPatJets'),
labelName = 'UpdatedJEC',
jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None') # Do not forget 'L2L3Residual' on data!
)
# from PhysicsTools.PatAlgos.producersLayer1.jetUpdater_cff import patJetCorrFactorsUpdated
# # PF AK4CHS jets
# if not hasattr(process, "JECpayloadAK4PFchs"):
# raise Exception("Error: Could not access process.JECpayloadAK4PFchs! Please load Jet_cfi.py before calling customizations")
# process.patJetCorrFactorsReapplyJECAK4CHS = patJetCorrFactorsUpdated.clone(
# src = cms.InputTag("slimmedJets"),
# levels = ['L1FastJet', 'L2Relative', 'L3Absolute'],
# payload = process.JECpayloadAK4PFchs.payload, # Set in Jet_cfi.py
# )
# from PhysicsTools.PatAlgos.producersLayer1.jetUpdater_cff import patJetsUpdated
# process.patJetsReapplyJECAK4CHS = patJetsUpdated.clone(
# jetSource = cms.InputTag("slimmedJets"),
# jetCorrFactorsSource = cms.VInputTag(cms.InputTag("patJetCorrFactorsReapplyJECAK4CHS"))
# )
# # PUPPI jets
# updateJetCollection(
# process,
# jetSource = cms.InputTag('slimmedJetsPuppi'),
# labelName = 'UpdatedJECPuppi',
# jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None') # Do not$
# )
# if not hasattr(process, "JECpayloadAK4PFPuppi"):
# raise Exception("Error: Could not access process.JECpayloadAK4PFPuppi! Please load Jet_cfi.py before calling customizations")
# process.patJetCorrFactorsReapplyJECPuppi = patJetCorrFactorsUpdated.clone(
# src = cms.InputTag("slimmedJetsPuppi"),
# levels = ['L1FastJet', 'L2Relative', 'L3Absolute'],
# payload = process.JECpayloadAK4PFPuppi.payload, # Set in Jet_cfi.py
# )
# from PhysicsTools.PatAlgos.producersLayer1.jetUpdater_cff import patJetsUpdated
# process.patJetsReapplyJECPuppi = patJetsUpdated.clone(
# jetSource = cms.InputTag("slimmedJetsPuppi"),
# jetCorrFactorsSource = cms.VInputTag(cms.InputTag("patJetCorrFactorsReapplyJECPuppi"))
# )
#process.reapplyJEC = cms.Sequence(process.patJetCorrFactorsReapplyJECAK4CHS +
# process.patJetsReapplyJECAK4CHS +
# process.patJetCorrFactorsReapplyJECPuppi +
# process.patJetsReapplyJECPuppi)
# process.CustomisationsSequence += process.patJetCorrFactorsReapplyJECAK4CHS
# process.CustomisationsSequence += process.patJetsReapplyJECAK4CHS
# process.CustomisationsSequence += process.patJetCorrFactorsReapplyJECPuppi
# process.CustomisationsSequence += process.patJetsReapplyJECPuppi
process.CustomisationsSequence += process.patJetCorrFactorsUpdatedJEC
process.CustomisationsSequence += process.updatedPatJetsUpdatedJEC
def produceAK8JEC(process, isData):
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
JEC = ['L1FastJet','L2Relative','L3Absolute']
if isData:
JEC += ['L2L3Residual']
updateJetCollection(
process,
labelName = 'AK8PFCHS',
jetSource = cms.InputTag("slimmedJetsAK8"),
rParam = 0.8,
jetCorrections = ('AK8PFchs', cms.vstring(JEC), 'None')
)
process.AK8CustomisationsSequence += process.patJetCorrFactorsAK8PFCHS
process.AK8CustomisationsSequence += process.updatedPatJetsAK8PFCHS
return
def nanoAOD_addDeepBTagFor80X(process):
print("Updating process to run DeepCSV btag on legacy 80X datasets")
updateJetCollection(
process,
jetSource = cms.InputTag('slimmedJets'),
jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute','L2L3Residual']), 'None'),
btagDiscriminators = ['pfDeepCSVJetTags:probb','pfDeepCSVJetTags:probbb','pfDeepCSVJetTags:probc'], ## to add discriminators
btagPrefix = ''
)
process.load("Configuration.StandardSequences.MagneticField_cff")
process.looseJetId.src="selectedUpdatedPatJets"
process.tightJetId.src="selectedUpdatedPatJets"
process.tightJetIdLepVeto.src="selectedUpdatedPatJets"
process.bJetVars.src="selectedUpdatedPatJets"
process.slimmedJetsWithUserData.src="selectedUpdatedPatJets"
process.qgtagger80x.srcJets="selectedUpdatedPatJets"
patAlgosToolsTask = getPatAlgosToolsTask(process)
patAlgosToolsTask .add(process.updatedPatJets)
patAlgosToolsTask .add(process.patJetCorrFactors)
process.additionalendpath = cms.EndPath(patAlgosToolsTask)
return process
def nanoAOD_addDeepFlavourTagFor94X2016(process):
print("Updating process to run DeepCSV btag on 94X re-miniAOD of legacy 80X datasets")
updateJetCollection(
process,
jetSource = cms.InputTag('slimmedJets'),
jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute','L2L3Residual']), 'None'),
btagDiscriminators = ['pfDeepFlavourJetTags:probb','pfDeepFlavourJetTags:probbb','pfDeepFlavourJetTags:problepb'], ## to add discriminators
btagPrefix = ''
)
process.load("Configuration.StandardSequences.MagneticField_cff")
process.looseJetId.src="selectedUpdatedPatJets"
process.tightJetId.src="selectedUpdatedPatJets"
process.tightJetIdLepVeto.src="selectedUpdatedPatJets"
process.bJetVars.src="selectedUpdatedPatJets"
process.slimmedJetsWithUserData.src="selectedUpdatedPatJets"
process.qgtagger80x.srcJets="selectedUpdatedPatJets"
process.pfDeepFlavourJetTags.graph_path = 'RecoBTag/Combined/data/DeepFlavourV03_10X_training/constant_graph.pb'
process.pfDeepFlavourJetTags.lp_names = ["cpf_input_batchnorm/keras_learning_phase"]
patAlgosToolsTask = getPatAlgosToolsTask(process)
patAlgosToolsTask .add(process.updatedPatJets)
patAlgosToolsTask .add(process.patJetCorrFactors)
process.additionalendpath = cms.EndPath(patAlgosToolsTask)
return process
def makeTreeFromMiniAOD(
process,
outfile,
reportfreq=10,
dataset="",
globaltag="",
numevents=1000,
geninfo=False,
tagname="RECO",
jsonfile="",
jecfile="",
residual=False,
jerfile="",
pufile="",
doPDFs=False,
fastsim=False,
signal=False,
scenario=""
):
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
## Preamble
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_condDBv2_cff")
process.GlobalTag.globaltag = globaltag
# log output
process.load("FWCore.MessageService.MessageLogger_cfi")
process.MessageLogger.cerr.FwkReport.reportEvery = reportfreq
process.options = cms.untracked.PSet(
allowUnscheduled = cms.untracked.bool(True),
# wantSummary = cms.untracked.bool(True) # off by default
)
# files to process
import FWCore.PythonUtilities.LumiList as LumiList
process.maxEvents = cms.untracked.PSet(
input = cms.untracked.int32(numevents)
)
process.source = cms.Source("PoolSource",
fileNames = cms.untracked.vstring(dataset)
)
if len(jsonfile)>0: process.source.lumisToProcess = LumiList.LumiList(filename = jsonfile).getVLuminosityBlockRange()
# output file
process.TFileService = cms.Service("TFileService",
fileName = cms.string(outfile+".root")
)
# branches for treemaker
VectorRecoCand = cms.vstring()
VarsDouble = cms.vstring()
VarsInt = cms.vstring()
VarsBool = cms.vstring()
VectorTLorentzVector = cms.vstring()
VectorDouble = cms.vstring()
VectorString = cms.vstring()
VectorInt = cms.vstring()
VectorBool = cms.vstring()
# configure treemaker
from LeptoQuarkTreeMaker.LeptoQuarkTreeMaker.treeMaker import TreeMaker
process.LQTreeMaker2 = TreeMaker.clone(
TreeName = cms.string("SimpleTree"),
VectorRecoCand = VectorRecoCand,
VarsDouble = VarsDouble,
VarsInt = VarsInt,
VarsBool = VarsBool,
VectorTLorentzVector = VectorTLorentzVector,
VectorDouble = VectorDouble,
VectorInt = VectorInt,
VectorString = VectorString,
VectorBool = VectorBool,
)
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
## Standard producers
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
## SUSY scan info
## ----------------------------------------------------------------------------------------------
## WeightProducer
## ----------------------------------------------------------------------------------------------
if geninfo:
from LeptoQuarkTreeMaker.WeightProducer.getWeightProducer_cff import getWeightProducer
process.WeightProducer = getWeightProducer(process.source.fileNames[0],fastsim and signal)
process.WeightProducer.Lumi = cms.double(1) #default: 1 pb-1 (unit value)
process.WeightProducer.FileNamePUDataDistribution = cms.string(pufile)
VarsDouble.extend(['WeightProducer:weight(Weight)','WeightProducer:xsec(CrossSection)','WeightProducer:nevents(NumEvents)',
'WeightProducer:TrueNumInteractions','WeightProducer:PUweight(puWeight)','WeightProducer:PUSysUp(puSysUp)','WeightProducer:PUSysDown(puSysDown)'])
VarsInt.extend(['WeightProducer:NumInteractions'])
## ----------------------------------------------------------------------------------------------
## PDF weights for PDF systematics
## ----------------------------------------------------------------------------------------------
if geninfo and doPDFs:
process.PDFWeights = cms.EDProducer('PDFWeightProducer')
VectorDouble.extend(['PDFWeights:PDFweights','PDFWeights:ScaleWeights','PDFWeights:genWeight'])
VectorInt.extend(['PDFWeights:PDFids'])
## ----------------------------------------------------------------------------------------------
## GenHT for stitching together MC samples
## ----------------------------------------------------------------------------------------------
if geninfo:
process.MadHT = cms.EDProducer('GenHTProducer')
# called madHT, i.e. MadGraph, to distinguish from GenHT from GenJets
VarsDouble.extend(['MadHT:genHT(madHT)'])
## ----------------------------------------------------------------------------------------------
## PrimaryVertices
## ----------------------------------------------------------------------------------------------
process.goodVertices = cms.EDFilter("VertexSelector",
src = cms.InputTag("offlineSlimmedPrimaryVertices"),
cut = cms.string("!isFake && ndof > 4 && abs(z) < 24 && position.Rho < 2"),
filter = cms.bool(False)
)
from LeptoQuarkTreeMaker.Utils.primaryvertices_cfi import primaryvertices
process.NVtx = primaryvertices.clone(
VertexCollection = cms.InputTag('goodVertices'),
)
VarsInt.extend(['NVtx'])
# also store total number of vertices without quality checks
process.nAllVertices = primaryvertices.clone(
VertexCollection = cms.InputTag('offlineSlimmedPrimaryVertices'),
)
VarsInt.extend(['nAllVertices'])
## ----------------------------------------------------------------------------------------------
## GenParticles
## ----------------------------------------------------------------------------------------------
## JECs
## ----------------------------------------------------------------------------------------------
process.load("CondCore.DBCommon.CondDBCommon_cfi")
from CondCore.DBCommon.CondDBSetup_cfi import CondDBSetup
# default miniAOD tags
JetTag = cms.InputTag('slimmedJets')
JetAK8Tag = cms.InputTag('slimmedJetsAK8')
METTag = cms.InputTag('slimmedMETs')
if scenario=="2016ReMiniAOD03Feb": METTag = cms.InputTag('slimmedMETsMuEGClean')
# get the JECs (disabled by default)
# this requires the user to download the .db file from this twiki
# https://twiki.cern.ch/twiki/bin/viewauth/CMS/JECDataMC
if len(jecfile)>0:
#get name of JECs without any directories
JECera = jecfile.split('/')[-1]
JECPatch = cms.string('sqlite_file:'+jecfile+'.db')
if os.getenv('GC_CONF'):
JECPatch = cms.string('sqlite_file:../src/'+jecfile+'.db')
process.jec = cms.ESSource("PoolDBESSource",CondDBSetup,
connect = JECPatch,
toGet = cms.VPSet(
cms.PSet(
record = cms.string("JetCorrectionsRecord"),
tag = cms.string("JetCorrectorParametersCollection_"+JECera+"_AK4PFchs"),
label = cms.untracked.string("AK4PFchs")
),
cms.PSet(
record = cms.string("JetCorrectionsRecord"),
tag = cms.string("JetCorrectorParametersCollection_"+JECera+"_AK4PF"),
label = cms.untracked.string("AK4PF")
),
cms.PSet(
record = cms.string("JetCorrectionsRecord"),
tag = cms.string("JetCorrectorParametersCollection_"+JECera+"_AK8PFchs"),
label = cms.untracked.string("AK8PFchs")
),
)
)
process.es_prefer_jec = cms.ESPrefer("PoolDBESSource","jec")
levels = ['L1FastJet','L2Relative','L3Absolute']
if residual: levels.append('L2L3Residual')
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
updateJetCollection(
process,
jetSource = cms.InputTag('slimmedJets'),
postfix = 'UpdatedJEC',
jetCorrections = ('AK4PFchs', levels, 'None')
)
JetTag = cms.InputTag('updatedPatJetsUpdatedJEC')
# also update the corrections for AK8 jets
updateJetCollection(
process,
jetSource = cms.InputTag('slimmedJetsAK8'),
labelName = 'AK8',
postfix = 'UpdatedJEC',
jetCorrections = ('AK8PFchs', levels, 'None')
)
JetAK8Tag = cms.InputTag('updatedPatJetsAK8UpdatedJEC')
# update the MET to account for the new JECs
from PhysicsTools.PatUtils.tools.runMETCorrectionsAndUncertainties import runMetCorAndUncFromMiniAOD
runMetCorAndUncFromMiniAOD(
process,
isData=not geninfo, # controls gen met
)
process.load('RecoMET.METFilters.badGlobalMuonTaggersMiniAOD_cff')
process.badGlobalMuonTaggerMAOD.taggingMode = cms.bool(True)
process.cloneGlobalMuonTaggerMAOD.taggingMode = cms.bool(True)
from PhysicsTools.PatUtils.tools.muonRecoMitigation import muonRecoMitigation
muonRecoMitigation(
process = process,
pfCandCollection = "packedPFCandidates", #input PF Candidate Collection
runOnMiniAOD = True, #To determine if you are running on AOD or MiniAOD
selection="", #You can use a custom selection for your bad muons. Leave empty if you would like to use the bad muon recipe definition.
muonCollection="", #The muon collection name where your custom selection will be applied to. Leave empty if you would like to use the bad muon recipe definition.
cleanCollName="cleanMuonsPFCandidates", #output pf candidate collection ame
cleaningScheme="computeAllApplyClone", #Options are: "all", "computeAllApplyBad","computeAllApplyClone". Decides which (or both) bad muon collections to be used for MET cleaning coming from the bad muon recipe.
postfix="" #Use if you would like to add a post fix to your muon / pf collections
)
runMetCorAndUncFromMiniAOD(process,
isData=not geninfo,
pfCandColl="cleanMuonsPFCandidates",
recoMetFromPFCs=True,
postfix="MuClean"
)
process.mucorMET = cms.Sequence(
process.badGlobalMuonTaggerMAOD *
process.cloneGlobalMuonTaggerMAOD *
#process.badMuons * # If you are using cleaning mode "all", uncomment this line
process.cleanMuonsPFCandidates *
process.fullPatMetSequenceMuClean
)
from PhysicsTools.PatUtils.tools.corMETFromMuonAndEG import corMETFromMuonAndEG
corMETFromMuonAndEG(process,
pfCandCollection="", #not needed
electronCollection="slimmedElectronsBeforeGSFix",
photonCollection="slimmedPhotonsBeforeGSFix",
corElectronCollection="slimmedElectrons",
corPhotonCollection="slimmedPhotons",
allMETEGCorrected=True,
muCorrection=False,
eGCorrection=True,
runOnMiniAOD=True,
postfix="MuEGClean"
)
process.slimmedMETsMuEGClean = process.slimmedMETs.clone()
process.slimmedMETsMuEGClean.src = cms.InputTag("patPFMetT1MuEGClean")
process.slimmedMETsMuEGClean.rawVariation = cms.InputTag("patPFMetRawMuEGClean")
process.slimmedMETsMuEGClean.t1Uncertainties = cms.InputTag("patPFMetT1%sMuEGClean")
del process.slimmedMETsMuEGClean.caloMET
METTag = cms.InputTag('slimmedMETs','',process.name_())
else:
# pointless run of MET tool because it is barely functional
from PhysicsTools.PatUtils.tools.runMETCorrectionsAndUncertainties import runMetCorAndUncFromMiniAOD
runMetCorAndUncFromMiniAOD(
process,
isData=not geninfo, # controls gen met
)
# keep jets before any further modifications for hadtau
JetTagBeforeSmearing = JetTag
# JEC uncertainty - after JECs are updated
from LeptoQuarkTreeMaker.Utils.jetuncertainty_cfi import JetUncertaintyProducer
process.jecUnc = JetUncertaintyProducer.clone(
JetTag = JetTag,
jecUncDir = cms.int32(0)
)
_infosToAdd = ['jecUnc']
if geninfo:
# JER factors - central, up, down
from LeptoQuarkTreeMaker.Utils.smearedpatjet_cfi import SmearedPATJetProducer
process.jerFactor = SmearedPATJetProducer.clone(
src = JetTag,
variation = cms.int32(0),
store_factor = cms.bool(True)
)
process.jerFactorUp = SmearedPATJetProducer.clone(
src = JetTag,
variation = cms.int32(1),
store_factor = cms.bool(True)
)
process.jerFactorDown = SmearedPATJetProducer.clone(
src = JetTag,
variation = cms.int32(-1),
store_factor = cms.bool(True)
)
_infosToAdd.extend(['jerFactor','jerFactorUp','jerFactorDown'])
# add userfloat & update tag
from LeptoQuarkTreeMaker.LeptoQuarkTreeMaker.addJetInfo import addJetInfo
process, JetTag = addJetInfo(process, JetTag, _infosToAdd, [])
## ----------------------------------------------------------------------------------------------
## IsoTracks
## ----------------------------------------------------------------------------------------------
## MET Filters
## ----------------------------------------------------------------------------------------------
# When the miniAOD file is created, the results of several different
# MET filters are save in a TriggerResults object for the PAT process
# Look at /PhysicsTools/PatAlgos/python/slimming/metFilterPaths_cff.py
# for the available filter flags
# The decision was made to include the filter decision flags
# as individual branches in the tree
if not fastsim: # MET filters are not run for fastsim samples
from LeptoQuarkTreeMaker.Utils.filterdecisionproducer_cfi import filterDecisionProducer
process.CSCTightHaloFilter = filterDecisionProducer.clone(
trigTagArg1 = cms.string('TriggerResults'),
trigTagArg2 = cms.string(''),
trigTagArg3 = cms.string(tagname),
filterName = cms.string("Flag_CSCTightHalo2015Filter"),
)
VarsInt.extend(['CSCTightHaloFilter'])
process.globalTightHalo2016Filter = filterDecisionProducer.clone(
trigTagArg1 = cms.string('TriggerResults'),
trigTagArg2 = cms.string(''),
trigTagArg3 = cms.string(tagname),
filterName = cms.string("Flag_globalTightHalo2016Filter"),
)
VarsInt.extend(['globalTightHalo2016Filter'])
process.HBHENoiseFilter = filterDecisionProducer.clone(
trigTagArg1 = cms.string('TriggerResults'),
trigTagArg2 = cms.string(''),
trigTagArg3 = cms.string(tagname),
filterName = cms.string("Flag_HBHENoiseFilter"),
)
VarsInt.extend(['HBHENoiseFilter'])
process.HBHEIsoNoiseFilter = filterDecisionProducer.clone(
trigTagArg1 = cms.string('TriggerResults'),
trigTagArg2 = cms.string(''),
trigTagArg3 = cms.string(tagname),
filterName = cms.string("Flag_HBHENoiseIsoFilter"),
)
VarsInt.extend(['HBHEIsoNoiseFilter'])
process.EcalDeadCellTriggerPrimitiveFilter = filterDecisionProducer.clone(
trigTagArg1 = cms.string('TriggerResults'),
trigTagArg2 = cms.string(''),
trigTagArg3 = cms.string(tagname),
filterName = cms.string("Flag_EcalDeadCellTriggerPrimitiveFilter"),
)
VarsInt.extend(['EcalDeadCellTriggerPrimitiveFilter'])
process.eeBadScFilter = filterDecisionProducer.clone(
trigTagArg1 = cms.string('TriggerResults'),
trigTagArg2 = cms.string(''),
trigTagArg3 = cms.string(tagname),
filterName = cms.string("Flag_eeBadScFilter"),
)
VarsInt.extend(['eeBadScFilter'])
# some filters need to be rerun
process.load('RecoMET.METFilters.BadChargedCandidateFilter_cfi')
process.BadChargedCandidateFilter.muons = cms.InputTag("slimmedMuons")
process.BadChargedCandidateFilter.PFCandidates = cms.InputTag("packedPFCandidates")
process.BadChargedCandidateFilter.taggingMode = True
VarsBool.extend(['BadChargedCandidateFilter'])
process.load('RecoMET.METFilters.BadPFMuonFilter_cfi')
process.BadPFMuonFilter.muons = cms.InputTag("slimmedMuons")
process.BadPFMuonFilter.PFCandidates = cms.InputTag("packedPFCandidates")
process.BadPFMuonFilter.taggingMode = True
VarsBool.extend(['BadPFMuonFilter'])
from EgammaAnalysis.ElectronTools.regressionWeights_cfi import regressionWeights
process = regressionWeights(process)
'''
process.RandomNumberGeneratorService = cms.Service("RandomNumberGeneratorService",
calibratedPatElectrons = cms.PSet( initialSeed = cms.untracked.uint32(8675389),
engineName = cms.untracked.string('TRandom3'),
),
calibratedPatPhotons = cms.PSet( initialSeed = cms.untracked.uint32(8675389),
engineName = cms.untracked.string('TRandom3'),
),
)
'''
process.load('Configuration.StandardSequences.Services_cff')
process.RandomNumberGeneratorService = cms.Service("RandomNumberGeneratorService",
calibratedPatElectrons = cms.PSet(
initialSeed = cms.untracked.uint32(81),
engineName = cms.untracked.string('TRandom3'),
),
calibratedPatPhotons = cms.PSet(
initialSeed = cms.untracked.uint32(81),
engineName = cms.untracked.string('TRandom3'),
),
)
process.load('EgammaAnalysis.ElectronTools.regressionApplication_cff')
process.load('EgammaAnalysis.ElectronTools.calibratedPatElectronsRun2_cfi')
process.calibratedPatElectrons.isMC = cms.bool(False)
process.selectedElectrons = cms.EDFilter(
"PATElectronSelector",
src = cms.InputTag("slimmedElectrons"),
cut = cms.string("pt > 5 && abs(eta)<2.5")
)
process.calibratedPatElectrons.electrons = cms.InputTag('selectedElectrons')
process.calibratedPatElectrons.isMC = cms.bool(False)
#process.EGMRegression =cms.Path(process.regressionApplication)
# process.EGMSmearerElectrons = cms.Path(process.calibratedPatElectrons)
# process.EGMSmearerElectrons.isMC = cms.bool(False)
#process.schedule = cms.Schedule(process.EGMRegression,process.EGMSmearerElectrons,process.analysis)
'''
process.load('Configuration.StandardSequences.Services_cff')
process.RandomNumberGeneratorService = cms.Service("RandomNumberGeneratorService",
calibratedPatElectrons = cms.PSet(
initialSeed = cms.untracked.uint32(81),
engineName = cms.untracked.string('TRandom3'),
),
calibratedPatPhotons = cms.PSet(
initialSeed = cms.untracked.uint32(81),
engineName = cms.untracked.string('TRandom3'),
),
)
process.load('EgammaAnalysis.ElectronTools.calibratedElectronsRun2_cfi')
correctionType = "Moriond2017_JEC "
calibratedPatElectrons = cms.EDProducer("CalibratedPatElectronProducerRun2",
# input collections
electrons = cms.InputTag('slimmedElectrons'),
gbrForestName = cms.string("gedelectron_p4combination_25ns"),
# data or MC corrections
# if isMC is false, data corrections are applied
isMC = cms.bool(True),
# set to True to get special "fake" smearing for synchronization. Use JUST in case of synchronization
isSynchronization = cms.bool(True),
correctionFile = cms.string("Moriond2017_JEC ")
)
'''
#process.Baseline += process.calibratedPatElectrons
from PhysicsTools.SelectorUtils.tools.vid_id_tools import *
switchOnVIDElectronIdProducer(process, DataFormat.MiniAOD)
my_id_modules = []
my_id_modules.append('RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Spring15_25ns_V1_cff')
my_id_modules.append('RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV60_cff')
my_id_modules.append('RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV70_cff')
my_id_modules.append('RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_25ns_nonTrig_V1_cff')
for idmod in my_id_modules:
setupAllVIDIdsInModule(process,idmod,setupVIDElectronSelection)
process.egmGsfElectronIDs.physicsObjectSrc = cms.InputTag('calibratedPatElectrons')
process.electronMVAValueMapProducer.srcMiniAOD = cms.InputTag('calibratedPatElectrons')
process.heepIDVarValueMaps.elesMiniAOD = cms.InputTag('calibratedPatElectrons')
process.electronRegressionValueMapProducer.srcMiniAOD = cms.InputTag('calibratedPatElectrons')
from LeptoQuarkTreeMaker.Utils.HEEPProducer_cfi import HEEPProducer
process.HEEPProducer = HEEPProducer.clone(
eletag = cms.InputTag('calibratedPatElectrons')
)
#process.Baseline += process.HEEPProducer
VectorDouble.extend(['HEEPProducer:trackiso(Electron_trackiso)'])
#VectorDouble.extend(['HEEPProducer:Eta(Electron_Eta)'])
VectorDouble.extend(['HEEPProducer:Et(Electron_Et)'])
VectorDouble.extend(['HEEPProducer:DeltaEtain(Electron_DeltaEtain)'])
VectorDouble.extend(['HEEPProducer:DeltaPhiin(Electron_DeltaPhiin)'])
VectorDouble.extend(['HEEPProducer:HbE(Electron_HOverE)'])
#VectorDouble.extend(['HEEPProducer:SiEtaiEta(Electron_SiEtaiEta)'])
VectorDouble.extend(['HEEPProducer:Ecaliso(Electron_Ecaliso)'])
VectorDouble.extend(['HEEPProducer:HD1iso(Electron_HD1iso)'])
#VectorDouble.extend(['HEEPProducer:HD2iso(Electron_HD2iso)'])
VectorBool.extend(['HEEPProducer:ecalDriven(Electron_ecalDriven)'])
#VectorDouble.extend(['HEEPProducer:e25max(Electron_e25max)'])
#VectorDouble.extend(['HEEPProducer:e55(Electron_e55)'])
VectorDouble.extend(['HEEPProducer:e25bye55(Electron_e25bye55)'])
VectorDouble.extend(['HEEPProducer:Fullsce25bye55(Electron_Fullsce25bye55)'])
VectorDouble.extend(['HEEPProducer:Fulle15bye55(Electron_Fulle15bye55)'])
VectorDouble.extend(['HEEPProducer:scEnergy(Electron_scEnergy)'])
VectorDouble.extend(['HEEPProducer:DeltaEtaSeed(Electron_DeltaEtaSeed)'])
VectorDouble.extend(['HEEPProducer:rho(rho)'])
VectorInt.extend(['HEEPProducer:Charge(Electron_Charge)'])
#VectorDouble.extend(['HEEPProducer:ePt(Electron_Pt)'])
#VectorDouble.extend(['HEEPProducer:e15(Electron_e15)'])
VectorDouble.extend(['HEEPProducer:ecalEnergy(Electron_ecalEnergy)'])
VectorDouble.extend(['HEEPProducer:full55SiEtaiEta(Electron_full55SiEtaiEta)'])
#VectorDouble.extend(['HEEPProducer:sce25max(Electron_sce25max)'])
#VectorDouble.extend(['HEEPProducer:sce55(Electron_sce55)'])
VectorDouble.extend(['HEEPProducer:sce25bye55(Electron_sce25bye55)'])
VectorDouble.extend(['HEEPProducer:e15bye55(Electron_e15bye55)'])
#VectorDouble.extend(['HEEPProducer:DeltaEtaSeedscandTrack(Electron_DeltaEtaSeedscandTrack)'])
VectorDouble.extend(['HEEPProducer:Phi(Electron_Phi)'])
VectorDouble.extend(['HEEPProducer:eEnergy(Electron_Energy)'])
VectorDouble.extend(['HEEPProducer:dxy(dxy)'])
VectorInt.extend(['HEEPProducer:losthits(Electron_losthits)'])
VectorDouble.extend(['HEEPProducer:ePz(Electron_Pz)'])
#VectorDouble.extend(['HEEPProducer:eTheta(Electron_Theta)'])
VectorDouble.extend(['HEEPProducer:ePx(Electron_Px)'])
VectorDouble.extend(['HEEPProducer:ePy(Electron_Py)'])
#VectorDouble.extend(['HEEPProducer:normalizedChi2(Electron_normalizedChi2)'])
VectorInt.extend(['HEEPProducer:PDGID(PDGID)'])
VectorInt.extend(['HEEPProducer:gencharge(gencharge)'])
VectorDouble.extend(['HEEPProducer:genPt(genPt)'])
VectorDouble.extend(['HEEPProducer:genEta(genEta)'])
VectorDouble.extend(['HEEPProducer:genPhi(genPhi)'])
VectorDouble.extend(['HEEPProducer:genEnergy(genEnergy)'])
VectorInt.extend(['HEEPProducer:motherPDGID(motherPDGID)'])
VectorInt.extend(['HEEPProducer:elstatus(elstatus)'])
VectorDouble.extend(['HEEPProducer:PtHEEP(Electron_PtHEEP)'])
#VectorDouble.extend(['HEEPProducer:scEtaa(Electron_scEtaa)'])
VectorDouble.extend(['HEEPProducer:scEta(Electron_scEta)'])
VectorDouble.extend(['HEEPProducer:heep70TrkIso(Electron_heep70TrkIso)'])
VectorBool.extend(['HEEPProducer:passEMHD1iso(Electron_passEMHD1iso)'])
VectorBool.extend(['HEEPProducer:passShowerShape(Electron_passShowerShape)'])
VectorBool.extend(['HEEPProducer:passDeltaEta(Electron_passDeltaEta)'])
VectorBool.extend(['HEEPProducer:passDeltaPhi(Electron_passDeltaPhi)'])
VectorBool.extend(['HEEPProducer:passEMHD1iso(Electron_passEMHD1iso)'])
VectorBool.extend(['HEEPProducer:passHoverE(Electron_passHoverE)'])
VectorBool.extend(['HEEPProducer:passDXY(Electron_passDXY)'])
VectorBool.extend(['HEEPProducer:passMissingHits(Electron_passMissingHits)'])
VectorBool.extend(['HEEPProducer:passEcaldriven(Electron_passEcaldriven)'])
VectorBool.extend(['HEEPProducer:passN1TrkIso(Electron_passN1TrkIso)'])
VectorDouble.extend(['HEEPProducer:worzsystempt(worzsystempt)'])
## Muons
## ----------------------------------------------------------------------------------------------
from LeptoQuarkTreeMaker.Utils.MuonProducer_cfi import MuonProducer
process.MuonProducer = MuonProducer.clone(
muontag = cms.InputTag('slimmedMuons')
)
#process.Baseline += process.MuonProducer
#VectorBool.extend(['MuonProducer:MuonisTightMuon(MuonisTightMuon)'])
#VectorBool.extend(['MuonProducer:MuonisHighPtMuon(MuonisHighPtMuon)'])
VectorDouble.extend(['MuonProducer:MuonEta(MuonEta)'])
VectorDouble.extend(['MuonProducer:MuonPhi(MuonPhi)'])
VectorDouble.extend(['MuonProducer:MuonPt(MuonPt)'])
VectorDouble.extend(['MuonProducer:MuonEnergy(MuonEnergy)'])
#VectorDouble.extend(['MuonProducer:MuonPtError(MuonPtError)'])
#VectorDouble.extend(['MuonProducer:MuonGlobalChi2(MuonGlobalChi2)'])
#VectorDouble.extend(['MuonProducer:MuonTrkPtError(MuonTrkPtError)'])
#VectorInt.extend(['MuonProducer:MuonIsPF(MuonIsPF)'])
VectorInt.extend(['MuonProducer:MuonCharge(MuonCharge)'])
#VectorInt.extend(['MuonProducer:MuonGlobalTrkValidHits(MuonGlobalTrkValidHits)'])
#VectorInt.extend(['MuonProducer:MuonTrkPixelHits(MuonTrkPixelHits)'])
#VectorInt.extend(['MuonProducer:MuonStationMatches(MuonStationMatches)'])
#VectorDouble.extend(['MuonProducer:MuonPFIsoR04Photon(MuonPFIsoR04Photon)'])
#VectorDouble.extend(['MuonProducer:MuonPFIsoR04NeutralHadron(MuonPFIsoR04NeutralHadron)'])
#VectorDouble.extend(['MuonProducer:MuonPFIsoR04PU(MuonPFIsoR04PU)'])
#VectorDouble.extend(['MuonProducer:MuonTrackerIsoSumPT(MuonTrackerIsoSumPT)'])
#VectorDouble.extend(['MuonProducer:MuonPFIsoR04ChargedHadron(MuonPFIsoR04ChargedHadron)'])
VectorInt.extend(['MuonProducer:MuonPassID(MuonPassID)'])
VectorInt.extend(['MuonProducer:MuonIsGlobal(MuonIsGlobal)'])
#VectorInt.extend(['MuonProducer:MuonTrackLayersWithMeasurement(MuonTrackLayersWithMeasurement)'])
#VectorDouble.extend(['MuonProducer:CocktailEta(CocktailPtError)'])
#VectorDouble.extend(['MuonProducer:CocktailPt(CocktailPt)'])
#VectorDouble.extend(['MuonProducer:MuonBestTrackVtxDistXY(MuonBestTrackVtxDistXY)'])
#VectorDouble.extend(['MuonProducer:MuonBestTrackVtxDistZ(MuonBestTrackVtxDistZ)'])
## ----------------------------------------------------------------------------------------------
## Taus
## ----------------------------------------------------------------------------------------------
from LeptoQuarkTreeMaker.Utils.TauProducer_cfi import TauProducer
process.TauProducer = TauProducer.clone(
tautag = cms.InputTag('slimmedTaus')
)
#process.Baseline += process.TauProducer
VectorDouble.extend(['TauProducer:tEta(TauEta)'])
VectorDouble.extend(['TauProducer:tPhi(TauPhi)'])
VectorDouble.extend(['TauProducer:tPt(TauPt)'])
## ----------------------------------------------------------------------------------------------
## Triggers
## ----------------------------------------------------------------------------------------------
# The trigger results are saved to the tree as a vector
# Three vectors are saved:
# 1) names of the triggers
# 2) trigger results
# 3) trigger prescales
# the indexing of these vectors must match
# If the version number of the input trigger name is omitted,
# any matching trigger will be included (default behavior)
from LeptoQuarkTreeMaker.Utils.triggerproducer_cfi import triggerProducer
from LeptoQuarkTreeMaker.LeptoQuarkTreeMaker.triggerNameList import triggerNameList as _triggerNameList
process.TriggerProducer = triggerProducer.clone(
trigTagArg1 = cms.string('TriggerResults'),
trigTagArg2 = cms.string(''),
trigTagArg3 = cms.string('HLT'),
prescaleTagArg1 = cms.string('patTrigger'),
prescaleTagArg2 = cms.string(''),
prescaleTagArg3 = cms.string(''),
triggerNameList = _triggerNameList
)
VectorInt.extend(['TriggerProducer:TriggerPass','TriggerProducer:TriggerPrescales'])
VectorString.extend(['TriggerProducer:TriggerNames'])
VectorDouble.extend(['TriggerProducer:objectPt'])
VectorDouble.extend(['TriggerProducer:objecteta'])
VectorDouble.extend(['TriggerProducer:objectphi'])
VectorDouble.extend(['TriggerProducer:objectE'])
VectorDouble.extend(['TriggerProducer:ColumnNum'])
## ----------------------------------------------------------------------------------------------
## JER smearing, various uncertainties
## ----------------------------------------------------------------------------------------------
# list of clean tags - ignore jet ID for jets matching these objects
SkipTag = cms.VInputTag(
)
# get the JERs (disabled by default)
# this requires the user to download the .db file from this github
# https://github.com/cms-jet/JRDatabase
if len(jerfile)>0:
#get name of JERs without any directories
JERera = jerfile.split('/')[-1]
JERPatch = cms.string('sqlite_file:'+jerfile+'.db')
if os.getenv('GC_CONF'):
JERPatch = cms.string('sqlite_file:../src/'+jerfile+'.db')
process.jer = cms.ESSource("PoolDBESSource",CondDBSetup,
connect = JERPatch,
toGet = cms.VPSet(
cms.PSet(
record = cms.string('JetResolutionRcd'),
tag = cms.string('JR_'+JERera+'_PtResolution_AK4PFchs'),
label = cms.untracked.string('AK4PFchs_pt')
),
cms.PSet(
record = cms.string('JetResolutionScaleFactorRcd'),
tag = cms.string('JR_'+JERera+'_SF_AK4PFchs'),
label = cms.untracked.string('AK4PFchs')
),
),
)
process.es_prefer_jer = cms.ESPrefer('PoolDBESSource', 'jer')
# skip all jet smearing and uncertainties for data
from LeptoQuarkTreeMaker.LeptoQuarkTreeMaker.JetDepot import JetDepot #........Uncomment it once you start running on MC datasets
from LeptoQuarkTreeMaker.LeptoQuarkTreeMaker.makeJetVars import makeJetVars
process = makeJetVars(process,
JetTag=JetTag,
suff='',
skipGoodJets=False,
storeProperties=2,
geninfo=geninfo,
fastsim=fastsim,
SkipTag=SkipTag
)
if geninfo:
# JEC unc up
process, JetTagJECup = JetDepot(process,
JetTag=JetTag,
jecUncDir=1,
doSmear=True,
jerUncDir=0
)
process = makeJetVars(process,
JetTag=JetTagJECup,
suff='JECup',
skipGoodJets=False,
storeProperties=1,
geninfo=geninfo,
fastsim=fastsim,
SkipTag=SkipTag
)
# JEC unc down
process, JetTagJECdown = JetDepot(process,
JetTag=JetTag,
jecUncDir=-1,
doSmear=True,
jerUncDir=0
)
process = makeJetVars(process,
JetTag=JetTagJECdown,
suff='JECdown',
skipGoodJets=False,
storeProperties=1,
geninfo=geninfo,
fastsim=fastsim,
SkipTag=SkipTag
)
# JER unc up
process, JetTagJERup = JetDepot(process,
JetTag=JetTag,
jecUncDir=0,
doSmear=True,
jerUncDir=1
)
process = makeJetVars(process,
JetTag=JetTagJERup,
suff='JERup',
skipGoodJets=False,
storeProperties=1,
geninfo=geninfo,
fastsim=fastsim,
SkipTag=SkipTag
)
# JER unc down
process, JetTagJERdown = JetDepot(process,
JetTag=JetTag,
jecUncDir=0,
doSmear=True,
jerUncDir=-1
)
process = makeJetVars(process,
JetTag=JetTagJERdown,
suff='JERdown',
skipGoodJets=False,
storeProperties=1,
geninfo=geninfo,
fastsim=fastsim,
SkipTag=SkipTag
)
# finally, do central smearing and replace jet tag
process, JetTag = JetDepot(process,
JetTag=JetTag,
jecUncDir=0,
doSmear=True,
jerUncDir=0
)
## ----------------------------------------------------------------------------------------------
## Jet variables
## ----------------------------------------------------------------------------------------------
'''
# get updated QG training
QGPatch = cms.string('sqlite_file:data/QGL_80X.db')
if os.getenv('GC_CONF'):
QGPatch = cms.string('sqlite_file:../src/data/QGL_80X.db')
process.qgdb = cms.ESSource("PoolDBESSource",CondDBSetup,
connect = QGPatch,
toGet = cms.VPSet(
cms.PSet(
record = cms.string('QGLikelihoodRcd'),
tag = cms.string('QGLikelihoodObject_80X_AK4PFchs'),
label = cms.untracked.string('QGL_AK4PFchs')
),
cms.PSet(
record = cms.string('QGLikelihoodRcd'),
tag = cms.string('QGLikelihoodObject_80X_AK4PFchs_antib'),
label = cms.untracked.string('QGL_AK4PFchs_antib')
),
)
)
process.es_prefer_qg = cms.ESPrefer("PoolDBESSource","qgdb")
# get QG tagging discriminant
process.QGTagger = cms.EDProducer('QGTagger',
srcJets = JetTag,
jetsLabel = cms.string('QGL_AK4PFchs'),
srcRho = cms.InputTag('fixedGridRhoFastjetAll'),
srcVertexCollection = cms.InputTag('offlinePrimaryVerticesWithBS'),
useQualityCuts = cms.bool(False)
)
# add userfloats & update tag
process, JetTag = addJetInfo(process, JetTag, ['QGTagger:qgLikelihood','QGTagger:ptD', 'QGTagger:axis2'], ['QGTagger:mult'])
process = makeJetVars(process,
JetTag=JetTag,
suff='',
skipGoodJets=False,
storeProperties=2,
geninfo=geninfo,
fastsim=fastsim,
SkipTag=SkipTag
)
# get double b-tagger (w/ miniAOD customizations)
process.load("RecoBTag.ImpactParameter.pfImpactParameterAK8TagInfos_cfi")
process.pfImpactParameterAK8TagInfos.primaryVertex = cms.InputTag("offlineSlimmedPrimaryVertices")
process.pfImpactParameterAK8TagInfos.candidates = cms.InputTag("packedPFCandidates")
process.pfImpactParameterAK8TagInfos.jets = JetAK8Tag
process.load("RecoBTag.SecondaryVertex.pfInclusiveSecondaryVertexFinderAK8TagInfos_cfi")
process.pfInclusiveSecondaryVertexFinderAK8TagInfos.extSVCollection = cms.InputTag("slimmedSecondaryVertices")
process.pfInclusiveSecondaryVertexFinderAK8TagInfos.trackIPTagInfos = cms.InputTag("pfImpactParameterAK8TagInfos")
process.load("RecoBTag.SecondaryVertex.pfBoostedDoubleSVAK8TagInfos_cfi")
process.load("RecoBTag.SecondaryVertex.candidateBoostedDoubleSecondaryVertexAK8Computer_cfi")
process.load("RecoBTag.SecondaryVertex.pfBoostedDoubleSecondaryVertexAK8BJetTags_cfi")
# add discriminator and update tag
process, JetAK8Tag = addJetInfo(process, JetAK8Tag, [], [], cms.VInputTag(cms.InputTag("pfBoostedDoubleSecondaryVertexAK8BJetTags")))
# apply jet ID
process = makeJetVars(process,
JetTag=JetAK8Tag,
suff='AK8',
skipGoodJets=False,
storeProperties=1,
geninfo=geninfo,
fastsim=fastsim,
onlyGoodJets=True
)
# AK8 jet variables - separate instance of jet properties producer
from LeptoQuarkTreeMaker.Utils.jetproperties_cfi import jetproperties
process.JetsPropertiesAK8 = jetproperties.clone(
JetTag = JetAK8Tag,
properties = cms.vstring(
"prunedMass" ,
"NsubjettinessTau1" ,
"NsubjettinessTau2" ,
"NsubjettinessTau3" ,
"bDiscriminatorSubjet1",
"bDiscriminatorSubjet2",
"bDiscriminatorCSV" ,
"NumBhadrons" ,
"NumChadrons" ,
)
)
#specify userfloats
process.JetsPropertiesAK8.prunedMass = cms.vstring('ak8PFJetsCHSPrunedMass')
process.JetsPropertiesAK8.NsubjettinessTau1 = cms.vstring('NjettinessAK8:tau1')
process.JetsPropertiesAK8.NsubjettinessTau2 = cms.vstring('NjettinessAK8:tau2')
process.JetsPropertiesAK8.NsubjettinessTau3 = cms.vstring('NjettinessAK8:tau3')
process.JetsPropertiesAK8.bDiscriminatorSubjet1 = cms.vstring('SoftDrop','pfCombinedInclusiveSecondaryVertexV2BJetTags')
process.JetsPropertiesAK8.bDiscriminatorSubjet2 = cms.vstring('SoftDrop','pfCombinedInclusiveSecondaryVertexV2BJetTags')
process.JetsPropertiesAK8.bDiscriminatorCSV = cms.vstring('pfBoostedDoubleSecondaryVertexAK8BJetTags')
#VectorRecoCand.extend([JetAK8Tag.value()+'(JetsAK8)'])
VectorDouble.extend(['JetsPropertiesAK8:prunedMass(JetsAK8_prunedMass)',
'JetsPropertiesAK8:bDiscriminatorSubjet1(JetsAK8_bDiscriminatorSubjet1CSV)',
'JetsPropertiesAK8:bDiscriminatorSubjet2(JetsAK8_bDiscriminatorSubjet2CSV)',
'JetsPropertiesAK8:bDiscriminatorCSV(JetsAK8_doubleBDiscriminator)',
'JetsPropertiesAK8:NsubjettinessTau1(JetsAK8_NsubjettinessTau1)',
'JetsPropertiesAK8:NsubjettinessTau2(JetsAK8_NsubjettinessTau2)',
'JetsPropertiesAK8:NsubjettinessTau3(JetsAK8_NsubjettinessTau3)'])
VectorInt.extend(['JetsPropertiesAK8:NumBhadrons(JetsAK8_NumBhadrons)',
'JetsPropertiesAK8:NumChadrons(JetsAK8_NumChadrons)'])
'''
## ----------------------------------------------------------------------------------------------
## GenJet variables
## ----------------------------------------------------------------------------------------------
if geninfo:
# store all genjets
VectorRecoCand.extend ( [ 'slimmedGenJets(GenJets)' ] )
from LeptoQuarkTreeMaker.Utils.subJetSelection_cfi import SubGenJetSelection
process.GenHTJets = SubGenJetSelection.clone(
JetTag = cms.InputTag('slimmedGenJets'),
MinPt = cms.double(30),
MaxEta = cms.double(2.4),
)
VectorBool.extend(['GenHTJets:SubJetMask(GenJets_HTMask)'])
# make gen HT
from LeptoQuarkTreeMaker.Utils.htdouble_cfi import htdouble
process.GenHT = htdouble.clone(
JetTag = cms.InputTag("GenHTJets"),
)
VarsDouble.extend(['GenHT'])
process.GenMHTJets = SubGenJetSelection.clone(
JetTag = cms.InputTag('slimmedGenJets'),
MinPt = cms.double(30),
MaxEta = cms.double(5.0),
)
VectorBool.extend(['GenMHTJets:SubJetMask(GenJets_MHTMask)'])
# make gen MHT
## ----------------------------------------------------------------------------------------------
## Baseline filters
## ----------------------------------------------------------------------------------------------
# sequence for baseline filters
process.Baseline = cms.Sequence()
#process.Baseline += process.MHTFilter
## ----------------------------------------------------------------------------------------------
## MET
## ----------------------------------------------------------------------------------------------
from LeptoQuarkTreeMaker.Utils.metdouble_cfi import metdouble
process.MET = metdouble.clone(
METTag = METTag,
GenMETTag = cms.InputTag("slimmedMETs","",tagname), #original collection used deliberately here
JetTag = cms.InputTag('HTJets'),
geninfo = cms.untracked.bool(geninfo),
)
VarsDouble.extend(['MET:Pt(MET)','MET:Phi(METPhi)','MET:CaloPt(CaloMET)','MET:CaloPhi(CaloMETPhi)','MET:PFCaloPtRatio(PFCaloMETRatio)'])
if geninfo:
VarsDouble.extend(['MET:GenPt(GenMET)','MET:GenPhi(GenMETPhi)'])
VectorDouble.extend(['MET:PtUp(METUp)', 'MET:PtDown(METDown)', 'MET:PhiUp(METPhiUp)', 'MET:PhiDown(METPhiDown)'])
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
## Optional producers (background estimations, control regions)
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
## Hadronic Tau Background
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
## Lost Lepton Background
## ----------------------------------------------------------------------------------------------
## Zinv Background
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
## Final steps
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
# create the process path
process.dump = cms.EDAnalyzer("EventContentAnalyzer")
process.WriteTree = cms.Path(
process.Baseline *
process.LQTreeMaker2
)
return process
def define_jets(process, reapplyJEC=False, runOnData=False):
"""Define reconstructed jets.
Configure reconstructed jets to be used in an analysis. In
particular, reapply JEC if requested.
Arguments:
process: The process to which relevant jet producers are added.
reapplyJEC: Flag determining if JEC are to be reapplied or not.
runOnData: Flag to distinguish processing of data and
simulation.
Return value:
Return a tuple with the following elements:
recorrectedJetsLabel: Label to access collection of jets with
up-to-date JEC (reapplied or not, depending on the
configuration) and no kinamatical or quality selection.
jetQualityCuts: List of string-based quality selections whose
decisions are to be saved.
Create the following jet collections:
analysisPatJets: Jets with up-to-date JEC and a loose quality
selection to be used in an analysis.
"""
# Reapply JEC [1] and evaluate DeepCSV b-taggers [2]. Jet
# collection is updated regardless of the value of parameter
# reapplyJEC because of the b-taggers.
# [1] https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookJetEnergyCorrections?rev=139#CorrPatJets
# [2] https://twiki.cern.ch/twiki/bin/viewauth/CMS/DeepFlavour?rev=6
jecLevels = ['L1FastJet', 'L2Relative', 'L3Absolute']
if runOnData:
jecLevels.append('L2L3Residual')
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
updateJetCollection(
process, labelName = 'UpdatedJECBTags',
jetSource = cms.InputTag('slimmedJets'),
jetCorrections = ('AK4PFchs', cms.vstring(jecLevels), 'None'),
btagDiscriminators = [
'deepFlavourJetTags:probbb', 'deepFlavourJetTags:probb',
'deepFlavourJetTags:probcc', 'deepFlavourJetTags:probc',
'deepFlavourJetTags:probudsg'
]
)
# When b-tagging is rerun, JEC are first undone, b-taggind is
# discriminators are evaluated, and then another jet collection is
# produced. This is the name that is used for the final collection.
recorrectedJetsLabel = 'updatedPatJetsTransientCorrectedUpdatedJECBTags'
# Define analysis-level jets. The produced collection will contain
# all jets that have a chance to pass the given pt threshold thanks
# to JEC and JER variations.
process.analysisPatJets = cms.EDFilter('JERCJetSelector',
src = cms.InputTag(recorrectedJetsLabel),
jetTypeLabel = cms.string('AK4PFchs'),
preselection = cms.string('abs(eta) < 5.2'),
minPt = cms.double(20.),
includeJERCVariations = cms.bool(not runOnData),
genJets = cms.InputTag('slimmedGenJets'),
rho = cms.InputTag('fixedGridRhoFastjetAll')
)
# Additional selection to be evaluated (empty at the moment)
jetQualityCuts = cms.vstring()
return recorrectedJetsLabel, jetQualityCuts
def addParticleNetAK8(process, runParticleNet=False, runParticleNetMD=True):
if not runParticleNet and not runParticleNetMD:
return process
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
from RecoBTag.MXNet.pfParticleNet_cff import _pfParticleNetJetTagsProbs as pfParticleNetJetTagsProbs
from RecoBTag.MXNet.pfParticleNet_cff import _pfMassDecorrelatedParticleNetJetTagsProbs as pfMassDecorrelatedParticleNetJetTagsProbs
JETCorrLevels = ['L2Relative', 'L3Absolute', 'L2L3Residual']
bTagDiscriminators = []
if runParticleNet:
bTagDiscriminators += pfParticleNetJetTagsProbs
if runParticleNetMD:
bTagDiscriminators += pfMassDecorrelatedParticleNetJetTagsProbs
updateJetCollection(
process,
jetSource=cms.InputTag('selectedUpdatedPatJetsAK8WithDeepInfo'),
rParam=0.8,
jetCorrections=('AK8PFPuppi', cms.vstring(JETCorrLevels), 'None'),
btagDiscriminators=bTagDiscriminators,
postfix='AK8WithParticleNet',
)
process.jetCorrFactorsAK8.src = "selectedUpdatedPatJetsAK8WithParticleNet"
process.updatedJetsAK8.jetSource = "selectedUpdatedPatJetsAK8WithParticleNet"
from RecoBTag.ONNXRuntime.pfDeepBoostedJetTags_cfi import pfDeepBoostedJetTags as _pfDeepBoostedJetTags
if runParticleNet:
process.pfParticleNetJetTagsAK8WithParticleNet = _pfDeepBoostedJetTags.clone(
src=process.pfParticleNetJetTagsAK8WithParticleNet.src,
flav_names=process.pfParticleNetJetTagsAK8WithParticleNet.
flav_names,
preprocessParams=process.pfParticleNetJetTagsAK8WithParticleNet.
preprocessParams,
model_path=
'PhysicsTools/NanoTuples/data/ParticleNet/ak8/ParticleNet.onnx',
)
if runParticleNetMD:
process.pfMassDecorrelatedParticleNetJetTagsAK8WithParticleNet = _pfDeepBoostedJetTags.clone(
src=process.pfMassDecorrelatedParticleNetJetTagsAK8WithParticleNet.
src,
flav_names=process.
pfMassDecorrelatedParticleNetJetTagsAK8WithParticleNet.flav_names,
preprocessParams=process.
pfMassDecorrelatedParticleNetJetTagsAK8WithParticleNet.
preprocessParams,
model_path=
'PhysicsTools/NanoTuples/data/ParticleNet-MD/ak8/ParticleNetMD.onnx',
)
# add nominal taggers
if runParticleNet:
for prob in pfParticleNetJetTagsProbs:
name = 'ParticleNet_' + prob.split(':')[1]
setattr(
process.fatJetTable.variables, name,
Var("bDiscriminator('%s')" % prob,
float,
doc=prob,
precision=-1))
# add mass-decorelated taggers
if runParticleNetMD:
for prob in pfMassDecorrelatedParticleNetJetTagsProbs:
name = 'ParticleNetMD_' + prob.split(':')[1]
setattr(
process.fatJetTable.variables, name,
Var("bDiscriminator('%s')" % prob,
float,
doc=prob,
precision=-1))
return process
elif options.pileup == 200:
process.ntuple.photonEcorr = cms.FileInPath("PhaseTwoAnalysis/NTupler/data/photonEnergyCorrections_PU200.root")
process.ntuple.jets = "slimmedJetsPuppi"
process.ntuple.mets = "slimmedMETsPuppi"
if options.updateJEC:
# The updateJetCollection function will uncorred the jets from MiniAOD and then recorrect them using the current
# set of JEC in the event setup
# The new name of the updated jet collection becomes updatedPatJetsUpdatedJECAK4PFPuppi
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
if options.pileup==0:
if options.rerunBtag:
updateJetCollection(process,
jetSource = cms.InputTag('slimmedJets'),
postfix = 'UpdatedJECAK4PF',
jetCorrections = ('AK4PF', ['L2Relative','L3Absolute'], 'None'),
pfCandidates = cms.InputTag('packedPFCandidates'),
btagDiscriminators = ['pfDeepCSVJetTags:probb', 'pfDeepCSVJetTags:probbb'],
)
process.ntuple.jets = "selectedUpdatedPatJetsUpdatedJECAK4PF"
else:
updateJetCollection(process,
jetSource = cms.InputTag('slimmedJets'),
postfix = 'UpdatedJECAK4PF',
jetCorrections = ('AK4PF', ['L2Relative','L3Absolute'], 'None')
)
process.ntuple.jets = "updatedPatJetsUpdatedJECAK4PF"
else:
if options.rerunBtag:
updateJetCollection(process,
jetSource = cms.InputTag('slimmedJetsPuppi'),
# ),
# ),
# connect = cms.string(jetDBFile)
#)
#process.es_prefer_jer = cms.ESPrefer('PoolDBESSource', 'jer')
# Apply jet energy corrections:
# https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookJetEnergyCorrections#CorrPatJets
# https://github.com/cms-sw/cmssw/blob/CMSSW_8_0_X/PhysicsTools/PatAlgos/test/patTuple_updateJets_fromMiniAOD_cfg.py
# This should load them from the global tag
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
if varOptions.isMC :
updateJetCollection(
process,
jetSource = cms.InputTag('slimmedJets'),
jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None'),
)
else :
updateJetCollection(
process,
jetSource = cms.InputTag('slimmedJets'),
jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute', 'L2L3Residual']), 'None'),
)
process.rootTuplePFJetsAK4CHS.InputTag = cms.InputTag('updatedPatJets')
process.applyCorrections = cms.Path()
process.applyCorrections += process.patJetCorrFactors
process.applyCorrections += process.updatedPatJets
##----------------------------------------------------------------------------------------------------
## MET Re-Corrections and Uncertainties
label = cms.untracked.string("AK4PFPuppi"))
)
)
process.es_prefer_jec = cms.ESPrefer("PoolDBESSource","jec")
process.myana = cms.EDAnalyzer('BasicPatDistrib')
process.load("PhaseTwoAnalysis.BasicPatDistrib.CfiFile_cfi")
#process.myana.useDeepCSV = True
#process.myana.pileup = 0
#process.myana.mets = cms.InputTag("slimmedMETs"),
if options.updateJEC:
# The updateJetCollection function will uncorred the jets from MiniAOD and then recorrect them using the current
# set of JEC in the event setup
# The new name of the updated jet collection becomes updatedPatJetsUpdatedJECAK4PFPuppi
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
updateJetCollection(process,
jetSource = cms.InputTag('slimmedJetsPuppi'),
postfix = 'UpdatedJECAK4PFPuppi',
jetCorrections = ('AK4PFPuppi', ['L1FastJet','L2Relative','L3Absolute'], 'None')
)
process.myana.jets = "updatedPatJetsUpdatedJECAK4PFPuppi"
process.TFileService = cms.Service("TFileService",
fileName = cms.string('histos.root')
)
if options.updateJEC:
process.p = cms.Path(process.patJetCorrFactorsUpdatedJECAK4PFPuppi * process.updatedPatJetsUpdatedJECAK4PFPuppi * process.myana)
else:
process.p = cms.Path(process.myana)
)
)
process.load('Configuration.StandardSequences.Services_cff')
process.load("Configuration.Geometry.GeometryRecoDB_cff")
process.load("Configuration.StandardSequences.MagneticField_AutoFromDBCurrent_cff")
corList = cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute'])
if options.isData:
corList = cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute', 'L2L3Residual'])
# Re-apply JEC to AK4
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
updateJetCollection(
process,
jetSource = cms.InputTag('slimmedJets'),
labelName = 'UpdatedJEC',
jetCorrections = ('AK4PFchs', corList, 'None')
)
# Re-apply JEC to AK8
updateJetCollection(
process,
jetSource = cms.InputTag('slimmedJets'),
labelName = 'UpdatedJECAK8',
jetCorrections = ('AK8PFchs', corList, 'None')
)
jetsNameAK4="selectedUpdatedPatJetsUpdatedJEC"
jetsNameAK8="selectedUpdatedPatJetsUpdatedJECAK8"
#jetsNameAK10="patJetsReapplyJECAK10"
jetsNameAK10="selectedPatJetsAK10PFCHS"
runEnergyCorrections=True,
applyEPCombBug=False,
autoAdjustParams=True,
computeHeepTrkPtIso=True) #era is new to select between 2016 / 2017, it defaults to 2017)
#a sequence egammaPostRecoSeq has now been created and should be added to your path, eg process.p=cms.Path(process.egammaPostRecoSeq)
# Update jet collection
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
updateJetCollection(
process,
jetSource = cms.InputTag('slimmedJets'),
pvSource = cms.InputTag('offlineSlimmedPrimaryVertices'),
svSource = cms.InputTag('slimmedSecondaryVertices'),
jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None'),
btagDiscriminators = [
'pfDeepFlavourJetTags:probb',
'pfDeepFlavourJetTags:probbb',
'pfDeepFlavourJetTags:problepb',
'pfDeepFlavourJetTags:probc',
'pfDeepFlavourJetTags:probuds',
'pfDeepFlavourJetTags:probg'
],
postfix='NewDFTraining'
)
updateJetCollection(
process,
jetSource = cms.InputTag('selectedUpdatedPatJetsNewDFTraining'), # slimmedJets
labelName = 'UpdatedJEC',
jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute', 'L2L3Residual']), 'None') # Update: Safe to always add 'L2L3Residual' as MC contains dummy L2L3Residual corrections (always set to 1)
)
'pfDeepCSVJetTags:probudsg',
'pfDeepCSVJetTags:probb',
'pfDeepCSVJetTags:probc',
'pfDeepCSVJetTags:probbb',
'pfDeepFlavourJetTags:probb',
'pfDeepFlavourJetTags:probbb',
'pfDeepFlavourJetTags:probc',
'pfDeepFlavourJetTags:probuds',
'pfDeepFlavourJetTags:problepb',
'pfDeepFlavourJetTags:probg',
]
from PhysicsTools.PatAlgos.tools.jetTools import *
updateJetCollection(
process,
jetSource = cms.InputTag('slimmedJets'),
jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None'),
btagDiscriminators = bTagDiscriminators
)
#update training
process.pfDeepFlavourJetTags.graph_path = cms.FileInPath('RecoBTag/Combined/data/DeepFlavourV03_10X_training/constant_graph.pb')
process.pfDeepFlavourJetTags.lp_names = cms.vstring('cpf_input_batchnorm/keras_learning_phase')
## Initialize analyzer
process.bTaggingExerciseIIAK4Jets = cms.EDAnalyzer(
'FastBTV',
jets = cms.InputTag('selectedUpdatedPatJets'), # input jet collection name
bDiscriminators = cms.PSet(
CSVv2 = cms.vstring('pfCombinedInclusiveSecondaryVertexV2BJetTags'),
DeepCSV = cms.vstring(
'pfDeepCSVJetTags:probb',
# Setup VID for EGM ID
from PhysicsTools.SelectorUtils.tools.vid_id_tools import *
switchOnVIDPhotonIdProducer(process, DataFormat.MiniAOD)
# define which IDs we want to produce
my_id_modules = ['RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring15_25ns_V1_cff']
#add them to the VID producer
for idmod in my_id_modules:
setupAllVIDIdsInModule(process,idmod,setupVIDPhotonSelection)
## update AK4PFchs jet collection in MiniAOD JECs
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
updateJetCollection(
process,
jetSource = cms.InputTag('slimmedJets'),
labelName = 'UpdatedJEC',
jetCorrections = ('AK4PFchs', JEC, 'None') # Do not forget 'L2L3Residual' on data!
)
# main analyzer and inputs
process.diphoton = cms.EDAnalyzer(
'ExoDiPhotonAnalyzer',
# photon tag
photonsMiniAOD = cms.InputTag("slimmedPhotons"),
minPhotonPt = cms.double(75.),
# genParticle tag
genParticlesMiniAOD = cms.InputTag("prunedGenParticles"),
# vertex tag
vertices = cms.InputTag("offlineSlimmedPrimaryVertices"),
# beam spot tag
beamSpot = cms.InputTag("offlineBeamSpot", "", "RECO"),
if options.doJetToolbox:
jetCollection = 'selectedPatJets'+params['algo'].upper()+'PF'+pu_method
elif options.doMiniAOD and not options.doReclustering:
#straight from MiniAOD
jetCollection = "slimmedJets"
if params['algo'] == 'ak4' and pu_method == "Puppi":
jetCollection+= "Puppi"
elif params['algo'] == 'ak8':
jetCollection+="AK8"
#If updated the JEC using the patJetUpdater
if options.useUpdater:
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
updateJetCollection(process,
jetSource = cms.InputTag(jetCollection),
postfix = 'UpdatedJEC'+params['jec_payloads'][index],
jetCorrections = (params['jec_payloads'][index], params['jec_levels'], 'None')
)
jetCollection = 'updatedPatJetsUpdatedJEC'+params['jec_payloads'][index]
elif not options.doMiniAOD and not options.doJetToolbox:
jetCollection = 'selectedPatJets'+params['algo'].upper()+'PF'+pu_method
#jetCollection = params['algo']+'PFJets'+pu_method+PUSuffix.upper().replace("L1","L1Fast")
#################################################
## Controls the JER and JES used in the analyzer
#################################################
from Analysis.JMEDAS.JetDepot import JetDepot
if not options.UncertaintyOTF:
if options.JESUncertainty!='none':
process, jetCollection = JetDepot(process,
def applyDeepBtagging( process, postfix="" ) :
task = getPatAlgosToolsTask(process)
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
process.load('PhysicsTools.PatAlgos.slimming.slimmedJets_cfi')
# update slimmed jets to include DeepFlavour (keep same name)
# make clone for DeepFlavour-less slimmed jets, so output name is preserved
addToProcessAndTask('slimmedJetsNoDeepFlavour', process.slimmedJets.clone(), process, task)
updateJetCollection(
process,
jetSource = cms.InputTag('slimmedJetsNoDeepFlavour'),
# updateJetCollection defaults to MiniAOD inputs but
# here it is made explicit (as in training or MINIAOD redoing)
pvSource = cms.InputTag('offlineSlimmedPrimaryVertices'),
pfCandidates = cms.InputTag('packedPFCandidates'),
svSource = cms.InputTag('slimmedSecondaryVertices'),
muSource = cms.InputTag('slimmedMuons'),
elSource = cms.InputTag('slimmedElectrons'),
jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None'),
btagDiscriminators = [
'pfDeepFlavourJetTags:probb',
'pfDeepFlavourJetTags:probbb',
'pfDeepFlavourJetTags:problepb',
'pfDeepFlavourJetTags:probc',
'pfDeepFlavourJetTags:probuds',
'pfDeepFlavourJetTags:probg',
],
postfix = 'SlimmedDeepFlavour'+postfix,
printWarning = False
)
# slimmedJets with DeepFlavour (remove DeepFlavour-less)
delattr(process, 'slimmedJets')
addToProcessAndTask('slimmedJets', getattr(process,'selectedUpdatedPatJetsSlimmedDeepFlavour'+postfix).clone(), process, task)
# delete module not used anymore (slimmedJets substitutes)
delattr(process, 'selectedUpdatedPatJetsSlimmedDeepFlavour'+postfix)
# update slimmed jets to include DeepFlavour (keep same name)
# make clone for DeepDoubleB-less slimmed AK8 jets, so output name is preserved
addToProcessAndTask('slimmedJetsAK8NoDeepDoubleB', process.slimmedJetsAK8.clone(), process, task)
updateJetCollection(
process,
jetSource = cms.InputTag('slimmedJetsAK8NoDeepDoubleB'),
# updateJetCollection defaults to MiniAOD inputs but
# here it is made explicit (as in training or MINIAOD redoing)
pvSource = cms.InputTag('offlineSlimmedPrimaryVertices'),
pfCandidates = cms.InputTag('packedPFCandidates'),
svSource = cms.InputTag('slimmedSecondaryVertices'),
muSource = cms.InputTag('slimmedMuons'),
elSource = cms.InputTag('slimmedElectrons'),
rParam = 0.8,
jetCorrections = ('AK8PFPuppi', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None'),
btagDiscriminators = [
'pfDeepDoubleBJetTags:probQ',
'pfDeepDoubleBJetTags:probH',
],
postfix = 'SlimmedAK8DeepDoubleB'+postfix,
printWarning = False
)
# slimmedJetsAK8 with DeepDoubleB (remove DeepDoubleB-less)
delattr(process, 'slimmedJetsAK8')
addToProcessAndTask('slimmedJetsAK8', getattr(process,'selectedUpdatedPatJetsSlimmedAK8DeepDoubleB'+postfix).clone(), process, task)
# delete module not used anymore (slimmedJetsAK8 substitutes)
delattr(process, 'selectedUpdatedPatJetsSlimmedAK8DeepDoubleB'+postfix)
def setupCustomizedAK8(process, runOnMC=False, path=None):
# recluster Puppi jets
bTagDiscriminators = [
'pfCombinedInclusiveSecondaryVertexV2BJetTags',
'pfBoostedDoubleSecondaryVertexAK8BJetTags',
]
subjetBTagDiscriminators = [
'pfCombinedInclusiveSecondaryVertexV2BJetTags',
'pfDeepCSVJetTags:probb',
'pfDeepCSVJetTags:probbb',
]
JETCorrLevels = ['L2Relative', 'L3Absolute', 'L2L3Residual']
from PhysicsTools.NanoTuples.jetToolbox_cff import jetToolbox
jetToolbox(process,
'ak8',
'dummySeqAK8',
'noOutput',
PUMethod='Puppi',
JETCorrPayload='AK8PFPuppi',
JETCorrLevels=JETCorrLevels,
Cut='pt > 170.0 && abs(rapidity()) < 2.4',
runOnMC=runOnMC,
addNsub=True,
maxTau=3,
addSoftDrop=True,
addSoftDropSubjets=True,
subJETCorrPayload='AK4PFPuppi',
subJETCorrLevels=JETCorrLevels,
bTagDiscriminators=bTagDiscriminators,
subjetBTagDiscriminators=subjetBTagDiscriminators)
if runOnMC:
process.ak8GenJetsNoNu.jetPtMin = 100
process.ak8GenJetsNoNuSoftDrop.jetPtMin = 100
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
from RecoBTag.ONNXRuntime.pfDeepBoostedJet_cff import _pfDeepBoostedJetTagsProbs, _pfMassDecorrelatedDeepBoostedJetTagsProbs
from RecoBTag.MXNet.pfParticleNet_cff import _pfParticleNetJetTagsProbs, _pfMassDecorrelatedParticleNetJetTagsProbs
updateJetCollection(
process,
jetSource=cms.InputTag('packedPatJetsAK8PFPuppiSoftDrop'),
rParam=0.8,
jetCorrections=('AK8PFPuppi', cms.vstring(JETCorrLevels), 'None'),
btagDiscriminators=bTagDiscriminators + _pfDeepBoostedJetTagsProbs +
_pfMassDecorrelatedDeepBoostedJetTagsProbs +
_pfParticleNetJetTagsProbs +
_pfMassDecorrelatedParticleNetJetTagsProbs,
postfix='AK8WithPuppiDaughters',
)
# src
srcJets = cms.InputTag('selectedUpdatedPatJetsAK8WithPuppiDaughters')
# jetID
process.looseJetIdCustomAK8 = cms.EDProducer(
"PatJetIDValueMapProducer",
filterParams=cms.PSet(
version=cms.string('WINTER16'),
quality=cms.string('LOOSE'),
),
src=srcJets)
process.tightJetIdCustomAK8 = cms.EDProducer(
"PatJetIDValueMapProducer",
filterParams=cms.PSet(
version=cms.string('SUMMER18PUPPI'),
quality=cms.string('TIGHT'),
),
src=srcJets)
process.tightJetIdLepVetoCustomAK8 = cms.EDProducer(
"PatJetIDValueMapProducer",
filterParams=cms.PSet(
version=cms.string('SUMMER18PUPPI'),
quality=cms.string('TIGHTLEPVETO'),
),
src=srcJets)
run2_jme_2016.toModify(process.tightJetIdCustomAK8.filterParams,
version="WINTER16")
run2_jme_2016.toModify(process.tightJetIdLepVetoCustomAK8.filterParams,
version="WINTER16")
run2_jme_2017.toModify(process.tightJetIdCustomAK8.filterParams,
version="WINTER17PUPPI")
run2_jme_2017.toModify(process.tightJetIdLepVetoCustomAK8.filterParams,
version="WINTER17PUPPI")
process.customAK8WithUserData = cms.EDProducer(
"PATJetUserDataEmbedder",
src=srcJets,
userFloats=cms.PSet(),
userInts=cms.PSet(
tightId=cms.InputTag("tightJetIdCustomAK8"),
tightIdLepVeto=cms.InputTag("tightJetIdLepVetoCustomAK8"),
),
)
run2_jme_2016.toModify(
process.customAK8WithUserData.userInts,
looseId=cms.InputTag("looseJetIdCustomAK8"),
tightIdLepVeto=None,
)
process.customAK8Table = cms.EDProducer(
"SimpleCandidateFlatTableProducer",
src=cms.InputTag("customAK8WithUserData"),
name=cms.string("CustomAK8Puppi"),
cut=cms.string(""),
doc=cms.string("reclustered ak8 puppi jets"),
singleton=cms.bool(False), # the number of entries is variable
extension=cms.bool(False), # this is the main table for the jets
variables=cms.PSet(
P4Vars,
jetId=Var(
"userInt('tightId')*2+4*userInt('tightIdLepVeto')",
int,
doc=
"Jet ID flags bit1 is loose (always false in 2017 since it does not exist), bit2 is tight, bit3 is tightLepVeto"
),
area=Var("jetArea()",
float,
doc="jet catchment area, for JECs",
precision=10),
rawFactor=Var("1.-jecFactor('Uncorrected')",
float,
doc="1 - Factor to get back to raw pT",
precision=6),
nPFConstituents=Var("numberOfDaughters()",
int,
doc="Number of PF candidate constituents"),
tau1=Var("userFloat('NjettinessAK8Puppi:tau1')",
float,
doc="Nsubjettiness (1 axis)",
precision=10),
tau2=Var("userFloat('NjettinessAK8Puppi:tau2')",
float,
doc="Nsubjettiness (2 axis)",
precision=10),
tau3=Var("userFloat('NjettinessAK8Puppi:tau3')",
float,
doc="Nsubjettiness (3 axis)",
precision=10),
msoftdrop=Var("groomedMass()",
float,
doc="Corrected soft drop mass with PUPPI",
precision=10),
btagCSVV2=Var(
"bDiscriminator('pfCombinedInclusiveSecondaryVertexV2BJetTags')",
float,
doc=
" pfCombinedInclusiveSecondaryVertexV2 b-tag discriminator (aka CSVV2)",
precision=10),
btagHbb=Var(
"bDiscriminator('pfBoostedDoubleSecondaryVertexAK8BJetTags')",
float,
doc="Higgs to BB tagger discriminator",
precision=10),
nBHadrons=Var("jetFlavourInfo().getbHadrons().size()",
int,
doc="number of b-hadrons"),
nCHadrons=Var("jetFlavourInfo().getcHadrons().size()",
int,
doc="number of c-hadrons"),
subJetIdx1=Var(
"?nSubjetCollections()>0 && subjets().size()>0?subjets()[0].key():-1",
int,
doc="index of first subjet"),
subJetIdx2=Var(
"?nSubjetCollections()>0 && subjets().size()>1?subjets()[1].key():-1",
int,
doc="index of second subjet"),
))
run2_jme_2016.toModify(
process.customAK8Table.variables,
jetId=Var("userInt('tightId')*2+userInt('looseId')",
int,
doc="Jet ID flags bit1 is loose, bit2 is tight"))
process.customAK8Table.variables.pt.precision = 10
# add DeepAK8 scores: nominal
for prob in _pfDeepBoostedJetTagsProbs:
name = 'DeepAK8_' + prob.split(':')[1]
setattr(
process.customAK8Table.variables, name,
Var("bDiscriminator('%s')" % prob, float, doc=prob, precision=-1))
# add DeepAK8 scores: mass decorrelated
for prob in _pfMassDecorrelatedDeepBoostedJetTagsProbs:
name = 'DeepAK8MD_' + prob.split(':')[1]
setattr(
process.customAK8Table.variables, name,
Var("bDiscriminator('%s')" % prob, float, doc=prob, precision=-1))
# add ParticleNet nominal taggers
for prob in _pfParticleNetJetTagsProbs:
name = 'ParticleNet_' + prob.split(':')[1]
setattr(
process.customAK8Table.variables, name,
Var("bDiscriminator('%s')" % prob, float, doc=prob, precision=-1))
# add ParticleNet mass-decorelated taggers
for prob in _pfMassDecorrelatedParticleNetJetTagsProbs:
name = 'ParticleNetMD_' + prob.split(':')[1]
setattr(
process.customAK8Table.variables, name,
Var("bDiscriminator('%s')" % prob, float, doc=prob, precision=-1))
process.customAK8SubJetTable = cms.EDProducer(
"SimpleCandidateFlatTableProducer",
src=cms.InputTag("selectedPatJetsAK8PFPuppiSoftDropPacked", "SubJets"),
cut=cms.string(""),
name=cms.string("CustomAK8PuppiSubJet"),
doc=cms.string("reculstered ak8 puppi subjets"),
singleton=cms.bool(False), # the number of entries is variable
extension=cms.bool(False), # this is the main table for the jets
variables=cms.PSet(
P4Vars,
area=Var("jetArea()",
float,
doc="jet catchment area, for JECs",
precision=10),
rawFactor=Var("1.-jecFactor('Uncorrected')",
float,
doc="1 - Factor to get back to raw pT",
precision=6),
btagDeepB=Var(
"bDiscriminator('pfDeepCSVJetTags:probb')+bDiscriminator('pfDeepCSVJetTags:probbb')",
float,
doc="DeepCSV b+bb tag discriminator",
precision=10),
btagCSVV2=Var(
"bDiscriminator('pfCombinedInclusiveSecondaryVertexV2BJetTags')",
float,
doc=
" pfCombinedInclusiveSecondaryVertexV2 b-tag discriminator (aka CSVV2)",
precision=10),
nBHadrons=Var("jetFlavourInfo().getbHadrons().size()",
int,
doc="number of b-hadrons"),
nCHadrons=Var("jetFlavourInfo().getcHadrons().size()",
int,
doc="number of c-hadrons"),
))
process.customAK8SubJetTable.variables.pt.precision = 10
process.customizedAK8Task = cms.Task(process.tightJetIdCustomAK8,
process.tightJetIdLepVetoCustomAK8,
process.customAK8WithUserData,
process.customAK8Table,
process.customAK8SubJetTable)
if runOnMC:
process.customGenJetAK8Table = cms.EDProducer(
"SimpleCandidateFlatTableProducer",
src=cms.InputTag("ak8GenJetsNoNu"),
cut=cms.string("pt > 100."),
name=cms.string("CustomGenJetAK8"),
doc=cms.string("AK8 GenJets made with visible genparticles"),
singleton=cms.bool(False), # the number of entries is variable
extension=cms.bool(
False), # this is the main table for the genjets
variables=cms.PSet(P4Vars, ))
process.customGenJetAK8Table.variables.pt.precision = 10
process.customGenSubJetAK8Table = cms.EDProducer(
"SimpleCandidateFlatTableProducer",
src=cms.InputTag("ak8GenJetsNoNuSoftDrop", "SubJets"),
cut=cms.string(""),
name=cms.string("CustomGenSubJetAK8"),
doc=cms.string("AK8 Gen-SubJets made with visible genparticles"),
singleton=cms.bool(False), # the number of entries is variable
extension=cms.bool(
False), # this is the main table for the genjets
variables=cms.PSet(P4Vars, ))
process.customGenSubJetAK8Table.variables.pt.precision = 10
process.customizedAK8Task.add(process.customGenJetAK8Table)
process.customizedAK8Task.add(process.customGenSubJetAK8Table)
_customizedAK8Task_80X = process.customizedAK8Task.copy()
_customizedAK8Task_80X.replace(process.tightJetIdLepVetoCustomAK8,
process.looseJetIdCustomAK8)
run2_jme_2016.toReplaceWith(process.customizedAK8Task,
_customizedAK8Task_80X)
if path is None:
process.schedule.associate(process.customizedAK8Task)
else:
getattr(process, path).associate(process.customizedAK8Task)
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_25ns_nonTrig_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_25ns_Trig_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring16_GeneralPurpose_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring16_HZZ_V1_cff']
for idmod in my_id_modules:
setupAllVIDIdsInModule(process,idmod,setupVIDElectronSelection)
#process.globalPixelSeeds.OrderedHitsFactoryPSet.maxElement = cms.uint32(100000)
#process.gsfElectrons.MaxElePtForOnlyMVA = cms.double(50.0)
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
from PhysicsTools.PatAlgos.tools.jetTools import *
deep_discriminators = ["deepFlavourJetTags:probudsg", "deepFlavourJetTags:probb", "deepFlavourJetTags:probc", "deepFlavourJetTags:probbb", "deepFlavourJetTags:probcc" ]
updateJetCollection(
process,
jetSource = cms.InputTag('slimmedJets'),
jetCorrections = ('AK4PFchs', cms.vstring([]), 'None'),
btagDiscriminators = deep_discriminators
)
updateJetCollection(
process,
labelName = 'Puppi',
jetSource = cms.InputTag('slimmedJetsPuppi'),
jetCorrections = ('AK4PFchs', cms.vstring([]), 'None'),
btagDiscriminators = deep_discriminators
)
# Load Ntuple producer cff
process.load("CMS3.NtupleMaker.cms3CoreSequences_cff")
process.load("CMS3.NtupleMaker.cms3GENSequence_cff")
process.load("CMS3.NtupleMaker.cms3PFSequence_cff")
def miniAOD_customizeCommon(process):
process.patMuons.isoDeposits = cms.PSet()
process.patElectrons.isoDeposits = cms.PSet()
process.patTaus.isoDeposits = cms.PSet()
process.patPhotons.isoDeposits = cms.PSet()
#
process.patMuons.embedTrack = True # used for IDs
process.patMuons.embedCombinedMuon = True # used for IDs
process.patMuons.embedMuonBestTrack = True # used for IDs
process.patMuons.embedStandAloneMuon = True # maybe?
process.patMuons.embedPickyMuon = False # no, use best track
process.patMuons.embedTpfmsMuon = False # no, use best track
process.patMuons.embedDytMuon = False # no, use best track
process.patMuons.addPuppiIsolation = cms.bool(True)
process.patMuons.puppiIsolationChargedHadrons = cms.InputTag("muonPUPPIIsolation","h+-DR040-ThresholdVeto000-ConeVeto000")
process.patMuons.puppiIsolationNeutralHadrons = cms.InputTag("muonPUPPIIsolation","h0-DR040-ThresholdVeto000-ConeVeto001")
process.patMuons.puppiIsolationPhotons = cms.InputTag("muonPUPPIIsolation","gamma-DR040-ThresholdVeto000-ConeVeto001")
process.patMuons.puppiNoLeptonsIsolationChargedHadrons = cms.InputTag("muonPUPPINoLeptonsIsolation","h+-DR040-ThresholdVeto000-ConeVeto000")
process.patMuons.puppiNoLeptonsIsolationNeutralHadrons = cms.InputTag("muonPUPPINoLeptonsIsolation","h0-DR040-ThresholdVeto000-ConeVeto001")
process.patMuons.puppiNoLeptonsIsolationPhotons = cms.InputTag("muonPUPPINoLeptonsIsolation","gamma-DR040-ThresholdVeto000-ConeVeto001")
process.patMuons.computeMiniIso = cms.bool(True)
process.patMuons.computeMuonMVA = cms.bool(True)
process.patMuons.computeSoftMuonMVA = cms.bool(True)
#
# disable embedding of electron and photon associated objects already stored by the ReducedEGProducer
process.patElectrons.embedGsfElectronCore = False ## process.patElectrons.embed in AOD externally stored gsf electron core
process.patElectrons.embedSuperCluster = False ## process.patElectrons.embed in AOD externally stored supercluster
process.patElectrons.embedPflowSuperCluster = False ## process.patElectrons.embed in AOD externally stored supercluster
process.patElectrons.embedSeedCluster = False ## process.patElectrons.embed in AOD externally stored the electron's seedcluster
process.patElectrons.embedBasicClusters = False ## process.patElectrons.embed in AOD externally stored the electron's basic clusters
process.patElectrons.embedPreshowerClusters = False ## process.patElectrons.embed in AOD externally stored the electron's preshower clusters
process.patElectrons.embedPflowBasicClusters = False ## process.patElectrons.embed in AOD externally stored the electron's pflow basic clusters
process.patElectrons.embedPflowPreshowerClusters = False ## process.patElectrons.embed in AOD externally stored the electron's pflow preshower clusters
process.patElectrons.embedRecHits = False ## process.patElectrons.embed in AOD externally stored the RecHits - can be called from the PATElectronProducer
process.patElectrons.electronSource = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.patElectrons.usePfCandidateMultiMap = True
process.patElectrons.pfCandidateMultiMap = cms.InputTag("reducedEgamma","reducedGsfElectronPfCandMap")
process.patElectrons.electronIDSources = cms.PSet()
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
run2_miniAOD_80XLegacy.toModify(process.patElectrons,
addPFClusterIso = cms.bool(True),
ecalPFClusterIsoMap = cms.InputTag("reducedEgamma", "eleEcalPFClusIso"),
hcalPFClusterIsoMap = cms.InputTag("reducedEgamma", "eleHcalPFClusIso"))
from Configuration.Eras.Modifier_run2_miniAOD_94XFall17_cff import run2_miniAOD_94XFall17
run2_miniAOD_94XFall17.toModify(process.patElectrons,
addPFClusterIso = cms.bool(True),
ecalPFClusterIsoMap = cms.InputTag("reducedEgamma", "eleEcalPFClusIso"),
hcalPFClusterIsoMap = cms.InputTag("reducedEgamma", "eleHcalPFClusIso"))
#add puppi isolation in miniAOD
process.patElectrons.addPuppiIsolation = cms.bool(True)
process.patElectrons.puppiIsolationChargedHadrons = cms.InputTag("egmElectronPUPPIIsolation","h+-DR030-BarVeto000-EndVeto001")
process.patElectrons.puppiIsolationNeutralHadrons = cms.InputTag("egmElectronPUPPIIsolation","h0-DR030-BarVeto000-EndVeto000")
process.patElectrons.puppiIsolationPhotons = cms.InputTag("egmElectronPUPPIIsolation","gamma-DR030-BarVeto000-EndVeto008")
process.patElectrons.puppiNoLeptonsIsolationChargedHadrons = cms.InputTag("egmElectronPUPPINoLeptonsIsolation","h+-DR030-BarVeto000-EndVeto001")
process.patElectrons.puppiNoLeptonsIsolationNeutralHadrons = cms.InputTag("egmElectronPUPPINoLeptonsIsolation","h0-DR030-BarVeto000-EndVeto000")
process.patElectrons.puppiNoLeptonsIsolationPhotons = cms.InputTag("egmElectronPUPPINoLeptonsIsolation","gamma-DR030-BarVeto000-EndVeto008")
process.patElectrons.computeMiniIso = cms.bool(True)
process.elPFIsoDepositChargedPAT.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.elPFIsoDepositChargedAllPAT.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.elPFIsoDepositNeutralPAT.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.elPFIsoDepositGammaPAT.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.elPFIsoDepositPUPAT.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
#
process.patPhotons.embedSuperCluster = False ## whether to process.patPhotons.embed in AOD externally stored supercluster
process.patPhotons.embedSeedCluster = False ## process.patPhotons.embed in AOD externally stored the photon's seedcluster
process.patPhotons.embedBasicClusters = False ## process.patPhotons.embed in AOD externally stored the photon's basic clusters
process.patPhotons.embedPreshowerClusters = False ## process.patPhotons.embed in AOD externally stored the photon's preshower clusters
process.patPhotons.embedRecHits = False ## process.patPhotons.embed in AOD externally stored the RecHits - can be called from the PATPhotonProducer
#add puppi isolation in miniAOD
process.patPhotons.addPuppiIsolation = cms.bool(True)
process.patPhotons.puppiIsolationChargedHadrons = cms.InputTag("egmPhotonPUPPIIsolation","h+-DR030-")
process.patPhotons.puppiIsolationNeutralHadrons = cms.InputTag("egmPhotonPUPPIIsolation","h0-DR030-")
process.patPhotons.puppiIsolationPhotons = cms.InputTag("egmPhotonPUPPIIsolation","gamma-DR030-")
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
run2_miniAOD_80XLegacy.toModify(process.patPhotons,
addPFClusterIso = cms.bool(True),
ecalPFClusterIsoMap = cms.InputTag("reducedEgamma", "phoEcalPFClusIso"),
hcalPFClusterIsoMap = cms.InputTag("reducedEgamma", "phoHcalPFClusIso"))
from Configuration.Eras.Modifier_run2_miniAOD_94XFall17_cff import run2_miniAOD_94XFall17
run2_miniAOD_94XFall17.toModify(process.patPhotons,
addPFClusterIso = cms.bool(True),
ecalPFClusterIsoMap = cms.InputTag("reducedEgamma", "phoEcalPFClusIso"),
hcalPFClusterIsoMap = cms.InputTag("reducedEgamma", "phoHcalPFClusIso"))
#the 80X legacy customsations are done in ootPhotonProducer for OOT photons
run2_miniAOD_94XFall17.toModify(process.patOOTPhotons,
addPFClusterIso = cms.bool(True),
ecalPFClusterIsoMap = cms.InputTag("reducedEgamma", "ootPhoEcalPFClusIso"),
hcalPFClusterIsoMap = cms.InputTag("reducedEgamma", "ootPhoHcalPFClusIso"))
process.patPhotons.photonSource = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.patPhotons.electronSource = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.phPFIsoDepositChargedPAT.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.phPFIsoDepositChargedAllPAT.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.phPFIsoDepositNeutralPAT.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.phPFIsoDepositGammaPAT.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.phPFIsoDepositPUPAT.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
#
process.patOOTPhotons.photonSource = cms.InputTag("reducedEgamma","reducedOOTPhotons")
process.patOOTPhotons.electronSource = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
#
process.selectedPatJets.cut = cms.string("pt > 10")
process.selectedPatMuons.cut = cms.string("pt > 5 || isPFMuon || (pt > 3 && (isGlobalMuon || isStandAloneMuon || numberOfMatches > 0 || muonID('RPCMuLoose')))")
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify(process.selectedPatMuons, cut = "pt > 5 || isPFMuon || (pt > 3 && (isGlobalMuon || isStandAloneMuon || numberOfMatches > 0 || muonID('RPCMuLoose') || muonID('ME0MuonArbitrated') || muonID('GEMMuonArbitrated')) )")
process.selectedPatElectrons.cut = cms.string("")
process.selectedPatTaus.cut = cms.string("pt > 18. && tauID('decayModeFindingNewDMs')> 0.5")
process.selectedPatPhotons.cut = cms.string("")
from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection
from PhysicsTools.PatAlgos.slimming.applySubstructure_cff import applySubstructure
applySubstructure( process )
#
from PhysicsTools.PatAlgos.tools.trigTools import switchOnTriggerStandAlone
switchOnTriggerStandAlone( process, outputModule = '' )
process.patTrigger.packTriggerPathNames = cms.bool(True)
#
# apply type I + other PFMEt corrections to pat::MET object
# and estimate systematic uncertainties on MET
from PhysicsTools.PatUtils.tools.runMETCorrectionsAndUncertainties import runMetCorAndUncForMiniAODProduction
runMetCorAndUncForMiniAODProduction(process, metType="PF",
jetCollUnskimmed="patJets")
#caloMET computation
from PhysicsTools.PatAlgos.tools.metTools import addMETCollection
addMETCollection(process,
labelName = "patCaloMet",
metSource = "caloMetM"
)
#noHF pfMET =========
task = getPatAlgosToolsTask(process)
process.noHFCands = cms.EDFilter("GenericPFCandidateSelector",
src=cms.InputTag("particleFlow"),
cut=cms.string("abs(pdgId)!=1 && abs(pdgId)!=2 && abs(eta)<3.0")
)
task.add(process.noHFCands)
runMetCorAndUncForMiniAODProduction(process,
pfCandColl=cms.InputTag("noHFCands"),
recoMetFromPFCs=True, #needed for HF removal
jetSelection="pt>15 && abs(eta)<3.",
postfix="NoHF"
)
process.load('PhysicsTools.PatAlgos.slimming.slimmedMETs_cfi')
task.add(process.slimmedMETs)
addToProcessAndTask('slimmedMETsNoHF', process.slimmedMETs.clone(), process, task)
process.slimmedMETsNoHF.src = cms.InputTag("patMETsNoHF")
process.slimmedMETsNoHF.rawVariation = cms.InputTag("patPFMetNoHF")
process.slimmedMETsNoHF.t1Uncertainties = cms.InputTag("patPFMetT1%sNoHF")
process.slimmedMETsNoHF.t01Variation = cms.InputTag("patPFMetT0pcT1NoHF")
process.slimmedMETsNoHF.t1SmearedVarsAndUncs = cms.InputTag("patPFMetT1Smear%sNoHF")
process.slimmedMETsNoHF.tXYUncForRaw = cms.InputTag("patPFMetTxyNoHF")
process.slimmedMETsNoHF.tXYUncForT1 = cms.InputTag("patPFMetT1TxyNoHF")
process.slimmedMETsNoHF.tXYUncForT01 = cms.InputTag("patPFMetT0pcT1TxyNoHF")
process.slimmedMETsNoHF.tXYUncForT1Smear = cms.InputTag("patPFMetT1SmearTxyNoHF")
process.slimmedMETsNoHF.tXYUncForT01Smear = cms.InputTag("patPFMetT0pcT1SmearTxyNoHF")
del process.slimmedMETsNoHF.caloMET
# ================== NoHF pfMET
# ================== CHSMET
process.CHSCands = cms.EDFilter("CandPtrSelector",
src=cms.InputTag("packedPFCandidates"),
cut=cms.string("fromPV(0) > 0")
)
task.add(process.CHSCands)
process.pfMetCHS = cms.EDProducer("PFMETProducer",
src = cms.InputTag("CHSCands"),
alias = cms.string('pfMet'),
globalThreshold = cms.double(0.0),
calculateSignificance = cms.bool(False),
)
task.add(process.pfMetCHS)
addMETCollection(process,
labelName = "patCHSMet",
metSource = "pfMetCHS"
)
process.patCHSMet.computeMETSignificance = cms.bool(False)
# ================== CHSMET
# ================== TrkMET
process.TrkCands = cms.EDFilter("CandPtrSelector",
src=cms.InputTag("packedPFCandidates"),
cut=cms.string("charge()!=0 && pvAssociationQuality()>=4 && vertexRef().key()==0")
)
task.add(process.TrkCands)
process.pfMetTrk = cms.EDProducer("PFMETProducer",
src = cms.InputTag("TrkCands"),
alias = cms.string('pfMet'),
globalThreshold = cms.double(0.0),
calculateSignificance = cms.bool(False),
)
task.add(process.pfMetTrk)
addMETCollection(process,
labelName = "patTrkMet",
metSource = "pfMetTrk"
)
process.patTrkMet.computeMETSignificance = cms.bool(False)
# ================== TrkMET
## PU JetID
process.load("RecoJets.JetProducers.PileupJetID_cfi")
task.add(process.pileUpJetIDTask)
process.patJets.userData.userFloats.src = [ cms.InputTag("pileupJetId:fullDiscriminant"), ]
process.patJets.userData.userInts.src = [ cms.InputTag("pileupJetId:fullId"), ]
## Quark Gluon Likelihood
process.load('RecoJets.JetProducers.QGTagger_cfi')
task.add(process.QGTaggerTask)
process.patJets.userData.userFloats.src += [ cms.InputTag('QGTagger:qgLikelihood'), ]
## DeepCSV meta discriminators (simple arithmethic on output probabilities)
process.load('RecoBTag.Combined.deepFlavour_cff')
task.add(process.pfDeepCSVDiscriminatorsJetTags)
process.patJets.discriminatorSources.extend([
cms.InputTag('pfDeepCSVDiscriminatorsJetTags:BvsAll' ),
cms.InputTag('pfDeepCSVDiscriminatorsJetTags:CvsB' ),
cms.InputTag('pfDeepCSVDiscriminatorsJetTags:CvsL' ),
])
## CaloJets
process.caloJetMap = cms.EDProducer("RecoJetDeltaRValueMapProducer",
src = process.patJets.jetSource,
matched = cms.InputTag("ak4CaloJets"),
distMax = cms.double(0.4),
values = cms.vstring('pt','emEnergyFraction'),
valueLabels = cms.vstring('pt','emEnergyFraction'),
lazyParser = cms.bool(True) )
task.add(process.caloJetMap)
process.patJets.userData.userFloats.src += [ cms.InputTag("caloJetMap:pt"), cms.InputTag("caloJetMap:emEnergyFraction") ]
#Muon object modifications
from PhysicsTools.PatAlgos.slimming.muonIsolationsPUPPI_cfi import makeInputForPUPPIIsolationMuon
makeInputForPUPPIIsolationMuon(process)
#EGM object modifications
from PhysicsTools.PatAlgos.slimming.egmIsolationsPUPPI_cfi import makeInputForPUPPIIsolationEgm
makeInputForPUPPIIsolationEgm(process)
from RecoEgamma.EgammaTools.egammaObjectModificationsInMiniAOD_cff import egamma_modifications
process.slimmedElectrons.modifierConfig.modifications = egamma_modifications
process.slimmedPhotons.modifierConfig.modifications = egamma_modifications
#VID Electron IDs
process.patElectrons.addElectronID = cms.bool(True)
electron_ids = ['RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV70_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Fall17_94X_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Fall17_94X_V2_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_noIso_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_iso_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Summer16_80X_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring16_GeneralPurpose_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring16_HZZ_V1_cff',
]
switchOnVIDElectronIdProducer(process,DataFormat.MiniAOD, task)
process.egmGsfElectronIDs.physicsObjectSrc = \
cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.electronMVAValueMapProducer.src = \
cms.InputTag('reducedEgamma','reducedGedGsfElectrons')
process.electronRegressionValueMapProducer.src = \
cms.InputTag('reducedEgamma','reducedGedGsfElectrons')
for idmod in electron_ids:
setupAllVIDIdsInModule(process,idmod,setupVIDElectronSelection,None,False,task)
#heepIDVarValueMaps only exists if HEEP V6.1 or HEEP 7.0 ID has already been loaded
if hasattr(process,'heepIDVarValueMaps'):
process.heepIDVarValueMaps.elesMiniAOD = cms.InputTag('reducedEgamma','reducedGedGsfElectrons')
#force HEEP to use miniAOD (otherwise it'll detect the AOD)
process.heepIDVarValueMaps.dataFormat = cms.int32(2)
#add the HEEP trk isol to the slimmed electron, add it to the first FromFloatValMap modifier
for pset in process.slimmedElectrons.modifierConfig.modifications:
if pset.hasParameter("modifierName") and pset.modifierName == cms.string('EGExtraInfoModifierFromFloatValueMaps'):
pset.electron_config.heepTrkPtIso = cms.InputTag("heepIDVarValueMaps","eleTrkPtIso")
break
#VID Photon IDs
process.patPhotons.addPhotonID = cms.bool(True)
photon_ids = ['RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Fall17_94X_V1_TrueVtx_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Fall17_94X_V1_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Fall17_94X_V1p1_cff',
'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring16_V2p2_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Spring16_nonTrig_V1_cff']
switchOnVIDPhotonIdProducer(process,DataFormat.AOD, task)
process.egmPhotonIsolation.srcToIsolate = \
cms.InputTag("reducedEgamma","reducedGedPhotons")
for iPSet in process.egmPhotonIsolation.isolationConeDefinitions:
iPSet.particleBasedIsolation = cms.InputTag("reducedEgamma","reducedPhotonPfCandMap")
process.egmPhotonIDs.physicsObjectSrc = \
cms.InputTag("reducedEgamma","reducedGedPhotons")
process.photonIDValueMapProducer.src = \
cms.InputTag("reducedEgamma","reducedGedPhotons")
process.photonRegressionValueMapProducer.src = \
cms.InputTag("reducedEgamma","reducedGedPhotons")
process.photonIDValueMapProducer.particleBasedIsolation = \
cms.InputTag("reducedEgamma","reducedPhotonPfCandMap")
process.photonMVAValueMapProducer.src = \
cms.InputTag('reducedEgamma','reducedGedPhotons')
for idmod in photon_ids:
setupAllVIDIdsInModule(process,idmod,setupVIDPhotonSelection,None,False,task)
#add the cut base IDs bitmaps of which cuts passed
from RecoEgamma.EgammaTools.egammaObjectModifications_tools import makeVIDBitsModifier
egamma_modifications.append(makeVIDBitsModifier(process,"egmGsfElectronIDs","egmPhotonIDs"))
#-- Adding boosted taus
from RecoTauTag.Configuration.boostedHPSPFTaus_cfi import addBoostedTaus
addBoostedTaus(process)
process.load("RecoTauTag.Configuration.RecoPFTauTag_cff")
process.load("RecoTauTag.Configuration.HPSPFTaus_cff")
#-- Adding customization for 94X 2017 legacy reMniAOD
from Configuration.Eras.Modifier_run2_miniAOD_94XFall17_cff import run2_miniAOD_94XFall17
_makePatTausTaskWithRetrainedMVATauID = process.makePatTausTask.copy()
_makePatTausTaskWithRetrainedMVATauID.add(process.hpsPFTauDiscriminationByIsolationMVArun2v1DBoldDMwLTTask)
run2_miniAOD_94XFall17.toReplaceWith(
process.makePatTausTask, _makePatTausTaskWithRetrainedMVATauID
)
#-- Adding customization for 80X 2016 legacy reMiniAOD
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
_makePatTausTaskWithTauReReco = process.makePatTausTask.copy()
_makePatTausTaskWithTauReReco.add(process.PFTauTask)
run2_miniAOD_80XLegacy.toReplaceWith(
process.makePatTausTask, _makePatTausTaskWithTauReReco
)
# Adding puppi jets
if not hasattr(process, 'ak4PFJetsPuppi'): #MM: avoid confilct with substructure call
process.load('RecoJets.JetProducers.ak4PFJetsPuppi_cfi')
task.add(process.ak4PFJets)
task.add(process.ak4PFJetsPuppi)
process.ak4PFJetsPuppi.doAreaFastjet = True # even for standard ak4PFJets this is overwritten in RecoJets/Configuration/python/RecoPFJets_cff
from RecoJets.JetAssociationProducers.j2tParametersVX_cfi import j2tParametersVX
process.ak4PFJetsPuppiTracksAssociatorAtVertex = cms.EDProducer("JetTracksAssociatorAtVertex",
j2tParametersVX,
jets = cms.InputTag("ak4PFJetsPuppi")
)
task.add(process.ak4PFJetsPuppiTracksAssociatorAtVertex)
process.patJetPuppiCharge = cms.EDProducer("JetChargeProducer",
src = cms.InputTag("ak4PFJetsPuppiTracksAssociatorAtVertex"),
var = cms.string('Pt'),
exp = cms.double(1.0)
)
task.add(process.patJetPuppiCharge)
noDeepFlavourDiscriminators = [x.value() for x in process.patJets.discriminatorSources if not "DeepFlavour" in x.value()]
addJetCollection(process, postfix = "", labelName = 'Puppi', jetSource = cms.InputTag('ak4PFJetsPuppi'),
jetCorrections = ('AK4PFPuppi', ['L2Relative', 'L3Absolute'], ''),
pfCandidates = cms.InputTag("particleFlow"),
algo= 'AK', rParam = 0.4, btagDiscriminators = noDeepFlavourDiscriminators
)
process.patJetGenJetMatchPuppi.matched = 'slimmedGenJets'
process.patJetsPuppi.jetChargeSource = cms.InputTag("patJetPuppiCharge")
process.selectedPatJetsPuppi.cut = cms.string("pt > 15")
from PhysicsTools.PatAlgos.slimming.applyDeepBtagging_cff import applyDeepBtagging
applyDeepBtagging( process )
addToProcessAndTask('slimmedJetsPuppiNoMultiplicities', process.slimmedJetsNoDeepFlavour.clone(), process, task)
process.slimmedJetsPuppiNoMultiplicities.src = cms.InputTag("selectedPatJetsPuppi")
process.slimmedJetsPuppiNoMultiplicities.packedPFCandidates = cms.InputTag("packedPFCandidates")
from PhysicsTools.PatAlgos.patPuppiJetSpecificProducer_cfi import patPuppiJetSpecificProducer
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
process.patPuppiJetSpecificProducer = patPuppiJetSpecificProducer.clone(
src=cms.InputTag("slimmedJetsPuppiNoMultiplicities"),
)
task.add(process.patPuppiJetSpecificProducer)
updateJetCollection(
process,
labelName = 'PuppiJetSpecific',
jetSource = cms.InputTag('slimmedJetsPuppiNoMultiplicities'),
)
process.updatedPatJetsPuppiJetSpecific.userData.userFloats.src = ['patPuppiJetSpecificProducer:puppiMultiplicity', 'patPuppiJetSpecificProducer:neutralPuppiMultiplicity', 'patPuppiJetSpecificProducer:neutralHadronPuppiMultiplicity', 'patPuppiJetSpecificProducer:photonPuppiMultiplicity', 'patPuppiJetSpecificProducer:HFHadronPuppiMultiplicity', 'patPuppiJetSpecificProducer:HFEMPuppiMultiplicity' ]
process.slimmedJetsPuppi = process.selectedUpdatedPatJetsPuppiJetSpecific.clone()
delattr(process, 'selectedUpdatedPatJetsPuppiJetSpecific')
task.add(process.slimmedJetsPuppi)
## puppi met
from PhysicsTools.PatAlgos.slimming.puppiForMET_cff import makePuppies
makePuppies( process );
runMetCorAndUncForMiniAODProduction(process, metType="Puppi",
pfCandColl=cms.InputTag("puppiForMET"),
jetCollUnskimmed="slimmedJetsPuppi",
recoMetFromPFCs=True,
jetFlavor="AK4PFPuppi",
postfix="Puppi"
)
process.load('PhysicsTools.PatAlgos.slimming.slimmedMETs_cfi')
task.add(process.slimmedMETs)
addToProcessAndTask('slimmedMETsPuppi', process.slimmedMETs.clone(), process, task)
process.slimmedMETsPuppi.src = cms.InputTag("patMETsPuppi")
process.slimmedMETsPuppi.rawVariation = cms.InputTag("patPFMetPuppi")
process.slimmedMETsPuppi.t1Uncertainties = cms.InputTag("patPFMetT1%sPuppi")
process.slimmedMETsPuppi.t01Variation = cms.InputTag("patPFMetT0pcT1Puppi")
process.slimmedMETsPuppi.t1SmearedVarsAndUncs = cms.InputTag("patPFMetT1Smear%sPuppi")
process.slimmedMETsPuppi.tXYUncForRaw = cms.InputTag("patPFMetTxyPuppi")
process.slimmedMETsPuppi.tXYUncForT1 = cms.InputTag("patPFMetT1TxyPuppi")
process.slimmedMETsPuppi.tXYUncForT01 = cms.InputTag("patPFMetT0pcT1TxyPuppi")
process.slimmedMETsPuppi.tXYUncForT1Smear = cms.InputTag("patPFMetT1SmearTxyPuppi")
process.slimmedMETsPuppi.tXYUncForT01Smear = cms.InputTag("patPFMetT0pcT1SmearTxyPuppi")
del process.slimmedMETsPuppi.caloMET
# add DetIdAssociatorRecords to EventSetup (for isolatedTracks)
process.load("TrackingTools.TrackAssociator.DetIdAssociatorESProducer_cff")
# EGamma objects from HGCal are not yet in GED
# so add companion collections for Phase-II MiniAOD production
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
process.load("RecoEgamma.EgammaTools.slimmedEgammaFromMultiCl_cff")
phase2_hgcal.toModify(task, func=lambda t: t.add(process.slimmedEgammaFromMultiClTask))
def miniAOD_customizeCommon(process):
process.patMuons.isoDeposits = cms.PSet()
process.patElectrons.isoDeposits = cms.PSet()
process.patTaus.isoDeposits = cms.PSet()
process.patPhotons.isoDeposits = cms.PSet()
#
process.patMuons.embedTrack = True # used for IDs
process.patMuons.embedCombinedMuon = True # used for IDs
process.patMuons.embedMuonBestTrack = True # used for IDs
process.patMuons.embedStandAloneMuon = True # maybe?
process.patMuons.embedPickyMuon = False # no, use best track
process.patMuons.embedTpfmsMuon = False # no, use best track
process.patMuons.embedDytMuon = False # no, use best track
#
# disable embedding of electron and photon associated objects already stored by the ReducedEGProducer
process.patElectrons.embedGsfElectronCore = False ## process.patElectrons.embed in AOD externally stored gsf electron core
process.patElectrons.embedSuperCluster = False ## process.patElectrons.embed in AOD externally stored supercluster
process.patElectrons.embedPflowSuperCluster = False ## process.patElectrons.embed in AOD externally stored supercluster
process.patElectrons.embedSeedCluster = False ## process.patElectrons.embed in AOD externally stored the electron's seedcluster
process.patElectrons.embedBasicClusters = False ## process.patElectrons.embed in AOD externally stored the electron's basic clusters
process.patElectrons.embedPreshowerClusters = False ## process.patElectrons.embed in AOD externally stored the electron's preshower clusters
process.patElectrons.embedPflowBasicClusters = False ## process.patElectrons.embed in AOD externally stored the electron's pflow basic clusters
process.patElectrons.embedPflowPreshowerClusters = False ## process.patElectrons.embed in AOD externally stored the electron's pflow preshower clusters
process.patElectrons.embedRecHits = False ## process.patElectrons.embed in AOD externally stored the RecHits - can be called from the PATElectronProducer
process.patElectrons.electronSource = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.patElectrons.electronIDSources = cms.PSet(
# configure many IDs as InputTag <someName> = <someTag> you
# can comment out those you don't want to save some disk space
eidRobustLoose = cms.InputTag("reducedEgamma","eidRobustLoose"),
eidRobustTight = cms.InputTag("reducedEgamma","eidRobustTight"),
eidLoose = cms.InputTag("reducedEgamma","eidLoose"),
eidTight = cms.InputTag("reducedEgamma","eidTight"),
eidRobustHighEnergy = cms.InputTag("reducedEgamma","eidRobustHighEnergy"),
)
process.patElectrons.addPFClusterIso = cms.bool(True)
#add puppi isolation in miniAOD
process.patElectrons.addPuppiIsolation = cms.bool(True)
process.patElectrons.puppiIsolationChargedHadrons = cms.InputTag("egmElectronPUPPIIsolation","h+-DR030-BarVeto000-EndVeto001")
process.patElectrons.puppiIsolationNeutralHadrons = cms.InputTag("egmElectronPUPPIIsolation","h0-DR030-BarVeto000-EndVeto000")
process.patElectrons.puppiIsolationPhotons = cms.InputTag("egmElectronPUPPIIsolation","gamma-DR030-BarVeto000-EndVeto008")
process.patElectrons.puppiNoLeptonsIsolationChargedHadrons = cms.InputTag("egmElectronPUPPINoLeptonsIsolation","h+-DR030-BarVeto000-EndVeto001")
process.patElectrons.puppiNoLeptonsIsolationNeutralHadrons = cms.InputTag("egmElectronPUPPINoLeptonsIsolation","h0-DR030-BarVeto000-EndVeto000")
process.patElectrons.puppiNoLeptonsIsolationPhotons = cms.InputTag("egmElectronPUPPINoLeptonsIsolation","gamma-DR030-BarVeto000-EndVeto008")
process.patElectrons.ecalPFClusterIsoMap = cms.InputTag("reducedEgamma", "eleEcalPFClusIso")
process.patElectrons.hcalPFClusterIsoMap = cms.InputTag("reducedEgamma", "eleHcalPFClusIso")
process.elPFIsoDepositChargedPAT.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.elPFIsoDepositChargedAllPAT.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.elPFIsoDepositNeutralPAT.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.elPFIsoDepositGammaPAT.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.elPFIsoDepositPUPAT.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
#
process.patPhotons.embedSuperCluster = False ## whether to process.patPhotons.embed in AOD externally stored supercluster
process.patPhotons.embedSeedCluster = False ## process.patPhotons.embed in AOD externally stored the photon's seedcluster
process.patPhotons.embedBasicClusters = False ## process.patPhotons.embed in AOD externally stored the photon's basic clusters
process.patPhotons.embedPreshowerClusters = False ## process.patPhotons.embed in AOD externally stored the photon's preshower clusters
process.patPhotons.embedRecHits = False ## process.patPhotons.embed in AOD externally stored the RecHits - can be called from the PATPhotonProducer
process.patPhotons.addPFClusterIso = cms.bool(True)
#add puppi isolation in miniAOD
process.patPhotons.addPuppiIsolation = cms.bool(True)
process.patPhotons.puppiIsolationChargedHadrons = cms.InputTag("egmPhotonPUPPIIsolation","h+-DR030-")
process.patPhotons.puppiIsolationNeutralHadrons = cms.InputTag("egmPhotonPUPPIIsolation","h0-DR030-")
process.patPhotons.puppiIsolationPhotons = cms.InputTag("egmPhotonPUPPIIsolation","gamma-DR030-")
process.patPhotons.ecalPFClusterIsoMap = cms.InputTag("reducedEgamma", "phoEcalPFClusIso")
process.patPhotons.hcalPFClusterIsoMap = cms.InputTag("reducedEgamma", "phoHcalPFClusIso")
process.patPhotons.photonSource = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.patPhotons.electronSource = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.patPhotons.photonIDSources = cms.PSet(
PhotonCutBasedIDLoose = cms.InputTag('reducedEgamma',
'PhotonCutBasedIDLoose'),
PhotonCutBasedIDTight = cms.InputTag('reducedEgamma',
'PhotonCutBasedIDTight')
)
process.phPFIsoDepositChargedPAT.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.phPFIsoDepositChargedAllPAT.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.phPFIsoDepositNeutralPAT.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.phPFIsoDepositGammaPAT.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.phPFIsoDepositPUPAT.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
#
process.selectedPatJets.cut = cms.string("pt > 10")
process.selectedPatMuons.cut = cms.string("pt > 5 || isPFMuon || (pt > 3 && (isGlobalMuon || isStandAloneMuon || numberOfMatches > 0 || muonID('RPCMuLoose')))")
process.selectedPatElectrons.cut = cms.string("")
process.selectedPatTaus.cut = cms.string("pt > 18. && tauID('decayModeFindingNewDMs')> 0.5")
process.selectedPatPhotons.cut = cms.string("")
from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection
from PhysicsTools.PatAlgos.slimming.applySubstructure_cff import applySubstructure
applySubstructure( process )
#
from PhysicsTools.PatAlgos.tools.trigTools import switchOnTriggerStandAlone
switchOnTriggerStandAlone( process, outputModule = '' )
process.patTrigger.packTriggerPathNames = cms.bool(True)
#
# apply type I + other PFMEt corrections to pat::MET object
# and estimate systematic uncertainties on MET
from PhysicsTools.PatUtils.tools.runMETCorrectionsAndUncertainties import runMetCorAndUncForMiniAODProduction
runMetCorAndUncForMiniAODProduction(process, metType="PF",
jetCollUnskimmed="patJets")
#caloMET computation
from PhysicsTools.PatAlgos.tools.metTools import addMETCollection
addMETCollection(process,
labelName = "patCaloMet",
metSource = "caloMetM"
)
#noHF pfMET =========
task = getPatAlgosToolsTask(process)
process.noHFCands = cms.EDFilter("GenericPFCandidateSelector",
src=cms.InputTag("particleFlow"),
cut=cms.string("abs(pdgId)!=1 && abs(pdgId)!=2 && abs(eta)<3.0")
)
task.add(process.noHFCands)
runMetCorAndUncForMiniAODProduction(process,
pfCandColl=cms.InputTag("noHFCands"),
recoMetFromPFCs=True, #needed for HF removal
jetSelection="pt>15 && abs(eta)<3.",
postfix="NoHF"
)
process.load('PhysicsTools.PatAlgos.slimming.slimmedMETs_cfi')
task.add(process.slimmedMETs)
addToProcessAndTask('slimmedMETsNoHF', process.slimmedMETs.clone(), process, task)
process.slimmedMETsNoHF.src = cms.InputTag("patMETsNoHF")
process.slimmedMETsNoHF.rawVariation = cms.InputTag("patPFMetNoHF")
process.slimmedMETsNoHF.t1Uncertainties = cms.InputTag("patPFMetT1%sNoHF")
process.slimmedMETsNoHF.t01Variation = cms.InputTag("patPFMetT0pcT1NoHF")
process.slimmedMETsNoHF.t1SmearedVarsAndUncs = cms.InputTag("patPFMetT1Smear%sNoHF")
process.slimmedMETsNoHF.tXYUncForRaw = cms.InputTag("patPFMetTxyNoHF")
process.slimmedMETsNoHF.tXYUncForT1 = cms.InputTag("patPFMetT1TxyNoHF")
process.slimmedMETsNoHF.tXYUncForT01 = cms.InputTag("patPFMetT0pcT1TxyNoHF")
process.slimmedMETsNoHF.tXYUncForT1Smear = cms.InputTag("patPFMetT1SmearTxyNoHF")
process.slimmedMETsNoHF.tXYUncForT01Smear = cms.InputTag("patPFMetT0pcT1SmearTxyNoHF")
del process.slimmedMETsNoHF.caloMET
# ================== NoHF pfMET
#keep this after all addJetCollections otherwise it will attempt computing them also for stuf with no taginfos
#Some useful BTAG vars
if not hasattr( process, 'pfImpactParameterTagInfos' ):
process.load('RecoBTag.ImpactParameter.pfImpactParameterTagInfos_cfi')
task.add(process.pfImpactParameterTagInfos)
if not hasattr( process, 'pfSecondaryVertexTagInfos' ):
process.load('RecoBTag.SecondaryVertex.pfSecondaryVertexTagInfos_cfi')
task.add(process.pfSecondaryVertexTagInfos)
process.patJets.userData.userFunctions = cms.vstring(
'?(tagInfoCandSecondaryVertex("pfSecondaryVertex").nVertices()>0)?(tagInfoCandSecondaryVertex("pfSecondaryVertex").secondaryVertex(0).p4.M):(0)',
'?(tagInfoCandSecondaryVertex("pfSecondaryVertex").nVertices()>0)?(tagInfoCandSecondaryVertex("pfSecondaryVertex").secondaryVertex(0).numberOfSourceCandidatePtrs):(0)',
'?(tagInfoCandSecondaryVertex("pfSecondaryVertex").nVertices()>0)?(tagInfoCandSecondaryVertex("pfSecondaryVertex").flightDistance(0).value):(0)',
'?(tagInfoCandSecondaryVertex("pfSecondaryVertex").nVertices()>0)?(tagInfoCandSecondaryVertex("pfSecondaryVertex").flightDistance(0).significance):(0)',
'?(tagInfoCandSecondaryVertex("pfSecondaryVertex").nVertices()>0)?(tagInfoCandSecondaryVertex("pfSecondaryVertex").secondaryVertex(0).p4.x):(0)',
'?(tagInfoCandSecondaryVertex("pfSecondaryVertex").nVertices()>0)?(tagInfoCandSecondaryVertex("pfSecondaryVertex").secondaryVertex(0).p4.y):(0)',
'?(tagInfoCandSecondaryVertex("pfSecondaryVertex").nVertices()>0)?(tagInfoCandSecondaryVertex("pfSecondaryVertex").secondaryVertex(0).p4.z):(0)',
'?(tagInfoCandSecondaryVertex("pfSecondaryVertex").nVertices()>0)?(tagInfoCandSecondaryVertex("pfSecondaryVertex").secondaryVertex(0).vertex.x):(0)',
'?(tagInfoCandSecondaryVertex("pfSecondaryVertex").nVertices()>0)?(tagInfoCandSecondaryVertex("pfSecondaryVertex").secondaryVertex(0).vertex.y):(0)',
'?(tagInfoCandSecondaryVertex("pfSecondaryVertex").nVertices()>0)?(tagInfoCandSecondaryVertex("pfSecondaryVertex").secondaryVertex(0).vertex.z):(0)',
)
process.patJets.userData.userFunctionLabels = cms.vstring('vtxMass','vtxNtracks','vtx3DVal','vtx3DSig','vtxPx','vtxPy','vtxPz','vtxPosX','vtxPosY','vtxPosZ')
process.patJets.tagInfoSources = cms.VInputTag(cms.InputTag("pfSecondaryVertexTagInfos"))
process.patJets.addTagInfos = cms.bool(True)
## Legacy tight b-tag track selection
## (this will run below-specified taggers with the tight b-tag track selection enabled
## and will add an extra set of b-tag discriminators to 'selectedPatJets'
## with the 'tight' prefix added to the usual discriminator names)
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
updateJetCollection(
process,
jetSource = cms.InputTag('selectedPatJets'),
## updateJetCollection defaults to MiniAOD inputs. Here, this needs to be changed to RECO/AOD inputs
pvSource = cms.InputTag('offlinePrimaryVertices'),
pfCandidates = cms.InputTag('particleFlow'),
svSource = cms.InputTag('inclusiveCandidateSecondaryVertices'),
muSource = cms.InputTag('muons'),
elSource = cms.InputTag('gedGsfElectrons'),
##
jetCorrections = ('AK4PFchs', ['L1FastJet', 'L2Relative', 'L3Absolute'], ''),
btagDiscriminators = ["pfCombinedSecondaryVertexV2BJetTags", "pfCombinedInclusiveSecondaryVertexV2BJetTags",
"pfCombinedCvsLJetTags", "pfCombinedCvsBJetTags"],
runIVF = True,
tightBTagNTkHits = True,
btagPrefix = 'tight',
postfix = 'BTAG' # added to avoid problems with unrunnable schedule
)
#
## PU JetID
process.load("RecoJets.JetProducers.PileupJetID_cfi")
task.add(process.pileupJetId)
task.add(process.pileupJetIdCalculator)
task.add(process.pileupJetIdEvaluator)
process.patJets.userData.userFloats.src = [ cms.InputTag("pileupJetId:fullDiscriminant"), ]
process.patJets.userData.userInts.src = [ cms.InputTag("pileupJetId:fullId"), ]
## CaloJets
process.caloJetMap = cms.EDProducer("RecoJetDeltaRValueMapProducer",
src = process.patJets.jetSource,
matched = cms.InputTag("ak4CaloJets"),
distMax = cms.double(0.4),
values = cms.vstring('pt','emEnergyFraction'),
valueLabels = cms.vstring('pt','emEnergyFraction'),
lazyParser = cms.bool(True) )
task.add(process.caloJetMap)
process.patJets.userData.userFloats.src += [ cms.InputTag("caloJetMap:pt"), cms.InputTag("caloJetMap:emEnergyFraction") ]
#EGM object modifications
from PhysicsTools.PatAlgos.slimming.egmIsolationsPUPPI_cfi import makeInputForPUPPIIsolationEgm
makeInputForPUPPIIsolationEgm(process)
from RecoEgamma.EgammaTools.egammaObjectModificationsInMiniAOD_cff import egamma_modifications
process.slimmedElectrons.modifierConfig.modifications = egamma_modifications
process.slimmedPhotons.modifierConfig.modifications = egamma_modifications
#VID Electron IDs
electron_ids = ['RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_PHYS14_PU20bx25_V2_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Spring15_25ns_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Spring15_50ns_V2_cff',
'RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV60_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_25ns_nonTrig_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_25ns_Trig_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_50ns_Trig_V1_cff']
switchOnVIDElectronIdProducer(process,DataFormat.MiniAOD, task)
process.egmGsfElectronIDs.physicsObjectSrc = \
cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.electronMVAValueMapProducer.src = \
cms.InputTag('reducedEgamma','reducedGedGsfElectrons')
process.electronRegressionValueMapProducer.src = \
cms.InputTag('reducedEgamma','reducedGedGsfElectrons')
for idmod in electron_ids:
setupAllVIDIdsInModule(process,idmod,setupVIDElectronSelection,None,False,task)
#heepIDVarValueMaps only exists if HEEP V6.1 or HEEP 7.0 ID has already been loaded
if hasattr(process,'heepIDVarValueMaps'):
process.heepIDVarValueMaps.elesMiniAOD = cms.InputTag('reducedEgamma','reducedGedGsfElectrons')
#force HEEP to use miniAOD (otherwise it'll detect the AOD)
process.heepIDVarValueMaps.dataFormat = cms.int32(2)
#VID Photon IDs
photon_ids = ['RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring15_25ns_V1_cff',
'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring15_50ns_V1_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Spring15_25ns_nonTrig_V2p1_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Spring15_50ns_nonTrig_V2p1_cff']
switchOnVIDPhotonIdProducer(process,DataFormat.MiniAOD, task)
process.egmPhotonIDs.physicsObjectSrc = \
cms.InputTag("reducedEgamma","reducedGedPhotons")
process.photonIDValueMapProducer.src = \
cms.InputTag("reducedEgamma","reducedGedPhotons")
process.photonRegressionValueMapProducer.src = \
cms.InputTag("reducedEgamma","reducedGedPhotons")
process.photonIDValueMapProducer.particleBasedIsolation = \
cms.InputTag("reducedEgamma","reducedPhotonPfCandMap")
process.photonMVAValueMapProducer.src = \
cms.InputTag('reducedEgamma','reducedGedPhotons')
for idmod in photon_ids:
setupAllVIDIdsInModule(process,idmod,setupVIDPhotonSelection,None,False,task)
#---------------------------------------------------------------------------
#Adding Boosted Subjets taus
from RecoTauTag.Configuration.boostedHPSPFTaus_cfi import addBoostedTaus
addBoostedTaus(process)
#---------------------------------------------------------------------------
# Adding puppi jets
process.load('RecoJets.JetProducers.ak4PFJetsPuppi_cfi')
task.add(process.ak4PFJets)
task.add(process.ak4PFJetsPuppi)
process.ak4PFJetsPuppi.doAreaFastjet = True # even for standard ak4PFJets this is overwritten in RecoJets/Configuration/python/RecoPFJets_cff
from RecoJets.JetAssociationProducers.j2tParametersVX_cfi import j2tParametersVX
process.ak4PFJetsPuppiTracksAssociatorAtVertex = cms.EDProducer("JetTracksAssociatorAtVertex",
j2tParametersVX,
jets = cms.InputTag("ak4PFJetsPuppi")
)
task.add(process.ak4PFJetsPuppiTracksAssociatorAtVertex)
process.patJetPuppiCharge = cms.EDProducer("JetChargeProducer",
src = cms.InputTag("ak4PFJetsPuppiTracksAssociatorAtVertex"),
var = cms.string('Pt'),
exp = cms.double(1.0)
)
task.add(process.patJetPuppiCharge)
addJetCollection(process, postfix = "", labelName = 'Puppi', jetSource = cms.InputTag('ak4PFJetsPuppi'),
jetCorrections = ('AK4PFPuppi', ['L2Relative', 'L3Absolute'], ''),
algo= 'AK', rParam = 0.4, btagDiscriminators = map(lambda x: x.value() ,process.patJets.discriminatorSources)
)
process.patJetGenJetMatchPuppi.matched = 'slimmedGenJets'
process.patJetsPuppi.jetChargeSource = cms.InputTag("patJetPuppiCharge")
process.selectedPatJetsPuppi.cut = cms.string("pt > 15")
process.load('PhysicsTools.PatAlgos.slimming.slimmedJets_cfi')
task.add(process.slimmedJets)
task.add(process.slimmedJetsAK8)
addToProcessAndTask('slimmedJetsPuppi', process.slimmedJets.clone(), process, task)
process.slimmedJetsPuppi.src = cms.InputTag("selectedPatJetsPuppi")
process.slimmedJetsPuppi.packedPFCandidates = cms.InputTag("packedPFCandidates")
## puppi met
from PhysicsTools.PatAlgos.slimming.puppiForMET_cff import makePuppies
makePuppies( process );
runMetCorAndUncForMiniAODProduction(process, metType="Puppi",
pfCandColl=cms.InputTag("puppiForMET"),
jetCollUnskimmed="slimmedJetsPuppi",
recoMetFromPFCs=True,
jetFlavor="AK4PFPuppi",
postfix="Puppi"
)
process.load('PhysicsTools.PatAlgos.slimming.slimmedMETs_cfi')
task.add(process.slimmedMETs)
addToProcessAndTask('slimmedMETsPuppi', process.slimmedMETs.clone(), process, task)
process.slimmedMETsPuppi.src = cms.InputTag("patMETsPuppi")
process.slimmedMETsPuppi.rawVariation = cms.InputTag("patPFMetPuppi")
process.slimmedMETsPuppi.t1Uncertainties = cms.InputTag("patPFMetT1%sPuppi")
process.slimmedMETsPuppi.t01Variation = cms.InputTag("patPFMetT0pcT1Puppi")
process.slimmedMETsPuppi.t1SmearedVarsAndUncs = cms.InputTag("patPFMetT1Smear%sPuppi")
process.slimmedMETsPuppi.tXYUncForRaw = cms.InputTag("patPFMetTxyPuppi")
process.slimmedMETsPuppi.tXYUncForT1 = cms.InputTag("patPFMetT1TxyPuppi")
process.slimmedMETsPuppi.tXYUncForT01 = cms.InputTag("patPFMetT0pcT1TxyPuppi")
process.slimmedMETsPuppi.tXYUncForT1Smear = cms.InputTag("patPFMetT1SmearTxyPuppi")
process.slimmedMETsPuppi.tXYUncForT01Smear = cms.InputTag("patPFMetT0pcT1SmearTxyPuppi")
del process.slimmedMETsPuppi.caloMET
)
process.es_prefer_jer = cms.ESPrefer("PoolDBESSource", "jer")
################ end sqlite connection
#### RECOMPUTE JEC From GT ###
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
jecLevels = ["L1FastJet", "L2Relative", "L3Absolute"]
if options.isData:
jecLevels = ["L1FastJet", "L2Relative", "L3Absolute", "L2L3Residual"]
updateJetCollection(
process,
jetSource=process.nero.jets,
labelName="UpdatedJEC",
jetCorrections=("AK4PFchs", cms.vstring(jecLevels), "None"), # Do not forget 'L2L3Residual' on data!
)
updateJetCollection(
process,
jetSource=process.nero.chsAK8,
labelName="UpdatedJECAK8",
jetCorrections=("AK8PFchs", cms.vstring(jecLevels), "None"), # Do not forget 'L2L3Residual' on data!
)
print "-> Updating the jets collection to run on to 'updatedPatJetsUpdatedJEC' with the new jec in the GT"
process.nero.jets = cms.InputTag("updatedPatJetsUpdatedJEC")
process.nero.chsAK8 = cms.InputTag("updatedPatJetsUpdatedJECAK8")
process.jecSequence = cms.Sequence(
process.patJetCorrFactorsUpdatedJEC
def makeTreeFromMiniAOD(
process,
outfile,
reportfreq=10,
dataset="",
globaltag="",
numevents=-1,
lostlepton=False,
geninfo=False,
tagname="RECO",
jsonfile="",
jecfile="",
residual=False,
jerfile="",
pufile="",
doPDFs=False,
fastsim=False,
signal=False,
):
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
## Preamble
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_condDBv2_cff")
process.GlobalTag.globaltag = globaltag
# log output
process.load("FWCore.MessageService.MessageLogger_cfi")
process.MessageLogger.cerr.FwkReport.reportEvery = reportfreq
process.options = cms.untracked.PSet(
allowUnscheduled = cms.untracked.bool(True),
# wantSummary = cms.untracked.bool(True) # off by default
)
# files to process
import FWCore.PythonUtilities.LumiList as LumiList
process.maxEvents = cms.untracked.PSet(
input = cms.untracked.int32(numevents)
)
process.source = cms.Source("PoolSource",
fileNames = cms.untracked.vstring(dataset)
)
if len(jsonfile)>0: process.source.lumisToProcess = LumiList.LumiList(filename = jsonfile).getVLuminosityBlockRange()
# output file
process.TFileService = cms.Service("TFileService",
fileName = cms.string(outfile+".root")
)
# branches for treemaker
VectorRecoCand = cms.vstring()
VarsDouble = cms.vstring()
VarsInt = cms.vstring()
VarsBool = cms.vstring()
VectorTLorentzVector = cms.vstring()
VectorDouble = cms.vstring()
VectorString = cms.vstring()
VectorInt = cms.vstring()
VectorBool = cms.vstring()
process.Baseline = cms.Sequence()
# configure treemaker
from LeptoQuarkTreeMaker.LeptoQuarkTreeMaker.treeMaker import TreeMaker
process.LQTreeMaker2 = TreeMaker.clone(
TreeName = cms.string("SimpleTree"),
VectorRecoCand = VectorRecoCand,
VarsDouble = VarsDouble,
VarsInt = VarsInt,
VarsBool = VarsBool,
VectorTLorentzVector = VectorTLorentzVector,
VectorDouble = VectorDouble,
VectorInt = VectorInt,
VectorString = VectorString,
VectorBool = VectorBool,
)
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
## Standard producers
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
## SUSY scan info
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
## WeightProducer
## ----------------------------------------------------------------------------------------------
if geninfo:
from LeptoQuarkTreeMaker.WeightProducer.getWeightProducer_cff import getWeightProducer
process.WeightProducer = getWeightProducer(process.source.fileNames[0],fastsim and signal)
process.WeightProducer.Lumi = cms.double(1) #default: 1 pb-1 (unit value)
process.WeightProducer.FileNamePUDataDistribution = cms.string(pufile)
VarsDouble.extend(['WeightProducer:weight(Weight)','WeightProducer:xsec(CrossSection)','WeightProducer:nevents(NumEvents)',
'WeightProducer:TrueNumInteractions','WeightProducer:PUweight(puWeight)','WeightProducer:PUSysUp(puSysUp)','WeightProducer:PUSysDown(puSysDown)'])
VarsInt.extend(['WeightProducer:NumInteractions'])
## ----------------------------------------------------------------------------------------------
## PDF weights for PDF systematics
## ----------------------------------------------------------------------------------------------
if geninfo and doPDFs:
process.PDFWeights = cms.EDProducer('PDFWeightProducer')
VectorDouble.extend(['PDFWeights:PDFweights','PDFWeights:ScaleWeights'])
VectorInt.extend(['PDFWeights:PDFids'])
## ----------------------------------------------------------------------------------------------
## GenHT for stitching together MC samples
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
## PrimaryVertices
## ----------------------------------------------------------------------------------------------
process.goodVertices = cms.EDFilter("VertexSelector",
src = cms.InputTag("offlineSlimmedPrimaryVertices"),
cut = cms.string("!isFake && ndof > 4 && abs(z) < 24 && position.Rho < 2"),
filter = cms.bool(False)
)
from LeptoQuarkTreeMaker.Utils.primaryvertices_cfi import primaryvertices
process.NVtx = primaryvertices.clone(
VertexCollection = cms.InputTag('goodVertices'),
)
VarsInt.extend(['NVtx'])
# also store total number of vertices without quality checks
process.nAllVertices = primaryvertices.clone(
VertexCollection = cms.InputTag('offlineSlimmedPrimaryVertices'),
)
VarsInt.extend(['nAllVertices'])
## ----------------------------------------------------------------------------------------------
## GenParticles
## ----------------------------------------------------------------------------------------------
## JECs
## ----------------------------------------------------------------------------------------------
process.load("CondCore.DBCommon.CondDBCommon_cfi")
from CondCore.DBCommon.CondDBSetup_cfi import CondDBSetup
# default miniAOD tags
JetTag = cms.InputTag('slimmedJets')
JetAK8Tag = cms.InputTag('slimmedJetsAK8')
METTag = cms.InputTag('slimmedMETs')
# get the JECs (disabled by default)
# this requires the user to download the .db file from this twiki
# https://twiki.cern.ch/twiki/bin/viewauth/CMS/JECDataMC
if len(jecfile)>0:
#get name of JECs without any directories
JECera = jecfile.split('/')[-1]
JECPatch = cms.string('sqlite_file:'+jecfile+'.db')
if os.getenv('GC_CONF'):
JECPatch = cms.string('sqlite_file:../src/'+jecfile+'.db')
process.jec = cms.ESSource("PoolDBESSource",CondDBSetup,
connect = JECPatch,
toGet = cms.VPSet(
cms.PSet(
record = cms.string("JetCorrectionsRecord"),
tag = cms.string("JetCorrectorParametersCollection_"+JECera+"_AK4PFchs"),
label = cms.untracked.string("AK4PFchs")
),
cms.PSet(
record = cms.string("JetCorrectionsRecord"),
tag = cms.string("JetCorrectorParametersCollection_"+JECera+"_AK4PF"),
label = cms.untracked.string("AK4PF")
),
cms.PSet(
record = cms.string("JetCorrectionsRecord"),
tag = cms.string("JetCorrectorParametersCollection_"+JECera+"_AK8PFchs"),
label = cms.untracked.string("AK8PFchs")
),
)
)
process.es_prefer_jec = cms.ESPrefer("PoolDBESSource","jec")
levels = ['L1FastJet','L2Relative','L3Absolute']
if residual: levels.append('L2L3Residual')
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
updateJetCollection(
process,
jetSource = cms.InputTag('slimmedJets'),
postfix = 'UpdatedJEC',
jetCorrections = ('AK4PFchs', levels, 'None')
)
JetTag = cms.InputTag('updatedPatJetsUpdatedJEC')
# also update the corrections for AK8 jets
updateJetCollection(
process,
jetSource = cms.InputTag('slimmedJetsAK8'),
labelName = 'AK8',
postfix = 'UpdatedJEC',
jetCorrections = ('AK8PFchs', levels, 'None')
)
JetAK8Tag = cms.InputTag('updatedPatJetsAK8UpdatedJEC')
# update the MET to account for the new JECs
from PhysicsTools.PatUtils.tools.runMETCorrectionsAndUncertainties import runMetCorAndUncFromMiniAOD
runMetCorAndUncFromMiniAOD(
process,
isData=not geninfo, # controls gen met
)
METTag = cms.InputTag('slimmedMETs','',process.name_())
else:
# pointless run of MET tool because it is barely functional
from PhysicsTools.PatUtils.tools.runMETCorrectionsAndUncertainties import runMetCorAndUncFromMiniAOD
runMetCorAndUncFromMiniAOD(
process,
isData=not geninfo, # controls gen met
)
# keep jets before any further modifications for hadtau
JetTagBeforeSmearing = JetTag
# JEC uncertainty - after JECs are updated
from LeptoQuarkTreeMaker.Utils.jetuncertainty_cfi import JetUncertaintyProducer
process.jecUnc = JetUncertaintyProducer.clone(
JetTag = JetTag,
jecUncDir = cms.int32(0)
)
# JER factors - central, up, dow
from LeptoQuarkTreeMaker.Utils.smearedpatjet_cfi import SmearedPATJetProducer
process.jerFactor = SmearedPATJetProducer.clone(
src = JetTag,
variation = cms.int32(0),
store_factor = cms.bool(True)
)
process.jerFactorUp = SmearedPATJetProducer.clone(
src = JetTag,
variation = cms.int32(1),
store_factor = cms.bool(True)
)
process.jerFactorDown = SmearedPATJetProducer.clone(
src = JetTag,
variation = cms.int32(-1),
store_factor = cms.bool(True)
)
# add userfloat & update tag
from LeptoQuarkTreeMaker.LeptoQuarkTreeMaker.addJetInfo import addJetInfo
process, JetTag = addJetInfo(process, JetTag, ['jecUnc','jerFactor','jerFactorUp','jerFactorDown'], [])
## ----------------------------------------------------------------------------------------------
## IsoTracks
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
## Electrons/Muons
## ----------------------------------------------------------------------------------------------
# The decision was made to include the filter decision flags
# as individual branches in the tree
if not fastsim: # MET filters are not run for fastsim samples
from LeptoQuarkTreeMaker.Utils.filterdecisionproducer_cfi import filterDecisionProducer
process.CSCTightHaloFilter = filterDecisionProducer.clone(
trigTagArg1 = cms.string('TriggerResults'),
trigTagArg2 = cms.string(''),
trigTagArg3 = cms.string(tagname),
filterName = cms.string("Flag_CSCTightHalo2015Filter"),
)
VarsInt.extend(['CSCTightHaloFilter'])
process.globalTightHalo2016Filter = filterDecisionProducer.clone(
trigTagArg1 = cms.string('TriggerResults'),
trigTagArg2 = cms.string(''),
trigTagArg3 = cms.string(tagname),
filterName = cms.string("Flag_globalTightHalo2016Filter"),
)
VarsInt.extend(['globalTightHalo2016Filter'])
process.HBHENoiseFilter = filterDecisionProducer.clone(
trigTagArg1 = cms.string('TriggerResults'),
trigTagArg2 = cms.string(''),
trigTagArg3 = cms.string(tagname),
filterName = cms.string("Flag_HBHENoiseFilter"),
)
VarsInt.extend(['HBHENoiseFilter'])
process.HBHEIsoNoiseFilter = filterDecisionProducer.clone(
trigTagArg1 = cms.string('TriggerResults'),
trigTagArg2 = cms.string(''),
trigTagArg3 = cms.string(tagname),
filterName = cms.string("Flag_HBHENoiseIsoFilter"),
)
VarsInt.extend(['HBHEIsoNoiseFilter'])
process.EcalDeadCellTriggerPrimitiveFilter = filterDecisionProducer.clone(
trigTagArg1 = cms.string('TriggerResults'),
trigTagArg2 = cms.string(''),
trigTagArg3 = cms.string(tagname),
filterName = cms.string("Flag_EcalDeadCellTriggerPrimitiveFilter"),
)
VarsInt.extend(['EcalDeadCellTriggerPrimitiveFilter'])
process.eeBadScFilter = filterDecisionProducer.clone(
trigTagArg1 = cms.string('TriggerResults'),
trigTagArg2 = cms.string(''),
trigTagArg3 = cms.string(tagname),
filterName = cms.string("Flag_eeBadScFilter"),
)
VarsInt.extend(['eeBadScFilter'])
# some filters need to be rerun
process.load('RecoMET.METFilters.BadChargedCandidateFilter_cfi')
process.BadChargedCandidateFilter.muons = cms.InputTag("slimmedMuons")
process.BadChargedCandidateFilter.PFCandidates = cms.InputTag("packedPFCandidates")
process.BadChargedCandidateFilter.taggingMode = True
VarsBool.extend(['BadChargedCandidateFilter'])
process.load('RecoMET.METFilters.BadPFMuonFilter_cfi')
process.BadPFMuonFilter.muons = cms.InputTag("slimmedMuons")
process.BadPFMuonFilter.PFCandidates = cms.InputTag("packedPFCandidates")
process.BadPFMuonFilter.taggingMode = True
VarsBool.extend(['BadPFMuonFilter'])
'''
process.load('Configuration.StandardSequences.Services_cff')
process.RandomNumberGeneratorService = cms.Service("RandomNumberGeneratorService",
calibratedPatElectrons = cms.PSet(
initialSeed = cms.untracked.uint32(81),
engineName = cms.untracked.string('TRandom3'),
),
calibratedPatPhotons = cms.PSet(
initialSeed = cms.untracked.uint32(81),
engineName = cms.untracked.string('TRandom3'),
),
)
process.load('EgammaAnalysis.ElectronTools.calibratedElectronsRun2_cfi')
correctionType = "80Xapproval"
calibratedPatElectrons = cms.EDProducer("CalibratedPatElectronProducerRun2",
# input collections
electrons = cms.InputTag('slimmedElectrons'),
gbrForestName = cms.string("gedelectron_p4combination_25ns"),
# data or MC corrections
# if isMC is false, data corrections are applied
isMC = cms.bool(False),
# set to True to get special "fake" smearing for synchronization. Use JUST in case of synchronization
isSynchronization = cms.bool(False),
correctionFile = cms.string("80Xapproval")
)
process.Baseline += process.calibratedPatElectrons
from LeptoQuarkTreeMaker.Utils.HEEPProducer_cfi import HEEPProducer
process.HEEPProducer = HEEPProducer.clone(
eletag = cms.InputTag('slimmedElectrons')
)
process.Baseline += process.HEEPProducer
VectorDouble.extend(['HEEPProducer:trackiso(Electron_trackiso)'])
VectorDouble.extend(['HEEPProducer:Eta(Electron_Eta)'])
VectorDouble.extend(['HEEPProducer:Et(Electron_Et)'])
VectorDouble.extend(['HEEPProducer:DeltaEtain(Electron_DeltaEtain)'])
VectorDouble.extend(['HEEPProducer:DeltaPhiin(Electron_DeltaPhiin)'])
VectorDouble.extend(['HEEPProducer:HbE(Electron_HOverE)'])
VectorDouble.extend(['HEEPProducer:SiEtaiEta(Electron_SiEtaiEta)'])
VectorDouble.extend(['HEEPProducer:Ecaliso(Electron_Ecaliso)'])
VectorDouble.extend(['HEEPProducer:HD1iso(Electron_HD1iso)'])
VectorDouble.extend(['HEEPProducer:HD2iso(Electron_HD2iso)'])
VectorBool.extend(['HEEPProducer:ecalDriven(Electron_ecalDriven)'])
VectorDouble.extend(['HEEPProducer:e25max(Electron_e25max)'])
VectorDouble.extend(['HEEPProducer:e55(Electron_e55)'])
VectorDouble.extend(['HEEPProducer:e25bye55(Electron_e25bye55)'])
VectorDouble.extend(['HEEPProducer:Fullsce25bye55(Electron_Fullsce25bye55)'])
VectorDouble.extend(['HEEPProducer:Fulle15bye55(Electron_Fulle15bye55)'])
VectorDouble.extend(['HEEPProducer:scEnergy(Electron_scEnergy)'])
VectorDouble.extend(['HEEPProducer:DeltaEtaSeed(Electron_DeltaEtaSeed)'])
VectorDouble.extend(['HEEPProducer:rho(rho)'])
VectorInt.extend(['HEEPProducer:Charge(Electron_Charge)'])
VectorDouble.extend(['HEEPProducer:ePt(Electron_Pt)'])
VectorDouble.extend(['HEEPProducer:e15(Electron_e15)'])
VectorDouble.extend(['HEEPProducer:ecalEnergy(Electron_ecalEnergy)'])
VectorDouble.extend(['HEEPProducer:full55SiEtaiEta(Electron_full55SiEtaiEta)'])
VectorDouble.extend(['HEEPProducer:sce25max(Electron_sce25max)'])
VectorDouble.extend(['HEEPProducer:sce55(Electron_sce55)'])
VectorDouble.extend(['HEEPProducer:sce25bye55(Electron_sce25bye55)'])
VectorDouble.extend(['HEEPProducer:e15bye55(Electron_e15bye55)'])
VectorDouble.extend(['HEEPProducer:DeltaEtaSeedscandTrack(Electron_DeltaEtaSeedscandTrack)'])
VectorDouble.extend(['HEEPProducer:Phi(Electron_Phi)'])
VectorDouble.extend(['HEEPProducer:eEnergy(Electron_Energy)'])
VectorDouble.extend(['HEEPProducer:dxy(dxy)'])
VectorInt.extend(['HEEPProducer:losthits(Electron_losthits)'])
VectorDouble.extend(['HEEPProducer:ePz(Electron_Pz)'])
VectorDouble.extend(['HEEPProducer:eTheta(Electron_Theta)'])
VectorDouble.extend(['HEEPProducer:ePx(Electron_Px)'])
VectorDouble.extend(['HEEPProducer:ePy(Electron_Py)'])
VectorDouble.extend(['HEEPProducer:normalizedChi2(Electron_normalizedChi2)'])
VectorInt.extend(['HEEPProducer:PDGID(PDGID)'])
VectorInt.extend(['HEEPProducer:gencharge(gencharge)'])
VectorDouble.extend(['HEEPProducer:genPt(genPt)'])
VectorDouble.extend(['HEEPProducer:genEta(genEta)'])
VectorDouble.extend(['HEEPProducer:genPhi(genPhi)'])
VectorDouble.extend(['HEEPProducer:genEnergy(genEnergy)'])
VectorInt.extend(['HEEPProducer:motherPDGID(motherPDGID)'])
VectorInt.extend(['HEEPProducer:elstatus(elstatus)'])
VectorDouble.extend(['HEEPProducer:PtHEEP(Electron_PtHEEP)'])
VectorDouble.extend(['HEEPProducer:scEtaa(Electron_scEtaa)'])
VectorDouble.extend(['HEEPProducer:scEta(Electron_scEta)'])
## ----------------------------------------------------------------------------------------------
## Muons
## ----------------------------------------------------------------------------------------------
from LeptoQuarkTreeMaker.Utils.MuonProducer_cfi import MuonProducer
process.MuonProducer = MuonProducer.clone(
muontag = cms.InputTag('slimmedMuons')
)
process.Baseline += process.MuonProducer
VectorBool.extend(['MuonProducer:MuonisTightMuon(MuonisTightMuon)'])
VectorBool.extend(['MuonProducer:MuonisHighPtMuon(MuonisHighPtMuon)'])
VectorDouble.extend(['MuonProducer:MuonEta(MuonEta)'])
VectorDouble.extend(['MuonProducer:MuonPhi(MuonPhi)'])
VectorDouble.extend(['MuonProducer:MuonPt(MuonPt)'])
VectorDouble.extend(['MuonProducer:MuonEnergy(MuonEnergy)'])
VectorDouble.extend(['MuonProducer:MuonPtError(MuonPtError)'])
VectorDouble.extend(['MuonProducer:MuonGlobalChi2(MuonGlobalChi2)'])
VectorDouble.extend(['MuonProducer:MuonTrkPtError(MuonTrkPtError)'])
VectorInt.extend(['MuonProducer:MuonIsPF(MuonIsPF)'])
VectorInt.extend(['MuonProducer:MuonCharge(MuonCharge)'])
VectorInt.extend(['MuonProducer:MuonGlobalTrkValidHits(MuonGlobalTrkValidHits)'])
VectorInt.extend(['MuonProducer:MuonTrkPixelHits(MuonTrkPixelHits)'])
VectorInt.extend(['MuonProducer:MuonStationMatches(MuonStationMatches)'])
VectorDouble.extend(['MuonProducer:MuonPFIsoR04Photon(MuonPFIsoR04Photon)'])
VectorDouble.extend(['MuonProducer:MuonPFIsoR04NeutralHadron(MuonPFIsoR04NeutralHadron)'])
VectorDouble.extend(['MuonProducer:MuonPFIsoR04PU(MuonPFIsoR04PU)'])
VectorDouble.extend(['MuonProducer:MuonTrackerIsoSumPT(MuonTrackerIsoSumPT)'])
VectorDouble.extend(['MuonProducer:MuonPFIsoR04ChargedHadron(MuonPFIsoR04ChargedHadron)'])
VectorInt.extend(['MuonProducer:MuonPassID(MuonPassID)'])
VectorInt.extend(['MuonProducer:MuonIsGlobal(MuonIsGlobal)'])
VectorInt.extend(['MuonProducer:MuonTrackLayersWithMeasurement(MuonTrackLayersWithMeasurement)'])
VectorDouble.extend(['MuonProducer:CocktailEta(CocktailPtError)'])
VectorDouble.extend(['MuonProducer:CocktailPt(CocktailPt)'])
VectorDouble.extend(['MuonProducer:MuonBestTrackVtxDistXY(MuonBestTrackVtxDistXY)'])
VectorDouble.extend(['MuonProducer:MuonBestTrackVtxDistZ(MuonBestTrackVtxDistZ)'])
## ----------------------------------------------------------------------------------------------
## Taus
## ----------------------------------------------------------------------------------------------
from LeptoQuarkTreeMaker.Utils.TauProducer_cfi import TauProducer
process.TauProducer = TauProducer.clone(
tautag = cms.InputTag('slimmedTaus')
)
process.Baseline += process.TauProducer
VectorDouble.extend(['TauProducer:tEta(TauEta)'])
VectorDouble.extend(['TauProducer:tPhi(TauPhi)'])
VectorDouble.extend(['TauProducer:tPt(TauPt)'])
'''
## ----------------------------------------------------------------------------------------------
## Triggers
## ----------------------------------------------------------------------------------------------
# The trigger results are saved to the tree as a vector
# Three vectors are saved:
# 1) names of the triggers
# 2) trigger results
# 3) trigger prescales
# the indexing of these vectors must match
# If the version number of the input trigger name is omitted,
# any matching trigger will be included (default behavior)
from LeptoQuarkTreeMaker.Utils.triggerproducer_cfi import triggerProducer
from LeptoQuarkTreeMaker.LeptoQuarkTreeMaker.triggerNameList import triggerNameList as _triggerNameList
process.TriggerProducer = triggerProducer.clone(
trigTagArg1 = cms.string('TriggerResults'),
trigTagArg2 = cms.string(''),
trigTagArg3 = cms.string('HLT'),
prescaleTagArg1 = cms.string('patTrigger'),
prescaleTagArg2 = cms.string(''),
prescaleTagArg3 = cms.string(''),
triggerNameList = _triggerNameList
)
VectorInt.extend(['TriggerProducer:TriggerPass','TriggerProducer:TriggerPrescales'])
VectorString.extend(['TriggerProducer:TriggerNames'])
VectorDouble.extend(['TriggerProducer:objectPt'])
VectorDouble.extend(['TriggerProducer:objecteta'])
VectorDouble.extend(['TriggerProducer:objectphi'])
VectorDouble.extend(['TriggerProducer:objectE'])
'''
if not geninfo:
from LeptoQuarkTreeMaker.Utils.prescaleweightproducer_cfi import prescaleweightProducer
process.PrescaleWeightProducer = prescaleweightProducer.clone()
VarsDouble.extend(['PrescaleWeightProducer:weight(PrescaleWeightHT)'])
VarsDouble.extend(['PrescaleWeightProducer:ht(HTOnline)'])
VarsDouble.extend(['PrescaleWeightProducer:mht(MHTOnline)'])
'''
## ----------------------------------------------------------------------------------------------
## JER smearing, various uncertainties
## ----------------------------------------------------------------------------------------------
# list of clean tags - ignore jet ID for jets matching these objects
SkipTag = cms.VInputTag(
# cms.InputTag('LeptonsNew:IdIsoMuon'),
# cms.InputTag('LeptonsNew:IdIsoElectron'),
# cms.InputTag('IsolatedElectronTracksVeto'),
# cms.InputTag('IsolatedMuonTracksVeto'),
# cms.InputTag('IsolatedPionTracksVeto'),
)
# get the JERs (disabled by default)
# this requires the user to download the .db file from this github
# https://github.com/cms-jet/JRDatabase
'''
if len(jerfile)>0:
#get name of JERs without any directories
JERera = jerfile.split('/')[-1]
JERPatch = cms.string('sqlite_file:'+jerfile+'.db')
if os.getenv('GC_CONF'):
JERPatch = cms.string('sqlite_file:../src/'+jerfile+'.db')
process.jer = cms.ESSource("PoolDBESSource",CondDBSetup,
connect = JERPatch,
toGet = cms.VPSet(
cms.PSet(
record = cms.string('JetResolutionRcd'),
tag = cms.string('JR_'+JERera+'_PtResolution_AK4PFchs'),
label = cms.untracked.string('AK4PFchs_pt')
),
cms.PSet(
record = cms.string('JetResolutionScaleFactorRcd'),
tag = cms.string('JR_'+JERera+'_SF_AK4PFchs'),
label = cms.untracked.string('AK4PFchs')
),
),
)
process.es_prefer_jer = cms.ESPrefer('PoolDBESSource', 'jer')
'''
# skip all jet smearing and uncertainties for data
# from LeptoQuarkTreeMaker.LeptoQuarkTreeMaker.JetDepot import JetDepot
from LeptoQuarkTreeMaker.LeptoQuarkTreeMaker.makeJetVars import makeJetVars
process = makeJetVars(process,
JetTag=JetTag,
suff='',
skipGoodJets=False,
storeProperties=2,
geninfo=geninfo,
fastsim=fastsim,
SkipTag=SkipTag
)
if geninfo:
from LeptoQuarkTreeMaker.LeptoQuarkTreeMaker.JetDepot import JetDepot
# JEC unc up
process, JetTagJECup = JetDepot(process,
JetTag=JetTag,
jecUncDir=1,
doSmear=True,
jerUncDir=0
)
process = makeJetVars(process,
JetTag=JetTagJECup,
suff='JECup',
skipGoodJets=False,
storeProperties=1,
geninfo=geninfo,
fastsim=fastsim,
SkipTag=SkipTag
)
# JEC unc down
process, JetTagJECdown = JetDepot(process,
JetTag=JetTag,
jecUncDir=-1,
doSmear=True,
jerUncDir=0
)
process = makeJetVars(process,
JetTag=JetTagJECdown,
suff='JECdown',
skipGoodJets=False,
storeProperties=1,
geninfo=geninfo,
fastsim=fastsim,
SkipTag=SkipTag
)
# JER unc up
process, JetTagJERup = JetDepot(process,
JetTag=JetTag,
jecUncDir=0,
doSmear=True,
jerUncDir=1
)
process = makeJetVars(process,
JetTag=JetTagJERup,
suff='JERup',
skipGoodJets=False,
storeProperties=1,
geninfo=geninfo,
fastsim=fastsim,
SkipTag=SkipTag
)
# JER unc down
process, JetTagJERdown = JetDepot(process,
JetTag=JetTag,
jecUncDir=0,
doSmear=True,
jerUncDir=-1
)
process = makeJetVars(process,
JetTag=JetTagJERdown,
suff='JERdown',
skipGoodJets=False,
storeProperties=1,
geninfo=geninfo,
fastsim=fastsim,
SkipTag=SkipTag
)
# finally, do central smearing and replace jet tag
process, JetTag = JetDepot(process,
JetTag=JetTag,
jecUncDir=0,
doSmear=True,
jerUncDir=0
)
## ----------------------------------------------------------------------------------------------
## Jet variables
## ----------------------------------------------------------------------------------------------
'''
# get updated QG training
QGPatch = cms.string('sqlite_file:data/QGL_80X.db')
if os.getenv('GC_CONF'):
QGPatch = cms.string('sqlite_file:../src/data/QGL_80X.db')
process.qgdb = cms.ESSource("PoolDBESSource",CondDBSetup,
connect = QGPatch,
toGet = cms.VPSet(
cms.PSet(
record = cms.string('QGLikelihoodRcd'),
tag = cms.string('QGLikelihoodObject_80X_AK4PFchs'),
label = cms.untracked.string('QGL_AK4PFchs')
),
cms.PSet(
record = cms.string('QGLikelihoodRcd'),
tag = cms.string('QGLikelihoodObject_80X_AK4PFchs_antib'),
label = cms.untracked.string('QGL_AK4PFchs_antib')
),
)
)
process.es_prefer_qg = cms.ESPrefer("PoolDBESSource","qgdb")
# get QG tagging discriminant
process.QGTagger = cms.EDProducer('QGTagger',
srcJets = JetTag,
jetsLabel = cms.string('QGL_AK4PFchs'),
srcRho = cms.InputTag('fixedGridRhoFastjetAll'),
srcVertexCollection = cms.InputTag('offlinePrimaryVerticesWithBS'),
useQualityCuts = cms.bool(False)
)
# add userfloats & update tag
process, JetTag = addJetInfo(process, JetTag, ['QGTagger:qgLikelihood','QGTagger:ptD', 'QGTagger:axis2'], ['QGTagger:mult'])
process = makeJetVars(process,
JetTag=JetTag,
suff='',
skipGoodJets=False,
storeProperties=2,
geninfo=geninfo,
fastsim=fastsim,
SkipTag=SkipTag
)
# get double b-tagger (w/ miniAOD customizations)
process.load("RecoBTag.ImpactParameter.pfImpactParameterAK8TagInfos_cfi")
process.pfImpactParameterAK8TagInfos.primaryVertex = cms.InputTag("offlineSlimmedPrimaryVertices")
process.pfImpactParameterAK8TagInfos.candidates = cms.InputTag("packedPFCandidates")
process.pfImpactParameterAK8TagInfos.jets = JetAK8Tag
process.load("RecoBTag.SecondaryVertex.pfInclusiveSecondaryVertexFinderAK8TagInfos_cfi")
process.pfInclusiveSecondaryVertexFinderAK8TagInfos.extSVCollection = cms.InputTag("slimmedSecondaryVertices")
process.pfInclusiveSecondaryVertexFinderAK8TagInfos.trackIPTagInfos = cms.InputTag("pfImpactParameterAK8TagInfos")
process.load("RecoBTag.SecondaryVertex.pfBoostedDoubleSVAK8TagInfos_cfi")
process.load("RecoBTag.SecondaryVertex.candidateBoostedDoubleSecondaryVertexAK8Computer_cfi")
process.load("RecoBTag.SecondaryVertex.pfBoostedDoubleSecondaryVertexAK8BJetTags_cfi")
# add discriminator and update tag
process, JetAK8Tag = addJetInfo(process, JetAK8Tag, [], [], cms.VInputTag(cms.InputTag("pfBoostedDoubleSecondaryVertexAK8BJetTags")))
# apply jet ID
process = makeJetVars(process,
JetTag=JetAK8Tag,
suff='AK8',
skipGoodJets=False,
storeProperties=1,
geninfo=geninfo,
fastsim=fastsim,
onlyGoodJets=True
)
# AK8 jet variables - separate instance of jet properties producer
from LeptoQuarkTreeMaker.Utils.jetproperties_cfi import jetproperties
process.JetsPropertiesAK8 = jetproperties.clone(
JetTag = JetAK8Tag,
properties = cms.vstring(
"prunedMass" ,
"NsubjettinessTau1" ,
"NsubjettinessTau2" ,
"NsubjettinessTau3" ,
"bDiscriminatorSubjet1",
"bDiscriminatorSubjet2",
"bDiscriminatorCSV" ,
"NumBhadrons" ,
"NumChadrons" ,
)
)
#specify userfloats
process.JetsPropertiesAK8.prunedMass = cms.vstring('ak8PFJetsCHSPrunedMass')
process.JetsPropertiesAK8.NsubjettinessTau1 = cms.vstring('NjettinessAK8:tau1')
process.JetsPropertiesAK8.NsubjettinessTau2 = cms.vstring('NjettinessAK8:tau2')
process.JetsPropertiesAK8.NsubjettinessTau3 = cms.vstring('NjettinessAK8:tau3')
process.JetsPropertiesAK8.bDiscriminatorSubjet1 = cms.vstring('SoftDrop','pfCombinedInclusiveSecondaryVertexV2BJetTags')
process.JetsPropertiesAK8.bDiscriminatorSubjet2 = cms.vstring('SoftDrop','pfCombinedInclusiveSecondaryVertexV2BJetTags')
process.JetsPropertiesAK8.bDiscriminatorCSV = cms.vstring('pfBoostedDoubleSecondaryVertexAK8BJetTags')
#VectorRecoCand.extend([JetAK8Tag.value()+'(JetsAK8)'])
#VectorDouble.extend(['JetsPropertiesAK8:prunedMass(JetsAK8_prunedMass)',
# 'JetsPropertiesAK8:bDiscriminatorSubjet1(JetsAK8_bDiscriminatorSubjet1CSV)',
# 'JetsPropertiesAK8:bDiscriminatorSubjet2(JetsAK8_bDiscriminatorSubjet2CSV)',
# 'JetsPropertiesAK8:bDiscriminatorCSV(JetsAK8_doubleBDiscriminator)',
# 'JetsPropertiesAK8:NsubjettinessTau1(JetsAK8_NsubjettinessTau1)',
# 'JetsPropertiesAK8:NsubjettinessTau2(JetsAK8_NsubjettinessTau2)',
# 'JetsPropertiesAK8:NsubjettinessTau3(JetsAK8_NsubjettinessTau3)'])
#VectorInt.extend(['JetsPropertiesAK8:NumBhadrons(JetsAK8_NumBhadrons)',
# 'JetsPropertiesAK8:NumChadrons(JetsAK8_NumChadrons)'])
'''
## ----------------------------------------------------------------------------------------------
## GenJet variables
## ----------------------------------------------------------------------------------------------
if geninfo:
# store all genjets
VectorRecoCand.extend ( [ 'slimmedGenJets(GenJets)' ] )
from LeptoQuarkTreeMaker.Utils.subJetSelection_cfi import SubGenJetSelection
process.GenHTJets = SubGenJetSelection.clone(
JetTag = cms.InputTag('slimmedGenJets'),
MinPt = cms.double(30),
MaxEta = cms.double(2.4),
)
#VectorBool.extend(['GenHTJets:SubJetMask(GenJets_HTMask)'])
# make gen HT
from LeptoQuarkTreeMaker.Utils.htdouble_cfi import htdouble
process.GenHT = htdouble.clone(
JetTag = cms.InputTag("GenHTJets"),
)
#VarsDouble.extend(['GenHT'])
process.GenMHTJets = SubGenJetSelection.clone(
JetTag = cms.InputTag('slimmedGenJets'),
MinPt = cms.double(30),
MaxEta = cms.double(5.0),
)
#VectorBool.extend(['GenMHTJets:SubJetMask(GenJets_MHTMask)'])
'''
# make gen MHT
from LeptoQuarkTreeMaker.Utils.mhtdouble_cfi import mhtdouble
process.GenMHT = mhtdouble.clone(
JetTag = cms.InputTag('GenMHTJets'),
)
VarsDouble.extend(['GenMHT:Pt(GenMHT)','GenMHT:Phi(GenMHTPhi)'])
'''
## ----------------------------------------------------------------------------------------------
## Baseline filters
## ----------------------------------------------------------------------------------------------
# sequence for baseline filters
process.Baseline = cms.Sequence()
'''
from LeptoQuarkTreeMaker.Utils.doublefilter_cfi import DoubleFilter
process.HTFilter = DoubleFilter.clone(
DoubleTag = cms.InputTag('HT'),
CutValue = cms.double('500'),
)
process.MHTFilter = DoubleFilter.clone(
DoubleTag = cms.InputTag('MHT:Pt'),
CutValue = cms.double('200'),
)
if applybaseline:
process.Baseline += process.HTFilter
#process.Baseline += process.MHTFilter
'''
## ----------------------------------------------------------------------------------------------
## MET
## ----------------------------------------------------------------------------------------------
from LeptoQuarkTreeMaker.Utils.metdouble_cfi import metdouble
process.MET = metdouble.clone(
METTag = METTag,
GenMETTag = cms.InputTag("slimmedMETs","",tagname), #original collection used deliberately here
JetTag = cms.InputTag('HTJets'),
geninfo = cms.untracked.bool(geninfo),
)
VarsDouble.extend(['MET:Pt(MET)','MET:Phi(METPhi)'])
if geninfo:
VarsDouble.extend(['MET:GenPt(GenMET)','MET:GenPhi(GenMETPhi)'])
VectorDouble.extend(['MET:PtUp(METUp)', 'MET:PtDown(METDown)', 'MET:PhiUp(METPhiUp)', 'MET:PhiDown(METPhiDown)'])
'''
from LeptoQuarkTreeMaker.Utils.mt2producer_cfi import mt2Producer
process.Mt2Producer = mt2Producer.clone(
JetTag = cms.InputTag('MHTJets'),
METTag = METTag
)
VarsDouble.extend(['Mt2Producer:mt2(MT2)'])
'''
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
## Optional producers (background estimations, control regions)
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
## Hadronic Tau Background
## ----------------------------------------------------------------------------------------------
'''
if hadtau:
from LeptoQuarkTreeMaker.LeptoQuarkTreeMaker.doHadTauBkg import doHadTauBkg
dorecluster = False
if hadtaurecluster==0: dorecluster = False
elif hadtaurecluster==1: dorecluster = ("TTJets" in process.source.fileNames[0] or "WJets" in process.source.fileNames[0])
elif hadtaurecluster==2: dorecluster = geninfo
elif hadtaurecluster==3: dorecluster = True
process = doHadTauBkg(process,geninfo,residual,JetTagBeforeSmearing,fastsim,dorecluster)
## ----------------------------------------------------------------------------------------------
## Lost Lepton Background
## ----------------------------------------------------------------------------------------------
if lostlepton:
from LeptoQuarkTreeMaker.LeptoQuarkTreeMaker.doLostLeptonBkg import doLostLeptonBkg
process = doLostLeptonBkg(process,geninfo,METTag)
## ----------------------------------------------------------------------------------------------
## Zinv Background
## ----------------------------------------------------------------------------------------------
if doZinv:
from LeptoQuarkTreeMaker.LeptoQuarkTreeMaker.doZinvBkg import doZinvBkg
process = doZinvBkg(process,tagname,geninfo,residual,fastsim)
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
## Final steps
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
'''
# create the process path
process.dump = cms.EDAnalyzer("EventContentAnalyzer")
process.WriteTree = cms.Path(
process.Baseline *
process.LQTreeMaker2
)
return process
from RecoJets.Configuration.RecoPFJets_cff import ak8PFJetsCHSSoftDropMass
process.oldJetMass = ak8PFJetsCHSSoftDropMass.clone(
src = cms.InputTag("slimmedJets"),
matched = cms.InputTag("slimmedJets") )
patAlgosToolsTask.add(process.oldJetMass)
updateJetCollection(
process,
jetSource = cms.InputTag('slimmedJets'),
jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None'),
btagDiscriminators = [
'pfCombinedSecondaryVertexV2BJetTags',
'pfDeepCSVJetTags:probudsg',
'pfDeepCSVJetTags:probb',
'pfDeepCSVJetTags:probc',
'pfDeepCSVJetTags:probbb',
'pfDeepCSVJetTags:probcc',
## 'pfDeepCMVAJetTags:probudsg',
## 'pfDeepCMVAJetTags:probb',
## 'pfDeepCMVAJetTags:probc',
## 'pfDeepCMVAJetTags:probbb',
## 'pfDeepCMVAJetTags:probcc'
] ## to add discriminators
)
process.updatedPatJets.userData.userFloats.src += ['oldJetMass']
from PhysicsTools.PatAlgos.patInputFiles_cff import filesRelValTTbarPileUpMINIAODSIM
process.source.fileNames = filesRelValTTbarPileUpMINIAODSIM
# ##
# Setup VID for EGM ID
from PhysicsTools.SelectorUtils.tools.vid_id_tools import *
switchOnVIDPhotonIdProducer(process, DataFormat.MiniAOD)
# define which IDs we want to produce
my_id_modules = ['RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring15_25ns_V1_cff']
#add them to the VID producer
for idmod in my_id_modules:
setupAllVIDIdsInModule(process,idmod,setupVIDPhotonSelection)
## update AK4PFchs jet collection in MiniAOD JECs
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
updateJetCollection(
process,
jetSource = cms.InputTag('slimmedJets'),
labelName = 'UpdatedJEC',
jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None') # Do not forget 'L2L3Residual' on data!
)
# main analyzer and inputs
process.diphoton = cms.EDAnalyzer(
'ExoDiPhotonMCFakeRateClosureTestAnalyzer',
# photon tag
photonsMiniAOD = cms.InputTag("slimmedPhotons"),
# genParticle tag
genParticlesMiniAOD = cms.InputTag("prunedGenParticles"),
# ak4 jets
jetsMiniAOD = cms.InputTag("selectedUpdatedPatJetsUpdatedJEC"),
jetPtThreshold = cms.double(30.),
jetEtaThreshold = cms.double(2.5),
# rho tag
)
process.es_prefer_jer = cms.ESPrefer('PoolDBESSource', 'jer')
################ end sqlite connection
#### RECOMPUTE JEC From GT ###
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
jecLevels= ['L1FastJet', 'L2Relative', 'L3Absolute']
if options.isData:
jecLevels =['L1FastJet', 'L2Relative', 'L3Absolute', 'L2L3Residual']
updateJetCollection(
process,
jetSource = process.nero.jets,
labelName = 'UpdatedJEC',
jetCorrections = ('AK4PFchs', cms.vstring(jecLevels), 'None') # Do not forget 'L2L3Residual' on data!
)
updateJetCollection(
process,
jetSource = process.nero.chsAK8,
labelName = 'UpdatedJECAK8',
jetCorrections = ('AK8PFchs', cms.vstring(jecLevels), 'None') # Do not forget 'L2L3Residual' on data!
)
print "-> Updating the jets collection to run on to 'updatedPatJetsUpdatedJEC' with the new jec in the GT"
process.nero.jets=cms.InputTag('updatedPatJetsUpdatedJEC')
process.nero.chsAK8=cms.InputTag('updatedPatJetsUpdatedJECAK8')
process.jecSequence = cms.Sequence( process.patJetCorrFactorsUpdatedJEC* process.updatedPatJetsUpdatedJEC* process.patJetCorrFactorsUpdatedJECAK8* process.updatedPatJetsUpdatedJECAK8)
postfix="Puppi"
)
if is_data_flag:
process.AK4QGTaggerPuppi.jec = cms.InputTag("ak4PuppiL1FastL2L3ResidualCorrector")
process.AK8QGTaggerPuppi.jec = cms.InputTag("ak8PuppiL1FastL2L3ResidualCorrector")
process.CA15QGTaggerPuppi.jec = cms.InputTag("ak8PuppiL1FastL2L3ResidualCorrector")
process.AK4QGTaggerSubJetsPuppi.jec = cms.InputTag("ak4PuppiL1FastL2L3ResidualCorrector")
process.AK8QGTaggerSubJetsPuppi.jec = cms.InputTag("ak8PuppiL1FastL2L3ResidualCorrector")
process.CA15QGTaggerSubJetsPuppi.jec = cms.InputTag("ak8PuppiL1FastL2L3ResidualCorrector")
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
updateJetCollection(
process,
jetSource = cms.InputTag('slimmedJets'),
jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None'),
btagDiscriminators = ['pfDeepCMVAJetTags:probb','pfDeepCMVAJetTags:probc','pfDeepCMVAJetTags:probudsg','pfDeepCMVAJetTags:probbb',
'pfDeepCSVJetTags:probb' ,'pfDeepCSVJetTags:probc' ,'pfDeepCSVJetTags:probudsg' ,'pfDeepCSVJetTags:probbb']
)
# ALPACA
#process.load('BaconProd/Ntupler/myAlpacaCorrections_cff')
alpacaMet = ''
alpacaPuppiMet = ''
if do_alpaca:
alpacaMet = ('pfMetAlpacaData' if is_data_flag else 'pfMetAlpacaMC' )
alpacaPuppiMet = ('pfMetPuppiAlpacaData' if is_data_flag else 'pfMetPuppiAlpacaMC' )
#--------------------------------------------------------------------------------
# input settings
#================================================================================
'deepFlavourJetTags:probcc',
]
jetCorrectionsAK4 = ('AK4PFchs', ['L1FastJet', 'L2Relative', 'L3Absolute'], 'None')
jetCorrectionsAK8 = ('AK8PFchs', ['L1FastJet', 'L2Relative', 'L3Absolute'], 'None')
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
updateJetCollection(
process,
labelName = "DeepFlavour",
jetSource=cms.InputTag('slimmedJetsAK8PFCHSSoftDropPacked','SubJets'), #slimmedJetsAK8PFPuppiSoftDropPacked', 'SubJets'), # subjets from AK8
# jetSource = cms.InputTag('slimmedJets'), # 'ak4Jets'
jetCorrections = jetCorrectionsAK4,
pfCandidates = cms.InputTag('packedPFCandidates'),
pvSource = cms.InputTag("offlineSlimmedPrimaryVertices"),
svSource = cms.InputTag('slimmedSecondaryVertices'),
muSource = cms.InputTag('slimmedMuons'),
elSource = cms.InputTag('slimmedElectrons'),
btagInfos = bTagInfos,
btagDiscriminators = bTagDiscriminators,
explicitJTA = False
)
if hasattr(process,'updatedPatJetsTransientCorrectedDeepFlavour'):
process.updatedPatJetsTransientCorrectedDeepFlavour.addTagInfos = cms.bool(True)
process.updatedPatJetsTransientCorrectedDeepFlavour.addBTagInfo = cms.bool(True)
else:
raise ValueError('I could not find updatedPatJetsTransientCorrectedDeepFlavour to embed the tagInfos, please check the cfg')
# payload = 'AK4PFchs' ) # Make sure to choose the appropriate levels and payload here!
#
#from PhysicsTools.PatAlgos.producersLayer1.jetUpdater_cff import patJetsUpdated
#process.patJetsReapplyJEC = process.patJetsUpdated.clone(
# jetSource = cms.InputTag("slimmedJets"),
# jetCorrFactorsSource = cms.VInputTag(cms.InputTag("patJetCorrFactorsReapplyJEC"))
# )
#process.JEC = cms.Sequence( process.patJetCorrFactorsReapplyJEC + process. patJetsReapplyJEC )
#-----------------For JEC----------------- for 7.6.4 and above
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
if runOnData:
updateJetCollection(
process,
jetSource = cms.InputTag('slimmedJets'),
labelName = 'UpdatedJEC',
jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute','L2L3Residual']), 'None') # Do not forget 'L2L3Residual' on data!
)
else:
updateJetCollection(
process,
jetSource = cms.InputTag('slimmedJets'),
labelName = 'UpdatedJEC',
jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None') # Do not forget 'L2L3Residual' on data!
)
process.load('FWCore.MessageService.MessageLogger_cfi')
process.TFileService=cms.Service("TFileService",
fileName=cms.string("ntuple_output.root"),
closeFileFast = cms.untracked.bool(True)
label = cms.untracked.string('AK4PFchs')
),
## here you add as many jet types as you need
## note that the tag name is specific for the particular sqlite file
),
connect = jecString
# uncomment above tag lines and this comment to use MC JEC
)
process.es_prefer_jec = cms.ESPrefer('PoolDBESSource','jec')
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
updateJetCollection(
process,
jetSource = cms.InputTag('slimmedJets'),
labelName = 'UpdatedJEC',
jetCorrections = ('AK4PFchs', cms.vstring('L1FastJet', 'L2Relative', 'L3Absolute'), 'None')
)
process.jecSequence = cms.Sequence(process.patJetCorrFactorsUpdatedJEC * process.updatedPatJetsUpdatedJEC)
jerString = cms.string('sqlite:src/ntuple_maker/ntuple_maker/data/jer/Spring16_25nsV6_MC.db')
process.jer = cms.ESSource("PoolDBESSource",
CondDBSetup,
toGet = cms.VPSet(
# Resolution
cms.PSet(
record = cms.string('JetResolutionRcd'),
tag = cms.string('JR_Spring16_25nsV6_MC_PtResolution_AK4PFchs'),
label = cms.untracked.string('AK4PFchs_pt')
def makeAnalysisStep(self, stepName, **inputs):
step = super(JetBaseFlow, self).makeAnalysisStep(stepName, **inputs)
if stepName == 'preliminary':
# Pileup veto
# This puts the IDs in the event stream, not an updated
# jet collection
self.process.load("RecoJets.JetProducers.PileupJetID_cfi")
self.process.pileupJetIdUpdated = self.process.pileupJetId.clone(
jets = step.getObjTag('j'),
inputIsCorrected = True,
applyJec = True,
vertexes = step.getObjTag('v'),
)
step.addModule('pileupJetIdUpdated',
self.process.pileupJetIdUpdated,
'puID', puID='fullId')
# Jet energy corrections
corrections = ['L1FastJet', 'L2Relative', 'L3Absolute',]
if not self.isMC:
corrections.append('L2L3Residual')
updateJetCollection(
self.process,
jetSource = step.getObjTag('j'),
labelName = 'UpdatedJEC',
jetCorrections = ('AK4PFchs', cms.vstring(corrections), 'None'),
)
# Store PU ID in jet collection as a userInt
self.process.updatedPatJetsUpdatedJEC.userData.userInts.src += [step.getObjTagString('puID')]
self.process.jecSequence = cms.Sequence(
self.process.patJetCorrFactorsUpdatedJEC
* self.process.updatedPatJetsUpdatedJEC
)
step.addModule('jecSequence',
self.process.jecSequence,
'j')
if self.isMC:
# shift corrections up and down for systematics
jesShifts = cms.EDProducer(
"PATJetEnergyScaleShifter",
src = step.getObjTag('j'),
)
step.addModule('jesShifts', jesShifts, 'j_jesUp', 'j_jesDown',
j_jesUp='jesUp', j_jesDown='jesDown')
jetIDEmbedding = cms.EDProducer(
"PATJetIDEmbedder",
src = step.getObjTag('j'),
)
step.addModule('jetIDEmbedding', jetIDEmbedding, 'j')
if self.isMC:
jetIDEmbedding_jesUp = cms.EDProducer(
"PATJetIDEmbedder",
src = step.getObjTag('j_jesUp'),
)
step.addModule('jetIDEmbeddingJESUp', jetIDEmbedding_jesUp, 'j_jesUp')
jetIDEmbedding_jesDown = cms.EDProducer(
"PATJetIDEmbedder",
src = step.getObjTag('j_jesDown'),
)
step.addModule('jetIDEmbeddingJESDown', jetIDEmbedding_jesDown, 'j_jesDown')
jetSmearing = cms.EDProducer(
"PATJetSmearing",
src = step.getObjTag('j'),
rhoSrc = cms.InputTag("fixedGridRhoFastjetAll"),
systematics = cms.bool(True),
)
step.addModule("jetSmearing", jetSmearing, 'j', 'j_jerUp',
'j_jerDown', j_jerUp='jerUp', j_jerDown='jerDown')
jetSmearing_jesUp = jetSmearing.clone(src = step.getObjTag('j_jesUp'),
systematics = cms.bool(False))
step.addModule("jetSmearingJESUp", jetSmearing_jesUp, 'j_jesUp')
jetSmearing_jesDown = jetSmearing.clone(src = step.getObjTag('j_jesDown'),
systematics = cms.bool(False))
step.addModule("jetSmearingJESDown", jetSmearing_jesDown, 'j_jesDown')
# need to re-sort now that we're calibrated
jSort_jesUp = cms.EDProducer(
"PATJetCollectionSorter",
src = step.getObjTag('j_jesUp'),
function = cms.string('pt'),
)
step.addModule('jetSortingJESUp', jSort_jesUp, 'j_jesUp')
jSort_jesDn = cms.EDProducer(
"PATJetCollectionSorter",
src = step.getObjTag('j_jesDown'),
function = cms.string('pt'),
)
step.addModule('jetSortingJESDn', jSort_jesDn, 'j_jesDown')
jSort_jerUp = cms.EDProducer(
"PATJetCollectionSorter",
src = step.getObjTag('j_jerUp'),
function = cms.string('pt'),
)
step.addModule('jetSortingJERUp', jSort_jerUp, 'j_jerUp')
jSort_jerDn = cms.EDProducer(
"PATJetCollectionSorter",
src = step.getObjTag('j_jerDown'),
function = cms.string('pt'),
)
step.addModule('jetSortingJERDn', jSort_jerDn, 'j_jerDown')
# need to re-sort now that we're calibrated
jSort = cms.EDProducer(
"PATJetCollectionSorter",
src = step.getObjTag('j'),
function = cms.string('pt'),
)
step.addModule('jetSorting', jSort, 'j')
if stepName == 'preselection':
# For now, we're not using the PU ID, but we'll store it in the
# ntuples later
selectionString = ('pt > 30. && abs(eta) < 4.7 && '
'userFloat("idLoose") > 0.5')
# # use medium PU ID
# # PU IDs are stored as a userInt where the first three digits are
# # tight, medium, and loose PUID decisions (going right to left)
# selectionString = ('pt>30. && abs(eta) < 4.7 && '
# 'userFloat("idLoose") > 0.5 && '
# 'userInt("{}") >= 6').format(step.getObjTagString('puID'))
step.addBasicSelector('j', selectionString)
if self.isMC:
step.addBasicSelector('j_jesUp', selectionString)
step.addBasicSelector('j_jesDown', selectionString)
step.addBasicSelector('j_jerUp', selectionString)
step.addBasicSelector('j_jerDown', selectionString)
return step
## uncomment the following line to update different jet collections
## and add them to the event content
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
## An example where the jet energy correction are updated to the current GlobalTag
## and a userFloat containing the previous mass of the jet and an additional
## b-tag discriminator are added
from RecoJets.Configuration.RecoPFJets_cff import ak8PFJetsCHSSoftDropMass
process.oldJetMass = ak8PFJetsCHSSoftDropMass.clone(
src = cms.InputTag("slimmedJets"),
matched = cms.InputTag("slimmedJets") )
patAlgosToolsTask.add(process.oldJetMass)
updateJetCollection(
process,
jetSource = cms.InputTag('slimmedJets'),
jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None'),
btagDiscriminators = ['pfCombinedSecondaryVertexV2BJetTags'] ## to add discriminators
)
process.updatedPatJets.userData.userFloats.src += ['oldJetMass']
## An example where the jet corrections are undone
updateJetCollection(
process,
labelName = 'UndoneJEC',
jetSource = cms.InputTag('slimmedJets'),
jetCorrections = ('AK4PFchs', cms.vstring([]), 'None')
)
process.updatedPatJetsUndoneJEC.userData.userFloats.src = []
## An example where the jet corrections are reapplied
updateJetCollection(
def reSetJet(process):
## Filter out neutrinos from packed GenParticles
process.packedGenParticlesForJetsNoNu = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedGenParticles"), cut = cms.string("abs(pdgId) != 12 && abs(pdgId) != 14 && abs(pdgId) != 16"))
## Define GenJets
from RecoJets.JetProducers.ak5GenJets_cfi import ak5GenJets
process.ak5GenJetsNoNu = ak5GenJets.clone(src = 'packedGenParticlesForJetsNoNu')
## Select charged hadron subtracted packed PF candidates
process.pfCHS = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedPFCandidates"), cut = cms.string("fromPV"))
from RecoJets.JetProducers.ak5PFJets_cfi import ak5PFJets
## Define PFJetsCHS
process.ak5PFJetsCHS = ak5PFJets.clone(src = 'pfCHS', doAreaFastjet = True)
#################################################
## Remake PAT jets
#################################################
## b-tag discriminators
bTagDiscriminators = [
'pfCombinedInclusiveSecondaryVertexV2BJetTags'
]
#################################################################
slimmedAddPileupInfo = cms.EDProducer(
'PileupSummaryInfoSlimmer',
#src = cms.InputTag('addPileupInfo'),
keepDetailedInfoFor = cms.vint32(0)
)
#######################################################
from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection
## Add PAT jet collection based on the above-defined ak5PFJetsCHS
addJetCollection(
process,
labelName = 'AK5PFCHS',
jetSource = cms.InputTag('ak5PFJetsCHS'),
pvSource = cms.InputTag('offlineSlimmedPrimaryVertices'),
bsSource = cms.InputTag('offlineBeamSpot'),
pfCandidates = cms.InputTag('packedPFCandidates'),
svSource = cms.InputTag('slimmedSecondaryVertices'),
btagDiscriminators = bTagDiscriminators,
#jetCorrections = ('AK5PFchs', ['L1FastJet', 'L2Relative', 'L3Absolute'], 'None'), #commented before adding jet corrections
genJetCollection = cms.InputTag('ak5GenJetsNoNu'),
genParticles = cms.InputTag('prunedGenParticles'),
algo = 'AK',
rParam = 0.5
)
getattr(process,'selectedPatJetsAK5PFCHS').cut = cms.string('pt > 20.')
process.rejet = cms.Path(process.packedGenParticlesForJetsNoNu *
process.ak5GenJetsNoNu *
process.pfCHS *
process.ak5PFJetsCHS *
process.patJetCorrFactorsAK5PFCHS *
process.patJetPartons *
process.patJetFlavourAssociationAK5PFCHS *
process.patJetPartonMatchAK5PFCHS *
process.patJetGenJetMatchAK5PFCHS *
process.pfImpactParameterTagInfosAK5PFCHS *
process.pfInclusiveSecondaryVertexFinderTagInfosAK5PFCHS *
process.pfCombinedInclusiveSecondaryVertexV2BJetTagsAK5PFCHS *
process.patJetsAK5PFCHS *
process.selectedPatJetsAK5PFCHS)
from PhysicsTools.PatAlgos.tools.pfTools import adaptPVs
## Adapt primary vertex collection and BeamSpot
adaptPVs(process, pvCollection=cms.InputTag('offlineSlimmedPrimaryVertices'))
adaptBSs(process, bsCollection=cms.InputTag('offlineBeamSpot'))
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
updateJetCollection(
process,
jetSource = cms.InputTag('slimmedJets'),
labelName = 'UpdatedJEC',
jetCorrections = ('AK5PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None') # Do not forget 'L2L3Residual' on data
)
process.load('Configuration.StandardSequences.Services_cff') #Added info from now onwards
process.load("JetMETCorrections.Modules.JetResolutionESProducer_cfi")
from CondCore.DBCommon.CondDBSetup_cfi import *
import os
process.jer = cms.ESSource("PoolDBESSource",
CondDBSetup,
toGet = cms.VPSet(
# Resolution
cms.PSet(
record = cms.string('JetResolutionRcd'),
tag = cms.string('JR_Fall15_25nsV2_MC_PtResolution_AK5PFchs'),
label = cms.untracked.string('AK5PFchs_pt')
),
# Scale factors
cms.PSet(
record = cms.string('JetResolutionScaleFactorRcd'),
tag = cms.string('JR_Fall15_25nsV2_MC_SF_AK4PFchs'),
label = cms.untracked.string('AK5PFchs')
),
),
connect = cms.string('sqlite:Fall15_25nsV2_MC.db')
)
process.es_prefer_jer = cms.ESPrefer('PoolDBESSource', 'jer')