def addZMassHistos(self):
from PhysicsTools.PatAlgos.cleaningLayer1.muonCleaner_cfi import cleanPatMuons
zMassMuons = self.analysis.addAnalysisModule(
"ZMassMuons",
selector = cleanPatMuons.clone(
#preselection = cms.string(zMassVetoMuons),
src = muons,
checkOverlaps = cms.PSet(
muons = cms.PSet(
src = self.selectedMuons,
algorithm = cms.string("byDeltaR"),
preselection = cms.string(""),
deltaR = cms.double(0.1),
checkRecoComponents = cms.bool(False),
pairCut = cms.string(""),
requireNoOverlaps = cms.bool(True)
)
)
),
counter=False).getSelectorInputTag()
self.zmumu = self.analysis.addProducer("ZMuMu", self.candCombinerPrototype.clone(decay = cms.string(self.selectedMuons.getModuleLabel()+" "+zMassMuons.getModuleLabel())))
self.cloneHistoAnalyzer("ZMuMuCands")
self.histoAnalyzer.zmumu_ = cms.untracked.PSet(src = self.zmumu, histograms = cms.VPSet(histoZMass.pset()))
self.cloneMultipAnalyzer(name="MultiplicityZMuMuCands")
self.multipAnalyzer.zMassMuons = self.multipAnalyzer.selMuons.clone(src = zMassMuons)
def addZMassHistos(self):
from PhysicsTools.PatAlgos.cleaningLayer1.muonCleaner_cfi import cleanPatMuons
zMassMuons = self.analysis.addAnalysisModule(
"ZMassMuons",
selector=cleanPatMuons.clone(
#preselection = cms.string(zMassVetoMuons),
src=muons,
checkOverlaps=cms.PSet(
muons=cms.PSet(src=self.selectedMuons,
algorithm=cms.string("byDeltaR"),
preselection=cms.string(""),
deltaR=cms.double(0.1),
checkRecoComponents=cms.bool(False),
pairCut=cms.string(""),
requireNoOverlaps=cms.bool(True)))),
counter=False).getSelectorInputTag()
self.zmumu = self.analysis.addProducer(
"ZMuMu",
self.candCombinerPrototype.clone(
decay=cms.string(self.selectedMuons.getModuleLabel() + " " +
zMassMuons.getModuleLabel())))
self.cloneHistoAnalyzer("ZMuMuCands")
self.histoAnalyzer.zmumu_ = cms.untracked.PSet(src=self.zmumu,
histograms=cms.VPSet(
histoZMass.pset()))
self.cloneMultipAnalyzer(name="MultiplicityZMuMuCands")
self.multipAnalyzer.zMassMuons = self.multipAnalyzer.selMuons.clone(
src=zMassMuons)
def selectedMuonCleanedMuons(selectedMuon, allMuons=None):
if allMuons == None:
allMuons = getAllPatMuons()
from PhysicsTools.PatAlgos.cleaningLayer1.muonCleaner_cfi import cleanPatMuons
module = cleanPatMuons.clone(src=cms.InputTag(allMuons),
checkOverlaps=cms.PSet(muons=cms.PSet(
src=cms.InputTag(selectedMuon),
algorithm=cms.string("byDeltaR"),
preselection=cms.string(""),
deltaR=cms.double(0.0001),
checkRecoComponents=cms.bool(False),
pairCut=cms.string(""),
requireNoOverlaps=cms.bool(True),
), ))
return module
def selectedMuonCleanedMuons(selectedMuon, allMuons="selectedPatMuons"):
from PhysicsTools.PatAlgos.cleaningLayer1.muonCleaner_cfi import cleanPatMuons
module = cleanPatMuons.clone(
src = cms.InputTag("selectedPatMuons"),
checkOverlaps = cms.PSet(
muons = cms.PSet(
src = cms.InputTag(selectedMuon),
algorithm = cms.string("byDeltaR"),
preselection = cms.string(""),
deltaR = cms.double(0.0001),
checkRecoComponents = cms.bool(False),
pairCut = cms.string(""),
requireNoOverlaps = cms.bool(True),
),
)
)
return module
def addEmbeddingLikePreselection(process, sequence, param, prefix="embeddingLikePreselection", disableTrigger=True, pileupWeight=None, selectOnlyFirstGenTau=False, maxGenTaus=None):
counters = []
genTauSequence = cms.Sequence()
# Create PU weight producer for the counters
if pileupWeight == None:
puModule = cms.EDProducer("HPlusVertexWeightProducer",
alias = cms.string("pileupWeight"),
histogramAmbientLevel = cms.untracked.string("Systematics")
)
HChTools.insertPSetContentsTo(param.vertexWeight.clone(), puModule)
pileupWeight = prefix+"PileupWeight"
setattr(process, pileupWeight, puModule)
genTauSequence *= puModule
counterPrototype = cms.EDProducer("HPlusEventCountProducer",
weightSrc = cms.InputTag(pileupWeight)
)
# Disable trigger
if disableTrigger:
param.trigger.selectionType = "disabled"
param.tauTriggerEfficiencyScaleFactor.mode = "disabled"
param.metTriggerEfficiencyScaleFactor.mode = "disabled"
allCount = counterPrototype.clone()
setattr(process, prefix+"AllCount", allCount)
genTauSequence *= 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)
genTauSequence *= (pvFilter * 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(generatorTauSelection % generatorTauPt)
)
genTausName = prefix+"GenTau"
setattr(process, genTausName, genTaus)
genTauSequence *= genTaus
if maxGenTaus is not None:
genTausFilter = cms.EDFilter("PATCandViewCountFilter",
src = cms.InputTag(genTausName),
minNumber = cms.uint32(1),
maxNumber = cms.uint32(maxGenTaus),
)
else:
genTausFilter = cms.EDFilter("CandViewCountFilter",
src = cms.InputTag(genTausName),
minNumber = cms.uint32(1),
)
setattr(process, prefix+"GenTauFilter", genTausFilter)
genTauSequence *= genTausFilter
genTausCount = counterPrototype.clone()
setattr(process, prefix+"GenTauCount", genTausCount)
genTauSequence *= genTausCount
counters.append(prefix+"GenTauCount")
# Select first generator tau for e/mu veto, and if the flag is
# true, also for the jet cleaning and tau selection
genTauFirst = cms.EDProducer("HPlusFirstGenParticleSelector",
src = cms.InputTag(genTausName)
)
genTauFirstName = prefix+"GenTauFirst"
setattr(process, genTauFirstName, genTauFirst)
genTauSequence *= genTauFirst
if selectOnlyFirstGenTau:
genTausName = genTauFirstName
genTausVisible = cms.EDProducer("HPlusGenVisibleTauComputer",
src = cms.InputTag(genTausName)
)
genTausVisibleName = prefix+"GenTauVisible"
setattr(process, genTausVisibleName, genTausVisible)
genTauSequence *= genTausVisible
genTauFirstVisible = cms.EDProducer("HPlusGenVisibleTauComputer",
src = cms.InputTag(genTauFirstName)
)
genTauFirstVisibleName = prefix+"GenTauFirstVisible"
setattr(process, genTauFirstVisibleName, genTauFirstVisible)
genTauSequence *= genTauFirstVisible
# Tau selection
# genTauReco = cms.EDProducer("HPlusPATTauCandViewClosestDeltaRSelector",
# src = cms.InputTag("selectedPatTausHpsPFTau"),
# refSrc = cms.InputTag(genTausName),
# maxDeltaR = cms.double(0.5),
# )
genTauReco = cms.EDProducer("HPlusPATTauLorentzVectorViewClosestDeltaRSelector",
# src = cms.InputTag("selectedPatTaus"+PF2PATVersion), # not trigger matched
# src = cms.InputTag("selectedPatTausHpsPFTau"), # 2011
src = cms.InputTag("selectedPatTaus"),
refSrc = cms.InputTag(genTausVisibleName),
maxDeltaR = cms.double(0.5),
)
# if PF2PATVersion != "":
# raise Exception("I don't support PF2PAT at the moment")
if not disableTrigger:
genTauReco.src = param.tauSelection.src.value()
genTauRecoName = prefix+"TauMCMatched"
setattr(process, genTauRecoName, genTauReco)
genTauSequence *= genTauReco
param.tauSelection.src = genTauRecoName
genTauFirstReco = genTauReco.clone(
refSrc = genTauFirstVisibleName
)
genTauFirstRecoName = prefix+"FirstTauMCMatched"
setattr(process, genTauFirstRecoName, genTauFirstReco)
genTauSequence *= genTauFirstReco
if not selectOnlyFirstGenTau:
# Select the tau candidate which is most likely going to pass the identification
genTauSelected = cms.EDProducer("HPlusPATTauMostLikelyIdentifiedSelector",
eventCounter = param.eventCounter.clone(enabled = cms.untracked.bool(False)),
tauSelection = param.tauSelection.clone(),
vertexSrc = cms.InputTag(param.primaryVertexSelection.selectedSrc.value()),
histogramAmbientLevel = cms.untracked.string("Systematics"),
)
genTauSelectedName = prefix+"TauSelected"
setattr(process, genTauSelectedName, genTauSelected)
genTauSequence *= genTauSelected
param.tauSelection.src = genTauSelectedName
genTauCleanPSet = cms.PSet(
# src = cms.InputTag(param.tauSelection.src.value()),
src = cms.InputTag(genTauFirstRecoName),
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.ElectronSelection.ElectronCollectionName.value()),
checkOverlaps = cms.PSet(
genTaus = genTauCleanPSet.clone()
)
)
cleanedElectronsName = prefix+"CleanedElectrons"
param.ElectronSelection.ElectronCollectionName = cleanedElectronsName
setattr(process, cleanedElectronsName, cleanedElectrons)
cleanedMuons = cleanPatMuons.clone(
src = cms.InputTag(param.MuonSelection.MuonCollectionName.value()),
checkOverlaps = cms.PSet(
genTaus = genTauCleanPSet.clone()
)
)
cleanedMuonsName = prefix+"CleanedMuons"
param.MuonSelection.MuonCollectionName = cleanedMuonsName
setattr(process, cleanedMuonsName, cleanedMuons)
genTauSequence *= (cleanedElectrons * cleanedMuons)
# Electron and muon veto
import HiggsAnalysis.HeavyChHiggsToTauNu.HChGlobalElectronVetoFilter_cfi as ElectronVeto
eveto = ElectronVeto.hPlusGlobalElectronVetoFilter.clone(
histogramAmbientLevel = "Systematics"
)
eveto.eventCounter.enabled = cms.untracked.bool(False)
evetoCount = counterPrototype.clone()
import HiggsAnalysis.HeavyChHiggsToTauNu.HChGlobalMuonVetoFilter_cfi as MuonVeto
muveto = MuonVeto.hPlusGlobalMuonVetoFilter.clone(
histogramAmbientLevel = "Systematics"
)
muveto.eventCounter.enabled = cms.untracked.bool(False)
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"])
genTauSequence *= (
eveto * evetoCount *
muveto * muvetoCount
)
# 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)
import HiggsAnalysis.HeavyChHiggsToTauNu.HChJetFilter_cfi as jetFilter_cfi
cleanedJets = jetFilter_cfi.hPlusJetPtrSelectorFilter.clone(
tauSrc = param.tauSelection.src.value(),
allowEmptyTau = True,
histogramAmbientLevel = "Systematics",
)
cleanedJets.eventCounter.enabled = cms.untracked.bool(False)
cleanedJetsName = prefix+"CleanedJets"
setattr(process, cleanedJetsName, cleanedJets)
cleanedJetsCount = counterPrototype.clone()
setattr(process, cleanedJetsName+"Count", cleanedJetsCount)
counters.append(cleanedJetsName+"Count")
genTauSequence *= (
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 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 addEmbeddingLikePreselection(process,
sequence,
param,
prefix="embeddingLikePreselection",
disableTrigger=True,
pileupWeight=None,
selectOnlyFirstGenTau=False,
maxGenTaus=None):
counters = []
genTauSequence = cms.Sequence()
# Create PU weight producer for the counters
if pileupWeight == None:
puModule = cms.EDProducer(
"HPlusVertexWeightProducer",
alias=cms.string("pileupWeight"),
histogramAmbientLevel=cms.untracked.string("Systematics"))
HChTools.insertPSetContentsTo(param.vertexWeight.clone(), puModule)
pileupWeight = prefix + "PileupWeight"
setattr(process, pileupWeight, puModule)
genTauSequence *= puModule
counterPrototype = cms.EDProducer("HPlusEventCountProducer",
weightSrc=cms.InputTag(pileupWeight))
# Disable trigger
if disableTrigger:
param.trigger.selectionType = "disabled"
param.tauTriggerEfficiencyScaleFactor.mode = "disabled"
param.metTriggerEfficiencyScaleFactor.mode = "disabled"
allCount = counterPrototype.clone()
setattr(process, prefix + "AllCount", allCount)
genTauSequence *= 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)
genTauSequence *= (pvFilter * 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(generatorTauSelection %
generatorTauPt))
genTausName = prefix + "GenTau"
setattr(process, genTausName, genTaus)
genTauSequence *= genTaus
if maxGenTaus is not None:
genTausFilter = cms.EDFilter(
"PATCandViewCountFilter",
src=cms.InputTag(genTausName),
minNumber=cms.uint32(1),
maxNumber=cms.uint32(maxGenTaus),
)
else:
genTausFilter = cms.EDFilter(
"CandViewCountFilter",
src=cms.InputTag(genTausName),
minNumber=cms.uint32(1),
)
setattr(process, prefix + "GenTauFilter", genTausFilter)
genTauSequence *= genTausFilter
genTausCount = counterPrototype.clone()
setattr(process, prefix + "GenTauCount", genTausCount)
genTauSequence *= genTausCount
counters.append(prefix + "GenTauCount")
# Select first generator tau for e/mu veto, and if the flag is
# true, also for the jet cleaning and tau selection
genTauFirst = cms.EDProducer("HPlusFirstGenParticleSelector",
src=cms.InputTag(genTausName))
genTauFirstName = prefix + "GenTauFirst"
setattr(process, genTauFirstName, genTauFirst)
genTauSequence *= genTauFirst
if selectOnlyFirstGenTau:
genTausName = genTauFirstName
genTausVisible = cms.EDProducer("HPlusGenVisibleTauComputer",
src=cms.InputTag(genTausName))
genTausVisibleName = prefix + "GenTauVisible"
setattr(process, genTausVisibleName, genTausVisible)
genTauSequence *= genTausVisible
genTauFirstVisible = cms.EDProducer("HPlusGenVisibleTauComputer",
src=cms.InputTag(genTauFirstName))
genTauFirstVisibleName = prefix + "GenTauFirstVisible"
setattr(process, genTauFirstVisibleName, genTauFirstVisible)
genTauSequence *= genTauFirstVisible
# Tau selection
# genTauReco = cms.EDProducer("HPlusPATTauCandViewClosestDeltaRSelector",
# src = cms.InputTag("selectedPatTausHpsPFTau"),
# refSrc = cms.InputTag(genTausName),
# maxDeltaR = cms.double(0.5),
# )
genTauReco = cms.EDProducer(
"HPlusPATTauLorentzVectorViewClosestDeltaRSelector",
# src = cms.InputTag("selectedPatTaus"+PF2PATVersion), # not trigger matched
# src = cms.InputTag("selectedPatTausHpsPFTau"), # 2011
src=cms.InputTag("selectedPatTaus"),
refSrc=cms.InputTag(genTausVisibleName),
maxDeltaR=cms.double(0.5),
)
# if PF2PATVersion != "":
# raise Exception("I don't support PF2PAT at the moment")
if not disableTrigger:
genTauReco.src = param.tauSelection.src.value()
genTauRecoName = prefix + "TauMCMatched"
setattr(process, genTauRecoName, genTauReco)
genTauSequence *= genTauReco
param.tauSelection.src = genTauRecoName
genTauFirstReco = genTauReco.clone(refSrc=genTauFirstVisibleName)
genTauFirstRecoName = prefix + "FirstTauMCMatched"
setattr(process, genTauFirstRecoName, genTauFirstReco)
genTauSequence *= genTauFirstReco
if not selectOnlyFirstGenTau:
# Select the tau candidate which is most likely going to pass the identification
genTauSelected = cms.EDProducer(
"HPlusPATTauMostLikelyIdentifiedSelector",
eventCounter=param.eventCounter.clone(
enabled=cms.untracked.bool(False)),
tauSelection=param.tauSelection.clone(),
vertexSrc=cms.InputTag(
param.primaryVertexSelection.selectedSrc.value()),
histogramAmbientLevel=cms.untracked.string("Systematics"),
)
genTauSelectedName = prefix + "TauSelected"
setattr(process, genTauSelectedName, genTauSelected)
genTauSequence *= genTauSelected
param.tauSelection.src = genTauSelectedName
genTauCleanPSet = cms.PSet(
# src = cms.InputTag(param.tauSelection.src.value()),
src=cms.InputTag(genTauFirstRecoName),
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.ElectronSelection.ElectronCollectionName.value()),
checkOverlaps=cms.PSet(genTaus=genTauCleanPSet.clone()))
cleanedElectronsName = prefix + "CleanedElectrons"
param.ElectronSelection.ElectronCollectionName = cleanedElectronsName
setattr(process, cleanedElectronsName, cleanedElectrons)
cleanedMuons = cleanPatMuons.clone(
src=cms.InputTag(param.MuonSelection.MuonCollectionName.value()),
checkOverlaps=cms.PSet(genTaus=genTauCleanPSet.clone()))
cleanedMuonsName = prefix + "CleanedMuons"
param.MuonSelection.MuonCollectionName = cleanedMuonsName
setattr(process, cleanedMuonsName, cleanedMuons)
genTauSequence *= (cleanedElectrons * cleanedMuons)
# Electron and muon veto
import HiggsAnalysis.HeavyChHiggsToTauNu.HChGlobalElectronVetoFilter_cfi as ElectronVeto
eveto = ElectronVeto.hPlusGlobalElectronVetoFilter.clone(
histogramAmbientLevel="Systematics")
eveto.eventCounter.enabled = cms.untracked.bool(False)
evetoCount = counterPrototype.clone()
import HiggsAnalysis.HeavyChHiggsToTauNu.HChGlobalMuonVetoFilter_cfi as MuonVeto
muveto = MuonVeto.hPlusGlobalMuonVetoFilter.clone(
histogramAmbientLevel="Systematics")
muveto.eventCounter.enabled = cms.untracked.bool(False)
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"])
genTauSequence *= (eveto * evetoCount * muveto * muvetoCount)
# 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)
import HiggsAnalysis.HeavyChHiggsToTauNu.HChJetFilter_cfi as jetFilter_cfi
cleanedJets = jetFilter_cfi.hPlusJetPtrSelectorFilter.clone(
tauSrc=param.tauSelection.src.value(),
allowEmptyTau=True,
histogramAmbientLevel="Systematics",
)
cleanedJets.eventCounter.enabled = cms.untracked.bool(False)
cleanedJetsName = prefix + "CleanedJets"
setattr(process, cleanedJetsName, cleanedJets)
cleanedJetsCount = counterPrototype.clone()
setattr(process, cleanedJetsName + "Count", cleanedJetsCount)
counters.append(cleanedJetsName + "Count")
genTauSequence *= (
cleanedJets * #cleanedJetsFilter *
cleanedJetsCount)
setattr(process, prefix + "Sequence", genTauSequence)
sequence *= genTauSequence
return counters
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)
))
