removeMCMatching(process, ['All'], outputModules=[])
## ============================== ##
## Python tools --> Order matters ##
## ============================== ##
from PhysicsTools.PatAlgos.tools.coreTools import removeCleaning
from PhysicsTools.PatAlgos.tools.coreTools import removeSpecificPATObjects
if (cmsswRelease == 42):
removeCleaning(process, False)
elif (cmsswRelease == 44):
removeCleaning(process, outputModules=[])
else:
removeCleaning(process, outputModules=[])
removeSpecificPATObjects(process,
names=['Jets', 'Taus', 'METs'],
outputModules=[])
# Special change for saving good products in data
if isData:
process.out.outputCommands = cms.untracked.vstring("keep *")
#--- Trigger matching ---#
process.load("HeavyNu.AnalysisModules.hnutrigmatch_cfi")
from PhysicsTools.PatAlgos.tools.trigTools import *
if isData:
if (runMuonAnalysis or topStudy) and runElectronAnalysis:
triggerMatchersList = [
'muonTriggerMatchHLTMuons', 'electronTriggerMatchHLTElectrons'
]
elif runMuonAnalysis or topStudy or doDijet:
if isData:
from PhysicsTools.PatAlgos.tools.coreTools import *
if isPFJets:
removeMCMatchingPF2PAT( process, '' )
if cmsswRelease == 53:
removeMCMatching(process, ['All'], outputModules = [])
## ============================== ##
## Python tools --> Order matters ##
## ============================== ##
from PhysicsTools.PatAlgos.tools.coreTools import removeCleaning
from PhysicsTools.PatAlgos.tools.coreTools import removeSpecificPATObjects
if cmsswRelease == 53:
removeCleaning( process, outputModules = [] )
removeSpecificPATObjects(process, names = ['Jets','Taus','METs'], outputModules = [])
#-------------------------------#
#--- Output Module specifics ---#
#-------------------------------#
#--- Restore the event content after PAT ---#
process.out.outputCommands = cms.untracked.vstring("keep *","drop *_*_*_HNUSKIMS","keep edmTriggerResults_TriggerResults__HNUSKIMS")
#--- List of skims that will be kept ---#
process.out.SelectEvents = cms.untracked.PSet(SelectEvents=cms.vstring('plep35_35_prescale','plep50_35','pemu50_35'))
#----------------#
#--- LumiList ---#
#----------------#
process.lumilist = cms.EDAnalyzer('LumiList')
if not isMC:
process.llPath = cms.Path(process.lumilist + process.boolFalse)
def usePF2PAT_WREdition(process, runPF2PAT=True, jetAlgo='AK5', runOnMC=True, postfix="", jetCorrections=('AK5PFchs', ['L1FastJet','L2Relative','L3Absolute']), pvCollection=cms.InputTag('offlinePrimaryVertices'), typeIMetCorrections=False, outputModules=['out']):
# PLEASE DO NOT CLOBBER THIS FUNCTION WITH CODE SPECIFIC TO A GIVEN PHYSICS OBJECT.
# CREATE ADDITIONAL FUNCTIONS IF NEEDED.
"""Switch PAT to use PF2PAT instead of AOD sources. if 'runPF2PAT' is true, we'll also add PF2PAT in front of the PAT sequence"""
# -------- CORE ---------------
if runPF2PAT:
process.load("CommonTools.ParticleFlow.PF2PAT_cff")
process.patPF2PATSequence = cms.Sequence( process.PF2PAT + process.patDefaultSequence)
else:
process.patPF2PATSequence = cms.Sequence( process.patDefaultSequence )
if not postfix == "":
from PhysicsTools.PatAlgos.tools.helpers import cloneProcessingSnippet
cloneProcessingSnippet(process, process.patPF2PATSequence, postfix)
removeCleaning(process, postfix=postfix, outputModules=outputModules)
# Photons
print "Temporarily switching off photons completely"
removeSpecificPATObjects(process,names=['Photons', 'Taus', "Muons", "Electrons"],outputModules=outputModules,postfix=postfix)
removeIfInSequence(process,"patPhotonIsolation","patDefaultSequence",postfix)
# Jets
if runOnMC :
switchToPFJets( process, cms.InputTag('pfNoTau'+postfix), jetAlgo, postfix=postfix,
jetCorrections=jetCorrections, type1=typeIMetCorrections, outputModules=outputModules )
applyPostfix(process,"patDefaultSequence",postfix).replace(
applyPostfix(process,"patJetGenJetMatch",postfix),
getattr(process,"genForPF2PATSequence") *
applyPostfix(process,"patJetGenJetMatch",postfix)
)
else :
if not 'L2L3Residual' in jetCorrections[1]:
print '#################################################'
print 'WARNING! Not using L2L3Residual but this is data.'
print 'If this is okay with you, disregard this message.'
print '#################################################'
switchToPFJets( process, cms.InputTag('pfNoTau'+postfix), jetAlgo, postfix=postfix,
jetCorrections=jetCorrections, type1=typeIMetCorrections, outputModules=outputModules )
# Taus
if ishpsPFTau:
adaptPFTaus( process, tauType='hpsPFTau', postfix=postfix )
# MET
switchToPFMET(process, cms.InputTag('pfMET'+postfix), type1=typeIMetCorrections, postfix=postfix)
if not runOnMC :
if hasattr(process,'patPFMet'+postfix):
getattr(process,'patPFMet'+postfix).addGenMET = cms.bool(False)
# Unmasked PFCandidates
addPFCandidates(process,cms.InputTag('pfNoJet'+postfix),patLabel='PFParticles'+postfix,cut="",postfix=postfix)
# adapt primary vertex collection
adaptPVs(process, pvCollection=pvCollection, postfix=postfix)
if runOnMC:
process.load("CommonTools.ParticleFlow.genForPF2PAT_cff")
getattr(process, "patDefaultSequence"+postfix).replace(
applyPostfix(process,"patCandidates",postfix),
process.genForPF2PATSequence+applyPostfix(process,"patCandidates",postfix)
)
else:
removeMCMatchingPF2PAT(process,postfix=postfix,outputModules=outputModules)
print "Done: PF2PAT interfaced to PAT, postfix=", postfix
def usePF2PATForAnalysis(jetAlgo, postfix, useTypeIMET, usePFNoPU):
# Jet corrections
# No L2L3 Residual on purpose
if usePFNoPU:
jetCorrections = ("%sPFchs" % algo, ['L1FastJet', 'L2Relative', 'L3Absolute'])
postfix += "chs"
else:
jetCorrections = ("%sPF" % algo, ['L1FastJet', 'L2Relative', 'L3Absolute'])
#if not runOnMC:
# jetCorrections[1].append('L2L3Residual')
p = postfix
usePF2PAT(process, runPF2PAT=True, jetAlgo=jetAlgo, runOnMC=runOnMC, postfix=p, jetCorrections=jetCorrections, typeIMetCorrections = useTypeIMET)
getattr(process, "pfPileUp" + p).Enable = True
getattr(process, "pfPileUp" + p).Vertices = 'goodOfflinePrimaryVertices'
getattr(process, "pfPileUp" + p).checkClosestZVertex = cms.bool(False)
getattr(process, "pfJets" + p).doAreaFastjet = cms.bool(True)
getattr(process, "pfJets" + p).doRhoFastjet = False
getattr(process, 'patJetCorrFactors' + p).rho = cms.InputTag("kt6PFJets", "rho") # Do not use kt6PFJetsPFlowAK5, it's not ok for L1FastJet.
# top projections in PF2PAT:
getattr(process,"pfNoPileUp" + p).enable = cms.bool(usePFNoPU)
getattr(process,"pfNoMuon" + p).enable = True
getattr(process,"pfNoElectron" + p).enable = True
getattr(process,"pfNoTau" + p).enable = True
getattr(process,"pfNoJet" + p).enable = True
getattr(process,"patElectrons" + p).embedTrack = True
getattr(process,"patMuons" + p).embedTrack = True
# enable delta beta correction for muon selection in PF2PAT?
getattr(process,"pfIsolatedMuons" + p).doDeltaBetaCorrection = True
getattr(process, "patJets" + p).embedPFCandidates = False
# Keep only jets with pt > 2 Gev
getattr(process, "selectedPatJets" + p).cut = "pt > 2";
# Use a cone of 0.3 for photon isolation
#adaptPFIsoPhotons(process, applyPostfix(process, "patPhotons", postfix), postfix, "03")
# 2012 Photon ID
# Electron conversion
setattr(process, "patConversions" + p, cms.EDProducer("PATConversionProducer",
# input collection
electronSource = cms.InputTag("selectedPatElectrons" + p)
))
# Switch electron isolation to dR = 0.3, for PF2PAT
getattr(process, "pfIsolatedElectrons" + p).isolationValueMapsCharged = cms.VInputTag(cms.InputTag("elPFIsoValueCharged03PFId" + p))
getattr(process, "pfIsolatedElectrons" + p).deltaBetaIsolationValueMap = cms.InputTag("elPFIsoValuePU03PFId" + p)
getattr(process, "pfIsolatedElectrons" + p).isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("elPFIsoValueNeutral03PFId" + p), cms.InputTag("elPFIsoValueGamma03PFId" + p))
getattr(process, "pfElectrons" + p).isolationValueMapsCharged = cms.VInputTag(cms.InputTag("elPFIsoValueCharged03PFId" + p))
getattr(process, "pfElectrons" + p).deltaBetaIsolationValueMap = cms.InputTag("elPFIsoValuePU03PFId" + p)
getattr(process, "pfElectrons" + p).isolationValueMapsNeutral = cms.VInputTag(cms.InputTag( "elPFIsoValueNeutral03PFId" + p), cms.InputTag("elPFIsoValueGamma03PFId" + p))
# ... And for PAT
adaptPFIsoElectrons(process, getattr(process, "pfElectrons" + p), p, "03")
if runOnMC:
cloneProcessingSnippet(process, getattr(process, "makePatMuons" + p), "Loose" + p, p)
getattr(process, "muonMatchLoose" + p).src = cms.InputTag("pfMuons" + p)
getattr(process, "patMuonsLoose" + p).pfMuonSource = cms.InputTag("pfMuons" + p)
getattr(process, "patDefaultSequence" + p).replace(getattr(process, "makePatMuons" + p), getattr(process, "makePatMuons" + p) + getattr(process, "makePatMuonsLoose" + p))
else:
setattr(process, "patMuonsLoose" + p, getattr(process, "patMuons" + p).clone(
pfMuonSource = cms.InputTag("pfMuons" + p)
)
)
setattr(process, "selectedPatMuonsLoose" + p, getattr(process, "selectedPatMuons" + p).clone(
src = cms.InputTag("patMuonsLoose" + p)
)
)
sequence = getattr(process, "patDefaultSequence" + p)
if not runOnMC:
sequence += getattr(process, "patMuonsLoose" + p)
sequence += (getattr(process, "selectedPatMuonsLoose" + p))
setattr(process, "patElectronsLoose" + p, getattr(process, "patElectrons" + p).clone(
pfElectronSource = cms.InputTag("pfElectrons" + p)
)
)
setattr(process, "selectedPatElectronsLoose" + p, getattr(process, "selectedPatElectrons" + p).clone(
src = cms.InputTag("patElectronsLoose" + p)
)
)
adaptPFIsoElectrons(process, getattr(process, "patElectronsLoose" + p), postfix, "03")
sequence = getattr(process, "patDefaultSequence" + p)
sequence += (getattr(process, "patElectronsLoose" + p) * getattr(process, "selectedPatElectronsLoose" + p))
#giulia turn off qg tagger
## Setup quark gluon tagger
#process.load('QuarkGluonTagger.EightTeV.QGTagger_RecoJets_cff')
#cloneProcessingSnippet(process, process.QuarkGluonTagger, p)
#getattr(process, "QGTagger" + p).srcJets = cms.InputTag("selectedPatJets" + p)
#getattr(process, "QGTagger" + p).isPatJet = cms.untracked.bool(True)
#getattr(process, "QGTagger" + p).useCHS = cms.untracked.bool(usePFNoPU)
## Remove the processing of primary vertices, as it's already what we do here
#getattr(process, 'QGTagger' + p).srcPV = cms.InputTag('goodOfflinePrimaryVertices')
#getattr(process, 'QuarkGluonTagger' + p).remove(getattr(process, 'goodOfflinePrimaryVerticesQG' + p))
if not runOnMC:
if 'L2L3Residual' in jetCorrections:
getattr(process, 'patPFJetMETtype1p2Corr' + p).jetCorrLabel = 'L2L3Residual'
getattr(process, 'patPFMet' + p).addGenMET = cms.bool(False)
names = ["Taus"]
#if jetAlgo != "AK5":
#names += ["Electrons", "Muons"]
if len(names) > 0:
removeSpecificPATObjects(process, names = names, outputModules = ['out'], postfix = p)
adaptPVs(process, pvCollection = cms.InputTag("goodOfflinePrimaryVertices"), postfix = p)
getattr(process, "patDefaultSequence" + p).replace(getattr(process, "selectedPatElectrons" + p), getattr(process, "selectedPatElectrons" + p) + getattr(process, "patConversions" + p))
#getattr(process, "patDefaultSequence" + p).replace(getattr(process, "selectedPatJets" + p), getattr(process, "selectedPatJets" + p) + getattr(process, "QuarkGluonTagger" + p))
return getattr(process, "patPF2PATSequence" + p)
)
process.selectionSequence = cms.Sequence()
from PhysicsTools.PatAlgos.tools.coreTools import removeSpecificPATObjects, removeCleaning
from HiggsAnalysis.HeavyChHiggsToTauNu.HChPatTuple import addPat
from HiggsAnalysis.HeavyChHiggsToTauNu.HChDataSelection import addDataSelection
if options.doPat != 0:
process.collisionDataSelection = cms.Sequence()
if dataVersion.isData():
process.collisionDataSelection = addDataSelection(process, dataVersion, trigger)
process.patSequence = addPat(process, dataVersion, doPatTrigger=False, doTauHLTMatching=False,
doPatTaus=False, doPatElectronID=False)
removeSpecificPATObjects(process, ["Photons"], False)
removeCleaning(process, False)
process.patMuons.embedTrack = False # In order to avoid transient references and generalTracks is available anyway
process.selectionSequence = cms.Sequence(
process.collisionDataSelection *
process.patSequence
)
# Override the outputCommands here, since PAT modifies it
process.out.outputCommands = cms.untracked.vstring(
"drop *",
"keep edmMergeableCounter_*_*_*", # in lumi block
"keep *_muonNtp_*_MUONNTUPLE",
"keep *_metNtp_*_MUONNTUPLE",
"keep *_jetNtp_*_MUONNTUPLE",
import TopQuarkAnalysis.Configuration.patRefSel_refMuJets_cfi as patRefSel_refMuJets_cfi
# remove MC matching, object cleaning, objects etc.
## remove MCMatching if run on Data
if options.runOnData:
from PhysicsTools.PatAlgos.tools.coreTools import runOnData
runOnData(process, names = [ 'PFAll' ],postfix =postfix)
print "removeMatching"
if not runOnMC:
runOnData( process
, names = [ 'PFAll' ]
, postfix = postfix
)
PhysPatAlgCoreTools.removeSpecificPATObjects( process
, names = [ 'Photons', 'Taus' ]
, postfix = postfix
) # includes 'removeCleaning'
# additional event content has to be (re-)added _after_ the call to 'removeCleaning()':
process.out.outputCommands += [ 'keep edmTriggerResults_*_*_*'
, 'keep *_hltTriggerSummaryAOD_*_*'
# vertices and beam spot
, 'keep *_offlineBeamSpot_*_*'
, 'keep *_offlinePrimaryVertices*_*_*'
, 'keep *_goodOfflinePrimaryVertices*_*_*'
]
if runOnMC:
process.out.outputCommands += [ 'keep GenEventInfoProduct_*_*_*'
, 'keep recoGenParticles_*_*_*'
, 'keep *_addPileupInfo_*_*'
]
from HiggsAnalysis.HeavyChHiggsToTauNu.HChPatTuple import addPat
from HiggsAnalysis.HeavyChHiggsToTauNu.HChDataSelection import addDataSelection
if options.doPat != 0:
process.collisionDataSelection = cms.Sequence()
if dataVersion.isData():
process.collisionDataSelection = addDataSelection(
process, dataVersion, trigger)
process.patSequence = addPat(process,
dataVersion,
doPatTrigger=False,
doTauHLTMatching=False,
doPatTaus=False,
doPatElectronID=False)
removeSpecificPATObjects(process, ["Photons"], False)
removeCleaning(process, False)
process.patMuons.embedTrack = False # In order to avoid transient references and generalTracks is available anyway
process.selectionSequence = cms.Sequence(process.collisionDataSelection *
process.patSequence)
# Override the outputCommands here, since PAT modifies it
process.out.outputCommands = cms.untracked.vstring(
"drop *",
"keep edmMergeableCounter_*_*_*", # in lumi block
"keep *_muonNtp_*_MUONNTUPLE",
"keep *_metNtp_*_MUONNTUPLE",
"keep *_jetNtp_*_MUONNTUPLE",
"keep *_jetIdNtp_*_MUONNTUPLE",
)
def usePF2PATForAnalysis(jetAlgo, postfix, useTypeIMET, usePFNoPU):
# Jet corrections
# No L2L3 Residual on purpose
if usePFNoPU:
jetCorrections = ("%sPFchs" % algo, ['L1FastJet', 'L2Relative', 'L3Absolute'])
postfix += "chs"
else:
jetCorrections = ("%sPF" % algo, ['L1FastJet', 'L2Relative', 'L3Absolute'])
#if not runOnMC:
# jetCorrections[1].append('L2L3Residual')
p = postfix
usePF2PAT(process, runPF2PAT=True, jetAlgo=jetAlgo, runOnMC=runOnMC, postfix=p, jetCorrections=jetCorrections, typeIMetCorrections = useTypeIMET)
getattr(process, "pfPileUp" + p).Enable = True
getattr(process, "pfPileUp" + p).Vertices = 'goodOfflinePrimaryVertices'
getattr(process, "pfPileUp" + p).checkClosestZVertex = cms.bool(False)
getattr(process, "pfJets" + p).doAreaFastjet = cms.bool(True)
getattr(process, "pfJets" + p).doRhoFastjet = False
getattr(process, 'patJetCorrFactors' + p).rho = cms.InputTag("kt6PFJets", "rho") # Do not use kt6PFJetsPFlowAK5, it's not ok for L1FastJet.
# top projections in PF2PAT:
getattr(process,"pfNoPileUp" + p).enable = cms.bool(usePFNoPU)
getattr(process,"pfNoMuon" + p).enable = True
getattr(process,"pfNoElectron" + p).enable = True
getattr(process,"pfNoTau" + p).enable = True
getattr(process,"pfNoJet" + p).enable = True
getattr(process,"patElectrons" + p).embedTrack = True
getattr(process,"patMuons" + p).embedTrack = True
# enable delta beta correction for muon selection in PF2PAT?
getattr(process,"pfIsolatedMuons" + p).doDeltaBetaCorrection = True
getattr(process, "patJets" + p).embedPFCandidates = False
# Keep only jets with pt > 2 Gev
getattr(process, "selectedPatJets" + p).cut = "pt > 2";
# Use a cone of 0.3 for photon isolation
#adaptPFIsoPhotons(process, applyPostfix(process, "patPhotons", postfix), postfix, "03")
# 2012 Photon ID
# Electron conversion
setattr(process, "patConversions" + p, cms.EDProducer("PATConversionProducer",
# input collection
electronSource = cms.InputTag("selectedPatElectrons" + p)
))
# Switch electron isolation to dR = 0.3, for PF2PAT
getattr(process, "pfIsolatedElectrons" + p).isolationValueMapsCharged = cms.VInputTag(cms.InputTag("elPFIsoValueCharged03PFId" + p))
getattr(process, "pfIsolatedElectrons" + p).deltaBetaIsolationValueMap = cms.InputTag("elPFIsoValuePU03PFId" + p)
getattr(process, "pfIsolatedElectrons" + p).isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("elPFIsoValueNeutral03PFId" + p), cms.InputTag("elPFIsoValueGamma03PFId" + p))
getattr(process, "pfElectrons" + p).isolationValueMapsCharged = cms.VInputTag(cms.InputTag("elPFIsoValueCharged03PFId" + p))
getattr(process, "pfElectrons" + p).deltaBetaIsolationValueMap = cms.InputTag("elPFIsoValuePU03PFId" + p)
getattr(process, "pfElectrons" + p).isolationValueMapsNeutral = cms.VInputTag(cms.InputTag( "elPFIsoValueNeutral03PFId" + p), cms.InputTag("elPFIsoValueGamma03PFId" + p))
# ... And for PAT
adaptPFIsoElectrons(process, getattr(process, "pfElectrons" + p), p, "03")
##there used to be a modulo to keep track of muons gen info, doesnt work anymore and we don't use that info - so removed for now.
setattr(process, "patMuonsLoose" + p, getattr(process, "patMuons" + p).clone(
pfMuonSource = cms.InputTag("pfMuons" + p),
embedGenMatch = False,
addGenMatch = False
)
)
setattr(process, "selectedPatMuonsLoose" + p, getattr(process, "selectedPatMuons" + p).clone(
src = cms.InputTag("patMuonsLoose" + p)
)
)
sequence = getattr(process, "patDefaultSequence" + p)
sequence += getattr(process, "patMuonsLoose" + p)
sequence += (getattr(process, "selectedPatMuonsLoose" + p))
setattr(process, "patElectronsLoose" + p, getattr(process, "patElectrons" + p).clone(
pfElectronSource = cms.InputTag("pfElectrons" + p)
)
)
setattr(process, "selectedPatElectronsLoose" + p, getattr(process, "selectedPatElectrons" + p).clone(
src = cms.InputTag("patElectronsLoose" + p)
)
)
adaptPFIsoElectrons(process, getattr(process, "patElectronsLoose" + p), postfix, "03")
sequence = getattr(process, "patDefaultSequence" + p)
sequence += (getattr(process, "patElectronsLoose" + p) * getattr(process, "selectedPatElectronsLoose" + p))
# Setup quark gluon tagger
#process.load('QuarkGluonTagger.EightTeV.QGTagger_RecoJets_cff')
#cloneProcessingSnippet(process, process.QuarkGluonTagger, p)
#getattr(process, "QGTagger" + p).srcJets = cms.InputTag("selectedPatJets" + p)
#getattr(process, "QGTagger" + p).isPatJet = cms.untracked.bool(True)
#getattr(process, "QGTagger" + p).useCHS = cms.untracked.bool(usePFNoPU)
## Remove the processing of primary vertices, as it's already what we do here
#getattr(process, 'QGTagger' + p).srcPV = cms.InputTag('goodOfflinePrimaryVertices')
#getattr(process, 'QuarkGluonTagger' + p).remove(getattr(process, 'goodOfflinePrimaryVerticesQG' + p))
if not runOnMC:
if 'L2L3Residual' in jetCorrections:
getattr(process, 'patPFJetMETtype1p2Corr' + p).jetCorrLabel = 'L2L3Residual'
getattr(process, 'patPFMet' + p).addGenMET = cms.bool(False)
names = ["Taus"]
#if jetAlgo != "AK5":
#names += ["Electrons", "Muons"]
if len(names) > 0:
removeSpecificPATObjects(process, names = names, outputModules = ['out'], postfix = p)
adaptPVs(process, pvCollection = cms.InputTag("goodOfflinePrimaryVertices"), postfix = p)
getattr(process, "patDefaultSequence" + p).replace(getattr(process, "selectedPatElectrons" + p), getattr(process, "selectedPatElectrons" + p) + getattr(process, "patConversions" + p))
#getattr(process, "patDefaultSequence" + p).replace(getattr(process, "selectedPatJets" + p), getattr(process, "selectedPatJets" + p) + getattr(process, "QuarkGluonTagger" + p))
return getattr(process, "patPF2PATSequence" + p)
if not runOnMC:
runOnData(process, names = ['PFAll'], postfix = 'PF')
# We remove PAT photons here because they are not fully commisssioned
# in PF. (You could turn them on to check their performance.) This
# also turns off a cleaning step, which in the default PAT workflow
# tries to remove overlap between the physics object collections
# (e.g. removing muons from being reconstructed as degenerate "jets"),
# but this is not necessary with PF/the GED, especially with the top
# projections described above enabled.
from PhysicsTools.PatAlgos.tools.coreTools import removeSpecificPATObjects
removeSpecificPATObjects(process, names = ['Photons'], postfix = 'PF')
# Now we configure the job to keep ttbar events in all three decay
# modes. For hadronic, we will require that there be four
# reconstructed jets (the main hadronic trigger requires this anyway).
#
# For leptonic and dileptonic, we want to keep events with either one
# or two leptons (electrons or muons -- tau reconstruction is
# harder). What we will call a lepton depends on the mode: with one
# lepton, we need to cut a bit harder to increase the ttbar signal
# over the (W+jets) background. If we have two leptons, we don't have
# to cut as hard.
#
def addPat(process, isData, doRECO, doTTEffShrinkingConePFTau):
sequence = cms.Sequence()
# If running together with RECO
# We get another kt6PFJets from PAT, and as-is they clash producing an exception
runningWithReco = hasattr(process, "recoAllPFJets")
if runningWithReco:
process.recoAllPFJets.remove(process.kt6PFJets)
process.recoPFJets.remove(process.kt6PFJets)
process.load("PhysicsTools.PatAlgos.patSequences_cff")
if runningWithReco:
process.recoAllPFJets.replace(process.kt4PFJets,
process.kt4PFJets * process.kt6PFJets)
process.recoPFJets.replace(process.kt4PFJets,
process.kt4PFJets * process.kt6PFJets)
# process.load("PhysicsTools.PatAlgos.producersLayer1.patCandidates_cff")
# Calculate PF isolation of the muon
#process.muonPFIsolationSequence = MuonPFIsolation.addMuonPFIsolation(process, "muons", process.patMuons)
#sequence += process.muonPFIsolationSequence
if doRECO:
process.pfPileUpIso.PFCandidates = "particleFlowTmp" # I don't know why I have to do this
process.pfNoPileUpIso.bottomCollection = "particleFlowTmp"
jetCorr = ["L1FastJet", "L2Relative", "L3Absolute"]
if isData:
jetCorr.append("L2L3Residual")
# coreTools.removeMCMatching(process, ["All"], outputInProcess=False)
coreTools.removeMCMatching(process, ["All"], outputModules=[])
#### coreTools.removeCleaning(process, False)
coreTools.removeCleaning(process, outputModules=[])
#### coreTools.removeSpecificPATObjects(process, ["Electrons", "Photons", "METs"], False)
coreTools.removeSpecificPATObjects(process,
["Electrons", "Photons", "METs"],
outputModules=[])
tauTools.addTauCollection(process,
cms.InputTag('hpsPFTauProducer'),
algoLabel="hps",
typeLabel="PFTau")
jetTools.switchJetCollection(process,
cms.InputTag('ak5PFJets'),
doJTA=True,
doBTagging=True,
jetCorrLabel=('AK5PF', jetCorr),
doType1MET=False,
genJetCollection=cms.InputTag("ak5GenJets"),
doJetID=False,
jetIdLabel="ak5",
outputModules=[])
# If the reference tau should be the old TTEff shrinking cone
# if doTTEffShrinkingConePFTau:
# process.patTaus.tauSource = "TTEffShrinkingConePFTauProducer"
# for module in [process.tauIsoDepositPFCandidates, process.tauIsoDepositPFChargedHadrons, process.tauIsoDepositPFGammas, process.tauIsoDepositPFNeutralHadrons]:
# module.src = "TTEffShrinkingConePFTauProducer"
# module.ExtractorPSet.tauSource = "TTEffShrinkingConePFTauProducer"
# process.tauMatch.src = "TTEffShrinkingConePFTauProducer"
# process.patTaus.tauIDSources.leadingPionPtCut = "TTEffPFTauDiscriminationByLeadingPionPtCut"
# process.patTaus.tauIDSources.byIsolationUsingLeadingPion = "TTEffPFTauDiscriminationByIsolationUsingLeadingPion"
# process.patTaus.tauIDSources.leadingTrackFinding = "TTEffPFTauDiscriminationByLeadingTrackFinding"
# process.patTaus.tauIDSources.againstMuon = "TTEffPFTauDiscriminationAgainstMuon"
# process.patTaus.tauIDSources.againstElectron = "TTEffPFTauDiscriminationAgainstElectron"
# process.selectedPatTaus.cut = "pt() > 15 && abs(eta()) < 2.5 && tauID('leadingPionPtCut')"
sequence += process.patDefaultSequence
return sequence
def createProcess(runOnMC, runCHS, correctMETWithT1, processCaloJets, globalTag):
## import skeleton process
from PhysicsTools.PatAlgos.patTemplate_cfg import process
# load the PAT config
process.load("PhysicsTools.PatAlgos.patSequences_cff")
process.load("JetMETCorrections.Configuration.JetCorrectionProducers_cff")
# Do some CHS stuff
process.ak5PFchsL1Fastjet = process.ak5PFL1Fastjet.clone(algorithm = 'AK5PFchs')
process.ak5PFchsL2Relative = process.ak5PFL2Relative.clone(algorithm = 'AK5PFchs')
process.ak5PFchsL3Absolute = process.ak5PFL3Absolute.clone(algorithm = 'AK5PFchs')
process.ak5PFchsResidual = process.ak5PFResidual.clone(algorithm = 'AK5PFchs')
process.ak5PFchsL1FastL2L3 = cms.ESProducer(
'JetCorrectionESChain',
correctors = cms.vstring('ak5PFchsL1Fastjet', 'ak5PFchsL2Relative','ak5PFchsL3Absolute')
)
from PhysicsTools.SelectorUtils.pvSelector_cfi import pvSelector
## The good primary vertex filter ____________________________________________||
## This filter throw events with no primary vertex
process.primaryVertexFilter = cms.EDFilter(
"VertexSelector",
src = cms.InputTag("offlinePrimaryVertices"),
cut = cms.string("!isFake && ndof > 4 && abs(z) <= 24 && position.Rho <= 2"),
filter = cms.bool(True)
)
process.goodOfflinePrimaryVertices = cms.EDFilter("PrimaryVertexObjectFilter",
filterParams = pvSelector.clone( minNdof = cms.double(4.0), maxZ = cms.double(24.0) ),
src = cms.InputTag('offlinePrimaryVertices')
)
# Configure PAT to use PF2PAT instead of AOD sources
# this function will modify the PAT sequences.
from PhysicsTools.PatAlgos.tools.coreTools import removeSpecificPATObjects, removeMCMatching
from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT, adaptPFIsoElectrons, adaptPVs, usePFIso
#from PhysicsTools.PatAlgos.tools.metTools import *
def usePF2PATForAnalysis(jetAlgo, postfix, useTypeIMET, usePFNoPU):
# Jet corrections
# No L2L3 Residual on purpose
if usePFNoPU:
jetCorrections = ("%sPFchs" % algo, ['L1FastJet', 'L2Relative', 'L3Absolute'])
postfix += "chs"
else:
jetCorrections = ("%sPF" % algo, ['L1FastJet', 'L2Relative', 'L3Absolute'])
#if not runOnMC:
# jetCorrections[1].append('L2L3Residual')
p = postfix
usePF2PAT(process, runPF2PAT=True, jetAlgo=jetAlgo, runOnMC=runOnMC, postfix=p, jetCorrections=jetCorrections, typeIMetCorrections = useTypeIMET)
getattr(process, "pfPileUp" + p).Enable = True
getattr(process, "pfPileUp" + p).Vertices = 'goodOfflinePrimaryVertices'
getattr(process, "pfPileUp" + p).checkClosestZVertex = cms.bool(False)
getattr(process, "pfJets" + p).doAreaFastjet = cms.bool(True)
getattr(process, "pfJets" + p).doRhoFastjet = False
getattr(process, 'patJetCorrFactors' + p).rho = cms.InputTag("kt6PFJets", "rho") # Do not use kt6PFJetsPFlowAK5, it's not ok for L1FastJet.
# top projections in PF2PAT:
getattr(process,"pfNoPileUp" + p).enable = cms.bool(usePFNoPU)
getattr(process,"pfNoMuon" + p).enable = True
getattr(process,"pfNoElectron" + p).enable = True
getattr(process,"pfNoTau" + p).enable = True
getattr(process,"pfNoJet" + p).enable = True
getattr(process,"patElectrons" + p).embedTrack = True
getattr(process,"patMuons" + p).embedTrack = True
# enable delta beta correction for muon selection in PF2PAT?
getattr(process,"pfIsolatedMuons" + p).doDeltaBetaCorrection = True
getattr(process, "patJets" + p).embedPFCandidates = False
# Keep only jets with pt > 2 Gev
getattr(process, "selectedPatJets" + p).cut = "pt > 2";
# Use a cone of 0.3 for photon isolation
#adaptPFIsoPhotons(process, applyPostfix(process, "patPhotons", postfix), postfix, "03")
# 2012 Photon ID
# Electron conversion
setattr(process, "patConversions" + p, cms.EDProducer("PATConversionProducer",
# input collection
electronSource = cms.InputTag("selectedPatElectrons" + p)
))
# Switch electron isolation to dR = 0.3, for PF2PAT
getattr(process, "pfIsolatedElectrons" + p).isolationValueMapsCharged = cms.VInputTag(cms.InputTag("elPFIsoValueCharged03PFId" + p))
getattr(process, "pfIsolatedElectrons" + p).deltaBetaIsolationValueMap = cms.InputTag("elPFIsoValuePU03PFId" + p)
getattr(process, "pfIsolatedElectrons" + p).isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("elPFIsoValueNeutral03PFId" + p), cms.InputTag("elPFIsoValueGamma03PFId" + p))
getattr(process, "pfElectrons" + p).isolationValueMapsCharged = cms.VInputTag(cms.InputTag("elPFIsoValueCharged03PFId" + p))
getattr(process, "pfElectrons" + p).deltaBetaIsolationValueMap = cms.InputTag("elPFIsoValuePU03PFId" + p)
getattr(process, "pfElectrons" + p).isolationValueMapsNeutral = cms.VInputTag(cms.InputTag( "elPFIsoValueNeutral03PFId" + p), cms.InputTag("elPFIsoValueGamma03PFId" + p))
# ... And for PAT
adaptPFIsoElectrons(process, getattr(process, "pfElectrons" + p), p, "03")
##there used to be a modulo to keep track of muons gen info, doesnt work anymore and we don't use that info - so removed for now.
setattr(process, "patMuonsLoose" + p, getattr(process, "patMuons" + p).clone(
pfMuonSource = cms.InputTag("pfMuons" + p),
embedGenMatch = False,
addGenMatch = False
)
)
setattr(process, "selectedPatMuonsLoose" + p, getattr(process, "selectedPatMuons" + p).clone(
src = cms.InputTag("patMuonsLoose" + p)
)
)
sequence = getattr(process, "patDefaultSequence" + p)
sequence += getattr(process, "patMuonsLoose" + p)
sequence += (getattr(process, "selectedPatMuonsLoose" + p))
setattr(process, "patElectronsLoose" + p, getattr(process, "patElectrons" + p).clone(
pfElectronSource = cms.InputTag("pfElectrons" + p)
)
)
setattr(process, "selectedPatElectronsLoose" + p, getattr(process, "selectedPatElectrons" + p).clone(
src = cms.InputTag("patElectronsLoose" + p)
)
)
adaptPFIsoElectrons(process, getattr(process, "patElectronsLoose" + p), postfix, "03")
sequence = getattr(process, "patDefaultSequence" + p)
sequence += (getattr(process, "patElectronsLoose" + p) * getattr(process, "selectedPatElectronsLoose" + p))
# Setup quark gluon tagger
#process.load('QuarkGluonTagger.EightTeV.QGTagger_RecoJets_cff')
#cloneProcessingSnippet(process, process.QuarkGluonTagger, p)
#getattr(process, "QGTagger" + p).srcJets = cms.InputTag("selectedPatJets" + p)
#getattr(process, "QGTagger" + p).isPatJet = cms.untracked.bool(True)
#getattr(process, "QGTagger" + p).useCHS = cms.untracked.bool(usePFNoPU)
## Remove the processing of primary vertices, as it's already what we do here
#getattr(process, 'QGTagger' + p).srcPV = cms.InputTag('goodOfflinePrimaryVertices')
#getattr(process, 'QuarkGluonTagger' + p).remove(getattr(process, 'goodOfflinePrimaryVerticesQG' + p))
if not runOnMC:
if 'L2L3Residual' in jetCorrections:
getattr(process, 'patPFJetMETtype1p2Corr' + p).jetCorrLabel = 'L2L3Residual'
getattr(process, 'patPFMet' + p).addGenMET = cms.bool(False)
names = ["Taus"]
#if jetAlgo != "AK5":
#names += ["Electrons", "Muons"]
if len(names) > 0:
removeSpecificPATObjects(process, names = names, outputModules = ['out'], postfix = p)
adaptPVs(process, pvCollection = cms.InputTag("goodOfflinePrimaryVertices"), postfix = p)
getattr(process, "patDefaultSequence" + p).replace(getattr(process, "selectedPatElectrons" + p), getattr(process, "selectedPatElectrons" + p) + getattr(process, "patConversions" + p))
#getattr(process, "patDefaultSequence" + p).replace(getattr(process, "selectedPatJets" + p), getattr(process, "selectedPatJets" + p) + getattr(process, "QuarkGluonTagger" + p))
return getattr(process, "patPF2PATSequence" + p)
if correctMETWithT1:
process.load("PhysicsTools.PatUtils.patPFMETCorrections_cff")
from PhysicsTools.PatAlgos.tools.helpers import cloneProcessingSnippet
print "##########################"
print "PF jets with PF2PAT"
print "Using Type I met" if correctMETWithT1 else "NOT using Type I met"
print "##########################"
#runCHS = False
#postfixes = {'PFlowAK5': 'AK5', 'PFlowAK7': 'AK7'}
postfixes = {'PFlowAK5': 'AK5'}
# Setup quark gluon tagger
process.load('QuarkGluonTagger.EightTeV.QGTagger_RecoJets_cff')
process.sequence_chs = cms.Sequence()
process.sequence_nochs = cms.Sequence()
for p, algo in postfixes.items():
process.sequence_nochs += usePF2PATForAnalysis(jetAlgo=algo, postfix=p, usePFNoPU=False, useTypeIMET=correctMETWithT1)
if runCHS:
process.sequence_chs += usePF2PATForAnalysis(jetAlgo=algo, postfix=p, usePFNoPU=True, useTypeIMET=correctMETWithT1)
setattr(process, 'QGTagger' + p, process.QGTagger.clone())
getattr(process, "QGTagger" + p).srcJets = cms.InputTag("selectedPatJets" + p)
getattr(process, "QGTagger" + p).isPatJet = cms.untracked.bool(True)
getattr(process, "QGTagger" + p).useCHS = cms.untracked.bool(False)
process.QuarkGluonTagger.replace(process.QGTagger, getattr(process, 'QGTagger' + p))
if runCHS:
chsP = p + "chs"
setattr(process, 'QGTagger' + chsP, process.QGTagger.clone())
getattr(process, "QGTagger" + chsP).srcJets = cms.InputTag("selectedPatJets" + chsP)
getattr(process, "QGTagger" + chsP).isPatJet = cms.untracked.bool(True)
getattr(process, "QGTagger" + chsP).useCHS = cms.untracked.bool(True)
process.QuarkGluonTagger.replace(getattr(process, 'QGTagger' + p), getattr(process, 'QGTagger' + p) + getattr(process, 'QGTagger' + chsP))
print "##########################"
print "Calo jets" if processCaloJets else "No processing of calo jets"
print "##########################"
usePFIso(process, "")
#adaptPFIsoPhotons(process, process.patPhotons, "", "03")
if processCaloJets:
# No L2L3 Residual on purpose
jetCorrections = ('AK5Calo', ['L1Offset', 'L2Relative', 'L3Absolute'])
addJetCollection(process, cms.InputTag('ak7CaloJets'),
'AK7',
'Calo',
doJTA = True,
doBTagging = True,
jetCorrLabel = jetCorrections,
doType1MET = correctMETWithT1,
doL1Cleaning = False,
doL1Counters = False,
genJetCollection = cms.InputTag("ak7GenJets"),
doJetID = True,
jetIdLabel = "ak7"
)
switchJetCollection(process, cms.InputTag('ak5CaloJets'),
doJTA = True,
doBTagging = True,
jetCorrLabel = jetCorrections,
doType1MET = correctMETWithT1,
genJetCollection = cms.InputTag("ak5GenJets"),
doJetID = True,
jetIdLabel = "ak5"
)
process.selectedPatJets.cut = "pt > 2"
process.selectedPatJetsAK7Calo.cut = "pt > 2"
else:
removeSpecificPATObjects(process, names = ['Jets', 'METs'])
if not runOnMC:
# Remove MC Matching
removeMCMatching(process, names = ["All"])
removeSpecificPATObjects(process, names = ['Electrons', 'Muons', 'Taus'])
if runCHS:
print "##########################"
print "Running CHS sequence"
print "##########################"
process.analysisSequence = cms.Sequence()
process.analysisSequence *= process.sequence_nochs
if runCHS:
process.analysisSequence *= process.sequence_chs
# Quark Gluon tagging
process.analysisSequence *= process.QuarkGluonTagger
# Add default pat sequence to our path
# This brings to life TcMET, Calo jets and Photons
process.analysisSequence *= process.patDefaultSequence
# Add our PhotonIsolationProducer to the analysisSequence. This producer compute pf isolations
# for our photons
process.photonPFIsolation = cms.EDProducer("PhotonIsolationProducer",
src = cms.InputTag("selectedPatPhotons")
)
process.analysisSequence *= process.photonPFIsolation
# Filtering
# require physics declared
process.load('HLTrigger.special.hltPhysicsDeclared_cfi')
process.hltPhysicsDeclared.L1GtReadoutRecordTag = 'gtDigis'
# require scraping filter
process.scrapingVeto = cms.EDFilter("FilterOutScraping",
applyfilter = cms.untracked.bool(True),
debugOn = cms.untracked.bool(False),
numtrack = cms.untracked.uint32(10),
thresh = cms.untracked.double(0.25)
)
# Count events
process.nEventsTotal = cms.EDProducer("EventCountProducer")
process.nEventsFiltered = cms.EDProducer("EventCountProducer")
# MET Filters
process.load("RecoMET.METFilters.metFilters_cff")
# HCAL Laser filter : work only on Winter13 rereco
process.load("EventFilter.HcalRawToDigi.hcallaserFilterFromTriggerResult_cff")
#needed fot photon energy regression calculation
process.load('Calibration.EleNewEnergiesProducer.elenewenergiesproducer_cfi')
#getattr(process,"patPhotons" + p)
process.patPhotons.userData.userFloats.src = [
cms.InputTag("eleNewEnergiesProducer","energySCEleJoshPhoSemiParamV5ecorr")
]
## uncomment to run interactive
## process.eleNewEnergiesProducer.regrPhoJoshV5_SemiParamFile = cms.string('../../../../src/HiggsAnalysis/GBRLikelihoodEGTools/data/regweights_v5_forest_ph.root')
## process.eleNewEnergiesProducer.regrEleJoshV5_SemiParamFile = cms.string('../../../../src/HiggsAnalysis/GBRLikelihoodEGTools/data/regweights_v5_forest_ele.root')
process.eleNewEnergiesProducer.electronCollection = getattr(process,"patPhotons" + p).photonSource
# Let it run
process.p = cms.Path(
process.nEventsTotal +
# Filters
process.hcalfilter +
process.primaryVertexFilter +
process.scrapingVeto +
process.metFilters +
process.goodOfflinePrimaryVertices +
# photon energy regression
process.eleNewEnergiesProducer +
# Physics
process.analysisSequence +
process.nEventsFiltered
)
if runOnMC:
process.p.remove(process.hcalfilter)
process.p.remove(process.scrapingVeto)
# Add PF2PAT output to the created file
from PhysicsTools.PatAlgos.patEventContent_cff import patEventContentNoCleaning
#process.load("CommonTools.ParticleFlow.PF2PAT_EventContent_cff")
process.out.outputCommands = cms.untracked.vstring('drop *',
'keep *_photonCore_*_*',
'keep double_kt6*Jets*_rho_*',
'keep *_goodOfflinePrimaryVertices_*_*',
'keep recoPFCandidates_particleFlow_*_*',
# Content of *patEventContentNoCleaning
'keep *_selectedPatPhotons*_*_*', 'keep *_selectedPatElectrons*_*_*', 'keep *_selectedPatMuons*_*_*', 'keep *_selectedPatTaus*_*_*', 'keep *_selectedPatJets*_*_*', 'drop *_selectedPatJets_pfCandidates_*', 'drop *_*PF_caloTowers_*', 'drop *_*JPT_pfCandidates_*', 'drop *_*Calo_pfCandidates_*', 'keep *_patMETs*_*_*', 'keep *_selectedPatPFParticles*_*_*', 'keep *_selectedPatTrackCands*_*_*',
'keep *_cleanPatPhotons*_*_*', 'keep *_cleanPatElectrons*_*_*', 'keep *_cleanPatMuons*_*_*', 'keep *_cleanPatTaus*_*_*',
'keep *_cleanPatJets*_*_*', 'keep *_cleanPatHemispheres*_*_*', 'keep *_cleanPatPFParticles*_*_*',
'keep *_cleanPatTrackCands*_*_*',
'drop *_*PFlow_caloTowers_*',
# Type I residual
'drop *_selectedPatJetsForMET*_*_PAT',
'keep *_patPFMet*_*_PAT', # Keep raw met
# Trigger
'keep *_TriggerResults_*_HLT',
# Debug
#'keep *_pf*_*_PAT'
# Photon ID
'keep *_patConversions*_*_*',
'keep *_photonPFIsolation*_*_*',
# Quark Gluon tagging
'keep *_QGTagger*_*_*',
'drop *_kt6PFJetsIsoQG_*_PAT',
'drop *_kt6PFJetsQG_*_PAT',
# MC truth
'keep *_genParticles_*_*',
# RecHits
'keep *EcalRecHit*_*_*_*',
# Beam spot
'keep *_offlineBeamSpot_*_*',
#photon energy regression
'keep *_eleNewEnergiesProducer_*_*'
)
if runOnMC:
process.out.outputCommands.extend(['keep *_addPileupInfo_*_*', 'keep *_generator_*_*'])
# switch on PAT trigger
# from PhysicsTools.PatAlgos.tools.trigTools import switchOnTrigger
# switchOnTrigger( process )
## ------------------------------------------------------
# In addition you usually want to change the following
# parameters:
## ------------------------------------------------------
#
process.GlobalTag.globaltag = "%s::All" % (globalTag) ## (according to https://twiki.cern.ch/twiki/bin/view/CMS/SWGuideFrontierConditions)
# ##
#process.source.fileNames = cms.untracked.vstring('file:input_data.root') ## (e.g. 'file:AOD.root')
# ##
process.maxEvents.input = 2500
# ##
# process.out.outputCommands = [ ... ] ## (e.g. taken from PhysicsTools/PatAlgos/python/patEventContent_cff.py)
# ##
process.options.wantSummary = False ## (to suppress the long output at the end of the job)
process.MessageLogger.cerr.FwkReport.reportEvery = 1000
# Remove annoying ecalLaser messages
process.MessageLogger.suppressError = cms.untracked.vstring ('ecalLaserCorrFilter')
return process
def addPat(process, isData, doRECO, doTTEffShrinkingConePFTau):
sequence = cms.Sequence()
# If running together with RECO
# We get another kt6PFJets from PAT, and as-is they clash producing an exception
runningWithReco = hasattr(process, "recoAllPFJets")
if runningWithReco:
process.recoAllPFJets.remove(process.kt6PFJets)
process.recoPFJets.remove(process.kt6PFJets)
process.load("PhysicsTools.PatAlgos.patSequences_cff")
if runningWithReco:
process.recoAllPFJets.replace(process.kt4PFJets, process.kt4PFJets*process.kt6PFJets)
process.recoPFJets.replace(process.kt4PFJets, process.kt4PFJets*process.kt6PFJets)
# process.load("PhysicsTools.PatAlgos.producersLayer1.patCandidates_cff")
# Calculate PF isolation of the muon
#process.muonPFIsolationSequence = MuonPFIsolation.addMuonPFIsolation(process, "muons", process.patMuons)
#sequence += process.muonPFIsolationSequence
if doRECO:
process.pfPileUpIso.PFCandidates = "particleFlowTmp" # I don't know why I have to do this
process.pfNoPileUpIso.bottomCollection = "particleFlowTmp"
jetCorr = ["L1FastJet", "L2Relative", "L3Absolute"]
if isData:
jetCorr.append("L2L3Residual")
# coreTools.removeMCMatching(process, ["All"], outputInProcess=False)
coreTools.removeMCMatching(process, ["All"], outputModules = [])
#### coreTools.removeCleaning(process, False)
coreTools.removeCleaning(process, outputModules = [])
#### coreTools.removeSpecificPATObjects(process, ["Electrons", "Photons", "METs"], False)
coreTools.removeSpecificPATObjects(process, ["Electrons", "Photons", "METs"], outputModules = [])
tauTools.addTauCollection(process, cms.InputTag('hpsPFTauProducer'),
algoLabel = "hps", typeLabel = "PFTau")
jetTools.switchJetCollection(process, cms.InputTag('ak5PFJets'),
doJTA = True,
doBTagging = True,
jetCorrLabel = ('AK5PF', jetCorr),
doType1MET = False,
genJetCollection = cms.InputTag("ak5GenJets"),
doJetID = False,
jetIdLabel = "ak5",
outputModules = [])
# If the reference tau should be the old TTEff shrinking cone
# if doTTEffShrinkingConePFTau:
# process.patTaus.tauSource = "TTEffShrinkingConePFTauProducer"
# for module in [process.tauIsoDepositPFCandidates, process.tauIsoDepositPFChargedHadrons, process.tauIsoDepositPFGammas, process.tauIsoDepositPFNeutralHadrons]:
# module.src = "TTEffShrinkingConePFTauProducer"
# module.ExtractorPSet.tauSource = "TTEffShrinkingConePFTauProducer"
# process.tauMatch.src = "TTEffShrinkingConePFTauProducer"
# process.patTaus.tauIDSources.leadingPionPtCut = "TTEffPFTauDiscriminationByLeadingPionPtCut"
# process.patTaus.tauIDSources.byIsolationUsingLeadingPion = "TTEffPFTauDiscriminationByIsolationUsingLeadingPion"
# process.patTaus.tauIDSources.leadingTrackFinding = "TTEffPFTauDiscriminationByLeadingTrackFinding"
# process.patTaus.tauIDSources.againstMuon = "TTEffPFTauDiscriminationAgainstMuon"
# process.patTaus.tauIDSources.againstElectron = "TTEffPFTauDiscriminationAgainstElectron"
# process.selectedPatTaus.cut = "pt() > 15 && abs(eta()) < 2.5 && tauID('leadingPionPtCut')"
sequence += process.patDefaultSequence
return sequence
def usePF2PAT_WREdition(
process,
runPF2PAT=True,
jetAlgo='AK5',
runOnMC=True,
postfix="",
jetCorrections=('AK5PFchs', ['L1FastJet', 'L2Relative', 'L3Absolute']),
pvCollection=cms.InputTag('offlinePrimaryVertices'),
typeIMetCorrections=False,
outputModules=['out']):
# -------- CORE ---------------
if runPF2PAT:
process.load("CommonTools.ParticleFlow.PF2PAT_cff")
#add Pf2PAT *before* cloning so that overlapping modules are cloned too
#process.patDefaultSequence.replace( process.patCandidates, process.PF2PAT+process.patCandidates)
process.patPF2PATSequence = cms.Sequence(process.PF2PAT +
process.patDefaultSequence)
else:
process.patPF2PATSequence = cms.Sequence(process.patDefaultSequence)
if not postfix == "":
from PhysicsTools.PatAlgos.tools.helpers import cloneProcessingSnippet
cloneProcessingSnippet(process, process.patPF2PATSequence, postfix)
#delete everything pat PF2PAT modules! if you want to test the postfixing for completeness
#from PhysicsTools.PatAlgos.tools.helpers import listModules,listSequences
#for module in listModules(process.patDefaultSequence):
# if not module.label() is None: process.__delattr__(module.label())
#for sequence in listSequences(process.patDefaultSequence):
# if not sequence.label() is None: process.__delattr__(sequence.label())
#del process.patDefaultSequence
removeCleaning(process, postfix=postfix, outputModules=outputModules)
# -------- OBJECTS ------------
# Muons
#adaptPFMuons(process,
# applyPostfix(process,"patMuons",postfix),
# postfix)
# Electrons
#adaptPFElectrons(process,
# applyPostfix(process,"patElectrons",postfix),
# postfix)
# Photons
print "Temporarily switching off photons completely"
removeSpecificPATObjects(process,
names=['Photons', 'Taus', "Muons", "Electrons"],
outputModules=outputModules,
postfix=postfix)
removeIfInSequence(process, "patPhotonIsolation", "patDefaultSequence",
postfix)
# Jets
if runOnMC:
if ishpsPFTau:
switchToPFJets(process,
cms.InputTag('pfNoTau' + postfix),
jetAlgo,
postfix=postfix,
jetCorrections=jetCorrections,
type1=typeIMetCorrections,
outputModules=outputModules)
else:
switchToPFJets(process,
cms.InputTag('pfJets' + postfix),
jetAlgo,
postfix=postfix,
jetCorrections=jetCorrections,
type1=typeIMetCorrections,
outputModules=outputModules)
applyPostfix(process, "patDefaultSequence", postfix).replace(
applyPostfix(process, "patJetGenJetMatch", postfix),
getattr(process, "genForPF2PATSequence") *
applyPostfix(process, "patJetGenJetMatch", postfix))
else:
if not 'L2L3Residual' in jetCorrections[1]:
print '#################################################'
print 'WARNING! Not using L2L3Residual but this is data.'
print 'If this is okay with you, disregard this message.'
print '#################################################'
if ishpsPFTau:
switchToPFJets(process,
cms.InputTag('pfNoTau' + postfix),
jetAlgo,
postfix=postfix,
jetCorrections=jetCorrections,
type1=typeIMetCorrections,
outputModules=outputModules)
else:
switchToPFJets(process,
cms.InputTag('pfJets' + postfix),
jetAlgo,
postfix=postfix,
jetCorrections=jetCorrections,
type1=typeIMetCorrections,
outputModules=outputModules)
# Taus
#adaptPFTaus( process, tauType='shrinkingConePFTau', postfix=postfix )
#adaptPFTaus( process, tauType='fixedConePFTau', postfix=postfix )
if ishpsPFTau:
adaptPFTaus(process, tauType='hpsPFTau', postfix=postfix)
# MET
switchToPFMET(process,
cms.InputTag('pfMET' + postfix),
type1=typeIMetCorrections,
postfix=postfix)
# Unmasked PFCandidates
addPFCandidates(process,
cms.InputTag('pfNoJet' + postfix),
patLabel='PFParticles' + postfix,
cut="",
postfix=postfix)
# adapt primary vertex collection
adaptPVs(process, pvCollection=pvCollection, postfix=postfix)
if runOnMC:
process.load("CommonTools.ParticleFlow.genForPF2PAT_cff")
getattr(process, "patDefaultSequence" + postfix).replace(
applyPostfix(process, "patCandidates",
postfix), process.genForPF2PATSequence +
applyPostfix(process, "patCandidates", postfix))
else:
removeMCMatchingPF2PAT(process,
postfix=postfix,
outputModules=outputModules)
print "Done: PF2PAT interfaced to PAT, postfix=", postfix
def usePF2PAT_WREdition(process, runPF2PAT=True, jetAlgo='AK5', runOnMC=True, postfix="", jetCorrections=('AK5PFchs', ['L1FastJet','L2Relative','L3Absolute']), pvCollection=cms.InputTag('offlinePrimaryVertices'), typeIMetCorrections=False, outputModules=['out']):
# -------- CORE ---------------
if runPF2PAT:
process.load("CommonTools.ParticleFlow.PF2PAT_cff")
#add Pf2PAT *before* cloning so that overlapping modules are cloned too
#process.patDefaultSequence.replace( process.patCandidates, process.PF2PAT+process.patCandidates)
process.patPF2PATSequence = cms.Sequence( process.PF2PAT + process.patDefaultSequence)
else:
process.patPF2PATSequence = cms.Sequence( process.patDefaultSequence )
if not postfix == "":
from PhysicsTools.PatAlgos.tools.helpers import cloneProcessingSnippet
cloneProcessingSnippet(process, process.patPF2PATSequence, postfix)
#delete everything pat PF2PAT modules! if you want to test the postfixing for completeness
#from PhysicsTools.PatAlgos.tools.helpers import listModules,listSequences
#for module in listModules(process.patDefaultSequence):
# if not module.label() is None: process.__delattr__(module.label())
#for sequence in listSequences(process.patDefaultSequence):
# if not sequence.label() is None: process.__delattr__(sequence.label())
#del process.patDefaultSequence
removeCleaning(process, postfix=postfix, outputModules=outputModules)
# -------- OBJECTS ------------
# Muons
#adaptPFMuons(process,
# applyPostfix(process,"patMuons",postfix),
# postfix)
# Electrons
#adaptPFElectrons(process,
# applyPostfix(process,"patElectrons",postfix),
# postfix)
# Photons
print "Temporarily switching off photons completely"
removeSpecificPATObjects(process,names=['Photons', 'Taus', "Muons", "Electrons"],outputModules=outputModules,postfix=postfix)
removeIfInSequence(process,"patPhotonIsolation","patDefaultSequence",postfix)
# Jets
if runOnMC :
if ishpsPFTau:
switchToPFJets( process, cms.InputTag('pfNoTau'+postfix), jetAlgo, postfix=postfix,
jetCorrections=jetCorrections, type1=typeIMetCorrections, outputModules=outputModules )
else:
switchToPFJets( process, cms.InputTag('pfJets'+postfix), jetAlgo, postfix=postfix,
jetCorrections=jetCorrections, type1=typeIMetCorrections, outputModules=outputModules )
applyPostfix(process,"patDefaultSequence",postfix).replace(
applyPostfix(process,"patJetGenJetMatch",postfix),
getattr(process,"genForPF2PATSequence") *
applyPostfix(process,"patJetGenJetMatch",postfix)
)
else :
if not 'L2L3Residual' in jetCorrections[1]:
print '#################################################'
print 'WARNING! Not using L2L3Residual but this is data.'
print 'If this is okay with you, disregard this message.'
print '#################################################'
if ishpsPFTau:
switchToPFJets( process, cms.InputTag('pfNoTau'+postfix), jetAlgo, postfix=postfix,
jetCorrections=jetCorrections, type1=typeIMetCorrections, outputModules=outputModules )
else:
switchToPFJets( process, cms.InputTag('pfJets'+postfix), jetAlgo, postfix=postfix,
jetCorrections=jetCorrections, type1=typeIMetCorrections, outputModules=outputModules )
# Taus
#adaptPFTaus( process, tauType='shrinkingConePFTau', postfix=postfix )
#adaptPFTaus( process, tauType='fixedConePFTau', postfix=postfix )
if ishpsPFTau:
adaptPFTaus( process, tauType='hpsPFTau', postfix=postfix )
# MET
switchToPFMET(process, cms.InputTag('pfMET'+postfix), type1=typeIMetCorrections, postfix=postfix)
# Unmasked PFCandidates
addPFCandidates(process,cms.InputTag('pfNoJet'+postfix),patLabel='PFParticles'+postfix,cut="",postfix=postfix)
# adapt primary vertex collection
adaptPVs(process, pvCollection=pvCollection, postfix=postfix)
if runOnMC:
process.load("CommonTools.ParticleFlow.genForPF2PAT_cff")
getattr(process, "patDefaultSequence"+postfix).replace(
applyPostfix(process,"patCandidates",postfix),
process.genForPF2PATSequence+applyPostfix(process,"patCandidates",postfix)
)
else:
removeMCMatchingPF2PAT(process,postfix=postfix,outputModules=outputModules)
print "Done: PF2PAT interfaced to PAT, postfix=", postfix
def usePF2PAT_WREdition(
process,
runPF2PAT=True,
jetAlgo='AK5',
runOnMC=True,
postfix="",
jetCorrections=('AK5PFchs', ['L1FastJet', 'L2Relative', 'L3Absolute']),
pvCollection=cms.InputTag('offlinePrimaryVertices'),
typeIMetCorrections=False,
outputModules=['out']):
# PLEASE DO NOT CLOBBER THIS FUNCTION WITH CODE SPECIFIC TO A GIVEN PHYSICS OBJECT.
# CREATE ADDITIONAL FUNCTIONS IF NEEDED.
"""Switch PAT to use PF2PAT instead of AOD sources. if 'runPF2PAT' is true, we'll also add PF2PAT in front of the PAT sequence"""
# -------- CORE ---------------
if runPF2PAT:
process.load("CommonTools.ParticleFlow.PF2PAT_cff")
process.patPF2PATSequence = cms.Sequence(process.PF2PAT +
process.patDefaultSequence)
else:
process.patPF2PATSequence = cms.Sequence(process.patDefaultSequence)
if not postfix == "":
from PhysicsTools.PatAlgos.tools.helpers import cloneProcessingSnippet
cloneProcessingSnippet(process, process.patPF2PATSequence, postfix)
removeCleaning(process, postfix=postfix, outputModules=outputModules)
# Photons
print "Temporarily switching off photons completely"
removeSpecificPATObjects(process,
names=['Photons', 'Taus', "Muons", "Electrons"],
outputModules=outputModules,
postfix=postfix)
removeIfInSequence(process, "patPhotonIsolation", "patDefaultSequence",
postfix)
# Jets
if runOnMC:
switchToPFJets(process,
cms.InputTag('pfNoTau' + postfix),
jetAlgo,
postfix=postfix,
jetCorrections=jetCorrections,
type1=typeIMetCorrections,
outputModules=outputModules)
applyPostfix(process, "patDefaultSequence", postfix).replace(
applyPostfix(process, "patJetGenJetMatch", postfix),
getattr(process, "genForPF2PATSequence") *
applyPostfix(process, "patJetGenJetMatch", postfix))
else:
if not 'L2L3Residual' in jetCorrections[1]:
print '#################################################'
print 'WARNING! Not using L2L3Residual but this is data.'
print 'If this is okay with you, disregard this message.'
print '#################################################'
switchToPFJets(process,
cms.InputTag('pfNoTau' + postfix),
jetAlgo,
postfix=postfix,
jetCorrections=jetCorrections,
type1=typeIMetCorrections,
outputModules=outputModules)
# Taus
if ishpsPFTau:
adaptPFTaus(process, tauType='hpsPFTau', postfix=postfix)
# MET
switchToPFMET(process,
cms.InputTag('pfMET' + postfix),
type1=typeIMetCorrections,
postfix=postfix)
if not runOnMC:
if hasattr(process, 'patPFMet' + postfix):
getattr(process, 'patPFMet' + postfix).addGenMET = cms.bool(False)
# Unmasked PFCandidates
addPFCandidates(process,
cms.InputTag('pfNoJet' + postfix),
patLabel='PFParticles' + postfix,
cut="",
postfix=postfix)
# adapt primary vertex collection
adaptPVs(process, pvCollection=pvCollection, postfix=postfix)
if runOnMC:
process.load("CommonTools.ParticleFlow.genForPF2PAT_cff")
getattr(process, "patDefaultSequence" + postfix).replace(
applyPostfix(process, "patCandidates",
postfix), process.genForPF2PATSequence +
applyPostfix(process, "patCandidates", postfix))
else:
removeMCMatchingPF2PAT(process,
postfix=postfix,
outputModules=outputModules)
print "Done: PF2PAT interfaced to PAT, postfix=", postfix
process.higgssequence = cms.Sequence(process.makeGenEvtHiggs * process.generatorHiggsFilter)
else:
process.higgssequence = cms.Sequence()
if signal or higgsSignal or zGenInfo:
process.ntupleInRecoSeq = cms.Sequence()
else:
process.ntupleInRecoSeq = cms.Sequence(process.zsequence * process.writeNTuple)
####################################################################
## Remove all the tau stuff
from PhysicsTools.PatAlgos.tools.coreTools import removeSpecificPATObjects
removeSpecificPATObjects(process, names=["Taus", "Photons"], outputModules=[], postfix=pfpostfix)
# Remove the full pftau sequence as it is not needed for us
getattr(process, "patPF2PATSequence" + pfpostfix).remove(getattr(process, "pfTauPFJets08Region" + pfpostfix))
getattr(process, "patPF2PATSequence" + pfpostfix).remove(getattr(process, "pfTauPileUpVertices" + pfpostfix))
getattr(process, "patPF2PATSequence" + pfpostfix).remove(getattr(process, "pfTauTagInfoProducer" + pfpostfix))
getattr(process, "patPF2PATSequence" + pfpostfix).remove(getattr(process, "pfJetsPiZeros" + pfpostfix))
getattr(process, "patPF2PATSequence" + pfpostfix).remove(getattr(process, "pfJetsLegacyTaNCPiZeros" + pfpostfix))
getattr(process, "patPF2PATSequence" + pfpostfix).remove(getattr(process, "pfJetsLegacyHPSPiZeros" + pfpostfix))
getattr(process, "patPF2PATSequence" + pfpostfix).remove(getattr(process, "pfTausBase" + pfpostfix))
getattr(process, "patPF2PATSequence" + pfpostfix).remove(getattr(process, "hpsSelectionDiscriminator" + pfpostfix))
getattr(process, "patPF2PATSequence" + pfpostfix).remove(getattr(process, "hpsPFTauProducerSansRefs" + pfpostfix))
getattr(process, "patPF2PATSequence" + pfpostfix).remove(getattr(process, "hpsPFTauProducer" + pfpostfix))
getattr(process, "patPF2PATSequence" + pfpostfix).remove(
getattr(process, "pfTausBaseDiscriminationByDecayModeFinding" + pfpostfix)
)
getattr(process, "patPF2PATSequence" + pfpostfix).remove(
process.higgssequence = cms.Sequence()
if signal or higgsSignal or zGenInfo:
process.ntupleInRecoSeq = cms.Sequence()
else:
process.ntupleInRecoSeq = cms.Sequence(process.zsequence * process.writeNTuple)
####################################################################
## Remove all the tau stuff
from PhysicsTools.PatAlgos.tools.coreTools import removeSpecificPATObjects
removeSpecificPATObjects( process
, names = ['Taus', 'Photons']
, outputModules = []
, postfix = pfpostfix
)
if not createMvaMet:
# Remove the full pftau sequence as it is not needed for us
getattr(process,'patPF2PATSequence'+pfpostfix).remove(getattr(process,'pfTauPFJets08Region'+pfpostfix))
getattr(process,'patPF2PATSequence'+pfpostfix).remove(getattr(process,'pfTauPileUpVertices'+pfpostfix))
getattr(process,'patPF2PATSequence'+pfpostfix).remove(getattr(process,'pfTauTagInfoProducer'+pfpostfix))
getattr(process,'patPF2PATSequence'+pfpostfix).remove(getattr(process,'pfJetsPiZeros'+pfpostfix))
getattr(process,'patPF2PATSequence'+pfpostfix).remove(getattr(process,'pfJetsLegacyTaNCPiZeros'+pfpostfix))
getattr(process,'patPF2PATSequence'+pfpostfix).remove(getattr(process,'pfJetsLegacyHPSPiZeros'+pfpostfix))
getattr(process,'patPF2PATSequence'+pfpostfix).remove(getattr(process,'pfTausBase'+pfpostfix))
getattr(process,'patPF2PATSequence'+pfpostfix).remove(getattr(process,'hpsSelectionDiscriminator'+pfpostfix))
getattr(process,'patPF2PATSequence'+pfpostfix).remove(getattr(process,'hpsPFTauProducerSansRefs'+pfpostfix))
getattr(process,'patPF2PATSequence'+pfpostfix).remove(getattr(process,'hpsPFTauProducer'+pfpostfix))
getattr(process,'patPF2PATSequence'+pfpostfix).remove(getattr(process,'pfTausBaseDiscriminationByDecayModeFinding'+pfpostfix))
def createProcess(runOnMC, runCHS, correctMETWithT1, processCaloJets, processCA8Jets, globalTag):
## import skeleton process
from PhysicsTools.PatAlgos.patTemplate_cfg import process
# load the PAT config
process.load("PhysicsTools.PatAlgos.patSequences_cff")
process.load("JetMETCorrections.Configuration.JetCorrectionProducers_cff")
# Do some CHS stuff
process.ak5PFchsL1Fastjet = process.ak5PFL1Fastjet.clone(algorithm = 'AK5PFchs')
process.ak5PFchsL2Relative = process.ak5PFL2Relative.clone(algorithm = 'AK5PFchs')
process.ak5PFchsL3Absolute = process.ak5PFL3Absolute.clone(algorithm = 'AK5PFchs')
process.ak5PFchsResidual = process.ak5PFResidual.clone(algorithm = 'AK5PFchs')
process.ak5PFchsL1FastL2L3 = cms.ESProducer(
'JetCorrectionESChain',
correctors = cms.vstring('ak5PFchsL1Fastjet', 'ak5PFchsL2Relative','ak5PFchsL3Absolute')
)
from PhysicsTools.SelectorUtils.pvSelector_cfi import pvSelector
## The good primary vertex filter ____________________________________________||
## This filter throw events with no primary vertex
process.primaryVertexFilter = cms.EDFilter(
"VertexSelector",
src = cms.InputTag("offlinePrimaryVertices"),
cut = cms.string("!isFake && ndof > 4 && abs(z) <= 24 && position.Rho <= 2"),
filter = cms.bool(True)
)
process.goodOfflinePrimaryVertices = cms.EDFilter("PrimaryVertexObjectFilter",
filterParams = pvSelector.clone( minNdof = cms.double(4.0), maxZ = cms.double(24.0) ),
src = cms.InputTag('offlinePrimaryVertices')
)
# Configure PAT to use PF2PAT instead of AOD sources
# this function will modify the PAT sequences.
from PhysicsTools.PatAlgos.tools.coreTools import removeSpecificPATObjects, removeMCMatching
from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT, adaptPFIsoElectrons, adaptPVs, usePFIso
#from PhysicsTools.PatAlgos.tools.metTools import *
def usePF2PATForAnalysis(jetAlgo, postfix, useTypeIMET, usePFNoPU):
# Jet corrections
# No L2L3 Residual on purpose
if usePFNoPU:
jetCorrections = ("%sPFchs" % algo, ['L1FastJet', 'L2Relative', 'L3Absolute'])
postfix += "chs"
else:
jetCorrections = ("%sPF" % algo, ['L1FastJet', 'L2Relative', 'L3Absolute'])
#if not runOnMC:
# jetCorrections[1].append('L2L3Residual')
p = postfix
usePF2PAT(process, runPF2PAT=True, jetAlgo=jetAlgo, runOnMC=runOnMC, postfix=p, jetCorrections=jetCorrections, typeIMetCorrections = useTypeIMET)
getattr(process, "pfPileUp" + p).Enable = True
getattr(process, "pfPileUp" + p).Vertices = 'goodOfflinePrimaryVertices'
getattr(process, "pfPileUp" + p).checkClosestZVertex = cms.bool(False)
getattr(process, "pfJets" + p).doAreaFastjet = cms.bool(True)
getattr(process, "pfJets" + p).doRhoFastjet = False
getattr(process, 'patJetCorrFactors' + p).rho = cms.InputTag("kt6PFJets", "rho") # Do not use kt6PFJetsPFlowAK5, it's not ok for L1FastJet.
# top projections in PF2PAT:
getattr(process,"pfNoPileUp" + p).enable = cms.bool(usePFNoPU)
getattr(process,"pfNoMuon" + p).enable = True
getattr(process,"pfNoElectron" + p).enable = True
getattr(process,"pfNoTau" + p).enable = True
getattr(process,"pfNoJet" + p).enable = True
getattr(process,"patElectrons" + p).embedTrack = True
getattr(process,"patMuons" + p).embedTrack = True
# enable delta beta correction for muon selection in PF2PAT?
getattr(process,"pfIsolatedMuons" + p).doDeltaBetaCorrection = True
getattr(process, "patJets" + p).embedPFCandidates = False
# Keep only jets with pt > 2 Gev
getattr(process, "selectedPatJets" + p).cut = "pt > 2";
# Use a cone of 0.3 for photon isolation
#adaptPFIsoPhotons(process, applyPostfix(process, "patPhotons", postfix), postfix, "03")
# 2012 Photon ID
# Electron conversion
setattr(process, "patConversions" + p, cms.EDProducer("PATConversionProducer",
# input collection
electronSource = cms.InputTag("selectedPatElectrons" + p)
))
# Switch electron isolation to dR = 0.3, for PF2PAT
getattr(process, "pfIsolatedElectrons" + p).isolationValueMapsCharged = cms.VInputTag(cms.InputTag("elPFIsoValueCharged03PFId" + p))
getattr(process, "pfIsolatedElectrons" + p).deltaBetaIsolationValueMap = cms.InputTag("elPFIsoValuePU03PFId" + p)
getattr(process, "pfIsolatedElectrons" + p).isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("elPFIsoValueNeutral03PFId" + p), cms.InputTag("elPFIsoValueGamma03PFId" + p))
getattr(process, "pfElectrons" + p).isolationValueMapsCharged = cms.VInputTag(cms.InputTag("elPFIsoValueCharged03PFId" + p))
getattr(process, "pfElectrons" + p).deltaBetaIsolationValueMap = cms.InputTag("elPFIsoValuePU03PFId" + p)
getattr(process, "pfElectrons" + p).isolationValueMapsNeutral = cms.VInputTag(cms.InputTag( "elPFIsoValueNeutral03PFId" + p), cms.InputTag("elPFIsoValueGamma03PFId" + p))
# ... And for PAT
adaptPFIsoElectrons(process, getattr(process, "pfElectrons" + p), p, "03")
if runOnMC:
cloneProcessingSnippet(process, getattr(process, "makePatMuons" + p), "Loose" + p, p)
getattr(process, "muonMatchLoose" + p).src = cms.InputTag("pfMuons" + p)
getattr(process, "patMuonsLoose" + p).pfMuonSource = cms.InputTag("pfMuons" + p)
getattr(process, "patDefaultSequence" + p).replace(getattr(process, "makePatMuons" + p), getattr(process, "makePatMuons" + p) + getattr(process, "makePatMuonsLoose" + p))
else:
setattr(process, "patMuonsLoose" + p, getattr(process, "patMuons" + p).clone(
pfMuonSource = cms.InputTag("pfMuons" + p)
)
)
setattr(process, "selectedPatMuonsLoose" + p, getattr(process, "selectedPatMuons" + p).clone(
src = cms.InputTag("patMuonsLoose" + p)
)
)
sequence = getattr(process, "patDefaultSequence" + p)
if not runOnMC:
sequence += getattr(process, "patMuonsLoose" + p)
sequence += (getattr(process, "selectedPatMuonsLoose" + p))
setattr(process, "patElectronsLoose" + p, getattr(process, "patElectrons" + p).clone(
pfElectronSource = cms.InputTag("pfElectrons" + p)
)
)
setattr(process, "selectedPatElectronsLoose" + p, getattr(process, "selectedPatElectrons" + p).clone(
src = cms.InputTag("patElectronsLoose" + p)
)
)
adaptPFIsoElectrons(process, getattr(process, "patElectronsLoose" + p), postfix, "03")
sequence = getattr(process, "patDefaultSequence" + p)
sequence += (getattr(process, "patElectronsLoose" + p) * getattr(process, "selectedPatElectronsLoose" + p))
#giulia turn off qg tagger
## Setup quark gluon tagger
#process.load('QuarkGluonTagger.EightTeV.QGTagger_RecoJets_cff')
#cloneProcessingSnippet(process, process.QuarkGluonTagger, p)
#getattr(process, "QGTagger" + p).srcJets = cms.InputTag("selectedPatJets" + p)
#getattr(process, "QGTagger" + p).isPatJet = cms.untracked.bool(True)
#getattr(process, "QGTagger" + p).useCHS = cms.untracked.bool(usePFNoPU)
## Remove the processing of primary vertices, as it's already what we do here
#getattr(process, 'QGTagger' + p).srcPV = cms.InputTag('goodOfflinePrimaryVertices')
#getattr(process, 'QuarkGluonTagger' + p).remove(getattr(process, 'goodOfflinePrimaryVerticesQG' + p))
if not runOnMC:
if 'L2L3Residual' in jetCorrections:
getattr(process, 'patPFJetMETtype1p2Corr' + p).jetCorrLabel = 'L2L3Residual'
getattr(process, 'patPFMet' + p).addGenMET = cms.bool(False)
names = ["Taus"]
#if jetAlgo != "AK5":
#names += ["Electrons", "Muons"]
if len(names) > 0:
removeSpecificPATObjects(process, names = names, outputModules = ['out'], postfix = p)
adaptPVs(process, pvCollection = cms.InputTag("goodOfflinePrimaryVertices"), postfix = p)
getattr(process, "patDefaultSequence" + p).replace(getattr(process, "selectedPatElectrons" + p), getattr(process, "selectedPatElectrons" + p) + getattr(process, "patConversions" + p))
#getattr(process, "patDefaultSequence" + p).replace(getattr(process, "selectedPatJets" + p), getattr(process, "selectedPatJets" + p) + getattr(process, "QuarkGluonTagger" + p))
return getattr(process, "patPF2PATSequence" + p)
if correctMETWithT1:
process.load("PhysicsTools.PatUtils.patPFMETCorrections_cff")
from PhysicsTools.PatAlgos.tools.helpers import cloneProcessingSnippet
print "##########################"
print "PF jets with PF2PAT"
print "Using Type I met" if correctMETWithT1 else "NOT using Type I met"
print "##########################"
#runCHS = False
postfixes = {'PFlowAK5': 'AK5'}
#postfixes = {'PFlowAK5': 'AK5', 'PFlowAK7': 'AK7', 'PFlowCA8': 'CA8'}
#postfixes = {'PFlowCA8': 'CA8'}
##giulia turn off qg tagger
## Setup quark gluon tagger
#process.load('QuarkGluonTagger.EightTeV.QGTagger_RecoJets_cff')
process.sequence_chs = cms.Sequence()
process.sequence_nochs = cms.Sequence()
for p, algo in postfixes.items():
process.sequence_nochs += usePF2PATForAnalysis(jetAlgo=algo, postfix=p, usePFNoPU=False, useTypeIMET=correctMETWithT1)
if runCHS:
process.sequence_chs += usePF2PATForAnalysis(jetAlgo=algo, postfix=p, usePFNoPU=True, useTypeIMET=correctMETWithT1)
# setattr(process, 'QGTagger' + p, process.QGTagger.clone())
# getattr(process, "QGTagger" + p).srcJets = cms.InputTag("selectedPatJets" + p)
# getattr(process, "QGTagger" + p).isPatJet = cms.untracked.bool(True)
# getattr(process, "QGTagger" + p).useCHS = cms.untracked.bool(False)
#
# process.QuarkGluonTagger.replace(process.QGTagger, getattr(process, 'QGTagger' + p))
if runCHS:
chsP = p + "chs"
# setattr(process, 'QGTagger' + chsP, process.QGTagger.clone())
# getattr(process, "QGTagger" + chsP).srcJets = cms.InputTag("selectedPatJets" + chsP)
# getattr(process, "QGTagger" + chsP).isPatJet = cms.untracked.bool(True)
# getattr(process, "QGTagger" + chsP).useCHS = cms.untracked.bool(True)
# process.QuarkGluonTagger.replace(getattr(process, 'QGTagger' + p), getattr(process, 'QGTagger' + p) + getattr(process, 'QGTagger' + chsP))
print "##########################"
print "Calo jets" if processCaloJets else "No processing of calo jets"
print "##########################"
usePFIso(process, "")
#adaptPFIsoPhotons(process, process.patPhotons, "", "03")
# chiara init ----------------------------------
print "##########################"
print "CA8 Jets" if processCA8Jets else "No processing of CA8 jets collection"
print "##########################"
if processCA8Jets:
from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection
# Reco CA 0.8 jets
# non sapendo quali parametri usare esattamente lascerei i default della reco per ora.
# Per doAreaFastjet e doRhoFastjet per il momento usiamo quanto e' ridefinito sopra
from RecoJets.JetProducers.ca4PFJets_cfi import ca4PFJets
process.ca8PFJetsPFlow = ca4PFJets.clone(
rParam = cms.double(0.8)
# src = cms.InputTag('pfNoElectron'+postfix),
# doAreaFastjet = cms.bool(True),
# doRhoFastjet = cms.bool(True),
# Rho_EtaMax = cms.double(6.0),
# Ghost_EtaMax = cms.double(7.0)
)
# Gen CA 0.8 jets
from RecoJets.JetProducers.ca4GenJets_cfi import ca4GenJets
process.ca8GenJetsNoNu = ca4GenJets.clone(
rParam = cms.double(0.8),
src = cms.InputTag("genParticlesForJetsNoNu")
)
# chiara end ----------------------------------
if processCaloJets:
# No L2L3 Residual on purpose
jetCorrections = ('AK5Calo', ['L1Offset', 'L2Relative', 'L3Absolute'])
addJetCollection(process, cms.InputTag('ak7CaloJets'),
'AK7',
'Calo',
doJTA = True,
doBTagging = True,
jetCorrLabel = jetCorrections,
doType1MET = correctMETWithT1,
doL1Cleaning = False,
doL1Counters = False,
genJetCollection = cms.InputTag("ak7GenJets"),
doJetID = True,
jetIdLabel = "ak7"
)
switchJetCollection(process, cms.InputTag('ak5CaloJets'),
doJTA = True,
doBTagging = True,
jetCorrLabel = jetCorrections,
doType1MET = correctMETWithT1,
genJetCollection = cms.InputTag("ak5GenJets"),
doJetID = True,
jetIdLabel = "ak5"
)
process.selectedPatJets.cut = "pt > 2"
process.selectedPatJetsAK7Calo.cut = "pt > 2"
else:
removeSpecificPATObjects(process, names = ['Jets', 'METs'])
if not runOnMC:
# Remove MC Matching
removeMCMatching(process, names = ["All"])
removeSpecificPATObjects(process, names = ['Electrons', 'Muons', 'Taus'])
if runCHS:
print "##########################"
print "Running CHS sequence"
print "##########################"
process.analysisSequence = cms.Sequence()
process.analysisSequence *= process.sequence_nochs
#if runCHS:
# process.analysisSequence *= process.sequence_chs
# chiara init ----------------------------------
if processCA8Jets:
process.analysisSequence *= process.ca8PFJetsPFlow
print("done process.ca8PFJetsPFlow")
process.analysisSequence *= process.ca8GenJetsNoNu
print("done process.ca8GenJetsNoNu")
# nuovo
# chiara end ----------------------------------
#GIULIA
# Quark Gluon tagging
#process.analysisSequence *= process.QuarkGluonTagger
# Add default pat sequence to our path
# This brings to life TcMET, Calo jets and Photons
########process.analysisSequence *= process.patDefaultSequence
# Add our PhotonIsolationProducer to the analysisSequence. This producer compute pf isolations
# for our photons
process.photonPFIsolation = cms.EDProducer("PhotonIsolationProducer",
src = cms.InputTag("selectedPatPhotons")
)
##########process.analysisSequence *= process.photonPFIsolation
# Filtering
# require physics declared
process.load('HLTrigger.special.hltPhysicsDeclared_cfi')
process.hltPhysicsDeclared.L1GtReadoutRecordTag = 'gtDigis'
# require scraping filter
process.scrapingVeto = cms.EDFilter("FilterOutScraping",
applyfilter = cms.untracked.bool(True),
debugOn = cms.untracked.bool(False),
numtrack = cms.untracked.uint32(10),
thresh = cms.untracked.double(0.25)
)
# Count events
process.nEventsTotal = cms.EDProducer("EventCountProducer")
process.nEventsFiltered = cms.EDProducer("EventCountProducer")
# MET Filters
process.load("RecoMET.METFilters.metFilters_cff")
# HCAL Laser filter : work only on Winter13 rereco
process.load("EventFilter.HcalRawToDigi.hcallaserFilterFromTriggerResult_cff")
# Let it run
process.p = cms.Path(
process.nEventsTotal +
# Filters
process.hcalfilter +
process.primaryVertexFilter +
process.scrapingVeto +
process.metFilters +
process.goodOfflinePrimaryVertices +
# Physics
process.analysisSequence +
process.nEventsFiltered
)
if runOnMC:
process.p.remove(process.hcalfilter)
process.p.remove(process.scrapingVeto)
# Add PF2PAT output to the created file
from PhysicsTools.PatAlgos.patEventContent_cff import patEventContentNoCleaning
#process.load("CommonTools.ParticleFlow.PF2PAT_EventContent_cff")
process.out.outputCommands = cms.untracked.vstring('drop *',
#process.out.outputCommands = cms.untracked.vstring('keep *') #'drop *',
'keep *_*_*_SIM',
'keep *_*_*_HLT',
'keep *_*_*_RECO',
'keep *_*ca8*_*_PAT')
#'keep *_photonCore_*_*',
#'keep double_kt6*Jets*_rho_*',
#'keep *_goodOfflinePrimaryVertices_*_*',
#'keep recoPFCandidates_particleFlow_*_*',
# Content of *patEventContentNoCleaning
#'keep *_selectedPatPhotons*_*_*', 'keep *_selectedPatElectrons*_*_*', 'keep *_selectedPatMuons*_*_*', 'keep *_selectedPatTaus*_*_*', 'keep *_selectedPatJets*_*_*', 'drop *_selectedPatJets_pfCandidates_*', 'drop *_*PF_caloTowers_*', 'drop *_*JPT_pfCandidates_*', 'drop *_*Calo_pfCandidates_*', 'keep *_patMETs*_*_*', 'keep *_selectedPatPFParticles*_*_*', 'keep *_selectedPatTrackCands*_*_*',
#'keep *_cleanPatPhotons*_*_*', 'keep *_cleanPatElectrons*_*_*', 'keep *_cleanPatMuons*_*_*', 'keep *_cleanPatTaus*_*_*',
#'keep *_cleanPatJets*_*_*', 'keep *_cleanPatHemispheres*_*_*', 'keep *_cleanPatPFParticles*_*_*',
#'keep *_cleanPatTrackCands*_*_*',
#'drop *_*PFlow_caloTowers_*',
# Type I residual
#'drop *_selectedPatJetsForMET*_*_PAT',
#'keep *_patPFMet*_*_PAT', # Keep raw met
# Trigger
#'keep *_TriggerResults_*_HLT',
# Debug
#'keep *_pf*_*_PAT'
# Photon ID
#'keep *_patConversions*_*_*',
#'keep *_photonPFIsolation*_*_*',
# Quark Gluon tagging
#'keep *_QGTagger*_*_*',
#'drop *_kt6PFJetsIsoQG_*_PAT',
#'drop *_kt6PFJetsQG_*_PAT',
# MC truth
#'keep *_genParticles_*_*'
#)
if runOnMC:
process.out.outputCommands.extend(['keep *_addPileupInfo_*_*', 'keep *_generator_*_*'])
# switch on PAT trigger
# from PhysicsTools.PatAlgos.tools.trigTools import switchOnTrigger
# switchOnTrigger( process )
## ------------------------------------------------------
# In addition you usually want to change the following
# parameters:
## ------------------------------------------------------
#
process.GlobalTag.globaltag = "%s::All" % (globalTag) ## (according to https://twiki.cern.ch/twiki/bin/view/CMS/SWGuideFrontierConditions)
# ##
#process.source.fileNames = cms.untracked.vstring('file:input_data.root') ## (e.g. 'file:AOD.root')
# ##
#process.maxEvents.input = 2500
process.maxEvents.input = 5000
# ##
# process.out.outputCommands = [ ... ] ## (e.g. taken from PhysicsTools/PatAlgos/python/patEventContent_cff.py)
# ##
process.options.wantSummary = False ## (to suppress the long output at the end of the job)
process.MessageLogger.cerr.FwkReport.reportEvery = 1000
# Remove annoying ecalLaser messages
process.MessageLogger.suppressError = cms.untracked.vstring ('ecalLaserCorrFilter')
return process
# plugins/PAT2Ntuple.cc for an example of accessing these matches.)
from PhysicsTools.PatAlgos.tools.coreTools import runOnData
if not runOnMC:
runOnData(process, names=['PFAll'], postfix='PF')
# We remove PAT photons here because they are not fully commisssioned
# in PF. (You could turn them on to check their performance.) This
# also turns off a cleaning step, which in the default PAT workflow
# tries to remove overlap between the physics object collections
# (e.g. removing muons from being reconstructed as degenerate "jets"),
# but this is not necessary with PF/the GED, especially with the top
# projections described above enabled.
from PhysicsTools.PatAlgos.tools.coreTools import removeSpecificPATObjects
removeSpecificPATObjects(process, names=['Photons'], postfix='PF')
# Now we configure the job to keep ttbar events in all three decay
# modes. For hadronic, we will require that there be four
# reconstructed jets (the main hadronic trigger requires this anyway).
#
# For leptonic and dileptonic, we want to keep events with either one
# or two leptons (electrons or muons -- tau reconstruction is
# harder). What we will call a lepton depends on the mode: with one
# lepton, we need to cut a bit harder to increase the ttbar signal
# over the (W+jets) background. If we have two leptons, we don't have
# to cut as hard.
#
# The next eight statements make separate EDProducers for each cut
# case so that a simple EDFilter module later ("countPatLeptons*") can
# count the number that pass. As discussed above, the lepton
def pat_tuple_process(runOnMC=True, suppress_stdout=True):
process = cms.Process('PAT')
process.maxEvents = cms.untracked.PSet(input = cms.untracked.int32(100))
process.source = cms.Source('PoolSource', fileNames = cms.untracked.vstring('/store/mc/Summer12_DR53X/TTJets_HadronicMGDecays_8TeV-madgraph/AODSIM/PU_S10_START53_V7A-v1/00001/FCAF3F92-5A16-E211-ACCC-E0CB4E19F95A.root' if runOnMC else '/store/data/Run2012B/MultiJet1Parked/AOD/05Nov2012-v2/10000/0003D331-5C49-E211-8210-00259020081C.root'))
process.options = cms.untracked.PSet(wantSummary = cms.untracked.bool(False))
process.load('FWCore.MessageLogger.MessageLogger_cfi')
process.MessageLogger.cerr.FwkReport.reportEvery = 1000000
process.MessageLogger.cerr.threshold = 'INFO'
process.MessageLogger.categories.append('PATSummaryTables')
process.MessageLogger.cerr.PATSummaryTables = cms.untracked.PSet(limit = cms.untracked.int32(-1))
for category in ['TwoTrackMinimumDistance']:
process.MessageLogger.categories.append(category)
setattr(process.MessageLogger.cerr, category, cms.untracked.PSet(limit=cms.untracked.int32(0)))
process.load('Configuration.Geometry.GeometryIdeal_cff')
process.load('Configuration.StandardSequences.MagneticField_AutoFromDBCurrent_cff')
process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff')
process.GlobalTag.globaltag = 'START53_V27::All' if runOnMC else 'FT53_V21A_AN6::All'
from PhysicsTools.PatAlgos.patEventContent_cff import patEventContent
process.out = cms.OutputModule('PoolOutputModule',
fileName = cms.untracked.string('pat.root'),
SelectEvents = cms.untracked.PSet(SelectEvents = cms.vstring('p')),
outputCommands = cms.untracked.vstring(*patEventContent),
)
process.outp = cms.EndPath(process.out)
process.load('JMTucker.Tools.PATTupleSelection_cfi')
# Event cleaning, with MET cleaning recommendations from
# https://twiki.cern.ch/twiki/bin/view/CMS/MissingETOptionalFilters
process.load('HLTrigger.special.hltPhysicsDeclared_cfi')
process.hltPhysicsDeclared.L1GtReadoutRecordTag = 'gtDigis'
from DPGAnalysis.Skims.goodvertexSkim_cff import noscraping as FilterOutScraping
process.FilterOutScraping = FilterOutScraping
process.load('CommonTools.ParticleFlow.goodOfflinePrimaryVertices_cfi')
process.goodOfflinePrimaryVertices.filter = cms.bool(True)
process.load('RecoMET.METFilters.metFilters_cff')
process.trackingFailureFilter.VertexSource = 'goodOfflinePrimaryVertices'
# Instead of filtering out events at tupling time, schedule separate
# paths for all the "good data" filters so that the results of them
# get stored in a small TriggerResults::PAT object, which can be
# accessed later. Make one path for each so they can be accessed
# separately in the TriggerResults object; the "All" path that is the
# product of all of the filters isn't necessary but it's nice for
# convenience.
process.eventCleaningAll = cms.Path()
for name in process.jtupleParams.eventFilters.value():
negate = name.startswith('~')
name = name.replace('~', '')
filter_obj = getattr(process, name)
if negate:
filter_obj = ~filter_obj
setattr(process, 'eventCleaning' + name, cms.Path(filter_obj))
process.eventCleaningAll *= filter_obj
################################################################################
# PAT/PF2PAT configuration inspired by TopQuarkAnalysis/Configuration
# (test/patRefSel_allJets_cfg.py and included modules) with tag
# V07-00-01.
# First, turn off stdout so that the spam from PAT/PF2PAT doesn't
# flood the screen (especially useful in batch job submission).
if suppress_stdout:
print 'tuple.py: PAT would spam a lot of stuff to stdout... hiding it.'
from cStringIO import StringIO
old_stdout = sys.stdout
sys.stdout = buf = StringIO()
jecLevels = ['L1FastJet', 'L2Relative', 'L3Absolute']
if not runOnMC:
jecLevels.append('L2L3Residual')
#jecLevels += ['L5Flavor', 'L7Parton']
postfix = 'PF'
def processpostfix(name):
return getattr(process, name + postfix)
def setprocesspostfix(name, obj):
setattr(process, name + postfix, obj)
def InputTagPostFix(name):
return cms.InputTag(name + postfix)
process.load('PhysicsTools.PatAlgos.patSequences_cff')
from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT
usePF2PAT(process,
runPF2PAT = True,
runOnMC = runOnMC,
jetAlgo = 'AK5',
postfix = postfix,
jetCorrections = ('AK5PFchs', jecLevels), # 'chs': using PFnoPU
typeIMetCorrections = True,
pvCollection = cms.InputTag('goodOfflinePrimaryVertices'),
)
processpostfix('pfNoPileUp') .enable = True # usePFnoPU
processpostfix('pfNoMuon') .enable = True # useNoMuon
processpostfix('pfNoElectron').enable = True # useNoElectron
processpostfix('pfNoJet') .enable = True # useNoJet
processpostfix('pfNoTau') .enable = True # useNoTau
processpostfix('pfPileUp').checkClosestZVertex = False
processpostfix('pfPileUpIso').checkClosestZVertex = False
processpostfix('pfMuonsFromVertex').d0Cut = processpostfix('pfElectronsFromVertex').d0Cut = 2
processpostfix('pfMuonsFromVertex').dzCut = processpostfix('pfElectronsFromVertex').dzCut = 2
processpostfix('pfSelectedMuons').cut = 'pt > 5.'
#processpostfix('pfSelectedMuons').cut += process.jtupleParams.muonCut
processpostfix('pfIsolatedMuons').isolationCut = 0.2
if False: # pfMuonIsoConeR03
processpostfix('pfIsolatedMuons').isolationValueMapsCharged = cms.VInputTag(InputTagPostFix('muPFIsoValueCharged03'))
processpostfix('pfIsolatedMuons').deltaBetaIsolationValueMap = InputTagPostFix('muPFIsoValuePU03')
processpostfix('pfIsolatedMuons').isolationValueMapsNeutral = cms.VInputTag(InputTagPostFix('muPFIsoValueNeutral03'), InputTagPostFix('muPFIsoValueGamma03'))
processpostfix('pfMuons').isolationValueMapsCharged = cms.VInputTag(InputTagPostFix('muPFIsoValueCharged03'))
processpostfix('pfMuons').deltaBetaIsolationValueMap = InputTagPostFix('muPFIsoValuePU03')
processpostfix('pfMuons').isolationValueMapsNeutral = cms.VInputTag(InputTagPostFix('muPFIsoValueNeutral03'), InputTagPostFix('muPFIsoValueGamma03'))
processpostfix('patMuons').isolationValues.pfNeutralHadrons = InputTagPostFix('muPFIsoValueNeutral03')
processpostfix('patMuons').isolationValues.pfChargedAll = InputTagPostFix('muPFIsoValueChargedAll03')
processpostfix('patMuons').isolationValues.pfPUChargedHadrons = InputTagPostFix('muPFIsoValuePU03')
processpostfix('patMuons').isolationValues.pfPhotons = InputTagPostFix('muPFIsoValueGamma03')
processpostfix('patMuons').isolationValues.pfChargedHadrons = InputTagPostFix('muPFIsoValueCharged03')
processpostfix('pfSelectedElectrons').cut = 'pt > 5. && gsfTrackRef.isNonnull && gsfTrackRef.trackerExpectedHitsInner.numberOfLostHits < 2'
#processpostfix('pfSelectedElectrons').cut += ' && ' + process.jtupleParams.electronCut # disabled by default, but can use minimal (veto) electron selection cut on top of pfElectronSelectionCut
processpostfix('pfIsolatedElectrons').isolationCut = 0.2
if True: # pfElectronIsoConeR03
processpostfix('pfIsolatedElectrons').isolationValueMapsCharged = cms.VInputTag(InputTagPostFix('elPFIsoValueCharged03PFId'))
processpostfix('pfIsolatedElectrons').deltaBetaIsolationValueMap = InputTagPostFix('elPFIsoValuePU03PFId')
processpostfix('pfIsolatedElectrons').isolationValueMapsNeutral = cms.VInputTag(InputTagPostFix('elPFIsoValueNeutral03PFId'), InputTagPostFix('elPFIsoValueGamma03PFId'))
processpostfix('pfElectrons').isolationValueMapsCharged = cms.VInputTag(InputTagPostFix('elPFIsoValueCharged03PFId'))
processpostfix('pfElectrons').deltaBetaIsolationValueMap = InputTagPostFix('elPFIsoValuePU03PFId')
processpostfix('pfElectrons').isolationValueMapsNeutral = cms.VInputTag(InputTagPostFix('elPFIsoValueNeutral03PFId'), InputTagPostFix('elPFIsoValueGamma03PFId'))
processpostfix('patElectrons').isolationValues.pfNeutralHadrons = InputTagPostFix('elPFIsoValueNeutral03PFId')
processpostfix('patElectrons').isolationValues.pfChargedAll = InputTagPostFix('elPFIsoValueChargedAll03PFId')
processpostfix('patElectrons').isolationValues.pfPUChargedHadrons = InputTagPostFix('elPFIsoValuePU03PFId')
processpostfix('patElectrons').isolationValues.pfPhotons = InputTagPostFix('elPFIsoValueGamma03PFId')
processpostfix('patElectrons').isolationValues.pfChargedHadrons = InputTagPostFix('elPFIsoValueCharged03PFId')
process.load('EgammaAnalysis.ElectronTools.electronIdMVAProducer_cfi')
processpostfix('patElectrons').electronIDSources.mvaTrigV0 = cms.InputTag("mvaTrigV0")
processpostfix('patElectrons').electronIDSources.mvaNonTrigV0 = cms.InputTag("mvaNonTrigV0")
processpostfix('patMuons').embedTrack = True
processpostfix('patJets').addTagInfos = True
processpostfix('selectedPatElectrons').cut = process.jtupleParams.electronCut
processpostfix('selectedPatMuons').cut = process.jtupleParams.muonCut
processpostfix('selectedPatJets').cut = process.jtupleParams.jetCut
process.load('CMGTools.External.pujetidsequence_cff')
for x in (process.puJetId, process.puJetMva, process.puJetIdChs, process.puJetMvaChs):
x.jets = InputTagPostFix('selectedPatJets')
# fix bug in V00-03-04 of CMGTools/External
if hasattr(x, 'algos'):
bad, good = 'RecoJets/JetProducers', 'CMGTools/External'
for ps in x.algos:
if hasattr(ps, 'tmvaWeights'):
s = ps.tmvaWeights.value()
if s.startswith(bad):
ps.tmvaWeights = s.replace(bad, good)
from PhysicsTools.PatAlgos.tools.coreTools import runOnData, removeSpecificPATObjects
if not runOnMC:
runOnData(process, names = ['All'], postfix = postfix)
removeSpecificPATObjects(process, names = ['Photons'], postfix = postfix) # will also remove cleaning
# Make some extra SV producers for MFV studies. JMTBAD postfix junk
for cut in (1., 1.5, 2., 2.5, 3., 3.5, 4., 4.5, 5., 5.5, 6.):
cut_name = ('%.1f' % cut).replace('.', 'p')
tag_info_name = 'secondaryVertexMaxDR%sTagInfosAODPF' % cut_name
tag_info_obj = process.secondaryVertexTagInfosAODPF.clone()
tag_info_obj.vertexCuts.maxDeltaRToJetAxis = cut
setattr(process, tag_info_name, tag_info_obj)
process.patJetsPF.tagInfoSources.append(cms.InputTag(tag_info_name))
processpostfix('patPF2PATSequence').replace(processpostfix('patJets'), tag_info_obj * processpostfix('patJets'))
from JMTucker.Tools.PATTupleSelection_cfi import makeLeptonProducers
makeLeptonProducers(process, postfix=postfix, params=process.jtupleParams)
common_seq = cms.ignore(process.goodOfflinePrimaryVertices) + cms.ignore(process.mvaTrigV0) + cms.ignore(process.mvaNonTrigV0) + processpostfix('patPF2PATSequence') + process.puJetIdSqeuenceChs
process.load('JMTucker.MFVNeutralino.Vertexer_cff')
common_seq *= process.mfvVertices
# Require numbers of jets based on the trigger: hadronic channel will
# have at least a 4-jet trigger (maybe 6!), while semileptonic uses a
# 3-jet trigger. Dileptonic has no jets in trigger, but we'll require
# at least one b-tag anyway.
setprocesspostfix('countPatJetsHadronic', processpostfix('countPatJets').clone(minNumber = 4))
setprocesspostfix('countPatJetsSemileptonic', processpostfix('countPatJets').clone(minNumber = 3))
setprocesspostfix('countPatJetsDileptonic', processpostfix('countPatJets').clone(minNumber = 1))
channels = ('Hadronic', 'Semileptonic', 'Dileptonic')
for channel in channels:
setattr(process, 'p' + channel, cms.Path(common_seq))
process.pHadronic *= processpostfix('countPatJetsHadronic')
process.pSemileptonic *= processpostfix('countPatJetsSemileptonic') + process.jtupleSemileptonSequence + process.countSemileptons
process.pDileptonic *= processpostfix('countPatJetsDileptonic') + process.jtupleDileptonSequence + process.countDileptons
process.out.SelectEvents.SelectEvents = ['p' + channel for channel in channels]
process.out.outputCommands = [
'drop *',
'keep *_selectedPatElectrons*_*_*',
'keep *_selectedPatMuons*_*_*',
'keep *_selectedPatJets*_*_*',
'drop *_selectedPatJetsForMETtype1p2CorrPF_*_*',
'drop *_selectedPatJetsForMETtype2CorrPF_*_*',
'keep *_mfvVertices*_*_*',
'drop CaloTowers_*_*_*',
'keep *_patMETs*_*_*',
'keep *_goodOfflinePrimaryVertices_*_*',
'keep edmTriggerResults_TriggerResults__PAT', # for post-tuple filtering on the goodData paths
'keep *_puJet*_*_*',
]
# The normal TrigReport doesn't state how many events are written
# total to the file in case of OutputModule's SelectEvents having
# multiple paths. Add a summary to stdout that so that it is easy to
# see what the total number of events should be (for debugging CRAB
# jobs). (This means we can kill the normal TrigReport.)
process.ORTrigReport = cms.EDAnalyzer('ORTrigReport',
results_src = cms.InputTag('TriggerResults', '', process.name_()),
paths = process.out.SelectEvents.SelectEvents
)
process.pORTrigReport = cms.EndPath(process.ORTrigReport) # Must be on an EndPath.
# As a simple check of the paths' efficiencies, add some lines to the
# summary showing stats on events with generator-level muons/electrons
# in acceptance from W decays.
if runOnMC:
for name, cut in [('Muon', 'abs(pdgId) == 13 && abs(eta) < 2.4 && abs(mother.pdgId) == 24 && pt > 20'),
('Electron', 'abs(pdgId) == 11 && abs(eta) < 2.5 && abs(mother.pdgId) == 24 && pt > 20'),
('Lepton', '((abs(pdgId) == 13 && abs(eta) < 2.4) || (abs(pdgId) == 11 && abs(eta) < 2.5)) && abs(mother.pdgId) == 24 && pt > 20'),
]:
name = 'gen' + name + 's'
filter = cms.EDFilter('CandViewSelector', src = cms.InputTag('genParticles'), cut = cms.string(cut))
counter = cms.EDFilter('CandViewCountFilter', src = cms.InputTag(name), minNumber = cms.uint32(1))
setattr(process, name, filter)
setattr(process, name + 'Count', counter)
setattr(process, 'p' + name + 'Count', cms.Path(filter*counter))
# Check that the stdout spam from PAT was what we expect.
if suppress_stdout:
pat_output = buf.getvalue()
sys.stdout = old_stdout
buf.close()
hsh = hash(pat_output)
#open('pat_spam.txt', 'wt').write(pat_output)
hsh_expected = 6563257886911239637 if runOnMC else 3125511795667431709
print 'PAT is done (spam hash %s, expected %s).' % (hsh, hsh_expected)
if hsh != hsh_expected:
from JMTucker.Tools.general import big_warn
big_warn('Unexpected spam hash! Did you change an option?')
return process, common_seq
