Calibration/Hotline/python/hotlineSkims_cff.py - master - githubmirror/cmssw

Calibration/Hotline/python/hotlineSkims_cff.py
324 строки11 KB
maria
update the 2016 halo filter for the hotline
05 сен 2016, 12:40
05 сен 2016, 12:40c777aa1
import FWCore.ParameterSet.Config as cms

#Hotline skim parameters
singleMuonCut = 600
doubleMuonCut = 300
tripleMuonCut = 150
singleElectronCut = 900
doubleElectronCut = 300
tripleElectronCut = 100
singlePhotonCut = 1200
doublePhotonCut = 700
triplePhotonCut = 300
singleJetCut = 1600
doubleJetCut = 1400
multiJetCut = 100
multiJetNJets = 8
htCut = 4000
dimuonMassCut = 800
dielectronMassCut = 800
diEMuMassCut = 800

#MET hotline skim parameters
pfMetCut = 300
caloMetCut = 300
condPFMetCut = 100 #PF MET cut for large Calo/PF skim
condCaloMetCut = 100 #Calo MET cut for large PF/Calo skim
caloOverPFRatioCut = 2 #cut on Calo MET / PF MET
PFOverCaloRatioCut = 2 #cut on PF MET / Calo MET

## select events with at least one good PV
from RecoMET.METFilters.primaryVertexFilter_cfi import *

## apply HBHE Noise filter
from CommonTools.RecoAlgos.HBHENoiseFilter_cfi import HBHENoiseFilter
from CommonTools.RecoAlgos.HBHENoiseFilterResultProducer_cfi import HBHENoiseFilterResultProducer

#CSC beam halo filter
from RecoMET.METFilters.globalTightHalo2016Filter_cfi import *

#one muon
singleMuonSelector = cms.EDFilter(
    "CandViewSelector",
    src = cms.InputTag("muons"),
    cut = cms.string( "isGlobalMuon() & pt() > "+str(singleMuonCut) )
)
singleMuonFilter = cms.EDFilter(
    "CandViewCountFilter",
    src = cms.InputTag("singleMuonSelector"),
    minNumber = cms.uint32(1)
)
seqHotlineSkimSingleMuon = cms.Sequence(primaryVertexFilter * globalTightHalo2016Filter * HBHENoiseFilterResultProducer * HBHENoiseFilter * singleMuonSelector * singleMuonFilter)

#two muons
doubleMuonSelector = cms.EDFilter(
    "CandViewSelector",
    src = cms.InputTag("muons"),
    cut = cms.string( "pt() > "+str(doubleMuonCut) )
)
doubleMuonFilter = cms.EDFilter(
    "CandViewCountFilter",
    src = cms.InputTag("doubleMuonSelector"),
    minNumber = cms.uint32(2)
)
seqHotlineSkimDoubleMuon = cms.Sequence(primaryVertexFilter * globalTightHalo2016Filter * HBHENoiseFilterResultProducer * HBHENoiseFilter * doubleMuonSelector * doubleMuonFilter)

#three muons
tripleMuonSelector = cms.EDFilter(
    "CandViewSelector",
    src = cms.InputTag("muons"),
    cut = cms.string( "pt() > "+str(tripleMuonCut) )
)
tripleMuonFilter = cms.EDFilter(
    "CandViewCountFilter",
    src = cms.InputTag("tripleMuonSelector"),
    minNumber = cms.uint32(3)
)
seqHotlineSkimTripleMuon = cms.Sequence(primaryVertexFilter * globalTightHalo2016Filter * HBHENoiseFilterResultProducer * HBHENoiseFilter * tripleMuonSelector * tripleMuonFilter)

#one electron
singleElectronSelector = cms.EDFilter(
    "CandViewSelector",
    src = cms.InputTag("gedGsfElectrons"),
    cut = cms.string( "pt() > "+str(singleElectronCut) )
)
singleElectronFilter = cms.EDFilter(
    "CandViewCountFilter",
    src = cms.InputTag("singleElectronSelector"),
    minNumber = cms.uint32(1)
)
seqHotlineSkimSingleElectron = cms.Sequence(primaryVertexFilter * globalTightHalo2016Filter * HBHENoiseFilterResultProducer * HBHENoiseFilter * singleElectronSelector * singleElectronFilter)

#two electrons
doubleElectronSelector = cms.EDFilter(
    "CandViewSelector",
    src = cms.InputTag("gedGsfElectrons"),
    cut = cms.string( "pt() > "+str(doubleElectronCut) )
)
doubleElectronFilter = cms.EDFilter(
    "CandViewCountFilter",
    src = cms.InputTag("doubleElectronSelector"),
    minNumber = cms.uint32(2)
)
seqHotlineSkimDoubleElectron = cms.Sequence(primaryVertexFilter * globalTightHalo2016Filter * HBHENoiseFilterResultProducer * HBHENoiseFilter * doubleElectronSelector * doubleElectronFilter)

