def define_METs(process, runOnData=False):
"""Define reconstructed MET.
Configure recalculation of corrected MET and its systematic
uncertainties. Only type-1 corrections are applied. Due to
limitations of MET tools, uncertainties are calculated even when
running over data, while this is not needed. Moreover, they include
uncertainties corresponding to variations in energies of leptons,
taus, and photons, although these variations are not considered in
targeted analyses.
Arguments:
process: The process to which relevant MET producers are added.
runOnData: Flag to distinguish processing of data and
simulation.
Return value:
InputTag that defines MET collection to be used.
"""
# Recalculate MET corrections [1]
# [1] https://twiki.cern.ch/twiki/bin/view/CMS/MissingETUncertaintyPrescription?rev=64#Instructions_for_8_0_X_X_26_patc
from PhysicsTools.PatUtils.tools.runMETCorrectionsAndUncertainties import \
runMetCorAndUncFromMiniAOD
runMetCorAndUncFromMiniAOD(process, isData=runOnData, postfix='')
# In data apply an additional correction for the ECAL gain switch
# issue [1]
# [1] https://twiki.cern.ch/twiki/bin/view/CMSPublic/ReMiniAOD03Feb2017Notes?rev=19#MET_Recipes
if runOnData:
from PhysicsTools.PatUtils.tools.corMETFromMuonAndEG import corMETFromMuonAndEG
corMETFromMuonAndEG(
process,
pfCandCollection='',
electronCollection='slimmedElectronsBeforeGSFix',
photonCollection='slimmedPhotonsBeforeGSFix',
corElectronCollection='slimmedElectrons',
corPhotonCollection='slimmedPhotons',
allMETEGCorrected=True,
muCorrection=False,
eGCorrection=True,
runOnMiniAOD=True,
postfix='MuEGClean'
)
process.slimmedMETsMuEGClean = process.slimmedMETs.clone(
src = cms.InputTag('patPFMetT1MuEGClean'),
rawVariation = cms.InputTag('patPFMetRawMuEGClean'),
t1Uncertainties = cms.InputTag('patPFMetT1%sMuEGClean')
)
del process.slimmedMETsMuEGClean.caloMET
if runOnData:
metTag = cms.InputTag('slimmedMETsMuEGClean', processName=process.name_())
else:
metTag = cms.InputTag('slimmedMETs', processName=process.name_())
return metTag
def nanoHRT_customizeData_METMuEGClean(process):
process = nanoHRT_customizeCommon(process, False)
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
process.metTable.src = cms.InputTag('slimmedMETsMuEGClean')
process.NANOAODoutput.fakeNameForCrab = cms.untracked.bool(
True) # hack for crab publication
return process
)
# MET correction and uncertainties
from PhysicsTools.PatUtils.tools.runMETCorrectionsAndUncertainties import runMetCorAndUncFromMiniAOD
runMetCorAndUncFromMiniAOD(process, isData=True)
# Now you are creating the e/g corrected MET on top of the bad muon corrected MET (on re-miniaod)
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
process.egcorrMET = cms.Sequence(
process.cleanedPhotonsMuEGClean + process.cleanedCorPhotonsMuEGClean +
def addExtraMETCollections(process, unCleanPFCandidateCollection,
cleanElectronCollection,
cleanPhotonCollection,
unCleanElectronCollection,
unCleanPhotonCollection ):
# Muon/EGamma un/corrected pfMET ============
from PhysicsTools.PatUtils.tools.corMETFromMuonAndEG import corMETFromMuonAndEG
from PhysicsTools.PatUtils.tools.runMETCorrectionsAndUncertainties import runMetCorAndUncForMiniAODProduction
# uncorrected MET
cloneProcessingSnippet(process, getattr(process,"makePatJets"),"BackupAllEvents")
massSearchReplaceAnyInputTag(getattr(process,"makePatJetsBackupAllEvents"), "ak4PFJetsCHS", "ak4PFJetsCHSBackupAllEvents")
massSearchReplaceAnyInputTag(getattr(process,"makePatJetsBackupAllEvents"), "pfCandidatesBadMuonsCleaned", "particleFlow")
del process.patJetsBackupAllEvents.userData
process.patJetsBackupAllEvents.addAssociatedTracks = cms.bool(False)
process.patJetsBackupAllEvents.addBTagInfo = cms.bool(False)
process.patJetsBackupAllEvents.addDiscriminators = cms.bool(False)
process.patJetsBackupAllEvents.addGenJetMatch = cms.bool(False)
process.patJetsBackupAllEvents.addGenPartonMatch = cms.bool(False)
process.patJetsBackupAllEvents.addJetCharge = cms.bool(False)
process.patJetsBackupAllEvents.addJetCorrFactors = cms.bool(True)
process.patJetsBackupAllEvents.addJetFlavourInfo = cms.bool(False)
process.patJetsBackupAllEvents.addJetID = cms.bool(False)
process.patJetsBackupAllEvents.addPartonJetMatch = cms.bool(False)
process.patJetsBackupAllEvents.addResolutions = cms.bool(False)
process.patJetsBackupAllEvents.addTagInfos = cms.bool(False)
process.patJetsBackupAllEvents.discriminatorSources = cms.VInputTag()
process.patJetsBackupAllEvents.embedGenJetMatch = cms.bool(False)
runMetCorAndUncForMiniAODProduction(process,
metType="PF",
pfCandColl=cms.InputTag(unCleanPFCandidateCollection),
recoMetFromPFCs=True,
jetCollUnskimmed="patJetsBackupAllEvents",
postfix="Uncorrected"
)
if not hasattr(process, "slimmedMETs"):
process.load('PhysicsTools.PatAlgos.slimming.slimmedMETs_cfi')
process.slimmedMETsUncorrected = process.slimmedMETs.clone()
process.slimmedMETsUncorrected.src = cms.InputTag("patPFMetT1Uncorrected")
process.slimmedMETsUncorrected.rawVariation = cms.InputTag("patPFMetUncorrected")
process.slimmedMETsUncorrected.t1Uncertainties = cms.InputTag("patPFMetT1%sUncorrected")
process.slimmedMETsUncorrected.t01Variation = cms.InputTag("patPFMetT0pcT1Uncorrected")
process.slimmedMETsUncorrected.t1SmearedVarsAndUncs = cms.InputTag("patPFMetT1Smear%sUncorrected")
process.slimmedMETsUncorrected.tXYUncForRaw = cms.InputTag("patPFMetTxyUncorrected")
process.slimmedMETsUncorrected.tXYUncForT1 = cms.InputTag("patPFMetT1TxyUncorrected")
process.slimmedMETsUncorrected.tXYUncForT01 = cms.InputTag("patPFMetT0pcT1TxyUncorrected")
process.slimmedMETsUncorrected.tXYUncForT1Smear = cms.InputTag("patPFMetT1SmearTxyUncorrected")
process.slimmedMETsUncorrected.tXYUncForT01Smear = cms.InputTag("patPFMetT0pcT1SmearTxyUncorrected")
del process.slimmedMETsUncorrected.caloMET
# EG corrected MET
corMETFromMuonAndEG(process,
pfCandCollection="", #not needed
electronCollection=unCleanElectronCollection,
photonCollection=unCleanPhotonCollection,
corElectronCollection=cleanElectronCollection,
corPhotonCollection=cleanPhotonCollection,
allMETEGCorrected=True,
muCorrection=False,
eGCorrection=True,
runOnMiniAOD=False,
eGPFix="Uncorrected",
postfix="EGOnly"
)
process.slimmedMETsEGClean = process.slimmedMETs.clone()
process.slimmedMETsEGClean.src = cms.InputTag("patPFMetT1UncorrectedEGOnly")
process.slimmedMETsEGClean.rawVariation = cms.InputTag("patPFMetRawUncorrectedEGOnly")
process.slimmedMETsEGClean.t1Uncertainties = cms.InputTag("patPFMetT1%sUncorrectedEGOnly")
process.slimmedMETsEGClean.t01Variation = cms.InputTag("patPFMetT0pcT1UncorrectedEGOnly")
process.slimmedMETsEGClean.t1SmearedVarsAndUncs = cms.InputTag("patPFMetT1Smear%sUncorrectedEGOnly")
process.slimmedMETsEGClean.tXYUncForRaw = cms.InputTag("patPFMetTxyUncorrectedEGOnly")
process.slimmedMETsEGClean.tXYUncForT1 = cms.InputTag("patPFMetT1TxyUncorrectedEGOnly")
process.slimmedMETsEGClean.tXYUncForT01 = cms.InputTag("patPFMetT0pcT1TxyUncorrectedEGOnly")
process.slimmedMETsEGClean.tXYUncForT1Smear = cms.InputTag("patPFMetT1SmearTxyUncorrectedEGOnly")
process.slimmedMETsEGClean.tXYUncForT01Smear = cms.InputTag("patPFMetT0pcT1SmearTxyUncorrectedEGOnly")
del process.slimmedMETsEGClean.caloMET
# fully corrected MET
corMETFromMuonAndEG(process,
pfCandCollection="", #not needed
electronCollection=unCleanElectronCollection,
photonCollection=unCleanPhotonCollection,
corElectronCollection=cleanElectronCollection,
corPhotonCollection=cleanPhotonCollection,
allMETEGCorrected=True,
muCorrection=False,
eGCorrection=True,
runOnMiniAOD=False,
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")
process.slimmedMETsMuEGClean.t01Variation = cms.InputTag("patPFMetT0pcT1MuEGClean")
process.slimmedMETsMuEGClean.t1SmearedVarsAndUncs = cms.InputTag("patPFMetT1Smear%sMuEGClean")
process.slimmedMETsMuEGClean.tXYUncForRaw = cms.InputTag("patPFMetTxyMuEGClean")
process.slimmedMETsMuEGClean.tXYUncForT1 = cms.InputTag("patPFMetT1TxyMuEGClean")
process.slimmedMETsMuEGClean.tXYUncForT01 = cms.InputTag("patPFMetT0pcT1TxyMuEGClean")
process.slimmedMETsMuEGClean.tXYUncForT1Smear = cms.InputTag("patPFMetT1SmearTxyMuEGClean")
process.slimmedMETsMuEGClean.tXYUncForT01Smear = cms.InputTag("patPFMetT0pcT1SmearTxyMuEGClean")
del process.slimmedMETsMuEGClean.caloMET
addKeepStatement(process, "keep *_slimmedMETs_*_*",
["keep *_slimmedMETsUncorrected_*_*", "keep *_slimmedMETsEGClean_*_*", "keep *_slimmedMETsMuEGClean_*_*"])
def addExtraPuppiMETCorrections(process,
cleanPFCandidateCollection,
unCleanPFCandidateCollection,
cleanElectronCollection,
cleanPhotonCollection,
unCleanElectronCollection,
unCleanPhotonCollection
):
from PhysicsTools.PatUtils.tools.corMETFromMuonAndEG import corMETFromMuonAndEG
#EG correction for puppi, muon correction done right above
corMETFromMuonAndEG(process,
pfCandCollection="puppiForMET",
electronCollection=unCleanElectronCollection,
photonCollection=unCleanPhotonCollection,
corElectronCollection=cleanElectronCollection,
corPhotonCollection=cleanPhotonCollection,
allMETEGCorrected=True,
muCorrection=False,
eGCorrection=True,
runOnMiniAOD=False,
eGPfCandMatching=True,
eGPFix="Puppi",
postfix="PuppiClean"
)
if not hasattr(process, "slimmedMETs"):
process.load('PhysicsTools.PatAlgos.slimming.slimmedMETs_cfi')
process.slimmedMETsPuppi.src = cms.InputTag("patPFMetT1PuppiPuppiClean")
process.slimmedMETsPuppi.rawVariation = cms.InputTag("patPFMetRawPuppiPuppiClean")
process.slimmedMETsPuppi.t1Uncertainties = cms.InputTag("patPFMetT1%sPuppiPuppiClean")
process.slimmedMETsPuppi.t01Variation = cms.InputTag("patPFMetT0pcT1PuppiPuppiClean")
process.slimmedMETsPuppi.t1SmearedVarsAndUncs = cms.InputTag("patPFMetT1Smear%sPuppiPuppiClean")
process.slimmedMETsPuppi.tXYUncForRaw = cms.InputTag("patPFMetTxyPuppiPuppiClean")
process.slimmedMETsPuppi.tXYUncForT1 = cms.InputTag("patPFMetT1TxyPuppiPuppiClean")
process.slimmedMETsPuppi.tXYUncForT01 = cms.InputTag("patPFMetT0pcT1TxyPuppiPuppiClean")
process.slimmedMETsPuppi.tXYUncForT1Smear = cms.InputTag("patPFMetT1SmearTxyPuppiPuppiClean")
process.slimmedMETsPuppi.tXYUncForT01Smear = cms.InputTag("patPFMetT0pcT1SmearTxyPuppiPuppiClean")
#del process.slimmedMETsPuppi.caloMET
#EGamma correction
process.puppiMETEGCor = cms.EDProducer("CorrMETDataExtractor",
corrections = cms.VInputTag(
cms.InputTag("corMETPhotonPuppiClean"),
cms.InputTag("corMETElectronPuppiClean") )
)
#Muon correction, restarting from PF candidates to take the weights
process.puppiMuonCorrection = cms.EDProducer("ShiftedParticleMETcorrInputProducer",
srcOriginal = cms.InputTag(unCleanPFCandidateCollection),
srcShifted = cms.InputTag(cleanPFCandidateCollection),
)
process.puppiMETMuCor = cms.EDProducer("CorrMETDataExtractor",
corrections = cms.VInputTag(
cms.InputTag("puppiMuonCorrection") )
)
addKeepStatement(process, "keep *_slimmedMETsPuppi_*_*",
["keep *_puppiMETEGCor_*_*", "keep *_puppiMETMuCor_*_*"])
def runMETs(process,isMC):
#================================ Get the most recent JEC ==================================================================#
# Setup the private SQLite -- Ripped from PhysicsTools/PatAlgos/test/corMETFromMiniAOD.py
era = "Summer16_23Sep2016"
if isMC :
era += "V4_MC"
else :
era += "AllV4_DATA"
dBFile = os.path.expandvars(era+".db")
print dBFile
if usePrivateSQlite:
process.jec = cms.ESSource("PoolDBESSource",
CondDBSetup,
connect = cms.string("sqlite_file:"+dBFile),
toGet = cms.VPSet(
cms.PSet(
record = cms.string("JetCorrectionsRecord"),
tag = cms.string("JetCorrectorParametersCollection_"+era+"_AK4PF"),
label= cms.untracked.string("AK4PF")
),
cms.PSet(
record = cms.string("JetCorrectionsRecord"),
tag = cms.string("JetCorrectorParametersCollection_"+era+"_AK4PFchs"),
label= cms.untracked.string("AK4PFchs")
),
)
)
process.es_prefer_jec = cms.ESPrefer("PoolDBESSource",'jec')
#===========================================================================================================================#
##only corrects JEC/JER uncertainties for the baseline collection; means only muon corrected and EG/Muon corrected MET collections are guaranteed to have the correct JEC uncertainties.
runMetCorAndUncFromMiniAOD(process, metType="PF",
recoMetFromPFCs=False,
postfix="",
isData=(not isMC),
)
if isMC:
process.flashggMets = cms.EDProducer('FlashggMetProducer',
verbose = cms.untracked.bool(False),
metTag = cms.InputTag('slimmedMETs'),
)
process.flashggMetSequence = cms.Sequence(process.flashggMets)
if not isMC:
corMETFromMuonAndEG(process,
pfCandCollection="", #not needed
electronCollection="slimmedElectronsBeforeGSFix",
photonCollection="slimmedPhotonsBeforeGSFix",
corElectronCollection="slimmedElectrons",
corPhotonCollection="slimmedPhotons",
allMETEGCorrected=True,
muCorrection=False,
eGCorrection=True,
runOnMiniAOD=True,
postfix="FullMETClean"
)
process.slimmedMETsFullMETClean = process.slimmedMETs.clone()
process.slimmedMETsFullMETClean.src = cms.InputTag("patPFMetT1FullMETClean")
process.slimmedMETsFullMETClean.rawVariation = cms.InputTag("patPFMetRawFullMETClean")
process.slimmedMETsFullMETClean.t1Uncertainties = cms.InputTag("patPFMetT1%sFullMETClean")
del process.slimmedMETsFullMETClean.caloMET
process.egcorrMET = cms.Sequence(
process.cleanedPhotonsFullMETClean+process.cleanedCorPhotonsFullMETClean+
process.matchedPhotonsFullMETClean + process.matchedElectronsFullMETClean +
process.corMETPhotonFullMETClean+process.corMETElectronFullMETClean+
process.patPFMetT1FullMETClean+process.patPFMetRawFullMETClean+
process.patPFMetT1SmearFullMETClean+process.patPFMetT1TxyFullMETClean+
process.patPFMetTxyFullMETClean+process.patPFMetT1JetEnUpFullMETClean+
process.patPFMetT1JetResUpFullMETClean+process.patPFMetT1SmearJetResUpFullMETClean+
process.patPFMetT1ElectronEnUpFullMETClean+process.patPFMetT1PhotonEnUpFullMETClean+
process.patPFMetT1MuonEnUpFullMETClean+process.patPFMetT1TauEnUpFullMETClean+
process.patPFMetT1UnclusteredEnUpFullMETClean+process.patPFMetT1JetEnDownFullMETClean+
process.patPFMetT1JetResDownFullMETClean+process.patPFMetT1SmearJetResDownFullMETClean+
process.patPFMetT1ElectronEnDownFullMETClean+process.patPFMetT1PhotonEnDownFullMETClean+
process.patPFMetT1MuonEnDownFullMETClean+process.patPFMetT1TauEnDownFullMETClean+
process.patPFMetT1UnclusteredEnDownFullMETClean+process.slimmedMETsFullMETClean)
process.flashggMets = cms.EDProducer('FlashggMetProducer',
verbose = cms.untracked.bool(False),
metTag = cms.InputTag('slimmedMETs'),
)
# process.flashggMetsMuons = cms.EDProducer('FlashggMetProducer',
# verbose = cms.untracked.bool(False),
# metTag = cms.InputTag('slimmedMETs'),
# )
# process.flashggMetsEG = cms.EDProducer('FlashggMetProducer',
# verbose = cms.untracked.bool(False),
# metTag = cms.InputTag('slimmedMETsEGClean'),
# )
# process.flashggMets = cms.EDProducer('FlashggMetProducer',
# verbose = cms.untracked.bool(False),
# metTag = cms.InputTag('slimmedMETsFullMETClean'),
# )
# process.flashggMetsEGmuon = cms.EDProducer('FlashggMetProducer',
# verbose = cms.untracked.bool(False),
# metTag = cms.InputTag('slimmedMETsMuEGClean'),
# )
# process.flashggMetsUncorr = cms.EDProducer('FlashggMetProducer',
# verbose = cms.untracked.bool(False),
# metTag = cms.InputTag('slimmedMETsUncorrected'),
# )
# process.flashggMetSequence = cms.Sequence(process.flashggMetsMuons *process.flashggMetsEGmuon*process.flashggMets*process.flashggMetsUncorr)
process.flashggMetSequence = cms.Sequence(process.flashggMets)
def runMETs(process, isMC):
#================================ Get the most recent JEC ==================================================================#
# Setup the private SQLite -- Ripped from PhysicsTools/PatAlgos/test/corMETFromMiniAOD.py
era = "Summer16_23Sep2016"
if isMC:
era += "V4_MC"
else:
era += "AllV4_DATA"
dBFile = os.path.expandvars(era + ".db")
print dBFile
if usePrivateSQlite:
process.jec = cms.ESSource(
"PoolDBESSource",
CondDBSetup,
connect=cms.string("sqlite_file:" + dBFile),
toGet=cms.VPSet(
cms.PSet(record=cms.string("JetCorrectionsRecord"),
tag=cms.string("JetCorrectorParametersCollection_" +
era + "_AK4PF"),
label=cms.untracked.string("AK4PF")),
cms.PSet(record=cms.string("JetCorrectionsRecord"),
tag=cms.string("JetCorrectorParametersCollection_" +
era + "_AK4PFchs"),
label=cms.untracked.string("AK4PFchs")),
))
process.es_prefer_jec = cms.ESPrefer("PoolDBESSource", 'jec')
#===========================================================================================================================#
##only corrects JEC/JER uncertainties for the baseline collection; means only muon corrected and EG/Muon corrected MET collections are guaranteed to have the correct JEC uncertainties.
runMetCorAndUncFromMiniAOD(
process,
metType="PF",
recoMetFromPFCs=False,
postfix="",
isData=(not isMC),
)
if isMC:
process.flashggMets = cms.EDProducer(
'FlashggMetProducer',
verbose=cms.untracked.bool(False),
metTag=cms.InputTag('slimmedMETs'),
)
process.flashggMetSequence = cms.Sequence(process.flashggMets)
if not isMC:
corMETFromMuonAndEG(
process,
pfCandCollection="", #not needed
electronCollection="slimmedElectronsBeforeGSFix",
photonCollection="slimmedPhotonsBeforeGSFix",
corElectronCollection="slimmedElectrons",
corPhotonCollection="slimmedPhotons",
allMETEGCorrected=True,
muCorrection=False,
eGCorrection=True,
runOnMiniAOD=True,
postfix="FullMETClean")
process.slimmedMETsFullMETClean = process.slimmedMETs.clone()
process.slimmedMETsFullMETClean.src = cms.InputTag(
"patPFMetT1FullMETClean")
process.slimmedMETsFullMETClean.rawVariation = cms.InputTag(
"patPFMetRawFullMETClean")
process.slimmedMETsFullMETClean.t1Uncertainties = cms.InputTag(
"patPFMetT1%sFullMETClean")
del process.slimmedMETsFullMETClean.caloMET
process.egcorrMET = cms.Sequence(
process.cleanedPhotonsFullMETClean +
process.cleanedCorPhotonsFullMETClean +
process.matchedPhotonsFullMETClean +
process.matchedElectronsFullMETClean +
process.corMETPhotonFullMETClean +
process.corMETElectronFullMETClean +
process.patPFMetT1FullMETClean +
process.patPFMetRawFullMETClean +
process.patPFMetT1SmearFullMETClean +
process.patPFMetT1TxyFullMETClean +
process.patPFMetTxyFullMETClean +
process.patPFMetT1JetEnUpFullMETClean +
process.patPFMetT1JetResUpFullMETClean +
process.patPFMetT1SmearJetResUpFullMETClean +
process.patPFMetT1ElectronEnUpFullMETClean +
process.patPFMetT1PhotonEnUpFullMETClean +
process.patPFMetT1MuonEnUpFullMETClean +
process.patPFMetT1TauEnUpFullMETClean +
process.patPFMetT1UnclusteredEnUpFullMETClean +
process.patPFMetT1JetEnDownFullMETClean +
process.patPFMetT1JetResDownFullMETClean +
process.patPFMetT1SmearJetResDownFullMETClean +
process.patPFMetT1ElectronEnDownFullMETClean +
process.patPFMetT1PhotonEnDownFullMETClean +
process.patPFMetT1MuonEnDownFullMETClean +
process.patPFMetT1TauEnDownFullMETClean +
process.patPFMetT1UnclusteredEnDownFullMETClean +
process.slimmedMETsFullMETClean)
process.flashggMetsMuons = cms.EDProducer(
'FlashggMetProducer',
verbose=cms.untracked.bool(False),
metTag=cms.InputTag('slimmedMETs'),
)
process.flashggMetsEG = cms.EDProducer(
'FlashggMetProducer',
verbose=cms.untracked.bool(False),
metTag=cms.InputTag('slimmedMETsEGClean'),
)
process.flashggMets = cms.EDProducer(
'FlashggMetProducer',
verbose=cms.untracked.bool(False),
metTag=cms.InputTag('slimmedMETsFullMETClean'),
)
process.flashggMetsEGmuon = cms.EDProducer(
'FlashggMetProducer',
verbose=cms.untracked.bool(False),
metTag=cms.InputTag('slimmedMETsMuEGClean'),
)
process.flashggMetsUncorr = cms.EDProducer(
'FlashggMetProducer',
verbose=cms.untracked.bool(False),
metTag=cms.InputTag('slimmedMETsUncorrected'),
)
process.flashggMetSequence = cms.Sequence(
process.flashggMetsMuons * process.flashggMetsEGmuon *
process.flashggMets * process.flashggMetsUncorr)
def addExtraMETCollections(process, unCleanPFCandidateCollection,
cleanElectronCollection,
cleanPhotonCollection,
unCleanElectronCollection,
unCleanPhotonCollection ):
task = getPatAlgosToolsTask(process)
# Muon/EGamma un/corrected pfMET ============
from PhysicsTools.PatUtils.tools.corMETFromMuonAndEG import corMETFromMuonAndEG
from PhysicsTools.PatUtils.tools.runMETCorrectionsAndUncertainties import runMetCorAndUncForMiniAODProduction
# uncorrected MET
cloneProcessingSnippet(process, getattr(process,"makePatJets"),"BackupAllEvents", addToTask = True )
massSearchReplaceAnyInputTag(getattr(process,"makePatJetsBackupAllEvents"), "ak4PFJetsCHS", "ak4PFJetsCHSBackupAllEvents")
massSearchReplaceAnyInputTag(getattr(process,"makePatJetsBackupAllEvents"), "pfCandidatesBadMuonsCleaned", "particleFlow")
del process.patJetsBackupAllEvents.userData
process.patJetsBackupAllEvents.addAssociatedTracks = cms.bool(False)
process.patJetsBackupAllEvents.addBTagInfo = cms.bool(False)
process.patJetsBackupAllEvents.addDiscriminators = cms.bool(False)
process.patJetsBackupAllEvents.addGenJetMatch = cms.bool(False)
process.patJetsBackupAllEvents.addGenPartonMatch = cms.bool(False)
process.patJetsBackupAllEvents.addJetCharge = cms.bool(False)
process.patJetsBackupAllEvents.addJetCorrFactors = cms.bool(True)
process.patJetsBackupAllEvents.addJetFlavourInfo = cms.bool(False)
process.patJetsBackupAllEvents.addJetID = cms.bool(False)
process.patJetsBackupAllEvents.addPartonJetMatch = cms.bool(False)
process.patJetsBackupAllEvents.addResolutions = cms.bool(False)
process.patJetsBackupAllEvents.addTagInfos = cms.bool(False)
process.patJetsBackupAllEvents.discriminatorSources = cms.VInputTag()
process.patJetsBackupAllEvents.embedGenJetMatch = cms.bool(False)
runMetCorAndUncForMiniAODProduction(process,
metType="PF",
pfCandColl=cms.InputTag(unCleanPFCandidateCollection),
recoMetFromPFCs=True,
jetCollUnskimmed="patJetsBackupAllEvents",
postfix="Uncorrected"
)
if not hasattr(process, "slimmedMETs"):
process.load('PhysicsTools.PatAlgos.slimming.slimmedMETs_cfi')
process.slimmedMETsUncorrected = process.slimmedMETs.clone()
task.add(process.slimmedMETs)
process.slimmedMETsUncorrected.src = cms.InputTag("patPFMetT1Uncorrected")
process.slimmedMETsUncorrected.rawVariation = cms.InputTag("patPFMetUncorrected")
process.slimmedMETsUncorrected.t1Uncertainties = cms.InputTag("patPFMetT1%sUncorrected")
process.slimmedMETsUncorrected.t01Variation = cms.InputTag("patPFMetT0pcT1Uncorrected")
process.slimmedMETsUncorrected.t1SmearedVarsAndUncs = cms.InputTag("patPFMetT1Smear%sUncorrected")
process.slimmedMETsUncorrected.tXYUncForRaw = cms.InputTag("patPFMetTxyUncorrected")
process.slimmedMETsUncorrected.tXYUncForT1 = cms.InputTag("patPFMetT1TxyUncorrected")
process.slimmedMETsUncorrected.tXYUncForT01 = cms.InputTag("patPFMetT0pcT1TxyUncorrected")
process.slimmedMETsUncorrected.tXYUncForT1Smear = cms.InputTag("patPFMetT1SmearTxyUncorrected")
process.slimmedMETsUncorrected.tXYUncForT01Smear = cms.InputTag("patPFMetT0pcT1SmearTxyUncorrected")
del process.slimmedMETsUncorrected.caloMET
# EG corrected MET
corMETFromMuonAndEG(process,
pfCandCollection="", #not needed
electronCollection=unCleanElectronCollection,
photonCollection=unCleanPhotonCollection,
corElectronCollection=cleanElectronCollection,
corPhotonCollection=cleanPhotonCollection,
allMETEGCorrected=True,
muCorrection=False,
eGCorrection=True,
runOnMiniAOD=False,
eGPFix="Uncorrected",
postfix="EGOnly"
)
process.slimmedMETsEGClean = process.slimmedMETs.clone()
task.add(process.slimmedMETsEGClean)
process.slimmedMETsEGClean.src = cms.InputTag("patPFMetT1UncorrectedEGOnly")
process.slimmedMETsEGClean.rawVariation = cms.InputTag("patPFMetRawUncorrectedEGOnly")
process.slimmedMETsEGClean.t1Uncertainties = cms.InputTag("patPFMetT1%sUncorrectedEGOnly")
process.slimmedMETsEGClean.t01Variation = cms.InputTag("patPFMetT0pcT1UncorrectedEGOnly")
process.slimmedMETsEGClean.t1SmearedVarsAndUncs = cms.InputTag("patPFMetT1Smear%sUncorrectedEGOnly")
process.slimmedMETsEGClean.tXYUncForRaw = cms.InputTag("patPFMetTxyUncorrectedEGOnly")
process.slimmedMETsEGClean.tXYUncForT1 = cms.InputTag("patPFMetT1TxyUncorrectedEGOnly")
process.slimmedMETsEGClean.tXYUncForT01 = cms.InputTag("patPFMetT0pcT1TxyUncorrectedEGOnly")
process.slimmedMETsEGClean.tXYUncForT1Smear = cms.InputTag("patPFMetT1SmearTxyUncorrectedEGOnly")
process.slimmedMETsEGClean.tXYUncForT01Smear = cms.InputTag("patPFMetT0pcT1SmearTxyUncorrectedEGOnly")
del process.slimmedMETsEGClean.caloMET
# fully corrected MET
corMETFromMuonAndEG(process,
pfCandCollection="", #not needed
electronCollection=unCleanElectronCollection,
photonCollection=unCleanPhotonCollection,
corElectronCollection=cleanElectronCollection,
corPhotonCollection=cleanPhotonCollection,
allMETEGCorrected=True,
muCorrection=False,
eGCorrection=True,
runOnMiniAOD=False,
postfix="MuEGClean"
)
process.slimmedMETsMuEGClean = process.slimmedMETs.clone()
task.add(process.slimmedMETsMuEGClean)
process.slimmedMETsMuEGClean.src = cms.InputTag("patPFMetT1MuEGClean")
process.slimmedMETsMuEGClean.rawVariation = cms.InputTag("patPFMetRawMuEGClean")
process.slimmedMETsMuEGClean.t1Uncertainties = cms.InputTag("patPFMetT1%sMuEGClean")
process.slimmedMETsMuEGClean.t01Variation = cms.InputTag("patPFMetT0pcT1MuEGClean")
process.slimmedMETsMuEGClean.t1SmearedVarsAndUncs = cms.InputTag("patPFMetT1Smear%sMuEGClean")
process.slimmedMETsMuEGClean.tXYUncForRaw = cms.InputTag("patPFMetTxyMuEGClean")
process.slimmedMETsMuEGClean.tXYUncForT1 = cms.InputTag("patPFMetT1TxyMuEGClean")
process.slimmedMETsMuEGClean.tXYUncForT01 = cms.InputTag("patPFMetT0pcT1TxyMuEGClean")
process.slimmedMETsMuEGClean.tXYUncForT1Smear = cms.InputTag("patPFMetT1SmearTxyMuEGClean")
process.slimmedMETsMuEGClean.tXYUncForT01Smear = cms.InputTag("patPFMetT0pcT1SmearTxyMuEGClean")
del process.slimmedMETsMuEGClean.caloMET
addKeepStatement(process, "keep *_slimmedMETs_*_*",
["keep *_slimmedMETsUncorrected_*_*", "keep *_slimmedMETsEGClean_*_*", "keep *_slimmedMETsMuEGClean_*_*"])
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 addExtraPuppiMETCorrections(process,
cleanPFCandidateCollection,
unCleanPFCandidateCollection,
cleanElectronCollection,
cleanPhotonCollection,
unCleanElectronCollection,
unCleanPhotonCollection
):
task = getPatAlgosToolsTask(process)
from PhysicsTools.PatUtils.tools.corMETFromMuonAndEG import corMETFromMuonAndEG
#EG correction for puppi, muon correction done right above
corMETFromMuonAndEG(process,
metType="Puppi",
electronCollection=unCleanElectronCollection,
photonCollection=unCleanPhotonCollection,
corElectronCollection=cleanElectronCollection,
corPhotonCollection=cleanPhotonCollection,
allMETEGCorrected=True,
muCorrection=False,
eGCorrection=True,
runOnMiniAOD=False,
eGPfCandMatching=True,
eGPFix="Puppi",
postfix="PuppiClean"
)
if not hasattr(process, "slimmedMETs"):
process.load('PhysicsTools.PatAlgos.slimming.slimmedMETs_cfi')
task.add(process.slimmedMETs)
process.slimmedMETsPuppi.src = cms.InputTag("patPFMetT1PuppiPuppiClean")
process.slimmedMETsPuppi.rawVariation = cms.InputTag("patPFMetRawPuppiPuppiClean")
process.slimmedMETsPuppi.t1Uncertainties = cms.InputTag("patPFMetT1%sPuppiPuppiClean")
process.slimmedMETsPuppi.t01Variation = cms.InputTag("patPFMetT0pcT1PuppiPuppiClean")
process.slimmedMETsPuppi.t1SmearedVarsAndUncs = cms.InputTag("patPFMetT1Smear%sPuppiPuppiClean")
process.slimmedMETsPuppi.tXYUncForRaw = cms.InputTag("patPFMetTxyPuppiPuppiClean")
process.slimmedMETsPuppi.tXYUncForT1 = cms.InputTag("patPFMetT1TxyPuppiPuppiClean")
process.slimmedMETsPuppi.tXYUncForT01 = cms.InputTag("patPFMetT0pcT1TxyPuppiPuppiClean")
process.slimmedMETsPuppi.tXYUncForT1Smear = cms.InputTag("patPFMetT1SmearTxyPuppiPuppiClean")
process.slimmedMETsPuppi.tXYUncForT01Smear = cms.InputTag("patPFMetT0pcT1SmearTxyPuppiPuppiClean")
#del process.slimmedMETsPuppi.caloMET
#EGamma correction
process.puppiMETEGCor = cms.EDProducer("CorrMETDataExtractor",
corrections = cms.VInputTag(
cms.InputTag("corMETPhotonPuppiClean"),
cms.InputTag("corMETElectronPuppiClean") )
)
task.add(process.puppiMETEGCor)
#Muon correction, restarting from PF candidates to take the weights
process.puppiMuonCorrection = cms.EDProducer("ShiftedParticleMETcorrInputProducer",
srcOriginal = cms.InputTag(unCleanPFCandidateCollection),
srcShifted = cms.InputTag(cleanPFCandidateCollection),
srcWeights = cms.InputTag("")
)
task.add(process.puppiMuonCorrection)
process.puppiMETMuCor = cms.EDProducer("CorrMETDataExtractor",
corrections = cms.VInputTag(
cms.InputTag("puppiMuonCorrection") )
)
task.add(process.puppiMETMuCor)
addKeepStatement(process, "keep *_slimmedMETsPuppi_*_*",
["keep *_puppiMETEGCor_*_*", "keep *_puppiMETMuCor_*_*"])
def runMETs(process, era):
dBFile = os.path.expandvars(era + ".db")
print dBFile
if usePrivateSQlite:
process.jec = cms.ESSource(
"PoolDBESSource",
CondDBSetup,
connect=cms.string("sqlite_file:" + dBFile),
toGet=cms.VPSet(
cms.PSet(record=cms.string("JetCorrectionsRecord"),
tag=cms.string("JetCorrectorParametersCollection_" +
era + "_AK4PF"),
label=cms.untracked.string("AK4PF")),
cms.PSet(record=cms.string("JetCorrectionsRecord"),
tag=cms.string("JetCorrectorParametersCollection_" +
era + "_AK4PFchs"),
label=cms.untracked.string("AK4PFchs")),
))
process.es_prefer_jec = cms.ESPrefer("PoolDBESSource", 'jec')
#===========================================================================================================================#
isMC = False
if 'MC' in dBFile:
isMC = True
##only corrects JEC/JER uncertainties for the baseline collection; means only muon corrected and EG/Muon corrected MET collections are guaranteed to have the correct JEC uncertainties.
runMetCorAndUncFromMiniAOD(
process,
metType="PF",
recoMetFromPFCs=False,
postfix="",
isData=(not isMC),
)
if isMC or os.environ["CMSSW_VERSION"].count("CMSSW_9"):
runMetCorAndUncFromMiniAOD(
process,
isData=(not isMC),
fixEE2017=True,
# will produce new MET collection: slimmedMETsModifiedMET
postfix="ModifiedMET",
)
process.flashggMets = cms.EDProducer(
'FlashggMetProducer',
verbose=cms.untracked.bool(False),
metTag=cms.InputTag('slimmedMETsModifiedMET'),
)
process.flashggMetSequence = cms.Sequence(
process.fullPatMetSequenceModifiedMET * process.flashggMets)
if not isMC and os.environ["CMSSW_VERSION"].count("CMSSW_8_0_28"):
corMETFromMuonAndEG(
process,
pfCandCollection="", #not needed
electronCollection="slimmedElectronsBeforeGSFix",
photonCollection="slimmedPhotonsBeforeGSFix",
corElectronCollection="slimmedElectrons",
corPhotonCollection="slimmedPhotons",
allMETEGCorrected=True,
muCorrection=False,
eGCorrection=True,
runOnMiniAOD=True,
postfix="FullMETClean",
)
process.slimmedMETsFullMETClean = process.slimmedMETs.clone()
process.slimmedMETsFullMETClean.src = cms.InputTag(
"patPFMetT1FullMETClean")
process.slimmedMETsFullMETClean.rawVariation = cms.InputTag(
"patPFMetRawFullMETClean")
process.slimmedMETsFullMETClean.t1Uncertainties = cms.InputTag(
"patPFMetT1%sFullMETClean")
del process.slimmedMETsFullMETClean.caloMET
process.egcorrMET = cms.Sequence(
process.cleanedPhotonsFullMETClean +
process.cleanedCorPhotonsFullMETClean +
process.matchedPhotonsFullMETClean +
process.matchedElectronsFullMETClean +
process.corMETPhotonFullMETClean +
process.corMETElectronFullMETClean +
process.patPFMetT1FullMETClean + process.patPFMetRawFullMETClean +
process.patPFMetT1SmearFullMETClean +
process.patPFMetT1TxyFullMETClean +
process.patPFMetTxyFullMETClean +
process.patPFMetT1JetEnUpFullMETClean +
process.patPFMetT1JetResUpFullMETClean +
process.patPFMetT1SmearJetResUpFullMETClean +
process.patPFMetT1ElectronEnUpFullMETClean +
process.patPFMetT1PhotonEnUpFullMETClean +
process.patPFMetT1MuonEnUpFullMETClean +
process.patPFMetT1TauEnUpFullMETClean +
process.patPFMetT1UnclusteredEnUpFullMETClean +
process.patPFMetT1JetEnDownFullMETClean +
process.patPFMetT1JetResDownFullMETClean +
process.patPFMetT1SmearJetResDownFullMETClean +
process.patPFMetT1ElectronEnDownFullMETClean +
process.patPFMetT1PhotonEnDownFullMETClean +
process.patPFMetT1MuonEnDownFullMETClean +
process.patPFMetT1TauEnDownFullMETClean +
process.patPFMetT1UnclusteredEnDownFullMETClean +
process.slimmedMETsFullMETClean)
process.flashggMets = cms.EDProducer(
'FlashggMetProducer',
verbose=cms.untracked.bool(False),
metTag=cms.InputTag('slimmedMETsModifiedMET'),
)
# process.flashggMetsMuons = cms.EDProducer('FlashggMetProducer',
# verbose = cms.untracked.bool(False),
# metTag = cms.InputTag('slimmedMETs'),
# )
# process.flashggMetsEG = cms.EDProducer('FlashggMetProducer',
# verbose = cms.untracked.bool(False),
# metTag = cms.InputTag('slimmedMETsEGClean'),
# )
# process.flashggMets = cms.EDProducer('FlashggMetProducer',
# verbose = cms.untracked.bool(False),
# metTag = cms.InputTag('slimmedMETsFullMETClean'),
# )
# process.flashggMetsEGmuon = cms.EDProducer('FlashggMetProducer',
# verbose = cms.untracked.bool(False),
# metTag = cms.InputTag('slimmedMETsMuEGClean'),
# )
# process.flashggMetsUncorr = cms.EDProducer('FlashggMetProducer',
# verbose = cms.untracked.bool(False),
# metTag = cms.InputTag('slimmedMETsUncorrected'),
# )
# process.flashggMetSequence = cms.Sequence(process.flashggMetsMuons *process.flashggMetsEGmuon*process.flashggMets*process.flashggMetsUncorr)
process.flashggMetSequence = cms.Sequence(process.flashggMets)
def runMETs(process,era):
dBFile = os.path.expandvars(era+".db")
print dBFile
if usePrivateSQlite:
process.jec = cms.ESSource("PoolDBESSource",
CondDBSetup,
connect = cms.string("sqlite_file:"+dBFile),
toGet = cms.VPSet(
cms.PSet(
record = cms.string("JetCorrectionsRecord"),
tag = cms.string("JetCorrectorParametersCollection_"+era+"_AK4PF"),
label= cms.untracked.string("AK4PF")
),
cms.PSet(
record = cms.string("JetCorrectionsRecord"),
tag = cms.string("JetCorrectorParametersCollection_"+era+"_AK4PFchs"),
label= cms.untracked.string("AK4PFchs")
),
)
)
process.es_prefer_jec = cms.ESPrefer("PoolDBESSource",'jec')
#===========================================================================================================================#
isMC = False
if 'MC' in dBFile:
isMC = True
##only corrects JEC/JER uncertainties for the baseline collection; means only muon corrected and EG/Muon corrected MET collections are guaranteed to have the correct JEC uncertainties.
runMetCorAndUncFromMiniAOD(process, metType="PF",
recoMetFromPFCs=False,
postfix="",
isData=(not isMC),
)
if isMC or os.environ["CMSSW_VERSION"].count("CMSSW_9"):
runMetCorAndUncFromMiniAOD(process,
isData=(not isMC),
fixEE2017 = True,
# will produce new MET collection: slimmedMETsModifiedMET
postfix = "ModifiedMET",
)
process.flashggMets = cms.EDProducer('FlashggMetProducer',
verbose = cms.untracked.bool(False),
metTag = cms.InputTag('slimmedMETsModifiedMET'),
)
process.flashggMetSequence = cms.Sequence(process.fullPatMetSequenceModifiedMET*process.flashggMets)
if not isMC and os.environ["CMSSW_VERSION"].count("CMSSW_8_0_28"):
corMETFromMuonAndEG(process,
pfCandCollection="", #not needed
electronCollection="slimmedElectronsBeforeGSFix",
photonCollection="slimmedPhotonsBeforeGSFix",
corElectronCollection="slimmedElectrons",
corPhotonCollection="slimmedPhotons",
allMETEGCorrected=True,
muCorrection=False,
eGCorrection=True,
runOnMiniAOD=True,
postfix="FullMETClean",
)
process.slimmedMETsFullMETClean = process.slimmedMETs.clone()
process.slimmedMETsFullMETClean.src = cms.InputTag("patPFMetT1FullMETClean")
process.slimmedMETsFullMETClean.rawVariation = cms.InputTag("patPFMetRawFullMETClean")
process.slimmedMETsFullMETClean.t1Uncertainties = cms.InputTag("patPFMetT1%sFullMETClean")
del process.slimmedMETsFullMETClean.caloMET
process.egcorrMET = cms.Sequence(
process.cleanedPhotonsFullMETClean+process.cleanedCorPhotonsFullMETClean+
process.matchedPhotonsFullMETClean + process.matchedElectronsFullMETClean +
process.corMETPhotonFullMETClean+process.corMETElectronFullMETClean+
process.patPFMetT1FullMETClean+process.patPFMetRawFullMETClean+
process.patPFMetT1SmearFullMETClean+process.patPFMetT1TxyFullMETClean+
process.patPFMetTxyFullMETClean+process.patPFMetT1JetEnUpFullMETClean+
process.patPFMetT1JetResUpFullMETClean+process.patPFMetT1SmearJetResUpFullMETClean+
process.patPFMetT1ElectronEnUpFullMETClean+process.patPFMetT1PhotonEnUpFullMETClean+
process.patPFMetT1MuonEnUpFullMETClean+process.patPFMetT1TauEnUpFullMETClean+
process.patPFMetT1UnclusteredEnUpFullMETClean+process.patPFMetT1JetEnDownFullMETClean+
process.patPFMetT1JetResDownFullMETClean+process.patPFMetT1SmearJetResDownFullMETClean+
process.patPFMetT1ElectronEnDownFullMETClean+process.patPFMetT1PhotonEnDownFullMETClean+
process.patPFMetT1MuonEnDownFullMETClean+process.patPFMetT1TauEnDownFullMETClean+
process.patPFMetT1UnclusteredEnDownFullMETClean+process.slimmedMETsFullMETClean)
process.flashggMets = cms.EDProducer('FlashggMetProducer',
verbose = cms.untracked.bool(False),
metTag = cms.InputTag('slimmedMETsModifiedMET'),
)
# process.flashggMetsMuons = cms.EDProducer('FlashggMetProducer',
# verbose = cms.untracked.bool(False),
# metTag = cms.InputTag('slimmedMETs'),
# )
# process.flashggMetsEG = cms.EDProducer('FlashggMetProducer',
# verbose = cms.untracked.bool(False),
# metTag = cms.InputTag('slimmedMETsEGClean'),
# )
# process.flashggMets = cms.EDProducer('FlashggMetProducer',
# verbose = cms.untracked.bool(False),
# metTag = cms.InputTag('slimmedMETsFullMETClean'),
# )
# process.flashggMetsEGmuon = cms.EDProducer('FlashggMetProducer',
# verbose = cms.untracked.bool(False),
# metTag = cms.InputTag('slimmedMETsMuEGClean'),
# )
# process.flashggMetsUncorr = cms.EDProducer('FlashggMetProducer',
# verbose = cms.untracked.bool(False),
# metTag = cms.InputTag('slimmedMETsUncorrected'),
# )
# process.flashggMetSequence = cms.Sequence(process.flashggMetsMuons *process.flashggMetsEGmuon*process.flashggMets*process.flashggMetsUncorr)
process.flashggMetSequence = cms.Sequence(process.flashggMets)
process.BadChargedCandidateFilter.PFCandidates = cms.InputTag('packedPFCandidates', '', 'PAT')
process.lldjMETFiltersSequence = cms.Sequence(
process.BadPFMuonFilter *
process.BadChargedCandidateFilter
)
# creae e/g corrected MET on top of the bad muon corrected MET
from PhysicsTools.PatUtils.tools.corMETFromMuonAndEG import corMETFromMuonAndEG
corMETFromMuonAndEG(process,
pfCandCollection='', #not needed
electronCollection='slimmedElectronsBeforeGSFix',
photonCollection='slimmedPhotonsBeforeGSFix',
corElectronCollection='selectedElectrons',
corPhotonCollection='selectedPhotons',
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
process.egcorrMET = cms.Sequence(
process.cleanedPhotonsMuEGClean+process.cleanedCorPhotonsMuEGClean+
process.matchedPhotonsMuEGClean + process.matchedElectronsMuEGClean +
mvaHZZValuesMap = cms.InputTag("electronMVAValueMapProducer:ElectronMVAEstimatorRun2Spring16HZZV1Values"),
mvaHZZCategoriesMap = cms.InputTag("electronMVAValueMapProducer:ElectronMVAEstimatorRun2Spring16HZZV1Categories")
)
#rerun MET sequence to update JECs
from PhysicsTools.PatUtils.tools.runMETCorrectionsAndUncertainties import runMetCorAndUncFromMiniAOD
runMetCorAndUncFromMiniAOD(process, isData=True )
# creating the e/g corrected MET on top of the bad muon corrected MET (on re-miniaod)
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
#run electron ID sequence
process.egmIDPath = cms.Path(process.egmGsfElectronIDSequence)
#run met bad track filters
