def addMuonTriggerFix(process, dataVersion, sequence, options):
if dataVersion.isData() and len(options.trigger) == 0:
raise Exception(
"You must give 'trigger' command line argument for data")
# Count all events
process.muonTriggerFixAllEvents = cms.EDProducer("EventCountProducer")
sequence *= process.muonTriggerFixAllEvents
trigger = options.trigger
if len(trigger) == 0:
trigger = "HLT_Mu40_eta2p1_v1"
print "########################################"
print "#"
print "# Applying fix for missing muon trigger in embedding skim for MC"
print "# Trigger: %s" % trigger
print "#"
print "########################################"
from HLTrigger.HLTfilters.triggerResultsFilter_cfi import triggerResultsFilter
process.muonTriggerFixFilter = triggerResultsFilter.clone()
process.muonTriggerFixFilter.hltResults = cms.InputTag(
"TriggerResults", "", dataVersion.getTriggerProcess())
process.muonTriggerFixFilter.l1tResults = cms.InputTag("")
#process.TriggerFilter.throw = cms.bool(False) # Should it throw an exception if the trigger product is not found
process.muonTriggerFixFilter.triggerConditions = cms.vstring(trigger)
sequence *= process.muonTriggerFixFilter
process.muonTriggerFixPassed = cms.EDProducer("EventCountProducer")
sequence *= process.muonTriggerFixPassed
return ["muonTriggerFixAllEvents", "muonTriggerFixPassed"]
def addMuonTriggerFix(process, dataVersion, sequence, options):
if dataVersion.isData() and len(options.trigger) == 0:
raise Exception("You must give 'trigger' command line argument for data")
# Count all events
process.muonTriggerFixAllEvents = cms.EDProducer("EventCountProducer")
sequence *= process.muonTriggerFixAllEvents
trigger = options.trigger
if len(trigger) == 0:
trigger = "HLT_Mu40_eta2p1_v1"
print "########################################"
print "#"
print "# Applying fix for missing muon trigger in embedding skim for MC"
print "# Trigger: %s" % trigger
print "#"
print "########################################"
from HLTrigger.HLTfilters.triggerResultsFilter_cfi import triggerResultsFilter
process.muonTriggerFixFilter = triggerResultsFilter.clone()
process.muonTriggerFixFilter.hltResults = cms.InputTag("TriggerResults", "", dataVersion.getTriggerProcess())
process.muonTriggerFixFilter.l1tResults = cms.InputTag("")
#process.TriggerFilter.throw = cms.bool(False) # Should it throw an exception if the trigger product is not found
process.muonTriggerFixFilter.triggerConditions = cms.vstring(trigger)
sequence *= process.muonTriggerFixFilter
process.muonTriggerFixPassed = cms.EDProducer("EventCountProducer")
sequence *= process.muonTriggerFixPassed
return ["muonTriggerFixAllEvents", "muonTriggerFixPassed"]
def addMcSelection(process, dataVersion, applyTrigger, trigger):
if not dataVersion.isMC():
raise Exception("Data version is not MC!")
seq = cms.Sequence()
# Count all events
process.allEvents = cms.EDProducer("EventCountProducer")
seq *= process.allEvents
# Trigger
if applyTrigger:
if len(trigger) == 0:
raise Exception("triggerMC=1 and no trigger is specified!")
print "########################################"
print "#"
print "# Applying trigger filter for MC"
print "# "+" OR ".join(trigger)
print "#"
print "########################################"
process.TriggerFilter = triggerResultsFilter.clone()
process.TriggerFilter.hltResults = cms.InputTag("TriggerResults", "", dataVersion.getTriggerProcess())
process.TriggerFilter.l1tResults = cms.InputTag("")
#process.TriggerFilter.throw = cms.bool(False) # Should it throw an exception if the trigger product is not found
process.TriggerFilter.triggerConditions = cms.vstring(trigger)
seq *= process.TriggerFilter
process.passedTrigger = cms.EDProducer("EventCountProducer")
seq *= process.passedTrigger
return seq
def addMcSelection(process, dataVersion, applyTrigger, trigger):
if not dataVersion.isMC():
raise Exception("Data version is not MC!")
seq = cms.Sequence()
# Count all events
process.allEvents = cms.EDProducer("EventCountProducer")
seq *= process.allEvents
# Trigger
if applyTrigger:
if len(trigger) == 0:
raise Exception("triggerMC=1 and no trigger is specified!")
print "########################################"
print "#"
print "# Applying trigger filter for MC"
print "# " + " OR ".join(trigger)
print "#"
print "########################################"
process.TriggerFilter = triggerResultsFilter.clone()
process.TriggerFilter.hltResults = cms.InputTag(
"TriggerResults", "", dataVersion.getTriggerProcess())
process.TriggerFilter.l1tResults = cms.InputTag("")
#process.TriggerFilter.throw = cms.bool(False) # Should it throw an exception if the trigger product is not found
process.TriggerFilter.triggerConditions = cms.vstring(trigger)
seq *= process.TriggerFilter
process.passedTrigger = cms.EDProducer("EventCountProducer")
seq *= process.passedTrigger
return seq
def addTriggerCut(self, dataVersion, triggerConditions, name="Trigger", throw=True):
m = triggerResultsFilter.clone()
m.hltResults = cms.InputTag("TriggerResults", "", dataVersion.getTriggerProcess())
m.l1tResults = cms.InputTag("")
m.throw = cms.bool(throw) # Should it throw an exception if the trigger product is not found
m.triggerConditions = cms.vstring(triggerConditions)
self.addFilter(name, m)
def addTriggerCut(self,
dataVersion,
triggerConditions,
name="Trigger",
throw=True):
m = triggerResultsFilter.clone()
m.hltResults = cms.InputTag("TriggerResults", "",
dataVersion.getTriggerProcess())
m.l1tResults = cms.InputTag("")
m.throw = cms.bool(
throw
) # Should it throw an exception if the trigger product is not found
m.triggerConditions = cms.vstring(triggerConditions)
self.addFilter(name, m)
def addDataSelection(process,
dataVersion,
options,
calculateEventCleaning=False):
if not dataVersion.isData():
raise Exception("Data version is not data!")
seq = cms.Sequence()
# Count all events
process.allEvents = cms.EDProducer("EventCountProducer")
seq *= process.allEvents
# Trigger
if len(options.trigger) > 0:
print "Triggering with", " OR ".join(options.trigger)
process.TriggerFilter = triggerResultsFilter.clone()
process.TriggerFilter.hltResults = cms.InputTag(
"TriggerResults", "", dataVersion.getTriggerProcess())
process.TriggerFilter.l1tResults = cms.InputTag("")
process.TriggerFilter.triggerConditions = cms.vstring(options.trigger)
if options.triggerThrow == 0:
# Should it throw an exception if the trigger product is not found
process.TriggerFilter.throw = False
seq *= process.TriggerFilter
process.passedTrigger = cms.EDProducer("EventCountProducer")
seq *= process.passedTrigger
# Filter out Beam Scraping events, see
# https://twiki.cern.ch/twiki/bin/viewauth/CMS/Collisions2010Recipes#Removal_of_Beam_Scraping_Events
# http://cmssw.cvs.cern.ch/cgi-bin/cmssw.cgi/CMSSW/RecoMET/METFilters/test/exampleICHEPrecommendation_cfg.py?revision=1.3&view=markup&pathrev=V00-00-13
process.scrapingVeto = cms.EDFilter("FilterOutScraping",
applyfilter=cms.untracked.bool(True),
debugOn=cms.untracked.bool(False),
numtrack=cms.untracked.uint32(10),
thresh=cms.untracked.double(0.25))
process.passedScrapingVeto = cms.EDProducer("EventCountProducer")
seq *= process.scrapingVeto
seq *= process.passedScrapingVeto
# Produce results for filters
return seq
def addDataSelection(process, dataVersion, options, calculateEventCleaning=False):
if not dataVersion.isData():
raise Exception("Data version is not data!")
seq = cms.Sequence()
# Count all events
process.allEvents = cms.EDProducer("EventCountProducer")
seq *= process.allEvents
# Trigger
if len(options.trigger) > 0:
print "Triggering with", " OR ".join(options.trigger)
process.TriggerFilter = triggerResultsFilter.clone()
process.TriggerFilter.hltResults = cms.InputTag("TriggerResults", "", dataVersion.getTriggerProcess())
process.TriggerFilter.l1tResults = cms.InputTag("")
process.TriggerFilter.triggerConditions = cms.vstring(options.trigger)
if options.triggerThrow == 0:
# Should it throw an exception if the trigger product is not found
process.TriggerFilter.throw = False
seq *= process.TriggerFilter
process.passedTrigger = cms.EDProducer("EventCountProducer")
seq *= process.passedTrigger
# Filter out Beam Scraping events, see
# https://twiki.cern.ch/twiki/bin/viewauth/CMS/Collisions2010Recipes#Removal_of_Beam_Scraping_Events
# http://cmssw.cvs.cern.ch/cgi-bin/cmssw.cgi/CMSSW/RecoMET/METFilters/test/exampleICHEPrecommendation_cfg.py?revision=1.3&view=markup&pathrev=V00-00-13
process.scrapingVeto = cms.EDFilter("FilterOutScraping",
applyfilter = cms.untracked.bool(True),
debugOn = cms.untracked.bool(False),
numtrack = cms.untracked.uint32(10),
thresh = cms.untracked.double(0.25)
)
process.passedScrapingVeto = cms.EDProducer("EventCountProducer")
seq *= process.scrapingVeto
seq *= process.passedScrapingVeto
# Produce results for filters
return seq
import FWCore.ParameterSet.Config as cms
from HLTrigger.HLTfilters.triggerResultsFilter_cfi import triggerResultsFilter
filterJet80Filter = triggerResultsFilter.clone(
hltResults=cms.InputTag(
'TriggerResults', '',
'HLT'), # HLT results - set to empty to ignore HLT
l1tResults=cms.InputTag(''), # L1 GT results - set to empty to ignore L1
l1tIgnoreMask=cms.bool(False), # use L1 mask
l1techIgnorePrescales=cms.bool(
False), # read L1 technical bits from PSB#9, bypassing the prescales
daqPartitions=cms.uint32(0x01), # used by the definition of the L1 mask
throw=cms.bool(
False
), # if HLT path not in the table, crash/ignore according to true/false
triggerConditions=cms.vstring('HLT_Jet80*'))
filterJet80 = cms.Sequence(filterJet80Filter)
#'keep *_boostedMuons_*_*',
#'keep *_onlyIDMuons_*_Demo',
#'keep *_tightMuons_*_Demo',
#'keep *_looseMuonBooster_*_*',
#'keep *_myFirstNtuple_*_*'
'keep *_diLeptons4Veto_*_*'
)
# ===== TRIGGER FILTER
from HLTrigger.HLTfilters.triggerResultsFilter_cfi import triggerResultsFilter
process.hltFilter = triggerResultsFilter.clone(
l1tResults = '',
hltResults = cms.InputTag( "TriggerResults", "", "REDIGI311X"),
throw = True,
triggerConditions = [ #'HLT_Mu7',
'HLT_Mu15_v*',
]
)
# ======== For Filtering muons in MuEnriched QCD sample
process.genMuFilter = cms.EDFilter("CandViewSelector",
src = cms.InputTag("prunedGen"),
cut = cms.string("abs(pdgId) == 13 && pt >15 && abs(eta)<2.5 && status == 1"),
filter = cms.bool(True),
)
# ==== TRIGGER REPORT
import FWCore.ParameterSet.Config as cms
from HLTrigger.HLTfilters.triggerResultsFilter_cfi import triggerResultsFilter
ZeroBiasFilter = triggerResultsFilter.clone(
hltResults = cms.InputTag('TriggerResults','','HLT'), # HLT results - set to empty to ignore HLT
l1tResults = cms.InputTag(''), # L1 GT results - set to empty to ignore L1
l1tIgnoreMask = cms.bool(False), # use L1 mask
l1techIgnorePrescales = cms.bool(False), # read L1 technical bits from PSB#9, bypassing the prescales
daqPartitions = cms.uint32(0x01), # used by the definition of the L1 mask
throw = cms.bool(False), # if HLT path not in the table, crash/ignore according to true/false
triggerConditions = cms.vstring(
'HLT_ZeroBias*')
)
filterZeroBias = cms.Sequence( ZeroBiasFilter )
inTracks = cms.InputTag(options.inputCollection)
process.load('CalibTracker.SiStripCommon.prescaleEvent_cfi')
process.load('CalibTracker.Configuration.Filter_Refit_cff')
## use CalibrationTracks (for clusters) and CalibrationTracksRefit (for tracks)
process.CalibrationTracks.src = inTracks
tracksForCalib = cms.InputTag("CalibrationTracksRefit")
process.prescaleEvent.prescale = 1
process.load("CalibTracker.SiStripCommon.SiStripBFieldFilter_cfi")
from HLTrigger.HLTfilters.triggerResultsFilter_cfi import triggerResultsFilter
process.IsolatedMuonFilter = triggerResultsFilter.clone(
triggerConditions = cms.vstring("HLT_IsoMu20_*"),
hltResults = cms.InputTag("TriggerResults", "", "HLT"),
l1tResults = cms.InputTag(""),
throw = cms.bool(False)
)
if len(options.cosmicTriggers) > 0:
print("Cosmic triggers: {0}".format(", ".join(options.cosmicTriggers)))
process.IsolatedMuonFilter.triggerConditions = cms.vstring(options.cosmicTriggers)
else:
print("Cosmic triggers: {0} (default)".format(", ".join(process.IsolatedMuonFilter.triggerConditions)))
print("Argument passed: {0}".format(options.cosmicTriggers))
process.TkCalSeq = cms.Sequence(
process.prescaleEvent*
process.IsolatedMuonFilter*
process.siStripBFieldOnFilter*
process.CalibrationTracks,
cms.Task(process.MeasurementTrackerEvent),
def addPreFakeFilter(process,isMC):
### Pre-filters for fake rate studies
from HLTrigger.HLTfilters.triggerResultsFilter_cfi import triggerResultsFilter
process.hltFilter4Fakes = triggerResultsFilter.clone(
l1tResults = '',
hltResults = cms.InputTag( "TriggerResults", "", "HLT"),
throw = True,
triggerConditions = [ 'HLT_Mu8_v*',
'HLT_Mu12_v*',
'HLT_Mu17_v*',
'HLT_IsoMu24_*',
'HLT_Mu24_*',
'HLT_IsoMu24_*',
'HLT_Ele8_*',
'HLT_Ele8_CaloIdL_CaloIsoVL_v*',
'HLT_Ele17_CaloIdL_CaloIsoVL_v*' ]
)
process.jetsPt5 = cms.EDFilter("CandViewSelector",
src = cms.InputTag("ak5PFJets"),
cut = cms.string("pt > 5 && numberOfDaughters >= 3"),
filter = cms.bool(True),
)
process.leptonPlusJet = cms.EDProducer("CandViewShallowCloneCombiner",
decay = cms.string('noTauLeps jetsPt5'),
cut = cms.string(
'deltaR(daughter(0).eta,daughter(0).phi,daughter(1).eta,daughter(1).phi) > 0.7 && ' +
'daughter(0).pt >= 10'
),
checkCharge = cms.bool(False),
)
process.countLeptonPlusJet = process.countDiLeps.clone(src = "leptonPlusJet")
process.diLeptons4Veto = cms.EDProducer("CandViewShallowCloneCombiner",
decay = cms.string('noTauLeps@+ noTauLeps@-'),
# cut = cms.string('abs(daughter(0).pdgId) == abs(daughter(1).pdgId) && (mass < 12 || abs(mass-91.1876) < 15)')
cut = cms.string('abs(daughter(0).pdgId) == abs(daughter(1).pdgId) && (mass < 12)')
)
process.diLeptons4VetoFilter = process.countDiLeps.clone(src = "diLeptons4Veto")
process.metVeto20 = cms.EDFilter("CandViewSelector",
src = cms.InputTag("pfMet"),
cut = cms.string("pt < 20"),
filter = cms.bool(True),
)
process.recoW4Veto = cms.EDProducer("CandViewShallowCloneCombiner",
decay = cms.string('noTauLeps pfMet'),
cut = cms.string("sqrt(2*daughter(0).pt*daughter(1).pt*(1 - cos(daughter(0).phi - daughter(1).phi))) > 20"),
checkCharge = cms.bool(False)
)
process.recoW4VetoFilter = process.countDiLeps.clone(src = "recoW4Veto")
process.preFakeFilter = cms.Sequence()
if not isMC:
process.preFakeFilter += process.hltFilter4Fakes
process.preFakeFilter += (
process.metVeto20 +
process.nonSTAMuons * process.noTauLeps *
( process.jetsPt5 * process.leptonPlusJet * process.countLeptonPlusJet +
process.diLeptons4Veto * ~process.diLeptons4VetoFilter +
process.recoW4Veto * ~process.recoW4VetoFilter )
)
process.out.outputCommands = cms.untracked.vstring(
'drop *',
#'keep *_slimPatJetsTriggerMatch_*_*',
#'keep *_boostedMuons_*_*',
#'keep *_onlyIDMuons_*_Demo',
#'keep *_tightMuons_*_Demo',
#'keep *_looseMuonBooster_*_*',
#'keep *_myFirstNtuple_*_*'
'keep *_diLeptons4Veto_*_*')
# ===== TRIGGER FILTER
from HLTrigger.HLTfilters.triggerResultsFilter_cfi import triggerResultsFilter
process.hltFilter = triggerResultsFilter.clone(
l1tResults='',
hltResults=cms.InputTag("TriggerResults", "", "REDIGI311X"),
throw=True,
triggerConditions=[ #'HLT_Mu7',
'HLT_Mu15_v*',
])
# ======== For Filtering muons in MuEnriched QCD sample
process.genMuFilter = cms.EDFilter(
"CandViewSelector",
src=cms.InputTag("prunedGen"),
cut=cms.string(
"abs(pdgId) == 13 && pt >15 && abs(eta)<2.5 && status == 1"),
filter=cms.bool(True),
)
# ==== TRIGGER REPORT
#process.MessageLogger.categories.append('HLTrigReport')
label=cms.untracked.string("AK5PFchs")),
)
)
process.es_prefer_jec = cms.ESPrefer('PoolDBESSource','jec')
###
######################################################################
### import triggerResultsFilter to preFilter on HLT paths if desired
######################################################################
from HLTrigger.HLTfilters.triggerResultsFilter_cfi import triggerResultsFilter
process.trigPreFilter = triggerResultsFilter.clone(
hltResults = cms.InputTag('TriggerResults::HLT'),
triggerConditions = cms.vstring(WhichPreTrigger)
)
process.p1 = cms.Path(process.trigPreFilter *
process.ak5PFJetsL2L3 *
process.ak5PFJetsL1FastL2L3 *
process.ak5PFJetsL1FastL2L3Residual *
process.makeAK5PFNoPUJets *
process.ak5PFchsJetsL1FastL2L3 *
process.ak5PFchsJetsL1FastL2L3Residual *
process.compJets_uncorr *
process.compJets_corr *
process.compJets_corrL2L3reco *
process.compJets_corrWresid *
process.compJets_chs_corr *
def addDataSelection(process, dataVersion, trigger):
if not dataVersion.isData():
raise Exception("Data version is not data!")
seq = cms.Sequence()
# Count all events
process.allEvents = cms.EDProducer("EventCountProducer")
seq *= process.allEvents
# Physics declared bit, see
# https://twiki.cern.ch/twiki/bin/viewauth/CMS/Collisions2010Recipes#Physics_Declared_bit_selection
process.load('HLTrigger.special.hltPhysicsDeclared_cfi')
process.hltPhysicsDeclared.L1GtReadoutRecordTag = 'gtDigis'
process.passedPhysicsDeclared = cms.EDProducer("EventCountProducer")
seq *= process.hltPhysicsDeclared
seq *= process.passedPhysicsDeclared
# Trigger
if len(trigger) > 0:
process.TriggerFilter = triggerResultsFilter.clone()
process.TriggerFilter.hltResults = cms.InputTag(
"TriggerResults", "", dataVersion.getTriggerProcess())
process.TriggerFilter.l1tResults = cms.InputTag("")
# process.TriggerFilter.throw = cms.bool(False) # Should it throw an exception if the trigger product is not found
process.TriggerFilter.triggerConditions = cms.vstring(trigger)
seq *= process.TriggerFilter
process.passedTrigger = cms.EDProducer("EventCountProducer")
seq *= process.passedTrigger
# Filter out Beam Scraping events, see
# https://twiki.cern.ch/twiki/bin/viewauth/CMS/Collisions2010Recipes#Removal_of_Beam_Scraping_Events
process.scrapingVeto = cms.EDFilter("FilterOutScraping",
applyfilter=cms.untracked.bool(True),
debugOn=cms.untracked.bool(False),
numtrack=cms.untracked.uint32(10),
thresh=cms.untracked.double(0.25))
process.passedScrapingVeto = cms.EDProducer("EventCountProducer")
seq *= process.scrapingVeto
seq *= process.passedScrapingVeto
# Reject events with anomalous HCAL noise, see
# https://twiki.cern.ch/twiki/bin/viewauth/CMS/Collisions2010Recipes#Anomalous_Signals_treatment_reco
# https://twiki.cern.ch/twiki/bin/view/CMS/HcalDPGAnomalousSignals
# https://twiki.cern.ch/twiki/bin/viewauth/CMS/HcalNoiseInfoLibrary#How_do_I_reject_events_with_anom
process.load('CommonTools/RecoAlgos/HBHENoiseFilter_cfi')
process.passedHBHENoiseFilter = cms.EDProducer("EventCountProducer")
seq *= process.HBHENoiseFilter
seq *= process.passedHBHENoiseFilter
# Require a good primary vertex (we might want to do this for MC too), see
# https://twiki.cern.ch/twiki/bin/viewauth/CMS/Collisions2010Recipes#Good_Vertex_selection
# This is from rev. 1.4 of DPGAnalysis/Skims/python/GoodVertex_cfg.py
# process.load("HiggsAnalysis.HeavyChHiggsToTauNu.HChPrimaryVertex_cfi")
# process.primaryVertexFilter = cms.EDFilter("VertexCountFilter",
# src = cms.InputTag("goodPrimaryVertices"),
# minNumber = cms.uint32(1),
# maxNumber = cms.uint32(999)
# )
# process.passedPrimaryVertexFilter = cms.EDProducer("EventCountProducer")
# seq *= process.goodPrimaryVertices
# seq *= process.primaryVertexFilter
# seq *= process.passedPrimaryVertexFilter
return seq
process.scale_1 = cms.EDFilter('HLTPrescaler')
process.scale_2 = cms.EDFilter('HLTPrescaler')
process.scale_3 = cms.EDFilter('HLTPrescaler')
process.fail = cms.EDFilter('HLTBool', result=cms.bool(False))
process.success = cms.EDFilter('HLTBool', result=cms.bool(True))
process.Path_1 = cms.Path(process.scale_1)
process.Path_2 = cms.Path(process.scale_2)
process.Path_3 = cms.Path(process.scale_3)
process.AlwaysTrue = cms.Path(process.success)
process.AlwaysFalse = cms.Path(process.fail)
process.L1_Path = cms.Path(process.success)
# define the TriggerResultsFilters based on the status of the previous paths
from HLTrigger.HLTfilters.triggerResultsFilter_cfi import triggerResultsFilter as _triggerResultsFilter
triggerResultsFilter = _triggerResultsFilter.clone(usePathStatus=True)
# accept if 'Path_1' succeeds
process.filter_1 = triggerResultsFilter.clone(triggerConditions=('Path_1', ),
l1tResults='',
throw=False)
# accept if 'Path_2' succeeds
process.filter_2 = triggerResultsFilter.clone(triggerConditions=('Path_2', ),
l1tResults='',
throw=False)
# accept if 'Path_3' succeeds
process.filter_3 = triggerResultsFilter.clone(triggerConditions=('Path_3', ),
l1tResults='',
throw=False)
#'keep *_boostedEles_*_*',
#'keep *_onlyIDEles_*_Demo',
#'keep *_tightEles_*_Demo',
#'keep *_looseEleBooster_*_*',
#'keep *_myFirstNtuple_*_*'
'keep *_diLeptons4Veto_*_*'
)
# ===== TRIGGER FILTER
from HLTrigger.HLTfilters.triggerResultsFilter_cfi import triggerResultsFilter
process.hltFilter = triggerResultsFilter.clone(
l1tResults = '',
#hltResults = cms.InputTag( "TriggerResults", "", "REDIGI311X"),
hltResults = cms.InputTag( "TriggerResults", "", "HLT"),
throw = True,
triggerConditions = [ 'HLT_Ele8_CaloIdL_CaloIsoVL_v*',
'HLT_Ele17_CaloIdL_CaloIsoVL_v*',
#'HLT_Ele8_v*',
]
)
# ======== For Filtering muons in MuEnriched QCD sample
process.genMuFilter = cms.EDFilter("CandViewSelector",
src = cms.InputTag("prunedGen"),
cut = cms.string("abs(pdgId) == 13 && pt >15 && abs(eta)<2.5 && status == 1"),
filter = cms.bool(True),
)
outputFile = outputFile.replace( 'root', 'local.root' )
process.out.fileName = outputFile
logFile = outputFile.replace( 'root', 'log' )
### Trigger
# Trigger
if triggerSelectionMuons == '' or triggerSelectionMuons == '*':
triggerSelectionMuons = 'HLT_*'
if triggerSelectionElectrons == '' or triggerSelectionElectrons == '*':
triggerSelectionElectrons = 'HLT_*'
from HLTrigger.HLTfilters.triggerResultsFilter_cfi import triggerResultsFilter
process.triggerResultsFilterMuons = triggerResultsFilter.clone( hltResults = cms.InputTag( 'TriggerResults::%s'%( hltProcess ) )
, l1tResults = cms.InputTag( '' )
, triggerConditions = [ triggerSelectionMuons ]
, throw = False
)
process.triggerResultsFilterElectrons = process.triggerResultsFilterMuons.clone( triggerConditions = [ triggerSelectionElectrons ]
)
### Cleaning
# Vertices
process.goodOfflinePrimaryVertices = cms.EDFilter(
"PrimaryVertexObjectFilter"
, src = cms.InputTag( 'offlinePrimaryVertices' )
, filter = cms.bool( True )
, filterParams = cms.PSet(
minNdof = cms.double( 4. )
def addVariables(process,
is_mc,
year,
reportEvery,
hlt_filter,
suppressMessages=True,
checkUniqueness=True):
process.electronTable.variables.hoe.precision = cms.int32(12)
process.electronTable.variables.deltaPhiSC = Var(
"superCluster().phi()-phi()",
float,
doc="delta phi (SC,ele) with sign",
precision=10)
process.electronTable.variables.deltaEtaSC_trackatVtx = Var(
"deltaEtaSuperClusterTrackAtVtx()",
float,
doc="HLT safe delta eta (SC,ele) with sign",
precision=10)
process.electronTable.variables.deltaPhiSC_trackatVtx = Var(
"deltaPhiSuperClusterTrackAtVtx()",
float,
doc="HLT safe delta phi (SC,ele) with sign",
precision=10)
process.electronTable.variables.pfRelIso04_all = Var(
"userFloat('PFIsoAll04')/pt",
float,
doc="PF relative isolation dR=0.4, total (with rho*EA PU corrections)")
process.electronTable.variables.jetNDauChargedMVASel = Var(
"?userCand('jetForLepJetVar').isNonnull()?userFloat('jetNDauChargedMVASel'):0",
int,
doc="jetNDauChargedMVASel variable used by TTH MVA")
process.electronTable.variables.jetPtRelv2 = Var(
"?userCand('jetForLepJetVar').isNonnull()?userFloat('ptRel'):0",
float,
doc="jetPtRelv2 variable used by TTH MVA")
process.electronTable.variables.jetPtRatio = Var(
"?userCand('jetForLepJetVar').isNonnull()?userFloat('ptRatio'):1.0/(1.0+userFloat('PFIsoAll04')/pt)",
float,
doc="jetPtRatio variable used by TTH MVA")
process.electronTable.variables.jetBTagCSV = Var(
"?userCand('jetForLepJetVar').isNonnull()?"
"userCand('jetForLepJetVar').bDiscriminator('pfCombinedInclusiveSecondaryVertexV2BJetTags'):"
"-1.",
float,
doc="jetBTagCSV variable used by TTH MVA")
process.electronTable.variables.jetBTagDeepCSV = Var(
"?userCand('jetForLepJetVar').isNonnull()?"
"userCand('jetForLepJetVar').bDiscriminator('pfDeepCSVJetTags:probb')+"
"userCand('jetForLepJetVar').bDiscriminator('pfDeepCSVJetTags:probbb'):"
"-1.",
float,
doc="jetBTagDeepCSV variable")
process.electronTable.variables.jetBTagDeepJet = Var(
"?userCand('jetForLepJetVar').isNonnull()?"
"userCand('jetForLepJetVar').bDiscriminator('pfDeepFlavourJetTags:probb')+"
"userCand('jetForLepJetVar').bDiscriminator('pfDeepFlavourJetTags:probbb')+"
"userCand('jetForLepJetVar').bDiscriminator('pfDeepFlavourJetTags:problepb'):"
"-1.",
float,
doc="jetBTagDeepJet variable")
process.muonTable.variables.jetNDauChargedMVASel = Var(
"?userCand('jetForLepJetVar').isNonnull()?userFloat('jetNDauChargedMVASel'):0",
int,
doc="jetNDauChargedMVASel variable used by TTH MVA")
process.muonTable.variables.jetPtRelv2 = Var(
"?userCand('jetForLepJetVar').isNonnull()?userFloat('ptRel'):0",
float,
doc="jetPtRelv2 variable used by TTH MVA")
process.muonTable.variables.jetPtRatio = Var(
"?userCand('jetForLepJetVar').isNonnull()?"
"userFloat('ptRatio'):"
"1.0/("
"1.0+("
"pfIsolationR04().sumChargedHadronPt + max("
"pfIsolationR04().sumNeutralHadronEt + pfIsolationR04().sumPhotonEt - pfIsolationR04().sumPUPt/2,"
"0.0"
")"
")/pt"
")",
float,
doc="jetPtRatio variable used by TTH MVA")
process.muonTable.variables.jetBTagCSV = Var(
"?userCand('jetForLepJetVar').isNonnull()?"
"userCand('jetForLepJetVar').bDiscriminator('pfCombinedInclusiveSecondaryVertexV2BJetTags'):"
"-1.",
float,
doc="jetBTagCSV variable used by TTH MVA")
process.muonTable.variables.jetBTagDeepCSV = Var(
"?userCand('jetForLepJetVar').isNonnull()?"
"userCand('jetForLepJetVar').bDiscriminator('pfDeepCSVJetTags:probb')+"
"userCand('jetForLepJetVar').bDiscriminator('pfDeepCSVJetTags:probbb'):"
"-1.",
float,
doc="jetBTagDeepCSV variable")
process.muonTable.variables.jetBTagDeepJet = Var(
"?userCand('jetForLepJetVar').isNonnull()?"
"userCand('jetForLepJetVar').bDiscriminator('pfDeepFlavourJetTags:probb')+"
"userCand('jetForLepJetVar').bDiscriminator('pfDeepFlavourJetTags:probbb')+"
"userCand('jetForLepJetVar').bDiscriminator('pfDeepFlavourJetTags:problepb'):"
"-1.",
float,
doc="jetBTagDeepJet variable")
for modifier in run2_miniAOD_80XLegacy, run2_nanoAOD_94X2016:
modifier.toModify(
process.electronTable.variables,
jetRelIso=Var(
"?userCand('jetForLepJetVar').isNonnull()?(1./userFloat('ptRatio'))-1.:userFloat('PFIsoAll04')/pt",
float,
doc="Relative isolation in matched jet"))
modifier.toModify(
process.muonTable.variables,
jetRelIso=Var(
"?userCand('jetForLepJetVar').isNonnull()?"
"(1./userFloat('ptRatio'))-1.:"
"(pfIsolationR04().sumChargedHadronPt + "
"max(pfIsolationR04().sumNeutralHadronEt + pfIsolationR04().sumPhotonEt - pfIsolationR04().sumPUPt/2,0.0)"
")/pt",
float,
doc="Relative isolation in matched jet"))
process.jetTable.variables.btagDeepCvsL = Var(
"bDiscriminator('pfDeepCSVJetTags:probc')/"
"(bDiscriminator('pfDeepCSVJetTags:probc') + bDiscriminator('pfDeepCSVJetTags:probudsg'))",
float,
doc="DeepCSV Charm vs Light Jet (udsg) b-tag discriminator",
precision=10)
process.jetTable.variables.btagDeepCvsB = Var(
"bDiscriminator('pfDeepCSVJetTags:probc')/("
"bDiscriminator('pfDeepCSVJetTags:probc') + bDiscriminator('pfDeepCSVJetTags:probb') + "
"bDiscriminator('pfDeepCSVJetTags:probbb')"
")",
float,
doc="DeepCSV Charm vs b,b+bb b-tag discriminator",
precision=10)
process.jetTable.variables.puIdDisc = Var(
"userFloat('pileupJetId:fullDiscriminant')",
float,
doc="Pilup ID discriminant",
precision=10)
process.jetTable.variables.puId = Var("1", int, doc="Pilup ID")
process.metTable.variables.covXX = Var(
"getSignificanceMatrix().At(0,0)",
float,
doc="xx element of met covariance matrix",
precision=10)
process.metTable.variables.covXY = Var(
"getSignificanceMatrix().At(0,1)",
float,
doc="xy element of met covariance matrix",
precision=10)
process.metTable.variables.covYY = Var(
"getSignificanceMatrix().At(1,1)",
float,
doc="yy element of met covariance matrix",
precision=10)
process.metTable.variables.significance = Var("metSignificance()",
float,
doc="MET significance",
precision=10)
for modifier in run2_nanoAOD_94XMiniAODv1, run2_nanoAOD_94XMiniAODv2:
modifier.toModify(
process.metTable,
src=cms.InputTag("slimmedMETsFixEE2017"),
doc=cms.string(
"Type-1 corrected PF MET, with fixEE2017 definition"),
)
modifier.toModify(
process.metFixEE2017Table,
src=cms.InputTag("slimmedMETs"),
name=cms.string("METUnFixedEE2017"),
doc=cms.string("slimmedMET, type-1 corrected PF MET"),
)
process.jetTables.remove(process.bjetMVA)
addJetSubstructureObservables(process)
addLeptonSubtractedAK8Jets(process,
runOnMC=is_mc,
era=year,
useFakeable=False)
addLeptonSubtractedAK4Jets(process,
runOnMC=is_mc,
era=year,
useFakeable=False)
addDeepTau2017v2(process)
recomputeQGL(process)
addLepMVA(process)
addEScaleSmearing2018(process)
if hlt_filter:
if hlt_filter == 'QCD':
triggers_attr = 'triggers_leptonFR_flat'
elif hlt_filter == 'all':
triggers_attr = 'triggers_flat'
else:
raise ValueError("Invalid value for 'hlt_filter' option: %s" %
hlt_filter)
triggers = [
'{}_v*'.format(trigger)
for trigger in getattr(Triggers(year), triggers_attr)
]
process.triggerFilter = triggerResultsFilter.clone(
hltResults=cms.InputTag("TriggerResults::HLT"),
triggerConditions=cms.vstring(triggers),
l1tResults=cms.InputTag(''),
throw=cms.bool(False),
)
print(
"Filtering events based on '{}' trigger option if they pass OR of the following HLT paths: {}"
.format(hlt_filter, ', '.join(triggers)))
process.nanoAOD_step.insert(0, process.triggerFilter)
output = getattr(process,
'NANOAOD{}output'.format('SIM' if is_mc else ''))
output.SelectEvents = cms.untracked.PSet(
SelectEvents=cms.vstring('nanoAOD_step'))
if hasattr(process,
'genWeightsTable') and process.nanoAOD_step.contains(
process.genWeightsTable):
process.nanoAOD_step.remove(process.genWeightsTable)
process.nanoAOD_step.insert(0, process.genWeightsTable)
else:
print(
"NOT filtering events based on whether or not they pass OR of some combination of HLT paths"
)
assert (reportEvery > 0)
process.MessageLogger.cerr.FwkReport.reportEvery = reportEvery
if suppressMessages:
process.MessageLogger.suppressInfo.append(
'genJetAK4FlavourAssociation')
process.MessageLogger.suppressInfo.append(
'genJetAK8FlavourAssociation')
process.MessageLogger.suppressInfo.append('mergedGenParticles')
process.MessageLogger.suppressWarning.append(
'genJetAK4FlavourAssociation')
process.MessageLogger.suppressWarning.append(
'genJetAK8FlavourAssociation')
process.MessageLogger.suppressWarning.append('mergedGenParticles')
if not checkUniqueness:
process.source.duplicateCheckMode = cms.untracked.string(
'noDuplicateCheck')
process.add_(
cms.Service('InitRootHandlers', EnableIMT=cms.untracked.bool(False)))
def addPreFakeFilter(process, isMC):
### Pre-filters for fake rate studies
from HLTrigger.HLTfilters.triggerResultsFilter_cfi import triggerResultsFilter
process.hltFilter4Fakes = triggerResultsFilter.clone(
l1tResults='',
hltResults=cms.InputTag("TriggerResults", "", "HLT"),
throw=True,
triggerConditions=[
'HLT_Mu8_v*', 'HLT_Mu12_v*', 'HLT_Mu17_v*', 'HLT_IsoMu24_*',
'HLT_Mu24_*', 'HLT_IsoMu24_*', 'HLT_Ele8_*',
'HLT_Ele8_CaloIdL_CaloIsoVL_v*', 'HLT_Ele17_CaloIdL_CaloIsoVL_v*'
])
process.jetsPt5 = cms.EDFilter(
"CandViewSelector",
src=cms.InputTag("ak5PFJets"),
cut=cms.string("pt > 5 && numberOfDaughters >= 3"),
filter=cms.bool(True),
)
process.leptonPlusJet = cms.EDProducer(
"CandViewShallowCloneCombiner",
decay=cms.string('noTauLeps jetsPt5'),
cut=cms.string(
'deltaR(daughter(0).eta,daughter(0).phi,daughter(1).eta,daughter(1).phi) > 0.7 && '
+ 'daughter(0).pt >= 10'),
checkCharge=cms.bool(False),
)
process.countLeptonPlusJet = process.countDiLeps.clone(src="leptonPlusJet")
process.diLeptons4Veto = cms.EDProducer(
"CandViewShallowCloneCombiner",
decay=cms.string('noTauLeps@+ noTauLeps@-'),
# cut = cms.string('abs(daughter(0).pdgId) == abs(daughter(1).pdgId) && (mass < 12 || abs(mass-91.1876) < 15)')
cut=cms.string(
'abs(daughter(0).pdgId) == abs(daughter(1).pdgId) && (mass < 12)'))
process.diLeptons4VetoFilter = process.countDiLeps.clone(
src="diLeptons4Veto")
process.metVeto20 = cms.EDFilter(
"CandViewSelector",
src=cms.InputTag("pfMet"),
cut=cms.string("pt < 20"),
filter=cms.bool(True),
)
process.recoW4Veto = cms.EDProducer(
"CandViewShallowCloneCombiner",
decay=cms.string('noTauLeps pfMet'),
cut=cms.string(
"sqrt(2*daughter(0).pt*daughter(1).pt*(1 - cos(daughter(0).phi - daughter(1).phi))) > 20"
),
checkCharge=cms.bool(False))
process.recoW4VetoFilter = process.countDiLeps.clone(src="recoW4Veto")
process.preFakeFilter = cms.Sequence()
if not isMC:
process.preFakeFilter += process.hltFilter4Fakes
process.preFakeFilter += (
process.metVeto20 + process.nonSTAMuons * process.noTauLeps *
(process.jetsPt5 * process.leptonPlusJet * process.countLeptonPlusJet +
process.diLeptons4Veto * ~process.diLeptons4VetoFilter +
process.recoW4Veto * ~process.recoW4VetoFilter))
import FWCore.ParameterSet.Config as cms
from Calibration.TkAlCaRecoProducers.ALCARECOSiStripCalCosmics_cff import ALCARECOSiStripCalCosmics
from CalibTracker.SiStripCommon.prescaleEvent_cfi import prescaleEvent
from HLTrigger.HLTfilters.triggerResultsFilter_cfi import triggerResultsFilter
ALCARECOSiStripCalCosmicsNanoPrescale = prescaleEvent.clone(prescale=1)
ALCARECOSiStripCalCosmicsNanoHLT = triggerResultsFilter.clone(
triggerConditions=cms.vstring("HLT_L1SingleMuCosmics_v*"),
hltResults=cms.InputTag("TriggerResults", "", "HLT"),
l1tResults=cms.InputTag(""),
throw=cms.bool(False)
)
from CalibTracker.Configuration.Filter_Refit_cff import CalibrationTracks, CalibrationTracksRefit, MeasurementTrackerEvent, offlineBeamSpot
ALCARECOSiStripCalCosmicsNanoCalibTracks = CalibrationTracks.clone(src=cms.InputTag("ALCARECOSiStripCalCosmics"))
ALCARECOSiStripCalCosmicsNanoCalibTracksRefit = CalibrationTracksRefit.clone(
src=cms.InputTag("ALCARECOSiStripCalCosmicsNanoCalibTracks")
)
ALCARECOSiStripCalCosmicsNanoTkCalSeq = cms.Sequence(
ALCARECOSiStripCalCosmicsNanoPrescale*
ALCARECOSiStripCalCosmicsNanoHLT*
ALCARECOSiStripCalCosmicsNanoCalibTracks,
cms.Task(MeasurementTrackerEvent),
cms.Task(offlineBeamSpot),
cms.Task(ALCARECOSiStripCalCosmicsNanoCalibTracksRefit)
)
# load conditions from the global tag
process.load(
'Configuration.StandardSequences.FrontierConditions_GlobalTag_cff')
from Configuration.AlCa.GlobalTag import GlobalTag
process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:run2_mc', '')
# read back the trigger decisions
process.source = cms.Source(
'PoolSource', fileNames=cms.untracked.vstring('file:trigger.root'))
from HLTrigger.HLTfilters.triggerResultsFilter_cfi import triggerResultsFilter
# accept if 'Path_1' succeeds
process.filter_1 = triggerResultsFilter.clone(triggerConditions=('Path_1', ),
l1tResults='',
throw=False)
# accept if 'Path_2' succeeds
process.filter_2 = triggerResultsFilter.clone(triggerConditions=('Path_2', ),
l1tResults='',
throw=False)
# accept if 'Path_3' succeeds
process.filter_3 = triggerResultsFilter.clone(triggerConditions=('Path_3', ),
l1tResults='',
throw=False)
# accept if any path succeeds (explicit OR)
process.filter_any_or = triggerResultsFilter.clone(
triggerConditions=('Path_1', 'Path_2', 'Path_3'),
def addDataSelection(process, dataVersion, trigger):
if not dataVersion.isData():
raise Exception("Data version is not data!")
seq = cms.Sequence()
# Count all events
process.allEvents = cms.EDProducer("EventCountProducer")
seq *= process.allEvents
# Physics declared bit, see
# https://twiki.cern.ch/twiki/bin/viewauth/CMS/Collisions2010Recipes#Physics_Declared_bit_selection
process.load('HLTrigger.special.hltPhysicsDeclared_cfi')
process.hltPhysicsDeclared.L1GtReadoutRecordTag = 'gtDigis'
process.passedPhysicsDeclared = cms.EDProducer("EventCountProducer")
seq *= process.hltPhysicsDeclared
seq *= process.passedPhysicsDeclared
# Trigger
if len(trigger) > 0:
process.TriggerFilter = triggerResultsFilter.clone()
process.TriggerFilter.hltResults = cms.InputTag("TriggerResults", "", dataVersion.getTriggerProcess())
process.TriggerFilter.l1tResults = cms.InputTag("")
# process.TriggerFilter.throw = cms.bool(False) # Should it throw an exception if the trigger product is not found
process.TriggerFilter.triggerConditions = cms.vstring(trigger)
seq *= process.TriggerFilter
process.passedTrigger = cms.EDProducer("EventCountProducer")
seq *= process.passedTrigger
# Filter out Beam Scraping events, see
# https://twiki.cern.ch/twiki/bin/viewauth/CMS/Collisions2010Recipes#Removal_of_Beam_Scraping_Events
process.scrapingVeto = cms.EDFilter("FilterOutScraping",
applyfilter = cms.untracked.bool(True),
debugOn = cms.untracked.bool(False),
numtrack = cms.untracked.uint32(10),
thresh = cms.untracked.double(0.25)
)
process.passedScrapingVeto = cms.EDProducer("EventCountProducer")
seq *= process.scrapingVeto
seq *= process.passedScrapingVeto
# Reject events with anomalous HCAL noise, see
# https://twiki.cern.ch/twiki/bin/viewauth/CMS/Collisions2010Recipes#Anomalous_Signals_treatment_reco
# https://twiki.cern.ch/twiki/bin/view/CMS/HcalDPGAnomalousSignals
# https://twiki.cern.ch/twiki/bin/viewauth/CMS/HcalNoiseInfoLibrary#How_do_I_reject_events_with_anom
process.load('CommonTools/RecoAlgos/HBHENoiseFilter_cfi')
process.passedHBHENoiseFilter = cms.EDProducer("EventCountProducer")
seq *= process.HBHENoiseFilter
seq *= process.passedHBHENoiseFilter
# Require a good primary vertex (we might want to do this for MC too), see
# https://twiki.cern.ch/twiki/bin/viewauth/CMS/Collisions2010Recipes#Good_Vertex_selection
# This is from rev. 1.4 of DPGAnalysis/Skims/python/GoodVertex_cfg.py
# process.load("HiggsAnalysis.HeavyChHiggsToTauNu.HChPrimaryVertex_cfi")
# process.primaryVertexFilter = cms.EDFilter("VertexCountFilter",
# src = cms.InputTag("goodPrimaryVertices"),
# minNumber = cms.uint32(1),
# maxNumber = cms.uint32(999)
# )
# process.passedPrimaryVertexFilter = cms.EDProducer("EventCountProducer")
# seq *= process.goodPrimaryVertices
# seq *= process.primaryVertexFilter
# seq *= process.passedPrimaryVertexFilter
return seq
import FWCore.ParameterSet.Config as cms
muonSelectionAllEvents = cms.EDProducer("EventCountProducer")
from HLTrigger.HLTfilters.triggerResultsFilter_cfi import triggerResultsFilter
muonTrigger = triggerResultsFilter.clone()
muonTrigger.hltResults = cms.InputTag("TriggerResults")
muonTrigger.l1tResults = cms.InputTag("") # dummy
muonTrigger.throw = cms.bool(True)
muonTrigger.triggerConditions = cms.vstring("HLT_Mu9")
muonSelectionTriggered = cms.EDProducer("EventCountProducer")
muonFirstPrimaryVertex = cms.EDProducer("HPlusFirstVertexSelector",
src = cms.InputTag("offlinePrimaryVertices")
)
muonGoodPrimaryVertex = cms.EDFilter("VertexSelector",
filter = cms.bool(False),
src = cms.InputTag("muonFirstPrimaryVertex"),
cut = cms.string("!isFake && ndof > 4 && abs(z) < 24.0 && position.rho < 2.0")
)
muonPrimaryVertexFilter = cms.EDFilter("VertexCountFilter",
src = cms.InputTag("muonGoodPrimaryVertex"),
minNumber = cms.uint32(1),
maxNumber = cms.uint32(999)
)
muonSelectionPrimaryVertex = cms.EDProducer("EventCountProducer")
tightMuons = cms.EDFilter("PATMuonSelector",
src = cms.InputTag("selectedPatMuons"),
cut = cms.string(
'drop *',
#'keep *_slimPatJetsTriggerMatch_*_*',
#'keep *_boostedEles_*_*',
#'keep *_onlyIDEles_*_Demo',
#'keep *_tightEles_*_Demo',
#'keep *_looseEleBooster_*_*',
#'keep *_myFirstNtuple_*_*'
'keep *_diLeptons4Veto_*_*')
# ===== TRIGGER FILTER
from HLTrigger.HLTfilters.triggerResultsFilter_cfi import triggerResultsFilter
process.hltFilter = triggerResultsFilter.clone(
l1tResults='',
#hltResults = cms.InputTag( "TriggerResults", "", "REDIGI311X"),
hltResults=cms.InputTag("TriggerResults", "", "HLT"),
throw=True,
triggerConditions=[
'HLT_Ele8_CaloIdL_CaloIsoVL_v*',
'HLT_Ele17_CaloIdL_CaloIsoVL_v*',
#'HLT_Ele8_v*',
])
# ======== For Filtering muons in MuEnriched QCD sample
process.genMuFilter = cms.EDFilter(
"CandViewSelector",
src=cms.InputTag("prunedGen"),
cut=cms.string(
"abs(pdgId) == 13 && pt >15 && abs(eta)<2.5 && status == 1"),
filter=cms.bool(True),
)
# ==== TRIGGER REPORT