#three electrons
tripleElectronSelector = cms.EDFilter(
    "CandViewSelector",
    src = cms.InputTag("gedGsfElectrons"),
    cut = cms.string( "pt() > "+str(tripleElectronCut) )
)
tripleElectronFilter = cms.EDFilter(
    "CandViewCountFilter",
    src = cms.InputTag("tripleElectronSelector"),
    minNumber = cms.uint32(3)
)
seqHotlineSkimTripleElectron = cms.Sequence(primaryVertexFilter * globalTightHalo2016Filter * HBHENoiseFilterResultProducer * HBHENoiseFilter * tripleElectronSelector * tripleElectronFilter)

#one photon
singlePhotonSelector = cms.EDFilter(
    "CandViewSelector",
    src = cms.InputTag("gedPhotons"),
    cut = cms.string( "pt() > "+str(singlePhotonCut) )
)
singlePhotonFilter = cms.EDFilter(
    "CandViewCountFilter",
    src = cms.InputTag("singlePhotonSelector"),
    minNumber = cms.uint32(1)
)
seqHotlineSkimSinglePhoton = cms.Sequence(primaryVertexFilter * globalTightHalo2016Filter * HBHENoiseFilterResultProducer * HBHENoiseFilter * singlePhotonSelector * singlePhotonFilter)

#two photons
doublePhotonSelector = cms.EDFilter(
    "CandViewSelector",
    src = cms.InputTag("gedPhotons"),
    cut = cms.string( "pt() > "+str(doublePhotonCut) )
)
doublePhotonFilter = cms.EDFilter(
    "CandViewCountFilter",
    src = cms.InputTag("doublePhotonSelector"),
    minNumber = cms.uint32(2)
)
seqHotlineSkimDoublePhoton = cms.Sequence(primaryVertexFilter * globalTightHalo2016Filter * HBHENoiseFilterResultProducer * HBHENoiseFilter * doublePhotonSelector * doublePhotonFilter)

#three photons
triplePhotonSelector = cms.EDFilter(
    "CandViewSelector",
    src = cms.InputTag("gedPhotons"),
    cut = cms.string( "pt() > "+str(triplePhotonCut) )
)
triplePhotonFilter = cms.EDFilter(
    "CandViewCountFilter",
    src = cms.InputTag("triplePhotonSelector"),
    minNumber = cms.uint32(3)
)
seqHotlineSkimTriplePhoton = cms.Sequence(primaryVertexFilter * globalTightHalo2016Filter * HBHENoiseFilterResultProducer * HBHENoiseFilter * triplePhotonSelector * triplePhotonFilter)

#one jet
singleJetSelector = cms.EDFilter(
    "CandViewSelector",
    src = cms.InputTag("ak4PFJets"),
    cut = cms.string( "pt() > "+str(singleJetCut) )
)
singleJetFilter = cms.EDFilter(
    "CandViewCountFilter",
    src = cms.InputTag("singleJetSelector"),
    minNumber = cms.uint32(1)
)
seqHotlineSkimSingleJet = cms.Sequence(primaryVertexFilter * globalTightHalo2016Filter * HBHENoiseFilterResultProducer * HBHENoiseFilter * singleJetSelector * singleJetFilter)

#two jets
doubleJetSelector = cms.EDFilter(
    "CandViewSelector",
    src = cms.InputTag("ak4PFJets"),
    cut = cms.string( "pt() > "+str(doubleJetCut) )
)
doubleJetFilter = cms.EDFilter(
    "CandViewCountFilter",
    src = cms.InputTag("doubleJetSelector"),
    minNumber = cms.uint32(2)
)
seqHotlineSkimDoubleJet = cms.Sequence(primaryVertexFilter * globalTightHalo2016Filter * HBHENoiseFilterResultProducer * HBHENoiseFilter * doubleJetSelector * doubleJetFilter)

#many jets
multiJetSelector = cms.EDFilter(
    "CandViewSelector",
    src = cms.InputTag("ak4PFJets"),
    cut = cms.string( "pt() > "+str(multiJetCut) )
)
multiJetFilter = cms.EDFilter(
    "CandViewCountFilter",
    src = cms.InputTag("multiJetSelector"),
    minNumber = cms.uint32(multiJetNJets)
)
seqHotlineSkimMultiJet = cms.Sequence(primaryVertexFilter * globalTightHalo2016Filter * HBHENoiseFilterResultProducer * HBHENoiseFilter * multiJetSelector * multiJetFilter)

#HT
htMht = cms.EDProducer( "HLTHtMhtProducer",
    usePt = cms.bool( False ),
    minPtJetHt = cms.double( 40.0 ),
    maxEtaJetMht = cms.double( 5.0 ),
    minNJetMht = cms.int32( 0 ),
    jetsLabel = cms.InputTag( "ak4CaloJets" ),
    maxEtaJetHt = cms.double( 3.0 ),
    minPtJetMht = cms.double( 30.0 ),
    minNJetHt = cms.int32( 0 ),
    pfCandidatesLabel = cms.InputTag( "" ),
    excludePFMuons = cms.bool( False )
)
htSelector = cms.EDFilter(
    "CandViewSelector",
    src = cms.InputTag("htMht"),
    cut = cms.string( "sumEt() > "+str(htCut) )
)
htFilter = cms.EDFilter(
    "CandViewCountFilter",
    src = cms.InputTag("htSelector"),
    minNumber = cms.uint32(1)
)
seqHotlineSkimHT = cms.Sequence(primaryVertexFilter * globalTightHalo2016Filter * HBHENoiseFilterResultProducer * HBHENoiseFilter * htMht * htSelector * htFilter)

