def addTagInfos(process, jetMetCorrections):
from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection
# print jetMetCorrections
switchJetCollection(
process, jetSource=cms.InputTag("ak5CaloJets"), jetCorrections=("AK5Calo", jetMetCorrections, "None")
)
def ak4JetReclustering(self, process, pfCandCollection,
patMetModuleSequence, postfix):
if not hasattr(process, "ak4PFJets"):
process.load("RecoJets.JetProducers.ak4PFJets_cfi")
print "reclustering ak4pf", pfCandCollection
process.ak4PFJets.src = pfCandCollection
process.ak4PFJets.doAreaFastjet = True
patMetModuleSequence += getattr(process, "ak4PFJets")
switchJetCollection(process,
jetSource=cms.InputTag('ak4PFJets'),
jetCorrections=('AK4PF', [
'L1FastJet', 'L2Relative', 'L3Absolute'
], ''))
process.patJets.addGenJetMatch = False
process.patJets.addGenPartonMatch = False
process.patJets.addPartonJetMatch = False
del process.patJets.JetFlavourInfoSource
del process.patJets.JetPartonMapSource
process.patJets.getJetMCFlavour = False
process.patJetCorrFactors.primaryVertices = cms.InputTag(
"offlineSlimmedPrimaryVertices")
return cms.InputTag("selectedPatJets")
def ak4JetReclustering(self, process, pfCandCollection, patMetModuleSequence, postfix):
if not hasattr(process, "ak4PFJets"):
process.load("RecoJets.JetProducers.ak4PFJets_cfi")
print "reclustering ak4pf", pfCandCollection
process.ak4PFJets.src = pfCandCollection
process.ak4PFJets.doAreaFastjet = True
patMetModuleSequence += getattr(process, "ak4PFJets")
switchJetCollection(
process,
jetSource=cms.InputTag("ak4PFJets"),
jetCorrections=("AK4PF", ["L1FastJet", "L2Relative", "L3Absolute"], ""),
)
process.patJets.addGenJetMatch = False
process.patJets.addGenPartonMatch = False
process.patJets.addPartonJetMatch = False
del process.patJets.JetFlavourInfoSource
del process.patJets.JetPartonMapSource
process.patJets.getJetMCFlavour = False
process.patJetCorrFactors.primaryVertices = cms.InputTag("offlineSlimmedPrimaryVertices")
return cms.InputTag("selectedPatJets")
def loadPAT(process, jetMetCorrections, mcInfo):
#-- Changes for electron and photon ID ----------------------------------------
# Turn off photon-electron cleaning (i.e., flag only)
process.cleanPatPhotons.checkOverlaps.electrons.requireNoOverlaps = False
# Add CiC electron ID's and WP eleID's
process.load("TripHto4lep.Skim3lep.cicEleIdSequence_42_cff")
process.load("TripHto4lep.Skim3lep.hzzEleIdSequence_cff")
process.load("TripHto4lep.Skim3lep.simpleEleIdSequence_cff")
process.patElectrons.electronIDSources = cms.PSet(
eidVeryLoose=cms.InputTag("eidVeryLooseMC"),
eidLoose=cms.InputTag("eidLooseMC"),
eidMedium=cms.InputTag("eidMediumMC"),
eidTight=cms.InputTag("eidTightMC"),
eidSuperTight=cms.InputTag("eidSuperTightMC"),
eidHyperTight1=cms.InputTag("eidHyperTight1MC"),
eidHZZVeryLoose=cms.InputTag("eidHZZVeryLoose"),
eidHZZLoose=cms.InputTag("eidHZZLoose"),
eidHZZMedium=cms.InputTag("eidHZZMedium"),
eidHZZTight=cms.InputTag("eidHZZTight"),
eidHZZSuperTight=cms.InputTag("eidHZZSuperTight"),
# eidHZZHyperTight1= cms.InputTag("eidHZZHyperTight1"),
simpleEleId95relIso=cms.InputTag("simpleEleId95relIso"),
simpleEleId90relIso=cms.InputTag("simpleEleId90relIso"),
simpleEleId85relIso=cms.InputTag("simpleEleId85relIso"),
simpleEleId80relIso=cms.InputTag("simpleEleId80relIso"),
simpleEleId70relIso=cms.InputTag("simpleEleId70relIso"),
simpleEleId60relIso=cms.InputTag("simpleEleId60relIso"))
process.patDefaultSequence.replace(
process.patElectrons,
process.simpleEleIdSequence + process.cicEleIdSequence +
process.hzzEleIdSequence + process.patElectrons)
# Switch to PF Jets
from PhysicsTools.PatAlgos.tools.jetTools import *
#switchJetCollection(process, jetCollection = cms.InputTag("ak5PFJets"), outputModule = 'out')
switchJetCollection(
process,
cms.InputTag('ak5PFJets'),
doJTA=True,
doBTagging=True,
jetCorrLabel=('AK5PF',
cms.vstring(['L1Offset', 'L2Relative', 'L3Absolute'])),
doType1MET=True,
genJetCollection=cms.InputTag("ak5GenJets"),
doJetID=True)
process.patJetCorrFactors.rho = cms.InputTag('')
def Pat(self) :
from PhysicsTools.PatAlgos.tools.coreTools import removeMCMatching,removeCleaning,restrictInputToAOD,removeAllPATObjectsBut
from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection
from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection
if self.options.isData: removeMCMatching(self.process, ['All'])
restrictInputToAOD(self.process)
removeCleaning(self.process)
removeAllPATObjectsBut(self.process, ['Jets','METs','Muons'])
addJetCollection(self.process,
cms.InputTag('ak5CaloJets'),
'AK5',
'Calo',
jetCorrLabel = ('AK5Calo',self.options.jetCorrections),
genJetCollection = cms.InputTag('ak5GenJets'),
doType1MET = False,
)
switchJetCollection(self.process,
cms.InputTag('ak5PFJets'),
doJTA = True,
doBTagging = True,
doJetID = True,
jetCorrLabel = ('AK5PF',self.options.jetCorrections),
genJetCollection = cms.InputTag('ak5GenJets'),
doType1MET = False,
jetIdLabel = 'ak5pf'
)
self.process.selectedPatJets.cut = cms.string("pt > 30 && \
abs(eta) < 3.0 && \
neutralHadronEnergyFraction < 0.9 && \
neutralEmEnergyFraction < 0.90 && \
nConstituents > 1 && \
(? abs(eta)<2.4 ? chargedHadronEnergyFraction : 1) > 0 && \
(? abs(eta)<2.4 ? chargedHadronMultiplicity : 1) > 0 && \
(? abs(eta)<2.4 ? chargedEmEnergyFraction : 0) < 0.99")
del self.process.out
del self.process.outpath
return self.process.patDefaultSequence
def metUncertainty(process):
process.load("PhysicsTools.PatAlgos.patSequences_cff")
#process.MetSequence += process.type0PFMEtCorrection
#process.MetSequence += process.patPFMETtype0Corr
#from PhysicsTools.PatAlgos.patTemplate_cfg import *
#from PhysicsTools.PatAlgos.tools.coreTools import *
from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection
#from PhysicsTools.PatAlgos.tools.metTools import *
switchJetCollection(
process,
cms.InputTag('ak5PFJets'),
doJTA=True,
doBTagging=False,
jetCorrLabel=('AK5PF',
cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute'])),
doType1MET=False,
doJetID=True,
jetIdLabel="ak5",
outputModules=[] # no PAT output module
)
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
runMEtUncertainties(process)
def metUncertainty(process):
process.load("PhysicsTools.PatAlgos.patSequences_cff")
# process.MetSequence += process.type0PFMEtCorrection
# process.MetSequence += process.patPFMETtype0Corr
# from PhysicsTools.PatAlgos.patTemplate_cfg import *
# from PhysicsTools.PatAlgos.tools.coreTools import *
from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection
# from PhysicsTools.PatAlgos.tools.metTools import *
switchJetCollection(
process,
cms.InputTag("ak5PFJets"),
doJTA=True,
doBTagging=False,
jetCorrLabel=("AK5PF", cms.vstring(["L1FastJet", "L2Relative", "L3Absolute"])),
doType1MET=False,
doJetID=True,
jetIdLabel="ak5",
outputModules=[], # no PAT output module
)
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
runMEtUncertainties(process)
def ReRunJetsEMB(process):
process.load("RecoJets.Configuration.RecoPFJets_cff")
import PhysicsTools.PatAlgos.tools.jetTools as jettools
process.load("PhysicsTools.PatAlgos.patSequences_cff")
process.load("UWAnalysis.Configuration.tools.patJetPUId_cfi")
from RecoBTag.SoftLepton.softLepton_cff import *
from RecoBTag.ImpactParameter.impactParameter_cff import *
from RecoBTag.SecondaryVertex.secondaryVertex_cff import *
from RecoBTau.JetTagComputer.combinedMVA_cff import *
process.pileupJetIdProducer.applyJec = cms.bool(True)
# Define options for BTagging - these are release dependent.
btag_options = {'doBTagging': True}
btag_options['btagInfo'] = [
'secondaryVertexTagInfos',
]
btag_options['btagdiscriminators'] = [
'combinedSecondaryVertexMVABJetTags',
'combinedSecondaryVertexBJetTags',
]
jec = ['L1FastJet', 'L2Relative', 'L3Absolute', 'L2L3Residual']
jettools.switchJetCollection(
process,
cms.InputTag('ak5PFJets'),
doJTA=False,
jetCorrLabel=('AK5PF', jec),
#jetCorrLabel = None,
doType1MET=False,
doJetID=True,
genJetCollection=cms.InputTag("ak5GenJets"),
outputModules=[],
**btag_options
)
process.patJets.embedPFCandidates = False
process.patJets.embedCaloTowers = False
process.patJets.embedGenJetMatch = False
process.patJets.addAssociatedTracks = False
process.patJets.embedGenPartonMatch = False
process.patJets.tagInfoSources = cms.VInputTag(cms.InputTag("secondaryVertexTagInfos"))
process.patJets.discriminatorSources = cms.VInputTag(cms.InputTag("combinedSecondaryVertexMVABJetTags"), cms.InputTag("combinedSecondaryVertexBJetTags"))
process.patJets.addBTagInfo = cms.bool(True)
process.ak5JetTracksAssociatorAtVertex = cms.EDProducer("JetTracksAssociatorAtVertex",
tracks = cms.InputTag("tmfTracks"),
jets = cms.InputTag("ak5PFJets"),
coneSize = cms.double(0.5)
)
process.load('UWAnalysis.Configuration.tools.RecoBTag_cff')
process.patJetCharge.src = cms.InputTag("ak5JetTracksAssociatorAtVertex")
process.NewSelectedPatJets = process.selectedPatJets.clone(src = cms.InputTag("patJetId"))
process.analysisSequence = cms.Sequence(
process.analysisSequence*
process.ak5PFJets*
process.ak5JetTracksAssociatorAtVertex*
process.btagging*
process.pileupJetIdProducer*
process.makePatJets*
process.patJetsPUID*
process.patJetId*
process.NewSelectedPatJets
)
process,
postfix = postfixAK4PFCHS,
labelName = labelAK4PFCHS,
jetSource = cms.InputTag('ak4PFJetsCHS'),
jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'Type-2')
)
process.out.outputCommands.append( 'drop *_selectedPatJets%s%s_caloTowers_*'%( labelAK4PFCHS, postfixAK4PFCHS ) )
# uncomment the following lines to add ak4PFJets to your PAT output
switchJetCollection(
process,
jetSource = cms.InputTag('ak4PFJets'),
jetCorrections = ('AK4PF', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'Type-1'),
btagDiscriminators = [
'pfJetBProbabilityBJetTags'
, 'pfJetProbabilityBJetTags'
, 'pfTrackCountingHighPurBJetTags'
, 'pfTrackCountingHighEffBJetTags'
, 'pfSimpleSecondaryVertexHighEffBJetTags'
, 'pfSimpleSecondaryVertexHighPurBJetTags'
, 'pfCombinedInclusiveSecondaryVertexV2BJetTags'
]
)
process.out.outputCommands.append( 'drop *_selectedPatJets_caloTowers_*' )
# uncomment the following lines to add ak8PFJetsCHSSoftDrop to your PAT output
labelAK8PFCHSSoftDrop = 'AK8PFCHSSoftDrop'
addJetCollection(
process,
labelName = labelAK8PFCHSSoftDrop,
jetSource = cms.InputTag('ak8PFJetsCHSSoftDrop',''),
algo = 'AK',
def addPlainPat(process, dataVersion, doPatTrigger=True, doPatTaus=True, doHChTauDiscriminators=True, doPatMET=True, doPatElectronID=True,
doPatCalo=True, doBTagging=True, doPatMuonPFIsolation=False, doPatTauIsoDeposits=False,
doTauHLTMatching=True, matchingTauTrigger=None, matchingJetTrigger=None,
includePFCands=False):
out = None
outdict = process.outputModules_()
if outdict.has_key("out"):
out = outdict["out"]
outputCommands = []
# Tau Discriminators
process.hplusPatTauSequence = cms.Sequence()
if doPatTaus:
process.hplusPatTauSequence = addPFTausAndDiscriminators(process, dataVersion, doPatCalo, doHChTauDiscriminators)
# PAT Layer 0+1
process.load("PhysicsTools.PatAlgos.patSequences_cff")
sequence = cms.Sequence(
process.hplusPatTauSequence
)
# Restrict input to AOD
restrictInputToAOD(process, ["All"])
# Remove MC stuff if we have collision data (has to be done any add*Collection!)
# This also adds the L2L3Residual JEC correction to the process.patJetCorrFactors
if dataVersion.isData():
runOnData(process, outputInProcess = out!=None)
# Jets
# Produce kt6 rho for L1Fastjet
process.load('RecoJets.Configuration.RecoPFJets_cff')
process.kt6PFJets.doRhoFastjet = True
process.ak5PFJets.doAreaFastjet = True
process.ak5PFJetSequence = cms.Sequence(process.kt6PFJets * process.ak5PFJets)
# Set defaults
process.patJets.jetSource = cms.InputTag("ak5CaloJets")
process.patJets.trackAssociationSource = cms.InputTag("ak5JetTracksAssociatorAtVertex")
setPatJetDefaults(process.patJets)
setPatJetCorrDefaults(process.patJetCorrFactors, dataVersion)
process.patDefaultSequence.replace(process.patJetCorrFactors,
process.ak5PFJetSequence*process.patJetCorrFactors)
process.selectedPatJets.cut = jetPreSelection
# The default JEC to be embedded to pat::Jets are L2Relative,
# L3Absolute, L5Flavor and L7Parton. The default JEC to be applied
# is L2L3Residual, or L3Absolute, or Uncorrected (in this order).
if doPatCalo:
# Add JPT jets
# FIXME: Disabled for now until the JEC for JPT works again (with the latest JEC)
# addJetCollection(process, cms.InputTag('JetPlusTrackZSPCorJetAntiKt5'),
# 'AK5', 'JPT',
# doJTA = True,
# doBTagging = doBTagging,
# jetCorrLabel = ('AK5JPT', process.patJetCorrFactors.levels),
# doType1MET = False,
# doL1Cleaning = False,
# doL1Counters = True,
# genJetCollection = cms.InputTag("ak5GenJets"),
# doJetID = True
# )
# Add PF jets
addJetCollection(process, cms.InputTag('ak5PFJets'),
'AK5', 'PF',
doJTA = True,
doBTagging = doBTagging,
jetCorrLabel = ('AK5PF', process.patJetCorrFactors.levels),
doType1MET = False,
doL1Cleaning = False,
doL1Counters = True,
genJetCollection = cms.InputTag("ak5GenJets"),
doJetID = True
)
setPatJetCorrDefaults(process.patJetCorrFactorsAK5PF, dataVersion, True)
else:
setPatJetCorrDefaults(process.patJetCorrFactors, dataVersion, True)
switchJetCollection(process, cms.InputTag('ak5PFJets'),
doJTA = True,
doBTagging = doBTagging,
jetCorrLabel = ('AK5PF', process.patJetCorrFactors.levels),
doType1MET = False,
genJetCollection = cms.InputTag("ak5GenJets"),
doJetID = True
)
outputCommands.extend([
"keep *_selectedPatJets_*_*",
"keep *_selectedPatJetsAK5JPT_*_*",
"keep *_selectedPatJetsAK5PF_*_*",
'drop *_selectedPatJets_pfCandidates_*', ## drop for default patJets which are CaloJets
'drop *_*PF_caloTowers_*',
'drop *_*JPT_pfCandidates_*',
'drop *_*Calo_pfCandidates_*',
])
# Taus
# Set default PATTauProducer options here, they should be
# replicated to all added tau collections (and the first call to
# addTauCollection should replace the default producer modified
# here)
setPatTauDefaults(process.patTaus, includePFCands)
process.selectedPatTaus.cut = tauPreSelection
if doPatTaus:
if doHChTauDiscriminators:
addHChTauDiscriminators()
# Don't enable TCTau nor shrinking cone tau
# if doPatCalo:
# tauTools.addTauCollection(process,cms.InputTag('caloRecoTauProducer'),
# algoLabel = "caloReco",
# typeLabel = "Tau")
# setPatTauDefaults(process.patTausCaloRecoTau, True)
# process.patTausCaloRecoTau.embedLeadTrack = not includePFCands
# process.patTausCaloRecoTau.embedLeadPFChargedHadrCand = False
# tauTools.addTauCollection(process,cms.InputTag('shrinkingConePFTauProducer'),
# algoLabel = "shrinkingCone",
# typeLabel = "PFTau")
# # Disable isoDeposits like this until the problem with doPFIsoDeposits is fixed
# if not doPatTauIsoDeposits:
# process.patTausShrinkingConePFTau.isoDeposits = cms.PSet()
tauTools.addTauCollection(process,cms.InputTag('hpsPFTauProducer'),
algoLabel = "hps",
typeLabel = "PFTau")
if not doPatTauIsoDeposits:
process.patTausHpsPFTau.isoDeposits = cms.PSet()
addPatTauIsolationEmbedding(process, process.patDefaultSequence, "HpsPFTau")
tauTools.addTauCollection(process,cms.InputTag('hpsTancTaus'),
algoLabel = "hpsTanc",
typeLabel = "PFTau")
if not doPatTauIsoDeposits:
process.patTausHpsTancPFTau.isoDeposits = cms.PSet()
# Disable discriminators which are not in AOD
# del process.patTausHpsTancPFTau.tauIDSources.againstCaloMuon
# del process.patTausHpsTancPFTau.tauIDSources.byHPSvloose
addPatTauIsolationEmbedding(process, process.patDefaultSequence, "HpsTancPFTau")
# Add visible taus
if dataVersion.isMC():
process.VisibleTaus = cms.EDProducer("HLTTauMCProducer",
GenParticles = cms.untracked.InputTag("genParticles"),
ptMinTau = cms.untracked.double(3),
ptMinMuon = cms.untracked.double(3),
ptMinElectron = cms.untracked.double(3),
BosonID = cms.untracked.vint32(23),
EtaMax = cms.untracked.double(2.5)
)
sequence *= process.VisibleTaus
outputCommands.append("keep *_VisibleTaus_*_*")
else:
# FIXME: this is broken at the moment
#removeSpecificPATObjects(process, ["Taus"], outputInProcess= out != None)
process.patDefaultSequence.remove(process.patTaus)
process.patDefaultSequence.remove(process.selectedPatTaus)
outputCommands.extend(["drop *_selectedPatTaus_*_*",
# "keep *_selectedPatTausCaloRecoTau_*_*",
# "keep *_selectedPatTausShrinkingConePFTau_*_*",
"keep *_selectedPatTausHpsPFTau_*_*",
"keep *_selectedPatTausHpsTancPFTau_*_*",
#"keep *_cleanPatTaus_*_*",
#"drop *_cleanPatTaus_*_*",
#"keep *_patTaus*_*_*",
#"keep *_patPFTauProducerFixedCone_*_*",
# keep these until the embedding problem with pat::Tau is fixed
#"keep recoPFCandidates_particleFlow_*_*",
#"keep recoTracks_generalTracks_*_*"
])
# MET
addPfMET(process, 'PF')
if doPatCalo:
addTcMET(process, 'TC')
else:
# FIXME: This is broken at the moment...
#removeSpecificPATObjects(process, ["METs"], outputInProcess= out != None)
#process.patDefaultSequen
process.patDefaultSequence.remove(process.patMETCorrections)
process.patDefaultSequence.remove(process.patMETs)
del process.patMETCorrections
del process.patMETs
outputCommands.extend([
"keep *_patMETs_*_*",
"keep *_patMETsTC_*_*",
"keep *_patMETsPF_*_*",
"keep *_genMetTrue_*_*",
])
# Muons
setPatLeptonDefaults(process.patMuons, includePFCands)
if doPatMuonPFIsolation:
addPFMuonIsolation(process, process.patMuons, sequence, verbose=True)
outputCommands.extend([
"keep *_selectedPatMuons_*_*"
])
# Electrons
# In order to calculate the transverse impact parameter w.r.t.
# beam spot instead of primary vertex, see
setPatLeptonDefaults(process.patMuons, includePFCands)
# Electron ID, see
# https://twiki.cern.ch/twiki/bin/view/CMS/SimpleCutBasedEleID
if doPatElectronID:
addPatElectronID(process, process.patElectrons, process.patDefaultSequence)
outputCommands.extend([
"keep *_selectedPatElectrons_*_*"
])
# Photons
# process.patPhotons.embedGenMatch = False
outputCommands.extend([
"keep *_selectedPatPhotons_*_*"
])
# Trigger
if doPatTrigger:
outMod= ''
if out != None:
outMod = 'out'
switchOnTrigger(process, hltProcess=dataVersion.getTriggerProcess(), outputModule=outMod)
process.patTrigger.addL1Algos = cms.bool(True)
process.patTrigger.l1ExtraMu = cms.InputTag("l1extraParticles")
process.patTrigger.l1ExtraCenJet = cms.InputTag("l1extraParticles", "Central")
process.patTrigger.l1ExtraTauJet = cms.InputTag("l1extraParticles", "Tau")
process.patTrigger.l1ExtraForJet = cms.InputTag("l1extraParticles", "Forward")
process.patTrigger.l1ExtraETM = cms.InputTag("l1extraParticles", "MET")
process.patTrigger.l1ExtraHTM = cms.InputTag("l1extraParticles", "MHT")
# Keep StandAlone trigger objects for enabling trigger
# matching in the analysis phase with PAT tools
outputCommands.extend(patTriggerStandAloneEventContent)
# Remove cleaning step and set the event content
if out == None:
myRemoveCleaning(process)
else:
backup = out.outputCommands[:]
myRemoveCleaning(process)
# backup_pat = out.outputCommands[:]
# Remove PFParticles here, they are explicitly included when needed
# backup_pat = filter(lambda n: "selectedPatPFParticles" not in n, backup_pat)
out.outputCommands = backup
# out.outputCommands.extend(backup_pat)
out.outputCommands.extend(outputCommands)
# Build sequence
sequence *= process.patDefaultSequence
# Tau+HLT matching
if doTauHLTMatching:
sequence *= HChTriggerMatching.addTauHLTMatching(process, matchingTauTrigger, matchingJetTrigger)
return sequence
########################################
if isData:
from PhysicsTools.PatAlgos.tools.coreTools import *
removeMCMatching(process, ['All'], outputInProcess=False)
########################################
# PAT Jet Energy Corrections - MC vs Data
########################################
#
from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection
if isMC:
switchJetCollection(process,
jetCollection=cms.InputTag('ak5CaloJets'),
jetCorrLabel=('AK5Calo',
['L1Offset', 'L2Relative',
'L3Absolute']))
else:
switchJetCollection(process,
jetCollection=cms.InputTag('ak5CaloJets'),
jetCorrLabel=('AK5Calo',
['L1Offset', 'L2Relative',
'L3Absolute']))
########################################
# PAT Trigger matching
########################################
# imported directly from PhysicsTools/PatExamples/test/analyzePatTrigger_onTheFly_cfg.py
#
process.load("HeavyNu.AnalysisModules.hnutrigmatch_cfi")
rParam = 0.8,
jetCorrections = ('AK7PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None'),
trackSource = cms.InputTag('unpackedTracksAndVertices'),
pvSource = cms.InputTag('unpackedTracksAndVertices'),
)
addJetCollection(
process,
labelName = 'AK8PFCHS',
jetSource = cms.InputTag('ak8PFJetsCHS'),
algo = 'ak8',
rParam = 0.8,
jetCorrections = ('AK7PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None'),
trackSource = cms.InputTag('unpackedTracksAndVertices'),
pvSource = cms.InputTag('unpackedTracksAndVertices'),
)
"""
switchJetCollection(
process,
jetSource = cms.InputTag('ak4PFJets'),
algo = 'ak4',
rParam = 0.4,
jetCorrections = ('AK5PF', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'Type-1'),
# btagDiscriminators = ['jetBProbabilityBJetTags',
# 'jetProbabilityBJetTags',
# 'trackCountingHighPurBJetTags',
# 'trackCountingHighEffBJetTags',
# 'simpleSecondaryVertexHighEffBJetTags',
# 'simpleSecondaryVertexHighPurBJetTags',
# 'combinedSecondaryVertexBJetTags'
# ],
trackSource = cms.InputTag('unpackedTracksAndVertices'),
def configurePatTuple(process, isMC=True, **kwargs):
# Stuff we always keep
output_commands = [
# '*',
'*_addPileupInfo_*_*',
'edmMergeableCounter_*_*_*',
'*_lumiProducer_*_*',
'*_particleFlow_*_*',
'*_offlineBeamSpot_*_*',
'*_generalTracks_*_*',
'*_electronGsfTracks_*_*',
'*_offlinePrimaryVertices*_*_*',
'*_ak5GenJets_*_*',
'*_hltTriggerSummaryAOD_*_*',
'edmTriggerResults_TriggerResults_*_%s' % process.name_(),
'*_MEtoEDMConverter*_*_%s' % process.name_(),
'LHEEventProduct_*_*_*',
'GenEventInfoProduct_generator_*_*',
'*_kt6PFJetsForRhoComputationVoronoi_rho_*',
'*_kt6PFJetsForIso_rho_*',
'*_kt6PFJets_rho_*',
'*_kt6PFJetsCentralHZGPho_rho_*',
'*_kt6PFJetsCentralHZGEle_rho_*',
'*_kt6PFJetsCentralHZGMu_rho_*',
'*_kt6PFJetsCentralNeutralHZGMu_rho_*',
'*_kt6PFJetsCentral_rho_*',
'*_kt6PFJetsCentralNeutral_rho_*', #for zz muons
'*_photonCore_*_*',
# for Zmumu -> embedded samples
'*_generator_weight_*', # 2k11
"GenFilterInfo_generator_minVisPtFilter_*", #2k12
'*_genDaughters_*_*',
'*_boosted*_*_*',
'*_tmfTracks_*_*',
]
# Define our patTuple production sequence
process.tuplize = cms.Sequence()
# Only keep interesting genParticles
process.load("FinalStateAnalysis.RecoTools.genParticleTrimmer_cfi")
process.genParticles = process.prunedGenParticles.clone()
if isMC:
#process.tuplize += process.genParticles
#output_commands.append('*_genParticles_*_%s' % process.name_())
output_commands.append('*_genParticles_*_*')
output_commands.append('*_tauGenJetsSelectorAllHadrons_*_*')
output_commands.append('*_tauGenJets_*_*')
output_commands.append('*_ak5GenJets_*_*')
# Select vertices
process.load("FinalStateAnalysis.RecoTools.vertexSelection_cff")
output_commands.append('*_selectedPrimaryVertex_*_*')
output_commands.append('*_selectPrimaryVerticesQuality_*_*')
process.tuplize += process.selectPrimaryVertices
# Run the ZZ recipe for rho
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets \
as zzCantDoAnythingRight
process.kt6PFJetsForIso = zzCantDoAnythingRight.clone(
rParam=cms.double(0.6),
doAreaFastjet=cms.bool(True),
doRhoFastjet=cms.bool(True),
Rho_EtaMax=cms.double(2.5),
Ghost_EtaMax=cms.double(2.5),
)
process.tuplize += process.kt6PFJetsForIso
# Standard services
process.load('Configuration.StandardSequences.Services_cff')
# tack on seeds for FSA PATTuple modules
add_fsa_random_seeds(process)
if cmssw_major_version() == 5 and cmssw_minor_version() >= 3:
process.load('Configuration.Geometry.GeometryIdeal_cff')
else:
process.load('Configuration.StandardSequences.GeometryIdeal_cff')
process.load('Configuration.StandardSequences.MagneticField_cff')
process.load(
'Configuration.StandardSequences.FrontierConditions_GlobalTag_cff')
# Rerun tau ID
if cmssw_major_version() == 4:
process.load("RecoTauTag.Configuration.RecoPFTauTag_cff")
# Optimization - remove PFTauTagInfo compatibility layer
process.recoTauClassicHPSSequence.remove(
process.pfRecoTauTagInfoProducer)
process.recoTauClassicHPSSequence.remove(
process.ak5PFJetTracksAssociatorAtVertex)
assert (process.combinatoricRecoTaus.modifiers[3].name.value() ==
'TTIworkaround')
del process.combinatoricRecoTaus.modifiers[3]
# Don't build junky taus below 19 GeV
process.combinatoricRecoTaus.builders[0].minPtToBuild = cms.double(17)
process.tuplize += process.recoTauClassicHPSSequence
else:
# We can run less tau stuff in 52, since HPS taus already built.
process.load("RecoTauTag.Configuration.updateHPSPFTaus_cff")
process.tuplize += process.updateHPSPFTaus
## Run rho computation. Only necessary in 42X
if cmssw_major_version() == 4:
from RecoJets.Configuration.RecoPFJets_cff import kt6PFJets
kt6PFJets.Rho_EtaMax = cms.double(4.4)
kt6PFJets.doRhoFastjet = True
process.kt6PFJets = kt6PFJets
process.tuplize += process.kt6PFJets
# In 4_X we have to rerun ak5PFJets with area computation enabled.
if cmssw_major_version() == 4:
process.load("RecoJets.Configuration.RecoPFJets_cff")
process.ak5PFJets.doAreaFastjet = True
process.tuplize += process.ak5PFJets
# Only keep the new ak5PFJets
output_commands.append('*_ak5PFJets_*_%s' % process.name_())
else:
# Just keep the normal ones
output_commands.append('*_ak5PFJets_*_*')
# In the embedded samples, we need to re-run the b-tagging
if kwargs['embedded']:
process.load('RecoBTag/Configuration/RecoBTag_cff')
process.load('RecoJets/JetAssociationProducers/ak5JTA_cff')
process.ak5JetTracksAssociatorAtVertex.jets = cms.InputTag("ak5PFJets")
process.ak5JetTracksAssociatorAtVertex.tracks = cms.InputTag(
"tmfTracks")
process.tuplize += process.ak5JetTracksAssociatorAtVertex
process.tuplize += process.btagging
# Run pat default sequence
process.load("PhysicsTools.PatAlgos.patSequences_cff")
# Embed PF Isolation in electrons & muons
pfTools.usePFIso(process)
# Setup H2Tau custom iso definitions
setup_h2tau_iso(process)
# Setup hZg custom iso definitions
add_hZg_iso_needs(process)
# Use POG recommendations for (these) electron Isos
process.elPFIsoValueGamma04PFIdPFIso.deposits[0].vetos = cms.vstring(
'EcalEndcaps:ConeVeto(0.08)')
process.elPFIsoValueGamma04NoPFIdPFIso.deposits[0].vetos = cms.vstring(
'EcalEndcaps:ConeVeto(0.08)')
process.elPFIsoValueCharged04PFIdPFIso.deposits[0].vetos = cms.vstring(
'EcalEndcaps:ConeVeto(0.015)')
process.elPFIsoValueCharged04NoPFIdPFIso.deposits[0].vetos = cms.vstring(
'EcalEndcaps:ConeVeto(0.015)')
# Unembed junk
process.patMuons.embedCaloMETMuonCorrs = False
process.patMuons.embedTcMETMuonCorrs = False
process.patMuons.embedTrack = True
process.patMuons.pvSrc = cms.InputTag("selectedPrimaryVertex")
# Do extra electron ID
process.load("FinalStateAnalysis.PatTools.electrons.electronID_cff")
process.tuplize += process.recoElectronID
process.patElectrons.electronIDSources = process.electronIDSources
process.patElectrons.embedTrack = True
# Now run PAT
process.tuplize += process.patDefaultSequence
# Add FSR photons for ZZ analysis
process.load("FinalStateAnalysis.PatTools.fsrPhotons_cff")
process.tuplize += process.fsrPhotonSequence
# Use HPS taus
tautools.switchToPFTauHPS(process)
# Disable tau IsoDeposits
process.patDefaultSequence.remove(process.patPFTauIsolation)
process.patTaus.isoDeposits = cms.PSet()
process.patTaus.userIsolation = cms.PSet()
# Disable gen match embedding - we keep it in the ntuple
process.patMuons.embedGenMatch = False
process.patElectrons.embedGenMatch = False
process.patTaus.embedGenMatch = False
process.patTaus.embedGenJetMatch = False
# Use PFJets and turn on JEC
jec = ['L1FastJet', 'L2Relative', 'L3Absolute']
# If we are running on data (not MC), or embedded sample,
# apply the MC-DATA residual correction.
if not isMC or kwargs['embedded']:
jec.extend(['L2L3Residual'])
# Define options for BTagging - these are release dependent.
btag_options = {'doBTagging': True}
if cmssw_major_version() == 5:
btag_options['btagInfo'] = [
'impactParameterTagInfos', 'secondaryVertexTagInfos',
'softMuonTagInfos', 'secondaryVertexNegativeTagInfos'
]
btag_options['btagdiscriminators'] = [
'trackCountingHighEffBJetTags',
'simpleSecondaryVertexHighEffBJetTags',
'combinedSecondaryVertexMVABJetTags',
'combinedSecondaryVertexBJetTags',
]
# Use AK5 PFJets
jettools.switchJetCollection(
process,
cms.InputTag('ak5PFJets'),
doJTA=False,
jetCorrLabel=('AK5PF', jec),
#jetCorrLabel = None,
doType1MET=False,
doJetID=True,
genJetCollection=cms.InputTag("ak5GenJets"),
**btag_options)
process.patJets.embedPFCandidates = False
process.patJets.embedCaloTowers = False
process.patJets.embedGenJetMatch = False
process.patJets.addAssociatedTracks = False
process.patJets.embedGenPartonMatch = False
#process.patJetCorrFactors.useRho = True
## Let's use the same rho as in the TauID, so we don't need to do it twice.
#process.patJetCorrFactors.rho = cms.InputTag(
#"kt6PFJetsForRhoComputationVoronoi", "rho")
# Use PFMEt
mettools.addPfMET(process)
if not isMC:
coreTools.runOnData(process)
process.patMETsPF.addGenMET = False
output_commands.append('*_selectedPatJets_*_*')
# Customize/embed all our sequences
process.load("FinalStateAnalysis.PatTools.patJetProduction_cff")
# We have to keep all jets (for the MVA MET...)
process.patJetGarbageRemoval.cut = 'pt > 0'
final_jet_collection = chain_sequence(process.customizeJetSequence,
"patJets")
process.customizeJetSequence.insert(0, process.patJets)
# Make it a "complete" sequence
process.customizeJetSequence += process.selectedPatJets
# We can't mess up the selected pat jets because the taus use them.
process.selectedPatJets.src = final_jet_collection
process.patDefaultSequence.replace(process.patJets,
process.customizeJetSequence)
# Produce the electron collections
process.load("FinalStateAnalysis.PatTools.patElectronProduction_cff")
final_electron_collection = chain_sequence(
process.customizeElectronSequence, "selectedPatElectrons")
process.tuplize += process.customizeElectronSequence
process.customizeElectronSequence.insert(0, process.selectedPatElectrons)
process.patDefaultSequence.replace(process.selectedPatElectrons,
process.customizeElectronSequence)
# We have to do the pat Jets before the pat electrons since we embed them
process.customizeElectronSequence.insert(0, process.selectedPatJets)
process.cleanPatElectrons.src = final_electron_collection
#setup the energy regression for the specific dataset
process.patElectronEnergyCorrections.isMC = cms.bool(bool(isMC))
process.patElectronEnergyCorrections.isAOD = \
cms.bool(bool(kwargs['isAOD']))
process.patElectronEnergyCorrections.dataSet = \
cms.string(kwargs['calibrationTarget'])
process.load("FinalStateAnalysis.PatTools.patMuonProduction_cff")
final_muon_collection = chain_sequence(process.customizeMuonSequence,
"selectedPatMuons")
process.customizeMuonSequence.insert(0, process.selectedPatMuons)
process.patDefaultSequence.replace(process.selectedPatMuons,
process.customizeMuonSequence)
process.cleanPatMuons.src = final_muon_collection
process.patMuonRochesterCorrectionEmbedder.isMC = cms.bool(bool(isMC))
process.load("FinalStateAnalysis.PatTools.patTauProduction_cff")
final_tau_collection = chain_sequence(process.customizeTauSequence,
"selectedPatTaus")
# Inject into the pat sequence
process.customizeTauSequence.insert(0, process.selectedPatTaus)
process.patDefaultSequence.replace(process.selectedPatTaus,
process.customizeTauSequence)
process.cleanPatTaus.src = final_tau_collection
# Remove muons and electrons
process.cleanPatTaus.checkOverlaps.muons.requireNoOverlaps = False
process.cleanPatTaus.checkOverlaps.electrons.requireNoOverlaps = False
# Apply a loose preselection
process.cleanPatTaus.preselection = 'abs(eta) < 2.5 & pt > 17'
# Don't apply any "final" cut
process.cleanPatTaus.finalCut = ''
# Setup pat::Photon Production
process.load("FinalStateAnalysis.PatTools.patPhotonProduction_cff")
final_photon_collection = chain_sequence(process.customizePhotonSequence,
"selectedPatPhotons")
#inject photons into pat sequence
process.customizePhotonSequence.insert(0, process.selectedPatPhotons)
process.patDefaultSequence.replace(process.selectedPatPhotons,
process.customizePhotonSequence)
process.cleanPatPhotons.src = final_photon_collection
# Setup MET production
process.load("FinalStateAnalysis.PatTools.patMETProduction_cff")
final_met_collection = chain_sequence(process.customizeMETSequence,
"patMETsPF")
process.tuplize += process.customizeMETSequence
# The MET systematics depend on all other systematics
process.systematicsMET.tauSrc = cms.InputTag("cleanPatTaus")
process.systematicsMET.muonSrc = cms.InputTag("cleanPatMuons")
process.systematicsMET.electronSrc = cms.InputTag("cleanPatElectrons")
# Keep all the data formats needed for the systematics
output_commands.append('recoLeafCandidates_*_*_%s' % process.name_())
# Define the default lepton cleaning
process.cleanPatElectrons.preselection = cms.string('pt > 5')
process.cleanPatElectrons.checkOverlaps.muons.requireNoOverlaps = False
# Make sure we don't kill any good taus by calling them electrons
# Note that we don't actually remove these overlaps.
process.cleanPatElectrons.checkOverlaps.taus = cms.PSet(
src=final_tau_collection,
algorithm=cms.string("byDeltaR"),
preselection=cms.string(
"tauID('decayModeFinding') > 0.5 &&"
"tauID('byLooseCombinedIsolationDeltaBetaCorr') > 0.5 &&"
"tauID('againstElectronLoose') > 0.5 && "
"pt > 10"),
deltaR=cms.double(0.1),
checkRecoComponents=cms.bool(False),
pairCut=cms.string(""),
requireNoOverlaps=cms.bool(False),
)
output_commands.append('*_cleanPatTaus_*_*')
output_commands.append('*_cleanPatElectrons_*_*')
output_commands.append('*_cleanPatMuons_*_*')
output_commands.append('*_cleanPatPhotons_*_*')
output_commands.append('*_%s_*_*' % final_met_collection.value())
trigtools.switchOnTrigger(process)
# Now build the PATFinalStateLS object, which holds LumiSection info.
process.load(
"FinalStateAnalysis.PatTools.finalStates.patFinalStateLSProducer_cfi")
process.tuplize += process.finalStateLS
output_commands.append('*_finalStateLS_*_*')
if isMC:
process.finalStateLS.xSec = kwargs['xSec']
# Tell the framework to shut up!
process.load("FWCore.MessageLogger.MessageLogger_cfi")
process.MessageLogger.cerr.FwkReport.reportEvery = 1000
# Which collections are used to build the final states
fs_daughter_inputs = {
'electrons': 'cleanPatElectrons',
'muons': 'cleanPatMuons',
'taus': 'cleanPatTaus',
'photons': 'cleanPatPhotons',
'jets': 'selectedPatJets',
'met': final_met_collection,
}
# Setup all the PATFinalState objects
produce_final_states(process, fs_daughter_inputs, output_commands,
process.tuplize, kwargs['puTag'])
return process.tuplize, output_commands
jetSource=cms.InputTag('ak4PFJetsCHS'),
jetCorrections=('AK4PFchs',
cms.vstring(
['L1FastJet', 'L2Relative',
'L3Absolute']), 'Type-2'))
process.out.outputCommands.append('drop *_selectedPatJets%s%s_caloTowers_*' %
(labelAK4PFCHS, postfixAK4PFCHS))
# uncomment the following lines to add ak4PFJets to your PAT output
switchJetCollection(
process,
jetSource=cms.InputTag('ak4PFJets'),
jetCorrections=('AK4PF',
cms.vstring(['L1FastJet', 'L2Relative',
'L3Absolute']), 'Type-1'),
btagDiscriminators=[
'pfJetBProbabilityBJetTags', 'pfJetProbabilityBJetTags',
'pfTrackCountingHighPurBJetTags', 'pfTrackCountingHighEffBJetTags',
'pfSimpleSecondaryVertexHighEffBJetTags',
'pfSimpleSecondaryVertexHighPurBJetTags',
'pfCombinedInclusiveSecondaryVertexV2BJetTags'
])
process.out.outputCommands.append('drop *_selectedPatJets_caloTowers_*')
# uncomment the following lines to add ak8PFJetsCHSSoftDrop to your PAT output
labelAK8PFCHSSoftDrop = 'AK8PFCHSSoftDrop'
addJetCollection(
process,
labelName=labelAK8PFCHSSoftDrop,
jetSource=cms.InputTag('ak8PFJetsCHSSoftDrop', ''),
algo='AK',
def configurePatTuple(process, isMC=True, **kwargs):
# Stuff we always keep
output_commands = [
# '*',
'*_addPileupInfo_*_*',
'edmMergeableCounter_*_*_*',
'*_lumiProducer_*_*',
'*_particleFlow_*_*',
'*_offlineBeamSpot_*_*',
'*_generalTracks_*_*',
'*_electronGsfTracks_*_*',
'*_offlinePrimaryVertices*_*_*',
'*_ak5GenJets_*_*',
'*_hltTriggerSummaryAOD_*_*',
'edmTriggerResults_TriggerResults_*_%s' % process.name_(),
'*_MEtoEDMConverter*_*_%s' % process.name_(),
'LHEEventProduct_*_*_*',
'GenEventInfoProduct_generator_*_*',
'*_kt6PFJetsForRhoComputationVoronoi_rho_*',
'*_kt6PFJetsForIso_rho_*',
'*_kt6PFJets_rho_*',
'*_kt6PFJetsCentralHZGPho_rho_*',
'*_kt6PFJetsCentralHZGEle_rho_*',
'*_kt6PFJetsCentralHZGMu_rho_*',
'*_kt6PFJetsCentralNeutralHZGMu_rho_*',
'*_kt6PFJetsCentral_rho_*',
'*_kt6PFJetsCentralNeutral_rho_*', #for zz muons
'*_photonCore_*_*',
# for Zmumu -> embedded samples
'*_generator_weight_*', # 2k11
"GenFilterInfo_generator_minVisPtFilter_*", #2k12
'*_genDaughters_*_*',
'*_boosted*_*_*',
'*_tmfTracks_*_*',
]
# Define our patTuple production sequence
process.tuplize = cms.Sequence()
# Only keep interesting genParticles
process.load("FinalStateAnalysis.RecoTools.genParticleTrimmer_cfi")
process.genParticles = process.prunedGenParticles.clone()
if isMC:
#process.tuplize += process.genParticles
#output_commands.append('*_genParticles_*_%s' % process.name_())
output_commands.append('*_genParticles_*_*')
output_commands.append('*_tauGenJetsSelectorAllHadrons_*_*')
output_commands.append('*_tauGenJets_*_*')
output_commands.append('*_ak5GenJets_*_*')
# Select vertices
process.load("FinalStateAnalysis.RecoTools.vertexSelection_cff")
output_commands.append('*_selectedPrimaryVertex_*_*')
output_commands.append('*_selectPrimaryVerticesQuality_*_*')
process.tuplize += process.selectPrimaryVertices
# Run the ZZ recipe for rho
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets \
as zzCantDoAnythingRight
process.kt6PFJetsForIso = zzCantDoAnythingRight.clone(
rParam = cms.double(0.6),
doAreaFastjet = cms.bool(True),
doRhoFastjet = cms.bool(True),
Rho_EtaMax = cms.double(2.5),
Ghost_EtaMax = cms.double(2.5),
)
process.tuplize += process.kt6PFJetsForIso
# Standard services
process.load('Configuration.StandardSequences.Services_cff')
# tack on seeds for FSA PATTuple modules
add_fsa_random_seeds(process)
if cmssw_major_version() == 5 and cmssw_minor_version() >= 3:
process.load('Configuration.Geometry.GeometryIdeal_cff')
else:
process.load('Configuration.StandardSequences.GeometryIdeal_cff')
process.load('Configuration.StandardSequences.MagneticField_cff')
process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff')
# Rerun tau ID
if cmssw_major_version() == 4:
process.load("RecoTauTag.Configuration.RecoPFTauTag_cff")
# Optimization - remove PFTauTagInfo compatibility layer
process.recoTauClassicHPSSequence.remove(process.pfRecoTauTagInfoProducer)
process.recoTauClassicHPSSequence.remove(process.ak5PFJetTracksAssociatorAtVertex)
assert(process.combinatoricRecoTaus.modifiers[3].name.value() == 'TTIworkaround')
del process.combinatoricRecoTaus.modifiers[3]
# Don't build junky taus below 19 GeV
process.combinatoricRecoTaus.builders[0].minPtToBuild = cms.double(17)
process.tuplize += process.recoTauClassicHPSSequence
else:
# We can run less tau stuff in 52, since HPS taus already built.
process.load("RecoTauTag.Configuration.updateHPSPFTaus_cff")
process.tuplize += process.updateHPSPFTaus
## Run rho computation. Only necessary in 42X
if cmssw_major_version() == 4:
from RecoJets.Configuration.RecoPFJets_cff import kt6PFJets
kt6PFJets.Rho_EtaMax = cms.double(4.4)
kt6PFJets.doRhoFastjet = True
process.kt6PFJets = kt6PFJets
process.tuplize += process.kt6PFJets
# In 4_X we have to rerun ak5PFJets with area computation enabled.
if cmssw_major_version() == 4:
process.load("RecoJets.Configuration.RecoPFJets_cff")
process.ak5PFJets.doAreaFastjet = True
process.tuplize += process.ak5PFJets
# Only keep the new ak5PFJets
output_commands.append('*_ak5PFJets_*_%s' % process.name_())
else:
# Just keep the normal ones
output_commands.append('*_ak5PFJets_*_*')
# In the embedded samples, we need to re-run the b-tagging
if kwargs['embedded']:
process.load('RecoBTag/Configuration/RecoBTag_cff')
process.load('RecoJets/JetAssociationProducers/ak5JTA_cff')
process.ak5JetTracksAssociatorAtVertex.jets = cms.InputTag("ak5PFJets")
process.ak5JetTracksAssociatorAtVertex.tracks = cms.InputTag("tmfTracks")
process.tuplize += process.ak5JetTracksAssociatorAtVertex
process.tuplize += process.btagging
# Run pat default sequence
process.load("PhysicsTools.PatAlgos.patSequences_cff")
# Embed PF Isolation in electrons & muons
pfTools.usePFIso(process)
# Setup H2Tau custom iso definitions
setup_h2tau_iso(process)
# Setup hZg custom iso definitions
add_hZg_iso_needs(process)
# Use POG recommendations for (these) electron Isos
process.elPFIsoValueGamma04PFIdPFIso.deposits[0].vetos = cms.vstring('EcalEndcaps:ConeVeto(0.08)')
process.elPFIsoValueGamma04NoPFIdPFIso.deposits[0].vetos = cms.vstring('EcalEndcaps:ConeVeto(0.08)')
process.elPFIsoValueCharged04PFIdPFIso.deposits[0].vetos = cms.vstring('EcalEndcaps:ConeVeto(0.015)')
process.elPFIsoValueCharged04NoPFIdPFIso.deposits[0].vetos = cms.vstring('EcalEndcaps:ConeVeto(0.015)')
# Unembed junk
process.patMuons.embedCaloMETMuonCorrs = False
process.patMuons.embedTcMETMuonCorrs = False
process.patMuons.embedTrack = True
process.patMuons.pvSrc = cms.InputTag("selectedPrimaryVertex")
# Do extra electron ID
process.load("FinalStateAnalysis.PatTools.electrons.electronID_cff")
process.tuplize += process.recoElectronID
process.patElectrons.electronIDSources = process.electronIDSources
process.patElectrons.embedTrack = True
# Now run PAT
process.tuplize += process.patDefaultSequence
# Add FSR photons for ZZ analysis
process.load("FinalStateAnalysis.PatTools.fsrPhotons_cff")
process.tuplize += process.fsrPhotonSequence
# Use HPS taus
tautools.switchToPFTauHPS(process)
# Disable tau IsoDeposits
process.patDefaultSequence.remove(process.patPFTauIsolation)
process.patTaus.isoDeposits = cms.PSet()
process.patTaus.userIsolation = cms.PSet()
# Disable gen match embedding - we keep it in the ntuple
process.patMuons.embedGenMatch = False
process.patElectrons.embedGenMatch = False
process.patTaus.embedGenMatch = False
process.patTaus.embedGenJetMatch = False
# Use PFJets and turn on JEC
jec = [ 'L1FastJet', 'L2Relative', 'L3Absolute' ]
# If we are running on data (not MC), or embedded sample,
# apply the MC-DATA residual correction.
if not isMC or kwargs['embedded']:
jec.extend([ 'L2L3Residual' ])
# Define options for BTagging - these are release dependent.
btag_options = {'doBTagging' : True}
if cmssw_major_version() == 5:
btag_options['btagInfo'] = [
'impactParameterTagInfos',
'secondaryVertexTagInfos',
'softMuonTagInfos',
'secondaryVertexNegativeTagInfos'
]
btag_options['btagdiscriminators'] = [
'trackCountingHighEffBJetTags',
'simpleSecondaryVertexHighEffBJetTags',
'combinedSecondaryVertexMVABJetTags',
'combinedSecondaryVertexBJetTags',
]
# Use AK5 PFJets
jettools.switchJetCollection(
process,
cms.InputTag('ak5PFJets'),
doJTA = False,
jetCorrLabel = ('AK5PF', jec),
#jetCorrLabel = None,
doType1MET = False,
doJetID = True,
genJetCollection = cms.InputTag("ak5GenJets"),
**btag_options
)
process.patJets.embedPFCandidates = False
process.patJets.embedCaloTowers = False
process.patJets.embedGenJetMatch = False
process.patJets.addAssociatedTracks = False
process.patJets.embedGenPartonMatch = False
#process.patJetCorrFactors.useRho = True
## Let's use the same rho as in the TauID, so we don't need to do it twice.
#process.patJetCorrFactors.rho = cms.InputTag(
#"kt6PFJetsForRhoComputationVoronoi", "rho")
# Use PFMEt
mettools.addPfMET(process)
if not isMC:
coreTools.runOnData(process)
process.patMETsPF.addGenMET = False
output_commands.append('*_selectedPatJets_*_*')
# Customize/embed all our sequences
process.load("FinalStateAnalysis.PatTools.patJetProduction_cff")
# We have to keep all jets (for the MVA MET...)
process.patJetGarbageRemoval.cut = 'pt > 0'
final_jet_collection = chain_sequence(
process.customizeJetSequence, "patJets")
process.customizeJetSequence.insert(0, process.patJets)
# Make it a "complete" sequence
process.customizeJetSequence += process.selectedPatJets
# We can't mess up the selected pat jets because the taus use them.
process.selectedPatJets.src = final_jet_collection
process.patDefaultSequence.replace(process.patJets,
process.customizeJetSequence)
# Produce the electron collections
process.load("FinalStateAnalysis.PatTools.patElectronProduction_cff")
final_electron_collection = chain_sequence(
process.customizeElectronSequence, "selectedPatElectrons")
process.tuplize += process.customizeElectronSequence
process.customizeElectronSequence.insert(0, process.selectedPatElectrons)
process.patDefaultSequence.replace(process.selectedPatElectrons,
process.customizeElectronSequence)
# We have to do the pat Jets before the pat electrons since we embed them
process.customizeElectronSequence.insert(0, process.selectedPatJets)
process.cleanPatElectrons.src = final_electron_collection
#setup the energy regression for the specific dataset
process.patElectronEnergyCorrections.isMC = cms.bool(bool(isMC))
process.patElectronEnergyCorrections.isAOD = \
cms.bool(bool(kwargs['isAOD']))
process.patElectronEnergyCorrections.dataSet = \
cms.string(kwargs['calibrationTarget'])
process.load("FinalStateAnalysis.PatTools.patMuonProduction_cff")
final_muon_collection = chain_sequence(
process.customizeMuonSequence, "selectedPatMuons")
process.customizeMuonSequence.insert(0, process.selectedPatMuons)
process.patDefaultSequence.replace(process.selectedPatMuons,
process.customizeMuonSequence)
process.cleanPatMuons.src = final_muon_collection
process.patMuonRochesterCorrectionEmbedder.isMC = cms.bool(bool(isMC))
process.load("FinalStateAnalysis.PatTools.patTauProduction_cff")
final_tau_collection = chain_sequence(
process.customizeTauSequence, "selectedPatTaus")
# Inject into the pat sequence
process.customizeTauSequence.insert(0, process.selectedPatTaus)
process.patDefaultSequence.replace(process.selectedPatTaus,
process.customizeTauSequence)
process.cleanPatTaus.src = final_tau_collection
# Remove muons and electrons
process.cleanPatTaus.checkOverlaps.muons.requireNoOverlaps = False
process.cleanPatTaus.checkOverlaps.electrons.requireNoOverlaps = False
# Apply a loose preselection
process.cleanPatTaus.preselection = 'abs(eta) < 2.5 & pt > 17'
# Don't apply any "final" cut
process.cleanPatTaus.finalCut = ''
# Setup pat::Photon Production
process.load("FinalStateAnalysis.PatTools.patPhotonProduction_cff")
final_photon_collection = chain_sequence(process.customizePhotonSequence,
"selectedPatPhotons")
#inject photons into pat sequence
process.customizePhotonSequence.insert(0,process.selectedPatPhotons)
process.patDefaultSequence.replace(process.selectedPatPhotons,
process.customizePhotonSequence)
process.cleanPatPhotons.src = final_photon_collection
# Setup MET production
process.load("FinalStateAnalysis.PatTools.patMETProduction_cff")
final_met_collection = chain_sequence(
process.customizeMETSequence, "patMETsPF")
process.tuplize += process.customizeMETSequence
# The MET systematics depend on all other systematics
process.systematicsMET.tauSrc = cms.InputTag("cleanPatTaus")
process.systematicsMET.muonSrc = cms.InputTag("cleanPatMuons")
process.systematicsMET.electronSrc = cms.InputTag("cleanPatElectrons")
# Keep all the data formats needed for the systematics
output_commands.append('recoLeafCandidates_*_*_%s'
% process.name_())
# Define the default lepton cleaning
process.cleanPatElectrons.preselection = cms.string('pt > 5')
process.cleanPatElectrons.checkOverlaps.muons.requireNoOverlaps = False
# Make sure we don't kill any good taus by calling them electrons
# Note that we don't actually remove these overlaps.
process.cleanPatElectrons.checkOverlaps.taus = cms.PSet(
src = final_tau_collection,
algorithm = cms.string("byDeltaR"),
preselection = cms.string(
"tauID('decayModeFinding') > 0.5 &&"
"tauID('byLooseCombinedIsolationDeltaBetaCorr') > 0.5 &&"
"tauID('againstElectronLoose') > 0.5 && "
"pt > 10"
),
deltaR = cms.double(0.1),
checkRecoComponents = cms.bool(False),
pairCut = cms.string(""),
requireNoOverlaps = cms.bool(False),
)
output_commands.append('*_cleanPatTaus_*_*')
output_commands.append('*_cleanPatElectrons_*_*')
output_commands.append('*_cleanPatMuons_*_*')
output_commands.append('*_cleanPatPhotons_*_*')
output_commands.append('*_%s_*_*' % final_met_collection.value())
trigtools.switchOnTrigger(process)
# Now build the PATFinalStateLS object, which holds LumiSection info.
process.load(
"FinalStateAnalysis.PatTools.finalStates.patFinalStateLSProducer_cfi")
process.tuplize += process.finalStateLS
output_commands.append('*_finalStateLS_*_*')
if isMC:
process.finalStateLS.xSec = kwargs['xSec']
# Tell the framework to shut up!
process.load("FWCore.MessageLogger.MessageLogger_cfi")
process.MessageLogger.cerr.FwkReport.reportEvery = 1000
# Which collections are used to build the final states
fs_daughter_inputs = {
'electrons' : 'cleanPatElectrons',
'muons' : 'cleanPatMuons',
'taus' : 'cleanPatTaus',
'photons' : 'cleanPatPhotons',
'jets' : 'selectedPatJets',
'met' : final_met_collection,
}
# Setup all the PATFinalState objects
produce_final_states(process, fs_daughter_inputs, output_commands,
process.tuplize, kwargs['puTag'])
return process.tuplize, output_commands
process.goodDataAll = cms.Path(process.hltPhysicsDeclared * process.primaryVertexFilter * process.noscraping)
# Add MET and jets. Configuration to be revisited later.
from PhysicsTools.PatAlgos.tools.metTools import addPfMET, addTcMET
addPfMET(process)
addTcMET(process)
from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection
switchJetCollection(
process,
cms.InputTag("ak5PFJets"),
doJTA=True,
doBTagging=True,
jetCorrLabel=("AK5PF", ["L1FastJet", "L2Relative", "L3Absolute"]),
doType1MET=False,
genJetCollection=cms.InputTag("ak5GenJets"),
doJetID=False,
jetIdLabel="ak5",
)
# Make a collection of muons with our final selection applied so that
# the muon-jet cleaning will use only muons passing those cuts. This
# muon collection is not saved in the output.
from SUSYBSMAnalysis.Zprime2muAnalysis.OurSelectionDec2012_cff import loose_cut
process.muonsForJetCleaning = process.selectedPatMuons.clone(cut=loose_cut.replace("pt > 45", "pt > 30"))
process.patDefaultSequence.replace(process.selectedPatMuons, process.selectedPatMuons * process.muonsForJetCleaning)
process.cleanPatJets.checkOverlaps.muons.src = "muonsForJetCleaning"
process.cleanPatJets.checkOverlaps.muons.deltaR = 0.2
pvSource = 'offlinePrimaryVertices'
svSource = cms.InputTag('inclusiveSecondaryVertices')
else:
jetSource = 'ak4PFJetsCHS'
trackSource = 'unpackedTracksAndVertices'
pvSource = 'unpackedTracksAndVertices'
svSource = cms.InputTag('unpackedTracksAndVertices', 'secondary')
from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection
## Switch the default jet collection (done in order to use the above specified b-tag infos and discriminators)
switchJetCollection(process,
jetSource=cms.InputTag(jetSource),
trackSource=cms.InputTag(trackSource),
pvSource=cms.InputTag(pvSource),
svSource=svSource,
btagInfos=bTagInfos,
btagDiscriminators=bTagDiscriminators,
jetCorrections=jetCorr,
genJetCollection=cms.InputTag(genJetCollection),
postfix=pfpostfix)
getattr(process, 'patJetPartons' +
pfpostfix).particles = cms.InputTag(genParticleCollection)
getattr(process, 'patJetPartonMatch' +
pfpostfix).matched = cms.InputTag(genParticleCollection)
getattr(process, 'patJetCorrFactors' +
pfpostfix).primaryVertices = cms.InputTag(pvSource)
## agrohsje following lines needed ?
process.inclusiveVertexFinder.tracks = cms.InputTag(trackSource)
process.trackVertexArbitrator.tracks = cms.InputTag(trackSource)
def setup_jets(process, cms, options, postfix="PFlow"):
print "=" * 60
print "Setting up Jets"
print "=" * 60
# MC setup
inputJetCorrLabel = ("AK5PFchs", ["L1FastJet", "L2Relative", "L3Absolute"])
caloJetCorrection = ("AK5Calo", ["L1Offset", "L2Relative", "L3Absolute"])
if options.useData: # data set up
inputJetCorrLabel = ("AK5PFchs", ["L1FastJet", "L2Relative", "L3Absolute", "L2L3Residual"])
caloJetCorrection = ("AK5Calo", ["L1Offset", "L2Relative", "L3Absolute", "L2L3Residual"])
print "Using jet energy corrections: "
print "Calo Jets"
print caloJetCorrection
print "PF Jets"
print inputJetCorrLabel
if options.CMSSW == "44X":
process.patJetCorrFactorsPFlow.payload = inputJetCorrLabel[0]
process.patJetCorrFactorsPFlow.levels = inputJetCorrLabel[1]
process.patJetCorrFactorsPFlow.rho = cms.InputTag("kt6PFJets", "rho")
###############################
#### Jet RECO includes ########
###############################
from RecoJets.JetProducers.SubJetParameters_cfi import SubJetParameters
###############################
#### Calo Jet Setup ########
###############################
# this has to run after PF2PAT and before removeMCMatching
# see https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookPAT38xChanges#Details_with_PF2PAT
from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection, addJetCollection
# print 'adding calo jets'
switchJetCollection(
process,
jetCollection=cms.InputTag("ak5CaloJets"),
jetCorrLabel=caloJetCorrection,
doBTagging=True,
doType1MET=False,
)
###############################
###### Bare KT 0.6 jets #######
###############################
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets
process.kt6PFJets = kt4PFJets.clone(
rParam=cms.double(0.6), doAreaFastjet=cms.bool(True), doRhoFastjet=cms.bool(True)
)
process.kt6PFJetsPFlow = kt4PFJets.clone(
rParam=cms.double(0.6),
src=cms.InputTag("pfNoElectron" + postfix),
doAreaFastjet=cms.bool(True),
doRhoFastjet=cms.bool(True),
)
process.kt4PFJetsPFlow = kt4PFJets.clone(
rParam=cms.double(0.4),
src=cms.InputTag("pfNoElectron" + postfix),
doAreaFastjet=cms.bool(True),
doRhoFastjet=cms.bool(True),
)
###############################
### TagInfo and Matching Setup#
###############################
# Do some configuration of the jet substructure things
for jetcoll in [process.patJetsPFlow]:
if options.useData == False:
jetcoll.embedGenJetMatch = True
jetcoll.getJetMCFlavour = True
jetcoll.addGenPartonMatch = True
# Add CATopTag info... piggy-backing on b-tag functionality
jetcoll.addBTagInfo = True
jetcoll.embedCaloTowers = True
jetcoll.embedPFCandidates = True
additionalJets = [
getattr(process, "kt6PFJets"),
getattr(process, "kt6PFJets" + postfix),
getattr(process, "kt4PFJets" + postfix),
]
pfNoElectron = getattr(process, "pfNoElectron" + postfix)
for module in additionalJets:
getattr(process, "patPF2PATSequence" + postfix).replace(pfNoElectron, pfNoElectron * module)
# comment-out to take new HPS + TaNC combined tau id. algorithm
#tauTools.switchToPFTauHPSpTaNC(process)
# disable preselection on of pat::Taus
# (disabled also in TauAnalysis/RecoTools/python/patPFTauConfig_cfi.py ,
# but re-enabled after switching tau collection)
process.cleanPatTaus.preselection = cms.string('')
#--------------------------------------------------------------------------------
#--------------------------------------------------------------------------------
# import utility function for managing pat::Jets
import PhysicsTools.PatAlgos.tools.jetTools as jetTools
# uncomment to replace caloJets by pfJets
jetTools.switchJetCollection(process, jetCollection = cms.InputTag("ak5PFJets"),
doBTagging = True, outputModule = '')
#--------------------------------------------------------------------------------
#--------------------------------------------------------------------------------
# import utility function for managing pat::METs
import TauAnalysis.Configuration.tools.metTools as metTools
# uncomment to add pfMET
# set Boolean swich to true in order to apply type-1 corrections
metTools.addPFMet(process, correct = False)
# uncomment to replace caloMET by pfMET in all di-tau objects
process.load("TauAnalysis.CandidateTools.diTauPairProductionAllKinds_cff")
metTools.replaceMETforDiTaus(process, cms.InputTag('patMETs'), cms.InputTag('patPFMETs'))
#--------------------------------------------------------------------------------
def configurePatTuple(process, isMC=True, **kwargs):
# Stuff we always keep
output_commands = [
'*_addPileupInfo_*_*',
'edmMergeableCounter_*_*_*',
'*_lumiProducer_*_*',
'*_particleFlow_*_*',
'*_offlineBeamSpot_*_*',
'*_generalTracks_*_*',
'*_electronGsfTracks_*_*',
'*_gsfElectrons_*_*',
'*_gsfElectronCores_*_*',
'*_offlinePrimaryVertices*_*_*',
'*_ak5GenJets_*_*',
'*_hltTriggerSummaryAOD_*_*',
'edmTriggerResults_TriggerResults_*_%s' % process.name_(),
'*_MEtoEDMConverter*_*_%s' % process.name_(),
'LHEEventProduct_*_*_*',
'GenEventInfoProduct_generator_*_*',
'*_kt6PFJetsForRhoComputationVoronoi_rho_*',
'*_kt6PFJetsForIso_rho_*',
'*_kt6PFJets_rho_*',
'*_kt6PFJetsHZGPho_rho_*',
'*_kt6PFJetsCentralHZGEle_rho_*',
'*_kt6PFJetsCentralHZGMu_rho_*',
'*_kt6PFJetsCentralNeutralHZGMu_rho_*',
'*_kt6PFJetsCentral_rho_*',
'*_kt6PFJetsCentralNeutral_rho_*', # for zz muons
'*_photonCore_*_*',
'*_boostedFsrPhotons_*_*',
# for Zmumu -> embedded samples
# https://twiki.cern.ch/twiki/bin/view/CMS/MuonTauReplacementRecHit
'*_generalTracksORG_*_EmbeddedRECO',
'*_electronGsfTracksORG_*_EmbeddedRECO',
'double_TauSpinnerReco_TauSpinnerWT_EmbeddedSPIN',
'double_ZmumuEvtSelEffCorrWeightProducer_weight_EmbeddedRECO',
'double_muonRadiationCorrWeightProducer_weight_EmbeddedRECO',
'GenFilterInfo_generator_minVisPtFilter_EmbeddedRECO',
]
# Define our patTuple production sequence
process.tuplize = cms.Sequence()
# Only keep interesting genParticles
process.load("FinalStateAnalysis.RecoTools.genParticleTrimmer_cfi")
process.genParticles = process.prunedGenParticles.clone()
if isMC:
#process.tuplize += process.genParticles
#output_commands.append('*_genParticles_*_%s' % process.name_())
output_commands.append('*_genParticles_*_*')
output_commands.append('*_tauGenJetsSelectorAllHadrons_*_*')
output_commands.append('*_tauGenJets_*_*')
output_commands.append('*_ak5GenJets_*_*')
# Select vertices
process.load("FinalStateAnalysis.RecoTools.vertexSelection_cff")
output_commands.append('*_selectedPrimaryVertex*_*_*')
output_commands.append('*_selectPrimaryVerticesQuality*_*_*')
process.tuplize += process.selectPrimaryVertices
# Run the ZZ recipe for rho
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets \
as zzCantDoAnythingRight
process.kt6PFJetsForIso = zzCantDoAnythingRight.clone(
rParam=cms.double(0.6),
doAreaFastjet=cms.bool(True),
doRhoFastjet=cms.bool(True),
Rho_EtaMax=cms.double(2.5),
Ghost_EtaMax=cms.double(2.5),
)
process.tuplize += process.kt6PFJetsForIso
# Standard services
process.load('Configuration.StandardSequences.Services_cff')
# tack on seeds for FSA PATTuple modules
add_fsa_random_seeds(process)
if cmssw_major_version() == 5 and cmssw_minor_version() >= 3:
process.load('Configuration.Geometry.GeometryDB_cff')
else:
process.load('Configuration.StandardSequences.GeometryDB_cff')
process.load('Configuration.StandardSequences.MagneticField_cff')
process.load(
'Configuration.StandardSequences.FrontierConditions_GlobalTag_cff')
# Rerun tau ID
process.load("RecoTauTag.Configuration.RecoPFTauTag_cff")
# Optimization - remove PFTauTagInfo compatibility layer
process.recoTauClassicHPSSequence.remove(
process.pfRecoTauTagInfoProducer)
process.recoTauClassicHPSSequence.remove(
process.ak5PFJetTracksAssociatorAtVertex)
assert(process.combinatoricRecoTaus.modifiers[3].name.value() ==
'TTIworkaround')
del process.combinatoricRecoTaus.modifiers[3]
# Don't build junky taus below 19 GeV
process.combinatoricRecoTaus.builders[0].minPtToBuild = cms.double(17)
process.tuplize += process.recoTauClassicHPSSequence
## Run rho computation. Only necessary in 42X
if cmssw_major_version() == 4:
# This function call can klobber everything if it isn't done
# before the other things are attached to the process, so do it now.
# The klobbering would occur through usePFIso->setupPFIso->_loadPFBRECO
from CommonTools.ParticleFlow.Tools.pfIsolation import _loadPFBRECO
_loadPFBRECO(process)
process.load("RecoJets.Configuration.RecoPFJets_cff")
process.kt6PFJets.Rho_EtaMax = cms.double(4.4)
process.kt6PFJets.doRhoFastjet = True
process.tuplize += process.kt6PFJets
# In 4_X we have to rerun ak5PFJets with area computation enabled.
if cmssw_major_version() == 4:
process.load("RecoJets.Configuration.RecoPFJets_cff")
process.ak5PFJets.doAreaFastjet = True
process.tuplize += process.ak5PFJets
# Only keep the new ak5PFJets
output_commands.append('*_ak5PFJets_*_%s' % process.name_())
else:
# Just keep the normal ones
output_commands.append('*_ak5PFJets_*_*')
# Run pat default sequence
process.load("PhysicsTools.PatAlgos.patSequences_cff")
# Embed PF Isolation in electrons & muons
pfTools.usePFIso(process)
# Setup H2Tau custom iso definitions
setup_h2tau_iso(process)
# Setup hZg custom iso definitions
add_hZg_iso_needs(process)
#alter the photon matching to accept various fakes
# and sort matches by d-pt-rel
if isMC:
process.photonMatch = cms.EDProducer(
"MCMatcherByPt",
src=cms.InputTag("photons"),
maxDPtRel=cms.double(100.0),
mcPdgId=cms.vint32(),
mcStatus=cms.vint32(1),
resolveByMatchQuality=cms.bool(False),
maxDeltaR=cms.double(0.3),
checkCharge=cms.bool(False),
resolveAmbiguities=cms.bool(True),
matched=cms.InputTag("genParticles")
)
# Use POG recommendations for (these) electron Isos
process.elPFIsoValueGamma04PFIdPFIso.deposits[0].vetos = cms.vstring(
'EcalEndcaps:ConeVeto(0.08)')
process.elPFIsoValueGamma04NoPFIdPFIso.deposits[0].vetos = cms.vstring(
'EcalEndcaps:ConeVeto(0.08)')
process.elPFIsoValueCharged04PFIdPFIso.deposits[0].vetos = cms.vstring(
'EcalEndcaps:ConeVeto(0.015)')
process.elPFIsoValueCharged04NoPFIdPFIso.deposits[0].vetos = cms.vstring(
'EcalEndcaps:ConeVeto(0.015)')
# Unembed junk
process.patMuons.embedCaloMETMuonCorrs = False
process.patMuons.embedTcMETMuonCorrs = False
process.patMuons.embedTrack = True
process.patMuons.pvSrc = cms.InputTag("selectedPrimaryVertex")
# Do extra electron ID
process.load("FinalStateAnalysis.PatTools.electrons.electronID_cff")
if cmssw_major_version() == 4:
process.patDefaultSequence.replace(process.patElectrons,
process.recoElectronID42X +
process.patElectrons)
process.patElectrons.electronIDSources = process.electronIDSources42X
else:
process.patDefaultSequence.replace(process.patElectrons,
process.recoElectronID5YX +
process.patElectrons)
process.patElectrons.electronIDSources = process.electronIDSources5YX
process.electronMatch.checkCharge = cms.bool(False)
process.patElectrons.embedTrack = False
process.patElectrons.embedPFCandidate = False
process.patElectrons.embedGsfElectronCore = False
process.patElectrons.embedSuperCluster = True
# Now run PAT
process.tuplize += process.patDefaultSequence
# Add FSR photons for ZZ analysis
process.load("FinalStateAnalysis.PatTools.fsrPhotons_cff")
process.tuplize += process.fsrPhotonSequence
# Use HPS taus
tautools.switchToPFTauHPS(process)
# Disable tau IsoDeposits
process.patDefaultSequence.remove(process.patPFTauIsolation)
process.patTaus.isoDeposits = cms.PSet()
process.patTaus.userIsolation = cms.PSet()
# Disable gen match embedding - we keep it in the ntuple
process.patMuons.embedGenMatch = False
process.patElectrons.embedGenMatch = False
process.patTaus.embedGenMatch = False
process.patTaus.embedGenJetMatch = False
process.patPhotons.embedGenMatch = False
# Use PFJets and turn on JEC
jec = ['L1FastJet', 'L2Relative', 'L3Absolute']
# If we are running on data (not MC), or embedded sample,
# apply the MC-DATA residual correction.
if not isMC or kwargs['embedded']:
jec.extend(['L2L3Residual'])
# Define options for BTagging - these are release dependent.
btag_options = {'doBTagging': True}
if cmssw_major_version() == 5:
btag_options['btagInfo'] = [
'impactParameterTagInfos',
'secondaryVertexTagInfos',
'softMuonTagInfos',
'secondaryVertexNegativeTagInfos'
]
btag_options['btagdiscriminators'] = [
'trackCountingHighEffBJetTags',
'simpleSecondaryVertexHighEffBJetTags',
'combinedSecondaryVertexMVABJetTags',
'combinedSecondaryVertexBJetTags',
]
# Use AK5 PFJets
jettools.switchJetCollection(
process,
cms.InputTag('ak5PFJets'),
doJTA=False,
jetCorrLabel=('AK5PF', jec),
#jetCorrLabel = None,
doType1MET=False,
doJetID=True,
genJetCollection=cms.InputTag("ak5GenJets"),
**btag_options
)
process.patJets.embedPFCandidates = False
process.patJets.embedCaloTowers = False
process.patJets.embedGenJetMatch = False
process.patJets.addAssociatedTracks = False
process.patJets.embedGenPartonMatch = False
#process.patJetCorrFactors.useRho = True
## Let's use the same rho as in the TauID, so we don't need to do it twice.
#process.patJetCorrFactors.rho = cms.InputTag(
#"kt6PFJetsForRhoComputationVoronoi", "rho")
# Use PFMEt
mettools.addPfMET(process)
if not isMC:
coreTools.runOnData(process)
process.patMETsPF.addGenMET = False
output_commands.append('*_selectedPatJets_*_*')
# Customize/embed all our sequences
process.load("FinalStateAnalysis.PatTools.patJetProduction_cff")
process.patJetGarbageRemoval.cut = 'pt > 12'
final_jet_collection = chain_sequence(
process.customizeJetSequence, "patJets")
process.customizeJetSequence.insert(0, process.patJets)
# Make it a "complete" sequence
process.customizeJetSequence += process.selectedPatJets
# We can't mess up the selected pat jets because the taus use them.
process.selectedPatJets.src = final_jet_collection
process.patDefaultSequence.replace(process.patJets,
process.customizeJetSequence)
# Produce the electron collections
process.load("FinalStateAnalysis.PatTools.patElectronProduction_cff")
# Electron Energy Regression and Calibrations
process.load(
"EgammaAnalysis.ElectronTools.electronRegressionEnergyProducer_cfi")
process.load("EgammaAnalysis.ElectronTools.calibratedPatElectrons_cfi")
#setup the energy regression for the specific dataset
if kwargs['eleReg']:
print "-- Applying Electron Regression and Calibration --"
process.customizeElectronSequence += process.eleRegressionEnergy
process.customizeElectronSequence += process.calibratedPatElectrons
process.eleRegressionEnergy.energyRegressionType = cms.uint32(2)
process.calibratedPatElectrons.correctionsType = cms.int32(2)
if isMC:
process.calibratedPatElectrons.inputDataset = cms.string(
"Summer12_LegacyPaper")
else:
process.calibratedPatElectrons.inputDataset = cms.string(
"22Jan2013ReReco")
process.calibratedPatElectrons.combinationType = cms.int32(3)
process.calibratedPatElectrons.lumiRatio = cms.double(1.0)
process.calibratedPatElectrons.synchronization = cms.bool(True)
process.calibratedPatElectrons.isMC = cms.bool(isMC == 1)
process.calibratedPatElectrons.verbose = cms.bool(False)
final_electron_collection = chain_sequence(
process.customizeElectronSequence, "selectedPatElectrons",
# Some of the EGamma modules have non-standard src InputTags,
# specify them here.
("src", "inputPatElectronsTag", "inputElectronsTag")
)
process.tuplize += process.customizeElectronSequence
process.customizeElectronSequence.insert(0, process.selectedPatElectrons)
process.patDefaultSequence.replace(process.selectedPatElectrons,
process.customizeElectronSequence)
# We have to do the pat Jets before the pat electrons since we embed them
process.customizeElectronSequence.insert(0, process.selectedPatJets)
# Define cleanPatElectrons input collection
process.cleanPatElectrons.src = final_electron_collection
process.load("FinalStateAnalysis.PatTools.patMuonProduction_cff")
final_muon_collection = chain_sequence(
process.customizeMuonSequence, "selectedPatMuons")
process.customizeMuonSequence.insert(0, process.selectedPatMuons)
process.patDefaultSequence.replace(process.selectedPatMuons,
process.customizeMuonSequence)
process.cleanPatMuons.src = final_muon_collection
process.patMuonRochesterCorrectionEmbedder.isMC = cms.bool(bool(isMC))
process.load("FinalStateAnalysis.PatTools.patTauProduction_cff")
# Require all taus to pass decay mode finding and have high PT
process.patTauGarbageRemoval.cut = cms.string(
"pt > 17 && abs(eta) < 2.5 && tauID('decayModeFinding')")
final_tau_collection = chain_sequence(
process.customizeTauSequence, "selectedPatTaus")
# Inject into the pat sequence
process.customizeTauSequence.insert(0, process.selectedPatTaus)
process.patDefaultSequence.replace(process.selectedPatTaus,
process.customizeTauSequence)
process.cleanPatTaus.src = final_tau_collection
# Remove muons and electrons
process.cleanPatTaus.checkOverlaps.muons.requireNoOverlaps = False
process.cleanPatTaus.checkOverlaps.electrons.requireNoOverlaps = False
# Cuts already applied by the garbage removal
process.cleanPatTaus.preselection = ''
process.cleanPatTaus.finalCut = ''
# Setup pat::Photon Production
process.load("FinalStateAnalysis.PatTools.patPhotonProduction_cff")
final_photon_collection = chain_sequence(process.customizePhotonSequence,
"selectedPatPhotons")
#setup PHOSPHOR for a specific dataset
if cmssw_major_version() == 4: # for now 2011 = CMSSW42X
process.patPhotonPHOSPHOREmbedder.year = cms.uint32(2011)
else: # 2012 is 5YX
process.patPhotonPHOSPHOREmbedder.year = cms.uint32(2012)
process.patPhotonPHOSPHOREmbedder.isMC = cms.bool(bool(isMC))
#inject photons into pat sequence
process.customizePhotonSequence.insert(0, process.selectedPatPhotons)
process.patDefaultSequence.replace(process.selectedPatPhotons,
process.customizePhotonSequence)
process.cleanPatPhotons.src = final_photon_collection
# We cut out a lot of the junky taus and jets - but we need these
# to correctly apply the MET uncertainties. So, let's make a
# non-cleaned version of the jet and tau sequence.
process.jetsForMetSyst = helpers.cloneProcessingSnippet(
process, process.customizeJetSequence, 'ForMETSyst')
process.tausForMetSyst = helpers.cloneProcessingSnippet(
process, process.customizeTauSequence, 'ForMETSyst')
# Don't apply any cut for these
process.patTauGarbageRemovalForMETSyst.cut = ''
process.patJetGarbageRemovalForMETSyst.cut = ''
process.tuplize += process.jetsForMetSyst
process.tuplize += process.tausForMetSyst
# We have to make our clone of cleanPatTaus separately, since e/mu
# cleaning is applied - therefore it isn't in the customizeTausSequence.
process.cleanPatTausForMETSyst = process.cleanPatTaus.clone(
src=cms.InputTag(process.cleanPatTaus.src.value() + "ForMETSyst"))
process.cleanPatTausForMETSyst.preselection = ''
process.cleanPatTausForMETSyst.finalCut = ''
process.patTausEmbedJetInfoForMETSyst.jetSrc = \
final_jet_collection.value() + "ForMETSyst"
process.tuplize += process.cleanPatTausForMETSyst
# Setup MET production
process.load("FinalStateAnalysis.PatTools.patMETProduction_cff")
# The MET systematics depend on all other systematics
process.systematicsMET.tauSrc = cms.InputTag("cleanPatTausForMETSyst")
process.systematicsMET.muonSrc = cms.InputTag("cleanPatMuons")
process.systematicsMET.electronSrc = cms.InputTag("cleanPatElectrons")
final_met_collection = chain_sequence(
process.customizeMETSequence, "patMETsPF")
process.tuplize += process.customizeMETSequence
output_commands.append('*_%s_*_*' % final_met_collection.value())
# Make a version with the MVA MET reconstruction method
process.load("FinalStateAnalysis.PatTools.met.mvaMetOnPatTuple_cff")
process.tuplize += process.pfMEtMVAsequence
mva_met_sequence = helpers.cloneProcessingSnippet(
process, process.customizeMETSequence, "MVA")
final_mvamet_collection = chain_sequence(
mva_met_sequence, "patMEtMVA")
process.tuplize += mva_met_sequence
output_commands.append('*_%s_*_*' % final_mvamet_collection.value())
# Keep all the data formats needed for the systematics
output_commands.append('recoLeafCandidates_*_*_%s'
% process.name_())
# We can drop to jet and tau MET specific products. They were only used for
# computation of the MET numbers.
output_commands.append('drop recoLeafCandidates_*ForMETSyst_*_%s'
% process.name_())
# Define the default lepton cleaning
process.cleanPatElectrons.preselection = cms.string(
'pt > 5')
process.cleanPatElectrons.checkOverlaps.muons.requireNoOverlaps = False
# Make sure we don't kill any good taus by calling them electrons
# Note that we don't actually remove these overlaps.
process.cleanPatElectrons.checkOverlaps.taus = cms.PSet(
src=final_tau_collection,
algorithm=cms.string("byDeltaR"),
preselection=cms.string(
"tauID('decayModeFinding') > 0.5 &&"
"tauID('byLooseCombinedIsolationDeltaBetaCorr') > 0.5 &&"
"tauID('againstElectronLoose') > 0.5 && "
"pt > 10"
),
deltaR=cms.double(0.1),
checkRecoComponents=cms.bool(False),
pairCut=cms.string(""),
requireNoOverlaps=cms.bool(False),
)
output_commands.append('*_cleanPatTaus_*_*')
output_commands.append('*_cleanPatElectrons_*_*')
output_commands.append('*_cleanPatMuons_*_*')
output_commands.append('*_cleanPatPhotons_*_*')
trigtools.switchOnTrigger(process)
#configure the PAT trigger
if kwargs['HLTprocess']:
process.patTrigger.processName = cms.string(kwargs['HLTprocess'])
process.patTriggerEvent.processName = cms.string(kwargs['HLTprocess'])
# Now build the PATFinalStateLS object, which holds LumiSection info.
process.load(
"FinalStateAnalysis.PatTools.finalStates.patFinalStateLSProducer_cfi")
process.tuplize += process.finalStateLS
output_commands.append('*_finalStateLS_*_*')
if isMC:
process.finalStateLS.xSec = kwargs['xSec']
# Tell the framework to shut up!
process.load("FWCore.MessageLogger.MessageLogger_cfi")
process.MessageLogger.cerr.FwkReport.reportEvery = 1000
# Which collections are used to build the final states
fs_daughter_inputs = {
'electrons': 'cleanPatElectrons',
'muons': 'cleanPatMuons',
'taus': 'cleanPatTaus',
'photons': 'cleanPatPhotons',
'jets': 'selectedPatJets',
'pfmet': final_met_collection,
'mvamet': final_mvamet_collection,
}
# Setup all the PATFinalState objects
produce_final_states(process, fs_daughter_inputs, output_commands,
process.tuplize, kwargs['puTag'],
zzMode=kwargs.get('zzMode', False))
return process.tuplize, output_commands
'L1',
doJTA=True,
doBTagging=True,
jetCorrLabel=('AK5PF',
cms.vstring(['L2Relative', 'L3Absolute', 'L2L3Residual'])),
doL1Cleaning=True,
doL1Counters=True,
doType1MET=True,
doJetID=True)
from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection
switchJetCollection(
process,
cms.InputTag('ak5PFJets'),
doJTA=True,
doBTagging=True,
jetCorrLabel=('AK5PF',
cms.vstring(['L2Relative', 'L3Absolute', 'L2L3Residual'])),
doType1MET=True,
doJetID=True)
from PhysicsTools.PatAlgos.tools.trigTools import *
switchOnTrigger(process)
process.load("ElectroWeakAnalysis.WENu.simpleEleIdSequence_cff")
process.patElectrons.addElectronID = cms.bool(True)
process.patElectrons.electronIDSources = cms.PSet(
simpleEleId95relIso=cms.InputTag("simpleEleId95relIso"),
simpleEleId90relIso=cms.InputTag("simpleEleId90relIso"),
simpleEleId85relIso=cms.InputTag("simpleEleId85relIso"),
addJetCollection(
process,
labelName = 'AK8PFCHS',
jetSource = cms.InputTag('ak8PFJetsCHS'),
algo = 'ak8',
rParam = 0.8,
jetCorrections = ('AK7PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None')
)
switchJetCollection(
process,
jetSource = cms.InputTag('ak4PFJets'),
rParam = 0.4,
jetCorrections = ('AK5PF', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'Type-1'),
btagDiscriminators = ['jetBProbabilityBJetTags',
'jetProbabilityBJetTags',
'trackCountingHighPurBJetTags',
'trackCountingHighEffBJetTags',
'simpleSecondaryVertexHighEffBJetTags',
'simpleSecondaryVertexHighPurBJetTags',
'combinedSecondaryVertexBJetTags'
],
)
#process.patJetGenJetMatchCA8PFCHS.matched = cms.InputTag("ca8GenJetsNoNu")
patJetsAK4 = process.patJetsAK4PFCHS
patJetsCA8 = process.patJetsCA8PFCHS
patJetsAK8 = process.patJetsAK8PFCHS
process.out.outputCommands += ['keep *_ak4PFJetsCHS_*_*',
'keep *_patJetsAK4PFCHS_*_*',
genJetCollection = cms.InputTag('ak4GenJets'),
jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None'), # FIXME: Use proper JECs, as soon as available
btagDiscriminators = [
'combinedSecondaryVertexBJetTags'
],
)
process.out.outputCommands.append( 'drop *_selectedPatJets%s_caloTowers_*'%( labelCA8PFCHSPruned ) )
# uncomment the following lines to switch to ak4CaloJets in your PAT output
switchJetCollection(
process,
jetSource = cms.InputTag('ak5CaloJets'),
jetCorrections = ('AK5Calo', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'Type-1'), # FIXME: Use proper JECs, as soon as available
btagDiscriminators = [
'jetBProbabilityBJetTags'
, 'jetProbabilityBJetTags'
, 'trackCountingHighPurBJetTags'
, 'trackCountingHighEffBJetTags'
, 'simpleSecondaryVertexHighEffBJetTags'
, 'simpleSecondaryVertexHighPurBJetTags'
, 'combinedSecondaryVertexBJetTags'
],
)
## JetID works only with RECO input for the CaloTowers (s. below for 'process.source.fileNames')
#process.patJets.addJetID=True
#process.load("RecoJets.JetProducers.ak4JetID_cfi")
#process.patJets.jetIDMap="ak4JetID"
process.patJets.useLegacyJetMCFlavour=True # Need to use legacy flavour since the new flavour requires jet constituents which are dropped for CaloJets from AOD
process.out.outputCommands.append( 'keep *_selectedPatJets_caloTowers_*' )
process.out.outputCommands.append( 'drop *_selectedPatJets_pfCandidates_*' )
#print process.out.outputCommands
rParam = 0.8,
jetCorrections = ('AK8PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None')
)
addJetCollection(
process,
labelName = 'AK8PFCHS',
jetSource = cms.InputTag('ak8PFJetsCHS'),
algo = 'ak8',
rParam = 0.8,
jetCorrections = ('AK8PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None')
)
switchJetCollection(
process,
jetSource = cms.InputTag('ak4PFJets'),
rParam = 0.4,
jetCorrections = ('AK4PF', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'Type-1'),
)
#process.patJetGenJetMatchCA8PFCHS.matched = cms.InputTag("ca8GenJetsNoNu")
patJetsAK4 = process.patJetsAK4PFCHS
patJetsCA8 = process.patJetsCA8PFCHS
patJetsAK8 = process.patJetsAK8PFCHS
process.out.outputCommands += ['keep *_ak4PFJetsCHS_*_*',
'keep *_patJetsAK4PFCHS_*_*',
'keep *_ca8PFJetsCHS_*_*',
'keep *_patJetsCA8PFCHS_*_*',
'keep *_ak8PFJetsCHS_*_*',
'keep *_patJetsAK8PFCHS_*_*']
process.goodDataHLTPhysicsDeclared = cms.Path(process.hltPhysicsDeclared)
process.goodDataPrimaryVertexFilter = cms.Path(process.primaryVertexFilter)
process.goodDataNoScraping = cms.Path(process.noscraping)
process.goodDataAll = cms.Path(process.hltPhysicsDeclared * process.primaryVertexFilter * process.noscraping)
# Add MET and jets. Configuration to be revisited later.
from PhysicsTools.PatAlgos.tools.metTools import addPfMET, addTcMET
addPfMET(process)
addTcMET(process)
from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection
switchJetCollection(process,
cms.InputTag('ak5PFJets'),
doJTA = True,
doBTagging = True,
jetCorrLabel = ('AK5PF', ['L1FastJet', 'L2Relative', 'L3Absolute']),
doType1MET = False,
genJetCollection = cms.InputTag("ak5GenJets"),
doJetID = False,
jetIdLabel = "ak5"
)
# Make a collection of muons with our final selection applied so that
# the muon-jet cleaning will use only muons passing those cuts. This
# muon collection is not saved in the output.
from SUSYBSMAnalysis.Zprime2muAnalysis.OurSelectionDec2012_cff import loose_cut
process.muonsForJetCleaning = process.selectedPatMuons.clone(cut = loose_cut.replace('pt > 45', 'pt > 30'))
process.patDefaultSequence.replace(process.selectedPatMuons, process.selectedPatMuons * process.muonsForJetCleaning)
process.cleanPatJets.checkOverlaps.muons.src = 'muonsForJetCleaning'
process.cleanPatJets.checkOverlaps.muons.deltaR = 0.2
process.cleanPatJets.checkOverlaps.muons.requireNoOverlaps = True
process.cleanPatJets.finalCut = 'pt > 30.0'
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 addInvHiggsProcess(process, iRunOnData=True, iData="PromptC2", iHLTFilter="MET", iMCSignal=False, iFile='/store/data/Run2012C/MET/AOD/PromptReco-v2/000/203/002/04BCEC26-AA02-E211-A81D-003048CF99BA.root', iMaxEvent=100):
###--------------------------------------------------------------
### Load PAT, because it insists on defining the process for you
#from PhysicsTools.PatAlgos.patTemplate_cfg import *
###--------------------------------------------------------------
###--------------------------------------------------------------
### Input
process.maxEvents.input = iMaxEvent
process.source.fileNames = [iFile]
###--------------------------------------------------------------
###--------------------------------------------------------------
### GlobalTag
if iRunOnData == True:
if (iData.find("Jul13")==0):
process.GlobalTag.globaltag = "FT_53_V6C_AN3::All"
elif (iData.find("Aug06")==0):
process.GlobalTag.globaltag = "FT_53_V6C_AN3::All"
elif (iData.find("Aug24")==0):
process.GlobalTag.globaltag = "FT53_V10A_AN3::All"
elif (iData.find("PromptC2")==0):
process.GlobalTag.globaltag = "GR_P_V42_AN3::All"
elif (iData.find("PromptD")==0):
process.GlobalTag.globaltag = "GR_P_V42_AN3::All"
elif (iData.find("Dec11")==0): #Run201191
process.GlobalTag.globaltag = "FT_P_V42C_AN3::All"
else:
process.GlobalTag.globaltag = "GR_P_V42_AN3::All"
else:
process.GlobalTag.globaltag = "START53_V7G::All"
###--------------------------------------------------------------
###--------------------------------------------------------------
### Logger
process.load("FWCore.MessageService.MessageLogger_cfi")
process.load("FWCore.MessageLogger.MessageLogger_cfi")
process.MessageLogger.cerr.FwkReport = cms.untracked.PSet(
reportEvery = cms.untracked.int32(2000),
limit = cms.untracked.int32(10000000)
)
###--------------------------------------------------------------
###--------------------------------------------------------------
### HLT Trigger(s)
# If it's MC signal, no trigger will be applied
if iRunOnData == False and iMCSignal == True:
iHLTFilter = "NoTrig"
# Load hltHighLevel
process.load('HLTrigger.HLTfilters.hltHighLevel_cfi')
process.hltHighLevel.TriggerResultsTag = cms.InputTag("TriggerResults","","HLT")
process.hltHighLevel.throw = cms.bool(False) # Tolerate if triggers not available
process.hltHighLevel.andOr = cms.bool(True) # True = OR, False = AND
if (iHLTFilter.find("MET")==0):
process.hltHighLevel.HLTPaths = cms.vstring(
"HLT_DiPFJet40_PFMETnoMu65_MJJ600VBF_LeadingJets_v*",
"HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v*"
)
elif (iHLTFilter.find("SingleMu")==0):
process.hltHighLevel.HLTPaths = cms.vstring("HLT_IsoMu24_eta2p1_v*","HLT_Mu40_eta2p1_v*")
elif (iHLTFilter.find("DoubleMu")==0):
process.hltHighLevel.HLTPaths = cms.vstring("HLT_Mu17_Mu8_v*")
elif (iHLTFilter.find("SingleElectron")==0):
process.hltHighLevel.HLTPaths = cms.vstring("HLT_Ele27_WP80_v*")
elif (iHLTFilter.find("DoubleElectron")==0):
process.hltHighLevel.HLTPaths = cms.vstring("HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v*")
elif (iHLTFilter.find("NoTrig")==0):
process.hltHighLevel.HLTPaths = cms.vstring("*")
else:
process.hltHighLevel.HLTPaths = cms.vstring(
"HLT_DiPFJet40_PFMETnoMu65_MJJ600VBF_LeadingJets_v*",
"HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v*"
)
###--------------------------------------------------------------
###--------------------------------------------------------------
print "-----------------------------------------------"
print "INVISIBLE HIGGS: Ntuple V10"
print "-----------------------------------------------"
print "RunOnData = ", iRunOnData
if iRunOnData == True:
print "Dataset = ", iData
else:
if iMCSignal == True:
print "Dataset = MC Signal"
else:
print "Dataset = MC Background"
print "GlobalTag = ", process.GlobalTag.globaltag
print "Trigger = ", process.hltHighLevel.HLTPaths
print "Sample input file = ", iFile
print "Max events = ", iMaxEvent
print "-----------------------------------------------"
###--------------------------------------------------------------
###--------------------------------------------------------------
### Basic filters
# Track quality filter
process.noscraping = cms.EDFilter(
"FilterOutScraping",
applyfilter = cms.untracked.bool(True),
debugOn = cms.untracked.bool(False),
numtrack = cms.untracked.uint32(10),
thresh = cms.untracked.double(0.25)
)
# Require a good 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)
)
###--------------------------------------------------------------
###--------------------------------------------------------------
### MET Filters
# The iso-based HBHE noise filter
process.load('CommonTools.RecoAlgos.HBHENoiseFilter_cfi')
# The CSC beam halo tight filter
process.load('RecoMET.METAnalyzers.CSCHaloFilter_cfi')
# The HCAL laser filter
process.load("RecoMET.METFilters.hcalLaserEventFilter_cfi")
process.load("EventFilter.HcalRawToDigi.hcallasereventfilter2012_cff")
process.hcallasereventfilter2012.eventFileName = cms.string('HCALLaser2012AllDatasets.txt.gz')
# The ECAL dead cell trigger primitive filter
process.load('RecoMET.METFilters.EcalDeadCellTriggerPrimitiveFilter_cfi')
# The EE bad SuperCrystal filter
process.load('RecoMET.METFilters.eeBadScFilter_cfi')
# The ECAL laser correction filter
process.load('RecoMET.METFilters.ecalLaserCorrFilter_cfi')
# The Good vertices collection needed by the tracking failure filter
process.goodVertices = cms.EDFilter(
"VertexSelector",
filter = cms.bool(False),
src = cms.InputTag("offlinePrimaryVertices"),
cut = cms.string("!isFake && ndof > 4 && abs(z) <= 24 && position.rho < 2")
)
# The tracking failure filter
process.load('RecoMET.METFilters.trackingFailureFilter_cfi')
# The tracking POG filters
process.load('RecoMET.METFilters.trackingPOGFilters_cff')
###--------------------------------------------------------------
###--------------------------------------------------------------
### customise PAT
process.load('JetMETCorrections.Configuration.DefaultJEC_cff')
from PhysicsTools.PatAlgos.tools.coreTools import removeMCMatching,runOnData
if iRunOnData == True:
removeMCMatching(process, ['All'])
runOnData(process)
# Add the PF MET
from PhysicsTools.PatAlgos.tools.metTools import addPfMET
addPfMET(process, 'PF')
# Switch to PF jets
from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection
if iRunOnData == True:
switchJetCollection(process,
cms.InputTag('ak5PFJets'),
doJTA = True,
doBTagging = True,
jetCorrLabel = ('AK5PF', ['L1FastJet', 'L2Relative', 'L3Absolute', 'L2L3Residual']),
doType1MET = True,
doJetID = False,
jetIdLabel = "ak5"
)
else:
switchJetCollection(process,
cms.InputTag('ak5PFJets'),
doJTA = True,
doBTagging = True,
jetCorrLabel = ('AK5PF', ['L1FastJet', 'L2Relative', 'L3Absolute']),
doType1MET = True,
genJetCollection = cms.InputTag("ak5GenJetsNoNu"),
doJetID = False,
jetIdLabel = "ak5"
)
from PhysicsTools.PatAlgos.tools.pfTools import usePFIso
usePFIso(process)
process.patMuons.isoDeposits = cms.PSet()
process.patMuons.isolationValues = cms.PSet()
process.patElectrons.isolationValues = cms.PSet(
pfChargedHadrons = cms.InputTag("elPFIsoValueCharged03PFIdPFIso"),
pfChargedAll = cms.InputTag("elPFIsoValueChargedAll03PFIdPFIso"),
pfPUChargedHadrons = cms.InputTag("elPFIsoValuePU03PFIdPFIso"),
pfNeutralHadrons = cms.InputTag("elPFIsoValueNeutral03PFIdPFIso"),
pfPhotons = cms.InputTag("elPFIsoValueGamma03PFIdPFIso")
)
process.patElectrons.isolationValuesNoPFId = cms.PSet(
pfChargedHadrons = cms.InputTag("elPFIsoValueCharged03NoPFIdPFIso"),
pfChargedAll = cms.InputTag("elPFIsoValueChargedAll03NoPFIdPFIso"),
pfPUChargedHadrons = cms.InputTag("elPFIsoValuePU03NoPFIdPFIso"),
pfNeutralHadrons = cms.InputTag("elPFIsoValueNeutral03NoPFIdPFIso"),
pfPhotons = cms.InputTag("elPFIsoValueGamma03NoPFIdPFIso")
)
process.patDefaultSequence.replace(process.patElectrons,process.eleIsoSequence+process.patElectrons)
process.cleanPatTaus.preselection = cms.string('tauID("decayModeFinding") > 0.5 & tauID("byLooseCombinedIsolationDeltaBetaCorr") > 0.5')
###--------------------------------------------------------------
###--------------------------------------------------------------
### Object (pre) selection
# Jet selection
process.selectedPatJets.cut = cms.string("pt>10. && abs(eta)<5.")
# Remove overlaps ???
# process.cleanPatJets.finalCut = "!hasOverlaps('electrons') && !hasOverlaps('muons')"
# Apply loose PF jet ID
from PhysicsTools.SelectorUtils.pfJetIDSelector_cfi import pfJetIDSelector
process.goodPatJets = cms.EDFilter("PFJetIDSelectionFunctorFilter",
filterParams = pfJetIDSelector.clone(),
src = cms.InputTag("selectedPatJets"),
filter = cms.bool(True)
)
process.selectedPatMuons.cut = cms.string("isGlobalMuon && pt>10. && abs(eta)<2.5")
process.selectedPatElectrons.cut = cms.string("pt>10. && abs(eta)<2.5")
###--------------------------------------------------------------
###--------------------------------------------------------------
### Load the PU JetID sequence
if iRunOnData == True:
process.load("CMGTools.External.pujetidsequence_cff")
process.puJetMva.jets = cms.InputTag("goodPatJets")
process.puJetId.jets = cms.InputTag("goodPatJets")
else:
process.load("CMGTools.External.pujetidsequence_cff")
process.puJetMva.jets = cms.InputTag("goodPatJets")
process.puJetId.jets = cms.InputTag("goodPatJets")
process.puJetMvaSmeared = process.puJetMva.clone()
process.puJetIdSmeared = process.puJetId.clone()
process.puJetMvaResUp = process.puJetMva.clone()
process.puJetIdResUp = process.puJetId.clone()
process.puJetMvaResDown = process.puJetMva.clone()
process.puJetIdResDown = process.puJetId.clone()
process.puJetMvaEnUp = process.puJetMva.clone()
process.puJetIdEnUp = process.puJetId.clone()
process.puJetMvaEnDown = process.puJetMva.clone()
process.puJetIdEnDown = process.puJetId.clone()
process.puJetIdSmeared.jets = cms.InputTag("smearedGoodPatJetsWithGaussian")
process.puJetMvaSmeared.jetids = cms.InputTag("puJetIdSmeared")
process.puJetMvaSmeared.jets = cms.InputTag("smearedGoodPatJetsWithGaussian")
process.puJetIdResUp.jets = cms.InputTag("smearedGoodPatJetsResUpWithGaussian")
process.puJetMvaResUp.jetids = cms.InputTag("puJetIdResUp")
process.puJetMvaResUp.jets = cms.InputTag("smearedGoodPatJetsResUpWithGaussian")
process.puJetIdResDown.jets = cms.InputTag("smearedGoodPatJetsResDownWithGaussian")
process.puJetMvaResDown.jetids = cms.InputTag("puJetIdResDown")
process.puJetMvaResDown.jets = cms.InputTag("smearedGoodPatJetsResDownWithGaussian")
process.puJetIdEnUp.jets = cms.InputTag("shiftedGoodPatJetsEnUpForCorrMEtWithGaussian")
process.puJetMvaEnUp.jetids = cms.InputTag("puJetIdEnUp")
process.puJetMvaEnUp.jets = cms.InputTag("shiftedGoodPatJetsEnUpForCorrMEtWithGaussian")
process.puJetIdEnDown.jets = cms.InputTag("shiftedGoodPatJetsEnDownForCorrMEtWithGaussian")
process.puJetMvaEnDown.jetids = cms.InputTag("puJetIdEnDown")
process.puJetMvaEnDown.jets = cms.InputTag("shiftedGoodPatJetsEnDownForCorrMEtWithGaussian")
# For jet without Gaussian smearing collection
process.puJetMvaSmearedNoGaussian = process.puJetMva.clone()
process.puJetIdSmearedNoGaussian = process.puJetId.clone()
process.puJetMvaResUpNoGaussian = process.puJetMva.clone()
process.puJetIdResUpNoGaussian = process.puJetId.clone()
process.puJetMvaResDownNoGaussian = process.puJetMva.clone()
process.puJetIdResDownNoGaussian = process.puJetId.clone()
process.puJetMvaEnUpNoGaussian = process.puJetMva.clone()
process.puJetIdEnUpNoGaussian = process.puJetId.clone()
process.puJetMvaEnDownNoGaussian = process.puJetMva.clone()
process.puJetIdEnDownNoGaussian = process.puJetId.clone()
process.puJetIdSmearedNoGaussian.jets = cms.InputTag("smearedGoodPatJetsNoGaussian")
process.puJetMvaSmearedNoGaussian.jetids = cms.InputTag("puJetIdSmearedNoGaussian")
process.puJetMvaSmearedNoGaussian.jets = cms.InputTag("smearedGoodPatJetsNoGaussian")
process.puJetIdResUpNoGaussian.jets = cms.InputTag("smearedGoodPatJetsResUpNoGaussian")
process.puJetMvaResUpNoGaussian.jetids = cms.InputTag("puJetIdResUpNoGaussian")
process.puJetMvaResUpNoGaussian.jets = cms.InputTag("smearedGoodPatJetsResUpNoGaussian")
process.puJetIdResDownNoGaussian.jets = cms.InputTag("smearedGoodPatJetsResDownNoGaussian")
process.puJetMvaResDownNoGaussian.jetids = cms.InputTag("puJetIdResDownNoGaussian")
process.puJetMvaResDownNoGaussian.jets = cms.InputTag("smearedGoodPatJetsResDownNoGaussian")
process.puJetIdEnUpNoGaussian.jets = cms.InputTag("shiftedGoodPatJetsEnUpForCorrMEtNoGaussian")
process.puJetMvaEnUpNoGaussian.jetids = cms.InputTag("puJetIdEnUpNoGaussian")
process.puJetMvaEnUpNoGaussian.jets = cms.InputTag("shiftedGoodPatJetsEnUpForCorrMEtNoGaussian")
process.puJetIdEnDownNoGaussian.jets = cms.InputTag("shiftedGoodPatJetsEnDownForCorrMEtNoGaussian")
process.puJetMvaEnDownNoGaussian.jetids = cms.InputTag("puJetIdEnDownNoGaussian")
process.puJetMvaEnDownNoGaussian.jets = cms.InputTag("shiftedGoodPatJetsEnDownForCorrMEtNoGaussian")
###--------------------------------------------------------------
###--------------------------------------------------------------
### MET
# Apply type 0 MET corrections based on PFCandidate
process.load("JetMETCorrections.Type1MET.pfMETCorrectionType0_cfi")
process.pfType1CorrectedMet.applyType0Corrections = cms.bool(False)
process.pfType1CorrectedMet.srcType1Corrections = cms.VInputTag(
cms.InputTag('pfMETcorrType0'),
cms.InputTag('pfJetMETcorr', 'type1')
)
# Get loose ID/Iso muons and veto ID electrons
process.load("InvisibleHiggs.Ntuple.PhysicsObjectCandidates_cff")
# Get PFMET from runMEtUncertainties
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
process.load("JetMETCorrections.Type1MET.pfMETsysShiftCorrections_cfi")
if iRunOnData == True:
runMEtUncertainties(process,
electronCollection = cms.InputTag('selectVetoElectrons'),
photonCollection = '',
muonCollection = 'selectLooseMuons',
tauCollection = '',
jetCollection = cms.InputTag('goodPatJets'),
jetCorrLabel = 'L2L3Residual',
doSmearJets = False,
makeType1corrPFMEt = True,
makeType1p2corrPFMEt = False,
makePFMEtByMVA = False,
makeNoPileUpPFMEt = False,
doApplyType0corr = True,
sysShiftCorrParameter = process.pfMEtSysShiftCorrParameters_2012runAvsNvtx_data,
doApplySysShiftCorr = False,
addToPatDefaultSequence = False,
postfix = ''
)
process.patPFJetMETtype1p2Corr.jetCorrLabel = cms.string('L2L3Residual')
process.patPFJetMETtype2Corr.jetCorrLabel = cms.string('L2L3Residual')
else:
runMEtUncertainties(process,
electronCollection = cms.InputTag('selectVetoElectrons'),
photonCollection = '',
muonCollection = 'selectLooseMuons',
tauCollection = '',
jetCollection = cms.InputTag('goodPatJets'),
jetCorrLabel = 'L3Absolute',
doSmearJets = True,
makeType1corrPFMEt = True,
makeType1p2corrPFMEt = False,
makePFMEtByMVA = False,
makeNoPileUpPFMEt = False,
doApplyType0corr = True,
sysShiftCorrParameter = process.pfMEtSysShiftCorrParameters_2012runAvsNvtx_mc,
doApplySysShiftCorr = False,
addToPatDefaultSequence = False,
postfix = 'WithGaussian'
)
runMEtUncertainties(process,
electronCollection = cms.InputTag('selectVetoElectrons'),
photonCollection = '',
muonCollection = 'selectLooseMuons',
tauCollection = '',
jetCollection = cms.InputTag('goodPatJets'),
jetCorrLabel = 'L3Absolute',
doSmearJets = True,
makeType1corrPFMEt = True,
makeType1p2corrPFMEt = False,
makePFMEtByMVA = False,
makeNoPileUpPFMEt = False,
doApplyType0corr = True,
sysShiftCorrParameter = process.pfMEtSysShiftCorrParameters_2012runAvsNvtx_mc,
doApplySysShiftCorr = False,
addToPatDefaultSequence = False,
postfix = 'NoGaussian'
)
# Turn off gaussian smearing
process.smearedGoodPatJetsNoGaussian.doGaussian = cms.int32(0)
process.smearedGoodPatJetsResUpNoGaussian.doGaussian = cms.int32(0)
process.smearedGoodPatJetsResDownNoGaussian.doGaussian = cms.int32(0)
# Fix Type0 correction module
process.patPFMETtype0Corr.correction.par3 = cms.double(0.909209)
process.patPFMETtype0Corr.correction.par2 = cms.double(0.0303531)
process.patPFMETtype0Corr.correction.par1 = cms.double(-0.703151)
process.patPFMETtype0Corr.correction.par0 = cms.double(0.0)
###--------------------------------------------------------------
# PAT/ntuples one step
# Z and W candidates
process.load('InvisibleHiggs/Ntuple/WCandidates_cff')
process.load('InvisibleHiggs/Ntuple/ZCandidates_cff')
# Ntuple producer
process.load('InvisibleHiggs/Ntuple/invHiggsInfo_cfi')
if iRunOnData == False:
# Jet/MET uncertainty
process.invHiggsInfo.jetTag = cms.untracked.InputTag("smearedGoodPatJetsWithGaussian")
process.invHiggsInfo.metTag = cms.untracked.InputTag("patType1CorrectedPFMetWithGaussian")
process.invHiggsInfo.puJetMvaTag = cms.untracked.InputTag("puJetMvaSmeared", "fullDiscriminant")
process.invHiggsInfo.puJetIdTag = cms.untracked.InputTag("puJetMvaSmeared", "fullId")
# PU re-weighting
process.invHiggsInfo.puMCFile = cms.untracked.string("PUHistS10.root")
process.invHiggsInfo.puDataFile = cms.untracked.string("PUHistRun2012All_forV9.root")
process.invHiggsInfo.puMCHist = cms.untracked.string("pileup")
process.invHiggsInfo.puDataHist = cms.untracked.string("pileup")
process.invHiggsInfo.mcPYTHIA = cms.untracked.bool(True)
process.invHiggsInfo.trigCorrFile = cms.untracked.string("DataMCWeight_53X_v1.root")
process.invHiggsInfo.leptCorrFile = cms.untracked.string("leptonWeights.root")
# TTree output file
process.load("CommonTools.UtilAlgos.TFileService_cfi")
process.TFileService.fileName = cms.string('invHiggsInfo_MC.root')
###--------------------------------------------------------------
###--------------------------------------------------------------
### Tau
# removeSpecificPATObjects( process, ['Taus'] )
# process.patDefaultSequence.remove( process.patTaus )
process.load("RecoTauTag.Configuration.RecoPFTauTag_cff")
###--------------------------------------------------------------
###--------------------------------------------------------------
### Trigger matching
# from PhysicsTools.PatAlgos.tools.trigTools import *
# process.metTriggerMatch = cms.EDProducer(
# "PATTriggerMatcherDRLessByR" # match by DeltaR only, best match by DeltaR
# , src = cms.InputTag( 'patMETs' )
# , matched = cms.InputTag( 'patTrigger' ) # default producer label as defined in PhysicsTools/PatAlgos/python/triggerLayer1/triggerProducer_cfi.py
# , matchedCuts = cms.string( 'path( "HLT_MET100_v*" )' )
# , maxDPtRel = cms.double( 0.5 )
# , maxDeltaR = cms.double( 0.5 )
# , resolveAmbiguities = cms.bool( True ) # only one match per trigger object
# , resolveByMatchQuality = cms.bool( True ) # take best match found per reco object: by DeltaR here (s. above)
# )
# process.jetTriggerMatch = cms.EDProducer(
# "PATTriggerMatcherDRLessByR" # match by DeltaR only, best match by DeltaR
# , src = cms.InputTag( 'patJets' )
# , matched = cms.InputTag( 'patTrigger' ) # default producer label as defined in PhysicsTools/PatAlgos/python/triggerLayer1/triggerProducer_cfi.py
# , matchedCuts = cms.string( 'path( "HLT_Jet30_v*" )' )
# , maxDPtRel = cms.double( 0.5 )
# , maxDeltaR = cms.double( 0.5 )
# , resolveAmbiguities = cms.bool( True ) # only one match per trigger object
# , resolveByMatchQuality = cms.bool( True ) # take best match found per reco object: by DeltaR here (s. above)
# )
# switchOnTriggerMatchEmbedding( process, [ 'metTriggerMatch', 'jetTriggerMatch' ] )
###--------------------------------------------------------------
###--------------------------------------------------------------
### Paths
process.p0 = cms.Path( process.HBHENoiseFilter )
process.p1 = cms.Path( process.CSCTightHaloFilter )
process.p2 = cms.Path( process.hcalLaserEventFilter )
process.p3 = cms.Path( process.EcalDeadCellTriggerPrimitiveFilter )
process.p4 = cms.Path( process.eeBadScFilter )
process.p5 = cms.Path( process.ecalLaserCorrFilter )
process.p6 = cms.Path( process.goodVertices * process.trackingFailureFilter )
process.p7 = cms.Path( process.trkPOGFilters )
process.p8 = cms.Path( process.hcallLaserEvent2012Filter )
if iRunOnData == True:
process.p = cms.Path(
# Trigger filter
process.hltHighLevel *
# Basic filters
process.noscraping *
process.primaryVertexFilter *
# MET filters (Move to be flags)
# MET Correction
process.type0PFMEtCorrection *
# Tau
process.recoTauClassicHPSSequence *
# Generate PAT
process.pfParticleSelectionSequence *
process.patDefaultSequence *
process.goodPatJets *
process.PhysicsObjectSequence *
process.metUncertaintySequence *
process.puJetIdSqeuence *
process.WSequence *
process.ZSequence *
process.invHiggsInfo
)
else:
process.p = cms.Path(
# Trigger filter
process.hltHighLevel *
# Basic filters
process.noscraping *
process.primaryVertexFilter *
# MET filters (Move to be flags)
# MET Correction
process.type0PFMEtCorrection *
# Tau
process.recoTauClassicHPSSequence *
# Generate PAT
process.pfParticleSelectionSequence *
process.genParticlesForJetsNoNu *
process.ak5GenJetsNoNu *
process.patDefaultSequence *
process.goodPatJets *
process.PhysicsObjectSequence *
process.metUncertaintySequenceWithGaussian *
process.metUncertaintySequenceNoGaussian *
process.puJetIdSqeuence *
process.puJetIdSmeared *
process.puJetMvaSmeared *
process.puJetIdResUp *
process.puJetMvaResUp *
process.puJetIdResDown *
process.puJetMvaResDown *
process.puJetIdEnUp *
process.puJetMvaEnUp *
process.puJetIdEnDown *
process.puJetMvaEnDown *
process.puJetIdSmearedNoGaussian *
process.puJetMvaSmearedNoGaussian *
process.puJetIdResUpNoGaussian *
process.puJetMvaResUpNoGaussian *
process.puJetIdResDownNoGaussian *
process.puJetMvaResDownNoGaussian *
process.puJetIdEnUpNoGaussian *
process.puJetMvaEnUpNoGaussian *
process.puJetIdEnDownNoGaussian *
process.puJetMvaEnDownNoGaussian *
process.WSequence *
process.ZSequence *
process.invHiggsInfo
)
###--------------------------------------------------------------
###--------------------------------------------------------------
### Output
process.out.outputCommands += [
# trigger results
'keep edmTriggerResults_*_*_*'
,'keep *_hltTriggerSummaryAOD_*_*'
# L1
,'keep *_l1extraParticles_MET_RECO'
,'keep *_l1extraParticles_MHT_RECO'
# good jets
,'keep *_goodPatJets_*_*'
# PU jet ID
,'keep *_puJetId*_*_*'
,'keep *_puJetMva*_*_*'
# vertices
,'keep *_offlineBeamSpot_*_*'
,'keep *_offlinePrimaryVertices*_*_*'
,'keep *_goodOfflinePrimaryVertices*_*_*'
,'keep double_*_rho_*'
]
if iRunOnData == False:
process.out.outputCommands += ['keep GenEventInfoProduct_*_*_*'
,'keep recoGenParticles_*_*_*'
,'keep GenMETs_*_*_*'
,'keep *_addPileupInfo_*_*'
,'keep LHEEventProduct_*_*_*'
,'keep ak5GenJets_*_*_*'
,'keep ak5GenJetsNoNu_*_*_*'
]
process.out.fileName = 'patTuple.root'
del(process.out)
del(process.outpath)
btagInfos=btagInfos,
jetTrackAssociation=True,
outputModules=outputModules,
)
if runOnMC:
getattr(process, 'patJetGenJetMatchPatJetsCA15PFCHSFilteredSubJets' +
postfix).matched = cms.InputTag('ca15GenJetsNoNuFiltered',
'SubJets')
# Do switchJetCollection(...) at the end
switchJetCollection(
process,
jetSource=cms.InputTag('ak5PFJetsCHS'),
algo=jetAlgo,
postfix=postfix,
jetCorrections=('AK5PFchs', inputJetCorrLabel, ''),
btagDiscriminators=btagDiscriminators,
btagInfos=btagInfos,
jetTrackAssociation=True,
outputModules=outputModules,
)
# ------------------------------------------------------------------------------
# Pileup Jet ID
# https://twiki.cern.ch/twiki/bin/view/CMS/PileupJetID
# ------------------------------------------------------------------------------
process.load("JetMETCorrections.Configuration.JetCorrectionServices_cff")
# Convert algorithm from AK5PFCHS to AK5PFchs
process.ak5PFCHSL1Offset.algorithm = cms.string('AK5PFchs')
process.ak5PFCHSL1Fastjet.algorithm = cms.string('AK5PFchs')
process.ak5PFCHSL2Relative.algorithm = cms.string('AK5PFchs')
jetCorrections = ('AK10PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None'),
trackSource = cms.InputTag('unpackedTracksAndVertices'),
pvSource = cms.InputTag('offlineSlimmedPrimaryVertices'),
svSource = cms.InputTag('slimmedSecondaryVertices'),
pfCandidates = cms.InputTag('packedPFCandidates'),
btagDiscriminators = ['pfCombinedSecondaryVertexBJetTags', 'pfCombinedInclusiveSecondaryVertexV2BJetTags'],
genJetCollection=cms.InputTag('ak4GenJets'),
)
switchJetCollection(
process,
jetSource = cms.InputTag('ak4PFJets'),
algo = 'ak4',
rParam = 0.4,
jetCorrections = ('AK4PF', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'Type-1'),
trackSource = cms.InputTag('unpackedTracksAndVertices'),
pvSource = cms.InputTag('offlineSlimmedPrimaryVertices'),
svSource = cms.InputTag('slimmedSecondaryVertices'),
pfCandidates = cms.InputTag('packedPFCandidates'),
#btagDiscriminators = ['pfCombinedSecondaryVertexBJetTags', 'pfCombinedInclusiveSecondaryVertexV2BJetTags'], #this breaks the config
genJetCollection=cms.InputTag('ak4GenJets'),
)
for module in [process.patJetsAK4PFCHS, process.patJetsAK8PFCHS, process.patJetsAK10PFCHS, process.patJetsAK12PFCHS, process.patJetsAK15PFCHS]:
module.addJetCharge = False
module.addBTagInfo = True
module.getJetMCFlavour = False
module.addAssociatedTracks = False
for module in [process.patJetPartonMatch, process.patJetPartonMatchAK4PFCHS, process.patJetPartonMatchAK8PFCHS, process.patJetPartonMatchAK10PFCHS, process.patJetPartonMatchAK12PFCHS, process.patJetPartonMatchAK15PFCHS]:
module.matched='prunedGenParticles'
SelectEvents=cms.untracked.PSet(SelectEvents=cms.vstring('p')),
outputCommands = cms.untracked.vstring("keep *")
)
process.outpath = cms.EndPath(process.out)
from PhysicsTools.PatAlgos.tools.coreTools import *
removeMCMatching(process, ['All'])
########################################
# PAT Jet Energy Corrections - MC vs Data
########################################
#
from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection
if isMC:
switchJetCollection( process,
jetCollection=cms.InputTag('ak5CaloJets'),
jetCorrLabel=('AK5Calo', ['L2Relative','L3Absolute']))
else:
switchJetCollection( process,
jetCollection=cms.InputTag('ak5CaloJets'),
jetCorrLabel=('AK5Calo', ['L2Relative','L3Absolute','L2L3Residual']))
########################################
# PAT Trigger matching
########################################
# imported directly from PhysicsTools/PatExamples/test/analyzePatTrigger_onTheFly_cfg.py
#
process.load("HeavyNu.AnalysisModules.hnutrigmatch_cfi")
### ============
### Python tools
# comment-out to take new HPS + TaNC combined tau id. algorithm
#tauTools.switchToPFTauHPSpTaNC(process)
# disable preselection on of pat::Taus
# (disabled also in TauAnalysis/RecoTools/python/patPFTauConfig_cfi.py ,
# but re-enabled after switching tau collection)
process.cleanPatTaus.preselection = cms.string('')
#--------------------------------------------------------------------------------
#--------------------------------------------------------------------------------
# import utility function for managing pat::Jets
import PhysicsTools.PatAlgos.tools.jetTools as jetTools
# uncomment to replace caloJets by pfJets
jetTools.switchJetCollection(process,
jetCollection=cms.InputTag("ak5PFJets"),
doBTagging=True,
outputModule='')
#--------------------------------------------------------------------------------
#--------------------------------------------------------------------------------
# import utility function for managing pat::METs
import TauAnalysis.Configuration.tools.metTools as metTools
# uncomment to add pfMET
# set Boolean swich to true in order to apply type-1 corrections
metTools.addPFMet(process, correct=False)
# uncomment to replace caloMET by pfMET in all di-tau objects
process.load("TauAnalysis.CandidateTools.diTauPairProductionAllKinds_cff")
metTools.replaceMETforDiTaus(process, cms.InputTag('patMETs'),
cms.InputTag('patPFMETs'))
execfile("TopAnalysis/Configuration/analysis/semiLeptonic/jetEnergy/analyzeJetEnergyCorrections_aod_template_cfg.py")
from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection
switchJetCollection(process,
cms.InputTag('iterativeCone5CaloJets'),
doJTA = True,
doBTagging = True,
jetCorrLabel = ('IC5','Calo'),
doType1MET = True,
genJetCollection = cms.InputTag("iterativeCone5GenJets"),
doJetID = True,
jetIdLabel = 'ic5'
)
myGenJets = "iterativeCone5GenJets"
process.ttSemiLepGenJetPartonMatch.jets = myGenJets
process.analyzeJetEnergyGenMatch_raw .genJets = myGenJets
process.analyzeJetEnergyGenMatch_off .genJets = myGenJets
process.analyzeJetEnergyGenMatch_rel .genJets = myGenJets
process.analyzeJetEnergyGenMatch_abs .genJets = myGenJets
process.analyzeJetEnergyGenMatch_emf .genJets = myGenJets
process.analyzeJetEnergyGenMatch_had .genJets = myGenJets
process.analyzeJetEnergyGenMatch_ue .genJets = myGenJets
process.analyzeJetEnergyGenMatch_part.genJets = myGenJets
process.analyzeJetEnergyGeom_raw .genJets = myGenJets
process.analyzeJetEnergyGeom_off .genJets = myGenJets
process.analyzeJetEnergyGeom_rel .genJets = myGenJets
process.analyzeJetEnergyGeom_abs .genJets = myGenJets
process.analyzeJetEnergyGeom_emf .genJets = myGenJets
def addTagInfos(process,jetMetCorrections):
from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection
switchJetCollection( process,
jetCollection=cms.InputTag('ak5CaloJets'),
jetCorrLabel=('AK5Calo', jetMetCorrections))
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 ReRunJetsMC(process):
process.load("RecoJets.Configuration.RecoPFJets_cff")
import PhysicsTools.PatAlgos.tools.jetTools as jettools
process.load("PhysicsTools.PatAlgos.patSequences_cff")
process.load("UWAnalysis.Configuration.tools.patJetPUId_cfi")
from RecoBTag.SoftLepton.softLepton_cff import *
from RecoBTag.ImpactParameter.impactParameter_cff import *
from RecoBTag.SecondaryVertex.secondaryVertex_cff import *
from RecoBTau.JetTagComputer.combinedMVA_cff import *
process.pileupJetIdProducer.applyJec = cms.bool(True)
process.load('RecoVertex/AdaptiveVertexFinder/inclusiveVertexing_cff')
#process.load('RecoBTag/SecondaryVertex/bToCharmDecayVertexMerger_cfi')
process.simpleSecondaryVertex = cms.ESProducer("SimpleSecondaryVertexESProducer",
use3d = cms.bool(True),
unBoost = cms.bool(False),
useSignificance = cms.bool(True),
minTracks = cms.uint32(2)
)
# Define options for BTagging - these are release dependent.
btag_options = {'doBTagging': True}
btag_options['btagInfo'] = [
'impactParameterTagInfos',
'secondaryVertexTagInfos',
'softMuonTagInfos'
]
btag_options['btagdiscriminators'] = [
'simpleSecondaryVertexHighEffBJetTags',
'simpleSecondaryVertexHighPurBJetTags',
'combinedSecondaryVertexMVABJetTags',
'combinedSecondaryVertexBJetTags',
]
jec = ['L1FastJet', 'L2Relative', 'L3Absolute']
# For Data jec.extend(['L2L3Residual'])
jettools.switchJetCollection(
process,
cms.InputTag('ak5PFJets'),
doJTA=False,
jetCorrLabel=('AK5PF', jec),
#jetCorrLabel = None,
doType1MET=False,
doJetID=True,
genJetCollection=cms.InputTag("ak5GenJets"),
outputModules=[],
**btag_options
)
process.patJets.embedPFCandidates = False
process.patJets.embedCaloTowers = False
process.patJets.embedGenJetMatch = False
process.patJets.addAssociatedTracks = False
process.patJets.embedGenPartonMatch = False
process.patJets.tagInfoSources = cms.VInputTag(
cms.InputTag("impactParameterTagInfos"),
#cms.InputTag("secondaryVertexNegativeTagInfos"),
cms.InputTag("secondaryVertexTagInfos"))
process.patJets.discriminatorSources = cms.VInputTag(
cms.InputTag("combinedSecondaryVertexMVABJetTags"),
cms.InputTag("combinedSecondaryVertexBJetTags"),
cms.InputTag("simpleSecondaryVertexHighPurBJetTags"),
cms.InputTag("simpleSecondaryVertexHighEffBJetTags"))
process.patJets.trackAssociationSource = cms.InputTag("ak5JetTracksAssociatorAtVertex")
process.patJets.addBTagInfo = cms.bool(True)
process.patJets.addDiscriminators = cms.bool(True)
process.patJets.addTagInfos = cms.bool(True)
process.ak5JetTracksAssociatorAtVertex = cms.EDProducer("JetTracksAssociatorAtVertex",
tracks = cms.InputTag("generalTracks"),
jets = cms.InputTag("ak5PFJets"),
coneSize = cms.double(0.5)
)
process.load('UWAnalysis.Configuration.tools.RecoBTag_cff')
process.patJetCharge.src = cms.InputTag("ak5JetTracksAssociatorAtVertex")
process.NewSelectedPatJets = process.selectedPatJets.clone(src = cms.InputTag("patJetId"))
process.analysisSequence = cms.Sequence(
process.analysisSequence*
process.ak5PFJets*
process.ak5JetTracksAssociatorAtVertex*
process.btagging*
process.pileupJetIdProducer*
process.makePatJets*
process.patJetsPUID*
process.patJetId*
process.NewSelectedPatJets
)
def configurePatTuple(process, isMC=True, **kwargs):
# Stuff we always keep
output_commands = [
'*_addPileupInfo_*_*',
'edmMergeableCounter_*_*_*',
'*_lumiProducer_*_*',
'*_particleFlow_*_*',
'*_offlineBeamSpot_*_*',
'*_trackCandidates_*_*',
'*_gsfTrackCandidates_*_*',
#'*_generalTracks_*_*',
'*_electronGsfTracks_*_*',
'*_offlinePrimaryVertices*_*_*',
'*_ak5PFJets_*_*',
'*_ak5GenJets_*_*',
'*_hltTriggerSummaryAOD_*_*',
'edmTriggerResults_TriggerResults_*_%s' % process.name_(),
'*_MEtoEDMConverter*_*_%s' % process.name_(),
'LHEEventProduct_*_*_*',
'GenEventInfoProduct_generator_*_*',
'*_kt6PFJetsForRhoComputationVoronoi_rho_*',
'*_kt6PFJetsForIso_rho_*',
]
# Define our patTuple production sequence
process.tuplize = cms.Sequence()
# Only keep interesting genParticles
process.load("FinalStateAnalysis.RecoTools.genParticleTrimmer_cfi")
process.genParticles = process.prunedGenParticles.clone()
if isMC:
#process.tuplize += process.genParticles
#output_commands.append('*_genParticles_*_%s' % process.name_())
output_commands.append('*_genParticles_*_*')
output_commands.append('*_tauGenJetsSelectorAllHadrons_*_*')
output_commands.append('*_tauGenJets_*_*')
output_commands.append('*_ak5GenJets_*_*')
# Select vertices
process.load("FinalStateAnalysis.RecoTools.vertexSelection_cff")
output_commands.append('*_selectedPrimaryVertex_*_*')
output_commands.append('*_selectPrimaryVerticesQuality_*_*')
process.tuplize += process.selectPrimaryVertices
# Run the ZZ recipe for rho
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets \
as zzCantDoAnythingRight
process.kt6PFJetsForIso = zzCantDoAnythingRight.clone(
rParam = cms.double(0.6),
doAreaFastjet = cms.bool(True),
doRhoFastjet = cms.bool(True),
Rho_EtaMax = cms.double(2.5),
Ghost_EtaMax = cms.double(2.5),
)
process.tuplize += process.kt6PFJetsForIso
# Rerun tau-ID
process.load('Configuration/StandardSequences/Services_cff')
process.load('Configuration/StandardSequences/GeometryIdeal_cff')
process.load('Configuration/StandardSequences/MagneticField_cff')
process.load('Configuration/StandardSequences/FrontierConditions_GlobalTag_cff')
process.load("RecoTauTag.Configuration.RecoPFTauTag_cff")
# Optimization - remove PFTauTagInfo compatibility layer
process.recoTauClassicHPSSequence.remove(process.pfRecoTauTagInfoProducer)
assert(process.combinatoricRecoTaus.modifiers[3].name.value() == 'TTIworkaround')
del process.combinatoricRecoTaus.modifiers[3]
process.tuplize += process.recoTauClassicHPSSequence
## Run rho computation
#from RecoJets.Configuration.RecoPFJets_cff import kt6PFJets
#kt6PFJets.Rho_EtaMax = cms.double(2.5)
#kt6PFJets.doRhoFastjet = True
#process.kt6PFJets = kt6PFJets
#process.tuplize += process.kt6PFJets
# Run pat default sequence
process.load("PhysicsTools.PatAlgos.patSequences_cff")
# Embed PF Isolation in electrons & muons
pfTools.usePFIso(process)
# Custom veto cones
process.elPFIsoValuePU04PFIdPFIso.deposits.vetos = cms.vstring()
process.elPFIsoValueChargedAll04PFIdPFIso.deposits.vetos = cms.vstring(
'EcalBarrel:ConeVeto(0.01)','EcalEndcaps:ConeVeto(0.015)')
# Unembed junk
process.patMuons.embedCaloMETMuonCorrs = False
process.patMuons.embedTcMETMuonCorrs = False
process.patMuons.embedTrack = True
process.patMuons.pvSrc = cms.InputTag("selectedPrimaryVertex")
# Do extra electron ID
process.load("FinalStateAnalysis.PatTools.electrons.electronID_cff")
process.tuplize += process.recoElectronID
process.patElectrons.electronIDSources = process.electronIDSources
process.patElectrons.embedTrack = True
# Run EGamma electron energy calibration
process.load("EgammaCalibratedGsfElectrons.CalibratedElectronProducers.calibratedGsfElectrons_cfi")
process.RandomNumberGeneratorService.calibratedGsfElectrons = cms.PSet(
initialSeed = cms.untracked.uint32(1), # A frickin billion
engineName = cms.untracked.string('TRandom3')
)
process.calibratedGsfElectrons.inputDataset = kwargs['dataset']
process.calibratedGsfElectrons.isMC = bool(isMC)
process.calibratedGsfElectrons.isAOD = True
process.calibratedGsfElectrons.updateEnergyError = cms.bool(True)
# Run a sanity check on the calibration configuration.
from FinalStateAnalysis.PatTools.electrons.patElectronEmbedCalibratedGsf_cfi \
import validate_egamma_calib_config
validate_egamma_calib_config(process)
process.tuplize += process.calibratedGsfElectrons
# Keep the calibratedGsfElectrons - we embed refs to this into the
# pat::Electrons
output_commands.append('*_calibratedGsfElectrons_*_*')
# Now run PAT
process.tuplize += process.patDefaultSequence
# Use HPS taus
tautools.switchToPFTauHPS(process)
# Disable tau IsoDeposits
process.patDefaultSequence.remove(process.patPFTauIsolation)
process.patTaus.isoDeposits = cms.PSet()
process.patTaus.userIsolation = cms.PSet()
# Disable gen match embedding - we keep it in the ntuple
process.patMuons.embedGenMatch = False
process.patElectrons.embedGenMatch = False
process.patTaus.embedGenMatch = False
process.patTaus.embedGenJetMatch = False
# Use PFJets and turn on JEC
jec = [ 'L1FastJet', 'L2Relative', 'L3Absolute' ]
if not isMC:
jec.extend([ 'L2L3Residual' ])
# Use AK5 PFJets
jettools.switchJetCollection(process,
cms.InputTag('ak5PFJets'),
doJTA = False,
doBTagging = True,
jetCorrLabel = ('AK5PF', jec),
#jetCorrLabel = None,
doType1MET = False,
doJetID = True,
genJetCollection = cms.InputTag("ak5GenJets"))
process.patJets.embedPFCandidates = False
process.patJets.embedCaloTowers = False
process.patJets.embedGenJetMatch = False
process.patJets.addAssociatedTracks = False
process.patJets.embedGenPartonMatch = False
process.patJetCorrFactors.useRho = True
# Let's use the same rho as in the TauID, so we don't need to do it twice.
process.patJetCorrFactors.rho = cms.InputTag(
"kt6PFJetsForRhoComputationVoronoi", "rho")
# Use PFMEt
mettools.addPfMET(process)
if not isMC:
coreTools.runOnData(process)
process.patMETsPF.addGenMET = False
output_commands.append('patJets_selectedPatJets_*_*')
# Customize/embed all our sequences
process.load("FinalStateAnalysis.PatTools.patJetProduction_cff")
# We have to keep all jets (for the MVA MET...)
process.patJetGarbageRemoval.cut = 'pt > 0'
final_jet_collection = chain_sequence(
process.customizeJetSequence, "patJets")
process.customizeJetSequence.insert(0, process.patJets)
# Make it a "complete" sequence
process.customizeJetSequence += process.selectedPatJets
# We can't mess up the selected pat jets because the taus use them.
process.selectedPatJets.src = final_jet_collection
process.patDefaultSequence.replace(process.patJets,
process.customizeJetSequence)
# Produce the electron collections
process.load("FinalStateAnalysis.PatTools.patElectronProduction_cff")
final_electron_collection = chain_sequence(
process.customizeElectronSequence, "selectedPatElectrons")
process.tuplize += process.customizeElectronSequence
process.customizeElectronSequence.insert(0, process.selectedPatElectrons)
process.patDefaultSequence.replace(process.selectedPatElectrons,
process.customizeElectronSequence)
# We have to do the pat Jets before the pat electrons since we embed them
process.customizeElectronSequence.insert(0, process.selectedPatJets)
process.cleanPatElectrons.src = final_electron_collection
# The "effective area" calculation needs to know if it is data/mc, etc.
process.patElectronMVAIsoEmbedding.target = kwargs['target']
process.patElectronEffectiveAreaEmbedder.target = kwargs['target']
process.load("FinalStateAnalysis.PatTools.patMuonProduction_cff")
final_muon_collection = chain_sequence(
process.customizeMuonSequence, "selectedPatMuons")
process.customizeMuonSequence.insert(0, process.selectedPatMuons)
process.patDefaultSequence.replace(process.selectedPatMuons,
process.customizeMuonSequence)
process.cleanPatMuons.src = final_muon_collection
# The "effective area" calculation needs to know if it is data/mc, etc.
process.patMuonMVAIdIsoEmbedding.target = kwargs['target']
process.patMuonEffectiveAreaEmbedder.target = kwargs['target']
process.load("FinalStateAnalysis.PatTools.patTauProduction_cff")
final_tau_collection = chain_sequence(
process.customizeTauSequence, "selectedPatTaus")
# Inject into the pat sequence
process.customizeTauSequence.insert(0, process.selectedPatTaus)
process.patDefaultSequence.replace(process.selectedPatTaus,
process.customizeTauSequence)
process.cleanPatTaus.src = final_tau_collection
# Remove muons and electrons
process.cleanPatTaus.checkOverlaps.muons.requireNoOverlaps = False
process.cleanPatTaus.checkOverlaps.electrons.requireNoOverlaps = False
# Don't apply any prselections
process.cleanPatTaus.preselection = 'abs(eta) < 2.5 & (pt > 18 | userFloat("jetPt") > 18)'
# Setup MET production
process.load("FinalStateAnalysis.PatTools.patMETProduction_cff")
final_met_collection = chain_sequence(
process.customizeMETSequence, "patMETsPF")
process.tuplize += process.customizeMETSequence
# The MET systematics depend on all other systematics
process.systematicsMET.tauSrc = cms.InputTag("cleanPatTaus")
process.systematicsMET.muonSrc = cms.InputTag("cleanPatMuons")
process.systematicsMET.electronSrc = cms.InputTag("cleanPatElectrons")
# Keep all the data formats needed for the systematics
output_commands.append('recoLeafCandidates_*_*_%s'
% process.name_())
# Define the default lepton cleaning
process.cleanPatElectrons.preselection = cms.string('pt > 5')
process.cleanPatElectrons.checkOverlaps.muons.requireNoOverlaps = False
# Make sure we don't kill any good taus by calling them electrons
# Note that we don't actually remove these overlaps.
process.cleanPatElectrons.checkOverlaps.taus = cms.PSet(
src = final_tau_collection,
algorithm = cms.string("byDeltaR"),
preselection = cms.string(
"tauID('decayModeFinding') > 0.5 &&"
"tauID('byLooseCombinedIsolationDeltaBetaCorr') > 0.5 &&"
"tauID('againstElectronLoose') > 0.5 && "
"pt > 10"
),
deltaR = cms.double(0.1),
checkRecoComponents = cms.bool(False),
pairCut = cms.string(""),
requireNoOverlaps = cms.bool(False),
)
output_commands.append('*_cleanPatTaus_*_*')
output_commands.append('*_cleanPatElectrons_*_*')
output_commands.append('*_cleanPatMuons_*_*')
output_commands.append('*_%s_*_*' % final_met_collection.value())
#process.load("PhysicsTools.PatAlgos.triggerLayer1.triggerMatcher_cfi")
#trigtools.switchOnTriggerMatchEmbedding(process)
trigtools.switchOnTrigger(process)
# Build the PATFinalStateEventObject
process.load("FinalStateAnalysis.PatTools.finalStates.patFinalStateEventProducer_cfi")
process.patFinalStateEventProducer.electronSrc = final_electron_collection
process.patFinalStateEventProducer.muonSrc = cms.InputTag("cleanPatMuons")
process.patFinalStateEventProducer.tauSrc = cms.InputTag("cleanPatTaus")
process.patFinalStateEventProducer.jetSrc = cms.InputTag("selectedPatJets")
process.patFinalStateEventProducer.metSrc = final_met_collection
process.tuplize += process.patFinalStateEventProducer
output_commands.append('*_patFinalStateEventProducer_*_*')
process.patFinalStateEventProducer.puTag = cms.string(kwargs['puTag'])
# Now build the PATFinalStateLS object, which holds LumiSection info.
process.load(
"FinalStateAnalysis.PatTools.finalStates.patFinalStateLSProducer_cfi")
process.tuplize += process.finalStateLS
output_commands.append('*_finalStateLS_*_*')
if isMC:
process.finalStateLS.xSec = kwargs['xSec']
# Apply some loose PT cuts on the objects we use to create the final states
# so the combinatorics don't blow up
process.muonsForFinalStates = cms.EDFilter(
"PATMuonRefSelector",
src = cms.InputTag("cleanPatMuons"),
cut = cms.string('pt > 4'),
filter = cms.bool(False),
)
process.electronsForFinalStates = cms.EDFilter(
"PATElectronRefSelector",
src = cms.InputTag("cleanPatElectrons"),
cut = cms.string('abs(eta) < 2.5 & pt > 4'),
filter = cms.bool(False),
)
# Require that the PT of the jet (either corrected jet or tau)
# to be greater than 17
process.tausForFinalStates = cms.EDFilter(
"PATTauRefSelector",
src = cms.InputTag("cleanPatTaus"),
cut = cms.string('abs(eta) < 2.5 & pt > 17 & tauID("decayModeFinding")'),
filter = cms.bool(False),
)
process.selectObjectsForFinalStates = cms.Sequence(
process.muonsForFinalStates
+ process.electronsForFinalStates
+ process.tausForFinalStates
)
process.tuplize += process.selectObjectsForFinalStates
# Now build all of our DiLeptons and TriLepton final states
lepton_types = [('Elec', cms.InputTag("electronsForFinalStates")),
('Mu', cms.InputTag("muonsForFinalStates")),
('Tau', cms.InputTag("tausForFinalStates"))]
#lepton_types = [('Elec', cms.InputTag("cleanPatElectrons")),
#('Mu', cms.InputTag("cleanPatMuons")),
#('Tau', cms.InputTag("cleanPatTaus"))]
process.buildDiLeptons = cms.Sequence()
process.load(
"FinalStateAnalysis.PatTools.finalStates.patFinalStatesEmbedExtraCollections_cfi")
# Build di-lepton pairs
for dilepton in _combinatorics(lepton_types, 2):
# Don't build two jet states
if (dilepton[0][0], dilepton[1][0]) == ('Tau', 'Tau'):
continue
# Define some basic selections for building combinations
cuts = ['smallestDeltaR() > 0.3'] # basic x-cleaning
producer = cms.EDProducer(
"PAT%s%sFinalStateProducer" % (dilepton[0][0], dilepton[1][0]),
evtSrc = cms.InputTag("patFinalStateEventProducer"),
leg1Src = dilepton[0][1],
leg2Src = dilepton[1][1],
# X-cleaning
cut = cms.string(' & '.join(cuts))
)
producer_name = "finalState%s%s" % (dilepton[0][0], dilepton[1][0])
setattr(process, producer_name + "Raw", producer)
process.buildDiLeptons += producer
# Embed the other collections
embedder_seq = helpers.cloneProcessingSnippet(process,
process.patFinalStatesEmbedObjects, producer_name)
process.buildDiLeptons += embedder_seq
# Do some trickery so the final module has a nice output name
final_module_name = chain_sequence(embedder_seq, producer_name + "Raw")
final_module = getattr(process, final_module_name.value())
final_module.setLabel(producer_name)
setattr(process, producer_name, final_module)
output_commands.append("*_%s_*_*" % producer_name)
process.tuplize += process.buildDiLeptons
# Build tri-lepton pairs
process.buildTriLeptons = cms.Sequence()
for trilepton in _combinatorics(lepton_types, 3):
# Don't build three jet states
if (trilepton[0][0], trilepton[1][0], trilepton[2][0]) == \
('Tau', 'Tau', 'Tau'):
continue
# Define some basic selections for building combinations
cuts = ['smallestDeltaR() > 0.3'] # basic x-cleaning
producer = cms.EDProducer(
"PAT%s%s%sFinalStateProducer" %
(trilepton[0][0], trilepton[1][0], trilepton[2][0]),
evtSrc = cms.InputTag("patFinalStateEventProducer"),
leg1Src = trilepton[0][1],
leg2Src = trilepton[1][1],
leg3Src = trilepton[2][1],
# X-cleaning
cut = cms.string(' & '.join(cuts))
)
producer_name = "finalState%s%s%s" % (
trilepton[0][0], trilepton[1][0], trilepton[2][0])
#setattr(process, producer_name, producer)
#process.buildTriLeptons += producer
setattr(process, producer_name + "Raw", producer)
process.buildTriLeptons += producer
# Embed the other collections
embedder_seq = helpers.cloneProcessingSnippet(process,
process.patFinalStatesEmbedObjects, producer_name)
process.buildTriLeptons += embedder_seq
# Do some trickery so the final module has a nice output name
final_module_name = chain_sequence(embedder_seq, producer_name + "Raw")
final_module = getattr(process, final_module_name.value())
final_module.setLabel(producer_name)
setattr(process, producer_name, final_module)
output_commands.append("*_%s_*_*" % producer_name)
process.tuplize += process.buildTriLeptons
# Build 4 lepton final states
process.buildQuadLeptons = cms.Sequence()
for quadlepton in _combinatorics(lepton_types, 4):
# Don't build states with more than 2 hadronic taus
if [x[0] for x in quadlepton].count('Tau') > 2:
continue
# Define some basic selections for building combinations
cuts = ['smallestDeltaR() > 0.3'] # basic x-cleaning
producer = cms.EDProducer(
"PAT%s%s%s%sFinalStateProducer" %
(quadlepton[0][0], quadlepton[1][0], quadlepton[2][0],
quadlepton[3][0]),
evtSrc = cms.InputTag("patFinalStateEventProducer"),
leg1Src = quadlepton[0][1],
leg2Src = quadlepton[1][1],
leg3Src = quadlepton[2][1],
leg4Src = quadlepton[3][1],
# X-cleaning
cut = cms.string(' & '.join(cuts))
)
producer_name = "finalState%s%s%s%s" % (
quadlepton[0][0], quadlepton[1][0], quadlepton[2][0],
quadlepton[3][0]
)
#setattr(process, producer_name, producer)
#process.buildTriLeptons += producer
setattr(process, producer_name + "Raw", producer)
process.buildQuadLeptons += producer
# Embed the other collections
embedder_seq = helpers.cloneProcessingSnippet(process,
process.patFinalStatesEmbedObjects, producer_name)
process.buildQuadLeptons += embedder_seq
# Do some trickery so the final module has a nice output name
final_module_name = chain_sequence(embedder_seq, producer_name + "Raw")
final_module = getattr(process, final_module_name.value())
final_module.setLabel(producer_name)
setattr(process, producer_name, final_module)
output_commands.append("*_%s_*_*" % producer_name)
process.tuplize += process.buildQuadLeptons
# Tell the framework to shut up!
process.load("FWCore.MessageLogger.MessageLogger_cfi")
process.MessageLogger.cerr.FwkReport.reportEvery = 1000
return process.tuplize, output_commands
## import skeleton process
from PhysicsTools.PatAlgos.patTemplate_cfg import *
## switch to uncheduled mode
process.options.allowUnscheduled = cms.untracked.bool(True)
process.load("PhysicsTools.PatAlgos.producersLayer1.patCandidates_cff")
process.load("PhysicsTools.PatAlgos.selectionLayer1.selectedPatCandidates_cff")
process.load("PhysicsTools.PatUtils.patPFMETCorrections_cff")
from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection
switchJetCollection(
process,
jetSource=cms.InputTag("ak4PFJets"),
jetCorrections=("AK4PF", ["L1FastJet", "L2Relative", "L3Absolute"], ""),
)
# apply type I/type I + II PFMEt corrections to pat::MET object
# and estimate systematic uncertainties on MET
from PhysicsTools.PatUtils.tools.runType1PFMEtUncertainties import runType1PFMEtUncertainties
runType1PFMEtUncertainties(
process,
addToPatDefaultSequence=False,
jetCollection="selectedPatJets",
electronCollection="selectedPatElectrons",
muonCollection="selectedPatMuons",
tauCollection="selectedPatTaus",
)
runOnData( process )
# subsequent jet area calculations needed for L1FastJet on RECO jets
if useCaloJets and useL1FastJet:
if useRelVals:
process.ak5CaloJets = ak5CaloJets.clone( doAreaFastjet = True )
process.ak5JetID = ak5JetID.clone()
process.ak5CaloJetSequence = cms.Sequence(
process.ak5CaloJets
* process.ak5JetID
)
from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection
switchJetCollection( process
, cms.InputTag( jetAlgo.lower() + 'CaloJets' )
, doJTA = True
, doBTagging = True
, jetCorrLabel = ( jecSet, jecLevels )
, doType1MET = False
, genJetCollection = cms.InputTag( jetAlgo.lower() + 'GenJets' )
, doJetID = True
)
else:
print 'WARNING patRefSel_muJets_test_cfg.py:'
print ' L1FastJet JECs are not available for AK5Calo jets in this data due to missing jet area computation;'
print ' switching to L1Offset !!!'
jecLevelsCalo.insert( 0, 'L1Offset' )
jecLevelsCalo.remove( 'L1FastJet' )
process.patJetCorrFactors.levels = jecLevelsCalo
#process.patJetCorrFactors.useRho = False # FIXME: does not apply
if usePFJets:
if useL1FastJet:
process.ak5PFJets = ak5PFJets.clone( doAreaFastjet = True )
SelectEvents=cms.untracked.PSet(SelectEvents=cms.vstring('p')),
# save PAT Layer 1 output; you need a '*' to
# unpack the list of commands 'patEventContent'
dropMetaData=cms.untracked.string('DROPPED'),
outputCommands=cms.untracked.vstring('keep *'))
#####################################################
#--------------------------------------------------------------------------------
# produce PAT-tuple
process.load("PhysicsTools/PatAlgos/patSequences_cff")
# configure pat::Jet production
# (enable L2L3Residual corrections in case running on Data)
jetCorrections = ('L1FastJet', 'L2Relative', 'L3Absolute')
from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection
switchJetCollection(process,
jetSource=cms.InputTag('ak4PFJetsCHS'),
jetCorrections=('AK4PFchs', jetCorrections, ""),
outputModules=[])
#process.patJets.addTagInfos = cms.bool(True)
#process.patJets.addBTagInfo = cms.bool(True)
#--------------------------------------------------------------------------------
process.load(
"RecoTauTag.Configuration.RecoPFTauTag_cff") #loading the configuration
# switch to HPS PFTaus (and disable all "cleaning" cuts)
from PhysicsTools.PatAlgos.tools.tauTools import *
switchToPFTauHPS(process)
#process.ak4PFJetsLegacyHPSPiZeros.stripPhiAssociationDistance = cms.double(0.9)
# switch on PAT trigger
def configurePatTuple(process, isMC=True, **kwargs):
'''
Core function for PATTuple production
'''
#fix argparser output
isMC = bool(isMC)
########################
## ##
## PATTuple content ##
## ##
########################
# Stuff we always keep
output_commands = [
'*_addPileupInfo_*_*',
'edmMergeableCounter_*_*_*',
'*_lumiProducer_*_*',
'*_particleFlow_*_*',
'*_offlineBeamSpot_*_*',
'*_generalTracks_*_*',
'*_electronGsfTracks_*_*',
'*_gsfElectrons_*_*',
'*_gsfElectronCores_*_*',
'*_offlinePrimaryVertices*_*_*',
'*_ak5GenJets_*_*',
'*_hltTriggerSummaryAOD_*_*',
'edmTriggerResults_TriggerResults_*_%s' % process.name_(),
'*_MEtoEDMConverter*_*_%s' % process.name_(),
'LHEEventProduct_*_*_*',
'GenEventInfoProduct_generator_*_*',
'*_kt6PFJetsForRhoComputationVoronoi_rho_*',
'*_kt6PFJetsForIso_rho_*',
'*_kt6PFJets_rho_*',
'*_kt6PFJetsHZGPho_rho_*',
'*_kt6PFJetsCentralHZGEle_rho_*',
'*_kt6PFJetsCentralHZGMu_rho_*',
'*_kt6PFJetsCentralNeutralHZGMu_rho_*',
'*_kt6PFJetsCentral_rho_*',
'*_kt6PFJetsCentralNeutral_rho_*', # for zz muons
'*_photonCore_*_*',
'*_boostedFsrPhotons_*_*',
# for Zmumu -> embedded samples
# https://twiki.cern.ch/twiki/bin/view/CMS/MuonTauReplacementRecHit
'*_generalTracksORG_*_EmbeddedRECO',
'*_electronGsfTracksORG_*_EmbeddedRECO',
'double_TauSpinnerReco_TauSpinnerWT_EmbeddedSPIN',
'double_ZmumuEvtSelEffCorrWeightProducer_weight_EmbeddedRECO',
'double_muonRadiationCorrWeightProducer_weight_EmbeddedRECO',
'GenFilterInfo_generator_minVisPtFilter_EmbeddedRECO',
]
# Define our patTuple production sequence
process.tuplize = cms.Sequence()
# Only keep interesting genParticles
process.load("FinalStateAnalysis.RecoTools.genParticleTrimmer_cfi")
process.genParticles = process.prunedGenParticles.clone()
if isMC:
#process.tuplize += process.genParticles
#output_commands.append('*_genParticles_*_%s' % process.name_())
output_commands.append('*_genParticles_*_*')
output_commands.append('*_tauGenJetsSelectorAllHadrons_*_*')
output_commands.append('*_tauGenJets_*_*')
output_commands.append('*_ak5GenJets_*_*')
########################
## ##
## PAT ##
## ##
########################
# Run pat default sequence
process.load("PhysicsTools.PatAlgos.patSequences_cff")
# Embed PF Isolation in electrons & muons
pfTools.usePFIso(process)
# Setup H2Tau custom iso definitions
setup_h2tau_iso(process)
# Setup hZg custom iso definitions
add_hZg_iso_needs(process)
# Now run PAT
process.tuplize += process.patDefaultSequence
# Add FSR photons for ZZ analysis
process.load("FinalStateAnalysis.PatTools.fsrPhotons_cff")
process.tuplize += process.fsrPhotonSequence
########################
## GEN ##
########################
# Disable gen match embedding - we keep it in the ntuple
process.patMuons.embedGenMatch = False
process.patElectrons.embedGenMatch = False
process.patTaus.embedGenMatch = False
process.patTaus.embedGenJetMatch = False
process.patPhotons.embedGenMatch = False
if not isMC:
coreTools.runOnData(process)
########################
## MUONS ##
########################
# Unembed junk
process.patMuons.embedCaloMETMuonCorrs = False
process.patMuons.embedTcMETMuonCorrs = False
process.patMuons.embedTrack = True
process.patMuons.pvSrc = cms.InputTag("selectedPrimaryVertex")
process.load("FinalStateAnalysis.PatTools.patMuonProduction_cff")
final_muon_collection = chain_sequence(process.customizeMuonSequence,
"selectedPatMuons")
process.customizeMuonSequence.insert(0, process.selectedPatMuons)
process.patDefaultSequence.replace(process.selectedPatMuons,
process.customizeMuonSequence)
process.cleanPatMuons.src = final_muon_collection
process.patMuonRochesterCorrectionEmbedder.isMC = cms.bool(bool(isMC))
########################
## TAUS ##
########################
# Use HPS taus
tautools.switchToPFTauHPS(
process) #this NEEDS a sequence called patDefaultSequence
# Disable tau IsoDeposits
process.patDefaultSequence.remove(process.patPFTauIsolation)
process.patTaus.isoDeposits = cms.PSet()
process.patTaus.userIsolation = cms.PSet()
process.load("FinalStateAnalysis.PatTools.patTauProduction_cff")
# Require all taus to pass decay mode finding and have high PT
process.patTauGarbageRemoval.cut = cms.string(
"pt > 17 && abs(eta) < 2.5 && tauID('decayModeFindingNewDMs')")
final_tau_collection = chain_sequence(process.customizeTauSequence,
"selectedPatTaus")
# Inject into the pat sequence
process.customizeTauSequence.insert(0, process.selectedPatTaus)
process.patDefaultSequence.replace(process.selectedPatTaus,
process.customizeTauSequence)
process.cleanPatTaus.src = final_tau_collection
# Remove muons and electrons
process.cleanPatTaus.checkOverlaps.muons.requireNoOverlaps = False
process.cleanPatTaus.checkOverlaps.electrons.requireNoOverlaps = False
# Cuts already applied by the garbage removal
process.cleanPatTaus.preselection = ''
process.cleanPatTaus.finalCut = ''
########################
## ELECTRONS ##
########################
# Use POG recommendations for (these) electron Isos
process.elPFIsoValueGamma04PFIdPFIso.deposits[0].vetos = cms.vstring(
'EcalEndcaps:ConeVeto(0.08)')
process.elPFIsoValueGamma04NoPFIdPFIso.deposits[0].vetos = cms.vstring(
'EcalEndcaps:ConeVeto(0.08)')
process.elPFIsoValueCharged04PFIdPFIso.deposits[0].vetos = cms.vstring(
'EcalEndcaps:ConeVeto(0.015)')
process.elPFIsoValueCharged04NoPFIdPFIso.deposits[0].vetos = cms.vstring(
'EcalEndcaps:ConeVeto(0.015)')
# Do extra electron ID
process.load("FinalStateAnalysis.PatTools.electrons.electronID_cff")
if cmssw_major_version() == 4:
process.patDefaultSequence.replace(
process.patElectrons,
process.recoElectronID42X + process.patElectrons)
process.patElectrons.electronIDSources = process.electronIDSources42X
else:
process.patDefaultSequence.replace(
process.patElectrons,
process.recoElectronID5YX + process.patElectrons)
process.patElectrons.electronIDSources = process.electronIDSources5YX
process.electronMatch.checkCharge = cms.bool(False)
process.patElectrons.embedTrack = False
process.patElectrons.embedPFCandidate = False
process.patElectrons.embedGsfElectronCore = False
process.patElectrons.embedSuperCluster = True
# Produce the electron collections
process.load("FinalStateAnalysis.PatTools.patElectronProduction_cff")
# Electron Energy Regression and Calibrations
process.load(
"EgammaAnalysis.ElectronTools.electronRegressionEnergyProducer_cfi")
process.load("EgammaAnalysis.ElectronTools.calibratedPatElectrons_cfi")
#setup the energy regression for the specific dataset
if kwargs['eleReg']:
print "-- Applying Electron Regression and Calibration --"
process.customizeElectronSequence += process.eleRegressionEnergy
process.customizeElectronSequence += process.calibratedPatElectrons
process.eleRegressionEnergy.energyRegressionType = cms.uint32(2)
process.calibratedPatElectrons.correctionsType = cms.int32(2)
if isMC:
process.calibratedPatElectrons.inputDataset = cms.string(
"Summer12_LegacyPaper")
else:
process.calibratedPatElectrons.inputDataset = cms.string(
"22Jan2013ReReco")
process.calibratedPatElectrons.combinationType = cms.int32(3)
process.calibratedPatElectrons.lumiRatio = cms.double(1.0)
process.calibratedPatElectrons.synchronization = cms.bool(True)
process.calibratedPatElectrons.isMC = cms.bool(isMC == 1)
process.calibratedPatElectrons.verbose = cms.bool(False)
final_electron_collection = chain_sequence(
process.customizeElectronSequence,
"selectedPatElectrons",
# Some of the EGamma modules have non-standard src InputTags,
# specify them here.
("src", "inputPatElectronsTag", "inputElectronsTag"))
#process.tuplize += process.customizeElectronSequence #why do we need this?
process.customizeElectronSequence.insert(0, process.selectedPatElectrons)
process.patDefaultSequence.replace(process.selectedPatElectrons,
process.customizeElectronSequence)
# We have to do the pat Jets before the pat electrons since we embed them
process.customizeElectronSequence.insert(0, process.selectedPatJets)
# Define cleanPatElectrons input collection
process.cleanPatElectrons.src = final_electron_collection
# Define the default lepton cleaning
process.cleanPatElectrons.preselection = cms.string('pt > 5')
process.cleanPatElectrons.checkOverlaps.muons.requireNoOverlaps = False
# Make sure we don't kill any good taus by calling them electrons
# Note that we don't actually remove these overlaps.
process.cleanPatElectrons.checkOverlaps.taus = cms.PSet(
src=final_tau_collection,
algorithm=cms.string("byDeltaR"),
preselection=cms.string(
"tauID('decayModeFinding') > 0.5 &&"
"tauID('byLooseCombinedIsolationDeltaBetaCorr') > 0.5 &&"
"tauID('againstElectronLoose') > 0.5 && "
"pt > 10"),
deltaR=cms.double(0.1),
checkRecoComponents=cms.bool(False),
pairCut=cms.string(""),
requireNoOverlaps=cms.bool(False),
)
########################
## JETS ##
########################
# Use PFJets and turn on JEC
jec = ['L1FastJet', 'L2Relative', 'L3Absolute']
# If we are running on data (not MC), or embedded sample,
# apply the MC-DATA residual correction.
if not isMC or kwargs['embedded']:
jec.extend(['L2L3Residual'])
# tmp
# define the b-tag squences for offline reconstruction
process.load("RecoBTag.SecondaryVertex.secondaryVertex_cff")
process.load("RecoBTau.JetTagComputer.combinedMVA_cff")
process.load('RecoVertex/AdaptiveVertexFinder/inclusiveVertexing_cff')
process.load('RecoBTag/SecondaryVertex/bToCharmDecayVertexMerger_cfi')
#process.load("PhysicsTools.PatAlgos.patSequences_cff")
# Define options for BTagging - these are release dependent.
btag_options = {'doBTagging': True}
if cmssw_major_version() == 5:
btag_options['btagInfo'] = [
'impactParameterTagInfos', 'secondaryVertexTagInfos',
'softMuonTagInfos', 'secondaryVertexNegativeTagInfos',
'inclusiveSecondaryVertexFinderFilteredTagInfos'
]
btag_options['btagdiscriminators'] = [
'trackCountingHighEffBJetTags',
'trackCountingHighPurBJetTags',
'simpleSecondaryVertexHighEffBJetTags',
'simpleSecondaryVertexHighPurBJetTags',
'simpleInclusiveSecondaryVertexHighEffBJetTags',
'simpleInclusiveSecondaryVertexHighPurBJetTags',
'combinedSecondaryVertexMVABJetTags',
'combinedSecondaryVertexBJetTags',
'jetBProbabilityBJetTags',
'jetProbabilityBJetTags',
]
#Avoid embedding
process.patJets.embedPFCandidates = True
process.patJets.embedCaloTowers = False
process.patJets.embedGenJetMatch = True
process.patJets.addAssociatedTracks = True
process.patJets.embedGenPartonMatch = True
# Add AK5chs PFJets
jettools.addJetCollection(process,
cms.InputTag('ak5PFchsJets'),
algoLabel="AK5",
typeLabel="PFchs",
doJTA=True,
jetCorrLabel=('AK5PFchs', jec),
doType1MET=False,
doL1Cleaning=False,
doL1Counters=False,
genJetCollection=cms.InputTag('ak5GenJets'),
doJetID=True,
**btag_options)
# Use AK5 PFJets
jettools.switchJetCollection(
process,
cms.InputTag('ak5PFJets'),
doJTA=True,
jetCorrLabel=('AK5PF', jec),
#jetCorrLabel = None,
doType1MET=False,
doJetID=True,
genJetCollection=cms.InputTag("ak5GenJets"),
**btag_options)
# Customize/embed all our sequences
process.load("FinalStateAnalysis.PatTools.patJetProduction_cff")
helpers.cloneProcessingSnippet(process, process.customizeJetSequence,
'AK5PFchs')
process.patJetGarbageRemoval.cut = 'pt > 12'
final_jet_collection = chain_sequence(process.customizeJetSequence,
"patJets")
process.customizeJetSequence.insert(0, process.patJets)
# Make it a "complete" sequence
process.customizeJetSequence += process.selectedPatJets
# process.customizeJetSequence += process.btagging
# We can't mess up the selected pat jets because the taus use them.
process.selectedPatJets.src = final_jet_collection
process.patDefaultSequence.replace(process.patJets,
process.customizeJetSequence)
process.customizeJetSequenceAK5PFchs.remove(process.patJetsPUIDAK5PFchs)
process.customizeJetSequenceAK5PFchs.remove(
process.pileupJetIdProducerAK5PFchs)
process.patJetGarbageRemovalAK5PFchs.cut = 'pt > 20'
process.patJetCorrFactorsAK5PFchs.payload = cms.string('AK5PFchs')
final_jetchs_collection = chain_sequence(
process.customizeJetSequenceAK5PFchs, "patJetsAK5PFchs")
process.customizeJetSequenceAK5PFchs.insert(0, process.patJetsAK5PFchs)
# Make it a "complete" sequence
process.customizeJetSequenceAK5PFchs += process.selectedPatJetsAK5PFchs
# We can't mess up the selected pat jets because the taus use them.
process.selectedPatJetsAK5PFchs.src = final_jetchs_collection
process.selectedPatJetsAK5chsPF = process.selectedPatJetsAK5PFchs.clone(
) #that's what we keep
process.customizeJetSequenceAK5PFchs += process.selectedPatJetsAK5chsPF
process.patDefaultSequence.replace(process.patJetsAK5PFchs,
process.customizeJetSequenceAK5PFchs)
output_commands.append('*_selectedPatJets_*_*')
output_commands.append('*_selectedPatJetsAK5chsPF_*_*')
output_commands.append('*SecondaryVertexTagInfo*_*_*_*')
output_commands.append('*TrackIPTagInfo*_*_*_*')
output_commands.append('*SoftLeptonTagInfo*_*_*_*')
output_commands.append('*_ak5PFJets_*_*')
output_commands.append('*_ak5PFchsJets_*_*')
########################
## MET ##
########################
# Use PFMEt
mettools.addPfMET(process)
# We cut out a lot of the junky taus and jets - but we need these
# to correctly apply the MET uncertainties. So, let's make a
# non-cleaned version of the jet and tau sequence.
process.jetsForMetSyst = helpers.cloneProcessingSnippet(
process, process.customizeJetSequence, 'ForMETSyst')
process.tausForMetSyst = helpers.cloneProcessingSnippet(
process, process.customizeTauSequence, 'ForMETSyst')
# Don't apply any cut for these
process.patTauGarbageRemovalForMETSyst.cut = ''
process.patJetGarbageRemovalForMETSyst.cut = ''
process.tuplize += process.jetsForMetSyst
process.tuplize += process.tausForMetSyst
# We have to make our clone of cleanPatTaus separately, since e/mu
# cleaning is applied - therefore it isn't in the customizeTausSequence.
process.cleanPatTausForMETSyst = process.cleanPatTaus.clone(
src=cms.InputTag(process.cleanPatTaus.src.value() + "ForMETSyst"))
process.cleanPatTausForMETSyst.preselection = ''
process.cleanPatTausForMETSyst.finalCut = ''
process.patTausEmbedJetInfoForMETSyst.jetSrc = \
final_jet_collection.value() + "ForMETSyst"
process.tuplize += process.cleanPatTausForMETSyst
# Setup MET production
process.load("FinalStateAnalysis.PatTools.patMETProduction_cff")
# The MET systematics depend on all other systematics
process.systematicsMET.tauSrc = cms.InputTag("cleanPatTausForMETSyst")
process.systematicsMET.muonSrc = cms.InputTag("cleanPatMuons")
process.systematicsMET.electronSrc = cms.InputTag("cleanPatElectrons")
final_met_collection = chain_sequence(process.customizeMETSequence,
"patMETsPF")
process.tuplize += process.customizeMETSequence
process.patMETsPF.addGenMET = bool(isMC)
output_commands.append('*_%s_*_*' % final_met_collection.value())
# Make a version with the MVA MET reconstruction method
process.load("FinalStateAnalysis.PatTools.met.mvaMetOnPatTuple_cff")
process.tuplize += process.pfMEtMVAsequence
mva_met_sequence = helpers.cloneProcessingSnippet(
process, process.customizeMETSequence, "MVA")
final_mvamet_collection = chain_sequence(mva_met_sequence, "patMEtMVA")
process.tuplize += mva_met_sequence
output_commands.append('*_%s_*_*' % final_mvamet_collection.value())
# Keep all the data formats needed for the systematics
output_commands.append('recoLeafCandidates_*_*_%s' % process.name_())
# We can drop to jet and tau MET specific products. They were only used for
# computation of the MET numbers.
output_commands.append('drop recoLeafCandidates_*ForMETSyst_*_%s' %
process.name_())
########################
## PHOTONS ##
########################
#alter the photon matching to accept various fakes
# and sort matches by d-pt-rel
if isMC:
process.photonMatch = cms.EDProducer(
"MCMatcherByPt",
src=cms.InputTag("photons"),
maxDPtRel=cms.double(100.0),
mcPdgId=cms.vint32(),
mcStatus=cms.vint32(1),
resolveByMatchQuality=cms.bool(False),
maxDeltaR=cms.double(0.3),
checkCharge=cms.bool(False),
resolveAmbiguities=cms.bool(True),
matched=cms.InputTag("genParticles"))
# Setup pat::Photon Production
process.load("FinalStateAnalysis.PatTools.patPhotonProduction_cff")
final_photon_collection = chain_sequence(process.customizePhotonSequence,
"selectedPatPhotons")
#setup PHOSPHOR for a specific dataset
if cmssw_major_version() == 4: # for now 2011 = CMSSW42X
process.patPhotonPHOSPHOREmbedder.year = cms.uint32(2011)
else: # 2012 is 5YX
process.patPhotonPHOSPHOREmbedder.year = cms.uint32(2012)
process.patPhotonPHOSPHOREmbedder.isMC = cms.bool(bool(isMC))
#inject photons into pat sequence
process.customizePhotonSequence.insert(0, process.selectedPatPhotons)
process.patDefaultSequence.replace(process.selectedPatPhotons,
process.customizePhotonSequence)
process.cleanPatPhotons.src = final_photon_collection
########################
## TRIGGER ##
########################
trigtools.switchOnTrigger(process)
#configure the PAT trigger
if kwargs['HLTprocess']:
process.patTrigger.processName = cms.string(kwargs['HLTprocess'])
process.patTriggerEvent.processName = cms.string(kwargs['HLTprocess'])
########################
## -------------- ##
########################
output_commands.append('*_cleanPatTaus_*_*')
output_commands.append('*_cleanPatElectrons_*_*')
output_commands.append('*_cleanPatMuons_*_*')
output_commands.append('*_cleanPatPhotons_*_*')
########################
## ##
## FSA ##
## ##
########################
# Now build the PATFinalStateLS object, which holds LumiSection info.
process.load(
"FinalStateAnalysis.PatTools.finalStates.patFinalStateLSProducer_cfi")
process.tuplize += process.finalStateLS
output_commands.append('*_finalStateLS_*_*')
if isMC:
process.finalStateLS.xSec = kwargs['xSec']
# Tell the framework to shut up!
process.load("FWCore.MessageLogger.MessageLogger_cfi")
process.MessageLogger.cerr.FwkReport.reportEvery = 1000
# Which collections are used to build the final states
fs_daughter_inputs = {
'electrons': 'cleanPatElectrons',
'muons': 'cleanPatMuons',
'taus': 'cleanPatTaus',
'photons': 'cleanPatPhotons',
'jets': 'selectedPatJets',
'pfmet': final_met_collection,
'mvamet': final_mvamet_collection,
}
# Setup all the PATFinalState objects
produce_final_states(process,
fs_daughter_inputs,
output_commands,
process.tuplize,
kwargs['puTag'],
zzMode=kwargs.get('zzMode', False))
return process.tuplize, output_commands
def addInvHiggsProcess(
process,
iRunOnData=True,
iData="ParkedData",
iHLTFilter="MET",
iMCSignal=False,
iFile='/store/data/Run2012C/VBF1Parked/AOD/22Jan2013-v1/20000/40F56410-D979-E211-9843-002618943849.root',
iMaxEvent=100):
###--------------------------------------------------------------
### Load PAT, because it insists on defining the process for you
#from PhysicsTools.PatAlgos.patTemplate_cfg import *
###--------------------------------------------------------------
###--------------------------------------------------------------
### Input
process.maxEvents.input = iMaxEvent
process.source.fileNames = [iFile]
###--------------------------------------------------------------
###--------------------------------------------------------------
### GlobalTag
if iRunOnData == True:
process.GlobalTag.globaltag = "FT53_V21A_AN6::All"
else:
process.GlobalTag.globaltag = "START53_V27::All"
###--------------------------------------------------------------
###--------------------------------------------------------------
### Logger
process.load("FWCore.MessageService.MessageLogger_cfi")
process.load("FWCore.MessageLogger.MessageLogger_cfi")
process.MessageLogger.cerr.FwkReport = cms.untracked.PSet(
reportEvery=cms.untracked.int32(2000),
limit=cms.untracked.int32(10000000))
###--------------------------------------------------------------
###--------------------------------------------------------------
### L1 Trigger
process.load('L1Trigger.Skimmer.l1Filter_cfi')
process.l1Filter.algorithms = cms.vstring('L1_ETM40')
###--------------------------------------------------------------
###--------------------------------------------------------------
### HLT Trigger(s)
# If it's MC signal, no trigger will be applied
if iRunOnData == False and iMCSignal == True:
iHLTFilter = "NoTrig"
# Load hltHighLevel
process.load('HLTrigger.HLTfilters.hltHighLevel_cfi')
process.hltHighLevel.TriggerResultsTag = cms.InputTag(
"TriggerResults", "", "HLT")
process.hltHighLevel.throw = cms.bool(
False) # Tolerate if triggers not available
process.hltHighLevel.andOr = cms.bool(True) # True = OR, False = AND
if (iRunOnData == True and iHLTFilter.find("MET") == 0):
process.hltHighLevel.HLTPaths = cms.vstring(
#"HLT_DiPFJet40_PFMETnoMu65_MJJ600VBF_LeadingJets_v*",
#"HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v*"
"HLT_DiJet35_MJJ700_AllJets_DEta3p5_VBF_v*",
"HLT_DiJet30_MJJ700_AllJets_DEta3p5_VBF_v*")
elif (iHLTFilter.find("SingleMu") == 0):
process.hltHighLevel.HLTPaths = cms.vstring("HLT_IsoMu24_eta2p1_v*",
"HLT_Mu40_eta2p1_v*")
#elif (iHLTFilter.find("DoubleMu")==0):
# process.hltHighLevel.HLTPaths = cms.vstring("HLT_Mu17_Mu8_v*")
#elif (iHLTFilter.find("SingleElectron")==0):
# process.hltHighLevel.HLTPaths = cms.vstring("HLT_Ele27_WP80_v*")
#elif (iHLTFilter.find("DoubleElectron")==0):
# process.hltHighLevel.HLTPaths = cms.vstring("HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v*")
elif (iHLTFilter.find("NoTrig") == 0):
process.hltHighLevel.HLTPaths = cms.vstring("*")
else:
process.hltHighLevel.HLTPaths = cms.vstring(
#"HLT_DiPFJet40_PFMETnoMu65_MJJ600VBF_LeadingJets_v*",
#"HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v*"
"HLT_DiJet35_MJJ700_AllJets_DEta3p5_VBF_v*",
"HLT_DiJet30_MJJ700_AllJets_DEta3p5_VBF_v*")
### VBF filter for MC Background
process.vbfFilter = cms.EDFilter("HLTPFJetVBFFilter",
saveTags=cms.bool(True),
triggerType=cms.int32(85),
inputTag=cms.InputTag("ak5PFJets"),
leadingJetOnly=cms.bool(False),
minPtHigh=cms.double(25.0),
minPtLow=cms.double(25.0),
maxEta=cms.double(5.0),
etaOpposite=cms.bool(True),
minDeltaEta=cms.double(3.0),
minInvMass=cms.double(500.0))
###--------------------------------------------------------------
###--------------------------------------------------------------
print "-----------------------------------------------"
print "INVISIBLE HIGGS: Ntuple V12 for Parked Data"
print "-----------------------------------------------"
print "RunOnData = ", iRunOnData
if iRunOnData == True:
print "Dataset = ", iData
else:
if iMCSignal == True:
print "Dataset = MC Signal or DYNoTrig"
else:
print "Dataset = MC Background"
print "GlobalTag = ", process.GlobalTag.globaltag
print "Trigger = ", process.hltHighLevel.HLTPaths
print "Sample input file = ", iFile
print "Max events = ", iMaxEvent
print "-----------------------------------------------"
###--------------------------------------------------------------
###--------------------------------------------------------------
### Basic filters
# Track quality filter
process.noscraping = cms.EDFilter("FilterOutScraping",
applyfilter=cms.untracked.bool(True),
debugOn=cms.untracked.bool(False),
numtrack=cms.untracked.uint32(10),
thresh=cms.untracked.double(0.25))
# Require a good 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))
###--------------------------------------------------------------
###--------------------------------------------------------------
### MET Filters
# The iso-based HBHE noise filter
process.load('CommonTools.RecoAlgos.HBHENoiseFilter_cfi')
# The CSC beam halo tight filter
process.load('RecoMET.METAnalyzers.CSCHaloFilter_cfi')
# The HCAL laser filter
process.load("RecoMET.METFilters.hcalLaserEventFilter_cfi")
#process.load("EventFilter.HcalRawToDigi.hcallasereventfilter2012_cff")
#process.hcallasereventfilter2012.eventFileName = cms.string('HCALLaser2012AllDatasets.txt.gz')
process.load(
"EventFilter.HcalRawToDigi.hcallaserFilterFromTriggerResult_cff")
# The ECAL dead cell trigger primitive filter
process.load('RecoMET.METFilters.EcalDeadCellTriggerPrimitiveFilter_cfi')
# The EE bad SuperCrystal filter
process.load('RecoMET.METFilters.eeBadScFilter_cfi')
# The ECAL laser correction filter
process.load('RecoMET.METFilters.ecalLaserCorrFilter_cfi')
# The Good vertices collection needed by the tracking failure filter
process.goodVertices = cms.EDFilter(
"VertexSelector",
filter=cms.bool(False),
src=cms.InputTag("offlinePrimaryVertices"),
cut=cms.string(
"!isFake && ndof > 4 && abs(z) <= 24 && position.rho < 2"))
# The tracking failure filter
process.load('RecoMET.METFilters.trackingFailureFilter_cfi')
# The tracking POG filters
process.load('RecoMET.METFilters.trackingPOGFilters_cff')
###--------------------------------------------------------------
###--------------------------------------------------------------
### customise PAT
process.load('JetMETCorrections.Configuration.DefaultJEC_cff')
from PhysicsTools.PatAlgos.tools.coreTools import removeMCMatching, runOnData
if iRunOnData == True:
removeMCMatching(process, ['All'])
runOnData(process)
# Add the PF MET
from PhysicsTools.PatAlgos.tools.metTools import addPfMET
addPfMET(process, 'PF')
# Switch to PF jets
from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection
if iRunOnData == True:
switchJetCollection(process,
cms.InputTag('ak5PFJets'),
doJTA=True,
doBTagging=False,
jetCorrLabel=('AK5PF', [
'L1FastJet', 'L2Relative', 'L3Absolute',
'L2L3Residual'
]),
doType1MET=True,
genJetCollection=cms.InputTag("ak5GenJets"),
doJetID=False,
jetIdLabel="ak5")
else:
switchJetCollection(
process,
cms.InputTag('ak5PFJets'),
doJTA=True,
doBTagging=False,
jetCorrLabel=('AK5PF', ['L1FastJet', 'L2Relative', 'L3Absolute']),
doType1MET=True,
genJetCollection=cms.InputTag("ak5GenJets"),
doJetID=False,
jetIdLabel="ak5")
from PhysicsTools.PatAlgos.tools.pfTools import usePFIso
usePFIso(process)
process.patMuons.isoDeposits = cms.PSet()
process.patMuons.isolationValues = cms.PSet()
process.patElectrons.isolationValues = cms.PSet(
pfChargedHadrons=cms.InputTag("elPFIsoValueCharged03PFIdPFIso"),
pfChargedAll=cms.InputTag("elPFIsoValueChargedAll03PFIdPFIso"),
pfPUChargedHadrons=cms.InputTag("elPFIsoValuePU03PFIdPFIso"),
pfNeutralHadrons=cms.InputTag("elPFIsoValueNeutral03PFIdPFIso"),
pfPhotons=cms.InputTag("elPFIsoValueGamma03PFIdPFIso"))
process.patElectrons.isolationValuesNoPFId = cms.PSet(
pfChargedHadrons=cms.InputTag("elPFIsoValueCharged03NoPFIdPFIso"),
pfChargedAll=cms.InputTag("elPFIsoValueChargedAll03NoPFIdPFIso"),
pfPUChargedHadrons=cms.InputTag("elPFIsoValuePU03NoPFIdPFIso"),
pfNeutralHadrons=cms.InputTag("elPFIsoValueNeutral03NoPFIdPFIso"),
pfPhotons=cms.InputTag("elPFIsoValueGamma03NoPFIdPFIso"))
process.patDefaultSequence.replace(
process.patElectrons, process.eleIsoSequence + process.patElectrons)
process.cleanPatTaus.preselection = cms.string(
'tauID("decayModeFinding") > 0.5 & tauID("byLooseCombinedIsolationDeltaBetaCorr") > 0.5'
)
###--------------------------------------------------------------
###--------------------------------------------------------------
### Object (pre) selection
# Jet selection
process.selectedPatJets.cut = cms.string("pt>10. && abs(eta)<5.")
# Remove overlaps ???
# process.cleanPatJets.finalCut = "!hasOverlaps('electrons') && !hasOverlaps('muons')"
# Apply loose PF jet ID
from PhysicsTools.SelectorUtils.pfJetIDSelector_cfi import pfJetIDSelector
process.goodPatJets = cms.EDFilter("PFJetIDSelectionFunctorFilter",
filterParams=pfJetIDSelector.clone(),
src=cms.InputTag("selectedPatJets"),
filter=cms.bool(True))
process.selectedPatMuons.cut = cms.string(
"isGlobalMuon && pt>10. && abs(eta)<2.5")
process.selectedPatElectrons.cut = cms.string("pt>10. && abs(eta)<2.5")
###--------------------------------------------------------------
###--------------------------------------------------------------
### Load the PU JetID sequence
if iRunOnData == True:
process.load("CMGTools.External.pujetidsequence_cff")
process.puJetMva.jets = cms.InputTag("goodPatJets")
process.puJetId.jets = cms.InputTag("goodPatJets")
else:
process.load("CMGTools.External.pujetidsequence_cff")
process.puJetMva.jets = cms.InputTag("goodPatJets")
process.puJetId.jets = cms.InputTag("goodPatJets")
process.puJetMvaSmeared = process.puJetMva.clone()
process.puJetIdSmeared = process.puJetId.clone()
process.puJetMvaResUp = process.puJetMva.clone()
process.puJetIdResUp = process.puJetId.clone()
process.puJetMvaResDown = process.puJetMva.clone()
process.puJetIdResDown = process.puJetId.clone()
process.puJetMvaEnUp = process.puJetMva.clone()
process.puJetIdEnUp = process.puJetId.clone()
process.puJetMvaEnDown = process.puJetMva.clone()
process.puJetIdEnDown = process.puJetId.clone()
process.puJetIdSmeared.jets = cms.InputTag("smearedGoodPatJets")
process.puJetMvaSmeared.jetids = cms.InputTag("puJetIdSmeared")
process.puJetMvaSmeared.jets = cms.InputTag("smearedGoodPatJets")
process.puJetIdResUp.jets = cms.InputTag("smearedGoodPatJetsResUp")
process.puJetMvaResUp.jetids = cms.InputTag("puJetIdResUp")
process.puJetMvaResUp.jets = cms.InputTag("smearedGoodPatJetsResUp")
process.puJetIdResDown.jets = cms.InputTag("smearedGoodPatJetsResDown")
process.puJetMvaResDown.jetids = cms.InputTag("puJetIdResDown")
process.puJetMvaResDown.jets = cms.InputTag(
"smearedGoodPatJetsResDown")
process.puJetIdEnUp.jets = cms.InputTag(
"shiftedGoodPatJetsEnUpForCorrMEt")
process.puJetMvaEnUp.jetids = cms.InputTag("puJetIdEnUp")
process.puJetMvaEnUp.jets = cms.InputTag(
"shiftedGoodPatJetsEnUpForCorrMEt")
process.puJetIdEnDown.jets = cms.InputTag(
"shiftedGoodPatJetsEnDownForCorrMEt")
process.puJetMvaEnDown.jetids = cms.InputTag("puJetIdEnDown")
process.puJetMvaEnDown.jets = cms.InputTag(
"shiftedGoodPatJetsEnDownForCorrMEt")
###--------------------------------------------------------------
###--------------------------------------------------------------
### MET
# Apply type 0 MET corrections based on PFCandidate
process.load("JetMETCorrections.Type1MET.pfMETCorrectionType0_cfi")
process.pfType1CorrectedMet.applyType0Corrections = cms.bool(False)
process.pfType1CorrectedMet.srcType1Corrections = cms.VInputTag(
cms.InputTag('pfMETcorrType0'), cms.InputTag('pfJetMETcorr', 'type1'))
# Get loose ID/Iso muons and veto ID electrons
process.load("InvisibleHiggs.Ntuple.PhysicsObjectCandidates_cff")
# Get PFMET from runMEtUncertainties
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
process.load("JetMETCorrections.Type1MET.pfMETsysShiftCorrections_cfi")
if iRunOnData == True:
runMEtUncertainties(
process,
electronCollection=cms.InputTag('selectVetoElectrons'),
photonCollection='',
muonCollection='selectLooseMuons',
tauCollection='',
jetCollection=cms.InputTag('goodPatJets'),
jetCorrLabel='L2L3Residual',
doSmearJets=False,
makeType1corrPFMEt=True,
makeType1p2corrPFMEt=False,
makePFMEtByMVA=False,
makeNoPileUpPFMEt=False,
doApplyType0corr=True,
sysShiftCorrParameter=process.
pfMEtSysShiftCorrParameters_2012runAvsNvtx_data,
doApplySysShiftCorr=False,
addToPatDefaultSequence=False,
)
process.patPFJetMETtype1p2Corr.jetCorrLabel = cms.string(
'L2L3Residual')
process.patPFJetMETtype2Corr.jetCorrLabel = cms.string('L2L3Residual')
else:
runMEtUncertainties(
process,
electronCollection=cms.InputTag('selectVetoElectrons'),
photonCollection='',
muonCollection='selectLooseMuons',
tauCollection='',
jetCollection=cms.InputTag('goodPatJets'),
jetCorrLabel='L3Absolute',
doSmearJets=True,
makeType1corrPFMEt=True,
makeType1p2corrPFMEt=False,
makePFMEtByMVA=False,
makeNoPileUpPFMEt=False,
doApplyType0corr=True,
sysShiftCorrParameter=process.
pfMEtSysShiftCorrParameters_2012runAvsNvtx_mc,
doApplySysShiftCorr=False,
addToPatDefaultSequence=False,
)
# Fix Type0 correction module
#process.patPFMETtype0Corr.correction.par3 = cms.double(0.909209)
#process.patPFMETtype0Corr.correction.par2 = cms.double(0.0303531)
#process.patPFMETtype0Corr.correction.par1 = cms.double(-0.703151)
#process.patPFMETtype0Corr.correction.par0 = cms.double(0.0)
# Need this line for CMSSW_5_3_11
process.producePatPFMETCorrections.replace(
process.patPFJetMETtype2Corr, process.patPFJetMETtype2Corr +
process.type0PFMEtCorrectionPFCandToVertexAssociation +
process.patPFMETtype0Corr)
#process.producePatPFMETCorrections.replace(process.patPFJetMETtype2Corr,process.patPFJetMETtype2Corr + process.patPFMETtype0Corr)
###--------------------------------------------------------------
# PAT/ntuples one step
# Z and W candidates
process.load('InvisibleHiggs/Ntuple/WCandidates_cff')
process.load('InvisibleHiggs/Ntuple/ZCandidates_cff')
# Ntuple producer
process.load('InvisibleHiggs/Ntuple/invHiggsInfo_cfi')
if iRunOnData == False:
# Jet/MET uncertainty
process.invHiggsInfo.jetTag = cms.untracked.InputTag(
"smearedGoodPatJets")
process.invHiggsInfo.metTag = cms.untracked.InputTag(
"patType1CorrectedPFMet")
process.invHiggsInfo.puJetMvaTag = cms.untracked.InputTag(
"puJetMvaSmeared", "full53xDiscriminant")
process.invHiggsInfo.puJetIdTag = cms.untracked.InputTag(
"puJetMvaSmeared", "full53xId")
# PU re-weighting
process.invHiggsInfo.puMCFile = cms.untracked.string("PUHistS10.root")
process.invHiggsInfo.puDataFile = cms.untracked.string(
"PUHistRun2012All_forParked.root")
process.invHiggsInfo.puMCHist = cms.untracked.string("pileup")
process.invHiggsInfo.puDataHist = cms.untracked.string("pileup")
process.invHiggsInfo.mcPYTHIA = cms.untracked.bool(True)
process.invHiggsInfo.trigCorrFile = cms.untracked.string(
"DataMCWeight_53X_v1.root")
# TTree output file
process.load("CommonTools.UtilAlgos.TFileService_cfi")
process.TFileService.fileName = cms.string('invHiggsInfo.root')
###--------------------------------------------------------------
###--------------------------------------------------------------
### Tau
# removeSpecificPATObjects( process, ['Taus'] )
# process.patDefaultSequence.remove( process.patTaus )
process.load("RecoTauTag.Configuration.RecoPFTauTag_cff")
###--------------------------------------------------------------
###--------------------------------------------------------------
### Trigger matching
# from PhysicsTools.PatAlgos.tools.trigTools import *
# process.metTriggerMatch = cms.EDProducer(
# "PATTriggerMatcherDRLessByR" # match by DeltaR only, best match by DeltaR
# , src = cms.InputTag( 'patMETs' )
# , matched = cms.InputTag( 'patTrigger' ) # default producer label as defined in PhysicsTools/PatAlgos/python/triggerLayer1/triggerProducer_cfi.py
# , matchedCuts = cms.string( 'path( "HLT_MET100_v*" )' )
# , maxDPtRel = cms.double( 0.5 )
# , maxDeltaR = cms.double( 0.5 )
# , resolveAmbiguities = cms.bool( True ) # only one match per trigger object
# , resolveByMatchQuality = cms.bool( True ) # take best match found per reco object: by DeltaR here (s. above)
# )
# process.jetTriggerMatch = cms.EDProducer(
# "PATTriggerMatcherDRLessByR" # match by DeltaR only, best match by DeltaR
# , src = cms.InputTag( 'patJets' )
# , matched = cms.InputTag( 'patTrigger' ) # default producer label as defined in PhysicsTools/PatAlgos/python/triggerLayer1/triggerProducer_cfi.py
# , matchedCuts = cms.string( 'path( "HLT_Jet30_v*" )' )
# , maxDPtRel = cms.double( 0.5 )
# , maxDeltaR = cms.double( 0.5 )
# , resolveAmbiguities = cms.bool( True ) # only one match per trigger object
# , resolveByMatchQuality = cms.bool( True ) # take best match found per reco object: by DeltaR here (s. above)
# )
# switchOnTriggerMatchEmbedding( process, [ 'metTriggerMatch', 'jetTriggerMatch' ] )
###--------------------------------------------------------------
###--------------------------------------------------------------
### Paths
process.p0 = cms.Path(process.HBHENoiseFilter)
process.p1 = cms.Path(process.CSCTightHaloFilter)
process.p2 = cms.Path(process.hcalLaserEventFilter)
process.p3 = cms.Path(process.EcalDeadCellTriggerPrimitiveFilter)
process.p4 = cms.Path(process.eeBadScFilter)
process.p5 = cms.Path(process.ecalLaserCorrFilter)
process.p6 = cms.Path(process.goodVertices * process.trackingFailureFilter)
process.p7 = cms.Path(process.trkPOGFilters)
if iRunOnData == True:
#process.p8 = cms.Path( process.hcallLaserEvent2012Filter )
process.p8 = cms.Path(process.hcalfilter)
else:
process.p8 = cms.Path(process.primaryVertexFilter)
if iRunOnData == True:
process.p = cms.Path(
# Trigger filter
process.l1Filter * process.hltHighLevel *
# Basic filters
process.noscraping * process.primaryVertexFilter *
# MET filters (Move to be flagged)
# MET Correction
process.type0PFMEtCorrection *
# Tau
process.recoTauClassicHPSSequence *
# Generate PAT
process.pfParticleSelectionSequence * process.patDefaultSequence *
process.goodPatJets * process.PhysicsObjectSequence *
process.metUncertaintySequence * process.puJetIdSqeuence *
process.WSequence * process.ZSequence * process.invHiggsInfo)
elif (iMCSignal == True):
process.p = cms.Path(
# Trigger filter
#process.hltHighLevel *
# Basic filters
process.noscraping * process.primaryVertexFilter *
# MET filters (Move to be flags)
# MET Correction
process.type0PFMEtCorrection *
# Tau
process.recoTauClassicHPSSequence *
# Generate PAT
process.pfParticleSelectionSequence * process.patDefaultSequence *
process.goodPatJets * process.PhysicsObjectSequence *
process.metUncertaintySequence * process.puJetIdSqeuence *
process.puJetIdSmeared * process.puJetMvaSmeared *
process.puJetIdResUp * process.puJetMvaResUp *
process.puJetIdResDown * process.puJetMvaResDown *
process.puJetIdEnUp * process.puJetMvaEnUp *
process.puJetIdEnDown * process.puJetMvaEnDown *
process.WSequence * process.ZSequence * process.invHiggsInfo)
else:
process.p = cms.Path(
# Trigger filter
#process.hltHighLevel *
process.vbfFilter *
# Basic filters
process.noscraping * process.primaryVertexFilter *
# MET filters (Move to be flags)
# MET Correction
process.type0PFMEtCorrection *
# Tau
process.recoTauClassicHPSSequence *
# Generate PAT
process.pfParticleSelectionSequence * process.patDefaultSequence *
process.goodPatJets * process.PhysicsObjectSequence *
process.metUncertaintySequence * process.puJetIdSqeuence *
process.puJetIdSmeared * process.puJetMvaSmeared *
process.puJetIdResUp * process.puJetMvaResUp *
process.puJetIdResDown * process.puJetMvaResDown *
process.puJetIdEnUp * process.puJetMvaEnUp *
process.puJetIdEnDown * process.puJetMvaEnDown *
process.WSequence * process.ZSequence * process.invHiggsInfo)
###--------------------------------------------------------------
###--------------------------------------------------------------
### Output
process.out.outputCommands += [
# trigger results
'keep edmTriggerResults_*_*_*',
'keep *_hltTriggerSummaryAOD_*_*'
# L1
,
'keep *_l1extraParticles_MET_RECO',
'keep *_l1extraParticles_MHT_RECO'
# good jets
,
'keep *_goodPatJets_*_*'
# PU jet ID
,
'keep *_puJetId*_*_*',
'keep *_puJetMva*_*_*'
# vertices
,
'keep *_offlineBeamSpot_*_*',
'keep *_offlinePrimaryVertices*_*_*',
'keep *_goodOfflinePrimaryVertices*_*_*',
'keep double_*_rho_*'
]
if iRunOnData == False:
process.out.outputCommands += [
'keep GenEventInfoProduct_*_*_*', 'keep recoGenParticles_*_*_*',
'keep GenMETs_*_*_*', 'keep *_addPileupInfo_*_*',
'keep LHEEventProduct_*_*_*'
]
process.out.fileName = 'patTuple.root'
del (process.out)
del (process.outpath)
if runStandardPAT:
if not runOnMC:
runOnData(process)
# subsequent jet area calculations needed for L1FastJet on RECO jets
if useCaloJets and useL1FastJet:
if useRelVals:
process.ak5CaloJets = ak5CaloJets.clone(doAreaFastjet=True)
process.ak5JetID = ak5JetID.clone()
process.ak5CaloJetSequence = cms.Sequence(process.ak5CaloJets *
process.ak5JetID)
from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection
switchJetCollection(process,
cms.InputTag(jetAlgo.lower() + 'CaloJets'),
doJTA=True,
doBTagging=True,
jetCorrLabel=(jecSet, jecLevels),
doType1MET=False,
genJetCollection=cms.InputTag(jetAlgo.lower() +
'GenJets'),
doJetID=True)
else:
print 'WARNING patRefSel_muJets_test_cfg.py:'
print ' L1FastJet JECs are not available for AK5Calo jets in this data due to missing jet area computation;'
print ' switching to L1Offset !!!'
jecLevelsCalo.insert(0, 'L1Offset')
jecLevelsCalo.remove('L1FastJet')
process.patJetCorrFactors.levels = jecLevelsCalo
#process.patJetCorrFactors.useRho = False # FIXME: does not apply
if usePFJets:
if useL1FastJet:
process.ak5PFJets = ak5PFJets.clone(doAreaFastjet=True)
## import skeleton process
from PhysicsTools.PatAlgos.patTemplate_cfg import *
process.load("PhysicsTools.PatAlgos.producersLayer1.patCandidates_cff")
patAlgosToolsTask.add(process.patCandidatesTask)
#Temporary customize to the unit tests that fail due to old input samples
process.patTaus.skipMissingTauID = True
process.load("PhysicsTools.PatAlgos.selectionLayer1.selectedPatCandidates_cff")
patAlgosToolsTask.add(process.selectedPatCandidatesTask)
process.load("PhysicsTools.PatUtils.patPFMETCorrections_cff")
from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection
switchJetCollection(process,
jetSource = cms.InputTag('ak4PFJets'),
jetCorrections = ('AK4PF', ['L1FastJet', 'L2Relative', 'L3Absolute'], '')
)
# apply type I PFMEt corrections to pat::MET object
# and estimate systematic uncertainties on MET
from PhysicsTools.PatUtils.tools.runMETCorrectionsAndUncertainties import runMETCorrectionsAndUncertainties
runMETCorrectionsAndUncertainties(process, metType="PF",
correctionLevel=["T1"],
computeUncertainties=True,
produceIntermediateCorrections=False,
addToPatDefaultSequence=False,
jetCollectionUnskimmed="patJets",
jetSelection="pt>15 && abs(eta)<9.9",
postfix="",
)
process,
labelName = 'AK15PFCHS',
jetSource = cms.InputTag('ak15PFJetsCHS'),
algo = 'ak15',
rParam = 1.5,
jetCorrections = ('AK10PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None'),
trackSource = cms.InputTag('unpackedTracksAndVertices'),
pvSource = cms.InputTag('unpackedTracksAndVertices'),
btagDiscriminators = ['combinedSecondaryVertexBJetTags'],
)
switchJetCollection(
process,
jetSource = cms.InputTag('ak4PFJets'),
algo = 'ak4',
rParam = 0.4,
jetCorrections = ('AK4PF', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'Type-1'),
trackSource = cms.InputTag('unpackedTracksAndVertices'),
pvSource = cms.InputTag('unpackedTracksAndVertices'),
#btagDiscriminators = ['combinedSecondaryVertexBJetTags'], #this breaks the config
)
for module in [process.patJetsAK4PFCHS, process.patJetsAK8PFCHS, process.patJetsAK10PFCHS, process.patJetsAK12PFCHS, process.patJetsAK15PFCHS]:
module.addJetCharge = False
module.addBTagInfo = True
module.getJetMCFlavour = False
module.addAssociatedTracks = False
for module in [process.patJetPartonMatch, process.patJetPartonMatchAK4PFCHS, process.patJetPartonMatchAK8PFCHS, process.patJetPartonMatchAK10PFCHS, process.patJetPartonMatchAK12PFCHS, process.patJetPartonMatchAK15PFCHS]:
module.matched='prunedGenParticles'
for module in [process.patJetCorrFactors, process.patJetCorrFactorsAK4PFCHS, process.patJetCorrFactorsAK8PFCHS, process.patJetCorrFactorsAK10PFCHS, process.patJetCorrFactorsAK12PFCHS, process.patJetCorrFactorsAK15PFCHS]:
def addTagInfos(process, jetMetCorrections):
from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection
switchJetCollection(process,
jetCollection=cms.InputTag('ak5CaloJets'),
jetCorrLabel=('AK5Calo', jetMetCorrections))
def configurePatTuple(process, isMC=True, **kwargs):
'''
Core function for PATTuple production
'''
#fix argparser output
isMC = bool(isMC)
########################
## ##
## PATTuple content ##
## ##
########################
# Stuff we always keep
output_commands = [
'*_addPileupInfo_*_*',
'edmMergeableCounter_*_*_*',
'*_lumiProducer_*_*',
'*_particleFlow_*_*',
'*_offlineBeamSpot_*_*',
'*_generalTracks_*_*',
'*_electronGsfTracks_*_*',
'*_gsfElectrons_*_*',
'*_gsfElectronCores_*_*',
'*_offlinePrimaryVertices*_*_*',
'*_ak5GenJets_*_*',
'*_hltTriggerSummaryAOD_*_*',
'edmTriggerResults_TriggerResults_*_%s' % process.name_(),
'*_MEtoEDMConverter*_*_%s' % process.name_(),
'LHEEventProduct_*_*_*',
'GenEventInfoProduct_generator_*_*',
'*_kt6PFJetsForRhoComputationVoronoi_rho_*',
'*_kt6PFJetsForIso_rho_*',
'*_kt6PFJets_rho_*',
'*_kt6PFJetsHZGPho_rho_*',
'*_kt6PFJetsCentralHZGEle_rho_*',
'*_kt6PFJetsCentralHZGMu_rho_*',
'*_kt6PFJetsCentralNeutralHZGMu_rho_*',
'*_kt6PFJetsCentral_rho_*',
'*_kt6PFJetsCentralNeutral_rho_*', # for zz muons
'*_photonCore_*_*',
'*_boostedFsrPhotons_*_*',
# for Zmumu -> embedded samples
# https://twiki.cern.ch/twiki/bin/view/CMS/MuonTauReplacementRecHit
'*_generalTracksORG_*_EmbeddedRECO',
'*_electronGsfTracksORG_*_EmbeddedRECO',
'double_TauSpinnerReco_TauSpinnerWT_EmbeddedSPIN',
'double_ZmumuEvtSelEffCorrWeightProducer_weight_EmbeddedRECO',
'double_muonRadiationCorrWeightProducer_weight_EmbeddedRECO',
'GenFilterInfo_generator_minVisPtFilter_EmbeddedRECO',
]
# Define our patTuple production sequence
process.tuplize = cms.Sequence()
# Only keep interesting genParticles
process.load("FinalStateAnalysis.RecoTools.genParticleTrimmer_cfi")
process.genParticles = process.prunedGenParticles.clone()
if isMC:
#process.tuplize += process.genParticles
#output_commands.append('*_genParticles_*_%s' % process.name_())
output_commands.append('*_genParticles_*_*')
output_commands.append('*_tauGenJetsSelectorAllHadrons_*_*')
output_commands.append('*_tauGenJets_*_*')
output_commands.append('*_ak5GenJets_*_*')
########################
## ##
## PAT ##
## ##
########################
# Run pat default sequence
process.load("PhysicsTools.PatAlgos.patSequences_cff")
# Embed PF Isolation in electrons & muons
pfTools.usePFIso(process)
# Setup H2Tau custom iso definitions
setup_h2tau_iso(process)
# Setup hZg custom iso definitions
add_hZg_iso_needs(process)
# Now run PAT
process.tuplize += process.patDefaultSequence
# Add FSR photons for ZZ analysis
process.load("FinalStateAnalysis.PatTools.fsrPhotons_cff")
process.tuplize += process.fsrPhotonSequence
########################
## GEN ##
########################
# Disable gen match embedding - we keep it in the ntuple
process.patMuons.embedGenMatch = False
process.patElectrons.embedGenMatch = False
process.patTaus.embedGenMatch = False
process.patTaus.embedGenJetMatch = False
process.patPhotons.embedGenMatch = False
if not isMC:
coreTools.runOnData(process)
########################
## MUONS ##
########################
# Unembed junk
process.patMuons.embedCaloMETMuonCorrs = False
process.patMuons.embedTcMETMuonCorrs = False
process.patMuons.embedTrack = True
process.patMuons.pvSrc = cms.InputTag("selectedPrimaryVertex")
process.load("FinalStateAnalysis.PatTools.patMuonProduction_cff")
final_muon_collection = chain_sequence(
process.customizeMuonSequence, "selectedPatMuons")
process.customizeMuonSequence.insert(0, process.selectedPatMuons)
process.patDefaultSequence.replace(process.selectedPatMuons,
process.customizeMuonSequence)
process.cleanPatMuons.src = final_muon_collection
process.patMuonRochesterCorrectionEmbedder.isMC = cms.bool(bool(isMC))
########################
## TAUS ##
########################
# Use HPS taus
tautools.switchToPFTauHPS(process) #this NEEDS a sequence called patDefaultSequence
# Disable tau IsoDeposits
process.patDefaultSequence.remove(process.patPFTauIsolation)
process.patTaus.isoDeposits = cms.PSet()
process.patTaus.userIsolation = cms.PSet()
process.load("FinalStateAnalysis.PatTools.patTauProduction_cff")
# Require all taus to pass decay mode finding and have high PT
process.patTauGarbageRemoval.cut = cms.string(
"pt > 17 && abs(eta) < 2.5 && tauID('decayModeFindingNewDMs')")
final_tau_collection = chain_sequence(
process.customizeTauSequence, "selectedPatTaus")
# Inject into the pat sequence
process.customizeTauSequence.insert(0, process.selectedPatTaus)
process.patDefaultSequence.replace(process.selectedPatTaus,
process.customizeTauSequence)
process.cleanPatTaus.src = final_tau_collection
# Remove muons and electrons
process.cleanPatTaus.checkOverlaps.muons.requireNoOverlaps = False
process.cleanPatTaus.checkOverlaps.electrons.requireNoOverlaps = False
# Cuts already applied by the garbage removal
process.cleanPatTaus.preselection = ''
process.cleanPatTaus.finalCut = ''
########################
## ELECTRONS ##
########################
# Use POG recommendations for (these) electron Isos
process.elPFIsoValueGamma04PFIdPFIso.deposits[0].vetos = cms.vstring(
'EcalEndcaps:ConeVeto(0.08)')
process.elPFIsoValueGamma04NoPFIdPFIso.deposits[0].vetos = cms.vstring(
'EcalEndcaps:ConeVeto(0.08)')
process.elPFIsoValueCharged04PFIdPFIso.deposits[0].vetos = cms.vstring(
'EcalEndcaps:ConeVeto(0.015)')
process.elPFIsoValueCharged04NoPFIdPFIso.deposits[0].vetos = cms.vstring(
'EcalEndcaps:ConeVeto(0.015)')
# Do extra electron ID
process.load("FinalStateAnalysis.PatTools.electrons.electronID_cff")
if cmssw_major_version() == 4:
process.patDefaultSequence.replace(process.patElectrons,
process.recoElectronID42X +
process.patElectrons)
process.patElectrons.electronIDSources = process.electronIDSources42X
else:
process.patDefaultSequence.replace(process.patElectrons,
process.recoElectronID5YX +
process.patElectrons)
process.patElectrons.electronIDSources = process.electronIDSources5YX
process.electronMatch.checkCharge = cms.bool(False)
process.patElectrons.embedTrack = False
process.patElectrons.embedPFCandidate = False
process.patElectrons.embedGsfElectronCore = False
process.patElectrons.embedSuperCluster = True
# Produce the electron collections
process.load("FinalStateAnalysis.PatTools.patElectronProduction_cff")
# Electron Energy Regression and Calibrations
process.load(
"EgammaAnalysis.ElectronTools.electronRegressionEnergyProducer_cfi")
process.load("EgammaAnalysis.ElectronTools.calibratedPatElectrons_cfi")
#setup the energy regression for the specific dataset
if kwargs['eleReg']:
print "-- Applying Electron Regression and Calibration --"
process.customizeElectronSequence += process.eleRegressionEnergy
process.customizeElectronSequence += process.calibratedPatElectrons
process.eleRegressionEnergy.energyRegressionType = cms.uint32(2)
process.calibratedPatElectrons.correctionsType = cms.int32(2)
if isMC:
process.calibratedPatElectrons.inputDataset = cms.string(
"Summer12_LegacyPaper")
else:
process.calibratedPatElectrons.inputDataset = cms.string(
"22Jan2013ReReco")
process.calibratedPatElectrons.combinationType = cms.int32(3)
process.calibratedPatElectrons.lumiRatio = cms.double(1.0)
process.calibratedPatElectrons.synchronization = cms.bool(True)
process.calibratedPatElectrons.isMC = cms.bool(isMC == 1)
process.calibratedPatElectrons.verbose = cms.bool(False)
final_electron_collection = chain_sequence(
process.customizeElectronSequence, "selectedPatElectrons",
# Some of the EGamma modules have non-standard src InputTags,
# specify them here.
("src", "inputPatElectronsTag", "inputElectronsTag")
)
#process.tuplize += process.customizeElectronSequence #why do we need this?
process.customizeElectronSequence.insert(0, process.selectedPatElectrons)
process.patDefaultSequence.replace(process.selectedPatElectrons,
process.customizeElectronSequence)
# We have to do the pat Jets before the pat electrons since we embed them
process.customizeElectronSequence.insert(0, process.selectedPatJets)
# Define cleanPatElectrons input collection
process.cleanPatElectrons.src = final_electron_collection
# Define the default lepton cleaning
process.cleanPatElectrons.preselection = cms.string(
'pt > 5')
process.cleanPatElectrons.checkOverlaps.muons.requireNoOverlaps = False
# Make sure we don't kill any good taus by calling them electrons
# Note that we don't actually remove these overlaps.
process.cleanPatElectrons.checkOverlaps.taus = cms.PSet(
src=final_tau_collection,
algorithm=cms.string("byDeltaR"),
preselection=cms.string(
"tauID('decayModeFinding') > 0.5 &&"
"tauID('byLooseCombinedIsolationDeltaBetaCorr') > 0.5 &&"
"tauID('againstElectronLoose') > 0.5 && "
"pt > 10"
),
deltaR=cms.double(0.1),
checkRecoComponents=cms.bool(False),
pairCut=cms.string(""),
requireNoOverlaps=cms.bool(False),
)
########################
## JETS ##
########################
# Use PFJets and turn on JEC
jec = ['L1FastJet', 'L2Relative', 'L3Absolute']
# If we are running on data (not MC), or embedded sample,
# apply the MC-DATA residual correction.
if not isMC or kwargs['embedded']:
jec.extend(['L2L3Residual'])
# tmp
# define the b-tag squences for offline reconstruction
process.load("RecoBTag.SecondaryVertex.secondaryVertex_cff")
process.load("RecoBTau.JetTagComputer.combinedMVA_cff")
process.load('RecoVertex/AdaptiveVertexFinder/inclusiveVertexing_cff')
process.load('RecoBTag/SecondaryVertex/bToCharmDecayVertexMerger_cfi')
#process.load("PhysicsTools.PatAlgos.patSequences_cff")
# Define options for BTagging - these are release dependent.
btag_options = {'doBTagging': True}
if cmssw_major_version() == 5:
btag_options['btagInfo'] = [
'impactParameterTagInfos',
'secondaryVertexTagInfos',
'softMuonTagInfos',
'secondaryVertexNegativeTagInfos',
'inclusiveSecondaryVertexFinderFilteredTagInfos'
]
btag_options['btagdiscriminators'] = [
'trackCountingHighEffBJetTags',
'trackCountingHighPurBJetTags',
'simpleSecondaryVertexHighEffBJetTags',
'simpleSecondaryVertexHighPurBJetTags',
'simpleInclusiveSecondaryVertexHighEffBJetTags',
'simpleInclusiveSecondaryVertexHighPurBJetTags',
'combinedSecondaryVertexMVABJetTags',
'combinedSecondaryVertexBJetTags',
'jetBProbabilityBJetTags',
'jetProbabilityBJetTags',
]
#Avoid embedding
process.patJets.embedPFCandidates = True
process.patJets.embedCaloTowers = False
process.patJets.embedGenJetMatch = True
process.patJets.addAssociatedTracks = True
process.patJets.embedGenPartonMatch = True
# Add AK5chs PFJets
jettools.addJetCollection(
process,
cms.InputTag('ak5PFchsJets'),
algoLabel = "AK5",
typeLabel = "PFchs",
doJTA = True,
jetCorrLabel = ('AK5PFchs', jec),
doType1MET = False,
doL1Cleaning = False,
doL1Counters = False,
genJetCollection = cms.InputTag('ak5GenJets'),
doJetID = True,
**btag_options
)
# Use AK5 PFJets
jettools.switchJetCollection(
process,
cms.InputTag('ak5PFJets'),
doJTA=True,
jetCorrLabel=('AK5PF', jec),
#jetCorrLabel = None,
doType1MET=False,
doJetID=True,
genJetCollection=cms.InputTag("ak5GenJets"),
**btag_options
)
# Customize/embed all our sequences
process.load("FinalStateAnalysis.PatTools.patJetProduction_cff")
helpers.cloneProcessingSnippet( process, process.customizeJetSequence, 'AK5PFchs' )
process.patJetGarbageRemoval.cut = 'pt > 12'
final_jet_collection = chain_sequence(
process.customizeJetSequence, "patJets")
process.customizeJetSequence.insert(0, process.patJets)
# Make it a "complete" sequence
process.customizeJetSequence += process.selectedPatJets
# process.customizeJetSequence += process.btagging
# We can't mess up the selected pat jets because the taus use them.
process.selectedPatJets.src = final_jet_collection
process.patDefaultSequence.replace(process.patJets,
process.customizeJetSequence)
process.customizeJetSequenceAK5PFchs.remove( process.patJetsPUIDAK5PFchs )
process.customizeJetSequenceAK5PFchs.remove( process.pileupJetIdProducerAK5PFchs )
process.patJetGarbageRemovalAK5PFchs.cut = 'pt > 20'
process.patJetCorrFactorsAK5PFchs.payload = cms.string('AK5PFchs')
final_jetchs_collection = chain_sequence(
process.customizeJetSequenceAK5PFchs, "patJetsAK5PFchs")
process.customizeJetSequenceAK5PFchs.insert(0, process.patJetsAK5PFchs)
# Make it a "complete" sequence
process.customizeJetSequenceAK5PFchs += process.selectedPatJetsAK5PFchs
# We can't mess up the selected pat jets because the taus use them.
process.selectedPatJetsAK5PFchs.src = final_jetchs_collection
process.selectedPatJetsAK5chsPF = process.selectedPatJetsAK5PFchs.clone() #that's what we keep
process.customizeJetSequenceAK5PFchs += process.selectedPatJetsAK5chsPF
process.patDefaultSequence.replace(process.patJetsAK5PFchs,
process.customizeJetSequenceAK5PFchs)
output_commands.append('*_selectedPatJets_*_*')
output_commands.append('*_selectedPatJetsAK5chsPF_*_*')
output_commands.append('*SecondaryVertexTagInfo*_*_*_*')
output_commands.append('*TrackIPTagInfo*_*_*_*')
output_commands.append('*SoftLeptonTagInfo*_*_*_*')
output_commands.append('*_ak5PFJets_*_*')
output_commands.append('*_ak5PFchsJets_*_*')
########################
## MET ##
########################
# Use PFMEt
mettools.addPfMET(process)
# We cut out a lot of the junky taus and jets - but we need these
# to correctly apply the MET uncertainties. So, let's make a
# non-cleaned version of the jet and tau sequence.
process.jetsForMetSyst = helpers.cloneProcessingSnippet(
process, process.customizeJetSequence, 'ForMETSyst')
process.tausForMetSyst = helpers.cloneProcessingSnippet(
process, process.customizeTauSequence, 'ForMETSyst')
# Don't apply any cut for these
process.patTauGarbageRemovalForMETSyst.cut = ''
process.patJetGarbageRemovalForMETSyst.cut = ''
process.tuplize += process.jetsForMetSyst
process.tuplize += process.tausForMetSyst
# We have to make our clone of cleanPatTaus separately, since e/mu
# cleaning is applied - therefore it isn't in the customizeTausSequence.
process.cleanPatTausForMETSyst = process.cleanPatTaus.clone(
src=cms.InputTag(process.cleanPatTaus.src.value() + "ForMETSyst"))
process.cleanPatTausForMETSyst.preselection = ''
process.cleanPatTausForMETSyst.finalCut = ''
process.patTausEmbedJetInfoForMETSyst.jetSrc = \
final_jet_collection.value() + "ForMETSyst"
process.tuplize += process.cleanPatTausForMETSyst
# Setup MET production
process.load("FinalStateAnalysis.PatTools.patMETProduction_cff")
# The MET systematics depend on all other systematics
process.systematicsMET.tauSrc = cms.InputTag("cleanPatTausForMETSyst")
process.systematicsMET.muonSrc = cms.InputTag("cleanPatMuons")
process.systematicsMET.electronSrc = cms.InputTag("cleanPatElectrons")
final_met_collection = chain_sequence(
process.customizeMETSequence, "patMETsPF")
process.tuplize += process.customizeMETSequence
process.patMETsPF.addGenMET = bool(isMC)
output_commands.append('*_%s_*_*' % final_met_collection.value())
# Make a version with the MVA MET reconstruction method
process.load("FinalStateAnalysis.PatTools.met.mvaMetOnPatTuple_cff")
process.tuplize += process.pfMEtMVAsequence
mva_met_sequence = helpers.cloneProcessingSnippet(
process, process.customizeMETSequence, "MVA")
final_mvamet_collection = chain_sequence(
mva_met_sequence, "patMEtMVA")
process.tuplize += mva_met_sequence
output_commands.append('*_%s_*_*' % final_mvamet_collection.value())
# Keep all the data formats needed for the systematics
output_commands.append('recoLeafCandidates_*_*_%s'
% process.name_())
# We can drop to jet and tau MET specific products. They were only used for
# computation of the MET numbers.
output_commands.append('drop recoLeafCandidates_*ForMETSyst_*_%s'
% process.name_())
########################
## PHOTONS ##
########################
#alter the photon matching to accept various fakes
# and sort matches by d-pt-rel
if isMC:
process.photonMatch = cms.EDProducer(
"MCMatcherByPt",
src=cms.InputTag("photons"),
maxDPtRel=cms.double(100.0),
mcPdgId=cms.vint32(),
mcStatus=cms.vint32(1),
resolveByMatchQuality=cms.bool(False),
maxDeltaR=cms.double(0.3),
checkCharge=cms.bool(False),
resolveAmbiguities=cms.bool(True),
matched=cms.InputTag("genParticles")
)
# Setup pat::Photon Production
process.load("FinalStateAnalysis.PatTools.patPhotonProduction_cff")
final_photon_collection = chain_sequence(process.customizePhotonSequence,
"selectedPatPhotons")
#setup PHOSPHOR for a specific dataset
if cmssw_major_version() == 4: # for now 2011 = CMSSW42X
process.patPhotonPHOSPHOREmbedder.year = cms.uint32(2011)
else: # 2012 is 5YX
process.patPhotonPHOSPHOREmbedder.year = cms.uint32(2012)
process.patPhotonPHOSPHOREmbedder.isMC = cms.bool(bool(isMC))
#inject photons into pat sequence
process.customizePhotonSequence.insert(0, process.selectedPatPhotons)
process.patDefaultSequence.replace(process.selectedPatPhotons,
process.customizePhotonSequence)
process.cleanPatPhotons.src = final_photon_collection
########################
## TRIGGER ##
########################
trigtools.switchOnTrigger(process)
#configure the PAT trigger
if kwargs['HLTprocess']:
process.patTrigger.processName = cms.string(kwargs['HLTprocess'])
process.patTriggerEvent.processName = cms.string(kwargs['HLTprocess'])
########################
## -------------- ##
########################
output_commands.append('*_cleanPatTaus_*_*')
output_commands.append('*_cleanPatElectrons_*_*')
output_commands.append('*_cleanPatMuons_*_*')
output_commands.append('*_cleanPatPhotons_*_*')
########################
## ##
## FSA ##
## ##
########################
# Now build the PATFinalStateLS object, which holds LumiSection info.
process.load(
"FinalStateAnalysis.PatTools.finalStates.patFinalStateLSProducer_cfi")
process.tuplize += process.finalStateLS
output_commands.append('*_finalStateLS_*_*')
if isMC:
process.finalStateLS.xSec = kwargs['xSec']
# Tell the framework to shut up!
process.load("FWCore.MessageLogger.MessageLogger_cfi")
process.MessageLogger.cerr.FwkReport.reportEvery = 1000
# Which collections are used to build the final states
fs_daughter_inputs = {
'electrons': 'cleanPatElectrons',
'muons': 'cleanPatMuons',
'taus': 'cleanPatTaus',
'photons': 'cleanPatPhotons',
'jets': 'selectedPatJets',
'pfmet': final_met_collection,
'mvamet': final_mvamet_collection,
}
# Setup all the PATFinalState objects
produce_final_states(process, fs_daughter_inputs, output_commands,
process.tuplize, kwargs['puTag'],
zzMode=kwargs.get('zzMode', False))
return process.tuplize, output_commands
jetCorrections=('AK5PFchs',
cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']),
'None'), # FIXME: Use proper JECs, as soon as available
btagDiscriminators=['combinedSecondaryVertexBJetTags'],
)
process.out.outputCommands.append('drop *_selectedPatJets%s_caloTowers_*' %
(labelCA8PFCHSPruned))
# uncomment the following lines to switch to ak4CaloJets in your PAT output
switchJetCollection(
process,
jetSource=cms.InputTag('ak4CaloJets'),
jetCorrections=('AK5Calo',
cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']),
'Type-1'), # FIXME: Use proper JECs, as soon as available
btagDiscriminators=[
'jetBProbabilityBJetTags', 'jetProbabilityBJetTags',
'trackCountingHighPurBJetTags', 'trackCountingHighEffBJetTags',
'simpleSecondaryVertexHighEffBJetTags',
'simpleSecondaryVertexHighPurBJetTags',
'combinedSecondaryVertexBJetTags'
],
)
## JetID works only with RECO input for the CaloTowers (s. below for 'process.source.fileNames')
#process.patJets.addJetID=True
#process.load("RecoJets.JetProducers.ak4JetID_cfi")
#process.patJets.jetIDMap="ak4JetID"
process.patJets.useLegacyJetMCFlavour = True # Need to use legacy flavour since the new flavour requires jet constituents which are dropped for CaloJets from AOD
process.out.outputCommands.append('keep *_selectedPatJets_caloTowers_*')
process.out.outputCommands.append('drop *_selectedPatJets_pfCandidates_*')
#print process.out.outputCommands
# this should be your last selected electron collection name since currently index is used to match with electron later. We can fix this using reference pointer. ,
)
################## PAT ELECTRONS ####################
###### PAT JETS ########
import PhysicsTools.PatAlgos.tools.jetTools as jetTools
jetTools.switchJetCollection(process,
cms.InputTag('ak5PFJets'),
doJTA = True,
doBTagging = True,
# MC: jetCorrLabel = ('AK5PF', ['L1FastJet', 'L2Relative', 'L3Absolute']),
# data:
jetCorrLabel = ('AK5PF', ['L1FastJet', 'L2Relative', 'L3Absolute','L2L3Residual']),
doType1MET = False,
# genJetCollection = cms.InputTag("ak5GenJets"),
doJetID = False, #True in MC
jetIdLabel = "ak5",
outputModules = [],
)
###### PAT JETS ########
process.bsVertexAnalysis = cms.EDAnalyzer("BsToJpsiPhiAnalysis",
isMCstudy = cms.bool(False),
genParticlesLabel = cms.InputTag(""),
TrackLabel_K = cms.InputTag("kTracks"),
TrackLabel_pi = cms.InputTag("piTracks"),
TriggerTag = cms.InputTag("TriggerResults::HLT"),
],
)
getattr(process, 'patJetsAK5Calo' + postfixAK5Calo).addJetID=True
getattr(process, 'patJetsAK5Calo' + postfixAK5Calo).jetIDMap="ak5JetID"
process.out.outputCommands.append( 'drop *_selectedPatJetsAK5Calo%s_pfCandidates_*'%(postfixAK5Calo) )
#process.patJetsAK5Calo.addJetID=True
#process.patJetsAK5Calo.jetIDMap="ak5JetID"
## uncomment the following lines to add ak5PFJets to your PAT output
switchJetCollection(
process,
jetSource = cms.InputTag('ak5PFJets'),
jetCorrections = ('AK5PF', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'Type-2'),
btagDiscriminators = [
'jetBProbabilityBJetTags'
, 'jetProbabilityBJetTags'
, 'trackCountingHighPurBJetTags'
, 'trackCountingHighEffBJetTags'
, 'simpleSecondaryVertexHighEffBJetTags'
, 'simpleSecondaryVertexHighPurBJetTags'
, 'combinedSecondaryVertexBJetTags'
],
)
## let it run
#process.p = cms.Path(
# process.patDefaultSequence
#)
##process.Tracer = cms.Service("Tracer")
#process.p = cms.Path(
#process.selectedPatCandidates
'L3Absolute']), 'None'))
addJetCollection(process,
labelName='AK8PFCHS',
jetSource=cms.InputTag('ak8PFJetsCHS'),
algo='ak8',
rParam=0.8,
jetCorrections=('AK8PFchs',
cms.vstring(
['L1FastJet', 'L2Relative',
'L3Absolute']), 'None'))
switchJetCollection(
process,
jetSource=cms.InputTag('ak4PFJets'),
rParam=0.4,
jetCorrections=('AK4PF',
cms.vstring(['L1FastJet', 'L2Relative',
'L3Absolute']), 'Type-1'),
)
#process.patJetGenJetMatchCA8PFCHS.matched = cms.InputTag("ca8GenJetsNoNu")
patJetsAK4 = process.patJetsAK4PFCHS
patJetsCA8 = process.patJetsCA8PFCHS
patJetsAK8 = process.patJetsAK8PFCHS
process.out.outputCommands += [
'keep *_ak4PFJetsCHS_*_*', 'keep *_patJetsAK4PFCHS_*_*',
'keep *_ca8PFJetsCHS_*_*', 'keep *_patJetsCA8PFCHS_*_*',
'keep *_ak8PFJetsCHS_*_*', 'keep *_patJetsAK8PFCHS_*_*'
]
)
process.patJetsAk8PuppiJets.userData.userFloats.src += ['ak8PFJetsPuppiSoftDropMass','ak8PFJetsPuppiSoftDropMassCorrected']
#process.patJetsAk8PuppiJets.userData.userFloats.src += ['ak8PFJetsPuppiPrunedMass','ak8PFJetsPuppiPrunedMassCorrected']
process.patJetsAk8PuppiJets.userData.userFloats.src += ['NjettinessAK8Puppi:tau1','NjettinessAK8Puppi:tau2','NjettinessAK8Puppi:tau3']
process.patJetsAk8PuppiJets.addTagInfos = True
# ###### Recluster MET ##########
if config["DOMETRECLUSTERING"]:
from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection
if config["RUNONMC"]:
switchJetCollection(process,
jetSource = cms.InputTag('ak4PFJetsCHS'),
jetCorrections = ('AK4PFchs', ['L1FastJet', 'L2Relative', 'L3Absolute'], ''),
genParticles = cms.InputTag('prunedGenParticles'),
pvSource = cms.InputTag('offlineSlimmedPrimaryVertices')
)
else:
switchJetCollection(process,
jetSource = cms.InputTag('ak4PFJetsCHS'),
jetCorrections = ('AK4PFchs', ['L1FastJet', 'L2Relative', 'L3Absolute','L2L3Residual'], ''),
genParticles = cms.InputTag('prunedGenParticles'),
pvSource = cms.InputTag('offlineSlimmedPrimaryVertices')
)
process.patJets.addGenJetMatch = cms.bool(False)
process.patJets.addGenPartonMatch = cms.bool(False)
process.patJets.addPartonJetMatch = cms.bool(False)
from PhysicsTools.PatUtils.tools.runMETCorrectionsAndUncertainties import runMetCorAndUncFromMiniAOD
# PUT THE DISCRIMINATORS HERE
#
]
## Switch the default PAT jet collection to the above-defined ak4PFJetsCHS
#
# REPLACE THE FIXME!
#
FIXME = 'FIXME' #this is just here to avoid python to raise an exception
switchJetCollection(process,
jetSource=FIXME,
pvSource=FIXME,
pfCandidates=FIXME,
svSource=FIXME,
muSource=FIXME,
elSource=FIXME,
btagDiscriminators=bTagDiscriminators,
jetCorrections=('AK4PFchs',
['L1FastJet', 'L2Relative',
'L3Absolute'], 'None'),
genJetCollection=FIXME,
genParticles=FIXME)
getattr(process, 'selectedPatJets').cut = cms.string(
'pt > 10') # to match the selection for slimmedJets in MiniAOD
# What is this needed for?
# In[ ]:
from PhysicsTools.PatAlgos.tools.pfTools import adaptPVs
## Adapt primary vertex collection