def buildSequence(process, patArgs):
sequence = cms.Sequence()
# Produce HPS taus from AK5 PF jets already in AOD
process.load("RecoTauTag.Configuration.RecoPFTauTag_cff")
sequence *= process.PFTau
# Produce pat taus, assuming patDefaultSequence is already included to the process
if not hasattr(process, "patTausHpsPFTau"):
tauTools.addTauCollection(process,
cms.InputTag('hpsPFTauProducer'),
algoLabel="hps",
typeLabel="PFTau")
process.patTausHpsPFTauForPV = process.patTausHpsPFTau.clone(
addGenJetMatch=False,
embedGenJetMatch=False,
addGenMatch=False,
embedGenMatch=False,
userIsolation=cms.PSet(),
isoDeposits=cms.PSet(),
)
process.patTausHpsPFTauForPV.tauIDSources.byRawCombinedIsolationDeltaBetaCorr = cms.InputTag(
"hpsPFTauDiscriminationByRawCombinedIsolationDBSumPtCorr")
sequence *= process.patTausHpsPFTauForPV
# Trigger matching
sequence *= HChTriggerMatching.addTauHLTMatching(
process,
patArgs["matchingTauTrigger"],
collections=["patTausHpsPFTauForPV"],
postfix="ForPV")
# Require decay mode finding
process.selectedPatTausHpsPFTauForPV = cms.EDFilter(
"PATTauSelector",
src=cms.InputTag("patTausHpsPFTauForPVTriggerMatchedForPV"),
cut=cms.string("tauID('decayModeFinding')"))
sequence *= process.selectedPatTausHpsPFTauForPV
# Obtain the index of the vertex of most isolated tau
process.selectedPrimaryVertexIndex = cms.EDProducer(
"HPlusVertexIndexTauMostIsolatedProducer",
vertexSrc=cms.InputTag("offlinePrimaryVertices"),
tauSrc=cms.InputTag("selectedPatTausHpsPFTauForPV"),
tauDiscriminator=cms.string("byRawCombinedIsolationDeltaBetaCorr"),
dz=cms.double(0.2),
)
sequence *= process.selectedPrimaryVertexIndex
return sequence
def buildSequence(process, patArgs):
sequence = cms.Sequence()
# Produce HPS taus from AK5 PF jets already in AOD
process.load("RecoTauTag.Configuration.RecoPFTauTag_cff")
sequence *= process.PFTau
# Produce pat taus, assuming patDefaultSequence is already included to the process
if not hasattr(process, "patTausHpsPFTau"):
tauTools.addTauCollection(process, cms.InputTag('hpsPFTauProducer'),
algoLabel = "hps",
typeLabel = "PFTau")
process.patTausHpsPFTauForPV = process.patTausHpsPFTau.clone(
addGenJetMatch = False,
embedGenJetMatch = False,
addGenMatch = False,
embedGenMatch = False,
userIsolation = cms.PSet(),
isoDeposits = cms.PSet(),
)
process.patTausHpsPFTauForPV.tauIDSources.byRawCombinedIsolationDeltaBetaCorr = cms.InputTag("hpsPFTauDiscriminationByRawCombinedIsolationDBSumPtCorr")
sequence *= process.patTausHpsPFTauForPV
# Trigger matching
sequence *= HChTriggerMatching.addTauHLTMatching(process, patArgs["matchingTauTrigger"], collections=["patTausHpsPFTauForPV"], postfix="ForPV")
# Require decay mode finding
process.selectedPatTausHpsPFTauForPV = cms.EDFilter("PATTauSelector",
src = cms.InputTag("patTausHpsPFTauForPVTriggerMatchedForPV"),
cut = cms.string("tauID('decayModeFinding')")
)
sequence *= process.selectedPatTausHpsPFTauForPV
# Obtain the index of the vertex of most isolated tau
process.selectedPrimaryVertexIndex = cms.EDProducer("HPlusVertexIndexTauMostIsolatedProducer",
vertexSrc = cms.InputTag("offlinePrimaryVertices"),
tauSrc = cms.InputTag("selectedPatTausHpsPFTauForPV"),
tauDiscriminator = cms.string("byRawCombinedIsolationDeltaBetaCorr"),
dz = cms.double(0.2),
)
sequence *= process.selectedPrimaryVertexIndex
return sequence
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
def addPatOnTheFly(process, options, dataVersion,
doPlainPat=True, doPF2PAT=False,
plainPatArgs={}, pf2patArgs={},
doMcPreselection=False):
def setPatArg(args, name, value):
if name in args:
print "Overriding PAT arg '%s' from '%s' to '%s'" % (name, str(args[name]), str(value))
args[name] = value
def setPatArgs(args, d):
for name, value in d.iteritems():
setPatArg(args, name, value)
counters = []
if dataVersion.isData():
counters.extend(HChDataSelection.dataSelectionCounters[:])
if options.tauEmbeddingInput != 0:
import HiggsAnalysis.HeavyChHiggsToTauNu.tauEmbedding.PFEmbeddingSource_cff as PFEmbeddingSource
counters.extend(MuonSelection.muonSelectionCounters[:])
counters.extend(PFEmbeddingSource.muonSelectionCounters)
elif dataVersion.isMC() and doMcPreselection:
counters = HChMcSelection.mcSelectionCounters[:]
if options.doPat == 0:
process.load("HiggsAnalysis.HeavyChHiggsToTauNu.HChPrimaryVertex_cfi")
seq = cms.Sequence(
# process.goodPrimaryVertices10
)
if dataVersion.isMC() and doMcPreselection:
process.eventPreSelection = HChMcSelection.addMcSelection(process, dataVersion, options.trigger)
seq *= process.eventPreSelection
if options.doTauHLTMatchingInAnalysis != 0:
process.patTausHpsPFTauTauTriggerMatched = HChTriggerMatching.createTauTriggerMatchingInAnalysis(options.trigger, "selectedPatTausHpsPFTau")
seq *= process.patTausHpsPFTauTauTriggerMatched
return (seq, counters)
print "Running PAT on the fly"
process.eventPreSelection = cms.Sequence()
if options.tauEmbeddingInput != 0:
if doPF2PAT or not doPlainPat:
raise Exception("Only plainPat can be done for tau embedding input at the moment")
# Hack to not to crash if something in PAT assumes process.out
hasOut = hasattr(process, "out")
if not hasOut:
process.out = cms.OutputModule("PoolOutputModule",
fileName = cms.untracked.string('dummy.root'),
outputCommands = cms.untracked.vstring()
)
setPatArgs(plainPatArgs, {"doPatTrigger": False,
"doTauHLTMatching": False,
"doPatCalo": False,
"doBTagging": True,
"doPatElectronID": False})
process.patSequence = addPat(process, dataVersion, plainPatArgs=plainPatArgs)
# FIXME: this is broken at the moment
#removeSpecificPATObjects(process, ["Muons", "Electrons", "Photons"], False)
process.patDefaultSequence.remove(process.patMuons)
process.patDefaultSequence.remove(process.selectedPatMuons)
#process.selectedPatCandidates.remove(process.selectedPatMuons)
process.patDefaultSequence.remove(process.muonMatch)
process.patDefaultSequence.remove(process.patElectrons)
process.patDefaultSequence.remove(process.selectedPatElectrons)
#process.selectedPatCandidates.remove(process.selectedPatElectrons)
process.patDefaultSequence.remove(process.electronMatch)
process.patDefaultSequence.remove(process.patPhotons)
process.patDefaultSequence.remove(process.selectedPatPhotons)
#process.selectedPatCandidates.remove(process.selectedPatPhotons)
process.patDefaultSequence.remove(process.photonMatch)
del process.patMuons
del process.selectedPatMuons
del process.muonMatch
del process.patElectrons
del process.selectedPatElectrons
del process.electronMatch
del process.patPhotons
del process.selectedPatPhotons
del process.photonMatch
# Remove soft muon b tagging discriminators as they are not
# well defined, cause technical problems and we don't use
# them.
process.patJets.discriminatorSources = filter(lambda tag: "softMuon" not in tag.getModuleLabel(), process.patJets.discriminatorSources)
for seq in [process.btagging, process.btaggingJetTagsAOD, process.btaggingTagInfosAOD]:
softMuonRemover = RemoveSoftMuonVisitor.RemoveSoftMuonVisitor()
seq.visit(softMuonRemover)
softMuonRemover.removeFound(process, seq)
# Use the merged track collection
process.ak5PFJetTracksAssociatorAtVertex.tracks.setModuleLabel("tmfTracks")
process.jetTracksAssociatorAtVertex.tracks.setModuleLabel("tmfTracks")
# Do jet-parton matching with the genParticles of the original event
if dataVersion.isMC():
process.patJetPartons.src.setProcessName(dataVersion.getTriggerProcess())
process.patJetPartonMatch.matched.setProcessName(dataVersion.getTriggerProcess())
# in v13_3 embeddings the GenJets are done from the tau part, hence they are meaningless
process.patJets.addGenJetMatch = False
process.patJets.genJetMatch = ""
# Another part of the PAT process.out hack
if not hasOut:
del process.out
# Add PV selection, if not yet done by PAT
# if dataVersion.isData():
# process.load("HiggsAnalysis.HeavyChHiggsToTauNu.HChPrimaryVertex_cfi")
# process.patSequence *= process.goodPrimaryVertices
else:
if dataVersion.isData():
process.eventPreSelection = HChDataSelection.addDataSelection(process, dataVersion, options.trigger)
elif dataVersion.isMC() and doMcPreselection:
process.eventPreSelection = HChMcSelection.addMcSelection(process, dataVersion, options.trigger)
pargs = plainPatArgs.copy()
pargs2 = pf2patArgs.copy()
argsList = []
if doPlainPat:
argsList.append(pargs)
if doPF2PAT:
argsList.append(pargs2)
for args in argsList:
if args.get("doTauHLTMatching", True):
if not "matchingTauTrigger" in args:
if options.trigger == "":
raise Exception("Command line argument 'trigger' is missing")
args["matchingTauTrigger"] = options.trigger
print "Trigger used for tau matching:", args["matchingTauTrigger"]
process.patSequence = addPat(process, dataVersion,
doPlainPat=doPlainPat, doPF2PAT=doPF2PAT,
plainPatArgs=pargs, pf2patArgs=pargs2,)
# Add selection of PVs with sumPt > 10
# process.patSequence *= process.goodPrimaryVertices10
dataPatSequence = cms.Sequence(
process.eventPreSelection *
process.patSequence
)
if options.tauEmbeddingInput != 0:
from HiggsAnalysis.HeavyChHiggsToTauNu.tauEmbedding.customisations import addTauEmbeddingMuonTaus
process.patMuonTauSequence = addTauEmbeddingMuonTaus(process)
process.patSequence *= process.patMuonTauSequence
return (dataPatSequence, counters)
def addPlainPat(process, dataVersion, doPatTrigger=True, doPatTaus=True, doHChTauDiscriminators=True, doPatMET=True, doPatElectronID=True,
doPatCalo=True, doBTagging=True, doPatMuonPFIsolation=False, doPatTauIsoDeposits=False,
doTauHLTMatching=True, matchingTauTrigger=None, matchingJetTrigger=None,
includePFCands=False):
out = None
outdict = process.outputModules_()
if outdict.has_key("out"):
out = outdict["out"]
outputCommands = []
# Tau Discriminators
process.hplusPatTauSequence = cms.Sequence()
if doPatTaus:
process.hplusPatTauSequence = addPFTausAndDiscriminators(process, dataVersion, doPatCalo, doHChTauDiscriminators)
# PAT Layer 0+1
process.load("PhysicsTools.PatAlgos.patSequences_cff")
sequence = cms.Sequence(
process.hplusPatTauSequence
)
# Restrict input to AOD
restrictInputToAOD(process, ["All"])
# Remove MC stuff if we have collision data (has to be done any add*Collection!)
# This also adds the L2L3Residual JEC correction to the process.patJetCorrFactors
if dataVersion.isData():
runOnData(process, outputInProcess = out!=None)
# Jets
# Produce kt6 rho for L1Fastjet
process.load('RecoJets.Configuration.RecoPFJets_cff')
process.kt6PFJets.doRhoFastjet = True
process.ak5PFJets.doAreaFastjet = True
process.ak5PFJetSequence = cms.Sequence(process.kt6PFJets * process.ak5PFJets)
# Set defaults
process.patJets.jetSource = cms.InputTag("ak5CaloJets")
process.patJets.trackAssociationSource = cms.InputTag("ak5JetTracksAssociatorAtVertex")
setPatJetDefaults(process.patJets)
setPatJetCorrDefaults(process.patJetCorrFactors, dataVersion)
process.patDefaultSequence.replace(process.patJetCorrFactors,
process.ak5PFJetSequence*process.patJetCorrFactors)
process.selectedPatJets.cut = jetPreSelection
# The default JEC to be embedded to pat::Jets are L2Relative,
# L3Absolute, L5Flavor and L7Parton. The default JEC to be applied
# is L2L3Residual, or L3Absolute, or Uncorrected (in this order).
if doPatCalo:
# Add JPT jets
# FIXME: Disabled for now until the JEC for JPT works again (with the latest JEC)
# addJetCollection(process, cms.InputTag('JetPlusTrackZSPCorJetAntiKt5'),
# 'AK5', 'JPT',
# doJTA = True,
# doBTagging = doBTagging,
# jetCorrLabel = ('AK5JPT', process.patJetCorrFactors.levels),
# doType1MET = False,
# doL1Cleaning = False,
# doL1Counters = True,
# genJetCollection = cms.InputTag("ak5GenJets"),
# doJetID = True
# )
# Add PF jets
addJetCollection(process, cms.InputTag('ak5PFJets'),
'AK5', 'PF',
doJTA = True,
doBTagging = doBTagging,
jetCorrLabel = ('AK5PF', process.patJetCorrFactors.levels),
doType1MET = False,
doL1Cleaning = False,
doL1Counters = True,
genJetCollection = cms.InputTag("ak5GenJets"),
doJetID = True
)
setPatJetCorrDefaults(process.patJetCorrFactorsAK5PF, dataVersion, True)
else:
setPatJetCorrDefaults(process.patJetCorrFactors, dataVersion, True)
switchJetCollection(process, cms.InputTag('ak5PFJets'),
doJTA = True,
doBTagging = doBTagging,
jetCorrLabel = ('AK5PF', process.patJetCorrFactors.levels),
doType1MET = False,
genJetCollection = cms.InputTag("ak5GenJets"),
doJetID = True
)
outputCommands.extend([
"keep *_selectedPatJets_*_*",
"keep *_selectedPatJetsAK5JPT_*_*",
"keep *_selectedPatJetsAK5PF_*_*",
'drop *_selectedPatJets_pfCandidates_*', ## drop for default patJets which are CaloJets
'drop *_*PF_caloTowers_*',
'drop *_*JPT_pfCandidates_*',
'drop *_*Calo_pfCandidates_*',
])
# Taus
# Set default PATTauProducer options here, they should be
# replicated to all added tau collections (and the first call to
# addTauCollection should replace the default producer modified
# here)
setPatTauDefaults(process.patTaus, includePFCands)
process.selectedPatTaus.cut = tauPreSelection
if doPatTaus:
if doHChTauDiscriminators:
addHChTauDiscriminators()
# Don't enable TCTau nor shrinking cone tau
# if doPatCalo:
# tauTools.addTauCollection(process,cms.InputTag('caloRecoTauProducer'),
# algoLabel = "caloReco",
# typeLabel = "Tau")
# setPatTauDefaults(process.patTausCaloRecoTau, True)
# process.patTausCaloRecoTau.embedLeadTrack = not includePFCands
# process.patTausCaloRecoTau.embedLeadPFChargedHadrCand = False
# tauTools.addTauCollection(process,cms.InputTag('shrinkingConePFTauProducer'),
# algoLabel = "shrinkingCone",
# typeLabel = "PFTau")
# # Disable isoDeposits like this until the problem with doPFIsoDeposits is fixed
# if not doPatTauIsoDeposits:
# process.patTausShrinkingConePFTau.isoDeposits = cms.PSet()
tauTools.addTauCollection(process,cms.InputTag('hpsPFTauProducer'),
algoLabel = "hps",
typeLabel = "PFTau")
if not doPatTauIsoDeposits:
process.patTausHpsPFTau.isoDeposits = cms.PSet()
addPatTauIsolationEmbedding(process, process.patDefaultSequence, "HpsPFTau")
tauTools.addTauCollection(process,cms.InputTag('hpsTancTaus'),
algoLabel = "hpsTanc",
typeLabel = "PFTau")
if not doPatTauIsoDeposits:
process.patTausHpsTancPFTau.isoDeposits = cms.PSet()
# Disable discriminators which are not in AOD
# del process.patTausHpsTancPFTau.tauIDSources.againstCaloMuon
# del process.patTausHpsTancPFTau.tauIDSources.byHPSvloose
addPatTauIsolationEmbedding(process, process.patDefaultSequence, "HpsTancPFTau")
# Add visible taus
if dataVersion.isMC():
process.VisibleTaus = cms.EDProducer("HLTTauMCProducer",
GenParticles = cms.untracked.InputTag("genParticles"),
ptMinTau = cms.untracked.double(3),
ptMinMuon = cms.untracked.double(3),
ptMinElectron = cms.untracked.double(3),
BosonID = cms.untracked.vint32(23),
EtaMax = cms.untracked.double(2.5)
)
sequence *= process.VisibleTaus
outputCommands.append("keep *_VisibleTaus_*_*")
else:
# FIXME: this is broken at the moment
#removeSpecificPATObjects(process, ["Taus"], outputInProcess= out != None)
process.patDefaultSequence.remove(process.patTaus)
process.patDefaultSequence.remove(process.selectedPatTaus)
outputCommands.extend(["drop *_selectedPatTaus_*_*",
# "keep *_selectedPatTausCaloRecoTau_*_*",
# "keep *_selectedPatTausShrinkingConePFTau_*_*",
"keep *_selectedPatTausHpsPFTau_*_*",
"keep *_selectedPatTausHpsTancPFTau_*_*",
#"keep *_cleanPatTaus_*_*",
#"drop *_cleanPatTaus_*_*",
#"keep *_patTaus*_*_*",
#"keep *_patPFTauProducerFixedCone_*_*",
# keep these until the embedding problem with pat::Tau is fixed
#"keep recoPFCandidates_particleFlow_*_*",
#"keep recoTracks_generalTracks_*_*"
])
# MET
addPfMET(process, 'PF')
if doPatCalo:
addTcMET(process, 'TC')
else:
# FIXME: This is broken at the moment...
#removeSpecificPATObjects(process, ["METs"], outputInProcess= out != None)
#process.patDefaultSequen
process.patDefaultSequence.remove(process.patMETCorrections)
process.patDefaultSequence.remove(process.patMETs)
del process.patMETCorrections
del process.patMETs
outputCommands.extend([
"keep *_patMETs_*_*",
"keep *_patMETsTC_*_*",
"keep *_patMETsPF_*_*",
"keep *_genMetTrue_*_*",
])
# Muons
setPatLeptonDefaults(process.patMuons, includePFCands)
if doPatMuonPFIsolation:
addPFMuonIsolation(process, process.patMuons, sequence, verbose=True)
outputCommands.extend([
"keep *_selectedPatMuons_*_*"
])
# Electrons
# In order to calculate the transverse impact parameter w.r.t.
# beam spot instead of primary vertex, see
setPatLeptonDefaults(process.patMuons, includePFCands)
# Electron ID, see
# https://twiki.cern.ch/twiki/bin/view/CMS/SimpleCutBasedEleID
if doPatElectronID:
addPatElectronID(process, process.patElectrons, process.patDefaultSequence)
outputCommands.extend([
"keep *_selectedPatElectrons_*_*"
])
# Photons
# process.patPhotons.embedGenMatch = False
outputCommands.extend([
"keep *_selectedPatPhotons_*_*"
])
# Trigger
if doPatTrigger:
outMod= ''
if out != None:
outMod = 'out'
switchOnTrigger(process, hltProcess=dataVersion.getTriggerProcess(), outputModule=outMod)
process.patTrigger.addL1Algos = cms.bool(True)
process.patTrigger.l1ExtraMu = cms.InputTag("l1extraParticles")
process.patTrigger.l1ExtraCenJet = cms.InputTag("l1extraParticles", "Central")
process.patTrigger.l1ExtraTauJet = cms.InputTag("l1extraParticles", "Tau")
process.patTrigger.l1ExtraForJet = cms.InputTag("l1extraParticles", "Forward")
process.patTrigger.l1ExtraETM = cms.InputTag("l1extraParticles", "MET")
process.patTrigger.l1ExtraHTM = cms.InputTag("l1extraParticles", "MHT")
# Keep StandAlone trigger objects for enabling trigger
# matching in the analysis phase with PAT tools
outputCommands.extend(patTriggerStandAloneEventContent)
# Remove cleaning step and set the event content
if out == None:
myRemoveCleaning(process)
else:
backup = out.outputCommands[:]
myRemoveCleaning(process)
# backup_pat = out.outputCommands[:]
# Remove PFParticles here, they are explicitly included when needed
# backup_pat = filter(lambda n: "selectedPatPFParticles" not in n, backup_pat)
out.outputCommands = backup
# out.outputCommands.extend(backup_pat)
out.outputCommands.extend(outputCommands)
# Build sequence
sequence *= process.patDefaultSequence
# Tau+HLT matching
if doTauHLTMatching:
sequence *= HChTriggerMatching.addTauHLTMatching(process, matchingTauTrigger, matchingJetTrigger)
return sequence
)
muons = "preselectedMuons" # this is common to embedding muon selection and muon veto
process.preselectedMuonsFilter = cms.EDFilter("CandViewCountFilter",
src = cms.InputTag("preselectedMuons"),
minNumber = cms.uint32(1)
)
process.preselectedMuonsCount = cms.EDProducer("EventCountProducer")
process.commonSequence += (
process.preselectedMuons +
process.preselectedMuonsFilter +
process.preselectedMuonsCount
)
additionalCounters.append("preselectedMuonsCount")
# Trigger matching
import HiggsAnalysis.HeavyChHiggsToTauNu.HChTriggerMatching as HChTriggerMatching
process.preselectedMuonsMatched = HChTriggerMatching.createMuonTriggerMatchingInAnalysis(options.trigger, "preselectedMuons")
process.preselectedMuonsMatchedFilter = cms.EDFilter("CandViewCountFilter",
src = cms.InputTag("preselectedMuonsMatched"),
minNumber = cms.uint32(1)
)
process.preselectedMuonsMatchedCount = cms.EDProducer("EventCountProducer")
process.commonSequence += (
process.preselectedMuonsMatched +
process.preselectedMuonsMatchedFilter +
process.preselectedMuonsMatchedCount
)
additionalCounters.append("preselectedMuonsMatchedCount")
# Kinematic cuts
process.preselectedMuons41 = cms.EDFilter("PATMuonSelector",
src = cms.InputTag("preselectedMuonsMatched"),
cut = cms.string("pt() > 41 && abs(eta) < 2.1")
# Uncomment the following in order to print the counters at the end of
# the job (note that if many other modules are being run in the same
# job, their INFO messages are printed too)
#process.MessageLogger.cerr.threshold = cms.untracked.string("INFO")
# Fragment to run PAT on the fly if requested from command line
from HiggsAnalysis.HeavyChHiggsToTauNu.HChPatTuple import addPatOnTheFly
process.commonSequence, additionalCounters = addPatOnTheFly(
process, options, dataVersion)
# Re-run trigger matching
if doRerunTriggerMatching:
import HiggsAnalysis.HeavyChHiggsToTauNu.HChTriggerMatching as TriggerMatching
process.triggerMatching = TriggerMatching.addTauTriggerMatching(
process,
options.trigger,
"Tau",
#pathFilterMap={} # by default, use filter name in trigger matching re-running
)
process.commonSequence *= process.triggerMatching
# Add configuration information to histograms.root
from HiggsAnalysis.HeavyChHiggsToTauNu.HChTools import addConfigInfo
process.infoPath = addConfigInfo(process, options, dataVersion)
# MC Filter
import HiggsAnalysis.HeavyChHiggsToTauNu.tauEmbedding.customisations as tauEmbeddingCustomisations
if filterGenTaus:
additionalCounters.extend(
tauEmbeddingCustomisations.addGeneratorTauFilter(
process,
process.commonSequence,
"&& innerTrack().hitPattern().numberOfValidPixelHits() > 0"
"&& track().hitPattern().trackerLayersWithMeasurement() > 8"))
muons = "preselectedMuons" # this is common to embedding muon selection and muon veto
process.preselectedMuonsFilter = cms.EDFilter(
"CandViewCountFilter",
src=cms.InputTag("preselectedMuons"),
minNumber=cms.uint32(1))
process.preselectedMuonsCount = cms.EDProducer("EventCountProducer")
process.commonSequence += (process.preselectedMuons +
process.preselectedMuonsFilter +
process.preselectedMuonsCount)
additionalCounters.append("preselectedMuonsCount")
# Trigger matching
import HiggsAnalysis.HeavyChHiggsToTauNu.HChTriggerMatching as HChTriggerMatching
process.preselectedMuonsMatched = HChTriggerMatching.createMuonTriggerMatchingInAnalysis(
options.trigger, "preselectedMuons")
process.preselectedMuonsMatchedFilter = cms.EDFilter(
"CandViewCountFilter",
src=cms.InputTag("preselectedMuonsMatched"),
minNumber=cms.uint32(1))
process.preselectedMuonsMatchedCount = cms.EDProducer("EventCountProducer")
process.commonSequence += (process.preselectedMuonsMatched +
process.preselectedMuonsMatchedFilter +
process.preselectedMuonsMatchedCount)
additionalCounters.append("preselectedMuonsMatchedCount")
# Kinematic cuts
process.preselectedMuons41 = cms.EDFilter(
"PATMuonSelector",
src=cms.InputTag("preselectedMuonsMatched"),
cut=cms.string("pt() > 41 && abs(eta) < 2.1"))
process.preselectedMuons41Filter = cms.EDFilter(
def customise(process):
# Catch the case when this config is run from cmsDriver, it won't work due to VarParsing
# First protect against crab job creation, then the no-argument case
if hasattr(sys, "argv") and len(sys.argv) > 0:
if "cmsDriver" in sys.argv[0]:
print "Running pf_customise from cmsDriver, not executing running() further due to VarParsing"
return
else:
print "Running pf_customise"
# Command line arguments
import FWCore.ParameterSet.VarParsing as VarParsing
options = VarParsing.VarParsing('analysis')
options.register(
'overrideBeamSpot',
0, # default value, false
VarParsing.VarParsing.multiplicity.singleton,
VarParsing.VarParsing.varType.int,
"should I override beamspot in globaltag?")
options.register(
"tauDecayMode",
0, # Default is all decays
VarParsing.VarParsing.multiplicity.singleton,
VarParsing.VarParsing.varType.int,
"Tau decay mode (0=all, 230=hadronic)")
options.register(
"tauMinVisPt",
-1, # Disabled
VarParsing.VarParsing.multiplicity.singleton,
VarParsing.VarParsing.varType.int,
"Minimum visible pt of tau decay (-1 disabled, >= 0 cut value in GeV)")
options, dataVersion = getOptionsDataVersion("53XmcS10", options)
hltProcessName = dataVersion.getTriggerProcess()
recoProcessName = dataVersion.getRecoProcess()
processName = process.name_()
# Setup trigger matching
if not (dataVersion.isMC() and options.triggerMC == 0
and options.triggerMCInAnalysis == 0):
HChTriggerMatching.setMuonTriggerMatchingInAnalysis(
process.tightenedMuonsMatched, options.trigger)
# Setup MuScleFit
if dataVersion.isMC():
process.muscleCorrectedMuons.identifier = "Summer12_DR53X_smearReReco"
process.muscleCorrectedMuons.applySmearing = True
else:
process.muscleCorrectedMuons.identifier = "Data2012_53X_ReReco"
# Setup output
outputModule = None
outdict = process.outputModules_()
if len(outdict) == 1:
outputModule = outdict.values()[0]
elif outdict.has_key("RECOSIMoutput"):
outputModule = outdict["RECOSIMoutput"]
print "Adjusting event content to GEN-SIM-RECO+misc"
process.load(
"HiggsAnalysis.HeavyChHiggsToTauNu.tauEmbedding.HChEventContent_cff")
#outputModule.outputCommands = cms.untracked.vstring("keep *")
outputModule.outputCommands = cms.untracked.vstring("drop *")
outputModule.outputCommands.extend(
process.RECOSIMEventContent.outputCommands)
outputModule.outputCommands.extend([
"drop *_*_*_%s" % recoProcessName,
"keep *_generalTracks_*_%s" % recoProcessName,
"keep *_muons_*_%s" % recoProcessName,
"keep *_globalMuons_*_%s" % recoProcessName,
"keep recoGsfElectronCores_*_*_%s" % recoProcessName,
"keep *_gsfElectrons_*_%s" % recoProcessName,
"keep *_photons_*_%s" % recoProcessName,
"keep *_photonCore_*_%s" % recoProcessName,
"drop *_*_*_%s" % processName,
"keep *_particleFlow*_*_%s" % processName,
"keep *_generalTracks_*_%s" % processName,
"keep *_muons_*_%s" % processName,
"keep *_globalMuons_*_%s" % processName,
"keep *_*Electron*_*_%s" % processName,
"keep *_eid*_*_*",
])
outputModule.outputCommands.extend(
eventContent(hltProcessName, recoProcessName, processName))
# re_procName = re.compile("_\*$")
# outputModule.outputCommands.extend([re_procName.sub("_"+processName, x) for x in process.RECOSIMEventContent.outputCommands])
outputModule.outputCommands.extend(process.HChEventContent.outputCommands)
#outputModule.outputCommands.extend(process.RecoParticleFlowRECO.outputCommands)
#outputModule.outputCommands.extend(["keep *_%s_*_%s" % (x, processName) for x in [
#]])
# Remove duplicate "drop *"
index = 0
for item in outputModule.outputCommands[:]:
if item == "drop *" and index > 0:
del outputModule.outputCommands[index]
index -= 1
index += 1
# Disable gen vertex smearing
process.VtxSmeared = cms.EDProducer("FlatEvtVtxGenerator",
MaxZ=cms.double(0.0),
MaxX=cms.double(0.0),
MaxY=cms.double(0.0),
MinX=cms.double(0.0),
MinY=cms.double(0.0),
MinZ=cms.double(0.0),
TimeOffset=cms.double(0.0),
src=cms.InputTag("generator"))
# Set up tau decay options
process.generator.ZTauTau.TauolaOptions.InputCards.mdtau = options.tauDecayMode
if options.tauMinVisPt >= 0:
process.generator.ZTauTau.minVisibleTransverseMomentum = "%d" % options.tauMinVisPt
print "TAUOLA mdtau =", process.generator.ZTauTau.TauolaOptions.InputCards.mdtau
# Do we have to override the beam spot for data?
if options.overrideBeamSpot != 0:
bs = cms.string(
"BeamSpotObjects_2009_LumiBased_SigmaZ_v25_offline") # 44x data gt
#bs = cms.string("BeamSpotObjects_2009_LumiBased_SigmaZ_v21_offline") # 42x data gt
process.GlobalTag.toGet = cms.VPSet(
cms.PSet(record=cms.string("BeamSpotObjectsRcd"),
tag=bs,
connect=cms.untracked.string(
"frontier://FrontierProd/CMS_COND_31X_BEAMSPOT")))
print "BeamSpot in globaltag set to ", bs
else:
print "BeamSpot in globaltag not changed"
# Merge tracks
process.tmfTracks = cms.EDProducer(
"RecoTracksMixer",
trackCol1=cms.InputTag("dimuonsGlobal", "tracks"),
trackCol2=cms.InputTag("generalTracks", "", processName))
process.offlinePrimaryVerticesWithBS.TrackLabel = cms.InputTag("tmfTracks")
process.offlinePrimaryVertices.TrackLabel = cms.InputTag("tmfTracks")
#print process.muons
if hasattr(process.muons, "TrackExtractorPSet"):
# <= 42X
process.muons.TrackExtractorPSet.inputTrackCollection = cms.InputTag(
"tmfTracks")
elif hasattr(process, "muons1stStep") and hasattr(process.muons1stStep,
"TrackExtractorPSet"):
# >= 44X
process.muons1stStep.TrackExtractorPSet.inputTrackCollection = cms.InputTag(
"tmfTracks")
else:
raise Exception(
"Problem in overriding track collection for reco::Muon producer")
# Ensure that tmfTracks is always run after generalTracks (to mix the original and embedded tracks)
for p in process.paths:
pth = getattr(process, p)
if "generalTracks" in pth.moduleNames():
pth.replace(process.generalTracks,
process.generalTracks * process.tmfTracks)
# it should be the best solution to take the original beam spot for the
# reconstruction of the new primary vertex
# use the one produced earlier, do not produce your own
for s in process.sequences:
seq = getattr(process, s)
seq.remove(process.offlineBeamSpot)
# Remove beam halo Id
try:
process.metreco.remove(process.BeamHaloId)
except:
pass
# Disable lumi producer
process.localreco_HcalNZS.remove(process.lumiProducer)
process.localreco.remove(process.lumiProducer)
# PFCandidate embedding
process.particleFlowORG = process.particleFlow.clone()
# Since CMSSW 4_4 the particleFlow reco works a bit differently. The step is
# twofold, first particleFlowTmp is created and then the final particleFlow
# collection. What we do in this case is that we merge the final ParticleFlow
# collection. For the muon reconstruction, we also merge particleFlowTmp in
# order to get PF-based isolation right.
if hasattr(process, 'particleFlowTmp'):
process.particleFlowTmpMixed = cms.EDProducer(
'PFCandidateMixer',
col1=cms.untracked.InputTag("dimuonsGlobal", "pfCands"),
col2=cms.untracked.InputTag("particleFlowTmp", ""),
trackCol=cms.untracked.InputTag("tmfTracks"),
# Don't produce value maps:
muons=cms.untracked.InputTag(""),
gsfElectrons=cms.untracked.InputTag(""))
process.muons.PFCandidates = cms.InputTag("particleFlowTmpMixed")
for p in process.paths:
pth = getattr(process, p)
if "particleFlow" in pth.moduleNames():
pth.replace(process.particleFlow,
process.particleFlowORG * process.particleFlow)
if "muons" in pth.moduleNames():
pth.replace(process.muons,
process.particleFlowTmpMixed * process.muons)
else:
# CMSSW_4_2
if hasattr(process, "famosParticleFlowSequence"):
process.famosParticleFlowSequence.remove(
process.pfPhotonTranslatorSequence)
process.famosParticleFlowSequence.remove(
process.pfElectronTranslatorSequence)
process.famosParticleFlowSequence.remove(process.particleFlow)
process.famosParticleFlowSequence.__iadd__(process.particleFlowORG)
process.famosParticleFlowSequence.__iadd__(process.particleFlow)
process.famosParticleFlowSequence.__iadd__(
process.pfElectronTranslatorSequence)
process.famosParticleFlowSequence.__iadd__(
process.pfPhotonTranslatorSequence)
elif hasattr(process, "particleFlowReco"):
process.particleFlowReco.remove(process.pfPhotonTranslatorSequence)
process.particleFlowReco.remove(
process.pfElectronTranslatorSequence)
process.particleFlowReco.remove(process.particleFlow)
process.particleFlowReco.__iadd__(process.particleFlowORG)
process.particleFlowReco.__iadd__(process.particleFlow)
process.particleFlowReco.__iadd__(
process.pfElectronTranslatorSequence)
process.particleFlowReco.__iadd__(
process.pfPhotonTranslatorSequence)
else:
raise "Cannot find pflow sequence"
process.pfSelectedElectrons.src = cms.InputTag("particleFlowORG")
process.pfSelectedPhotons.src = cms.InputTag("particleFlowORG")
process.particleFlow = cms.EDProducer(
'PFCandidateMixer',
col1=cms.untracked.InputTag("dimuonsGlobal", "pfCands"),
col2=cms.untracked.InputTag("particleFlowORG", ""),
trackCol=cms.untracked.InputTag("tmfTracks"),
muons=cms.untracked.InputTag("muons"),
gsfElectrons=cms.untracked.InputTag(
"gsfElectrons", "", recoProcessName) # FIXME does this work?
#gsfElectrons = cms.untracked.InputTag("")
)
# Set the empty event filter source
process.filterEmptyEv.src.setProcessName(processName)
# Find all modules having particleFlow as their input
pfInputNeeded = {}
for p in process.paths:
i = getattr(process, p)
target = process.particleFlow
lookForPFInput = ["particleFlow"]
seqVis = SeqVisitor(target)
seqVis.prepareSearch()
seqVis.setLookFor(target)
i.visit(seqVis)
while seqVis.catch != 1 and seqVis.found == 1:
target = seqVis.giveNext()
pfInput = []
targetAttributes = dir(target)
for targetAttribute in targetAttributes:
attr = getattr(target, targetAttribute
) # get actual attribute, not just the name
if isinstance(attr, cms.InputTag):
if attr.getModuleLabel(
) == "particleFlow" and attr.getProductInstanceLabel(
) != "":
print "Changing: ", target, " ", targetAttribute, " ", attr, " to particleFlowORG"
attr.setModuleLabel("particleFlowORG")
if attr.getModuleLabel() in lookForPFInput:
pfInput.append(attr)
if len(pfInput) > 0:
lookForPFInput.append(target.label())
pfInputNeeded[target.label()] = pfInput
#i.replace(target, source)
seqVis.prepareSearch()
seqVis.setLookFor(target)
i.visit(seqVis)
#if (seqVis.catch==1):
#seqVis.catch=0
#i.__iadd__(source)
pfOutputCommands = []
for label in pfInputNeeded.keys():
print "particleFlow as input in module %s, InputTags: %s" % (
label, ", ".join(str(x) for x in pfInputNeeded[label]))
pfOutputCommands.append("keep *_%s_*_%s" % (label, processName))
outputModule.outputCommands.extend(pfOutputCommands)
#process.pfSelectedElectrons.src = "particleFlowORG" # 4_2 legacy, already included above
#process.pfSelectedPhotons.src = "particleFlowORG" # 4_2 legacy, already included above
# Setup/remove some HLT/DQM stuff whcih doesn't work
if hasattr(process, "hltTrigReport"):
process.hltTrigReport.HLTriggerResults.setProcessName(processName)
if hasattr(process, "DQM_FEDIntegrity_v2"):
process.schedule.remove(process.DQM_FEDIntegrity_v2)
if hasattr(process, "DQM_FEDIntegrity_v3"):
process.schedule.remove(process.DQM_FEDIntegrity_v3)
if hasattr(process, "DQM_FEDIntegrity_v5"):
process.schedule.remove(process.DQM_FEDIntegrity_v5)
if hasattr(process, "HLTAnalyzerEndpath"):
process.schedule.remove(process.HLTAnalyzerEndpath)
del process.HLTAnalyzerEndpath
#process.load("HiggsAnalysis.HeavyChHiggsToTauNu.tauEmbedding.printGenParticles_cff")
#process.generation_step *= process.printGenParticles
print "#############################################################"
print " Warning! PFCandidates 'electron' collection is not mixed, "
print " and probably shouldnt be used. "
print "#############################################################"
addPAT(process, options, dataVersion)
f = open("configDumpEmbed.py", "w")
f.write(process.dumpPython())
f.close()
return process
# job, their INFO messages are printed too)
# process.MessageLogger.cerr.threshold = cms.untracked.string("INFO")
# Fragment to run PAT on the fly if requested from command line
from HiggsAnalysis.HeavyChHiggsToTauNu.HChPatTuple import addPatOnTheFly
process.commonSequence, additionalCounters = addPatOnTheFly(process, options, dataVersion)
# Re-run trigger matching
if doRerunTriggerMatching:
import HiggsAnalysis.HeavyChHiggsToTauNu.HChTriggerMatching as TriggerMatching
process.triggerMatching = TriggerMatching.addTauTriggerMatching(
process,
options.trigger,
"Tau",
# pathFilterMap={} # by default, use filter name in trigger matching re-running
)
process.commonSequence *= process.triggerMatching
# Add configuration information to histograms.root
from HiggsAnalysis.HeavyChHiggsToTauNu.HChTools import addConfigInfo
process.infoPath = addConfigInfo(process, options, dataVersion)
# MC Filter
import HiggsAnalysis.HeavyChHiggsToTauNu.tauEmbedding.customisations as tauEmbeddingCustomisations
if filterGenTaus:
additionalCounters.extend(
def customise(process):
# Catch the case when this config is run from cmsDriver, it won't work due to VarParsing
# First protect against crab job creation, then the no-argument case
if hasattr(sys, "argv") and len(sys.argv) > 0:
if "cmsDriver" in sys.argv[0]:
print "Running pf_customise from cmsDriver, not executing running() further due to VarParsing"
return
else:
print "Running pf_customise"
# Command line arguments
import FWCore.ParameterSet.VarParsing as VarParsing
options = VarParsing.VarParsing ('analysis')
options.register ('overrideBeamSpot',
0, # default value, false
VarParsing.VarParsing.multiplicity.singleton,
VarParsing.VarParsing.varType.int,
"should I override beamspot in globaltag?")
options.register("tauDecayMode", 0, # Default is all decays
VarParsing.VarParsing.multiplicity.singleton, VarParsing.VarParsing.varType.int,
"Tau decay mode (0=all, 230=hadronic)")
options.register("tauMinVisPt", -1, # Disabled
VarParsing.VarParsing.multiplicity.singleton, VarParsing.VarParsing.varType.int,
"Minimum visible pt of tau decay (-1 disabled, >= 0 cut value in GeV)")
options, dataVersion = getOptionsDataVersion("53XmcS10", options)
hltProcessName = dataVersion.getTriggerProcess()
recoProcessName = dataVersion.getRecoProcess()
processName = process.name_()
# Setup trigger matching
if not (dataVersion.isMC() and options.triggerMC == 0 and options.triggerMCInAnalysis == 0):
HChTriggerMatching.setMuonTriggerMatchingInAnalysis(process.tightenedMuonsMatched, options.trigger)
# Setup MuScleFit
if dataVersion.isMC():
process.muscleCorrectedMuons.identifier = "Summer12_DR53X_smearReReco"
process.muscleCorrectedMuons.applySmearing = True
else:
process.muscleCorrectedMuons.identifier = "Data2012_53X_ReReco"
# Setup output
outputModule = None
outdict = process.outputModules_()
if len(outdict) == 1:
outputModule = outdict.values()[0]
elif outdict.has_key("RECOSIMoutput"):
outputModule = outdict["RECOSIMoutput"]
print "Adjusting event content to GEN-SIM-RECO+misc"
process.load("HiggsAnalysis.HeavyChHiggsToTauNu.tauEmbedding.HChEventContent_cff")
#outputModule.outputCommands = cms.untracked.vstring("keep *")
outputModule.outputCommands = cms.untracked.vstring("drop *")
outputModule.outputCommands.extend(process.RECOSIMEventContent.outputCommands)
outputModule.outputCommands.extend([
"drop *_*_*_%s" % recoProcessName,
"keep *_generalTracks_*_%s" % recoProcessName,
"keep *_muons_*_%s" % recoProcessName,
"keep *_globalMuons_*_%s" % recoProcessName,
"keep recoGsfElectronCores_*_*_%s" % recoProcessName,
"keep *_gsfElectrons_*_%s" % recoProcessName,
"keep *_photons_*_%s" % recoProcessName,
"keep *_photonCore_*_%s" % recoProcessName,
"drop *_*_*_%s" % processName,
"keep *_particleFlow*_*_%s" % processName,
"keep *_generalTracks_*_%s" % processName,
"keep *_muons_*_%s" % processName,
"keep *_globalMuons_*_%s" % processName,
"keep *_*Electron*_*_%s" % processName,
"keep *_eid*_*_*",
])
outputModule.outputCommands.extend(eventContent(hltProcessName, recoProcessName, processName))
# re_procName = re.compile("_\*$")
# outputModule.outputCommands.extend([re_procName.sub("_"+processName, x) for x in process.RECOSIMEventContent.outputCommands])
outputModule.outputCommands.extend(process.HChEventContent.outputCommands)
#outputModule.outputCommands.extend(process.RecoParticleFlowRECO.outputCommands)
#outputModule.outputCommands.extend(["keep *_%s_*_%s" % (x, processName) for x in [
#]])
# Remove duplicate "drop *"
index = 0
for item in outputModule.outputCommands[:]:
if item == "drop *" and index > 0:
del outputModule.outputCommands[index]
index -= 1
index += 1
# Disable gen vertex smearing
process.VtxSmeared = cms.EDProducer("FlatEvtVtxGenerator",
MaxZ = cms.double(0.0),
MaxX = cms.double(0.0),
MaxY = cms.double(0.0),
MinX = cms.double(0.0),
MinY = cms.double(0.0),
MinZ = cms.double(0.0),
TimeOffset = cms.double(0.0),
src = cms.InputTag("generator")
)
# Set up tau decay options
process.generator.ZTauTau.TauolaOptions.InputCards.mdtau = options.tauDecayMode
if options.tauMinVisPt >= 0:
process.generator.ZTauTau.minVisibleTransverseMomentum = "%d"%options.tauMinVisPt
print "TAUOLA mdtau =", process.generator.ZTauTau.TauolaOptions.InputCards.mdtau
# Do we have to override the beam spot for data?
if options.overrideBeamSpot != 0:
bs = cms.string("BeamSpotObjects_2009_LumiBased_SigmaZ_v25_offline") # 44x data gt
#bs = cms.string("BeamSpotObjects_2009_LumiBased_SigmaZ_v21_offline") # 42x data gt
process.GlobalTag.toGet = cms.VPSet(
cms.PSet(record = cms.string("BeamSpotObjectsRcd"),
tag = bs,
connect = cms.untracked.string("frontier://FrontierProd/CMS_COND_31X_BEAMSPOT")
)
)
print "BeamSpot in globaltag set to ", bs
else:
print "BeamSpot in globaltag not changed"
# Merge tracks
process.tmfTracks = cms.EDProducer("RecoTracksMixer",
trackCol1 = cms.InputTag("dimuonsGlobal", "tracks"),
trackCol2 = cms.InputTag("generalTracks", "", processName)
)
process.offlinePrimaryVerticesWithBS.TrackLabel = cms.InputTag("tmfTracks")
process.offlinePrimaryVertices.TrackLabel = cms.InputTag("tmfTracks")
#print process.muons
if hasattr(process.muons, "TrackExtractorPSet"):
# <= 42X
process.muons.TrackExtractorPSet.inputTrackCollection = cms.InputTag("tmfTracks")
elif hasattr(process, "muons1stStep") and hasattr(process.muons1stStep, "TrackExtractorPSet"):
# >= 44X
process.muons1stStep.TrackExtractorPSet.inputTrackCollection = cms.InputTag("tmfTracks")
else:
raise Exception("Problem in overriding track collection for reco::Muon producer")
# Ensure that tmfTracks is always run after generalTracks (to mix the original and embedded tracks)
for p in process.paths:
pth = getattr(process, p)
if "generalTracks" in pth.moduleNames():
pth.replace(process.generalTracks, process.generalTracks*process.tmfTracks)
# it should be the best solution to take the original beam spot for the
# reconstruction of the new primary vertex
# use the one produced earlier, do not produce your own
for s in process.sequences:
seq = getattr(process,s)
seq.remove(process.offlineBeamSpot)
# Remove beam halo Id
try:
process.metreco.remove(process.BeamHaloId)
except:
pass
# Disable lumi producer
process.localreco_HcalNZS.remove(process.lumiProducer)
process.localreco.remove(process.lumiProducer)
# PFCandidate embedding
process.particleFlowORG = process.particleFlow.clone()
# Since CMSSW 4_4 the particleFlow reco works a bit differently. The step is
# twofold, first particleFlowTmp is created and then the final particleFlow
# collection. What we do in this case is that we merge the final ParticleFlow
# collection. For the muon reconstruction, we also merge particleFlowTmp in
# order to get PF-based isolation right.
if hasattr(process, 'particleFlowTmp'):
process.particleFlowTmpMixed = cms.EDProducer('PFCandidateMixer',
col1 = cms.untracked.InputTag("dimuonsGlobal", "pfCands"),
col2 = cms.untracked.InputTag("particleFlowTmp", ""),
trackCol = cms.untracked.InputTag("tmfTracks"),
# Don't produce value maps:
muons = cms.untracked.InputTag(""),
gsfElectrons = cms.untracked.InputTag("")
)
process.muons.PFCandidates = cms.InputTag("particleFlowTmpMixed")
for p in process.paths:
pth = getattr(process, p)
if "particleFlow" in pth.moduleNames():
pth.replace(process.particleFlow, process.particleFlowORG*process.particleFlow)
if "muons" in pth.moduleNames():
pth.replace(process.muons, process.particleFlowTmpMixed*process.muons)
else:
# CMSSW_4_2
if hasattr(process,"famosParticleFlowSequence"):
process.famosParticleFlowSequence.remove(process.pfPhotonTranslatorSequence)
process.famosParticleFlowSequence.remove(process.pfElectronTranslatorSequence)
process.famosParticleFlowSequence.remove(process.particleFlow)
process.famosParticleFlowSequence.__iadd__(process.particleFlowORG)
process.famosParticleFlowSequence.__iadd__(process.particleFlow)
process.famosParticleFlowSequence.__iadd__(process.pfElectronTranslatorSequence)
process.famosParticleFlowSequence.__iadd__(process.pfPhotonTranslatorSequence)
elif hasattr(process,"particleFlowReco"):
process.particleFlowReco.remove(process.pfPhotonTranslatorSequence)
process.particleFlowReco.remove(process.pfElectronTranslatorSequence)
process.particleFlowReco.remove(process.particleFlow)
process.particleFlowReco.__iadd__(process.particleFlowORG)
process.particleFlowReco.__iadd__(process.particleFlow)
process.particleFlowReco.__iadd__(process.pfElectronTranslatorSequence)
process.particleFlowReco.__iadd__(process.pfPhotonTranslatorSequence)
else:
raise "Cannot find pflow sequence"
process.pfSelectedElectrons.src = cms.InputTag("particleFlowORG")
process.pfSelectedPhotons.src = cms.InputTag("particleFlowORG")
process.particleFlow = cms.EDProducer('PFCandidateMixer',
col1 = cms.untracked.InputTag("dimuonsGlobal", "pfCands"),
col2 = cms.untracked.InputTag("particleFlowORG", ""),
trackCol = cms.untracked.InputTag("tmfTracks"),
muons = cms.untracked.InputTag("muons"),
gsfElectrons = cms.untracked.InputTag("gsfElectrons","",recoProcessName) # FIXME does this work?
#gsfElectrons = cms.untracked.InputTag("")
)
# Set the empty event filter source
process.filterEmptyEv.src.setProcessName(processName)
# Find all modules having particleFlow as their input
pfInputNeeded = {}
for p in process.paths:
i = getattr(process,p)
target = process.particleFlow
lookForPFInput = ["particleFlow"]
seqVis = SeqVisitor(target)
seqVis.prepareSearch()
seqVis.setLookFor(target)
i.visit(seqVis)
while seqVis.catch != 1 and seqVis.found == 1:
target = seqVis.giveNext()
pfInput = []
targetAttributes = dir(target)
for targetAttribute in targetAttributes:
attr=getattr(target,targetAttribute) # get actual attribute, not just the name
if isinstance(attr, cms.InputTag):
if attr.getModuleLabel()=="particleFlow" and attr.getProductInstanceLabel()!="":
print "Changing: ", target, " ", targetAttribute, " ", attr, " to particleFlowORG"
attr.setModuleLabel("particleFlowORG")
if attr.getModuleLabel() in lookForPFInput:
pfInput.append(attr)
if len(pfInput) > 0:
lookForPFInput.append(target.label())
pfInputNeeded[target.label()] = pfInput
#i.replace(target, source)
seqVis.prepareSearch()
seqVis.setLookFor(target)
i.visit(seqVis)
#if (seqVis.catch==1):
#seqVis.catch=0
#i.__iadd__(source)
pfOutputCommands = []
for label in pfInputNeeded.keys():
print "particleFlow as input in module %s, InputTags: %s" % (label, ", ".join(str(x) for x in pfInputNeeded[label]))
pfOutputCommands.append("keep *_%s_*_%s" % (label, processName))
outputModule.outputCommands.extend(pfOutputCommands)
#process.pfSelectedElectrons.src = "particleFlowORG" # 4_2 legacy, already included above
#process.pfSelectedPhotons.src = "particleFlowORG" # 4_2 legacy, already included above
# Setup/remove some HLT/DQM stuff whcih doesn't work
if hasattr(process, "hltTrigReport"):
process.hltTrigReport.HLTriggerResults.setProcessName(processName)
if hasattr(process, "DQM_FEDIntegrity_v2"):
process.schedule.remove(process.DQM_FEDIntegrity_v2)
if hasattr(process, "DQM_FEDIntegrity_v3"):
process.schedule.remove(process.DQM_FEDIntegrity_v3)
if hasattr(process, "DQM_FEDIntegrity_v5"):
process.schedule.remove(process.DQM_FEDIntegrity_v5)
if hasattr(process, "HLTAnalyzerEndpath"):
process.schedule.remove(process.HLTAnalyzerEndpath)
del process.HLTAnalyzerEndpath
#process.load("HiggsAnalysis.HeavyChHiggsToTauNu.tauEmbedding.printGenParticles_cff")
#process.generation_step *= process.printGenParticles
print "#############################################################"
print " Warning! PFCandidates 'electron' collection is not mixed, "
print " and probably shouldnt be used. "
print "#############################################################"
addPAT(process, options, dataVersion)
f = open("configDumpEmbed.py", "w")
f.write(process.dumpPython())
f.close()
return process