import FWCore.ParameterSet.Config as cms
from ElectroWeakAnalysis.VPlusJets.AllPassFilter_cfi import AllPassFilter
#--------------------------
# Counter1: All read events
AllEventsStep = AllPassFilter.clone()
##-------- Scraping veto --------
noscraping = cms.EDFilter("FilterOutScraping",
applyfilter=cms.untracked.bool(True),
debugOn=cms.untracked.bool(False),
numtrack=cms.untracked.uint32(10),
thresh=cms.untracked.double(0.25))
noscrapingStep = AllPassFilter.clone()
##---------HBHE Noise Filter ------
from CommonTools.RecoAlgos.HBHENoiseFilter_cfi import HBHENoiseFilter
HBHENoiseFilter.minIsolatedNoiseSumE = cms.double(999999.)
HBHENoiseFilter.minNumIsolatedNoiseChannels = cms.int32(999999)
HBHENoiseFilter.minIsolatedNoiseSumEt = cms.double(999999.)
HBHENoiseStep = AllPassFilter.clone()
##-------- Primary vertex filter --------
primaryVertex = cms.EDFilter(
"VertexSelector",
src=cms.InputTag("offlinePrimaryVertices"),
cut=cms.string("!isFake && ndof >= 4 && abs(z) <= 24 && position.Rho <= 2"
), # tracksSize() > 3 for the older cut
filter=cms.bool(
True
import FWCore.ParameterSet.Config as cms
from ElectroWeakAnalysis.VPlusJets.AllPassFilter_cfi import AllPassFilter
#--------------------------
# Counter1: All read events
AllEventsStep = AllPassFilter.clone()
##-------- Scraping veto --------
noscraping = cms.EDFilter("FilterOutScraping",
applyfilter = cms.untracked.bool(True),
debugOn = cms.untracked.bool(False),
numtrack = cms.untracked.uint32(10),
thresh = cms.untracked.double(0.2)
)
noscrapingStep = AllPassFilter.clone()
##---------HBHE Noise Filter ------
from CommonTools.RecoAlgos.HBHENoiseFilter_cfi import HBHENoiseFilter
HBHENoiseFilter.minIsolatedNoiseSumE = cms.double(999999.)
HBHENoiseFilter.minNumIsolatedNoiseChannels = cms.int32(999999)
HBHENoiseFilter.minIsolatedNoiseSumEt = cms.double(999999.)
HBHENoiseStep = AllPassFilter.clone()
## The CSC beam halo tight filter ____________________________________________||
from RecoMET.METAnalyzers.CSCHaloFilter_cfi import CSCBasedHaloFilter
CSCHaloStep = AllPassFilter.clone()
" && globalTrack().normalizedChi2<10"
" && globalTrack().hitPattern().numberOfValidMuonHits>0"
" && globalTrack().hitPattern().numberOfValidPixelHits>0"
" && numberOfMatchedStations>1"
" && globalTrack().hitPattern().trackerLayersWithMeasurement>5"
" && " + isolationCutString
)
)
## tight mu filter
tightMuonFilter = cms.EDFilter("PATCandViewCountFilter",
minNumber = cms.uint32(1),
maxNumber = cms.uint32(999999),
src = cms.InputTag("tightMuons")
)
tightLeptonStep = AllPassFilter.clone()
ZToMuMu = cms.EDProducer("CandViewShallowCloneCombiner",
decay = cms.string("tightMuons@+ tightMuons@-"),
#cut = cms.string(' daughter(1).pt >20 && sqrt(2*daughter(0).pt*daughter(1).pt*(1-cos(daughter(0).phi-daughter(1).phi)))>30'),
cut = cms.string(' 60 < mass <120 '),
checkCharge = cms.bool(True),
)
bestZmumu = cms.EDFilter("LargestPtCandViewSelector",
maxNumber = cms.uint32(10),
src = cms.InputTag("ZToMuMu")
)
bestZToMuMuStep = AllPassFilter.clone()
## modified WP70
tightElectrons = cms.EDProducer("PATElectronIdSelector",
src = cms.InputTag( "selectedPatElectronsPFlow" ),
idLabel = cms.string(tightEleIdLabel),
useMVAbasedID_ = cms.bool(True)
)
## tight ele filter
tightElectronFilter = cms.EDFilter("PATCandViewCountFilter",
minNumber = cms.uint32(1),
maxNumber = cms.uint32(999999),
src = cms.InputTag("tightElectrons")
)
tightLeptonStep = AllPassFilter.clone()
WToEnu = cms.EDProducer("CandViewShallowCloneCombiner",
# decay = cms.string("tightElectrons pfMEtSysShiftCorr"),
decay = cms.string("tightElectrons patMetShiftCorrected"),
## Note: the 'mt()' method doesn't compute the transverse mass correctly, so we have to do it by hand.
cut = cms.string('daughter(1).pt >20 && sqrt(2*daughter(0).pt*daughter(1).pt*(1-cos(daughter(0).phi-daughter(1).phi)))>30'),
checkCharge = cms.bool(False),
)
bestWToEnu =cms.EDFilter("LargestPtCandViewSelector",
maxNumber = cms.uint32(10),
src=cms.InputTag("selectedPatMuonsPFlow"),
cut=cms.string(
"pt>20 && isGlobalMuon && isPFMuon && abs(eta)<2.4"
" && globalTrack().normalizedChi2<10"
" && globalTrack().hitPattern().numberOfValidMuonHits>0"
" && globalTrack().hitPattern().numberOfValidPixelHits>0"
" && numberOfMatchedStations>1"
" && globalTrack().hitPattern().trackerLayersWithMeasurement>5"
" && " + isolationCutString))
## tight mu filter
tightMuonFilter = cms.EDFilter("PATCandViewCountFilter",
minNumber=cms.uint32(1),
maxNumber=cms.uint32(999999),
src=cms.InputTag("tightMuons"))
tightLeptonStep = AllPassFilter.clone()
ZToMuMu = cms.EDProducer(
"CandViewShallowCloneCombiner",
decay=cms.string("tightMuons@+ tightMuons@-"),
#cut = cms.string(' daughter(1).pt >20 && sqrt(2*daughter(0).pt*daughter(1).pt*(1-cos(daughter(0).phi-daughter(1).phi)))>30'),
cut=cms.string(' 60 < mass <120 '),
checkCharge=cms.bool(True),
)
bestZmumu = cms.EDFilter("LargestPtCandViewSelector",
maxNumber=cms.uint32(10),
src=cms.InputTag("ZToMuMu"))
bestZToMuMuStep = AllPassFilter.clone()
electronFilter = cms.EDFilter("PATCandViewCountFilter",
def LooseLeptonVetoPAT(process,
isQCD,
isHEEPID,
isMuonAnalyzer,
patMuonCollection,
pTCutLooseMuonVeto,
pTCutLooseElectronVeto,
patElectronCollection = cms.InputTag("selectedPatElectronsPFlow"),
vertexCollection = cms.InputTag("goodOfflinePrimaryVertices"),
looseEleIdLabel="loose"):
print " "
print "###############################"
print "## Loose Lepton veto Module ##"
print "###############################"
print " "
print "Chosen Options: "
print "input pat muon collection = %s"%patMuonCollection
print "input pat electron collection = %s"%patElectronCollection
print "input vertex collection = %s"%vertexCollection
print "is running QCD isolation cut = %d"%isQCD
print "run the High pT muon ID and HEEP electron instead of Higgs ones = %d"%isHEEPID
print "flag to understand we are looking for W->munu or W->enu = %d"%isMuonAnalyzer
print "chosen pT threshold for loose muon veto = %f"%pTCutLooseMuonVeto
print "chosen pT threshold for loose electron veto = %f"%pTCutLooseElectronVeto
print "id label considered for loose electron veto = %s"%looseEleIdLabel
print " "
if isHEEPID :
## produce loose muon collection
process.looseMuons = cms.EDFilter("PATMuonRefSelector",
src = patMuonCollection,
cut = cms.string(""))
## set the cut to the loose Hight pT muon ID
process.looseMuons.cut = cms.string(" isGlobalMuon && isTrackerMuon && pt>%f && abs(eta) < 2.4 && abs(phi)<3.2 && trackIso/pt < 0.1 && abs(dB) <0.2"
" && globalTrack().hitPattern().numberOfValidPixelHits>0 "
" && globalTrack().hitPattern().numberOfValidMuonHits>0 "
" && globalTrack().hitPattern().trackerLayersWithMeasurement>5 "
" && numberOfMatchedStations>1 && userFloat(\"ptError\")/pt<0.3"%pTCutLooseMuonVeto)
## filter the event where there are loose muons -->
process.looseMuonFilter = cms.EDFilter("PATCandViewCountFilter",
src = cms.InputTag("looseMuons"))
process.looseMuonStep = AllPassFilter.clone()
if isMuonAnalyzer:
## if W->munu analysis is running, we need to produce heep electron from patElectronCollection --> this is why the HEEPID flag is set to true
process.heepPatElectronsPFlow = cms.EDProducer("HEEPAttStatusToPAT",
eleLabel = patElectronCollection,
barrelCuts = cms.PSet(heepBarrelCuts),
endcapCuts = cms.PSet(heepEndcapCuts),
applyRhoCorrToEleIsol = cms.bool(True),
eleIsolEffectiveAreas = cms.PSet (heepEffectiveAreas),
eleRhoCorrLabel = cms.InputTag("kt6PFJetsPFlow","rho"),
verticesLabel = vertexCollection)
## define the loose heep electron collection
process.looseElectrons = cms.EDProducer("HEEPElectronProducer",
electronCollection = patElectronCollection,
eleIdType = cms.string("LooseID"),
pTCutValue = cms.double(pTCutLooseElectronVeto))
if isMuonAnalyzer :
process.looseElectrons.electronCollection = cms.InputTag("heepPatElectronsPFlow")
## select events with a least one for the moment
process.looseElectronFilter = cms.EDFilter("PATCandViewCountFilter",
src = cms.InputTag("looseElectrons"),
minNumber = cms.uint32(1),
maxNumber = cms.uint32(999))
if isMuonAnalyzer : ## if the W->munu analysis is running, we need exactly one loose muon == tight and no loose electrons
process.looseMuonFilter.minNumber = cms.uint32(1)
process.looseMuonFilter.maxNumber = cms.uint32(1)
process.looseElectronFilter.minNumber = cms.uint32(0)
process.looseElectronFilter.maxNumber = cms.uint32(0)
else : ## if the W->enu analysis is running, we need exactly one loose electron == tight and no loose muons
process.looseMuonFilter.minNumber = cms.uint32(0)
process.looseMuonFilter.maxNumber = cms.uint32(0)
process.looseElectronFilter.minNumber = cms.uint32(1)
process.looseElectronFilter.maxNumber = cms.uint32(1)
process.looseElectronStep = AllPassFilter.clone()
if isMuonAnalyzer:
process.VetoSequence = cms.Sequence(process.looseMuons*
process.looseMuonFilter*
process.looseMuonStep*
process.heepPatElectronsPFlow*
process.looseElectrons*
process.looseElectronFilter*
process.looseElectronStep)
else: process.VetoSequence = cms.Sequence(process.looseElectrons*
process.looseElectronFilter*
process.looseElectronStep*
process.looseMuons*
process.looseMuonFilter*
process.looseMuonStep)
else:
## Define loose electron selection for veto ######
process.looseElectrons = cms.EDProducer("PATElectronIdSelector",
src = patElectronCollection,
idLabel = cms.string(looseEleIdLabel),
useMVAbasedID = cms.bool(True))
## Define loose muon selection for veto ######
process.looseMuons = cms.EDFilter("PATMuonRefSelector",
src = patMuonCollection,
cut = cms.string(""))
process.looseMuons.cut = cms.string(" pt>%f &&isPFMuon && (isGlobalMuon || isTrackerMuon) && abs(eta)<2.4 && (pfIsolationR04().sumChargedHadronPt+"
" max(0.,pfIsolationR04().sumNeutralHadronEt+pfIsolationR04().sumPhotonEt-0.5*pfIsolationR04().sumPUPt))/pt< 0.2"%pTCutLooseMuonVeto)
if isMuonAnalyzer : ## for W->munu events just one tight muon and no loose electrons
nLooseElectron = 0 ;
nLooseMuon = 1 ;
else : ## for W->enu events just one tight electron and no loose muons
nLooseElectron = 1 ;
nLooseMuon = 0 ;
process.looseElectronFilter = cms.EDFilter("PATCandViewCountFilter",
minNumber = cms.uint32(nLooseElectron),
maxNumber = cms.uint32(nLooseElectron),
src = cms.InputTag("looseElectrons"))
process.looseElectronStep = AllPassFilter.clone()
process.looseMuonFilter = cms.EDFilter("PATCandViewCountFilter",
minNumber = cms.uint32(nLooseMuon),
maxNumber = cms.uint32(nLooseMuon),
src = cms.InputTag("looseMuons"))
process.looseMuonStep = AllPassFilter.clone()
process.VetoSequence = cms.Sequence(process.looseElectrons*
process.looseElectronFilter*
process.looseElectronStep*
process.looseMuons*
process.looseMuonFilter*
process.looseMuonStep)
def WmunuCollectionsPAT(process,
patMuonCollection,
patElectronCollection,
vertexCollection,
isQCD,
isHEEPID,
pTCutValue,
pTCutLooseMuonVeto,
pTCutLooseElectronVeto,
isTransverseMassCut,
TransverseMassCutValue,
patTypeICorrectedMetSysShifted):
isMuonAnalyzer = True
print " "
print "######################################"
print "## Muon Selection in W->munu events ##"
print "######################################"
print " "
print "Chosen Options: "
print "input pat muon collection = %s"%patMuonCollection
print "input pat electron collection = %s"%patElectronCollection
print "input vertex collection = %s"%vertexCollection
print "is running QCD isolation cut = %d"%isQCD
print "run the High pT muon ID instead of Tight Muon ID = %d"%isHEEPID
print "chosen pT threshold for the ID = %f"%pTCutValue
print "chosen pT threshold for loose muon veto = %f"%pTCutLooseMuonVeto
print "chosen pT threshold for loose Electron veto = %f"%pTCutLooseElectronVeto
print "apply tranverse mass cut = %d"%isTransverseMassCut
print "transverse mass cut value = %f"%TransverseMassCutValue
print "patTypeICorrectedMetSysShifted = %s"%patTypeICorrectedMetSysShifted
print " "
isolationCutString = cms.string("")
### produce new muon momentum using the new TuneP --> version of CMSSW after 5_3_5
process.patTunePMuonPFlow = cms.EDProducer("TunePMuonProducer",
muLabel = patMuonCollection)
process.tightMuons = cms.EDFilter("PATMuonSelector",
src = cms.InputTag("patTunePMuonPFlow"),
cut = cms.string(""))
if isQCD:
### invert the isolation cut to select a QCD enriched sample in data
isolationCutString = "(pfIsolationR04().sumChargedHadronPt+max(0.,pfIsolationR04().sumNeutralHadronEt+pfIsolationR04().sumPhotonEt-0.5*pfIsolationR04().sumPUPt))/pt> 0.12"
else:
if isHEEPID :
### Isolation Cut given by the Hight pT muon ID group
isolationCutString = "trackIso()/pt< 0.1"
else :
### Isolation Cut given by the tight muon ID POG recipe
isolationCutString = "(pfIsolationR04().sumChargedHadronPt+max(0.,pfIsolationR04().sumNeutralHadronEt+pfIsolationR04().sumPhotonEt-0.5*pfIsolationR04().sumPUPt))/pt< 0.12"
if isHEEPID : process.tightMuons.cut = cms.string((" isGlobalMuon && isTrackerMuon && pt > %f && abs(dB) < 0.2 && globalTrack().hitPattern().numberOfValidPixelHits() >0 "
" && globalTrack().hitPattern().numberOfValidMuonHits() >0 && globalTrack().hitPattern().trackerLayersWithMeasurement>5 "
" && numberOfMatchedStations() > 1 && abs(eta)< 2.1 && userFloat(\"ptError\")/pt<0.3 && "+ isolationCutString)%pTCutValue)
else : process.tightMuons.cut = cms.string((" pt>%f && isGlobalMuon && isPFMuon && abs(eta)<2.4 && globalTrack().normalizedChi2<10"
" && globalTrack().hitPattern().numberOfValidMuonHits>0 && globalTrack().hitPattern().numberOfValidPixelHits>0 && numberOfMatchedStations>1"
" && globalTrack().hitPattern().trackerLayersWithMeasurement>5 && " + isolationCutString)%pTCutValue)
## tight mu filter --> at least one tight muon
process.tightMuonFilter = cms.EDFilter("PATCandViewCountFilter",
minNumber = cms.uint32(1),
maxNumber = cms.uint32(999999),
src = cms.InputTag("tightMuons"))
process.tightLeptonStep = AllPassFilter.clone()
## produce the leptonic W candidate from reco Objects --> tight muon and corrected met Type I
process.WToMunu = cms.EDProducer("CandViewShallowCloneCombiner",
decay = cms.string("tightMuons "+patTypeICorrectedMetSysShifted[0]),
cut = cms.string('daughter(0).pt >%f && daughter(1).pt >%f && sqrt(2*daughter(0).pt*daughter(1).pt*(1-cos(daughter(0).phi-'
'daughter(1).phi)))>0'%(pTCutValue,pTCutValue)),
checkCharge = cms.bool(False))
if isTransverseMassCut : process.WToMunu.cut = cms.string(' daughter(0).pt >%f && daughter(1).pt >%f && sqrt(2*daughter(0).pt*daughter(1).pt*(1-cos(daughter(0).phi-'
' daughter(1).phi)))>%f'%(pTCutValue,pTCutValue,TransverseMassCutValue))
process.bestWmunu = cms.EDFilter("LargestPtCandViewSelector",
maxNumber = cms.uint32(10),
src = cms.InputTag("WToMunu"))
process.bestWToLepnuStep = AllPassFilter.clone()
## --------- Loose Lepton Filters ----------
if isHEEPID : patMuonCollection = cms.InputTag("patTunePMuonPFlow")
from ElectroWeakAnalysis.VPlusJets.LooseLeptonVetoPAT_cfi import LooseLeptonVetoPAT
patMuonCollection4LooseVeto = cms.InputTag('patTunePMuonPFlow')
LooseLeptonVetoPAT(process,
isQCD,
isHEEPID,
isMuonAnalyzer,
patMuonCollection4LooseVeto,
pTCutLooseMuonVeto,
pTCutLooseElectronVeto,
patElectronCollection,
vertexCollection)
process.WSequence = cms.Sequence(process.patTunePMuonPFlow*
process.tightMuons *
process.tightMuonFilter *
process.tightLeptonStep *
process.WToMunu *
process.bestWmunu *
process.bestWToLepnuStep)
process.WPath = cms.Sequence(process.WSequence*process.VetoSequence)
import FWCore.ParameterSet.Config as cms
from ElectroWeakAnalysis.VPlusJets.AllPassFilter_cfi import AllPassFilter
#--------------------------
# Counter1: All read events
AllEventsStep = AllPassFilter.clone()
##-------- Scraping veto --------
noscraping = cms.EDFilter("FilterOutScraping",
applyfilter = cms.untracked.bool(True),
debugOn = cms.untracked.bool(False),
numtrack = cms.untracked.uint32(10),
thresh = cms.untracked.double(0.25)
)
noscrapingStep = AllPassFilter.clone()
##---------HBHE Noise Filter ------
from CommonTools.RecoAlgos.HBHENoiseFilter_cfi import HBHENoiseFilter
HBHENoiseFilter.minIsolatedNoiseSumE = cms.double(999999.)
HBHENoiseFilter.minNumIsolatedNoiseChannels = cms.int32(999999)
HBHENoiseFilter.minIsolatedNoiseSumEt = cms.double(999999.)
HBHENoiseStep = AllPassFilter.clone()
##-------- Primary vertex filter --------
primaryVertex = cms.EDFilter("VertexSelector",
src = cms.InputTag("offlinePrimaryVertices"),
cut = cms.string("!isFake && ndof >= 4 && abs(z) <= 24 && position.Rho <= 2"), # tracksSize() > 3 for the older cut
filter = cms.bool(True), # otherwise it won't filter the events, just produce an empty vertex collection.
def WmunuCollectionsPAT(process,isQCD, isHEEPID,isTransverseMassCut):
isolationCutString = cms.string("")
if isHEEPID:
# process.TunePMuon = cms.EDProducer("TunePMuonProducer",
# mulabel = cms.InputTag("selectedPatMuons")
# )
process.tightMuons = cms.EDFilter("PATMuonSelector",
src = cms.InputTag("selectedPatMuons"),
cut = cms.string(""))
else:
process.tightMuons = cms.EDFilter("PATMuonSelector",
src = cms.InputTag("selectedPatMuonsPFlow"),
cut = cms.string(""))
if isQCD:
isolationCutString = "(pfIsolationR04().sumChargedHadronPt+max(0.,pfIsolationR04().sumNeutralHadronEt+pfIsolationR04().sumPhotonEt-0.5*pfIsolationR04().sumPUPt))/pt> 0.12"
else:
if isHEEPID : isolationCutString = "trackIso()/pt< 0.1"
else : isolationCutString = "(pfIsolationR04().sumChargedHadronPt+max(0.,pfIsolationR04().sumNeutralHadronEt+pfIsolationR04().sumPhotonEt-0.5*pfIsolationR04().sumPUPt))/pt< 0.12"
if isHEEPID : process.tightMuons.cut = cms.string(" isGlobalMuon && isTrackerMuon && pt > 50 && abs(dB) < 0.2 && globalTrack().hitPattern().numberOfValidPixelHits() >0 "
" && globalTrack().hitPattern().numberOfValidMuonHits() >0 && globalTrack().hitPattern().trackerLayersWithMeasurement() > 8 "
" && numberOfMatchedStations() > 1 && abs(eta)< 2.1 && "+ isolationCutString)
else : process.tightMuons.cut = cms.string(" pt>20 && isGlobalMuon && isPFMuon && abs(eta)<2.4 && globalTrack().normalizedChi2<10"
" && globalTrack().hitPattern().numberOfValidMuonHits>0 && globalTrack().hitPattern().numberOfValidPixelHits>0 && numberOfMatchedStations>1"
" && globalTrack().hitPattern().trackerLayersWithMeasurement>5 && " + isolationCutString)
## tight mu filter
process.tightMuonFilter = cms.EDFilter("PATCandViewCountFilter",
minNumber = cms.uint32(1),
maxNumber = cms.uint32(999999),
src = cms.InputTag("tightMuons")
)
process.tightLeptonStep = AllPassFilter.clone()
process.WToMunu = cms.EDProducer("CandViewShallowCloneCombiner",
decay = cms.string("tightMuons patMetShiftCorrected"),
cut = cms.string(' daughter(0).pt >20 && daughter(1).pt >20 && sqrt(2*daughter(0).pt*daughter(1).pt*(1-cos(daughter(0).phi-daughter(1).phi)))>0'),
checkCharge = cms.bool(False),
)
if isTransverseMassCut : process.WToMunu.cut = cms.string(' daughter(1).pt >20 && sqrt(2*daughter(0).pt*daughter(1).pt*(1-cos(daughter(0).phi-daughter(1).phi)))>30')
process.bestWmunu = cms.EDFilter("LargestPtCandViewSelector",
maxNumber = cms.uint32(10),
src = cms.InputTag("WToMunu")
)
process.bestWToLepnuStep = AllPassFilter.clone()
## --------- Loose Lepton Filters ----------
LooseLeptonVetoPAT(process,isQCD, isHEEPID, isMuonAnalyzer)
process.WSequence = cms.Sequence(#process.TunePMuon*
process.tightMuons *
process.tightMuonFilter *
process.tightLeptonStep *
process.WToMunu *
process.bestWmunu *
process.bestWToLepnuStep
)
process.WPath = cms.Sequence(process.WSequence*process.VetoSequence)
def WenuCollectionsPAT(process, isQCD, isHEEPID, isTransverseMassCut):
#WP80 electrons, only track iso, remove H/E cut
tightEleIdLabel = "tight"
looseEleIdLabel = "loose"
if isQCD:
tightEleIdLabel = "qcd"
looseEleIdLabel = "qcd"
## modified WP70
if isHEEPID:
process.heepPatElectrons = cms.EDProducer(
"HEEPAttStatusToPAT",
eleLabel=cms.InputTag("selectedPatElectronsPFlow"),
barrelCuts=cms.PSet(heepBarrelCuts),
endcapCuts=cms.PSet(heepEndcapCuts),
applyRhoCorrToEleIsol=cms.bool(True),
eleIsolEffectiveAreas=cms.PSet(heepEffectiveAreas),
eleRhoCorrLabel=cms.InputTag("kt6PFJetsPFlow", "rho"),
verticesLabel=cms.InputTag("offlinePrimaryVerticesWithBS"))
process.tightElectrons = cms.EDProducer(
"HEEPElectronProducer",
electronCollection=cms.InputTag("heepPatElectrons"),
eleIdType=cms.string("TightID"),
)
process.tightElectronFilter = cms.EDFilter(
"PATCandViewCountFilter",
minNumber=cms.uint32(1),
maxNumber=cms.uint32(999999),
src=cms.InputTag("tightElectrons"))
process.tightLeptonStep = AllPassFilter.clone()
process.WToEnu = cms.EDProducer(
"CandViewShallowCloneCombiner",
decay=cms.string("tightElectrons patMetShiftCorrected"),
cut=cms.string(
'daughter(0).pt >20 && daughter(1).pt >20 && sqrt(2*daughter(0).pt*daughter(1).pt*(1-cos(daughter(0).phi-daughter(1).phi)))>0'
),
checkCharge=cms.bool(False),
)
if isTransverseMassCut:
process.WToEnu.cut = cms.string(
'daughter(1).pt >20 && sqrt(2*daughter(0).pt*daughter(1).pt*(1-cos(daughter(0).phi-daughter(1).phi)))>30'
)
process.bestWToEnu = cms.EDFilter("LargestPtCandViewSelector",
maxNumber=cms.uint32(10),
src=cms.InputTag("WToEnu"))
process.bestWToLepnuStep = AllPassFilter.clone()
process.WSequence = cms.Sequence(
process.heepPatElectrons * process.tightElectrons *
process.tightElectronFilter * process.tightLeptonStep *
process.WToEnu * process.bestWToEnu * process.bestWToLepnuStep)
LooseLeptonVetoPAT(process, isQCD, isHEEPID, isMuonAnalyzer,
looseEleIdLabel)
process.WPath = cms.Sequence(process.WSequence * process.VetoSequence)
else:
process.tightElectrons = cms.EDProducer(
"PATElectronIdSelector",
src=cms.InputTag("selectedPatElectronsPFlow"),
idLabel=cms.string(
tightEleIdLabel), # refers to Higgs Cut Based or MVA WP
useMVAbasedID_=cms.bool(True),
idType=cms.string("HiggsID"))
process.tightElectronFilter = cms.EDFilter(
"PATCandViewCountFilter",
minNumber=cms.uint32(1),
maxNumber=cms.uint32(999999),
src=cms.InputTag("tightElectrons"))
## tight ele filter
process.tightLeptonStep = AllPassFilter.clone()
process.WToEnu = cms.EDProducer(
"CandViewShallowCloneCombiner",
decay=cms.string("tightElectrons patMetShiftCorrected"),
cut=cms.string(
'daughter(1).pt >20 && sqrt(2*daughter(0).pt*daughter(1).pt*(1-cos(daughter(0).phi-daughter(1).phi)))>0'
),
checkCharge=cms.bool(False),
)
if isTransverseMassCut:
process.WToEnu.cut = cms.string(
'daughter(1).pt >20 && sqrt(2*daughter(0).pt*daughter(1).pt*(1-cos(daughter(0).phi-daughter(1).phi)))>30'
)
process.bestWToEnu = cms.EDFilter("LargestPtCandViewSelector",
maxNumber=cms.uint32(10),
src=cms.InputTag("WToEnu"))
process.bestWToLepnuStep = AllPassFilter.clone()
process.WSequence = cms.Sequence(
process.tightElectrons * process.tightElectronFilter *
process.tightLeptonStep * process.WToEnu * process.bestWToEnu *
process.bestWToLepnuStep)
LooseLeptonVetoPAT(process, isQCD, isHEEPID, isMuonAnalyzer,
looseEleIdLabel)
process.WPath = cms.Sequence(process.WSequence * process.VetoSequence)
def WenuCollectionsPAT(process,isQCD,isHEEPID,isTransverseMassCut) :
#WP80 electrons, only track iso, remove H/E cut
tightEleIdLabel = "tight"
looseEleIdLabel = "loose"
if isQCD:
tightEleIdLabel = "qcd"
looseEleIdLabel = "qcd"
## modified WP70
if isHEEPID:
process.heepPatElectrons = cms.EDProducer("HEEPAttStatusToPAT",
eleLabel = cms.InputTag("selectedPatElectronsPFlow"),
barrelCuts = cms.PSet(heepBarrelCuts),
endcapCuts = cms.PSet(heepEndcapCuts),
applyRhoCorrToEleIsol = cms.bool(True),
eleIsolEffectiveAreas = cms.PSet (heepEffectiveAreas),
eleRhoCorrLabel = cms.InputTag("kt6PFJetsPFlow","rho"),
verticesLabel = cms.InputTag("offlinePrimaryVerticesWithBS")
)
process.tightElectrons = cms.EDProducer("HEEPElectronProducer",
electronCollection = cms.InputTag("heepPatElectrons"),
eleIdType = cms.string("TightID"),
)
process.tightElectronFilter = cms.EDFilter("PATCandViewCountFilter",
minNumber = cms.uint32(1),
maxNumber = cms.uint32(999999),
src = cms.InputTag("tightElectrons")
)
process.tightLeptonStep = AllPassFilter.clone()
process.WToEnu = cms.EDProducer("CandViewShallowCloneCombiner",
decay = cms.string("tightElectrons patMetShiftCorrected"),
cut = cms.string('daughter(0).pt >20 && daughter(1).pt >20 && sqrt(2*daughter(0).pt*daughter(1).pt*(1-cos(daughter(0).phi-daughter(1).phi)))>0'),
checkCharge = cms.bool(False),
)
if isTransverseMassCut : process.WToEnu.cut = cms.string('daughter(1).pt >20 && sqrt(2*daughter(0).pt*daughter(1).pt*(1-cos(daughter(0).phi-daughter(1).phi)))>30')
process.bestWToEnu =cms.EDFilter("LargestPtCandViewSelector",
maxNumber = cms.uint32(10),
src = cms.InputTag("WToEnu")
)
process.bestWToLepnuStep = AllPassFilter.clone()
process.WSequence = cms.Sequence(process.heepPatElectrons*
process.tightElectrons *
process.tightElectronFilter *
process.tightLeptonStep *
process.WToEnu *
process.bestWToEnu *
process.bestWToLepnuStep
)
LooseLeptonVetoPAT(process,isQCD, isHEEPID, isMuonAnalyzer, looseEleIdLabel)
process.WPath = cms.Sequence(process.WSequence*process.VetoSequence)
else:
process.tightElectrons = cms.EDProducer("PATElectronIdSelector",
src = cms.InputTag( "selectedPatElectronsPFlow" ),
idLabel = cms.string(tightEleIdLabel), # refers to Higgs Cut Based or MVA WP
useMVAbasedID_ = cms.bool(True),
idType = cms.string("HiggsID")
)
process.tightElectronFilter = cms.EDFilter("PATCandViewCountFilter",
minNumber = cms.uint32(1),
maxNumber = cms.uint32(999999),
src = cms.InputTag("tightElectrons")
)
## tight ele filter
process.tightLeptonStep = AllPassFilter.clone()
process.WToEnu = cms.EDProducer("CandViewShallowCloneCombiner",
decay = cms.string("tightElectrons patMetShiftCorrected"),
cut = cms.string('daughter(1).pt >20 && sqrt(2*daughter(0).pt*daughter(1).pt*(1-cos(daughter(0).phi-daughter(1).phi)))>0'),
checkCharge = cms.bool(False),
)
if isTransverseMassCut : process.WToEnu.cut = cms.string('daughter(1).pt >20 && sqrt(2*daughter(0).pt*daughter(1).pt*(1-cos(daughter(0).phi-daughter(1).phi)))>30')
process.bestWToEnu =cms.EDFilter("LargestPtCandViewSelector",
maxNumber = cms.uint32(10),
src = cms.InputTag("WToEnu")
)
process.bestWToLepnuStep = AllPassFilter.clone()
process.WSequence = cms.Sequence(process.tightElectrons *
process.tightElectronFilter *
process.tightLeptonStep *
process.WToEnu *
process.bestWToEnu *
process.bestWToLepnuStep
)
LooseLeptonVetoPAT(process,isQCD, isHEEPID, isMuonAnalyzer, looseEleIdLabel)
process.WPath = cms.Sequence(process.WSequence*process.VetoSequence)
def WenuCollectionsPAT(process,
patMuonCollection ,
patElectronCollection,
vertexCollection,
isQCD,
isHEEPID,
pTCutValue,
pTCutLooseMuonVeto,
pTCutLooseElectronVeto,
isTransverseMassCut,
TransverseMassCutValue,
patTypeICorrectedMetSysShifted):
isMuonAnalyzer = False ## here we are looking for electron channel
print " "
print "#########################################"
print "## Electron Selection in W->enu events ##"
print "#########################################"
print " "
print "Chosen Options: "
print "input pat muon collection = %s"%patMuonCollection
print "input pat electron collection = %s"%patElectronCollection
print "input vertex collection = %s"%vertexCollection
print "is running QCD isolation cut = %d"%isQCD
print "run the HEEP elctron ID instead of Higgs MVA ID = %d"%isHEEPID
print "chosen pT threshold for the ID = %f"%pTCutValue
print "chosen pT threshold for loose muon veto = %f"%pTCutLooseMuonVeto
print "chosen pT threshold for loose electron veto = %f"%pTCutLooseElectronVeto
print "apply tranverse mass cut = %d"%isTransverseMassCut
print "transverse mass cut value = %f"%TransverseMassCutValue
print "patTypeICorrectedMetSysShifted = %s"%patTypeICorrectedMetSysShifted
print " "
tightEleIdLabel = "tight" ## id label for tight electrons
if isQCD:
tightEleIdLabel = "qcd"
## modified WP70
if isHEEPID:
### heep electrons producer starting from a set of pat electrons
process.heepPatElectronsPFlow = cms.EDProducer("HEEPAttStatusToPAT",
eleLabel = patElectronCollection,
barrelCuts = cms.PSet(heepBarrelCuts),
endcapCuts = cms.PSet(heepEndcapCuts),
applyRhoCorrToEleIsol = cms.bool(True),
eleIsolEffectiveAreas = cms.PSet (heepEffectiveAreas),
eleRhoCorrLabel = cms.InputTag("kt6PFJetsPFlow","rho"),
verticesLabel = vertexCollection)
### tight heep electrons definition through plugins/HEEPElectronProducer.cc
process.tightElectrons = cms.EDProducer("HEEPElectronProducer",
electronCollection = cms.InputTag("heepPatElectronsPFlow"),
eleIdType = cms.string("TightID"),
pTCutValue = cms.double(pTCutValue))
## requrie at least one tight electrons
process.tightElectronFilter = cms.EDFilter("PATCandViewCountFilter",
minNumber = cms.uint32(1),
maxNumber = cms.uint32(999999),
src = cms.InputTag("tightElectrons"))
process.tightLeptonStep = AllPassFilter.clone()
## build the leptonic W candidate with the met and the tight electron
process.WToEnu = cms.EDProducer("CandViewShallowCloneCombiner",
decay = cms.string("tightElectrons "+patTypeICorrectedMetSysShifted[0]),
cut = cms.string('daughter(0).pt >20 && daughter(1).pt >20 && sqrt(2*daughter(0).pt*daughter(1).pt*(1-cos(daughter(0).phi-daughter(1).phi)))>0'),
checkCharge = cms.bool(False))
if isTransverseMassCut :
process.WToEnu.cut = cms.string('daughter(1).pt >20 && sqrt(2*daughter(0).pt*daughter(1).pt*(1-cos(daughter(0).phi-daughter(1).phi)))>%f'%isTransverseMassCut)
process.bestWToEnu =cms.EDFilter("LargestPtCandViewSelector",
maxNumber = cms.uint32(10),
src = cms.InputTag("WToEnu"))
process.bestWToLepnuStep = AllPassFilter.clone()
### final sequence
process.WSequence = cms.Sequence(process.heepPatElectronsPFlow*
process.tightElectrons *
process.tightElectronFilter *
process.tightLeptonStep *
process.WToEnu *
process.bestWToEnu *
process.bestWToLepnuStep)
from ElectroWeakAnalysis.VPlusJets.LooseLeptonVetoPAT_cfi import LooseLeptonVetoPAT
## Lepton Veto Sequence
LooseLeptonVetoPAT(process,
isQCD,
isHEEPID,
isMuonAnalyzer,
patMuonCollection,
pTCutLooseMuonVeto,
pTCutLooseElectronVeto)
process.WPath = cms.Sequence(process.WSequence*
process.VetoSequence)
else:
### Tight electron selection according to egamma mva Higgs id
process.tightElectrons = cms.EDProducer("PATElectronIdSelector",
src = patElectronCollection,
idLabel = cms.string(tightEleIdLabel), # refers to Higgs Cut Based or MVA WP
useMVAbasedID = cms.bool(True))
### require at least one tight electrons
process.tightElectronFilter = cms.EDFilter("PATCandViewCountFilter",
minNumber = cms.uint32(1),
maxNumber = cms.uint32(999999),
src = cms.InputTag("tightElectrons"))
### tight ele filter
process.tightLeptonStep = AllPassFilter.clone()
process.WToEnu = cms.EDProducer("CandViewShallowCloneCombiner",
decay = cms.string("tightElectrons "+patTypeICorrectedMetSysShifted[0]),
cut = cms.string('daughter(1).pt >20 && sqrt(2*daughter(0).pt*daughter(1).pt*(1-cos(daughter(0).phi-daughter(1).phi)))>0'),
checkCharge = cms.bool(False))
if isTransverseMassCut :
process.WToEnu.cut = cms.string('daughter(1).pt >20 && sqrt(2*daughter(0).pt*daughter(1).pt*(1-cos(daughter(0).phi-daughter(1).phi)))>%f'%TransverseMassCutValue)
process.bestWToEnu =cms.EDFilter("LargestPtCandViewSelector",
maxNumber = cms.uint32(10),
src = cms.InputTag("WToEnu"))
process.bestWToLepnuStep = AllPassFilter.clone()
### final sequence
process.WSequence = cms.Sequence(process.tightElectrons *
process.tightElectronFilter *
process.tightLeptonStep *
process.WToEnu *
process.bestWToEnu *
process.bestWToLepnuStep
)
### call python function for loose lepton producer and veto
LooseLeptonVetoPAT(process,
isQCD,
isHEEPID,
isMuonAnalyzer,
patMuonCollection,
pTCutLooseMuonVeto,
pTCutLooseElectronVeto)
process.WPath = cms.Sequence(process.WSequence*
process.VetoSequence)
def LooseLeptonVetoPAT(process,isQCD, isHEEPID, isMuonAnalyzer, looseEleIdLabel="loose"):
if isHEEPID :
process.looseMuons = cms.EDFilter("PATMuonRefSelector",
src = cms.InputTag("selectedPatMuons"),
cut = cms.string(""))
process.looseMuons.cut = cms.string("isGlobalMuon && isTrackerMuon && pt>20 && abs(eta) < 2.4 && abs(phi)<3.2 && trackIso/pt < 0.1 && abs(dB) <0.2"
" && globalTrack().hitPattern().numberOfValidPixelHits>0 "
" && globalTrack().hitPattern().numberOfValidMuonHits>0 "
" && globalTrack().hitPattern().trackerLayersWithMeasurement>8 "
" && numberOfMatchedStations>1 " )
process.looseMuonFilter = cms.EDFilter("PATCandViewCountFilter",
src = cms.InputTag("looseMuons")
)
process.looseMuonStep = AllPassFilter.clone()
if isMuonAnalyzer:
process.heepPatElectrons = cms.EDProducer("HEEPAttStatusToPAT",
eleLabel = cms.InputTag("selectedPatElectronsPFlow"),
barrelCuts = cms.PSet(heepBarrelCuts),
endcapCuts = cms.PSet(heepEndcapCuts),
applyRhoCorrToEleIsol = cms.bool(True),
eleIsolEffectiveAreas = cms.PSet (heepEffectiveAreas),
eleRhoCorrLabel = cms.InputTag("kt6PFJetsPFlow","rho"),
verticesLabel = cms.InputTag("offlinePrimaryVerticesWithBS")
)
process.looseElectrons = cms.EDProducer("HEEPElectronProducer",
electronCollection = cms.InputTag("heepPatElectrons"),
eleIdType = cms.string("LooseID"),
)
process.looseElectronFilter = cms.EDFilter("PATCandViewCountFilter",
src = cms.InputTag("looseElectrons"),
minNumber = cms.uint32(1),
maxNumber = cms.uint32(999),
)
if isMuonAnalyzer :
process.looseMuonFilter.minNumber = cms.uint32(1)
process.looseMuonFilter.maxNumber = cms.uint32(1)
process.looseElectronFilter.minNumber = cms.uint32(0)
process.looseElectronFilter.maxNumber = cms.uint32(0)
else :
process.looseMuonFilter.minNumber = cms.uint32(0)
process.looseMuonFilter.maxNumber = cms.uint32(0)
process.looseElectronFilter.minNumber = cms.uint32(1)
process.looseElectronFilter.maxNumber = cms.uint32(1)
process.looseElectronStep = AllPassFilter.clone()
if isMuonAnalyzer:
process.VetoSequence = cms.Sequence(process.looseMuons*
process.looseMuonFilter*
process.looseMuonStep*
process.heepPatElectrons*
process.looseElectrons*
process.looseElectronFilter*
process.looseElectronStep
)
else: process.VetoSequence = cms.Sequence(process.looseElectrons*
process.looseElectronFilter*
process.looseElectronStep*
process.looseMuons*
process.looseMuonFilter*
process.looseMuonStep
)
else:
## Define loose electron selection for veto ######
process.looseElectrons = cms.EDProducer("PATElectronIdSelector",
src = cms.InputTag( "selectedPatElectronsPFlow" ),
idLabel = cms.string(looseEleIdLabel),
useMVAbasedID_ = cms.bool(True),
idType = cms.string("HiggsID")
)
## Define loose muon selection for veto ######
process.looseMuons = cms.EDFilter("PATMuonRefSelector",
src = cms.InputTag("selectedPatMuonsPFlow"),
cut = cms.string(""))
process.looseMuons.cut = cms.string(" pt>10 &&isPFMuon && (isGlobalMuon || isTrackerMuon) && abs(eta)<2.4"
" && (pfIsolationR04().sumChargedHadronPt+max(0.,pfIsolationR04().sumNeutralHadronEt+pfIsolationR04().sumPhotonEt-0.5*pfIsolationR04().sumPUPt))/pt< 0.2")
if isMuonAnalyzer :
nLooseElectron = 0 ;
nLooseMuon = 1 ;
else :
nLooseElectron = 1 ;
nLooseMuon = 0 ;
process.looseElectronFilter = cms.EDFilter("PATCandViewCountFilter",
minNumber = cms.uint32(nLooseElectron),
maxNumber = cms.uint32(nLooseElectron),
src = cms.InputTag("looseElectrons")
)
process.looseElectronStep = AllPassFilter.clone()
process.looseMuonFilter = cms.EDFilter("PATCandViewCountFilter",
minNumber = cms.uint32(nLooseMuon),
maxNumber = cms.uint32(nLooseMuon),
src = cms.InputTag("looseMuons")
)
process.looseMuonStep = AllPassFilter.clone()
process.VetoSequence = cms.Sequence(process.looseElectrons*process.looseElectronFilter*process.looseElectronStep*process.looseMuons*process.looseMuonFilter*process.looseMuonStep)
