def addHEEPId(process):
# Run the HEEP electron id. This must be done at PAT tuple making
# time and cannot be done later unless some modifications are done
# the GsfElectron/GsfElectronCore classes.
from SHarper.HEEPAnalyzer.HEEPSelectionCuts_cfi import heepBarrelCuts, heepEndcapCuts
from SHarper.HEEPAnalyzer.HEEPEventParameters_cfi import heepEventPara
process.HEEPId = cms.EDProducer('HEEPIdValueMapProducer',
eleLabel = cms.InputTag('gsfElectrons'),
barrelCuts = heepBarrelCuts,
endcapCuts = heepEndcapCuts,
eleIsolEffectiveAreas = heepEventPara.eleIsolEffectiveAreas,
applyRhoCorrToEleIsol = heepEventPara.applyRhoCorrToEleIsol,
eleRhoCorrLabel = heepEventPara.eleRhoCorrTag,
writeIdAsInt = cms.bool(True),
)
# For isolation correction
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets
process.kt6PFJetsForIsolation = kt4PFJets.clone( rParam = 0.6, doRhoFastjet = True )
process.kt6PFJetsForIsolation.Rho_EtaMax = cms.double(2.5)
# Embed the HEEP cut bitwords into the userData of the
# patElectrons so we can use it to cut on at dilepton-making time
# instead of necessarily dropping them in the selectedPatElectrons
# or cleanPatElectrons steps.
process.patElectrons.userData.userInts.src.append('HEEPId')
process.patDefaultSequence.replace(process.patElectrons, process.kt6PFJetsForIsolation * process.HEEPId * process.patElectrons)
def defineAnalysis(process,castorDir="",reRunRho=False) :
# our MET producer
process.ClusteredPFMetProducer = ClusteredPFMetProducer.clone()
#
# configure the analyzer (cf. base values are in the StandardSelections_cfi)
#
process.evAnalyzer = cms.EDAnalyzer("DileptonPlusMETEventAnalyzer",
dtag=cms.string('llvv'),
Trigger = BaseTriggerSelection.clone(),
Generator = BaseGeneratorSelection.clone(),
Vertices = BaseVertexSelection.clone(),
Photons = BasePhotonsSelection.clone(),
LooseMuons = BaseLooseMuonsSelection.clone(),
Muons = BaseMuonsSelection.clone(),
LooseElectrons = BaseLooseElectronsSelection.clone(),
Electrons = BaseElectronsSelection.clone(),
Dileptons = BaseDileptonSelection.clone(),
Jets = BaseJetSelection.clone(),
AssocJets = AssocJetSelection.clone(),
MET = BaseMetSelection.clone()
)
if(castorDir.find('12_03_13_HZZ2l2v_pat')>0):
print ' Warning: applying PF muon patch to standard selection'
process.evAnalyzer.Muons.source=cms.InputTag("selectedPatMuonsPFlow")
process.evAnalyzer.Muons.sourceIsPF=cms.bool(True)
process.evAnalyzer.LooseMuons.source=process.evAnalyzer.Muons.source
process.evAnalyzer.LooseMuons.sourceIsPF=process.evAnalyzer.Muons.sourceIsPF
#MVAs for IDs
#process.load('EGamma.EGammaAnalysisTools.electronIdMVAProducer_cfi')
#process.mvaIDs = cms.Sequence( process.mvaTrigV0 + process.mvaNonTrigV0 )
from JetMETCorrections.Configuration.JetCorrectionProducers_cff import ak5PFJetsL1L2L3
process.ak5PFJetsL1L2L3ForMVAMET=ak5PFJetsL1L2L3.clone()
#rho for muon isolation
if(reRunRho) :
process.pfAllNeutralHadronsAndPhotons = pfAllNeutralHadronsAndPhotons.clone( src=cms.InputTag("particleFlow") )
process.kt6PFJetsCentralNeutral = kt4PFJets.clone( src = cms.InputTag("pfAllNeutralHadronsAndPhotons"),
rParam = cms.double(0.6),
doAreaFastjet = cms.bool(True),
doRhoFastjet = cms.bool(True),
Ghost_EtaMax = cms.double(3.1),
Rho_EtaMax = cms.double(2.5),
inputEtMin = cms.double(0.5)
)
process.rhoForIsolationSequence = cms.Sequence(process.pfAllNeutralHadronsAndPhotons*process.kt6PFJetsCentralNeutral)
process.analysis = cms.Path( #process.mvaIDs +
process.rhoForIsolationSequence +
process.ak5PFJetsL1L2L3ForMVAMET +
process.ClusteredPFMetProducer +
process.evAnalyzer)
else :
process.analysis = cms.Path( #process.mvaIDs +
process.ak5PFJetsL1L2L3ForMVAMET +
process.ClusteredPFMetProducer +
process.evAnalyzer)
def enablePileUpCorrectionInPF2PAT( process, postfix, sequence='PF2PAT'):
"""
Modifies the PF2PAT sequence according to the recipe of JetMET:
"""
# pile up subtraction
getattr(process,"pfNoPileUp"+postfix).enable = True
getattr(process,"pfPileUp"+postfix).Enable = True
getattr(process,"pfPileUp"+postfix).checkClosestZVertex = False
getattr(process,"pfPileUp"+postfix).Vertices = 'goodOfflinePrimaryVertices'
getattr(process,"pfJets"+postfix).doAreaFastjet = True
getattr(process,"pfJets"+postfix).doRhoFastjet = False
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets
setattr( process, 'kt6PFJets'+postfix, kt4PFJets.clone( rParam = cms.double(0.6),
src = cms.InputTag('pfNoElectron'+postfix),
doAreaFastjet = cms.bool(True),
doRhoFastjet = cms.bool(True)
# voronoiRfact = cms.double(0.9)
)
)
# adding kt6PFJets
getattr(process,'pfJetSequence'+postfix).replace( getattr(process,"pfJets"+postfix),
getattr(process,"kt6PFJets"+postfix) +
getattr(process,"pfJets"+postfix) )
# adding goodOfflinePrimaryVertices before pfPileUp
process.load('CommonTools.ParticleFlow.goodOfflinePrimaryVertices_cfi')
getattr(process, 'pfNoPileUpSequence'+postfix).replace( getattr(process,"pfPileUp"+postfix),
process.goodOfflinePrimaryVertices +
getattr(process,"pfPileUp"+postfix) )
def rho25(process) :
#https://twiki.cern.ch/twiki/bin/view/CMS/EgammaEARhoCorrection
#(also https://twiki.cern.ch/twiki/bin/view/CMS/Vgamma2011PhotonID)
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets
process.kt6PFJetsForIsolation = kt4PFJets.clone( rParam = 0.6, doRhoFastjet = True )
process.kt6PFJetsForIsolation.Rho_EtaMax = cms.double(2.5)
return cms.Path( process.kt6PFJetsForIsolation )
def applyFastJet(process,postfix):
process.pfPileUpPFlow.Enable = True
process.pfPileUpPFlow.checkClosestZVertex = cms.bool(False)
process.pfPileUpPFlow.Vertices = cms.InputTag('goodOfflinePrimaryVertices')
process.pfJetsPFlow.doAreaFastjet = True
process.pfJetsPFlow.doRhoFastjet = False
# Compute the mean pt per unit area (rho) from the
# PFchs inputs
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets
process.kt6PFJetsPFlow = kt4PFJets.clone(
rParam = cms.double(0.6),
src = cms.InputTag('pfNoElectron'+postfix),
doAreaFastjet = cms.bool(True),
doRhoFastjet = cms.bool(True),
#voronoiRfact = cms.double(0.9)
)
process.patJetCorrFactorsPFlow.rho = cms.InputTag("kt6PFJetsPFlow", "rho")
# Add the PV selector and KT6 producer to the sequence
getattr(process,"patPF2PATSequence"+postfix).replace(
getattr(process,"pfNoElectron"+postfix),
getattr(process,"pfNoElectron"+postfix)*process.kt6PFJetsPFlow )
process.PFCandidatesAll = cms.EDProducer('PFCand_NoPU_WithAM',
PFCandidateCollection = cms.InputTag('particleFlow'),
VertexCollection = cms.InputTag('offlinePrimaryVertices'),
VertexTrackAssociationMap = cms.InputTag('Tracks2VertexAll'),
ConversionsCollection = cms.InputTag('allConversions'),
V0KshortCollection = cms.InputTag('generalV0Candidates','Kshort'),
V0LambdaCollection = cms.InputTag('generalV0Candidates','Lambda'),
NIVertexCollection = cms.InputTag('particleFlowDisplacedVertex'),
)
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets
process.kt6PFJets1st = kt4PFJets.clone(
src = cms.InputTag("PFCandidates1st"),
rParam = cms.double(0.6),
doAreaFastjet = cms.bool(True),
doRhoFastjet = cms.bool(True),
Ghost_EtaMax = cms.double(6.5),
)
process.kt6PFJetsAll = kt4PFJets.clone(
src = cms.InputTag("PFCandidatesAll"),
rParam = cms.double(0.6),
doAreaFastjet = cms.bool(True),
doRhoFastjet = cms.bool(True),
Ghost_EtaMax = cms.double(6.5)
)
process.kt6GenJetsn = cms.EDProducer("CandViewNtpProducer",
src = cms.InputTag("kt6GenJets"),
lazyParser = cms.untracked.bool(True),
for name, pset in kappa_jets.iteritems():
setattr(process.kappaTuple.Jets, name, pset)
process.kappaTuple.Jets.taggers = cms.vstring(
"puJetIDFullDiscriminant", "puJetIDFullLoose", "puJetIDFullMedium", "puJetIDFullTight"
)
#print reduce(lambda a, b: a * b, jet_resources + sorted(cmssw_jets.values()))
#process.path *= reduce(lambda a, b: a * b, jet_resources + sorted(cmssw_jets.values()))
# Gluon tagging? - https://twiki.cern.ch/twiki/bin/viewauth/CMS/GluonTag
# B-tagging (for ak5 jets)? - https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookBTagging#DifferentJets
# B-tagging for (ak5 CHS jets)? - https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookBTagging#DifferentJets
# PileupDensity ########################
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets
process.pileupDensitykt6PFJets = kt4PFJets.clone(rParam=0.6, doRhoFastjet=True, Rho_EtaMax=2.5)
process.kappaTuple.active += cms.vstring('Jets', 'PileupDensity')
process.kappaTuple.PileupDensity.rename = cms.vstring("fixedGridRhoFastjetAll => pileupDensity")
process.path *= (process.pileupDensitykt6PFJets)
# MET correction ----------------------------------------------------------
#TODO check type 0 corrections
from RecoMET.METProducers.PFMET_cfi import pfMet
process.pfMETCHS = pfMet.clone(src=cms.InputTag(input_PFCandidates))
process.kappaTuple.active += cms.vstring('MET')
# MET without forward region
process.PFCandidatesNoHF = cms.EDFilter("CandPtrSelector",
src = cms.InputTag(input_PFCandidates),
cut = cms.string("abs(eta) < 3" )
def addPF2PAT(process, dataVersion, postfix="PFlow",
doTauHLTMatching=True, matchingTauTrigger=None,
):
# if hasattr(process, "patDefaultSequence"):
# raise Exception("PAT should not exist before calling addPF2PAT at the moment")
# Hack to not to crash if something in PAT assumes process.out
hasOut = hasattr(process, "out")
outputCommands = []
outputCommandsBackup = []
if hasOut:
outputCommandsBackup = process.out.outputCommands[:]
else:
process.out = cms.OutputModule("PoolOutputModule",
fileName = cms.untracked.string('dummy.root'),
outputCommands = cms.untracked.vstring()
)
outputCommands = []
# Jet modifications
# PhysicsTools/PatExamples/test/patTuple_42x_jec_cfg.py
jetCorrFactors = patJetCorrLevels(dataVersion, True)
jetCorrPayload = "AK5PFchs"
process.load("PhysicsTools.PatAlgos.patSequences_cff")
pfTools.usePF2PAT(process, runPF2PAT=True, jetAlgo="AK5", jetCorrections=(jetCorrPayload, jetCorrFactors),
runOnMC=dataVersion.isMC(), postfix=postfix)
outputCommands = [
# "keep *_selectedPatPhotons%s_*_*" % postfix,
# 'keep *_selectedPatElectrons%s_*_*' % postfix,
'keep *_selectedPatMuons%s_*_*' % postfix,
'keep *_selectedPatJets%s*_*_*' % postfix,
'keep *_selectedPatTaus%s_*_*' % postfix,
'keep *_selectedPatPFParticles%s_*_*' % postfix,
'keep *_selectedPatJets%s_pfCandidates_*' % postfix,
'drop *_*PF_caloTowers_*',
'drop *_*JPT_pfCandidates_*',
'drop *_*Calo_pfCandidates_*',
'keep *_patMETs%s_*_*' % postfix,
]
# Enable PFnoPU
getattr(process, "pfPileUp"+postfix).Enable = True
getattr(process, "pfPileUp"+postfix).checkClosestZVertex = False
getattr(process, "pfPileUp"+postfix).Vertices = "offlinePrimaryVertices"
# Jet modifications
# L1FastJet
# https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookJetEnergyCorrections#OffsetJEC
# https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookJetEnergyCorrections#JetEnCor2011
# https://hypernews.cern.ch/HyperNews/CMS/get/jes/184.html
kt6name = "kt6PFJets"+postfix
process.load('RecoJets.Configuration.RecoPFJets_cff')
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets
setattr(process, kt6name, kt4PFJets.clone(
rParam = 0.6,
src = 'pfNoElectron'+postfix,
doRhoFastjet = True,
doAreaFastJet = cms.bool(True),
))
getattr(process, "patPF2PATSequence"+postfix).replace(
getattr(process, "pfNoElectron"+postfix),
getattr(process, "pfNoElectron"+postfix) * getattr(process, kt6name))
getattr(process, "patJetCorrFactors"+postfix).rho = cms.InputTag(kt6name, "rho")
getattr(process, "patJetCorrFactors"+postfix).useRho = True
# ak5PFJets
getattr(process, "pfJets"+postfix).doAreaFastjet = cms.bool(True)
getattr(process, "pfJets"+postfix).doRhoFastjet = False
# getattr(process, "pfJets"+postfix).Vertices = cms.InputTag("goodPrimaryVertices")
setPatJetDefaults(getattr(process, "patJets"+postfix))
# Use HPS taus
# Add and recalculate the discriminators
addHChTauDiscriminators()
if not hasattr(process, "hpsPFTauDiscriminationForChargedHiggsByLeadingTrackPtCut"):
import RecoTauTag.RecoTau.PFRecoTauDiscriminationForChargedHiggs_cfi as HChPFTauDiscriminators
import RecoTauTag.RecoTau.CaloRecoTauDiscriminationForChargedHiggs_cfi as HChCaloTauDiscriminators
tauAlgos = ["hpsPFTau"]
# tauAlgos = ["pfTaus"+postfix]
HChPFTauDiscriminators.addPFTauDiscriminationSequenceForChargedHiggs(process, tauAlgos)
HChPFTauDiscriminatorsCont.addPFTauDiscriminationSequenceForChargedHiggsCont(process, tauAlgos)
PFTauTestDiscrimination.addPFTauTestDiscriminationSequence(process, tauAlgos)
fixFlightPath(process, tauAlgos[0])
fixFlightPath(process, tauAlgos[0], "Cont")
patHelpers.cloneProcessingSnippet(process, process.hpsPFTauHplusDiscriminationSequence, postfix)
patHelpers.cloneProcessingSnippet(process, process.hpsPFTauHplusDiscriminationSequenceCont, postfix)
patHelpers.cloneProcessingSnippet(process, process.hpsPFTauHplusTestDiscriminationSequence, postfix)
patTauSeq = cms.Sequence(
getattr(process, "hpsPFTauHplusDiscriminationSequence"+postfix) *
getattr(process, "hpsPFTauHplusDiscriminationSequenceCont"+postfix) *
getattr(process, "hpsPFTauHplusTestDiscriminationSequence"+postfix)
# getattr(process, "pfTaus"+postfix+"HplusDiscriminationSequence") *
# getattr(process, "pfTaus"+postfix+"HplusDiscriminationSequenceCont") *
# getattr(process, "pfTaus"+postfix+"HplusTestDiscriminationSequence")
)
setattr(process, "hplusPatTauSequence"+postfix, patTauSeq)
patHelpers.massSearchReplaceParam(patTauSeq, "PFTauProducer", cms.InputTag("hpsPFTauProducer"), cms.InputTag("pfTaus"+postfix))
patHelpers.massSearchReplaceAnyInputTag(patTauSeq, cms.InputTag("hpsPFTauDiscriminationByDecayModeFinding"), cms.InputTag("hpsPFTauDiscriminationByDecayModeFinding"+postfix))
pfTools.adaptPFTaus(process, "hpsPFTau", postfix=postfix)
setPatTauDefaults(getattr(process, "patTaus"+postfix), False)
addPatTauIsolationEmbedding(process, getattr(process, "patDefaultSequence"+postfix), postfix)
getattr(process, "selectedPatTaus"+postfix).cut = tauPreSelection
# The prediscriminant of pfTausBaseDiscriminationByLooseIsolation
# is missing from the default sequence, but since we don't want to
# apply any tau selections as a part of PF2PAT anyway, let's just
# remove this too
getattr(process, "pfTaus"+postfix).discriminators = cms.VPSet()
# getattr(process, "pfTauSequence"+postfix).remove(getattr(process, "pfTaus"+postfix))
# delattr(process, "pfTaus"+postfix)
# getattr(process, "pfTausBaseSequence"+postfix).remove(getattr(process, "pfTausBaseDiscriminationByLooseIsolation"+postfix))
# Remove the shrinking cone altogether, we don't care about it
# getattr(process, "patDefaultSequence"+postfix).remove(getattr(process, "patShrinkingConePFTauDiscrimination"+postfix))
# Override the tau source (this is WRONG in the standard PF2PAT, the expers should know it already)
# getattr(process, "patTaus"+postfix).tauSource = "hpsPFTauProducer"+postfix
# patHelpers.massSearchReplaceAnyInputTag(getattr(process, "patHPSPFTauDiscrimination"+postfix),
# cms.InputTag("pfTaus"+postfix),
# cms.InputTag("hpsPFTauProducer"+postfix))
# getattr(process, "pfNoTau"+postfix).topCollection = cms.InputTag("hpsPFTauProducer"+postfix)
# Disable iso deposits, they take a LOT of space
getattr(process, "patTaus"+postfix).isoDeposits = cms.PSet()
# Disable tau top projection, the taus are identified and removed
# from jets as a part of the analysis
getattr(process, "pfNoTau"+postfix).enable = False
# Lepton modifications
setPatLeptonDefaults(getattr(process, "patMuons"+postfix), False)
#setPatLeptonDefaults(getattr(process, "patElectrons"+postfix), False)
#addPatElectronID(process, getattr(process, "patElectrons"+postfix), getattr(process, "makePatElectrons"+postfix))
# PATElectronProducer segfaults, and we don't really need them now
getattr(process, "patDefaultSequence"+postfix).remove(getattr(process, "makePatElectrons"+postfix))
getattr(process, "patDefaultSequence"+postfix).remove(getattr(process, "selectedPatElectrons"+postfix))
getattr(process, "patDefaultSequence"+postfix).remove(getattr(process, "countPatElectrons"+postfix))
getattr(process, "patDefaultSequence"+postfix).remove(getattr(process, "countPatLeptons"+postfix))
# Disable muon and electron top projections, needs wider
# discussion about lepton definitions
getattr(process, "pfNoMuon"+postfix).enable = False
getattr(process, "pfNoElectron"+postfix).enable = False
# Remove photon MC matcher in order to avoid keeping photons in the event content
#process.patDefaultSequencePFlow.remove(process.photonMatchPFlow)
if hasOut:
process.out.outputCommands = outputCommandsBackup
process.out.outputCommands.extend(outputCommands)
else:
del process.out
getattr(process, "patDefaultSequence"+postfix).replace(
getattr(process, "patTaus"+postfix),
patTauSeq *
getattr(process, "patTaus"+postfix)
)
sequence = cms.Sequence(
getattr(process, "patPF2PATSequence"+postfix)
)
if doTauHLTMatching:
sequence *= HChTriggerMatching.addTauHLTMatching(process, matchingTauTrigger, collections=["selectedPatTaus"+postfix], postfix=postfix)
return sequence
process.pfJetsPF2PAT.doAreaFastjet = True
process.pfJetsPF2PAT.doRhoFastjet = False
removeMCMatching(process, ['All'])
removeIfInSequence(process, 'patJetGenJetMatchAK5JPT', "patDefaultSequence")
removeIfInSequence(process, 'patJetPartonMatchAK5JPT', "patDefaultSequence")
removeIfInSequence(process, 'patJetPartons', "patDefaultSequence")
removeIfInSequence(process, 'patJetPartonAssociation', "patDefaultSequence")
removeIfInSequence(process, 'patJetPartonAssociationAK5JPT', "patDefaultSequence")
removeIfInSequence(process, 'patJetFlavourAssociation', "patDefaultSequence")
removeIfInSequence(process, 'patJetFlavourAssociationAK5JPT', "patDefaultSequence")
process.load('RecoJets.Configuration.RecoJets_cff')
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets
process.kt6PFJets = kt4PFJets.clone()
process.kt6PFJets.rParam = 0.6
process.kt6PFJets.src = cms.InputTag('pfNoElectron'+postfix)
process.kt6PFJets.Rho_EtaMax = cms.double( 4.4)
process.kt6PFJets.doRhoFastjet = True
process.kt6PFJets.doAreaFastjet = True
#process.kt6PFJets.voronoiRfact = 0.9
#process.patJetCorrFactorsPFlow.rho = cms.InputTag("kt6PFJets", "rho")
getattr(process,"patJetCorrFactors"+postfix).rho = cms.InputTag("kt6PFJets", "rho")
process.load("MiniTree.MiniTreeProducer.neutralpfcandidates_cfi")
process.kt6NeutralPFJets = kt4PFJets.clone()
process.kt6NeutralPFJets.rParam = 0.6
process.kt6NeutralPFJets.Rho_EtaMax = cms.double( 4.4)
removeSpecificPATObjects(process, ['Electrons', 'Muons'])
removeCleaning(process)
process.pfAllMuons.src = cms.InputTag("particleFlow")
process.patJetsAK5PF.discriminatorSources = cms.VInputTag(
cms.InputTag("simpleSecondaryVertexHighEffBJetTagsAK5PF"),
cms.InputTag("simpleSecondaryVertexHighPurBJetTagsAK5PF"),
cms.InputTag("combinedSecondaryVertexBJetTagsAK5PF"),
)
if (release == '42X'):
# process.PFTau = process.recoTauClassicHPSSequence
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.patJetCorrFactorsAK5PF.rho = cms.InputTag("kt6PFJets", "rho")
#if isEmbedded:
# process.jetTracksAssociatorAtVertexAK5PF.tracks = cms.InputTag("tmfTracks")
process.btaggingAK5PF = cms.Sequence(
process.impactParameterTagInfosAK5PF
+process.secondaryVertexTagInfosAK5PF
+process.simpleSecondaryVertexHighEffBJetTagsAK5PF
+process.simpleSecondaryVertexHighPurBJetTagsAK5PF
+process.combinedSecondaryVertexBJetTagsAK5PF
)
else:
usePF2PAT(process,runPF2PAT=True, jetAlgo=jetAlgo, runOnMC=runOnMC, postfix=postfix,
jetCorrections=('AK5PFchs', ['L1FastJet', 'L2Relative', 'L3Absolute', 'L2L3Residual']) )
applyPostfix(process,"pfPileUp",postfix).checkClosestZVertex = cms.bool(False)
from PhysicsTools.PatAlgos.tools.metTools import *
process.pfPileUpPF2PAT.Enable = True
process.pfPileUpPF2PAT.Vertices = cms.InputTag('goodOfflinePrimaryVertices')
process.load('RecoJets.Configuration.RecoJets_cff')
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets
process.kt6PFJets = kt4PFJets.clone()
process.kt6PFJets.rParam = 0.6
#process.kt6PFJets.src = cms.InputTag('pfNoElectron'+postfix)
process.kt6PFJets.Rho_EtaMax = cms.double( 4.4)
process.kt6PFJets.doRhoFastjet = True
process.kt6PFJets.doAreaFastjet = True
#process.kt6PFJets.voronoiRfact = 0.9
#process.patJetCorrFactorsPFlow.rho = cms.InputTag("kt6PFJets", "rho")
getattr(process,"patJetCorrFactors"+postfix).rho = cms.InputTag("kt6PFJets", "rho")
#-------------------------------------
#Redo the primary vertex
from PhysicsTools.SelectorUtils.pvSelector_cfi import pvSelector
def configure( dataset, sourceNames=[], hltPaths=[], maxEvents = -1, outputName = '', runNoPUMVAMetSequence=False ):
""" This is the main routine used to configure the nTuplizer. Please check
the correctness of all relevant default parameters.
dataset: Please choose one of the entries in the lists.
sourceNames: list of AOD filenames
hltPaths: list of trigger hlt paths (will be ignored for MC)
maxEvents: maximal number of events
runNoPUMVAMetSequence: please read README for more details
"""
collisionDatasets = [
'52xPrompt', # Run2012[AB]{C}-PromptReco{_v1}
'52x23May2012', # Run2012A-23May2012
'53xPromptC', # Run2012C-PromptReco-v2
'53xPromptD', # Run2012D-PromptReco
'53x13July2012', # Run2012[AB]-13Jul2012
'53x06Aug2012', # Run2012A-06Aug2012
'53x24Aug2012', # Run2012C-24Aug2012
'53x11Dec2012', # Run2012C-EcalRecover_11Dec2012
'53x16Jan2013', # Run2012D-16Jan2013
'53x22Jan2013' # Run2012[ABCD]-22Jan2013
]
mcDatasets = [
'52xFullSim',
'52xFastSim',
'53xFullSim',
'53xFastSim'
]
isRealData = dataset in collisionDatasets
isMC = dataset in mcDatasets
isFastSim = isMC and 'FastSim' in dataset
is53x = '53x' in dataset
is52x = '52x' in dataset
if not isRealData and not isMC:
raise RuntimeError("Dataset " + dataset + " not defined")
import FWCore.ParameterSet.Config as cms
##########################
### Initialize process ###
##########################
process = cms.Process("RA3")
process.maxEvents = cms.untracked.PSet(input = cms.untracked.int32(maxEvents))
process.options = cms.untracked.PSet(
wantSummary = cms.untracked.bool(False),
FailPath = cms.untracked.vstring(
'FatalRootError'
)
)
process.source = cms.Source("PoolSource",
noEventSort = cms.untracked.bool(True),
duplicateCheckMode = cms.untracked.string('noDuplicateCheck'),
fileNames = cms.untracked.vstring(sourceNames)
)
#####################
### MessageLogger ###
#####################
process.load('FWCore.MessageService.MessageLogger_cfi')
process.MessageLogger.cerr.FwkReport.reportEvery = 1000
process.MessageLogger.suppressWarning = cms.untracked.vstring(
'newSecondaryVertexTagInfos',
'chsSecondaryVertexTagInfos',
'pfCandidateToVertexAssoc',
'manystripclus53X',
'toomanystripclus53X'
)
process.MessageLogger.suppressError = cms.untracked.vstring('ecalLaserCorrFilter')
process.MessageLogger.categories.append('SusyNtuplizer')
process.MessageLogger.cerr.SusyNtuplizer = cms.untracked.PSet( limit = cms.untracked.int32(100) )
#############################
### Conditions & Services ###
#############################
process.load('Configuration.Geometry.GeometryIdeal_cff')
process.load('Configuration.StandardSequences.MagneticField_38T_cff')
process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff')
# The following global tags are the latest as of April 8th 2013. The user is strongly recommended to check the
# SWGuideFrontierConditions twiki before running the configuration.
if dataset == '52xPrompt':
process.GlobalTag.globaltag = 'GR_P_V39_AN3::All'
elif dataset == '52x23May2012':
process.GlobalTag.globaltag = 'FT_P_V32B_AN4::All'
elif dataset == '53xPromptC' or dataset == '53xPromptD':
process.GlobalTag.globaltag = 'GR_P_V42_AN4::All'
elif dataset == '53x13July2012':
process.GlobalTag.globaltag = 'FT_53_V6C_AN4::All'
elif dataset == '53x06Aug2012':
process.GlobalTag.globaltag = 'FT_53_V6C_AN4::All'
elif dataset == '53x24Aug2012':
process.GlobalTag.globaltag = 'FT53_V10A_AN4::All'
elif dataset == '53x11Dec2012':
process.GlobalTag.globaltag = 'FT_P_V42C_AN4::All'
elif dataset == '53x16Jan2013':
process.GlobalTag.globaltag = 'FT_P_V43E_AN4::All'
elif dataset == '53x22Jan2013':
process.GlobalTag.globaltag = 'FT_53_V21_AN4::All'
elif isMC and is52x:
process.GlobalTag.globaltag = 'START52_V16::All'
elif isMC and is53x:
process.GlobalTag.globaltag = 'START53_V25::All'
#####################
### SusyNtuplizer ###
#####################
process.load("SUSYPhotonAnalysis.SusyNtuplizer.susyNtuplizer_cfi")
process.susyNtuplizer.debugLevel = 0
process.susyNtuplizer.isFastSim = isFastSim
process.susyNtuplizer.caloJetCollectionTags = []
if outputName:
process.susyNtuplizer.outputFileName = outputName
#########################
### HLT result filter ###
#########################
if len(hltPaths) != 0:
process.load("HLTrigger.HLTfilters.hltHighLevel_cfi")
process.hltHighLevel.HLTPaths = hltPaths
else:
process.hltHighLevel = cms.Sequence() # placeholder
##########################################
### Good vertex collection (transient) ###
##########################################
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")
)
process.primaryVertex = cms.EDFilter("PATSingleVertexSelector",
mode = cms.string('firstVertex'),
vertices = cms.InputTag('goodVertices'),
filter = cms.bool(False)
)
process.vertexSelectionSequence = cms.Sequence(
process.goodVertices +
process.primaryVertex
)
###########################
### PU Rho calculations ###
###########################
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets
#Calculate rho restricted to barrel for photon pileup subtraction
process.kt6PFJetsRhoBarrelOnly = kt4PFJets.clone(
src = cms.InputTag('particleFlow'),
rParam = cms.double(0.6),
#Eta range of jets to be considered for Rho calculation
#Should be at most (jet acceptance - jet radius)
doRhoFastjet = cms.bool(True),
Rho_EtaMax=cms.double(1.4442),
#Eta range of ghost jets to be considered for Rho calculation - must be greater than Rho_EtaMax
Ghost_EtaMax=cms.double(2.5)
)
#Calculate rho restricted to barrel for photon pileup subtraction
process.kt6PFJetsRho25 = kt4PFJets.clone(
src = cms.InputTag('particleFlow'),
rParam = cms.double(0.6),
#Eta range of jets to be considered for Rho calculation
#Should be at most (jet acceptance - jet radius)
doRhoFastjet = cms.bool(True),
Rho_EtaMax=cms.double(2.5)
)
process.puRhoSequence = cms.Sequence(
process.kt6PFJetsRhoBarrelOnly +
process.kt6PFJetsRho25
)
###############################
### PF-based reconstruction ###
###############################
# Run the full event reconstruction starting from the full list of PFCandidates (particleFlow).
# Serves as inputs to isoDeposit, CHS jets, and NoPUMET.
process.load("CommonTools.ParticleFlow.PFBRECO_cff")
process.pfPileUp.Vertices = cms.InputTag("goodVertices")
process.pfPileUp.checkClosestZVertex = False
process.pfBasedRecoSequence = cms.Sequence(
process.pfNoPileUpSequence +
process.pfParticleSelectionSequence +
process.pfPhotonSequence +
process.pfMuonSequence +
process.pfNoMuon +
process.pfElectronSequence +
process.pfNoElectron
)
####################################
### Photon & electron isoDeposit ###
####################################
# Runs PU identificaton over particleFlow, then calculates isodeposits around
# the given particles using the NoPU collection.
# The end product is equivalent to running setupPFIso in
# CommonTools.ParticleFlow.Tools.pfIsolation, just with fewer modules to run.
process.photonPFIsoDepositCharged = process.phPFIsoDepositCharged.clone(src = 'photons')
process.photonPFIsoDepositNeutral = process.phPFIsoDepositNeutral.clone(src = 'photons')
process.photonPFIsoDepositGamma = process.phPFIsoDepositGamma.clone(src = 'photons')
process.gsfElectronPFIsoDepositCharged = process.elPFIsoDepositCharged.clone(src = 'gsfElectrons')
process.gsfElectronPFIsoDepositNeutral = process.elPFIsoDepositNeutral.clone(src = 'gsfElectrons')
process.gsfElectronPFIsoDepositGamma = process.elPFIsoDepositGamma.clone(src = 'gsfElectrons')
process.photonPFIsoValueCharged03 = process.phPFIsoValueCharged03PFId.clone()
process.photonPFIsoValueCharged03.deposits[0].src = cms.InputTag('photonPFIsoDepositCharged')
process.photonPFIsoValueNeutral03 = process.phPFIsoValueNeutral03PFId.clone()
process.photonPFIsoValueNeutral03.deposits[0].src = cms.InputTag('photonPFIsoDepositNeutral')
process.photonPFIsoValueGamma03 = process.phPFIsoValueGamma03PFId.clone()
process.photonPFIsoValueGamma03.deposits[0].src = cms.InputTag('photonPFIsoDepositGamma')
process.gsfElectronPFIsoValueCharged03 = process.elPFIsoValueCharged03PFId.clone()
process.gsfElectronPFIsoValueCharged03.deposits[0].src = cms.InputTag('gsfElectronPFIsoDepositCharged')
process.gsfElectronPFIsoValueNeutral03 = process.elPFIsoValueNeutral03PFId.clone()
process.gsfElectronPFIsoValueNeutral03.deposits[0].src = cms.InputTag('gsfElectronPFIsoDepositNeutral')
process.gsfElectronPFIsoValueGamma03 = process.elPFIsoValueGamma03PFId.clone()
process.gsfElectronPFIsoValueGamma03.deposits[0].src = cms.InputTag('gsfElectronPFIsoDepositGamma')
process.photonIsoDepositSequence = cms.Sequence(
process.photonPFIsoDepositCharged +
process.photonPFIsoDepositNeutral +
process.photonPFIsoDepositGamma +
process.photonPFIsoValueCharged03 +
process.photonPFIsoValueNeutral03 +
process.photonPFIsoValueGamma03
)
process.gsfElectronIsoDepositSequence = cms.Sequence(
process.gsfElectronPFIsoDepositCharged +
process.gsfElectronPFIsoDepositNeutral +
process.gsfElectronPFIsoDepositGamma +
process.gsfElectronPFIsoValueCharged03 +
process.gsfElectronPFIsoValueNeutral03 +
process.gsfElectronPFIsoValueGamma03
)
process.pfIsolationSequence = cms.Sequence(
process.photonIsoDepositSequence +
process.gsfElectronIsoDepositSequence
)
###############################################
### PFchs (charged hadron subtraction) jets ###
###############################################
# pfJets comes from PFBRECO.
process.ak5PFchsJets = process.pfJets.clone()
process.ak5PFchsJets.doAreaFastjet = True
process.pfCHSJetSequence = cms.Sequence(
process.ak5PFchsJets
)
###########
### JEC ###
###########
process.load("JetMETCorrections.Configuration.DefaultJEC_cff")
process.load("JetMETCorrections.Configuration.JetCorrectionServices_cff")
# Setting up JEC ESProducers for ak5PFchs. This block will be included in the JetCorrectionServices_cff
# in a future tag by JetMET (April 8, 2013)
process.ak5PFchsL1Fastjet = process.ak5PFL1Fastjet.clone(algorithm = cms.string('AK5PFchs'))
process.ak5PFchsL2Relative = process.ak5PFL2Relative.clone(algorithm = cms.string('AK5PFchs'))
process.ak5PFchsL3Absolute = process.ak5PFL3Absolute.clone(algorithm = cms.string('AK5PFchs'))
process.ak5PFchsResidual = process.ak5PFResidual.clone(algorithm = cms.string('AK5PFchs'))
process.ak5PFchsL2L3 = cms.ESProducer('JetCorrectionESChain',
correctors = cms.vstring('ak5PFchsL2Relative', 'ak5PFchsL3Absolute')
)
process.ak5PFchsL2L3Residual = process.ak5PFchsL2L3.clone()
process.ak5PFchsL2L3Residual.correctors.append('ak5PFchsResidual')
process.ak5PFchsL1FastL2L3 = process.ak5PFchsL2L3.clone()
process.ak5PFchsL1FastL2L3.correctors.insert(0, 'ak5PFchsL1Fastjet')
process.ak5PFchsL1FastL2L3Residual = process.ak5PFchsL1FastL2L3.clone()
process.ak5PFchsL1FastL2L3Residual.correctors.append('ak5PFchsResidual')
###############################
### Corrected MET producers ###
###############################
process.load("JetMETCorrections.Type1MET.caloMETCorrections_cff")
process.load("JetMETCorrections.Type1MET.pfMETCorrections_cff")
if isRealData:
process.caloJetMETcorr.jetCorrLabel = cms.string("ak5CaloL2L3Residual")
process.pfJetMETcorr.jetCorrLabel = cms.string("ak5PFL1FastL2L3Residual")
else:
process.caloJetMETcorr.jetCorrLabel = cms.string("ak5CaloL2L3")
process.pfJetMETcorr.jetCorrLabel = cms.string("ak5PFL1FastL2L3")
from JetMETCorrections.Type1MET.pfMETsysShiftCorrections_cfi import pfMEtSysShiftCorr
process.pfMEtSysShiftCorr = pfMEtSysShiftCorr.clone(
srcVertices = cms.InputTag('goodVertices')
)
# http://cmssw.cvs.cern.ch/cgi-bin/cmssw.cgi/CMSSW/JetMETCorrections/Type1MET/python/pfMETsysShiftCorrections_cfi.py?revision=1.6&view=markup
# pfMEtSysShiftCorrParameters_2012runABCvsNvtx_data (_mc)
if isRealData:
process.pfMEtSysShiftCorr.parameter = cms.PSet(
px = cms.string("+0.2661 + 0.3217*Nvtx"),
py = cms.string("-0.2251 - 0.1747*Nvtx")
)
else:
process.pfMEtSysShiftCorr.parameter = cms.PSet(
px = cms.string("+0.1166 + 0.0200*Nvtx"),
py = cms.string("+0.2764 - 0.1280*Nvtx")
)
# Remove the track-based type 0 correction
process.producePFMETCorrections.remove(process.pfchsMETcorr)
# Use PF-based type 0 correction. Reference: AN-2012/333
# Note that type 0 and type 1 are not truly orthogonal; the implicit assumption is that the PU
# contributions are fully captured in the high-pt jet offset, low-pt jet, and non-clustering
# energy terms in the type 1 MET correction formula.
from CommonTools.RecoUtils.pfcand_assomap_cfi import PFCandAssoMap
from JetMETCorrections.Type1MET.pfMETCorrectionType0_cfi import pfMETcorrType0
# Full implementation requires the reconstruction of displaced vertex, which we are skipping here.
# (Displaced vertex reconstruction requires TrackExtra information and is impossible from AOD)
process.pfCandidateToVertexAssoc = PFCandAssoMap.clone()
# Attention: Type0PFMETcorrInputProducer does not produce sumEt of the correction.
process.pfType0MetCorrection = pfMETcorrType0.clone(
srcPFCandidateToVertexAssociations = cms.InputTag('pfCandidateToVertexAssoc'),
srcHardScatterVertex = cms.InputTag('primaryVertex')
)
process.pfType01CorrectedMet = process.pfType1CorrectedMet.clone(
srcType1Corrections = cms.VInputTag(
cms.InputTag('pfType0MetCorrection'),
cms.InputTag('pfJetMETcorr', 'type1')
)
)
process.pfType01p2CorrectedMet = process.pfType1p2CorrectedMet.clone(
srcType1Corrections = cms.VInputTag(
cms.InputTag('pfType0MetCorrection'),
cms.InputTag('pfJetMETcorr', 'type1')
)
)
process.pfSysShiftCorrectedMet = process.pfType1CorrectedMet.clone(
srcType1Corrections = cms.VInputTag(
cms.InputTag('pfMEtSysShiftCorr')
)
)
process.pfType01SysShiftCorrectedMet = process.pfType1CorrectedMet.clone(
srcType1Corrections = cms.VInputTag(
cms.InputTag('pfType0MetCorrection'),
cms.InputTag('pfJetMETcorr', 'type1'),
cms.InputTag('pfMEtSysShiftCorr')
)
)
process.correctedMetSequence = cms.Sequence(
process.produceCaloMETCorrections +
process.producePFMETCorrections +
process.pfCandidateToVertexAssoc +
process.pfType0MetCorrection +
process.pfType01CorrectedMet +
process.pfType01p2CorrectedMet +
process.pfMEtSysShiftCorr +
process.pfSysShiftCorrectedMet +
process.pfType01SysShiftCorrectedMet
)
#############################
### MVA-based electron ID ###
#############################
process.load('EGamma.EGammaAnalysisTools.electronIdMVAProducer_cfi')
process.eidMVASequence = cms.Sequence(
process.mvaTrigV0 *
process.mvaNonTrigV0
)
#################
### PU jet ID ###
#################
from RecoJets.JetProducers.PileupJetIDParams_cfi import full_5x, full_5x_chs, cutbased
from RecoJets.JetProducers.PileupJetID_cfi import pileupJetIdProducer, pileupJetIdProducerChs
process.recoPuJetId = pileupJetIdProducer.clone(
jets = cms.InputTag("ak5PFJets"),
algos = cms.VPSet(full_5x, cutbased),
applyJec = cms.bool(True),
inputIsCorrected = cms.bool(False),
residualsTxt = cms.FileInPath("RecoJets/JetProducers/data/mva_JetID_v1.weights.xml") # not used, but has to point to an existing file
)
process.recoPuJetIdChs = pileupJetIdProducerChs.clone(
jets = cms.InputTag("ak5PFchsJets"),
algos = cms.VPSet(full_5x_chs, cutbased),
applyJec = cms.bool(True),
inputIsCorrected = cms.bool(False),
residualsTxt = cms.FileInPath("RecoJets/JetProducers/data/mva_JetID_v1.weights.xml") # not used, but has to point to an existing file
)
process.recoPuJetIdSequence = cms.Sequence(
process.recoPuJetId +
process.recoPuJetIdChs
)
##################################
### Jet-parton matching for MC ###
##################################
if isMC:
process.myPartons = cms.EDProducer("PartonSelector",
withLeptons = cms.bool(False),
src = cms.InputTag("genParticles")
)
process.flavourByRef = cms.EDProducer("JetPartonMatcher",
jets = cms.InputTag("ak5PFJets"),
coneSizeToAssociate = cms.double(0.3),
partons = cms.InputTag("myPartons")
)
process.flavourAssociationAlg = cms.EDProducer("JetFlavourIdentifier",
srcByReference = cms.InputTag("flavourByRef"),
physicsDefinition = cms.bool(False)
)
process.flavourAssociationPhy = cms.EDProducer("JetFlavourIdentifier",
srcByReference = cms.InputTag("flavourByRef"),
physicsDefinition = cms.bool(True)
)
process.flavourByRefCHS = cms.EDProducer("JetPartonMatcher",
jets = cms.InputTag("ak5PFchsJets"),
coneSizeToAssociate = cms.double(0.3),
partons = cms.InputTag("myPartons")
)
process.flavourAssociationCHSAlg = cms.EDProducer("JetFlavourIdentifier",
srcByReference = cms.InputTag("flavourByRefCHS"),
physicsDefinition = cms.bool(False)
)
process.flavourAssociationCHSPhy = cms.EDProducer("JetFlavourIdentifier",
srcByReference = cms.InputTag("flavourByRefCHS"),
physicsDefinition = cms.bool(True)
)
process.JetFlavourMatchingSequence = cms.Sequence(
process.myPartons *
process.flavourByRef *
process.flavourByRefCHS *
process.flavourAssociationAlg *
process.flavourAssociationPhy *
process.flavourAssociationCHSAlg *
process.flavourAssociationCHSPhy
)
else:
process.JetFlavourMatchingSequence = cms.Sequence() # placeholder
#################
### b-tagging ###
#################
# Re-run b-tagging with PFJets as input
# b-tagging general configuration
process.load("RecoJets.JetAssociationProducers.ic5PFJetTracksAssociatorAtVertex_cfi")
process.load("RecoBTag.Configuration.RecoBTag_cff")
# create a new jets and tracks associaiton
process.newJetTracksAssociatorAtVertex = process.ic5PFJetTracksAssociatorAtVertex.clone(
jets = cms.InputTag("ak5PFJets"),
tracks = cms.InputTag("generalTracks")
)
process.chsJetTracksAssociatorAtVertex = process.ic5PFJetTracksAssociatorAtVertex.clone(
jets = cms.InputTag("ak5PFchsJets"),
tracks = cms.InputTag("generalTracks")
)
# impact parameter b-tag
process.newImpactParameterTagInfos = process.impactParameterTagInfos.clone(
jetTracks = cms.InputTag("newJetTracksAssociatorAtVertex")
)
process.chsImpactParameterTagInfos = process.impactParameterTagInfos.clone(
jetTracks = cms.InputTag("chsJetTracksAssociatorAtVertex")
)
# TCHE
process.newTrackCountingHighEffBJetTags = process.trackCountingHighEffBJetTags.clone(
tagInfos = cms.VInputTag( cms.InputTag("newImpactParameterTagInfos") )
)
process.chsTrackCountingHighEffBJetTags = process.trackCountingHighEffBJetTags.clone(
tagInfos = cms.VInputTag( cms.InputTag("chsImpactParameterTagInfos") )
)
# TCHP
process.newTrackCountingHighPurBJetTags = process.trackCountingHighPurBJetTags.clone(
tagInfos = cms.VInputTag( cms.InputTag("newImpactParameterTagInfos") )
)
process.chsTrackCountingHighPurBJetTags = process.trackCountingHighPurBJetTags.clone(
tagInfos = cms.VInputTag( cms.InputTag("chsImpactParameterTagInfos") )
)
# JP
process.newJetProbabilityBJetTags = process.jetProbabilityBJetTags.clone(
tagInfos = cms.VInputTag( cms.InputTag("newImpactParameterTagInfos") )
)
process.chsJetProbabilityBJetTags = process.jetProbabilityBJetTags.clone(
tagInfos = cms.VInputTag( cms.InputTag("chsImpactParameterTagInfos") )
)
# JBP
process.newJetBProbabilityBJetTags = process.jetBProbabilityBJetTags.clone(
tagInfos = cms.VInputTag( cms.InputTag("newImpactParameterTagInfos") )
)
process.chsJetBProbabilityBJetTags = process.jetBProbabilityBJetTags.clone(
tagInfos = cms.VInputTag( cms.InputTag("chsImpactParameterTagInfos") )
)
# secondary vertex b-tag
process.newSecondaryVertexTagInfos = process.secondaryVertexTagInfos.clone(
trackIPTagInfos = cms.InputTag("newImpactParameterTagInfos")
)
process.chsSecondaryVertexTagInfos = process.secondaryVertexTagInfos.clone(
trackIPTagInfos = cms.InputTag("chsImpactParameterTagInfos")
)
# SSV
process.newSimpleSecondaryVertexBJetTags = process.simpleSecondaryVertexBJetTags.clone(
tagInfos = cms.VInputTag( cms.InputTag("newSecondaryVertexTagInfos") )
)
process.chsSimpleSecondaryVertexBJetTags = process.simpleSecondaryVertexBJetTags.clone(
tagInfos = cms.VInputTag( cms.InputTag("chsSecondaryVertexTagInfos") )
)
# CSV
process.newCombinedSecondaryVertexBJetTags = process.combinedSecondaryVertexBJetTags.clone(
tagInfos = cms.VInputTag( cms.InputTag("newImpactParameterTagInfos"),
cms.InputTag("newSecondaryVertexTagInfos")
)
)
process.chsCombinedSecondaryVertexBJetTags = process.combinedSecondaryVertexBJetTags.clone(
tagInfos = cms.VInputTag( cms.InputTag("chsImpactParameterTagInfos"),
cms.InputTag("chsSecondaryVertexTagInfos")
)
)
# CSVMVA
process.newCombinedSecondaryVertexMVABJetTags = process.combinedSecondaryVertexMVABJetTags.clone(
tagInfos = cms.VInputTag( cms.InputTag("newImpactParameterTagInfos"),
cms.InputTag("newSecondaryVertexTagInfos")
)
)
process.chsCombinedSecondaryVertexMVABJetTags = process.combinedSecondaryVertexMVABJetTags.clone(
tagInfos = cms.VInputTag( cms.InputTag("chsImpactParameterTagInfos"),
cms.InputTag("chsSecondaryVertexTagInfos")
)
)
# soft electron b-tag
process.newSoftElectronTagInfos = process.softElectronTagInfos.clone(
jets = "ak5PFJets"
)
process.newSoftElectronBJetTags = process.softElectronBJetTags.clone(
tagInfos = cms.VInputTag( cms.InputTag("newSoftElectronTagInfos") )
)
process.chsSoftElectronTagInfos = process.softElectronTagInfos.clone(
jets = "ak5PFchsJets"
)
process.chsSoftElectronBJetTags = process.softElectronBJetTags.clone(
tagInfos = cms.VInputTag( cms.InputTag("chsSoftElectronTagInfos") )
)
# soft muon b-tag
process.newSoftMuonTagInfos = process.softMuonTagInfos.clone(
jets = "ak5PFJets"
)
process.newSoftMuonBJetTags = process.softMuonBJetTags.clone(
tagInfos = cms.VInputTag( cms.InputTag("newSoftMuonTagInfos") )
)
process.newSoftMuonByIP3dBJetTags = process.softMuonByIP3dBJetTags.clone(
tagInfos = cms.VInputTag( cms.InputTag("newSoftMuonTagInfos") )
)
process.newSoftMuonByPtBJetTags = process.softMuonByPtBJetTags.clone(
tagInfos = cms.VInputTag( cms.InputTag("newSoftMuonTagInfos") )
)
process.chsSoftMuonTagInfos = process.softMuonTagInfos.clone(
jets = "ak5PFchsJets"
)
process.chsSoftMuonBJetTags = process.softMuonBJetTags.clone(
tagInfos = cms.VInputTag( cms.InputTag("chsSoftMuonTagInfos") )
)
process.chsSoftMuonByIP3dBJetTags = process.softMuonByIP3dBJetTags.clone(
tagInfos = cms.VInputTag( cms.InputTag("chsSoftMuonTagInfos") )
)
process.chsSoftMuonByPtBJetTags = process.softMuonByPtBJetTags.clone(
tagInfos = cms.VInputTag( cms.InputTag("chsSoftMuonTagInfos") )
)
process.newJetTracksAssociator = cms.Sequence(
process.newJetTracksAssociatorAtVertex
)
process.chsJetTracksAssociator = cms.Sequence(
process.chsJetTracksAssociatorAtVertex
)
process.newJetBtaggingIP = cms.Sequence(
process.newImpactParameterTagInfos * (
process.newTrackCountingHighEffBJetTags +
process.newTrackCountingHighPurBJetTags +
process.newJetProbabilityBJetTags +
process.newJetBProbabilityBJetTags
)
)
process.chsJetBtaggingIP = cms.Sequence(
process.chsImpactParameterTagInfos * (
process.chsTrackCountingHighEffBJetTags +
process.chsTrackCountingHighPurBJetTags +
process.chsJetProbabilityBJetTags +
process.chsJetBProbabilityBJetTags
)
)
process.newJetBtaggingSV = cms.Sequence(
process.newImpactParameterTagInfos *
process.newSecondaryVertexTagInfos * (
process.newSimpleSecondaryVertexBJetTags +
process.newCombinedSecondaryVertexBJetTags +
process.newCombinedSecondaryVertexMVABJetTags
)
)
process.chsJetBtaggingSV = cms.Sequence(
process.chsImpactParameterTagInfos *
process.chsSecondaryVertexTagInfos * (
process.chsSimpleSecondaryVertexBJetTags +
process.chsCombinedSecondaryVertexBJetTags +
process.chsCombinedSecondaryVertexMVABJetTags
)
)
process.newJetBtaggingEle = cms.Sequence(
process.softElectronCands *
process.newSoftElectronTagInfos *
process.newSoftElectronBJetTags
)
process.chsJetBtaggingEle = cms.Sequence(
process.softElectronCands *
process.chsSoftElectronTagInfos *
process.chsSoftElectronBJetTags
)
process.newJetBtaggingMu = cms.Sequence(
process.newSoftMuonTagInfos * (
process.newSoftMuonBJetTags +
process.newSoftMuonByIP3dBJetTags +
process.newSoftMuonByPtBJetTags
)
)
process.chsJetBtaggingMu = cms.Sequence(
process.chsSoftMuonTagInfos * (
process.chsSoftMuonBJetTags +
process.chsSoftMuonByIP3dBJetTags +
process.chsSoftMuonByPtBJetTags
)
)
process.newJetBtagging = cms.Sequence(
process.newJetBtaggingIP +
process.newJetBtaggingSV +
process.newJetBtaggingEle +
process.newJetBtaggingMu
)
process.chsJetBtagging = cms.Sequence(
process.chsJetBtaggingIP +
process.chsJetBtaggingSV +
process.chsJetBtaggingEle +
process.chsJetBtaggingMu
)
# These are fixes for the JetProbability b-tagger calibrations as recommended by BTV.
# See https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuideBTagJetProbabilityCalibration#Calibration_in_52x_Data_and_MC
useSpecialBTagCalibration = True
if isRealData and is52x:
btagTrackProbability2DTag = "TrackProbabilityCalibration_2D_2012DataTOT_v1_offline"
btagTrackProbability3DTag = "TrackProbabilityCalibration_3D_2012DataTOT_v1_offline"
elif isRealData and is53x:
btagTrackProbability2DTag = "TrackProbabilityCalibration_2D_Data53X_v2"
btagTrackProbability3DTag = "TrackProbabilityCalibration_3D_Data53X_v2"
elif isMC and is53x:
btagTrackProbability2DTag = "TrackProbabilityCalibration_2D_MC53X_v2"
btagTrackProbability3DTag = "TrackProbabilityCalibration_3D_MC53X_v2"
else:
useSpecialBTagCalibration = False
if useSpecialBTagCalibration:
process.GlobalTag.toGet = cms.VPSet(
cms.PSet(record = cms.string("BTagTrackProbability2DRcd"),
tag = cms.string(btagTrackProbability2DTag),
connect = cms.untracked.string("frontier://FrontierPrep/CMS_COND_BTAU")
),
cms.PSet(record = cms.string("BTagTrackProbability3DRcd"),
tag = cms.string(btagTrackProbability3DTag),
connect = cms.untracked.string("frontier://FrontierPrep/CMS_COND_BTAU")
)
)
###########################
### Quark-gluon tagging ###
###########################
from QuarkGluonTagger.EightTeV.QGTagger_RecoJets_cff import goodOfflinePrimaryVerticesQG, QGTagger
process.goodOfflinePrimaryVerticesQG = goodOfflinePrimaryVerticesQG
process.QGTaggerAK5 = QGTagger.clone(
srcJets = cms.InputTag('ak5PFJets'),
srcRho = cms.InputTag('kt6PFJets', 'rho'),
srcRhoIso = cms.InputTag('kt6PFJetsRho25', 'rho')
)
process.QGTaggerAK5chs = QGTagger.clone(
srcJets = cms.InputTag('ak5PFchsJets'),
useCHS = cms.untracked.bool(True),
srcRho = cms.InputTag('kt6PFJets', 'rho'),
srcRhoIso = cms.InputTag('kt6PFJetsRho25', 'rho')
)
if isRealData:
process.QGTaggerAK5.jec = cms.untracked.string('ak5PFL1FastL2L3Residual')
process.QGTaggerAK5chs.jec = cms.untracked.string('ak5PFchsL1FastL2L3Residual')
else:
process.QGTaggerAK5.jec = cms.untracked.string('ak5PFL1FastL2L3')
process.QGTaggerAK5chs.jec = cms.untracked.string('ak5PFchsL1FastL2L3')
process.QGTaggingSequence = cms.Sequence(
process.goodOfflinePrimaryVerticesQG +
process.QGTaggerAK5 +
process.QGTaggerAK5chs
)
###################
### MET filters ###
###################
# HBHENoiseFilterResultProducer
process.load('CommonTools.RecoAlgos.HBHENoiseFilterResultProducer_cfi')
# HCAL laser events filter
process.load("RecoMET.METFilters.hcalLaserEventFilter_cfi")
process.hcalLaserEventFilter.taggingMode = cms.bool(True)
# EcalDeadCellTriggerPrimitiveFilter
process.load('RecoMET.METFilters.EcalDeadCellTriggerPrimitiveFilter_cfi')
process.EcalDeadCellTriggerPrimitiveFilter.taggingMode = cms.bool(True)
# EcalDeadCellBoundaryEnergyFilter
process.load('RecoMET.METFilters.EcalDeadCellBoundaryEnergyFilter_cfi')
process.EcalDeadCellBoundaryEnergyFilter.taggingMode = cms.bool(True)
# Tracking failure filter
process.load('RecoMET.METFilters.trackingFailureFilter_cfi')
process.trackingFailureFilter.taggingMode = cms.bool(True)
# EE Bad SC Filter
process.load('RecoMET.METFilters.eeBadScFilter_cfi')
process.eeBadScFilter.taggingMode = cms.bool(True)
# EE ring of fire
process.load('RecoMET.METFilters.eeNoiseFilter_cfi')
process.eeNoiseFilter.taggingMode = cms.bool(True)
# Inconsistent muon pf candidate filter
process.load('RecoMET.METFilters.inconsistentMuonPFCandidateFilter_cfi')
process.inconsistentMuonPFCandidateFilter.taggingMode = cms.bool(True)
# Greedy muon pf candidate filter
process.load('RecoMET.METFilters.greedyMuonPFCandidateFilter_cfi')
process.greedyMuonPFCandidateFilter.taggingMode = cms.bool(True)
# The ECAL laser correction filter (needs correct GT to work)
process.load('RecoMET.METFilters.ecalLaserCorrFilter_cfi')
process.ecalLaserCorrFilter.taggingMode = cms.bool(True)
# The tracking POG filters
process.load('RecoMET.METFilters.trackingPOGFilters_cff')
process.manystripclus53X.taggedMode = cms.untracked.bool(True)
process.toomanystripclus53X.taggedMode = cms.untracked.bool(True)
process.logErrorTooManyClusters.taggedMode = cms.untracked.bool(True)
process.logErrorTooManyTripletsPairs.taggedMode = cms.untracked.bool(True)
process.logErrorTooManySeeds.taggedMode = cms.untracked.bool(True)
#Add up all MET filters
process.metFiltersSequence = cms.Sequence(
process.HBHENoiseFilterResultProducer +
process.hcalLaserEventFilter +
process.EcalDeadCellTriggerPrimitiveFilter +
process.EcalDeadCellBoundaryEnergyFilter +
process.trackingFailureFilter +
process.eeBadScFilter +
process.eeNoiseFilter +
process.inconsistentMuonPFCandidateFilter +
process.greedyMuonPFCandidateFilter +
process.ecalLaserCorrFilter +
process.manystripclus53X +
process.toomanystripclus53X +
process.logErrorTooManyClusters +
process.logErrorTooManyTripletsPairs +
process.logErrorTooManySeeds
)
######################
### NoPU & MVA MET ###
######################
if runNoPUMVAMetSequence:
from RecoJets.JetProducers.PileupJetIDParams_cfi import JetIdParams
from JetMETCorrections.Configuration.JetCorrectionProducers_cff import ak5PFJetsL1
if isRealData:
process.ak5PFJetsL123Corrected = ak5PFJetsL1.clone(correctors = ['ak5PFL1FastL2L3Residual'])
else:
process.ak5PFJetsL123Corrected = ak5PFJetsL1.clone(correctors = ['ak5PFL1FastL2L3'])
process.recoPuJetIdCorrected = pileupJetIdProducer.clone(
jets = cms.InputTag("ak5PFJetsL123Corrected"),
algos = cms.VPSet(full_5x, cutbased),
residualsTxt = cms.FileInPath("RecoJets/JetProducers/data/mva_JetID_v1.weights.xml") # not used, but has to point to an existing file
)
# NoPU MET
from JetMETCorrections.METPUSubtraction.noPileUpPFMET_cff import noPileUpPFMEtData, noPileUpPFMEt
process.pfNoPileUpMetData = noPileUpPFMEtData.clone(
srcJets = cms.InputTag('ak5PFJetsL123Corrected'),
srcJetIds = cms.InputTag('recoPuJetIdCorrected', 'fullId'),
srcPFCandToVertexAssociations = cms.InputTag('pfCandidateToVertexAssoc'),
srcHardScatterVertex = cms.InputTag('primaryVertex')
)
process.pfNoPileUpMet = noPileUpPFMEt.clone(
srcMVAMEtData = cms.InputTag('pfNoPileUpMetData'),
srcLeptons = cms.VInputTag(
'pfIsolatedPhotons',
'pfIsolatedMuons',
'pfIsolatedElectrons'
),
srcType0Correction = cms.InputTag('pfType0MetCorrection'),
saveInputs = cms.bool(False)
)
# MVA MET
from JetMETCorrections.METPUSubtraction.mvaPFMET_cff import pfMEtMVA
process.pfMVAMet = pfMEtMVA.clone(
srcCorrJets = cms.InputTag('ak5PFJetsL123Corrected'),
srcLeptons = cms.VInputTag(
'pfIsolatedPhotons',
'pfIsolatedMuons',
'pfIsolatedElectrons'
)
)
process.noPUMVAMetSequence = cms.Sequence(
process.ak5PFJetsL123Corrected +
process.recoPuJetIdCorrected +
process.pfNoPileUpMetData +
process.pfNoPileUpMet +
process.pfMVAMet
)
else:
process.noPUMVAMetSequence = cms.Sequence() # placeholder
###################################################################
### Dataset-dependent sequence and event content configurations ###
###################################################################
if isRealData:
process.susyNtuplizer.metCollectionTags.remove('genMetTrue')
process.susyNtuplizer.jetFlavourMatchingTags = cms.PSet()
process.susyNtuplizer.gridParams = cms.vstring()
if isFastSim:
process.susyNtuplizer.muonCollectionTags = cms.vstring("muons")
process.susyNtuplizer.muonIdTags = cms.PSet()
process.metFiltersSequence.remove(process.HBHENoiseFilterResultProducer)
process.metFiltersSequence.remove(process.logErrorTooManyClusters)
process.metFiltersSequence.remove(process.logErrorTooManyTripletsPairs)
process.metFiltersSequence.remove(process.logErrorTooManySeeds)
# met filters with run = False will automatically be default = False
process.susyNtuplizer.metFilters.CSCBeamHalo.run = False
process.susyNtuplizer.metFilters.HcalNoise.run = False
process.susyNtuplizer.metFilters.LogErrorTooManyClusters.run = False
process.susyNtuplizer.metFilters.LogErrorTooManyTripletsPairs.run = False
process.susyNtuplizer.metFilters.LogErrorTooManySeeds.run = False
if is52x or isFastSim:
process.metFiltersSequence.remove(process.manystripclus53X)
process.metFiltersSequence.remove(process.toomanystripclus53X)
process.susyNtuplizer.metFilters.ManyStripClus53X.run = False
process.susyNtuplizer.metFilters.TooManyStripClus53X.run = False
if not runNoPUMVAMetSequence:
process.susyNtuplizer.metCollectionTags.remove('pfNoPileUpMet')
process.susyNtuplizer.metCollectionTags.remove('pfMVAMet')
if dataset in ['52xPrompt', '52x23May2012', '53xPromptC', '53x13July2012', '53x06Aug2012', '53x24Aug2012', '53x11Dec2013']:
process.susyNtuplizer.metFilters.HcalLaserEventList.default = True
if dataset in ['53xPromptD', '53x16Jan2013']:
process.susyNtuplizer.metFilters.HcalLaserOccupancy.default = True
if dataset == '53x22Jan2013':
process.susyNtuplizer.metFilters.HcalLaserRECOUserStep.default = True
else:
process.susyNtuplizer.metFilters.HcalLaserRECOUserStep.run = False
if dataset in ['53x13July2012', '53x24Aug2012']:
process.susyNtuplizer.metFilters.EcalLaserCorr.default = True
process.susyNtuplizer.storeLumiInfo = cms.bool(False)
if dataset == '53x22Jan2013':
process.correctedMetSequence.remove(process.pfMEtSysShiftCorr)
process.correctedMetSequence.remove(process.pfSysShiftCorrectedMet)
process.correctedMetSequence.remove(process.pfType01SysShiftCorrectedMet)
process.susyNtuplizer.metCollectionTags.remove('pfSysShiftCorrectedMet')
process.susyNtuplizer.metCollectionTags.remove('pfType01SysShiftCorrectedMet')
#####################
### Finalize path ###
#####################
process.standard_step = cms.Path(
process.hltHighLevel +
process.vertexSelectionSequence +
process.puRhoSequence +
process.pfBasedRecoSequence +
process.pfIsolationSequence +
process.pfCHSJetSequence +
process.correctedMetSequence +
process.eidMVASequence +
process.recoPuJetIdSequence +
process.JetFlavourMatchingSequence +
process.newJetTracksAssociator +
process.chsJetTracksAssociator +
process.newJetBtagging +
process.chsJetBtagging +
process.QGTaggingSequence +
process.metFiltersSequence
)
process.optional_step = cms.Path(
process.hltHighLevel +
process.noPUMVAMetSequence
)
process.ntuplizer_step = cms.Path(
process.hltHighLevel +
process.susyNtuplizer
)
process.schedule = cms.Schedule(process.standard_step,process.optional_step,process.ntuplizer_step)
return process
from FWCore.MessageService.MessageLogger_cfi import MessageLogger
process.MessageLogger = MessageLogger
process.MessageLogger.cerr.FwkReport.reportEvery = 100 # Report status ever 100 events
process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(-1) )
# Output file
process.TFileService = cms.Service("TFileService",
fileName = cms.string("test.root")
)
# rho value for isolation
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets # the 4 references the rParam = 0.4
process.kt6PFJetsForIsolation = kt4PFJets.clone(
rParam = 0.6,
doRhoFastjet = True,
Rho_EtaMax = cms.double(2.5)
)
# Energy and calibrations for electrons
process.load('Configuration.StandardSequences.GeometryDB_cff')
process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff')
process.GlobalTag.globaltag = 'GR_P_V42_AN3::All'
from ZFinder.Event.electron_regression_cfi import RandomNumberGeneratorService
# Set up random numbers (needed for the electron regression)
process.RandomNumberGeneratorService = RandomNumberGeneratorService
# Run on MC
for name, pset in kappa_jets.iteritems():
setattr(process.kappaTuple.Jets, name, pset)
process.kappaTuple.Jets.taggers = cms.vstring(
"puJetIDFullDiscriminant", "puJetIDFullLoose", "puJetIDFullMedium", "puJetIDFullTight"
)
#print reduce(lambda a, b: a * b, jet_resources + sorted(cmssw_jets.values()))
#process.path *= reduce(lambda a, b: a * b, jet_resources + sorted(cmssw_jets.values()))
# Gluon tagging? - https://twiki.cern.ch/twiki/bin/viewauth/CMS/GluonTag
# B-tagging (for ak5 jets)? - https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookBTagging#DifferentJets
# B-tagging for (ak5 CHS jets)? - https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookBTagging#DifferentJets
# PileupDensity ########################
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets
process.pileupDensitykt6PFJets = kt4PFJets.clone(rParam=0.6, doRhoFastjet=True, Rho_EtaMax=2.5)
process.kappaTuple.active += cms.vstring('Jets', 'PileupDensity')
process.kappaTuple.PileupDensity.rename = cms.vstring("fixedGridRhoFastjetAll => pileupDensity")
process.path *= (process.pileupDensitykt6PFJets)
# MET correction ----------------------------------------------------------
#TODO check type 0 corrections
from RecoMET.METProducers.PFMET_cfi import pfMet
process.pfMETCHS = pfMet.clone(src=cms.InputTag(input_PFCandidates))
process.kappaTuple.active += cms.vstring('MET')
# MET without forward region
process.PFCandidatesNoHF = cms.EDFilter("CandPtrSelector",
src = cms.InputTag(input_PFCandidates),
cut = cms.string("abs(eta) < 3" )
def addPATSequences(process,runMC):
# Load the PAT config
from PhysicsTools.PatAlgos.patEventContent_cff import patEventContent
process.out = cms.OutputModule("PoolOutputModule",
fileName = cms.untracked.string('patTuple.root'),
SelectEvents = cms.untracked.PSet( SelectEvents = cms.vstring('pat_step') ),
outputCommands = cms.untracked.vstring('drop *', *patEventContent )
)
###
process.load('PhysicsTools.PatAlgos.patSequences_cff')
from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT
postfix = "PFlow"
jetAlgo="AK5"
jetCorrections = None
if runMC:
jetCorrections = ('AK5PFchs', ['L1FastJet','L2Relative','L3Absolute'])
else:
jetCorrections = ('AK5PFchs', ['L1FastJet','L2Relative','L3Absolute','L2L3Residual'])
usePF2PAT(process,runPF2PAT=True,
jetAlgo=jetAlgo, runOnMC=runMC, postfix=postfix,jetCorrections=jetCorrections)
#from PhysicsTools.PatAlgos.tools.coreTools import removeMCMatching
#if not runMC:
# removeMCMatching(process, ['All'],"")
#-----------------Customization----------------
process.pfPileUpPFlow.Enable = True
process.pfPileUpPFlow.checkClosestZVertex = False
process.pfPileUpPFlow.Vertices = cms.InputTag('goodOfflinePrimaryVertices')
process.pfPileUpPFlow.verbose = True
process.pfJetsPFlow.doAreaFastjet = True
process.pfJetsPFlow.doRhoFastjet = False
from PhysicsTools.SelectorUtils.pvSelector_cfi import pvSelector
process.goodOfflinePrimaryVertices = cms.EDFilter(
"PrimaryVertexObjectFilter",
filterParams = pvSelector.clone( minNdof = cms.double(4.0), maxZ = cms.double(24.0) ),
src=cms.InputTag('offlinePrimaryVertices')
)
# Compute the mean pt per unit area (rho) from the PFCHS inputs
#from RecoJets.Configuration.RecoPFJets_cff import kt6PFJets,ak5PFJets
#process.kt6PFJetsPFlow = kt6PFJets.clone(
# src = cms.InputTag('pfNoElectron'+postfix),
# doAreaFastjet = cms.bool(True),
# doRhoFastjet = cms.bool(True)
# )
#process.patJetCorrFactorsPFlow.rho = cms.InputTag("kt6PFJetsPFlow", "rho")
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets
process.kt6PFJetsForPAT = kt4PFJets.clone(
rParam = cms.double(0.6),
doAreaFastjet = cms.bool(True),
doRhoFastjet = cms.bool(True)
)
process.patJetCorrFactorsPFlow.rho = cms.InputTag("kt6PFJetsForPAT", "rho")
from RecoJets.JetProducers.ak5PFJets_cfi import ak5PFJets
process.ak5PFJetsPileUp = ak5PFJets.clone( src = cms.InputTag('pfPileUp'+postfix) )
# Switch on PAT trigger
from PhysicsTools.PatAlgos.tools.trigTools import switchOnTrigger
#switchOnTrigger( process,triggerProducer = 'patTrigger', triggerEventProducer = 'patTriggerEvent', sequence = 'patPF2PATSequence',hltProcess = 'HLT', outputModule = 'out')
switchOnTrigger( process ,sequence ='patPF2PATSequence'+postfix)
process.patTrigger.addL1Algos = cms.bool( True )
switchOnTrigger( process ,sequence = 'patPF2PATSequence'+postfix) # to fix event content
#-------------------------------------------------------------------------------------------------------------
# Add modules to default sequence
#if runMC:
# getattr(process, "patElectrons"+postfix).embedGenMatch = True
# getattr(process, "patMuons"+postfix).embedGenMatch = True
#else:
# getattr(process, "patElectrons"+postfix).embedGenMatch = False
# getattr(process, "patMuons"+postfix).embedGenMatch = False
# Add modules to default sequence
getattr(process,"patPF2PATSequence"+postfix).replace(
getattr(process,"pfNoElectron"+postfix),
getattr(process,"pfNoElectron"+postfix)*process.kt6PFJetsForPAT
)
getattr(process,"patPF2PATSequence"+postfix).replace(
getattr(process,"pfNoPileUp"+postfix),
getattr(process,"pfNoPileUp"+postfix) * process.ak5PFJetsPileUp
)
#----------------------------------------------
# Let it run
process.pat_step = cms.Path(
process.goodOfflinePrimaryVertices *
#process.patDefaultSequence +
getattr(process,"patPF2PATSequence"+postfix)
)
# Add PatTrigger output to the created file
from PhysicsTools.PatAlgos.patEventContent_cff import patTriggerEventContent
# Add PF2PAT output to the created file
from PhysicsTools.PatAlgos.patEventContent_cff import patEventContentNoCleaning
patOutputCommands = cms.untracked.vstring('drop *',
'keep recoPFCandidates_particleFlow_*_*',
*patEventContentNoCleaning)
# Adjust the event content
patOutputCommands += [
#'keep *_selectedPat*_*_*',
'keep *_genParticles*_*_*',
'keep *_offlinePrimaryVertices*_*_*',
'keep *_goodOfflinePrimaryVertices*_*_*',
#'keep *_pileUpN*PrimaryVertices_*_*',
#'keep *_pfPileUpExclN*_*_*',
'keep *_pfPileUpPFlow*_*_*',
'keep *_pfNoPileUpPFlow*_*_*',
'keep *_ak5PFJetsPileUp_*_*',
'keep *_ak5PFJets_*_*',
'keep recoTracks_generalTracks_*_*',
'keep HcalNoiseSummary_hcalnoise_*_*',
'keep *_BeamHaloSummary_*_*',
#------- Trigger collections ------
'keep edmTriggerResults_TriggerResults_*_*',
'keep *_hltTriggerSummaryAOD_*_*',
'keep L1GlobalTriggerObjectMapRecord_*_*_*',
'keep L1GlobalTriggerReadoutRecord_*_*_*',
#------- CASTOR rec hits ------
'keep *_logErrorHarvester_*_*',
'keep *_castorreco_*_*',
#------- Calo towers (just for now) ------
'keep *_towerMaker_*_*',
#---------------PatTrigger----------------
'keep patTriggerObjects_patTrigger*_*_*',
'keep patTriggerFilters_patTrigger*_*_*',
'keep patTriggerPaths_patTrigger*_*_*',
'keep patTriggerEvent_patTriggerEvent*_*_*'
]
process.out.outputCommands = patOutputCommands
# top projections in PF2PAT:
getattr(process,"pfNoPileUp"+postfix).enable = True
getattr(process,"pfNoMuon"+postfix).enable = True
getattr(process,"pfNoElectron"+postfix).enable = True
getattr(process,"pfNoTau"+postfix).enable = False
getattr(process,"pfNoJet"+postfix).enable = True
# verbose flags for the PF2PAT modules
getattr(process,"pfNoJet"+postfix).verbose = False
# PF2PAT with only charged hadrons from first PV
postfixPUSubAK5 = "PFlowPUSubAK5"
usePF2PAT(process, runPF2PAT=True, jetAlgo="AK5", runOnMC=not options.useData, postfix=postfixPUSubAK5)
process.pfPileUpPFlowPUSubAK5.Enable = True
process.pfPileUpPFlowPUSubAK5.Vertices = cms.InputTag("goodOfflinePrimaryVertices")
process.pfJetsPFlowPUSubAK5.doAreaFastjet = True
process.pfJetsPFlowPUSubAK5.doRhoFastjet = False
process.pfJetsPFlowPUSubAK5.Ghost_EtaMax = 6.5
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets
process.kt6PFJets = kt4PFJets.clone(
src=cms.InputTag("pfNoElectronPFlowAK5"),
rParam=cms.double(0.6),
doAreaFastjet=cms.bool(True),
doRhoFastjet=cms.bool(True),
Ghost_EtaMax=cms.double(6.5),
)
process.kt6PFJetsPUSub = kt4PFJets.clone(
src=cms.InputTag("pfNoElectronPFlowPUSubAK5"),
rParam=cms.double(0.6),
doAreaFastjet=cms.bool(True),
doRhoFastjet=cms.bool(True),
Ghost_EtaMax=cms.double(6.5),
)
removeSpecificPATObjects(process, ["Taus"], postfix=postfixAK5)
removeSpecificPATObjects(process, ["Taus"], postfix=postfixPUSubAK5)
# turn to false when running on data
#--- Jet Corrections using PF and PF2PAT ---#
#--- twiki reference: CMSPublic/WorkBookJetEnergyCorrections ---#
#--- See also: PhysicsTools/PatExamples/test/patTuple_42x_jec_cfg.py ---#
#-----------------------------------------------------------------------#
from PhysicsTools.SelectorUtils.pvSelector_cfi import pvSelector
process.goodOfflinePrimaryVertices = cms.EDFilter(
"PrimaryVertexObjectFilter",
filterParams = pvSelector.clone( minNdof = cms.double(4.0), maxZ = cms.double(24.0) ),
src=cms.InputTag('offlinePrimaryVertices')
)
# Compute the mean pt per unit area (rho) from the PFchs inputs
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets
process.kt6PFJetsPFlow = kt4PFJets.clone(
rParam = cms.double(0.6),
src = cms.InputTag('pfNoElectron'+postfix),
doAreaFastjet = cms.bool(True),
doRhoFastjet = cms.bool(True)
)
process.patJetCorrFactorsPFlow.rho = cms.InputTag("kt6PFJetsPFlow", "rho")
# Needed for AOD PF jets
##-------------------- Import the JEC services -----------------------
process.load('JetMETCorrections.Configuration.DefaultJEC_cff')
process.kt6PFJets = kt4PFJets.clone(
rParam = cms.double(0.6),
src = cms.InputTag('pfNoElectron'),
doAreaFastjet = cms.bool(True),
doRhoFastjet = cms.bool(True)
)
# Add the PV selector and KT6 producer to the sequence
getattr(process,"patPF2PATSequence"+postfix).replace(
process.pfJetsPF2PAT.doAreaFastjet = True
process.pfJetsPF2PAT.doRhoFastjet = False
removeMCMatching(process, ['All'])
removeIfInSequence(process, 'patJetGenJetMatchAK5JPT', "patDefaultSequence")
removeIfInSequence(process, 'patJetPartonMatchAK5JPT', "patDefaultSequence")
removeIfInSequence(process, 'patJetPartons', "patDefaultSequence")
removeIfInSequence(process, 'patJetPartonAssociation', "patDefaultSequence")
removeIfInSequence(process, 'patJetPartonAssociationAK5JPT', "patDefaultSequence")
removeIfInSequence(process, 'patJetFlavourAssociation', "patDefaultSequence")
removeIfInSequence(process, 'patJetFlavourAssociationAK5JPT', "patDefaultSequence")
process.load('RecoJets.Configuration.RecoJets_cff')
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets
process.kt6PFJets = kt4PFJets.clone()
process.kt6PFJets.rParam = 0.6
process.kt6PFJets.src = cms.InputTag('pfNoElectron'+postfix)
process.kt6PFJets.Rho_EtaMax = cms.double( 4.4)
process.kt6PFJets.doRhoFastjet = True
process.kt6PFJets.doAreaFastjet = True
#process.kt6PFJets.voronoiRfact = 0.9
#process.patJetCorrFactorsPFlow.rho = cms.InputTag("kt6PFJets", "rho")
getattr(process,"patJetCorrFactors"+postfix).rho = cms.InputTag("kt6PFJets", "rho")
process.load("TopQuarkAnalysis.MiniTreeProducer.neutralpfcandidates_cfi")
process.kt6NeutralPFJets = kt4PFJets.clone()
process.kt6NeutralPFJets.rParam = 0.6
process.kt6NeutralPFJets.Rho_EtaMax = cms.double( 4.4)
#configure the pat to load the id in
process.load("PhysicsTools.PatAlgos.patSequences_cff");
### Taus are currently broken in 523, luckly I copied this example from a 41X config file where taus were also broken
from PhysicsTools.PatAlgos.tools.coreTools import *
removeSpecificPATObjects( process, ['Taus'] )
process.patDefaultSequence.remove( process.patTaus )
if isMC==False:
removeMCMatching(process, ['All'])
process.patElectrons.userData.userInts.src = cms.VInputTag('HEEPId')
#for isolation correction
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets
process.kt6PFJetsForIsolation = kt4PFJets.clone( rParam = 0.6, doRhoFastjet = True )
process.kt6PFJetsForIsolation.Rho_EtaMax = cms.double(2.5)
#little example analyzer
process.heepAnalyzer = cms.EDAnalyzer("HEEPAnalyzerPATHEEPId",
eleLabel=cms.InputTag("patElectrons")
)
process.p = cms.Path(process.kt6PFJetsForIsolation*
process.HEEPId* #makes the HEEPID value map
process.patDefaultSequence* #runs pat
process.heepAnalyzer #example analyser module
)
#process.patJetsPF2PAT.getJetMCFlavour = True
#process.patJetsPF2PAT.addGenPartonMatch = True
# Add the calo towers and PFCandidates.
process.patJetsPF2PAT.embedCaloTowers = True
process.patJetsPF2PAT.embedPFCandidates = True
process.patJetsPF2PAT.tagInfoSources = cms.VInputTag(
cms.InputTag("secondaryVertexTagInfosAODPF2PAT"))
###############################
###### Bare KT 0.6 jets #######
###############################
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets
process.kt6PFJetsPF2PAT = kt4PFJets.clone(
rParam=cms.double(0.6),
src=cms.InputTag('pfNoElectronPF2PAT'),
doAreaFastjet=cms.bool(True),
doRhoFastjet=cms.bool(True))
getattr(process, "patPF2PATSequencePF2PAT").replace(
getattr(process, "pfNoElectronPF2PAT"),
getattr(process, "pfNoElectronPF2PAT") *
getattr(process, "kt6PFJetsPF2PAT"))
# addJetCollection stuff
from PhysicsTools.PatAlgos.tools.jetTools import *
addJetCollection(
process,
cms.InputTag('ak5PFJets'),
'AK5',
# if release in ['72X']:
# process.ic72XSequence += process.PFTau
# if release in ['70XMINIAOD', '72XMINIAOD']:
# process.load('PhysicsTools.PatAlgos.slimming.unpackedTracksAndVertices_cfi')
# process.icMiniAODSequence += process.unpackedTracksAndVertices
#switchOnTrigger(process, outputModule="")
################################################################
# Need to create kt6PFJets in 42X for L1FastJet correction
################################################################
if release in ['72X', '72XMINIAOD']:
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.ic72XSequence += process.kt6PFJets
from PhysicsTools.SelectorUtils.pvSelector_cfi import pvSelector
process.goodOfflinePrimaryVertices = cms.EDFilter(
"PrimaryVertexObjectFilter",
filterParams=pvSelector.clone(minNdof=cms.double(4.0),
maxZ=cms.double(24.0)),
src=cms.InputTag('offlinePrimaryVertices'))
process.load("PhysicsTools.PatAlgos.patSequences_cff")
from PhysicsTools.PatAlgos.tools.coreTools import *
from PhysicsTools.PatAlgos.tools.pfTools import *
from PhysicsTools.PatAlgos.tools.tauTools import *
from PhysicsTools.PatAlgos.tools.jetTools import *
from RecoJets.JetProducers.ca4PFJets_cfi import ca4PFJets from RecoJets.JetProducers.fixedGridRhoProducer_cfi import fixedGridRhoAll from RecoJets.JetProducers.fixedGridRhoProducerFastjet_cfi import fixedGridRhoFastjetAll from RecoJets.JetProducers.caTopTaggers_cff import * from RecoJets.JetProducers.ak8PFJetsCHS_groomingValueMaps_cfi import ak8PFJetsCHSPrunedLinks, ak8PFJetsCHSFilteredLinks, ak8PFJetsCHSTrimmedLinks, ak8PFJetsCHSSoftDropLinks from RecoJets.JetProducers.ca8PFJetsCHS_groomingValueMaps_cfi import ca8PFJetsCHSPrunedLinks, ca8PFJetsCHSFilteredLinks, ca8PFJetsCHSTrimmedLinks, ca8PFJetsCHSSoftDropLinks from CommonTools.PileupAlgos.Puppi_cff import puppi from CommonTools.PileupAlgos.softKiller_cfi import softKiller from RecoJets.JetProducers.ak4PFJetsPuppi_cfi import ak4PFJetsPuppi from RecoJets.JetProducers.ak4PFJetsSK_cfi import ak4PFJetsSK sisCone7PFJets = sisCone5PFJets.clone( rParam = 0.7 ) ak7PFJets = ak5PFJets.clone( rParam = 0.7 ) ak8PFJets = ak5PFJets.clone( rParam = 0.8 ) gk7PFJets = gk5PFJets.clone( rParam = 0.7 ) kt6PFJets = kt4PFJets.clone( rParam = 0.6 ) ca8PFJets = ca4PFJets.clone( rParam = 0.8 ) #compute areas for Fastjet PU subtraction kt6PFJets.doRhoFastjet = True kt6PFJets.doAreaFastjet = True #use active areas and not Voronoi tessellation for the moment kt6PFJets.voronoiRfact = 0.9 ak4PFJets.doAreaFastjet = True ak5PFJets.doAreaFastjet = True ak5PFJetsTrimmed.doAreaFastjet = True ak7PFJets.doAreaFastjet = True ak8PFJets.doAreaFastjet = True ak4PFJetsSK.doAreaFastjet = True kt6PFJetsCentralChargedPileUp = kt6PFJets.clone(
def setup_jets(process, cms, options, postfix="PFlow"):
print "=" * 60
print "Setting up Jets"
print "=" * 60
# MC setup
inputJetCorrLabel = ("AK5PFchs", ["L1FastJet", "L2Relative", "L3Absolute"])
if options.useData: # data set up
inputJetCorrLabel = ("AK5PFchs", ["L1FastJet", "L2Relative", "L3Absolute", "L2L3Residual"])
print "Using jet energy corrections: "
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
###############################
###### 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)
#process.patJetsPF2PAT.embedGenJetMatch = True
#process.patJetsPF2PAT.getJetMCFlavour = True
#process.patJetsPF2PAT.addGenPartonMatch = True
# Add the calo towers and PFCandidates.
process.patJetsPF2PAT.embedCaloTowers = True
process.patJetsPF2PAT.embedPFCandidates = True
process.patJetsPF2PAT.tagInfoSources = cms.VInputTag( cms.InputTag("secondaryVertexTagInfosAODPF2PAT") )
###############################
###### Bare KT 0.6 jets #######
###############################
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets
process.kt6PFJetsPF2PAT = kt4PFJets.clone(
rParam = cms.double(0.6),
src = cms.InputTag('pfNoElectronPF2PAT'),
doAreaFastjet = cms.bool(True),
doRhoFastjet = cms.bool(True)
)
getattr(process,"patPF2PATSequencePF2PAT").replace( getattr(process,"pfNoElectronPF2PAT"), getattr(process,"pfNoElectronPF2PAT")*getattr(process,"kt6PFJetsPF2PAT") )
# addJetCollection stuff
#from PhysicsTools.PatAlgos.tools.jetTools import *
#addJetCollection(process,cms.InputTag('ak5PFJets'),
# 'AK5', 'PF',
# doJTA = True,
# doBTagging = True,
# jetCorrLabel = ('AK5PF', cms.vstring(['L1Offset', 'L2Relative', 'L3Absolute'])),
# doType1MET = False,
def getBaseConfig(
globaltag,
testfile,
maxevents,
nickname,
outputfilename,
kappaverbosity,
):
from Kappa.Skimming.KSkimming_template_cfg import process
process.source.fileNames = testfile
process.maxEvents.input = maxevents ## number of events to be processed (-1 = all in file)
process.kappaTuple.outputFile = outputfilename ## name of output file
process.kappaTuple.verbose = cms.int32(kappaverbosity) ## verbosity level
process.kappaTuple.profile = cms.bool(False)
if not globaltag.lower() == 'auto' :
process.GlobalTag.globaltag = globaltag
data = datasetsHelper.isData(nickname)
centerOfMassEnergy = datasetsHelper.getCenterOfMassEnergy(nickname)
process.options = cms.untracked.PSet( wantSummary = cms.untracked.bool(False) )
## some infos
print "\n--------CONFIGURATION----------"
print "input: ", testfile
print "nickname: ", nickname
print "global tag: ", process.GlobalTag.globaltag
print "max events: ", maxevents
print "output filename:", outputfilename
print "------------------\n"
process.p = cms.Path ( )
## ------------------------------------------------------------------------
# Configure Metadata describing the file
process.kappaTuple.active = cms.vstring('TreeInfo')
process.kappaTuple.TreeInfo.parameters = cms.PSet(
dataset = cms.string(datasetsHelper.getDatasetName(nickname)),
generator = cms.string(datasetsHelper.getGenerator(nickname)),
productionProcess = cms.string(datasetsHelper.getProcess(nickname)),
globalTag = cms.string(globaltag),
prodCampaignGlobalTag = cms.string(datasetsHelper.getProductionCampaignGlobalTag(nickname, centerOfMassEnergy)),
runPeriod = cms.string(datasetsHelper.getRunPeriod(nickname)),
jetMultiplicity = cms.int32(datasetsHelper.getJetMultiplicity(nickname)),
centerOfMassEnergy = cms.int32(centerOfMassEnergy),
puScenario = cms.string(datasetsHelper.getPuScenario(nickname, centerOfMassEnergy)),
isData = cms.bool(data)
)
## ------------------------------------------------------------------------
# General configuration
process.kappaTuple.active += cms.vstring('VertexSummary') ## save VertexSummary,
process.kappaTuple.VertexSummary.whitelist = cms.vstring('goodOfflinePrimaryVertices')
#process.kappaTuple.active += cms.vstring('BeamSpot') ## save Beamspot,
#process.kappaTuple.active += cms.vstring('TriggerObjects')
if data:
process.kappaTuple.active+= cms.vstring('DataInfo') ## produce Metadata for data,
else:
process.kappaTuple.active+= cms.vstring('GenInfo') ## produce Metadata for MC,
process.kappaTuple.active+= cms.vstring('GenParticles')
process.kappaTuple.Info.hltWhitelist = cms.vstring( ## HLT selection
# can be tested at http://regexpal.com
# matches 'HLT_Mu17_Mu8_v7' etc.
'^HLT_(Double)?Mu([0-9]+)_(Double)?Mu([0-9]+)(_v[[:digit:]]+)?$',
# matches 'HLT_DoubleMu7_v8' etc.
'^HLT_(Double)?Mu([0-9]+)(_v[[:digit:]]+)?$',
)
## ------------------------------------------------------------------------
# Configure PFCandidates and offline PV
# PFCandidates ------------------------------------------------------------
process.load('Kappa.Skimming.KPFCandidates_cff')
# Modifications for new particleFlow Pointers
#process.pfPileUp.PFCandidates = cms.InputTag('particleFlowPtrs')
#process.pfPileUpIso.PFCandidates = cms.InputTag('particleFlowPtrs')
#process.pfNoPileUp.bottomCollection = cms.InputTag('particleFlowPtrs')
#process.pfNoPileUpIso.bottomCollection = cms.InputTag('particleFlowPtrs')
process.pfJetTracksAssociatorAtVertex.jets= cms.InputTag('ak5PFJets')
process.p *= (process.goodOfflinePrimaryVertices * process.pfPileUp * process.pfNoPileUp)# process.makePFBRECO * process.makeKappaPFCandidates)
## ------------------------------------------------------------------------
# Configure Muons
process.load('Kappa.Skimming.KMuons_cff')
process.kappaTuple.active += cms.vstring('Muons') ## produce/save KappaMuons
#process.kappaTuple.Muons.minPt = cms.double(8.0)
process.goodMuons = cms.EDFilter('CandViewSelector',
src = cms.InputTag('muons'),
cut = cms.string("pt > 15.0 & abs(eta) < 8.0"),# & isGlobalMuon()"),
)
process.twoGoodMuons = cms.EDFilter('CandViewCountFilter',
src = cms.InputTag('goodMuons'),
minNumber = cms.uint32(2),
)
process.p *= (#process.goodMuons * process.twoGoodMuons *
process.makeKappaMuons)
## for muon iso
# https://github.com/ajgilbert/ICHiggsTauTau/blob/master/test/higgstautau_new_cfg.py#L430-L460
process.load('CommonTools.ParticleFlow.Isolation.pfMuonIsolation_cff')
process.muPFIsoValueCharged04PFIso = process.muPFIsoValueCharged04.clone()
process.muPFIsoValueChargedAll04PFIso = process.muPFIsoValueChargedAll04.clone()
process.muPFIsoValueGamma04PFIso = process.muPFIsoValueGamma04.clone()
process.muPFIsoValueNeutral04PFIso = process.muPFIsoValueNeutral04.clone()
process.muPFIsoValuePU04PFIso = process.muPFIsoValuePU04.clone()
process.muonPFIsolationValuesSequence = cms.Sequence(
process.muPFIsoValueCharged04PFIso+
process.muPFIsoValueChargedAll04PFIso+
process.muPFIsoValueGamma04PFIso+
process.muPFIsoValueNeutral04PFIso+
process.muPFIsoValuePU04PFIso
)
process.muPFIsoDepositCharged.src = cms.InputTag('muons')
process.muPFIsoDepositChargedAll.src = cms.InputTag('muons')
process.muPFIsoDepositNeutral.src = cms.InputTag('muons')
process.muPFIsoDepositGamma.src = cms.InputTag('muons')
process.muPFIsoDepositPU.src = cms.InputTag('muons')
## ------------------------------------------------------------------------
## KappaJets
process.load('Kappa.Skimming.KJets_cff')
process.kappaTuple.active += cms.vstring('Jets', 'PileupDensity')
process.kappaTuple.Jets = cms.PSet(
process.kappaNoCut,
process.kappaNoRegEx,
taggers = cms.vstring(
# 'QGlikelihood',
# 'QGmlp',
'TrackCountingHighEffBJetTags',
'TrackCountingHighPurBJetTags',
'JetProbabilityBJetTags',
'JetBProbabilityBJetTags',
'SoftElectronBJetTags',
'SoftMuonBJetTags',
'SoftMuonByIP3dBJetTags',
'SoftMuonByPtBJetTags',
'SimpleSecondaryVertexBJetTags',
'CombinedSecondaryVertexBJetTags',
'CombinedSecondaryVertexMVABJetTags',
'puJetIDFullDiscriminant',
'puJetIDFullLoose',
'puJetIDFullMedium',
'puJetIDFullTight',
#'puJetIDCutbasedDiscriminant',
#'puJetIDCutbasedLoose',
#'puJetIDCutbasedMedium',
#'puJetIDCutbasedTight'
),
AK5PFTaggedJets = cms.PSet(
src = cms.InputTag('ak5PFJets'),
#QGtagger = cms.InputTag('AK5PFJetsQGTagger'),
QGtagger = cms.InputTag(''),
Btagger = cms.InputTag('ak5PF'),
PUJetID = cms.InputTag('ak5PFPuJetMva'),
PUJetID_full = cms.InputTag('full'),
),
AK5PFTaggedJetsCHS = cms.PSet(
src = cms.InputTag('ak5PFJetsCHS'),
#QGtagger = cms.InputTag('AK5PFJetsCHSQGTagger'),
QGtagger = cms.InputTag(''),
Btagger = cms.InputTag('ak5PFCHS'),
PUJetID = cms.InputTag('ak5PFCHSPuJetMva'),
PUJetID_full = cms.InputTag('full'),
),
)
#process.kappaTuple.Jets.minPt = cms.double(5.0)
if not data:
process.kappaTuple.active += cms.vstring('GenJets')
process.kappaTuple.GenJets.whitelist = cms.vstring('ak5GenJets')
process.kappaTuple.GenJets.rename = cms.vstring('ak => AK')
# add kt6PFJets, needed for the PileupDensity
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets
process.kt6PFJets = kt4PFJets.clone( rParam = 0.6, doRhoFastjet = True )
process.kt6PFJets.Rho_EtaMax = cms.double(2.5)
process.p *= (
process.makePFJets *
process.makePFJetsCHS *
process.kt6PFJets *
# process.makeQGTagging *
process.makeBTagging *
process.makePUJetID
)
## ------------------------------------------------------------------------
## MET
# MET correction ----------------------------------------------------------
process.load('JetMETCorrections.Type1MET.pfMETCorrectionType0_cfi')
process.p *= (
process.type0PFMEtCorrection
)
#TODO check type 0 corrections
process.kappaTuple.active += cms.vstring('MET') ## produce/save KappaPFMET
process.kappaTuple.MET.whitelist = cms.vstring('pfChMet', '_pfMet_')
#process.kappaTuple.MET.rename = cms.vstring('pfChMet => PFMETCHS', 'pfMet => PFMET')
# MET correction ----------------------------------------------------------
process.load("JetMETCorrections.Type1MET.pfMETCorrections_cff")
process.pfchsMETcorr.src = cms.InputTag('goodOfflinePrimaryVertices')
# Type-0
process.pfMETCHS = process.pfType1CorrectedMet.clone(
applyType1Corrections = cms.bool(False),
applyType0Corrections = cms.bool(True)
)
# MET Path
process.p *= (
process.producePFMETCorrections * process.pfMETCHS
)
process.kappaTuple.MET.whitelist += cms.vstring("pfMETCHS")
## ------------------------------------------------------------------------
## And let it run
process.p *= (
process.kappaOut
)
print process.p
return process
process.vertexSelectionSequence = cms.Sequence(
process.goodVertices +
process.primaryVertex
)
###########################
### PU Rho calculations ###
###########################
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets
#Calculate rho restricted to barrel for photon pileup subtraction
process.kt6PFJetsRhoBarrelOnly = kt4PFJets.clone(
src = cms.InputTag('particleFlow'),
rParam = cms.double(0.6),
#Eta range of jets to be considered for Rho calculation
#Should be at most (jet acceptance - jet radius)
doRhoFastjet = cms.bool(True),
Rho_EtaMax=cms.double(1.4442),
#Eta range of ghost jets to be considered for Rho calculation - must be greater than Rho_EtaMax
Ghost_EtaMax=cms.double(2.5)
)
#Calculate rho restricted to barrel for photon pileup subtraction
process.kt6PFJetsRho25 = kt4PFJets.clone(
src = cms.InputTag('particleFlow'),
rParam = cms.double(0.6),
#Eta range of jets to be considered for Rho calculation
#Should be at most (jet acceptance - jet radius)
doRhoFastjet = cms.bool(True),
Rho_EtaMax=cms.double(2.5)
)
def initTP_Electrons(process, mcInfo=False, hltName="HLT", is7X=True):
################################################################################################################################
# ___ ____ ____ ____ _ _ ___ ___ ____ ____ ___ ____
# | |__| | __ |__| |\ | | \ |__] |__/ | | |__] |___
# | | | |__] | | | \| |__/ | | \ |__| |__] |___
################################################################################################################################
process.load("SimGeneral.HepPDTESSource.pythiapdt_cfi")
################################################################################################################################
# ____ _ _ ___ ____
# | | | | [__
# |___ |__| | ___]
SC_COLL_EB = "correctedHybridSuperClusters"
SC_COLL_EE = "correctedMulti5x5SuperClustersWithPreshower"
ELE_COLL = "gedGsfElectrons" if is7X else "gsfElectrons"
JET_COLL = "cleanPatJets" if is7X else "cleanPatJetsAK5PF"
TAG_CUTS = "p4().Pt() > 10 && abs(eta) < 2.5 && electronID('simpleEleId80relIso') == 7"
SC_PROBE_CUTS = "et>5 && abs(eta)<2.5"
GSF_PROBE_CUTS = "(ecalEnergy*sin(superClusterPosition.theta))>5 && abs(superCluster.eta) <= 2.5 && ecalDrivenSeed==1"
PAT_PROBE_CUTS = ("(isEB||isEE) && (abs(eta())<= 2.5) "
"&& (gsfTrack.trackerExpectedHitsInner.numberOfHits <= 1)"
"&& ( (isEB"
" && (sigmaIetaIeta<0.01)"
" && ( abs(deltaPhiSuperClusterTrackAtVtx)<0.06 )"
" && ( abs(deltaEtaSuperClusterTrackAtVtx)<0.004 )"
" && (hadronicOverEm<0.12)"
" )"
" || (isEE"
" && (sigmaIetaIeta<0.03)"
" && ( abs(deltaPhiSuperClusterTrackAtVtx)<0.03 )"
" && ( abs(deltaEtaSuperClusterTrackAtVtx)<0.007 )"
" && (hadronicOverEm<0.1) "
" )"
" )"
"&& passConversionVeto")
JET_CUTS = ("pt() >= 40.0 && abs(eta()) <= 2.4 "
" && neutralHadronEnergyFraction() < 0.99 "
" && neutralEmEnergyFraction() < 0.99 "
" && chargedEmEnergyFraction() < 0.99 "
" && chargedHadronEnergyFraction() > 0 "
" && chargedMultiplicity() > 0 "
" && (chargedMultiplicity() + neutralMultiplicity() + muonMultiplicity()) > 1")
# 2012 SingleElectron Triggers
PASS_ANY = '!triggerObjectMatchesByType("TriggerElectron").empty() && ('
PASS_ANY += '!triggerObjectMatchesByPath("HLT_Ele22_CaloIdL_CaloIsoVL_v*" ,1,0).empty() || '
PASS_ANY += '!triggerObjectMatchesByPath("HLT_Ele27_CaloIdL_CaloIsoVL_v*" ,1,0).empty() || '
PASS_ANY += '!triggerObjectMatchesByPath("HLT_Ele27_WP80_v*" ,1,0).empty() || '
PASS_ANY += '!triggerObjectMatchesByPath("HLT_Ele30_CaloIdVT_TrkIdT_v*" ,1,0).empty() || '
PASS_ANY += '!triggerObjectMatchesByPath("HLT_Ele32_CaloIdL_CaloIsoVL_TrkIdVL_TrkIsoVL_v*",1,0).empty() || '
PASS_ANY += '!triggerObjectMatchesByPath("HLT_Ele80_CaloIdVT_GsfTrkIdT_v*" ,0,1).empty() || '
PASS_ANY += '!triggerObjectMatchesByPath("HLT_Ele90_CaloIdVT_GsfTrkIdT_v*" ,0,1).empty() || '
# 2012 EleHad Triggers
PASS_ANY += '!triggerObjectMatchesByPath("HLT_CleanPFHT350_Ele5_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET45_v*" ,0,1).empty() || '
PASS_ANY += '!triggerObjectMatchesByPath("HLT_CleanPFHT350_Ele5_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET50_v*" ,0,1).empty() || '
PASS_ANY += '!triggerObjectMatchesByPath("HLT_CleanPFNoPUHT350_Ele5_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET45_v*" ,0,1).empty() || '
PASS_ANY += '!triggerObjectMatchesByPath("HLT_CleanPFNoPUHT350_Ele5_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET50_v*" ,0,1).empty() || '
PASS_ANY += '!triggerObjectMatchesByPath("HLT_CleanPFHT300_Ele15_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET45_v*" ,0,1).empty() || '
PASS_ANY += '!triggerObjectMatchesByPath("HLT_CleanPFHT300_Ele15_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET50_v*" ,0,1).empty() || '
PASS_ANY += '!triggerObjectMatchesByPath("HLT_CleanPFNoPUHT300_Ele15_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET45_v*",0,1).empty() || '
PASS_ANY += '!triggerObjectMatchesByPath("HLT_CleanPFNoPUHT300_Ele15_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET50_v*",0,1).empty() || '
PASS_ANY += '!triggerObjectMatchesByPath("HLT_CleanPFHT300_Ele40_CaloIdVT_TrkIdT_v*" ,1,0).empty() || '
PASS_ANY += '!triggerObjectMatchesByPath("HLT_CleanPFHT300_Ele60_CaloIdVT_TrkIdT_v*" ,1,0).empty() || '
PASS_ANY += '!triggerObjectMatchesByPath("HLT_CleanPFNoPUHT300_Ele40_CaloIdVT_TrkIdT_v*" ,1,0).empty() || '
PASS_ANY += '!triggerObjectMatchesByPath("HLT_CleanPFNoPUHT300_Ele60_CaloIdVT_TrkIdT_v*" ,1,0).empty() '
PASS_ANY += ')'
AllTriggerFlags = cms.PSet(
############################################################
# DO NOT USE LONG VARIABLE NAMES - THERE'S A BUG ! ! ! #
############################################################
# 2012 SingleElectron Triggers
passing_HLT_Ele22 = cms.string('!triggerObjectMatchesByPath("HLT_Ele22_CaloIdL_CaloIsoVL_v*" ,1,0).empty()'),
passing_HLT_Ele27 = cms.string('!triggerObjectMatchesByPath("HLT_Ele27_CaloIdL_CaloIsoVL_v*" ,1,0).empty()'),
passing_HLT_Ele27_WP80 = cms.string('!triggerObjectMatchesByPath("HLT_Ele27_WP80_v*" ,1,0).empty()'),
passing_HLT_Ele30 = cms.string('!triggerObjectMatchesByPath("HLT_Ele30_CaloIdVT_TrkIdT_v*" ,1,0).empty()'),
passing_HLT_Ele32 = cms.string('!triggerObjectMatchesByPath("HLT_Ele32_CaloIdL_CaloIsoVL_TrkIdVL_TrkIsoVL_v*" ,1,0).empty()'),
passing_HLT_Ele80 = cms.string('!triggerObjectMatchesByPath("HLT_Ele80_CaloIdVT_GsfTrkIdT_v*" ,0,1).empty()'),
passing_HLT_Ele90 = cms.string('!triggerObjectMatchesByPath("HLT_Ele90_CaloIdVT_GsfTrkIdT_v*" ,0,1).empty()'),
# 2012 EleHad Triggers
passing_HLT_CleanPFHT350_Ele5_PFMET45 = cms.string('!triggerObjectMatchesByPath("HLT_CleanPFHT350_Ele5_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET45_v*" ,0,1).empty()'),
passing_HLT_CleanPFHT350_Ele5_PFMET50 = cms.string('!triggerObjectMatchesByPath("HLT_CleanPFHT350_Ele5_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET50_v*" ,0,1).empty()'),
passing_HLT_CleanPFNoPUHT350_Ele5_PFMET45 = cms.string('!triggerObjectMatchesByPath("HLT_CleanPFNoPUHT350_Ele5_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET45_v*" ,0,1).empty()'),
passing_HLT_CleanPFNoPUHT350_Ele5_PFMET50 = cms.string('!triggerObjectMatchesByPath("HLT_CleanPFNoPUHT350_Ele5_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET50_v*" ,0,1).empty()'),
passing_HLT_CleanPFHT300_Ele15_PFMET45 = cms.string('!triggerObjectMatchesByPath("HLT_CleanPFHT300_Ele15_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET45_v*" ,0,1).empty()'),
passing_HLT_CleanPFHT300_Ele15_PFMET50 = cms.string('!triggerObjectMatchesByPath("HLT_CleanPFHT300_Ele15_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET50_v*" ,0,1).empty()'),
passing_HLT_CleanPFNoPUHT300_Ele15_PFMET45 = cms.string('!triggerObjectMatchesByPath("HLT_CleanPFNoPUHT300_Ele15_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET45_v*",0,1).empty()'),
passing_HLT_CleanPFNoPUHT300_Ele15_PFMET50 = cms.string('!triggerObjectMatchesByPath("HLT_CleanPFNoPUHT300_Ele15_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET50_v*",0,1).empty()'),
passing_HLT_CleanPFHT300_Ele40 = cms.string('!triggerObjectMatchesByPath("HLT_CleanPFHT300_Ele40_CaloIdVT_TrkIdT_v*" ,0,1).empty()'),
passing_HLT_CleanPFHT300_Ele60 = cms.string('!triggerObjectMatchesByPath("HLT_CleanPFHT300_Ele60_CaloIdVT_TrkIdT_v*" ,0,1).empty()'),
passing_HLT_CleanPFNoPUHT300_Ele40 = cms.string('!triggerObjectMatchesByPath("HLT_CleanPFNoPUHT300_Ele40_CaloIdVT_TrkIdT_v*" ,0,1).empty()'),
passing_HLT_CleanPFNoPUHT300_Ele60 = cms.string('!triggerObjectMatchesByPath("HLT_CleanPFNoPUHT300_Ele60_CaloIdVT_TrkIdT_v*" ,0,1).empty()'),
)
################################################################################################################################
# ___ ____ ____ ____
# | |__| | __ [__
# | | | |__] ___]
process.tagPATElectrons = cms.EDFilter("PATElectronRefSelector",
src = cms.InputTag("cleanPatElectronsTriggerMatch"),
cut = cms.string( TAG_CUTS + " && " + PASS_ANY )
)
################################################################################################################################
# ___ ____ ____ ___ ____ ____
# |__] |__/ | | |__] |___ [__
# | | \ |__| |__] |___ ___]
## ____ ____ _ _
## / ___| _ _ _ __ ___ _ __ / ___| |_ _ ___| |_ ___ _ __
## \___ \| | | | '_ \ / _ \ '__| | | | | | / __| __/ _ \ '__|
## ___) | |_| | |_) | __/ | | |___| | |_| \__ \ || __/ |
## |____/ \__,_| .__/ \___|_| \____|_|\__,_|___/\__\___|_|
##
# probe1: superclusters
# SuperClusters ################
process.superClusters = cms.EDProducer("SuperClusterMerger",
src = cms.VInputTag(cms.InputTag( SC_COLL_EB ), cms.InputTag( SC_COLL_EE) )
)
process.superClusterCands = cms.EDProducer("ConcreteEcalCandidateProducer",
src = cms.InputTag("superClusters"),
particleType = cms.int32(11),
)
# Get the above SC's Candidates and place a cut on their Et and eta
process.goodSuperClusters = cms.EDFilter("CandViewSelector",
src = cms.InputTag("superClusterCands"),
cut = cms.string( SC_PROBE_CUTS ),
filter = cms.bool(True)
)
#### remove real jets (with high hadronic energy fraction) from SC collection
##### this improves the purity of the probe sample without affecting efficiency
process.JetsToRemoveFromSuperCluster = cms.EDFilter("CaloJetSelector",
src = cms.InputTag("ak5CaloJets"),
cut = cms.string('pt>5 && energyFractionHadronic > 0.15')
)
process.goodSuperClustersClean = cms.EDProducer("CandViewCleaner",
srcObject = cms.InputTag("goodSuperClusters"),
module_label = cms.string(''),
srcObjectsToRemove = cms.VInputTag(cms.InputTag("JetsToRemoveFromSuperCluster")),
deltaRMin = cms.double(0.1)
)
## ____ __ _____ _ _
## / ___|___ / _| ____| | ___ ___| |_ _ __ ___ _ __
## | | _/ __| |_| _| | |/ _ \/ __| __| '__/ _ \| '_ \
## | |_| \__ \ _| |___| | __/ (__| |_| | | (_) | | | |
## \____|___/_| |_____|_|\___|\___|\__|_| \___/|_| |_|
##
# probe2: GsfElectrons
# GsfElectron ################
process.goodElectrons = cms.EDFilter("GsfElectronRefSelector",
src = cms.InputTag(ELE_COLL),
cut = cms.string( GSF_PROBE_CUTS )
)
# probe3: Pat Electrons
process.goodPATElectrons = cms.EDFilter("PATElectronRefSelector",
src = cms.InputTag("cleanPatElectronsTriggerMatch"),
cut = cms.string( PAT_PROBE_CUTS ),
)
process.allEleTagsAndProbes = cms.Sequence(
process.tagPATElectrons +
(process.superClusters *
process.superClusterCands *
(process.goodSuperClusters + process.JetsToRemoveFromSuperCluster) *
process.goodSuperClustersClean) +
process.goodElectrons +
process.goodPATElectrons
)
################################################################################################################################
# ___ ____ ____ _ _ ___ ____ ____ ___ ____ ___ ____ _ ____ ____
# | |__| | __ |\ | |__] |__/ | | |__] |___ |__] |__| | |__/ [__
# | | | |__] | \| | | \ |__| |__] |___ | | | | | \ ___]
#
## _____ ___ ____ ____ _
## |_ _( _ ) | _ \ | _ \ __ _(_)_ __ ___
## | | / _ \/\ |_) | | |_) / _` | | '__/ __|
## | || (_> < __/ | __/ (_| | | | \__ \
## |_| \___/\/_| |_| \__,_|_|_| |___/
##
##
# Tag & probe selection ######
process.tagPATSC = cms.EDProducer("CandViewShallowCloneCombiner",
decay = cms.string("tagPATElectrons@+ goodSuperClustersClean@-"),
checkCharge = cms.bool(False),
cut = cms.string("40 < mass < 140"),
)
process.tagPATGsf = process.tagPATSC.clone()
process.tagPATGsf.decay = cms.string("tagPATElectrons@+ goodElectrons@-")
process.tagPATGoodPATElectron = process.tagPATSC.clone()
process.tagPATGoodPATElectron.decay = cms.string("tagPATElectrons@+ goodPATElectrons@-")
process.allEleTPPairs = cms.Sequence(
process.tagPATSC +
process.tagPATGsf +
process.tagPATGoodPATElectron
)
################################################################################################################################
# _ _ ____ ___ ____ _ _ ____ _ _ ___ ___ ____ ____ ____
# |\/| |__| | | |__| |__| |\ | | \ |__] |__| [__ [__
# | | | | | |___ | | | | | \| |__/ | | | ___] ___]
## ____ ____ __ ____ __
## / ___| / ___| \ \ / ___|___ / _|
## \___ \| | _____\ \ | | _/ __| |_
## ___) | |___ |_____/ / | |_| \__ \ _|
## |____/ \____| /_/ \____|___/_|
##
# passing1: Superclusters passing as Gsf Electrons
process.GsfMatchedSuperClusterCands = cms.EDProducer("ElectronMatchedCandidateProducer",
src = cms.InputTag("goodSuperClustersClean"),
ReferenceElectronCollection = cms.untracked.InputTag("goodElectrons"),
deltaR = cms.untracked.double(0.3)
)
## ____ __ __ ___ ___ _
## / ___|___ / _| \ \ |_ _|___ ___ |_ _|__| |
## | | _/ __| |_ _____\ \ | |/ __|/ _ \ | |/ _` |
## | |_| \__ \ _| |_____/ / | |\__ \ (_) | _ | | (_| |
## \____|___/_| /_/ |___|___/\___/ ( ) |___\__,_|
## |/
# passing2: Gsf electrons passing isolation, ID cuts (Pat electrons)
if is7X:
process.GSFtoPATMatchedElectrons = cms.EDProducer("PatMatchedGsfElectronProducer",
srcObject = cms.InputTag("goodElectrons"),
srcObjectsToMatch = cms.VInputTag(cms.InputTag("goodPATElectrons")),
deltaRMax = cms.double(0.1), # Because Pat Electrons are Gsf Electrons
) # 0.01
process.GSFPassingGoodPat = cms.EDProducer("ElectronMatchedCandidateProducer",
src = cms.InputTag("goodElectrons"),
ReferenceElectronCollection = cms.untracked.InputTag("GSFtoPATMatchedElectrons"),
deltaR = cms.untracked.double(0.3)
)
process.GSFtoPATMatchedSuperClusterCandsClean = cms.EDProducer("ElectronMatchedCandidateProducer",
src = cms.InputTag("goodSuperClustersClean"),
ReferenceElectronCollection = cms.untracked.InputTag("GSFtoPATMatchedElectrons"),
deltaR = cms.untracked.double(0.3)
)
process.allElePassingProbes = cms.Sequence(
process.GsfMatchedSuperClusterCands +
process.GSFtoPATMatchedElectrons *
( process.GSFtoPATMatchedSuperClusterCandsClean +
process.GSFPassingGoodPat )
)
else:
process.GSFPassingGoodPat = cms.EDProducer("MatchGsfElectronsToPAT",
electrons = cms.InputTag("goodElectrons"),
pat = cms.InputTag("goodPATElectrons"),
patCut = cms.string("pt>0"),
matchByReference = cms.bool(False)
)
process.GSFtoPATMatchedSuperClusterCandsClean = cms.EDProducer("ElectronMatchedCandidateProducer",
src = cms.InputTag("goodSuperClustersClean"),
ReferenceElectronCollection = cms.untracked.InputTag("GSFPassingGoodPat"),
deltaR = cms.untracked.double(0.3)
)
process.allElePassingProbes = cms.Sequence(
process.GsfMatchedSuperClusterCands +
process.GSFPassingGoodPat * process.GSFtoPATMatchedSuperClusterCandsClean
)
## ___ _ __ _ _ _ _____
## |_ _|__| | \ \ | | | | | |_ _|
## | |/ _` | _____\ \ | |_| | | | |
## | | (_| | |_____/ / | _ | |___| |
## |___\__,_| /_/ |_| |_|_____|_|
##
# passing 3: ID electrons passing HLT paths
# corresponding matches and passes can be found in the top CUTS sections
# Additional variable to check if event passed the specific cross trigger
process.patEventPassingHLTCleanPFHT350Ele5PFMET45 = cms.EDProducer("HLTResultProducer",
probes = cms.InputTag("cleanPatElectronsTriggerMatch"),
TriggerResultsTag = cms.InputTag("TriggerResults","",hltName),
HLTPaths = cms.vstring("HLT_CleanPFHT350_Ele5_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET45_v.*"),
andOr = cms.bool(True)
)
process.patEventPassingHLTCleanPFHT350Ele5PFMET50 = process.patEventPassingHLTCleanPFHT350Ele5PFMET45.clone(HLTPaths = cms.vstring("HLT_CleanPFHT350_Ele5_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET50_v.*"))
process.patEventPassingHLTCleanPFHT300Ele15PFMET45 = process.patEventPassingHLTCleanPFHT350Ele5PFMET45.clone(HLTPaths = cms.vstring("HLT_CleanPFHT300_Ele15_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET45_v.*"))
process.patEventPassingHLTCleanPFHT300Ele15PFMET50 = process.patEventPassingHLTCleanPFHT350Ele5PFMET45.clone(HLTPaths = cms.vstring("HLT_CleanPFHT300_Ele15_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET50_v.*"))
process.patEventPassingHLTCleanPFHT300Ele40 = process.patEventPassingHLTCleanPFHT350Ele5PFMET45.clone(HLTPaths = cms.vstring("HLT_CleanPFHT300_Ele40_CaloIdVT_TrkIdT_v.*"))
process.patEventPassingHLTCleanPFHT300Ele60 = process.patEventPassingHLTCleanPFHT350Ele5PFMET45.clone(HLTPaths = cms.vstring("HLT_CleanPFHT300_Ele60_CaloIdVT_TrkIdT_v.*"))
process.patEventPassingHLTCleanPFNoPUHT350Ele5PFMET45 = process.patEventPassingHLTCleanPFHT350Ele5PFMET45.clone(HLTPaths = cms.vstring("HLT_CleanPFNoPUHT350_Ele5_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET45_v.*"))
process.patEventPassingHLTCleanPFNoPUHT350Ele5PFMET50 = process.patEventPassingHLTCleanPFHT350Ele5PFMET45.clone(HLTPaths = cms.vstring("HLT_CleanPFNoPUHT350_Ele5_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET50_v.*"))
process.patEventPassingHLTCleanPFNoPUHT300Ele15PFMET45 = process.patEventPassingHLTCleanPFHT350Ele5PFMET45.clone(HLTPaths = cms.vstring("HLT_CleanPFNoPUHT300_Ele15_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET45_v.*"))
process.patEventPassingHLTCleanPFNoPUHT300Ele15PFMET50 = process.patEventPassingHLTCleanPFHT350Ele5PFMET45.clone(HLTPaths = cms.vstring("HLT_CleanPFNoPUHT300_Ele15_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET50_v.*"))
process.patEventPassingHLTCleanPFNoPUHT300Ele40 = process.patEventPassingHLTCleanPFHT350Ele5PFMET45.clone(HLTPaths = cms.vstring("HLT_CleanPFNoPUHT300_Ele40_CaloIdVT_TrkIdT_v.*"))
process.patEventPassingHLTCleanPFNoPUHT300Ele60 = process.patEventPassingHLTCleanPFHT350Ele5PFMET45.clone(HLTPaths = cms.vstring("HLT_CleanPFNoPUHT300_Ele60_CaloIdVT_TrkIdT_v.*"))
process.allEleHLTResults = cms.Sequence(
process.patEventPassingHLTCleanPFHT350Ele5PFMET45 +
process.patEventPassingHLTCleanPFHT350Ele5PFMET50 +
process.patEventPassingHLTCleanPFHT300Ele15PFMET45 +
process.patEventPassingHLTCleanPFHT300Ele15PFMET50 +
process.patEventPassingHLTCleanPFHT300Ele40 +
process.patEventPassingHLTCleanPFHT300Ele60 +
process.patEventPassingHLTCleanPFNoPUHT350Ele5PFMET45 +
process.patEventPassingHLTCleanPFNoPUHT350Ele5PFMET50 +
process.patEventPassingHLTCleanPFNoPUHT300Ele15PFMET45 +
process.patEventPassingHLTCleanPFNoPUHT300Ele15PFMET50 +
process.patEventPassingHLTCleanPFNoPUHT300Ele40 +
process.patEventPassingHLTCleanPFNoPUHT300Ele60
)
## __ __ ____ __ __ _ _
## | \/ |/ ___| | \/ | __ _| |_ ___| |__ ___ ___
## | |\/| | | | |\/| |/ _` | __/ __| '_ \ / _ \/ __|
## | | | | |___ | | | | (_| | || (__| | | | __/\__ \
## |_| |_|\____| |_| |_|\__,_|\__\___|_| |_|\___||___/
##
process.McMatchSC = cms.EDProducer("MCTruthDeltaRMatcherNew",
matchPDGId = cms.vint32(11),
src = cms.InputTag("goodSuperClustersClean"),
distMin = cms.double(0.3),
matched = cms.InputTag("genParticles")
)
process.McMatchGsf = process.McMatchSC.clone()
process.McMatchGsf.src = cms.InputTag("goodElectrons")
process.McMatchGSF = process.McMatchSC.clone()
process.McMatchGSF.src = cms.InputTag(ELE_COLL)
process.McMatchPATElectron = process.McMatchSC.clone()
process.McMatchPATElectron.src = cms.InputTag("goodPATElectrons")
process.McMatchTagPATElectron = process.McMatchSC.clone()
process.McMatchTagPATElectron.src = cms.InputTag("tagPATElectrons")
process.allEleMcMatches = cms.Sequence(
process.McMatchSC +
process.McMatchGSF +
process.McMatchGsf +
process.McMatchPATElectron +
process.McMatchTagPATElectron
)
################################################################################################################################
## _____ _ _ __ __
## | ____|_ _| |_ ___ _ __ _ __ __ _| | \ \ / /_ _ _ __ ___
## | _| \ \/ / __/ _ \ '__| '_ \ / _` | | \ \ / / _` | '__/ __|
## | |___ > <| || __/ | | | | | (_| | | \ V / (_| | | \__ \
## |_____/_/\_\\__\___|_| |_| |_|\__,_|_| \_/ \__,_|_| |___/
##
################################################################################################################################
# Vertices
process.scNvertices = cms.EDProducer("VertexMultiplicityCounter",
probes = cms.InputTag("goodSuperClusters"),
objects = cms.InputTag("offlinePrimaryVertices"),
objectSelection = cms.string("!isFake && ndof > 4 && abs(z) <= 24 && position.Rho <= 2"),
)
process.gsfNvertices = process.scNvertices.clone(probes = ELE_COLL)
process.patNvertices = process.scNvertices.clone(probes = "cleanPatElectronsTriggerMatch")
process.allEleVertices = cms.Sequence(
process.scNvertices +
process.gsfNvertices +
process.patNvertices
)
################################################################################################################################
# PU Reweighting
process.scPileup = cms.EDProducer("PileupWeightComputer",
probes = cms.InputTag("goodSuperClusters"),
isMC = cms.bool(mcInfo),
dataPileupFile = cms.string("PileupHistogram_2012Data_FlatPU_50bins.root"),
mcPileupFile = cms.string("PileupHistogram_2012Data_FlatPU_50bins.root"),
dataPileupHistoName = cms.string("pileup"),
mcPileupHistoName = cms.string("mcpileup"),
mcLumiScale = cms.double(221.95),
dataPileupInputFile = cms.string("run_ls_instlumi_pileup_2012.txt"),
)
process.gsfPileup = process.scPileup.clone(probes = cms.InputTag(ELE_COLL))
process.patPileup = process.scPileup.clone(probes = cms.InputTag("cleanPatElectronsTriggerMatch"))
process.allElePileup = cms.Sequence(
process.scPileup +
process.gsfPileup +
process.patPileup
)
################################################################################################################################
# _ _ _ ___ ____ ____ ___ ___ ____ ____ ____ _ _ ____ ___ ____ ____
# | |\/| |__] |__| | | |__] |__| |__/ |__| |\/| |___ | |___ |__/
# | | | | | | |___ | | | | | \ | | | | |___ | |___ | \
process.gsfImpactParameter = cms.EDProducer("GsfElectronImpactParameter",
probes = cms.InputTag(ELE_COLL),
)
process.patImpactParameter = cms.EDProducer("PatElectronImpactParameter",
probes = cms.InputTag("cleanPatElectronsTriggerMatch"),
)
process.allEleImpactParameters = cms.Sequence(
process.gsfImpactParameter +
process.patImpactParameter
)
################################################################################################################################
# _ ____ ___ ____
# | |___ | [__
# _| |___ | ___]
process.selectedJets = cms.EDFilter("PATJetSelector",
src = cms.InputTag( JET_COLL ),
cut = cms.string( JET_CUTS ), # <= anpassen
)
# DeltaR
process.scDRToNearestJet = cms.EDProducer("minCutDeltaRNearestPatJetComputer",
probes = cms.InputTag("goodSuperClusters"),
objects = cms.InputTag("selectedJets"),
minDeltaR = cms.double(0.3),
objectSelection = cms.InputTag(""),
)
process.gsfDRToNearestJet = process.scDRToNearestJet.clone(probes = cms.InputTag(ELE_COLL))
process.patDRToNearestJet = process.scDRToNearestJet.clone(probes = cms.InputTag("cleanPatElectronsTriggerMatch"))
# Njet
process.scJetMultiplicity = cms.EDProducer("PatJetMultiplicityCounter",
probes = cms.InputTag("goodSuperClusters"),
objects = cms.InputTag("selectedJets"),
minDeltaR = cms.double(0.3),
objectSelection = cms.InputTag(""),
)
process.gsfJetMultiplicity = process.scJetMultiplicity.clone(probes = cms.InputTag(ELE_COLL))
process.patJetMultiplicity = process.scJetMultiplicity.clone(probes = cms.InputTag("cleanPatElectronsTriggerMatch"))
# HT
process.scHT = cms.EDProducer("PatJetHTComputer",
probes = cms.InputTag("goodSuperClusters"),
objects = cms.InputTag("selectedJets"),
objectSelection = cms.InputTag(""),
)
process.gsfHT = process.scHT.clone(probes = cms.InputTag(ELE_COLL))
process.patHT = process.scHT.clone(probes = cms.InputTag("cleanPatElectronsTriggerMatch"))
# MET
process.scMet = cms.EDProducer("PatMetAssociator",
probes = cms.InputTag("goodSuperClusters"),
metTag = cms.InputTag("patMETsPF"),
)
process.gsfMet = process.scMet.clone(probes = cms.InputTag(ELE_COLL))
process.patMet = process.scMet.clone(probes = cms.InputTag("cleanPatElectronsTriggerMatch"))
# ST
process.gsfST = cms.EDProducer("PatMetSTComputer",
probes = cms.InputTag(ELE_COLL),
metTag = cms.InputTag("patMETsPF"),
)
process.patST = process.gsfST.clone(probes = cms.InputTag("cleanPatElectronsTriggerMatch"))
process.allEleJets = cms.Sequence(
process.selectedJets*
(process.scDRToNearestJet +
process.gsfDRToNearestJet +
process.patDRToNearestJet +
process.scJetMultiplicity +
process.gsfJetMultiplicity +
process.patJetMultiplicity +
process.scHT +
process.gsfHT +
process.patHT)
)
process.allEleMet = cms.Sequence(
process.scMet +
process.gsfMet +
process.patMet
)
process.allEleST = cms.Sequence(
process.gsfST +
process.patST
)
################################################################################################################################
# _ ____ ____ _ ____ ___ _ ____ _ _ ____
# | [__ | | | |__| | | | | |\ | [__
# | ___] |__| |___ | | | | |__| | \| ___]
#compute rho for 2011 effective area Egamma isolation corrections
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets
process.kt6PFJetsForIsolation = kt4PFJets.clone( rParam = 0.6, doRhoFastjet = True )
process.kt6PFJetsForIsolation.Rho_EtaMax = cms.double(2.5)
# Rho Corrected Relative Isolation
process.gsfRelIso = cms.EDProducer("GsfElectronRelIsoProducer",
isMC = cms.bool(mcInfo),
ElectronProbes = cms.InputTag(ELE_COLL),
rhoIsoInputTag = cms.InputTag("kt6PFJetsForIsolation", "rho"),
isoValInputTags = cms.VInputTag(
cms.InputTag('elPFIsoValueCharged03PFIdPFIso'),
cms.InputTag('elPFIsoValueGamma03PFIdPFIso'),
cms.InputTag('elPFIsoValueNeutral03PFIdPFIso')
),
)
process.patRelIso = cms.EDProducer("PatElectronRelIsoProducer",
isMC = cms.bool(mcInfo),
ElectronProbes = cms.InputTag("cleanPatElectronsTriggerMatch"),
rhoIsoInputTag = cms.InputTag("kt6PFJetsForIsolation", "rho"),
isoValInputTags = cms.VInputTag(
cms.InputTag('elPFIsoValueCharged03PFIdPFIso'),
cms.InputTag('elPFIsoValueGamma03PFIdPFIso'),
cms.InputTag('elPFIsoValueNeutral03PFIdPFIso')
),
)
if is7X:
process.gsfRelIso.isoValInputTags = cms.VInputTag(
cms.InputTag('elPFIsoValueCharged03PFId'),
cms.InputTag('elPFIsoValueGamma03PFId'),
cms.InputTag('elPFIsoValueNeutral03PFId')
)
process.patRelIso.isoValInputTags = cms.VInputTag(
cms.InputTag('elPFIsoValueCharged03PFId'),
cms.InputTag('elPFIsoValueGamma03PFId'),
cms.InputTag('elPFIsoValueNeutral03PFId')
)
process.allEleRelIso = cms.Sequence(
process.kt6PFJetsForIsolation *
( process.gsfRelIso +
process.patRelIso )
)
################################################################################################################################
# Delta Reco-PF Electron Pt
process.gsfDeltaPfRecoPt = cms.EDProducer("GsfElectronDeltaPfRecoPt",
probes = cms.InputTag(ELE_COLL),
)
process.patDeltaPfRecoPt = cms.EDProducer("ElectronDeltaPfRecoPt",
probes = cms.InputTag("cleanPatElectronsTriggerMatch"),
)
process.allEleDeltaPfRecoPt = cms.Sequence(
process.gsfDeltaPfRecoPt +
process.patDeltaPfRecoPt
)
################################################################################################################################
# Conversion Rejection
#process.gsfConvRejVars = cms.EDProducer("ElectronConversionRejectionVars",
# probes = cms.InputTag(ELE_COLL)
#)
################################################################################################################################
# ___ ____ ____ ____ _ _ ____ ___ ____ ____ ____
# |__] |__| |__/ |__| |\/| |___ | |___ |__/ [__
# | | | | \ | | | | |___ | |___ | \ ___]
if mcInfo:
mcTruthCommonStuff = cms.PSet(
isMC = cms.bool(True),
addRunLumiInfo = cms.bool(False),
makeMCUnbiasTree = cms.bool(False),
checkMotherInUnbiasEff = cms.bool(True),
motherPdgId = cms.vint32(22,23), # Gamma or Z
tagMatches = cms.InputTag("McMatchTagPATElectron"),
#mcVariables = cms.PSet(
# mass = cms.string("mass"),
# mt = cms.string("mt"),
# pt = cms.string("pt"),
# et = cms.string("et"),
# phi = cms.string("phi"),
# eta = cms.string("eta"),
# e = cms.string("energy"),
# p = cms.string("p"),
# px = cms.string("px"),
# py = cms.string("py"),
# pz = cms.string("pz"),
# theta = cms.string("theta"),
# vx = cms.string("vx"),
# vy = cms.string("vy"),
# vz = cms.string("vz"),
# charge = cms.string("charge"),
# rapidity = cms.string("rapidity"),
#),
#mcFlags = cms.PSet(
# flag = cms.string("pt>0")
#),
)
else:
mcTruthCommonStuff = cms.PSet(
isMC = cms.bool(False),
addRunLumiInfo = cms.bool(True),
)
commonStuff = cms.PSet(
mcTruthCommonStuff,
addEventVariablesInfo = cms.bool(False),
ignoreExceptions = cms.bool(False),
arbitration = cms.string("Random2"),
#pairFlags = cms.PSet(
# mass60to120 = cms.string("60 < mass < 120")
#),
#pairVariables = cms.PSet(
# #mass = cms.string("mass"), # created automatically
# mt = cms.string("mt"),
# pt = cms.string("pt"),
# et = cms.string("et"),
# phi = cms.string("phi"),
# eta = cms.string("eta"),
# abs_eta = cms.string("abs(eta)"),
# #e = cms.string("energy"),
# #p = cms.string("p"),
# #px = cms.string("px"),
# #py = cms.string("py"),
# #pz = cms.string("pz"),
# #theta = cms.string("theta"),
# #vx = cms.string("vx"),
# #vy = cms.string("vy"),
# #vz = cms.string("vz"),
# #rapidity = cms.string("rapidity"),
#),
)
scParameters = cms.PSet(
variables = cms.PSet(
pt = cms.string("pt"),
et = cms.string("et"),
phi = cms.string("phi"),
eta = cms.string("eta"),
abs_eta = cms.string("abs(eta)"),
nvtx = cms.InputTag("scNvertices"),
pileup = cms.InputTag("scPileup","pileup"),
instlumi = cms.InputTag("scPileup","instlumi"),
weight = cms.InputTag("scPileup","weight"),
drjet = cms.InputTag("scDRToNearestJet"),
njet = cms.InputTag("scJetMultiplicity"),
ht = cms.InputTag("scHT"),
met = cms.InputTag("scMet"),
#e = cms.string("energy"),
#p = cms.string("p"),
#px = cms.string("px"),
#py = cms.string("py"),
#pz = cms.string("pz"),
#theta = cms.string("theta"),
),
tagVariables = cms.PSet(),
flags = cms.PSet( # The flags below somehow don't work in 7X
passing_gsf = cms.InputTag("GsfMatchedSuperClusterCands"),
passing_pat = cms.InputTag("GSFtoPATMatchedSuperClusterCandsClean"),
),
tagFlags = cms.PSet(),
)
gsfParameters = cms.PSet(
variables = cms.PSet(
pt = cms.string("pt"),
et = cms.string("et"),
phi = cms.string("phi"),
eta = cms.string("eta"),
abs_eta = cms.string("abs(eta)"),
sc_et = cms.string("superCluster.energy*sin(superClusterPosition.theta)"),
sc_phi = cms.string("superCluster.phi"),
sc_eta = cms.string("superCluster.eta"),
track_pt = cms.string("gsfTrack.pt"),
track_phi = cms.string("gsfTrack.phi"),
track_eta = cms.string("gsfTrack.eta"),
nvtx = cms.InputTag("gsfNvertices"),
pileup = cms.InputTag("gsfPileup","pileup"),
instlumi = cms.InputTag("gsfPileup","instlumi"),
weight = cms.InputTag("gsfPileup","weight"),
d0_v = cms.InputTag("gsfImpactParameter","d0v"),
d0_b = cms.InputTag("gsfImpactParameter","d0b"),
dz_v = cms.InputTag("gsfImpactParameter","dzv"),
dz_b = cms.InputTag("gsfImpactParameter","dzb"),
drjet = cms.InputTag("gsfDRToNearestJet"),
njet = cms.InputTag("gsfJetMultiplicity"),
ht = cms.InputTag("gsfHT"),
met = cms.InputTag("gsfMet"),
st = cms.InputTag("gsfST"),
absdeltapt = cms.InputTag("gsfDeltaPfRecoPt","absdeltapt"), # -9999: under 10 GeV
reliso = cms.InputTag("gsfRelIso","reliso"),
#passConvRej = cms.InputTag("gsfConvRejVars","passConvRej"),
#conv_dist = cms.InputTag("gsfConvRejVars","dist"),
#conv_dcot = cms.InputTag("gsfConvRejVars","dcot"),
#conv_radius = cms.InputTag("gsfConvRejVars","convradius"),
#theta = cms.string("theta"),
#rapidity = cms.string("rapidity"),
#e = cms.string("energy"),
#p = cms.string("p"),
#px = cms.string("px"),
#py = cms.string("py"),
#pz = cms.string("pz"),
#charge = cms.string("charge"),
#missingHits = cms.string("gsfTrack.trackerExpectedHitsInner.numberOfHits"),
#convDist = cms.string("convDist"),
#convDcot = cms.string("convDcot"),
#convRadius = cms.string("convRadius"),
#hasL1BPixHit = cms.string("gsfTrack.hitPattern.hasValidHitInFirstPixelBarrel"),
## super cluster quantities
#sc_e = cms.string("superCluster.energy"),
#sc_x = cms.string("superCluster.x"),
#sc_y = cms.string("superCluster.y"),
#sc_z = cms.string("superCluster.z"),
#sc_theta = cms.string("superClusterPosition.theta"),
#sc_nhit = cms.string("superCluster.size"),
## track quantities
#track_p = cms.string("gsfTrack.p"),
#track_px = cms.string("gsfTrack.px"),
#track_py = cms.string("gsfTrack.py"),
#track_pz = cms.string("gsfTrack.pz"),
#track_theta = cms.string("gsfTrack.theta"),
#track_vx = cms.string("gsfTrack.vx"),
#track_vy = cms.string("gsfTrack.vy"),
#track_vz = cms.string("gsfTrack.vz"),
#track_dxy = cms.string("gsfTrack.dxy"),
#track_d0 = cms.string("gsfTrack.d0"),
#track_dsz = cms.string("gsfTrack.dsz"),
#track_charge = cms.string("gsfTrack.charge"),
#track_qoverp = cms.string("gsfTrack.qoverp"),
#track_normChi2 = cms.string("gsfTrack.normalizedChi2"),
## isolation
#trackiso = cms.string("dr03TkSumPt"),
#ecaliso = cms.string("dr03EcalRecHitSumEt"),
#hcaliso = cms.string("dr03HcalTowerSumEt"),
## classification, location, etc.
#classification = cms.string("classification"),
#numberOfBrems = cms.string("numberOfBrems"),
#bremFraction = cms.string("fbrem"),
#mva = cms.string("mva"),
#deltaEta = cms.string("deltaEtaSuperClusterTrackAtVtx"),
#deltaPhi = cms.string("deltaPhiSuperClusterTrackAtVtx"),
#deltaPhiOut = cms.string("deltaPhiSeedClusterTrackAtCalo"),
#deltaEtaOut = cms.string("deltaEtaSeedClusterTrackAtCalo"),
#isEB = cms.string("isEB"),
#isEE = cms.string("isEE"),
#isGap = cms.string("isGap"),
## Hcal energy over Ecal Energy
#HoverE = cms.string("hcalOverEcal"),
#EoverP = cms.string("eSuperClusterOverP"),
#eSeedClusterOverP = cms.string("eSeedClusterOverP"),
## Cluster shape information
#sigmaEtaEta = cms.string("sigmaEtaEta"),
#sigmaIetaIeta = cms.string("sigmaIetaIeta"),
#e1x5 = cms.string("e1x5"),
#e2x5Max = cms.string("e2x5Max"),
#e5x5 = cms.string("e5x5"),
## is ECAL driven ? is Track driven ?
#ecalDrivenSeed = cms.string("ecalDrivenSeed"),
#trackerDrivenSeed = cms.string("trackerDrivenSeed"),
),
tagVariables = cms.PSet(),
flags = cms.PSet(
passing_pat = cms.InputTag("GSFPassingGoodPat"),
),
tagFlags = cms.PSet(),
)
patParameters = cms.PSet(
variables = cms.PSet(
pt = cms.string("pt"),
et = cms.string("et"),
phi = cms.string("phi"),
eta = cms.string("eta"),
abs_eta = cms.string("abs(eta)"),
sc_et = cms.string("superCluster.energy*sin(superClusterPosition.theta)"),
sc_phi = cms.string("superCluster.phi"),
sc_eta = cms.string("superCluster.eta"),
track_pt = cms.string("gsfTrack.pt"),
track_phi = cms.string("gsfTrack.phi"),
track_eta = cms.string("gsfTrack.eta"),
nvtx = cms.InputTag("patNvertices"),
pileup = cms.InputTag("patPileup","pileup"),
instlumi = cms.InputTag("patPileup","instlumi"),
weight = cms.InputTag("patPileup","weight"),
d0_v = cms.InputTag("patImpactParameter","d0v"),
d0_b = cms.InputTag("patImpactParameter","d0b"),
dz_v = cms.InputTag("patImpactParameter","dzv"),
dz_b = cms.InputTag("patImpactParameter","dzb"),
drjet = cms.InputTag("patDRToNearestJet"),
njet = cms.InputTag("patJetMultiplicity"),
ht = cms.InputTag("patHT"),
met = cms.InputTag("patMet"),
st = cms.InputTag("patST"),
absdeltapt = cms.InputTag("patDeltaPfRecoPt","absdeltapt"), # -9999: under 10 GeV
reliso = cms.InputTag("patRelIso","reliso"),
#charge = cms.string("charge"),
#isEB = cms.string("isEB"),
#isEE = cms.string("isEE"),
#isGap = cms.string("isGap"),
#trackiso = cms.string("dr03TkSumPt"),
#ecaliso = cms.string("dr03EcalRecHitSumEt"),
#hcaliso = cms.string("dr03HcalTowerSumEt"),
event_passing_HLT_CleanPFHT350_Ele5_PFMET45 = cms.InputTag("patEventPassingHLTCleanPFHT350Ele5PFMET45"),
event_passing_HLT_CleanPFHT350_Ele5_PFMET50 = cms.InputTag("patEventPassingHLTCleanPFHT350Ele5PFMET50"),
event_passing_HLT_CleanPFHT300_Ele15_PFMET45 = cms.InputTag("patEventPassingHLTCleanPFHT300Ele15PFMET45"),
event_passing_HLT_CleanPFHT300_Ele15_PFMET50 = cms.InputTag("patEventPassingHLTCleanPFHT300Ele15PFMET50"),
event_passing_HLT_CleanPFHT300_Ele40 = cms.InputTag("patEventPassingHLTCleanPFHT300Ele40"),
event_passing_HLT_CleanPFHT300_Ele60 = cms.InputTag("patEventPassingHLTCleanPFHT300Ele60"),
event_passing_HLT_CleanPFNoPUHT350_Ele5_PFMET45 = cms.InputTag("patEventPassingHLTCleanPFNoPUHT350Ele5PFMET45"),
event_passing_HLT_CleanPFNoPUHT350_Ele5_PFMET50 = cms.InputTag("patEventPassingHLTCleanPFNoPUHT350Ele5PFMET50"),
event_passing_HLT_CleanPFNoPUHT300_Ele15_PFMET45 = cms.InputTag("patEventPassingHLTCleanPFNoPUHT300Ele15PFMET45"),
event_passing_HLT_CleanPFNoPUHT300_Ele15_PFMET50 = cms.InputTag("patEventPassingHLTCleanPFNoPUHT300Ele15PFMET50"),
event_passing_HLT_CleanPFNoPUHT300_Ele40 = cms.InputTag("patEventPassingHLTCleanPFNoPUHT300Ele40"),
event_passing_HLT_CleanPFNoPUHT300_Ele60 = cms.InputTag("patEventPassingHLTCleanPFNoPUHT300Ele60"),
),
tagVariables = cms.PSet(),
flags = cms.PSet( AllTriggerFlags ),
tagFlags = cms.PSet( AllTriggerFlags ),
)
################################################################################################################################
# ____ _ ___ ___ ____ ____ ____ ___ ____ ____ ___ _ _ ____ ____ ____
# |___ | | | |__/ |___ |___ |__] |__/ | | | \ | | | |___ |__/
# | | | | | \ |___ |___ | | \ |__| |__/ |__| |___ |___ | \
## ____ ____ __ ____ __
## / ___| / ___| \ \ / ___|___ / _|
## \___ \| | _____\ \ | | _/ __| |_
## ___) | |___ |_____/ / | |_| \__ \ _|
## |____/ \____| /_/ \____|___/_|
##
process.SuperClusterToGsfElectronPATTag = cms.EDAnalyzer("TagProbeFitTreeProducer",
commonStuff, scParameters,
tagProbePairs = cms.InputTag("tagPATSC"),
allProbes = cms.InputTag("goodSuperClustersClean"),
probeMatches = cms.InputTag("McMatchSC"),
)
## ____ __ __ ___ ___ _
## / ___|___ / _| \ \ |_ _|___ ___ |_ _|__| |
## | | _/ __| |_ _____\ \ | |/ __|/ _ \ | |/ _` |
## | |_| \__ \ _| |_____/ / | |\__ \ (_) | _ | | (_| |
## \____|___/_| /_/ |___|___/\___/ ( ) |___\__,_|
## |/
process.GsfElectronToIdPATTag = cms.EDAnalyzer("TagProbeFitTreeProducer",
commonStuff, gsfParameters,
tagProbePairs = cms.InputTag("tagPATGsf"),
allProbes = cms.InputTag("goodElectrons"),
probeMatches = cms.InputTag("McMatchGsf"),
)
## ___ _ __ _ _ _ _____
## |_ _|__| | \ \ | | | | | |_ _|
## | |/ _` | _____\ \ | |_| | | | |
## | | (_| | |_____/ / | _ | |___| |
## |___\__,_| /_/ |_| |_|_____|_|
##
process.goodPATEleToHLT = cms.EDAnalyzer("TagProbeFitTreeProducer",
commonStuff, patParameters,
tagProbePairs = cms.InputTag("tagPATGoodPATElectron"),
allProbes = cms.InputTag("goodPATElectrons"),
probeMatches = cms.InputTag("McMatchPATElectron"),
)
process.allEleTPTrees = cms.Sequence(
process.SuperClusterToGsfElectronPATTag +
process.GsfElectronToIdPATTag +
process.goodPATEleToHLT
)
##############################################################################################################
## ____ _ _
## | _ \ __ _| |_| |__
## | |_) / _` | __| '_ \
## | __/ (_| | |_| | | |
## |_| \__,_|\__|_| |_|
##
if mcInfo:
process.TagAndProbe_Electrons = cms.Sequence(
process.allEleTagsAndProbes *
( process.allEleTPPairs +
process.allElePassingProbes +
process.allEleHLTResults +
process.allEleMcMatches +
process.allEleVertices +
process.allElePileup +
process.allEleImpactParameters +
process.allEleJets +
process.allEleMet +
process.allEleST +
process.allEleDeltaPfRecoPt +
process.allEleRelIso
#process.gsfConvRejVars
)*process.allEleTPTrees
)
else:
process.TagAndProbe_Electrons = cms.Sequence(
process.allEleTagsAndProbes *
( process.allEleTPPairs +
process.allElePassingProbes +
process.allEleHLTResults +
process.allEleVertices +
process.allElePileup +
process.allEleImpactParameters +
process.allEleJets +
process.allEleMet +
process.allEleST +
process.allEleDeltaPfRecoPt +
process.allEleRelIso
#process.gsfConvRejVars
)*process.allEleTPTrees
)
postfix = "PFlow"
usePF2PAT(process,runPF2PAT=True,jetAlgo='AK5',runOnMC=True,postfix = postfix,jetCorrections=('AK5PFchs',['L1FastJet','L2Relative','L3Absol\
ute','L2L3Residual']))
process.pfPileUpPFlow.Enable = True
process.pfPileUpPFlow.Vertices = 'goodOfflinePrimaryVertices'
process.pfJetsPFlow.doAreaFastjet = True
process.pfJetsPFlow.doRhoFastjet = False
process.pfPileUpPFlow.checkClosestZVertex = cms.bool(False)
process.patJetCorrFactorsPFlow.rho = cms.InputTag("kt6PFJetsPFlow","rho")
# Compute the mean pt per unit area (rho) from the PF chs inputs
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets
process.kt6PFJetsPFlow = kt4PFJets.clone(
rParam = cms.double(0.6),
src = cms.InputTag('pfNoElectron'+postfix),
doAreaFastjet = cms.bool(True),
doRhoFastjet = cms.bool(True),
)
process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(100) )
process.source = cms.Source("PoolSource",
# replace 'myfile.root' with the source file you want to use
fileNames = cms.untracked.vstring(
'/store/data/Run2011A/Photon/AOD/May10ReReco-v1/0000/00372EF6-C37B-E011-983B-001A64789E0C.root'
)
)
#process.load("DelPanj.TreeMaker.patTuples_ZmmMadgraph_cfi")
baseJetSel = cms.PSet(
Jets=cms.InputTag("selectedPatJetsPFlow")
#Jets=cms.InputTag("selectedPatJetsAK5PF")
def getBaseConfig(
globaltag,
testfile,
maxevents,
nickname,
outputfilename,
channel='mm',
is_data=None,
):
# Config parameters ##############################################
cmssw_version = os.environ["CMSSW_VERSION"].split('_')
cmssw_version = tuple([int(i) for i in cmssw_version[1:4]] + cmssw_version[4:])
autostr = ""
if globaltag.lower() == 'auto':
from Configuration.AlCa.autoCond import autoCond
globaltag = autoCond['startup']
autostr = " (from autoCond)"
if is_data is None:
data = any([name in testfile[0] for name in 'SingleMu', 'DoubleMu', 'DoubleElectron', 'MuEG'])
else:
data = is_data
miniaod = False
## print information
print "\n------- CONFIGURATION 1 ---------"
print "input: ", testfile[0], "... (%d files)" % len(testfile) if len(testfile) > 1 else ""
print "file type: ", "miniAOD" if miniaod else "AOD"
print "data: ", data
print "output: ", outputfilename
print "nickname: ", nickname
print "global tag: ", globaltag + autostr
print "max events: ", maxevents
print "cmssw version: ", '.'.join([str(i) for i in cmssw_version])
print "channel: ", channel
print "---------------------------------"
print
############################################################################
# Basic Process Setup
############################################################################
process = cms.Process("KAPPA")
## MessageLogger
process.load("FWCore.MessageLogger.MessageLogger_cfi")
process.MessageLogger.default = cms.untracked.PSet(
ERROR = cms.untracked.PSet(limit = cms.untracked.int32(5))
#suppressError = cms.untracked.vstring("electronIdMVAProducer")
)
process.MessageLogger.cerr.FwkReport.reportEvery = 50
## Options and Output Report
process.options = cms.untracked.PSet( wantSummary = cms.untracked.bool(True) )
## Source
process.source = cms.Source("PoolSource",
fileNames = cms.untracked.vstring()
)
## Maximal number of Events
process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(100) )
## Geometry and Detector Conditions (needed for a few patTuple production steps)
import Kappa.Skimming.tools as tools
cmssw_version_number = tools.get_cmssw_version_number()
process.load("Configuration.Geometry.GeometryIdeal_cff")
process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff")
from Configuration.AlCa.autoCond import autoCond
process.GlobalTag.globaltag = cms.string(autoCond['startup'])
# print the global tag until it is clear whether this auto global tag is fine
print "GT from autoCond:", process.GlobalTag.globaltag
process.load("Configuration.StandardSequences.MagneticField_cff")
############################################################################
# KAPPA
############################################################################
process.load('Kappa.Producers.KTuple_cff')
process.kappaTuple = cms.EDAnalyzer('KTuple',
process.kappaTupleDefaultsBlock,
outputFile = cms.string("kappaTuple.root"),
)
process.kappaTuple.active = cms.vstring()
process.kappaTuple.outputFile = outputfilename ## name of output file
process.kappaTuple.verbose = 0 ## verbosity level
process.kappaTuple.profile = cms.bool(False)
process.kappaOut = cms.Sequence(process.kappaTuple)
process.path = cms.Path()
process.source.fileNames = testfile
process.maxEvents.input = maxevents ## number of events to be processed (-1 = all in file)
if not globaltag.lower() == 'auto' :
process.GlobalTag.globaltag = globaltag
data = datasetsHelper.isData(nickname)
process.options = cms.untracked.PSet( wantSummary = cms.untracked.bool(False) )
############################################################################
# Basic Objects
############################################################################
process.kappaTuple.active += cms.vstring('VertexSummary') ## save VertexSummary,
process.kappaTuple.VertexSummary.whitelist = cms.vstring('goodOfflinePrimaryVertices')
#process.kappaTuple.active += cms.vstring('BeamSpot') ## save Beamspot,
#process.kappaTuple.active += cms.vstring('TriggerObjects')
if data:
process.kappaTuple.active+= cms.vstring('DataInfo') ## produce Metadata for data,
else:
process.kappaTuple.active+= cms.vstring('GenInfo') ## produce Metadata for MC,
process.kappaTuple.active+= cms.vstring('GenParticles')
#Trigger
trigger_dict = {
'mtrigger': ['^HLT_(Double)?Mu([0-9]+)_(Double)?Mu([0-9]+)(_v[[:digit:]]+)?$'],
'etrigger': ['HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL.*'],
'emtrigger': ["HLT_Mu17_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL.*", "HLT_Mu8_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL.*",]
}
channel_dict = {
'ee': ['etrigger'],
'mm': ['mtrigger'],
'eemm': ['etrigger', 'mtrigger'],
'em': ['emtrigger']
}
process.kappaTuple.Info.hltWhitelist = cms.vstring("")
for triggers in channel_dict[channel]:
for trigger in trigger_dict[triggers]:
process.kappaTuple.Info.hltWhitelist += cms.vstring(trigger)
############################################################################
# PFCandidates
############################################################################
process.load('Kappa.Skimming.KPFCandidates_cff')
process.path *= (
process.goodOfflinePrimaryVertices
* process.pfPileUp
* process.pfNoPileUp
#* process.makePFBRECO
#* process.makeKappaPFCandidates
)
if 'm' in channel:
############################################################################
# Muons
############################################################################
process.kappaTuple.active += cms.vstring('Muons') ## produce/save KappaMuons
process.kappaTuple.Muons.minPt = cms.double(8.0)
## Isodeposits for muons
process.load('TrackPropagation.SteppingHelixPropagator.SteppingHelixPropagatorAny_cfi')
process.load('TrackPropagation.SteppingHelixPropagator.SteppingHelixPropagatorAlong_cfi')
process.load('TrackPropagation.SteppingHelixPropagator.SteppingHelixPropagatorOpposite_cfi')
process.pfmuIsoDepositPFCandidates = cms.EDProducer(
"CandIsoDepositProducer",
src = cms.InputTag("muons"),
MultipleDepositsFlag = cms.bool(False),
trackType = cms.string('candidate'),
ExtractorPSet = cms.PSet(
Diff_z = cms.double(99999.99),
ComponentName = cms.string('CandViewExtractor'),
DR_Max = cms.double(1.0),
Diff_r = cms.double(99999.99),
inputCandView = cms.InputTag("particleFlow"),
DR_Veto = cms.double(1e-05),
DepositLabel = cms.untracked.string('')
)
)
process.path *= (process.pfmuIsoDepositPFCandidates)
process.goodMuons = cms.EDFilter('CandViewSelector',
src = cms.InputTag('muons'),
cut = cms.string("pt > 15.0"),
)
process.oneGoodMuon = cms.EDFilter('CandViewCountFilter',
src = cms.InputTag('goodMuons'),
minNumber = cms.uint32(1),
)
process.twoGoodMuons = cms.EDFilter('CandViewCountFilter',
src = cms.InputTag('goodMuons'),
minNumber = cms.uint32(2),
)
if 'mm' in channel:
process.path *= (process.goodMuons * process.twoGoodMuons)
if 'e' in channel:
############################################################################
# Electrons
############################################################################
#TODO Add Electron
process.load('EgammaAnalysis.ElectronTools.electronIdMVAProducer_cfi')
process.load('TrackingTools.TransientTrack.TransientTrackBuilder_cfi')
process.load('PhysicsTools.PatAlgos.producersLayer1.electronProducer_cfi')
process.patElectrons.electronIDSources = cms.PSet(
## default cut based Id
eidRobustLoose = cms.InputTag("eidRobustLoose" ),
eidRobustTight = cms.InputTag("eidRobustTight" ),
eidLoose = cms.InputTag("eidLoose" ),
eidTight = cms.InputTag("eidTight" ),
eidRobustHighEnergy = cms.InputTag("eidRobustHighEnergy"),
## MVA based Id
idMvaTrigV0 = cms.InputTag("mvaTrigV0" ),
idMvaTrigNoIPV0 = cms.InputTag("mvaTrigNoIPV0" ),
idMvaNonTrigV0 = cms.InputTag("mvaNonTrigV0" ),
)
process.patElectrons.genParticleMatch = ""
process.patElectrons.addGenMatch = False
process.patElectrons.embedGenMatch = False
process.patElectrons.embedGsfElectronCore = True
process.patElectrons.embedGsfTrack = True
process.patElectrons.embedSuperCluster = True
process.patElectrons.embedPflowSuperCluster = True
process.patElectrons.embedSeedCluster = True
process.patElectrons.embedBasicClusters = True
process.patElectrons.embedPreshowerClusters = True
process.patElectrons.embedPflowBasicClusters = True
process.patElectrons.embedPflowPreshowerClusters = True
process.patElectrons.embedPFCandidate = True
process.patElectrons.embedTrack = True
process.patElectrons.embedRecHits = True
process.patElectrons.embedHighLevelSelection.pvSrc = "goodOfflinePrimaryVertices"
process.electronIdMVA = cms.Sequence(
process.mvaTrigV0+
process.mvaTrigNoIPV0+
process.mvaNonTrigV0
)
process.makeKappaElectrons = cms.Sequence(
process.electronIdMVA *
process.patElectrons
)
process.path *= (process.makeKappaElectrons)
## CALIBRATIONS
# momentum corrections
process.load('EgammaAnalysis.ElectronTools.electronRegressionEnergyProducer_cfi')
process.eleRegressionEnergy.inputElectronsTag = cms.InputTag('patElectrons')
process.eleRegressionEnergy.inputCollectionType = cms.uint32(1)
process.load("Configuration.StandardSequences.Services_cff")
process.RandomNumberGeneratorService = cms.Service("RandomNumberGeneratorService",
calibratedPatElectrons = cms.PSet(
initialSeed = cms.untracked.uint32(1),
engineName = cms.untracked.string('TRandom3')
),
)
# calibrate pat electrons
process.load("EgammaAnalysis.ElectronTools.calibratedPatElectrons_cfi")
if data:
inputDataset = "22Jan2013ReReco"
else:
#inputDataset = "Summer12_DR53X_HCP2012"
inputDataset = "Summer12_LegacyPaper"
print "Using electron calibration", inputDataset
process.calibratedPatElectrons.inputDataset = cms.string(inputDataset)
process.calibratedPatElectrons.isMC = cms.bool(not data)
## for cutbased ID
from CommonTools.ParticleFlow.Tools.pfIsolation import setupPFElectronIso, setupPFMuonIso
process.calibeleIsoSequence = setupPFElectronIso(process, 'calibratedPatElectrons', "PFIsoCal")
process.eleIsoSequence = setupPFElectronIso(process, 'patElectrons')
process.pfiso = cms.Sequence(process.pfParticleSelectionSequence
+ process.eleIsoSequence + process.calibeleIsoSequence
)
# rho for e isolation
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets
process.kt6PFJetsForIsolation = kt4PFJets.clone( rParam = 0.6, doRhoFastjet = True )
process.kt6PFJetsForIsolation.Rho_EtaMax = cms.double(2.5)
process.path *= (
process.eleRegressionEnergy *
process.calibratedPatElectrons *
process.pfiso *
process.kt6PFJetsForIsolation
)
#add to Kappa
process.kappaTuple.active += cms.vstring('Electrons')
process.kappaTuple.Electrons = cms.PSet(
process.kappaNoCut, process.kappaNoRegEx,
ids = cms.vstring(),
srcIds = cms.string("pat"),
electrons = cms.PSet(
src = cms.InputTag("patElectrons"),
allConversions = cms.InputTag("allConversions"),
offlineBeamSpot = cms.InputTag("offlineBeamSpot"),
vertexcollection = cms.InputTag("goodOfflinePrimaryVertices"),
isoValInputTags = cms.VInputTag(
cms.InputTag('elPFIsoValueChargedAll04PFIdPFIso'),
cms.InputTag('elPFIsoValueGamma04PFIdPFIso'),
cms.InputTag('elPFIsoValueNeutral04PFIdPFIso'),
cms.InputTag('elPFIsoValuePU04PFIdPFIso')),
rhoIsoInputTag = cms.InputTag("kt6PFJetsForIsolation", "rho"),
),
)
process.kappaTuple.Electrons.correlectrons = process.kappaTuple.Electrons.electrons.clone(
src = cms.InputTag("calibratedPatElectrons"),
isoValInputTags = cms.VInputTag(
cms.InputTag('elPFIsoValueChargedAll04PFIdPFIsoCal'),
cms.InputTag('elPFIsoValueGamma04PFIdPFIsoCal'),
cms.InputTag('elPFIsoValueNeutral04PFIdPFIsoCal'),
cms.InputTag('elPFIsoValuePU04PFIdPFIsoCal')),
)
#process.kappaTuple.Electrons.ids = cms.VInputTag("mvaTrigV0", "mvaTrigNoIPV0", "mvaNonTrigV0")
process.kappaTuple.Electrons.ids = cms.VInputTag('idMvaNonTrigV0', 'idMvaTrigNoIPV0', 'idMvaTrigV0')
process.kappaTuple.Electrons.minPt = cms.double(8.0)
### Filter
process.goodElectrons = cms.EDFilter('CandViewSelector',
src = cms.InputTag('calibratedPatElectrons'),
cut = cms.string("pt > 15.0"),
)
process.oneGoodElectron = cms.EDFilter('CandViewCountFilter',
src = cms.InputTag('goodElectrons'),
minNumber = cms.uint32(1),
)
process.twoGoodElectrons = cms.EDFilter('CandViewCountFilter',
src = cms.InputTag('goodElectrons'),
minNumber = cms.uint32(2),
)
if 'ee' in channel:
process.path *= (process.goodElectrons * process.twoGoodElectrons)
if 'em' in channel:
process.path *= (process.goodElectrons * process.oneGoodElectron
* process.goodMuons * process.oneGoodMuon)
############################################################################
# Jets
############################################################################
process.load('RecoJets.JetProducers.ak5PFJets_cfi')
process.ak5PFJets.srcPVs = cms.InputTag('goodOfflinePrimaryVertices')
process.ak5PFJetsCHS = process.ak5PFJets.clone( src = cms.InputTag('pfNoPileUp') )
process.kappaTuple.active += cms.vstring('Jets', 'PileupDensity')
process.kappaTuple.Jets = cms.PSet(
process.kappaNoCut,
process.kappaNoRegEx,
taggers = cms.vstring(),
ak5PFJets = cms.PSet(
src = cms.InputTag('ak5PFJets'),
QGtagger = cms.InputTag('AK5PFJetsQGTagger'),
Btagger = cms.InputTag('ak5PF'),
PUJetID = cms.InputTag('ak5PFPuJetMva'),
PUJetID_full = cms.InputTag('full'),
),
ak5PFJetsCHS = cms.PSet(
src = cms.InputTag('ak5PFJetsCHS'),
QGtagger = cms.InputTag('AK5PFJetsCHSQGTagger'),
Btagger = cms.InputTag('ak5PFCHS'),
PUJetID = cms.InputTag('ak5PFCHSPuJetMva'),
PUJetID_full = cms.InputTag('full'),
),
)
process.kappaTuple.Jets.minPt = cms.double(5.0)
if not data:
process.load('RecoJets.JetProducers.ak5GenJets_cfi')
process.path *= (
process.genParticlesForJetsNoNu *
process.ak5GenJetsNoNu
)
process.kappaTuple.active += cms.vstring('LV')
process.kappaTuple.LV.rename = cms.vstring('ak => AK')
process.kappaTuple.LV.whitelist = cms.vstring('ak5GenJetsNoNu')
# add kt6PFJets, needed for the PileupDensity
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets
process.kt6PFJets = kt4PFJets.clone( rParam = 0.6, doRhoFastjet = True )
process.kt6PFJets.Rho_EtaMax = cms.double(2.5)
process.path *= (
process.ak5PFJets
* process.ak5PFJetsCHS
* process.kt6PFJets
)
############################################################################
# MET
############################################################################
# MET correction ----------------------------------------------------------
process.load('JetMETCorrections.Type1MET.pfMETCorrectionType0_cfi')
process.path *= (
process.type0PFMEtCorrection
)
#TODO check type 0 corrections
process.kappaTuple.active += cms.vstring('MET') ## produce/save KappaPFMET
process.kappaTuple.MET.whitelist = cms.vstring('pfChMet', '_pfMet_')
if cmssw_version_number.startswith("5"):
# MET correction ----------------------------------------------------------
process.load("JetMETCorrections.Type1MET.pfMETCorrections_cff")
process.pfchsMETcorr.src = cms.InputTag('goodOfflinePrimaryVertices')
# Type-0
process.pfMETCHS = process.pfType1CorrectedMet.clone(
applyType1Corrections = cms.bool(False),
applyType0Corrections = cms.bool(True)
)
# MET Path
process.path *= (
process.producePFMETCorrections * process.pfMETCHS
)
process.kappaTuple.MET.whitelist += cms.vstring("pfMETCHS")
############################################################################
# Almost done ...
############################################################################
process.path *= (
process.kappaOut
)
return process
)
elPFIsoDepositCharged.src = cms.InputTag("patElectrons")
elPFIsoDepositChargedAll.src = cms.InputTag("patElectrons")
elPFIsoDepositNeutral.src = cms.InputTag("patElectrons")
elPFIsoDepositGamma.src = cms.InputTag("patElectrons")
elPFIsoDepositPU.src = cms.InputTag("patElectrons")
# electron/muon PF iso sequence
pfElectronIso = cms.Sequence(
electronPFIsolationDepositsSequence +
electronPFIsolationValuesSequence
)
# rho for electron iso
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets
kt6PFJetsForIsolation = kt4PFJets.clone( rParam = 0.6, doRhoFastjet = True )
kt6PFJetsForIsolation.Rho_EtaMax = cms.double(2.5)
## ------------------------------------------------------------------------
## Definition of sequences
## run this to produce patElectrons w/o generator match or trigger match
## and with MVA electron ID
makeKappaElectrons = cms.Sequence(
egmGsfElectronIDSequence *
patElectrons *
pfElectronIso *
kt6PFJetsForIsolation
)
import FWCore.ParameterSet.Config as cms
from RecoMET.METPUSubtraction.objectSelection_cff import *
##================================================
## MVA MET sequence
##================================================
from JetMETCorrections.Configuration.JetCorrectionServicesAllAlgos_cff import *
from JetMETCorrections.Configuration.DefaultJEC_cff import *
from RecoJets.JetProducers.PileupJetIDParams_cfi import JetIdParams
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets
kt6PFJets = kt4PFJets.clone(rParam = cms.double(0.6), doRhoFastjet = True )
calibratedAK4PFJetsForPFMVAMEt = cms.EDProducer('PFJetCorrectionProducer',
src = cms.InputTag('ak4PFJets'),
correctors = cms.vstring("ak4PFL1FastL2L3") # NOTE: use "ak5PFL1FastL2L3" for MC / "ak5PFL1FastL2L3Residual" for Data
)
pfMVAMEt = cms.EDProducer("PFMETProducerMVA",
srcCorrJets = cms.InputTag('calibratedAK4PFJetsForPFMVAMEt'),
srcUncorrJets = cms.InputTag('ak4PFJets'),
srcPFCandidates = cms.InputTag('particleFlow'),
srcVertices = cms.InputTag('offlinePrimaryVertices'),
srcLeptons = cms.VInputTag('selectedElectrons',
'selectedMuons',
'selectedTaus',
'selectedPhotons',
'selectedJets'),
minNumLeptons = cms.int32(0),
process.pfPileUp.Enable = True
process.pfPileUp.checkClosestZVertex = cms.bool(False)
process.pfPileUp.Vertices = cms.InputTag('goodOfflinePrimaryVertices')
process.pfJets.doAreaFastjet = True
process.pfJets.doRhoFastjet = False
#process.pfJets.Rho_EtaMax = cms.double(4.4)
#Compute the mean pt per unit area (rho) from the
#PFchs inputs
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets
process.kt6PFJets = kt4PFJets.clone(
rParam = cms.double(0.6),
src = cms.InputTag('pfNoElectron'+postfix),
doAreaFastjet = cms.bool(True),
doRhoFastjet = cms.bool(True),
# voronoiRfact = cms.double(0.9),
# Rho_EtaMax = cms.double(4.4)
)
process.patJetCorrFactors.rho = cms.InputTag("kt6PFJets", "rho")
inputJetCorrLabel = ('AK5PFchs', ['L1FastJet', 'L2Relative', 'L3Absolute','L2L3Residual'])
process.patJetCorrFactors.payload = inputJetCorrLabel[0]
process.patJetCorrFactors.levels = inputJetCorrLabel[1]
coneOpening = cms.double(0.4)
defaultIsolationCut = cms.double(0.2)
#coneOpening = process.coneOpening
#defaultIsolationCut = process.coneOpening
getattr(process,"pfNoJet"+postfix).enable = True # this i guess it's for photons...
#add q/g discriminator
process.load('QuarkGluonTagger.EightTeV.QGTagger_RecoJets_cff')
process.QGTagger.srcJets = cms.InputTag("selectedPatJets"+postfix)
process.QGTagger.isPatJet = cms.untracked.bool(True)
process.QGTagger.useCHS = cms.untracked.bool(True)
process.QGTagger.srcRho = cms.InputTag('kt6PFJets','rho')
process.QGTagger.srcRhoIso = cms.InputTag('kt6PFJetsCentral','rho')
process.qgSequence=cms.Sequence(process.goodOfflinePrimaryVerticesQG+process.QGTagger)
#compute rho from central pf candidates only
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets
process.kt6PFJetsCentral = kt4PFJets.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) )
from UserCode.llvv_fwk.btvDefaultSequence_cff import *
btvDefaultSequence(process,isMC,"selectedPatJets"+postfix,"goodOfflinePrimaryVertices")
# cf. https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookMetAnalysis
process.load("JetMETCorrections.Type1MET.pfMETCorrections_cff")
process.load("JetMETCorrections.Type1MET.pfMETCorrectionType0_cfi")
process.pfType1CorrectedMet.applyType0Corrections = cms.bool(False)
process.pfType1CorrectedMet.srcType1Corrections = cms.VInputTag( cms.InputTag('pfMETcorrType0'),
cms.InputTag('pfJetMETcorr', 'type1')
)
def getBaseConfig(globaltag= 'START53_V15A::All', testfile=cms.untracked.vstring(""), maxevents=100, nickname = 'SM_VBFHToTauTau_M_90_powheg_pythia_8TeV', kappaTag = 'Kappa_1_0_0'):
from Kappa.Skimming.KSkimming_template_cfg import process
process.source.fileNames = testfile
process.maxEvents.input = maxevents ## number of events to be processed (-1 = all in file)
process.kappaTuple.outputFile = 'kappaTuple.root' ## name of output file
process.kappaTuple.verbose = cms.int32(0) ## verbosity level
process.kappaTuple.profile = cms.bool(True)
if not globaltag.lower() == 'auto' :
process.GlobalTag.globaltag = globaltag
print "GT (overwritten):", process.GlobalTag.globaltag
data = datasetsHelper.isData(nickname)
centerOfMassEnergy = datasetsHelper.getCenterOfMassEnergy(nickname)
isEmbedded = datasetsHelper.getIsEmbedded(nickname)
process.p = cms.Path()
## ------------------------------------------------------------------------
# Configure Metadata describing the file
process.kappaTuple.active = cms.vstring('TreeInfo')
process.kappaTuple.TreeInfo.parameters = cms.PSet(
dataset = cms.string(datasetsHelper.getDatasetName(nickname)),
generator = cms.string(datasetsHelper.getGenerator(nickname)),
productionProcess = cms.string(datasetsHelper.getProcess(nickname)),
globalTag = cms.string(globaltag),
prodCampaignGlobalTag = cms.string(datasetsHelper.getProductionCampaignGlobalTag(nickname, centerOfMassEnergy)),
runPeriod = cms.string(datasetsHelper.getRunPeriod(nickname)),
kappaTag = cms.string(kappaTag),
isEmbedded = cms.bool(isEmbedded),
jetMultiplicity = cms.int32(datasetsHelper.getJetMultiplicity(nickname)),
centerOfMassEnergy = cms.int32(centerOfMassEnergy),
puScenario = cms.string(datasetsHelper.getPuScenario(nickname, centerOfMassEnergy)),
isData = cms.bool(data),
)
## ------------------------------------------------------------------------
# General configuration
process.kappaTuple.active += cms.vstring('VertexSummary') ## save VertexSummary,
process.kappaTuple.active += cms.vstring('BeamSpot') ## save Beamspot,
process.kappaTuple.active += cms.vstring('TriggerObjects')
if not isEmbedded:
if data:
process.kappaTuple.active+= cms.vstring('DataInfo') ## produce Metadata for data,
else:
process.kappaTuple.active+= cms.vstring('GenInfo') ## produce Metadata for MC,
process.kappaTuple.active+= cms.vstring('GenParticles') ## save GenParticles,
process.kappaTuple.active+= cms.vstring('GenTaus') ## save GenParticles,
# prune GenParticles
if not data:
process.load("SimGeneral.HepPDTESSource.pythiapdt_cfi")
process.prunedGenParticles = cms.EDProducer("GenParticlePruner",
src = cms.InputTag("genParticles", "", "SIM"),
select = cms.vstring(
"drop *",
"keep status == 3", # all status 3
"keep++ abs(pdgId) == 23", # Z
"keep++ abs(pdgId) == 24", # W
"keep++ abs(pdgId) == 25", # H
"keep abs(pdgId) == 11 || abs(pdgId) == 13", # charged leptons
"keep++ abs(pdgId) == 15" # keep full tau decay chain
)
)
process.kappaTuple.Info.hltWhitelist = cms.vstring( ## HLT selection
# https://github.com/cms-analysis/HiggsAnalysis-KITHiggsToTauTau/blob/master/data/triggerTables-2011-2012.txt
# https://twiki.cern.ch/twiki/bin/viewauth/CMS/HiggsToTauTauWorkingSummer2013
# can be tested at http://regexpal.com
# e
"^HLT_Ele[0-9]+_CaloIdVT(_CaloIsoT)?_TrkIdT(_TrkIsoT)?_v[0-9]+$",
"^HLT_Ele[0-9]+_WP[0-9]+_v[0-9]+$",
# m
"^HLT_(Iso)?Mu[0-9]+(_eta2p1)?_v[0-9]+$",
# ee
"^HLT_Ele[0-9]+_CaloId(L|T)(_TrkIdVL)?_CaloIsoVL(_TrkIdVL)?(_TrkIsoVL)?" +
"_Ele[0-9]+_CaloId(L|T)(_TrkIdVL)?_CaloIsoVL(_TrkIdVL)?(_TrkIsoVL)?_v[0-9]+$",
"^HLT_Ele[0-9]+_Ele[0-9]+_CaloId(L|T)_CaloIsoVL(_TrkIdVL_TrkIsoVL)?_v[0-9]+$",
# mm
"^HLT_(Double)?Mu[0-9]+(_(Mu|Jet)[0-9]+)?_v[0-9]+$",
# em
"^HLT_Mu[0-9]+_(Ele|Photon)[0-9]+_CaloId(L|T|VT)(_CaloIsoVL|_IsoT)?(_TrkIdVL_TrkIsoVL)?_v[0-9]+$",
# et
"^HLT_Ele[0-9]+_CaloIdVT(_Calo(IsoRho|Iso)T)?_TrkIdT(_TrkIsoT)?_(Loose|Medium|Tight)IsoPFTau[0-9]+_v[0-9]+$",
"^HLT_Ele[0-9]+_eta2p1_WP[0-9]+(Rho|NoIso)_LooseIsoPFTau[0-9]+_v[0-9]+$",
# mt
"^HLT_(Iso)?Mu[0-9]+(_eta2p1)?_(Loose|Medium|Tight)IsoPFTau[0-9]+(_Trk[0-9]_eta2p1)?_v[0-9]+$",
# tt
"^HLT_Double(Medium)?IsoPFTau[0-9]+_Trk(1|5)_eta2p1_(Jet[0-9]+|Prong[0-9])?_v[0-9]+$",
"^HLT_Double(Medium)?IsoPFTau[0-9]+_Trk(1|5)(_eta2p1)?_v[0-9]+$",
# specials (possible generalization: Mu15, L1ETM20, Photon20, Ele8)
"^HLT_Ele[0-9]+_CaloId(L|T|VT)_CaloIso(VL|T|VT)(_TrkIdT)?(_TrkIsoVT)?_(SC|Ele)[0-9](_Mass[0-9]+)?_v[0-9]+$",
"^HLT_Ele8_v[0-9]+$",
"^HLT_IsoMu15(_eta2p1)?_L1ETM20_v[0-9]+$",
"^HLT_Photon20_CaloIdVT_IsoT_Ele8_CaloIdL_CaloIsoVL_v[0-9]+$",
# specials for tag and probe and em fakerate studies could be added if enough bits are ensured
#"^HLT_Ele[0-9]+_CaloId(L|T|VT)_CaloIso(VL|T|VT)(_TrkIdT_TrkIso(T|VT))?_(SC|Ele)[0-9]+(_Mass[0-9]+)?_v[0-9]+$",
#"^HLT_Mu[0-9]+_Photon[0-9]+_CaloIdVT_IsoT_v[0-9]+$",
#"^HLT_Ele[0-9]+_CaloId(L|T)(_TrkIdVL)?_CaloIsoVL(_TrkIdVL_TrkIsoVL)?(_TrkIsoVL)?(_Jet[0-9]+|)?_v[0-9]+$",
)
process.kappaTuple.Info.hltBlacklist = cms.vstring(
"HLT_Mu13_Mu8", # v21 gives errors for the trigger objects
)
## ------------------------------------------------------------------------
# Configure PFCandidates and offline PV
process.load("Kappa.Skimming.KPFCandidates_cff")
#process.kappaTuple.active += cms.vstring('PFCandidates') ## save PFCandidates for deltaBeta corrected
process.kappaTuple.PFCandidates.whitelist = cms.vstring( ## isolation used for electrons and muons.
## "pfNoPileUpChargedHadrons", ## switch to pfAllChargedParticles
"pfAllChargedParticles", ## same as pfNoPileUpChargedHadrons +pf_electrons + pf_muons
"pfNoPileUpNeutralHadrons",
"pfNoPileUpPhotons",
"pfPileUpChargedHadrons",
)
process.p *= ( process.makePFBRECO * process.makePFCandidatesForDeltaBeta )
## ------------------------------------------------------------------------
# Configure Muons
process.load("Kappa.Skimming.KMuons_cff")
process.kappaTuple.active += cms.vstring('Muons') ## produce/save KappaMuons
process.kappaTuple.Muons.minPt = cms.double(8.0)
process.p *= process.makeKappaMuons
## ------------------------------------------------------------------------
# Configure Electrons
process.load("Kappa.Skimming.KElectrons_cff")
process.kappaTuple.active += cms.vstring('Electrons') ## produce/save KappaElectrons,
process.kappaTuple.Electrons.ids = cms.vstring("mvaTrigV0",
"mvaTrigNoIPV0",
"mvaNonTrigV0")
process.kappaTuple.Electrons.minPt = cms.double(8.0)
process.p *= process.makeKappaElectrons
## for electron/muon iso
# https://github.com/ajgilbert/ICHiggsTauTau/blob/master/test/higgstautau_cfg.py#L418-L448
from CommonTools.ParticleFlow.Tools.pfIsolation import setupPFElectronIso, setupPFMuonIso
process.eleIsoSequence = setupPFElectronIso(process, 'patElectrons')
process.muIsoSequence = setupPFMuonIso(process, 'muons')
process.eleIsoSequence.remove(process.elPFIsoValueCharged03NoPFIdPFIso)
process.eleIsoSequence.remove(process.elPFIsoValueChargedAll03NoPFIdPFIso)
process.eleIsoSequence.remove(process.elPFIsoValueGamma03NoPFIdPFIso)
process.eleIsoSequence.remove(process.elPFIsoValueNeutral03NoPFIdPFIso)
process.eleIsoSequence.remove(process.elPFIsoValuePU03NoPFIdPFIso)
process.eleIsoSequence.remove(process.elPFIsoValueCharged04NoPFIdPFIso)
process.eleIsoSequence.remove(process.elPFIsoValueChargedAll04NoPFIdPFIso)
process.eleIsoSequence.remove(process.elPFIsoValueGamma04NoPFIdPFIso)
process.eleIsoSequence.remove(process.elPFIsoValueNeutral04NoPFIdPFIso)
process.eleIsoSequence.remove(process.elPFIsoValuePU04NoPFIdPFIso)
process.elPFIsoValueGamma04PFIdPFIso.deposits[0].vetos = cms.vstring('EcalEndcaps:ConeVeto(0.08)','EcalBarrel:ConeVeto(0.08)')
process.elPFIsoValueNeutral04PFIdPFIso.deposits[0].vetos = cms.vstring()
process.elPFIsoValuePU04PFIdPFIso.deposits[0].vetos = cms.vstring()
process.elPFIsoValueCharged04PFIdPFIso.deposits[0].vetos = cms.vstring('EcalEndcaps:ConeVeto(0.015)')
process.elPFIsoValueChargedAll04PFIdPFIso.deposits[0].vetos = cms.vstring('EcalEndcaps:ConeVeto(0.015)','EcalBarrel:ConeVeto(0.01)')
process.pfiso = cms.Sequence(process.pfParticleSelectionSequence + process.eleIsoSequence + process.muIsoSequence)
# rho for electron iso
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets
process.kt6PFJetsForIsolation = kt4PFJets.clone( rParam = 0.6, doRhoFastjet = True )
process.kt6PFJetsForIsolation.Rho_EtaMax = cms.double(2.5)
process.p *= (process.pfiso * process.kt6PFJetsForIsolation)
## ------------------------------------------------------------------------
# Configure Taus
process.load("Kappa.Skimming.KTaus_cff")
process.kappaTuple.active += cms.vstring('Taus') ## produce/save KappaTaus
process.kappaTuple.Taus.minPt = cms.double(8.0)
process.p *= process.makeKappaTaus
## ------------------------------------------------------------------------
## Kappa Jets
process.load("Kappa.Skimming.KJets_cff")
process.kappaTuple.active += cms.vstring('Jets', 'PileupDensity')
process.kappaTuple.Jets = cms.PSet(
process.kappaNoCut,
process.kappaNoRegEx,
taggers = cms.vstring(
"QGlikelihood",
"QGmlp",
"TrackCountingHighEffBJetTags",
"TrackCountingHighPurBJetTags",
"JetProbabilityBJetTags",
"JetBProbabilityBJetTags",
"SoftElectronBJetTags",
"SoftMuonBJetTags",
"SoftMuonByIP3dBJetTags",
"SoftMuonByPtBJetTags",
"SimpleSecondaryVertexBJetTags",
"CombinedSecondaryVertexBJetTags",
"CombinedSecondaryVertexMVABJetTags",
"puJetIDFullDiscriminant",
"puJetIDFullLoose",
"puJetIDFullMedium",
"puJetIDFullTight",
"puJetIDCutbasedDiscriminant",
"puJetIDCutbasedLoose",
"puJetIDCutbasedMedium",
"puJetIDCutbasedTight"
),
AK5PFTaggedJets = cms.PSet(
src = cms.InputTag("ak5PFJets"),
QGtagger = cms.InputTag("AK5PFJetsQGTagger"),
Btagger = cms.InputTag("ak5PF"),
PUJetID = cms.InputTag("ak5PFPuJetMva"),
PUJetID_full = cms.InputTag("full"),
),
AK5PFTaggedJetsCHS = cms.PSet(
src = cms.InputTag("ak5PFJetsCHS"),
QGtagger = cms.InputTag("AK5PFJetsCHSQGTagger"),
Btagger = cms.InputTag("ak5PFCHS"),
PUJetID = cms.InputTag("ak5PFCHSPuJetMva"),
PUJetID_full = cms.InputTag("full"),
),
)
process.kappaTuple.Jets.minPt = cms.double(10.0)
## ------------------------------------------------------------------------
# Special settings for embedded samples
# https://twiki.cern.ch/twiki/bin/viewauth/CMS/MuonTauReplacementWithPFlow
if isEmbedded:
process.load('RecoBTag/Configuration/RecoBTag_cff')
process.load('RecoJets/JetAssociationProducers/ak5JTA_cff')
process.ak5PFJetNewTracksAssociatorAtVertex.tracks = "tmfTracks"
process.ak5PFCHSNewJetTracksAssociatorAtVertex.tracks = "tmfTracks"
process.p *= process.btagging
# disable overrideHLTCheck for embedded samples, since it triggers an Kappa error
process.kappaTuple.Info.overrideHLTCheck = cms.untracked.bool(True)
process.kappaTuple.active+= cms.vstring('DataInfo')
process.kappaTuple.active+= cms.vstring('GenParticles') ## save GenParticles,
process.kappaTuple.active+= cms.vstring('GenTaus') ## save GenParticles,
process.kappaTuple.GenParticles.genParticles.src = cms.InputTag("genParticles","","EmbeddedRECO")
process.kappaTuple.Info.isEmbedded = cms.bool(True)
# Let Jets run
process.p *= (
process.makeKappaTaus *
process.makePFJets *
process.makePFJetsCHS *
process.makeQGTagging *
process.makeBTagging *
process.makePUJetID
)
## ------------------------------------------------------------------------
## MET
process.load("Kappa.Skimming.KMET_cff")
process.kappaTuple.active += cms.vstring('GenMET') ## produce/save KappaMET
process.kappaTuple.active += cms.vstring('MET') ## produce/save KappaPFMET
process.p *= process.makeKappaMET
#"""
if not data:
process.load('PhysicsTools/JetMCAlgos/TauGenJets_cfi')
process.load('PhysicsTools/JetMCAlgos/TauGenJetsDecayModeSelectorAllHadrons_cfi')
process.p *= (process.tauGenJets+process.tauGenJetsSelectorAllHadrons)
process.kappaTuple.GenJets.whitelist = cms.vstring("tauGenJets")
process.kappaTuple.active += cms.vstring('GenJets')
# add python config to TreeInfo
process.kappaTuple.TreeInfo.parameters.config = cms.string(process.dumpPython())
# add repository revisions to TreeInfo
for repo, rev in tools.get_repository_revisions().iteritems():
setattr(process.kappaTuple.TreeInfo.parameters, repo, cms.string(rev))
## ------------------------------------------------------------------------
## And let it run
process.p *= (
process.kappaOut
)
## ------------------------------------------------------------------------
## declare edm OutputModule (expects a path 'p'), uncommented if wanted
#process.edmOut = cms.OutputModule(
# "PoolOutputModule",
# fileName = cms.untracked.string('dump.root'), ## name of output file
# SelectEvents = cms.untracked.PSet( SelectEvents = cms.vstring('p') ), ## save only events passing the full path
# outputCommands = cms.untracked.vstring('drop *', 'keep *_*_*_KAPPA') ## save each edm object that has been produced by process KAPPA
# )
#process.ep = cms.EndPath(process.edmOut)
return process
outputCommands = cms.untracked.vstring('drop *', *patEventContent )
)
# Configure PAT to use PF2PAT instead of AOD sources
from PhysicsTools.PatAlgos.tools.pfTools import *
# Compute the mean pt per unit area (rho) from the
# various PFchs inputs
# -> note: when using PFnoPileUp, rho must be computed from the kt6-pfjets
# with charged pf-candidates not coming from the PV already subtracted!
# since the kt6-pfjets come from the pfNoElectron collection (which
# is different for each pf2pat branch) we run it three times...
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets
process.kt6PFJetsPF2 = kt4PFJets.clone(
rParam = cms.double(0.6),
src = cms.InputTag('pfNoElectronPF2'),
doAreaFastjet = cms.bool(True),
doRhoFastjet = cms.bool(True)
)
process.kt6PFJetsPF3 = kt4PFJets.clone(
rParam = cms.double(0.6),
src = cms.InputTag('pfNoElectronPF3'),
doAreaFastjet = cms.bool(True),
doRhoFastjet = cms.bool(True)
)
process.kt6PFJetsPFAntiIso = kt4PFJets.clone(
rParam = cms.double(0.6),
src = cms.InputTag('pfNoElectronPFAntiIso'),
doAreaFastjet = cms.bool(True),
doRhoFastjet = cms.bool(True)
)
import FWCore.ParameterSet.Config as cms
# load jet energy correction parameters
from JetMETCorrections.Configuration.JetCorrectionServices_cff import *
#--------------------------------------------------------------------------------
# produce rho parameters needed for L1FastJet corrections
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets
kt6PFNewJets = kt4PFJets.clone(
src = cms.InputTag('particleFlow'),
rParam = cms.double(0.6),
doRhoFastjet = cms.bool(True),
Rho_EtaMax = cms.double(2.5)
)
# CV: need to rerun 'ak5PFJets' module with jet area computation enabled,
# since it has not been enabled per default in CMSSW_4_2_x
# (if the jet area of 'ak5PFJets' is zero, the L1FastjetCorrector::correction function always returns 1.0)
from RecoJets.JetProducers.ak5PFJets_cfi import ak5PFJets
ak5PFJets.doAreaFastjet = cms.bool(True)
#--------------------------------------------------------------------------------
#--------------------------------------------------------------------------------
# select PFCandidates ("unclustered energy") not within jets
# for Type 2 MET correction
from CommonTools.ParticleFlow.TopProjectors.pfNoJet_cfi import pfNoJet
pfCandsNotInJet = pfNoJet.clone(
topCollection = cms.InputTag('ak5PFJets'),
bottomCollection = cms.InputTag('particleFlow')
)
#--------------------------------------------------------------------------------
def getBaseConfig(globaltag='START53_V15A::All',
testfile=cms.untracked.vstring(""),
maxevents=100,
nickname='SM_VBFHToTauTau_M_90_powheg_pythia_8TeV',
kappaTag='Kappa_1_0_0'):
from Kappa.Skimming.KSkimming_template_cfg import process
process.source.fileNames = testfile
process.maxEvents.input = maxevents ## number of events to be processed (-1 = all in file)
process.kappaTuple.outputFile = 'kappaTuple.root' ## name of output file
process.kappaTuple.verbose = cms.int32(0) ## verbosity level
process.kappaTuple.profile = cms.bool(True)
if not globaltag.lower() == 'auto':
process.GlobalTag.globaltag = globaltag
print "GT (overwritten):", process.GlobalTag.globaltag
data = datasetsHelper.isData(nickname)
centerOfMassEnergy = datasetsHelper.getCenterOfMassEnergy(nickname)
isEmbedded = datasetsHelper.getIsEmbedded(nickname)
process.p = cms.Path()
## ------------------------------------------------------------------------
# Configure Metadata describing the file
process.kappaTuple.active = cms.vstring('TreeInfo')
process.kappaTuple.TreeInfo.parameters = cms.PSet(
dataset=cms.string(datasetsHelper.getDatasetName(nickname)),
generator=cms.string(datasetsHelper.getGenerator(nickname)),
productionProcess=cms.string(datasetsHelper.getProcess(nickname)),
globalTag=cms.string(globaltag),
prodCampaignGlobalTag=cms.string(
datasetsHelper.getProductionCampaignGlobalTag(
nickname, centerOfMassEnergy)),
runPeriod=cms.string(datasetsHelper.getRunPeriod(nickname)),
kappaTag=cms.string(kappaTag),
isEmbedded=cms.bool(isEmbedded),
jetMultiplicity=cms.int32(datasetsHelper.getJetMultiplicity(nickname)),
centerOfMassEnergy=cms.int32(centerOfMassEnergy),
puScenario=cms.string(
datasetsHelper.getPuScenario(nickname, centerOfMassEnergy)),
isData=cms.bool(data),
)
## ------------------------------------------------------------------------
# General configuration
process.kappaTuple.active += cms.vstring(
'VertexSummary') ## save VertexSummary,
process.kappaTuple.active += cms.vstring('BeamSpot') ## save Beamspot,
process.kappaTuple.active += cms.vstring('TriggerObjects')
if not isEmbedded:
if data:
process.kappaTuple.active += cms.vstring(
'DataInfo') ## produce Metadata for data,
else:
process.kappaTuple.active += cms.vstring(
'GenInfo') ## produce Metadata for MC,
process.kappaTuple.active += cms.vstring(
'GenParticles') ## save GenParticles,
process.kappaTuple.active += cms.vstring(
'GenTaus') ## save GenParticles,
# prune GenParticles
if not data:
process.load("SimGeneral.HepPDTESSource.pythiapdt_cfi")
process.prunedGenParticles = cms.EDProducer(
"GenParticlePruner",
src=cms.InputTag("genParticles", "", "SIM"),
select=cms.vstring(
"drop *",
"keep status == 3", # all status 3
"keep++ abs(pdgId) == 23", # Z
"keep++ abs(pdgId) == 24", # W
"keep++ abs(pdgId) == 25", # H
"keep abs(pdgId) == 11 || abs(pdgId) == 13", # charged leptons
"keep++ abs(pdgId) == 15" # keep full tau decay chain
))
process.kappaTuple.Info.hltWhitelist = cms.vstring( ## HLT selection
# https://github.com/cms-analysis/HiggsAnalysis-KITHiggsToTauTau/blob/master/data/triggerTables-2011-2012.txt
# https://twiki.cern.ch/twiki/bin/viewauth/CMS/HiggsToTauTauWorkingSummer2013
# can be tested at http://regexpal.com
# e
"^HLT_Ele[0-9]+_CaloIdVT(_CaloIsoT)?_TrkIdT(_TrkIsoT)?_v[0-9]+$",
"^HLT_Ele[0-9]+_WP[0-9]+_v[0-9]+$",
# m
"^HLT_(Iso)?Mu[0-9]+(_eta2p1)?_v[0-9]+$",
# ee
"^HLT_Ele[0-9]+_CaloId(L|T)(_TrkIdVL)?_CaloIsoVL(_TrkIdVL)?(_TrkIsoVL)?"
+
"_Ele[0-9]+_CaloId(L|T)(_TrkIdVL)?_CaloIsoVL(_TrkIdVL)?(_TrkIsoVL)?_v[0-9]+$",
"^HLT_Ele[0-9]+_Ele[0-9]+_CaloId(L|T)_CaloIsoVL(_TrkIdVL_TrkIsoVL)?_v[0-9]+$",
# mm
"^HLT_(Double)?Mu[0-9]+(_(Mu|Jet)[0-9]+)?_v[0-9]+$",
# em
"^HLT_Mu[0-9]+_(Ele|Photon)[0-9]+_CaloId(L|T|VT)(_CaloIsoVL|_IsoT)?(_TrkIdVL_TrkIsoVL)?_v[0-9]+$",
# et
"^HLT_Ele[0-9]+_CaloIdVT(_Calo(IsoRho|Iso)T)?_TrkIdT(_TrkIsoT)?_(Loose|Medium|Tight)IsoPFTau[0-9]+_v[0-9]+$",
"^HLT_Ele[0-9]+_eta2p1_WP[0-9]+(Rho|NoIso)_LooseIsoPFTau[0-9]+_v[0-9]+$",
# mt
"^HLT_(Iso)?Mu[0-9]+(_eta2p1)?_(Loose|Medium|Tight)IsoPFTau[0-9]+(_Trk[0-9]_eta2p1)?_v[0-9]+$",
# tt
"^HLT_Double(Medium)?IsoPFTau[0-9]+_Trk(1|5)_eta2p1_(Jet[0-9]+|Prong[0-9])?_v[0-9]+$",
"^HLT_Double(Medium)?IsoPFTau[0-9]+_Trk(1|5)(_eta2p1)?_v[0-9]+$",
# specials (possible generalization: Mu15, L1ETM20, Photon20, Ele8)
"^HLT_Ele[0-9]+_CaloId(L|T|VT)_CaloIso(VL|T|VT)(_TrkIdT)?(_TrkIsoVT)?_(SC|Ele)[0-9](_Mass[0-9]+)?_v[0-9]+$",
"^HLT_Ele8_v[0-9]+$",
"^HLT_IsoMu15(_eta2p1)?_L1ETM20_v[0-9]+$",
"^HLT_Photon20_CaloIdVT_IsoT_Ele8_CaloIdL_CaloIsoVL_v[0-9]+$",
# specials for tag and probe and em fakerate studies could be added if enough bits are ensured
#"^HLT_Ele[0-9]+_CaloId(L|T|VT)_CaloIso(VL|T|VT)(_TrkIdT_TrkIso(T|VT))?_(SC|Ele)[0-9]+(_Mass[0-9]+)?_v[0-9]+$",
#"^HLT_Mu[0-9]+_Photon[0-9]+_CaloIdVT_IsoT_v[0-9]+$",
#"^HLT_Ele[0-9]+_CaloId(L|T)(_TrkIdVL)?_CaloIsoVL(_TrkIdVL_TrkIsoVL)?(_TrkIsoVL)?(_Jet[0-9]+|)?_v[0-9]+$",
)
process.kappaTuple.Info.hltBlacklist = cms.vstring(
"HLT_Mu13_Mu8", # v21 gives errors for the trigger objects
)
## ------------------------------------------------------------------------
# Configure PFCandidates and offline PV
process.load("Kappa.Skimming.KPFCandidates_cff")
#process.kappaTuple.active += cms.vstring('PFCandidates') ## save PFCandidates for deltaBeta corrected
process.kappaTuple.PFCandidates.whitelist = cms.vstring( ## isolation used for electrons and muons.
## "pfNoPileUpChargedHadrons", ## switch to pfAllChargedParticles
"pfAllChargedParticles", ## same as pfNoPileUpChargedHadrons +pf_electrons + pf_muons
"pfNoPileUpNeutralHadrons",
"pfNoPileUpPhotons",
"pfPileUpChargedHadrons",
)
process.p *= (process.makePFBRECO * process.makePFCandidatesForDeltaBeta)
## ------------------------------------------------------------------------
# Configure Muons
process.load("Kappa.Skimming.KMuons_cff")
process.kappaTuple.active += cms.vstring(
'Muons') ## produce/save KappaMuons
process.kappaTuple.Muons.minPt = cms.double(8.0)
process.p *= process.makeKappaMuons
## ------------------------------------------------------------------------
# Configure Electrons
process.load("Kappa.Skimming.KElectrons_cff")
process.kappaTuple.active += cms.vstring(
'Electrons') ## produce/save KappaElectrons,
process.kappaTuple.Electrons.ids = cms.vstring("mvaTrigV0",
"mvaTrigNoIPV0",
"mvaNonTrigV0")
process.kappaTuple.Electrons.minPt = cms.double(8.0)
process.p *= process.makeKappaElectrons
## for electron/muon iso
# https://github.com/ajgilbert/ICHiggsTauTau/blob/master/test/higgstautau_cfg.py#L418-L448
from CommonTools.ParticleFlow.Tools.pfIsolation import setupPFElectronIso, setupPFMuonIso
process.eleIsoSequence = setupPFElectronIso(process, 'patElectrons')
process.muIsoSequence = setupPFMuonIso(process, 'muons')
process.eleIsoSequence.remove(process.elPFIsoValueCharged03NoPFIdPFIso)
process.eleIsoSequence.remove(process.elPFIsoValueChargedAll03NoPFIdPFIso)
process.eleIsoSequence.remove(process.elPFIsoValueGamma03NoPFIdPFIso)
process.eleIsoSequence.remove(process.elPFIsoValueNeutral03NoPFIdPFIso)
process.eleIsoSequence.remove(process.elPFIsoValuePU03NoPFIdPFIso)
process.eleIsoSequence.remove(process.elPFIsoValueCharged04NoPFIdPFIso)
process.eleIsoSequence.remove(process.elPFIsoValueChargedAll04NoPFIdPFIso)
process.eleIsoSequence.remove(process.elPFIsoValueGamma04NoPFIdPFIso)
process.eleIsoSequence.remove(process.elPFIsoValueNeutral04NoPFIdPFIso)
process.eleIsoSequence.remove(process.elPFIsoValuePU04NoPFIdPFIso)
process.elPFIsoValueGamma04PFIdPFIso.deposits[0].vetos = cms.vstring(
'EcalEndcaps:ConeVeto(0.08)', 'EcalBarrel:ConeVeto(0.08)')
process.elPFIsoValueNeutral04PFIdPFIso.deposits[0].vetos = cms.vstring()
process.elPFIsoValuePU04PFIdPFIso.deposits[0].vetos = cms.vstring()
process.elPFIsoValueCharged04PFIdPFIso.deposits[0].vetos = cms.vstring(
'EcalEndcaps:ConeVeto(0.015)')
process.elPFIsoValueChargedAll04PFIdPFIso.deposits[0].vetos = cms.vstring(
'EcalEndcaps:ConeVeto(0.015)', 'EcalBarrel:ConeVeto(0.01)')
process.pfiso = cms.Sequence(process.pfParticleSelectionSequence +
process.eleIsoSequence +
process.muIsoSequence)
# rho for electron iso
from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets
process.kt6PFJetsForIsolation = kt4PFJets.clone(rParam=0.6,
doRhoFastjet=True)
process.kt6PFJetsForIsolation.Rho_EtaMax = cms.double(2.5)
process.p *= (process.pfiso * process.kt6PFJetsForIsolation)
## ------------------------------------------------------------------------
# Configure Taus
process.load("Kappa.Skimming.KTaus_cff")
process.kappaTuple.active += cms.vstring('Taus') ## produce/save KappaTaus
process.kappaTuple.Taus.minPt = cms.double(8.0)
process.p *= process.makeKappaTaus
## ------------------------------------------------------------------------
## Kappa Jets
process.load("Kappa.Skimming.KJets_cff")
process.kappaTuple.active += cms.vstring('Jets', 'PileupDensity')
process.kappaTuple.Jets = cms.PSet(
process.kappaNoCut,
process.kappaNoRegEx,
taggers=cms.vstring(
"QGlikelihood", "QGmlp", "TrackCountingHighEffBJetTags",
"TrackCountingHighPurBJetTags", "JetProbabilityBJetTags",
"JetBProbabilityBJetTags", "SoftElectronBJetTags",
"SoftMuonBJetTags", "SoftMuonByIP3dBJetTags",
"SoftMuonByPtBJetTags", "SimpleSecondaryVertexBJetTags",
"CombinedSecondaryVertexBJetTags",
"CombinedSecondaryVertexMVABJetTags", "puJetIDFullDiscriminant",
"puJetIDFullLoose", "puJetIDFullMedium", "puJetIDFullTight",
"puJetIDCutbasedDiscriminant", "puJetIDCutbasedLoose",
"puJetIDCutbasedMedium", "puJetIDCutbasedTight"),
AK5PFTaggedJets=cms.PSet(
src=cms.InputTag("ak5PFJets"),
QGtagger=cms.InputTag("AK5PFJetsQGTagger"),
Btagger=cms.InputTag("ak5PF"),
PUJetID=cms.InputTag("ak5PFPuJetMva"),
PUJetID_full=cms.InputTag("full"),
),
AK5PFTaggedJetsCHS=cms.PSet(
src=cms.InputTag("ak5PFJetsCHS"),
QGtagger=cms.InputTag("AK5PFJetsCHSQGTagger"),
Btagger=cms.InputTag("ak5PFCHS"),
PUJetID=cms.InputTag("ak5PFCHSPuJetMva"),
PUJetID_full=cms.InputTag("full"),
),
)
process.kappaTuple.Jets.minPt = cms.double(10.0)
## ------------------------------------------------------------------------
# Special settings for embedded samples
# https://twiki.cern.ch/twiki/bin/viewauth/CMS/MuonTauReplacementWithPFlow
if isEmbedded:
process.load('RecoBTag/Configuration/RecoBTag_cff')
process.load('RecoJets/JetAssociationProducers/ak5JTA_cff')
process.ak5PFJetNewTracksAssociatorAtVertex.tracks = "tmfTracks"
process.ak5PFCHSNewJetTracksAssociatorAtVertex.tracks = "tmfTracks"
process.p *= process.btagging
# disable overrideHLTCheck for embedded samples, since it triggers an Kappa error
process.kappaTuple.Info.overrideHLTCheck = cms.untracked.bool(True)
process.kappaTuple.active += cms.vstring('DataInfo')
process.kappaTuple.active += cms.vstring(
'GenParticles') ## save GenParticles,
process.kappaTuple.active += cms.vstring(
'GenTaus') ## save GenParticles,
process.kappaTuple.GenParticles.genParticles.src = cms.InputTag(
"genParticles", "", "EmbeddedRECO")
process.kappaTuple.Info.isEmbedded = cms.bool(True)
# Let Jets run
process.p *= (process.makeKappaTaus * process.makePFJets *
process.makePFJetsCHS * process.makeQGTagging *
process.makeBTagging * process.makePUJetID)
## ------------------------------------------------------------------------
## MET
process.load("Kappa.Skimming.KMET_cff")
process.kappaTuple.active += cms.vstring(
'GenMET') ## produce/save KappaMET
process.kappaTuple.active += cms.vstring('MET') ## produce/save KappaPFMET
process.p *= process.makeKappaMET
#"""
if not data:
process.load('PhysicsTools/JetMCAlgos/TauGenJets_cfi')
process.load(
'PhysicsTools/JetMCAlgos/TauGenJetsDecayModeSelectorAllHadrons_cfi'
)
process.p *= (process.tauGenJets +
process.tauGenJetsSelectorAllHadrons)
process.kappaTuple.GenJets.whitelist = cms.vstring("tauGenJets")
process.kappaTuple.active += cms.vstring('GenJets')
# add python config to TreeInfo
process.kappaTuple.TreeInfo.parameters.config = cms.string(
process.dumpPython())
# add repository revisions to TreeInfo
for repo, rev in tools.get_repository_revisions().iteritems():
setattr(process.kappaTuple.TreeInfo.parameters, repo, cms.string(rev))
## ------------------------------------------------------------------------
## And let it run
process.p *= (process.kappaOut)
## ------------------------------------------------------------------------
## declare edm OutputModule (expects a path 'p'), uncommented if wanted
#process.edmOut = cms.OutputModule(
# "PoolOutputModule",
# fileName = cms.untracked.string('dump.root'), ## name of output file
# SelectEvents = cms.untracked.PSet( SelectEvents = cms.vstring('p') ), ## save only events passing the full path
# outputCommands = cms.untracked.vstring('drop *', 'keep *_*_*_KAPPA') ## save each edm object that has been produced by process KAPPA
# )
#process.ep = cms.EndPath(process.edmOut)
return process
