def addMuonJetSelection(process, sequence, prefix="muonSelectionJetSelection"):
selector = prefix+"GoodJets"
filter = prefix+"Filter"
counter = prefix
import muonSelectionPF_cff as muonSelection
from PhysicsTools.PatAlgos.cleaningLayer1.jetCleaner_cfi import cleanPatJets
m1 = cleanPatJets.clone(
# src = "selectedPatJets",
src = "goodJets", # we should use the pat::Jets constructed in the
preselection = cms.string(jetSelection),
checkOverlaps = cms.PSet(
muons = cms.PSet(
src = cms.InputTag(tauEmbeddingMuons),
algorithm = cms.string("byDeltaR"),
preselection = cms.string(""),
deltaR = cms.double(0.1),
checkRecoComponents = cms.bool(False),
pairCut = cms.string(""),
requireNoOverlaps = cms.bool(True),
)
)
)
m2 = muonSelection.goodJetFilter.clone(src=selector, minNumber=3)
m3 = cms.EDProducer("EventCountProducer")
setattr(process, selector, m1)
setattr(process, filter, m2)
setattr(process, counter, m3)
sequence *= (m1 * m2 * m3)
return [counter]
def __init__(self,
process,
prefix="",
beginSequence=None,
afterOtherCuts=False,
muonPtCut=30,
muonIsolationCut=0.05,
metCut=20,
njets=3,
jets=jets,
doJetId=False):
self.process = process
self.prefix = prefix
self.afterOtherCuts = afterOtherCuts
self.doJetId = doJetId
self._ptCut = ptCutString % muonPtCut
self._metCut = metCutString % metCut
self._njets = njets
self._jets = jets
self._isolationCut = "%s < %f" % (relIso, muonIsolationCut)
counters = []
if dataVersion.isData():
counters = dataSelectionCounters
self.analysis = Analysis(self.process,
"analysis",
options,
prefix,
additionalCounters=counters)
#self.analysis.getCountAnalyzer().printMainCounter = cms.untracked.bool(True)
#self.analysis.getCountAnalyzer().printSubCounters = cms.untracked.bool(True)
#self.analysis.getCountAnalyzer().printAvailableCounters = cms.untracked.bool(True)
if beginSequence != None:
self.analysis.appendToSequence(beginSequence)
self.multipName = "Multiplicity"
self.pileupName = "VertexCount"
self.selectedMuons = muons
self.selectedJets = self._jets
# Setup the analyzers
if not self.afterOtherCuts:
self.histoAnalyzer = self.analysis.addMultiHistoAnalyzer(
"AllMuons", [("muon_", muons, histosBeginning),
("calomet_", cms.InputTag(caloMET), [histoMet]),
("pfmet_", cms.InputTag(pfMET), [histoMet]),
("tcmet_", cms.InputTag(tcMET), [histoMet])])
self.multipAnalyzer = self.analysis.addAnalyzer(
self.multipName,
cms.EDAnalyzer(
"HPlusCandViewMultiplicityAnalyzer",
allMuons=cms.untracked.PSet(src=muons,
min=cms.untracked.int32(0),
max=cms.untracked.int32(10),
nbins=cms.untracked.int32(10)),
selMuons=cms.untracked.PSet(src=muons,
min=cms.untracked.int32(0),
max=cms.untracked.int32(10),
nbins=cms.untracked.int32(10)),
jets=cms.untracked.PSet(src=self._jets,
min=cms.untracked.int32(0),
max=cms.untracked.int32(20),
nbins=cms.untracked.int32(20))))
self.pileupAnalyzer = None
if beginSequence == None:
self.pileupAnalyzer = self.analysis.addAnalyzer(
self.pileupName,
cms.EDAnalyzer(
"HPlusVertexCountAnalyzer",
src=cms.untracked.VInputTag([
cms.untracked.InputTag(x)
for x in vertexCollections
]),
min=cms.untracked.double(0),
max=cms.untracked.double(20),
nbins=cms.untracked.int32(20),
))
# Create the prototype for muon cleaner
from PhysicsTools.PatAlgos.cleaningLayer1.muonCleaner_cfi import cleanPatMuons
self.muonJetCleanerPrototype = cleanPatMuons.clone(
src=cms.InputTag("dummy"),
checkOverlaps=cms.PSet(
jets=cms.PSet(src=cms.InputTag("dummy"),
algorithm=cms.string("byDeltaR"),
preselection=cms.string(""),
deltaR=cms.double(0.3),
checkRecoComponents=cms.bool(False),
pairCut=cms.string(""),
requireNoOverlaps=cms.bool(True))))
# Create the prototype for jet cleaner
from PhysicsTools.PatAlgos.cleaningLayer1.jetCleaner_cfi import cleanPatJets
self.jetMuonCleanerPrototype = cleanPatJets.clone(
src=cms.InputTag("dummy"),
checkOverlaps=cms.PSet(
muons=cms.PSet(src=cms.InputTag("dummy"),
algorithm=cms.string("byDeltaR"),
preselection=cms.string(""),
deltaR=cms.double(0.1),
checkRecoComponents=cms.bool(False),
pairCut=cms.string(""),
requireNoOverlaps=cms.bool(True))))
# Create the prototype for candidate combiner
self.candCombinerPrototype = cms.EDProducer(
"CandViewShallowCloneCombiner",
checkCharge=cms.bool(False),
cut=cms.string(""),
decay=cms.string("dummy"))
# Setup the afterOtherCuts prototypes
if self.afterOtherCuts:
self.afterOtherCutsModule = cms.EDAnalyzer(
"HPlusCandViewHistoAfterOtherCutsAnalyzer",
src=cms.InputTag("dummy"),
histograms=cms.VPSet(
histoPt.pset().clone(
cut=cms.untracked.string(self._ptCut)),
histoEta.pset().clone(cut=cms.untracked.string(etaCut)),
histoDB.pset().clone(cut=cms.untracked.string(dbCut)),
))
self.afterOtherCutsModuleIso = self.afterOtherCutsModule.clone()
self.afterOtherCutsModuleIso.histograms.append(
histoIso.pset().clone(
cut=cms.untracked.string(self._isolationCut)))
cut='userInt("isGoodNonIso")',
)
process.goodJets = cleanPatJets.clone(
src=cms.InputTag("jetUserData"),
preselection='userInt("passesPt") && userInt("isGood")',
checkOverlaps=cms.PSet(
electrons=cms.PSet(
src=cms.InputTag("goodElectrons"),
algorithm=cms.string("byDeltaR"),
preselection=cms.string(""),
deltaR=cms.double(cleaningDeltaR),
# don't check if they share some AOD object ref
checkRecoComponents=cms.bool(False),
pairCut=cms.string(""),
requireNoOverlaps=cms.bool(True),
),
muons=cms.PSet(
src=cms.InputTag("goodMuons"),
algorithm=cms.string("byDeltaR"),
preselection=cms.string(""),
deltaR=cms.double(cleaningDeltaR),
# don't check if they share some AOD object ref
checkRecoComponents=cms.bool(False),
pairCut=cms.string(""),
requireNoOverlaps=cms.bool(True),
),
)
)
process.goodJetsEConversionRegion = process.goodJets.clone()
process.goodJetsEConversionRegion.checkOverlaps.electrons.src = 'goodConversionElectrons'
def addEmbeddingLikePreselection(process, sequence, param, prefix="embeddingLikePreselection", disableTrigger=True):
counters = []
# Create PU weight producer for the counters
pileupWeight = cms.EDProducer("HPlusVertexWeightProducer",
alias = cms.string("pileupWeight"),
)
HChTools.insertPSetContentsTo(param.vertexWeight.clone(), pileupWeight)
setattr(process, prefix+"PileupWeight", pileupWeight)
counterPrototype = cms.EDProducer("HPlusEventCountProducer",
weightSrc = cms.InputTag(prefix+"PileupWeight")
)
# Disable trigger
if disableTrigger:
param.trigger.selectionType = "disabled"
param.triggerEfficiencyScaleFactor.mode = "disabled"
allCount = counterPrototype.clone()
setattr(process, prefix+"AllCount", allCount)
counters.append(prefix+"AllCount")
# Primary vertex
pvFilter = cms.EDFilter("VertexCountFilter",
src = cms.InputTag("selectedPrimaryVertex"),
minNumber = cms.uint32(1),
maxNumber = cms.uint32(999)
)
pvFilterCount = counterPrototype.clone()
setattr(process, prefix+"PrimaryVertex", pvFilter)
setattr(process, prefix+"PrimaryVertexCount", pvFilterCount)
counters.append(prefix+"PrimaryVertexCount")
# Generator taus (if you modify this, remember to modify similar in above)
genTaus = cms.EDFilter("GenParticleSelector",
src = cms.InputTag("genParticles"),
cut = cms.string("abs(pdgId()) == 15 && pt() > 40 && abs(eta()) < 2.1")
)
genTausName = prefix+"GenTau"
setattr(process, genTausName, genTaus)
genTausFilter = cms.EDFilter("CandViewCountFilter",
src = cms.InputTag(genTausName),
minNumber = cms.uint32(1),
)
setattr(process, prefix+"GenTauFilter", genTausFilter)
genTausCount = counterPrototype.clone()
setattr(process, prefix+"GenTauCount", genTausCount)
counters.append(prefix+"GenTauCount")
# Select first generator tau for the jet cleaning and tau selection
genTauFirst = cms.EDProducer("HPlusFirstCandidateSelector",
src = cms.InputTag(genTausName)
)
genTauFirstName = prefix+"First"
setattr(process, genTauFirstName, genTauFirst)
# Tau selection
genTauReco = cms.EDProducer("HPlusPATTauCandViewDeltaRSelector",
src = cms.InputTag("selectedPatTausHpsPFTau"), # not trigger matched
refSrc = cms.InputTag(genTauFirstName),
deltaR = cms.double(0.5),
)
if not disableTrigger:
genTauReco.src = param.tauSelection.src.value()
genTauRecoName = prefix+"Reco"
setattr(process, genTauRecoName, genTauReco)
param.tauSelection.src = genTauRecoName
genTauCleanPSet = cms.PSet(
src = cms.InputTag(genTauFirstName),
algorithm = cms.string("byDeltaR"),
preselection = cms.string(""),
deltaR = cms.double(0.5),
checkRecoComponents = cms.bool(False),
pairCut = cms.string(""),
requireNoOverlaps = cms.bool(True),
)
# Clean the selected generator tau from the electrons and muons
# for the e/mu veto. We don't want to reject events where the e/mu
# comes from the tau decay.
from PhysicsTools.PatAlgos.cleaningLayer1.electronCleaner_cfi import cleanPatElectrons
from PhysicsTools.PatAlgos.cleaningLayer1.muonCleaner_cfi import cleanPatMuons
cleanedElectrons = cleanPatElectrons.clone(
src = cms.InputTag(param.GlobalElectronVeto.ElectronCollectionName.value()),
checkOverlaps = cms.PSet(
genTaus = genTauCleanPSet.clone()
)
)
cleanedElectronsName = prefix+"CleanedElectrons"
param.GlobalElectronVeto.ElectronCollectionName = cleanedElectronsName
setattr(process, cleanedElectronsName, cleanedElectrons)
cleanedMuons = cleanPatMuons.clone(
src = cms.InputTag(param.GlobalMuonVeto.MuonCollectionName.value()),
checkOverlaps = cms.PSet(
genTaus = genTauCleanPSet.clone()
)
)
cleanedMuonsName = prefix+"CleanedMuons"
param.GlobalMuonVeto.MuonCollectionName = cleanedMuonsName
setattr(process, cleanedMuonsName, cleanedMuons)
# Electron and muon veto
eveto = ElectronVeto.hPlusGlobalElectronVetoFilter.clone()
evetoCount = counterPrototype.clone()
muveto = MuonVeto.hPlusGlobalMuonVetoFilter.clone()
muvetoCount = counterPrototype.clone()
setattr(process, prefix+"ElectronVeto", eveto)
setattr(process, prefix+"ElectronVetoCount", evetoCount)
setattr(process, prefix+"MuonVeto", muveto)
setattr(process, prefix+"MuonVetoCount", muvetoCount)
counters.extend([prefix+"ElectronVetoCount", prefix+"MuonVetoCount"])
# 3 jets
from PhysicsTools.PatAlgos.cleaningLayer1.jetCleaner_cfi import cleanPatJets
cleanedJets = cleanPatJets.clone(
src = cms.InputTag(param.jetSelection.src.value()),
preselection = cms.string(jetSelection),
checkOverlaps = cms.PSet(
genTaus = genTauCleanPSet.clone()
)
)
cleanedJetsName = prefix+"CleanedJets"
setattr(process, cleanedJetsName, cleanedJets)
cleanedJetsFilter = cms.EDFilter("CandViewCountFilter",
src = cms.InputTag(cleanedJetsName),
minNumber = cms.uint32(3)
)
setattr(process, cleanedJetsName+"Filter", cleanedJetsFilter)
cleanedJetsCount = counterPrototype.clone()
setattr(process, cleanedJetsName+"Count", cleanedJetsCount)
counters.append(cleanedJetsName+"Count")
genTauSequence = cms.Sequence(
pileupWeight *
allCount *
pvFilter * pvFilterCount *
genTaus * genTausFilter * genTausCount * genTauFirst * genTauReco *
cleanedElectrons * cleanedMuons *
eveto * evetoCount *
muveto * muvetoCount *
cleanedJets * cleanedJetsFilter * cleanedJetsCount
)
setattr(process, prefix+"Sequence", genTauSequence)
sequence *= genTauSequence
return counters
def __init__(self, process, prefix="", beginSequence=None, afterOtherCuts=False,
muonPtCut=30, muonIsolationCut=0.05, metCut=20, njets=3, jets=jets, doJetId=False):
self.process = process
self.prefix = prefix
self.afterOtherCuts = afterOtherCuts
self.doJetId = doJetId
self._ptCut = ptCutString % muonPtCut
self._metCut = metCutString % metCut
self._njets = njets
self._jets = jets
self._isolationCut = "%s < %f" % (relIso, muonIsolationCut)
counters = []
if dataVersion.isData():
counters = dataSelectionCounters
self.analysis = Analysis(self.process, "analysis", options, prefix, additionalCounters=counters)
#self.analysis.getCountAnalyzer().printMainCounter = cms.untracked.bool(True)
#self.analysis.getCountAnalyzer().printSubCounters = cms.untracked.bool(True)
#self.analysis.getCountAnalyzer().printAvailableCounters = cms.untracked.bool(True)
if beginSequence != None:
self.analysis.appendToSequence(beginSequence)
self.multipName = "Multiplicity"
self.pileupName = "VertexCount"
self.selectedMuons = muons
self.selectedJets = self._jets
# Setup the analyzers
if not self.afterOtherCuts:
self.histoAnalyzer = self.analysis.addMultiHistoAnalyzer("AllMuons", [
("muon_", muons, histosBeginning),
("calomet_", cms.InputTag(caloMET), [histoMet]),
("pfmet_", cms.InputTag(pfMET), [histoMet]),
("tcmet_", cms.InputTag(tcMET), [histoMet])])
self.multipAnalyzer = self.analysis.addAnalyzer(self.multipName, cms.EDAnalyzer("HPlusCandViewMultiplicityAnalyzer",
allMuons = cms.untracked.PSet(
src = muons,
min = cms.untracked.int32(0),
max = cms.untracked.int32(10),
nbins = cms.untracked.int32(10)
),
selMuons = cms.untracked.PSet(
src = muons,
min = cms.untracked.int32(0),
max = cms.untracked.int32(10),
nbins = cms.untracked.int32(10)
),
jets = cms.untracked.PSet(
src = self._jets,
min = cms.untracked.int32(0),
max = cms.untracked.int32(20),
nbins = cms.untracked.int32(20)
)
))
self.pileupAnalyzer = None
if beginSequence == None:
self.pileupAnalyzer = self.analysis.addAnalyzer(self.pileupName, cms.EDAnalyzer("HPlusVertexCountAnalyzer",
src = cms.untracked.VInputTag([cms.untracked.InputTag(x) for x in vertexCollections]),
min = cms.untracked.double(0),
max = cms.untracked.double(20),
nbins = cms.untracked.int32(20),
))
# Create the prototype for muon cleaner
from PhysicsTools.PatAlgos.cleaningLayer1.muonCleaner_cfi import cleanPatMuons
self.muonJetCleanerPrototype = cleanPatMuons.clone(
src = cms.InputTag("dummy"),
checkOverlaps = cms.PSet(
jets = cms.PSet(
src = cms.InputTag("dummy"),
algorithm = cms.string("byDeltaR"),
preselection = cms.string(""),
deltaR = cms.double(0.3),
checkRecoComponents = cms.bool(False),
pairCut = cms.string(""),
requireNoOverlaps = cms.bool(True)
)
)
)
# Create the prototype for jet cleaner
from PhysicsTools.PatAlgos.cleaningLayer1.jetCleaner_cfi import cleanPatJets
self.jetMuonCleanerPrototype = cleanPatJets.clone(
src = cms.InputTag("dummy"),
checkOverlaps = cms.PSet(
muons = cms.PSet(
src = cms.InputTag("dummy"),
algorithm = cms.string("byDeltaR"),
preselection = cms.string(""),
deltaR = cms.double(0.1),
checkRecoComponents = cms.bool(False),
pairCut = cms.string(""),
requireNoOverlaps = cms.bool(True)
)
)
)
# Create the prototype for candidate combiner
self.candCombinerPrototype = cms.EDProducer("CandViewShallowCloneCombiner",
checkCharge = cms.bool(False),
cut = cms.string(""),
decay = cms.string("dummy")
)
# Setup the afterOtherCuts prototypes
if self.afterOtherCuts:
self.afterOtherCutsModule = cms.EDAnalyzer("HPlusCandViewHistoAfterOtherCutsAnalyzer",
src = cms.InputTag("dummy"),
histograms = cms.VPSet(
histoPt.pset().clone(cut=cms.untracked.string(self._ptCut)),
histoEta.pset().clone(cut=cms.untracked.string(etaCut)),
histoDB.pset().clone(cut=cms.untracked.string(dbCut)),
)
)
self.afterOtherCutsModuleIso = self.afterOtherCutsModule.clone()
self.afterOtherCutsModuleIso.histograms.append(histoIso.pset().clone(cut=cms.untracked.string(self._isolationCut)))
def __init__(self, process, dataVersion, additionalCounters,
prefix="", beginSequence=None, afterOtherCuts=False,
trigger=None,
muons="selectedPatMuons", allMuons="selectedPatMuons", muonPtCut=30,
doIsolationWithTau=False, isolationWithTauDiscriminator="byTightIsolation",
doMuonIsolation=False, muonIsolation="sumIsoRel", muonIsolationCut=0.05,
electrons="selectedPatElectrons",
met="patMETsPF", metCut=20,
jets="selectedPatJetsAK5PF", njets=3,
vertexCollections=["offlinePrimaryVertices", "goodPrimaryVertices", "goodPrimaryVertices10"],
weightSrc=None):
self.process = process
self.dataVersion = dataVersion
self.prefix = prefix
self.afterOtherCuts = afterOtherCuts
self.doIsolationWithTau = doIsolationWithTau
self.doMuonIsolation = doMuonIsolation
self._trigger = trigger
self._muons = cms.InputTag(muons)
self._allMuons = cms.InputTag(allMuons)
self._ptCut = "pt() > %d" % muonPtCut
self._etaCut = "abs(eta()) < 2.1"
self._electrons = electrons
self._met = met
self._metCut = "et() > %d" % metCut
self._njets = njets
self._jets = cms.InputTag(jets)
self._muonIsolation = muonIsolation
self._isolationCut = "%s < %f" % (isolations[muonIsolation], muonIsolationCut)
self._isolationWithTauDiscriminator = isolationWithTauDiscriminator
if self._trigger == None:
raise Exception("Must specify trigger!")
self.analysis = HChTools.Analysis(self.process, "analysis", prefix, additionalCounters=additionalCounters, weightSrc=weightSrc)
#self.analysis.getCountAnalyzer().printMainCounter = cms.untracked.bool(True)
#self.analysis.getCountAnalyzer().printSubCounters = cms.untracked.bool(True)
#self.analysis.getCountAnalyzer().printAvailableCounters = cms.untracked.bool(True)
if beginSequence != None:
self.analysis.appendToSequence(beginSequence)
self.multipName = "Multiplicity"
self.pileupName = "VertexCount"
self.selectedMuons = cms.InputTag(muons)
self.selectedJets = self._jets
# Setup the analyzers
if not self.afterOtherCuts:
self.histoAnalyzer = self.analysis.addMultiHistoAnalyzer("AllMuons", [
("muon_", self.selectedMuons, histosBeginning),
("jet_", self.selectedJets, histosJet),
("met_", cms.InputTag(met), histosMet)])
self.multipAnalyzer = self.analysis.addAnalyzer(self.multipName, cms.EDAnalyzer("HPlusCandViewMultiplicityAnalyzer",
allMuons = cms.untracked.PSet(
src = self.selectedMuons,
min = cms.untracked.int32(0),
max = cms.untracked.int32(10),
nbins = cms.untracked.int32(10)
),
selMuons = cms.untracked.PSet(
src = self.selectedMuons,
min = cms.untracked.int32(0),
max = cms.untracked.int32(10),
nbins = cms.untracked.int32(10)
),
jets = cms.untracked.PSet(
src = self.selectedJets,
min = cms.untracked.int32(0),
max = cms.untracked.int32(20),
nbins = cms.untracked.int32(20)
),
))
if weightSrc != None:
self.histoAnalyzer.weights = cms.untracked.InputTag(weightSrc)
self.multipAnalyzer.weights = cms.untracked.InputTag(weightSrc)
self.pileupAnalyzer = None
if beginSequence == None:
self.pileupAnalyzer = self.analysis.addAnalyzer(self.pileupName, cms.EDAnalyzer("HPlusVertexCountAnalyzer",
src = cms.untracked.VInputTag([cms.untracked.InputTag(x) for x in vertexCollections]),
min = cms.untracked.double(0),
max = cms.untracked.double(20),
nbins = cms.untracked.int32(20),
))
if weightSrc != None:
self.pileupAnalyzer.weights = cms.untracked.InputTag(weightSrc)
# Create the prototype for muon cleaner
from PhysicsTools.PatAlgos.cleaningLayer1.muonCleaner_cfi import cleanPatMuons
self.muonJetCleanerPrototype = cleanPatMuons.clone(
src = cms.InputTag("dummy"),
checkOverlaps = cms.PSet(
jets = cms.PSet(
src = cms.InputTag("dummy"),
algorithm = cms.string("byDeltaR"),
preselection = cms.string(""),
deltaR = cms.double(0.3),
checkRecoComponents = cms.bool(False),
pairCut = cms.string(""),
requireNoOverlaps = cms.bool(True)
)
)
)
# Create the prototype for jet cleaner
from PhysicsTools.PatAlgos.cleaningLayer1.jetCleaner_cfi import cleanPatJets
self.jetMuonCleanerPrototype = cleanPatJets.clone(
src = cms.InputTag("dummy"),
checkOverlaps = cms.PSet(
muons = cms.PSet(
src = cms.InputTag("dummy"),
algorithm = cms.string("byDeltaR"),
preselection = cms.string(""),
deltaR = cms.double(0.1),
checkRecoComponents = cms.bool(False),
pairCut = cms.string(""),
requireNoOverlaps = cms.bool(True)
)
)
)
# Create the prototype for candidate combiner
self.candCombinerPrototype = cms.EDProducer("CandViewShallowCloneCombiner",
checkCharge = cms.bool(False),
cut = cms.string(""),
decay = cms.string("dummy")
)
# Setup the afterOtherCuts prototypes
if self.afterOtherCuts:
self.afterOtherCutsModule = cms.EDAnalyzer("HPlusCandViewHistoAfterOtherCutsAnalyzer",
src = cms.InputTag("dummy"),
histograms = cms.VPSet(
histoPt.pset().clone(cut=cms.untracked.string(self._ptCut)),
histoEta.pset().clone(cut=cms.untracked.string(self._etaCut)),
)
)
if weightSrc != None:
self.afterOtherCutsModule.weights = cms.untracked.InputTag(weightSrc)
self.afterOtherCutsModuleIso = self.afterOtherCutsModule.clone()
self.afterOtherCutsModuleIso.histograms.append(histoIsos[muonIsolation].pset().clone(
cut=cms.untracked.string(self._isolationCut)
))
process.goodNonIsoElectrons = process.goodElectrons.clone(
cut='userInt("isGoodNonIso")', )
process.goodJets = cleanPatJets.clone(
src=cms.InputTag("jetUserData"),
preselection='userInt("passesPt") && userInt("isGood")',
checkOverlaps=cms.PSet(
electrons=cms.PSet(
src=cms.InputTag("goodElectrons"),
algorithm=cms.string("byDeltaR"),
preselection=cms.string(""),
deltaR=cms.double(cleaningDeltaR),
# don't check if they share some AOD object ref
checkRecoComponents=cms.bool(False),
pairCut=cms.string(""),
requireNoOverlaps=cms.bool(True),
),
muons=cms.PSet(
src=cms.InputTag("goodMuons"),
algorithm=cms.string("byDeltaR"),
preselection=cms.string(""),
deltaR=cms.double(cleaningDeltaR),
# don't check if they share some AOD object ref
checkRecoComponents=cms.bool(False),
pairCut=cms.string(""),
requireNoOverlaps=cms.bool(True),
),
))
process.goodJetsEConversionRegion = process.goodJets.clone()
process.goodJetsEConversionRegion.checkOverlaps.electrons.src = 'goodConversionElectrons'
def makeMET(process, isData, pfCandidates, jetSource, jetFlavor, postfix=''):
"""
@jetFlavor: e.g. 'ak4PFchs'
Additional information (such as gen and calo mets) are added only if postfix is empty.
"""
sequence = cms.Sequence()
# postfix is automatically added to the module names
addattr = AddAttr(process, sequence, postfix)
if postfix == '':
# default MET - extract from input slimmedMETs
pfMet = addattr(
'pfMet',
cms.EDProducer("RecoMETExtractor",
metSource=cms.InputTag(
"slimmedMETs",
processName=cms.InputTag.skipCurrentProcess()),
correctionLevel=cms.string('raw')))
else:
pfMet = addattr(
'pfMet',
PFMET_cfi.pfMet.clone(
src=pfCandidates,
calculateSignificance=False # done in PAT
))
cleanedJets = addattr(
'cleanedJetsForMET',
cms.EDProducer(
"PATJetCleanerForType1MET",
src=cms.InputTag(jetSource),
jetCorrEtaMax=cms.double(9.9),
jetCorrLabel=cms.InputTag("L3Absolute"),
jetCorrLabelRes=cms.InputTag("L2L3Residual"),
offsetCorrLabel=cms.InputTag("L1FastJet"),
skipEM=cms.bool(True),
skipEMfractionThreshold=cms.double(0.9),
skipMuonSelection=cms.string('isGlobalMuon | isStandAloneMuon'),
skipMuons=cms.bool(True),
type1JetPtThreshold=cms.double(15.0)))
selectedJets = addattr(
'selectedJetsForMET',
selectedPatJets.clone(src=cleanedJets,
cut='pt > 15 && abs(eta) < 9.9'))
crossCleanedJets = addattr('crossCleanedJetsForMET',
cleanPatJets.clone(src=selectedJets))
ccJetsMod = addattr.last
ccJetsMod.checkOverlaps.muons.src = muons
ccJetsMod.checkOverlaps.electrons.src = electrons
del ccJetsMod.checkOverlaps.photons
del ccJetsMod.checkOverlaps.taus
# not used at all and electrons are already cleaned
del ccJetsMod.checkOverlaps.tkIsoElectrons
patPFMet = addattr(
'patPFMet',
patMET_cff.patPFMet.clone(
metSource=pfMet,
genMETSource='genMetTrue',
srcPFCands=pfCandidates,
computeMETSignificance=True,
parameters=(METSignificanceParams_Data
if isData else METSignificanceParams),
srcJets=crossCleanedJets,
srcLeptons=[electrons, muons, photons],
addGenMET=(not isData and postfix == '')))
patPFMetT1Corr = addattr(
'patPFMetT1Corr',
patMET_cff.patPFMetT1T2Corr.clone(src=crossCleanedJets))
patPFMetT1 = addattr(
'patPFMetT1',
patMET_cff.patPFMetT1.clone(src=patPFMet,
srcCorrections=[
cms.InputTag(
patPFMetT1Corr.getModuleLabel(),
'type1')
]))
pfCandsNoEle = addattr(
'pfCandsNoEle',
cms.EDProducer("CandPtrProjector",
src=cms.InputTag(pfCandidates),
veto=electrons))
pfCandsNoEleMu = addattr(
'pfCandsNoEleMu',
cms.EDProducer("CandPtrProjector", src=pfCandsNoEle, veto=muons))
pfCandsNoEleMuTau = addattr(
'pfCandsNoEleMuTau',
cms.EDProducer("CandPtrProjector", src=pfCandsNoEleMu, veto=taus))
pfCandsNoEleMuTauGamma = addattr(
'pfCandsNoEleMuTauGamma',
cms.EDProducer("CandPtrProjector", src=pfCandsNoEleMuTau,
veto=photons))
pfCandsForUnclusteredUnc = addattr(
'pfCandsForUnclusteredUnc',
cms.EDProducer("CandPtrProjector",
src=pfCandsNoEleMuTauGamma,
veto=crossCleanedJets))
for vsign, vname in [(1, 'Up'), (-1, 'Down')]:
shiftConf = [('MuonEn', muons.value(),
'((x<100)?(0.002+0*y):(0.05+0*y))'),
('ElectronEn', electrons.value(),
'((abs(y)<1.479)?(0.006+0*x):(0.015+0*x))'),
('PhotonEn', photons.value(),
'((abs(y)<1.479)?(0.01+0*x):(0.025+0*x))'),
('TauEn', taus.value(), '0.03+0*x*y'),
('UnclusteredEn', pfCandsForUnclusteredUnc.value(), ''),
('JetEn', crossCleanedJets.value(), '')]
for part, coll, formula in shiftConf:
if part == 'UnclusteredEn':
shifted = addattr(
'shifted' + part + vname,
cms.EDProducer(
"ShiftedParticleProducer",
src=pfCandsForUnclusteredUnc,
binning=cms.VPSet(
# charged PF hadrons - tracker resolution
cms.PSet(
binSelection=cms.string('charge!=0'),
binUncertainty=cms.string(
'sqrt(pow(0.00009*x,2)+pow(0.0085/sqrt(sin(2*atan(exp(-y)))),2))'
)),
# neutral PF hadrons - HCAL resolution
cms.PSet(
binSelection=cms.string('pdgId==130'),
energyDependency=cms.bool(True),
binUncertainty=cms.string(
'((abs(y)<1.3)?(min(0.25,sqrt(0.64/x+0.0025))):(min(0.30,sqrt(1.0/x+0.0016))))'
)),
# photon - ECAL resolution
cms.PSet(binSelection=cms.string('pdgId==22'),
energyDependency=cms.bool(True),
binUncertainty=cms.string(
'sqrt(0.0009/x+0.000001)+0*y')),
# HF particules - HF resolution
cms.PSet(binSelection=cms.string(
'pdgId==1 || pdgId==2'),
energyDependency=cms.bool(True),
binUncertainty=cms.string(
'sqrt(1./x+0.0025)+0*y')),
),
shiftBy=cms.double(float(vsign))))
elif part == 'JetEn':
shifted = addattr(
'shifted' + part + vname,
cms.EDProducer(
'SUEPShiftedPATJetProducer',
src=crossCleanedJets,
jetCorrPayloadName=cms.string(jetFlavor),
jetCorrUncertaintyTag=cms.string('Uncertainty'),
addResidualJES=cms.bool(isData),
jetCorrLabelUpToL3=cms.InputTag(
'L3Absolute'), # use embedded correction factors
jetCorrLabelUpToL3Res=cms.InputTag('L2L3Residual'),
shiftBy=cms.double(float(vsign))))
else:
shifted = addattr(
'shifted' + part + vname,
cms.EDProducer("ShiftedParticleProducer",
src=cms.InputTag(coll),
uncertainty=cms.string(formula),
shiftBy=cms.double(float(vsign))))
metCorrShifted = addattr(
'metCorrShifted' + part + vname,
cms.EDProducer("ShiftedParticleMETcorrInputProducer",
srcOriginal=cms.InputTag(coll),
srcShifted=shifted))
addattr(
'patPFMetT1' + part + vname,
patMET_cff.patPFMetT1.clone(src=patPFMetT1,
srcCorrections=[metCorrShifted]))
# Dummy JetResUp and JetResDown modules because PATJetSlimmer requires them
# Jet smearing should be propagated to MET simply by using ptSmear(|Up|Down) branches at the ntuples level
addattr('patPFMetT1JetResUp',
getattr(process, 'patPFMetT1JetEnUp' + postfix).clone())
addattr('patPFMetT1JetResDown',
getattr(process, 'patPFMetT1JetEnDown' + postfix).clone())
addattr(
'slimmedMETs',
slimmedMETs.clone(src=patPFMetT1,
rawVariation=patPFMet,
t1Uncertainties="patPFMetT1%s" + postfix,
runningOnMiniAOD=True))
slimmed = addattr.last
if postfix == '': # default MET
slimmed.caloMET = 'patCaloMet'
else:
del slimmed.caloMET
del slimmed.t01Variation
del slimmed.t1SmearedVarsAndUncs
del slimmed.tXYUncForT1
del slimmed.tXYUncForRaw
del slimmed.tXYUncForT01
del slimmed.tXYUncForT1Smear
del slimmed.tXYUncForT01Smear
return sequence