#high-mass dileptons
dimuons = cms.EDProducer(
    "CandViewShallowCloneCombiner",
    decay = cms.string("muons muons"),
    checkCharge = cms.bool(False),
    cut = cms.string("daughter(0).pt>150 & daughter(1).pt>150 & mass > "+str(dimuonMassCut)),
)
dielectrons = cms.EDProducer(
    "CandViewShallowCloneCombiner",
    decay = cms.string("gedGsfElectrons gedGsfElectrons"),
    checkCharge = cms.bool(False),
    cut = cms.string("daughter(0).pt>150 & daughter(1).pt>150 & mass > "+str(dielectronMassCut)),
)
diEMu = cms.EDProducer(
    "CandViewShallowCloneCombiner",
    decay = cms.string("muons gedGsfElectrons"),
    checkCharge = cms.bool(False),
    cut = cms.string("daughter(0).pt>150 & daughter(1).pt>150 & mass > "+str(diEMuMassCut)),
)
dimuonMassFilter = cms.EDFilter(
    "CandViewCountFilter",
    src = cms.InputTag("dimuons"),
    minNumber = cms.uint32(1)
)
dielectronMassFilter = cms.EDFilter(
    "CandViewCountFilter",
    src = cms.InputTag("dielectrons"),
    minNumber = cms.uint32(1)
)
diEMuMassFilter = cms.EDFilter(
    "CandViewCountFilter",
    src = cms.InputTag("diEMu"),
    minNumber = cms.uint32(1)
)

seqHotlineSkimMassiveDimuon = cms.Sequence(primaryVertexFilter * globalTightHalo2016Filter * HBHENoiseFilterResultProducer * HBHENoiseFilter * dimuons * dimuonMassFilter)
seqHotlineSkimMassiveDielectron = cms.Sequence(primaryVertexFilter * globalTightHalo2016Filter * HBHENoiseFilterResultProducer * HBHENoiseFilter * dielectrons * dielectronMassFilter)
seqHotlineSkimMassiveEMu = cms.Sequence(primaryVertexFilter * globalTightHalo2016Filter * HBHENoiseFilterResultProducer * HBHENoiseFilter * diEMu * diEMuMassFilter)

## select events with high pfMET
pfMETSelector = cms.EDFilter(
    "CandViewSelector",
    src = cms.InputTag("pfMet"),
    cut = cms.string( "pt()>"+str(pfMetCut) )
)

pfMETCounter = cms.EDFilter(
    "CandViewCountFilter",
    src = cms.InputTag("pfMETSelector"),
    minNumber = cms.uint32(1),
)

seqHotlineSkimPFMET = cms.Sequence(
   primaryVertexFilter*
   globalTightHalo2016Filter*
   HBHENoiseFilterResultProducer*
   HBHENoiseFilter*
   pfMETSelector*
   pfMETCounter
)

## select events with high caloMET
caloMETSelector = cms.EDFilter(
    "CandViewSelector",
    src = cms.InputTag("caloMetM"),
    cut = cms.string( "pt()>"+str(caloMetCut) )
)

caloMETCounter = cms.EDFilter(
    "CandViewCountFilter",
    src = cms.InputTag("caloMETSelector"),
    minNumber = cms.uint32(1),
)

seqHotlineSkimCaloMET = cms.Sequence(
   primaryVertexFilter* 
   globalTightHalo2016Filter*
   HBHENoiseFilterResultProducer*
   HBHENoiseFilter*
   caloMETSelector*
   caloMETCounter
)

## select events with extreme PFMET/CaloMET ratio
CondMETSelector = cms.EDProducer(
   "CandViewShallowCloneCombiner",
   decay = cms.string("pfMet caloMetM"),
   cut = cms.string("(daughter(0).pt/daughter(1).pt > "+str(PFOverCaloRatioCut)+" && daughter(1).pt > "+str(condCaloMetCut)+") || (daughter(1).pt/daughter(0).pt > "+str(caloOverPFRatioCut)+" && daughter(0).pt > "+str(condPFMetCut)+" )  " )
)

CondMETCounter = cms.EDFilter(
    "CandViewCountFilter",
    src = cms.InputTag("CondMETSelector"),
    minNumber = cms.uint32(1),
)

seqHotlineSkimCondMET = cms.Sequence(
   primaryVertexFilter* 
   globalTightHalo2016Filter*
   HBHENoiseFilterResultProducer*
   HBHENoiseFilter*
   CondMETSelector*
   CondMETCounter
)